ctx_checker 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bd23ca0a7767d79f02f7b0103f0c2f524534ab677d368f995484981d93fbbfb
-  data.tar.gz: 9c324f79c104b917338007d105c2a55405a09a036e66a3c9349ef57e3f9664de
+  metadata.gz: 71962914e6b52e83b27e6c79345530ef9e92fb4168175a43e6cc46f464abc8f4
+  data.tar.gz: e1e3adf05ec7d615920b49d65734e44cd3df35ba5efff584f11b5d0b5273df22
 SHA512:
-  metadata.gz: 15cf93bf62713e215071bc2d5d0081820cdad50d67b38ddbbc3874e6df30b8f256417997b33e2383ea849bc15b879537b7f9013f393f01dd74f9c943db0a9aff
-  data.tar.gz: 0ac66781f4a9795b92bc872704633d72ab12a88a19b26ebe6b3af7e8b8a4239c013bbec61c28c2182e859043fc6b2ee2726eff3f3339e52e648d950769634137
+  metadata.gz: 270d9b5bf20181cfc30f89dbe9b069ae5ac3499ab57efc726c991be5e2fe3f633156de1e8e51d612b7719be1981d74e89c26334fb546fbe19262f6290d759871
+  data.tar.gz: 124f1e9f0609e3a46e382305ffd23768096b272868e852ffd1a25da317ae58defefac2ec1bfb6200fc94b381f1bb0bf594e69baf4d7db286731043c722ddb49e

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 Changes to the public contract are recorded here. Versions follow Semantic Versioning.
 
+## 0.2.1 (2026-10-17)
+
+- Validate time-limit snapshot compatibility during policy construction; reject unsupported Numeric objects before evaluation while preserving exact Rational values.
+
+## 0.2.0 (2026-10-17)
+
+- Require ctx_parser and ctx_driver 0.2.x for the renamed public contracts.
+
+- Allow isolated package verification to install explicitly supplied dependency candidate artifacts without changing gemspec dependency constraints.
+- Require a measured temperature when an exact sensor policy supplies numeric thresholds.
+- Preserve conflicting Cisco interface states as incomplete evidence and retain observed protocol failures.
+- Normalize integer OSPF process identities in policies, observations, and coverage scopes; reject normalized duplicates.
+- Bound parser diagnostic samples to 128 plus an omitted-count summary, and skip vendor parsing for explicit command failures.
+- Index validated command implementations for response parsing, rebuilding the index after discovery expansion.
+
+- Use the shared `CtxParser::Configuration`, `Results`, and `Commands` names and dimension indexes where applicable.
+
+- Name system field definitions and validation `SystemFields`; exercise installed BGP parsing during package verification.
+
+- Rename domain APIs directly; callers must use the new names (no compatibility aliases).
+
+- Name required-dimension predicates and policy validators explicitly; expose sampling interval units in counter evaluation.
+
+### Changed
+
+- Index CPU windows, optical measurements, aggregation membership, and required interfaces once, avoiding repeated full scans during parsing and health evaluation.
+
 ## 0.1.0 (2026-10-16)
 
 ### Added

data/README-zh.md

@@ -67,8 +67,16 @@ error、CRC、discard 保持独立，不相加；单次累计值不能当作当
 
 生命周期 connector 是宿主适配器，提供 `open { |session| }`，VXLAN 和 Wireless 还要求 `platform`；原生 `Net::Connector::Base` 实例并不提供这一宿主生命周期协议。已连接的原生会话可传入 `CtxDriver::Reader` 或 `CtxChecker::Collector#collect_session`，不会隐式连接或重试。
 
+## 领域术语
+
+`Observation` 表示某维度的采集证据，`Finding` 表示健康判定。`Policy#required_dimension?`、`SystemPolicy#required_dimension?` 查询必需观测维度。接口与光学测量仍按其完整身份匹配要求。计数器阈值比较经过连续性验证的采样区间内增量，区间以秒计；阈值不是累计总量或每秒速率。
+
+整数 OSPF 进程 ID 在策略、观测记录和覆盖作用域中统一转换成字符串，再检查身份重复。明确配置温度阈值时必须有数值读数，只有 `ok` 状态不能满足阈值策略。每个解析结果最多保留 128 条诊断样本，额外的 `diagnostics_truncated` 摘要记录省略数量；截断不能证明证据完整。
+
 ## 开发与测试
 
