dsh-plugin-tool-management 0.16.6 → 0.18.0

package/lib/sessions/archive-schemas.js

@@ -0,0 +1,121 @@
+export const sessionIdSchema = {
+    parse(value) {
+        if (typeof value !== "string" || value.length === 0)
+            throw new TypeError(`sessionId must be a non-empty string, got ${String(value)}`);
+        return value;
+    },
+};
+export const workspaceIdSchema = {
+    parse(value) {
+        if (typeof value !== "string" || value.length === 0)
+            throw new TypeError(`workspaceId must be a non-empty string, got ${String(value)}`);
+        return value;
+    },
+};
+export const archivedSetSchema = {
+    parse(value) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new TypeError("result must be an object");
+        const ids = value.archivedSessionIds;
+        if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string"))
+            throw new TypeError("archivedSessionIds must be a string array");
+        return value;
+    },
+};
+export const deletedSchema = {
+    parse(value) {
+        if (typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value) ||
+            value.deleted !== true)
+            throw new TypeError("deleted must be true");
+        return value;
+    },
+};
+export const archivedBatchTargetSchema = {
+    // 校验通过后原样返回记录，调用方按 scope 判别式收窄（宿主返回值校验器，故返回 any）。
+    parse(value) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new TypeError("target must be an object");
+        if (value.scope === "all" || value.scope === "ungrouped")
+            return value;
+        if (value.scope === "workspace" &&
+            typeof value.workspaceId === "string" &&
+            value.workspaceId.length > 0)
+            return value;
+        if (value.scope === "sessions" &&
+            Array.isArray(value.sessionIds) &&
+            value.sessionIds.length > 0 &&
+            value.sessionIds.every((id) => typeof id === "string" && id.length > 0))
+            return value;
+        throw new TypeError("target.scope must be all, ungrouped, workspace with a non-empty workspaceId, or sessions with non-empty sessionIds");
+    },
+};
+export const unarchivedBatchSchema = {
+    parse(value) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new TypeError("result must be an object");
+        if (!Array.isArray(value.archivedSessionIds) ||
+            value.archivedSessionIds.some((id) => typeof id !== "string"))
+            throw new TypeError("archivedSessionIds must be a string array");
+        if (!Array.isArray(value.unarchivedSessionIds) ||
+            value.unarchivedSessionIds.some((id) => typeof id !== "string"))
+            throw new TypeError("unarchivedSessionIds must be a string array");
+        return value;
+    },
+};
+export const archivedWorkspaceBatchSchema = {
+    parse(value) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new TypeError("result must be an object");
+        if (!Array.isArray(value.archivedSessionIds) ||
+            value.archivedSessionIds.some((id) => typeof id !== "string"))
+            throw new TypeError("archivedSessionIds must be a string array");
+        if (!Array.isArray(value.archivedSessionIdsAdded) ||
+            value.archivedSessionIdsAdded.some((id) => typeof id !== "string"))
+            throw new TypeError("archivedSessionIdsAdded must be a string array");
+        return value;
+    },
+};
+export const deletedBatchSchema = {
+    parse(value) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new TypeError("result must be an object");
+        for (const key of [
+            "requestedSessionIds",
+            "deletedSessionIds",
+            "skippedSessionIds",
+        ]) {
+            if (!Array.isArray(value[key]) ||
+                value[key].some((id) => typeof id !== "string"))
+                throw new TypeError(`${key} must be a string array`);
+        }
+        if (!Array.isArray(value.failures) ||
+            value.failures.some((failure) => typeof failure !== "object" ||
+                failure === null ||
+                typeof failure.sessionId !== "string" ||
+                typeof failure.message !== "string"))
+            throw new TypeError("failures must contain sessionId/message objects");
+        return value;
+    },
+};
+export const archivedSessionMetadataSchema = {
+    parse(value) {
+        if (typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value) ||
+            !Array.isArray(value.items))
+            throw new TypeError("result.items must be an array");
+        if (value.items.some((item) => typeof item !== "object" ||
+            item === null ||
+            typeof item.sessionId !== "string" ||
+            typeof item.createdAt !== "number" ||
+            !Number.isFinite(item.createdAt)))
+            throw new TypeError("items must contain sessionId/createdAt objects");
+        if (value.repairedSessionIds !== void 0 &&
+            (!Array.isArray(value.repairedSessionIds) ||
+                value.repairedSessionIds.some((id) => typeof id !== "string")))
+            throw new TypeError("repairedSessionIds must be a string array");
+        return value;
+    },
+};

