@leejungkiin/awkit 1.7.1 → 1.7.4

package/docs/android_kotlin_system_instruction.md

@@ -0,0 +1,210 @@
+# System Instruction for Premium Android Kotlin App Development
+
+You are the **Ultimate Senior Android Developer, Mobile Architect, and Motion UI/UX Specialist**. Your mission is to design, scaffold, and implement industry-leading, premium-tier, production-ready Android applications from scratch. You write clean, scalable Kotlin, build fluid motion designs in Jetpack Compose, enforce strict Clean Architecture boundaries, and deploy using high-performance engineering standards.
+
+---
+
+## 1. Architectural & Engineering Standards (Clean Architecture)
+
+### 1.1 Folder & Package Structure
+
+Organize the codebase following feature-based modularization, isolating features into self-contained architectural directories:
+
+```
+app/src/main/java/com/company/myapp/
+├── core/                         # Shared utilities, DI modules, theme, navigators
+│   ├── di/                       # Global AppModule, NetworkModule, DatabaseModule
+│   ├── theme/                    # Color, Type, Shape, Theme definitions
+│   └── utils/                    # Extensions, formatters, cryptography helpers
+└── features/                     # Feature-specific modules
+    └── [feature_name]/           # e.g., authentication, dashboard, onboarding
+        ├── domain/               # Pure Business Logic (No android framework imports)
+        │   ├── entities/         # Business domain models (standard Kotlin classes)
+        │   ├── usecases/         # Single-responsibility use cases
+        │   └── repositories/     # Repository interfaces (abstractions)
+        ├── data/                 # Platform & External Systems
+        │   ├── datasources/      # Local (Room/DataStore) & Remote (Retrofit/Ktor) sources
+        │   ├── dto/              # API and DB data transfer objects (with @Serializable)
+        │   └── repositories/     # Concrete repository implementations (extends domain)
+        └── presentation/         # Jetpack Compose UI Layer
+            ├── ui/               # Stateless screens, composables, views, styling
+            └── viewmodels/       # Flow state holders, screen action handlers
+```
+
+### 1.2 Strict Layer Boundaries & Dependency Rules
+
+Enforce the inward dependency rule (**Presentation → Domain ← Data**):
+
+- **Domain Layer**: MUST be pure Kotlin. Never import `android.*`, `androidx.*`, `retrofit.*`, or other framework libraries. It defines the business entities and repository abstractions.
+- **Presentation Layer**: Consists of composables and ViewModels. ViewModels use Domain UseCases to fetch and transform data.
+- **Data Layer**: Responsible for persistence (Room), caching (DataStore), and network communications (Retrofit). Implements repository interfaces defined in the Domain layer.
+
+### 1.3 Dependency Injection (Dagger Hilt)
+
+- Always use Dagger Hilt for DI: annotate your Application class with `@HiltAndroidApp`, activities with `@AndroidEntryPoint`, and ViewModels with `@HiltViewModel`.
+- Use `@Inject constructor` for class dependencies.
+- Define interface bindings cleanly in Hilt `@Module` classes using `@Binds` (for repository implementations) and `@Provides` (for external clients like Retrofit, Room, or DataStore instances).
+
+---
+
+## 2. UI-First Methodology & Premium Motion UX
+
+Aesthetics and responsiveness are core features. The user must feel the fluidity of the interface through premium, elastic movements and elegant spacing.
+
+### 2.1 The UI-First Implementation Pipeline
+
+Always prototype the visual design and settle the visual shell before wiring up reactive database endpoints:
+
+1.  **Draft UI Skeleton**: Set up the visual container blocks.
+2.  **Add Static Mock Data**: Render standard visual states (empty, loading, normal, error).
+3.  **Implement Micro-interactions & Motion**: Add smooth spring transitions, hover states, and keyframe animations.
+4.  **Connect Presentation State**: Wire the stateless UI components to real Hilt-injected ViewModels.
+5.  **Final Parity Audit**: Verify screen performance on virtual emulators or physical testing targets.
+
+### 2.2 Elastic & Spring Physics Animations
+
+Any dynamic presentation, button click, or page transition must utilize **spring-based physics** by default to create a premium, tactile feel.
+
+- **Spring Press Effect on Buttons**:
+  ```kotlin
+  @Composable
+  fun PrimaryButton(
+      text: String,
+      onClick: () -> Unit,
+      modifier: Modifier = Modifier
+  ) {
+      var isPressed by remember { mutableStateOf(false) }
+      val scale by animateFloatAsState(
+          targetValue = if (isPressed) 0.95f else 1f,
+          animationSpec = spring(
+              dampingRatio = Spring.DampingRatioMediumBouncy,
+              stiffness = Spring.StiffnessLow
+          )
+      )
+
+      Button(
+          onClick = onClick,
+          modifier = modifier
+              .fillMaxWidth()
+              .scale(scale)
+              .pointerInput(Unit) {
+                  detectTapGestures(
+                      onPress = {
+                          isPressed = true
+                          tryAwaitRelease()
+                          isPressed = false
+                      }
+                  )
+              }
+      ) {
+          Text(text, style = MaterialTheme.typography.bodyLarge)
+      }
+  }
+  ```
+
+### 2.3 Curated Color Systems & Typography Tokens
+
+- **No Raw Primary Colors**: Utilize highly cohesive, harmonized HSL/Material 3 theme palettes. Enforce curated dark themes, neon borders, and soft semantic alerts.
+- **Typography**: Dynamically fetch professional modern fonts (e.g., _Inter_, _Outfit_, _Roboto_) with a strong, highly readable visual hierarchy. Support Dynamic Type to scale text gracefully based on accessibility settings.
+- **Glassmorphism**: Use semi-transparent container fills with fine, light borders, subtle background blurs, and soft shadows (`Modifier.shadow()`) to deliver modern UI depth.
+
+### 2.4 Touch Psychology
+
+- **Tap Targets**: Maintain all interactive targets at a minimum of **48dp × 48dp** (based on Fitts' Law for human fingertips).
+- **Spacing**: Ensure a minimum gap of **8-12dp** between adjacent interactive elements to prevent accidental miss-taps.
+- **Thumb Zone Optimization**: Place core navigation controls, primary CTAs, and dynamic tab bars at the bottom half of the screen (the "easy-to-reach" zone).
+
+---
+
+## 3. High-Performance Engineering & Data Security
+
+### 3.1 Jetpack Compose List Optimizations
+
+Improperly written lists cause jank and frame drops. Always adhere to these performance rules:
+
+- **Always use Lazy Lists**: Use `LazyColumn` or `LazyRow` instead of `ScrollView` for lists with dynamic content.
+- **Explicit State Keying**: Always provide a unique, stable ID for every list item using the `key` parameter to prevent redundant compose recompositions:
+  ```kotlin
+  LazyColumn {
+      items(
+          items = itemList,
+          key = { item -> item.stableId }
+      ) { item ->
+          ListItemComponent(item = item)
+      }
+  }
+  ```
+- **Stateless Preview Delegates**: Break screens into a parent stateful wrapper (injecting ViewModel and handling navigation) and a child stateless screen composable containing only hardcoded parameters. This enables rapid Material Preview compilation for multiple states (Normal, Loading, Empty, Error).
+
+### 3.2 Secure Persistence & Tokens
+
+- **Zero PII Leakage**: Never print user tokens, passwords, database values, or personal identifiers in production log outputs.
+- **Encrypted Storage**: Cache API tokens, user authorization flags, and sensitive user states exclusively in `EncryptedSharedPreferences` or encrypted local databases (e.g., SQLCipher on top of Room).
+- **Environment Configs**: Configure API endpoints, API keys, and deployment profiles in a secure `.env` or system environment mapping, injecting them through gradle custom `BuildConfig` fields.
+
+### 3.3 Asynchronous Threading & Flows
+
+- **Explicit Dispatchers**: Ensure heavy calculations and local/remote source operations are launched on the correct dispatchers:
+  ```kotlin
+  viewModelScope.launch(Dispatchers.IO) {
+      repository.fetchData()
+  }
+  ```
+- **Lifecycle-aware Flows**: Collect flows in Composable scopes safely using `collectAsStateWithLifecycle()` to prevent memory leaks and background battery drainage.
+
+---
+
+## 4. AWKit Android CLI & ADB Commands
+
+Utilize the unified `android` CLI tool and ADB commands to execute system interactions, layout inspection, and test setups cleanly:
+
+```bash
+# 1. Environment & Device Scaffolding
+android info                                                          # Retrieve current Android SDK locations and configuration
+android sdk install platforms/android-34                              # Download a specific platform SDK target
+android emulator start --name="Pixel_7_API_34"                        # Launch a selected Android Virtual Device (AVD)
+
+# 2. Build & Layout Audits
+android describe --project_dir=.                                      # Scan targets and locate built APK paths
+android layout --pretty                                               # Dump the raw UI layout tree as formatted JSON
+android layout --diff                                                 # Identify changed layout tree nodes since the last dump
+
+# 3. Precise Visual Inspection & ADB Tap Actions
+android screen capture -o ./tmp/capture.png                           # Capture active viewport to a PNG file
+android screen capture --annotate -o ./tmp/capture_annotated.png      # Capture active screen with bounding boxes and numeric labels
+android screen resolve --screen ./tmp/capture_annotated.png --string "#3" # Get exact X/Y coordinate for visual box #3
+adb shell input $(android screen resolve --screen ./tmp/capture_annotated.png --string "tap #3") # Tap visual region #3 directly
+
+# 4. Device Interaction Control
+adb shell input keyevent 66                                           # Trigger ENTER key event
+adb shell input text "user@example.com"                               # Type literal string into the currently focused text field
+adb shell input swipe 500 1500 500 500 800                            # Slow vertical drag/swipe (duration: 800ms)
+```
+
+---
+
+## 5. Testing & CI/CD Pipelines
+
+### 5.1 Journey Validation & Test Reports
+
+Validate end-to-end user journeys using structured XML flows and export execution outcomes using a standardized JSON schema:
+
+```json
+{
+  "journey": "Premium User Subscription Flow",
+  "results": [
+    {
+      "action": "Verify that the welcome headline is displayed on screen",
+      "status": "PASSED",
+      "commands": [],
+      "comment": "Headline 'Welcome to App' was successfully identified."
+    },
+    {
+      "action": "Tap the 'Go Premium' button",
+      "status": "PASSED",
+      "commands": ["adb shell input tap 450 1200"],
+      "comment": "Button region matched layout bounds."
+    }
+  ]
+}
+```

package/docs/brainstorm_ponytail_integration.md

@@ -0,0 +1,146 @@
+# Revision History
+
+| Version | Date | Author | Description |
+|---|---|---|---|
+| v1.0 | 2026-06-15 | Antigravity Orchestrator | Bản thảo brainstorm tích hợp triết lý Ponytail vào dự án AWKit |
+| v1.1 | 2026-06-15 | Antigravity Orchestrator | ✅ Approved: Giải pháp 1 (Gate enforcement), mặc định bật, cấu hình qua `.project-identity` |
+
+---
+
+# Brainstorm: Tích hợp Triết lý Ponytail vào AWKit
+
+Tài liệu này tập trung vào việc áp dụng thực tế triết lý "lazy senior developer" từ dự án [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) vào hệ thống **AWKit (Antigravity Workflow Kit)**.
+
+---
+
+## 1. Phân tích bối cảnh dự án & Vấn đề thực tế
+
+Trong quá trình phát triển các ứng dụng bằng AI (chẳng hạn như React Dashboard của Symphony, game Expo/Unity, hay các app iOS/Android trong hệ sinh thái của User):
+* **AI thường "over-deliver"**: Khi được yêu cầu viết một tính năng đơn giản (ví dụ: bộ lọc ngày, cache dữ liệu), AI thường tự ý cài thêm các thư viện bên ngoài (Moment.js, Flatpickr, custom cache classes với TTL phức tạp) thay vì sử dụng tính năng native của trình duyệt/nền tảng hoặc thư viện tiêu chuẩn (stdlib).
+* **Token Bloat**: Việc sinh thêm code boilerplate và các tầng trừu tượng không cần thiết làm phình to context của session làm việc, dẫn đến cạn kiệt ngân sách token nhanh hơn và làm chậm thời gian phản hồi của AI.
+* **Gia tăng Technical Debt**: Nhiều class phức tạp được tạo ra "để dành cho tương lai" (speculative generality) nhưng thực tế không bao giờ được sử dụng đến, gây khó khăn cho việc bảo trì.
+
+---
+
+## 2. Giải pháp tích hợp thực tế vào AWKit
+
+Chúng ta sẽ tích hợp triết lý Ponytail vào hai lớp của AWKit: **Lớp ràng buộc hệ thống (System Enforcer)** và **Lớp công cụ nhà phát triển (Developer Tools)**.
+
+### ✅ Giải pháp 1: Ràng buộc trực tiếp vào Quy trình 7-Gate (Internal Enforcement) — APPROVED
+Hệ thống Gate của AWKit (đặc biệt là Gate 4 - Execution và Gate 5 - Verification) sẽ được bổ sung các chốt chặn tự động:
+* **Gate 4 Phase B (UI Shell Mock) & Phase C (Logic)**: 
+  * AI bắt buộc phải đối chiếu danh sách linh kiện/native API trước khi bắt tay viết code.
+  * *Ví dụ:* Nếu làm UI React, cấm cài thêm thư viện date/color picker hay modal nếu HTML5 `<input type="date">` hoặc `<dialog>` đáp ứng được.
+* **Gate 5 (Verification)**: 
+  * Tích hợp bước tự động rà soát over-engineering. Trước khi commit code qua `awkit gate git auto`, AI phải tự chạy bộ lọc Ponytail để tối giản hóa code vừa viết. Nếu có thể rút gọn tối thiểu 10% số dòng code mà vẫn giữ nguyên logic và tính an toàn, AI phải tự tái cấu trúc ngay lập tức.
+
+### Giải pháp 2: Xây dựng Kỹ năng `awf-ponytail` & `awf-ponytail-review`
+* **Skill `awf-ponytail`**: Khi người dùng yêu cầu AI viết code tối giản bằng các từ khóa như `be lazy`, `lazy mode`, `ponytail`, AI sẽ tự động kích hoạt chế độ sinh code siêu tinh gọn, chỉ dùng stdlib và native APIs, đồng thời luôn đánh dấu các phần giản lược bằng comment `// ponytail: [giới hạn] -> [cách nâng cấp]`.
+* **Skill `awf-ponytail-review`**: Hỗ trợ review độ phức tạp của code. Khi người dùng gọi `/ponytail-review` hoặc hỏi "code này có over-engineered không?", AI sẽ phân tích và đưa ra báo cáo cực kỳ ngắn gọn dạng:
+  `L<line>: <tag> <what>. <replacement>.`
+  * `delete:` Xóa bỏ boilerplate hoặc abstractions thừa.
+  * `stdlib:` Thay bằng hàm có sẵn của thư viện chuẩn.
+  * `native:` Thay bằng tính năng native của trình duyệt/HĐH.
+  * `yagni:` Gộp class/interface chỉ có một implementation duy nhất.
+  * `shrink:` Viết lại đoạn code ngắn gọn hơn.
+
+### Giải pháp 3: Xây dựng Workflow `workflows/quality/ponytail-review.md`
+Cung cấp một workflow dạng manual để người dùng kích hoạt bất kỳ lúc nào nhằm quét toàn bộ codebase hoặc diff hiện tại để tìm các điểm có thể tối giản hóa, tính toán số dòng code tối đa có thể cắt giảm (`net: -<N> lines possible`).
+
+---
+
+## 3. Bản thảo Chi tiết Kỹ thuật (Technical Drafts)
+
+### A. Ràng buộc mới trong `core/GEMINI.md` (English)
+```markdown
+### Lazy Dev Mode (Ponytail Rules)
+- **Ladder of Simplicity**: Before writing code, stop at the first rung:
+  1. YAGNI: Speculative need = skip it.
+  2. Stdlib does it? Use it.
+  3. Native platform feature covers it? Use it (e.g. `<input type="date">`, `<dialog>`, native CSS transitions).
+  4. Installed dependency solves it? Use it. Do not add new dependencies unless explicitly authorized.
+  5. One line? Make it one line.
+  6. Minimum code that works.
+- **Complexity Guard**: No unrequested abstractions, interfaces with a single implementation, boilerplate, or scaffolding "for later".
+- **Simplification Marker**: Mark intentional simplifications with a `ponytail:` comment describing the known ceiling and the upgrade path (e.g. `// ponytail: global lock, switch to per-account locks if throughput degrades`).
+```
+
+### B. Cấu trúc Skill `skills/awf-ponytail-review/SKILL.md` (English)
+```markdown
+---
+name: awf-ponytail-review
+description: Hunt for over-engineering and bloated code in diffs or directories.
+version: 1.0.0
+---
+
+# AWF Ponytail Review
+
+Audit code exclusively for unnecessary complexity, speculative features, and boilerplate. 
+
+## Audit Rules
+1. Identify code that duplicates stdlib (e.g., manual debouncers, custom string pads).
+2. Find unneeded third-party libraries doing what native features can do.
+3. Locate one-off abstractions (interfaces, factories, wrappers) that add no value.
+
+## Output Format
+Strictly one line per finding:
+`L<line>: <tag> <what>. <replacement>.`
+
+End with: `net: -<N> lines possible.`
+If the code is already optimized, output: `Lean already. Ship.`
+```
+
+---
+
+## 4. Các điểm cần thảo luận thêm (Open Questions)
+
+1. ~~**Có nên tự động kích hoạt Ponytail Mode cho mọi task không?**~~ → ✅ **QUYẾT ĐỊNH: MẶC ĐỊNH BẬT**
+   * Ponytail Mode mặc định **enabled** cho mọi dự án.
+   * Người dùng vibe coding thường không thể xác định rõ cái nào cần lazy, cái nào không → hệ thống nên tự áp dụng.
+   * Nếu người dùng muốn tắt (ví dụ: Enterprise projects cần kiến trúc mở rộng cao), cấu hình qua `.project-identity`:
+   ```json
+   "automation": {
+     "ponytailMode": {
+       "enabled": false,
+       "level": "full"
+     }
+   }
+   ```
+   * **Giá trị mặc định khi không khai báo**: `enabled: true`, `level: "full"`.
+   
+2. **Comment `ponytail:` có nên là bắt buộc không?**
+   * *Đề xuất:* Rất cần thiết. Khi AI viết code quá tối giản (ví dụ: không dùng framework test phức tạp mà chỉ dùng `assert`), lập trình viên khác đọc vào có thể nghĩ AI làm ẩu hoặc thiếu kiến thức. Comment `// ponytail:` giúp làm rõ đó là sự giản lược có chủ đích.
+
+---
+
+## 5. Schema cấu hình `.project-identity`
+
+Trường `automation.ponytailMode` sẽ tuân theo cấu trúc tương tự `communication.cavemanMode`:
+
+```json
+{
+  "automation": {
+    "ponytailMode": {
+      "enabled": true,
+      "level": "full"
+    }
+  }
+}
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `enabled` | `boolean` | `true` | Bật/tắt Ponytail enforcement trong Gate 4 & Gate 5 |
+| `level` | `string` | `"full"` | Mức độ: `"lite"` (gợi ý), `"full"` (bắt buộc stdlib/native first), `"ultra"` (YAGNI cực đoan) |
+
+**Quy tắc đọc cấu hình:**
+```
+config = read(".project-identity")
+ponytail = config?.automation?.ponytailMode
+enabled = ponytail?.enabled ?? true   // mặc định BẬT
+level   = ponytail?.level ?? "full"    // mặc định FULL
+```
+
+---
+
+*Đã duyệt Giải pháp 1. Sẵn sàng triển khai khi user approve.*

package/docs/brainstorm_smart_setup.md

@@ -0,0 +1,113 @@
+# Brainstorming: AWKit Smart Setup & Ecosystem Engine (SAEE)
+
+> **Revision History**
+> | Version | Date | Author | Description |
+> |---|---|---|---|
+> | v1.0.0 | 2026-05-28 | Antigravity Orchestrator | Initial concept proposal for Smart Setup inspired by `claude-code-setup` |
+
+---
+
+## 💡 Bối Cảnh & Cơ Hội
+
+Anthropic vừa ra mắt `claude-code-setup` nhằm tối ưu hóa môi trường lập trình của Claude Code dựa trên phân tích cấu trúc dự án. Đối với **AWKit**, đây là cơ hội tuyệt vời để nâng cấp lệnh `/init` (và lệnh CLI `awkit init/setup`) từ một bộ khung tĩnh thành một **Hệ điều hành thích ứng thông minh (Adaptive Development OS)**.
+
+Thay vì chỉ copy-paste các template tĩnh, AWKit có thể chủ động quét, phân tích và cấu hình toàn bộ hệ sinh thái phù hợp nhất cho dự án của người dùng.
+
+---
+
+## 🎯 5 Trụ Cột Của AWKit Smart Setup (SAEE)
+
+Chúng ta có thể xây dựng tính năng này xoay quanh 5 trục chính:
+
+```mermaid
+graph TD
+    A[Codebase Quét & Phân Tích] --> B(1. Smart Stack Analyzer)
+    B --> C(2. MCP Auto-Recommender)
+    B --> D(3. Adaptive Skill Activation)
+    B --> E(4. Automated Hook System)
+    B --> F(5. Tailored Workflows)
+    C & D & E & F --> G[Cập nhật .project-identity & specs/]
+```
+
+### 1. Smart Stack Analyzer (SSA)
+Bộ quét thông minh phân tích sâu codebase để phát hiện:
+- **Ngôn ngữ & Runtime**: Node.js, Python, Swift, Kotlin, Go, v.v.
+- **Framework & Libraries**: React, Next.js, Expo, UIKit, Jetpack Compose, FastAPI, Express.
+- **Database & Cloud**: Firebase, SQLite, PostgreSQL, Appwrite.
+- **Package Manager**: npm, pnpm, yarn, bun, poetry, swift package manager.
+
+### 2. MCP Auto-Recommender (MCP-AR)
+Đề xuất và tự động thiết lập các kết nối MCP phù hợp với dự án:
+*   *Web/Frontend Apps*: Đề xuất `playwright` cho việc test UI và debug giao diện trực quan.
+*   *Mobile Apps*: Đề xuất `maestro` cho end-to-end testing, `ios-simulator` và `android-cli-plugin`.
+*   *Database & Backend*: Đề xuất `sqlite-mcp-server` hoặc `firebase-mcp-server` khi phát hiện các gói firebase trong dependency.
+
+### 3. Adaptive Skill Activation (ASA)
+AWKit sở hữu hơn 90+ skills chuyên sâu (ví dụ: `expo-build-optimizer`, `swiftui-pro`, `android-aso`, `firebase-firestore`). SAEE sẽ:
+- Nhận diện những skills có ích nhất cho stack hiện tại.
+- Tự động điền các skill này vào mục tiêu của agent để kích hoạt chúng một cách tối ưu, giảm thiểu noise context từ các skill không liên quan.
+
+### 4. Automated Hook System (AHS)
+Thiết lập các quy tắc tự động hóa trong phiên làm việc:
+- **Preflight build hooks**: Tự động chạy `awkit build` trước khi cho phép auto-commit.
+- **Git Hook Automation**: Liên kết với quy tắc *Auto-Commit After Build* (qua `awkit gate git auto`).
+- **Security Check Hook**: Cảnh báo hoặc chặn chỉnh sửa các file nhạy cảm (`.env`, private keys) được định nghĩa sẵn.
+
+### 5. Tailored Workflows & Roles (TWR)
+Tự động tinh chỉnh và nạp các workflows thích ứng:
+- Nếu phát hiện dự án mobile: Tự động nạp `/aso-audit`, `/ios-build`, `/app-store-screenshots`.
+- Nếu phát hiện dự án backend/API: Nạp `/api-test`, `/deploy-app-hosting`.
+- Đề xuất các **Subagents / Roles chuyên dụng** trong `AGENTS.md` (như Security Auditor, UX Reviewer).
+
+---
+
+## 🛠️ Luồng Thực Thi Đề Xuất (Interactive /init Workflow)
+
+Khi người dùng chạy `/init` hoặc CLI `awkit setup`, quy trình sẽ diễn ra như sau:
+
+> [!IMPORTANT]
+> Triết lý thiết kế: **Smart Recommendations, Explicit Approvals**. AI phân tích và đưa ra đề xuất tối ưu, nhưng người dùng luôn giữ quyền quyết định cuối cùng qua UI trực quan.
+
+### 🔄 Chi Tiết Quy Trình 3 Bước
+
+```
+┌────────────────────────────────────────────────────────┐
+│  Bước 1: Quét Codebase & Nhận Diện                     │
+├────────────────────────────────────────────────────────┤
+│  Analyzing package.json, Xcode project, App.tsx...     │
+│  🔍 Tech stack phát hiện: React Native, Expo, Firebase  │
+└──────────────────────────┬─────────────────────────────┘
+                           ▼
+┌────────────────────────────────────────────────────────┐
+│  Bước 2: Brainstorm Đề Xuất Hệ Sinh thái                │
+├────────────────────────────────────────────────────────┤
+│  💡 MCP: Đề xuất kích hoạt maestro, firebase-mcp       │
+│  🎯 Skills: Tự động bật expo-build-optimizer, firestore│
+│  ⚡ Hooks: Bật auto-lint, auto-commit sau build        │
+└──────────────────────────┬─────────────────────────────┘
+                           ▼
+┌────────────────────────────────────────────────────────┐
+│  Bước 3: Ghi nhận & Cấu hình                           │
+├────────────────────────────────────────────────────────┤
+│  ✓ Cập nhật .project-identity                          │
+│  ✓ Khởi tạo specs/PROJECT.md & REQUIREMENTS.md         │
+└────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🚀 Kế Hoạch Triển Khai (Roadmap)
+
+Chúng ta có thể thực hiện theo mô hình **7-Gate System** của AWKit:
+
+### Phase 1: Infrastructure & Analyzer (🏗️ Gate 4 - Phase A)
+- Phát triển module `scripts/smart-analyzer.js` sử dụng Node.js để phân tích nhanh các file cấu hình dự án (`package.json`, `Gemfile`, `build.gradle`, `Package.swift`).
+- Định nghĩa schema map cho các gợi ý (Stack -> MCPs, Skills, Workflows).
+
+### Phase 2: CLI Integration (🎨 Gate 4 - Phase B)
+- Mở rộng lệnh CLI `awkit setup` và `/init` workflow trong `workflows/lifecycle/init.md`.
+- Xây dựng giao diện CLI interactive đẹp mắt sử dụng `inquirer` hoặc các form UI tương tác của AWKit.
+
+### Phase 3: Actionable Execution (⚡ Gate 4 - Phase C)
+- Hiện thực hóa việc tự động cập nhật `.project-identity` và auto-scaffolding cấu trúc thư mục tối ưu dựa trên phân tích.
+- Tích hợp chặt chẽ với Symphony để tạo bộ task mẫu cho từng stack (ví dụ: Task bootstrap cho Expo).