@lininn/openflow 0.1.7 → 0.1.8

package/README.md

@@ -23,10 +23,25 @@ openflow init --tools claude
 1. Detect and guide OpenSpec CLI installation
 2. Detect Superpowers and show install instructions
 3. Check if OpenSpec is initialized in the project
-4. Generate openflow skills to `.claude/skills/openflow/`
+4. Generate openflow skills to the selected tools' local skill directories, such as `.claude/skills/openflow/`, `.codex/skills/openflow/`, or `.cursor/skills/openflow/`
 
 Supported tools: `claude`, `codex`, `cursor` (comma-separated, e.g. `--tools claude,codex`)
 
+### Install skills globally
+
+```bash
+openflow init --tools claude -g
+openflow init --tools claude,codex,cursor --global
+```
+
+With `-g` / `--global`, `openflow` installs skills under the selected tools' home directories:
+
+| Tool | Global skill path |
+|------|-------------------|
+| `claude` | `~/.claude/skills/openflow/` |
+| `codex` | `~/.codex/skills/openflow/` |
+| `cursor` | `~/.cursor/skills/openflow/` |
+
 ### Check status
 
 ```bash
@@ -69,7 +84,7 @@ Works without them: yes, with manual-file fallback
 
 | Layer | Mechanism | When missing |
 |-------|-----------|-------------|
-| **Init time** | Detect OpenSpec → auto-install; Detect Superpowers → show install hint | Non-blocking, skills still generated |
+| **Init time** | Detect OpenSpec CLI from `PATH`; detect project OpenSpec in `./openspec/`; detect Superpowers in the selected tools' local/global skill dirs | Non-blocking, skills still generated |
 | **Runtime** | Dependency check injected into SKILL.md | Build phase falls back to manual step-by-step execution |
 
 ## Architecture

package/README.zh-CN.md

@@ -23,10 +23,25 @@ openflow init --tools claude
 1. 检测并引导安装 OpenSpec CLI
 2. 检测 Superpowers 并提示安装方式
 3. 检测项目 OpenSpec 初始化状态
-4. 生成 openflow skills 到项目 `.claude/skills/openflow/`
+4. 生成 openflow skills 到所选工具的项目级 skill 目录，如 `.claude/skills/openflow/`、`.codex/skills/openflow/` 或 `.cursor/skills/openflow/`
 
 支持的工具：`claude`、`codex`、`cursor`（逗号分隔，如 `--tools claude,codex`）
 
+### 安装到全局 skills
+
+```bash
+openflow init --tools claude -g
+openflow init --tools claude,codex,cursor --global
+```
+
+加 `-g` / `--global` 后，`openflow` 会把 skills 安装到所选工具的全局目录：
+
+| 工具 | 全局 skill 路径 |
+|------|-----------------|
+| `claude` | `~/.claude/skills/openflow/` |
+| `codex` | `~/.codex/skills/openflow/` |
+| `cursor` | `~/.cursor/skills/openflow/` |
+
 ### 查看状态
 
 ```bash
@@ -69,7 +84,7 @@ Works without them: yes, with manual-file fallback
 
 | 层 | 机制 | 缺失时 |
 |----|------|--------|
-| **init 时** | 检测 OpenSpec → 自动安装；检测 Superpowers → 提示安装命令 | 不阻断，继续生成 skills |
+| **init 时** | 从 `PATH` 检测 OpenSpec CLI；从 `./openspec/` 检测当前项目 OpenSpec；从所选工具的本地/全局 skill 目录检测 Superpowers | 不阻断，继续生成 skills |
 | **运行时** | SKILL.md 注入依赖检测段 | build 阶段降级为手动拆解步骤执行 |
 
 ## 架构

package/dist/cli/init.js

@@ -9,15 +9,17 @@ const SUPPORTED_TOOLS = Object.keys(TOOL_PATHS);
 export const initCommand = new Command('init')
     .description('Initialize openflow skills in the current project')
     .option('-t, --tools <tools>', 'Target tools, comma-separated', 'claude')
