pi-skill-evolve 0.0.0-stage → 0.1.0

package/extensions/skill-evolve/test/single-flight.test.ts

@@ -0,0 +1,122 @@
+/**
+ * 全局单飞闸（用户 2026-11-08：「每次最多一个复盘agent」）：
+ * 扫 `runs/<runId>/run.json` 的 pid（复盘）与 supervisorPid（督导），alive 为真即占用。
+ *
+ * 用注入的 alive 模拟存活，不起真进程、不看真 pid。
+ */
+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 test from "node:test";
+import { findOccupant, guardBusy } from "../lib/single-flight.ts";
+import type { TelemetryInput, TelemetryWriter } from "../lib/telemetry.ts";
+
+const NOW = 1_760_000_000_000;
+
+function workspace(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-single-"));
+}
+
+function writeRun(evolutionDir: string, runId: string, record: Record<string, unknown>): void {
+  const runDir = path.join(evolutionDir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "run.json"), JSON.stringify({ runId, ...record }), "utf8");
+}
+
+/** 只有列出来的 pid 算活着 */
+function aliveOnly(...pids: number[]): (pid: number) => boolean {
+  return (pid) => pids.includes(pid);
+}
+
+function writer(): { events: TelemetryInput[]; sync: TelemetryInput[]; telemetry: TelemetryWriter } {
+  const events: TelemetryInput[] = [];
+  const sync: TelemetryInput[] = [];
+  return {
+    events,
+    sync,
+    telemetry: {
+      append: (event) => events.push(event),
+      appendSync: (event) => sync.push(event),
+      flush: async () => undefined,
+    },
+  };
+}
+
+test("findOccupant：没有 runs 目录 → null", () => {
+  assert.equal(findOccupant(workspace()), null);
+});
+
+test("findOccupant：run.json 里没有 pid / supervisorPid → null", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: null });
+  assert.equal(findOccupant(dir, { alive: () => true }), null);
+});
+
+test("findOccupant：pid 已死 → null（死进程自然释放，不需要谁清场）", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: 4242, dispatchedAt: NOW });
+  assert.equal(findOccupant(dir, { alive: aliveOnly(9999) }), null);
+});
+
+test("findOccupant：复盘子进程活着 → kind=复盘", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: 4242, dispatchedAt: NOW });
+  assert.deepEqual(findOccupant(dir, { alive: aliveOnly(4242) }), { runId: "r1", pid: 4242, kind: "复盘" });
+});
+
+test("findOccupant：复盘 pid 死了但督导活着 → kind=督导", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "analyzed", pid: 4242, supervisorPid: 5151, dispatchedAt: NOW });
+  assert.deepEqual(findOccupant(dir, { alive: aliveOnly(5151) }), { runId: "r1", pid: 5151, kind: "督导" });
+});
+
+test("findOccupant：两条 run 都活着 → 返回最早派发的那条", () => {
+  const dir = workspace();
+  writeRun(dir, "new", { status: "dispatched", pid: 2, dispatchedAt: NOW + 1000 });
+  writeRun(dir, "old", { status: "dispatched", pid: 1, dispatchedAt: NOW });
+  assert.deepEqual(findOccupant(dir, { alive: aliveOnly(1, 2) }), { runId: "old", pid: 1, kind: "复盘" });
+});
+
+test("findOccupant：ignoreRunId 排除自己那条（督导与自己同属一条 run）", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: 4242, dispatchedAt: NOW });
+  assert.equal(findOccupant(dir, { alive: aliveOnly(4242), ignoreRunId: "r1" }), null);
+});
+
+test("guardBusy：占用时写 skipped(busy) 遥测并返回占用者", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: 4242, dispatchedAt: NOW });
+  const { events, sync, telemetry } = writer();
+  const occupant = guardBusy({
+    evolutionDir: dir,
+    sessionId: "s1",
+    telemetry,
+    trigger: "auto",
+    rounds: 2,
+    alive: aliveOnly(4242),
+  });
+  assert.deepEqual(occupant, { runId: "r1", pid: 4242, kind: "复盘" });
+  assert.deepEqual(events, [
+    { kind: "skipped", sessionId: "s1", why: "busy", occupant: { runId: "r1", pid: 4242, kind: "复盘" }, trigger: "auto", rounds: 2 },
+  ]);
+  assert.deepEqual(sync, [], "非退出路径走异步 append");
+});
+
+test("guardBusy：退出补发路径用 appendSync 同步落盘", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: 4242, dispatchedAt: NOW });
+  const { events, sync, telemetry } = writer();
+  guardBusy({ evolutionDir: dir, sessionId: "s1", telemetry, sync: true, trigger: "shutdown", alive: aliveOnly(4242) });
+  assert.equal(events.length, 0);
+  assert.equal(sync.length, 1);
+  assert.equal(sync[0]!.why, "busy");
+});
+
+test("guardBusy：空闲时返回 null 且不写遥测", () => {
+  const dir = workspace();
+  writeRun(dir, "r1", { status: "dispatched", pid: 4242, dispatchedAt: NOW });
+  const { events, telemetry } = writer();
+  assert.equal(guardBusy({ evolutionDir: dir, sessionId: "s1", telemetry, alive: aliveOnly(9999) }), null);
+  assert.deepEqual(events, []);
+});

