ai-scaffold-pro 1.1.1

package/i18n/en.json

@@ -0,0 +1,536 @@
+{
+  "changelog": {
+    "title": "Changelog",
+    "format_line1": "Format: vX.Y.Z (YYYY.MM.DD)",
+    "format_line2": "X = Architecture refactor | Y = Feature change | Z = Patch",
+    "added_entry": "Project overview, build commands, rules and skill trigger strategy",
+    "added_project_rule": "main development rules",
+    "added_conflict_resolution": "Rule conflict resolution mechanism",
+    "added_plan_mode": "Structured task decomposition skill",
+    "added_code_review": "Code review skill",
+    "added_arch_review": "Architecture compliance review agent",
+    "added_resource_sync": "Resource sync verification agent",
+    "added_proactive_correction": "Proactive correction agent (rule self-consistency + existing code compliance + implementation rationality scan, can execute fixes)",
+    "added_post_edit_tracker": "Edit tracking hook",
+    "added_check_review": "Review reminder hook",
+    "added_settings": "Hook registration config",
+    "added_gen_references": "Module reference doc auto-generation script",
+    "added_references": "Module reference documentation"
+  },
+  "project_rule": {
+    "title": "Development Rules",
+    "scope": "**Scope**: Code generation, modification, review, refactoring operations.",
+    "skip_conditions": "**Skip conditions**: Casual chat, general knowledge Q&A, non-code discussions, negative context.",
+    "negative_title": "Negative Keyword Protection",
+    "negative_table_header": "| Negative Pattern | Example | Reason |",
+    "negative_row1": "| General concept discussion | \"What's the difference between X and Y in principle?\" | General Q&A |",
+    "negative_row2": "| Analogy/comparison | \"How does this mechanism work in similar projects?\" | External project discussion |",
+    "negative_row3": "| Explicit exclusion | \"Help me review the code logic, no need to check standards\" | User exclusion |",
+    "negative_row4": "| Closed context | \"That issue has been resolved\" | Issue closed |",
+    "conduct_title": "Code of Conduct",
+    "conduct_search_first": "**Search before writing**: Before generating code, read the target module documentation in",
+    "conduct_search_first_suffix": "to confirm class names, method names, and paths actually exist",
+    "conduct_no_fabrication": "**No fabrication**: Do not use classes/methods/constants/paths that don't exist in the project; when uncertain, verify with search tools",
+    "conduct_no_new_deps": "**No new dependencies**: Only use third-party libraries listed in",
+    "conduct_no_new_deps_suffix": "",
+    "conduct_reuse": "**Prioritize existing utilities**: Existing wrappers must be used; do not bypass them to re-implement",
+    "conduct_confirm": "**Confirm when uncertain**: Ask the user when encountering gray areas; do not make decisions independently",
+    "proactive_title": "Proactive Correction Guidelines",
+    "proactive_scan": "**Proactive scanning, not passive waiting**: When touching any source file or rule file, proactively check compliance and rationality rather than waiting for review triggers",
+    "proactive_fix": "**Fix when found, don't just report**: When finding rule consistency defects, code compliance violations, or implementation rationality issues, provide specific fix proposals and push for closure, not just list problems",
+    "proactive_rules": "**Rules are not infallible**: Rule files themselves may have defects (internal contradictions, omissions, outdated); proactively point these out and propose corrections when found",
+    "proactive_closure": "**Correction closure, not forgetting**: Fatal issues must be tracked until fixed; no \"report and forget\"",
+    "proactive_confirm": "**User confirmation required for corrections**: Notify the user before executing fixes; user decides whether to proceed; no unconfirmed auto-modifications",
+    "proactive_limit": "**Max 5 files per correction round**: To prevent uncontrolled over-modification, correct at most 5 files per round",
+    "arch_title": "Architecture Constraints",
+    "arch_dep_title": "Module Dependency Direction",
+    "arch_comm_title": "Inter-Module Communication",
+    "arch_comm_desc": "Use specified mechanism for cross-module communication. Direct imports between business modules are prohibited.",
+    "arch_inherit_title": "Inheritance Hierarchy",
+    "forbidden_title": "Forbidden Patterns",
+    "forbidden_desc": "The following patterns are **strictly prohibited** in project code:",
+    "forbidden_table_header": "| # | Forbidden Pattern | Correct Alternative | Reason |",
+    "naming_title": "Naming Conventions",
+    "naming_resource_title": "Resource Prefixes",
+    "naming_class_title": "Class/File Naming",
+    "naming_layout_title": "Layout Naming",
+    "platform_title": "Specific Rules",
+    "ndk_title": "C++ / NDK Specific Rules",
+    "ndk_jni_memory_title": "JNI Memory Management",
+    "ndk_jni_memory_desc": "JNI layer involves C heap memory and JNI references — both cannot be recovered by GC after leaking. Strictly follow these rules:",
+    "ndk_jni_memory_table_header": "| # | Rule | Description |",
+    "ndk_jni_memory_row1": "| 1 | GetStringUTFChars must pair with ReleaseStringUTFChars | Ensure release after acquisition; recommend `goto cleanup` pattern for unified release point |",
+    "ndk_jni_memory_row2": "| 2 | malloc/calloc/realloc must pair with free | Every malloc must have corresponding free, including all branch paths |",
+    "ndk_jni_memory_row3": "| 3 | Local references from NewStringUTF/NewObject should be promptly DeleteLocalRef | Excessive local references can overflow the reference table; clean up unused local refs before function return |",
+    "ndk_jni_memory_row4": "| 4 | GetStringUTFChars return value must be null-checked | When returning NULL, cannot be used for string operations; return early or goto cleanup |",
+    "ndk_jni_memory_row5": "| 5 | NewGlobalRef must pair with DeleteGlobalRef | Global references must be released when no longer needed; otherwise permanent leak |",
+    "ndk_jni_memory_row6": "| 6 | No access to released resources after goto cleanup | After cleanup label: only release and return, never use any released pointer/reference |",
+    "ndk_jni_coding_title": "JNI Coding Standards",
+    "ndk_jni_coding_table_header": "| # | Rule | Description |",
+    "ndk_jni_coding_row1": "| 1 | JNI method signature must match Java native declaration | Parameter types and return types must strictly match; signature errors during registration cause UnsatisfiedLinkError |",
+    "ndk_jni_coding_row2": "| 2 | Register native methods in JNI_OnLoad preferred over static binding | Dynamic registration (RegisterNatives) should be done in JNI_OnLoad |",
+    "ndk_jni_coding_row3": "| 3 | Do not cache JNIEnv pointer in JNI layer | JNIEnv is thread-local; cross-thread use requires JavaVM->AttachCurrentThread |",
+    "ndk_jni_coding_row4": "| 4 | C++ exceptions must not cross JNI boundary | JNI functions must catch all C++ exceptions; no exception propagation to JVM |",
+    "ndk_memory_safety_title": "C++ Memory Safety and Optimization",
+    "ndk_memory_safety_row1": "No raw pointers for heap memory management | Prefer std::unique_ptr / std::shared_ptr, or project-standard RAII wrappers",
+    "ndk_memory_safety_row2": "Array operations must have bounds checking | No unchecked index access to arrays, especially for indices from JNI layer",
+    "ndk_memory_safety_row3": "String operations must ensure buffer sufficiency | sprintf/snprintf target buffer must have enough space; prefer snprintf to prevent overflow",
+    "ndk_memory_safety_row4": "No returning pointers/references to stack-local variables | Stack memory is invalid after function return; must use heap allocation or value return",
+    "ndk_memory_safety_row5": "Large memory allocations should check return value | malloc/calloc/new returns NULL on failure; must handle exceptions",
+    "ndk_memory_safety_row6": "Sensitive data must be zeroed after use | Key, token and other sensitive memory regions must be cleared with memset_s/SecureZeroMemory after use",
+    "ndk_build_title": "NDK Build Standards",
+    "ndk_build_row2": "so library name must match System.loadLibrary parameter | Remove lib prefix and .so suffix",
+    "ndk_build_row3": "ABI architectures must cover target devices | Common combination: armeabi-v7a + arm64-v8a, adjust as needed",
+    "ndk_build_row4": "NDK path via local.properties ndk.dir | No hardcoding NDK paths in build scripts",
+    "ndk_build_row5": "Compiler optimization flags should match build type | Debug uses -O0 -g, Release uses -O2/-O3",
+    "ndk_build_row6": "Security compile options must be enabled | -fstack-protector-all, -fvisibility=hidden and other security hardening options",
+    "quality_title": "Code Implementation Quality Rules",
+    "quality_rules": "- 3+ identical/similar code blocks in the same module must be extracted to a common method\n- No copy-paste coding\n- Prioritize reusing existing classes\n- Singleton pattern consistency (Kotlin lazy(SYNCHRONIZED) / Java inner class holder)",
+    "quality_ndk_title": "C++ / NDK Code Quality Rules",
+    "quality_ndk_rules": "- 3+ identical/similar code blocks in JNI functions (e.g., package name validation, signature concatenation) must be extracted to C-layer common functions\n- C++ function resource allocation and release must be symmetric; recommend `goto cleanup` unified exit pattern\n- No inline large business logic in JNI functions; split into independent C/C++ functions called by JNI layer\n- Sensitive key arrays should use `__attribute__((section(\".mytext\")))` or equivalent obfuscation protection",
+    "checklist_title": "Code Self-Check Checklist",
+    "checklist_desc": "After each code change, verify item by item:",
+    "checklist_table_header": "| # | Check Item |",
+    "checklist_row1": "| 1 | Referenced classes/methods actually exist in the project? |",
+    "checklist_row2": "| 2 | Module dependency direction correct? |",
+    "checklist_row3": "| 3 | No forbidden pattern usage? |",
+    "checklist_row4": "| 4 | No hardcoded route paths/SP keys/colors/dimensions/localized strings? |",
+    "checklist_row5": "| 5 | Correct logging tool selection? |",
+    "checklist_row6": "| 6 | No duplicate code blocks? |",
+    "checklist_rowC1": "| C1 | Proactive correction scan executed? (delegate `proactive-correction` agent) |",
+    "checklist_rowC2": "| C2 | Fatal violations found have been fixed and closed? |",
+    "checklist_rowC3": "| C3 | Rule self-consistency verified? (must check when touching rule files) |",
+    "checklist_ndk_row1": "NDK build config correct (ndk.dir, ABI coverage, security compile options)?",
+    "checklist_ndk_row2": "JNI method signatures match Java native methods?",
+    "checklist_ndk_row3": "JNI GetStringUTFChars / ReleaseStringUTFChars properly paired?",
+    "checklist_ndk_row4": "JNI malloc / free properly paired (including all branch paths)?",
+    "checklist_ndk_row5": "JNI GetStringUTFChars return value null-checked?",
+    "checklist_ndk_row6": "JNI local references promptly DeleteLocalRef when bulk-created?",
+    "checklist_ndk_row7": "JNI NewGlobalRef / DeleteGlobalRef properly paired?",
+    "checklist_ndk_row8": "C++ heap memory allocation return value checked?",
+    "checklist_ndk_row9": "Sensitive data (keys/tokens) zeroed after use?",
+    "checklist_ndk_row10": "C++ exceptions don't cross JNI boundary?",
+    "config_title": "Configuration Change Management",
+    "config_desc": "Any configuration file modification under",
+    "config_desc_suffix": "directory **must**:",
+    "config_step1": "Update",
+    "config_step1_suffix": "(Keep a Changelog format)",
+    "config_step2_prefix": "Bump",
+    "config_step2_suffix": "first-line version number",
+    "config_version_table_header": "| Change Type | Version Bump |",
+    "config_version_row1": "| Architecture-level refactor | X |",
+    "config_version_row2": "| Feature change (new rules/skills/hooks/docs) | Y |",
+    "config_version_row3": "| Patch (fix/supplement) | Z |",
+    "config_scope": "**Scope**:",
+    "config_scope_table_header": "| File | Description |",
+    "config_scope_entry": "Entry dispatch layer",
+    "config_scope_rules": "Rule files",
+    "config_scope_skills": "Skill files",
+    "config_scope_agents": "Agent configurations",
+    "config_scope_hooks": "Hook scripts",
+    "config_scope_settings": "Hook/permission configuration",
+    "config_scope_references": "Reference documentation",
+    "config_scope_scripts": "Utility scripts",
+    "conduct_codegraph_search": "**Use codegraph_explore to search the codebase**: Before modifying code, use the codegraph_explore tool to search for relevant classes/methods/symbols and verify they actually exist. Complement with",
+    "conduct_codegraph_search_suffix": "for architecture decisions and business conventions",
+    "conduct_codegraph_lightweight": "**references/ is in lightweight mode**: Contains only architecture decisions, business logic summaries, and project conventions. Full file lists and directory trees are replaced by CodeGraph's structural exploration capability."
+  },
+  "conflict_resolution": {
+    "title": "Rule Conflict Resolution",
+    "desc": "This file defines the priority arbitration mechanism when multiple rules are loaded simultaneously.",
+    "desc2": "Each rule file header declares `id`, `domains`, and `priority` via HTML comments.",
+    "priority_title": "Priority Principles",
+    "priority_1": "**Domain-specific rules override general rules** — narrower domain wins within its territory",
+    "priority_2": "**Higher priority value wins within overlapping domains** — only compared when domains overlap",
+    "priority_3": "**Rules stack by default, only conflicting items are arbitrated** — non-conflicting parts are all retained",
+    "priority_4": "**Conflicts not covered by arbitration table → ask user** — register to this table after confirmation",
+    "domain_title": "Current Rule Domain Registration",
+    "domain_table_header": "| Rule ID | Priority | Domains |",
+    "conflict_table_title": "Known Conflict Arbitration Table",
+    "conflict_table_header": "| # | Conflict Scenario | Rule A Guidance | Rule B Guidance | Decision | Reason |",
+    "conflict_row1": "| 1 | proactive-correction finds fatal violation vs. code_review only reports | proactive-correction proposes fixes and pushes for closure | code_review only reports | proactive-correction priority | Fatal issues must be closed; reporting alone leaves issues unresolved |",
+    "conflict_row2": "| 2 | proactive-correction scans all code vs. arch-review scans only changes | proactive-correction scans all code | arch-review scans only changes | Each does its job | Full-scan and change-introduced violations are different in nature |",
+    "conflict_row3": "| 3 | proactive-correction finds rule consistency defect vs. project_rule forbidden patterns | proactive-correction believes rules have gaps/contradictions | project_rule defines current forbidden patterns | project_rule priority, but proactive-correction should record and alert user | Rules are user-defined; agents cannot modify rules, but must proactively remind |",
+    "conflict_row4": "| 4 | proactive-correction requests fix vs. user refuses | proactive-correction pushes for fix closure | User chooses not to fix | User decision priority | Corrections require user confirmation; user has right to refuse |",
+    "conflict_row5": "| 5 | proactive-correction 5-file limit per round vs. more violations found | proactive-correction limits to 5 files per round | Actually >5 violation files | 5-file limit priority; remaining violations recorded as \"known but not fixed\" | Prevent uncontrolled over-modification; handle in multiple rounds |",
+    "conflict_row6": "| 6 | plan_mode correction checkpoint vs. user says \"just do it\" | plan_mode triggers correction scan after each step | User wants to skip checks | User priority, but fatal issues still flagged | User controls workflow pace, but fatal issues cannot be silently ignored |",
+    "conflict_row_other": "| — | Others TBD | — | — | — | To be supplemented as project evolves |",
+    "registration_title": "New Rule Registration Process",
+    "registration_steps": "1. Add `id`, `domains`, `priority` metadata comments to new rule file header\n2. Register in Domain Registration table\n3. Check new rule domains for intersections with existing rules\n4. Identify conflict points and register in arbitration table\n5. Arbitration principle: narrower/more specialized domain rules take priority",
+    "registration_step6_prefix": "Add trigger conditions and core constraint summary in",
+    "registration_step6_suffix": "",
+    "maintenance_title": "Arbitration Table Maintenance",
+    "maintenance_rules": "- AI should alert user and record when encountering uncovered conflicts in actual scenarios\n- Arbitration table updates must sync with",
+    "maintenance_rules_suffix": "- Arbitration reasons must be stated; no empty entries allowed"
+  },
+  "arch_review": {
+    "description": "Architecture compliance review expert. Detects module dependency direction violations, forbidden pattern usage, cross-module communication compliance.",
+    "title": "Architecture Compliance Review Agent",
+    "intro": "You are a review expert focused on architecture compliance for the",
+    "intro_suffix": "project.",
+    "dimension_title": "Review Dimensions",
+    "dep_title": "Module Dependency Direction",
+    "dep_check_title": "Check principles:",
+    "dep_check_method": "Check method:\n- In changed file import statements, confirm each imported package's module exists in current module's dependency configuration\n- Search for reverse dependencies",
+    "forbidden_title": "Forbidden Pattern Detection",
+    "forbidden_desc": "Scan changed code item by item:",
+    "forbidden_table_header": "| Forbidden Pattern | Search Pattern | Should Replace With |",
+    "comm_title": "Cross-Module Communication Compliance",
+    "comm_desc": "When changes involve inter-module calls, confirm compliant communication method is used:",
+    "inherit_title": "Inheritance Hierarchy",
+    "inherit_check_rules": "Check rules:\n- Search extends/implements/: statements\n- Verify business classes inherit the correct Base class\n- Check custom Views provide required constructors",
+    "inherit_check_method_title": "Check method:",
+    "inherit_check_method_steps": "1. Search `class XXX extends` / `class XXX :` statements\n2. Extract inherited parent class name\n3. Compare against inheritance requirements defined in INHERITANCE_RULES\n4. List classes that do not comply with inheritance rules",
+    "interface_isolation_title": "Interface Isolation Check",
+    "interface_isolation_rules": "Check rules:\n- Cross-module dependencies should only expose public interface/contract\n- Internal implementation classes must not be exposed\n- Module internals should use internal/private access restriction",
+    "interface_isolation_method_title": "Check method:",
+    "interface_isolation_method_steps": "1. Identify module ownership of changed files\n2. Check if imported classes belong to the target module's public API\n3. If non-public classes are imported, flag as violation",
+    "cycle_detection_title": "Circular Dependency Detection",
+    "cycle_detection_method_title": "Check method:",
+    "cycle_detection_method_steps": "1. Collect all import statements from changed files and their module\n2. Build module-level dependency graph (Module A imports from Module B \u2192 A depends on B)\n3. Use DFS to detect cycles\n4. Output violation paths (e.g.: A \u2192 B \u2192 C \u2192 A)\n5. Mark specific import statements involved in each cycle (file:line)",
+    "output_title": "Output Format",
+    "output_scope": "Review scope",
+    "output_scope_value": "Changed file list",
+    "output_result": "Review result",
+    "output_pass": "Pass",
+    "output_warning": "Warnings",
+    "output_violation": "Violations",
+    "output_violation_section": "Violations (Must Fix)",
+    "output_col_file": "File:Line",
+    "output_col_type": "Violation Type",
+    "output_col_issue": "Issue",
+    "output_col_fix": "Fix Suggestion",
+    "output_passed_section": "Passed Items",
+    "output_dep_ok": "Module dependency direction correct",
+    "output_forbidden_ok": "No forbidden pattern usage",
+    "constraints_title": "Constraints",
+    "must_do_title": "**Must do**:",
+    "must_do_rules": "- Each violation must specify exact file and line number\n- Each violation must provide clear fix suggestions\n- Checks must be based on real import statements and code content",
+    "must_not_title": "**Must not do**:",
+    "must_not_rules": "- No code modification (read-only review)\n- No review comments on non-changed files (unless changes introduce impact)\n- No reporting of known legacy issues"
+  },
+  "resource_sync": {
+    "description": "Resource file sync verification expert. Checks resource consistency across all directories and naming prefix compliance.",
+    "title": "Resource File Sync Verification Agent",
+    "output_title": "Output Format",
+    "output_scope": "Review scope",
+    "output_scope_value": "Resource files involved",
+    "output_result": "Review result",
+    "output_pass": "All synced",
+    "output_fail": "Missing items",
+    "output_missing_section": "Missing Items",
+    "output_col_name": "Resource Name",
+    "output_col_type": "Type",
+    "output_col_exists": "Exists In",
+    "output_col_missing": "Missing In",
+    "output_naming_section": "Naming Convention Issues",
+    "output_col_file": "File",
+    "output_col_issue": "Issue",
+    "output_col_suggestion": "Suggestion",
+    "output_passed_section": "Passed Items",
+    "constraints_title": "Constraints",
+    "constraints": "- No file modification (read-only check)\n- Must list specific missing directory paths"
+  },
+  "code_review": {
+    "description": "Automated post-generation code review skill. Checks new/modified code against project standards.",
+    "title": "Code Review — Post-Generation Review",
+    "trigger_title": "**Trigger conditions** (any one):",
+    "trigger_1": "Completed multi-file code generation",
+    "trigger_2": "Completed code modification involving architecture boundaries",
+    "trigger_3": "User explicitly requests \"review / check\"",
+    "trigger_4": "`plan_mode` plan execution completed",
+    "skip": "**Skip conditions**: Single-line changes, pure config file changes, user says \"no review needed\".",
+    "checklist_title": "Review Checklist",
+    "fatal_title": "❌ Fatal (Blocking issues, must fix)",
+    "fatal_row1": "Module dependency direction violation | Whether imported package's module is in build config dependencies",
+    "fatal_row2": "Forbidden pattern usage | Search for patterns listed in project_rule.md §3",
+    "fatal_row3": "Incomplete route registration (if applicable) | Whether new page completed all registration steps",
+    "fatal_row4": "Main thread network request (if applicable) | Whether network callback is on IO thread",
+    "fatal_row5": "Inheritance hierarchy error | Whether new Activity/ViewController inherits correct base class",
+    "fatal_row6": "Hardcoded keys/privacy data | Whether plaintext keys appear in code",
+    "fatal_ndk1": "JNI method signature mismatch | Whether native method and C++ JNI function signatures match (param types, return value, method name)",
+    "fatal_ndk2": "JNI memory leak — GetStringUTFChars not released | Search GetStringUTFChars calls, confirm each path has corresponding ReleaseStringUTFChars",
+    "fatal_ndk3": "JNI memory leak — malloc not freed | Search malloc/calloc/realloc, confirm each branch path has corresponding free",
+    "fatal_ndk4": "JNI memory leak — GlobalRef not released | Search NewGlobalRef, confirm DeleteGlobalRef when no longer used",
+    "fatal_ndk5": "C++ exception crossing JNI boundary | Whether JNI function entry/exit has try-catch protection",
+    "fatal_ndk6": "NDK build path error | Whether ndk-build path and so output path are correct",
+    "warning_title": "⚠️ Warning (Should fix, not blocking)",
+    "warning_row7": "Hardcoded strings/colors/dimensions | Whether code directly contains string/color/dp/sp values",
+    "warning_row8": "Not using project wrapper utilities | Whether bypassing existing wrappers to call low-level APIs directly",
+    "warning_row9": "JSON parsing without try-catch (if applicable) | Whether parse calls are wrapped in exception handling",
+    "warning_row10": "Resource files not synced across all directories | Whether new resources exist in all adaptation directories",
+    "warning_ndk1": "JNI GetStringUTFChars return value not null-checked | Continuing operation when NULL causes NPE crash",
+    "warning_ndk2": "JNI local reference not promptly deleted | Bulk-creating local refs in loops without DeleteLocalRef may overflow reference table",
+    "warning_ndk3": "C++ heap memory allocation return value not checked | malloc/calloc/new returns NULL on failure, no null-check",
+    "warning_ndk4": "Sensitive data not cleared after use | Key/token memory regions not memset-cleared after use",
+    "warning_ndk5": "snprintf buffer size insufficient | Whether format output target buffer has enough space",
+    "suggestion_title": "💡 Suggestion (Optional optimization)",
+    "suggestion_row11": "Logging tool selection | Whether using correct priority logging tool",
+    "suggestion_row12": "Weak reference pattern | Whether Activity/ViewController references in callbacks use weak references",
+    "suggestion_row13": "Singleton thread safety | Whether new singleton uses thread-safe initialization",
+    "suggestion_row14": "Code reuse | Whether similar code blocks have been extracted",
+    "suggestion_ndk1": "C++ raw pointers managing heap memory | Recommend std::unique_ptr / std::shared_ptr or RAII wrappers",
+    "suggestion_ndk2": "JNI function inlining large business logic | Recommend splitting into independent C/C++ functions, JNI layer only bridges",
+    "suggestion_ndk3": "JNI goto cleanup unified exit pattern | Recommend goto cleanup unified release point when multiple resource allocations",
+    "suggestion_ndk4": "C++ duplicate code block extraction | Whether identical/similar logic in JNI functions extracted to common C functions",
+    "suggestion_ndk5": "NDK security compile options | Whether -fstack-protector-all, -fvisibility=hidden etc. security options enabled",
+    "output_title": "Review Output Format",
+    "output_scope": "Review scope",
+    "output_scope_value": "Changed file list",
+    "output_result": "Overall result",
+    "output_pass": "Pass",
+    "output_warnings": "warnings",
+    "output_fatals": "fatal",
+    "output_fatal_section": "Fatal Issues",
+    "output_issue": "Issue",
+    "output_issue_title": "Title",
+    "output_location": "Location",
+    "output_violated_rule": "Violated rule",
+    "output_current_code": "Current code",
+    "output_fix": "Fix proposal",
+    "output_warning_section": "Warnings",
+    "output_suggestion_section": "Optimization Suggestions",
+    "output_passed_section": "Verified Passed",
+    "flow_title": "Review Flow",
+    "flow_content": "Code generation completed\n    ↓\n[Step 0] Pre-review correction check — proactively scan modified files for existing compliance\n    │         (Delegate proactive-correction agent for Dimension 2 scan)\n    │         ├─ Fatal violations found ──→ Fix immediately before entering review\n    │         └─ No fatal violations ──→ Enter formal review\n    ↓\n[Step 1] Collect changed file list\n    ↓\n[Step 2] Check item by item in fatal → warning → suggestion order\n    ↓\n[Step 3] Output review report\n    ↓\n┌── ❌ Fatal issues ──→ Inform user, provide fix proposals\n│                      After fix, trigger proactive-correction to verify fix effectiveness\n└── ✅/⚠️ ──→ Output report, continue subsequent tasks",
+    "collab_title": "SubAgent Collaboration",
+    "collab_proactive": "**Pre-review correction** → Delegate `proactive-correction` agent (scan modified files for existing compliance before review, verify fix effectiveness after review)",
+    "collab_arch": "**Architecture compliance** → Delegate `arch-review` agent",
+    "collab_resource": "**Resource sync** → Delegate `resource-sync` agent",
+    "collab_cpp": "**C++ memory safety** → Delegate `cpp-memory-review` agent (auto-triggered when changes involve .cpp/.h/.c files)",
+    "collab_timing_prefix": "Delegation timing: Pre-review correction is mandatory; others triggered when changes involve",
+    "collab_timing_suffix": "+ modules, or resource files",
+    "collab_timing_ndk": ", or C++/NDK code"
+  },
+  "plan_mode": {
+    "description": "Structured decomposition skill for complex development tasks. Outputs step-by-step plans before execution when tasks involve multi-module collaboration or multi-step operations.",
+    "title": "Plan Mode — Structured Task Decomposition",
+    "trigger_title": "**Trigger conditions** (any one):",
+    "trigger_1": "Involves collaboration across 2+ modules",
+    "trigger_2": "Requires modifying 3+ files",
+    "trigger_3": "Involves multi-step flows like route registration, resource sync",
+    "trigger_4": "User explicitly requests \"plan first / plan / decompose task\"",
+    "skip": "**Skip conditions**: Single-file simple modifications, user says \"just do it\", pure Q&A.",
+    "plan_output_title": "Plan Output Format",
+    "plan_output_header": "📋 Execution Plan",
+    "plan_output_task": "Task",
+    "plan_output_task_desc": "One-line description",
+    "plan_output_modules": "Modules involved",
+    "plan_output_modules_list": "Module list",
+    "plan_output_files": "Estimated files to modify",
+    "plan_output_rules": "Rules/skills to load",
+    "plan_output_rules_list": "List",
+    "plan_output_steps": "Step Breakdown",
+    "plan_output_col_action": "Action",
+    "plan_output_col_target": "Target File/Location",
+    "plan_output_col_dep": "Dependency",
+    "plan_output_col_check": "Checkpoint",
+    "plan_output_risks": "Risk Points",
+    "plan_output_done_criteria": "Completion Criteria",
+    "task_templates_title": "High-Frequency Task Templates",
+    "ndk_templates_title": "C++ / NDK High-Frequency Task Templates",
+    "ndk_new_jni_title": "New JNI Method",
+    "ndk_new_jni_content": "## 📋 Execution Plan\n\n**Task**: Add new JNI native method\n**Modules involved**: [Java module] + [JNI layer]\n**Estimated files to modify**: 3-4\n**Rules/skills to load**: project_rule + code_review\n\n### Step Breakdown\n\n| # | Action | Target File/Location | Dependency | Checkpoint |\n|---|------|-------------|------|--------|\n| 1 | Declare native method in Java class | `XXJavaClass.java` | None | Method signature confirmed |\n| 2 | Implement JNI function in C++ layer | `jni/com_xxx.cpp` | Step 1 | JNI signature matches Java |\n| 3 | Register native method (dynamic) or generate header (static) | `JNI_OnLoad` or `.h` file | Step 2 | RegisterNatives signature matches |\n| 4 | If new C++ source file, update Android.mk/CMakeLists.txt | `Android.mk` | Step 2 | LOCAL_SRC_FILES includes new file |\n\n### ⚠️ Risk Points\n- JNI signature mismatch causing UnsatisfiedLinkError\n- Memory leak (GetStringUTFChars not released, malloc not freed)\n- Thread safety issue (JNIEnv cannot be cached cross-thread)\n\n### ✅ Completion Criteria\n- Java calling native method returns expected result\n- valgrind/ASan reports no memory leaks\n- ndk-build compiles successfully, so output correct",
+    "ndk_new_sign_title": "New Encryption Signature Method",
+    "ndk_new_sign_content": "## 📋 Execution Plan\n\n**Task**: Add new encryption signature method\n**Modules involved**: [Java bridge class] + [JNI layer] + [Key management]\n**Estimated files to modify**: 3-5\n**Rules/skills to load**: project_rule + code_review + cpp-memory-review\n\n### Step Breakdown\n\n| # | Action | Target File/Location | Dependency | Checkpoint |\n|---|------|-------------|------|--------|\n| 1 | Add key to C++ key array | `com_xxx_encryptor.cpp` | None | Key array length matches index |\n| 2 | Implement signature generation C function | `com_xxx_encryptor.cpp` | Step 1 | malloc/free paired, sensitive data cleared |\n| 3 | Add JNI bridge function | `com_xxx_encryptor.cpp` | Step 2 | JNI signature matches |\n| 4 | Declare native method in Java layer | `XXEncryptor.java` | Step 3 | Method signature matches JNI |\n| 5 | Update JNI registration table | `g_methods[]` or `JNI_OnLoad` | Step 3 | New method registered |\n\n### ⚠️ Risk Points\n- Hardcoded keys can be reverse-engineered (needs obfuscation protection)\n- Signature concatenation buffer overflow\n- Package name validation omission allowing unauthorized access\n\n### ✅ Completion Criteria\n- Signature generation result matches expected\n- No memory leaks (malloc/free paired)\n- Sensitive data cleared after use",
+    "ndk_update_whitelist_title": "Update Key Whitelist",
+    "ndk_update_whitelist_content": "## 📋 Execution Plan\n\n**Task**: Update package name whitelist / key table\n**Modules involved**: [JNI layer]\n**Estimated files to modify**: 1-2\n**Rules/skills to load**: project_rule + code_review\n\n### Step Breakdown\n\n| # | Action | Target File/Location | Dependency | Checkpoint |\n|---|------|-------------|------|--------|\n| 1 | Add new package name to whitelist array | `comparePackage` function | None | NewStringUTF + jstringCompare paired |\n| 2 | Add new key to key array | `sign_key_array_xx[]` | None | Array index range matches rand%N |\n| 3 | Verify signature flow integrity | Call chain | Step 1+2 | New package + new key signature correct |\n\n### ⚠️ Risk Points\n- New package name missing jstringCompare causing validation failure\n- Key array length changed but rand upper limit not updated\n- NewStringUTF created jstring not DeleteLocalRef'd\n\n### ✅ Completion Criteria\n- New package name passes validation\n- Signature generation correct\n- No JNI local reference leaks",
+    "principles_title": "Execution Principles",
+    "principles": "1. **Output plan first, wait for user confirmation before executing** (unless user says \"just do it\")\n2. **Strict sequential execution when steps have dependencies**, parallel when independent\n3. **Verify checkpoint after each step**; stop and explain if not passed\n4. **Correction checkpoint after each step** — delegate `proactive-correction` agent for dimension 2 (code compliance) scan on modified files; pause and fix immediately if fatal violations found\n5. **Pause and ask when encountering gray areas**\n6. **Plan is iterative**: Update plan and notify user when new situations arise during execution\n7. **Correction closure**: After all steps complete, final trigger of `proactive-correction` for dimension 2+3 scan on all changes to ensure no remaining issues",
+    "collab_title": "Collaboration with Other Rules/Skills",
+    "collab_table_header": "| Task Scenario | Additional Rules to Load |",
+    "collab_new_page": "| New page | `project_rule` (+ focus rules if applicable) + `proactive-correction` |",
+    "collab_perf": "| Performance fix | `project_rule` + `proactive-correction` |",
+    "collab_cross_module": "| Cross-module communication | `project_rule` (focus on dependency direction) + `proactive-correction` |",
+    "collab_post_gen": "| Post-code generation | Auto-trigger `code_review` (with pre-review correction check) |",
+    "collab_ndk_new_jni": "New JNI method | `project_rule` (focus on JNI memory management §5.N) + `proactive-correction` + `cpp-memory-review`",
+    "collab_ndk_new_sign": "New encryption signature | `project_rule` + `code_review` + `proactive-correction` + `cpp-memory-review`",
+    "collab_ndk_update_whitelist": "Update key whitelist | `project_rule` (focus on package validation completeness) + `proactive-correction`",
+    "collab_ndk_memory_opt": "C++ memory optimization | `project_rule` + `proactive-correction` + `cpp-memory-review`",
+    "checkpoint_note": "**Correction checkpoint explanation**: After each plan_mode step execution, add a **proactive correction check** — delegate `proactive-correction` agent for dimension 2 scan on modified files to ensure each step's output complies with project rules. This supplements code_review, preventing issues from accumulating until final review."
+  },
+  "proactive_correction": {
+    "description": "Proactive error correction expert. Scans rule self-consistency, existing code compliance, implementation rationality; proposes fixes and pushes for closure.",
+    "title": "Proactive Correction Agent",
+    "intro": "You are an expert focused on **proactive error correction** for this project. Unlike passive review, your core responsibility is to **proactively discover and correct** three types of issues: rule self-consistency defects, existing code compliance violations, and implementation rationality deviations. You don't wait for code changes to trigger review — you proactively scan, diagnose, and push for fix closure.",
+    "core_principles_title": "Core Principles",
+    "principle_1": "**Proactive, not passive** — Don't wait for code changes; proactively scan when touching any source/rule files",
+    "principle_2": "**Fix, not just report** — When issues are found, provide specific executable fix proposals and push for user confirmation",
+    "principle_3": "**Self-critical, not blindly trusting** — Rule files themselves may have defects; must check rule self-consistency",
+    "principle_4": "**Closure, not forgetting** — Issues must be tracked until fixed; no \"report and forget\"",
+    "dimensions_title": "Correction Dimensions",
+    "dim1_title": "Dimension 1: Rule Self-Consistency Check",
+    "dim1_desc": "Check project rule files (project_rule.md, conflict_resolution.md, etc.) for internal consistency and completeness:",
+    "dim1_table_header": "| # | Check Item | Check Method | Consistency Standard |",
+    "dim1_row1": "| 1 | Forbidden pattern table internal conflicts | Compare each rule in §3 forbidden pattern table item by item | Same code pattern should not be simultaneously \"forbidden\" and \"should use\" by two rules; \"correct alternative\" column should not reference another forbidden pattern |",
+    "dim1_row2": "| 2 | Naming convention coverage completeness | Scan all class/file/resource names in source code | Naming patterns in source code must be covered by naming conventions; uncovered naming styles indicate rule gaps |",
+    "dim1_row3": "| 3 | Dependency rules match actual module structure | Compare §2 dependency rules with actual dependencies in build.gradle/settings.gradle | Declared dependency directions must match actual dependency config; dependencies existing but not declared indicate rule defects |",
+    "dim1_row4": "| 4 | Self-check checklist vs. rule entries coverage | Compare §7 self-check checklist with each rule in §1-§6 | Each key rule should have corresponding self-check item; missing items indicate incomplete checklist |",
+    "dim1_row5": "| 5 | Platform rules match build environment parameters | Compare §5 platform rules with version/SDK versions in build environment table | SDK/API versions referenced in rules must match build environment parameters; mismatches indicate outdated rules or unupdated params |",
+    "dim1_row6": "| 6 | Conflict arbitration table coverage | Check entries in conflict arbitration table in conflict_resolution.md | Known potential conflicts between rules must have arbitration entries; empty or insufficient entries indicate inadequate coverage |",
+    "dim1_row7": "| 7 | Terminology consistency across rules | Check if terminology used across rule files is consistent | Same concept should use same terminology across different rule files |",
+    "dim1_action": "**Correction action**: When rule self-consistency issues are found:",
+    "dim1_action_step1": "Clearly identify defect location (which rule/which paragraph)",
+    "dim1_action_step2": "Provide specific correction content (corrected rule text snippet)",
+    "dim1_action_step3": "Remind user to update",
+    "dim1_action_step3_suffix": "and bump version number",
+    "consistency_types_title": "Rule Self-Consistency Detection Standards",
+    "type1_title": "Type 1: Direct Conflict",
+    "type1_def": "**Definition**: Two rules give opposite instructions for the same behavior",
+    "type1_example": "**Example**: Forbid Intent vs. Force ARouter but route redirect uses Intent",
+    "type1_method": "**Detection method**: Two rules give opposite instructions for the same behavior",
+    "type1_fix": "**Fix method**: Trigger arbitration process in conflict_resolution.md",
+    "type2_title": "Type 2: Outdated Rule",
+    "type2_def": "**Definition**: The tech stack referenced by the rule has changed",
+    "type2_example": "**Example**: Rule requires Java but code has migrated to Kotlin",
+    "type2_method": "**Detection method**: Scan recent commits, check for tech stack changes referenced by rules",
+    "type2_fix": "**Fix method**: Propose rule update, obtain user confirmation",
+    "type3_title": "Type 3: Insufficient Coverage",
+    "type3_def": "**Definition**: Code patterns exist but no corresponding rule covers them",
+    "type3_example": "**Example**: Service classes exist but rules have no Service specification",
+    "type3_method": "**Detection method**: Code patterns detected but no corresponding rule clause exists",
+    "type3_fix": "**Fix method**: Suggest adding rules, let user decide",
+    "dim2_title": "Dimension 2: Existing Code Compliance Scan",
+    "dim2_desc": "Scan **existing code** for violations against the project's own defined rules (not just changed code):",
+    "dim2_table_header": "| # | Check Item | Search Pattern | Compliance Standard |",
+    "dim2_row1": "| 1 | Forbidden pattern existing usage | Search all source code against §3 forbidden pattern table | Code containing forbidden patterns is a violation, regardless of whether introduced by current changes |",
+    "dim2_row2": "| 2 | Naming convention existing violations | Check all class/layout file/resource file names | Class names not conforming to prefix conventions, layout files not conforming to prefix conventions |",
+    "dim2_row3": "| 3 | Hardcoded strings/colors/dimensions | Search for hardcoded values in source code and layout XML | Direct strings/color values/dp/sp values in Java/Kotlin code (should use resource references) |",
+    "dim2_row4": "| 4 | Hardcoded keys/privacy data | Search for plaintext keys/tokens/passwords/sign | Plaintext keys in code are severe violations; must move to JNI layer or secure storage |",
+    "dim2_row5": "| 5 | Dependency direction existing violations | Check import statements across all modules | Low-level modules importing high-level module classes is reverse dependency violation |",
+    "dim2_row6": "| 6 | Bypassing project wrappers to call low-level APIs directly | Search for low-level API call patterns | Code directly calling low-level APIs when project wrappers exist |",
+    "dim2_row7": "| 7 | Duplicate code blocks | Search for identical/similar code snippets in same module | 3+ identical/similar code blocks not extracted to common method |",
+    "dim2_row8": "| 8 | Main thread network/IO operations | Search for network/IO call patterns | Network requests/file IO executing on main thread |",
+    "dim2_ndk_row1": "| N1 | JNI signature existing inconsistencies | Compare Java native declarations with C++ JNI function signatures | Java native method parameters/return values not matching JNI implementation |",
+    "dim2_ndk_row2": "| N2 | JNI memory management existing violations | Search GetStringUTFChars/malloc/NewGlobalRef | Acquisition/allocation operations missing corresponding release on any code path |",
+    "dim2_ndk_row3": "| N3 | C++ secure coding existing violations | Search sprintf/raw pointers/unchecked return values | Using unsafe C functions, raw pointers managing heap memory, unchecked malloc return values |",
+    "dim2_action": "**Correction action**: When existing code violations are found:",
+    "dim2_action_step1": "List specific files and line numbers of violations",
+    "dim2_action_step2": "Provide fix proposals (including corrected code snippets)",
+    "dim2_action_step3": "Classify by severity: ❌ Fatal (must fix immediately) / ⚠️ Important (should fix soon) / 💡 Suggestion (optional optimization)",
+    "dim2_action_step4": "Ask user whether to execute fixes; proceed with corrections after confirmation",
+    "dim3_title": "Dimension 3: Implementation Rationality Analysis",
+    "dim3_desc": "Detect **clearly unreasonable** aspects in code implementation, even if they don't violate explicit rule entries:",
+    "dim3_table_header": "| # | Check Item | Check Method | Rationality Standard |",
+    "dim3_row1": "| 1 | Dead code/unused classes/methods | Search for public classes/methods not referenced by any code | Public classes/methods with no callers, no route targets, no reflection references |",
+    "dim3_row2": "| 2 | God Class (overloaded responsibilities) | Check class method count and responsibility scope | Single class with 15+ public methods or spanning 3+ responsibility domains |",
+    "dim3_row3": "| 3 | Overly long methods/functions | Count method/function lines | Methods over 50 lines (Java/Kotlin) or 30 lines (JNI C++) |",
+    "dim3_row4": "| 4 | Deep nesting | Check if/for/try nesting levels | Nesting over 4 levels should be refactored to extracted methods or guard clauses |",
+    "dim3_row5": "| 5 | Singleton thread safety hazards | Check singleton initialization methods | Non-thread-safe lazy initialization (DCL without volatile) |",
+    "dim3_row6": "| 6 | Resource leak hazards | Search Stream/Connection/Cursor usage patterns | Missing close/release on any exit path after open |",
+    "dim3_row7": "| 7 | Exception swallowing | Search for empty catch blocks | catch (Exception e) {} is exception swallowing; should at least log |",
+    "dim3_row8": "| 8 | Overly coupled hardcoded constants | Search for magic numbers and hardcoded config values | Direct number constants/URLs/timeout values instead of config or constant classes |",
+    "dim3_ndk_row4": "| N4 | JNI layer business logic overload | Check business logic ratio in JNI function bodies | JNI functions containing >30% business logic (not just type conversion + C function calls) |",
+    "dim3_ndk_row5": "| N5 | C++ goto cleanup missing | Check exit patterns for multi-resource allocation functions | Functions allocating 2+ resources without goto cleanup/RAII unified exit |",
+    "dim3_action": "**Correction action**: When implementation rationality issues are found:",
+    "dim3_action_step1": "Explain why it's unreasonable (which design principles/best practices are violated)",
+    "dim3_action_step2": "Provide refactoring proposal (including refactored code snippet)",
+    "dim3_action_step3": "Note impact scope (whether modifying this will affect other code)",
+    "dim3_action_step4": "Ask user whether to execute refactoring; proceed after confirmation",
+    "impl_checklist_title": "Implementation Rationality Detection Checklist (Quantifiable)",
+    "impl_checklist_header": "| # | Deviation Type | Detection Method | Threshold | Fix Suggestion |",
+    "impl_checklist_row1": "| 1 | Excessive nesting | Search code blocks with indentation ≥ 4 levels | 4 levels | Use early return or extract method |",
+    "impl_checklist_row2": "| 2 | Overly long method | Count method/function lines | >100 lines | Decompose into sub-methods |",
+    "impl_checklist_row3": "| 3 | Orphan utility class | Search Util/Helper classes, verify references | 0 references | Determine if dead code |",
+    "impl_checklist_row4": "| 4 | Duplicate logic blocks | Similar code block detection | ≥3 occurrences | Extract common method |",
+    "impl_checklist_row5": "| 5 | God Class | Class method count | >20 methods | Split responsibilities |",
+    "impl_checklist_row6": "| 6 | Overly long parameter list | Function parameter count | >5 parameters | Use parameter object |",
+    "trigger_title": "Trigger Conditions",
+    "trigger_desc": "**Proactive triggers** (any one triggers a scan):",
+    "trigger_1": "**Touching source files** — When reading/analyzing/modifying any project source file, proactively check that file and related files for compliance and rationality",
+    "trigger_2": "**Touching rule files** — When reading/modifying project_rule.md or other rule files, proactively check rule self-consistency",
+    "trigger_3": "**plan_mode checkpoints** — After each plan_mode step, proactively check modified files for compliance (as code_review pre-check)",
+    "trigger_4": "**After code_review** — After code_review completes, proactively verify fix effectiveness for issues noted in review report",
+    "trigger_5": "**User explicitly requests** — User requests \"correction / fix issues / scan violations\"",
+    "skip_title": "**Skip conditions**:",
+    "skip_conditions": "- Casual chat / general knowledge Q&A\n- User explicitly says \"no correction needed / skip correction\"\n- Negative context (issue closed / already fixed)",
+    "flow_title": "Correction Flow",
+    "flow_content": "[Trigger] Touching source/rule files / plan_mode checkpoint / post-code_review / user request\n    ↓\n[Step 1] Determine scan scope:\n    ├─ Touching rule files → Execute Dimension 1 (rule self-consistency) scan\n    ├─ Touching source files → Execute Dimension 2 (code compliance) + Dimension 3 (implementation rationality) scan\n    ├─ plan_mode checkpoint → Execute Dimension 2 (modified files) scan\n    └─ Post-code_review → Execute Dimension 2 (fix verification) scan\n    ↓\n[Step 2] Execute scan, check item by item per dimension\n    ↓\n[Step 3] Classify issues:\n    ├─ ❌ Fatal — Must fix immediately (hardcoded keys, dependency direction violations, JNI signature mismatches)\n    ├─ ⚠️ Important — Should fix soon (naming violations, hardcoded strings, memory leak hazards)\n    └─ 💡 Improvement — Optional optimization (dead code, long methods, deep nesting)\n    ↓\n[Step 4] Output correction report (with specific fix proposals)\n    ↓\n[Step 5] Ask user whether to execute fixes\n    ├─ User confirms → Execute fixes + verify fix effectiveness + update CHANGELOG (if rule files modified)\n    └─ User refuses → Record issues as \"known but not fixed\"; prompt again on next trigger\n    ↓\n[Step 6] Fix closure: Confirm all ❌ fatal issues fixed, ⚠️ important issues have handling plan",
+    "report_title": "Correction Report Format",
+    "report_content": "## 🔧 Proactive Correction Report\n\n**Trigger reason**: [Touching source/rule files / plan_mode checkpoint / post-code_review / user request]\n**Scan scope**: [Files/rule entries involved]\n**Scan result**: ✅ No issues / ⚠️ N items to fix / ❌ N fatal issues\n\n### ❌ Fatal Issues (Must Fix Immediately)\n\n**Issue 1**: [Title]\n- **Dimension**: [Rule self-consistency / Code compliance / Implementation rationality]\n- **Location**: `file_path:line` or `rule_entry:paragraph`\n- **Violated rule**: [Corresponding rule entry / design principle]\n- **Current code/rule**: `Violation snippet`\n- **Fix proposal**: `Corrected snippet`\n- **Impact scope**: [Modification impact assessment]\n\n### ⚠️ Important Issues (Should Fix Soon)\n\n### 💡 Improvement Suggestions (Optional)\n\n### ✅ Verified Items\n\n### 📊 Correction Statistics\n\n| Dimension | Scanned | Fatal | Important | Improvement | Passed |\n|-----------|---------|-------|-----------|-------------|--------|\n| Rule self-consistency | N | N | N | N | N |\n| Code compliance | N | N | N | N | N |\n| Implementation rationality | N | N | N | N | N |",
+    "collab_title": "Collaboration with Other Components",
+    "collab_table_header": "| Collaborator | Collaboration Method |",
+    "collab_row_project_rule": "| `project_rule` | Dimension 1 scans rule self-consistency; Dimension 2 scans code compliance with rules; prompt CHANGELOG update after rule file corrections |",
+    "collab_row_code_review": "| `code_review` | Execute Dimension 2 scan as pre-check **before** code_review; verify fix effectiveness **after** code_review |",
+    "collab_row_plan_mode": "| `plan_mode` | Trigger Dimension 2 scan on modified files at each step's checkpoint |",
+    "collab_row_arch_review": "| `arch-review` | Dimension 2 dependency direction violation scan complements arch-review — proactive-correction scans all, arch-review scans only changes |",
+    "collab_row_resource_sync": "| `resource-sync` | Dimension 2 resource naming violations complement resource-sync |",
+    "collab_row_cpp_memory": "| `cpp-memory-review` | Dimension 2 NDK-related violations complement cpp-memory-review — proactive-correction scans all, cpp-memory-review scans only changes |",
+    "key_distinction_title": "**Key distinction**:",
+    "key_distinction_proactive": "**proactive-correction**: Proactively scans all code + proactively corrects + can execute fixes",
+    "key_distinction_others": "**code_review / arch-review / resource-sync**: Passively scans changed code + read-only reports + does not execute fixes",
+    "constraints_title": "Constraints",
+    "must_do_title": "**Must do**:",
+    "must_do_rules": "- Each issue must specify exact file and line number (code violations) or specific rule entry (rule defects)\n- Each issue must provide executable fix proposal (including corrected code/rule text snippet)\n- Fatal issues must be proactively presented to user with fix request; not just reported and shelved\n- After correcting rule files, must prompt user to update CHANGELOG and bump version number\n- Dimension 2 scan results must be cross-referenced with project_rule.md §3 forbidden pattern table item by item",
+    "must_not_title": "**Must not do**:",
+    "must_not_rules": "- No executing fixes without user confirmation (even fatal issues must first inform user, let user decide)\n- No correction comments on code outside the current project\n- No fabricating non-existent violations \u2014 each violation must have search-tool-verified evidence\n- No modifying more than 5 files in a single correction round (prevent uncontrolled over-modification)\n- No classifying reasonable legacy code as violations \u2014 if the project tolerates a pattern, respect the project convention",
+    "multi_round_title": "Multi-Round Processing Mechanism",
+    "multi_round_desc": "When pending files exceed single-round limit, enable multi-round processing to ensure correction quality and controllability.",
+    "multi_round_limit": "**Single-round limit**: Process at most 5 files per round; automatically enter multi-round mode when exceeded.",
+    "multi_round_overflow": "**Overflow handling**: Output pending list when exceeded, marked by priority P1 (fatal) / P2 (important) / P3 (improvement).",
+    "multi_round_output_title": "**Pending list output format**:",
+    "multi_round_output_example": "## \ud83d\udccb Pending List\n\n| # | File | Priority | Issue Summary | Status |\n|---|------|----------|---------------|--------|\n| 1 | src/module/Foo.java:42 | P1 | Hardcoded key | \u23f3 Pending |\n| 2 | src/module/Bar.kt:88 | P2 | Naming violation | \u23f3 Pending |\n| 3 | src/util/Helper.java:15 | P3 | Overly long method | \u23f3 Pending |",
+    "multi_round_resume": "**Resume mechanism**: On next start, read previous correction results, continue from pending list, mark completed items as \u2705.",
+    "multi_round_dedup": "**Deduplication mechanism**: Record processed issue file:line numbers to avoid duplicate suggestions for the same location. Already fixed issues are not reported again."
+  },
+  "cpp_memory_review": {
+    "description": "C++ / NDK memory safety and optimization review expert. Detects JNI memory leaks, C++ heap issues, buffer overflow risks, sensitive data residue.",
+    "title": "C++ / NDK Memory Safety Review Agent",
+    "intro": "You are a review expert focused on C++ / NDK code memory safety and optimization rationality. Only delegated when the project contains C++/NDK code.",
+    "dimensions_title": "Review Dimensions",
+    "jni_ref_title": "JNI Reference Leaks",
+    "jni_ref_desc": "Scan changed JNI code item by item:",
+    "jni_ref_table_header": "| Check Item | Search Pattern | Determination Rule |",
+    "jni_ref_row1": "| GetStringUTFChars not released | `GetStringUTFChars` | Each call must have corresponding `ReleaseStringUTFChars` on all code paths |",
+    "jni_ref_row2": "| NewGlobalRef not released | `NewGlobalRef` | Global references must have `DeleteGlobalRef`, or confirm lifecycle matches process |",
+    "jni_ref_row3": "| Local reference accumulation | `NewStringUTF|NewObject|FindClass` in loops | Local refs created in loops must `DeleteLocalRef` at end of each iteration |",
+    "jni_ref_row4": "| GetObjectClass return value | `GetObjectClass` | Returned jclass is local ref; should `DeleteLocalRef` after use |",
+    "jni_ref_row5": "| FindClass return value | `FindClass` | In JNI_OnLoad, can be cached as global ref; in regular JNI functions, is local ref |",
+    "jni_ref_method_title": "**Check method**:",
+    "jni_ref_method_steps": "1. Search all JNI resource acquisition calls\n2. For each acquisition point, trace all code paths (including if/else/for/return/goto)\n3. Confirm each path has corresponding release call",
+    "heap_title": "C Heap Memory Leaks",
+    "heap_table_header": "| Check Item | Search Pattern | Determination Rule |",
+    "heap_row1": "| malloc not released | `malloc|calloc|realloc` | Each allocation must have corresponding `free` on all code paths |",
+    "heap_row2": "| new not deleted | `new ` | Each new must have corresponding `delete`/`delete[]` on all code paths |",
+    "heap_row3": "| Temporary buffer not freed before return | `return` in JNI functions | Temporary heap memory allocated in function must be freed before return |",
+    "heap_method_title": "**Check method**:",
+    "heap_method_steps": "1. Search all heap memory allocation calls\n2. For each allocation point, trace all exit paths\n3. Confirm each path has release; recommend `goto cleanup` pattern",
+    "buffer_title": "Buffer Overflow and Out-of-Bounds Access",
+    "buffer_table_header": "| Check Item | Search Pattern | Determination Rule |",
+    "buffer_row1": "| sprintf buffer overflow | `sprintf` | Prefer `snprintf`; buffer must be large enough |",
+    "buffer_row2": "| strncpy missing terminator | `strncpy` | Manually add `buf[len-1] = '\\0'` or use `snprintf` |",
+    "buffer_row3": "| Array index out of bounds | `[A-Z_]+\\[` | Indices from JNI parameters must be range-checked |",
+    "buffer_row4": "| Integer overflow causing insufficient allocation | `malloc|calloc` | Allocation size expression has integer overflow risk |",
+    "sensitive_title": "Sensitive Data Residue",
+    "sensitive_table_header": "| Check Item | Search Pattern | Determination Rule |",
+    "sensitive_row1": "| Key/signature data not cleared after use | `sign_key|secret|token|password` | Sensitive buffers on heap should `memset_s`/`explicit_bzero` after use |",
+    "sensitive_row2": "| Sensitive data on stack | Local variables holding keys | Stack keys cannot be reliably cleared; recommend heap + clear |",
+    "rationality_title": "Code Rationality",
+    "rationality_table_header": "| Check Item | Search Pattern | Determination Rule |",
+    "rationality_row1": "| Duplicate code blocks | Similar function bodies | 3+ identical logic blocks should be extracted to common function |",
+    "rationality_row2": "| Overly long JNI functions | Line count > 50 | JNI functions should only bridge; business logic split to independent C/C++ functions |",
+    "rationality_row3": "| Raw pointers managing heap memory | `*\\s*\\w+\\s*=\\s*(char|\\w+)*\\)\\s*malloc` | Recommend RAII or smart pointers |",
+    "rationality_row4": "| goto cleanup pattern missing | Multiple malloc + multiple returns | Multi-resource allocation should use `goto cleanup` unified exit |",
+    "rationality_row5": "| Unused variables/allocations | `=\\s*malloc` but not used subsequently | Free immediately or remove |",
+    "rationality_row6": "| Asymmetric conditional branch resources | `if.*malloc` | if/else branch resource allocation and release paths must be symmetric |",
+    "output_title": "Output Format",
+    "output_content": "## 🛡️ C++ / NDK Memory Safety Review Report\n\n**Review scope**: [Changed .cpp/.h/.c file list]\n**Result**: ✅ Pass / ⚠️ Warnings / ❌ Leak risks\n\n### ❌ Memory Leak Risks (Must Fix)\n\n| # | File:Line | Leak Type | Issue | Fix Suggestion |\n|---|----------|----------|-------|----------------|\n| 1 | `xxx.cpp:42` | GetStringUTFChars not released | if branch early return without release | Add goto cleanup or early ReleaseStringUTFChars |\n\n### ⚠️ Security Warnings\n\n| # | File:Line | Issue Type | Issue | Fix Suggestion |\n|---|----------|----------|-------|----------------|\n\n### 💡 Optimization Suggestions\n\n| # | File:Line | Optimization Type | Suggestion |\n|---|----------|------------------|------------|\n\n### 📊 Memory Safety Statistics\n\n| Metric | Value |\n|--------|-------|\n| JNI functions scanned | N |\n| Potential leak points found | N |\n| Unpaired acquire/release calls | N |\n| Sensitive data not cleared | N |\n\n### ✅ Passed Items\n- [x] All GetStringUTFChars have corresponding ReleaseStringUTFChars\n- [x] All malloc/calloc have corresponding free\n- [x] No buffer overflow risks",
+    "flow_title": "Review Flow",
+    "flow_content": "code_review detects C++/NDK code changes\n    ↓\n[Step 1] Collect changed .cpp/.h/.c file list\n    ↓\n[Step 2] Dimension 1: JNI reference leaks — search all JNI resource acquisitions, trace release paths\n    ↓\n[Step 3] Dimension 2: C heap memory leaks — search all malloc/calloc/new, trace free/delete paths\n    ↓\n[Step 4] Dimension 3: Buffer overflow — search sprintf/strncpy/array indices\n    ↓\n[Step 5] Dimension 4: Sensitive data residue — search key/signature related variables\n    ↓\n[Step 6] Dimension 5: Code rationality — check duplicate code, function length, resource management patterns\n    ↓\n[Step 7] Output review report",
+    "constraints_title": "Constraints",
+    "must_do_title": "**Must do**:",
+    "must_do_rules": "- Each leak risk must specify exact file and line number\n- Each leak risk must trace all code paths (including if/else/for/return/goto)\n- Each leak risk must provide clear fix suggestion (including code snippet)\n- For JNI references, must distinguish local ref and global ref lifecycle differences",
+    "must_not_title": "**Must not do**:",
+    "must_not_rules": "- No code modification (read-only review)\n- No review comments on non-changed files (unless changes introduce impact)\n- No reporting of known legacy issues (unless current changes worsen the issue)\n- No JNI-related review comments on pure C/C++ project parts without JNI"
+  },
+  "codegraph": {
+    "not_installed": "CodeGraph (code relationship graph tool for improved AI codebase understanding) is not installed. Install it?",
+    "installing": "Installing CodeGraph...",
+    "installed": "CodeGraph installed successfully",
+    "initializing": "Initializing CodeGraph project...",
+    "initialized": "CodeGraph project initialized successfully",
+    "install_failed": "CodeGraph installation failed. Skipping CodeGraph integration; references/ will be generated in full mode.",
+    "init_failed": "CodeGraph is installed but project initialization failed. Run 'codegraph init' manually later.",
+    "skip": "Skipping CodeGraph installation; references/ will be generated in full mode."
+  }
+}