@leejungkiin/awkit 1.0.0

package/skill-packs/neural-memory/pack.json

@@ -0,0 +1,35 @@
+{
+    "name": "neural-memory",
+    "auto_install": true,
+    "description": "NeuralMemory-powered ambient brain sync with spreading activation recall",
+    "requires": [
+        {
+            "type": "pip",
+            "package": "neural-memory",
+            "python_min": "3.11",
+            "check_cmd": "nmem --version",
+            "install_cmd": "pip install neural-memory",
+            "description": "NeuralMemory Python engine (SQLite graph + MCP server)"
+        }
+    ],
+    "post_install": [
+        {
+            "cmd": "nmem init",
+            "description": "Initialize NeuralMemory database (~/.nmem/brain.db)",
+            "optional": true,
+            "skip_if_exists": "~/.nmem/brain.db"
+        }
+    ],
+    "mcp_setup": {
+        "description": "Add NeuralMemory MCP server to your AI editor config",
+        "server_name": "neural-memory",
+        "config_json": {
+            "command": "nmem-mcp"
+        },
+        "editors": {
+            "Gemini (GEMINI.md)": "Not required — skills use nmem_* tools via MCP auto-discovery",
+            "Cursor / Windsurf": "Add to .cursor/mcp.json or mcp_config.json",
+            "Claude Code": "Run: /plugin install neural-memory"
+        }
+    }
+}

package/skill-packs/neural-memory/schemas/brain-snapshot.json

@@ -0,0 +1,167 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "NeuralMemory Brain Snapshot",
+    "description": "Schema for nm-snapshot exported brain state — Portable Consciousness",
+    "type": "object",
+    "required": [
+        "version",
+        "exported_at",
+        "memories",
+        "synapses"
+    ],
+    "properties": {
+        "version": {
+            "type": "string",
+            "const": "1.0"
+        },
+        "exported_at": {
+            "type": "string",
+            "format": "date-time"
+        },
+        "project": {
+            "type": "string",
+            "description": "Project name from .project-identity"
+        },
+        "scope": {
+            "type": "string",
+            "enum": [
+                "full",
+                "topic",
+                "recent",
+                "high-priority"
+            ]
+        },
+        "memories": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": [
+                    "id",
+                    "content",
+                    "type",
+                    "priority",
+                    "created_at"
+                ],
+                "properties": {
+                    "id": {
+                        "type": "string"
+                    },
+                    "content": {
+                        "type": "string"
+                    },
+                    "type": {
+                        "type": "string",
+                        "enum": [
+                            "fact",
+                            "decision",
+                            "todo",
+                            "error",
+                            "insight",
+                            "preference",
+                            "instruction",
+                            "workflow",
+                            "context"
+                        ]
+                    },
+                    "priority": {
+                        "type": "integer",
+                        "minimum": 0,
+                        "maximum": 10
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
+                    },
+                    "created_at": {
+                        "type": "string",
+                        "format": "date-time"
+                    },
+                    "expires_at": {
+                        "type": "string",
+                        "format": "date-time"
+                    },
+                    "activation_score": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1
+                    },
+                    "recall_count": {
+                        "type": "integer",
+                        "minimum": 0
+                    },
+                    "status": {
+                        "type": "string",
+                        "enum": [
+                            "active",
+                            "archived",
+                            "expired"
+                        ]
+                    }
+                }
+            }
+        },
+        "synapses": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": [
+                    "from_id",
+                    "to_id",
+                    "type",
+                    "weight"
+                ],
+                "properties": {
+                    "from_id": {
+                        "type": "string"
+                    },
+                    "to_id": {
+                        "type": "string"
+                    },
+                    "type": {
+                        "type": "string",
+                        "enum": [
+                            "CAUSED_BY",
+                            "LEADS_TO",
+                            "DISCUSSED",
+                            "CONTRADICTS",
+                            "SUPERSEDES",
+                            "COMPLEMENTS",
+                            "RELATED"
+                        ]
+                    },
+                    "weight": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1
+                    },
+                    "created_at": {
+                        "type": "string",
+                        "format": "date-time"
+                    }
+                }
+            }
+        },
+        "stats": {
+            "type": "object",
+            "properties": {
+                "total_memories": {
+                    "type": "integer"
+                },
+                "total_synapses": {
+                    "type": "integer"
+                },
+                "avg_priority": {
+                    "type": "number"
+                },
+                "active_memories": {
+                    "type": "integer"
+                },
+                "archived_memories": {
+                    "type": "integer"
+                }
+            }
+        }
+    }
+}

