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
2026-05-19 14:24:27 +08:00
parent 349896bd02
commit 7a635a0a9f
85 changed files with 4290 additions and 2028 deletions
--- a/openspec/specs/checker-runner-abstraction/spec.md
+++ b/openspec/specs/checker-runner-abstraction/spec.md
@@ -145,35 +145,31 @@
 - **THEN** store SHALL 对每个 target 调用对应 checker 的 `serialize()` 方法获取 `{ target, config }`

 ### Requirement: 共享 expect 断言函数
-系统 SHALL 在 `src/server/checker/expect/` 中提供可被多个 checker 复用的 expect 函数。checker 专用的 expect 函数 SHALL 保留在各自子包内。仅被单个 checker 使用的断言模块 SHALL 位于该 checker 目录内。
+系统 SHALL 在 `src/server/checker/expect/` 中提供可被多个 checker 复用的 expect 基础设施。共享基础设施 SHALL 包含 matcher、content rules、key-value expect、failure 构造和 ReDoS 校验。checker 专用的状态类断言 SHALL 保留在对应 checker 目录，或在多个 checker 复用时移动到共享模块。仅被单个 checker 使用且不属于通用 matcher/content/key-value 模型的断言模块 SHALL 位于该 checker 目录内。

-#### Scenario: 共享 duration 断言
- **WHEN** 任何 checker 需要校验执行耗时
- **THEN** SHALL 调用 `expect/duration.ts` 中的 `checkDuration(durationMs, maxDurationMs?)`，返回统一的 `ExpectResult`
+#### Scenario: 共享 ValueMatcher 断言
+- **WHEN** 任何 checker 需要对数字、字符串、布尔或 JSON value 执行 matcher 匹配
+- **THEN** SHALL 调用共享 matcher 工具执行 `equals`、`contains`、`regex`、`exists`、`empty`、`gt`、`gte`、`lt` 和 `lte` 语义

-#### Scenario: 共享 operator 断言
- **WHEN** 任何 checker 需要对值执行 operator 匹配
- **THEN** SHALL 调用 `expect/operator.ts` 中的 `applyOperator(actual, op)`
+#### Scenario: 共享 ContentRules 断言
+- **WHEN** HTTP body、LLM output、Cmd stdout/stderr、UDP response 或 TCP banner 需要执行返回内容校验
+- **THEN** SHALL 调用共享 content rules 工具，而不是在 checker 目录内复制 contains/regex/json/css/xpath 逻辑
+
+#### Scenario: 共享 KeyValueExpect 断言
+- **WHEN** HTTP 或 LLM checker 需要校验响应 headers，或 DB checker 需要校验 rows 中的列值
+- **THEN** SHALL 调用共享 key-value expect 工具，并按调用方规则决定 key 是否大小写敏感
+
+#### Scenario: 共享 regex ReDoS 校验
+- **WHEN** 任一 matcher 或 content rule 配置 `regex`
+- **THEN** SHALL 调用共享 ReDoS 校验工具在启动期拒绝危险正则

 #### Scenario: 共享 failure 构造
 - **WHEN** 任何 checker 需要构造 CheckFailure 对象
- **THEN** SHALL 调用 `expect/failure.ts` 中的 `errorFailure()` 或 `mismatchFailure()`
+- **THEN** SHALL 调用 `expect/failure.ts` 中的 `errorFailure()` 或 `mismatchFailure()`，并保留 actual 截断策略

-#### Scenario: HTTP body 断言位于 HTTP 目录
- **WHEN** HTTP checker 需要对响应体执行 contains/regex/json/css/xpath 规则校验
- **THEN** SHALL 调用 `runner/http/body.ts` 中的 `checkBodyExpect(body, rules)`
-
-#### Scenario: Cmd text 断言位于 Cmd 目录
- **WHEN** Cmd checker 需要对 stdout/stderr 执行文本规则校验
- **THEN** SHALL 调用 `runner/cmd/text.ts` 中的 `checkTextRules(text, rules, phase)`
-
-#### Scenario: HTTP 专用 expect
- **WHEN** HTTP checker 需要校验响应状态码和响应头
- **THEN** SHALL 调用 `runner/http/expect.ts` 中的 `checkStatus()` 和 `checkHeaders()`
-
-#### Scenario: Cmd 专用 expect
- **WHEN** Cmd checker 需要校验退出码
- **THEN** SHALL 调用 `runner/cmd/expect.ts` 中的 `checkExitCode()`
+#### Scenario: HTTP 专用 status 断言
+- **WHEN** HTTP 或 LLM checker 需要校验响应状态码
+- **THEN** SHALL 复用同一 status 断言函数，支持精确状态码和 `1xx` 到 `5xx` 范围模式

 ### Requirement: 超时控制由引擎注入 signal
 Checker 实现的 `execute()` MUST 使用 `ctx.signal` 感知超时，不得自行创建 `AbortController` 或 `setTimeout` 用于超时控制。Cmd checker 和 ping checker 可在 signal abort 时 `proc.kill()` 以确保子进程被终止。
--- a/openspec/specs/cmd-checker/spec.md
+++ b/openspec/specs/cmd-checker/spec.md
@@ -55,7 +55,7 @@
 - **THEN** 系统 MUST 停止收集输出并终止该检查，记录 `matched=false`，并在 failure 中写入输出超限信息

 ### Requirement: cmd expect 校验
-系统 SHALL 支持 cmd 专用 expect，包括 `exitCode`、`stdout` 和 `stderr`，并按 exitCode、duration、stdout、stderr 的阶段顺序快速失败。
+系统 SHALL 支持 cmd 专用 expect，包括 `exitCode`、`durationMs`、`stdout` 和 `stderr`，并按 exitCode、durationMs、stdout、stderr 的阶段顺序快速失败。`exitCode` SHALL 保持有限整数数组语义，未配置时默认 `[0]`。`durationMs` SHALL 使用共享 `ValueMatcher` 校验完整命令执行耗时。`stdout` 和 `stderr` MUST 使用共享 `ContentRules` 数组，直接 matcher 作用于对应输出文本，`json` extractor SHALL 支持对 JSON CLI 输出执行 JSONPath 断言。

 #### Scenario: 默认 exitCode 成功语义
 - **WHEN** cmd target 未显式配置 `expect.exitCode`
@@ -67,75 +67,67 @@

 #### Scenario: exitCode 不匹配快速失败
 - **WHEN** cmd target 配置 `expect.exitCode: [0]` 且实际 exit code 为 1
- **THEN** 系统 SHALL 立即返回 `matched=false`，并在 failure 中写入 phase=`exitCode`、path=`expect.exitCode`、expected 和 actual
+- **THEN** 系统 SHALL 立即返回 `matched=false`，并在 failure 中写入 phase=`exitCode`、path=`exitCode`、expected 和 actual
+
+#### Scenario: durationMs 校验
+- **WHEN** cmd target 配置 `expect.durationMs: {lte: 1000}` 且实际执行耗时为 1500ms
+- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `duration`

 #### Scenario: stdout 按配置顺序校验
- **WHEN** cmd target 配置 `expect.stdout` 为两个规则，第一条通过且第二条失败
- **THEN** 系统 SHALL 先执行第一条 stdout 规则，再执行第二条，并将 failure.path 指向失败的 `expect.stdout[1]`
+- **WHEN** cmd target 配置 `expect.stdout` 为两个 ContentRules，第一条通过且第二条失败
+- **THEN** 系统 SHALL 先执行第一条 stdout 规则，再执行第二条，并将 failure.path 指向失败的 `stdout[1]`

 #### Scenario: stderr 校验为空
 - **WHEN** cmd target 配置 `expect.stderr: [{empty: true}]` 且实际 stderr 为空字符串
 - **THEN** 系统 SHALL 判定 stderr 阶段通过

+#### Scenario: stdout JSON 输出校验
+- **WHEN** cmd target 输出 stdout 为 `{"status":"ok"}` 且配置 `expect.stdout: [{json: {path: "$.status", equals: "ok"}}]`
+- **THEN** 系统 SHALL 判定 stdout 阶段通过
+
 #### Scenario: stdout 失败后不检查 stderr
 - **WHEN** cmd target 同时配置 stdout 和 stderr 规则，且 stdout 规则失败
 - **THEN** 系统 SHALL 快速失败并 MUST NOT 继续执行 stderr 规则

 ### Requirement: cmd checker 启动期配置校验
-系统 SHALL 在启动期对 cmd checker 的配置契约和语义执行严格校验。Cmd target 的 `cmd` 分组 SHALL 只允许 `exec`、`args`、`cwd`、`env`、`maxOutputBytes` 字段；Cmd expect SHALL 只允许 `exitCode`、`maxDurationMs`、`stdout`、`stderr` 字段。未知字段、非法类型和不可编译正则 MUST 导致启动期配置错误。`expect.exitCode` SHALL 保留原有有限整数数组语义，不限制到特定平台范围。
+系统 SHALL 在启动期对 cmd checker 的配置契约和语义执行严格校验。Cmd target 的 `cmd` 分组 SHALL 只允许 `exec`、`args`、`cwd`、`env`、`maxOutputBytes` 字段。Cmd expect SHALL 只允许 `exitCode`、`durationMs`、`stdout`、`stderr` 字段。未知字段、非法类型、不可编译正则和 ReDoS 风险正则 MUST 导致启动期配置错误。`expect.exitCode` SHALL 保留原有有限整数数组语义，不限制到特定平台范围。

 #### Scenario: cmd args 类型非法
 - **WHEN** YAML 中 cmd target 配置 `cmd.args` 不是字符串数组
 - **THEN** 系统 SHALL 以配置错误退出，提示 cmd.args 格式错误

-#### Scenario: cmd cwd 类型非法
- **WHEN** YAML 中 cmd target 配置 `cmd.cwd` 不是字符串
- **THEN** 系统 SHALL 以配置错误退出，提示 cmd.cwd 必须为字符串
-
 #### Scenario: cmd env 值类型非法
 - **WHEN** YAML 中 cmd target 配置 `cmd.env`，且任一环境变量值不是字符串
 - **THEN** 系统 SHALL 以配置错误退出，提示 cmd.env 对应变量值必须为字符串

-#### Scenario: cmd maxOutputBytes 非法
- **WHEN** YAML 中 cmd target 或 defaults.cmd 配置的 `maxOutputBytes` 不是合法 size 值
- **THEN** 系统 SHALL 以配置错误退出，提示 maxOutputBytes 格式错误
-
-#### Scenario: cmd 分组未知字段失败
- **WHEN** YAML 中 cmd target 的 `cmd` 分组包含 `shell: true` 等未知字段
- **THEN** 系统 SHALL 以配置错误退出，提示 cmd 分组包含未知字段
-
 #### Scenario: cmd expect exitCode 类型非法
 - **WHEN** YAML 中 cmd target 配置 `expect.exitCode` 不是整数数组
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.exitCode 必须为整数数组

-#### Scenario: cmd expect exitCode 不限制平台范围
- **WHEN** YAML 中 cmd target 配置 `expect.exitCode` 为有限整数数组
- **THEN** 系统 SHALL 接受该数组，不额外限制为 0-255 等平台相关范围
+#### Scenario: cmd expect durationMs 非法
+- **WHEN** YAML 中 cmd target 配置 `expect.durationMs` 不是合法 `ValueMatcher`
+- **THEN** 系统 SHALL 以配置错误退出，提示 expect.durationMs 格式错误

-#### Scenario: cmd expect maxDurationMs 非法
- **WHEN** YAML 中 cmd target 配置 `expect.maxDurationMs` 不是非负有限数字
- **THEN** 系统 SHALL 以配置错误退出，提示 expect.maxDurationMs 格式错误
-
-#### Scenario: stdout 必须为规则数组
+#### Scenario: stdout 必须为 ContentRules 数组
 - **WHEN** YAML 中 cmd target 配置 `expect.stdout` 但其值不是数组
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.stdout 必须为数组

-#### Scenario: stderr 必须为规则数组
+#### Scenario: stderr 必须为 ContentRules 数组
 - **WHEN** YAML 中 cmd target 配置 `expect.stderr` 但其值不是数组
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.stderr 必须为数组

 #### Scenario: stdout text rule 空对象非法
 - **WHEN** YAML 中 cmd target 配置 `expect.stdout: [{}]`
