@cannbot-plugin/cannbot-harness 0.0.0-stage → 0.1.5

package/assets/ops-direct-invoke/skills/ops-spec-gen/examples/softmax/spec.yaml

@@ -0,0 +1,231 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+
+# ============================================================
+# softmax — L0 数学约束 spec
+# 教学点：reduction_composite 自动注入（dim attribute / accumulator_dtype / composition / 数值稳定技巧）
+#         + 三类 invariant 综合使用（value 组的 elementwise_ge/le、reduce_equals + structural 的 no_leak）
+#         + 数值稳定性 anti_pattern_id 联动（AP-004：缺 max-shift 必触发）
+# ============================================================
+schema_version: 1
+
+op:
+  name: softmax
+  version: "1.0"
+  description: "Softmax along reduce_axis with max-shift stabilization"
+  category: ReductionComposite
+  paradigms: [Reduction, Broadcast, NumericalStable, FusedComposite]
+  paradigm_groups:
+    - kind: fusion
+      paradigms: [Reduction, Broadcast]
+  lifecycle: stable
+  error_codes:
+    - null_input
+    - attribute_value_out_of_range
+  platform_constraints:
+    supported_chips: [Ascend910B]
+    requires_hccl: false
+
+inputs:
+  - name: x
+    role: tensor
+    dtype_set: [float16, float32, bfloat16]
+    rank_range: [0, 8]
+    layout: ND
+    data_distribution: normal
+    shape:
+      symbolic: ["...d"]
+    contiguous: optional
+
+# Reduction 范式自动注入约束：必须有 axis/dim/axes 之一
+attributes:
+  - name: dim
+    type: int64
+    default: -1
+    semantics: "归约轴；负值按 Python 风格折算"
+    machine_constraint:
+      kind: int_in_range_relative_to_rank
+      target: x
+      lower_inclusive: "-rank(x)"
+      upper_exclusive: "rank(x)"
+
+outputs:
+  - name: y
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      y.shape = x.shape
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      y.dtype = x.dtype
+    layout: ND
+    aliasing: none
+
+shape_constraints:
+  symbols: {}                 # 折叠维 ...d 不需要登记
+  global_constraints:
+    - "rank(x) <= 8"
+
+# reduction_composite 触发：accumulator_dtype 必填，且必须 ≥ fp32
+dtype_policy:
+  promotion: same_as_first_input
+  supported_combinations:
+    - {inputs: {x: float16},  outputs: {y: float16}}
+    - {inputs: {x: float32},  outputs: {y: float32}}
+    - {inputs: {x: bfloat16}, outputs: {y: bfloat16}}
+  accumulator_dtype: float32
+
+broadcast:
+  kind: none
+
+math_semantics:
+  formula_kind: numpy_expr
+  formula: |
+    m = x.max(axis=dim, keepdims=True)
+    e = np.exp(x - m)
+    y = e / e.sum(axis=dim, keepdims=True)
+
+  reference_oracle:
+    framework: torch
+    api: torch.nn.functional.softmax
+    kwargs: {dim: "${attr.dim}"}            # 占位符按当前 case 的 dim 实际值替换
+    available_for_dtype: [float16, float32, bfloat16]
+    absent: false
+
+  invariants:
+    # value 组：值域下界
+    - name: nonneg
+      kind: elementwise_ge
+      value: 0.0
+    # value 组：值域上界
+    - name: bounded_above
+      kind: elementwise_le
+      value: 1.0
+    # value 组：归一化语义（核心 invariant，oracle 也未必能严格捕捉到）
+    - name: sum_to_one
+      kind: reduce_equals
+      reducer: sum
+      axis: "${attr.dim}"
+      value: 1.0
+      tolerance_inherit: true
+    # structural 组：composition 中间 tensor 不外漏
+    - name: no_leak
+      kind: no_leak_intermediates
+      tolerance_inherit: false
+
+  # FusedComposite 范式必填：把 formula 拆成白盒原语序列
+  composition:
+    primitives:
+      - id: max_reduce
+        op: reduce                            # 必须在 PRIMITIVE_WHITELIST 内
+        inputs: [x]
+        outputs: [m]
+      - id: subtract
+        op: elementwise_binary
+        inputs: [x, m]
+        outputs: [shifted]
+      - id: exp
+        op: elementwise_unary
+        inputs: [shifted]
+        outputs: [e]
+      - id: sum_reduce
+        op: reduce
+        inputs: [e]
+        outputs: [s]
+      - id: divide
+        op: elementwise_binary
+        inputs: [e, s]
+        outputs: [y]
+    dataflow:
+      intermediates: [m, shifted, e, s]       # 不可出现在 outputs，否则 stage 2 FAIL
+      no_leak: true
+      fusable_groups:
+        - [max_reduce, subtract, exp, sum_reduce, divide]
+
+# NumericalStable 范式必填：required==true 且 techniques 非空
+numerical_stability:
+  required: true
+  techniques:
+    - name: max_subtraction
+      applies_to: "exp 之前减去 reduce 轴最大值"
+      rationale: "避免 fp16 下 exp 溢出（fp16 上限约 6.5e4）"
+      anti_pattern_id: AP-004                  # 缺此技巧的实现触发 critical
+  affects_invariants: false
+
+numerical_tolerance:
+  source: "ops-precision-standard/float_compute_community.md"
+  per_dtype:
+    float32:  {rtol: 1.0e-4, atol: 1.0e-4, metric: max_relative}
+    float16:  {rtol: 1.0e-3, atol: 1.0e-3, metric: max_relative}
+    bfloat16: {rtol: 4.0e-3, atol: 4.0e-3, metric: max_relative}
+
+boundary_conditions:
+  - case: "reduce 轴长度为 1"
+    tags: [reduce_axis_size_1]
+    synthesize: {x.shape: "[1]", attr.dim: 0}
+    machine_check: {kind: equals, value: 1.0}
+  - case: "rank=0 标量输入"
+    tags: [rank_zero_scalar]
+    synthesize: {x.shape: "[]", attr.dim: 0}
+    machine_check: {kind: equals, value: 1.0}
+  - case: "空 Tensor"
+    tags: [empty_tensor]
+    synthesize: {x.shape: "[0, 4]", attr.dim: -1}
+    machine_check: {kind: returns_empty}
+  - case: "dim 越界（负向）"
+    synthesize: {x.shape: "[2, 3]", attr.dim: -3}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+  - case: "dim 越界（正向）"
+    synthesize: {x.shape: "[2, 3]", attr.dim: 2}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+
+extreme_inputs:
+  - case: "含单个 NaN（按行传播）"
+    synthesize:
+      shapes: {x: "[1, 8]"}
+      attrs: {dim: -1}
+      patterns:
+        - {pattern: inject_nan_one_element, target: x}
+    machine_check: {kind: produces_nan, scope: "整行"}
+
+  - case: "含单个 +inf → 该位置=1，其余=0"
+    synthesize:
+      shapes: {x: "[1, 8]"}
+      attrs: {dim: -1}
+      patterns:
+        - {pattern: single_pos_inf, target: x}
+    machine_check: {kind: matches_oracle}
+
+  - case: "全 -inf → exp 全 0 → 0/0 = NaN"
+    synthesize:
+      shapes: {x: "[1, 8]"}
+      attrs: {dim: -1}
+      patterns:
+        - {pattern: all_neg_inf, target: x}
+    machine_check: {kind: produces_nan, scope: "整行"}
+
+  - case: "全相同值 → 均匀分布 1/N"
+    synthesize:
+      shapes: {x: "[1, 8]"}
+      attrs: {dim: -1}
+      patterns:
+        - {pattern: "all_same(3.14)", target: x}
+    machine_check: {kind: matches_oracle}
+
+  - case: "fp16 上溢边界（验证 max_subtraction 是否生效）"
+    synthesize:
+      shapes: {x: "[1, 8]"}
+      attrs: {dim: -1}
+      patterns:
+        - {pattern: "all_same(60000.0)", target: x}
+      dtype: float16
+    machine_check: {kind: matches_invariant, name: sum_to_one}   # 即便 oracle 也可能 NaN，靠 invariant 兜底
+
+determinism:
+  required: true
+  accumulation_order: stable_in_axis
+  bitwise_reproducible: true

