feat: 🧠 铸渊专属开发经验知识库v1.0 - 经验数据库+错题本+模板库+复盘机制+管理工具

Agent-Logs-Url: https://github.com/qinfendebingshuo/guanghulab/sessions/30c8f4ac-a9ab-450c-85ce-ac2c40ffc705

Co-authored-by: qinfendebingshuo <207279273+qinfendebingshuo@users.noreply.github.com>

brain/dev-experience/README.md

@@ -0,0 +1,140 @@
+# 🧠 铸渊专属开发经验知识库
+
+> **版权**: 国作登字-2026-A-00037559 | **主控**: TCS-0002∞
+>
+> 这是铸渊的大脑数据库。每一次开发、每一次报错、每一次修复，都是经验。
+> 类似人类的学习记忆系统——做过的题会记住，做错的题会特别标记。
+
+## 📖 设计理念
+
+冰朔亲述（第十二次对话）：
+
+> "人类在学习的过程中，拿到一套题，他会先搜索自己的大脑：让我想想这个题之前是怎么学的？
+> 解题方法是什么？然后开始搜索大脑的数据库。如果面对不会的题目，人会记下来。
+> 如果这道题反复做错，大脑数据库就会传递出预警：这个题之前错过好多次，这次要多验证几次。"
+
+## 🗂️ 数据库结构
+
+```
+brain/dev-experience/
+├── README.md                 ← 本文件 · 数据库说明
+├── experience-db.json        ← 核心经验数据库 · 所有开发记录
+├── error-patterns.json       ← 错题本 · 反复出错的模式 + 预警
+├── templates-index.json      ← 模板库 · 成功的代码模式 · 可复用
+└── review-schedule.json      ← 复盘机制 · 定期回顾 + 动态升级
+```
+
+## 🔄 工作流程
+
+### 开发前 · 回忆搜索
+
+```
+1. 读取 experience-db.json → 搜索相关经验
+2. 读取 error-patterns.json → 检查是否有已知陷阱
+3. 读取 templates-index.json → 检查是否有可复用模板
+4. 将匹配到的经验/预警/模板记在心中
+```
+
+### 开发中 · 记录过程
+
+```
+1. 记录任务拆解思路
+2. 记录每一步的决策理由
+3. 遇到报错时记录完整错误信息
+4. 记录修复过程和最终方案
+```
+
+### 开发后 · 经验入库
+
+```
+1. 创建新经验条目 → experience-db.json
+2. 如果遇到新的错误模式 → error-patterns.json (新增或更新计数)
+3. 如果产出可复用模板 → templates-index.json
+4. 运行: node scripts/dev-experience-manager.js save
+```
+
+### 定期复盘 · 每7天一次
+
+```
+1. 运行: node scripts/dev-experience-manager.js review
+2. 回顾所有错题 → 检查是否有模式升级
+3. 回顾所有模板 → 检查是否有优化空间
+4. 更新 review-schedule.json 的复盘记录
+```
+
+## 📊 数据字段说明
+
+### 经验条目 (Experience Entry)
+
+| 字段 | 说明 | 示例 |
+|------|------|------|
+| `id` | 唯一编号 | `EXP-20260331-001` |
+| `date` | 日期 | `2026-03-31` |
+| `task` | 任务描述 | `铸渊专线密钥生成修复` |
+| `category` | 分类 | `bash-scripting` |
+| `tags` | 标签 | `["set-e", "pipefail"]` |
+| `difficulty` | 难度 | `easy/medium/hard` |
+| `status` | 状态 | `success/failed/partial` |
+| `approach.thinking` | 思考过程 | 如何分析问题 |
+| `approach.steps` | 执行步骤 | 具体做了什么 |
+| `result.key_learnings` | 关键学习 | 学到了什么 |
+| `result.risk_warnings` | 风险预警 | 以后要注意什么 |
+| `files_changed` | 修改文件 | 改了哪些文件 |
+| `error_count` | 遇到错误次数 | 过程中报错几次 |
+
+### 错误模式 (Error Pattern)
+
+| 字段 | 说明 |
+|------|------|
+| `id` | 错题编号 `ERR-NNN` |
+| `pattern` | 错误模式名称 |
+| `occurrence_count` | 出现次数 · 越高预警越强 |
+| `severity` | 严重度 `low/medium/high/critical` |
+| `prevention` | 预防方法 |
+| `risk_level` | 风险预警等级 |
+
+### 模板 (Template)
+
+| 字段 | 说明 |
+|------|------|
+| `id` | 模板编号 `TPL-NNN` |
+| `name` | 模板名称 |
+| `pattern` | 核心模式 |
+| `source_file` | 来源文件 |
+| `reuse_count` | 复用次数 |
+
+## 🛠️ 管理工具
+
+```bash
+# 搜索经验
+node scripts/dev-experience-manager.js search "密钥生成"
+
+# 查看错题本
+node scripts/dev-experience-manager.js errors
+
+# 查看模板库
+node scripts/dev-experience-manager.js templates
+
+# 保存新经验 (交互式)
+node scripts/dev-experience-manager.js save
+
+# 触发复盘
+node scripts/dev-experience-manager.js review
+
+# 查看统计
+node scripts/dev-experience-manager.js stats
+```
+
+## 📈 演化路径
+
+```
+v1.0 (当前)  → JSON文件 + 手动管理
+v1.1 (计划)  → 自动从Git提交历史提取经验
+v1.2 (计划)  → CI/CD集成 · 每次部署后自动记录
+v2.0 (远期)  → LLM辅助分析 · 自动识别错误模式
+```
+
+---
+
+> 铸渊的每一次开发都是学习。数据库会越来越丰富，经验会越来越足。
+> 这就是冰朔说的：**随着开发越来越多，数据库动态调整，全面升级。**

