pi-skill-evolve 0.1.4 → 0.1.6

package/extensions/skill-evolve/test/aggregate-harness.ts

@@ -0,0 +1,114 @@
+/**
+ * 聚合检测的测试夹具：假子进程 + 假派发器 + 临时工作区。
+ *
+ * 为什么不放在 .test.ts 里：聚合有两条入口（自动派发与退出前补发），
+ * 各自一个测试文件，夹具共用一份才不会两边算出不同的场景。
+ *
+ * 纪律：pid 用合成号段（90001 起）而不是本进程 pid —— 「子进程是死是活」由用例通过 setAlive 控制，
+ * 否则测试进程自己活着就会被判成「有在途复盘」。全程不起真子进程。
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { DEFAULT_CONFIG } from "../lib/config.ts";
+import { createDispatcher } from "../lib/dispatch.ts";
+import { type SpawnedChild, type SpawnLike } from "../lib/spawn-plan.ts";
+import { directQueue, type TelemetryEvent, type TelemetryInput, type TelemetryWriter } from "../lib/telemetry.ts";
+import { fakeSupervisorSpawn } from "./fake-review-spawn.ts";
+
+export const TEMPLATE = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "prompts", "复盘.md");
+/** 固定时钟：判据里的「派发时刻 / 未来时刻」都按它算，用例才可复现 */
+export const NOW = 1_760_000_000_000;
+
+/**
+ * 假子进程：pid 用**合成的号段**（不是本进程 pid）。
+ *
+ * 这样「子进程是死是活」完全由用例通过 setAlive 控制 —— 聚合与单飞闸都读注入的 alive，
+ * 不会因为测试进程自己活着就被判成「有在途复盘」。
+ * 合成 pid 对真 kill(pid,0) 来说是死的，于是残锁会被当作孤儿回收：正好符合「子进程已退出」的场景。
+ */
+export class FakeChild {
+  readonly pid: number;
+  constructor(pid: number) {
+    this.pid = pid;
+  }
+  private listeners = new Map<string, (arg: unknown) => void>();
+  unref(): void {}
+  once(event: string, listener: (arg: unknown) => void): this {
+    this.listeners.set(event, listener);
+    return this;
+  }
+  emit(event: string, arg: unknown): void {
+    this.listeners.get(event)?.(arg);
+  }
+}
+
+export interface Harness {
+  evolutionDir: string;
+  calls: { command: string; args: string[]; options: Record<string, unknown> }[];
+  children: FakeChild[];
+  events: TelemetryEvent[];
+  logs: string[];
+  tick: (ms: number) => void;
+  /** 「子进程还活着吗」：聚合与单飞闸共用这个注入，用例按需翻转 */
+  setAlive: (value: boolean) => void;
+  dispatch: ReturnType<typeof createDispatcher>["dispatch"];
+}
+
+export function harness(tag: string): Harness {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `skill-evolve-agg-${tag}-`));
+  const evolutionDir = path.join(dir, ".pi", "evolution");
+  const calls: Harness["calls"] = [];
+  const children: FakeChild[] = [];
+  const events: TelemetryEvent[] = [];
+  const logs: string[] = [];
+  const pushEvent = (event: TelemetryInput): void => {
+    events.push({ ...event, ts: NOW, iso: "" } as TelemetryEvent);
+  };
+  const writer: TelemetryWriter = { append: pushEvent, appendSync: pushEvent, flush: async () => undefined };
+  const spawnFn: SpawnLike = (command, args, options) => {
+    calls.push({ command, args, options });
+    // pid 从 90001 起编号：每个用例一个独立工作区，不会和本机真实进程号撞上也无关（judged by alive）
+    const child = new FakeChild(90_001 + children.length);
+    children.push(child);
+    return child as unknown as SpawnedChild;
+  };
+  let alive = true;
+  let clock = NOW;
+  const dispatcher = createDispatcher({
+    evolutionDir,
+    cwd: dir,
+    config: { ...DEFAULT_CONFIG, enabled: true, telemetry: true },
+    telemetry: writer,
+    queue: directQueue,
+    promptTemplatePath: TEMPLATE,
+    log: (msg) => logs.push(msg),
+    now: () => clock,
+    env: {},
+    spawnFn,
+    alive: () => alive,
+    supervisorSpawnFn: fakeSupervisorSpawn([]),
+  });
+  return {
+    evolutionDir,
+    calls,
+    children,
+    events,
+    logs,
+    tick: (ms) => {
+      clock += ms;
+    },
+    setAlive: (value) => {
+      alive = value;
+    },
+    dispatch: dispatcher.dispatch,
+  };
+}
+export function readRun(h: Harness, runId: string): Record<string, unknown> {
+  return JSON.parse(fs.readFileSync(path.join(h.evolutionDir, "runs", runId, "run.json"), "utf8")) as Record<string, unknown>;
+}
+
+export const settleAsync = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 50));
+

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