- **THEN** 系统 SHALL 以配置错误退出，提示 stdout 规则必须包含至少一个合法 operator
+- **THEN** 系统 SHALL 以配置错误退出，提示 stdout 规则必须包含至少一个合法 matcher 或 extractor

 #### Scenario: stderr text rule 未知字段非法
 - **WHEN** YAML 中 cmd target 配置 `expect.stderr: [{foo: "bar"}]`
- **THEN** 系统 SHALL 以配置错误退出，提示 stderr 规则包含未知 operator
+- **THEN** 系统 SHALL 以配置错误退出，提示 stderr 规则包含未知 matcher 或未知 extractor

-#### Scenario: stdout match 正则非法
- **WHEN** YAML 中 cmd target 配置 `expect.stdout: [{match: "[invalid"}]`
+#### Scenario: stdout regex 正则非法
+- **WHEN** YAML 中 cmd target 配置 `expect.stdout: [{regex: "[invalid"}]`
 - **THEN** 系统 SHALL 在启动期配置校验失败，而不是延迟到运行期抛错

 #### Scenario: cmd expect 未知字段失败
- **WHEN** YAML 中 cmd target 的 expect 包含 `status: [200]` 或其他非 cmd expect 字段
+- **WHEN** YAML 中 cmd target 的 expect 包含 `status: [200]`、`maxDurationMs: 1000` 或其他非 cmd expect 字段
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect 包含未知字段
--- a/openspec/specs/db-checker/spec.md
+++ b/openspec/specs/db-checker/spec.md
@@ -75,11 +75,11 @@
 - **THEN** 系统 SHALL 立即关闭数据库连接

 ### Requirement: db expect 校验
-系统 SHALL 支持 db 专用 expect，包括 `maxDurationMs`、`rowCount` 和 `rows`，按 duration、rowCount、rows 的阶段顺序快速失败。
+系统 SHALL 支持 db 专用 expect，包括 `durationMs`、`rowCount`、`rows` 和 `result`，按 durationMs、rowCount、rows、result 的阶段顺序快速失败。`durationMs` 和 `rowCount` SHALL 使用共享 `ValueMatcher`。`rows` SHALL 保留按行索引匹配列值的语义，类型为 `Array<KeyValueExpect>`（外层数组按行索引，内层每个元素为一个 `KeyValueExpect` 表达该行的列值断言），每个行规则中列值字面量等价于 `{equals: <literal>}`。`result` MUST 使用共享 `ContentRules` 数组，对查询结果对象 `{ rows, rowCount }` 执行断言。

-#### Scenario: maxDurationMs 校验
- **WHEN** db target 配置 `expect.maxDurationMs: 3000` 且实际执行耗时 4000ms
- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `"duration"`
+#### Scenario: durationMs 校验
+- **WHEN** db target 配置 `expect.durationMs: {lte: 3000}` 且实际执行耗时 4000ms
+- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `duration`

 #### Scenario: rowCount 校验通过
 - **WHEN** db target 配置 `expect.rowCount: { gte: 1 }` 且查询返回 5 行
@@ -87,13 +87,13 @@

 #### Scenario: rowCount 校验失败
 - **WHEN** db target 配置 `expect.rowCount: { gte: 1 }` 且查询返回 0 行
- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `"rowCount"`，path 为 `"rowCount"`，expected 为 `{ gte: 1 }`，actual 为 0
+- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `rowCount`，path 为 `rowCount`，expected 为 `{ gte: 1 }`，actual 为 0

-#### Scenario: rows 按索引匹配列值（operator 形式）
+#### Scenario: rows 按索引匹配列值 matcher 形式
 - **WHEN** db target 配置 `expect.rows: [{ cnt: { gte: 100 } }]` 且查询首行 cnt 列值为 50
- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `"row"`，path 为 `"rows[0].cnt"`
+- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `row`，path 为 `rows[0].cnt`

-#### Scenario: rows 按索引匹配列值（字面量形式）
+#### Scenario: rows 按索引匹配列值字面量形式
 - **WHEN** db target 配置 `expect.rows: [{ status: "active" }]` 且查询首行 status 列值为 `"active"`
 - **THEN** 系统 SHALL 判定该行该列通过（字面量等价于 `{ equals: "active" }`）

@@ -103,25 +103,33 @@

 #### Scenario: rows 结果行数不足
 - **WHEN** db target 配置 `expect.rows` 包含 3 个元素但查询仅返回 2 行
- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `"row"`，message 说明结果行数不足
+- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `row`，message 说明结果行数不足

-#### Scenario: 无 query 时 expect 被忽略
- **WHEN** db target 未配置 `db.query` 但配置了 `expect.rowCount`
- **THEN** 系统 SHALL 忽略 expect 中的 rowCount 和 rows 断言（仅 maxDurationMs 生效）
+#### Scenario: result JSONPath 校验
+- **WHEN** db target 查询返回首行 `{status: "active"}` 且配置 `expect.result: [{json: {path: "$.rows[0].status", equals: "active"}}]`
+- **THEN** 系统 SHALL 基于 `{rows, rowCount}` 结果对象执行 JSONPath，并判定 result 阶段通过
+
+#### Scenario: result rowCount 校验
+- **WHEN** db target 查询返回 2 行且配置 `expect.result: [{json: {path: "$.rowCount", equals: 2}}]`
+- **THEN** 系统 SHALL 判定 result 阶段通过
+
+#### Scenario: 无 query 时结果类 expect 被忽略
+- **WHEN** db target 未配置 `db.query` 但配置了 `expect.rowCount`、`expect.rows` 或 `expect.result`
+- **THEN** 系统 SHALL 忽略这些查询结果断言（仅 `durationMs` 生效）

 #### Scenario: 快速失败顺序
- **WHEN** db target 同时配置 maxDurationMs、rowCount 和 rows
- **THEN** 系统 SHALL 按 duration → rowCount → rows 顺序校验，任一阶段失败立即返回
+- **WHEN** db target 同时配置 durationMs、rowCount、rows 和 result
+- **THEN** 系统 SHALL 按 durationMs → rowCount → rows → result 顺序校验，任一阶段失败立即返回

 ### Requirement: db checker 启动期配置校验
-系统 SHALL 在启动期对 db checker 的配置契约和语义执行严格校验。Db target 的 `db` 分组 SHALL 只允许 `url` 和 `query` 字段。Db expect SHALL 只允许 `maxDurationMs`、`rowCount` 和 `rows` 字段。
+系统 SHALL 在启动期对 db checker 的配置契约和语义执行严格校验。Db target 的 `db` 分组 SHALL 只允许 `url` 和 `query` 字段。Db expect SHALL 只允许 `durationMs`、`rowCount`、`rows` 和 `result` 字段。未知字段、非法 matcher、非法 ContentRules、非法 regex 和 ReDoS 风险正则 MUST 导致启动期配置错误。

-#### Scenario: db expect maxDurationMs 非法
- **WHEN** YAML 中 db target 配置 `expect.maxDurationMs` 不是非负有限数字
- **THEN** 系统 SHALL 以配置错误退出，提示 expect.maxDurationMs 格式错误
+#### Scenario: db expect durationMs 非法
+- **WHEN** YAML 中 db target 配置 `expect.durationMs` 不是合法 `ValueMatcher`
+- **THEN** 系统 SHALL 以配置错误退出，提示 expect.durationMs 格式错误

 #### Scenario: db expect rowCount 非法
- **WHEN** YAML 中 db target 配置 `expect.rowCount` 不是合法的 operator 对象
+- **WHEN** YAML 中 db target 配置 `expect.rowCount` 不是合法 `ValueMatcher`
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.rowCount 格式错误

 #### Scenario: db expect rows 非法
@@ -129,13 +137,17 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.rows 必须为对象数组

 #### Scenario: db expect rows 元素列值非法
- **WHEN** YAML 中 db target 配置 `expect.rows: [{ cnt: { foo: 1 } }]`，其中 foo 不是合法 operator
- **THEN** 系统 SHALL 以配置错误退出，提示 rows 中包含未知 operator
+- **WHEN** YAML 中 db target 配置 `expect.rows: [{ cnt: { foo: 1 } }]`，其中 foo 不是合法 matcher
+- **THEN** 系统 SHALL 以配置错误退出，提示 rows 中包含未知 matcher
+
+#### Scenario: db expect result 非法
+- **WHEN** YAML 中 db target 配置 `expect.result` 不是合法 ContentRules 数组
+- **THEN** 系统 SHALL 以配置错误退出，提示 expect.result 格式错误

 #### Scenario: db expect 未知字段失败
- **WHEN** YAML 中 db target 的 expect 包含 `status: [200]` 或其他非 db expect 字段
+- **WHEN** YAML 中 db target 的 expect 包含 `status: [200]`、`maxDurationMs: 1000` 或其他非 db expect 字段
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect 包含未知字段

-#### Scenario: db expect rows 中 match 正则非法
- **WHEN** YAML 中 db target 配置 `expect.rows: [{ name: { match: "[invalid" } }]`
+#### Scenario: db expect rows 中 regex 正则非法
+- **WHEN** YAML 中 db target 配置 `expect.rows: [{ name: { regex: "[invalid" } }]`
 - **THEN** 系统 SHALL 在启动期配置校验失败，而不是延迟到运行期抛错
--- a/openspec/specs/expect-body-checkers/spec.md
+++ b/openspec/specs/expect-body-checkers/spec.md
@@ -5,35 +5,23 @@
 ## Requirements

 ### Requirement: 响应体多种校验方法
-系统 SHALL 支持对 HTTP 响应体进行五种可组合的校验方法：contains（子串）、regex（正则）、json（JSONPath）、css（CSS 选择器）、xpath（XPath）。这些方法 MUST 配置在 `expect.body` 有序数组中。
+系统 SHALL 支持通过共享 `ContentRules` 对 HTTP 响应体进行有序内容校验。`expect.body` MUST 为规则数组。每个规则 SHALL 为直接 `ValueMatcher`，或 `json`、`css`、`xpath` extractor 规则之一。直接 matcher SHALL 作用于完整响应体文本。`json` SHALL 解析响应体为 JSON 并用 JSONPath 子集提取值。`css` SHALL 使用 CSS selector 从 HTML 中提取元素文本或属性。`xpath` SHALL 使用 XPath 从 XML/HTML 中提取节点值。Extractor 未配置 matcher 时 SHALL 等价于 `exists: true`。

 #### Scenario: contains 子串匹配
 - **WHEN** HTTP target 配置 `expect.body: [{contains: "healthy"}]`，且响应体包含 `"healthy"`
 - **THEN** 系统 SHALL 判定该 body 规则通过

-#### Scenario: contains 不匹配
- **WHEN** HTTP target 配置 `expect.body: [{contains: "healthy"}]`，且响应体不包含该文本
- **THEN** 系统 SHALL 判定 matched 为 false，并记录该规则的 failure.path
-
 #### Scenario: regex 正则匹配
 - **WHEN** HTTP target 配置 `expect.body: [{regex: '"status"\\s*:\\s*"ok"'}]`，且响应体匹配该正则
 - **THEN** 系统 SHALL 判定该 body 规则通过

-#### Scenario: regex 不匹配
- **WHEN** HTTP target 配置 regex body 规则，且响应体不匹配该正则
- **THEN** 系统 SHALL 判定 matched 为 false，并记录该规则的 failure.path
-
 #### Scenario: json JSONPath 等值匹配
 - **WHEN** HTTP target 配置 `expect.body: [{json: {path: "$.status", equals: "ok"}}]`，且响应 JSON 中 `$.status` 值为 `"ok"`
 - **THEN** 系统 SHALL 判定该 body 规则通过

-#### Scenario: json JSONPath 值不匹配
- **WHEN** HTTP target 配置 json body 规则，且提取值不符合期望
- **THEN** 系统 SHALL 判定 matched 为 false，并记录包含 JSONPath 的 failure.path
-
-#### Scenario: json 解析失败
- **WHEN** HTTP target 配置了 json body 规则但响应体不是合法 JSON
- **THEN** 系统 SHALL 判定 matched 为 false
+#### Scenario: json JSONPath 存在性匹配
+- **WHEN** HTTP target 配置 `expect.body: [{json: {path: "$.status"}}]`，且响应 JSON 中存在 `$.status`
+- **THEN** 系统 SHALL 将该规则按 `exists: true` 语义判定通过

 #### Scenario: css 选择器匹配
 - **WHEN** HTTP target 配置 `expect.body: [{css: {selector: "div#health", equals: "OK"}}]`，且 HTML 中存在 `div#health` 元素文本为 `"OK"`
