@openorbit/skill 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZK-Andy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# OpenOrbit -- Development Governance Compass
+
+A meta-skill for OpenCode AI assistants that routes development tasks to the right workflow path automatically.
+
+---
+
+## What is OpenOrbit?
+
+OpenOrbit is a governance compass, not a tool. It lives inside an OpenCode-powered AI agent and determines the optimal workflow for whatever task lands on its plate. When you ask for a new feature, a bug fix, or a quick change, OpenOrbit classifies the work and steers the agent through the right sequence of steps: propose, design, implement, review, verify, archive. It makes sure nothing gets skipped and nothing gets over-engineered.
+
+The project bundles four engines that work together. openspec-cn defines what to do. oh-my-opencode orchestrates who does it. superpowers-zh enforces quality standards. dotnet-skills provides deep technical knowledge for implementation work.
+
+---
+
+## Features
+
+- **Intelligent task routing.** Five workflow paths match the scope of the change. The system picks one automatically so the agent never wastes time on ceremony it does not need.
+- **Four-engine architecture.** openspec-cn, oh-my-opencode, superpowers-zh, and dotnet-skills each own a layer. You can upgrade or replace any engine without touching the others.
+- **Bilingual support.** The spec layer, commit messages, and code reviews all work in both English and Chinese. Teams can mix languages freely.
+- **Quality gates at every stage.** Each workflow step has a verification gate: spec validation, architecture review, test-driven development, code review, and final verification before archive.
+
+---
+
+## Prerequisites
+
+OpenOrbit requires an OpenCode-compatible AI environment and a Git-based project. Full setup details are in [docs/prerequisites.md](docs/prerequisites.md).
+
+The four engines each have their own prerequisites:
+
+- **openspec-cn** -- Workflow shell that defines the step sequence. See its documentation for the spec-driven workflow model.
+- **oh-my-opencode** -- Execution orchestration layer. The Atlas/Sisyphus master agent dispatches tasks, supervises sub-agents, and runs reviews.
+- **superpowers-zh** -- Quality gates for code review, commit conventions, documentation standards, and TDD workflows.
+- **dotnet-skills** -- 159+ .NET domain skills covering ASP.NET Core, Blazor, EF Core, MAUI, WPF, testing, performance, and more.
+
+---
+
+## Quick Start
+
+You have three ways to install OpenOrbit in your project. Pick the one that fits your setup.
+
+### Direct copy
+
+Clone the repository and copy the skill directory into your project.
+
+```
+git clone https://github.com/ZK-Andy/OpenOrbit.git
+cp -r OpenOrbit/skills/OpenOrbit/ your-project/.opencode/skills/
+```
+
+### npm
+
+Install the published package, then link or copy it to your skills directory.
+
+```
+npm install @openorbit/skill
+cp -r node_modules/@openorbit/skill/dist your-project/.opencode/skills/OpenOrbit/
+```
+
+### Git submodule
+
+Add the repository as a submodule and create a symlink or copy.
+
+```
+git submodule add https://github.com/ZK-Andy/OpenOrbit.git .openorbit
+ln -s ../../.openorbit/skills/OpenOrbit .opencode/skills/OpenOrbit
+```
+
+On Windows, use a junction or copy instead of a symlink.
+
+---
+
+## How It Works
+
+OpenOrbit classifies every incoming task by type and routes it through one of five workflow paths.
+
+- **New feature with architecture decisions.** Full path: propose -> apply -> sync -> verify -> archive. The agent creates a proposal, generates specs and design docs, implements the code, syncs specs back to the main spec tree, verifies everything, and archives the change record.
+
+- **Small feature with clear architecture.** Short path: propose -> apply -> archive. The agent proposes the change and moves straight to implementation, skipping the sync step because the spec impact is minimal.
+
+- **Minimal change under 10 lines.** Fast-forward path: ff -> archive. The agent applies the change directly and archives it. No proposal, no spec, no design. Just the diff and a record.
+
+- **Bug fix.** Fast-forward plus debugging: ff + systematic-debugging -> archive. The agent runs a structured debugging workflow, applies the fix, and archives it.
+
+- **Exploration.** Explore path: explore -> (choose next path). The agent enters exploration mode to investigate a problem or clarify requirements, then picks one of the other paths once the picture is clear.
+
+Every step in every path has a quality gate. The agent cannot proceed to the next step without passing verification.
+
+---
+
+## Project Structure
+
+```
+OpenOrbit/
+├── .github/
+│   └── ISSUE_TEMPLATE/       # Contribution issue templates
+├── docs/
+│   └── design/               # Architecture decision records
+├── examples/
+│   └── sample-project/       # Example project using OpenOrbit
+├── skills/
+│   └── OpenOrbit/            # The skill itself
+│       ├── SKILL.md          # Skill definition and invocation
+│       └── ...               # Supporting resources
+├── README.md                 # This file
+└── LICENSE                   # MIT License
+```
+
+---
+
+## Contributing
+
+Contributions are welcome. Please open an issue first to discuss what you would like to change. Pull requests should target the main branch and include a description of the change and its motivation.
+
+All contributions are governed by the standards defined in the OpenOrbit workflow itself. Open an issue for feature requests, bug reports, or questions.
+
+---
+
+## License
+
+[MIT](LICENSE)
+
+Copyright (c) 2026 ZK-Andy

package/README.zh-CN.md

