@mison/ling 1.0.0

package/.agents/skills/app-builder/templates/nuxt-app/TEMPLATE.md

@@ -0,0 +1,134 @@
+---
+name: nuxt-app
+description: Nuxt 4 Full-Stack template（全栈模板）。Vue 3（Vapor Mode，蒸汽模式）、Pinia、Tailwind v4、Prisma。
+---
+
+# Nuxt 4 Full-Stack Template（全栈模板，2026 版）
+
+Nuxt 4 的现代全栈模板，使用 Vapor Mode（蒸汽模式）与 Tailwind v4 优化性能。
+
+## Tech Stack（技术栈）
+
+| Component（组件） | Technology（技术） | Version / Notes（版本/说明） |
+| --- | --- | --- |
+| Framework（框架） | Nuxt | v4.0+（App Directory（应用目录）结构） |
+| UI Engine（UI 引擎） | Vue | v3.6+（启用 Vapor Mode） |
+| Language（语言） | TypeScript | v5+（Strict Mode，严格模式） |
+| State（状态） | Pinia | v3+（Store syntax（Store 语法）） |
+| Database（数据库） | PostgreSQL | Prisma ORM（对象关系映射） |
+| Styling（样式） | Tailwind CSS | v4.0（Vite 插件，零配置） |
+| UI Lib（组件库） | Nuxt UI | v3（Tailwind v4 原生） |
+| Validation（校验） | Zod | Schema validation（模式校验） |
+
+---
+
+## Directory Structure（Nuxt 4 标准）
+
+使用 `app/` 结构保持根目录整洁。
+
+```
+project-name/
++-- app/                  # Application Source（应用源码）
+|   +-- assets/
+|   |   +-- css/
+|   |       +-- main.css  # Tailwind v4 导入
+|   +-- components/       # Auto-imported components（自动导入组件）
+|   +-- composables/      # Auto-imported logic（自动导入逻辑）
+|   +-- layouts/
+|   +-- pages/            # File-based routing（基于文件路由）
+|   +-- app.vue           # Root component（根组件）
+|   +-- router.options.ts
++-- server/               # Nitro Server Engine（服务端引擎）
+|   +-- api/              # API Routes（接口路由，例如 /api/users）
+|   +-- routes/           # Server Routes（服务端路由）
+|   +-- utils/            # Server-only helpers（仅服务端辅助，Prisma）
++-- prisma/
+|   +-- schema.prisma
++-- public/
++-- nuxt.config.ts        # Main Config（主配置）
++-- package.json
+```
+
+---
+
+## Key Concepts（2026）
+
+| Concept（概念） | Description（说明） | Future Update（未来更新） |
+| --- | --- | --- |
+| **App Directory（应用目录）** | `app/` | 分离应用源码与根配置文件。 |
+| **Vapor Mode（蒸汽模式）** | 性能优先 | 无需 Virtual DOM（虚拟 DOM，类似 SolidJS）。在 `nuxt.config` 中启用。 |
+| **Server Functions（服务端函数）** | RPC 风格调用 | 从客户端直接调用服务端函数（逐步替代手写 API routes（API 路由））。 |
+| **Tailwind v4** | CSS-first | 主题直接在 CSS 中配置，无需 `tailwind.config.js`。 |
+| **Nuxt Islands（岛屿组件）** | Server Components（服务端组件） | 在服务端隔离渲染组件（`<NuxtIsland name="..." />`）。 |
+
+---
+
+## Environment Variables（环境变量）
+
+| Variable（变量） | Purpose（用途） |
+| --- | --- |
+| DATABASE_URL | Prisma connection string（PostgreSQL 连接字符串） |
+| NUXT_PUBLIC_APP_URL | Canonical URL（规范 URL） |
+| NUXT_SESSION_PASSWORD | Session encryption key（会话加密密钥） |
+
+---
+
+## Setup Steps（设置步骤）
+
+1. Initialize Project（初始化项目）：
+   ```bash
+   npx nuxi@latest init my-app
+   # 如有提示，选择 "Nuxt 4 structure"
+   ```
+
+2. Install Core Deps（安装核心依赖）：
+   ```bash
+   npm install @pinia/nuxt @prisma/client zod
+   npm install -D prisma
+   ```
+
+3. Setup Tailwind v4（设置 Tailwind v4）：
+   安装 Vite 插件（新标准）：
+   ```bash
+   npm install tailwindcss @tailwindcss/vite
+   ```
+
+   添加到 `nuxt.config.ts`：
+   ```ts
+   import tailwindcss from '@tailwindcss/vite'
+   export default defineNuxtConfig({
+     vite: {
+       plugins: [tailwindcss()]
+     },
+     css: ['~/assets/css/main.css']
+   })
+   ```
+
+4. Configure CSS（配置 CSS）：
+   在 `app/assets/css/main.css` 中：
+   ```css
+   @import "tailwindcss";
+   @theme {
+     --color-primary: oklch(0.6 0.15 150);
+   }
+   ```
+
+5. 开发运行：
+   ```bash
+   npm run dev
+   # 使用 Turbo/Vite 运行
+   ```
+
+---
+
+## 最佳实践
+
+- **Vapor Mode（Vapor 模式）**：为渲染密集型组件启用：
+  ```ts
+  <script setup lang="ts" vapor>
+  // 此组件会编译为 Vapor 模式（无 VDOM）
+  </script>
+  ```
+- **Data Fetching（数据获取）**：对仅客户端任务使用 `useFetch` + `server: false`，或使用 Server Functions 获得更好的类型安全。
+- **State（状态）**：使用 `defineStore`（Pinia）管理全局状态，Nuxt 的 `useState` 用于服务端/客户端共享的简单状态。
+- **Type Safety（类型安全）**：为 API routes（API 路由）自动生成类型（`$fetch` 自动类型化）。

