dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/ops/snapshot.js

@@ -14,8 +14,9 @@
 //      导出物不该顺手把它们带走；要完整导出必须显式传 `includeSecrets:true`（界面二次确认）。
 //      打码值导回来由 `secret-guard` 拿目标机的旧真值顶替（`mcpm-import` 既有的行为）。
 import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
+import { basename, join, resolve } from 'node:path';
 import { unzipSync, zipSync } from 'fflate';
+import { maskSecretValue, maskUrlQuery } from '../mcp/secret-guard.js';
 const SNAP_PREFIX = 'dsh-tool-management-snapshot-';
 /** 快照目录里各部分的名字（导入侧按这些名字找东西，别改）。 */
 const F_MANIFEST = 'manifest.json';
@@ -25,11 +26,11 @@ const F_SCENES = 'scenes.json';
 const D_MEMORIES = 'memories';
 const D_SUBAGENTS = 'subagents';
 const D_PROMPTS = 'prompts';
+const D_QUICK = 'quick-prompts';
 const D_SKILLS = 'skills';
-/** 三个"文件域"：整个目录打进一份 zip，键是相对路径。 */
-const FILE_DOMAINS = [D_MEMORIES, D_SUBAGENTS, D_PROMPTS];
-const ALL_DOMAINS = ['mcp', D_MEMORIES, D_SUBAGENTS, D_PROMPTS, D_SKILLS, 'settings', 'scenes'];
-const MASKED = '••••••';
+/** 四个"文件域"：整个目录打进一份 zip，键是相对路径。 */
+const FILE_DOMAINS = [D_MEMORIES, D_SUBAGENTS, D_PROMPTS, D_QUICK];
+const ALL_DOMAINS = ['mcp', D_MEMORIES, D_SUBAGENTS, D_PROMPTS, D_QUICK, D_SKILLS, 'settings', 'scenes'];
 function stamp() {
     return new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
 }
