dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/memories/snapshot.js

@@ -8,13 +8,17 @@
 //
 // 对 service.ts 只做 type-only 引用（`import type`），避免与它形成运行时循环依赖。
 import { readdirSync, statSync } from 'node:fs';
-import { cp, lstat, mkdir, readFile, readdir, realpath, rename, rm } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { parseSkillDoc, resolveDshHome, unquote } from '../skills/core.js';
-import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, MAX_DESCRIPTION_LENGTH, DEFAULT_ORDER, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, TRUNCATION_MARKER, DROPPED_HEADING, SCENE_MEMORY_NOTE, LEGACY_BUNDLE_DOC, bundleDocName, SEGMENT_RULE_HINT, SHARED_GROUP, byteLen, message, isValidGroupSegment } from './constants.js';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { parseSkillDoc } from '../skills/core.js';
+import { MAX_SOURCE_DEPTH, MAX_DIRECTORIES, MAX_ENTRIES, DEFAULT_ORDER, DEFAULT_GROUP_ORDER, GLOBAL_SCENE, TRUNCATION_MARKER, DROPPED_HEADING, SCENE_MEMORY_NOTE, LEGACY_BUNDLE_DOC, bundleDocName, SHARED_GROUP, byteLen, message, isValidGroupSegment } from './constants.js';
 import { ensureSceneRecords, resolveActiveScenes, signatureOfIndex, sceneLabel, sceneHeading, sceneLine, compareSceneBuckets, memoryBlock } from './projection.js';
-import { isIndexQuarantined, readIndex, writeIndex, pathExists, readFileIfExistsSync } from './index-io.js';
-export const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() : p);
+import { isIndexQuarantined, readIndex, writeIndex, readFileOrThrowSync, isAbsentError } from './index-io.js';
+// 来源发现与投影（扫目录读成条目 / frontmatter 投成规则 / 老布局搬家）2026-10-01 整段搬到
+// ./discovery.js，正文一字未改（moved-verify 逐字对拍）。snapshot.js 的公开面照旧：搬走的
+// 九件全部从这里再出口 —— memories/service.ts 按 ./snapshot.js 引它们。
+export { deriveDescription, deriveFromDoc, discover, identity, projectRule, relocateLegacyLayout, } from './discovery.js';
+import { deriveFromDoc, discover, projectRule, } from './discovery.js';
 // ── 文件工具 ───────────────────────────────────────────────────────────────
 /**
  * BFS 发现（realpath 防环、深度/目录/条目预算），与 readonly-discovery 同构，
@@ -27,213 +31,10 @@ export const identity = (p) => (process.platform === 'win32' ? p.toLowerCase() :
  * 都没有则它是场景/子分类，继续遍历其下 .md（flat，任意层级）
  * 与子目录。同名 flat 与 bundle 冲突时 bundle 优先，flat 记入 shadowed。
  */