+共享类按实际职责命名，平台信息放在命名空间中。直接对应设备命令的解析器保留文件名和类名。
+
 ```sh
 bundle install
 bundle exec rake
@@ -78,6 +86,8 @@ bundle exec rake build
 
 `bundle exec rake` 执行 RSpec、RuboCop 及离线示例。测试放在 `spec/`，沿用项目 RSpec 约定；样例采用合成或脱敏证据。新增解析格式时补充成功、不完整、不支持及非法输入回归。离线测试不代表所有设备版本均通过实机验证。
 
+运行 `ruby script/verify_package.rb /path/to/ctx_checker.gem`，验证使用已发布依赖的隔离安装。联动开发时可追加明确构建的依赖包路径，例如 `/path/to/ctx_parser.gem`，先安装这些候选包；候选包验证通过不代表注册表中的依赖已兼容。`bundle exec ruby -Ilib benchmark/runtime.rb` 用合成输入测量本地命令查找和诊断开销。
+
 使用声明的最低 Ruby 版本检查兼容性。方法用途统一使用简明中文注释；复杂实现还需说明业务规则、实现思路及关键分支。保持公开返回值与错误契约。真实回显和凭据不可进入示例、fixture、日志或发布包。
 
 ## 发布

data/README.md

@@ -67,8 +67,16 @@ Detailed vendor behavior, historical validation notes, and Motor-only integratio
 
 The lifecycle connector is a host adapter exposing `open { |session| }` (and `platform` for VXLAN and Wireless). It is distinct from a native `Net::Connector::Base` device instance. Borrowed native sessions are accepted by `CtxDriver::Reader` and `CtxChecker::Collector#collect_session`; they are never implicitly connected or retried.
 
+## Domain vocabulary
+
+An `Observation` describes collected evidence for a dimension; a `Finding` describes its health assessment. `Policy#required_dimension?` and `SystemPolicy#required_dimension?` query required observation dimensions. Interface and optical requirements retain their scoped identity checks. Counter limits compare increments over a validated sampling interval in seconds; they are not cumulative totals or rates.
+
+Integer OSPF process IDs are normalized to strings in policies, observations, and covered scopes before checking identities. An explicit temperature threshold requires a numeric reading; an `ok` sensor state alone cannot satisfy it. Parsers retain at most 128 diagnostic samples per result, plus a `diagnostics_truncated` entry counting omitted diagnostics; truncation never proves complete evidence.
+
 ## Development and tests
 
