@chongyan/autospec 1.0.1 → 1.0.2

package/plugins/commands/env-sync.md

@@ -14,57 +14,51 @@ $ARGUMENTS
 
 ## 执行指令
 
-### Step 0: 初始化环境目录（如不存在）
+### Step 0: 初始化目录结构
 
-检查 `.autospec/environment/` 是否已存在：
-- 不存在 → 自动创建目录结构
-- 已存在 → 跳过初始化，直接进入扫描
-
-创建目录结构：
+**【强制】** 创建精简的目录结构，与 `knowledge/09-templates/` 模板一一对应：
 
 ```
 .autospec/environment/
-├── env-knowledge/
-│   ├── middleware/         # 中间件知识（MD格式）
-│   ├── infrastructure/     # 基础设施知识
-│   └── env-variables/      # 环境变量模板
-├── component-lib/
-│   ├── components/         # 组织组件库（MD格式）
-│   ├── best-practices/     # 最佳实践
-│   └── domain-models/      # 领域模型
-├── design-knowledge/       # 设计知识库
-│   ├── product/            # 产品设计
-│   ├── architecture/       # 架构设计（含UML图）
-│   ├── api/                # 接口设计
-│   └── database/           # 数据库设计
-├── test-knowledge/         # 测试知识库
-│   ├── test-designs/       # 测试设计
-│   └── evaluation/         # 评测设计（AI/模型）
-├── business-knowledge/     # 业务知识库
-│   ├── glossary.md         # 术语表
-│   ├── rules.md            # 业务规则
-│   └── flows/              # 业务流程图
-├── standards/              # 规范知识库
-│   ├── coding-style.md
-│   ├── data-consistency.md
-│   └── code-review.md
-├── guides/                 # 指南知识库
-│   ├── system-design.md
-│   ├── requirement-engineering.md
-│   └── stages/             # 各阶段指南
-├── integration/
-│   ├── ci-cd/              # CI/CD配置
-│   ├── testing/            # 测试环境
-│   └── deployment/         # 部署配置
-├── knowledge-source.json   # 知识来源配置
-└── registry.json           # 知识注册表
-```
-
-初始化 `registry.json`（如不存在）：
+├── 01-env-knowledge/              # 环境知识
+│   ├── middleware/                # 中间件知识（含外部服务）→ 10-middleware-knowledge.md
+│   ├── infrastructure/            # 基础设施知识
+│   └── env-variables/             # 环境变量
+│
+├── 02-component-lib/              # 组件库
+│   ├── components/                # 组织组件 → 08-component-knowledge.md
+│   └── best-practices/            # 最佳实践 → 09-best-practices.md
+│
+├── 03-design-knowledge/           # 设计知识
+│   ├── product/                   # 产品设计 → 00-requirement-proposal.md, 04-product-design.md
+│   ├── architecture/              # 架构设计 → 01-architecture-design.md
+│   ├── api/                       # API 设计（含 RPC）→ 02-api-design.md
+│   └── database/                  # 数据库设计 → 03-database-design.md
+│
+├── 04-business-knowledge/         # 业务知识
+│   └── {domain-name}.md           # 领域业务知识（含数据模型）→ 05-domain-business.md
+│
+├── 05-test-knowledge/             # 测试知识
+│   ├── test-designs/              # 测试设计 → 06-test-design.md
+│   └── evaluation/                # 评测设计 → 07-evaluation-design.md
+│
+├── 06-standards/                  # 规范文档
+├── 07-guides/                     # 指南
+├── 08-integration/                # 集成配置
+├── registry.json                  # 知识注册表
+└── knowledge-source.json          # 知识来源配置
+```
+
+**设计原则**：
+- **高内聚低耦合**：相关内容聚合，避免过度拆分
+- **模板对应**：目录与 `knowledge/09-templates/` 一一对应
+- **整合优化**：RPC 服务合并到 api/，数据模型合并到 business-knowledge/
+
+**初始化 registry.json**（如不存在）：
 
 ```json
 {
-  "version": "2.0",
+  "version": "2.1",
   "activeProfiles": {
     "environment": "development",
     "components": []
@@ -76,8 +70,7 @@ $ARGUMENTS
   },
   "componentKnowledge": {
     "components": [],
-    "bestPractices": [],
-    "domainModels": []
+    "bestPractices": []
   },
   "designKnowledge": {
     "product": [],
@@ -85,556 +78,1204 @@ $ARGUMENTS
     "api": [],
     "database": []
   },
+  "businessKnowledge": [],
   "testKnowledge": {
     "testDesigns": [],
     "evaluation": []
   },
-  "businessKnowledge": {
-    "glossary": [],
-    "rules": [],
-    "flows": []
-  },
   "standardsKnowledge": [],
   "guidesKnowledge": [],
-  "integrationKnowledge": {
-    "ci_cd": [],
-    "testing": [],
-    "deployment": []
-  }
+  "integrationKnowledge": []
 }
 ```
 
-### Step 0.5: 加载模板定义
+### Step 0.5: 加载模板和检测规则
 
-**【强制】** 读取模板注册表和模板文件：
+**【强制】** 读取模板文件和检测规则：
 
-1. **读取模板注册表**
-   - 优先读取框架模板：`knowledge/environment/template-registry.md`
-   - 项目级自定义模板（如有）：`.autospec/knowledge/environment/template-registry.md`
+1. **读取检测规则**
+   - `knowledge/06-environment/01-detection-patterns.yaml`
+   - 解析 buildFiles, frameworks, designDocs, businessDocs, testDocs, sourceAnalysis 规则
 
-2. **加载模板文件**
-   - 中间件模板：`knowledge/environment/middleware-knowledge.md`
-   - 组件模板：`knowledge/environment/component-knowledge.md`
-   - 设计/测试/业务模板：`knowledge/templates/*.md`
+2. **读取模板文件**
+   - 中间件模板：`knowledge/09-templates/10-middleware-knowledge.md`
+   - 组件模板：`knowledge/09-templates/08-component-knowledge.md`
+   - 设计模板：`knowledge/09-templates/01-architecture-design.md`, `02-api-design.md`, `03-database-design.md`, `00-requirement-proposal.md`
+   - 测试模板：`knowledge/09-templates/06-test-design.md`, `07-evaluation-design.md`
+   - 业务模板：`knowledge/09-templates/05-domain-business.md`
+   - 最佳实践模板：`knowledge/09-templates/09-best-practices.md`
 
 3. **缓存模板信息**
    - 必填章节列表
    - 类型枚举
    - 输出路径模板
 
-### Step 1: 扫描代码（确定性）
+---
+
+## Step 1: 扫描代码和依赖（多语言支持）
+
+**【强制】** 根据 `detection-patterns.yaml` 执行多语言扫描：
+
+### 1.0 多项目检测（规则 + 模型驱动）
+
+**【强制】** 首先检测工作目录下的所有子项目：
+
+**规则检测**：
+```bash
+# 检测所有构建文件
+find . -maxdepth 3 \( -name "pom.xml" -o -name "package.json" -o -name "go.mod" -o -name "Cargo.toml" -o -name "pyproject.toml" \) -not -path "*/node_modules/*" -not -path "*/target/*"
+```
+
+**模型驱动检测**（使用 `modelDrivenDetection.stages.projectDiscovery`）：
+
+当规则检测完成后，启用模型探索模式：
+
+```
+你是一个项目结构分析专家。请探索当前工作目录，发现所有子项目。
+
+## 探索工具
+
+使用以下工具进行探索：
+- find: 查找构建文件和目录结构
+- grep: 搜索特定内容
+- read: 读取配置文件
+
+## 探索目标
 
-**【强制】** 根据 `knowledge/environment/detection-patterns.yaml` 中的检测规则执行扫描：
+1. 发现非标准目录结构的项目（如 app/, modules/, services/）
+2. 识别多模块项目的父子关系
+3. 发现隐藏的项目配置
+4. 分析项目间的依赖关系
 
-1. **扫描依赖文件**（使用 buildFiles 规则）
-   - package.json / requirements.txt / pom.xml / go.mod 等
-   - 提取依赖列表并匹配框架识别规则
+## 输出
 
-2. **扫描代码模式**（使用 sourceDirectories 规则）
-   - 定位源码目录（backend/frontend/data/ai）
-   - 匹配 import/require/实例化模式
+生成项目列表，包含：name, path, language, framework, type, buildTool, srcDirs, entryPoint
+```
 
-3. **扫描环境变量**
-   - process.env.XXX
-   - os.environ.get('XXX')
-   - System.getenv("XXX")
+**输出**：
+```json
+{
+  "projects": [
+    {
+      "name": "project-a",
+      "path": "project-a",
+      "language": "java",
+      "framework": "Spring Boot",
+      "type": "backend",
+      "buildTool": "maven",
+      "srcDirs": ["src/main/java"],
+      "entryPoint": "src/main/java/.../Application.java"
+    },
+    {
+      "name": "project-b",
+      "path": "project-b",
+      "language": "java",
+      "framework": "Spring Boot",
+      "type": "hybrid",
+      "types": ["backend", "ai-assistant"],
+      "buildTool": "maven",
+      "srcDirs": ["app/*/src/main/java"]
+    }
+  ]
+}
+```
 
-4. **检测 AI/数据组件**（使用 aiComponents 和 dataComponents 规则）
-   - 识别 LLM 应用、RAG、向量存储
-   - 识别数据仓库、ETL 管道
+### 1.1 识别项目语言
+
+扫描构建文件确定项目类型：
+
+| 构建文件 | 语言 | 解析器 |
+|---------|------|--------|
+| package.json | JavaScript/TypeScript | packageJson |
+| pom.xml | Java (Maven) | pomXml |
+| build.gradle | Java/Kotlin (Gradle) | buildGradle |
+| build.gradle.kts | Kotlin (Gradle) | buildGradleKts |
+| go.mod | Go | goMod |
+| Cargo.toml | Rust | cargoToml |
+| pyproject.toml | Python (Poetry/PDM) | pyprojectToml |
+| requirements.txt | Python (pip) | requirements |
+| setup.py | Python (setuptools) | setupPy |
+| dbt_project.yml | SQL (dbt) | dbtProject |
+| pubspec.yaml | Dart/Flutter | pubspec |
+| composer.json | PHP | composer |
+| Gemfile | Ruby | gemfile |
+
+**支持多模块项目路径**：
+- `src/main/java` - 标准路径
+- `app/*/src/main/java` - 多模块路径
+- `*/src/main/java` - 通用多模块路径
+
+### 1.2 提取依赖和框架
+
+**提取依赖列表**：
+- 读取对应的构建文件
+- 解析依赖声明
+
+**匹配框架规则**（使用 frameworks 规则）：
+- JavaScript: react, vue, angular, express, nestjs, next, nuxt 等
+- Python: django, fastapi, flask, torch, tensorflow, langchain, crewai 等
+- Java: spring-boot, spring-cloud, dubbo, quarkus 等
+- Go: gin, echo, fiber, chi 等
+- Rust: actix, rocket, warp, axum 等
+
+**识别 AI/数据组件**（使用 aiComponents 和 dataComponents 规则）：
+- LLM 应用：langchain, llamaindex, openai, anthropic
+- Agent 框架：crewai, autogen, semantic-kernel
+- 向量存储：faiss, chromadb, pinecone, weaviate
+- 模型训练：torch, tensorflow, transformers
+- 数据仓库：dbt
+- ETL 管道：airflow, prefect, dagster
+
+### 1.3 模型驱动中间件检测
+
+**【强制】** 使用 `modelDrivenDetection.stages.middlewareDiscovery` 进行深度检测：
 
-输出扫描结果到 `.autospec/runtime/env-scan-result.json`
+```
+你是一个中间件和框架识别专家。请深入分析项目，发现所有使用的中间件和框架。
 
