@lininn/openflow 0.1.0 → 0.1.2

package/README.md

@@ -1,103 +1,123 @@
 # @lininn/openflow
 
-OpenSpec + Superpowers 工作流协调器，串联需求规格与工程执行，消除格式鸿沟。
+[中文文档](./README.zh-CN.md)
 
-## 安装
+OpenSpec + Superpowers workflow orchestrator — bridging requirements specs and engineering execution, eliminating the format gap.
+
+## Installation
 
 ```bash
 npm install -g @lininn/openflow
 ```
 
-## 使用
+## Usage
 
-### 初始化项目
+### Initialize a project
 
 ```bash
 cd your-project
 openflow init --tools claude
 ```
 
-`init` 会自动：
-1. 检测并引导安装 OpenSpec CLI
-2. 检测 Superpowers 并提示安装方式
-3. 检测项目 OpenSpec 初始化状态
-4. 生成 openflow skills 到项目 `.claude/skills/openflow/`
+`init` will automatically:
+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/`
 
-支持的工具：`claude`、`codex`、`cursor`（逗号分隔，如 `--tools claude,codex`）
+Supported tools: `claude`, `codex`, `cursor` (comma-separated, e.g. `--tools claude,codex`)
 
-### 查看状态
+### Check status
 
 ```bash
 openflow status
 ```
 
-显示依赖安装状态和项目中的活跃变更。
+Shows dependency installation status and active changes in the project.
 
-### 更新 skills
+### Update skills
 
 ```bash
 openflow update
 ```
 
-升级 npm 包后运行，重新生成项目内的 skills 文件。
+Re-generates project skills after upgrading the npm package.
 
-## 工作流命令
+## Workflow Commands
 
-| 命令 | 阶段 | 说明 |
-|------|------|------|
-| `/openflow proposal` | proposal | 轻量提问，3-5 问快速收敛需求 |
-| `/openflow brainstorming` | brainstorming | 深度设计，多轮方案探索 |
-| `/openflow spec` | spec | 调用 OpenSpec 生成规格 + 自动翻译 |
-| `/openflow build` | build | 调用 Superpowers 执行实现 |
-| `/openflow close` | close | 验证一致性 + 归档 |
+| Command | Phase | Description |
+|---------|-------|-------------|
+| `/openflow proposal` | proposal | Lightweight capture — 3-5 questions to converge on requirements |
+| `/openflow brainstorming` | brainstorming | Deep design — multi-round tradeoff exploration |
+| `/openflow spec` | spec | Call OpenSpec to generate specs + auto-translate to plan-ready.md |
+| `/openflow build` | build | Call Superpowers to execute implementation |
+| `/openflow close` | close | Verify consistency + archive |
 
-## 依赖策略
+## Dependency Strategy
 
 ```
 Best with: OpenSpec + Superpowers
 Works without them: yes, with manual-file fallback
 ```
 
-| 依赖 | 安装方式 | 缺失时降级 |
-|------|----------|-----------|
-| OpenSpec | `npm install -g @fission-ai/openspec@latest` | 手动创建 `openspec/changes/` 目录和文件 |
-| Superpowers | `/plugin install superpowers@claude-plugins-official` | build 阶段手动拆解 plan-ready.md 步骤执行 |
+| Dependency | Install | Fallback when missing |
+|------------|---------|----------------------|
+| OpenSpec | `npm install -g @fission-ai/openspec@latest` | Manually create `openspec/changes/` directories and files |
+| Superpowers | `/plugin install superpowers@claude-plugins-official` | Manually break down plan-ready.md steps in build phase |
+
+### Dual-layer dependency check
 
-## 架构
+| Layer | Mechanism | When missing |
+|-------|-----------|-------------|
+| **Init time** | Detect OpenSpec → auto-install; Detect Superpowers → show install hint | Non-blocking, skills still generated |
+| **Runtime** | Dependency check injected into SKILL.md | Build phase falls back to manual step-by-step execution |
+
+## Architecture
 
 ```
-用户需求
+User Requirements
    │