@@ -43,20 +31,16 @@
 - **WHEN** HTTP target 配置 css 规则带 `attr: "content"` 用于提取属性，且属性值匹配期望
 - **THEN** 系统 SHALL 判定该 body 规则通过

-#### Scenario: css 选择器无匹配元素
- **WHEN** HTTP target 配置了 css 选择器但 HTML 中无匹配元素
- **THEN** 系统 SHALL 判定 matched 为 false
-
 #### Scenario: xpath 表达式匹配
 - **WHEN** HTTP target 配置 `expect.body: [{xpath: {path: "/root/status/text()", equals: "ok"}}]`，且 XML 中 `/root/status` 节点文本为 `"ok"`
 - **THEN** 系统 SHALL 判定该 body 规则通过

-#### Scenario: xpath 表达式无匹配节点
- **WHEN** HTTP target 配置了 xpath 表达式但 XML 中无匹配节点
+#### Scenario: 提取器无匹配目标失败
+- **WHEN** HTTP target 配置了 json、css 或 xpath 规则且对应路径、元素或节点不存在，并且规则未配置 `exists: false`
 - **THEN** 系统 SHALL 判定 matched 为 false

 ### Requirement: 多种 body 校验方法 AND 组合
-系统 SHALL 支持在 `expect.body` 数组中同时配置多种 body 校验方法，所有方法均通过时 matched 方为 true。
+系统 SHALL 支持在 `expect.body` 数组中同时配置多条内容规则，所有规则均通过时 matched 方为 true。系统 SHALL 按数组顺序执行规则，任一规则失败后 MUST NOT 继续执行后续规则。

 #### Scenario: 多种方法全部通过
 - **WHEN** HTTP target 的 `expect.body` 数组依次配置 contains、json、regex，且全部通过
@@ -66,54 +50,50 @@
 - **WHEN** HTTP target 的 `expect.body` 数组第一条 contains 不通过，后续还有 json 规则
 - **THEN** 系统 SHALL 判定 matched 为 false，且不再检查后续 json 规则

+#### Scenario: 直接 matcher 多字段组合
+- **WHEN** HTTP target 配置 `expect.body: [{contains: "ok", regex: "status"}]`，且响应体同时满足 contains 和 regex
+- **THEN** 系统 SHALL 判定该规则通过
+
 ### Requirement: 操作符系统
-系统 SHALL 支持对提取值和文本值使用以下操作符进行比较：equals（默认等值）、contains（子串包含）、match（正则匹配）、empty（空值判断）、exists（存在性判断）、gte/lte/gt/lt（数值比较）。
+系统 SHALL 支持通过共享 `ValueMatcher` 对提取值和文本值进行比较：`equals`（深度等值）、`contains`（子串包含）、`regex`（正则匹配）、`empty`（空值判断）、`exists`（存在性判断）、`gte`/`lte`/`gt`/`lt`（数值比较）。系统 MUST NOT 支持旧 `match` 字段。

-#### Scenario: 标量值隐式 equals
- **WHEN** 配置的期望值为标量（字符串/数字/布尔/null），如 `equals: "ok"`
- **THEN** 系统 SHALL 使用 equals 操作符，对实际值做严格相等比较
+#### Scenario: equals 匹配 JSON value
+- **WHEN** 配置 `{equals: {status: "ok"}}`，且实际值为相同 JSON object
+- **THEN** 系统 SHALL 使用深度相等判定通过

-#### Scenario: 显式 contains 操作符
- **WHEN** 配置 `{contains: "success"}`，且实际值包含 `"success"`
+#### Scenario: 显式 contains matcher
+- **WHEN** 配置 `{contains: "success"}`，且实际值字符串化后包含 `"success"`
 - **THEN** 系统 SHALL 判定该规则通过

-#### Scenario: 显式 match 操作符
- **WHEN** 配置 `{match: '\\d+\\.\\d+\\.\\d+'}`，且实际值匹配该正则
+#### Scenario: 显式 regex matcher
+- **WHEN** 配置 `{regex: '\\d+\\.\\d+\\.\\d+'}`，且实际值字符串化后匹配该正则
 - **THEN** 系统 SHALL 判定该规则通过

-#### Scenario: empty 操作符判断为空
+#### Scenario: empty matcher 判断为空
 - **WHEN** 配置 `{empty: true}`，且实际值为空数组 `[]`
 - **THEN** 系统 SHALL 判定该规则通过

-#### Scenario: empty 操作符判断非空
- **WHEN** 配置 `{empty: false}`，且实际值为 `[1, 2]`
+#### Scenario: exists matcher 判断不存在
+- **WHEN** 配置 `{exists: false}`，且实际值为 `undefined`
 - **THEN** 系统 SHALL 判定该规则通过

-#### Scenario: exists 操作符判断存在
- **WHEN** 配置 `{exists: false}`，且实际值不存在
- **THEN** 系统 SHALL 判定该规则通过
-
-#### Scenario: gte 数值比较
- **WHEN** 配置 `{gte: 10}`，且实际值为 `15`（数字）
- **THEN** 系统 SHALL 判定该规则通过
-
-#### Scenario: gt/lt 数值比较
+#### Scenario: 数值比较 matcher
 - **WHEN** 配置 `{gt: 0, lt: 1000}`，且实际值为 `500`
- **THEN** 系统 SHALL 对同一字段进行多操作符复合比较，全部通过则该规则通过
+- **THEN** 系统 SHALL 对同一字段进行多 matcher 复合比较，全部通过则该规则通过

 ### Requirement: 响应头校验
-系统 SHALL 支持通过 `expect.headers` 配置对 HTTP 响应头进行键值规则校验，header 名称匹配 MUST 不区分大小写。
+系统 SHALL 支持通过共享 `KeyValueExpect` 配置 `expect.headers` 对 HTTP 响应头进行键值规则校验，header 名称匹配 MUST 不区分大小写。header 期望值 MAY 为字符串字面量或 `ValueMatcher`。字符串字面量 SHALL 等价于 `{equals: <value>}`。

-#### Scenario: 响应头匹配
- **WHEN** HTTP target 配置 `expect.headers: {"Content-Type": {contains: "application/json"}}`，且响应包含该 header 且值匹配
+#### Scenario: 响应头字面量匹配
+- **WHEN** HTTP target 配置 `expect.headers: {"Content-Type": "application/json"}`，且响应包含该 header 且值精确匹配
 - **THEN** 系统 SHALL 判定 headers 阶段通过

-#### Scenario: 响应头不匹配
- **WHEN** HTTP target 配置 `expect.headers: {"Content-Type": {equals: "application/json"}}`，且响应 header 值为 `"text/html"`
- **THEN** 系统 SHALL 判定 matched 为 false
+#### Scenario: 响应头 matcher 匹配
+- **WHEN** HTTP target 配置 `expect.headers: {"Content-Type": {contains: "application/json"}}`，且响应 header 值包含该文本
+- **THEN** 系统 SHALL 判定 headers 阶段通过

 #### Scenario: 响应头缺失
- **WHEN** HTTP target 配置了某个 header 但响应中不存在该 header
+- **WHEN** HTTP target 配置了某个 header 但响应中不存在该 header，且未配置 `exists: false`
 - **THEN** 系统 SHALL 判定 matched 为 false

 ### Requirement: 结构化 expect 失败信息
@@ -175,79 +155,43 @@
 - **THEN** 系统 SHALL 在启动期配置校验失败

 ### Requirement: HTTP expect 规则启动期校验
-系统 SHALL 在启动期校验 HTTP expect 中已支持字段的类型、格式、未知字段和可编译表达式。HTTP expect、body rule、json/css/xpath rule 和 operator 对象中的未知字段 SHALL 导致启动期配置失败。每个 body rule 对象 MUST 恰好包含 contains、regex、json、css、xpath 中的一种规则类型。纯 operator 对象 MUST 至少包含一个已知 operator；body 提取规则可以不配置 operator，并以路径、元素或节点存在作为通过语义。`equals` operator SHALL 支持任意 JSON value，包括数组和对象。系统 SHALL 在启动期对 regex body 规则和 match operator 的正则表达式进行 ReDoS 安全检测，含有嵌套量词等危险模式的正则 SHALL 导致启动期配置失败。
+系统 SHALL 在启动期校验 HTTP expect 中已支持字段的类型、格式、未知字段和可编译表达式。HTTP expect SHALL 只允许 `status`、`headers`、`body` 和 `durationMs` 字段。`expect.body` MUST 为 `ContentRules` 数组。直接 `ValueMatcher` 对象 MUST 至少包含一个合法 matcher。Extractor 规则 MUST 只包含 `json`、`css`、`xpath` 中的一种 extractor。Extractor 内部可以不配置 matcher，并 SHALL 在运行期以存在性作为通过语义。`equals` matcher SHALL 支持任意 JSON value，包括数组和对象。系统 SHALL 在启动期对所有 `regex` 执行静态 ReDoS 检测。

 #### Scenario: body rule 使用 regex 字段
 - **WHEN** HTTP target 配置 `expect.body: [{regex: "ok|healthy"}]` 且 regex 可编译且无 ReDoS 风险
- **THEN** 系统 SHALL 接受该配置，并在运行期按 regex body 规则匹配响应体
+- **THEN** 系统 SHALL 接受该配置，并在运行期按 regex 规则匹配响应体

 #### Scenario: body rule 不支持 match 字段
- **WHEN** HTTP target 配置 `expect.body: [{match: "ok"}]` 且该规则没有 contains、regex、json、css、xpath 任一支持字段
+- **WHEN** HTTP target 配置 `expect.body: [{match: "ok"}]`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示 `match` 是未知字段或不支持字段
+
+#### Scenario: body rule 多 extractor 非法
+- **WHEN** HTTP target 的同一条 body rule 同时配置 `json` 和 `css`
 - **THEN** 系统 SHALL 在启动期配置校验失败

-#### Scenario: body rule 忽略未知字段 → body rule 未知字段启动失败
- **WHEN** HTTP target 配置 `expect.body: [{contains: "ok", note: "ignored"}]`
- **THEN** 系统 SHALL 在启动期配置校验失败，提示 `note` 是未知字段
-
-#### Scenario: body rule 多支持字段非法
- **WHEN** HTTP target 的同一条 body rule 同时配置 contains 和 regex
+#### Scenario: matcher regex 正则非法
+- **WHEN** HTTP target 的 expect.headers、body 直接 matcher 或 extractor 内部 matcher 配置了不可编译的 regex
 - **THEN** 系统 SHALL 在启动期配置校验失败

-#### Scenario: operator match 正则非法
- **WHEN** HTTP target 的 expect.headers、json、css 或 xpath operator 配置了不可编译的 match 正则
+#### Scenario: matcher 数值比较类型非法
+- **WHEN** HTTP target 的 matcher 配置 gt、gte、lt 或 lte，且对应值不是有限数字
 - **THEN** 系统 SHALL 在启动期配置校验失败

-#### Scenario: operator 数值比较类型非法
- **WHEN** HTTP target 的 expect operator 配置 gt、gte、lt 或 lte，且对应值不是有限数字
- **THEN** 系统 SHALL 在启动期配置校验失败
-
-#### Scenario: operator 布尔类型非法
- **WHEN** HTTP target 的 expect operator 配置 empty 或 exists，且对应值不是布尔值
+#### Scenario: matcher 布尔类型非法
+- **WHEN** HTTP target 的 matcher 配置 empty 或 exists，且对应值不是布尔值
 - **THEN** 系统 SHALL 在启动期配置校验失败

 #### Scenario: JSONPath 子集非法
 - **WHEN** HTTP target 的 json body rule path 不符合系统支持的 JSONPath 子集
 - **THEN** 系统 SHALL 在启动期配置校验失败

-#### Scenario: operator 未知字段非法
- **WHEN** HTTP target 的 expect operator 配置了 `foo: "bar"` 等未知 operator 字段
+#### Scenario: matcher 未知字段非法
+- **WHEN** HTTP target 的 matcher 配置了 `foo: "bar"` 等未知字段
 - **THEN** 系统 SHALL 在启动期配置校验失败

