pi-skill-evolve 0.0.0-stage → 0.1.2

package/extensions/skill-evolve/test/lock.test.ts

@@ -0,0 +1,138 @@
+/**
+ * 跨进程目录锁单测（零依赖，node --test）。
+ *
+ * 运行：
+ *   cd .pi/extensions/skill-evolve
+ *   node --experimental-strip-types --test test/lock.test.ts
+ *
+ * 覆盖三种回收判据（活 pid / 死 pid / 超时）+ 抢锁、忙等待、残锁回收。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { acquireLock, acquireLockSync, isPidAlive, lockDir, readOwnerSync, releaseLock, releaseLockSync, shouldReclaim, writeOwnerSync } from "../lib/lock.ts";
+
+const MAX = 20 * 60_000;
+const NOW = 1_760_000_000_000;
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-lock-"));
+}
+
+test("shouldReclaim：没有 owner.json 视为残锁", () => {
+  assert.equal(shouldReclaim(null, NOW, MAX), true);
+});
+
+test("shouldReclaim：pid 已死 → 立即回收，不看年龄（3 秒前才写的也回收）", () => {
+  assert.equal(shouldReclaim({ pid: 4242, ts: NOW - 3000 }, NOW, MAX, () => false), true);
+});
+
+test("shouldReclaim：pid 活着 → 永不回收，ts 再老也不回收（宁可阻塞不可抢锁）", () => {
+  assert.equal(shouldReclaim({ pid: 4242, ts: NOW - 1000 }, NOW, MAX, () => true), false);
+  assert.equal(shouldReclaim({ pid: 4242, ts: NOW - 2 * MAX }, NOW, MAX, () => true), false);
+  assert.equal(shouldReclaim({ pid: 4242, ts: NOW - 100 * MAX }, NOW, MAX, () => true), false);
+});
+
+test("shouldReclaim：owner 字段坏（pid 非法但 ts 可读）→ 才按年龄兜底", () => {
+  assert.equal(shouldReclaim({ pid: Number.NaN, ts: NOW - 2 * MAX }, NOW, MAX, () => true), true);
+  assert.equal(shouldReclaim({ pid: 0, ts: NOW - 2 * MAX }, NOW, MAX), true);
+  assert.equal(shouldReclaim({ pid: Number.NaN, ts: NOW - 1000 }, NOW, MAX, () => true), false);
+  assert.equal(shouldReclaim({ pid: Number.NaN, ts: Number.NaN }, NOW, MAX, () => true), true);
+});
+
+test("isPidAlive：当前进程活着，0 与负值直接判死", () => {
+  assert.equal(isPidAlive(process.pid), true);
+  assert.equal(isPidAlive(0), false);
+  assert.equal(isPidAlive(-1), false);
+});
+
+test("acquireLock：抢到后写 owner.json，第二次抢返回 busy，释放后可再抢", async () => {
+  const dir = tmpDir();
+  const first = await acquireLock({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW, sessionId: "s1" }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(first.ok, true);
+  const ownerFile = path.join(lockDir(dir), "owner.json");
+  assert.deepEqual(JSON.parse(fs.readFileSync(ownerFile, "utf8")), { pid: process.pid, ts: NOW, sessionId: "s1" });
+
+  const second = await acquireLock({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(second.ok, false);
+  assert.equal(second.why, "busy");
+  assert.equal(second.owner?.sessionId, "s1");
+
+  await releaseLock(dir);
+  assert.equal(fs.existsSync(lockDir(dir)), false);
+  const third = await acquireLock({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(third.ok, true);
+  await releaseLock(dir);
+});
+
+test("acquireLock：回收死 pid 残锁并成功抢到（不看年龄）", async () => {
+  const dir = tmpDir();
+  fs.mkdirSync(lockDir(dir), { recursive: true });
+  // 真跑一个 node 子进程拿它的 pid，退出后这个 pid 必然已死：模拟 kill -9 后留下的残锁
+  const deadPid = spawnSync(process.execPath, ["-e", ""]).pid ?? 0;
+  assert.equal(isPidAlive(deadPid), false);
+  // ts 就是 NOW（年龄为 0）也必须回收——这正是「派发后主进程立刻退出」的死锁场景
+  fs.writeFileSync(path.join(lockDir(dir), "owner.json"), JSON.stringify({ pid: deadPid, ts: NOW, sessionId: "dead" }), "utf8");
+  const logs: string[] = [];
+  const result = await acquireLock({
+    evolutionDir: dir,
+    owner: { pid: process.pid, ts: NOW },
+    maxRuntimeMs: MAX,
+    now: () => NOW,
+    log: (msg) => logs.push(msg),
+  });
+  assert.equal(result.ok, true);
+  assert.equal(logs.some((line) => line.includes("回收孤儿锁")), true);
+  await releaseLock(dir);
+});
+
+test("acquireLock：活 pid 的锁 ts 再老也不抢（宁可阻塞，不可抢正在跑的 run）", async () => {
+  const dir = tmpDir();
+  fs.mkdirSync(lockDir(dir), { recursive: true });
+  fs.writeFileSync(path.join(lockDir(dir), "owner.json"), JSON.stringify({ pid: process.pid, ts: NOW - 3 * MAX }), "utf8");
+  const result = await acquireLock({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.deepEqual([result.ok, result.why, result.owner?.pid], [false, "busy", process.pid]);
+  await releaseLock(dir);
+});
+
+test("releaseLock：目录不存在也当成功（幂等）", async () => {
+  const dir = tmpDir();
+  await releaseLock(dir);
+  assert.equal(fs.existsSync(lockDir(dir)), false);
+});
+
+test("acquireLockSync：同步抢锁、忙时让位、写 owner.json", () => {
+  const dir = tmpDir();
+  const first = acquireLockSync({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW, sessionId: "s1" }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(first.ok, true);
+  assert.deepEqual(readOwnerSync(lockDir(dir)), { pid: process.pid, ts: NOW, sessionId: "s1" });
+
+  const second = acquireLockSync({ evolutionDir: dir, owner: { pid: 999_999, ts: NOW, sessionId: "s2" }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(second.ok, false);
+  assert.equal(second.why, "busy");
+  assert.equal(second.owner?.pid, process.pid);
+  releaseLockSync(dir);
+  assert.equal(fs.existsSync(lockDir(dir)), false);
+});
+
+test("acquireLockSync：死 pid 的残锁会被回收后抢到", () => {
+  const dir = tmpDir();
+  fs.mkdirSync(lockDir(dir), { recursive: true });
+  fs.writeFileSync(path.join(lockDir(dir), "owner.json"), `${JSON.stringify({ pid: 999_999, ts: NOW, sessionId: "old" })}\n`);
+  const result = acquireLockSync({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW, sessionId: "s1" }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(result.ok, true);
+  assert.equal(readOwnerSync(lockDir(dir))?.sessionId, "s1");
+  releaseLockSync(dir);
+});
+
+test("writeOwnerSync：把持有者换成子进程 pid，供 status 与孤儿判定使用", () => {
+  const dir = tmpDir();
+  acquireLockSync({ evolutionDir: dir, owner: { pid: process.pid, ts: NOW, sessionId: "s1" }, maxRuntimeMs: MAX, now: () => NOW });
+  assert.equal(writeOwnerSync(dir, { pid: 4321, ts: NOW + 1, sessionId: "s1" }), true);
+  assert.deepEqual(readOwnerSync(lockDir(dir)), { pid: 4321, ts: NOW + 1, sessionId: "s1" });
+  releaseLockSync(dir);
+});

package/extensions/skill-evolve/test/logfile.test.ts

@@ -0,0 +1,85 @@
+/**
+ * 扩展日志落盘（用户 2026-11-08：「tui 的这些推送不看了，影响我」）：
+ * 默认只写 `.pi/evolution/logs/extension.log`，`PI_SKILL_EVOLVE_DEBUG=1` 才回显终端，超 1MB 轮转成 `.1`。
+ *
+ * 全部喂临时目录；console.log 用临时替换的假函数断言，不起任何子进程。
+ */
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import { LOG_MAX_BYTES, logFile, logLine } from "../lib/logfile.ts";
+
+function workspace(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-logfile-"));
+}
+
+/** 临时接管 console.log：返回调用记录与还原函数（测试之间不许互相污染） */
+function spyConsole(): { calls: string[]; restore: () => void } {
+  const original = console.log;
+  const calls: string[] = [];
+  console.log = (...args: unknown[]) => {
+    calls.push(args.map((arg) => String(arg)).join(" "));
+  };
+  return { calls, restore: () => (console.log = original) };
+}
+
+/** 环境变量按需设 / 删，并在 finally 里还原成测试前的样子 */
+function withDebugEnv(value: string | undefined, run: () => void): void {
+  const before = process.env.PI_SKILL_EVOLVE_DEBUG;
+  if (value === undefined) delete process.env.PI_SKILL_EVOLVE_DEBUG;
+  else process.env.PI_SKILL_EVOLVE_DEBUG = value;
+  try {
+    run();
+  } finally {
+    if (before === undefined) delete process.env.PI_SKILL_EVOLVE_DEBUG;
+    else process.env.PI_SKILL_EVOLVE_DEBUG = before;
+  }
+}
+
+test("logLine：自动建 logs/ 目录，一行一条带 ISO 时间戳", () => {
+  const dir = workspace();
+  withDebugEnv(undefined, () => logLine(dir, "[skill-evolve] 已派生复盘 pid 1", false));
+  const file = logFile(dir);
+  assert.equal(file, path.join(dir, "logs", "extension.log"));
+  const text = fs.readFileSync(file, "utf8");
+  assert.match(text, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z \[skill-evolve\] 已派生复盘 pid 1\n$/);
+});
+
+test("logLine：DEBUG 未设时一次都不调 console.log，但文件照写", () => {
+  const dir = workspace();
+  const spy = spyConsole();
+  try {
+    withDebugEnv(undefined, () => logLine(dir, "静默一行"));
+  } finally {
+    spy.restore();
+  }
+  assert.deepEqual(spy.calls, [], "默认零推送：终端不该出现任何一行");
+  assert.match(fs.readFileSync(logFile(dir), "utf8"), /静默一行/);
+});
+
+test("logLine：PI_SKILL_EVOLVE_DEBUG=1 时同时回显终端", () => {
+  const dir = workspace();
+  const spy = spyConsole();
+  try {
+    withDebugEnv("1", () => logLine(dir, "可见一行"));
+  } finally {
+    spy.restore();
+  }
+  assert.deepEqual(spy.calls, ["可见一行"]);
+  assert.match(fs.readFileSync(logFile(dir), "utf8"), /可见一行/);
+});
+
+test("logLine：单文件超 1MB 轮转成 .1，新文件只留新的一行", () => {
+  const dir = workspace();
+  const file = logFile(dir);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  // 刚好等于阈值不轮转，超一个字节才轮转：这里直接写 MAX+1
+  fs.writeFileSync(file, "x".repeat(LOG_MAX_BYTES + 1), "utf8");
+  withDebugEnv(undefined, () => logLine(dir, "轮转后的一行", false));
+  assert.equal(fs.statSync(`${file}.1`).size, LOG_MAX_BYTES + 1, "旧内容整体挪到 .1");
+  const current = fs.readFileSync(file, "utf8");
+  assert.equal(current.includes("xxxx"), false, "新文件里没有旧内容");
+  assert.match(current, /轮转后的一行/);
+});

