luna-ai 1.0.0

package/templates/standard/.claude/skills/archiver/SKILL.md

@@ -0,0 +1,34 @@
+# Kỹ năng: Archiver 📦
+
+## Mô tả
+Kỹ năng này chịu trách nhiệm dọn dẹp và lưu trữ dữ liệu sau khi một dự án hoặc tính năng hoàn thành. Nó đảm bảo thư mục `plans/` luôn gọn gàng và mọi lịch sử làm việc được cất giữ đúng chỗ.
+
+## Quy trình của Kỹ năng
+
+### 1. Tham vấn Người dùng
+- **Hành động**: Agent phải dừng lại và thông báo cho người dùng: "Tính năng đã hoàn tất. Anh muốn em **Di chuyển** thư mục kế hoạch (bao gồm bản tổng kết SUMMARY.md) vào `plans/archive/` hay muốn **Xóa** nó đi cho gọn ạ?"
+- **Lưu ý**: Tuyệt đối không tự ý hành động khi chưa có phản hồi rõ ràng.
+
+### 2. Lưu trữ (Move to Archive)
+- Nếu người dùng chọn "Di chuyển":
+    - Đảm bảo thư mục `plans/archive/` tồn tại.
+    - Di chuyển toàn bộ thư mục `plans/<YYYY-MM-DD>-<feature-name>/` vào trong `plans/archive/`.
+    - Giữ nguyên cấu trúc bên trong (bao gồm `brief.md`, `plan.md`, `phases/` và `SUMMARY.md`) để tham chiếu sau này.
+
+### 3. Xóa bỏ (Cleanup)
+- Nếu người dùng chọn "Xóa":
+    - Xóa vĩnh viễn thư mục tính năng hiện hành.
+    - Xác nhận việc dọn dẹp đã hoàn tất.
+
+### 4. Xác nhận Kết thúc
+- **Dọn dẹp Trạng thái**: Xóa file **`plans/ACTIVE`** để xác nhận không còn nhiệm vụ hiện hành nào đang được xử lý.
+- Gửi thông báo cuối cùng: "Quy trình đã hoàn tất. Bản tổng kết chi tiết đã được cất vào kho lưu trữ. Em đã sẵn sàng cho nhiệm vụ tiếp theo."
+
+## Công cụ sử dụng
+- `move_file` / `delete_file`: Để di chuyển hoặc xóa thư mục.
+- `mkdir`: Để tạo thư mục lưu trữ nếu cần.
+
+## Lưu ý cho Agent
+- Chỉ kích hoạt Skill này đối với các **Standard Task**.
+- Trước khi Archive, hãy đảm bảo file `SUMMARY.md` đã được QA Agent tạo thành công ở bước trước đó.
+- Sau khi hoàn tất, hãy đảm bảo thư mục gốc của dự án hoàn toàn sạch sẽ.

package/templates/standard/.claude/skills/git-manager/SKILL.md

@@ -0,0 +1,30 @@
+# Kỹ năng: Git Manager 🌳⚡
+
+## Mô tả
+Kỹ năng này giúp Agent quản lý mã nguồn thông qua Git một cách chuyên nghiệp và tự động. Nó biến các chuỗi lệnh Git phức tạp thành các thao tác đơn giản, ưu tiên tính an toàn của các nhánh chính và tuân thủ quy trình bàn giao code chuẩn.
+
+## Quy trình của Kỹ năng
+
+### 1. Siêu lệnh "cp" (Commit & Push)
+- **Hành động**: Thực hiện chuỗi lệnh `git add .` -> `git commit` -> `git push`.
+- **Bắt buộc Kiểm tra Nhánh**: Trước khi thực hiện, Agent phải kiểm tra nhánh hiện tại.
+    - Nếu đang ở `main`, `master`, `dev`, hoặc `staging`: Agent **KHÔNG ĐƯỢC** push trực tiếp. Phải thông báo cho người dùng và thực hiện checkout sang một nhánh tính năng mới (ví dụ: `feature/name`) trước khi tiếp tục.
+- **Commit Message**: Tự động soạn thảo nội dung commit chuyên nghiệp dựa trên các task đã hoàn thành trong `plan.md`.
+
+### 2. Siêu lệnh "cpp" (Commit, Push & PR)
+- **Hành động**: Bao gồm toàn bộ quy trình của siêu lệnh "cp" (bao gồm cả bước kiểm tra an toàn nhánh) và sau đó thực hiện tạo Pull Request vào nhánh chính.
+- **Mô tả PR**: Tự động tóm tắt các thay đổi quan trọng để điền vào nội dung PR.
+
+### 3. Đồng bộ hóa & Quản lý (Sync)
+- Hỗ trợ nhanh các lệnh `git pull` để đảm bảo code luôn mới nhất.
+- Hỗ trợ tạo nhánh mới (`git checkout -b`) theo yêu cầu trực tiếp.
+
+## Công cụ sử dụng
+- `execute_command`: Chạy các lệnh `git` trong terminal.
+- `project-discovery`: Để hiểu nội dung thay đổi nhằm viết commit message chuẩn.
+- `AskUserQuestion`: Để hỏi ý kiến người dùng khi cần chuyển nhánh hoặc chốt nội dung PR.
+
+## Lưu ý cho Agent
+- **An toàn là trên hết**: Tuyệt đối không `force push` trừ khi có yêu cầu đặc biệt.
+- **Tính minh bạch**: Luôn thông báo cho người dùng biết mình đang ở nhánh nào và định push đi đâu.
+- **Đồng bộ hóa**: Luôn đảm bảo `plan.md` phản ánh đúng trạng thái code trước khi thực hiện `cp` hoặc `cpp`.

package/templates/standard/.claude/skills/implement/SKILL.md

