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

package/assets/ops-direct-invoke/skills/ascendc-direct-invoke-template/references/matmul_blaze_template/test_matmul_blaze.cpp

@@ -0,0 +1,145 @@
+/**
+ * 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.
+ */
+
+#include <cstdint>
+#include <cstdlib>
+#include <exception>
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include "acl/acl.h"
+
+#include "common/acl_utils.h"
+#include "common/common_utils.h"
+#include "common/io_utils.h"
+#include "op_tiling/matmul_tiling_data.h"
+#include "op_tiling/matmul_tiling_stub.h"
+
+extern "C" void matmul_blaze_launch(
+    aclrtStream stream,
+    void* dA, void* dB, void* dScaleA, void* dScaleB, void* dC,
+    const QuantMatmulTilingData tilingData,
+    bool transA, bool transB);
+
+int RunMatmulBlaze(uint64_t m, uint64_t k, uint64_t n, bool transA, bool transB)
+{
+    constexpr int32_t deviceId = 0;
+    constexpr uint64_t MXFP_DIVISOR = 64;
+    constexpr uint64_t MXFP_MULTI_BASE = 2;
+
+    QuantMatmulTilingData tilingData;
+    MatmulTilingStub tilingEngine;
+    tilingEngine.GetTilingData(m, n, k, transA, transB, tilingData);
+
+    AclRtSession aclSession(deviceId);
+    aclSession.Init();
+    aclrtStream stream = aclSession.GetStream();
+
+    uint64_t sizeA = m * k;
+    uint64_t sizeB = k * n;
+    uint64_t sizeScaleA =
+        (m * CeilDiv(k, MXFP_DIVISOR) * MXFP_MULTI_BASE) * sizeof(uint8_t);
+    uint64_t sizeScaleB =
+        (n * CeilDiv(k, MXFP_DIVISOR) * MXFP_MULTI_BASE) * sizeof(uint8_t);
+    uint64_t sizeC = m * n * sizeof(bfloat16_t);
+
+    ExampleIoPaths paths = GetExampleIoPaths();
+
+    uint8_t* hA = nullptr;
+    uint8_t* hB = nullptr;
+    uint8_t* hScaleA = nullptr;
+    uint8_t* hScaleB = nullptr;
+    uint8_t* hC = nullptr;
+
+    CHECK_COND(aclrtMallocHost((void**)&hA, sizeA) == ACL_SUCCESS, "Failed to allocate host buffer for A.");
+    std::unique_ptr<void, aclError (*)(void*)> hostA(hA, aclrtFreeHost);
+    CHECK_COND(aclrtMallocHost((void**)&hB, sizeB) == ACL_SUCCESS, "Failed to allocate host buffer for B.");
+    std::unique_ptr<void, aclError (*)(void*)> hostB(hB, aclrtFreeHost);
+    CHECK_COND(aclrtMallocHost((void**)&hScaleA, sizeScaleA) == ACL_SUCCESS, "Failed to allocate host buffer for scaleA.");
+    std::unique_ptr<void, aclError (*)(void*)> hostScaleA(hScaleA, aclrtFreeHost);
+    CHECK_COND(aclrtMallocHost((void**)&hScaleB, sizeScaleB) == ACL_SUCCESS, "Failed to allocate host buffer for scaleB.");
+    std::unique_ptr<void, aclError (*)(void*)> hostScaleB(hScaleB, aclrtFreeHost);
+    CHECK_COND(aclrtMallocHost((void**)&hC, sizeC) == ACL_SUCCESS, "Failed to allocate host buffer for C.");
+    std::unique_ptr<void, aclError (*)(void*)> hostC(hC, aclrtFreeHost);
+
+    CHECK_COND(ReadExactFile(paths.inputDir + "/input_a.bin", hA, sizeA), "Failed to read input_a.bin.");
+    CHECK_COND(ReadExactFile(paths.inputDir + "/input_b.bin", hB, sizeB), "Failed to read input_b.bin.");
+    CHECK_COND(ReadExactFile(paths.inputDir + "/input_scaleA.bin", hScaleA, sizeScaleA), "Failed to read input_scaleA.bin.");
+    CHECK_COND(ReadExactFile(paths.inputDir + "/input_scaleB.bin", hScaleB, sizeScaleB), "Failed to read input_scaleB.bin.");
+
+    void* dAPtr = nullptr;
+    CHECK_COND(aclrtMalloc(&dAPtr, sizeA, ACL_MEM_MALLOC_HUGE_ONLY) == ACL_SUCCESS, "aclrtMalloc A failed.");
+    std::unique_ptr<void, aclError (*)(void*)> deviceA(dAPtr, aclrtFree);
+
+    void* dBPtr = nullptr;
+    CHECK_COND(aclrtMalloc(&dBPtr, sizeB, ACL_MEM_MALLOC_HUGE_ONLY) == ACL_SUCCESS, "aclrtMalloc B failed.");
+    std::unique_ptr<void, aclError (*)(void*)> deviceB(dBPtr, aclrtFree);
+
+    void* dScaleAPtr = nullptr;
+    CHECK_COND(aclrtMalloc(&dScaleAPtr, sizeScaleA, ACL_MEM_MALLOC_HUGE_ONLY) == ACL_SUCCESS, "aclrtMalloc scaleA failed.");
+    std::unique_ptr<void, aclError (*)(void*)> deviceScaleA(dScaleAPtr, aclrtFree);
+
+    void* dScaleBPtr = nullptr;
+    CHECK_COND(aclrtMalloc(&dScaleBPtr, sizeScaleB, ACL_MEM_MALLOC_HUGE_ONLY) == ACL_SUCCESS, "aclrtMalloc scaleB failed.");
+    std::unique_ptr<void, aclError (*)(void*)> deviceScaleB(dScaleBPtr, aclrtFree);
+
+    void* dCPtr = nullptr;
+    CHECK_COND(aclrtMalloc(&dCPtr, sizeC, ACL_MEM_MALLOC_HUGE_ONLY) == ACL_SUCCESS, "aclrtMalloc C failed.");
+    std::unique_ptr<void, aclError (*)(void*)> deviceC(dCPtr, aclrtFree);
+
+    CHECK_COND(aclrtMemcpyAsync(dAPtr, sizeA, hA, sizeA, ACL_MEMCPY_HOST_TO_DEVICE, stream) == ACL_SUCCESS, "memcpy A H2D failed.");
+    CHECK_COND(aclrtMemcpyAsync(dBPtr, sizeB, hB, sizeB, ACL_MEMCPY_HOST_TO_DEVICE, stream) == ACL_SUCCESS, "memcpy B H2D failed.");
+    CHECK_COND(aclrtMemcpyAsync(dScaleAPtr, sizeScaleA, hScaleA, sizeScaleA, ACL_MEMCPY_HOST_TO_DEVICE, stream) == ACL_SUCCESS, "memcpy scaleA H2D failed.");
+    CHECK_COND(aclrtMemcpyAsync(dScaleBPtr, sizeScaleB, hScaleB, sizeScaleB, ACL_MEMCPY_HOST_TO_DEVICE, stream) == ACL_SUCCESS, "memcpy scaleB H2D failed.");
+
+    matmul_blaze_launch(
+        stream,
+        dAPtr, dBPtr, dScaleAPtr, dScaleBPtr, dCPtr,
+        tilingData, transA, transB);
+
+    CHECK_COND(aclrtMemcpyAsync(hC, sizeC, dCPtr, sizeC, ACL_MEMCPY_DEVICE_TO_HOST, stream) == ACL_SUCCESS, "memcpy C D2H failed.");
+    CHECK_COND(aclrtSynchronizeStream(stream) == ACL_SUCCESS, "stream sync failed.");
+
+    CHECK_COND(WriteFile(paths.outputDir + "/npu_out.bin", hC, sizeC), "Failed to write npu_out.bin.");
+    return 0;
+}
+
+int main(int argc, char* argv[])
+{
+    uint64_t m = 16;
+    uint64_t k = 128;
+    uint64_t n = 16384;
+    bool transA = false;
+    bool transB = true;
+
+    try {
+        if (argc >= 4) {
+            m = ParsePositiveUint64(argv[1], "m");
+            k = ParsePositiveUint64(argv[2], "k");
+            n = ParsePositiveUint64(argv[3], "n");
+        }
+        if (argc >= 6) {
+            transA = (std::string(argv[4]) == "true");
+            transB = (std::string(argv[5]) == "true");
+        }
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << std::endl;
+        PrintUsage(argv[0]);
+        return 1;
+    }
+
+    try {
+        return RunMatmulBlaze(m, k, n, transA, transB);
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << std::endl;
+        return 1;
+    }
+}

