pi-skill-evolve 0.1.4 → 0.1.5

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

@@ -0,0 +1,153 @@
+/**
+ * 同会话聚合检测：同一个会话已经有在途复盘时，本轮**并入**它，不再另开一条 run。
+ *
+ * 为什么需要（用户 2026-11-08：「如果是同一会话产生的多个, 并且他还没开始跑复盘, 会导致一会话多次跑复盘」）：
+ * runId 是 `会话哈希8-时间戳`，每轮结算都算出一个新的；全局单飞闸只保证「同时只有一个子进程」，
+ * 挡不住「队列里排着同一个会话的好几条」。真实现场（2026-11-08 的 vkk_client_flutter 工作区）：
+ * 同一个 sessionId 下堆了 1 条 analyzed + 7 条 stale，同一段会话被反反复复复盘。
+ *
+ * 三条边界，缺一条就会误并：
+ * ① 只并 in-flight（status=dispatched）的 run；analyzed / proposed / reviewed 表示复盘确实跑完了，
+ *    那是新的一轮对话，允许另开；
+ * ② 只并**子进程还活着**的 run：pid 已死说明它已经是尸体，交给 lib/stale.ts 标 stale，本轮照旧另开；
+ * ③ 01-findings.json 已落盘的一律不并 —— 状态可能还没被回写，判据与 runs.ts 的 listRuns 同一口径。
+ *
+ * 为什么这里用同步 fs：两个调用点（异步派发 / 退出前同步补发）必须给出**同一个**判定，
+ * 拆成异步 + 同步两套实现迟早分叉；扫描量是 runs/ 下 ≤100 个 run.json，同步读的代价远小于分叉的代价。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isPidAlive } from "./lock.ts";
+import { parseCoverage, patchRunRecordSync, type RunCoverage } from "./runs.ts";
+import type { TelemetryWriter } from "./telemetry.ts";
+
+/** 只有这个状态算「复盘还在跑」：analyzed 起都是跑完了 */
+export const IN_FLIGHT_STATUS = "dispatched";
+/** 扫描上限：与面板同一个量级，够了；runs/ 里可能有几百个历史目录 */
+const MAX_SCAN = 100;
+
+export interface AggregateRun {
+  runId: string;
+  runDir: string;
+  sessionId: string;
+  status: string;
+  pid: number | null;
+  dispatchedAt: number;
+  /** 01-findings.json 已落盘 = 复盘其实已经跑完（run.json 的状态可能还没被回写） */
+  hasFindings: boolean;
+  /** run.json 里已有的覆盖轮数（并入时要在它上面累加） */
+  coverage: RunCoverage | null;
+}
+
+/** 扫 runs/ 下最近 MAX_SCAN 条；run.json 缺失或坏掉一律跳过（坏记录不能伪造出一条在途 run） */
+export function readAggregateRuns(evolutionDir: string): AggregateRun[] {
+  const runsDir = path.join(evolutionDir, "runs");
+  let names: string[];
+  try {
+    names = fs.readdirSync(runsDir);
+  } catch {
+    return [];
+  }
+  const runs: AggregateRun[] = [];
+  for (const name of names) {
+    const runDir = path.join(runsDir, name);
+    let raw: Record<string, unknown>;
+    try {
+      raw = JSON.parse(fs.readFileSync(path.join(runDir, "run.json"), "utf8")) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+    runs.push({
+      runId: typeof raw.runId === "string" ? raw.runId : name,
+      runDir,
+      sessionId: typeof raw.sessionId === "string" ? raw.sessionId : "",
+      status: typeof raw.status === "string" ? raw.status : "unknown",
+      pid: typeof raw.pid === "number" ? raw.pid : null,
+      dispatchedAt: typeof raw.dispatchedAt === "number" ? raw.dispatchedAt : 0,
+      hasFindings: fs.existsSync(path.join(runDir, "01-findings.json")),
+      coverage: parseCoverage(raw.coverage),
+    });
+  }
+  return runs.sort((a, b) => b.dispatchedAt - a.dispatchedAt).slice(0, MAX_SCAN);
+}
+
+/** 纯函数：找「同一会话、复盘还在跑、子进程活着」的那条 run；多条命中时取最近派发的 */
+export function findSameSessionRun(
+  runs: readonly AggregateRun[],
+  sessionId: string,
+  isAlive: (pid: number) => boolean,
+  now: number,
+): AggregateRun | null {
+  let found: AggregateRun | null = null;
+  for (const run of runs) {
+    if (run.sessionId !== sessionId) continue;
+    if (run.status !== IN_FLIGHT_STATUS || run.hasFindings) continue;
+    if (run.pid === null || !isAlive(run.pid)) continue;
+    // 时钟回拨写出来的「未来」派发时刻无法判断真伪：宁可不并（另开一条至少看得见）
+    if (run.dispatchedAt > now) continue;
+    if (found === null || run.dispatchedAt > found.dispatchedAt) found = run;
+  }
+  return found;
+}
+
+export interface MergeRoundInput {
+  evolutionDir: string;
+  sessionId: string;
+  /** 本次要记的轮次总数（本轮 + 之前被去抖挡下的轮数） */
+  rounds: number;
+  now: number;
+  /** pid 存活判定（默认 kill(pid,0)；单测注入，测试里不起真进程） */
+  isAlive?: (pid: number) => boolean;
+  telemetry?: TelemetryWriter;
+  log?: (msg: string) => void;
+}
+
+export interface MergeOutcome {
+  runId: string;
+  /** 并入后的累计轮数 */
+  rounds: number;
+}
+
+/**
+ * 读盘 → 判定 → 打补丁。没命中返回 null，调用方照旧派生新 run。
+ * 任何异常都吞掉并按「未命中」处理：聚合是省一次复盘，不能反过来把派发流程搞挂。
+ */
+export function mergeRoundIntoRun(input: MergeRoundInput): MergeOutcome | null {
+  try {
+    const target = findSameSessionRun(
+      readAggregateRuns(input.evolutionDir),
+      input.sessionId,
+      input.isAlive ?? isPidAlive,
+      input.now,
+    );
+    if (target === null) return null;
+    const coverage = mergedCoverage(target, input);
+    // run.json 读不到了：按未命中处理，走老路另开一条（宁可多一条看得见的 run，也不静默吞掉这一轮）
+    if (!patchRunRecordSync(target.runDir, { coverage })) return null;
+    input.telemetry?.append({ kind: "merged", sessionId: input.sessionId, runId: target.runId, rounds: coverage.rounds });
+    input.log?.(
+      `[skill-evolve] 同会话已有在途复盘 ${target.runId}，本轮并入（共 ${coverage.rounds} 轮），不再派生`,
+    );
+    return { runId: target.runId, rounds: coverage.rounds };
+  } catch (error) {
+    input.log?.(`[skill-evolve] 同会话聚合检测失败（按未命中处理）：${String(error)}`);
+    return null;
+  }
+}
+
+/**
+ * 并入后的 coverage：在已有轮数上**累加**本次并入的轮数。
+ *
+ * `rounds` 必须做加法而不是取 max：那条在途 run 派发时已经覆盖了 1 轮（run.json 里可能还没有
+ * coverage 字段，那就按 1 算），本次再并入 pending 里的 N 轮，总数是 1 + N。
+ * `since` 保留原起点（区间起点不变，只是末尾又长了一截）。
+ */
+function mergedCoverage(target: AggregateRun, input: MergeRoundInput): RunCoverage {
+  const base = target.coverage;
+  return {
+    rounds: (base?.rounds ?? 1) + input.rounds,
+    since: base?.since ?? target.dispatchedAt,
+    lastAt: input.now,
+    merged: (base?.merged ?? 0) + 1,
+  };
+}

package/extensions/skill-evolve/lib/dispatch-types.ts

@@ -0,0 +1,65 @@
+/**
+ * 派发层的类型：输入 / 依赖 / 结果。
+ *
+ * 为什么单独一个文件：dispatch.ts 已经贴着 300 行闸门，而这几块是**纯声明**（没有一行逻辑），
+ * 搬出来不改变任何行为；dispatch.ts 仍然把它们原样再导出，调用方按老路径取类型不受影响。
+ */
+import type { Attribution } from "./attribution.ts";
+import type { EvolutionConfig } from "./config.ts";
+import type { RunRecord } from "./runs.ts";
+import type { SpawnLike } from "./spawn-plan.ts";
+import type { SupervisorSpawn } from "./review-spawn.ts";
+import type { MutationQueue, TelemetryWriter } from "./telemetry.ts";
+
+export interface DispatchInput {
+  sessionId: string;
+  skills: string[];
+  sessionFile?: string;
+  /** 已经机械归因过的技能（A~E）：写进 prompt，复盘 agent 不必重判 */
+  attributions?: Attribution[];
+}
+
+export interface DispatchDeps {
+  evolutionDir: string;
+  cwd: string;
+  config: EvolutionConfig;
+  telemetry: TelemetryWriter;
+  queue: MutationQueue;
+  promptTemplatePath: string;
+  log?: (msg: string) => void;
+  now?: () => number;
+  env?: NodeJS.ProcessEnv;
+  spawnFn?: SpawnLike;
+  /** 评审模型（"inherit" 或 provider/model）：每次派生现取，配置改动立即生效 */
+  reviewModel?: () => string;
+  /** 必红自检没过 → 整条流水线停用（设计稿 12.4） */
+  selftestFailed?: () => boolean;
+  /** 评审督导的 spawn（默认 node spawn；单测注入假实现） */
+  supervisorSpawnFn?: SupervisorSpawn;
+  /** pid 存活判定（全局单飞闸用；单测注入，测试里不起真子进程） */
+  alive?: (pid: number) => boolean;
+}
+
+export interface DispatchedRun {
+  runId: string;
+  runDir: string;
+  pid: number | null;
+}
+
+/** 派发结果：调用方（命令 / 事件）要据此出文案，所以不能再只用 null 表示「没派」 */
+export type DispatchOutcome =
+  | { status: "dispatched"; run: DispatchedRun }
+  | {
+      status: "skipped";
+      why: "disabled" | "cap" | "lock" | "lock-error" | "selftest-failed" | "busy";
+      ownerPid: number | null;
+    }
+  | { status: "superseded"; rounds: number }
+  /** 同一会话已有在途复盘：这一轮并进去了，既没建新 run 也没起进程（见 lib/aggregate.ts） */
+  | { status: "merged"; runId: string; rounds: number };
+
+export interface DispatchOptions {
+  /** 手动 `/skill-evolve run`：跳过去抖与单会话上限，但**仍必须守全局锁** */
+  bypassThrottle?: boolean;
+  trigger?: RunRecord["trigger"];
+}

package/extensions/skill-evolve/lib/dispatch.ts

@@ -10,67 +10,23 @@
  */
 import { spawn } from "node:child_process";
 import * as path from "node:path";
-import { mergeAttributions, type Attribution } from "./attribution.ts";
-import type { EvolutionConfig } from "./config.ts";
+import { mergeRoundIntoRun } from "./aggregate.ts";
+import { mergeAttributions } from "./attribution.ts";
 import { acquireLock, releaseLock, writeOwnerSync } from "./lock.ts";
 import { buildPrompt, readPromptTemplateSync } from "./prompt.ts";
-import { writeRunRecord, type RunRecord } from "./runs.ts";
+import { writeRunRecord } from "./runs.ts";
 import { writeSessionIndex } from "./session-index.ts";
-import { CHILD_LOG, resolvePiBin, spawnDetached, uniqueRunId, sessionHashOf, type SpawnLike } from "./spawn-plan.ts";
+import { CHILD_LOG, resolvePiBin, spawnDetached, uniqueRunId, sessionHashOf } from "./spawn-plan.ts";
 import { mergePendingRounds } from "./pending.ts";
 import { watchRunChild } from "./run-watch.ts";
-import { spawnReviewSupervisor, type SupervisorSpawn } from "./review-spawn.ts";
+import { spawnReviewSupervisor } from "./review-spawn.ts";
 import { guardBusy } from "./single-flight.ts";
 import { drainPending } from "./drain-pending.ts";
 import type { PendingRounds } from "./shutdown-dispatch.ts";
-import type { MutationQueue, TelemetryWriter } from "./telemetry.ts";
+import type { DispatchDeps, DispatchInput, DispatchOptions, DispatchOutcome } from "./dispatch-types.ts";
 
-export interface DispatchInput {
-  sessionId: string;
-  skills: string[];
-  sessionFile?: string;
-  /** 已经机械归因过的技能（A~E）：写进 prompt，复盘 agent 不必重判 */
-  attributions?: Attribution[];
-}
-
-export interface DispatchDeps {
-  evolutionDir: string;
-  cwd: string;
-  config: EvolutionConfig;
-  telemetry: TelemetryWriter;
-  queue: MutationQueue;
-  promptTemplatePath: string;
-  log?: (msg: string) => void;
-  now?: () => number;
-  env?: NodeJS.ProcessEnv;
-  spawnFn?: SpawnLike;
-  /** 评审模型（"inherit" 或 provider/model）：每次派生现取，配置改动立即生效 */
-  reviewModel?: () => string;
-  /** 必红自检没过 → 整条流水线停用（设计稿 12.4） */
-  selftestFailed?: () => boolean;
-  /** 评审督导的 spawn（默认 node spawn；单测注入假实现） */
-  supervisorSpawnFn?: SupervisorSpawn;
-  /** pid 存活判定（全局单飞闸用；单测注入，测试里不起真子进程） */
-  alive?: (pid: number) => boolean;
-}
-
-export interface DispatchedRun {
-  runId: string;
-  runDir: string;
-  pid: number | null;
-}
-
-/** 派发结果：调用方（命令 / 事件）要据此出文案，所以不能再只用 null 表示「没派」 */
-export type DispatchOutcome =
-  | { status: "dispatched"; run: DispatchedRun }
-  | { status: "skipped"; why: "disabled" | "cap" | "lock" | "lock-error" | "selftest-failed" | "busy"; ownerPid: number | null }
-  | { status: "superseded"; rounds: number };
-
-export interface DispatchOptions {
-  /** 手动 `/skill-evolve run`：跳过去抖与单会话上限，但**仍必须守全局锁** */
-  bypassThrottle?: boolean;
-  trigger?: RunRecord["trigger"];
-}
+// 类型都搬到了 ./dispatch-types.ts（本文件贴着 300 行闸门），这里原样再导出，调用方路径不变
+export type { DispatchInput, DispatchDeps, DispatchedRun, DispatchOutcome, DispatchOptions } from "./dispatch-types.ts";
 
 /** 去抖：窗口内又结束一轮，只更新 pending，不再叠加进程 */
 export function shouldDebounce(lastDispatchAt: number | undefined, now: number, idleMs: number): boolean {
@@ -106,6 +62,26 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
     return merged;
   };
 
+  /**
+   * 并入在途复盘的这一轮：不建 run、不抢锁、不起进程，只把轮数累加进那条 run 的 coverage。
+   * 手动 `/skill-evolve run` 也走这道检查 —— 「立刻复盘」不该变成「同一会话并行两条」。
+   */
+  const tryMerge = (input: DispatchInput, at: number): DispatchOutcome | null => {
+    const result = mergeRoundIntoRun({
+      evolutionDir: deps.evolutionDir,
+      sessionId: input.sessionId,
+      // 本轮 + 之前被去抖挡下、还没派出去的轮次
+      rounds: (pending.get(input.sessionId)?.rounds ?? 0) + 1,
+      now: at,
+      telemetry: deps.telemetry,
+      log,
+      ...(deps.alive ? { isAlive: deps.alive } : {}),
+    });
+    if (result === null) return null;
+    pending.delete(input.sessionId);
+    return { status: "merged", runId: result.runId, rounds: result.rounds };
+  };
+
   const run = async (input: DispatchInput, options: DispatchOptions = {}): Promise<DispatchOutcome> => {
     const at = now();
     const bypass = options.bypassThrottle === true;
@@ -144,6 +120,10 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
       }
     }
 