package/assets/ops-direct-invoke/skills/ops-spec-gen/examples/split/spec.yaml

@@ -0,0 +1,160 @@
+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
+# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+# CANN Open Software License Agreement Version 2.0 (the "License").
+# Please refer to the License for details. You may not use this file except in compliance with the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+# INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE in the root of the software repository for the full text of the License.
+
+# ============================================================
+# split — L0 数学约束 spec
+# 教学点：VariableOutput + output_count_determined_by=attribute
+#         （属性决定多输出：split_size 决定输出个数与 shape，区别于 nonzero 这类"数据决定输出个数"）
+#         + list[int64] 属性（split_size）注入 formula/shape_rule 沙箱
+#         v1: dim=0 连续切分，固定 2 段输出（y0/y1）
+# ============================================================
+schema_version: 1
+
+op:
+  name: split
+  version: "1.0"
+  description: "Split x along dim by split_size array (v1: dim=0, 2 outputs)"
+  category: VariableOutput
+  paradigms: [VariableOutput]
+  output_count_determined_by: attribute   # 关键：输出个数由属性决定，豁免 data_dependent_shape 与 nonzero 类 boundary
+  lifecycle: stable
+  error_codes:
+    - null_input
+    - attribute_value_out_of_range
+  platform_constraints:
+    supported_chips: [Ascend910B]
+    requires_hccl: false
+
+inputs:
+  - name: x
+    role: tensor
+    dtype_set: [float16, float32]
+    rank_range: [1, 8]
+    layout: ND
+    shape:
+      symbolic: [4, 8]
+    contiguous: optional
+
+attributes:
+  - name: dim
+    type: int64
+    default: 0
+    semantics: "切分轴；v1 仅支持 dim=0（连续切分）"
+    machine_constraint:
+      kind: int_in_range_relative_to_rank
+      target: x
+      lower_inclusive: "-rank(x)"
+      upper_exclusive: "rank(x)"
+  - name: split_size
+    type: list[int64]
+    default: [2, 2]
+    semantics: "各段大小数组，Σ == x.shape[dim]；v1 固定 2 段"
+    machine_constraint:
+      kind: list_of_int_in_range
+      target: x
+      lower_inclusive: 1
+
+outputs:
+  - name: y0
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      y0.shape = list(x.shape); y0.shape[dim] = split_size[0]
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      y0.dtype = x.dtype
+    layout: ND
+    aliasing: none
+  - name: y1
+    shape_rule_kind: numpy_expr
+    shape_rule: |
+      y1.shape = list(x.shape); y1.shape[dim] = x.shape[dim] - split_size[0]
+    dtype_rule_kind: numpy_expr
+    dtype_rule: |
+      y1.dtype = x.dtype
+    layout: ND
+    aliasing: none
+
+shape_constraints:
+  symbols: {}
+  global_constraints:
+    - "rank(x) <= 8"
+    - "sum(split_size) == x.shape[dim]"
+
+dtype_policy:
+  promotion: same_as_first_input
+  supported_combinations:
+    - {inputs: {x: float16}, outputs: {y0: float16, y1: float16}}
+    - {inputs: {x: float32}, outputs: {y0: float32, y1: float32}}
+
+broadcast:
+  kind: none
+
+math_semantics:
+  formula_kind: numpy_expr
+  formula: |
+    # dim=0 连续切分；split_size（list）注入沙箱后按下标取值
+    s0 = int(split_size[0])
+    y0 = x[:s0]
+    y1 = x[s0:]
+
+  reference_oracle:
+    framework: torch
+    api: torch.split
+    kwargs: {split_size_or_sections: "${attr.split_size}", dim: "${attr.dim}"}
+    available_for_dtype: [float16, float32]
+    absent: false
+
+  invariants: []
+
+numerical_stability:
+  required: false
+  techniques: []
+  affects_invariants: false
+
+numerical_tolerance:
+  source: "ops-precision-standard/float_compute_community.md"
+  per_dtype:
+    float32: {rtol: 0.0e+0, atol: 0.0e+0, metric: bitwise_equal}
+    float16: {rtol: 0.0e+0, atol: 0.0e+0, metric: bitwise_equal}
+
+boundary_conditions:
+  - case: "等分切分"
+    tags: [equal_split]
+    synthesize: {x.shape: "[4, 8]", attr.dim: 0, attr.split_size: "[2,2]"}
+    machine_check: {kind: matches_oracle}
+  - case: "不等分切分"
+    tags: [unequal_split]
+    synthesize: {x.shape: "[4, 8]", attr.dim: 0, attr.split_size: "[1,3]"}
+    machine_check: {kind: matches_oracle}
+  - case: "dim 越界"
+    synthesize: {x.shape: "[2, 3]", attr.dim: 5, attr.split_size: "[1,1]"}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+  - case: "Σ split_size ≠ shape[dim]"
+    synthesize: {x.shape: "[4, 8]", attr.dim: 0, attr.split_size: "[1,1]"}
+    machine_check: {kind: raises_error, error_type: attribute_value_out_of_range}
+
+extreme_inputs:
+  - case: "含 NaN 输入"
+    synthesize:
+      shapes: {x: "[4, 8]"}
+      attrs: {dim: 0, split_size: "[2,2]"}
+      patterns:
+        - {pattern: inject_nan_one_element, target: x}
+    machine_check: {kind: matches_oracle}
+  - case: "含 inf 输入"
+    synthesize:
+      shapes: {x: "[4, 8]"}
+      attrs: {dim: 0, split_size: "[2,2]"}
+      patterns:
+        - {pattern: single_pos_inf, target: x}
+    machine_check: {kind: matches_oracle}
+
+determinism:
+  required: true
+  accumulation_order: stable_in_axis
+  bitwise_reproducible: true

