@leejungkiin/awkit 1.0.6 → 1.0.8

package/skills/workflows/nm-snapshot.md

@@ -0,0 +1,69 @@
+---
+description: Export NeuralMemory brain state to JSON snapshot (portable consciousness)
+---
+
+# /nm-snapshot — Brain Snapshot Export
+
+## When to use
+- Trước khi switch AI tools hoặc agents
+- Backup trước sprint hoặc major refactor
+- Share brain với teammate/agent
+- "Portable Consciousness" — export & re-import vào agent khác
+
+## Steps
+
+### Step 1: Choose snapshot scope
+```
+Snapshot scope:
+  a) Full brain — all memories + synapses
+  b) Topic scope — memories matching [topic]
+  c) Recent — memories from last [N] days
+  d) High priority — priority >= 7 only
+
+[Choose scope]
+```
+
+### Step 2: Generate snapshot
+```python
+# Export to JSON
+snapshot = {
+  "version": "1.0",
+  "exported_at": "2026-02-26T12:00:00Z",
+  "project": "<from .project-identity>",
+  "scope": "<chosen scope>",
+  "memories": [...],
+  "synapses": [...],
+  "stats": {
+    "total_memories": N,
+    "total_synapses": N,
+    "avg_priority": X.X
+  }
+}
+```
+
+### Step 3: Save + report
+```
+✅ Snapshot saved: brain_snapshot_2026-02-26.json
+
+  Memories: 127
+  Synapses: 245
+  Size: 48KB
+
+💡 To import into another agent:
+   nmem import brain_snapshot_2026-02-26.json
+   
+💡 To share with teammate:
+   Copy the JSON file and they run nmem import
+```
+
+## Portable Consciousness
+
+This snapshot is the "Brain-as-a-Service" concept from NeuralMemory's vision:
+- All associative reflexes are preserved in the synapse graph
+- Another agent loading this snapshot gets all the relationships
+- Not just facts — but the causal and temporal reasoning
+
+## Anti-patterns
+- Do NOT snapshot before deduplication (exports noise)
+- Do NOT share snapshots with sensitive credentials/tokens in memories
+- DO run /memory-audit before important snapshots

package/workflows/_uncategorized/nm-import.md

@@ -0,0 +1,73 @@
+---
+description: Import project knowledge into NeuralMemory (decisions, errors, patterns)
+---
+
+# /nm-import — Project Knowledge Import
+
+## When to use
+- Bắt đầu NeuralMemory trên project đã có sẵn
+- Sau khi `awkit enable-pack neural-memory` lần đầu
+- Muốn bulk-import từ brain/ Markdown files (legacy)
+
+## What to import
+
+```
+Priority 1 — Decisions (brain/decisions/*.md)
+Priority 2 — Solutions (brain/solutions/*.md)  
+Priority 3 — CODEBASE.md (architecture patterns)
+Priority 4 — .project-identity (project context)
+Priority 5 — git log (recent changes pattern)
+```
+
+## Steps
+
+### Step 1: Scan sources
+```
+Sources found:
+  brain/decisions/ — 12 files
+  brain/solutions/ — 8 files
+  CODEBASE.md — 1 file
+  .project-identity — 1 file
+
+Total import estimate: ~45 memories
+Proceed? [yes/no]
+```
+
+### Step 2: Parse each source
+For each file:
+- Extract individual information units
+- Classify by type (decision, error, fact, instruction)
+- Extract tags from content
+- Set priority based on type
+
+### Step 3: Deduplication
+```python
+# Check NeuralMemory for existing similar memories
+nmem_recall(content_keywords)
+# → Skip if identical
+# → Flag if conflicting
+```
+
+### Step 4: Batch import preview
+Show 10 at a time, confirm each batch
+
+### Step 5: Build synapse graph
+After import, run:
+```python
+nmem_auto()  # Auto-detect relationships between imported memories
+```
+
+### Step 6: Import summary
+```
+✅ Import Complete
+   Imported: 42 memories
+   Skipped: 3 duplicates
+   Auto-linked: 18 synapse connections
+
+Brain is now seeded. Run /memory-audit to check quality.
+```
+
+## Anti-patterns
+- Do NOT import everything blindly — quality over quantity
+- Do NOT import temporary notes or debug snippets
+- Do NOT skip the deduplication step (creates noise)

package/workflows/_uncategorized/nm-recall.md