package/skill-packs/neural-memory/skills/nm-memory-audit/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: nm-memory-audit
+description: |
+  6-dimension quality review of NeuralMemory brain health.
+  Grades each dimension (A-F), produces graded findings, and recommends
+  concrete actions for improvement. Run weekly or before major sprints.
+metadata:
+  stage: review
+  version: "1.0"
+  requires: neural-memory (pip install neural-memory)
+  tags: [memory, audit, quality, review, neuralmemory]
+agent: Memory Quality Inspector
+trigger:
+  commands: ["/memory-audit", "/nm-audit"]
+  keywords: ["audit brain", "check memory", "memory health"]
+allowed-tools:
+  - nmem_recall
+  - nmem_stats
+  - nmem_context
+---
+
+# NM Memory Audit — Memory Quality Inspector
+
+> Systematic quality review of the NeuralMemory brain.
+> Grades memory health across 6 dimensions, surfaces actionable findings.
+
+## Trigger
+
+```
+/memory-audit
+/nm-audit
+```
+
+---
+
+## 6 Audit Dimensions
+
+### 1. Purity (A-F)
+**Question:** Are memories well-typed and single-concept?
+
+Check for:
+- Mixed types in one memory (fact + decision combined)
+- Vague or generic content ("fixed a bug" → F)
+- Missing source attribution
+- Over-broad scope ("everything about auth")
+
+**Grade:**
+- A: 90%+ memories are single-concept, well-typed
+- B: 75-89% clean
+- C: 60-74% — noticeable clutter
+- D: 40-59% — significant cleanup needed
+- F: <40% — urgent restructuring required
+
+### 2. Freshness (A-F)
+**Question:** Are memories still current and relevant?
+
+Check for:
+- Expired memories (past TTL) still active
+- Outdated decisions (superseded but not marked)
+- Stale context (project state changed)
+- Memories about deprecated features/APIs
+
+**Grade based on:** % expired / stale vs total
+
+### 3. Coverage (A-F)
+**Question:** Are important areas of the project well-documented?
+
+Check for:
+- Core architecture decisions — present? complete?
+- Recent bugs/fixes — all captured?
+- Team preferences — documented?
+- Onboarding knowledge — accessible?
+
+**Grade based on:** Key areas vs documented areas ratio
+
+### 4. Clarity (A-F)
+**Question:** Can memories be understood without context?
+
+Check for:
+- Jargon without explanation ("the THING was fixed")
+- Missing who/what/why ("updated it")
+- Inconsistent terminology (same concept, multiple names)
+- Vietnamese/English mixing without clear pattern
+
+**Grade based on:** Avg clarity score across sampled memories
+
+### 5. Relevance (A-F)
+**Question:** Are memories being recalled and used?
+
+Check for:
+- Low-activation memories (never recalled in 30d)
+- Duplicate memories competing for activation
+- Orphaned memories (no synapse connections)
+- Memories blocking relevant recall (noise)
+
+**Grade based on:** Recall frequency + synapse connectivity
+
+### 6. Structure (A-F)
+**Question:** Is the synapse graph healthy?
+
+Check for:
+- Isolated neurons (no connections)
+- Missing causal links (decisions without causes)
+- Tag inconsistency (similar concepts, different tags)
+- Temporal gaps (events without before/after links)
+
+**Grade based on:** Graph connectivity metrics from nmem_stats
+
+---
+
+## Output Format
+
+```
+🔍 Memory Brain Audit — [date]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+📊 Health Overview
+  Total memories: 127
+  Active (recalled 7d): 43 (34%)
+  Expired/stale: 12 (9%)
+  Orphaned neurons: 8 (6%)
+
+📋 Dimension Grades
+  Purity:    B (78%) — Some mixed-concept memories found
+  Freshness: A (92%) — Brain is current ✨
+  Coverage:  C (61%) — Auth and deploy areas sparse
+  Clarity:   B (80%) — Minor jargon issues
+  Relevance: B (75%) — 8 orphaned low-priority memories
+  Structure: C (65%) — Missing causal links in 15 decisions
+
+Overall: B- (75%)
+
+🔴 Critical Findings (fix now)
+  1. 3 expired `todo` memories still active — run /memory-evolution to prune
+  2. Auth architecture has no decision memories — document now
+
+🟡 Moderate Findings (fix this week)
+  3. 8 orphaned memories — no synapse connections
+  4. "deployment" and "deploy" tags used inconsistently (15 memories)
+
+🟢 Minor Findings (optional)
+  5. 5 memories could be split into smaller single-concept memories
+  6. 3 decisions missing "because Y" reasoning
+
+💡 Recommended Next Step
+  Run: /memory-evolution "prune expired, fix auth coverage"
+```
+
+---
+
+## Rules
+
+- Always show the full 6-dimension breakdown
+- Never modify memories during audit — report only
+- Grade based on objective metrics when possible
+- Prioritize by impact: Critical > Moderate > Minor
+- End with one concrete "next step" recommendation

package/skill-packs/neural-memory/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/skill-packs/neural-memory/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