@@ -86,7 +87,7 @@ function namesOf(res, prefer) {
         return [];
     const bags = [res.data, res].filter(Boolean);
     for (const bag of bags) {
-        for (const key of ['rows', 'personas', 'presets', 'scenes', 'skills', 'list', 'entries', 'items']) {
+        for (const key of ['rows', 'personas', 'presets', 'prompts', 'scenes', 'skills', 'list', 'entries', 'items']) {
             const arr = bag[key];
             if (!Array.isArray(arr))
                 continue;
@@ -110,6 +111,43 @@ function namesOf(res, prefer) {
     }
     return [];
 }
+/**
+ * 从 `skill-state` 的返回里取「<来源>/<技能名>」清单。
+ *
+ * 为什么不能复用 `namesOf`（2026-09-30 审查 P1-6）：`skill-state` 的形状是
+ * `{ ok, data: { roots: [{ key, skills: [{ name, declaredName, … }] }] } }` —— 顶层键是
+ * `roots`，而 `namesOf` 只找 `rows / personas / presets / scenes / skills / list / entries /
+ * items` 这些**数组**键，一个都对不上 → 恒返回 `[]` → 技能域**永远导出 0 项**，而界面显示的
+ * 是"迁移完成"。key 用**声明名**（frontmatter `name`），口径与 `index.ts` 的
+ * `skillArchiveKeysOfRoot` 一致（档案里存的就是声明名，用条目名拼会在 stale 校验里被丢掉）。
+ */
+function skillKeysOf(res) {
+    if (!res || res.ok === false)
+        return [];
+    for (const bag of [res.data, res].filter(Boolean)) {
+        const roots = bag.roots;
+        if (!Array.isArray(roots))
+            continue;
+        const out = [];
+        for (const root of roots) {
+            const rootKey = String(root?.key || '');
+            if (!rootKey)
+                continue;
+            const skills = root.skills;
+            if (!Array.isArray(skills))
+                continue;
+            for (const sk of skills) {
+                const s = sk;
+                const name = String((s && (s.declaredName || s.name)) || '');
+                if (name)
+                    out.push(rootKey + '/' + name);
+            }
+        }
+        if (out.length)
+            return out;
+    }
+    return [];
+}
 /** 场景清单（带 label / description / 提示词绑定）：`rules-list` 的 scenes 那一栏，读不到就是空。 */
 function sceneRecordsOf(res) {
     const bags = [res && res.data, res].filter(Boolean);
@@ -128,11 +166,18 @@ function sceneRecordsOf(res) {
     }
     return [];
 }
+/**
+ * 键值对打码：**走 `secret-guard` 的唯一口径**（`$VAR` / `!!js` 这类间接引用原样保留）。
+ *
+ * 这里曾经自己写了一份「所有键一律打成 `••••••`」的版本 —— 与 MCP 列表视图的口径不一致，
+ * 结果是配置里的间接引用被当成密钥导出、导回来时 `resolveMaskedKv` 顶替不出真值只能丢键。
+ * 打码形态只允许有一处定义（审查 P0-4）。
+ */
 function maskKv(map) {
     const out = {};
     if (map && typeof map === 'object' && !Array.isArray(map)) {
         for (const k of Object.keys(map))
-            out[k] = MASKED;
+            out[k] = maskSecretValue(map[k]);
     }
     return out;
 }
@@ -175,8 +220,14 @@ export function createSnapshotOps(deps) {
                 copy.env = maskKv(copy.env);
             if (copy.headers)
                 copy.headers = maskKv(copy.headers);
+            // URL 查询串走 `secret-guard.maskUrlQuery`（与 MCP 列表视图同一口径）。这里原先是**自写的
+            // 一条窄正则** `([?&](?:key|token|secret|password)=)`，只认四个固定参数名 ——
+            // `?api_key=` / `?access_token=` / `?sig=` / `?client_secret=` 这类 MCP 托管服务最常见的
+            // 形态全部漏掉，而这正是「凭据挂在 URL 上」的主流写法。后果不是界面显示问题：默认
+            // （`includeSecrets` 缺省 false）导出的 `mcp.json` 里就是**明文凭据**，而这份目录的用途
+            // 就是拷去 U 盘 / 网盘 / 另一台机器（审查 P0-4）。
             if (typeof copy.url === 'string')
-                copy.url = copy.url.replace(/([?&](?:key|token|secret|password)=)[^&]*/gi, '$1' + MASKED);
+                copy.url = maskUrlQuery(copy.url);
             return copy;
         });
         try {
@@ -186,11 +237,12 @@ export function createSnapshotOps(deps) {
             return { ok: false, error: '写 mcp.json 失败: ' + deps.message(e) };
         }
         domains.mcp = mcpOut.length;
-        // ── 文件域：记忆 / 子智能体 / 提示词，各打进一份 zip（键 = 相对路径）──────────
+        // ── 文件域：记忆 / 子智能体 / 提示词 / 快捷提示词，各打进一份 zip（键 = 相对路径）──
         const roots = {
             [D_MEMORIES]: deps.hubPath(D_MEMORIES),
             [D_SUBAGENTS]: deps.hubPath(D_SUBAGENTS),
             [D_PROMPTS]: deps.promptsDir(),
+            [D_QUICK]: deps.quickPromptsDir(),
         };
         for (const kind of FILE_DOMAINS) {
             const files = await walk(roots[kind]);
@@ -215,7 +267,7 @@ export function createSnapshotOps(deps) {
         }
         // ── 技能：源目录在外部（不在 hub），交给既有的 `bundle-export` 走它自己的收集路径 ──
         const skillState = await deps.invokeOp('skill-state', {});
-        const skillKeys = namesOf(skillState, ['key']).filter((k) => k.indexOf('/') > 0);
+        const skillKeys = skillKeysOf(skillState);
         if (!skillKeys.length)
             notes.push('技能这次没导出：没从 skill-state 读到「<来源>/<名字>」形态的清单');
         if (skillKeys.length) {
@@ -302,6 +354,7 @@ export function createSnapshotOps(deps) {
             mcp: namesOf(await deps.invokeOp('mcpm-list', {}), ['serverName']),
             [D_SUBAGENTS]: namesOf(await deps.invokeOp('subagent-list', {}), ['name']),
             [D_PROMPTS]: namesOf(await deps.invokeOp('agentsmd-list', {}), ['id']),
+            [D_QUICK]: namesOf(await deps.invokeOp('quickprompt-list', {}), ['id']),
             [D_MEMORIES]: namesOf(await deps.invokeOp('rules-list', {}), ['id']),
             scenes: sceneRecordsOf(await deps.invokeOp('rules-list', {})).map((r) => r.name),
         };
@@ -385,13 +438,23 @@ export function createSnapshotOps(deps) {
             return { ok: false, error: read.error };
         const { files } = read;
         const report = [];
-        /** 一个域失败只记在这一行上：迁移的意义正是「哪域没过来」看得清，不是整批回滚。 */
+        /**
+         * 一个域失败只记在这一行上：迁移的意义正是「哪域没过来」看得清，不是整批回滚。
+         *
+         * `warning` 也要透传（2026-09-30 审查 P2-9）：各域的 import op 会用它报"带过来了但有
+         * 东西被跳过"（`mcpm-import` 的「这些密钥已是打码占位符，请在编辑里重新填写」就是其中
+         * 最重要的一条）。此前只取 imported/skipped，于是"迁移成功"的界面下藏着一份**需要用户
+         * 动手补的密钥清单**，用户在另一台机器上等到调用工具时才发现。
+         */
         async function run(domain, task) {
             if (domains.indexOf(domain) < 0)
                 return;
             try {
                 const r = await task();
-                report.push({ domain, imported: r.imported, skipped: r.skipped });
+                report.push({
+                    domain, imported: r.imported, skipped: r.skipped,
+                    ...(r.warning ? { warnings: [r.warning] } : {}),
+                });
             }
             catch (e) {
                 report.push({ domain, imported: 0, skipped: 0, error: deps.message(e) });
@@ -404,7 +467,12 @@ export function createSnapshotOps(deps) {
             const res = await deps.invokeOp('mcpm-import', overwrite ? { json: raw, conflict: 'overwrite' } : { json: raw });
             if (!res || res.ok === false)
                 throw new Error(String((res && res.error) || 'mcpm-import 失败'));
-            return { imported: (res.added || []).length + (res.overwritten || []).length, skipped: (res.skipped || []).length };
+            return {
+                imported: (res.added || []).length + (res.overwritten || []).length,
+                skipped: (res.skipped || []).length,
+                // 「打码占位符被跳过」这类结论必须跟着走：它是用户要动手补的清单，不是内部细节。
+                ...(typeof res.warning === 'string' && res.warning ? { warning: res.warning } : {}),
+            };
         });
         await run(D_SUBAGENTS, async () => {
             const zip = files[D_SUBAGENTS + '.zip'];
@@ -428,12 +496,13 @@ export function createSnapshotOps(deps) {
                 throw new Error(String((res && res.error) || 'subagent-import 失败'));
             return { imported: (res.imported || []).length, skipped: skipped + (res.skipped || []).length };
         });
-        await run(D_PROMPTS, async () => {
-            const zip = files[D_PROMPTS + '.zip'];
+        // 两个提示词域同形：`<id>/<正文>` + 可选 `<id>/meta.json`，一次一份地导入。差别只在
+        // 正文文件名与 op 名（快捷域没有独立的 import op，`create` 就是那个形状），所以共用一段。
+        const importPromptLike = (domain, docName, importOp, updateOp) => run(domain, async () => {
+            const zip = files[domain + '.zip'];
             if (!zip)
                 return { imported: 0, skipped: 0 };
             const entries = unzipSync(new Uint8Array(await readFile(zip)));
-            // 提示词的落点是 `<id>/AGENTS.md`（+ 可选 `<id>/meta.json`），而 `agentsmd-import` 一次一份。
             const bodies = {};
             const metas = {};
             let skipped = 0;
@@ -444,7 +513,7 @@ export function createSnapshotOps(deps) {
                     continue;
                 }
                 const text = Buffer.from(bytes).toString('utf8');
-                if (parts[1] === 'AGENTS.md')
+                if (parts[1] === docName)
                     bodies[parts[0]] = text;
                 else if (parts[1] === 'meta.json') {
                     try {
@@ -456,17 +525,17 @@ export function createSnapshotOps(deps) {
             let imported = 0;
             for (const id of Object.keys(bodies)) {
                 const desc = String((metas[id] && metas[id].description) || '');
-                const res = await deps.invokeOp('agentsmd-import', { id, content: bodies[id], description: desc });
+                const res = await deps.invokeOp(importOp, { id, content: bodies[id], description: desc });
                 if (res && res.ok) {
                     imported += 1;
                     continue;
                 }
-                // 同名预设 `agentsmd-import` 一律拒（它不覆盖）。覆盖模式下改走 upsert 那条 update 路径。
+                // 同名一律拒（两个 import 口都不覆盖）。覆盖模式下改走 upsert 那条 update 路径。
                 if (!overwrite) {
                     skipped += 1;
                     continue;
                 }
-                const upd = await deps.invokeOp('agentsmd-update', { id, nextId: id, content: bodies[id], description: desc });
+                const upd = await deps.invokeOp(updateOp, { id, nextId: id, content: bodies[id], description: desc });
                 if (upd && upd.ok)
                     imported += 1;
                 else
@@ -474,6 +543,8 @@ export function createSnapshotOps(deps) {
             }
             return { imported, skipped };
         });
+        await importPromptLike(D_PROMPTS, 'AGENTS.md', 'agentsmd-import', 'agentsmd-update');
+        await importPromptLike(D_QUICK, 'PROMPT.md', 'quickprompt-create', 'quickprompt-update');
         await run(D_MEMORIES, async () => {
             const zip = files[D_MEMORIES + '.zip'];
             if (!zip)
@@ -499,6 +570,7 @@ export function createSnapshotOps(deps) {
                 (byScene[scene] || (byScene[scene] = [])).push({ name, data: Buffer.from(bytes).toString('base64') });
             }
             let imported = 0;
+            const reasons = [];
             for (const scene of Object.keys(byScene)) {
                 const res = await deps.invokeOp('rules-import', { scene, files: byScene[scene] });
                 if (!res || res.ok === false) {
@@ -507,9 +579,19 @@ export function createSnapshotOps(deps) {
                 }
                 const data = res.data || res;
                 imported += (data.imported || []).length;
-                skipped += (data.skipped || []).length;
+                const skippedRows = Array.isArray(data.skipped) ? data.skipped : [];
+                skipped += skippedRows.length;
+                // `rules-import` 的 skipped 是 `{name, reason}` —— 只数个数会把「为什么没过来」
+                // 丢掉，而那正是用户要照着修的东西（名字不合法 / 正文超限 / 附件重名）。
+                // 上限 5 条：这是提示不是日志，界面上一行放不下更多（审查 P2-9 同一条口径）。
+                for (const row of skippedRows.slice(0, 5)) {
+                    const name = String((row && row.name) || '');
+                    const reason = String((row && row.reason) || '');
+                    if (reason)
+                        reasons.push(`${name ? name + '：' : ''}${reason}`);
+                }
             }
-            return { imported, skipped };
+            return { imported, skipped, ...(reasons.length ? { warning: reasons.join('；') } : {}) };
         });
         await run('scenes', async () => {
             if (!files[F_SCENES])
@@ -577,9 +659,26 @@ export function createSnapshotOps(deps) {
             let imported = 0;
             let skipped = 0;
             for (const zip of zips) {
-                const res = await deps.invokeOp('skill-import', overwrite ? { source: zip, conflict: 'overwrite' } : { source: zip });
+                // 走 `skill-upload`（把 zip 读成 base64）而**不是** `skill-import`（2026-09-30 审查 P1-6）：
+                // 导出侧产出的是 `bundle-export` 打的**一个 zip**（内含 `<技能名>/<文件>`），而
+                // `skill-import` 的 `analyzeSource` 用 `lstat` + `endsWith('.md')` 判定来源，**完全不认识
+                // `.zip`** —— 喂过去必然 `error.source.unrecognized`，该域整行报错。zip 的解包只存在于
+                // `skill-upload` 这条链（`importUploadedSkill` → `prepareUploadedSource` → `writeUploadedZip`）；
+                // 已实测它能正确吃下这种形态（`<技能名>/SKILL.md` → 落 `hub/skills/<技能名>/`）。
+                let b64;
+                try {
+                    b64 = (await readFile(zip)).toString('base64');
+                }
+                catch (e) {
+                    throw new Error(`读取技能包失败：${deps.message(e)}`);
+                }
+                const res = await deps.invokeOp('skill-upload', {
+                    name: basename(zip).replace(/\.zip$/i, ''),
+                    zip: b64,
+                    ...(overwrite ? { conflict: 'overwrite' } : {}),
+                });
                 if (!res || res.ok === false)
-                    throw new Error(String((res && res.error) || 'skill-import 失败'));
+                    throw new Error(String((res && res.error) || 'skill-upload 失败'));
                 const data = res.data || {};
                 imported += (data.imported || []).length;
                 skipped += (data.skipped || []).length + (data.failed || []).length;

package/lib/ops/trash.js

@@ -2,7 +2,7 @@
 //
 // 删除进回收站、从回收站恢复、回收站列出与彻底删除。与记忆正文 ops 分域，
 // 但共用 copyIntoMemoriesTrash 等入口，经 MemoriesOpsCtx 显式传入。
-import { copyFile, lstat, mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';
+import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { isValidTrashId } from '../hub.js';
 import { LEGACY_BUNDLE_DOC, bundleDocName, isValidGroupSegment, isValidGroupPath, fail, MEMORIES_TRASH_DIR } from '../memories/constants.js';
@@ -45,7 +45,14 @@ export function buildTrashOps(rc) {
         catch {
             return fail('error.rules.notFound', `回收站条目不存在：${trashId}`);
         }
-        if (!manifest || typeof manifest.name !== 'string' || typeof manifest.group !== 'string' || !isValidGroupSegment(manifest.name)) {
+        if (!manifest || typeof manifest.name !== 'string' || typeof manifest.group !== 'string'
+            || !isValidGroupSegment(manifest.name)
+            // `group` 是**磁盘数据**（manifest.json 可能被手改 / 别的进程写 / 随一份恶意档案包进来），
+            // 而它是拼进 `join(memoriesRoot, group)` 的那一段 —— 只判类型的话 `../..` 就能把正文写到
+            // 记忆根之外（`mkdir({recursive:true})` 还会顺手把目录建出来）。同文件 `rulesTrashList`
+            // 一直是有这道判据的（`if (group !== '' && !isValidGroupPath(group)) continue`），
+            // 两条路径口径必须一致（审查 P0-3）。
+            || (manifest.group !== '' && !isValidGroupPath(manifest.group))) {
             return fail('error.rules.notFound', `回收站条目损坏：${trashId}`);
         }
         // 恢复目标已存在（期间用户重建了同名规则）→ 拒绝，避免覆盖。
@@ -54,14 +61,43 @@ export function buildTrashOps(rc) {
             return fail('error.rules.exists', `同名记忆已存在：${conflict.id}，请先移除后再恢复`);
         }
         const form = manifest.form === 'bundle' ? 'bundle' : 'flat';
-        if (form === 'bundle') {
-            await mkdir(join(memoriesRoot, manifest.group), { recursive: true });
-            const { cp } = await import('node:fs/promises');
-            await cp(join(trashDir, 'bundle'), join(memoriesRoot, manifest.group, manifest.name), { recursive: true });
+        // 落点根内断言（realpath 口径）：`isValidGroupPath` 只挡 `..` 与分隔符，挡不住
+        // 「中间目录是指向根外的链接」。与 `rulesRemove` 的删除前断言同一道闸。
+        const groupDir = join(memoriesRoot, manifest.group);
+        const denied = await refuseOutsideRoot(groupDir);
+        if (denied)
+            return denied;
+        // 恢复 = 先复制、后删回收站条目。**复制中途失败必须回滚**（2026-09-30 审查 F11）：
+        // 原来这里 `cp` / `copyFile` 都没有 try/catch，失败时目标留下半份内容、回收站条目仍在，
+        // 于是下一次点恢复会撞上面那条「同名记忆已存在」—— 这条记忆**永远恢复不了**，只能人工
+        // 去删目录。场景回收站（`sceneTrashRestore`）早有这条回滚（`moveIntoTrash` 反向搬回），
+        // 记忆回收站这条缺了。这里方向相反：源还在回收站，所以回滚是**删掉没放完整的副本**。
+        const target = form === 'bundle'
+            ? join(groupDir, manifest.name)
+            : join(groupDir, manifest.name + '.md');
+        try {
+            await mkdir(groupDir, { recursive: true });
+            if (form === 'bundle')
+                await cp(join(trashDir, 'bundle'), target, { recursive: true });
+            else
+                await copyFile(join(trashDir, 'rule.md'), target);
         }
-        else {
-            await mkdir(join(memoriesRoot, manifest.group), { recursive: true });
-            await copyFile(join(trashDir, 'rule.md'), join(memoriesRoot, manifest.group, manifest.name + '.md'));
+        catch (e) {
+            let cleaned = true;
+            try {
+                await rm(target, { recursive: true, force: true });
+            }
+            catch (cleanupError) {
+                // 落点**本来就没建成**时（父路径不是目录 → ENOTDIR；`force` 已吞掉 ENOENT），
+                // 没有残留要清，别把它报成「清理失败」——那会让用户去手工删一个不存在的路径。
+                const code = cleanupError?.code;
+                cleaned = code === 'ENOENT' || code === 'ENOTDIR';
+            }
+            // 清理失败也如实说清楚，别让用户以为还能原样重试。
+            const tail = cleaned
+                ? '（未放回完整的落点已清理，回收站条目仍在，可直接重试）'
+                : `（未放回完整的落点没能清理：${target}，请先手工删除再重试）`;
+            return fail('error.rules.ioFailed', `恢复记忆失败：${String(e?.message ?? e)}${tail}`);
         }
         await rm(trashDir, { recursive: true, force: true });
         invalidateSnapshot();

package/lib/prompts/quick-service.js

@@ -0,0 +1,211 @@
+// dsh-plugin-tool-management —— 快捷提示词库（hub/quick-prompts/）。
+//
+// 与「全局提示词预设」（`./service.ts`）是**两件事**，别混着看：
+//   预设 = 一份会覆盖写 `~/.dsh/AGENTS.md` 的指令基线，进上下文、被场景绑定、模型能在之间挑；
+//   快捷 = 用户存好的一段现成文字，只由**用户自己**在对话框 `/` 菜单里点出来贴进草稿。
+//
+// 所以它**不注入上下文、不进场景**，实现上靠"另起一份存储"来保证：预设服务的
+// `list()` 只扫 `hub/prompts/` 下的合法目录，注入取的是场景绑定的那份正文，模型工具
+// `prompt_manager_list` 复用的又是 `agentsmd-list` —— 四条路径各自只认 `hub/prompts/`，
+// 快捷词放在隔壁目录里就天然进不去。**不要**为了少一个目录把它塞进 prompts/ 加个标记位：
+// 那等于让四条路径各自学会过滤，漏一条就是"快捷词被当成基线注入"。
+// 条目那颗开关（`enabled`）只管"在不在对话框 `/` 菜单里出现"，同样不碰上面四条路径。
+//
+// `list()` 连**正文一起给**，不是偷懒省一次请求：宿主的 `settle()` 拿到 onPick 的返回值后
+// **同步**执行插入（input-trigger client.js），异步读正文来不及 —— 点的时候手里就得有那段字。
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isValidPresetId, normalizePresetId } from './preset-id.js';
+import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
+/** 快捷提示词正文的文件名。与预设的 `AGENTS.md` 刻意不同名：这两个库不该被互换过。 */
+const FILENAME = 'PROMPT.md';
+/** 侧车（说明 + 启停），与正文同目录：正文本身一个字都不该被这些元信息污染。 */
+const META_FILE = 'meta.json';
+export function createQuickPromptsService(deps) {
+    const message = (e) => String((e && e.message) || e);
+    const idError = (raw) => {
+        const result = normalizePresetId(raw);
+        return result.ok ? null : result.error;
+    };
+    /** 侧车读回来的形状：缺字段一律按"没动过"解释（说明为空、开关为开）。 */
+    async function readMeta(id) {
+        try {
+            const parsed = JSON.parse(await readFile(join(deps.dir, id, META_FILE), 'utf8'));
+            return {
+                description: typeof parsed.description === 'string' ? parsed.description : '',
+                // 只有明确写着 false 才算关：这颗开关之前的老库根本没有这个字段，默认必须是"照常在 / 里出现"。
+                enabled: parsed.enabled !== false,
+            };
+        }
+        catch {
+            return { description: '', enabled: true };
+        }
+    }
+    /**
+     * 侧车写：`undefined` = 那一项不动（空串 / `true` 才是明确回到默认）。
+     * 两项都回到默认时连文件一起删 —— 不留空壳（原来"说明清空就删侧车"那条纪律照旧）。
+     */
+    async function writeMeta(id, patch) {
+        const cur = await readMeta(id);
+        const description = patch.description === undefined ? cur.description : String(patch.description).trim();
+        const enabled = patch.enabled === undefined ? cur.enabled : patch.enabled === true;
+        const body = {};
+        if (description !== '')
+            body.description = description;
+        if (enabled !== true)
+            body.enabled = false;
+        const file = join(deps.dir, id, META_FILE);
+        try {
+            if (!Object.keys(body).length) {
+                await rm(file, { force: true });
+                return;
+            }
+            await writeFile(file, JSON.stringify(body, null, 2) + '\n', 'utf8');
+        }
+        catch { /* 元信息写不进去不该让保存失败：正文才是本体 */ }
+    }
+    async function list() {
+        try {
+            let entries = [];
+            try {
+                entries = await readdir(deps.dir, { withFileTypes: true });
+            }
+            catch { /* 库还没建过 = 空 */ }
+            const ids = entries.filter((e) => e.isDirectory() && isValidPresetId(e.name)).map((e) => e.name);
+            const prompts = await Promise.all(ids.map(async (id) => {
+                const meta = await readMeta(id);
+                return {
+                    id,
+                    description: meta.description,
+                    enabled: meta.enabled,
+                    // 读不到的那条（正文被外部删了）给空串：界面上仍然列出来，用户能看见"它在但没内容"，
+                    // 而不是凭空少一条却查不出为什么。
+                    content: await readFile(join(deps.dir, id, FILENAME), 'utf8').catch(() => ''),
+                };
+            }));
+            prompts.sort((a, b) => a.id.localeCompare(b.id));
+            return { ok: true, prompts };
+        }
+        catch (e) {
+            return { ok: false, error: message(e) };
+        }
+    }
+    async function create(id, content, description) {
+        const bad = idError(id);
+        if (bad)
+            return { ok: false, error: '非法 id：' + bad };
+        const safeId = String(id ?? '').trim();
+        const dir = join(deps.dir, safeId);
+        try {
+            await stat(dir);
+            return { ok: false, error: 'id 已存在：' + safeId };
+        }
+        catch { /* 不存在，继续 */ }
+        await mkdir(dir, { recursive: true });
+        await writeFile(join(dir, FILENAME), String(content ?? ''), 'utf8');
+        await writeMeta(safeId, { description });
+        return { ok: true, id: safeId };
+    }
+    async function update(id, content, nextId, description) {
+        const bad = idError(id);
+        if (bad)
+            return { ok: false, error: '非法 id：' + bad };
+        const safeId = String(id ?? '').trim();
+        try {
+            await stat(join(deps.dir, safeId));
+        }
+        catch {
+            return { ok: false, error: '快捷提示词不存在：' + safeId };
+        }
+        let targetId = safeId;
+        if (nextId !== undefined && String(nextId).trim() !== safeId) {
+            const badNext = idError(nextId);
+            if (badNext)
+                return { ok: false, error: '非法新 id：' + badNext };
+            targetId = String(nextId).trim();
+            try {
+                await stat(join(deps.dir, targetId));
+                return { ok: false, error: '新 id 已存在：' + targetId };
+            }
+            catch { /* 可用 */ }
+            try {
+                await rename(join(deps.dir, safeId), join(deps.dir, targetId));
+            }
+            catch (e) {
+                return { ok: false, error: '改名失败：' + message(e) };
+            }
+        }
+        await writeFile(join(deps.dir, targetId, FILENAME), String(content ?? ''), 'utf8');
+        await writeMeta(targetId, { description });
+        return { ok: true, id: targetId, ...(targetId === safeId ? {} : { renamedFrom: safeId }) };
+    }
+    /**
+     * 启停：只写侧车那一个字段，正文与说明一律不动。
+     * 目录不存在时照实拒绝 —— 静默"成功"会在界面上留下一颗凭空出现的开关。
+     */
+    async function setEnabled(id, enabled) {
+        const safeId = String(id ?? '').trim();
+        const bad = idError(safeId);
+        if (bad)
+            return { ok: false, error: '非法 id：' + bad };
+        try {
+            await stat(join(deps.dir, safeId));
+        }
+        catch {
+            return { ok: false, error: '快捷提示词不存在：' + safeId };
+        }
+        await writeMeta(safeId, { enabled });
+        return { ok: true, id: safeId, enabled };
+    }
+    /** 删除 = 整个目录进回收站（与预设同一条纪律：不静默删用户写的东西）。 */
+    async function remove(id) {
+        const safeId = String(id ?? '').trim();
+        const bad = idError(safeId);
+        if (bad)
+            return { ok: false, error: '非法 id：' + bad };
+        const dir = join(deps.dir, safeId);
+        try {
+            await stat(dir);
+        }
+        catch {
+            return { ok: false, error: '快捷提示词不存在：' + safeId };
+        }
+        const moved = await moveToTrash('quick-prompts', safeId, [{ from: dir, dest: 'prompt' }]);
+        if (moved.ok === false)
+            return { ok: false, error: '移入回收站失败：' + moved.error };
+        return { ok: true, id: safeId };
+    }
+    async function trashList() {
+        return { ok: true, trash: await listTrashEntries('quick-prompts') };
+    }
+    async function trashRestore(id) {
+        const entry = await readTrashEntry('quick-prompts', String(id ?? '').trim());
+        if (!entry)
+            return { ok: false, error: '回收站条目不存在：' + String(id ?? '').trim() };
+        const bad = idError(entry.name);
+        if (bad)
+            return { ok: false, error: '回收站里的 id 不合法：' + bad };
+        const target = join(deps.dir, entry.name);
+        try {
+            await stat(target);
+            return { ok: false, error: '无法恢复，同 id 已存在：' + entry.name };
+        }
+        catch { /* 可用 */ }
+        try {
+            await mkdir(deps.dir, { recursive: true });
+            await moveOutOfTrash('quick-prompts', entry.id, 'prompt', target);
+        }
+        catch (e) {
+            return { ok: false, error: '恢复失败：' + message(e) };
+        }
+        await purgeTrashEntry('quick-prompts', entry.id);
+        return { ok: true, id: entry.name };
+    }
+    async function trashDelete(id) {
+        const clean = String(id ?? '').trim();
+        if (!(await purgeTrashEntry('quick-prompts', clean)))
+            return { ok: false, error: '回收站条目不存在：' + clean };
+        return { ok: true, id: clean };
+    }
+    return { list, create, update, setEnabled, remove, trashList, trashRestore, trashDelete };
+}

package/lib/prompts/service.js

@@ -17,6 +17,11 @@ import { join } from 'node:path';
 import { createHash } from 'node:crypto';
 import { isValidPresetId, LAST_APPLIED_PRESET_ID, normalizePresetId } from './preset-id.js';
 import { listTrashEntries, moveOutOfTrash, moveToTrash, purgeTrashEntry, readTrashEntry } from '../hub.js';
+// 全局 AGENTS.md 的落盘走**原子写**（temp + rename，见 `memories/index-io.ts`）。
+// 为什么非它不可（2026-09-30 审查 P2-2）：这个文件是宿主**每个 agent/pre-step 都会 stat 并
+// 重读**的，裸 `writeFile` 在中断/断电时会留下**半截内容** —— 而半截的提示词会原样进模型
+// 上下文（截断点还可能在代码块中间）。原子写保证读到的是「要么旧、要么新」的完整内容。
+import { writeFileAtomically } from '../memories/index-io.js';
 const FILENAME = 'AGENTS.md';
 /** 描述侧车：与 AGENTS.md 同目录，避免描述的文字被当成提示词正文注入。 */
 const META_FILE = 'meta.json';
@@ -321,7 +326,7 @@ export function createPromptsService(_ctx, deps) {
         }
         const prev = await readGlobal();
         const backedUp = await backupGlobal(prev);
-        await writeFile(await deps.getGlobalAgentsMdPath(), content, 'utf8');
+        await writeFileAtomically(await deps.getGlobalAgentsMdPath(), content);
         await writeAppliedId(safeId);
         return { ok: true, id: safeId, backedUp };
     }
@@ -335,7 +340,7 @@ export function createPromptsService(_ctx, deps) {
         const prev = await readGlobal();
         const backedUp = await backupGlobal(prev);
         try {
-            await writeFile(await deps.getGlobalAgentsMdPath(), text, 'utf8');
+            await writeFileAtomically(await deps.getGlobalAgentsMdPath(), text);
         }
         catch (e) {
             return { ok: false, error: '写入全局 AGENTS.md 失败：' + message(e) };