@@ -0,0 +1,67 @@
+---
+description: Query NeuralMemory với associative recall (spreading activation)
+---
+
+# /nm-recall — NeuralMemory Associative Recall
+
+## When to use
+- Cần tìm lại quyết định, lỗi, hoặc patterns từ past sessions
+- Regular recall không đủ — cần associative links
+- Muốn surface hidden connections giữa các memories
+
+## Steps
+
+1. **Extract query keywords** từ user's question
+   - Lấy 3-5 keywords cốt lõi
+   - Bỏ qua stop words
+
+2. **Run activating recall**
+   ```
+   nmem_recall(query, depth=2)
+   ```
+   - `depth=1`: Instant recall — direct matches only
+   - `depth=2`: Context recall — + 1 hop via synapses (default)
+   - `depth=3`: Deep recall — use for complex architecture questions
+
+3. **Format recall results**
+   ```
+   🧠 Recalled [N] memories for: "[query]"
+   
+   [type] "[content excerpt]"
+   → Tags: [tags] | Priority: [P] | Age: [X days]
+   → Connected to: [related memory brief] via [synapse_type]
+   
+   [type] "[content excerpt]"
+   ...
+   ```
+
+4. **Surface connections**
+   - Highlight `CAUSED_BY`, `LEADS_TO`, `DISCUSSED` links
+   - Show causal chains when relevant: A → caused → B → leads to → C
+
+5. **If no results (depth=2)**
+   - Try `depth=3` automatically
+   - If still empty: "🧠 No relevant memories found. Consider /nm-intake to capture this."
+
+## Output Examples
+
+```
+🧠 Recalled 3 memories for: "auth JWT"
+
+[decision] "Chose JWT over sessions for stateless API auth"
+→ Tags: [auth, jwt, api, decision] | Priority: 8 | Age: 14 days
+→ Caused by: "Need to support mobile + web clients simultaneously"
+→ Leads to: "JWT stored in Authorization header, 24h expiry"
+
+[error] "Fixed: JWT middleware running before auth check caused 401 on valid tokens"
+→ Tags: [auth, jwt, middleware, error] | Priority: 7 | Age: 5 days
+→ Solution: "Reorder middleware: auth check → JWT verify → route handler"
+
+[instruction] "Never store JWT in localStorage — XSS vulnerability"
+→ Tags: [auth, security, jwt, instruction] | Priority: 9 | Age: 30 days
+```
+
+## Anti-patterns
+- Do NOT just keyword search — use NeuralMemory's associative engine
+- Do NOT show all memories — only top activations (max 8)
+- Do NOT skip connections — the synapse links ARE the value

package/workflows/_uncategorized/nm-snapshot.md

@@ -0,0 +1,69 @@
+---
+description: Export NeuralMemory brain state to JSON snapshot (portable consciousness)
+---
+
+# /nm-snapshot — Brain Snapshot Export
+
+## When to use
+- Trước khi switch AI tools hoặc agents
+- Backup trước sprint hoặc major refactor
+- Share brain với teammate/agent
+- "Portable Consciousness" — export & re-import vào agent khác
+
+## Steps
+
+### Step 1: Choose snapshot scope
+```
+Snapshot scope:
+  a) Full brain — all memories + synapses
+  b) Topic scope — memories matching [topic]
+  c) Recent — memories from last [N] days
+  d) High priority — priority >= 7 only
+
+[Choose scope]
+```
+
+### Step 2: Generate snapshot
+```python
+# Export to JSON
+snapshot = {
+  "version": "1.0",
+  "exported_at": "2026-02-26T12:00:00Z",
+  "project": "<from .project-identity>",
+  "scope": "<chosen scope>",
+  "memories": [...],
+  "synapses": [...],
+  "stats": {
+    "total_memories": N,
+    "total_synapses": N,
+    "avg_priority": X.X
+  }
+}
+```
+
+### Step 3: Save + report
+```
+✅ Snapshot saved: brain_snapshot_2026-02-26.json
+
+  Memories: 127
+  Synapses: 245
+  Size: 48KB
+
+💡 To import into another agent:
+   nmem import brain_snapshot_2026-02-26.json
+   
+💡 To share with teammate:
+   Copy the JSON file and they run nmem import
+```
+
+## Portable Consciousness
+
+This snapshot is the "Brain-as-a-Service" concept from NeuralMemory's vision:
+- All associative reflexes are preserved in the synapse graph
+- Another agent loading this snapshot gets all the relationships
+- Not just facts — but the causal and temporal reasoning
+
+## Anti-patterns
+- Do NOT snapshot before deduplication (exports noise)
+- Do NOT share snapshots with sensitive credentials/tokens in memories
+- DO run /memory-audit before important snapshots