@@ -0,0 +1,100 @@
+# OpenOrbit — 开发治理罗盘
+
+**Development Governance Compass**
+
+OpenOrbit 是一个面向 OpenCode AI 助手的元技能（meta-skill）。它能自动将开发任务路由到最优工作流路径，让 AI 助手根据任务类型选择正确的工作流，而不是用一种方法处理所有场景。
+
+OpenOrbit 不是一个工具，而是一个罗盘。它告诉你该走哪条路，而不是替你把路走完。
+
+## 功能特性
+
+- **智能任务路由** — 支持 5 种工作流路径，根据任务类型自动匹配最优流程
+- **四引擎架构驱动** — 由 openspec-cn、oh-my-opencode、superpowers-zh 和 dotnet-skills 四套技术栈协同工作
+- **中英双语支持** — 项目文档和技能说明同时提供中英文版本
+- **各环节质量门禁** — 每个步骤都内置验证机制，确保产出质量
+
+## 前置依赖
+
+OpenOrbit 基于以下四个核心引擎运行：
+
+- **openspec-cn** — 规范驱动的工作流外壳，管理提案、设计、任务和归档
+- **oh-my-opencode** — 执行层编排引擎，负责任务分解和子 agent 调度
+- **superpowers-zh** — 中文增强技能框架，提供 20 个开发技能
+- **dotnet-skills** — .NET 领域知识库，包含 159 个专业技能
+
+详细说明请参考 [前置依赖文档](docs/prerequisites.md)。
+
+## 快速安装
+
+OpenOrbit 提供三种安装方式，你可以根据使用场景选择最合适的一种。
+
+### 方式一：直接复制
+
+将 `skills/OpenOrbit/` 目录复制到你的 OpenCode 项目技能目录中：
+
+```bash
+cp -r skills/OpenOrbit/ <你的项目>/.opencode/skills/
+```
+
+### 方式二：npm 安装
+
+```bash
+npm install @openorbit/skill
+```
+
+安装后，在 OpenCode 配置中引用 `@openorbit/skill` 即可。
+
+### 方式三：Git submodule
+
+```bash
+git submodule add https://github.com/ZK-Andy/OpenOrbit.git .openorbit
+```
+
+通过 submodule 方式可以获得最新的更新，便于长期维护。
+
+## 工作原理
+
+OpenOrbit 的核心是一个路由系统。它根据任务类型将请求分发到不同的工作流路径：
+
+1. **新功能完整路径** — 适用于新增功能或模块。流程为：提案 -> 规约 -> 设计 -> 任务分解 -> 实现 -> 验证 -> 归档
+2. **小功能快捷路径** — 适用于小范围修改或增量功能。跳过完整设计阶段，直接从规约进入实现
+3. **极简修改** — 适用于文案调整、配置变更等微小改动。直接进入实现和验证
+4. **Bug 修复** — 适用于缺陷修复。先使用 systematic-debugging 定位根因，再进入修复和验证
+5. **探索模式** — 适用于需求不明确或需要调研的场景。通过 brainstorming 和 openspec-explore 进行探索
+
+每种路径都包含对应的质量检查点，确保输出结果符合规范要求。
+
+## 项目结构
+
+```
+OpenOrbit/
+├── skills/              # 技能文件
+│   └── OpenOrbit/       # OpenOrbit 核心技能
+├── docs/                # 文档
+│   ├── design/          # 设计文档
+│   └── prerequisites.md # 前置依赖说明
+├── examples/            # 使用示例
+│   └── sample-project/  # 示例项目
+├── .github/             # GitHub 配置文件
+│   └── ISSUE_TEMPLATE/  # Issue 模板
+├── package.json         # npm 包配置
+├── LICENSE              # 许可证
+├── README.md            # 英文文档
+└── README.zh-CN.md      # 中文文档
+```
+
+## 贡献指南
+
+欢迎参与 OpenOrbit 的开发。你可以通过以下方式贡献：
+
+- 提交 Issue 报告问题或建议新功能
+- 提交 Pull Request 改进代码或文档
+- 完善项目中的技能文件和工作流定义
+
+提交 PR 前请确保你的修改通过了现有的验证流程。关于更详细的贡献规范，请参考项目中的 Issue 模板和相关文档。
+
+## 许可证
+
+[MIT](LICENSE)
+
+Copyright (c) 2026 ZK-Andy

package/docs/architecture.md

@@ -0,0 +1,139 @@
+# OpenOrbit Architecture
+
+## Overview
+
+OpenOrbit sits at the top of a four-engine stack. It is the routing layer -- the "compass" that directs development tasks to the correct workflow path through the layers below. Each layer has a clear, distinct responsibility, and together they form a complete spec-driven development pipeline.
+
+---
+
+## Architecture Layers
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                   OpenOrbit (Routing Layer)                       │
+│  Task classification -> Workflow path selection -> Route dispatch │
+│  (Routes tasks to the optimal path through the layers below)     │
+│                                                                  │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │    openspec-cn (Workflow Shell)                          │   │
+│  │    /opsx:propose -> /opsx:apply -> /opsx:sync -> /opsx:  │   │
+│  │    archive                                               │   │
+│  │    Defines WHAT to do -- proposal, specs, design, tasks  │   │
+│  │                                                          │   │
+│  │  ┌──────────────────────────────────────────────────┐   │   │
+│  │  │    oh-my-opencode (Execution Orchestration)       │   │   │
+│  │  │    Atlas/Sisyphus master agent                    │   │   │
+│  │  │    Reads tasks.md -> Decomposes modules ->        │   │   │
+│  │  │    Dispatches sub-agents -> Reviews output        │   │   │
+│  │  │                                                   │   │   │
+│  │  │  ┌────────────────────────────────────────┐      │   │   │
+│  │  │  │ superpowers-zh + dotnet-skills          │      │   │   │
+│  │  │  │ (Quality Gates + Domain Knowledge)       │      │   │   │
+│  │  │  │ Sub-agent TDD cycle:                    │      │   │   │
+│  │  │  │ Write tests -> Write code -> Self-review│      │   │   │
+│  │  │  │ -> Submit                               │      │   │   │
+│  │  │  │ Master review: same standards            │      │   │   │
+│  │  │  └────────────────────────────────────────┘      │   │   │
+│  │  └──────────────────────────────────────────────────┘   │   │
+│  └──────────────────────────────────────────────────────────┘   │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+### Layer 1: openspec-cn (Workflow Shell)
+
+The topmost engine layer. openspec-cn defines the workflow sequence -- what to do at each step of a development task.
+
+- **Purpose**: Defines the workflow sequence -- what to do at each step.
+- **Artifacts**: proposal.md, design.md, specs/, tasks.md.
+- **Commands**: /opsx:propose, /opsx:apply, /opsx:sync, /opsx:verify, /opsx:archive, /opsx:ff, /opsx:continue, /opsx:explore.
+- **Key Principle**: Spec-driven development -- specs define expected behavior before implementation begins.
+
+The full workflow for a new feature follows this path:
+
+```
+/opsx:propose -> /opsx:apply -> /opsx:sync -> /opsx:verify -> /opsx:archive
+```
+
+Smaller changes skip to a fast path:
+
+```
+/opsx:ff -> /opsx:sync -> /opsx:archive
+```
+
+---
+
+### Layer 2: oh-my-opencode (Execution Orchestration)
+
+The orchestration engine. oh-my-opencode manages who does what -- a master agent that decomposes tasks and dispatches work to sub-agents.
+
+- **Purpose**: Orchestrates who does what -- master agent manages the entire execution.
+- **Components**: Atlas (Master Orchestrator), Sisyphus-Junior (Task Executors), Specialized sub-agents.
+- **Process**: Read tasks.md -> Decompose -> Dispatch -> Supervise -> Review.
+- **Key Principle**: Master agent delegates, never writes code directly.
+
+The master agent reads the tasks.md artifact produced by openspec-cn, decomposes it into independent modules, dispatches each module to a sub-agent, supervises execution, and reviews all output before merging.
+
+---
+
+### Layer 3: superpowers-zh (Quality Gates)
+
+The quality enforcement layer. superpowers-zh provides a set of skills that enforce quality standards at every step of development.
+
+- **Purpose**: Enforces quality standards at every step.
+- **Skills**: brainstorming, chinese-code-review, chinese-commit-conventions, chinese-documentation, test-driven-development, systematic-debugging, verification-before-completion, and others.
+- **Key Principle**: Every deliverable passes through a quality gate before proceeding.
+
+Each sub-agent follows a strict TDD cycle guided by superpowers-zh:
+
+1. Write tests first (test-driven-development)
+2. Write code to pass tests
+3. Self-review against quality standards (chinese-code-review, verification-before-completion)
+4. Submit for master review
+
+---
+
+### Layer 4: dotnet-skills (Domain Knowledge)
+
+The domain expertise layer. dotnet-skills provides deep .NET technical knowledge to power implementation quality.
+
+- **Purpose**: Provides deep .NET technical expertise for implementation.
+- **Coverage**: 159+ skills covering ASP.NET Core, EF Core, Blazor, MAUI, testing, code analysis, performance, architecture, and more.
+- **Key Principle**: Domain-specific knowledge powers implementation quality.
+
+When a sub-agent receives a task that involves, for example, creating an API endpoint, the system loads the relevant dotnet-skills (aspnet-core + minimal-apis) alongside superpowers-zh to guide implementation with proper patterns and conventions.
+
+---
+
+## Data Flow
+
+The complete flow from task input to completion follows these stages:
+
+1. **Classification**: User describes a task. OpenOrbit classifies it (new feature, small feature, bug fix, exploration, etc.).
+
+2. **Routing**: OpenOrbit routes to the appropriate workflow path. Full path for new features, fast path for small changes, directed debug path for bugs.
+
+3. **Spec Generation**: openspec-cn generates the required artifacts -- proposal, design, specs, tasks. This defines what needs to be built.
+
+4. **Task Dispatch**: oh-my-opencode reads tasks.md, decomposes work into independent modules, and dispatches each to a sub-agent.
+
+5. **TDD Execution**: Each sub-agent executes the TDD cycle using superpowers-zh quality gates and dotnet-skills domain knowledge. Write tests, write code, self-review, submit.
+
+6. **Master Review**: The master agent reviews all sub-agent output against the same quality standards. Changes that fail review are sent back for fixes.
+
+7. **Archive**: openspec-cn archives the completed change. Specs are synced to the main specification set. Work is complete.
+
+---
+
+## Design Principles
+
+- **Separation of concerns**: Each layer has a clear, distinct responsibility. Routing, workflow, orchestration, quality, and domain knowledge do not overlap.
+
+- **Incremental updates**: All changes are incremental. No full rewrites. Each change builds on the previous state of the system.
+
+- **Quality gates**: Every step has verification built in. No deliverable moves forward without passing its quality gate.
+
+- **Bilingual**: Chinese is the primary language for internal documentation and communication, with English annotations for technical terms and code.
+
+- **Spec-driven**: Behavior is defined in specs before code is written. Implementation is measured against the spec.