-#### Scenario: equals 支持对象
- **WHEN** HTTP target 配置 `expect.body: [{json: {path: "$.payload", equals: {status: "ok"}}}]`
- **THEN** 系统 SHALL 接受该配置，并在运行期使用深度相等比较提取值和对象期望
-
-#### Scenario: equals 支持数组
- **WHEN** HTTP target 配置 `expect.body: [{json: {path: "$.items", equals: ["a", "b"]}}]`
- **THEN** 系统 SHALL 接受该配置，并在运行期使用深度相等比较提取值和数组期望
-
-#### Scenario: 纯 operator 对象不能为空
- **WHEN** HTTP target 的 `expect.headers` 中某个 header 期望配置为空对象 `{}`
- **THEN** 系统 SHALL 在启动期配置校验失败，要求显式配置至少一个 operator
-
-#### Scenario: json rule 允许存在性语义
- **WHEN** HTTP target 配置 `expect.body: [{json: {path: "$.status"}}]`
- **THEN** 系统 SHALL 接受该配置，并在运行期以 JSONPath 值存在作为通过语义
-
-#### Scenario: css rule 未知字段非法
- **WHEN** HTTP target 配置 `expect.body: [{css: {selector: "h1", unknown: true}}]`
- **THEN** 系统 SHALL 在启动期配置校验失败，提示未知字段
-
-#### Scenario: xpath rule 未知字段非法
- **WHEN** HTTP target 配置 `expect.body: [{xpath: {path: "/html/body", unknown: true}}]`
- **THEN** 系统 SHALL 在启动期配置校验失败，提示未知字段
-
-#### Scenario: regex body 规则含嵌套量词启动失败
- **WHEN** HTTP target 配置 `expect.body: [{regex: "(a+)+$"}]`
- **THEN** 系统 SHALL 在启动期配置校验失败，提示正则存在 ReDoS 风险
-
-#### Scenario: match operator 含嵌套量词启动失败
- **WHEN** HTTP target 的 expect operator 配置 `{match: "(\\d+)*x"}`
- **THEN** 系统 SHALL 在启动期配置校验失败，提示正则存在 ReDoS 风险
-
-#### Scenario: 安全正则通过校验
- **WHEN** HTTP target 配置 `expect.body: [{regex: "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"}]`
- **THEN** 系统 SHALL 接受该配置（无嵌套量词，无 ReDoS 风险）
+#### Scenario: durationMs matcher 非法
+- **WHEN** HTTP target 配置 `expect.durationMs` 不是合法 `ValueMatcher` 或其中数值 matcher 不是有限数字
+- **THEN** 系统 SHALL 在启动期配置校验失败

 ### Requirement: HTTP body 运行期失败结构化
 系统 SHALL 将 HTTP body 运行期失败记录为结构化 CheckFailure，并保留与具体规则相关的 phase 和 path。响应内容不符合配置 SHALL 记录为 mismatch；响应内容无法按配置解析或解码 SHALL 记录为 error。
--- a/openspec/specs/expect-rule-system/spec.md
+++ b/openspec/specs/expect-rule-system/spec.md
@@ -0,0 +1,193 @@
+## Purpose
+
+定义共享 expect 断言规则系统的核心概念和基础设施：ValueMatcher 统一匹配器、ContentRules 内容规则数组、KeyValueExpect 键值规则、以及相关的启动期校验和失败路径规范。
+
+## Requirements
+
+### Requirement: ValueMatcher 统一匹配器
+系统 SHALL 提供共享 `ValueMatcher` 作为所有非状态类 expect 的基础匹配结构。`ValueMatcher` SHALL 支持 `equals`、`contains`、`regex`、`exists`、`empty`、`gt`、`gte`、`lt` 和 `lte` 字段。`equals` MUST 支持任意 JSON value，并使用深度相等比较。`contains` 和 `regex` SHALL 将实际值转换为字符串后匹配。`gt`、`gte`、`lt` 和 `lte` SHALL 将实际值转换为有限数字后比较，无法转换为有限数字时 SHALL 判定不匹配。一个 `ValueMatcher` 对象包含多个 matcher 字段时，系统 SHALL 要求全部 matcher 均通过。
+
+#### Scenario: equals 匹配对象
+- **WHEN** 实际值为 `{status: "ok", count: 1}` 且 matcher 为 `{equals: {status: "ok", count: 1}}`
+- **THEN** 系统 SHALL 使用深度相等判定该 matcher 通过
+
+#### Scenario: contains 字符串化匹配
+- **WHEN** 实际值为 `"service ready"` 且 matcher 为 `{contains: "ready"}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+#### Scenario: 数字范围组合匹配
+- **WHEN** 实际值为 `50` 且 matcher 为 `{gte: 0, lte: 100}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+#### Scenario: 多 matcher 快速失败
+- **WHEN** 实际值为 `"healthy"` 且 matcher 为 `{contains: "health", regex: "^ready$"}`
+- **THEN** 系统 SHALL 在任一 matcher 不满足时判定该 matcher 对象不通过
+
+### Requirement: ValueMatcher 启动期校验
+系统 SHALL 在启动期对所有 `ValueMatcher` 对象执行严格的类型和语义校验。`contains` MUST 为 string。`equals` MAY 为任意 JSON value。`exists` 和 `empty` MUST 为 boolean。`gt`、`gte`、`lt` 和 `lte` MUST 为有限数字（`Number.isFinite`）。`regex` MUST 为可编译的 string pattern，并通过 ReDoS 风险校验。ValueMatcher 对象 MUST 至少包含一个合法 matcher 字段，空对象 `{}` SHALL 导致启动期配置错误。ValueMatcher 对象 MUST NOT 包含未知字段，任何不属于 `equals`、`contains`、`regex`、`exists`、`empty`、`gt`、`gte`、`lt`、`lte` 的字段 SHALL 导致启动期配置错误。
+
+#### Scenario: 空 matcher 对象被拒绝
+- **WHEN** YAML 配置中任一 matcher 对象为空 `{}`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示 matcher 必须包含至少一个合法字段
+
+#### Scenario: 未知 matcher 字段被拒绝
+- **WHEN** YAML 配置中任一 matcher 对象包含 `foo: "bar"` 等未知字段
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示该字段未知
+
+#### Scenario: 数值 matcher 非有限数字被拒绝
+- **WHEN** YAML 配置中任一 matcher 的 `gt`、`gte`、`lt` 或 `lte` 值为 `NaN`、`Infinity` 或非数字类型
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示数值 matcher 必须为有限数字
+
+#### Scenario: 布尔 matcher 非布尔值被拒绝
+- **WHEN** YAML 配置中任一 matcher 的 `exists` 或 `empty` 值不是布尔类型
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示该字段必须为布尔值
+
+### Requirement: empty matcher 语义
+`empty: true` SHALL 在以下情况判定通过：实际值为 `null`、`undefined`、空字符串 `""`、空数组 `[]` 或空对象 `{}`。`empty: false` SHALL 在以上条件均不满足时判定通过。数字 `0` 和布尔 `false` SHALL NOT 被视为 empty。
+
+#### Scenario: null 视为 empty
+- **WHEN** 实际值为 `null` 且 matcher 为 `{empty: true}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+#### Scenario: 空字符串视为 empty
+- **WHEN** 实际值为 `""` 且 matcher 为 `{empty: true}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+#### Scenario: 空数组视为 empty
+- **WHEN** 实际值为 `[]` 且 matcher 为 `{empty: true}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+#### Scenario: 空对象视为 empty
+- **WHEN** 实际值为 `{}` 且 matcher 为 `{empty: true}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+#### Scenario: 数字 0 不视为 empty
+- **WHEN** 实际值为 `0` 且 matcher 为 `{empty: true}`
+- **THEN** 系统 SHALL 判定该 matcher 不通过
+
+#### Scenario: 布尔 false 不视为 empty
+- **WHEN** 实际值为 `false` 且 matcher 为 `{empty: true}`
+- **THEN** 系统 SHALL 判定该 matcher 不通过
+
+### Requirement: exists 与其他 matcher 的组合语义
+当 `ValueMatcher` 同时包含 `exists: false` 和其他非存在性 matcher（如 `contains`、`regex`、`equals` 等）时，系统 SHALL 在启动期配置校验失败，提示 `exists: false` 不能与其他 matcher 组合使用。`exists: true` MAY 与其他 matcher 组合，语义为先确认存在再执行其他 matcher。
+
+#### Scenario: exists false 与 contains 组合被拒绝
+- **WHEN** YAML 配置中 matcher 为 `{exists: false, contains: "foo"}`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示 `exists: false` 不能与其他 matcher 组合
+
+#### Scenario: exists true 与 contains 组合允许
+- **WHEN** 实际值为 `"hello foo"` 且 matcher 为 `{exists: true, contains: "foo"}`
+- **THEN** 系统 SHALL 判定该 matcher 通过
+
+### Requirement: regex 字段语义
+系统 SHALL 使用 `regex` 作为唯一正则 matcher 字段。`regex` 值 MUST 为可编译的字符串 pattern。运行期 SHALL 固定使用无 flags 的 `new RegExp(pattern).test(String(actual))` 执行匹配。系统 MUST NOT 支持旧 `match` 字段。系统 SHALL 在启动期对所有 `regex` pattern 执行可编译校验和 ReDoS 风险校验。
+
+#### Scenario: regex 任意位置匹配
+- **WHEN** 实际值为 `"api status ok"` 且 matcher 为 `{regex: "status"}`
+- **THEN** 系统 SHALL 判定该 matcher 通过，因为无 flags 的 JavaScript 正则仍会搜索整个字符串中的第一次匹配
+
+#### Scenario: regex 完整匹配由用户声明锚点
+- **WHEN** 实际值为 `"OK\n"` 且 matcher 为 `{regex: "^OK$"}`
+- **THEN** 系统 SHALL 判定该 matcher 不通过，因为系统 MUST NOT 默认启用 multiline flags
+
+#### Scenario: match 字段启动失败
+- **WHEN** YAML 配置中任一 matcher 对象包含 `match: "ok"`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示 `match` 是未知字段或不支持字段
+
+#### Scenario: regex ReDoS 风险启动失败
+- **WHEN** YAML 配置中任一 `regex` 为 `"(a+)+$"`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示正则存在 ReDoS 风险
+
+### Requirement: ContentRules 内容规则数组
+系统 SHALL 提供共享 `ContentRules` 表达返回内容断言。`ContentRules` MUST 为有序数组，数组项 SHALL 为直接 `ValueMatcher`，或 `json`、`css`、`xpath` 三类 extractor 规则之一。系统 SHALL 按数组顺序执行全部规则，任一规则失败时 SHALL 立即停止并返回该规则的 failure。系统 MUST NOT 支持内容字段的非数组对象快捷写法。
+
+#### Scenario: 直接 matcher 内容规则
+- **WHEN** 内容字段配置 `[{contains: "ready"}, {regex: "listening on \\d+"}]` 且原始内容同时满足两条规则
+- **THEN** 系统 SHALL 判定该内容字段通过
+
+#### Scenario: 内容规则数组快速失败
+- **WHEN** 内容字段配置三条规则且第二条规则失败
+- **THEN** 系统 SHALL 返回第二条规则的 failure，并 MUST NOT 执行第三条规则
+
+#### Scenario: 内容字段必须为数组
+- **WHEN** YAML 中内容字段配置为 `{contains: "ok"}` 而不是数组
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示该内容字段必须为规则数组
+
+### Requirement: ContentRule 互斥性约束
+一条 `ContentRule` MUST 为直接 `ValueMatcher` 或恰好一个 extractor（`json`、`css`、`xpath` 之一）。系统 MUST NOT 允许同一条规则同时包含多个 extractor。直接 `ValueMatcher` 规则 MUST NOT 包含 `json`、`css`、`xpath` 字段。系统 SHALL 在启动期对违反互斥性的规则报错。
+
+#### Scenario: 多 extractor 被拒绝
+- **WHEN** YAML 中内容规则为 `{json: {path: "$.a"}, css: {selector: "div"}}`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示一条规则不能同时包含多个 extractor
+
+#### Scenario: 直接 matcher 混入 extractor 被拒绝
+- **WHEN** YAML 中内容规则为 `{contains: "ok", json: {path: "$.a"}}`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示直接 matcher 不能与 extractor 混用
+
+### Requirement: 空 ContentRules 数组语义
+`ContentRules` 空数组 `[]` SHALL 被系统接受为合法配置。运行期空数组 SHALL 等价于无规则，即该内容字段的断言直接通过。
+
+#### Scenario: 空 body 数组通过
+- **WHEN** HTTP target 配置 `expect.body: []` 且响应体为任意内容
+- **THEN** 系统 SHALL 判定 body 阶段通过
+
+### Requirement: ContentRules 非字符串值序列化
+当 `ContentRules` 的观测源为非字符串值（如对象或数组）时，直接 `ValueMatcher` 的 `contains` 和 `regex` SHALL 先将值 JSON 序列化为字符串后匹配。`equals` SHALL 直接在原始结构化值上使用深度相等比较，不进行序列化。
+
+#### Scenario: 对象序列化后 contains 匹配
+- **WHEN** ContentRules 观测源为 `{status: "ok"}` 且规则为 `{contains: "ok"}`
+- **THEN** 系统 SHALL 将对象 JSON 序列化后执行 contains 匹配
+
+#### Scenario: 对象 equals 不序列化
+- **WHEN** ContentRules 观测源为 `{status: "ok"}` 且规则为 `{equals: {status: "ok"}}`
+- **THEN** 系统 SHALL 直接在结构化值上使用深度相等比较
+
+### Requirement: ContentRules 提取器
+系统 SHALL 支持在 `ContentRules` 中使用 `json`、`css` 和 `xpath` extractor。`json.path` MUST 使用现有 JSONPath 子集。`css.selector` MUST 为非空字符串，并 MAY 配置 `attr` 提取属性值。`xpath.path` MUST 为非空字符串，并 SHALL 在启动期进行可编译校验。Extractor 内部 MAY 包含任意 `ValueMatcher` 字段。Extractor 规则未配置任何 matcher 时 SHALL 等价于 `exists: true`。
+
+#### Scenario: json extractor 数字比较
+- **WHEN** 原始内容为 JSON 字符串 `{"count": 2}` 且规则为 `{json: {path: "$.count", gte: 1}}`
+- **THEN** 系统 SHALL 解析 JSON、提取 `$.count` 并判定该规则通过
+
+#### Scenario: json extractor 存在性默认语义
+- **WHEN** 原始内容为 JSON 字符串 `{"user": {"id": null}}` 且规则为 `{json: {path: "$.user.id"}}`
+- **THEN** 系统 SHALL 将该规则视为 `{json: {path: "$.user.id", exists: true}}` 并判定通过
+
+#### Scenario: css attr 存在性默认语义
+- **WHEN** 原始内容包含 `<meta name="status" content="ok">` 且规则为 `{css: {selector: "meta[name=status]", attr: "content"}}`
+- **THEN** 系统 SHALL 在属性存在时判定该规则通过
+
+#### Scenario: xpath 无匹配节点失败
+- **WHEN** XML 内容中不存在 XPath 指向的节点，且规则为 `{xpath: {path: "/root/status"}}`
+- **THEN** 系统 SHALL 判定该规则不通过并生成 phase 对应内容字段的 mismatch failure
+
+### Requirement: KeyValueExpect 键值规则
+系统 SHALL 提供共享 `KeyValueExpect` 表达键值型观测值断言。`KeyValueExpect` SHALL 为动态键对象，每个键对应的值 MAY 为 `ValueMatcher` 或 JSON 字面量。字面量值 SHALL 等价于 `{equals: <literal>}`。调用方 MAY 指定 key 规范化策略；HTTP 与 LLM headers MUST 使用大小写不敏感的 key 匹配。
+
+#### Scenario: headers 字面量快捷写法
+- **WHEN** 响应 headers 中 `content-type` 为 `application/json`，且配置为 `headers: {Content-Type: "application/json"}`
+- **THEN** 系统 SHALL 按大小写不敏感 key 匹配并使用 equals 语义判定通过
+
+#### Scenario: headers matcher 写法
+- **WHEN** 响应 headers 中 `content-type` 为 `application/json; charset=utf-8`，且配置为 `headers: {Content-Type: {contains: "application/json"}}`
+- **THEN** 系统 SHALL 判定该 header 规则通过
+
+#### Scenario: 缺失键 exists false
+- **WHEN** 观测键值表中不存在 `x-debug`，且配置为 `{x-debug: {exists: false}}`
+- **THEN** 系统 SHALL 判定该键规则通过
+
+### Requirement: 结构化失败路径
+系统 SHALL 在共享 matcher、content 和 key-value 断言失败时生成结构化 `CheckFailure`。failure SHALL 包含 `kind`、`phase`、`path`、`message`，并在 mismatch 场景包含 `expected` 和 `actual`。内容规则 failure path SHALL 包含数组下标，key-value failure path SHALL 包含键名，extractor failure path SHALL 包含 extractor 类型和 path/selector 信息。
+
+#### Scenario: ContentRules 失败路径
+- **WHEN** `expect.body[1].json` 规则失败
+- **THEN** failure.path SHALL 指向 `body[1].json($.path)` 或等价可定位路径，failure.phase SHALL 为 `body`
+
+#### Scenario: KeyValueExpect 失败路径
+- **WHEN** `expect.headers.Content-Type` 不匹配
+- **THEN** failure.path SHALL 指向 `headers.Content-Type`，failure.phase SHALL 为 `headers`
+
+#### Scenario: actual 截断
+- **WHEN** matcher 失败时 actual 字符串长度超过 200 字符
+- **THEN** 系统 SHALL 使用现有截断策略保存 failure.actual，避免历史记录写入过长内容
--- a/openspec/specs/icmp-checker/spec.md
+++ b/openspec/specs/icmp-checker/spec.md
@@ -106,7 +106,7 @@
 - **THEN** 系统 SHALL 记录 `matched=false`，failure 的 kind 为 `error`，phase 为 `ping`，path 为 `parse`，message 包含 "无法解析 ping 输出"

 ### Requirement: ping expect 校验
