pi-skill-evolve 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,133 @@
+/**
+ * 会话送达：三类事件各发一条、同 runId 不重复、send 抛错不炸主流程、无 UI 时降级为日志。
+ */
+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 { collectNotifications, deliverNotifications, NOTIFIED_FILE } from "../lib/notify.ts";
+
+const NOW = Date.UTC(2026, 10, 8, 12);
+
+function workspace(): string {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-notify-"));
+  const evolutionDir = path.join(cwd, ".pi", "evolution");
+  fs.mkdirSync(path.join(evolutionDir, "runs"), { recursive: true });
+  return evolutionDir;
+}
+
+function writeRun(evolutionDir: string, runId: string, status: string): string {
+  const runDir = path.join(evolutionDir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  const record = { runId, status, dispatchedAt: NOW, sessionId: "s", trigger: "auto", pid: 1 };
+  fs.writeFileSync(path.join(runDir, "run.json"), JSON.stringify(record), "utf8");
+  return runDir;
+}
+
+function writeQueue(evolutionDir: string, items: Record<string, unknown>[]): void {
+  fs.writeFileSync(path.join(evolutionDir, "queue.json"), JSON.stringify(items), "utf8");
+}
+
+function item(runId: string, status: string, level: string, skill = "demo"): Record<string, unknown> {
+  return { runId, level, skill, targets: [`.pi/skills/${skill}/SKILL.md`], createdAt: NOW, status };
+}
+
+test("stale：一条消息，带原因与日志末行", () => {
+  const evolutionDir = workspace();
+  const runDir = writeRun(evolutionDir, "run-dead", "stale");
+  fs.writeFileSync(
+    path.join(runDir, "run-error.json"),
+    JSON.stringify({ reason: "timeout", at: NOW, childLogTail: ["准备中", "子进程 12 分钟没动静"] }),
+    "utf8",
+  );
+  const sent: string[] = [];
+  deliverNotifications({ evolutionDir, send: (text) => sent.push(text) });
+  assert.equal(sent.length, 1);
+  assert.match(sent[0]!, /^技能复盘失败：run-dead（超时）/);
+  assert.match(sent[0]!, /日志末行：子进程 12 分钟没动静/);
+  assert.equal(sent[0]!.split("\n").length, 2, "最多两行");
+});
+
+test("待批：一条消息，附采纳命令", () => {
+  const evolutionDir = workspace();
+  writeRun(evolutionDir, "run-wait", "reviewed");
+  writeQueue(evolutionDir, [item("run-wait", "pending", "approval", "rust")]);
+  const sent: string[] = [];
+  deliverNotifications({ evolutionDir, send: (text) => sent.push(text) });
+  assert.equal(sent.length, 1);
+  assert.match(sent[0]!, /^待批：run-wait 改动 rust/);
+  assert.match(sent[0]!, /\/skill-evolve approve run-wait/);
+});
+
+test("auto 采纳：一条消息，没有 diff", () => {
+  const evolutionDir = workspace();
+  writeRun(evolutionDir, "run-auto", "applied");
+  writeQueue(evolutionDir, [item("run-auto", "applied", "auto")]);
+  const sent: string[] = [];
+  deliverNotifications({ evolutionDir, send: (text) => sent.push(text) });
+  assert.deepEqual(sent, ["已自动采纳：run-auto（demo）"]);
+});
+
+test("去重：同一 runId 的同一类事件只发一次，跨调用也认（notified.json）", () => {
+  const evolutionDir = workspace();
+  writeRun(evolutionDir, "run-once", "stale");
+  const first: string[] = [];
+  const second: string[] = [];
+  assert.equal(deliverNotifications({ evolutionDir, now: NOW, send: (text) => first.push(text) }).length, 1);
+  assert.equal(deliverNotifications({ evolutionDir, now: NOW + 1, send: (text) => second.push(text) }).length, 0);
+  assert.equal(first.length, 1);
+  assert.deepEqual(second, []);
+  const notified = JSON.parse(fs.readFileSync(path.join(evolutionDir, "runs", "run-once", NOTIFIED_FILE), "utf8"));
+  assert.deepEqual(notified.kinds, ["stale"]);
+});
+
+test("send 抛错不炸主流程，且不记 notified（下一轮还能重试）", () => {
+  const evolutionDir = workspace();
+  writeRun(evolutionDir, "run-throw", "stale");
+  const logs: string[] = [];
+  const delivered = deliverNotifications({
+    evolutionDir,
+    send: () => {
+      throw new Error("no ui");
+    },
+    log: (msg) => logs.push(msg),
+  });
+  assert.deepEqual(delivered, [], "这条没送出去，不算已送达");
+  assert.equal(logs.length, 1);
+  assert.match(logs[0]!, /会话消息发送失败（run-throw）/);
+  assert.equal(fs.existsSync(path.join(evolutionDir, "runs", "run-throw", NOTIFIED_FILE)), false);
+
+  const retried: string[] = [];
+  assert.equal(deliverNotifications({ evolutionDir, send: (text) => retried.push(text) }).length, 1);
+  assert.equal(retried.length, 1, "重试成功");
+});
+
+test("拿不到 send（老版本 / 无 UI）：降级成日志，且不再重复刷", () => {
+  const evolutionDir = workspace();
+  writeRun(evolutionDir, "run-log", "stale");
+  const logs: string[] = [];
+  assert.equal(deliverNotifications({ evolutionDir, log: (msg) => logs.push(msg) }).length, 1);
+  assert.equal(logs.length, 1);
+  assert.match(logs[0]!, /技能复盘失败：run-log/, "多行文本压成一行");
+  assert.equal(logs[0]!.includes("\n"), false);
+  assert.equal(deliverNotifications({ evolutionDir, log: (msg) => logs.push(msg) }).length, 0);
+});
+
+test("队列里没有对应 run 目录的条目（手工塞的）不推送", () => {
+  const evolutionDir = workspace();
+  writeQueue(evolutionDir, [item("run-ghost", "pending", "approval")]);
+  assert.deepEqual(collectNotifications(evolutionDir), []);
+  const sent: string[] = [];
+  assert.deepEqual(deliverNotifications({ evolutionDir, send: (text) => sent.push(text) }), []);
+  assert.deepEqual(sent, []);
+});
+
+test("三类事件混在一起时各发一条，顺序稳定", () => {
+  const evolutionDir = workspace();
+  writeRun(evolutionDir, "run-mixed", "stale");
+  writeRun(evolutionDir, "run-ok", "applied");
+  writeQueue(evolutionDir, [item("run-ok", "applied", "auto")]);
+  const kinds = collectNotifications(evolutionDir).map((event) => `${event.runId}:${event.kind}`);
+  assert.deepEqual(kinds, ["run-mixed:stale", "run-ok:auto-applied"]);
+});

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

@@ -0,0 +1,100 @@
+/**
+ * M6 可观测胶水：面板刷新把状态变迁转成条目、派发立刻记一条、周报顺带落指标。
+ * 不 import pi 包，也不需要真子进程（周报在没有候选技能时不会去跑 rg）。
+ */
+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 { createObserver } from "../lib/evolution-observe.ts";
+import { metricsFile, readMetrics } from "../lib/metrics.ts";
+import { directQueue } from "../lib/telemetry.ts";
+
+const NOW = Date.UTC(2026, 10, 8, 12);
+
+function tmpWorkspace(): { cwd: string; evolutionDir: string; telemetryDir: string } {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-observe-"));
+  const evolutionDir = path.join(cwd, ".pi", "evolution");
+  fs.mkdirSync(path.join(cwd, ".pi", "skills", "demo"), { recursive: true });
+  fs.writeFileSync(path.join(cwd, ".pi", "skills", "demo", "SKILL.md"), "---\nname: demo\ndescription: 演示\n---\n", "utf8");
+  return { cwd, evolutionDir, telemetryDir: path.join(evolutionDir, "telemetry") };
+}
+
+function writeRun(evolutionDir: string, runId: string, status: string): void {
+  const runDir = path.join(evolutionDir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "run.json"), JSON.stringify({ runId, status, dispatchedAt: NOW, sessionId: "s" }), "utf8");
+}
+
+test("refresh：状态变迁发条目并推面板状态", () => {
+  const { evolutionDir, cwd, telemetryDir } = tmpWorkspace();
+  writeRun(evolutionDir, "r1", "reviewed");
+  writeRun(evolutionDir, "r2", "dispatched");
+  const entries: string[] = [];
+  const states: number[] = [];
+  const observer = createObserver({
+    cwd,
+    evolutionDir,
+    telemetryDir,
+    queue: directQueue,
+    now: () => NOW,
+    panel: {
+      onEntry: (entry) => entries.push(`${entry.kind}:${entry.runId}`),
+      onState: (state) => states.push(state.reviewing),
+    },
+  });
+  observer.refresh();
+  assert.deepEqual(entries, ["reviewed:r1"], "只有出了结论的 run 发条目");
+  assert.deepEqual(states, [1], "dispatched 的 run 算进行中");
+  observer.refresh();
+  assert.deepEqual(entries, ["reviewed:r1"], "重复刷新不重复发");
+});
+
+test("noteDispatched：派发立刻记一条，下一轮 refresh 不会重复记同一状态", () => {
+  const { evolutionDir, cwd, telemetryDir } = tmpWorkspace();
+  writeRun(evolutionDir, "r9", "dispatched");
+  const entries: string[] = [];
+  const observer = createObserver({
+    cwd,
+    evolutionDir,
+    telemetryDir,
+    queue: directQueue,
+    now: () => NOW,
+    panel: { onEntry: (entry) => entries.push(`${entry.kind}:${entry.runId}`) },
+  });
+  observer.noteDispatched("r9");
+  assert.deepEqual(entries, ["dispatched:r9"]);
+  observer.refresh();
+  assert.deepEqual(entries, ["dispatched:r9"]);
+});
+
+test("weekReportText：出周报并把当周指标落一行（重复调用不重复写）", async () => {
+  const { evolutionDir, cwd, telemetryDir } = tmpWorkspace();
+  fs.mkdirSync(telemetryDir, { recursive: true });
+  const line = {
+    ts: NOW,
+    iso: new Date(NOW).toISOString(),
+    kind: "advertised",
+    sessionId: "s",
+    skills: [{ name: "demo", filePath: "/x/demo/SKILL.md", disabled: false, source: "project" }],
+  };
+  fs.writeFileSync(path.join(telemetryDir, "2026-11-08.jsonl"), `${JSON.stringify(line)}\n`, "utf8");
+  const observer = createObserver({ cwd, evolutionDir, telemetryDir, queue: directQueue, now: () => NOW });
+  const first = await observer.weekReportText();
+  assert.match(first, /加载率 0\.0%（加载 0 \/ 曝光 1）/);
+  const rows = readMetrics(evolutionDir);
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0]!.advertised, 1);
+  await observer.weekReportText();
+  assert.equal(readMetrics(evolutionDir).length, 1, "同周同 runId 不重复写");
+  assert.equal(fs.existsSync(metricsFile(evolutionDir)), true);
+});
+
+test("weekReportText：没有任何遥测也不抛，报告写样本不足", async () => {
+  const { evolutionDir, cwd, telemetryDir } = tmpWorkspace();
+  const observer = createObserver({ cwd, evolutionDir, telemetryDir, queue: directQueue, now: () => NOW });
+  const text = await observer.weekReportText();
+  assert.match(text, /技能进化周报：2026-W45/);
+  assert.match(text, /候选表只是提醒，不是判决/);
+});

