@spzhongwin/skill-logger-plugin 1.0.2

package/dist/index.test.js

@@ -0,0 +1,39 @@
+import { describe, it, before } from "node:test";
+import assert from "node:assert/strict";
+let isSkillMdReadPath;
+let extractApiPluginConfig;
+describe("isSkillMdReadPath", () => {
+    before(async () => {
+        ({ isSkillMdReadPath, extractApiPluginConfig } = await import("./index.ts"));
+    });
+    it("POSIX 路径 basename 为 SKILL.md 时为 true", () => {
+        assert.equal(isSkillMdReadPath("/x/y/my-skill/SKILL.md"), true);
+    });
+    it("Windows 风格路径", { skip: process.platform !== "win32" }, () => {
+        assert.equal(isSkillMdReadPath(String.raw `C:\x\y\my-skill\SKILL.md`), true);
+    });
+    it("fooSKILL.md / my-SKILL.md 不误判", () => {
+        assert.equal(isSkillMdReadPath("/tmp/fooSKILL.md"), false);
+        assert.equal(isSkillMdReadPath("/tmp/my-SKILL.md"), false);
+    });
+});
+describe("extractApiPluginConfig", () => {
+    it("从 OpenClaw 注入的 api.pluginConfig 初始化运行期配置", () => {
+        assert.deepEqual(extractApiPluginConfig({
+            pluginConfig: {
+                platformBaseUrl: "https://platform.example/api",
+                reportBaseUrl: "https://report.example/api",
+                authToken: "Bearer token",
+                recordUnattributed: true,
+            },
+        }), {
+            platformBaseUrl: "https://platform.example/api",
+            reportBaseUrl: "https://report.example/api",
+            authToken: "Bearer token",
+            recordUnattributed: true,
+        });
+    });
+    it("未配置时返回空对象", () => {
+        assert.deepEqual(extractApiPluginConfig({}), {});
+    });
+});

package/dist/integration.test.js

@@ -0,0 +1,102 @@
+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 { createHash } from "node:crypto";
+import { ConfigSync } from "./config-sync.ts";
+import { SkillUpdater } from "./updater.ts";
+const idHash = (code, version) => createHash("sha256").update(`${code} ${code} ${version}`).digest("hex");
+let dir;
+beforeEach(async () => {
+    dir = path.join(os.tmpdir(), `slp-int-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(dir, { recursive: true });
+});
+afterEach(async () => {
+    await fs.rm(dir, { recursive: true, force: true });
+});
+describe("版本更新闭环（端到端）", () => {
+    it("config-pull 报最新版 → 检测落后 → 下载覆盖 → 再查收敛", async () => {
+        // 本地装一个 demo@1.0.0
+        const ws = path.join(dir, "workspace");
+        const skillDir = path.join(ws, "skills", "demo");
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(path.join(skillDir, "SKILL.md"), "---\nname: demo\nversion: 1.0.0\n---\nOLD\n");
+        const config = { platformBaseUrl: "https://api", autoUpdateSkills: true };
+        // 服务端最新版本（随测试推进而变化），模拟「更新后平台版本=本地版本」的收敛。
+        let platformLatest = "2.0.0";
+        // ConfigSync 的 fetch：/skill_config/pull → 带 latestVersion
+        const csFetch = async (_url, _init) => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ configs: [{ skillName: "demo", version: "1.0.0", latestVersion: platformLatest, functions: [] }] }),
+        });
+        // Updater 的 fetch：/skill_package/pull → {url, sha256}；GET → zip 字节
+        const upFetch = async (_url, init) => {
+            if (init?.method === "POST") {
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ url: "https://pkg/skill.zip", version: platformLatest, sha256: idHash("demo", platformLatest) }),
+                    arrayBuffer: async () => new ArrayBuffer(0),
+                };
+            }
+            return { ok: true, status: 200, json: async () => ({}), arrayBuffer: async () => new Uint8Array([1]).buffer };
+        };
+        // 解压：写出新版本的 SKILL.md（版本号与 platformLatest 一致）
+        const unzip = async (_zip, destDir) => {
+            const root = path.join(destDir, "demo");
+            await fs.mkdir(root, { recursive: true });
+            await fs.writeFile(path.join(root, "SKILL.md"), `---\nname: demo\nversion: ${platformLatest}\n---\nNEW\n`);
+        };
+        const updater = new SkillUpdater({ getConfig: () => config, fetchImpl: upFetch, unzip, tmpDir: dir });
+        const cs = new ConfigSync({
+            paths: { extensionsDir: path.join(dir, "ext"), syncStatePath: path.join(dir, "sync.json"), openclawConfigPath: path.join(dir, "openclaw.json") },
+            getConfig: () => config,
+            fetchImpl: csFetch,
+            resolveSkillDirs: () => [path.join(ws, "skills")],
+            updater,
+        });
+        // 第一轮：检测落后并覆盖到 2.0.0
+        await cs.checkVersionsAndUpdate();
+        const afterMd = await fs.readFile(path.join(skillDir, "SKILL.md"), "utf-8");
+        assert.ok(afterMd.includes("version: 2.0.0"), "应被更新到 2.0.0");
+        assert.ok(afterMd.includes("NEW"), "应为新内容");
+        // 第二轮：平台版本仍 2.0.0、本地已 2.0.0 → 收敛，无落后副本
+        platformLatest = "2.0.0";
+        await cs.checkVersionsAndUpdate();
+        assert.equal(cs.detectOutdated().length, 0, "更新后应收敛");
+        // sync.json 落了 installations 映射，且版本已是 2.0.0
+        const state = JSON.parse(await fs.readFile(path.join(dir, "sync.json"), "utf-8"));
+        assert.equal(state.installations.demo[0].version, "2.0.0");
+    });
+    it("autoUpdateSkills=false：检测到落后也不覆盖", async () => {
+        const ws = path.join(dir, "workspace");
+        const skillDir = path.join(ws, "skills", "demo");
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(path.join(skillDir, "SKILL.md"), "---\nname: demo\nversion: 1.0.0\n---\nOLD\n");
+        const config = { platformBaseUrl: "https://api", autoUpdateSkills: false };
+        const csFetch = async () => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ configs: [{ skillName: "demo", version: "1.0.0", latestVersion: "2.0.0", functions: [] }] }),
+        });
+        let upCalled = 0;
+        const upFetch = async () => {
+            upCalled++;
+            return { ok: true, status: 200, json: async () => ({ url: "" }), arrayBuffer: async () => new ArrayBuffer(0) };
+        };
+        const updater = new SkillUpdater({ getConfig: () => config, fetchImpl: upFetch, unzip: async () => { }, tmpDir: dir });
+        const cs = new ConfigSync({
+            paths: { extensionsDir: path.join(dir, "ext"), syncStatePath: path.join(dir, "sync.json"), openclawConfigPath: path.join(dir, "openclaw.json") },
+            getConfig: () => config,
+            fetchImpl: csFetch,
+            resolveSkillDirs: () => [path.join(ws, "skills")],
+            updater,
+        });
+        await cs.checkVersionsAndUpdate();
+        assert.equal(cs.detectOutdated().length, 1, "仍检测到落后");
+        assert.equal(upCalled, 0, "关闭时不应发起下载");
+        assert.ok((await fs.readFile(path.join(skillDir, "SKILL.md"), "utf-8")).includes("OLD"), "文件保持原样");
+    });
+});

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");
+    });
+});