package/extensions/skill-evolve/test/stale.test.ts

@@ -0,0 +1,272 @@
+/**
+ * 卡死判定与「失败可见」单测（设计稿 14 章的可观测补丁）。
+ *
+ * 铁律：全程**不真起 pi / node 子进程**。spawn 一律传假 spawnFn，
+ * 只断言它收到的 stdio / 目录，进程由测试自己用 fs 模拟写日志。
+ * 依据：2026-11-08 漏注入 spawnFn，一次跑出 51 个孤儿复盘子进程。
+ */
+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 test from "node:test";
+import { DEFAULT_CONFIG } from "../lib/config.ts";
+import { collectPanelState, panelWidget, statusEntries, statusLine } from "../lib/panel.ts";
+import { renderStatus } from "../lib/report.ts";
+import { SUPERVISOR_LOG, spawnReviewSupervisor } from "../lib/review-spawn.ts";
+import { CHILD_LOG, spawnDetached } from "../lib/spawn-plan.ts";
+import { classifyStale, listStaleRuns, readRunError, scanStaleRuns, STALE_MS } from "../lib/stale.ts";
+
+const NOW = Date.UTC(2026, 10, 8, 12);
+const MINUTE = 60_000;
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-stale-"));
+}
+
+/** 写一条 run.json；raw 里给了什么就写什么（pid 缺省不写 = dispatch 半路被打断的形态） */
+function writeRun(dir: string, runId: string, raw: Record<string, unknown>): string {
+  const runDir = path.join(dir, "runs", runId);
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, "run.json"), `${JSON.stringify({ runId, sessionId: "s", ...raw }, null, 2)}\n`, "utf8");
+  return runDir;
+}
+
+function readRun(runDir: string): Record<string, unknown> {
+  return JSON.parse(fs.readFileSync(path.join(runDir, "run.json"), "utf8")) as Record<string, unknown>;
+}
+
+const deadPid = (): boolean => false;
+const alivePid = (): boolean => true;
+
+test("classifyStale：刚派发 10 秒内即使 pid 不在也不算卡死", () => {
+  const verdict = classifyStale({ status: "dispatched", pid: 291916, dispatchedAt: NOW - 10_000 }, NOW, { alive: deadPid });
+  assert.deepEqual(verdict, { stale: false });
+});
+
+test("classifyStale：子进程已死且超过 5 分钟 → child-exited", () => {
+  assert.deepEqual(
+    classifyStale({ status: "dispatched", pid: 291916, dispatchedAt: NOW - STALE_MS - 1000 }, NOW, { alive: deadPid }),
+    { stale: true, reason: "child-exited" },
+  );
+  assert.deepEqual(classifyStale({ status: "proposed", pid: 1, dispatchedAt: NOW - STALE_MS }, NOW, { alive: deadPid }), {
+    stale: false,
+  }, "正好 5 分钟不算「超过」");
+  assert.deepEqual(
+    classifyStale({ status: "analyzed", dispatchedAt: NOW - STALE_MS - 1 }, NOW, { alive: deadPid }),
+    { stale: false },
+    "analyzed 说明结论已经写盘：子进程退出是正常的，不能报成卡死",
+  );
+});
+
+test("classifyStale：pid 还活着但超单 run 上限 → timeout", () => {
+  assert.deepEqual(
+    classifyStale({ status: "dispatched", pid: 11367, dispatchedAt: NOW - DEFAULT_CONFIG.maxRuntimeMs - 1 }, NOW, { alive: alivePid }),
+    { stale: true, reason: "timeout" },
+  );
+  assert.deepEqual(
+    classifyStale({ status: "dispatched", pid: 11367, dispatchedAt: NOW - 1000 }, NOW, { alive: alivePid }),
+    { stale: false },
+    "活着且没超时不能误报",
+  );
+});
+
+test("classifyStale：已出结论的状态与缺 dispatchedAt 的历史记录都不判", () => {
+  for (const status of ["reviewed", "applied", "rolled-back", "stale", "abandoned"]) {
+    assert.deepEqual(classifyStale({ status, pid: 1, dispatchedAt: NOW - 10 * 60 * MINUTE }, NOW, { alive: deadPid }), { stale: false });
+  }
+  assert.deepEqual(classifyStale({ status: "dispatched", pid: 1 }, NOW, { alive: deadPid }), { stale: false });
+});
+
+test("spawnDetached：stdout+stderr 指向 logFile，子进程写入能落到文件", () => {
+  const dir = tmpDir();
+  const logFile = path.join(dir, "runs", "run-1", CHILD_LOG);
+  let seen: Record<string, unknown> = {};
+  const child = spawnDetached(
+    (command, args, options) => {
+      seen = { command, args, options };
+      const stdio = options.stdio as [string, number, number];
+      // 父进程的 fd 此刻还开着：用 fs 模拟子进程写日志（不真起进程）
+      fs.writeSync(stdio[1], "子进程崩了\n");
+      return { pid: 4242, unref: () => {} };
+    },
+    "/bin/pi",
+    ["-p", "--no-session", "-ns", "prompt"],
+    { cwd: dir, env: {}, logFile },
+  );
+  assert.equal(child.pid, 4242);
+  const stdio = seen.options.stdio as [string, number, number];
+  assert.deepEqual([stdio[0], stdio[1] === stdio[2], typeof stdio[1]], ["ignore", true, "number"]);
+  assert.equal(seen.options.detached, true);
+  assert.equal(fs.readFileSync(logFile, "utf8"), "子进程崩了\n");
+});
+
+test("spawnDetached：日志文件开不出来时退回 stdio:\"ignore\"，不阻断派发", () => {
+  let stdio: unknown = null;
+  const child = spawnDetached(
+    (_command, _args, options) => {
+      stdio = options.stdio;
+      return { pid: 1, unref: () => {} };
+    },
+    "/bin/pi",
+    [],
+    { cwd: "/", env: {}, logFile: "/r/不许写的目录/child.log" },
+  );
+  assert.equal(child.pid, 1);
+  assert.equal(stdio, "ignore");
+});
+
+test("督导进程同样落盘：supervisor.log 就在 run 目录里", () => {
+  const dir = tmpDir();
+  const runDir = path.join(dir, "runs", "run-1");
+  fs.mkdirSync(runDir, { recursive: true });
+  let stdio: unknown = null;
+  spawnReviewSupervisor({
+    runDir,
+    cwd: dir,
+    env: {},
+    spawnFn: (_command, _args, options) => {
+      stdio = options.stdio;
+      return { pid: 7777, unref: () => {} };
+    },
+  });
+  assert.equal(Array.isArray(stdio), true, "写法必须是 fd 数组");
+  assert.equal(fs.existsSync(path.join(runDir, SUPERVISOR_LOG)), true);
+});
+
+test("scanStaleRuns：子进程已死 → run.json 转 stale + run-error.json 带日志尾部 20 行", () => {
+  const dir = tmpDir();
+  const runDir = writeRun(dir, "354df7db-1794130855", { status: "dispatched", pid: 291916, dispatchedAt: NOW - 10 * MINUTE });
+  const lines = Array.from({ length: 25 }, (_value, index) => `日志第 ${index + 1} 行`);
+  fs.writeFileSync(path.join(runDir, CHILD_LOG), `${lines.join("\n")}\n`, "utf8");
+
+  const found = scanStaleRuns(dir, NOW, { alive: deadPid });
+  assert.equal(found.length, 1);
+  assert.deepEqual([found[0]!.runId, found[0]!.reason], ["354df7db-1794130855", "child-exited"]);
+  assert.equal(found[0]!.lastLine, "日志第 25 行");
+  assert.equal(readRun(runDir).status, "stale");
+
+  const error = readRunError(runDir);
+  assert.equal(error?.reason, "child-exited");
+  assert.equal(error?.at, NOW);
+  assert.equal(error?.childLogTail.length, 20, "只留最后 20 行");
+  assert.equal(error?.childLogTail[0], "日志第 6 行");
+  assert.equal(error?.childLogTail[19], "日志第 25 行");
+});
+
+test("scanStaleRuns：超时的 run 先 kill 再标 stale，重复扫描不重复写（幂等）", () => {
+  const dir = tmpDir();
+  const runDir = writeRun(dir, "run-timeout", { status: "dispatched", pid: 4321, dispatchedAt: NOW - 30 * MINUTE });
+  const killed: number[] = [];
+  const found = scanStaleRuns(dir, NOW, { alive: alivePid, kill: (pid) => killed.push(pid), maxRuntimeMs: 20 * MINUTE });
+  assert.deepEqual(killed, [4321]);
+  assert.equal(found[0]!.reason, "timeout");
+  assert.equal(readRun(runDir).status, "stale");
+  const before = fs.readFileSync(path.join(runDir, "run-error.json"), "utf8");
+  assert.deepEqual(scanStaleRuns(dir, NOW + MINUTE, { alive: alivePid, kill: (pid) => killed.push(pid) }), []);
+  assert.deepEqual(killed, [4321], "已标 stale 的不再 kill 第二次");
+  assert.equal(fs.readFileSync(path.join(runDir, "run-error.json"), "utf8"), before);
+});
+
+test("scanStaleRuns：活着且没超时的 run 一动不动；run.json 坏掉的目录直接跳过", () => {
+  const dir = tmpDir();
+  const runDir = writeRun(dir, "run-alive", { status: "dispatched", pid: 1, dispatchedAt: NOW - MINUTE });
+  const broken = path.join(dir, "runs", "broken");
+  fs.mkdirSync(broken, { recursive: true });
+  fs.writeFileSync(path.join(broken, "run.json"), "{ 不是 json", "utf8");
+  assert.deepEqual(scanStaleRuns(dir, NOW, { alive: alivePid }), []);
+  assert.equal(readRun(runDir).status, "dispatched");
+  assert.equal(fs.existsSync(path.join(runDir, "run-error.json")), false);
+});
+
+test("collectPanelState：reviewing 只数活着的 run，staleCount 覆盖「已落盘 + 判定命中」", () => {
+  const dir = tmpDir();
+  writeRun(dir, "r-dead", { status: "dispatched", pid: 291916, dispatchedAt: NOW - 10 * MINUTE });
+  writeRun(dir, "r-alive", { status: "dispatched", pid: 1, dispatchedAt: NOW - MINUTE });
+  writeRun(dir, "r-young", { status: "dispatched", pid: 291917, dispatchedAt: NOW - MINUTE });
+  writeRun(dir, "r-stale", { status: "stale", pid: 2, dispatchedAt: NOW - 20 * MINUTE });
+  const state = collectPanelState({ evolutionDir: dir, now: NOW, alive: (pid) => pid === 1, maxRuntimeMs: 20 * MINUTE });
+  assert.equal(state.reviewing, 2, "r-dead 超期且 pid 不在不再算「复盘」；r-alive 与宽限期内的 r-young 仍算");
+  assert.equal(state.staleCount, 2, "r-stale 已落盘 + r-dead 判定命中：两处口径必须一致，否则网页会出现「卡死 1、列表 2 条」");
+
+  // 5 分钟宽限内即使 pid 不在也还当在跑：与扫描共用同一口径，免得面板在子进程刚退出时闪一下
+  const youngDead = collectPanelState({ evolutionDir: dir, now: NOW, alive: deadPid, maxRuntimeMs: 20 * MINUTE });
+  assert.equal(youngDead.reviewing, 2, "宽限期内的 r-young 仍算在跑");
+  assert.equal(youngDead.staleCount, 2, "宽限期内的死 pid 不算卡死，只有已落盘的 r-stale 与超期的 r-dead");
+});
+
+test("collectPanelState：analyzed 的 run 进程死掉不算「复盘」，督导活着才算", () => {
+  const dir = tmpDir();
+  writeRun(dir, "a-dead", { status: "analyzed", pid: 3001, dispatchedAt: NOW - 2 * MINUTE });
+  writeRun(dir, "a-live", { status: "analyzed", pid: 1, dispatchedAt: NOW - 2 * MINUTE });
+  writeRun(dir, "a-sup", { status: "analyzed", pid: 3002, supervisorPid: 1, dispatchedAt: NOW - 3 * MINUTE });
+  const state = collectPanelState({ evolutionDir: dir, now: NOW, alive: (pid) => pid === 1 });
+  assert.equal(state.reviewing, 2, "a-dead 结论已出且进程不在：不再算「复盘」；a-live 与有活督导的 a-sup 算");
+});
+
+test("panelWidget / statusLine：卡死压过待批，且不显示「复盘 0」", () => {
+  const stale = { reviewing: 0, staleCount: 1, pendingApprovals: 2, lastAppliedAt: null, rollbackRate: 0, appliedSamples: 0 };
+  assert.deepEqual(panelWidget(stale), ["复盘失败 1 / 待批 2"]);
+  assert.equal(statusLine(stale), "复盘失败 1");
+  assert.deepEqual(panelWidget({ ...stale, staleCount: 0, pendingApprovals: 0 }), null, "全零仍然返回 null");
+});
+
+test("statusEntries：stale 也会发一条 /tree 条目", () => {
+  const entry = statusEntries([{ runId: "354df7db-1794130855", status: "stale" }], new Map(), NOW)[0];
+  assert.deepEqual([entry?.kind, entry?.runId], ["stale", "354df7db-1794130855"]);
+});
+
+test("renderStatus：卡死单列一行，带原因与日志最后一行", () => {
+  const text = renderStatus({
+    config: DEFAULT_CONFIG,
+    configPath: "/repo/.pi/evolution/config.json",
+    telemetryDir: "/repo/.pi/evolution/telemetry",
+    lockPid: undefined,
+    runs: [],
+    staleRuns: [{ runId: "354df7db-1794130855", runDir: "/repo/runs/x", reason: "child-exited", lastLine: "Error: 子进程崩了", at: NOW }],
+  });
+  assert.equal(text.includes("  卡死 1 条：354df7db（child-exited，日志最后一行：Error: 子进程崩了）"), true);
+  const noLog = renderStatus({
+    config: DEFAULT_CONFIG,
+    configPath: "/c.json",
+    telemetryDir: "/t",
+    lockPid: undefined,
+    runs: [],
+    staleRuns: [{ runId: "abc-1", runDir: "/repo/runs/y", reason: "timeout", lastLine: null, at: NOW }],
+  });
+  assert.equal(noLog.includes("卡死 1 条：abc（timeout，日志最后一行：无日志（child.log 不存在或为空））"), true);
+});
+
+test("renderStatus：同一会话的多条卡死 run 用完整 runId，不写成两行一样的", () => {
+  const text = renderStatus({
+    config: DEFAULT_CONFIG,
+    configPath: "/c.json",
+    telemetryDir: "/t",
+    lockPid: undefined,
+    runs: [],
+    staleRuns: [
+      { runId: "354df7db-1794130855", runDir: "/r/a", reason: "child-exited", lastLine: null, at: NOW },
+      { runId: "354df7db-1794131353", runDir: "/r/b", reason: "child-exited", lastLine: null, at: NOW },
+    ],
+  });
+  assert.equal(text.includes("卡死 2 条：354df7db-1794130855（"), true);
+  assert.equal(text.includes("354df7db-1794131353（"), true);
+});
+
+test("listStaleRuns：只列已判 stale 的，按派发时间倒序并带上日志最后一行", () => {
+  const dir = tmpDir();
+  const older = writeRun(dir, "old-1", { status: "stale", pid: 1, dispatchedAt: NOW - 60 * MINUTE });
+  writeRun(dir, "new-2", { status: "stale", pid: 2, dispatchedAt: NOW - 10 * MINUTE });
+  writeRun(dir, "live-3", { status: "dispatched", pid: 3, dispatchedAt: NOW - MINUTE });
+  // run-error.json 是 stale 条目的唯一权威来源：lastLine 取它里面的 childLogTail 尾部
+  fs.writeFileSync(
+    path.join(older, "run-error.json"),
+    JSON.stringify({ reason: "timeout", at: NOW, childLogTail: ["前一行", "最后一行"] }),
+    "utf8",
+  );
+  scanStaleRuns(dir, NOW, { alive: deadPid });
+  const runs = listStaleRuns(dir, 5);
+  assert.deepEqual(runs.map((run) => run.runId), ["new-2", "old-1"]);
+  assert.equal(runs[0]!.lastLine, null, "没有 run-error / 日志就是 null，不编内容");
+  assert.deepEqual([runs[1]!.lastLine, runs[1]!.reason], ["最后一行", "timeout"]);
+});

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