@@ -0,0 +1,80 @@
+/**
+ * 同会话聚合检测：**判定规则**的单测（纯函数，不碰派发）。
+ *
+ * 现场（用户 2026-11-08 报的现象）：同一个 sessionId 下堆了 1 条 analyzed + 7 条 stale，
+ * 同一段会话被反反复复复盘。根因是 runId 每轮结算都会算出新的，而全局单飞闸只管「同时一个子进程」。
+ *
+ * 判定口径：只有「同会话 + 仍在途（dispatched）+ 子进程活着 + 还没落 01-findings.json」才并入；
+ * 尸体（进程已死）交 stale 逻辑、已跑完的交下一轮 —— 这三种不许混淆。
+ */
+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 { findSameSessionRun, readAggregateRuns, type AggregateRun } from "../lib/aggregate.ts";
+import { NOW } from "./aggregate-harness.ts";
+
+/** 假 run 的构造器：纯函数用例不需要真目录，只有 readAggregateRuns 才碰盘 */
+function runOf(overrides: Partial<AggregateRun> & { sessionId: string }): AggregateRun {
+  return {
+    runId: "run-1",
+    runDir: "/tmp/run-1",
+    status: "dispatched",
+    pid: 4242,
+    dispatchedAt: NOW - 1000,
+    hasFindings: false,
+    coverage: null,
+    ...overrides,
+  };
+}
+
+const alwaysAlive = (): boolean => true;
+const alwaysDead = (): boolean => false;
+
+test("纯函数：同会话在途且子进程活着 → 命中那条 run", () => {
+  const runs = [runOf({ sessionId: "s1", runId: "r1" })];
+  assert.equal(findSameSessionRun(runs, "s1", alwaysAlive, NOW)?.runId, "r1");
+  // 不同会话一律不并
+  assert.equal(findSameSessionRun(runs, "s2", alwaysAlive, NOW), null);
+});
+
+test("纯函数：状态不是 dispatched（复盘已跑完）→ 不命中", () => {
+  for (const status of ["analyzed", "proposed", "reviewed", "applied", "stale", "failed"]) {
+    const runs = [runOf({ sessionId: "s1", status })];
+    assert.equal(findSameSessionRun(runs, "s1", alwaysAlive, NOW), null, status);
+  }
+});
+
+test("纯函数：子进程已死 / 没有 pid → 不命中（尸体交给 stale，不往里并）", () => {
+  assert.equal(findSameSessionRun([runOf({ sessionId: "s1" })], "s1", alwaysDead, NOW), null);
+  assert.equal(findSameSessionRun([runOf({ sessionId: "s1", pid: null })], "s1", alwaysAlive, NOW), null);
+});
+
+test("纯函数：01-findings.json 已落盘 → 不命中（状态可能还没回写）", () => {
+  assert.equal(findSameSessionRun([runOf({ sessionId: "s1", hasFindings: true })], "s1", alwaysAlive, NOW), null);
+});
+
+test("纯函数：多条命中取最近派发的；派发时刻在未来的（时钟回拨）不并", () => {
+  const runs = [
+    runOf({ sessionId: "s1", runId: "old", dispatchedAt: NOW - 5000 }),
+    runOf({ sessionId: "s1", runId: "new", dispatchedAt: NOW - 100 }),
+    runOf({ sessionId: "s1", runId: "future", dispatchedAt: NOW + 60_000 }),
+  ];
+  assert.equal(findSameSessionRun(runs, "s1", alwaysAlive, NOW)?.runId, "new");
+});
+
+test("readAggregateRuns：坏 run.json 一律跳过，不伪造在途记录", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-agg-scan-"));
+  const evolutionDir = path.join(dir, ".pi", "evolution");
+  fs.mkdirSync(path.join(evolutionDir, "runs", "good"), { recursive: true });
+  fs.writeFileSync(path.join(evolutionDir, "runs", "good", "run.json"), JSON.stringify({ runId: "good", sessionId: "s1", status: "dispatched", pid: 7, dispatchedAt: NOW }), "utf8");
+  fs.mkdirSync(path.join(evolutionDir, "runs", "half"), { recursive: true });
+  fs.writeFileSync(path.join(evolutionDir, "runs", "half", "run.json"), '{"runId":"half"', "utf8");
+  const runs = readAggregateRuns(evolutionDir);
+  assert.deepEqual(runs.map((run) => run.runId), ["good"]);
+  // 01-findings.json 存在即视为复盘已跑完
+  fs.writeFileSync(path.join(evolutionDir, "runs", "good", "01-findings.json"), "{}", "utf8");
+  assert.equal(readAggregateRuns(evolutionDir)[0]?.hasFindings, true);
+});

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

