pi-skill-evolve 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,278 @@
+/**
+ * 五道闸单测（13.2）：逐闸失败各一条 + 成功路径 + 回滚逐字节还原。
+ *
+ * 全部在临时目录里跑：`.pi/skills` 只允许被测试的临时副本碰，真仓库一个字节都不动。
+ * git / md-check / commit 都是注入点，测试里绝不起真实子进程。
+ */
+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 { APPLIED_DIFF_FILE, VERIFY_FILE, appliedDiffFile, applyRun, readVerify, verifyFile } from "../lib/apply.ts";
+import type { GateDeps } from "../lib/apply-gates.ts";
+import { backupDir, cleanupBackups, runGates } from "../lib/apply-gates.ts";
+import { planTargets } from "../lib/apply-targets.ts";
+import { saveGate0 } from "../lib/gate0.ts";
+import type { QueueItem } 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";
+const DIFF = `--- a/${SKILL_REL}\n+++ b/${SKILL_REL}\n@@ -3,1 +3,1 @@\n-description: 演示技能\n+description: 演示技能（改后）\n`;
+
+interface Fixture {
+  cwd: string;
+  evolutionDir: string;
+  runDir: string;
+  skillAbs: string;
+}
+
+function setup(options: { type?: string; diff?: string; skillText?: string } = {}): Fixture {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-apply-"));
+  const evolutionDir = path.join(cwd, ".pi", "evolution");
+  const runDir = path.join(evolutionDir, "runs", "run-1");
+  const skillAbs = path.join(cwd, SKILL_REL);
+  fs.mkdirSync(path.dirname(skillAbs), { recursive: true });
+  fs.writeFileSync(skillAbs, options.skillText ?? SKILL_TEXT, "utf8");
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "02-proposal.json"), JSON.stringify({ type: options.type ?? "improve", skill: "demo" }), "utf8");
+  fs.writeFileSync(path.join(runDir, "02-proposal.diff"), options.diff ?? DIFF, "utf8");
+  return { cwd, evolutionDir, runDir, skillAbs };
+}
+
+function item(over: Partial<QueueItem> = {}): QueueItem {
+  return { runId: "run-1", level: "auto", skill: "demo", targets: [SKILL_REL], createdAt: NOW, status: "pending", proposalType: "improve", ...over };
+}
+
+/** git 假实现：默认干净（status / diff 都空串） */
+function fakeGit(status = "", diff = "") {
+  return (args: string[]) => ({ code: 0, out: args[0] === "status" ? status : diff });
+}
+
+function deps(fixture: Fixture, over: Partial<GateDeps> = {}): GateDeps {
+  return {
+    evolutionDir: fixture.evolutionDir,
+    cwd: fixture.cwd,
+    runId: "run-1",
+    queue: directQueue,
+    now: () => NOW,
+    log: () => {},
+    git: fakeGit(),
+    loadDiagnostics: () => [],
+    runMdCheck: () => ({ code: 0, output: "" }),
+    ...over,
+  };
+}
+
+async function seedGate0(fixture: Fixture, status = "", diff = ""): Promise<void> {
+  await saveGate0(fixture.evolutionDir, { at: NOW, status, diff }, directQueue);
+}
+
+test("成功路径：五闸全绿，文件真改成 after，05 与 06 都落盘", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const outcome = await applyRun(item(), deps(fixture));
+  assert.equal(outcome.status, "applied");
+  assert.deepEqual(outcome.gates.map((gate) => gate.gate), ["gate0", "gate1", "gate2", "gate3", "gate4"]);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT.replace("演示技能\n", "演示技能（改后）\n"));
+
+  const applied = fs.readFileSync(appliedDiffFile(fixture.runDir), "utf8");
+  assert.match(applied, /^\+\+\+ b\/\.pi\/skills\/demo\/SKILL\.md$/m);
+  assert.match(applied, /^\+description: 演示技能（改后）$/m);
+  const verify = readVerify(fixture.runDir);
+  assert.equal(verify?.status, "applied");
+  assert.equal(verify?.gates.length, 5);
+  assert.deepEqual(verify?.wrote, [SKILL_REL]);
+  assert.equal(fs.existsSync(verifyFile(fixture.runDir)), true);
+  assert.equal(APPLIED_DIFF_FILE, "05-applied.diff");
+  assert.equal(VERIFY_FILE, "06-verify.json");
+});
+
+test("闸1 把改动前的原文备份到 backups/<runId>/<相对路径>", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  await applyRun(item(), deps(fixture));
+  const backup = path.join(backupDir(fixture.evolutionDir, "run-1"), SKILL_REL);
+  assert.equal(fs.readFileSync(backup, "utf8"), SKILL_TEXT);
+});
+
+test("闸0 多出改动（会话起点后 .pi/skills 被改过）→ unauthorized_write，一个字节都不写", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const outcome = await applyRun(item(), deps(fixture, { git: fakeGit(" M .pi/skills/demo/SKILL.md") }));
+  assert.equal(outcome.status, "unauthorized_write");
+  assert.deepEqual(outcome.wrote, []);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+  assert.equal(fs.existsSync(appliedDiffFile(fixture.runDir)), false);
+  assert.match(outcome.detail ?? "", /闸0/);
+  assert.equal(readVerify(fixture.runDir)?.status, "unauthorized_write");
+});
+
+test("闸0 没有会话起点快照 → 同样拒采（宁可拒采，不赌）", async () => {
+  const fixture = setup();
+  const outcome = await applyRun(item(), deps(fixture));
+  assert.equal(outcome.status, "unauthorized_write");
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("闸1 备份写不进去（backups 路径被占成文件）→ failed，不写目标文件", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const blocker = backupDir(fixture.evolutionDir, "run-1");
+  fs.mkdirSync(path.dirname(blocker), { recursive: true });
+  fs.writeFileSync(blocker, "占位", "utf8");
+  const outcome = await applyRun(item(), deps(fixture));
+  assert.equal(outcome.status, "failed");
+  assert.match(outcome.detail ?? "", /闸1/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("闸2 原子写失败 → failed，磁盘内容不变（写入前 gate2 就抛，wrote 为空）", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const queue = async <T>(file: string, run: () => Promise<T>): Promise<T> => {
+    if (file === fixture.skillAbs) throw new Error("模拟磁盘忙");
+    return run();
+  };
+  const outcome = await applyRun(item(), deps(fixture, { queue }));
+  assert.equal(outcome.status, "failed");
+  assert.match(outcome.detail ?? "", /闸2/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("闸3 diagnostics 非空 → rolled-back，文件逐字节还原", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const before = fs.readFileSync(fixture.skillAbs);
+  const outcome = await applyRun(item(), deps(fixture, { loadDiagnostics: () => [{ path: SKILL_REL, message: "frontmatter 缺 description" }] }));
+  assert.equal(outcome.status, "rolled-back");
+  assert.match(outcome.detail ?? "", /diagnostics 非空/);
+  assert.deepEqual(fs.readFileSync(fixture.skillAbs), before);
+});
+
+test("闸3 md-check 退出码非 0 → rolled-back", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const outcome = await applyRun(item(), deps(fixture, { runMdCheck: () => ({ code: 2, output: "P1 标题层级跳级" }) }));
+  assert.equal(outcome.status, "rolled-back");
+  assert.match(outcome.detail ?? "", /md-check 失败/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("闸4 只提示「新会话生效」，不 reload", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const outcome = await applyRun(item(), deps(fixture));
+  const gate4 = outcome.gates.find((gate) => gate.gate === "gate4");
+  assert.equal(gate4?.ok, true);
+  assert.match(gate4?.detail ?? "", /新会话生效/);
+});
+
+test("auto 级 commit 失败 → 回滚该条（文件还原、状态 rolled-back）", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const outcome = await applyRun(item({ level: "auto" }), deps(fixture, { commit: () => ({ ok: false, detail: "hook 拒绝" }) }));
+  assert.equal(outcome.status, "rolled-back");
+  assert.match(outcome.detail ?? "", /commit 失败/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("auto 级 commit 成功 → outcome.commit 记短 hash", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const outcome = await applyRun(item({ level: "auto" }), deps(fixture, { commit: () => ({ ok: true, hash: "abc1234" }) }));
+  assert.equal(outcome.status, "applied");
+  assert.equal(outcome.commit, "abc1234");
+});
+
+test("approval 级即使给了 commit 也不调用（不自动提交）", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  let called = 0;
+  const outcome = await applyRun(item({ level: "approval" }), deps(fixture, { commit: () => { called += 1; return { ok: true, hash: "x" }; } }));
+  assert.equal(outcome.status, "applied");
+  assert.equal(called, 0);
+});
+
+test("新建技能缺引用面（无 .cursor stub / 无 AGENTS.md 索引行）→ 闸3 rolled-back 并删掉新文件", async () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-apply-create-"));
+  const evolutionDir = path.join(cwd, ".pi", "evolution");
+  const runDir = path.join(evolutionDir, "runs", "run-1");
+  const newRel = ".pi/skills/newbie/SKILL.md";
+  const candidate = "---\nname: newbie\ndescription: 新技能\n---\n\n正文\n";
+  fs.mkdirSync(path.join(runDir, "candidate", "newbie"), { recursive: true });
+  fs.writeFileSync(path.join(runDir, "02-proposal.json"), JSON.stringify({ type: "create", skill: "newbie" }), "utf8");
+  fs.writeFileSync(path.join(runDir, "02-proposal.diff"), `--- /dev/null\n+++ b/${newRel}\n@@ -0,0 +1,1 @@\n+占位\n`, "utf8");
+  fs.writeFileSync(path.join(runDir, "candidate", "newbie", "SKILL.md"), candidate, "utf8");
+  const fixture: Fixture = { cwd, evolutionDir, runDir, skillAbs: path.join(cwd, newRel) };
+  await seedGate0(fixture);
+  const outcome = await applyRun(item({ skill: "newbie", targets: [newRel], proposalType: "create" }), deps(fixture));
+  assert.equal(outcome.status, "rolled-back");
+  assert.match(outcome.detail ?? "", /引用面/);
+  assert.equal(fs.existsSync(path.join(cwd, newRel)), false);
+});
+
+test("提案目录不可用（无 02-proposal.json）→ failed 且不写盘", async () => {
+  const fixture = setup();
+  fs.rmSync(path.join(fixture.runDir, "02-proposal.json"));
+  const outcome = await applyRun(item(), deps(fixture));
+  assert.equal(outcome.status, "failed");
+  assert.equal(outcome.gates.length, 0);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("planTargets 规划出 before / after，且 diff 应用不上时如实失败", async () => {
+  const fixture = setup();
+  const plan = planTargets(fixture.runDir, fixture.cwd);
+  assert.equal(plan.ok, true);
+  assert.equal(plan.targets[0]?.before, SKILL_TEXT);
+  assert.match(plan.targets[0]?.after ?? "", /改后/);
+
+  const broken = setup({ diff: `--- a/${SKILL_REL}\n+++ b/${SKILL_REL}\n@@ -3,1 +3,1 @@\n-description: 对不上\n+description: 新\n` });
+  const failed = planTargets(broken.runDir, broken.cwd);
+  assert.equal(failed.ok, false);
+  assert.match(failed.reason ?? "", /不一致/);
+});
+
+test("排除删除提案：+++ /dev/null 不在这里执行（删技能必须走 --prune 人批）", async () => {
+  const fixture = setup({ diff: `--- a/${SKILL_REL}\n+++ /dev/null\n@@ -1,1 +0,0 @@\n-第一行\n` });
+  const plan = planTargets(fixture.runDir, fixture.cwd);
+  assert.equal(plan.ok, false);
+  assert.match(plan.reason ?? "", /--prune/);
+});
+
+test("runGates 备份清理只删超过 30 天的目录", () => {
+  const fixture = setup();
+  const root = path.join(fixture.evolutionDir, "backups");
+  const oldDir = path.join(root, "old");
+  const freshDir = path.join(root, "fresh");
+  fs.mkdirSync(oldDir, { recursive: true });
+  fs.mkdirSync(freshDir, { recursive: true });
+  const old = new Date(NOW - 40 * 86_400_000);
+  fs.utimesSync(oldDir, old, old);
+  const messages: string[] = [];
+  assert.equal(cleanupBackups(fixture.evolutionDir, NOW, (msg) => messages.push(msg)), 1);
+  assert.equal(fs.existsSync(oldDir), false);
+  assert.equal(fs.existsSync(freshDir), true);
+  assert.equal(messages.length, 1);
+});
+
+test("runGates 闸2 前会复核磁盘内容：中途被改过就拒写，不给别人覆盖", async () => {
+  const fixture = setup();
+  await seedGate0(fixture);
+  const queue = async <T>(file: string, run: () => Promise<T>): Promise<T> => {
+    // 备份阶段之后、写盘之前把文件改掉：模拟并发编辑
+    if (file.endsWith(SKILL_REL) && !fs.readFileSync(fixture.skillAbs, "utf8").includes("并发")) {
+      fs.writeFileSync(fixture.skillAbs, `${SKILL_TEXT}并发编辑\n`, "utf8");
+    }
+    return run();
+  };
+  const plan = planTargets(fixture.runDir, fixture.cwd);
+  assert.equal(plan.ok, true);
+  const run = await runGates(deps(fixture, { queue }), plan.targets);
+  assert.equal(run.ok, false);
+  assert.match(run.detail ?? "", /磁盘内容与计划不一致/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8").includes("并发编辑"), true);
+});

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

@@ -0,0 +1,248 @@
+/**
+ * 采纳胶水单测：扫 reviewed → 入队 → auto 自动应用 / approve 手动应用 / 队列文本。
+ *
+ * 全部临时目录 + 注入的 git/md-check/commit 假实现：不起任何真实子进程，
+ * 也不碰仓库里的 `.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 { gate0Path, readGate0, saveGate0 } from "../lib/gate0.ts";
+import { createApplyTools } from "../lib/evolution-apply.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";
+const AUTO_DIFF = `--- a/${SKILL_REL}\n+++ b/${SKILL_REL}\n@@ -3,1 +3,1 @@\n-description: 演示技能\n+description: 演示技能（改后）\n`;
+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;
+}
+
+function setup(): Fixture {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-approve-"));
+  const skillAbs = path.join(cwd, SKILL_REL);
+  fs.mkdirSync(path.dirname(skillAbs), { recursive: true });
+  fs.writeFileSync(skillAbs, SKILL_TEXT, "utf8");
+  return { cwd, evolutionDir: path.join(cwd, ".pi", "evolution"), skillAbs };
+}
+
+/** 造一个评审通过的 run：run.json status + 提案 json/diff */
+function seedRun(fixture: Fixture, runId: string, status: string, diffText = AUTO_DIFF, type = "improve"): string {
+  const runDir = path.join(fixture.evolutionDir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "run.json"), JSON.stringify({ runId, status, dispatchedAt: NOW }), "utf8");
+  fs.writeFileSync(path.join(runDir, "02-proposal.json"), JSON.stringify({ type, skill: "demo" }), "utf8");
+  fs.writeFileSync(path.join(runDir, "02-proposal.diff"), diffText, "utf8");
+  return runDir;
+}
+
+/** 闸0 需要会话起点快照：测试里直接写一份「干净」的，不去真跑 session_start */
+async function seedGate0(fixture: Fixture): Promise<void> {
+  await saveGate0(fixture.evolutionDir, { at: NOW, status: "", diff: "" }, directQueue);
+}
+
+function tools(fixture: Fixture, over: Partial<Parameters<typeof createApplyTools>[0]> = {}) {
+  return createApplyTools({
+    evolutionDir: fixture.evolutionDir,
+    cwd: fixture.cwd,
+    queue: directQueue,
+    now: () => NOW,
+    log: () => {},
+    git: (args: string[]) => ({ code: 0, out: args[0] === "status" ? "" : "" }),
+    loadDiagnostics: () => [],
+    runMdCheck: () => ({ code: 0, output: "" }),
+    ...over,
+  });
+}
+
+test("只给 reviewed 的 run 入队，级别由代码判（description 改动 → auto）", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-ok", "reviewed");
+  seedRun(fixture, "run-rejected", "rejected", BODY_DIFF);
+  const added = await tools(fixture).enqueueReady();
+  assert.equal(added, 1);
+  const queue = readQueue(fixture.evolutionDir);
+  assert.deepEqual(queue.map((item) => item.runId), ["run-ok"]);
+  assert.equal(queue[0]?.level, "auto");
+  assert.deepEqual(queue[0]?.targets, [SKILL_REL]);
+});
+
+test("正文改动 → approval 级入队（不自动写盘）", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-body", "reviewed", BODY_DIFF);
+  await tools(fixture).enqueueReady();
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.level, "approval");
+});
+
+test("路径越界的 run 判 forbidden：不入队并记日志", async () => {
+  const fixture = setup();
+  const badDiff = `--- a/.pi/skills/demo/notes.md\n+++ b/.pi/skills/demo/notes.md\n@@ -1,1 +1,1 @@\n-旧\n+新\n`;
+  seedRun(fixture, "run-bad", "reviewed", badDiff);
+  const logs: string[] = [];
+  const added = await tools(fixture, { log: (msg) => logs.push(msg) }).enqueueReady();
+  assert.equal(added, 0);
+  assert.deepEqual(readQueue(fixture.evolutionDir), []);
+  assert.match(logs.join("\n"), /forbidden/);
+});
+
+test("重复扫描幂等：第二次不再重复入队", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-ok", "reviewed");
+  const instance = tools(fixture);
+  assert.equal(await instance.enqueueReady(), 1);
+  assert.equal(await instance.enqueueReady(), 0);
+  assert.equal(readQueue(fixture.evolutionDir).length, 1);
+});
+
+test("session_start：写闸0 快照 + 自动应用 auto 条（改文件、队列 applied、run.json applied、04-decision）", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-ok", "reviewed");
+  tools(fixture).sessionStart();
+  for (let waited = 0; waited < 100 && readQueue(fixture.evolutionDir)[0]?.status !== "applied"; waited += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  assert.equal(fs.existsSync(gate0Path(fixture.evolutionDir)), true);
+  assert.equal(readGate0(fixture.evolutionDir)?.status, "");
+  assert.match(fs.readFileSync(fixture.skillAbs, "utf8"), /改后/);
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.status, "applied");
+  const runJson = JSON.parse(fs.readFileSync(path.join(fixture.evolutionDir, "runs", "run-ok", "run.json"), "utf8")) as { status: string };
+  assert.equal(runJson.status, "applied");
+  const decision = JSON.parse(fs.readFileSync(path.join(fixture.evolutionDir, "runs", "run-ok", "04-decision.json"), "utf8")) as { approver: string; level: string };
+  assert.equal(decision.approver, "auto");
+  assert.equal(decision.level, "auto");
+});
+
+test("approve：pending 的 approval 条走五道闸写盘，成功后队列 applied", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-body", "reviewed", BODY_DIFF);
+  const instance = tools(fixture);
+  instance.sessionStart();
+  await new Promise((resolve) => setTimeout(resolve, 30));
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.status, "pending");
+  const text = await instance.approve("run-body", false);
+  assert.match(text, /已采纳 run-body/);
+  assert.match(text, /gate0 授权核对/);
+  assert.match(fs.readFileSync(fixture.skillAbs, "utf8"), /再确认/);
+  assert.equal(readQueue(fixture.evolutionDir)[0]?.status, "applied");
+});
+
+test("approve 已 applied 的 run 幂等提示，不重复写盘", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-ok", "reviewed");
+  await seedGate0(fixture);
+  const instance = tools(fixture);
+  await instance.enqueueReady();
+  await instance.autoApplyPending();
+  const once = fs.readFileSync(fixture.skillAbs, "utf8");
+  const text = await instance.approve("run-ok", false);
+  assert.match(text, /已经应用过/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), once);
+});
+
+test("approve 队列里没有的 run：给出下一步提示，不动文件", async () => {
+  const fixture = setup();
+  const text = await tools(fixture).approve("run-404", false);
+  assert.match(text, /队列里没有 run-404/);
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});
+
+test("approve forbidden 条直接拒绝执行", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-fb", "reviewed", AUTO_DIFF);
+  // 正常路径根本不会把 forbidden 入队（enqueueReady 已拦），手工塞一条验证 approve 自己的兜底
+  fs.mkdirSync(fixture.evolutionDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(fixture.evolutionDir, "queue.json"),
+    JSON.stringify([{ runId: "run-fb", level: "forbidden", skill: "demo", targets: [SKILL_REL], createdAt: NOW, status: "pending" }]),
+    "utf8",
+  );
+  const text = await tools(fixture).approve("run-fb", false);
+  assert.match(text, /forbidden/);
+  assert.deepEqual(readQueue(fixture.evolutionDir).map((item) => item.runId), ["run-fb"]);
+});
+
+test("approve --prune：只出删技能清单，不真删", async () => {
+  const fixture = setup();
+  const runDir = seedRun(fixture, "run-prune", "reviewed", AUTO_DIFF, "prune");
+  fs.mkdirSync(path.join(fixture.cwd, ".cursor", "skills", "demo"), { recursive: true });
+  fs.writeFileSync(path.join(fixture.cwd, ".cursor", "skills", "demo", "SKILL.md"), "stub\n", "utf8");
+  fs.writeFileSync(path.join(fixture.cwd, "AGENTS.md"), "- `demo` —— `.pi/skills/demo/SKILL.md`\n", "utf8");
+  const text = await tools(fixture).approve("run-prune", true);
+  assert.match(text, /删技能待执行清单：demo/);
+  assert.match(text, /rm -rf \.pi\/skills\/demo\//);
+  assert.match(text, /\.dsh\/skills\/demo\/ 不动/);
+  // 一个字节都没真删
+  assert.equal(fs.existsSync(fixture.skillAbs), true);
+  assert.equal(fs.existsSync(path.join(fixture.cwd, ".cursor", "skills", "demo", "SKILL.md")), true);
+  assert.equal(fs.existsSync(path.join(runDir, "02-proposal.diff")), true);
+});
+
+test("queueText 分组列出 pending / applied 并给 pending 的 targets", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-body", "reviewed", BODY_DIFF);
+  const instance = tools(fixture);
+  await instance.enqueueReady();
+  const text = instance.queueText();
+  assert.match(text, /采纳队列：/);
+  assert.match(text, /pending 1 条/);
+  assert.match(text, /run-body\s+approval\s+demo/);
+  assert.match(text, /targets：\.pi\/skills\/demo\/SKILL\.md/);
+  assert.match(text, /approve <runId>/);
+});
+
+test("queueText 空队列给明确提示", () => {
+  const fixture = setup();
+  assert.match(tools(fixture).queueText(), /采纳队列为空/);
+});
+
+test("autoApplyPending 单条异常不拖垮整批：第一条失败第二条仍应用", async () => {
+  const fixture = setup();
+  const otherAbs = path.join(fixture.cwd, ".pi/skills/other/SKILL.md");
+  fs.mkdirSync(path.dirname(otherAbs), { recursive: true });
+  fs.writeFileSync(otherAbs, "---\nname: other\ndescription: 另一个\n---\n", "utf8");
+  seedRun(fixture, "run-a", "reviewed", AUTO_DIFF);
+  const otherDiff = `--- a/.pi/skills/other/SKILL.md\n+++ b/.pi/skills/other/SKILL.md\n@@ -3,1 +3,1 @@\n-description: 另一个\n+description: 另一个（改后）\n`;
+  const otherDir = path.join(fixture.evolutionDir, "runs", "run-b");
+  fs.mkdirSync(otherDir, { recursive: true });
+  fs.writeFileSync(path.join(otherDir, "run.json"), JSON.stringify({ runId: "run-b", status: "reviewed", dispatchedAt: NOW }), "utf8");
+  fs.writeFileSync(path.join(otherDir, "02-proposal.json"), JSON.stringify({ type: "improve", skill: "other" }), "utf8");
+  fs.writeFileSync(path.join(otherDir, "02-proposal.diff"), otherDiff, "utf8");
+  const queue = async <T>(file: string, run: () => Promise<T>): Promise<T> => {
+    if (file === fixture.skillAbs) throw new Error("模拟写失败");
+    return run();
+  };
+  await seedGate0(fixture);
+  const instance = tools(fixture, { queue });
+  await instance.enqueueReady();
+  const applied = await instance.autoApplyPending();
+  assert.equal(applied, 1);
+  assert.match(fs.readFileSync(otherAbs, "utf8"), /改后/);
+  const statuses = readQueue(fixture.evolutionDir).map((item) => `${item.runId}:${item.status}`).sort();
+  assert.deepEqual(statuses, ["run-a:failed", "run-b:applied"]);
+});
+
+test("同一技能有更早 pending 时，新 run 入队即 superseded 且不会被自动应用", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-body", "reviewed", BODY_DIFF);
+  const instance = tools(fixture);
+  await instance.enqueueReady();
+  // 再放一条同 skill 的 reviewed run（前一条还没处理）
+  const second = path.join(fixture.evolutionDir, "runs", "run-second");
+  fs.mkdirSync(second, { recursive: true });
+  fs.writeFileSync(path.join(second, "run.json"), JSON.stringify({ runId: "run-second", status: "reviewed" }), "utf8");
+  fs.writeFileSync(path.join(second, "02-proposal.json"), JSON.stringify({ type: "improve", skill: "demo" }), "utf8");
+  fs.writeFileSync(path.join(second, "02-proposal.diff"), AUTO_DIFF, "utf8");
+  await instance.enqueueReady();
+  const queue = readQueue(fixture.evolutionDir);
+  assert.equal(queue.find((item) => item.runId === "run-second")?.status, "superseded");
+  assert.equal(await instance.autoApplyPending(), 0); // 前一条是 approval，不等自动
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT);
+});

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