-### Step 1: 判断同步模式
+## 探索工具
 
-根据用户输入判断同步模式：
+使用以下工具进行探索：
+- grep: 搜索依赖声明、配置项、import 语句
+- read: 读取构建文件和配置文件
 
-**本地扫描模式**（无参数）：
-- 扫描项目代码生成知识
-- 继续执行 Step 2-7
+## 探索步骤
 
-**导入模式**（有参数或 URL）：
+1. 分析依赖：grep 构建文件中的依赖声明
+2. 扫描配置：查找 application*.properties/yml 中的配置项
+3. 扫描代码：grep import 语句识别引入的库
+4. 识别客户端：grep Client/Config/Manager 类
 
-1. **解析输入**
-   - `<url>` - 自动识别类型
-   - `--git <url>` - 明确 Git 仓库
-   - `--online <url>` - 明确在线文档
-   - `--npm <package>` - npm 包
-   - `--local <path>` - 本地目录
+## 识别标准
 
-2. **URL 自动识别规则**
-   | URL 模式 | 类型 | 处理方式 |
-   |---------|------|---------|
-   | `https://github.com/...` | Git | git clone |
-   | `git@github.com:...` | Git | git clone |
-   | Confluence/在线文档平台 等 | 在线文档 | 对应 API |
-   | 其他 | Git | 尝试 git clone |
+- 数据库: DataSource, Connection, Repository, Mapper, DAO
+- 缓存: Cache, Redis, Memcached, CacheManager
+- 消息队列: Producer, Consumer, Queue, Topic, Message
+- RPC: RpcClient, RpcServer, Facade, Stub
+- 存储: OssClient, S3Client, StorageService
+- LLM: LLMClient, ChatService, Embedding, VectorStore
+```
 
-跳转到 Step 1a 执行导入流程。
+**输出**：
+```json
+{
+  "middleware": [
+    {
+      "name": "distributed-db",
+      "type": "database",
+      "detectionSource": "config",
+      "configKeys": ["datasource.name", "datasource.version"],
+      "clientClasses": ["DataSourceConfig"],
+      "version": "1.0.0",
+      "confidence": 0.95
+    }
+  ],
+  "externalServices": [
+    {
+      "name": "llm-service",
+      "type": "llm",
+      "endpoint": "llm.service.url",
+      "clientClass": "LLMClient",
+      "confidence": 0.92
+    }
+  ]
+}
+```
 
-### Step 1a: 执行导入（导入模式）
+### 1.3.1 RPC 服务检测（新增）
 
-根据来源类型执行导入：
+**【强制】** 使用 `rpcServices` 规则检测 RPC 服务：
 
-**Git 来源**：
+**服务提供者检测**：
 ```bash
