commit 30b73ac7e617b25036ad4ef687eb5e2dceb76e12
Author: Claude Agent <claude-agent@romfast.ro>
Date:   Tue Jan 6 19:02:02 2026 +0000

    feat: Initial release of claude-learn plugin v1.0.0
    
    Commands:
    - /learn:analyze - Analyze conversation for patterns and gotchas
    - /learn:import - Import from other memory files (auto-build-memory.md, JSON)
    - /learn:reflect - Consolidate and clean memory
    - /learn:status - Show memory statistics
    
    Features:
    - Stop hook suggests /learn:analyze after significant sessions
    - Uses single memory file: .claude/rules/claude-learn-memory.md
    - Structured format for patterns (solutions) and gotchas (problems)
    - Import support for migrating existing memories
    
    🤖 Generated with [Claude Code](https://claude.com/claude-code)
    
    Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
new file mode 100644
index 0000000..39be798
--- /dev/null
+++ b/.claude-plugin/marketplace.json
@@ -0,0 +1,18 @@
+{
+  "name": "romfast-tools",
+  "owner": {
+    "name": "Romfast Team"
+  },
+  "metadata": {
+    "description": "Claude Code plugins for learning and memory"
+  },
+  "plugins": [
+    {
+      "name": "learn",
+      "source": "./plugin",
+      "description": "Lessons Learned: Automatic pattern and gotcha detection with CLAUDE.md updates",
+      "version": "1.0.0",
+      "keywords": ["learn", "memory", "patterns", "gotchas", "documentation"]
+    }
+  ]
+}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..5c962aa
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,13 @@
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Local testing
+.claude/
+*.local.*
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..7cc216f
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-01-06
+
+### Added
+- Initial release
+- `/learn:analyze` - Analyze conversation for patterns and gotchas
+- `/learn:import` - Import from other memory files
+- `/learn:reflect` - Consolidate and clean memory
+- `/learn:status` - Show memory statistics
+- Stop hook for automatic suggestions
+- Support for markdown and JSON import formats
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..5f0800b
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,44 @@
+# CLAUDE.md
+
+Development instructions for the claude-learn plugin.
+
+## Project Structure
+
+```
+claude-learn/
+├── .claude-plugin/marketplace.json  # Marketplace entry
+├── plugin/                          # Plugin code
+│   ├── .claude-plugin/plugin.json   # Plugin manifest
+│   ├── commands/                    # Slash commands
+│   ├── hooks/                       # Event hooks
+│   ├── rules/                       # Rule files
+│   └── templates/                   # JSON templates
+├── README.md                        # User documentation
+├── CLAUDE.md                        # This file
+└── CHANGELOG.md                     # Version history
+```
+
+## Key Decisions
+
+1. **Single Memory File**: Plugin uses only `.claude/rules/claude-learn-memory.md`
+2. **Import for Migration**: Use `/learn:import` to bring in existing memories
+3. **User Confirmation**: Always list proposals before saving
+4. **Stop Hook**: Suggests, doesn't auto-run
+
+## Testing
+
+```bash
+# Test locally
+claude --plugin-dir ./plugin
+
+# Verify commands appear
+/learn:status
+```
+
+## Release Process
+
+1. Update version in `plugin/.claude-plugin/plugin.json`
+2. Update version in `.claude-plugin/marketplace.json`
+3. Update CHANGELOG.md
+4. Commit and push to main
+5. Tag release: `git tag v1.0.0 && git push --tags`
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..401f2df
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Romfast Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..41d5a52
--- /dev/null
+++ b/README.md
@@ -0,0 +1,128 @@
+# Claude Learn
+
+A Claude Code plugin for capturing lessons learned during development sessions.
+
+## Features
+
+- **Automatic Detection**: Stop hook suggests capturing lessons after significant sessions
+- **Pattern & Gotcha Tracking**: Structured format for reusable solutions and problems to avoid
+- **Import Support**: Bring in existing memories from other formats
+- **Reflection Tools**: Consolidate and promote patterns to CLAUDE.md
+
+## Installation
+
+### Option 1: Marketplace (Recommended)
+
+Add to your `~/.claude/settings.json`:
+
+```json
+{
+  "plugin-marketplaces": [
+    "git@gitea.romfast.ro:romfast/claude-learn.git"
+  ]
+}
+```
+
+Then install:
+
+```bash
+claude plugin install learn@romfast-tools
+```
+
+### Option 2: Direct from Git
+
+```bash
+git clone git@gitea.romfast.ro:romfast/claude-learn.git
+claude --plugin-dir /path/to/claude-learn/plugin
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/learn:analyze` | Analyze conversation and propose lessons |
+| `/learn:analyze auto` | Auto-detect all categories |
+| `/learn:analyze patterns` | Focus on patterns only |
+| `/learn:analyze gotchas` | Focus on gotchas only |
+| `/learn:import <file>` | Import from another memory file |
+| `/learn:reflect` | Consolidate and clean up memory |
+| `/learn:status` | Show memory statistics |
+
+## Usage Flow
+
+```
+1. Work normally with Claude Code
+   ↓
+2. Claude finishes a significant response
+   ↓
+3. Stop Hook analyzes (15s)
+   ↓
+4. "💡 Run /learn:analyze to capture lessons"
+   ↓
+5. User: /learn:analyze
+   ↓
+6. Claude lists proposals (patterns, gotchas)
+   ↓
+7. User selects: [1, 3, all, none]
+   ↓
+8. Claude updates .claude/rules/claude-learn-memory.md
+   ↓
+9. Periodically: /learn:reflect for consolidation
+```
+
+## Memory File Format
+
+The plugin creates and maintains `.claude/rules/claude-learn-memory.md` with this structure:
+
+```markdown
+# Claude Learn Memory
+
+## Patterns
+
+### Pattern Title
+**Discovered**: 2025-01-06 (feature: user-dashboard)
+**Description**: What the pattern does and when to use it
+
+**Example** (`src/components/Dashboard.vue:45-52`):
+\```vue
+<template>...</template>
+\```
+
+**Tags**: vue, components, dashboard
+
+---
+
+## Gotchas
+
+### Gotcha Title
+**Discovered**: 2025-01-06 (feature: api-integration)
+**Problem**: What went wrong
+**Solution**: How to fix it
+
+**Tags**: api, axios, error-handling
+
+---
+
+## Memory Statistics
+
+- **Total Patterns**: 5
+- **Total Gotchas**: 3
+- **Last Session**: 2025-01-06
+- **Sessions Recorded**: 8
+```
+
+## Importing Existing Memories
+
+If you have an existing memory file (e.g., from auto-build plugin):
+
+```bash
+/learn:import .claude/rules/auto-build-memory.md
+```
+
+Supported formats:
+- Markdown with `## Patterns` and `## Gotchas` sections
+- JSON with `{patterns: [], gotchas: []}` structure
+
+## License
+
+MIT
diff --git a/plugin/.claude-plugin/plugin.json b/plugin/.claude-plugin/plugin.json
new file mode 100644
index 0000000..79ee6a6
--- /dev/null
+++ b/plugin/.claude-plugin/plugin.json
@@ -0,0 +1,8 @@
+{
+  "name": "learn",
+  "description": "Claude Learn: Session analysis for patterns and gotchas",
+  "version": "1.0.0",
+  "author": {
+    "name": "Romfast Team"
+  }
+}
diff --git a/plugin/README.md b/plugin/README.md
new file mode 100644
index 0000000..5cdba33
--- /dev/null
+++ b/plugin/README.md
@@ -0,0 +1,49 @@
+# Claude Learn Plugin
+
+This is the main plugin directory. For installation and usage instructions, see the [main README](../README.md).
+
+## Plugin Structure
+
+```
+plugin/
+├── .claude-plugin/
+│   └── plugin.json      # Plugin manifest
+├── commands/
+│   ├── analyze.md       # /learn:analyze command
+│   ├── import.md        # /learn:import command
+│   ├── reflect.md       # /learn:reflect command
+│   └── status.md        # /learn:status command
+├── hooks/
+│   └── hooks.json       # Stop hook configuration
+├── rules/
+│   └── memory-format.md # Memory file format spec
+├── templates/
+│   └── memory-entry.json # JSON templates
+└── README.md            # This file
+```
+
+## Development
+
+To test locally:
+
+```bash
+claude --plugin-dir /path/to/claude-learn/plugin
+```
+
+## Commands Overview
+
+### /learn:analyze
+Analyzes the current conversation and proposes patterns/gotchas to save.
+
+### /learn:import
+Imports memories from other files (auto-build-memory.md, JSON, etc.)
+
+### /learn:reflect
+Consolidates duplicates, promotes frequent patterns to CLAUDE.md.
+
+### /learn:status
+Shows memory statistics and suggestions.
+
+## Hook
+
+The Stop hook triggers after significant conversations, suggesting `/learn:analyze` when appropriate.
diff --git a/plugin/commands/analyze.md b/plugin/commands/analyze.md
new file mode 100644
index 0000000..6cfa5ab
--- /dev/null
+++ b/plugin/commands/analyze.md
@@ -0,0 +1,130 @@
+---
+description: Analizează conversația și propune lecții de salvat
+argument-hint: [auto|patterns|gotchas] - Detectare automată sau categorie specifică
+---
+
+# Analiză Conversație pentru Lecții
+
+Examinează conversația curentă și identifică insights pentru documentație.
+
+## Ce să cauți:
+
+### Patterns (Soluții Repetabile)
+- Abordări care au funcționat bine
+- Configurații utile descoperite
+- Tehnici noi aplicate cu succes
+- Workflow-uri eficiente
+
+### Gotchas (Capcane de Evitat)
+- Erori întâlnite și cum s-au rezolvat
+- Confuzii cauzate de documentație
+- Comportamente neașteptate
+- Anti-patterns descoperite
+
+### Reguli CLAUDE.md
+- Convenții noi de documentat
+- Comenzi de adăugat
+- Workflow-uri de standardizat
+
+## Workflow
+
+### 1. Scanează Conversația
+- Identifică tool calls cu erori → potențiale gotchas
+- Identifică soluții aplicate → potențiale patterns
+- Identifică decizii tehnice → posibile reguli noi
+
+### 2. Generează Propuneri
+Format pentru fiecare insight:
+
+**[PATTERN/GOTCHA] Titlu Scurt**
+- **Categorie**: patterns | gotchas | rules
+- **Descriere**: Ce s-a învățat
+- **Context**: În ce situație e relevant
+- **Exemplu**: Cod sau pași concreți
+- **Tags**: [tag1, tag2, tag3]
+
+### 3. Prezintă Utilizatorului
+```
+📚 Am identificat {N} lecții din această conversație:
+
+1. [PATTERN] {Titlu}
+   {Descriere scurtă}
+
+2. [GOTCHA] {Titlu}
+   {Descriere scurtă}
+
+Care dintre acestea vrei să le salvez în documentație?
+- [1, 2, 3] - Selectează specific
+- [all] - Toate
+- [none] - Niciuna
+- [edit N] - Modifică propunerea N
+```
+
+### 4. Salvează în .claude/rules/claude-learn-memory.md
+
+Dacă fișierul nu există, creează-l cu template-ul de mai jos.
+
+Folosește formatul:
+
+```markdown
+# Claude Learn Memory
+
+Patterns și Gotchas învățate din sesiuni de lucru.
+
+---
+
+## Patterns
+
+### {Titlu}
+**Discovered**: {YYYY-MM-DD} (feature: {context})
+**Description**: {descriere}
+
+**Example** (`{file}:{lines}`):
+\```{language}
+{code}
+\```
+
+**Tags**: {tags}
+
+---
+
+## Gotchas
+
+### {Titlu}
+**Discovered**: {YYYY-MM-DD} (feature: {context})
+**Problem**: {problema}
+**Solution**: {soluția}
+
+**Tags**: {tags}
+
+---
+
+## Memory Statistics
+
+- **Total Patterns**: {N}
+- **Total Gotchas**: {N}
+- **Last Session**: {YYYY-MM-DD}
+- **Sessions Recorded**: {N}
+```
+
+### 5. Actualizează Statistici
+La sfârșitul fișierului memory.md, actualizează secțiunea Memory Statistics:
+- Incrementează Total Patterns/Gotchas
+- Actualizează Last Session la data curentă
+- Incrementează Sessions Recorded
+
+### 6. Confirmă
+```
+✅ Salvat în .claude/rules/claude-learn-memory.md:
+- 2 patterns adăugate
+- 1 gotcha adăugată
+
+Statistici actualizate: 15 patterns, 8 gotchas
+```
+
+## Argument: $ARGUMENTS
+
+Dacă argumentul este:
+- `auto` sau gol → detectează toate categoriile
+- `patterns` → focus doar pe patterns
+- `gotchas` → focus doar pe gotchas
diff --git a/plugin/commands/import.md b/plugin/commands/import.md
new file mode 100644
index 0000000..e597332
--- /dev/null
+++ b/plugin/commands/import.md
@@ -0,0 +1,125 @@
+---
+description: Importă patterns și gotchas din alte fișiere de memorie
+argument-hint: <file-path> - Calea către fișierul sursă (ex: .claude/rules/auto-build-memory.md)
+---
+
+# Import Memorie din Alt Fișier
+
+Importă patterns și gotchas dintr-un fișier existent în formatul claude-learn-memory.md.
+
+## Argument: $ARGUMENTS
+
+Calea către fișierul sursă. Exemple:
+- `.claude/rules/auto-build-memory.md`
+- `/path/to/other-project/.claude/rules/memory.md`
+- `./backup/memories.json`
+
+## Fișiere Suportate
+
+- `.claude/rules/auto-build-memory.md` (format auto-build plugin)
+- `.claude/rules/*.md` (orice fișier markdown cu secțiuni Patterns/Gotchas)
+- Fișiere JSON cu structură `{patterns: [], gotchas: []}`
+
+## Workflow
+
+### 1. Verifică Fișierul Sursă
+```
+Verifică dacă fișierul există și poate fi citit.
+Dacă nu există, afișează eroare și sugestii.
+```
+
+Dacă `$ARGUMENTS` este gol, afișează:
+```
+⚠️ Specifică fișierul sursă:
+
+/learn:import .claude/rules/auto-build-memory.md
+
+Fișiere comune de importat:
+- .claude/rules/auto-build-memory.md (auto-build plugin)
+- .claude/rules/*-memory.md (alte plugins)
+```
+
+### 2. Detectează Formatul
+- Markdown cu `## Patterns` și `## Gotchas` → parsează secțiuni
+- JSON cu array-uri → convertește direct
+- Alt format → eroare cu instrucțiuni
+
+### 3. Extrage Entries
+Pentru fiecare pattern/gotcha găsit:
+- Titlu (din ### heading)
+- Descriere/Problem/Solution
+- Tags (dacă există)
+- Data descoperirii (dacă există, altfel data curentă)
+
+### 4. Prezintă Preview
+```
+📥 Am găsit în {file}:
+- {N} patterns
+- {M} gotchas
+
+Preview:
+1. [PATTERN] {Titlu1}
+2. [PATTERN] {Titlu2}
+3. [GOTCHA] {Titlu3}
+...
+
+Vrei să le import toate în claude-learn-memory.md?
+- [all] - Importă toate
+- [1, 3, 5] - Selectează specific
+- [none] - Anulează
+```
+
+### 5. Verifică Duplicate
+Pentru fiecare entry:
+- Verifică dacă există deja în claude-learn-memory.md (după titlu)
+- Dacă există → skip și raportează
+- Dacă nu există → adaugă
+
+### 6. Merge și Salvează
+- Dacă `.claude/rules/claude-learn-memory.md` nu există, creează-l cu template gol
+- Adaugă entries noi la claude-learn-memory.md
+- Păstrează ordinea: Patterns apoi Gotchas
+- Actualizează statisticile
+
+### 7. Confirmă
+```
+✅ Import complet:
+- {X} patterns importate (Y skipped - duplicate)
+- {Z} gotchas importate
+
+Statistici actualizate: {total} patterns, {total} gotchas
+```
+
+## Exemple Utilizare
+
+```bash
+# Import din auto-build memory (comun pentru proiecte cu auto-build plugin)
+/learn:import .claude/rules/auto-build-memory.md
+
+# Import din alt proiect
+/learn:import /path/to/other-project/.claude/rules/memory.md
+
+# Import din JSON backup
+/learn:import ./backup/memories.json
+```
+
+## Tratare Erori
+
+Dacă fișierul nu există:
+```
+❌ Fișierul nu a fost găsit: {path}
+
+Verifică:
+1. Calea este corectă
+2. Fișierul există
+3. Ai permisiuni de citire
+```
+
+Dacă formatul nu este recunoscut:
+```
+❌ Format nerecunoscut pentru: {path}
+
+Formate suportate:
+- Markdown cu secțiuni ## Patterns și ## Gotchas
+- JSON cu structură {patterns: [], gotchas: []}
+```
diff --git a/plugin/commands/reflect.md b/plugin/commands/reflect.md
new file mode 100644
index 0000000..2b2af9f
--- /dev/null
+++ b/plugin/commands/reflect.md
@@ -0,0 +1,95 @@
+---
+description: Sintetizează patterns din mai multe sesiuni și curăță duplicatele
+---
+
+# Reflecție și Sinteză Memory
+
+Analizează toate patterns și gotchas și:
+1. Identifică duplicate sau suprapuneri
+2. Consolidează patterns similare
+3. Identifică patterns care lipsesc din CLAUDE.md principal
+4. Propune actualizări pentru CLAUDE.md proiect
+
+## Workflow
+
+### 1. Citește Memory
+Citește `.claude/rules/claude-learn-memory.md`
+
+Dacă fișierul nu există:
+```
+ℹ️ Nu există încă un fișier de memorie.
+Rulează /learn:analyze pentru a crea primul entry.
+```
+
+### 2. Analizează Conținut
+
+#### Duplicate
+- Identifică patterns/gotchas cu titluri similare
+- Propune consolidare
+
+#### Patterns Frecvente
+- Identifică tags care apar de 3+ ori
+- Aceste patterns sunt candidați pentru CLAUDE.md principal
+
+#### Patterns Învechite
+- Identifică entries mai vechi de 90 zile fără utilizare
+- Propune arhivare sau ștergere
+
+### 3. Prezintă Raport
+```
+📊 Raport Reflecție Memory
+
+Statistici curente:
+- {N} patterns
+- {M} gotchas
+- {K} tags unice
+
+🔄 Duplicate găsite: {X}
+- "{Pattern A}" și "{Pattern B}" sunt similare
+
+⭐ Candidați pentru CLAUDE.md: {Y}
+- Tag "vue" apare în 5 patterns → propun secțiune Vue în CLAUDE.md
+- Tag "api" apare în 4 patterns → propun secțiune API în CLAUDE.md
+
+🗑️ Posibil învechite: {Z}
+- "{Gotcha veche}" - 120 zile, nicio referință
+
+Ce vrei să fac?
+- [consolidate] - Consolidează duplicatele
+- [promote] - Mută candidații în CLAUDE.md
+- [archive] - Arhivează entries vechi
+- [all] - Toate acțiunile
+- [none] - Doar raportul
+```
+
+### 4. Consolidează Duplicate (dacă selectat)
+- Merge entries similare
+- Păstrează cel mai recent/complet
+- Actualizează statistici
+
+### 5. Promovează în CLAUDE.md (dacă selectat)
+- Identifică CLAUDE.md din proiect
+- Propune secțiuni noi bazate pe patterns frecvente
+- Prezintă diff pentru aprobare
+- După aprobare, actualizează CLAUDE.md
+
+### 6. Arhivează Vechi (dacă selectat)
+- Mută entries vechi la sfârșitul fișierului într-o secțiune `## Archived`
+- Sau șterge complet (cu confirmare)
+
+### 7. Confirmă
+```
+✅ Reflecție completă:
+- {X} duplicate consolidate
+- {Y} patterns promovate în CLAUDE.md
+- {Z} entries arhivate
+
+Statistici actualizate: {total} patterns, {total} gotchas
+```
+
+## Când să rulezi /learn:reflect
+
+- După 10+ sesiuni de /learn:analyze
+- Când ai 20+ entries în memory
+- Înainte de release-uri mari
+- Lunar, pentru mentenanță
diff --git a/plugin/commands/status.md b/plugin/commands/status.md
new file mode 100644
index 0000000..654cf80
--- /dev/null
+++ b/plugin/commands/status.md
@@ -0,0 +1,77 @@
+---
+description: Arată statistici memory și patterns frecvente
+---
+
+# Status Memory
+
+Afișează statistici despre `.claude/rules/claude-learn-memory.md`.
+
+## Workflow
+
+### 1. Verifică Fișierul
+Citește `.claude/rules/claude-learn-memory.md`
+
+Dacă nu există:
+```
+ℹ️ Nu există încă un fișier de memorie.
+
+Pentru a începe:
+1. Lucrează normal cu Claude Code
+2. Când termini o sesiune semnificativă, rulează /learn:analyze
+3. Sau importă memorie existentă cu /learn:import
+
+Comenzi disponibile:
+- /learn:analyze - Analizează conversația curentă
+- /learn:import <file> - Importă din alt fișier
+- /learn:reflect - Consolidează și curăță memory
+```
+
+### 2. Parsează Conținut
+- Numără patterns (secțiunea ## Patterns)
+- Numără gotchas (secțiunea ## Gotchas)
+- Extrage tags
+- Calculează statistici
+
+### 3. Afișează Raport
+```
+📊 Claude Learn Memory Status
+
+📁 Fișier: .claude/rules/claude-learn-memory.md
+
+📈 Statistici:
+- Total patterns: {N}
+- Total gotchas: {M}
+- Tags unice: {K}
+- Ultima sesiune: {YYYY-MM-DD}
+- Sesiuni înregistrate: {S}
+
+🏷️ Top 5 Tags:
+1. vue (8 entries)
+2. api (5 entries)
+3. typescript (4 entries)
+4. database (3 entries)
+5. auth (3 entries)
+
+📅 Activitate Recentă (ultimele 7 zile):
+- {X} patterns adăugate
+- {Y} gotchas adăugate
+
+💡 Sugestii:
+{Dacă > 20 entries fără reflect}
+- Rulează /learn:reflect pentru a consolida memory
+
+{Dacă ultimul entry > 14 zile}
+- Nu ai salvat lecții recent. Rulează /learn:analyze după sesiuni importante.
+
+{Dacă există duplicate evidente}
+- Am detectat {N} posibile duplicate. Rulează /learn:reflect.
+```
+
+## Output Minimal (fără sugestii)
+
+Dacă memory-ul e în stare bună:
+```
+📊 Claude Learn Memory: {N} patterns, {M} gotchas
+   Ultima actualizare: {YYYY-MM-DD}
+   Top tags: vue, api, typescript
+```
diff --git a/plugin/hooks/hooks.json b/plugin/hooks/hooks.json
new file mode 100644
index 0000000..bdcc93e
--- /dev/null
+++ b/plugin/hooks/hooks.json
@@ -0,0 +1,17 @@
+{
+  "description": "Claude Learn hooks",
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "Analizează rapid conversația. Dacă au fost: (1) rezolvate erori semnificative, (2) descoperite soluții noi, (3) luate decizii tehnice importante, sau (4) întâlnite probleme neașteptate - sugerează utilizatorului: '💡 Rulează /learn:analyze pentru a captura lecțiile din această sesiune.' Dacă conversația a fost simplă (întrebări, citire fișiere, task-uri banale), nu afișa nimic.",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/plugin/rules/memory-format.md b/plugin/rules/memory-format.md
new file mode 100644
index 0000000..4f3f6f7
--- /dev/null
+++ b/plugin/rules/memory-format.md
@@ -0,0 +1,82 @@
+---
+paths: ".claude/rules/claude-learn-memory.md"
+---
+
+# Claude Learn Memory Format
+
+Acest fișier definește formatul pentru `.claude/rules/claude-learn-memory.md`.
+
+## Template Gol
+
+```markdown
+# Claude Learn Memory
+
+Patterns și Gotchas învățate din sesiuni de lucru.
+
+---
+
+## Patterns
+
+<!-- Patterns vor fi adăugate aici -->
+
+---
+
+## Gotchas
+
+<!-- Gotchas vor fi adăugate aici -->
+
+---
+
+## Memory Statistics
+
+- **Total Patterns**: 0
+- **Total Gotchas**: 0
+- **Last Session**: -
+- **Sessions Recorded**: 0
+```
+
+## Format Pattern
+
+```markdown
+### {Titlu Descriptiv}
+**Discovered**: {YYYY-MM-DD} (feature: {context-scurt})
+**Description**: {Descriere clară a pattern-ului și când să-l folosești}
+
+**Example** (`{file}:{lines}`):
+\```{language}
+{cod exemplu}
+\```
+
+**Tags**: {tag1}, {tag2}, {tag3}
+
+---
+```
+
+## Format Gotcha
+
+```markdown
+### {Titlu Descriptiv}
+**Discovered**: {YYYY-MM-DD} (feature: {context-scurt})
+**Problem**: {Ce problemă a apărut}
+**Solution**: {Cum s-a rezolvat}
+
+**Tags**: {tag1}, {tag2}, {tag3}
+
+---
+```
+
+## Convenții
+
+1. **Titluri**: Folosește titluri descriptive, nu generice
+   - ✅ "Vue Watch Needs Immediate Flag for Initial Load"
+   - ❌ "Vue Problem"
+
+2. **Tags**: Folosește kebab-case, maxim 5 tags per entry
+   - ✅ `vue`, `reactivity`, `watch`, `initialization`
+   - ❌ `Vue.js`, `REACTIVITY`, `this is a tag`
+
+3. **Exemple**: Include întotdeauna cod exemplu când e posibil
+
+4. **Context**: Folosește feature name scurt pentru context
+   - ✅ `(feature: user-dashboard)`
+   - ❌ `(feature: implementing the new user dashboard with stats and charts)`
diff --git a/plugin/templates/memory-entry.json b/plugin/templates/memory-entry.json
new file mode 100644
index 0000000..d3044f1
--- /dev/null
+++ b/plugin/templates/memory-entry.json
@@ -0,0 +1,29 @@
+{
+  "pattern": {
+    "title": "",
+    "discovered": "",
+    "feature": "",
+    "description": "",
+    "example": {
+      "file": "",
+      "lines": "",
+      "language": "",
+      "code": ""
+    },
+    "tags": []
+  },
+  "gotcha": {
+    "title": "",
+    "discovered": "",
+    "feature": "",
+    "problem": "",
+    "solution": "",
+    "tags": []
+  },
+  "statistics": {
+    "total_patterns": 0,
+    "total_gotchas": 0,
+    "last_session": "",
+    "sessions_recorded": 0
+  }
+}