npm - @aalis/plugin-session-manager - Versions diffs - 0.14.0 → 0.16.0 - Mend

@aalis/plugin-session-manager 0.14.0 → 0.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/index.js CHANGED Viewed

@@ -1,123 +1,79 @@
+import { basename } from 'node:path';
 import { agent } from '@aalis/api-agent';
+import { authority } from '@aalis/api-authority';
+import { chatScopeOf, windowKey } from '@aalis/api-gateway';
 import { hooks } from '@aalis/api-hooks';
-import { listLLMModels, 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 { ownHostConfig } from '@aalis/api-host-config';
+import { i18n, outputLanguageFor } from '@aalis/api-i18n';
+import { lightestThinking, llm, resolveLLMModel } from '@aalis/api-llm';
+import { historyCleared, memory } from '@aalis/api-memory';
+import { claimantsOf, getPlatformAdapters, platform, resolvePlatformBySession, sessionTypesOf, } from '@aalis/api-platform';
+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, parseConfig } from '@aalis/schema-config';
+import { defineConfig } from '@aalis/schema-config';
+import { asText, toSource, truncateParams, withText } from '@aalis/schema-i18n';
+import { truncateChars } from '@aalis/util-text-normalize';
+import { t } from './texts.js';
+// ===== 配置 =====
+// 取别的会话的东西（canTake）的范围与三个开关：都是按会话字段，按取的一方所在的会话生效。坏值原样交来，范围按本会话、开关按否
 const configSchema = defineConfig({
-    defaults: {
-        label: '全局默认配置',
-        description: '所有平台共享的最低层默认配置（platform profile 之下的 fallback）。LLM 默认模型由各 agent 插件通过 ServicePreference 锁定，不再在此配置；本节仅保留 persona 等通用默认。',
-        fields: {
-            persona: {
-                type: 'select',
-                label: '默认人设',
-                dynamicOptions: 'persona',
-                allowCustom: true,
-                description: '所有平台未单独指定时使用的默认人设',
-            },
-        },
+    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' },
     },
-    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 进一步覆盖。',
-            },
-        },
+    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 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 +86,20 @@ 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(', ') || '(默认)';
-}
 class SessionManager {
+    take;
     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,11 +108,29 @@ class SessionManager {
     store;
     /** 最近一次挂接的加载；apply 等它完成再对外提供服务 */
     loading = Promise.resolve();
-    /** 平台 → 默认 SessionConfig 模板 */
-    platformProfiles = new Map();
-    /** 全局默认配置（platform profile 之下的最低层 fallback） */
-    defaults = {};
-    constructor(caps) {
+    /** 已告警过的问题（坏数据、收录判不出的认领）：同一处只告警一次 */
+    warned = new Set();
+    /** 正在收录或补记的会话：同一会话并发的原生入站共用这一次 */
+    recording = new Map();
+    /** 正在删除的会话（从摘掉、删子会话之前起，到清完数据），删除做完时兑现：这期间到的同一会话的入站等它（见 recordInbound） */
+    removing = new Map();
+    /**
+     * 各会话的代号（generationOf）：开始删除的次数，在 remove 里加一，没删过的为 0。只记删过的 id，一直留着（之后同一 id 再建档
+     * 也不换回去，半路上删除之前的一代才认得出来），每个删过的 id 占一项；随这次激活，会话管理重新激活时清空
+     */
+    generations = new Map();
+    /**
+     * 在飞的回合：turnId → 所在会话与这一轮的结局（出错时带原因）。agent:turn:before 进出登记与注销，结局由
+     * agent:turn:after 记下（被拦下的一轮不发它，没有结局）。第一方 agent 同一会话一轮接一轮，契约不限别的实现在同一会话并行几轮，
+     * 所以按回合 id 记、会话在最后一轮结束时才收口；回合之外建档的会话按这里有没有回合定初始状态（见 ensureSession）
+     */
+    turns = new Map();
+    /** 正在解析所属实例的会话记录：同一条记录不并发解析，后到的调用不等它、直接返回 */
+    resolving = new WeakSet();
+    lookup = (id) => this.sessions.get(id);
+    /** take 读取的一方所在会话此刻的取别的会话的范围与三个开关（生效值，坏值原样） */
+    constructor(caps, take) {
+        this.take = take;
         this.caps = caps;
     }
     /**
@@ -171,18 +138,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 +159,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 +256,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,107 +271,363 @@ 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（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 && isUnfiled(session))
+            session.createdFrom = creation.createdFrom;
+        return this.updateSession(id, patch);
+    }
+    /**
+     * IM 房间收录：按原生入站记下的出生平台与聊天窗口建档，名字取出生平台给的群名或昵称（没有时不取名）。只给会话表里
+     * 还没有的 id 同步调用。场所是窗口的同时确保窗口的场所记录：insert 在第一次等待之前已同步占住 id、记下来源字段
+     */
+    async recordRoom(id, nativeName, origin) {
+        const [created] = await Promise.all([
+            this.insert(id, { name: nativeName, status: 'waiting' }, origin),
+            this.noteWindow(id, nativeName),
+        ]);
+        return created;
+    }
+    /**
+     * IM 房间收录的补记：按 id 兜底建档的根会话（没有来源字段、创建来源与绑定）与升级前只记了出生平台的记录（没有聊天窗口，
+     * 出生平台与消息平台相同）收到原生入站时，记下与按这条消息建档时一样的来源字段，还没有名字的一并补上，场所是窗口的
+     * 确保窗口的场所记录。只给表里这条记录同步调用，由收录监听判定这个 id 归消息平台的适配器管
      */
-    async ensureSession(id, patch = {}) {
-        if (this.sessions.has(id)) {
-            // updateSession 不接受 createdBy（建档专用），命中路径剥离后转发
-            const { createdBy: _ignore, ...updates } = patch;
-            return this.updateSession(id, updates);
+    async backfillRoom(session, nativeName, origin) {
+        Object.assign(session, origin, session.name === undefined && 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 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 || 'active',
-            config: patch.config || {},
+            status: patch.status || (this.hasTurnInFlight(id) ? 'active' : 'waiting'),
             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): ${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 面
+     * 会话不记。收录与补记时实例随来源字段一起记下（收录之前已解析）；收录时没有适配器认领（适配器没装好、连接还没上来、
+     * 账号暂时不属于任何实例）的房间与读表读进来的旧房间，由之后的真人入站调它补记。解析期间会话被删除或换表的不再写回，
+     * 同一条记录的解析不并发。不会拒绝。
+     */
+    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);
+        }
+    }
+    // ---- 取别的会话的东西 ----
+    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) {
-        const id = opts?.parentId
-            ? `${opts.parentId}::${crypto.randomUUID().slice(0, 8)}`
-            : `session-${crypto.randomUUID().slice(0, 8)}`;
+    async createSession(opts, creation) {
+        if (creation && opts?.parentId)
+            throw new Error('建档专用参数只给根会话：子会话按根会话取创建来源、所属工作区与绑定');
+        const created = creation ? this.creationFields(creation) : {};
+        // 子会话的 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: opts?.config || {},
             createdAt: now,
             updatedAt: now,
-            createdBy: opts?.createdBy || 'user',
-            inputContext: opts?.inputContext ?? opts?.metadata?.inputContext,
+            inputContext: opts?.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(`会话创建: ${toSource(sessionLabel(session))} (${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);
     }
@@ -389,37 +658,76 @@ class SessionManager {
             session.status = updates.status;
         if (updates.metadata !== undefined)
             session.metadata = { ...session.metadata, ...updates.metadata };
-        if (updates.config !== undefined) {
-            // 合并配置而不是替换
-            session.config = { ...session.config, ...updates.config };
-        }
         session.updatedAt = Date.now();
         this.markDirty();
-        await this.caps.events.emit('session:updated', session);
+        await this.caps.events.use.emit('session:updated', session);
         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 中移除
-        if (session.parentId) {
-            const parent = this.sessions.get(session.parentId);
-            if (parent) {
-                parent.children = parent.children.filter(c => c !== id);
-                parent.updatedAt = Date.now();
-            }
+            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);
+            parent.updatedAt = Date.now();
         }
         this.sessions.delete(id);
-        this.deleted.set(id, Symbol(id));
-        await this.clearDeletedSessionData(id);
+        this.deleted[SESSIONS].set(id, Symbol(id));
         this.markDirty();
-        await this.caps.events.emit('session:deleted', id);
-        this.caps.logger.info(`会话删除: ${session.name} (${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(`会话删除: ${toSource(sessionLabel(session))} (${id})`);
+        return removed;
     }
     async clearDeletedSessionData(id) {
         const clearData = {
@@ -427,7 +735,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 +747,148 @@ 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}: ${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) {
-        // 平台派生会话（cli-default、OneBot 会话 id）从不经 createSession 预建，父档缺失是常态；
-        // 先兜底建档再挂子会话，否则 create_subtask 在这些平台必败。
+        // 带 source 的注入回合（定时任务、编排）可能落在还没建档的会话上：先按 id 兜底建档再挂子会话，否则 create_subtask
+        // 在这些会话里必败。兜底建档的会话没有来源字段、创建来源与名字：是房间的由之后的原生入站补记来源字段与名字
         if (!this.sessions.has(parentId))
             await this.ensureSession(parentId);
-        return this.createSession({
-            ...opts,
-            parentId,
-            createdBy: opts?.createdBy || 'agent',
-        });
+        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 };
+        }
+        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);
+    }
+    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)
+            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;
+            }
         }
-        // 返回所有根会话的树
-        return this.listSessions({ parentId: null }).map(buildNode);
+        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);
     }
     // ---- 生命周期 ----
     async completeSession(id, result) {
@@ -484,8 +900,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(`会话完成: ${toSource(sessionLabel(session))} (${id})${result ? ` - ${result.slice(0, 100)}` : ''}`);
     }
     // ---- 标题管理 ----
     async generateTitle(sessionId, userMessage) {
@@ -497,11 +913,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()) {
@@ -525,34 +941,33 @@ 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}` },
                 ],
                 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);
+            title = truncateChars((resp.content || '').trim(), 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}`);
+            title = truncateChars(userMessage.trim().replace(/\s+/g, ' '), 20);
+            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,101 +979,74 @@ 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);
+    }
+    /** 同一处只告警一次：key 缺省为这句话本身 */
+    warnOnce(message, key = message) {
+        if (this.warned.has(key))
+            return;
+        this.warned.add(key);
+        this.caps.logger.use.warn(message);
+    }
+    hasTurnInFlight(sessionId) {
+        for (const turn of this.turns.values())
+            if (turn.sessionId === sessionId)
+                return true;
+        return false;
     }