-   ├── 轻量 ──→ /openflow proposal ──┐
-   │          3-5问快速收敛          │
-   │                                 ├─→ proposal.md
-   └── 深度 ──→ /openflow brainstorming ─┘ (openspec/changes/<name>/)
-               多轮方案探索
+   ├── Quick ──→ /openflow proposal ──┐
+   │           3-5 questions          │
+   │                                  ├─→ proposal.md
+   └── Deep ───→ /openflow brainstorming ─┘ (openspec/changes/<name>/)
+               Multi-round exploration
                                      │
                           ┌──────────▼───────────┐
                           │  /openflow spec        │
-                          │  OpenSpec 生成规格      │
+                          │  OpenSpec generates     │
                           └──────────┬───────────┘
                                      │
                           ┌──────────▼───────────┐
-                          │   翻译层 (核心)        │
-                          │  需求视角 → 工程视角    │
+                          │   Translation Layer    │
+                          │  Requirements → Eng    │
                           └──────────┬───────────┘
                                      │
                                 plan-ready.md
                                      │
                           ┌──────────▼───────────┐
                           │  /openflow build       │
-                          │  Superpowers 执行      │
-                          │  TDD 铁律 + 断点恢复   │
+                          │  Superpowers execution │
+                          │  TDD + checkpoint      │
                           └──────────┬───────────┘
                                      │
                           ┌──────────▼───────────┐
                           │  /openflow close       │
