pi-skill-evolve 0.1.4 → 0.1.5

package/extensions/skill-evolve/lib/web/session-view.ts

@@ -0,0 +1,260 @@
+/**
+ * 会话详情页的**纯函数**：把 pi 的会话 JSONL 解析成「可渲染的块」，再拼成 HTML 片段。
+ *
+ * 为什么要这一页（用户 2026-11-08：「支持打开会话的详情, 工具调用可收起展开, 默认收起」）：
+ * 面板上每条 run 都关联一段 pi 会话，出问题时要看的是「那段对话里到底发生了什么」——
+ * 而 sessions/*.jsonl 有几 MB、几千行，在编辑器里翻根本对不上哪句是哪轮。
+ *
+ * 结构口径（与 pi 的真实写入一致）：
+ * - 只取顶层 `type === "message"` 的条目，其余（session / model_change / thinking_level_change / custom）全跳过；
+ * - `message.role` = user / assistant / toolResult / system；system 不渲染（它是系统提示词，不是对话）；
+ * - assistant 的内容里 `text` 是给人看的、`thinking` 不渲染、`toolCall` 聚成折叠块；
+ * - toolResult 消息按 `toolCallId` 回连到那次调用（结果贴在该调用的参数之后）。
+ *
+ * 三条上限（会话可能很大，页面不能被一段对话撑爆浏览器）：
+ * 只渲染最后 200 条消息 · 单条 4000 字 · 用户原文 2000 字 · 总输出超 2MB 就停手并指路原文件。
+ *
+ * 这个文件里**没有一行 IO**：入参是字符串，出参是 HTML 字符串，所以能直接拿临时 JSONL 片段做单测。
+ */
+import { escapeHtml } from "./text.ts";
+
+/** 只渲染最后多少条 message（更早的对话对排查当前问题几乎无用） */
+export const MAX_MESSAGES = 200;
+/** 单条消息正文上限 */
+export const MAX_TEXT = 4000;
+/** 用户消息正文上限：用户要的是「原文」，所以给得比 assistant 宽，但仍要防一次粘贴几万字 */
+export const MAX_USER_TEXT = 2000;
+/** 一次工具调用的参数摘要上限 */
+export const MAX_ARGS = 400;
+/** 一次工具调用的结果上限 */
+export const MAX_RESULT = 200;
+/** 整页会话正文的输出上限（字符数，UTF-8 下中文 3 字节，这里按保守值算） */
+export const MAX_OUTPUT = 2 * 1024 * 1024;
+
+export interface SessionToolCall {
+  name: string;
+  /** 参数摘要（JSON 压成一行后截断） */
+  args: string;
+  /** 结果前 200 字（没有结果就是「（没有结果）」） */
+  result: string;
+}
+
+export type SessionEntry =
+  | { kind: "user"; text: string }
+  | { kind: "assistant"; text: string }
+  | { kind: "tools"; calls: SessionToolCall[] };
+
+/**
+ * 解析中途的调用记录：结果（toolResult）总是排在携带 toolCall 的 assistant 消息**之后**，
+ * 所以先带 id 收进来，全文扫完再回填结果 —— 边扫边取会永远取不到（那时结果还没出现）。
+ */
+interface RawCall {
+  id: string;
+  name: string;
+  args: string;
+}
+
+export interface SessionTranscript {
+  entries: SessionEntry[];
+  /** 解析到的 message 总条数（不限 200） */
+  messages: number;
+  /** 工具调用总次数 */
+  toolCalls: number;
+  /** 因为只留最后 200 条而丢掉的消息条数 */
+  dropped: number;
+}
+
+/** 截断并加省略号：中文一行话也可能超长，所以在字符数上截，不在行上截 */
+function clip(text: string, max: number): string {
+  const trimmed = text.trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+/** 参数压成一行 JSON：多行缩进在面板里只会占满屏 */
+function argumentsText(value: unknown): string {
+  let text: string;
+  if (typeof value === "string") {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value) ?? "";
+    } catch {
+      text = String(value);
+    }
+  }
+  return clip(text.replace(/\s+/g, " "), MAX_ARGS);
+}
+
+/** toolResult / user 的 content：可能是字符串，也可能是 [{type:"text",text}]，图片只留一句占位 */
+function contentText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const part of content) {
+    if (typeof part !== "object" || part === null) continue;
+    const record = part as Record<string, unknown>;
+    if (record.type === "text" && typeof record.text === "string") parts.push(record.text);
+    else if (record.type === "image") parts.push("（图片输出）");
+  }
+  return parts.join("\n");
+}
+
+/** 工具结果：只留前 200 字（完整输出在原理行数里，面板里看首尾就够判断成败） */
+function resultText(content: unknown): string {
+  return clip(contentText(content), MAX_RESULT);
+}
+
+/** assistant 内容块：文本拼接、toolCall 收集；thinking 不渲染（它是推理过程，不是回答） */
+function readAssistantParts(content: unknown): { text: string; calls: RawCall[] } {
+  if (typeof content === "string") return { text: content, calls: [] };
+  if (!Array.isArray(content)) return { text: "", calls: [] };
+  const texts: string[] = [];
+  const calls: RawCall[] = [];
+  for (const part of content) {
+    if (typeof part !== "object" || part === null) continue;
+    const record = part as Record<string, unknown>;
+    if (record.type === "text" && typeof record.text === "string") texts.push(record.text);
+    else if (record.type === "toolCall") {
+      calls.push({
+        id: typeof record.id === "string" ? record.id : "",
+        name: typeof record.name === "string" ? record.name : "（未命名工具）",
+        args: argumentsText(record.arguments),
+      });
+    }
+  }
+  return { text: texts.join("\n"), calls };
+}
+
+/** 解析整份 JSONL：坏行跳过（可能是进程被 kill 时写了一半的最后一行） */
+export function parseSessionText(raw: string): SessionTranscript {
+  type Pending = { entry: SessionEntry | { kind: "tools"; calls: RawCall[] }; roles: string[] };
+  const kept: Pending[] = [];
+  const results = new Map<string, string>();
+  let messages = 0;
+  for (const line of raw.split(/\r?\n/)) {
+    if (line.trim().length === 0) continue;
+    let record: Record<string, unknown>;
+    try {
+      record = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    if (record.type !== "message") continue;
+    const message = record.message;
+    if (typeof message !== "object" || message === null) continue;
+    const fields = message as Record<string, unknown>;
+    const role = typeof fields.role === "string" ? fields.role : "";
+    messages += 1;
+    if (role === "toolResult") {
+      // 结果先存起来：它总是排在携带 toolCall 的那条 assistant 消息之后
+      const id = typeof fields.toolCallId === "string" ? fields.toolCallId : "";
+      if (id.length > 0) results.set(id, resultText(fields.content));
+      continue;
+    }
+    if (role === "user") {
+      kept.push({ entry: { kind: "user", text: contentText(fields.content) }, roles: [role] });
+      continue;
+    }
+    if (role !== "assistant") continue; // system 是系统提示词，不是对话
+    const parts = readAssistantParts(fields.content);
+    if (parts.text.trim().length > 0) {
+      const last = kept[kept.length - 1];
+      // 一条 assistant 消息里「文本 + toolCall」并存：文本先出，工具另起一段，顺序与真实发生一致
+      if (last && last.roles[last.roles.length - 1] === "assistant-text") last.entry = { kind: "assistant", text: `${(last.entry as { text: string }).text}\n${parts.text}` };
+      else kept.push({ entry: { kind: "assistant", text: parts.text }, roles: ["assistant-text"] });
+    }
+    if (parts.calls.length > 0) {
+      const last = kept[kept.length - 1];
+      // 连续工具调用（中间没有文本）聚成一个折叠块：一次 read 一个块会堆出上百个折叠框
+      if (last && last.entry.kind === "tools" && last.roles[last.roles.length - 1] !== "assistant-text") {
+        (last.entry.calls as RawCall[]).push(...parts.calls);
+      } else {
+        kept.push({ entry: { kind: "tools", calls: [...parts.calls] }, roles: ["tools"] });
+      }
+    }
+  }
+  const toolCalls = kept.reduce((sum, item) => (item.entry.kind === "tools" ? sum + item.entry.calls.length : sum), 0);
+  const dropped = Math.max(0, kept.length - MAX_MESSAGES);
+  // 全文扫完再回填结果：toolResult 一定在 toolCall 之后出现
+  const entries: SessionEntry[] = kept.slice(dropped).map((item) =>
+    item.entry.kind === "tools"
+      ? {
+          kind: "tools",
+          calls: (item.entry.calls as RawCall[]).map((call) => ({
+            name: call.name,
+            args: call.args,
+            result: results.get(call.id) ?? "（没有结果）",
+          })),
+        }
+      : item.entry,
+  );
+  return { entries, messages, toolCalls, dropped };
+}
+
+/** 工具调用的抬头：`read ×3、bash ×2`（同名的合成一个计数，别写三遍 read） */
+function toolSummary(calls: readonly SessionToolCall[]): string {
+  const counts = new Map<string, number>();
+  for (const call of calls) counts.set(call.name, (counts.get(call.name) ?? 0) + 1);
+  return [...counts.entries()].map(([name, count]) => `${name} ×${count}`).join("、");
+}
+
+/** 一个工具调用块：名字 + 参数摘要 + 结果前 200 字（全转义，original 里可能带尖括号） */
+function toolBlock(call: SessionToolCall): string {
+  return `<div class="tool">
+<p class="tool-name">${escapeHtml(call.name)}</p>
+<pre class="tool-args">${escapeHtml(call.args.length > 0 ? call.args : "（无参数）")}</pre>
+<pre class="tool-result">${escapeHtml(call.result)}</pre>
+</div>`;
+}
+
+/**
+ * 一组工具调用：`<details>` **默认收起**（不加 `open`）——
+ * 一段会话动辄几百次调用，默认展开等于把对话正文顶到十屏之外。
+ */
+function toolGroup(calls: readonly SessionToolCall[]): string {
+  return `<details class="tools"><summary>工具调用：${escapeHtml(toolSummary(calls))}（点击展开）</summary>
+${calls.map(toolBlock).join("\n")}
+</details>`;
+}
+
+/** 一条对话消息：user 给原文（2000 字上限），assistant 给纯文本（4000 字上限） */
+function messageBlock(entry: Extract<SessionEntry, { kind: "user" | "assistant" }>): string {
+  const label = entry.kind === "user" ? "用户" : "助手";
+  const max = entry.kind === "user" ? MAX_USER_TEXT : MAX_TEXT;
+  const body = clip(entry.text, max);
+  if (body.length === 0) return "";
+  return `<div class="msg ${entry.kind}">
+<p class="who">${label}</p>
+<pre>${escapeHtml(body)}</pre>
+</div>`;
+}
+
+export interface RenderSessionOptions {
+  /** 因「只渲染最后 200 条」丢掉的条数（>0 时在顶部说明一句） */
+  dropped?: number;
+}
+
+/** 会话正文：按真实顺序渲染，超出总输出上限就停下并指路原文件 */
+export function renderSessionBody(transcript: SessionTranscript, options: RenderSessionOptions = {}): string {
+  const parts: string[] = [];
+  let size = 0;
+  let stopped = false;
+  if (options.dropped !== undefined && options.dropped > 0) {
+    parts.push(`<p class="hint">只渲染最后 ${MAX_MESSAGES} 条消息，前面还有 ${options.dropped} 条未显示（看全文请用 rg/read 打开原文件）。</p>`);
+  }
+  for (const entry of transcript.entries) {
+    const html = entry.kind === "tools" ? toolGroup(entry.calls) : messageBlock(entry);
+    if (html.length === 0) continue;
+    if (size + html.length > MAX_OUTPUT) {
+      stopped = true;
+      break;
+    }
+    parts.push(html);
+    size += html.length;
+  }
+  if (stopped) {
+    parts.push(`<p class="hint">已达页面输出上限（${Math.round(MAX_OUTPUT / 1024)}KB），后面还有内容未渲染：继续看请用 rg/read 打开原文件。</p>`);
+  }
+  if (parts.length === 0) return '<p class="empty">这段会话里没有可渲染的对话（可能全是工具调用与系统提示）。</p>';
+  return parts.join("\n");
+}

package/extensions/skill-evolve/lib/web/style.ts

@@ -102,6 +102,23 @@ h2 { margin: 20px 0 6px; font-size: 15px; font-weight: 600; color: #cfe3ff }
 .diff .meta { color: #6f7a8c }
 /* 改后全文：长文件限高内部滚动，别把后面的评审/五闸顶到屏幕外 */
 .candidate { max-height: 480px; overflow: auto }
+/* 会话详情页：工具调用块默认收起（details 不带 open），抬头是一行可点的摘要 */
+details > summary { cursor: pointer }
+details.tools { margin: 10px 0; padding: 8px 10px; background: #171b24; border-left: 2px solid #2b3342; border-radius: 4px }
+details.tools > summary { color: #cfe3ff }
+.tool { margin: 8px 0 0; padding: 8px 0 0; border-top: 1px solid #232733 }
+.tool-name { margin: 0; color: #7cc4ff }
+.tool-args, .tool-result { margin: 4px 0 0; padding: 8px; background: #141821;
+  border-left: 1px solid #2b3342; white-space: pre-wrap; word-break: break-word }
+.tool-result { color: #8d99ae }
+/* 对话消息：谁说的一句话决定左边框颜色，长文本靠 pre 自己的换行 */
+.msg { margin: 14px 0; padding-left: 10px; border-left: 2px solid #2b3342 }
+.msg.user { border-left-color: #7cc4ff }
+.msg .who { margin: 0; color: #8d99ae; font-size: 12px }
+.msg pre { margin: 4px 0 0; background: none; padding: 0; border: 0 }
+/* 列表页「会话」列：只显示 sessionId 前 8 位，完整值在 title 里 */
+a.sess { color: #8d99ae; text-decoration: none; border-bottom: 1px dashed #3f4654 }
+a.sess:hover { color: #7cc4ff; border-bottom-color: #7cc4ff }
 footer { margin-top: 24px; padding-top: 12px; border-top: 1px solid #232733; color: #6f7a8c }
 footer a { color: #7cc4ff }
 `.trim();

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

@@ -0,0 +1,165 @@
+/**
+ * 同会话聚合检测：**接线**的单测（派发器与退出前补发真的走到并入分支）。
+ *
+ * 这里断言的是「没建新 run、没起进程」这类后果 —— 只看返回值会漏掉「返回说并入了，其实又派了一个」。
+ * 场景与用户现场一致：同一会话连着几轮结算，第二轮起只并轮数。
+ */
+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 { DEFAULT_CONFIG } from "../lib/config.ts";
+import { patchRunRecordSync } from "../lib/runs.ts";
+import { flushPendingSync } from "../lib/shutdown-dispatch.ts";
+import { type SpawnedChild } from "../lib/spawn-plan.ts";
+import { type TelemetryEvent } from "../lib/telemetry.ts";
+import { FakeChild, NOW, TEMPLATE, harness, readRun, settleAsync } from "./aggregate-harness.ts";
+
+test("派发：同会话第二条不再派新 run，而是并入（不起进程、轮数与 merged 累加）", async () => {
+  const h = harness("merge");
+  const first = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(first.status, "dispatched");
+  if (first.status !== "dispatched") return;
+  const runId = first.run.runId;
+  const spawns = h.calls.length;
+
+  // 去抖窗口已过：这一轮会真的走到派发逻辑，聚合检测在单飞闸之前
+  h.tick(DEFAULT_CONFIG.idleMs + 1_000);
+  const second = await h.dispatch({ sessionId: "s1", skills: ["b"] });
+  assert.deepEqual(second, { status: "merged", runId, rounds: 2 });
+  assert.equal(h.calls.length, spawns, "并入的轮次不许再起子进程");
+  assert.equal(fs.readdirSync(path.join(h.evolutionDir, "runs")).length, 1, "也不许再建 run 目录");
+
+  const record = readRun(h, runId);
+  const coverage = record.coverage as Record<string, unknown>;
+  assert.deepEqual([coverage.rounds, coverage.merged, coverage.lastAt], [2, 1, NOW + DEFAULT_CONFIG.idleMs + 1_000]);
+  // run 原有的状态与 skills 不被并入操作改写：本轮并进去的是「覆盖轮数」，不是新一轮技能清单
+  assert.deepEqual([record.status, record.trigger], ["dispatched", "auto"]);
+
+  const merged = h.events.filter((event) => event.kind === "merged");
+  assert.equal(merged.length, 1);
+  assert.deepEqual([merged[0]?.sessionId, merged[0]?.runId, merged[0]?.rounds], ["s1", runId, 2]);
+  assert.equal(h.logs.some((line) => line.includes(`同会话已有在途复盘 ${runId}，本轮并入（共 2 轮），不再派生`)), true);
+});
+
+test("派发：连续并入时 rounds 递增、merged 累计；被去抖挡下的轮次也算进总数", async () => {
+  const h = harness("merge-twice");
+  const first = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(first.status, "dispatched");
+  if (first.status !== "dispatched") return;
+
+  // 窗口内又结算一轮：走老路记 pending（superseded），不是并入
+  const superseded = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.deepEqual(superseded, { status: "superseded", rounds: 1 });
+
+  // 窗口过后这一轮：pending 里的那轮 + 这一轮一起并进去
+  h.tick(DEFAULT_CONFIG.idleMs + 1_000);
+  const merged = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  // 派发时覆盖 1 轮 + pending 里 1 轮 + 这一轮 = 3 轮
+  assert.deepEqual(merged, { status: "merged", runId: first.run.runId, rounds: 3 });
+
+  h.tick(DEFAULT_CONFIG.idleMs + 1_000);
+  const third = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.deepEqual(third, { status: "merged", runId: first.run.runId, rounds: 4 });
+
+  const coverage = readRun(h, first.run.runId).coverage as Record<string, unknown>;
+  assert.deepEqual([coverage.rounds, coverage.merged], [4, 2]);
+  assert.equal(h.events.filter((event) => event.kind === "merged").length, 2);
+});
+
+test("派发：在途 run 的子进程已死 → 不并入，另开新 run（尸体交给 stale 逻辑）", async () => {
+  const h = harness("dead");
+  const first = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(first.status, "dispatched");
+  if (first.status !== "dispatched") return;
+
+  // 子进程退出（收尸会放锁并把这条 run 记成 abandoned），pid 判死：它不再是在途复盘
+  h.children[0].emit("exit", 1);
+  await settleAsync();
+  h.setAlive(false);
+  h.tick(DEFAULT_CONFIG.idleMs + 1_000);
+
+  const second = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(second.status, "dispatched");
+  if (second.status !== "dispatched") return;
+  assert.notEqual(second.run.runId, first.run.runId, "死 run 不许被并入，必须另开一条");
+  assert.equal(h.calls.length, 2);
+  // 聚合检测不擅自改别人的 run.json：这次并入失败，那条老 run 的 coverage 一个字都没动
+  assert.equal(readRun(h, first.run.runId).coverage, undefined);
+  assert.equal(h.events.filter((event) => event.kind === "merged").length, 0);
+});
+
+test("派发：同会话那条 run 已 analyzed（复盘确实跑完）→ 允许另开新 run", async () => {
+  const h = harness("analyzed");
+  const first = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(first.status, "dispatched");
+  if (first.status !== "dispatched") return;
+  // 复盘跑完 = 子进程已退出：先收尸放锁，再把状态写成 analyzed（复盘确实读到了产出）
+  h.children[0].emit("exit", 0);
+  await settleAsync();
+  h.setAlive(false);
+  assert.equal(patchRunRecordSync(first.run.runDir, { status: "analyzed" }), true);
+  h.tick(DEFAULT_CONFIG.idleMs + 1_000);
+
+  const second = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(second.status, "dispatched");
+  if (second.status !== "dispatched") return;
+  assert.notEqual(second.run.runId, first.run.runId);
+});
+
+test("派发：不同 sessionId 互不影响（各自照常派发）", async () => {
+  const h = harness("other-session");
+  const a = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  // s1 的子进程跑完退出（别让全局单飞闸挡住 s2 —— 它本来就该挡，这里测的是聚合不跨会话误判）
+  h.children[0].emit("exit", 0);
+  await settleAsync();
+  h.setAlive(false);
+  h.tick(DEFAULT_CONFIG.idleMs + 1_000);
+  const b = await h.dispatch({ sessionId: "s2", skills: ["a"] });
+  assert.equal(a.status, "dispatched");
+  assert.equal(b.status, "dispatched");
+  if (a.status !== "dispatched" || b.status !== "dispatched") return;
+  assert.notEqual(a.run.runId, b.run.runId);
+  assert.equal(h.calls.length, 2);
+  assert.equal(h.events.filter((event) => event.kind === "merged").length, 0);
+});
+
+test("退出补发：同样先过聚合检查，命中就只并轮次 + 写 merged 遥测", async () => {
+  const h = harness("shutdown");
+  const first = await h.dispatch({ sessionId: "s1", skills: ["a"] });
+  assert.equal(first.status, "dispatched");
+  if (first.status !== "dispatched") return;
+  const spawns = h.calls.length;
+
+  const result = flushPendingSync(
+    { sessionId: "s1", since: NOW - 1000, rounds: 2, skills: ["a"] },
+    {
+      evolutionDir: h.evolutionDir,
+      cwd: os.tmpdir(),
+      promptTemplatePath: TEMPLATE,
+      maxRuntimeMs: 20 * 60_000,
+      telemetry: { append: () => {}, appendSync: (event) => { h.events.push({ ...event, ts: NOW, iso: "" } as TelemetryEvent); }, flush: async () => undefined },
+      env: {},
+      spawnFn: (command, args, options) => {
+        h.calls.push({ command, args, options });
+        const child = new FakeChild(95_001 + h.children.length);
+        h.children.push(child);
+        return child as unknown as SpawnedChild;
+      },
+      autoReview: false,
+      alive: () => true,
+      log: (msg) => h.logs.push(msg),
+    },
+    NOW + 5_000,
+  );
+
+  assert.equal(result, "merged");
+  assert.equal(h.calls.length, spawns, "补发并入时不许再起子进程");
+  const coverage = readRun(h, first.run.runId).coverage as Record<string, unknown>;
+  // 在途 run 派发时覆盖 1 轮，补发这 2 轮并进去 → 3 轮
+  assert.deepEqual([coverage.rounds, coverage.merged], [3, 1]);
+  const merged = h.events.filter((event) => event.kind === "merged");
+  assert.deepEqual([merged[0]?.sessionId, merged[0]?.rounds], ["s1", 3]);
+});

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);
+});