pi-skill-evolve 0.1.2 → 0.1.3

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

@@ -8,14 +8,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadConfig } from "../config.ts";
+import { readQueue } from "../queue.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 */
+  /** 自动复盘开关（config.enabled，与 `/skill-evolve dispatch` 同一个字段）：派生子进程，花 token */
   enabled: boolean;
+  /** 自动评审开关（config.autoReview，与 `/skill-evolve review` 同一个字段）：提案后再起一个督导子进程 */
+  autoReview: boolean;
+  /** 自动采纳开关（config.autoApply，与 `/skill-evolve apply` 同一个字段）：auto 提案自动落盘 */
+  autoApply: boolean;
+  /** 队列里还在 pending 的 auto 条数：采纳关着时页面要写「N 条 auto 提案待人工」 */
+  pendingAuto: number;
   lastActivityAt: number | null;
 }
 
@@ -53,5 +60,15 @@ export function collectControls(evolutionDir: string): WebControls {
     if (latest === null || run.dispatchedAt > latest) latest = run.dispatchedAt;
   }
   const config = loadConfig(evolutionDir);
-  return { telemetry: config.telemetry, enabled: config.enabled, lastActivityAt: latest };
+  const pendingAuto = readQueue(evolutionDir).filter(
+    (item) => item.status === "pending" && item.level === "auto",
+  ).length;
+  return {
+    telemetry: config.telemetry,
+    enabled: config.enabled,
+    autoReview: config.autoReview,
+    autoApply: config.autoApply,
+    pendingAuto,
+    lastActivityAt: latest,
+  };
 }

package/extensions/skill-evolve/lib/web/render-controls.ts

@@ -11,7 +11,13 @@
  */
 import type { AuditEntry } from "./audit-log.ts";
 import type { ConfigFlag } from "../config.ts";
-import { FLAG_EFFECT, FLAG_LABEL, TELEMETRY_OFF_WARNING, telemetryOffWhileEnabled } from "../flags.ts";
+import {
+  FLAG_EFFECT,
+  FLAG_FIELDS,
+  FLAG_LABEL,
+  TELEMETRY_OFF_WARNING,
+  telemetryOffWhileEnabled,
+} from "../flags.ts";
 import type { WebView } from "./data.ts";
 import { RANGE_KEYS, RANGE_LABEL, STATUS_OPTIONS, pageHref, type ListFilter, type ViewPage } from "./filter.ts";
 import { escapeHtml, formatStamp } from "./text.ts";
