dsh-plugin-tool-management 0.13.0 → 0.14.0

package/lib/tools/memory.js

@@ -1,15 +1,32 @@
-// 记忆（rules）域的 model 工具（2026-09-19 从 index.ts 的注册区抽出）：
-// memory_manager_list / _read / _write / _set_enabled / _update。
+// 记忆（rules）域的 model 工具（2026-09-19 从 index.ts 的注册区抽出；2026-09-23 改名合并、
+// 同日把场景能力分出去）：memory_manager_list / _read / _switch / _save。
+//
+// 为什么族名在 0.14.0 里绕了一圈回到 `memory_manager_`：中途改成 `scene_memory_manager_`
+// 是为了跟注入段名（`scene-memory-manager-catalog`）对齐，但那个名字描述的是**域**，
+// 而这个族操作的全是记忆。加场景能力时这个错配就现形了 —— 场景是另一个对象（容器，
+// 进入时切换 mcp / 技能 / 人设），硬塞进 `save` 会让 `description` 变成双义参数（给
+// `memory` 时是记忆描述、给 `scene` 时是场景描述），门禁也得按参数分叉（记忆写入有开关
+// 可放行，场景写入是改运行时环境、不该有那条路）。所以拆成两族：这里管记忆内容，
+// `scene_manager_*`（tools/scene.ts）管场景本身。
+//
+// 场景清单也不挂在这条 list 的尾巴上（同日第四轮裁定：「记忆就管记忆，场景就管场景」）——
+// 它在 `scene_manager_list`，理由记在 tools/scene.ts 头部，别当"少写了一段"再加回来。
+//
+// 为什么 write + update 并成 save：两者的判定（同名 = 改、无同名 = 建）本来就只有
+// `rules-create` 知道 —— 它对同名是**拒绝**的，op 层不会替你 upsert。分开两条工具时，
+// 模型必须自己先查一次再决定调哪条，而它手里的清单可能已经过期。合并后由工具侧兜住。
 //
 // 活动场景的记忆正文会自动注入上下文（无需调用工具读取）；这里的工具用于查询/编辑规则