package/docs/installation.md

@@ -0,0 +1,77 @@
+# OpenOrbit Installation Guide
+
+You can install OpenOrbit in three ways. Pick the one that fits your workflow.
+
+## Method 1: Direct Copy from GitHub
+
+Clone the repository and copy the skill into your project.
+
+```bash
+git clone https://github.com/ZK-Andy/OpenOrbit.git
+cp -r OpenOrbit/skills/OpenOrbit/ your-project/.opencode/skills/
+```
+
+**Best for**: Users who want to customize the skill.
+
+**Pros**: Full control. You can modify the skill directly.
+
+**Cons**: Manual updates needed when the upstream changes.
+
+## Method 2: npm Install
+
+Install the package via npm, then copy or symlink the skill into your project.
+
+```bash
+npm install @openorbit/skill
+# Copy the skill directory:
+cp -r node_modules/@openorbit/skill/skills/ your-project/.opencode/skills/
+# Or create a symlink:
+ln -s node_modules/@openorbit/skill/skills/OpenOrbit your-project/.opencode/skills/OpenOrbit
+```
+
+**Best for**: npm-based projects.
+
+**Pros**: Version management through npm. Easy to update, downgrade, or pin.
+
+**Cons**: Requires npm.
+
+## Method 3: Git Submodule
+
+Add OpenOrbit as a git submodule and symlink the skill.
+
+```bash
+git submodule add https://github.com/ZK-Andy/OpenOrbit.git .openorbit
+ln -s ../../.openorbit/skills/OpenOrbit .opencode/skills/OpenOrbit
+```
+
+**Best for**: Teams that want to pin a specific version in the repo.
+
+**Pros**: Version is pinned in the repository. Updates are explicit and deliberate.
+
+**Cons**: More complex setup. Everyone on the team needs to understand submodules.
+
+## Verification
+
+After installing, confirm the skill works:
+
+1. Check the skill directory exists:
+   ```bash
+   ls .opencode/skills/OpenOrbit/
+   ```
+2. Verify the SKILL.md file is present:
+   ```bash
+   ls .opencode/skills/OpenOrbit/SKILL.md
+   ```
+3. In OpenCode, run `/OpenOrbit` to confirm it loads correctly.
+
+## Platform Notes
+
+**Windows users**: Use `copy` or `xcopy` instead of `cp`. For example:
+
+```cmd
+xcopy /E /I OpenOrbit\skills\OpenOrbit your-project\.opencode\skills\OpenOrbit
+```
+
+**Updating**: If you used the git clone method, run `git pull` in the OpenOrbit directory. For npm, run `npm update @openorbit/skill`.
+
+**Troubleshooting**: If the skill does not load, check OpenCode's skill loading path configuration. Make sure `.opencode/skills/` is in the search path.

package/docs/prerequisites.md

