dsh-plugin-tool-management 0.12.0 → 0.13.0

package/lib/mcp/manager.js

@@ -248,28 +248,32 @@ export function createMcpManager(deps) {
         notesCache = { at: Date.now(), value: out };
         return out;
     }
+    /**
+     * 备注侧车的读-改-写。**必须在调用方已持有写锁时调用** —— 自己再去拿一次锁会自锁。
+     * 空 note = 删掉该条目（与 `mcpm-note` 的语义一致）；强制重读，外部改过的侧车是合并而不是覆盖。
+     */
+    async function writeNoteUnderLock(id, note) {
+        const map = Object.assign({}, await readNotes(true));
+        if (note)
+            map[id] = note;
+        else
+            delete map[id];
+        try {
+            await writeJsonFile(mcpSidecar(MCP_NOTES_FILE), map);
+        }
+        catch (e) {
+            return { ok: false, error: '备注保存失败: ' + message(e) };
+        }
+        notesCache = { at: Date.now(), value: map };
+        return { ok: true, notes: map };
+    }
     async function mcpmNote(args) {
         const id = String((args && args.id) || '').trim();
         if (!id)
             return { ok: false, error: '缺少 id' };
         const note = String((args && args.note) == null ? '' : args.note).trim();
-        const p = await ensurePaths();
-        return withWriteLock(async () => {
-            // Force re-read so an externally edited notes file is merged, not clobbered.
-            const map = Object.assign({}, await readNotes(true));
-            if (note)
-                map[id] = note;
-            else
-                delete map[id];
-            try {
-                await writeJsonFile(mcpSidecar(MCP_NOTES_FILE), map);
-            }
-            catch (e) {
-                return { ok: false, error: '备注保存失败: ' + message(e) };
-            }
-            notesCache = { at: Date.now(), value: map };
-            return { ok: true, notes: map };
-        });
+        await ensurePaths();
+        return withWriteLock(async () => await writeNoteUnderLock(id, note));
     }
     // 界面轮询间隔的合法区间：再快没有意义（列表刷新本身要读文件），再慢就失去"自动跟上"的
     // 意义。两侧都夹住，避免手改侧车文件时写进一个 0 或无穷大把界面刷爆。
@@ -447,8 +451,8 @@ export function createMcpManager(deps) {
         });
     }
     // Visibility seam: keep one active restriction per **agent scope**, refreshed whenever
-    // the tool set or the disabled set changes. Three facts decide this design（都读过官方源码
-    // dsh-tools 0.1.5-rc.2）：
+    // the tool set / the disabled set / this agent's carrier set changes. Three facts decide
+    // this design（都读过官方源码 dsh-tools 0.1.5-rc.2）：
     //   · `restrict()` **要求 scoped context** —— 插件级 ctx 调用必抛 "requires a scoped
     //     context"，这正是「停用工具从模型可见 schema 消失」这半边此前从未生效的原因（V1）；
     //   · 每次 layer 变化（restriction 就是一次 layer effect）官方都会 emit `tools/change`
