dsh-plugin-tool-management 0.9.0 → 0.9.1

package/lib/rules/archive-engine.js

@@ -39,15 +39,26 @@ export function createArchiveEngine(deps) {
         if (notes.length) {
             await deps.applyMcpNotes(notes.map((x) => ({ id: x.id, note: x.note })));
         }
-        // 子智能体开关：先停「进入时被这次关掉的」那些（档案没勾 = 本场景不开），
-        // 再开回「进入时被这次启用过的」那批 —— 与进入时的顺序相反，两个方向都要还原。
-        const personasOff = snapshot.subagents ?? [];
-        if (personasOff.length) {
-            await deps.applySubagentSwitches(personasOff.map((n) => ({ name: n, enabled: false })));
+        // 子智能体开关（v0.9.1）：**全量映射优先**——退出即精确还原「进场景前」的开与关。
+        // 为什么不能只靠下面那两个部分名单：场景内页面开关已开放（未锁定即可改、改动同步进档案），
+        // 「现在开着」不再只来自档案勾选，部分名单答不出「这个人是场景开的还是用户开的」。
+        // 表里**记过的名字**逐个还原；场景中新建的人设不在表里 → 不动它（与技能域同口径）。
+        // 老 snapshot 没有这一栏 → 退回两个方向的部分名单（旧行为：先停被开的，再开回被关的）。
+        const personaStates = snapshot.subagentsAll;
+        if (personaStates && typeof personaStates === 'object') {
+            const switches = Object.entries(personaStates).map(([name, on]) => ({ name, enabled: on === true }));
+            if (switches.length)
+                await deps.applySubagentSwitches(switches);
         }
-        const personasOn = snapshot.subagentsOn ?? [];
-        if (personasOn.length) {
-            await deps.applySubagentSwitches(personasOn.map((n) => ({ name: n, enabled: true })));
+        else {
+            const personasOff = snapshot.subagents ?? [];
+            if (personasOff.length) {
+                await deps.applySubagentSwitches(personasOff.map((n) => ({ name: n, enabled: false })));
+            }
+            const personasOn = snapshot.subagentsOn ?? [];
+            if (personasOn.length) {
+                await deps.applySubagentSwitches(personasOn.map((n) => ({ name: n, enabled: true })));
+            }
         }
     }
     /**
@@ -156,7 +167,11 @@ export function createArchiveEngine(deps) {
                     delete archive.mcpNotes;
             }
             if (archive.skills) {
-                const known = await deps.knownSkillKeys();
+                // 校验用**可勾选**集合（不是「已知全集」）：被同名技能覆盖的副本与结构不完整的技能
+                // 永远不可能生效，勾了也是假的 —— 留着就是「档案说开着、技能页说没启动」（用户实测：
+                // 启动一个目录后档案里多出被覆盖的那个技能）。这里按同一口径丢弃并如实报告，
+                // 顺带把历史残留清掉。
+                const known = await deps.selectableSkillKeys();
                 const hadKeys = archive.skills.length > 0;
                 stale.push(...archive.skills.filter((k) => !known.has(k)).map((k) => 'skills/' + k));
                 archive.skills = archive.skills.filter((k) => known.has(k));
@@ -254,11 +269,16 @@ export function createArchiveEngine(deps) {
             let unboundPersonas = [];
             let personaRestore = [];
             let personaRestoreOn = [];
+            // 全量开关映射（v0.9.1）：退出即精确还原「进场景前」。半个名单做不到这件事 ——
+            // 场景里手动开过的人设，「改动前是关还是开」只在这张全量表里。
+            let personaStates = {};
             try {
                 const known = await deps.knownPersonas();
                 unboundPersonas = [...known].filter((n) => boundPersonas.indexOf(n) < 0).sort();
                 personaRestore = await deps.disabledPersonas(boundPersonas);
                 personaRestoreOn = await deps.enabledPersonas(unboundPersonas);
+                const on = new Set(await deps.enabledPersonas([...known]));
+                personaStates = Object.fromEntries([...known].map((n) => [n, on.has(n)]));
             }
             catch (e) {
                 return { ok: false, error: `读取人设开关状态失败（未改动任何东西）：${msg(e)}` };
@@ -320,7 +340,7 @@ export function createArchiveEngine(deps) {
             // 进入都可能改动运行时（哪怕只是停掉几台服务器 / 几个技能），退出都得能精确还原。
             const snapshot = 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, personaRestoreOn, noteBefore);
+            mcpPlan.serverSwitches.map((s) => ({ id: s.id, level: s.level, disabled: s.disabledBefore })), skillsPlan.sourceSwitches.map((s) => ({ root: s.root, enabled: s.enabledBefore })), personaRestore, personaRestoreOn, noteBefore, personaStates);
             const entered = { ...slice, mode: { scene: target, snapshot }, active: [target] };
             try {
                 await deps.saveSlice({ ...slice, mode: entered.mode });

package/lib/rules/archive.js

@@ -198,7 +198,12 @@ subagents = [],
 /** **将被档案停用**的人设名（改动前启用的子集；退出时按此重新打开）。 */
 subagentsOn = [], 
 /** **将被档案改动**的备注行，带改动前的备注（null = 原本没有）。 */
-mcpNotes = []) {
+mcpNotes = [], 
+/**
+ * 进入模式时**全部**人设的开关状态（名字 → 是否开着）。给了就写进 `subagentsAll`：
+ * 退出时按它精确还原（场景里手动开过的人设也会被还原回进场景前的状态）。
+ */
+subagentStates = null) {
     return {
         mcp: Object.fromEntries(Object.entries(mcpRaw).map(([k, v]) => [k, v.slice()])),
         skills: { ...skills },
@@ -206,6 +211,7 @@ mcpNotes = []) {
         skillSources: skillSources.map((x) => ({ root: x.root, enabled: x.enabled })),
         ...(subagents.length ? { subagents: subagents.slice() } : {}),
         ...(subagentsOn.length ? { subagentsOn: subagentsOn.slice() } : {}),
+        ...(subagentStates ? { subagentsAll: { ...subagentStates } } : {}),
         ...(mcpNotes.length ? { mcpNotes: mcpNotes.map((x) => ({ id: x.id, note: x.note })) } : {}),
     };
 }

package/lib/rules/service.js

@@ -486,9 +486,9 @@ export function parseModeState(raw) {
                 list.push(tool);
         }
     }
