pi-skill-evolve 0.0.0-stage → 0.1.2

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

@@ -0,0 +1,205 @@
+/**
+ * L0 遥测：append-only JSONL，按天分片 `.pi/evolution/telemetry/YYYY-MM-DD.jsonl`。
+ *
+ * 三条硬约定：
+ * 1. 写失败只记日志，绝不抛到主会话（采集器坏了不能影响用户干活）；
+ * 2. 每行同时存毫秒戳与 ISO 串（人读 ISO，机器算差值用毫秒）；
+ * 3. 这里只写事实，不做归因。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** 写入串行化：生产注入 pi 的 withFileMutationQueue，单测注入直写 */
+export type MutationQueue = <T>(filePath: string, fn: () => Promise<T>) => Promise<T>;
+
+export const directQueue: MutationQueue = async (_filePath, fn) => fn();
+
+export type TelemetryKind =
+  | "advertised"
+  | "loaded"
+  | "failed"
+  | "missed"
+  | "pending"
+  | "dispatched"
+  | "skipped"
+  | "superseded"
+  | "handler_error"
+  /** 机械归因结果：{kind:"attributed", skill, category, reason} */
+  | "attributed"
+  /** 硬禁令命中：{kind:"conflict", ruleId, level, skill, line} */
+  | "conflict";
+
+/** 曝光快照里的一条技能（filePath 可能为空：嵌入式调用缺该字段时要能兜底） */
+export interface TelemetrySkill {
+  name: string;
+  filePath: string;
+  disabled: boolean;
+  source: string;
+}
+
+export interface TelemetryEvent {
+  ts: number;
+  iso: string;
+  kind: TelemetryKind;
+  sessionId?: string;
+  [key: string]: unknown;
+}
+
+export type TelemetryInput = { kind: TelemetryKind; ts?: number; [key: string]: unknown };
+
+export interface MissedStat {
+  skill: string;
+  count: number;
+}
+
+export interface TelemetrySummary {
+  /** 跑了多少轮（advertised 事件数） */
+  rounds: number;
+  /** 曝光了多少个技能条目（各轮 skills 长度之和） */
+  advertised: number;
+  loaded: number;
+  failed: number;
+  missed: number;
+  /** 加载事件数 / 曝光条目数；重复加载会让它大于 1，读数时注意 */
+  loadRate: number;
+  missedTop: MissedStat[];
+}
+
+export interface TelemetryWriter {
+  append(event: TelemetryInput): void;
+  /** 同步追加：只给 `session_shutdown` 用（主进程马上退出，异步队列可能来不及落盘） */
+  appendSync(event: TelemetryInput): void;
+  flush(): Promise<void>;
+}
+
+/** 本地日期（YYYY-MM-DD）：报告按人看的「今天」对齐，不按 UTC */
+export function dayOf(ts: number): string {
+  const date = new Date(ts);
+  const pad = (value: number): string => String(value).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+export function shardFile(dir: string, ts: number): string {
+  return path.join(dir, `${dayOf(ts)}.jsonl`);
+}
+
+/** 除零返回 0，不返回 NaN/Infinity：报告里出现 NaN 比没数更糟 */
+export function ratio(part: number, total: number): number {
+  return Number.isFinite(part) && Number.isFinite(total) && total > 0 ? part / total : 0;
+}
+
+export function summarize(events: readonly TelemetryEvent[]): TelemetrySummary {
+  let rounds = 0;
+  let advertised = 0;
+  let loaded = 0;
+  let failed = 0;
+  let missed = 0;
+  const misses = new Map<string, number>();
+
+  for (const event of events) {
+    if (event.kind === "advertised") {
+      rounds += 1;
+      const skills = Array.isArray(event.skills) ? (event.skills as TelemetrySkill[]) : [];
+      // disableModelInvocation 的技能压根没进 prompt，不算曝光（它们属于归因 A 类，单独处理）
+      advertised += skills.filter((skill) => skill?.disabled !== true).length;
+    } else if (event.kind === "loaded") {
+      loaded += 1;
+    } else if (event.kind === "failed") {
+      failed += 1;
+    } else if (event.kind === "missed") {
+      missed += 1;
+      const skill = typeof event.skill === "string" ? event.skill : "(未知)";
+      misses.set(skill, (misses.get(skill) ?? 0) + 1);
+    }
+  }
+
+  const missedTop = [...misses.entries()]
+    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+    .slice(0, 10)
+    .map(([skill, count]) => ({ skill, count }));
+
+  return { rounds, advertised, loaded, failed, missed, loadRate: ratio(loaded, advertised), missedTop };
+}
+
+export function createTelemetry(options: {
+  dir: string;
+  queue: MutationQueue;
+  /** 可传 getter：`/skill-evolve on|off` 当场改配置后采集要立刻跟着变，不能靠重启会话 */
+  enabled: boolean | (() => boolean);
+  log?: (msg: string) => void;
+  now?: () => number;
+}): TelemetryWriter {
+  const log = options.log ?? (() => {});
+  const pending = new Set<Promise<void>>();
+  const enabledNow = (): boolean => (typeof options.enabled === "function" ? options.enabled() : options.enabled);
+
+  const recordOf = (event: TelemetryInput): { record: TelemetryEvent; file: string; line: string } => {
+    const ts = typeof event.ts === "number" && Number.isFinite(event.ts) ? event.ts : (options.now?.() ?? Date.now());
+    const record: TelemetryEvent = { ...event, ts, iso: new Date(ts).toISOString() };
+    const file = shardFile(options.dir, ts);
+    return { record, file, line: `${JSON.stringify(record)}\n` };
+  };
+
+  const append = (event: TelemetryInput): void => {
+    if (!enabledNow()) return;
+    const { file, line } = recordOf(event);
+    const write = options.queue(file, async () => {
+      await fs.promises.mkdir(path.dirname(file), { recursive: true });
+      await fs.promises.appendFile(file, line, "utf8");
+    });
+    const settled = write.then(
+      () => undefined,
+      (error: unknown) => {
+        log(`[skill-evolve] 遥测写入失败（${file}）：${String(error)}`);
+      },
+    );
+    pending.add(settled);
+    void settled.then(() => pending.delete(settled));
+  };
+
+  const appendSync = (event: TelemetryInput): void => {
+    if (!enabledNow()) return;
+    const { file, line } = recordOf(event);
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.appendFileSync(file, line, "utf8");
+    } catch (error) {
+      log(`[skill-evolve] 遥测写入失败（${file}）：${String(error)}`);
+    }
+  };
+
+  const flush = async (): Promise<void> => {
+    await Promise.all([...pending]);
+  };
+
+  return { append, appendSync, flush };
+}
+
+/** 读最近 days 天的事件（跨天分片按日期倒推，坏行跳过） */
+export function readEvents(dir: string, days: number, now: number = Date.now()): TelemetryEvent[] {
+  const span = Number.isFinite(days) && days > 0 ? Math.floor(days) : 7;
+  const events: TelemetryEvent[] = [];
+  for (let offset = span - 1; offset >= 0; offset -= 1) {
+    const day = new Date(now);
+    day.setDate(day.getDate() - offset);
+    const file = shardFile(dir, day.getTime());
+    let text: string;
+    try {
+      text = fs.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      if (line.trim().length === 0) continue;
+      try {
+        const parsed: unknown = JSON.parse(line);
+        if (parsed && typeof (parsed as TelemetryEvent).kind === "string") {
+          events.push(parsed as TelemetryEvent);
+        }
+      } catch {
+        // 坏行是旁路数据的常态，跳过即可，不影响报告结论
+      }
+    }
+  }
+  return events;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 界面推送闸：TUI 默认**零推送**（用户 2026-11-08：「tui 的这些推送不看了，影响我」）。
+ *
+ * 开关来自配置 `ui.widget` / `ui.entries`，默认全关；显式打开才调宿主的 setWidget / setStatus /
+ * appendEntry。实时状态另有出口，不需要占着对话区：
+ * `/skill-evolve status`、Web 面板（`/skill-evolve web`）、`.pi/evolution/logs/extension.log`。
+ *
+ * 为什么闸放在 lib 而不是 index.ts：index.ts 依赖 pi 包，`node --test` 里 import 不进来
+ * （找不到 `@earendil-works/pi-coding-agent`），只有下沉到 lib 才能被单测覆盖。
+ */
+import type { UiConfig } from "./config.ts";
+import { panelWidget, statusLine, type PanelState } from "./panel.ts";
+
+/** 宿主 TUI 的最小形状（pi 的 ctx.ui 结构兼容）：只声明本文件要用的两个方法 */
+export interface UiPanelHost {
+  setWidget(id: string, content: string[] | undefined): void;
+  setStatus(id: string, content: string | undefined): void;
+}
+
+export const PANEL_ID = "skill-evolve";
+
+/** widget 开关关着就一次都不调（连「清空」都不做）：默认零推送 */
+export function renderPanel(host: UiPanelHost, flags: UiConfig, state: PanelState): void {
+  if (!flags.widget) return;
+  host.setWidget(PANEL_ID, panelWidget(state) ?? undefined);
+  host.setStatus(PANEL_ID, statusLine(state) ?? undefined);
+}
+
+/** entries 开关关着就不写 `/tree` 条目；写入成功返回 true（单测按返回值断言） */
+export function writeEntry<T>(flags: UiConfig, write: (entry: T) => void, entry: T): boolean {
+  if (!flags.entries) return false;
+  write(entry);
+  return true;
+}

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

@@ -0,0 +1,299 @@
+/**
+ * 写操作的唯一入口：参数校验 → 调注入的回调 → 记一条审计。
+ *
+ * 三条纪律：
+ * 1. **不重写业务**：开关 / 派发 / 采纳 / 清理的实现都在 lib 与 index.ts 里，这里只做转发。
+ *    网页自己再实现一遍，就会变成「网页点的派发不走去抖、TUI 点的走」这种两套语义；
+ * 2. **成功与失败都留痕**：过了 csrf 的每次动作都写一条 actions.log，回调抛错也要写 ——
+ *    只记成功的审计等于「出事的时候什么都没有」；
+ * 3. **校验口径与 /approve 完全一致**：Content-Type / Host / Origin / 2KB / csrf 五道，
+ *    任何一道不过都不执行动作（`/action` 与 `/toggle` 不因为「是新增路径」就少一道）。
+ */
+import * as fs from "node:fs";
+import type * as http from "node:http";
+import * as path from "node:path";
+import { loadConfig, type ConfigFlag } from "../config.ts";
+import { FLAG_FIELDS, parseFlag } from "../flags.ts";
+import { appendAudit, type AuditAction, type AuditResult } from "./audit-log.ts";
+import { parseRedirectView } from "./filter.ts";
+import { FORM_TYPE, MAX_BODY_BYTES, readBody, sendBack, sendText, sourceDenied } from "./http.ts";
+import { readJson } from "./json-read.ts";
+import { resolveRunDir } from "./run-path.ts";
+import { CHILD_LOG } from "../spawn-plan.ts";
+import { SUPERVISOR_LOG } from "../review-spawn.ts";
+import { readLogTail } from "../stale.ts";
+
+/** `/action` 的 `name` 白名单：三个名字各自对应一个注入回调（开关走独立的 `/toggle?field=`） */
+export const ACTION_NAMES = ["run", "rerun", "cleanup"] as const;
+export type ActionName = (typeof ACTION_NAMES)[number];
+
+/** 一个写动作：返回给人看的结论（首行进 303 的 msg / err） */
+export type WebAction = (runId: string) => Promise<string>;
+/** 单个开关：`field` = telemetry（采集，不花 token）/ enabled（复盘，花 token）；`next` 由这里取反后传入 */
+export type ToggleHook = (field: ConfigFlag, next: boolean) => Promise<string>;
+/** 立即复盘 / 重跑：都是「触发一次新的复盘」，由 index.ts 接 evo.runNow */
+export type RunHook = () => Promise<string>;
+
+export interface WriteHooks {
+  /** 批准：由扩展注入 evo.apply.approve(runId, false)，与 TUI 同一条路 */
+  onApprove?: WebAction;
+  /** 拒绝：只改队列与 run.json 状态，不碰任何技能文件 */
+  onReject?: WebAction;
+  onToggle?: ToggleHook;
+  onRunNow?: RunHook;
+  /** 清理记录：只对 stale 放行，实现是把 run 目录移进 runs/.trash/ */
+  onCleanup?: WebAction;
+}
+
+export interface WriteContext extends WriteHooks {
+  evolutionDir: string;
+  csrf: string;
+  /** 实际监听端口（port=0 时只有监听后才知道）：Host / Origin 校验不接受外部声明 */
+  port(): number;
+}
+
+const POST_PATHS = new Set(["/approve", "/reject", "/action", "/toggle"]);
+/** 与 lib/report.ts 的 renderManualDispatch 首行对齐：能派发才是 ok，其余都是 partial */
+const DISPATCHED_PREFIX = "已派生复盘：";
+/** `child.log` 优先，其次 `supervisor.log`：前者是子进程自己的输出，会话细节都在里面 */
+const LOG_TAIL_LINES = 200;
+
+export function isPostPath(pathname: string): boolean {
+  return POST_PATHS.has(pathname);
+}
+
+/** 动作失败 / 校验失败时的统一收尾：一句人话 + 一条 error 审计（runId / field 原样入库） */
+function reject(
+  ctx: WriteContext,
+  response: http.ServerResponse,
+  action: AuditAction,
+  message: string,
+  extra: { runId?: string; field?: string } = {},
+): void {
+  console.error(`[skill-evolve] Web 面板 ${action} 被拒：${message}`);
+  appendAudit(ctx.evolutionDir, { at: Date.now(), action, ...extra, result: `error: ${message}`, via: "web" });
+  sendText(response, 400, `400：${message}\n`);
+}
+
+/** 本实例没注入回调 = 只读面板：403（路径合法，只是没有实现） */
+function rejectReadOnly(response: http.ServerResponse): void {
+  sendText(response, 403, "403：本实例只读（没注入写回调），不接受写操作\n");
+}
+
+function errorText(error: unknown): string {
+  const first = String(error).split("\n")[0]!.trim();
+  return first.length > 0 ? first.slice(0, 200) : "未知错误";
+}
+
+/**
+ * 派发类动作的结论：`已派生复盘：<runId>` 才算 ok，其余（总开关关 / 已有复盘在跑 / 去抖窗口里）
+ * 都是 partial。这不是抠字眼 —— 审计里 ok 与 partial 混在一起，回头就查不出「点了十次都没派发」。
+ */
+function dispatchResult(text: string): AuditResult {
+  return text.startsWith(DISPATCHED_PREFIX) ? "ok" : "partial";
+}
+
+/** 执行 + 记审计 + 303 回跳；回调抛错也回 303（网页不该因为一次动作出错就变成 500 页） */
+async function settle(
+  ctx: WriteContext,
+  response: http.ServerResponse,
+  action: AuditAction,
+  view: string,
+  call: () => Promise<string>,
+  extra: { runId?: string; field?: string } = {},
+): Promise<void> {
+  try {
+    const text = await call();
+    appendAudit(ctx.evolutionDir, {
+      at: Date.now(),
+      action,
+      ...extra,
+      result: action === "run" || action === "rerun" ? dispatchResult(text) : "ok",
+      via: "web",
+    });
+    sendBack(response, "msg", text, view);
+  } catch (error) {
+    const message = errorText(error);
+    console.error(`[skill-evolve] Web 面板 ${action} 失败：${message}`);
+    appendAudit(ctx.evolutionDir, { at: Date.now(), action, ...extra, result: `error: ${message}`, via: "web" });
+    sendBack(response, "err", message, view);
+  }
+}
+
+/** run.json 的 status；读不到就是 null —— 当它不是 stale（宁可不让清理，也不误移一个活着的 run） */
+function runStatusOf(runDir: string): string | null {
+  const raw = readJson<Record<string, unknown>>(path.join(runDir, "run.json"));
+  return typeof raw?.status === "string" ? raw.status : null;
+}
+
+/**
+ * 取 runId 并验目录：白名单 → 必须仍在 runs/ 下 → 必须真实存在。
+ * 三道都不过就在这里写一条 error 审计并回 400，调用方拿到 null 直接 return。
+ */
+function resolveTarget(
+  ctx: WriteContext,
+  response: http.ServerResponse,
+  action: AuditAction,
+  form: URLSearchParams,
+): { runId: string; runDir: string } | null {
+  const runId = (form.get("runId") ?? "").trim();
+  if (runId.length === 0) {
+    reject(ctx, response, action, "缺少 runId");
+    return null;
+  }
+  const runDir = resolveRunDir(ctx.evolutionDir, runId);
+  if (runDir === null) {
+    reject(ctx, response, action, "runId 不合法（只允许字母数字与 . _ -）", { runId });
+    return null;
+  }
+  if (!fs.existsSync(runDir)) {
+    reject(ctx, response, action, `找不到这个 run：${runId}`, { runId });
+    return null;
+  }
+  return { runId, runDir };
+}
+
+/** `POST /action`：三个名字各自校验参数，然后交给对应回调（开关另有 `/toggle`） */
+async function handleNamedAction(
+  ctx: WriteContext,
+  response: http.ServerResponse,
+  form: URLSearchParams,
+  view: string,
+): Promise<void> {
+  const raw = (form.get("name") ?? "").trim();
+  if (!(ACTION_NAMES as readonly string[]).includes(raw)) {
+    sendText(response, 400, `400：name 只认 ${ACTION_NAMES.join(" / ")}\n`);
+    return;
+  }
+  const action = raw as ActionName;
+  if (action === "run") {
+    const runNow = ctx.onRunNow;
+    if (!runNow) return rejectReadOnly(response);
+    await settle(ctx, response, action, view, () => runNow());
+    return;
+  }
+  if (action === "rerun") {
+    const runNow = ctx.onRunNow;
+    if (!runNow) return rejectReadOnly(response);
+    const target = resolveTarget(ctx, response, action, form);
+    if (target === null) return;
+    // 重跑不复用旧 runId：语义是「再派发一次复盘」，新旧两份结果都要留着对比
+    await settle(ctx, response, action, view, () => runNow(), { runId: target.runId });
+    return;
+  }
+  const cleanup = ctx.onCleanup;
+  if (!cleanup) return rejectReadOnly(response);
+  const target = resolveTarget(ctx, response, action, form);
+  if (target === null) return;
+  const status = runStatusOf(target.runDir);
+  if (status !== "stale") {
+    reject(ctx, response, action, `只有卡死（stale）的 run 能清理，当前状态：${status ?? "未知"}`, { runId: target.runId });
+    return;
+  }
+  await settle(ctx, response, action, view, () => cleanup(target.runId), { runId: target.runId });
+}
+
+/**
+ * `POST /toggle?field=telemetry|enabled`：只翻一个字段。五道校验与 /action 共用，
+ * 查询串只决定「翻哪一个」，不影响任何一道校验。
+ */
+async function handleToggleField(
+  ctx: WriteContext,
+  response: http.ServerResponse,
+  form: URLSearchParams,
+  url: URL,
+): Promise<void> {
+  const raw = url.searchParams.get("field");
+  const field = parseFlag(raw);
+  if (field === null) {
+    // 不猜：写错一个字段名绝不能静默改到另一个开关（把复盘当成采集翻，本意完全被丢掉）
+    const shown = raw === null ? "空" : raw;
+    reject(ctx, response, "toggle", `field 只认 ${FLAG_FIELDS.join(" / ")}（收到 ${shown}）`, raw === null ? {} : { field: raw });
+    return;
+  }
+  const toggle = ctx.onToggle;
+  if (!toggle) return rejectReadOnly(response);
+  // 取反用的是「读配置」而不是页面上的旧文字：两个标签页开着同一个面板时，页面显示的状态可能已经过期
+  const next = !loadConfig(ctx.evolutionDir)[field];
+  await settle(ctx, response, "toggle", parseRedirectView(form.get("view")), () => toggle(field, next), { field });
+}
+
+/**
+ * POST 总入口。校验顺序与历史一致：路径白名单 → Content-Type → Host/Origin → 体积 → csrf，
+ * 之后才看「这个动作有没有实现」。顺序本身就是信息：csrf 不对的请求连 runId 都不该被读。
+ */
+export async function handlePost(
+  ctx: WriteContext,
+  request: http.IncomingMessage,
+  response: http.ServerResponse,
+  url: URL,
+): Promise<void> {
+  if (!POST_PATHS.has(url.pathname)) {
+    response.setHeader("allow", "GET");
+    sendText(response, 405, "405：面板只提供 GET，写操作只有 /approve、/reject、/action 与 /toggle?field=\n");
+    return;
+  }
+  const type = String(request.headers["content-type"] ?? "").split(";")[0]!.trim().toLowerCase();
+  if (type !== FORM_TYPE) {
+    sendText(response, 415, `415：Content-Type 必须是 ${FORM_TYPE}\n`);
+    return;
+  }
+  const denied = sourceDenied(request, ctx.port());
+  if (denied) {
+    sendText(response, 403, `403：${denied}\n`);
+    return;
+  }
+  const body = await readBody(request, MAX_BODY_BYTES);
+  if (body === null) {
+    sendText(response, 413, `413：请求体超过 ${MAX_BODY_BYTES} 字节\n`);
+    return;
+  }
+  const form = new URLSearchParams(body);
+  // csrf 先比：令牌不对就什么都不做，连 name / runId 都不看
+  if (form.get("csrf") !== ctx.csrf) {
+    sendText(response, 403, "403：csrf 校验失败，本次请求未执行任何动作\n");
+    return;
+  }
+  if (url.pathname === "/toggle") {
+    await handleToggleField(ctx, response, form, url);
+    return;
+  }
+  if (url.pathname === "/action") {
+    // 回跳页由表单里的 view 决定：控制条动作用户在哪一页点的，就回哪一页
+    await handleNamedAction(ctx, response, form, parseRedirectView(form.get("view")));
+    return;
+  }
+  const action: AuditAction = url.pathname === "/approve" ? "approve" : "reject";
+  const run = action === "approve" ? ctx.onApprove : ctx.onReject;
+  if (!run) return rejectReadOnly(response);
+  const runId = (form.get("runId") ?? "").trim();
+  if (runId.length === 0) {
+    // 与 /action 的校验失败同一种收尾：失败也要在审计里留一条
+    reject(ctx, response, action, "缺少 runId");
+    return;
+  }
+  await settle(ctx, response, action, "approvals", () => run(runId), { runId });
+}
+
+/**
+ * `GET /log?runId=`：只读，不做 csrf（没有副作用，也不会改任何状态）。
+ * 内容只可能是 run 目录下的两个日志文件之一，且 runId 过了白名单 + 目录归属校验，否则一律 404 ——
+ * 404 而不是 403，是因为「这个 run 不存在」与「你想读别人的文件」不该给出可区分的回答。
+ */
+export function handleLog(evolutionDir: string, response: http.ServerResponse, url: URL): void {
+  const runId = (url.searchParams.get("runId") ?? "").trim();
+  const runDir = resolveRunDir(evolutionDir, runId);
+  if (runDir === null || !fs.existsSync(runDir)) {
+    sendText(response, 404, `404：没有这个 run 的日志（runId=${runId}）\n`);
+    return;
+  }
+  const lines = readLogTail(path.join(runDir, CHILD_LOG), LOG_TAIL_LINES);
+  const source = lines.length > 0 ? CHILD_LOG : SUPERVISOR_LOG;
+  const tail = lines.length > 0 ? lines : readLogTail(path.join(runDir, SUPERVISOR_LOG), LOG_TAIL_LINES);
+  if (tail.length === 0) {
+    sendText(response, 404, `404：${runId} 还没有日志（${CHILD_LOG} 与 ${SUPERVISOR_LOG} 都不存在或为空）\n`);
+    return;
+  }
+  // 首行写清这是谁的哪份日志：面板上点「看日志」看到的是纯文本，没有它分不清是子进程还是监督进程
+  sendText(response, 200, `# ${runId} · ${source}（末 ${tail.length} 行）\n${tail.join("\n")}\n`);
+}

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

@@ -0,0 +1,57 @@
+/**
+ * 顶部控制条要的两个事实：总开关现在是什么状态、最后一次动作发生在什么时候。
+ *
+ * 「最后活动」取两个来源的较大值：`runs/<runId>/run.json` 的 dispatchedAt（复盘派发）与遥测最新事件的 ts（采集）。
+ * 一个记录都没有就返回 null，让页面写「还没有任何记录」—— 绝不能拿 now 顶替，
+ * 否则一台刚装好、什么都没跑过的机器会显示「刚刚有活动」。
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../config.ts";
+import { listRuns } from "../runs.ts";
+import { readLogTail } from "../stale.ts";
+
+export interface WebControls {
+  /** 采集遥测开关（config.telemetry，与 `/skill-evolve collect` 同一个字段）：只写本地 jsonl，不花 token */
+  telemetry: boolean;
+  /** 自动复盘开关（config.enabled，与 `/skill-evolve review` 同一个字段）：派生子进程，花 token */
+  enabled: boolean;
+  lastActivityAt: number | null;
+}
+
+/** 只需要「最新那一条」，但 dispatchedAt 为 null 的 run 会占名额，多取一些兜住 */
+const RUN_SCAN_LIMIT = 50;
+/** 一天一个分片，最后一条就是最新的；50 行足够跳过坏行与残行 */
+const TELEMETRY_TAIL_LINES = 50;
+
+function latestTelemetryTs(telemetryDir: string): number | null {
+  let names: string[];
+  try {
+    names = fs.readdirSync(telemetryDir).filter((name) => name.endsWith(".jsonl"));
+  } catch {
+    return null; // 没开过采集 = 没有分片目录，不是错误
+  }
+  // 分片名是 YYYY-MM-DD.jsonl：字典序倒排即时间倒排，第一个读得出 ts 的分片就是最新的
+  for (const name of names.sort().reverse()) {
+    const lines = readLogTail(path.join(telemetryDir, name), TELEMETRY_TAIL_LINES);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      try {
+        const ts = (JSON.parse(lines[index]!) as { ts?: unknown }).ts;
+        if (typeof ts === "number" && Number.isFinite(ts)) return ts;
+      } catch {
+        // 坏行（写入中途被杀）继续往前找，不能因为最后一行坏了就说「没有活动」
+      }
+    }
+  }
+  return null;
+}
+
+export function collectControls(evolutionDir: string): WebControls {
+  let latest = latestTelemetryTs(path.join(evolutionDir, "telemetry"));
+  for (const run of listRuns(evolutionDir, RUN_SCAN_LIMIT)) {
+    if (run.dispatchedAt === null) continue;
+    if (latest === null || run.dispatchedAt > latest) latest = run.dispatchedAt;
+  }
+  const config = loadConfig(evolutionDir);
+  return { telemetry: config.telemetry, enabled: config.enabled, lastActivityAt: latest };
+}

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

