@leejungkiin/awkit 1.0.6 → 1.0.8

package/skills/skills/nm-memory-evolution/SKILL.md

@@ -0,0 +1,202 @@
+---
+name: nm-memory-evolution
+description: |
+  Evidence-based brain optimization. Analyzes usage patterns to consolidate
+  fragmented memories, enrich sparse ones, prune stale/irrelevant ones,
+  and normalize tags. Improves recall quality over time.
+metadata:
+  stage: workflow
+  version: "1.0"
+  requires: neural-memory (pip install neural-memory)
+  tags: [memory, evolution, optimize, prune, consolidate]
+agent: Memory Evolution Strategist
+trigger:
+  commands: ["/memory-evolution", "/nm-evolve"]
+  keywords: ["optimize brain", "clean memory", "prune", "consolidate memories"]
+allowed-tools:
+  - nmem_remember
+  - nmem_recall
+  - nmem_stats
+  - nmem_context
+  - nmem_auto
+---
+
+# NM Memory Evolution — Memory Evolution Strategist
+
+> Evidence-based brain optimization using actual usage patterns.
+> Consolidates, enriches, prunes, and normalizes — making recall more precise over time.
+
+## Trigger
+
+```
+/memory-evolution                          # Full brain optimization
+/memory-evolution "focus on auth topic"    # Scoped to topic
+/nm-evolve "prune expired todos"           # Specific operation
+```
+
+---
+
+## Analysis Phase
+
+Before any changes, generate evolution opportunities:
+
+```python
+# 1. Usage patterns
+stats = nmem_stats()
+# → recall_frequency, activation_scores, orphan_neurons
+
+# 2. Cluster detection  
+context = nmem_context(topic=focus_area)
+# → related memory clusters, fragmentation patterns
+
+# 3. Tag analysis
+# → inconsistency, synonyms, normalization needs
+```
+
+---
+
+## 4 Evolution Operations
+
+### 1. Consolidation
+**When:** Multiple fragmented memories cover same concept
+
+**Example:**
+```
+Before (3 memories):
+  [fact] "API uses JWT"
+  [fact] "JWT tokens expire in 24h"
+  [fact] "JWT stored in Authorization header"
+
+After (1 memory):
+  [instruction] "API auth: JWT tokens, 24h expiry, sent via Authorization header. 
+                 Chosen for stateless architecture (see decision #42)."
+```
+
+**Rules:**
+- Show before/after preview — never auto-consolidate
+- Keep highest priority + merge all tags
+- Create `SUPERSEDES` synapse to old memories
+- Log: "Consolidated 3 → 1 [topic]"
+
+### 2. Enrichment
+**When:** Memories exist but lack context/reasoning
+
+**Example:**
+```
+Before: [decision] "Using Redis for cache"
+After:  [decision] "Using Redis for cache. Reason: Redis Cluster supports Lua scripts 
+                   needed for atomic counter ops. Team has Redis expertise. 
+                   Chosen over Memcached on 2026-01-15."
+```
+
+**Sources for enrichment:**
+- Related memories in the activation cluster
+- User can be asked for missing info (non-blocking)
+
+### 3. Pruning
+**When:** Memories that reduce recall quality
+
+**Prune candidates:**
+- Expired TTL memories (todos past deadline, stale context)
+- Duplicate/near-duplicate memories (similarity > 0.95)
+- Orphaned facts with 0 recall in 60d
+- Superseded decisions (overridden by newer ones)
+- Out-of-scope memories (wrong project/context)
+
+**Rules:**
+- NEVER hard-delete — archive with `status=archived`
+- Show full prune list before executing
+- "Archived X memories" — not "deleted"
+- Allow rescue: user can un-archive any item
+
+### 4. Tag Normalization
+**When:** Inconsistent tags reduce recall precision
+
+**Common issues:**
+- Synonyms: "frontend" / "front-end" / "FE" → normalize to "frontend"
+- Abbreviations: "db" / "database" / "DB" → normalize to "database"  
+- Case: "Auth" / "auth" / "AUTH" → normalize to "auth"
+- Language mix: "xác thực" / "auth" for same concept → pick one
+
+**Process:**
+1. Build tag frequency map
+2. Identify synonym clusters
+3. Propose normalization mapping
+4. Apply after user confirms
+
+---
+
+## Output Format
+
+```
+🔄 Memory Evolution Plan
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 Analysis Results
+  Memories analyzed: 127
+  Evolution opportunities: 23
+
+📋 Proposed Operations
+
+CONSOLIDATE (4 groups → 4 memories)
+  1. Auth memories: 5 fragments → 1 instruction [preview]
+  2. Database facts: 3 fragments → 1 fact [preview]
+  ...
+
+ENRICH (6 memories lacking context)
+  1. [decision] "Using Redis" — missing reasoning [add]
+  2. [instruction] "Always validate input" — missing scope [add]
+  ...
+
+PRUNE (9 memories)
+  1. 4 expired todos (past deadline) [archive]
+  2. 3 orphaned facts (0 recall in 60d) [archive]
+  3. 2 near-duplicates [merge]
+
+NORMALIZE TAGS
+  "frontend" / "front-end" / "FE" → "frontend" (affects 18 memories)
+  "db" / "database" → "database" (affects 12 memories)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Execute plan? [all / select / cancel]
+  > all        → execute all operations
+  > select     → choose operations individually
+  > cancel     → abort
+```
+
+---
+
+## Execution Protocol
+
+1. **Show full plan** — never execute without preview
+2. **Execute in order:** Prune → Consolidate → Enrich → Normalize
+   (pruning first reduces noise for better consolidation)
+3. **Checkpoint after each phase** — can stop mid-way
+4. **Create evolution snapshot** before starting (rollback point)
+
+---
+
+## Post-Evolution Report
+
+```
+✅ Evolution Complete
+
+  Consolidated: 4 memory groups (15 → 4)
+  Enriched: 6 memories
+  Archived: 9 memories
+  Tags normalised: 30 memories updated
+
+  Brain quality: B- → A- (estimated)
+  
+💡 Recommended audit in 7 days: /memory-audit
+```
+
+---
+
+## Rules
+
+- **Never auto-prune** — always show prune list to user
+- **Archive, don't delete** — memories may be relevant later
+- **Preserve intent** — consolidation must not lose meaning
+- **Test recall after** — spot-check key topics after evolution
+- **Vietnamese support** — operations work regardless of language