package/assets/ops-direct-invoke/skills/ops-spec-gen/references/accumulation_order.md

@@ -0,0 +1,63 @@
+# `determinism.accumulation_order` 语义定义
+
+> `spec.yaml` 中 `determinism.accumulation_order` + `bitwise_reproducible` 的规范来源。
+> 枚举值定义于 spec 层（非 regbase 范式原生术语），语义映射见本文档。
+> 枚举见 `schemas/op-spec.json`: `["stable_in_axis", "tree", "sequential", "none"]`。
+
+## 0. 三个维度
+
+| 维度 | 回答的问题 | 控制字段 | 备注 |
+|------|-----------|---------|------|
+| **A. 累加顺序** | 跨核切分后 partial 按何种顺序合并？ | `accumulation_order` | |
+| **B. kernel 自身可复现性** | 同输入同设备多次执行 kernel，结果是否 bitwise 一致？ | `bitwise_reproducible` | 当前 scope 内可由 A 推导（stable_in_axis/sequential/none → `true`） |
+| **C. 数值容差** | 浮点累加顺序位差用多大容差吸收？ | `numerical_tolerance.per_dtype` | |
+
+## 1. 枚举值
+
+### `stable_in_axis` —— 归约类
+
+归约轴（R）可跨核切分（regbase `reduce-split-strategy.md:12,32`：A 并行度不足时借 R 轴分核）；
+跨核时各核沿局部 R 段做 partial reduce 写 workspace，Phase 2 串联合并（`reduce-design-overview.md:229`）。
+范式 §3.3.11 指引：固定切分 + 固定累加顺序 → 同设备同输入多次执行 bitwise 可复现。
+具体切分策略（优先 A 轴 / A 并行度不足时借 R 轴走 Group 两阶段合并）由 regbase 范式按核数与并行度决定，见 `reduce-split-strategy.md` §零/§二，**不由本字段规定**。
+**不规定核内累加算法**（由 regbase `needs_bisection` 决定，见 §2）。
+
+适用：Reduction / ReductionComposite（sum/mean/max/min/prod 均适用）；ArgReduce 待对照其范式确认。
+
+### `tree` —— Contraction 类
+
+累加轴（如 matmul K 轴）可跨核切分，partial 按固定树形顺序合并。详见 Contraction 范式文档。
+
+### `sequential` —— Recurrence 类
+
+累加严格沿元素序列顺序，存在 inter-element 依赖，**禁止并行化累加轴**；batch/其他维度可自由切。
+适用：Recurrence（cumsum 等）。
+
+### `none` —— 无累加约束
+
+算子不涉及累加/规约。适用：Elementwise / Broadcast / LayoutTransform 等。
+
+## 2. 与 regbase 的关系
+
+`stable_in_axis`（维度 A）与 `needs_bisection`（regbase 实现层）**正交**：前者是 spec 层对累加顺序确定性的声明，后者决定核内累加算法（sum/mean→二分树，max/min/prod→线性，见 `patterns.md:83`），禁止强绑定。regbase `patterns.md §3.3.11`"固定切分 + 固定累加顺序 → bitwise 可复现"仅针对 `needs_bisection=true`（sum/mean）。
+
+## 3. 快速决策表
+
+| 算子类别 | accumulation_order | bitwise_reproducible | numerical_tolerance |
+|----------|-------------------|----------------------|---------------------|
+| Reduction sum/mean | `stable_in_axis` | `true` | 浮点非 0 容差 |
+| Reduction max/min/prod | `stable_in_axis` | `true` | max/min 0 容差；prod 浮点非 0 |
+| Recurrence (cumsum) | `sequential` | `true` | 顺序与 golden 一致→可 0 容差；否则非 0 |
+| Elementwise | `none` | `true` | 0 容差 |
+
+## 4. 常见错误
+
+1. R 轴跨核切分（Group 模板）时 partial 合并顺序未固定 → **HIGH**。
+2. 整数 dtype reduce（sum/mean/prod）不可假定 0 容差——regbase kernel 内部 Cast 到 fp32 累加，fp32 域结合律不成立 → **HIGH**（假定 0 容差而无依据）。
+   - `tolerance_defaults.yaml` 对 int32/int64 的默认值是 `bitwise_equal` + 0，`generate_spec.py` 对 reduction 类算子（Reduction / ReductionComposite）自动覆盖为 fp32 容差。
+   - **max/min 除外**（精确比较、不累加，保持 `bitwise_equal` + 0）。
+   - ArgReduce 输出是索引（离散精确值，不受 fp32 累加影响），保留 `bitwise_equal` + 0。
+   - 非生成器产出的 spec 须手动确保。
+3. 浮点 dtype reduce 用 0 容差 → **HIGH**。
+4. `stable_in_axis` 与 `needs_bisection=true` 强绑定（对 max/min/prod 误声明"二分缓存树"）→ **MED**。
+5. §9.10 泛写"固定切分"未引用具体 `accumulation_order` 值 → **MED**。