-git clone --depth 1 {url} /tmp/autospec-import
+# 检测 @RpcProvider 注解
+grep -rn "@RpcProvider\|@DubboService\|@GrpcService" --include="*.java"
+
+# 提取服务实现类
+grep -rn "implements.*Facade\|implements.*Service" --include="*.java"
 ```
 
-**在线文档来源**：
-- 识别文档平台（Confluence、在线文档平台 等）
-- 使用对应 API 读取文档内容
-- 转换为本地知识文件格式
+**Facade 接口检测**：
+```bash
+# 检测 Facade 接口定义
+grep -rn "interface.*Facade\|interface.*Service" --include="*.java"
+
+# 扫描 facade 模块目录
+find . -path "*/app/facade/*" -name "*.java"
+find . -path "*/api/src/main/java/*" -name "*.java"
+```
 
-**npm 来源**：
+**服务引用检测**：
 ```bash
-npm pack {package}
-tar -xzf {package}-*.tgz
+# 检测 RPC 服务引用
+grep -rn "@RpcReference\|@DubboReference\|@FeignClient" --include="*.java"
+```
+
+**输出**：
+```json
+{
+  "rpcServices": [
+    {
+      "interface": "AssistantChatFacade",
+      "implementation": "AssistantChatFacadeImpl",
+      "methods": ["chat", "streamChat"],
+      "sourceFile": "app/facade/src/main/java/.../AssistantChatFacade.java",
+      "references": [
+        {"project": "backend", "file": "ChatController.java"}
+      ]
+    }
+  ]
+}
 ```
 
-**本地来源**：
+### 1.3.2 外部服务客户端检测（新增）
+
+**【强制】** 使用 `externalServiceClients` 规则检测外部服务：
+
+**客户端类检测**：
 ```bash
-cp -r {path}/* .autospec/environment/
+# 检测客户端类
+grep -rn "class.*Client\|class.*FacadeClient\|class.*Adapter\|class.*Gateway" --include="*.java" -l
+
+# 提取客户端方法
+grep -rn "public.*call\|public.*invoke\|public.*request\|public.*query" --include="*Client.java"
 ```
 
-### Step 1b: 验证知识库结构（导入模式）
+**配置项提取**：
+```bash
+# 提取服务端点配置
+grep -rn "\.service-url\|\.endpoint\|\.tr-service-url" --include="*.properties" --include="*.yml"
 
-检查导入的知识库是否包含：
-- `manifest.json` 或 `package.json`
-- `env-knowledge/` 目录
-- `component-lib/` 目录
+# 提取超时和重试配置
+grep -rn "\.timeout\|\.retry\|\.retries" --include="*.properties" --include="*.yml"
+```
 
-### Step 1c: 模板合规检查（导入模式）
+**服务类型分类**：
+- LLM 服务：LLMClient, ChatClient, ModelClient
+- 向量服务：VectorClient, EmbeddingClient
+- 存储服务：OssClient, StorageClient
+- 消息服务：MqClient, MessageClient
+- 认证服务：AuthClient, SecurityClient
 
-加载模板注册表 `knowledge/environment/template-registry.md`，对每个知识文件：
+**输出**：
+```json
+{
+  "externalServiceClients": [
+    {
+      "name": "LLMServiceClient",
+      "type": "llm",
+      "endpoint": "llm.service.url",
+      "methods": ["chat", "embed"],
+      "configKeys": ["llm.service.url", "llm.timeout"],
+      "sourceFile": "app/client/src/main/java/.../LLMServiceClient.java"
+    }
+  ]
+}
+```
 
-**中间件文件** (`env-knowledge/middleware/*.md`)：
-- 校验是否包含必填章节：基本信息、环境变量、连接代码模板
-- 检查基本信息表格是否包含：名称、类型
-- 检查类型是否在预定义枚举中
+### 1.3.3 数据模型检测（新增）
 
-**组件文件** (`component-lib/components/*/component.md`)：
-- 校验是否包含必填章节：基本信息、接口定义、使用示例
-- 检查基本信息表格是否包含：名称、类型、版本
-- 检查类型是否在预定义枚举中
+**【强制】** 使用 `dataModels` 规则检测数据模型：
 
-**设计/测试/业务知识文件**：
-- 校验是否包含对应模板的必填章节
+**DO/Entity 类检测**：
+```bash
+# 检测 DO 类
+grep -rn "class.*DO\|class.*Entity\|class.*PO\|class.*DTO" --include="*.java" -l
 
-生成校验报告：
+# 检测 @Entity @Table 注解
+grep -rn "@Entity\|@Table\|@TableName" --include="*.java" -l
 ```
-🔍 模板合规检查
 
-中间件: 5 文件
-  ✅ mysql.md - 符合模板规范
-  ✅ redis.md - 符合模板规范
-  ⚠️  kafka.md - 缺少「连接代码模板」章节
-  ❌ es.md - 缺少必填章节「基本信息」
+**表映射检测**：
+```bash
+# 提取表名
+grep -rn "@Table(name\|@TableName(" --include="*.java"
 
-组件: 2 文件
-  ✅ auth/component.md - 符合模板规范
-  ❌ payment/component.md - 缺少必填章节「接口定义」
+# 提取字段映射
+grep -rn "@Column\|@Field" --include="*.java"
+```
 
-总计: 7 文件, 4 完全合规, 1 有警告, 2 不合规
+**大数据存储模型检测**：
+```bash
+# 检测大数据存储目录
+find . -path "*/app/dal/**/bigdata/*" -name "*.java"
+find . -path "*/app/dal/**/lindorm/*" -name "*.java"
+find . -path "*/app/dal/**/hbase/*" -name "*.java"
+
+# 检测 TDO 类
+grep -rn "class.*TDO" --include="*.java" -l
 ```
 
-### Step 1d: AI 补全缺失章节（导入模式）
+**输出**：
+```json
+{
+  "dataModels": [
+    {
+      "name": "SessionDO",
+      "type": "DO",
+      "table": "t_session",
+      "fields": [
+        {"name": "id", "type": "Long", "column": "id", "primaryKey": true},
+        {"name": "userId", "type": "String", "column": "user_id"}
+      ],
+      "sourceFile": "app/dal/src/main/java/.../SessionDO.java"
+    }
+  ]
+}
+```
 
-对校验通过但缺少可选章节的知识文件：
+### 1.3.4 消息消费者检测（新增）
 
-1. **分析项目上下文**
-   - 当前项目技术栈
-   - 已有的环境配置
-   - 检测到的依赖包
+**【强制】** 使用 `messageConsumers` 规则检测消息消费者：
 
-2. **AI 补全缺失章节**
-   - 根据模板规范补全缺失的可选章节
-   - 例如：连接代码模板、最佳实践、反模式清单
+**消费者检测**：
+```bash
+# 检测消息消费者注解
+grep -rn "@MessageConsumer\|@KafkaListener\|@RabbitListener\|@RocketMQMessageListener" --include="*.java"
 
-3. **提供补全预览**
-   ```
-   📝 将补全以下章节：
+# 提取 Topic 配置
+grep -rn "topic\s*=\|queues\s*=" --include="*.java"
+```
+
+**生产者检测**：
+```bash
+# 检测生产者类
+grep -rn "class.*Producer\|class.*Publisher" --include="*.java" -l
+```
+
+**输出**：
+```json
+{
+  "messageConsumers": [
+    {
+      "class": "ChatEventConsumer",
+      "topic": "TP_CHAT_EVENT",
+      "method": "onMessage",
+      "sourceFile": "app/consumer/src/main/java/.../ChatEventConsumer.java"
+    }
+  ]
+}
+```
+
+### 1.4 扫描环境变量模式
 
-   kafka.md:
-     + 连接代码模板（Node.js、Python）
-     + 最佳实践
-     + 健康检查
+使用 grep 扫描多语言环境变量：
+
+```bash
+# JavaScript/TypeScript
+grep -r "process\.env\." --include="*.js" --include="*.ts"
 
-   是否执行补全？[Y/n]
-   ```
+# Python
+grep -r "os\.environ" --include="*.py"
+grep -r "getenv(" --include="*.py"
 