package/skills/skills/nm-memory-intake/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: nm-memory-intake
+description: |
+  Structured memory creation workflow. Converts messy notes, meeting logs,
+  and unstructured thoughts into well-typed, tagged, priority-scored NeuralMemory entries.
+  Uses 1-question-at-a-time clarification + batch preview before storing.
+metadata:
+  stage: workflow
+  version: "1.0"
+  requires: neural-memory (pip install neural-memory)
+  tags: [memory, intake, structured, neuralmemory, workflow]
+agent: Memory Intake Specialist
+trigger:
+  commands: ["/memory-intake", "/nm-intake"]
+  keywords: ["lưu notes", "save this", "remember meeting", "ghi lại buổi"]
+allowed-tools:
+  - nmem_remember
+  - nmem_recall
+  - nmem_stats
+  - nmem_context
+  - nmem_auto
+---
+
+# NM Memory Intake — Memory Intake Specialist
+
+> Transform raw, unstructured input into high-quality structured memories.
+> Acts as a thoughtful librarian — clarifying, categorizing, and filing
+> information so it can be recalled precisely when needed.
+
+## Trigger
+
+```
+/memory-intake "raw notes or conversation here"
+/nm-intake "messy meeting notes..."
+```
+
+---
+
+## Memory Types
+
+| Type | Signal Words | Priority |
+|------|-------------|----------|
+| `fact` | "is", "has", "uses", dates, numbers, names | 5 |
+| `decision` | "decided", "chose", "will use", "going with" | 7 |
+| `todo` | "need to", "should", "TODO", "must" | 6 |
+| `error` | "bug", "crash", "failed", "broken", "fix" | 7 |
+| `insight` | "realized", "learned", "turns out", "key takeaway" | 6 |
+| `preference` | "prefer", "always use", "never do", "convention" | 5 |
+| `instruction` | "rule:", "always:", "never:", "when X do Y" | 8 |
+| `workflow` | "process:", "steps:", "first...then...finally" | 6 |
+| `context` | background info, project state, env details | 4 |
+
+---
+
+## Process (6 Phases)
+
+### Phase 1: Triage
+Scan raw input → classify each information unit by type.
+If input is ambiguous → go to Phase 2.
+If clearly typed → skip to Phase 3.
+
+### Phase 2: Clarification (1-Question-at-a-Time)
+```
+Found: "We're using PostgreSQL now"
+
+What type?
+a) Decision — you chose PostgreSQL over alternatives
+b) Fact — PostgreSQL is the current database
+c) Instruction — always use PostgreSQL for this project
+d) Other (explain)
+```
+
+**Rules:**
+- ONE question per round — never dump a checklist
+- Always provide options (2-4 choices)
+- Infer when confident (>80%) — don't ask obvious ones
+- Max 5 rounds — then use best-guess
+- Group similar: "Found 3 TODOs. Priority for all? [high/normal/low]"
+
+### Phase 3: Enrichment
+For each item, determine:
+1. **Tags** — 2-5 relevant tags, normalize ("frontend" not "front-end")
+2. **Priority** — 0-10 scale (see type table above)
+3. **Expiry** — todo: 30d, error: 90d, fact: none, context: 30d
+4. **Source** — "Per meeting 2026-02-26: ...", "From error log: ..."
+
+### Phase 4: Deduplication
+```python
+nmem_recall("topic keywords")
+# → Identical: skip, report duplicate
+# → Updated: store new, note supersedes old
+# → Contradicts: store with conflict flag, alert user
+# → Complements: store, note connection
+```
+
+### Phase 5: Batch Preview + Confirm
+```
+Ready to store 7 memories:
+
+  1. [decision] "Chose PostgreSQL for user service" priority=7 tags=[database, arch]
+  2. [todo] "Migrate user table" priority=6 tags=[database, migration] expires=30d
+  3. [fact] "PostgreSQL 16 supports JSON path queries" priority=5 tags=[database]
+  ...
+
+Store all? [yes / edit # / skip # / cancel]
+```
+
+**Rules:**
+- Max 10 per batch — split larger batches with pause
+- NEVER auto-store without showing preview
+- Allow per-item edits before commit
+- Store: decisions first, then errors, then facts (priority order)
+
+### Phase 6: Intake Report
+```
+✅ Intake Complete
+   Stored: 7 memories (2 decisions, 3 facts, 1 todo, 1 insight)
+   Skipped: 1 duplicate
+   Conflicts: 0 | Gaps: 2 items need follow-up
+
+Follow-up needed:
+  - "Redis cache TTL" — what's the agreed TTL?
+  - "Deploy schedule" — weekly or bi-weekly?
+```
+
+---
+
+## Rules
+
+- **Never auto-store** — always show preview before writing
+- **Never guess security-sensitive info** — ask explicitly
+- **Prefer specific over vague** — "PostgreSQL 16 on AWS RDS" not "using a database"
+- **Include reasoning** — "Chose X because Y" not just "Using X"
+- **One concept per memory** — don't cram multiple facts
+- **Vietnamese support** — if input is Vietnamese, store in Vietnamese