package/assets/ops-direct-invoke/skills/ascendc-direct-invoke-template/references/matmul_blaze_template/test_matmul_blaze_torch.py

@@ -0,0 +1,141 @@
+#!/usr/bin/python3
+# coding=utf-8
+# ----------------------------------------------------------------------------------------------------------
+# 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.
+# ----------------------------------------------------------------------------------------------------------
+import math
+import os
+import sys
+
+os.environ["TORCH_DEVICE_BACKEND_AUTOLOAD"] = "0"
+
+import numpy as np
+import torch
+import torch_npu
+from en_dtypes import float8_e8m0
+from ml_dtypes import float8_e4m3fn
+
+SO_NAME = "libmatmul_blaze_ops.so"
+OP_NAME = "matmul_blaze"
+POINT_ERROR_TOL = 1e-1
+RATIO_POINT_ERROR_TOL = 1e-3
+ERROR_RATIO_TOL = 1e-3
+
+
+def build_scale_broadcast(scale, target_shape, chunk_axis):
+    scale_repeat = np.repeat(scale.astype(np.float32), 32, axis=-1)
+    if chunk_axis == 1:
+        scale_broadcast = scale_repeat.reshape(scale.shape[0], -1)[..., : target_shape[1]]
+    elif chunk_axis == 0:
+        scale_broadcast = np.transpose(scale_repeat, (0, 2, 1)).reshape(-1, scale.shape[1])[: target_shape[0], ...]
+    else:
+        raise ValueError(f"Invalid chunk_axis={chunk_axis}")
+    return scale_broadcast
+
+
+def dequant_mxfp8(fp8_input, scale, chunk_axis):
+    scale_broadcast = build_scale_broadcast(scale, fp8_input.shape, chunk_axis)
+    return fp8_input.astype(np.float32) * scale_broadcast
+
+
+def compute_golden(m, k, n, trans_a, trans_b):
+    a_shape = (k, m) if trans_a else (m, k)
+    a_ori = np.random.uniform(1, 8, a_shape).astype(float8_e4m3fn)
+
+    b_shape = (n, k) if trans_b else (k, n)
+    b_ori = np.random.uniform(1, 8, b_shape).astype(float8_e4m3fn)
+
+    a_scale_shape = (math.ceil(k / 64), m, 2) if trans_a else (m, math.ceil(k / 64), 2)
+    b_scale_shape = (n, math.ceil(k / 64), 2) if trans_b else (math.ceil(k / 64), n, 2)
+    a_scale = np.random.uniform(1, 8, size=a_scale_shape).astype(float8_e8m0)
+    b_scale = np.random.uniform(1, 8, size=b_scale_shape).astype(float8_e8m0)
+
+    a_chunk_axis = 0 if trans_a else 1
+    b_chunk_axis = 1 if trans_b else 0
+
+    a_dequant = dequant_mxfp8(a_ori, a_scale, a_chunk_axis)
+    b_dequant = dequant_mxfp8(b_ori, b_scale, b_chunk_axis)
+
+    a_matmul = np.swapaxes(a_dequant, -1, -2) if trans_a else a_dequant
+    b_matmul = np.swapaxes(b_dequant, -1, -2) if trans_b else b_dequant
+
+    golden = torch.matmul(torch.from_numpy(a_matmul), torch.from_numpy(b_matmul)).to(torch.bfloat16)
+
+    return a_ori, b_ori, a_scale, b_scale, golden
+
+
+def run_test(m, k, n, trans_a, trans_b):
+    a_ori, b_ori, a_scale, b_scale, golden = compute_golden(m, k, n, trans_a, trans_b)
+
+    a_t = torch.from_numpy(a_ori.view(np.uint8)).view(torch.float8_e4m3fn).to("npu")
+    b_t = torch.from_numpy(b_ori.view(np.uint8)).view(torch.float8_e4m3fn).to("npu")
+    sA_t = torch.from_numpy(a_scale.view(np.uint8)).to("npu")
+    sB_t = torch.from_numpy(b_scale.view(np.uint8)).to("npu")
+
+    op_fn = getattr(torch.ops.npu, OP_NAME)
+    c = op_fn(a_t, b_t, sA_t, sB_t, trans_a, trans_b)
+
+    diff = (c.cpu().float() - golden.float()).abs()
+    max_diff = diff.max().item()
+
+    rel_diff = diff / golden.float().abs().clamp_min(1e-8)
+    point_error_count = int((rel_diff > POINT_ERROR_TOL).sum().item())
+    error_count = int((diff > RATIO_POINT_ERROR_TOL).sum().item())
+    numel = m * n
+    error_ratio = error_count / numel if numel else 0.0
+
+    passed = point_error_count == 0 and error_ratio <= ERROR_RATIO_TOL
+    return passed, max_diff, error_ratio
+
+
+def parse_bool_arg(value, name):
+    normalized = str(value).strip().lower()
+    if normalized in ("1", "true", "t"):
+        return True
+    if normalized in ("0", "false", "f"):
+        return False
+    raise ValueError(f"Invalid {name}: {value}. Expected one of 0/1/true/false.")
+
+
+def main():
+    if len(sys.argv) not in (1, 4, 6):
+        print("Usage: python3 test_matmul_blaze_torch.py [m k n [transA transB]]")
+        print("Example: python3 test_matmul_blaze_torch.py 16 128 16384 false true")
+        sys.exit(1)
+
+    m = int(sys.argv[1]) if len(sys.argv) >= 4 else 16
+    k = int(sys.argv[2]) if len(sys.argv) >= 4 else 128
+    n = int(sys.argv[3]) if len(sys.argv) >= 4 else 16384
+    trans_a = parse_bool_arg(sys.argv[4], "transA") if len(sys.argv) >= 6 else False
+    trans_b = parse_bool_arg(sys.argv[5], "transB") if len(sys.argv) >= 6 else True
+
+    so_path = SO_NAME
+    if not os.path.exists(so_path):
+        so_path = os.path.join("build", SO_NAME)
+    if not os.path.exists(so_path):
+        print(f"ERROR: {SO_NAME} not found. Build matmul_blaze_ops first.")
+        sys.exit(1)
+    torch.ops.load_library(so_path)
+
+    print(f"Running torch test: M={m} K={k} N={n} transA={trans_a} transB={trans_b}")
+    passed, max_diff, error_ratio = run_test(m, k, n, trans_a, trans_b)
+
+    print(f"max abs diff: {max_diff}")
+    print(f"error ratio: {error_ratio:.6f}")
+    if passed:
+        print("[PASS] PyTorch results are consistent with CPU.")
+    else:
+        print(f"[FAIL] NPU results differ from CPU. "
+              f"Single-point relative error must be <= {POINT_ERROR_TOL}, "
+              f"and error ratio must be <= {ERROR_RATIO_TOL}.")
+    sys.exit(0 if passed else 1)
+
+
+if __name__ == "__main__":
+    main()

