pi-skill-evolve 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,81 @@
+/**
+ * 督导启动单测：这一层决定「用 execPath 而不是 pi」「带 --experimental-strip-types」
+ * 「env 里去掉 SKILL_EVOLVE_CHILD」三件事，接错任何一条都会让评审永远不启动。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { SUPERVISOR_SCRIPT, spawnReviewSupervisor } from "../lib/review-spawn.ts";
+
+function capture(): { calls: { command: string; args: string[]; options: Record<string, unknown> }[]; unrefs: number } {
+  return { calls: [], unrefs: 0 };
+}
+
+test("督导用 node + --experimental-strip-types 起，参数里带 runDir", () => {
+  const seen = capture();
+  const pid = spawnReviewSupervisor({
+    runDir: "/repo/.pi/evolution/runs/run-1",
+    cwd: "/repo",
+    env: {},
+    spawnFn: (command, args, options) => {
+      seen.calls.push({ command, args, options });
+      return {
+        pid: 4321,
+        unref: () => {
+          seen.unrefs += 1;
+        },
+      };
+    },
+  });
+  assert.equal(pid, 4321);
+  assert.equal(seen.calls[0].command, process.execPath);
+  assert.deepEqual(seen.calls[0].args, ["--experimental-strip-types", SUPERVISOR_SCRIPT, "/repo/.pi/evolution/runs/run-1"]);
+  assert.equal(seen.calls[0].options.detached, true);
+  assert.equal(seen.calls[0].options.stdio, "ignore");
+  assert.equal(seen.unrefs, 1, "必须 unref，否则主进程退出被拖住");
+  assert.equal(path.basename(SUPERVISOR_SCRIPT), "review-supervisor.ts");
+});
+
+test("inherit 不追加 --model，显式模型追加在 runDir 之后", () => {
+  const inheritArgs: string[][] = [];
+  const explicitArgs: string[][] = [];
+  const spawnFn = (command: string, args: string[], options: Record<string, unknown>) => {
+    inheritArgs.push(args);
+    explicitArgs.push(args);
+    return { pid: 1 };
+  };
+  spawnReviewSupervisor({ runDir: "/r", cwd: "/repo", env: {}, reviewModel: "inherit", spawnFn });
+  spawnReviewSupervisor({ runDir: "/r", cwd: "/repo", env: {}, reviewModel: "deepseek/deepseek-v3.2", spawnFn });
+  assert.deepEqual(inheritArgs[0], ["--experimental-strip-types", SUPERVISOR_SCRIPT, "/r"]);
+  assert.deepEqual(explicitArgs[1], ["--experimental-strip-types", SUPERVISOR_SCRIPT, "/r", "deepseek/deepseek-v3.2"]);
+});
+
+test("env 里去掉 SKILL_EVOLVE_CHILD，其他变量照旧带走", () => {
+  let env: NodeJS.ProcessEnv = {};
+  spawnReviewSupervisor({
+    runDir: "/r",
+    cwd: "/repo",
+    env: { SKILL_EVOLVE_CHILD: "1", PATH: "/usr/bin" },
+    spawnFn: (_command, _args, options) => {
+      env = options.env as NodeJS.ProcessEnv;
+      return { pid: 1 };
+    },
+  });
+  assert.equal(env.SKILL_EVOLVE_CHILD, undefined);
+  assert.equal(env.PATH, "/usr/bin");
+});
+
+test("起不来只记日志返回 null，不抛", () => {
+  const logs: string[] = [];
+  const pid = spawnReviewSupervisor({
+    runDir: "/r",
+    cwd: "/repo",
+    env: {},
+    log: (msg) => logs.push(msg),
+    spawnFn: () => {
+      throw new Error("EMFILE");
+    },
+  });
+  assert.equal(pid, null);
+  assert.match(logs.join("\n"), /启动失败/);
+});

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

@@ -0,0 +1,243 @@
+/**
+ * 评审督导单测（设计稿 12）：不真起 pi、不真等 900/300 秒。
+ *
+ * 覆盖四条最容易静默失败的路径：等提案超时、评审进程超时、invalid 重评、机械复验一票否决。
+ * 文件系统用内存 Map 替代，readText/writeText 都可注入。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { compileRules } from "../lib/hard-rules.ts";
+import { checkCandidateFrontmatter, parseProposal, runReviewSupervisor } from "../lib/review-supervisor.ts";
+import { fakeClock, fakeReviewSpawn, hangingReviewSpawn } from "./fake-review-spawn.ts";
+
+const RUN_DIR = "/repo/.pi/evolution/runs/run-1";
+const SKILL_FILE = "/repo/.pi/skills/demo/SKILL.md";
+const SKILL_TEXT = ["---", "name: demo", "description: 旧描述", "---", "", "检索一律用 rg，禁止 find。"].join("\n");
+const DESC_DIFF = [
+  "--- a/.pi/skills/demo/SKILL.md",
+  "+++ b/.pi/skills/demo/SKILL.md",
+  "@@ -3,1 +3,1 @@",
+  "-description: 旧描述",
+  "+description: 检索日志时用 rg，禁止 find 全盘扫",
+].join("\n");
+const PASS = JSON.stringify({ verdict: "pass", blocking: [], notes: "没问题" });
+const RUN_JSON = JSON.stringify({ runId: "run-1", status: "dispatched", cwd: "/repo", stages: [{ name: "analyze", model: "deepseek/flash", usage: {}, ms: 10 }] });
+/** 只放一条与仓库同形的 rg-over-find：用例不依赖 .pi/evolution/rules 文件是否在场 */
+const RULES = compileRules({
+  rules: [{ id: "rg-over-find", level: "P0", pattern: "\\bfind\\s+[.~/]", expect: "禁止 find 全盘扫", why: "慢" }],
+});
+
+function memFs(files: Record<string, string>) {
+  const store = new Map(Object.entries(files).map(([file, text]) => [path.resolve(file), text]));
+  return {
+    readText: (file: string) => store.get(path.resolve(file)),
+    writeText: (file: string, text: string) => {
+      store.set(path.resolve(file), text);
+    },
+    text: (file: string) => store.get(path.resolve(file)),
+    json: (file: string) => {
+      const raw = store.get(path.resolve(file));
+      return raw === undefined ? undefined : (JSON.parse(raw) as Record<string, unknown>);
+    },
+  };
+}
+
+function baseFiles(): Record<string, string> {
+  return {
+    [`${RUN_DIR}/run.json`]: RUN_JSON,
+    [`${RUN_DIR}/02-proposal.json`]: JSON.stringify({ type: "improve", skill: "demo", rationale: "理由不该进评审", evidence: [3], diffFile: "02-proposal.diff" }),
+    [`${RUN_DIR}/02-proposal.diff`]: DESC_DIFF,
+    [SKILL_FILE]: SKILL_TEXT,
+  };
+}
+
+test("正常路径：pass → reviewed，写 03-review.json/.md 并回写 run.json", async () => {
+  const fs = memFs(baseFiles());
+  const prompts: string[] = [];
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    reviewModel: "deepseek/flash",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    spawnFn: fakeReviewSpawn([PASS]),
+    pollMs: 1,
+    // 记下发给评审的 prompt，验证独立性（不给 rationale）
+    ...{},
+  });
+  assert.equal(outcome.status, "reviewed");
+  const review = fs.json(`${RUN_DIR}/03-review.json`) as Record<string, unknown>;
+  assert.equal(review.status, "reviewed");
+  assert.equal(review.verdict, "pass");
+  assert.equal(review.reviewerModel, "deepseek/flash");
+  assert.equal(review.proposerModel, "deepseek/flash");
+  assert.equal(review.sameModel, true);
+  assert.equal(review.action, "auto");
+  const md = fs.text(`${RUN_DIR}/03-review.md`) ?? "";
+  assert.ok(md.startsWith("> 同模型自评"), "同模型自评警告必须在首行");
+  const run = fs.json(`${RUN_DIR}/run.json`) as Record<string, unknown>;
+  assert.equal(run.status, "reviewed");
+  assert.deepEqual((run.review as Record<string, unknown>).sameModel, true);
+  assert.equal(prompts.length, 0);
+});
+
+test("评审 prompt 里不含提案 rationale", async () => {
+  const fs = memFs(baseFiles());
+  let captured = "";
+  const spawnFn = ((_cmd: string, args: string[]) => {
+    captured = args[3] ?? "";
+    return fakeReviewSpawn([PASS])(_cmd, args, {});
+  }) as unknown as Parameters<typeof runReviewSupervisor>[0]["spawnFn"];
+  await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    ...(spawnFn ? { spawnFn } : {}),
+    pollMs: 1,
+  });
+  assert.ok(captured.length > 0, "应当真的组装并传了 prompt");
+  assert.ok(!captured.includes("理由不该进评审"), "提案 rationale 不得进评审 prompt");
+  assert.ok(!captured.includes("01-findings"));
+});
+
+test("提案永不出现：900s 后写 skipped/proposal-timeout", async () => {
+  const fs = memFs({ [`${RUN_DIR}/run.json`]: RUN_JSON });
+  const clock = fakeClock();
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    now: clock.now,
+    sleep: clock.sleep,
+    pollMs: 2000,
+  });
+  assert.equal(outcome.status, "skipped");
+  const review = fs.json(`${RUN_DIR}/03-review.json`) as Record<string, unknown>;
+  assert.equal(review.status, "skipped");
+  assert.equal(review.reason, "proposal-timeout");
+  assert.ok(clock.elapsed() >= 900_000, `应当等满 900s，实际推进 ${clock.elapsed()}ms`);
+});
+
+test("提案文件是坏 JSON：skipped/proposal-unreadable", async () => {
+  const fs = memFs({ ...baseFiles(), [`${RUN_DIR}/02-proposal.json`]: "{坏掉的" });
+  const clock = fakeClock();
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    now: clock.now,
+    sleep: clock.sleep,
+  });
+  assert.equal(outcome.status, "skipped");
+  assert.equal((fs.json(`${RUN_DIR}/03-review.json`) as Record<string, unknown>).reason, "proposal-unreadable");
+});
+
+test("评审进程超时 300s → review_failed 且 kill 被调用", async () => {
+  const fs = memFs(baseFiles());
+  const clock = fakeClock();
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    spawnFn: hangingReviewSpawn(),
+    now: clock.now,
+    sleep: clock.sleep,
+    pollMs: 250,
+  });
+  assert.equal(outcome.status, "review_failed");
+  assert.match(outcome.record.detail ?? "", /review-timeout/);
+  assert.equal(outcome.record.attempts, 1, "超时不重试");
+});
+
+test("invalid 一次后重评成功：attempts=2 且 reviewed", async () => {
+  const fs = memFs(baseFiles());
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    spawnFn: fakeReviewSpawn([JSON.stringify({ verdict: "maybe", blocking: [] }), PASS]),
+    pollMs: 1,
+  });
+  assert.equal(outcome.status, "reviewed");
+  assert.equal(outcome.record.attempts, 2);
+});
+
+test("两次都 invalid → review_failed，run.json 也是 review_failed", async () => {
+  const fs = memFs(baseFiles());
+  const bad = JSON.stringify({ verdict: "maybe", blocking: [] });
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    readText: fs.readText,
+    writeText: fs.writeText,
+    spawnFn: fakeReviewSpawn([bad, bad]),
+    pollMs: 1,
+  });
+  assert.equal(outcome.status, "review_failed");
+  assert.equal(outcome.record.attempts, 2);
+  assert.match(outcome.record.detail ?? "", /bad-verdict/);
+  assert.equal((fs.json(`${RUN_DIR}/run.json`) as Record<string, unknown>).status, "review_failed");
+});
+
+test("机械复验：diff 新增 P0 命中时一票 reject（即使评审说 pass）", async () => {
+  const badDiff = [
+    "--- a/.pi/skills/demo/SKILL.md",
+    "+++ b/.pi/skills/demo/SKILL.md",
+    "@@ -6,1 +6,1 @@",
+    "-检索一律用 rg，禁止 find。",
+    "+找不到就 find . -name 文件名 全盘扫一遍。",
+  ].join("\n");
+  const fs = memFs({ ...baseFiles(), [`${RUN_DIR}/02-proposal.diff`]: badDiff });
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    rules: RULES,
+    readText: fs.readText,
+    writeText: fs.writeText,
+    spawnFn: fakeReviewSpawn([PASS]),
+    pollMs: 1,
+  });
+  assert.equal(outcome.status, "rejected");
+  assert.equal(outcome.record.verdict, "reject");
+  assert.match(outcome.record.detail ?? "", /frontmatter-invalid: 新增 P0 命中/);
+});
+
+test("create 提案：candidate frontmatter 缺 description → reject", async () => {
+  const candidate = ["---", "name: demo", "---", "正文"].join("\n");
+  const fs = memFs({
+    [`${RUN_DIR}/run.json`]: RUN_JSON,
+    [`${RUN_DIR}/02-proposal.json`]: JSON.stringify({ type: "create", skill: "demo", candidateFile: "candidate/demo/SKILL.md" }),
+    [`${RUN_DIR}/candidate/demo/SKILL.md`]: candidate,
+  });
+  const outcome = await runReviewSupervisor({
+    runDir: RUN_DIR,
+    evolutionDir: "/repo/.pi/evolution",
+    rules: RULES,
+    readText: fs.readText,
+    writeText: fs.writeText,
+    spawnFn: fakeReviewSpawn([PASS]),
+    pollMs: 1,
+  });
+  assert.equal(outcome.status, "rejected");
+  assert.match(outcome.record.detail ?? "", /frontmatter 缺 description/);
+  assert.equal(outcome.record.action, "approval");
+});
+
+test("parseProposal 只认真实字段，缺 type/skill 返回 undefined", () => {
+  assert.equal(parseProposal(undefined), undefined);
+  assert.equal(parseProposal("{}"), undefined);
+  assert.equal(parseProposal(JSON.stringify({ type: "improve", skill: "demo" }))?.skill, "demo");
+});
+
+test("checkCandidateFrontmatter 三种坏法都能识别", () => {
+  assert.equal(checkCandidateFrontmatter("没有 frontmatter"), "缺 frontmatter");
+  assert.equal(checkCandidateFrontmatter("---\ndescription: x\n---\n"), "frontmatter 缺 name");
+  assert.equal(checkCandidateFrontmatter("---\nname: x\n---\n"), "frontmatter 缺 description");
+  assert.equal(checkCandidateFrontmatter("---\nname: x\ndescription: y\n---\n"), null);
+});

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

