@spzhongwin/skill-logger-plugin 1.0.11 → 1.0.13

package/dist/matcher.js

@@ -0,0 +1,362 @@
+/**
+ * 多策略匹配引擎（纯函数、无 I/O）。
+ *
+ * 职责：给定一次观测到的工具调用（toolName + params）和「本 session 已激活的 skill 集合」，
+ * 判定它是否对应某 skill 的某功能点，并解析出参数。
+ *
+ * 四种策略（由标准配置里 `match.type` 判别）：
+ *   - script  ：exec 跑 skill 自带脚本（.py/.sh/.js），按脚本路径后缀匹配
+ *   - command ：exec 调包装 CLI（如 `mcporter call linear.list_issues`）
+ *   - tool    ：直接调非 exec 工具（MCP/SSE 工具），按 toolName(+参数谓词) 匹配
+ *   - http    ：curl/fetch 打 HTTP/SSE 端点，按 url/host 子串匹配
+ *
+ * 为保证 hook 热路径快：先用 buildIndex 预索引（按 basename / 命令头 / toolName / host 建桶），
+ * match 时仅在小候选集上做精确判定。
+ */
+import path from "node:path";
+/** 已知解释器/包装前缀，用于在找「命令头」时跳过。 */
+const INTERPRETERS = new Set([
+    "python", "python3", "py", "bash", "sh", "zsh", "node", "ts-node",
+    "tsx", "deno", "ruby", "perl", "uv", "uvx", "npx", "pnpm", "yarn", "env",
+]);
+/** 空索引。 */
+export function emptyIndex() {
+    return {
+        scriptByBasename: new Map(),
+        commandByHead: new Map(),
+        toolByName: new Map(),
+        toolFuzzy: [],
+        httpRules: [],
+    };
+}
+function pushBucket(map, key, fn) {
+    const arr = map.get(key);
+    if (arr)
+        arr.push(fn);
+    else
+        map.set(key, [fn]);
+}
+/** 把标准配置编译成可快速匹配的索引。 */
+export function buildIndex(configs) {
+    const index = emptyIndex();
+    for (const cfg of configs) {
+        for (const fn of cfg.functions) {
+            const indexed = {
+                skillName: cfg.skillName,
+                skillVersion: cfg.version,
+                functionId: fn.id,
+                functionName: fn.name,
+                rule: fn.match,
+            };
+            switch (fn.match.type) {
+                case "script":
+                    pushBucket(index.scriptByBasename, path.basename(fn.match.script), indexed);
+                    break;
+                case "command":
+                    pushBucket(index.commandByHead, fn.match.command, indexed);
+                    break;
+                case "tool":
+                    if (fn.match.toolName) {
+                        pushBucket(index.toolByName, fn.match.toolName, indexed);
+                    }
+                    else {
+                        if (fn.match.toolNameRegex) {
+                            try {
+                                indexed.compiledRegex = new RegExp(fn.match.toolNameRegex);
+                            }
+                            catch {
+                                indexed.compiledRegex = null; // 非法正则：预编译失败，匹配时直接不命中
+                            }
+                        }
+                        index.toolFuzzy.push(indexed);
+                    }
+                    break;
+                case "http":
+                    index.httpRules.push(indexed);
+                    break;
+            }
+        }
+    }
+    return index;
+}
+/**
+ * 把 shell 命令切成 token，识别简单的单/双引号；不求完整 shell 语义，够匹配脚本路径与 flag 即可。
+ */
+export function tokenize(command) {
+    const tokens = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let m;
+    while ((m = re.exec(command)) !== null) {
+        tokens.push(m[1] ?? m[2] ?? m[3] ?? "");
+    }
+    return tokens;
+}
+/** 路径后缀匹配（按路径分隔对齐，避免 `xfoo.py` 误判 `foo.py`）。 */
+export function pathEndsWith(token, scriptRel) {
+    const t = token.replace(/\\/g, "/");
+    const s = scriptRel.replace(/\\/g, "/").replace(/^\.?\//, "");
+    return t === s || t.endsWith("/" + s);
+}
+/** 解析命令行 flag：`--k v` / `--k=v` / `-k v` / 布尔 flag。返回去前缀的键值表。 */
+export function parseFlags(tokens) {
+    const out = {};
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t.startsWith("--")) {
+            const eq = t.indexOf("=");
+            if (eq >= 0) {
+                out[t.slice(2, eq)] = t.slice(eq + 1);
+            }
+            else {
+                const next = tokens[i + 1];
+                if (next !== undefined && !next.startsWith("-")) {
+                    out[t.slice(2)] = next;
+                    i++;
+                }
+                else {
+                    out[t.slice(2)] = true;
+                }
+            }
+        }
+        else if (t.length > 1 && t.startsWith("-") && !/^-\d/.test(t)) {
+            const key = t.slice(1);
+            const next = tokens[i + 1];
+            if (next !== undefined && !next.startsWith("-")) {
+                out[key] = next;
+                i++;
+            }
+            else {
+                out[key] = true;
+            }
+        }
+    }
+    return out;
+}
+/** argRules 全部命中才算命中（flag 去前缀比较；value 省略则只判存在）。 */
+function argRulesMatch(argRules, flags) {
+    if (!argRules || argRules.length === 0)
+        return true;
+    for (const rule of argRules) {
+        const key = rule.flag.replace(/^-+/, "");
+        if (!(key in flags))
+            return false;
+        if (rule.value !== undefined && String(flags[key]) !== rule.value)
+            return false;
+    }
+    return true;
+}
+/** 找命令头：跳过 `VAR=val` 环境前缀与已知解释器，返回首个真实命令名。 */
+export function commandHead(tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (/^[A-Za-z_][\w]*=/.test(t))
+            continue; // 环境变量前缀
+        const base = path.basename(t);
+        if (INTERPRETERS.has(base))
+            continue; // 解释器
+        return base;
+    }
+    return undefined;
+}
+/** 解析 `k=v` / `k:v`（用于 mcporter 等），避开 URL 的 `://`。 */
+export function parseKeyValues(tokens) {
+    const out = {};
+    for (const t of tokens) {
+        if (t.includes("://"))
+            continue;
+        const m = /^([A-Za-z_][\w.-]*)[=:](.*)$/.exec(t);
+        if (m)
+            out[m[1]] = m[2];
+    }
+    return out;
+}
+/** 从字符串里抽第一个 URL。 */
+function extractUrl(s) {
+    const m = /https?:\/\/[^\s"'`]+/.exec(s);
+    return m ? m[0] : undefined;
+}
+/** 解析 URL 的 query 参数为对象。 */
+function parseQuery(url) {
+    const out = {};
+    const qi = url.indexOf("?");
+    if (qi < 0)
+        return out;
+    for (const pair of url.slice(qi + 1).split("&")) {
+        if (!pair)
+            continue;
+        const eq = pair.indexOf("=");
+        const k = decodeURIComponent(eq >= 0 ? pair.slice(0, eq) : pair);
+        const v = eq >= 0 ? decodeURIComponent(pair.slice(eq + 1)) : true;
+        out[k] = v;
+    }
+    return out;
+}
+function httpMatchesUrl(url, rule) {
+    if (rule.urlContains && !url.includes(rule.urlContains))
+        return false;
+    if (rule.hostContains) {
+        let host = "";
+        try {
+            host = new URL(url).host;
+        }
+        catch {
+            host = url;
+        }
+        if (!host.includes(rule.hostContains))
+            return false;
+    }
+    return Boolean(rule.urlContains || rule.hostContains);
+}
+/** 点路径取嵌套字段。 */
+function getByPath(obj, dotted) {
+    let cur = obj;
+    for (const seg of dotted.split(".")) {
+        if (cur && typeof cur === "object" && seg in cur) {
+            cur = cur[seg];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return cur;
+}
+function whereMatches(where, params) {
+    if (!where || where.length === 0)
+        return true;
+    for (const p of where) {
+        if (String(getByPath(params, p.param)) !== p.equals)
+            return false;
+    }
+    return true;
+}
+function toolNameMatches(f, toolName) {
+    const rule = f.rule;
+    if (rule.toolName)
+        return rule.toolName === toolName;
+    if (rule.toolNamePrefix)
+        return toolName.startsWith(rule.toolNamePrefix);
+    if (rule.toolNameRegex) {
+        // 预编译命中走缓存；null 表示编译失败不命中；undefined 仅为兜底（理论上 buildIndex 必已编译）。
+        if (f.compiledRegex === null)
+            return false;
+        if (f.compiledRegex)
+            return f.compiledRegex.test(toolName);
+        try {
+            return new RegExp(rule.toolNameRegex).test(toolName);
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+/** 从工具参数里挑一个 url 字段（fetch 类工具）。 */
+function pickUrlParam(params) {
+    for (const key of ["url", "endpoint", "uri", "href"]) {
+        const v = params[key];
+        if (typeof v === "string" && /^https?:\/\//.test(v))
+            return v;
+    }
+    return undefined;
+}
+function toResult(f, matchType, args) {
+    return {
+        skillName: f.skillName,
+        skillVersion: f.skillVersion,
+        functionId: f.functionId,
+        functionName: f.functionName,
+        matchType,
+        args,
+    };
+}
+/**
+ * 主匹配。命中返回 MatchResult；无自信命中返回 null。
+ * 多候选时优先归属到 `activeSkills`（本 session 已触发的 skill）以消歧。
+ */
+export function match(call, activeSkills, index) {
+    const candidates = [];
+    const add = (res, strong = true) => candidates.push({ res, skillActive: activeSkills.has(res.skillName), strong });
+    if (call.toolName === "exec") {
+        const command = typeof call.params.command === "string" ? call.params.command : "";
+        if (!command)
+            return null;
+        const tokens = tokenize(command);
+        const flags = parseFlags(tokens);
+        // script：按 token 的 basename 命中桶。
+        //  - 强匹配：token 路径以配置脚本相对路径结尾（如完整 baseDir 路径）。
+        //  - 弱匹配：仅 basename 相同（如 `cd` 进目录后 `python model_usage.py`）；
+        //    弱匹配只有在「该 skill 已激活」时才会被采纳，避免跨 skill 同名脚本误判。
+        for (const tok of tokens) {
+            const fns = index.scriptByBasename.get(path.basename(tok));
+            if (!fns)
+                continue;
+            for (const f of fns) {
+                const rule = f.rule;
+                if (!argRulesMatch(rule.argRules, flags))
+                    continue;
+                add(toResult(f, "script", flags), pathEndsWith(tok, rule.script));
+            }
+        }
+        // command：命令头命中桶，再校验 targetPattern 出现在命令里（空白归一以增强鲁棒性）
+        const head = commandHead(tokens);
+        if (head) {
+            const fns = index.commandByHead.get(head);
+            if (fns) {
+                const normCmd = command.replace(/\s+/g, " ");
+                for (const f of fns) {
+                    const rule = f.rule;
+                    if (normCmd.includes(rule.targetPattern.replace(/\s+/g, " "))) {
+                        add(toResult(f, "command", parseKeyValues(tokens)));
+                    }
+                }
+            }
+        }
+        // http：curl/wget 命令里的 URL
+        if (index.httpRules.length > 0) {
+            const url = extractUrl(command);
+            if (url) {
+                for (const f of index.httpRules) {
+                    if (httpMatchesUrl(url, f.rule)) {
+                        add(toResult(f, "http", parseQuery(url)));
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // 非 exec：tool 直调
+        const exact = index.toolByName.get(call.toolName) ?? [];
+        for (const f of exact) {
+            const rule = f.rule;
+            if (whereMatches(rule.where, call.params))
+                add(toResult(f, "tool", { ...call.params }));
+        }
+        for (const f of index.toolFuzzy) {
+            const rule = f.rule;
+            if (toolNameMatches(f, call.toolName) && whereMatches(rule.where, call.params)) {
+                add(toResult(f, "tool", { ...call.params }));
+            }
+        }
+        // http：fetch 类工具的 url 参数
+        if (index.httpRules.length > 0) {
+            const url = pickUrlParam(call.params);
+            if (url) {
+                for (const f of index.httpRules) {
+                    if (httpMatchesUrl(url, f.rule)) {
+                        add(toResult(f, "http", parseQuery(url)));
+                    }
+                }
+            }
+        }
+    }
+    if (candidates.length === 0)
+        return null;
+    // 丢弃「弱匹配且 skill 未激活」的低置信候选。
+    const eligible = candidates.filter((c) => c.strong || c.skillActive);
+    if (eligible.length === 0)
+        return null;
+    // 置信度排序：强且激活 > 强 > 弱且激活。sort 在 V8 稳定，平手时保留配置顺序。
+    const rank = (c) => (c.strong ? 2 : 0) + (c.skillActive ? 1 : 0);
+    eligible.sort((a, b) => rank(b) - rank(a));
+    return eligible[0].res;
+}

package/dist/matcher.test.js

@@ -0,0 +1,139 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { buildIndex, match, parseFlags, parseKeyValues, pathEndsWith, commandHead, tokenize, } from "./matcher.ts";
+const configs = [
+    {
+        skillName: "model-usage",
+        version: "1.0.0",
+        functions: [
+            { id: "usage_current", name: "当前用量", match: { type: "script", script: "scripts/model_usage.py", argRules: [{ flag: "--mode", value: "current" }] } },
+            { id: "usage_all", name: "全部用量", match: { type: "script", script: "scripts/model_usage.py", argRules: [{ flag: "--mode", value: "all" }] } },
+        ],
+    },
+    {
+        skillName: "openai-whisper-api",
+        version: "1.0.0",
+        functions: [{ id: "transcribe", name: "转写", match: { type: "script", script: "scripts/transcribe.sh" } }],
+    },
+    {
+        skillName: "mcporter",
+        version: "1.0.0",
+        functions: [{ id: "list_issues", name: "列issue", match: { type: "command", command: "mcporter", targetPattern: "call linear.list_issues" } }],
+    },
+    {
+        skillName: "linear-mcp",
+        version: "1.0.0",
+        functions: [
+            { id: "create_issue", name: "建issue", match: { type: "tool", toolName: "linear_create_issue" } },
+            { id: "transcribe_http", name: "转写端点", match: { type: "http", urlContains: "/v1/audio/transcriptions" } },
+        ],
+    },
+];
+const index = buildIndex(configs);
+const noActive = new Set();
+function exec(command) {
+    return { toolName: "exec", params: { command } };
+}
+describe("pathEndsWith / tokenize / commandHead", () => {
+    it("脚本路径按段对齐，规避 fooX.py 误判", () => {
+        assert.equal(pathEndsWith("/a/b/scripts/model_usage.py", "scripts/model_usage.py"), true);
+        assert.equal(pathEndsWith("scripts/model_usage.py", "scripts/model_usage.py"), true);
+        assert.equal(pathEndsWith("/a/xscripts/model_usage.py", "scripts/model_usage.py"), false);
+        assert.equal(pathEndsWith("/a/foomodel_usage.py", "model_usage.py"), false);
+    });
+    it("tokenize 处理引号", () => {
+        assert.deepEqual(tokenize(`a "b c" 'd e' f`), ["a", "b c", "d e", "f"]);
+    });
+    it("commandHead 跳过环境前缀与解释器", () => {
+        assert.equal(commandHead(tokenize("FOO=1 python /x/scripts/y.py --a")), "y.py");
+        assert.equal(commandHead(tokenize("mcporter call linear.list_issues")), "mcporter");
+    });
+});
+describe("parseFlags / parseKeyValues", () => {
+    it("--k v / --k=v / 布尔 flag", () => {
+        const f = parseFlags(tokenize("x --mode current --pretty --n=3 -v"));
+        assert.equal(f.mode, "current");
+        assert.equal(f.pretty, true);
+        assert.equal(f.n, "3");
+        assert.equal(f.v, true);
+    });
+    it("k=v / k:v，跳过 URL", () => {
+        const kv = parseKeyValues(tokenize("call linear.list_issues team=ENG limit:5 url=https://x/y"));
+        assert.equal(kv.team, "ENG");
+        assert.equal(kv.limit, "5");
+        assert.equal(kv.url, undefined); // 含 :// 被跳过
+    });
+});
+describe("match - script", () => {
+    it("按 --mode 细分功能点", () => {
+        const cur = match(exec("python /e/skills/model-usage/scripts/model_usage.py --mode current"), noActive, index);
+        assert.equal(cur?.functionId, "usage_current");
+        assert.equal(cur?.matchType, "script");
+        assert.equal(cur?.args.mode, "current");
+        const all = match(exec("python /e/skills/model-usage/scripts/model_usage.py --mode all --pretty"), noActive, index);
+        assert.equal(all?.functionId, "usage_all");
+    });
+    it("argRules 不满足则不命中该功能点", () => {
+        const r = match(exec("python /e/scripts/model_usage.py --mode none"), noActive, index);
+        assert.equal(r, null);
+    });
+    it("解释器无关：bash 跑 .sh 命中", () => {
+        const r = match(exec("bash /e/openai-whisper-api/scripts/transcribe.sh a.mp3"), noActive, index);
+        assert.equal(r?.functionId, "transcribe");
+    });
+});
+describe("match - command / tool / http", () => {
+    it("command: mcporter call", () => {
+        const r = match(exec("mcporter call linear.list_issues team=ENG"), noActive, index);
+        assert.equal(r?.functionId, "list_issues");
+        assert.equal(r?.matchType, "command");
+        assert.equal(r?.args.team, "ENG");
+    });
+    it("tool: 非 exec 工具直调", () => {
+        const r = match({ toolName: "linear_create_issue", params: { title: "bug" } }, noActive, index);
+        assert.equal(r?.functionId, "create_issue");
+        assert.equal(r?.matchType, "tool");
+        assert.equal(r?.args.title, "bug");
+    });
+    it("http: curl 命中端点", () => {
+        const r = match(exec("curl -s https://api.openai.com/v1/audio/transcriptions -F file=@a.mp3"), noActive, index);
+        assert.equal(r?.functionId, "transcribe_http");
+        assert.equal(r?.matchType, "http");
+    });
+    it("http: fetch 类工具 url 参数命中", () => {
+        const r = match({ toolName: "fetch", params: { url: "https://api.openai.com/v1/audio/transcriptions?x=1" } }, noActive, index);
+        assert.equal(r?.functionId, "transcribe_http");
+        assert.equal(r?.args.x, "1");
+    });
+    it("无匹配返回 null", () => {
+        assert.equal(match(exec("ls -la"), noActive, index), null);
+        assert.equal(match({ toolName: "unknown_tool", params: {} }, noActive, index), null);
+    });
+});
+describe("match - 弱匹配（cd 后相对路径）仅在 skill 激活时采纳", () => {
+    it("仅 basename 相同：未激活 → null，激活 → 命中", () => {
+        // `cd .../openai-whisper-api/scripts && bash transcribe.sh a.mp3`
+        const call = exec("bash transcribe.sh a.mp3");
+        assert.equal(match(call, noActive, index), null);
+        const r = match(call, new Set(["openai-whisper-api"]), index);
+        assert.equal(r?.functionId, "transcribe");
+    });
+    it("强匹配优先于弱匹配", () => {
+        // 同时出现强（全路径）与弱（裸名）token 时取强匹配
+        const r = match(exec("bash /e/openai-whisper-api/scripts/transcribe.sh"), noActive, index);
+        assert.equal(r?.functionId, "transcribe");
+    });
+});
+describe("match - 歧义消解优先 activeSkills", () => {
+    const ambConfigs = [
+        { skillName: "A", version: "1", functions: [{ id: "a", name: "a", match: { type: "tool", toolNamePrefix: "x_" } }] },
+        { skillName: "B", version: "1", functions: [{ id: "b", name: "b", match: { type: "tool", toolNamePrefix: "x_" } }] },
+    ];
+    const ambIndex = buildIndex(ambConfigs);
+    it("无激活时取第一候选", () => {
+        assert.equal(match({ toolName: "x_do", params: {} }, noActive, ambIndex)?.skillName, "A");
+    });
+    it("激活 B 时归属 B", () => {
+        assert.equal(match({ toolName: "x_do", params: {} }, new Set(["B"]), ambIndex)?.skillName, "B");
+    });
+});

package/dist/paths.js

@@ -0,0 +1,62 @@
+/**
+ * 集中管理插件用到的所有文件系统路径。
+ *
+ * 为什么集中：① 单测可注入临时目录；② openclaw 安全策略下插件不读环境变量，
+ * 路径在此固定，运行时不依赖外部配置。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+/** 默认根目录 `~/.openclaw`。 */
+export function openclawHome() {
+    return path.join(os.homedir(), ".openclaw");
+}
+/**
+ * 解析所有 agent workspace 下的 skill 扫描目录。
+ *
+ * 来源：
+ *  - 顶层全局 skills：`<home>/skills`
+ *  - 默认 workspace：`<agents.defaults.workspace>/skills`（缺省为 `<home>/workspace`）
+ *  - 各 agent：`<agents.list[].workspace>/skills`（未显式配置 workspace 的 agent 落到默认）
+ *
+ * openclaw.json 不存在 / 解析失败 / 字段缺失时，回退到「顶层 skills + 默认 workspace skills」，
+ * 至少不弱于历史行为，且整段被 try/catch 包裹，绝不抛。
+ */
+export function resolveAgentSkillDirs(home, configPath) {
+    const dirs = new Set();
+    // 永远纳入的兜底目录（即便 openclaw.json 缺失也能工作）。
+    dirs.add(path.join(home, "skills"));
+    const defaultWorkspaceFallback = path.join(home, "workspace");
+    dirs.add(path.join(defaultWorkspaceFallback, "skills"));
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const cfg = JSON.parse(raw);
+        const agents = cfg?.agents;
+        const defaultWs = typeof agents?.defaults?.workspace === "string" ? agents.defaults.workspace : defaultWorkspaceFallback;
+        dirs.add(path.join(defaultWs, "skills"));
+        const list = Array.isArray(agents?.list) ? agents.list : [];
+        for (const a of list) {
+            const ws = typeof a?.workspace === "string" ? a.workspace : defaultWs;
+            dirs.add(path.join(ws, "skills"));
+        }
+    }
+    catch {
+        // openclaw.json 不存在 / 非法 JSON / 权限不足 → 用上面的兜底目录，绝不影响插件启动。
+    }
+    return [...dirs];
+}
+/**
+ * 生成一组路径。`overrides` 仅供测试注入（如指向临时目录）。
+ */
+export function resolvePaths(overrides) {
+    const home = openclawHome();
+    const logsDir = path.join(home, "logs");
+    return {
+        eventsLogPath: path.join(logsDir, "skill-logger-plugin.jsonl"),
+        syncStatePath: path.join(logsDir, "skill-logger-plugin.sync.json"),
+        cooldownStatePath: path.join(logsDir, "skill-logger-plugin.cooldown.json"),
+        extensionsDir: path.join(home, "extensions"),
+        openclawConfigPath: path.join(home, "openclaw.json"),
+        ...overrides,
+    };
+}

package/dist/paths.test.js

@@ -0,0 +1,49 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { resolveAgentSkillDirs } from "./paths.ts";
+let home;
+beforeEach(async () => {
+    home = path.join(os.tmpdir(), `slp-paths-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(home, { recursive: true });
+});
+afterEach(async () => {
+    await fs.rm(home, { recursive: true, force: true });
+});
+describe("resolveAgentSkillDirs", () => {
+    it("从 openclaw.json 收集各 agent workspace 的 skills 目录（含默认与顶层）", async () => {
+        const cfg = {
+            agents: {
+                defaults: { workspace: path.join(home, "workspace") },
+                list: [
+                    { id: "main" }, // 无 workspace → 落到默认
+                    { id: "coder", workspace: path.join(home, "workspace-coder") },
+                    { id: "proj", workspace: path.join(home, "agency-agents", "proj") },
+                ],
+            },
+        };
+        const configPath = path.join(home, "openclaw.json");
+        await fs.writeFile(configPath, JSON.stringify(cfg));
+        const dirs = resolveAgentSkillDirs(home, configPath);
+        assert.ok(dirs.includes(path.join(home, "skills")), "应含顶层全局 skills");
+        assert.ok(dirs.includes(path.join(home, "workspace", "skills")), "应含默认 workspace skills");
+        assert.ok(dirs.includes(path.join(home, "workspace-coder", "skills")), "应含 coder workspace skills");
+        assert.ok(dirs.includes(path.join(home, "agency-agents", "proj", "skills")), "应含 proj workspace skills");
+        // 去重：main 落到默认 workspace，不应产生重复项
+        assert.equal(new Set(dirs).size, dirs.length);
+    });
+    it("openclaw.json 缺失时回退到顶层 skills + 默认 workspace skills，且不抛", async () => {
+        const dirs = resolveAgentSkillDirs(home, path.join(home, "does-not-exist.json"));
+        assert.ok(dirs.includes(path.join(home, "skills")));
+        assert.ok(dirs.includes(path.join(home, "workspace", "skills")));
+    });
+    it("非法 JSON 不抛，回退到默认目录", async () => {
+        const configPath = path.join(home, "openclaw.json");
+        await fs.writeFile(configPath, "{ not valid json ");
+        const dirs = resolveAgentSkillDirs(home, configPath);
+        assert.ok(dirs.includes(path.join(home, "skills")));
+        assert.ok(dirs.includes(path.join(home, "workspace", "skills")));
+    });
+});