package/assets/ops-direct-invoke/skills/ascendc-docs-gen/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: ascendc-docs-gen
+description: Ascend C 算子文档写作参考。提供需求分析、详细设计、迭代计划、aclnnAPI接口文档、算子README的标准模板。当用户需要生成算子文档、aclnnAPI文档、算子README、参考文档模板或了解算子文档规范时触发此技能。
+---
+
+# Ascend C 算子文档写作指南
+
+## 概述
+
+本技能提供算子开发文档的写作标准和模板参考，覆盖开发过程文档和用户文档。
+
+## 文档类型
+
+| 文档类型 | 模板路径 | 输出位置 |
+|---------|---------|---------|
+| 需求分析 | [requirement-analysis-template.md](references/requirement-analysis-template.md) | `operators/{operator_name}/docs/REQUIREMENTS.md` |
+| 详细设计 | [detailed-design-template.md](references/detailed-design-template.md) | `operators/{operator_name}/docs/DESIGN.md` |
+| 迭代计划 | [iteration-plan-template.md](references/iteration-plan-template.md) | `operators/{operator_name}/docs/PLAN.md` |
+| aclnnAPI 接口文档 | [aclnn-api-doc-template.md](references/aclnn-api-doc-template.md) | `operators/{operator_name}/docs/aclnn{OperatorName}.md` |
+| 算子 README | [operator-readme-template.md](references/operator-readme-template.md) | `operators/{operator_name}/README.md` |
+
+## 使用方式
+
+- 生成文档时参考对应模板的结构和必填项
+- 根据实际算子特性调整内容
+
+## 文档关系
+
+```
+需求分析文档 ──[确认]──▶ 详细设计文档 ──▶ 迭代执行计划
+     │
+     ├──▶ aclnnAPI 接口文档（数据来源：需求文档的算子规格、API定义、约束部分）
+     │
+     └──▶ 算子 README（数据来源：需求文档+设计文档+代码）
+```
+
+## 核心规范
+
+### 文档命名
+
+- 需求分析：`REQUIREMENTS.md`
+- 详细设计：`DESIGN.md`
+- 迭代计划：`PLAN.md`
+- aclnnAPI 接口文档：`aclnn{OperatorName}.md`（如 `aclnnAdd.md`）
+- 算子 README：`README.md`
+
+### 版本管理
+
+- 文档需包含修订记录
+- 版本变更需记录修改人和修改内容
+
+### 设计锁定
+
+- 需求分析确认后锁定
+- 详细设计确认后锁定
+- 变更需经确认并更新文档