package/.agents/skills/app-builder/templates/python-fastapi/TEMPLATE.md

@@ -0,0 +1,83 @@
+---
+name: python-fastapi
+description: FastAPI REST API template principles（API 模板原则）。SQLAlchemy、Pydantic、Alembic。
+---
+
+# FastAPI API Template（API 模板）
+
+## Tech Stack（技术栈）
+
+| Component（组件） | Technology（技术） |
+| --- | --- |
+| Framework（框架） | FastAPI |
+| Language（语言） | Python 3.11+ |
+| ORM | SQLAlchemy 2.0 |
+| Validation（校验） | Pydantic v2 |
+| Migrations（迁移） | Alembic |
+| Auth（认证） | JWT + passlib（密码哈希） |
+
+---
+
+## Directory Structure（目录结构）
+
+```
+project-name/
++-- alembic/             # Migrations（迁移）
++-- app/
+|   +-- main.py          # FastAPI app（应用）
+|   +-- config.py        # Settings（配置）
+|   +-- database.py      # DB connection（数据库连接）
+|   +-- models/          # SQLAlchemy models（模型）
+|   +-- schemas/         # Pydantic schemas（模式）
+|   +-- routers/         # API routes（路由）
+|   +-- services/        # Business logic（业务逻辑）
+|   +-- dependencies/    # Dependency Injection（依赖注入）
+|   +-- utils/
++-- tests/
++-- .env.example
++-- requirements.txt
+```
+
+---
+
+## Key Concepts（关键概念）
+
+| Concept（概念） | Description（说明） |
+| --- | --- |
+| Async（异步） | async/await throughout（全程 async/await） |
+| Dependency Injection（依赖注入） | FastAPI Depends |
+| Pydantic v2 | Validation + serialization（验证 + 序列化） |
+| SQLAlchemy 2.0 | Async sessions（异步会话） |
+
+---
+
+## API Structure（API 结构）
+
+| Layer（层） | Responsibility（职责） |
+| --- | --- |
+| Routers（路由层） | HTTP handling（HTTP 处理） |
+| Dependencies（依赖层） | Auth, validation（认证、校验） |
+| Services（服务层） | Business logic（业务逻辑） |
+| Models（模型层） | Database entities（数据库实体） |
+| Schemas（模式层） | Request/response（请求/响应） |
+
+---
+
+## Setup Steps（设置步骤）
+
+1. `python -m venv venv`
+2. `source venv/bin/activate`
+3. `pip install fastapi uvicorn sqlalchemy alembic pydantic`
+4. Create `.env`（创建）
+5. `alembic upgrade head`
+6. `uvicorn app.main:app --reload`
+
+---
+
+## Best Practices（最佳实践）
+
+- Use async everywhere（全程使用 async）
+- Pydantic v2 for validation（用于验证）
+- SQLAlchemy 2.0 async sessions（异步会话）
+- Alembic for migrations（迁移）
+- pytest-asyncio for tests（测试）