package/workflows/_uncategorized/reverse-android-build.md

@@ -0,0 +1,222 @@
+---
+description: 🔨 RE Android Phase 2+3+4 — Blueprint + UI Shell → Logic Build → Final Parity (UI-First)
+parent: reverse-android
+---
+
+# /re-android-build — Blueprint + UI + Build (Per Feature)
+
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 2+3+4
+> **Prerequisite:** Completed Architecture from [`/re-android-design`](reverse-android-design.md)
+> **Skill:** `smali-to-kotlin` → `phase-2-blueprint-ui.md` + `phase-3-logic-build.md`
+
+---
+
+## 🔄 Feature Loop (UI-First)
+
+```
+For each feature (from Architecture Build Order):
+    Phase 2: Blueprint + UI (contracts + visual shell)
+        ↓ 🚦 GATE: User approves UI + contracts
+    Phase 3: Logic Build (domain → data → wire)
+        ↓ 📊 CHECKPOINT
+    → Next feature
+```
+
+---
+
+## 📐🎨 Phase 2: Blueprint + UI Design
+
+> **Output:** Approved contracts + Working Compose UI shell with mock data.
+
+### Part A: Contracts (signatures only)
+
+#### 2.1: Deep Smali Reading
+Read Smali files for the chosen feature. Extract class hierarchy, fields, method signatures,
+string constants, control flow. See `smali-reading-guide.md`.
+
+#### 2.2–2.5: Define Contracts
+```kotlin
+// 2.2 Domain Model
+data class [Model](val field: Type, ...)
+
+// 2.3 Repository Interface
+interface [Feature]Repository {
+    suspend fun [method](...): Result<[Type]>
+}
+
+// 2.4 API Interface
+interface [Feature]Api {
+    @[METHOD]("[endpoint]")
+    suspend fun [method](...): [Response]
+}
+
+// 2.5 UseCase
+class [Action]UseCase(repo: [Feature]Repository) {
+    suspend operator fun invoke(...): Result<[Type]> // TODO()
+}
+```
+
+#### 2.6: UI State Design
+```kotlin
+data class [Screen]UiState(
+    val field: Type = default,
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
+sealed interface [Screen]Event { /* navigation, snackbar */ }
+sealed interface [Screen]Action { /* user interactions */ }
+```
+
+### Part B: UI Visual Shell
+
+#### 2.7: Resource Extraction ⭐ (BEFORE UI code!)
+
+```bash
+# Only resources for THIS screen
+grep -o '@drawable/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+grep -o '@color/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+```
+
+Copy ONLY needed resources. Verify they compile.
+
+#### 2.8: UI Implementation ⭐ (Visual shell with mock data)
+
+- Use UiState from 2.6 with hardcoded defaults
+- Use REAL resources from 2.7
+- Create `[Screen]Content` composable (stateless)
+- Match visual parity with original app
+- NO ViewModel connection, NO real API calls
+
+```kotlin
+@Composable
+fun [Screen]Content(
+    uiState: [Screen]UiState = [Screen]UiState(),  // Mock
+    onAction: ([Screen]Action) -> Unit = {}          // No-op
+) {
+    // Full Compose UI matching original app
+}
+
+@Preview @Composable
+private fun NormalPreview() { AppTheme { [Screen]Content() } }
+
+@Preview @Composable
+private fun LoadingPreview() { AppTheme { [Screen]Content([Screen]UiState(isLoading = true)) } }
+
+@Preview @Composable
+private fun ErrorPreview() { AppTheme { [Screen]Content([Screen]UiState(error = "Error")) } }
+```
+
+#### 2.9: Visual Parity Check ⭐
+
+Compare with original app:
+- [ ] Layout structure matches
+- [ ] Colors, typography, spacing correct
+- [ ] Icons/images positioned correctly
+- [ ] All states: normal, loading, error, empty
+
+### 🚦 UI + Contracts Gate (MANDATORY)
+
+```
+"📐🎨 Blueprint + UI cho [Feature] xong:
+📝 Contracts: [N] models, [N] repos, [N] use cases, [N] APIs
+🎨 UI: [Screen] with [N] state previews
+📸 Visual Parity: [OK / needs adjustment]
+
+→ ✅ Approve → Phase 3 (Logic Build)
+→ 🎨 Adjust UI → fix then re-check
+→ 📝 Adjust contracts → revise"
+```
+
+> ⚠️ **DO NOT proceed to Phase 3 without user approval.**
+
+---
+
+## 🔨 Phase 3: Logic Build
+
+> **Output:** Full production-quality Kotlin code. Wire logic to EXISTING UI.
+
+### 3.1: Domain Layer
+Models + Repository interfaces + UseCases (implement invoke with repo calls)
+
+### 3.2: Data Layer
+DTOs + Retrofit API + Room (if applicable) + Repository implementation
+
+### 3.3: DI Module
+Hilt @Module with @Binds for repository
+
+### 3.4: ViewModel
+@HiltViewModel with StateFlow + SharedFlow, implements onAction()
+
+### 3.5: Wire UI ↔ Logic ⭐ (NOT "code new UI")
+
+The UI already exists from Phase 2.8. Only CONNECT it:
+
+```kotlin
+// Keep stateless Content composable from Phase 2 (for Preview):
+// [Screen]Content(uiState, onAction) — DO NOT MODIFY
+
+// ADD wrapper that wires ViewModel:
+@Composable
+fun [Screen](
+    viewModel: [Screen]ViewModel = hiltViewModel(),
+    onNavigate: () -> Unit
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    LaunchedEffect(Unit) {
+        viewModel.events.collect { event -> /* handle navigation */ }
+    }
+    [Screen]Content(uiState = uiState, onAction = viewModel::onAction)
+}
+```
+
+### 3.6: Integration Test ⭐
+- [ ] API calls succeed, data displays
+- [ ] Loading/error states work
+- [ ] Navigation correct
+- [ ] Crypto output matches (if applicable)
+
+### 🔒 Crypto Utils (Special)
+If crypto involved: implement + unit test IMMEDIATELY with known pairs.
+> ⚠️ MUST produce identical output.
+
+### ✅ Feature Checkpoint
+
+```markdown
+## ✅ Feature Complete: [Name]
+Files: [list] | Resources: [count] | Tests: [status]
+⏭️ Next Feature: [Name] → Return to Phase 2
+```
+
+---
+
+## ✅ Phase 4: Final Parity Check (After ALL features)
+
+### Checklist
+- [ ] API Parity — all endpoints match (headers, body, encoding)
+- [ ] Data Parity — crypto/hash output identical
+- [ ] UI Parity — screen-by-screen comparison
+- [ ] Edge Cases — empty states, errors, offline, lifecycle
+- [ ] Build: `./gradlew assembleDebug && ./gradlew test && ./gradlew lint`
+
+### 🎉 Final Summary
+
+```markdown
+## ✅ Reverse Engineering Complete!
+- Screens: [N] | Features: [N]
+- Libs reused: [N] | Replaced: [N]
+- Tests: [pass/fail] | Lint: [warnings]
+
+⏭️ Next: /test → /deploy → /code-janitor
+```
+
+---
+
+## 🔗 Related
+
+- **Parent:** [`/reverse-android`](reverse-android.md)
+- **Previous:** [`/re-android-design`](reverse-android-design.md) (Phase 1)
+- **Skill:** `smali-to-kotlin` → `phase-2-blueprint-ui.md` + `phase-3-logic-build.md`
+
+---
+
+*re-android-build v4.0.0 — UI-First Blueprint + Build*

