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/duration.ts

@@ -0,0 +1,20 @@
+import type { ExpectResult } from "./types";
+
+import { mismatchFailure } from "./failure";
+
+export function checkDuration(durationMs: number, maxDurationMs?: number): ExpectResult {
+  if (maxDurationMs === undefined) return { failure: null, matched: true };
+  if (durationMs > maxDurationMs) {
+    return {
+      failure: mismatchFailure(
+        "duration",
+        "duration",
+        `<=${maxDurationMs}ms`,
+        durationMs,
+        `duration ${durationMs}ms > ${maxDurationMs}ms`,
+      ),
+      matched: false,
+    };
+  }
+  return { failure: null, matched: true };
+}

src/server/checker/expect/failure.ts

@@ -0,0 +1,34 @@
+import type { CheckFailure } from "../types";
+
+export function errorFailure(phase: CheckFailure["phase"], path: string, message: string): CheckFailure {
+  return {
+    kind: "error",
+    message,
+    path,
+    phase,
+  };
+}
+
+export function mismatchFailure(
+  phase: CheckFailure["phase"],
+  path: string,
+  expected: unknown,
+  actual: unknown,
+  message: string,
+): CheckFailure {
+  return {
+    actual: truncateActual(actual),
+    expected,
+    kind: "mismatch",
+    message,
+    path,
+    phase,
+  };
+}
+
+export function truncateActual(value: unknown, maxLen = 200): unknown {
+  if (value === undefined || value === null) return value;
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  if (str.length <= maxLen) return value;
+  return str.slice(0, maxLen) + "...";
+}

src/server/checker/expect/operator.ts

@@ -0,0 +1,79 @@
+import { isEmptyObject, isEqual, isNil, isPlainObject } from "es-toolkit";
+
+import type { ExpectOperator, ExpectValue } from "../types";
+
+const OPERATOR_KEYS = new Set(["contains", "empty", "equals", "exists", "gt", "gte", "lt", "lte", "match"]);
+
+export function applyOperator(actual: unknown, op: ExpectOperator): boolean {
+  for (const [key, expected] of Object.entries(op)) {
+    if (expected === undefined) continue;
+
+    switch (key) {
+      case "contains":
+        if (!String(actual).includes(expected as string)) return false;
+        break;
+      case "empty": {
+        const isEmpty =
+          isNil(actual) || actual === "" || (Array.isArray(actual) && actual.length === 0) || isEmptyObject(actual);
+        if (expected !== isEmpty) return false;
+        break;
+      }
+      case "equals":
+        if (!isEqual(actual, expected)) return false;
+        break;
+      case "exists":
+        if (expected) {
+          if (actual === undefined) return false;
+        } else {
+          if (actual !== undefined) return false;
+        }
+        break;
+      case "gt":
+        if (!(Number(actual) > (expected as number))) return false;
+        break;
+      case "gte":
+        if (!(Number(actual) >= (expected as number))) return false;
+        break;
+      case "lt":
+        if (!(Number(actual) < (expected as number))) return false;
+        break;
+      case "lte":
+        if (!(Number(actual) <= (expected as number))) return false;
+        break;
+      case "match":
+        if (!new RegExp(expected as string).test(String(actual))) return false;
+        break;
+    }
+  }
+
+  return true;
+}
+
+export function checkExpectValue(actual: unknown, expected: ExpectValue): boolean {
+  if (isPlainObject(expected) && Object.keys(expected).some((key) => OPERATOR_KEYS.has(key))) {
+    return applyOperator(actual, expected as ExpectOperator);
+  }
+  return applyOperator(actual, { equals: expected as Exclude<ExpectValue, ExpectOperator> });
+}
+
+export function evaluateJsonPath(json: unknown, path: string): unknown {
+  if (!path.startsWith("$.")) return undefined;
+
+  const segments = path.slice(2).split(".");
+  let current: unknown = json;
+
+  for (const seg of segments) {
+    const bracketMatch = /^(.+?)\[(\d+)\]$/.exec(seg);
+    if (bracketMatch) {
+      current = (current as Record<string, unknown>)?.[bracketMatch[1]!];
+      const idx = parseInt(bracketMatch[2]!, 10);
+      if (!Array.isArray(current) || idx >= current.length) return undefined;
+      current = current[idx];
+    } else {
+      if (current === null || current === undefined) return undefined;
+      current = (current as Record<string, unknown>)[seg];
+    }
+  }
+
+  return current;
+}

src/server/checker/expect/types.ts

@@ -0,0 +1,6 @@
+import type { CheckFailure } from "../types";
+
+export interface ExpectResult {
+  failure: CheckFailure | null;
+  matched: boolean;
+}

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)];
+  }
+}