moluoxixi-ai-rules 0.2.9 → 0.2.11

package/README-en.md

@@ -13,7 +13,7 @@ The AIRules installer handles user-level package setup, asset distribution, and
 
 ## `general`
 
-For users who need to question plans, remember decisions across sessions, and organize documents. It also provides the shared base for development roles.
+For users who need to remember decisions across sessions, write skills, and organize documents. It also provides the shared base for development roles.
 
 ### Install
 
@@ -25,11 +25,10 @@ airules verify general --host all
 
 ### Features
 
-`general` selects `common` and `grilling`, providing five skills and the Hindsight memory MCP:
+`general` selects `common`, providing four skills and the Hindsight memory MCP:
 
 | Skill | Purpose |
 | --- | --- |
-| `grilling` | Question plans, decisions, and assumptions to establish tradeoffs and validation criteria |
 | `hindsight-memory` | Recall and retain confirmed project knowledge and connect memory visualization |
 | `hindsight-docs` | Consult Hindsight API, deployment, and configuration documentation |
 | `create-skill` | Create or revise a reusable agent skill |
@@ -37,14 +36,14 @@ airules verify general --host all
 
 The default MCP endpoint is `http://localhost:8888/mcp/`. The official Hindsight console at `http://localhost:9999` shows facts, source documents, and entity relationships. Connect a standalone console to an existing API, or use the bundled Docker Compose assets for a new deployment. Model settings live in the user configuration directory and data persists in a named volume. See [memory visualization](capabilities/common/skills/hindsight-memory/references/visualization.md).
 