@@ -0,0 +1,145 @@
+/**
+ * 遥测单测（零依赖，node --test）。
+ *
+ * 运行：
+ *   cd .pi/extensions/skill-evolve
+ *   node --experimental-strip-types --test test/telemetry.test.ts
+ *
+ * 覆盖：除零返回 0（绝不返回 NaN）、disabled 技能不算曝光、未命中 top10 排序与截断、
+ * 按天分片写入与跨天读取、写入失败只记日志不抛。
+ */
+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 { createTelemetry, dayOf, directQueue, ratio, readEvents, shardFile, summarize, type MutationQueue, type TelemetryEvent, type TelemetrySkill } from "../lib/telemetry.ts";
+
+const NOW = new Date(2026, 10, 8, 15, 30, 0).getTime(); // 本地时间 2026-11-08 15:30
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-tele-"));
+}
+
+function skill(name: string, disabled = false): TelemetrySkill {
+  return { name, filePath: `/repo/.pi/skills/${name}/SKILL.md`, disabled, source: "project" };
+}
+
+function advertised(skills: TelemetrySkill[]): TelemetryEvent {
+  return { ts: NOW, iso: new Date(NOW).toISOString(), kind: "advertised", sessionId: "s1", skills };
+}
+
+test("ratio：除零与非法值一律返回 0", () => {
+  assert.equal(ratio(0, 0), 0);
+  assert.equal(ratio(3, 0), 0);
+  assert.equal(ratio(Number.NaN, 5), 0);
+  assert.equal(ratio(5, Number.POSITIVE_INFINITY), 0);
+  assert.equal(ratio(2, 4), 0.5);
+});
+
+test("summarize：空数据不产生 NaN", () => {
+  const summary = summarize([]);
+  assert.equal(summary.loadRate, 0);
+  assert.equal(Number.isNaN(summary.loadRate), false);
+  assert.equal(summary.advertised, 0);
+  assert.deepEqual(summary.missedTop, []);
+});
+
+test("summarize：disabled 技能不算曝光，加载率按有效曝光算", () => {
+  const events: TelemetryEvent[] = [
+    advertised([skill("a"), skill("b"), skill("c", true)]),
+    { ts: NOW, iso: "", kind: "loaded", sessionId: "s1", skill: "a" },
+    { ts: NOW, iso: "", kind: "failed", sessionId: "s1", skill: "b" },
+  ];
+  const summary = summarize(events);
+  assert.equal(summary.rounds, 1);
+  assert.equal(summary.advertised, 2);
+  assert.equal(summary.loaded, 1);
+  assert.equal(summary.failed, 1);
+  assert.equal(summary.loadRate, 0.5);
+});
+
+test("summarize：未命中 top10 按次数倒序、同名同次按名字排序、最多 10 条", () => {
+  const events: TelemetryEvent[] = [{ ts: NOW, iso: "", kind: "missed", sessionId: "s1", skill: "b" }];
+  events.push({ ts: NOW, iso: "", kind: "missed", skill: "b" });
+  events.push({ ts: NOW, iso: "", kind: "missed", skill: "a" });
+  for (let i = 0; i < 12; i += 1) events.push({ ts: NOW, iso: "", kind: "missed", skill: `z${String(i).padStart(2, "0")}` });
+  const summary = summarize(events);
+  assert.equal(summary.missed, 15);
+  assert.equal(summary.missedTop.length, 10);
+  assert.deepEqual(summary.missedTop[0], { skill: "b", count: 2 });
+  assert.deepEqual(summary.missedTop[1], { skill: "a", count: 1 });
+});
+
+test("dayOf / shardFile：按本地日期分片", () => {
+  assert.equal(dayOf(NOW), "2026-11-08");
+  assert.equal(shardFile("/x/telemetry", NOW), path.join("/x/telemetry", "2026-11-08.jsonl"));
+});
+
+test("createTelemetry：append 后 flush，跨天读取能读到今天的行", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-tel-"));
+  const writer = createTelemetry({ dir, queue: directQueue, enabled: true, now: () => NOW });
+  // 两次写之间必须 flush：测试里注入的是 directQueue（不串行），真实链路靠 withFileMutationQueue 保证同文件串行
+  writer.append({ kind: "advertised", sessionId: "s1", skills: [skill("a")] });
+  await writer.flush();
+  writer.append({ kind: "loaded", sessionId: "s1", skill: "a", how: "read", ok: true });
+  await writer.flush();
+
+  const file = shardFile(dir, NOW);
+  const lines = fs.readFileSync(file, "utf8").trim().split("\n");
+  assert.equal(lines.length, 2);
+  const first = JSON.parse(lines[0]);
+  assert.equal(first.kind, "advertised");
+  assert.equal(first.ts, NOW);
+  assert.equal(first.iso, new Date(NOW).toISOString());
+  assert.equal(summarize(readEvents(dir, 1, NOW)).loaded, 1);
+});
+
+test("createTelemetry：enabled=false 时完全不写盘", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-tel-"));
+  const writer = createTelemetry({ dir, queue: directQueue, enabled: false, now: () => NOW });
+  writer.append({ kind: "pending", sessionId: "s1" });
+  await writer.flush();
+  assert.equal(fs.existsSync(shardFile(dir, NOW)), false);
+});
+
+test("createTelemetry：写失败只记日志，不抛到调用方", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-tel-"));
+  const logs: string[] = [];
+  const failing: MutationQueue = async () => {
+    throw new Error("磁盘满了");
+  };
+  const writer = createTelemetry({ dir, queue: failing, enabled: true, now: () => NOW, log: (msg) => logs.push(msg) });
+  writer.append({ kind: "loaded", sessionId: "s1", skill: "a" });
+  await writer.flush();
+  assert.equal(logs.some((line) => line.includes("遥测写入失败")), true);
+});
+
+test("readEvents：目录不存在、天数非法、坏行都安全", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-tel-"));
+  fs.writeFileSync(shardFile(dir, NOW), '{"kind":"loaded","ts":1}\n不是 JSON\n\n', "utf8");
+  assert.equal(readEvents(dir, 1, NOW).length, 1);
+  assert.deepEqual(readEvents(path.join(dir, "不存在"), 1, NOW), []);
+  assert.equal(readEvents(dir, 0, NOW).length, 1, "days<=0 回退 7 天应能读到今天的分片");
+});
+
+test("appendSync：同步落盘（退出前补发路径，不能等异步队列）", () => {
+  const dir = tmpDir();
+  const telemetry = createTelemetry({ dir, queue: directQueue, enabled: true, log: () => {}, now: () => NOW });
+  telemetry.appendSync({ kind: "dispatched", sessionId: "s1", runId: "r1", pid: 42, trigger: "shutdown", ts: NOW });
+  const file = shardFile(dir, NOW);
+  assert.equal(fs.existsSync(file), true);
+  assert.equal(fs.readFileSync(file, "utf8").includes("\"trigger\":\"shutdown\""), true);
+});
+
+test("appendSync：目录不可写时只记日志，不抛", () => {
+  const dir = tmpDir();
+  const logs: string[] = [];
+  // 用一个「父路径是文件」的目录制造必然失败的 mkdir
+  const blocked = path.join(dir, "not-a-dir");
+  fs.writeFileSync(blocked, "x");
+  const telemetry = createTelemetry({ dir: path.join(blocked, "telemetry"), queue: directQueue, enabled: true, log: (msg) => logs.push(msg), now: () => NOW });
+  assert.doesNotThrow(() => telemetry.appendSync({ kind: "skipped", sessionId: "s1", why: "lock", trigger: "shutdown" }));
+  assert.equal(logs.some((line) => line.includes("遥测写入失败")), true);
+});