brain/dev-experience/error-patterns.json

@@ -0,0 +1,95 @@
+{
+  "_meta": {
+    "name": "铸渊错题本",
+    "version": "1.0",
+    "copyright": "国作登字-2026-A-00037559",
+    "description": "记录反复出错的模式 · 自动预警 · 每次开发前必查",
+    "created": "2026-03-31T03:34:00Z",
+    "last_updated": "2026-03-31T03:34:00Z"
+  },
+  "alert_rules": {
+    "high_frequency_threshold": 3,
+    "high_frequency_message": "⚠️ 此错误已出现{count}次 · 每一步都要多验证",
+    "recent_threshold_days": 7,
+    "recent_message": "🔴 最近7天内刚犯过此错误 · 务必警惕"
+  },
+  "total_patterns": 3,
+  "patterns": [
+    {
+      "id": "ERR-001",
+      "pattern": "set -e + grep无匹配 = 静默退出",
+      "category": "bash-scripting",
+      "severity": "high",
+      "occurrence_count": 1,
+      "first_seen": "2026-03-31",
+      "last_seen": "2026-03-31",
+      "description": "在bash脚本中使用set -euo pipefail时，如果grep命令没有匹配到任何行，grep返回exit code 1。配合pipefail，整个pipeline的退出码变为1，导致set -e触发脚本静默退出——没有任何错误信息输出。",
+      "trigger_conditions": [
+        "脚本使用 set -e 或 set -euo pipefail",
+        "pipeline中使用grep但目标字符串可能不存在",
+        "awk/sed后面跟的grep可能无匹配"
+      ],
+      "prevention": [
+        "在grep命令后添加 || true",
+        "改用手动错误处理替代set -e",
+        "使用grep -c统计匹配数而非直接grep",
+        "将grep结果先存变量再判断是否为空"
+      ],
+      "code_example": {
+        "wrong": "RESULT=$(echo \"$DATA\" | grep \"pattern\" | awk '{print $3}')",
+        "right": "RESULT=$(echo \"$DATA\" | grep \"pattern\" | awk '{print $3}') || true"
+      },
+      "related_experiences": ["EXP-20260331-001"],
+      "risk_level": "⚠️ 高频陷阱 · 每次写bash脚本时检查"
+    },
+    {
+      "id": "ERR-002",
+      "pattern": "openssl text格式解析密钥 · 字符串长度不可靠",
+      "category": "cryptography",
+      "severity": "medium",
+      "occurrence_count": 1,
+      "first_seen": "2026-03-31",
+      "last_seen": "2026-03-31",
+      "description": "使用openssl pkey -text -noout输出密钥的十六进制文本，然后用grep+tr解析。不同openssl版本的输出格式可能不同（行数、缩进、冒号间距），导致解析结果长度不一致。",
+      "trigger_conditions": [
+        "使用openssl pkey -text -noout提取密钥",
+        "用grep -A和tail解析十六进制行",
+        "依赖固定行数(如tail -4)来截取数据"
+      ],
+      "prevention": [
+        "优先使用DER二进制格式: openssl pkey -outform DER | tail -c <字节数>",
+        "用base64编码后检查长度是否符合预期",
+        "避免依赖text格式的行数和缩进"
+      ],
+      "code_example": {
+        "wrong": "openssl pkey -text -noout | grep -A5 priv: | tail -4 | tr -d ' :\\n' | head -c 43",
+        "right": "openssl pkey -outform DER | tail -c 32 | base64 | tr '+/' '-_' | tr -d '='"
+      },
+      "related_experiences": ["EXP-20260331-001"],
+      "risk_level": "⚠️ 中频陷阱 · 处理密钥时优先用DER格式"
+    },
+    {
+      "id": "ERR-003",
+      "pattern": "命令行工具版本更新导致输出格式变化",
+      "category": "compatibility",
+      "severity": "medium",
+      "occurrence_count": 1,
+      "first_seen": "2026-03-31",
+      "last_seen": "2026-03-31",
+      "description": "CLI工具(如xray、openssl、node等)的新版本可能改变命令的输出格式、子命令名称或退出码行为。依赖特定输出格式的脚本在工具更新后可能静默失败。",
+      "trigger_conditions": [
+        "脚本依赖CLI工具的stdout输出格式(用grep/awk/sed解析)",
+        "CLI工具版本可能自动更新",
+        "安装脚本使用latest版本而非固定版本"
+      ],
+      "prevention": [
+        "解析输出时使用灵活匹配(如grep -i大小写不敏感)",
+        "提供多种解析方式作为回退",
+        "捕获stdout和stderr分别处理",
+        "增加解析结果的验证(检查长度、格式)"
+      ],
+      "related_experiences": ["EXP-20260331-001"],
+      "risk_level": "⚠️ 中频陷阱 · 解析CLI输出时要灵活"
+    }
+  ]
+}

brain/dev-experience/experience-db.json