package/extensions/skill-evolve/test/panel-pid.test.ts

@@ -0,0 +1,84 @@
+/**
+ * 「谁持有 Web 面板」的记录文件（`.pi/evolution/locks/web.json`）：
+ * 坏数据当没有、写失败不抛、删记录要比 pid。只碰临时目录，不起任何子进程。
+ */
+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 { clearWebPid, isAlive, readWebPid, WEB_PID_FILE, webPidFile, writeWebPid } from "../lib/web/panel-pid.ts";
+
+function workspace(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-panelpid-"));
+}
+
+/** 不存在的 pid：Linux 的 pid_max 远小于 INT32_MAX，这个号系统里不会有进程 */
+const DEAD_PID = 2_147_483_646;
+
+function record(pid: number): { pid: number; host: string; port: number; url: string; startedAt: number } {
+  return { pid, host: "127.0.0.1", port: 7788, url: "http://127.0.0.1:7788", startedAt: 1_760_000_000_000 };
+}
+
+test("记录落在 locks/web.json：writeWebPid 建目录、原子写、能原样读回", () => {
+  const dir = workspace();
+  const info = record(process.pid);
+  writeWebPid(dir, info);
+  assert.equal(WEB_PID_FILE, path.join("locks", "web.json"));
+  assert.deepEqual(readWebPid(dir), info);
+  // 原子写的临时文件不能留在目录里
+  assert.deepEqual(fs.readdirSync(path.join(dir, "locks")), ["web.json"]);
+  assert.equal(fs.existsSync(`${webPidFile(dir)}.tmp`), false);
+});
+
+test("坏 JSON / 字段不全 / 不是对象 → readWebPid 一律 null", () => {
+  const dir = workspace();
+  const file = webPidFile(dir);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const good = record(process.pid);
+  const bad = [
+    "{ 不是 JSON",
+    "",
+    "[]",
+    "null",
+    JSON.stringify({ ...good, pid: 0 }),
+    JSON.stringify({ ...good, port: "7788" }),
+    JSON.stringify({ ...good, url: "" }),
+    JSON.stringify({ ...good, startedAt: "昨天" }),
+    JSON.stringify({ pid: good.pid, host: good.host }),
+  ];
+  for (const raw of bad) {
+    fs.writeFileSync(file, raw, "utf8");
+    assert.equal(readWebPid(dir), null, `坏数据必须当没有：${raw}`);
+  }
+  fs.unlinkSync(file);
+  assert.equal(readWebPid(dir), null, "文件不存在同样是 null");
+});
+
+test("isAlive：本进程算活，不存在的 pid / 非法 pid 算死", () => {
+  assert.equal(isAlive(process.pid), true);
+  assert.equal(isAlive(DEAD_PID), false);
+  assert.equal(isAlive(0), false);
+  assert.equal(isAlive(-1), false);
+});
+
+test("写记录失败只记日志不抛：locks 位置被文件占住时面板照常运行", () => {
+  const dir = workspace();
+  fs.writeFileSync(path.join(dir, "locks"), "占位", "utf8");
+  const logs: string[] = [];
+  assert.doesNotThrow(() => writeWebPid(dir, record(process.pid), (msg) => logs.push(msg)));
+  assert.equal(logs.length, 1);
+  assert.match(logs[0]!, /写 Web 面板记录失败/);
+});
+
+test("clearWebPid：pid 对上才删，别人的记录与读不出来的坏记录都留着", () => {
+  const dir = workspace();
+  writeWebPid(dir, record(4321));
+  clearWebPid(dir, process.pid);
+  assert.equal(readWebPid(dir)?.pid, 4321, "不是自己写的记录不能删");
+  clearWebPid(dir, 4321);
+  assert.equal(fs.existsSync(webPidFile(dir)), false);
+  fs.writeFileSync(webPidFile(dir), "{坏", "utf8");
+  clearWebPid(dir, process.pid);
+  assert.equal(fs.existsSync(webPidFile(dir)), true, "坏记录无法证明归属，也不清");
+});

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