-4. **执行补全**
-   用户确认后，AI 补全并保存文件
+# Java
+grep -r "System\.getenv" --include="*.java"
+grep -r "@Value" --include="*.java"
 
-### Step 1e: 分析相关性（导入模式）
+# Go
+grep -r "os\.Getenv" --include="*.go"
 
-1. **识别内容**
-   - 包含的中间件列表
-   - 包含的组件列表
-   - 包含的最佳实践
+# Rust
+grep -r "std::env::" --include="*.rs"
+```
 
-2. **分析相关性**
-   - 与当前项目技术栈的匹配度
-   - 推荐激活的知识项
+### 1.5 输出扫描结果
 
-3. **提供激活建议**
-   ```
-   相关性分析:
-     技术栈匹配度: 85%
-     推荐激活: mysql, redis, auth
-   ```
+生成 `.autospec/runtime/env-scan-result.json`：
 
-跳转到 Step 8 继续执行。
+```json
+{
+  "projects": [
+    {"name": "project-a", "path": "project-a", "language": "java", "framework": "Spring Boot"}
+  ],
+  "language": "java",
+  "buildTool": "maven",
+  "frameworks": ["Spring Boot", "Dubbo"],
+  "middleware": [
+    {"name": "distributed-db", "type": "database", "confidence": 0.95}
+  ],
+  "externalServices": [
+    {"name": "llm-service", "type": "llm", "confidence": 0.92}
+  ],
+  "aiComponents": [],
+  "dataComponents": ["dbt"],
+  "envVariables": ["DB_HOST", "REDIS_ENDPOINT"],
+  "sourceDirectories": {
+    "backend": ["backend/src/main/java"],
+    "data": ["data/warehouse"]
+  },
+  "projectDependencies": [
+    {"from": "project-a", "to": "project-b", "type": "rpc", "services": ["XxxFacade"]}
+  ]
+}
+```
+
+### 1.6 置信度过滤
+
+**【强制】** 对检测结果按置信度分级处理：
+
+| 置信度范围 | 级别 | 处理方式 |
+|-----------|------|---------|
+| ≥ 0.85 | 高 | 直接采用，自动生成知识文件 |
+| 0.65 - 0.85 | 中 | 标记「待确认」，生成文件但添加 review 标记 |
+| 0.45 - 0.65 | 低 | 仅记录到扫描结果，不生成知识文件 |
+| < 0.45 | 忽略 | 不记录 |
+
+**输出格式**：
+
+```json
+{
+  "high": [...],      // 直接采用
+  "medium": [...],    // 待确认
+  "low": [...],       // 仅记录
+  "ignored": [...]    // 忽略
+}
+```
+
+**待确认文件标记**：
+
+在生成的 `.md` 文件头部添加：
+
+```markdown
+> ⚠️ **待确认**: 此文件由模型检测生成（置信度: 0.72），请人工确认后移除此标记。
+```
 
 ---
 
-## 本地扫描模式流程
+## Step 2: 扫描项目文档（设计/测试/业务）
+
+**【强制】** 按优先级扫描三类文档：
+
+### 2.1 扫描设计文档（使用 designDocs 规则）
+
+**产品设计**：
+- 扫描位置：`specs/proposal.md`, `docs/product/`, `product/`, `docs/requirements/`, `knowledge/02-process/`
+- 文件模式：`*proposal*.md`, `*product*.md`, `*requirement*.md`
+- 输出目录：`03-design-knowledge/01-product/`
 
-### Step 2: 扫描设计文档
+**架构设计**：
+- 扫描位置：`specs/design.md`, `docs/architecture/`, `architecture/`, `docs/design/`, `knowledge/03-guides/`
+- 文件模式：`*design*.md`, `*architecture*.md`, `*.uml`, `*.plantuml`, `*.md`
+- 输出目录：`03-design-knowledge/02-architecture/`
 
-**【强制】** 扫描项目中的设计文档：
+**接口设计**：
+- 扫描位置：`docs/api/`, `openapi/`, `api/`, `specs/contracts/`, `app/facade/`, `app/web/`
+- 文件模式：`openapi.yaml`, `openapi.json`, `swagger.yaml`, `swagger.json`, `*api*.md`
+- 输出目录：`03-design-knowledge/03-api/`
 
-1. **扫描产品设计文档**
-   - 扫描 `specs/` 目录下的 `proposal.md`
-   - 扫描 `docs/product/` 目录
-   - 提取业务架构设计、用例业务流程
+**数据库设计**：
+- 扫描位置：`docs/database/`, `db/`, `schema/`, `migrations/`, `app/dal/`, `app/model/`
+- 文件模式：`*schema*.sql`, `*database*.md`, `*.sql`, `*.ddl`, `*.proto`
+- 输出目录：`03-design-knowledge/04-database/`
 
-2. **扫描架构设计文档**
-   - 扫描 `specs/` 目录下的 `design.md`
-   - 扫描 `docs/architecture/` 目录
-   - 提取 UML 图（用例图、时序图、类图、框图、状态图等）
+### 2.2 扫描测试文档（使用 testDocs 规则）
 
-3. **扫描接口设计文档**
-   - 扫描 `docs/api/` 目录
-   - 扫描 `openapi.yaml` / `swagger.json`
-   - 提取接口概述、参数定义、错误码
+**测试设计**：
+- 扫描位置：`specs/testcase.md`, `tests/design/`, `test/`, `specs/`
+- 文件模式：`*testcase*.md`, `*test-design*.md`
+- 输出目录：`05-test-knowledge/01-test-designs/`
 
-4. **扫描数据库设计文档**
-   - 扫描 `docs/database/` 目录
-   - 扫描 `*.sql` 文件中的表结构
-   - 提取 ER 图、表结构、索引设计
+**评测设计**：
+- 扫描位置：`evaluation/`, `eval/`, `benchmarks/`, `tests/evaluation/`
+- 文件模式：`*eval*.md`, `*benchmark*.md`, `*metrics*.md`
+- 输出目录：`05-test-knowledge/02-evaluation/`
 
-### Step 3: 扫描测试文档
+### 2.3 扫描业务知识（使用 domain-business 模板）
 
-**【强制】** 扫描项目中的测试相关文档：
+**领域业务知识**：
+- 扫描位置：`docs/business/`, `knowledge/`, `docs/domain/`, `business/`
+- 文件模式：`*glossary*.md`, `*terminology*.md`, `*rules*.md`, `*policy*.md`, `*flow*.md`, `*process*.md`, `*domain*.md`
+- 输出目录：`04-business-knowledge/{domain-name}.md`
+- 使用模板：`knowledge/09-templates/05-domain-business.md`
 
-1. **扫描测试设计文档**
-   - 扫描 `specs/` 目录下的 `testcase.md`
-   - 扫描 `tests/` 目录下的测试设计
-   - 提取测试概要、测试用例、覆盖矩阵
+**整合内容**：
+- 业务术语表（统一语言）
+- 业务规则
+- 业务流程
+- 领域模型（含数据模型）
+- 实体详情
 
-2. **扫描AI评测文档**
-   - 扫描 `evaluation/` 目录
-   - 扫描 `benchmarks/` 目录
-   - 提取评测目标、数据集、指标定义
+### 2.4 扫描规范指南
 
-### Step 4: 扫描规范指南
+**规范文档**：
+- 扫描位置：`docs/standards/`, `.editorconfig`, `checkstyle.xml`
+- 输出目录：`06-standards/`
 
-**【强制】** 扫描项目中的规范和指南文档：
+**指南文档**：
+- 扫描位置：`docs/guides/`, `knowledge/03-guides/`
+- 输出目录：`07-guides/`
 
-1. **扫描规范文档**
-   - 扫描 `docs/standards/` 目录
-   - 扫描 `.editorconfig` / `.eslintrc` / `checkstyle.xml`
-   - 提取编码规范、数据一致性规范
+### 2.5 模型兜底扫描（Fallback）
 
-2. **扫描指南文档**
-   - 扫描 `docs/guides/` 目录
-   - 扫描 `knowledge/guides/` 目录
-   - 提取系统设计指南、需求工程指南
+**【强制】** 当规则匹配完成后，执行模型兜底扫描，捕获规则之外的潜在文档：
 
-### Step 5: 扫描业务知识
+#### 2.5.1 收集未匹配文件
 
-**【强制】** 扫描项目中的业务知识文档：
+```bash
+# 收集所有未被规则匹配的 Markdown 文件
+find docs/ specs/ knowledge/ business/ tests/ -name "*.md" \
+  ! -path "*/node_modules/*" \
+  ! -path "*/.git/*" \
+  ! -path "*/.autospec/*" \
+  | sort > /tmp/unmatched-files.txt
+```
 
-1. **扫描术语表**
-   - 扫描 `docs/business/glossary.md`
-   - 扫描 `knowledge/domain/glossary.md`
-   - 提取术语定义
+#### 2.5.2 排除已匹配文件
+
+```bash
+# 从全部文件中减去已规则匹配的文件
+comm -23 /tmp/all-md-files.txt /tmp/matched-files.txt > /tmp/candidate-files.txt
+```
 
-2. **扫描业务规则**
-   - 扫描 `docs/business/rules.md`
-   - 扫描 `knowledge/domain/rules.md`
-   - 提取规则ID、规则描述
+#### 2.5.3 AI 模型分类
 
-3. **扫描业务流程**
-   - 扫描 `docs/business/flows/` 目录
-   - 扫描 `knowledge/domain/flows/` 目录
-   - 提取 Mermaid 流程图
+**调用模型**，传入 `detection-patterns.yaml` 中定义的 `fallback.aiPrompt`：
 
-### Step 6: 分析每个检测项（AI）
+```
+输入：候选文件列表 + 文件内容摘要
+处理：使用对应的 aiPrompt 进行分类识别
+输出：JSON 格式的分类结果
+```
 
-对每个检测到的中间件/组件：
+**设计文档兜底**：
+- 使用 `designDocs.fallback.aiPrompt`
+- 识别架构/API/数据库/产品设计文档
+- 输出到对应子目录
 
-1. **阅读相关代码文件**
-   - 找到使用该中间件的代码文件
-   - 理解使用上下文
+**业务文档兜底**：
+- 使用 `businessDocs.fallback.aiPrompt`
+- 识别术语表/业务规则/业务流程文档
+- 输出到对应子目录
 
-2. **提取配置模式**
-   - 连接配置方式
-   - 初始化参数
-   - 错误处理模式
+**测试文档兜底**：
+- 使用 `testDocs.fallback.aiPrompt`
+- 识别测试设计/评测设计文档
+- 输出到对应子目录
 
-3. **识别使用特征**
-   - 连接池配置
-   - 重试机制
-   - 超时设置
-   - 认证方式
+#### 2.5.4 置信度过滤
 
-### Step 7: 生成知识文件（AI）
+```yaml
+# 只保留置信度 >= 0.7 的分类结果
+confidenceThreshold: 0.7
 