@@ -0,0 +1,124 @@
+# Prerequisites
+
+This document lists the four engines required to work on OpenOrbit. Each engine has a specific role in the development workflow. Install and verify all of them before contributing.
+
+---
+
+## 1. openspec-cn
+
+- **Role**: Workflow shell -- defines WHAT to do (propose, specs, design, tasks)
+- **Description**: Drives the spec-driven workflow with proposal, design, specs, and task generation. It structures the change lifecycle from proposal through verification and archival.
+- **Installation**:
+  ```bash
+  npm install -g openspec-cn
+  ```
+- **Verification**:
+  ```bash
+  openspec-cn --version
+  ```
+- **Official**: https://github.com/org/openspec-cn
+
+---
+
+## 2. oh-my-opencode
+
+- **Role**: Execution orchestration -- Atlas/Sisyphus master agent dispatches, supervises, and reviews sub-agents
+- **Description**: Reads tasks.md from openspec-cn, decomposes into modules, dispatches to sub-agents, and reviews all output. It is the execution layer that turns specs into working code.
+- **Installation**:
+  ```bash
+  npm install -g oh-my-opencode
+  ```
+- **Verification**: Check that the skill is available in the OpenCode agent environment (e.g. by running a capability check or reviewing the agent's skill list).
+- **Official**: https://github.com/org/oh-my-opencode
+
+---
+
+## 3. superpowers-zh
+
+- **Role**: Quality gates -- Chinese-enhanced development skills (code review, commit conventions, documentation, TDD)
+- **Description**: 20 skills covering brainstorming, code review, commit conventions, documentation, TDD, debugging, and more. These skills improve code quality and team collaboration for Chinese-speaking development teams.
+- **Installation**: Copy the skills directory from the superpowers-zh repository to the project's `.opencode/skills/` directory.
+  ```bash
+  git clone https://github.com/org/superpowers-zh.git
+  cp -r superpowers-zh/.opencode/skills/* .opencode/skills/
+  ```
+- **Verification**:
+  ```bash
+  ls .opencode/skills/
+  ```
+  The output should show skills like `brainstorming`, `chinese-code-review`, `chinese-commit-conventions`, `chinese-documentation`, `test-driven-development`, etc.
+- **Official**: https://github.com/org/superpowers-zh
+
+---
+
+## 4. dotnet-skills
+
+- **Role**: Domain knowledge -- 159+ .NET skills for implementation work
+- **Description**: Covers ASP.NET Core, EF Core, Blazor, MAUI, testing (MSTest, xUnit, NUnit, TUnit), code analysis, performance profiling, code coverage, architecture, and many more topics. These skills provide the .NET-specific implementation knowledge needed to build OpenOrbit.
+- **Installation**: Clone the repository to the `~/.claude/skills/` directory so the agent can discover them.
+  ```bash
+  git clone https://github.com/org/dotnet-skills.git ~/.claude/skills/
+  ```
+- **Verification**:
+  ```bash
+  ls ~/.claude/skills/ | head -20
+  ```
+  The output should show .NET skills such as `aspnet-core`, `entity-framework-core`, `blazor`, `mstest`, `xunit`, `code-analysis`, etc.
+- **Official**: https://github.com/org/dotnet-skills
+
+---
+
+## System Requirements
+
+- **AI Environment**: OpenCode-compatible agent runtime (Claude Code, OpenClaw, or Cursor)
+- **Project Setup**: Git-based project with the OpenOrbit repository cloned locally
+- **Node.js**: Required for `openspec-cn` and `oh-my-opencode` (npm-based tools)
+- **.NET SDK**: Required for `dotnet-skills` domain knowledge to be applicable
+- **Network Access**: Required to clone the skill repositories and install npm packages
+
+---
+
+## Verification Checklist
+
+After installing all four engines, run through this checklist to confirm everything is set up correctly.
+
+| # | Check | Command / Action |
+|---|-------|------------------|
+| 1 | openspec-cn CLI works | `openspec-cn --version` |
+| 2 | oh-my-opencode is installed | `npm list -g oh-my-opencode` |
+| 3 | superpowers-zh skills are present | `ls .opencode/skills/` shows skill files |
+| 4 | dotnet-skills are present | `ls ~/.claude/skills/` shows .NET skills |
+| 5 | Workspace is clean | `git status` shows a clean working tree |
+
+---
+
+## Troubleshooting
+
+### openspec-cn not found after installation
+
+- Ensure Node.js and npm are installed and on your PATH.
+- Try reinstalling: `npm uninstall -g openspec-cn && npm install -g openspec-cn`.
+- On Windows, npm global binaries may require the npm global prefix to be in your PATH. Run `npm config get prefix` and verify the folder is in your PATH.
+
+### oh-my-opencode not available in OpenCode
+
+- Confirm the package installed successfully: `npm list -g oh-my-opencode`.
+- Check that the OpenCode agent configuration points to the correct skill directories.
+- Restart the OpenCode agent session after installation.
+
+### superpowers-zh skills not showing up
+
+- Verify the skills were copied to the correct path: `ls .opencode/skills/`.
+- Each skill should be a directory containing a SKILL.md file. If the directory is empty or missing files, re-run the copy command.
+- Make sure the `.opencode/skills/` directory exists in the project root. Create it if needed: `mkdir -p .opencode/skills`.
+
+### dotnet-skills not visible to the agent
+
+- Confirm the skills directory exists: `ls ~/.claude/skills/`.
+- On Windows, `~` resolves to `C:\Users\<YourUsername>`. Verify the path is correct.
+- If the directory is empty or the clone failed, try cloning again with a verbose flag: `GIT_TRACE=1 git clone https://github.com/org/dotnet-skills.git ~/.claude/skills/`.
+
+### Version conflicts
+
+- Keep all four engines on their latest stable versions.
+- If you encounter unexpected behavior, run the verification commands above and check the official repositories for compatibility notes.

package/docs/workflow-reference.md

@@ -0,0 +1,158 @@
+# OpenOrbit Workflow Reference
+
+This document describes the 6 workflow paths available in OpenOrbit. Each path serves a different task type. Use the overview table below to pick the right path for your task.
+
+---
+
+## Overview Table
+
+| Task Type | Workflow Path | Entry Command | Description |
+|-----------|--------------|---------------|-------------|
+| New feature (architecture decision) | Full path | `/opsx:propose` | propose -> apply -> sync -> verify -> archive |
+| Small feature (clear architecture) | Short path | `/opsx:propose` | propose -> apply -> archive |
+| Minimal change (<10 lines) | Fast-forward | `/opsx:ff` | ff -> archive |
+| Bug fix | Bug fix | `/opsx:ff` | ff + systematic-debugging -> archive |
+| Resume incomplete work | Continue | `/opsx:continue` | Resume from last checkpoint |
+| Exploration | Explore | `/opsx:explore` | Investigate -> choose path |
+
+---
+
+## Detailed Path Descriptions
+
+### 1. Full Path (New Features)
+
+**When to use**: New features involving architecture decisions. Use this path when the feature requires design discussion, trade-off analysis, and structural changes across multiple components.
+
+**Steps**:
+
+1. `/opsx:propose` -- Generates proposal.md, design.md, specifications, and tasks.md. This single command produces the full artifact set needed to guide implementation.
+
+2. `/opsx:apply` -- The master agent starts by routing design.md to an Oracle sub-agent for incremental review. The Oracle does not rewrite the design. It validates the design against project constraints and flags any gaps. After review, the master agent decomposes the tasks and dispatches them to sub-agents. Each sub-agent runs the full TDD cycle (RED -> GREEN -> REFACTOR -> VERIFY). The master agent reviews all sub-agent output before proceeding.
+
+3. `/opsx:sync` -- Bidirectional sync between implementation and specifications. Updates the main specs to reflect changes made during implementation, and flags any spec items that were not fulfilled.
+
+4. `/opsx:verify` -- Verifies that the implementation matches the specifications. Runs checks against the design and task definitions. This is the gate before archiving.
+
+5. `/opsx:archive` -- Merges incremental changes back to the main specification files. The change branch or folder is finalized and closed.
+
+**Notes**:
+- Do not skip the Oracle review in step 2. It catches architectural drift early.
+- The sync step is critical for maintainability. Treat it as mandatory.
+- Use this path sparingly. Most tasks should use a shorter path.
+
+---
+
+### 2. Short Path (Small Features)
+
+**When to use**: Small features where the architecture is clear and no major design decisions are needed. Use this path for self-contained changes that fit within existing boundaries.
+
+**Steps**:
+
+1. `/opsx:propose` -- Generates an incremental artifact set. Because the architecture is already clear, the proposal and design artifacts are lighter than in the full path.
+
+2. `/opsx:apply` -- Skip the Oracle review. The master agent dispatches sub-agents directly. Each sub-agent runs the TDD cycle. The master agent reviews all output.
+
+3. `/opsx:archive` -- Merge incremental changes to main specs. Since there was no sync step, the archive also handles any minor spec alignment.
+
+**Notes**:
+- The Oracle step is skipped because the architecture is already settled.
+- If the feature grows in scope during apply, stop and switch to the full path.
+- Verify the feature stays within its original boundary before archiving.
+
+---
+
+### 3. Fast-Forward (Minimal Changes)
+
+**When to use**: Changes under 10 lines of code. This includes single-line fixes, comment corrections, minor config tweaks, and trivial refactors.
+
+**Steps**:
+
+1. `/opsx:ff` -- The master agent dispatches a single sub-agent for the full TDD loop (RED -> GREEN -> REFACTOR -> VERIFY). Because the change is minimal, the sub-agent handles it directly without parallel dispatch.
+
+2. `/opsx:archive` -- Archive the change immediately. No sync or verify step needed because the change scope is trivial.
+
+**Notes**:
+- If the change exceeds 10 lines during implementation, stop and switch to the short or full path.
+- Do not use this path for changes that touch multiple files or modify behavior logic.
+- This path is also the fastest way to address code review comments that are purely cosmetic.
+
+---
+
+### 4. Bug Fix Path
+
+**When to use**: Bug fixes of any size. This path forces a root cause analysis step before any code is written.
+
+**Steps**:
+
+1. `/opsx:ff` -- Start with the fast-forward command to set up the change context.
+
+2. `systematic-debugging` -- Run the systematic debugging skill. This produces a root cause analysis document. Do not skip this step. The analysis defines the fix.
+
+3. Sub-agent TDD -> fix -> `/opsx:archive` -- After the root cause is documented, a sub-agent runs the TDD cycle to implement the fix. Archive when done.
+
+**Notes**:
+- The systematic debugging step is mandatory. Fixing a bug without understanding the root cause leads to recurring issues.
+- If the root cause reveals a larger design problem, switch to the full path.
+- Always add a regression test in the TDD cycle. Without one, the same bug can reappear.
+
+---
+
+### 5. Continue Path
+
+**When to use**: Resuming incomplete work from a previous session. Use this path when the master agent was interrupted mid-work (for example, due to context limits, session timeout, or manual stop).
+
+**Steps**:
+
+1. `/opsx:continue` -- The master agent reads the existing task state and restores the dispatch. Work resumes from the last checkpoint without redoing completed steps.
+
+**Notes**:
+- The continue command restores task state automatically. You do not need to specify which task to resume.
+- If the change artifacts have been cleaned up, you may need to restart from `/opsx:propose` or `/opsx:ff`.
+- After continuing, always verify the restored state before dispatching new sub-agents.
+
+---
+
+### 6. Explore Path
+
+**When to use**: When you need to understand the codebase before committing to a workflow path. Use this path for unfamiliar code, third-party integrations, or when the task scope is unclear.
+
+**Steps**:
+
+1. `/opsx:explore` -- Enter explore mode. The master agent investigates the codebase, gathers context, and clarifies requirements with the user.
+
+2. Choose another path -- After exploration, pick one of the other 5 paths based on what you learned.
+
+**Notes**:
+- Exploration does not produce artifacts. Its output is shared context that feeds into the next path.
+- You can exit explore mode at any time by running a path command directly.
+- Do not use the explore path for changes you already understand. It adds overhead without benefit.
+
+---
+
+## Sub-agent TDD Cycle Reference
+
+Each sub-agent follows the same 4-step cycle:
+
+| Phase | Action | Description |
+|-------|--------|-------------|
+| RED | Write a failing test | Express the expected behavior as a test before writing any implementation code. The test must fail initially. |
+| GREEN | Write minimal code to pass | Implement the simplest code that makes the test pass. Do not optimize. Do not refactor. Just pass. |
+| REFACTOR | Improve the code | Clean up the implementation and tests. Remove duplication, improve naming, and enforce style rules. The tests must stay green. |
+| VERIFY | Run diagnostics and build | Run lsp_diagnostics, the full test suite, and the build. All must pass before the sub-agent reports completion. |
+
+The cycle is non-negotiable. Every sub-agent must complete all 4 phases before submitting work to the master agent.
+
+---
+
+## Choosing the Right Path
+
+When starting a task, ask these questions in order:
+
+1. Do I understand the codebase area? If no -> use **Explore** path.
+2. Is the change under 10 lines? If yes -> use **Fast-forward** path.
+3. Is this a bug fix? If yes -> use **Bug fix** path.
+4. Is the architecture clear? If no -> use **Full** path.
+5. Is the feature small and self-contained? If yes -> use **Short** path.
+6. Am I resuming previous work? If yes -> use **Continue** path.
+
+This decision tree covers all cases. When in doubt, prefer the path that adds more structure.

package/examples/sample-project/CLAUDE.md

@@ -0,0 +1,93 @@
+<!-- THIS IS A SAMPLE CONFIGURATION FILE for demonstration purposes. Copy and adapt to your project. -->
+<!-- ====== CLAUDE.md - Sample Configuration for OpenOrbit ====== -->
+<!-- This is an EXAMPLE configuration. Adapt paths for your project. -->
+
+# Sample Project
+
+This is a sample .NET project configured with the OpenOrbit development workflow.
+
+## Prerequisites
+
+See [docs/prerequisites.md](../docs/prerequisites.md) for detailed installation instructions.
+
+<!-- ====== Four Engines ====== -->
+
+<!--
+  The four engines work together:
+  1. openspec-cn — Workflow shell (define WHAT to do)
+  2. oh-my-opencode — Execution orchestration (who does what)
+  3. superpowers-zh — Quality gates (Chinese-enhanced)
+  4. dotnet-skills — Domain knowledge (159+ .NET skills)
+-->
+
+<!--
+  openspec-cn commands:
+    /opsx:propose → /opsx:apply → /opsx:sync → /opsx:verify → /opsx:archive
+-->
+
+<!--
+  OpenOrbit skill registration:
+  The OpenOrbit skill is available at .opencode/skills/OpenOrbit/SKILL.md
+  Run /OpenOrbit in OpenCode to start the development governance compass.
+-->
+
+<!-- ====== Task Routing (OpenOrbit) ====== -->
+
+<!--
+  OpenOrbit classifies incoming tasks and routes them through the appropriate
+  workflow path. The routing logic works as follows:
+
+  New feature (complex, multi-step):
+    /opsx:propose → /opsx:apply → /opsx:sync → /opsx:verify → /opsx:archive
+    Use this when the task requires spec writing, design review, and
+    multi-module implementation.
+
+  Small change (quick, well-understood):
+    /opsx:ff → /opsx:sync → /opsx:archive
+    Use this for minor enhancements or well-scoped changes that need no
+    separate proposal phase.
+
+  Bug fix:
+    /opsx:ff + systematic-debugging → /opsx:archive
+    Use this when the change is purely a bug fix. Load the debugging skill
+    alongside the fast-forward path to diagnose root cause before fixing.
+
+  Resume unfinished work:
+    /opsx:continue
+    Use this to pick up where a previous implementation left off.
+-->
+
+<!-- ====== AI Agent Instructions ====== -->
+
+<!--
+  When a development task comes in:
+    1. Classify the task type (new feature, small change, bug fix, etc.)
+    2. Follow the appropriate OpenOrbit workflow path from the routing table
+    3. Load matching skills from the four engines as specified in the workflow
+    4. Apply quality gates: TDD for implementation, code review after
+-->
+
+<!-- ====== Project-Specific Conventions ====== -->
+
+<!--
+  .NET SDK version: 8.0+ or 9.0+
+  Test framework: xUnit or MSTest (match existing project convention)
+  Code style: Follow .editorconfig at repo root
+  Commit style: Conventional Commits (see docs/commits.md)
+-->
+
+<!-- ====== OpenOrbit Skill Reference ====== -->
+
+<!--
+  The OpenOrbit skill (.opencode/skills/OpenOrbit/SKILL.md) provides:
+  - Development governance compass
+  - Workflow path selection
+  - Quality standard definitions
+  - Onboarding and review templates
+
+  To load the skill in OpenCode, run:
+    /OpenOrbit
+
+  This will display the governance compass and guide you to the correct
+  workflow for your task type.
+-->

package/examples/sample-project/README.md

@@ -0,0 +1,123 @@
+# Sample Project -- OpenOrbit in Action
+
+This is a minimal example project showing how to set up and use the OpenOrbit skill in a .NET project. It demonstrates the project structure and configuration needed to get the full OpenOrbit development governance workflow running.
+
+The project itself contains no application code. It is a configuration-only skeleton that illustrates how OpenOrbit integrates with an OpenCode-powered AI environment and the four-engine stack.
+
+---
+
+## Prerequisites
+
+Before using OpenOrbit, make sure your environment meets the requirements described in the [main project prerequisites](../../docs/prerequisites.md). In summary:
+
+- **OpenCode-compatible AI environment.** The AI agent that loads OpenOrbit must support the skill framework.
+- **.NET SDK (8.0+ or 9.0+).** Required for any .NET project work that OpenOrbit orchestrates.
+- **The four engines.** OpenOrbit coordinates these tools. Each must be installed and available:
+  - openspec-cn -- Workflow shell (propose, spec, design, task, archive)
+  - oh-my-opencode -- Execution orchestration (master agent dispatches and reviews sub-agents)
+  - superpowers-zh -- Quality gates (20 Chinese-enhanced development skills)
+  - dotnet-skills -- Domain knowledge (159+ .NET skills)
+
+---
+
+## Getting Started
+
+1. **Install OpenOrbit** in your project. Follow the [installation guide](../../docs/installation.md) to copy or link the skill into your `.opencode/skills/` directory.
+
+2. **Copy the skill.** The command below copies the OpenOrbit skill from the repository into this project:
+
+   ```bash
+   cp -r ../../skills/OpenOrbit .opencode/skills/OpenOrbit
+   ```
+
+   On Windows, use `xcopy` instead:
+
+   ```cmd
+   xcopy /E /I ..\..\skills\OpenOrbit .opencode\skills\OpenOrbit
+   ```
+
+3. **Configure CLAUDE.md.** Create or update the `CLAUDE.md` file at the project root. This file tells the AI agent which skills are available and how to use them. See the CLAUDE.md configuration section below.
+
+4. **Verify the setup.** Run `/OpenOrbit` in OpenCode. The agent should respond with available workflow paths and classify your project correctly.
+
+---
+
+## Project Structure
+
+This is the minimal directory layout for a project using OpenOrbit:
+
+```
+sample-project/
+├── .opencode/
+│   └── skills/
+│       └── OpenOrbit/              # The skill (copied or linked here)
+│           └── SKILL.md
+├── .github/ISSUE_TEMPLATE/         # OpenOrbit's community templates
+├── docs/                           # OpenOrbit's documentation
+├── src/
+│   └── SampleApp/                  # Your .NET application code
+├── tests/
+│   └── SampleApp.Tests/            # Your test project
+├── CLAUDE.md                       # AI agent configuration
+└── README.md                       # This file
+```
+
+Two things to note:
+
+- The `.opencode/skills/OpenOrbit/` directory is the skill itself. It can be a copy, a symlink, or a git submodule. The skill loading conventions of your AI environment determine which approach works best.
+- The `src/` and `tests/` directories are where your actual .NET code lives. OpenOrbit does not dictate the internal structure of these folders. Any standard .NET project layout works.
+
+---
+
+## CLAUDE.md Configuration
+
+The `CLAUDE.md` file at the project root tells the AI agent which skills are loaded and how to navigate them. A minimal configuration looks like this:
+
+```markdown
+# Sample Project
+
+This project uses OpenOrbit for development governance.
+
+## Available Skills
+
+- **OpenOrbit**: Development governance compass. Routes tasks to the right workflow path automatically.
+
+## How to Use
+
+When starting a task, run `/OpenOrbit` to classify the work. The agent will suggest a workflow path based on the scope of the change.
+
+For new features, follow the full workflow: propose, design, implement, review, verify, archive.
+
+For small changes, use the fast path. OpenOrbit will skip unnecessary steps.
+
+For bug fixes, OpenOrbit routes to the debug-first workflow with systematic debugging.
+```
+
+The actual `CLAUDE.md` in this directory contains the full configuration that references all four engines. Adjust the content to match the engines you have installed.
+
+---
+
+## Usage
+
+Once OpenOrbit is installed and configured, interacting with it is straightforward:
+
+1. **Start a task** by describing what you want to do. For example: "Add a new API endpoint for user registration."
+
+2. **Run `/OpenOrbit`** to classify the task. The agent reads the skill and maps your request to the correct workflow path:
+   - Full path for new features (propose, design, implement, review, verify, archive)
+   - Fast path for small changes (implement, verify, archive)
+   - Debug path for bug fixes (debug, fix, verify, archive)
+
+3. **Follow the suggested workflow.** The agent walks through each step in sequence. Quality gates at each stage make sure nothing is skipped.
+
+4. **Repeat for each new task.** OpenOrbit re-evaluates the scope every time, so it adapts to whatever you throw at it.
+
+---
+
+## Learn More
+
+- [OpenOrbit Installation Guide](../../docs/installation.md) -- Detailed installation instructions for all platforms
+- [Prerequisites](../../docs/prerequisites.md) -- Full engine setup guide
+- [Architecture](../../docs/architecture.md) -- How the four engines work together
+- [Workflow Reference](../../docs/workflow-reference.md) -- All workflow paths and their steps
+- [OpenOrbit Skill](.opencode/skills/OpenOrbit/SKILL.md) -- The skill definition loaded by this project

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@openorbit/skill",
+  "version": "1.0.0",
+  "description": "OpenOrbit — Development Governance Compass. A meta-skill that routes development tasks to the optimal workflow path, powered by openspec-cn, oh-my-opencode, superpowers-zh, and dotnet-skills.",
+  "files": [
+    "skills/",
+    "docs/",
+    "examples/",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZK-Andy/OpenOrbit.git"
+  },
+  "keywords": [
+    "openorbit",
+    "development-governance",
+    "opencode",
+    "skill",
+    "compass"
+  ],
+  "author": "ZK-Andy"
+}