@@ -0,0 +1,113 @@
+/**
+ * 必红自检单测（设计稿 12.4）：三个坏样本必须被拦住，任何一条被 pass 就算评审器不可信。
+ *
+ * 假 spawn 按 prompt 里的「技能名」回不同结论，所以用例不受 fixtures 目录枚举顺序影响。
+ */
+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 type { ReviewSpawn } from "../lib/review-run.ts";
+import { loadFixtures, renderSelftestReport, runSelftest, selftestFile, UNTRUSTED_NOTE } from "../lib/selftest.ts";
+import { FakeReviewChild } from "./fake-review-spawn.ts";
+
+const FIXTURES = fileURLToPath(new URL("../fixtures/selftest", import.meta.url));
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "sk-selftest-"));
+}
+
+/** 按 prompt 末尾的「技能名：x」挑结论 */
+function spawnBySkill(verdicts: Record<string, string>): ReviewSpawn {
+  return (_command, args) => {
+    const prompt = args[3] ?? "";
+    const skill = Object.keys(verdicts).find((name) => prompt.includes(`技能名：${name}`));
+    const reply = JSON.stringify({ verdict: skill ? verdicts[skill] : "pass", blocking: [], notes: "自检" });
+    const child = new FakeReviewChild();
+    setTimeout(() => {
+      child.stdout.emit("data", reply);
+      child.emit("exit", 0);
+    }, 1);
+    return child;
+  };
+}
+
+test("三个坏样本都能被读到，期望分别是 reject/reject/revise", () => {
+  const fixtures = loadFixtures(FIXTURES);
+  assert.deepEqual(fixtures.map((item) => item.name).sort(), ["delete-ban", "rg-to-find", "weak-description"]);
+  const expected = Object.fromEntries(fixtures.map((item) => [item.name, item.expected]));
+  assert.deepEqual(expected, { "delete-ban": "reject", "rg-to-find": "reject", "weak-description": "revise" });
+  for (const fixture of fixtures) {
+    assert.ok(fixture.diff.length > 0, `${fixture.name} 缺 diff`);
+    assert.ok(fixture.after.length > 0, `${fixture.name} 缺改后全文`);
+  }
+});
+
+test("三样本全部被正确拦住 → passed:true 并落盘 selftest.json", async () => {
+  const dir = tmpDir();
+  const report = await runSelftest({
+    evolutionDir: dir,
+    cwd: dir,
+    fixturesDir: FIXTURES,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "revise" }),
+    pollMs: 1,
+  });
+  assert.equal(report.passed, true);
+  assert.equal(report.results.length, 3);
+  assert.deepEqual(report.results.map((item) => item.actual), ["reject", "reject", "revise"]);
+  const saved = JSON.parse(fs.readFileSync(selftestFile(dir), "utf8")) as { passed: boolean };
+  assert.equal(saved.passed, true);
+  assert.ok(!renderSelftestReport(report).includes("【红】"));
+});
+
+test("有一个被 pass → passed:false，报告首行是红字", async () => {
+  const dir = tmpDir();
+  const report = await runSelftest({
+    evolutionDir: dir,
+    cwd: dir,
+    fixturesDir: FIXTURES,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "reject", "rg-retrieval": "reject", "misc-helper": "pass" }),
+    pollMs: 1,
+  });
+  assert.equal(report.passed, false);
+  const text = renderSelftestReport(report);
+  assert.ok(text.startsWith(`【红】${UNTRUSTED_NOTE}`), `红字必须在首行，实际：${text.slice(0, 40)}`);
+  assert.match(text, /✗ weak-description/);
+});
+
+test("单个样本就 pass（其余 reject）也判不可信", async () => {
+  const dir = tmpDir();
+  const report = await runSelftest({
+    evolutionDir: dir,
+    cwd: dir,
+    fixturesDir: FIXTURES,
+    spawnFn: spawnBySkill({ "ui-verify-lite": "pass", "rg-retrieval": "reject", "misc-helper": "revise" }),
+    pollMs: 1,
+  });
+  assert.equal(report.passed, false);
+  assert.equal(report.results.filter((item) => item.ok).length, 2);
+});
+
+test("fixture 缺 change.diff 被跳过，不猜也不补", () => {
+  const dir = tmpDir();
+  fs.mkdirSync(path.join(dir, "broken"), { recursive: true });
+  fs.writeFileSync(path.join(dir, "broken", "fixture.json"), JSON.stringify({ name: "broken", skill: "x", expected: "reject" }));
+  fs.writeFileSync(path.join(dir, "broken", "after.md"), "正文");
+  const logs: string[] = [];
+  const fixtures = loadFixtures(dir, (msg) => logs.push(msg));
+  assert.deepEqual(fixtures, []);
+  assert.match(logs.join("\n"), /缺 change\.diff/);
+});
+
+test("expected 非法同样跳过", () => {
+  const dir = tmpDir();
+  fs.mkdirSync(path.join(dir, "bad"), { recursive: true });
+  fs.writeFileSync(path.join(dir, "bad", "fixture.json"), JSON.stringify({ name: "bad", skill: "x", expected: "maybe" }));
+  fs.writeFileSync(path.join(dir, "bad", "change.diff"), "+++ b/x\n");
+  fs.writeFileSync(path.join(dir, "bad", "after.md"), "正文");
+  const logs: string[] = [];
+  assert.deepEqual(loadFixtures(dir, (msg) => logs.push(msg)), []);
+  assert.match(logs.join("\n"), /expected 非法/);
+});