-**【强制】** 按模板规范生成 Markdown 格式的知识文件：
+# 置信度 0.5-0.7 的标记为"待确认"
+reviewThreshold: 0.5
 
-加载模板：
-- 中间件模板：`knowledge/environment/middleware-knowledge.md`
-- 组件模板：`knowledge/environment/component-knowledge.md`
+# 置信度 < 0.5 的忽略
+ignoreThreshold: 0.5
+```
 
-**中间件知识格式**：
+#### 2.5.5 生成兜底报告
 
 ```markdown
-# {名称} 中间件知识
+## 模型兜底扫描结果
 
-## 基本信息
+### 设计文档
+- ✅ `docs/random-design.md` → architecture (confidence: 0.92)
+- ✅ `docs/api-intro.md` → api (confidence: 0.85)
+- ⚠️  `docs/overview.md` → product (confidence: 0.68, 待确认)
 
-| 字段 | 值 |
-|------|-----|
-| 名称 | {name} |
-| 类型 | {type} |
-| 默认端口 | {port} |
-| 知识版本 | v1.0 |
+### 业务文档
+- ✅ `docs/terms.md` → glossary (confidence: 0.88)
+- ✅ `docs/rules.md` → rules (confidence: 0.91)
 
-## 环境变量
+### 测试文档
+- ✅ `tests/manual-cases.md` → test-designs (confidence: 0.79)
 
-### 必需变量
+总计：发现 7 个规则外文档，6 个高置信度，1 个待确认
+```
 
-| 变量名 | 说明 | 示例 |
-|--------|------|------|
-| {NAME}_HOST | 主机地址 | db.example.com |
-| {NAME}_PASSWORD | 密码 | - |
+---
 
-### 可选变量
+## Step 3: 分析项目结构（多语言源码分析）
+
+**【强制】** 使用 model+grep 方式分析源码结构：
+
+### 3.1 Java 项目分析
+
+```yaml
+# 使用 sourceAnalysis.java 规则
+buildFiles: [pom.xml, build.gradle]
+srcDirs:
+  - src/main/java
+  - src/main/kotlin
+  - "app/*/src/main/java"      # 多模块项目
+  - "*/src/main/java"          # 通用多模块
+
+# Grep 模式提取架构信息
+grepPatterns:
+  package: "^package\\s+([\\w.]+);"
+  import: "^import\\s+([\\w.]+);"
+  class: "public\\s+class\\s+(\\w+)"
+  interface: "public\\s+interface\\s+(\\w+)"
+  facade: "interface.*Facade"
+
+# 注解识别
+annotations:
+  restController: "@RestController"
+  service: "@Service"
+  repository: "@Repository"
+  entity: "@Entity"
+  controller: "@Controller"
+  rpcProvider: "@RpcProvider"
+  rpcReference: "@RpcReference"
+```
 
-| 变量名 | 默认值 | 说明 |
-|--------|--------|------|
-| {NAME}_PORT | {默认端口} | 端口号 |
+**分析输出**：
+- 包结构列表
+- 核心类列表
+- Controller/Service/Repository 分布
+- RPC 服务分布（@RpcProvider）
+- 实体类列表
+
+### 3.2 Node.js 项目分析
+
+```yaml
+# 使用 sourceAnalysis.nodejs 规则
+buildFiles: [package.json]
+srcDirs: [src/, app/, lib/]
+
+# Grep 模式
+grepPatterns:
+  import: "import.*from|require\\("
+  export: "module.exports|exports\\.|export (default|const|function|class)"
+  route: "@Controller|@Get|@Post|router\\.(get|post|put|delete)"
+```
 
-## 连接代码模板
+**分析输出**：
+- 模块导入/导出列表
+- 路由定义位置
+- Controller 位置
 
-### Node.js
+### 3.3 Python 项目分析
 
-```javascript
-// 连接代码
+```yaml
+# 使用 sourceAnalysis.python 规则
+buildFiles: [requirements.txt, pyproject.toml]
+srcDirs: [src/, app/, backend/]
+
+# Grep 模式
+grepPatterns:
+  import: "^import|^from.*import"
+  class: "^class\\s+(\\w+)"
+  route: "@app\\.route|@router\\.route|@api\\.route"
 ```
 