package/extensions/skill-evolve/test/mechanical-wiring.test.ts

@@ -0,0 +1,217 @@
+/**
+ * 机械层的接线单测：settle 之后遥测里必须真的出现 attributed / conflict，
+ * 且派生 prompt 里带着「已机械归因」清单（复盘 agent 据此只做 F/G）。
+ *
+ * 运行：
+ *   cd .pi/extensions/skill-evolve
+ *   node --experimental-strip-types --test test/mechanical-wiring.test.ts
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { fakeSupervisorSpawn } from "./fake-review-spawn.ts";
+import { createEvolution } from "../lib/evolution.ts";
+import { directQueue, type TelemetryEvent, type TelemetrySkill } from "../lib/telemetry.ts";
+import type { SpawnedChild, SpawnLike } from "../lib/spawn-plan.ts";
+
+const TEMPLATE = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "prompts", "复盘.md");
+const NOW = 1_760_000_000_000;
+
+const RULES = {
+  version: 1,
+  rules: [
+    { id: "rg-over-find", level: "P0", pattern: "\\bgrep\\s+-[a-zA-Z]*r", expect: "用 rg", why: "实测 find 全盘 180s" },
+  ],
+};
+
+function skill(name: string, disabled = false): TelemetrySkill {
+  return { name, filePath: `/repo/.pi/skills/${name}/SKILL.md`, disabled, source: "project" };
+}
+
+/** 生产默认全关（clone 即静默）：这三个用例要验证采集，必须在夹具里显式打开 */
+function enableEvolution(dir: string): void {
+  fs.mkdirSync(path.join(dir, ".pi", "evolution"), { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, ".pi", "evolution", "config.json"),
+    `${JSON.stringify({ enabled: true, telemetry: true }, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+function readTelemetry(dir: string): TelemetryEvent[] {
+  const shard = path.join(dir, ".pi", "evolution", "telemetry");
+  let names: string[];
+  try {
+    names = fs.readdirSync(shard);
+  } catch {
+    return [];
+  }
+  const events: TelemetryEvent[] = [];
+  for (const name of names.sort()) {
+    for (const line of fs.readFileSync(path.join(shard, name), "utf8").split("\n")) {
+      if (line.trim().length > 0) events.push(JSON.parse(line));
+    }
+  }
+  return events;
+}
+
+class FakeChild {
+  readonly pid = process.pid;
+  unref(): void {}
+  once(): this {
+    return this;
+  }
+}
+
+test("settle 写 attributed + conflict，prompt 带上机械归因清单", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-wire-"));
+  enableEvolution(dir);
+  // 磁盘上真的放一个会命中硬禁令的技能，让 conflict 走真实扫描而不是桩
+  fs.mkdirSync(path.join(dir, ".pi/skills/alpha"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".pi/skills/alpha/SKILL.md"), "# alpha\n用 grep -r 搜全仓\n", "utf8");
+  fs.mkdirSync(path.join(dir, ".pi/evolution/rules"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".pi/evolution/rules/hard-rules.json"), JSON.stringify(RULES), "utf8");
+
+  const prompts: string[] = [];
+  // 技能 filePath 必须指向这个临时 cwd，否则 B 类的路径比较对不上（这正是它该做的事）
+  const at = (name: string): TelemetrySkill => ({
+    name,
+    filePath: path.join(dir, ".pi/skills", name, "SKILL.md"),
+    disabled: false,
+    source: "project",
+  });
+  const spawnFn: SpawnLike = (_bin, args) => {
+    prompts.push(args[args.length - 1]);
+    return new FakeChild() as unknown as SpawnedChild;
+  };
+  const evo = createEvolution({
+    cwd: dir,
+    promptTemplatePath: TEMPLATE,
+    queue: directQueue,
+    log: () => {},
+    now: () => NOW,
+    env: {},
+    spawnFn,
+    supervisorSpawnFn: fakeSupervisorSpawn([]),
+    // 注入发现结果：alpha 正常发现，beta 的 frontmatter 坏（诊断点名它）
+    loadSkills: () => ({
+      skills: [{ name: "alpha", filePath: path.join(dir, ".pi/skills/alpha/SKILL.md") }],
+      diagnostics: [{ path: path.join(dir, ".pi/skills/beta/SKILL.md"), message: "缺少 description", type: "warning" }],
+    }),
+  });
+
+  evo.recordAdvertised({
+    sessionId: "s1",
+    cwd: dir,
+    prompt: "查一下技能",
+    skills: [at("alpha"), at("beta")],
+    activeTools: ["read", "bash"],
+  });
+  evo.settle({ sessionId: "s1" });
+  await new Promise((resolve) => setTimeout(resolve, 200));
+
+  const events = readTelemetry(dir);
+  const advertised = events.find((item) => item.kind === "advertised");
+  assert.deepEqual(advertised?.activeTools, ["read", "bash"], "activeTools 必须落进遥测，否则类 E 无据可依");
+
+  // directQueue 是直写（生产用 withFileMutationQueue 串行），事件落盘顺序不保证，所以按技能名排序比对
+  const attributed = events.filter((item) => item.kind === "attributed");
+  assert.deepEqual(
+    attributed.map((item) => [item.skill, item.category]).sort((a, b) => a[0].localeCompare(b[0])),
+    [
+      ["alpha", "semantic"],
+      ["beta", "B"],
+    ],
+  );
+  assert.ok(attributed.every((item) => typeof item.reason === "string" && item.reason.length > 0));
+
+  const conflicts = events.filter((item) => item.kind === "conflict");
+  assert.equal(conflicts.length, 1);
+  assert.equal(conflicts[0].ruleId, "rg-over-find");
+  assert.equal(conflicts[0].line, 2);
+  assert.equal(conflicts[0].level, "P0");
+  // 首次 settle 会自动 bootstrap 存量基线（把当时的命中当存量接受），所以这条标 stock
+  assert.equal(conflicts[0].stock, true);
+
+  assert.equal(prompts.length, 1);
+  assert.match(prompts[0], /已机械归因（2 条/);
+  assert.match(prompts[0], /B beta/);
+  assert.match(prompts[0], /只对上面没出现的技能做 F\/G 判定/);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test("同一冲突只记一次：两轮 settle 不重复刷同一条", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-wire2-"));
+  enableEvolution(dir);
+  fs.mkdirSync(path.join(dir, ".pi/skills/alpha"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".pi/skills/alpha/SKILL.md"), "# alpha\n用 grep -r 搜全仓\n", "utf8");
+  fs.mkdirSync(path.join(dir, ".pi/evolution/rules"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".pi/evolution/rules/hard-rules.json"), JSON.stringify(RULES), "utf8");
+
+  const evo = createEvolution({
+    cwd: dir,
+    promptTemplatePath: TEMPLATE,
+    queue: directQueue,
+    log: () => {},
+    now: () => NOW,
+    env: {},
+    spawnFn: () => new FakeChild() as unknown as SpawnedChild,
+    supervisorSpawnFn: fakeSupervisorSpawn([]),
+    loadSkills: () => ({ skills: [{ name: "alpha", filePath: path.join(dir, ".pi/skills/alpha/SKILL.md") }], diagnostics: [] }),
+  });
+
+  for (let round = 0; round < 2; round += 1) {
+    evo.recordAdvertised({ sessionId: "s1", cwd: dir, prompt: "再来一次", skills: [skill("alpha")], activeTools: ["read"] });
+    evo.settle({ sessionId: "s1" });
+  }
+  await new Promise((resolve) => setTimeout(resolve, 200));
+
+  const conflicts = readTelemetry(dir).filter((item) => item.kind === "conflict");
+  assert.equal(conflicts.length, 1);
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test("conflict 事件带 stock：基线里没有的命中标成新增（stock=false）", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-wire3-"));
+  enableEvolution(dir);
+  fs.mkdirSync(path.join(dir, ".pi/skills/alpha"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".pi/skills/alpha/SKILL.md"), "# alpha\n用 grep -r 搜全仓\n", "utf8");
+  fs.mkdirSync(path.join(dir, ".pi/evolution/rules"), { recursive: true });
+  fs.writeFileSync(path.join(dir, ".pi/evolution/rules/hard-rules.json"), JSON.stringify(RULES), "utf8");
+  // 预置一份「只含别的存量」的基线：alpha 这条不在其中，应判新增
+  fs.writeFileSync(
+    path.join(dir, ".pi/evolution/baseline.json"),
+    JSON.stringify({ version: 1, generatedAt: NOW, bootstrap: false, violations: [{ ruleId: "rg-over-find", level: "P0", skill: "other", line: 9, quote: "别的", fingerprint: "deadbeefdeadbeef" }] }),
+    "utf8",
+  );
+
+  const evo = createEvolution({
+    cwd: dir,
+    promptTemplatePath: TEMPLATE,
+    queue: directQueue,
+    log: () => {},
+    now: () => NOW,
+    env: {},
+    spawnFn: (() => new FakeChild() as unknown as SpawnedChild) as SpawnLike,
+    supervisorSpawnFn: fakeSupervisorSpawn([]),
+    loadSkills: () => ({ skills: [], diagnostics: [] }),
+  });
+  evo.recordAdvertised({
+    sessionId: "s1",
+    cwd: dir,
+    prompt: "查一下技能",
+    skills: [skill("alpha")],
+    activeTools: ["read", "bash"],
+  });
+  evo.settle({ sessionId: "s1" });
+  await new Promise((resolve) => setTimeout(resolve, 200));
+
+  const conflicts = readTelemetry(dir).filter((item) => item.kind === "conflict");
+  assert.equal(conflicts.length, 1);
+  assert.equal(conflicts[0].stock, false);
+  fs.rmSync(dir, { recursive: true, force: true });
+});

package/extensions/skill-evolve/test/metrics.test.ts

@@ -0,0 +1,129 @@
+/**
+ * M6 指标：按 ISO 周聚合、去重落盘、除零不算 NaN。
+ * 用例编号对应设计稿 14.2（趋势指标）与 5.1（metrics.jsonl）。
+ */
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import test from "node:test";
+import { appendMetrics, buildMetrics, isoWeek, metricsFile, readMetrics, rollbackRate } from "../lib/metrics.ts";
+import { directQueue, type TelemetryEvent } from "../lib/telemetry.ts";
+
+const DAY = 86_400_000;
+
+function ev(kind: TelemetryEvent["kind"], ts: number, extra: Record<string, unknown> = {}): TelemetryEvent {
+  return { kind, ts, iso: new Date(ts).toISOString(), ...extra };
+}
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-metrics-"));
+}
+
+test("isoWeek：UTC 周四分周，跨年边界不拆成两周", () => {
+  // 2026-01-01 是周四 → 属于 2026-W01
+  assert.equal(isoWeek(Date.UTC(2026, 0, 1)), "2026-W01");
+  // 2026-01-04（周日）仍属 2026-W01
+  assert.equal(isoWeek(Date.UTC(2026, 0, 4)), "2026-W01");
+  // 2026-01-05（周一）进入 2026-W02
+  assert.equal(isoWeek(Date.UTC(2026, 0, 5)), "2026-W02");
+  // 2025-12-29（周一）属 2026-W01：ISO 周跨年跟周四走
+  assert.equal(isoWeek(Date.UTC(2025, 11, 29)), "2026-W01");
+});
+
+test("buildMetrics：按周聚合曝光 / 加载 / 尝试失败 / 冲突 / 归因", () => {
+  const now = Date.UTC(2026, 10, 5, 9);
+  const events = [
+    ev("advertised", now, {
+      skills: [
+        { name: "a", filePath: "/a/SKILL.md", disabled: false, source: "project" },
+        { name: "b", filePath: "/b/SKILL.md", disabled: true, source: "project" },
+      ],
+    }),
+    ev("advertised", now - DAY, { skills: [{ name: "a", filePath: "/a/SKILL.md", disabled: false, source: "project" }] }),
+    ev("loaded", now, { skill: "a" }),
+    ev("failed", now, { skill: "a" }),
+    ev("conflict", now, { level: "P0", ruleId: "rg-over-find" }),
+    ev("conflict", now, { level: "P1", ruleId: "x" }),
+    ev("attributed", now, { skill: "a", category: "G" }),
+    ev("attributed", now, { skill: "a", category: "semantic" }),
+  ];
+  const rows = buildMetrics(events, now);
+  assert.equal(rows.length, 1);
+  const row = rows[0]!;
+  assert.equal(row.advertised, 2, "disabled 的技能不算曝光");
+  assert.equal(row.loaded, 1);
+  assert.equal(row.attemptedFailed, 1);
+  assert.equal(row.loadRate, 0.5);
+  assert.deepEqual(row.conflicts, { p0: 1, p1: 1 });
+  assert.equal(row.attribution.G, 1);
+  assert.equal(Object.values(row.attribution).reduce((sum, n) => sum + n, 0), 1, "semantic 不算 A~G 之一");
+});
+
+test("buildMetrics：空数据返回空数组，零曝光周不产生 NaN", () => {
+  assert.deepEqual(buildMetrics([], Date.now()), []);
+  const rows = buildMetrics([ev("missed", Date.UTC(2026, 10, 5), { skill: "a" })], Date.UTC(2026, 10, 5));
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0]!.loadRate, 0);
+  assert.ok(Number.isFinite(rows[0]!.loadRate));
+});
+
+test("buildMetrics：run 状态按派发日归周，提案 / 采纳 / 回滚分开数", () => {
+  const now = Date.UTC(2026, 10, 5);
+  const runs = [
+    { runId: "r1", status: "proposed", dispatchedAt: now },
+    { runId: "r2", status: "applied", dispatchedAt: now },
+    { runId: "r3", status: "rolled-back", dispatchedAt: now },
+    { runId: "r4", status: "skipped-before-dispatch", dispatchedAt: null },
+  ];
+  const row = buildMetrics([], now, runs)[0]!;
+  assert.equal(row.proposed, 3, "proposed / applied / rolled-back 都算走到过提案阶段");
+  assert.equal(row.applied, 1);
+  assert.equal(row.rolledBack, 1);
+});
+
+test("buildMetrics：多周按周升序返回", () => {
+  const now = Date.UTC(2026, 10, 20);
+  const rows = buildMetrics([ev("loaded", now), ev("loaded", now - 14 * DAY)], now);
+  assert.equal(rows.length, 2);
+  assert.ok(rows[0]!.week < rows[1]!.week);
+});
+
+test("appendMetrics：同 week + runId 只落一行（去重）", async () => {
+  const dir = tmpDir();
+  const now = Date.UTC(2026, 10, 5);
+  const week = isoWeek(now);
+  const row = { ...emptyRow(week, now) };
+  assert.equal(await appendMetrics(dir, row, directQueue), true);
+  assert.equal(await appendMetrics(dir, row, directQueue), false, "重复写同周汇总必须被跳过");
+  const single = { ...row, runId: "r1" };
+  assert.equal(await appendMetrics(dir, single, directQueue), true, "同周不同 runId 是另一行");
+  assert.equal(await appendMetrics(dir, single, directQueue), false);
+  assert.equal(readMetrics(dir).length, 2);
+  assert.equal(fs.readFileSync(metricsFile(dir), "utf8").trim().split("\n").length, 2);
+});
+
+test("rollbackRate：没有采纳样本返回 0，不返回 NaN", () => {
+  assert.equal(rollbackRate([]), 0);
+  const now = Date.now();
+  assert.equal(rollbackRate([emptyRow("2026-W45", now)]), 0);
+  const row = { ...emptyRow("2026-W45", now), applied: 4, rolledBack: 1 };
+  assert.equal(rollbackRate([row]), 0.25);
+});
+
+/** 造一行空指标：数值字段全零，避免各用例重复写字段 */
+function emptyRow(week: string, ts: number) {
+  return {
+    ts,
+    week,
+    advertised: 0,
+    loaded: 0,
+    attemptedFailed: 0,
+    loadRate: 0,
+    conflicts: { p0: 0, p1: 0 },
+    proposed: 0,
+    applied: 0,
+    rolledBack: 0,
+    attribution: { A: 0, B: 0, C: 0, D: 0, E: 0, F: 0, G: 0 },
+  };
+}

package/extensions/skill-evolve/test/model-config.test.ts

@@ -0,0 +1,84 @@
+/**
+ * 模型配置单测（设计稿 12.5）：值只有两种形态——`provider/model` 或 `inherit`。
+ * 非法值一律退 inherit 而不是让派发失败，这条兜底要有用例钉住。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  DEFAULT_MODEL_CONFIG,
+  INHERIT,
+  describeModelConfig,
+  loadModelConfig,
+  modelChoices,
+  normalizeModelSpec,
+  readModelConfig,
+  resolveModel,
+  saveModelSpec,
+  specFromChoice,
+} from "../lib/model-config.ts";
+import { directQueue } from "../lib/telemetry.ts";
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "sk-model-"));
+}
+
+test("合法 provider/model 原样保留，非法值退 inherit", () => {
+  assert.equal(normalizeModelSpec("deepseek/deepseek-v3.2"), "deepseek/deepseek-v3.2");
+  assert.equal(normalizeModelSpec(" openai/gpt-5:high "), "openai/gpt-5:high");
+  for (const bad of ["", "inherit", "no-slash", "/missing-provider", "provider/", 42, null, undefined]) {
+    assert.equal(normalizeModelSpec(bad), INHERIT, `非法值 ${String(bad)} 应退 inherit`);
+  }
+});
+
+test("readModelConfig 缺字段 / 坏结构都当 inherit", () => {
+  assert.deepEqual(readModelConfig(undefined), DEFAULT_MODEL_CONFIG);
+  assert.deepEqual(readModelConfig({ propose: "not-an-object", review: { model: 3 } }), { propose: INHERIT, review: INHERIT });
+  assert.deepEqual(readModelConfig({ propose: { model: "a/b" }, review: { model: "c/d" } }), { propose: "a/b", review: "c/d" });
+});
+
+test("loadModelConfig：配置文件不存在时不报错也不建文件", () => {
+  const dir = tmpDir();
+  assert.deepEqual(loadModelConfig(dir), DEFAULT_MODEL_CONFIG);
+  assert.equal(fs.existsSync(path.join(dir, "config.json")), false);
+});
+
+test("resolveModel：inherit 取主会话模型，显式值优先于主会话", () => {
+  const host = { model: { provider: "deepseek", id: "deepseek-v3.2" } };
+  assert.equal(resolveModel("review", DEFAULT_MODEL_CONFIG, host), "deepseek/deepseek-v3.2");
+  assert.equal(resolveModel("review", { propose: INHERIT, review: "openai/gpt-5" }, host), "openai/gpt-5");
+});
+
+test("resolveModel：主会话没模型时仍返回 inherit，不伪造成空串", () => {
+  assert.equal(resolveModel("propose", DEFAULT_MODEL_CONFIG, {}), INHERIT);
+  assert.equal(resolveModel("propose", DEFAULT_MODEL_CONFIG, { model: { provider: "x" } }), INHERIT);
+});
+
+test("选择项第一项是跟随主会话，回读能还原成 inherit", () => {
+  const choices = modelChoices([{ provider: "deepseek", id: "deepseek-v3.2" }, { provider: "only-provider" }]);
+  assert.equal(choices.length, 2, "缺 id 的模型不进候选");
+  assert.match(choices[0], /跟随主会话/);
+  assert.equal(specFromChoice(choices[0]), INHERIT);
+  assert.equal(specFromChoice(choices[1]), "deepseek/deepseek-v3.2");
+});
+
+test("saveModelSpec 只改目标键，其余配置原样保留", async () => {
+  const dir = tmpDir();
+  fs.writeFileSync(path.join(dir, "config.json"), JSON.stringify({ enabled: false, idleMs: 1000, review: { model: "old/x" } }), "utf8");
+  const next = await saveModelSpec(dir, "propose", "deepseek/deepseek-v3.2", directQueue);
+  assert.equal(next.propose, "deepseek/deepseek-v3.2");
+  assert.equal(next.review, "old/x");
+  const saved = JSON.parse(fs.readFileSync(path.join(dir, "config.json"), "utf8")) as Record<string, unknown>;
+  assert.equal(saved.enabled, false, "其他键不得被覆盖");
+  assert.equal(saved.idleMs, 1000);
+  assert.deepEqual(saved.propose, { model: "deepseek/deepseek-v3.2" });
+});
+
+test("saveModelSpec 写入非法值时落 inherit 而不是坏字符串", async () => {
+  const dir = tmpDir();
+  const next = await saveModelSpec(dir, "review", "随便写点什么", directQueue);
+  assert.equal(next.review, INHERIT);
+  assert.match(describeModelConfig(next), /跟随主会话/);
+});