+Name shared classes by their responsibility and use the namespace for platform context. Preserve filenames and class names that directly match device commands.
+
 ```sh
 bundle install
 bundle exec rake
@@ -78,6 +86,8 @@ bundle exec rake build
 
 `bundle exec rake` runs RSpec, RuboCop, and the offline examples. Tests live in `spec/`, following the existing project's RSpec convention; fixtures use synthetic or sanitized evidence. Add regression cases for successful, incomplete, unsupported, and malformed inputs when extending a parser. Offline tests do not certify all device versions or replace live integration checks.
 
+Run `ruby script/verify_package.rb /path/to/ctx_checker.gem` to verify an isolated installation with published dependencies. During coordinated development, append explicitly built dependency artifacts, such as `/path/to/ctx_parser.gem`, to install those candidates first. Candidate verification does not establish that the published dependencies are compatible. `bundle exec ruby -Ilib benchmark/runtime.rb` measures synthetic command lookup and diagnostic overhead locally.
+
 Use the declared minimum Ruby version for compatibility checks. Document source methods and non-obvious business logic in concise Chinese, preserve public return/error contracts, and never add raw device captures or credentials to examples, fixtures, logs, or release archives.
 
 ## Release

data/docs/architecture-zh.md

@@ -23,12 +23,12 @@ net-connector session -> Collector / CtxDriver::Reader -> 逐命令 Parser
 ### 文件组织
 
 * `lib/ctx_checker/{observation,snapshot,policy,finding,report}.rb`：不可变领域对象和公共契约。
-* `lib/ctx_checker/{system_record,system_policy,observation_merger}.rb`：系统指标字段、运行阈值及多命令证据组合。
+* `lib/ctx_checker/{system_fields,system_policy,observation_merger}.rb`：系统指标字段、运行阈值及多命令证据组合。
 * `lib/ctx_checker/{evaluator,collector,runtime_parser,parser_registry}.rb`：判定组合、采集和离线入口。
 * `lib/ctx_checker/checks/*.rb`：按指标组织的厂商无关检查。
 * `lib/ctx_checker/parsers/{base,interface_names,scoped_result}.rb`：文本边界、完整性、接口名称及协议表范围证明。
 * `lib/ctx_checker/{h3c,cisco_ios,cisco_nxos,palo_alto,hillstone,radware_alteon}/profile.rb`：只读查询目录及厂商发现策略。
-* `lib/ctx_checker/<platform>/parsers/<command>.rb`：一个命令一个解析器；一份回显包含多个指标时返回 ResultSet。
+* `lib/ctx_checker/<platform>/parsers/<command>.rb`：一个命令一个解析器；一份回显包含多个指标时返回 Results。
 
 不创建每厂商一个巨型解析模板。共享同一语法才共享解析机制；健康规则集中在 checks。
 型号变体通过 Profile 策略或 MODEL_PARSERS 显式扩展，不按未知型号猜测命令。

data/lib/ctx_checker/checks/base.rb

@@ -15,11 +15,11 @@ module CtxChecker
       def call(observation)
         @observation = observation
         if observation.status == :not_applicable
-          return [ finding(:fail, :required_feature_not_configured, severity: :critical) ] if @policy.required?(observation.name)
+          return [ finding(:fail, :required_feature_not_configured, severity: :critical) ] if @policy.required_dimension?(observation.name)
 
           return [ finding(:not_applicable, :feature_not_configured) ]
         end
-        if observation.status == :not_requested && !@policy.required?(observation.name)
+        if observation.status == :not_requested && !@policy.required_dimension?(observation.name)
           return [ finding(:not_applicable, :not_requested) ]
         end
         results = observation.records.flat_map do |record|
@@ -51,8 +51,8 @@ module CtxChecker
       def missing_status = @observation.complete? ? :fail : :unknown
       # 仅在需要关联接口状态的检查中建立接口索引。
       def interface(name)
-        @interfaces ||= @snapshot.observation(:interfaces).records.to_h { |row| [ row[:name], row ] }
-        @interfaces[name]
+        @interfaces_by_name ||= @snapshot.observation(:interfaces).records.to_h { |row| [ row[:name], row ] }
+        @interfaces_by_name[name]
       end
 
       # 同级查询失败不能使其他来源的完整测量失效。

data/lib/ctx_checker/checks/clock.rb

@@ -19,10 +19,10 @@ module CtxChecker
           return results + [ finding(:unknown, :clock_time_unavailable, entity: entity) ]
         end
         observed_at = @observation.observed_at || @snapshot.observed_at
-        skew = (Time.iso8601(record[:time]) - observed_at).abs
+        skew_seconds = (Time.iso8601(record[:time]) - observed_at).abs
         limit = @policy.system.max_clock_skew_seconds
-        results << finding(skew > limit ? :fail : :pass, :clock_skew, entity: entity,
-          actual: { time: record[:time], skew_seconds: skew }, expected: { maximum_seconds: limit }, severity: skew > limit ? :warning : :info)
+        results << finding(skew_seconds > limit ? :fail : :pass, :clock_skew, entity: entity,
+          actual: { time: record[:time], skew_seconds: skew_seconds }, expected: { maximum_seconds: limit }, severity: skew_seconds > limit ? :warning : :info)
         results
       end
     end

data/lib/ctx_checker/checks/counters.rb

@@ -10,7 +10,7 @@ module CtxChecker
       def initialize(**options)
         super
         @previous_counters = @previous&.observation(dimension)
-        @previous_records = @previous_counters&.records&.to_h { |row| [ row.values_at(*identity_fields), row ] } || {}
+        @previous_records_by_identity = @previous_counters&.records&.to_h { |row| [ row.values_at(*identity_fields), row ] } || {}
       end
 
       private
@@ -21,7 +21,7 @@ module CtxChecker
         value = record[:value]
         return finding(:unknown, :counter_unavailable, entity: entity) if value.nil?
         previous = @previous_counters
-        prior = @previous_records[record.values_at(*identity_fields)]
+        prior = @previous_records_by_identity[record.values_at(*identity_fields)]
         if (reason = packet_semantics_reason(record, prior))
           return finding(:unknown, reason, entity: entity, actual: record.slice(:value, :unit, :scope))
         end
@@ -30,9 +30,9 @@ module CtxChecker
           return finding(value.zero? ? :pass : :unknown, value.zero? ? :zero_cumulative_counter : :cumulative_errors,
             entity: entity, actual: value, severity: value.zero? ? :info : :warning)
         end
-        interval = sample_time(record, @observation, @snapshot) - sample_time(prior, previous, @previous)
+        interval_seconds = sample_time(record, @observation, @snapshot) - sample_time(prior, previous, @previous)
         # 先验证时间与重置标记；数值下降可能是清零或重启，不能按负增量计算。
-        reason = if interval <= 0
+        reason = if interval_seconds <= 0
           :counter_sample_time_invalid
         elsif record[:discontinuity].nil? || prior[:discontinuity].nil?
           :counter_continuity_unconfirmed
@@ -45,10 +45,10 @@ module CtxChecker
         limit = limit_for(record)
         # 超限是已观察故障；未超限仍需前后来源完整才能证明通过。
         if delta <= limit && (!record_complete?(prior, previous) || !record_complete?(record, @observation))
-          return finding(:unknown, :counter_evidence_incomplete, entity: entity, actual: { delta: delta, seconds: interval })
+          return finding(:unknown, :counter_evidence_incomplete, entity: entity, actual: { delta: delta, seconds: interval_seconds })
         end
         finding(delta > limit ? :fail : :pass, :counter_delta, entity: entity,
-          actual: delta_measurement(value, delta, interval), expected: { maximum_delta: limit }, severity: :warning)
+          actual: delta_measurement(value, delta, interval_seconds), expected: { maximum_delta: limit }, severity: :warning)
       end
 
       # 选择当前评估负责的观测维度。
@@ -58,7 +58,7 @@ module CtxChecker
       # 优先使用资源专用阈值，再回退到策略默认值。
       def limit_for(record) = @policy.counter_limits.fetch(record[:metric], 0)
       # 将已计算增量与采样间隔组织为报告测量值。
-      def delta_measurement(_value, delta, interval) = { delta: delta, seconds: interval }
+      def delta_measurement(_value, delta, interval_seconds) = { delta: delta, seconds: interval_seconds }
       # 解析速率或增量分析所需的采样时间。
       def sample_time(record, observation, snapshot) = record[:sampled_at] ? Time.iso8601(record[:sampled_at]) : observation.observed_at || snapshot.observed_at
 

data/lib/ctx_checker/checks/device_counters.rb

@@ -26,7 +26,7 @@ module CtxChecker
       # 优先使用资源专用阈值，再回退到策略默认值。
       def limit_for(record) = @policy.system.device_counter_limits.fetch(record[:metric], 0)
       # 组织累计量、已验证增量及采样间隔，并计算每秒速率。
-      def delta_measurement(value, delta, interval) = { cumulative: value, delta: delta, seconds: interval, per_second: delta / interval }
+      def delta_measurement(value, delta, interval_seconds) = { cumulative: value, delta: delta, seconds: interval_seconds, per_second: delta / interval_seconds }
     end
   end
 end

data/lib/ctx_checker/checks/interfaces.rb

@@ -11,7 +11,7 @@ module CtxChecker
       # 按策略评估资源，同时保留测量值缺失的状态。
       def assess(record)
         name = record[:name]
-        required = @policy.required_interfaces.include?(name)
+        required = @policy.required_interface?(name)
         status, reason = if record[:admin_status] == :down && !required
           [ :not_applicable, :administratively_down ]
         elsif record[:oper_status] == :down || record[:protocol_status] == :down && record[:protocol_applicable] != false || required && record[:admin_status] == :down

data/lib/ctx_checker/checks/optics.rb

@@ -20,7 +20,7 @@ module CtxChecker
         end
         context = interface(record[:interface])
         if context && record_complete?(context, @snapshot.observation(:interfaces)) &&
-            context[:admin_status] == :down && !@policy.required_interfaces.include?(record[:interface]) && !@policy.required_optics?(record)
+            context[:admin_status] == :down && !@policy.required_interface?(record[:interface]) && !@policy.required_optics?(record)
           return finding(:not_applicable, :administratively_down, entity: entity)
         end
         if (record[:present] == false || record[:dom_supported] == false) && !ALARMS.include?(record[:alarm])

data/lib/ctx_checker/checks/temperature.rb

@@ -33,6 +33,8 @@ module CtxChecker
           if !override && (state == :ok && severity || explicit_fault && !severity)
             results << finding(:unknown, :temperature_state_disagreement, entity: entity)
           end
+        elsif override && value.nil?
+          results << finding(:unknown, :temperature_value_unavailable, entity: entity, expected: bounds)
         elsif !explicit_fault
           results << finding(state == :ok ? :pass : :unknown, :temperature_state, entity: entity, actual: record)
         end

data/lib/ctx_checker/cisco_ios/parsers/show_clock_detail.rb

@@ -14,7 +14,7 @@ module CtxChecker
 
         # 解析 show clock detail，保留不完整或不支持的证据。
         def parse_output(text, complete:)
-          records, issues = [], []
+          records, issues = [], diagnostics
           time_source = nil
           clean(text).each_line.with_index(1) do |source, number|
             line = source.strip

data/lib/ctx_checker/cisco_ios/parsers/show_environment_all.rb

@@ -2,7 +2,7 @@
 
 require_relative "../../parsers/base"
 require_relative "system_values"
-require "ctx_parser/result_set"
+require "ctx_parser/results"
 
 module CtxChecker
   module CiscoIos
@@ -16,7 +16,7 @@ module CtxChecker
         # 解析 show environment all，保留不完整或不支持的证据。
         def parse_output(text, complete:)
           @rows = { temperature: [], environment: [], power: [] }
-          @problems = @rows.transform_values { [] }
+          @problems = @rows.transform_values { diagnostics }
           @switch = "active"
           @temperature = nil
           @sensor_table = false
@@ -33,7 +33,7 @@ module CtxChecker
             identity = dimension == :temperature ? [ :component ] : %i[component kind]
             [ dimension, build_result(rows, complete: complete, recognized: rows.any?, issues: @problems[dimension], identity: identity) ]
           end
-          CtxParser::ResultSet.new(results: results)
+          CtxParser::Results.new(by_dimension: results)
         end
 
         # Catalyst StackWise Virtual 在传感器后按交换机报告电源和风扇托盘。

data/lib/ctx_checker/cisco_ios/parsers/show_etherchannel_summary.rb

@@ -18,7 +18,7 @@ module CtxChecker
         # 要求存在数据表或明确空表证据；标志图例不能作为成员记录。
         def parse_output(text, complete:)
           text = clean(text)
-          rows, issues, groups, totals = [], [], [], []
+          rows, issues, groups, totals = [], diagnostics, [], []
           current, header, empty = nil, false, false
           text.each_line.with_index(1) do |source, number|
             line = source.strip
@@ -49,16 +49,19 @@ module CtxChecker
           totals.each do |total|
             issues << { code: :count_mismatch, expected: total, observed: groups.size } unless total == groups.size
           end
+          member_groups = rows.to_h { |row| [ row[:group], true ] }
           groups.each do |group|
-            next if rows.any? { |row| row[:group] == group[:group] }
+            next if member_groups.key?(group[:group])
 
             rows << group.merge(member: nil, member_status: :unknown)
+            member_groups[group[:group]] = true
             issues << { code: :aggregation_members_missing, group: group[:group] }
           end
           repeated_groups = groups.group_by { |group| group[:group] }.select { |_, entries| entries.size > 1 }.keys
           if repeated_groups.any?
             issues << { code: :duplicate_aggregation_group, count: repeated_groups.size }
-            rows.reject! { |row| repeated_groups.include?(row[:group]) }
+            repeated = repeated_groups.to_h { |name| [ name, true ] }
+            rows.reject! { |row| repeated.key?(row[:group]) }
           end
           issues << { code: :contradictory_empty } if empty && groups.any?
           build_result(rows, complete: complete, recognized: empty || (header && groups.any?), issues: issues, identity: %i[group member])

data/lib/ctx_checker/cisco_ios/parsers/show_facility_alarm_status.rb

@@ -11,7 +11,7 @@ module CtxChecker
 
         # 解析 show facility alarm status，保留不完整或不支持的证据。
         def parse_output(text, complete:)
-          records, issues, totals, severities = [], [], [], []
+          records, issues, totals, severities = [], diagnostics, [], []
           clean(text).each_line.with_index(1) do |source, number|
             line = source.strip
             next if line.empty? || /\A[- ]+\z/.match?(line) || /\ASource\s+(?:Time\s+)?Severity\s+/.match?(line)

data/lib/ctx_checker/cisco_ios/parsers/show_interfaces.rb

@@ -2,7 +2,7 @@
 
 require_relative "../../parsers/base"
 require_relative "../../parsers/interface_names"
-require "ctx_parser/result_set"
+require "ctx_parser/results"
 
 module CtxChecker
   module CiscoIos
@@ -23,22 +23,24 @@ module CtxChecker
         # 分别跟踪覆盖率；有效状态头不能证明计数器已采集。
         def parse_output(text, complete:)
           text = clean(text)
-          interfaces, counters, state_issues, counter_issues = [], [], [], []
+          interfaces, counters, state_issues, counter_issues = [], [], diagnostics, diagnostics
           current = nil
+          states = {}
           text.each_line.with_index(1) do |source, number|
             line = source.strip
             next if line.empty?
 
             if (match = interface_header(line))
               current = interface_record(match)
+              states = current.slice(:admin_status, :protocol_status).transform_values { |value| value == :unknown ? [] : [ value ] }
               interfaces << current
             elsif (match = /\A(\S+) is /.match(line)) && CtxChecker::Parsers::InterfaceNames.kind(normalize_name(match[1])) != :unknown
               current = nil
               state_issues << { code: :unparsed_interface_header, line: number }
             elsif current && (match = /\Aadmin state is (up|down)\b/i.match(line))
-              current[:admin_status] = match[1].downcase.to_sym
+              assign_state(current, :admin_status, match[1].downcase.to_sym, states, state_issues, number)
             elsif current && (match = /\ALine protocol is (up|down)\b/i.match(line))
-              current[:protocol_status] = match[1].downcase.to_sym
+              assign_state(current, :protocol_status, match[1].downcase.to_sym, states, state_issues, number)
             elsif current && (match = /\ALast clearing of "show interfaces?" counters\s+(.+)\z/i.match(line))
               # 相对清零时长不能证明两个采样间的计数器连续性。
               current[:discontinuity] = nil
@@ -84,13 +86,25 @@ module CtxChecker
           interfaces.select { |record| record[:kind] == :physical }.each do |record|
             counters.concat(complete_counter_coverage(record, counters_by_interface.fetch(record[:name], []), counter_issues))
           end
-          CtxParser::ResultSet.new(results: {
+          CtxParser::Results.new(by_dimension: {
             interfaces: build_result(interfaces, complete: complete, recognized: interfaces.any?, issues: state_issues, identity: [ :name ]),
             counters: build_result(counters, complete: complete, recognized: counters.any?, issues: state_issues + counter_issues,
               identity: %i[interface metric])
           })
         end
 
+        # 冲突协议状态保留 down；冲突管理状态不能据此豁免接口检查。
+        def assign_state(record, field, value, states, issues, number)
+          values = states.fetch(field)
+          values << value unless values.include?(value)
+          record[field] = if values.size > 1
+            issues << { code: :conflicting_interface_state, field: field, interface: record[:name], line: number }
+            field == :protocol_status ? :down : :unknown
+          else
+            value
+          end
+        end
+
         # 按计数器标签匹配，不误取总包数，并保留格式错误的指标行。
         def counter_line?(line)
           line.match?(/\b(?:input errors?|output errors?|CRC(?:\/FCS)?|input discards?|output discards?|Total output drops)\b/i) ||

data/lib/ctx_checker/cisco_ios/parsers/show_interfaces_transceiver_detail.rb

@@ -16,7 +16,7 @@ module CtxChecker
         # 解析 show interfaces transceiver detail，保留不完整或不支持的证据。
         def parse_output(text, complete:)
           text = clean(text)
-          rows, issues, ports = [], [], []
+          rows, issues, ports = [], diagnostics, []
           metric, header, lane_column = nil, false, false
           text.each_line.with_index(1) do |source, number|
             line = source.strip
@@ -48,11 +48,12 @@ module CtxChecker
               issues << { code: :unparsed_row, line: number }
             end
           end
+          measurements = rows.to_h { |row| [ row.values_at(:interface, :lane, :metric), true ] }
           identities = rows.map { |row| row.values_at(:interface, :lane) }
           identities.concat((ports.uniq - rows.map { |row| row[:interface] }).map { |name| [ name, nil ] })
           identities.uniq.each do |name, lane|
             %i[tx_power rx_power].each do |expected|
-              next if rows.any? { |row| row.values_at(:interface, :lane, :metric) == [ name, lane, expected ] }
+              next if measurements.key?([ name, lane, expected ])
 
               issues << { code: :optical_measurement_missing, interface: name, lane: lane, metric: expected }
             end

data/lib/ctx_checker/cisco_ios/parsers/show_ip_bgp_summary.rb

@@ -19,7 +19,7 @@ module CtxChecker
         # 使用作用域与行身份，避免不同地址族或 VRF 相互覆盖。
         def parse_output(text, complete:)
           text = clean(text).gsub(/State\/\s*\n\s*PfxRcd/, "State/PfxRcd")
-          rows, issues = [], []
+          rows, issues = [], diagnostics
           scope = { vrf: "default", afi_safi: self.class::ADDRESS_FAMILY }
           sections = []
           section = { header: false, empty: false, count: 0, scope_fields: [], scope: scope }
@@ -46,7 +46,7 @@ module CtxChecker
               section[:empty] = true
             elsif parse_statistics(line, section, scope, issues, number)
               next
-            elsif CtxParser::Values.valid_host?(line)
+            elsif CtxParser::Values.ip_address?(line)
               issues << { code: :unparsed_row, line: number - 1 } if pending
               pending = line
             elsif peer_row?(line) || (pending && line.match?(/\A4\s/))
@@ -77,7 +77,7 @@ module CtxChecker
         end
 
         # 识别协议对等体记录，排除摘要和表头。
-        def peer_row?(line) = CtxParser::Values.valid_host?(line.split.first.to_s)
+        def peer_row?(line) = CtxParser::Values.ip_address?(line.split.first.to_s)
 
         # 解析单个路由作用域，不合并无关的 VRF 证据。
         def parse_scope(line, scope, issues, number)
@@ -124,7 +124,7 @@ module CtxChecker
         # 归一化单个路由对等体及其协议状态。
         def parse_peer(line, scope)
           match = /\A(\S+)\s+4\s+(\d+(?:\.\d+)?)\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\S+\s+(.+)\z/.match(line)
-          return unless match && CtxParser::Values.valid_host?(match[1])
+          return unless match && CtxParser::Values.ip_address?(match[1])
 
           remote_as = as_number(match[2])
           return unless remote_as
@@ -132,7 +132,7 @@ module CtxChecker
           state, prefixes = peer_state(match[3])
           return unless state
 
-          scope.merge(peer: CtxParser::Values.host(match[1]), state: state, received_prefixes: prefixes, remote_as: remote_as)
+          scope.merge(peer: CtxParser::Values.ip_address(match[1]), state: state, received_prefixes: prefixes, remote_as: remote_as)
         end
 
         # 仅在不存在平台附加标记时，末列数字才能证明会话已建立。

data/lib/ctx_checker/cisco_ios/parsers/show_ip_ospf_neighbor.rb

@@ -19,7 +19,7 @@ module CtxChecker
         # 解析 show ip ospf neighbor，保留不完整或不支持的证据。
         def parse_output(text, complete:)
           text = clean(text)
-          rows, issues = [], []
+          rows, issues = [], diagnostics
           scope = { vrf: "default", process_id: nil, area: nil }
           sections = []
           section = { header: false, empty: false, count: 0, totals: [], declared: false, scope: scope }
@@ -81,14 +81,14 @@ module CtxChecker
             ipv4_address?(match[1]) && ipv4_address?(match[5])
 
           scope.merge(interface: CtxChecker::Parsers::InterfaceNames.normalize(match[6], platform: self.class::PLATFORM),
-            router_id: CtxParser::Values.host(match[1]), neighbor_address: CtxParser::Values.host(match[5]),
+            router_id: CtxParser::Values.ip_address(match[1]), neighbor_address: CtxParser::Values.ip_address(match[5]),
             state: STATES.fetch(match[3].upcase), network_type: :unknown, local_role: :unknown,
             neighbor_role: match[4] == "-" ? :unknown : match[4].downcase.to_sym)
         end
 
         # OSPFv2 路由器 ID 与接口地址必须是 IPv4 主机地址。
         def ipv4_address?(text)
-          text.match?(/\A\d+(?:\.\d+){3}\z/) && CtxParser::Values.valid_host?(text)
+          text.match?(/\A\d+(?:\.\d+){3}\z/) && CtxParser::Values.ip_address?(text)
         end
       end
     end

data/lib/ctx_checker/cisco_ios/parsers/show_ip_traffic.rb

@@ -28,7 +28,7 @@ module CtxChecker
 
         # 解析 show ip traffic，保留不完整或不支持的证据。
         def parse_output(text, complete:)
-          records, issues = [], []
+          records, issues = [], diagnostics
           active = false
           recognized = false
           clean(text).each_line.with_index(1) do |source, number|

data/lib/ctx_checker/cisco_ios/parsers/show_memory_statistics.rb

@@ -11,7 +11,7 @@ module CtxChecker
 
         # 解析 show memory statistics，保留不完整或不支持的证据。
         def parse_output(text, complete:)
-          records, issues = [], []
+          records, issues = [], diagnostics
           clean(text).each_line.with_index(1) do |source, number|
             line = source.strip
             next if line.empty? || /\AHead\s+Total\(b\)/.match?(line) || /\ATracekey\s*:\s*[\da-f#]+\z/i.match?(line)

data/lib/ctx_checker/cisco_ios/parsers/show_ntp_status.rb

@@ -15,7 +15,7 @@ module CtxChecker
 
         # 解析 show ntp status，保留不完整或不支持的证据。
         def parse_output(text, complete:)
-          records, issues = [], []
+          records, issues = [], diagnostics
           clean(text).each_line.with_index(1) do |source, number|
             line = source.strip
             next if line.empty?

data/lib/ctx_checker/cisco_ios/parsers/show_processes_cpu.rb

@@ -14,7 +14,7 @@ module CtxChecker
 
         # 解析 show processes cpu，保留不完整或不支持的证据。
         def parse_output(text, complete:)
-          records, issues = [], []
+          records, issues = [], diagnostics
           recognized = false
           clean(text).each_line.with_index(1) do |source, number|
             line = source.strip

data/lib/ctx_checker/cisco_ios/profile.rb

@@ -18,7 +18,7 @@ module CtxChecker
   module CiscoIos
     # IOS 与 IOS-XE 共用命令契约；型号特有语法通过解析器覆盖。
     class Profile < CtxParser::Profile
-      CATALOG = CtxParser::CommandCatalog.new([
+      DECLARATIONS = CtxParser::Commands.new([
         { dimensions: %i[interfaces counters], command: "show interfaces", parser: Parsers::ShowInterfaces },
         { dimensions: [ :aggregation ], command: "show etherchannel summary", parser: Parsers::ShowEtherchannelSummary },
         { dimensions: [ :optics ], command: "show interfaces transceiver detail", parser: Parsers::ShowInterfacesTransceiverDetail },
@@ -32,8 +32,8 @@ module CtxChecker
         { dimensions: [ :alarms ], command: "show facility-alarm status", parser: Parsers::ShowFacilityAlarmStatus },
         { dimensions: [ :device_counters ], command: "show ip traffic", parser: Parsers::ShowIpTraffic }
       ])
-      COMMANDS = CATALOG.commands
-      PARSERS = CATALOG.parsers
+      COMMANDS = DECLARATIONS.by_dimension
+      PARSERS = DECLARATIONS.parsers
     end
   end
 end

data/lib/ctx_checker/cisco_nxos/parsers/show_environment.rb

@@ -2,7 +2,7 @@
 
 require_relative "../../parsers/base"
 require_relative "../../cisco_ios/parsers/system_values"
-require "ctx_parser/result_set"
+require "ctx_parser/results"
 
 module CtxChecker
   module CiscoNxos
@@ -18,7 +18,7 @@ module CtxChecker
         # 解析 show environment，保留不完整或不支持的证据。
         def parse_output(text, complete:)
           @rows = { temperature: [], environment: [], power: [] }
-          @problems = @rows.transform_values { [] }
+          @problems = @rows.transform_values { diagnostics }
           @section = nil
           @section_size = 0
           @power_columns = nil
@@ -34,7 +34,7 @@ module CtxChecker
             (dimension ? [ @problems[dimension] ] : @problems.values).each { |issues| issues << unparsed(number) }
           end
           finish_section
-          CtxParser::ResultSet.new(results: @rows.to_h do |dimension, rows|
+          CtxParser::Results.new(by_dimension: @rows.to_h do |dimension, rows|
             identity = dimension == :temperature ? [ :component ] : %i[component kind]
             [ dimension, build_result(rows, complete: complete, recognized: rows.any?, issues: @problems[dimension], identity: identity) ]
           end)