-系统 SHALL 支持 ping 专属 expect，包括 `alive`、`maxPacketLoss`、`maxAvgLatencyMs`、`maxMaxLatencyMs` 和 `maxDurationMs`，并按 alive、packetLoss、avgLatency、maxLatency、duration 的阶段顺序快速失败。
+系统 SHALL 支持 ping 专属 expect，包括 `alive`、`packetLossPercent`、`avgLatencyMs`、`maxLatencyMs` 和 `durationMs`，并按 alive、packetLossPercent、avgLatencyMs、maxLatencyMs、durationMs 的阶段顺序快速失败。`alive` SHALL 保持布尔状态语义，未配置时默认 `true`。`packetLossPercent` SHALL 表示 0 到 100 的丢包率百分比，并使用共享 `ValueMatcher`。`avgLatencyMs`、`maxLatencyMs` 和 `durationMs` SHALL 使用共享 `ValueMatcher`。

 #### Scenario: 默认 alive 成功语义
 - **WHEN** ping target 未显式配置 `expect.alive`
@@ -124,57 +124,53 @@
 - **WHEN** ping target 配置 `expect.alive: false`，且目标主机不可达
 - **THEN** 系统 SHALL 判定 alive 阶段通过（`matched=true`）

-#### Scenario: 反向 alive 断言失败
- **WHEN** ping target 配置 `expect.alive: false`，但目标主机可达
- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `alive`
+#### Scenario: packetLossPercent 校验通过
+- **WHEN** ping target 配置 `expect.packetLossPercent: {lte: 10}`，且实际丢包率为 0%
+- **THEN** 系统 SHALL 判定 packetLossPercent 阶段通过

-#### Scenario: maxPacketLoss 校验通过
- **WHEN** ping target 配置 `expect.maxPacketLoss: 10`，且实际丢包率为 0%
- **THEN** 系统 SHALL 判定 packetLoss 阶段通过
-
-#### Scenario: maxPacketLoss 校验失败
- **WHEN** ping target 配置 `expect.maxPacketLoss: 10`，且实际丢包率为 33%
+#### Scenario: packetLossPercent 校验失败
+- **WHEN** ping target 配置 `expect.packetLossPercent: {lte: 10}`，且实际丢包率为 33%
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `packetLoss`

-#### Scenario: maxAvgLatencyMs 校验通过
- **WHEN** ping target 配置 `expect.maxAvgLatencyMs: 200`，且实际平均延迟为 12ms
+#### Scenario: avgLatencyMs 校验通过
+- **WHEN** ping target 配置 `expect.avgLatencyMs: {lte: 200}`，且实际平均延迟为 12ms
 - **THEN** 系统 SHALL 判定 avgLatency 阶段通过

-#### Scenario: maxAvgLatencyMs 校验失败
- **WHEN** ping target 配置 `expect.maxAvgLatencyMs: 100`，且实际平均延迟为 156ms
+#### Scenario: avgLatencyMs 校验失败
+- **WHEN** ping target 配置 `expect.avgLatencyMs: {lte: 100}`，且实际平均延迟为 156ms
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `avgLatency`

-#### Scenario: maxMaxLatencyMs 校验通过
- **WHEN** ping target 配置 `expect.maxMaxLatencyMs: 500`，且实际最大延迟为 340ms
+#### Scenario: maxLatencyMs 校验通过
+- **WHEN** ping target 配置 `expect.maxLatencyMs: {lte: 500}`，且实际最大延迟为 340ms
 - **THEN** 系统 SHALL 判定 maxLatency 阶段通过

-#### Scenario: maxMaxLatencyMs 校验失败
- **WHEN** ping target 配置 `expect.maxMaxLatencyMs: 200`，且实际最大延迟为 340ms
+#### Scenario: maxLatencyMs 校验失败
+- **WHEN** ping target 配置 `expect.maxLatencyMs: {lte: 200}`，且实际最大延迟为 340ms
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `maxLatency`

-#### Scenario: maxDurationMs 校验
- **WHEN** ping target 配置 `expect.maxDurationMs: 5000`，且完整执行耗时超过 5000ms
+#### Scenario: durationMs 校验
+- **WHEN** ping target 配置 `expect.durationMs: {lte: 5000}`，且完整执行耗时超过 5000ms
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `duration`

 #### Scenario: alive=false 时跳过延迟断言
- **WHEN** ping target 配置 `expect.alive: true` 和 `expect.maxAvgLatencyMs: 100`，且目标不可达
+- **WHEN** ping target 配置 `expect.alive: true` 和 `expect.avgLatencyMs: {lte: 100}`，且目标不可达
 - **THEN** 系统 SHALL 在 alive 阶段即返回失败，不执行后续延迟断言

 #### Scenario: ping expect 未知字段失败
- **WHEN** YAML 中 ping target 的 expect 包含 `status: [200]` 或其他非 ping expect 字段
+- **WHEN** YAML 中 ping target 的 expect 包含 `status: [200]`、`maxPacketLoss`、`maxAvgLatencyMs`、`maxMaxLatencyMs`、`maxDurationMs` 或其他非 ping expect 字段
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect 包含未知字段

-#### Scenario: maxPacketLoss 类型非法
- **WHEN** YAML 中 ping target 的 `expect.maxPacketLoss` 不是 0 到 100 之间的数字
- **THEN** 系统 SHALL 以配置错误退出，提示 expect.maxPacketLoss 必须为 0-100 的数字
+#### Scenario: packetLossPercent 类型非法
+- **WHEN** YAML 中 ping target 的 `expect.packetLossPercent` 不是合法 `ValueMatcher`，或其数值范围无法用于 0 到 100 的百分比断言
+- **THEN** 系统 SHALL 以配置错误退出，提示 expect.packetLossPercent 格式错误

-#### Scenario: maxAvgLatencyMs 类型非法
- **WHEN** YAML 中 ping target 的 `expect.maxAvgLatencyMs` 不是非负有限数字
- **THEN** 系统 SHALL 以配置错误退出，提示 expect.maxAvgLatencyMs 格式错误
+#### Scenario: avgLatencyMs 类型非法
+- **WHEN** YAML 中 ping target 的 `expect.avgLatencyMs` 不是合法 `ValueMatcher`
+- **THEN** 系统 SHALL 以配置错误退出，提示 expect.avgLatencyMs 格式错误

