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

src/server/checker/runner/http/execute.ts

@@ -5,10 +5,10 @@ import type { CheckResult, RawTargetConfig } from "../../types";
 import type { CheckerContext, CheckerDefinition, CheckerValidationInput, ResolveContext } from "../types";
 import type { HttpExpectConfig, HttpTargetConfig, ResolvedHttpTarget } from "./types";
 
-import { checkDuration } from "../../expect/duration";
+import { checkContentRules } from "../../expect/content";
 import { errorFailure, mismatchFailure } from "../../expect/failure";
+import { checkValueMatcher } from "../../expect/matcher";
 import { parseSize } from "../../utils";
-import { checkBodyExpect } from "./body";
 import { checkHeaders, checkStatus } from "./expect";
 import { httpCheckerSchemas } from "./schema";
 import { validateHttpConfig } from "./validate";
@@ -54,7 +54,7 @@ export class HttpChecker implements CheckerDefinition<ResolvedHttpTarget> {
 
       const hasBodyRules = !!(expect?.body && expect.body.length > 0);
 
-      const earlyTimeout = hasBodyRules ? checkEarlyTimeout(start, expect?.maxDurationMs) : null;
+      const earlyTimeout = hasBodyRules ? checkEarlyTimeout(start, expect?.durationMs) : null;
       if (earlyTimeout) {
         return makeResult(t, timestamp, earlyTimeout.elapsed, earlyTimeout.failure, statusCode);
       }
@@ -70,14 +70,18 @@ export class HttpChecker implements CheckerDefinition<ResolvedHttpTarget> {
           return makeResult(t, timestamp, performance.now() - start, decodeResult.failure, statusCode);
         }
 
-        const bodyResult = checkBodyExpect(decodeResult.text, expect.body);
+        const bodyResult = checkContentRules(decodeResult.text, expect.body, { path: "body", phase: "body" });
         if (!bodyResult.matched) {
           return makeResult(t, timestamp, performance.now() - start, bodyResult.failure, statusCode);
         }
       }
 
       const durationMs = Math.round(performance.now() - start);
-      const durationResult = checkDuration(durationMs, expect?.maxDurationMs);
+      const durationResult = checkValueMatcher(durationMs, expect?.durationMs, {
+        message: "durationMs mismatch",
+        path: "durationMs",
+        phase: "duration",
+      });
       if (!durationResult.matched) {
         return makeResult(t, timestamp, durationMs, durationResult.failure, statusCode);
       }
@@ -190,23 +194,29 @@ function buildRedirectInit(init: RequestInit, statusCode: number, fromUrl: strin
 
 function checkEarlyTimeout(
   start: number,
-  maxDurationMs: number | undefined,
+  durationMatcher: HttpExpectConfig["durationMs"] | undefined,
 ): null | { elapsed: number; failure: CheckResult["failure"] } {
-  if (maxDurationMs === undefined) return null;
+  if (durationMatcher === undefined) return null;
+  const limit = Math.min(
+    durationMatcher.lte ?? Number.POSITIVE_INFINITY,
+    durationMatcher.lt ?? Number.POSITIVE_INFINITY,
+  );
+  if (!Number.isFinite(limit)) return null;
 
   const elapsed = performance.now() - start;
-  if (elapsed <= maxDurationMs) return null;
+  if (durationMatcher.lt !== undefined ? elapsed < limit : elapsed <= limit) return null;
 
   const durationMs = Math.round(elapsed);
+  const durationResult = checkValueMatcher(durationMs, durationMatcher, {
+    message: "durationMs mismatch",
+    path: "durationMs",
+    phase: "duration",
+  });
   return {
     elapsed,
-    failure: mismatchFailure(
-      "duration",
-      "duration",
-      `<=${maxDurationMs}ms`,
-      durationMs,
-      `duration ${durationMs}ms > ${maxDurationMs}ms`,
-    ),
+    failure:
+      durationResult.failure ??
+      mismatchFailure("duration", "durationMs", durationMatcher, durationMs, "durationMs mismatch"),
   };
 }