dsh-plugin-tool-management 0.9.1 → 0.11.0

package/lib/skills/core.js

@@ -12,11 +12,12 @@
 // 系统异常（fs ENOENT 等）透传 String(e.message)，不加 code。
 // 文件写入错误由路由返回给调用方。
 import { homedir } from "node:os";
-import { join, basename, dirname, resolve, relative, isAbsolute, sep, } from "node:path";
+import { join, basename, dirname, resolve, isAbsolute, } from "node:path";
 import { promises as fs } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { unzipSync } from "fflate";
 import { discoverReadonlyEntries, validDiscoveryName, } from "./readonly-discovery.js";
+import { isSameOrDescendant, isValidSegment } from "../paths.js";
 const KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const PROJECT_ROOT_KEY_RE = /^project-(?:dsh|agents):[a-f0-9]{16}$/;
 const CUSTOM_ROOT_KEY_RE = /^custom-[a-f0-9]{16}$/;
@@ -41,10 +42,12 @@ function codedError(message, code, params) {
 }
 /** 把业务 Error 的 code/params 附加到失败明细；系统异常（ENOENT 等，非 error.* 前缀）保持原文。 */
 function attachCode(item, error) {
-    if (error && typeof error.code === "string" && /^error\./.test(error.code))
-        item.code = error.code;
-    if (error && error.params)
-        item.params = error.params;
+    // 透传并回写任意失败明细对象（形状由各调用点决定），故按 any 处理。
+    const coded = error;
+    if (coded && typeof coded.code === "string" && /^error\./.test(coded.code))
+        item.code = coded.code;
+    if (coded && coded.params)
+        item.params = coded.params;
     return item;
 }
 // ── 路径解析 ────────────────────────────────────────────────────────────────
