dsh-plugin-tool-management 0.7.0 → 0.8.0

package/lib/mcp/state-section.js

@@ -0,0 +1,90 @@
+/** 段里最多列几台 server；超出部分只报数量。 */
+export const DEFAULT_MCP_MAX_ENTRIES = 50;
+/** 备注截断长度。备注是自由文本，界面侧另有 maxLength(500) 兜底，段侧再截一刀。 */
+export const DEFAULT_MCP_NOTE_MAX_LENGTH = 200;
+/**
+ * 备注的固定前缀。
+ *
+ * 备注是自由文本，注入后以**系统提示词的身份**生效。若用户写了指令式内容
+ * （如「忽略以上全部规则」），会被当作系统级指令执行。威胁模型上是**自伤**而非被攻击
+ * （内容由用户自己写、仅本机可写），但加固定前缀能降低被读成指令的概率。
+ */
+export const MCP_NOTE_PREFIX = '用户备注：';
+/** 备注压成单行（换行 → 空格）并截断。 */
+function normalizeNote(value, maxLength) {
+    const flat = String(value ?? '').replaceAll(/\s+/g, ' ').trim();
+    if (!flat)
+        return '';
+    return flat.length <= maxLength ? flat : `${flat.slice(0, maxLength - 3)}...`;
+}
+/**
+ * 渲染 MCP 状态段（纯函数，便于单独推理）。
+ *
+ * 返回 `''` 表示不注入 —— 没有可用 server 的用户零 token 成本。
+ */
+export function renderMcpStateSection(rows, opts = {}) {
+    const maxEntries = opts.maxEntries ?? DEFAULT_MCP_MAX_ENTRIES;
+    const noteMaxLength = opts.noteMaxLength ?? DEFAULT_MCP_NOTE_MAX_LENGTH;
+    // 「当前真正可用」= 已启用 且 有工具。任一不满足都不进段。
+    const usable = rows.filter((r) => !r.disabled && Number(r.toolCount) > 0);
+    if (!usable.length)
+        return '';
+    // 按展示名排序：即使补丁文件里的行序变化，段文本也保持逐字节稳定（前缀缓存契约）。
+    const sorted = [...usable].sort((a, b) => {
+        const x = String(a.serverName ?? '');
+        const y = String(b.serverName ?? '');
+        return x < y ? -1 : x > y ? 1 : 0;
+    });
+    const shown = sorted.slice(0, Math.max(0, maxEntries));
+    const lines = shown.map((r) => {
+        const count = Number(r.toolCount) || 0;
+        const head = '- **' + String(r.serverName ?? r.id) + '**（' + count + ' 个工具）';
+        const note = normalizeNote(r.notes, noteMaxLength);
+        return note ? head + ' — ' + MCP_NOTE_PREFIX + note : head;
+    });
+    const out = ['## MCP 服务器', '', ...lines];
+    const hidden = sorted.length - shown.length;
+    if (hidden > 0)
+        out.push('', `（另有 ${hidden} 台未列出。）`);
+    return out.join('\n');
+}
+/** 创建 SWR 的 MCP 状态目录。计算失败时保留上一次的值，不把段清空。 */
+export function createMcpStateCatalog(deps, opts = {}) {
+    const ttlMs = opts.ttlMs ?? 3000;
+    const now = opts.now ?? (() => Date.now());
+    let value = '';
+    let loadedAt = Number.NEGATIVE_INFINITY;
+    let inflight = null;
+    const recompute = async () => {
+        try {
+            const result = await deps.rows();
+            if (result && result.ok !== false) {
+                value = renderMcpStateSection(result.rows ?? [], opts);
+            }
+        }
+        catch { /* 保留上一次的值；首次失败则维持 '' */ }
+        loadedAt = now();
+    };
+    const revalidate = () => {
+        if (inflight)
+            return inflight;
+        inflight = recompute().finally(() => { inflight = null; });
+        return inflight;
+    };
+    return {
+        text: () => {
+            if (now() - loadedAt > ttlMs)
+                void revalidate();
+            return value;
+        },
+        refresh: () => {
+            loadedAt = Number.NEGATIVE_INFINITY;
+            return revalidate();
+        },
+        warm: () => revalidate(),
+    };
+}
+/** 供 `createPromptSectionRegistrar` 使用的段声明。 */
+export function mcpStateSectionOf(catalog, order) {
+    return { name: 'tool-management:mcp-state', order, text: () => catalog.text() };
+}