package/.agents/skills/app-builder/templates/react-native-app/TEMPLATE.md

@@ -0,0 +1,119 @@
+---
+name: react-native-app
+description: React Native mobile app template（移动应用模板）原则。Expo、TypeScript、导航。
+---
+
+# React Native App Template（应用模板，2026 版）
+
+现代移动应用模板，针对 New Architecture（新架构）与 React 19 优化。
+
+## Tech Stack（技术栈）
+
+| Component（组件） | Technology（技术） | Version / Notes（版本/说明） |
+| --- | --- | --- |
+| Core（核心） | React Native + Expo | SDK 52+（启用新架构） |
+| Language（语言） | TypeScript | v5+（Strict Mode，严格模式） |
+| UI Logic（UI 逻辑） | React | v19（React Compiler（编译器），自动记忆化） |
+| Navigation（导航） | Expo Router | v4+（File-based（基于文件）、Universal Links（通用链接）） |
+| Styling（样式） | NativeWind | v4.0（Tailwind v4，CSS-first 配置） |
+| State（状态） | Zustand + React Query | v5+（异步状态管理） |
+| Storage（存储） | Expo SecureStore | 加密本地存储 |
+
+---
+
+## Directory Structure（目录结构）
+
+Expo Router 与 NativeWind v4 的标准化结构。
+
+```
+project-name/
++-- app/                 # Expo Router（基于文件的路由）
+|   +-- _layout.tsx      # Root Layout（Stack/Tabs 配置）
+|   +-- index.tsx        # Main Screen（主屏幕）
+|   +-- (tabs)/          # Tab Bar Route Group（标签栏路由组）
+|   |   +-- _layout.tsx
+|   |   +-- home.tsx
+|   |   +-- profile.tsx
+|   +-- +not-found.tsx   # 404 Page（404 页面）
+|   +-- [id].tsx         # Dynamic Route（类型化）
++-- components/
+|   +-- ui/              # Primitive Components（Button, Text）
+|   +-- features/        # Complex Components（复杂组件）
++-- hooks/               # Custom Hooks（自定义 hooks）
++-- lib/
+|   +-- api.ts           # Axios/Fetch 客户端
+|   +-- storage.ts       # SecureStore wrapper（封装）
++-- store/               # Zustand store（状态仓库）
++-- constants/           # 颜色、主题配置
++-- assets/              # 字体、图片
++-- global.css           # NativeWind v4 entry（入口点）
++-- tailwind.config.ts   # Tailwind 配置（如需自定义主题）
++-- babel.config.js      # NativeWind Babel 插件
++-- app.json             # Expo 配置
+```
+
+---
+
+## Navigation Patterns（Expo Router）
+
+| Pattern（模式） | Description（描述） | Implement（实现） |
+| --- | --- | --- |
+| Stack（堆栈） | 层级导航（Push/Pop） | `<Stack />` 在 `_layout.tsx` |
+| Tabs（标签） | 底部导航栏 | `<Tabs />` 在 `(tabs)/_layout.tsx` |
+| Drawer（抽屉） | 侧滑菜单 | `expo-router/drawer` |
+| Modals（模态） | 覆盖屏幕 | Stack 页面中的 `presentation: 'modal'` |
+
+---
+
+## Key Packages & Purpose（关键依赖与用途）
+
+| Package（依赖） | Purpose（用途） |
+| --- | --- |
+| expo-router | 基于文件的路由（类似 Next.js） |
+| nativewind | 在 React Native 中使用 Tailwind CSS 类 |
+| react-native-reanimated | 平滑动画（在 UI（用户界面）线程上运行） |
+| @tanstack/react-query | 服务端状态管理、缓存、预取 |
+| zustand | 全局状态管理（比 Redux 更轻） |
+| expo-image | 优化图像渲染以提升性能 |
+
+---
+
+## Setup Steps（2026 标准）
+
+1. Initialize Project（初始化项目）：
+   ```bash
+   npx create-expo-app@latest my-app --template default
+   cd my-app
+   ```
+
+2. Install Core Dependencies（安装核心依赖）：
+   ```bash
+   npx expo install expo-router react-native-safe-area-context react-native-screens expo-link expo-constants expo-status-bar
+   ```
+
+3. Install NativeWind v4（安装 NativeWind v4）：
+   ```bash
+   npm install nativewind tailwindcss react-native-reanimated
+   ```
+
+4. Configure NativeWind（Babel 与 CSS）：
+   - 在 `babel.config.js` 添加插件：`plugins: ["nativewind/babel"]`。
+   - 创建 `global.css` 并包含：`@import "tailwindcss";`。
+   - 在 `app/_layout.tsx` 中导入 `global.css`。
+
+5. Run Project（运行项目）：
+   ```bash
+   npx expo start -c
+   # 按 'i' 启动 iOS 模拟器或按 'a' 启动 Android 模拟器
+   ```
+
+---
+
+## Best Practices（更新）
+
+- **New Architecture（新架构）**：确保 `app.json` 中 `newArchEnabled: true`，以利用 TurboModules 与 Fabric Renderer。
+- **Typed Routes（类型化路由）**：使用 Expo Router 的 “Typed Routes” 特性实现类型安全路由（例如 `router.push('/path')`）。
+- **React 19**：借助 React Compiler（编译器，如已启用）减少 `useMemo` 或 `useCallback` 的使用。
+- **组件**：使用 NativeWind `className` 构建 UI（用户界面）原语（Box, Text），提高可复用性。
+- **资产**：使用 `expo-image` 代替默认 `<Image />`，提升缓存与性能。
+- **API（接口）**：使用 TanStack Query 包装 API 调用，避免在 `useEffect` 中直接调用。

