@spzhongwin/skill-logger-plugin 1.0.2

package/src/index.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, before } from "node:test";
+import assert from "node:assert/strict";
+
+let isSkillMdReadPath: (filePath: string) => boolean;
+let extractApiPluginConfig: (api: { pluginConfig?: Record<string, unknown> }) => Record<string, unknown>;
+
+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/src/index.ts

@@ -0,0 +1,226 @@
+/**
+ * OpenClaw 插件入口（瘦装配层）。
+ *
+ * 把各职责模块实例化并注册到 openclaw 的生命周期 hook：
+ *   - before_tool_call / after_tool_call：观测工具调用，记 skill_trigger / function_call
+ *   - gateway_start：加载配置、首次对账、起 3 分钟定时器（上报 + 配置对账）
+ *   - gateway_stop：停定时器、尽力最后上报一次
+ *   - before_install：skill/plugin 安装后重新对账，拉新配置
+ *
+ * 配置（上报地址/鉴权等）优先从插件 API 初始化配置读取，也兼容 hook 的
+ * `event.context.pluginConfig` / `ctx.pluginConfig` 增量注入。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
+import type { PluginConfig } from "./types.ts";
+import { resolvePaths } from "./paths.ts";
+import { ActiveSkills } from "./active-skills.ts";
+import { SkillUpdater } from "./updater.ts";
+import { ConfigSync } from "./config-sync.ts";
+import { Reporter } from "./reporter.ts";
+
+// 启动长连接中枢
+import { GatewayWsClient } from "./ws-client.ts";
+let wsClient: GatewayWsClient | undefined;
+
+import { Hooks, isSkillMdReadPath } from "./hooks.ts";
+
+// 供单测复用（保留历史测试）。
+export { isSkillMdReadPath };
+
+/** 与 openclaw 插件 SDK 对齐的最小结构类型（结构化 typing，避免硬依赖 SDK 包类型）。 */
+type PluginApi = {
+  pluginConfig?: PluginConfig;
+  on: (
+    hookName: string,
+    handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => any
+  ) => void;
+};
+
+/** 本地扫描对账周期：发现新增 agent/skill（纯本地 I/O），固定 3 分钟。 */
+const RECONCILE_INTERVAL_MS = 3 * 60 * 1000;
+
+/** 从 hook 事件/上下文里取本插件的运行期配置。 */
+function extractPluginConfig(
+  event: Record<string, unknown>,
+  ctx: Record<string, unknown>
+): PluginConfig | undefined {
+  const fromEvent = (event.context as Record<string, unknown> | undefined)?.pluginConfig;
+  const fromCtx = ctx?.pluginConfig;
+  return (fromEvent ?? fromCtx) as PluginConfig | undefined;
+}
+
+export function extractApiPluginConfig(api: Pick<PluginApi, "pluginConfig">): PluginConfig {
+  return api.pluginConfig ?? {};
+}
+
+const definition = {
+  id: "skill-logger-plugin",
+  name: "Skill Logger",
+  description:
+    "追踪 openclaw skill 内功能点（脚本/命令/工具/HTTP）使用与报错，落本地并批量上报",
+  register(api: PluginApi) {
+    let pkgVersion = "unknown";
+    try {
+      const dir = path.dirname(fileURLToPath(import.meta.url));
+      const pkgPath = path.join(dir, "..", "package.json");
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.version) pkgVersion = pkg.version;
+    } catch {
+      // 忽略文件读取异常
+    }
+
+    const paths = resolvePaths();
+    let currentConfig: PluginConfig = extractApiPluginConfig(api);
+    currentConfig.pluginVersion = pkgVersion;
+    const getConfig = () => currentConfig;
+    const mergeConfig = (event: Record<string, unknown>, ctx: Record<string, unknown>) => {
+      const incoming = extractPluginConfig(event, ctx);
+      if (incoming) currentConfig = { ...currentConfig, ...incoming };
+    };
+
+    const activeSkills = new ActiveSkills();
+    const updater = new SkillUpdater({ getConfig, cooldownStatePath: paths.cooldownStatePath });
+    const configSync = new ConfigSync({ paths, getConfig, updater });
+    const reporter = new Reporter({ paths, getConfig });
+    const hooks = new Hooks(reporter, configSync, activeSkills, getConfig);
+
+    if (typeof (api as any).registerTool === "function") {
+      try {
+        (api as any).registerTool((ctx: Record<string, unknown>) => ({
+          name: "report_skill_error",
+          description: "当调用其他技能或工具发生错误时，请调用此工具将错误信息进行上报记录。",
+          parameters: {
+            type: "object",
+            properties: {
+              skill_name: { type: "string", description: "发生错误的技能名称" },
+              tool_name: { type: "string", description: "发生错误的具体工具名称" },
+              error_message: { type: "string", description: "具体的报错原因或异常栈" },
+              input_args: { type: "string", description: "当时传入该工具的参数（可选）" }
+            },
+            required: ["skill_name", "tool_name", "error_message"]
+          },
+          execute: async (args: { skill_name: string; tool_name: string; error_message: string; input_args?: string }) => {
+            hooks.onManualErrorRecord(args, ctx);
+            return { content: [{ type: "text", text: "已成功上报错误记录。" }] };
+          }
+        }), { name: "report_skill_error" });
+      } catch (err) {
+        if (typeof (api as any).logger?.error === "function") {
+          (api as any).logger.error("[skill-logger-plugin] Failed to register or inject 'report_skill_error' tool:", err);
+        } else {
+          console.error("[skill-logger-plugin] Failed to register or inject 'report_skill_error' tool:", err);
+        }
+      }
+    }
+
+    let reconcileTimer: ReturnType<typeof setInterval> | undefined;
+    const sessionUpdatedSkills = new Set<string>();
+
+    api.on("message_received", (event, ctx) => {
+      mergeConfig(event, ctx);
+      hooks.onMessageReceived(event, ctx);
+    });
+
+    api.on("before_prompt_build", () => {
+      let appendStr = "【全局强制约束】如果出现调用技能(skill)或工具执行报错、异常时，请务必主动调用 report_skill_error 这个工具，将具体的错误信息、工具名称等进行上报记录。\n";
+      
+      if (sessionUpdatedSkills.size > 0) {
+        appendStr += `\n【系统环境实时通知】：在当前对话期间，以下技能已被更新或重装：[${Array.from(sessionUpdatedSkills).join(", ")}]。如果你之前调用它遇到了报错，请立即抛弃旧的经验，重新阅读它的说明并以最新结果为准！`;
+      }
+      return { appendSystemContext: appendStr.trim() };
+    });
+
+    api.on("before_tool_call", (event, ctx) => {
+      mergeConfig(event, ctx);
+      hooks.onBeforeToolCall(event, ctx);
+    });
+
+    api.on("after_tool_call", (event, ctx) => {
+      mergeConfig(event, ctx);
+      hooks.onAfterToolCall(event);
+    });
+
+    api.on("session_end", (_event, ctx) => {
+      hooks.onSessionEnd(ctx);
+    });
+
+    api.on("gateway_start", (event, ctx) => {
+      mergeConfig(event, ctx);
+      
+      // =========================================================
+      // 启动星型中枢长连接网络
+      // =========================================================
+      if (!wsClient) {
+        const currentConfig = getConfig();
+        
+        // 优先使用配置文件中的 pluginId，否则回退到 OS hostname
+        const uniqueGatewayId = currentConfig.pluginId || process.env.GATEWAY_ID || `gateway-${os.hostname()}`;
+        
+        // 智能推导 WebSocket 服务地址
+        let finalWsUrl = currentConfig.wsServerUrl || process.env.CENTRAL_WS_URL;
+        if (!finalWsUrl && currentConfig.platformBaseUrl) {
+          try {
+            const url = new URL(currentConfig.platformBaseUrl);
+            finalWsUrl = `${url.protocol === 'https:' ? 'wss:' : 'ws:'}//${url.host}/gateway/ws`;
+          } catch (e) {
+            // 容错处理
+            finalWsUrl = currentConfig.platformBaseUrl.replace(/^http/, 'ws').replace(/\/api\/?$/, '').replace(/\/$/, '') + '/gateway/ws';
+          }
+        }
+        if (!finalWsUrl) {
+          finalWsUrl = "wss://aishuo.co/gateway/ws";
+        }
+        
+        wsClient = new GatewayWsClient({
+          serverUrl: finalWsUrl,
+          gatewayId: uniqueGatewayId,
+          authToken: currentConfig.authToken, // 从 openclaw.json 的 config 节点动态读取鉴权 token
+          updater: updater,
+          enableFileLog: currentConfig.enableFileLog // 将日志开关透传给客户端模块
+        });
+        wsClient.connect();
+      }
+      // =========================================================
+
+      // 启动即跑一次：先 load 缓存 → 本地对账（扫描+匹配配置）
+      void configSync
+        .load()
+        .then(() => configSync.reconcile())
+        .catch((err) => console.warn("[skill-logger-plugin] 启动初始化异常", err));
+      reporter.startTimer();
+      // 定时器①：本地扫描对账，固定 3 分钟。
+      if (!reconcileTimer) {
+        reconcileTimer = setInterval(() => void configSync.reconcile(), RECONCILE_INTERVAL_MS);
+        if (typeof reconcileTimer.unref === "function") reconcileTimer.unref();
+      }
+    });
+
+    api.on("gateway_stop", async () => {
+      // 停止时销毁连接
+      if (wsClient) { 
+        wsClient.destroy(); 
+        wsClient = undefined; 
+      }
+      
+      if (reconcileTimer) {
+        clearInterval(reconcileTimer);
+        reconcileTimer = undefined;
+      }
+      await hooks.flushAllPending();
+      await reporter.stopTimer();
+    });
+
+    api.on("before_install", (event, ctx) => {
+      mergeConfig(event, ctx);
+      // 安装后立即对账拉取最新配置，不执行自动更新（由 WSS 指令统一控制更新动作）
+      void configSync
+        .reconcile()
+        .catch((err) => console.warn("[skill-logger-plugin] before_install 处理异常", err));
+    });
+  },
+};
+
+export default definition;