package/lib/prompt-sections.js

@@ -0,0 +1,148 @@
+// dsh-plugin-tool-management —— systemPrompt 段注册（通用骨架）。
+//
+// 本模块是「把插件状态投影为 system prompt 段（自动在场）」的**唯一实现**。
+// 场景记忆段（src/rules/service.ts）、子智能体人设段、MCP 状态段
+// （src/index.ts）都经它注册，避免每个域各抄一份 scope 遍历逻辑。
+//
+// 官方接口语义（@deepseek-ai/dsh-system-prompt）：
+//   - `section({ name, order, text })` 在**调用者的 scope** 注册；scoped 段遮蔽同名全局段。
+//   - `text` 可以是**每次装配时求值的 provider 函数** → 切换启用状态后**下一个请求即生效**，
+//     无需重开会话、无需重载插件。
+//   - `renderPrompt` 会**删除空段** → 无内容时返回 `''`，不产生空标题、零 token 成本。
+//
+// 为什么每个段都注册两处（全局 + per-agent）：
+//   全局注册覆盖所有 agent（含子 agent）；per-agent 注册保证即使插件 ctx 自带 scope
+//   （全局段对某些 agent 不可见）也能命中 —— 两者同名，scoped 遮蔽全局，不会重复注入。
+//
+// 缓存契约（§5.2）：段文本必须**会话级恒定**（只由持久化配置与文件内容决定），
+// 因此前缀逐字节稳定 → 前缀缓存可命中；**禁止**在段里放时间戳/计数/相对时间。
+// 异步数据源（人设目录、MCP 清单）走 stale-while-revalidate：`text()` 同步返回缓存值，
+// 由调用方在写操作后触发重算，绝不在 `text()` 里发起 IO。
+const GLOBAL_KEY = '@global';
+/** 复合 key 的分隔符：NUL 不会出现在 agent id 或段名里。 */
+const KEY_SEP = '\u0000';
+/** 取 scope 上的 systemPrompt 服务（Cordis 的 ctx.get 可能抛错，全部吞掉）。 */
+function systemPromptOf(scope) {
+    if (!scope)
+        return undefined;
+    try {
+        if (typeof scope.get === 'function')
+            return scope.get('systemPrompt');
+        return scope.systemPrompt;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 注册一组 systemPrompt 段：全局 scope + 每个活动 agent 的 scope。
+ *
+ * 任一 scope / 任一段注册失败都只降级为"该段不注入"，不影响其余段与其余 scope。
+ */
+export function createPromptSectionRegistrar(ctx, sections) {
+    const registrations = new Map();
+    const install = (scope, scopeKey) => {
+        if (!scope)
+            return;
+        const systemPrompt = systemPromptOf(scope);
+        if (!systemPrompt || typeof systemPrompt.section !== 'function')
+            return;
+        for (const spec of sections) {
+            const key = scopeKey + KEY_SEP + spec.name;
+            if (registrations.has(key))
+                continue;
+            try {
+                const dispose = systemPrompt.section({
+                    name: spec.name,
+                    order: spec.order,
+                    // 每次装配重读 → 切换启用状态后下一个请求即生效。
+                    // 包一层箭头函数：spec.text 自身若被替换（热更新）也能跟上。
+                    text: () => spec.text(),
+                });
+                registrations.set(key, { scope, dispose: typeof dispose === 'function' ? dispose : () => { } });
+            }
+            catch (e) {
+                // 同层重名注册会抛错：降级为"该段不注入"，不影响其余 scope 与其余段。
+                console.error(`[dsh-plugin-tool-management] ${spec.name} section registration failed:`, String((e && e.message) || e));
+            }
+        }
+    };
+    const uninstall = (scopeKey) => {
+        const prefix = scopeKey + KEY_SEP;
+        for (const key of [...registrations.keys()]) {
+            if (!key.startsWith(prefix))
+                continue;
+            const entry = registrations.get(key);
+            registrations.delete(key);
+            try {
+                entry?.dispose();
+            }
+            catch { /* ignore */ }
+        }
+    };
+    // ① 全局：插件 ctx 的 scope（覆盖所有 agent）
+    install(ctx, GLOBAL_KEY);
+    // ② per-agent：与既有 install/uninstall 生命周期一致（agent/created、agent/disposed）
+    const on = ctx && ctx.on;
+    let stopCreated;
+    let stopDisposed;
+    if (typeof on === 'function') {
+        stopCreated = on('agent/created', (payload) => {
+            const agent = payload && payload.agent;
+            if (agent && agent.id != null)
+                install(agent.ctx, String(agent.id));
+        });
+        stopDisposed = on('agent/disposed', (payload) => {
+            const agent = payload && payload.agent;
+            if (agent && agent.id != null)
+                uninstall(String(agent.id));
+        });
+    }
+    // 已存在的 agent（插件热加载场景）：补注册。
+    try {
+        const agents = typeof ctx.get === 'function' ? ctx.get('agents') : undefined;
+        if (agents && typeof agents.list === 'function') {
+            for (const agent of agents.list()) {
+                if (agent && agent.id != null)
+                    install(agent.ctx, String(agent.id));
+            }
+        }
+    }
+    catch { /* agents 服务不可用 → 仅靠事件 */ }
+    return {
+        invalidate: () => {
+            for (const entry of registrations.values()) {
+                try {
+                    entry.scope?.emit?.('system-prompt/change');
+                }
+                catch { /* 宿主无该事件 → 忽略 */ }
+            }
+        },
+        dispose: () => {
+            if (typeof stopCreated === 'function')
+                stopCreated();
+            if (typeof stopDisposed === 'function')
+                stopDisposed();
+            for (const key of [...registrations.keys()]) {
+                const entry = registrations.get(key);
+                registrations.delete(key);
+                try {
+                    entry?.dispose();
+                }
+                catch { /* ignore */ }
+            }
+        },
+    };
+}
+/**
+ * 官方 `SECTION_ORDERS` 里 2901–4999 是空档，本插件的段全部落在该区间。
+ * 数值本身无外部含义，只决定同一次装配里的相对顺序（小在前）。
+ */
+export const SECTION_ORDER = {
+    /** 场景记忆（rules 服务）。 */
+    sceneMemory: 3000,
+    /** 子智能体人设目录。 */
+    subagents: 3010,
+    /** MCP 服务器状态与用户备注。 */
+    mcpState: 3020,
+};

package/lib/rules/archive-engine.js

@@ -3,7 +3,7 @@
 //                     退出 = 恢复快照 → 落盘自由模式；切换 = 先退后进。
 // 失败语义（fail-closed）：任一步失败即反向恢复运行时并写回旧切片；回滚不全会如实写进错误文本。
 // v2：MCP 段两级（服务器勾选 + '*' / 工具明细），停用表存勾选集的补集，通配由 index.ts 的 guard/restrict 原生支持。
-import { computeMcpPlan, computeMemoriesPlan, computeSkillsPlan, normalizeArchive, snapshotRuntime, hasSection, } from './archive.js';
+import { computeMcpPlan, computeSkillsPlan, normalizeArchive, snapshotRuntime, hasSection, } from './archive.js';
 const msg = (e) => String((e && e.message) || e);
 export function createArchiveEngine(deps) {
     let chain = Promise.resolve();
@@ -20,9 +20,25 @@ export function createArchiveEngine(deps) {
      * 技能只写快照列出的键（这是既有批量通道的语义）：模式期间新增的技能保持现状。
      */
     async function restoreSnapshot(snapshot) {
+        // 顺序与进入时**相反**：先恢复服务器级 / 来源级，再恢复工具级 / 技能级 ——
+        // 来源还关着的时候写技能级策略会被吞掉（`skills/core.js` 的 sourceEnabled 判定）。
+        // 老 snapshot 没有这两栏 → `?? []`，按旧行为只恢复下层。
+        const servers = snapshot.mcpServers ?? [];
+        if (servers.length) {
+            await deps.applyMcpServerSwitches(servers.map((x) => ({ id: x.id, level: x.level, enabled: !x.disabled })));
+        }
+        const sources = snapshot.skillSources ?? [];
+        if (sources.length) {
+            await deps.applySkillSourceSwitches(sources.map((x) => ({ root: x.root, enabled: x.enabled })));
+        }
         const mcp = Object.fromEntries(Object.entries(snapshot.mcp).map(([k, v]) => [k, v.slice()]));
         await deps.applyMcpEntries(mcp);
         await deps.applySkills({ ...snapshot.skills });
+        // 子智能体开关：只停「进入时被这次启用过的」那些（老 snapshot 没有这栏 → []，按旧行为跳过）。
+        const personas = snapshot.subagents ?? [];
+        if (personas.length) {
+            await deps.applySubagentSwitches(personas.map((n) => ({ name: n, enabled: false })));
+        }
     }
     /**
      * 失败回滚：运行时还原 + 切片写回；每步失败都记下来，绝不谎报「已回滚」。
@@ -89,17 +105,11 @@ export function createArchiveEngine(deps) {
                 if (hadKeys && archive.subagents.length === 0)
                     delete archive.subagents;
             }
-            if (archive.memories) {
-                // 记忆段只影响投影（正文是否进 system prompt），不写任何运行时状态；
-                // 这里只把已不存在的记忆 id 剔掉并上报，避免档案里留下指向空气的勾选。
-                const known = await deps.knownMemoryIds();
-                const hadKeys = archive.memories.length > 0;
-                const { stale: memStale } = computeMemoriesPlan(archive.memories, known);
-                stale.push(...memStale);
-                archive.memories = archive.memories.filter((id) => known.has(id));
-                if (hadKeys && archive.memories.length === 0)
-                    delete archive.memories;
-            }
+            // 记忆段（P5 已废弃）：不再写入、不再校验。记忆的开关是 `rules[*].enabled` 单一真相源，
+            // 老档案里残留的 `memories` 字段被忽略（不迁移、不删除，回滚代码时仍可读）。
+            // 保存档案时顺手把残留字段清掉，避免新旧语义并存造成误读。
+            if (archive.memories !== undefined)
+                delete archive.memories;
             const slice = await deps.loadSlice();
             if (Object.keys(archive).length === 0)
                 delete slice.archives[scene];
@@ -147,10 +157,50 @@ export function createArchiveEngine(deps) {
             const archive = slice.archives[target];
             if (!(await deps.sceneExists(target)))
                 return { ok: false, error: `场景不存在: ${target}` };
-            if (!archive || (!hasSection(archive, 'mcp') && !hasSection(archive, 'skills'))) {
-                return { ok: false, error: `场景「${target}」的档案没有 MCP / 技能段（仅记忆或仅子智能体的场景不需要进入模式）` };
+            // 无档案段（纯记忆 / 纯人设场景）**也要能进入**：不应用档案、不建快照，但
+            // `mode.scene` 与 `active` 照常写入。原因有二：
+            //   ① 场景开关（P6）是唯一入口，纯记忆场景点开关不能报错；
+            //   ② 顶部「当前模式」横幅的渲染条件是 `mode.scene`，不写就永远不显示 ——
+            //      用户裁定：无档案场景开开关也要显示横幅，副标题走 `scenes.mode.noProfile`。
+            const appliesArchive = !!archive && (hasSection(archive, 'mcp') || hasSection(archive, 'skills') || hasSection(archive, 'subagents'));
+            // 先算计划、再拍快照：快照只记**将被改动**的服务器行 / 来源 / 人设（带改动前的状态），
+            // 退出时按记录精确恢复 —— 不动用户手动设置的其他行。
+            let mcpPlan = null;
+            let skillsPlan = null;
+            if (appliesArchive && archive) {
+                try {
+                    if (archive.mcp) {
+                        mcpPlan = computeMcpPlan(archive.mcp, {
+                            configuredServers: await deps.configuredServers(),
+                            knownTools: await deps.serverKnownTools(),
+                            serverStates: await deps.mcpServerStates(),
+                        });
+                    }
+                    if (archive.skills) {
+                        skillsPlan = computeSkillsPlan(archive.skills, await deps.knownSkillKeys(), await deps.skillSourceStates());
+                    }
+                }
+                catch (e) {
+                    return { ok: false, error: `读取运行时状态失败（未改动任何东西）：${msg(e)}` };
+                }
             }
-            const snapshot = snapshotRuntime(await deps.currentMcpRaw(), await deps.currentSkills());
+            // 子智能体段：进入时把档案勾选的人设**启用**（子智能体页同步亮起）。
+            // 快照只记「改动前停用」的那些 —— 退出时按名单停回，不动其他行。
+            const boundPersonas = archive && Array.isArray(archive.subagents) ? archive.subagents : [];
+            let personaRestore = [];
+            if (boundPersonas.length) {
+                try {
+                    personaRestore = await deps.disabledPersonas(boundPersonas);
+                }
+                catch (e) {
+                    return { ok: false, error: `读取人设开关状态失败（未改动任何东西）：${msg(e)}` };
+                }
+            }
+            const snapshot = appliesArchive
+                ? snapshotRuntime(await deps.currentMcpRaw(), await deps.currentSkills(), 
+                // 直接用计划带出的 `*Before`（改动前的状态），不在这里反推 —— 反推容易搞反方向。
+                (mcpPlan?.serverSwitches ?? []).map((s) => ({ id: s.id, level: s.level, disabled: s.disabledBefore })), (skillsPlan?.sourceSwitches ?? []).map((s) => ({ root: s.root, enabled: s.enabledBefore })), personaRestore)
+                : null;
             const entered = { ...slice, mode: { scene: target, snapshot }, active: [target] };
             try {
                 await deps.saveSlice({ ...slice, mode: entered.mode });
@@ -160,31 +210,51 @@ export function createArchiveEngine(deps) {
             }
             const stale = [];
             try {
-                if (archive.mcp) {
-                    const plan = computeMcpPlan(archive.mcp, {
-                        configuredServers: await deps.configuredServers(),
-                        knownTools: await deps.serverKnownTools(),
-                    });
-                    stale.push(...plan.stale);
-                    await deps.applyMcpEntries(plan.entries);
+                // ① 先切**上层**（服务器级 / 来源级）——下层只有在上层开着时才有意义：
+                //    服务器没起来，它的工具不存在，工具级停用无从谈起；来源关着，技能级 enable 会被吞掉。
+                if (mcpPlan && mcpPlan.serverSwitches.length) {
+                    await deps.applyMcpServerSwitches(mcpPlan.serverSwitches.map((s) => ({ id: s.id, level: s.level, enabled: s.enabled })));
+                }
+                if (skillsPlan && skillsPlan.sourceSwitches.length) {
+                    await deps.applySkillSourceSwitches(skillsPlan.sourceSwitches.map((s) => ({ root: s.root, enabled: s.enabled })));
+                }
+                // ② 再写**下层**（工具级停用表 / 技能级策略）。
+                if (mcpPlan) {
+                    stale.push(...mcpPlan.stale);
+                    await deps.applyMcpEntries(mcpPlan.entries);
+                }
+                if (skillsPlan) {
+                    stale.push(...skillsPlan.stale);
+                    await deps.applySkills(skillsPlan.target);
                 }
-                if (archive.skills) {
-                    const plan = computeSkillsPlan(archive.skills, await deps.knownSkillKeys());
-                    stale.push(...plan.stale);
-                    await deps.applySkills(plan.target);
+                // ③ 子智能体开关：把档案勾选的人设启用（子智能体页与目录段同步亮起）。
+                if (boundPersonas.length) {
+                    await deps.applySubagentSwitches(boundPersonas.map((n) => ({ name: n, enabled: true })));
                 }
             }
             catch (e) {
-                return await rollback(slice, snapshot, '应用档案', e);
+                // 无档案段时没有运行时改动可回滚（snapshot 为 null）。
+                return snapshot ? await rollback(slice, snapshot, '应用档案', e) : { ok: false, error: `应用档案失败：${String(e?.message || e)}` };
             }
             // ③ 记忆启用集收窄为 {S}（`_shared` 由 resolveActiveScenes 恒常加入；退出不恢复）。
             try {
                 await deps.saveSlice(entered);
             }
             catch (e) {
-                return await rollback(slice, snapshot, '记忆收窄落盘', e);
+                return snapshot ? await rollback(slice, snapshot, '记忆收窄落盘', e) : { ok: false, error: `记忆收窄落盘失败：${String(e?.message || e)}` };
             }
-            return { ok: true, mode: entered.mode, applied: { mcp: !!archive.mcp, skills: !!archive.skills }, stale, narrowedTo: [target] };
+            return {
+                ok: true,
+                mode: entered.mode,
+                applied: { mcp: !!(archive && archive.mcp), skills: !!(archive && archive.skills), subagents: !!(archive && archive.subagents) },
+                // 上层实际切换了几个（0 = 本来就已经是目标状态，界面不必提示"已停用 N 台"）。
+                switched: {
+                    mcpServers: mcpPlan ? mcpPlan.serverSwitches.length : 0,
+                    skillSources: skillsPlan ? skillsPlan.sourceSwitches.length : 0,
+                },
+                stale,
+                narrowedTo: [target],
+            };
         }),
     };
     return { ops, writeOps: new Set(['scene-archive-save', 'scene-mode-set']) };

package/lib/rules/archive.js

@@ -94,20 +94,63 @@ export function computeMcpPlan(mcp, input) {
             if (known.indexOf(t) < 0)
                 stale.push('mcp/' + server + '/' + t);
     }
-    return { entries, wildcards, stale };
+    // 服务器级双向切换：勾选集 = 该场景下的**服务器启停配置**。
+    // 勾了 → 启用；没勾 → 停用。只推入状态需要变化的行。
+    const serverSwitches = [];
+    for (const state of input.serverStates || []) {
+        if (!configured.has(state.serverName))
+            continue;
+        const enabled = mcp[state.serverName] !== undefined;
+        if (state.disabled === !enabled)
+            continue; // 已经是目标状态
+        serverSwitches.push({ id: state.id, serverName: state.serverName, level: state.level, enabled, disabledBefore: state.disabled });
+    }
+    return { entries, wildcards, stale, serverSwitches };
 }
-/** 技能段应用计划：已知技能全集 → 勾选集决定启停。 */
-export function computeSkillsPlan(skills, knownSkillKeys) {
+/**
+ * 技能段应用计划：已知技能全集 → 勾选集决定启停。
+ *
+ * `sourceStates` 传了才会产出 `sourceSwitches`（来源级双向切换）；不传 = 只做技能级。
+ */
+export function computeSkillsPlan(skills, knownSkillKeys, sourceStates) {
     const target = {};
     for (const key of knownSkillKeys)
         target[key] = skills.indexOf(key) >= 0;
     const stale = skills.filter((k) => !knownSkillKeys.has(k)).map((k) => 'skills/' + k);
-    return { target, stale };
+    const sourceSwitches = [];
+    if (sourceStates) {
+        // 该来源下有没有被勾选的技能（只看已知技能，避免 stale 项把来源"点亮"）。
+        const checked = new Set(skills);
+        const onRoots = new Set();
+        for (const key of knownSkillKeys) {
+            if (!checked.has(key))
+                continue;
+            const i = key.indexOf('/');
+            if (i > 0)
+                onRoots.add(key.slice(0, i));
+        }
+        for (const state of sourceStates) {
+            const enabled = onRoots.has(state.root);
+            if (state.enabled === enabled)
+                continue;
+            sourceSwitches.push({ root: state.root, enabled, enabledBefore: state.enabled });
+        }
+    }
+    return { target, stale, sourceSwitches };
 }
-export function snapshotRuntime(mcpRaw, skills) {
+export function snapshotRuntime(mcpRaw, skills, 
+/** **将被档案改动**的服务器行，带改动前的 `disabled`。 */
+mcpServers = [], 
+/** **将被档案改动**的来源，带改动前的 `enabled`。 */
+skillSources = [], 
+/** **将被档案启用**的人设名（改动前停用的子集；退出时按此停回）。 */
+subagents = []) {
     return {
         mcp: Object.fromEntries(Object.entries(mcpRaw).map(([k, v]) => [k, v.slice()])),
         skills: { ...skills },
+        mcpServers: mcpServers.map((x) => ({ id: x.id, level: x.level, disabled: x.disabled })),
+        skillSources: skillSources.map((x) => ({ root: x.root, enabled: x.enabled })),
+        ...(subagents.length ? { subagents: subagents.slice() } : {}),
     };
 }
 // ── 记忆勾选（v3）──────────────────────────────────────────────────────────
@@ -115,26 +158,11 @@ export function snapshotRuntime(mcpRaw, skills) {
 // 记忆段与其余三段有一处关键差别：MCP / 技能是**运行时启停**（改了要落表、进/退模式要回滚），
 // 记忆只是**投影**（正文进 system prompt）。所以记忆段不产生"应用计划"、不进模式快照，
 // 而是在渲染时被查询——勾选后下一个请求即生效，退出模式无需回滚任何东西。
-/**
- * 记忆是否应当注入（纯函数，供渲染路径同步调用）。
- *
- * 口径与其余段同构：
- *   - 该记忆所属场景**没有** memories 段 → 全部记忆照常注入（老档案 = 未定义 = 不碰）；
- *   - 有段 → 只有列在段里的记忆注入（段已定义但空 = 该场景记忆全部不注入）。
- *
- * 入参 `sceneEnabled` 是索引里的单条启停（`enabled === false` 的条目在上游已被过滤，
- * 这里只为把两种"不注入"的原因分开，便于体检报告区分）。
- */
-export function memoryAllowed(archives, scene, id) {
-    const archive = archives ? archives[scene] : undefined;
-    if (!archive || archive.memories === undefined)
-        return true;
-    return archive.memories.indexOf(id) >= 0;
-}
-/**
- * 记忆段的 stale 上报（档案保存时调用）：段里引用了已经不存在的记忆 id。
- * 记忆段不写任何运行时状态，因此除 stale 外没有别的计划产物。
- */
-export function computeMemoriesPlan(memories, knownMemoryIds) {
-    return { stale: memories.filter((id) => !knownMemoryIds.has(id)).map((id) => 'memories/' + id) };
-}
+// P5（2026-09-15）已删除 `memoryAllowed` 与 `computeMemoriesPlan`：
+// 记忆的注入条件改为**单一真相源** `rules[*].enabled`，场景档案不再持有 `memories` 段。
+// 原因是「两个开关串联 + 两步操作」——用户必须先建段、再逐条勾，而且记忆页与档案页
+// 各显示一半状态，看起来永远对不上。现在档案弹窗里的记忆勾选直接读写 `enabled`，
+// 与记忆页同一个写入口，天然一致。
+//
+// 老档案兼容：`archives[*].memories` 字段被**忽略**，不做自动迁移。影响可控 ——
+// 段内记忆的 `enabled` 通常本就是 true，忽略后行为不变。