ai-scaffold-pro 1.1.1

package/i18n/index.js

@@ -0,0 +1,27 @@
+import Handlebars from 'handlebars';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let currentTranslations = {};
+
+export function registerI18n(lang) {
+  const filePath = path.join(__dirname, `${lang}.json`);
+  currentTranslations = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+
+  Handlebars.registerHelper('t', (key) => {
+    const result = key.split('.').reduce((obj, k) => obj?.[k], currentTranslations);
+    if (result === undefined) {
+      console.warn(`[i18n] Missing translation key: ${key}`);
+      return `[MISSING:${key}]`;
+    }
+    return new Handlebars.SafeString(result);
+  });
+}
+
+export function t(key) {
+  return key.split('.').reduce((obj, k) => obj?.[k], currentTranslations) || `[MISSING:${key}]`;
+}

package/i18n/zh.json

@@ -0,0 +1,536 @@
+{
+  "changelog": {
+    "title": "版本记录",
+    "format_line1": "格式: vX.Y.Z (YYYY.MM.DD)",
+    "format_line2": "X = 架构级重构 | Y = 功能变更 | Z = 修补",
+    "added_entry": "项目概述、构建命令、规则与技能触发策略",
+    "added_project_rule": "开发主规则",
+    "added_conflict_resolution": "规则冲突解决机制",
+    "added_plan_mode": "任务结构化拆分技能",
+    "added_code_review": "代码审查技能",
+    "added_arch_review": "架构合规审查 agent",
+    "added_resource_sync": "资源同步校验 agent",
+    "added_proactive_correction": "主动纠错 agent（规则自洽性 + 存量代码合规性 + 实现合理性扫描，可执行修正）",
+    "added_post_edit_tracker": "编辑追踪钩子",
+    "added_check_review": "审查提醒钩子",
+    "added_settings": "钩子注册配置",
+    "added_gen_references": "模块参考文档自动生成脚本",
+    "added_references": "模块参考文档"
+  },
+  "project_rule": {
+    "title": "开发规则",
+    "scope": "**适用范围**：代码生成、修改、审查、重构操作。",
+    "skip_conditions": "**跳过条件**：纯闲聊、通用知识问答、非代码相关讨论、否定语境。",
+    "negative_title": "否定词保护",
+    "negative_table_header": "| 否定模式 | 示例 | 原因 |",
+    "negative_row1": "| 通用概念讨论 | \"X 和 Y 在原理上有什么区别？\" | 通用知识问答 |",
+    "negative_row2": "| 类比/对比 | \"类似项目中这个机制怎么做的？\" | 讨论外部项目 |",
+    "negative_row3": "| 明确排除 | \"帮我看看代码逻辑，不需要检查规范\" | 用户显式排除 |",
+    "negative_row4": "| 已关闭语境 | \"之前那个问题已经解决了\" | 问题已关闭 |",
+    "conduct_title": "行为准则",
+    "conduct_search_first": "**先查后写**：生成代码前，先查阅",
+    "conduct_search_first_suffix": "目录下目标模块文档，确认类名、方法名、路径真实存在",
+    "conduct_no_fabrication": "**禁止虚构**：不得使用项目中不存在的类/方法/常量/路径；不确定时必须用搜索工具验证",
+    "conduct_no_new_deps": "**禁止引入新依赖**：仅使用",
+    "conduct_no_new_deps_suffix": "中已列出的第三方库和模块依赖",
+    "conduct_reuse": "**优先复用工具类**：项目中已有封装必须优先使用，禁止绕过封装重新实现",
+    "conduct_confirm": "**不确定即确认**：遇到灰色地带必须向用户确认，禁止自行决策",
+    "proactive_title": "主动纠错准则",
+    "proactive_scan": "**主动扫描不被动等待**：在接触任何源码文件或规则文件时，必须主动检查合规性和合理性，而非仅等待审查触发",
+    "proactive_fix": "**发现即纠正而非仅报告**：发现规则自洽性缺陷、代码合规性违规、实现合理性偏差时，不仅列出问题，还必须提供具体修正方案并推动闭环",
+    "proactive_rules": "**规则自洽性不可盲信**：规则文件本身也可能有缺陷（内部矛盾、遗漏、过时），发现时必须主动指出并提出修正",
+    "proactive_closure": "**纠错闭环不遗忘**：发现的致命问题必须追踪至修复完成，禁止\"报告即遗忘\"",
+    "proactive_confirm": "**纠错需用户确认**：执行修正前必须告知用户，由用户决定是否执行；禁止未经确认自动修改",
+    "proactive_limit": "**同一轮纠错限 5 文件**：防止过度修改失控，每轮纠错最多修改 5 个文件",
+    "arch_title": "架构约束",
+    "arch_dep_title": "模块依赖方向",
+    "arch_comm_title": "模块间通信",
+    "arch_comm_desc": "通过指定机制进行跨模块通信。禁止业务模块间直接 import。",
+    "arch_inherit_title": "继承体系",
+    "forbidden_title": "禁止模式",
+    "forbidden_desc": "以下模式在项目代码中**严格禁止**：",
+    "forbidden_table_header": "| # | 禁止模式 | 正确替代 | 原因 |",
+    "naming_title": "命名规范",
+    "naming_resource_title": "资源前缀",
+    "naming_class_title": "类/文件命名",
+    "naming_layout_title": "布局命名",
+    "platform_title": "专项规则",
+    "ndk_title": "C++ / NDK 专项规则",
+    "ndk_jni_memory_title": "JNI 内存管理",
+    "ndk_jni_memory_desc": "JNI 层涉及 C 堆内存和 JNI 引用两类资源，泄漏后无法被 GC 回收，必须严格遵守以下规则：",
+    "ndk_jni_memory_table_header": "| # | 规则 | 说明 |",
+    "ndk_jni_memory_row1": "| 1 | GetStringUTFChars 必须配对 ReleaseStringUTFChars | 获取后必须确保释放，推荐 `goto cleanup` 模式统一释放点 |",
+    "ndk_jni_memory_row2": "| 2 | malloc/calloc/realloc 必须配对 free | 每个 malloc 必须有对应 free，包括所有分支路径 |",
+    "ndk_jni_memory_row3": "| 3 | NewStringUTF/NewObject 等创建的 local reference 应及时 DeleteLocalRef | 大量 local reference 可能撑爆引用表，函数结束前应清理不再使用的局部引用 |",
+    "ndk_jni_memory_row4": "| 4 | GetStringUTFChars 返回值必须做空指针检查 | 返回 NULL 时不可用于字符串操作，应提前返回或 goto cleanup |",
+    "ndk_jni_memory_row5": "| 5 | NewGlobalRef 必须配对 DeleteGlobalRef | 全局引用在不再使用时必须释放，否则永久泄漏 |",
+    "ndk_jni_memory_row6": "| 6 | 禁止在 goto cleanup 之后的代码路径中访问已释放资源 | cleanup 标签后只做释放和返回，不再使用任何已释放的指针/引用 |",
+    "ndk_jni_coding_title": "JNI 编码规范",
+    "ndk_jni_coding_table_header": "| # | 规则 | 说明 |",
+    "ndk_jni_coding_row1": "| 1 | JNI 方法签名必须与 Java native 声明一致 | 参数类型和返回值类型必须严格匹配，注册时签名错误会导致 UnsatisfiedLinkError |",
+    "ndk_jni_coding_row2": "| 2 | JNI_OnLoad 中注册 native 方法优先于静态绑定 | 动态注册（RegisterNatives）应在 JNI_OnLoad 中完成 |",
+    "ndk_jni_coding_row3": "| 3 | 禁止在 JNI 层缓存 JNIEnv 指针 | JNIEnv 线程相关，跨线程使用必须通过 JavaVM->AttachCurrentThread 获取 |",
+    "ndk_jni_coding_row4": "| 4 | C++ 异常不得跨越 JNI 边界 | JNI 函数中必须 catch 所有 C++ 异常，禁止异常传播至 JVM |",
+    "ndk_memory_safety_title": "C++ 内存安全与优化",
+    "ndk_memory_safety_row1": "禁止使用裸指针管理堆内存 | 优先使用 std::unique_ptr / std::shared_ptr，或项目约定的 RAII 封装",
+    "ndk_memory_safety_row2": "数组操作必须进行边界检查 | 禁止未校验索引直接访问数组，尤其是来自 JNI 层的索引参数",
+    "ndk_memory_safety_row3": "字符串操作必须确保缓冲区足够 | sprintf/snprintf 目标缓冲区必须留足空间，优先使用 snprintf 防止溢出",
+    "ndk_memory_safety_row4": "禁止返回栈上局部变量的指针/引用 | 函数返回后栈内存无效，必须使用堆分配或值返回",
+    "ndk_memory_safety_row5": "大块内存分配应检查返回值 | malloc/calloc/new 失败时返回 NULL，必须做异常处理",
+    "ndk_memory_safety_row6": "敏感数据使用后应清零 | 密钥、token 等敏感内存区域使用后必须 memset_s/SecureZeroMemory 清零",
+    "ndk_build_title": "NDK 构建规范",
+    "ndk_build_row2": "so 库名必须与 System.loadLibrary 参数一致 | 去掉 lib 前缀和 .so 后缀",
+    "ndk_build_row3": "ABI 架构必须覆盖目标设备 | 常见组合：armeabi-v7a + arm64-v8a，按需增减",
+    "ndk_build_row4": "NDK 路径通过 local.properties 的 ndk.dir 配置 | 禁止硬编码 NDK 路径到构建脚本",
+    "ndk_build_row5": "编译优化标记应与构建类型匹配 | Debug 用 -O0 -g，Release 用 -O2/-O3",
+    "ndk_build_row6": "安全编译选项必须启用 | -fstack-protector-all、-fvisibility=hidden 等安全加固选项",
+    "quality_title": "代码实现质量规则",
+    "quality_rules": "- 同一模块内 3 次及以上相同/相似代码块，必须抽取为公共方法\n- 禁止 Copy-Paste 式编码\n- 优先复用现有类\n- 单例模式统一（Kotlin lazy(SYNCHRONIZED) / Java 内部类持有）",
+    "quality_ndk_title": "C++ / NDK 代码质量规则",
+    "quality_ndk_rules": "- JNI 函数中 3 次及以上相同/相似代码块（如包名校验、签名拼接），必须抽取为 C 层公共函数\n- C++ 函数中资源分配与释放必须对称，推荐 `goto cleanup` 统一出口模式\n- 禁止在 JNI 函数中内联大段业务逻辑，应拆分为独立的 C/C++ 函数后由 JNI 层调用\n- 敏感密钥数组应使用 `__attribute__((section(\".mytext\")))` 或等效的混淆保护",
+    "checklist_title": "代码自查清单",
+    "checklist_desc": "每次代码变更后逐项检查：",
+    "checklist_table_header": "| # | 检查项 |",
+    "checklist_row1": "| 1 | 引用的类/方法在项目中真实存在？ |",
+    "checklist_row2": "| 2 | 模块依赖方向正确？ |",
+    "checklist_row3": "| 3 | 无禁止模式使用？ |",
+    "checklist_row4": "| 4 | 无硬编码路由路径/SP Key/颜色/尺寸/中文字符串？ |",
+    "checklist_row5": "| 5 | 日志工具选择正确？ |",
+    "checklist_row6": "| 6 | 无重复代码块？ |",
+    "checklist_rowC1": "| C1 | 主动纠错扫描已执行？（委派 `proactive-correction` agent） |",
+    "checklist_rowC2": "| C2 | 发现的致命违规已修正闭环？ |",
+    "checklist_rowC3": "| C3 | 规则自洽性无缺陷？（接触规则文件时必查） |",
+    "checklist_ndk_row1": "NDK 构建配置正确（ndk.dir、ABI 覆盖、安全编译选项）？",
+    "checklist_ndk_row2": "JNI 方法签名与 Java native 方法一致？",
+    "checklist_ndk_row3": "JNI GetStringUTFChars / ReleaseStringUTFChars 配对完整？",
+    "checklist_ndk_row4": "JNI malloc / free 配对完整（含所有分支路径）？",
+    "checklist_ndk_row5": "JNI GetStringUTFChars 返回值已做空指针检查？",
+    "checklist_ndk_row6": "JNI local reference 大量创建时已及时 DeleteLocalRef？",
+    "checklist_ndk_row7": "JNI NewGlobalRef / DeleteGlobalRef 配对完整？",
+    "checklist_ndk_row8": "C++ 堆内存分配后做了返回值检查？",
+    "checklist_ndk_row9": "敏感数据（密钥/token）使用后已清零？",
+    "checklist_ndk_row10": "C++ 异常不会跨越 JNI 边界传播？",
+    "config_title": "配置变更管理",
+    "config_desc": "凡修改",
+    "config_desc_suffix": "目录下的任何配置文件，**必须**：",
+    "config_step1": "更新",
+    "config_step1_suffix": "（Keep a Changelog 格式）",
+    "config_step2_prefix": "升级",
+    "config_step2_suffix": "首行版本号",
+    "config_version_table_header": "| 变更类型 | 版本递增 |",
+    "config_version_row1": "| 架构级重构 | X |",
+    "config_version_row2": "| 功能变更（新增规则/技能/hooks/文档） | Y |",
+    "config_version_row3": "| 修补（修正/补充） | Z |",
+    "config_scope": "**适用范围**：",
+    "config_scope_table_header": "| 文件 | 说明 |",
+    "config_scope_entry": "入口调度层",
+    "config_scope_rules": "规则文件",
+    "config_scope_skills": "技能文件",
+    "config_scope_agents": "Agent 配置",
+    "config_scope_hooks": "钩子脚本",
+    "config_scope_settings": "钩子/权限配置",
+    "config_scope_references": "参考文档",
+    "config_scope_scripts": "工具脚本",
+    "conduct_codegraph_search": "**使用 codegraph_explore 工具搜索代码库**：修改代码前，通过 codegraph_explore 工具搜索相关类/方法/符号，确认其真实存在。配合",
+    "conduct_codegraph_search_suffix": "目录下的架构决策和业务约定文档",
+    "conduct_codegraph_lightweight": "**references/ 为轻量模式**：仅包含架构决策、业务逻辑摘要和项目约定，不包含完整文件列表和目录树（由 CodeGraph 提供结构探索能力）"
+  },
+  "conflict_resolution": {
+    "title": "规则冲突解决",
+    "desc": "本文件定义多规则同时加载时的优先级裁决机制。",
+    "desc2": "每条规则文件头部通过 HTML 注释声明 `id`、`domains`、`priority`。",
+    "priority_title": "优先级原则",
+    "priority_1": "**特定领域规则优先于通用规则** — domain 更窄者在其领域内胜出",
+    "priority_2": "**priority 数值越高，在其声明的 domain 内优先级越高** — 仅在 domain 重叠时比较",
+    "priority_3": "**规则默认叠加，仅冲突条目按优先级裁决** — 非冲突部分全部保留",
+    "priority_4": "**裁决表未覆盖的冲突 → 向用户确认** — 确认后补充登记到本表",
+    "domain_title": "当前规则 Domain 注册",
+    "domain_table_header": "| 规则 ID | priority | domains |",
+    "conflict_table_title": "已知冲突裁决表",
+    "conflict_table_header": "| # | 冲突场景 | 规则A 指导 | 规则B 指导 | 裁决 | 原因 |",
+    "conflict_row1": "| 1 | proactive-correction 发现致命违规 vs. code_review 仅报告 | proactive-correction 主动提修正方案并推动闭环 | code_review 只报告不推动修正 | proactive-correction 优先 | 致命问题必须闭环解决，仅报告会导致问题遗留 |",
+    "conflict_row2": "| 2 | proactive-correction 扫描存量代码违规 vs. arch-review 只扫变更代码 | proactive-correction 扫全量代码 | arch-review 只扫变更部分 | proactive-correction 扫全量，arch-review 扫变更 | 全量违规和变更引入的违规性质不同，需分别处理 |",
+    "conflict_row3": "| 3 | proactive-correction 发现规则自洽性缺陷 vs. project_rule 禁止模式表 | proactive-correction 认为规则有遗漏/矛盾 | project_rule 定义了当前禁止模式 | project_rule 优先，但 proactive-correction 应记录并提示用户 | 规则由用户定义，agent 不能自行修改规则，但必须主动提醒 |",
+    "conflict_row4": "| 4 | proactive-correction 要求修正 vs. 用户拒绝修正 | proactive-correction 推动修正闭环 | 用户选择不修正 | 用户决策优先 | 纠错需用户确认，用户有权拒绝修正 |",
+    "conflict_row5": "| 5 | proactive-correction 同一轮限 5 文件 vs. 发现更多违规 | proactive-correction 限制每轮最多修改 5 文件 | 实际存在 > 5 个违规文件 | 5 文件限制优先，剩余违规记录为\"已知但未修正\" | 防止过度修改失控，多轮迭代处理 |",
+    "conflict_row6": "| 6 | plan_mode 纠错检查点触发 vs. 用户说\"直接做\" | plan_mode 每步完成后触发纠错扫描 | 用户要求跳过检查直接执行 | 用户优先，但致命问题仍需标记 | 用户有权决定流程节奏，但致命问题不得静默忽略 |",
+    "conflict_row_other": "| — | 其他暂无 | — | — | — | 待项目发展中补充 |",
+    "registration_title": "新增规则登记流程",
+    "registration_steps": "1. 在新规则文件头部添加 `id`、`domains`、`priority` 元数据注释\n2. 在 Domain 注册表中登记\n3. 检查新规则 domains 与已有规则的交集\n4. 识别冲突点，在裁决表中登记\n5. 裁决原则：领域更窄/更专业的规则优先",
+    "registration_step6_prefix": "在",
+    "registration_step6_suffix": "中添加触发条件和核心约束摘要",
+    "maintenance_title": "裁决表维护规范",
+    "maintenance_rules": "- AI 在实际场景中遇到未覆盖的冲突，应提示用户并记录\n- 裁决表更新需同步更新",
+    "maintenance_rules_suffix": "- 裁决理由必须写明，禁止留空"
+  },
+  "arch_review": {
+    "description": "架构合规性审查专家。检测模块依赖方向违规、禁止模式使用、跨模块通信合规性。",
+    "title": "架构合规性审查 Agent",
+    "intro": "你是一个专注于",
+    "intro_suffix": "项目架构合规性的审查专家。",
+    "dimension_title": "审查维度",
+    "dep_title": "模块依赖方向",
+    "dep_check_title": "检查原则：",
+    "dep_check_method": "检查方法：\n- 在变更文件的 import 语句中，确认每个 import 的包所属模块在当前模块的依赖配置中存在\n- 搜索是否出现反向依赖",
+    "forbidden_title": "禁止模式检测",
+    "forbidden_desc": "逐项扫描变更代码：",
+    "forbidden_table_header": "| 禁止模式 | 搜索模式 | 应替换为 |",
+    "comm_title": "跨模块通信合规性",
+    "comm_desc": "当变更涉及模块间调用时，确认使用了合规通信方式：",
+    "inherit_title": "继承体系",
+    "inherit_check_rules": "检查规则：\n- 搜索 extends/implements/: 语句\n- 验证业务类是否继承了正确的 Base 类\n- 检查自定义 View 是否提供了必要的构造器",
+    "inherit_check_method_title": "检查方法：",
+    "inherit_check_method_steps": "1. 搜索 `class XXX extends` / `class XXX :` 语句\n2. 提取继承的父类名\n3. 对比 INHERITANCE_RULES 中定义的继承要求\n4. 列出不符合继承规则的类",
+    "interface_isolation_title": "接口隔离检查",
+    "interface_isolation_rules": "检查规则：\n- 跨模块依赖时，仅暴露 public interface/contract\n- 禁止暴露内部实现类\n- 模块内部使用 internal/private 限制访问",
+    "interface_isolation_method_title": "检查方法：",
+    "interface_isolation_method_steps": "1. 识别变更文件的模块归属\n2. 检查 import 的类是否属于目标模块的公开 API\n3. 如果导入了非公开类，标记为违规",
+    "cycle_detection_title": "循环依赖检测",
+    "cycle_detection_method_title": "检查方法：",
+    "cycle_detection_method_steps": "1. 收集变更文件及其所在模块的所有 import 语句\n2. 构建模块级依赖图（Module A imports from Module B → A depends on B）\n3. 使用 DFS 检测环路\n4. 输出违规路径（如：A → B → C → A）\n5. 每条环路标记涉及的具体 import 语句（文件:行号）",
+    "output_title": "输出格式",
+    "output_scope": "审查范围",
+    "output_scope_value": "变更文件列表",
+    "output_result": "审查结果",
+    "output_pass": "通过",
+    "output_warning": "有警告",
+    "output_violation": "有违规",
+    "output_violation_section": "违规项（必须修复）",
+    "output_col_file": "文件:行号",
+    "output_col_type": "违规类型",
+    "output_col_issue": "具体问题",
+    "output_col_fix": "修复建议",
+    "output_passed_section": "已通过项",
+    "output_dep_ok": "模块依赖方向正确",
+    "output_forbidden_ok": "无禁止模式使用",
+    "constraints_title": "约束",
+    "must_do_title": "**必须做**：",
+    "must_do_rules": "- 每个违规项必须给出具体文件和行号\n- 每个违规项必须给出明确的修复建议\n- 检查必须基于真实的 import 语句和代码内容",
+    "must_not_title": "**禁止做**：",
+    "must_not_rules": "- 禁止修改代码（只读审查）\n- 禁止对非变更文件提出审查意见（除非变更引入了影响）\n- 禁止报告已知的历史遗留问题"
+  },
+  "resource_sync": {
+    "description": "资源文件同步校验专家。检测资源全目录一致性、命名前缀规范。",
+    "title": "资源文件同步校验 Agent",
+    "output_title": "输出格式",
+    "output_scope": "审查范围",
+    "output_scope_value": "涉及的资源文件列表",
+    "output_result": "审查结果",
+    "output_pass": "全部同步",
+    "output_fail": "存在缺失",
+    "output_missing_section": "缺失项",
+    "output_col_name": "资源名",
+    "output_col_type": "类型",
+    "output_col_exists": "已存在目录",
+    "output_col_missing": "缺失目录",
+    "output_naming_section": "命名规范问题",
+    "output_col_file": "文件",
+    "output_col_issue": "问题",
+    "output_col_suggestion": "建议",
+    "output_passed_section": "已通过项",
+    "constraints_title": "约束",
+    "constraints": "- 禁止修改文件（只读检查）\n- 必须明确列出缺失的具体目录路径"
+  },
+  "code_review": {
+    "description": "代码生成后的自动化审查技能。对新增/修改的代码执行项目规范合规检查。",
+    "title": "Code Review — 代码生成后审查",
+    "trigger_title": "**触发条件**（满足任一即执行）：",
+    "trigger_1": "完成了多文件代码生成",
+    "trigger_2": "完成了涉及架构边界的代码修改",
+    "trigger_3": "用户明确要求\"审查/review/检查\"",
+    "trigger_4": "`plan_mode` 的计划执行完毕后",
+    "skip": "**跳过条件**：单行修改、纯配置文件修改、用户说\"不需要审查\"。",
+    "checklist_title": "审查清单",
+    "fatal_title": "❌ 致命级（阻断性问题，必须修复）",
+    "fatal_row1": "模块依赖方向违规 | import 的包所属模块是否在 build 配置的依赖中",
+    "fatal_row2": "使用了禁止模式 | 搜索 project_rule.md §3 中列出的模式",
+    "fatal_row3": "路由注册不完整（如适用） | 新页面是否完成所有注册步骤",
+    "fatal_row4": "主线程网络请求（如适用） | 网络回调是否在 IO 线程",
+    "fatal_row5": "继承体系错误 | 新 Activity/ViewController 是否继承正确基类",
+    "fatal_row6": "硬编码密钥/隐私数据 | 代码中是否出现明文密钥",
+    "fatal_ndk1": "JNI 方法签名不一致 | native 方法与 C++ 层 JNI 函数签名是否匹配（参数类型、返回值、方法名）",
+    "fatal_ndk2": "JNI 内存泄漏 — GetStringUTFChars 未释放 | 搜索 GetStringUTFChars 调用，确认每个路径都有对应 ReleaseStringUTFChars",
+    "fatal_ndk3": "JNI 内存泄漏 — malloc 未释放 | 搜索 malloc/calloc/realloc，确认每个分支路径都有对应 free",
+    "fatal_ndk4": "JNI 内存泄漏 — GlobalRef 未释放 | 搜索 NewGlobalRef，确认不再使用时有 DeleteGlobalRef",
+    "fatal_ndk5": "C++ 异常跨越 JNI 边界 | JNI 函数入口/出口是否有 try-catch 保护",
+    "fatal_ndk6": "NDK 构建路径错误 | ndk-build 路径和 so 输出路径是否正确",
+    "warning_title": "⚠️ 警告级（应修复，不阻断）",
+    "warning_row7": "硬编码字符串/颜色/尺寸 | 代码中是否直接写字符串/色值/dp/sp 值",
+    "warning_row8": "未使用项目封装工具类 | 是否绕过已有封装直接调用底层 API",
+    "warning_row9": "JSON 解析无 try-catch（如适用） | 解析调用是否被异常处理包裹",
+    "warning_row10": "资源文件未全目录同步 | 新资源是否在所有适配目录中存在",
+    "warning_ndk1": "JNI GetStringUTFChars 返回值未做空指针检查 | 返回 NULL 时继续操作会导致 NPE 崩溃",
+    "warning_ndk2": "JNI local reference 未及时删除 | 循环中大量创建 local ref 未 DeleteLocalRef 可能撑爆引用表",
+    "warning_ndk3": "C++ 堆内存分配未检查返回值 | malloc/calloc/new 失败返回 NULL，未做空指针检查",
+    "warning_ndk4": "敏感数据使用后未清零 | 密钥/token 等内存区域使用后未 memset 清零",
+    "warning_ndk5": "snprintf 缓冲区大小不足 | 格式化输出目标缓冲区是否留足空间",
+    "suggestion_title": "💡 建议级（可选优化）",
+    "suggestion_row11": "日志工具选择 | 是否使用了正确优先级的日志工具",
+    "suggestion_row12": "弱引用模式 | 回调中引用 Activity/ViewController 是否用了弱引用",
+    "suggestion_row13": "单例线程安全 | 新单例是否使用线程安全初始化",
+    "suggestion_row14": "代码复用 | 同类代码块是否已抽取",
+    "suggestion_ndk1": "C++ 裸指针管理堆内存 | 建议使用 std::unique_ptr / std::shared_ptr 或 RAII 封装",
+    "suggestion_ndk2": "JNI 函数内联大段业务逻辑 | 建议拆分为独立 C/C++ 函数，JNI 层仅做桥接",
+    "suggestion_ndk3": "JNI goto cleanup 模式统一出口 | 多处资源分配时建议使用 goto cleanup 统一释放点",
+    "suggestion_ndk4": "C++ 重复代码块抽取 | JNI 函数中相同/相似逻辑是否已抽取为公共 C 函数",
+    "suggestion_ndk5": "NDK 安全编译选项 | 是否启用 -fstack-protector-all、-fvisibility=hidden 等安全选项",
+    "output_title": "审查输出格式",
+    "output_scope": "审查范围",
+    "output_scope_value": "变更文件列表",
+    "output_result": "总体结果",
+    "output_pass": "通过",
+    "output_warnings": "项警告",
+    "output_fatals": "项致命",
+    "output_fatal_section": "致命问题",
+    "output_issue": "问题",
+    "output_issue_title": "标题",
+    "output_location": "位置",
+    "output_violated_rule": "违反规则",
+    "output_current_code": "当前代码",
+    "output_fix": "修复方案",
+    "output_warning_section": "警告",
+    "output_suggestion_section": "优化建议",
+    "output_passed_section": "已验证通过",
+    "flow_title": "审查流程",
+    "flow_content": "代码生成完成\n    ↓\n[Step 0] 前置纠错检查 — 主动扫描已修改文件的存量合规性\n    │         （委派 proactive-correction agent 执行维度 2 扫描）\n    │         ├─ 发现致命违规 ──→ 立即修正后再进入审查\n    │         └─ 无致命违规 ──→ 进入正式审查\n    ↓\n[Step 1] 收集变更文件列表\n    ↓\n[Step 2] 按致命 → 警告 → 建议顺序逐项检查\n    ↓\n[Step 3] 输出审查报告\n    ↓\n┌── ❌ 有致命问题 ──→ 告知用户，给出修复方案\n│                      修正后触发 proactive-correction 验证修复效果\n└── ✅/⚠️ ──→ 输出报告，继续后续任务",
+    "collab_title": "与 SubAgent 协作",
+    "collab_proactive": "**前置纠错检查** → 委派 `proactive-correction` agent（在审查前扫描已修改文件的存量合规性，在审查后验证修复效果）",
+    "collab_arch": "**架构合规** → 委派 `arch-review` agent",
+    "collab_resource": "**资源同步** → 委派 `resource-sync` agent",
+    "collab_cpp": "**C++ 内存安全** → 委派 `cpp-memory-review` agent（当变更涉及 .cpp/.h/.c 文件时自动触发）",
+    "collab_timing_prefix": "委派时机：前置纠错检查为必经步骤；其余为变更涉及",
+    "collab_timing_suffix": "+ 模块，或涉及资源文件",
+    "collab_timing_ndk": "，或涉及 C++/NDK 代码"
+  },
+  "plan_mode": {
+    "description": "复杂开发任务的结构化拆分技能。当任务涉及多模块协作、多步骤操作时，在执行前先输出分步计划。",
+    "title": "Plan Mode — 任务结构化拆分",
+    "trigger_title": "**触发条件**（满足任一即加载）：",
+    "trigger_1": "涉及 2 个及以上模块的协作",
+    "trigger_2": "需要修改 3 个及以上文件",
+    "trigger_3": "涉及路由注册、资源同步等多步流程",
+    "trigger_4": "用户明确要求\"先规划/plan/拆分任务\"",
+    "skip": "**跳过条件**：单文件简单修改、用户说\"直接改\"、纯问答。",
+    "plan_output_title": "计划输出格式",
+    "plan_output_header": "📋 执行计划",
+    "plan_output_task": "任务",
+    "plan_output_task_desc": "一句话描述",
+    "plan_output_modules": "涉及模块",
+    "plan_output_modules_list": "模块列表",
+    "plan_output_files": "预计修改文件数",
+    "plan_output_rules": "需加载规则/技能",
+    "plan_output_rules_list": "列出",
+    "plan_output_steps": "步骤拆分",
+    "plan_output_col_action": "操作",
+    "plan_output_col_target": "目标文件/位置",
+    "plan_output_col_dep": "依赖",
+    "plan_output_col_check": "检查点",
+    "plan_output_risks": "风险点",
+    "plan_output_done_criteria": "完成标准",
+    "task_templates_title": "高频任务模板",
+    "ndk_templates_title": "C++ / NDK 高频任务模板",
+    "ndk_new_jni_title": "新增 JNI 方法",
+    "ndk_new_jni_content": "## 📋 执行计划\n\n**任务**：新增 JNI native 方法\n**涉及模块**：[Java 模块] + [JNI 层]\n**预计修改文件数**：3-4\n**需加载规则/技能**：project_rule + code_review\n\n### 步骤拆分\n\n| # | 操作 | 目标文件/位置 | 依赖 | 检查点 |\n|---|------|-------------|------|--------|\n| 1 | Java 类中声明 native 方法 | `XXJavaClass.java` | 无 | 方法签名确定 |\n| 2 | C++ 层实现 JNI 函数 | `jni/com_xxx.cpp` | 步骤1 | JNI 签名与 Java 一致 |\n| 3 | 注册 native 方法（动态注册）或生成头文件（静态注册） | `JNI_OnLoad` 或 `.h` 文件 | 步骤2 | RegisterNatives 签名匹配 |\n| 4 | 如有新 C++ 源文件，更新 Android.mk/CMakeLists.txt | `Android.mk` | 步骤2 | LOCAL_SRC_FILES 已包含 |\n\n### ⚠️ 风险点\n- JNI 签名不匹配导致 UnsatisfiedLinkError\n- 内存泄漏（GetStringUTFChars 未释放、malloc 未 free）\n- 线程安全问题（JNIEnv 不可跨线程缓存）\n\n### ✅ 完成标准\n- Java 调用 native 方法返回预期结果\n- valgrind/ASan 无内存泄漏报告\n- ndk-build 编译通过，so 正确输出",
+    "ndk_new_sign_title": "新增加密签名方法",
+    "ndk_new_sign_content": "## 📋 执行计划\n\n**任务**：新增加密签名方法\n**涉及模块**：[Java 桥接类] + [JNI 层] + [密钥管理]\n**预计修改文件数**：3-5\n**需加载规则/技能**：project_rule + code_review + cpp-memory-review\n\n### 步骤拆分\n\n| # | 操作 | 目标文件/位置 | 依赖 | 检查点 |\n|---|------|-------------|------|--------|\n| 1 | 添加密钥到 C++ 密钥数组 | `com_xxx_encryptor.cpp` | 无 | 密钥数组长度与索引一致 |\n| 2 | 实现签名生成 C 函数 | `com_xxx_encryptor.cpp` | 步骤1 | malloc/free 配对、敏感数据清零 |\n| 3 | 添加 JNI 桥接函数 | `com_xxx_encryptor.cpp` | 步骤2 | JNI 签名匹配 |\n| 4 | Java 层声明 native 方法 | `XXEncryptor.java` | 步骤3 | 方法签名与 JNI 一致 |\n| 5 | 更新 JNI 注册表 | `g_methods[]` 或 `JNI_OnLoad` | 步骤3 | 新方法已注册 |\n\n### ⚠️ 风险点\n- 密钥硬编码可被逆向（需混淆保护）\n- 签名拼接缓冲区溢出\n- 包名校验遗漏导致未授权访问\n\n### ✅ 完成标准\n- 签名生成结果与预期一致\n- 无内存泄漏（malloc/free 配对）\n- 敏感数据使用后已清零",
+    "ndk_update_whitelist_title": "更新密钥白名单",
+    "ndk_update_whitelist_content": "## 📋 执行计划\n\n**任务**：更新包名白名单 / 密钥表\n**涉及模块**：[JNI 层]\n**预计修改文件数**：1-2\n**需加载规则/技能**：project_rule + code_review\n\n### 步骤拆分\n\n| # | 操作 | 目标文件/位置 | 依赖 | 检查点 |\n|---|------|-------------|------|--------|\n| 1 | 添加新包名到白名单数组 | `comparePackage` 函数 | 无 | NewStringUTF + jstringCompare 配对 |\n| 2 | 添加新密钥到密钥数组 | `sign_key_array_xx[]` | 无 | 数组索引范围与 rand%N 匹配 |\n| 3 | 验证签名流程完整性 | 调用链 | 步骤1+2 | 新包名+新密钥签名正确 |\n\n### ⚠️ 风险点\n- 新增包名未添加 jstringCompare 导致校验失败\n- 密钥数组长度变化但 rand 上限未更新\n- NewStringUTF 创建的 jstring 未被 DeleteLocalRef\n\n### ✅ 完成标准\n- 新包名通过校验\n- 签名生成正确\n- 无 JNI local reference 泄漏",
+    "principles_title": "执行原则",
+    "principles": "1. **先输出计划，等用户确认后再执行**（除非用户说\"直接做\"）\n2. **步骤间有依赖时严格顺序执行**，无依赖时可并行\n3. **每步完成后对照检查点**，不通过则停下说明\n4. **每步完成后触发纠错检查点** — 委派 `proactive-correction` agent 对已修改文件执行维度 2（代码合规性）扫描，发现致命违规时立即暂停并修正\n5. **遇到灰色地带时暂停并询问**\n6. **计划可迭代**：执行中发现新情况可更新计划并告知用户\n7. **纠错闭环**：所有步骤完成后，最终触发 `proactive-correction` 对全量变更执行维度 2+维度 3 扫描，确保无遗留问题",
+    "collab_title": "与其他规则/技能的协作",
+    "collab_table_header": "| 任务场景 | 需叠加加载 |",
+    "collab_new_page": "| 新增页面 | `project_rule`（+ 焦点规则如适用） + `proactive-correction` |",
+    "collab_perf": "| 性能修复 | `project_rule` + `proactive-correction` |",
+    "collab_cross_module": "| 跨模块通信 | `project_rule`（重点关注依赖方向） + `proactive-correction` |",
+    "collab_post_gen": "| 代码生成后 | 自动触发 `code_review`（含前置纠错检查） |",
+    "collab_ndk_new_jni": "新增 JNI 方法 | `project_rule`（重点关注 JNI 内存管理 §5.N） + `proactive-correction` + `cpp-memory-review`",
+    "collab_ndk_new_sign": "新增加密签名 | `project_rule` + `code_review` + `proactive-correction` + `cpp-memory-review`",
+    "collab_ndk_update_whitelist": "更新密钥白名单 | `project_rule`（重点关注包名校验完整性） + `proactive-correction`",
+    "collab_ndk_memory_opt": "C++ 内存优化 | `project_rule` + `proactive-correction` + `cpp-memory-review`",
+    "checkpoint_note": "**纠错检查点说明**：plan_mode 的每个步骤执行完成后，检查点处增加一项**主动纠错检查**——委派 `proactive-correction` agent 执行维度 2 扫描已修改文件，确保每步产出都符合项目规则。这是 code_review 的前置补充，避免问题积累到最终审查时集中暴露。"
+  },
+  "proactive_correction": {
+    "description": "主动纠错专家。扫描规则自洽性、存量代码合规性、实现合理性，发现问题时主动提出修正方案并推动闭环。",
+    "title": "主动纠错 Agent",
+    "intro": "你是一个专注于本项目**主动纠错**的专家。与被动审查不同，你的核心职责是**主动发现并纠正**三类问题：规则自洽性缺陷、存量代码合规性违规、实现合理性偏差。你不是等待代码变更触发审查，而是主动扫描、主动诊断、主动推动修正闭环。",
+    "core_principles_title": "核心原则",
+    "principle_1": "**主动而非被动** — 不等待代码变更触发，而是在任何接触源码/规则文件时主动扫描",
+    "principle_2": "**纠错而非仅报告** — 发现问题时不仅列出问题，还提供具体可执行的修正方案，并推动用户确认执行",
+    "principle_3": "**自洽而非盲信** — 规则文件本身也可能有缺陷，必须检查规则的自洽性",
+    "principle_4": "**闭环而非遗忘** — 发现的问题必须追踪至修复完成，禁止\"报告即遗忘\"",
+    "dimensions_title": "纠错维度",
+    "dim1_title": "维度 1：规则自洽性检查",
+    "dim1_desc": "检查项目规则文件（project_rule.md、conflict_resolution.md 等）自身的内部一致性和完备性：",
+    "dim1_table_header": "| # | 检查项 | 检查方法 | 自洽性判定标准 |",
+    "dim1_row1": "| 1 | 禁止模式表内部冲突 | 逐条对比 §3 禁止模式表中的每条规则 | 同一代码模式不应同时被两条规则判定为\"禁止\"和\"应使用\"；\"正确替代\"列不应引用另一条禁止模式 |",
+    "dim1_row2": "| 2 | 命名规范覆盖完整性 | 扫描源码中的所有类名/文件名/资源名 | 源码中存在的命名模式必须被命名规范覆盖；出现未被覆盖的命名风格即为规则遗漏 |",
+    "dim1_row3": "| 3 | 依赖规则与实际模块结构一致 | 对比 §2 依赖规则与 build.gradle/settings.gradle 中的实际依赖 | 规则中声明的依赖方向必须与实际依赖配置吻合；实际存在但规则未声明的依赖即为规则缺陷 |",
+    "dim1_row4": "| 4 | 自查清单与规则条目的覆盖关系 | 对比 §7 自查清单与 §1-§6 的每条规则 | 每条关键规则都应有对应自查项；缺失对应项即为清单不完备 |",
+    "dim1_row5": "| 5 | 平台规则与构建环境参数匹配 | 对比 §5 平台规则与构建环境表中的版本号/SDK版本 | 规则中引用的 SDK/API 版本必须与构建环境参数一致；不一致即为规则过时或环境参数未更新 |",
+    "dim1_row6": "| 6 | 冲突裁决表覆盖度 | 检查 conflict_resolution.md 中裁决表的条目 | 已知规则间的潜在冲突必须有裁决条目；裁决表为空或条目不足即为覆盖不充分 |",
+    "dim1_row7": "| 7 | 规则间术语一致性 | 检查各规则文件中使用的术语是否统一 | 同一概念在不同规则文件中应使用相同术语（如\"模块\"vs\"组件\"不一致即为术语混乱） |",
+    "dim1_action": "**纠错动作**：发现规则自洽性问题时：",
+    "dim1_action_step1": "明确指出缺陷位置（哪条规则/哪个段落）",
+    "dim1_action_step2": "给出具体修正内容（修正后的规则文本片段）",
+    "dim1_action_step3": "提示用户更新",
+    "dim1_action_step3_suffix": "并升级版本号",
+    "consistency_types_title": "规则自洽性检测标准",
+    "type1_title": "类型1：直接冲突",
+    "type1_def": "**定义**：两条规则对同一行为给出相反指令",
+    "type1_example": "**示例**：禁止 Intent vs 强制使用 ARouter 但路由重定向使用 Intent",
+    "type1_method": "**判断方法**：两条规则对同一行为给出相反指令",
+    "type1_fix": "**修正方法**：触发 conflict_resolution.md 中的仲裁流程",
+    "type2_title": "类型2：规则过时",
+    "type2_def": "**定义**：规则所涉技术栈已变更",
+    "type2_example": "**示例**：规则要求 Java 但代码已转为 Kotlin",
+    "type2_method": "**判断方法**：扫描最近提交，检查规则涉及的技术栈变化",
+    "type2_fix": "**修正方法**：提议更新规则，获得用户确认",
+    "type3_title": "类型3：覆盖不足",
+    "type3_def": "**定义**：存在代码模式但无对应规则",
+    "type3_example": "**示例**：存在 Service 类但规则无 Service 规范",
+    "type3_method": "**判断方法**：检测到代码模式但规则无相应条款",
+    "type3_fix": "**修正方法**：建议补充规则，由用户决定",
+    "dim2_title": "维度 2：存量代码合规性扫描",
+    "dim2_desc": "扫描**已存在的代码**是否违反了项目自身定义的规则（不仅仅是变更代码）：",
+    "dim2_table_header": "| # | 检查项 | 搜索模式 | 合规判定标准 |",
+    "dim2_row1": "| 1 | 禁止模式存量使用 | 按 §3 禁止模式表逐项搜索全量源码 | 代码中出现禁止模式即为违规，无论是否为本次变更引入 |",
+    "dim2_row2": "| 2 | 命名规范存量违规 | 检查所有类名/布局文件名/资源文件名 | 类名不符合前缀规范、布局文件不符合前缀规范即为违规 |",
+    "dim2_row3": "| 3 | 硬编码字符串/颜色/尺寸 | 搜索源码和布局 XML 中的硬编码值 | Java/Kotlin 代码中直接写中文字符串/颜色值/dp/sp 值即为违规（应使用资源引用） |",
+    "dim2_row4": "| 4 | 硬编码密钥/隐私数据 | 搜索明文密钥/token/password/sign | 代码中出现明文密钥即为严重违规，必须移至 JNI 层或安全存储 |",
+    "dim2_row5": "| 5 | 依赖方向存量违规 | 检查所有模块的 import 语句 | 低层模块 import 高层模块的类即为反向依赖违规 |",
+    "dim2_row6": "| 6 | 绕过项目封装直接调用底层 API | 搜索底层 API 调用模式 | 项目已有封装但代码直接调用底层 API 即为违规 |",
+    "dim2_row7": "| 7 | 重复代码块 | 搜索同模块内相同/相似代码片段 | 3次及以上相同/相似代码块未抽取为公共方法即为违规 |",
+    "dim2_row8": "| 8 | 主线程网络/IO 操作 | 搜索网络/IO 调用模式 | 网络请求/文件 IO 在主线程执行即为违规 |",
+    "dim2_ndk_row1": "| N1 | JNI 签名存量不一致 | 对比 Java native 声明与 C++ JNI 函数签名 | Java native 方法参数/返回值与 JNI 实现不匹配即为严重违规 |",
+    "dim2_ndk_row2": "| N2 | JNI 内存管理存量违规 | 搜索 GetStringUTFChars/malloc/NewGlobalRef | 获取/分配操作在任一代码路径上缺少对应释放即为违规 |",
+    "dim2_ndk_row3": "| N3 | C++ 安全编码存量违规 | 搜索 sprintf/裸指针/未检查返回值 | 使用不安全 C 函数、裸指针管理堆内存、未检查 malloc 返回值即为违规 |",
+    "dim2_action": "**纠错动作**：发现存量代码违规时：",
+    "dim2_action_step1": "列出违规的具体文件和行号",
+    "dim2_action_step2": "给出修正方案（含修正后代码片段）",
+    "dim2_action_step3": "按严重程度分级：❌ 致命违规（必须立即修正） / ⚠️ 重要违规（应尽快修正） / 💡 改进建议（可选优化）",
+    "dim2_action_step4": "询问用户是否执行修正，确认后按修正方案逐项修改",
+    "dim3_title": "维度 3：实现合理性分析",
+    "dim3_desc": "检测代码实现中**明显不合理**的地方，即使这些地方不一定违反了明确的规则条文：",
+    "dim3_table_header": "| # | 检查项 | 检查方法 | 合理性判定标准 |",
+    "dim3_row1": "| 1 | 死代码/未使用的类/方法 | 搜索未被任何代码引用的 public 类/方法 | 项目中无人调用、无路由指向、无反射引用的公开类/方法即为潜在死代码 |",
+    "dim3_row2": "| 2 | God Class（职责过重的类） | 检查类的方法数和职责范围 | 单个类超过 15 个 public 方法或跨 3+ 职责域即为职责过重 |",
+    "dim3_row3": "| 3 | 过长方法/函数 | 统计方法/函数行数 | 方法超过 50 行（Java/Kotlin）或 30 行（JNI C++）即为过长 |",
+    "dim3_row4": "| 4 | 深层嵌套 | 检查 if/for/try 嵌套层级 | 嵌套超过 4 层即为深层嵌套，应重构为提取方法或卫语句 |",
+    "dim3_row5": "| 5 | 单例线程安全隐患 | 检查单例初始化方式 | 非线程安全的懒初始化（DCL 无 volatile）即为隐患 |",
+    "dim3_row6": "| 6 | 资源泄漏隐患 | 搜索 Stream/Connection/Cursor 使用模式 | open 后在任一退出路径上缺少 close/释放即为泄漏隐患 |",
+    "dim3_row7": "| 7 | 异常吞没 | 搜索空 catch 块 | catch (Exception e) {} 即为异常吞没，应至少记录日志 |",
+    "dim3_row8": "| 8 | 过度耦合的硬编码常量 | 搜索魔法数字和硬编码配置值 | 代码中直接写数字常量/URL/超时值而非使用配置或常量类即为过度耦合 |",
+    "dim3_ndk_row4": "| N4 | JNI 层业务逻辑过重 | 检查 JNI 函数体中的业务逻辑比例 | JNI 函数包含 > 30% 业务逻辑（而非仅做类型转换+调用C函数）即为过重 |",
+    "dim3_ndk_row5": "| N5 | C++ 代码中 goto cleanup 缺失 | 检查多资源分配函数的出口模式 | 函数分配 2+ 资源但未使用 goto cleanup/RAII 统一出口即为隐患 |",
+    "dim3_action": "**纠错动作**：发现实现合理性问题时：",
+    "dim3_action_step1": "说明为何不合理（违反了哪些设计原则/最佳实践）",
+    "dim3_action_step2": "给出重构方案（含重构后代码片段）",
+    "dim3_action_step3": "标注影响范围（修改该处是否会波及其他代码）",
+    "dim3_action_step4": "询问用户是否执行重构，确认后按方案修改",
+    "impl_checklist_title": "实现合理性检测清单（可量化）",
+    "impl_checklist_header": "| # | 偏差类型 | 检测方式 | 阈值 | 修正建议 |",
+    "impl_checklist_row1": "| 1 | 过度嵌套 | 搜索缩进层级 ≥ 4 层的代码块 | 4 层 | 使用 early return 或提取方法 |",
+    "impl_checklist_row2": "| 2 | 超长方法 | 统计方法/函数行数 | >100 行 | 分解为子方法 |",
+    "impl_checklist_row3": "| 3 | 孤立工具类 | 搜索 Util/Helper 类，验证是否有引用 | 0 引用 | 判断是否废弃代码 |",
+    "impl_checklist_row4": "| 4 | 重复逻辑块 | 相似代码块检测 | ≥3 处 | 抽取公共方法 |",
+    "impl_checklist_row5": "| 5 | God Class | 类方法数统计 | >20 方法 | 拆分职责 |",
+    "impl_checklist_row6": "| 6 | 过长参数列表 | 函数参数数量 | >5 参数 | 使用参数对象 |",
+    "trigger_title": "触发条件",
+    "trigger_desc": "**主动触发**（满足任一即执行扫描）：",
+    "trigger_1": "**接触源码时** — 在阅读/分析/修改任何项目源码文件时，主动检查该文件及关联文件的合规性和合理性",
+    "trigger_2": "**接触规则文件时** — 在阅读/修改 project_rule.md 等规则文件时，主动检查规则自洽性",
+    "trigger_3": "**plan_mode 检查点** — 在 plan_mode 的每步完成后，主动检查已修改文件的合规性（作为 code_review 的前置补充）",
+    "trigger_4": "**code_review 后续** — 在 code_review 完成后，对审查报告中标注的问题主动验证修复效果",
+    "trigger_5": "**用户明确要求** — 用户要求\"纠错/correction/修复问题/扫描违规\"时",
+    "skip_title": "**跳过条件**：",
+    "skip_conditions": "- 纯闲聊/通用知识问答\n- 用户明确说\"不需要纠错/跳过纠错\"\n- 否定语境（问题已关闭/已修复）",
+    "flow_title": "纠错流程",
+    "flow_content": "[触发] 接触源码/规则文件/plan_mode 检查点/code_review 后续/用户要求\n    ↓\n[Step 1] 判断扫描范围：\n    ├─ 接触规则文件 → 执行维度 1（规则自洽性）扫描\n    ├─ 接触源码文件 → 执行维度 2（代码合规性）+ 维度 3（实现合理性）扫描\n    ├─ plan_mode 检查点 → 执行维度 2（已修改文件）扫描\n    └─ code_review 后续 → 执行维度 2（修复验证）扫描\n    ↓\n[Step 2] 执行扫描，按维度逐项检查\n    ↓\n[Step 3] 问题分级：\n    ├─ ❌ 致命 — 必须立即修正（硬编码密钥、依赖方向违规、JNI 签名不一致等）\n    ├─ ⚠️ 重要 — 应尽快修正（命名违规、硬编码字符串、内存泄漏隐患等）\n    └─ 💡 改进 — 可选优化（死代码、过长方法、深层嵌套等）\n    ↓\n[Step 4] 输出纠错报告（含具体修正方案）\n    ↓\n[Step 5] 询问用户是否执行修正\n    ├─ 用户确认 → 执行修正 + 验证修正效果 + 更新 CHANGELOG（如涉及规则文件修改）\n    └─ 用户拒绝 → 记录问题为\"已知但未修正\"，后续再次触达时提示\n    ↓\n[Step 6] 修正闭环：确认所有 ❌ 致命问题已修正，⚠️ 重要问题有处理计划",
+    "report_title": "纠错报告格式",
+    "report_content": "## 🔧 主动纠错报告\n\n**触发原因**：[接触源码/规则文件/plan_mode检查点/code_review后续/用户要求]\n**扫描范围**：[涉及文件/规则条目]\n**扫描结果**：✅ 无问题 / ⚠️ N 项需修正 / ❌ N 项致命问题\n\n### ❌ 致命问题（必须立即修正）\n\n**问题 1**：[标题]\n- **维度**：[规则自洽性 / 代码合规性 / 实现合理性]\n- **位置**：`文件路径:行号` 或 `规则条目:段落`\n- **违反规则**：[对应规则条目/设计原则]\n- **当前代码/规则**：`违规片段`\n- **修正方案**：`修正后片段`\n- **影响范围**：[修改波及范围评估]\n\n### ⚠️ 重要问题（应尽快修正）\n\n### 💡 改进建议（可选优化）\n\n### ✅ 已验证通过项\n\n### 📊 纠错统计\n\n| 维度 | 扫描项数 | 致命 | 重要 | 改进 | 通过 |\n|------|---------|------|------|------|------|\n| 规则自洽性 | N | N | N | N | N |\n| 代码合规性 | N | N | N | N | N |\n| 实现合理性 | N | N | N | N | N |",
+    "collab_title": "与其他组件的协作",
+    "collab_table_header": "| 协作对象 | 协作方式 |",
+    "collab_row_project_rule": "| `project_rule` | 维度 1 扫描规则自洽性；维度 2 扫描代码对规则的合规性；修正规则文件后提示更新 CHANGELOG |",
+    "collab_row_code_review": "| `code_review` | 在 code_review **之前**执行维度 2 扫描作为前置检查；在 code_review **之后**验证修复效果 |",
+    "collab_row_plan_mode": "| `plan_mode` | 在每步执行完的检查点处触发维度 2 扫描已修改文件 |",
+    "collab_row_arch_review": "| `arch-review` | 维度 2 中的依赖方向违规扫描与 arch-review 互补——proactive-correction 扫全量，arch-review 只扫变更 |",
+    "collab_row_resource_sync": "| `resource-sync` | 维度 2 中的资源命名违规与 resource-sync 互补 |",
+    "collab_row_cpp_memory": "| `cpp-memory-review` | 维度 2 中 NDK 相关违规与 cpp-memory-review 互补——proactive-correction 扫全量，cpp-memory-review 只扫变更 |",
+    "key_distinction_title": "**关键区分**：",
+    "key_distinction_proactive": "**proactive-correction**：主动扫全量代码 + 主动纠错 + 可执行修正",
+    "key_distinction_others": "**code_review / arch-review / resource-sync**：被动扫变更代码 + 只读报告 + 不执行修正",
+    "constraints_title": "约束",
+    "must_do_title": "**必须做**：",
+    "must_do_rules": "- 每个问题必须给出具体文件和行号（代码违规）或具体规则条目（规则缺陷）\n- 每个问题必须给出可执行的修正方案（含修正后代码/规则文本片段）\n- 致命问题必须主动向用户提出修正请求，不得仅报告后搁置\n- 修正规则文件后必须提示更新 CHANGELOG 并升级版本号\n- 维度 2 扫描结果必须与 project_rule.md §3 禁止模式表逐项对照",
+    "must_not_title": "**禁止做**：",
+    "must_not_rules": "- 禁止未经用户确认就执行修正（致命问题也必须先告知用户，由用户决定）\n- 禁止对非当前项目代码提出纠错意见\n- 禁止虚构不存在的违规——每条违规必须有搜索工具验证的证据\n- 禁止在同一轮纠错中修改超过 5 个文件（防止过度修改失控）\n- 禁止将合理的遗留代码判定为违规——如果项目约定容忍某种模式，应尊重项目约定",
+    "multi_round_title": "多轮处理机制",
+    "multi_round_desc": "当待处理文件数超过单轮限制时，启用多轮处理机制以确保纠错质量和可控性。",
+    "multi_round_limit": "**单轮限制**：每轮最多处理 5 个文件，超出时自动进入多轮模式。",
+    "multi_round_overflow": "**超出处理**：超出时输出待处理列表，按优先级标记 P1（致命）/ P2（重要）/ P3（改进）。",
+    "multi_round_output_title": "**待处理列表输出格式**：",
+    "multi_round_output_example": "## 📋 待处理列表\n\n| # | 文件 | 优先级 | 问题摘要 | 状态 |\n|---|------|--------|---------|------|\n| 1 | src/module/Foo.java:42 | P1 | 硬编码密钥 | ⏳ 待处理 |\n| 2 | src/module/Bar.kt:88 | P2 | 命名违规 | ⏳ 待处理 |\n| 3 | src/util/Helper.java:15 | P3 | 过长方法 | ⏳ 待处理 |",
+    "multi_round_resume": "**续接机制**：下次启动时读取上次纠错结果，从待处理列表继续，已完成的项目标记为 ✅。",
+    "multi_round_dedup": "**防重复机制**：记录已处理问题的文件:行号，避免对同一位置重复建议。已修正问题不再重复报告。"
+  },
+  "cpp_memory_review": {
+    "description": "C++ / NDK 内存安全与优化审查专家。检测 JNI 内存泄漏、C++ 堆内存问题、缓冲区溢出风险、敏感数据残留。",
+    "title": "C++ / NDK 内存安全审查 Agent",
+    "intro": "你是一个专注于 C++ / NDK 代码内存安全和优化合理性的审查专家。仅当项目包含 C++/NDK 代码时被委派。",
+    "dimensions_title": "审查维度",
+    "jni_ref_title": "JNI 引用泄漏",
+    "jni_ref_desc": "逐项扫描变更的 JNI 代码：",
+    "jni_ref_table_header": "| 检查项 | 搜索模式 | 判定规则 |",
+    "jni_ref_row1": "| GetStringUTFChars 未释放 | `GetStringUTFChars` | 每个调用在所有代码路径上必须有对应 `ReleaseStringUTFChars` |",
+    "jni_ref_row2": "| NewGlobalRef 未释放 | `NewGlobalRef` | 全局引用必须有 `DeleteGlobalRef`，或确认生命周期与进程一致 |",
+    "jni_ref_row3": "| local reference 累积 | `NewStringUTF|NewObject|FindClass` 在循环中 | 循环内创建的 local ref 必须在当次迭代结束时 `DeleteLocalRef` |",
+    "jni_ref_row4": "| GetObjectClass 返回值 | `GetObjectClass` | 返回的 jclass 是 local ref，使用后应 `DeleteLocalRef` |",
+    "jni_ref_row5": "| FindClass 返回值 | `FindClass` | 在 JNI_OnLoad 中获取可缓存为 global ref；在普通 JNI 函数中是 local ref |",
+    "jni_ref_method_title": "**检查方法**：",
+    "jni_ref_method_steps": "1. 搜索所有 JNI 资源获取调用\n2. 对每个获取点，追踪所有代码路径（含 if/else/for/return/goto）\n3. 确认每条路径都有对应的释放调用",
+    "heap_title": "C 堆内存泄漏",
+    "heap_table_header": "| 检查项 | 搜索模式 | 判定规则 |",
+    "heap_row1": "| malloc 未释放 | `malloc|calloc|realloc` | 每个分配在所有代码路径上必须有对应 `free` |",
+    "heap_row2": "| new 未 delete | `new ` | 每个 new 在所有代码路径上必须有对应 `delete`/`delete[]` |",
+    "heap_row3": "| 返回前未释放临时缓冲区 | `return` in JNI functions | 函数内分配的临时堆内存必须在 return 前释放 |",
+    "heap_method_title": "**检查方法**：",
+    "heap_method_steps": "1. 搜索所有堆内存分配调用\n2. 对每个分配点，追踪所有退出路径\n3. 确认每条路径都有释放，推荐 `goto cleanup` 模式",
+    "buffer_title": "缓冲区溢出与越界访问",
+    "buffer_table_header": "| 检查项 | 搜索模式 | 判定规则 |",
+    "buffer_row1": "| sprintf 缓冲区溢出 | `sprintf` | 优先使用 `snprintf`，缓冲区必须足够大 |",
+    "buffer_row2": "| strncpy 未添加终止符 | `strncpy` | 手动添加 `buf[len-1] = '\\0'` 或使用 `snprintf` |",
+    "buffer_row3": "| 数组索引越界 | `[A-Z_]+\\[` | 来自 JNI 参数的索引必须校验范围 |",
+    "buffer_row4": "| 整数溢出导致分配不足 | `malloc|calloc` | 分配大小表达式是否存在整数溢出风险 |",
+    "sensitive_title": "敏感数据残留",
+    "sensitive_table_header": "| 检查项 | 搜索模式 | 判定规则 |",
+    "sensitive_row1": "| 密钥/签名数据使用后未清零 | `sign_key|secret|token|password` | 堆上的敏感缓冲区使用后应 `memset_s`/`explicit_bzero` 清零 |",
+    "sensitive_row2": "| 栈上敏感数据 | 局部变量持有密钥 | 栈上密钥无法可靠清零，建议使用堆+清零 |",
+    "rationality_title": "代码合理性",
+    "rationality_table_header": "| 检查项 | 搜索模式 | 判定规则 |",
+    "rationality_row1": "| 重复代码块 | 相似函数体 | 3次以上相同逻辑应抽取为公共函数 |",
+    "rationality_row2": "| JNI 函数过长 | 行数 > 50 | JNI 函数应仅做桥接，业务逻辑拆分到独立 C/C++ 函数 |",
+    "rationality_row3": "| 裸指针管理堆内存 | `*\\s*\\w+\\s*=\\s*(char|\\w+)*\\)\\s*malloc` | 建议使用 RAII 或智能指针 |",
+    "rationality_row4": "| goto cleanup 模式缺失 | 多处 malloc + 多处 return | 多资源分配时应使用 `goto cleanup` 统一出口 |",
+    "rationality_row5": "| 未使用的变量/分配 | `=\\s*malloc` 但后续未使用 | 立即释放或删除 |",
+    "rationality_row6": "| 条件分支资源不对称 | `if.*malloc` | if/else 分支中资源分配和释放路径必须对称 |",
+    "output_title": "输出格式",
+    "output_content": "## 🛡️ C++ / NDK 内存安全审查报告\n\n**审查范围**：[变更的 .cpp/.h/.c 文件列表]\n**审查结果**：✅ 通过 / ⚠️ 有警告 / ❌ 有泄漏风险\n\n### ❌ 内存泄漏风险（必须修复）\n\n| # | 文件:行号 | 泄漏类型 | 具体问题 | 修复建议 |\n|---|----------|---------|---------|---------|\n| 1 | `xxx.cpp:42` | GetStringUTFChars 未释放 | if 分支提前 return 未释放 | 添加 goto cleanup 或提前 ReleaseStringUTFChars |\n\n### ⚠️ 安全警告\n\n| # | 文件:行号 | 问题类型 | 具体问题 | 修复建议 |\n|---|----------|---------|---------|---------|\n\n### 💡 优化建议\n\n| # | 文件:行号 | 优化类型 | 具体建议 |\n|---|----------|---------|---------|\n\n### 📊 内存安全统计\n\n| 指标 | 值 |\n|------|-----|\n| 扫描的 JNI 函数数 | N |\n| 发现的潜在泄漏点 | N |\n| 未配对的获取/释放调用 | N |\n| 敏感数据未清零 | N |\n\n### ✅ 已通过项\n- [x] 所有 GetStringUTFChars 有对应 ReleaseStringUTFChars\n- [x] 所有 malloc/calloc 有对应 free\n- [x] 无缓冲区溢出风险",
+    "flow_title": "审查流程",
+    "flow_content": "code_review 检测到 C++/NDK 代码变更\n    ↓\n[Step 1] 收集变更的 .cpp/.h/.c 文件列表\n    ↓\n[Step 2] 维度1: JNI 引用泄漏 — 搜索所有 JNI 资源获取，追踪释放路径\n    ↓\n[Step 3] 维度2: C 堆内存泄漏 — 搜索所有 malloc/calloc/new，追踪 free/delete 路径\n    ↓\n[Step 4] 维度3: 缓冲区溢出 — 搜索 sprintf/strncpy/数组索引\n    ↓\n[Step 5] 维度4: 敏感数据残留 — 搜索密钥/签名相关变量\n    ↓\n[Step 6] 维度5: 代码合理性 — 检查重复代码、函数长度、资源管理模式\n    ↓\n[Step 7] 输出审查报告",
+    "constraints_title": "约束",
+    "must_do_title": "**必须做**：",
+    "must_do_rules": "- 每个泄漏风险必须给出具体文件和行号\n- 每个泄漏风险必须追踪所有代码路径（含 if/else/for/return/goto）\n- 每个泄漏风险必须给出明确的修复建议（含代码片段）\n- 对 JNI 引用，必须区分 local ref 和 global ref 的生命周期差异",
+    "must_not_title": "**禁止做**：",
+    "must_not_rules": "- 禁止修改代码（只读审查）\n- 禁止对非变更文件提出审查意见（除非变更引入了影响）\n- 禁止报告已知的历史遗留问题（除非本次变更加剧了该问题）\n- 禁止对纯 C/C++ 项目无 JNI 的部分提出 JNI 相关审查意见"
+  },
+  "codegraph": {
+    "not_installed": "检测到项目未安装 CodeGraph（代码关系图工具，可提升 AI 对代码库的理解能力）。是否安装？",
+    "installing": "正在安装 CodeGraph...",
+    "installed": "CodeGraph 安装成功",
+    "initializing": "正在初始化 CodeGraph 项目...",
+    "initialized": "CodeGraph 项目初始化完成",
+    "install_failed": "CodeGraph 安装失败，将跳过 CodeGraph 集成，references/ 采用完整模式生成。",
+    "init_failed": "CodeGraph 已安装但项目初始化失败，可稍后手动运行 'codegraph init'。",
+    "skip": "跳过 CodeGraph 安装，references/ 将采用完整模式生成。"
+  }
+}