-    // ---- 配置解析 ----
     /**
-     * 解析指定会话的最终生效配置
-     *
-     * 合并优先级（从高到低）：
-     * 1. 会话自身 config
-     * 2. 父会话的 sessionDefaults
-     * 3. 平台 profile
-     * 4. 全局 defaults（最低）
+     * 回合开始：登记这一轮；已有记录且不是 active 的翻 active。归档的不翻：归档是 owner 不想在列表里看到它，
+     * 她在那里跑一轮不该让它回到列表，只有手动恢复才回来
      */
-    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;
+    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 给的可能带上游的整段响应（字符串本身，或文字对象的参数），会随会话落盘、进子任务提醒，截短；空串当作没给
+        if (outcome !== 'error' || !error)
+            turn.error = undefined;
+        else
+            turn.error = typeof error === 'string' ? truncateChars(error, ERROR_MAX, '…') : truncateParams(error, ERROR_MAX);
     }
     /**
-     * 解析「继承默认」：不含 session 自身 config，只算 defaults + platform profile + 父 sessionDefaults。
-     *
-     * WebUI 「继承 (xxx)」提示应该用这个值，否则会显示用户自己的覆盖值。
+     * 回合结束：注销这一轮，记下 lastTurn（被拦下、没有结局的一轮记为 silent），结局为 replied 的另记下她开口的时间。
+     * 会话里的最后一轮结束时，仍为 active 的会话（根会话与子会话一样）按这一轮的结局收口：出错为 error，其余为 completed
      */
