pi-skill-evolve 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,80 @@
+/**
+ * 复盘提示词拼装：模板正文 + 本轮输入（会话原文路径、索引、run 目录、覆盖轮数）。
+ *
+ * 单独成文件是为了让 dispatch.ts（常规派发）与 shutdown-dispatch.ts（退出前补发）
+ * 共用同一份拼装逻辑，同时不把两者卷进循环 import。
+ */
+import * as fs from "node:fs";
+import type { Attribution } from "./attribution.ts";
+
+/** 被去抖合并掉的轮次范围：起点 + 合并了几轮 */
+export interface PromptCoverage {
+  rounds: number;
+  since: number;
+}
+
+export interface PromptInput {
+  template: string;
+  sessionFile?: string;
+  /** 缺省表示没有会话索引（telemetry-only）：prompt 里要明说索引不可用，别让子进程去读不存在的文件 */
+  indexFile?: string;
+  runDir: string;
+  sessionId: string;
+  skills: string[];
+  dispatchedAt: number;
+  /** 缺省表示机械层没给结论（发现失败 / 无归因），全部交给复盘 agent 判 */
+  attributions?: Attribution[];
+  /** 缺省表示只覆盖刚刚结束的那一轮 */
+  coverage?: PromptCoverage;
+}
+
+/** 模板缺失时的最小指令：宁可少说，也不能因为读不到模板就不派生 */
+export const FALLBACK_TEMPLATE = [
+  "你在复盘上一轮会话里技能为什么没被加载。",
+  "只按索引抽查，禁止整文件读会话原文。",
+  "只写本 run 目录下的 01-findings.json，禁止改 .pi/skills/。",
+].join("\n");
+
+export function buildPrompt(input: PromptInput): string {
+  const evidence = input.sessionFile
+    ? `会话原文：${input.sessionFile}`
+    : "会话原文：不可用（evidenceMode=telemetry-only，只按遥测做保守结论）";
+  const index = input.indexFile
+    ? `索引：${input.indexFile}`
+    : "索引：不可用（evidenceMode=telemetry-only，只按遥测事件下保守结论，evidence 一律留空）";
+  const coverage = input.coverage
+    ? `覆盖轮数：合并了 ${input.coverage.rounds} 轮待复盘区间（起点 ts=${new Date(input.coverage.since).toISOString()}），结论要覆盖整段，不要只看最后一轮`
+    : "覆盖轮数：1 轮（刚刚结束的这一轮）";
+  // 机械层已经定死的结论不要让复盘 agent 重判：它重判只会把「frontmatter 坏」改成「改写 description」
+  const mechanical = (input.attributions ?? []).length === 0
+    ? ["机械归因：无（本轮全部技能需要你判 F/G）"]
+    : [
+        `已机械归因（${(input.attributions ?? []).length} 条，结论直接沿用，不要重判）：`,
+        ...(input.attributions ?? []).map((item) => `  ${item.category} ${item.skill} —— ${item.reason}`),
+        "你只对上面没出现的技能做 F/G 判定；已归因为 A~E 的不要重复判，也不要在 findings 里改它的 category。",
+      ];
+  return [
+    input.template.trimEnd(),
+    "",
+    "---",
+    `会话ID：${input.sessionId}`,
+    evidence,
+    `技能清单（逐个判定，不许遗漏也不许新增）：${input.skills.length > 0 ? input.skills.join("、") : "（本轮无曝光技能）"}`,
+    coverage,
+    ...mechanical,
+    index,
+    `run 目录：${input.runDir}`,
+    `派生时间：${new Date(input.dispatchedAt).toISOString()}`,
+    "",
+  ].join("\n");
+}
+
+/** 同步读模板：派发时读一次就够，模板很小；读不到回退最小指令而不是放弃派发 */
+export function readPromptTemplateSync(file: string, log: (msg: string) => void): string {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch (error) {
+    log(`[skill-evolve] 复盘模板读取失败，改用内置最小指令：${String(error)}`);
+    return FALLBACK_TEMPLATE;
+  }
+}

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