-export async function discover(memoriesRoot) {
-    const entries = new Map();
-    const shadowed = [];
-    const groups = new Set();
-    const scenes = [];
-    const warnings = [];
-    const rootPath = resolve(memoriesRoot);
-    try {
-        const st = await lstat(rootPath);
-        if (!st.isDirectory() || st.isSymbolicLink())
-            return { entries, shadowed, groups, scenes, warnings, truncated: false };
-    }
-    catch {
-        return { entries, shadowed, groups, scenes, warnings, truncated: false };
-    }
-    const queue = [
-        { path: rootPath, group: '', depth: 0, ancestors: new Set() },
-    ];
-    let directories = 0;
-    let itemCount = 0;
-    let truncated = false;
-    const addEntry = (entry) => {
-        const existing = entries.get(entry.id);
-        if (!existing) {
-            entries.set(entry.id, entry);
-            return;
-        }
-        if (entry.kind === 'bundle' && existing.kind === 'flat') {
-            shadowed.push({ ...existing, shadowed: true });
-            entries.set(entry.id, entry);
-            return;
-        }
-        if (entry.kind === 'flat' && existing.kind === 'bundle') {
-            shadowed.push({ ...entry, shadowed: true });
-        }
-    };
-    for (let cursor = 0; cursor < queue.length; cursor++) {
-        if (directories >= MAX_DIRECTORIES || itemCount >= MAX_ENTRIES) {
-            truncated = true;
-            break;
-        }
-        const current = queue[cursor];
-        let realDirectory;
-        let dirents = [];
-        try {
-            realDirectory = await realpath(current.path);
-            if (current.ancestors.has(identity(realDirectory)))
-                continue;
-            const dir = await readdir(current.path, { withFileTypes: true });
-            directories++;
-            for (const item of dir) {
-                if (itemCount >= MAX_ENTRIES) {
-                    truncated = true;
-                    break;
-                }
-                itemCount++;
-                dirents.push(item);
-            }
-        }
-        catch {
-            continue; // 失效链接或不可读目录不阻断其他来源
-        }
-        // bundle 检查：当前目录含 `<目录名>.md`（或旧版 `SKILL.md`）→ 它是规则叶子，父路径为场景。
-        //
-        // **根下的一级目录恒为场景**（`parentGroup === ''` 时不做 bundle 判断）——与
-        // `probeSceneFilesSync`（注入段）同口径。场景 `1` 里一条叫 `1` 的记忆（`memories/1/1.md`）
-        // 与「根层的 bundle `1`」在磁盘上同形，认成后者会把整个场景目录吃成叶子：同场景其余
-        // 记忆全从列表消失、多出一条「未归属场景」的同名记忆，新建记忆还会被误报「同名 bundle
-        // 遮蔽」（2026-09-16 用户实测）。根层因此没有 bundle，只有 legacy 裸 .md（见 rulesCheck 的 noScene）。
-        if (current.group !== '') {
-            const sepIdx = current.group.lastIndexOf('/');
-            const parentGroup = sepIdx >= 0 ? current.group.slice(0, sepIdx) : '';
-            const name = sepIdx >= 0 ? current.group.slice(sepIdx + 1) : current.group;
-            let docPath = '';
-            if (parentGroup !== '') {
-                for (const candidate of [bundleDocName(name), LEGACY_BUNDLE_DOC]) {
-                    const p = join(current.path, candidate);
-                    try {
-                        const st = await lstat(p);
-                        if (st.isFile() && !st.isSymbolicLink()) {
-                            docPath = p;
-                            break;
-                        }
-                    }
-                    catch { /* 该候选名不存在 → 试下一个 */ }
-                }
-            }
-            if (docPath !== '') {
-                const id = parentGroup ? `${parentGroup}/${name}` : name;
-                addEntry({ id, group: parentGroup, name, kind: 'bundle', docPath, entryPath: current.path });
-                continue;
-            }
-        }
-        if (current.group !== '') {
-            groups.add(current.group);
-            // 一级目录 = 场景名（多段场景名用 '/' 连接，见 isValidGroupPath）。
-            if (current.depth === 1)
-                scenes.push(current.group);
-        }
-        dirents.sort((a, b) => a.name.localeCompare(b.name));
-        const ancestors = new Set(current.ancestors).add(identity(realDirectory));
-        for (const item of dirents) {
-            if (item.name.startsWith('.'))
-                continue; // 隐藏目录/文件跳过
-            const path = join(current.path, item.name);
-            try {
-                const st = await lstat(path);
-                // 符号链接一律不跟随：注入路径（`probeSceneFilesSync`）本来就不跟随，两端必须同口径 ——
-                // 否则列表里会出现**永远注入不进去**的记忆（用户打开开关却什么也没发生）。顺带也关掉了
-                // 「链接指向根外、写操作顺着链接穿透出去」这条路（写入侧另有 realpath 断言兜底）。
-                if (st.isSymbolicLink())
-                    continue;
-                if (st.isDirectory()) {
-                    if (!isValidGroupSegment(item.name)) {
-                        warnings.push(`跳过非法目录名（${SEGMENT_RULE_HINT}）：${current.group ? current.group + '/' : ''}${item.name}`);
-                        continue;
-                    }
-                    if (current.depth >= MAX_SOURCE_DEPTH || queue.length >= MAX_DIRECTORIES) {
-                        truncated = true;
-                        continue;
-                    }
-                    queue.push({
-                        path,
-                        group: current.group ? `${current.group}/${item.name}` : item.name,
-                        depth: current.depth + 1,
-                        ancestors,
-                    });
-                    continue;
-                }
-                if (!st.isFile())
-                    continue;
-                if (!item.name.toLowerCase().endsWith('.md'))
-                    continue; // 只认 .md
-                const name = item.name.slice(0, -3);
-                const id = current.group ? `${current.group}/${name}` : name;
-                addEntry({ id, group: current.group, name, kind: 'flat', docPath: path, entryPath: path });
-            }
-            catch {
-                /* 来源在扫描期间失效时跳过 */
-            }
-        }
-    }
-    return { entries, shadowed, groups, scenes, warnings, truncated };
-}
 // ── 规则解析 + 派生 ────────────────────────────────────────────────────────
 /** 派生 description：首个 `#` 标题 → 首个非空行；截断 500 字符。 */