@@ -139,7 +142,9 @@ export function userRoots() {
 const DEFAULT_SOURCE_KEYS = Object.freeze(["dsh", "hub"]);
 /** 是否为默认来源。接受 root 对象或 key 字符串；`dsh` / `hub` 的所有特判都走这里。 */
 export function isDefaultSkillSource(rootOrKey) {
-    const key = rootOrKey && typeof rootOrKey === "object" ? rootOrKey.key : rootOrKey;
+    const key = rootOrKey && typeof rootOrKey === "object"
+        ? rootOrKey.key
+        : rootOrKey;
     return DEFAULT_SOURCE_KEYS.includes(key);
 }
 function projectIdentity(path) {
@@ -159,9 +164,8 @@ export function customRootKey(path) {
 }
 /** 从状态值解析自定义来源定义；非法条目静默丢弃，key 与 path 不匹配的不信任。 */
 export function customRootsFromState(stateValue) {
-    const list = stateValue && Array.isArray(stateValue.customRoots)
-        ? stateValue.customRoots
-        : [];
+    const state = stateValue;
+    const list = state && Array.isArray(state.customRoots) ? state.customRoots : [];
     const out = [];
     for (const item of list) {
         if (!item || typeof item !== "object")
@@ -443,6 +447,7 @@ export async function browseDirectories(inputPath) {
         directory = await fs.stat(canonical);
     }
     catch (error) {
+        // 系统异常按可选 message 读取，保持既有判定分支不变。
         return {
             ok: false,
             error: `无法读取目录: ${target}`,
@@ -487,6 +492,7 @@ export async function browseDirectories(inputPath) {
         }
     }
     catch (error) {
+        // 系统异常按可选 message 读取，保持既有判定分支不变。
         return {
             ok: false,
             error: `无法读取目录: ${canonical}`,
@@ -517,6 +523,7 @@ export async function browseDirectories(inputPath) {
     return { path: canonical, home: homedir(), crumbs, entries, truncated };
 }
 function dshRootPath() {
+    // userRoots() 恒含 dsh 来源（见上方列表），断言只为让类型收敛。
     return userRoots().find((root) => root.key === "dsh").path;
 }
 /**
@@ -564,13 +571,14 @@ function notDeletableError(definition) {
  */
 function reservedSourceError(root) {
     const key = root && root.key ? root.key : "";
+    const origin = key === "dsh"
+        ? "DSH 技能目录是默认来源，必须读取"
+        : "导入技能目录是默认来源、插件新建/导入的落点，必须读取";
     return {
         ok: false,
         code: "error.source.reserved",
-        params: { root: key },
-        error: key === "dsh"
-            ? "DSH 技能目录是默认来源，必须读取：不能停用或移除（里面的技能可以删除）"
-            : "导入技能目录是默认来源、插件新建/导入的落点，必须读取：不能停用或移除（里面的技能可以删除）",
+        params: { root: key, origin },
+        error: `${origin}：不能停用或移除（里面的技能可以删除）`,
     };
 }
 function rootDefinition(root) {
@@ -622,7 +630,11 @@ async function checkedWritableRootDefinition(root) {
         };
     }
     // 项目仓库内容不可信；拒绝通过 .dsh 或 skills 链接把写入重定向到项目之外。
-    for (const path of [join(definition.projectRoot, ".dsh"), definition.path]) {
+    // definition.scope === "project" 时 projectRoot 必有值（见 ProjectSource），断言只为让类型收敛。
+    for (const path of [
+        join(definition.projectRoot, ".dsh"),
+        definition.path,
+    ]) {
         const st = await lstatOrNull(path);
         if (st && (!st.isDirectory() || st.isSymbolicLink())) {
             return {
@@ -635,12 +647,6 @@ async function checkedWritableRootDefinition(root) {
     }
     return definition;
 }
-/** 判断 child 是否与 parent 相同或位于其内部。跨盘符时 relative 会返回绝对路径。 */
-function isSameOrDescendant(parent, child) {
-    const rel = relative(resolve(parent), resolve(child));
-    return (rel === "" ||
-        (!isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`)));
-}
 /** 解析真实路径；中间若有目录链接，按落地目录比较重叠。 */
 async function resolvedPath(path) {
     try {
@@ -701,16 +707,9 @@ async function lstatOrNull(path) {
 }
 /** 名称只允许一个普通路径段；不把既有技能名称限制为 kebab-case。 */
 export function entryPath(root, name) {
-    if (typeof name !== "string" ||
-        name === "" ||
-        name === "." ||
-        name === ".." ||
-        name.startsWith(".") ||
-        name.length > MAX_ENTRY_NAME_LENGTH ||
-        /[\\/:*?"<>|\0]/.test(name) ||
-        /[. ]$/.test(name) ||
-        WINDOWS_DEVICE_NAME_RE.test(name) ||
-        basename(name) !== name)
+    // 段名谓词收敛到 paths.js（此前与 rules / subagents / imports 各写一套，口径不一）。
+    // 原实现里 `basename(name) !== name` 那条已被谓词的「不含路径分隔符」覆盖。
+    if (!isValidSegment(name, MAX_ENTRY_NAME_LENGTH))
         return null;
     const rootPath = resolve(root);
     const path = resolve(rootPath, name);
@@ -819,6 +818,7 @@ export function unquote(v) {
 /** Windows 上杀毒软件或索引器可能短暂占用目录；只重试明确可恢复的 rename 错误。 */
 export async function renameWithRetry(source, destination, options = {}) {
     const rename = typeof options.rename === "function" ? options.rename : fs.rename;
+    // Number.isInteger/isFinite 不收窄类型，故断言成 number 以保持既有比较表达式。
     const maxAttempts = Number.isInteger(options.maxAttempts) && options.maxAttempts > 0
         ? options.maxAttempts
         : 6;
@@ -830,6 +830,7 @@ export async function renameWithRetry(source, destination, options = {}) {
             return await rename(source, destination);
         }
         catch (error) {
+            // 系统 rename 异常按可选 code 读取，保持既有重试判定。
             if (!TRANSIENT_RENAME_CODES.has(error && error.code) ||
                 attempt >= maxAttempts)
                 throw error;
@@ -853,6 +854,7 @@ async function movePathWithFallback(source, destination, options = {}) {
         return { copied: false, cleanupError: null };
     }
     catch (error) {
+        // 系统异常按可选 code 读取，保持既有 EXDEV 判定。
         if (!error || error.code !== "EXDEV")
             throw error;
     }
@@ -877,6 +879,7 @@ async function movePathWithFallback(source, destination, options = {}) {
         await removeMovedPath(quarantine);
     }
     catch (error) {
+        // 调用方按可选 message 读取该清理异常，保持既有告警文案。
         cleanupError = error;
     }
     return { copied: true, cleanupError, quarantine };
@@ -913,6 +916,7 @@ export async function resolveEntry(root, name) {
             return null;
         return ((await discoverReadonlyEntries(definition.path)).entries.find((entry) => entry.name === name) || null);
     }
+    // 传入 definition 对象时取它的 path；其余情况按 key 字符串处理。
     root = definition ? definition.path : root;
     try {
         const bundlePath = entryPath(root, name);
@@ -1019,6 +1023,7 @@ export async function scanEntries(root, options = {}) {
     const definition = rootDefinition(root);
     if (definition && !definition.mutable) {
         const discovered = await discoverReadonlyEntries(definition.path);
+        // metadataOnly 时条目的摘要字段由调用方按需读取（见 visibleEntryForRoot）。
         if (options.metadataOnly)
             return discovered;
         const entries = [];
@@ -1035,6 +1040,7 @@ export async function scanEntries(root, options = {}) {
         }
         return { ...discovered, entries };
     }
+    // 传入 definition 对象时取它的 path；其余情况按 key 字符串处理。
     root = definition ? definition.path : root;
     const rootStat = await lstatOrNull(resolve(root));
     if (!rootStat || !rootStat.isDirectory() || rootStat.isSymbolicLink())
@@ -1103,7 +1109,10 @@ export async function scanEntries(root, options = {}) {
 }
 /** 同一真实技能优先归属直接 SSOT；同类条目再按来源 rank 决胜。 */
 async function scanDeduplicatedRoots(roots = userRoots(), options = {}) {
-    const results = await Promise.all(roots.map(async (root) => [root, await scanEntries(root, options)]));
+    const results = await Promise.all(roots.map(async (root) => [
+        root,
+        await scanEntries(root, options),
+    ]));
     const scans = new Map();
     const groups = new Map();
     for (const [root, scan] of results) {
@@ -1342,9 +1351,8 @@ function normalizeManagerState(value) {
  *     也不参与 provider 候选。源文件不动，清掉这个标记即恢复。
  */
 export function activeUserRoots(stateValue) {
-    const removed = new Set(stateValue && Array.isArray(stateValue.removedSources)
-        ? stateValue.removedSources
-        : []);
+    const state = stateValue;
+    const removed = new Set(state && Array.isArray(state.removedSources) ? state.removedSources : []);
     return userRoots().filter((root) => !removed.has(root.key));
 }
 /** 裁剪自定义来源列表：非法条目丢弃，key/path 绑定校验，label 规整。 */
@@ -1419,6 +1427,7 @@ export async function readManagerState() {
         };
     }
     catch (error) {
+        // 系统异常按可选 code 读取，保持既有 ENOENT 判定。
         if (error && error.code === "ENOENT")
             return { state: defaultManagerState(), warning: null, writable: true };
         return {
@@ -1578,6 +1587,7 @@ async function checkedPolicyRootDefinition(root) {
             resolve(join(definition.projectRoot, definition.kind === "project-dsh" ? ".dsh" : ".agents", "skills"));
     if (!validProjectRoot)
         return null;
+    // validProjectRoot 已校验 projectRoot 为字符串，断言只为让类型收敛。
     if (!(await projectSourceSafe(definition))) {
         return {
             ok: false,
@@ -1778,12 +1788,13 @@ async function readTrashMetadata(id) {
  * 在短重试窗口后仍返回 EPERM。此时保留 stage 作为唯一可回滚副本，逐项复制到最终目录，
  * 并最后写 metadata：listTrash() 在复制完整前不会暴露半成品。
  */
-async function publishTrashStage(stage, finalPath, metadata, renameOptions) {
+async function publishTrashStage(stage, finalPath, metadata, renameOptions = {}) {
     try {
         await renameWithRetry(stage, finalPath, renameOptions);
         return { fallback: false, cleanupError: null };
     }
     catch (error) {
+        // 系统异常按可选 code 读取，保持既有可恢复码判定。
         if (!TRANSIENT_RENAME_CODES.has(error && error.code))
             throw error;
     }
@@ -1810,6 +1821,7 @@ async function publishTrashStage(stage, finalPath, metadata, renameOptions) {
         await fs.rm(stage, { recursive: true, force: true });
     }
     catch (error) {
+        // 调用方按可选 message 读取该清理异常，保持既有告警文案。
         cleanupError = error;
     }
     return { fallback: true, cleanupError };
@@ -1918,12 +1930,14 @@ export async function deleteSkill(root, name, log, options = {}) {
         return { id, name, deletedAt: metadata.deletedAt, root: metadata.root };
     }
     catch (error) {
+        // 系统异常按可选 message 读取，保持既有回滚失败明细。
         const rollbackFailures = [];
         for (const item of moved.reverse()) {
             try {
                 await movePathWithFallback(item.destination, item.path, options.renameOptions);
             }
             catch (rollbackError) {
+                // 系统异常按可选 message 读取，保持既有回滚失败明细。
                 rollbackFailures.push({
                     path: item.destination,
                     error: String(rollbackError && rollbackError.message
@@ -2127,8 +2141,11 @@ async function collectCandidates(dir) {
 }
 /** 导入内容不接受符号链接，避免把目标目录外的内容带入技能目录。 */
 async function assertNoSymbolicLinks(source) {
-    const pending = [{ path: source, depth: 0 }];
+    const pending = [
+        { path: source, depth: 0 },
+    ];
     while (pending.length) {
+        // while 条件保证栈非空，断言只为让类型收敛。
         const current = pending.pop();
         if (current.depth > MAX_SOURCE_DEPTH)
             throw codedError(`skill 来源目录层级超过 ${MAX_SOURCE_DEPTH} 层: ${source}`, "error.source.tooDeep", { depth: MAX_SOURCE_DEPTH, path: source });
@@ -2160,6 +2177,7 @@ async function preflightCandidates(pending, conflicts, failed) {
                 await assertNoSymbolicLinks(candidate.source);
             }
             catch (error) {
+                // 系统异常按可选 message 读取，保持既有失败明细文案。
                 failed.push(attachCode({
                     source: candidate.source,
                     error: String(error && error.message ? error.message : error),
@@ -2190,20 +2208,26 @@ async function copyToTemporary(source, target, isDir) {
 async function replaceWithCopy(source, dest, isDir, existing = []) {
     const stage = await copyToTemporary(source, dest, isDir);
     const backups = [];
+    // 三处 rename 一律走 `renameWithRetry`：瞬时占用（Windows 杀软 / 索引器 / 资源管理器）返回的
+    // EACCES / EBUSY / EPERM 正是它重试的那些码。此前只有 `:959` 的回滚用了带重试的版本，
+    // 而**发布与它的补偿回滚用的是裸 rename** —— 发布因瞬时锁抛错时，紧随其后的回滚在同一刻、
+    // 同一目录上大概率撞同一个句柄，于是留下"目标已空、真值还叫 backup"的半态（无自动恢复路径）。
+    // 保护覆盖不均不是取舍，是漏。
     try {
         for (const path of existing) {
             const backup = temporaryPath(path, "backup");
-            await fs.rename(path, backup);
+            await renameWithRetry(path, backup);
             backups.push({ path, backup });
         }
-        await fs.rename(stage, dest);
+        await renameWithRetry(stage, dest);
     }
     catch (error) {
+        // 系统异常按可选 message 读取，保持既有回滚失败明细。
         await fs.rm(stage, { recursive: true, force: true }).catch(() => undefined);
         const rollbackFailures = [];
         for (const item of backups.reverse()) {
             try {
-                await fs.rename(item.backup, item.path);
+                await renameWithRetry(item.backup, item.path);
             }
             catch (rollbackError) {
                 rollbackFailures.push(item.backup);
@@ -2221,6 +2245,7 @@ async function replaceWithCopy(source, dest, isDir, existing = []) {
             await fs.rm(item.backup, { recursive: true, force: true });
         }
         catch (error) {
+            // 系统异常按可选 message 读取，保持既有告警文案。
             warnings.push({
                 code: "warning.backupUncleaned",
                 params: {
@@ -2272,6 +2297,7 @@ export async function importSkill(source, log, options = {}) {
             candidates = await collectCandidates(source);
         }
         catch (error) {
+            // 系统异常按可选 message 读取，保持既有失败明细文案。
             return attachCode({
                 ok: false,
                 error: String(error && error.message ? error.message : error),
@@ -2321,6 +2347,7 @@ export async function importSkill(source, log, options = {}) {
             });
             continue;
         }
+        // 上方计数循环已为该 kebab 记数（合法名称且目标可写），断言只为让类型收敛。
         if (nameCount.get(c.kebab) > 1) {
             failed.push({
                 source: c.source,
@@ -2377,6 +2404,7 @@ export async function importSkill(source, log, options = {}) {
                 log("import", `导入 ${p.source} -> ${p.dest}`);
         }
         catch (e) {
+            // 系统异常按可选 message 读取，保持既有失败明细文案。
             failed.push(attachCode({ source: p.source, error: String(e && e.message ? e.message : e) }, e));
         }
     }
@@ -2392,6 +2420,7 @@ export async function importSkill(source, log, options = {}) {
                     log("import-overwrite", `覆盖导入 ${c.source} -> ${dest}`);
             }
             catch (e) {
+                // 系统异常按可选 message 读取，保持既有失败明细文案。
                 failed.push(attachCode({ source: c.source, error: String(e && e.message ? e.message : e) }, e));
             }
         }
@@ -2467,9 +2496,11 @@ function decodeUploadBase64(value, maxBytes, code = "error.upload.tooLarge") {
     return bytes;
 }
 function uploadError(error) {
+    // 按可选 message 读取抛出值，保持既有兜底文案。
+    const cause = error;
     return attachCode({
         ok: false,
-        error: String(error && error.message ? error.message : error),
+        error: String(cause && cause.message ? cause.message : error),
     }, error);
 }
 async function writeUploadedEntries(contentRoot, entries) {
@@ -2520,6 +2551,7 @@ async function writeUploadedZip(contentRoot, encoded) {
         });
     }
     catch (error) {
+        // 业务错误（我们抛的 error.* 前缀）透传；其余按 ZIP 解压失败处理。
         if (error && /^error\./.test(String(error.code || "")))
             throw error;
         throw codedError(`ZIP 无法解压: ${String(error && error.message ? error.message : error)}`, "error.upload.zipInvalid");
@@ -2554,7 +2586,7 @@ async function prepareUploadedSource(sessionRoot, input) {
     const batchRoot = join(sessionRoot, "batch");
     const wrappedRoot = join(batchRoot, skillName);
     await fs.mkdir(batchRoot, { recursive: true });
-    await fs.rename(contentRoot, wrappedRoot);
+    await renameWithRetry(contentRoot, wrappedRoot);
     return batchRoot;
 }
 /**
@@ -2648,12 +2680,13 @@ export async function createSkill(input, log, options = {}) {
             log("create", `创建 ${flatPath}`);
         return { name, path: flatPath, root: definition.key };
     }
+    // 上方 entryPath(root, name) === null 的守卫已保证目标非空，断言只为让类型收敛。
     const target = entryPath(root, name);
     const stage = temporaryPath(target, "create");
     try {
         await fs.mkdir(stage);
         await fs.writeFile(join(stage, "SKILL.md"), content, "utf8");
-        await fs.rename(stage, target);
+        await renameWithRetry(stage, target);
     }
     catch (error) {
         await fs.rm(stage, { recursive: true, force: true }).catch(() => undefined);
@@ -2722,7 +2755,10 @@ export async function listProviderCandidates(options = {}) {
     const candidates = [];
     const user = activeUserRoots(policyResult.state).concat(customRootsFromState(policyResult.state).filter((root) => !policyResult.state.removedSources.includes(root.key)));
     const userScans = await scanDeduplicatedRoots(user);
-    const items = user.flatMap((root) => userScans.get(root.key).entries.map((entry) => ({ root, entry })));
+    const items = user.flatMap((root) => userScans.get(root.key).entries.map((entry) => ({
+        root,
+        entry,
+    })));
     const cwd = options && typeof options.cwd === "string" ? options.cwd : undefined;
     if (cwd) {
         const roots = await projectRoots([cwd]);

package/lib/skills/readonly-discovery.js

@@ -22,7 +22,9 @@ export function validDiscoveryName(name) {
 /** 只返回文件定位信息，不读取正文，供列表、详情及策略复用同一发现与去重规则。 */
 export async function discoverReadonlyEntries(root) {
     const rootPath = resolve(root);
-    const queue = [{ path: rootPath, depth: 0, ancestors: new Set() }];
+    const queue = [
+        { path: rootPath, depth: 0, ancestors: new Set() },
+    ];
     const byName = new Map();
     let directories = 0;
     let entries = 0;
@@ -50,6 +52,7 @@ export async function discoverReadonlyEntries(root) {
                     docStat = await fs.lstat(docPath);
                 }
                 catch (error) {
+                    // fs 抛出的错误按 Node 错误形状读取 code（此处只关心 ENOENT）
                     if (error.code !== "ENOENT")
                         throw error;
                 }

package/lib/skills/service.js

@@ -9,6 +9,7 @@ import { Worker } from 'node:worker_threads';
 import { spawn } from 'node:child_process';
 import { homedir } from 'node:os';
 import { basename, join } from 'node:path';
+import { isInsideRootResolved } from '../paths.js';
 import { state, setSkillEnabled, setPreferredSkill, markSkillsDisabled, setSourceEnabled, setSourceRemoved, deleteSkill, restoreTrash, permanentlyDeleteTrash, importSkill, importUploadedSkill, browseDirectories, createSkill, skillDetail, listProviderCandidates, getProviderSkill, userRoots, projectRoots, readManagerState, customRootsFromState, addCustomRoot, removeCustomRoot, logPath, trashRootPath, } from './core.js';
 const MAX_LOG_BYTES = 1 << 20;
 const PROVIDER_NAME = 'dsh-plugin-tool-management-external';
@@ -35,18 +36,44 @@ function makeLog() {
     };
 }
 // ── 系统回收站（永久删除的最后一道保险） ──────────────────────────────────
+/**
+ * 外部进程（PowerShell / gio）的超时上限。这些调用在技能的**写队列**里被 await
+ * （skill-trash-delete），进程一旦挂起，该域全部写操作会永久停摆且无任何提示 ——
+ * 回收站 API 在文件被占用、系统弹窗等情况下确实会挂住。超时后杀掉进程并返回 false，
+ * 让调用方按既有的「回收站失败 → 硬删除」兜底走下去，队列得以继续。
+ */
+const EXTERNAL_CMD_TIMEOUT_MS = 30_000;
 function runQuietly(command, args) {
     return new Promise((resolve) => {
+        let settled = false;
+        let timer = null;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            resolve(ok);
+        };
         let child;
         try {
             child = spawn(command, args, { stdio: 'ignore', windowsHide: true });
         }
         catch {
-            resolve(false);
+            finish(false);
             return;
         }
-        child.on('error', () => resolve(false));
-        child.on('close', (code) => resolve(code === 0));
+        timer = setTimeout(() => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch { /* 进程可能已自行退出 */ }
+            finish(false);
+        }, EXTERNAL_CMD_TIMEOUT_MS);
+        child.on('error', () => finish(false));
+        child.on('close', (code) => finish(code === 0));
     });
 }
 function psQuote(value) {
@@ -92,7 +119,7 @@ async function permanentlyDeleteTrashSafely(id, log) {
 // ── 文件监听：外部改动自动失效 ────────────────────────────────────────────
 /**
  * 监听目录，200ms 防抖后回调：在编辑器或其他工具里新增/修改/删除文件后，无需手动
- * 刷新即可看到变化。技能来源与规则根目录共用（见 src/rules/service.ts 的场景记忆段缓存）。
+ * 刷新即可看到变化。技能来源与规则根目录共用（见 src/memories/service.ts 的场景记忆段缓存）。
  *
  * 为什么用 worker_threads：Windows 上 fs.watch(recursive) 的句柄在「被监听
  * 目录被删除」时会静默卡死事件循环（不触发 error、unref 也无效）——宿主
@@ -433,6 +460,36 @@ export function createSkillsService(ctx) {
         'skill-set-all',
         'skill-trash-restore', 'skill-trash-delete', 'skill-custom-add', 'skill-custom-remove',
     ]);
+    /**
+     * 新建 / 导入 / 恢复技能后统一「默认停用」。**失败不能吞。**
+     *
+     * 这里原先写作 `.catch(() => undefined)`，两处都漏：一是抛出的写失败被吞，二是
+     * `markSkillsDisabled` 在状态文件不可读时**不抛**、而是返回 `{ ok: false }` —— 那个
+     * 返回值此前根本没被看过。两种情况下技能都停在启用态、下一轮就进模型上下文，而用户
+     * 看到的是「创建成功」。
+     *
+     * 沿用 `sceneSyncError` 的形状：这里只给**原因原文**，句子由界面按当前语言拼
+     * （服务端拼中文会让英文界面露出中文）。
+     */
+    async function disableNewSkills(targets, res) {
+        if (!targets.length)
+            return res;
+        let reason = null;
+        try {
+            const out = await markSkillsDisabled(targets, log);
+            if (out && out.ok === false)
+                reason = String(out.error || '状态文件不可读');
+        }
+        catch (e) {
+            reason = message(e);
+        }
+        if (reason === null)
+            return res;
+        // 本来就已经失败的回执：把原因并进 error，不要用 warning 把失败说成「成功但有提示」。
+        return res && res.ok === false
+            ? { ...res, error: `${res.error}；另外，「默认停用」也没能写入（${reason}）` }
+            : { ...res, stateSyncError: reason };
+    }
     const ops = {
         // 读操作（state 走短 TTL 缓存，见上方 readState）
         'skill-state': wrap(() => readState()),
@@ -488,7 +545,7 @@ export function createSkillsService(ctx) {
             const res = await createSkill({ name: args.name, description: args.description, body: args.body }, log, { root: (await requestRoot(key)) || key });
             // v0.8.5：新建技能默认不启动（用户裁定）——与子智能体 / MCP 同口径。
             if (res && res.ok !== false && res.name) {
-                await markSkillsDisabled([{ root: String(res.root || 'hub'), name: String(res.name) }], log).catch(() => undefined);
+                return disableNewSkills([{ root: String(res.root || 'hub'), name: String(res.name) }], res);
             }
             return res;
         }), afterWrite),
@@ -499,9 +556,7 @@ export function createSkillsService(ctx) {
             });
             // 导入的技能默认停用；部分成功也对 imported 逐条停用。
             const names = res && Array.isArray(res.imported) ? res.imported : [];
-            if (names.length)
-                await markSkillsDisabled(names.map((n) => ({ root: 'hub', name: String(n) })), log).catch(() => undefined);
-            return res;
+            return disableNewSkills(names.map((n) => ({ root: 'hub', name: String(n) })), res);
         }), afterWrite),
         'skill-upload': wrap((args) => write(async () => {
             const res = await importUploadedSkill({ name: args.name, entries: args.entries, zip: args.zip }, log, {
@@ -509,16 +564,14 @@ export function createSkillsService(ctx) {
             });
             // 上传/导入同口径：默认停用。
             const names = res && Array.isArray(res.imported) ? res.imported : (res && res.name ? [res.name] : []);
-            if (names.length)
-                await markSkillsDisabled(names.map((n) => ({ root: 'hub', name: String(n) })), log).catch(() => undefined);
-            return res;
+            return disableNewSkills(names.map((n) => ({ root: 'hub', name: String(n) })), res);
         }), afterWrite),
         'skill-delete': wrap((args) => write(async () => deleteSkill(await requestRoot(String(args.root || 'dsh')), String(args.name || ''), log)), afterWrite),
         'skill-trash-restore': wrap((args) => write(async () => {
             const res = await restoreTrash(String(args.id || ''), log, projectOptions());
             // 恢复的技能默认停用（v0.8.5 用户裁定：新建/导入/恢复一律不启动，手动开启）。
             if (res && res.ok !== false && res.name) {
-                await markSkillsDisabled([{ root: String(res.root || 'hub'), name: String(res.name) }], log).catch(() => undefined);
+                return disableNewSkills([{ root: String(res.root || 'hub'), name: String(res.name) }], res);
             }
             return res;
         }), afterWrite),
@@ -527,5 +580,37 @@ export function createSkillsService(ctx) {
         'skill-custom-add': wrap((args) => write(() => addCustomRoot(args && args.path, args && args.label, log)), afterWrite),
         'skill-custom-remove': wrap((args) => write(() => removeCustomRoot(args && args.key, log)), afterWrite),
     };
-    return { ops, writeOps, registerProviders };
+    /**
+     * 该绝对路径是否落在「本插件认识的技能来源」内。
+     *
+     * 为什么需要它：`skill-open` 会把路径交给**系统默认编辑器**，不设边界的话它就是一个
+     * 「任意绝对路径 → 启动外部程序」的入口。三类来源都要收进来，否则会把合法技能误挡在外：
+     * 静态根（`userRoots`）+ 状态文件里的自定义根 + 当前活动工作区的项目来源。
+     */
+    async function isInsideKnownSkillRoot(abs) {
+        const dirs = roots.map((r) => String((r && r.path) || '')).filter(Boolean);
+        try {
+            for (const r of customRootsFromState((await readManagerState()).state)) {
+                if (r && r.path)
+                    dirs.push(String(r.path));
+            }
+        }
+        catch { /* 状态不可读 → 只用静态根 */ }
+        try {
+            for (const r of await projectRoots(projectOptions().projectCwds)) {
+                if (r && r.path)
+                    dirs.push(String(r.path));
+            }
+        }
+        catch { /* 项目来源解析失败 → 跳过 */ }
+        for (const dir of dirs) {
+            try {
+                if (await isInsideRootResolved(dir, abs))
+                    return true;
+            }
+            catch { /* 单个根失败不影响其他 */ }
+        }
+        return false;
+    }
+    return { ops, writeOps, registerProviders, isInsideKnownSkillRoot };
 }