package/skills/skills/nm-memory-sync/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: nm-memory-sync
+description: |
+  NeuralMemory-powered ambient brain sync. Replaces flat-file memory-sync with
+  associative graph recall via spreading activation. Auto-reads/writes brain on
+  every session, debug, task, and error — with richer context than keyword matching.
+metadata:
+  stage: core
+  version: "1.0"
+  replaces: memory-sync, ambient-brain
+  requires: neural-memory (pip install neural-memory)
+  tags: [memory, neural, sync, core, ambient]
+agent: Ambient Neural Brain
+allowed-tools:
+  - nmem_remember
+  - nmem_recall
+  - nmem_context
+  - nmem_stats
+  - nmem_auto
+---
+
+# NM Memory Sync — Ambient Neural Brain
+
+> Drop-in upgrade for `memory-sync` and `ambient-brain`.
+> Uses NeuralMemory's spreading activation instead of keyword overlap.
+
+---
+
+## Core Difference vs memory-sync
+
+| Feature | memory-sync (flat-file) | nm-memory-sync (this) |
+|---------|------------------------|----------------------|
+| Storage | Markdown files | SQLite graph (neurons + synapses) |
+| Recall | keyword overlap > 2 | Spreading activation graph |
+| Causality | None | `CAUSED_BY`, `LEADS_TO` links |
+| Time decay | None | Natural decay by age/priority |
+| Dedup | None | Automatic conflict detection |
+| Context | Whole file | Scoped activation subgraph |
+
+---
+
+## READ TRIGGERS (Auto-Read từ Brain)
+
+### R1: Session Start
+**Condition:** Conversation bắt đầu
+**Action:** `nmem_context()` → load recent + high-activation memories
+**Output:** Silent loading, brief summary nếu relevant
+
+### R2: New Task / Debugging
+**Condition:** User bắt đầu task mới hoặc debug session
+**Action:** `nmem_recall(task_keywords)` → associative recall
+**Output:** Show relevant decisions, past errors, solutions
+
+### R3: Error Encountered
+**Condition:** Exception, crash, hoặc lỗi xuất hiện
+**Action:** `nmem_recall(error_type + keywords)` → find past similar errors
+**Output:** Auto-propose known solutions if confidence > 0.7
+
+### R4: Architecture Question
+**Condition:** User hỏi về design, pattern, tech choice
+**Action:** `nmem_recall(topic, depth=3)` → deep associative recall
+**Output:** Related decisions, constraints, context
+
+### R5: Recurring Problem (Enhanced)
+**Condition:** Vấn đề tương tự đã gặp (spreading activation detects similarity)
+**Action:** Activate related memory cluster
+**Output:** "🧠 Similar to [memory]: [solution]" — NO keyword threshold needed
+
+---
+
+## WRITE TRIGGERS (Auto-Write vào Brain)
+
+### W1: Decision Made → `decision` type
+**Condition:** AI hoặc user đưa ra quyết định kỹ thuật
+**Capture:** "Chose X because Y" format
+**Store:** `nmem_remember(content, type="decision", priority=7)`
+**Links:** Auto-link to related memories via NeuralMemory engine
+
+### W2: Bug Fixed → `error` type
+**Condition:** User confirm fix thành công ("xong", "ok", "chạy rồi")
+**Capture:** Error + root cause + solution
+**Store:** `nmem_remember(content, type="error", priority=8)`
+**Links:** `CAUSED_BY` → triggering condition, `LEADS_TO` → fix applied
+
+### W3: Architecture Change → `instruction` type
+**Condition:** File structure thay đổi, pattern mới được áp dụng
+**Capture:** What changed + why
+**Store:** `nmem_remember(content, type="instruction", priority=7)`
+**Links:** `SUPERSEDES` → old pattern if exists
+
+### W4: Task Complete → `workflow` type
+**Condition:** Task marked done trong Beads
+**Capture:** What was done + approach taken
+**Store:** `nmem_remember(content, type="workflow", priority=5)`
+
+### W5: User Preference Detected → `preference` type
+**Condition:** User consistently uses pattern or expresses preference
+**Capture:** The preference + context
+**Store:** `nmem_remember(content, type="preference", priority=6)`
+
+---
+
+## Sync Protocol
+
+### Session Start Flow
+```
+1. nmem_context() → get active memory cluster
+2. Filter by project tags (from .project-identity if available)
+3. SILENT load — no output unless > 3 highly relevant memories
+4. If relevant: "🧠 Recalled: [brief summary]"
+```
+
+### Error Flow
+```
+1. Extract: error_type, file, function, keywords
+2. nmem_recall(f"{error_type} {keywords}", depth=2)
+3. If match (activation > 0.6):
+   → "🧠 Similar error: [past error] — Solution: [fix]"
+4. After fix confirmed:
+   → nmem_remember(error + solution, type="error", tags=[...])
+   → Create CAUSED_BY + LEADS_TO synapses
+```
+
+### Decision Write Flow
+```
+1. Detect decision signal words: "chose", "decided", "going with", "will use"
+2. Extract: choice + reason (requires both for quality decision memory)
+3. nmem_recall(topic) → check for conflicts
+4. SILENT store: nmem_remember(content, type="decision", priority=7)
+5. Confirm: "💾 Saved decision: [brief]"
+```
+
+---
+
+## Associative Recall Strategy
+
+Unlike keyword overlap (old memory-sync), nm-memory-sync uses:
+
+```
+Query: "API authentication failing"
+         ↓ spreading activation
+Anchor neurons: [api, auth, fail]
+         ↓ activate synapses (depth=2)
+Related neurons: [jwt, token, session, middleware]
+         ↓ intersect top activations
+Surface memories: 
+  - "Decided JWT over sessions for stateless API" (decision, auth tags)
+  - "Fixed middleware order causing 401" (error, api tags)
+  - "Never store tokens in localStorage" (instruction, security tags)
+```
+
+This surfaces memories that a keyword search would miss.
+
+---
+
+## Notification Behavior
+
+| Event | Output |
+|-------|--------|
+| Relevant memory found (activation > 0.7) | `🧠 [brief recall]` |
+| Decision auto-saved | `💾 Saved: [brief]` |
+| Bug solution stored | `🔧 Stored fix: [brief]` |
+| No relevant memory | Silent (no output) |
+| Conflict detected | `⚠️ Conflicts with: [memory]` |
+
+---
+
+## Fallback Mode (NeuralMemory Not Installed)
+
+If `nmem` is not available, falls back to flat-file behavior:
+```
+- Reads from brain/decisions/, brain/solutions/
+- Keyword overlap matching (legacy behavior)
+- Shows warning once: "⚠️ NeuralMemory not installed. Using flat-file fallback."
+```
+
+---
+
+## Integration
+
+- Works alongside `beads-manager` for task lifecycle hooks
+- Reads `.project-identity` for project-scoped memory filtering
+- Feeds data to `nm-memory-audit` for quality checks
+- Activated before `orchestrator` dispatches (priority 2.5 in skill chain)