@@ -55,7 +61,8 @@ function runForm(ctx: ControlBarOptions): string {
 /**
  * 一个独立开关：状态 + 后果说明 + 「点下去会发生什么」的按钮。
  *
- * 两个开关各自 post 到 `/toggle?field=`（带上隐藏的 view，动作完回同一页），
+ * 四个开关各自 post 到 `/toggle?field=`（带上隐藏的 view，动作完回同一页），**不互相联动**：
+ * 想采集但不花钱、想评审但不自动采纳，都是常见中间态；要批量切只有命令 `on|off`。
  * 按钮文案写动作不写状态 —— 状态已经在左边那一段里，按钮再写一遍会让人把「当前值」看成「点了会变的值」。
  */
 function flagSwitch(field: ConfigFlag, on: boolean, ctx: ControlBarOptions): string {
@@ -73,11 +80,12 @@ function flagSwitch(field: ConfigFlag, on: boolean, ctx: ControlBarOptions): str
 }
 
 /**
- * 顶部控制条：两个独立开关（采集 / 复盘）+ 立即复盘 + 最后活动。
+ * 顶部控制条：四个独立开关（采集 / 复盘 / 评审 / 采纳）+ 立即复盘 + 最后活动。
  *
- * 两个开关不许合成一个「开启采集与派生」：采集只写本地文件，复盘才花 token，
- * 想采集样本但不想花钱是常见的中间状态，捆在一起就无路可走。
- * 只开复盘不采集时另给一行警告（见 flags.ts 的 TELEMETRY_OFF_WARNING），不许静默。
+ * 四个开关不许合成一个「开启全部」：采集只写本地文件，复盘与评审才花 token，
+ * 采纳直接改仓库文件 —— 想采集样本但不想花钱、想评审但不想自动落盘，都是常见的中间状态。
+ * 两类提醒不许静默：只开复盘不采集（见 flags.ts 的 TELEMETRY_OFF_WARNING）、
+ * 采纳关着但队列里积了 auto 提案（告诉人有多少条等人工批）。
  */
 export function renderControlBar(controls: WebControls, ctx: ControlBarOptions): string {
   const writable = ctx.canWrite === true && (ctx.csrf ?? "").length > 0;
@@ -85,12 +93,16 @@ export function renderControlBar(controls: WebControls, ctx: ControlBarOptions):
   const warn = telemetryOffWhileEnabled(controls.enabled, controls.telemetry)
     ? `<p class="warn">⚠ ${TELEMETRY_OFF_WARNING}</p>\n`
     : "";
+  const backlog =
+    !controls.autoApply && controls.pendingAuto > 0
+      ? `<p class="warn">⏸ ${controls.pendingAuto} 条 auto 提案待人工（自动采纳关着）</p>\n`
+      : "";
+  const switches = FLAG_FIELDS.map((field) => flagSwitch(field, controls[field], ctx)).join("\n");
   return `<div class="ctl">
-${flagSwitch("telemetry", controls.telemetry, ctx)}
-${flagSwitch("enabled", controls.enabled, ctx)}
+${switches}
 ${run}<span class="act">${escapeHtml(activityText(controls.lastActivityAt, ctx.now))}</span>
 </div>
-${warn}`;
+${warn}${backlog}`;
 }
 
 /** 状态下拉：先「全部」，再固定七个状态（顺序与 STATUS_OPTIONS 一致，别在渲染层重排） */

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

@@ -59,10 +59,73 @@ function tools(fixture: Fixture, over: Partial<Parameters<typeof createApplyTool
     git: (args: string[]) => ({ code: 0, out: args[0] === "status" ? "" : "" }),
     loadDiagnostics: () => [],
     runMdCheck: () => ({ code: 0, output: "" }),
+    // 开关默认全开（老用例断言的是「开关都开着」时的行为）；个别用例自己 over 掉
+    flags: () => ({ autoReview: true, autoApply: true }),
     ...over,
   });
 }
 
+test("autoApply 关着：auto 条照旧入队但不落盘，提示只打一次", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-auto", "reviewed");
+  await seedGate0(fixture);
+  const logs: string[] = [];
+  const t = tools(fixture, { flags: () => ({ autoReview: true, autoApply: false }), log: (line: string) => logs.push(line) });
+  assert.equal(await t.enqueueReady(), 1, "入队不受采纳开关影响：待审批页要看得见");
+  assert.equal(await t.autoApplyPending(), 0, "采纳关着一条都不许动");
+  assert.equal(await t.autoApplyPending(), 0);
+  const item = readQueue(fixture.evolutionDir)[0]!;
+  assert.equal(item.status, "pending", "队列条目必须还在，等人工批准");
+  assert.equal(item.level, "auto");
+  assert.equal(fs.readFileSync(fixture.skillAbs, "utf8"), SKILL_TEXT, "技能文件一个字都不许改");
+  const notices = logs.filter((line) => line.includes("自动采纳已关"));
+  assert.equal(notices.length, 1, "同一批待办只提示一次，不能每轮扫描刷一遍");
+  assert.match(notices[0]!, /1 条 auto 提案在队列里等人工批准/);
+});
+
+test("autoReview 关着：proposed 的 run 也入队并标 reviewSkipped（待审批页可见）", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-proposed", "proposed");
+  const t = tools(fixture, { flags: () => ({ autoReview: false, autoApply: false }) });
+  assert.equal(await t.enqueueReady(), 1, "评审关着时 run 停在 proposed，也要让待审批页看得见");
+  const item = readQueue(fixture.evolutionDir)[0]!;
+  assert.equal(item.reviewSkipped, true, "没有 03-review.json 的条目标记出来，页面才能区分");
+  assert.equal(item.level, "auto", "级别仍按 classify-action 的分类走，不因为跳过评审就降级");
+});
+
+test("中途打开评审：同一个 tools 实例先关后开，下一轮扫描不再收 proposed", async () => {
+  const fixture = setup();
+  const flags = { autoReview: false, autoApply: false };
+  const t = tools(fixture, { flags: () => flags });
+  seedRun(fixture, "run-p1", "proposed");
+  assert.equal(await t.enqueueReady(), 1, "关着的时候 proposed 也入队");
+  flags.autoReview = true;
+  seedRun(fixture, "run-p2", "proposed");
+  assert.equal(await t.enqueueReady(), 0, "打开评审后要等督导写 reviewed，不再提前入队");
+});
+
+test("autoReview 开着：proposed 的 run 不入队（等督导写完 reviewed 再进）", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-proposed", "proposed");
+  const t = tools(fixture, { flags: () => ({ autoReview: true, autoApply: true }) });
+  assert.equal(await t.enqueueReady(), 0);
+  assert.deepEqual(readQueue(fixture.evolutionDir), []);
+});
+
+test("中途改开关：同一个 tools 实例先关后开，下一轮扫描就落盘", async () => {
+  const fixture = setup();
+  seedRun(fixture, "run-auto", "reviewed");
+  await seedGate0(fixture);
+  const flags = { autoReview: true, autoApply: false };
+  const t = tools(fixture, { flags: () => flags });
+  await t.enqueueReady();
+  assert.equal(await t.autoApplyPending(), 0);
+  // 用户中途 `/skill-evolve apply on`：下一轮扫描就该生效，不许等重开会话
+  flags.autoApply = true;
+  assert.equal(await t.autoApplyPending(), 1);
+  assert.equal(readQueue(fixture.evolutionDir)[0]!.status, "applied");
+});
+
 test("只给 reviewed 的 run 入队，级别由代码判（description 改动 → auto）", async () => {
   const fixture = setup();
   seedRun(fixture, "run-ok", "reviewed");

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

@@ -78,7 +78,7 @@ function fakeEvolution(calls: string[]): Evolution {
 test("补全：空前缀给全量，命中前缀只给命中项，乱前缀也给全量", () => {
   assert.deepEqual(
     matchSubcommand("").map((item) => item.value),
-    ["status", "report", "run", "baseline", "selftest", "approve", "queue", "web", "config", "collect", "review", "on", "off"],
+    ["status", "report", "run", "baseline", "selftest", "approve", "queue", "web", "config", "collect", "dispatch", "review", "apply", "on", "off"],
   );
   assert.deepEqual(
     matchSubcommand("re").map((item) => item.value),
@@ -94,7 +94,11 @@ test("补全：空前缀给全量，命中前缀只给命中项，乱前缀也
   );
   assert.deepEqual(
     matchSubcommand("ap").map((item) => item.value),
-    ["approve"],
+    ["approve", "apply"],
+  );
+  assert.deepEqual(
+    matchSubcommand("di").map((item) => item.value),
+    ["dispatch"],
   );
   assert.deepEqual(
     matchSubcommand("o").map((item) => item.value),
@@ -110,7 +114,7 @@ test("补全：空前缀给全量，命中前缀只给命中项，乱前缀也
   );
   assert.deepEqual(
     matchSubcommand("zzz").map((item) => item.value),
-    ["status", "report", "run", "baseline", "selftest", "approve", "queue", "web", "config", "collect", "review", "on", "off"],
+    ["status", "report", "run", "baseline", "selftest", "approve", "queue", "web", "config", "collect", "dispatch", "review", "apply", "on", "off"],
   );
   assert.deepEqual(
     matchSubcommand("w").map((item) => item.value),
@@ -193,7 +197,10 @@ test("未知子命令返回用法串且不碰 Evolution", async () => {
   const calls: string[] = [];
   const text = await runCommand("propose", fakeEvolution(calls), TARGET);
   assert.match(text, /未知子命令：propose/);
-  assert.match(text, /status\|report\|run\|baseline\|selftest\|approve\|queue\|web\|config\|collect\|review\|on\|off/);
+  assert.match(
+    text,
+    /status\|report\|run\|baseline\|selftest\|approve\|queue\|web\|config\|collect\|dispatch\|review\|apply\|on\|off/,
+  );
   assert.deepEqual(calls, []);
 });
 
@@ -205,20 +212,36 @@ test("collect on|off：只动采集（telemetry），不碰复盘", async () =>
   assert.deepEqual(calls, ["flag:telemetry=true", "flag:telemetry=false"]);
 });
 
-test("review on|off：只动复盘（enabled），不碰采集", async () => {
+test("dispatch on|off：只动自动复盘（enabled），不碰采集", async () => {
   const calls: string[] = [];
   const evo = fakeEvolution(calls);
-  assert.equal(await runCommand("review on", evo, TARGET), "开关：enabled=true");
-  assert.equal(await runCommand("review off", evo, TARGET), "开关：enabled=false");
+  assert.equal(await runCommand("dispatch on", evo, TARGET), "开关：enabled=true");
+  assert.equal(await runCommand("dispatch off", evo, TARGET), "开关：enabled=false");
   assert.deepEqual(calls, ["flag:enabled=true", "flag:enabled=false"]);
 });
 
-test("collect / review 参数非法（缺失或写错）：给用法串且不改配置", async () => {
+test("review on|off：只动自动评审（autoReview）—— 语义从「自动复盘」改到这里", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("review on", evo, TARGET), "开关：autoReview=true");
+  assert.equal(await runCommand("review off", evo, TARGET), "开关：autoReview=false");
+  assert.deepEqual(calls, ["flag:autoReview=true", "flag:autoReview=false"]);
+});
+
+test("apply on|off：只动自动采纳（autoApply）", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("apply on", evo, TARGET), "开关：autoApply=true");
+  assert.equal(await runCommand("apply off", evo, TARGET), "开关：autoApply=false");
+  assert.deepEqual(calls, ["flag:autoApply=true", "flag:autoApply=false"]);
+});
+
+test("collect / dispatch / review / apply 参数非法（缺失或写错）：给用法串且不改配置", async () => {
   const calls: string[] = [];
   const evo = fakeEvolution(calls);
-  for (const args of ["collect", "collect yes", "review", "review 1"]) {
+  for (const args of ["collect", "collect yes", "dispatch", "review", "review 1", "apply", "apply yes"]) {
     const text = await runCommand(args, evo, TARGET);
-    assert.match(text, /用法：\/skill-evolve (collect|review) on\|off/, args);
+    assert.match(text, /用法：\/skill-evolve (collect|dispatch|review|apply) on\|off/, args);
     assert.match(text, /配置未改动/, args);
   }
   assert.deepEqual(calls, [], "非法参数不该调 setFlag");

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

@@ -17,44 +17,75 @@ function workspace(): string {
   return path.join(cwd, ".pi", "evolution");
 }
 
-test("DEFAULT_CONFIG：采集与派生都默认关（clone 即静默）", () => {
-  assert.deepEqual([DEFAULT_CONFIG.enabled, DEFAULT_CONFIG.telemetry], [false, false]);
+test("DEFAULT_CONFIG：只开自动评审，采集 / 复盘 / 自动采纳都默认关", () => {
+  // 自动评审单独为 true 是安全的：enabled 关着时它永远走不到，不会替 clone 下来的人花 token
+  assert.deepEqual(
+    [DEFAULT_CONFIG.enabled, DEFAULT_CONFIG.telemetry, DEFAULT_CONFIG.autoReview, DEFAULT_CONFIG.autoApply],
+    [false, false, true, false],
+  );
 });
 
-test("loadConfig：没有 config.json 时全关，且不会顺手造文件", () => {
+test("loadConfig：没有 config.json 时只开自动评审，且不会顺手造文件", () => {
   const evolutionDir = workspace();
   const config = loadConfig(evolutionDir);
-  assert.deepEqual([config.enabled, config.telemetry], [false, false]);
+  assert.deepEqual(
+    [config.enabled, config.telemetry, config.autoReview, config.autoApply],
+    [false, false, true, false],
+  );
   assert.equal(fs.existsSync(configFile(evolutionDir)), false, "读配置不能有副作用");
 });
 
-test("normalizeConfig：空对象与缺字段都回落到全关", () => {
-  assert.deepEqual([normalizeConfig({}).enabled, normalizeConfig({}).telemetry], [false, false]);
+test("normalizeConfig：空对象与缺字段都回落到默认（评审开、其余关）", () => {
+  const empty = normalizeConfig({});
+  assert.deepEqual([empty.enabled, empty.telemetry, empty.autoReview, empty.autoApply], [false, false, true, false]);
   const onlyEnabled = normalizeConfig({ enabled: true });
-  assert.deepEqual([onlyEnabled.enabled, onlyEnabled.telemetry], [true, false], "只写 enabled 不等于打开采集");
+  assert.deepEqual(
+    [onlyEnabled.enabled, onlyEnabled.telemetry, onlyEnabled.autoApply],
+    [true, false, false],
+    "只写 enabled 不等于打开采集或自动采纳",
+  );
+});
+
+test("normalizeConfig：autoReview / autoApply 写错类型回落到默认值", () => {
+  // 手改配置写成字符串是常事：坏值只回退那一个字段，不能让整份配置失效
+  const wrong = normalizeConfig({ autoReview: "off", autoApply: 1 });
+  assert.deepEqual([wrong.autoReview, wrong.autoApply], [true, false]);
+  const explicit = normalizeConfig({ autoReview: false, autoApply: true, enabled: true });
+  assert.deepEqual([explicit.enabled, explicit.autoReview, explicit.autoApply], [true, false, true]);
 });
 
-test("saveConfigSwitch：on 两个键都开，其余字段原样保留", async () => {
+test("saveConfigSwitch：on 只开复盘 + 评审，采集与自动采纳保持原值", async () => {
   const evolutionDir = workspace();
   fs.mkdirSync(evolutionDir, { recursive: true });
   fs.writeFileSync(
     configFile(evolutionDir),
-    JSON.stringify({ enabled: false, telemetry: false, idleMs: 1_234, perSessionCap: 3 }),
+    JSON.stringify({ enabled: false, telemetry: true, autoReview: false, autoApply: false, idleMs: 1_234, perSessionCap: 3 }),
     "utf8",
   );
   const next = await saveConfigSwitch(evolutionDir, true, directQueue);
-  assert.deepEqual([next.enabled, next.telemetry, next.idleMs, next.perSessionCap], [true, true, 1_234, 3]);
+  assert.deepEqual(
+    [next.enabled, next.autoReview, next.telemetry, next.autoApply, next.idleMs, next.perSessionCap],
+    [true, true, true, false, 1_234, 3],
+  );
   const raw = JSON.parse(fs.readFileSync(configFile(evolutionDir), "utf8"));
-  assert.deepEqual([raw.enabled, raw.telemetry, raw.idleMs, raw.perSessionCap], [true, true, 1_234, 3]);
+  assert.deepEqual(
+    [raw.enabled, raw.autoReview, raw.telemetry, raw.autoApply, raw.idleMs, raw.perSessionCap],
+    [true, true, true, false, 1_234, 3],
+    "写盘内容必须与返回值一致：采集关着不能被 on 顺手打开，自动采纳更不能被打开",
+  );
 });
 
-test("saveConfigSwitch：off 两个键都关", async () => {
+test("saveConfigSwitch：off 四个键全关，去抖等其它字段原样保留", async () => {
   const evolutionDir = workspace();
   fs.mkdirSync(evolutionDir, { recursive: true });
-  fs.writeFileSync(configFile(evolutionDir), JSON.stringify({ enabled: true, telemetry: true, idleMs: 5_000 }), "utf8");
+  fs.writeFileSync(
+    configFile(evolutionDir),
+    JSON.stringify({ enabled: true, telemetry: true, autoReview: true, autoApply: true, idleMs: 5_000 }),
+    "utf8",
+  );
   await saveConfigSwitch(evolutionDir, false, directQueue);
   const raw = JSON.parse(fs.readFileSync(configFile(evolutionDir), "utf8"));
-  assert.deepEqual([raw.enabled, raw.telemetry, raw.idleMs], [false, false, 5_000]);
+  assert.deepEqual([raw.enabled, raw.telemetry, raw.autoReview, raw.autoApply, raw.idleMs], [false, false, false, false, 5_000]);
 });
 
 test("normalizeConfig：web 默认开 + 7788（采集/派生仍关），端口边界 1/65535 合法、整块类型不对回退", () => {
@@ -121,6 +152,23 @@ test("saveFlag：只改目标字段，其余键（含 web 块）原样保留", a
   assert.deepEqual([raw.enabled, raw.telemetry, raw.idleMs, raw.web], [false, true, 1_234, { enabled: true, port: 7799 }]);
 });
 
+test("saveFlag：autoReview / autoApply 各自独立，翻一个不动其它三个", async () => {
+  const evolutionDir = workspace();
+  fs.mkdirSync(evolutionDir, { recursive: true });
+  await saveFlag(evolutionDir, "enabled", true, directQueue);
+  await saveFlag(evolutionDir, "telemetry", true, directQueue);
+  await saveFlag(evolutionDir, "autoReview", false, directQueue);
+  const raw = JSON.parse(fs.readFileSync(configFile(evolutionDir), "utf8"));
+  assert.deepEqual(
+    [raw.enabled, raw.telemetry, raw.autoReview, raw.autoApply],
+    [true, true, false, false],
+    "关评审不能动复盘/采集，也不能顺手打开自动采纳",
+  );
+  await saveFlag(evolutionDir, "autoApply", true, directQueue);
+  const after = JSON.parse(fs.readFileSync(configFile(evolutionDir), "utf8"));
+  assert.deepEqual([after.enabled, after.telemetry, after.autoReview, after.autoApply], [true, true, false, true]);
+});
+
 test("saveFlag：两个字段互不牵连（先开复盘再关采集）", async () => {
   const evolutionDir = workspace();
   fs.mkdirSync(evolutionDir, { recursive: true });
@@ -132,15 +180,19 @@ test("saveFlag：两个字段互不牵连（先开复盘再关采集）", async
   assert.deepEqual([after.enabled, after.telemetry], [true, false], "关采集不动复盘");
 });
 
-test("switchLine：采集与复盘分两段写，第四种组合带警告", () => {
-  const base = { idleMs: 1, maxRuntimeMs: 1, perSessionCap: 1 };
-  const off = "采集：关（不写遥测）｜复盘：关（不会派生 agent）";
-  const collectOnly = "采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：关（不会派生 agent）";
-  const both = "采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：开（会派生 agent）";
-  assert.equal(switchLine({ ...base, enabled: false, telemetry: false }), `${off}（/skill-evolve on 全开；collect / review 单独控制）`);
-  assert.equal(switchLine({ ...base, enabled: false, telemetry: true }), `${collectOnly}（/skill-evolve on 全开；collect / review 单独控制）`);
-  assert.equal(switchLine({ ...base, enabled: true, telemetry: true }), `${both}（/skill-evolve off 全关；collect / review 单独控制）`);
-  const warn = switchLine({ ...base, enabled: true, telemetry: false });
+test("switchLine：四个开关各写一段，只开复盘不采集时带警告", () => {
+  const base = { idleMs: 1, maxRuntimeMs: 1, perSessionCap: 1, autoReview: true, autoApply: false };
+  const hint = "（collect / dispatch / review / apply 单独控制；on / off 批量切）";
+  const allOff = "采集：关（不写遥测）｜复盘：关（不会派生 agent）｜评审：关（提案停在 proposed 等人工）｜采纳：关（auto 提案等人工批准）";
+  const collectOnly = "采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：关（不会派生 agent）｜评审：开（提案后自动起督导）｜采纳：关（auto 提案等人工批准）";
+  const both = "采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：开（会派生 agent）｜评审：开（提案后自动起督导）｜采纳：开（auto 提案自动落盘）";
+  assert.equal(
+    switchLine({ ...base, enabled: false, telemetry: false, autoReview: false }),
+    `${allOff}${hint}`,
+  );
+  assert.equal(switchLine({ ...base, enabled: false, telemetry: true }), `${collectOnly}${hint}`);
+  assert.equal(switchLine({ ...base, enabled: true, telemetry: true, autoApply: true }), `${both}${hint}`);
+  const warn = switchLine({ ...base, enabled: true, telemetry: false, autoReview: false });
   assert.equal(warn.startsWith("采集：关（不写遥测）｜复盘：开（会派生 agent）"), true);
   assert.equal(warn.includes(TELEMETRY_OFF_WARNING), true, "只开复盘不采集：必须带警告，不许静默");
 });

package/extensions/skill-evolve/test/dispatch-busy.test.ts

@@ -162,6 +162,7 @@ test("shutdown-dispatch：已有活的督导 → 不 spawn，同步写 busy，
       telemetry: ctx.telemetry,
       env: {},
       spawnFn: noSpawn,
+      autoReview: true,
       alive: ctx.alive,
       log: () => {},
     },
@@ -186,6 +187,7 @@ test("review-spawn：别的 run 的复盘活着 → 不起督导，写 busy 遥
     runDir,
     cwd: ctx.cwd,
     env: {},
+    autoReview: true,
     telemetry: ctx.telemetry,
     alive: ctx.alive,
     log: () => {},
@@ -213,6 +215,7 @@ test("review-spawn：自己这条 run 的复盘活着不算占用，起督导并
     runDir,
     cwd: ctx.cwd,
     env: {},
+    autoReview: true,
     telemetry: ctx.telemetry,
     alive: ctx.alive,
     log: () => {},

package/extensions/skill-evolve/test/dispatch-supervisor.test.ts

@@ -25,7 +25,14 @@ class FakeChild {
   }
 }
 
-function harness(options: { config?: Partial<EvolutionConfig>; selftestFailed?: () => boolean; reviewModel?: () => string } = {}) {
+function harness(
+  options: {
+    config?: Partial<EvolutionConfig>;
+    selftestFailed?: () => boolean;
+    reviewModel?: () => string;
+    logs?: string[];
+  } = {},
+) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-sup-"));
   const events: TelemetryEvent[] = [];
   const supervisorCalls: { args: string[]; options: Record<string, unknown> }[] = [];
@@ -47,7 +54,7 @@ function harness(options: { config?: Partial<EvolutionConfig>; selftestFailed?:
     telemetry: writer,
     queue: directQueue,
     promptTemplatePath: TEMPLATE,
-    log: () => {},
+    log: (line: string) => options.logs?.push(line),
     now: () => NOW,
     env: {},
     spawnFn,
@@ -70,6 +77,23 @@ test("派发成功时同一轮就起评审督导，并把评审模型透传过
   assert.equal(args[args.length - 1], "deepseek/deepseek-v3.2");
 });
 
+test("自动评审关着：复盘照跑，但不起督导，run 停在 proposed 等人工", async () => {
+  const logs: string[] = [];
+  const h = harness({ config: { autoReview: false }, logs });
+  const outcome = await h.dispatch({ sessionId: "sess-1", skills: ["alpha"] });
+  assert.equal(outcome.status, "dispatched", "复盘本身不受评审开关影响");
+  assert.equal(h.supervisorCalls.length, 0, "评审关着就一个督导都不许起（子进程也花 token）");
+  assert.equal(outcome.status, "dispatched");
+  const runDir = outcome.status === "dispatched" ? outcome.run.runDir : "";
+  const run = JSON.parse(fs.readFileSync(path.join(runDir, "run.json"), "utf8"));
+  assert.equal(run.status, "dispatched", "复盘 agent 还没写提案，状态由它自己推到 proposed");
+  assert.equal(
+    logs.some((line) => line.includes("自动评审已关") && line.includes(String(run.runId))),
+    true,
+    "必须留一句日志，否则人只会以为评审坏了",
+  );
+});
+
 test("总开关关闭：既不复盘也不起督导", async () => {
   const h = harness({ config: { enabled: false } });
   const outcome = await h.dispatch({ sessionId: "sess-1", skills: ["alpha"] });

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

@@ -35,6 +35,8 @@ interface Harness {
   /** 模拟某个子进程退出（收尸会顺手放锁） */
   exitChild: (index: number) => Promise<void>;
   children: FakeChild[];
+  /** 评审督导的起进程记录（断言「关着就一个都不起」用） */
+  supervisorCalls: { args: string[]; options: Record<string, unknown> }[];
   events: () => TelemetryEvent[];
   tick: (ms: number) => void;
 }
@@ -54,7 +56,7 @@ class FakeChild {
 }
 
 /**
- * 夹具的 config.json：生产默认全关（clone 即静默），所以每个用例都得显式打开；
+ * 夹具的 config.json：生产默认只开自动评审（采集 / 复盘 / 采纳关），所以每个用例都得显式打开；
  * 要验证「默认啥都不做」的用例直接自己建目录、不走这个 helper。
  */
 function writeConfig(dir: string, config: Record<string, unknown> = {}): void {
@@ -72,6 +74,7 @@ function harness(env: NodeJS.ProcessEnv = {}, config: Record<string, unknown> =
   writeConfig(dir, config);
   let clock = NOW;
   const children: FakeChild[] = [];
+  const supervisorCalls: { args: string[]; options: Record<string, unknown> }[] = [];
   const spawnFn: SpawnLike = () => (children.push(new FakeChild()), children[children.length - 1] as unknown as SpawnedChild);
   const evo = createEvolution({
     cwd: dir,
@@ -83,12 +86,13 @@ function harness(env: NodeJS.ProcessEnv = {}, config: Record<string, unknown> =
     spawnFn,
     // 假子进程的 pid 就是本进程 pid（锁回收要真 pid 才判得活）；单飞闸用注入的 alive 模拟「子进程已退出」
     alive: () => false,
-    supervisorSpawnFn: fakeSupervisorSpawn([]),
+    supervisorSpawnFn: fakeSupervisorSpawn(supervisorCalls),
   });
   return {
     dir,
     evo,
     children,
+    supervisorCalls,
     get spawns() {
       return children.length;
     },
@@ -216,7 +220,12 @@ test("tool_result 对齐不到 tool_call 时静默忽略（跨会话/子代理
 test("statusText / reportText：无数据也不崩，且带上盲区提示", async () => {
   const h = harness();
   const status = await h.evo.statusText();
-  assert.equal(status.includes("采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：开（会派生 agent）"), true);
+  assert.equal(
+    status.includes(
+      "采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：开（会派生 agent）｜评审：开（提案后自动起督导）｜采纳：关（auto 提案等人工批准）",
+    ),
+    true,
+  );
   assert.equal(status.includes("锁：空闲"), true);
   const report = h.evo.reportText();
   assert.equal(report.includes("无曝光数据"), true);
@@ -248,29 +257,40 @@ test("reportText：按遥测给出曝光/加载/未命中", async () => {
   );
 });
 
-test("setEnabled：写回 config.json（两个键一起切）并立即生效", async () => {
+test("setEnabled：off 四个全关、on 只开复盘 + 评审（不动采集与自动采纳）", async () => {
   const h = harness();
   const message = await h.evo.setEnabled(false);
   assert.equal(message.includes("关闭"), true);
   const raw = JSON.parse(fs.readFileSync(path.join(h.dir, ".pi", "evolution", "config.json"), "utf8"));
-  assert.deepEqual([raw.enabled, raw.telemetry], [false, false]);
-  assert.equal((await h.evo.statusText()).includes("采集：关（不写遥测）｜复盘：关（不会派生 agent）"), true);
+  assert.deepEqual([raw.enabled, raw.telemetry, raw.autoReview, raw.autoApply], [false, false, false, false]);
+  assert.equal((await h.evo.statusText()).includes("采集：关（不写遥测）｜复盘：关（不会派生 agent）｜评审：关（提案停在 proposed 等人工）｜采纳：关（auto 提案等人工批准）"), true);
 
   await h.evo.setEnabled(true);
   const back = JSON.parse(fs.readFileSync(path.join(h.dir, ".pi", "evolution", "config.json"), "utf8"));
-  assert.deepEqual([back.enabled, back.telemetry], [true, true]);
+  // 用户定的语义：on = 复盘 + 评审两开；采集要另外 collect on，自动采纳要另外 apply on
+  assert.deepEqual([back.enabled, back.autoReview, back.telemetry, back.autoApply], [true, true, false, false]);
 });
 
-test("setFlag：只切一个字段，并把当前两个开关的状态写进回执", async () => {
-  const h = harness({}, { enabled: false, telemetry: false });
+test("setFlag：只切一个字段，并把当前四个开关的状态写进回执", async () => {
+  const h = harness({}, { enabled: false, telemetry: false, autoReview: false });
   const text = await h.evo.setFlag("telemetry", true);
-  // 回执要能看出「只开了采集、复盘还关着」，否则用户以为已经会花 token 了
-  assert.equal(text.includes("采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：关（不会派生 agent）"), true);
+  // 回执要能看出「只开了采集、复盘/评审还关着」，否则用户以为已经会花 token 了
+  assert.equal(
+    text.includes("采集：开（遥测写入 .pi/evolution/telemetry/）｜复盘：关（不会派生 agent）｜评审：关（提案停在 proposed 等人工）"),
+    true,
+  );
   const raw = JSON.parse(fs.readFileSync(path.join(h.dir, ".pi", "evolution", "config.json"), "utf8"));
   assert.deepEqual([raw.enabled, raw.telemetry], [false, true], "setFlag(telemetry) 不碰复盘");
   await h.evo.setFlag("enabled", true);
   const after = JSON.parse(fs.readFileSync(path.join(h.dir, ".pi", "evolution", "config.json"), "utf8"));
   assert.deepEqual([after.enabled, after.telemetry], [true, true], "setFlag(enabled) 不碰采集");
+  await h.evo.setFlag("autoReview", true);
+  const judged = JSON.parse(fs.readFileSync(path.join(h.dir, ".pi", "evolution", "config.json"), "utf8"));
+  assert.deepEqual(
+    [judged.enabled, judged.telemetry, judged.autoReview, judged.autoApply],
+    [true, true, true, false],
+    "review 只翻 autoReview：复盘/采集/采纳都不许跟着动",
+  );
 });
 
 test("没有 config.json 时默认全关：不派生、不落遥测", async () => {
@@ -288,19 +308,42 @@ test("没有 config.json 时默认全关：不派生、不落遥测", async () =
     supervisorSpawnFn: fakeSupervisorSpawn([]),
   });
   const status = await evo.statusText();
-  assert.equal(status.includes("采集：关（不写遥测）｜复盘：关（不会派生 agent）"), true);
+  assert.equal(
+    status.includes("采集：关（不写遥测）｜复盘：关（不会派生 agent）｜评审：开（提案后自动起督导）｜采纳：关（auto 提案等人工批准）"),
+    true,
+    "默认只开自动评审：enabled 关着时它永远走不到",
+  );
   evo.recordAdvertised({ sessionId: "s1", cwd: dir, prompt: "x", skills: [skill("a")] });
   evo.settle({ sessionId: "s1" });
   await settleAsync();
   assert.deepEqual(readTelemetry(dir), [], "默认关：遥测也不写");
 });
 
-test("telemetry 关着时只记开关状态不落盘（on 之后才采集）", async () => {
+test("autoReview 关着：退出前补发照跑，但不起督导（run 停在 proposed 等人工）", async () => {
+  const h = harness({}, { autoReview: false });
+  h.evo.recordAdvertised({ sessionId: "s1", cwd: h.dir, prompt: "第1轮", skills: [skill("a")] });
+  h.evo.settle({ sessionId: "s1" });
+  await settleAsync();
+  assert.equal(h.spawns, 1, "复盘本身照旧派发");
+  assert.equal(h.supervisorCalls.length, 0, "评审关着：派发路径也不许起督导");
+  await h.exitChild(0);
+
+  h.tick(1000);
+  h.evo.recordAdvertised({ sessionId: "s1", cwd: h.dir, prompt: "第2轮", skills: [skill("b")] });
+  h.evo.settle({ sessionId: "s1" });
+  await settleAsync();
+  h.evo.shutdown();
+  assert.equal(h.spawns, 2, "退出补发这条路径同样要派发复盘");
+  assert.equal(h.supervisorCalls.length, 0, "退出补发路径也要看评审开关");
+});
+
+test("telemetry 关着时只记开关状态不落盘（collect on 之后才采集）", async () => {
   const h = harness({}, { telemetry: false });
   h.evo.recordAdvertised({ sessionId: "s1", cwd: h.dir, prompt: "x", skills: [skill("a")] });
   await settleAsync();
   assert.deepEqual(h.events(), []);
-  await h.evo.setEnabled(true);
+  // 2026-11-08 起 on 不再顺带开采集：采集必须显式 collect on
+  await h.evo.setFlag("telemetry", true);
   h.evo.recordAdvertised({ sessionId: "s1", cwd: h.dir, prompt: "y", skills: [skill("a")] });
   await settleAsync();
   assert.equal(h.events().some((event) => event.kind === "advertised"), true, "on 之后同一会话就采集");

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

@@ -51,6 +51,8 @@ function tools(fixture: Fixture) {
     git: () => ({ code: 0, out: "" }),
     loadDiagnostics: () => [],
     runMdCheck: () => ({ code: 0, output: "" }),
+    // 开关默认全开：拒绝侧的用例只关心队列/run 状态，不该被自动采纳开关挡住
+    flags: () => ({ autoReview: true, autoApply: true }),
   });
 }