-    // v2 快照的**服务器级 / 来源级**名单与 v0.8 的子智能体名单必须原样透传 ——
-    // 这里曾把它们剥掉，结果退出模式时两张恢复名单全是空的：服务器级 MCP 与技能来源
-    // 永远不回滚（用户报的「MCP 不复原」「技能目录不回退」），只有工具级 / 技能级能还原。
+    // v2 快照的**服务器级 / 来源级**名单、v0.8 的子智能体名单、v0.9.1 的人设全量映射
+    // 必须原样透传 —— 这里曾把它们剥掉，结果退出模式时两张恢复名单全是空的：服务器级 MCP 与
+    // 技能来源永远不回滚（用户报的「MCP 不复原」「技能目录不回退」），只有工具级 / 技能级能还原。
     const mcpServers = (Array.isArray(snapshotRaw.mcpServers) ? snapshotRaw.mcpServers : [])
         .filter((x) => !!x && typeof x === 'object')
         .map((x) => ({ id: String(x.id || ''), level: String(x.level || ''), disabled: x.disabled === true }))
@@ -501,6 +501,9 @@ export function parseModeState(raw) {
     // 同 subagents 一组：进入时被档案**关掉**的人设（退出要重新打开）。漏掉它 = 用户实测的
     // 「进场景关掉了，退出却没开回来」——快照落盘后读回来就只剩「被启用」那一半名单。
     const subagentsOn = (Array.isArray(snapshotRaw.subagentsOn) ? snapshotRaw.subagentsOn : []).map((x) => String(x)).filter(Boolean);
+    // v0.9.1 的人设**全量**开关映射（名字 → 进场景时是否开着）：同样必须原样透传 ——
+    // 剥掉它，退出模式就只能退回上面两个部分名单，「场景里手动开过的人设」不再被还原。
+    const subagentsAll = toFlagMap(snapshotRaw.subagentsAll);
     // v0.8.1 的场景备注恢复名单：**必须原样透传**——这里漏掉它，退出模式时备注永不回退
     //（与历史上 mcpServers / skillSources 被剥掉是同一类 bug）。
     const mcpNotes = (Array.isArray(snapshotRaw.mcpNotes) ? snapshotRaw.mcpNotes : [])
@@ -517,6 +520,7 @@ export function parseModeState(raw) {
                 ...(skillSources.length ? { skillSources } : {}),
                 ...(subagents.length ? { subagents } : {}),
                 ...(subagentsOn.length ? { subagentsOn } : {}),
+                ...(Object.keys(subagentsAll).length ? { subagentsAll } : {}),
                 ...(mcpNotes.length ? { mcpNotes } : {}),
             }
             : null,
@@ -1251,6 +1255,37 @@ function attachmentNamesSync(bundleDir, name) {
         return [];
     }
 }