-    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）
-        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));
-            }
-        }
-        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) };
-            }
-            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(', ')}`);
-        }
+    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 +1055,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,220 +1088,165 @@ 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) };
 }
 /**
- * 页面动作全是 apply 里的闭包：直接用这次激活的 manager 与能力，
- * 登记随激活存亡（插件不在，WebUI 就调不到这些方法）。
+ * 判得出的根会话的平台：IM 房间（出生平台加聊天窗口）取出生平台，owner 的面（有创建来源）取创建来源。不在会话表里的、按 id
+ * 兜底建档的空记录与只记了出生平台的旧房间记录（等下一条原生入站补记）判不出
  */
-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 };
-    });
+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 }), createdAt: now, updatedAt: now };
+}
+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 }) };
+}
+/** 排序时默认工作区在前，其余不动 */
+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);
+/**
+ * 会话记录里会进会话列表与协议、类型不对会让读者出错的可选字段，各自的类型。种类载入时重算，不在这里
+ */
+const OPTIONAL_FIELDS = {
+    name: isText,
+    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 || asText(value.error) !== undefined),
+    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,
+        children: isTextList(record.children),
+        status: SESSION_STATUSES.has(record.status),
+        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:` 开头，窗口的不是）时回这个字段名，整条不载入；
+ * 可选的名字（默认工作区没有）、目录与 metadata 类型不对时去掉它
+ */
+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),
+        createdAt: isTime(record.createdAt),
+        updatedAt: isTime(record.updatedAt),
+    };
+    const wrong = Object.keys(required).find(field => !required[field]);
+    if (wrong)
+        return { wrong };
+    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 };
 }
 // ===== 插件入口 =====
 const uses = {
     /** 会话档案与消息历史的唯一落点：没有 memory 就没有会话管理 */
     memory,
     /**
-     * 本插件不调用 agent 的方法；声明它是为了 agent:* 钩子的键类型。
-     * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与 `agent:turn:after` 收口；
+     * 删除会话清数据时经它的 clearing 按住这个会话；另为 agent:* 钩子的键类型。
+     * 第一方栈由 core 关停编排（optional 环成员先全部 drain）与回合结束时的收口处理；
      * 此处 onDrain 兜的是未装 agent 或钩子未挂上的路径。
      */
     agent: optional(agent),
-    /** 自动标题的模型来源；没有 LLM 时退回用户消息首段 */
+    /** 自动标题的模型来源（没有 LLM 时退回用户消息首段） */
     llm: optional(llm),
-    /** 下列三项只供 WebUI 下拉框枚举选项，缺席即空列表 */
-    persona: optional(persona),
+    /**
+     * 自动标题的输出语言：取全局语言（读者是 owner），缺席时按中文。plugin-i18n 也以 optional 用会话管理，
+     * 两边成可选环
+     */
+    i18n: optional(i18n),
+    /** 房间建档时问认领者、取平台的类型声明记下聊天窗口；解析接管房间的适配器实例（originInstance） */
     platform: optional(platform),
-    tools: optional(tools),
-    /** 页面与页面动作的登记口；无 WebUI 时会话管理照常在后台运行 */
-    webui: optional(webuiServer),
+    /**
+     * owner 的 IM 私聊在默认工作区：placeOf 按它认对端是不是 owner，与房间类别同一判据。plugin-authority 也以 optional
+     * 用会话管理，两边成可选环；缺席时认不出 owner，一对一窗口按窗口算
+     */
+    authority: optional(authority),
+    /**
+     * 按会话读取别的会话的范围与三个开关；缺席时取插件配置里的值。plugin-session-settings 以 required 用会话管理：这边可选，
+     * 读取器的登记随它上线补上
+     */
+    sessionFields: optional(sessionFields),
+    /** 按会话字段的全局层：宿主配置文档里本实例的那一段 */
+    document: optional(ownHostConfig),
+    config,
     events,
     hooks,
     lifecycle,
     logger,
-    config,
     provide,
 };
 export default definePlugin({
     name: '@aalis/plugin-session-manager',
-    displayName: '会话管理',
+    displayName: t('displayName'),
     subsystem: 'session',
     configSchema,
     provides: [sessionManager],
@@ -921,101 +1254,81 @@ export default definePlugin({
     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 manager = new SessionManager(caps);
+    const { memory, events, hooks, lifecycle, logger, provide } = caps;
+    const manager = new SessionManager(caps, caps.sessionFields.use.fields(configSchema, 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: t('displayName') });
+    // ===== IM 房间收录 =====
+    // 原生入站的收录与补记见 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 session = manager.getSession(msg.sessionId);
-        if (session && session.status !== 'active') {
-            manager.updateSession(msg.sessionId, { status: 'active' }).catch(() => { });
+        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 }),
+            });
         }
     });
