pi-skill-evolve 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,110 @@
+/**
+ * 采纳队列单测：幂等、superseded 去重、并发入队不丢条目、坏文件容错。
+ *
+ * 用临时目录 + directQueue 跑真实 IO：这段逻辑的坑全在「文件里到底写了什么」。
+ */
+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 { enqueue, findItem, markDone, queueFile, readQueue, takePending } from "../lib/queue.ts";
+import { directQueue } from "../lib/telemetry.ts";
+
+const NOW = 1_760_000_000_000;
+
+function tempEvolutionDir(): string {
+  return path.join(fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-queue-")), ".pi", "evolution");
+}
+
+function deps(dir: string, at = NOW) {
+  return { evolutionDir: dir, queue: directQueue, now: () => at };
+}
+
+function input(runId: string, over: Partial<Parameters<typeof enqueue>[1]> = {}) {
+  return { runId, level: "approval" as const, skill: "deploy-test", targets: [".pi/skills/deploy-test/SKILL.md"], ...over };
+}
+
+test("首次入队是 pending，createdAt 用注入时间", async () => {
+  const dir = tempEvolutionDir();
+  const result = await enqueue(deps(dir), input("run-1"));
+  assert.equal(result.item.status, "pending");
+  assert.equal(result.item.createdAt, NOW);
+  assert.equal(result.supersededBy, undefined);
+  assert.equal(readQueue(dir).length, 1);
+});
+
+test("同一个 runId 重复入队幂等：条数不变、不刷 createdAt", async () => {
+  const dir = tempEvolutionDir();
+  await enqueue(deps(dir), input("run-1"));
+  const again = await enqueue(deps(dir, NOW + 5000), input("run-1"));
+  assert.equal(readQueue(dir).length, 1);
+  assert.equal(again.item.createdAt, NOW);
+});
+
+test("同一技能已有 pending 时，新条目直接 superseded 并指出被谁顶掉", async () => {
+  const dir = tempEvolutionDir();
+  await enqueue(deps(dir), input("run-1"));
+  const second = await enqueue(deps(dir, NOW + 1000), input("run-2"));
+  assert.equal(second.item.status, "superseded");
+  assert.equal(second.supersededBy, "run-1");
+  assert.match(second.item.detail ?? "", /run-1/);
+  // 前一条仍是 pending，takePending 只给它
+  assert.deepEqual(takePending(readQueue(dir)).map((item) => item.runId), ["run-1"]);
+});
+
+test("同一技能的前一条已 applied 后，新条目可以再成为 pending", async () => {
+  const dir = tempEvolutionDir();
+  await enqueue(deps(dir), input("run-1"));
+  await markDone(deps(dir), "run-1", "applied");
+  const second = await enqueue(deps(dir, NOW + 1000), input("run-2"));
+  assert.equal(second.item.status, "pending");
+});
+
+test("不同技能互不影响，takePending 按入队时间升序且可按级别过滤", async () => {
+  const dir = tempEvolutionDir();
+  await enqueue(deps(dir, NOW + 2000), input("run-late", { skill: "hard-rules" }));
+  await enqueue(deps(dir, NOW), input("run-early", { skill: "deploy-test", level: "auto" }));
+  assert.deepEqual(takePending(readQueue(dir)).map((item) => item.runId), ["run-early", "run-late"]);
+  assert.deepEqual(takePending(readQueue(dir), "auto").map((item) => item.runId), ["run-early"]);
+});
+
+test("并发入队不丢条目：两个 runId 同时写，队列里两条都在", async () => {
+  const dir = tempEvolutionDir();
+  await Promise.all([
+    enqueue(deps(dir), input("run-a", { skill: "skill-a" })),
+    enqueue(deps(dir), input("run-b", { skill: "skill-b" })),
+  ]);
+  assert.deepEqual(readQueue(dir).map((item) => item.runId).sort(), ["run-a", "run-b"]);
+});
+
+test("markDone 改状态并写 detail；找不到 runId 时返回 false 且不改文件", async () => {
+  const dir = tempEvolutionDir();
+  await enqueue(deps(dir), input("run-1"));
+  assert.equal(await markDone(deps(dir), "run-1", "applied", "五道闸全绿"), true);
+  const item = findItem(readQueue(dir), "run-1");
+  assert.equal(item?.status, "applied");
+  assert.equal(item?.detail, "五道闸全绿");
+  assert.equal(await markDone(deps(dir), "run-404", "failed"), false);
+  assert.equal(readQueue(dir).length, 1);
+});
+
+test("损坏文件容错：坏 JSON 当空队列，单条非法字段只丢那一条", async () => {
+  const dir = tempEvolutionDir();
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(queueFile(dir), "{不是 JSON", "utf8");
+  assert.deepEqual(readQueue(dir), []);
+  fs.writeFileSync(
+    queueFile(dir),
+    JSON.stringify([
+      { runId: "ok", level: "auto", skill: "s", targets: [], createdAt: NOW, status: "pending" },
+      { runId: "bad", level: "whatever", skill: "s", targets: [], createdAt: NOW, status: "pending" },
+    ]),
+    "utf8",
+  );
+  assert.deepEqual(readQueue(dir).map((item) => item.runId), ["ok"]);
+  // 坏文件之后仍能继续入队（不会被坏内容卡死）
+  const result = await enqueue(deps(dir), input("run-new", { skill: "other" }));
+  assert.equal(result.item.status, "pending");
+  assert.deepEqual(readQueue(dir).map((item) => item.runId).sort(), ["ok", "run-new"]);
+});

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

@@ -0,0 +1,134 @@
+/**
+ * 拒绝胶水单测：Web 面板「拒绝」只改状态，不碰技能文件。
+ *
+ * 走的是 index.ts 注入的同一条路径（createApplyTools(...).reject），
+ * 全部临时目录 + 注入的 git/md-check 假实现：不起任何真实子进程，也不碰仓库里的 `.pi/skills`。
+ */
+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 { createApplyTools } from "../lib/evolution-apply.ts";
+import { gate0Path, readGate0, saveGate0 } from "../lib/gate0.ts";
+import { readQueue } from "../lib/queue.ts";
+import { directQueue } from "../lib/telemetry.ts";
+
+const NOW = 1_760_000_000_000;
+const SKILL_REL = ".pi/skills/demo/SKILL.md";
+const SKILL_TEXT = "---\nname: demo\ndescription: 演示技能\n---\n\n## 步骤\n1. 先读文档\n";
+/** 正文改动 → approval 级：正是需要人批的那种提案 */
+const BODY_DIFF = `--- a/${SKILL_REL}\n+++ b/${SKILL_REL}\n@@ -7,1 +7,1 @@\n-1. 先读文档\n+1. 先读文档，再确认\n`;
+
+interface Fixture {
+  cwd: string;
+  evolutionDir: string;
+  skillAbs: string;
+  runDir: string;
+}
+
+function setup(runId = "run-body"): Fixture {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-reject-"));
+  const skillAbs = path.join(cwd, SKILL_REL);
+  fs.mkdirSync(path.dirname(skillAbs), { recursive: true });
+  fs.writeFileSync(skillAbs, SKILL_TEXT, "utf8");
+  const evolutionDir = path.join(cwd, ".pi", "evolution");
+  const runDir = path.join(evolutionDir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "run.json"), JSON.stringify({ runId, status: "reviewed", dispatchedAt: NOW }), "utf8");
+  fs.writeFileSync(path.join(runDir, "02-proposal.json"), JSON.stringify({ type: "improve", skill: "demo" }), "utf8");
+  fs.writeFileSync(path.join(runDir, "02-proposal.diff"), BODY_DIFF, "utf8");
+  return { cwd, evolutionDir, skillAbs, runDir };
+}
+
+function tools(fixture: Fixture) {
+  return createApplyTools({
+    evolutionDir: fixture.evolutionDir,
+    cwd: fixture.cwd,
+    queue: directQueue,
+    now: () => NOW,
+    log: () => {},
+    git: () => ({ code: 0, out: "" }),
+    loadDiagnostics: () => [],
+    runMdCheck: () => ({ code: 0, output: "" }),
+  });
+}
+
+async function seedQueue(fixture: Fixture): Promise<void> {
+  await saveGate0(fixture.evolutionDir, { at: NOW, status: "", diff: "" }, directQueue);
+  const added = await tools(fixture).enqueueReady();
+  assert.equal(added, 1, "前置条件：正文改动应入队成一条 approval");
+}
+
+function runStatus(fixture: Fixture): string {
+  return JSON.parse(fs.readFileSync(path.join(fixture.runDir, "run.json"), "utf8")).status as string;
+}
+
+test("reject：队列条目转 rejected，run.json 转 rejected，技能文件一字未动", async () => {
+  const fixture = setup();
+  await seedQueue(fixture);
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.level, "approval");
+
+  const text = await tools(fixture).reject("run-body");
+  assert.match(text, /已拒绝 run-body/);
+  assert.match(text, /技能文件未改动/);
+
+  const item = readQueue(fixture.evolutionDir)[0];
+  assert.equal(item?.status, "rejected");
+  assert.match(item?.detail ?? "", /人主动拒绝/);
+  assert.equal(runStatus(fixture), "rejected");
+  // 拒绝的核心承诺：技能文件一个字节都不变
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+  // 闸0 快照也不该被拒绝动作刷新
+  assert.equal((await readGate0(fixture.evolutionDir))?.at, NOW);
+  assert.equal(fs.existsSync(gate0Path(fixture.evolutionDir)), true);
+});
+
+test("reject：队列里没有这个 runId → 回人话，不动任何状态", async () => {
+  const fixture = setup();
+  await seedQueue(fixture);
+  const text = await tools(fixture).reject("run-nope");
+  assert.match(text, /队列里没有 run-nope/);
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.status, "pending");
+  assert.equal(runStatus(fixture), "reviewed");
+});
+
+test("reject：空 runId → 只回用法，不猜目标", async () => {
+  const fixture = setup();
+  await seedQueue(fixture);
+  const text = await tools(fixture).reject("");
+  assert.match(text, /用法/);
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.status, "pending");
+});
+
+test("reject：已 applied 的条目不能再拒绝（幂等不靠猜）", async () => {
+  const fixture = setup();
+  await seedQueue(fixture);
+  const queueFile = path.join(fixture.evolutionDir, "queue.json");
+  const items = JSON.parse(fs.readFileSync(queueFile, "utf8")) as Record<string, unknown>[];
+  items[0]!.status = "applied";
+  fs.writeFileSync(queueFile, JSON.stringify(items), "utf8");
+
+  const text = await tools(fixture).reject("run-body");
+  assert.match(text, /当前状态是 applied，只有 pending 能拒绝/);
+  assert.equal(runStatus(fixture), "reviewed", "run.json 保持评审通过，不被一次无效拒绝改写");
+});
+
+test("reject：run.json 丢了也能拒（队列先转 rejected，不留下永远 pending 的条目）", async () => {
+  const fixture = setup();
+  await seedQueue(fixture);
+  fs.rmSync(path.join(fixture.runDir, "run.json"));
+
+  const text = await tools(fixture).reject("run-body");
+  assert.match(text, /只改了队列状态/);
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.status, "rejected");
+});
+
+test("queueText：拒绝后条目归到 rejected 组，不再算待批", async () => {
+  const fixture = setup();
+  await seedQueue(fixture);
+  await tools(fixture).reject("run-body");
+  const text = await tools(fixture).queueText();
+  assert.match(text, /rejected 1 条/);
+  assert.equal(/pending 1 条/.test(text), false);
+});

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

