dsh-plugin-tool-management 0.10.0 → 0.12.0

package/lib/context-inject.js

@@ -71,6 +71,7 @@
 // 遥测同理（`noteToolUse` 自己吞异常）：它绝不能影响工具本身。
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionSeq } from '@deepseek-ai/dsh-session';
+import { clearRuntimeNote, noteRuntime } from './compat/runtime-notes.js';
 /**
  * 权威域顺序（界面勾选、注入消息先后都按它）。
  * 场景和记忆排第一：它是"当前模式"的框架，先给框架再给内容。
@@ -415,6 +416,38 @@ function kindOfMessage(message) {
     const source = message?.source;
     return source && typeof source.kind === 'string' ? source.kind : undefined;
 }
+// B4：关域拦截的**顺序自检**。官方那两条注入行与本插件同挂在这条瀑布上，拦截成立的剩余前提是
+// "本插件排在它们上游"（本插件用 `{ prepend: true }` 把自己钉在钩子表最前，所以真正还依赖的
+// 只剩一条：官方那两条仍用**默认 push** 方式注册）。这仍是非契约事实（见 pre-step 监听器里的
+// 注释）。官方哪天改成 prepend 抢到更前面，症状就是「关了域、模型还是收到内容」，且**完全没有
+// 报错**。这里做最轻的自检：关域生效期间连续 N 个真实 turn 一条都没剔到，就上报一次；
+// 剔到过就收掉那条上报。如实写清两种可能（顺序变了 / 官方这一轮本来没内容），
+// 不把它说成一定是事故。
+const SUPPRESSION_SUSPECT_TURNS = 5;
+function suppressionVerdict(active, dropped, counter) {
+    if (!active) {
+        counter.turns = 0;
+        counter.drops = 0;
+        clearRuntimeNote('official-suppression');
+        return;
+    }
+    counter.turns += 1;
+    counter.drops += dropped;
+    if (counter.drops > 0) {
+        counter.turns = 0;
+        clearRuntimeNote('official-suppression');
+        return;
+    }
+    if (counter.turns < SUPPRESSION_SUSPECT_TURNS)
+        return;
+    noteRuntime({
+        id: 'official-suppression',
+        label: '官方注入的关域拦截',
+        kind: 'read',
+        fallback: 'inform-only',
+        detail: `关掉的注入域已连续 ${counter.turns} 轮没有拦到任何官方消息（自检）：可能是瀑布注册顺序变了导致拦截失效，也可能是官方那两条注入行这几轮本来就没有内容。可到「注入实况」对照模型实际收到的内容。`,
+    });
+}
 /** 实况展示用的 kind 表：本插件的五条 + 官方两条。 */
 const LIVE_KINDS = new Map([
     ...PLUGIN_KINDS,
@@ -567,7 +600,30 @@ export function createContextInjector(deps) {
     const ctx = deps.ctx;
     if (!ctx || typeof ctx.on !== 'function')
         return { dispose: () => { }, live, noteToolUse };
+    /** B4 自检计数（每个注入器实例各自一份，随实例销毁而消失）。 */
+    const suppressionCounter = { turns: 0, drops: 0 };
+    // `{ prepend: true }` —— 位置**必须**钉在钩子表最前，理由见 `next()` 之后那段注释
+    // （关域拦截只在上游成立）。这里不靠"谁先注册"：cordis 的 Loader 是**并发**挂载条目的
+    // （`await Promise.allSettled(config.map((options) => this.create(options)))`，
+    // cordis-plugin-loader/lib/index.js），每个官方包 apply 的完成先后由模块导入与 IO 决定，
+    // 逐次启动都可能不同；本插件的条目又是补丁层 `insert` 推到条目列表**末尾**的
+    // （dsh-app-boot/lib/index.js：顶层 insert 走 `data.push(...insert)`）。
+    // 2026-09-20 实测到那次翻转：关掉技能 / 提示词域后，官方注入照旧进上下文。
+    // `prepend` 由 cordis `EventsService.register()` 实现（`hooks[options.prepend ? 'unshift' : 'push']`），
+    // 于是不论挂载先后，本插件都排在官方那两条**默认 push** 注册的注入行之前 ——
+    // 顺序从"竞态"变成"约定"。
     const stop = ctx.on('agent/pre-step', async (payload, next) => {
+        // 令牌门禁在**最前面**：没验过令牌时这一轮整个不放行，`next()` 都不必跑（后面那些注入
+        // 本来就是给模型看的，模型这一步根本不会被调用）。宿主据此把 turn 收成 `blocked`。
+        // 代价（宿主文档写明）：被认领的那条用户消息会被丢弃 —— 这是"拦住"的固有代价，界面侧
+        // 的可见提示由兼容页那条「去填令牌」横幅承担。
+        try {
+            if (deps.tokenGateActive && deps.tokenGateActive()) {
+                log('令牌未验证：本轮对话被拒绝（在「工具 → 兼容」页填入访问令牌后恢复）');
+                return { kind: 'reject' };
+            }
+        }
+        catch { /* 门禁判定失败不能反过来卡住对话：当作放行 */ }
         const decision = await next();
         try {
             if (!decision || decision.kind === 'reject')
@@ -592,17 +648,31 @@ export function createContextInjector(deps) {
             // 边界说明：这不是改官方包、也不是改宿主机制 —— pre-step 的 decision 本来就是每个插件
             // 都能改的那条缝（官方自己就在这里追加消息），我们只把它剔出这一步的批次。代价是官方
             // 插件每一步都会重新渲染并尝试注入（它的历史读的是会话事件，读不到被拦下的那条），
-            // 模型侧不受影响。位置在本监听器 `next()` 之后：本插件在这条瀑布里位于官方之前
-            // （自己的消息总落在批次末尾，实测），所以官方这一步追加的消息在这里看得见。
+            // 模型侧不受影响。
+            // **为什么 `prepend` 是必需的**：官方那两条注入行都在 `await next()` **之后**才往
+            // `decision.messages` 里追加（dsh-tool-skill 末尾 `[...decision.messages, catalog]`；
+            // dsh-agent-instructions `toSpliced(lastClaimedIndex + 1, 0, desired)`），而瀑布的
+            // `next()` 只做"取钩子表的下一个"。所以只有排在他们**上游**的监听器，其 `next()`
+            // 返回时才看得见这些追加 —— 本插件的过滤在 `next()` 之后，位置必须在上游。
             const suppressedKinds = officialKindsToSuppress(settings);
             let messages = messagesOf(decision);
             if (suppressedKinds.size > 0) {
+                let dropped = 0;
                 const kept = messages.filter((message) => {
                     const kind = kindOfMessage(message);
-                    return kind === undefined || !suppressedKinds.has(kind);
+                    if (kind !== undefined && suppressedKinds.has(kind)) {
+                        dropped += 1;
+                        return false;
+                    }
+                    return true;
                 });
                 if (kept.length !== messages.length)
                     messages = kept;
+                // B4 自检：只有"这一步真的在拦"时才有意义（令牌门禁 reject、空 turn 早退都在上面）。
+                suppressionVerdict(true, dropped, suppressionCounter);
+            }
+            else {
+                suppressionVerdict(false, 0, suppressionCounter);
             }
             const facts = await deps.factsFor(agent);
             const sections = selectInjections(domains, settings, facts, agent);
@@ -681,13 +751,17 @@ export function createContextInjector(deps) {
             log('context injection failed: ' + String((error && error.message) || error));
             return decision;
         }
-    });
+    }, { prepend: true });
     return {
-        dispose: () => { try {
-            if (typeof stop === 'function')
-                stop();
-        }
-        catch { /* ignore */ } },
+        dispose: () => {
+            try {
+                if (typeof stop === 'function')
+                    stop();
+            }
+            catch { /* ignore */ }
+            // 注入通道没了，自检结论也失效（B4）——留着会让兼容页报一件不存在的事。
+            clearRuntimeNote('official-suppression');
+        },
         live,
         noteToolUse,
     };

package/lib/host-names.js

@@ -0,0 +1,12 @@
+/**
+ * 宿主身份常量：插件在文件里认的这几个名字只在这里写一次。
+ *
+ * 以前 `@deepseek-ai/dsh-mcp-client` 在 `index.ts` 里有 6 份副本（2 份写给补丁的 YAML、
+ * 2 份解析补丁时的比对、2 份运行时清单匹配），`preset-reach.ts` 里还有第 7 份 —— 官方改包名时
+ * 少改一处就是「开关点了没反应」或「列表凭空少一行」。档案目录名同理。
+ */
+export const MCP_CLIENT_MODULE = '@deepseek-ai/dsh-mcp-client';
+/** `ensurePaths()` 的档案探测顺序（先 web 后 headless）；都不在才退到「任意带 patch 的档案」。 */
+export const PROFILE_CANDIDATES = ['web', 'headless'];
+/** 探测不到任何档案时的兜底目录名（历史上的默认档案）。 */
+export const DEFAULT_PROFILE_NAME = 'web';

package/lib/http-fence.js

@@ -21,9 +21,12 @@ const headerValue = (req, name) => {
 /**
  * 判定请求是否应被拒（返回 null = 放行）。
  *
- * 优先用宿主栅栏；它不在场时（非 web 组合、服务未注册）退回等价的本地判定，
- * 而不是静默放行。栅栏自身抛错时同样退回本地判定 —— 宁可拒绝也不要因为宿主
- * 内部变动而变成开放路由。
+ * 优先用宿主栅栏；它不在场时（非 web 组合、服务未注册）退回**本地最小判定**，而不是静默放行。
+ * 栅栏自身抛错时同样退回本地判定 —— 但这句**不是**"宁可拒绝"：本地链不含 cookie 鉴权，
+ * 于是丢掉的恰好是宿主栅栏比本地判定多出来的那一层。无 Origin 的非浏览器请求只要带上
+ * `Host: localhost` 就能过（本机任意进程都做得到），而写 op 里包含 `mcpm-add`（宿主 stdio
+ * 传输会按 command/args spawn 它）与 `history-delete`（永久删除会话）。
+ * 准确的说法是：退回一个**不依赖宿主内部**的判定 —— 仍要求回环 Host，但没有会话凭证。
  *
  * @param req - Node 请求对象（只读 headers）。
  * @param connection - ctx.get('connection')，可缺失。
@@ -71,24 +74,41 @@ export function fenceRejection(req, connection) {
     }
     return null;
 }
+// 令牌相关的拒绝文案**只有这一句**，所有出口都引用它（用户裁定 2026-09-18：
+// 「这些关于密钥没填的提示词应该统一文案」；2026-09-19 再简化成一句话）。
+//
+// 2026-09-19 晚再去掉"去哪儿填、点什么"那两句（用户截图：提示条在好几个地方都折成两行）——
+// 提示条右侧本来就挂着「填写令牌」按钮，把按钮名念一遍等于同一件事在一行里说两遍，还占掉
+// 一整行的宽度。这一句只说"缺什么 / 错在哪"，动作交给那颗按钮；它跳到哪、填完什么状态，
+// 由兼容页的胶囊与三行自己说。**不要再往这句里加指引**：契约测试钉着它的长度。
+//
+// 为什么必须同源：同一个"没填令牌"会在四个地方冒出来（宿主写门禁、明文门禁的两条分支、
+// 界面的错误码词典），此前各写一套 —— 截图里同一件事出现了三种说法，用户无法判断它们
+// 是不是同一件事。界面靠**文本相等**识别这句话（见 client.js 的 isTokenGateText），
+// 所以改这句必须同时改界面词典里的那三个键。
+export const TOKEN_MSG = '缺少访问令牌，或令牌不对';
+/**
+ * 界面按 code 在最右侧挂「填写令牌」跳转按钮（这一族里的 code 都算）。
+ *
+ * 2026-09-19 之后 `secretOpRejection` **不再产生** NO_HOST（没配令牌就直接放行，见上），
+ * 但常量与界面词典里的 `error.secret.noToken` 都留着：宿主没重启时旧响应里还可能出现它，
+ * 而界面同时按 code 与**文本相等**两条路识别这一族（见 client.js 的 isTokenGateText）。
+ */
+export const TOKEN_CODE_NO_HOST = 'error.secret.noToken';
+export const TOKEN_CODE_BAD = 'error.token.required';
 /**
  * 判定敏感 op 是否应被拒（返回 null = 放行）。
  *
- * 两种情况分开报，因为处置方式不同：没配令牌要去宿主配置里加，配了但没带/带错
- * 只要在界面里填对即可（界面按 code 决定给不给输入框）。
+ * 没配令牌 ⇒ 放行（与写门禁同一激活条件，理由见上方段落）。有令牌 ⇒ 必须带对的。
+ *
+ * 两个 code 仍然分开报：界面用不到（话已经一样了），但日志与排查需要区分
+ * 「宿主根本没配令牌」与「这次带的令牌不对」—— 前者是配置问题，后者是输入问题。
  */
 export function secretOpRejection(state) {
-    if (!state.tokenConfigured) {
-        return {
-            code: 'error.secret.noToken',
-            error: '明文查看与导出已被禁用：宿主未配置访问令牌。请在本插件配置里加 token（或设环境变量 DSH_PLUGIN_TOOL_MANAGEMENT_TOKEN）后重启 DSH，再在界面上填入同一个令牌。',
-        };
-    }
+    if (!state.tokenConfigured)
+        return null;
     if (!state.tokenAccepted) {
-        return {
-            code: 'error.secret.badToken',
-            error: '访问令牌缺失或不正确：请在界面里填入与宿主配置相同的令牌（随请求以 x-dsh-token 发送）。',
-        };
+        return { code: TOKEN_CODE_BAD, error: TOKEN_MSG };
     }
     return null;
 }

package/lib/hub.js

@@ -24,7 +24,13 @@
 //   ├─ mcp-disabled-tools.json | mcp-known-tools.json | mcp-notes.json | mcp-settings.json | mcp-export.json
 //   ├─ tool-management.log                               插件日志（滚动 .1）
 //   ├─ backups/cordis.patch.yml.bak-<时间戳>             改宿主 patch 前的备份
-//   └─ trash/{skills,subagents,prompts,scenes,memories}-trash/<id>/
+//   ├─ trash/{skills,subagents,prompts,scenes}-trash/<id>/  回收站（除记忆外的四类）
+//   └─ memories-trash/<id>/                              记忆回收站（**hub 根下独立目录**）
+//
+// 记忆回收站**不在 `trash/` 下**（本机实测 `trash/` 只有 4 个 `-trash` 目录）：它走
+// `memories/service.ts` 自己的路径（`join(stateDir, 'memories-trash', id)`，stateDir = hub 根），
+// 不经本模块的 `moveToTrash`。此前这行把它画进 `trash/{…}` 里，按它写备份/迁移脚本会既漏搬
+// 又误判（那是一类真实存在、条目数最多的用户数据）。
 //
 // 留在 `$DSH_HOME` 根下的两个文件**不是**插件的：`AGENTS.md`（宿主每轮读取的全局基线，
 // 插件只是按场景/预设写它）与 `cordis.patch.yml`（宿主加载插件的配置入口）。
@@ -365,14 +371,34 @@ export async function listTrashEntries(kind) {
 export async function readTrashEntry(kind, id) {
     return await readManifest(kind, id);
 }
+/**
+ * 条目里的一个负载名是不是"就在这个条目目录里"。
+ *
+ * 为什么 id 与场景名都有谓词、这里还得多一道：`manifest.json` 的 `files[]` 是**磁盘上的数据**，
+ * 它跟 id 不一样 —— id 只由本模块生成（`isValidTrashId` 严格白名单），而 files 可能来自
+ * 用户手改、别的进程、或一份被塞进来的恶意档案包。不校验就 `join(dir, dest)` 等于给了
+ * "任意相对路径读源 + 任意绝对目录建目标"的能力（`mkdir(dirname(to))` 会顺手把目录建出来）。
+ */
+export function isValidTrashPayloadName(dest) {
+    const text = String(dest ?? '');
+    if (!text || text.startsWith('.') || text.includes('\0'))
+        return false;
+    if (/[\\/]/.test(text))
+        return false;
+    if (text === 'manifest.json')
+        return false;
+    return true;
+}
 /**
  * 把条目里的一个负载搬回 `to`。**不覆盖**：调用方必须先确认 `to` 不存在。
- * @throws 条目或负载缺失时抛错（调用方翻成人话）。
+ * @throws 条目、负载名或负载缺失时抛错（调用方翻成人话）。
  */
 export async function moveOutOfTrash(kind, id, dest, to) {
     const dir = trashEntryPath(kind, id);
     if (dir === null)
         throw new Error(`回收站条目 id 非法：${id}`);
+    if (!isValidTrashPayloadName(dest))
+        throw new Error(`回收站负载名非法：${dest}`);
     const from = join(dir, dest);
     await mkdir(dirname(to), { recursive: true });
     try {

package/lib/imports/parsers.js

@@ -18,19 +18,22 @@ export function extractText(content) {
             if (typeof part === 'string')
                 out += part;
             else if (part && typeof part === 'object') {
-                if (typeof part.text === 'string')
-                    out += part.text;
-                else if (typeof part.content === 'string')
-                    out += part.content;
+                // JSON 块的实际形状由下方 typeof 运行时比较决定，这里按记录形状读取字段
+                const record = part;
+                if (typeof record.text === 'string')
+                    out += record.text;
+                else if (typeof record.content === 'string')
+                    out += record.content;
             }
         }
         return out;
     }
     if (content && typeof content === 'object') {
-        if (typeof content.text === 'string')
-            return content.text;
-        if (typeof content.content === 'string')
-            return content.content;
+        const record = content;
+        if (typeof record.text === 'string')
+            return record.text;
+        if (typeof record.content === 'string')
+            return record.content;
     }
     return '';
 }
@@ -58,6 +61,7 @@ export function detectFormat(fileName, content) {
     const first = String(content || '').split(/\r?\n/).map((s) => s.trim()).find((s) => s) || '';
     if (first.startsWith('{')) {
         try {
+            // JSON 值实际形状未知；若为对象，type/role 字段由下方运行时比较判定
             const obj = JSON.parse(first);
             if (obj && typeof obj === 'object' && (obj.type === 'user' || obj.type === 'assistant' || obj.role === 'user' || obj.role === 'assistant'))
                 return 'jsonl';
@@ -83,6 +87,7 @@ export function parseJsonlTranscript(text) {
         const line = raw.trim();
         if (!line)
             continue;
+        // JSONL 每行的实际形状未知；字段有效性由下方运行时比较判定
         let obj;
         try {
             obj = JSON.parse(line);
@@ -95,7 +100,7 @@ export function parseJsonlTranscript(text) {
         let role = null;
         let content;
         if (obj.type === 'user' || obj.type === 'assistant') {
-            const message = obj.message && typeof obj.message === 'object' && !Array.isArray(obj.message) ? obj.message : null;
+            const message = (obj.message && typeof obj.message === 'object' && !Array.isArray(obj.message) ? obj.message : null);
             role = message && (message.role === 'user' || message.role === 'assistant') ? message.role : (obj.type === 'user' ? 'user' : 'assistant');
             content = message ? message.content : undefined;
         }
@@ -112,6 +117,7 @@ export function parseJsonlTranscript(text) {
             lastText += '\n' + piece;
         }
         else {
+            // lastText 非空 ⇒ lastRole 已随 lastText 同步赋值（非 null），类型层无法表达该不变式
             if (lastText)
                 turns.push({ role: lastRole, text: lastText });
             lastRole = role;

package/lib/imports/upload.js

@@ -3,12 +3,28 @@
 // 场景记忆（~/.dsh/tool-management/memories/<场景>/<名>.md；场景留空 = 保留场景 global）。
 // 约定：只认 .md；zip 内任意层级；隐藏项 / 绝对路径 / `..` 穿越 / 超限条目一律跳过并回报；
 //       重名策略（跳过 or 覆盖）不在这里实现——由调用方按文件系统现状裁决（本项目取「跳过并报告」）。
+//
+// 两条限额的**口径**要分清（2026-09-19 审计 T-09）：`MAX_IMPORT_TOTAL_BYTES` 管的是
+// **上传（编码后）**字节，管不住解压后的体积 —— 一个 8 MiB 条目 × 2000 条 ≈ 16 GiB 会在
+// 单次 `unzipSync` 里被实体化。所以另有 `MAX_IMPORT_UNCOMPRESSED_BYTES` 管**解压后**的
+// 累计量，在 filter 里按档案自报的 `info.originalSize` 累加。
 import { unzipSync } from 'fflate';
+import { isValidSegment } from '../paths.js';
 export const MAX_IMPORT_FILES = 200;
 export const MAX_IMPORT_ENTRY_BYTES = 8 * 1024 * 1024;
+/** 上传（编码后）总量：与传输层的 88 MiB 体限是同一层口径，防止一次请求塞进几百 MiB。 */
 export const MAX_IMPORT_TOTAL_BYTES = 32 * 1024 * 1024;
 export const MAX_IMPORT_ENTRIES = 2000;
 export const MAX_IMPORT_NAME_LENGTH = 64;
+/**
+ * 解压后累计上限（与技能上传器 `MAX_UPLOAD_TOTAL_BYTES = 64 MiB` 同层口径）。
+ *
+ * 为什么必须单列：单条目 8 MiB × 2000 条 ≈ 16 GiB 会在一次 `unzipSync` 里全部展开进内存 ——
+ * 传输层与 `MAX_IMPORT_TOTAL_BYTES` 都只数**压缩后**的字节，一个数不到。
+ * 已知前提：信任档案自报的 `info.originalSize`（fflate 不独立约束输出长度）；谎报只能让
+ * 解压产物比申报的大，**不会**绕过这个上限之前的条目数门禁。
+ */
+export const MAX_IMPORT_UNCOMPRESSED_BYTES = 64 * 1024 * 1024;
 const message = (e) => String((e && e.message) || e);
 /** base64 → 字节；容忍 `data:...;base64,` 前缀。 */
 export function decodeBase64(data) {
@@ -57,6 +73,8 @@ export function expandUploads(files) {
         problems.push({ name: `(其余 ${all.length - MAX_IMPORT_FILES} 个文件)`, reason: `一次最多导入 ${MAX_IMPORT_FILES} 个文件` });
     }
     let total = 0;
+    /** 解压后超限只报一次（与"超条目数"同口径，避免几千条问题刷屏）。 */
+    let uncompressedReported = false;
     for (const raw of list) {
         const file = (raw || {});
         const name = String(file.name || '').trim() || '(未命名)';
@@ -76,6 +94,7 @@ export function expandUploads(files) {
         }
         if (isZipBytes(bytes)) {
             let unzipped;
+            let uncompressed = 0;
             try {
                 let count = 0;
                 unzipped = unzipSync(bytes, {
@@ -95,6 +114,18 @@ export function expandUploads(files) {
                             problems.push({ name: info.name, reason: `zip 内单条目超过 ${MAX_IMPORT_ENTRY_BYTES >> 20} MiB，已跳过` });
                             return false;
                         }
+                        // 解压后累计：单条目与条目数都挡不住「2000 × 8 MiB」这种组合，只有累计量挡得住。
+                        // 目录条目不占解压预算（originalSize 为 0 且不产出内容）。
+                        if (!info.name.endsWith('/')) {
+                            uncompressed += info.originalSize;
+                            if (uncompressed > MAX_IMPORT_UNCOMPRESSED_BYTES) {
+                                if (!uncompressedReported) {
+                                    uncompressedReported = true;
+                                    problems.push({ name: info.name, reason: `zip 解压后合计超过 ${MAX_IMPORT_UNCOMPRESSED_BYTES >> 20} MiB，该条目及其后条目已忽略` });
+                                }
+                                return false;
+                            }
+                        }
                         return true;
                     },
                 });
@@ -120,14 +151,22 @@ export function expandUploads(files) {
             problems.push({ name, reason: '只支持 .md 或 .zip' });
             continue;
         }
-        entries.push({ path: name, bytes });
+        // 非 zip 分支同样要走 `normalizeEntryPath`：客户端给的文件名是**外部输入**，
+        // `"../../x.md"` / `".hidden/x.md"` 直接进 `RawEntry[]` 就把"隐藏项/穿越一律跳过"
+        // 这条承诺交给下游 planner 兜着 —— 本模块的文件头正是这么承诺的（审计 T-10）。
+        // 不变量该由承诺方强制：新增的第三个消费者不该靠"运气好下游也查了"才安全。
+        const normalized = normalizeEntryPath(name);
+        if (!normalized) {
+            problems.push({ name, reason: '路径非法或隐藏项，已跳过' });
+            continue;
+        }
+        entries.push({ path: normalized, bytes });
     }
     return { entries, problems };
 }
-/** 单个名字段（人设名 / 记忆名 / 场景路径的一段）合法性：与宿主侧校验同口径。 */
+/** 单个名字段（人设名 / 记忆名 / 场景路径的一段）合法性：谓词收敛到 `../paths.ts`。 */
 export function isValidImportName(name) {
-    const s = String(name || '');
-    return s.length > 0 && s.length <= MAX_IMPORT_NAME_LENGTH && s === s.trim() && !s.startsWith('.') && !/[\\/<>:"|?*]/.test(s);
+    return isValidSegment(String(name || ''), MAX_IMPORT_NAME_LENGTH);
 }
 /** 场景/分组路径合法性：逐段校验（空串 = 根/全局，合法）。 */
 export function isValidImportGroup(group) {