refactor: checker 模块内聚化 — 每个 checker 自包含于独立目录

将 checker 架构重构为完全内聚模式：每个 checker 目录包含自身的
types、schema、validate、execute、expect 和 index，新增 checker
只需创建一个目录并在 runner/index.ts 添加一行注册。

主要变更：
- runner/shared/ 拆分：断言基础设施迁入 checker/expect/，
  body.ts 迁入 http/，text.ts 迁入 command/
- config-contract/ 重命名为 schema/，schema.ts → builder.ts
- size.ts + parseDuration 合并为 utils.ts
- 顶层 types.ts 改为 base interface + index signature，
  checker 专属类型下沉到各自 types.ts
- runner/index.ts 改为显式数组注册模式
- 更新 DEVELOPMENT.md 项目结构和开发新 Checker 指南

src/server/checker/expect/validate-operator.ts

@@ -0,0 +1,80 @@
+import type { ConfigValidationIssue } from "../schema/issues";
+import type { JsonValue } from "../types";
+
+import { OperatorKeys } from "../schema/fragments";
+import { issue, joinPath } from "../schema/issues";
+
+const OPERATOR_KEY_SET = new Set<string>(OperatorKeys);
+
+export function isJsonValue(value: unknown): value is JsonValue {
+  if (value === null) return true;
+  if (typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  if (typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).every(isJsonValue);
+  }
+  return false;
+}
+
+export function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function validateOperatorObject(
+  operators: unknown,
+  path: string,
+  targetName?: string,
+  options: { requireAtLeastOne: boolean } = { requireAtLeastOne: true },
+): ConfigValidationIssue[] {
+  if (!isPlainRecord(operators)) return [issue("invalid-type", path, "必须为操作符对象", targetName)];
+  const issues: ConfigValidationIssue[] = [];
+  let found = 0;
+  for (const [key, value] of Object.entries(operators)) {
+    if (!OPERATOR_KEY_SET.has(key)) {
+      issues.push(issue("unknown-operator", joinPath(path, key), "是未知 operator", targetName));
+      continue;
+    }
+    if (value === undefined) continue;
+    found++;
+    issues.push(...validateOperatorValue(key, value, joinPath(path, key), targetName));
+  }
+  if (options.requireAtLeastOne && found === 0) {
+    issues.push(issue("empty-operator", path, "必须包含至少一个合法 operator", targetName));
+  }
+  return issues;
+}
+
+export function validateOperatorValue(
+  key: string,
+  value: unknown,
+  path: string,
+  targetName?: string,
+): ConfigValidationIssue[] {
+  switch (key) {
+    case "contains":
+      return typeof value === "string" ? [] : [issue("invalid-type", path, "必须为字符串", targetName)];
+    case "empty":
+    case "exists":
+      return typeof value === "boolean" ? [] : [issue("invalid-type", path, "必须为布尔值", targetName)];
+    case "equals":
+      return isJsonValue(value) ? [] : [issue("invalid-type", path, "必须为 JSON value", targetName)];
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return typeof value === "number" && Number.isFinite(value)
+        ? []
+        : [issue("invalid-type", path, "必须为有限数字", targetName)];
+    case "match":
+      if (typeof value !== "string") return [issue("invalid-type", path, "必须为字符串", targetName)];
+      try {
+        new RegExp(value);
+        return [];
+      } catch {
+        return [issue("invalid-regex", path, "正则不合法", targetName)];
+      }
+    default:
+      return [issue("unknown-operator", path, "是未知 operator", targetName)];
+  }
+}