@@ -0,0 +1,64 @@
+/**
+ * 「已采纳」列表的数据：队列里 `status="applied"` 的条目 + 提案摘要 + 五闸结果。
+ *
+ * 为什么单独一个文件：「已采纳」是用户要反复回看的一页（改了什么、五闸过没过、什么时候落的地），
+ * 它的字段比其它列表都多（提案类型 / 行数 / 采纳时刻 / 逐闸结果），塞回 data.ts 会把那个文件推过 300 行。
+ *
+ * 只读：读 02-proposal.json、04-decision.json、06-verify.json，一个都不写。
+ */
+import * as path from "node:path";
+import { readVerify } from "../apply.ts";
+import { readProposalSummary } from "../proposal.ts";
+import type { QueueItem } from "../queue.ts";
+import { asNumber, asText, readJson } from "./json-read.ts";
+
+/** 已采纳列表上限：与 DONE_LIMIT 同量级 —— 网页看近期，不是审计日志 */
+export const APPLIED_LIMIT = 50;
+
+/** 一个已采纳条目：技能 · 提案类型 · +N/-M · 采纳时间 · 五闸是否全 ok */
+export interface AppliedItem {
+  runId: string;
+  /** auto（不需要人） / approval（人批） */
+  level: string;
+  skill: string;
+  /** 提案类型：improve / create / merge / prune；读不到 02-proposal.json 时写「—」 */
+  type: string;
+  added: number;
+  removed: number;
+  /** 采纳时间：取 04-decision.json 的 at（队列 createdAt 是入队时刻），读不到退回入队时刻 */
+  appliedAt: number | null;
+  /** 五闸逐条（06-verify.json）；没有记录就是空数组 */
+  gates: { gate: string; name: string; ok: boolean }[];
+  /** 五闸是否全 ok；null = 没有 06-verify.json（判不了，不能显示成失败） */
+  gatesOk: boolean | null;
+}
+
+/**
+ * 采纳时刻为什么取 04-decision.json 而不是队列 createdAt：
+ * 队列 createdAt 是**入队**时刻（可能比批准早几小时），用户看「已采纳」要看的是技能文件真正落地的时刻。
+ */
+export function buildApplied(items: readonly QueueItem[], evolutionDir: string): AppliedItem[] {
+  const rows: AppliedItem[] = [];
+  for (const item of items) {
+    if (item.status !== "applied") continue;
+    const runDir = path.join(evolutionDir, "runs", item.runId);
+    const proposal = readProposalSummary(runDir);
+    const verify = readVerify(runDir);
+    const decision = readJson<Record<string, unknown>>(path.join(runDir, "04-decision.json"));
+    const gates = Array.isArray(verify?.gates)
+      ? verify.gates.map((gate) => ({ gate: asText(gate.gate), name: asText(gate.name), ok: gate.ok === true }))
+      : [];
+    rows.push({
+      runId: item.runId,
+      level: item.level,
+      skill: item.skill.length > 0 ? item.skill : (proposal?.skill ?? ""),
+      type: proposal?.type ?? asText(item.proposalType, "—"),
+      added: proposal?.added ?? 0,
+      removed: proposal?.removed ?? 0,
+      appliedAt: asNumber(decision?.at) ?? asNumber(item.createdAt),
+      gates,
+      gatesOk: verify ? gates.every((gate) => gate.ok) : null,
+    });
+  }
+  return rows.sort((a, b) => (b.appliedAt ?? 0) - (a.appliedAt ?? 0)).slice(0, APPLIED_LIMIT);
+}