package/src/integration.test.ts

@@ -0,0 +1,119 @@
+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";
+import type { PluginConfig } from "./types.ts";
+
+const idHash = (code: string, version: string) =>
+  createHash("sha256").update(`${code} ${code} ${version}`).digest("hex");
+
+let dir: string;
+
+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: PluginConfig = { platformBaseUrl: "https://api", autoUpdateSkills: true };
+
+    // 服务端最新版本（随测试推进而变化），模拟「更新后平台版本=本地版本」的收敛。
+    let platformLatest = "2.0.0";
+
+    // ConfigSync 的 fetch：/skill_config/pull → 带 latestVersion
+    const csFetch = async (_url: string, _init?: any) => ({
+      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: string, init?: any) => {
+      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: string, destDir: string) => {
+      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 as any,
+      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: PluginConfig = { 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 as any,
+      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/src/matcher.test.ts

@@ -0,0 +1,170 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  buildIndex,
+  match,
+  parseFlags,
+  parseKeyValues,
+  pathEndsWith,
+  commandHead,
+  tokenize,
+} from "./matcher.ts";
+import type { SkillStandardConfig, ToolCall } from "./types.ts";
+
+const configs: SkillStandardConfig[] = [
+  {
+    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<string>();
+
+function exec(command: string): ToolCall {
+  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: SkillStandardConfig[] = [
+    { 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");
+  });
+});