@aalis/plugin-session-manager 0.14.0 → 0.15.0

package/dist/index.js

@@ -1,123 +1,35 @@
+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 { hooks } from '@aalis/api-hooks';
-import { listLLMModels, llm, resolveLLMModel } from '@aalis/api-llm';
+import { hostConfig } from '@aalis/api-host-config';
+import { lightestThinking, llm, resolveLLMModel } from '@aalis/api-llm';
 import { memory } from '@aalis/api-memory';
-import { persona } from '@aalis/api-persona';
-import { getPlatformNames, platform } from '@aalis/api-platform';
-import { sessionManager, } from '@aalis/api-session-manager';
-import { tools } from '@aalis/api-tools';
-import { webuiServer } from '@aalis/api-webui';
-import { config, definePlugin, events, lifecycle, logger, optional, provide } from '@aalis/core';
-import { defineConfig, parseConfig } from '@aalis/schema-config';
-const configSchema = defineConfig({
-    defaults: {
-        label: '全局默认配置',
-        description: '所有平台共享的最低层默认配置（platform profile 之下的 fallback）。LLM 默认模型由各 agent 插件通过 ServicePreference 锁定，不再在此配置；本节仅保留 persona 等通用默认。',
-        fields: {
-            persona: {
-                type: 'select',
-                label: '默认人设',
-                dynamicOptions: 'persona',
-                allowCustom: true,
-                description: '所有平台未单独指定时使用的默认人设',
-            },
-        },
-    },
-    platformProfiles: {
-        type: 'array',
-        label: '平台默认配置',
-        default: [],
-        description: '为每个平台设置默认的会话配置模板。新会话创建时自动应用对应平台的模板。',
-        items: {
-            platform: {
-                type: 'string',
-                label: '平台标识',
-                required: true,
-                description: '平台名（如 onebot、webui、cli）',
-            },
-            persona: {
-                type: 'select',
-                label: '人设文件',
-                dynamicOptions: 'persona',
-                allowCustom: true,
-                description: '该平台默认使用的人设文件名（不含后缀）',
-            },
-            llm: {
-                type: 'llm-ref',
-                label: '默认模型',
-                description: '该平台新会话的默认 LLM (provider + model)。留空则沿用 ServicePreference 锁定的全局默认。',
-            },
-            enabledToolGroups: {
-                type: 'multiselect',
-                label: '工具分组',
-                dynamicOptions: 'toolGroups',
-                allowCustom: true,
-                description: '该平台启用的工具分组',
-            },
-            disableOutputFormat: {
-                type: 'boolean',
-                label: '禁用结构化输出',
-                description: '禁用 JSON 结构化输出，回复纯文本',
-            },
-            clientSideJsonRendering: {
-                type: 'boolean',
-                label: '客户端渲染 JSON',
-                description: '保留完整 JSON 给前端渲染，不提取回复字段',
-            },
-            think: {
-                type: 'select',
-                label: 'thinking 默认',
-                options: [
-                    { label: '继承 provider 全局配置', value: '' },
-                    { label: '强制开启', value: 'on' },
-                    { label: '强制关闭', value: 'off' },
-                ],
-                description: '该平台会话的深度思考默认档。留空=各 LLM provider 自行决定；会话可用 /session.set -t 进一步覆盖。',
-            },
-        },
-    },
-});
+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 { truncateChars } from '@aalis/util-text-normalize';
+import { applyPatch, assertName, assertSessionPatch, checkPatch, isLayerName, readLayers, readSetting, SettingRegistry, writeLayers, } from './settings.js';
 // ===== 常量 =====
-const METADATA_NAMESPACE = 'sessions';
+/** 会话表与场所记录在记忆后端元数据里的命名空间 */
+const SESSIONS = 'sessions';
+const PLACES = 'places';
+/** 必填字段不对、没有载入的记录移到 `<命名空间>-rejected`：留在原处会被之后同键的建档整条覆盖 */
+const REJECTED_SUFFIX = '-rejected';
+/** 工作区的场所键前缀；默认工作区的 id 为 default */
+const WORKSPACE_PREFIX = 'workspace:';
+const DEFAULT_WORKSPACE = 'default';
+const DEFAULT_PLACE = Object.freeze({
+    kind: 'workspace',
+    key: `${WORKSPACE_PREFIX}${DEFAULT_WORKSPACE}`,
+});
 /** 读会话表失败后的重试间隔（毫秒）；用尽仍失败按读表失败处理 */
 const LOAD_RETRY_DELAYS = [1000, 3000, 10_000];
-// ===== WebuiPages（声明式 UI） =====
-/**
- * WebUI 传来的会话配置补丁：JSON 带不了 undefined，前端用 null 表示「删除该键、恢复继承」。
- * updateSession 是合并语义，键置为 undefined 即从生效配置里消失（resolveConfig 会 strip）。
- */
-export function normalizeSessionConfigPatch(patch) {
-    if (!patch || typeof patch !== 'object' || Array.isArray(patch))
-        throw new Error('缺少配置');
-    return Object.fromEntries(Object.entries(patch).map(([k, v]) => [k, v === null ? undefined : v]));
-}
-const webuiPages = [
-    {
-        key: 'sessions',
-        label: '会话管理',
-        icon: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/><path d="M8 10h8M8 14h4"/></svg>',
-        order: 6,
-        renderer: 'sessions',
-    },
-];
+/** 最近一轮出错原因最多留多少字 */
+const ERROR_MAX = 200;
 // ===== 辅助函数 =====