-export function deriveDescription(body) {
-    const text = String(body ?? '').trim();
-    if (!text)
-        return '';
-    const heading = /^#\s+(.+)$/m.exec(text);
-    const raw = heading && heading[1].trim() ? heading[1].trim() : text.split(/\r?\n/, 1)[0].trim();
-    return raw.slice(0, MAX_DESCRIPTION_LENGTH);
-}
 /** 从 frontmatter/正文派生字段（派生只存在于内存投影，不写回文件）。 */
-export function deriveFromDoc(entry, doc) {
-    const declaredName = doc.map.name != null && String(doc.map.name).trim() !== '' ? unquote(String(doc.map.name)).trim() : '';
-    const name = declaredName || entry.name;
-    let description = doc.map.description != null ? unquote(String(doc.map.description)).trim() : '';
-    let descriptionDerived = false;
-    if (description === '') {
-        description = deriveDescription(doc.body);
-        descriptionDerived = true;
-    }
-    const globs = doc.map.globs != null && String(doc.map.globs).trim() !== '' ? String(doc.map.globs).trim() : undefined;
-    let whenToUse;
-    if (doc.map.whenToUse != null && String(doc.map.whenToUse).trim() !== '') {
-        whenToUse = String(doc.map.whenToUse).trim();
-    }
-    else if (globs) {
-        whenToUse = `适用路径：${globs}`;
-    }
-    const metadata = doc.map.metadata !== undefined ? doc.map.metadata : undefined;
-    return { name, description, descriptionDerived, whenToUse, globs, metadata };
-}
 /** 合并索引字段（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 } : {}),
-        ...(derived.globs !== undefined ? { globs: derived.globs } : {}),
-        ...(derived.metadata !== undefined ? { metadata: derived.metadata } : {}),
-        enabled: idxEntry?.enabled ?? true,
-        order: idxEntry?.order ?? DEFAULT_ORDER,
-        tags: Array.isArray(idxEntry?.tags) ? idxEntry.tags : [],
-        pinned: idxEntry?.pinned === true,
-        note: typeof idxEntry?.note === 'string' ? idxEntry.note : '',
-        ...(typeof idxEntry?.updatedAt === 'string' ? { updatedAt: idxEntry.updatedAt } : {}),
-    };
-    return rule;
-}
 // ── 侧车文件（索引 / 场景）─────────────────────────────────────────────────
 /** 把旧布局搬进 `tool-management/`（每个进程只尝试一次，幂等）。
  *
@@ -246,49 +47,6 @@ export function projectRule(entry, derived, idxEntry) {
  * 源目录**保留**（内容已搬走，留空壳不影响正确性，也方便用户核对）。
  * 目标已存在同名项 → 保留目标、跳过该项（绝不覆盖新数据）。
  */
