@spzhongwin/skill-logger-plugin 1.0.2

package/src/matcher.ts

@@ -0,0 +1,393 @@
+/**
+ * 多策略匹配引擎（纯函数、无 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";
+import type {
+  ArgRule,
+  CommandMatchRule,
+  HttpMatchRule,
+  MatchResult,
+  ScriptMatchRule,
+  SkillStandardConfig,
+  ToolCall,
+  ToolMatchRule,
+  WherePredicate,
+} from "./types.ts";
+
+/** 索引里每个功能点附带其所属 skill 信息。 */
+type IndexedFn = {
+  skillName: string;
+  skillVersion: string;
+  functionId: string;
+  functionName: string;
+  rule: ScriptMatchRule | CommandMatchRule | ToolMatchRule | HttpMatchRule;
+  /** tool 规则的 toolNameRegex 预编译结果：RegExp 命中、null 表示编译失败、undefined 表示无正则。 */
+  compiledRegex?: RegExp | null;
+};
+
+export type MatchIndex = {
+  /** script：按脚本 basename 建桶。 */
+  scriptByBasename: Map<string, IndexedFn[]>;
+  /** command：按命令头建桶。 */
+  commandByHead: Map<string, IndexedFn[]>;
+  /** tool：精确 toolName 建桶。 */
+  toolByName: Map<string, IndexedFn[]>;
+  /** tool：前缀/正则规则（无法用精确 key 命中，逐个判定）。 */
+  toolFuzzy: IndexedFn[];
+  /** http：规则量少，整体扫描。 */
+  httpRules: IndexedFn[];
+};
+
+/** 已知解释器/包装前缀，用于在找「命令头」时跳过。 */
+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(): MatchIndex {
+  return {
+    scriptByBasename: new Map(),
+    commandByHead: new Map(),
+    toolByName: new Map(),
+    toolFuzzy: [],
+    httpRules: [],
+  };
+}
+
+function pushBucket(map: Map<string, IndexedFn[]>, key: string, fn: IndexedFn): void {
+  const arr = map.get(key);
+  if (arr) arr.push(fn);
+  else map.set(key, [fn]);
+}
+
+/** 把标准配置编译成可快速匹配的索引。 */
+export function buildIndex(configs: SkillStandardConfig[]): MatchIndex {
+  const index = emptyIndex();
+  for (const cfg of configs) {
+    for (const fn of cfg.functions) {
+      const indexed: IndexedFn = {
+        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: string): string[] {
+  const tokens: string[] = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(command)) !== null) {
+    tokens.push(m[1] ?? m[2] ?? m[3] ?? "");
+  }
+  return tokens;
+}
+
+/** 路径后缀匹配（按路径分隔对齐，避免 `xfoo.py` 误判 `foo.py`）。 */
+export function pathEndsWith(token: string, scriptRel: string): boolean {
+  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: string[]): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  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: ArgRule[] | undefined, flags: Record<string, unknown>): boolean {
+  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: string[]): string | undefined {
+  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: string[]): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  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: string): string | undefined {
+  const m = /https?:\/\/[^\s"'`]+/.exec(s);
+  return m ? m[0] : undefined;
+}
+
+/** 解析 URL 的 query 参数为对象。 */
+function parseQuery(url: string): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  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: string, rule: HttpMatchRule): boolean {
+  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: Record<string, unknown>, dotted: string): unknown {
+  let cur: unknown = obj;
+  for (const seg of dotted.split(".")) {
+    if (cur && typeof cur === "object" && seg in (cur as Record<string, unknown>)) {
+      cur = (cur as Record<string, unknown>)[seg];
+    } else {
+      return undefined;
+    }
+  }
+  return cur;
+}
+
+function whereMatches(where: WherePredicate[] | undefined, params: Record<string, unknown>): boolean {
+  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: IndexedFn, toolName: string): boolean {
+  const rule = f.rule as ToolMatchRule;
+  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: Record<string, unknown>): string | undefined {
+  for (const key of ["url", "endpoint", "uri", "href"]) {
+    const v = params[key];
+    if (typeof v === "string" && /^https?:\/\//.test(v)) return v;
+  }
+  return undefined;
+}
+
+type Candidate = { res: MatchResult; skillActive: boolean; strong: boolean };
+
+function toResult(f: IndexedFn, matchType: MatchResult["matchType"], args: Record<string, unknown>): MatchResult {
+  return {
+    skillName: f.skillName,
+    skillVersion: f.skillVersion,
+    functionId: f.functionId,
+    functionName: f.functionName,
+    matchType,
+    args,
+  };
+}
+
+/**
+ * 主匹配。命中返回 MatchResult；无自信命中返回 null。
+ * 多候选时优先归属到 `activeSkills`（本 session 已触发的 skill）以消歧。
+ */
+export function match(
+  call: ToolCall,
+  activeSkills: ReadonlySet<string>,
+  index: MatchIndex
+): MatchResult | null {
+  const candidates: Candidate[] = [];
+  const add = (res: MatchResult, 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 as ScriptMatchRule;
+        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 as CommandMatchRule;
+          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 as HttpMatchRule)) {
+            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 as ToolMatchRule;
+      if (whereMatches(rule.where, call.params)) add(toResult(f, "tool", { ...call.params }));
+    }
+    for (const f of index.toolFuzzy) {
+      const rule = f.rule as ToolMatchRule;
+      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 as HttpMatchRule)) {
+            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: Candidate) => (c.strong ? 2 : 0) + (c.skillActive ? 1 : 0);
+  eligible.sort((a, b) => rank(b) - rank(a));
+  return eligible[0].res;
+}