+    // 同会话聚合：已有在途复盘就把这一轮并进去（放单飞闸之前 —— 单飞闸只会回一句 busy 然后丢掉这一轮）
+    const merged = tryMerge(input, at);
+    if (merged) return merged;
+
     // 全局单飞（跨会话也成立）：已有复盘或督导在跑这一轮就不叠进程；放去抖 / 上限之后，那两条是「本轮不派」的既定语义
     const occupant = guardBusy({ evolutionDir: deps.evolutionDir, sessionId: input.sessionId, telemetry: deps.telemetry, trigger, alive: deps.alive, log });
     if (occupant) return { status: "skipped", why: "busy", ownerPid: occupant.pid };

package/extensions/skill-evolve/lib/evolution.ts

@@ -218,6 +218,7 @@ export function createEvolution(deps: EvolutionDeps): Evolution {
       })
       .then((outcome) => {
         if (outcome.status === "skipped") log(`[skill-evolve] 本轮未派生：${outcome.why}`);
+        // merged：并入在途 run 的日志由派发器打（那里能看到轮数），这里不重复
         else if (outcome.status === "dispatched") observer.noteDispatched(outcome.run.runId);
       })
       .catch((error: unknown) => recordHandlerError("dispatch", error));

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

@@ -161,7 +161,7 @@ export function renderReport(input: ReportInput): string {
   ].join("\n");
 }
 