@@ -0,0 +1,111 @@
+/**
+ * M6 端到端复演：六段状态齐全、产物落盘、评审不通过时停在评审段。
+ * 用例编号对应设计稿 15 章（M6 验收硬指标：整轮可复演）。
+ * 这里一律用假评审 + 假 git：测试里绝不起真子进程（真跑用 scripts/replay.ts --real）。
+ */
+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 { FAKE_REVIEW_TEXT } from "../lib/replay-fixture.ts";
+import { REPLAY_STAGES, runReplay } from "../lib/replay.ts";
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-replay-test-"));
+}
+
+const fakeGit = () => ({ code: 0, out: "" });
+
+test("复演：六段全通，run.json status 序列完整", async () => {
+  const dir = tmpDir();
+  const outcome = await runReplay({
+    cwd: dir,
+    evolutionDir: path.join(dir, ".pi", "evolution"),
+    fakeReview: true,
+    git: fakeGit,
+    now: () => Date.UTC(2026, 10, 8, 12),
+  });
+  assert.deepEqual(outcome.failures, []);
+  assert.equal(outcome.ok, true);
+  for (const stage of REPLAY_STAGES) {
+    assert.ok(!outcome.stages[stage].startsWith("未执行"), `${stage} 段必须真的执行过`);
+    assert.ok(!outcome.stages[stage].startsWith("失败"), `${stage} 段不应失败：${outcome.stages[stage]}`);
+  }
+  assert.deepEqual(outcome.statuses, ["dispatched", "analyzed", "proposed", "reviewed", "applied"]);
+  assert.equal(outcome.lines.length, 6);
+});
+
+test("复演：产物齐全（00-session / 提案 / 评审 / 决策 / 采纳 diff / 复验）", async () => {
+  const dir = tmpDir();
+  const outcome = await runReplay({
+    cwd: dir,
+    evolutionDir: path.join(dir, ".pi", "evolution"),
+    fakeReview: true,
+    git: fakeGit,
+    now: () => Date.UTC(2026, 10, 8, 12),
+  });
+  const runDir = path.join(dir, ".pi", "evolution", "runs", outcome.runId);
+  for (const file of [
+    "run.json",
+    "00-session/index.json",
+    "02-proposal.json",
+    "02-proposal.diff",
+    "03-review.json",
+    "04-decision.json",
+    "05-applied.diff",
+    "06-verify.json",
+  ]) {
+    assert.ok(fs.existsSync(path.join(runDir, file)), `${file} 必须存在`);
+  }
+  // 05 是真实落盘的 diff，06 里五道闸全 ok
+  assert.ok(fs.readFileSync(path.join(runDir, "05-applied.diff"), "utf8").includes("+"));
+  const verify = JSON.parse(fs.readFileSync(path.join(runDir, "06-verify.json"), "utf8")) as {
+    status: string;
+    gates: { gate: string; ok: boolean }[];
+  };
+  assert.equal(verify.status, "applied");
+  assert.equal(verify.gates.length, 5);
+  assert.ok(verify.gates.every((gate) => gate.ok));
+  // 技能文件真的被改了（复演的本质：碰了技能文件）
+  const skillText = fs.readFileSync(path.join(dir, ".pi", "skills", "replay-demo", "SKILL.md"), "utf8");
+  assert.match(skillText, /index\.json 再读会话原文/);
+  // 会话索引不含原文正文：只留 ≤80 字摘录
+  const index = JSON.parse(fs.readFileSync(path.join(runDir, "00-session", "index.json"), "utf8")) as {
+    lines: { excerpt: string }[];
+    stats: { lines: number; hasCompaction: boolean };
+  };
+  assert.ok(index.lines.length > 0);
+  assert.ok(index.lines.every((line) => line.excerpt.length <= 80));
+  assert.equal(index.stats.hasCompaction, false);
+});
+
+test("复演：评审 reject 时停在评审段，不改技能文件", async () => {
+  const dir = tmpDir();
+  const reject = JSON.stringify({
+    verdict: "reject",
+    blocking: [{ file: ".pi/skills/replay-demo/SKILL.md", line: 9, quote: "+- 复演时必须先看…", why: "新增条款与硬约束冲突" }],
+    evidence: [{ file: ".pi/skills/replay-demo/SKILL.md", line: 9, quote: "index.json" }],
+  });
+  const outcome = await runReplay({
+    cwd: dir,
+    evolutionDir: path.join(dir, ".pi", "evolution"),
+    fakeReview: true,
+    fakeReviewText: reject,
+    git: fakeGit,
+    now: () => Date.UTC(2026, 10, 8, 12),
+  });
+  assert.equal(outcome.ok, false);
+  assert.equal(outcome.failures.length, 1);
+  assert.match(outcome.failures[0]!, /^review：/);
+  assert.equal(outcome.stages.approve, "未执行");
+  const skillText = fs.readFileSync(path.join(dir, ".pi", "skills", "replay-demo", "SKILL.md"), "utf8");
+  assert.ok(!skillText.includes("index.json 再读会话原文"), "评审没过就不许动技能文件");
+});
+
+test("复演假评审文本本身要过字段校验，否则流水线验的是假结论", async () => {
+  const { postProcessReview } = await import("../lib/review-post.ts");
+  const result = postProcessReview(FAKE_REVIEW_TEXT);
+  assert.equal(result.status, "ok");
+  assert.equal(result.verdict, "pass");
+});

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