-### Python
+**分析输出**：
+- 模块依赖关系
+- 类定义列表
+- API 路由位置
+
+### 3.4 Go 项目分析
 
-```python
-# 连接代码
+```yaml
+# 使用 sourceAnalysis.go 规则
+buildFiles: [go.mod]
+srcDirs: [cmd/, internal/, pkg/]
+
+# Grep 模式
+grepPatterns:
+  package: "^package\\s+(\\w+)"
+  func: "^func\\s+(\\w+)"
+  struct: "type\\s+(\\w+)\\s+struct"
 ```
 
-## 最佳实践
+**分析输出**：
+- 包结构
+- 函数列表
+- 结构体定义
+
+### 3.5 Rust 项目分析
 
-1. 实践1
-2. 实践2
+```yaml
+# 使用 sourceAnalysis.rust 规则
+buildFiles: [Cargo.toml]
+srcDirs: [src/]
 
-## 反模式清单
+# Grep 模式
+grepPatterns:
+  module: "^mod\\s+(\\w+)"
+  fn: "^pub\\s+fn\\s+(\\w+)"
+  struct: "^pub\\s+struct\\s+(\\w+)"
+```
 
-| 反模式 | 风险 | 替代方案 |
-|--------|------|----------|
-| 反模式描述 | 风险说明 | 替代方案 |
+**分析输出**：
+- 模块结构
+- 公共函数列表
+- 结构体定义
 
-## 健康检查
+### 3.6 项目间依赖分析
+
+**【强制】** 使用 `modelDrivenDetection.stages.dependencyAnalysis` 分析项目间依赖：
 
-```bash
-# 健康检查命令
 ```
+你是一个依赖关系分析专家。请分析项目间的调用和依赖关系。
+
+## 探索工具
+
+使用以下工具进行探索：
+- grep: 搜索构建依赖、RPC 引用、HTTP 客户端调用
+- read: 读取构建文件和配置
+
+## 探索步骤
+
+1. 构建依赖分析：grep <dependency>, workspaces
+2. RPC 服务引用：grep @RpcReference, XxxFacade
+3. HTTP 客户端调用：grep RestTemplate, HttpClient, fetch, axios
+4. 共享代码分析：find common, shared, core
+
+## 输出
+
+生成依赖关系图，包含：projectDependencies, sharedModules, externalDependencies
 ```
 
-**组件知识格式**：
+**输出文件**：`03-design-knowledge/02-architecture/service-dependency-graph.md`
 
-```markdown
-# {名称} 组件知识
+---
 
-## 基本信息
+## Step 4: 提取架构设计（AI 驱动）
 
-| 字段 | 值 |
-|------|-----|
-| 名称 | {name} |
-| 类型 | {type} |
-| 版本 | {version} |
+**【强制】** 基于 Step 2 扫描结果和 Step 3 源码分析，提取架构信息：
 
-## 功能描述
+### 4.1 识别架构文档
 
-组件功能描述
+- 检查是否已有架构设计文档（`*architecture*.md`, `*design*.md`）
+- 有文档 → 直接复制到 `03-design-knowledge/02-architecture/`
+- 无文档 → 进入 4.2 AI 提取
 
-## 接口定义
+### 4.2 AI 提取架构信息
 
-| 方法名 | 说明 |
-|--------|------|
-| method1 | 方法说明 |
+**输入**：
+- Step 1 的框架识别结果
+- Step 3 的源码分析结果（包结构、类列表、注解位置）
 
-## 使用示例
+**使用模板**：`knowledge/09-templates/01-architecture-design.md`
 
-### Node.js
+**生成内容**：
+1. 架构愿景（从项目 README、package.json description 提取）
+2. 逻辑架构（从包结构、模块依赖推断）
+3. 技术选型（从 frameworks 识别结果）
+4. 质量属性（从配置推断）
 
-**安装**
+**输出文件**：`03-design-knowledge/02-architecture/{project-name}-architecture.md`
 
+---
+
+## Step 5: 提取接口定义（AI 驱动）
+
+**【强制】** 提取接口定义：
+
+### 5.1 识别 OpenAPI/Swagger 文件
+
+- 扫描 `openapi.yaml`, `openapi.json`, `swagger.yaml`, `swagger.json`
+- 找到 → 复制到 `03-design-knowledge/03-api/`
+- 无 → 进入 5.2 代码提取
+
+### 5.2 从代码提取接口
+
+**【强制】** 使用 `modelDrivenDetection.stages.apiDiscovery` 进行深度检测：
+
+**Java (Spring + RPC)**：
 ```bash
-npm install @org/component
+# 提取 HTTP @RestController 和 @Controller
+grep -r "@RestController\|@Controller" --include="*.java"
+# 提取 @RequestMapping 等
+grep -r "@GetMapping\|@PostMapping\|@PutMapping\|@DeleteMapping" --include="*.java"
+
+# 提取 RPC @RpcProvider 服务
+grep -r "@RpcProvider" --include="*.java" -A 5
+# 提取 Facade 接口定义
+grep -r "interface.*Facade" --include="*.java"
+# 提取 RPC 引用
+grep -r "@RpcReference" --include="*.java"
 ```
 
-**使用**
+**Node.js (Express/NestJS)**：
+```bash
+# 提取路由定义
+grep -r "router\.\(get\|post\|put\|delete\)" --include="*.js" --include="*.ts"
+# 提取 NestJS Controller
+grep -r "@Controller\|@Get\|@Post" --include="*.ts"
+```
+
+**Python (FastAPI/Flask)**：
+```bash
+# 提取路由
+grep -r "@app\.route\|@router\.route" --include="*.py"
+# 提取 FastAPI 端点
+grep -r "@app\.get\|@app\.post" --include="*.py"
+```
+
+**模型驱动深度检测**：
 
-```javascript
-// 使用代码
 ```
+你是一个 API 接口分析专家。请发现项目中所有的 HTTP 和 RPC 接口。
 
-## 配置项
+## 探索工具
 
-### 必需配置
+使用以下工具进行探索：
+- grep: 搜索注解和路由定义
+- read: 读取 Controller/Facade 类
 
-| 配置项 | 说明 |
-|--------|------|
-| CONFIG_ENDPOINT | 服务地址 |
+## 探索步骤
 
-## 使用检查清单
+1. HTTP 接口检测：grep @RestController, @GetMapping 等
+2. RPC 接口检测：grep @RpcProvider, interface.*Facade
+3. OpenAPI 检测：find openapi*.yaml, swagger*.yaml
+4. 读取接口定义：读取类文件提取方法签名
 
-### 使用前检查
+## 输出
 
-- [ ] 检查项1
-- [ ] 检查项2
+生成 HTTP 和 RPC 接口列表，包含：controller, basePath, endpoints, methods
 ```
 
-### Step 8: 模板合规校验
+**使用模板**：`knowledge/09-templates/02-api-design.md`
 
-**【强制】** 对生成的每个知识文件，执行模板校验：
+**输出文件**：`03-design-knowledge/03-api/{api-name}.md`
 
-1. **章节完整性检查**
-   - 中间件：基本信息、环境变量、连接代码模板
-   - 组件：基本信息、接口定义、使用示例
+---
 