-                          │  验证一致性 + 归档      │
+                          │  Verify + archive      │
                           └──────────────────────┘
 ```
 
+## Acknowledgments
+
+openflow orchestrates two open-source projects:
+
+| Project | Repository | License | Usage |
+|---------|-----------|---------|-------|
+| [OpenSpec](https://github.com/Fission-AI/OpenSpec) | `@fission-ai/openspec` | MIT | Generates structured spec files (proposal.md, design.md, specs/, tasks.md). openflow calls its CLI and reads its output format. |
+| [Superpowers](https://github.com/obra/superpowers) | `superpowers` plugin | MIT | Provides `writing-plans` skill for detailed implementation planning. openflow delegates build-phase execution to its workflow. |
+
+openflow is a **standalone orchestrator** — it does not bundle, fork, or embed code from either project. Dependencies are detected at init/runtime, with manual fallback when either is not installed.
+
 ## License
 
 MIT

package/README.zh-CN.md

@@ -0,0 +1,123 @@
+# @lininn/openflow
+
+[English](./README.md)
+
+OpenSpec + Superpowers 工作流协调器，串联需求规格与工程执行，消除格式鸿沟。
+
+## 安装
+
+```bash
+npm install -g @lininn/openflow
+```
+
+## 使用
+
+### 初始化项目
+
+```bash
+cd your-project
+openflow init --tools claude
+```
+
+`init` 会自动：
+1. 检测并引导安装 OpenSpec CLI
+2. 检测 Superpowers 并提示安装方式
+3. 检测项目 OpenSpec 初始化状态
+4. 生成 openflow skills 到项目 `.claude/skills/openflow/`
+
+支持的工具：`claude`、`codex`、`cursor`（逗号分隔，如 `--tools claude,codex`）
+
+### 查看状态
+
+```bash
+openflow status
+```
+
+显示依赖安装状态和项目中的活跃变更。
+
+### 更新 skills
+
+```bash
+openflow update
+```
+
+升级 npm 包后运行，重新生成项目内的 skills 文件。
+
+## 工作流命令
+
+| 命令 | 阶段 | 说明 |
+|------|------|------|
+| `/openflow proposal` | proposal | 轻量提问，3-5 问快速收敛需求 |
+| `/openflow brainstorming` | brainstorming | 深度设计，多轮方案探索 |
+| `/openflow spec` | spec | 调用 OpenSpec 生成规格 + 自动翻译 |
+| `/openflow build` | build | 调用 Superpowers 执行实现 |
+| `/openflow close` | close | 验证一致性 + 归档 |
+
+## 依赖策略
+
+```
+Best with: OpenSpec + Superpowers
+Works without them: yes, with manual-file fallback
+```
+
+| 依赖 | 安装方式 | 缺失时降级 |
+|------|----------|-----------|
+| OpenSpec | `npm install -g @fission-ai/openspec@latest` | 手动创建 `openspec/changes/` 目录和文件 |
+| Superpowers | `/plugin install superpowers@claude-plugins-official` | build 阶段手动拆解 plan-ready.md 步骤执行 |
+
+### 双层依赖保障
+
+| 层 | 机制 | 缺失时 |
+|----|------|--------|
+| **init 时** | 检测 OpenSpec → 自动安装；检测 Superpowers → 提示安装命令 | 不阻断，继续生成 skills |
+| **运行时** | SKILL.md 注入依赖检测段 | build 阶段降级为手动拆解步骤执行 |
+
+## 架构
+
+```
+用户需求
+   │
+   ├── 轻量 ──→ /openflow proposal ──┐
+   │          3-5问快速收敛          │
+   │                                 ├─→ proposal.md
+   └── 深度 ──→ /openflow brainstorming ─┘ (openspec/changes/<name>/)
+               多轮方案探索
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /openflow spec        │
+                          │  OpenSpec 生成规格      │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │   翻译层 (核心)        │
+                          │  需求视角 → 工程视角    │
+                          └──────────┬───────────┘
+                                     │
+                                plan-ready.md
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /openflow build       │
+                          │  Superpowers 执行      │
+                          │  TDD 铁律 + 断点恢复   │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /openflow close       │
+                          │  验证一致性 + 归档      │
+                          └──────────────────────┘
+```
+
+## 致谢
+
+openflow 编排了以下两个开源项目：
+
+| 项目 | 仓库 | 许可证 | 使用方式 |
+|------|------|--------|----------|
+| [OpenSpec](https://github.com/Fission-AI/OpenSpec) | `@fission-ai/openspec` | MIT | 生成结构化规格文件（proposal.md、design.md、specs/、tasks.md）。openflow 调用其 CLI 并读取其输出格式。 |
+| [Superpowers](https://github.com/obra/superpowers) | `superpowers` 插件 | MIT | 提供 `writing-plans` skill 用于生成详细实现计划。openflow 在 build 阶段委托其工作流执行。 |
+
+openflow 是**独立编排器** — 不捆绑、不分叉、不嵌入任何项目的代码。依赖在 init/运行时检测，任一缺失时降级为手动模式。
+
+## License
+
+MIT

package/dist/cli/index.js

@@ -6,7 +6,7 @@ export function run() {
     const program = new Command();
     program
         .name('openflow')
-        .description('OpenSpec + Superpowers 工作流协调器')
+        .description('OpenSpec + Superpowers workflow orchestrator')
         .version('0.1.0');
     program.addCommand(initCommand);
     program.addCommand(statusCommand);

package/dist/cli/init.js

@@ -7,24 +7,24 @@ import { logger } from '../utils/logger.js';
 import { exec } from '../utils/shell.js';
 const SUPPORTED_TOOLS = Object.keys(TOOL_PATHS);
 export const initCommand = new Command('init')
-    .description('在当前项目初始化 openflow skills')
-    .option('-t, --tools <tools>', '目标工具，逗号分隔', 'claude')
+    .description('Initialize openflow skills in the current project')
+    .option('-t, --tools <tools>', 'Target tools, comma-separated', 'claude')
     .action(async (options) => {
     const cwd = process.cwd();
     const tools = options.tools.split(',').map((t) => t.trim());
     logger.blank();
-    logger.info('openflow init — 初始化工作流协调器');
+    logger.info('openflow init — workflow orchestrator setup');
     logger.blank();
     // Step 1: Check OpenSpec
-    logger.step('检测 OpenSpec ...');
+    logger.step('Checking OpenSpec ...');
     let depStatus = checkDependencies();
     if (!depStatus.openspec.installed) {
-        logger.warn('OpenSpec CLI 未安装');
+        logger.warn('OpenSpec CLI not installed');
         const { installOpenSpec } = await inquirer.prompt([
             {
                 type: 'confirm',
                 name: 'installOpenSpec',
-                message: `是否自动安装？(npm install -g ${DEPS.openspec.npmPkg}@latest)`,
+                message: `Auto-install? (npm install -g ${DEPS.openspec.npmPkg}@latest)`,
                 default: true,
             },
         ]);
@@ -35,49 +35,49 @@ export const initCommand = new Command('init')
                 depStatus.openspec.autoInstalled = true;
         }
         else {
-            logger.warn('跳过 OpenSpec 安装，spec 阶段将使用手动降级模式');
+            logger.warn('Skipped OpenSpec install — spec phase will use manual fallback');
         }
     }
     else {
-        logger.success(`OpenSpec CLI 已安装${depStatus.openspec.version ? ` (v${depStatus.openspec.version})` : ''}`);
+        logger.success(`OpenSpec CLI installed${depStatus.openspec.version ? ` (v${depStatus.openspec.version})` : ''}`);
     }
     // Step 2: Check Superpowers
-    logger.step('检测 Superpowers ...');
+    logger.step('Checking Superpowers ...');
     if (!depStatus.superpowers.installed) {
-        logger.warn('Superpowers 未安装');
+        logger.warn('Superpowers not installed');
         logger.info(DEPS.superpowers.installHint);
-        logger.info('安装后可重新运行 openflow init，或 build 阶段将使用手动降级模式');
+        logger.info('Re-run openflow init after installing, or build phase will use manual fallback');
     }
     else {
-        logger.success('Superpowers 已安装');
+        logger.success('Superpowers installed');
     }
     // Step 3: Check if OpenSpec is initialized in project
-    logger.step('检测项目 OpenSpec 初始化 ...');
+    logger.step('Checking project OpenSpec initialization ...');
     if (!checkOpenSpecInitialized(cwd)) {
         if (depStatus.openspec.installed) {
             const { initOpenSpec } = await inquirer.prompt([
                 {
                     type: 'confirm',
                     name: 'initOpenSpec',
-                    message: '项目未初始化 OpenSpec，是否运行 openspec init？',
+                    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 项目初始化完成');
+                logger.success('OpenSpec project initialized');
             }
         }
         else {
-            logger.info('项目未初始化 OpenSpec，将在首次使用 /openflow proposal 时自动创建目录');
+            logger.info('OpenSpec not initialized — directories will be auto-created on first /openflow proposal');
         }
     }
     else {
-        logger.success('OpenSpec 项目已初始化');
+        logger.success('OpenSpec project initialized');
     }
     // Step 4: Generate skills
-    logger.step('生成 openflow skills ...');
+    logger.step('Generating openflow skills ...');
     generateSkills({ cwd, tools, depStatus });
     // Step 5: Write state
     writeState(cwd, {
@@ -88,18 +88,18 @@ export const initCommand = new Command('init')
         tools,
     });
     logger.blank();
-    logger.success('openflow 初始化完成！');
+    logger.success('openflow initialized!');
     logger.blank();
     if (!depStatus.superpowers.installed) {
-        logger.warn('提示: Superpowers 未安装，/openflow build 将使用手动执行模式');
-        logger.info(`  安装方式: ${DEPS.superpowers.installHint}`);
+        logger.warn('Note: Superpowers not installed — /openflow build will use manual execution mode');
+        logger.info(`  Install with: ${DEPS.superpowers.installHint}`);
         logger.blank();
     }
-    logger.info('可用命令:');
-    logger.info('  /openflow proposal      轻量需求捕获');
-    logger.info('  /openflow brainstorming  深度设计探索');
-    logger.info('  /openflow spec           生成规格 + 翻译');
-    logger.info('  /openflow build          执行实现');
-    logger.info('  /openflow close          验证归档');
+    logger.info('Available commands:');
+    logger.info('  /openflow proposal      Quick requirement capture');
+    logger.info('  /openflow brainstorming  Deep design exploration');
+    logger.info('  /openflow spec           Generate specs + translate');
+    logger.info('  /openflow build          Execute implementation');
+    logger.info('  /openflow close          Verify + archive');
     logger.blank();
 });

package/dist/cli/status.js

@@ -5,58 +5,57 @@ import { checkDependencies, readState, checkOpenSpecInitialized } from '../core/
 import { logger } from '../utils/logger.js';
 import { dirExists } from '../utils/shell.js';
 export const statusCommand = new Command('status')
-    .description('显示依赖状态和活跃变更')
+    .description('Show dependency status and active changes')
     .action(() => {
     const cwd = process.cwd();
     logger.blank();
     logger.info('openflow status');
     logger.blank();
     // Dependencies
-    logger.step('依赖:');
+    logger.step('Dependencies:');
     const depStatus = checkDependencies();
     if (depStatus.openspec.installed) {
         logger.success(`OpenSpec CLI${depStatus.openspec.version ? ` v${depStatus.openspec.version}` : ''}`);
     }
     else {
-        logger.warn('OpenSpec CLI — 未安装');
+        logger.warn('OpenSpec CLI — not installed');
     }
     if (depStatus.superpowers.installed) {
         logger.success('Superpowers');
     }
     else {
-        logger.warn('Superpowers — 未安装 (build 阶段将使用手动模式)');
+        logger.warn('Superpowers — not installed (build phase will use manual mode)');
     }
     logger.blank();
     // Project state
-    logger.step('项目:');
+    logger.step('Project:');
     const state = readState(cwd);
     if (state) {
-        logger.success(`已初始化 (${state.tools.join(', ')})`);
-        logger.info(`  初始化时间: ${state.createdAt}`);
+        logger.success(`Initialized (${state.tools.join(', ')})`);
+        logger.info(`  Created at: ${state.createdAt}`);
     }
     else {
-        logger.warn('未初始化，请运行 openflow init');
+        logger.warn('Not initialized — run openflow init');
         return;
     }
     if (checkOpenSpecInitialized(cwd)) {
-        logger.success('OpenSpec 项目已初始化');
+        logger.success('OpenSpec project initialized');
     }
     else {
-        logger.warn('OpenSpec 项目未初始化');
+        logger.warn('OpenSpec project not initialized');
     }
     logger.blank();
     // Active changes
-    logger.step('活跃变更:');
+    logger.step('Active changes:');
     const changesDir = path.join(cwd, 'openspec', 'changes');
-    const archiveDir = path.join(changesDir, 'archive');
     if (!dirExists(changesDir)) {
-        logger.info('  无');
+        logger.info('  None');
         return;
     }
     const entries = fs.readdirSync(changesDir, { withFileTypes: true })
         .filter((d) => d.isDirectory() && d.name !== 'archive');
     if (entries.length === 0) {
-        logger.info('  无');
+        logger.info('  None');
         return;
     }
     for (const entry of entries) {

package/dist/cli/update.js

@@ -3,16 +3,16 @@ import { checkDependencies, readState, writeState, checkOpenSpecInitialized } fr
 import { generateSkills } from '../core/skill-generator.js';
 import { logger } from '../utils/logger.js';
 export const updateCommand = new Command('update')
-    .description('重新生成项目内的 openflow skills')
+    .description('Regenerate openflow skills in the current project')
     .action(() => {
     const cwd = process.cwd();
     const state = readState(cwd);
     if (!state) {
-        logger.error('项目未初始化，请先运行 openflow init');
+        logger.error('Project not initialized — run openflow init first');
         return;
     }
     logger.blank();
-    logger.info('openflow update — 重新生成 skills');
+    logger.info('openflow update — regenerating skills');
     logger.blank();
     const depStatus = checkDependencies();
     generateSkills({
@@ -27,6 +27,6 @@ export const updateCommand = new Command('update')
         openspecProjectInitialized: checkOpenSpecInitialized(cwd),
     });
     logger.blank();
-    logger.success('skills 已更新');
+    logger.success('Skills updated');
     logger.blank();
 });

package/dist/core/dependency-check.js

@@ -28,14 +28,14 @@ export function checkDependencies() {
     };
 }
 export function tryAutoInstall(pkg) {
-    logger.step(`正在安装 ${pkg} ...`);
+    logger.step(`Installing ${pkg} ...`);
     try {
         execSync(`npm install -g ${pkg}@latest`, { stdio: 'inherit' });
-        logger.success(`${pkg} 安装成功`);
+        logger.success(`${pkg} installed`);
         return true;
     }
     catch {
-        logger.error(`${pkg} 安装失败，请手动执行: npm install -g ${pkg}@latest`);
+        logger.error(`Failed to install ${pkg} — please run manually: npm install -g ${pkg}@latest`);
         return false;
     }
 }

package/dist/core/skill-generator.js

@@ -13,11 +13,11 @@ export function generateSkills(options) {
     for (const tool of tools) {
         const toolPaths = TOOL_PATHS[tool];
         if (!toolPaths) {
-            logger.warn(`未知工具: ${tool}，跳过`);
+            logger.warn(`Unknown tool: ${tool}, skipping`);
             continue;
         }
         const skillsDir = path.join(cwd, toolPaths.skillsDir, SKILL_NAME);
-        logger.step(`生成 ${tool} skills 到 ${path.relative(cwd, skillsDir)}/`);
+        logger.step(`Generating ${tool} skills to ${path.relative(cwd, skillsDir)}/`);
         if (!dirExists(skillsDir)) {
             fs.mkdirSync(skillsDir, { recursive: true });
         }
@@ -28,7 +28,7 @@ export function generateSkills(options) {
         for (const phase of phases) {
             generateSkillFile(skillsDir, `${phase}.md`, depStatus);
         }
-        logger.success(`${tool} skills 生成完成`);
+        logger.success(`${tool} skills generated`);
     }
 }
 function generateSkillFile(skillsDir, filename, depStatus) {
@@ -61,13 +61,13 @@ function injectRuntimeDepCheck(content, depStatus) {
 
 | 依赖 | 检测方式 | 不可用时 |
 |------|----------|----------|
-| Superpowers writing-plans | \\\`~/.claude/skills/writing-plans/SKILL.md\\\` 是否存在 | 降级为手动拆解 plan-ready.md 中的步骤，逐条执行 |
-| OpenSpec CLI | \\\`openspec\\\` 命令是否可执行 | 不影响 build 阶段，但 close 阶段归档需手动 mv |
+| Superpowers writing-plans | \`~/.claude/skills/writing-plans/SKILL.md\` 是否存在 | 降级为手动拆解 plan-ready.md 中的步骤，逐条执行 |
+| OpenSpec CLI | \`openspec\` 命令是否可执行 | 不影响 build 阶段，但 close 阶段归档需手动 mv |
 
 如果 Superpowers 不可用，提示用户：
 > "Superpowers 未安装，build 将使用手动执行模式。安装后体验更佳：${DEPS.superpowers.installHint}"
 
-如果 Superpowers 可用，调用其 \\\`writing-plans\\\` skill 生成详细实现计划。
+如果 Superpowers 可用，调用其 \`writing-plans\` skill 生成详细实现计划。
 `;
     // Insert after the first heading
     const lines = content.split('\n');