package/skills/OpenOrbit/SKILL.md

@@ -0,0 +1,263 @@
+---
+name: OpenOrbit
+description: Development Governance Compass — automatically routes development tasks to the optimal workflow path. 开发治理罗盘 — 自动将开发任务路由到最优工作流路径。
+---
+
+# OpenOrbit — 开发治理罗盘 (Development Governance Compass)
+
+> **Version**: 1.0.0
+> **Requires**: openspec-cn, oh-my-opencode, superpowers-zh, dotnet-skills
+
+## 前置依赖 (Prerequisites)
+
+OpenOrbit 是一个元技能（meta-skill），协调以下四个引擎协同工作：
+
+| 引擎 (Engine) | 作用 (Role) |
+|---------------|-------------|
+| **openspec-cn** | 工作流外壳 — 定义"做什么"：提案、规约、设计、任务、归档 |
+| **oh-my-opencode** | 执行层编排 — 主 agent (Atlas/Sisyphus) 分解任务、分发子 agent、监督审核 |
+| **superpowers-zh** | 中文增强技能框架 — 提供 20 个开发技能（brainstorming、TDD、代码审查等） |
+| **dotnet-skills** | .NET 领域知识库 — 159 个专业技能（ASP.NET Core、EF Core、MAUI 等） |
+
+请确保目标项目已安装以上四个引擎。详见 [前置依赖文档](../../docs/prerequisites.md)。
+
+## 概述 (Overview)
+
+OpenOrbit 是一个开发治理罗盘。它帮助你面对不同开发任务自动指向最佳工作流路径。底层由 openspec-cn、oh-my-opencode、superpowers-zh、dotnet-skills 四引擎驱动。openspec-cn 做工作流外壳（定义做什么），oh-my-opencode 做执行层编排（主 agent 分发任务监督审核），superpowers-zh + dotnet-skills 联合提供全流程质量门禁。
+
+## 何时使用 (When to Use)
+
+### 适用场景 (Appropriate Scenarios)
+
+- 初始化一个新的 .NET 项目，需要规范驱动的开发流程 (Setting up a new .NET project with spec-driven workflow)
+- 接手使用了这四引擎的项目，需要理解工作流和目录结构 (Inheriting a project using these four engines)
+- 计划新功能，不确定走完整路径还是快捷路径 (Planning a new feature, unsure which workflow path to take)
+- 配置 CI/CD，需要理解各环节的验证点 (Configuring CI/CD, need to understand validation gates)
+- 团队需要统一开发流程规范 (Team needs standardized development workflow)
+
+### 不适用的场景 (Inappropriate Scenarios)
+
+- 已有稳定的非 openspec 工作流，无迁移必要 (Already has a stable non-openspec workflow with no migration need)
+- 纯前端项目（无 .NET 代码）— dotnet-skills 不适用 (Pure frontend project with no .NET code)
+- 单人快速原型阶段 — 流程可能偏重 (Solo rapid prototyping where processes may be too heavy)
+- 需要严格的 Git 分支管理工作流 — 请使用 chinese-git-workflow (Requires strict Git branch management)
+- 项目尚处于探索/调研阶段，无需完整实现 (Project still in exploration/research phase)
+
+## 架构分层 (Architecture Layers)
+
+```
+┌──────────────────────────────────────────────────────────────────────────┐
+│               openspec-cn（工作流外壳 / Workflow Shell）                   │
+│  /opsx:propose → /opsx:apply → /opsx:sync → /opsx:verify → /opsx:archive │
+│  （定义"做什么"——提案、规约、设计、任务 / Defines WHAT to do）               │
+│                                                                          │
+│  ┌──────────────────────────────────────────────────────────────────┐   │
+│  │    oh-my-opencode（执行层编排 / Execution Orchestration）         │   │
+│  │    Atlas/Sisyphus 主 agent（Master Agent）                        │   │
+│  │    读取 tasks.md → 分解模块 → 分发子 agent → 审核               │   │
+│  │    (Read tasks.md → Decompose → Dispatch sub-agents → Review)     │   │
+│  │                                                                   │   │
+│  │  ┌───────────────────────────────────────────────────────┐       │   │
+│  │  │ superpowers-zh + dotnet-skills（质量门禁 / Quality Gate）│       │   │
+│  │  │ 子 agent TDD 循环 (Sub-agent TDD cycle)：              │       │   │
+│  │  │ 写测试 → 写代码 → 自审查 → 提交                         │       │   │
+│  │  │ (Write test → Write code → Self-review → Commit)        │       │   │
+│  │  │ 主 agent 审查：同样标准审核产出                          │       │   │
+│  │  │ (Master agent reviews with same standards)              │       │   │
+│  │  └───────────────────────────────────────────────────────┘       │   │
+│  └──────────────────────────────────────────────────────────────────┘   │
+└──────────────────────────────────────────────────────────────────────────┘
+```
+
+## 核心工作流 (Core Workflow)
+
+不同的变更类型走不同的路径。OpenOrbit 提供 5+1 种路径选择：
+
+```
+需求来了 (Requirement arrives)
+  │
+  ├── 新功能（涉及架构决策 / New feature, involves architecture decisions）
+  │   ├── /opsx:propose → 生成 proposal + design + specs + tasks
+  │   ├── /opsx:apply
+  │   │   ├── 主 agent 启动 → Oracle 子 agent 增量审核 design.md
+  │   │   │   (Master agent starts → Oracle sub-agent incrementally reviews design.md)
+  │   │   ├── 主 agent 分解 tasks → 分发子 agent（并行 TDD 编码）
+  │   │   │   (Master agent decomposes tasks → distributes to sub-agents for parallel TDD)
+  │   │   └── 主 agent 审核所有子 agent 产出
+  │   │       (Master agent reviews all sub-agent output)
+  │   ├── /opsx:sync → 双向同步实现 vs 规约 (Bidirectional sync implementation vs specs)
+  │   ├── /opsx:verify
+  │   └── /opsx:archive → 合并增量到主规约 (Merge deltas into main specs)
+  │
+  ├── 小功能（架构清晰 / Small feature, architecture is clear）
+  │   ├── /opsx:ff → 增量制品集 (Incremental artifact set)
+  │   ├── /opsx:apply → 跳过 Oracle → 分发子 agent → 审核
+  │   │   (Skip Oracle → dispatch sub-agents → review)
+  │   └── /opsx:archive
+  │
+  ├── 极简修改（< 10 行 / Minimal change, < 10 lines）
+  │   └── /opsx:ff → 子 agent TDD → /opsx:archive
+  │
+  ├── Bug 修复 (Bug fix)
+  │   ├── /opsx:ff
+  │   ├── systematic-debugging（English: systematic debugging）→ 定位根因
+  │   │   (Identify root cause)
+  │   └── 子 agent TDD → /opsx:archive
+  │
+  ├── 继续未完成的工作 (Continue incomplete work)
+  │   └── /opsx:continue → 主 agent 恢复任务分发
+  │       (Master agent resumes task distribution)
+  │
+  └── 需要先理解代码库 (Need to understand the codebase first)
+      └── /opsx:explore → 再走其他路径 (Then proceed with another path)
+```
+
+## 子 agent TDD 循环 (Sub-agent TDD Cycle)
+
+每个子 agent 拿到一个模块任务后，内部的编码循环遵循严格的 TDD 纪律：
+
+```
+子 agent 收到模块任务 (Sub-agent receives module task)
+  │
+  ├── ① 写测试 — RED（Write failing tests）
+  │   test-driven-development（English: test-driven development）
+  │   + dotnet-test-frameworks（English: .NET test frameworks）
+  │   → 编写失败的测试，定义期望行为 (Write failing tests, define expected behavior)
+  │
+  ├── ② 写代码 — GREEN（Write minimal code to pass）
+  │   test-driven-development（English: test-driven development）
+  │   + 对应领域 dotnet-skill（English: corresponding domain .NET skill）
+  │   → 实现刚好让测试通过的最小代码 (Implement minimal code to pass tests)
+  │
+  ├── ③ 自审查 — REFACTOR（Self-review and refactor）
+  │   chinese-code-review（English: Chinese code review standards）
+  │   + code-analysis（English: .NET SDK code analysis）
+  │   + format（English: dotnet format）
+  │   → 检查代码质量、架构合规、性能、安全 (Check quality, architecture, performance, security)
+  │
+  └── ④ 验证 + 提交 — VERIFY（Verify and commit）
+      verification-before-completion（English: verification before completion）
+      + chinese-commit-conventions（English: Chinese commit conventions）
+      → 运行验证命令 → 确认通过 → 提交 (Run verification → Confirm pass → Commit)
+```
+
+## 质量标准 (Quality Standards)
+
+六个规范标准由 OpenOrbit（superpowers-zh + dotnet-skills）联合定义：
+
+| 规范 (Standard) | superpowers-zh 技能 | dotnet-skills 技能 |
+|-----------------|---------------------|-------------------|
+| 提交 (Commit) | chinese-commit-conventions | format |
+| 代码 (Code) | chinese-code-review | code-analysis + format |
+| 注释 (Comments) | chinese-documentation | code-analysis (XML Doc) |
+| 架构 (Architecture) | chinese-code-review | architecture + code-analysis |
+| 测试 (Test) | test-driven-development | dotnet-test-frameworks |
+| 文档 (Documentation) | chinese-documentation | code-analysis |
+
+## 快速参考 (Quick Reference)
+
+### 目录结构 (Directory Structure)
+
+一个标准的使用 OpenOrbit 的项目目录结构如下：
+
+```
+project-root/
+├── .opencode/
+│   └── skills/
+│       └── OpenOrbit/           # OpenOrbit 技能定义
+│           └── SKILL.md         # 本文件
+├── openspec/
+│   ├── config.yaml              # openspec-cn 配置
+│   ├── specs/                   # 主规约目录 (Master specs)
+│   │   ├── architecture.md
+│   │   └── ...
+│   └── changes/                 # 变更目录 (Change artifacts)
+│       └── <change-id>/
+│           ├── proposal.md      # 提案
+│           ├── design.md        # 设计文档
+│           ├── tasks.md         # 任务分解
+│           └── specs/           # 增量规约 (Delta specs)
+├── .claude/
+│   └── skills/                  # Claude 技能目录
+├── CLAUDE.md                    # 项目配置 (含 OpenOrbit 引用)
+└── src/                         # 源代码
+```
+
+### 质量门禁与验证 (Quality Gates)
+
+| 阶段 (Phase) | 验证工具 (Verification Tool) | 检查内容 (Checks) |
+|--------------|------------------------------|-------------------|
+| TDD 写测试 | lsp_diagnostics | 测试代码无编译错误 |
+| TDD 写代码 | lsp_diagnostics + dotnet build | 代码编译通过 |
+| 自审查 | chinese-code-review | 代码质量、架构合规 |
+| 验证 | verification-before-completion | 测试通过、构建通过 |
+| 归档前 | /opsx:verify | 实现与规约一致 |
+
+### 可用命令 (Available Commands)
+
+| 命令 (Command) | 用途 (Purpose) |
+|----------------|----------------|
+| `/opsx:propose` | 提案新变更，生成 proposal + design + specs + tasks |
+| `/opsx:apply` | 实现变更中的任务，启动主 agent 分发 |
+| `/opsx:ff` | 快速创建变更并生成所有产出物 |
+| `/opsx:continue` | 继续处理未完成的变更 |
+| `/opsx:sync` | 同步增量规约到主规约 |
+| `/opsx:verify` | 验证实现与变更产出物一致 |
+| `/opsx:archive` | 归档已完成的变更 |
+| `/opsx:explore` | 进入探索模式，构思想法、调查问题 |
+
+## 初始化指南 (Initialization Guide)
+
+在新项目中初始化 OpenOrbit 工作流：
+
+1. **安装四引擎**：
+   - 确保 openspec-cn CLI 已安装并可用 (`openspec-cn --version`)
+   - 确保 oh-my-opencode 在主 agent 环境中已配置
+   - 确保 superpowers-zh 技能框架已加载到项目 `.opencode/skills/` 目录
+   - 确保 dotnet-skills 已安装到 `~/.claude/skills/`（159 个技能）
+
+2. **复制技能定义**：
+   ```bash
+   # 将 OpenOrbit 技能复制到项目
+   cp -r skills/OpenOrbit/ <你的项目>/.opencode/skills/OpenOrbit/
+   ```
+
+3. **初始化 openspec-cn**：
+   ```bash
+   cd <你的项目>
+   openspec-cn init
+   ```
+
+4. **配置 CLAUDE.md**：在项目根目录的 `CLAUDE.md` 中添加 OpenOrbit 引用：
+   ```markdown
+   <!-- OpenOrbit 开发治理罗盘 -->
+   <!-- openspec-cn v1.3.1 已初始化 -->
+   <!-- skill: OpenOrbit -->
+   ```
+
+5. **验证安装**：运行 `/OpenOrbit` 命令检查配置状态。
+
+## 常见错误 (Common Errors)
+
+| 错误 (Error) | 原因 (Cause) | 解决 (Solution) |
+|--------------|--------------|-----------------|
+| "openspec-cn: command not found" | openspec-cn CLI 未安装 | `npm install -g openspec-cn` 或按项目文档安装 |
+| "缺少 superpowers-zh 技能" | superpowers-zh 未复制到项目 | 将 `.opencode/skills/` 目录从 superpowers-zh 项目复制过来 |
+| "dotnet build 失败" | .NET SDK 版本不匹配或依赖未恢复 | 检查 `global.json`，运行 `dotnet restore` |
+| "/opsx:apply 找不到 tasks.md" | 未先运行 `/opsx:propose` 或 `/opsx:ff` | 先运行提案或快速创建命令生成产出物 |
+| "子 agent 审核不通过" | 代码未达到质量标准 | 检查质量标准表，运行 `chinese-code-review` 和 `code-analysis` |
+| "changes 目录冲突" | 多人同时修改同一变更 | 使用 `/opsx:continue` 恢复，或归档冲突变更后重建 |
+
+## 相关技能 (Related Skills)
+
+- `brainstorming`（English: brainstorming）— 创造性工作前的需求分析与设计探索
+- `test-driven-development`（English: test-driven development）— 测试先行的开发方法论
+- `chinese-code-review`（English: Chinese code review standards）— 中文代码审查规范
+- `chinese-commit-conventions`（English: Chinese commit conventions）— 中文 Git 提交规范
+- `chinese-documentation`（English: Chinese documentation standards）— 中文技术文档写作规范
+- `verification-before-completion`（English: verification before completion）— 完成前验证机制
+- `systematic-debugging`（English: systematic debugging）— 系统化调试方法论
+- `subagent-driven-development`（English: sub-agent driven development）— 子 agent 驱动的开发模式
+- `dispatching-parallel-agents` — 并行 agent 分发
+- `writing-plans`（English: writing plans）— 多步骤任务规划
+- `finishing-a-development-branch`（English: finishing a development branch）— 开发分支收尾