@@ -0,0 +1,162 @@
+/**
+ * 会话页快速导航（用户 2026-11-08：「会话缺少快速导航，一直往下滚动太累了」）的验收测试。
+ *
+ * 口径：目录与锚点由**服务端一次遍历**产出（不引 JS，不做滚动高亮）；
+ * 宽屏左侧常驻、窄屏顶部折叠是同一份 HTML 的两种 CSS，所以两处内容必须一模一样。
+ *
+ * 纪律：`SessionSource` 一律由本文件现造的 JSONL 解析而来，不读真实 sessions 目录。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import type { WebState } from "../lib/web/data.ts";
+import { renderSessionPage } from "../lib/web/render-session.ts";
+import { parseSessionText } from "../lib/web/session-view.ts";
+import type { SessionSource } from "../lib/web/session-file.ts";
+
+const SID = "01a1b90f-08c3-722c-871d-d024b083770a";
+const FILE = `/tmp/${SID}.jsonl`;
+
+function line(record: unknown): string {
+  return `${JSON.stringify(record)}\n`;
+}
+
+function user(text: string, at: number): string {
+  return line({
+    type: "message",
+    timestamp: new Date(at).toISOString(),
+    message: { role: "user", content: [{ type: "text", text }] },
+  });
+}
+
+function assistant(text: string, calls: { id: string; name: string; arguments?: unknown }[] = []): string {
+  const content: unknown[] = [];
+  if (text.length > 0) content.push({ type: "text", text });
+  for (const call of calls) content.push({ type: "toolCall", id: call.id, name: call.name, arguments: call.arguments ?? {} });
+  return line({ type: "message", message: { role: "assistant", content } });
+}
+
+function result(toolCallId: string, text: string): string {
+  return line({
+    type: "message",
+    message: { role: "toolResult", toolCallId, toolName: "read", content: [{ type: "text", text }] },
+  });
+}
+
+/** 三条用户消息 + 两段工具调用（够测导航、锚点与「只看对话」） */
+function jsonl(): string {
+  const t = (hour: number, minute: number) => new Date(2026, 10, 8, hour, minute).getTime();
+  return (
+    user("第一段：先看列表页", t(10, 32)) +
+    assistant("", [{ id: "c1", name: "read", arguments: { path: "render.ts" } }]) +
+    result("c1", "ok") +
+    user("第二段：再改样式", t(11, 5)) +
+    assistant("", [
+      { id: "c2", name: "bash", arguments: { command: "npm test" } },
+      { id: "c3", name: "bash", arguments: { command: "npm run lint" } },
+    ]) +
+    result("c2", "ok") +
+    result("c3", "ok") +
+    user("第三段：收尾", t(11, 52)) +
+    assistant("好了")
+  );
+}
+
+function emptyState(): WebState {
+  return {
+    pending: [],
+    approvals: [],
+    applied: [],
+    done: [],
+    reports: [],
+    summary: { reviewing: 0, stale: 0, pendingApprovals: 0, appliedTotal: 0, rollbackRate: 0 },
+  };
+}
+
+function source(raw = jsonl()): SessionSource {
+  return { sessionId: SID, file: FILE, sizeBytes: Buffer.byteLength(raw, "utf8"), transcript: parseSessionText(raw) };
+}
+
+function page(options: { onlyUser?: boolean } = {}): string {
+  return renderSessionPage(source(), { state: emptyState(), onlyUser: options.onlyUser === true });
+}
+
+/** 取 aside 里的目录链接（宽屏那份） */
+function tocLinks(html: string): string[] {
+  const aside = /<aside class="toc">([\s\S]*?)<\/aside>/.exec(html)?.[1] ?? "";
+  return [...aside.matchAll(/<a href="#(m-\d+)">/g)].map((match) => match[1] ?? "");
+}
+
+test("目录条目数等于渲染出的用户消息数（用户消息就是天然章节）", () => {
+  const html = page();
+  assert.equal(tocLinks(html).length, 3);
+  assert.match(html, /<a href="#m-1">10:32 · 第一段：先看列表页<\/a>/);
+});
+
+test("锚点与目录一一对应：id 唯一、href 全都能落到实处", () => {
+  const html = page();
+  const ids = [...html.matchAll(/<div class="msg user m" id="(m-\d+)">/g)].map((match) => match[1]);
+  assert.deepEqual(ids, ["m-1", "m-3", "m-5"], "三条用户消息的块号（工具块不占 msg 块号）");
+  assert.deepEqual(new Set(ids).size, ids.length, "id 不许重复");
+  assert.deepEqual(tocLinks(html), ids, "目录指向的正是这三块");
+});
+
+test("窄屏折叠目录：同一份内容放在顶部 <details> 里（宽屏由 CSS 隐藏）", () => {
+  const html = page();
+  assert.match(html, /<details class="toc-fold"><summary>目录（3 条用户消息）<\/summary>/);
+  const fold = /<div class="toc-list">([\s\S]*?)<\/div>/.exec(html)?.[1] ?? "";
+  assert.deepEqual([...fold.matchAll(/<a href="#(m-\d+)">/g)].map((match) => match[1]), tocLinks(html));
+});
+
+test("目录文本：转义且截到 40 字（长标题不把侧栏撑成两行）", () => {
+  const long = `${"很".repeat(60)}<b>x</b>`;
+  const html = renderSessionPage(
+    { sessionId: SID, file: FILE, sizeBytes: 10, transcript: parseSessionText(user(long, new Date(2026, 10, 8, 9, 0).getTime())) },
+    { state: emptyState() },
+  );
+  const aside = /<aside class="toc">([\s\S]*?)<\/aside>/.exec(html)?.[1] ?? "";
+  assert.match(aside, new RegExp(`09:00 · 很{40}…`));
+  assert.equal(aside.includes("<b>"), false, "目录文本必须转义");
+});
+
+test("只看对话：工具块全部省略成一行，且给「看全部」的回头路", () => {
+  const html = page({ onlyUser: true });
+  assert.equal(html.includes('<details class="tools">'), false);
+  assert.match(html, /<p class="hint">… 本轮省略 1 次工具调用/);
+  assert.match(html, /<p class="hint">… 本轮省略 2 次工具调用（<a href="[^"]+">看全部<\/a>）<\/p>/);
+  const back = /<a href="([^"]+)">看全部<\/a>/.exec(html)?.[1] ?? "";
+  assert.ok(back.includes(`sessionId=${SID}`), "回头路必须还在这个会话");
+  assert.equal(back.includes("only=user"), false, "看全部 = 去掉 only=user");
+});
+
+test("看全部 ⇄ 只看对话：切换链接都带着 sessionId 与原文件路径", () => {
+  const all = page();
+  const toOnly = /<a href="([^"]+)">只看对话<\/a>/.exec(all)?.[1] ?? "";
+  assert.ok(toOnly.includes("only=user"));
+  assert.ok(toOnly.includes(encodeURIComponent(FILE)), "换机器时 file 参数是找回原文的关键");
+  const only = page({ onlyUser: true });
+  assert.match(only, /<span class="ov-link"><a href="[^"]*">看全部<\/a>（当前只看对话）<\/span>/);
+});
+
+test("两个跳转：顶部「跳到最新 ↓」指向最后一块，底部「↑ 回到顶部」指回 #top", () => {
+  const html = page();
+  // 最后一块是收尾的助手消息（m-6）：跳转要落在它身上，不能落在工具块上
+  assert.match(html, /<a class="to-end" href="#m-6">跳到最新 ↓<\/a>/);
+  assert.match(html, /<a class="to-top" href="#top">↑ 回到顶部<\/a>/);
+  assert.match(html, /<div class="wrap" id="top">/);
+});
+
+test("没有用户消息时目录给一句人话；没有任何块时也不给「跳到最新」", () => {
+  const onlyAssistant = renderSessionPage(
+    { sessionId: SID, file: FILE, sizeBytes: 10, transcript: parseSessionText(assistant("只有助手在自言自语")) },
+    { state: emptyState() },
+  );
+  assert.match(onlyAssistant, /这段会话里没有用户消息/);
+
+  const nothing = renderSessionPage(
+    { sessionId: SID, file: FILE, sizeBytes: 0, transcript: parseSessionText("") },
+    { state: emptyState() },
+  );
+  assert.equal(nothing.includes('class="to-end"'), false, "没有块可跳就不给「跳到最新」");
+  assert.match(nothing, /没有可渲染的对话/);
+});

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