@@ -0,0 +1,66 @@
+/**
+ * status / report 文本单测：提案摘要只显示不应用，且没提案的 run 不该多出空行。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { renderReport, renderStatus } from "../lib/report.ts";
+import type { EvolutionConfig } from "../lib/config.ts";
+import { summarize } from "../lib/telemetry.ts";
+
+const CONFIG: EvolutionConfig = {
+  enabled: true,
+  idleMs: 90_000,
+  maxRuntimeMs: 1_200_000,
+  perSessionCap: 2,
+  telemetry: true,
+};
+
+const NOW = 1_760_000_000_000;
+
+test("status：run 列表带提案摘要（只显示，不应用）", () => {
+  const text = renderStatus({
+    config: CONFIG,
+    configPath: "/repo/.pi/evolution/config.json",
+    telemetryDir: "/repo/.pi/evolution/telemetry",
+    lockPid: undefined,
+    runs: [
+      {
+        runId: "abc12345-1",
+        status: "proposed",
+        dispatchedAt: NOW,
+        sessionId: "s1",
+        proposal: { type: "improve", skill: "deploy-test", status: "ok", added: 2, removed: 1, file: "02-proposal.diff" },
+      },
+      { runId: "abc12345-0", status: "analyzed", dispatchedAt: NOW - 1000, sessionId: "s1" },
+    ],
+  });
+  assert.match(text, /abc12345-1\s+proposed\s+.*提案 improve deploy-test \[ok\] \+2\/-1/);
+  assert.match(text, /abc12345-0\s+analyzed/);
+});
+
+test("report：有提案时多一句「不应用」说明，没提案时不出现", () => {
+  const summary = summarize([]);
+  const withProposal = renderReport({
+    days: 7,
+    summary,
+    runs: [
+      {
+        runId: "abc12345-1",
+        status: "proposed",
+        dispatchedAt: NOW,
+        sessionId: "s1",
+        proposal: { type: "create", skill: "deploy-check", status: "ok", added: 0, removed: 0, file: "candidate/deploy-check/SKILL.md" },
+      },
+    ],
+  });
+  assert.match(withProposal, /提案 create deploy-check \[ok\]/);
+  assert.match(withProposal, /提案只生成不应用/);
+
+  const withoutProposal = renderReport({
+    days: 7,
+    summary,
+    runs: [{ runId: "abc12345-0", status: "analyzed", dispatchedAt: NOW, sessionId: "s1" }],
+  });
+  assert.doesNotMatch(withoutProposal, /提案只生成不应用/);
+  assert.match(withoutProposal, /加载率：无曝光数据/);
+});

package/extensions/skill-evolve/test/review-post.test.ts

@@ -0,0 +1,92 @@
+/**
+ * 评审后处理单测（设计稿 12.3）：结构、证据、一致性一律代码判，不信 LLM 自觉。
+ * 每条用例对应「模型输出的一种坏法」，覆盖判 invalid / reject 的每一道关。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseReviewJson, postProcessReview } from "../lib/review-post.ts";
+
+const GOOD_PASS = JSON.stringify({ verdict: "pass", blocking: [], notes: "没问题" });
+const withBlocking = (verdict: string, evidence: unknown): string =>
+  JSON.stringify({ verdict, blocking: [{ issue: "有问题", evidence }], notes: "" });
+const EVIDENCE = { file: ".pi/skills/demo/SKILL.md", line: 12, quote: "允许用 find" };
+
+test("合法 pass 返回 ok", () => {
+  const result = postProcessReview(GOOD_PASS);
+  assert.equal(result.status, "ok");
+  assert.equal(result.verdict, "pass");
+  assert.deepEqual(result.blocking, []);
+});
+
+test("带 ```json 围栏与前后废话也能抠出 JSON", () => {
+  const text = `好的，结论如下：\n\`\`\`json\n${GOOD_PASS}\n\`\`\`\n以上。`;
+  assert.equal(parseReviewJson(text).json?.verdict, "pass");
+  assert.equal(postProcessReview(text).status, "ok");
+});
+
+test("坏 verdict 判 invalid：bad-verdict", () => {
+  for (const verdict of ["approved", "", 42, null]) {
+    const result = postProcessReview(JSON.stringify({ verdict, blocking: [] }));
+    assert.equal(result.status, "invalid");
+    assert.match(result.detail ?? "", /bad-verdict/);
+  }
+});
+
+test("根本不是 JSON 判 invalid：bad-json", () => {
+  const result = postProcessReview("我觉得还行，可以过。");
+  assert.equal(result.status, "invalid");
+  assert.match(result.detail ?? "", /bad-json/);
+});
+
+test("blocking 不是数组判 invalid", () => {
+  const result = postProcessReview(JSON.stringify({ verdict: "reject", blocking: "missing-evidence" }));
+  assert.equal(result.status, "invalid");
+  assert.match(result.detail ?? "", /bad-blocking/);
+});
+
+test("evidence 缺字段逐种判 invalid：file / line / quote", () => {
+  const cases: [unknown, RegExp][] = [
+    [{ line: 1, quote: "x" }, /evidence.file 为空/],
+    [{ file: ".pi/skills/demo/SKILL.md", quote: "x" }, /evidence.line 不是正整数/],
+    [{ file: ".pi/skills/demo/SKILL.md", line: 0, quote: "x" }, /evidence.line 不是正整数/],
+    [{ file: ".pi/skills/demo/SKILL.md", line: -3, quote: "x" }, /evidence.line 不是正整数/],
+    [{ file: ".pi/skills/demo/SKILL.md", line: 2.5, quote: "x" }, /evidence.line 不是正整数/],
+    [{ file: ".pi/skills/demo/SKILL.md", line: "12", quote: "x" }, /evidence.line 不是正整数/],
+    [{ file: ".pi/skills/demo/SKILL.md", line: 12, quote: "   " }, /evidence.quote 为空/],
+    [null, /evidence 不是对象/],
+  ];
+  for (const [evidence, pattern] of cases) {
+    const result = postProcessReview(withBlocking("reject", evidence));
+    assert.equal(result.status, "invalid", `evidence=${JSON.stringify(evidence)}`);
+    assert.match(result.detail ?? "", /missing-evidence/);
+    assert.match(result.detail ?? "", pattern);
+  }
+});
+
+test("pass 却带 blocking 判 invalid：contradiction", () => {
+  const result = postProcessReview(withBlocking("pass", EVIDENCE));
+  assert.equal(result.status, "invalid");
+  assert.match(result.detail ?? "", /contradiction/);
+  assert.equal(result.blocking.length, 1);
+});
+
+test("reject 带完整证据返回 ok 且保留 blocking/notes", () => {
+  const result = postProcessReview(JSON.stringify({ verdict: "reject", blocking: [{ issue: "引入 find", evidence: EVIDENCE }], notes: "违反 P0" }));
+  assert.equal(result.status, "ok");
+  assert.equal(result.verdict, "reject");
+  assert.equal(result.blocking[0].evidence.line, 12);
+  assert.equal(result.notes, "违反 P0");
+});
+
+test("机械复验失败一票 reject，覆盖 LLM 的 pass", () => {
+  const result = postProcessReview(GOOD_PASS, { recheck: () => "frontmatter 缺 name" });
+  assert.equal(result.status, "reject");
+  assert.equal(result.verdict, "reject");
+  assert.match(result.detail ?? "", /frontmatter-invalid: frontmatter 缺 name/);
+});
+
+test("机械复验通过时不影响 LLM 结论", () => {
+  const result = postProcessReview(GOOD_PASS, { recheck: () => null });
+  assert.equal(result.status, "ok");
+  assert.equal(result.verdict, "pass");
+});

package/extensions/skill-evolve/test/review-prompt.test.ts

@@ -0,0 +1,105 @@
+/**
+ * 评审 prompt 组装单测：独立性靠「给什么」保证，所以这里断言的是「没给什么」。
+ *
+ * 设计稿 12.1 硬约束②：只给改后全文 + diff + 硬禁令 + 验收标准，
+ * findings / rationale 一旦混进来，评审就会顺着提案者的话往下点头。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { ACCEPTANCE_STANDARDS, buildReviewPrompt } from "../lib/review-prompt.ts";
+
+const DIFF = [
+  "--- a/.pi/skills/demo/SKILL.md",
+  "+++ b/.pi/skills/demo/SKILL.md",
+  "@@ -3,1 +3,1 @@",
+  "-description: 处理各种事情",
+  "+description: 检索日志时用 rg，禁止 find 全盘扫",
+].join("\n");
+
+const SKILL_TEXT = ["---", "name: demo", "description: 检索日志时用 rg，禁止 find 全盘扫", "---", "正文"].join("\n");
+
+const RULES = [
+  { id: "rg-over-find", level: "P0", expect: "禁止用 find 全盘扫描" },
+  { id: "no-golden-midscene", level: "P0", expect: "不写 golden 截图" },
+];
+
+test("prompt 里不含复盘产物，也不含 rationale 字段", () => {
+  const prompt = buildReviewPrompt({
+    skillName: "demo",
+    skillText: SKILL_TEXT,
+    diffApplied: true,
+    diff: DIFF,
+    hardRules: RULES,
+  });
+  assert.ok(!prompt.includes("01-findings"), "不得出现 01-findings");
+  assert.ok(!prompt.includes("rationale"), "不得出现 rationale 字样");
+  assert.ok(!prompt.includes("02-proposal"), "不得出现 02-proposal 路径");
+});
+
+test("prompt 含全部硬禁令 ruleId 与 expect，且 diff 原样出现", () => {
+  const prompt = buildReviewPrompt({
+    skillName: "demo",
+    skillText: SKILL_TEXT,
+    diffApplied: true,
+    diff: DIFF,
+    hardRules: RULES,
+  });
+  for (const rule of RULES) {
+    assert.ok(prompt.includes(rule.id), `缺规则 ${rule.id}`);
+    assert.ok(prompt.includes(rule.expect), `缺规则说明 ${rule.id}`);
+  }
+  assert.ok(prompt.includes(DIFF), "diff 必须原样出现");
+  assert.ok(prompt.includes("rg-over-find") && prompt.includes("P0"));
+});
+
+test("验收标准四条全部写入 prompt", () => {
+  const prompt = buildReviewPrompt({
+    skillName: "demo",
+    skillText: SKILL_TEXT,
+    diffApplied: true,
+    diff: DIFF,
+    hardRules: RULES,
+  });
+  for (const line of ACCEPTANCE_STANDARDS) assert.ok(prompt.includes(line), `缺验收标准：${line}`);
+});
+
+test("apply 失败时明说「只有 diff 可信」，不冒充改后全文", () => {
+  const prompt = buildReviewPrompt({
+    skillName: "demo",
+    skillText: SKILL_TEXT,
+    diffApplied: false,
+    diff: DIFF,
+    hardRules: RULES,
+  });
+  assert.match(prompt, /改动前/);
+  assert.match(prompt, /只有上面的 diff 可信/);
+});
+
+test("CompiledRule 形态也能渲染出匹配模式", () => {
+  const prompt = buildReviewPrompt({
+    skillName: "demo",
+    skillText: SKILL_TEXT,
+    diffApplied: true,
+    diff: DIFF,
+    hardRules: [{ rule: { id: "rg-over-find", level: "P0", pattern: "\\bfind\\b", expect: "禁止 find" }, regex: /x/ }],
+  });
+  assert.ok(prompt.includes("rg-over-find"));
+  assert.ok(prompt.includes("\\bfind\\b"));
+});
+
+test("空禁令列表给出明确文案而不是留白", () => {
+  const prompt = buildReviewPrompt({
+    skillName: "demo",
+    skillText: SKILL_TEXT,
+    diffApplied: true,
+    diff: DIFF,
+    hardRules: [],
+  });
+  assert.match(prompt, /没有可注入的硬约束/);
+});
+
+test("verdict 语义写进 prompt：能改的小毛病不许判 reject（真实自检第一跑就栽在这）", () => {
+  const prompt = buildReviewPrompt({ skillName: "demo", skillText: "正文", diffApplied: true, diff: "+++ b/x\n", hardRules: [] });
+  assert.match(prompt, /revise：方向可以接受/);
+  assert.match(prompt, /reject：删掉了原有的明确禁止项/);
+});