-2. **表格格式校验**
-   - 表格必须有表头行
-   - 表格列数必须一致
-   - 必填表格不能为空
+## Step 6: 提取数据模型（AI 驱动）
 
-3. **类型枚举校验**
-   - 中间件类型必须在预定义枚举中
-   - 组件类型必须在预定义枚举中
+**【强制】** 提取数据库/数据模型设计：
 
-校验通过后进入 Step 9 注册。
+### 6.1 识别 Schema 文件
 
-### Step 9: 注册激活
+- 扫描 `*.sql`, `*.ddl`, `schema.sql`
+- 扫描 ORM 模型文件（`*model*.py`, `*entity*.java`, `*model*.ts`）
 
-1. 将知识文件写入对应目录：
-   - 中间件：`.autospec/environment/env-knowledge/middleware/{name}.md`
-   - 组件：`.autospec/environment/component-lib/components/{name}/component.md`
-2. 更新 `registry.json`
-3. 标记为自动检测
+### 6.2 提取表结构
+
+**SQL 文件**：
+```bash
+# 提取 CREATE TABLE
+grep -A 20 "CREATE TABLE" --include="*.sql"
+```
+
+**ORM 模型**：
+- Java: `@Entity` 注解的类
+- Python: `class *(db.Model)` 或 `class *(Model)`
+- Node.js: `mongoose.model` 或 `sequelize.model`
+
+### 6.3 AI 生成数据模型文档
+
+**使用模板**：`knowledge/09-templates/03-database-design.md`
+
+**生成内容**：
+1. 概念模型（ER 图）
+2. 逻辑模型（表结构）
+3. 物理模型（索引、分区）
+
+**输出文件**：`03-design-knowledge/04-database/schema-design.md`
 
 ---
 
-## 产出物
+## Step 7: 生成知识文件（按模板）
 
-- `.autospec/environment/` 目录结构（如不存在则创建）
-- `.autospec/runtime/env-scan-result.json` 扫描结果
-- `.autospec/environment/env-knowledge/middleware/*.md` 中间件知识（Markdown格式）
-- `.autospec/environment/component-lib/components/*/component.md` 组件知识（Markdown格式）
-- `.autospec/environment/design-knowledge/` 设计知识（Markdown格式）
-- `.autospec/environment/test-knowledge/` 测试知识（Markdown格式）
-- `.autospec/environment/business-knowledge/` 业务知识（Markdown格式）
-- `.autospec/environment/standards/` 规范文档（Markdown格式）
-- `.autospec/environment/guides/` 指南文档（Markdown格式）
-- 更新的 `registry.json`
-- `knowledge-source.json` 知识来源配置（如需要）
+**【强制】** 使用对应模板生成知识文件：
+
+### 7.1 环境知识
+
+**中间件知识**：
+- 模板：`knowledge/09-templates/10-middleware-knowledge.md`
+- 输出目录：`01-env-knowledge/middleware/`
+- 生成文件：每个检测到的中间件生成一个 `.md` 文件
+
+**基础设施知识**：
+- 输出目录：`01-env-knowledge/infrastructure/`
+
+**环境变量**：
+- 输出目录：`01-env-knowledge/env-variables/`
+
+### 7.2 组件库知识
+
+**组件知识**：
+- 模板：`knowledge/09-templates/08-component-knowledge.md`
+- 输出目录：`02-component-lib/components/`
+- 生成文件：每个组织组件生成 `{component-name}/component.md`
+
+**最佳实践**：
+- 模板：`knowledge/09-templates/09-best-practices.md`
+- 输出目录：`02-component-lib/best-practices/`
+
+### 7.3 设计知识
+
+**产品设计**：
+- 模板：`knowledge/09-templates/00-requirement-proposal.md`, `knowledge/09-templates/04-product-design.md`
+- 输出目录：`03-design-knowledge/product/`
+
+**架构设计**：
+- 模板：`knowledge/09-templates/01-architecture-design.md`
+- 输出目录：`03-design-knowledge/architecture/`
+
+**API 设计（含 RPC）**：
+- 模板：`knowledge/09-templates/02-api-design.md`
+- 输出目录：`03-design-knowledge/api/`
+- 说明：HTTP API 和 RPC 服务统一输出到此目录
+
+**数据库设计**：
+- 模板：`knowledge/09-templates/03-database-design.md`
+- 输出目录：`03-design-knowledge/database/`
+
+### 7.4 业务知识（含数据模型）
+
+**领域业务知识**：
+- 模板：`knowledge/09-templates/05-domain-business.md`
+- 输出目录：`04-business-knowledge/`
+- 生成文件：`{domain-name}.md`
+- 整合内容：业务术语表、业务规则、业务流程、领域模型（含数据模型）、实体详情
+
+### 7.5 测试知识
+
+**测试设计**：
+- 模板：`knowledge/09-templates/06-test-design.md`
+- 输出目录：`05-test-knowledge/test-designs/`
+
+**评测设计**：
+- 模板：`knowledge/09-templates/07-evaluation-design.md`
+- 输出目录：`05-test-knowledge/evaluation/`
 
 ---
 
-## 输出结果
+## Step 8: 模板合规校验
+
+**【强制】** 对生成的每个知识文件执行模板校验：
+
+### 8.1 章节完整性检查
+
+| 知识类型 | 必填章节 |
+|---------|---------|
+| 中间件 | 基本信息、环境变量、连接代码模板、依赖信息、配置项详解、实际使用代码 |
+| 组件 | 基本信息、接口定义、使用示例 |
+| 架构设计 | 架构愿景、逻辑架构、技术选型、服务依赖关系 |
+| API 设计 | 接口概述、端点设计、RPC 接口设计、错误处理 |
+| 数据库设计 | 概念模型、逻辑模型、物理模型、数据模型知识 |
+| 领域业务 | 业务术语表、业务规则、业务流程、领域模型、实体详情 |
+
+### 8.2 表格格式校验
 