@@ -0,0 +1,115 @@
+/**
+ * M6 面板：没数据不显示 0、状态栏只放最紧急一件、状态变迁只发一次 `/tree` 条目。
+ * 用例编号对应设计稿 14.1（四层可见性）。
+ */
+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 { collectPanelState, entryLines, panelWidget, statusEntries, statusLine } from "../lib/panel.ts";
+
+const NOW = Date.UTC(2026, 10, 8, 12);
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-panel-"));
+}
+
+function writeRun(dir: string, runId: string, status: string, dispatchedAt = NOW, extra: Record<string, unknown> = {}): void {
+  const runDir = path.join(dir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "run.json"), JSON.stringify({ runId, status, dispatchedAt, sessionId: "s", ...extra }), "utf8");
+}
+
+function writeQueue(dir: string, items: unknown[]): void {
+  fs.writeFileSync(path.join(dir, "queue.json"), JSON.stringify(items), "utf8");
+}
+
+test("panelWidget：全零返回 null，不显示「复盘 0 / 待批 0」", () => {
+  assert.equal(panelWidget({ reviewing: 0, staleCount: 0, pendingApprovals: 0, lastAppliedAt: null, rollbackRate: 0, appliedSamples: 0 }), null);
+});
+
+test("panelWidget：有哪项就拼哪项，缺项不占位", () => {
+  const state = { reviewing: 3, staleCount: 0, pendingApprovals: 0, lastAppliedAt: Date.UTC(2026, 10, 7), rollbackRate: 0, appliedSamples: 2 };
+  assert.deepEqual(panelWidget(state), ["复盘 3 / 上次采纳 11-07"]);
+  assert.deepEqual(panelWidget({ ...state, pendingApprovals: 2, reviewing: 0 }), ["待批 2 / 上次采纳 11-07"]);
+});
+
+test("statusLine：待批优先于回滚率告警，只显示一件事", () => {
+  const state = { reviewing: 4, staleCount: 0, pendingApprovals: 2, lastAppliedAt: NOW, rollbackRate: 0.5, appliedSamples: 10 };
+  assert.equal(statusLine(state), "待批 2");
+});
+
+test("statusLine：样本少于 5 次不下回滚率结论", () => {
+  assert.equal(statusLine({ reviewing: 0, staleCount: 0, pendingApprovals: 0, lastAppliedAt: NOW, rollbackRate: 0.4, appliedSamples: 4 }), null);
+});
+
+test("statusLine：样本够且超 5% 才告警（含建议关 auto）", () => {
+  const state = { reviewing: 1, staleCount: 0, pendingApprovals: 0, lastAppliedAt: NOW, rollbackRate: 0.06, appliedSamples: 6 };
+  assert.equal(statusLine(state), "回滚率 6% 超 5%，建议关 auto");
+  assert.equal(statusLine({ ...state, rollbackRate: 0.05 }), null, "正好 5% 不算「超」");
+});
+
+test("collectPanelState：进行中的 run 算「复盘」，待批只数 approval 级 pending", () => {
+  const dir = tmpDir();
+  writeRun(dir, "r1", "dispatched");
+  writeRun(dir, "r2", "proposed", NOW, { supervisorPid: 1 });
+  writeRun(dir, "r5", "proposed", NOW, { pid: 999999 });
+  writeRun(dir, "r3", "reviewed");
+  writeQueue(dir, [
+    { runId: "r3", level: "approval", skill: "a", targets: [], proposalType: "improve", status: "pending", createdAt: NOW },
+    { runId: "r4", level: "auto", skill: "b", targets: [], proposalType: "improve", status: "pending", createdAt: NOW },
+  ]);
+  const state = collectPanelState({ evolutionDir: dir, now: NOW, alive: (pid) => pid === 1 });
+  assert.equal(state.reviewing, 2, "dispatched 宽限期内 + 督导活着的 proposed 算；结论已出且进程不在的不算");
+  assert.equal(state.pendingApprovals, 1, "auto 条不等审批");
+});
+
+test("collectPanelState：上次采纳取 04-decision.json 的 at，采纳 / 回滚率按队列算", () => {
+  const dir = tmpDir();
+  const appliedAt = Date.UTC(2026, 10, 7, 8);
+  writeRun(dir, "r1", "applied");
+  fs.writeFileSync(path.join(dir, "runs", "r1", "04-decision.json"), JSON.stringify({ at: appliedAt }), "utf8");
+  writeRun(dir, "r2", "rolled-back");
+  writeQueue(dir, [
+    { runId: "r1", level: "approval", skill: "a", targets: [], proposalType: "improve", status: "applied", createdAt: NOW },
+    { runId: "r2", level: "approval", skill: "a", targets: [], proposalType: "improve", status: "rolled-back", createdAt: NOW },
+  ]);
+  const state = collectPanelState({ evolutionDir: dir, now: NOW });
+  assert.equal(state.lastAppliedAt, appliedAt);
+  assert.equal(state.appliedSamples, 2);
+  assert.equal(state.rollbackRate, 0.5);
+});
+
+test("statusEntries：同一状态只发一次，dispatched 由调用方单独记", () => {
+  const seen = new Map<string, string>();
+  const runs = [
+    { runId: "r1", status: "dispatched" },
+    { runId: "r2", status: "reviewed" },
+    { runId: "r3", status: "applied" },
+    { runId: "r4", status: "rolled-back" },
+    { runId: "r5", status: "rejected" },
+  ];
+  const first = statusEntries(runs, seen, NOW);
+  assert.deepEqual(
+    first.map((entry) => [entry.runId, entry.kind]),
+    [
+      ["r2", "reviewed"],
+      ["r3", "applied"],
+      ["r4", "rolled-back"],
+      ["r5", "reviewed"],
+    ],
+  );
+  assert.equal(first.find((entry) => entry.runId === "r5")?.detail, "rejected", "非 pass 的结论要带上原因");
+  assert.deepEqual(statusEntries(runs, seen, NOW), [], "同状态不重复发");
+  assert.deepEqual(
+    statusEntries([...runs, { runId: "r6", status: "applied" }], seen, NOW).map((entry) => entry.runId),
+    ["r6"],
+  );
+});
+
+test("entryLines：/tree 条目单行、带短日期与动作", () => {
+  const lines = entryLines({ kind: "applied", runId: "run-1", at: NOW, detail: "approval · a" });
+  assert.equal(lines.length, 1);
+  assert.match(lines[0]!, /\[skill-evolve\] 采纳 run-1 · 11-08 · approval · a/);
+});

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