@@ -0,0 +1,35 @@
+# Kỹ năng: Implement 🧪
+
+## Mô tả
+Kỹ năng này hướng dẫn Agent thực hiện việc viết code theo phương pháp **Lập trình hướng kiểm thử (TDD)**. Mục tiêu là đảm bảo mọi dòng code logic được viết ra đều có kiểm thử đi kèm và hoạt động đúng như mong đợi ngay từ đầu.
+
+## Quy trình của Kỹ năng
+
+### 1. Phân tích Test Case
+- Dựa trên các yêu cầu và Phase đã định nghĩa trong `plan.md`, xác định các trường hợp kiểm thử (input/output/edge cases).
+- Chọn framework test phù hợp với ngôn ngữ của dự án (ví dụ: Jest cho Node.js, Pytest cho Python).
+
+### 2. Viết Test trước (Red Phase)
+- **Hành động**: Tạo file test mới hoặc bổ sung vào file test hiện có.
+- **Mục tiêu**: Viết mã kiểm thử mô tả hành vi mong muốn. Ở giai đoạn này, chạy test **BẮT BUỘC** phải thất bại (vì chưa có logic).
+
+### 3. Triển khai Logic (Green Phase)
+- **Hành động**: Viết mã nguồn tối thiểu cần thiết để làm cho các bài test vượt qua.
+- **Công cụ**: Sử dụng `edit_file` để chỉnh sửa code chính xác, tránh ghi đè toàn bộ file khi không cần thiết.
+
+### 4. Chạy & Xác minh
+- Sử dụng lệnh terminal (`npm test`, `pytest`, v.v.) để thực thi test.
+- Nếu test thất bại: Phân tích lỗi, sửa lại logic và chạy lại.
+- **Giới hạn nỗ lực**: Nếu sau 3 lần sửa mà vẫn thất bại, hãy dừng lại và kích hoạt cơ chế **Escalation** (Báo cáo & Chuyển hướng). Không được cố gắng sửa đổi mù quáng.
+
+### 5. Tối ưu hóa (Refactor)
+- Sau khi test đã pass, tiến hành làm sạch code và tối ưu hóa cấu trúc nhưng vẫn đảm bảo các bài test luôn vượt qua.
+
+## Công cụ sử dụng
+- `write_file` / `edit_file`: Tạo và chỉnh sửa mã nguồn/test.
+- `execute_command`: Chạy các lệnh terminal để thực thi test.
+
+## Lưu ý cho Agent
+- **BẮT BUỘC**: File test phải tồn tại trước khi viết code logic.
+- Không được bỏ qua các trường hợp xử lý lỗi (error handling).
+- Luôn cập nhật trạng thái thành `[x]` trong `plan.md` sau khi một bộ test cho task đã hoàn thành thành công.

package/templates/standard/.claude/skills/memory-manager/SKILL.md

@@ -0,0 +1,28 @@
+# Kỹ năng: Memory Manager 🧠
+
+## Mô tả
+Kỹ năng này giúp Agent duy trì bộ nhớ dài hạn của dự án thông qua file `.claude/rules/project-memory.md`. Khác với các kỹ năng khác, kỹ năng này **CHỈ** hoạt động khi có yêu cầu trực tiếp từ người dùng để ghi lại một bài học hoặc quyết định quan trọng.
+
+## Quy trình của Kỹ năng
+
+### 1. Tiếp nhận Yêu cầu
+- Kỹ năng này chỉ được kích hoạt khi người dùng nói các câu lệnh như: "Hãy ghi nhớ điều này", "Lưu bài học này lại", "Cập nhật luật dự án cho phần này nhé"...
+
+### 2. Soạn thảo Quy tắc (Drafting)
+- Agent tóm tắt bối cảnh vừa thảo luận hoặc bài học vừa rút ra.
+- Chuyển đổi thông tin đó thành một "Quy tắc" (Rule) súc tích, dễ hiểu và mang tính thực thi cao.
+
+### 3. Cập nhật file Rules
+- **Hành động**: Sử dụng `edit_file` để chèn quy tắc mới vào file `.claude/rules/project-memory.md`.
+- **Định dạng**: Ghi rõ nội dung và ngày ghi nhận.
+
+### 4. Xác nhận
+- Thông báo cho người dùng: "Em đã cập nhật bài học/quyết định này vào hệ thống quy tắc tự động (`project-memory.md`) rồi ạ."
+
+## Công cụ sử dụng
+- `read_file`: Đọc nội dung bộ nhớ hiện tại.
+- `edit_file`: Chèn thêm quy tắc mới.
+
+## Lưu ý cho Agent
+- **KHÔNG TỰ Ý CẬP NHẬT**: Tuyệt đối không tự động ghi vào file này ở cuối mỗi task. Chỉ làm khi được lệnh.
+- **Tính thực thi**: Viết quy tắc sao cho các Agent phiên bản sau đọc vào là biết phải làm gì ngay (Actionable).

package/templates/standard/.claude/skills/plan-manager/SKILL.md

@@ -0,0 +1,32 @@
+# Kỹ năng: Plan Manager 📋
+
+## Mô tả
+Kỹ năng này chịu trách nhiệm khởi tạo và duy trì tính toàn vẹn của hệ thống kế hoạch. Nó đảm bảo mọi hoạt động của Agent được ghi nhận minh bạch thông qua các Phase và Task trong file `plan.md`.
+
+## Quy trình của Kỹ năng
+
+### 1. Khởi tạo Kế hoạch
+- **Tạo Thư mục & Brief**: Tự động lấy ngày và tên tính năng để tạo thư mục `plans/<YYYY-MM-DD>-<tên-tính-năng>/` và file `brief.md` tóm tắt nhiệm vụ.
+- **Sử dụng Mẫu (Templates)**: Agent PHẢI ưu tiên tìm đọc các mẫu kế hoạch trong thư mục `.claude/templates/plans/` để chọn ra cấu trúc Phase phù hợp nhất với loại nhiệm vụ (Tính năng mới, Sửa lỗi, hay Tối ưu hóa).
+- **Đánh dấu Tính năng Hiện hành**: Ghi tên thư mục vừa tạo vào file **`plans/ACTIVE`** để chỉ định đây là nhiệm vụ đang được thực hiện.
+- **Cấu trúc đa file**: 
+    - Tạo file `plan.md` chính dựa trên nội dung Brief và Mẫu kế hoạch đã chọn để quản lý trạng thái các Phase.
+    - Tạo thư mục `phases/` bên trong thư mục kế hoạch.
+    - Tạo các file `phases/phase-n.md` chi tiết chứa danh sách task để thực thi.
+
+### 2. Theo dõi Tiến độ
+- **Chốt Phase**: Chỉ cập nhật trạng thái (ví dụ `[ ]` -> `[x]`) trong file `plan.md` chính khi toàn bộ nội dung của Phase tương ứng đã hoàn thành. 
+- **Định dạng Task trong Phase**: Các task trong file `phases/phase-n.md` không cần dùng prefix checkbox `[ ]`. Chỉ liệt kê danh sách đơn giản hoặc đánh số để dễ đọc.
+
+### 3. Đồng bộ hóa
+- Đảm bảo `plan.md` luôn phản ánh đúng tiến độ thực tế trong **Bước 3: Execution**.
+- Không thay đổi cấu trúc bảng hoặc danh sách đã định nghĩa ban đầu trừ khi có yêu cầu sửa đổi kế hoạch.
+
+## Công cụ sử dụng
+- `write_file` / `edit_file`: Tạo và cập nhật trạng thái trong `plan.md`.
+- `mkdir`: Tạo cấu trúc thư mục `plans/` và `phases/`.
+
+## Lưu ý cho Agent
+- **Bắt buộc dùng Mẫu**: Việc sử dụng mẫu giúp duy trì tính chuyên nghiệp và không bỏ sót các bước quan trọng như Testing hay Quality Guard.
+- **KHÔNG BAO GIỜ** nhảy bước. Phase 1 phải hoàn thành trước Phase 2.
+- File `plan.md` phải luôn dễ đọc cho con người.