package/.agents/skills/architecture/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: architecture
+description: Architectural decision-making framework（架构决策框架）。Requirements analysis（需求分析）、trade-off evaluation（权衡评估）、ADR documentation（架构决策记录）。Use when making architecture decisions or analyzing system design（用于架构决策与系统设计分析）。
+allowed-tools: Read, Glob, Grep
+---
+
+# Architecture Decision Framework（架构决策框架）
+
+> "Requirements drive architecture. Trade-offs inform decisions. ADRs capture rationale."（需求驱动架构，权衡决定结论，ADR 记录依据。）
+
+##  Selective Reading Rule（选择性阅读规则）
+
+**Read ONLY files relevant to the request（仅阅读与请求相关的文档）！** Check the content map, find what you need（查阅内容地图，找到所需信息）。
+
+| File（文件） | Description（描述） | When to Read（阅读时机） |
+| ---- | ---- | -------- |
+| `context-discovery.md` | Questions to ask, project classification（提问列表、项目分类） | Starting architecture design（开始架构设计） |
+| `trade-off-analysis.md` | ADR templates, trade-off framework（ADR 模板、权衡分析框架） | Documenting decisions（记录决策） |
+| `pattern-selection.md` | Decision trees, anti-patterns（决策树、反模式） | Choosing patterns（选择模式） |
+| `examples.md` | MVP, SaaS, Enterprise examples（示例） | Reference implementations（参考实现） |
+| `patterns-reference.md` | Quick lookup for patterns（模式速查） | Pattern comparison（模式对比） |
+
+---
+
+##  Related Skills（相关技能）
+
+| Skill（技能） | Use For（用途） |
+| ------------ | ---- |
+| `@[skills/database-design]` | Database schema design（数据库模式设计） |
+| `@[skills/api-patterns]` | API design patterns（API 设计模式） |
+| `@[skills/deployment-procedures]` | Deployment architecture（部署架构） |
+
+---
+
+## Core Principle（核心原则）
+
+**"Simplicity is the ultimate sophistication."（至简即至繁）**
+
+- Start simple（从简单开始）。
+- Add complexity ONLY when proven necessary（仅在必要时增加复杂性）。
+- You can always add patterns later（随时可补充模式）。
+- Removing complexity is MUCH harder than adding it（移除复杂性远比增加难）。
+
+---
+
+## Validation Checklist（验证检查清单）
+
+Before finalizing architecture（最终确定架构之前）：
+
+- [ ] **Requirements clearly understood（需求已清晰理解）。**
+- [ ] **Constraints identified（约束条件已明确）。**
+- [ ] **Each decision has trade-off analysis（每项决策有权衡分析）。**
+- [ ] **Simpler alternatives considered（已考虑更简单替代方案）。**
+- [ ] **ADRs written for significant decisions（重大决策已编写 ADR）。**
+- [ ] **Team expertise matches chosen patterns（团队能力与模式匹配）。**
+
+---

