@aalis/plugin-session-manager 0.15.0 → 0.16.0

package/dist/index.js

@@ -1,17 +1,61 @@
 import { basename } from 'node:path';
-import { isDeepStrictEqual } from 'node:util';
 import { agent } from '@aalis/api-agent';
 import { authority } from '@aalis/api-authority';
-import { chatScopeOf, parseWindowKey, windowKey } from '@aalis/api-gateway';
+import { chatScopeOf, windowKey } from '@aalis/api-gateway';
 import { hooks } from '@aalis/api-hooks';
-import { hostConfig } from '@aalis/api-host-config';
+import { ownHostConfig } from '@aalis/api-host-config';
+import { i18n, outputLanguageFor } from '@aalis/api-i18n';
 import { lightestThinking, llm, resolveLLMModel } from '@aalis/api-llm';
-import { memory } from '@aalis/api-memory';
+import { historyCleared, memory } from '@aalis/api-memory';
 import { claimantsOf, getPlatformAdapters, platform, resolvePlatformBySession, sessionTypesOf, } from '@aalis/api-platform';
-import { rootSessionOf, SESSION_LAYERS, SessionConfigError, sessionKind, sessionManager, } from '@aalis/api-session-manager';
-import { definePlugin, events, lifecycle, logger, optional, provide, services } from '@aalis/core';
+import { isUnfiled, oneToOneWith, rootSessionOf, sessionKind, sessionLabel, sessionManager, TAKE_UNKNOWN, } from '@aalis/api-session-manager';
+import { sessionFields } from '@aalis/api-session-settings';
+import { config, definePlugin, events, lifecycle, logger, optional, provide } from '@aalis/core';
+import { defineConfig } from '@aalis/schema-config';
+import { asText, toSource, truncateParams, withText } from '@aalis/schema-i18n';
 import { truncateChars } from '@aalis/util-text-normalize';
-import { applyPatch, assertName, assertSessionPatch, checkPatch, isLayerName, readLayers, readSetting, SettingRegistry, writeLayers, } from './settings.js';
+import { t } from './texts.js';
+// ===== 配置 =====
+// 取别的会话的东西（canTake）的范围与三个开关：都是按会话字段，按取的一方所在的会话生效。坏值原样交来，范围按本会话、开关按否
+const configSchema = defineConfig({
+    takeScope: {
+        type: 'select',
+        label: t('takeScopeLabel'),
+        description: t('takeScopeDescription'),
+        default: 'platform',
+        onInvalid: 'error',
+        options: [
+            { label: t('takeScopeSession'), value: 'session' },
+            { label: t('takeScopePlatform'), value: 'platform' },
+            { label: t('takeScopeAll'), value: 'all' },
+        ],
+        session: { prominence: 'advanced' },
+    },
+    takeOtherGroups: {
+        type: 'boolean',
+        label: t('takeOtherGroupsLabel'),
+        description: t('takeOtherGroupsDescription'),
+        default: true,
+        onInvalid: 'error',
+        session: { prominence: 'advanced' },
+    },
+    takeOthersPrivate: {
+        type: 'boolean',
+        label: t('takeOthersPrivateLabel'),
+        description: t('takeOthersPrivateDescription'),
+        default: false,
+        onInvalid: 'error',
+        session: { prominence: 'advanced' },
+    },
+    takeCrossBot: {
+        type: 'boolean',
+        label: t('takeCrossBotLabel'),
+        description: t('takeCrossBotDescription'),
+        default: false,
+        onInvalid: 'error',
+        session: { prominence: 'advanced' },
+    },
+});
 // ===== 常量 =====
 /** 会话表与场所记录在记忆后端元数据里的命名空间 */
 const SESSIONS = 'sessions';
@@ -42,11 +86,8 @@ function wait(ms, signal) {
         signal.addEventListener('abort', done, { once: true });
     });
 }