package/templates/standard/.claude/skills/project-discovery/SKILL.md

@@ -0,0 +1,50 @@
+# Kỹ năng: Project Discovery 🔍
+
+## Mô tả
+Kỹ năng này giúp Agent thu thập toàn bộ "nguyên liệu" cần thiết về ngữ cảnh, công nghệ và cấu trúc của dự án hiện tại. Đây là bước đệm bắt buộc để Agent có đủ dữ liệu lập ra một bản kế hoạch (Plan) chính xác và khả thi ở Bước 2.
+
+## Quy trình của Kỹ năng
+
+1. **Phân loại dựa trên Rủi ro**:
+   - Đánh giá mức độ rủi ro của yêu cầu trên thang điểm 1-5:
+     - **Mức 1-2 (Rủi ro thấp - Fast Track)**: Thay đổi ở "Vùng Xanh" (README, Comment, UI Text, hằng số hiển thị, refactor tên biến cục bộ).
+     - **Mức 3 (Rủi ro trung bình - Fast Track + Cảnh báo)**: Thay đổi logic nhỏ có tiềm ẩn ảnh hưởng nhẹ. Thực hiện trực tiếp nhưng phải giải trình lý do.
+     - **Mức 4-5 (Rủi ro cao - Standard Track)**: Thay đổi ở "Vùng Đỏ" (Logic cốt lõi, Database, Auth, API Routes, tạo file mới, tích hợp thư viện).
+   - Kết quả đánh giá này quyết định luồng hành động trong `CLAUDE.md`.
+
+2. **Kiểm tra Cấu trúc**:
+   - **ƯU TIÊN**: Tìm và đọc file `STRUCTURE.md` tại gốc dự án trước khi thực hiện các lệnh quét khác.
+   - Nếu có `STRUCTURE.md`: Sử dụng thông tin trong đó để xác định ngay các vùng code liên quan.
+   - Nếu không có: Đề xuất người dùng sử dụng kỹ năng `project-mapper` để khởi tạo.
+
+3. **Sơ đồ hóa (Mapping)**:
+   - Chỉ thực hiện quét sâu nếu `STRUCTURE.md` không tồn tại hoặc thông tin không đủ chi tiết.
+   - Sử dụng `ls -R` hoặc các công cụ tìm kiếm để nắm bắt sơ đồ thư mục.
+   - Xác định các thư mục chính (src, tests, docs, config...).
+
+4. **Nhận diện Công nghệ**:
+   - Tìm và đọc các file quản lý phụ thuộc (`package.json`, `requirements.txt`, `go.mod`...).
+   - Xác định ngôn ngữ lập trình chính và các framework đang dùng.
+
+5. **Phân tích Tác động & Dự báo Rủi ro sâu (Advanced Impact Analysis)**:
+   - **Truy vết Phụ thuộc**: Không chỉ tìm từ khóa, hãy xác định các file đang import hoặc gọi đến đoạn code sắp sửa đổi.
+   - **Cảnh báo Hiệu ứng Lan truyền**: Tự động nhận diện các thay đổi có rủi ro cao (ví dụ: sửa đổi Interface, Schema DB, API chung) và liệt kê các thành phần có khả năng bị hỏng.
+   - **Đề xuất Kiểm thử**: Dựa trên rủi ro, đề xuất các khu vực cụ thể cần chạy test bổ sung để đảm bảo không phát sinh lỗi phụ (regression errors).
+
+6. **Tổng hợp**:
+   - Tóm tắt thông tin trên thành Ngữ cảnh Nội bộ (Internal Context) gồm: Stack công nghệ, các file liên quan và ràng buộc kỹ thuật.
+
+7. **Nhận diện Điểm mơ hồ**:
+   - **BẮT BUỘC**: Liệt kê các điểm chưa rõ ràng hoặc các phương án cần lựa chọn.
+   - **Sử dụng Tool**: Gọi công cụ **`AskUserQuestion`** để trình bày các lựa chọn này. Việc này đảm bảo hệ thống dừng lại và hiển thị giao diện tương tác.
+   - Nếu có điểm mơ hồ, skill này phải chặn việc chuyển sang Bước 2 cho đến khi nhận được phản hồi.
+
+## Công cụ sử dụng
+- `read_file`: Đọc file cấu hình và nguồn.
+- `ls`: Liệt kê thư mục.
+- `grep` / `search`: Tìm kiếm chuỗi ký tự trong dự án.
+- `AskUserQuestion`: Đặt câu hỏi tương tác cho người dùng.
+
+## Lưu ý cho Agent
+- Luôn ưu tiên đọc `CLAUDE.md` hoặc `README.md` trước để nắm các quy tắc chung.
+- Đảm bảo không bỏ sót các file test liên quan để phục vụ tư duy TDD.

package/templates/standard/.claude/skills/project-mapper/SKILL.md