-// 本身。memory_manager_write 受 tools/pre-execute 审批门禁（D2）。
+// 本身。memory_manager_save 受 tools/pre-execute 审批门禁（D2）。
 // 路径锚点：$DSH_HOME/tool-management/memories/<场景>/…（场景 `global` = 界面「全局」）。
 import { text } from './deps.js';
 export function buildMemoryTools(deps) {
     const { defineTool, register } = deps;
     register(defineTool({
         name: 'memory_manager_list',
-        description: 'List memories (id, scene, enabled, description). What is injected each turn is in the「本机当前的场景和记忆」reminder; use this for ids/paths and for entries that are off. Defaults to the ones that would be injected; all=true for every entry.',
+        // 末尾**不点名** `scene_manager_list`：场景一族在出厂默认里就是关着的，指向一条模型没有的
+        // 工具只会让它去猜名字（用户 2026-09-23 把默认名单扩到十五条时去掉的这句）。
+        description: 'List memories (id, scene, enabled, description) plus the scene injection currently follows. What is injected each turn is in the「本机当前的记忆」reminder; use this for ids and for entries that are off. all=true lists everything.',
         parameters: {
             group: { type: 'string', description: 'Optional scene filter.' },
             all: { type: 'boolean', description: 'Include memories that are off, in an inactive scene, or shadowed (default false).' },
@@ -38,43 +55,56 @@ export function buildMemoryTools(deps) {
             const shown = showAll ? rows : rows.filter((row) => row.injects);
             const lines = shown.map(({ x, label }) => ('- ' + x.id + ' [' + (x.group || '未归属场景') + '] ' + label +
                 (x.description ? ' — ' + x.description : '')));
-            const scenes = (r.scenes || []).map((s) => (s.label || s.name) + (s.active ? '(启用)' : '(未启用)')).join('、');
+            // 注入按哪个场景走 —— 上面那句「场景未启用」只有配上它才可解读：少了这一行，
+            // 模型看到一片"未启用"会以为是条目自己的问题。（场景本身的清单在 `scene_manager_list`，
+            // 2026-09-23 拆过去了；这里只留"记忆按哪一集注入"，因为那是记忆域自己的现状。）
+            const scope = r.activeMode === 'all'
+                ? '全部场景（历史默认，未收窄）'
+                : (r.activeScene ? '「' + String(r.activeScene) + '」' : '未启用任何场景');
             const header = '记忆：' + (showAll
                 ? rows.length + ' 条'
                 : shown.length + ' 条会注入 / 共 ' + rows.length + ' 条' +
-                    (shown.length === rows.length ? '' : '（传 all=true 看全部）')) + '\n';
+                    (shown.length === rows.length ? '' : '（传 all=true 看全部）')) +
+                '\n注入范围：' + scope + ' + global（global 恒常注入）\n';
             // 注入边界：压制型预设（persona complete / 关闭运行时上下文）下本插件默认不注入，
             // 此时列出的记忆**不在**模型上下文里。必须说出来，否则模型会假设自己已经看到正文。
             const notice = await deps.reachNoticeForAgent(deps.presetRoster(), exec && exec.agent && exec.agent.ctx, deps.injectNoticeOptions());
-            return header + (lines.join('\n') || '(无记忆)') +
-                '\n场景：' + (scenes || '(无)') + (r.activeMode === 'all' ? '（默认全部启用）' : '（已收窄）') + notice;
+            return header + (lines.join('\n') || '(无记忆)') + notice;
         },
     }));
     register(defineTool({
         name: 'memory_manager_read',
         description: 'Read the full body of one memory. Only for ones not already in your context (disabled, scene not active, or dropped by the byte budget).',
         parameters: {
-            id: { type: 'string', required: true, description: 'Memory id like <scene>/<name>.' },
+            memory: { type: 'string', required: true, description: 'Memory id like <scene>/<name>.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args) {
-            const r = await deps.rulesOps['rules-read'](args);
+            // op 的字段名是 `id`，不改 op：这里显式转换（键名对模型是 `<场景>/<名字>`，对 op 是 `id`）。
+            const r = await deps.rulesOps['rules-read']({ id: String((args && args.memory) || '') });
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || '读取规则失败');
             return '# ' + r.rule.id + '\n\n' + (r.rule.body || '');
         },
     }));
     register(defineTool({
-        name: 'memory_manager_set_enabled',
+        name: 'memory_manager_switch',
+        // 为什么叫 `_switch` 而不是 `_set_enabled`（2026-09-23 用户裁定）：六个域里"拨一个开关"
+        // 是同一件事，名字该同形 —— `mcp_manager_switch` 早就是这个名字，`_set_enabled` 只剩
+        // 记忆 / 技能 / 人设三族在叫。**参数保留 `enabled` 布尔**：这里没有 `restart` 那第三个
+        // 动词，`action: 'on' | 'off'` 只会在 `true`/`false` 之上多一层映射、多付一段 schema。
+        // 旧名不注册别名（同 0.14.0 的口径：注册就进工具表、就要付 token）；用户的旧设置由
+        // `tools/table.ts` 的 `LEGACY_TOOL_NAME_MAP` 翻译。
+        //
         // 为什么单独一个工具：注入实况里「这个域注入了几次 / 模型调了几次」都看得到，但模型此前
         // 看得到一份记忆却开关不了它 —— 只能回一句"请你去界面上点"。启停是它替用户调整环境时
         // 最常碰的一格，而 `rules-toggle` 这个 op 早就带齐了门禁（写令牌 + 场景冻结）。
         // 三个写侧工具共用一句 consent（`Only when the user asks or approves.` / `Only on the
         // user's instruction.`）：这些动的都是"以后每一轮都会带上"的东西，模型不该顺手做。
-        // 描述同时按"省 token"重写了一遍 —— 这 20 段文字每次请求都要发出去，废话是常驻成本。
+        // 描述同时按"省 token"重写了一遍 —— 这几段文字每次请求都要发出去，废话是常驻成本。
         description: 'Enable or disable one memory (index switch; the .md file is untouched). Disabled memories stop being injected, freeing the byte budget. Prefer this over deleting — it is reversible. Only when the user asks or approves.',
         parameters: {
-            id: { type: 'string', required: true, description: 'Memory id like <scene>/<name> (from memory_manager_list).' },
+            memory: { type: 'string', required: true, description: 'Memory id like <scene>/<name>.' },
             enabled: { type: 'boolean', required: true, description: 'true = enable, false = disable; omission is refused.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
@@ -82,12 +112,17 @@ export function buildMemoryTools(deps) {
             const blocked = await deps.lockedSceneGuard();
             if (blocked)
                 throw new Error(blocked);
-            const r = await deps.rulesOps['rules-toggle'](args);
+            const memory = String((args && args.memory) || '');
+            // `enabled` 必须是布尔：`rules-toggle` 缺了它直接拒（ops/memory.ts），但那是给用户看的
+            // 中文 op 错；这里先挡一句说清"这条工具要什么"。
+            if (typeof (args && args.enabled) !== 'boolean')
+                throw new Error('缺少参数：enabled 必须是 true 或 false');
+            const r = await deps.rulesOps['rules-toggle']({ id: memory, enabled: args.enabled });
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || '切换记忆启停失败');
             const rule = r.rule || {};
-            // 「启用了一条不在启用场景里的记忆」是一次静默无效：单条开关拨上去了,注入集里却没有它。
-            // 这一句不说,模型会以为已经生效 —— 与 skill_manager_set_enabled 说清影子副本同一条理由。
+            // 「启用了一条不在启用场景里的记忆」是一次静默无效：单条开关拨上去了，注入集里却没有它。
+            // 这一句不说，模型会以为已经生效 —— 与 skill_manager_switch 说清影子副本同一条理由。
             let sceneNote = '';
             try {
                 const all = await deps.rulesOps['rules-list']({});
@@ -101,87 +136,103 @@ export function buildMemoryTools(deps) {
             catch {
                 sceneNote = '';
             }
-            return 'OK: memory ' + String(rule.id || args.id) + ' ' + (rule.enabled === false ? 'disabled' : 'enabled') + sceneNote;
-        },
-    }));
-    register(defineTool({
-        name: 'memory_manager_update',
-        description: 'Update a memory: body, description, or name (renaming keeps the old file in the trash). Omit a field to keep it — this merges. Read it with memory_manager_read first and change one part rather than restating the file; if a memory already covers this, update that one instead of adding a second. Only on the user\'s instruction.',
-        parameters: {
-            id: { type: 'string', required: true, description: 'Memory id like <scene>/<name> (from memory_manager_list).' },
-            body: { type: 'string', description: 'New Markdown body (<=256 KiB, non-empty). Omit to keep the current body.' },
-            description: { type: 'string', description: 'New one-sentence description (<=500 chars). Empty string = drop it and re-derive from the body; omit = keep.' },
-            name: { type: 'string', description: 'New memory name (= file name). Omit to keep it.' },
-        },
-        output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
-        async execute(args) {
-            const blocked = await deps.lockedSceneGuard();
-            if (blocked)
-                throw new Error(blocked);
-            // 三个可改字段一个都没给 → 直接拒。`rules-update` 会按"保留现有"落一次盘并刷新
-            // updatedAt,模型以为改了点什么,其实只是把文件重写了一遍。
-            const touches = ['body', 'description', 'name'].filter((k) => args[k] !== undefined);
-            if (!touches.length)
-                throw new Error('没有要改的东西：body / description / name 至少给一个');
-            const r = await deps.rulesOps['rules-update'](args);
-            if (!r || r.ok === false)
-                throw new Error((r && r.error) || '更新记忆失败');
-            const rule = r.rule || {};
-            return 'OK: updated ' + String(rule.id || args.id) + '（改了 ' + touches.join('、') + '）' +
-                (rule.id && String(rule.id) !== String(args.id) ? ' → 现在是 ' + rule.id : '');
+            return 'OK: memory ' + String(rule.id || memory) + ' ' + (rule.enabled === false ? 'disabled' : 'enabled') + sceneNote;
         },
     }));
     register(defineTool({
-        name: 'memory_manager_write',
+        name: 'memory_manager_save',
         // 「能推导的别记」「先查重」这两句是 0.13.0 加的：记忆是唯一直接吃注入预算的域
         // （场景段 128 KiB），而模型很乐意把「这个项目用 pnpm」记一条 —— 那看一眼 `package.json`
-        // 就知道，记下来却永久占着每一轮请求。
-        description: 'Create a memory (the scene must already exist; global is the always-on one). Memories cost context on EVERY later request, so record only what cannot be re-derived from code, config or git, and check the list for one that already says this — update that instead of adding a near-duplicate. Only on the user\'s instruction.',
+        // 就知道，记下来却永久占着每一轮请求。合并 write/update 后这两句更要留：upsert 降低了
+        // "再记一条"的摩擦，而摩擦正是这里唯一拦得住它的东西。
+        description: 'Create a memory, or update the one that already has this id — the receipt says which happened. Memories cost context on EVERY later request, so record only what cannot be re-derived from code, config or git, and check the list for one that already says this — update that instead of adding a near-duplicate. Only on the user\'s instruction.',
         parameters: {
-            group: { type: 'string', required: true, description: 'Scene name (no path separators or < > : " | ? *); `global` = the always-on scene.' },
-            name: { type: 'string', required: true, description: 'Memory name = .md file name without extension; <=64 chars, no path separators or < > : " | ? *, must not start with a dot.' },
-            description: { type: 'string', required: true, description: 'One-sentence description (<=500 chars).' },
-            body: { type: 'string', required: true, description: 'Markdown body (<=256 KiB).' },
+            memory: { type: 'string', required: true, description: 'Memory id like <scene>/<name> — copy it from the list. `global` is the always-on scene.' },
+            description: { type: 'string', description: 'One-sentence description (<=500 chars). Required when creating. Empty string = drop it and re-derive from the body; omit = keep.' },
+            body: { type: 'string', description: 'Markdown body (<=256 KiB). Required when creating. Omit to keep the current body.' },
+            nextName: { type: 'string', description: 'New memory name (= file name); omit to keep it. The old file goes to the trash.' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args) {
             const blocked = await deps.lockedSceneGuard();
             if (blocked)
                 throw new Error(blocked);
-            // 先扫一遍已有的：疑似重复只**说出来**，不拒绝 —— 猜错一次就把该记的东西记不下去，
-            // 比多记一条代价大得多；而且"像不像同一条"本来就是人判断的事。
-            const norm = (value) => String(value ?? '').toLowerCase().replace(/\s+/g, ' ').trim();
-            const wantName = norm(args && args.name);
-            const wantDesc = norm(args && args.description);
-            let similar = [];
-            try {
-                const before = await deps.rulesOps['rules-list']({});
-                if (before && before.ok !== false) {
-                    similar = (before.rules || [])
-                        .filter((x) => {
-                        const have = norm(x.name);
-                        const desc = norm(x.description);
-                        if (have === wantName)
-                            return true;
-                        if (wantDesc !== '' && desc !== '' && desc === wantDesc)
-                            return true;
-                        // 名字互相包含：只在两边都不短于 4 个字符时算，否则 "git" 会把所有条目都匹配上。
-                        return have.length >= 4 && wantName.length >= 4 && (have.includes(wantName) || wantName.includes(have));
-                    })
-                        .map((x) => String(x.id))
-                        .slice(0, 3);
-                }
+            const memory = String((args && args.memory) || '').trim();
+            // 拆成 `<场景>/<名字>`：要求两段都非空。**不做"没有斜杠就落 global"的兜底** —— 那会把
+            // 一次拼错的 id 变成一条"每轮都注入"的全局记忆，而清单上看起来完全正常。
+            // 清单里打印的就是 `<场景>/<名字>`，照抄比拼装准（§2 规则一）。
+            const slash = memory.indexOf('/');
+            if (slash <= 0 || slash === memory.length - 1) {
+                throw new Error('memory 必须是 <场景>/<名字> 两段（照抄清单里那一行；全局场景写 global/<名字>）：' + (memory || '(空)'));
             }
-            catch { /* 查重读不到就当没查到：它不该拦住写入 */ }
-            const r = await deps.rulesOps['rules-create'](args);
+            const group = memory.slice(0, slash);
+            const name = memory.slice(slash + 1);
+            // 先取全量：既用来定位（命中 = 改、未命中 = 建），也是查重的数据源。判定必须在工具
+            // 这一侧 —— `rules-create` 对同名是**拒绝**的（`error.rules.exists`），op 不会 upsert。
+            const all = await deps.rulesOps['rules-list']({});
+            if (!all || all.ok === false)
+                throw new Error((all && all.error) || '读取规则失败');
+            const hit = (all.rules || []).find((x) => String(x.id) === memory);
+            if (hit) {
+                // 改的分支一律 read-modify-write（省略 = 保持），因为 `rules-update` 是整份重写。
+                // 三个可改字段一个都没给就拒：op 会按"保留现有"落一次盘并刷新 updatedAt，
+                // 模型以为改了点什么，其实只是把文件重写了一遍。
+                const touched = ['body', 'description', 'nextName'].filter((k) => args[k] !== undefined);
+                if (!touched.length)
+                    throw new Error('没有要改的东西：body / description / nextName 至少给一个');
+                const payload = { id: memory };
+                // 只带模型真给过的键：`description` 传空串在 op 里是"删除并重新派生"，与"未给"是两种
+                // 意图，都必须原样透传 —— 所以用 `!== undefined` 而不是真值判断。
+                if (args.body !== undefined)
+                    payload.body = args.body;
+                if (args.description !== undefined)
+                    payload.description = args.description;
+                if (args.nextName !== undefined)
+                    payload.name = args.nextName;
+                const r = await deps.rulesOps['rules-update'](payload);
+                if (!r || r.ok === false)
+                    throw new Error((r && r.error) || '更新记忆失败');
+                const rule = r.rule || {};
+                return 'OK: updated ' + String(rule.id || memory) + '（改了 ' + touched.join('、') + '）' +
+                    (rule.id && String(rule.id) !== memory ? ' → 现在是 ' + rule.id : '');
+            }
+            // 建的分支：正文与描述都必填。`rules-create` 自己会拒空正文与非法名（ops/memory.ts），
+            // 但那是给用户看的中文 op 错；模型需要的是"这条工具要什么"，所以在工具侧先挡、点名缺哪个。
+            const body = args && args.body !== undefined ? String(args.body) : '';
+            const description = args && args.description !== undefined ? String(args.description) : '';
+            const missing = [
+                body.trim() === '' ? 'body' : '',
+                description.trim() === '' ? 'description' : '',
+            ].filter((x) => x !== '');
+            if (missing.length)
+                throw new Error('新建记忆必须给 ' + missing.join(' 与 ') + '（' + memory + ' 还不存在）');
+            // 查重只**说出来**，不拒绝 —— 猜错一次就把该记的东西记不下去，比多记一条代价大得多；
+            // 而且"像不像同一条"本来就是人判断的事。只在建的分支提示：改的分支没有"再记一条"的风险。
+            const norm = (value) => String(value ?? '').toLowerCase().replace(/\s+/g, ' ').trim();
+            const wantName = norm(name);
+            const wantDesc = norm(description);
+            const similar = (all.rules || [])
+                .filter((x) => {
+                const have = norm(x.name);
+                const desc = norm(x.description);
+                if (have === wantName)
+                    return true;
+                if (wantDesc !== '' && desc !== '' && desc === wantDesc)
+                    return true;
+                // 名字互相包含：只在两边都不短于 4 个字符时算，否则 "git" 会把所有条目都匹配上。
+                return have.length >= 4 && wantName.length >= 4 && (have.includes(wantName) || wantName.includes(have));
+            })
+                .map((x) => String(x.id))
+                .slice(0, 3);
+            const r = await deps.rulesOps['rules-create']({ group, name, description, body });
             if (!r || r.ok === false)
                 throw new Error((r && r.error) || '创建规则失败');
             // 刚建好的这条自己会在列表里，从名单里去掉。
-            similar = similar.filter((id) => id !== String(r.rule.id));
-            const dup = similar.length
-                ? `\n注意：已有 ${similar.length} 条名字或描述与它很像（${similar.join('、')}）—— 若是同一件事，改那一条而不是留着两条。`
+            const dup = similar.filter((id) => id !== String(r.rule.id));
+            const warn = dup.length
+                ? `\n注意：已有 ${dup.length} 条名字或描述与它很像（${dup.join('、')}）—— 若是同一件事，改那一条而不是留着两条。`
                 : '';
-            return 'OK: memory ' + r.rule.id + '（场景「' + (r.rule.group || '未归属') + '」启用后自动生效）' + dup;
+            return 'OK: created ' + r.rule.id + '（场景「' + (r.rule.group || '未归属') + '」启用后自动生效）' + warn;
         },
     }));
 }

package/lib/tools/prompt.js

@@ -3,35 +3,46 @@
 //
 // 模型可查、可切，**不能造 / 不能删** —— 避免模型乱删用户预设。
 import { join } from 'node:path';
+import { normalizePresetDescription } from '../prompts/service.js';
 import { text } from './deps.js';
 export function buildPromptTools(deps) {
     const { defineTool, register } = deps;
     register(defineTool({
         name: 'prompt_manager_list',
-        description: 'List AGENTS.md presets (id, active state, file path); read that file for a preset body. The one in effect is in the「本机提示词」reminder, whose「来源：」line names the file. Defaults to the one in effect; all=true for the whole library.',
+        description: 'List AGENTS.md presets (id, description, active state, file path); read that file for a preset body. The one in effect is in the「本机提示词」reminder, whose「来源：」line names the file. Defaults to the one in effect; all=true for the whole library.',
         parameters: {
             all: { type: 'boolean', description: 'Include inactive presets (default false).' },
         },
         output: { schema: { type: 'string' }, render: (_a, v) => text(v) },
         async execute(args, exec) {
             const showAll = Boolean(args && args.all === true);
-            const r = await deps.promptsService.list();
-            if (!r.ok)
-                throw new Error(r.error);
+            const r = await deps.promptOps['agentsmd-list']({});
+            if (!r || r.ok === false)
+                throw new Error((r && r.error) || '读取提示词预设失败');
             const all = r.presets || [];
             // 默认只列「当前这份 ~/.dsh/AGENTS.md 是从哪个预设来的」（用户裁定 2026-09-16）。
-            // 判定分两级：内容逐字节相同 = 生效；否则看服务层记下的「最近一次应用」——
-            // 用户手改过全局文件时，第二级仍能给出答案，不必退化成全列（那会白烧上下文）。
+            // 判定分两级：`active`（场景驱动时 = 场景绑的那份；否则 = 内容逐字节相同）优先，
+            // 否则看服务层记下的「最近一次应用」—— 用户手改过全局文件时，第二级仍能给出答案，
+            // 不必退化成全列（那会白烧上下文）。
             const active = all.filter((p) => p.active === true);
             const fallback = active.length ? active : all.filter((p) => p.lastApplied === true);
             const shown = showAll ? all : fallback;
-            // 路径这一列是「名单 → 全文」的闭环：预设正文既不进提示词、也没有读取工具，
-            // 给出文件路径让模型用宿主的文件工具读，比再造一个 read 工具省一条常驻 schema。
+            // 三列各有用途：
+            //   · 路径 —— 「名单 → 全文」的闭环。预设正文既不进提示词、也没有读取工具，给出文件
+            //     路径让模型用宿主的文件工具读，比再造一个 read 工具省一条常驻 schema。
+            //   · 描述 —— 0.14.0 加的。模型要能在预设之间做选择，而 id 本身不说明用途。描述在
+            //     这里按 `DEFAULT_PRESET_DESC_MAX_LENGTH` 压行截断（与 MCP 备注同一条口径），
+            //     因为它从这一版起是**常驻成本**而不是"只给使用者看"。
+            //   · mark —— `activeVia` 必须打出来：`fileApplied` 但场景绑着别的，说明文件里那份
+            //     已经**不生效**了。0.14.0 之前这里会错报成 [active]（那正是被修掉的那句假话）。
             const summary = shown.map((p) => {
-                const mark = p.active ? ' [active]'
-                    : p.lastApplied ? ' [last applied — ~/.dsh/AGENTS.md has changed since]'
-                        : '';
-                return p.id + mark + ' | ' + join(deps.promptsDir, p.id, 'AGENTS.md');
+                const mark = p.active
+                    ? (p.activeVia === 'scene' ? ' [active via scene]' : ' [active via file]')
+                    : (p.fileApplied
+                        ? ' [matches ~/.dsh/AGENTS.md, but a scene binding drives the baseline]'
+                        : (p.lastApplied ? ' [last applied — ~/.dsh/AGENTS.md has changed since]' : ''));
+                const desc = normalizePresetDescription(p.description);
+                return p.id + mark + ' | ' + (desc || '(no description)') + ' | ' + join(deps.promptsDir, p.id, 'AGENTS.md');
             });
             const header = 'AGENTS.md presets: ' + (showAll
                 ? all.length + ' in the library'
@@ -64,7 +75,10 @@ export function buildPromptTools(deps) {
             if (r.viaScene) {
                 return 'OK: preset ' + args.id + ' is now the prompt binding of scene 「' + (r.scene || '') + '」 and the scene was re-synced (effective next turn; ~/.dsh/AGENTS.md now carries that scene\'s binding).';
             }
-            return 'OK: preset ' + args.id + ' applied to ~/.dsh/AGENTS.md (next session; current session unchanged' + (r.backedUp ? '; previous backed up to __last-applied__' : '') + ')';
+            // 生效时机与宿主行为对齐（index.ts 提示词服务一节考证过）：dsh-agent-instructions
+            // 每个 pre-step 都 stat 比对版本，写文件即下一轮重读 —— 不是"下个会话"。说错了
+            // 模型会劝用户重开会话，而其实下一句话就已经在新基线下跑。
+            return 'OK: preset ' + args.id + ' applied to ~/.dsh/AGENTS.md — effective next turn' + (r.backedUp ? ' (previous backed up to __last-applied__)' : '');
         },
     }));
 }