@@ -0,0 +1,200 @@
+/**
+ * 会话详情页的读盘层与整页渲染（node --test）。
+ *
+ * 纪律：所有会话文件都造在临时目录里，并把 `home` 显式传进 readSessionSource ——
+ * 绝不扫真实 `~/.pi/agent/sessions`（本机会话文件随时在变，测试不能依赖它）。
+ *
+ * 覆盖：按 sessionId 反查、三条安全闸（根外路径 / 名字不含 sessionId / 非 .jsonl）、
+ * run.json 里的 sessionFile 优先、文件不在本机的文案、整页统计与「工具块默认收起」、HTTP 路由接对。
+ */
+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 type { WebState } from "../lib/web/data.ts";
+import { renderSessionPage } from "../lib/web/render-session.ts";
+import {
+  declaredSessionFile,
+  findSessionFile,
+  readSessionSource,
+  resolveSessionFile,
+  safeSessionId,
+  sessionsRoot,
+} from "../lib/web/session-file.ts";
+import { startWebPanel } from "../lib/web/server.ts";
+
+const SESSION_ID = "01a1b90f-08c3-722c-871d-d024b083770a";
+
+/** 一段最小的会话 JSONL：一条用户消息 + 一次带结果的工具调用 */
+function sessionJsonl(): string {
+  return [
+    JSON.stringify({ type: "session", id: SESSION_ID }),
+    JSON.stringify({ type: "message", message: { role: "user", content: [{ type: "text", text: "看一下这个文件" }] } }),
+    JSON.stringify({
+      type: "message",
+      message: { role: "assistant", content: [{ type: "toolCall", id: "c1", name: "read", arguments: { path: "a.ts" } }] },
+    }),
+    JSON.stringify({ type: "message", message: { role: "toolResult", toolCallId: "c1", toolName: "read", content: [{ type: "text", text: "文件内容" }] } }),
+  ].join("\n") + "\n";
+}
+
+/** 临时 home：`<home>/.pi/agent/sessions/--project--/2026-11-08T00-00-00-000Z_<id>.jsonl` */
+function fakeHome(): { home: string; file: string } {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-home-"));
+  const dir = path.join(sessionsRoot(home), "--home-suveng-demo--");
+  fs.mkdirSync(dir, { recursive: true });
+  const file = path.join(dir, `2026-11-08T00-00-00-000Z_${SESSION_ID}.jsonl`);
+  fs.writeFileSync(file, sessionJsonl(), "utf8");
+  return { home, file };
+}
+
+/** 临时工作区：只造 runs/<runId>/run.json，够 readSessionSource 反查 sessionFile */
+function fakeEvolution(runId: string, record: Record<string, unknown>): string {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-evo-"));
+  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, ...record }), "utf8");
+  return evolutionDir;
+}
+
+function emptyState(): WebState {
+  return {
+    pending: [],
+    approvals: [],
+    applied: [],
+    done: [],
+    reports: [],
+    summary: { reviewing: 0, stale: 0, pendingApprovals: 0, appliedTotal: 0, rollbackRate: 0 },
+  };
+}
+
+test("sessionsRoot / safeSessionId：路径拼对，非法 id 一律拒（它会被当文件名匹配词）", () => {
+  assert.equal(sessionsRoot("/home/demo"), path.join("/home/demo", ".pi", "agent", "sessions"));
+  assert.equal(safeSessionId(SESSION_ID), SESSION_ID);
+  assert.equal(safeSessionId("  " + SESSION_ID + "  "), SESSION_ID);
+  for (const bad of ["", "../../etc/passwd", "a/b", "x".repeat(200), "id with space"]) {
+    assert.equal(safeSessionId(bad), null, bad);
+  }
+});
+
+test("findSessionFile：按 sessionId 在 sessions 子目录里反查，命中多条取最近（文件名时间最大）", () => {
+  const { home, file } = fakeHome();
+  const dir = path.dirname(file);
+  const older = path.join(dir, `2026-11-07T00-00-00-000Z_${SESSION_ID}.jsonl`);
+  fs.copyFileSync(file, older);
+  assert.equal(findSessionFile(SESSION_ID, sessionsRoot(home)), file);
+  // 换一个 sessionId 就找不到（绝不模糊匹配到别的会话）
+  assert.equal(findSessionFile("ffffffff-0000-0000-0000-000000000000", sessionsRoot(home)), null);
+});
+
+test("resolveSessionFile 安全闸：根目录外 / 名字不含 sessionId / 非 .jsonl 一律不采纳（回落到按 id 反查）", () => {
+  const { home, file } = fakeHome();
+  const root = sessionsRoot(home);
+  assert.equal(resolveSessionFile({ sessionId: SESSION_ID, file, root }), file);
+
+  // 根目录内但不是这个会话的文件：不采纳那一条，落到反查（反查命中的才是真会话）
+  const other = path.join(path.dirname(file), "2026-11-08T00-00-00-000Z_other.jsonl");
+  fs.writeFileSync(other, "{}\n", "utf8");
+  assert.equal(resolveSessionFile({ sessionId: SESSION_ID, file: other, root }), file);
+  // 后缀不是 .jsonl 同理
+  const txt = path.join(path.dirname(file), `${SESSION_ID}.txt`);
+  fs.writeFileSync(txt, "x", "utf8");
+  assert.equal(resolveSessionFile({ sessionId: SESSION_ID, file: txt, root }), file);
+
+  // ?file=/etc/passwd 这种绝不能读（根目录外）：任何情况下都不会返回它
+  const outside = resolveSessionFile({ sessionId: SESSION_ID, file: "/etc/passwd", root });
+  assert.equal(outside, file);
+  assert.equal(resolveSessionFile({ sessionId: "ffffffff-0000-0000-0000-000000000000", file: "/etc/passwd", root }), null);
+});
+
+test("declaredSessionFile：从 runs 里的 run.json 反查同一会话的 sessionFile", () => {
+  const file = "/tmp/demo-session.jsonl";
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, sessionFile: file, status: "rejected" });
+  assert.equal(declaredSessionFile(evolutionDir, SESSION_ID), file);
+  assert.equal(declaredSessionFile(evolutionDir, "ffffffff-0000-0000-0000-000000000000"), null);
+});
+
+test("readSessionSource：解析会话原文并给出消息数 / 工具调用数 / 字节数", () => {
+  const { home, file } = fakeHome();
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, sessionFile: file, status: "rejected" });
+  const source = readSessionSource({ evolutionDir, sessionId: SESSION_ID, home });
+  assert.equal(source.file, file);
+  assert.equal(source.transcript?.messages, 3);
+  assert.equal(source.transcript?.toolCalls, 1);
+  assert.equal(source.sizeBytes, Buffer.byteLength(sessionJsonl(), "utf8"));
+});
+
+test("readSessionSource：run.json 记的路径已不在本机时按 sessionId 反查兜底", () => {
+  const { home, file } = fakeHome();
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, sessionFile: "/gone/away.jsonl", status: "rejected" });
+  const source = readSessionSource({ evolutionDir, sessionId: SESSION_ID, home });
+  assert.equal(source.file, file, "声明的路径没了，但本机其它目录里还留着这个会话");
+});
+
+test("readSessionSource：彻底找不到 → file 与 transcript 都是 null（页面要说人话，不能 500）", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-home-empty-"));
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, sessionFile: null, status: "rejected" });
+  const source = readSessionSource({ evolutionDir, sessionId: SESSION_ID, home });
+  assert.deepEqual([source.file, source.transcript, source.sizeBytes], [null, null, 0]);
+});
+
+test("readSessionSource：非法 sessionId 直接返回空，不扫盘", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-home-empty-"));
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, status: "rejected" });
+  const source = readSessionSource({ evolutionDir, sessionId: "../../etc/passwd", home });
+  assert.deepEqual([source.file, source.transcript], [null, null]);
+});
+
+test("renderSessionPage：顶部一行给返回入口 / 会话短 id / 原文件，概览与出口给统计，工具块默认收起", () => {
+  const { home, file } = fakeHome();
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, sessionFile: file, status: "rejected" });
+  const source = readSessionSource({ evolutionDir, sessionId: SESSION_ID, home });
+  const html = renderSessionPage(source, { state: emptyState() });
+  // 顶部一行：回来有路、会话只显示前 8 位（完整 id 在 title 里，9 条 run 的前缀全一样）
+  assert.match(html, /<a href="\/\?view=pending&amp;range=all">← 返回待处理<\/a>/);
+  assert.match(html, /<span class="ses-id">会话 <code>01a1b90f<\/code><\/span>/);
+  assert.match(html, /原文件 <code title="[^"]*2026-11-08T00-00-00-000Z_.*\.jsonl">/);
+  // 概览：消息 / 工具调用 / 大小（时间跨度只在这段会话有 timestamp 时才出现）
+  assert.match(html, /<p class="ov">消息 3 · 工具调用 1 · \d+B/);
+  // 出口：渲染了多少条、原文件在哪
+  assert.match(html, /已渲染全部 3 条消息（原文件 <code>.*\.jsonl<\/code>）/);
+  assert.equal(/<details[^>]*\sopen/.test(html), false, "工具块默认收起");
+  assert.match(html, /看一下这个文件/);
+});
+
+test("renderSessionPage：会话文件不在本机时给一句人话，不是空白页", () => {
+  const source = readSessionSource({
+    evolutionDir: fakeEvolution("run-1", { sessionId: SESSION_ID, status: "rejected" }),
+    sessionId: SESSION_ID,
+    home: fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-home-empty-")),
+  });
+  const html = renderSessionPage(source, { state: emptyState() });
+  assert.match(html, /会话文件已不在本机/);
+  assert.match(html, /原文件：<span class="off">会话文件已不在本机<\/span>/);
+});
+
+test("HTTP 路由：GET /?view=session&sessionId= 接对了（HOME 指到临时目录，绝不碰真实 sessions）", async () => {
+  const { home, file } = fakeHome();
+  const evolutionDir = fakeEvolution("run-1", { sessionId: SESSION_ID, sessionFile: file, status: "rejected" });
+  const original = process.env.HOME;
+  process.env.HOME = home;
+  const result = await startWebPanel({ evolutionDir, port: 0 });
+  assert.equal(result.ok, true);
+  if (!result.ok) return;
+  try {
+    const response = await fetch(`${result.panel.url}/?view=session&sessionId=${SESSION_ID}`);
+    assert.equal(response.status, 200);
+    assert.match(response.headers.get("content-type") ?? "", /text\/html/);
+    const html = await response.text();
+    assert.match(html, /<details class="tools"><summary>▸ read ×1 · <span class="muted">/);
+    assert.equal(/<details[^>]*\sopen/.test(html), false);
+    assert.match(html, /← 返回待处理/);
+  } finally {
+    await result.panel.close();
+    if (original === undefined) delete process.env.HOME;
+    else process.env.HOME = original;
+  }
+});