package/.agents/skills/architecture/context-discovery.md

@@ -0,0 +1,43 @@
+# 上下文发现
+
+> 在提出任何架构方案前，先收集上下文信息。
+
+## 问题层级（先问用户）
+
+1. **规模（Scale）**
+   - 用户量级是多少？（10、1K、100K、1M+）
+   - 数据规模是多少？（MB、GB、TB）
+   - 事务速率是多少？（每秒/每分钟）
+
+2. **团队（Team）**
+   - 个人开发还是团队协作？
+   - 团队规模与能力结构？
+   - 是分布式团队还是同地办公？
+
+3. **时间线（Timeline）**
+   - 是 MVP（最小可行产品）/原型，还是长期产品？
+   - 上线时效压力有多大？
+
+4. **业务域（Domain）**
+   - 以 CRUD（增删改查）为主，还是业务逻辑复杂？
+   - 是否有实时性要求？
+   - 是否有合规/监管要求？
+
+5. **约束条件（Constraints）**
+   - 是否有预算限制？
+   - 是否要集成遗留系统？
+   - 是否有技术栈偏好？
+
+## 项目分类矩阵
+
+```
+                    MVP（最小可行产品）      SaaS（软件即服务）     Enterprise（企业级）
++----------------------------------------------------------------------------+
+| 规模           | <1K                 | 1K-100K          | 100K+           |
+| 团队           | 单人                | 2-10             | 10+             |
+| 时间线         | 快（周级）           | 中（月级）        | 长（年级）        |
+| 架构           | 简单架构             | 模块化架构        | 分布式架构        |
+| 模式           | 最小模式集           | 选择性模式        | 全面模式体系      |
+| 示例           | Next.js API（接口）  | NestJS           | Microservices（微服务）|
++----------------------------------------------------------------------------+
+```

package/.agents/skills/architecture/examples.md