@@ -456,25 +460,62 @@ export function createMcpManager(deps) {
     //     `tools/change` 上 —— 名单没变还重放就是自激；
     //   · 表要取自**不受限**的插件级视图：在 agent scope 里取 `schemas()`，第一次限制生效后
     //     表里就没有被停用的工具了，第二次重放会把它从 deny 名单里筛掉 —— 停用静默复活。
+    // （2026-09-23：名单有三处来源，其中 `carrierHiddenTools` 逐 agent 不同，所以从"一份名单给
+    //  所有 agent"改成逐 agent 各装一层 —— 见下面 restrictAgent / appliedByAgent 的注释。）
     let restrictTimer = null;
     /** 已应用名单的键；相同即返回（防自激，也让每次 tools/change 变成一次廉价判等）。 */
     let appliedNamesKey = null;
-    /** 当前期望的 deny 名单（agent 晚到 / 重放时用它）。 */
+    /** 当前期望的**全局** deny 名单（agent 晚到 / 重放时用它，再叠加该 agent 自己那份）。 */
     let desiredNames = [];
     /** agent → 撤掉这层限制的 disposer。 */
     const agentRestrictions = new Map();
+    /** agent → 已应用的**合并后**名单键（名单现在与 agent 有关，不能再只记一份全局的）。 */
+    const appliedByAgent = new Map();
     /** 见过的 agent（重放时逐个重新应用；disposed 时移除）。 */
     const seenAgents = new Set();
+    /**
+     * 重放代数：`carrierHiddenTools` 是异步的，算名单期间可能又来了新的一轮重放（或 agent
+     * 已经下线）。每次重放自增，回来时代数对不上就作废 —— 否则会用旧名单盖掉新的那一层。
+     */
+    let epoch = 0;
     function scopedToolsOf(agent) {
         const scoped = agent && agent.ctx && agent.ctx.tools;
         return scoped && typeof scoped === 'object' ? scoped : undefined;
     }
-    /** 把当前名单装到某个 agent scope 上（空名单 = 没有要摘的工具，不碰它）。 */
-    function restrictAgent(agent) {
-        if (desiredNames.length === 0)
+    /** 撤掉某个 agent 上的限制（名单变了要重装：`restrict` 是叠加层，装新的不撤旧的会越叠越多）。 */
+    function liftRestriction(agent) {
+        const release = agentRestrictions.get(agent);
+        agentRestrictions.delete(agent);
+        appliedByAgent.delete(agent);
+        if (release) {
+            try {
+                release();
+            }
+            catch (e) { /* ignore */ }
+        }
+    }
+    /** 把该 agent 该背的名单装到它 scope 上（全局那份 ∪ 它自己那份；空名单 = 不碰它）。 */
+    async function restrictAgent(agent) {
+        const mine = epoch;
+        let extra = [];
+        if (deps.carrierHiddenTools) {
+            // 判据失败一律当"没有额外要藏的"：藏错了模型就少一条路，留着只是多花 token。
+            try {
+                extra = await deps.carrierHiddenTools(agent);
+            }
+            catch (e) {
+                extra = [];
+            }
+        }
+        if (mine !== epoch)
             return;
+        if (!seenAgents.has(agent))
+            return;
+        const names = [...new Set([...desiredNames, ...extra])];
         const scoped = scopedToolsOf(agent);
         if (!scoped || typeof scoped.restrict !== 'function') {
+            if (names.length === 0)
+                return;
             // agent scope 上没有 tools 面（或它没有 restrict）：这半边做不成，如实说 ——
             // 静默跳过会让人以为"停用工具从模型工具表里消失"已经生效。
             noteRuntime({
@@ -482,13 +523,22 @@ export function createMcpManager(deps) {
                 label: '停用工具的可见性',
                 kind: 'write',
                 fallback: 'inform-only',
-                detail: 'agent scope 上没有可用的 tools.restrict（官方接口变了或该 scope 未暴露 tools）：停用的 MCP 工具仍会出现在模型可见的工具表里，执行侧拦截仍然生效。',
+                detail: 'agent scope 上没有可用的 tools.restrict（官方接口变了或该 scope 未暴露 tools）：停用的 MCP 工具与兼容页关掉的本插件工具仍会出现在模型可见的工具表里，执行侧拦截仍然生效。',
             });
             return;
         }
+        const key = names.slice().sort().join('\u0000');
+        if (appliedByAgent.get(agent) === key)
+            return;
+        liftRestriction(agent);
+        if (names.length === 0) {
+            clearRuntimeNote('mcp-tool-visibility');
+            return;
+        }
         try {
-            const dispose = scoped.restrict({ deny: desiredNames });
+            const dispose = scoped.restrict({ deny: names });
             agentRestrictions.set(agent, typeof dispose === 'function' ? dispose : () => { });
+            appliedByAgent.set(agent, key);
             clearRuntimeNote('mcp-tool-visibility');
         }
         catch (e) {
@@ -499,7 +549,7 @@ export function createMcpManager(deps) {
                 label: '停用工具的可见性',
                 kind: 'write',
                 fallback: 'inform-only',
-                detail: '停用的 MCP 工具没能从模型可见的工具表里摘掉（' + message(e) + '）：执行侧拦截仍然生效，模型仍能看到该工具的名字。',
+                detail: '有工具没能从模型可见的工具表里摘掉（' + message(e) + '）：执行侧拦截仍然生效，模型仍能看到该工具的名字。',
             });
         }
     }
@@ -508,19 +558,12 @@ export function createMcpManager(deps) {
         if (!agent || (typeof agent !== 'object' && typeof agent !== 'function'))
             return;
         seenAgents.add(agent);
-        restrictAgent(agent);
+        void restrictAgent(agent).catch(() => { });
     }
-    /** agent 下线（`agent/disposed`）：先撤限制再销登记（撤限制会把 disposer 摘掉）。 */
+    /** agent 下线（`agent/disposed`）：先撤限制再销登记。 */
     function detachAgent(agent) {
         seenAgents.delete(agent);
-        const dispose = agentRestrictions.get(agent);
-        agentRestrictions.delete(agent);
-        if (dispose) {
-            try {
-                dispose();
-            }
-            catch (e) { /* ignore */ }
-        }
+        liftRestriction(agent);
     }
     async function applyToolRestrictions() {
         if (typeof tools.restrict !== 'function')
@@ -545,24 +588,33 @@ export function createMcpManager(deps) {
                 if (fullName.startsWith(prefix))
                     wanted.push(fullName);
         }
-        const names = wanted.filter((name) => registered.has(name));
-        const key = names.join('\u0000');
-        if (key === appliedNamesKey)
-            return;
-        appliedNamesKey = key;
-        desiredNames = names;
-        // 每次重放先撤旧限制：名单变短（重新启用某个工具）时，只有撤掉这层限制它才会重新可见。
-        for (const [agent, dispose] of agentRestrictions) {
-            agentRestrictions.delete(agent);
+        // 兼容页「模型工具表」关掉的本插件工具并进同一份名单（理由见 deps.pluginHiddenTools）。
+        // 交给上面那个 `registered` 过滤是**必要的**而不是保险：官方对认不出的名字直接抛错，
+        // 而关掉的工具里可能有一个这次根本没注册成功（注册失败会被子智能体页的黄条报出来）。
+        if (deps.pluginHiddenTools) {
             try {
-                dispose();
+                for (const name of deps.pluginHiddenTools())
+                    wanted.push(name);
             }
-            catch (e) { /* ignore */ }
+            catch (e) { /* 读设置失败 = 这次不摘它们 */ }
         }
-        if (!names.length)
+        const names = [...new Set(wanted)].filter((name) => registered.has(name));
+        const key = names.join('\u0000');
+        // 有 `carrierHiddenTools` 时不拿全局键短路：那份名单与"官方工具此时挂没挂"有关，
+        // 而它变了不会改全局键（官方挂载/卸载本身就发 tools/change，正是靠这条通路追上）。
+        // 代价是每次 tools/change 都重算一遍 —— 逐 agent 的键判等会把绝大多数挡在装层之前，
+        // 事实读取也有 TTL 缓存；装层本身会再发一次 tools/change，那一轮键相同即收敛，不自激。
+        if (key === appliedNamesKey && deps.carrierHiddenTools === undefined)
             return;
+        appliedNamesKey = key;
+        desiredNames = names;
+        // 每次重放先撤掉每个 agent 上的旧层：名单变短（重新启用某个工具）时，只有撤掉这层限制
+        // 它才会重新可见；名单变了（含逐 agent 那份）也必须重装而不是叠加。
+        epoch += 1;
+        for (const agent of [...agentRestrictions.keys()])
+            liftRestriction(agent);
         for (const agent of seenAgents)
-            restrictAgent(agent);
+            void restrictAgent(agent).catch(() => { });
     }
     function scheduleToolRestrictions() {
         if (restrictTimer)
@@ -1097,7 +1149,16 @@ export function createMcpManager(deps) {
             catch (e) {
                 return { ok: false, error: '写入补丁失败: ' + message(e) };
             }
-            return { ok: true, row: { ...row, level, disabled: defaultDisabled }, ...(guardNotes.length ? { warning: guardNotes.join('；') } : {}) };
+            const out = { ok: true, row: { ...row, level, disabled: defaultDisabled }, ...(guardNotes.length ? { warning: guardNotes.join('；') } : {}) };
+            // 备注跟着新增一起落侧车：**id 只有这里算得出来**（重名会加 `-2` 后缀），留给客户端
+            // 补一次 `mcpm-note` 就拿不到最终 id。写失败不回滚已建好的条目，只把失败并进同一条 warning。
+            const note = String((args && args.note) == null ? '' : args.note).trim();
+            if (note) {
+                const noted = await writeNoteUnderLock(id, note);
+                if (!noted.ok)
+                    out.warning = out.warning ? out.warning + '；' + noted.error : noted.error;
+            }
+            return out;
         });
     }
     async function mcpmEdit(args) {
@@ -1714,13 +1775,10 @@ export function createMcpManager(deps) {
             restrictTimer = null;
         }
         // 插件卸载时把挂在每个 agent scope 上的限制都撤掉（否则那些 scope 会继续背着一层名单）。
-        for (const [, release] of agentRestrictions) {
-            try {
-                release();
-            }
-            catch (e) { /* ignore */ }
-        }
-        agentRestrictions.clear();
+        epoch += 1;
+        for (const agent of [...agentRestrictions.keys()])
+            liftRestriction(agent);
+        appliedByAgent.clear();
         seenAgents.clear();
     }
     return {

package/lib/mcp/state-section.js

@@ -41,8 +41,11 @@
 // 与子智能体目录同构的 stale-while-revalidate（见 src/subagents/catalog.ts）。
 /** 段里最多列几台 server；超出部分只报数量。 */
 export const DEFAULT_MCP_MAX_ENTRIES = 50;
-/** 备注截断长度。备注是自由文本，界面侧另有 maxLength(500) 兜底，段侧再截一刀。 */
-export const DEFAULT_MCP_NOTE_MAX_LENGTH = 200;
+/**
+ * 备注截断长度。界面上那两枚输入框（MCP 页与场景档案）用同一个数当字数上限，
+ * 客户端镜像在 `42-shared-ui.js` 的 `MCP_NOTE_MAX` —— 改这里要一起改它。
+ */
+export const DEFAULT_MCP_NOTE_MAX_LENGTH = 300;
 /**
  * 备注的固定前缀（模型侧口径，用户裁定 2026-09-16：字段与段统一叫 user-hint / 用户提示）。
  *

package/lib/memories/archive-engine.js

@@ -180,6 +180,205 @@ export function createArchiveEngine(deps) {
             const slice = await deps.loadSlice();
             return { ok: true, archives: slice.archives, mode: slice.mode, active: slice.active };
         },
+        // 读：把「进入场景会改什么」先算一遍给人看，**一个字节都不写**。
+        //
+        // 为什么单独一个 op 而不是让界面自己估：进入场景真正的改动来自 `scene-mode-set` 里那三步
+        // （服务器级/来源级切换 → 工具级/技能级 → 人设 + 备注），计划由 `computeMcpPlan` /
+        // `computeSkillsPlan` 两个**纯函数**算出来。本 op 走同一批纯函数、读同一批现状，
+        // 只是把后面的 `apply*` 与 `saveSlice` 全部去掉 —— 于是预览与实际执行不可能各说各话
+        // （界面自己数勾出来的数字才会：档案段未定义 = 全关这条语义它并不知道）。
+        // 副作用清单：只有读。`loadSlice` / `current*` / `*States` / `known*` 全是读盘或读内存。
+        'scene-mode-preview': async (args) => {
+            const hasKey = args && 'scene' in (args || {});
+            if (!hasKey)
+                return { ok: false, error: '缺少 scene（null = 退出模式）' };
+            const raw = (args && args.scene) ?? null;
+            const target = raw == null ? null : String(raw).trim() || null;
+            const slice = await deps.loadSlice();
+            const current = slice.mode && slice.mode.scene ? slice.mode.scene : null;
+            const cap = 60;
+            let truncated = false;
+            const clip = (list) => {
+                if (list.length <= cap)
+                    return list;
+                truncated = true;
+                return list.slice(0, cap);
+            };
+            // ── 退出模式：说的是「快照会回写什么」，不是「关掉场景后剩下什么」 ──────────
+            if (target === null) {
+                if (!current) {
+                    return { ok: true, current: null, target: null, noChange: true, exit: null, memory: null, mcp: null, skills: null, subagents: null, stale: [], truncated: false };
+                }
+                const snap = slice.mode.snapshot;
+                if (!snap) {
+                    // 当前在场景内但快照丢了：退出只能落盘模式位，运行时回不来 —— 这句必须说出来。
+                    return { ok: true, current, target: null, noChange: false, exit: { snapshotMissing: true }, memory: null, mcp: null, skills: null, subagents: null, stale: [], truncated: false };
+                }
+                const personaStates = snap.subagentsAll;
+                return {
+                    ok: true,
+                    current,
+                    target: null,
+                    noChange: false,
+                    exit: {
+                        scene: current,
+                        mcpServers: Object.keys(snap.mcp || {}).length,
+                        skills: Object.keys(snap.skills || {}).length,
+                        subagents: personaStates ? Object.keys(personaStates).length : (snap.subagents ?? []).length + (snap.subagentsOn ?? []).length,
+                        mcpNotes: (snap.mcpNotes ?? []).length,
+                    },
+                    // 记忆启用集**不随退出恢复**（设计 §2.2）：退出后仍是这个场景，界面别把它写成"会还原"。
+                    memory: { from: slice.active, to: slice.active, narrowed: false },
+                    mcp: null, skills: null, subagents: null, stale: [], truncated: false,
+                };
+            }
+            if (!(await deps.sceneExists(target)))
+                return { ok: false, error: `场景不存在: ${target}` };
+            if (target === current) {
+                return { ok: true, current, target, noChange: true, exit: null, memory: null, mcp: null, skills: null, subagents: null, stale: [], truncated: false };
+            }
+            const archive = slice.archives[target];
+            // 与进入时逐字同口径：mcp / skills / subagents 三段**未定义 = 一个都没勾 = 全部停用**，
+            // 备注段是唯一例外（未定义 = 不覆盖）。所以这里不给 `compute*Plan` 兜空对象的分支。
+            let mcpPlan;
+            let skillsPlan;
+            let serverStates;
+            let sourceStates;
+            let configured = [];
+            try {
+                serverStates = await deps.mcpServerStates();
+                sourceStates = await deps.skillSourceStates();
+                configured = await deps.configuredServers();
+                mcpPlan = computeMcpPlan((archive && archive.mcp) || {}, {
+                    configuredServers: configured,
+                    knownTools: await deps.serverKnownTools(),
+                    serverStates,
+                });
+                skillsPlan = computeSkillsPlan((archive && archive.skills) || [], await deps.knownSkillKeys(), sourceStates);
+            }
+            catch (e) {
+                return { ok: false, error: `读取运行时状态失败：${msg(e)}` };
+            }
+            let personas = null;
+            try {
+                const bound = archive && Array.isArray(archive.subagents) ? archive.subagents : [];
+                const known = await deps.knownPersonas();
+                const unbound = [...known].filter((n) => bound.indexOf(n) < 0).sort();
+                personas = { on: await deps.disabledPersonas(bound), off: await deps.enabledPersonas(unbound) };
+            }
+            catch (e) {
+                return { ok: false, error: `读取人设开关状态失败：${msg(e)}` };
+            }
+            // 服务器级：计划里已只含「需要变化」的行，按目标状态分两个方向。
+            const serversOn = [];
+            const serversOff = [];
+            for (const s of mcpPlan.serverSwitches)
+                (s.enabled ? serversOn : serversOff).push(s.serverName);
+            // 工具级停用表：与现状逐台比对（['*'] 是"整台停用"这个原子状态，不当工具名处理）。
+            //
+            // ⚠️ 只报**前后都在跑**的服务器（`offServers`）。服务器没在跑的时候，它的工具停用表只是
+            // 记账：把一台本来就没启用的（或这次正要停用的）服务器记成「整台停用」没有任何可见效果，
+            // 报成「停用 N 个 MCP 工具」是假话 —— 用户实测就是这么看到「停用 6 个 MCP 工具：
+            // context7/*、fastgraph/* …」，而那 6 台从来没启用过（2026-09-23）。服务器级的改动
+            // 由 `serverSwitches` 那一行如实说（它只含真的会变的），工具级留给逐工具开关真正起作用的
+            // 情形。
+            const offServers = new Set();
+            for (const state of serverStates)
+                if (state.disabled)
+                    offServers.add(state.serverName);
+            for (const sw of mcpPlan.serverSwitches)
+                if (!sw.enabled)
+                    offServers.add(sw.serverName);
+            const toolsOn = [];
+            const toolsOff = [];
+            try {
+                const now = await deps.currentMcpRaw();
+                for (const [server, want] of Object.entries(mcpPlan.entries)) {
+                    if (offServers.has(server))
+                        continue;
+                    const before = now[server] || [];
+                    const wildcard = (list) => list.length === 1 && list[0] === '*';
+                    if (wildcard(want)) {
+                        if (!wildcard(before))
+                            toolsOff.push(`${server}/*`);
+                        continue;
+                    }
+                    if (wildcard(before)) {
+                        toolsOn.push(`${server}/*`);
+                        continue;
+                    }
+                    const wantSet = new Set(want);
+                    const beforeSet = new Set(before);
+                    for (const tool of want)
+                        if (!beforeSet.has(tool))
+                            toolsOff.push(`${server}/${tool}`);
+                    for (const tool of before)
+                        if (!wantSet.has(tool))
+                            toolsOn.push(`${server}/${tool}`);
+                }
+            }
+            catch (e) {
+                return { ok: false, error: `读取 MCP 停用表现状失败：${msg(e)}` };
+            }
+            // 技能级：计划产出的是**已知全集**的目标状态，与现状比对才得到"这次真的会改几个"。
+            const skillsOn = [];
+            const skillsOff = [];
+            try {
+                const now = await deps.currentSkills();
+                for (const [key, want] of Object.entries(skillsPlan.target)) {
+                    const before = now[key];
+                    if (before === undefined)
+                        continue; // 现状里没有这一行 → 这次不算改动
+                    if (want && !before)
+                        skillsOn.push(key);
+                    else if (!want && before)
+                        skillsOff.push(key);
+                }
+            }
+            catch (e) {
+                return { ok: false, error: `读取技能启停现状失败：${msg(e)}` };
+            }
+            const sourcesOn = [];
+            const sourcesOff = [];
+            for (const s of skillsPlan.sourceSwitches)
+                (s.enabled ? sourcesOn : sourcesOff).push(s.root);
+            const stale = [...mcpPlan.stale, ...skillsPlan.stale];
+            const notesDefined = !!(archive && archive.mcpNotes);
+            const noteCount = notesDefined
+                ? Object.keys(archive.mcpNotes).filter((server) => archive.mcp && server in archive.mcp).length
+                : 0;
+            // 「进入后处于启用」的服务器（场景勾着的那几台 ∩ 配置里真实存在的）。它是**状态**不是改动，
+            // 与上面几行的"会改什么"互补：什么都没变时 MCP 那一段整段消失，读起来像缺了信息（用户
+            // 2026-09-23 实测）。工具级不列（服务器没在跑时它的工具数无从得知，报了就是猜）。
+            const enterServers = Object.keys((archive && archive.mcp) || {})
+                .filter((name) => configured.indexOf(name) >= 0)
+                .sort();
+            return {
+                ok: true,
+                current,
+                target,
+                noChange: false,
+                // 目标场景**没存过档案**：进入不是"按档案配"，而是四域一律全关（未定义 = 全关）。
+                // 这是最容易被当成"点了个没配置的场景，应该什么都不改"的一种，界面必须单独说。
+                hasArchive: !!archive,
+                exit: current ? { scene: current, snapshotMissing: !slice.mode.snapshot } : null,
+                memory: { from: slice.active, to: [target], narrowed: true },
+                mcp: {
+                    serversOn: clip(serversOn), serversOff: clip(serversOff),
+                    toolsOn: clip(toolsOn), toolsOff: clip(toolsOff),
+                    notes: noteCount, notesDefined,
+                },
+                // 进入后**处于启用**的服务器（结果口径；界面上是"进入后启用 N 台…"那一行）。
+                enter: { servers: clip(enterServers) },
+                skills: {
+                    on: clip(skillsOn), off: clip(skillsOff),
+                    sourcesOn: clip(sourcesOn), sourcesOff: clip(sourcesOff),
+                },
+                subagents: { on: clip(personas.on), off: clip(personas.off) },
+                stale: clip(stale),
+                truncated,
+            };
+        },
         // 写：保存某场景档案（三段整体替换；键对实时发现全集校验，未知键丢弃并报告）
         'scene-archive-save': (args) => serial(async () => {
             const scene = String((args && args.scene) || '').trim();

package/lib/memories/constants.js

@@ -17,7 +17,7 @@ export const MAX_RULE_BYTES = 1 << 18; // 正文上限 256 KiB
 export const DEFAULT_ORDER = 1000; // 默认投影 order（索引无记录时）
 export const DEFAULT_GROUP_ORDER = 1000; // 新场景默认 order
 export const SNAPSHOT_TTL_MS = 1000; // 读路径短 TTL 缓存，吸收 UI 密集轮询
-export const DEFAULT_MAX_BYTES = 65536; // 场景记忆段预算上限（字节）
+export const DEFAULT_MAX_BYTES = 1 << 17; // 场景记忆段预算上限（字节，=128 KiB）
 // ── 保留场景名 ─────────────────────────────────────────────────────────────
 /** 保留场景名：界面显示「全局」，恒定存在、不可删除，其记忆注入任何对话。 */
 export const GLOBAL_SCENE = 'global';

package/lib/memories/snapshot.js

@@ -204,12 +204,22 @@ export function deriveFromDoc(entry, doc) {
 }
 /** 合并索引字段（enabled/order 等以索引为准；无记录走默认投影）。 */
 export function projectRule(entry, derived, idxEntry) {
+    // 体积按**正文文件**算（bundle 的附件不计：附件不进注入正文）。一次 stat 一条记忆，
+    // 结果随快照的 1s TTL 缓存一起复用；读不到就不带这个字段，别把"不知道"报成 0 B。
+    let size;
+    try {
+        size = statSync(entry.docPath).size;
+    }
+    catch {
+        size = undefined;
+    }
     const rule = {
         id: entry.id,
         group: entry.group,
         name: derived.name,
         form: entry.kind,
         path: entry.docPath,
+        ...(size !== undefined ? { bytes: size } : {}),
         description: derived.description,
         ...(derived.descriptionDerived ? { descriptionDerived: true } : {}),
         ...(derived.whenToUse !== undefined ? { whenToUse: derived.whenToUse } : {}),