-#### Scenario: maxMaxLatencyMs 类型非法
- **WHEN** YAML 中 ping target 的 `expect.maxMaxLatencyMs` 不是非负有限数字
- **THEN** 系统 SHALL 以配置错误退出，提示 expect.maxMaxLatencyMs 格式错误
+#### Scenario: maxLatencyMs 类型非法
+- **WHEN** YAML 中 ping target 的 `expect.maxLatencyMs` 不是合法 `ValueMatcher`
+- **THEN** 系统 SHALL 以配置错误退出，提示 expect.maxLatencyMs 格式错误

 ### Requirement: ping statusDetail 摘要
 系统 SHALL 在 ping 执行成功后生成结构化 statusDetail 摘要，展示关键指标。
--- a/openspec/specs/llm-checker/spec.md
+++ b/openspec/specs/llm-checker/spec.md
@@ -108,7 +108,7 @@ LLM checker SHALL 在 SDK 调用结果和 expect 断言之间构建 `LlmCheckObs
 - **THEN** LLM checker SHALL 返回 `phase: "request"` 的 error failure

 ### Requirement: LLM Expect 断言
-LLM checker SHALL 支持 `expect.status`、`expect.headers`、`expect.output`、`expect.finishReason`、`expect.rawFinishReason`、`expect.usage.inputTokens`、`expect.usage.outputTokens`、`expect.usage.totalTokens`、`expect.stream.completed`、`expect.stream.firstTokenMs` 和 `expect.maxDurationMs`。`expect.status` 和 `expect.headers` 的运行期断言 SHALL 复用 `src/server/checker/runner/http/expect.ts` 中的 `checkStatus` 和 `checkHeaders` 函数。LLM checker MUST 按固定顺序快速失败，非流式顺序为 status、headers、output、finishReason、rawFinishReason、usage、duration；流式顺序为 status、headers、stream.completed、stream.firstTokenMs、output、finishReason、rawFinishReason、usage、duration。
+LLM checker SHALL 支持 `expect.status`、`expect.headers`、`expect.output`、`expect.finishReason`、`expect.rawFinishReason`、`expect.usage.inputTokens`、`expect.usage.outputTokens`、`expect.usage.totalTokens`、`expect.stream.completed`、`expect.stream.firstTokenMs` 和 `expect.durationMs`。`expect.status` SHALL 保持 HTTP 状态码数组语义并复用 HTTP status 断言。`expect.headers` SHALL 使用共享 `KeyValueExpect` 且 header key 大小写不敏感。`expect.output` MUST 使用共享 `ContentRules`。`expect.finishReason` 和 `expect.rawFinishReason` SHALL 使用共享 `ValueMatcher`。`expect.usage.*`、`expect.stream.firstTokenMs` 和 `expect.durationMs` SHALL 使用共享 `ValueMatcher`。LLM checker MUST 按固定顺序快速失败，非流式顺序为 status、headers、output、finishReason、rawFinishReason、usage、durationMs；流式顺序为 status、headers、stream.completed、stream.firstTokenMs、output、finishReason、rawFinishReason、usage、durationMs。

 #### Scenario: 默认 status 断言
 - **WHEN** LLM target 未配置 `expect.status`
@@ -118,13 +118,25 @@ LLM checker SHALL 支持 `expect.status`、`expect.headers`、`expect.output`、
 - **WHEN** observing fetch 捕获的响应 headers 满足 `expect.headers` 配置
 - **THEN** LLM checker SHALL 判定 headers 断言通过

-#### Scenario: expect headers 不匹配
- **WHEN** observing fetch 捕获的响应 headers 不满足 `expect.headers` 中的某项配置
- **THEN** LLM checker SHALL 返回 `phase: "headers"` 的 mismatch failure
+#### Scenario: output ContentRules 通过
+- **WHEN** LLM 输出文本满足 `expect.output` 中配置的全部 ContentRules
+- **THEN** LLM checker SHALL 判定 output 阶段通过

-#### Scenario: 全部 expect 通过
- **WHEN** LLM checker 构建出的 observation 满足所有已配置 expect
- **THEN** 检查结果 SHALL 为 `matched=true` 且 `failure=null`
+#### Scenario: finishReason ValueMatcher 通过
+- **WHEN** observation.finishReason 为 `stop` 且 target 配置 `expect.finishReason: {equals: "stop"}`
+- **THEN** LLM checker SHALL 判定 finishReason 阶段通过
+
+#### Scenario: rawFinishReason regex 通过
+- **WHEN** observation.rawFinishReason 为 `end_turn` 且 target 配置 `expect.rawFinishReason: {regex: "^(stop|end_turn)$"}`
+- **THEN** LLM checker SHALL 判定 rawFinishReason 阶段通过
+
+#### Scenario: usage matcher 通过
+- **WHEN** observation.usage.totalTokens 为 14 且 target 配置 `expect.usage.totalTokens: {lte: 20}`
+- **THEN** LLM checker SHALL 判定 usage 阶段通过
+
+#### Scenario: durationMs matcher 失败
+- **WHEN** LLM target 配置 `expect.durationMs: {lte: 1000}` 且实际执行耗时为 1500ms
+- **THEN** LLM checker SHALL 返回 phase=`duration` 的 mismatch failure

 #### Scenario: 首个 expect 失败
 - **WHEN** 多个 LLM expect 中某个较早顺序的断言失败
@@ -139,7 +151,7 @@ LLM checker SHALL 支持 `expect.status`、`expect.headers`、`expect.output`、
 - **THEN** LLM checker SHALL 因 `outputText` 缺失返回 `phase: "output"` 的 mismatch failure

 ### Requirement: LLM Output 规则
-LLM checker SHALL 支持 `expect.output` 有序规则数组，每个规则 MUST 仅包含 `equals`、`contains`、`regex` 或 `json` 中的一种。`equals` SHALL 对原始输出字符串做严格相等比较。`contains` SHALL 判断原始输出是否包含子串。`regex` SHALL 对原始输出执行正则匹配。`json` SHALL 将原始输出解析为 JSON，并用现有 JSONPath 子集和 operator 校验提取值。
+LLM checker SHALL 使用共享 `ContentRules` 校验 `expect.output`。每个 output rule SHALL 为直接 `ValueMatcher`，或 `json`、`css`、`xpath` extractor 规则之一。直接 matcher SHALL 作用于原始输出字符串。`equals` SHALL 对原始输出字符串做严格相等比较。`contains` SHALL 判断原始输出是否包含子串。`regex` SHALL 对原始输出执行无 flags 正则匹配。`json` SHALL 将原始输出解析为 JSON，并用现有 JSONPath 子集和 `ValueMatcher` 校验提取值。`json.equals` SHALL 支持任意 JSON value。`css` 和 `xpath` 在 schema 层面可用，但 LLM 输出通常为纯文本或 JSON，实际场景中仅 `json` 提取器有意义。

 #### Scenario: 原始输出严格相等
 - **WHEN** `outputText` 为 `"OK\n"` 且 target 配置 `expect.output: [{ equals: "OK" }]`
@@ -150,19 +162,27 @@ LLM checker SHALL 支持 `expect.output` 有序规则数组，每个规则 MUST
 - **THEN** LLM checker SHALL 判定该 output contains 规则通过

 #### Scenario: output regex 通过
- **WHEN** `outputText` 匹配配置的合法正则
+- **WHEN** `outputText` 匹配配置的合法 regex
 - **THEN** LLM checker SHALL 判定该 output regex 规则通过

-#### Scenario: output JSONPath 通过
- **WHEN** `outputText` 是 JSON 字符串且 JSONPath 提取值满足 operator
+#### Scenario: output JSONPath 字符串 equals 通过
+- **WHEN** `outputText` 是 JSON 字符串且 JSONPath 提取字符串值满足 `equals`
 - **THEN** LLM checker SHALL 判定该 output json 规则通过

+#### Scenario: output JSONPath 对象 equals 通过
+- **WHEN** `outputText` 是 JSON 字符串且 JSONPath 提取对象值满足 `equals`
+- **THEN** LLM checker SHALL 使用深度相等判定该 output json 规则通过
+
+#### Scenario: output JSONPath 存在性默认语义
+- **WHEN** `outputText` 是 JSON 字符串且 target 配置 `expect.output: [{json: {path: "$.status"}}]`
+- **THEN** LLM checker SHALL 将该规则按 `exists: true` 语义执行
+
 #### Scenario: output 规则按顺序快速失败
 - **WHEN** `expect.output` 包含多个规则且第一条规则失败
 - **THEN** LLM checker SHALL 返回第一条失败规则的 mismatch failure，不继续校验后续 output 规则

 ### Requirement: LLM Stream 断言
-LLM checker SHALL 仅允许 `mode: stream` 使用 `expect.stream`。`expect.stream.completed` 未配置时，LLM checker SHALL 在 stream observation 路径使用默认 `true` 语义。`expect.stream.firstTokenMs` SHALL 仅统计第一个非空 `text-delta` 事件耗时，不统计 reasoning、tool call 或 source 事件。
+LLM checker SHALL 仅允许 `mode: stream` 使用 `expect.stream`。`expect.stream.completed` 未配置时，LLM checker SHALL 在 stream observation 路径使用默认 `true` 语义。`expect.stream.firstTokenMs` SHALL 使用共享 `ValueMatcher`，并仅统计第一个非空 `text-delta` 事件耗时，不统计 reasoning、tool call 或 source 事件。

 #### Scenario: stream completed 默认值
 - **WHEN** target 配置 `llm.mode: stream` 且未配置 `expect.stream.completed`
@@ -173,7 +193,7 @@ LLM checker SHALL 仅允许 `mode: stream` 使用 `expect.stream`。`expect.stre
 - **THEN** LLM checker SHALL 返回 `phase: "stream"` 的 failure

 #### Scenario: firstTokenMs 达标
- **WHEN** target 配置 `expect.stream.firstTokenMs` 且首个非空 text delta 耗时满足 operator
+- **WHEN** target 配置 `expect.stream.firstTokenMs: {lte: 1000}` 且首个非空 text delta 耗时满足 matcher
 - **THEN** LLM checker SHALL 判定 firstTokenMs 断言通过

 #### Scenario: firstTokenMs 缺失
--- a/openspec/specs/probe-config/spec.md
+++ b/openspec/specs/probe-config/spec.md
@@ -193,9 +193,9 @@
 - **WHEN** YAML 中某个 HTTP target 的 `expect.status` 包含非整数或不在 100-599 范围内的数字
 - **THEN** 系统 SHALL 以错误退出，提示该 target 的 status 数字不合法

-#### Scenario: maxDurationMs 非法
- **WHEN** YAML 中某个 target 的 `expect.maxDurationMs` 不是非负有限数字
- **THEN** 系统 SHALL 以错误退出，提示该 target 的 expect.maxDurationMs 格式错误
+#### Scenario: durationMs matcher 非法
+- **WHEN** YAML 中某个 target 的 `expect.durationMs` 不是合法 `ValueMatcher`
+- **THEN** 系统 SHALL 以错误退出，提示该 target 的 expect.durationMs 格式错误

 #### Scenario: ping target 缺少 host
 - **WHEN** YAML 中某个 target 配置 `type: ping` 但缺少 `ping.host`
@@ -237,13 +237,13 @@
 - **WHEN** YAML 中某个 HTTP target 的 body xpath 规则缺少 path，或 path 不是非空字符串，或可被现有 XPath 库静态判定为语法错误
 - **THEN** 系统 SHALL 以错误退出，提示该 body xpath path 不合法

-#### Scenario: expect operator 类型非法
- **WHEN** YAML 中某个 HTTP expect operator 的 match 不是可编译正则字符串，empty/exists 不是布尔值，或 gt/gte/lt/lte 不是有限数字
- **THEN** 系统 SHALL 以错误退出，提示对应 operator 配置不合法
+#### Scenario: expect matcher 类型非法
+- **WHEN** YAML 中某个 expect matcher 的 regex 不是可编译正则字符串，empty/exists 不是布尔值，或 gt/gte/lt/lte 不是有限数字
+- **THEN** 系统 SHALL 以错误退出，提示对应 matcher 配置不合法

-#### Scenario: expect operator 类型非法
- **WHEN** YAML 中某个 expect operator 的 match 不是可编译正则字符串，empty/exists 不是布尔值，或 gt/gte/lt/lte 不是有限数字
- **THEN** 系统 SHALL 以错误退出，提示对应 operator 配置不合法
+#### Scenario: expect match 字段不再支持
+- **WHEN** YAML 中某个 expect matcher 配置 `match` 字段
+- **THEN** 系统 SHALL 以错误退出，提示 `match` 是未知字段，请使用 `regex`

 #### Scenario: unknown 字段失败
 - **WHEN** YAML 中任一结构化配置对象包含契约未声明的字段，且该对象不是明确允许动态键的对象