@@ -0,0 +1,94 @@
+# 架构示例
+
+> 按项目类型给出现实世界的架构决策示例。
+
+---
+
+## 示例 1：MVP（最小可行产品）电商（单人开发）
+
+```yaml
+需求:
+  - 初期 <1000 用户
+  - 单人开发
+  - 快速上线（8 周）
+  - 预算敏感
+
+架构决策:
+  应用结构: Monolith（单体，更适合单人）
+  框架: Next.js（全栈、开发快）
+  数据层: Prisma 直连（避免过度抽象）
+  认证: JWT（JSON Web Token，比 OAuth（授权协议）更轻量）
+  支付: Stripe（托管支付方案）
+  数据库: PostgreSQL（订单场景需要 ACID）
+
+接受的权衡:
+  - Monolith -> 无法独立扩缩（团队规模暂不支持）
+  - 不使用 Repository（仓储模式） -> 可测性较弱（简单 CRUD 阶段可接受）
+  - JWT -> 初期无社交登录（后续可补）
+
+后续迁移路径:
+  - 用户 > 10K -> 拆分支付服务
+  - 团队 > 3 -> 引入 Repository pattern（仓储模式）
+  - 需要社交登录 -> 增加 OAuth（授权协议）
+```
+
+---
+
+## 示例 2：SaaS（软件即服务）产品（5-10 人团队）
+
+```yaml
+需求:
+  - 1K-100K 用户
+  - 5-10 名开发者
+  - 长期（12 个月以上）
+  - 多业务域（计费、用户、核心）
+
+架构决策:
+  应用结构: Modular Monolith（模块化单体，适合团队规模）
+  框架: NestJS（天然模块化）
+  数据层: Repository pattern（仓储模式，利于测试与替换）
+  领域模型: Partial DDD（部分领域驱动）
+  认证: OAuth（授权协议） + JWT（JSON Web Token）
+  缓存: Redis
+  数据库: PostgreSQL
+
+接受的权衡:
+  - Modular Monolith -> 模块间仍有耦合（微服务时机未到）
+  - Partial DDD -> 不做完整聚合（缺少强领域专家）
+  - RabbitMQ（消息队列）后置 -> 初期先同步调用（需求验证后再引入）
+
+迁移路径:
+  - 团队 > 10 -> 考虑微服务
+  - 域冲突加剧 -> 拆分有界上下文
+  - 读性能问题 -> 引入 CQRS（命令查询职责分离）
+```
+
+---
+
+## 示例 3：企业级（100K+ 用户）
+
+```yaml
+需求:
+  - 100K+ 用户
+  - 10+ 开发者
+  - 多业务域
+  - 不同扩缩需求
+  - 7×24 可用性
+
+架构决策:
+  应用结构: Microservices（微服务，独立扩缩）
+  API 网关: Kong/AWS API GW（网关）
+  领域模型: Full DDD（完整领域驱动）
+  一致性: Event-driven（事件驱动，接受最终一致性）
+  消息总线: Kafka
+  认证: OAuth（授权协议） + SAML（企业 SSO）
+  数据库: Polyglot（按场景选数据库）
+  CQRS（命令查询职责分离）: 选定服务
+
+运行要求:
+  - Service mesh（Istio/Linkerd）
+  - Distributed tracing（分布式追踪，Jaeger/Tempo）
+  - Centralized logging（集中日志，ELK/Loki）
+  - Circuit breakers（熔断器，Resilience4j）
+  - Kubernetes/Helm
+```

package/.agents/skills/architecture/pattern-selection.md

@@ -0,0 +1,68 @@
+# 模式选择指南
+
+> 选择架构模式的决策树。
+
+## 主决策树
+
+```
+开始：你的主要关注点是什么？
+
++- 数据访问复杂度？
+|  +- 高（复杂查询，需要测试）
+|  |  -> Repository Pattern（仓储模式）+ Unit of Work（工作单元）
+|  |  验证：数据源会频繁变化吗？
+|  |     +- 是 -> Repository（仓储模式）值得增加间接层
+|  |     +- 否 -> 考虑更简单的 ORM（对象关系映射）直连访问
+|  +- 低（简单 CRUD（增删改查），单一数据库）
+|     -> ORM（对象关系映射）直连（Prisma, Drizzle）
+|     越简单 = 越好、越快
+|
++- 业务规则复杂度？
+|  +- 高（领域逻辑复杂，规则随上下文变化）
+|  |  -> Domain-Driven Design（领域驱动设计，DDD）
+|  |  验证：团队里有领域专家吗？
+|  |     +- 是 -> Full DDD（聚合、值对象）
+|  |     +- 否 -> Partial DDD（富实体、清晰边界）
+|  +- 低（主要是 CRUD，简单校验）
+|     -> Transaction Script（事务脚本）模式
+|     越简单 = 越好、越快
+|
++- 需要独立扩缩吗？
+|  +- 是（不同组件扩缩方式不同）
+|  |  -> Microservices（微服务）值得承担复杂性
+|  |  要求（必须全部满足）：
+|  |    - 清晰的领域边界
+|  |    - 团队 > 10 名开发者
+|  |    - 各服务有不同的扩缩需求
+|  |  未全部满足 -> Modular Monolith（模块化单体）
+|  +- 否（整体一起扩缩）
+|     -> Modular Monolith（模块化单体）
+|     以后在确有必要时再拆服务
+|
++- 实时性需求？
+   +- 高（即时更新，多用户同步）
+   |  -> Event-Driven Architecture（事件驱动架构）
+   |  -> Message Queue（消息队列）（RabbitMQ, Redis, Kafka）
+   |  验证：你能处理最终一致性（eventual consistency）吗？
+   |     +- 是 -> 事件驱动可行
+   |     +- 否 -> 同步 + 轮询
+   +- 低（可接受最终一致性）
+      -> 同步（REST/GraphQL）
+      越简单 = 越好、越快
+```
+
+## 三个问题（选择任何模式前）
+
+1. **问题是否被解决**：该模式解决的具体问题是什么？
+2. **更简单的替代方案**：是否存在更简单的方案？
+3. **延迟复杂性**：能否在必要时再引入该模式？
+
+## 红旗（反模式）
+
+| 模式 | 反模式 | 更简单的替代方案 |
+| ---- | ------ | ---------------- |
+| Microservices（微服务） | 过早拆分 | 从单体开始，后续再拆 |
+| Clean/Hexagonal（整洁/六边形） | 过度抽象 | 先写具体实现，后引入接口 |
+| Event Sourcing（事件溯源） | 过度设计 | 追加式审计日志 |
+| CQRS（命令查询职责分离） | 不必要的复杂性 | 单一模型 |
+| Repository（仓储模式） | 对简单 CRUD 的 YAGNI（你不会需要它） | ORM 直连 |