-### 本地扫描模式
+- 表格必须有表头行
+- 表格列数必须一致
+- 必填表格不能为空
+
+### 8.3 类型枚举校验
+
+- 中间件类型必须在预定义枚举中
+- 组件类型必须在预定义枚举中
+
+### 8.4 生成校验报告
 
 ```
-✅ 环境知识同步完成
+🔍 模板合规检查
 
-初始化:
-  .autospec/environment/     目录结构
+中间件：5 文件
+  ✅ mysql.md - 符合模板规范
+  ✅ redis.md - 符合模板规范
+  ⚠️  kafka.md - 缺少「连接代码模板」章节
 
-模板加载:
-  template-registry.md
-  middleware-knowledge.md
-  component-knowledge.md
-  api-design.md
-  database-design.md
-  ai-evaluation.md
+设计知识：3 文件
+  ✅ architecture.md - 符合模板规范
+  ✅ api.md - 符合模板规范
+
+总计：8 文件，7 完全合规，1 有警告
+```
+
+---
+
+## Step 9: 注册激活
+
+**【强制】** 将知识注册到 registry.json：
+
+### 9.1 更新注册表
+
+```json
+{
+  "environmentKnowledge": {
+    "middleware": [
+      {"file": "01-env-knowledge/middleware/mysql.md", "auto": true}
+    ]
+  },
+  "designKnowledge": {
+    "architecture": [
+      {"file": "03-design-knowledge/architecture/project-architecture.md", "auto": true}
+    ],
+    "api": [
+      {"file": "03-design-knowledge/api/chat-api.md", "auto": true}
+    ]
+  },
+  "businessKnowledge": [
+    {"file": "04-business-knowledge/chat-domain.md", "auto": true}
+  ]
+}
+```
+
+### 9.2 生成同步报告
+
+```
+✅ 环境知识同步完成
+
+目录结构:
+  ✅ 01-env-knowledge/
+  ✅ 02-component-lib/
+  ✅ 03-design-knowledge/
+  ✅ 04-business-knowledge/
+  ✅ 05-test-knowledge/
+  ✅ 06-standards/
+  ✅ 07-guides/
+  ✅ 08-integration/
 
 扫描结果:
-  依赖: X 项
-  中间件: X 项
-  环境变量: X 项
-  设计文档: X 项
-  测试文档: X 项
-  规范文档: X 项
-  业务知识: X 项
+  语言：Java (Maven)
+  框架：Spring Boot, Dubbo
+  中间件：MySQL, Redis, Kafka
+  设计文档：3 个
+  测试文档：1 个
+  业务知识：2 个
 
 生成知识:
-  环境知识:
-    middleware/mysql.md
-    middleware/redis.md
-    components/auth/component.md
-  设计知识:
-    design-knowledge/product/order-system.md
-    design-knowledge/architecture/order-service.md
-    design-knowledge/api/order-api.md
-    design-knowledge/database/order-db.md
-  测试知识:
-    test-knowledge/test-designs/order-test.md
-    test-knowledge/evaluation/chat-bot-eval.md
-  业务知识:
-    business-knowledge/glossary.md
-    business-knowledge/rules.md
-    business-knowledge/flows/order-flow.md
-  规范指南:
-    standards/coding-style.md
-    guides/system-design.md
+  环境知识：5 文件
+  组件库：2 文件
+  设计知识：4 文件
+  业务知识：2 文件
+  测试知识：2 文件
 
 校验结果:
-  ✅ mysql.md - 符合模板规范
-  ✅ redis.md - 符合模板规范
-  ✅ auth/component.md - 符合模板规范
+  ✅ 15 文件完全合规
+  ⚠️  1 文件有警告
 
 下一步:
   1. 检查生成的知识文件
   2. 执行 /autospec:env-validate 验证配置
   3. 执行 /autospec:env-update --dry-run 预览变更
-  4. 手动调整配置细节
 ```
 
-### 导入模式
+---
+
+## Step 10: 增量同步检测
+
+**【强制】** 检测是否需要增量同步：
+
+### 10.1 检测变更
+
+**依赖变更检测**：
+```bash
+# 检测 pom.xml/package.json 变更
+git diff --name-only HEAD~1 HEAD -- "**/pom.xml" "**/package.json" "**/go.mod" "**/requirements.txt"
+```
+
+**代码变更检测**：
+```bash
+# 检测关键代码变更
+git diff --name-only HEAD~1 HEAD -- "**/*.java" "**/*.py" "**/*.ts" "**/*.go"
+```
+
+**配置变更检测**：
+```bash
+# 检测配置文件变更
+git diff --name-only HEAD~1 HEAD -- "**/application*.properties" "**/application*.yml" "**/*.env"
+```
+
+### 10.2 增量同步策略
+
+| 变更类型 | 同步范围 | 说明 |
+|---------|---------|------|
+| 依赖变更 | 仅更新受影响的中间件知识 | 解析新增/删除的依赖 |
+| 代码变更 | 仅更新受影响的 RPC 服务/数据模型知识 | 重新扫描变更文件 |
+| 配置变更 | 仅更新受影响的配置项 | 提取新的配置项 |
+| 无变更 | 跳过同步 | 输出「无变更」提示 |
 
+### 10.3 增量同步输出
+
+```json
+{
+  "mode": "incremental",
+  "changes": {
+    "dependencies": ["新增: redis-client"],
+    "code": ["修改: ChatController.java"],
+    "config": ["新增: cache.ttl"]
+  },
+  "affectedKnowledge": [
+    "01-env-knowledge/middleware/redis.md"
+  ],
+  "skipped": ["mysql.md", "kafka.md"]
+}
 ```
-✅ 知识库导入完成
 
-来源: https://github.com/org/design-templates
-类型: Git
+### 10.4 强制全量同步
+
+用户可指定 `--full` 参数强制全量同步：
 
-结构验证:
-  ✅ manifest.json 存在
-  ✅ env-knowledge/ 目录存在
-  ✅ component-lib/ 目录存在
+```bash
+/autospec:env-sync --full
+```
+
+---
 
-模板合规检查:
-  中间件: 5 文件, 4 合规
-  组件: 2 文件, 1 合规
+## 产出物
 
-自动补全:
-  kafka.md - 已补全「连接代码模板」「最佳实践」
+- `.autospec/environment/` 精简目录结构
+- `.autospec/runtime/env-scan-result.json` 扫描结果
+- `.autospec/environment/01-env-knowledge/`
+  - `middleware/*.md`           # 中间件知识（含外部服务）
+  - `infrastructure/*.md`       # 基础设施知识
+  - `env-variables/`            # 环境变量
+- `.autospec/environment/02-component-lib/`
+  - `components/*/component.md` # 组件知识
+  - `best-practices/*.md`       # 最佳实践
+- `.autospec/environment/03-design-knowledge/`
+  - `product/*.md`              # 产品设计
+  - `architecture/*.md`         # 架构设计（含服务依赖）
+  - `api/*.md`                  # API 设计（含 RPC）
+  - `database/*.md`             # 数据库设计
+- `.autospec/environment/04-business-knowledge/`
+  - `{domain-name}.md`          # 领域业务知识（含数据模型）
+- `.autospec/environment/05-test-knowledge/`
+  - `test-designs/*.md`         # 测试设计
+  - `evaluation/*.md`           # 评测设计
+- `.autospec/environment/registry.json` 知识注册表
+- `.autospec/environment/knowledge-source.json` 知识来源配置
 
-相关性分析:
-  技术栈匹配度: 85%
-  推荐激活: mysql, redis, auth
+---
+
+## 输出结果
+
+```
+✅ 环境知识同步完成
+
+初始化:
+  .autospec/environment/     精简目录结构
+
+模板加载:
+  检测规则：01-detection-patterns.yaml
+  中间件模板：10-middleware-knowledge.md（含外部服务）
+  组件模板：08-component-knowledge.md
+  最佳实践模板：09-best-practices.md
+  设计模板：01-architecture-design.md（含服务依赖）, 02-api-design.md（含RPC）, 03-database-design.md（含数据模型）
+  业务模板：05-domain-business.md（整合术语/规则/流程/领域模型/数据模型）
+  测试模板：06-test-design.md, 07-evaluation-design.md
+
+扫描结果:
+  语言：{language}
+  框架：{frameworks}
+  中间件：{middleware_count} 项
+  设计文档：{design_docs_count} 项
+  测试文档：{test_docs_count} 项
+  业务知识：{business_docs_count} 项
+
+生成知识:
+  环境知识：{env_files} 文件
+  组件库：{component_files} 文件
+  设计知识：{design_files} 文件
+  业务知识：{business_files} 文件
+  测试知识：{test_files} 文件
+
+校验结果:
+  ✅ {compliant_count} 文件完全合规
+  ⚠️  {warning_count} 文件有警告
 
 下一步:
-  1. 检查导入的知识文件
+  1. 检查生成的知识文件
   2. 执行 /autospec:env-validate 验证配置
   3. 执行 /autospec:env 查看环境状态
 ```