@caesarloo/dsh-skill-audit 0.1.0

package/README.md

@@ -0,0 +1,107 @@
+# @caesarloo/dsh-skill-audit
+
+让 **DSH 技能一改就自动被审核** 的插件：监听 `tools/post-execute`，在技能文件被 `write`/`edit`/shell 改动之后、或在 `dsh_config_git_backup` 的 `restore`/`backup` 之后，跑一遍技能审核，并把结论作为上下文回传给模型。同时注册 `skill_audit` 工具供按需调用。
+
+## 为什么需要插件（而不是 hooks.json）
+
+DSH 自带的 Claude Code 钩子桥接（`@deepseek-ai/dsh-hooks-claude-code`）通过 **`ctx.shell`** 执行钩子命令。当宿主没有可用的沙箱 runner 时（Windows 上 ACL 后端未挂载时的实测情形），执行器按设计 **fail-closed**：命令根本不会启动，会话日志里只留下
+
+```
+hook/invoked  PostToolUse ...
+hook/result   decision=pass  stderr=sandbox mode "workspace-write" is requested
+              but no sandbox backend is usable on this host; refusing to run the command unconfined
+```
+
+—— 也就是说 `hooks.json` 配置得再正确也没用。同类第三方 hooks 插件（如 `dsh-hooks-plugin`、`dsh-plugin-hooks`）同样走 `ctx.shell`，会撞同一堵墙。
+
+本插件在 **harness 进程内**用 `ctx.subprocess`（host 层）直接跑审核脚本，**不经过 `ctx.shell`**，因此不受沙箱策略限制；这也是官方对"没有 Claude Code 对应物的定制行为"给出的推荐形态。
+
+## 安装
+
+```sh
+# 从 npm（推荐）
+dsh plugin --profile web add @caesarloo/dsh-skill-audit
+
+# 本地开发（link 到工作副本）
+dsh plugin --profile web add C:\workspace\dsh-skill-audit
+```
+
+装完**重启 dsh**（bundle 层变更无 HMR；`dsh --profile web --dump-config` 应能看到 `id: tool-skill-audit`）。
+
+## 前置
+
+审核逻辑不在本插件内（**单一真源**），默认调用：
+
+```
+<DSH_HOME>/skills/skill-audit/scripts/audit-skills.ps1
+```
+
+即 `skill-audit` 技能的静态审核引擎（frontmatter 契约、脚本 UTF-8 BOM + PowerShell 5.1 可解析、SKILL.md 引用完整性、凭据泄漏、机器专属路径、危险命令）。该脚本不存在时：`skill_audit` 工具返回明确错误，自动触发**静默跳过**（不会因为审核引擎缺失而干扰正常写文件）。
+
+## 配置
+
+```yaml
+- insert:
+    - id: tool-skill-audit
+      name: '@caesarloo/dsh-skill-audit'
+      config:
+        skillsRoot: 'C:\Users\me\.dsh\skills'        # 可选，缺省 <DSH_HOME>/skills
+        auditScript: '...\audit-skills.ps1'          # 可选，缺省 <skillsRoot>/skill-audit/scripts/audit-skills.ps1
+        autoAudit: true                              # 可选，false = 只保留工具、不做自动触发
+        powershell: 'C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe'
+        timeoutMs: 120000                            # 可选，单次审核超时
+        maxContextChars: 2000                        # 可选，回传上下文的字符上限
+```
+
+正常使用无需任何配置（路径从 `DSH_HOME` 推导）。
+
+## 自动触发规则
+
+| 工具调用 | 审核范围 |
+| --- | --- |
+| **写入类**文件工具（`write`/`edit`/`multi_edit`/`notebook_edit`/`apply_patch` …），目标路径落在 `<skillsRoot>/<技能>/` 下 | **只审该技能**（快，约 1 秒） |
+| 只读工具（`read`/`glob`/`grep`） | **不触发** —— 它们同样携带 `file_path` 却不修改内容；不加这条白名单，每读一次技能文件就会注入一次审核上下文 |
+| `dsh_config_git_backup`，`mode` 为 `restore` 或 `backup` | **全量**（整批覆盖 / 入库前体检） |
+| `pwsh` / `bash` 等 shell，命令行同时含 `skills` 与写操作迹象（`Set-Content`/`Copy-Item`/`Remove-Item`/`robocopy`/`git checkout` …） | **全量**（shell 里改了哪个文件无法精确判定，宁可全量） |
+| 其它工具、或路径不在技能目录内 | 不触发，静默 `next()` |
+
+- 审核在 **`tools/post-execute`（写入之后）** 执行，因此审的是**新内容**（对比：`pre-execute` 时文件还没落盘，只能审到旧版本）。
+- **上下文分级**：定向单技能（`write`/`edit`）时详列 `fail` + `warn`；**全量场景**（restore/backup、shell 批量改写）只详列 `fail`，`warn` 压成一行汇总 —— 本机 11 个技能里 9 个各有 1~3 条元数据类 warn，逐条列出会把上下文挤爆并失去焦点。**全量且只有 warn 时完全不注入**（背景噪音不该打断写入）；全部通过时同样保持安静，只写 `<DSH_HOME>/vet/skill-audits/`。
+- 自动触发**永远不会**影响工具调用本身：任何异常都被吞掉并委托 `next()`。
+
+## `skill_audit` 工具
+
+```
+skill_audit()                      # 审计 skillsRoot 下全部技能
+skill_audit({ skill: 'a,b' })      # 只审指定技能（逗号分隔）
+```
+
+返回逐技能的通过/注意/失败与逐条发现，并把同样的 JSON 结论写入 `<DSH_HOME>/vet/skill-audits/`（`latest.json` + 时间戳档，保留最近 40 份）。
+
+## 依赖约定
+
+`@deepseek-ai/dsh-tools`、`@deepseek-ai/dsh-subprocess`、`@deepseek-ai/dsh-llm` 一律声明为 **optional peerDependencies**，由宿主提供，本包不打包它们。这是刻意的：这两个包若与主包各装一份，会形成**两个模块实例**，而 `TOOL_RUNTIME_SCHEDULER` 是 `Symbol()`（非 `Symbol.for`），跨实例注册失败会导致**所有工具调用崩**。`dsh-llm` 仅用于构造回传上下文消息，缺失时插件降级为"审核照跑、不注入上下文"。
+
+## 开发
+
+```sh
+pnpm install
+pnpm run build      # tsc → dist/
+pnpm test           # node test/smoke.mjs：假 ctx + 真实审核引擎，端到端
+pnpm run typecheck
+```
+
+冒烟测试在临时目录里造两个技能（一个只有 warn、一个含 fail），用假 `ctx`（`tools.register` 捕获工具、`subprocess.spawn` 委托 `node:child_process`、`on()` 捕获 waterfall 处理器）驱动真实实现，断言：工具注册、`planAudit` 的六类范围判定、`parseReport` 的容错、定向/全量审核输出、上下文注入与静默路径、引擎缺失时的 fail-closed。
+
+> `SMOKE_PLUGIN_DIST` 可指向另一份构建产物，但该副本必须位于**能解析 `@deepseek-ai/dsh-tools` 的树**中；不要指向 dsh 安装树（`~/.dsh/profiles/web/node_modules/...`）——裸 node 在那里会解析到版本不匹配的 `dsh-llm` 副本。
+
+## 边界（明确不做）
+
+- 不实现审核规则本身（在 `skill-audit` 技能的脚本里，此处只负责触发与回传）；
+- 不改写工具输入、不阻塞工具调用（`fail` 也只在上下文里告知模型）；
+- 不覆盖 `SessionStart`/`Stop` 等非工具事件；
+- 不做技能目录的文件系统监视（`dsh-skill-filesystem` 已有 watcher；本插件只在工具调用后触发）。
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# dsh-skill-audit bundle layer — applied when a profile lists this bundle.
+# `name` is resolved through the profile's node_modules (or $DSH_HOME/profiles/node_modules),
+# NOT a relative path.
+- insert:
+    - id: tool-skill-audit
+      name: '@caesarloo/dsh-skill-audit'