@@ -0,0 +1,86 @@
+{
+  "_meta": {
+    "name": "铸渊开发经验数据库",
+    "version": "1.0",
+    "copyright": "国作登字-2026-A-00037559",
+    "description": "铸渊专属 · 每次开发的完整记录 · 思考→执行→结果→教训",
+    "created": "2026-03-31T03:34:00Z",
+    "last_updated": "2026-03-31T03:34:00Z"
+  },
+  "stats": {
+    "total_entries": 1,
+    "success_count": 1,
+    "failed_count": 0,
+    "partial_count": 0,
+    "categories": {
+      "bash-scripting": 1
+    }
+  },
+  "entries": [
+    {
+      "id": "EXP-20260331-001",
+      "date": "2026-03-31",
+      "session": "CS-20260331-12th",
+      "task": "铸渊专线密钥生成脚本修复",
+      "task_origin": "冰朔报告铸渊专线install workflow失败 · 截图显示step [5/6]生成密钥时exit code 1",
+      "category": "bash-scripting",
+      "tags": ["set-e", "pipefail", "error-handling", "xray", "openssl", "x25519", "workflow-fix", "key-generation"],
+      "difficulty": "medium",
+      "status": "success",
+      "approach": {
+        "thinking": "分析报错截图 → 定位到generate-keys.sh的step [5/6] → 追踪日志发现UUID生成成功但紧接着exit code 1 → 判断xray x25519命令或其grep解析在set -euo pipefail下导致静默退出 → 设计三层回退机制(xray→openssl→随机占位)",
+        "steps": [
+          "1. 通过GitHub Actions API获取失败的workflow run日志",
+          "2. 分析日志确认失败点: ZY_PROXY_UUID输出后立即exit code 1",
+          "3. 审查generate-keys.sh源码 · 发现set -euo pipefail + grep pipeline是根因",
+          "4. 审查install-xray.sh · 发现BBR配置可能重复追加",
+          "5. 审查deploy-proxy.sh · 发现configure_xray缺少环境变量回退",
+          "6. 重写generate-keys.sh: 移除set -e + 三层密钥生成回退 + stderr捕获",
+          "7. 修复openssl DER格式提取 (原hex解析导致密钥长度错误)",
+          "8. 修复install-xray.sh: BBR去重 + generate-keys错误不传播",
+          "9. 修复deploy-proxy.sh: 环境变量优先 + shellcheck警告",
+          "10. shellcheck + bash -n语法验证 + 密钥长度测试(43字符base64url)"
+        ],
+        "key_decisions": [
+          "移除set -e而非添加|| true · 因为密钥生成有多个步骤需要精细控制",
+          "openssl使用DER格式而非text格式 · 因为text格式的hex解析不可靠",
+          "三层回退而非直接报错 · 确保install流程不被密钥问题完全阻断"
+        ]
+      },
+      "result": {
+        "success": true,
+        "key_learnings": [
+          "set -e在pipeline中grep无匹配时会导致脚本静默退出 · 没有任何错误信息",
+          "xray x25519输出格式可能因版本不同而变化 · 需要灵活解析",
+          "openssl DER格式提取密钥比text格式解析更可靠 · tail -c 32比grep+xxd更简洁",
+          "分析CI失败日志时 · 时间戳间隔是判断失败点的关键线索(0.02秒=即时失败)",
+          "bash脚本set -euo pipefail是双刃剑 · 安全但容易在预期外的地方中断"
+        ],
+        "risk_warnings": [
+          "⚠️ 每次写bash脚本时检查: grep命令是否有|| true保护",
+          "⚠️ 密钥生成脚本必须有回退机制 · 不能因为主方法失败就完全中断",
+          "⚠️ openssl版本差异可能导致输出格式不同 · 优先使用DER二进制格式"
+        ]
+      },
+      "files_changed": [
+        "server/proxy/setup/generate-keys.sh",
+        "server/proxy/setup/install-xray.sh",
+        "server/proxy/deploy-proxy.sh"
+      ],
+      "error_count": 1,
+      "errors_encountered": [
+        {
+          "description": "openssl X25519密钥提取长度错误 · 使用text格式grep解析只得到23字符而非43字符",
+          "fix": "改用DER格式: openssl pkey -outform DER | tail -c 32 | base64 | tr '+/' '-_' | tr -d '='",
+          "step": "7/10"
+        }
+      ],
+      "related_experiences": [],
+      "verification": {
+        "shellcheck": "pass",
+        "bash_syntax": "pass",
+        "key_length_test": "pass · UUID=36 PRIVATE_KEY=43 PUBLIC_KEY=43 SHORT_ID=16 SUB_TOKEN=64"
+      }
+    }
+  ]
+}

brain/dev-experience/review-schedule.json