package/assets/ops-direct-invoke/skills/ops-spec-gen/references/error-codes.md

@@ -0,0 +1,199 @@
+# Validator rule_id 目录
+
+> 由 `scripts/dump_rule_ids.py` 自动生成；改动 validator 后跑 `--write` 同步。CI 由
+> `tests/test_doc_drift.py` 守门：源文件中的 rule_id 与本文件不一致即 fail。
+
+本目录列出 11-stage L0 校验器输出的所有 `rule_id` 字面量。新增 finding 时把字符串
+登记到对应 stage；若是 evaluator（numpy AST 求值器）内部抛 `DslError`，code 会在 stages.py 拼成
+`<stage>.<code>`，所以**新增 evaluator 错误码必须同时拓宽 SKILL.md §4.x 表**。
+
+## Stage 2 category_paradigm_consistency
+
+- `category_paradigm_consistency.broadcast_kind_requires_paradigm`
+- `category_paradigm_consistency.fused_composite_basics`
+- `category_paradigm_consistency.mutually_exclusive`
+- `category_paradigm_consistency.required_paradigm_missing`
+- `category_paradigm_consistency.shape_rule_broadcast_requires_paradigm`
+
+## Stage 2 paradigm_constraint
+
+- `paradigm_constraint.argreduce_dtype`
+- `paradigm_constraint.collective_hccl`
+- `paradigm_constraint.dataflow_unclosed`
+- `paradigm_constraint.dtype_chip_mismatch`
+- `paradigm_constraint.error_code_not_declared`
+- `paradigm_constraint.error_codes_undeclared`
+- `paradigm_constraint.fused_composite_composition_missing`
+- `paradigm_constraint.fused_composite_min_primitives`
+- `paradigm_constraint.intermediate_leak`
+- `paradigm_constraint.numerical_stable`
+- `paradigm_constraint.primitive_not_whitelisted`
+- `paradigm_constraint.quantization_attrs`
+- `paradigm_constraint.random_sampling_seed`
+- `paradigm_constraint.reduction_axis_missing`
+- `paradigm_constraint.stateful_state_or_inplace`
+- `paradigm_constraint.unknown_anti_pattern`
+- `paradigm_constraint.unknown_chip`
+- `paradigm_constraint.variable_output_flag`
+
+## Stage 2 invariant_kind_resolved
+
+- `invariant_kind_resolved.missing_field`
+- `invariant_kind_resolved.tolerance_inherit_forbidden`
+- `invariant_kind_resolved.tolerance_inherit_required`
+- `invariant_kind_resolved.unknown_kind`
+
+## Stage 2 interface_contract
+
+- `interface_contract.layout_contract_duplicate_tensor_ref`
+- `interface_contract.layout_contract_duplicate_variant_id`
+- `interface_contract.layout_contract_invalid_guard`
+- `interface_contract.layout_contract_rank_mismatch`
+- `interface_contract.layout_contract_ref_not_tensor`
+- `interface_contract.layout_contract_unknown_ref`
+- `interface_contract.list_length_cycle`
+- `interface_contract.list_length_expression`
+- `interface_contract.list_length_invalid_range`
+- `interface_contract.list_length_negative`
+- `interface_contract.list_length_non_list`
+- `interface_contract.list_length_ref_not_list`
+- `interface_contract.list_length_unexpected_field`
+- `interface_contract.list_length_unknown_ref`
+- `interface_contract.semantic_case_conflicting_members`
+- `interface_contract.semantic_case_conflicting_same_guard`
+- `interface_contract.semantic_case_duplicate_id`
+- `interface_contract.semantic_case_input_not_optional`
+- `interface_contract.semantic_case_invalid_guard`
+- `interface_contract.semantic_case_output_not_optional`
+- `interface_contract.semantic_case_unknown_member`
+- `interface_contract.tensor_list_length_missing`
+
+## Stage 3 shape_closure
+
+- `shape_closure.data_dependent_flag_missing`
+- `shape_closure.data_dependent_missing_bounds`
+- `shape_closure.data_dependent_missing_description`
+- `shape_closure.data_dependent_requires_variable_output`
+- `shape_closure.numpy_expr_formula_eval_error`
+- `shape_closure.numpy_expr_shape_mismatch`
+- `shape_closure.rank_overflow`
+- `shape_closure.reduction_shape_identity_suspicious`
+- `shape_closure.shape_rule_kind_missing`
+- `shape_closure.shape_rule_kind_unknown`
+- `shape_closure.shape_rule_placeholder`
+- `shape_closure.synthesize_parse_error`
+- `shape_closure.textual_only_requires_description`
+- `shape_closure.textual_only_requires_format_variants`
+- `shape_closure.unregistered_symbol`
+
+## Stage 4 dtype_closure
+
+- `dtype_closure.combination_mismatch`
+- `dtype_closure.combination_missing_output`
+- `dtype_closure.dtype_rule_kind_unknown`
+
+## Stage 6 boundary_min_set
+
+- `boundary_min_set.missing_required_case`
+
+## Stage 7 tolerance_coverage
+
+- `tolerance_coverage.tolerance_too_tight`
+- `tolerance_coverage.uncovered_output_dtype`
+
+## Stage 8 formula_smoke_eval
+
+- `formula_smoke_eval.dtype_mismatch_at_runtime`
+- `formula_smoke_eval.empty_formula`
+- `formula_smoke_eval.missing_output`
+- `formula_smoke_eval.no_combination`
+- `formula_smoke_eval.numpy_eval_error`
+- `formula_smoke_eval.numpy_not_installed`
+- `formula_smoke_eval.output_not_array`
+- `formula_smoke_eval.produces_unexpected_nan`
+- `formula_smoke_eval.skipped_non_numpy`
+- `formula_smoke_eval.syntax_error`
+
+## Stage 9 oracle_reachable
+
+- `oracle_reachable.absent`
+- `oracle_reachable.api_framework_mismatch`
+- `oracle_reachable.api_not_callable`
+- `oracle_reachable.api_not_found`
+- `oracle_reachable.composition_arg_unresolved`
+- `oracle_reachable.composition_id_collision`
+- `oracle_reachable.composition_id_shadows_input`
+- `oracle_reachable.composition_node_invalid`
+- `oracle_reachable.composition_output_unresolved`
+- `oracle_reachable.dtype_unsupported`
+- `oracle_reachable.framework_not_installed`
+- `oracle_reachable.incomplete`
+- `oracle_reachable.placeholder_unresolved`
+- `oracle_reachable.unknown_framework`
+
+## 其他 / 未归类
+
+- `composition_single_primitive`
+- `composition_without_fused_composite`
+- `error_type_unknown`
+- `machine_check_kind_unknown`
+- `schema_static`
+- `stage_skipped`
+- `synthesize_legacy_format`
+- `synthesize_pattern_unknown`
+- `data_distribution.accumulation_requires_normal`
+- `data_distribution.non_accumulation_must_omit`
+- `extreme_check.nan_propagates_violated`
+- `extreme_check.produces_nan_conflict`
+- `format_variants.oracle_kwargs_dim_mismatch`
+- `format_variants.reduction_axes_negative`
+- `format_variants.reduction_axes_out_of_rank`
+- `formula_oracle_equiv.absent`
+- `formula_oracle_equiv.api_unreachable`
+- `formula_oracle_equiv.composition_not_supported`
+- `formula_oracle_equiv.framework_import_error`
+- `formula_oracle_equiv.framework_not_installed`
+- `formula_oracle_equiv.incomplete_oracle`
+- `formula_oracle_equiv.inf_pattern_divergence`
+- `formula_oracle_equiv.nan_pattern_divergence`
+- `formula_oracle_equiv.no_combination`
+- `formula_oracle_equiv.no_test_inputs`
+- `formula_oracle_equiv.numpy_not_installed`
+- `formula_oracle_equiv.oracle_call_failed`
+- `formula_oracle_equiv.shape_mismatch`
+- `formula_oracle_equiv.skipped_non_numpy`
+- `formula_oracle_equiv.value_divergence`
+- `formula_oracle_equiv.zero_sign_divergence`
+- `invariant_exec.elementwise_eq_violated`
+- `invariant_exec.equals_input_when_other_is_zero_violated`
+- `invariant_exec.equals_under_swap_violated`
+- `invariant_exec.equals_when_input_is_zero_violated`
+- `invariant_exec.formula_no_output`
+- `invariant_exec.kind_not_executable`
+- `invariant_exec.no_combination`
+- `invariant_exec.no_inputs`
+- `invariant_exec.no_invariants`
+- `invariant_exec.numpy_not_installed`
+- `invariant_exec.produces_in_set_violated`
+- `invariant_exec.range_in_violated`
+- `invariant_exec.reduce_equals_unresolved`
+- `invariant_exec.reduce_equals_violated`
+- `invariant_exec.skipped_non_numpy`
+- `paradigm_groups.combination_missing_switch`
+- `paradigm_groups.combination_missing_when`
+- `paradigm_groups.combination_should_exist`
+- `paradigm_groups.fusion_min_basic`
+- `paradigm_groups.mismatch`
+- `paradigm_groups.mode_switch_may_need_combination`
+
+## Evaluator 错误码（`DslError(code, ...)`）
+
+以下错误码由 `scripts/evaluators/` 内部抛出，被 stage 3-5 / 8 / 9 包装为 `<stage>.<code>`。
+
+- `dsl_eval_error`
+- `dsl_parse_error`
+- `explicit_rules_uncovered`
+- `folded_dim_misuse`
+- `incompatible_dims`
+- `numpy_violation`
+- `unresolved_symbol`