package/dist/index.js

@@ -0,0 +1,377 @@
+// dsh-skill-audit — 技能审核的自动触发器（host 层执行，不经 ctx.shell，因此不受沙箱限制）。
+//
+// 为什么必须是插件，而不是 hooks 桥接：
+//   @deepseek-ai/dsh-hooks-claude-code 通过 `ctx.shell` 运行钩子命令。当宿主没有可用的沙箱
+//   runner 时（本机 Windows 实测：`SANDBOX_UNAVAILABLE`，执行器按设计 fail-closed、绝不静默
+//   降级），钩子命令根本无法启动 —— hooks.json 配得再对也没用。本插件在 harness 进程内用
+//   `ctx.subprocess`（host 层）直接跑审核脚本，绕开该限制；这也是官方对"没有 Claude Code
+//   对应物的定制行为"给出的推荐形态。
+//
+// 两条通道：
+//   1) `tools/post-execute` 自动触发（写入**之后**，审的是新内容）：
+//        · write / edit 命中 <DSH_HOME>/skills/<技能>/ → 只审该技能
+//        · dsh_config_git_backup 的 restore / backup → 全量（整批覆盖 / 入库前）
+//        · pwsh 等 shell，命令行同时含 skills 与写操作迹象 → 全量
+//   2) `skill_audit` 工具 —— agent 可主动定向或全量审核。
+//
+// 审核逻辑不在本插件内（单一真源）：默认调用
+//   <DSH_HOME>/skills/skill-audit/scripts/audit-skills.ps1
+// 该脚本缺失时工具报明确错误、自动触发静默跳过（不打扰正常写文件）。
+import { stat } from 'node:fs/promises';
+import { isAbsolute, join, resolve as resolvePath } from 'node:path';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+// Plugin display name, shown in loader diagnostics.
+export const name = 'tool-skill-audit';
+export const inject = ['tools', 'subprocess'];
+const POWERSHELL = process.platform === 'win32'
+    ? 'C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe'
+    : 'pwsh';
+const RAW_OUTPUT_MAX_BYTES = 4 * 1024 * 1024; // 全量审核的 JSON 报告可达数十 KB，留足余量
+const STDERR_MAX_BYTES = 256 * 1024;
+const GRACE_MS = 3000;
+const DEFAULT_TIMEOUT_MS = 120000;
+const DEFAULT_MAX_CONTEXT_CHARS = 2000;
+function dshHome() {
+    if (process.env.DSH_HOME)
+        return process.env.DSH_HOME;
+    const home = process.env.USERPROFILE ?? process.env.HOME ?? '.';
+    return join(home, '.dsh');
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** 从工具参数里尽力提取被操作的路径（不同工具键名不同，另有兜底扫描）。 */
+export function candidatePaths(args) {
+    const out = [];
+    if (!args || typeof args !== 'object')
+        return out;
+    const rec = args;
+    for (const key of ['file_path', 'filePath', 'path', 'target_file', 'file', 'notebook_path']) {
+        const value = rec[key];
+        if (typeof value === 'string' && value.length > 0)
+            out.push(value);
+    }
+    for (const value of Object.values(rec)) {
+        if (typeof value === 'string' && /skills[\\/]/i.test(value))
+            out.push(value);
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                if (typeof item === 'string' && /skills[\\/]/i.test(item))
+                    out.push(item);
+            }
+        }
+    }
+    return [...new Set(out)];
+}
+const SHELL_TOOLS = new Set(['pwsh', 'powershell', 'bash', 'sh', 'cmd']);
+/**
+ * 只有写入类文件工具才触发审核。read / glob / grep 等只读工具同样携带 `file_path`，
+ * 但它们不修改内容 —— 2026-09-17 实测：不做这个白名单，每读一次技能文件就会注入一次
+ * 审核上下文（纯噪音）。新出现的写入工具名在此登记即可。
+ */
+const FILE_WRITE_TOOLS = new Set([
+    'write',
+    'edit',
+    'multi_edit',
+    'multiedit',
+    'notebook_edit',
+    'apply_patch',
+    'create_file',
+    'str_replace_editor',
+]);
+const WRITE_HINTS = /(?:Set-Content|Out-File|Add-Content|Clear-Content|Copy-Item|Move-Item|Remove-Item|New-Item|robocopy|git\s+(?:checkout|restore|apply))/i;
+/** 决定这次工具调用要不要触发审核；返回 null 表示与该工具无关。 */
+export function planAudit(toolName, args, skillsRoot) {
+    const lower = toolName.toLowerCase();
+    if (lower === 'dsh_config_git_backup') {
+        const mode = String(args?.mode ?? '').toLowerCase();
+        if (mode && mode !== 'restore' && mode !== 'backup')
+            return null;
+        return { skills: null, scope: `dsh_config_git_backup(${mode || '?'}) → 全量` };
+    }
+    if (SHELL_TOOLS.has(lower)) {
+        const command = String(args?.command ?? '');
+        if (!command || !/skills/i.test(command) || !WRITE_HINTS.test(command))
+            return null;
+        return { skills: null, scope: `${toolName} → 命令行涉及 skills 目录（全量）` };
+    }
+    // 只读工具（read/glob/grep …）也带 file_path，但不改内容 → 不触发
+    if (!FILE_WRITE_TOOLS.has(lower))
+        return null;
+    const hits = [];
+    const root = skillsRoot.toLowerCase();
+    for (const raw of candidatePaths(args)) {
+        const abs = isAbsolute(raw) ? raw : resolvePath(raw);
+        if (!abs.toLowerCase().startsWith(root))
+            continue;
+        const seg = abs.slice(skillsRoot.length).replace(/^[\\/]+/, '').split(/[\\/]/)[0];
+        if (seg)
+            hits.push(seg);
+    }
+    if (hits.length === 0)
+        return null;
+    const skills = [...new Set(hits)];
+    return { skills, scope: `${toolName} → 技能 ${skills.join(', ')}` };
+}
+export function parseReport(text) {
+    const raw = text.trim();
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        // 输出可能带前置警告/ BOM：从第一个 { 起再试一次
+        const idx = raw.indexOf('{');
+        if (idx <= 0)
+            return null;
+        try {
+            return JSON.parse(raw.slice(idx));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+export function apply(ctx, config = {}) {
+    const skillsRoot = (config.skillsRoot ?? join(dshHome(), 'skills')).replace(/[\\/]+$/, '');
+    const auditScript = config.auditScript ?? join(skillsRoot, 'skill-audit', 'scripts', 'audit-skills.ps1');
+    const powershell = config.powershell ?? POWERSHELL;
+    const autoAudit = config.autoAudit !== false;
+    const timeoutMs = config.timeoutMs && config.timeoutMs > 0 ? config.timeoutMs : DEFAULT_TIMEOUT_MS;
+    const maxContextChars = config.maxContextChars && config.maxContextChars > 0
+        ? config.maxContextChars
+        : DEFAULT_MAX_CONTEXT_CHARS;
+    async function runAudit(skills, signal) {
+        if (!(await fileExists(auditScript))) {
+            return { exitCode: -1, stdout: '', stderr: `审核脚本不存在: ${auditScript}` };
+        }
+        const argv = [
+            powershell,
+            '-NoProfile',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-File',
+            auditScript,
+            '-Json',
+            '-SkillsRoot',
+            skillsRoot,
+        ];
+        if (skills && skills.length > 0)
+            argv.push('-Skill', skills.join(','));
+        let handle;
+        try {
+            handle = ctx.subprocess.spawn({
+                argv,
+                cwd: skillsRoot,
+                stdio: {
+                    stdin: 'ignore',
+                    stdout: { maxBytes: RAW_OUTPUT_MAX_BYTES },
+                    stderr: { maxBytes: STDERR_MAX_BYTES },
+                },
+                graceMs: GRACE_MS,
+                signal,
+            });
+        }
+        catch (error) {
+            return { exitCode: -1, stdout: '', stderr: `无法启动审核脚本: ${String(error)}` };
+        }
+        let outcome;
+        try {
+            outcome = await handle.done;
+        }
+        catch (error) {
+            return { exitCode: -1, stdout: '', stderr: `审核脚本执行失败: ${String(error)}` };
+        }
+        if (outcome.signal !== null || outcome.exitCode === null) {
+            return {
+                exitCode: -1,
+                stdout: '',
+                stderr: `审核脚本被信号终止: ${outcome.signal ?? '(unknown)'}`,
+            };
+        }
+        const stdout = handle.collected.stdout?.readFrom(0);
+        const stderr = handle.collected.stderr?.readFrom(0);
+        return {
+            exitCode: outcome.exitCode,
+            stdout: stdout?.text ?? '',
+            stderr: stderr?.text ?? '',
+        };
+    }
+    /** 审核并把结论渲染成人读文本（供工具返回）；无法解析时返回原始输出。 */
+    async function auditAndRender(skills, signal) {
+        const run = await runAudit(skills, signal);
+        if (run.exitCode === -1)
+            return { ok: false, text: run.stderr, report: null };
+        const report = parseReport(run.stdout);
+        if (!report) {
+            const fallback = [run.stdout.trim(), run.stderr.trim()].filter(Boolean).join('\n');
+            return { ok: false, text: fallback || '(审核脚本无输出)', report: null };
+        }
+        const problem = (report.results ?? []).filter((r) => r.status !== 'pass');
+        const lines = [];
+        lines.push(`技能审核：${report.results?.length ?? 0} 个技能，fail ${report.fail ?? 0}，warn ${report.warn ?? 0}`);
+        for (const r of report.results ?? []) {
+            const mark = r.status === 'pass' ? '[通过]' : r.status === 'warn' ? '[注意]' : '[失败]';
+            lines.push(`${mark} ${r.skill}（脚本 ${r.scripts} 个，fail ${r.fails}，warn ${r.warns}）`);
+            for (const f of r.findings ?? []) {
+                if (f.level === 'info')
+                    continue;
+                lines.push(`    - [${f.level}] ${f.message}`);
+            }
+        }
+        if (problem.length === 0)
+            lines.push('全部技能通过。');
+        return { ok: true, text: lines.join('\n'), report };
+    }
+    /**
+     * 构造回传上下文；只有存在需要行动的问题时才返回消息。
+     *
+     * `failsOnly` 用于**全量场景**（restore/backup、shell 批量改写）：那里 warn 的绝对数量很大
+     * （本机 11 个技能里 9 个各有 1~3 条元数据类 warn），逐条列出会把上下文挤爆且失去焦点 ——
+     * 全量时只详列 fail，warn 压成一行汇总；定向单技能时（通常 1~3 条）才 fail+warn 都列。
+     * 全量且**只有 warn**时直接返回 undefined：那属于背景噪音，不该打断任何一次写入。
+     */
+    async function buildContextMessage(report, scope, failsOnly = false) {
+        const problem = (report.results ?? []).filter((r) => r.status !== 'pass');
+        if (problem.length === 0)
+            return undefined;
+        const lines = [`【技能审核 skill-audit】范围：${scope}`];
+        const warnOnly = [];
+        for (const r of problem) {
+            const detail = (r.findings ?? []).filter((f) => f.level !== 'info');
+            const fails = detail.filter((f) => f.level === 'fail');
+            if (failsOnly && fails.length === 0) {
+                warnOnly.push(r.skill);
+                continue;
+            }
+            const mark = r.status === 'fail' ? '未通过' : '有注意项';
+            lines.push(`· ${r.skill}：${mark}（fail ${r.fails} / warn ${r.warns}）`);
+            const list = failsOnly ? fails : detail;
+            const shown = list.slice(0, 4);
+            for (const f of shown)
+                lines.push(`    - [${f.level}] ${f.message}`);
+            if (list.length > shown.length) {
+                lines.push(`    … 另有 ${list.length - shown.length} 项，见 ~/.dsh/vet/skill-audits/latest.json`);
+            }
+        }
+        // 全量场景下一条 fail 都没有 → 完全不打扰（warn 是背景噪音，只留在日志里）。
+        // 注意必须在这里早退：一旦先 push 了下面的汇总行，再判断"只剩标题"就永远不成立。
+        if (failsOnly && lines.length === 1)
+            return undefined;
+        if (warnOnly.length > 0) {
+            const head = warnOnly.slice(0, 8).join('、');
+            lines.push(`· 另有 ${warnOnly.length} 个技能仅有 warn（多为缺 version/whenToUse 等元数据）：${head}${warnOnly.length > 8 ? ' …' : ''}`);
+        }
+        lines.push('修复后可调用 skill_audit 工具复验；判据与误报处置见 skill-audit 技能。');
+        let text = lines.join('\n');
+        if (text.length > maxContextChars) {
+            text = `${text.slice(0, maxContextChars)}\n…（已截断；完整结论见 ~/.dsh/vet/skill-audits/latest.json）`;
+        }
+        try {
+            const llm = (await import('@deepseek-ai/dsh-llm'));
+            if (typeof llm.createUserMessage !== 'function')
+                return undefined;
+            return llm.createUserMessage({
+                content: [{ type: 'text', text }],
+                source: { kind: 'plugin', plugin: 'tool-skill-audit' },
+            });
+        }
+        catch {
+            // dsh-llm 不可用时降级：审核照常执行并留日志，只是不注入上下文
+            return undefined;
+        }
+    }
+    ctx.tools.register(defineTool({
+        name: 'skill_audit',
+        description: 'Statically audit DSH skills: frontmatter contract (name/description/whenToUse/version), ' +
+            'script usability (UTF-8 BOM + PowerShell 5.1 parse), SKILL.md reference integrity, ' +
+            'credential leakage, machine-specific paths and dangerous command patterns. ' +
+            'Pass "skill" to audit one or more skills (comma separated); omit it to audit every skill ' +
+            'under the skills root. Findings are also logged to <DSH_HOME>/vet/skill-audits/.',
+        parameters: {
+            skill: {
+                type: 'string',
+                description: 'Skill name(s) to audit, comma separated. Omit to audit all skills in the skills root.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                properties: {
+                    stdout: { type: 'string', required: true, description: 'Human-readable audit report.' },
+                    stderr: { type: 'string', required: true, description: 'Diagnostics when the run failed.' },
+                },
+                additionalProperties: false,
+            },
+            render: (_args, value) => [
+                {
+                    type: 'text',
+                    text: (value.stdout?.trim?.()?.length ?? 0) > 0
+                        ? value.stdout
+                        : value.stderr?.trim?.()?.length > 0
+                            ? `(no stdout) ${value.stderr}`
+                            : '(empty output)',
+                },
+            ],
+        },
+        timeoutMs,
+        async execute(args, exec) {
+            if (exec.signal.aborted)
+                throw new Error('skill_audit was aborted before completion');
+            const raw = typeof args.skill === 'string' ? args.skill.trim() : '';
+            const skills = raw
+                ? raw
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean)
+                : null;
+            const { ok, text } = await auditAndRender(skills, exec.signal);
+            if (exec.signal.aborted)
+                throw new Error('skill_audit was aborted before completion');
+            if (!ok)
+                throw new Error(`skill_audit 执行失败:\n${text}`);
+            return { stdout: text, stderr: '' };
+        },
+    }));
+    if (autoAudit) {
+        const on = ctx.on;
+        if (typeof on === 'function') {
+            on('tools/post-execute', async (...handlerArgs) => {
+                // waterfall 契约：(exec, result, next)
+                const exec = handlerArgs[0];
+                const next = handlerArgs[2];
+                try {
+                    const toolName = typeof exec?.name === 'string' ? exec.name : '';
+                    if (!toolName || typeof next !== 'function')
+                        return await next?.();
+                    const plan = planAudit(toolName, exec?.arguments, skillsRoot);
+                    if (!plan)
+                        return await next();
+                    const run = await runAudit(plan.skills, exec?.signal);
+                    const report = run.exitCode === -1 ? null : parseReport(run.stdout);
+                    const context = report
+                        ? await buildContextMessage(report, plan.scope, plan.skills === null)
+                        : undefined;
+                    const downstream = (await next());
+                    if (!context)
+                        return downstream;
+                    const existing = Array.isArray(downstream?.additionalContexts)
+                        ? downstream.additionalContexts
+                        : [];
+                    return { ...(downstream ?? {}), additionalContexts: [context, ...existing] };
+                }
+                catch {
+                    // 自动触发永远不能影响工具调用本身
+                    return await next?.();
+                }
+            });
+        }
+    }
+    ctx.logger.info(`[tool-skill-audit] registered "skill_audit" — script=${auditScript} skillsRoot=${skillsRoot} autoAudit=${autoAudit}`);
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@caesarloo/dsh-skill-audit",
+  "version": "0.1.0",
+  "description": "Audit DSH skills automatically: a host-layer tools/post-execute plugin that runs the skill-audit engine after skill files change (write/edit/shell) or after a dsh_config_git_backup restore, feeding findings back to the model as context; also registers the skill_audit tool.",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "skill",
+    "audit",
+    "lint",
+    "quality"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/caesarloo/dsh-skill-audit.git"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node test/smoke.mjs"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-subprocess": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-subprocess": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-subprocess": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
+    "@types/node": "^22.10.0",
+    "typescript": "^5.6.0"
+  }
+}