@@ -301,18 +301,38 @@
 - **THEN** 系统 SHALL 调用 `Bun.YAML.parse()` 将内容解析为配置对象

 ### Requirement: expect 配置增强
-系统 SHALL 支持 typed target 的领域专用 expect 配置，包括 HTTP 的 `status`（支持精确数字和范围模式）、`headers`、`body`，cmd 的 `exitCode`、`stdout`、`stderr`，tcp 的 `connected`、`banner`，ping 的 `alive`、`maxPacketLoss`、`maxAvgLatencyMs`、`maxMaxLatencyMs`，udp 的 `responded`、`response`、`responseSize`、`sourceHost`、`sourcePort` 和 `maxDurationMs`，以及 llm 的 `status`、`headers`、`output`、`finishReason`、`rawFinishReason`、`usage`、`stream` 和 `maxDurationMs`。内容类 expect MUST 使用数组表达配置顺序。
+系统 SHALL 支持 typed target 的领域专用 expect 配置，并通过共享 `ValueMatcher`、`ContentRules` 和 `KeyValueExpect` 表达可复用断言能力。状态类字段 SHALL 保持枚举或布尔语义，包括 HTTP/LLM 的 `status`（支持精确数字和范围模式）、cmd 的 `exitCode`、tcp 的 `connected`、ping 的 `alive` 和 udp 的 `responded`。数字指标字段 SHALL 使用 `ValueMatcher`，包括通用 `durationMs`、db 的 `rowCount`、udp 的 `responseSize`/`sourceHost`/`sourcePort`、ping 的 `packetLossPercent`/`avgLatencyMs`/`maxLatencyMs`、llm 的 usage token 与 stream 首 token 耗时。内容类字段 MUST 使用 `ContentRules` 数组表达配置顺序，包括 HTTP `body`、cmd `stdout`/`stderr`、tcp `banner`、udp `response`、llm `output` 和 db `result`。LLM `finishReason` 和 `rawFinishReason` SHALL 使用 `ValueMatcher`（非 ContentRules），因为它们是单值字符串元数据。键值类字段 SHALL 使用 `KeyValueExpect`，包括 HTTP/LLM `headers` 和 db `rows` 中的列值断言（db `rows` 的类型为 `Array<KeyValueExpect>`，外层数组按行索引，内层每个元素为 KeyValueExpect）。

 #### Scenario: 解析 HTTP expect 配置
- **WHEN** YAML 配置文件中 HTTP target 的 expect 包含 status、headers、body 规则数组及内部方法
+- **WHEN** YAML 配置文件中 HTTP target 的 expect 包含 status、headers、body 规则数组和 durationMs matcher
 - **THEN** 系统 SHALL 正确解析并存储为 HTTP target 的 expect 字段

 #### Scenario: 解析 cmd expect 配置
- **WHEN** YAML 配置文件中 cmd target 的 expect 包含 exitCode、stdout 和 stderr 规则数组
+- **WHEN** YAML 配置文件中 cmd target 的 expect 包含 exitCode、stdout、stderr 和 durationMs matcher
 - **THEN** 系统 SHALL 正确解析并存储为 cmd target 的 expect 字段

-#### Scenario: 解析 body 有序规则数组
- **WHEN** YAML 中 HTTP target 配置 `expect.body` 为 contains、json、regex 三个数组项
+#### Scenario: 解析 db expect 配置
+- **WHEN** YAML 配置文件中 db target 的 expect 包含 durationMs、rowCount、rows 和 result
+- **THEN** 系统 SHALL 正确解析并存储为 db target 的 expect 字段
+
+#### Scenario: 解析 tcp expect 配置
+- **WHEN** YAML 配置文件中 tcp target 的 expect 包含 connected、banner 规则数组和 durationMs matcher
+- **THEN** 系统 SHALL 正确解析并存储为 tcp target 的 expect 字段
+
+#### Scenario: 解析 ping expect 配置
+- **WHEN** YAML 配置文件中 ping target 的 expect 包含 alive、packetLossPercent、avgLatencyMs、maxLatencyMs 和 durationMs matcher
+- **THEN** 系统 SHALL 正确解析并存储为 ping target 的 expect 字段
+
+#### Scenario: 解析 udp expect 配置
+- **WHEN** YAML 配置文件中 udp target 的 expect 包含 responded、response、responseSize、sourceHost、sourcePort 和 durationMs matcher
+- **THEN** 系统 SHALL 正确解析并存储为 udp target 的 expect 字段
+
+#### Scenario: 解析 llm expect 配置
+- **WHEN** YAML 配置文件中 llm target 的 expect 包含 status、headers、output、finishReason、rawFinishReason、usage、stream 和 durationMs matcher
+- **THEN** 系统 SHALL 正确解析并存储为 llm target 的 expect 字段，并保留 output 内容规则数组顺序
+
+#### Scenario: 解析有序 ContentRules 数组
+- **WHEN** YAML 中任一内容类 expect 配置 contains、json、regex 三个数组项
 - **THEN** 系统 SHALL 保留数组顺序，供执行阶段按配置顺序快速失败

 #### Scenario: 不配置 HTTP status
@@ -323,41 +343,37 @@
 - **WHEN** HTTP target 配置 `expect.status: ["2xx"]`
 - **THEN** 系统 SHALL 在执行 expect 时匹配所有 200-299 状态码

-#### Scenario: 配置 HTTP status 混合模式
- **WHEN** HTTP target 配置 `expect.status: ["2xx", 301]`
- **THEN** 系统 SHALL 在执行 expect 时匹配所有 200-299 状态码或精确匹配 301
-
 #### Scenario: 不配置 cmd exitCode
 - **WHEN** cmd target 未配置 `expect.exitCode`
 - **THEN** 系统 SHALL 在执行 expect 时使用默认 `exitCode: [0]` 语义

 #### Scenario: 不配置 expect
 - **WHEN** target 未配置任何 expect 规则
- **THEN** 系统 SHALL 正常处理，expect 字段为 undefined
+- **THEN** 系统 SHALL 正常处理，expect 字段为 undefined，并由各 checker 使用自身默认状态语义

-#### Scenario: 解析 ping expect 配置
- **WHEN** YAML 配置文件中 ping target 的 expect 包含 alive、maxPacketLoss、maxAvgLatencyMs、maxMaxLatencyMs 和 maxDurationMs
- **THEN** 系统 SHALL 正确解析并存储为 ping target 的 expect 字段
+#### Scenario: 旧 maxDurationMs 字段不再支持
+- **WHEN** YAML 中任一 target 配置 `expect.maxDurationMs`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示该字段未知，并要求使用 `expect.durationMs`

-#### Scenario: 不配置 ping expect
- **WHEN** ping target 未配置任何 expect 规则
- **THEN** 系统 SHALL 正常处理，expect 字段为 undefined，执行时使用默认 alive=true 语义
+#### Scenario: 旧 match 字段不再支持
+- **WHEN** YAML 中任一 matcher 或内容规则配置 `match`
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示该字段未知，并要求使用 `regex`

-#### Scenario: 解析 udp expect 配置
- **WHEN** YAML 配置文件中 udp target 的 expect 包含 responded、response、responseSize、sourceHost、sourcePort 和 maxDurationMs
- **THEN** 系统 SHALL 正确解析并存储为 udp target 的 expect 字段
+#### Scenario: durationMs matcher 配置
+- **WHEN** YAML 中任一 target 配置 `expect.durationMs: {lte: 1000}`
+- **THEN** 系统 SHALL 接受该配置并在运行期使用完整执行耗时进行 matcher 校验

-#### Scenario: 不配置 udp expect
- **WHEN** udp target 未配置任何 expect 规则
- **THEN** 系统 SHALL 正常处理，expect 字段为 undefined，执行时使用默认 responded=true 语义
+#### Scenario: 动态 headers 字段允许
+- **WHEN** YAML 中 `http.headers`、`defaults.http.headers`、`llm.headers`、`defaults.llm.headers` 或 `expect.headers` 包含任意 header 名称，且对应值符合契约
+- **THEN** 系统 SHALL 接受这些动态 header 名称

-#### Scenario: 解析 llm expect 配置
- **WHEN** YAML 配置文件中 llm target 的 expect 包含 status、headers、output、finishReason、rawFinishReason、usage、stream 和 maxDurationMs
- **THEN** 系统 SHALL 正确解析并存储为 llm target 的 expect 字段，并保留 output 规则数组顺序
+#### Scenario: ContentRules 字段必须为数组
+- **WHEN** YAML 中任一内容类 expect 字段配置为非数组
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示该字段必须为规则数组

-#### Scenario: 不配置 llm expect
- **WHEN** llm target 未配置任何 expect 规则
- **THEN** 系统 SHALL 正常处理，expect 字段为 undefined，执行时使用默认 status=[200] 语义
+#### Scenario: regex 字段非法
+- **WHEN** YAML 中任一 `regex` 不是字符串、不是可编译正则或存在 ReDoS 风险
+- **THEN** 系统 SHALL 在启动期配置校验失败，提示对应 regex 不合法

 ### Requirement: 数据保留配置字段
 配置 schema 的 `runtime` 段 SHALL 支持 `retention` 字段，类型为字符串，格式为 `<数字><单位>`（单位：`d` 天、`h` 小时、`m` 分钟），用于指定历史数据保留时长。
@@ -444,7 +460,7 @@
 - **THEN** target schema SHALL 声明 `id` 的 minLength 为 1、maxLength 为 30，并声明 `name` 为可选字段，类型为 string 或 null，字符串的 minLength 为 1、maxLength 为 30

 ### Requirement: TCP 配置校验
-系统 SHALL 在启动期对 tcp checker 的配置契约和语义执行严格校验。Tcp target 的 `tcp` 分组 SHALL 只允许 `host`、`port`、`readBanner`、`bannerReadTimeout` 和 `maxBannerBytes` 字段；Tcp expect SHALL 只允许 `connected`、`maxDurationMs` 和 `banner` 字段。未知字段、非法类型、非法端口、非法 size 和不可编译正则 MUST 导致启动期配置错误。
+系统 SHALL 在启动期对 tcp checker 的配置契约和语义执行严格校验。Tcp target 的 `tcp` 分组 SHALL 只允许 `host`、`port`、`readBanner`、`bannerReadTimeout` 和 `maxBannerBytes` 字段；Tcp expect SHALL 只允许 `connected`、`durationMs` 和 `banner` 字段。`banner` MUST 为 `ContentRules` 数组。未知字段、非法类型、非法端口、非法 size 和不可编译正则 MUST 导致启动期配置错误。

 #### Scenario: tcp host 类型非法
 - **WHEN** YAML 中 tcp target 的 `tcp.host` 不是非空字符串
@@ -471,11 +487,11 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.connected 必须为布尔值

 #### Scenario: tcp expect banner 非法
- **WHEN** YAML 中 tcp target 的 `expect.banner` 不是合法 operator 对象
+- **WHEN** YAML 中 tcp target 的 `expect.banner` 不是合法 ContentRules 数组
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.banner 格式错误

-#### Scenario: tcp expect banner match 正则非法
- **WHEN** YAML 中 tcp target 配置 `expect.banner: { match: "[invalid" }`
+#### Scenario: tcp expect banner regex 正则非法
+- **WHEN** YAML 中 tcp target 配置 `expect.banner: [{ regex: "[invalid" }]`
 - **THEN** 系统 SHALL 在启动期配置校验失败，而不是延迟到运行期抛错

 #### Scenario: tcp 分组未知字段失败
@@ -487,7 +503,7 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示 defaults.tcp 包含未知字段

 ### Requirement: LLM 配置校验