package/extensions/skill-evolve/test/ui-gate.test.ts

@@ -0,0 +1,77 @@
+/**
+ * TUI 闸（用户 2026-11-08：「tui 的这些推送不看了，影响我」）：
+ * `ui.widget` / `ui.entries` 为 false 时一次都不碰宿主 UI；显式打开才各写一次。
+ *
+ * 宿主用记录型假对象，不依赖 pi 运行时。
+ */
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { UiConfig } from "../lib/config.ts";
+import type { PanelEntry, PanelState } from "../lib/panel.ts";
+import { PANEL_ID, renderPanel, writeEntry, type UiPanelHost } from "../lib/ui-gate.ts";
+
+const OFF: UiConfig = { widget: false, entries: false };
+const ON: UiConfig = { widget: true, entries: true };
+
+function busyState(): PanelState {
+  return { reviewing: 1, staleCount: 1, pendingApprovals: 2, lastAppliedAt: null, rollbackRate: 0, appliedSamples: 0 };
+}
+
+interface Calls {
+  host: UiPanelHost;
+  widgets: (string[] | undefined)[];
+  statuses: (string | undefined)[];
+}
+
+function fakeHost(): Calls {
+  const widgets: (string[] | undefined)[] = [];
+  const statuses: (string | undefined)[] = [];
+  return {
+    widgets,
+    statuses,
+    host: {
+      setWidget: (id, content) => {
+        assert.equal(id, PANEL_ID);
+        widgets.push(content);
+      },
+      setStatus: (id, content) => {
+        assert.equal(id, PANEL_ID);
+        statuses.push(content);
+      },
+    },
+  };
+}
+
+test("renderPanel：ui.widget=false 时一次都不调 setWidget / setStatus", () => {
+  const calls = fakeHost();
+  renderPanel(calls.host, OFF, busyState());
+  assert.deepEqual(calls.widgets, []);
+  assert.deepEqual(calls.statuses, []);
+});
+
+test("renderPanel：ui.widget=true 时面板与状态栏各写一次", () => {
+  const calls = fakeHost();
+  renderPanel(calls.host, ON, busyState());
+  assert.equal(calls.widgets.length, 1);
+  assert.equal(calls.statuses.length, 1);
+  assert.ok((calls.widgets[0] ?? []).length > 0, "有数据时面板不该是空的");
+  assert.equal(typeof calls.statuses[0], "string");
+});
+
+test("writeEntry：ui.entries=false 时不写 /tree 条目，返回 false", () => {
+  const written: PanelEntry[] = [];
+  const ok = writeEntry<PanelEntry>(OFF, (entry) => written.push(entry), {
+    kind: "reviewed",
+    runId: "r1",
+    at: 1,
+  });
+  assert.equal(ok, false);
+  assert.deepEqual(written, []);
+});
+
+test("writeEntry：ui.entries=true 时写一次并返回 true", () => {
+  const written: PanelEntry[] = [];
+  const entry: PanelEntry = { kind: "dispatched", runId: "r1", at: 1 };
+  assert.equal(writeEntry<PanelEntry>(ON, (item) => written.push(item), entry), true);
+  assert.deepEqual(written, [entry]);
+});