@zhuan-ai/zhuanspec 2.0.0 → 2.1.1

package/dist/core/validation/strict-rules.js

@@ -0,0 +1,287 @@
+/**
+ * Strict Validation Rules
+ *
+ * Implementation of three strict validation rules for `zhuanspec validate --strict`:
+ * 1. pre-clarification-completed: Check Pre-Clarification Log section
+ * 2. skill-tags-valid: Validate @skill tags against known skills
+ * 3. task-ordering-by-wave: Verify task ordering follows wave structure
+ */
+import { generateExecutionPlan } from '../task-graph/execution-planner.js';
+// Patterns for detecting unresolved markers
+const UNRESOLVED_MARKERS = /\b(TODO|TBD|PENDING|\?)\b/i;
+const HTML_COMMENT_PATTERN = /<!--[\s\S]*?-->/g;
+const PRE_CLARIFICATION_SECTION_PATTERN = /^##\s+Pre-Clarification\s+Log\s*$/im;
+const VALID_COMPLETION_MARKERS = [
+    /no\s+clarification\s+needed/i,
+    /status:\s*completed/i,
+];
+// Skill mapping section header pattern
+const SKILL_MAPPING_SECTION_PATTERN = /^##\s+Skill\s+Mapping\s*$/im;
+// Table data row pattern (starts with |, not a separator row like |---|---|)
+const TABLE_DATA_ROW_PATTERN = /^\|(?![-:|\s]+\|$)[^\n]+\|/gm;
+const SKILL_TAG_PATTERN = /@skill:([^\s@]+)/g;
+// Wave header pattern
+const WAVE_HEADER_PATTERN = /^###\s+Wave\s+(\d+)/im;
+/**
+ * Rule 1: pre-clarification-completed
+ *
+ * Checks that tasks.md has a valid "## Pre-Clarification Log" section.
+ * Valid content includes:
+ *   - Actual Q&A record text
+ *   - "No clarification needed"
+ *   - "Status: COMPLETED"
+ * Invalid:
+ *   - Section missing
+ *   - Section empty (whitespace only)
+ *   - Only HTML comments
+ *   - Contains "TODO", "TBD", "PENDING", "?" unresolved markers
+ */
+export function checkPreClarification(tasksContent) {
+    const result = {
+        ruleId: 'pre-clarification-completed',
+        ruleName: 'Pre-clarification completed',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // Check if section exists
+    const sectionMatch = tasksContent.match(PRE_CLARIFICATION_SECTION_PATTERN);
+    if (!sectionMatch) {
+        result.errors.push('Pre-Clarification Log section is missing');
+        return result;
+    }
+    // Extract section content (from header to next ## or end)
+    const sectionStartIndex = sectionMatch.index + sectionMatch[0].length;
+    const nextSectionMatch = tasksContent.slice(sectionStartIndex).match(/^##\s+/m);
+    const sectionEndIndex = nextSectionMatch
+        ? sectionStartIndex + nextSectionMatch.index
+        : tasksContent.length;
+    let sectionContent = tasksContent.slice(sectionStartIndex, sectionEndIndex);
+    // Remove HTML comments for content analysis
+    const contentWithoutComments = sectionContent.replace(HTML_COMMENT_PATTERN, '').trim();
+    // Check if section is empty
+    if (!contentWithoutComments) {
+        result.errors.push('Pre-Clarification Log section is empty or contains only HTML comments');
+        return result;
+    }
+    // Check for unresolved markers
+    if (UNRESOLVED_MARKERS.test(contentWithoutComments)) {
+        result.errors.push('Pre-Clarification Log contains unresolved markers (TODO, TBD, PENDING, or ?)');
+        return result;
+    }
+    // Check for valid completion markers or actual content
+    const hasValidCompletionMarker = VALID_COMPLETION_MARKERS.some(pattern => pattern.test(contentWithoutComments));
+    const hasSubstantiveContent = contentWithoutComments.length > 20; // More than just a few words
+    if (hasValidCompletionMarker || hasSubstantiveContent) {
+        result.passed = true;
+    }
+    else {
+        result.errors.push('Pre-Clarification Log does not contain valid completion markers or substantive Q&A content');
+    }
+    return result;
+}
+/**
+ * Rule 2: skill-tags-valid
+ *
+ * Validates:
+ *   a. Skill Mapping table exists with at least one data row
+ *   b. Each task has @skill:xxx tag or @skill:none
+ *   c. @skill:none tasks should have a reason in description
+ *   d. All @skill:xxx names must exist in knownSkillNames
+ *   e. Comma-separated multi-skills are validated individually
+ */
+export function checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames) {
+    const result = {
+        ruleId: 'skill-tags-valid',
+        ruleName: 'Skill tags valid',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // a. Check Skill Mapping section exists with table data
+    const sectionMatch = tasksContent.match(SKILL_MAPPING_SECTION_PATTERN);
+    if (!sectionMatch) {
+        result.warnings.push('Skill Mapping section not found');
+    }
+    else {
+        // Extract section content (from header to next ## or end)
+        const sectionStartIndex = sectionMatch.index + sectionMatch[0].length;
+        const nextSectionMatch = tasksContent.slice(sectionStartIndex).match(/^##\s+/m);
+        const sectionEndIndex = nextSectionMatch
+            ? sectionStartIndex + nextSectionMatch.index
+            : tasksContent.length;
+        const sectionContent = tasksContent.slice(sectionStartIndex, sectionEndIndex);
+        // Check for table data rows (lines starting with | that are not separator rows)
+        const tableRows = sectionContent.match(TABLE_DATA_ROW_PATTERN);
+        // Filter out header rows and separator rows
+        const dataRows = tableRows?.filter(row => {
+            const trimmed = row.trim();
+            // Skip separator rows like |---|---| or |:---|---:|
+            if (/^\|[-:\s|]+\|$/.test(trimmed))
+                return false;
+            // Skip header rows (first non-separator row is header)
+            return true;
+        });
+        // Need at least 2 rows (header + 1 data row)
+        if (!dataRows || dataRows.length < 2) {
+            result.warnings.push('Skill Mapping table has no data rows');
+        }
+    }
+    // If no tasks, consider it valid
+    if (parsedTasks.length === 0) {
+        result.passed = true;
+        return result;
+    }
+    // b, c, d, e. Validate each task's skill tags
+    const knownSkillSet = new Set(knownSkillNames.map(s => s.toLowerCase()));
+    for (const task of parsedTasks) {
+        // b. Check if task has skill tag
+        if (task.skills.length === 0) {
+            result.errors.push(`Task ${task.id}: missing @skill tag`);
+            continue;
+        }
+        // Validate each skill
+        for (const skill of task.skills) {
+            const skillLower = skill.toLowerCase();
+            // c. @skill:none should have a reason
+            if (skillLower === 'none') {
+                // Check if description mentions why no skill needed
+                const descLower = task.description.toLowerCase();
+                const hasReason = descLower.includes('manual') ||
+                    descLower.includes('review') ||
+                    descLower.includes('document') ||
+                    descLower.includes('config') ||
+                    descLower.includes('test') ||
+                    descLower.includes('verify') ||
+                    task.description.length > 30; // Substantial description is acceptable
+                if (!hasReason) {
+                    result.warnings.push(`Task ${task.id}: @skill:none should have a reason in description`);
+                }
+                continue;
+            }
+            // d. Validate skill exists in known skills
+            if (knownSkillNames.length > 0 && !knownSkillSet.has(skillLower)) {
+                const availableSkills = knownSkillNames.length <= 10
+                    ? knownSkillNames.join(', ')
+                    : `${knownSkillNames.slice(0, 10).join(', ')}... (${knownSkillNames.length} total)`;
+                result.errors.push(`Task ${task.id}: @skill:${skill} is not a known skill. Available skills: ${availableSkills}`);
+            }
+        }
+    }
+    // Passed if no errors
+    result.passed = result.errors.length === 0;
+    return result;
+}
+/**
+ * Rule 3: task-ordering-by-wave
+ *
+ * Validates:
+ *   - Tasks are ordered by wave (wave 1 tasks before wave 2, etc.)
+ *   - Wave headers "### Wave N" match actual computed wave numbers
+ *   - Tasks.md must have Wave headers
+ */
+export function checkTaskOrderingByWave(tasksContent, parsedTasks) {
+    const result = {
+        ruleId: 'task-ordering-by-wave',
+        ruleName: 'Task ordering by wave',
+        passed: false,
+        errors: [],
+        warnings: [],
+    };
+    // If no tasks, consider it valid
+    if (parsedTasks.length === 0) {
+        result.passed = true;
+        return result;
+    }
+    // Check for wave headers
+    const waveHeaders = [];
+    const waveHeaderRegex = /^###\s+Wave\s+(\d+)/gim;
+    let match;
+    while ((match = waveHeaderRegex.exec(tasksContent)) !== null) {
+        waveHeaders.push({
+            wave: parseInt(match[1], 10),
+            position: match.index,
+        });
+    }
+    if (waveHeaders.length === 0) {
+        result.errors.push('No Wave headers found in tasks.md. Expected format: "### Wave N"');
+        return result;
+    }
+    // Generate execution plan to get actual waves
+    const executionPlan = generateExecutionPlan(parsedTasks);
+    if (executionPlan.hasCycle) {
+        result.errors.push('Task dependency graph has cycles, cannot validate wave ordering');
+        return result;
+    }
+    // Build a map of task ID to actual wave number
+    const taskToWave = new Map();
+    for (const wave of executionPlan.waves) {
+        for (const task of wave.tasks) {
+            taskToWave.set(task.id, wave.wave);
+        }
+    }
+    // Find task positions in content
+    const taskPositions = [];
+    for (const task of parsedTasks) {
+        // Find task line in content
+        const taskPattern = new RegExp(`-\\s+\\[[ xX]\\]\\s+${task.id.replace('.', '\\.')}\\s`, 'gm');
+        const taskMatch = taskPattern.exec(tasksContent);
+        if (taskMatch) {
+            const actualWave = taskToWave.get(task.id);
+            if (actualWave !== undefined) {
+                taskPositions.push({
+                    id: task.id,
+                    position: taskMatch.index,
+                    actualWave,
+                });
+            }
+        }
+    }
+    // Sort by position in file
+    taskPositions.sort((a, b) => a.position - b.position);
+    // Check ordering: all tasks of wave N should appear before tasks of wave N+1
+    let lastWave = 0;
+    for (const task of taskPositions) {
+        if (task.actualWave < lastWave) {
+            result.errors.push(`Task ${task.id} (wave ${task.actualWave}) appears after tasks of wave ${lastWave}`);
+        }
+        lastWave = Math.max(lastWave, task.actualWave);
+    }
+    // Validate wave headers match actual wave numbers
+    const actualWaveNumbers = new Set(executionPlan.waves.map(w => w.wave));
+    const declaredWaveNumbers = new Set(waveHeaders.map(h => h.wave));
+    for (const declared of declaredWaveNumbers) {
+        if (!actualWaveNumbers.has(declared)) {
+            result.warnings.push(`Wave header "### Wave ${declared}" does not match any computed wave`);
+        }
+    }
+    for (const actual of actualWaveNumbers) {
+        if (!declaredWaveNumbers.has(actual)) {
+            result.errors.push(`Missing Wave header for computed wave ${actual}`);
+        }
+    }
+    // Check wave header ordering
+    for (let i = 1; i < waveHeaders.length; i++) {
+        if (waveHeaders[i].wave <= waveHeaders[i - 1].wave) {
+            result.errors.push(`Wave headers are not in ascending order: Wave ${waveHeaders[i - 1].wave} followed by Wave ${waveHeaders[i].wave}`);
+        }
+    }
+    result.passed = result.errors.length === 0;
+    return result;
+}
+/**
+ * Main entry: Run all strict validation rules
+ */
+export async function runStrictValidation(tasksContent, parsedTasks, knownSkillNames) {
+    const checks = [
+        checkPreClarification(tasksContent),
+        checkSkillTagsValid(tasksContent, parsedTasks, knownSkillNames),
+        checkTaskOrderingByWave(tasksContent, parsedTasks),
+    ];
+    const allPassed = checks.every(check => check.passed);
+    return {
+        checks,
+        allPassed,
+    };
+}
+//# sourceMappingURL=strict-rules.js.map

package/dist/core/validation/types.d.ts

@@ -6,6 +6,13 @@ export interface ValidationIssue {
     line?: number;
     column?: number;
 }
+export interface StrictCheckSummary {
+    ruleId: string;
+    ruleName: string;
+    passed: boolean;
+    errors: string[];
+    warnings: string[];
+}
 export interface ValidationReport {
     valid: boolean;
     issues: ValidationIssue[];
@@ -14,5 +21,8 @@ export interface ValidationReport {
         warnings: number;
         info: number;
     };
+    strictChecks?: StrictCheckSummary[];
+    /** Mermaid diagram content if task graph analysis succeeded */
+    mermaidDiagram?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/core/validation/validator.d.ts

@@ -29,5 +29,10 @@ export declare class Validator {
     private containsShallOrMust;
     private countScenarios;
     private formatSectionList;
+    /**
+     * Find project root directory by walking up from changeDir.
+     * Looks for common project markers like package.json, .git, or skills directory.
+     */
+    private findProjectRoot;
 }
 //# sourceMappingURL=validator.d.ts.map

package/dist/core/validation/validator.js

@@ -6,6 +6,12 @@ import { ChangeParser } from '../parsers/change-parser.js';
 import { MIN_PURPOSE_LENGTH, MAX_REQUIREMENT_TEXT_LENGTH, VALIDATION_MESSAGES } from './constants.js';
 import { parseDeltaSpec, normalizeRequirementName } from '../parsers/requirement-blocks.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
+import { runStrictValidation } from './strict-rules.js';
+import { discoverSkills } from '../skill-discovery.js';
+import { existsSync } from 'fs';
+import { parseTasks } from '../task-graph/task-parser.js';
+import { generateExecutionPlan } from '../task-graph/execution-planner.js';
+import { renderMermaidDiagram } from '../task-graph/mermaid-renderer.js';
 export class Validator {
     strictMode;
     constructor(strictMode = false) {
@@ -253,7 +259,84 @@ export class Validator {
         if (totalDeltas === 0) {
             issues.push({ level: 'ERROR', path: 'file', message: this.enrichTopLevelError('change', VALIDATION_MESSAGES.CHANGE_NO_DELTAS) });
         }
-        return this.createReport(issues);
+        // Strict mode validation for tasks.md
+        let strictChecks;
+        if (this.strictMode) {
+            const tasksFile = path.join(changeDir, 'tasks.md');
+            let tasksContent;
+            try {
+                tasksContent = await fs.readFile(tasksFile, 'utf-8');
+            }
+            catch {
+                // tasks.md not found - skip strict validation for tasks
+            }
+            if (tasksContent) {
+                const parsedTasks = parseTasks(tasksContent);
+                // Get known skill names
+                let knownSkillNames = [];
+                try {
+                    const projectRoot = this.findProjectRoot(changeDir);
+                    const skills = discoverSkills(projectRoot);
+                    knownSkillNames = skills.map(s => s.name);
+                }
+                catch {
+                    // skill discovery failed - add warning and continue without skill name validation
+                    issues.push({
+                        level: 'WARNING',
+                        path: 'tasks.md',
+                        message: 'Could not discover skills for strict validation — skill name check skipped',
+                    });
+                }
+                // Run strict validation
+                const strictResult = await runStrictValidation(tasksContent, parsedTasks, knownSkillNames);
+                strictChecks = strictResult.checks;
+                // Merge strict errors into main issues
+                for (const check of strictResult.checks) {
+                    for (const error of check.errors) {
+                        issues.push({
+                            level: 'ERROR',
+                            path: 'tasks.md',
+                            message: `[${check.ruleName}] ${error}`,
+                        });
+                    }
+                    for (const warning of check.warnings) {
+                        issues.push({
+                            level: 'WARNING',
+                            path: 'tasks.md',
+                            message: `[${check.ruleName}] ${warning}`,
+                        });
+                    }
+                }
+            }
+        }
+        // Generate Mermaid diagram if tasks.md exists and has tasks
+        let mermaidDiagram;
+        const tasksFile = path.join(changeDir, 'tasks.md');
+        let tasksContentForMermaid;
+        try {
+            tasksContentForMermaid = await fs.readFile(tasksFile, 'utf-8');
+        }
+        catch {
+            // tasks.md not found - skip Mermaid generation
+        }
+        if (tasksContentForMermaid) {
+            const parsedTasksForMermaid = parseTasks(tasksContentForMermaid);
+            if (parsedTasksForMermaid.length > 0) {
+                const executionPlan = generateExecutionPlan(parsedTasksForMermaid);
+                // Only generate Mermaid diagram if execution plan is valid (no cycles)
+                if (!executionPlan.hasCycle && executionPlan.waves.length > 0) {
+                    mermaidDiagram = renderMermaidDiagram(executionPlan, parsedTasksForMermaid);
+                }
+            }
+        }
+        const report = this.createReport(issues);
+        if (strictChecks) {
+            report.strictChecks = strictChecks;
+        }
+        if (mermaidDiagram) {
+            report.mermaidDiagram = mermaidDiagram;
+        }
+        return report;
     }
     convertZodErrors(error) {
         return error.issues.map(err => {
@@ -405,5 +488,24 @@ export class Validator {
         const last = sections[sections.length - 1];
         return `${head.join(', ')} and ${last}`;
     }
+    /**
+     * Find project root directory by walking up from changeDir.
+     * Looks for common project markers like package.json, .git, or skills directory.
+     */
+    findProjectRoot(changeDir) {
+        let current = path.resolve(changeDir);
+        const root = path.parse(current).root;
+        while (current !== root) {
+            // Check for project root markers
+            if (existsSync(path.join(current, 'package.json')) ||
+                existsSync(path.join(current, '.git')) ||
+                existsSync(path.join(current, 'skills'))) {
+                return current;
+            }
+            current = path.dirname(current);
+        }
+        // Fallback to process.cwd() if no markers found
+        return process.cwd();
+    }
 }
 //# sourceMappingURL=validator.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhuan-ai/zhuanspec",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "zhuanspec",

package/schemas/spec-driven/schema.yaml

@@ -44,19 +44,19 @@ artifacts:
       创建建立此变更原因的提案文档。
 
       章节：
-      - **Why**：关于问题或机会的 1-2 句话。它解决了什么问题？为什么是现在？
-      - **What Changes**：变更的要点列表。具体说明新功能、修改或移除。用 **BREAKING** 标记破坏性更改。
-      - **Capabilities**：确定将创建或修改哪些规范：
-        - **New Capabilities**：列出正在引入的功能。每个都会成为新的 `specs/<name>/spec.md`。使用 kebab-case 名称（例如，`user-auth`、`data-export`）。
-        - **Modified Capabilities**：列出其 REQUIREMENTS 正在更改的现有功能。仅当规范级行为更改时（不仅仅是实现细节）才包含。每个都需要一个增量规范文件。检查 `openspec/specs/` 以获取现有规范名称。如果没有要求更改，则留空。
-      - **Skill Mapping**：运行 `zhuanspec skills list` 发现可用 skill，基于 skill description 进行语义匹配：
+      - **变更原因**：关于问题或机会的 1-2 句话。它解决了什么问题？为什么是现在？
+      - **变更内容**：变更的要点列表。具体说明新功能、修改或移除。用 **BREAKING** 标记破坏性更改。
+      - **功能范围**：确定将创建或修改哪些规范：
+        - **新增功能**：列出正在引入的功能。每个都会成为新的 `specs/<name>/spec.md`。使用 kebab-case 名称（例如，`user-auth`、`data-export`）。
+        - **修改功能**：列出其 REQUIREMENTS 正在更改的现有功能。仅当规范级行为更改时（不仅仅是实现细节）才包含。每个都需要一个增量规范文件。检查 `openspec/specs/` 以获取现有规范名称。如果没有要求更改，则留空。
+      - **Skill 映射**：运行 `zhuanspec skills list` 发现可用 skill，基于 skill description 进行语义匹配：
         1. 仔细阅读每个 skill 的 description，理解其具体功能和适用场景
         2. 只有当实现区域的实际功能与 skill description 明确匹配时才关联
         3. 简单的代码修改（如枚举值增删）应匹配通用编码规范 skill，而非架构级 skill
         4. 避免仅因模块名称或文件路径中的关键词而错误匹配
         5. 在表格中说明匹配理由，确保映射合理性
         此映射将在 tasks.md 中用于 @skill 标注。如果没有匹配 skill 则留空。
-      - **Impact**：受影响的代码、API、依赖项或系统。
+      - **影响范围**：受影响的代码、API、依赖项或系统。
 
       重要提示：Capabilities 部分至关重要。它在提案和规范阶段之间创建契约。在填写之前，请研究现有规范。
       此处列出的每个功能都需要一个相应的规范文件。
@@ -134,12 +134,12 @@ artifacts:
       - 在编码之前从技术决策中受益的模糊性
 
       章节：
-      - **Context**：背景、当前状态、约束、利益相关者
-      - **Goals / Non-Goals**：此设计实现的内容和明确排除的内容
-      - **Decisions**：关键的技术选择及其理由（为什么选择 X 而不是 Y？）。包括为每个决策考虑的替代方案。
-      - **Risks / Trade-offs**：已知的限制，可能出错的事情。格式：[Risk] → Mitigation
-      - **Migration Plan**：部署步骤、回滚策略（如果适用）
-      - **Open Questions**：待解决的决定或未知数
+      - **背景**：背景、当前状态、约束、利益相关者
+      - **目标 / 非目标**：此设计实现的内容和明确排除的内容
+      - **决策**：关键的技术选择及其理由（为什么选择 X 而不是 Y？）。包括为每个决策考虑的替代方案。
+      - **风险 / 权衡**：已知的限制，可能出错的事情。格式：[风险] → 缓解措施
+      - **迁移计划**：部署步骤、回滚策略（如果适用）
+      - **待解决问题**：待解决的决定或未知数
 
       专注于架构和方法，而不是逐行实现。
       参考提案了解动机，参考规范了解要求。

package/schemas/spec-driven/templates/design.md

@@ -1,19 +1,19 @@
-## Context
+## 背景
 
 <!-- 背景和当前状态 -->
 
-## Goals / Non-Goals
+## 目标 / 非目标
 
-**Goals:**
+**目标：**
 <!-- 此设计旨在实现的目标 -->
 
-**Non-Goals:**
+**非目标：**
 <!-- 明确不在范围内的内容 -->
 
-## Decisions
+## 决策
 
 <!-- 关键设计决策和理由 -->
 
-## Risks / Trade-offs
+## 风险 / 权衡
 
 <!-- 已知风险和权衡 -->

package/schemas/spec-driven/templates/proposal.md

@@ -1,24 +1,24 @@
-## Why
+## 变更原因
 
 <!-- 解释此变更的动机。它解决了什么问题？为什么是现在？ -->
 
-## What Changes
+## 变更内容
 
 <!-- 描述将要更改的内容。具体说明新功能、修改或移除。 -->
 
-## Capabilities
+## 功能范围
 
-### New Capabilities
+### 新增功能
 <!-- 正在引入的功能。将 <name> 替换为 kebab-case 标识符（例如，user-auth、data-export、api-rate-limiting）。每个都会创建 specs/<name>/spec.md -->
 - `<name>`: <此功能涵盖内容的简要描述>
 
-### Modified Capabilities
+### 修改功能
 <!-- 其 REQUIREMENTS 正在更改的现有功能（不仅仅是实现）。
      仅当规范级行为更改时，才在此处列出。每个都需要一个增量规范文件。
      使用 zhuanspec/specs/ 中的现有规范名称。如果没有要求更改，则留空。 -->
 - `<existing-name>`: <正在更改的要求>
 
-## Skill Mapping
+## Skill 映射
 
 <!-- 重要：运行 `zhuanspec skills list` 查看可用 skill，基于 skill description 进行语义匹配。
      匹配原则：
@@ -38,6 +38,6 @@
 |---------|---------|-----------|---------|
 | <!-- 模块/文件 --> | <!-- 具体功能 --> | <!-- skill 名称 --> | <!-- 为什么匹配 --> |
 
-## Impact
+## 影响范围
 
 <!-- 受影响的代码、API、依赖项、系统 -->

package/schemas/spec-driven/templates/spec.md

@@ -1,8 +1,8 @@
 ## ADDED Requirements
 
-### Requirement: <!-- 要求名称 -->
+### 需求：<!-- 要求名称 -->
 <!-- 要求文本 -->
 
-#### Scenario: <!-- 场景名称 -->
-- **WHEN** <!-- 条件 -->
-- **THEN** <!-- 预期结果 -->
+#### 场景：<!-- 场景名称 -->
+- **当** <!-- 条件 -->
+- **则** <!-- 预期结果 -->