@@ -82,7 +82,7 @@ function injectRuntimeDepCheck(content, depStatus) {
 }
 function injectSpecRuntimeCheck(content, depStatus) {
     const checkNote = `
-> **OpenSpec 检测**：如果 \\\`openspec\\\` CLI 可用，调用 \\\`openspec propose\\\` 生成完整规格；否则手动根据 proposal.md 生成 design.md + specs/ + tasks.md。
+> **OpenSpec 检测**：如果 \`openspec\` CLI 可用，调用 \`openspec propose\` 生成完整规格；否则手动根据 proposal.md 生成 design.md + specs/ + tasks.md。
 `;
     const lines = content.split('\n');
     const proposeIdx = lines.findIndex((l) => l.includes('openspec propose'));
@@ -106,21 +106,21 @@ description: "OpenSpec + Superpowers 工作流协调器。使用 /openflow propo
 
 | 命令 | 阶段 | 说明 |
 |------|------|------|
-| \\\`/openflow proposal\\\` | proposal | 轻量提问，快速收敛需求 |
-| \\\`/openflow brainstorming\\\` | brainstorming | 深度设计，多轮探索 |
-| \\\`/openflow spec\\\` | spec | 调用 OpenSpec 生成规格 + 翻译 |
-| \\\`/openflow build\\\` | build | 调用 Superpowers 执行实现 |
-| \\\`/openflow close\\\` | close | 验证一致性 + 归档 |
+| \`/openflow proposal\` | proposal | 轻量提问，快速收敛需求 |
+| \`/openflow brainstorming\` | brainstorming | 深度设计，多轮探索 |
+| \`/openflow spec\` | spec | 调用 OpenSpec 生成规格 + 翻译 |
+| \`/openflow build\` | build | 调用 Superpowers 执行实现 |
+| \`/openflow close\` | close | 验证一致性 + 归档 |
 
 ## 状态检测
 
-当用户调用 \\\`/openflow\\\` 不带子命令，或调用某个子命令需要确认前置条件时，执行以下状态检测：
+当用户调用 \`/openflow\` 不带子命令，或调用某个子命令需要确认前置条件时，执行以下状态检测：
 
 | 检查项 | 怎么查 | 结果 |
 |--------|--------|------|
-| 有活跃变更？ | \\\`openspec/changes/\\\` 下是否有非 archive 子目录 | 有→继续 |
-| 有 plan-ready.md？ | 变更目录下是否有 \\\`plan-ready.md\\\` | 有→看实现状态 |
-| 实现已开始？ | \\\`docs/superpowers/plans/\\\` 下是否有计划文件 | 有→看是否完成 |
+| 有活跃变更？ | \`openspec/changes/\` 下是否有非 archive 子目录 | 有→继续 |
+| 有 plan-ready.md？ | 变更目录下是否有 \`plan-ready.md\` | 有→看实现状态 |
+| 实现已开始？ | \`docs/superpowers/plans/\` 下是否有计划文件 | 有→看是否完成 |
 | 实现已完成？ | 计划文件全部 checkbox 已勾选 | 是→close 阶段 |
 
 判定结果：
@@ -134,9 +134,9 @@ description: "OpenSpec + Superpowers 工作流协调器。使用 /openflow propo
 
 根据子命令或状态检测结果，读取对应阶段文件并执行：
 
-1. 如果用户指定了子命令（如 \\\`/openflow build\\\`），优先按指定阶段执行，但检查前置条件
-2. 如果用户只输入 \\\`/openflow\\\`，执行状态检测，自动路由到对应阶段
-3. 读取阶段文件：\\\`\\\${CLAUDE_SKILL_DIR}/<阶段>.md\\\`
+1. 如果用户指定了子命令（如 \`/openflow build\`），优先按指定阶段执行，但检查前置条件
+2. 如果用户只输入 \`/openflow\`，执行状态检测，自动路由到对应阶段
+3. 读取阶段文件：\`\${CLAUDE_SKILL_DIR}/<阶段>.md\`
 4. 按阶段文件中的流程执行
 
 ### 前置条件检查

package/package.json

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

package/scripts/postinstall.js

@@ -1,12 +1,12 @@
 console.log(`
-openflow — OpenSpec + Superpowers 工作流协调器
+openflow — OpenSpec + Superpowers workflow orchestrator
 
-初始化项目:
+Initialize a project:
   openflow init --tools claude
 
-查看状态:
+Check status:
   openflow status
 
-更新 skills:
+Update skills:
   openflow update
 `);

package/templates/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: openflow
-description: "OpenSpec + Superpowers 工作流协调器。使用 /openflow proposal 轻量提问、/openflow brainstorming 深度设计、/openflow spec 生成规格、/openflow build 执行实现、/openflow close 验证归档。串联需求规格与工程执行，消除格式鸿沟。"
+description: "OpenSpec + Superpowers workflow orchestrator. Use /openflow proposal for quick capture, /openflow brainstorming for deep design, /openflow spec to generate specs + translate, /openflow build to execute, /openflow close to verify and archive. Bridges requirements specs and engineering execution."
 ---
 
 # openflow: 工作流协调器

package/templates/brainstorming.md

@@ -1,6 +1,6 @@
 ---
 name: openflow/brainstorming
-description: 深度设计 — 多轮探索，确认架构和方案
+description: Deep design — multi-round exploration to confirm architecture and approach
 ---
 
 # Brainstorming: 深度设计

package/templates/build.md

@@ -1,6 +1,6 @@
 ---
 name: openflow/build
-description: 调用 Superpowers 执行实现，支持断点恢复
+description: Call Superpowers to execute implementation, supports checkpoint recovery
 ---
 
 # Build: Superpowers 执行

package/templates/close.md

@@ -1,6 +1,6 @@
 ---
 name: openflow/close
-description: 验证实现一致性并归档
+description: Verify implementation consistency and archive
 ---
 
 # Close: 验证归档

package/templates/proposal.md

@@ -1,6 +1,6 @@
 ---
 name: openflow/proposal
-description: 轻量需求捕获 — 3-5 个问题快速收敛需求
+description: Lightweight requirement capture — 3-5 questions to quickly converge on requirements
 ---
 
 # Proposal: 轻量需求捕获

package/templates/spec.md

@@ -1,6 +1,6 @@
 ---
 name: openflow/spec
-description: 调用 OpenSpec 生成规格文档，确认后自动翻译为 plan-ready.md
+description: Call OpenSpec to generate specs, auto-translate to plan-ready.md after user confirmation
 ---
 
 # Spec: 生成规格并翻译