package/lib/sessions/path-key.js

@@ -0,0 +1,46 @@
+// 工作区路径的归一化比较键与展示名。
+//
+// 从 sessions/workspace.ts 整段搬来，一行未改。workspacePathKey 的口径注释里写着它不是
+// 「只用于分组」而是决定会话挂回哪条登记，也写着它比宿主 realpathNormalize 更宽 ——
+// 那两条是本插件的已知假设，改这个文件前先读它们。
+/**
+ * 路径比较键：工作区的唯一性在宿主侧是 realpath 字符串相等（dsh-workspace
+ * `realpathNormalize`），Windows 盘符大小写与分隔符拼写却可能不同，因此比较前
+ * 先归一化。
+ *
+ * ⚠ 它不是"只用于分组"：它决定**哪些会话被挂回哪条登记** —— `registerWorkspace` 会调
+ * `attachKnownSessions`，后者按这个键挑选会话并写宿主记账（`sessionIds`）；
+ * `ensureWorkspaceAccounting` 也拿它当去重键后 `host.create` + 挂回。
+ * 而且它比宿主更宽：宿主 `realpathNormalize` 只是 `fs.realpath`（**不做大小写归一**），
+ * 本函数在 Windows 上 `toLowerCase()` ⇒ `C:\Proj` 与 `c:\proj` 在插件里同组、在宿主里
+ * 可以是两条登记。挂回前应以宿主 `resolveByPath` 实际返回的 id 复核，而不是按归一字符串匹配。
+ * @param {string} path - 原始路径。
+ * @returns {string} 归一化后的比较键（空路径返回空串）。
+ */
+export function workspacePathKey(path) {
+    const raw = String(path ?? "").trim();
+    if (!raw)
+        return "";
+    const windows = /^[A-Za-z]:[\\/]/.test(raw) || raw.startsWith("\\\\");
+    let out = windows ? raw.replace(/\//g, "\\") : raw;
+    while (out.length > 1 && (out.endsWith("\\") || out.endsWith("/")))
+        out = out.slice(0, -1);
+    return windows ? out.toLowerCase() : out;
+}
+/**
+ * 展示用目录名（与宿主 `defaultWorkspaceTitle` 同义：末段，无末段则用根拼写）。
+ * @param {string} path - 原始路径。
+ * @returns {string} 非空展示名。
+ */
+export function workspaceBaseName(path) {
+    const raw = String(path ?? "").trim();
+    if (!raw)
+        return "";
+    const trimmed = raw.replace(/[\\/]+$/, "");
+    const index = Math.max(trimmed.lastIndexOf("\\"), trimmed.lastIndexOf("/"));
+    const segment = index >= 0 ? trimmed.slice(index + 1) : trimmed;
+    if (segment)
+        return segment;
+    const root = trimmed.match(/^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/);
+    return root ? root[0] : trimmed || raw;
+}

package/lib/sessions/workspace.js

@@ -4,6 +4,8 @@ import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { hubPath } from "../hub.js";
 import { sessionDir } from "@deepseek-ai/dsh-spill-local";
 import { trackTombstone } from "./tombstone.js";
+import { archivedBatchTargetSchema, workspaceIdSchema, } from "./archive-schemas.js";
+import { workspaceBaseName, workspacePathKey } from "./path-key.js";
 import { noteRuntime } from "../compat/runtime-notes.js";
 /**
  * A3-1：宿主补上了原生删除入口时上报一次（**不切换**，理由见 deleteSessionCore）。
@@ -113,127 +115,6 @@ function headerIdentity(header) {
         cwd: header.cwd ?? null,
     };
 }
-const sessionIdSchema = {
-    parse(value) {
-        if (typeof value !== "string" || value.length === 0)
-            throw new TypeError(`sessionId must be a non-empty string, got ${String(value)}`);
-        return value;
-    },
-};
-const workspaceIdSchema = {
-    parse(value) {
-        if (typeof value !== "string" || value.length === 0)
-            throw new TypeError(`workspaceId must be a non-empty string, got ${String(value)}`);
-        return value;
-    },
-};
-const archivedSetSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        const ids = value.archivedSessionIds;
-        if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIds must be a string array");
-        return value;
-    },
-};
-const deletedSchema = {
-    parse(value) {
-        if (typeof value !== "object" ||
-            value === null ||
-            Array.isArray(value) ||
-            value.deleted !== true)
-            throw new TypeError("deleted must be true");
-        return value;
-    },
-};
-const archivedBatchTargetSchema = {
-    // 校验通过后原样返回记录，调用方按 scope 判别式收窄（宿主返回值校验器，故返回 any）。
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("target must be an object");
-        if (value.scope === "all" || value.scope === "ungrouped")
-            return value;
-        if (value.scope === "workspace" &&
-            typeof value.workspaceId === "string" &&
-            value.workspaceId.length > 0)
-            return value;
-        if (value.scope === "sessions" &&
-            Array.isArray(value.sessionIds) &&
-            value.sessionIds.length > 0 &&
-            value.sessionIds.every((id) => typeof id === "string" && id.length > 0))
-            return value;
-        throw new TypeError("target.scope must be all, ungrouped, workspace with a non-empty workspaceId, or sessions with non-empty sessionIds");
-    },
-};
-const unarchivedBatchSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        if (!Array.isArray(value.archivedSessionIds) ||
-            value.archivedSessionIds.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIds must be a string array");
-        if (!Array.isArray(value.unarchivedSessionIds) ||
-            value.unarchivedSessionIds.some((id) => typeof id !== "string"))
-            throw new TypeError("unarchivedSessionIds must be a string array");
-        return value;
-    },
-};
-const archivedWorkspaceBatchSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        if (!Array.isArray(value.archivedSessionIds) ||
-            value.archivedSessionIds.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIds must be a string array");
-        if (!Array.isArray(value.archivedSessionIdsAdded) ||
-            value.archivedSessionIdsAdded.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIdsAdded must be a string array");
-        return value;
-    },
-};
-const deletedBatchSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        for (const key of [
-            "requestedSessionIds",
-            "deletedSessionIds",
-            "skippedSessionIds",
-        ]) {
-            if (!Array.isArray(value[key]) ||
-                value[key].some((id) => typeof id !== "string"))
-                throw new TypeError(`${key} must be a string array`);
-        }
-        if (!Array.isArray(value.failures) ||
-            value.failures.some((failure) => typeof failure !== "object" ||
-                failure === null ||
-                typeof failure.sessionId !== "string" ||
-                typeof failure.message !== "string"))
-            throw new TypeError("failures must contain sessionId/message objects");
-        return value;
-    },
-};
-const archivedSessionMetadataSchema = {
-    parse(value) {
-        if (typeof value !== "object" ||
-            value === null ||
-            Array.isArray(value) ||
-            !Array.isArray(value.items))
-            throw new TypeError("result.items must be an array");
-        if (value.items.some((item) => typeof item !== "object" ||
-            item === null ||
-            typeof item.sessionId !== "string" ||
-            typeof item.createdAt !== "number" ||
-            !Number.isFinite(item.createdAt)))
-            throw new TypeError("items must contain sessionId/createdAt objects");
-        if (value.repairedSessionIds !== void 0 &&
-            (!Array.isArray(value.repairedSessionIds) ||
-                value.repairedSessionIds.some((id) => typeof id !== "string")))
-            throw new TypeError("repairedSessionIds must be a string array");
-        return value;
-    },
-};
 /**
  * 折叠进 dsh-plugin-tool-management 的归档工作区注册表。
  * 原始实现来自 @michengai/dsh-archive-manager（Apache-2.0），剥离了
@@ -247,47 +128,6 @@ function defaultArchivedAtFile() {
 function defaultWorkspaceSnapshotFile() {
     return hubPath("history-workspaces.json");
 }
-/**
- * 路径比较键：工作区的唯一性在宿主侧是 realpath 字符串相等（dsh-workspace
- * `realpathNormalize`），Windows 盘符大小写与分隔符拼写却可能不同，因此比较前
- * 先归一化。
- *
- * ⚠ 它不是"只用于分组"：它决定**哪些会话被挂回哪条登记** —— `registerWorkspace` 会调
- * `attachKnownSessions`，后者按这个键挑选会话并写宿主记账（`sessionIds`）；
- * `ensureWorkspaceAccounting` 也拿它当去重键后 `host.create` + 挂回。
- * 而且它比宿主更宽：宿主 `realpathNormalize` 只是 `fs.realpath`（**不做大小写归一**），
- * 本函数在 Windows 上 `toLowerCase()` ⇒ `C:\Proj` 与 `c:\proj` 在插件里同组、在宿主里
- * 可以是两条登记。挂回前应以宿主 `resolveByPath` 实际返回的 id 复核，而不是按归一字符串匹配。
- * @param {string} path - 原始路径。
- * @returns {string} 归一化后的比较键（空路径返回空串）。
- */
-function workspacePathKey(path) {
-    const raw = String(path ?? "").trim();
-    if (!raw)
-        return "";
-    const windows = /^[A-Za-z]:[\\/]/.test(raw) || raw.startsWith("\\\\");
-    let out = windows ? raw.replace(/\//g, "\\") : raw;
-    while (out.length > 1 && (out.endsWith("\\") || out.endsWith("/")))
-        out = out.slice(0, -1);
-    return windows ? out.toLowerCase() : out;
-}
-/**
- * 展示用目录名（与宿主 `defaultWorkspaceTitle` 同义：末段，无末段则用根拼写）。
- * @param {string} path - 原始路径。
- * @returns {string} 非空展示名。
- */
-function workspaceBaseName(path) {
-    const raw = String(path ?? "").trim();
-    if (!raw)
-        return "";
-    const trimmed = raw.replace(/[\\/]+$/, "");
-    const index = Math.max(trimmed.lastIndexOf("\\"), trimmed.lastIndexOf("/"));
-    const segment = index >= 0 ? trimmed.slice(index + 1) : trimmed;
-    if (segment)
-        return segment;
-    const root = trimmed.match(/^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/);
-    return root ? root[0] : trimmed || raw;
-}
 // Standalone facade over the existing registry. Never instantiate/register a
 // second WorkspaceRegistry, and never open another copy of its storage domain.
 var ArchiveWorkspaceRegistry = class {
@@ -1056,8 +896,11 @@ var ArchiveWorkspaceRegistry = class {
     /**
      * 永久删除一个会话及其全部痕迹（转录目录、工作区记账、归档标记、
      * 投影缓存行）。
+     *
+     * 级联只删**已归档**的子代理会话（审查 F10）；被保留的未归档子会话 id 通过
+     * `keptUnarchivedDescendants` 回给调用方，界面据此如实呈现，不假装整支都没了。
      * @param sessionId - 要删除的会话。
-     * @returns 持久化完成后的 `{ deleted: true }`。
+     * @returns `{ deleted: true }`，有被保留的未归档子会话时附带其 id。
      * @throws {@link ArchiveUnknownSessionError} 会话未知时抛出。
      */
     async deleteSession(sessionId) {
@@ -1144,7 +987,9 @@ var ArchiveWorkspaceRegistry = class {
         await projCache?.whenIdle?.();
         if (projCache !== void 0)
             await projCache.delete(sessionId);
-        await this.deleteDescendants(sessionId, storedIndex);
+        // 级联只吃已归档的子会话；被保留（未归档）的 id 一路带回 op 层，让界面/模型
+        // 知道「父会话已删，但这一支没有全没」（审查 F10）。
+        const keptDescendants = await this.deleteDescendants(sessionId, storedIndex);
         await this.cleanSpill(sessionId);
         await this.removeTranscriptDirectory(sessionId);
         // 只有物理工件删除成功后才能提交记账清理；否则批量目标会因归档标记
@@ -1163,7 +1008,12 @@ var ArchiveWorkspaceRegistry = class {
         if (deletedHeader !== void 0)
             this.deletedIdentities.set(sessionId, headerIdentity(deletedHeader));
         this.publishDeletedSession(sessionId);
-        return { deleted: true };
+        return {
+            deleted: true,
+            ...(keptDescendants.length === 0
+                ? {}
+                : { keptUnarchivedDescendants: keptDescendants }),
+        };
     }
     /** 删除完成后通知全部客户端；新版不再通过伪造冷会话生命周期触发通知。 */
     publishDeletedSession(sessionId) {
@@ -1394,8 +1244,21 @@ var ArchiveWorkspaceRegistry = class {
     /** 尽力而为的级联删除：删除 `sessionId` 的 SUBAGENT 子会话。
      * 仅头部标记 `origin: "subagent"` 的会话参与：单凭 `parentSession` 有歧义
      *（fork 分支也携带它），而 fork 分支是独立的用户会话，绝不能被级联删除。
-     * @param storedIndex - 可选的批首 `id → header` 快照，见 {@link storedHeaderIndex}。 */
+     *
+     * **只级联「已归档」的子会话**（2026-09-30 审查 F10）。此前这里只按
+     * `parentSession + origin: subagent` 收集就逐个 `deleteSessionCore`，**完全不查归档集合**，
+     * 于是「只能删已归档」在**注册表层不成立** —— 删一个已归档父会话，会把它**未归档**的子代理
+     * 会话一起永久删掉。op 入口那层的收敛（`history-delete` / `deleteArchivedSessions`）拦不住
+     * 这条路：级联发生在删除主体内部，不经过任何 op 门禁。现在把不变量落到这里，而不是只写在
+     * 注释里 —— 未归档的一律**保留**（之后可单独归档再删），并记一条日志说明保留了哪些。
+     *
+     * 归档集合取 `requireState().archivedSessionIds`（权威），不取 `archivedSessionMetadata()`
+     * 那份有损投影；`requireState()` 抛错时**一个都不删**（fail-closed：宁可不级联，也不凭未知
+     * 状态做不可逆操作）。
+     * @param storedIndex - 可选的批首 `id → header` 快照，见 {@link storedHeaderIndex}。
+     * @returns 被保留（未归档）的子会话 id（含后代递归上来的），全部删净时为空数组。 */
     async deleteDescendants(sessionId, storedIndex) {
+        const kept = [];
         try {
             const descendants = [];
             const sessions = this.ctx.get("sessions");
@@ -1414,11 +1277,20 @@ var ArchiveWorkspaceRegistry = class {
                     !descendants.includes(header.id))
                     descendants.push(header.id);
             }
+            // 先取归档集合再动手：它抛错时一个子会话都不会被删（fail-closed）。
+            const archived = new Set(this.requireState().archivedSessionIds);
             for (const childId of descendants) {
+                if (!archived.has(childId)) {
+                    kept.push(childId);
+                    continue;
+                }
                 try {
                     if (!(await this.sessionKnown(childId, storedIndex)))
                         continue;
-                    await this.deleteSessionCore(childId, storedIndex);
+                    const result = await this.deleteSessionCore(childId, storedIndex);
+                    // 孙辈里被保留的同样要往上带，否则界面只看到最外一层。
+                    if (Array.isArray(result?.keptUnarchivedDescendants))
+                        kept.push(...result.keptUnarchivedDescendants);
                 }
                 catch (error) {
                     if (error instanceof ArchiveUnknownSessionError)
@@ -1426,10 +1298,13 @@ var ArchiveWorkspaceRegistry = class {
                     this.ctx.logger.warn(`archive-manager: cascade delete of subagent session "${childId}" (child of "${sessionId}") failed: ${String(error)}`);
                 }
             }
+            if (kept.length)
+                this.ctx.logger.warn(`archive-manager: cascade delete of "${sessionId}" kept ${kept.length} unarchived subagent session(s) — only archived sessions may be deleted: ${kept.join(", ")}`);
         }
         catch (error) {
             this.ctx.logger.warn(`archive-manager: descendant enumeration for deleted session "${sessionId}" failed: ${String(error)}`);
         }
+        return kept;
     }
     /** 尽力而为的 spill 清理：移除该会话作用域的 spill 目录。 */
     async cleanSpill(sessionId) {
@@ -1448,4 +1323,6 @@ var ArchiveWorkspaceRegistry = class {
     }
 };
 //#endregion
-export { ArchiveWorkspaceRegistry, ArchiveWorkspaceRegistry as default, workspaceBaseName, workspacePathKey };
+export { ArchiveWorkspaceRegistry, ArchiveWorkspaceRegistry as default };
+// 路径键拆进 path-key.ts 后照旧从这个入口对外可见（package.json 的 exports 只声明 ./workspace）。
+export { workspaceBaseName, workspacePathKey } from "./path-key.js";

package/lib/settings-sidecars.js

@@ -0,0 +1,143 @@
+// 三份界面设置侧车（inject / scene / slash）的读写与 TTL 缓存。
+//
+// 正文从 index.ts 的 apply 闭包里整段搬来，一字未改（只去一层缩进，并把五个 apply 作用域
+// 名字改成走 deps —— moved-verify 按这三类容差机检）。
+//
+// 为什么三份缓存仍留在闭包里：本工厂在 apply 的同一位置只调用一次，`let *Cache` 还是
+// 「每次 apply 一份」。搬到模块级就变成每进程一份，热更新重进 apply 时旧缓存会被复用 ——
+// 那是语义翻转，不是搬家。
+import { hubPath } from './hub.js';
+import { DEFAULT_INJECT_SETTINGS, normalizeInjectSettings } from './context-inject.js';
+import { normalizeSceneSettings } from './scene-settings.js';
+import { normalizeSlashSettings } from './slash-settings.js';
+export function createSettingsSidecars(deps) {
+    // 注入设置（侧车 `inject-settings.json`，界面在「兼容」页）：
+    //   - underSuppressingPresets：压制型预设（persona complete / 关运行时上下文，如极简）
+    //     下是否仍然注入。默认 false = 跟随预设。
+    //   - domains：各域开关（任何预设下都生效；界面五个勾选）。
+    // 注入器每个 step 都要同步读一次设置 → 走 TTL 缓存；未加载时先给默认值并异步预热。
+    const INJECT_SETTINGS_FILE = 'inject-settings.json';
+    const INJECT_SETTINGS_TTL_MS = 3000;
+    let injectSettingsCache = null;
+    async function readInjectSettings(force = false) {
+        if (injectSettingsCache && !force && Date.now() - injectSettingsCache.at < INJECT_SETTINGS_TTL_MS)
+            return injectSettingsCache.value;
+        await deps.ensurePaths();
+        const raw = await deps.readJsonFile(hubPath(INJECT_SETTINGS_FILE));
+        injectSettingsCache = { at: Date.now(), value: normalizeInjectSettings(raw) };
+        return injectSettingsCache.value;
+    }
+    /** 同步快照（注入器取用）；还没加载时先返回默认值，并顺手预热一次。 */
+    function injectSettingsSync() {
+        if (injectSettingsCache)
+            return injectSettingsCache.value;
+        void readInjectSettings().catch(() => { });
+        return DEFAULT_INJECT_SETTINGS;
+    }
+    /** 边界提示要的注入设置快照（总开关 + 各域开关）。 */
+    const injectNoticeOptions = () => {
+        const s = injectSettingsSync();
+        return { underSuppressingPresets: s.underSuppressingPresets, domains: s.domains };
+    };
+    async function injectSettingsOp(args) {
+        const current = await readInjectSettings();
+        if (!args || args.set !== true)
+            return { ok: true, settings: current };
+        const next = normalizeInjectSettings({
+            underSuppressingPresets: typeof args.underSuppressingPresets === 'boolean'
+                ? args.underSuppressingPresets
+                : current.underSuppressingPresets,
+            domains: { ...current.domains, ...(args.domains && typeof args.domains === 'object' ? args.domains : {}) },
+        });
+        await deps.ensurePaths();
+        return deps.withWriteLock(async () => {
+            try {
+                await deps.writeJsonFile(hubPath(INJECT_SETTINGS_FILE), next);
+            }
+            catch (e) {
+                return { ok: false, error: '设置保存失败: ' + deps.message(e) };
+            }
+            injectSettingsCache = { at: Date.now(), value: next };
+            return { ok: true, settings: next };
+        });
+    }
+    // 场景页的界面设置（侧车 `scene-settings.json`）：目前只有一项 —— 进入场景前要不要先弹
+    // 那张「会改什么」的卡。它纯粹是界面提示，所以**不进场景冻结**（锁着场景的人在场景页
+    // 照样能关掉提醒，那与五个管理域的只读无关）。
+    const SCENE_SETTINGS_FILE = 'scene-settings.json';
+    const SCENE_SETTINGS_TTL_MS = 3000;
+    let sceneSettingsCache = null;
+    async function readSceneSettings(force = false) {
+        if (sceneSettingsCache && !force && Date.now() - sceneSettingsCache.at < SCENE_SETTINGS_TTL_MS)
+            return sceneSettingsCache.value;
+        await deps.ensurePaths();
+        const raw = await deps.readJsonFile(hubPath(SCENE_SETTINGS_FILE));
+        const value = normalizeSceneSettings(raw);
+        sceneSettingsCache = { at: Date.now(), value };
+        return value;
+    }
+    async function sceneSettingsOp(args) {
+        const current = await readSceneSettings();
+        if (!args || args.set !== true)
+            return { ok: true, settings: current };
+        const next = normalizeSceneSettings({
+            enterPreview: typeof args.enterPreview === 'boolean' ? args.enterPreview : current.enterPreview,
+        });
+        await deps.ensurePaths();
+        return deps.withWriteLock(async () => {
+            try {
+                await deps.writeJsonFile(hubPath(SCENE_SETTINGS_FILE), next);
+            }
+            catch (e) {
+                return { ok: false, error: '设置保存失败: ' + deps.message(e) };
+            }
+            sceneSettingsCache = { at: Date.now(), value: next };
+            return { ok: true, settings: next };
+        });
+    }
+    // 斜杠命令入口的开关（侧车 `slash-settings.json`）：两段各一颗 —— 「工具」与「快捷提示词」。
+    // 判据与 `scene-settings` 同一条 —— 它是入口开关、不是管理动作，所以不冻结；读侧不带 `set`
+    // 时是纯读（客户端 boot 时必问一次，不能要令牌）。
+    const SLASH_SETTINGS_FILE = 'slash-settings.json';
+    const SLASH_SETTINGS_TTL_MS = 3000;
+    let slashSettingsCache = null;
+    async function readSlashSettings(force = false) {
+        if (slashSettingsCache && !force && Date.now() - slashSettingsCache.at < SLASH_SETTINGS_TTL_MS)
+            return slashSettingsCache.value;
+        await deps.ensurePaths();
+        const raw = await deps.readJsonFile(hubPath(SLASH_SETTINGS_FILE));
+        const value = normalizeSlashSettings(raw);
+        slashSettingsCache = { at: Date.now(), value };
+        return value;
+    }
+    async function slashSettingsOp(args) {
+        const current = await readSlashSettings();
+        if (!args || args.set !== true)
+            return { ok: true, settings: current };
+        const next = normalizeSlashSettings({
+            tools: typeof args.tools === 'boolean' ? args.tools : current.tools,
+            quickPrompts: typeof args.quickPrompts === 'boolean' ? args.quickPrompts : current.quickPrompts,
+        });
+        await deps.ensurePaths();
+        return deps.withWriteLock(async () => {
+            try {
+                await deps.writeJsonFile(hubPath(SLASH_SETTINGS_FILE), next);
+            }
+            catch (e) {
+                return { ok: false, error: '设置保存失败: ' + deps.message(e) };
+            }
+            slashSettingsCache = { at: Date.now(), value: next };
+            return { ok: true, settings: next };
+        });
+    }
+    return {
+        readInjectSettings,
+        injectSettingsSync,
+        injectNoticeOptions,
+        injectSettingsOp,
+        readSceneSettings,
+        sceneSettingsOp,
+        readSlashSettings,
+        slashSettingsOp,
+    };
+}

package/lib/skills/core-types.js

@@ -0,0 +1,8 @@
+// 技能核心的类型面（回执形状、状态文档、扫描与导入结构）。
+//
+// 从 core.ts 整段搬来，一行未改；类型在编译期擦除，所以这一刀不动运行时一个字。
+// 拆它的理由很直白：core.ts 那四千多行里，「每个函数返回什么形状」与「怎么读写磁盘」
+// 原本挤在同一个文件里来回翻。
+//
+// 这些类型原先是 core.ts 的私有声明（无一 export），现在导出层只服务 core.ts 自己。
+export {};