package/workflows/_uncategorized/reverse-android-design.md

@@ -0,0 +1,139 @@
+---
+description: 🏗️ RE Android Phase 1 — Architecture Design (NO CODE BODIES)
+parent: reverse-android
+---
+
+# /re-android-design — Architecture Blueprint
+
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 1
+> **Prerequisite:** Completed App Map from [`/re-android-discover`](reverse-android-discover.md)
+> **Skill:** `smali-to-kotlin` → `phase-1-architecture.md`
+> **Zoom Level:** 1 — District View
+> **Output:** Architecture Blueprint (diagrams, tables, NO CODE BODIES)
+
+---
+
+## ⛔ ZOOM 1 RULE
+
+```
+This workflow produces NO CODE BODIES.
+Allowed: Architecture diagrams, layer maps, feature tables, file paths, API endpoint lists.
+Allowed: build.gradle.kts plugin/dependency declarations (declaration only).
+If you are about to write a function body → STOP → wrong zoom level.
+```
+
+---
+
+## 📐 Step 1: Layer Design
+
+Design Clean Architecture layers based on App Map:
+
+```
+┌─────────────────────────────────────┐
+│ Presentation                        │
+│ ├── screens/ ([N] screens)          │
+│ ├── navigation/ (NavGraph + Routes) │
+│ ├── theme/ (Material 3)            │
+│ └── components/ (Shared UI)        │
+├─────────────────────────────────────┤
+│ Domain                              │
+│ ├── model/ ([N] models)             │
+│ ├── repository/ ([N] interfaces)   │
+│ └── usecase/ ([N] use cases)        │
+├─────────────────────────────────────┤
+│ Data                                │
+│ ├── remote/ ([N] API services)     │
+│ ├── local/ (Room, DataStore)       │
+│ └── repository/ (implementations)  │
+├─────────────────────────────────────┤
+│ DI (Hilt)                           │
+│ └── modules/ (Network, DB, Repo)   │
+└─────────────────────────────────────┘
+```
+
+## 📋 Step 2: Feature → File Mapping
+
+Map mỗi feature tới Clean Architecture components:
+
+| Feature | Domain Model | Repository | UseCase | Screen(s) | ViewModel |
+|---------|-------------|-----------|---------|-----------|-----------|
+
+## 🌐 Step 3: API Endpoint Inventory
+
+Trích xuất TẤT CẢ API endpoints từ Smali:
+
+| # | Method | Endpoint | Auth | Notes |
+|---|--------|----------|------|-------|
+
+**Base URL:** `[from Smali const-string]`
+
+## 💾 Step 4: Data Schema
+
+| Model | Key Fields | Source | Storage |
+|-------|-----------|--------|---------|
+
+## 📁 Step 5: Project Structure
+
+```
+app/src/main/java/[package]/
+├── App.kt
+├── di/
+├── data/remote/ + data/local/ + data/repository/
+├── domain/model/ + domain/repository/ + domain/usecase/
+├── presentation/navigation/ + screens/ + theme/
+└── util/
+```
+
+## 🔢 Step 6: Build Order (UI-First) ⭐
+
+| # | Phase | Scope | Complexity |
+|---|-------|-------|-----------|
+| 1 | 🟢 Foundation | Project + DI skeleton + Theme/Design System | Low |
+| 2 | 🟢 Navigation | Routes, tab bar, NavGraph | Low |
+| 3 | 🔵 Per Feature | Blueprint (contracts) + UI Shell (visual) | Medium |
+| 4 | 🚦 UI Gate | User approves UI before logic | — |
+| 5 | 🟡 Per Feature | Logic Build (Domain → Data → VM → Wire UI) | High |
+| 6 | 📦 SDKs | Third-party SDK + Native libs integration | Medium |
+| N | 🔴 Final | Full Parity Check | High |
+
+> **UI-First:** Design and approve UI before coding logic for each feature.
+
+## 🔧 Step 7: Tech Stack Confirmation
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| UI | Jetpack Compose + M3 | Modern |
+| DI | Hilt | Standard |
+| ... | ... | ... |
+
+---
+
+## 📊 Output: Architecture Blueprint
+
+Sử dụng template từ `skills/smali-to-kotlin/templates/architecture.md`.
+
+---
+
+## ✅ Gate: Chuyển sang Phase 2
+
+```
+"🏗️ Architecture Blueprint xong!
+Anh muốn bắt đầu từ feature nào?
+Em suggest: [Feature X] vì [reason]."
+
+→ User picks feature → /re-android-build (Phase 2: Blueprint for that feature)
+→ User wants changes → adjust architecture
+```
+
+---
+
+## 🔗 Related
+
+- **Previous:** [`/re-android-discover`](reverse-android-discover.md) (Phase 0)
+- **Next:** [`/re-android-build`](reverse-android-build.md) (Phase 2+3)
+- **Parent:** [`/reverse-android`](reverse-android.md)
+- **Skill:** `skills/smali-to-kotlin/phase-1-architecture.md`
+
+---
+
+*re-android-design v3.0.0 — Phase 1: Architecture Blueprint*