+/**
+ * bundle 记忆的附件**摘要**（列表页用）：数量 / 总体积 / 前几个文件名。
+ *
+ * 口径与 `attachmentNamesSync`（也就是注入给模型的那份清单）逐字一致：跳过正文本体，
+ * 只认普通文件 —— 所以页面上的数字与模型实际看到的一致，不会出现「界面说 3 个、模型只见 2 个」。
+ * `names` 截到 ATTACHMENT_LIST_MAX：tooltip 列不下更多，要全看到编辑弹窗里去看。
+ *
+ * 目录读不到（索引残留了已消失的条目）→ 返回 null，让界面**什么都不显示**，
+ * 而不是谎报「0 个附件」。
+ */
+function attachmentSummarySync(bundleDir, name) {
+    let names;
+    try {
+        const docNames = new Set([bundleDocName(name), LEGACY_BUNDLE_DOC]);
+        names = readdirSync(bundleDir, { withFileTypes: true })
+            .filter((e) => e.isFile() && !docNames.has(e.name))
+            .map((e) => e.name)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return null;
+    }
+    let bytes = 0;
+    for (const entry of names) {
+        try {
+            bytes += statSync(join(bundleDir, entry)).size;
+        }
+        catch { /* 读不到的条目不计体积 */ }
+    }
+    return { count: names.length, bytes, names: names.slice(0, ATTACHMENT_LIST_MAX) };
+}
 /**
  * 附件行（只有 bundle 记忆才有）：**给目录与文件名，不给内容**。
  * 附件可能是图片、二进制、大 md —— 全文注入又贵又会把段预算吃光；给路径，模型需要时自己读。
@@ -1667,7 +1702,16 @@ export function createRulesService(ctx, deps) {
         const index = await readIndex(stateDir);
         const rules = snap.rules
             .filter((r) => !groupFilter || r.group === groupFilter)
-            .sort((a, b) => a.group.localeCompare(b.group) || a.order - b.order || a.name.localeCompare(b.name));
+            .sort((a, b) => a.group.localeCompare(b.group) || a.order - b.order || a.name.localeCompare(b.name))
+            // bundle 记忆附带附件摘要（用户裁定 2026-09-17）：界面要显示「几个附件」。
+            // 每条 bundle 一次 readdirSync + 每个附件一次 statSync —— bundle 记忆通常只有几条，
+            // 这个开销可以忽略；flat 没有目录，直接原样返回（不加字段 = 界面不显示附件标签）。
+            .map((r) => {
+            if (r.form !== 'bundle')
+                return r;
+            const attach = attachmentSummarySync(dirname(r.path), r.name);
+            return attach ? { ...r, attach } : r;
+        });
         const groups = groupFilter ? snap.groups.filter((g) => g.name === groupFilter) : snap.groups;
         const scenes = sceneRows(snap, index);
         // 场景锁定状态（v0.8）：任意一个场景锁定 = 五个管理域整体冻结。界面据此禁用各页的写控件。

package/lib/scene-prompt-sync.js

@@ -9,7 +9,8 @@
 // 六个动作会触发同步（调用方在 op 层包一层 `withSync`）：
 //   ① 启用/切换场景    ② 关掉场景（恢复进场景前的基线）
 //   ③ 改场景绑定的预设  ④ 编辑"正在驱动基线的那份预设"的正文
-//   ⑤ 从回收站恢复预设（绑定重新变活）  ⑥ 应用提示词（场景接管时只放行绑定的那一份）
+//   ⑤ 从回收站恢复预设（绑定重新变活）  ⑥ 应用提示词（**应用别的份 = 换掉当前场景的绑定**，
+//      改完绑定再走一次同步；见 index.ts 的 `applyPresetGuarded`）
 //
 // 「进场景前的基线」快照存在 hub 的 `scene-baseline.json`：进场景时记下当时的
 // AGENTS.md 正文（以及当时匹配到的预设 id），关掉场景时**按原文**写回 ——
@@ -20,7 +21,7 @@
 // 写失败**不改**原操作的成功结论，而是把原因放进 `error` 交给界面显示成警告。
 //
 // 这里同时是**三条状态的事实源**（用户实测反馈「显示 A、实际注入 B、A 还能删 B 不能删」后加的）：
-//   `driver()`     —— 谁在驱动基线（提示词页「应用」的守卫依据：场景接管期间不许应用别的预设）；
+//   `driver()`     —— 谁在驱动基线（提示词页「应用」据此判断：应用别的份 = 换掉该场景的绑定）；
 //   `refs()`       —— 每个预设被谁引用（删除保护的唯一依据：场景绑定 / 基线当前内容 / 退出恢复目标）；
 //   `baseline()`   —— 进场景前的基线快照（退出场景后要恢复的那一份）。
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
@@ -85,15 +86,6 @@ export function createScenePromptSync(deps) {
             return null;
         return { scene: current.scene, label: current.label || current.scene, presetId: current.presetId };
     }
-    async function applyGuard(id) {
-        const current = await driver();
-        if (!current)
-            return null;
-        // 同一份 = 重新应用（把被手改的基线写回场景绑定的内容）→ 放行。
-        if (current.presetId === String(id ?? '').trim())
-            return null;
-        return current;
-    }
     async function refs() {
         const out = new Map();
         const add = (id, ref) => {
@@ -197,5 +189,5 @@ export function createScenePromptSync(deps) {
         const agentsMd = await sync();
         return { ...res, agentsMd };
     }
-    return { sync, withSync, state, driver, applyGuard, refs };
+    return { sync, withSync, state, driver, refs };
 }

package/lib/skills/service.js

@@ -308,6 +308,33 @@ export function createSkillsService(ctx) {
         const list = await projectRoots(projectOptions().projectCwds);
         return list.find((root) => root.key === key);
     };
+    /**
+     * **项目来源**（`project-dsh:<hash>` / `project-agents:<hash>`）能不能被启停，此前取决于
+     * 「它的工作区此刻在不在活动会话里」（`requestRoot` 的第三步）——于是场景快照恢复时工作区
+     * 早已关闭，解析落空 → `setSourceEnabled(undefined)` → 「该技能来源不允许启用或停用」→
+     * 退出模式直接失败、卡在场景里（用户 2026-09-17 报的）。
+     *
+     * key 本身就是自描述的（`<kind>:<路径哈希>`），而启停只写本地状态文件
+     * （`state.sources[key]`），一个字节都不碰源目录 —— 所以按前缀合成一个最小 definition
+     * 交给 core 即可：这个工作区下次被打开时，来源按记录的状态生效。
+     */
+    const PROJECT_SOURCE_KEY_RE = /^project-(dsh|agents):[a-f0-9]{16}$/;
+    function projectKeyStub(key) {
+        if (!PROJECT_SOURCE_KEY_RE.test(key))
+            return undefined;
+        return {
+            key,
+            kind: key.slice(0, key.indexOf(':')),
+            scope: 'project',
+            toggleable: true,
+            mutable: false,
+            deletable: false,
+            label: key,
+            path: '',
+        };
+    }
+    /** 启停来源专用的解析：静态 / 自定义 / 活动工作区都命中不了时，按 key 前缀兜底。 */
+    const requestSwitchRoot = async (key) => (await requestRoot(key)) || projectKeyStub(key);
     const providerInvalidators = new Set();
     const invalidateSkills = () => {
         for (const invalidate of providerInvalidators) {
@@ -402,6 +429,8 @@ export function createSkillsService(ctx) {
         'skill-source-remove', 'skill-source-restore',
         'skill-prefer', 'skill-unprefer',
         'skill-create', 'skill-import', 'skill-upload', 'skill-delete',
+        // 批量启停与单条启停同权：配了访问令牌的宿主必须同样要求带令牌。
+        'skill-set-all',
         'skill-trash-restore', 'skill-trash-delete', 'skill-custom-add', 'skill-custom-remove',
     ]);
     const ops = {
@@ -416,14 +445,39 @@ export function createSkillsService(ctx) {
         // 启停（写 manager 状态，不改源文件）
         'skill-enable': wrap((args) => write(async () => setSkillEnabled(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), true, log)), afterWrite),
         'skill-disable': wrap((args) => write(async () => setSkillEnabled(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), false, log)), afterWrite),
-        'skill-source-enable': wrap((args) => write(async () => setSourceEnabled(await requestRoot(String(args.root || '')), true, log)), afterWrite),
-        'skill-source-disable': wrap((args) => write(async () => setSourceEnabled(await requestRoot(String(args.root || '')), false, log)), afterWrite),
+        'skill-source-enable': wrap((args) => write(async () => setSourceEnabled(await requestSwitchRoot(String(args.root || '')), true, log)), afterWrite),
+        'skill-source-disable': wrap((args) => write(async () => setSourceEnabled(await requestSwitchRoot(String(args.root || '')), false, log)), afterWrite),
         // 移除 / 恢复来源（「不再读取这个文件夹」）：只改本地状态，源目录一个字节都不动。
         'skill-source-remove': wrap((args) => write(async () => setSourceRemoved(await requestRoot(String(args.root || '')), true, log)), afterWrite),
         'skill-source-restore': wrap((args) => write(async () => setSourceRemoved(await requestRoot(String(args.root || '')), false, log)), afterWrite),
         // 同名技能首选来源（手工指定哪个同名版本生效；只写本地策略）。
         'skill-prefer': wrap((args) => write(async () => setPreferredSkill(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), true, log)), afterWrite),
         'skill-unprefer': wrap((args) => write(async () => setPreferredSkill(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), false, log)), afterWrite),