+    .option('-g, --global', 'Install skills globally under home tool directories')
     .action(async (options) => {
     const cwd = process.cwd();
     const tools = options.tools.split(',').map((t) => t.trim());
+    const installGlobally = Boolean(options.global);
     logger.blank();
-    logger.info('openflow init — workflow orchestrator setup');
+    logger.info(`openflow init — ${installGlobally ? 'global skill setup' : 'workflow orchestrator setup'}`);
     logger.blank();
     // Step 1: Check OpenSpec
     logger.step('Checking OpenSpec ...');
-    let depStatus = checkDependencies();
+    let depStatus = checkDependencies({ cwd, tools });
     if (!depStatus.openspec.installed) {
         logger.warn('OpenSpec CLI not installed');
         const { installOpenSpec } = await inquirer.prompt([
@@ -30,7 +32,7 @@ export const initCommand = new Command('init')
         ]);
         if (installOpenSpec) {
             const ok = tryAutoInstall(DEPS.openspec.npmPkg);
-            depStatus = checkDependencies(); // recheck
+            depStatus = checkDependencies({ cwd, tools }); // recheck
             if (ok)
                 depStatus.openspec.autoInstalled = true;
         }
@@ -49,44 +51,51 @@ export const initCommand = new Command('init')
         logger.info('Re-run openflow init after installing, or build phase will use manual fallback');
     }
     else {
-        logger.success('Superpowers installed');
+        logger.success(`Superpowers installed${depStatus.superpowers.path ? ` (${depStatus.superpowers.path})` : ''}`);
     }
-    // Step 3: Check if OpenSpec is initialized in project
-    logger.step('Checking project OpenSpec initialization ...');
-    if (!checkOpenSpecInitialized(cwd)) {
-        if (depStatus.openspec.installed) {
-            const { initOpenSpec } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'initOpenSpec',
-                    message: 'OpenSpec not initialized in this project. Run openspec init?',
-                    default: true,
-                },
-            ]);
-            if (initOpenSpec) {
-                const toolsFlag = tools.map((t) => t).join(',');
-                exec(`openspec init --tools ${toolsFlag}`, { stdio: 'inherit' });
-                logger.success('OpenSpec project initialized');
+    if (installGlobally) {
+        logger.step('Skipping project OpenSpec initialization for global install');
+    }
+    else {
+        // Step 3: Check if OpenSpec is initialized in project
+        logger.step('Checking project OpenSpec initialization ...');
+        if (!checkOpenSpecInitialized(cwd)) {
+            if (depStatus.openspec.installed) {
+                const { initOpenSpec } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'initOpenSpec',
+                        message: 'OpenSpec not initialized in this project. Run openspec init?',
+                        default: true,
+                    },
+                ]);
+                if (initOpenSpec) {
+                    const toolsFlag = tools.map((t) => t).join(',');
+                    exec(`openspec init --tools ${toolsFlag}`, { stdio: 'inherit' });
+                    logger.success('OpenSpec project initialized');
+                }
+            }
+            else {
+                logger.info('OpenSpec not initialized — directories will be auto-created on first /openflow proposal');
             }
         }
         else {
-            logger.info('OpenSpec not initialized — directories will be auto-created on first /openflow proposal');
+            logger.success('OpenSpec project initialized');
         }
     }
-    else {
-        logger.success('OpenSpec project initialized');
-    }
     // Step 4: Generate skills
     logger.step('Generating openflow skills ...');
-    generateSkills({ cwd, tools, depStatus });
-    // Step 5: Write state
-    writeState(cwd, {
-        openspec: depStatus.openspec.installed,
-        superpowers: depStatus.superpowers.installed,
-        openspecProjectInitialized: checkOpenSpecInitialized(cwd),
-        createdAt: new Date().toISOString(),
-        tools,
-    });
+    generateSkills({ cwd, tools, depStatus, global: installGlobally });
+    if (!installGlobally) {
+        // Step 5: Write state
+        writeState(cwd, {
+            openspec: depStatus.openspec.installed,
+            superpowers: depStatus.superpowers.installed,
+            openspecProjectInitialized: checkOpenSpecInitialized(cwd),
+            createdAt: new Date().toISOString(),
+            tools,
+        });
+    }
     logger.blank();
     logger.success('openflow initialized!');
     logger.blank();

package/dist/cli/status.js