@@ -0,0 +1,36 @@
+# Kỹ năng: Project Mapper 🗺️
+
+## Mô tả
+Kỹ năng này cho phép Agent tự động tạo ra và duy trì một bản đồ ngữ cảnh (Context Map) dưới dạng file `STRUCTURE.md`. Bản đồ này giúp Agent nắm bắt nhanh kiến trúc dự án, tiết kiệm thời gian và token.
+
+## Quy trình của Kỹ năng
+
+1. **Kiểm tra Sự tồn tại & Ngữ cảnh**:
+   - Tìm file `STRUCTURE.md`. Nếu đã có, đọc nội dung hiện tại.
+   - Xác định các thay đổi vừa thực hiện trong phiên làm việc hiện tại (các file/thư mục mới tạo hoặc di chuyển).
+
+2. **Cập nhật từng phần (Incremental Update)**:
+   - **ƯU TIÊN**: Sử dụng kiến thức về các thay đổi vừa thực hiện để cập nhật chính xác các dòng liên quan trong `STRUCTURE.md` bằng lệnh `edit_file`.
+   - Tránh quét lại toàn bộ codebase nếu chỉ có những thay đổi nhỏ về cấu trúc.
+
+3. **Quét & Phân tích Kiến trúc (Khi cần)**:
+   - Chỉ thực hiện quét sâu (`ls -R`, `find`) nếu `STRUCTURE.md` chưa tồn tại hoặc dự án có sự xáo trộn cấu trúc quy mô lớn.
+   - Nhận diện loại dự án và các Module/Thư mục chính.
+
+4. **Xác định Luồng chính (Key Flows)**:
+   - Tìm điểm bắt đầu (Entry points) của ứng dụng.
+   - Tóm tắt cách các thành phần chính tương tác với nhau.
+
+5. **Xuất bản/Cập nhật STRUCTURE.md**:
+   - Ghi lại thông tin: Tổng quan công nghệ, Sơ đồ thư mục tóm tắt, và các quy ước quan trọng.
+   - Đảm bảo định dạng rõ ràng, dễ đọc cho cả người và AI.
+
+## Công cụ sử dụng
+- `ls`, `find`: Để quét cấu trúc.
+- `read_file`: Để hiểu vai trò của file cấu hình.
+- `write_file` / `edit_file`: Để tạo hoặc cập nhật `STRUCTURE.md`.
+
+## Lưu ý cho Agent
+- **Tính tinh gọn**: Chỉ đưa vào các thư mục/file thực sự quan trọng, bỏ qua rác (`node_modules`, `dist`, `temp`...).
+- **Tính tự động**: Phải tự giác cập nhật bản đồ này ở Bước 4 (Review) của Workflow nếu cấu trúc thay đổi.
+- **Tính hữu dụng**: Luôn đặt mình vào vị trí một AI mới để viết mô tả cấu trúc dễ hiểu nhất.

package/templates/standard/.claude/skills/quality-guard/SKILL.md

@@ -0,0 +1,40 @@
+# Kỹ năng: Quality Guard 🛡️
+
+## Mô tả
+Kỹ năng này đóng vai trò là "người gác cổng" chất lượng mã nguồn. Agent sử dụng kỹ năng này để tự động kiểm soát, làm sạch và tối ưu hóa code trước khi bàn giao, đảm bảo sản phẩm cuối cùng không có rác và tuân thủ tuyệt đối quy chuẩn của người dùng.
+
+## Quy trình của Kỹ năng
+
+### 1. Rà soát & Củng cố Quy tắc (Rule Reinforcement)
+- **Hành động**: Trước khi rà soát mã nguồn, Agent **BẮT BUỘC** đọc lại các file tại `.claude/rules/` (đặc biệt là `code-style.md` và `project-structure.md`).
+- **Mục tiêu**: Đảm bảo bộ nhớ ưu tiên (Context) của Agent luôn chứa đầy đủ các quy chuẩn mới nhất, tránh tình trạng "quên luật" khi codebase quá lớn.
+
+### 2. Rà soát Mã nguồn (Code Cleanup)
+- **Hành động**: Quét các file đã sửa để tìm và loại bỏ:
+    - Lệnh debug thừa (`console.log`, `print`, `debugger`).
+    - Chú thích tạm thời vô giá trị (`// TODO`, `// FIXME`, `// check this`).
+    - Biến hoặc import đã khai báo nhưng không dùng.
+
+### 2. Kiểm tra tính Toàn vẹn
+- **Hành động**: Đối chiếu cấu trúc code để đảm bảo:
+    - Mọi thành phần mới đều đã được export/import chính xác.
+    - Không có file nào bị bỏ trống hoặc quên xóa sau khi refactor.
+    - Tên file/thư mục tuân thủ đúng quy tắc dự án.
+
+### 3. Bộ nhớ & Hiệu suất (Memory & Performance)
+- **Hành động**: Đọc file `.claude/rules/project-memory.md` để lấy quy chuẩn riêng và phân tích hiệu suất:
+    - Kiểm tra phong cách viết code (ví dụ: ưu tiên `const`, dùng `arrow functions`).
+    - **Tối ưu hiệu suất**: Nhận diện code có độ phức tạp cao, vòng lặp lồng nhau hoặc truy vấn dư thừa để đề xuất cải tiến.
+    - Đảm bảo các lỗi "kinh điển" trong Memory không lặp lại.
+
+### 4. Báo cáo Chất lượng
+- **Hành động**: Tổng hợp ngắn gọn các lỗi đã tự sửa, các cải tiến hiệu suất đã làm và lưu ý chất lượng cho người dùng ở Bước 4 (Review).
+
+## Công cụ sử dụng
+- `grep` / `search`: Tìm kiếm các đoạn code "rác".
+- `read_file` / `edit_file`: Kiểm tra và làm sạch code.
+- `execute_command`: Chạy các công cụ linter/formatter của dự án.
+
+## Lưu ý cho Agent
+- **Tự động nhưng thận trọng**: Chỉ tự xóa những thứ chắc chắn là "rác". Nếu phân vân, hãy để lại ghi chú cho người dùng.
+- **Dựa trên Memory**: Luôn coi `.claude/rules/project-memory.md` là kim chỉ nam cho các tiêu chuẩn chất lượng cá nhân hóa.

package/templates/standard/.claude/skills/research-documentation/SKILL.md