package/.agents/skills/architecture/patterns-reference.md

@@ -0,0 +1,50 @@
+# 架构模式参考
+
+> 常用模式快速参考及使用指南。
+
+## 数据访问模式
+
+| 模式 | 适用场景 | 不适用场景 | 复杂度 |
+| ---- | -------- | ---------- | ------ |
+| **Active Record（活动记录）** | 简单 CRUD（增删改查），快速原型开发 | 复杂查询，多数据源 | 低 |
+| **Repository（仓储模式）** | 需要测试，多数据源 | 简单 CRUD（增删改查），单一数据库 | 中 |
+| **Unit of Work（工作单元）** | 复杂事务 | 简单操作 | 高 |
+| **Data Mapper（数据映射）** | 复杂领域、性能要求高 | 简单 CRUD（增删改查），快速开发 | 高 |
+
+## 领域逻辑模式
+
+| 模式 | 适用场景 | 不适用场景 | 复杂度 |
+| ---- | -------- | ---------- | ------ |
+| **Transaction Script（事务脚本）** | 简单 CRUD（增删改查），过程式逻辑 | 复杂业务规则 | 低 |
+| **Table Module（表模块）** | 基于记录的逻辑 | 需要丰富领域行为 | 低 |
+| **Domain Model（领域模型）** | 复杂业务逻辑 | 简单 CRUD（增删改查） | 中 |
+| **DDD（完整领域驱动）** | 复杂领域，有领域专家 | 简单领域，无领域专家 | 高 |
+
+## 分布式系统模式
+
+| 模式 | 适用场景 | 不适用场景 | 复杂度 |
+| ---- | -------- | ---------- | ------ |
+| **Modular Monolith（模块化单体）** | 小团队，边界不清晰 | 上下文清晰、扩缩需求不同 | 中 |
+| **Microservices（微服务）** | 不同扩缩需求、大团队 | 小团队、简单领域 | 极高 |
+| **Event-Driven（事件驱动）** | 实时性、松耦合 | 简单工作流、强一致性 | 高 |
+| **CQRS（命令查询职责分离）** | 读写性能分化明显 | 简单 CRUD（增删改查）、同一模型 | 高 |
+| **Saga（补偿事务）** | 分布式事务 | 单一数据库、简单 ACID（事务特性） | 高 |
+
+## API 模式
+
+| 模式 | 适用场景 | 不适用场景 | 复杂度 |
+| ---- | -------- | ---------- | ------ |
+| **REST（表述性状态转移）** | 标准 CRUD（增删改查），资源导向 | 实时性、复杂查询 | 低 |
+| **GraphQL（图查询语言）** | 灵活查询，多客户端 | 简单 CRUD（增删改查）、强缓存需求 | 中 |
+| **gRPC（远程过程调用）** | 内部服务、高性能 | 公共 API、浏览器客户端 | 中 |
+| **WebSocket（全双工通信）** | 实时更新 | 简单请求/响应 | 中 |
+
+---
+
+## 简单原则
+
+**“从简单开始，只有在证明有必要时才增加复杂性。”**
+
+- 你可以随时在以后添加模式。
+- 移除复杂性远比增加复杂性难得多。
+- 有疑问时，选择更简单的选项。