-    events.on('outbound:message', (msg) => {
-        if (!msg.sessionId)
-            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:turn:before）才翻 active，归档的不翻：群里只有消息、她没开口的房间不显示「进行中」
+    //（触发判定在入站相位，挡下的消息到不了这里）。同一个中间件在 finally 里记下这一轮并收口，根会话与子会话一样，这是
+    // 唯一的收口：next() 返回时整轮已跑完、agent:turn:after 也已执行（agent 只在这个钩子的默认动作里发它），结局已经记下；
+    // 后面的中间件不调 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();
+        }
+        finally {
+            manager.endTurn(data.turnId);
         }
     });
-    // 回合终态收口：agent 在 replied/silent/aborted/error 四条路径都会发 agent:turn:after。
-    // 上面的 outbound:message 只覆盖"产生了回复"的情形——用户中途停止生成（aborted）或
-    // 空回复（silent）时不发 outbound:message，会话会永远停在 'active'（即"进行中"）。
-    // 这里订阅生命周期钩子作幂等互补，确保任何回合结束都把根会话收口为 'completed'。
-    hooks.middleware('agent:turn:after', async (data, next) => {
+    hooks.use.middleware('agent:turn:after', async (data, next) => {
+        manager.recordOutcome(data.turnId, data.outcome, data.error);
         await next();
-        if (!data.sessionId)
-            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']);
+    // 模型调用的 token 按会话累加：对话、摘要、识图、转写的调用都带会话 id
+    events.use.on('llm:usage', usage => manager.recordUsage(usage));
+    // 自动标题：只给带创建来源的根会话（WebUI 新建的、终端建的）生成，在首条消息时生成、不等回复；IM 房间不生成，
+    // owner 从 WebUI 往房间插话也不拿来给房间起名。异步生成，不阻塞消息处理；直接传入这条消息，不依赖历史
     const titleGenerating = new Set();
-    events.on('inbound:message', (msg) => {
-        const { sessionId, platform } = msg;
-        if (!sessionId) {
-            logger.debug('标题生成跳过: 缺少 sessionId');
-            return;
-        }
-        if (titleGenerating.has(sessionId))
-            return;
-        // 仅对指定平台生成标题；非 webui/cli 平台（如 onebot）静默跳过，避免日志污染。
-        // platform 缺省同样跳过：白名单是正向门，来路不明的消息不该顺带建档 + 烧一次 LLM 生成标题。
-        if (!platform || !TITLE_PLATFORMS.has(platform))
-            return;
+    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