refactor: 统一 expect 断言体系，引入共享 ValueMatcher/ContentRules/KeyValueExpect 模型

- 引入共享 ValueMatcher（equals/contains/regex/exists/empty/gt/gte/lt/lte）
- 引入共享 ContentRules 数组（direct/json/css/xpath 提取器）
- 引入共享 KeyValueExpect（动态键值断言，字面量等价 equals）
- maxDurationMs → durationMs: ValueMatcher（所有 checker）
- match → regex（固定无 flags）
- Ping max* → packetLossPercent/avgLatencyMs/maxLatencyMs（ValueMatcher）
- LLM finishReason/rawFinishReason → ValueMatcher
- DB 新增 result: ContentRules
- TCP banner → ContentRules 数组
- 删除旧模块：operator.ts、validate-operator.ts、duration.ts、body.ts、text.ts、output.ts
- 更新全部 checker schema/validate/expect/execute
- 更新 probe-config.schema.json、probes.example.yaml
- 更新 README.md、DEVELOPMENT.md（含 expect 字段选择规范）
- 同步 10 个 delta specs 到主 specs，归档 change

tests/server/checker/runner/shared/body.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
-import { checkBodyExpect } from "../../../../../src/server/checker/runner/http/body";
+import { checkContentRules } from "../../../../../src/server/checker/expect/content";
+
+function checkBodyExpect(body: string, rules?: Parameters<typeof checkContentRules>[1]) {
+  return checkContentRules(body, rules, { path: "body", phase: "body" });
+}
 
 describe("checkBodyExpect (BodyRule[])", () => {
   test("无规则返回匹配成功", () => {
@@ -57,7 +61,7 @@ describe("checkBodyExpect (BodyRule[])", () => {
   test("json 操作符匹配", () => {
     const body = JSON.stringify({ count: 42, version: "v2.1.0" });
     expect(checkBodyExpect(body, [{ json: { gte: 10, path: "$.count" } }]).matched).toBe(true);
-    expect(checkBodyExpect(body, [{ json: { match: "\\d+\\.\\d+\\.\\d+", path: "$.version" } }]).matched).toBe(true);
+    expect(checkBodyExpect(body, [{ json: { path: "$.version", regex: "\\d+\\.\\d+\\.\\d+" } }]).matched).toBe(true);
     expect(checkBodyExpect(body, [{ json: { gte: 100, path: "$.count" } }]).matched).toBe(false);
   });
 

tests/server/checker/runner/shared/duration.test.ts

@@ -1,6 +1,13 @@
 import { describe, expect, test } from "bun:test";
 
-import { checkDuration } from "../../../../../src/server/checker/expect/duration";
+import { checkValueMatcher } from "../../../../../src/server/checker/expect/matcher";
+
+function checkDuration(durationMs: number, maxDurationMs?: number) {
+  return checkValueMatcher(durationMs, maxDurationMs === undefined ? undefined : { lte: maxDurationMs }, {
+    path: "durationMs",
+    phase: "duration",
+  });
+}
 
 describe("checkDuration", () => {
   test("未配置 maxDurationMs 返回匹配成功", () => {

tests/server/checker/runner/shared/operator.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { applyOperator, checkExpectValue, evaluateJsonPath } from "../../../../../src/server/checker/expect/operator";
+import { applyMatcher, checkExpectValue, evaluateJsonPath } from "../../../../../src/server/checker/expect/matcher";
 
 describe("evaluateJsonPath", () => {
   const obj = {
@@ -55,81 +55,83 @@ describe("evaluateJsonPath", () => {
   });
 });
 
-describe("applyOperator", () => {
+describe("applyMatcher", () => {
   test("equals 操作符", () => {
-    expect(applyOperator("ok", { equals: "ok" })).toBe(true);
-    expect(applyOperator("ok", { equals: "error" })).toBe(false);
-    expect(applyOperator(42, { equals: 42 })).toBe(true);
-    expect(applyOperator(42, { equals: 41 })).toBe(false);
-    expect(applyOperator(null, { equals: null })).toBe(true);
-    expect(applyOperator(true, { equals: true })).toBe(true);
+    expect(applyMatcher("ok", { equals: "ok" })).toBe(true);
+    expect(applyMatcher("ok", { equals: "error" })).toBe(false);
+    expect(applyMatcher(42, { equals: 42 })).toBe(true);
+    expect(applyMatcher(42, { equals: 41 })).toBe(false);
+    expect(applyMatcher(null, { equals: null })).toBe(true);
+    expect(applyMatcher(true, { equals: true })).toBe(true);
   });
 
   test("equals 支持 JSON 对象和数组", () => {
-    expect(applyOperator({ status: "ok" }, { equals: { status: "ok" } })).toBe(true);
-    expect(applyOperator({ status: "ok" }, { equals: { status: "fail" } })).toBe(false);
-    expect(applyOperator(["a", "b"], { equals: ["a", "b"] })).toBe(true);
-    expect(applyOperator(["a", "b"], { equals: ["b", "a"] })).toBe(false);
+    expect(applyMatcher({ status: "ok" }, { equals: { status: "ok" } })).toBe(true);
+    expect(applyMatcher({ status: "ok" }, { equals: { status: "fail" } })).toBe(false);
+    expect(applyMatcher(["a", "b"], { equals: ["a", "b"] })).toBe(true);
+    expect(applyMatcher(["a", "b"], { equals: ["b", "a"] })).toBe(false);
   });
 
   test("contains 操作符", () => {
-    expect(applyOperator("hello world", { contains: "hello" })).toBe(true);
-    expect(applyOperator("hello world", { contains: "missing" })).toBe(false);
-    expect(applyOperator(12345, { contains: "23" })).toBe(true);
+    expect(applyMatcher("hello world", { contains: "hello" })).toBe(true);
+    expect(applyMatcher("hello world", { contains: "missing" })).toBe(false);
+    expect(applyMatcher(12345, { contains: "23" })).toBe(true);
   });
 
-  test("match 操作符", () => {
-    expect(applyOperator("v2.1.0", { match: "\\d+\\.\\d+\\.\\d+" })).toBe(true);
-    expect(applyOperator("v2.1", { match: "\\d+\\.\\d+\\.\\d+" })).toBe(false);
-    expect(applyOperator("abc123", { match: "^\\w+\\d+$" })).toBe(true);
+  test("regex matcher", () => {
+    expect(applyMatcher("v2.1.0", { regex: "\\d+\\.\\d+\\.\\d+" })).toBe(true);
+    expect(applyMatcher("v2.1", { regex: "\\d+\\.\\d+\\.\\d+" })).toBe(false);
+    expect(applyMatcher("abc123", { regex: "^\\w+\\d+$" })).toBe(true);
   });
 
   test("empty 操作符", () => {
-    expect(applyOperator("", { empty: true })).toBe(true);
-    expect(applyOperator(null, { empty: true })).toBe(true);
-    expect(applyOperator(undefined, { empty: true })).toBe(true);
-    expect(applyOperator([], { empty: true })).toBe(true);
-    expect(applyOperator({}, { empty: true })).toBe(true);
-    expect(applyOperator("ok", { empty: true })).toBe(false);
-    expect(applyOperator([1, 2], { empty: false })).toBe(true);
-    expect(applyOperator([], { empty: false })).toBe(false);
+    expect(applyMatcher("", { empty: true })).toBe(true);
+    expect(applyMatcher(null, { empty: true })).toBe(true);
+    expect(applyMatcher(undefined, { empty: true })).toBe(true);
+    expect(applyMatcher([], { empty: true })).toBe(true);
+    expect(applyMatcher({}, { empty: true })).toBe(true);
+    expect(applyMatcher("ok", { empty: true })).toBe(false);
+    expect(applyMatcher(0, { empty: true })).toBe(false);
+    expect(applyMatcher(false, { empty: true })).toBe(false);
+    expect(applyMatcher([1, 2], { empty: false })).toBe(true);
+    expect(applyMatcher([], { empty: false })).toBe(false);
   });
 
   test("exists 操作符", () => {
-    expect(applyOperator("ok", { exists: true })).toBe(true);
-    expect(applyOperator(null, { exists: true })).toBe(true);
-    expect(applyOperator(undefined, { exists: true })).toBe(false);
-    expect(applyOperator(undefined, { exists: false })).toBe(true);
-    expect(applyOperator("ok", { exists: false })).toBe(false);
+    expect(applyMatcher("ok", { exists: true })).toBe(true);
+    expect(applyMatcher(null, { exists: true })).toBe(true);
+    expect(applyMatcher(undefined, { exists: true })).toBe(false);
+    expect(applyMatcher(undefined, { exists: false })).toBe(true);
+    expect(applyMatcher("ok", { exists: false })).toBe(false);
   });
 
   test("gte 操作符", () => {
-    expect(applyOperator(10, { gte: 5 })).toBe(true);
-    expect(applyOperator(5, { gte: 5 })).toBe(true);
-    expect(applyOperator(3, { gte: 5 })).toBe(false);
-    expect(applyOperator("10", { gte: 5 })).toBe(true);
+    expect(applyMatcher(10, { gte: 5 })).toBe(true);
+    expect(applyMatcher(5, { gte: 5 })).toBe(true);
+    expect(applyMatcher(3, { gte: 5 })).toBe(false);
+    expect(applyMatcher("10", { gte: 5 })).toBe(true);
   });
 
   test("lte 操作符", () => {
-    expect(applyOperator(3, { lte: 5 })).toBe(true);
-    expect(applyOperator(5, { lte: 5 })).toBe(true);
-    expect(applyOperator(10, { lte: 5 })).toBe(false);
+    expect(applyMatcher(3, { lte: 5 })).toBe(true);
+    expect(applyMatcher(5, { lte: 5 })).toBe(true);
+    expect(applyMatcher(10, { lte: 5 })).toBe(false);
   });
 
   test("gt 操作符", () => {
-    expect(applyOperator(10, { gt: 5 })).toBe(true);
-    expect(applyOperator(5, { gt: 5 })).toBe(false);
+    expect(applyMatcher(10, { gt: 5 })).toBe(true);
+    expect(applyMatcher(5, { gt: 5 })).toBe(false);
   });
 
   test("lt 操作符", () => {
-    expect(applyOperator(3, { lt: 5 })).toBe(true);
-    expect(applyOperator(5, { lt: 5 })).toBe(false);
+    expect(applyMatcher(3, { lt: 5 })).toBe(true);
+    expect(applyMatcher(5, { lt: 5 })).toBe(false);
   });
 
   test("多操作符 AND 组合", () => {
-    expect(applyOperator(7, { gte: 5, lte: 10 })).toBe(true);
-    expect(applyOperator(3, { gte: 5, lte: 10 })).toBe(false);
-    expect(applyOperator(15, { gte: 5, lte: 10 })).toBe(false);
+    expect(applyMatcher(7, { gte: 5, lte: 10 })).toBe(true);
+    expect(applyMatcher(3, { gte: 5, lte: 10 })).toBe(false);
+    expect(applyMatcher(15, { gte: 5, lte: 10 })).toBe(false);
   });
 });
 

tests/server/checker/runner/shared/text.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
-import { checkTextRules } from "../../../../../src/server/checker/runner/cmd/text";
+import { checkContentRules } from "../../../../../src/server/checker/expect/content";
+
+function checkTextRules(text: string, rules: Parameters<typeof checkContentRules>[1], phase: string) {
+  return checkContentRules(text, rules, { path: phase, phase });
+}
 
 describe("checkTextRules", () => {
   test("无规则返回匹配成功", () => {
@@ -24,7 +28,7 @@ describe("checkTextRules", () => {
   test("多条规则全部通过", () => {
     const r = checkTextRules(
       "version: 3.2.1, build: ok",
-      [{ contains: "version" }, { match: "\\d+\\.\\d+\\.\\d+" }],
+      [{ contains: "version" }, { regex: "\\d+\\.\\d+\\.\\d+" }],
       "stdout",
     );
     expect(r.matched).toBe(true);