@@ -11,9 +11,10 @@ export const statusCommand = new Command('status')
     logger.blank();
     logger.info('openflow status');
     logger.blank();
+    const state = readState(cwd);
     // Dependencies
     logger.step('Dependencies:');
-    const depStatus = checkDependencies();
+    const depStatus = checkDependencies({ cwd, tools: state?.tools });
     if (depStatus.openspec.installed) {
         logger.success(`OpenSpec CLI${depStatus.openspec.version ? ` v${depStatus.openspec.version}` : ''}`);
     }
@@ -21,7 +22,7 @@ export const statusCommand = new Command('status')
         logger.warn('OpenSpec CLI — not installed');
     }
     if (depStatus.superpowers.installed) {
-        logger.success('Superpowers');
+        logger.success(`Superpowers${depStatus.superpowers.path ? ` (${depStatus.superpowers.path})` : ''}`);
     }
     else {
         logger.warn('Superpowers — not installed (build phase will use manual mode)');
@@ -29,7 +30,6 @@ export const statusCommand = new Command('status')
     logger.blank();
     // Project state
     logger.step('Project:');
-    const state = readState(cwd);
     if (state) {
         logger.success(`Initialized (${state.tools.join(', ')})`);
         logger.info(`  Created at: ${state.createdAt}`);

package/dist/cli/update.js

@@ -14,7 +14,7 @@ export const updateCommand = new Command('update')
     logger.blank();
     logger.info('openflow update — regenerating skills');
     logger.blank();
-    const depStatus = checkDependencies();
+    const depStatus = checkDependencies({ cwd, tools: state.tools });
     generateSkills({
         cwd,
         tools: state.tools,

package/dist/core/constants.d.ts

@@ -13,7 +13,7 @@ export declare const DEPS: {
     readonly superpowers: {
         readonly name: "Superpowers";
         readonly checkPath: "writing-plans/SKILL.md";
-        readonly installHint: "请在 Claude Code 中执行: /plugin install superpowers@claude-plugins-official";
+        readonly installHint: "请在当前工具中安装 Superpowers writing-plans skill（Claude Code: /plugin install superpowers@claude-plugins-official）";
         readonly autoInstallable: false;
     };
 };

package/dist/core/constants.js

@@ -13,7 +13,7 @@ export const DEPS = {
     superpowers: {
         name: 'Superpowers',
         checkPath: 'writing-plans/SKILL.md',
-        installHint: '请在 Claude Code 中执行: /plugin install superpowers@claude-plugins-official',
+        installHint: '请在当前工具中安装 Superpowers writing-plans skill（Claude Code: /plugin install superpowers@claude-plugins-official）',
         autoInstallable: false,
     },
 };

package/dist/core/dependency-check.d.ts

@@ -7,9 +7,15 @@ export interface DepStatus {
     superpowers: {
         installed: boolean;
         hint?: string;
+        path?: string;
+        checkedPaths: string[];
     };
 }
-export declare function checkDependencies(): DepStatus;
+export interface CheckDependencyOptions {
+    cwd?: string;
+    tools?: string[];
+}
+export declare function checkDependencies(options?: CheckDependencyOptions): DepStatus;
 export declare function tryAutoInstall(pkg: string): boolean;
 export declare function checkOpenSpecInitialized(cwd: string): boolean;
 export interface InitState {

package/dist/core/dependency-check.js

@@ -1,21 +1,24 @@
 import { execSync } from 'child_process';
 import { cmdExists, fileExists, dirExists, exec } from '../utils/shell.js';
-import { DEPS } from './constants.js';
+import { DEPS, TOOL_PATHS } from './constants.js';
 import { logger } from '../utils/logger.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs';
-export function checkDependencies() {
+export function checkDependencies(options = {}) {
     const home = os.homedir();
+    const cwd = options.cwd ?? process.cwd();
+    const tools = options.tools?.length ? options.tools : Object.keys(TOOL_PATHS);
     // Check OpenSpec
     const openspecInstalled = cmdExists(DEPS.openspec.cliCmd);
     let openspecVersion;
     if (openspecInstalled) {
         openspecVersion = exec('openspec --version') || undefined;
     }
-    // Check Superpowers
-    const superpowersSkillPath = path.join(home, '.claude', 'skills', DEPS.superpowers.checkPath);
-    const superpowersInstalled = fileExists(superpowersSkillPath);
+    // Check Superpowers in the selected tools' local and global skill dirs.
+    const superpowersSkillPaths = getSuperpowersSkillPaths(cwd, home, tools);
+    const superpowersSkillPath = superpowersSkillPaths.find((candidate) => fs.existsSync(candidate));
+    const superpowersInstalled = Boolean(superpowersSkillPath);
     return {
         openspec: {
             installed: openspecInstalled,
@@ -24,9 +27,22 @@ export function checkDependencies() {
         superpowers: {
             installed: superpowersInstalled,
             hint: superpowersInstalled ? undefined : DEPS.superpowers.installHint,
+            path: superpowersSkillPath,
+            checkedPaths: superpowersSkillPaths,
         },
     };
 }
+function getSuperpowersSkillPaths(cwd, home, tools) {
+    const candidates = new Set();
+    for (const tool of tools) {
+        const toolPaths = TOOL_PATHS[tool];
+        if (!toolPaths)
+            continue;
+        candidates.add(path.join(cwd, toolPaths.skillsDir, DEPS.superpowers.checkPath));
+        candidates.add(path.join(home, toolPaths.skillsDir, DEPS.superpowers.checkPath));
+    }
+    return [...candidates];
+}
 export function tryAutoInstall(pkg) {
     logger.step(`Installing ${pkg} ...`);
     try {
@@ -43,21 +59,29 @@ export function checkOpenSpecInitialized(cwd) {
     return dirExists(path.join(cwd, 'openspec'));
 }
 export function readState(cwd) {
-    const stateFile = path.join(cwd, '.claude', 'openflow-state.json');
-    if (!fileExists(stateFile))
-        return null;
-    try {
-        return JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
-    }
-    catch {
-        return null;
+    for (const stateFile of getStateFileCandidates(cwd)) {
+        if (!fileExists(stateFile))
+            continue;
+        try {
+            return JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
     }
+    return null;
 }
 export function writeState(cwd, state) {
-    const stateDir = path.join(cwd, '.claude');
+    const stateDir = path.join(cwd, '.openflow');
     if (!dirExists(stateDir)) {
         fs.mkdirSync(stateDir, { recursive: true });
     }
-    const stateFile = path.join(stateDir, 'openflow-state.json');
+    const stateFile = path.join(stateDir, 'state.json');
     fs.writeFileSync(stateFile, JSON.stringify(state, null, 2) + '\n');
 }
+function getStateFileCandidates(cwd) {
+    return [
+        path.join(cwd, '.openflow', 'state.json'),
+        path.join(cwd, '.claude', 'openflow-state.json'),
+    ];
+}

package/dist/core/skill-generator.d.ts

@@ -3,5 +3,6 @@ export interface GenerateOptions {
     cwd: string;
     tools: string[];
     depStatus: DepStatus;
+    global?: boolean;
 }
 export declare function generateSkills(options: GenerateOptions): void;

package/dist/core/skill-generator.js

@@ -1,7 +1,8 @@
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { fileExists, dirExists } from '../utils/shell.js';
+import { fileExists } from '../utils/shell.js';
 import { logger } from '../utils/logger.js';
 import { SKILL_NAME, TOOL_PATHS, DEPS } from './constants.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -9,16 +10,20 @@ const __dirname = path.dirname(__filename);
 // Resolve templates dir: from dist/core/ → ../../templates/
 const TEMPLATES_DIR = path.resolve(__dirname, '..', '..', 'templates');
 export function generateSkills(options) {
-    const { cwd, tools, depStatus } = options;
+    const { cwd, tools, depStatus, global = false } = options;
+    const baseDir = global ? os.homedir() : cwd;
     for (const tool of tools) {
         const toolPaths = TOOL_PATHS[tool];
         if (!toolPaths) {
             logger.warn(`Unknown tool: ${tool}, skipping`);
             continue;
         }
-        const skillsDir = path.join(cwd, toolPaths.skillsDir, SKILL_NAME);
-        logger.step(`Generating ${tool} skills to ${path.relative(cwd, skillsDir)}/`);
-        if (!dirExists(skillsDir)) {
+        const skillsDir = path.join(baseDir, toolPaths.skillsDir, SKILL_NAME);
+        const displayPath = global
+            ? path.join('~', toolPaths.skillsDir, SKILL_NAME)
+            : path.relative(cwd, skillsDir);
+        logger.step(`Generating ${tool} skills to ${displayPath}/`);
+        if (!fs.existsSync(skillsDir)) {
             fs.mkdirSync(skillsDir, { recursive: true });
         }
         // Generate main SKILL.md
@@ -61,7 +66,7 @@ function injectRuntimeDepCheck(content, depStatus) {
 
 | 依赖 | 检测方式 | 不可用时 |
 |------|----------|----------|
-| Superpowers writing-plans | \`~/.claude/skills/writing-plans/SKILL.md\` 是否存在 | 降级为手动拆解 plan-ready.md 中的步骤，逐条执行 |
+| Superpowers writing-plans | 当前工具的本地或全局 skills 目录下是否存在 \`writing-plans/SKILL.md\` | 降级为手动拆解 plan-ready.md 中的步骤，逐条执行 |
 | OpenSpec CLI | \`openspec\` 命令是否可执行 | 不影响 build 阶段，但 close 阶段归档需手动 mv |
 
 如果 Superpowers 不可用，提示用户：
@@ -82,12 +87,12 @@ function injectRuntimeDepCheck(content, depStatus) {
 }
 function injectSpecRuntimeCheck(content, depStatus) {
     const checkNote = `
-> **OpenSpec 检测**：如果 \`openspec\` CLI 可用，调用 \`openspec propose\` 生成完整规格；否则手动根据 proposal.md 生成 design.md + specs/ + tasks.md。
+> **OpenSpec 检测**：根据 proposal.md 生成 design.md + specs/ + tasks.md；如果 \`openspec\` CLI 可用，生成后运行 \`openspec validate <变更名> --strict\` 校验。
 `;
     const lines = content.split('\n');
-    const proposeIdx = lines.findIndex((l) => l.includes('openspec propose'));
-    if (proposeIdx >= 0) {
-        lines.splice(proposeIdx + 1, 0, checkNote);
+    const validateIdx = lines.findIndex((l) => l.includes('openspec validate'));
+    if (validateIdx >= 0) {
+        lines.splice(validateIdx, 0, checkNote);
     }
     return lines.join('\n');
 }
@@ -136,7 +141,7 @@ description: "OpenSpec + Superpowers 工作流协调器。使用 /openflow propo
 
 1. 如果用户指定了子命令（如 \`/openflow build\`），优先按指定阶段执行，但检查前置条件
 2. 如果用户只输入 \`/openflow\`，执行状态检测，自动路由到对应阶段
-3. 读取阶段文件：\`\${CLAUDE_SKILL_DIR}/<阶段>.md\`
+3. 读取当前 openflow skill 目录下的阶段文件：\`<阶段>.md\`（与本 \`SKILL.md\` 同目录；不要依赖 Claude 专属环境变量）
 4. 按阶段文件中的流程执行
 
 ### 前置条件检查

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lininn/openflow",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "OpenSpec + Superpowers workflow orchestrator for Claude Code",
   "bin": {
     "openflow": "./bin/openflow.js"

package/templates/SKILL.md

@@ -41,7 +41,7 @@ description: "OpenSpec + Superpowers workflow orchestrator. Use /openflow propos
 
 1. 如果用户指定了子命令（如 `/openflow build`），优先按指定阶段执行，但检查前置条件
 2. 如果用户只输入 `/openflow`，执行状态检测，自动路由到对应阶段
-3. 读取阶段文件：`${CLAUDE_SKILL_DIR}/<阶段>.md`
+3. 读取当前 openflow skill 目录下的阶段文件：`<阶段>.md`（与本 `SKILL.md` 同目录；不要依赖 Claude 专属环境变量）
 4. 按阶段文件中的流程执行
 
 ### 前置条件检查

package/templates/brainstorming.md

@@ -37,22 +37,22 @@ description: Deep design — multi-round exploration to confirm architecture and
 
 > "确认的设计方向：[方案名]。核心决策：[2-3 条]。这样对吗？"
 
-### 5. 创建 OpenSpec 变更
+### 5. 创建 OpenSpec 变更目录
 
-用户确认后，调用 OpenSpec 创建变更：
+用户确认后，按 OpenSpec 目录约定创建变更。`<变更名>` 使用 kebab-case、动词开头（如 `add-user-login`）：
 
 ```bash
-openspec new <变更名>
+mkdir -p openspec/changes/<变更名>/specs
 ```
 
-如果 OpenSpec CLI 不可用，手动创建目录结构：
+将确认的需求描述和设计方向写入 `openspec/changes/<变更名>/proposal.md`。
+
+如果 OpenSpec CLI 可用，可用以下命令检查当前变更列表：
 
 ```bash
-mkdir -p openspec/changes/<变更名>/specs
+openspec list
 ```
 
-将确认的需求描述和设计方向写入 `openspec/changes/<变更名>/proposal.md`。
-
 ### 6. 提示下一步
 
 > "需求已记录。接下来可以用 `/openflow spec` 生成完整规格。"

package/templates/close.md

@@ -52,10 +52,16 @@ description: Verify implementation consistency and archive
 
 ### 5. 归档
 
-全部一致（或用户接受不一致项）后，执行归档：
+全部一致（或用户接受不一致项）后，先校验变更：
 
 ```bash
-openspec archive <变更名>
+openspec validate <变更名> --strict
+```
+
+校验通过后执行归档：
+
+```bash
+openspec archive <变更名> --yes
 ```
 
 如果 OpenSpec CLI 不可用，手动归档：

package/templates/proposal.md

@@ -27,22 +27,22 @@ description: Lightweight requirement capture — 3-5 questions to quickly conver
 
 > "我理解的需求是：[一句话概括]。具体来说：[2-3 条要点]。这样理解对吗？"
 
-### 3. 创建 OpenSpec 变更
+### 3. 创建 OpenSpec 变更目录
 
-用户确认后，调用 OpenSpec 创建变更：
+用户确认后，按 OpenSpec 目录约定创建变更。`<变更名>` 使用 kebab-case、动词开头（如 `add-user-login`）：
 
 ```bash
-openspec new <变更名>
+mkdir -p openspec/changes/<变更名>/specs
 ```
 
-如果 OpenSpec CLI 不可用，手动创建目录结构：
+将确认的需求描述写入 `openspec/changes/<变更名>/proposal.md`。
+
+如果 OpenSpec CLI 可用，可用以下命令检查当前变更列表：
 
 ```bash
-mkdir -p openspec/changes/<变更名>/specs
+openspec list
 ```
 
-将确认的需求描述写入 `openspec/changes/<变更名>/proposal.md`。
-
 ### 4. 提示下一步
 
 > "需求已记录。接下来可以用 `/openflow spec` 生成完整规格，或继续补充细节。"

package/templates/spec.md

@@ -26,21 +26,23 @@ description: Call OpenSpec to generate specs, auto-translate to plan-ready.md af
 如果有多个，列出并让用户选择：
 > "检测到多个活跃变更：[列表]。要对哪个生成规格？"
 
-### 2. 调用 OpenSpec 生成规格
+### 2. 生成 OpenSpec 规格文件
 
-调用 OpenSpec 的 propose 命令（或 OPSX 工作流）生成完整规格：
-
-```bash
-openspec propose <变更名>
-```
-
-如果 OpenSpec CLI 不可用，手动根据 proposal.md 的内容生成以下文件：
+根据 proposal.md 的内容生成或补齐以下文件：
 
 - `openspec/changes/<变更名>/proposal.md` — 已存在，可补充
 - `openspec/changes/<变更名>/design.md` — 技术方案
 - `openspec/changes/<变更名>/specs/` — 具体规格变更（标记新增/修改/删除）
 - `openspec/changes/<变更名>/tasks.md` — 实现任务清单
 
+如果 OpenSpec CLI 可用，生成后运行校验：
+
+```bash
+openspec validate <变更名> --strict
+```
+
+如果校验失败，根据错误修正上述文件后重新校验。
+
 ### 3. 与用户确认规格
 
 展示规格摘要，逐项确认：