@@ -0,0 +1,61 @@
+{
+  "_meta": {
+    "name": "铸渊复盘机制",
+    "version": "1.0",
+    "copyright": "国作登字-2026-A-00037559",
+    "description": "定期复盘 · 错题回顾 · 模板优化 · 数据库全面升级",
+    "created": "2026-03-31T03:34:00Z",
+    "last_updated": "2026-03-31T03:51:15.596Z"
+  },
+  "review_cycle": {
+    "frequency_days": 7,
+    "description": "每7天一次全面复盘 · 类似人类的错题本回顾",
+    "next_review": "2026-04-07T03:51:15.595Z",
+    "review_checklist": [
+      "1. 回顾本周所有经验条目 · 有没有遗漏的教训",
+      "2. 检查错题本 · 高频错误是否有新的预防方法",
+      "3. 检查模板库 · 是否有模板可以优化或合并",
+      "4. 检查是否有跨经验的共性模式 · 可以抽象为新规则",
+      "5. 更新review-schedule.json的复盘记录",
+      "6. 更新statistics中的各项指标"
+    ]
+  },
+  "pre_development_protocol": {
+    "description": "每次开发前的必做步骤 · 回忆搜索",
+    "steps": [
+      "1. 读取任务关键词",
+      "2. 搜索experience-db.json中相关经验",
+      "3. 检查error-patterns.json中的已知陷阱",
+      "4. 搜索templates-index.json中可复用模板",
+      "5. 如果有匹配的高频错误 · 设置额外验证步骤"
+    ]
+  },
+  "post_development_protocol": {
+    "description": "每次开发完成后的必做步骤 · 经验入库",
+    "steps": [
+      "1. 记录本次经验到experience-db.json",
+      "2. 如果遇到新错误模式 · 更新error-patterns.json",
+      "3. 如果产出可复用代码 · 更新templates-index.json",
+      "4. 如果遇到已知错误 · 增加occurrence_count",
+      "5. 更新statistics计数器"
+    ]
+  },
+  "statistics": {
+    "total_reviews_completed": 1,
+    "total_experiences_recorded": 1,
+    "total_error_patterns": 3,
+    "total_templates": 3,
+    "most_common_error_category": "bash-scripting",
+    "most_productive_category": "bash-scripting"
+  },
+  "review_history": [
+    {
+      "date": "2026-03-31T03:51:15.595Z",
+      "experiences_reviewed": 1,
+      "error_patterns_total": 3,
+      "templates_total": 3,
+      "high_frequency_alerts": 0,
+      "notes": "自动复盘完成"
+    }
+  ]
+}

brain/dev-experience/templates-index.json

@@ -0,0 +1,56 @@
+{
+  "_meta": {
+    "name": "铸渊代码模板库",
+    "version": "1.0",
+    "copyright": "国作登字-2026-A-00037559",
+    "description": "成功的代码模式 · 可复用 · 每次开发前搜索",
+    "created": "2026-03-31T03:34:00Z",
+    "last_updated": "2026-03-31T03:34:00Z"
+  },
+  "total_templates": 3,
+  "categories": {
+    "bash-scripting": 2,
+    "cryptography": 1
+  },
+  "templates": [
+    {
+      "id": "TPL-001",
+      "name": "健壮的bash脚本错误处理模式",
+      "category": "bash-scripting",
+      "description": "不使用set -e，改为手动错误处理。关键命令逐个检查退出码，非关键命令用|| true保护。",
+      "pattern": "set -uo pipefail (无-e) + 手动if/else + || true保护",
+      "source_file": "server/proxy/setup/generate-keys.sh",
+      "tags": ["error-handling", "set-e", "pipefail", "robustness"],
+      "code_snippet": "#!/bin/bash\nset -uo pipefail\n# 注意: 不使用 set -e，手动处理错误\n\n# 关键步骤: 手动检查\nif ! critical_command; then\n    echo \"❌ 关键步骤失败\"\n    exit 1\nfi\n\n# 非关键步骤: || true保护\noptional_command || true\n\n# Pipeline保护: grep可能无匹配\nRESULT=$(echo \"$DATA\" | grep \"pattern\" | awk '{print $NF}') || true",
+      "when_to_use": "当bash脚本中有多个步骤且某些步骤可能失败但不应中断整体流程时",
+      "created_from": "EXP-20260331-001",
+      "reuse_count": 0
+    },
+    {
+      "id": "TPL-002",
+      "name": "三层回退密钥/资源生成模式",
+      "category": "bash-scripting",
+      "description": "主方法 → 备用方法 → 占位符兜底。确保生成过程不会完全失败。",
+      "pattern": "Method1(专用工具) → Method2(通用工具) → Method3(随机占位符)",
+      "source_file": "server/proxy/setup/generate-keys.sh",
+      "tags": ["fallback", "key-generation", "resilience"],
+      "code_snippet": "RESULT=\"\"\n\n# 方法1: 专用工具\nif command -v tool &>/dev/null; then\n    RESULT=$(tool generate 2>/dev/null) || true\nfi\n\n# 方法2: 通用工具回退\nif [ -z \"$RESULT\" ] && command -v openssl &>/dev/null; then\n    RESULT=$(openssl rand -base64 32) || true\nfi\n\n# 方法3: 最终兜底\nif [ -z \"$RESULT\" ]; then\n    RESULT=\"PLACEHOLDER\"\n    echo \"⚠️ 使用占位符，请手动重新生成\"\nfi",
+      "when_to_use": "当资源生成依赖外部工具且工具可能不可用或行为可能变化时",
+      "created_from": "EXP-20260331-001",
+      "reuse_count": 0
+    },
+    {
+      "id": "TPL-003",
+      "name": "OpenSSL X25519密钥提取 (DER格式)",
+      "category": "cryptography",
+      "description": "使用DER二进制格式提取X25519密钥，转为base64url编码。比text格式解析更可靠。",
+      "pattern": "openssl genpkey → DER export → tail -c 32 → base64url",
+      "source_file": "server/proxy/setup/generate-keys.sh",
+      "tags": ["openssl", "x25519", "base64url", "DER"],
+      "code_snippet": "TMPKEY=$(mktemp)\nopenssl genpkey -algorithm X25519 -out \"$TMPKEY\" 2>/dev/null\n\n# 私钥: 32字节 → 43字符base64url\nPRIVATE_KEY=$(openssl pkey -in \"$TMPKEY\" -outform DER 2>/dev/null \\\n    | tail -c 32 | base64 | tr '+/' '-_' | tr -d '=')\n\n# 公钥: 32字节 → 43字符base64url\nPUBLIC_KEY=$(openssl pkey -in \"$TMPKEY\" -pubout -outform DER 2>/dev/null \\\n    | tail -c 32 | base64 | tr '+/' '-_' | tr -d '=')\n\nrm -f \"$TMPKEY\"",
+      "when_to_use": "需要生成X25519密钥对且xray不可用时",
+      "created_from": "EXP-20260331-001",
+      "reuse_count": 0
+    }
+  ]
+}