-/** 手动 `/skill-evolve run` 的回执：把三种 outcome 翻译成一句人话（CLI 回显用） */
+/** 手动 `/skill-evolve run` 的回执：把四种 outcome 翻译成一句人话（CLI 回显用） */
 export function renderManualDispatch(outcome: DispatchOutcome): string {
   if (outcome.status === "dispatched") {
     const { runId, pid, runDir } = outcome.run;
@@ -176,5 +176,8 @@ export function renderManualDispatch(outcome: DispatchOutcome): string {
     }
     return `本次未派发：${outcome.why}`;
   }
+  if (outcome.status === "merged") {
+    return `同一会话已有在途复盘 ${outcome.runId}：本轮并进去了（共 ${outcome.rounds} 轮），不再另派`;
+  }
   return `本轮已在待复盘区间里（累计 ${outcome.rounds} 轮），静默窗口过后会自动补一次`;
 }

package/extensions/skill-evolve/lib/runs.ts

@@ -37,6 +37,20 @@ export interface RunStage {
   ms: number;
 }
 
+/**
+ * 覆盖轮数：`rounds` 是这条 run 一共复盘了几轮，`merged` 是其中有多少轮属于
+ * 「同一会话已有在途复盘」被并进来的（见 lib/aggregate.ts）。
+ */
+export interface RunCoverage {
+  rounds: number;
+  /** 覆盖起点：第一次被挡下的时刻（缺省同 dispatchedAt） */
+  since: number;
+  /** 最近一次并进新轮次的时刻 */
+  lastAt?: number;
+  /** 其中有多少轮是并入在途 run 的（缺省 0） */
+  merged?: number;
+}
+
 export interface RunRecord {
   runId: string;
   status: RunStatus;
@@ -54,8 +68,8 @@ export interface RunRecord {
   supervisorPid?: number | null;
   cwd: string;
   skills: string[];
-  /** 去抖合并掉的轮次范围（缺省 = 只覆盖刚结束的 1 轮） */
-  coverage?: { rounds: number; since: number };
+  /** 去抖合并 / 同会话聚合记下的轮次范围（缺省 = 只覆盖刚结束的 1 轮） */
+  coverage?: RunCoverage;
   stages: RunStage[];
   artifacts: Record<string, string>;
   /** M3：复盘子进程产出提案后回写（{type, skill, status, added, removed, file}） */
@@ -79,6 +93,10 @@ export interface RunSummary {
   status: string;
   dispatchedAt: number | null;
   sessionId: string;
+  /** 会话原文的绝对路径：面板据此打开「会话详情」页（同会话聚合也要它） */
+  sessionFile: string | null;
+  /** 复盘的轮次覆盖（缺省 null = 只覆盖 1 轮，没被并过） */
+  coverage: RunCoverage | null;
   /** 子进程 pid：面板靠它判「还活着吗」（见 lib/stale.ts） */
   pid: number | null;
   /** 评审督导 pid：面板据此把阶段标成「评审中」 */
@@ -167,6 +185,19 @@ export async function updateRunStatus(
   return found;
 }
 
+/** run.json 里的 coverage：字段缺失或类型不对一律当 null（坏数据当空，不让它污染展示） */
+export function parseCoverage(value: unknown): RunCoverage | null {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value as Record<string, unknown>;
+  if (typeof record.rounds !== "number" || typeof record.since !== "number") return null;
+  return {
+    rounds: record.rounds,
+    since: record.since,
+    ...(typeof record.lastAt === "number" ? { lastAt: record.lastAt } : {}),
+    ...(typeof record.merged === "number" ? { merged: record.merged } : {}),
+  };
+}
+
 /** 按派生时间倒序列出最近若干个 run（run.json 坏掉的目录直接跳过） */
 export function listRuns(evolutionDir: string, limit = 10): RunSummary[] {
   const dir = path.join(evolutionDir, "runs");
@@ -195,6 +226,8 @@ export function listRuns(evolutionDir: string, limit = 10): RunSummary[] {
         status,
         dispatchedAt: typeof raw.dispatchedAt === "number" ? raw.dispatchedAt : null,
         sessionId: raw.sessionId ?? "",
+        sessionFile: typeof raw.sessionFile === "string" ? raw.sessionFile : null,
+        coverage: parseCoverage(raw.coverage),
         pid: typeof raw.pid === "number" ? raw.pid : null,
         supervisorPid: typeof raw.supervisorPid === "number" ? raw.supervisorPid : null,
         ...(proposal ? { proposal } : {}),

package/extensions/skill-evolve/lib/shutdown-dispatch.ts

@@ -7,6 +7,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { mergeRoundIntoRun } from "./aggregate.ts";
 import type { Attribution } from "./attribution.ts";
 import { acquireLockSync, releaseLockSync, writeOwnerSync } from "./lock.ts";
 import { buildPrompt, readPromptTemplateSync } from "./prompt.ts";
@@ -48,10 +49,32 @@ export interface ShutdownDeps {
   log: (msg: string) => void;
 }
 
-export type ShutdownResult = "dispatched" | "skipped" | "failed";
+/** `merged`：同一会话已有在途复盘，这次补发的轮次并进去了（不建 run、不起进程） */
+export type ShutdownResult = "dispatched" | "skipped" | "failed" | "merged";
 
 /** 同步补发一次：任何异常都在内部吞掉，绝不阻塞退出、绝不抛给调用方 */
 export function flushPendingSync(item: PendingRounds, deps: ShutdownDeps, now: number): ShutdownResult {
+  // 同会话聚合：已有在途复盘就把这几轮并进去（与异步派发同一判定，见 lib/aggregate.ts）
+  const merged = mergeRoundIntoRun({
+    evolutionDir: deps.evolutionDir,
+    sessionId: item.sessionId,
+    rounds: item.rounds,
+    now,
+    ...(deps.alive ? { isAlive: deps.alive } : {}),
+    log: deps.log,
+  });
+  if (merged) {
+    // 退出路径必须同步落盘：异步队列很可能来不及写，进程就没了
+    deps.telemetry.appendSync({
+      kind: "merged",
+      ts: now,
+      sessionId: item.sessionId,
+      runId: merged.runId,
+      rounds: merged.rounds,
+    });
+    return "merged";
+  }
+
   // 全局单飞：退出补发也不能叠进程（已有活的复盘 / 督导就放弃本次，不建目录不抢锁）
   const occupant = guardBusy({
     evolutionDir: deps.evolutionDir,

package/extensions/skill-evolve/lib/telemetry.ts

@@ -21,6 +21,8 @@ export type TelemetryKind =
   | "missed"
   | "pending"
   | "dispatched"
+  /** 同会话聚合：{kind:"merged", runId, sessionId, rounds} —— 这一轮并进了已有的在途 run */
+  | "merged"
   | "skipped"
   | "superseded"
   | "handler_error"

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

@@ -11,6 +11,7 @@ import { readVerify } from "../apply.ts";
 import { readProposalSummary } from "../proposal.ts";
 import type { QueueItem } from "../queue.ts";
 import { asNumber, asText, readJson } from "./json-read.ts";
+import { readRunSession, type SessionRef } from "./run-session.ts";
 
 /** 已采纳列表上限：与 DONE_LIMIT 同量级 —— 网页看近期，不是审计日志 */
 export const APPLIED_LIMIT = 50;
@@ -18,6 +19,8 @@ export const APPLIED_LIMIT = 50;
 /** 一个已采纳条目：技能 · 提案类型 · +N/-M · 采纳时间 · 五闸是否全 ok */
 export interface AppliedItem {
   runId: string;
+  /** 这条 run 是哪个会话跑出来的：行上「会话」列要用（缺 = NO_SESSION） */
+  session: SessionRef;
   /** auto（不需要人） / approval（人批） */
   level: string;
   skill: string;
@@ -50,6 +53,7 @@ export function buildApplied(items: readonly QueueItem[], evolutionDir: string):
       : [];
     rows.push({
       runId: item.runId,
+      session: readRunSession(runDir),
       level: item.level,
       skill: item.skill.length > 0 ? item.skill : (proposal?.skill ?? ""),
       type: proposal?.type ?? asText(item.proposalType, "—"),

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

@@ -11,9 +11,12 @@ import * as path from "node:path";
 import type { QueueItem } from "../queue.ts";
 import { readProposalSummary } from "../proposal.ts";
 import { asNumber, asText, readJson } from "./json-read.ts";
+import { readRunSession, type SessionRef } from "./run-session.ts";
 
 export interface ApprovalItem {
   runId: string;
+  /** 这条 run 是哪个会话跑出来的：行上「会话」列要用（缺 = NO_SESSION） */
+  session: SessionRef;
   skill: string;
   level: string;
   /** 相对仓库根的落盘目标（队列里就存着，不重算） */
@@ -46,6 +49,7 @@ export function buildApprovals(evolutionDir: string, items: readonly QueueItem[]
       const summary = readProposalSummary(runDir);
       return {
         runId: item.runId,
+        session: readRunSession(runDir),
         skill: item.skill,
         level: item.level,
         targets: item.targets,