@@ -0,0 +1,159 @@
+/**
+ * 提案解析与校验单测（设计稿 九、十）：正常 diff、超 40 行、越界路径、candidate frontmatter。
+ *
+ * 全部走临时 run 目录：校验函数本来就是「读盘 + 判定」，只测纯函数会漏掉 diff 文件名约定。
+ */
+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 {
+  MAX_DIFF_LINES,
+  parseUnifiedDiff,
+  readProposalSummary,
+  validateCandidate,
+  validateProposal,
+} from "../lib/proposal.ts";
+
+const DIFF_OK = [
+  "--- a/.pi/skills/deploy-test/SKILL.md",
+  "+++ b/.pi/skills/deploy-test/SKILL.md",
+  "@@ -1,4 +1,5 @@",
+  " name: deploy-test",
+  "-description: 老的描述",
+  "+description: 部署验收、验收清单、测服部署",
+  "+路由：部署验收",
+].join("\n");
+
+function runDir(files: Record<string, string>): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-proposal-"));
+  for (const [name, content] of Object.entries(files)) {
+    const file = path.join(dir, name);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, content, "utf8");
+  }
+  return dir;
+}
+
+function proposalJson(over: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    type: "improve",
+    skill: "deploy-test",
+    rationale: "description 缺「验收」路由词",
+    evidence: [1234],
+    diffFile: "02-proposal.diff",
+    ...over,
+  });
+}
+
+test("parseUnifiedDiff：统计增删行与文件路径", () => {
+  const parsed = parseUnifiedDiff(DIFF_OK);
+  assert.equal(parsed.ok, true);
+  assert.equal(parsed.added, 2);
+  assert.equal(parsed.removed, 1);
+  assert.deepEqual(parsed.files.map((item) => item.path), [".pi/skills/deploy-test/SKILL.md"]);
+  assert.equal(parsed.files[0].hunks, 1);
+});
+
+test("parseUnifiedDiff：空文本判空，不是 ok", () => {
+  const parsed = parseUnifiedDiff("");
+  assert.equal(parsed.ok, false);
+  assert.equal(parsed.reason, "empty");
+});
+
+test("validateProposal：正常 diff 判 ok 并带增删行数", () => {
+  const dir = runDir({ "02-proposal.json": proposalJson(), "02-proposal.diff": DIFF_OK });
+  const check = validateProposal(dir);
+  assert.equal(check.status, "ok");
+  assert.equal(check.type, "improve");
+  assert.equal(check.skill, "deploy-test");
+  assert.equal(check.added, 2);
+  assert.equal(check.removed, 1);
+  assert.equal(check.file, "02-proposal.diff");
+});
+
+test("validateProposal：没有 02-proposal.json 判 missing", () => {
+  const dir = runDir({});
+  assert.equal(validateProposal(dir).status, "missing");
+});
+
+test("validateProposal：增删超过 40 行判 too_large（不拒绝生成，标给人工）", () => {
+  const long = [
+    "--- a/.pi/skills/deploy-test/SKILL.md",
+    "+++ b/.pi/skills/deploy-test/SKILL.md",
+    "@@ -1,60 +1,60 @@",
+    ...Array.from({ length: MAX_DIFF_LINES }, (_, index) => `-旧行 ${index}`),
+    ...Array.from({ length: MAX_DIFF_LINES }, (_, index) => `+新行 ${index}`),
+  ].join("\n");
+  const dir = runDir({ "02-proposal.json": proposalJson(), "02-proposal.diff": long });
+  const check = validateProposal(dir);
+  assert.equal(check.status, "too_large");
+  assert.equal(check.added, MAX_DIFF_LINES);
+  assert.equal(check.removed, MAX_DIFF_LINES);
+  assert.match(check.detail, /转人工/);
+});
+
+test("validateProposal：diff 动了技能目录外的路径判 bad_path", () => {
+  const diff = [
+    "--- a/rust_server/src/x.rs",
+    "+++ b/rust_server/src/x.rs",
+    "@@ -1,1 +1,2 @@",
+    " fn main() {}",
+    "+// 顺手改一下",
+  ].join("\n");
+  const dir = runDir({ "02-proposal.json": proposalJson(), "02-proposal.diff": diff });
+  const check = validateProposal(dir);
+  assert.equal(check.status, "bad_path");
+  assert.match(check.detail, /rust_server\/src\/x\.rs/);
+});
+
+test("validateProposal：create 缺 candidate 目录判 invalid_candidate", () => {
+  const dir = runDir({ "02-proposal.json": proposalJson({ type: "create", skill: "deploy-check" }) });
+  const check = validateProposal(dir);
+  assert.equal(check.status, "invalid_candidate");
+  assert.match(check.detail, /缺 SKILL\.md/);
+});
+
+test("validateProposal：create 的 candidate 合规判 ok", () => {
+  const dir = runDir({
+    "02-proposal.json": proposalJson({ type: "create", skill: "deploy-check" }),
+    "candidate/deploy-check/SKILL.md": "---\nname: deploy-check\ndescription: 部署后逐项验收\n---\n\n正文\n",
+  });
+  const check = validateProposal(dir);
+  assert.equal(check.status, "ok");
+  assert.equal(check.file, "candidate/deploy-check/SKILL.md");
+});
+
+test("validateCandidate：name 不合规 / 缺 description / 与目录名不一致都判坏", () => {
+  const badName = runDir({ "SKILL.md": "---\nname: Deploy_Check\ndescription: x\n---\n" });
+  assert.match(validateCandidate(badName).detail, /name 不合规/);
+
+  const noDesc = runDir({ "SKILL.md": "---\nname: deploy-check\n---\n" });
+  assert.equal(validateCandidate(noDesc).ok, false);
+  assert.match(validateCandidate(noDesc).detail, /缺 description/);
+
+  const mismatch = runDir({ "SKILL.md": "---\nname: other-name\ndescription: x\n---\n" });
+  assert.match(validateCandidate(mismatch).detail, /不一致/);
+
+  const okDir = path.join(runDir({}), "deploy-check");
+  fs.mkdirSync(okDir, { recursive: true });
+  fs.writeFileSync(path.join(okDir, "SKILL.md"), "---\nname: deploy-check\ndescription: 部署后逐项验收\n---\n", "utf8");
+  const ok = validateCandidate(okDir);
+  assert.equal(ok.ok, true);
+  assert.equal(ok.name, "deploy-check");
+});
+
+test("readProposalSummary：没提案返回 undefined，有提案返回摘要（报告只显示不应用）", () => {
+  assert.equal(readProposalSummary(runDir({})), undefined);
+  const dir = runDir({ "02-proposal.json": proposalJson(), "02-proposal.diff": DIFF_OK });
+  const summary = readProposalSummary(dir);
+  assert.deepEqual(summary, {
+    type: "improve",
+    skill: "deploy-test",
+    status: "ok",
+    added: 2,
+    removed: 1,
+    file: "02-proposal.diff",
+  });
+});