-/**
- * 递归归档：先归档所有子会话再归档自己。
- *
- * 写成自由函数而非方法：页面动作是被单独取出调用的（没有 receiver），递归不能依赖 this。
- */
-async function archiveRecursively(sm, id) {
-    const session = sm.getSession(id);
-    if (session) {
-        for (const childId of session.children) {
-            const child = sm.getSession(childId);
-            if (child && child.status !== 'archived') {
-                await archiveRecursively(sm, childId);
-            }
-        }
-    }
-    await sm.updateSession(id, { status: 'archived' });
-}
 /** 等待 ms 毫秒，signal 中止时提前返回。不用 node:timers/promises：全局定时器测试里能用假时钟推进 */
 function wait(ms, signal) {
     return new Promise(resolve => {
@@ -130,27 +42,23 @@ function wait(ms, signal) {
         signal.addEventListener('abort', done, { once: true });
     });
 }
-function formatConfigSummary(config) {
-    const parts = [];
-    if (config.llm?.model)
-        parts.push(`${config.llm.provider}/${config.llm.model}`);
-    if (config.enabledToolGroups?.length)
-        parts.push(config.enabledToolGroups.includes('*') ? 'tools:全部' : `tools:${config.enabledToolGroups.length}组`);
-    if (config.persona)
-        parts.push(`persona:${config.persona}`);
-    return parts.join(', ') || '(默认)';
-}
+/** 层表里这一层的称呼，日志里点名层时用 */
+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 {
     sessions = new Map();
+    /** 场所记录：键 → 记录。与会话表一同加载与落盘 */
+    places = new Map();
     caps;
     persistTimer = null;
     dirty = false;
     /**
-     * 本进程显式删除、尚未落盘的会话（墓碑）。persist 写全量快照，但只删这些键，不按「后端有、内存无」清扫：
-     * 后端里还可能有本进程没读到的会话，按差集清扫会把它们当孤儿删掉。每条墓碑带令牌，提交成功后只清掉
+     * 本进程显式删除、尚未落盘的记录（墓碑），按表分开。persist 写全量快照，但只删这些键，不按「后端有、内存无」清扫：
+     * 后端里还可能有本进程没读到的记录，按差集清扫会把它们当孤儿删掉。每条墓碑带令牌，提交成功后只清掉
      * 提交时那一版，提交期间再删的保留到下一次。换后端时墓碑随旧表一起作废。
      */
-    deleted = new Map();
+    deleted = { [SESSIONS]: new Map(), [PLACES]: new Map() };
     /**
      * 会话表所在的 memory 实例：跟随 memory 胜者。换人时先把旧表的未落盘变更写回旧实例，再从新实例读表整体替换
      * （换后端即换库，不跨后端合并）。新表加载完成前仍指向旧实例，落盘不会把旧表写进新后端；加载窗口里的改动
@@ -159,10 +67,77 @@ class SessionManager {
     store;
     /** 最近一次挂接的加载；apply 等它完成再对外提供服务 */
     loading = Promise.resolve();
-    /** 平台 → 默认 SessionConfig 模板 */
-    platformProfiles = new Map();
-    /** 全局默认配置（platform profile 之下的最低层 fallback） */
-    defaults = {};
+    /** 插件登记的设置项：登记与撤回都发 session:config:changed */
+    settings = new SettingRegistry(() => void this.caps.events.use.emit('session:config:changed'));
+    /** 已告警过的设置问题：取值无效、文档形状不对。解析每轮都跑，同一处只告警一次 */
+    warned = new Set();
+    /**
+     * 在飞的回合：turnId → 所在会话与这一轮的结局（出错时带原因）。agent:input:before 进出登记与注销，结局由
+     * agent:turn:after 记下（消息被拦下的一轮不发它，没有结局）。同一会话按 lane 可以并行多轮（后台任务结束通知、白纸通知
+     * 与真人回合），会话在最后一轮结束时才收口；回合之外建档的会话按这里有没有回合定初始状态（见 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) {
         this.caps = caps;
     }
@@ -171,18 +146,20 @@ class SessionManager {
      * 会话表另经 {@link store} 跟随，见 {@link attach}。
      */
     get memory() {
-        const m = this.caps.memory.current;
-        if (!m)
+        if (!this.caps.memory.present)
             throw new Error('session-manager 需要 memory 服务');
-        return m;
+        return this.caps.memory.use;
     }
     /**
-     * memory 胜者的 follow 挂接：从这个实例读会话表并整体替换内存里的这份。
+     * memory 胜者的 follow 挂接：从这个实例读会话表与场所记录，整体替换内存里的这份。
      * 返回的清理在换人或关闭时执行：中止读表重试的等待，等本次加载落定，再把未落盘的变更写回这个实例。
      */
     attach(instance) {
         const detached = new AbortController();
-        this.loading = this.load(instance, AbortSignal.any([detached.signal, this.caps.lifecycle.signal]));
+        // 挂上的句柄只活到这次挂载的清理落定；之后的落盘（换人后的加载窗口、停机时的收尾）按条目 id 打到这一家
+        const id = this.caps.memory.list().find(p => p.selected)?.id;
+        const target = id === undefined ? instance : this.caps.memory.of(id);
+        this.loading = this.load(instance, target, AbortSignal.any([detached.signal, this.caps.lifecycle.use.signal]));
         return async () => {
             detached.abort();
             await this.loading;
@@ -190,52 +167,96 @@ class SessionManager {
                 clearTimeout(this.persistTimer);
                 this.persistTimer = null;
             }
-            await this.persist().catch(err => this.caps.logger.warn('换后端前落盘会话失败:', err));
+            // 这一家可能已经撤回：清理期间经挂上的句柄落盘
+            await this.persist(instance).catch(err => this.caps.logger.use.warn('换后端前落盘会话失败:', err));
         };
     }
     /**
-     * 从 memory 元数据加载持久化会话列表，加载完成后以它为会话表与落盘目标。读表失败按 {@link LOAD_RETRY_DELAYS}
-     * 有限重试，其间仍用原来的会话表与落盘目标；用尽或被中止（换人、停机）时会话表为空且不落盘。
+     * 从 memory 元数据加载会话表与场所记录，加载完成后以它们为准、以这个实例为落盘目标。读表失败按 {@link LOAD_RETRY_DELAYS}
+     * 有限重试，其间仍用原来的表与落盘目标；用尽或被中止（换人、停机）时两张表为空且不落盘。默认工作区的记录不在时补上
+     * （随下一次落盘写进后端）。
      */
-    async load(instance, signal) {
-        let sessions;
+    async load(instance, target, signal) {
+        let loaded;
         for (let attempt = 0;; attempt++) {
             try {
-                const entries = await instance.listMetadata(METADATA_NAMESPACE);
-                sessions = new Map();
-                for (const { key, data } of entries) {
-                    const info = data;
-                    if (info && info.id === key)
-                        sessions.set(key, info);
-                }
+                loaded = {
+                    sessions: await this.readTable(instance, SESSIONS, '会话记录', (key, data) => {
+                        const read = storedSession(key, data);
+                        return 'wrong' in read
+                            ? read
+                            : { record: { ...read.record, ...describeSession(read.record) }, dropped: read.dropped };
+                    }),
+                    places: await this.readTable(instance, PLACES, '场所记录', storedPlace),
+                };
                 break;
             }
             catch (err) {
                 const delay = LOAD_RETRY_DELAYS[attempt];
                 if (delay !== undefined && !signal.aborted) {
-                    this.caps.logger.warn(`加载会话数据失败，${delay}ms 后重试:`, err);
+                    this.caps.logger.use.warn(`加载会话数据失败，${delay}ms 后重试:`, err);
                     await wait(delay, signal);
                     if (!signal.aborted)
                         continue;
                 }
                 if (signal.aborted)
-                    this.caps.logger.info('已中止加载会话数据（停用、停机或换后端）');
+                    this.caps.logger.use.info('已中止加载会话数据（停用、停机或换后端）');
                 else
-                    this.caps.logger.error('加载会话数据失败，在这个后端上的会话改动不落盘（以免覆盖原有记录）:', err);
+                    this.caps.logger.use.error('加载会话数据失败，在这个后端上的会话改动不落盘（以免覆盖原有记录）:', err);
                 break;
             }
         }
-        // 加载窗口里旧表的改动：落盘目标此前仍是旧实例，换表前取快照，换表后写回
+        // 加载窗口里旧表的改动：落盘目标此前仍是旧的那一家，换表前取快照，换表后写回
         const previous = this.store;
         const pending = previous && this.dirty ? this.snapshot().ops : undefined;
-        this.sessions = sessions ?? new Map();
-        this.deleted.clear();
+        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.deleted = { [SESSIONS]: new Map(), [PLACES]: new Map() };
         this.dirty = false;
-        this.store = sessions ? instance : undefined;
-        if (sessions)
-            this.caps.logger.info(`已加载 ${sessions.size} 个会话`);
-        if (previous && pending)
-            await previous.commitMetadata(pending).catch(err => this.caps.logger.warn('换后端时写回旧后端失败:', err));
+        this.store = loaded ? target : undefined;
+        if (loaded)
+            this.caps.logger.use.info(`已加载 ${loaded.sessions.size} 个会话、${loaded.places.size} 个场所`);
+        if (previous && pending) {
+            try {
+                await previous.commitMetadata(pending);
+            }
+            catch (err) {
+                this.caps.logger.use.warn('换后端时写回旧后端失败:', err);
+            }
+        }
+    }
+    /**
+     * 读一张表：必填字段不对的记录不载入，移到 `<命名空间>-rejected`（先写副本再删原处：后端不保证整批原子时，停在半途也
+     * 不丢记录）；可选字段类型不对的去掉这些字段照常载入。两种都告警
+     */
+    async readTable(instance, namespace, label, parse) {
+        const rows = new Map();
+        const dropped = [];
+        const rejected = [];
+        for (const { key, data } of await instance.listMetadata(namespace)) {
+            const read = parse(key, data);
+            if ('wrong' in read) {
+                rejected.push({ key, data, field: read.wrong });
+                continue;
+            }
+            if (read.dropped.length > 0)
+                dropped.push(`${key}（${read.dropped.join('、')}）`);
+            rows.set(key, read.record);
+        }
+        const aside = `${namespace}${REJECTED_SUFFIX}`;
+        if (rejected.length > 0) {
+            await instance.commitMetadata(rejected.flatMap(({ key, data }) => [
+                { op: 'put', namespace: aside, key, data },
+                { op: 'del', namespace, key },
+            ]));
+            this.caps.logger.use.warn(`${label}的必填字段不对，没有载入，原记录已移到 metadata 命名空间 ${aside}：` +
+                rejected.map(({ key, field }) => `${key}（${field}）`).join('、'));
+        }
+        if (dropped.length > 0)
+            this.caps.logger.use.warn(`${label}有字段类型不对，去掉这些字段后照常载入：${dropped.join('、')}`);
+        return rows;
     }
     /** 标记需要持久化并延迟刷盘 */
     markDirty() {
@@ -243,7 +264,7 @@ class SessionManager {
         if (!this.persistTimer) {
             this.persistTimer = setTimeout(() => {
                 this.persistTimer = null;
-                this.persist().catch(err => this.caps.logger.warn('持久化会话失败:', err));
+                this.persist().catch(err => this.caps.logger.use.warn('持久化会话失败:', err));
             }, 1000);
         }
     }
@@ -258,50 +279,112 @@ class SessionManager {
      * 而是**幂等 + 可重试**：每次写的是全量快照（不是增量），删除只针对墓碑；失败时 dirty 复位、
      * 墓碑保留，下一次 markDirty 会把完整状态重写一遍，前一次的半成品被整体覆盖。
      */
-    async persist() {
-        const target = this.store;
-        if (!this.dirty || !target)
+    async persist(target = this.store) {
+        if (!this.dirty || !this.store || !target)
             return;
         this.dirty = false;
         const { ops, tombstones } = this.snapshot();
         try {
             // 写入目标取落盘开始时的会话表所在实例：换人窗口里当前胜者可能已是新后端，旧表不能写过去
             await target.commitMetadata(ops);
-            for (const [key, token] of tombstones)
-                if (this.deleted.get(key) === token)
-                    this.deleted.delete(key);
+            for (const [table, key, token] of tombstones) {
+                if (this.deleted[table].get(key) === token)
+                    this.deleted[table].delete(key);
+            }
         }
         catch (err) {
             this.dirty = true; // 失败要能重试，否则这批变更永远落不了盘
             throw err;
         }
     }
-    /** 会话表的全量快照：每个会话一条 put，墓碑各一条 del */
+    /** 两张表的全量快照：每条记录一条 put，墓碑各一条 del */
     snapshot() {
-        const ops = [...this.sessions].map(([id, info]) => ({
-            op: 'put',
-            namespace: METADATA_NAMESPACE,
-            key: id,
-            data: info,
-        }));
-        const tombstones = [...this.deleted];
-        for (const [key] of tombstones) {
-            if (!this.sessions.has(key))
-                ops.push({ op: 'del', namespace: METADATA_NAMESPACE, key });
+        const ops = [];
+        const tombstones = [];
+        for (const [namespace, rows] of [
+            [SESSIONS, this.sessions],
+            [PLACES, this.places],
+        ]) {
+            for (const [key, data] of rows) {
+                ops.push({ op: 'put', namespace, key, data: data });
+            }
+            for (const [key, token] of this.deleted[namespace]) {
+                tombstones.push([namespace, key, token]);
+                if (!rows.has(key))
+                    ops.push({ op: 'del', namespace, key });
+            }
         }
         return { ops, tombstones };
     }
     /**
-     * 按精确 id 幂等 upsert：命中走 updateSession（合并 config + emit `session:updated`），
-     * 未命中以传入 id 建 active 记录（emit `session:created`）。
-     * 平台派生 sessionId（onebot 等）首次落配置覆盖时用——那些 id 不经 createSession 预建。
+     * 按精确 id 幂等 upsert：命中走 updateSession（合并 config + emit `session:updated`），未命中以传入 id 建档。
+     * 创建来源在建档时写；命中按 id 兜底建档留下的空记录（没有创建来源、出生平台与绑定）时补写，随这次更新落盘。
+     * 终端配置的会话 id、/session.set 落配置覆盖时用
+     */
+    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) {
+            session.createdFrom = creation.createdFrom;
+        }
+        return this.updateSession(id, patch);
+    }
+    /**
+     * IM 房间收录：按原生入站记下的出生平台与聊天窗口建档，名字取出生平台给的群名或昵称（没有时为 id）。只给会话表里
+     * 还没有的 id 同步调用。场所是窗口的同时确保窗口的场所记录：insert 在第一次等待之前已同步占住 id、记下来源字段
      */
-    async ensureSession(id, patch = {}) {
-        if (this.sessions.has(id)) {
-            // updateSession 不接受 createdBy（建档专用），命中路径剥离后转发
-            const { createdBy: _ignore, ...updates } = patch;
-            return this.updateSession(id, updates);
+    async recordRoom(id, nativeName, origin) {
+        const [created] = await Promise.all([
+            this.insert(id, { name: nativeName || id, 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, describeSession(session));
+        await this.noteWindow(session.id, nativeName);
+        this.markDirty();
+        await this.caps.events.use.emit('session:updated', session);
+    }
+    /**
+     * 原生入站之后的窗口场所记录：会话的场所是窗口时，没有记录就建（显示名取出生平台给的名字，没有时为场所键），有记录而
+     * 名字变了就跟着改。场所是工作区的（owner 的 IM 私聊）不建。建了或改了名，给场所是这个窗口的根会话各发一次
+     * session:updated：会话的摘要在生成时取场所的显示名，不说话的群改了名也要刷新
+     */
+    async noteWindow(sessionId, nativeName) {
+        const place = this.placeOf(sessionId);
+        if (place.kind !== 'window')
+            return;
+        const record = this.places.get(place.key);
+        if (!record) {
+            this.places.set(place.key, newPlace(place, nativeName || place.key));
         }
+        else if (nativeName && record.name !== nativeName) {
+            record.name = nativeName;
+            record.updatedAt = Date.now();
+        }
+        else
+            return;
+        this.markDirty();
+        for (const session of [...this.sessions.values()]) {
+            if (!session.parentId && this.placeOf(session.id).key === place.key) {
+                await this.caps.events.use.emit('session:updated', session);
+            }
+        }
+    }
+    /**
+     * 以传入 id 建档（emit `session:created`），fields 是只在建档时写的字段。状态缺省按有没有回合在跑：有为 active
+     * （回合结束时收口），没有为 waiting（指令回复等回合之外的出站不改状态，建成 active 就会一直停在进行中）
+     */
+    async insert(id, patch, fields) {
+        const config = this.checkedConfig(patch.config);
         const now = Date.now();
         const session = {
             id,
@@ -310,25 +393,53 @@ class SessionManager {
             title: patch.metadata?.title,
             parentId: undefined,
             children: [],
-            status: patch.status || 'active',
-            config: patch.config || {},
+            status: patch.status || (this.hasTurnInFlight(id) ? 'active' : 'waiting'),
+            config,
             createdAt: now,
             updatedAt: now,
-            createdBy: patch.createdBy || 'user',
             inputContext: patch.metadata?.inputContext,
             metadata: patch.metadata,
+            ...fields,
+            ...describeSession(fields),
         };
         this.sessions.set(id, session);
         this.markDirty();
-        await this.caps.events.emit('session:created', session);
-        this.caps.logger.info(`会话建档(ensure): ${session.name} (${id})`);
+        await this.caps.events.use.emit('session:created', session);
+        this.caps.logger.use.info(`会话建档(ensure): ${session.name} (${id})`);
         return session;
     }
+    /**
+     * 有出生平台的房间还没记下接管它的适配器实例时，解析并记下，会话列表按它分组；已记下的不改，子任务与 owner 面
+     * 会话不记。收录与补记时实例随来源字段一起记下（收录之前已解析）；收录时没有适配器认领（适配器没装好、连接还没上来、
+     * 账号暂时不属于任何实例）的房间与读表读进来的旧房间，由之后的真人入站调它补记。解析期间会话被删除或换表的不再写回，
+     * 同一条记录的解析不并发。不会拒绝。
+     */
+    async recordOriginInstance(session) {
+        if (session.kind !== 'room' || session.originInstance || this.resolving.has(session))
+            return;
+        this.resolving.add(session);
+        try {
+            const entry = await resolvePlatformBySession(this.caps.platform, session.id, this.caps.logger.use);
+            if (!entry || this.sessions.get(session.id) !== session)
+                return;
+            session.originInstance = entry.id;
+            this.markDirty();
+            await this.caps.events.use.emit('session:updated', session);
+        }
+        finally {
+            this.resolving.delete(session);
+        }
+    }
     // ---- CRUD ----
-    async createSession(opts) {
+    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)}`;
+        const parent = opts?.parentId ? this.sessions.get(opts.parentId) : undefined;
         const now = Date.now();
         const session = {
             id,
@@ -338,27 +449,47 @@ class SessionManager {
             parentId: opts?.parentId,
             children: [],
             status: opts?.status || 'active',
-            config: opts?.config || {},
+            config,
             createdAt: now,
             updatedAt: now,
-            createdBy: opts?.createdBy || 'user',
             inputContext: opts?.inputContext ?? opts?.metadata?.inputContext,
             metadata: opts?.metadata,
+            ...created,
+            // 子会话的当前目录取父会话此刻的值，之后各改各的
+            ...(parent?.currentDir === undefined ? {} : { currentDir: parent.currentDir }),
+            ...describeSession({ parentId: opts?.parentId }),
         };
         this.sessions.set(id, session);
-        // 如果有父会话，更新父会话的 children
-        if (session.parentId) {
-            const parent = this.sessions.get(session.parentId);
-            if (parent) {
-                parent.children.push(id);
-                parent.updatedAt = now;
-            }
+        // 挂到父会话的 children 下：父会话的子会话列表变了，建档之后再给它发一次 session:updated
+        if (parent) {
+            parent.children.push(id);
+            parent.updatedAt = now;
         }
         this.markDirty();
-        await this.caps.events.emit('session:created', session);
-        this.caps.logger.info(`会话创建: ${session.name} (${id})`);
+        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})`);
         return session;
     }
+    /**
+     * 建档专用参数落成会话字段：工作区要有记录，项目工作区（有目录的）要带绑定，没有目录的不收绑定；默认工作区不记
+     * （缺省即默认工作区）。建档不写当前目录：没有值即场所的主目录
+     */
+    creationFields({ createdFrom, workspace = DEFAULT_WORKSPACE, work, }) {
+        const record = this.places.get(`${WORKSPACE_PREFIX}${workspace}`);
+        if (!record)
+            throw new Error(`工作区不存在：${workspace}`);
+        if (record.root !== undefined && !work)
+            throw new Error(`在项目工作区里建会话要带绑定目录：${workspace}`);
+        if (record.root === undefined && work)
+            throw new Error(`绑定目录只给项目工作区里的会话：${workspace}`);
+        return {
+            createdFrom,
+            ...(workspace === DEFAULT_WORKSPACE ? {} : { workspace }),
+            ...(work ? { work: { root: work.root, extraRoots: [], worktrees: [] } } : {}),
+        };
+    }
     getSession(id) {
         return this.sessions.get(id);
     }
@@ -383,19 +514,21 @@ 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 (updates.config !== undefined) {
-            // 合并配置而不是替换
-            session.config = { ...session.config, ...updates.config };
-        }
+        if (config)
+            session.config = applyPatch(session.config, config);
         session.updatedAt = Date.now();
         this.markDirty();
-        await this.caps.events.emit('session:updated', session);
+        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) {
@@ -406,20 +539,20 @@ class SessionManager {
         for (const childId of [...session.children]) {
             await this.deleteSession(childId);
         }
-        // 从父会话的 children 中移除
-        if (session.parentId) {
-            const parent = this.sessions.get(session.parentId);
-            if (parent) {
-                parent.children = parent.children.filter(c => c !== id);
-                parent.updatedAt = Date.now();
-            }
+        // 从父会话的 children 中移除：父会话的子会话列表变了，删除之后再给它发一次 session:updated
+        const parent = session.parentId ? this.sessions.get(session.parentId) : undefined;
+        if (parent) {
+            parent.children = parent.children.filter(c => c !== id);
+            parent.updatedAt = Date.now();
         }
         this.sessions.delete(id);
-        this.deleted.set(id, Symbol(id));
+        this.deleted[SESSIONS].set(id, Symbol(id));
         await this.clearDeletedSessionData(id);
         this.markDirty();
-        await this.caps.events.emit('session:deleted', id);
-        this.caps.logger.info(`会话删除: ${session.name} (${id})`);
+        await this.caps.events.use.emit('session:deleted', id);
+        if (parent)
+            await this.caps.events.use.emit('session:updated', parent);
+        this.caps.logger.use.info(`会话删除: ${session.name} (${id})`);
     }
     async clearDeletedSessionData(id) {
         const clearData = {
@@ -427,7 +560,7 @@ class SessionManager {
             sessionId: id,
             results: [],
         };
-        await this.caps.hooks.run('memory:clear', clearData, async () => {
+        await this.caps.hooks.use.run('memory:clear', clearData, async () => {
             try {
                 await this.memory.clearSession(id);
                 clearData.results.push({ source: 'memory', success: true, message: '会话消息历史已清空' });
@@ -439,40 +572,123 @@ class SessionManager {
         });
         const failed = clearData.results.filter(r => !r.success);
         if (failed.length > 0) {
-            this.caps.logger.warn(`会话数据清理存在失败项 [${id}]: ${failed.map(r => `${r.source}: ${r.message}`).join('; ')}`);
+            this.caps.logger.use.warn(`会话数据清理存在失败项 [${id}]: ${failed.map(r => `${r.source}: ${r.message}`).join('; ')}`);
         }
     }
     // ---- 树形操作 ----
     async createChildSession(parentId, opts) {
-        // 平台派生会话（cli-default、OneBot 会话 id）从不经 createSession 预建，父档缺失是常态；
-        // 先兜底建档再挂子会话，否则 create_subtask 在这些平台必败。
+        // 带 source 的注入回合（定时任务、编排）可能落在还没建档的会话上：先按 id 兜底建档再挂子会话，否则 create_subtask
+        // 在这些会话里必败。兜底建档的会话没有来源字段与创建来源，名字为 id：是房间的由之后的原生入站补记来源字段与名字
         if (!this.sessions.has(parentId))
-            await this.ensureSession(parentId);
-        return this.createSession({
-            ...opts,
-            parentId,
-            createdBy: opts?.createdBy || 'agent',
-        });
+            await this.ensureSession(parentId, { name: parentId });
+        return this.createSession({ ...opts, parentId });
     }
     getChildren(parentId) {
         return this.listSessions({ parentId });
     }
-    getTree(rootId) {
-        const buildNode = (session) => ({
-            session,
-            children: session.children
-                .map(cid => this.sessions.get(cid))
-                .filter((s) => !!s)
-                .map(buildNode),
-        });
-        if (rootId) {
-            const root = this.sessions.get(rootId);
-            if (!root)
-                return [];
-            return [buildNode(root)];
+    // ---- 当前目录与项目会话的绑定 ----
+    async setCurrentDir(sessionId, dir) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`会话不存在: ${sessionId}`);
+        session.currentDir = dir;
+        this.markDirty();
+        await this.caps.events.use.emit('session:updated', session);
+    }
+    async setExtraRoots(sessionId, extraRoots) {
+        const { root, work } = this.inWorkTree(sessionId);
+        work.extraRoots = [...extraRoots];
+        this.markDirty();
+        await this.caps.events.use.emit('session:updated', root);
+    }
+    async addWorktree(sessionId, path) {
+        const { root, work } = this.inWorkTree(sessionId);
+        if (work.worktrees.includes(path))
+            return;
+        work.worktrees.push(path);
+        this.markDirty();
+        await this.caps.events.use.emit('session:updated', root);
+    }
+    /** 项目会话树的根会话与它的绑定；会话不存在或不在项目会话树里时抛错 */
+    inWorkTree(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`会话不存在: ${sessionId}`);
+        const root = rootSessionOf(session, this.lookup);
+        if (!root?.work)
+            throw new Error(`会话 ${sessionId} 不在项目会话里：根会话没有绑定目录`);
+        return { root, work: root.work };
+    }
+    // ---- 场所与工作区 ----
+    placeOf(sessionId) {
+        const root = rootSessionOf(this.sessions.get(sessionId), this.lookup);
+        if (root?.originPlatform !== undefined) {
+            const chat = root.originChat;
+            const targetId = chat?.targetId ?? '';
+            // owner 的 IM 私聊是默认工作区的入口；没有 authority 时认不出 owner，按窗口算（与房间类别的失败关闭同向）
+            const owner = targetId !== '' &&
+                !chat?.multiParty &&
+                (this.caps.authority.present ? this.caps.authority.use.isOwner(root.originPlatform, targetId) : undefined);
+            if (owner)
+                return DEFAULT_PLACE;
+            const key = windowKey({ platform: root.originPlatform, type: chat?.type ?? '', targetId });
+            // 聊天窗口缺失或没有目标的坏数据同样是窗口：落进默认工作区会把 owner 给工作区设的值套到房间上
+            if (targetId === '')
+                this.warnOnce(`会话 ${root.id} 有出生平台却没有聊天窗口或目标，按窗口 ${key} 算`);
+            return { kind: 'window', key };
         }
-        // 返回所有根会话的树
-        return this.listSessions({ parentId: null }).map(buildNode);
+        if (root?.workspace === undefined)
+            return DEFAULT_PLACE;
+        const key = `${WORKSPACE_PREFIX}${root.workspace}`;
+        if (this.places.has(key))
+            return { kind: 'workspace', key };
+        this.warnOnce(`会话 ${root.id} 记下的工作区 ${root.workspace} 没有记录，按默认工作区`);
+        return DEFAULT_PLACE;
+    }
+    getPlace(key) {
+        const record = this.places.get(key);
+        return record && placeInfo(record);
+    }
+    addWorkspace(root) {
+        const existing = [...this.places.values()].find(record => record.root === root);
+        if (existing)
+            return { workspace: workspaceInfo(existing), existed: true };
+        const record = newPlace({ kind: 'workspace', key: `${WORKSPACE_PREFIX}${crypto.randomUUID()}` }, basename(root), root);
+        this.places.set(record.key, record);
+        this.markDirty();
+        this.caps.logger.use.info(`登记工作区: ${record.name} (${record.key}) ${root}`);
+        return { workspace: workspaceInfo(record), existed: false };
+    }
+    listWorkspaces() {
+        return [...this.places.values()]
+            .filter(record => record.kind === 'workspace')
+            .sort((a, b) => defaultFirst(a.key, b.key) || a.createdAt - b.createdAt)
+            .map(workspaceInfo);
+    }
+    async removeWorkspace(id) {
+        if (id === DEFAULT_WORKSPACE)
+            throw new Error('默认工作区不能取消登记');
+        const key = `${WORKSPACE_PREFIX}${id}`;
+        const record = this.places.get(key);
+        if (!record)
+            throw new Error(`工作区不存在：${id}`);
+        // 先认出原属的会话树（按根会话记下的工作区），再一并清：根会话的所属工作区与绑定，整棵树的当前目录
+        const affected = [...this.sessions.values()].filter(s => rootSessionOf(s, this.lookup)?.workspace === id);
+        const changed = affected.filter(s => !s.parentId || s.currentDir !== undefined);
+        for (const session of affected) {
+            delete session.currentDir;
+            if (!session.parentId) {
+                delete session.workspace;
+                delete session.work;
+            }
+        }
+        this.places.delete(key);
+        this.deleted[PLACES].set(key, Symbol(key));
+        this.markDirty();
+        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) {
@@ -484,8 +700,8 @@ class SessionManager {
         session.updatedAt = Date.now();
         this.markDirty();
         // 发事件通知（wait_subtasks 通过事件驱动感知完成）
-        await this.caps.events.emit('session:completed', session);
-        this.caps.logger.info(`会话完成: ${session.name} (${id})${result ? ` - ${result.slice(0, 100)}` : ''}`);
+        await this.caps.events.use.emit('session:completed', session);
+        this.caps.logger.use.info(`会话完成: ${session.name} (${id})${result ? ` - ${result.slice(0, 100)}` : ''}`);
     }
     // ---- 标题管理 ----
     async generateTitle(sessionId, userMessage) {
@@ -497,11 +713,11 @@ class SessionManager {
             return session.title;
         const entry = resolveLLMModel(this.caps.llm, undefined, ['chat']);
         if (!entry) {
-            this.caps.logger.warn(`无可用 LLM，无法生成标题: ${sessionId}`);
+            this.caps.logger.use.warn(`无可用 LLM，无法生成标题: ${sessionId}`);
             return undefined;
         }
-        this.caps.logger.debug(`标题生成使用 LLM: ${entry.contextId}`);
-        const model = entry.instance;
+        this.caps.logger.use.debug(`标题生成使用 LLM: ${entry.id}`);
+        const model = entry.use;
         // 优先使用直接传入的用户消息；否则从历史获取
         let contextStr;
         if (userMessage?.trim()) {
@@ -530,29 +746,28 @@ class SessionManager {
                     { role: 'user', content: `请为以下对话生成标题：\n\n${contextStr}` },
                 ],
                 temperature: 0.3,
-                // 关闭 thinking：标题生成无需推理，避免 reasoning 占满 token 预算导致 content 为空。
-                // DeepSeek 会映射为 thinking.type=disabled；其他不消费此字段的 provider 视为 no-op。
-                think: false,
+                // 标题生成无需推理，用模型最浅的思考档：避免 reasoning 占满 token 预算导致 content 为空
+                think: lightestThinking(model),
             });
             title = (resp.content || '').trim().slice(0, 50);
             if (!title) {
-                this.caps.logger.warn(`会话标题 LLM 返回空内容: ${sessionId} (resp.content=${JSON.stringify(resp.content)}, reasoning=${(resp.reasoningContent ?? '').length}字)`);
+                this.caps.logger.use.warn(`会话标题 LLM 返回空内容: ${sessionId} (resp.content=${JSON.stringify(resp.content)}, reasoning=${(resp.reasoningContent ?? '').length}字)`);
             }
         }
         catch (err) {
-            this.caps.logger.warn(`自动生成标题失败 [${sessionId}]:`, err);
+            this.caps.logger.use.warn(`自动生成标题失败 [${sessionId}]:`, err);
         }
         // 兜底：LLM 失败或返回空时，用用户消息首段作为临时标题，避免会话永远没有标题
         if (!title && userMessage?.trim()) {
             title = userMessage.trim().replace(/\s+/g, ' ').slice(0, 20);
-            this.caps.logger.info(`使用用户消息兜底生成标题: ${sessionId} -> ${title}`);
+            this.caps.logger.use.info(`使用用户消息兜底生成标题: ${sessionId} -> ${title}`);
         }
         if (title) {
             session.title = title;
             session.updatedAt = Date.now();
             this.markDirty();
-            await this.caps.events.emit('session:updated', session);
-            this.caps.logger.info(`会话标题已生成: [${sessionId}] ${title}`);
+            await this.caps.events.use.emit('session:updated', session);
+            this.caps.logger.use.info(`会话标题已生成: [${sessionId}] ${title}`);
             return title;
         }
         return undefined;
@@ -564,102 +779,370 @@ class SessionManager {
         session.title = title;
         session.updatedAt = Date.now();
         this.markDirty();
-        await this.caps.events.emit('session:updated', session);
+        await this.caps.events.use.emit('session:updated', session);
+    }
+    // ---- 会话设置 ----
+    registerSetting(setting, plugin) {
+        return this.settings.register(setting, plugin);
+    }
+    listSettings() {
+        return this.settings.list();
     }
-    // ---- 配置解析 ----
     /**
-     * 解析指定会话的最终生效配置
-     *
-     * 合并优先级（从高到低）：
-     * 1. 会话自身 config
-     * 2. 父会话的 sessionDefaults
-     * 3. 平台 profile
-     * 4. 全局 defaults（最低）
+     * 解析指定会话的最终生效配置：继承链之上叠会话自己的覆盖。由服务偏好承担的项在全局默认之上各层都没设时不给值：
+     * 取用方交给 resolveLLMModel，偏好指向的模型不在时也落得到服务此刻解析到的那一个
      */
     resolveConfig(sessionId, platform) {
-        // 2-4 层即「继承默认」
-        const result = this.resolveInheritedDefaults(sessionId, platform);
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return result;
-        // 1. 会话自身 config（最高优先级）
-        Object.assign(result, stripUndefined(session.config));
-        // 移除 sessionDefaults（不传递到消费方）
-        delete result.sessionDefaults;
-        return result;
+        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) };
     }
     /**
-     * 解析「继承默认」：不含 session 自身 config，只算 defaults + platform profile + 父 sessionDefaults。
-     *
-     * WebUI 「继承 (xxx)」提示应该用这个值，否则会显示用户自己的覆盖值。
+     * 继承链解析：不含会话自身 config，按层表的先后叠加，另记下每个键来自哪一层。子会话按根会话取：有出生平台的会话不论从
+     * 哪个入口驱动都按出生平台选平台档，按聊天窗口的类型名选平台类型档；传入的入口平台只对没有出生平台的会话起作用
      */
-    resolveInheritedDefaults(sessionId, platform) {
-        const result = {};
-        // 3. 全局 defaults（最低）
-        Object.assign(result, stripUndefined(this.defaults));
-        // 2. 平台 profile
-        if (platform) {
-            const profile = this.platformProfiles.get(platform);
-            if (profile)
-                Object.assign(result, stripUndefined(profile));
-        }
-        // 1. 父会话 sessionDefaults（最高，覆盖 profile/defaults）
+    resolveInheritance(sessionId, platform) {
         const session = this.sessions.get(sessionId);
-        if (session?.parentId) {
-            const parent = this.sessions.get(session.parentId);
-            if (parent?.config?.sessionDefaults) {
-                Object.assign(result, stripUndefined(parent.config.sessionDefaults));
+        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);
         }
-        delete result.sessionDefaults;
-        return result;
-    }
-    getDefaults() {
-        return { ...this.defaults };
-    }
-    /** 从配置加载全局 defaults */
-    loadDefaults(cfg) {
-        const next = {};
-        if (cfg.persona)
-            next.persona = cfg.persona;
-        this.defaults = next;
-        if (Object.keys(next).length > 0) {
-            this.caps.logger.info(`已加载全局 defaults: ${Object.keys(next).join(', ')}`);
-        }
-    }
-    getPlatformProfiles() {
-        const result = {};
-        for (const [platform, profile] of this.platformProfiles) {
-            result[platform] = { ...profile };
-        }
-        return result;
-    }
-    /** 从配置加载平台 profiles（唯一入口：平台档属插件配置，无运行时写接口——写了也不落盘） */
-    loadPlatformProfiles(profiles) {
-        for (const entry of profiles) {
-            const profile = {};
-            if (entry.persona)
-                profile.persona = entry.persona;
-            if (entry.llm && typeof entry.llm === 'object' && entry.llm.provider && entry.llm.model) {
-                profile.llm = { provider: String(entry.llm.provider), model: String(entry.llm.model) };
+        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;
             }
-            if (entry.enabledToolGroups !== undefined)
-                profile.enabledToolGroups = entry.enabledToolGroups;
-            if (entry.disableOutputFormat !== undefined)
-                profile.disableOutputFormat = entry.disableOutputFormat;
-            if (entry.clientSideJsonRendering !== undefined)
-                profile.clientSideJsonRendering = entry.clientSideJsonRendering;
-            // 空串表示继承 provider 全局配置。
-            if (entry.think === 'on')
-                profile.think = true;
-            else if (entry.think === 'off')
-                profile.think = false;
-            this.platformProfiles.set(entry.platform, profile);
-        }
-        if (this.platformProfiles.size > 0) {
-            this.caps.logger.info(`已加载 ${this.platformProfiles.size} 个平台配置模板: ${[...this.platformProfiles.keys()].join(', ')}`);
+            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))
+            return;
+        this.warned.add(message);
+        this.caps.logger.use.warn(message);
+    }
+    hasTurnInFlight(sessionId) {
+        for (const turn of this.turns.values())
+            if (turn.sessionId === sessionId)
+                return true;
+        return false;
+    }
+    /**
+     * 回合开始：登记这一轮；已有记录且不是 active 的翻 active。归档的不翻：归档是 owner 不想在列表里看到它，
+     * 她在那里跑一轮不该让它回到列表，只有手动恢复才回来
+     */
+    beginTurn(id, turnId) {
+        this.turns.set(turnId, { sessionId: id });
+        const session = this.sessions.get(id);
+        if (session && session.status !== 'active' && session.status !== 'archived') {
+            this.updateSession(id, { status: 'active' }).catch(() => { });
         }
     }
+    /** 记下这一轮的结局与出错原因（只有结局为 error 时留原因），回合结束时用 */
+    recordOutcome(turnId, outcome, error) {
+        const turn = this.turns.get(turnId);
+        if (!turn)
+            return;
+        turn.outcome = outcome;
+        // 一句原因：agent 给的可能带上游的整段响应，会随会话落盘、进子任务提醒；空串当作没给
+        turn.error = outcome === 'error' && error ? truncateChars(error, ERROR_MAX, '…') : undefined;
+    }
+    /**
+     * 回合结束：注销这一轮，记下 lastTurn（被拦下、没有结局的一轮记为 silent），结局为 replied 的另记下她开口的时间。
+     * 会话里的最后一轮结束时，仍为 active 的会话（根会话与子会话一样）按这一轮的结局收口：出错为 error，其余为 completed
+     */
+    endTurn(turnId) {
+        const turn = this.turns.get(turnId);
+        if (!turn)
+            return;
+        this.turns.delete(turnId);
+        const session = this.sessions.get(turn.sessionId);
+        if (!session)
+            return;
+        const { outcome = 'silent', error } = turn;
+        const endedAt = Date.now();
+        session.lastTurn = error === undefined ? { outcome, endedAt } : { outcome, endedAt, error };
+        if (outcome === 'replied')
+            session.lastReplyAt = endedAt;
+        const settle = session.status === 'active' && !this.hasTurnInFlight(session.id);
+        const status = outcome === 'error' ? 'error' : 'completed';
+        this.updateSession(session.id, settle ? { status } : {}).catch(() => { });
+    }
+    /** 按会话累加一次模型调用的 token：只记已有的会话，不改 updatedAt；记了就发 session:updated */
+    recordUsage({ sessionId, inputTokens, outputTokens }) {
+        const session = sessionId === undefined ? undefined : this.sessions.get(sessionId);
+        if (!session)
+            return;
+        const { input, output } = session.tokens ?? { input: 0, output: 0 };
+        session.tokens = { input: input + inputTokens, output: output + outputTokens };
+        this.markDirty();
+        void this.caps.events.use.emit('session:updated', session);
+    }
     /**
      * 关停收尾：仍 `active` 的会话立即收口并落盘。
      *
@@ -667,7 +1150,7 @@ class SessionManager {
      * 关停打断在飞回合与那条路径同义，沿用同一状态，不新造值。
      * waiting / completed / error / archived 不是在飞，原样保留。
      *
-     * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与 `agent:turn:after` 收口；
+     * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与回合结束时的收口（{@link endTurn}）处理；
      * 此处兜的是未装 agent 或钩子未挂上的路径。
      * persist 也在这里立刻刷，不走 1s debounce——onDispose 的 shutdown 仍会再刷一次。
      */
@@ -700,322 +1183,303 @@ class SessionManager {
 }
 // ===== 工具函数 =====
 /**
- * 移除值为 undefined / null 的键。
- *
- * null 必须一起剥：清除会话覆盖（`/model 复位`）写入的是 undefined，
- * 而它经 BSON 持久化后读回来是 **null**。不剥的话这个 null 会在 Object.assign 里
- * 把平台 profile 的同名字段盖成空——agent 侧判 `llm?.provider && llm?.model` 不成立、
- * 退回 `resolveLLMModel(undefined)`，静默落到首个注册的 entry。表现就是
- * 「配置里写着 A，实际跑的是 B」，且没有任何告警。persona 同理。
- * 本模型里「没有值」一律等于「继承上层」，null 与 undefined 同义。
+ * 会话的种类，只由父会话与出生平台推出。新建、建档、补记与加载入表时覆盖写入，调用方传的值与存储里的旧值都不采信
  */
-function stripUndefined(obj) {
-    if (!obj)
-        return {};
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (value !== undefined && value !== null)
-            result[key] = value;
-    }
-    return result;
+function describeSession(session) {
+    return { kind: sessionKind(session) };
 }
+/** 新建的场所记录：设置为空 */
+function newPlace(place, name, root) {
+    const now = Date.now();
+    return { ...place, name, ...(root === undefined ? {} : { root }), config: {}, createdAt: now, updatedAt: now };
+}
+function placeInfo({ kind, key, name }) {
+    return { kind, key, name };
+}
+function workspaceInfo({ key, name, root }) {
+    return { id: key.slice(WORKSPACE_PREFIX.length), name, ...(root === undefined ? {} : { root }) };
+}
+/** 排序时默认工作区在前，其余不动 */
+function defaultFirst(a, b) {
+    return Number(b === DEFAULT_PLACE.key) - Number(a === DEFAULT_PLACE.key);
+}
+const SESSION_STATUSES = new Set([
+    'active',
+    'waiting',
+    'completed',
+    'error',
+    'archived',
+]);
+const TURN_OUTCOMES = new Set([
+    'replied',
+    'silent',
+    'aborted',
+    'error',
+]);
+const isText = (value) => typeof value === 'string';
+const isTextList = (value) => Array.isArray(value) && value.every(isText);
+const isTime = (value) => typeof value === 'number' && Number.isFinite(value);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 /**
- * 页面动作全是 apply 里的闭包：直接用这次激活的 manager 与能力，
- * 登记随激活存亡（插件不在，WebUI 就调不到这些方法）。
+ * 会话记录里会进会话列表与协议、类型不对会让读者出错的可选字段，各自的类型。种类载入时重算，不在这里
  */
-function registerSessionActions(caps, manager) {
-    const { webui, memory, persona, llm, tools, platform } = caps;
-    webui.registerAction('listSessions', async () => manager.listSessions().map(s => ({
-        ...s,
-        displayTitle: s.title || s.name,
-        configSummary: formatConfigSummary(s.config),
-        childCount: s.children.length,
-    })));
-    webui.registerAction('createSession', async (args) => {
-        const parentId = args.parentId || undefined;
-        // 新建会话时复制当前生效配置，而非留空继承
-        let config = args.config || {};
-        if (Object.keys(config).length === 0) {
-            if (parentId) {
-                // 子会话：复制父会话的 resolved config
-                config = { ...manager.resolveConfig(parentId, 'webui') };
-            }
-            else {
-                // 根会话：复制 webui 平台 profile 作为初始配置
-                const profiles = manager.getPlatformProfiles();
-                if (profiles.webui)
-                    config = { ...profiles.webui };
-            }
-        }
-        return manager.createSession({
-            name: args.name ||
-                `会话 ${new Date().toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })}`,
-            parentId,
-            config,
-            createdBy: 'user',
-            // 新建的空会话尚未发生任何对话，初始为 'waiting'（等待中）而非 'active'（进行中）。
-            // 否则侧栏新建的会话会一直显示"进行中"——直到首条消息触发 inbound→active→turn:after→completed。
-            status: 'waiting',
-        });
-    });
-    webui.registerAction('deleteSession', async (args) => {
-        const id = args.id;
-        if (!id)
-            throw new Error('缺少会话 ID');
-        await manager.deleteSession(id);
-        return { success: true };
-    });
-    webui.registerAction('updateSessionConfig', async (args) => {
-        const id = args.id;
-        if (!id)
-            throw new Error('缺少会话 ID');
-        return manager.updateSession(id, { config: normalizeSessionConfigPatch(args.config) });
-    });
-    webui.registerAction('getSessionHistory', async (args) => {
-        const store = memory.current;
-        if (!store)
-            throw new Error('memory 服务不可用');
-        const sessionId = args.sessionId;
-        if (!sessionId)
-            throw new Error('缺少 sessionId');
-        const limit = args.limit || 100;
-        const history = await store.getHistory(sessionId, limit);
-        return { sessionId, messages: history };
-    });
-    /** 批量归档会话 */
-    webui.registerAction('batchArchive', async (args) => {
-        const ids = args.ids;
-        if (!Array.isArray(ids) || ids.length === 0)
-            throw new Error('缺少会话 ID 列表');
-        let count = 0;
-        for (const id of ids) {
-            try {
-                await manager.updateSession(id, { status: 'archived' });
-                count++;
-            }
-            catch {
-                /* skip */
-            }
-        }
-        return { success: true, count };
-    });
-    /** 批量删除会话 */
-    webui.registerAction('batchDelete', async (args) => {
-        const ids = args.ids;
-        if (!Array.isArray(ids) || ids.length === 0)
-            throw new Error('缺少会话 ID 列表');
-        let count = 0;
-        for (const id of ids) {
-            try {
-                await manager.deleteSession(id);
-                count++;
-            }
-            catch {
-                /* skip */
-            }
-        }
-        return { success: true, count };
-    });
-    webui.registerAction('getSessionTree', async () => manager.getTree());
-    /** 获取可选项列表（供前端下拉框使用） */
-    webui.registerAction('getConfigOptions', async () => {
-        // 可用人设列表
-        const personaService = persona.current;
-        const personas = personaService?.listModels ? await personaService.listModels() : [];
-        // 可用 LLM 模型列表（枚举所有 chat-capable entry）
-        const models = listLLMModels(llm, { caps: ['chat'] }).map(e => ({
-            id: e.instance.id,
-            capabilities: [...e.instance.capabilities],
-            provider: e.instance.providerId,
-            contextId: e.contextId,
-        }));
-        // 工具分组列表
-        const toolGroups = tools.current?.getGroups().map(g => ({ name: g.name, label: g.label })) ?? [];
-        // 已注册平台列表
-        const platforms = getPlatformNames(platform);
-        return { personas, models, toolGroups, platforms, profiles: manager.getPlatformProfiles() };
-    });
-    /** 获取指定会话的最终生效配置（合并所有层级后的结果） */
-    webui.registerAction('getResolvedConfig', async (args) => {
-        const sessionId = args.sessionId;
-        if (!sessionId)
-            throw new Error('缺少 sessionId');
-        return manager.resolveConfig(sessionId, args.platform);
-    });
-    /**
-     * 获取「继承默认」——不含 session 自身 config，只算 platform profile + 父 sessionDefaults。
-     * WebUI 「继承 (xxx)」提示用这个，避免显示用户自己的覆盖值。
-     */
-    webui.registerAction('getInheritedDefaults', async (args) => {
-        const sessionId = args.sessionId;
-        if (!sessionId)
-            throw new Error('缺少 sessionId');
-        return manager.resolveInheritedDefaults(sessionId, args.platform);
-    });
-    /** 获取会话详情（含完整消息历史，包括已归档消息） */
-    webui.registerAction('getSessionDetail', async (args) => {
-        const store = memory.current;
-        if (!store)
-            throw new Error('memory 服务不可用');
-        const id = args.id;
-        if (!id)
-            throw new Error('缺少会话 ID');
-        const session = manager.getSession(id);
-        if (!session)
-            throw new Error(`会话不存在: ${id}`);
-        const limit = args.limit || 200;
-        // 优先使用 getFullHistory（含已归档消息），确保 UI 能看到完整对话
-        const messages = store.getFullHistory ? await store.getFullHistory(id, limit) : await store.getHistory(id, limit);
-        return { session, messages };
-    });
-    /** 手动重命名会话标题 */
-    webui.registerAction('renameSession', async (args) => {
-        const id = args.id;
-        const title = args.title;
-        if (!id || !title)
-            throw new Error('缺少 id 或 title');
-        await manager.updateSessionTitle(id, title);
-        return { success: true };
-    });
-    /** 归档子会话（父已不再需要） */
-    webui.registerAction('archiveSession', async (args) => {
-        const id = args.id;
-        if (!id)
-            throw new Error('缺少会话 ID');
-        await archiveRecursively(manager, id);
-        return { success: true };
-    });
+const OPTIONAL_FIELDS = {
+    title: isText,
+    parentId: isText,
+    createdFrom: isText,
+    originPlatform: isText,
+    originChat: value => isRecord(value) &&
+        isText(value.type) &&
+        typeof value.multiParty === 'boolean' &&
+        isText(value.targetId) &&
+        (value.selfId === undefined || isText(value.selfId)),
+    workspace: isText,
+    work: value => isRecord(value) && isText(value.root) && isTextList(value.extraRoots) && isTextList(value.worktrees),
+    currentDir: isText,
+    originInstance: isText,
+    lastReplyAt: isTime,
+    lastTurn: value => isRecord(value) &&
+        TURN_OUTCOMES.has(value.outcome) &&
+        isTime(value.endedAt) &&
+        (value.error === undefined || isText(value.error)),
+    tokens: value => isRecord(value) && isTime(value.input) && isTime(value.output),
+};
+/**
+ * 读回的会话记录：存储把没有的可选字段存成 null 的（MongoDB 就是这样）去掉这个键。字段不对的（旧数据、手改或别的插件写坏的）：
+ * 可选字段去掉，记在 dropped 里；必填字段不对时回这个字段名，整条不载入
+ */
+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),
+    };
+    const wrong = Object.keys(required).find(field => !required[field]);
+    if (wrong)
+        return { wrong };
+    const dropped = Object.entries(OPTIONAL_FIELDS)
+        .filter(([field, valid]) => record[field] !== undefined && !valid(record[field]))
+        .map(([field]) => field);
+    for (const field of dropped)
+        delete record[field];
+    return { record: record, dropped };
+}
+/**
+ * 读回的场所记录：必填字段不对（含类别与键对不上：工作区的键以 `workspace:` 开头，窗口的不是）时回这个字段名，整条不载入；
+ * 目录的类型不对时去掉它
+ */
+function storedPlace(key, data) {
+    const record = Object.fromEntries(Object.entries(data).filter(([, value]) => value !== null));
+    const required = {
+        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;
+    return { record: record, dropped };
 }
 // ===== 插件入口 =====
 const uses = {
     /** 会话档案与消息历史的唯一落点：没有 memory 就没有会话管理 */
     memory,
     /**
-     * 本插件不调用 agent 的方法；声明它是为了 agent:* 钩子的键类型。
-     * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与 `agent:turn:after` 收口；
+     * 本插件不调用 agent 的方法；声明它是为了 agent:* 钩子的键类型，并据它认出真正调模型的那个插件（默认模型按它的选择写）。
+     * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与回合结束时的收口处理；
      * 此处 onDrain 兜的是未装 agent 或钩子未挂上的路径。
      */
     agent: optional(agent),
-    /** 自动标题的模型来源；没有 LLM 时退回用户消息首段 */
+    /** 自动标题的模型来源（没有 LLM 时退回用户消息首段）；全局默认层的「模型」按偏好指向的条目写出提供者与模型 */
     llm: optional(llm),
-    /** 下列三项只供 WebUI 下拉框枚举选项，缺席即空列表 */
-    persona: optional(persona),
+    /** 房间建档时取平台的类型声明记下聊天窗口；解析接管房间的适配器实例（originInstance）；可设的平台与类型 */
     platform: optional(platform),
-    tools: optional(tools),
-    /** 页面与页面动作的登记口；无 WebUI 时会话管理照常在后台运行 */
-    webui: optional(webuiServer),
+    /**
+     * 会话设置的全局默认、平台档与平台类型档存放在宿主配置文档的 sessionConfig 字段里。由宿主在根上提供、没有插件
+     * provide 它，写进激活闸只会挂一条解析不到提供者的告警；缺席时这三层为空、按层写被拒
+     */
+    hostConfig: optional(hostConfig),
+    /**
+     * owner 的 IM 私聊在默认工作区：placeOf 按它认对端是不是 owner，与房间类别同一判据。plugin-authority 也以 optional
+     * 用会话管理，两边成可选环；缺席时认不出 owner，一对一窗口按窗口算
+     */
+    authority: optional(authority),
+    /** 全局默认层的「模型」读写 llm 服务的偏好 */
+    services,
     events,
     hooks,
     lifecycle,
     logger,
-    config,
     provide,
 };
 export default definePlugin({
     name: '@aalis/plugin-session-manager',
     displayName: '会话管理',
     subsystem: 'session',
-    configSchema,
     provides: [sessionManager],
     uses,
     apply: run,
 });
 async function run(caps) {
-    const cfg = parseConfig(configSchema, caps.config, caps.logger);
-    const { memory, webui, events, hooks, lifecycle, logger, provide } = caps;
-    // 注册 WebUI 页面
-    for (const page of webuiPages)
-        webui.registerPage(page);
-    if (memory.current === undefined) {
-        logger.error('memory 服务不可用，会话管理无法启动');
-        return;
-    }
+    const { memory, events, hooks, lifecycle, logger, provide } = caps;
     const manager = new SessionManager(caps);
     // 会话表跟随 memory 胜者：首次挂接即加载；运行中胜者换人时先写回旧后端再读新后端
     memory.follow(instance => manager.attach(instance));
     await manager.loading;
     // 读表（含重试等待）期间停用或停机的，不再发布服务与登记
-    lifecycle.signal.throwIfAborted();
-    // 加载平台 profiles
-    manager.loadPlatformProfiles(cfg.platformProfiles);
-    // 加载全局 defaults
-    manager.loadDefaults(cfg.defaults);
+    lifecycle.use.signal.throwIfAborted();
     // 注册服务
-    provide(sessionManager, manager, { label: '会话管理' });
-    registerSessionActions(caps, manager);
-    // ===== 会话状态自治管理 =====
-    // 监听消息事件，自动维护会话状态（从 Agent 职责中迁出）
-    events.on('inbound:message', (msg) => {
-        if (!msg.sessionId)
+    provide.use(sessionManager, manager, { label: '会话管理' });
+    // ===== 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;
-        const session = manager.getSession(msg.sessionId);
-        if (session && session.status !== 'active') {
-            manager.updateSession(msg.sessionId, { status: 'active' }).catch(() => { });
+        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);
         }
-    });
-    events.on('outbound:message', (msg) => {
-        if (!msg.sessionId)
+        void manager.recordOriginInstance(session);
+    };
+    events.use.on('inbound:message', async (msg) => {
+        const { sessionId } = msg;
+        if (!sessionId || msg.source || sessionId.includes('::'))
             return;
-        const session = manager.getSession(msg.sessionId);
-        // 子会话（有 parentId）由 plugin-subtask 的 agent:turn:after 中间件负责完成并提取 result
-        if (session && session.status === 'active' && !session.parentId) {
-            manager.updateSession(msg.sessionId, { status: 'completed' }).catch(() => { });
-        }
-    });
-    // 回合终态收口：agent 在 replied/silent/aborted/error 四条路径都会发 agent:turn:after。
-    // 上面的 outbound:message 只覆盖"产生了回复"的情形——用户中途停止生成（aborted）或
-    // 空回复（silent）时不发 outbound:message，会话会永远停在 'active'（即"进行中"）。
-    // 这里订阅生命周期钩子作幂等互补，确保任何回合结束都把根会话收口为 'completed'。
-    hooks.middleware('agent:turn:after', async (data, next) => {
-        await next();
-        if (!data.sessionId)
+        const known = manager.getSession(sessionId);
+        if (recorded(known, msg)) {
+            noteRecorded(known, msg);
             return;
-        const session = manager.getSession(data.sessionId);
-        // 子会话由 plugin-subtask 负责完成并回传 result，这里只收口根会话。
-        if (session && session.status === 'active' && !session.parentId) {
-            manager.updateSession(data.sessionId, { status: 'completed' }).catch(() => { });
         }
-    });
-    // 监听用户消息事件 → 自动生成会话标题
-    // 在用户首次发消息时即生成标题，无需等待 AI 回复
-    // 仅对 webui / cli 等用户交互平台生效，onebot 等外部平台不生成标题
-    const TITLE_PLATFORMS = new Set(['webui', 'cli']);
-    const titleGenerating = new Set();
-    events.on('inbound:message', (msg) => {
-        const { sessionId, platform } = msg;
-        if (!sessionId) {
-            logger.debug('标题生成跳过: 缺少 sessionId');
+        const claimants = await claimantsOf(caps.platform, sessionId, logger.use);
+        const session = manager.getSession(sessionId);
+        if (recorded(session, msg)) {
+            noteRecorded(session, msg);
             return;
         }
-        if (titleGenerating.has(sessionId))
+        const platforms = [...new Set(claimants.map(({ use: instance }) => instance.platform))];
+        if (platforms.length > 1) {
+            warnOnce(`claim:${sessionId}`, `会话 ${sessionId} 同时由平台「${platforms.join('」「')}」认领：判不出它是哪个平台的聊天窗口，不收录。` +
+                '改配置，一个会话 id 只归一个平台');
             return;
-        // 仅对指定平台生成标题；非 webui/cli 平台（如 onebot）静默跳过，避免日志污染。
-        // platform 缺省同样跳过：白名单是正向门，来路不明的消息不该顺带建档 + 烧一次 LLM 生成标题。
-        if (!platform || !TITLE_PLATFORMS.has(platform))
+        }
+        // 补记只认这个 id 归消息平台的适配器管的入站：WebUI 与终端往房间插话不算
+        if (session && platforms[0] !== msg.platform)
             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 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，归档的不翻：群里只有消息、她没开口的房间不显示「进行中」
+    //（触发判定在入站相位，挡下的消息到不了这里）。同一个中间件在 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);
+        try {
+            await next();
+        }
+        finally {
+            manager.endTurn(data.turnId);
+        }
+    });
+    hooks.use.middleware('agent:turn:after', async (data, next) => {
+        manager.recordOutcome(data.turnId, data.outcome, data.error);
+        await next();
+    });
+    // 模型调用的 token 按会话累加：对话、摘要、识图、转写的调用都带会话 id
+    events.use.on('llm:usage', usage => manager.recordUsage(usage));
+    // 自动标题：只给带创建来源的根会话（WebUI 新建的、终端建的）生成，在首条消息时生成、不等回复；IM 房间不生成，
+    // owner 从 WebUI 往房间插话也不拿来给房间起名。异步生成，不阻塞消息处理；直接传入这条消息，不依赖历史
+    const titleGenerating = new Set();
+    events.use.on('inbound:message', (msg) => {
+        const { sessionId } = msg;
         const session = manager.getSession(sessionId);
-        // 已有标题或子任务会话跳过（静默）
-        if (session && (session.title || session.parentId))
+        if (!session?.createdFrom || session.title || titleGenerating.has(sessionId))
             return;
         titleGenerating.add(sessionId);
-        logger.info(`开始生成会话标题: ${sessionId} (platform=${platform})`);
-        // 平台派生会话（cli-default 等）从不经 createSession 预建，缺档是常态：先兜底建档再生成
-        // 标题（与 createChildSession 同路），否则这些平台永远没有标题、且每条消息告警一次。
-        // 异步生成，不阻塞消息处理；直接传入用户消息避免依赖历史
-        (session ? Promise.resolve() : manager.ensureSession(sessionId).then(() => undefined))
-            .then(() => manager.generateTitle(sessionId, msg.content))
-            .catch(err => logger.warn('标题生成失败:', err))
+        logger.use.info(`开始生成会话标题: ${sessionId}`);
+        manager
+            .generateTitle(sessionId, msg.content)
+            .catch(err => logger.use.warn('标题生成失败:', err))
             .finally(() => titleGenerating.delete(sessionId));
     });
     // 关停收尾：仍 active 的会话在 onDrain 收口并落盘。
-    // 第一方栈由 core 关停编排（optional 环成员先全部 drain）与 agent:turn:after 收口；
+    // 第一方栈由 core 关停编排（optional 环成员先全部 drain）与回合结束时的收口处理；
     // 此处兜的是未装 agent 或钩子未挂上的路径。
     // 持久化仍走 onDispose：覆盖 bounce / unload / updateConfig 等全部拆卸路径
     // （只在全局停机触发的话，热重载即丢会话元数据）。
     // 异步收尾由编排层的 disposeAsync 等待完成；app.stop() 的拓扑逆序保证此时 memory 提供者
     // 尚未关闭，单独热重载/禁用 memory 提供者时无此保证。shutdown() 幂等：清 timer + 置 dirty + 落盘。
-    lifecycle.onDrain(() => manager.settleActiveOnDrain(), '收口在飞会话');
-    lifecycle.onDispose(() => manager.shutdown());
-    logger.info('会话管理服务已启用');
+    lifecycle.use.onDrain(() => manager.settleActiveOnDrain(), '收口在飞会话');
+    lifecycle.use.onDispose(() => manager.shutdown());
+    logger.use.info('会话管理服务已启用');
 }
 //# sourceMappingURL=index.js.map