-export async function relocateLegacyLayout(memoriesRoot) {
-    const home = resolveDshHome();
-    const legacyRoots = [join(home, 'scene-memory'), join(home, 'rules')];
-    for (const legacyRoot of legacyRoots) {
-        if (!(await pathExists(legacyRoot)))
-            continue;
-        if (identity(resolve(legacyRoot)) === identity(resolve(memoriesRoot)))
-            continue; // 自定义 roots 落在旧路径 → 不自我搬移
-        let items;
-        try {
-            items = await readdir(legacyRoot, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const item of items) {
-            if (item.name.startsWith('.'))
-                continue;
-            const src = join(legacyRoot, item.name);
-            // 根层 .md = 旧的「全局」桶 → 搬进 `global/`，文件名保留（否则多套一层目录）。
-            // 其余条目（场景目录）整体搬进 memories/，目录名保留。
-            const isRootMd = item.isFile() && item.name.toLowerCase().endsWith('.md');
-            const destDir = isRootMd ? join(memoriesRoot, GLOBAL_SCENE) : memoriesRoot;
-            const dest = join(destDir, item.name);
-            try {
-                if (await pathExists(dest))
-                    continue;
-                await mkdir(destDir, { recursive: true });
-                try {
-                    await rename(src, dest);
-                }
-                catch {
-                    // 跨设备/被占用 → 复制后删源；复制失败则保留源文件（宁可重复，不可丢失）。
-                    await cp(src, dest, { recursive: true });
-                    await rm(src, { recursive: true, force: true });
-                }
-            }
-            catch {
-                /* 单项失败不阻断其余项（如文件被外部程序锁住，下次启动再试） */
-            }
-        }
-    }
-}
 // ── 快照（发现 + 索引合并 + 索引清理）──────────────────────────────────────
 export async function buildSnapshot(memoriesRoot, stateDir) {
     const discovery = await discover(memoriesRoot);
@@ -365,13 +123,23 @@ export async function buildSnapshot(memoriesRoot, stateDir) {
         .sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
     return { rules, groups, scenes: discovery.scenes, warnings, truncated: discovery.truncated, entries, bodies, index };
 }
+/**
+ * `mtime:size` 指纹；**不存在**返回 `'missing'`，其余 IO 失败**抛异常**。
+ *
+ * 为什么抛（2026-09-30 审查 F7）：探测阶段这个值同时用来判「bundle 的正文文件在不在」。
+ * 把 EACCES/EBUSY 一并吞成 `'missing'`，等于把"读不动"读成"没有这条记忆" —— 段里少一条，
+ * 而注入通道只看到"内容变了/变空了"，最坏时发出一条假的「已清空」。抛出去之后，注入侧
+ * 报 `error` 并**保留上一轮内容**，界面侧退回上一轮投影（见 service.ts 的同名注释）。
+ */
 export function fileStampSync(path) {
     try {
         const st = statSync(path);
         return `${st.mtimeMs}:${st.size}`;
     }
-    catch {
-        return 'missing';
+    catch (e) {
+        if (isAbsentError(e))
+            return 'missing';
+        throw e;
     }
 }
 /**
@@ -381,6 +149,11 @@ export function fileStampSync(path) {
  * 根层的裸 .md **不再是记忆**（旧的「全局」桶已迁入 `global/`，见 relocateLegacyLayout），
  * 因此这里不再扫描根层文件——把文件丢在 memories/ 根下不会静默生效，也不会被投影。
  * `signature` 不变 ⇒ 上次渲染结果可原样复用（零正文 IO、零重排）。
+ *
+ * **读失败抛异常、不存在才算空**（2026-09-30 审查 F7）：根目录与子目录的 `readdirSync` 只在
+ * `ENOENT`（目录不存在 = 全新用户 / 刚删掉）时退化成空段；其余 IO 错误（Windows 上杀软 /
+ * 索引器 / 备份软件占住会报 EACCES/EBUSY）一律抛给调用方 —— 把"读不动"当成"没有记忆"会让
+ * 注入通道发出假的「已清空」。
  */
 export function probeSceneFilesSync(memoriesRoot, index, 
 // 索引已损坏时置真：索引是开关的唯一真相源，它没了就无法知道用户开过哪些记忆，
@@ -395,8 +168,11 @@ forceDisabled = false) {
     try {
         rootEntries = readdirSync(memoriesRoot, { withFileTypes: true });
     }
-    catch {
-        // 目录不存在/不可读 → 空段（不报错）。签名含固定前缀，便于与"空树"区分。
+    catch (e) {
+        // 目录不存在（全新用户 / 刚删掉）→ 空段。签名含固定前缀，便于与"空树"区分。
+        // 其余 IO 错误必须抛：见函数头注释（F7）。
+        if (!isAbsentError(e))
+            throw e;
         return { refs: [], scenes: [], truncated: false, signature: `∅|${signatureOfIndex(index)}` };
     }
     const add = (ref) => {
@@ -415,8 +191,11 @@ forceDisabled = false) {
         try {
             entries = readdirSync(dir, { withFileTypes: true });
         }
-        catch {
-            return;
+        catch (e) {
+            // 子目录在遍历中途被删 → 跳过（正常竞态）；其余 IO 失败照函数头的口径抛出（F7）。
+            if (isAbsentError(e))
+                return;
+            throw e;
         }
         budget.dirs++;
         entries.sort((a, b) => a.name.localeCompare(b.name));
@@ -504,9 +283,11 @@ forceDisabled = false) {
 export function renderSceneMemory(probe, index, maxBytes) {
     const files = [];
     for (const ref of probe.refs) {
-        const text = readFileIfExistsSync(ref.path);
+        const text = readFileOrThrowSync(ref.path);
+        // 探测与读取之间被删 → 跳过（下次指纹变化会再校正）。读不动**不**走这条：那会静默
+        // 少一条记忆，最坏时让注入通道发假的「已清空」（F7）—— 抛出去由调用方决定处置。
         if (text === null)
-            continue; // 探测与读取之间被删：跳过（下次指纹变化会再校正）
+            continue;
         const doc = parseSkillDoc(text);
         const derived = deriveFromDoc({ id: ref.id, group: ref.scene, name: ref.name, kind: ref.kind, docPath: ref.path, entryPath: ref.path }, doc);
         files.push({

package/lib/op-registry.js

@@ -12,6 +12,8 @@
 //                 而 service 不再自报 → 也红。两边谁改了都必须动另一边。
 //   write         需要访问令牌。判据是"会不会改**宿主或外部系统**的状态" —— 注意这**不是**
 //                 "会不会写盘"：见下方 readonly 那一段。
+//   writeWhen     仅对"两态 op"（一个名字兼读与写）生效：**这次调用**算不算写。判据不成立
+//                 = 纯读，免令牌也不记流水。没带这一项的 op，标了 write 就一律按写处理。
 //   sensitive     会泄露明文凭据 / 完整配置。**必须**带对的令牌，没配令牌就一律拒绝。
 //   frozen        任一场景 locked=true 时整体拒绝（五个管理域冻结）。
 //   frozenScope   frozen 的三种口径，默认 'all'：
@@ -43,7 +45,7 @@ export const OP_REGISTRY = Object.freeze({
     'mcpm-import': { write: true, frozen: true },
     'mcpm-compact': { write: true, frozen: true },
     'mcpm-note': { write: true, frozen: true },
-    'mcpm-settings': { write: true, frozen: true },
+    'mcpm-settings': { write: true, frozen: true, writeWhen: (a) => a.set === true },
     'mcpm-set-enabled': { write: true, frozen: true, syncsArchive: true },
     'mcpm-set-all': { write: true, frozen: true, syncsArchive: true },
     'mcpm-tool-enabled': { write: true, frozen: true, syncsArchive: true },
@@ -56,7 +58,10 @@ export const OP_REGISTRY = Object.freeze({
     'mcpm-tools-refresh': { write: true },
     'mcpm-tools': { readonly: true },
     // 配置体检：只读补丁文件 + 一次 PATH 查询（`where`/`which`，不执行配置里的命令）。
-    // 返回的是检查项 id，不回任何字段值 —— 与 `mcpm-list` 同档，不带令牌。
+    // 回的是检查项 id + 少量**打码后**的字段值（URL 查询串走 `maskUrlQuery`，与 `mcpm-list`
+    // 同口径；`command` 明文，理由同 `mcpm-list`：命令名不是凭据，`args` 两边都不回）。
+    // 与 `mcpm-list` 同档，不带令牌 —— 0.16.6 之前这里回的是 URL 原文，等于让免令牌的请求
+    // 拿到 `?api_key=…`，绕过了 `mcpm-reveal` 那道防线（审查 P0-5，0.17.0 修）。
     'mcpm-inspect': { readonly: true },
     // ── 技能域（22，含内联的 skill-open）───────────────────────────────────────
     'skill-state': { annotatesLock: true },
@@ -148,6 +153,22 @@ export const OP_REGISTRY = Object.freeze({
     'agentsmd-import': { write: true, frozen: true },
     'agentsmd-trash-restore': { write: true, frozen: true },
     'agentsmd-trash-delete': { write: true, frozen: true },
+    // ── 快捷提示词域（8）───────────────────────────────────────────────────────
+    // 只改插件自己的侧车（`hub/quick-prompts/`），不写 AGENTS.md、不进场景、不进注入；
+    // 但"改用户存好的东西"按本文件口径就是写操作（判据不是"会不会写盘"，见文件头）。
+    // frozen 与五个管理域同一条：**锁定期间整体只读**（用户裁定 2026-09-30，不给它开例外，
+    // 免得"锁定"这件事要分两套话术解释）。
+    'quickprompt-list': { readonly: true },
+    'quickprompt-trash-list': { readonly: true },
+    'quickprompt-create': { write: true, frozen: true },
+    'quickprompt-update': { write: true, frozen: true },
+    // 那颗开关改的是"这条在不在对话框 `/` 菜单里出现"，动的仍是用户自己的东西 ——
+    // 与 create/update 同档，不因为它不碰正文就免了令牌。`syncsArchive`：场景绑了快捷词时，
+    // 在场景里手动开关一条要跟着改进那份勾选集（未绑定的场景不跟，见 index.ts 那一支的注释）。
+    'quickprompt-toggle': { write: true, frozen: true, syncsArchive: true },
+    'quickprompt-remove': { write: true, frozen: true },
+    'quickprompt-trash-restore': { write: true, frozen: true },
+    'quickprompt-trash-delete': { write: true, frozen: true },
     // ── 历史会话域（16）────────────────────────────────────────────────────────
     'history-list': { readonly: true },
     'history-sessions': { readonly: true },
@@ -187,14 +208,24 @@ export const OP_REGISTRY = Object.freeze({
     'injection-live': { readonly: true },
     'backups-list': { readonly: true },
     // 注入设置（各域开关 / 压制型预设口径）写侧车。它是"配置"不是"宿主状态"，但改的是
-    // 投递语义，按写操作门禁。
-    'inject-settings': { write: true },
+    // 投递语义，按写操作门禁。读侧（不带 `set:true`）只回当前设置，是纯读。
+    'inject-settings': { write: true, writeWhen: (a) => a.set === true },
     // 模型工具表（哪些工具根本不发给模型）也写侧车，改的是每轮请求的内容 —— 同上按写门禁。
-    'tool-table': { write: true },
+    // 三条写触发：`set` 换名单；`presetSave` / `presetDelete` 只动 `presets`、**不动 `hidden`**
+    // —— 后两条不经过 `set`，只认 `set` 的判据会把它们当成读放行（审查 F2）。
+    'tool-table': {
+        write: true,
+        writeWhen: (a) => a.set === true || a.presetSave !== undefined || a.presetDelete !== undefined,
+    },
     // 场景页的界面设置（进入场景前要不要弹「会改什么」的预览卡）：写侧车，按写门禁。
     // **刻意不冻结**：它只是界面提示，锁着场景的人在场景页照样该能关掉提醒 —— 冻结的是五个
     // 管理域的改动，不是这个页面的显示偏好（判据见文件头 write/frozen 两段的边界）。
-    'scene-settings': { write: true },
+    'scene-settings': { write: true, writeWhen: (a) => a.set === true },
+    // 斜杠命令入口的开关（侧车 `slash-settings.json`）：与 `scene-settings` 同规格 —— 写侧车所以
+    // 按写门禁，但**刻意不冻结**（关掉一个界面入口不属于五个管理域的改动）。读侧不带 `set` 是纯读：
+    // 客户端 boot 时必问一次决定挂不挂 `/` 菜单，那一次不能要令牌，否则没配令牌的宿主上这个功能
+    // 永远出不来。
+    'slash-settings': { write: true, writeWhen: (a) => a.set === true },
     // 清理 patch 备份：删磁盘文件（备份里含明文凭据副本），按写操作门禁。
     'backups-clean': { write: true },
     // ── 场景候选源（4）与内联（1）──────────────────────────────────────────────
@@ -230,6 +261,27 @@ export function frozenOps(scope) {
     }
     return out;
 }
+/**
+ * 这次调用是不是「读侧」（免令牌、不记流水）。
+ *
+ * 判据只有一个来源：登记表的 `writeWhen`。**没带 `writeWhen` 的 op 一律返回 false**
+ * —— 即"标了 write 就是写"，不知道就别放行。
+ *
+ * 判据抛错也返回 false（按写处理）：一个会抛的谓词说明这次调用的形状没人设计过，
+ * 那种时候**要求令牌**才是安全的方向 —— 反过来会让"某个畸形 args 恰好免门禁"成为漏洞。
+ */
+export function isReadCall(op, args) {
+    const cls = OP_REGISTRY[op];
+    if (!cls || cls.writeWhen === undefined)
+        return false;
+    const bag = (args && typeof args === 'object' ? args : {});
+    try {
+        return cls.writeWhen(bag) !== true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * 对账：真实 op 表里**没在登记表出现**的键。
  *
@@ -256,10 +308,20 @@ export function serviceWriteMismatch(reported) {
         extra: [...declared].filter((op) => !actual.has(op)).sort(),
     };
 }
-/** 自相矛盾的条目：既声明只读又声明要令牌 / 泄露明文。（登记时手滑的兜底。） */
+/** 自相矛盾的条目：既声明只读又声明要令牌 / 泄露明文 / 带写判据。（登记时手滑的兜底。） */
 export function contradictoryEntries() {
     return Object.entries(OP_REGISTRY)
-        .filter(([, cls]) => cls.readonly === true && (cls.write === true || cls.sensitive === true))
+        .filter(([, cls]) => cls.readonly === true && (cls.write === true || cls.sensitive === true || cls.writeWhen !== undefined))
+        .map(([op]) => op)
+        .sort();
+}
+/**
+ * 标了 `writeWhen` 却没标 `write` 的条目：写判据写了，可这条 op 根本不进写门禁
+ * —— 那份判据永远不会被问一次，等于没写（静默失效，正是 F2 的形状）。
+ */
+export function writeWhenUnwritten() {
+    return Object.entries(OP_REGISTRY)
+        .filter(([, cls]) => cls.writeWhen !== undefined && cls.write !== true)
         .map(([op]) => op)
         .sort();
 }
@@ -278,6 +340,7 @@ export function auditOpRegistry(opNames, serviceWriteOps) {
         serviceWriteMissing: mismatch.missing,
         serviceWriteExtra: mismatch.extra,
         contradictory: contradictoryEntries(),
+        writeWhenUnwritten: writeWhenUnwritten(),
         total: names.length,
     };
 }
@@ -289,5 +352,6 @@ export function auditProblems(audit) {
         ...audit.serviceWriteMissing.map((op) => op + '（service 自报写、登记表未标）'),
         ...audit.serviceWriteExtra.map((op) => op + '（登记表标了写、service 未自报）'),
         ...audit.contradictory.map((op) => op + '（只读与写自相矛盾）'),
+        ...audit.writeWhenUnwritten.map((op) => op + '（有写判据却没标写）'),
     ];
 }

package/lib/ops/compat.js

@@ -8,6 +8,7 @@
 // 守卫仍作用在组装后的整张表上，见 index.ts）。
 import { EXPECTED_MIN_HOST_VERSION, EXPECTED_PEER_RANGE, VERIFIED_HOST_VERSION, isSourceInstall, routeFor, summarize, } from '../compat/probe.js';
 import { INJECT_DOMAIN_KEYS } from '../context-inject.js';
+import { MCP_TOOL_PREFIX } from '../host-names.js';
 import { assessPresetReach } from '../compat/preset-reach.js';
 import { runtimeNotes } from '../compat/runtime-notes.js';
 import { pluginLog } from '../skills/service.js';
@@ -99,7 +100,7 @@ export function buildCompatOps(deps) {
                 let mcpTools;
                 try {
                     const schemas = (await deps.tools.schemas());
-                    mcpTools = schemas.filter((s) => String(s && s.name || '').startsWith('mcp__')).length;
+                    mcpTools = schemas.filter((s) => String(s && s.name || '').startsWith(MCP_TOOL_PREFIX)).length;
                 }
                 catch {
                     mcpTools = undefined;
@@ -175,7 +176,10 @@ export function buildCompatOps(deps) {
                     ['mcp-tool-visibility', '工具表可见性（停用 / 关掉的工具不下发）', 'mcp'],
                 ];
                 for (const [noteId, label, tab] of assemblyRows) {
-                    const note = notes.get(noteId);
+                    // 注入通道有**两类**上报：装配失败（`context-injection`）与运行期失败
+                    // （`context-injection-runtime`，2026-09-30 P1-8：某域取数抛异常 / 整段注入抛异常）。
+                    // 合并到同一行 —— 用户关心的是"这条通道现在好不好"，不是"哪一类失败"。
+                    const note = notes.get(noteId) ?? (noteId === 'context-injection' ? notes.get('context-injection-runtime') : undefined);
                     push({
                         key: noteId, label, tab, state: note === undefined ? 'ok' : 'degraded',
                         detail: note === undefined ? '装配正常，无降级上报' : note.detail,
@@ -255,6 +259,17 @@ export function buildCompatOps(deps) {
                     key: 'tool-table', label: '模型工具表', tab: 'compat', state: 'ok', detail: offPart,
                     hidden: table.hiddenCount, total: table.totalCount, defaults: table.defaultHiddenCount,
                 });
+                // 斜杠命令入口（`/` 菜单里的「工具」与「快捷提示词」两段，各一颗开关）。服务端只知道
+                // **开关开没开**：真正挂没挂上是浏览器那半的事（宿主有没有 `inputTriggers` 服务），那一句
+                // 由兼容页就地报，不冒充服务端探测（见 client 48-slash.js 的挂载状态）。两个布尔一起带上，
+                // "开着哪一段"由界面按语言说。
+                const slash = await deps.readSlashSettings();
+                push({
+                    key: 'slash-commands', label: '斜杠命令入口', tab: 'compat',
+                    state: slash.tools || slash.quickPrompts ? 'ok' : 'disabled',
+                    detail: slash.tools || slash.quickPrompts ? '开关已开（在对话输入框打 / 唤出已打开的那几段）' : '两段都已关闭（本页可重新打开）',
+                    slashTools: slash.tools, slashQuickPrompts: slash.quickPrompts,
+                });
                 const nativeNote = notes.get('workspace.delete-native');
                 push({
                     key: 'native-delete', label: '宿主原生删除入口', tab: 'compat',

package/lib/ops/prompts.js

@@ -76,14 +76,27 @@ export function buildPromptOps(deps) {
         // 场景绑定（含恒常的 `_shared` / `global`）、`~/.dsh/AGENTS.md` 的当前内容、
         // 进场景前保存的基线（退出场景后要恢复的那一份）。拒绝时逐条说明「谁在用」，
         // 用户知道该先改哪里。引用清单由 scene-prompt-sync 与显示/注入同源算出。
-        // 探测失败（refs() 返回 null）时放行并记 warn：删预设不动 ~/.dsh/AGENTS.md，
-        // 最坏是少一份副本，可重建 —— 不因一次探测故障把删除堵死。
+        //
+        // 探测**失败**时改为拒绝（2026-09-30 审查 F13）。原来的取舍是「放行并记 warn：删预设不动
+        // ~/.dsh/AGENTS.md，最坏是少一份副本，可重建」—— 这对「副本」成立，对**场景态**不成立：
+        // 删掉场景绑定的那一份，场景驱动会因为找不到预设而静默失效（`driver()` 返回 null），
+        // 而 AGENTS.md 停在场景态，用户看到的是「没场景驱动所以什么都没做」。
+        // `refs()` 返回 null 只代表**三类探测里至少一类读盘失败**（全新环境没有场景时它返回的是
+        // **空表**而不是 null），所以拒绝不会堵住正常路径。文案必须说清是「探测失败」而不是
+        // 「有引用」—— 否则用户会去改一堆并不存在的引用。
         'agentsmd-remove': async (args) => {
             const id = String((args && args.id) || '');
             const refs = await deps.scenePromptSync.refs();
-            if (refs === null)
-                deps.warn('prompts: reference probe failed; remove allowed');
-            const why = refs ? refs.get(id) || [] : [];
+            if (refs === null) {
+                deps.warn('prompts: reference probe failed; remove refused');
+                return {
+                    ok: false,
+                    code: 'error.agentsMd.refProbeFailed',
+                    error: `无法确认「${id}」是否被引用，已拒绝删除：引用探测失败（场景绑定 / AGENTS.md 当前内容 / 进场景前的基线，这三类里至少有一类没读到）。请稍后重试。`,
+                    params: { id },
+                };
+            }
+            const why = refs.get(id) || [];
             if (why.length) {
                 const refsText = why.map(deps.promptRefReason).join('；');
                 return {

package/lib/ops/quick-prompts.js

@@ -0,0 +1,26 @@
+// 快捷提示词域的 HTTP ops（实现见 ../prompts/quick-service.ts）。
+//
+// 与 `ops/prompts.ts` 的差别不是"少写了几条"，而是**这个域没有宿主状态**：不写
+// `~/.dsh/AGENTS.md`、不参与场景同步、没有"生效中"。所以这里既不需要 `withAgentsMdSync`
+// 也不需要引用探测 —— 反过来，正因为它是纯侧车读写，才更要老老实实进 `op-registry`
+// 的写门禁清单（配了令牌的宿主上，免令牌请求不该能改用户存好的文字）。
+export function buildQuickPromptOps(quick) {
+    const text = (args, key) => args && typeof args[key] === 'string' ? String(args[key]) : undefined;
+    return {
+        // 列表连正文一起回（客户端点用时手里就得有那段字，见 quick-service.ts 头注）。
+        'quickprompt-list': async () => quick.list(),
+        'quickprompt-create': (args) => quick.create(String((args && args.id) || ''), text(args, 'content') ?? '', text(args, 'description')),
+        // 改名不牵连任何别处：快捷提示词不被场景绑定、不被引用，改完就是改完了。
+        'quickprompt-update': (args) => quick.update(String((args && args.id) || ''), text(args, 'content') ?? '', args && args.nextId !== undefined ? String(args.nextId) : undefined, text(args, 'description')),
+        'quickprompt-remove': (args) => quick.remove(String((args && args.id) || '')),
+        // 启停只改侧车的 `enabled`（在不在对话框 `/` 菜单里出现），正文一个字不动。
+        // `enabled` 必须是真布尔：省略它不叫"打开"，而是调用方写错了，静默按某一种处理会
+        // 让界面与落盘各说各话。
+        'quickprompt-toggle': (args) => (args && typeof args.enabled === 'boolean')
+            ? quick.setEnabled(String((args && args.id) || ''), args.enabled === true)
+            : Promise.resolve({ ok: false, error: '缺少 enabled（true / false）' }),
+        'quickprompt-trash-list': () => quick.trashList(),
+        'quickprompt-trash-restore': (args) => quick.trashRestore(String((args && args.id) || '')),
+        'quickprompt-trash-delete': (args) => quick.trashDelete(String((args && args.id) || '')),
+    };
+}