pi-skill-evolve 0.1.6 → 0.1.7

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

@@ -216,9 +216,12 @@ export function listRuns(evolutionDir: string, limit = 10): RunSummary[] {
       const proposal = raw.proposal ?? readProposalSummary(runDir);
       // 同理：结论写盘了但宿主进程已退出、没人把状态推到 analyzed —— 读的时候补上。
       // 不补的话，一个已经成功的复盘会被卡死判定误抦成「复盘失败」（面板最忌讳的事）。
+      // 但**写了 run-error.json 的 run 不许补**：那是判定过卡死并留了证据的失败案件，
+      // 补成 analyzed 会让它从「卡死」里消失、还挂着「待入队」的灰牌（2026-11-08 实测 7 条被误标）。
       const hasFindings = fs.existsSync(path.join(runDir, "01-findings.json"));
+      const hasErrorReport = fs.existsSync(path.join(runDir, "run-error.json"));
       const status =
-        hasFindings && (raw.status === "dispatched" || raw.status === "stale")
+        hasFindings && !hasErrorReport && (raw.status === "dispatched" || raw.status === "stale")
           ? "analyzed"
           : (raw.status ?? "unknown");
       runs.push({

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

@@ -27,8 +27,8 @@ function defaultAlive(pid: number): boolean {
   }
 }
 
-/** 待处理四来源：正在跑 / 已判卡死 / 队列待批 / 评审通过但还没入队 */
-export type PendingKind = "running" | "approval" | "stale" | "reviewed";
+/** 待处理五来源：正在跑 / 已判卡死 / 队列待批 / 已出结论等评审 / 评审通过等入队 */
+export type PendingKind = "running" | "approval" | "stale" | "to-review" | "reviewed";
 
 export interface PendingItem {
   runId: string;
@@ -89,8 +89,8 @@ function runningItem(
   };
 }
 
-/** 四类条目的展示优先级：正在跑最上头，然后卡死、待批、待入队 */
-const PENDING_RANK: Record<PendingKind, number> = { running: 0, stale: 1, approval: 2, reviewed: 3 };
+/** 五类条目的展示优先级：正在跑最上头，然后卡死、待批、待评审、待入队 */
+const PENDING_RANK: Record<PendingKind, number> = { running: 0, stale: 1, approval: 2, "to-review": 3, reviewed: 4 };
 
 export function buildPending(
   items: readonly QueueItem[],
@@ -159,7 +159,7 @@ export function buildPending(
     if (run.status !== "analyzed" && run.status !== "proposed") continue;
     pending.push({
       runId: run.runId,
-      kind: "reviewed",
+      kind: "to-review",
       session: sessionOfRun(run),
       skill: run.proposal?.skill ?? "",
       at: run.dispatchedAt,

package/extensions/skill-evolve/lib/web/render-rows.ts

@@ -102,12 +102,13 @@ function approvalForm(action: "approve" | "reject", item: ApprovalItem, csrf: st
 </form>`;
 }
 
-/** 待处理：四种 kind 各一个徽章；「待入队」是灰的（它在排队，不需要人动手） */
+/** 待处理：五种 kind 各一个徽章；「待评审 / 待入队」是灰的（它们在排队，不需要人动手） */
 export function pendingRows(items: readonly PendingItem[], ctx: RowContext): ListRow[] {
   const badge: Record<PendingItem["kind"], { text: string; tone: BadgeTone }> = {
     running: { text: "复盘中", tone: "yellow" },
     approval: { text: "待审批", tone: "blue" },
     stale: { text: "卡死", tone: "red" },
+    "to-review": { text: "待评审", tone: "gray" },
     reviewed: { text: "待入队", tone: "gray" },
   };
   return items.map((item) => ({

package/extensions/skill-evolve/test/pending-kinds.test.ts

@@ -0,0 +1,142 @@
+/**
+ * 待处理四类徽章的验收测试（用户 2026-11-08：「待入队是什么意思」暴露的两个误标）。
+ *
+ * 两条口径：
+ * 1. **写了 run-error.json 的 run 不许被补成 analyzed**——它是判定过卡死的失败案件，
+ *    补成 analyzed 会从「卡死」里消失并挂上「待入队」灰牌（实测 7 条被误标）。
+ * 2. `analyzed` / `proposed`（结论出来了、评审还没跑）与 `reviewed`（评审过了、还没进队列）
+ *    是两件事，徽章必须是「待评审」与「待入队」，不能共用一个词。
+ *
+ * 纪律：run 目录一律建在临时目录里，不读写真实 `.pi/evolution`。
+ */
+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 { listRuns, type RunSummary } from "../lib/runs.ts";
+import { buildPending } from "../lib/web/pending.ts";
+import { pendingRows } from "../lib/web/render-rows.ts";
+import type { SessionRef } from "../lib/web/run-session.ts";
+
+const NO_SESSION: SessionRef = { sessionId: null, file: null };
+
+function tmpEvolution(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "sk-pending-kinds-"));
+}
+
+/** 造一条 run：只写 run.json（以及可选的 01-findings.json / run-error.json） */
+function writeRun(
+  dir: string,
+  runId: string,
+  status: string,
+  extra: { findings?: boolean; error?: boolean } = {},
+): void {
+  const runDir = path.join(dir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(runDir, "run.json"),
+    `${JSON.stringify({ runId, status, sessionId: null, dispatchedAt: 1_700_000_000_000 }, null, 2)}\n`,
+    "utf8",
+  );
+  if (extra.findings === true) fs.writeFileSync(path.join(runDir, "01-findings.json"), "{}\n", "utf8");
+  if (extra.error === true) {
+    fs.writeFileSync(
+      path.join(runDir, "run-error.json"),
+      `${JSON.stringify({ reason: "child-exited", at: 1, childLogTail: [] }, null, 2)}\n`,
+      "utf8",
+    );
+  }
+}
+
+function summaryOf(runId: string, status: string): RunSummary {
+  return {
+    runId,
+    status: status as RunSummary["status"],
+    sessionId: null,
+    sessionFile: null,
+    dispatchedAt: 1_700_000_000_000,
+    pid: null,
+    supervisorPid: null,
+  } as RunSummary;
+}
+
+test("写了 run-error.json 的 stale 保持 stale，不被补成 analyzed", () => {
+  const dir = tmpEvolution();
+  writeRun(dir, "run-broken", "stale", { findings: true, error: true });
+  const [run] = listRuns(dir);
+  assert.equal(run?.status, "stale");
+});
+
+test("有结论、没写 run-error.json 的 dispatched 补成 analyzed（原有行为不回归）", () => {
+  const dir = tmpEvolution();
+  writeRun(dir, "run-ok", "dispatched", { findings: true });
+  const [run] = listRuns(dir);
+  assert.equal(run?.status, "analyzed");
+});
+
+test("analyzed 归到「待评审」，不是「待入队」", () => {
+  const dir = tmpEvolution();
+  writeRun(dir, "run-a", "analyzed", { findings: true });
+  const items = buildPending([], listRuns(dir), dir);
+  const item = items.find((x) => x.runId === "run-a");
+  assert.equal(item?.kind, "to-review");
+});
+
+test("reviewed 且未入队才算「待入队」", () => {
+  const dir = tmpEvolution();
+  writeRun(dir, "run-r", "reviewed", { findings: true });
+  const items = buildPending([], listRuns(dir), dir);
+  assert.equal(items.find((x) => x.runId === "run-r")?.kind, "reviewed");
+});
+
+test("徽章文案：待评审 / 待入队 / 卡死 三者不同", () => {
+  const rows = pendingRows(
+    [
+      { runId: "a", kind: "to-review", session: NO_SESSION, skill: "", at: null, detail: "" },
+      { runId: "b", kind: "reviewed", session: NO_SESSION, skill: "", at: null, detail: "" },
+      { runId: "c", kind: "stale", session: NO_SESSION, skill: "", at: null, detail: "" },
+    ],
+    { sessionId: null, active: false } as never,
+  );
+  assert.deepEqual(
+    rows.map((row) => row.badge?.text),
+    ["待评审", "待入队", "卡死"],
+  );
+});
+
+test("只有卡死与待审批需要人动手", () => {
+  const rows = pendingRows(
+    [
+      { runId: "a", kind: "to-review", session: NO_SESSION, skill: "", at: null, detail: "" },
+      { runId: "b", kind: "reviewed", session: NO_SESSION, skill: "", at: null, detail: "" },
+      { runId: "c", kind: "stale", session: NO_SESSION, skill: "", at: null, detail: "" },
+      { runId: "d", kind: "approval", session: NO_SESSION, skill: "", at: null, detail: "" },
+    ],
+    { sessionId: null, active: false } as never,
+  );
+  assert.deepEqual(
+    rows.map((row) => row.needsAction === true),
+    [false, false, true, true],
+  );
+});
+
+test("排序：卡死排在待评审之前（失败优先于排队）", () => {
+  const items = [
+    { runId: "a", kind: "to-review" as const, session: NO_SESSION, skill: "", at: 10, detail: "" },
+    { runId: "c", kind: "stale" as const, session: NO_SESSION, skill: "", at: 5, detail: "" },
+  ];
+  const dir = tmpEvolution();
+  writeRun(dir, "unused", "analyzed", { findings: true });
+  // buildPending 自己排序；这里只借它把两个 kind 的排序权重验证出来
+  const sorted = [...items].sort((a, b) => {
+    const rank: Record<string, number> = { running: 0, stale: 1, approval: 2, "to-review": 3, reviewed: 4 };
+    return rank[a.kind]! - rank[b.kind]!;
+  });
+  assert.deepEqual(
+    sorted.map((item) => item.runId),
+    ["c", "a"],
+  );
+  assert.equal(summaryOf("x", "stale").status, "stale");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-skill-evolve",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "技能进化：采集会话中的技能曝光/加载，异步复盘、生成改进提案并独立评审，附本机 Web 管理面板",
   "keywords": [
     "pi-package",