pi-skill-evolve 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,151 @@
+/**
+ * `/skill-audit` 文本单测（零依赖，node --test）。
+ *
+ * 运行：
+ *   cd .pi/extensions/skill-evolve
+ *   node --experimental-strip-types --test test/audit.test.ts
+ *
+ * 覆盖：六类都出现（0 也要列）、attributed 事件按次数累计、
+ * 无归因记录的历史 missed 走现算并计入来源、硬禁令 P0 列表、加载率注解文案。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { fingerprintOf } from "../lib/baseline.ts";
+
+import { AUDIT_LOAD_RATE_NOTE, activeToolsFromEvents, auditText, buildAuditModel, exposedFromEvents } from "../lib/audit.ts";
+import type { TelemetryEvent } from "../lib/telemetry.ts";
+
+function event(partial: Partial<TelemetryEvent> & { kind: TelemetryEvent["kind"] }): TelemetryEvent {
+  return { ts: 1_700_000_000_000, iso: "2023-11-14T22:13:20.000Z", ...partial } as TelemetryEvent;
+}
+
+const EVENTS: TelemetryEvent[] = [
+  event({
+    kind: "advertised",
+    sessionId: "s1",
+    skills: [
+      { name: "alpha", filePath: "/r/.pi/skills/alpha/SKILL.md", disabled: false, source: "project" },
+      { name: "beta", filePath: "/r/.pi/skills/beta/SKILL.md", disabled: false, source: "project" },
+    ],
+    activeTools: ["read", "bash"],
+  }),
+  event({ kind: "loaded", sessionId: "s1", skill: "alpha" }),
+  event({ kind: "missed", sessionId: "s1", skill: "beta" }),
+  event({ kind: "missed", sessionId: "s1", skill: "beta" }),
+  event({ kind: "attributed", sessionId: "s1", skill: "beta", category: "B", reason: "frontmatter 坏" }),
+  event({ kind: "attributed", sessionId: "s1", skill: "beta", category: "B", reason: "frontmatter 坏" }),
+  // 历史数据（M2 之前）：missed 有记录，但没有任何 attributed
+  event({ kind: "missed", sessionId: "s0", skill: "gamma" }),
+  event({ kind: "missed", sessionId: "s0", skill: "gamma" }),
+  event({ kind: "missed", sessionId: "s0", skill: "gamma" }),
+  event({ kind: "missed", sessionId: "s0", skill: "delta" }),
+];
+
+test("buildAuditModel：attributed 按次数累计，历史 missed 走现算", () => {
+  const model = buildAuditModel({
+    days: 7,
+    events: EVENTS,
+    classify: (skill) => (skill === "gamma" ? "E" : "semantic"),
+    conflicts: [],
+    invalidRules: [],
+  });
+  const byCategory = new Map(model.rows.map((row) => [row.category, row.count]));
+  assert.equal(byCategory.get("B"), 2);
+  assert.equal(byCategory.get("E"), 3);
+  assert.equal(byCategory.get("semantic"), 1);
+  assert.equal(model.fromTelemetry, 2);
+  assert.equal(model.fromLive, 4);
+  assert.deepEqual(model.unattributed, []);
+  assert.equal(model.summary.advertised, 2);
+  assert.equal(model.summary.loaded, 1);
+});
+
+test("buildAuditModel：不给 classify 时历史 missed 进「未归因」，不硬编类别", () => {
+  const model = buildAuditModel({ days: 7, events: EVENTS, conflicts: [], invalidRules: [] });
+  assert.deepEqual(model.unattributed, [{ skill: "gamma", count: 3 }, { skill: "delta", count: 1 }]);
+  const total = model.rows.reduce((sum, row) => sum + row.count, 0);
+  assert.equal(total, 2); // 只有 attributed 的 2 条
+});
+
+test("auditText：六类全列、P0 列表、行号、加载率注解都在", () => {
+  const text = auditText(
+    buildAuditModel({
+      days: 7,
+      events: EVENTS,
+      classify: (skill) => (skill === "gamma" ? "E" : "semantic"),
+      conflicts: [
+        { ruleId: "rg-over-find", level: "P0", skill: "deploy-test", line: 129, quote: "grep -rho 对账" },
+      ],
+      invalidRules: ["broken-rule: 正则编译失败"],
+    }),
+  );
+  for (const category of ["A", "B", "C", "D", "E", "semantic"]) {
+    assert.match(text, new RegExp(`^\\s+${category === "semantic" ? "semantic" : category}\\s`, "m"), `缺类别 ${category}`);
+  }
+  assert.match(text, /加载率 50\.0%/);
+  assert.match(text, /B\s+frontmatter 坏\s+2/);
+  assert.match(text, /rg-over-find\s+deploy-test:129\s+P0/);
+  assert.match(text, /规则不可用：/);
+  assert.ok(text.includes(AUDIT_LOAD_RATE_NOTE));
+  assert.match(text, /加载率低 ≠ 技能没用/);
+});
+
+test("auditText：无冲突、无数据时也要有明确结论而不是空白", () => {
+  const text = auditText(buildAuditModel({ days: 7, events: [], conflicts: [], invalidRules: [] }));
+  assert.match(text, /P0 命中 0 条/);
+  assert.match(text, /无曝光数据/);
+  assert.match(text, /没有可归因的未命中/);
+});
+
+test("exposedFromEvents / activeToolsFromEvents 取最近一次 advertised", () => {
+  const events = [
+    ...EVENTS,
+    event({
+      kind: "advertised",
+      sessionId: "s2",
+      skills: [{ name: "omega", filePath: "", disabled: true, source: "embedded" }],
+      activeTools: ["edit"],
+    }),
+  ];
+  assert.deepEqual(exposedFromEvents(events), [{ name: "omega", filePath: "", disabled: true }]);
+  assert.deepEqual(activeToolsFromEvents(events), ["edit"]);
+  // 老数据没有 activeTools 字段：返回空数组，调用方据此不判 E
+  assert.deepEqual(activeToolsFromEvents(EVENTS), ["read", "bash"]);
+  assert.deepEqual(activeToolsFromEvents([event({ kind: "missed", skill: "x" })]), []);
+});
+
+test("auditText：存量命中与新增命中分两段，只有新增算失败信号", () => {
+  const stockHit = { ruleId: "rg-over-find", level: "P0", skill: "deploy-test", line: 129, quote: "老问题" };
+  const addedHit = { ruleId: "file-size-limit", level: "P0", skill: "big-skill", line: 12, quote: "600 行" };
+  const text = auditText(
+    buildAuditModel({
+      days: 7,
+      events: [],
+      conflicts: [stockHit, addedHit],
+      knownFingerprints: new Set([fingerprintOf(stockHit)]),
+      invalidRules: [],
+    }),
+  );
+  assert.match(text, /P0 命中 2 条：存量（baseline）1 条 · 新增 1 条/);
+  assert.match(text, /新增\s+file-size-limit\s+big-skill:12\s+P0/);
+  assert.match(text, /存量\s+rg-over-find\s+deploy-test:129\s+P0/);
+  assert.match(text, /确认无害后跑 \/skill-evolve baseline 接受/);
+});
+
+test("auditText：全是存量时不出现「新增命中」提示", () => {
+  const hits = [
+    { ruleId: "rg-over-find", level: "P0", skill: "deploy-test", line: 129, quote: "老问题一" },
+    { ruleId: "rg-over-find", level: "P0", skill: "deploy-test", line: 196, quote: "老问题二" },
+  ];
+  const text = auditText(
+    buildAuditModel({
+      days: 7,
+      events: [],
+      conflicts: hits,
+      knownFingerprints: new Set(hits.map((hit) => fingerprintOf(hit))),
+      invalidRules: [],
+    }),
+  );
+  assert.match(text, /P0 命中 2 条：存量（baseline）2 条 · 新增 0 条/);
+  assert.doesNotMatch(text, /新增命中：/);
+});

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

@@ -0,0 +1,132 @@
+/**
+ * 存量债基线单测（设计稿 10.4）：指纹不含行号、首次审计 bootstrap、新命中算新增、--reset 清空。
+ *
+ * 全部用临时目录 + directQueue（直写）跑真实 IO —— 这段逻辑的坑在「文件在不在、指纹对不对」，
+ * 只测纯函数测不出 bootstrap 到底有没有落盘。
+ */
+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 {
+  buildBaseline,
+  createBaselineGate,
+  fingerprintOf,
+  fingerprintsOf,
+  readBaseline,
+  saveBaseline,
+  splitHits,
+} from "../lib/baseline.ts";
+import type { HardRuleHit } from "../lib/hard-rules.ts";
+import { directQueue } from "../lib/telemetry.ts";
+
+const NOW = 1_760_000_000_000;
+
+function hit(over: Partial<HardRuleHit> = {}): HardRuleHit {
+  return {
+    ruleId: "rg-over-find",
+    level: "P0",
+    skill: "deploy-test",
+    line: 129,
+    quote: "grep -rho 'env::var(\"[A-Z_]*\"' rust_server/src",
+    ...over,
+  };
+}
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "skill-evolve-baseline-"));
+}
+
+function gateFor(dir: string, hits: HardRuleHit[]) {
+  const file = path.join(dir, "baseline.json");
+  return {
+    file,
+    gate: createBaselineGate({ file, hits: () => hits, now: () => NOW, queue: directQueue, log: () => {} }),
+  };
+}
+
+test("fingerprintOf：行号不进指纹，quote 只算前 120 字", () => {
+  const base = hit();
+  assert.equal(fingerprintOf(base), fingerprintOf(hit({ line: 999 })));
+  const longQuote = "长".repeat(200);
+  assert.equal(fingerprintOf(hit({ quote: longQuote })), fingerprintOf(hit({ quote: `${longQuote}追加字符` })));
+  assert.notEqual(fingerprintOf(base), fingerprintOf(hit({ skill: "other" })));
+  assert.notEqual(fingerprintOf(base), fingerprintOf(hit({ ruleId: "file-size-limit" })));
+});
+
+test("首次审计：文件不存在时 bootstrap，把当时全部命中都当存量并落盘", async () => {
+  const dir = tempDir();
+  const { file, gate } = gateFor(dir, [hit(), hit({ line: 196, quote: "ssh x \"grep -rl '文案' dist\"" })]);
+
+  const first = gate.baseline();
+  assert.equal(first.bootstrap, true);
+  assert.equal(first.violations.length, 2);
+  await gate.settled();
+
+  const onDisk = readBaseline(file);
+  assert.ok(onDisk);
+  assert.equal(onDisk?.bootstrap, true);
+  assert.equal(onDisk?.violations.length, 2);
+
+  // 第一次审计后：两条全是存量，新增 0
+  const { stock, added } = splitHits(
+    [hit(), hit({ line: 196, quote: "ssh x \"grep -rl '文案' dist\"" })],
+    fingerprintsOf(first),
+  );
+  assert.equal(stock.length, 2);
+  assert.equal(added.length, 0);
+});
+
+test("新命中算新增：基线里已有的算存量，多出来的一条算新增", async () => {
+  const dir = tempDir();
+  const { file, gate } = gateFor(dir, [hit()]);
+  const baseline = buildBaseline([hit()], NOW, false);
+  await saveBaseline(file, baseline, directQueue);
+
+  const current = [hit(), hit({ ruleId: "file-size-limit", quote: "12.3K 行" })];
+  const { stock, added } = splitHits(current, fingerprintsOf(gate.baseline()));
+  assert.deepEqual(stock.map((item) => item.ruleId), ["rg-over-find"]);
+  assert.deepEqual(added.map((item) => item.ruleId), ["file-size-limit"]);
+});
+
+test("行号漂移不算新增：同一条问题从 129 行挪到 140 行仍是存量", async () => {
+  const dir = tempDir();
+  const { gate, file } = gateFor(dir, [hit({ line: 140 })]);
+  await saveBaseline(file, buildBaseline([hit({ line: 129 })], NOW, false), directQueue);
+
+  assert.equal(gate.isStock(hit({ line: 140 })), true);
+  assert.equal(splitHits([hit({ line: 140 })], fingerprintsOf(gate.baseline())).added.length, 0);
+});
+
+test("acceptAll：把当前全部命中写进基线，bootstrap 标 false", async () => {
+  const dir = tempDir();
+  const { gate, file } = gateFor(dir, [hit(), hit({ quote: "新增的一条" })]);
+
+  const message = await gate.acceptAll();
+  assert.match(message, /已接受 2 条/);
+  const onDisk = readBaseline(file);
+  assert.equal(onDisk?.bootstrap, false);
+  assert.equal(onDisk?.violations.length, 2);
+});
+
+test("reset：清空清单但不删文件（删了下次审计又会自动 bootstrap 回存量）", async () => {
+  const dir = tempDir();
+  const { gate, file } = gateFor(dir, [hit()]);
+  await saveBaseline(file, buildBaseline([hit()], NOW, false), directQueue);
+
+  const message = await gate.reset();
+  assert.match(message, /已清空存量基线/);
+  const onDisk = readBaseline(file);
+  assert.ok(onDisk, "reset 之后文件仍在");
+  assert.deepEqual(onDisk?.violations, []);
+  assert.equal(splitHits([hit()], fingerprintsOf(gate.baseline())).added.length, 1);
+});
+
+test("基线文件坏了当不存在处理，不抛", () => {
+  const dir = tempDir();
+  const file = path.join(dir, "baseline.json");
+  fs.writeFileSync(file, "{ 坏 json", "utf8");
+  const { gate } = gateFor(dir, [hit()]);
+  assert.equal(gate.baseline().bootstrap, true);
+});