@@ -0,0 +1,133 @@
+/**
+ * G2 机械归因单测（零依赖，node --test）。
+ *
+ * 运行：
+ *   cd .pi/extensions/skill-evolve
+ *   node --experimental-strip-types --test test/attribution.test.ts
+ *
+ * 重点不是「每类能判出来」，而是**顺序**：A 与 E 同时成立必须判 A，E 与 semantic 同时成立必须判 E。
+ * 顺序错了会得到「建议改写 description」这种最误导人的结论。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { CATEGORY_ORDER, DISPOSITIONS, classifyMechanical, classifyOne, type AttributionInput } from "../lib/attribution.ts";
+
+const SKILLS = "/repo/.pi/skills";
+
+function base(overrides: Partial<AttributionInput> = {}): AttributionInput {
+  return {
+    missed: ["target"],
+    exposed: [{ name: "target", filePath: `${SKILLS}/target/SKILL.md` }],
+    loadedFromPi: [{ name: "target", filePath: `${SKILLS}/target/SKILL.md` }],
+    diagnostics: [],
+    activeTools: ["read", "bash", "edit"],
+    diskSkillNames: ["target"],
+    ...overrides,
+  };
+}
+
+test("A：disableModelInvocation=true", () => {
+  const input = base({ exposed: [{ name: "target", filePath: `${SKILLS}/target/SKILL.md`, disabled: true }] });
+  assert.equal(classifyOne("target", input).category, "A");
+});
+
+test("B：诊断里点到该技能的 file", () => {
+  const input = base({
+    diagnostics: [{ file: `${SKILLS}/target/SKILL.md`, message: "缺少 description", type: "warning" }],
+  });
+  assert.equal(classifyOne("target", input).category, "B");
+});
+
+test("B：诊断给的是相对路径也能对上（末端路径比较）", () => {
+  const input = base({ diagnostics: [{ file: ".pi/skills/target/SKILL.md", message: "YAML 解析失败" }] });
+  assert.equal(classifyOne("target", input).category, "B");
+});
+
+test("C：同名技能出现在两处", () => {
+  const input = base({
+    loadedFromPi: [
+      { name: "target", filePath: `${SKILLS}/target/SKILL.md` },
+      { name: "target", filePath: "/other/skills/target/SKILL.md" },
+    ],
+  });
+  assert.equal(classifyOne("target", input).category, "C");
+});
+
+test("C：collision 诊断点名也算（名字是子串时不误判）", () => {
+  const collision = base({
+    loadedFromPi: [],
+    diskSkillNames: [],
+    diagnostics: [{ file: "", message: "Skill name collision: target 与 target-extra 冲突", type: "collision" }],
+  });
+  assert.equal(classifyOne("target", collision).category, "C");
+  const unrelated = base({
+    loadedFromPi: [],
+    diskSkillNames: [],
+    diagnostics: [{ file: "", message: "Skill name collision: schema 与 schema-v2", type: "collision" }],
+  });
+  // "a" 不能命中 "schema" 里的那个 a：词边界判定
+  assert.equal(classifyOne("a", unrelated).category, "semantic");
+});
+
+test("D：磁盘上有目录但不在发现结果里", () => {
+  const input = base({ loadedFromPi: [], diskSkillNames: ["target", "other"] });
+  assert.equal(classifyOne("target", input).category, "D");
+});
+
+test("E：本轮 activeTools 既没 read 也没 bash", () => {
+  const input = base({ activeTools: ["edit", "write"] });
+  assert.equal(classifyOne("target", input).category, "E");
+});
+
+test("E：activeTools 为空表示没采到，不许判 E（退回 semantic）", () => {
+  assert.equal(classifyOne("target", base({ activeTools: [] })).category, "semantic");
+});
+
+test("都不命中 → semantic", () => {
+  assert.equal(classifyOne("target", base()).category, "semantic");
+});
+
+test("顺序：同时满足 A 与 E 时判 A", () => {
+  const input = base({
+    exposed: [{ name: "target", filePath: `${SKILLS}/target/SKILL.md`, disabled: true }],
+    activeTools: ["edit"],
+  });
+  assert.equal(classifyOne("target", input).category, "A");
+});
+
+test("顺序：同时满足 E 与 semantic 时判 E", () => {
+  assert.equal(classifyOne("target", base({ activeTools: ["edit"] })).category, "E");
+});
+
+test("顺序：同时满足 D 与 E 时判 D（范围问题比工具问题更根本）", () => {
+  const input = base({ loadedFromPi: [], activeTools: ["edit"] });
+  assert.equal(classifyOne("target", input).category, "D");
+});
+
+test("classifyMechanical 保持传入顺序，且每条都带 reason", () => {
+  const input = base({
+    missed: ["target", "second"],
+    exposed: [
+      { name: "target", filePath: `${SKILLS}/target/SKILL.md`, disabled: true },
+      { name: "second", filePath: `${SKILLS}/second/SKILL.md` },
+    ],
+    loadedFromPi: [
+      { name: "target", filePath: `${SKILLS}/target/SKILL.md` },
+      { name: "second", filePath: `${SKILLS}/second/SKILL.md` },
+    ],
+    diskSkillNames: ["target", "second"],
+  });
+  const result = classifyMechanical(input);
+  assert.deepEqual(result.map((item) => item.skill), ["target", "second"]);
+  assert.deepEqual(result.map((item) => item.category), ["A", "semantic"]);
+  assert.ok(result.every((item) => item.reason.length > 0));
+});
+
+test("六类都有展示标签，顺序固定 A~E → semantic", () => {
+  assert.deepEqual([...CATEGORY_ORDER], ["A", "B", "C", "D", "E", "semantic"]);
+  for (const category of CATEGORY_ORDER) {
+    assert.ok(DISPOSITIONS[category].label.length > 0);
+    assert.ok(DISPOSITIONS[category].action.length > 0);
+  }
+});