@@ -0,0 +1,27 @@
+# Kỹ năng: Research & Documentation 🌐
+
+## Mô tả
+Kỹ năng này cho phép Agent mở rộng phạm vi hiểu biết ra bên ngoài dự án bằng cách tra cứu tài liệu, thư viện và giải pháp kỹ thuật trên Web. Đây là kỹ năng quan trọng để lập kế hoạch cho tính năng mới hoặc tích hợp công nghệ chưa có sẵn trong codebase.
+
+## Quy trình của Kỹ năng
+
+1. **Xác định Lỗ hổng Kiến thức**:
+   - Sau khi thực hiện `project-discovery`, Agent xác định các thành phần chưa rõ (ví dụ: thư viện mới, API bên thứ ba, thuật toán phức tạp).
+
+2. **Tra cứu Ngoại vi**:
+   - Sử dụng công cụ `web_search` để tìm tài liệu chính thức, hướng dẫn (tutorials) và ví dụ thực tế trên GitHub/StackOverflow.
+
+3. **Phân tích Tính khả thi**:
+   - Đọc và tóm tắt các bước cài đặt, cấu hình và cách dùng công nghệ đó.
+   - Đối chiếu với stack công nghệ hiện tại của dự án để đảm bảo tương thích.
+
+4. **Cung cấp Giải pháp**:
+   - Tổng hợp các bước thực hiện cụ thể (lệnh, đoạn code) để sẵn sàng đưa vào Bước 2 (Planning) của Workflow chính.
+
+## Công cụ sử dụng
+- `web_search`: Công cụ chính để tìm kiếm thông tin trên Internet.
+- `web_fetch` / `browser`: Để đọc chi tiết nội dung từ các trang tài liệu kỹ thuật.
+
+## Lưu ý cho Agent
+- Luôn ưu tiên nguồn tài liệu chính thống (Documentation) hơn là các bài blog cá nhân.
+- Chú ý đến phiên bản (Version) để đảm bảo không áp dụng kiến thức cũ lỗi thời.

package/templates/standard/.claude/skills/skill-creator/SKILL.md

@@ -0,0 +1,34 @@
+# Kỹ năng: Skill Creator 🏗️
+
+## Mô tả
+Kỹ năng này cho phép Agent tự động thiết kế, xây dựng và tích hợp các kỹ năng mới dưới dạng **Plugin** vào hệ thống. Mỗi Plugin được đóng gói trọn vẹn trong một thư mục tại `.claude/skills/`, giúp mở rộng năng lực của Agent một cách không giới hạn thông qua cơ chế tự động nhận diện.
+
+## Quy trình của Kỹ năng
+
+### 1. Phân tích Nhu cầu
+- Khi Agent phát hiện một tác vụ lặp lại hoặc đòi hỏi quy trình chuyên biệt chưa có trong danh mục Plugin hiện tại.
+- Xác định rõ: Tên Plugin, mục tiêu và các công cụ (Tools) cần thiết.
+
+### 2. Thiết kế & Đóng gói Plugin
+- **Tạo thư mục**: Khởi tạo thư mục mới tại `.claude/skills/<tên-plugin>/`.
+- **Soạn thảo SKILL.md**: Viết file hướng dẫn chuẩn gồm:
+    - **Mô tả**: Chức năng của Plugin.
+    - **Quy trình**: Các bước thực hiện logic.
+    - **Công cụ**: Danh sách công cụ AI cần dùng.
+    - **Lưu ý**: Ràng buộc và mẹo vận hành.
+
+### 3. Tích hợp Tự động
+- **Nhận diện**: Nhờ cơ chế Dynamic Skills, Plugin mới sẽ khả dụng ngay lập tức sau khi file `SKILL.md` được khởi tạo.
+- **Tài liệu**: Tự động cập nhật bản đồ `STRUCTURE.md` để ghi nhận sự hiện diện của Plugin mới.
+
+### 4. Xác minh & Tinh chỉnh
+- Thử nghiệm gọi Plugin mới trong tình huống giả định để đảm bảo hướng dẫn là rõ ràng và hiệu quả.
+
+## Công cụ sử dụng
+- `mkdir`: Tạo không gian cho Plugin.
+- `write_file` / `edit_file`: Soạn thảo nội dung và cập nhật `STRUCTURE.md`.
+
+## Lưu ý cho Agent
+- **Tính chuẩn hóa**: Plugin mới phải tuân thủ tuyệt đối định dạng của Framework.
+- **Tránh trùng lặp**: Luôn kiểm tra xem tính năng đã có trong Plugin khác chưa.
+- **Sự cho phép**: Đối với các Plugin có tác động lớn, hãy hỏi ý kiến người dùng trước khi "đúc".

package/templates/standard/.claude/skills/verification-review/SKILL.md

@@ -0,0 +1,36 @@
+# Kỹ năng: Verification & Review 🏁
+
+## Mô tả
+Kỹ năng này hướng dẫn Agent cách tổng kết, kiểm tra chéo và báo cáo kết quả sau khi hoàn thành nhiệm vụ lập trình. Mục tiêu là đảm bảo sản phẩm cuối đạt chất lượng cao nhất và người dùng nắm bắt được toàn bộ thay đổi.
+
+## Quy trình của Kỹ năng
+
+### 1. Kiểm tra Cuối cùng
+- **Đối chiếu kế hoạch**: Kiểm tra `plan.md` đảm bảo mọi Phase và Task trong từng Phase đều đã chốt `[x]`.
+- **Chạy Toàn bộ Test**: Thực thi tất cả các bài test trong dự án (không chỉ các test mới) để đảm bảo không có lỗi phụ.
+- **Tuân thủ Tiêu chuẩn**: Quét lại mã nguồn đảm bảo tuân thủ tiêu chuẩn code (linting, formatting).
+
+### 2. Tổng hợp Thay đổi
+- Liệt kê các file mới tạo.
+- Tóm tắt các thay đổi lớn trong file hiện có.
+- Trích xuất kết quả chạy test quan trọng.
+
+### 3. Báo cáo & Tổng kết (The Chronicler) 📜
+- **Hành động**: Tự động soạn thảo file `SUMMARY.md` nằm trong thư mục tính năng hiện hành. Nội dung bao gồm:
+    - **Yêu cầu**: Tóm tắt từ `brief.md`.
+    - **Kết quả**: Chi tiết các Phase đã hoàn tất.
+    - **Kỹ thuật**: Danh sách file thay đổi và kết quả test.
+    - **Hành động tiếp theo**: Gợi ý các bước phát triển (nếu có).
+- **Trình bày**: Gửi một bản tóm tắt ngắn gọn và link đến file `SUMMARY.md` cho người dùng.
+
+### 4. Lắng nghe Phản hồi
+- Sẵn sàng giải thích quyết định kỹ thuật hoặc chỉnh sửa nhỏ nếu người dùng yêu cầu sau review.
+
+## Công cụ sử dụng
+- `read_file`: Đọc lại kế hoạch và mã nguồn.
+- `write_file`: Để "xuất bản" file `SUMMARY.md`.
+- `execute_command`: Chạy lệnh xác minh, linting và test tổng thể.
+
+## Lưu ý cho Agent
+- Báo cáo phải trung thực: Nêu rõ nếu có phần nào chưa hoàn hảo.
+- Luôn giữ thái độ cầu thị và sẵn sàng hỗ trợ người dùng kiểm tra kết quả.

