pi-skill-evolve 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,208 @@
+/**
+ * run 记录（`runs/<runId>/run.json`）的读写：
+ * 状态机 dispatched → analyzed / proposed → reviewed / rejected / review_failed（或任一步 abandoned）。
+ *
+ * 拆成独立文件是为了让 dispatch.ts（派生流程）与 evolution.ts（状态/报告）共用同一套
+ * 序列化口径，同时把 dispatch.ts 压在 300 行以内。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readProposalSummary, type ProposalSummary } from "./proposal.ts";
+import type { SupervisorStatus } from "./review-record.ts";
+import type { ActionLevel } from "./classify-action.ts";
+import type { MutationQueue } from "./telemetry.ts";
+
+export const RUN_STATUSES = [
+  "dispatched",
+  "analyzed",
+  "proposed",
+  "reviewed",
+  "rejected",
+  "review_failed",
+  "abandoned",
+  // M5 采纳结果（闸门逐闸推进，见 apply.ts）
+  "applied",
+  "rolled-back",
+  "unauthorized_write",
+  "failed",
+  // 卡死（子进程已死 / 超时）：判定见 lib/stale.ts，不自动重跑
+  "stale",
+] as const;
+export type RunStatus = (typeof RUN_STATUSES)[number];
+
+export interface RunStage {
+  name: string;
+  model: string | null;
+  usage: unknown;
+  ms: number;
+}
+
+export interface RunRecord {
+  runId: string;
+  status: RunStatus;
+  /** 谁触发的：自动结算 / 手动命令 / 退出前补发 —— 报告里能区分别把“手动兜底”当自动行为 */
+  trigger: "auto" | "manual" | "shutdown";
+  sessionId: string;
+  sessionHash: string;
+  sessionFile: string | null;
+  /** 会话原文不可读时降级为 telemetry-only，报告里要写明 */
+  evidenceMode: "session+telemetry" | "telemetry-only";
+  dispatchedAt: number;
+  dispatchedAtIso: string;
+  pid: number | null;
+  /** 评审督导 pid（全局单飞闸的第二个占用位）：派发时写入，督导退出/失败时清成 null */
+  supervisorPid?: number | null;
+  cwd: string;
+  skills: string[];
+  /** 去抖合并掉的轮次范围（缺省 = 只覆盖刚结束的 1 轮） */
+  coverage?: { rounds: number; since: number };
+  stages: RunStage[];
+  artifacts: Record<string, string>;
+  /** M3：复盘子进程产出提案后回写（{type, skill, status, added, removed, file}） */
+  proposal?: ProposalSummary;
+  /** M4：评审督导回写（只给建议动作，本版一律不写 .pi/skills） */
+  review?: RunReview;
+  abandonedReason?: string;
+}
+
+export interface RunReview {
+  status: SupervisorStatus;
+  verdict: string | null;
+  action: ActionLevel | null;
+  reviewerModel: string;
+  proposerModel: string;
+  sameModel: boolean;
+}
+
+export interface RunSummary {
+  runId: string;
+  status: string;
+  dispatchedAt: number | null;
+  sessionId: string;
+  /** 子进程 pid：面板靠它判「还活着吗」（见 lib/stale.ts） */
+  pid: number | null;
+  /** 评审督导 pid：面板据此把阶段标成「评审中」 */
+  supervisorPid: number | null;
+  /** 本轮产出的提案摘要（M3）：只用于展示，不应用 */
+  proposal?: ProposalSummary;
+  /** 本轮评审结论（M4）：只用于展示，不应用 */
+  review?: RunReview;
+}
+
+export async function writeRunRecord(runDir: string, record: RunRecord, queue: MutationQueue): Promise<void> {
+  const file = path.join(runDir, "run.json");
+  await queue(file, async () => {
+    await fs.promises.mkdir(runDir, { recursive: true });
+    await fs.promises.writeFile(file, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+  });
+}
+
+/** 同步写 run.json：只给退出前补发用（主进程马上退出，不能等异步队列） */
+export function writeRunRecordSync(runDir: string, record: RunRecord): void {
+  const file = path.join(runDir, "run.json");
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+}
+
+/**
+ * 同步打补丁：只改给定字段，其余原样保留（督导 pid 的写入 / 清除走这条）。
+ * 读不到 run.json 就返回 false，不凭空造记录。
+ */
+export function patchRunRecordSync(runDir: string, patch: Record<string, unknown>): boolean {
+  const file = path.join(runDir, "run.json");
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+    Object.assign(raw, patch);
+    writeRunRecordSync(runDir, raw as unknown as RunRecord);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 记容器的失败态：写不进去只记日志，绝不让「收尸」这一步反过来把主流程搞挂 */
+export async function markRunAbandoned(
+  runDir: string,
+  reason: string,
+  queue: MutationQueue,
+  log: (msg: string) => void,
+): Promise<void> {
+  try {
+    const record = JSON.parse(await fs.promises.readFile(path.join(runDir, "run.json"), "utf8")) as RunRecord;
+    record.status = "abandoned";
+    record.abandonedReason = reason;
+    await writeRunRecord(runDir, record, queue);
+  } catch (error) {
+    log(`[skill-evolve] 标记 abandoned 失败：${String(error)}`);
+  }
+}
+
+/** 采纳后回写状态：只改 status 与可选补丁字段，其余字段原样保留 */
+export async function updateRunStatus(
+  evolutionDir: string,
+  runId: string,
+  status: RunStatus,
+  queue: MutationQueue,
+  patch: Record<string, unknown> = {},
+): Promise<boolean> {
+  const runDir = path.join(evolutionDir, "runs", runId);
+  const file = path.join(runDir, "run.json");
+  let found = false;
+  try {
+    await queue(file, async () => {
+      let raw: Record<string, unknown>;
+      try {
+        raw = JSON.parse(await fs.promises.readFile(file, "utf8")) as Record<string, unknown>;
+      } catch {
+        return; // run.json 不在：不凭空造一条假记录
+      }
+      found = true;
+      raw.status = status;
+      Object.assign(raw, patch);
+      await fs.promises.writeFile(file, `${JSON.stringify(raw, null, 2)}\n`, "utf8");
+    });
+  } catch {
+    return false;
+  }
+  return found;
+}
+
+/** 按派生时间倒序列出最近若干个 run（run.json 坏掉的目录直接跳过） */
+export function listRuns(evolutionDir: string, limit = 10): RunSummary[] {
+  const dir = path.join(evolutionDir, "runs");
+  let names: string[];
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const runs: RunSummary[] = [];
+  for (const name of names) {
+    const runDir = path.join(dir, name);
+    try {
+      const raw = JSON.parse(fs.readFileSync(path.join(runDir, "run.json"), "utf8")) as Partial<RunRecord>;
+      // 子进程可能只写了 02-proposal.json 而没回写 run.json，所以两处都要看
+      const proposal = raw.proposal ?? readProposalSummary(runDir);
+      // 同理：结论写盘了但宿主进程已退出、没人把状态推到 analyzed —— 读的时候补上。
+      // 不补的话，一个已经成功的复盘会被卡死判定误抦成「复盘失败」（面板最忌讳的事）。
+      const hasFindings = fs.existsSync(path.join(runDir, "01-findings.json"));
+      const status =
+        hasFindings && (raw.status === "dispatched" || raw.status === "stale")
+          ? "analyzed"
+          : (raw.status ?? "unknown");
+      runs.push({
+        runId: raw.runId ?? name,
+        status,
+        dispatchedAt: typeof raw.dispatchedAt === "number" ? raw.dispatchedAt : null,
+        sessionId: raw.sessionId ?? "",
+        pid: typeof raw.pid === "number" ? raw.pid : null,
+        supervisorPid: typeof raw.supervisorPid === "number" ? raw.supervisorPid : null,
+        ...(proposal ? { proposal } : {}),
+        ...(raw.review ? { review: raw.review } : {}),
+      });
+    } catch {
+      continue;
+    }
+  }
+  return runs.sort((a, b) => (b.dispatchedAt ?? 0) - (a.dispatchedAt ?? 0)).slice(0, limit);
+}

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

@@ -0,0 +1,201 @@
+/**
+ * 必红自检（设计稿 12.4）：拿三个**已知该被拦住**的坏样本去考评审器。
+ *
+ * 这是整条流水线唯一的「评审器自己可信吗」证据：如果评审器把「可以用 find」判成 pass，
+ * 后面所有真提案的 pass 都没有意义，所以这里任何一条 expected 没命中就拿 `passed: false`
+ * 并在报告里打红字，派发也随之停摆。
+ *
+ * 注意：这里**故意不跑机械 P0 复验** —— 那几个坏样本里有两条本身就违反硬规则，
+ * 用规则引擎拒掉只能证明规则还活着，证明不了评审器会判断内容。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadHardRules, type CompiledRules } from "./hard-rules.ts";
+import { buildReviewPrompt } from "./review-prompt.ts";
+import { reviewWithRetry, type ReviewSpawn } from "./review-run.ts";
+
+export type SelftestExpectation = "pass" | "reject" | "revise";
+
+export interface SelftestFixture {
+  name: string;
+  skill: string;
+  expected: SelftestExpectation;
+  why: string;
+  dir: string;
+  diff: string;
+  after: string;
+}
+
+export interface SelftestCase {
+  name: string;
+  expected: SelftestExpectation;
+  actual: string;
+  ok: boolean;
+  detail?: string;
+  attempts: number;
+  ms: number;
+}
+
+export interface SelftestReport {
+  at: number;
+  atIso: string;
+  passed: boolean;
+  results: SelftestCase[];
+}
+
+export const SELFTEST_FILE = "selftest.json";
+/** 报告与命令里共用的红字提示 */
+export const UNTRUSTED_NOTE = "评审器不可信，流水线停用：先修评审 prompt / 换更大的评审模型，再跑 /skill-evolve selftest";
+
+const EXPECTATIONS: readonly SelftestExpectation[] = ["pass", "reject", "revise"];
+
+export function selftestFile(evolutionDir: string): string {
+  return path.join(evolutionDir, SELFTEST_FILE);
+}
+
+function readText(file: string): string | undefined {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+/** 读三个 fixture；缺文件 / 坏 JSON 的目录直接跳过（不猜、不补） */
+export function loadFixtures(dir: string, log: (msg: string) => void = () => {}): SelftestFixture[] {
+  let entries: string[];
+  try {
+    entries = fs.readdirSync(dir).sort();
+  } catch (error) {
+    log(`[skill-evolve] 自检样本目录读不到：${String(error)}`);
+    return [];
+  }
+  const fixtures: SelftestFixture[] = [];
+  for (const entry of entries) {
+    const fixtureDir = path.join(dir, entry);
+    const meta = readText(path.join(fixtureDir, "fixture.json"));
+    if (!meta) continue;
+    let parsed: Record<string, unknown>;
+    try {
+      parsed = JSON.parse(meta) as Record<string, unknown>;
+    } catch {
+      log(`[skill-evolve] 自检样本坏 JSON，跳过：${entry}`);
+      continue;
+    }
+    const name = typeof parsed.name === "string" ? parsed.name : entry;
+    const skill = typeof parsed.skill === "string" ? parsed.skill : name;
+    const expected = parsed.expected as SelftestExpectation | undefined;
+    if (!expected || !EXPECTATIONS.includes(expected)) {
+      log(`[skill-evolve] 自检样本 expected 非法，跳过：${entry}`);
+      continue;
+    }
+    const diff = readText(path.join(fixtureDir, "change.diff"));
+    const after = readText(path.join(fixtureDir, "after.md"));
+    if (diff === undefined || after === undefined) {
+      log(`[skill-evolve] 自检样本缺 change.diff / after.md，跳过：${entry}`);
+      continue;
+    }
+    fixtures.push({
+      name,
+      skill,
+      expected,
+      why: typeof parsed.why === "string" ? parsed.why : "",
+      dir: fixtureDir,
+      diff,
+      after,
+    });
+  }
+  return fixtures;
+}
+
+export function readSelftestReport(evolutionDir: string): SelftestReport | undefined {
+  const text = readText(selftestFile(evolutionDir));
+  if (!text) return undefined;
+  try {
+    const raw = JSON.parse(text) as Record<string, unknown>;
+    return typeof raw.passed === "boolean" ? (raw as unknown as SelftestReport) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export interface SelftestOptions {
+  evolutionDir: string;
+  cwd: string;
+  fixturesDir?: string;
+  rules?: CompiledRules;
+  model?: string;
+  env?: NodeJS.ProcessEnv;
+  spawnFn?: ReviewSpawn;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+  timeoutMs?: number;
+  log?: (msg: string) => void;
+}
+
+/** 依次跑完三个坏样本；返回报告并写 `selftest.json`（写失败只记日志） */
+export async function runSelftest(options: SelftestOptions): Promise<SelftestReport> {
+  const log = options.log ?? (() => {});
+  const now = options.now ?? Date.now;
+  const fixturesDir = options.fixturesDir ?? fileURLToPath(new URL("../fixtures/selftest", import.meta.url));
+  const rules = options.rules ?? loadHardRules(path.join(options.evolutionDir, "rules", "hard-rules.json"));
+  const fixtures = loadFixtures(fixturesDir, log);
+  const results: SelftestCase[] = [];
+  for (const fixture of fixtures) {
+    const prompt = buildReviewPrompt({
+      skillName: fixture.skill,
+      skillText: fixture.after,
+      diffApplied: true,
+      diff: fixture.diff,
+      hardRules: rules.compiled,
+    });
+    const outcome = await reviewWithRetry({
+      prompt,
+      cwd: options.cwd,
+      ...(options.model ? { model: options.model } : {}),
+      ...(options.env ? { env: options.env } : {}),
+      ...(options.spawnFn ? { spawnFn: options.spawnFn } : {}),
+      ...(options.sleep ? { sleep: options.sleep } : {}),
+      ...(options.timeoutMs ? { timeoutMs: options.timeoutMs } : {}),
+      now,
+      log,
+    });
+    const actual = outcome.result.verdict ?? outcome.result.status;
+    const ok = outcome.result.status === "ok" && outcome.result.verdict === fixture.expected;
+    results.push({
+      name: fixture.name,
+      expected: fixture.expected,
+      actual,
+      ok,
+      ...(outcome.result.detail ? { detail: outcome.result.detail } : {}),
+      attempts: outcome.attempts,
+      ms: outcome.ms,
+    });
+    log(
+      `[skill-evolve] 自检 ${fixture.name}：期望 ${fixture.expected}，实际 ${actual}${ok ? "" : " ← 不合格"}`,
+    );
+  }
+  const at = now();
+  const report: SelftestReport = { at, atIso: new Date(at).toISOString(), passed: results.length > 0 && results.every((item) => item.ok), results };
+  try {
+    fs.mkdirSync(options.evolutionDir, { recursive: true });
+    fs.writeFileSync(selftestFile(options.evolutionDir), `${JSON.stringify(report, null, 2)}\n`, "utf8");
+  } catch (error) {
+    log(`[skill-evolve] 自检报告写失败：${String(error)}`);
+  }
+  log(`[skill-evolve] 自检${report.passed ? "通过" : "未通过"}：${results.filter((item) => item.ok).length}/${results.length}`);
+  return report;
+}
+
+/** 命令侧文案：任一不合格就把红字顶到第一行 */
+export function renderSelftestReport(report: SelftestReport | undefined): string {
+  if (!report) return "自检：还没跑过（/skill-evolve selftest）";
+  const lines: string[] = [];
+  if (!report.passed) lines.push(`【红】${UNTRUSTED_NOTE}`, "");
+  lines.push(`自检（${report.atIso}）：${report.passed ? "通过" : "未通过"}`);
+  for (const item of report.results) {
+    lines.push(`  ${item.ok ? "✓" : "✗"} ${item.name}  期望 ${item.expected}  实际 ${item.actual}${item.detail ? `（${item.detail}）` : ""}`);
+  }
+  return lines.join("\n");
+}

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

@@ -0,0 +1,145 @@
+/**
+ * 会话索引：把 `getSessionFile()` 的 JSONL 变成「行号 → 类型/角色/时间/摘要」。
+ *
+ * 铁律（设计稿 5.4）：**只产索引，绝不把会话原文复制进 run 目录**。
+ * 平均会话近 1MB，正文进 prompt 会立刻撑爆上下文；复盘子进程拿索引抽查，按行号回读原文。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { MutationQueue } from "./telemetry.ts";
+
+export interface SessionIndexLine {
+  /** 1 起算的物理行号，复盘证据就写这个 */
+  line: number;
+  type: string;
+  role?: string;
+  ts?: string;
+  /** 该行原始字符数，用来判断这行值不值得读 */
+  chars: number;
+  /** 摘要，最多 80 字 */
+  excerpt: string;
+}
+
+export interface SessionIndex {
+  lines: SessionIndexLine[];
+  stats: { lines: number; bytes: number; hasCompaction: boolean };
+}
+
+const EXCERPT_MAX = 80;
+
+function flatten(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+/** 截到 80 字以内（超出时用省略号占最后一位） */
+export function excerptOf(text: string): string {
+  const flat = flatten(text);
+  return flat.length > EXCERPT_MAX ? `${flat.slice(0, EXCERPT_MAX - 1)}…` : flat;
+}
+
+function textOfContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts: string[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const piece = part as Record<string, unknown>;
+    if (piece.type === "text" && typeof piece.text === "string") parts.push(piece.text);
+    else if (piece.type === "toolCall") parts.push(`[调用 ${String(piece.name ?? "工具")}]`);
+  }
+  return parts.join(" ");
+}
+
+/** 一条 entry 里值得进摘要的文字 */
+function excerptOfEntry(entry: Record<string, unknown>, type: string): string {
+  if (type === "session") return String(entry.cwd ?? "");
+  if (type === "compaction" || type === "branch_summary") return String(entry.summary ?? "");
+  if (type === "custom" || type === "custom_message") return String(entry.customType ?? "");
+  const message = entry.message;
+  if (!message || typeof message !== "object") return "";
+  const fields = message as Record<string, unknown>;
+  const text = textOfContent(fields.content);
+  const tool = typeof fields.toolName === "string" ? fields.toolName : "";
+  return tool ? `[${tool}] ${text}` : text;
+}
+
+export function buildSessionIndex(text: string): SessionIndex {
+  const rawLines = text.split("\n");
+  const lines: SessionIndexLine[] = [];
+  let total = 0;
+  let hasCompaction = false;
+
+  for (let i = 0; i < rawLines.length; i += 1) {
+    const raw = rawLines[i];
+    if (raw.trim().length === 0) continue;
+    total += 1;
+    let entry: Record<string, unknown>;
+    try {
+      const parsed: unknown = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object") continue;
+      entry = parsed as Record<string, unknown>;
+    } catch {
+      // 坏行只计数不进索引：截断的会话尾巴很常见，不能因此整份索引失败
+      continue;
+    }
+    const type = typeof entry.type === "string" ? entry.type : "unknown";
+    if (type === "compaction") hasCompaction = true;
+    const message = entry.message && typeof entry.message === "object" ? (entry.message as Record<string, unknown>) : null;
+    const role = message && typeof message.role === "string" ? message.role : undefined;
+    const ts = typeof entry.timestamp === "string" ? entry.timestamp : undefined;
+    const line: SessionIndexLine = {
+      line: i + 1,
+      type,
+      chars: raw.length,
+      // 摘要一律过一遍 excerptOf：这是「≤80 字」的唯一出口，绝不让某类 entry 绕过它
+      excerpt: excerptOf(excerptOfEntry(entry, type)),
+    };
+    if (role) line.role = role;
+    if (ts) line.ts = ts;
+    lines.push(line);
+  }
+
+  return { lines, stats: { lines: total, bytes: Buffer.byteLength(text, "utf8"), hasCompaction } };
+}
+
+/** 同步版索引生成：只给退出前补发用（主进程马上退出，不能 await） */
+export function writeSessionIndexSync(options: {
+  sessionFile: string;
+  outDir: string;
+  log?: (msg: string) => void;
+}): SessionIndex | null {
+  const log = options.log ?? (() => {});
+  try {
+    const text = fs.readFileSync(options.sessionFile, "utf8");
+    const index = buildSessionIndex(text);
+    fs.mkdirSync(options.outDir, { recursive: true });
+    fs.writeFileSync(path.join(options.outDir, "index.json"), `${JSON.stringify(index, null, 2)}\n`, "utf8");
+    return index;
+  } catch (error) {
+    log(`[skill-evolve] 会话索引生成失败（${options.sessionFile}）：${String(error)}`);
+    return null;
+  }
+}
+
+/** 写 `runs/<runId>/00-session/index.json`；会话不可读时返回 null，由调用方降级为 telemetry-only */
+export async function writeSessionIndex(options: {
+  sessionFile: string;
+  outDir: string;
+  queue: MutationQueue;
+  log?: (msg: string) => void;
+}): Promise<SessionIndex | null> {
+  const log = options.log ?? (() => {});
+  try {
+    const text = await fs.promises.readFile(options.sessionFile, "utf8");
+    const index = buildSessionIndex(text);
+    const outFile = path.join(options.outDir, "index.json");
+    await options.queue(outFile, async () => {
+      await fs.promises.mkdir(options.outDir, { recursive: true });
+      await fs.promises.writeFile(outFile, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+    });
+    return index;
+  } catch (error) {
+    log(`[skill-evolve] 会话索引生成失败（${options.sessionFile}）：${String(error)}`);
+    return null;
+  }
+}