-`moluoxixi`, `trellis`, and `matt` inherit these capabilities with `extends_roles: [general]`. Installing a development role includes its inherited capabilities. See [General](roles/general/README.md) and [role inheritance](capabilities/README.md#角色继承).
+The `development` template inherits these capabilities with `extends_roles: [general]`. `moluoxixi`, `trellis`, and `matt` all inherit `development`. Installing a development role includes its inherited capabilities. See [General](roles/general/README.md) and [role inheritance](capabilities/README.md#角色继承).
 
 ### Usage
 
 Describe the goal or name a skill directly:
 
 ```text
-Use grilling to question this plan and check its assumptions and tradeoffs.
+Organize this project's documentation directories, indexes, and links.
 Remember our confirmed decisions, reasoning, and next validation criteria.
 Recall this project's earlier decisions and check whether they still apply.
 Open this project's memory visualization to inspect facts and entity relationships.
@@ -52,9 +51,42 @@ Open this project's memory visualization to inspect facts and entity relationshi
 
 Roles share the same Hindsight API and project bank. Start the service using the deployment guide and verify memory reads and writes before using it.
 
+## `development`
+
+The shared development template adds `coding`, `productivity`, and `frontend` to the memory and documentation capabilities inherited from `general`. `matt`, `moluoxixi`, and `trellis` all use `extends_roles: [development]` and receive the same base skills and MCP servers. `matt` selects `engineering` separately; Moluoxixi and Trellis use their own engineering workflows.
+
+### Install
+
+```bash
+npm install --global moluoxixi-ai-rules
+airules install development --host all
+airules verify development --host all
+```
+
+### Features
+
+```text
+general
+└── development
+    ├── matt
+    ├── moluoxixi
+    └── trellis
+```
+
+The template can be installed independently without project initialization. Concrete roles retain their own CLI, workflow, and initialization entry. Add shared development capabilities in the template once. See [Development](roles/development/README.md) for capabilities and inheritance rules.
+
+### Usage
+
+```text
+Use grilling to question this development plan and establish validation criteria.
+Use frontend-design to design this interface, then inspect it with Playwright.
+```
+
+For a new development role, declare `extends_roles: [development]` and `capabilities: []` in its `role.yaml`. Add role-specific capabilities to its own declaration. Each role may extend at most one parent, and multi-level chains are supported.
+
 ## `moluoxixi`
 
-For users who want a complete AI development workflow with the native Moluoxixi CLI, project knowledge, multi-domain skills, and controlled multi-agent dispatch. It inherits `general` and adds `coding`, `productivity`, and `frontend`.
+For users who want a complete AI development workflow with the native Moluoxixi CLI, project knowledge, multi-domain skills, and controlled multi-agent dispatch. It inherits all shared capabilities from `development` and adds its own project workflow.
 
 ### Install
 
@@ -84,7 +116,7 @@ npm install --global @moluoxixi/airules-moluoxixi-cli
 | Layer | Assets | Responsibility |
 | --- | --- | --- |
 | User-level role | Moluoxixi core, `moluoxixi`/`ml`, `init-project` | Native initialization, update, task, memory, workflow, and channel commands |
-| Shared capabilities | Inherited `common`, `grilling`; own `coding`, `productivity`, `frontend` | Shared and pinned external skills plus MCP servers |
+| Shared capabilities | Shared tools inherited from `development` | General skills, productivity skills, frontend skills, and MCP servers |
 | Native project | `.moluoxixi/workflow.md`, `tasks/`, `spec/`, `scripts/`, `agents/`, host configuration | Workflow state, task artifacts, project rules, and agent definitions |
 | AIRules project extension | `.moluoxixi/knowledge/`, knowledge runtime and hook, `moluoxixi-knowledge` | Source change detection and traceable project knowledge |
 
@@ -116,13 +148,15 @@ Project workflow entries become slash commands or discoverable skills according
 | `common` | `hindsight-docs` | Look up Hindsight API, deployment, and advanced configuration |
 | `frontend` | `frontend-design` | Give intentional visual direction when creating or reshaping interfaces |
 | `productivity` | `grill-me` | Start a rigorous interview that turns an idea into an executable plan |
-| `grilling` | `grilling` | Inherited from `general`; stress-test plans, decisions, and designs |
+| `productivity` | `grilling` | Stress-test plans, decisions, and designs |
 | `productivity` | `handoff` | Compress the conversation into a document another agent can resume |
 | `productivity` | `teach` | Run stateful teaching across sessions in the current repository |
 | `productivity` | `to-questionnaire` | Turn unresolved decisions into a questionnaire for an informed person |
 | `productivity` | `wait-what` | Restate misunderstood material in direct technical English |
 | `productivity` | `writing-for-agents` | Write skills, `AGENTS.md`, and `CLAUDE.md` for agent consumption |
 
+Shared tools are maintained in [Development](roles/development/README.md). The Moluoxixi workflow below owns engineering implementation and review.
+
 The `common` capability configures the Hindsight HTTP memory MCP at `http://localhost:8888/mcp/`. See [Common](capabilities/common/README.md) for service startup and model configuration. The `coding` capability installs CodeGraph, Context7, and Sequential Thinking MCP for code relationships, library documentation, and structured reasoning. The `frontend` capability installs Playwright MCP for browser inspection and automation.
 
 #### Agents, hooks, and dispatch
@@ -189,7 +223,7 @@ airules verify matt --host all
 
 #### Installed assets
 
-`matt` inherits `common` and `grilling` from `general`, then adds its own `engineering` and `productivity` capabilities. Shared skills and the Hindsight MCP are installed with the role and use the same project bank as other roles. See [memory visualization](capabilities/common/skills/hindsight-memory/references/visualization.md) for console setup. Engineering and productivity skills use a pinned upstream revision; the role requires no project initialization.
+`matt` inherits the base development capabilities from `development` and separately selects `engineering` to organize engineering work with Matt skills, without project initialization. The install includes shared skills and Hindsight, CodeGraph, Context7, Sequential Thinking, and Playwright MCP servers. Engineering and productivity skills use a pinned upstream revision. Hindsight uses the same project bank as other roles; see [memory visualization](capabilities/common/skills/hindsight-memory/references/visualization.md) for console setup.
 
 #### Skills
 
@@ -199,6 +233,7 @@ airules verify matt --host all
 | `common` | `spec-organization` | Organize document directories, indexes, and links |
 | `common` | `hindsight-memory` | Retain and recall project memory and connect the official console |
 | `common` | `hindsight-docs` | Consult Hindsight API and deployment documentation |
+| `frontend` | `frontend-design` | Guide visual design for new interfaces and redesigns |
 | `engineering` | `ask-matt` | Explicit router that selects the appropriate Matt skill or flow |
 | `engineering` | `code-review` | Review changes since a baseline against standards and specification |
 | `engineering` | `codebase-design` | Improve module boundaries, interfaces, and testability using deep-module principles |
@@ -218,7 +253,7 @@ airules verify matt --host all
 | `engineering` | `wayfinder` | Plan work larger than one agent session as a decision and ticket map |
 | `engineering` | `wizard` | Generate an interactive Bash wizard for human-only credentials, consoles, or migrations |
 | `productivity` | `grill-me` | Start a rigorous planning interview |
-| `grilling` | `grilling` | Inherited from `general`; stress-test a plan, decision, or design |
+| `productivity` | `grilling` | Stress-test a plan, decision, or design |
 | `productivity` | `handoff` | Produce a resumable cross-agent handoff |
 | `productivity` | `teach` | Teach across sessions with recorded state |
 | `productivity` | `to-questionnaire` | Turn unknowns into a questionnaire for an informed person |
@@ -246,7 +281,7 @@ Role source: [`roles/matt`](roles/matt).
 
 ## `trellis`
 
-For users who want the native [Trellis](https://github.com/mindfold-ai/Trellis) task-and-specification workflow together with AIRules shared skills, MCP, project knowledge, and multi-agent dispatch. It inherits `general` and adds `coding`, `productivity`, and `frontend`.
+For users who want the native [Trellis](https://github.com/mindfold-ai/Trellis) task-and-specification workflow together with AIRules shared skills, MCP, project knowledge, and multi-agent dispatch. It inherits all shared capabilities from `development` and adds its own project workflow.
 
 ### Install
 
@@ -266,7 +301,7 @@ The role install provides the Trellis CLI and user-level capabilities but does n
 | Layer | Assets | Responsibility |
 | --- | --- | --- |
 | User-level role | Trellis CLI and `init-project` | Native `init/update/upgrade/uninstall/mem/workflow/platforms/channel` commands |
-| Shared capabilities | Inherited `common`, `grilling`; own `coding`, `productivity`, `frontend` | The same shared skills, pinned external skills, and MCP servers as Moluoxixi |
+| Shared capabilities | Shared tools inherited from `development` | The same base skills and MCP servers as other development roles |
 | Native project | `.trellis/workflow.md`, `tasks/`, `spec/`, `scripts/`, `agents/`, host configuration | Plan/Execute/Finish state, task artifacts, specs, and agent definitions |
 | AIRules project extension | `.trellis/knowledge/`, knowledge runtime and hook, `trellis-knowledge` | Source change detection and bidirectionally traceable knowledge |
 
@@ -296,13 +331,15 @@ Native Trellis projects workflow entries as commands or skills according to host
 | `common` | `hindsight-docs` | Look up Hindsight API, deployment, and advanced configuration |
 | `frontend` | `frontend-design` | Guide intentional frontend design and redesign |
 | `productivity` | `grill-me` | Start a rigorous requirements interview |
-| `grilling` | `grilling` | Inherited from `general`; stress-test plans, decisions, and designs |
+| `productivity` | `grilling` | Stress-test plans, decisions, and designs |
 | `productivity` | `handoff` | Produce a cross-agent handoff |
 | `productivity` | `teach` | Teach across sessions with recorded progress |
 | `productivity` | `to-questionnaire` | Turn unresolved questions into a questionnaire |
 | `productivity` | `wait-what` | Restate misunderstood material |
 | `productivity` | `writing-for-agents` | Write agent-facing documents and skills |
 
+Shared tools are maintained in [Development](roles/development/README.md). The Trellis workflow below owns engineering implementation and review.
+
 Trellis configures Hindsight, CodeGraph, Context7, Sequential Thinking, and Playwright MCP. Its role-owned MCP manifest is empty; these servers come from `common`, `coding`, and `frontend` capabilities. See [Common](capabilities/common/README.md) for Hindsight service requirements.
 
 #### Agents, hooks, and dispatch
@@ -346,7 +383,7 @@ Role source: [`roles/trellis`](roles/trellis).
 
 Shared skills, MCP catalogs, and vendor declarations live together in `capabilities/<capability>/`, such as `capabilities/common/skills/`. Each capability is a data-only directory containing `capability.yaml`, skills, MCP catalogs, and documentation; roles select capabilities in `role.yaml`. The runtime loader lives in `scripts/lib/capabilities.ts`, composes vendors in declaration order, merges compatible projections, deduplicates identical projections, and rejects source or target conflicts. See [capabilities/README.md](capabilities/README.md) for the layout and complete mapping.
 
-`extends_roles` recursively combines parent capabilities before the child's own choices. Shared ancestors and capabilities are deduplicated; missing parents and inheritance cycles are rejected. A parent may be a declaration-only template. The child declares its own role vendor, hosts, and CLI packages. See [role inheritance](capabilities/README.md#角色继承).
+`extends_roles` combines capabilities along a single inheritance chain before the child's own choices. Each role may extend at most one parent; repeated capabilities are deduplicated. Multiple parents, missing parents, and inheritance cycles are rejected. A parent may be a declaration-only template. The child declares its own role vendor, hosts, and CLI packages. See [role inheritance](capabilities/README.md#角色继承).
 
 Host directories, aliases, skill projection switches, and MCP formats are declared in [hosts/hosts.yaml](hosts/hosts.yaml). `scripts/lib/hosts.ts` loads and validates the declaration and resolves paths; declaration types live in `scripts/lib/types/`. Adding a host only requires a YAML entry. See [hosts/README.md](hosts/README.md) for fields and maintenance guidance.
 

package/README.md

@@ -13,7 +13,7 @@ AIRules 安装器负责用户级 package setup、资产分发和受管 skills/MC
 
 ## `general`
 
-适合需要计划审问、跨会话记忆和文档整理的用户，也是开发角色共享的基础角色。
+适合需要跨会话记忆、skill 编写和文档整理的用户，也是开发角色共享的基础角色。
 
 ### 安装
 
@@ -25,11 +25,10 @@ airules verify general --host all
 
 ### 功能
 
-`general` 选择 `common` 和 `grilling`，提供五项 skills 和 Hindsight 记忆 MCP：
+`general` 选择 `common`，提供四项 skills 和 Hindsight 记忆 MCP：
 
 | Skill | 做什么 |
 | --- | --- |
-| `grilling` | 审问计划、决策和假设，明确取舍与验证条件 |
 | `hindsight-memory` | 按项目回忆和保存已确认的信息，连接记忆可视化 |
 | `hindsight-docs` | 查询 Hindsight API、部署和高级配置文档 |
 | `create-skill` | 创建或修订可复用的 agent skill |
@@ -37,14 +36,14 @@ airules verify general --host all
 
 Hindsight MCP 默认连接 `http://localhost:8888/mcp/`。官方控制台默认位于 `http://localhost:9999`，可查看记忆事实、来源文档和实体关系图。已有 API 可单独启动控制台；首次部署可使用随 skill 分发的 Docker Compose，模型配置和数据分别保存在用户配置目录与持久化卷中。步骤见 [记忆可视化](capabilities/common/skills/hindsight-memory/references/visualization.md)。
 
-`moluoxixi`、`trellis` 和 `matt` 通过 `extends_roles: [general]` 继承这些通用能力；安装开发角色时会一并安装。声明与规则见 [General](roles/general/README.md) 和 [角色继承](capabilities/README.md#角色继承)。
+开发模板 `development` 通过 `extends_roles: [general]` 继承这些通用能力；`moluoxixi`、`trellis` 和 `matt` 再统一继承 `development`。安装开发角色时会一并安装。声明与规则见 [General](roles/general/README.md) 和 [角色继承](capabilities/README.md#角色继承)。
 
 ### 用法
 
 直接在宿主中描述目标或点名 skill：
 
 ```text
-请用 grilling 审问这个计划，逐项检查假设和取舍。
+请整理这个项目的文档目录、索引和链接。
 请记住我们已确认的结论、理由和下一步验证条件。
 回忆这个项目之前的决定，并核对是否仍适用。
 打开当前项目的记忆可视化，查看事实和实体关系图。
@@ -52,9 +51,42 @@ Hindsight MCP 默认连接 `http://localhost:8888/mcp/`。官方控制台默认
 
 不同角色使用同一 Hindsight 服务和项目 bank，复用已确认的记忆。使用记忆前按上述部署说明启动服务并验证读写。
 
+## `development`
+
+开发通用模板，在 `general` 的记忆和文档能力之上集中提供 `coding`、`productivity` 和 `frontend`。`matt`、`moluoxixi`、`trellis` 都使用 `extends_roles: [development]`，获得相同的基础 skills 和 MCP。`engineering` 由 `matt` 单独选择；Moluoxixi 和 Trellis 使用各自的工程工作流。
+
+### 安装
+
+```bash
+npm install --global moluoxixi-ai-rules
+airules install development --host all
+airules verify development --host all
+```
+
+### 功能
+
+```text
+general
+└── development
+    ├── matt
+    ├── moluoxixi
+    └── trellis
+```
+
+模板可独立安装，无需项目初始化。具体角色保留自身的 CLI、工作流和初始化入口；新增共享开发能力只需更新模板。完整能力与继承规则见 [Development](roles/development/README.md)。
+
+### 用法
+
+```text
+请使用 grilling 审问这个开发计划，明确取舍和验证条件。
+请使用 frontend-design 设计这个界面，并用 Playwright 检查效果。
+```
+
+新增开发角色时，在其 `role.yaml` 中声明 `extends_roles: [development]`，并设置 `capabilities: []`；专属能力可在自身声明中追加。每个角色最多继承一个父角色，支持多层链。
+
 ## `moluoxixi`
 
-适合希望获得完整 AI 开发流程，同时需要 Moluoxixi 原生 CLI、项目知识库、多领域 skills 和可控多 agent 调度的用户。继承 `general`，再增加 `coding`、`productivity` 和 `frontend`。
+适合希望获得完整 AI 开发流程，同时需要 Moluoxixi 原生 CLI、项目知识库、多领域 skills 和可控多 agent 调度的用户。继承 `development` 的全部共享开发能力，再提供自己的项目工作流。
 
 ### 安装
 
@@ -84,7 +116,7 @@ npm install --global @moluoxixi/airules-moluoxixi-cli
 | 层级 | 资产 | 作用 |
 | --- | --- | --- |
 | 用户级角色资产 | Moluoxixi core、`moluoxixi`/`ml` CLI、`init-project` | 提供原生项目初始化、更新、任务、memory、workflow 和 channel 命令 |
-| 公共 capability | 继承的 `common`、`grilling`；自身的 `coding`、`productivity`、`frontend` | 组合共享 skills、外部固定版本 skills 和 MCP servers |
+| 公共 capability | 从 `development` 继承共享工具能力 | 组合通用 skills、效率 skills、前端 skills 和 MCP servers |
 | 原生项目资产 | `.moluoxixi/workflow.md`、`tasks/`、`spec/`、`scripts/`、`agents/`、宿主配置 | 保存工作流状态、任务工件、项目规范和 agent 定义 |
 | AIRules 项目扩展 | `.moluoxixi/knowledge/`、知识 runtime、宿主 knowledge hook、`moluoxixi-knowledge` | 检测 source 变化，维护可追踪的项目知识库 |
 
@@ -116,13 +148,15 @@ npm install --global @moluoxixi/airules-moluoxixi-cli
 | `common` | `hindsight-docs` | 查询 Hindsight API、部署和高级配置文档 |
 | `frontend` | `frontend-design` | 为新 UI 或现有界面重塑提供有明确审美方向的设计指导 |
 | `productivity` | `grill-me` | 启动严格访谈，把模糊想法推进到可执行方案 |
-| `grilling` | `grilling` | 从 `general` 继承，压力测试计划、决策或设计中的薄弱假设 |
+| `productivity` | `grilling` | 压力测试计划、决策或设计中的薄弱假设 |
 | `productivity` | `handoff` | 把当前对话压缩为下一位 agent 可接手的交接文档 |
 | `productivity` | `teach` | 在当前仓库中进行可跨会话记录状态的教学 |
 | `productivity` | `to-questionnaire` | 把 agent 无法独立回答的决策转成给知情人的问卷 |
 | `productivity` | `wait-what` | 用更直接的技术英语重新解释未被理解的内容 |
 | `productivity` | `writing-for-agents` | 编写供 agent 消费的 skills、`AGENTS.md` 和 `CLAUDE.md` |
 
+共享工具由 [Development](roles/development/README.md) 集中维护，工程实施和审查由下述 Moluoxixi 工作流负责。
+
 `common` capability 配置 Hindsight HTTP 记忆 MCP，默认连接 `http://localhost:8888/mcp/`；服务启动和模型配置见 [Common](capabilities/common/README.md)。`coding` capability 安装 CodeGraph、Context7、Sequential Thinking MCP，用于代码关系探索、库文档查询和结构化推理；`frontend` capability 安装 Playwright MCP，用于浏览器检查与自动化。
 
 #### Agents、hooks 与调度
@@ -196,7 +230,7 @@ airules verify matt --host all
 
 #### 安装后的资产
 
-`matt` 继承 `general` 的 `common` 和 `grilling`，再组合自身的 `engineering` 和 `productivity`。通用 skills 和 Hindsight MCP 随角色安装，项目 bank 与其它角色共用；控制台部署见 [记忆可视化](capabilities/common/skills/hindsight-memory/references/visualization.md)。工程和效率 skills 固定上游版本，角色无需项目初始化。
+`matt` 继承 `development` 的基础开发能力，再单独选择 `engineering`，使用 Matt skills 组织工程工作，无需项目初始化。共享 skills 以及 Hindsight、CodeGraph、Context7、Sequential Thinking 和 Playwright MCP 随角色安装。工程和效率 skills 固定上游版本；Hindsight 项目 bank 与其它角色共用，控制台部署见 [记忆可视化](capabilities/common/skills/hindsight-memory/references/visualization.md)。
 
 #### Skills
 
@@ -206,6 +240,7 @@ airules verify matt --host all
 | `common` | `spec-organization` | 整理文档目录、索引和链接 |
 | `common` | `hindsight-memory` | 保存和检索项目记忆，连接官方可视化控制台 |
 | `common` | `hindsight-docs` | 查询 Hindsight API 和部署文档 |
+| `frontend` | `frontend-design` | 为新 UI 和界面改造提供视觉设计指导 |
 | `engineering` | `ask-matt` | 根据当前问题选择适合的 Matt skill 或工作流；这是显式调用的路由器 |
 | `engineering` | `code-review` | 从指定基线对改动做 standards 与 spec 双轴审查 |
 | `engineering` | `codebase-design` | 用深模块原则改进模块边界、接口和可测试性 |
@@ -225,7 +260,7 @@ airules verify matt --host all
 | `engineering` | `wayfinder` | 把超出单次会话的大型工作规划成决策与 ticket 地图 |
 | `engineering` | `wizard` | 生成交互式 bash wizard，引导人工完成凭据、控制台或迁移步骤 |
 | `productivity` | `grill-me` | 启动严格访谈，把模糊计划推进到可执行状态 |
-| `grilling` | `grilling` | 从 `general` 继承，压力测试计划、决策或设计 |
+| `productivity` | `grilling` | 压力测试计划、决策或设计 |
 | `productivity` | `handoff` | 生成下一位 agent 可直接接手的交接文档 |
 | `productivity` | `teach` | 在仓库中进行可记录进度的跨会话教学 |
 | `productivity` | `to-questionnaire` | 把未决问题转成面向知情人的问卷 |
@@ -253,7 +288,7 @@ airules verify matt --host all
 
 ## `trellis`
 
-适合希望使用原生 [Trellis](https://github.com/mindfold-ai/Trellis) 的任务与规范驱动工作流，同时获得 AIRules 共享 skills、MCP、知识库和多 agent 调度的用户。继承 `general`，再增加 `coding`、`productivity` 和 `frontend`。
+适合希望使用原生 [Trellis](https://github.com/mindfold-ai/Trellis) 的任务与规范驱动工作流，同时获得 AIRules 共享 skills、MCP、知识库和多 agent 调度的用户。继承 `development` 的全部共享开发能力，再提供自己的项目工作流。
 
 ### 安装
 
@@ -273,7 +308,7 @@ trellis --version
 | 层级 | 资产 | 作用 |
 | --- | --- | --- |
 | 用户级角色资产 | Trellis CLI、`init-project` | 提供原生 `init/update/upgrade/uninstall/mem/workflow/platforms/channel` 命令 |
-| 公共 capability | 继承的 `common`、`grilling`；自身的 `coding`、`productivity`、`frontend` | 与 Moluoxixi 相同的共享 skills、外部固定版本 skills 和 MCP servers |
+| 公共 capability | 从 `development` 继承共享工具能力 | 与其它开发角色相同的基础 skills 和 MCP servers |
 | 原生项目资产 | `.trellis/workflow.md`、`tasks/`、`spec/`、`scripts/`、`agents/`、宿主配置 | 保存 Plan/Execute/Finish 状态、任务工件、规范和 agent 定义 |
 | AIRules 项目扩展 | `.trellis/knowledge/`、知识 runtime、宿主 hook、`trellis-knowledge` | 自动发现 source 变化并维护双向可追踪知识关系 |
 
@@ -303,13 +338,15 @@ trellis --version
 | `common` | `hindsight-docs` | 查询 Hindsight API、部署和高级配置文档 |
 | `frontend` | `frontend-design` | 指导有明确视觉方向的前端设计与重塑 |
 | `productivity` | `grill-me` | 启动严格需求访谈 |
-| `grilling` | `grilling` | 从 `general` 继承，压力测试计划、决策或设计 |
+| `productivity` | `grilling` | 压力测试计划、决策或设计 |
 | `productivity` | `handoff` | 生成跨 agent 交接文档 |
 | `productivity` | `teach` | 进行可记录进度的跨会话教学 |
 | `productivity` | `to-questionnaire` | 把未决问题转成问卷 |
 | `productivity` | `wait-what` | 重新解释未被理解的内容 |
 | `productivity` | `writing-for-agents` | 编写 agent 文档与 skills |
 
+共享工具由 [Development](roles/development/README.md) 集中维护，工程实施和审查由下述 Trellis 工作流负责。
+
 Trellis 同样配置 Hindsight、CodeGraph、Context7、Sequential Thinking 和 Playwright MCP；role-owned MCP 清单为空，实际 MCP 来自 `common`、`coding` 与 `frontend` capabilities。Hindsight 服务的运行要求见 [Common](capabilities/common/README.md)。
 
 #### Agents、hooks 与调度
@@ -353,7 +390,7 @@ Plan 阶段创建并确认 PRD，复杂任务补齐 design/implement 后 `task.p
 
 共享 skills、MCP 清单和供应商声明按能力集中在 `capabilities/<能力>/`，例如 `capabilities/common/skills/`。每个能力目录是纯数据目录，只包含 `capability.yaml`、skills、MCP 清单和文档；Role 在 `role.yaml` 中选择 capability。运行时加载器位于 `scripts/lib/capabilities.ts`，负责按声明顺序组合 vendor，合并兼容投影、去重完全相同的 projection，并拒绝来源或目标冲突。目录结构与完整映射见 [capabilities/README.md](capabilities/README.md)。
 
-角色通过 `extends_roles` 递归继承父角色的 capabilities，再加入自身能力。共同祖先和重复能力自动去重；缺失父角色与循环继承会报错。父角色可作为纯声明模板；子角色使用自身的 role vendor、宿主和 CLI packages。规则见 [角色继承](capabilities/README.md#角色继承)。
+角色通过 `extends_roles` 沿单继承链读取父角色的 capabilities，再加入自身能力。每个角色最多继承一个父角色，链上的重复能力自动去重；多父角色、缺失父角色与循环继承会报错。父角色可作为纯声明模板；子角色使用自身的 role vendor、宿主和 CLI packages。规则见 [角色继承](capabilities/README.md#角色继承)。
 
 宿主目录、别名、skills 投影开关和 MCP 格式统一声明在 [hosts/hosts.yaml](hosts/hosts.yaml)。`scripts/lib/hosts.ts` 负责加载、校验和路径解析，声明类型放在 `scripts/lib/types/`。新增宿主只需更新 YAML；字段与维护说明见 [hosts/README.md](hosts/README.md)。
 

package/capabilities/README.md

@@ -24,7 +24,6 @@ capabilities/
 │   ├── capability.yaml         # Anthropic frontend-design 上游声明
 │   ├── mcps.json               # Playwright
 │   └── README.md
-├── grilling/capability.yaml    # 仅同步 Matt Pocock grilling
 ├── productivity/capability.yaml # Matt Pocock productivity 上游声明
 └── engineering/capability.yaml # Matt Pocock engineering 上游声明
 ```
@@ -40,25 +39,23 @@ AIRules 自有共享 skills 实际存放在 `capabilities/<能力>/skills/`。
 | [`common`](common/README.md) | AIRules `create-skill`、`spec-organization`、`hindsight-memory`；上游 `hindsight-docs` | Hindsight HTTP 记忆 |
 | [`coding`](coding/README.md) | 无 | CodeGraph、Context7、Sequential Thinking |
 | [`frontend`](frontend/README.md) | Anthropic `frontend-design` | Playwright |
-| `productivity` | Matt Pocock productivity skills | 无 |
+| `productivity` | Matt Pocock productivity skills，包括 `grilling` | 无 |
 | `engineering` | Matt Pocock engineering skills | 无 |
-| [`grilling`](grilling/README.md) | Matt Pocock `grilling` | 无 |
 
 | Role | 继承 | 自身 Capabilities |
 |---|---|---|
-| [`general`](../roles/general/README.md) | 无 | `common`, `grilling` |
-| `trellis` | `general` | `coding`, `productivity`, `frontend` |
-| `moluoxixi` | `general` | `coding`, `productivity`, `frontend` |
-| `matt` | `general` | `engineering`, `productivity` |
+| [`general`](../roles/general/README.md) | 无 | `common` |
+| [`development`](../roles/development/README.md) | `general` | `coding`, `productivity`, `frontend` |
+| `trellis` | `development` | 无，使用模板的共享能力 |
+| `moluoxixi` | `development` | 无，使用模板的共享能力 |
+| `matt` | `development` | `engineering` |
 
 角色选择示例：
 
 ```yaml
 # roles/<role>/role.yaml
-extends_roles: [general]
-capabilities:
-  - coding
-  - frontend
+extends_roles: [development]
+capabilities: []
 ```
 
 `roles/<role>/role.yaml` 声明角色自身的 `role_vendor`、CLI 安装命令、宿主支持、继承关系和 publishable packages。角色自有的 `init-project`、hooks、agents、packages 等仍放在 `roles/<role>/`，由 `role-assets` 全量同步。旧包若仍带有 `constants/skills.ts`，安装器会在没有 `role.yaml` 时兼容读取它。
@@ -67,11 +64,15 @@ capabilities:
 
 ## 角色继承
 
-`extends_roles` 将角色作为可复用的能力模板。`general` 既能独立安装，也作为开发角色的基础：子角色安装时递归读取父角色的 `capabilities`，再加入自己的能力。多层和多父角色按声明顺序合并，共同祖先与相同能力只处理一次。子角色可用 `capabilities: []` 继承整组通用能力。
+`extends_roles` 将角色作为可复用的能力模板。每个角色只允许继承一个父角色，或用 `extends_roles: []` 声明没有父角色。多父角色声明会在加载阶段报错，重复填写相同父角色也会报错；YAML 与旧 `extendsRoles` 导出使用同一校验规则。
+
+`general` 提供记忆、skill 编写与文档整理；`development` 继承 `general`，集中维护 `coding`、`productivity` 与 `frontend`。具体开发角色统一继承 `development` 的基础 skills 与 MCP，再选择自己的工程工作流。`engineering` 由 Matt 角色单独选择。两个基础角色也可独立安装。
+
+子角色安装时沿单继承链读取父角色的 `capabilities`，再加入自己的能力；链上重复的能力只处理一次。子角色可用 `capabilities: []` 继承整组模板能力。能力组合仍会校验供应商版本和投影目标冲突。
 
 继承范围是 capability 声明及其 skills、MCP 与供应商 setup。子角色的 `role_vendor`、角色专属资产、CLI packages 和 hosts 由自身声明；安装器将继承的第一方能力从子角色的 AIRules 远程 checkout 投影到 vendor。能力模板可只声明 `capabilities` 和 `extends_roles`；独立安装的角色需提供自身 `role_vendor`。
 
-缺失父角色、循环继承、单份声明中的重复能力及供应商版本冲突会报错。`grilling` 同时由父角色显式选择、由子角色的 `productivity` namespace 带入时，同一供应商的同一源码只投影一次；不同来源的同名 skill 仍报冲突。
+缺失父角色、循环继承、单份声明中的重复能力及供应商版本冲突会报错。同一供应商的同一源码只投影一次；不同来源的同名 skill 仍报冲突。`grilling` skill 归属 `productivity`，随该能力的 namespace 一起同步。
 
 ## MCP 清单
 

package/dist/scripts/lib/roles.d.ts

@@ -9,6 +9,7 @@ export interface RolePaths {
 }
 export declare function requireRolePaths(repoRoot: string, roleValue: unknown): RolePaths;
 export declare function roleOverlayOrder(repoRoot: string, roleValue?: unknown): Promise<string[]>;
+export declare function requireRoleInheritance(value: unknown, location: string): string[];
 export declare function resolveRoleManifestPath(repoRoot: string, roleValue: unknown, options?: {
     preferDist?: boolean;
 }): string;

package/dist/scripts/lib/roles.js

@@ -63,26 +63,28 @@ export async function roleOverlayOrder(repoRoot, roleValue = DEFAULT_ROLE) {
     }
     const role = requireRoleName(roleValue);
     const orderedRoles = [];
-    const seenRoles = new Set();
     const visitingRoles = new Set();
-    async function visit(roleName) {
+    let roleName = role;
+    while (roleName !== undefined) {
         requireRolePaths(repoRoot, roleName);
-        if (seenRoles.has(roleName)) {
-            return;
-        }
         if (visitingRoles.has(roleName)) {
             throw new Error(`AIRules role inheritance cycle detected at "${roleName}"`);
         }
         visitingRoles.add(roleName);
-        for (const extendedRole of await loadRoleExtendsRoles(repoRoot, roleName)) {
-            await visit(extendedRole);
-        }
-        visitingRoles.delete(roleName);
-        seenRoles.add(roleName);
         orderedRoles.push(roleName);
+        const parents = await loadRoleExtendsRoles(repoRoot, roleName);
+        roleName = parents[0];
     }
-    await visit(role);
-    return orderedRoles;
+    return orderedRoles.reverse();
+}
+export function requireRoleInheritance(value, location) {
+    if (!Array.isArray(value) || !value.every(roleName => typeof roleName === 'string')) {
+        throw new TypeError(`${location} must be a string array`);
+    }
+    if (value.length > 1) {
+        throw new Error(`${location} supports at most one parent role (single inheritance)`);
+    }
+    return value;
 }
 export function resolveRoleManifestPath(repoRoot, roleValue, options = {}) {
     if (roleValue === '') {
@@ -150,18 +152,12 @@ async function loadRoleExtendsRoles(repoRoot, role) {
         }
         const record = value;
         const extendsRoles = record.extends_roles ?? record.extendsRoles ?? [];
-        if (!Array.isArray(extendsRoles) || !extendsRoles.every(roleName => typeof roleName === 'string')) {
-            throw new TypeError(`roles/${role}/role.yaml field "extends_roles" must be a string array`);
-        }
-        return extendsRoles;
+        return requireRoleInheritance(extendsRoles, `roles/${role}/role.yaml field "extends_roles"`);
     }
     const manifestUrl = pathToFileURL(path.resolve(manifestPath)).href;
     const module = await import(manifestUrl);
     const extendsRoles = module.extendsRoles ?? module.default?.extendsRoles ?? [];
-    if (!Array.isArray(extendsRoles) || !extendsRoles.every(roleName => typeof roleName === 'string')) {
-        throw new TypeError(`roles/${role}/constants/skills.ts export "extendsRoles" must be a string array`);
-    }
-    return extendsRoles;
+    return requireRoleInheritance(extendsRoles, `roles/${role}/constants/skills.ts export "extendsRoles"`);
 }
 function requireInsideRoot(root, target, field, rootLabel) {
     if (!isPathInside(root, target)) {

package/dist/scripts/lib/vendors.js

@@ -4,7 +4,7 @@ import { fileURLToPath, pathToFileURL, URL } from 'node:url';
 import { parseDocument } from 'yaml';
 import { CAPABILITY_NAMES, composeCapabilities } from './capabilities.js';
 import { HOST_IDS } from './hosts.js';
-import { resolveRoleManifestPath, roleOverlayOrder } from './roles.js';
+import { requireRoleInheritance, resolveRoleManifestPath, roleOverlayOrder } from './roles.js';
 import { flattenedSkillName, flattenedVendorSkillTarget } from './skill-projection.js';
 const vendorNamePattern = /^[A-Za-z0-9][\w-]*$/u;
 const npmPackageNamePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u;
@@ -212,6 +212,7 @@ export async function loadVendorManifest(manifestPath) {
     const module = isRoleYaml
         ? {}
         : await import(pathToFileURL(resolvedManifestPath).href);
+    requireRoleInheritance(roleContract?.extendsRoles ?? module.extendsRoles ?? module.default?.extendsRoles ?? [], `Vendor manifest "${manifestPath}" field "extends_roles"`);
     const roleVendor = roleContract?.roleVendor
         ?? module.roleVendor
         ?? module.default?.roleVendor;
@@ -313,10 +314,7 @@ function tryLoadRoleContract(manifestPath) {
 }
 async function requireRoleCapabilityContract(manifestPath, contract) {
     const contractPath = resolveRoleContractPath(manifestPath);
-    const extendsRoles = contract.extendsRoles ?? [];
-    if (!Array.isArray(extendsRoles) || !extendsRoles.every(role => typeof role === 'string')) {
-        throw new TypeError(`Role contract "${contractPath}" field "extends_roles" must be a string array`);
-    }
+    const extendsRoles = requireRoleInheritance(contract.extendsRoles ?? [], `Role contract "${contractPath}" field "extends_roles"`);
     const roleRoot = path.dirname(contractPath);
     const repoRoot = path.resolve(roleRoot, '..', '..');
     const role = path.basename(roleRoot);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "moluoxixi-ai-rules",
   "type": "module",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Remote AI role asset distribution for supported hosts.",
   "license": "MIT",
   "repository": "https://github.com/moluoxixi/AIRules",

package/roles/development/README.md

@@ -0,0 +1,50 @@
+# Development
+
+`development` 是开发通用模板，继承 [`general`](../general/README.md) 的记忆、skill 编写和文档整理能力，再提供效率 skills、代码工具和前端能力。
+
+```text
+general
+└── development
+    ├── matt
+    ├── moluoxixi
+    └── trellis
+```
+
+## 共享能力
+
+| Capability | 提供的能力 |
+|---|---|
+| `common`，继承自 `general` | `create-skill`、`spec-organization`、`hindsight-memory`、`hindsight-docs`，以及 Hindsight 记忆 MCP 和可视化部署资产 |
+| `coding` | CodeGraph、Context7、Sequential Thinking MCP |
+| `productivity` | Matt Pocock 的效率 skills：`grilling`、`grill-me`、`handoff`、`teach`、`to-questionnaire`、`wait-what`、`writing-for-agents` 等 |
+| `frontend` | Anthropic `frontend-design` skill 和 Playwright MCP |
+
+共享能力只在 [`role.yaml`](role.yaml) 中选择；供应商、固定 commit 和远程投影统一维护在 [`capabilities/`](../../capabilities/README.md)。新增共享开发能力时更新本模板，所有子角色会随之获得。
+
+三个子角色获得相同的基础 skills 和 MCP。`matt` 单独选择 `engineering`，提供 `ask-matt`、`tdd`、`code-review`、`diagnosing-bugs`、`to-spec`、`to-tickets` 等 Matt 工程工作流；`moluoxixi` 提供自身 CLI、项目工作流、hooks、agents 与知识库初始化；`trellis` 提供原生 Trellis CLI 与项目工作流初始化。工程工作流由各角色选择，基础模板集中维护共享工具。角色专属资产由子角色的 `role_vendor` 全量远程同步，CLI 和 packages 由子角色自己声明。
+
+## 继承模板
+
+新增开发角色只需声明父模板和自身专属配置：
+
+```yaml
+# roles/<role>/role.yaml 的继承部分
+extends_roles: [development]
+capabilities: []
+```
+
+如需角色专属能力，在自身 `capabilities` 中追加。每个角色最多继承一个父角色，支持 `general → development → 子角色` 这样的多层链。声明多个父角色会在加载时直接报错，包括重复填写同一个父角色。链上的重复能力和相同上游源码自动去重。父模板的 `role_vendor`、CLI、packages 和 hosts 不会覆盖子角色的安装设置。
+
+## 独立使用
+
+模板也可独立安装，直接获得共享开发 skills 和 MCP：
+
+```bash
+npm install --global moluoxixi-ai-rules
+airules install development --host all
+airules verify development --host all
+```
+
+安装共享 MCP 时会执行其前置工具 setup。`development` 没有专属项目 CLI，也无需 `init-project`。需要项目工作流时安装相应子角色。
+
+Hindsight MCP 默认连接 `http://localhost:8888/mcp/`，记忆控制台默认位于 `http://localhost:9999`。实际使用记忆前按[记忆可视化部署说明](../../capabilities/common/skills/hindsight-memory/references/visualization.md)启动服务并配置模型。

package/roles/development/role.yaml

@@ -0,0 +1,22 @@
+schema_version: 1
+role_id: development
+role_version: 0.1.0
+status: stable
+canonical_root: roles/development
+description: Shared development template for productivity, coding tools, and frontend work.
+capabilities:
+  - coding
+  - productivity
+  - frontend
+hosts: all
+extends_roles: [general]
+role_vendor:
+  name: development-role
+  source: https://github.com/moluoxixi/AIRules.git
+  projections:
+    - kind: role-assets
+      source_dir: roles/development
+distribution:
+  bootstrap_manifest: role.yaml
+  full_role_path_required: true
+  npm_embedded_source: false

package/roles/general/README.md

@@ -1,6 +1,6 @@
 # General
 
-`general` 提供计划审问、长期记忆、skill 编写和知识整理等通用能力。角色在 [`role.yaml`](role.yaml) 中选择 `common` 和 `grilling`，资产从远程供应商同步。
+`general` 提供长期记忆、skill 编写和知识整理等通用能力。角色在 [`role.yaml`](role.yaml) 中选择 `common`，资产从远程供应商同步。
 
 ## 安装
 
@@ -14,7 +14,6 @@ airules verify general --host all
 
 | Skill | 用途 |
 |---|---|
-| `grilling` | 逐项审问计划、决策和假设，明确取舍与验证条件 |
 | `hindsight-memory` | 按项目回忆和保存已确认的信息，查看记忆控制台 |
 | `hindsight-docs` | 查询 Hindsight API、部署和高级配置 |
 | `create-skill` | 编写或修订通用 skill |
@@ -25,7 +24,7 @@ airules verify general --host all
 ## 使用
 
 ```text
-请用 grilling 审问这个计划，逐项检查假设和取舍。
+请整理这个项目的文档目录、索引和链接。
 请记住我们已确认的结论、理由和下一步验证条件。
 回忆这个项目之前的决定，并核对是否仍适用。
 打开当前项目的记忆可视化，查看保存的事实和实体关系图。
@@ -33,16 +32,15 @@ airules verify general --host all
 
 记忆控制台默认位于 `http://localhost:9999`。在控制台选择与 MCP 相同的项目 bank，查看事实、来源文档、实体关系图和异步操作状态。已有 Hindsight API 时只需添加控制台；首次部署可使用随 `hindsight-memory` skill 分发的 Docker Compose。操作步骤见 [记忆可视化](../../capabilities/common/skills/hindsight-memory/references/visualization.md)。
 
-审问中的候选方案与已确认结论分别标注状态；只有确认保存成功后才报告记忆已写入。
+候选方案与已确认结论分别标注状态；只有确认保存成功后才报告记忆已写入。
 
 ## 作为基础角色
 
-`moluoxixi`、`trellis` 和 `matt` 通过 `extends_roles: [general]` 继承通用能力。新增开发角色同样可以继承，再选择自身能力：
+[`development`](../development/README.md) 通过 `extends_roles: [general]` 继承通用能力，并集中选择共享开发能力。`moluoxixi`、`trellis` 和 `matt` 再继承 `development`。新增开发角色使用同一模板：
 
 ```yaml
-extends_roles: [general]
-capabilities:
-  - coding
+extends_roles: [development]
+capabilities: []
 ```
 
-多层继承与共同祖先自动合并；规则见 [角色继承](../../capabilities/README.md#角色继承)。
+角色仅支持单继承，可以沿单个父角色形成多层继承链；相同能力自动去重。规则见 [角色继承](../../capabilities/README.md#角色继承)。

package/roles/general/role.yaml

@@ -3,10 +3,9 @@ role_id: general
 role_version: 0.1.0
 status: stable
 canonical_root: roles/general
-description: Shared skills for grilling plans, organizing knowledge, and persistent memory with the Hindsight console.
+description: Shared skills for organizing knowledge and persistent memory with the Hindsight console.
 capabilities:
   - common
-  - grilling
 hosts: all
 extends_roles: []
 role_vendor:

package/roles/matt/role.yaml

@@ -3,15 +3,14 @@ role_id: matt
 role_version: 0.1.0
 status: experimental
 canonical_root: roles/matt
-description: Installs Matt Pocock's engineering and productivity skills through AIRules.
+description: Development role using Matt Pocock's skills and shared coding and frontend tools.
 assets:
   skills: skills
 capabilities:
   - engineering
-  - productivity
 role_vendor_position: after
 hosts: all
-extends_roles: [general]
+extends_roles: [development]
 role_vendor:
   name: matt-role
   source: https://github.com/moluoxixi/AIRules.git

package/roles/moluoxixi/role.yaml

@@ -3,17 +3,14 @@ role_id: moluoxixi
 role_version: 0.5.0
 status: experimental
 canonical_root: roles/moluoxixi
-description: Publishable role-local Moluoxixi packages, project initialization, and shared coding, frontend, and productivity capabilities.
+description: Publishable role-local Moluoxixi packages and project initialization with the shared development template.
 assets:
   skills: skills
   mcp: mcp
   packages: packages
-capabilities:
-  - coding
-  - productivity
-  - frontend
+capabilities: []
 hosts: all
-extends_roles: [general]
+extends_roles: [development]
 role_vendor:
   name: moluoxixi
   source: https://github.com/moluoxixi/AIRules.git

package/roles/trellis/role.yaml

@@ -3,16 +3,13 @@ role_id: trellis
 role_version: 0.5.0
 status: stable
 canonical_root: roles/trellis
-description: Installs Trellis, shared coding and frontend capabilities, native project initialization, and Matt Pocock productivity skills through AIRules.
+description: Installs Trellis and native project initialization with the shared development template.
 assets:
   skills: skills
   mcp: mcp
-capabilities:
-  - coding
-  - productivity
-  - frontend
+capabilities: []
 hosts: all
-extends_roles: [general]
+extends_roles: [development]
 role_vendor:
   name: trellis
   source: https://github.com/moluoxixi/AIRules.git

package/capabilities/grilling/README.md

@@ -1,5 +0,0 @@
-# Grilling
-
-[`capability.yaml`](capability.yaml) 从 Matt Pocock 的 skills 仓库固定版本同步 `skills/productivity/grilling`，提供计划、决策与假设审问能力。
-
-`grilling` capability 只投影这一项 skill。需要整组效率 skills 时可选择 `productivity`；需要轻量通用组合时使用 [`general`](../../roles/general/README.md)。

package/capabilities/grilling/capability.yaml

@@ -1,12 +0,0 @@
-schema_version: 1
-capability_id: grilling
-description: Matt Pocock's grilling skill for stress-testing plans and decisions.
-vendors:
-  - name: mattpocock
-    source: https://github.com/mattpocock/skills.git
-    revision: 8b78b531ab965735c5dc74f6f7a219e1e37326df
-    projections:
-      - kind: skills
-        source_base_dir: skills/productivity
-        skills:
-          - grilling