package/templates/standard/.claude/skills/workflow-executor/SKILL.md

@@ -0,0 +1,48 @@
+# Kỹ năng: Workflow Executor 🚀
+
+## Mô tả
+Kỹ năng này đóng vai trò là "động cơ" điều phối việc thực thi các kế hoạch lập trình. Nó cho phép Agent tự động hóa quá trình làm việc bằng cách đọc trạng thái từ các file kế hoạch và phối hợp các bộ kỹ năng khác để hoàn thành nhiệm vụ theo từng giai đoạn (Phase).
+
+## Quy trình của Kỹ năng
+
+### 1. Định vị Nhiệm vụ
+- **Đọc file ACTIVE**: Tìm và đọc nội dung file `plans/ACTIVE` để xác định thư mục tính năng đang xử lý.
+- **Xác nhận Phase**: Dựa trên yêu cầu người dùng (ví dụ: "Thực hiện Phase 1"), tìm file phase tương ứng:
+  - **Ưu tiên mới**: Tìm trong `phases/phase-n.md` (cấu trúc mới).
+  - **Dự phòng**: Nếu không có, tìm `phase-n.md` ở gốc thư mục tính năng (tương thích ngược).
+
+### 2. Điều phối Thực thi
+- **Đọc danh sách Task**: Phân tích các task trong file `phase-n.md`.
+- **Gọi kỹ năng bổ trợ**: 
+    - Sử dụng kỹ năng `implement` để thực hiện TDD cho từng task.
+    - Sử dụng kỹ năng `quality-guard` để dọn dẹp và tối ưu sau thay đổi lớn.
+- **Xử lý tuần tự**: Đảm bảo hoàn thành dứt điểm từng task trước khi sang task kế tiếp.
+- **Phát nhịp đập (Heartbeat)**: Sau mỗi task hoàn thành, Agent phải gửi thông báo cập nhật tiến độ ngắn gọn cho người dùng để duy trì tính minh bạch.
+
+### 3. Cập nhật Trạng thái
+- **Chốt Phase**: Sau khi hoàn thành toàn bộ nội dung trong `phase-n.md`, Agent phải:
+    - Cập nhật trạng thái `[x]` cho Phase tương ứng trong file `plan.md` chính.
+    - Thực hiện **Checkpointing**: Tóm tắt kết quả Phase vừa xong cho người dùng.
+
+## Công cụ sử dụng
+- `read_file`: Đọc file `ACTIVE`, `plan.md` và các file phase.
+- `edit_file`: Cập nhật trạng thái trong `plan.md`.
+- Phối hợp với kỹ năng: `implement`, `quality-guard`.
+
+## Cấu trúc Đường dẫn Phase File
+**Cấu trúc mới (ưu tiên):**
+```
+plans/<date>-<feature>/phases/phase-n.md
+```
+
+**Cấu trúc cũ (tương thích ngược):**
+```
+plans/<date>-<feature>/phase-n.md
+```
+
+Agent tự động kiểm tra cả hai vị trí, ưu tiên cấu trúc mới.
+
+## Lưu ý cho Agent
+- **Kiểm tra file ACTIVE**: Nếu không tồn tại, phải hỏi người dùng để xác định nhiệm vụ.
+- **Tính chính xác**: Không thực thi Phase đã đánh dấu hoàn thành (`[x]`) trừ khi có yêu cầu làm lại.
+- **Giao tiếp**: Báo cáo ngay nếu gặp lỗi không thể tự xử lý trong quá trình chạy Phase.

package/templates/standard/.claude/templates/plans/bugfix.md

@@ -0,0 +1,13 @@
+# Mẫu Kế hoạch: Sửa lỗi (Bug Fix) 🐞
+
+## Phase 1: Tái hiện & Phân tích 🔍
+- [ ] Task 1.1: Tạo file test để tái hiện chính xác lỗi (Reproduce).
+- [ ] Task 1.2: Xác định nguyên nhân gốc rễ (Root Cause Analysis).
+
+## Phase 2: Khắc phục & Kiểm chứng 🛠️
+- [ ] Task 2.1: Sửa đổi logic để khắc phục lỗi.
+- [ ] Task 2.2: Chạy lại test để xác nhận lỗi đã biến mất và không gây lỗi phụ.
+
+## Phase 3: Rà soát & Đóng gói 🏁
+- [ ] Task 3.1: Sử dụng Quality Guard kiểm tra tính toàn vẹn.
+- [ ] Task 3.2: Cập nhật bài học vào Project Memory để tránh lặp lại lỗi.

package/templates/standard/.claude/templates/plans/feature.md

@@ -0,0 +1,17 @@
+# Mẫu Kế hoạch: Tính năng mới 🚀
+
+## Phase 1: Chuẩn bị & Thiết kế 🏗️
+- [ ] Task 1.1: Phân tích cấu trúc logic và các thành phần liên quan.
+- [ ] Task 1.2: Thiết kế Interface/API và cấu trúc dữ liệu.
+
+## Phase 2: Kiểm thử (TDD) 🧪
+- [ ] Task 2.1: Viết các Unit Test bao phủ yêu cầu chính.
+- [ ] Task 2.2: Xác minh Test thất bại (Red Phase).
+
+## Phase 3: Thực thi Logic ⚙️
+- [ ] Task 3.1: Triển khai mã nguồn để pass các bài test.
+- [ ] Task 3.2: Refactor code và tối ưu hóa ban đầu.
+
+## Phase 4: Kiểm định & Bàn giao 🏁
+- [ ] Task 4.1: Chạy Quality Guard để dọn dẹp rác.
+- [ ] Task 4.2: Tổng kết và Archive nhiệm vụ.

package/templates/standard/.claude/templates/plans/refactor.md