-/** 层表里这一层的称呼，日志里点名层时用 */
-const layerLabel = (name) => SESSION_LAYERS.find(layer => layer.name === name).label;
-/** 全局默认层由服务偏好承担的项：字段类型为 llm-ref（选 llm 服务的提供者）的设置项，读写 llm 服务的偏好 */
-const preferenceBacked = (setting) => setting.field.type === 'llm-ref';
 class SessionManager {
+    take;
     sessions = new Map();
     /** 场所记录：键 → 记录。与会话表一同加载与落盘 */
     places = new Map();
@@ -67,78 +108,29 @@ class SessionManager {
     store;
     /** 最近一次挂接的加载；apply 等它完成再对外提供服务 */
     loading = Promise.resolve();
-    /** 插件登记的设置项：登记与撤回都发 session:config:changed */
-    settings = new SettingRegistry(() => void this.caps.events.use.emit('session:config:changed'));
-    /** 已告警过的设置问题：取值无效、文档形状不对。解析每轮都跑，同一处只告警一次 */
+    /** 已告警过的问题（坏数据、收录判不出的认领）：同一处只告警一次 */
     warned = new Set();
+    /** 正在收录或补记的会话：同一会话并发的原生入站共用这一次 */
+    recording = new Map();
+    /** 正在删除的会话（从摘掉、删子会话之前起，到清完数据），删除做完时兑现：这期间到的同一会话的入站等它（见 recordInbound） */
+    removing = new Map();
+    /**
+     * 各会话的代号（generationOf）：开始删除的次数，在 remove 里加一，没删过的为 0。只记删过的 id，一直留着（之后同一 id 再建档
+     * 也不换回去，半路上删除之前的一代才认得出来），每个删过的 id 占一项；随这次激活，会话管理重新激活时清空
+     */
+    generations = new Map();
     /**
-     * 在飞的回合：turnId → 所在会话与这一轮的结局（出错时带原因）。agent:input:before 进出登记与注销，结局由
-     * agent:turn:after 记下（消息被拦下的一轮不发它，没有结局）。同一会话按 lane 可以并行多轮（后台任务结束通知、白纸通知
-     * 与真人回合），会话在最后一轮结束时才收口；回合之外建档的会话按这里有没有回合定初始状态（见 ensureSession）
+     * 在飞的回合：turnId → 所在会话与这一轮的结局（出错时带原因）。agent:turn:before 进出登记与注销，结局由
+     * agent:turn:after 记下（被拦下的一轮不发它，没有结局）。第一方 agent 同一会话一轮接一轮，契约不限别的实现在同一会话并行几轮，
+     * 所以按回合 id 记、会话在最后一轮结束时才收口；回合之外建档的会话按这里有没有回合定初始状态（见 ensureSession）
      */
     turns = new Map();
     /** 正在解析所属实例的会话记录：同一条记录不并发解析，后到的调用不等它、直接返回 */
     resolving = new WeakSet();
     lookup = (id) => this.sessions.get(id);
-    /** 层表的实现：一层一条，继承链、按层读写与可设的层都遍历它（先后取自 SESSION_LAYERS） */
-    layerTable = {
-        defaults: {
-            select: () => ({ scope: 'defaults' }),
-            assert: () => { },
-            read: () => this.readDefaults(),
-            write: (_layer, values) => this.writeDefaults(values),
-            list: () => [{ scope: 'defaults' }],
-            describe: () => layerLabel('defaults'),
-            context: () => ({}),
-        },
-        platform: {
-            select: ({ platform }) => (platform === undefined ? undefined : { scope: 'platform', platform }),
-            assert: layer => assertName('平台名', layer.platform),
-            read: layer => this.docLayers().platforms.get(layer.platform),
-            write: (layer, values) => this.writeDoc(doc => doc.platforms.set(layer.platform, values)),
-            list: () => this.platformNames().map(platform => ({ scope: 'platform', platform })),
-            describe: layer => `${layerLabel('platform')} ${layer.platform}`,
-            context: ({ platform }) => ({ platform }),
-        },
-        type: {
-            select: ({ platform, type }) => platform === undefined || type === undefined ? undefined : { scope: 'type', platform, type },
-            assert: layer => {
-                assertName('平台名', layer.platform);
-                assertName('类型名', layer.type);
-            },
-            read: layer => this.docLayers().types.get(layer.platform)?.get(layer.type),
-            write: (layer, values) => this.writeDoc(doc => doc.types.set(layer.platform, new Map(doc.types.get(layer.platform)).set(layer.type, values))),
-            list: () => this.platformNames().flatMap(platform => this.typeNames(platform).map(type => ({ scope: 'type', platform, type }))),
-            describe: layer => `${layerLabel('type')} ${layer.platform} · ${layer.type}`,
-            context: ({ platform, type }) => ({ platform, type }),
-        },
-        place: {
-            select: ({ place }) => place && { scope: 'place', key: place.key },
-            assert: layer => {
-                if (typeof layer.key !== 'string' || !this.places.has(layer.key)) {
-                    throw new SessionConfigError(`场所不存在：${String(layer.key)}`);
-                }
-            },
-            read: layer => this.places.get(layer.key)?.config,
-            write: async (layer, values) => {
-                const record = this.places.get(layer.key);
-                record.config = values;
-                record.updatedAt = Date.now();
-                this.markDirty();
-            },
-            list: () => [...this.places.keys()]
-                .sort()
-                .sort(defaultFirst)
-                .map(key => ({ scope: 'place', key })),
-            describe: layer => `${layerLabel('place')} ${layer.key}`,
-            context: layer => {
-                const { kind, key } = this.places.get(layer.key);
-                const window = kind === 'window' ? parseWindowKey(key) : undefined;
-                return { platform: window?.platform, type: window?.type, place: { kind, key } };
-            },
-        },
-    };
-    constructor(caps) {
+    /** take 读取的一方所在会话此刻的取别的会话的范围与三个开关（生效值，坏值原样） */
+    constructor(caps, take) {
+        this.take = take;
         this.caps = caps;
     }
     /**
@@ -212,7 +204,7 @@ class SessionManager {
         this.sessions = loaded?.sessions ?? new Map();
         this.places = loaded?.places ?? new Map();
         if (!this.places.has(DEFAULT_PLACE.key))
-            this.places.set(DEFAULT_PLACE.key, newPlace(DEFAULT_PLACE, '默认工作区'));
+            this.places.set(DEFAULT_PLACE.key, newPlace(DEFAULT_PLACE));
         this.deleted = { [SESSIONS]: new Map(), [PLACES]: new Map() };
         this.dirty = false;
         this.store = loaded ? target : undefined;
@@ -317,37 +309,36 @@ class SessionManager {
         return { ops, tombstones };
     }
     /**
-     * 按精确 id 幂等 upsert：命中走 updateSession（合并 config + emit `session:updated`），未命中以传入 id 建档。
-     * 创建来源在建档时写；命中按 id 兜底建档留下的空记录（没有创建来源、出生平台与绑定）时补写，随这次更新落盘。
-     * 终端配置的会话 id、/session.set 落配置覆盖时用
+     * 按精确 id 幂等 upsert：命中走 updateSession（emit `session:updated`），未命中以传入 id 建档。
+     * 创建来源在建档时写；命中按 id 兜底建档留下的空记录（{@link isUnfiled}）时补写，随这次更新落盘。
+     * 终端配置的会话 id、在收录不了的会话上写设置时用
      */
     async ensureSession(id, patch = {}, creation) {
         const session = this.sessions.get(id);
         if (!session)
             return this.insert(id, patch, creation ? { createdFrom: creation.createdFrom } : {});
-        if (creation && !session.createdFrom && !session.originPlatform && !session.work) {
+        if (creation && isUnfiled(session))
             session.createdFrom = creation.createdFrom;
-        }
         return this.updateSession(id, patch);
     }
     /**
-     * IM 房间收录：按原生入站记下的出生平台与聊天窗口建档，名字取出生平台给的群名或昵称（没有时为 id）。只给会话表里
+     * IM 房间收录：按原生入站记下的出生平台与聊天窗口建档，名字取出生平台给的群名或昵称（没有时不取名）。只给会话表里
      * 还没有的 id 同步调用。场所是窗口的同时确保窗口的场所记录：insert 在第一次等待之前已同步占住 id、记下来源字段
      */
     async recordRoom(id, nativeName, origin) {
         const [created] = await Promise.all([
-            this.insert(id, { name: nativeName || id, status: 'waiting' }, origin),
+            this.insert(id, { name: nativeName, status: 'waiting' }, origin),
             this.noteWindow(id, nativeName),
         ]);
         return created;
     }
     /**
      * IM 房间收录的补记：按 id 兜底建档的根会话（没有来源字段、创建来源与绑定）与升级前只记了出生平台的记录（没有聊天窗口，
-     * 出生平台与消息平台相同）收到原生入站时，记下与按这条消息建档时一样的来源字段，名字还是 id 的一并补上，场所是窗口的
+     * 出生平台与消息平台相同）收到原生入站时，记下与按这条消息建档时一样的来源字段，还没有名字的一并补上，场所是窗口的
      * 确保窗口的场所记录。只给表里这条记录同步调用，由收录监听判定这个 id 归消息平台的适配器管
      */
     async backfillRoom(session, nativeName, origin) {
-        Object.assign(session, origin, session.name === session.id && nativeName ? { name: nativeName } : {});
+        Object.assign(session, origin, session.name === undefined && nativeName ? { name: nativeName } : {});
         Object.assign(session, describeSession(session));
         await this.noteWindow(session.id, nativeName);
         this.markDirty();
@@ -384,20 +375,15 @@ class SessionManager {
      * （回合结束时收口），没有为 waiting（指令回复等回合之外的出站不改状态，建成 active 就会一直停在进行中）
      */
     async insert(id, patch, fields) {
-        const config = this.checkedConfig(patch.config);
         const now = Date.now();
         const session = {
             id,
-            name: patch.name ||
-                `会话 ${new Date().toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })}`,
-            title: patch.metadata?.title,
+            name: patch.name || undefined,
             parentId: undefined,
             children: [],
             status: patch.status || (this.hasTurnInFlight(id) ? 'active' : 'waiting'),
-            config,
             createdAt: now,
             updatedAt: now,
-            inputContext: patch.metadata?.inputContext,
             metadata: patch.metadata,
             ...fields,
             ...describeSession(fields),
@@ -405,9 +391,116 @@ class SessionManager {
         this.sessions.set(id, session);
         this.markDirty();
         await this.caps.events.use.emit('session:created', session);
-        this.caps.logger.use.info(`会话建档(ensure): ${session.name} (${id})`);
+        this.caps.logger.use.info(`会话建档(ensure): ${toSource(sessionLabel(session))} (${id})`);
         return session;
     }
+    /**
+     * 原生入站的收录与补记。会话表里还没有记录的真人入站（不带 source）按这条消息建档：出生平台取消息的平台，聊天窗口按这个
+     * 平台的类型声明经 chatScopeOf 记下，之后不变。WebUI 与终端的会话在入站之前已建档、带创建来源，走快路径。带 source 的是
+     * 内部注入（工作流、定时任务、空闲开话题、宿主通知、好友申请与入群邀请的合成通知），不登记；子会话按 parentId 不登记（recorded）。
+     * 消息带的类型名不在平台的声明里时按多方记下，每个平台与类型名告警一次；消息没带类型名、按平台声明的第一个多方类型记下时，
+     * 每个平台告警一次。按 id 兜底建档的根会话（注入回合在未登记的房间开子任务）没有来源字段，升级前的记录只记了出生平台、没有
+     * 聊天窗口，两者都由第一条归它的适配器管的原生入站补记（backfillRoom；后者只认出生平台的入站）。
+     * 收录与补记之前问遍认领这个 id 的适配器（claimantsOf），第一个认领者随来源字段记作所属实例。认领它的平台不止一个
+     * （如终端配置的会话 id 配成了群的 id）时判不出它是谁的窗口，不收录、不补记，每个 id 告警一次：结果不能取决于
+     * 适配器的登记先后。问的期间别的入站可能已收录，问完按会话表此刻的记录判，再建档或补记。同一会话并发的调用共用这一次。
+     * 名字只采信出生平台自己的入站：多方取群名、一对一取对方昵称，缺省不取名（群的首条入站可能是不带群名的戳一戳，
+     * 不回退到昵称）。没有名字时由后到的原生入站补上，起过的名字不动；补记不成、仍没有聊天窗口的记录判不出该取哪个，不补。
+     * 场所是窗口的同时建窗口的场所记录，它的显示名随出生平台的入站更新（owner 的 IM 私聊在默认工作区，不建）。
+     * 已登记、还没记下所属实例的房间，每条真人入站都再解析一次，认领到就补记。不会拒绝：收录失败只告警。
+     * 这个会话正在删除时（带 source 的也一样）先等删除做完，问认领者的期间开始删除的同样等删完再从头问：删除期间到的是新的
+     * 一代，不被这次删除停下、清掉
+     */
+    recordInbound(msg) {
+        const { sessionId } = msg;
+        const removing = this.removing.get(sessionId);
+        if (removing)
+            return removing.then(() => this.recordInbound(msg));
+        if (!sessionId || msg.source)
+            return Promise.resolve();
+        const known = this.sessions.get(sessionId);
+        if (this.recorded(known, msg)) {
+            this.noteRecorded(known, msg);
+            return Promise.resolve();
+        }
+        const pending = this.recording.get(sessionId);
+        if (pending)
+            return pending;
+        const recording = this.record(msg)
+            .catch(err => this.caps.logger.use.warn(`IM 房间登记失败 (${sessionId}):`, err))
+            .finally(() => this.recording.delete(sessionId));
+        this.recording.set(sessionId, recording);
+        return recording;
+    }
+    generationOf(sessionId) {
+        return this.generations.get(sessionId) ?? 0;
+    }
+    /** 不经这条入站收录或补记的会话：子会话（没有窗口），有聊天窗口、创建来源或绑定的，与出生平台不是消息平台的 */
+    recorded(session, msg) {
+        return (session !== undefined &&
+            (Boolean(session.parentId || session.originChat || session.createdFrom || session.work) ||
+                (session.originPlatform ?? msg.platform) !== msg.platform));
+    }
+    /** 已收录的会话：出生平台的入站补名、更新窗口的显示名，还没记下所属实例的再解析一次（都不等） */
+    noteRecorded(session, msg) {
+        const chat = session.originChat;
+        if (chat && session.originPlatform === msg.platform) {
+            const nativeName = chat.multiParty ? msg.groupName : msg.nickname;
+            if (nativeName && session.name === undefined)
+                this.updateSession(session.id, { name: nativeName }).catch(() => { });
+            void this.noteWindow(session.id, nativeName);
+        }
+        void this.recordOriginInstance(session);
+    }
+    /** 问完认领者再收录或补记，见 {@link recordInbound} */
+    async record(msg) {
+        const { sessionId } = msg;
+        const claimants = await claimantsOf(this.caps.platform, sessionId, this.caps.logger.use);
+        // 问的期间开始删除这个会话的，与入口同一条规则：等删除做完再从头问
+        const removing = this.removing.get(sessionId);
+        if (removing)
+            return removing.then(() => this.record(msg));
+        const session = this.sessions.get(sessionId);
+        if (this.recorded(session, msg)) {
+            this.noteRecorded(session, msg);
+            return;
+        }
+        const platforms = [...new Set(claimants.map(({ use: instance }) => instance.platform))];
+        if (platforms.length > 1) {
+            this.warnOnce(`会话 ${sessionId} 同时由平台「${platforms.join('」「')}」认领：判不出它是哪个平台的聊天窗口，不收录。` +
+                '改配置，一个会话 id 只归一个平台', `claim:${sessionId}`);
+            return;
+        }
+        // 补记只认这个 id 归消息平台的适配器管的入站：WebUI 与终端往房间插话不算
+        if (session && platforms[0] !== msg.platform)
+            return;
+        const adapter = getPlatformAdapters(this.caps.platform).find(a => a.platform === msg.platform);
+        const scope = chatScopeOf(msg, sessionTypesOf(adapter));
+        if (scope.undeclared) {
+            this.warnOnce(`平台「${scope.platform}」没有声明类型「${scope.type}」（${sessionId}）：这个聊天窗口按多方记下。` +
+                '适配器要在 sessionTypes 里声明它发出的类型名', `type:${scope.platform}:${scope.type}`);
+        }
+        else if (msg.sessionType === undefined && scope.multiParty) {
+            this.warnOnce(`平台「${scope.platform}」的消息没带类型名（${sessionId}）：这个聊天窗口按类型「${scope.type}」、多方记下。` +
+                '适配器要在消息上带类型名', `untyped:${scope.platform}`);
+        }
+        const originChat = {
+            type: scope.type,
+            multiParty: scope.multiParty,
+            ...(msg.selfId === undefined ? {} : { selfId: msg.selfId }),
+            targetId: scope.targetId,
+        };
+        const nativeName = scope.multiParty ? msg.groupName : msg.nickname;
+        const origin = {
+            originPlatform: msg.platform,
+            originChat,
+            ...(claimants[0] ? { originInstance: claimants[0].id } : {}),
+        };
+        if (session)
+            await this.backfillRoom(session, nativeName, origin);
+        else
+            await this.recordRoom(sessionId, nativeName, origin);
+    }
     /**
      * 有出生平台的房间还没记下接管它的适配器实例时，解析并记下，会话列表按它分组；已记下的不改，子任务与 owner 面
      * 会话不记。收录与补记时实例随来源字段一起记下（收录之前已解析）；收录时没有适配器认领（适配器没装好、连接还没上来、
@@ -430,29 +523,74 @@ class SessionManager {
             this.resolving.delete(session);
         }
     }
+    // ---- 取别的会话的东西 ----
+    canTake(currentId, targetId, principal) {
+        if (currentId === targetId)
+            return { ok: true };
+        const current = rootSessionOf(this.sessions.get(currentId), this.lookup);
+        const target = rootSessionOf(this.sessions.get(targetId), this.lookup);
+        // 同一棵会话树：两个判不出的根会话（都是 undefined）不算相同
+        if (current && current === target)
+            return { ok: true };
+        const from = platformOf(current);
+        const to = platformOf(target);
+        if (!current || !target || from === undefined || to === undefined)
+            return { ok: false, reason: TAKE_UNKNOWN };
+        const values = this.take.get(currentId, { platform: from });
+        // 范围写坏了的按本会话
+        if (values.takeScope !== 'platform' && values.takeScope !== 'all')
+            return { ok: false, reason: t('scopeSession') };
+        if (values.takeScope === 'platform' && from !== to)
+            return { ok: false, reason: t('scopePlatform') };
+        // 机器人账号只在同一平台里有意义：跨平台由范围管
+        const ownBot = current.originChat?.selfId;
+        const chat = target.originChat;
+        const otherBot = from === to && ownBot !== undefined && chat?.selfId !== undefined && chat.selfId !== ownBot;
+        if (otherBot && values.takeCrossBot !== true)
+            return { ok: false, reason: t('crossBot') };
+        if (chat?.multiParty) {
+            return values.takeOtherGroups === true ? { ok: true } : { ok: false, reason: t('otherGroups') };
+        }
+        if (this.ownChat(target, principal))
+            return { ok: true };
+        return values.takeOthersPrivate === true ? { ok: true } : { ok: false, reason: t('othersPrivate') };
+    }
+    /**
+     * 一对一的目标（根会话）是不是授权身份自己与她的私聊。owner 的面按与 owner 的一对一，看授权身份是不是 owner；IM 窗口按
+     * oneToOneWith，出生平台的适配器（与收录时判一对一用的同一个）明确声明了它的类型为一对一才算。权限服务不在时没有人是 owner
+     */
+    ownChat(root, principal) {
+        const authority = this.caps.authority.present ? this.caps.authority.use : undefined;
+        const isOwner = authority && ((platform, userId) => authority.isOwner(platform, userId));
+        if (root.originPlatform === undefined) {
+            return Boolean(principal?.userId && isOwner?.(principal.platform, principal.userId));
+        }
+        const adapter = getPlatformAdapters(this.caps.platform).find(a => a.platform === root.originPlatform);
+        const declared = adapter?.sessionTypes?.find(type => type.name === root.originChat?.type)?.multiParty === false;
+        return oneToOneWith(root, principal, declared, isOwner);
+    }
     // ---- CRUD ----
     async createSession(opts, creation) {
         if (creation && opts?.parentId)
             throw new Error('建档专用参数只给根会话：子会话按根会话取创建来源、所属工作区与绑定');
         const created = creation ? this.creationFields(creation) : {};
-        const config = this.checkedConfig(opts?.config);
-        const id = opts?.parentId
-            ? `${opts.parentId}::${crypto.randomUUID().slice(0, 8)}`
-            : `session-${crypto.randomUUID().slice(0, 8)}`;
+        // 子会话的 id 同样不带父会话的 id：平台按会话 id 认领窗口，子会话没有窗口。撞上已有的会话就重抽
+        let id;
+        do
+            id = `session-${crypto.randomUUID().slice(0, 8)}`;
+        while (this.sessions.has(id));
         const parent = opts?.parentId ? this.sessions.get(opts.parentId) : undefined;
         const now = Date.now();
         const session = {
             id,
-            name: opts?.name ||
-                `会话 ${new Date().toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })}`,
-            title: opts?.metadata?.title,
+            name: opts?.name || undefined,
+            title: opts?.title,
             parentId: opts?.parentId,
             children: [],
             status: opts?.status || 'active',
-            config,
             createdAt: now,
             updatedAt: now,
-            inputContext: opts?.inputContext ?? opts?.metadata?.inputContext,
+            inputContext: opts?.inputContext,
             metadata: opts?.metadata,
             ...created,
             // 子会话的当前目录取父会话此刻的值，之后各改各的
@@ -469,7 +607,7 @@ class SessionManager {
         await this.caps.events.use.emit('session:created', session);
         if (parent)
             await this.caps.events.use.emit('session:updated', parent);
-        this.caps.logger.use.info(`会话创建: ${session.name} (${id})`);
+        this.caps.logger.use.info(`会话创建: ${toSource(sessionLabel(session))} (${id})`);
         return session;
     }
     /**
@@ -514,32 +652,45 @@ class SessionManager {
         const session = this.sessions.get(id);
         if (!session)
             throw new Error(`会话不存在: ${id}`);
-        // 先校验再动记录：配置被拒时什么都不改
-        const config = updates.config && this.checkedPatch(updates.config);
         if (updates.name !== undefined)
             session.name = updates.name;
         if (updates.status !== undefined)
             session.status = updates.status;
         if (updates.metadata !== undefined)
             session.metadata = { ...session.metadata, ...updates.metadata };
-        if (config)
-            session.config = applyPatch(session.config, config);
         session.updatedAt = Date.now();
         this.markDirty();
         await this.caps.events.use.emit('session:updated', session);
-        if (config)
-            await this.caps.events.use.emit('session:config:changed');
         return session;
     }
     async deleteSession(id) {
+        await this.removeAll([id]);
+    }
+    /**
+     * 逐个删掉这些会话（各连同下面各级子会话），返回删掉的会话数。哪一处抛错都不拦住其余的，全部做完再交出：一处原样交出，几处
+     * 合成一个挂着给人看的文字的 AggregateError（各级的摊平成一层）
+     */
+    async removeAll(ids) {
+        const failures = [];
+        let removed = 0;
+        for (const id of ids)
+            removed += await this.remove(id, failures);
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1) {
+            const text = t('deleteFailed', { count: failures.length });
+            throw withText(new AggregateError(failures, text.source), text);
+        }
+        return removed;
+    }
+    /** 删掉一个会话连同下面各级子会话，返回删掉的会话数（不在表里的算 0）；抛错带会话 id 告警、收进 failures，自己不抛 */
+    async remove(id, failures) {
         const session = this.sessions.get(id);
         if (!session)
-            return;
-        // 递归删除所有子会话（含活跃子会话）
-        for (const childId of [...session.children]) {
-            await this.deleteSession(childId);
-        }
-        // 从父会话的 children 中移除：父会话的子会话列表变了，删除之后再给它发一次 session:updated
+            return 0;
+        // 开始删除，同一步：从表里摘掉（父会话的子会话列表变了，删除之后再给它发一次 session:updated）、换代号。这之后到的同一会话的
+        // 入站等删除做完（见 recordInbound），是新的一代；这之前已收录、还在半路上的是旧的一代，网关交给 agent 之前、agent 交给通道
+        // 之前比代号放掉、不归档
         const parent = session.parentId ? this.sessions.get(session.parentId) : undefined;
         if (parent) {
             parent.children = parent.children.filter(c => c !== id);
@@ -547,12 +698,36 @@ class SessionManager {
         }
         this.sessions.delete(id);
         this.deleted[SESSIONS].set(id, Symbol(id));
-        await this.clearDeletedSessionData(id);
         this.markDirty();
-        await this.caps.events.use.emit('session:deleted', id);
+        let done;
+        this.removing.set(id, new Promise(resolve => (done = resolve)));
+        this.generations.set(id, this.generationOf(id) + 1);
+        // 整个删除交给 agent 的 clearing：它先按住这个会话、停下在跑的一轮并等它收尾，按住到清完，删子会话期间这个会话也不开轮。先删
+        // 各级子会话（含活跃子会话），再发事件、清数据：监听方在事件里停掉这个会话在跑的东西，清数据时就不会有中途写回来的。子会话的
+        // 抛错收进 failures，不拦住余下的子会话与这个会话自己的发事件、清数据、给上一级发 session:updated：这个会话已摘掉，停在半路
+        // 的话它的数据不清，余下子会话的 parentId 悬空，也没法再删一次
+        let removed = 1;
+        const finish = async () => {
+            for (const childId of [...session.children])
+                removed += await this.remove(childId, failures);
+            await this.caps.events.use.emit('session:deleted', id);
+            await this.clearDeletedSessionData(id);
+        };
+        try {
+            await (this.caps.agent.present ? this.caps.agent.use.clearing([id], finish, '会话删除') : finish());
+        }
+        catch (err) {
+            this.caps.logger.use.warn(`会话删除出错 [${id}]:`, err);
+            failures.push(err);
+        }
+        finally {
+            this.removing.delete(id);
+            done();
+        }
         if (parent)
             await this.caps.events.use.emit('session:updated', parent);
-        this.caps.logger.use.info(`会话删除: ${session.name} (${id})`);
+        this.caps.logger.use.info(`会话删除: ${toSource(sessionLabel(session))} (${id})`);
+        return removed;
     }
     async clearDeletedSessionData(id) {
         const clearData = {
@@ -572,15 +747,25 @@ class SessionManager {
         });
         const failed = clearData.results.filter(r => !r.success);
         if (failed.length > 0) {
-            this.caps.logger.use.warn(`会话数据清理存在失败项 [${id}]: ${failed.map(r => `${r.source}: ${r.message}`).join('; ')}`);
+            this.caps.logger.use.warn(`会话数据清理存在失败项 [${id}]: ${failed.map(r => `${r.source}: ${toSource(r.message)}`).join('; ')}`);
         }
     }
+    /**
+     * 删掉一个会话的全部子会话（连同下面各级），不给 parentId 即删掉全部子会话；会话不在表里时什么都不删。返回这次删掉的会话数
+     * （途中别处建的、删的会话不算）
+     */
+    async deleteChildren(parentId) {
+        if (parentId !== undefined && !this.sessions.has(parentId))
+            return 0;
+        const targets = [...this.sessions.values()].filter(s => parentId === undefined ? s.parentId !== undefined : s.parentId === parentId);
+        return this.removeAll(targets.map(s => s.id));
+    }
     // ---- 树形操作 ----
     async createChildSession(parentId, opts) {
         // 带 source 的注入回合（定时任务、编排）可能落在还没建档的会话上：先按 id 兜底建档再挂子会话，否则 create_subtask
-        // 在这些会话里必败。兜底建档的会话没有来源字段与创建来源，名字为 id：是房间的由之后的原生入站补记来源字段与名字
+        // 在这些会话里必败。兜底建档的会话没有来源字段、创建来源与名字：是房间的由之后的原生入站补记来源字段与名字
         if (!this.sessions.has(parentId))
-            await this.ensureSession(parentId, { name: parentId });
+            await this.ensureSession(parentId);
         return this.createSession({ ...opts, parentId });
     }
     getChildren(parentId) {
@@ -649,6 +834,22 @@ class SessionManager {
         const record = this.places.get(key);
         return record && placeInfo(record);
     }
+    listPlaces() {
+        return [...this.places.keys()]
+            .sort()
+            .sort(defaultFirst)
+            .map(key => placeInfo(this.places.get(key)));
+    }
+    async updatePlace(key, updates) {
+        const record = this.places.get(key);
+        if (!record)
+            throw new Error(`场所不存在：${key}`);
+        if (updates.metadata !== undefined)
+            record.metadata = { ...record.metadata, ...updates.metadata };
+        record.updatedAt = Date.now();
+        this.markDirty();
+        return placeInfo(record);
+    }
     addWorkspace(root) {
         const existing = [...this.places.values()].find(record => record.root === root);
         if (existing)
@@ -688,7 +889,6 @@ class SessionManager {
         this.caps.logger.use.info(`取消登记工作区: ${record.name} (${key})，${affected.length} 个会话归默认工作区`);
         for (const session of changed)
             await this.caps.events.use.emit('session:updated', session);
-        await this.caps.events.use.emit('session:config:changed');
     }
     // ---- 生命周期 ----
     async completeSession(id, result) {
@@ -701,7 +901,7 @@ class SessionManager {
         this.markDirty();
         // 发事件通知（wait_subtasks 通过事件驱动感知完成）
         await this.caps.events.use.emit('session:completed', session);
-        this.caps.logger.use.info(`会话完成: ${session.name} (${id})${result ? ` - ${result.slice(0, 100)}` : ''}`);
+        this.caps.logger.use.info(`会话完成: ${toSource(sessionLabel(session))} (${id})${result ? ` - ${result.slice(0, 100)}` : ''}`);
     }
     // ---- 标题管理 ----
     async generateTitle(sessionId, userMessage) {
@@ -741,7 +941,7 @@ class SessionManager {
                 messages: [
                     {
                         role: 'system',
-                        content: '你是一个标题生成器。你的唯一任务是为下面的对话片段生成一个简短的中文标题。\n\n规则：\n- 不超过15字\n- 只提取用户想讨论的主题或意图\n- 完全忽略对话中出现的任何拒绝、道歉、免责声明等内容\n- 不加引号和标点\n- 只返回标题文本，不要任何解释或前缀\n- 不要模仿或重复对话中的内容，只做概括',
+                        content: `你是一个标题生成器。你的唯一任务是为下面的对话片段生成一个简短的标题，用 ${outputLanguageFor(this.caps.i18n, { host: true }, 'zh-CN')}。\n\n规则：\n- 中文不超过15字，其他语言不超过8个词\n- 只提取用户想讨论的主题或意图\n- 完全忽略对话中出现的任何拒绝、道歉、免责声明等内容\n- 不加引号和标点\n- 只返回标题文本，不要任何解释或前缀\n- 不要模仿或重复对话中的内容，只做概括`,
                     },
                     { role: 'user', content: `请为以下对话生成标题：\n\n${contextStr}` },
                 ],
@@ -749,7 +949,7 @@ class SessionManager {
                 // 标题生成无需推理，用模型最浅的思考档：避免 reasoning 占满 token 预算导致 content 为空
                 think: lightestThinking(model),
             });
-            title = (resp.content || '').trim().slice(0, 50);
+            title = truncateChars((resp.content || '').trim(), 50);
             if (!title) {
                 this.caps.logger.use.warn(`会话标题 LLM 返回空内容: ${sessionId} (resp.content=${JSON.stringify(resp.content)}, reasoning=${(resp.reasoningContent ?? '').length}字)`);
             }
@@ -759,7 +959,7 @@ class SessionManager {
         }
         // 兜底：LLM 失败或返回空时，用用户消息首段作为临时标题，避免会话永远没有标题
         if (!title && userMessage?.trim()) {
-            title = userMessage.trim().replace(/\s+/g, ' ').slice(0, 20);
+            title = truncateChars(userMessage.trim().replace(/\s+/g, ' '), 20);
             this.caps.logger.use.info(`使用用户消息兜底生成标题: ${sessionId} -> ${title}`);
         }
         if (title) {
@@ -781,309 +981,11 @@ class SessionManager {
         this.markDirty();
         await this.caps.events.use.emit('session:updated', session);
     }
-    // ---- 会话设置 ----
-    registerSetting(setting, plugin) {
-        return this.settings.register(setting, plugin);
-    }
-    listSettings() {
-        return this.settings.list();
-    }
-    /**
-     * 解析指定会话的最终生效配置：继承链之上叠会话自己的覆盖。由服务偏好承担的项在全局默认之上各层都没设时不给值：
-     * 取用方交给 resolveLLMModel，偏好指向的模型不在时也落得到服务此刻解析到的那一个
-     */
-    resolveConfig(sessionId, platform) {
-        const { values, sources } = this.resolveInheritance(sessionId, platform);
-        const inherited = { ...values };
-        for (const setting of this.settings.list()) {
-            if (preferenceBacked(setting) && sources[setting.key] === 'defaults')
-                delete inherited[setting.key];
-        }
-        return { ...inherited, ...this.getOwnConfig(sessionId) };
-    }
-    /**
-     * 继承链解析：不含会话自身 config，按层表的先后叠加，另记下每个键来自哪一层。子会话按根会话取：有出生平台的会话不论从
-     * 哪个入口驱动都按出生平台选平台档，按聊天窗口的类型名选平台类型档；传入的入口平台只对没有出生平台的会话起作用
-     */
-    resolveInheritance(sessionId, platform) {
-        const session = this.sessions.get(sessionId);
-        const root = rootSessionOf(session, this.lookup);
-        const ctx = {
-            platform: root?.originPlatform ?? platform,
-            type: root?.originPlatform === undefined ? undefined : root.originChat?.type,
-            place: this.placeOf(sessionId),
-            parent: session?.parentId ? this.sessions.get(session.parentId) : undefined,
-        };
-        return { platform: ctx.platform, type: ctx.type, ...this.stack(this.chain(ctx)) };
-    }
-    getOwnConfig(sessionId) {
-        return this.valid(this.sessions.get(sessionId)?.config, `会话 ${sessionId}`, true);
-    }
-    childConfig(parentId, platform) {
-        const config = this.resolveConfig(parentId, platform);
-        for (const setting of this.settings.list()) {
-            if (setting.liveOnly || setting.narrowest)
-                delete config[setting.key];
-        }
-        return config;
-    }
-    resolvedDefaults() {
-        // 按真正调模型的 agent 插件的解析顺序取（它可能设了本插件偏好）；没装 agent 时按本插件的
-        const agentId = this.caps.agent.list().find(p => p.selected)?.id;
-        const entries = this.caps.llm.list();
-        const ordered = agentId === undefined
-            ? entries
-            : this.caps.services.use
-                .inspect(llm, { for: agentId })
-                .flatMap(info => entries.filter(e => e.id === info.contextId));
-        const entry = resolveLLMModel({ list: () => ordered }, undefined, ['chat']);
-        if (!entry)
-            return {};
-        const model = { provider: entry.use.providerId, model: entry.use.id };
-        return Object.fromEntries(this.settings.list().flatMap(s => (preferenceBacked(s) ? [[s.key, model]] : [])));
-    }
-    listLayers() {
-        return SESSION_LAYERS.flatMap(({ name }) => Object.hasOwn(this.layerTable, name) ? this.layerTable[name].list() : []);
-    }
-    getLayer(layer) {
-        const impl = this.implOf(layer);
-        impl.assert(layer);
-        return this.valid(impl.read(layer), impl.describe(layer));
-    }
-    resolveLayer(layer) {
-        const impl = this.implOf(layer);
-        impl.assert(layer);
-        return this.stack(this.chain(impl.context(layer), layer.scope));
-    }
-    async updateLayer(layer, patch) {
-        const impl = this.implOf(layer);
-        impl.assert(layer);
-        const checked = checkPatch(this.settings, patch);
-        await impl.write(layer, applyPatch(impl.read(layer), checked));
-        this.caps.logger.use.info(`会话设置已改：${impl.describe(layer)}（${[...checked.keys()].join('、')}）`);
-        void this.caps.events.use.emit('session:config:changed');
-    }
-    /** 这一层的实现；不认识的层抛 {@link SessionConfigError} */
-    implOf(layer) {
-        const scope = layer?.scope;
-        if (typeof scope !== 'string' || !Object.hasOwn(this.layerTable, scope)) {
-            throw new SessionConfigError(`会话设置的层不认识：${String(scope)}`);
-        }
-        return this.layerTable[scope];
-    }
-    /**
-     * 按层表的先后取一个会话（或一层的视图）上各层的值，到 until 为止：会话之上的层各按自己的实现选那一份，父会话层是
-     * 父会话的 sessionDefaults（旧数据）
-     */
-    chain(ctx, until = 'parent') {
-        const parts = [];
-        for (const { name } of SESSION_LAYERS) {
-            if (name === 'session')
-                break;
-            if (name === 'parent') {
-                if (ctx.parent)
-                    parts.push([ctx.parent.config.sessionDefaults, name, `会话 ${ctx.parent.id} 给子会话的默认值`]);
-            }
-            else {
-                const impl = this.layerTable[name];
-                const layer = impl.select(ctx);
-                if (layer)
-                    parts.push([impl.read(layer), name, impl.describe(layer)]);
-            }
-            if (name === until)
-                break;
-        }
-        return parts;
-    }
-    /** 按顺序叠加几处设置：后面的覆盖前面的，逐键记下来源 */
-    stack(parts) {
-        const values = {};
-        const sources = {};
-        for (const [raw, source, where] of parts) {
-            for (const [key, value] of Object.entries(this.valid(raw, where, source === 'parent'))) {
-                values[key] = value;
-                sources[key] = source;
-            }
-        }
-        return { values, sources };
-    }
-    /** 宿主配置文档里的三层；没有文档时为空 */
-    docLayers() {
-        return readLayers(this.caps.hostConfig.present ? this.caps.hostConfig.use.get('sessionConfig') : undefined, message => this.warnOnce(message));
-    }
-    /** 改宿主配置文档并落盘：change 改文档并返回撤回它的函数。没有文档时抛错；落盘失败时撤回、以拒绝传出 */
-    async saveHost(change) {
-        if (!this.caps.hostConfig.present)
-            throw new Error('宿主没有提供配置文档（host-config），会话设置的各层无处保存');
-        const host = this.caps.hostConfig.use;
-        const revert = change(host);
-        try {
-            await host.save();
-        }
-        catch (err) {
-            // 拒写与写入失败都撤回：免得下一次任意保存把这次没存下的修改写进文件
-            revert();
-            throw err;
-        }
-    }
-    /** 改文档里的三层：在现读的一份上改，整份写回 */
-    writeDoc(update) {
-        return this.saveHost(host => {
-            const previous = host.get('sessionConfig');
-            const layers = this.docLayers();
-            update(layers);
-            host.set('sessionConfig', writeLayers(layers));
-            return () => host.set('sessionConfig', previous);
-        });
-    }
-    /**
-     * 全局默认层：文档里的 defaults，由服务偏好承担的项换成 llm 服务的偏好。文档里写了这些项的告警后忽略（按层写时不再写回）
-     */
-    readDefaults() {
-        const values = { ...this.docLayers().defaults };
-        const preferred = this.preferredModel();
-        for (const setting of this.settings.list()) {
-            if (!preferenceBacked(setting))
-                continue;
-            if (setting.key in values) {
-                this.warnOnce(`宿主配置 sessionConfig.defaults.${setting.key} 不再生效，已忽略：默认模型只在 llm 服务的偏好里，` +
-                    '在「会话默认」的全局默认层改');
-            }
-            delete values[setting.key];
-            if (preferred)
-                values[setting.key] = preferred;
-        }
-        return values;
-    }
-    /**
-     * llm 服务的偏好写成模型引用：条目在时按它的提供者与模型 id；不在时按还装着的提供者拆（取能作为 `<提供者>/` 前缀的最长的
-     * 一个，模型 id 里的斜杠留在模型里），提供者也不在时按最后一个斜杠拆。拆不出、或拆出的提供者只剩 npm scope（偏好只写了
-     * 提供者，如 `@scope/llm-x`）的读不成模型引用，偏好没有生效由 doctor 报出
-     */
-    preferredModel() {
-        const contextId = this.caps.services.use.preferred(llm);
-        if (contextId === undefined)
-            return undefined;
-        const entries = this.caps.llm.list();
-        const entry = entries.find(e => e.id === contextId);
-        if (entry)
-            return { provider: entry.use.providerId, model: entry.use.id };
-        const provider = entries
-            .map(e => e.use.providerId)
-            .filter(id => contextId.startsWith(`${id}/`))
-            .sort((a, b) => b.length - a.length)[0];
-        const cut = provider === undefined ? contextId.lastIndexOf('/') : provider.length;
-        const ref = { provider: contextId.slice(0, cut), model: contextId.slice(cut + 1) };
-        return cut > 0 && !/^@[^/]*$/.test(ref.provider) ? ref : undefined;
-    }
-    /**
-     * 写全局默认层：由服务偏好承担的项写 llm 服务的偏好（运行态与文档的 servicePreferences，没有值即取消偏好），其余写文档的
-     * defaults。这一层读出的是偏好（{@link readDefaults}），按读出的值比：只有这一项改了才动偏好，几项都由偏好承担时取改了的
-     * 那一项。读不成模型引用的偏好（手写的）读出来没有这一项，改别的项不碰它。落盘失败时偏好与文档一并撤回
-     */
-    writeDefaults(values) {
-        const backed = this.settings.list().filter(preferenceBacked);
-        const preferred = this.preferredModel();
-        const changed = backed.find(setting => !isDeepStrictEqual(values[setting.key], preferred));
-        const ref = changed && values[changed.key];
-        const rest = { ...values };
-        for (const { key } of backed)
-            delete rest[key];
-        return this.saveHost(host => {
-            const revertPreference = changed ? this.setPreference(host, ref && `${ref.provider}/${ref.model}`) : () => { };
-            const previous = host.get('sessionConfig');
-            host.set('sessionConfig', writeLayers({ ...this.docLayers(), defaults: rest }));
-            return () => {
-                host.set('sessionConfig', previous);
-                revertPreference();
-            };
-        });
-    }
-    /** 改 llm 服务的偏好（运行态与文档），返回撤回它的函数 */
-    setPreference(host, contextId) {
-        const runtime = this.caps.services.use.preferred(llm);
-        const documented = host.getServicePreferences()[llm.name];
-        const apply = (live, doc) => {
-            if (live === undefined)
-                this.caps.services.use.unprefer(llm);
-            else
-                this.caps.services.use.prefer(llm, live);
-            if (doc === undefined)
-                host.removeServicePreference(llm.name);
-            else
-                host.setServicePreference(llm.name, doc);
-        };
-        apply(contextId, contextId);
-        return () => apply(runtime, documented);
-    }
-    /**
-     * 平台档可设的平台：已装适配器的平台加文档里写过的（两段里的都算），按名字排。名字不合层标识写法的不列（文档里的读时已滤掉）：
-     * 列出的层都要能按层读写
-     */
-    platformNames() {
-        const doc = this.docLayers();
-        const names = new Set([...doc.platforms.keys(), ...doc.types.keys()]);
-        for (const adapter of getPlatformAdapters(this.caps.platform))
-            names.add(adapter.platform);
-        return [...names].filter(isLayerName).sort();
-    }
-    /** 平台类型档可设的类型：适配器声明的类型加文档里写过的，按名字排；没声明类型的适配器不单列，名字不合写法的不列 */
-    typeNames(platform) {
-        const names = new Set(this.docLayers().types.get(platform)?.keys());
-        for (const adapter of getPlatformAdapters(this.caps.platform)) {
-            if (adapter.platform === platform)
-                for (const type of adapter.sessionTypes ?? [])
-                    names.add(type.name);
-        }
-        return [...names].filter(isLayerName).sort();
-    }
-    /**
-     * 一处设置里已登记的项：没登记的不参与解析；取值不合登记字段的当作没设置，字段标了 onInvalid: 'error' 的原样交出、
-     * 由登记它的插件按拒绝处理。会话上的设置（会话自己的覆盖、父会话给子会话的默认值）里只能设到场所为止的项不参与解析：
-     * 写入不收它，旧数据里留着的不能压过场所。这两种问题同一处同一项只告警一次
-     */
-    valid(values, where, onSession = false) {
-        const out = {};
-        for (const [key, value] of Object.entries(values ?? {})) {
-            // 清掉的覆盖经 BSON 落盘读回来是 null，与没有同义
-            if (value === undefined || value === null)
-                continue;
-            const setting = this.settings.get(key);
-            if (!setting)
-                continue;
-            if (onSession && setting.narrowest) {
-                this.warnOnce(`设置项 ${key}（${where}）只能设到场所为止，会话上的值不生效：改到场所或以上的层，再清掉它`);
-                continue;
-            }
-            const read = readSetting(setting, value);
-            if (!('invalid' in read)) {
-                if (read.value !== undefined)
-                    out[key] = read.value;
-            }
-            else if (setting.field.onInvalid === 'error') {
-                this.warnOnce(`设置项 ${key}（${where}）取值无效（${read.invalid}），原样交给登记它的插件按拒绝处理`);
-                out[key] = value;
-            }
-            else {
-                this.warnOnce(`设置项 ${key}（${where}）取值无效（${read.invalid}），按没设置处理`);
-            }
-        }
-        return out;
-    }
-    /** 写会话自己的覆盖：按登记的设置项校验，只能设到场所为止的项不收 */
-    checkedPatch(patch) {
-        const checked = checkPatch(this.settings, patch);
-        assertSessionPatch(this.settings, checked);
-        return checked;
-    }
-    /** 建会话时给的配置：校验后作为会话自己的覆盖 */
-    checkedConfig(config) {
-        return config ? applyPatch({}, this.checkedPatch(config)) : {};
-    }
-    warnOnce(message) {
-        if (this.warned.has(message))
+    /** 同一处只告警一次：key 缺省为这句话本身 */
+    warnOnce(message, key = message) {
+        if (this.warned.has(key))
             return;
-        this.warned.add(message);
+        this.warned.add(key);
         this.caps.logger.use.warn(message);
     }
     hasTurnInFlight(sessionId) {
@@ -1109,8 +1011,11 @@ class SessionManager {
         if (!turn)
             return;
         turn.outcome = outcome;
-        // 一句原因：agent 给的可能带上游的整段响应，会随会话落盘、进子任务提醒；空串当作没给
-        turn.error = outcome === 'error' && error ? truncateChars(error, ERROR_MAX, '…') : undefined;
+        // 一句原因：agent 给的可能带上游的整段响应（字符串本身，或文字对象的参数），会随会话落盘、进子任务提醒，截短；空串当作没给
+        if (outcome !== 'error' || !error)
+            turn.error = undefined;
+        else
+            turn.error = typeof error === 'string' ? truncateChars(error, ERROR_MAX, '…') : truncateParams(error, ERROR_MAX);
     }
     /**
      * 回合结束：注销这一轮，记下 lastTurn（被拦下、没有结局的一轮记为 silent），结局为 replied 的另记下她开口的时间。
@@ -1188,13 +1093,22 @@ class SessionManager {
 function describeSession(session) {
     return { kind: sessionKind(session) };
 }
-/** 新建的场所记录：设置为空 */
+/**
+ * 判得出的根会话的平台：IM 房间（出生平台加聊天窗口）取出生平台，owner 的面（有创建来源）取创建来源。不在会话表里的、按 id
+ * 兜底建档的空记录与只记了出生平台的旧房间记录（等下一条原生入站补记）判不出
+ */
+function platformOf(root) {
+    if (root?.originPlatform !== undefined)
+        return root.originChat ? root.originPlatform : undefined;
+    return root?.createdFrom;
+}
+/** 新建的场所记录：默认工作区没有名字 */
 function newPlace(place, name, root) {
     const now = Date.now();
-    return { ...place, name, ...(root === undefined ? {} : { root }), config: {}, createdAt: now, updatedAt: now };
+    return { ...place, name, ...(root === undefined ? {} : { root }), createdAt: now, updatedAt: now };
 }
-function placeInfo({ kind, key, name }) {
-    return { kind, key, name };
+function placeInfo({ kind, key, name, metadata }) {
+    return { kind, key, name, ...(metadata === undefined ? {} : { metadata }) };
 }
 function workspaceInfo({ key, name, root }) {
     return { id: key.slice(WORKSPACE_PREFIX.length), name, ...(root === undefined ? {} : { root }) };
@@ -1224,6 +1138,7 @@ const isRecord = (value) => typeof value === 'object' && value !== null && !Arra
  * 会话记录里会进会话列表与协议、类型不对会让读者出错的可选字段，各自的类型。种类载入时重算，不在这里
  */
 const OPTIONAL_FIELDS = {
+    name: isText,
     title: isText,
     parentId: isText,
     createdFrom: isText,
@@ -1241,7 +1156,7 @@ const OPTIONAL_FIELDS = {
     lastTurn: value => isRecord(value) &&
         TURN_OUTCOMES.has(value.outcome) &&
         isTime(value.endedAt) &&
-        (value.error === undefined || isText(value.error)),
+        (value.error === undefined || asText(value.error) !== undefined),
     tokens: value => isRecord(value) && isTime(value.input) && isTime(value.output),
 };
 /**
@@ -1252,10 +1167,8 @@ function storedSession(key, data) {
     const record = Object.fromEntries(Object.entries(data).filter(([, value]) => value !== null));
     const required = {
         id: record.id === key,
-        name: isText(record.name),
         children: isTextList(record.children),
         status: SESSION_STATUSES.has(record.status),
-        config: isRecord(record.config),
         createdAt: isTime(record.createdAt),
         updatedAt: isTime(record.updatedAt),
     };
@@ -1271,7 +1184,7 @@ function storedSession(key, data) {
 }
 /**
  * 读回的场所记录：必填字段不对（含类别与键对不上：工作区的键以 `workspace:` 开头，窗口的不是）时回这个字段名，整条不载入；
- * 目录的类型不对时去掉它
+ * 可选的名字（默认工作区没有）、目录与 metadata 类型不对时去掉它
  */
 function storedPlace(key, data) {
     const record = Object.fromEntries(Object.entries(data).filter(([, value]) => value !== null));
@@ -1279,17 +1192,18 @@ function storedPlace(key, data) {
         key: record.key === key,
         kind: (record.kind === 'workspace' || record.kind === 'window') &&
             (record.kind === 'workspace') === key.startsWith(WORKSPACE_PREFIX),
-        name: isText(record.name),
-        config: isRecord(record.config),
         createdAt: isTime(record.createdAt),
         updatedAt: isTime(record.updatedAt),
     };
     const wrong = Object.keys(required).find(field => !required[field]);
     if (wrong)
         return { wrong };
-    const dropped = record.root !== undefined && !isText(record.root) ? ['root'] : [];
-    if (dropped.length > 0)
-        delete record.root;
+    const dropped = [
+        ...['name', 'root'].filter(field => record[field] !== undefined && !isText(record[field])),
+        ...(record.metadata !== undefined && !isRecord(record.metadata) ? ['metadata'] : []),
+    ];
+    for (const field of dropped)
+        delete record[field];
     return { record: record, dropped };
 }
 // ===== 插件入口 =====
@@ -1297,27 +1211,33 @@ const uses = {
     /** 会话档案与消息历史的唯一落点：没有 memory 就没有会话管理 */
     memory,
     /**
-     * 本插件不调用 agent 的方法；声明它是为了 agent:* 钩子的键类型，并据它认出真正调模型的那个插件（默认模型按它的选择写）。
+     * 删除会话清数据时经它的 clearing 按住这个会话；另为 agent:* 钩子的键类型。
      * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与回合结束时的收口处理；
      * 此处 onDrain 兜的是未装 agent 或钩子未挂上的路径。
      */
     agent: optional(agent),
-    /** 自动标题的模型来源（没有 LLM 时退回用户消息首段）；全局默认层的「模型」按偏好指向的条目写出提供者与模型 */
+    /** 自动标题的模型来源（没有 LLM 时退回用户消息首段） */
     llm: optional(llm),
-    /** 房间建档时取平台的类型声明记下聊天窗口；解析接管房间的适配器实例（originInstance）；可设的平台与类型 */
-    platform: optional(platform),
     /**
-     * 会话设置的全局默认、平台档与平台类型档存放在宿主配置文档的 sessionConfig 字段里。由宿主在根上提供、没有插件
-     * provide 它，写进激活闸只会挂一条解析不到提供者的告警；缺席时这三层为空、按层写被拒
+     * 自动标题的输出语言：取全局语言（读者是 owner），缺席时按中文。plugin-i18n 也以 optional 用会话管理，
+     * 两边成可选环
      */
-    hostConfig: optional(hostConfig),
+    i18n: optional(i18n),
+    /** 房间建档时问认领者、取平台的类型声明记下聊天窗口；解析接管房间的适配器实例（originInstance） */
+    platform: optional(platform),
     /**
      * owner 的 IM 私聊在默认工作区：placeOf 按它认对端是不是 owner，与房间类别同一判据。plugin-authority 也以 optional
      * 用会话管理，两边成可选环；缺席时认不出 owner，一对一窗口按窗口算
      */
     authority: optional(authority),
-    /** 全局默认层的「模型」读写 llm 服务的偏好 */
-    services,
+    /**
+     * 按会话读取别的会话的范围与三个开关；缺席时取插件配置里的值。plugin-session-settings 以 required 用会话管理：这边可选，
+     * 读取器的登记随它上线补上
+     */
+    sessionFields: optional(sessionFields),
+    /** 按会话字段的全局层：宿主配置文档里本实例的那一段 */
+    document: optional(ownHostConfig),
+    config,
     events,
     hooks,
     lifecycle,
@@ -1326,123 +1246,52 @@ const uses = {
 };
 export default definePlugin({
     name: '@aalis/plugin-session-manager',
-    displayName: '会话管理',
+    displayName: t('displayName'),
     subsystem: 'session',
+    configSchema,
     provides: [sessionManager],
     uses,
     apply: run,
 });
 async function run(caps) {
     const { memory, events, hooks, lifecycle, logger, provide } = caps;
-    const manager = new SessionManager(caps);
+    const manager = new SessionManager(caps, caps.sessionFields.use.fields(configSchema, caps));
     // 会话表跟随 memory 胜者：首次挂接即加载；运行中胜者换人时先写回旧后端再读新后端
     memory.follow(instance => manager.attach(instance));
     await manager.loading;
     // 读表（含重试等待）期间停用或停机的，不再发布服务与登记
     lifecycle.use.signal.throwIfAborted();
     // 注册服务
-    provide.use(sessionManager, manager, { label: '会话管理' });
+    provide.use(sessionManager, manager, { label: t('displayName') });
     // ===== IM 房间收录 =====
-    // 会话表里还没有记录的真人入站（不带 source、不是子任务）按这条消息建档：出生平台取消息的平台，聊天窗口按这个平台的
-    // 类型声明经 chatScopeOf 记下，之后不变。WebUI 与终端的会话在入站之前已建档、带创建来源，不经这里。带 source 的是
-    // 内部注入（工作流、定时任务、空闲开话题、宿主通知、好友申请与入群邀请的合成通知），不登记。消息带的类型名不在平台的
-    // 声明里时按多方记下，每个平台与类型名告警一次；消息没带类型名、按平台声明的第一个多方类型记下时，每个平台告警一次。
-    // 按 id 兜底建档的根会话（注入回合在未登记的房间开子任务）没有来源字段，升级前的记录只记了出生平台、没有聊天窗口，
-    // 两者都由第一条归它的适配器管的原生入站补记（backfillRoom；后者只认出生平台的入站）。
-    // 收录与补记之前问遍认领这个 id 的适配器（claimantsOf），第一个认领者随来源字段记作所属实例。认领它的平台不止一个
-    // （如终端配置的会话 id 配成了群的 id）时判不出它是谁的窗口，不收录、不补记，每个 id 告警一次：结果不能取决于
-    // 适配器的登记先后。问的期间别的入站可能已收录，问完按会话表此刻的记录判，再同步建档或补记。
-    // 名字只采信出生平台自己的入站：多方取群名、一对一取对方昵称，缺省用 id（群的首条入站可能是不带群名的戳一戳，
-    // 不回退到昵称）。现名还是 id 时由后到的原生入站补上，起过的名字不动；补记不成、仍没有聊天窗口的记录判不出该取哪个，
-    // 不补。
-    // 场所是窗口的同时建窗口的场所记录，它的显示名随出生平台的入站更新（owner 的 IM 私聊在默认工作区，不建）。
-    // 已登记、还没记下所属实例的房间，每条真人入站都再解析一次，认领到就补记。
-    const warned = new Set();
-    const warnOnce = (key, message) => {
-        if (warned.has(key))
-            return;
-        warned.add(key);
-        logger.use.warn(message);
-    };
-    /** 不经这条入站收录或补记的会话：有聊天窗口、创建来源或绑定的，与出生平台不是消息平台的 */
-    const recorded = (session, msg) => session !== undefined &&
-        (Boolean(session.originChat || session.createdFrom || session.work) ||
-            (session.originPlatform ?? msg.platform) !== msg.platform);
-    /** 已收录的会话：出生平台的入站补名、更新窗口的显示名，还没记下所属实例的再解析一次 */
-    const noteRecorded = (session, msg) => {
-        const chat = session.originChat;
-        if (chat && session.originPlatform === msg.platform) {
-            const nativeName = chat.multiParty ? msg.groupName : msg.nickname;
-            if (nativeName && session.name === session.id)
-                manager.updateSession(session.id, { name: nativeName }).catch(() => { });
-            void manager.noteWindow(session.id, nativeName);
-        }
-        void manager.recordOriginInstance(session);
-    };
-    events.use.on('inbound:message', async (msg) => {
-        const { sessionId } = msg;
-        if (!sessionId || msg.source || sessionId.includes('::'))
-            return;
-        const known = manager.getSession(sessionId);
-        if (recorded(known, msg)) {
-            noteRecorded(known, msg);
-            return;
-        }
-        const claimants = await claimantsOf(caps.platform, sessionId, logger.use);
-        const session = manager.getSession(sessionId);
-        if (recorded(session, msg)) {
-            noteRecorded(session, msg);
-            return;
-        }
-        const platforms = [...new Set(claimants.map(({ use: instance }) => instance.platform))];
-        if (platforms.length > 1) {
-            warnOnce(`claim:${sessionId}`, `会话 ${sessionId} 同时由平台「${platforms.join('」「')}」认领：判不出它是哪个平台的聊天窗口，不收录。` +
-                '改配置，一个会话 id 只归一个平台');
-            return;
-        }
-        // 补记只认这个 id 归消息平台的适配器管的入站：WebUI 与终端往房间插话不算
-        if (session && platforms[0] !== msg.platform)
+    // 原生入站的收录与补记见 recordInbound；网关在入站相位之前也等它，同一会话共用同一次
+    events.use.on('inbound:message', msg => manager.recordInbound(msg));
+    // ===== 清空连带删除子会话 =====
+    // 会话的消息历史清成功（结果里 type 为 context 的行都成功了）之后，它的子会话一并删除：范围为 session 删这个会话的，为 all
+    // 删全部子会话，删了的在结果里加一行。只清别的类型、消息历史没清成时不删；会话不在表里（删除会话自己触发的那次清理，会话已
+    // 先从表里摘掉）时什么都不做
+    hooks.use.middleware('memory:clear', async (data, next) => {
+        await next();
+        if (!historyCleared(data))
             return;
-        const adapter = getPlatformAdapters(caps.platform).find(a => a.platform === msg.platform);
-        const scope = chatScopeOf(msg, sessionTypesOf(adapter));
-        if (scope.undeclared) {
-            warnOnce(`type:${scope.platform}:${scope.type}`, `平台「${scope.platform}」没有声明类型「${scope.type}」（${sessionId}）：这个聊天窗口按多方记下。` +
-                '适配器要在 sessionTypes 里声明它发出的类型名');
-        }
-        else if (msg.sessionType === undefined && scope.multiParty) {
-            warnOnce(`untyped:${scope.platform}`, `平台「${scope.platform}」的消息没带类型名（${sessionId}）：这个聊天窗口按类型「${scope.type}」、多方记下。` +
-                '适配器要在消息上带类型名');
+        const deleted = await manager.deleteChildren(data.scope === 'all' ? undefined : data.sessionId);
+        if (deleted > 0) {
+            data.results.push({
+                source: 'session-manager',
+                type: 'context',
+                success: true,
+                message: t('childrenDeleted', { count: deleted }),
+            });
         }
-        const originChat = {
-            type: scope.type,
-            multiParty: scope.multiParty,
-            ...(msg.selfId === undefined ? {} : { selfId: msg.selfId }),
-            targetId: scope.targetId,
-        };
-        const nativeName = scope.multiParty ? msg.groupName : msg.nickname;
-        const origin = {
-            originPlatform: msg.platform,
-            originChat,
-            ...(claimants[0] ? { originInstance: claimants[0].id } : {}),
-        };
-        (session
-            ? manager.backfillRoom(session, nativeName, origin)
-            : manager.recordRoom(sessionId, nativeName, origin)).catch(err => logger.use.warn(`IM 房间登记失败 (${sessionId}):`, err));
-    });
-    // 全局默认层的「模型」就是 llm 服务的偏好：偏好从别处改了（宿主启动时应用）、llm 的提供者上下线（偏好指向的模型在不在、
-    // 服务实际用的那一个随之变）同样算会话设置变了
-    events.use.on('service:changed', name => {
-        if (name === llm.name)
-            void events.use.emit('session:config:changed');
     });
     // ===== 会话状态 =====
-    // 回合真正开始时（agent:input:before）才翻 active，归档的不翻：群里只有消息、她没开口的房间不显示「进行中」
+    // 回合真正开始时（agent:turn:before）才翻 active，归档的不翻：群里只有消息、她没开口的房间不显示「进行中」
     //（触发判定在入站相位，挡下的消息到不了这里）。同一个中间件在 finally 里记下这一轮并收口，根会话与子会话一样，这是
     // 唯一的收口：next() 返回时整轮已跑完、agent:turn:after 也已执行（agent 只在这个钩子的默认动作里发它），结局已经记下；
-    // 后面的中间件不调 next() 或抛错时 agent 不发回合收尾，同样由这里兜住。按回合 id 登记在飞的回合，会话里最后一轮结束
-    // 才收口，别的 lane 还在跑时不显示已完成；回合中途的出站（send_attachment、paper_send 在工具执行中直接发）不收口。
-    hooks.use.middleware('agent:input:before', async (data, next) => {
-        manager.beginTurn(data.message.sessionId, data.turnId);
+    // 后面的中间件不调 next() 或抛错时 agent 不发回合收尾，同样由这里兜住。按回合 id 登记在飞的回合，会话里没有别的在飞回合
+    // 时才收口；回合中途的出站（send_attachment、paper_send 在工具执行中直接发）不收口。
+    hooks.use.middleware('agent:turn:before', async (data, next) => {
+        manager.beginTurn(data.sessionId, data.turnId);
         try {
             await next();
         }