-系统 SHALL 在启动期对 llm checker 的配置契约和语义执行严格校验。LLM target 的 `llm` 分组 SHALL 只允许 `provider`、`url`、`model`、`prompt`、`mode`、`key`、`authToken`、`headers`、`ignoreSSL`、`options` 和 `providerOptions` 字段。`defaults.llm` 分组 SHALL 只允许 `mode`、`headers`、`ignoreSSL`、`options` 和 `providerOptions` 字段。LLM expect SHALL 只允许 `status`、`headers`、`output`、`finishReason`、`rawFinishReason`、`usage`、`stream` 和 `maxDurationMs` 字段。未知字段、非法 provider、非法 URL、非法 mode、非法认证组合、非法 options、非法 output 规则和 `mode: http` 下配置 `expect.stream` MUST 导致启动期配置错误。
+系统 SHALL 在启动期对 llm checker 的配置契约和语义执行严格校验。LLM target 的 `llm` 分组 SHALL 只允许 `provider`、`url`、`model`、`prompt`、`mode`、`key`、`authToken`、`headers`、`ignoreSSL`、`options` 和 `providerOptions` 字段。`defaults.llm` 分组 SHALL 只允许 `mode`、`headers`、`ignoreSSL`、`options` 和 `providerOptions` 字段。LLM expect SHALL 只允许 `status`、`headers`、`output`、`finishReason`、`rawFinishReason`、`usage`、`stream` 和 `durationMs` 字段。`expect.output` MUST 为 `ContentRules` 数组。`expect.finishReason` 和 `expect.rawFinishReason` SHALL 使用 `ValueMatcher`。`expect.usage.*` 和 `expect.stream.firstTokenMs` SHALL 使用 `ValueMatcher`。未知字段、非法 provider、非法 URL、非法 mode、非法认证组合、非法 options、非法 output 规则和 `mode: http` 下配置 `expect.stream` MUST 导致启动期配置错误。

 #### Scenario: llm provider 非法
 - **WHEN** YAML 中 llm target 的 `llm.provider` 不是 `openai`、`openai-responses` 或 `anthropic`
@@ -538,12 +554,12 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示 llm 分组包含未知字段

 #### Scenario: llm output 规则缺少支持字段
- **WHEN** YAML 中 llm target 的 `expect.output` 数组项未包含 equals、contains、regex、json 任一支持字段
+- **WHEN** YAML 中 llm target 的 `expect.output` 数组项未包含任何合法 ValueMatcher 字段或 extractor
 - **THEN** 系统 SHALL 以配置错误退出，提示 output rule 缺少支持的规则类型

-#### Scenario: llm output 规则同时配置多个支持字段
- **WHEN** YAML 中 llm target 的同一条 output rule 同时包含 equals、contains、regex、json 中的多个支持字段
- **THEN** 系统 SHALL 以配置错误退出，提示每条 output rule 只能配置一种规则类型
+#### Scenario: llm output 规则同时配置多个 extractor
+- **WHEN** YAML 中 llm target 的同一条 output rule 同时包含 json、css、xpath 中的多个 extractor
+- **THEN** 系统 SHALL 以配置错误退出，提示每条 output rule 只能配置一种 extractor

 #### Scenario: llm output regex 非法
 - **WHEN** YAML 中 llm target 的 output regex 规则不是字符串、不是可编译正则表达式或存在 ReDoS 风险
@@ -554,7 +570,7 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示该 output json path 不合法

 #### Scenario: llm expect usage 非法
- **WHEN** YAML 中 llm target 的 `expect.usage.inputTokens`、`expect.usage.outputTokens` 或 `expect.usage.totalTokens` 不是合法 operator 对象
+- **WHEN** YAML 中 llm target 的 `expect.usage.inputTokens`、`expect.usage.outputTokens` 或 `expect.usage.totalTokens` 不是合法 `ValueMatcher`
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.usage 格式错误

 #### Scenario: llm expect stream 仅允许 stream mode
@@ -562,5 +578,5 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.stream 仅支持 stream mode

 #### Scenario: llm expect stream firstTokenMs 非法
- **WHEN** YAML 中 llm target 的 `expect.stream.firstTokenMs` 不是合法 operator 对象
+- **WHEN** YAML 中 llm target 的 `expect.stream.firstTokenMs` 不是合法 `ValueMatcher`
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect.stream.firstTokenMs 格式错误
--- a/openspec/specs/tcp-checker/spec.md
+++ b/openspec/specs/tcp-checker/spec.md
@@ -86,28 +86,32 @@
 - **THEN** `statusDetail` SHALL 展示截断后的 banner 摘要，避免 UI 和历史记录写入过长文本

 ### Requirement: tcp expect 校验
-系统 SHALL 支持 tcp 专属 expect，包括 `connected`、`banner` 和 `maxDurationMs`，并按 connected、banner、duration 的阶段顺序快速失败。
+系统 SHALL 支持 tcp 专属 expect，包括 `connected`、`banner` 和 `durationMs`，并按 connected、banner、durationMs 的阶段顺序快速失败。`connected` SHALL 保持布尔状态语义，未配置时默认 `true`。`banner` MUST 使用共享 `ContentRules` 数组，并仅在 `tcp.readBanner: true` 时允许配置。`durationMs` SHALL 使用共享 `ValueMatcher` 校验包含连接和 banner 读取在内的完整执行耗时。

 #### Scenario: 默认 connected 成功语义
 - **WHEN** tcp target 未显式配置 `expect.connected`
 - **THEN** 系统 SHALL 使用默认 `expect.connected: true` 进行校验

-#### Scenario: maxDurationMs 校验
- **WHEN** tcp target 配置 `expect.maxDurationMs: 100`，且完整执行耗时超过 100ms
+#### Scenario: durationMs 校验
+- **WHEN** tcp target 配置 `expect.durationMs: {lte: 100}`，且完整执行耗时超过 100ms
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `duration`

-#### Scenario: banner operator 校验通过
- **WHEN** tcp target 配置 `readBanner: true`、`expect.banner: { contains: "ESMTP" }`，且实际 banner 包含 `ESMTP`
+#### Scenario: banner ContentRules 校验通过
+- **WHEN** tcp target 配置 `readBanner: true`、`expect.banner: [{contains: "ESMTP"}]`，且实际 banner 包含 `ESMTP`
 - **THEN** 系统 SHALL 判定 banner 阶段通过

-#### Scenario: banner operator 校验失败
- **WHEN** tcp target 配置 `readBanner: true`、`expect.banner: { contains: "ESMTP" }`，且实际 banner 不包含 `ESMTP`
- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `banner`，path 为 `banner`
+#### Scenario: banner regex 校验失败
+- **WHEN** tcp target 配置 `readBanner: true`、`expect.banner: [{regex: "^SSH-2\\.0"}]`，且实际 banner 不匹配该正则
+- **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `banner`，path 指向失败的 banner 规则
+
+#### Scenario: banner 多规则快速失败
+- **WHEN** tcp target 配置两条 banner 规则且第一条失败
+- **THEN** 系统 SHALL 返回第一条失败规则的 failure，并 MUST NOT 执行第二条规则

 #### Scenario: expect.banner 未开启 readBanner
 - **WHEN** tcp target 配置 `expect.banner`，但 `tcp.readBanner` 未配置为 `true`
 - **THEN** 系统 SHALL 在启动期配置校验失败，提示 banner 断言需要启用 tcp.readBanner

 #### Scenario: tcp expect 未知字段失败
- **WHEN** YAML 中 tcp target 的 expect 包含 `status: [200]` 或其他非 tcp expect 字段
+- **WHEN** YAML 中 tcp target 的 expect 包含 `status: [200]`、`maxDurationMs: 1000` 或其他非 tcp expect 字段
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect 包含未知字段
--- a/openspec/specs/udp-checker/spec.md
+++ b/openspec/specs/udp-checker/spec.md
@@ -133,17 +133,21 @@
 - **THEN** 系统 SHALL 以配置错误退出，提示 maxResponseBytes 格式错误

 ### Requirement: udp expect 校验
-系统 SHALL 支持 udp 专属 expect，包括 `responded`、`response`、`responseSize`、`sourceHost`、`sourcePort` 和 `maxDurationMs`，并按 responded、responseSize、response、sourceHost、sourcePort、duration 的阶段顺序快速失败。
+系统 SHALL 支持 udp 专属 expect，包括 `responded`、`response`、`responseSize`、`sourceHost`、`sourcePort` 和 `durationMs`，并按 responded、responseSize、response、sourceHost、sourcePort、durationMs 的阶段顺序快速失败。`responded` SHALL 保持布尔状态语义，未配置时默认 `true`。`response` MUST 使用共享 `ContentRules` 数组，并作用于按 `udp.responseEncoding` 转换后的响应文本。`responseSize`、`sourceHost`、`sourcePort` 和 `durationMs` SHALL 使用共享 `ValueMatcher`。

 #### Scenario: 默认 responded 成功语义
 - **WHEN** udp target 未显式配置 `expect.responded`
 - **THEN** 系统 SHALL 使用默认 `expect.responded: true` 进行校验

-#### Scenario: response text rules 校验通过
+#### Scenario: response ContentRules 校验通过
 - **WHEN** udp target 配置 `expect.response: [{ contains: "PONG" }]`，且按 `responseEncoding` 转换后的响应文本包含 `PONG`
 - **THEN** 系统 SHALL 判定 response 阶段通过

-#### Scenario: response text rules 校验失败
+#### Scenario: response JSON 校验通过
+- **WHEN** udp target 收到文本响应 `{"status":"ok"}` 且配置 `expect.response: [{json: {path: "$.status", equals: "ok"}}]`
+- **THEN** 系统 SHALL 判定 response 阶段通过
+
+#### Scenario: response ContentRules 校验失败
 - **WHEN** udp target 配置 `expect.response: [{ contains: "PONG" }]`，但按 `responseEncoding` 转换后的响应文本不包含 `PONG`
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `response`，path 指向失败的 response 规则

@@ -151,28 +155,24 @@
 - **WHEN** udp target 配置 `udp.responseEncoding: "hex"` 且收到字节内容 `PONG`
 - **THEN** 系统 SHALL 将响应转换为小写 hex 字符串 `504f4e47` 后执行 `expect.response` 规则

-#### Scenario: responseEncoding 为 base64
- **WHEN** udp target 配置 `udp.responseEncoding: "base64"` 且收到字节内容 `PONG`
- **THEN** 系统 SHALL 将响应转换为 base64 字符串 `UE9ORw==` 后执行 `expect.response` 规则
-
-#### Scenario: responseSize operator 校验通过
+#### Scenario: responseSize matcher 校验通过
 - **WHEN** udp target 配置 `expect.responseSize: { gte: 4 }`，且实际响应为 4 字节
 - **THEN** 系统 SHALL 判定 responseSize 阶段通过

-#### Scenario: responseSize operator 校验失败
+#### Scenario: responseSize matcher 校验失败
 - **WHEN** udp target 配置 `expect.responseSize: { gte: 4 }`，但实际响应为 2 字节
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 kind 为 `mismatch`，phase 为 `responseSize`

-#### Scenario: sourceHost operator 校验
+#### Scenario: sourceHost matcher 校验
 - **WHEN** udp target 配置 `expect.sourceHost: { equals: "127.0.0.1" }`，且 Bun 回调中的来源地址为 `127.0.0.1`
 - **THEN** 系统 SHALL 判定 sourceHost 阶段通过

-#### Scenario: sourcePort operator 校验
+#### Scenario: sourcePort matcher 校验
 - **WHEN** udp target 配置 `expect.sourcePort: { equals: 9000 }`，且 Bun 回调中的来源端口为 `9000`
 - **THEN** 系统 SHALL 判定 sourcePort 阶段通过

-#### Scenario: maxDurationMs 校验
- **WHEN** udp target 配置 `expect.maxDurationMs: 100`，且完整执行耗时超过 100ms
+#### Scenario: durationMs 校验
+- **WHEN** udp target 配置 `expect.durationMs: {lte: 100}`，且完整执行耗时超过 100ms
 - **THEN** 系统 SHALL 返回 `matched=false`，failure 的 phase 为 `duration`

 #### Scenario: response 断言要求实际有响应
@@ -184,7 +184,7 @@
 - **THEN** 系统 SHALL 在启动期配置校验失败，提示响应来源断言需要 `expect.responded` 为 true

 #### Scenario: udp expect 未知字段失败
- **WHEN** YAML 中 udp target 的 expect 包含 `status: [200]` 或其他非 udp expect 字段
+- **WHEN** YAML 中 udp target 的 expect 包含 `status: [200]`、`maxDurationMs: 1000` 或其他非 udp expect 字段
 - **THEN** 系统 SHALL 以配置错误退出，提示 expect 包含未知字段

 ### Requirement: udp statusDetail 摘要