@@ -0,0 +1,13 @@
+# Mẫu Kế hoạch: Tối ưu hóa (Refactor) ⚡
+
+## Phase 1: Đo lường & Lập sơ đồ 📊
+- [ ] Task 1.1: Xác định các đoạn code cần tối ưu (Performance/Complexity).
+- [ ] Task 1.2: Đảm bảo bộ test hiện tại đang hoạt động tốt để bảo vệ logic cũ.
+
+## Phase 2: Thực thi Tối ưu 🛠️
+- [ ] Task 2.1: Tiến hành thay đổi mã nguồn (vẫn đảm bảo pass test 100%).
+- [ ] Task 2.2: Đo lường lại hiệu suất sau khi thay đổi.
+
+## Phase 3: Hoàn thiện 🏁
+- [ ] Task 3.1: Dọn dẹp các đoạn code thừa, hằng số dư thừa.
+- [ ] Task 3.2: Cập nhật bản đồ STRUCTURE.md nếu có thay đổi cấu trúc.

package/templates/standard/.claude/workflow/1-context.md

@@ -0,0 +1,23 @@
+# Bước 1: Context & Analysis 🔍
+
+## Mục tiêu
+**Discovery Specialist** phải hiểu rõ yêu cầu của người dùng và nắm bắt đầy đủ ngữ cảnh của codebase hiện tại trước khi đưa ra bất kỳ đề xuất nào.
+
+## Chỉ dẫn cho Agent
+1. **Kiểm tra Ngữ cảnh & Trạng thái**:
+   - Tìm và đọc file `STRUCTURE.md` đầu tiên để nắm bắt nhanh kiến trúc dự án.
+   - **BẮT BUỘC**: Đọc file `.claude/rules/project-memory.md` (được nạp tự động qua Claude Rules) để nắm bắt sở thích của người dùng và các quyết định quan trọng đã chốt.
+   - Kiểm tra thư mục `plans/` để tìm các kế hoạch dở dang thông qua file `plans/ACTIVE`.
+2. **Phân loại nhiệm vụ**: Sử dụng kỹ năng `project-discovery` để xác định yêu cầu là `Tiny Task` hay `Standard Task` (Dựa trên điểm rủi ro 1-5).
+3. **Thu thập yêu cầu**: Đọc kỹ tin nhắn của người dùng để xác định mục tiêu cuối cùng.
+4. **Quét Codebase**: Tìm kiếm các file liên quan đến yêu cầu.
+5. **Cơ chế Làm rõ (Interactive Clarification)**:
+   - **BẮT BUỘC**: Nếu có điểm mơ hồ hoặc nhiều phương án kỹ thuật, **Discovery Specialist** PHẢI sử dụng công cụ `AskUserQuestion` để đặt câu hỏi.
+   - **Định dạng câu hỏi**: Liệt kê các lựa chọn cụ thể có đánh số.
+6. **Phân tích**: Xác định các thành phần code bị ảnh hưởng và các rủi ro.
+
+## Kết quả đầu ra
+Một bản tóm tắt ngữ cảnh. Sau khi mọi thứ rõ ràng, **Discovery Specialist** BẮT BUỘC thực hiện các việc sau:
+1. Tạo thư mục `plans/<YYYY-MM-DD>-<feature-name>/`.
+2. Tạo file `brief.md` bên trong thư mục đó, tóm tắt: Yêu cầu, Phạm vi tác động, và Giải pháp kỹ thuật đã chốt.
+3. Sau đó bàn giao cho **System Architect** để sang **Bước 2: Planning**.

package/templates/standard/.claude/workflow/2-planning.md

@@ -0,0 +1,20 @@
+# Bước 2: Planning 📋
+
+## Mục tiêu
+**System Architect** tạo ra một bản kế hoạch chi tiết, minh bạch được phân rã thành các Phase nhỏ để người dùng có thể kiểm soát và theo dõi.
+
+## Chỉ dẫn cho Agent
+1. **Đọc Brief**: Luôn bắt đầu bằng việc đọc kỹ file `plans/<YYYY-MM-DD>-<feature-name>/brief.md` đã tạo ở Bước 1.
+2. **Khởi tạo cấu trúc kế hoạch**: Dựa trên nội dung Brief để:
+   - Tạo file `plan.md` chính để quản lý trạng thái các Phase.
+   - Tạo thư mục `phases/` và các file `phase-n.md` chi tiết chứa danh sách task để thực thi.
+   - Đánh dấu nhiệm vụ hiện hành qua file `plans/ACTIVE`.
+3. **Phân rã kế hoạch (Phasing)**:
+   - Chia nhỏ yêu cầu thành các **Phase** (Giai đoạn).
+   - **BẮT BUỘC phải có Phase hoặc Task dành cho việc viết Test Case.**
+   - Trong mỗi Phase, chia nhỏ thành các **Task** cụ thể (Lưu ý: Chia càng nhỏ càng tốt nhưng không cần prefix checkbox `[ ]` trong file phase).
+4. **Định dạng plan.md (Tổng quát)**: Liệt kê danh sách các Phase kèm theo trạng thái (ví dụ: Phase 1: [ ], Phase 2: [ ]). Đây là file duy nhất dùng để quản lý trạng thái.
+5. **Trạng thái ban đầu**: Tất cả các Phase trong `plan.md` phải ở trạng thái `[ ]`.
+
+## Kết quả đầu ra
+Cấu trúc kế hoạch tại `plans/` được khởi tạo hoàn chỉnh. Sau đó, thông báo cho người dùng kiểm tra và bàn giao cho **Senior Coder** để sang **Bước 3: Execution**.

package/templates/standard/.claude/workflow/3-execution.md

