pi-skill-evolve 0.1.2 → 0.1.4

package/extensions/skill-evolve/index.ts

@@ -99,7 +99,7 @@ export default function skillEvolve(pi: ExtensionAPI): void {
         ...(port === undefined ? {} : { port }),
         onApprove: (runId) => evo.apply.approve(runId, false),
         onReject: (runId) => evo.apply.reject(runId),
-        onToggle: (field, next) => evo.setFlag(field, next), // 两个开关各自一个入口
+        onToggle: (field, next) => evo.setFlag(field, next), // 四个开关各自一个入口，网页点哪个只切哪个
         // 会话文件为空是允许的：派发时按「没有索引」处理，不会因为从网页点就少走一道
         onRunNow: () => evo.runNow({ sessionId: "web-panel" }),
         onCleanup: async (runId) => moveRunToTrash(evolutionDirOf(cwd), runId),
@@ -246,7 +246,7 @@ export default function skillEvolve(pi: ExtensionAPI): void {
 
   pi.registerCommand("skill-evolve", {
     description:
-      "技能进化：status 状态 / report 近 7 天报告（--week 周报） / run 立即复盘 / baseline 接受存量 P0 / audit 机械审计 / approve 采纳某条 run / queue 采纳队列 / web 网页面板（--port N 换端口，--once 不写配置） / selftest 评审必红自检 / config 选模型 / collect 只开采集遥测（不花 token） / review 只开自动复盘（花 token） / on / off 两个一起开关",
+      "技能进化：status 状态 / report 近 7 天报告（--week 周报） / run 立即复盘 / baseline 接受存量 P0 / audit 机械审计 / approve 采纳某条 run / queue 采纳队列 / web 网页面板（--port N 换端口，--once 不写配置） / selftest 评审必红自检 / config 选模型 / collect 只开采集遥测（不花 token） / dispatch 只开自动复盘（花 token） / review 只开自动评审（提案后再起督导，再花一份 token） / apply 只开自动采纳（auto 提案自动落盘） / on 复盘+评审两开（不动采集与采纳） / off 四个全关",
     getArgumentCompletions: (prefix) => matchSubcommand(prefix),
     handler: async (args, ctx) => {
       try {

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

@@ -24,9 +24,11 @@ export const SUBCOMMANDS: readonly SubcommandItem[] = [
   { value: "web", label: "web", description: "启动本机 Web 面板（127.0.0.1:7788，--port N 换端口，--once 不写进配置）" },
   { value: "config", label: "config", description: "选提案/评审模型（inherit = 跟随主会话）" },
   { value: "collect", label: "collect", description: "只开/关遥测采集（on|off；只写本地日志，不花 token）" },
-  { value: "review", label: "review", description: "只开/关自动复盘（on|off；会派生子进程，花 token）" },
-  { value: "on", label: "on", description: "采集与派生一起打开" },
-  { value: "off", label: "off", description: "采集与派生一起关闭" },
+  { value: "dispatch", label: "dispatch", description: "只开/关自动复盘（on|off；会派生子进程，花 token）" },
+  { value: "review", label: "review", description: "只开/关自动评审（on|off；提案后再起督导，再花一份 token）" },
+  { value: "apply", label: "apply", description: "只开/关自动采纳（on|off；auto 提案自动落盘，可回滚）" },
+  { value: "on", label: "on", description: "只打开自动复盘（采集 / 评审 / 采纳都不动）" },
+  { value: "off", label: "off", description: "四个开关（采集/复盘/评审/采纳）一起关闭" },
 ];
 
 /** 补全：前缀命中就只给命中项；一个都没命中时给全量，避免用户看到空列表 */
@@ -78,8 +80,8 @@ export async function runCommand(args: string, evo: Evolution, target: CommandTa
   // 非 TUI 兜底：真正能交互选模型的路径在 index.ts（那里才拿得到 ctx.ui.select）
   if (command === "config") return runConfigCommand(null, evo.model, arg);
   if (command === "on" || command === "off") return evo.setEnabled(command === "on");
-  // `collect on|off` 只动 telemetry、`review on|off` 只动 enabled：缺参数或写错就给用法，一概不改配置
-  if (command === "collect" || command === "review") {
+  // `collect / dispatch / review / apply on|off` 各自只动一个字段：缺参数或写错就给用法，一概不改配置
+  if (command === "collect" || command === "dispatch" || command === "review" || command === "apply") {
     const field: ConfigFlag = COMMAND_FLAG[command];
     const value = arg === "on" ? true : arg === "off" ? false : null;
     if (value === null) {

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

@@ -1,7 +1,15 @@
 /**
  * 技能进化配置：唯一来源是 `.pi/evolution/config.json`。
  *
- * **默认全关**（`enabled:false` + `telemetry:false`）：别人 clone 下来什么都不写、不派生、不留痕迹；
+ * **四个开关默认全关**（采集 `telemetry` / 复盘 `enabled` / 评审 `autoReview` / 采纳 `autoApply` 都是 false，
+ * 2026-11-08 用户定「autoReview 默认也关」）：别人 clone 下来不采集、不派生、不评审、不落盘，零 token 开销。
+ * 要用就一条一条显式打开（`collect` / `dispatch` / `review` / `apply`），谁开谁负责。
+ * 每一档花不花 token：
+ * - 采集遥测：只写本地 jsonl，**不花 token**；
+ * - 自动复盘：起子进程跑 agent，**花 token**；
+ * - 自动评审：复盘出了提案再起一个督导子进程，**再花一份 token**；
+ * - 自动采纳：改 `.pi/skills/` 与 `.cursor/` 文件，**不花 token，但会动仓库文件**（可回滚）。
+ *
  * 只有显式 `/skill-evolve on` 才写这个文件（`config.json` 也是本机偏好，进 `.gitignore`，断然不能入库
  * —— 否则一个人开了，提交一推，整个团队都被打开）。
  */
@@ -32,15 +40,17 @@ export interface WebConfig {
 }
 
 /**
- * 两个独立开关的字段名：
- * - `enabled`   = 派生复盘（会起子进程跑 agent，**花 token**）
- * - `telemetry` = 采集遥测（每轮一条曝光/加载/派生记录，只写本地 jsonl，**不花 token**）
- * 字段级分开之后，命令（collect / review）与 Web 控制条都只切其中一个。
+ * 四个独立开关的字段名（用户 2026-11-08：「自动复盘后，还有自动评审、自动采纳的流程，开关也独立出来」）：
+ * - `enabled`    = 派生复盘（起子进程跑 agent，**花 token**）
+ * - `telemetry`  = 采集遥测（只写本地 jsonl，**不花 token**）
+ * - `autoReview` = 提案后的自动评审（再起一个督导子进程，**再花一份 token**）
+ * - `autoApply`  = auto 级提案自动落盘（改 `.pi/skills/` 与 `.cursor/`，**可回滚**）
+ * 字段级分开之后，命令（collect / dispatch / review / apply）与 Web 控制条都只切其中一个。
  */
-export type ConfigFlag = "enabled" | "telemetry";
+export type ConfigFlag = "enabled" | "telemetry" | "autoReview" | "autoApply";
 
 export interface EvolutionConfig {
-  /** 派生总开关：false 时一律不派生（`/skill-evolve on|off` 会与 telemetry 一起切；`review` 只切它） */
+  /** 派生总开关：false 时一律不派生（`/skill-evolve on` 与自动评审一起开、`off` 全关；`dispatch` 只切它） */
   enabled: boolean;
   /** 去抖窗口（毫秒）：窗口内再次 settled 只记 superseded，不叠加派生 */
   idleMs: number;
@@ -50,6 +60,10 @@ export interface EvolutionConfig {
   perSessionCap: number;
   /** L0 遥测采集开关（默认关：采集会在 `.pi/evolution/telemetry/` 落盘；`collect` 只切它） */
   telemetry: boolean;
+  /** 自动评审开关（默认开：复盘出了提案就起评审督导；关掉后 run 停在 proposed 等人工批准） */
+  autoReview: boolean;
+  /** 自动采纳开关（默认关：只有 description / `.cursor` stub / AGENTS.md 索引行这三类 auto 提案会落盘，且须人工先开） */
+  autoApply: boolean;
   /** 界面推送开关：默认全关（想回 TUI 面板就显式打开） */
   ui: UiConfig;
   /** Web 面板：默认不起（谁也没要过就不该占端口），端口按约定值 7788 */
@@ -62,6 +76,11 @@ export const DEFAULT_CONFIG: Readonly<EvolutionConfig> = Object.freeze({
   maxRuntimeMs: 20 * 60_000,
   perSessionCap: 20,
   telemetry: false,
+  // 自动评审默认关（2026-11-08 用户定）：评审本身也要起子进程再花一份 token，
+  // 不能让「打开复盘」顺手把 token 翻倍。要评审就显式 `/skill-evolve review on`。
+  autoReview: false,
+  // 自动采纳默认关：它改的是仓库文件，必须人工先开一次；默认开等于替用户做决定。
+  autoApply: false,
   ui: Object.freeze({ widget: false, entries: false }),
   // Web 面板是「管理界面」，默认随 pi 启动；它与采集/派生（enabled / telemetry）是两回事，
   // 后者默认关闭——面板起来不等于开始花 token。2026-11-08 用户定。
@@ -104,6 +123,8 @@ export function normalizeConfig(raw: unknown, log: (msg: string) => void = () =>
     maxRuntimeMs: positiveInt(input.maxRuntimeMs, DEFAULT_CONFIG.maxRuntimeMs),
     perSessionCap: positiveInt(input.perSessionCap, DEFAULT_CONFIG.perSessionCap),
     telemetry: bool(input.telemetry, DEFAULT_CONFIG.telemetry),
+    autoReview: bool(input.autoReview, DEFAULT_CONFIG.autoReview),
+    autoApply: bool(input.autoApply, DEFAULT_CONFIG.autoApply),
     ui: {
       widget: bool(ui.widget, DEFAULT_CONFIG.ui.widget),
       entries: bool(ui.entries, DEFAULT_CONFIG.ui.entries),
@@ -139,8 +160,8 @@ export function loadConfig(evolutionDir: string, log: (msg: string) => void = ()
 }
 
 /**
- * 只写一个开关（`/skill-evolve collect|review`、Web 控制条的单个开关）：
- * 目标字段按传入值写，其余键（另一个开关、去抖 / 上限、ui / web 块）原样保留。
+ * 只写一个开关（`/skill-evolve collect|dispatch|review|apply`、Web 控制条的单个开关）：
+ * 目标字段按传入值写，其余键（其它三个开关、去抖 / 上限、ui / web 块）原样保留。
  * 返回归一化后的新配置，调用方用 Object.assign 原地更新正在用的那份。
  */
 export async function saveFlag(
@@ -160,17 +181,27 @@ export async function saveFlag(
 }
 
 /**
- * 一键全开/全关（`/skill-evolve on|off`）：两次单字段写入，语义仍是「采集与派生一起切」。
- * 保留这个入口是因为「先全关再走」比连点两个开关更不容易漏 —— 但它不再是唯一的开关路径。
- * 两次写在同一队列里顺序执行，最终状态一定是两个字段都等于 `on`。
+ * 一键切换（`/skill-evolve on|off`）：
+ * - `on`  = 复盘 + 评审两开（**不动采集，也不动自动采纳**）：这两项才是「花 token 的那条流水线」；
+ * - `off` = 四个全关（连采集与自动采纳一起停），因为「先全关再走」比连点四个开关更不容易漏。
+ * 一次读 + 一次写，四个键落在同一个事务里，不会出现「写了一半」的中间态。
  */
 export async function saveConfigSwitch(
   evolutionDir: string,
   on: boolean,
   queue: MutationQueue,
 ): Promise<EvolutionConfig> {
-  await saveFlag(evolutionDir, "enabled", on, queue);
-  return saveFlag(evolutionDir, "telemetry", on, queue);
+  const raw = readRawConfig(evolutionDir);
+  const patch = on
+    ? { enabled: true }
+    : { enabled: false, telemetry: false, autoReview: false, autoApply: false };
+  const next = normalizeConfig({ ...raw, ...patch });
+  const file = configFile(evolutionDir);
+  await queue(file, async () => {
+    await fs.promises.mkdir(evolutionDir, { recursive: true });
+    await fs.promises.writeFile(file, `${JSON.stringify({ ...raw, ...next }, null, 2)}\n`, "utf8");
+  });
+  return next;
 }
 
 /**

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

@@ -21,7 +21,8 @@ import { mergePendingRounds } from "./pending.ts";
 import { watchRunChild } from "./run-watch.ts";
 import { spawnReviewSupervisor, type SupervisorSpawn } from "./review-spawn.ts";
 import { guardBusy } from "./single-flight.ts";
-import { flushPendingSync, type PendingRounds, type ShutdownResult } from "./shutdown-dispatch.ts";
+import { drainPending } from "./drain-pending.ts";
+import type { PendingRounds } from "./shutdown-dispatch.ts";
 import type { MutationQueue, TelemetryWriter } from "./telemetry.ts";
 
 export interface DispatchInput {
@@ -241,6 +242,7 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
       dispatchCount.set(input.sessionId, (dispatchCount.get(input.sessionId) ?? 0) + 1);
       watchRunChild(child, { runDir, queue: deps.queue, log, onExit: releaseOnce });
       // 同一次派发再起一个独立督导：等 02-proposal.json → 另起评审进程 → 写 03-review.*
+      // 开关在这里现读（用户可能中途 review on/off）；关着时由 spawnReviewSupervisor 自己拒绝并记日志
       spawnReviewSupervisor({
         runDir,
         cwd: deps.cwd,
@@ -248,6 +250,7 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
         reviewModel: deps.reviewModel?.() ?? "inherit",
         spawnFn: deps.supervisorSpawnFn,
         sessionId: input.sessionId, telemetry: deps.telemetry, ...(deps.alive ? { alive: deps.alive } : {}),
+        autoReview: deps.config.autoReview,
         log,
       });
       return { status: "dispatched", run: { runId, runDir, pid: record.pid } };
@@ -261,39 +264,29 @@ export function createDispatcher(deps: DispatchDeps): Dispatcher {
   const flushPending = (): number => {
     if (pending.size === 0) return 0;
     const at = now();
-    let dispatched = 0;
-    for (const item of [...pending.values()]) {
-      let result: ShutdownResult = "failed";
-      try {
-        result = flushPendingSync(
-          item,
-          {
-            evolutionDir: deps.evolutionDir,
-            cwd: deps.cwd,
-            promptTemplatePath: deps.promptTemplatePath,
-            maxRuntimeMs: deps.config.maxRuntimeMs,
-            telemetry: deps.telemetry,
-            env,
-            spawnFn: deps.spawnFn ?? (spawn as unknown as SpawnLike),
-            ...(deps.reviewModel ? { reviewModel: deps.reviewModel() } : {}),
-            ...(deps.supervisorSpawnFn ? { supervisorSpawnFn: deps.supervisorSpawnFn } : {}), ...(deps.alive ? { alive: deps.alive } : {}),
-            log,
-          },
-          at,
-        );
-      } catch (error) {
-        // flushPendingSync 自己已 try/catch；这里再兜一层，退出路径不允许抛
-        log(`[skill-evolve] 退出补发失败：${String(error)}`);
-      }
-      if (result === "dispatched") {
-        dispatched += 1;
-        lastDispatchAt.set(item.sessionId, at);
-        dispatchCount.set(item.sessionId, (dispatchCount.get(item.sessionId) ?? 0) + 1);
-      }
-      // 退出是最后一次机会：无论成败都从这里清掉，避免 shutdown 被调用两次时重复派发
-      pending.delete(item.sessionId);
+    const sessions = drainPending(
+      pending,
+      {
+        evolutionDir: deps.evolutionDir,
+        cwd: deps.cwd,
+        promptTemplatePath: deps.promptTemplatePath,
+        maxRuntimeMs: deps.config.maxRuntimeMs,
+        autoReview: deps.config.autoReview,
+        telemetry: deps.telemetry,
+        env,
+        spawnFn: deps.spawnFn ?? (spawn as unknown as SpawnLike),
+        ...(deps.reviewModel ? { reviewModel: deps.reviewModel } : {}),
+        ...(deps.supervisorSpawnFn ? { supervisorSpawnFn: deps.supervisorSpawnFn } : {}),
+        ...(deps.alive ? { alive: deps.alive } : {}),
+        log,
+      },
+      at,
+    );
+    for (const sessionId of sessions) {
+      lastDispatchAt.set(sessionId, at);
+      dispatchCount.set(sessionId, (dispatchCount.get(sessionId) ?? 0) + 1);
     }
-    return dispatched;
+    return sessions.length;
   };
 
   return { dispatch: run, flushPending };

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

@@ -0,0 +1,65 @@
+/**
+ * 把「待复盘区间」一次性补发干净（dispatch 的 flushPending 只留状态更新）。
+ *
+ * 为什么单独一个文件：`dispatch.ts` 已经贴着 300 行闸门，而这段是**独立职责** ——
+ * 它只管遍历 pending 映射、逐条走同步补发、无论成败都把条目摘掉；
+ * 派发成功后的「上次派发时刻 / 本会话已派次数」属于 dispatch 自己的状态，用返回值交回去。
+ *
+ * 任何异常都不许冒出来：这条路径的调用方是退出钩子，抛出去等于把退出流程也弄坏。
+ */
+import { flushPendingSync, type PendingRounds, type ShutdownResult } from "./shutdown-dispatch.ts";
+import type { SupervisorSpawn } from "./review-spawn.ts";
+import type { SpawnLike } from "./spawn-plan.ts";
+import type { TelemetryWriter } from "./telemetry.ts";
+
+export interface DrainPendingOptions {
+  evolutionDir: string;
+  cwd: string;
+  promptTemplatePath: string;
+  maxRuntimeMs: number;
+  /** 自动评审开关（配置现读）：关着时补发照跑，但不起督导 */
+  autoReview: boolean;
+  telemetry: TelemetryWriter;
+  env: NodeJS.ProcessEnv;
+  spawnFn: SpawnLike;
+  /** 每个会话现算一次的评审模型（"inherit" 或 provider/model） */
+  reviewModel?: () => string;
+  supervisorSpawnFn?: SupervisorSpawn;
+  alive?: (pid: number) => boolean;
+  log: (msg: string) => void;
+}
+
+/** 返回这次真的派发成功的 sessionId（按 pending 的遍历顺序） */
+export function drainPending(pending: Map<string, PendingRounds>, options: DrainPendingOptions, at: number): string[] {
+  const dispatched: string[] = [];
+  for (const item of [...pending.values()]) {
+    let result: ShutdownResult = "failed";
+    try {
+      result = flushPendingSync(
+        item,
+        {
+          evolutionDir: options.evolutionDir,
+          cwd: options.cwd,
+          promptTemplatePath: options.promptTemplatePath,
+          maxRuntimeMs: options.maxRuntimeMs,
+          telemetry: options.telemetry,
+          env: options.env,
+          spawnFn: options.spawnFn,
+          autoReview: options.autoReview,
+          ...(options.reviewModel ? { reviewModel: options.reviewModel() } : {}),
+          ...(options.supervisorSpawnFn ? { supervisorSpawnFn: options.supervisorSpawnFn } : {}),
+          ...(options.alive ? { alive: options.alive } : {}),
+          log: options.log,
+        },
+        at,
+      );
+    } catch (error) {
+      // flushPendingSync 自己已 try/catch；这里再兜一层，退出路径不允许抛
+      options.log(`[skill-evolve] 退出补发失败：${String(error)}`);
+    }
+    if (result === "dispatched") dispatched.push(item.sessionId);
+    // 退出是最后一次机会：无论成败都从这里清掉，避免 shutdown 被调用两次时重复派发
+    pending.delete(item.sessionId);
+  }
+  return dispatched;
+}

package/extensions/skill-evolve/lib/evolution-apply.ts

@@ -17,11 +17,18 @@ import { enqueue, findItem, markDone, readQueue, takePending, type QueueItem, ty
 import { logLine } from "./logfile.ts";
 import { updateRunStatus } from "./runs.ts";
 import type { MutationQueue } from "./telemetry.ts";
+import type { EvolutionConfig } from "./config.ts";
 
 export interface ApplyToolsDeps {
   evolutionDir: string;
   cwd: string;
   queue: MutationQueue;
+  /**
+   * 开关读取（每次调用现读，**不许拿会话起点的缓存**）：
+   * `autoReview` 决定 proposed 的 run 要不要入队，`autoApply` 决定 auto 条要不要落盘 ——
+   * 用户中途 `/skill-evolve apply on`，下一轮扫描就该生效。
+   */
+  flags: () => Pick<EvolutionConfig, "autoReview" | "autoApply">;
   now?: () => number;
   log?: (msg: string) => void;
   git: GitRunner;
@@ -46,6 +53,8 @@ export interface ApplyTools {
 
 /** 只有评审通过（reviewed）的 run 才进队列；rejected / review_failed 一律不排 */
 const READY_STATUS = "reviewed";
+/** 评审关着时 run 停在这里：提案写完了、没人看过，仍然入队等人工批准 */
+const PROPOSED_STATUS = "proposed";
 const MAX_SCAN = 50;
 
 function readText(file: string): string | null {
@@ -101,6 +110,8 @@ export function createApplyTools(deps: ApplyToolsDeps): ApplyTools {
   };
 
   const enqueueReady: ApplyTools["enqueueReady"] = async () => {
+    // 开关现读（不缓存）：中途 review off 就新提案进队列标 reviewSkipped，review on 就恢复只收 reviewed
+    const autoReview = deps.flags().autoReview;
     const runsDir = path.join(deps.evolutionDir, "runs");
     let names: string[];
     try {
@@ -114,7 +125,10 @@ export function createApplyTools(deps: ApplyToolsDeps): ApplyTools {
       if (known.has(name)) continue;
       const runDir = path.join(runsDir, name);
       const raw = readRunJson(runDir);
-      if (!raw || raw.status !== READY_STATUS) continue;
+      if (!raw) continue;
+      // 评审关着时 run 停在 proposed：照旧入队（「待审批」页要看得见），只是标 reviewSkipped
+      const reviewSkipped = !autoReview && raw.status === PROPOSED_STATUS;
+      if (raw.status !== READY_STATUS && !reviewSkipped) continue;
       const meta = readProposalMeta(runDir);
       if (!meta) continue;
       const diffText = readText(path.join(runDir, meta.diffFile)) ?? "";
@@ -129,8 +143,10 @@ export function createApplyTools(deps: ApplyToolsDeps): ApplyTools {
         skill: meta.skill,
         targets: targetsOf(runDir, meta.skill, meta.type, graded.targets),
         proposalType: meta.type,
+        ...(reviewSkipped ? { reviewSkipped: true } : {}),
       });
       if (result.supersededBy) log(`[skill-evolve] ${name} 被更早的 pending 顶掉（${result.supersededBy}）`);
+      else if (reviewSkipped) log(`[skill-evolve] ${name} 入队（评审已关，待人工批准）：${graded.level}（${graded.reasons[0] ?? ""}）`);
       else log(`[skill-evolve] ${name} 入队：${graded.level}（${graded.reasons[0] ?? ""}）`);
       added += 1;
     }
@@ -180,7 +196,20 @@ export function createApplyTools(deps: ApplyToolsDeps): ApplyTools {
     return outcome;
   };
 
+  // 「自动采纳已关」只提示一次：settle 每轮都会调到，同一条不变就别反复刷日志
+  let applyOffNotice = "";
+
   const autoApplyPending: ApplyTools["autoApplyPending"] = async () => {
+    // 开关现读：`/skill-evolve apply on` 之后下一轮扫描就落盘，不用重开会话
+    if (!deps.flags().autoApply) {
+      const waiting = takePending(readQueue(deps.evolutionDir), "auto").length;
+      const notice = `[skill-evolve] 自动采纳已关：${waiting} 条 auto 提案在队列里等人工批准`;
+      if (waiting > 0 && notice !== applyOffNotice) {
+        log(notice);
+        applyOffNotice = notice;
+      }
+      return 0;
+    }
     let applied = 0;
     for (const item of takePending(readQueue(deps.evolutionDir), "auto")) {
       try {

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

@@ -84,7 +84,7 @@ export interface Evolution {
   /** `/skill-evolve baseline`：把当前命中全部接受为存量；reset 清空清单 */
   acceptBaseline(mode: "accept" | "reset"): Promise<string>;
   setEnabled(enabled: boolean): Promise<string>;
-  /** `/skill-evolve collect|review` 与 Web 控制条：只切一个开关（另一个保持原值） */
+  /** `/skill-evolve collect|dispatch|review|apply` 与 Web 控制条：只切一个开关（其余三个保持原值） */
   setFlag(field: ConfigFlag, value: boolean): Promise<string>;
   /** 模型配置 + 必红自检（`/skill-evolve config|selftest`） */
   model: ModelTools;
@@ -144,6 +144,8 @@ export function createEvolution(deps: EvolutionDeps): Evolution {
     evolutionDir,
     cwd: deps.cwd,
     queue: deps.queue,
+    // 传 getter：review / apply 中途开关后，下一轮扫描立刻按新值走
+    flags: () => ({ autoReview: config.autoReview, autoApply: config.autoApply }),
     log,
     now,
     git: deps.git ?? createGitRunner(),
@@ -257,14 +259,14 @@ export function createEvolution(deps: EvolutionDeps): Evolution {
   const setEnabled = async (on: boolean): Promise<string> => {
     Object.assign(config, await saveConfigSwitch(evolutionDir, on, deps.queue));
     return on
-      ? `技能进化已打开（采集 + 自动复盘）：${configFile(evolutionDir)}（当前会话立即生效）`
-      : `技能进化已全部关闭（采集也停）：${configFile(evolutionDir)}（当前会话立即生效）`;
+      ? `技能进化已打开（自动复盘 + 自动评审；采集与自动采纳未改）：${configFile(evolutionDir)}（当前会话立即生效）`
+      : `技能进化已全部关闭（采集 / 复盘 / 评审 / 采纳）：${configFile(evolutionDir)}（当前会话立即生效）`;
   };
 
-  /** 只切一个开关：另一个保持原值（`collect` = telemetry、`review` = enabled） */
+  /** 只切一个开关：其余三个保持原值（`collect` = telemetry、`dispatch` = enabled、`review` = autoReview、`apply` = autoApply） */
   const setFlag = async (field: ConfigFlag, value: boolean): Promise<string> => {
     Object.assign(config, await saveFlag(evolutionDir, field, value, deps.queue));
-    return `${FLAG_LABEL[field]}已${value ? "开启" : "关闭"}：${configFile(evolutionDir)}（当前会话立即生效）\n${flagStateText(config.enabled, config.telemetry)}`;
+    return `${FLAG_LABEL[field]}已${value ? "开启" : "关闭"}：${configFile(evolutionDir)}（当前会话立即生效）\n${flagStateText(config)}`;
   };
 
   return {

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

@@ -1,39 +1,53 @@
 /**
- * 「采集遥测」与「自动复盘」两个开关的口径：字段名、标签、后果说明、状态文案只此一份。
+ * 四个开关（采集遥测 / 自动复盘 / 自动评审 / 自动采纳）的口径：字段名、标签、后果说明、状态文案只此一份。
  *
- * 两个字段在配置里本来就是独立的（`telemetry` 只写本地 jsonl，不花 token；`enabled` 派生子进程复盘，花 token），
- * 命令文案、Web 控制条、HTTP 的 `field` 校验都从这里取 —— 三处各写一份字符串，
- * 迟早出现「命令里叫遥测、网页上叫采集、日志里又叫 telemetry」这种对不上的情况。
+ * 四个字段在配置里本来就是独立的（`telemetry` 只写本地 jsonl；`enabled` 派生子进程复盘；
+ * `autoReview` 再起一个督导子进程；`autoApply` 改仓库文件），命令文案、Web 控制条、
+ * HTTP 的 `field` 校验都从这里取 —— 三处各写一份字符串，
+ * 迟早出现「命令里叫评审、网页上叫审核、日志里又叫 autoReview」这种对不上的情况。
  */
-import type { ConfigFlag } from "./config.ts";
+import type { ConfigFlag, EvolutionConfig } from "./config.ts";
 
-/** 字段顺序即界面顺序：先采集（不花钱的），再复盘（花钱的） */
-export const FLAG_FIELDS: readonly ConfigFlag[] = ["telemetry", "enabled"];
+/** 字段顺序即界面顺序：先不花钱的（采集），再花钱的（复盘 → 评审），最后动文件的（采纳） */
+export const FLAG_FIELDS: readonly ConfigFlag[] = ["telemetry", "enabled", "autoReview", "autoApply"];
 
-export const FLAG_LABEL: Record<ConfigFlag, string> = { telemetry: "采集遥测", enabled: "自动复盘" };
+export const FLAG_LABEL: Record<ConfigFlag, string> = {
+  telemetry: "采集遥测",
+  enabled: "自动复盘",
+  autoReview: "自动评审",
+  autoApply: "自动采纳",
+};
 
-/** 后果说明：两个开关长得一样，不写清各自花什么，人只会以为都是「开关插件」 */
+/** 后果说明：四个开关长得一样，不写清各自花什么，人只会以为都是「开关插件」 */
 export const FLAG_EFFECT: Record<ConfigFlag, string> = {
   telemetry: "只写本地日志，不花 token",
   enabled: "会派生子进程，花 token",
+  autoReview: "提案后再起一个督导子进程，再花一份 token",
+  autoApply: "改 .pi/skills/ 与 .cursor/ 文件，可回滚",
 };
 
-/** 命令名 → 字段：`collect` 管采集，`review` 管复盘（命令名与字段名故意不同，别在别处再映射一遍） */
-export const COMMAND_FLAG: Record<"collect" | "review", ConfigFlag> = {
+/** 命令名 → 字段（命令名与字段名故意不同，别在别处再映射一遍）：`dispatch` 是复盘、`review` 是评审 */
+export const COMMAND_FLAG: Record<"collect" | "dispatch" | "review" | "apply", ConfigFlag> = {
   collect: "telemetry",
-  review: "enabled",
+  dispatch: "enabled",
+  review: "autoReview",
+  apply: "autoApply",
 };
 
 /** 参数 → 字段：不认的值一律 null（调用方回用法提示或 400，不猜一个默认值） */
 export function parseFlag(value: string | null | undefined): ConfigFlag | null {
-  return value === "telemetry" || value === "enabled" ? value : null;
+  return value === "telemetry" || value === "enabled" || value === "autoReview" || value === "autoApply" ? value : null;
 }
 
-/** 一行两段的状态文案：`status` 与命令回执共用，免得同一句话在两处写法不同 */
-export function flagStateText(enabled: boolean, telemetry: boolean): string {
-  const collect = telemetry ? "采集：开（遥测写入 .pi/evolution/telemetry/）" : "采集：关（不写遥测）";
-  const review = enabled ? "复盘：开（会派生 agent）" : "复盘：关（不会派生 agent）";
-  return `${collect}｜${review}`;
+/** `status` 与命令回执共用的四段状态文案：四个字段各自一句话，合成一行 */
+export function flagStateText(
+  config: Pick<EvolutionConfig, "telemetry" | "enabled" | "autoReview" | "autoApply">,
+): string {
+  const collect = config.telemetry ? "采集：开（遥测写入 .pi/evolution/telemetry/）" : "采集：关（不写遥测）";
+  const dispatch = config.enabled ? "复盘：开（会派生 agent）" : "复盘：关（不会派生 agent）";
+  const review = config.autoReview ? "评审：开（提案后自动起督导）" : "评审：关（提案停在 proposed 等人工）";
+  const apply = config.autoApply ? "采纳：开（auto 提案自动落盘）" : "采纳：关（auto 提案等人工批准）";
+  return `${collect}｜${dispatch}｜${review}｜${apply}`;
 }
 
 /** 只开复盘却不采集时唯一的不一致组合：归因靠遥测，缺了就只能退到原始会话，加载率算不出来 */

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

@@ -25,6 +25,8 @@ export interface QueueItem {
   status: QueueStatus;
   proposalType?: string;
   detail?: string;
+  /** 自动评审关着时入队的条目：run 没有 03-review.json，等人工 `/skill-evolve approve`（待审批页可见） */
+  reviewSkipped?: boolean;
 }
 
 export const QUEUE_FILE = "queue.json";

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

@@ -203,6 +203,8 @@ export async function runReplay(options: ReplayOptions): Promise<ReplayOutcome>
       evolutionDir,
       cwd: options.cwd,
       queue,
+      // 复演不做开关判定：它本来就是人手动触发的全链路
+      flags: () => ({ autoReview: true, autoApply: true }),
       now,
       log,
       git,

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

@@ -90,12 +90,11 @@ export interface StatusInput {
 }
 
 /**
- * 开关行：采集与复盘分两段写。两个字段本来就是独立的，合成一句「已开」只会让人以为只有一个总开关；
- * 第四种组合（只开复盘不采集）再补一句警告 —— 归因靠遥测，缺了就不能静默。
+ * 开关行：采集 / 复盘 / 评审 / 采纳四段各自写。四个字段本来就是独立的，合成一句「已开」只会让人
+ * 以为只有一个总开关；「只开复盘不采集」这个组合再补一句警告 —— 归因靠遥测，缺了就不能静默。
  */
 export function switchLine(config: EvolutionConfig): string {
-  const hint = config.enabled && config.telemetry ? "/skill-evolve off 全关" : "/skill-evolve on 全开";
-  const line = `${flagStateText(config.enabled, config.telemetry)}（${hint}；collect / review 单独控制）`;
+  const line = `${flagStateText(config)}（collect / dispatch / review / apply 单独控制；on / off 批量切）`;
   return telemetryOffWhileEnabled(config.enabled, config.telemetry) ? `${line} ⚠ ${TELEMETRY_OFF_WARNING}` : line;
 }
 
@@ -111,7 +110,7 @@ export function renderStatus(input: StatusInput): string {
   return [
     "技能进化 · 状态",
     `  ${switchLine(config)}`,
-    `  配置：${input.configPath}（不存在即默认全关）· 遥测目录：${input.telemetryDir}`,
+    `  配置：${input.configPath}（不存在即默认只开自动评审，采集 / 复盘 / 采纳关）· 遥测目录：${input.telemetryDir}`,
     `  去抖 ${Math.round(config.idleMs / 1000)}s · 单 run 上限 ${Math.round(config.maxRuntimeMs / 60_000)}min · 单会话派生上限 ${config.perSessionCap}`,
     `  锁：${lockText}`,
     ...webPanelLine(input.webPanel),

package/extensions/skill-evolve/lib/review-spawn.ts

@@ -30,6 +30,13 @@ export type SupervisorSpawn = (command: string, args: string[], options: Record<
 
 export interface SpawnSupervisorOptions {
   runDir: string;
+  /**
+   * 自动评审开关（`/skill-evolve review on|off`）：关着就不起督导，只留一句日志。
+   *
+   * 门禁放在这里而不是两个调用点各写一遍 —— dispatch 与退出补发是同一条语义，
+   * 分开写迟早有一边忘改。调用方必须在**真正下手前**现读配置（用户可能中途切换）。
+   */
+  autoReview: boolean;
   cwd: string;
   env?: NodeJS.ProcessEnv;
   /** "inherit" / 空 → 不传参，督导按默认模型评审 */
@@ -48,6 +55,10 @@ export interface SpawnSupervisorOptions {
 /** 返回 pid；被单飞闸挡住或起不来返回 null（只记日志，绝不抛到主会话） */
 export function spawnReviewSupervisor(options: SpawnSupervisorOptions): number | null {
   const runId = path.basename(options.runDir);
+  if (!options.autoReview) {
+    options.log?.(`[skill-evolve] 自动评审已关，run ${runId} 停在 proposed 待人工 /skill-evolve approve`);
+    return null;
+  }
   const occupant = guardBusy({
     evolutionDir: path.dirname(path.dirname(options.runDir)),
     sessionId: options.sessionId ?? runId,

package/extensions/skill-evolve/lib/shutdown-dispatch.ts

@@ -38,6 +38,8 @@ export interface ShutdownDeps {
   telemetry: TelemetryWriter;
   env: NodeJS.ProcessEnv;
   spawnFn: SpawnLike;
+  /** 自动评审开关（配置现读）：false 时不超督导，run 落成 proposed 等人工批准 */
+  autoReview: boolean;
   /** 评审模型（"inherit" 或 provider/model），退出补发这条路径同样要起督导 */
   reviewModel?: string;
   supervisorSpawnFn?: SupervisorSpawn;
@@ -147,6 +149,7 @@ export function flushPendingSync(item: PendingRounds, deps: ShutdownDeps, now: n
       rounds: item.rounds,
     });
     deps.log(`[skill-evolve] 退出前补发复盘：runId ${runId} pid ${childPid ?? "未知"}（合并 ${item.rounds} 轮）`);
+    // 退出前现读一次开关（与 dispatch 同一口径）：关着由 spawnReviewSupervisor 自己拒绝并记日志
     spawnReviewSupervisor({
       runDir,
       cwd: deps.cwd,
@@ -156,6 +159,7 @@ export function flushPendingSync(item: PendingRounds, deps: ShutdownDeps, now: n
       sessionId: item.sessionId,
       telemetry: deps.telemetry,
       sync: true,
+      autoReview: deps.autoReview,
       ...(deps.alive ? { alive: deps.alive } : {}),
       log: deps.log,
     });

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

@@ -29,7 +29,7 @@ export type ActionName = (typeof ACTION_NAMES)[number];
 
 /** 一个写动作：返回给人看的结论（首行进 303 的 msg / err） */
 export type WebAction = (runId: string) => Promise<string>;
-/** 单个开关：`field` = telemetry（采集，不花 token）/ enabled（复盘，花 token）；`next` 由这里取反后传入 */
+/** 单个开关：字段名 → /skill-evolve collect / dispatch / review / apply 各切一个；`next` 由这里取反后传入 */
 export type ToggleHook = (field: ConfigFlag, next: boolean) => Promise<string>;
 /** 立即复盘 / 重跑：都是「触发一次新的复盘」，由 index.ts 接 evo.runNow */
 export type RunHook = () => Promise<string>;
@@ -194,8 +194,8 @@ async function handleNamedAction(
 }
 
 /**
- * `POST /toggle?field=telemetry|enabled`：只翻一个字段。五道校验与 /action 共用，
- * 查询串只决定「翻哪一个」，不影响任何一道校验。
+ * `POST /toggle?field=telemetry|enabled|autoReview|autoApply`：只翻一个字段。五道校验与 /action 共用，
+ * 查询串只决定「翻哪一个」，不影响任何一道校验；四个开关互不联动（要批量切只有命令 on|off）。
  */
 async function handleToggleField(
   ctx: WriteContext,