@dtt_siye/atool 1.3.0 → 1.3.1

package/lib/pre-scan.sh

@@ -426,7 +426,7 @@ _extract_typescript() {
     local lang="typescript"
     [[ "$rel_path" == *.js || "$rel_path" == *.jsx ]] && lang="javascript"
 
-    # --- Imports ---
+    # --- Imports (enhanced with named symbols for cross-reference) ---
     local imports_json="[]"
     imports_json=$({ grep -n -E '^(import |const .* = require)' "$file" 2>/dev/null || true; } | awk -F: '
     {
@@ -435,20 +435,47 @@ _extract_typescript() {
         if (content ~ /^import /) {
             # ES module import
             source = ""
+            syms = "[]"
+            # Extract source path
             if (match(content, /from "[^"]*"/)) {
                 source = substr(content, RSTART+6, RLENGTH-7)
             } else if (match(content, /"[^"]*"/)) {
                 source = substr(content, RSTART+1, RLENGTH-2)
             }
+            # Extract named symbols from destructured import: import { X, Y } from ...
+            if (match(content, /\{[^}]+\}/)) {
+                brace = substr(content, RSTART+1, RLENGTH-2)
+                gsub(/^[[:space:]]+/, "", brace)
+                gsub(/[[:space:]]+$/, "", brace)
+                n = split(brace, parts, ",")
+                sym_arr = "["
+                for (i = 1; i <= n; i++) {
+                    gsub(/^[[:space:]]+/, "", parts[i])
+                    gsub(/[[:space:]]+$/, "", parts[i])
+                    gsub(/[[:space:]]+as[[:space:]]+.*/, "", parts[i])
+                    gsub(/=.*/, "", parts[i])
+                    if (parts[i] != "") {
+                        if (length(sym_arr) > 1) sym_arr = sym_arr ","
+                        sym_arr = sym_arr "\"" parts[i] "\""
+                    }
+                }
+                syms = sym_arr "]"
+            } else if (content ~ /^import [a-zA-Z_]/ && content !~ /^import type/ && content !~ /^import \*/) {
+                # Default import: import X from '"'"'Z'"'"'
+                tmp = content
+                gsub(/^import /, "", tmp)
+                gsub(/ .*$/, "", tmp)
+                syms = "[\"" tmp "\"]"
+            }
             is_local = (source ~ /^\./ || source ~ /^@/) ? "true" : "false"
-            printf "{\"from\":\"%s\",\"import\":null,\"line\":%s,\"is_local\":%s}\n", source, line, is_local
+            printf "{\"from\":\"%s\",\"import\":null,\"line\":%s,\"is_local\":%s,\"symbols\":%s}\n", source, line, is_local, syms
         } else if (index(content, "require(") > 0) {
             source = ""
             if (match(content, /"[^"]*"/)) {
                 source = substr(content, RSTART+1, RLENGTH-2)
             }
             is_local = (source ~ /^\./ || source ~ /^@/) ? "true" : "false"
-            printf "{\"from\":\"%s\",\"import\":null,\"line\":%s,\"is_local\":%s}\n", source, line, is_local
+            printf "{\"from\":\"%s\",\"import\":null,\"line\":%s,\"is_local\":%s,\"symbols\":[]}\n", source, line, is_local
         }
     }' | jq -s '.' 2>/dev/null || echo '[]')
 
@@ -687,7 +714,7 @@ _extract_rust() {
     hash=$(file_checksum "$file")
     line_count=$(wc -l < "$file" | tr -d ' ')
 
-    # --- Imports ---
+    # --- Imports (enhanced with symbols from use paths) ---
     local imports_json="[]"
     imports_json=$({ grep -n -E '^use ' "$file" 2>/dev/null || true; } | awk '
     {
@@ -697,7 +724,45 @@ _extract_rust() {
         gsub(/^use /, "", content)
         gsub(/;.*$/, "", content)
         gsub(/ *$/, "", content)
-        printf "{\"from\":\"%s\",\"import\":null,\"line\":%s,\"is_local\":false}\n", content, line
+
+        # Detect local imports: crate::, self::, super::, or crate-relative paths
+        is_local = "false"
+        if (content ~ /^crate::/ || content ~ /^super::/ || content ~ /^self::/) is_local = "true"
+
+        # Extract symbols from {A, B, C} grouped imports: use path::{A, B}
+        syms = "[]"
+        if (match(content, /\{[^}]+\}/)) {
+            brace = substr(content, RSTART+1, RLENGTH-2)
+            gsub(/^[[:space:]]+/, "", brace)
+            gsub(/[[:space:]]+$/, "", brace)
+            n = split(brace, parts, ",")
+            sym_arr = "["
+            for (i = 1; i <= n; i++) {
+                gsub(/^[[:space:]]+/, "", parts[i])
+                gsub(/[[:space:]]+$/, "", parts[i])
+                gsub(/[[:space:]]+as[[:space:]]+.*/, "", parts[i])
+                gsub(/ .*$/, "", parts[i])
+                if (parts[i] != "") {
+                    if (length(sym_arr) > 1) sym_arr = sym_arr ","
+                    sym_arr = sym_arr "\"" parts[i] "\""
+                }
+            }
+            syms = sym_arr "]"
+        } else {
+            # Single import: extract the last segment as symbol
+            n = split(content, seg, "::")
+            if (n > 0 && seg[n] != "" && seg[n] !~ /^\{/ && seg[n] !~ /\}$/) {
+                gsub(/[[:space:]]+as[[:space:]]+.*/, "", seg[n])
+                gsub(/ .*/, "", seg[n])
+                if (seg[n] != "*") {
+                    syms = "[\"" seg[n] "\"]"
+                }
+            }
+        }
+
+        # Escape double quotes in content for JSON
+        gsub(/"/, "\\\"", content)
+        printf "{\"from\":\"%s\",\"import\":null,\"line\":%s,\"is_local\":%s,\"symbols\":%s}\n", content, line, is_local, syms
     }' | jq -s '.' 2>/dev/null || echo '[]')
 
     # --- Structs/Enums/Traits ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dtt_siye/atool",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "AI Developer Toolkit - 一键配置 AI IDE 的工具集",
   "bin": {
     "atool": "bin/atool.js"

package/skills/project-analyze/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: project-analyze
 description: "Deep project analysis v5.0 — 7-phase pipeline with five-dimensional analysis framework, 14 node types, 24 edge types, 5-level granularity zooming, interactive visualization (Cytoscape.js), and query system. 5 depth levels (L1-L5): Discovery → Pre-Scan → Inventory → Deep Analysis → Knowledge Graph → Multi-Dimensional Analysis → Code Quality → Document Synthesis → Validation. Checkpoint/resume, incremental docs, large-module decomposition. Zero-KT standard, Chinese output. 触发：分析项目/生成文档/analyze project/generate docs/project analysis"
-version: 5.1.0
+version: 5.2.0
 ---
 
 # Project Analyzer v5.0
@@ -75,14 +75,15 @@ Pipeline 中 AI 与 bash 工具的分工遵循核心原则：**确定性操作
 
 ## Pipeline Controller
 
-### 5-Phase 架构
+### 6-Phase 架构
 
 ```
 Phase 1: SETUP      → phases/phase1-setup.md        (bash only, no AI, ~30秒)
 Phase 2: UNDERSTAND → phases/phase2-understand.md   (AI sub-agents ≤5并行)
+Phase 2.5: REFINE   → phases/phase2.5-refine.md     (AI sub-agents ≤5并行，串联 requirements-writer + software-architecture Refine Mode)
 Phase 3: GRAPH      → phases/phase3-graph.md        (bash only, no AI, ~30秒)
-Phase 4: SYNTHESIZE → phases/phase4-synthesize.md   (main agent + sub-agents)
-Phase 5: EXPORT     → phases/phase5-export.md       (bash only, no AI, ~10秒)
+Phase 4: SYNTHESIZE → phases/phase4-synthesize.md   (main agent, 聚合模式)
+Phase 5: EXPORT     → phases/phase5-export.md       (bash + AI, export 单文件)
 ```
 
 ### 执行规则（硬性）
@@ -93,30 +94,48 @@ Phase 5: EXPORT     → phases/phase5-export.md       (bash only, no AI, ~10秒)
 4. **Phase 2 并发上限 5 个 sub-agent**，超出部分按 importance 降序分批排队
 5. **Phase 3 bash 调用失败时**：在 state.json 记录 `phase3_graph: "failed"`，继续 Phase 4（跳过图谱相关文档，Phase 4 检查此标记）
 6. **断点续传**：先读 state.json，跳过 `status: "completed"` 的 phase
+7. Phase 2.5 在 Phase 2 完成后自动执行；`--skip-refine` 可跳过；`--refine-threshold N` 自定义门禁阈值（默认 70）
 
 ### 状态管理（简化版）
 
 `analysis-state.json` 最小结构：
-```json
+```jsonc
 {
-  "version": "5.1",
-  "project_root": "/path/to/project",
-  "stack": "java-spring",
+  "version": "5.2.0",
+  "project": "...",
+  "detected_stack": "java-spring",
   "depth": "L2",
-  "scale": "MEDIUM",
-  "modules": ["user-service", "order-service"],
   "phases": {
     "phase1_setup": "completed",
     "phase2_understand": "in_progress",
+    "phase2_5_refine": "pending",
     "phase3_graph": "pending",
     "phase4_synthesize": "pending",
     "phase5_export": "pending"
   },
   "module_status": {
-    "user-service": { "phase2": "completed" },
-    "order-service": { "phase2": "in_progress" }
+    "{slug}": {
+      "phase2": "completed|in_progress|pending",
+      "assigned_to": "sub-agent-id"
+    }
   },
-  "updated_at": "2026-04-04T10:00:00Z"
+  "refine_status": {
+    "{slug}": {
+      "prd_refine": "completed|in_progress|pending",
+      "prd_coverage": 82,
+      "prd_gate": "passed|failed",
+      "arch_refine": "completed|in_progress|pending|skipped",
+      "arch_gate": "passed|failed",
+      "conventions_loaded": "java-conventions",
+      "degraded": false,
+      "degraded_reason": null
+    }
+  },
+  "deliverable_status": {
+    "project_deliverable_md": "pending",
+    "export_single_file": "pending"
+  },
+  "errors": []
 }
 ```
 
@@ -275,10 +294,10 @@ When resuming Phase 5, incrementally update already-generated documents using `<
 | Collaborating Skill | Trigger Condition | Interaction |
 |---------------------|-------------------|-------------|
 | code-review | Phase 4 quality report generation | References rules/ files |
-| software-architecture | Phase 3 structural layer violation rate >30% | Suggest running |
+| software-architecture | Phase 2.5 Refine Mode 调用；Phase 4 聚合时 layer_violations/total_edges > 30% 建议深度审查 | 精炼模式 + 建议运行 |
 | {stack}-conventions | Phase 2 module analysis | Load stack-level conventions |
 | doc-standards-enforcer | Phase 4 document generation | Validate frontmatter format |
 | smart-dispatch | LARGE/XLARGE projects | Batch parallel by module |
 | project-query | Need to query analysis results | User manually invokes /project-query |
-| requirements-writer | Phase 4 PRD 覆盖率 < 70% | 建议运行，自动进入后向增强模式读取 atool-analysis/ |
+| requirements-writer | Phase 2.5 Refine Mode 调用；Phase 4 PRD 降级模块存在时建议补全 | 精炼模式 + 建议运行 |
 | clarify-before-build | Before Phase 1 user confirmation | Requirement clarification (auto-injected) |

package/skills/project-analyze/phases/phase2-understand.md

@@ -94,7 +94,13 @@ atool-analysis/modules/{module-name}/dev-guide.md    # 层2c: 开发指引
 ## 完成条件
 
 - 所有模块的 `module_status.{slug}.phase2 == "completed"`
-- `atool-analysis/modules/*/README.md` 全部存在
+- 每个模块至少 5/6 核心文件存在（data-model.md 可选）：
+  - `atool-analysis/modules/*/README.md` ✓ 必须
+  - `atool-analysis/modules/*/api.md` ✓ 必须
+  - `atool-analysis/modules/*/dev-guide.md` ✓ 必须
+  - `atool-analysis/modules/*/prd.md` ✓ 必须
+  - `atool-analysis/modules/*/test-cases.md` ✓ 必须
+  - `atool-analysis/modules/*/data-model.md` ○ 可选（无实体时可不存在）
 - `.atool-docs/modules/*/data.json` 全部存在
 - 更新 state：`phases.phase2_understand = "completed"`
 

package/skills/project-analyze/phases/phase2.5-refine.md

@@ -0,0 +1,284 @@
+# Phase 2.5: REFINE（精炼链 — AI sub-agents ≤5 并行）
+
+**目标**：对 Phase 2 生成的模块初稿，串联 requirements-writer 和 software-architecture 的 Refine Mode 进行精炼，将初稿升级为专业级交付文档。
+
+**并发上限**：最多 5 个模块同时精炼。每个模块内部串行（PRD 精炼 → 架构精炼）。
+
+---
+
+## 前置检查
+
+1. `analysis-state.json` 中 `phases.phase2_understand == "completed"`
+2. 读取 `detected_stack` 用于 conventions 加载
+3. 如果 `phases.phase2_5_refine == "completed"` 且非 `--force`，跳过本 Phase
+4. 如果 `--skip-refine`，跳过本 Phase
+
+## 输入数据
+
+| 来源 | 文件 |
+|------|------|
+| Phase 2 模块文档 | `atool-analysis/modules/*/README.md`, `api.md`, `data-model.md`, `dev-guide.md`, `prd.md`, `test-cases.md` |
+| Phase 2 结构化数据 | `.atool-docs/modules/*/data.json` |
+| Conventions | `~/.claude/skills/{stack}-conventions/SKILL.md`（仅 Architecture + API Design 节） |
+
+## 执行流程
+
+### 2.5.1 加载 Conventions 上下文
+
+```bash
+# 从 state.json 读取技术栈
+STACK=$(jq -r '.detected_stack // "generic"' .atool-docs/analysis-state.json)
+```
+
+从对应 conventions SKILL.md 中提取以下章节内容（不加载全文，控制在 ~200 行）：
+- `## Architecture` 或 `## 架构` 章节
+- `## API Design` 或 `## API 设计` 章节
+
+存为 `{conventions_context}` 变量。如果对应 conventions skill 不存在，`{conventions_context}` 为空字符串。
+
+### 2.5.2 构建模块精炼队列
+
+```bash
+# 读取模块列表，按重要性降序排列
+MODULES=$(jq -r '.modules | sort_by(-.importance) | .[].name' .atool-docs/pre-scan/manifest.json)
+```
+
+**断点续传检查**：对每个模块读取 `refine_status.{module}`：
+
+| 状态 | 行为 |
+|------|------|
+| `arch_refine == "completed"` | 跳过该模块 |
+| `prd_refine == "completed"` 且 `arch_refine != "completed"` | 加入队列，从架构精炼开始 |
+| `prd_refine != "completed"` | 加入队列，从 PRD 精炼开始 |
+| `degraded == true` | 跳过（除非 `--force`） |
+
+### 2.5.3 Gate 1: 初稿完整性检查（Hard Gate）
+
+**对每个待精炼模块执行**：
+
+检查项：
+- `atool-analysis/modules/{name}/prd.md` 存在且 ≥ 30 行
+- `atool-analysis/modules/{name}/README.md` 存在
+- `.atool-docs/modules/{name}/data.json` 存在且是合法 JSON
+
+**失败处理**：该模块不进入精炼队列，记录 `refine_status.{name}.gate1 = "failed"`，打印警告，其他模块继续。
+
+### 2.5.4 批量派发精炼 Sub-Agents
+
+**每批最多 5 个模块并行**，每个模块的精炼链为串行两步。等待当前批次全部完成后再派发下一批。
+
+---
+
+#### Step A: requirements-writer Refine（PRD 精炼）
+
+为每个模块派发 sub-agent，prompt 模板：
+
+```
+你是 requirements-writer 的精炼模式（Refine Mode）。
+
+## 任务
+将以下模块的 PRD 初稿精炼为标准 8 节结构。
+
+## 模块信息
+- 模块名：{module_name}
+- 模块路径：{module_path}
+- 技术栈：{detected_stack}
+
+## 输入文件（必须全部读取）
+- atool-analysis/modules/{module_name}/prd.md — Phase 2 初稿
+- atool-analysis/modules/{module_name}/api.md — 接口定义
+- atool-analysis/modules/{module_name}/data-model.md — 数据模型（可能不存在，跳过）
+- .atool-docs/modules/{module_name}/data.json — 结构化数据
+
+## 编码规范约束
+{conventions_context}
+
+## 精炼规则
+参考 requirements-writer SKILL.md 的 "Refine Mode（精炼模式）" 章节，严格按照其中的精炼逻辑执行：
+1. 保留初稿 §1-§3 和原 §4 非目标（移至 §6）
+2. 补全 §4 数据需求、§5 跨模块依赖、§7 风险与假设、§8 需求追溯矩阵
+3. 增强 §2 加 FR-{MOD}-NNN 编号 + Given-When-Then AC + UI 交互表；§3 加 NFR-{MOD}-NNN 编号，标注 [待系统级确认]
+4. 输出必须包含完整 8 节结构
+
+## 输出
+原地覆盖 atool-analysis/modules/{module_name}/prd.md
+
+## 禁止行为
+- 不做交互式问答
+- 不修改 README.md / api.md / data-model.md / dev-guide.md / test-cases.md
+- 不创建新文件
+```
+
+完成后立即写入 checkpoint：
+
+```bash
+jq --arg mod "{module_name}" \
+   '.refine_status[$mod].prd_refine = "completed"' \
+   .atool-docs/analysis-state.json > tmp && mv tmp .atool-docs/analysis-state.json
+```
+
+---
+
+#### Gate 2: PRD 覆盖率门禁（Hard Gate）
+
+**对每个模块的精炼后 prd.md 执行**：
+
+检查项（每项 20 分，满分 100）：
+
+| 检查项 | 验证方式 | 分值 |
+|--------|---------|------|
+| 8 节结构完整 | `grep -c "^## [0-9]"` ≥ 8 | 20 |
+| FR 编号存在 | `grep -c "FR-"` ≥ 1 | 20 |
+| Given-When-Then AC | `grep -c "Given\|When\|Then"` ≥ 3 | 20 |
+| NFR 编号存在 | `grep -c "NFR-"` ≥ 1 | 20 |
+| 数据需求填充 | §4 非空（> 3 行） | 20 |
+
+**通过**（≥ 70 分）→ 记录分数到 `refine_status.{name}.prd_coverage`，进入 Step B
+
+**失败**（< 70 分）→ 提供恢复选项：
+
+```
+❌ Gate 2 失败：模块 {module_name} PRD 覆盖率 {score}%（需 ≥ 70%）
+   缺失项：{列出具体未通过的检查项}
+
+   恢复选项：
+   [A] 重跑该模块的 PRD 精炼（自动重试 1 次）
+   [B] 手动编辑 prd.md 后输入 "继续" 
+   [C] 降级：跳过精炼，使用 Phase 2 初稿（标记 [未精炼]）
+```
+
+选择 A 时：重新派发 Step A sub-agent（仅 1 次重试，再失败则自动降级）
+选择 C 时：`refine_status.{name}.degraded = true, degraded_reason = "PRD coverage {score}% below threshold"`
+
+```bash
+# Gate 2 通过时写入
+jq --arg mod "{module_name}" --argjson score {score} \
+   '.refine_status[$mod].prd_coverage = $score | .refine_status[$mod].prd_gate = "passed"' \
+   .atool-docs/analysis-state.json > tmp && mv tmp .atool-docs/analysis-state.json
+```
+
+---
+
+#### Step B: software-architecture Refine（架构精炼）
+
+仅对通过 Gate 2 的模块执行。为每个模块派发 sub-agent，prompt 模板：
+
+```
+你是 software-architecture 的精炼模式（Refine Mode）。
+
+## 任务
+在以下模块的 dev-guide.md 基础上追加架构章节。
+
+## 模块信息
+- 模块名：{module_name}
+- 模块路径：{module_path}
+- 技术栈：{detected_stack}
+
+## 输入文件（必须全部读取）
+- atool-analysis/modules/{module_name}/dev-guide.md — 当前内容（保留全部，在末尾追加）
+- atool-analysis/modules/{module_name}/prd.md — 精炼后的标准 PRD（8 节）
+- atool-analysis/modules/{module_name}/api.md — 接口定义
+- atool-analysis/modules/{module_name}/data-model.md — 数据模型（可能不存在，跳过）
+- atool-analysis/modules/{module_name}/README.md — 模块概述
+- .atool-docs/modules/{module_name}/data.json — 结构化数据（含 refine_hints）
+
+## 编码规范约束
+{conventions_context}
+
+## 精炼规则
+参考 software-architecture SKILL.md 的 "Refine Mode（精炼模式）" 章节，严格按照其中的精炼逻辑执行：
+1. 在现有 dev-guide.md 内容末尾追加（不删除原有内容）
+2. 追加 B-subset 组件设计（分层表 + 边界 + 依赖方向）
+3. 追加 C-subset 数据与交互设计（数据所有权 + 同步/异步边界 + API 契约）
+4. 追加至少 1 个 ADR（使用 7 节 ADR 模板：Status/Context/Decision/Options/Consequences/NFR Impact/Related）
+5. NFR 对齐：标注 [待系统级确认]
+
+## 输出
+原地覆盖 atool-analysis/modules/{module_name}/dev-guide.md
+
+## 禁止行为
+- 不删除 dev-guide.md 的原有内容
+- 不修改 prd.md / api.md / data-model.md / README.md / test-cases.md
+- 不创建新文件
+- 不生成项目级文档（A/D/E/F）
+```
+
+完成后写入 checkpoint：
+
+```bash
+jq --arg mod "{module_name}" \
+   '.refine_status[$mod].arch_refine = "completed"' \
+   .atool-docs/analysis-state.json > tmp && mv tmp .atool-docs/analysis-state.json
+```
+
+---
+
+#### Gate 3: 架构精炼门禁（Hard Gate）
+
+**对每个模块的精炼后 dev-guide.md 执行**：
+
+检查项：
+- 包含 "组件设计" 或 "Component Design" 章节标题（`grep -c "组件设计\|Component Design"`）
+- 包含 "ADR" 或 "架构决策" 标题（`grep -c "ADR\|架构决策"`）
+- ADR 中包含 "Status" + "Decision" + "Consequences"（或中文等价 "状态" + "决策" + "影响"）
+
+**通过** → 记录 `arch_gate = "passed"`
+**失败** → 同 Gate 2 的三选项恢复机制（A 重试 / B 手动 / C 降级）
+
+```bash
+# Gate 3 通过时写入
+jq --arg mod "{module_name}" \
+   '.refine_status[$mod].arch_gate = "passed"' \
+   .atool-docs/analysis-state.json > tmp && mv tmp .atool-docs/analysis-state.json
+```
+
+### 2.5.5 完成 Checkpoint
+
+每个模块完成全部精炼（或降级）后，写入完整状态：
+
+```bash
+jq --arg mod "{module_name}" \
+   --argjson score {prd_score} \
+   --arg conv "{conventions_skill}" \
+   '.refine_status[$mod] = {
+     "prd_refine": "completed",
+     "prd_coverage": $score,
+     "prd_gate": "passed",
+     "arch_refine": "completed",
+     "arch_gate": "passed",
+     "conventions_loaded": $conv,
+     "degraded": false,
+     "degraded_reason": null
+   }' .atool-docs/analysis-state.json > tmp && mv tmp .atool-docs/analysis-state.json
+```
+
+### 2.5.6 跨 IDE 降级
+
+| IDE | 检测方式 | 行为 |
+|-----|---------|------|
+| Claude Code | Agent tool 可用 | 完整并行（≤5 模块同时） |
+| Cursor | Agent tool 不可用 | 顺序执行（每次 1 个模块） |
+| Kiro | 无 Agent tool + 无 sub-agent | 跳过 Phase 2.5（与 Phase 2 一样） |
+
+检测逻辑沿用 SKILL.md 的 Cross-IDE Adaptation 章节。
+
+---
+
+## 完成条件
+
+- 所有非降级模块的 `refine_status.{name}.arch_gate == "passed"`
+- 降级模块已记录 `degraded = true` 和 `degraded_reason`
+- 更新 state：
+
+```bash
+jq '.phases.phase2_5_refine = "completed"' .atool-docs/analysis-state.json > tmp && mv tmp .atool-docs/analysis-state.json
+```
+
+- 打印精炼摘要：
+
+```
+✅ Phase 2.5 REFINE 完成
+   精炼模块：{M}/{N}（{M} 个精炼完成，{D} 个降级）
+   平均 PRD 覆盖率：{avg_score}%
+   降级模块：{list}（如有，标注降级原因）
+```