@@ -0,0 +1,227 @@
+/**
+ * 提案产物的解析与校验（设计稿 九、十）：M3 只做「生成 + 校验」，不评审、不写 `.pi/skills`。
+ *
+ * 复盘子进程把提案写在 `runs/<runId>/` 下：
+ *   - 改现有技能：`02-proposal.json`（元信息）+ `02-proposal.diff`（unified diff，不是整篇）
+ *   - 新建技能：`02-proposal.json` + `candidate/<名>/SKILL.md`
+ * 这里只做纯解析（diff / frontmatter）与读盘一层，方便 `node --test` 直接跑。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export const PROPOSAL_TYPES = ["improve", "create", "merge", "prune"] as const;
+export type ProposalType = (typeof PROPOSAL_TYPES)[number];
+
+/** 增删行合计超过它不拒绝生成，但标记转人工：一次改 40 行以上的技能文案没人能审 */
+export const MAX_DIFF_LINES = 40;
+/** 提案只许动技能目录，别的路径一律 bad_path */
+export const SKILL_PATH_PREFIX = ".pi/skills/";
+
+export type ProposalStatus = "ok" | "missing" | "too_large" | "bad_path" | "invalid_candidate";
+
+export interface DiffFile {
+  path: string;
+  hunks: number;
+}
+
+export interface DiffParseResult {
+  ok: boolean;
+  reason?: "empty" | "bad_path" | "malformed";
+  detail?: string;
+  files: DiffFile[];
+  added: number;
+  removed: number;
+}
+
+/** 去掉 git 的 `a/` `b/` 前缀与行尾 tab 时间戳；`/dev/null` 返回 null（新建/删除文件时会出现） */
+function normalizeDiffPath(raw: string): string | null {
+  const head = raw.split("\t")[0].trim();
+  if (head === "/dev/null" || head.length === 0) return null;
+  return head.replace(/^[ab]\//, "");
+}
+
+function isSkillPath(filePath: string): boolean {
+  return filePath.startsWith(SKILL_PATH_PREFIX);
+}
+
+/**
+ * 解析 unified diff，只统计增删行与文件路径，不重建内容。
+ * 注意：hunk 里以 `--- ` 开头的内容行会被当成文件头 —— 技能文档里出现这种行的概率可忽略，
+ * 真要写这种内容就得用转义形式，属于可接受的解析边界。
+ */
+export function parseUnifiedDiff(text: string): DiffParseResult {
+  const files: DiffFile[] = [];
+  let added = 0;
+  let removed = 0;
+  let badPath: string | null = null;
+  let current: DiffFile | null = null;
+
+  for (const line of text.split(/\r?\n/)) {
+    if (line.startsWith("--- ")) {
+      const oldPath = normalizeDiffPath(line.slice(4));
+      if (oldPath !== null && !isSkillPath(oldPath)) badPath ??= oldPath;
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const newPath = normalizeDiffPath(line.slice(4));
+      if (newPath === null) {
+        current = null;
+        continue;
+      }
+      if (!isSkillPath(newPath)) {
+        badPath ??= newPath;
+        current = null;
+        continue;
+      }
+      current = { path: newPath, hunks: 0 };
+      files.push(current);
+      continue;
+    }
+    if (line.startsWith("@@")) {
+      if (current) current.hunks += 1;
+      continue;
+    }
+    // `diff --git` / `index abc..def` 之类的头对统计无意义，直接跳过
+    if (line.startsWith("diff ") || line.startsWith("index ")) continue;
+    if (!current) continue;
+    if (line.startsWith("+")) added += 1;
+    else if (line.startsWith("-")) removed += 1;
+  }
+
+  if (badPath !== null) return { ok: false, reason: "bad_path", detail: badPath, files, added, removed };
+  if (files.length === 0) return { ok: false, reason: "empty", detail: "没有可用文件头", files, added, removed };
+  return { ok: true, files, added, removed };
+}
+
+export interface CandidateCheck {
+  ok: boolean;
+  detail: string;
+  name?: string;
+}
+
+/** 读 frontmatter 的 name / description：只认 `key: value` 单行形式（技能 frontmatter 就这两种） */
+export function readFrontmatter(text: string): Record<string, string> {
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  const fields: Record<string, string> = {};
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "---") break;
+    const match = /^([A-Za-z_-]+):\s*(.*)$/.exec(line);
+    if (!match) continue;
+    fields[match[1]] = match[2].trim().replace(/^["']|["']$/g, "");
+  }
+  return fields;
+}
+
+export function validateCandidate(dir: string): CandidateCheck {
+  let text: string;
+  try {
+    text = fs.readFileSync(path.join(dir, "SKILL.md"), "utf8");
+  } catch {
+    return { ok: false, detail: `缺 SKILL.md：${dir}` };
+  }
+  const fields = readFrontmatter(text);
+  const name = fields.name ?? "";
+  if (name.length === 0) return { ok: false, detail: "frontmatter 缺 name" };
+  if ((fields.description ?? "").length === 0) return { ok: false, detail: "frontmatter 缺 description" };
+  if (name.length > 20) return { ok: false, detail: `name 超过 20 字：${name}` };
+  if (!/^[a-z0-9-]+$/.test(name)) return { ok: false, detail: `name 不合规（只许小写字母/数字/短横线）：${name}` };
+  const dirName = path.basename(dir);
+  if (name !== dirName) return { ok: false, detail: `name(${name}) 与目录名(${dirName}) 不一致` };
+  return { ok: true, detail: `${name} 校验通过`, name };
+}
+
+export interface ProposalCheck {
+  status: ProposalStatus;
+  detail: string;
+  type?: ProposalType;
+  skill?: string;
+  added?: number;
+  removed?: number;
+  /** 相对 run 目录的产物文件名（diff 或 candidate 的 SKILL.md） */
+  file?: string;
+}
+
+function readProposalJson(runDir: string): { json: Record<string, unknown> | null; error?: string } {
+  try {
+    const raw = fs.readFileSync(path.join(runDir, "02-proposal.json"), "utf8");
+    const parsed = JSON.parse(raw) as unknown;
+    if (typeof parsed !== "object" || parsed === null) return { json: null, error: "02-proposal.json 不是对象" };
+    return { json: parsed as Record<string, unknown> };
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return { json: null, error: code === "ENOENT" ? "没有 02-proposal.json" : `02-proposal.json 解析失败：${String(error)}` };
+  }
+}
+
+/** 校验一个 run 目录的提案：只有 status==="ok" 才允许后续（人工）评审 */
+export function validateProposal(runDir: string): ProposalCheck {
+  const { json, error } = readProposalJson(runDir);
+  if (!json) return { status: "missing", detail: error ?? "没有提案" };
+
+  const type = String(json.type ?? "");
+  const skill = String(json.skill ?? "");
+  if (!(PROPOSAL_TYPES as readonly string[]).includes(type)) {
+    return { status: "missing", detail: `02-proposal.json 的 type 非法：${type || "（空）"}` };
+  }
+  if (skill.length === 0) return { status: "missing", detail: "02-proposal.json 缺 skill" };
+  const typed = type as ProposalType;
+
+  if (typed === "create") {
+    const rel = path.join("candidate", skill, "SKILL.md");
+    const check = validateCandidate(path.join(runDir, "candidate", skill));
+    return check.ok
+      ? { status: "ok", detail: check.detail, type: typed, skill, file: rel, added: 0, removed: 0 }
+      : { status: "invalid_candidate", detail: check.detail, type: typed, skill, file: rel };
+  }
+
+  const diffRel = typeof json.diffFile === "string" && json.diffFile.length > 0 ? json.diffFile : "02-proposal.diff";
+  let text: string;
+  try {
+    text = fs.readFileSync(path.resolve(runDir, diffRel), "utf8");
+  } catch {
+    return { status: "missing", detail: `缺 diff：${diffRel}`, type: typed, skill };
+  }
+  const parsed = parseUnifiedDiff(text);
+  if (!parsed.ok) {
+    return {
+      status: parsed.reason === "bad_path" ? "bad_path" : "missing",
+      detail: parsed.reason === "bad_path" ? `diff 改了技能目录外的路径：${parsed.detail}` : (parsed.detail ?? "diff 为空"),
+      type: typed,
+      skill,
+      added: parsed.added,
+      removed: parsed.removed,
+      file: diffRel,
+    };
+  }
+  const total = parsed.added + parsed.removed;
+  const base = { type: typed, skill, added: parsed.added, removed: parsed.removed, file: diffRel };
+  if (total > MAX_DIFF_LINES) {
+    return { status: "too_large", detail: `增删 ${total} 行 > ${MAX_DIFF_LINES}，转人工`, ...base };
+  }
+  return { status: "ok", detail: `增删 ${total} 行，路径 ${parsed.files.map((item) => item.path).join("、")}`, ...base };
+}
+
+export interface ProposalSummary {
+  type: string;
+  skill: string;
+  status: ProposalStatus;
+  added: number;
+  removed: number;
+  file: string | null;
+}
+
+/** 报告里显示提案摘要：没有 `02-proposal.json` 返回 undefined（这一轮本来就没提案，不是错） */
+export function readProposalSummary(runDir: string): ProposalSummary | undefined {
+  const { json } = readProposalJson(runDir);
+  if (!json) return undefined;
+  const check = validateProposal(runDir);
+  return {
+    type: String(json.type ?? "?"),
+    skill: check.skill ?? String(json.skill ?? "?"),
+    status: check.status,
+    added: check.added ?? 0,
+    removed: check.removed ?? 0,
+    file: check.file ?? null,
+  };
+}

package/extensions/skill-evolve/lib/prune-plan.ts

@@ -0,0 +1,62 @@
+/**
+ * 删技能的「待执行清单」（设计稿 10.4）：插件只出清单，真删留给人手动执行。
+ *
+ * 为什么不在插件里真删：删技能是不可逆操作，插件能做的只有把「要动哪五处、当前哪处还缺」
+ * 摊开给人看。人批（`approve <runId> --prune`）只换取这份清单，不换取删除动作。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { readProposalMeta } from "./apply-targets.ts";
+
+export interface PrunePlan {
+  skill: string;
+  steps: string[];
+  /** 当前就不存在 / 已经缺的引用面（清单里标出来，别让人白跑） */
+  missing: string[];
+}
+
+function exists(file: string): boolean {
+  return fs.existsSync(file);
+}
+
+function readText(file: string): string {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+export function buildPrunePlan(runDir: string, cwd: string): PrunePlan | null {
+  const meta = readProposalMeta(runDir);
+  if (!meta || meta.skill.length === 0) return null;
+  const skill = meta.skill;
+  const missing: string[] = [];
+  const stub = path.join(cwd, ".cursor", "skills", skill, "SKILL.md");
+  if (!exists(stub)) missing.push(`.cursor/skills/${skill}/SKILL.md（已不存在）`);
+  const agents = readText(path.join(cwd, "AGENTS.md"));
+  if (agents.length > 0 && !new RegExp(`^\\s*[-*]\\s+\`${skill.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\``, "m").test(agents)) {
+    missing.push(`AGENTS.md 索引表（已无 ${skill} 那一行）`);
+  }
+  const steps = [
+    `① 删除技能目录：rm -rf .pi/skills/${skill}/`,
+    `② 删除 .cursor 路由 stub：rm -f .cursor/skills/${skill}/SKILL.md`,
+    `③ 从 AGENTS.md 的 Skill 索引表删掉 ${skill} 那一行（先 rg -n "\`${skill}\`" AGENTS.md 定位）`,
+    `④ .dsh/skills/${skill}/ 不动（SSOT 只认 .pi，见设计稿 17.1）`,
+    `⑤ 扫其余引用：rg -n "${skill}" --no-ignore -uu . —— 逐条改，只允许剩进化记录里的历史引用`,
+    `校验：rg -n "${skill}" --no-ignore -uu . 只剩 .pi/evolution/ 下的历史记录`,
+    `收尾：git add -A && git commit -m "docs(skill): 移除技能 ${skill}"`,
+  ];
+  return { skill, steps, missing };
+}
+
+export function renderPrunePlan(plan: PrunePlan): string {
+  const lines = [`删技能待执行清单：${plan.skill}（插件不执行，请手动逐条确认后再删）`, ""];
+  lines.push(...plan.steps);
+  if (plan.missing.length > 0) {
+    lines.push("", "已有缺口（不必重复处理）：");
+    lines.push(...plan.missing.map((item) => `  · ${item}`));
+  }
+  lines.push("", "删除不可逆：确认没有其它技能/文档仍依赖它之后再动手。");
+  return lines.join("\n");
+}

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

@@ -0,0 +1,136 @@
+/**
+ * 采纳队列：`.pi/evolution/queue.json`（运行态，不入库）。
+ *
+ * 为什么要有队列而不是评审完立刻写盘：评审督导是独立 node 进程、没有 withFileMutationQueue
+ * （闸2 只能在 pi 运行时里用）。督导只写 03-review.json，把「可采纳」排进队列；扩展在
+ * session_start 与 settle 时扫队列并执行，所以主会话退出也不会丢。
+ *
+ * superseded 规则：同一个 skill 已经有更早的 pending 时，新条目直接标 superseded ——
+ * 否则两次改动会落到同一文件上，谁先谁后都不对。要采纳新的，先把旧的处理掉。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ActionLevel } from "./classify-action.ts";
+import type { MutationQueue } from "./telemetry.ts";
+
+export type QueueStatus = "pending" | "applied" | "rolled-back" | "failed" | "superseded" | "rejected";
+
+export interface QueueItem {
+  runId: string;
+  level: ActionLevel;
+  skill: string;
+  /** 相对仓库根的路径（.pi/skills/… / .cursor/skills/… / AGENTS.md） */
+  targets: string[];
+  createdAt: number;
+  status: QueueStatus;
+  proposalType?: string;
+  detail?: string;
+}
+
+export const QUEUE_FILE = "queue.json";
+const LEVELS: readonly ActionLevel[] = ["auto", "approval", "forbidden"];
+// rejected 是人主动否掉（网页点「拒绝」/TUI），与 superseded（被更早的 pending 顶掉）不是一回事
+const STATUSES: readonly QueueStatus[] = ["pending", "applied", "rolled-back", "failed", "superseded", "rejected"];
+
+export function queueFile(evolutionDir: string): string {
+  return path.join(evolutionDir, QUEUE_FILE);
+}
+
+function isItem(raw: unknown): raw is QueueItem {
+  if (typeof raw !== "object" || raw === null) return false;
+  const item = raw as Record<string, unknown>;
+  return (
+    typeof item.runId === "string" &&
+    typeof item.skill === "string" &&
+    LEVELS.includes(item.level as ActionLevel) &&
+    STATUSES.includes(item.status as QueueStatus)
+  );
+}
+
+/** 读队列：文件缺 / JSON 坏 / 单条字段不合规都只丢那一条，绝不让命令挂掉 */
+export function readQueue(evolutionDir: string): QueueItem[] {
+  try {
+    const raw = JSON.parse(fs.readFileSync(queueFile(evolutionDir), "utf8")) as unknown;
+    return Array.isArray(raw) ? raw.filter(isItem) : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeJson(evolutionDir: string, items: readonly QueueItem[]): void {
+  fs.mkdirSync(evolutionDir, { recursive: true });
+  fs.writeFileSync(queueFile(evolutionDir), `${JSON.stringify(items, null, 2)}\n`, "utf8");
+}
+
+export interface QueueDeps {
+  evolutionDir: string;
+  queue: MutationQueue;
+  now?: () => number;
+}
+
+export interface EnqueueResult {
+  item: QueueItem;
+  /** 新条目被更早的 pending 顶掉时给出对方 runId */
+  supersededBy?: string;
+}
+
+/** 入队（幂等：同一个 runId 已存在就直接返回原条目） */
+export async function enqueue(
+  deps: QueueDeps,
+  input: Omit<QueueItem, "createdAt" | "status">,
+): Promise<EnqueueResult> {
+  const now = deps.now ?? (() => Date.now());
+  let result: EnqueueResult | undefined;
+  await deps.queue(queueFile(deps.evolutionDir), async () => {
+    // 队列内重读：并发入队时后写的一方不会用旧快照覆盖前一方
+    const items = readQueue(deps.evolutionDir);
+    const existing = items.find((item) => item.runId === input.runId);
+    if (existing) {
+      result = { item: existing };
+      return;
+    }
+    const older = items.find((item) => item.skill === input.skill && item.status === "pending");
+    const item: QueueItem = {
+      ...input,
+      createdAt: now(),
+      status: older ? "superseded" : "pending",
+      ...(older ? { detail: `同一技能已有更早的 pending：${older.runId}` } : {}),
+    };
+    items.push(item);
+    writeJson(deps.evolutionDir, items);
+    result = older ? { item, supersededBy: older.runId } : { item };
+  });
+  if (!result) throw new Error("入队失败：队列写回调未返回结果");
+  return result;
+}
+
+/** 取待办（按入队时间升序；给 level 就只看该级） */
+export function takePending(items: readonly QueueItem[], level?: ActionLevel): QueueItem[] {
+  return items
+    .filter((item) => item.status === "pending" && (level === undefined || item.level === level))
+    .sort((a, b) => a.createdAt - b.createdAt);
+}
+
+export function findItem(items: readonly QueueItem[], runId: string): QueueItem | undefined {
+  return items.find((item) => item.runId === runId);
+}
+
+/** 改某条状态；返回是否找到了该 runId（命令据此区分「没有这条」与「已处理」） */
+export async function markDone(
+  deps: QueueDeps,
+  runId: string,
+  status: QueueStatus,
+  detail?: string,
+): Promise<boolean> {
+  let found = false;
+  await deps.queue(queueFile(deps.evolutionDir), async () => {
+    const items = readQueue(deps.evolutionDir);
+    const target = items.find((item) => item.runId === runId);
+    if (!target) return;
+    found = true;
+    target.status = status;
+    if (detail) target.detail = detail;
+    writeJson(deps.evolutionDir, items);
+  });
+  return found;
+}

package/extensions/skill-evolve/lib/replay-fixture.ts

@@ -0,0 +1,80 @@
+/**
+ * 端到端复演的固定数据：假技能前后文、提案 diff、假会话 JSONL、假评审结论。
+ *
+ * 单独一个文件是为了让 `replay.ts` 只留流程（300 行闸门），也方便测试直接引用这些常量。
+ */
+
+/** 复演用技能：改动前 */
+export const REPLAY_BEFORE = [
+  "---",
+  "name: replay-demo",
+  "description: 复演流水线时使用的临时技能，别在真实会话里用",
+  "---",
+  "",
+  "# replay-demo",
+  "",
+  "- 只给 scripts/replay.ts 用。",
+  "",
+].join("\n");
+
+/** 复演用技能：改动后（只加正文条款 → approval 级，正好走「人批」这一段） */
+export const REPLAY_AFTER = [
+  "---",
+  "name: replay-demo",
+  "description: 复演流水线时使用的临时技能，别在真实会话里用",
+  "---",
+  "",
+  "# replay-demo",
+  "",
+  "- 只给 scripts/replay.ts 用。",
+  "- 复演时必须先看 00-session/index.json 再读会话原文。",
+  "",
+].join("\n");
+
+/**
+ * 复演用的提案 diff：**带上下文行**的真实形状（提案由复盘子 agent 写，不是整文件重渲染）。
+ * 整文件重渲染那种 diff 里 frontmatter 会变成增删行，分级会误判 forbidden —— 那不是真实提案的样子。
+ */
+export const REPLAY_DIFF = [
+  "--- a/.pi/skills/replay-demo/SKILL.md",
+  "+++ b/.pi/skills/replay-demo/SKILL.md",
+  "@@ -5,4 +5,5 @@",
+  " ",
+  " # replay-demo",
+  " ",
+  " - 只给 scripts/replay.ts 用。",
+  "+- 复演时必须先看 00-session/index.json 再读会话原文。",
+  "",
+].join("\n");
+
+/** 假评审结论：形状必须过 postProcessReview 的字段校验（证据三件套齐全） */
+export const FAKE_REVIEW_TEXT = JSON.stringify({
+  verdict: "pass",
+  blocking: [],
+  evidence: [{ file: ".pi/skills/replay-demo/SKILL.md", line: 9, quote: "复演时必须先看 00-session/index.json" }],
+  notes: ["复演用假评审：只验证流水线，不代表真实评审质量"],
+});
+
+/** 假会话 JSONL：只要够 buildSessionIndex 抽出结构，不复制真实会话 */
+export function fakeSessionText(cwd: string, at: number): string {
+  const iso = new Date(at).toISOString();
+  return [
+    JSON.stringify({ type: "session", version: 3, id: "replay-session", timestamp: iso, cwd }),
+    JSON.stringify({
+      type: "message",
+      id: "r1",
+      parentId: null,
+      timestamp: iso,
+      message: { role: "user", content: [{ type: "text", text: "帮我看看 replay-demo 这个技能该怎么改" }] },
+    }),
+    JSON.stringify({
+      type: "message",
+      id: "r2",
+      parentId: "r1",
+      timestamp: iso,
+      message: { role: "assistant", content: [{ type: "text", text: "先按索引抽查，再给提案。" }] },
+    }),
+    "",
+  ].join("\n");
+}
+