@@ -0,0 +1,22 @@
+# Bước 3: Execution & Tracking ⚙️
+
+## Mục tiêu
+**Senior Coder** thực hiện các nhiệm vụ trong kế hoạch một cách chính xác theo từng Phase và cập nhật tiến độ liên tục vào file kế hoạch chính.
+
+## Chỉ dẫn cho Agent
+1. **Xác định Nhiệm vụ**: Làm việc trực tiếp trên file `plans/ACTIVE` và các file chi tiết tại `phases/` đã tạo ở Bước 2.
+2. **Thực hiện theo tư duy TDD (Test-Driven Development)**:
+   - **BẮT BUỘC viết Test trước khi viết code logic**: Tạo các file test và định nghĩa các case cần pass qua kỹ năng `implement`.
+   - Chỉ khi Test đã được thiết lập xong mới bắt đầu triển khai code logic.
+3. **Thực hiện theo Phase & Báo cáo tiến độ**:
+   - Hoàn thành dứt điểm toàn bộ nội dung trong file `phase-n.md` trước khi sang Phase tiếp theo.
+   - **Heartbeat (Nhịp đập)**: Sau mỗi task nhỏ hoàn thành, Agent phải gửi một dòng cập nhật tiến độ siêu ngắn (Ví dụ: "✅ Xong task 1.1...").
+   - **Chốt Phase**: Chỉ khi hoàn thành toàn bộ Phase, cập nhật trạng thái `[x]` cho Phase tương ứng trong file `plan.md` chính.
+   - **Checkpointing**: Tóm tắt nhanh kết quả sau mỗi Phase lớn hoàn thành.
+4. **Tự sửa lỗi & Cơ chế Cứu hộ (Escalation)**:
+   - Nếu gặp lỗi, tự phân tích dựa trên ngữ cảnh để khắc phục.
+   - **Quy tắc 3 lần**: Nếu một task không thể hoàn thành sau 3 nỗ lực sửa đổi liên tiếp, Agent **BẮT BUỘC** phải dừng lại, báo cáo cho người dùng và triệu hồi **Discovery Specialist** để phân tích lại hoặc đề xuất hướng đi mới (Pivot).
+5. **Cập nhật trạng thái trực tiếp**: Không cập nhật trạng thái checkbox vụn vặt trong các file phase.
+
+## Kết quả đầu ra
+Tất cả các Phase trong file `plan.md` đều được đánh dấu `[x]`. Sau đó bàn giao cho **QA Engineer** để sang **Bước 4: Final Review**.

package/templates/standard/.claude/workflow/4-review.md

@@ -0,0 +1,22 @@
+# Bước 4: Final Review 🏁
+
+## Mục tiêu
+**QA Engineer** tổng kết toàn bộ các Phase đã thực hiện, xác minh chất lượng sản phẩm cuối cùng và trình bày cho người dùng kiểm tra.
+
+## Chỉ dẫn cho Agent
+1. **Rà soát Quy tắc (Rule Cross-check)**: QA Agent tự động đọc lại các hướng dẫn trong `.claude/rules/` để đảm bảo kết quả thực hiện không bị trôi dạt khỏi quy chuẩn ban đầu.
+2. **Kiểm tra file kế hoạch**: Mở file `plan.md` và đảm bảo tất cả các Phase đều đã được đánh dấu `[x]`.
+2. **Kiểm tra chất lượng (Quality Guard)**:
+   - **BẮT BUỘC** sử dụng kỹ năng `quality-guard` để rà soát lỗi, dọn rác và tối ưu hiệu suất/bộ nhớ dựa trên `.claude/rules/project-memory.md`.
+3. **Xác minh kỹ thuật**:
+   - Sử dụng `verification-review` để chạy test tổng thể và kiểm tra tiêu chuẩn code.
+4. **Báo cáo tổng kết**: Gửi một bản tóm tắt cho người dùng bao gồm:
+   - Các tính năng chính đã triển khai qua từng Phase.
+   - Danh sách file mới/sửa đổi.
+   - Kết quả từ `quality-guard` và các lệnh test.
+5. **Bảo trì Bản đồ (Self-Maintenance)**:
+   - Cập nhật lại `STRUCTURE.md` nếu có thay đổi cấu trúc quan trọng.
+6. **Chờ xác nhận**: Thông báo cho người dùng kiểm tra lại kết quả cuối cùng.
+
+## Điều kiện chuyển bước
+Sau khi người dùng xác nhận kết quả OK, **QA Engineer** chuyển sang **Bước 5: Archiving**.

package/templates/standard/.claude/workflow/5-archiving.md

@@ -0,0 +1,14 @@
+# Bước 5: Archiving 📦
+
+## Mục tiêu
+**QA Engineer** dọn dẹp không gian làm việc sau khi hoàn tất tính năng bằng cách lưu trữ hoặc xóa bỏ theo ý muốn của người dùng.
+
+## Chỉ dẫn cho Agent
+1. **Tham vấn Người dùng**: Sử dụng kỹ năng `archiver` để hỏi người dùng về việc **Di chuyển** kế hoạch vào `plans/archive/` hay **Xóa** bỏ.
+2. **Thực hiện Lưu trữ/Dọn dẹp**:
+   - Tiến hành thao tác file theo lựa chọn của người dùng.
+   - **Xóa file ACTIVE** sau khi hoàn tất.
+3. **Thông báo kết thúc**: Xác nhận với người dùng sau khi đã thực hiện xong và sẵn sàng cho nhiệm vụ tiếp theo.
+
+## Kết quả đầu ra
+Dự án trở về trạng thái sạch, sẵn sàng cho nhiệm vụ mới. Quy trình chính thức đóng lại.

package/templates/standard/CLAUDE.md

@@ -0,0 +1,20 @@
+# Luna AI Agent Framework 🌙
+
+Bạn là một **Tổng quản Thông minh (Autonomous Orchestrator)** mang tên **Luna**. Nhiệm vụ của bạn là thấu hiểu "Vibe" của người dùng và điều phối đội ngũ Agent con hoàn thành công việc thông qua hệ thống Plugin linh hoạt.
+
+## 🚀 Cơ chế Plugin (Dynamic Skills)
+Hệ thống này vận hành dựa trên các Plugin kỹ năng. Bạn PHẢI:
+1. **Tự động Nhận diện**: Luôn quét thư mục `.claude/skills/` để cập nhật danh sách công cụ khả dụng. 
+2. **Kích hoạt tức thì**: Bất kỳ Plugin nào có file `SKILL.md` đều có thể được sử dụng ngay lập tức.
+
+## 🧰 Danh sách Plugin cốt lõi (Mặc định)
+- `project-discovery`, `project-mapper`, `memory-manager`, `git-manager`, `skill-creator`, `workflow-executor`, `research-documentation`, `plan-manager`, `implement`, `quality-guard`, `verification-review`, `archiver`.
+
+## 🛠 Cách thức hoạt động
+- **Rules**: Tự động tuân thủ các quy tắc tại `.claude/rules/`.
+- **Commands**: Hỗ trợ các lệnh điều khiển tại `.claude/commands/`.
+- **Vibe Coding**: Ưu tiên thấu hiểu ngôn ngữ tự nhiên để tự động rẽ nhánh quy trình.
+
+## 📜 Chú ý quan trọng
+- Luôn ưu tiên `STRUCTURE.md` và `project-memory.md`.
+- Mọi nhiệm vụ Standard phải có `brief.md` và `plan.md`.