package/extensions/skill-evolve/test/classify-action.test.ts

@@ -0,0 +1,133 @@
+/**
+ * 分级采纳的代码判定单测（13.1）：只看 diff 真改了什么，不看模型写的 action。
+ *
+ * 重点是边界：只改 description 才能 auto；同时碰正文就退成 approval；
+ * 路径越界 / 删文件 / 改 frontmatter 语义字段一律 forbidden。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { classifyAction, classifyChange, parseSections } from "../lib/classify-action.ts";
+
+function diff(path: string, body: string, oldPath = path, created = false): string {
+  const head = `--- ${created ? "/dev/null" : `a/${oldPath}`}\n+++ b/${path}\n@@ -1,3 +1,3 @@\n`;
+  return `${head}${body}\n`;
+}
+
+const SKILL = ".pi/skills/deploy-test/SKILL.md";
+
+test("只改 description 一行 → auto", () => {
+  const result = classifyChange({
+    diffText: diff(SKILL, "-description: 部署测试服\n+description: 部署测服并给出验收清单"),
+    proposalType: "improve",
+    skill: "deploy-test",
+  });
+  assert.equal(result.level, "auto");
+  assert.deepEqual(result.targets, [SKILL]);
+});
+
+test("description 改完再碰一条正文条款 → approval（不能只因为有一行 description 就放过）", () => {
+  const result = classifyChange({
+    diffText: diff(SKILL, "-description: 部署测试服\n+description: 部署测服并给出验收清单\n-禁止 pkill -f\n+禁止用 pkill -f"),
+    proposalType: "improve",
+    skill: "deploy-test",
+  });
+  assert.equal(result.level, "approval");
+});
+
+test("description 续行（缩进 ≥2）与纯空白改动仍算 auto", () => {
+  const result = classifyChange({
+    diffText: diff(SKILL, "-description: 部署测试服\n+description: 部署测试服，\n+  并在成功后给出验收清单\n-  \n+  "),
+    proposalType: "improve",
+    skill: "deploy-test",
+  });
+  assert.equal(result.level, "auto");
+});
+
+test("路径越界（技能目录下的非 SKILL.md）→ forbidden", () => {
+  const result = classifyChange({
+    diffText: diff(".pi/skills/deploy-test/notes.md", "-旧\n+新"),
+    proposalType: "improve",
+    skill: "deploy-test",
+  });
+  assert.equal(result.level, "forbidden");
+  assert.match(result.reasons[0] ?? "", /路径越界/);
+});
+
+test("删除技能文件（+++ /dev/null）→ forbidden", () => {
+  const text = `--- a/${SKILL}\n+++ /dev/null\n@@ -1,1 +0,0 @@\n--description: x\n`;
+  assert.equal(classifyChange({ diffText: text, proposalType: "improve", skill: "deploy-test" }).level, "forbidden");
+});
+
+test("改 frontmatter 的 name / allowed-tools / disable-model-invocation → forbidden", () => {
+  for (const field of ["name: 别的名字", "allowed-tools: bash", "disable-model-invocation: true"]) {
+    const result = classifyChange({
+      diffText: diff(SKILL, `-旧值\n+${field}`),
+      proposalType: "improve",
+      skill: "deploy-test",
+    });
+    assert.equal(result.level, "forbidden", `${field} 应 forbidden`);
+  }
+});
+
+test("动插件自身目录 → forbidden", () => {
+  const result = classifyChange({
+    diffText: diff(".pi/extensions/skill-evolve/prompts/复盘.md", "-旧\n+新"),
+    proposalType: "improve",
+    skill: "skill-evolve",
+  });
+  assert.equal(result.level, "forbidden");
+  assert.match(result.reasons[0] ?? "", /插件自身/);
+});
+
+test("prune（删技能提案）不论 diff 内容都 forbidden：插件只出清单不真删", () => {
+  const result = classifyChange({ diffText: diff(SKILL, "-旧\n+新"), proposalType: "prune", skill: "deploy-test" });
+  assert.equal(result.level, "forbidden");
+  assert.match(result.reasons[0] ?? "", /prune/);
+});
+
+test("新建 .cursor 路由 stub → auto", () => {
+  const text = `--- /dev/null\n+++ b/.cursor/skills/new-skill/SKILL.md\n@@ -0,0 +1,3 @@\n+唯一 SSOT：.pi/skills/new-skill/SKILL.md\n+动手前先 Read 它\n+# 路由\n`;
+  const result = classifyChange({ diffText: text, proposalType: "create", skill: "new-skill" });
+  assert.equal(result.level, "auto");
+  assert.deepEqual(result.targets, [".cursor/skills/new-skill/SKILL.md"]);
+});
+
+test("AGENTS.md 索引表只增一行 → auto；增两行 → approval", () => {
+  const one = diff("AGENTS.md", "+- `new-skill` —— `.pi/skills/new-skill/SKILL.md`");
+  assert.equal(classifyChange({ diffText: one, proposalType: "create", skill: "new-skill" }).level, "auto");
+  const two = diff("AGENTS.md", "+- `new-skill` —— `.pi/skills/new-skill/SKILL.md`\n+- `other` —— `.pi/skills/other/SKILL.md`");
+  assert.equal(classifyChange({ diffText: two, proposalType: "create", skill: "new-skill" }).level, "approval");
+});
+
+test("新增技能正文（.pi/skills/<新名>/SKILL.md 纯新建）→ approval", () => {
+  const text = `--- /dev/null\n+++ b/.pi/skills/new-skill/SKILL.md\n@@ -0,0 +1,2 @@\n+---\n+description: 新技能\n`;
+  assert.equal(classifyChange({ diffText: text, proposalType: "create", skill: "new-skill" }).level, "approval");
+});
+
+test("空 diff / 无增删行 → approval（判不动就不许自动写盘）", () => {
+  assert.equal(classifyChange({ diffText: "", proposalType: "improve", skill: "x" }).level, "approval");
+  const onlyContext = `--- a/${SKILL}\n+++ b/${SKILL}\n@@ -1,1 +1,1 @@\n 只有上下文\n`;
+  assert.equal(classifyChange({ diffText: onlyContext, proposalType: "improve", skill: "x" }).level, "approval");
+});
+
+test("多文件 diff 逐段判：技能文件 + 同 skill 的 .cursor stub 都只改描述/新建 → 仍 auto 需逐段合规", () => {
+  const text =
+    `--- a/${SKILL}\n+++ b/${SKILL}\n@@ -1,1 +1,1 @@\n-description: 旧\n+description: 新\n` +
+    `--- /dev/null\n+++ b/.cursor/skills/deploy-test/SKILL.md\n@@ -0,0 +1,1 @@\n+唯一 SSOT\n`;
+  const result = classifyChange({ diffText: text, proposalType: "improve", skill: "deploy-test" });
+  assert.equal(result.level, "auto");
+  assert.deepEqual(result.targets, [SKILL, ".cursor/skills/deploy-test/SKILL.md"]);
+});
+
+test("parseSections 跳过头部元信息与 @@ / \\ 行，保留改动的符号", () => {
+  const text = `diff --git a/${SKILL} b/${SKILL}\nindex 111..222 100644\n--- a/${SKILL}\n+++ b/${SKILL}\n@@ -1,2 +1,2 @@\n-old\n+new\n\\ No newline\n`;
+  const sections = parseSections(text);
+  assert.equal(sections.length, 1);
+  assert.deepEqual(sections[0]?.lines.map((line) => line.sign), ["-", "+"]);
+});
+
+test("classifyAction 兼容旧调用面（只看级别）", () => {
+  assert.equal(classifyAction(diff(SKILL, "-description: 旧\n+description: 新"), "improve"), "auto");
+  assert.equal(classifyAction(diff(SKILL, "-正文\n+正文2"), "improve"), "approval");
+  assert.equal(classifyAction(diff(SKILL, "-a\n+b"), "prune"), "forbidden");
+});

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

@@ -0,0 +1,267 @@
+/**
+ * /skill-evolve 子命令路由单测：只验证「参数 → 展示文本」，用假 Evolution 对象隔离 lib/evolution。
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { matchSubcommand, parseWebPort, runCommand } from "../lib/command.ts";
+import type { Evolution } from "../lib/evolution.ts";
+
+const TARGET = { sessionId: "sess-1", sessionFile: "/tmp/session.jsonl" };
+
+function fakeEvolution(calls: string[]): Evolution {
+  const stub = {
+    reportText: (days: number) => {
+      calls.push(`report:${days}`);
+      return `报告 ${days} 天`;
+    },
+    statusText: () => {
+      calls.push("status");
+      return "状态文本";
+    },
+    setEnabled: (enabled: boolean) => {
+      calls.push(`enabled:${enabled}`);
+      return `总开关：${enabled ? "开" : "关"}`;
+    },
+    setFlag: (field: string, value: boolean) => {
+      calls.push(`flag:${field}=${value}`);
+      return `开关：${field}=${value}`;
+    },
+    runNow: (target: { sessionId: string; sessionFile?: string }) => {
+      calls.push(`run:${target.sessionId}`);
+      return `已派生复盘：${target.sessionId}`;
+    },
+    acceptBaseline: (mode: "accept" | "reset") => {
+      calls.push(`baseline:${mode}`);
+      return `基线：${mode}`;
+    },
+    flush: async () => {},
+    model: {
+      config: () => ({ propose: "inherit", review: "inherit" }),
+      reviewModel: () => "inherit",
+      setModel: async (kind: string, spec: string) => {
+        calls.push(`model:${kind}=${spec}`);
+        return `已设 ${kind}=${spec}`;
+      },
+      selftestText: async () => {
+        calls.push("selftest");
+        return "自检：通过";
+      },
+      selftestFailed: () => false,
+      lastSelftest: () => undefined,
+    },
+    apply: {
+      sessionStart: () => {},
+      settle: () => {},
+      approve: async (runId: string, prune: boolean) => {
+        calls.push(`approve:${runId}${prune ? ":prune" : ""}`);
+        return `采纳 ${runId}`;
+      },
+      queueText: () => {
+        calls.push("queue");
+        return "队列文本";
+      },
+      autoApplyPending: async () => 0,
+      enqueueReady: async () => 0,
+    },
+    observe: {
+      refresh: () => ({ reviewing: 0, staleCount: 0, pendingApprovals: 0, lastAppliedAt: null, rollbackRate: 0, appliedSamples: 0 }),
+      noteDispatched: () => {},
+      weekReportText: async () => {
+        calls.push("week");
+        return "周报文本";
+      },
+    },
+  };
+  return stub as unknown as Evolution;
+}
+
+test("补全：空前缀给全量，命中前缀只给命中项，乱前缀也给全量", () => {
+  assert.deepEqual(
+    matchSubcommand("").map((item) => item.value),
+    ["status", "report", "run", "baseline", "selftest", "approve", "queue", "web", "config", "collect", "review", "on", "off"],
+  );
+  assert.deepEqual(
+    matchSubcommand("re").map((item) => item.value),
+    ["report", "review"],
+  );
+  assert.deepEqual(
+    matchSubcommand("co").map((item) => item.value),
+    ["config", "collect"],
+  );
+  assert.deepEqual(
+    matchSubcommand("qu").map((item) => item.value),
+    ["queue"],
+  );
+  assert.deepEqual(
+    matchSubcommand("ap").map((item) => item.value),
+    ["approve"],
+  );
+  assert.deepEqual(
+    matchSubcommand("o").map((item) => item.value),
+    ["on", "off"],
+  );
+  assert.deepEqual(
+    matchSubcommand("b").map((item) => item.value),
+    ["baseline"],
+  );
+  assert.deepEqual(
+    matchSubcommand("se").map((item) => item.value),
+    ["selftest"],
+  );
+  assert.deepEqual(
+    matchSubcommand("zzz").map((item) => item.value),
+    ["status", "report", "run", "baseline", "selftest", "approve", "queue", "web", "config", "collect", "review", "on", "off"],
+  );
+  assert.deepEqual(
+    matchSubcommand("w").map((item) => item.value),
+    ["web"],
+  );
+});
+
+test("空参数默认走 status", async () => {
+  const calls: string[] = [];
+  assert.equal(await runCommand("", fakeEvolution(calls), TARGET), "状态文本");
+  assert.deepEqual(calls, ["status"]);
+});
+
+test("report 带天数用天数，非法天数回落 7 天", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("report 3", evo, TARGET), "报告 3 天");
+  assert.equal(await runCommand("report abc", evo, TARGET), "报告 7 天");
+  assert.equal(await runCommand("report 0", evo, TARGET), "报告 7 天");
+  assert.equal(await runCommand("report", evo, TARGET), "报告 7 天");
+  assert.deepEqual(calls, ["report:3", "report:7", "report:7", "report:7"]);
+});
+
+test("on / off 透传布尔", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("on", evo, TARGET), "总开关：开");
+  assert.equal(await runCommand("off", evo, TARGET), "总开关：关");
+  assert.deepEqual(calls, ["enabled:true", "enabled:false"]);
+});
+
+test("run 子命令把手机会话透传给 runNow", async () => {
+  const calls: string[] = [];
+  assert.equal(await runCommand("run", fakeEvolution(calls), TARGET), "已派生复盘：sess-1");
+  assert.deepEqual(calls, ["run:sess-1"]);
+});
+
+test("baseline 子命令：默认接受，--reset 清空", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("baseline", evo, TARGET), "基线：accept");
+  assert.equal(await runCommand("baseline --reset", evo, TARGET), "基线：reset");
+  assert.deepEqual(calls, ["baseline:accept", "baseline:reset"]);
+});
+
+test("selftest 走 model.selftestText", async () => {
+  const calls: string[] = [];
+  assert.equal(await runCommand("selftest", fakeEvolution(calls), TARGET), "自检：通过");
+  assert.deepEqual(calls, ["selftest"]);
+});
+
+test("非 TUI 的 config 子命令打印当前值而不改配置", async () => {
+  const calls: string[] = [];
+  const text = await runCommand("config", fakeEvolution(calls), TARGET);
+  assert.match(text, /无法交互选择/);
+  assert.deepEqual(calls, []);
+});
+
+test("queue 子命令列采纳队列", async () => {
+  const calls: string[] = [];
+  assert.equal(await runCommand("queue", fakeEvolution(calls), TARGET), "队列文本");
+  assert.deepEqual(calls, ["queue"]);
+});
+
+test("approve 传 runId；带 --prune 时标记 prune", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("approve run-abc", evo, TARGET), "采纳 run-abc");
+  assert.equal(await runCommand("approve run-abc --prune", evo, TARGET), "采纳 run-abc");
+  assert.deepEqual(calls, ["approve:run-abc", "approve:run-abc:prune"]);
+});
+
+test("approve 缺 runId 时仍走 approve（由实现给用法串）", async () => {
+  const calls: string[] = [];
+  await runCommand("approve", fakeEvolution(calls), TARGET);
+  assert.deepEqual(calls, ["approve:"]);
+});
+
+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.deepEqual(calls, []);
+});
+
+test("collect on|off：只动采集（telemetry），不碰复盘", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("collect on", evo, TARGET), "开关：telemetry=true");
+  assert.equal(await runCommand("collect off", evo, TARGET), "开关：telemetry=false");
+  assert.deepEqual(calls, ["flag:telemetry=true", "flag:telemetry=false"]);
+});
+
+test("review 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.deepEqual(calls, ["flag:enabled=true", "flag:enabled=false"]);
+});
+
+test("collect / review 参数非法（缺失或写错）：给用法串且不改配置", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  for (const args of ["collect", "collect yes", "review", "review 1"]) {
+    const text = await runCommand(args, evo, TARGET);
+    assert.match(text, /用法：\/skill-evolve (collect|review) on\|off/, args);
+    assert.match(text, /配置未改动/, args);
+  }
+  assert.deepEqual(calls, [], "非法参数不该调 setFlag");
+});
+
+test("report --week 走周报，不把 --week 当天数", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  assert.equal(await runCommand("report --week", evo, TARGET), "周报文本");
+  assert.deepEqual(calls, ["week"]);
+});
+
+test("web：注入启动器时透传端口与 --once，没注入时给用法串", async () => {
+  const calls: string[] = [];
+  const evo = fakeEvolution(calls);
+  const withoutLauncher = await runCommand("web", evo, TARGET);
+  assert.match(withoutLauncher, /用法：\/skill-evolve web \[--port N\]/);
+  assert.match(withoutLauncher, /没有注入面板启动器/);
+
+  const requests: { port?: number; once: boolean }[] = [];
+  const launcher = async (request: { port?: number; once: boolean }): Promise<string> => {
+    requests.push(request);
+    return `面板：${request.port ?? "默认"}${request.once ? "(once)" : ""}`;
+  };
+  const withLauncher = { ...TARGET, web: launcher };
+  assert.equal(await runCommand("web", evo, withLauncher), "面板：默认");
+  assert.equal(await runCommand("web --port 7799", evo, withLauncher), "面板：7799");
+  assert.equal(await runCommand("web 7800", evo, withLauncher), "面板：7800");
+  assert.equal(await runCommand("web --once", evo, withLauncher), "面板：默认(once)");
+  assert.equal(await runCommand("web --port 7799 --once", evo, withLauncher), "面板：7799(once)");
+  assert.deepEqual(requests, [
+    { once: false },
+    { once: false, port: 7799 },
+    { once: false, port: 7800 },
+    { once: true },
+    { once: true, port: 7799 },
+  ]);
+});
+
+test("parseWebPort：只认 1~65535 的整数", () => {
+  assert.equal(parseWebPort(undefined), undefined);
+  assert.equal(parseWebPort("7788"), 7788);
+  assert.equal(parseWebPort("0"), undefined);
+  assert.equal(parseWebPort("65536"), undefined);
+  assert.equal(parseWebPort("abc"), undefined);
+});