package/assets/ops-direct-invoke/skills/ascendc-docs-gen/evals/evals.json

@@ -0,0 +1,191 @@
+{
+  "eval_mode": "file_based",
+  "evals": [
+    {
+      "id": 1,
+      "title": "为 Add 算子生成需求分析文档",
+      "config": {
+        "max_tokens": 160000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 180000,
+          "glm-5": 200000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "file_based"
+      },
+      "prompt": "我需要开发一个 Add 算子，请帮我生成需求分析文档。算子规格如下：\n\n算子名称：Add\n数学公式：z = x + alpha * y（逐元素加法）\n输入：x fp16 [1024, 4096], y fp16 [1024, 4096]\n输出：z fp16 [1024, 4096]\n目标芯片：Ascend910B\n精度要求：fp16 双千分之一\n调用方式：ACLNN 调用\n\n请生成 REQUIREMENTS.md 文件。",
+      "expected_output": "生成的 REQUIREMENTS.md 应严格遵循需求分析模板结构，包含以下关键章节：\n\n- 修订记录表格（版本、修订内容、修订时间、修订人）\n- §1 需求背景：需求来源、基线对齐（框架API/论文公式/用户给定公式的勾选框）\n- §2 运行环境：服务器型号、芯片号、编译宏架构（DAV_*）\n- §3 调用方式表格：列出 ACLNN 调用、torch_npu 单算子、torch.compile 入图、GE 图模式等调用方式的支持情况\n- §4 算子规格：基本信息（算子名称、数学公式）、输入输出规格（x/y/z 的 shape 和 dtype）、数据类型支持（fp16/fp32/bfloat16/int8 勾选框）、精度要求\n- §5 ACLNN API 接口定义：两段式接口声明（aclnnAddGetWorkspaceSize + aclnnAdd）、参数说明表、约束与限制（类型推导规则、shape 约束、广播规则）\n- §8 约束与要求：计算约束",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 2,
+      "title": "为 Softmax 算子生成详细设计文档",
+      "config": {
+        "max_tokens": 200000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 240000,
+          "glm-5": 300000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "file_based"
+      },
+      "prompt": "我需要开发一个 Softmax 算子，请帮我生成详细设计文档。算子规格如下：\n\n算子名称：Softmax\n数学公式：softmax(x_i) = exp(x_i - max(x)) / sum(exp(x_j - max(x)))\n输入：x fp16 [1024, 4096]\n输出：y fp16 [1024, 4096]\n目标芯片：Ascend910B，架构 arch22\n算子类别：Reduction\n\n请生成 DESIGN.md 文件。",
+      "expected_output": "生成的 DESIGN.md 应严格遵循详细设计模板结构，包含以下关键章节：\n\n- §1 概述：基本信息表（算子名称、算子类别 Reduction、支持数据类型、目标芯片 Ascend910B、目标架构 arch22）、算子功能描述、数学公式\n- §2 架构设计：逻辑视图（op_api/op_host/op_kernel/op_graph 四个模块职责表和依赖关系）、开发视图（目录结构树）、运行视图（数据流 GM→UB→GM、执行流程 aclnnGetWorkspaceSize→aclnn 执行）\n- §3 实现方案：模板划分总览（TilingKey 机制、模板参数定义表、模板划分表）、TilingData 结构体定义、每个模板包含触发条件、Host 侧 Tiling 代码、Kernel 侧模板实例化代码、API 映射表（6列：计算步骤/Ascend C API/参数签名/平台验证/约束说明/替代方案）、API 验证记录表、数据流设计、内存管理表、UB 容量验证（DAV_2201 184KB 限制）\n- §4 性能优化：并行策略、流水线设计\n- §5 风险评估：API 风险、精度风险、应对措施\n- §6 交付件清单\n- §7 迭代规划表（迭代一/二/三的目标和代码开发/UT开发/ST用例）",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 3,
+      "title": "为 Add 算子生成迭代执行计划",
+      "config": {
+        "max_tokens": 160000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 150000,
+          "glm-5": 135000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "file_based"
+      },
+      "prompt": "我需要为 Add 算子制定迭代开发计划，请帮我生成迭代执行计划文档。算子规格如下：\n\n算子名称：Add\n支持数据类型：fp16, fp32\n目标芯片：Ascend910B\n模板划分：模板一（fp16 + small_shape）、模板二（fp32 + small_shape）、模板三（fp16 + large_shape 切分）\n\n请生成 PLAN.md 文件。",
+      "expected_output": "生成的 PLAN.md 应严格遵循迭代计划模板结构，包含以下关键章节：\n\n- 迭代一穿刺列表：表格形式（任务类型/TilingKey/Dtype/Memory Strategy），选择主要 dtype（fp16），包含主线 + 多个穿刺任务，注明并行要求（主线 + 穿刺必须同一次响应发起）\n- 迭代二整合目标：列出需要整合的 TilingKey\n- 迭代二穿刺列表：表格形式验证迭代三任务，包含验证目标\n- 迭代三全覆盖目标：覆盖全 dtype（fp16, fp32）、边界 case、广播用例\n- 穿刺结果判定表：成功/部分成功/失败的处理方式",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 4,
+      "title": "为 Add 算子生成 aclnnAPI 接口文档",
+      "config": {
+        "max_tokens": 400000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 352000,
+          "glm-5": 320000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "file_based"
+      },
+      "prompt": "我需要为 Add 算子编写 aclnnAPI 接口文档，请帮我生成。算子规格如下：\n\n算子名称：Add\n数学公式：out = self + alpha \\* other\n输入：self（aclTensor*）, other（aclTensor*）, alpha（aclScalar*）\n输出：out（aclTensor*）\n支持数据类型：FLOAT, FLOAT16, INT32, INT64, BFLOAT16 等\n支持产品：Ascend 950PR/950DT, Atlas A2, Atlas A3, Atlas 训练系列\n约束：self 和 other 需满足 broadcast 关系，数据类型需满足互推导关系\n\n请生成 aclnnAdd.md 文件。",
+      "expected_output": "生成的 aclnnAdd.md 应严格遵循 aclnnAPI 文档模板结构，包含以下关键章节：\n\n- 产品支持情况表：按固定产品顺序列出（Ascend 950PR/950DT、Atlas A3、Atlas A2、Atlas 200I/500 A2、Atlas 推理系列、Atlas 训练系列），用 √/× 标注支持情况\n- 功能说明：接口功能描述、计算公式（out = self + alpha * other）\n- 函数原型：两段式接口（aclnnAddGetWorkspaceSize 和 aclnnAdd），每行一个参数，参数对齐\n- aclnnAddGetWorkspaceSize 参数说明：8 字段参数表（参数名/输入输出/描述/使用说明/数据类型/数据格式/维度shape/非连续Tensor），使用说明中包含空 Tensor 支持度和数据类型推导规则引用\n- 返回值表：包含错误码（如 ACLNN_ERR_PARAM_NULLPTR 161001、ACLNN_ERR_PARAM_INVALID 161002）\n- aclnnAdd 第二段接口参数说明：workspace/workspaceSize/executor/stream\n- 约束说明：确定性说明（三选一格式）\n- 调用示例：标注编译运行参考路径",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 5,
+      "title": "为 Add 算子生成算子 README",
+      "config": {
+        "max_tokens": 350000,
+        "max_tokens_by_model": {
+          "deepseek-v4-flash": 350000,
+          "glm-5": 350000
+        },
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "file_based"
+      },
+      "prompt": "我需要为 Add 算子编写开源仓的 README 文档，请帮我生成。算子规格如下：\n\n算子名称：Add\n数学公式：y = x1 + alpha * x2\n输入：x1, x2（支持 FLOAT, FLOAT16, INT32, BFLOAT16 等）\n输出：y\n可选属性：alpha（默认值 1.0）\n支持产品：Ascend 950PR/950DT, Atlas A2, Atlas A3, Atlas 训练系列\n调用方式：aclnn 调用 + 图模式调用\n约束：无特殊约束\n\n请生成 README.md 文件。",
+      "expected_output": "生成的 README.md 应严格遵循算子 README 模板结构，包含以下关键章节：\n\n- 产品支持情况表：按固定产品顺序列出（含麒麟芯片行），用 √/× 标注\n- 功能说明：算子功能一句话描述、计算公式（y = x1 + alpha * x2）\n- 参数说明表：5 列表格（参数名/输入输出属性/描述/数据类型/数据格式），包含 x1、x2、alpha（可选属性）、y 四个参数，芯片差异说明（如 Atlas 训练系列不支持 BFLOAT16）\n- 约束说明：无特殊约束时写\"无\"\n- 调用说明：表格形式列出 aclnn 调用和图模式调用，链接到 examples 目录的样例代码\n- 参考资源（可选）：链接到算子设计文档",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 6,
+      "title": "信息不足时主动追问",
+      "config": {
+        "max_tokens": 160000,
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "帮我写个算子文档",
+      "expected_output": "回复应主动追问关键信息，而不是直接生成文档。应至少询问以下信息中的一项或多项：算子名称、数学公式/功能描述、输入输出规格（shape/dtype）、目标芯片/架构、需要生成哪种类型的文档（需求分析/详细设计/迭代计划/aclnnAPI/README）。不应在缺乏算子规格的情况下直接输出完整的文档模板内容。",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 7,
+      "title": "文档类型体系和命名规范知识验证",
+      "config": {
+        "max_tokens": 160000,
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "ascendc-docs-gen 支持哪些文档类型？每种文档的命名规范是什么？它们之间有什么关系？",
+      "expected_output": "回复应完整列出 5 种文档类型及其命名规范：\n\n- 需求分析文档：REQUIREMENTS.md\n- 详细设计文档：DESIGN.md\n- 迭代执行计划：PLAN.md\n- aclnnAPI 接口文档：aclnn{OperatorName}.md（如 aclnnAdd.md）\n- 算子 README：README.md\n\n应说明文档间的依赖关系：需求分析确认后产出详细设计，详细设计产出迭代计划；aclnnAPI 文档的数据来源于需求文档的算子规格、API 定义和约束部分；算子 README 的数据来源于需求文档、设计文档和代码。应提及文档存放位置（docs/ 目录或算子根目录）。",
+      "files": [],
+      "expectations": []
+    },
+    {
+      "id": 8,
+      "title": "需求变更后的文档更新与版本管理",
+      "config": {
+        "max_tokens": 160000,
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我之前已经为 Add 算子输出了一版需求分析文档 REQUIREMENTS.md（v1.0，已和设计评审确认过）。现在需求变更了：输入数据类型要从只支持 fp16 扩展到同时支持 fp16 和 fp32，对应的详细设计文档也需要跟着改。请告诉我更新这些文档时在版本管理上应该注意什么。",
+      "expected_output": "回复应覆盖版本管理规范要点：算子文档需包含修订记录（修订记录表格含版本、修订内容、修订时间、修订人）；需求变更后应新增一条修订记录并递增版本号（如 v1.0 → v1.1）；修订内容需明确记录\"输入数据类型扩展支持 fp16、fp32\"；版本变更需记录修改人和修改内容；同时应评估下游文档（详细设计 DESIGN.md、迭代计划 PLAN.md）是否需要同步更新。",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 9,
+      "title": "设计锁定后的变更处理流程",
+      "config": {
+        "max_tokens": 160000,
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我们的 Softmax 算子需求分析文档已经评审确认并锁定，详细设计也已经基于它完成。现在需求方提出要新增一个 axis 参数来控制按哪个维度做 softmax，这会改动需求规格和详细设计。这种情况应该怎么处理？",
+      "expected_output": "1. 回复应说明设计锁定与变更门槛：需求分析文档确认后即锁定、详细设计文档确认后即锁定；变更不得直接改动锁定文档，须经确认/评审批准后才更新。\n2. 回复应给出文档更新顺序：先更新需求分析文档中受影响的部分（算子规格/参数、API 定义、约束），重新确认后再同步更新详细设计文档。\n3. 回复应说明变更需在文档修订记录中登记（版本、修改人、修改内容），且 aclnnAPI 接口文档等下游文档需同步更新。",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 10,
+      "title": "aclnnAPI 接口文档的数据来源与关键章节",
+      "config": {
+        "max_tokens": 160000,
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我要为 LayerNorm 算子编写 aclnnAPI 接口文档（aclnnLayerNorm.md），但接口定义、参数约束这些内容我不确定该从哪里获取。帮我梳理一下写这份文档需要哪些输入资料，以及文档本身要包含哪些关键内容。",
+      "expected_output": "回复应覆盖 aclnnAPI 接口文档的写作要点：文档数据来源是需求分析文档的算子规格、API 定义和约束部分；文档输出位置为 operators/layernorm/docs/aclnnLayerNorm.md；接口采用两段式声明（先调用 aclnnLayerNormGetWorkspaceSize 获取 workspace 大小与执行器，再调用 aclnnLayerNorm 执行计算）；文档应包含产品支持情况表（按固定产品顺序用 √/× 标注）、函数原型、参数说明表（8 字段：参数名/输入输出/描述/使用说明/数据类型/数据格式/维度shape/非连续Tensor）、约束说明（含确定性说明三选一）、调用示例。",
+      "expectations": [],
+      "files": []
+    },
+    {
+      "id": 11,
+      "title": "算子 README 的数据来源与结构",
+      "config": {
+        "max_tokens": 160000,
+        "ascend_platforms": [
+          "A2"
+        ],
+        "eval_mode": "text"
+      },
+      "prompt": "我负责的 Exp 算子已经完成开发并合入开源仓，现在要为它编写算子 README 文档。请问写 README 需要参考哪些已有资料，README 里要包含哪些核心章节？",
+      "expected_output": "回复应覆盖算子 README 的写作要点：README 的数据来源是需求分析文档、详细设计文档和代码；输出位置为 operators/exp/README.md（算子根目录）；应包含产品支持情况表（按固定产品顺序用 √/× 标注）、功能说明（含计算公式）、参数说明表（5 列：参数名/输入输出属性/描述/数据类型/数据格式）、约束说明（无特殊约束时写\"无\"）、调用说明（表格列出 aclnn 调用和图模式调用，链接到 examples 目录样例代码），可包含参考资源链接到算子设计文档。",
+      "expectations": [],
+      "files": []
+    }
+  ],
+  "skill_name": "ascendc-docs-gen"
+}