+        /**
+         * 批量启停（技能页 / 记忆页那种「全选 / 取消全选」用）。
+         *
+         * 为什么要有它：前端逐条打单条 op 时，每次成功都会清状态缓存 + 重扫技能目录 +
+         * 广播 agent-preset 事件，几十上百条就是几十上百轮全量重扫。这里一次写锁走完、
+         * 只在最后失效一次。逐条仍复用单条写通道（不另写一份策略逻辑）。
+         */
+        'skill-set-all': wrap((args) => write(async () => {
+            const items = Array.isArray(args && args.items) ? args.items : [];
+            const enabled = (args && args.enabled) === true;
+            const failed = [];
+            let changed = 0;
+            for (const item of items) {
+                const rootKey = String((item && item.root) || '');
+                const name = String((item && item.name) || '');
+                if (!rootKey || !name)
+                    continue;
+                const res = await setSkillEnabled(await requestRoot(rootKey), name, enabled, log);
+                if (res && res.ok === false)
+                    failed.push({ root: rootKey, name, error: String(res.error || '') });
+                else
+                    changed++;
+            }
+            return { enabled, changed, failed };
+        }), afterWrite),
         // 创建 / 导入 / 删除 / 回收站
         // 创建默认落 hub（`tool-management/skills/`）：UI 不传 root 时走这里；
         // core.js 的 createSkill 默认值是第二道保险（同口径）。官方 `~/.dsh/skills/` 仍作为来源列出。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-tool-management",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "DSH plugin: one settings panel for MCP servers, skills, scenes, memories, subagents, AGENTS.md presets and archived sessions — scene memory injects into the system prompt, scene lock freezes all five domains, deleted workspaces re-register with one click. Settings UI + HTTP API + 14 model tools (mcp_manager_*, skill_manager_*, prompt_manager_*, memory_manager_*, subagent_*). Install with one command: dsh plugin --profile web add dsh-plugin-tool-management@latest",
   "repository": {
     "type": "git",