package/skills/smali-to-kotlin/phase-0-discovery.md

@@ -0,0 +1,128 @@
+# 🗺️ Phase 0: Discovery (Satellite View)
+
+> **Zoom Level:** 0 — Bird's Eye
+> **Goal:** Create an "App Map" — understand WHAT the app is and WHAT it contains.
+> **Output:** Diagrams, tables, maps. **NO CODE.**
+
+---
+
+## ⛔ OUTPUT RULE
+
+```
+✅ ALLOWED: ASCII diagrams, Mermaid, tables, bullet lists, bash scan commands
+❌ BLOCKED: Kotlin/Java code, function signatures, class definitions
+```
+
+---
+
+## 📋 Sub-steps
+
+### 0.1: Confirm Input
+
+```
+🔧 Android Reverse Engineering bắt đầu!
+
+Em cần biết:
+1. Thư mục Apktool output ở đâu?
+2. Tên app gốc? Package name?
+
+Chưa chạy Apktool? → apktool d your-app.apk -o ./decompiled/
+```
+
+### 0.2: Structure Scan
+
+Quét folder structure để hiểu quy mô app:
+
+```bash
+# Top-level packages (app code vs libraries)
+find [apktool_dir]/smali -maxdepth 3 -type d | sed 's|.*/smali/||' | sort
+
+# Multi-dex check
+find [apktool_dir] -name "smali*" -maxdepth 1 -type d
+
+# Resource overview
+ls [apktool_dir]/res/layout/ | wc -l         # Number of layouts
+ls [apktool_dir]/res/drawable*/ | wc -l       # Number of drawables
+cat [apktool_dir]/res/values/strings.xml | grep '<string' | wc -l  # Strings count
+```
+
+### 0.3: Library Detection
+
+Quét smali directories để nhận diện thư viện. Ref: `library-patterns.md`
+
+```bash
+# Known library packages
+find [apktool_dir]/smali -maxdepth 3 -type d | grep -E "(google|facebook|squareup|airbnb|bumptech|jakewharton|reactivex|greenrobot)" | sort
+
+# Native libraries
+find [apktool_dir]/lib -name "*.so" 2>/dev/null
+
+# Assets (ML models, WebView, configs)
+ls [apktool_dir]/assets/ 2>/dev/null
+```
+
+**Phân loại thành 5 nhóm:**
+
+| Category | Meaning | Action |
+|----------|---------|--------|
+| ✅ Reuse | Modern, still maintained | Add to build.gradle |
+| 🔄 Replace | Legacy/deprecated | Map to modern replacement |
+| 🔵 Firebase/Google | Platform SDKs | Use latest version |
+| 📱 Native (.so) | JNI libraries | Keep, create bridge |
+| 🏷️ App Code | Original app logic | Rebuild in Kotlin |
+
+### 0.4: Manifest Analysis
+
+```bash
+cat [apktool_dir]/AndroidManifest.xml
+```
+
+Extract:
+- Application ID + Package name
+- Min/Target SDK
+- Permissions (grouped by category)
+- Entry points: Application class, Launcher Activity
+- All components: Activities, Services, Receivers, Providers
+- Deep links / Intent filters
+
+### 0.5: Screen Map
+
+Map Activities → future Compose screens. Draw navigation flow:
+
+```
+Activities found → Group by feature → Draw screen graph
+```
+
+### 0.6: Complexity Estimate
+
+Rate each area 1-5 dots:
+- Data Layer: ●●●○○ (APIs, DB, preferences)
+- Core Logic: ●●○○○ (crypto, formatters, utils)
+- UI Screens: ●●●●○ (screen count, complex layouts)
+- SDK Integration: ●●○○○ (third-party, native libs)
+
+---
+
+## 📊 Output: App Map
+
+Use template from `templates/app-map.md`. Must include:
+
+1. **Identity** — package, SDK levels, screen count
+2. **Screen Flow** — navigation graph (ASCII or Mermaid)
+3. **Library Landscape** — categorized dependency list
+4. **Complexity Estimate** — visual dots rating
+5. **Key Observations** — anything notable (obfuscation, unusual patterns)
+
+---
+
+## ✅ Gate
+
+```
+"🗺️ Đây là App Map. Anh review xem có gì cần diều chỉnh không?"
+→ User approves → Proceed to Phase 1 (Architecture)
+→ User has questions → Investigate and update map
+```
+
+---
+
+*Phase 0: Discovery — No code, just understanding*