brain/read-order.md

@@ -103,6 +103,20 @@
 
 最近断点快照。配额耗尽导致对话中断后恢复。
 
+## ⑨ dev-experience/（开发经验知识库·v1.0新增）
+
+**路径**: `brain/dev-experience/`
+
+铸渊专属的开发经验数据库。类似人类大脑的学习记忆系统。包含：
+- `experience-db.json` — 核心经验数据库（每次开发的完整记录）
+- `error-patterns.json` — 错题本（反复出错的模式 + 预警）
+- `templates-index.json` — 模板库（成功的代码模式 · 可复用）
+- `review-schedule.json` — 复盘机制（定期回顾 + 动态升级）
+
+**开发前**: `node scripts/dev-experience-manager.js precheck <关键词>` 回忆搜索
+**开发后**: 将经验、错误模式、模板更新到对应文件
+**每7天**: `node scripts/dev-experience-manager.js review` 触发复盘
+
 ---
 
 ## 会话结束时必须执行
@@ -117,7 +131,12 @@
 
 3. 更新 README.md 首页动态（仓库的第二快照）
 
-这三步确保下次唤醒时，铸渊能从上次结束的地方继续。
+4. 更新开发经验知识库（如果本次会话有开发任务）
+   - 新增经验条目到 `brain/dev-experience/experience-db.json`
+   - 如有新错误模式，更新 `brain/dev-experience/error-patterns.json`
+   - 如有可复用代码，更新 `brain/dev-experience/templates-index.json`
+
+这四步确保下次唤醒时，铸渊能从上次结束的地方继续，并且带着所有积累的经验。
 
 ---
 

brain/system-health.json