package/src/paths.test.ts

@@ -0,0 +1,57 @@
+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: string;
+
+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")));
+  });
+});

package/src/paths.ts

@@ -0,0 +1,84 @@
+/**
+ * 集中管理插件用到的所有文件系统路径。
+ *
+ * 为什么集中：① 单测可注入临时目录；② openclaw 安全策略下插件不读环境变量，
+ * 路径在此固定，运行时不依赖外部配置。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+/** 所有可注入路径的集合；不传时回落到 `~/.openclaw` 下的默认位置。 */
+export type PluginPaths = {
+  /** 事件日志队列：待上报事件追加写入；成功上报后清理已确认行。 */
+  eventsLogPath: string;
+  /** 配置同步状态：已装 skill 签名 + 缓存的标准配置。 */
+  syncStatePath: string;
+  /** 更新冷却期状态：skill@version → 上次尝试时间戳。 */
+  cooldownStatePath: string;
+  /** openclaw 扩展安装目录，用于扫描已装 skill。 */
+  extensionsDir: string;
+  /** openclaw 主配置文件路径（含 agents 列表），用于动态解析各 agent workspace 的 skills 目录。 */
+  openclawConfigPath: string;
+};
+
+/** 默认根目录 `~/.openclaw`。 */
+export function openclawHome(): string {
+  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: string, configPath: string): string[] {
+  const dirs = new Set<string>();
+  // 永远纳入的兜底目录（即便 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) as {
+      agents?: { defaults?: { workspace?: unknown }; list?: Array<{ workspace?: unknown }> };
+    };
+    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?: Partial<PluginPaths>): PluginPaths {
+  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/src/reporter.test.ts

@@ -0,0 +1,139 @@
+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 { Reporter } from "./reporter.ts";
+import type { PluginConfig, SkillEvent } from "./types.ts";
+
+const identityProvider = {
+  getIdentity: async () => ({ user_id: "", git_name: "n", git_email: "e", machine_id: "m" }),
+};
+
+function makeEvent(i: number): SkillEvent {
+  return { event_id: `id${i}`, event_type: "function_call", skill_name: "s", called_at: new Date().toISOString() };
+}
+
+let dir: string;
+let paths: { eventsLogPath: string };
+
+beforeEach(async () => {
+  dir = path.join(os.tmpdir(), `slp-reporter-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  await fs.mkdir(dir, { recursive: true });
+  paths = {
+    eventsLogPath: path.join(dir, "events.jsonl"),
+  };
+});
+
+afterEach(async () => {
+  await fs.rm(dir, { recursive: true, force: true });
+});
+
+/** 缺文件视为空，匹配轮转模型下「上报成功即删除」的形态。 */
+async function readEventsOrEmpty(p: string): Promise<string> {
+  try {
+    return await fs.readFile(p, "utf-8");
+  } catch {
+    return "";
+  }
+}
+
+/** 列出已轮转、待上报的日志文件（排除活跃的 events.jsonl）。 */
+async function listRotated(d: string): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(d);
+    return entries.filter((f) => f.startsWith("events.") && f.endsWith(".jsonl") && f !== "events.jsonl");
+  } catch {
+    return [];
+  }
+}
+
+describe("Reporter.appendEvent", () => {
+  it("目录自动创建并追加写", async () => {
+    const r = new Reporter({ paths, getConfig: () => ({}), identityProvider });
+    await r.appendEvent(makeEvent(1));
+    await r.appendEvent(makeEvent(2));
+    const lines = (await fs.readFile(paths.eventsLogPath, "utf-8")).trim().split("\n");
+    assert.equal(lines.length, 2);
+    assert.equal(JSON.parse(lines[1]).event_id, "id2");
+  });
+});
+
+describe("Reporter.flush", () => {
+  it("未配置 reportBaseUrl 时不上报", async () => {
+    let called = 0;
+    const r = new Reporter({
+      paths,
+      getConfig: () => ({}),
+      identityProvider,
+      fetchImpl: async () => {
+        called++;
+        return { ok: true, status: 200 };
+      },
+    });
+    await r.appendEvent(makeEvent(1));
+    await r.flush();
+    assert.equal(called, 0);
+  });
+
+  it("成功上报后清理本地日志，再次 flush 不重复发", async () => {
+    const sent: number[] = [];
+    const config: PluginConfig = { reportBaseUrl: "https://x" };
+    const r = new Reporter({
+      paths,
+      getConfig: () => config,
+      identityProvider,
+      fetchImpl: async (_url, init) => {
+        const body = JSON.parse(String(init.body));
+        sent.push(body.events.length);
+        return { ok: true, status: 200 };
+      },
+    });
+    await r.appendEvent(makeEvent(1));
+    await r.appendEvent(makeEvent(2));
+    await r.flush();
+    await r.flush(); // 无新事件
+    assert.deepEqual(sent, [2]);
+    // 轮转文件已全部上报并删除，活跃日志清空
+    assert.equal(await readEventsOrEmpty(paths.eventsLogPath), "");
+    assert.equal((await listRotated(dir)).length, 0);
+  });
+
+  it("保留 flush 期间新追加的事件（轮转隔离读写）", async () => {
+    let appendedDuringFlush = false;
+    const r = new Reporter({
+      paths,
+      getConfig: () => ({ reportBaseUrl: "https://x" }),
+      identityProvider,
+      fetchImpl: async () => {
+        if (!appendedDuringFlush) {
+          appendedDuringFlush = true;
+          await fs.appendFile(paths.eventsLogPath, JSON.stringify(makeEvent(2)) + "\n");
+        }
+        return { ok: true, status: 200 };
+      },
+    });
+    await r.appendEvent(makeEvent(1));
+    await r.flush();
+    const lines = (await readEventsOrEmpty(paths.eventsLogPath)).trim().split("\n").filter(Boolean);
+    assert.equal(lines.length, 1);
+    assert.equal(JSON.parse(lines[0]).event_id, "id2");
+  });
+
+  it("上报失败保留轮转文件，下轮重试成功后清空", async () => {
+    let ok = false;
+    const r = new Reporter({
+      paths,
+      getConfig: () => ({ reportBaseUrl: "https://x" }),
+      identityProvider,
+      fetchImpl: async () => ({ ok, status: ok ? 200 : 500 }),
+    });
+    await r.appendEvent(makeEvent(1));
+    await r.flush(); // 失败：轮转文件保留待重试
+    assert.equal((await listRotated(dir)).length, 1);
+    ok = true;
+    await r.flush(); // 成功：清空
+    assert.equal((await listRotated(dir)).length, 0);
+    assert.equal(await readEventsOrEmpty(paths.eventsLogPath), "");
+  });
+});