package/extensions/skill-evolve/test/session-index.test.ts

@@ -0,0 +1,128 @@
+/**
+ * 会话索引单测（零依赖，node --test）。
+ *
+ * 运行：
+ *   cd .pi/extensions/skill-evolve
+ *   node --experimental-strip-types --test test/session-index.test.ts
+ *
+ * 覆盖：行号 1 起算、compaction 标记、坏行只计数不崩、摘要 ≤80 字、
+ * 以及「索引里不出现会话原文」这条铁律（设计稿 5.4）。
+ */
+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 { buildSessionIndex, excerptOf, writeSessionIndex } from "../lib/session-index.ts";
+import { directQueue } from "../lib/telemetry.ts";
+
+const LONG_TEXT = "这是一段用来撑长度的用户原话。".repeat(20);
+
+/** 贴近真实会话的一小段 JSONL：头部 + 用户 + 助手带工具调用 + 工具结果 + compaction */
+const SESSION_JSONL = [
+  JSON.stringify({ type: "session", version: 3, id: "sess-1", timestamp: "2026-11-08T02:48:52.675Z", cwd: "/repo" }),
+  JSON.stringify({ type: "model_change", id: "e0", timestamp: "2026-11-08T02:48:53.000Z" }),
+  JSON.stringify({
+    type: "message",
+    id: "e1",
+    parentId: "e0",
+    timestamp: "2026-11-08T02:49:00.000Z",
+    message: { role: "user", content: [{ type: "text", text: "帮我把需求 R-20261108 推进到开发中" }] },
+  }),
+  JSON.stringify({
+    type: "message",
+    id: "e2",
+    parentId: "e1",
+    timestamp: "2026-11-08T02:49:05.000Z",
+    message: {
+      role: "assistant",
+      content: [
+        { type: "text", text: "先看流程" },
+        { type: "toolCall", id: "call-1", name: "read", arguments: { path: ".pi/skills/kb-test-map/SKILL.md" } },
+      ],
+    },
+  }),
+  JSON.stringify({
+    type: "message",
+    id: "e3",
+    parentId: "e2",
+    timestamp: "2026-11-08T02:49:06.000Z",
+    message: { role: "toolResult", toolCallId: "call-1", toolName: "read", isError: false, content: [{ type: "text", text: "# kb-test-map" }] },
+  }),
+  JSON.stringify({ type: "compaction", id: "e4", timestamp: "2026-11-08T02:50:00.000Z", summary: "先前讨论了需求推进规则", firstKeptEntryId: "e2", tokensBefore: 42000 }),
+  "",
+].join("\n");
+
+test("buildSessionIndex：行号 1 起算、类型与角色正确", () => {
+  const index = buildSessionIndex(SESSION_JSONL);
+  assert.equal(index.stats.lines, 6);
+  assert.equal(index.stats.bytes, Buffer.byteLength(SESSION_JSONL, "utf8"));
+  assert.equal(index.lines[0].line, 1);
+  assert.equal(index.lines[0].type, "session");
+  assert.equal(index.lines[0].excerpt, "/repo");
+  assert.equal(index.lines[2].line, 3);
+  assert.equal(index.lines[2].role, "user");
+  assert.equal(index.lines[2].excerpt.includes("推进到开发中"), true);
+  assert.equal(index.lines[2].ts, "2026-11-08T02:49:00.000Z");
+  // 助手消息里的工具调用占位进摘要，方便复盘按行号回读
+  assert.equal(index.lines[3].excerpt.includes("[调用 read]"), true);
+  // 工具结果摘要前缀工具名
+  assert.equal(index.lines[4].excerpt.startsWith("[read]"), true);
+});
+
+test("buildSessionIndex：compaction 被标记且摘要进索引", () => {
+  const index = buildSessionIndex(SESSION_JSONL);
+  assert.equal(index.stats.hasCompaction, true);
+  const compaction = index.lines.find((line) => line.type === "compaction");
+  assert.equal(compaction?.line, 6);
+  assert.equal(compaction?.excerpt, "先前讨论了需求推进规则");
+});
+
+test("buildSessionIndex：坏行只计数不进索引，不整份失败", () => {
+  const index = buildSessionIndex(`${SESSION_JSONL}\n{"type":"message","id":broken\n`);
+  assert.equal(index.stats.lines, 7);
+  assert.equal(index.lines.length, 6);
+});
+
+test("buildSessionIndex：空行不计入 lines 统计", () => {
+  const index = buildSessionIndex("\n\n\n");
+  assert.equal(index.stats.lines, 0);
+  assert.deepEqual(index.lines, []);
+  assert.equal(index.stats.hasCompaction, false);
+});
+
+test("excerptOf：折叠空白并截到 80 字", () => {
+  assert.equal(excerptOf("a\n\n  b\tc"), "a b c");
+  const short = excerptOf(LONG_TEXT);
+  assert.equal(short.length, 80);
+  assert.equal(short.endsWith("…"), true);
+  assert.equal(excerptOf("x".repeat(80)).length, 80);
+});
+
+test("索引里不出现会话原文（长文本被截断，原文不入库）", () => {
+  const long = JSON.stringify({ type: "message", id: "x", message: { role: "user", content: [{ type: "text", text: LONG_TEXT }] } });
+  const index = buildSessionIndex(long);
+  assert.equal(index.lines.length, 1);
+  assert.equal(index.lines[0].chars, long.length);
+  assert.equal(JSON.stringify(index).includes(LONG_TEXT), false);
+});
+
+test("writeSessionIndex：生成 index.json 并从原文取字节数", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-index-"));
+  const sessionFile = path.join(dir, "session.jsonl");
+  fs.writeFileSync(sessionFile, SESSION_JSONL, "utf8");
+  const outDir = path.join(dir, "00-session");
+  const index = await writeSessionIndex({ sessionFile, outDir, queue: directQueue });
+  assert.equal(index?.stats.lines, 6);
+  const written = JSON.parse(fs.readFileSync(path.join(outDir, "index.json"), "utf8"));
+  assert.equal(written.stats.hasCompaction, true);
+  assert.equal(written.lines.length, 6);
+});
+
+test("writeSessionIndex：原文读不到时返回 null（调用方降级 telemetry-only）", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-index-"));
+  const index = await writeSessionIndex({ sessionFile: path.join(dir, "不存在.jsonl"), outDir: path.join(dir, "00-session"), queue: directQueue, log: () => {} });
+  assert.equal(index, null);
+  assert.equal(fs.existsSync(path.join(dir, "00-session", "index.json")), false);
+});