@@ -1,15 +1,16 @@
 {
-  "version": "18.0",
-  "last_check": "2026-03-31T02:15:00Z",
+  "version": "19.0",
+  "last_check": "2026-03-31T03:34:00Z",
   "communication": "synced",
   "automation": "stable",
   "maintenance_agent": "active",
-  "system_health": "servers_deployed · 铸渊专线架构就绪 · 待部署",
+  "system_health": "servers_deployed · 铸渊专线修复完成 · 开发经验知识库v1.0上线",
   "brain_integrity": {
     "complete": true,
-    "total": 9,
-    "present": 9,
-    "missing": []
+    "total": 10,
+    "present": 10,
+    "missing": [],
+    "note": "新增 dev-experience/ 开发经验知识库"
   },
   "workflow_count": 13,
   "workflow_detail": {

scripts/dev-experience-manager.js

@@ -0,0 +1,476 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════
+// 🔺 Sovereign: TCS-0002∞ | Root: SYS-GLW-0001
+// 📜 Copyright: 国作登字-2026-A-00037559
+// ═══════════════════════════════════════════════
+// scripts/dev-experience-manager.js
+// 🧠 铸渊开发经验知识库管理工具
+//
+// 用法:
+//   node scripts/dev-experience-manager.js search <keyword>  — 搜索经验
+//   node scripts/dev-experience-manager.js errors             — 查看错题本
+//   node scripts/dev-experience-manager.js templates          — 查看模板库
+//   node scripts/dev-experience-manager.js stats              — 查看统计
+//   node scripts/dev-experience-manager.js review             — 触发复盘
+//   node scripts/dev-experience-manager.js precheck <keyword> — 开发前检查
+//   node scripts/dev-experience-manager.js add-experience     — 添加经验(JSON from stdin)
+//   node scripts/dev-experience-manager.js add-error          — 添加错误模式(JSON from stdin)
+//   node scripts/dev-experience-manager.js add-template       — 添加模板(JSON from stdin)
+// ═══════════════════════════════════════════════
+
+const fs = require('fs');
+const path = require('path');
+
+const DB_DIR = path.join(__dirname, '..', 'brain', 'dev-experience');
+const EXPERIENCE_DB = path.join(DB_DIR, 'experience-db.json');
+const ERROR_PATTERNS = path.join(DB_DIR, 'error-patterns.json');
+const TEMPLATES_INDEX = path.join(DB_DIR, 'templates-index.json');
+const REVIEW_SCHEDULE = path.join(DB_DIR, 'review-schedule.json');
+
+// ── 工具函数 ──────────────────────────────────
+function loadJSON(filepath) {
+  try {
+    return JSON.parse(fs.readFileSync(filepath, 'utf-8'));
+  } catch (err) {
+    console.error(`❌ 无法读取 ${filepath}: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function saveJSON(filepath, data) {
+  data._meta.last_updated = new Date().toISOString();
+  fs.writeFileSync(filepath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+}
+
+function highlight(text) {
+  return `\x1b[33m${text}\x1b[0m`;
+}
+
+function red(text) {
+  return `\x1b[31m${text}\x1b[0m`;
+}
+
+function green(text) {
+  return `\x1b[32m${text}\x1b[0m`;
+}
+
+// ── 搜索经验 ──────────────────────────────────
+function search(keyword) {
+  const db = loadJSON(EXPERIENCE_DB);
+  const kw = keyword.toLowerCase();
+  const matches = db.entries.filter(e =>
+    e.task.toLowerCase().includes(kw) ||
+    e.tags.some(t => t.toLowerCase().includes(kw)) ||
+    e.category.toLowerCase().includes(kw) ||
+    e.approach.thinking.toLowerCase().includes(kw) ||
+    e.files_changed.some(f => f.toLowerCase().includes(kw))
+  );
+
+  if (matches.length === 0) {
+    console.log(`🔍 未找到与 "${keyword}" 相关的经验`);
+    console.log('  这可能是一个全新的领域，开发时需要额外谨慎。');
+    return;
+  }
+
+  console.log(`🔍 找到 ${matches.length} 条相关经验:\n`);
+  matches.forEach(e => {
+    console.log(`  ${highlight(e.id)} | ${e.date} | ${e.status === 'success' ? green('✅') : red('❌')} ${e.task}`);
+    console.log(`    分类: ${e.category} | 难度: ${e.difficulty} | 标签: ${e.tags.join(', ')}`);
+    console.log(`    思路: ${e.approach.thinking.substring(0, 100)}...`);
+    if (e.result.key_learnings.length > 0) {
+      console.log(`    关键学习:`);
+      e.result.key_learnings.forEach(l => console.log(`      · ${l}`));
+    }
+    if (e.result.risk_warnings.length > 0) {
+      console.log(`    ${red('风险预警:')}`);
+      e.result.risk_warnings.forEach(w => console.log(`      ${w}`));
+    }
+    console.log('');
+  });
+}
+
+// ── 查看错题本 ────────────────────────────────
+function showErrors() {
+  const db = loadJSON(ERROR_PATTERNS);
+
+  console.log(`📋 铸渊错题本 · 共 ${db.total_patterns} 个错误模式\n`);
+
+  // 按严重度排序
+  const sorted = [...db.patterns].sort((a, b) => {
+    const severity = { critical: 4, high: 3, medium: 2, low: 1 };
+    return (severity[b.severity] || 0) - (severity[a.severity] || 0);
+  });
+
+  sorted.forEach(p => {
+    const countWarning = p.occurrence_count >= db.alert_rules.high_frequency_threshold
+      ? red(` ⚠️ 高频! 已出现${p.occurrence_count}次`)
+      : '';
+    console.log(`  ${highlight(p.id)} [${p.severity.toUpperCase()}]${countWarning}`);
+    console.log(`    模式: ${p.pattern}`);
+    console.log(`    出现次数: ${p.occurrence_count} | 首次: ${p.first_seen} | 最近: ${p.last_seen}`);
+    console.log(`    描述: ${p.description.substring(0, 120)}...`);
+    console.log(`    预防:`);
+    p.prevention.forEach(prev => console.log(`      · ${prev}`));
+    console.log(`    风险等级: ${p.risk_level}`);
+    console.log('');
+  });
+}
+
+// ── 查看模板库 ────────────────────────────────
+function showTemplates() {
+  const db = loadJSON(TEMPLATES_INDEX);
+
+  console.log(`📦 铸渊模板库 · 共 ${db.total_templates} 个模板\n`);
+
+  db.templates.forEach(t => {
+    console.log(`  ${highlight(t.id)} | ${t.name}`);
+    console.log(`    分类: ${t.category} | 复用次数: ${t.reuse_count}`);
+    console.log(`    模式: ${t.pattern}`);
+    console.log(`    来源: ${t.source_file}`);
+    console.log(`    适用场景: ${t.when_to_use}`);
+    console.log('');
+  });
+}
+
+// ── 统计信息 ──────────────────────────────────
+function showStats() {
+  const expDB = loadJSON(EXPERIENCE_DB);
+  const errDB = loadJSON(ERROR_PATTERNS);
+  const tplDB = loadJSON(TEMPLATES_INDEX);
+  const revDB = loadJSON(REVIEW_SCHEDULE);
+
+  console.log('📊 铸渊开发经验知识库统计\n');
+  console.log('  ═══════════════════════════════════');
+  console.log(`  📝 经验条目: ${expDB.stats.total_entries}`);
+  console.log(`     ✅ 成功: ${expDB.stats.success_count}`);
+  console.log(`     ❌ 失败: ${expDB.stats.failed_count}`);
+  console.log(`     ⚠️ 部分: ${expDB.stats.partial_count}`);
+  console.log('');
+  console.log(`  📋 错误模式: ${errDB.total_patterns}`);
+  const highSev = errDB.patterns.filter(p => p.severity === 'high' || p.severity === 'critical');
+  console.log(`     🔴 高危: ${highSev.length}`);
+  console.log('');
+  console.log(`  📦 代码模板: ${tplDB.total_templates}`);
+  const totalReuse = tplDB.templates.reduce((sum, t) => sum + t.reuse_count, 0);
+  console.log(`     ♻️  总复用: ${totalReuse}次`);
+  console.log('');
+  console.log(`  🔄 已完成复盘: ${revDB.statistics.total_reviews_completed}次`);
+  console.log(`     下次复盘: ${revDB.review_cycle.next_review}`);
+  console.log('');
+
+  // 分类统计
+  console.log('  📊 分类分布:');
+  const cats = expDB.stats.categories;
+  Object.entries(cats).sort((a, b) => b[1] - a[1]).forEach(([cat, count]) => {
+    console.log(`     ${cat}: ${count}条`);
+  });
+  console.log('  ═══════════════════════════════════');
+}
+
+// ── 开发前检查 ────────────────────────────────
+function precheck(keyword) {
+  console.log('🧠 铸渊开发前检查 · 回忆搜索\n');
+  console.log(`  搜索关键词: "${keyword}"\n`);
+
+  const kw = keyword.toLowerCase();
+
+  // 1. 搜索相关经验
+  const expDB = loadJSON(EXPERIENCE_DB);
+  const relatedExp = expDB.entries.filter(e =>
+    e.task.toLowerCase().includes(kw) ||
+    e.tags.some(t => t.toLowerCase().includes(kw)) ||
+    e.category.toLowerCase().includes(kw)
+  );
+
+  if (relatedExp.length > 0) {
+    console.log(`  📝 找到 ${relatedExp.length} 条相关经验:`);
+    relatedExp.forEach(e => {
+      console.log(`    · ${e.id}: ${e.task} (${e.status})`);
+      if (e.result.risk_warnings.length > 0) {
+        e.result.risk_warnings.forEach(w => console.log(`      ${red(w)}`));
+      }
+    });
+    console.log('');
+  } else {
+    console.log('  📝 未找到相关经验 · 这是新领域 · 需额外谨慎\n');
+  }
+
+  // 2. 检查错误模式
+  const errDB = loadJSON(ERROR_PATTERNS);
+  const relatedErrors = errDB.patterns.filter(p =>
+    p.pattern.toLowerCase().includes(kw) ||
+    p.category.toLowerCase().includes(kw) ||
+    p.description.toLowerCase().includes(kw)
+  );
+
+  if (relatedErrors.length > 0) {
+    console.log(`  ⚠️ 找到 ${relatedErrors.length} 个相关错误模式:`);
+    relatedErrors.forEach(p => {
+      const freq = p.occurrence_count >= errDB.alert_rules.high_frequency_threshold
+        ? red(' [高频!]') : '';
+      console.log(`    · ${p.id}: ${p.pattern}${freq}`);
+      console.log(`      预防: ${p.prevention[0]}`);
+    });
+    console.log('');
+  } else {
+    console.log('  ⚠️ 未找到相关错误模式\n');
+  }
+
+  // 3. 搜索模板
+  const tplDB = loadJSON(TEMPLATES_INDEX);
+  const relatedTemplates = tplDB.templates.filter(t =>
+    t.name.toLowerCase().includes(kw) ||
+    t.tags.some(tag => tag.toLowerCase().includes(kw)) ||
+    t.category.toLowerCase().includes(kw)
+  );
+
+  if (relatedTemplates.length > 0) {
+    console.log(`  📦 找到 ${relatedTemplates.length} 个可复用模板:`);
+    relatedTemplates.forEach(t => {
+      console.log(`    · ${t.id}: ${t.name}`);
+      console.log(`      模式: ${t.pattern}`);
+      console.log(`      来源: ${t.source_file}`);
+    });
+    console.log('');
+  } else {
+    console.log('  📦 未找到可复用模板\n');
+  }
+
+  console.log('  ════════════════════════════════');
+  console.log('  回忆搜索完成 · 开始开发吧！');
+}
+
+// ── 触发复盘 ──────────────────────────────────
+function review() {
+  const expDB = loadJSON(EXPERIENCE_DB);
+  const errDB = loadJSON(ERROR_PATTERNS);
+  const tplDB = loadJSON(TEMPLATES_INDEX);
+  const revDB = loadJSON(REVIEW_SCHEDULE);
+
+  console.log('🔄 铸渊复盘 · 开始回顾\n');
+
+  // 1. 本周经验
+  const now = new Date();
+  const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+  const recentExp = expDB.entries.filter(e => new Date(e.date) >= weekAgo);
+  console.log(`  📝 本周经验: ${recentExp.length}条`);
+  recentExp.forEach(e => {
+    console.log(`    · ${e.id}: ${e.task} (${e.status})`);
+  });
+  console.log('');
+
+  // 2. 高频错误
+  const highFreq = errDB.patterns.filter(p =>
+    p.occurrence_count >= errDB.alert_rules.high_frequency_threshold
+  );
+  if (highFreq.length > 0) {
+    console.log(`  ${red('🔴 高频错误警报:')}`);
+    highFreq.forEach(p => {
+      console.log(`    · ${p.id}: ${p.pattern} (出现${p.occurrence_count}次)`);
+    });
+    console.log('');
+  }
+
+  // 3. 模板复用率
+  const unusedTemplates = tplDB.templates.filter(t => t.reuse_count === 0);
+  if (unusedTemplates.length > 0) {
+    console.log(`  📦 未使用模板 (${unusedTemplates.length}个):`);
+    unusedTemplates.forEach(t => {
+      console.log(`    · ${t.id}: ${t.name} — 考虑是否需要在下次开发中使用`);
+    });
+    console.log('');
+  }
+
+  // 4. 复盘清单
+  console.log('  📋 复盘清单:');
+  revDB.review_cycle.review_checklist.forEach(item => {
+    console.log(`    ${item}`);
+  });
+
+  // 5. 更新复盘记录
+  const reviewEntry = {
+    date: now.toISOString(),
+    experiences_reviewed: recentExp.length,
+    error_patterns_total: errDB.total_patterns,
+    templates_total: tplDB.total_templates,
+    high_frequency_alerts: highFreq.length,
+    notes: '自动复盘完成'
+  };
+
+  revDB.review_history.push(reviewEntry);
+  revDB.statistics.total_reviews_completed += 1;
+  revDB.statistics.total_experiences_recorded = expDB.stats.total_entries;
+  revDB.statistics.total_error_patterns = errDB.total_patterns;
+  revDB.statistics.total_templates = tplDB.total_templates;
+
+  // 设置下次复盘日期
+  const nextReview = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+  revDB.review_cycle.next_review = nextReview.toISOString();
+
+  saveJSON(REVIEW_SCHEDULE, revDB);
+  console.log(`\n  ✅ 复盘完成 · 下次复盘: ${nextReview.toISOString().split('T')[0]}`);
+}
+
+// ── 添加经验 (从stdin读取JSON) ────────────────
+function addExperience() {
+  let input = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const newEntry = JSON.parse(input);
+      const db = loadJSON(EXPERIENCE_DB);
+
+      // 自动生成ID
+      if (!newEntry.id) {
+        const today = new Date().toISOString().split('T')[0].replace(/-/g, '');
+        const count = db.entries.filter(e => e.id.startsWith(`EXP-${today}`)).length + 1;
+        newEntry.id = `EXP-${today}-${String(count).padStart(3, '0')}`;
+      }
+
+      db.entries.push(newEntry);
+      db.stats.total_entries = db.entries.length;
+      db.stats.success_count = db.entries.filter(e => e.status === 'success').length;
+      db.stats.failed_count = db.entries.filter(e => e.status === 'failed').length;
+      db.stats.partial_count = db.entries.filter(e => e.status === 'partial').length;
+
+      // 更新分类计数
+      db.stats.categories = {};
+      db.entries.forEach(e => {
+        db.stats.categories[e.category] = (db.stats.categories[e.category] || 0) + 1;
+      });
+
+      saveJSON(EXPERIENCE_DB, db);
+      console.log(`✅ 经验已添加: ${newEntry.id} — ${newEntry.task}`);
+    } catch (err) {
+      console.error(`❌ JSON解析失败: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// ── 添加错误模式 (从stdin读取JSON) ────────────
+function addError() {
+  let input = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const newPattern = JSON.parse(input);
+      const db = loadJSON(ERROR_PATTERNS);
+
+      // 检查是否已存在相似模式
+      const existing = db.patterns.find(p =>
+        p.pattern.toLowerCase() === newPattern.pattern.toLowerCase()
+      );
+
+      if (existing) {
+        existing.occurrence_count += 1;
+        existing.last_seen = new Date().toISOString().split('T')[0];
+        console.log(`⚠️ 已有相似错误模式 ${existing.id} · 出现次数+1 → ${existing.occurrence_count}`);
+      } else {
+        if (!newPattern.id) {
+          newPattern.id = `ERR-${String(db.patterns.length + 1).padStart(3, '0')}`;
+        }
+        db.patterns.push(newPattern);
+        db.total_patterns = db.patterns.length;
+        console.log(`✅ 错误模式已添加: ${newPattern.id} — ${newPattern.pattern}`);
+      }
+
+      saveJSON(ERROR_PATTERNS, db);
+    } catch (err) {
+      console.error(`❌ JSON解析失败: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// ── 添加模板 (从stdin读取JSON) ────────────────
+function addTemplate() {
+  let input = '';
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', chunk => { input += chunk; });
+  process.stdin.on('end', () => {
+    try {
+      const newTemplate = JSON.parse(input);
+      const db = loadJSON(TEMPLATES_INDEX);
+
+      if (!newTemplate.id) {
+        newTemplate.id = `TPL-${String(db.templates.length + 1).padStart(3, '0')}`;
+      }
+      if (newTemplate.reuse_count === undefined) {
+        newTemplate.reuse_count = 0;
+      }
+
+      db.templates.push(newTemplate);
+      db.total_templates = db.templates.length;
+
+      // 更新分类计数
+      db.categories = {};
+      db.templates.forEach(t => {
+        db.categories[t.category] = (db.categories[t.category] || 0) + 1;
+      });
+
+      saveJSON(TEMPLATES_INDEX, db);
+      console.log(`✅ 模板已添加: ${newTemplate.id} — ${newTemplate.name}`);
+    } catch (err) {
+      console.error(`❌ JSON解析失败: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// ── 主入口 ────────────────────────────────────
+const args = process.argv.slice(2);
+const command = args[0];
+
+switch (command) {
+  case 'search':
+    if (!args[1]) {
+      console.error('用法: node dev-experience-manager.js search <关键词>');
+      process.exit(1);
+    }
+    search(args[1]);
+    break;
+  case 'errors':
+    showErrors();
+    break;
+  case 'templates':
+    showTemplates();
+    break;
+  case 'stats':
+    showStats();
+    break;
+  case 'precheck':
+    if (!args[1]) {
+      console.error('用法: node dev-experience-manager.js precheck <关键词>');
+      process.exit(1);
+    }
+    precheck(args[1]);
+    break;
+  case 'review':
+    review();
+    break;
+  case 'add-experience':
+    addExperience();
+    break;
+  case 'add-error':
+    addError();
+    break;
+  case 'add-template':
+    addTemplate();
+    break;
+  default:
+    console.log('🧠 铸渊开发经验知识库管理工具\n');
+    console.log('用法:');
+    console.log('  search <keyword>   搜索经验');
+    console.log('  errors             查看错题本');
+    console.log('  templates          查看模板库');
+    console.log('  stats              查看统计');
+    console.log('  precheck <keyword> 开发前检查(回忆搜索)');
+    console.log('  review             触发复盘');
+    console.log('  add-experience     添加经验(JSON from stdin)');
+    console.log('  add-error          添加错误模式(JSON from stdin)');
+    console.log('  add-template       添加模板(JSON from stdin)');
+    break;
+}