diff --git a/.claude/agents/pareto-strategy-optimizer.md b/.claude/agents/pareto-strategy-optimizer.md
new file mode 100644
index 0000000..0940e24
--- /dev/null
+++ b/.claude/agents/pareto-strategy-optimizer.md
@@ -0,0 +1,116 @@
+---
+name: pareto-strategy-optimizer
+description: Use this agent when you need to analyze a task or problem and find the most efficient solution that follows the Pareto principle (80/20 rule) - achieving maximum results with minimum resources. This agent excels at strategic exploration of options to identify high-leverage approaches that deliver disproportionate value relative to effort invested. Examples:\n\n\nContext: User wants to optimize their learning approach for a new programming language\nuser: "I need to learn Python for data science work"\nassistant: "I'll use the pareto-strategy-optimizer agent to identify the most efficient learning path"\n\nThe user needs a strategic approach to learning, so the pareto-strategy-optimizer will explore options and identify the 20% of Python concepts that will give 80% of practical data science capability.\n\n\n\n\nContext: User needs to improve application performance\nuser: "Our app is running slowly and we need to optimize it"\nassistant: "Let me engage the pareto-strategy-optimizer agent to identify the highest-impact optimizations"\n\nPerformance optimization requires strategic thinking to identify which improvements will yield the greatest results with minimal effort.\n\n\n\n\nContext: User wants to streamline a business process\nuser: "We have a complex onboarding process with 30 steps"\nassistant: "I'll deploy the pareto-strategy-optimizer agent to find the critical path that delivers most value"\n\nProcess optimization is perfect for Pareto analysis - finding which steps deliver the most value.\n\n
+tools: Glob, Grep, Read, WebFetch, TodoWrite, WebSearch, BashOutput, KillBash, Bash
+model: opus
+color: green
+---
+
+### Rol și Responsabilități
+Ești un agent specialist în analiza Pareto și optimizare strategică - the art of achieving 80% of results with 20% of effor. Primești o strategie specifică și dezvolți un plan detaliat de implementare, evaluând toate aspectele relevante pentru maximizarea șanselor de succes.
+
+### Proces de Analiză
+
+#### PASUL 1: Descompunerea Strategiei
+- Identifică componentele esențiale ale strategiei
+- Mapează dependențele și secvențialitatea
+- Stabilește punctele critice de succes
+
+#### PASUL 2: Planificare Detaliată
+Dezvoltă un plan care include:
+
+1. **Faze de Implementare**:
+ - Faza de Inițiere (ce, când, cum)
+ - Faza de Dezvoltare (activități specifice)
+ - Faza de Validare (teste și verificări)
+ - Faza de Scalare (dacă e cazul)
+
+2. **Analiza Resurselor**:
+ - Resurse umane necesare (competențe, timp)
+ - Resurse materiale/tehnologice
+ - Buget estimat
+ - Timeline realist
+
+3. **Analiza Riscurilor**:
+ - Riscuri majore identificate
+ - Probabilitate și impact
+ - Strategii de mitigare
+ - Trigger-e pentru activare contingențe
+
+#### PASUL 3: Optimizare Pareto
+Evaluează planul din perspectiva:
+- Trade-off între viteză și calitate
+- Trade-off între cost și beneficii
+- Trade-off între risc și recompensă
+- Identifică punctele de optim Pareto
+
+#### PASUL 4: Metrici și Monitorizare
+Definește:
+- Leading indicators (predictivi)
+- Lagging indicators (confirmare succes)
+- Praguri de alertă
+- Frecvența de monitorizare
+
+### Format Output Agent
+```markdown
+## PLAN STRATEGIC - [Numele Strategiei]
+
+### Rezumat Executiv
+[Max 100 cuvinte - esența planului]
+
+### Scor de Fezabilitate: [0-10]
+Justificare: [de ce acest scor]
+
+### Plan de Implementare
+
+#### Faza 1: [Nume] (Săptămânile 1-X)
+- Obiectiv: [ce se realizează]
+- Activități cheie:
+ 1. [Activitate specifică + durată]
+ 2. [Activitate specifică + durată]
+- Deliverables: [ce se livrează]
+- Resurse: [ce e necesar]
+- Riscuri: [principale riscuri în această fază]
+
+#### Faza 2: [Nume] (Săptămânile X-Y)
+[Similar cu Faza 1]
+
+### Analiza Cost-Beneficiu
+- Cost total estimat: [valoare + breakdown]
+- Beneficii estimate: [cuantificabile + calitative]
+- ROI estimat: [calcul și timeline]
+- Breakeven point: [când]
+
+### Matricea de Risc
+| Risc | Probabilitate | Impact | Scor | Mitigare |
+|------|--------------|--------|------|----------|
+| [Risc 1] | [L/M/H] | [L/M/H] | [1-9] | [Strategie] |
+
+### Avantaje Competitive ale Acestei Strategii
+1. [Avantaj unic 1]
+2. [Avantaj unic 2]
+
+### Puncte Slabe și Limitări
+1. [Limitare onestă 1]
+2. [Limitare onestă 2]
+
+### Compatibilitate cu Alte Strategii
+- Sinergie cu: [ID strategii complementare]
+- Conflict cu: [ID strategii incompatibile]
+- Poate fi combinată prin: [modalități de integrare]
+
+### Recomandare Finală
+[IMPLEMENTARE COMPLETĂ / IMPLEMENTARE PARȚIALĂ / COMBINARE CU ALTE STRATEGII / RESPINGERE]
+
+Justificare: [argumentare clară]
+
+**Key Principles**
+ - Always question whether each element is truly necessary
+ - Focus on outcomes, not activities
+ - Seek multiplicative rather than additive improvements
+ - Embrace "good enough" for non-critical elements
+ - Iterate quickly based on feedback rather than perfecting upfront
+
+When you receive a task, explore it thoroughly but efficiently. Challenge assumptions, identify shortcuts, and find creative ways to deliver exceptional value with minimal resource expenditure. Your goal is not just efficiency, but strategic brilliance - finding the elegant solution that others miss by being too focused on completeness rather than effectiveness.
+
+Remember: Perfection is often the enemy of efficiency. Your role is to find the sweet spot where effort and results achieve optimal balance.
diff --git a/PLAN_IMPLEMENTARE_S8_DETALIAT.md b/PLAN_IMPLEMENTARE_S8_DETALIAT.md
new file mode 100644
index 0000000..cb921cd
--- /dev/null
+++ b/PLAN_IMPLEMENTARE_S8_DETALIAT.md
@@ -0,0 +1,1160 @@
+# PLAN DETALIAT IMPLEMENTARE STRATEGIA S8 - HYBRID CLAUDE + SCRIPTS
+## Pentru Indexare Activități și Jocuri Cercetășești
+
+### CONTEXT ȘI OBIECTIVE
+- **Proiect:** INDEX-SISTEM-JOCURI v2.0
+- **Situație actuală:** 63 activități indexate din INDEX_MASTER.md
+- **Țintă:** 2000+ activități din 2086 fișiere diverse
+- **Strategie:** S8 Hybrid - Scripts Python pentru 90% volum + Claude pentru 10% high-value
+- **Timp total estimat:** 8 ore (poate fi împărțit în mai multe sesiuni)
+- **Buget:** $0 (folosind doar Claude Code existent)
+
+### DISTRIBUȚIA FIȘIERELOR (VERIFICATĂ)
+```
+1876 HTML files (89.9%) - Procesare automată cu BeautifulSoup
+122 PDF files (5.8%) - Procesare cu Claude (high-value, densitate mare)
+29 DOC files (1.4%) - Procesare cu Claude
+14 DOCX files (0.7%) - Procesare semi-automată cu python-docx
+35 TXT files (1.7%) - Procesare automată simplă
+10 MD files (0.5%) - Procesare automată simplă
+```
+
+### STRUCTURA BAZEI DE DATE EXISTENTE
+```sql
+-- Tabela activities cu toate câmpurile necesare
+id, name, description, rules, variations, category, subcategory,
+source_file, page_reference, age_group_min, age_group_max,
+participants_min, participants_max, duration_min, duration_max,
+materials_category, materials_list, skills_developed,
+difficulty_level, keywords, tags, popularity_score
+```
+
+---
+
+## FAZA 1: SETUP ȘI PREGĂTIRE (30 minute)
+
+### Pasul 1.1: Verificare și instalare dependențe
+```bash
+# Claude Code să execute:
+cd /mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri/INDEX-SISTEM-JOCURI
+
+# Verificare Python packages existente
+pip list | grep -E "beautifulsoup4|pypdf2|python-docx|lxml"
+
+# Instalare pachete lipsă
+pip install beautifulsoup4 lxml pypdf2 python-docx chardet
+
+# Creare director pentru scripturi noi
+mkdir -p scripts/extractors
+```
+
+### Pasul 1.2: Creare structură fișiere
+```bash
+# Claude Code să creeze următoarele fișiere:
+touch scripts/extractors/__init__.py
+touch scripts/extractors/html_extractor.py
+touch scripts/extractors/text_extractor.py
+touch scripts/extractors/pdf_extractor.py
+touch scripts/extractors/unified_processor.py
+touch scripts/run_extraction.py
+```
+
+### Pasul 1.3: Backup bază de date
+```bash
+# IMPORTANT: Backup înainte de procesare
+cp data/activities.db data/activities_backup_$(date +%Y%m%d_%H%M%S).db
+```
+
+---
+
+## FAZA 2: DEZVOLTARE EXTRACTOARE AUTOMATE (3 ore)
+
+### Pasul 2.1: HTML Extractor (cel mai important - 1876 fișiere)
+
+**Claude Code să creeze `/scripts/extractors/html_extractor.py`:**
+
+```python
+#!/usr/bin/env python3
+"""
+HTML Activity Extractor - Procesează 1876 fișiere HTML
+Extrage automat activități folosind pattern recognition
+"""
+
+import os
+import re
+import json
+from pathlib import Path
+from bs4 import BeautifulSoup
+import chardet
+from typing import List, Dict, Optional
+import sqlite3
+from datetime import datetime
+
+class HTMLActivityExtractor:
+ def __init__(self, db_path='data/activities.db'):
+ self.db_path = db_path
+ # Pattern-uri pentru detectare activități în română
+ self.activity_patterns = {
+ 'title_patterns': [
+ r'(?i)(joc|activitate|exerci[țt]iu|team[\s-]?building|energizer|ice[\s-]?breaker)[\s:]+([^\.]{5,100})',
+ r'(?i)]*>([^<]*(?:joc|activitate|exerci[țt]iu)[^<]*)',
+ r'(?i)([^<]*(?:joc|activitate|exerci[țt]iu)[^<]*)',
+ r'(?i)^[\d]+\.?\s*([A-Z][^\.]{10,100}(?:joc|activitate|exerci[țt]iu)[^\.]{0,50})$',
+ ],
+ 'description_markers': [
+ 'descriere', 'reguli', 'cum se joac[ăa]', 'instructiuni',
+ 'obiectiv', 'desfasurare', 'explicatie', 'mod de joc'
+ ],
+ 'materials_markers': [
+ 'materiale', 'necesare', 'echipament', 'ce avem nevoie',
+ 'se folosesc', 'trebuie sa avem', 'dotari'
+ ],
+ 'age_patterns': [
+ r'(?i)v[âa]rst[ăa][\s:]+(\d+)[\s-]+(\d+)',
+ r'(?i)(\d+)[\s-]+(\d+)\s*ani',
+ r'(?i)pentru\s+(\d+)[\s-]+(\d+)\s*ani',
+ r'(?i)categoria?\s*(?:de\s*)?v[âa]rst[ăa][\s:]+(\d+)[\s-]+(\d+)',
+ ],
+ 'participants_patterns': [
+ r'(?i)(\d+)[\s-]+(\d+)\s*(?:participan[țt]i|juc[ăa]tori|persoane|copii)',
+ r'(?i)num[ăa]r\s*(?:de\s*)?(?:participan[țt]i|juc[ăa]tori)[\s:]+(\d+)[\s-]+(\d+)',
+ r'(?i)grup\s*de\s*(\d+)[\s-]+(\d+)',
+ ],
+ 'duration_patterns': [
+ r'(?i)durat[ăa][\s:]+(\d+)[\s-]+(\d+)\s*(?:minute|min)',
+ r'(?i)timp[\s:]+(\d+)[\s-]+(\d+)\s*(?:minute|min)',
+ r'(?i)(\d+)[\s-]+(\d+)\s*minute',
+ ]
+ }
+
+ # Categorii predefinite bazate pe sistemul existent
+ self.categories = {
+ '[A]': ['joc', 'joaca', 'distractie', 'amuzament'],
+ '[B]': ['aventura', 'explorare', 'descoperire'],
+ '[C]': ['camping', 'tabara', 'excursie', 'drumetie'],
+ '[D]': ['foc', 'flacara', 'lumina'],
+ '[E]': ['noduri', 'frânghii', 'sfori', 'legare'],
+ '[F]': ['bushcraft', 'supravietuire', 'survival'],
+ '[G]': ['educatie', 'educativ', 'invatare', 'scoala'],
+ '[H]': ['orientare', 'busola', 'harta', 'navigare']
+ }
+
+ def detect_encoding(self, file_path):
+ """Detectează encoding-ul fișierului"""
+ with open(file_path, 'rb') as f:
+ result = chardet.detect(f.read())
+ return result['encoding'] or 'utf-8'
+
+ def extract_from_html(self, html_path: str) -> List[Dict]:
+ """Extrage activități dintr-un singur fișier HTML"""
+ activities = []
+
+ try:
+ # Detectare encoding și citire
+ encoding = self.detect_encoding(html_path)
+ with open(html_path, 'r', encoding=encoding, errors='ignore') as f:
+ content = f.read()
+
+ soup = BeautifulSoup(content, 'lxml')
+
+ # Metodă 1: Caută liste de activități
+ activities.extend(self._extract_from_lists(soup, html_path))
+
+ # Metodă 2: Caută activități în headings
+ activities.extend(self._extract_from_headings(soup, html_path))
+
+ # Metodă 3: Caută pattern-uri în text
+ activities.extend(self._extract_from_patterns(soup, html_path))
+
+ # Metodă 4: Caută în tabele
+ activities.extend(self._extract_from_tables(soup, html_path))
+
+ except Exception as e:
+ print(f"Error processing {html_path}: {e}")
+
+ return activities
+
+ def _extract_from_lists(self, soup, source_file):
+ """Extrage activități din liste HTML (ul, ol)"""
+ activities = []
+
+ for list_elem in soup.find_all(['ul', 'ol']):
+ # Verifică dacă lista pare să conțină activități
+ list_text = list_elem.get_text().lower()
+ if any(marker in list_text for marker in ['joc', 'activitate', 'exercitiu']):
+ for li in list_elem.find_all('li'):
+ text = li.get_text(strip=True)
+ if len(text) > 20: # Minim 20 caractere pentru o activitate validă
+ activity = self._create_activity_from_text(text, source_file)
+ if activity:
+ activities.append(activity)
+
+ return activities
+
+ def _extract_from_headings(self, soup, source_file):
+ """Extrage activități bazate pe headings"""
+ activities = []
+
+ for heading in soup.find_all(['h1', 'h2', 'h3', 'h4', 'h5', 'h6']):
+ heading_text = heading.get_text(strip=True)
+
+ # Verifică dacă heading-ul conține cuvinte cheie
+ if any(keyword in heading_text.lower() for keyword in ['joc', 'activitate', 'exercitiu']):
+ # Caută descrierea în elementele următoare
+ description = ""
+ next_elem = heading.find_next_sibling()
+
+ while next_elem and next_elem.name not in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
+ if next_elem.name in ['p', 'div', 'ul']:
+ description += next_elem.get_text(strip=True) + " "
+ if len(description) > 500: # Limită descriere
+ break
+ next_elem = next_elem.find_next_sibling()
+
+ if description:
+ activity = {
+ 'name': heading_text[:200],
+ 'description': description[:1000],
+ 'source_file': str(source_file),
+ 'category': self._detect_category(heading_text + " " + description)
+ }
+ activities.append(activity)
+
+ return activities
+
+ def _extract_from_patterns(self, soup, source_file):
+ """Extrage activități folosind pattern matching"""
+ activities = []
+ text = soup.get_text()
+
+ # Caută pattern-uri de activități
+ for pattern in self.activity_patterns['title_patterns']:
+ matches = re.finditer(pattern, text, re.MULTILINE)
+ for match in matches:
+ title = match.group(0) if match.lastindex == 0 else match.group(match.lastindex)
+ if len(title) > 10:
+ # Extrage context în jurul match-ului
+ start = max(0, match.start() - 200)
+ end = min(len(text), match.end() + 500)
+ context = text[start:end]
+
+ activity = self._create_activity_from_text(context, source_file, title)
+ if activity:
+ activities.append(activity)
+
+ return activities
+
+ def _extract_from_tables(self, soup, source_file):
+ """Extrage activități din tabele"""
+ activities = []
+
+ for table in soup.find_all('table'):
+ rows = table.find_all('tr')
+ if len(rows) > 1: # Cel puțin header și o linie de date
+ # Detectează coloanele relevante
+ headers = [th.get_text(strip=True).lower() for th in rows[0].find_all(['th', 'td'])]
+
+ for row in rows[1:]:
+ cells = row.find_all(['td'])
+ if cells:
+ activity_data = {}
+ for i, cell in enumerate(cells):
+ if i < len(headers):
+ activity_data[headers[i]] = cell.get_text(strip=True)
+
+ # Creează activitate din date tabel
+ if any(key in activity_data for key in ['joc', 'activitate', 'nume', 'titlu']):
+ activity = self._create_activity_from_table_data(activity_data, source_file)
+ if activity:
+ activities.append(activity)
+
+ return activities
+
+ def _create_activity_from_text(self, text, source_file, title=None):
+ """Creează un dicționar de activitate din text"""
+ if not text or len(text) < 30:
+ return None
+
+ activity = {
+ 'name': title or text[:100].split('.')[0].strip(),
+ 'description': text[:1000],
+ 'source_file': str(source_file),
+ 'category': self._detect_category(text),
+ 'keywords': self._extract_keywords(text),
+ 'created_at': datetime.now().isoformat()
+ }
+
+ # Extrage metadata suplimentară
+ activity.update(self._extract_metadata(text))
+
+ return activity
+
+ def _create_activity_from_table_data(self, data, source_file):
+ """Creează activitate din date de tabel"""
+ activity = {
+ 'source_file': str(source_file),
+ 'created_at': datetime.now().isoformat()
+ }
+
+ # Mapare câmpuri tabel la câmpuri DB
+ field_mapping = {
+ 'nume': 'name', 'titlu': 'name', 'joc': 'name', 'activitate': 'name',
+ 'descriere': 'description', 'detalii': 'description', 'explicatie': 'description',
+ 'materiale': 'materials_list', 'echipament': 'materials_list',
+ 'varsta': 'age_group_min', 'categoria': 'category',
+ 'participanti': 'participants_min', 'numar': 'participants_min',
+ 'durata': 'duration_min', 'timp': 'duration_min'
+ }
+
+ for table_field, db_field in field_mapping.items():
+ if table_field in data:
+ activity[db_field] = data[table_field]
+
+ # Validare minimă
+ if 'name' in activity and len(activity.get('name', '')) > 5:
+ return activity
+
+ return None
+
+ def _extract_metadata(self, text):
+ """Extrage metadata din text folosind pattern-uri"""
+ metadata = {}
+
+ # Extrage vârsta
+ for pattern in self.activity_patterns['age_patterns']:
+ match = re.search(pattern, text)
+ if match:
+ metadata['age_group_min'] = int(match.group(1))
+ metadata['age_group_max'] = int(match.group(2)) if match.lastindex >= 2 else int(match.group(1))
+ break
+
+ # Extrage număr participanți
+ for pattern in self.activity_patterns['participants_patterns']:
+ match = re.search(pattern, text)
+ if match:
+ metadata['participants_min'] = int(match.group(1))
+ metadata['participants_max'] = int(match.group(2)) if match.lastindex >= 2 else int(match.group(1))
+ break
+
+ # Extrage durata
+ for pattern in self.activity_patterns['duration_patterns']:
+ match = re.search(pattern, text)
+ if match:
+ metadata['duration_min'] = int(match.group(1))
+ metadata['duration_max'] = int(match.group(2)) if match.lastindex >= 2 else int(match.group(1))
+ break
+
+ # Extrage materiale
+ materials = []
+ text_lower = text.lower()
+ for marker in self.activity_patterns['materials_markers']:
+ idx = text_lower.find(marker)
+ if idx != -1:
+ # Extrage următoarele 200 caractere după marker
+ materials_text = text[idx:idx+200]
+ # Extrage items din listă
+ items = re.findall(r'[-•]\s*([^\n-•]+)', materials_text)
+ if items:
+ materials.extend(items)
+
+ if materials:
+ metadata['materials_list'] = ', '.join(materials[:10]) # Maxim 10 materiale
+
+ return metadata
+
+ def _detect_category(self, text):
+ """Detectează categoria activității bazată pe cuvinte cheie"""
+ text_lower = text.lower()
+
+ for category, keywords in self.categories.items():
+ if any(keyword in text_lower for keyword in keywords):
+ return category
+
+ return '[A]' # Default categoria jocuri
+
+ def _extract_keywords(self, text):
+ """Extrage cuvinte cheie din text"""
+ keywords = []
+ text_lower = text.lower()
+
+ # Lista de cuvinte cheie relevante
+ keyword_list = [
+ 'cooperare', 'competitie', 'echipa', 'creativitate', 'miscare',
+ 'strategie', 'comunicare', 'incredere', 'coordonare', 'atentie',
+ 'reflexe', 'logica', 'imaginatie', 'muzica', 'dans', 'sport',
+ 'natura', 'mediu', 'stiinta', 'matematica', 'limba', 'cultura'
+ ]
+
+ for keyword in keyword_list:
+ if keyword in text_lower:
+ keywords.append(keyword)
+
+ return ', '.join(keywords[:5]) # Maxim 5 keywords
+
+ def save_to_database(self, activities):
+ """Salvează activitățile în baza de date"""
+ conn = sqlite3.connect(self.db_path)
+ cursor = conn.cursor()
+
+ saved_count = 0
+ duplicate_count = 0
+
+ for activity in activities:
+ try:
+ # Verifică duplicate
+ cursor.execute(
+ "SELECT id FROM activities WHERE name = ? AND source_file = ?",
+ (activity.get('name'), activity.get('source_file'))
+ )
+
+ if cursor.fetchone():
+ duplicate_count += 1
+ continue
+
+ # Pregătește valorile pentru insert
+ columns = []
+ values = []
+ placeholders = []
+
+ for key, value in activity.items():
+ if key != 'created_at': # Skip created_at, it has default
+ columns.append(key)
+ values.append(value)
+ placeholders.append('?')
+
+ # Insert în DB
+ query = f"INSERT INTO activities ({', '.join(columns)}) VALUES ({', '.join(placeholders)})"
+ cursor.execute(query, values)
+ saved_count += 1
+
+ except Exception as e:
+ print(f"Error saving activity: {e}")
+ continue
+
+ conn.commit()
+ conn.close()
+
+ return saved_count, duplicate_count
+
+ def process_all_html_files(self, base_path='/mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri'):
+ """Procesează toate fișierele HTML din directorul specificat"""
+ base_path = Path(base_path)
+ html_files = list(base_path.rglob("*.html"))
+ html_files.extend(list(base_path.rglob("*.htm")))
+
+ print(f"Found {len(html_files)} HTML files to process")
+
+ all_activities = []
+ processed = 0
+ errors = 0
+
+ for i, html_file in enumerate(html_files):
+ try:
+ activities = self.extract_from_html(str(html_file))
+ all_activities.extend(activities)
+ processed += 1
+
+ # Progress update
+ if (i + 1) % 100 == 0:
+ print(f"Progress: {i+1}/{len(html_files)} files processed, {len(all_activities)} activities found")
+ # Save batch to DB
+ if all_activities:
+ saved, dupes = self.save_to_database(all_activities)
+ print(f"Batch saved: {saved} new activities, {dupes} duplicates skipped")
+ all_activities = [] # Clear buffer
+
+ except Exception as e:
+ print(f"Error processing {html_file}: {e}")
+ errors += 1
+
+ # Save remaining activities
+ if all_activities:
+ saved, dupes = self.save_to_database(all_activities)
+ print(f"Final batch saved: {saved} new activities, {dupes} duplicates skipped")
+
+ print(f"\nProcessing complete!")
+ print(f"Files processed: {processed}")
+ print(f"Errors: {errors}")
+
+ return processed, errors
+
+# Funcție main pentru test
+if __name__ == "__main__":
+ extractor = HTMLActivityExtractor()
+
+ # Test pe un fișier sample mai întâi
+ print("Testing on sample file first...")
+ # Găsește un fișier HTML pentru test
+ test_files = list(Path('/mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri').rglob("*.html"))[:3]
+
+ for test_file in test_files:
+ print(f"\nTesting: {test_file}")
+ activities = extractor.extract_from_html(str(test_file))
+ print(f"Found {len(activities)} activities")
+ if activities:
+ print(f"Sample activity: {activities[0]['name'][:50]}...")
+
+ # Întreabă dacă să continue cu procesarea completă
+ response = input("\nContinue with full processing? (y/n): ")
+ if response.lower() == 'y':
+ extractor.process_all_html_files()
+```
+
+### Pasul 2.2: Text/MD Extractor (simplu - 45 fișiere)
+
+**Claude Code să creeze `/scripts/extractors/text_extractor.py`:**
+
+```python
+#!/usr/bin/env python3
+"""
+Text/Markdown Activity Extractor
+Procesează fișiere TXT și MD pentru extracție activități
+"""
+
+import re
+from pathlib import Path
+from typing import List, Dict
+import sqlite3
+from datetime import datetime
+
+class TextActivityExtractor:
+ def __init__(self, db_path='data/activities.db'):
+ self.db_path = db_path
+ self.activity_patterns = {
+ 'section_headers': [
+ r'^#{1,6}\s*(.+)$', # Markdown headers
+ r'^([A-Z][^\.]{10,100})$', # Titluri simple
+ r'^\d+\.\s*(.+)$', # Numbered lists
+ r'^[•\-\*]\s*(.+)$', # Bullet points
+ ],
+ 'activity_markers': [
+ 'joc:', 'activitate:', 'exercitiu:', 'team building:',
+ 'nume:', 'titlu:', 'denumire:'
+ ]
+ }
+
+ def extract_from_text(self, file_path: str) -> List[Dict]:
+ """Extrage activități din fișier text/markdown"""
+ activities = []
+
+ try:
+ with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+ content = f.read()
+
+ # Metodă 1: Caută secțiuni markdown
+ if file_path.endswith('.md'):
+ activities.extend(self._extract_from_markdown(content, file_path))
+
+ # Metodă 2: Caută pattern-uri generale
+ activities.extend(self._extract_from_patterns(content, file_path))
+
+ # Metodă 3: Caută blocuri de text structurate
+ activities.extend(self._extract_from_blocks(content, file_path))
+
+ except Exception as e:
+ print(f"Error processing {file_path}: {e}")
+
+ return activities
+
+ def _extract_from_markdown(self, content, source_file):
+ """Extrage activități din format markdown"""
+ activities = []
+ lines = content.split('\n')
+
+ current_activity = None
+ current_content = []
+
+ for line in lines:
+ # Verifică dacă e header de activitate
+ if re.match(r'^#{1,3}\s*(.+)', line):
+ # Salvează activitatea anterioară dacă există
+ if current_activity and current_content:
+ current_activity['description'] = '\n'.join(current_content[:20]) # Max 20 linii
+ activities.append(current_activity)
+
+ # Verifică dacă noul header e o activitate
+ header_text = re.sub(r'^#{1,3}\s*', '', line)
+ if any(marker in header_text.lower() for marker in ['joc', 'activitate', 'exercitiu']):
+ current_activity = {
+ 'name': header_text[:200],
+ 'source_file': str(source_file),
+ 'category': '[A]'
+ }
+ current_content = []
+ else:
+ current_activity = None
+
+ elif current_activity:
+ # Adaugă conținut la activitatea curentă
+ if line.strip():
+ current_content.append(line)
+
+ # Salvează ultima activitate
+ if current_activity and current_content:
+ current_activity['description'] = '\n'.join(current_content[:20])
+ activities.append(current_activity)
+
+ return activities
+
+ def _extract_from_patterns(self, content, source_file):
+ """Extrage folosind pattern matching"""
+ activities = []
+
+ # Caută markeri specifici de activități
+ for marker in self.activity_patterns['activity_markers']:
+ pattern = re.compile(f'{re.escape(marker)}\\s*(.+?)(?=\\n\\n|{re.escape(marker)}|$)',
+ re.IGNORECASE | re.DOTALL)
+ matches = pattern.finditer(content)
+
+ for match in matches:
+ activity_text = match.group(1)
+ if len(activity_text) > 20:
+ activity = {
+ 'name': activity_text.split('\n')[0][:200],
+ 'description': activity_text[:1000],
+ 'source_file': str(source_file),
+ 'category': '[A]'
+ }
+ activities.append(activity)
+
+ return activities
+
+ def _extract_from_blocks(self, content, source_file):
+ """Extrage din blocuri de text separate"""
+ activities = []
+
+ # Împarte în blocuri separate de linii goale
+ blocks = re.split(r'\n\s*\n', content)
+
+ for block in blocks:
+ if len(block) > 50: # Minim 50 caractere
+ lines = block.strip().split('\n')
+ first_line = lines[0].strip()
+
+ # Verifică dacă blocul pare o activitate
+ if any(keyword in first_line.lower() for keyword in ['joc', 'activitate', 'exercitiu']):
+ activity = {
+ 'name': first_line[:200],
+ 'description': block[:1000],
+ 'source_file': str(source_file),
+ 'category': '[A]'
+ }
+ activities.append(activity)
+
+ return activities
+
+ def save_to_database(self, activities):
+ """Salvează în baza de date"""
+ conn = sqlite3.connect(self.db_path)
+ cursor = conn.cursor()
+
+ saved_count = 0
+
+ for activity in activities:
+ try:
+ # Check for duplicates
+ cursor.execute(
+ "SELECT id FROM activities WHERE name = ? AND source_file = ?",
+ (activity.get('name'), activity.get('source_file'))
+ )
+
+ if not cursor.fetchone():
+ columns = list(activity.keys())
+ values = list(activity.values())
+ placeholders = ['?' for _ in values]
+
+ query = f"INSERT INTO activities ({', '.join(columns)}) VALUES ({', '.join(placeholders)})"
+ cursor.execute(query, values)
+ saved_count += 1
+
+ except Exception as e:
+ print(f"Error saving: {e}")
+
+ conn.commit()
+ conn.close()
+
+ return saved_count
+
+ def process_all_text_files(self, base_path='/mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri'):
+ """Procesează toate fișierele text și markdown"""
+ base_path = Path(base_path)
+
+ text_files = list(base_path.rglob("*.txt"))
+ md_files = list(base_path.rglob("*.md"))
+ all_files = text_files + md_files
+
+ print(f"Found {len(all_files)} text/markdown files")
+
+ all_activities = []
+
+ for file_path in all_files:
+ activities = self.extract_from_text(str(file_path))
+ all_activities.extend(activities)
+ print(f"Processed {file_path.name}: {len(activities)} activities")
+
+ # Save to database
+ saved = self.save_to_database(all_activities)
+ print(f"\nTotal saved: {saved} activities from {len(all_files)} files")
+
+ return len(all_files), saved
+
+if __name__ == "__main__":
+ extractor = TextActivityExtractor()
+ extractor.process_all_text_files()
+```
+
+### Pasul 2.3: Unified Processor (orchestrator)
+
+**Claude Code să creeze `/scripts/extractors/unified_processor.py`:**
+
+```python
+#!/usr/bin/env python3
+"""
+Unified Activity Processor
+Orchestrează toate extractoarele pentru procesare completă
+"""
+
+import time
+from pathlib import Path
+from html_extractor import HTMLActivityExtractor
+from text_extractor import TextActivityExtractor
+import sqlite3
+
+class UnifiedProcessor:
+ def __init__(self, db_path='data/activities.db'):
+ self.db_path = db_path
+ self.html_extractor = HTMLActivityExtractor(db_path)
+ self.text_extractor = TextActivityExtractor(db_path)
+ self.stats = {
+ 'html_processed': 0,
+ 'text_processed': 0,
+ 'pdf_to_process': 0,
+ 'doc_to_process': 0,
+ 'total_activities': 0,
+ 'start_time': None,
+ 'end_time': None
+ }
+
+ def get_current_activity_count(self):
+ """Obține numărul curent de activități din DB"""
+ conn = sqlite3.connect(self.db_path)
+ cursor = conn.cursor()
+ cursor.execute("SELECT COUNT(*) FROM activities")
+ count = cursor.fetchone()[0]
+ conn.close()
+ return count
+
+ def count_files_to_process(self, base_path):
+ """Numără fișierele care trebuie procesate"""
+ base_path = Path(base_path)
+
+ counts = {
+ 'html': len(list(base_path.rglob("*.html"))) + len(list(base_path.rglob("*.htm"))),
+ 'txt': len(list(base_path.rglob("*.txt"))),
+ 'md': len(list(base_path.rglob("*.md"))),
+ 'pdf': len(list(base_path.rglob("*.pdf"))),
+ 'doc': len(list(base_path.rglob("*.doc"))),
+ 'docx': len(list(base_path.rglob("*.docx")))
+ }
+
+ return counts
+
+ def process_automated_formats(self, base_path='/mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri'):
+ """Procesează toate formatele care pot fi automatizate"""
+ print("="*60)
+ print("UNIFIED ACTIVITY PROCESSOR - AUTOMATED PHASE")
+ print("="*60)
+
+ self.stats['start_time'] = time.time()
+ initial_count = self.get_current_activity_count()
+
+ # Afișează statistici inițiale
+ file_counts = self.count_files_to_process(base_path)
+ print(f"\nFiles to process:")
+ for format, count in file_counts.items():
+ print(f" {format.upper()}: {count} files")
+ print(f"\nCurrent activities in database: {initial_count}")
+ print("-"*60)
+
+ # FAZA 1: Procesare HTML (prioritate maximă - volum mare)
+ print("\n[1/2] Processing HTML files...")
+ print("-"*40)
+ html_processed, html_errors = self.html_extractor.process_all_html_files(base_path)
+ self.stats['html_processed'] = html_processed
+
+ # FAZA 2: Procesare Text/MD
+ print("\n[2/2] Processing Text/Markdown files...")
+ print("-"*40)
+ text_processed, text_saved = self.text_extractor.process_all_text_files(base_path)
+ self.stats['text_processed'] = text_processed
+
+ # Statistici finale
+ self.stats['end_time'] = time.time()
+ final_count = self.get_current_activity_count()
+ self.stats['total_activities'] = final_count - initial_count
+
+ # Identifică fișierele care necesită procesare manuală
+ self.stats['pdf_to_process'] = file_counts['pdf']
+ self.stats['doc_to_process'] = file_counts['doc'] + file_counts['docx']
+
+ self.print_summary()
+ self.save_pdf_doc_list(base_path)
+
+ def print_summary(self):
+ """Afișează rezumatul procesării"""
+ print("\n" + "="*60)
+ print("PROCESSING SUMMARY")
+ print("="*60)
+
+ duration = self.stats['end_time'] - self.stats['start_time']
+
+ print(f"\nAutomated Processing Results:")
+ print(f" HTML files processed: {self.stats['html_processed']}")
+ print(f" Text/MD files processed: {self.stats['text_processed']}")
+ print(f" New activities added: {self.stats['total_activities']}")
+ print(f" Processing time: {duration:.1f} seconds")
+
+ print(f"\nFiles requiring Claude processing:")
+ print(f" PDF files: {self.stats['pdf_to_process']}")
+ print(f" DOC/DOCX files: {self.stats['doc_to_process']}")
+
+ print("\n" + "="*60)
+ print("NEXT STEPS:")
+ print("1. Review the file 'pdf_doc_for_claude.txt' for manual processing")
+ print("2. Use Claude to extract activities from PDF/DOC files")
+ print("3. Focus on largest PDF files first (highest activity density)")
+ print("="*60)
+
+ def save_pdf_doc_list(self, base_path):
+ """Salvează lista de PDF/DOC pentru procesare cu Claude"""
+ base_path = Path(base_path)
+
+ pdf_files = sorted(base_path.rglob("*.pdf"), key=lambda p: p.stat().st_size, reverse=True)
+ doc_files = list(base_path.rglob("*.doc"))
+ docx_files = list(base_path.rglob("*.docx"))
+
+ with open('pdf_doc_for_claude.txt', 'w', encoding='utf-8') as f:
+ f.write("PDF/DOC FILES FOR CLAUDE PROCESSING\n")
+ f.write("="*60 + "\n")
+ f.write("Files sorted by size (largest first = likely more activities)\n\n")
+
+ f.write("TOP PRIORITY PDF FILES (process these first):\n")
+ f.write("-"*40 + "\n")
+ for i, pdf in enumerate(pdf_files[:20], 1):
+ size_mb = pdf.stat().st_size / (1024*1024)
+ f.write(f"{i}. {pdf.name} ({size_mb:.1f} MB)\n")
+ f.write(f" Path: {pdf}\n\n")
+
+ if len(pdf_files) > 20:
+ f.write(f"\n... and {len(pdf_files)-20} more PDF files\n\n")
+
+ f.write("\nDOC/DOCX FILES:\n")
+ f.write("-"*40 + "\n")
+ for doc in doc_files + docx_files:
+ size_kb = doc.stat().st_size / 1024
+ f.write(f"- {doc.name} ({size_kb:.1f} KB)\n")
+
+ print(f"\nPDF/DOC list saved to: pdf_doc_for_claude.txt")
+
+if __name__ == "__main__":
+ processor = UnifiedProcessor()
+ processor.process_automated_formats()
+```
+
+---
+
+## FAZA 3: PROCESARE MANUALĂ CU CLAUDE (3-4 ore)
+
+### Pasul 3.1: Template pentru extracție cu Claude
+
+**Claude Code să creeze `/scripts/claude_extraction_template.md`:**
+
+```markdown
+# TEMPLATE PENTRU EXTRACȚIE ACTIVITĂȚI CU CLAUDE
+
+## Instrucțiuni pentru Claude Code:
+
+Pentru fiecare PDF/DOC, folosește următorul format de extracție:
+
+### 1. Citește fișierul:
+```
+Claude, te rog citește fișierul: [CALE_FISIER]
+```
+
+### 2. Extrage activitățile folosind acest template JSON:
+```json
+{
+ "source_file": "[NUME_FISIER]",
+ "activities": [
+ {
+ "name": "Numele activității",
+ "description": "Descrierea completă a activității",
+ "rules": "Regulile jocului/activității",
+ "variations": "Variante sau adaptări",
+ "category": "[A-H] bazat pe tip",
+ "age_group_min": 6,
+ "age_group_max": 14,
+ "participants_min": 4,
+ "participants_max": 20,
+ "duration_min": 10,
+ "duration_max": 30,
+ "materials_list": "Lista materialelor necesare",
+ "skills_developed": "Competențe dezvoltate",
+ "difficulty_level": "Ușor/Mediu/Dificil",
+ "keywords": "cuvinte cheie separate prin virgulă",
+ "tags": "taguri relevante"
+ }
+ ]
+}
+```
+
+### 3. Salvează în fișier:
+După extracție, salvează JSON-ul în: `/scripts/extracted_activities/[NUME_FISIER].json`
+
+### 4. Priorități de procesare:
+
+**TOP PRIORITY (procesează primele):**
+1. 1000 Fantastic Scout Games.pdf
+2. Cartea Mare a jocurilor.pdf
+3. 160-de-activitati-dinamice-jocuri-pentru-team-building.pdf
+4. 101 Ways to Create an Unforgettable Camp Experience.pdf
+5. 151 Awesome Summer Camp Nature Activities.pdf
+
+**Categorii de focus:**
+- [A] Jocuri Cercetășești
+- [C] Camping & Activități Exterior
+- [G] Activități Educaționale
+```
+
+### Pasul 3.2: Script pentru import activități din JSON
+
+**Claude Code să creeze `/scripts/import_claude_activities.py`:**
+
+```python
+#!/usr/bin/env python3
+"""
+Import activities extracted by Claude from JSON files
+"""
+
+import json
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+
+class ClaudeActivityImporter:
+ def __init__(self, db_path='data/activities.db'):
+ self.db_path = db_path
+ self.json_dir = Path('scripts/extracted_activities')
+ self.json_dir.mkdir(exist_ok=True)
+
+ def import_json_file(self, json_path):
+ """Import activities from a single JSON file"""
+ with open(json_path, 'r', encoding='utf-8') as f:
+ data = json.load(f)
+
+ source_file = data.get('source_file', str(json_path))
+ activities = data.get('activities', [])
+
+ conn = sqlite3.connect(self.db_path)
+ cursor = conn.cursor()
+
+ imported = 0
+ for activity in activities:
+ try:
+ # Add source file and timestamp
+ activity['source_file'] = source_file
+ activity['created_at'] = datetime.now().isoformat()
+
+ # Prepare insert
+ columns = list(activity.keys())
+ values = list(activity.values())
+ placeholders = ['?' for _ in values]
+
+ # Check for duplicate
+ cursor.execute(
+ "SELECT id FROM activities WHERE name = ? AND source_file = ?",
+ (activity.get('name'), source_file)
+ )
+
+ if not cursor.fetchone():
+ query = f"INSERT INTO activities ({', '.join(columns)}) VALUES ({', '.join(placeholders)})"
+ cursor.execute(query, values)
+ imported += 1
+
+ except Exception as e:
+ print(f"Error importing activity: {e}")
+
+ conn.commit()
+ conn.close()
+
+ print(f"Imported {imported} activities from {json_path.name}")
+ return imported
+
+ def import_all_json_files(self):
+ """Import all JSON files from the extracted_activities directory"""
+ json_files = list(self.json_dir.glob("*.json"))
+
+ if not json_files:
+ print("No JSON files found in extracted_activities directory")
+ return 0
+
+ total_imported = 0
+ for json_file in json_files:
+ imported = self.import_json_file(json_file)
+ total_imported += imported
+
+ print(f"\nTotal imported: {total_imported} activities from {len(json_files)} files")
+ return total_imported
+
+if __name__ == "__main__":
+ importer = ClaudeActivityImporter()
+ importer.import_all_json_files()
+```
+
+---
+
+## FAZA 4: SCRIPT PRINCIPAL DE ORCHESTRARE
+
+**Claude Code să creeze `/scripts/run_extraction.py`:**
+
+```python
+#!/usr/bin/env python3
+"""
+Main extraction orchestrator
+Rulează întregul proces de extracție
+"""
+
+import sys
+import time
+from pathlib import Path
+
+# Add extractors to path
+sys.path.append(str(Path(__file__).parent / 'extractors'))
+
+from extractors.unified_processor import UnifiedProcessor
+from import_claude_activities import ClaudeActivityImporter
+
+def main():
+ print("="*60)
+ print("ACTIVITY EXTRACTION SYSTEM")
+ print("Strategy S8: Hybrid Claude + Scripts")
+ print("="*60)
+
+ # Step 1: Run automated extraction
+ print("\nSTEP 1: Automated Extraction")
+ print("-"*40)
+ processor = UnifiedProcessor()
+ processor.process_automated_formats()
+
+ # Step 2: Wait for Claude processing
+ print("\n" + "="*60)
+ print("STEP 2: Manual Claude Processing Required")
+ print("-"*40)
+ print("Please process PDF/DOC files with Claude using the template.")
+ print("Files are listed in: pdf_doc_for_claude.txt")
+ print("Save extracted activities as JSON in: scripts/extracted_activities/")
+ print("="*60)
+
+ response = input("\nHave you completed Claude processing? (y/n): ")
+
+ if response.lower() == 'y':
+ # Step 3: Import Claude-extracted activities
+ print("\nSTEP 3: Importing Claude-extracted activities")
+ print("-"*40)
+ importer = ClaudeActivityImporter()
+ importer.import_all_json_files()
+
+ print("\n" + "="*60)
+ print("EXTRACTION COMPLETE!")
+ print("="*60)
+
+if __name__ == "__main__":
+ main()
+```
+
+---
+
+## INSTRUCȚIUNI DE EXECUȚIE PENTRU CLAUDE CODE
+
+### Executare automată (Claude Code să ruleze acestea):
+
+```bash
+# 1. Setup inițial
+cd /mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri/INDEX-SISTEM-JOCURI
+pip install beautifulsoup4 lxml pypdf2 python-docx chardet
+
+# 2. Creează toate fișierele de mai sus
+# [Claude Code creează toate fișierele Python descrise]
+
+# 3. Backup database
+cp data/activities.db data/activities_backup_$(date +%Y%m%d).db
+
+# 4. Rulează extracția automată
+python scripts/run_extraction.py
+
+# 5. După procesare automată, afișează lista PDF pentru procesare manuală
+cat pdf_doc_for_claude.txt | head -30
+```
+
+### Pentru procesarea PDF/DOC cu Claude:
+
+1. **Claude citește fiecare PDF din lista prioritară**
+2. **Extrage activitățile în format JSON**
+3. **Salvează în `/scripts/extracted_activities/[nume_fisier].json`**
+4. **După completare, rulează importul**:
+ ```bash
+ python scripts/import_claude_activities.py
+ ```
+
+### Verificare finală:
+
+```bash
+# Verifică câte activități au fost indexate
+sqlite3 data/activities.db "SELECT COUNT(*) as total FROM activities;"
+
+# Verifică distribuția pe categorii
+sqlite3 data/activities.db "SELECT category, COUNT(*) as count FROM activities GROUP BY category;"
+
+# Verifică sursele
+sqlite3 data/activities.db "SELECT source_file, COUNT(*) as count FROM activities GROUP BY source_file ORDER BY count DESC LIMIT 10;"
+```
+
+---
+
+## REZULTATE ESTIMATE
+
+### După procesare automată (4 ore):
+- **HTML**: ~1200-1500 activități
+- **TXT/MD**: ~100-200 activități
+- **Total automat**: ~1300-1700 activități
+
+### După procesare Claude (3-4 ore):
+- **PDF**: ~300-500 activități (high quality)
+- **DOC/DOCX**: ~100-150 activități
+- **Total Claude**: ~400-650 activități
+
+### TOTAL FINAL: ~1700-2350 activități
+
+---
+
+## TROUBLESHOOTING
+
+### Probleme comune și soluții:
+
+1. **Encoding errors**: Scripturile folosesc chardet pentru auto-detectare
+2. **Memory issues**: Procesare în batch-uri de 100 fișiere
+3. **Duplicate detection**: Verificare automată name+source_file
+4. **PDF extraction fails**: Fallback la Claude pentru procesare manuală
+5. **Database locked**: Închide aplicația Flask înainte de procesare
+
+---
+
+## NOTE PENTRU IMPLEMENTARE
+
+1. **Prioritizează PDF-urile mari** - conțin cele mai multe activități
+2. **Rulează noaptea** dacă vrei să procesezi tot automatul
+3. **Salvează progresul** - scripturile salvează în batch-uri
+4. **Verifică calitatea** - spot-check pe câteva activități random
+5. **Backup întotdeauna** - ai backup automat în script
+
+Acest plan este complet automatizat pentru 90% din muncă. Claude Code poate rula totul automat, tu doar supraveghezi și procesezi PDF-urile importante cu Claude.
\ No newline at end of file
diff --git a/docs/project/PM_PROMPT.md b/docs/project/PM_PROMPT.md
deleted file mode 100644
index 6be4c83..0000000
--- a/docs/project/PM_PROMPT.md
+++ /dev/null
@@ -1,267 +0,0 @@
-# Project Manager Prompt
-## Sistem de Indexare și Căutare Activități Educaționale
-
-### CONTEXT ȘI ROLUL TĂU
-
-Ești un **Project Manager Senior** cu experiență în dezvoltarea de produse software educaționale. Ai fost asignat să supraveghezi implementarea sistemului **INDEX-SISTEM-JOCURI** - un tool web pentru indexarea și căutarea activităților educaționale.
-
-**Documentul principal:** `PRD.md` (citește întregul document înainte de a începe)
-
-**Obiectivul tău:** Să ghidezi echipa de dezvoltare prin implementarea completă și livrarea cu succes a acestui sistem în 6-9 zile lucrătoare.
-
-### RESPONSABILITĂȚILE TALE
-
-#### 1. **Planning & Coordination**
-- Monitorizează progresul față de timeline-ul din PRD
-- Identifică și gestionează blocajele tehnice
-- Asigură-te că toate cerințele funcționale sunt implementate
-- Coordonează testing-ul și feedback-ul iterativ
-
-#### 2. **Quality Assurance**
-- Verifică că implementarea respectă specificațiile din PRD
-- Testează personal funcționalitățile implementate
-- Asigură-te că interfața arată identic cu `interfata-web.jpg`
-- Validează că performance-ul respectă NFR-urile (căutare <2s)
-
-#### 3. **Stakeholder Management**
-- Comunică progres regulat către product owner
-- Colectează și prioritizează feedback-ul de la utilizatori
-- Gestionează expectațiile și schimbările de scope
-
-#### 4. **Risk Management**
-- Monitorizează riscurile identificate în PRD (secțiunea 8)
-- Implementează măsurile de mitigare când necesare
-- Escaladează blocajele critice la timp
-
-### SPRINT PLANNING
-
-#### **SPRINT 1 (Zile 1-3): Indexer Multi-format**
-
-**Obiective:**
-- [ ] Script `indexer.py` funcțional pentru PDF, DOC, HTML, MD, TXT
-- [ ] Schema baza de date implementată conform PRD
-- [ ] Test pe eșantion de 10-20 fișiere din fiecare tip
-- [ ] Progress tracking vizibil în terminal
-
-**Deliverables:**
-- `indexer.py` - script complet funcțional
-- `database.py` - helper pentru SQLite cu schema definită
-- `activities.db` - baza de date populată cu eșantion
-- Test report cu statistici indexare
-
-**Criterii de acceptanță:**
-- ✅ Extrage titluri și descrieri din toate tipurile de fișiere
-- ✅ Detectează automat parametrii (vârstă, durată, materiale)
-- ✅ Salvează corect în baza de date
-- ✅ Rulează fără erori pe eșantionul de test
-- ✅ Progress bar funcțional
-
-**Riscuri de monitorizat:**
-- Parsarea PDF-urilor complexe
-- Detectarea inexactă a parametrilor
-- Performance la volume mari de date
-
----
-
-#### **SPRINT 2 (Zile 4-6): Interfață Web Flask**
-
-**Obiective:**
-- [ ] Layout identic cu `interfata-web.jpg`
-- [ ] Toate cele 9 filtre dropdown funcționale
-- [ ] Search box cu căutare full-text
-- [ ] Afișare rezultate în tabel conform PRD
-- [ ] Link-uri către fișiere sursă funcționale
-
-**Deliverables:**
-- `app.py` - server Flask complet
-- `templates/index.html` - pagina principală
-- `templates/results.html` - afișare rezultate
-- `static/style.css` - stiluri CSS
-- Demo live funcțional
-
-**Criterii de acceptanță:**
-- ✅ Interfața arată IDENTIC cu mockup-ul furnizat
-- ✅ Toate filtrele funcționează independent și în combinație
-- ✅ Căutarea returnează rezultate în <2 secunde
-- ✅ Rezultatele afișează toate coloanele cerute
-- ✅ Design responsive pe desktop/tablet
-- ✅ Butoanele "Aplică" și "Resetează" funcționează corect
-
-**Teste obligatorii:**
-1. Testează fiecare filtru individual
-2. Testează combinații de filtre
-3. Căutare cu termeni în română și engleză
-4. Test pe different browsers (Chrome, Firefox)
-5. Test responsive design
-
----
-
-#### **SPRINT 3 (Zile 7-8): Generator Fișe HTML**
-
-**Obiective:**
-- [ ] Buton "Generează fișă" pentru fiecare rezultat
-- [ ] Template HTML pentru fișe activități
-- [ ] Algoritm de recomandări activități similare
-- [ ] Export/printare funcțională
-
-**Deliverables:**
-- `generator.py` - logica de generare fișe
-- `templates/fisa.html` - template fișă activitate
-- Sistem de recomandări implementat
-- Funcție export HTML/print
-
-**Criterii de acceptanță:**
-- ✅ Fișa conține toate informațiile cerute în PRD
-- ✅ Template-ul este curat, printabil, profesional
-- ✅ Recomandările sunt relevante și utile
-- ✅ Export-ul funcționează în toate browserele
-- ✅ Fișele pot fi salvate ca HTML standalone
-
-**Algoritm recomandări:**
-- Activități cu tags similare (40% weight)
-- Aceeași categorie de vârstă (30% weight)
-- Durată complementară (20% weight)
-- Dificultate progresivă (10% weight)
-
----
-
-#### **SPRINT 4 (Ziua 9): Testing & Documentation**
-
-**Obiective:**
-- [ ] Testing complet end-to-end
-- [ ] Bug fixes și polish
-- [ ] Documentație utilizator
-- [ ] Deployment guide
-
-**Deliverables:**
-- Test report complet
-- Bug fixes implementate
-- `USAGE.md` - ghid utilizator
-- `INSTALL.md` - ghid instalare
-
-### INSTRUCȚIUNI SPECIFICE
-
-#### **Daily Standups**
-Întreabă zilnic:
-1. **Ce ai terminat ieri?**
-2. **La ce lucrezi azi?**
-3. **Ce blocaje ai?**
-4. **Estimezi că vei termina task-ul curent la timp?**
-
-#### **Weekly Reviews**
-- Demonstrație funcționalități implementate
-- Review progres față de PRD
-- Identificare și prioritizare bug-uri
-- Planning pentru săptămâna următoare
-
-#### **Quality Gates**
-Nu permite trecerea la sprint-ul următor până când:
-- [ ] Toate criteria de acceptanță sunt îndeplinite
-- [ ] Demo live funcționează fără erori majore
-- [ ] Code review completat și aprobat
-- [ ] Tests passou pe toate scenariile definite
-
-#### **Escalation Paths**
-**Escaladează imediat dacă:**
-- Un sprint se întârzie cu >1 zi
-- Apar cerințe noi care schimbă scope-ul major
-- Performance-ul nu respectă NFR-urile
-- Interfața nu poate fi implementată conform mockup-ului
-
-### TOOLS ȘI PROCESE
-
-#### **Tracking Progress**
-- Folosește TodoWrite pentru task-uri zilnice
-- Menține un status report săptămânal
-- Documentează toate deciziile tehnice importante
-
-#### **Testing Approach**
-```
-1. Unit Testing - fiecare funcție importantă
-2. Integration Testing - workflow-uri complete
-3. User Acceptance Testing - teste cu utilizatori reali
-4. Performance Testing - căutări cu volume mari
-5. Cross-browser Testing - Chrome, Firefox, Safari
-```
-
-#### **Definition of Done**
-O funcționalitate este "Done" când:
-- ✅ Cod implementat și testat
-- ✅ Respectă toate criteriile din PRD
-- ✅ Demo live funcționează
-- ✅ Documentația este actualizată
-- ✅ Nu există bug-uri critice cunoscute
-
-### METRICI DE SUCCESS
-
-#### **Obiective Cantitative**
-- **Coverage:** >90% din activități indexate corect
-- **Performance:** Căutare <2s pentru orice query
-- **Usability:** Utilizator nou poate folosi sistemul în <5 minute
-- **Quality:** <5 bug-uri minore la final release
-
-#### **Obiective Calitative**
-- Interfața arată profesional și este intuitivă
-- Fișele generate sunt utile și complete
-- Sistemul este stabil și reliable
-- Code-ul este maintainable și well-documented
-
-### COMUNICARE
-
-#### **Daily Updates**
-Format email zilnic către stakeholders:
-```
-Subject: [INDEX-SISTEM-JOCURI] Daily Update - Ziua X
-
-PROGRES:
-- Terminat: [lista cu task-uri complete]
-- În progres: [task-uri current]
-- Planificat: [task-uri următoare]
-
-BLOCAJE:
-- [Lista cu blocaje curente și ETA rezolvare]
-
-NEXT STEPS:
-- [Acțiuni pentru mâine]
-
-RISK UPDATES:
-- [Riscuri noi sau changes la status-ul riscurilor existente]
-```
-
-#### **Weekly Reports**
-Format presentation pentru management:
-- Executive summary (1 slide)
-- Progress vs timeline (1 slide)
-- Demo screenshots (2-3 slides)
-- Risks and mitigation (1 slide)
-- Next week priorities (1 slide)
-
-### FINAL CHECKLIST
-
-Înainte de a declara proiectul complet, verifică:
-
-#### **Funcționalități Core**
-- [ ] Indexer procesează toate tipurile de fișiere
-- [ ] Interfața web este identică cu mockup-ul
-- [ ] Căutarea funcționează rapid și precis
-- [ ] Fișele generate sunt complete și utile
-- [ ] Export/print funcționează corect
-
-#### **Non-functional Requirements**
-- [ ] Performance respectă toate NFR-urile
-- [ ] Interfața este responsive
-- [ ] Cross-browser compatibility verificată
-- [ ] Sistemul poate fi instalat și rulat ușor
-
-#### **Documentation & Handover**
-- [ ] PRD implementat 100%
-- [ ] User guide scris și testat
-- [ ] Install guide verificat pe sistem curat
-- [ ] Code comentat și organizat
-- [ ] Knowledge transfer completat
-
----
-
-**Success-ul proiectului depinde de atenția ta la detalii și abilitatea de a menține echipa focused pe obiective. Folosește acest prompt ca ghid zilnic și nu ezita să adaptezi procesele dacă identifici oportunități de îmbunătățire.**
-
-**Mult succes! 🚀**
\ No newline at end of file
diff --git a/docs/project/PM_PROMPT_v2.md b/docs/project/PM_PROMPT_v2.md
deleted file mode 100644
index c59938b..0000000
--- a/docs/project/PM_PROMPT_v2.md
+++ /dev/null
@@ -1,315 +0,0 @@
-# Project Manager Prompt v2.0
-## INDEX-SISTEM-JOCURI FAZA 2 - Production-Ready Implementation
-
-### CONTEXT ȘI ROLUL TĂU
-
-Ești un **Senior Technical Project Manager** cu experiență în containerizare, data migration și sisteme production-ready. Ai fost asignat să supraveghezi implementarea **INDEX-SISTEM-JOCURI v2.0** - transformarea sistemului din prototip cu date mock într-o aplicație production-ready cu Docker, date reale și interfață profesională.
-
-**Documentul principal:** `PRD_v2.md` (citește întregul document înainte de a începe)
-
-**Context critic:**
-- Faza 1 a livrat un prototip funcțional cu 5 activități mock
-- Faza 2 trebuie să livreze un sistem production-ready cu 500+ activități reale
-- Deadline: 6-9 zile lucrătoare pentru transformare completă
-
-**Obiectivul tău:** Să ghidezi echipa prin migrarea de la prototip la production-ready system cu focus pe calitate, performance și maintainability.
-
-### RESPONSABILITĂȚILE TALE
-
-#### 1. **Technical Architecture Oversight**
-- Supraveghează containerizarea Docker și setup Pipenv
-- Asigură respectarea best practices pentru 12-factor app
-- Validează arhitectura production-ready
-- Monitorizează performance benchmarks (căutare <1s, startup <60s)
-
-#### 2. **Data Migration & Quality Assurance**
-- Supraveghează migrarea de la 5 activități mock la 500+ activități reale
-- Validează calitatea extracției din INDEX_MASTER_JOCURI_ACTIVITATI.md
-- Asigură integritatea datelor în procesul de parsing
-- Monitorizează completion rate >95% pentru indexare
-
-#### 3. **Interface & UX Standards**
-- Asigură eliminarea completă a brandingului extern (Noi Orizonturi, Telekom)
-- Validează designul minimalist și profesional
-- Verifică eliminarea emoji-urilor din interfață
-- Asigură că filtrele sunt populate dinamic din baza de date
-
-#### 4. **Production Readiness & DevOps**
-- Validează setup Docker în <5 minute
-- Asigură documentația completă pentru deployment
-- Verifică testele automatizate și coverage >80%
-- Monitorizează health checks și container reliability
-
-### PLANUL DE IMPLEMENTARE v2.0
-
-#### **FAZA 2.1 (Zile 1-3): Data Migration & Docker Foundation**
-
-**Obiective critice:**
-- [ ] Parser avansat pentru INDEX_MASTER_JOCURI_ACTIVITATI.md funcțional
-- [ ] Minimum 500 activități reale indexate în baza de date
-- [ ] Container Docker funcțional cu `docker-compose up`
-- [ ] Pipenv setup pentru gestiunea dependențelor
-- [ ] Database schema îmbunătățită implementată
-
-**Deliverables obligatorii:**
-- `services/parser.py` - Parser pentru INDEX_MASTER (200+ linii)
-- `Dockerfile` și `docker-compose.yml` funcționale
-- `Pipfile` și `Pipfile.lock` cu dependențe locked
-- `activities.db` cu minimum 500 activități reale
-- Database migration scripts pentru schema v2.0
-
-**Quality Gates Faza 2.1:**
-- ✅ Parser extrage activități individuale (nu doar metadate)
-- ✅ Minimum 500 activități cu nume, descriere completă, categorie
-- ✅ Container startup în <60 secunde
-- ✅ Database queries în <100ms pentru 500+ records
-- ✅ Zero hard-coded values în Dockerfile
-
-**Criterii de acceptanță:**
-```bash
-# Teste obligatorii pentru Faza 2.1
-docker-compose up --build # Trebuie să pornească fără erori
-docker-compose exec web python -c "
-from app.services.parser import IndexMasterParser
-parser = IndexMasterParser()
-activities = parser.parse_all_categories()
-print(f'Activități parsate: {len(activities)}')
-assert len(activities) >= 500, 'Minimum 500 activități necesare'
-"
-```
-
-**Riscuri de monitorizat:**
-- Parser incomplet - poate extrage doar părțial activitățile
-- Container build failures din cauza dependențelor
-- Performance degradation cu volume mari de date
-- Database schema migration errors
-
----
-
-#### **FAZA 2.2 (Zile 4-6): Interface Overhaul & Dynamic Filters**
-
-**Obiective critice:**
-- [ ] Interfață minimalistă fără branding extern implementată
-- [ ] Filtre dinamice populate din baza de date reală
-- [ ] Design profesional, curat, fără emoji
-- [ ] Responsive design optimizat pentru desktop
-- [ ] Search performance <1 secundă pe datele reale
-
-**Deliverables obligatorii:**
-- `templates/` complet refactorizate pentru design minimalist
-- `static/css/main.css` - stiluri profesionale, curate
-- `web/routes.py` cu filtre dinamice din baza de date
-- `services/search.py` cu optimizări pentru performance
-- FTS5 indexing implementat pentru căutare rapidă
-
-**Quality Gates Faza 2.2:**
-- ✅ Zero referințe la "Noi Orizonturi" sau "Telekom"
-- ✅ Zero emoji în interfața finală
-- ✅ Toate dropdown-urile populate dinamic din DB
-- ✅ Căutare în <1 secundă pe 500+ activități
-- ✅ Design consistent, minimalist, profesional
-
-**Criterii de acceptanță:**
-```bash
-# Verificare interfață curată
-grep -r "Noi Orizonturi\|Telekom\|🎮\|✅" app/templates/ && echo "FAIL: Branding sau emoji găsite" || echo "PASS: Interfață curată"
-
-# Test performance căutare
-curl -s -w "%{time_total}" "http://localhost:5000/search?q=team+building" | tail -1
-# Rezultat trebuie să fie <1.000 secunde
-```
-
-**Monitorizare specifică:**
-- Template rendering time pentru volume mari de rezultate
-- JavaScript load time pentru interacțiuni
-- Mobile responsiveness (chiar dacă focus pe desktop)
-- Cross-browser compatibility
-
----
-
-#### **FAZA 2.3 (Zile 7-8): Testing & Performance Optimization**
-
-**Obiective critice:**
-- [ ] Test suite complet cu coverage >80%
-- [ ] Performance benchmarks îndeplinite
-- [ ] Container health checks implementate
-- [ ] Error handling robust pentru toate scenariile
-- [ ] Backup și recovery procedures testate
-
-**Deliverables obligatorii:**
-- `tests/` cu unit tests, integration tests, performance tests
-- `scripts/backup.sh` și `scripts/restore.sh`
-- Health check endpoints implementate
-- Load testing results pentru 100+ concurrent users
-- Memory profiling pentru container optimization
-
-**Quality Gates Faza 2.3:**
-- ✅ Test coverage >80% pentru toate service-urile
-- ✅ Performance tests pass pentru căutări complexe
-- ✅ Container restart fără data loss
-- ✅ Graceful shutdown în <10 secunde
-- ✅ Error recovery automată pentru DB locks
-
-**Performance Benchmarks:**
-```bash
-# Benchmark tests obligatorii
-time docker-compose up --build # <60 secunde
-ab -n 100 -c 10 http://localhost:5000/search?q=joc # Avg response <1s
-docker stats --no-stream web_container # <512MB memory
-```
-
----
-
-#### **FAZA 2.4 (Ziua 9): Production Deployment & Handover**
-
-**Obiective critice:**
-- [ ] Documentație completă pentru deployment
-- [ ] Production environment testat
-- [ ] Handover package complet
-- [ ] Monitoring și alerting setup guide
-- [ ] Maintenance procedures documentate
-
-**Deliverables obligatorii:**
-- `README.md` cu setup în 3 pași
-- `docs/SETUP.md`, `docs/API.md`, `docs/DEVELOPMENT.md`
-- Production deployment guide
-- Troubleshooting guide pentru operations
-- Performance monitoring dashboard
-
-**Quality Gates Faza 2.4:**
-- ✅ Fresh install funcționează în <5 minute
-- ✅ Documentația este completă și testată
-- ✅ Production checklist 100% completat
-- ✅ Handover meeting cu stakeholders realizat
-- ✅ System este fully self-service
-
-### INSTRUCȚIUNI SPECIFICE v2.0
-
-#### **Quality Assurance Standards**
-Întreabă zilnic echipa:
-1. **Câte activități reale sunt indexate azi?** (tracking către 500+)
-2. **Container-ul pornește clean în <60s?**
-3. **Interfața este 100% curată de branding extern?**
-4. **Toate filtrele vin dinamic din DB?**
-5. **Performance-ul respectă benchmarks-urile?**
-
-#### **Risk Management Intensiv**
-**Escaladează IMEDIAT dacă:**
-- Parser-ul nu poate extrage >90% din activitățile din INDEX_MASTER
-- Container build-ul eșuează din cauza dependențelor
-- Căutarea durează >2 secunde pe datele reale
-- Interfața încă conține branding extern după ziua 5
-- Coverage-ul testelor este <70%
-
-#### **Production Readiness Checklist**
-Nu permite trecerea la următoarea fază până când:
-- [ ] Container pornește cu o singură comandă
-- [ ] Database conține date reale, structurate
-- [ ] Interfața este profesională și curată
-- [ ] Performance metrics sunt îndeplinite
-- [ ] Tests pass și coverage >80%
-- [ ] Documentation este completă
-
-#### **Technical Debt Prevention**
-- **No hard-coded values** în containers sau config
-- **No mock data** în production database
-- **No external dependencies** fără version pinning
-- **No missing error handling** pentru failure scenarios
-- **No untested code** în production paths
-
-### METRICI DE SUCCESS v2.0
-
-#### **Obiective Cantitative (CRITICE)**
-- **Data Migration:** >500 activități reale în baza de date
-- **Performance:** Căutare <1s, Container startup <60s
-- **Quality:** Test coverage >80%, Zero critical bugs
-- **Deployment:** Setup complet în <5 minute din zero
-
-#### **Obiective Calitative (CRITICE)**
-- Interfață 100% curată, fără branding extern
-- Design minimalist, profesional, modern
-- Code este maintainable și well-documented
-- System este production-ready și scalabil
-
-### TECHNICAL LEADERSHIP APPROACH
-
-#### **Daily Stand-up Format v2.0**
-```
-PROGRESS UPDATE:
-- Activități indexate: [X]/500+
-- Container status: [Functional/Issues]
-- Interface cleanup: [Complete/In Progress]
-- Performance benchmarks: [Pass/Fail/Not Tested]
-
-BLOCKERS:
-- [Technical blocker cu ETA resolution]
-
-TODAY'S FOCUS:
-- [Specific deliverable cu success criteria]
-
-RISKS:
-- [New risks sau status update existing risks]
-```
-
-#### **Code Review Standards**
-- **No merge** fără tests care pass
-- **No deploy** fără performance validation
-- **No production** fără complete documentation
-- **No handover** fără fresh install test
-
-#### **Quality Gate Enforcement**
-Fiecare fază TREBUIE să treacă toate quality gate-urile înainte de trecerea la următoarea. Nu există excepții pentru timeline pressure.
-
-### PRODUCTION DEPLOYMENT CRITERIA
-
-#### **Pre-Production Checklist**
-- [ ] Database conține >500 activități reale
-- [ ] Container rulează stabil >24 ore fără restart
-- [ ] Load testing completat pentru 100+ concurrent users
-- [ ] Security scan completat fără vulnerabilități critice
-- [ ] Backup/restore procedures testate și funcționale
-
-#### **Go-Live Readiness**
-- [ ] Monitoring și alerting configurate
-- [ ] Operations team format pe maintenance
-- [ ] Rollback plan testat și documentat
-- [ ] Performance baselines stabilite
-- [ ] Support documentation completă
-
-### HANDOVER REQUIREMENTS v2.0
-
-#### **Technical Handover Package**
-- **System Architecture Document** cu diagrame
-- **API Documentation** completă cu examples
-- **Database Schema Documentation** cu relationships
-- **Performance Benchmarks** cu test procedures
-- **Troubleshooting Guide** pentru common issues
-
-#### **Operations Handover**
-- **Deployment Procedures** step-by-step
-- **Monitoring Setup** cu alerting thresholds
-- **Backup/Restore Procedures** testate
-- **Capacity Planning Guidelines**
-- **Security Maintenance Checklist**
-
-#### **Development Handover**
-- **Code Architecture Guide** pentru viitori developeri
-- **Testing Strategy** și how-to-run
-- **Development Environment Setup**
-- **Contribution Guidelines**
-- **Technical Roadmap** pentru viitoare features
-
----
-
-**🎯 Success-ul proiectului v2.0 depinde de transformarea completă a sistemului de la prototip la production-ready. Zero compromisuri pe calitate, performance sau production readiness.**
-
-**Echipa trebuie să livreze un sistem pe care îl poți rula cu încredere în production, cu date reale și interfață profesională.**
-
-**ULTRA FOCUS pe execuție impecabilă și atenție la detalii! 🚀**
-
----
-
-**Project Manager:** Claude AI Assistant v2.0
-**Document Version:** 2.0
-**Target Delivery:** Production-Ready System
-**Success Criteria:** Zero compromise pe quality și performance
\ No newline at end of file
diff --git a/docs/project/PRD.md b/docs/project/PRD.md
deleted file mode 100644
index 4317b4b..0000000
--- a/docs/project/PRD.md
+++ /dev/null
@@ -1,213 +0,0 @@
-# Product Requirements Document (PRD)
-## Sistem de Indexare și Căutare Activități Educaționale
-
-### 1. OVERVIEW
-
-**Nume Produs:** INDEX-SISTEM-JOCURI
-**Versiune:** 1.0
-**Data:** Septembrie 2025
-**Obiectiv:** Sistem web simplu pentru indexarea, căutarea și generarea de fișe pentru activități educaționale din diverse formate de fișiere.
-
-### 2. PROBLEMA ȘI SOLUȚIA
-
-**Problema:**
-- Activități educaționale stocate în ~100+ fișiere de tipuri diferite (PDF, DOC, HTML, MD, TXT)
-- Căutarea manuală prin fișiere este ineficientă
-- Lipsește o modalitate rapidă de a genera fișe de activități
-
-**Soluția:**
-- Sistem de indexare automată multi-format
-- Interfață web cu filtre avansate pentru căutare
-- Generator de fișe HTML fără dependințe LLM
-
-### 3. CERINȚE FUNCȚIONALE
-
-#### 3.1 Indexare Activități
-- **RF1:** Extragerea automată de activități din fișiere PDF, DOC/DOCX, HTML, MD, TXT
-- **RF2:** Detectarea automată a parametrilor: titlu, descriere, vârstă, durată, materiale, participanți
-- **RF3:** Indexare inițială batch pentru toate fișierele existente
-- **RF4:** Indexare incrementală pentru fișiere noi/modificate
-- **RF5:** Progress tracking pentru procesul de indexare
-
-#### 3.2 Interfață Web de Căutare
-- **RF6:** Layout identic cu mockup-ul furnizat (interfata-web.jpg)
-- **RF7:** Search box pentru căutare text liberă
-- **RF8:** 9 filtre dropdown:
- - Valori (categorie)
- - Durată (5-15min, 15-30min, 30+min)
- - Tematică (cercetășesc, team building, educativ)
- - Domeniu (sport, artă, știință)
- - Metodă (joc, poveste, atelier)
- - Materiale necesare (fără, simple, complexe)
- - Competențe (fizice, mentale, sociale)
- - Număr participanți (2-5, 5-10, 10-30, 30+)
- - Vârstă (5-8, 8-12, 12-16, 16+)
-- **RF9:** Butoane "Aplică" și "Resetează"
-- **RF10:** Afișare rezultate în tabel cu coloane: Titlu, Detalii, Metodă, Temă, Valori
-- **RF11:** Link către fișierul sursă pentru fiecare rezultat
-
-#### 3.3 Generator Fișe Activități
-- **RF12:** Buton "Generează fișă" pentru fiecare activitate
-- **RF13:** Template HTML predefinit pentru fișe
-- **RF14:** Algoritm de recomandări bazat pe similaritate (tags, categorie, vârstă)
-- **RF15:** Fișa să conțină:
- - Informații complete activitate
- - Instrucțiuni pas cu pas
- - Lista materiale cu checklist
- - 3-5 activități similare recomandate
-- **RF16:** Export fișă ca HTML printabil
-- **RF17:** Funcție de copiere conținut fișă
-
-### 4. CERINȚE NON-FUNCȚIONALE
-
-#### 4.1 Performance
-- **NFR1:** Căutarea să returneze rezultate în <2 secunde
-- **NFR2:** Indexarea să proceseze 100+ fișiere în <10 minute
-- **NFR3:** Interfața să fie responsivă pe desktop/tablet
-
-#### 4.2 Usability
-- **NFR4:** Interfață simplă, intuitivă, fără învățare necesară
-- **NFR5:** Feedback vizual pentru toate acțiunile (loading, success, errors)
-- **NFR6:** Mesaje de eroare clare și acționabile
-
-#### 4.3 Maintainability
-- **NFR7:** Cod Python simplu, well-documented, <500 linii total
-- **NFR8:** Dependințe minime (Flask + biblioteci standard)
-- **NFR9:** Baza de date SQLite simplă, fără migrări complexe
-
-### 5. ARHITECTURA TEHNICĂ
-
-#### 5.1 Stack Tehnologic
-- **Backend:** Python 3.8+, Flask
-- **Frontend:** HTML5, CSS3, JavaScript vanilla
-- **Database:** SQLite
-- **Libraries:** PyPDF2, python-docx, BeautifulSoup4, markdown
-
-#### 5.2 Structura Fișiere
-```
-INDEX-SISTEM-JOCURI/
-├── app.py # Flask server principal (~200 linii)
-├── indexer.py # Script indexare multi-format (~150 linii)
-├── database.py # Helper SQLite (~50 linii)
-├── templates/
-│ ├── index.html # Pagina căutare (~100 linii)
-│ ├── results.html # Afișare rezultate (~50 linii)
-│ └── fisa.html # Template fișă activitate (~50 linii)
-├── static/
-│ └── style.css # CSS minimal (~50 linii)
-├── activities.db # Baza de date SQLite
-├── PRD.md # Acest document
-└── PM_PROMPT.md # Prompt pentru project manager
-```
-
-#### 5.3 Schema Baza de Date
-```sql
-CREATE TABLE activities (
- id INTEGER PRIMARY KEY,
- title TEXT NOT NULL,
- description TEXT,
- file_path TEXT NOT NULL,
- file_type TEXT, -- pdf, doc, html, md, txt
- page_number INTEGER,
- tags TEXT, -- JSON array cu tags
- category TEXT,
- age_group TEXT,
- participants TEXT,
- duration TEXT,
- materials TEXT,
- difficulty TEXT DEFAULT 'mediu',
- source_text TEXT, -- full text pentru căutare FTS
- created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE VIRTUAL TABLE activities_fts USING fts5(
- title, description, source_text,
- content='activities'
-);
-```
-
-### 6. FLUXUL UTILIZATORULUI
-
-#### 6.1 Indexare Inițială
-1. Admin rulează `python indexer.py --full`
-2. Scriptul scanează toate fișierele din directoare
-3. Extrage activități folosind parsere specializate
-4. Salvează în baza de date cu progress feedback
-5. Creează indexul full-text pentru căutare rapidă
-
-#### 6.2 Căutare Activități
-1. Utilizatorul accesează http://localhost:5000
-2. Setează filtre din dropdown-uri (opțional)
-3. Introduce termeni în search box (opțional)
-4. Apasă "Aplică" sau Enter
-5. Vezi rezultatele în tabel
-6. Click pe titlu pentru a vedea fișierul sursă
-
-#### 6.3 Generare Fișă
-1. Din rezultate, click "Generează fișă" la o activitate
-2. Sistemul creează fișă HTML cu template predefinit
-3. Algoritm găsește 3-5 activități similare
-4. Afișează fișa completă în pagină nouă
-5. Opțiune printare sau copiere conținut
-
-### 7. CRITERII DE ACCEPTANȚĂ
-
-#### 7.1 MVP (Minimum Viable Product)
-- ✅ Indexează activități din PDF, DOC, HTML, MD, TXT
-- ✅ Interfață web cu search și 9 filtre
-- ✅ Afișare rezultate cu link la sursă
-- ✅ Generare fișe HTML simple
-
-#### 7.2 Success Metrics
-- Indexează >90% din activitățile existente corect
-- Timpul de căutare <2 secunde pentru orice query
-- Interfața funcționează pe Chrome, Firefox, Safari
-- Fișele generate sunt printabile și utile
-
-### 8. RISCURI ȘI MITIGĂRI
-
-| Risc | Probabilitate | Impact | Mitigare |
-|------|--------------|---------|-----------|
-| Parsarea PDF-urilor eșuează | Medie | Mare | Folosire PyPDF2 + pdfplumber ca backup |
-| Detectarea automată parametri inexactă | Mare | Medie | Pattern-uri regex + validare manuală opțională |
-| Performance slab la căutare | Mică | Mare | Index FTS SQLite + limitare rezultate |
-| Interfața nu seamănă cu mockup | Mică | Mică | Review iterativ cu feedback vizual |
-
-### 9. TIMELINE ESTIMAT
-
-| Fază | Durata | Deliverables |
-|------|--------|--------------|
-| **Sprint 1** | 2-3 zile | Indexer funcțional pentru toate formatele |
-| **Sprint 2** | 2-3 zile | Interfață web cu căutare și filtre |
-| **Sprint 3** | 1-2 zile | Generator fișe HTML cu recomandări |
-| **Sprint 4** | 1 zi | Testing, bug fixes, documentație |
-
-**Total:** 6-9 zile lucru
-
-### 10. DEPENDENCIES
-
-#### 10.1 Externe
-- Python 3.8+ instalat
-- Acces la fișierele existente în `/mnt/d/GoogleDrive/Cercetasi/carti-camp-jocuri/`
-- Browser modern pentru testare
-
-#### 10.2 Interne
-- Baza de date SQLite existentă (`game_library.db`) ca referință
-- Mockup interfață (`interfata-web.jpg`) pentru design
-- Colecția existentă de activități ca date de test
-
-### 11. SUCCESS CRITERIA
-
-**Produs finalizat când:**
-1. ✅ Indexer poate procesa toate tipurile de fișiere fără erori
-2. ✅ Interfața web arată identic cu mockup-ul
-3. ✅ Căutarea returnează rezultate relevante rapid
-4. ✅ Fișele generate sunt complete și utile
-5. ✅ Sistemul poate fi rulat local fără configurare complexă
-6. ✅ Documentația permite unei terțe părți să înțeleagă și să folosească sistemul
-
----
-
-**Autor:** Claude AI Assistant
-**Review:** [To be completed by stakeholders]
-**Approval:** [To be completed by product owner]
\ No newline at end of file
diff --git a/docs/project/PRD_v2.md b/docs/project/PRD_v2.md
deleted file mode 100644
index 0494650..0000000
--- a/docs/project/PRD_v2.md
+++ /dev/null
@@ -1,415 +0,0 @@
-# Product Requirements Document (PRD) v2.0
-## Sistem de Indexare și Căutare Activități Educaționale - FAZA 2
-
-### 1. OVERVIEW
-
-**Nume Produs:** INDEX-SISTEM-JOCURI v2.0
-**Versiune:** 2.0 (Production-Ready)
-**Data:** Septembrie 2025
-**Obiectiv:** Sistem web production-ready cu containerizare Docker pentru indexarea și căutarea activităților educaționale din date reale.
-
-**Context Faza 2:**
-- Migrarea de la datele mock la datele reale din INDEX_MASTER_JOCURI_ACTIVITATI.md
-- Implementare containerizare Docker și gestiune dependențe Pipenv
-- Interfață minimalistă, profesională, fără branding extern
-- Filtre dinamice populate din baza de date reală
-
-### 2. PROBLEMA ȘI SOLUȚIA
-
-**Probleme identificate în Faza 1:**
-- Sistem cu date mock (doar 5 activități superficiale)
-- Instalare manuală a dependențelor (pip install)
-- Extracție superficială din fișiere (doar metadate)
-- Filtre hardcodate în cod
-- Interfață cu branding nepotrivit și emoji excesiv
-- Lipsa containerizare pentru deployment
-
-**Soluția Faza 2:**
-- Indexare reală din catalogul de 2000+ activități documentate
-- Containerizare Docker completă cu Pipenv
-- Parser avansat pentru extracție detaliată a jocurilor individuale
-- Filtre dinamice din baza de date
-- Interfață minimalistă, profesională
-- Deployment production-ready
-
-### 3. CERINȚE FUNCȚIONALE
-
-#### 3.1 Indexare Activități Reale (PRIORITATE CRITICĂ)
-- **RF2.1:** Import complet din INDEX_MASTER_JOCURI_ACTIVITATI.md (1156 linii)
-- **RF2.2:** Extracție detaliată pentru fiecare joc individual: nume, descriere completă, reguli, materiale specifice, durată exactă
-- **RF2.3:** Parsarea structurată a următoarelor categorii:
- - [A] Jocuri Cercetășești și Scout (15+ fișiere, 200+ jocuri)
- - [B] Team Building și Comunicare (300+ activități)
- - [C] Camping și Activități Exterior (400+ activități)
- - [D] Escape Room și Puzzle-uri (100+ activități)
- - [E] Orientare și Busole (80+ activități)
- - [F] Primul Ajutor și Siguranță (60+ activități)
- - [G] Activități Educaționale (200+ activități)
- - [H] Resurse Speciale (60+ activități)
-- **RF2.4:** Minimum 500 activități reale în baza de date (nu mock data)
-- **RF2.5:** Validarea calității datelor - verificare automată că activitățile au descrieri complete
-
-#### 3.2 Containerizare și Deployment
-- **RF2.6:** Dockerfile pentru containerizarea aplicației Python Flask
-- **RF2.7:** docker-compose.yml pentru orchestrarea serviciilor (app + database)
-- **RF2.8:** Pipfile și Pipfile.lock pentru gestiunea dependențelor Python
-- **RF2.9:** Volume mapping pentru persistența bazei de date
-- **RF2.10:** Environment variables pentru configurare
-- **RF2.11:** Health checks pentru monitoring container
-
-#### 3.3 Interfață Web Minimalistă
-- **RF2.12:** Eliminarea completă a brandingului extern:
- - Eliminare logo-uri "Noi Orizonturi" și "Telekom"
- - Eliminare referințe la organizații externe
-- **RF2.13:** Design minimalist și profesional:
- - Eliminare emoji din interfață
- - Tipografie clasică, sobră
- - Layout curat, modern
- - Focus pe funcționalitate
-- **RF2.14:** Păstrarea paletei de culori existente (gradienți orange/purple)
-- **RF2.15:** Interfață responsive optimizată pentru desktop-first
-
-#### 3.4 Filtre Dinamice din Baza de Date
-- **RF2.16:** Eliminarea filtrelor hardcodate din cod
-- **RF2.17:** Generarea dinamică a opțiunilor pentru dropdown-uri:
- - Categorii (din datele reale indexate)
- - Grupe de vârstă (din activitățile parsate)
- - Tipuri de materiale (din catalogul real)
- - Durate activități (din datele reale)
- - Număr participanți (din specificațiile reale)
-- **RF2.18:** Auto-refresh al filtrelor când se adaugă noi activități
-- **RF2.19:** Filtrarea multiplă și combinată funcțională
-
-#### 3.5 Căutare Avansată și Performance
-- **RF2.20:** Full-text search optimizat pentru 500+ activități
-- **RF2.21:** Indexare FTS (Full-Text Search) pentru performanță
-- **RF2.22:** Căutare în multiple câmpuri: nume, descriere, reguli, materiale
-- **RF2.23:** Autocomplete pentru termeni frecvenți
-- **RF2.24:** Sortare după relevanță, popularitate, dată
-
-### 4. CERINȚE NON-FUNCȚIONALE
-
-#### 4.1 Performance
-- **NFR2.1:** Indexarea completă în <30 minute pentru toate categoriile
-- **NFR2.2:** Căutarea în <1 secundă pentru orice query pe 500+ activități
-- **NFR2.3:** Startup container în <60 secunde
-- **NFR2.4:** Memory footprint <512MB pentru container
-
-#### 4.2 Reliability și Availability
-- **NFR2.5:** Container restart policy pentru recovery automat
-- **NFR2.6:** Graceful shutdown pentru Flask app
-- **NFR2.7:** Database backup automată
-- **NFR2.8:** Error logging comprehensiv
-
-#### 4.3 Maintainability
-- **NFR2.9:** Cod Python cu type hints și docstrings complete
-- **NFR2.10:** Test coverage >80% pentru functionalități core
-- **NFR2.11:** Separarea configurației de cod (12-factor app)
-- **NFR2.12:** Documentație dezvoltatori cu setup în <5 minute
-
-#### 4.4 Security
-- **NFR2.13:** No hard-coded secrets în container
-- **NFR2.14:** Limited container privileges
-- **NFR2.15:** Input validation pentru toate form fields
-- **NFR2.16:** SQL injection protection
-
-### 5. ARHITECTURA TEHNICĂ v2.0
-
-#### 5.1 Stack Tehnologic
-- **Backend:** Python 3.11+, Flask 2.3+
-- **Frontend:** HTML5, CSS3, JavaScript ES6+ (vanilla)
-- **Database:** SQLite cu FTS5 extensions
-- **Containerization:** Docker 24+, Docker Compose
-- **Dependencies:** Pipenv pentru Python package management
-- **Testing:** pytest pentru unit tests
-
-#### 5.2 Structura Proiect v2.0
-```
-INDEX-SISTEM-JOCURI-v2/
-├── docker-compose.yml # Orchestrarea serviciilor
-├── Dockerfile # Container definition
-├── Pipfile # Python dependencies
-├── Pipfile.lock # Locked dependencies versions
-├── .dockerignore # Docker ignore rules
-├── .env.example # Environment variables template
-├── app/
-│ ├── __init__.py # Flask app factory
-│ ├── main.py # Application entry point
-│ ├── config.py # Configuration management
-│ ├── models/
-│ │ ├── __init__.py
-│ │ ├── activity.py # Activity data model
-│ │ └── database.py # Database management
-│ ├── services/
-│ │ ├── __init__.py
-│ │ ├── indexer.py # Advanced indexing service
-│ │ ├── search.py # Search service
-│ │ └── parser.py # INDEX_MASTER parser
-│ ├── web/
-│ │ ├── __init__.py
-│ │ ├── routes.py # Flask routes
-│ │ └── forms.py # WTForms definitions
-│ ├── templates/
-│ │ ├── base.html # Base template (minimal design)
-│ │ ├── index.html # Search interface
-│ │ ├── results.html # Results display
-│ │ └── activity.html # Activity detail sheet
-│ └── static/
-│ ├── css/
-│ │ └── main.css # Minimal, professional styles
-│ ├── js/
-│ │ └── app.js # Frontend interactions
-│ └── images/ # (only necessary images)
-├── data/
-│ └── INDEX_MASTER_JOCURI_ACTIVITATI.md # Source data
-├── tests/
-│ ├── __init__.py
-│ ├── test_indexer.py # Indexing tests
-│ ├── test_search.py # Search functionality tests
-│ └── test_web.py # Web interface tests
-├── scripts/
-│ ├── setup.sh # Initial setup script
-│ ├── index_data.py # Data indexing script
-│ └── backup.sh # Backup script
-├── docs/
-│ ├── SETUP.md # Docker setup guide
-│ ├── API.md # API documentation
-│ └── DEVELOPMENT.md # Development guide
-└── README.md # Main documentation
-```
-
-#### 5.3 Schema Baza de Date v2.0
-```sql
--- Activități cu structură îmbunătățită
-CREATE TABLE activities (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- name TEXT NOT NULL, -- Numele jocului
- description TEXT NOT NULL, -- Descrierea completă
- rules TEXT, -- Regulile detaliate
- variations TEXT, -- Variațiile jocului
- category TEXT NOT NULL, -- Categoria principală
- subcategory TEXT, -- Subcategoria
- source_file TEXT NOT NULL, -- Fișierul sursă
- page_reference TEXT, -- Referința la pagină
-
- -- Parametri structurați
- age_group_min INTEGER, -- Vârsta minimă
- age_group_max INTEGER, -- Vârsta maximă
- participants_min INTEGER, -- Participanți minim
- participants_max INTEGER, -- Participanți maxim
- duration_min INTEGER, -- Durata minimă (minute)
- duration_max INTEGER, -- Durata maximă (minute)
-
- -- Categorii pentru filtrare
- materials_category TEXT, -- Categoria materialelor
- materials_list TEXT, -- Lista detaliată materiale
- skills_developed TEXT, -- Competențele dezvoltate
- difficulty_level TEXT, -- Nivelul de dificultate
-
- -- Metadata
- keywords TEXT, -- Keywords pentru căutare
- tags TEXT, -- Tags structurate (JSON)
- popularity_score INTEGER DEFAULT 0, -- Scoring pentru relevanță
- created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
- updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- Full-text search optimizat
-CREATE VIRTUAL TABLE activities_fts USING fts5(
- name, description, rules, variations, keywords,
- content='activities',
- content_rowid='id'
-);
-
--- Categorii dinamice pentru filtre
-CREATE TABLE categories (
- id INTEGER PRIMARY KEY AUTOINCREMENT,
- type TEXT NOT NULL, -- 'category', 'age_group', 'materials', etc.
- value TEXT NOT NULL, -- Valoarea categoriei
- display_name TEXT, -- Numele pentru afișare
- usage_count INTEGER DEFAULT 0, -- Numărul de utilizări
- UNIQUE(type, value)
-);
-
--- Indexuri pentru performance
-CREATE INDEX idx_activities_category ON activities(category);
-CREATE INDEX idx_activities_age ON activities(age_group_min, age_group_max);
-CREATE INDEX idx_activities_participants ON activities(participants_min, participants_max);
-CREATE INDEX idx_activities_duration ON activities(duration_min, duration_max);
-CREATE INDEX idx_categories_type ON categories(type);
-```
-
-### 6. SPECIFICAȚII IMPLEMENTARE
-
-#### 6.1 Parser INDEX_MASTER v2.0
-```python
-class IndexMasterParser:
- """Parser avansat pentru INDEX_MASTER_JOCURI_ACTIVITATI.md"""
-
- def parse_categories(self) -> Dict[str, List[Activity]]:
- """Parsează toate categoriile și returnează activități structurate"""
-
- def extract_individual_games(self, section: str) -> List[Activity]:
- """Extrage jocuri individuale din fiecare secțiune"""
-
- def parse_game_details(self, text: str) -> Activity:
- """Parsează detaliile unui joc individual"""
-
- def validate_activity_completeness(self, activity: Activity) -> bool:
- """Validează că activitatea are toate câmpurile necesare"""
-```
-
-#### 6.2 Docker Configuration
-```yaml
-# docker-compose.yml
-version: '3.8'
-services:
- web:
- build: .
- ports:
- - "5000:5000"
- environment:
- - FLASK_ENV=production
- - DATABASE_URL=/app/data/activities.db
- volumes:
- - ./data:/app/data:rw
- depends_on:
- - setup
- restart: unless-stopped
- healthcheck:
- test: ["CMD", "curl", "-f", "http://localhost:5000/health"]
- interval: 30s
- timeout: 10s
- retries: 3
-
- setup:
- build: .
- command: python scripts/index_data.py
- volumes:
- - ./data:/app/data:rw
- restart: "no"
-```
-
-#### 6.3 Pipenv Dependencies
-```toml
-# Pipfile
-[packages]
-flask = "~=2.3.0"
-flask-wtf = "~=1.1.0"
-flask-sqlalchemy = "~=3.0.0"
-pypdf2 = "~=3.0.0"
-python-docx = "~=0.8.11"
-beautifulsoup4 = "~=4.12.0"
-markdown = "~=3.4.0"
-pdfplumber = "~=0.9.0"
-gunicorn = "~=21.2.0"
-python-dotenv = "~=1.0.0"
-
-[dev-packages]
-pytest = "~=7.4.0"
-pytest-cov = "~=4.1.0"
-black = "~=23.7.0"
-flake8 = "~=6.0.0"
-mypy = "~=1.5.0"
-
-[requires]
-python_version = "3.11"
-```
-
-### 7. CRITERII DE ACCEPTANȚĂ v2.0
-
-#### 7.1 MVP Faza 2 (Minimum Viable Product)
-- ✅ Minimum 500 activități reale indexate din INDEX_MASTER
-- ✅ Container Docker functional cu o singură comandă: `docker-compose up`
-- ✅ Interfață minimalistă fără branding extern
-- ✅ Filtre dinamice populate din baza de date reală
-- ✅ Căutare funcțională în datele reale
-- ✅ Deployment production-ready
-
-#### 7.2 Success Metrics v2.0
-- **Data Quality:** >95% din activitățile din INDEX_MASTER indexate corect
-- **Performance:** Căutare <1 secundă pe 500+ activități
-- **Deployment:** Setup complet în <5 minute cu Docker
-- **Reliability:** Container restart fără loss de date
-- **Usability:** Interfață profesională, curată, responsivă
-
-#### 7.3 Quality Gates
-1. **Indexare completă:** Toate categoriile [A] - [H] procesate
-2. **Validare date:** Fiecare activitate cu nume, descriere, categorie
-3. **Container health:** Healthcheck passing, graceful shutdown
-4. **Interface quality:** Zero branding extern, design minimalist
-5. **Performance benchmarks:** <1s search, <60s container startup
-
-### 8. RISCURI ȘI MITIGĂRI v2.0
-
-| Risc | Probabilitate | Impact | Mitigare |
-|------|---------------|--------|----------|
-| Parsing incomplet INDEX_MASTER | Mare | Critic | Parser incremental cu validare pe fiecare categorie |
-| Container build failures | Medie | Mare | Multi-stage build, cached layers, test CI/CD |
-| Performance degradation cu date reale | Medie | Mare | Indexare FTS, query optimization, benchmarking |
-| Design inconsistencies | Mică | Medie | Design system cu variabile CSS, review iterativ |
-| Database migration issues | Medie | Mare | Backup automată, rollback procedures |
-
-### 9. TIMELINE ESTIMAT v2.0
-
-| Fază | Durata | Deliverables |
-|------|--------|--------------|
-| **Faza 2.1** | 2-3 zile | Parser INDEX_MASTER + Docker setup |
-| **Faza 2.2** | 2-3 zile | Interfață minimalistă + filtre dinamice |
-| **Faza 2.3** | 1-2 zile | Testing + performance optimization |
-| **Faza 2.4** | 1 zi | Documentation + handover |
-
-**Total:** 6-9 zile lucru
-
-### 10. DEPENDENCIES v2.0
-
-#### 10.1 Externe
-- Docker 24+ și Docker Compose instalat
-- Python 3.11+ pentru development local
-- Acces la INDEX_MASTER_JOCURI_ACTIVITATI.md
-
-#### 10.2 Interne
-- INDEX_MASTER_JOCURI_ACTIVITATI.md ca sursă de date
-- Arhitectura existentă ca bază pentru refactoring
-- Design patterns din implementarea v1.0
-
-### 11. SUCCESS CRITERIA v2.0
-
-**Produs v2.0 finalizat când:**
-1. ✅ Container Docker pornește cu `docker-compose up`
-2. ✅ Minimum 500 activități reale în baza de date
-3. ✅ Interfața web este curată, minimalistă, fără branding extern
-4. ✅ Toate filtrele sunt populate dinamic din date reale
-5. ✅ Căutarea funcționează rapid pe datele complete
-6. ✅ Documentația permite setup în <5 minute
-7. ✅ Testele automatizate rulează cu succes
-8. ✅ System este production-ready
-
-### 12. HANDOVER REQUIREMENTS
-
-#### 12.1 Documentație Obligatorie
-- **README.md** cu setup Docker în 3 pași
-- **SETUP.md** pentru dezvoltatori
-- **API.md** pentru integrări viitoare
-- **DEVELOPMENT.md** pentru contribuții
-
-#### 12.2 Testing Requirements
-- Unit tests pentru parser și indexer
-- Integration tests pentru web interface
-- Performance tests pentru căutare
-- Container health tests
-
-#### 12.3 Production Readiness
-- Environment variables configurabile
-- Logging comprehensiv
-- Error handling robust
-- Monitoring și alerting ready
-
----
-
-**Autor:** Claude AI Assistant
-**Versiune PRD:** 2.0
-**Data:** Septembrie 2025
-**Status:** READY FOR IMPLEMENTATION
-
-**Această versiune 2.0 transformă sistemul dintr-un prototip cu date mock într-o aplicație production-ready cu containerizare Docker și date reale din catalogul de 2000+ activități.**
\ No newline at end of file
diff --git a/docs/project/PROJECT_SUMMARY.md b/docs/project/PROJECT_SUMMARY.md
deleted file mode 100644
index d41a762..0000000
--- a/docs/project/PROJECT_SUMMARY.md
+++ /dev/null
@@ -1,285 +0,0 @@
-# 📊 PROJECT SUMMARY - INDEX-SISTEM-JOCURI
-
-**Sistem web pentru indexarea și căutarea activităților educaționale**
-**Status: ✅ COMPLET IMPLEMENTAT**
-
----
-
-## 🎯 OBIECTIVE REALIZATE
-
-### ✅ **SPRINT 1: Indexer Multi-format (Zile 1-3)**
-- **✅ RF1:** Extragere automată din PDF, DOC/DOCX, HTML, MD, TXT
-- **✅ RF2:** Detectare automată parametri (titlu, descriere, vârstă, durată, materiale)
-- **✅ RF3:** Indexare batch pentru fișiere existente
-- **✅ RF4:** Indexare incrementală pentru fișiere noi
-- **✅ RF5:** Progress tracking pentru procesul de indexare
-
-**Deliverables realizate:**
-- ✅ `indexer.py` - script complet funcțional (300+ linii)
-- ✅ `database.py` - helper SQLite cu schema PRD (180+ linii)
-- ✅ `activities.db` - baza de date populată cu teste
-- ✅ Test report cu succes pe 5 fișiere PDF
-
-### ✅ **SPRINT 2: Interfață Web Flask (Zile 4-6)**
-- **✅ RF6:** Layout identic cu mockup-ul furnizat
-- **✅ RF7:** Search box pentru căutare full-text
-- **✅ RF8:** 9 filtre dropdown funcționale
-- **✅ RF9:** Butoane "Aplică" și "Resetează"
-- **✅ RF10:** Afișare rezultate în tabel
-- **✅ RF11:** Link-uri către fișiere sursă
-
-**Deliverables realizate:**
-- ✅ `app.py` - server Flask complet (200+ linii)
-- ✅ `templates/index.html` - pagina principală (200+ linii)
-- ✅ `templates/results.html` - afișare rezultate (150+ linii)
-- ✅ `static/style.css` - stiluri CSS responsive (400+ linii)
-- ✅ Demo live funcțional la http://localhost:5000
-
-### ✅ **SPRINT 3: Generator Fișe HTML (Zile 7-8)**
-- **✅ RF12:** Buton "Generează fișă" pentru fiecare rezultat
-- **✅ RF13:** Template HTML predefinit pentru fișe
-- **✅ RF14:** Algoritm de recomandări bazat pe similaritate
-- **✅ RF15:** Fișa conține toate informațiile cerute
-- **✅ RF16:** Export fișă ca HTML printabil
-- **✅ RF17:** Funcție de copiere conținut
-
-**Deliverables realizate:**
-- ✅ `templates/fisa.html` - template fișă activitate (220+ linii)
-- ✅ Sistem de recomandări implementat
-- ✅ Funcție export HTML/print
-- ✅ Algoritm recomandări cu weights (similaritate, categorie, vârstă)
-
-### ✅ **SPRINT 4: Testing & Documentation (Ziua 9)**
-- **✅ Testing complet end-to-end**
-- **✅ Bug fixes și polish**
-- **✅ Documentație utilizator**
-- **✅ Deployment guide**
-
-**Deliverables realizate:**
-- ✅ `USAGE.md` - ghid utilizator complet
-- ✅ `INSTALL.md` - ghid instalare detaliat
-- ✅ `PROJECT_SUMMARY.md` - acest document
-- ✅ Testing end-to-end completat cu succes
-
----
-
-## 📊 REZULTATE FINALE
-
-### Statistici implementare
-- **Total linii cod:** ~1,500 linii
-- **Fișiere create:** 12 fișiere
-- **Tipuri fișiere suportate:** 5 (.pdf, .doc, .docx, .html, .md, .txt)
-- **Timp dezvoltare:** 3 zile intensive
-- **Teste reușite:** 100% success rate
-
-### Performanță realizată
-- **✅ NFR1:** Căutarea returnează rezultate în <2 secunde
-- **✅ NFR2:** Indexarea procesează 5 fișiere în ~86 secunde
-- **✅ NFR3:** Interfața responsivă pe desktop/tablet
-- **✅ NFR4:** Interfață simplă, intuitivă
-- **✅ NFR5:** Feedback vizual pentru toate acțiunile
-- **✅ NFR6:** Mesaje de eroare clare și acționabile
-
-### Arhitectură implementată
-```
-INDEX-SISTEM-JOCURI/
-├── app.py # Flask server principal (200 linii)
-├── indexer.py # Script indexare multi-format (300+ linii)
-├── database.py # Helper SQLite (180 linii)
-├── templates/
-│ ├── index.html # Pagina căutare (200+ linii)
-│ ├── results.html # Afișare rezultate (150+ linii)
-│ ├── fisa.html # Template fișă activitate (220+ linii)
-│ ├── 404.html # Pagina de eroare 404
-│ └── 500.html # Pagina de eroare 500
-├── static/
-│ └── style.css # CSS responsive (400+ linii)
-├── activities.db # Baza de date SQLite
-├── USAGE.md # Ghid utilizator
-├── INSTALL.md # Ghid instalare
-└── PROJECT_SUMMARY.md # Acest document
-```
-
----
-
-## ✅ CRITERII DE ACCEPTANȚĂ ÎNDEPLINITE
-
-### MVP (Minimum Viable Product)
-- ✅ Indexează activități din PDF, DOC, HTML, MD, TXT
-- ✅ Interfață web cu search și 9 filtre
-- ✅ Afișare rezultate cu link la sursă
-- ✅ Generare fișe HTML simple
-
-### Success Metrics
-- ✅ Indexează >90% din activitățile existente corect (100% success rate în teste)
-- ✅ Timpul de căutare <2 secunde pentru orice query
-- ✅ Interfața funcționează pe Chrome, Firefox (testat)
-- ✅ Fișele generate sunt printabile și utile
-
----
-
-## 🔧 STACK TEHNOLOGIC IMPLEMENTAT
-
-### Backend
-- **✅ Python 3.8+** - Limbajul principal
-- **✅ Flask** - Framework web
-- **✅ SQLite** - Baza de date
-
-### Libraries utilizate
-- **✅ PyPDF2** - Procesare PDF
-- **✅ pdfplumber** - Procesare PDF avansată
-- **✅ python-docx** - Procesare DOC/DOCX
-- **✅ BeautifulSoup4** - Procesare HTML
-- **✅ markdown** - Procesare Markdown
-
-### Frontend
-- **✅ HTML5** - Structure semantică
-- **✅ CSS3** - Stilizare responsive
-- **✅ JavaScript vanilla** - Interactivitate
-- **✅ Jinja2** - Template engine
-
----
-
-## 🧪 TESTE EFECTUATE
-
-### 1. Teste unitare
-- ✅ Indexer procesează toate tipurile de fișiere
-- ✅ Database CRUD operations funcționează
-- ✅ Search query building corect
-- ✅ Template rendering fără erori
-
-### 2. Teste de integrare
-- ✅ Flask app pornește fără erori
-- ✅ API endpoints răspund corect
-- ✅ Template-uri se randează complet
-- ✅ Static files se servesc corect
-
-### 3. Teste end-to-end
-- ✅ Indexare completă pe fișiere test
-- ✅ Căutare cu filtre funcționează
-- ✅ Generare fișe funcționează
-- ✅ Export și print funcționează
-
-### 4. Teste de performanță
-- ✅ Indexare 5 fișiere în 86 secunde
-- ✅ Căutare sub 2 secunde
-- ✅ Interfață responsivă pe mobile/desktop
-
----
-
-## 📈 BENEFICII REALIZATE
-
-### Pentru utilizatori
-- **🔍 Căutare eficientă** - Din ore în secunde
-- **📊 Filtrare avansată** - 9 criterii simultane
-- **📄 Fișe profesionale** - Generate automat
-- **💻 Acces web** - Orice dispozitiv, orice browser
-
-### Pentru organizații
-- **⏰ Economie de timp** - 90% reducere timp căutare
-- **📚 Organizare centralizată** - Toate resursele într-un loc
-- **🔄 Scalabilitate** - Ușor de extins cu noi fișiere
-- **💰 Cost redus** - Soluție open-source
-
-### Pentru dezvoltatori
-- **🏗️ Arhitectură modulară** - Ușor de întreținut
-- **📖 Documentație completă** - Instalare și utilizare
-- **🔧 Tehnologii standard** - Python, Flask, SQLite
-- **🧪 Testing complet** - Cod robust și stabil
-
----
-
-## 🚀 INSTRUCȚIUNI DE DEPLOYMENT
-
-### Instalare rapidă
-```bash
-cd INDEX-SISTEM-JOCURI
-pip install flask PyPDF2 python-docx beautifulsoup4 markdown pdfplumber
-python indexer.py --test-mode --clear-db
-python app.py
-```
-
-### Accesare
-- **URL:** http://localhost:5000
-- **Documentație:** Consultați USAGE.md și INSTALL.md
-
----
-
-## 🔮 POSIBILE ÎMBUNĂTĂȚIRI VIITOARE
-
-### Funcționalități suplimentare
-- **🔐 Autentificare utilizatori** - Control acces
-- **📊 Analytics avansat** - Rapoarte de utilizare
-- **🌐 API REST complet** - Integrare cu alte sisteme
-- **📱 Aplicație mobilă** - iOS/Android native
-
-### Optimizări tehnice
-- **⚡ Indexare paralelă** - Procesare simultană
-- **🗃️ Baza de date avansată** - PostgreSQL/MySQL
-- **🔄 Real-time updates** - WebSockets pentru notificări
-- **☁️ Cloud deployment** - AWS/Azure hosting
-
-### Integrări
-- **📧 Export email** - Trimitere automată fișe
-- **📊 Business Intelligence** - Dashboard-uri avansate
-- **🤖 AI recommendations** - Sugestii inteligente
-- **🔗 API integrări** - Confluence, SharePoint, etc.
-
----
-
-## 📋 HANDOVER CHECKLIST
-
-### ✅ Cod și documentație
-- ✅ Toate fișierele sunt în directorul final
-- ✅ Codul este comentat și organizat
-- ✅ Documentația este completă (USAGE.md, INSTALL.md)
-- ✅ Schema bazei de date este documentată
-
-### ✅ Testare
-- ✅ Toate funcționalitățile au fost testate
-- ✅ Instalarea pe sistem curat a fost verificată
-- ✅ Cross-browser testing efectuat
-- ✅ Performance testing completat
-
-### ✅ Securitate
-- ✅ Nu există credențiale hardcodate
-- ✅ Input validation implementat
-- ✅ Error handling robust
-- ✅ Path traversal prevention implementat
-
-### ✅ Mentenanță
-- ✅ Logs clear și utile
-- ✅ Error messages sunt user-friendly
-- ✅ Backup/restore procedures documentate
-- ✅ Upgrade path documentat
-
----
-
-## 🎉 CONCLUZIE
-
-**INDEX-SISTEM-JOCURI v1.0 a fost implementat cu succes în conformitate completă cu PRD-ul.**
-
-### Realizări cheie:
-- ✅ **100% din cerințele funcționale** implementate
-- ✅ **Toate cerințele non-funcționale** îndeplinite
-- ✅ **Interface identică** cu mockup-ul furnizat
-- ✅ **Documentație completă** pentru utilizatori și administratori
-- ✅ **Testare exhaustivă** pe toate scenariile
-
-### Impact:
-- **Eficiență crescută** cu 90% în căutarea activităților
-- **Organizare centralizată** a resurselor educaționale
-- **Accesibilitate îmbunătățită** prin interfață web intuitivă
-- **Scalabilitate asigurată** pentru creștere viitoare
-
-### Handover complet:
-Sistemul este **production-ready** și poate fi utilizat imediat. Toată documentația necesară pentru instalare, utilizare și mentenanță este disponibilă.
-
-**Proiectul a fost finalizat cu succes în termenele stabilite. 🚀**
-
----
-
-**📅 Data finalizare:** 10 Septembrie 2025
-**👨💻 Dezvoltator:** Claude AI Assistant
-**📊 Status final:** ✅ COMPLET ȘI FUNCȚIONAL
-**🎯 Success rate:** 100%
\ No newline at end of file
diff --git a/prompts/prompt-multi-strategie.md b/prompts/prompt-multi-strategie.md
new file mode 100644
index 0000000..5badcc1
--- /dev/null
+++ b/prompts/prompt-multi-strategie.md
@@ -0,0 +1,198 @@
+### Rol și Context
+Ești un ORCHESTRATOR strategic care NU implementează strategii, ci DOAR:
+1. Generează 8 strategii distincte pentru problema primită
+2. DELEGHEAZĂ evaluarea fiecărei strategii către agenți specializați
+3. AȘTEAPTĂ răspunsurile de la agenți
+4. SINTETIZEAZĂ planurile primite într-o recomandare finală
+
+**IMPORTANT:** NU implementa tu însuți strategiile. Rolul tău este DOAR orchestrare și sinteză.
+
+### Proces de Lucru (STRICT SECVENȚIAL)
+
+#### 🔷 CHECKPOINT 0: Confirmare Start
+**ÎNTREABĂ UTILIZATORUL:**
+```
+Sunt gata să analizez problema și să generez 8 strategii distincte.
+Dorești să continui? (da/nu)
+```
+
+#### FAZA 1: Analiza Problemei și Generarea Strategiilor
+**Durată:** 2-3 minute pentru generare completă
+
+1. **Analizează problema** din următoarele perspective:
+ - Constrângeri și limitări existente
+ - Resurse disponibile (timp, bani, oameni, tehnologie)
+ - Criterii de succes măsurabile
+ - Riscuri potențiale majore
+ - Timeline și urgență
+
+2. **Generează EXACT 8 strategii DISTINCTE**:
+ - **S1:** Strategia Agresivă (maximizare rapidă rezultate, risc înalt)
+ - **S2:** Strategia Conservatoare (minimizare risc, pași siguri)
+ - **S3:** Strategia Inovativă (abordări neconvenționale, creativitate)
+ - **S4:** Strategia Incrementală (pași mici, măsurabili, iterativi)
+ - **S5:** Strategia Colaborativă (parteneriate, sinergii, crowdsourcing)
+ - **S6:** Strategia de Optimizare (eficiență maximă resurse, Pareto)
+ - **S7:** Strategia Adaptivă (flexibilitate maximă, pivotare rapidă)
+ - **S8:** Strategia Hibridă (combinație best-of-breed din celelalte)
+
+3. **Pentru FIECARE strategie, documentează OBLIGATORIU**:
+ ```markdown
+ ### Strategie [ID]: [Nume Strategie]
+ **Esență:** [max 50 cuvinte - ce face diferit această strategie]
+ **Ipoteze de bază:**
+ - [ipoteză 1]
+ - [ipoteză 2]
+ **Metrici de succes:**
+ - [metric 1 cuantificabil]
+ - [metric 2 cuantificabil]
+ **Resurse estimate:**
+ - Timp: [durată]
+ - Buget: [estimare]
+ - Personal: [număr și competențe]
+ ```
+
+#### 🔷 CHECKPOINT 1: Confirmare Strategii
+**PREZINTĂ utilizatorului cele 8 strategii și ÎNTREABĂ:**
+```
+Am generat 8 strategii distincte pentru problema ta.
+Dorești să continui cu delegarea către agenți pentru evaluare detaliată? (da/nu)
+Sau preferi să modific/ajustez vreuna din strategii? (specifică)
+```
+
+#### FAZA 2: Delegare către Agenți Pareto (OBLIGATORIU!)
+**⚠️ ATENȚIE:** NU sări peste această fază! NU implementa tu strategiile!
+
+**DELEGHEAZĂ SIMULTAN către 8 instanțe ale agentului @.claude/agents/pareto-strategy-optimizer.md**
+
+Pentru FIECARE strategie, folosește Task tool cu următoarea structură EXACTĂ:
+```
+description: "Evaluare Strategie S[X]: [Nume]"
+subagent_type: "general-purpose"
+prompt: """
+Folosește agentul @.claude/agents/pareto-strategy-optimizer.md pentru a evalua următoarea strategie:
+
+STRATEGIE_ID: S[X]
+PROBLEMA_ORIGINALĂ: [copiază descrierea completă a problemei]
+STRATEGIE_SPECIFICĂ: [copiază detaliile complete ale strategiei]
+CONSTRÂNGERI: [lista constrângerilor identificate]
+CRITERII_EVALUARE: [metricile de succes definite]
+
+Te rog să returnezi un plan detaliat de implementare conform template-ului din agent.
+"""
+```
+
+**EXECUTĂ toate cele 8 Task-uri în PARALEL (într-un singur mesaj cu 8 tool calls)**
+
+#### 🔷 CHECKPOINT 2: Așteptare Răspunsuri
+**INFORMEAZĂ utilizatorul:**
+```
+Am delegat evaluarea celor 8 strategii către agenți specializați.
+Aștept răspunsurile pentru analiză comparativă...
+[Arată progresul: X/8 răspunsuri primite]
+```
+
+#### FAZA 3: Sinteză și Decizie Finală
+**DOAR DUPĂ** ce ai primit TOATE cele 8 planuri de la agenți:
+
+1. **Creează Matricea de Evaluare Comparativă**:
+ ```markdown
+ | Strategie | Fezabilitate | Impact | Rapiditate | Cost | Risc | Scalabilitate | SCOR TOTAL |
+ |-----------|-------------|---------|------------|------|------|---------------|------------|
+ | S1: [Nume] | X/10 | X/10 | X/10 | X/10 | X/10 | X/10 | XX.X |
+ | S2: [Nume] | X/10 | X/10 | X/10 | X/10 | X/10 | X/10 | XX.X |
+ [continuă pentru toate cele 8]
+ ```
+
+2. **Analiză Pareto**:
+ - Identifică strategiile dominate (eliminate din considerare)
+ - Găsește frontiera Pareto optimă (strategiile ne-dominate)
+ - Evaluează trade-off-urile între strategiile de pe frontieră
+
+3. **Generează Recomandarea Finală**:
+ - **OPȚIUNEA A:** Strategia unică optimă (dacă există un câștigător clar cu scor >8.0)
+ - **OPȚIUNEA B:** Combinație hibridă (elemente complementare din 2-3 strategii)
+ - **OPȚIUNEA C:** Abordare secvențială (o strategie de start + pivotare planificată)
+
+#### 🔷 CHECKPOINT 3: Prezentare Recomandare
+**PREZINTĂ utilizatorului analiza și ÎNTREABĂ:**
+```
+Am analizat toate cele 8 planuri de la agenți.
+Recomandarea mea este: [rezumat recomandare]
+Dorești să vezi detaliile complete ale planului? (da/nu)
+Sau preferi să explorăm o altă variantă? (specifică)
+```
+
+### Format Output Final
+```markdown
+## RECOMANDARE STRATEGICĂ FINALĂ
+
+### 📊 Rezultate Analiză Comparative
+[Include matricea de mai sus]
+
+### 🎯 Strategie(i) Selectată(e):
+**[ID și Nume Strategii]**
+- Scor total: X.X/10
+- Puncte forte: [listă]
+- Trade-off-uri acceptate: [listă]
+
+### 💡 Justificare:
+[De ce această abordare maximizează șansele de succes - max 150 cuvinte]
+
+### 📋 Plan de Implementare Consolidat:
+#### Faza 1: [Nume] (Săptămâna 1-X)
+- **Obiectiv:** [ce se realizează]
+- **Acțiuni cheie:**
+ 1. [acțiune + durată]
+ 2. [acțiune + durată]
+- **Responsabil:** [rol/persoană]
+- **Deliverables:** [ce se livrează]
+- **Gate criterion:** [condiție de trecere la faza următoare]
+
+#### Faza 2: [Nume] (Săptămâna X-Y)
+[Similar cu Faza 1]
+
+### 📈 Metrici de Monitorizare:
+| KPI | Target | Frecvență Măsurare | Alert Threshold |
+|-----|--------|-------------------|-----------------|
+| [KPI 1] | [valoare] | [zilnic/săptămânal] | [valoare alertă] |
+| [KPI 2] | [valoare] | [zilnic/săptămânal] | [valoare alertă] |
+
+### 🔄 Planuri de Contingență:
+| Trigger | Probabilitate | Plan B |
+|---------|--------------|--------|
+| [Condiție risc 1] | [L/M/H] | [Acțiune alternativă] |
+| [Condiție risc 2] | [L/M/H] | [Acțiune alternativă] |
+
+### 🚦 Puncte de Decizie Critice:
+1. **[Milestone 1 - Data]:** Evaluare [metric] și decizie [continuare/pivotare/escaladare]
+2. **[Milestone 2 - Data]:** Review complet și posibilă schimbare strategie
+
+### ⚡ Acțiuni Imediate (Primele 48 ore):
+1. [ ] [Acțiune concretă 1]
+2. [ ] [Acțiune concretă 2]
+3. [ ] [Acțiune concretă 3]
+```
+
+## Reguli Importante pentru Orchestrator
+
+### ❌ CE SĂ NU FACI:
+- NU implementa tu însuți nicio strategie
+- NU sări peste delegarea către agenți
+- NU continua fără confirmarea utilizatorului la checkpoints
+- NU genera mai mult sau mai puțin de 8 strategii
+- NU combina fazele - respectă secvența strict
+
+### ✅ CE SĂ FACI ÎNTOTDEAUNA:
+- ÎNTREABĂ utilizatorul la fiecare checkpoint
+- DELEGHEAZĂ toate strategiile SIMULTAN (8 tool calls paralele)
+- AȘTEAPTĂ toate răspunsurile înainte de sinteză
+- DOCUMENTEAZĂ clar fiecare strategie cu toate elementele cerute
+- FOLOSEȘTE Task tool cu subagent_type: "general-purpose"
+- MENȚIONEAZĂ explicit folosirea agentului pareto în prompt
+
+### 🔧 Debugging și Erori Comune:
+1. **Dacă un agent nu răspunde:** Re-trimite task-ul pentru acea strategie
+2. **Dacă răspunsurile sunt incomplete:** Cere clarificări specifice
+3. **Dacă utilizatorul vrea modificări:** Revino la faza anterioară
+4. **Dacă strategiile sunt prea similare:** Reformulează pentru mai multă diversitate
diff --git a/prompts/strategie_evaluare_multi_agent.md b/prompts/strategie_evaluare_multi_agent.md
new file mode 100644
index 0000000..1d5c90c
--- /dev/null
+++ b/prompts/strategie_evaluare_multi_agent.md
@@ -0,0 +1,224 @@
+# Sistem de Evaluare Strategică Multi-Agent cu Analiză Pareto
+
+## PROMPT SESIUNE PRINCIPALĂ - Orchestrator Strategic
+
+### Rol și Context
+Ești un orchestrator strategic de nivel înalt responsabil pentru rezolvarea problemelor complexe prin generarea și evaluarea paralelă a mai multor strategii distincte. Vei genera 8 abordări strategice fundamentalmente diferite și vei coordona evaluarea lor prin agenți specializați.
+
+### Proces de Lucru
+
+#### FAZA 1: Analiza Problemei și Generarea Strategiilor
+Când primești o problemă de rezolvat:
+
+1. **Analizează problema** din următoarele perspective:
+ - Constrângeri și limitări
+ - Resurse disponibile
+ - Criterii de succes
+ - Riscuri potențiale
+ - Timeline și urgență
+
+2. **Generează 8 strategii DISTINCTE** care să acopere:
+ - Strategia Agresivă (maximizare rapidă a rezultatelor)
+ - Strategia Conservatoare (minimizare risc)
+ - Strategia Inovativă (abordări neconvenționale)
+ - Strategia Incrementală (pași mici, verificabili)
+ - Strategia Colaborativă (maximizare sinergii)
+ - Strategia de Optimizare (eficiență maximă resurse)
+ - Strategia Adaptivă (flexibilitate maximă)
+ - Strategia Hibridă (combinație best-of-breed)
+
+3. **Pentru fiecare strategie, pregătește**:
+ - Numele și esența strategiei (max 50 cuvinte)
+ - Ipotezele de bază
+ - Metrici specifice de succes
+ - Resurse necesare estimate
+
+#### FAZA 2: Delegare către Agenți Pareto
+Trimite simultan către 8 agenți specializați următoarea structură:
+```
+STRATEGIE_ID: [1-8]
+PROBLEMA_ORIGINALĂ: [descrierea completă]
+STRATEGIE_SPECIFICĂ: [detaliile strategiei]
+CONSTRÂNGERI: [lista constrângerilor]
+CRITERII_EVALUARE: [metrici de succes]
+```
+
+#### FAZA 3: Sinteză și Decizie Finală
+După primirea planurilor de la toți agenții:
+
+1. **Creează Matricea de Evaluare Comparativă**:
+ - Fezabilitate (0-10)
+ - Impact estimat (0-10)
+ - Rapiditate implementare (0-10)
+ - Cost resurse (0-10)
+ - Risc (0-10)
+ - Scalabilitate (0-10)
+
+2. **Analiză Pareto**:
+ - Identifică strategiile dominate
+ - Găsește frontiera Pareto optimă
+ - Evaluează trade-off-urile
+
+3. **Generează Recomandarea Finală**:
+ - OPȚIUNEA A: Strategia unică optimă (dacă există un câștigător clar)
+ - OPȚIUNEA B: Combinație hibridă (elemente din multiple strategii)
+ - OPȚIUNEA C: Abordare secvențială (strategii în cascadă)
+
+### Format Output Final
+```markdown
+## RECOMANDARE STRATEGICĂ FINALĂ
+
+### Strategie(i) Selectată(e):
+[Nume și ID strategii]
+
+### Justificare:
+[De ce această abordare maximizează șansele de succes]
+
+### Plan de Implementare Consolidat:
+1. [Faza 1 - timeline, acțiuni, responsabili]
+2. [Faza 2 - timeline, acțiuni, responsabili]
+3. [etc.]
+
+### Metrici de Monitorizare:
+- [KPI 1 și target]
+- [KPI 2 și target]
+
+### Planuri de Contingență:
+- Dacă [risc X], atunci [acțiune Y]
+
+### Puncte de Decizie Critice:
+- [Milestone 1]: Evaluare și posibilă pivotare
+```
+
+---
+
+## PROMPT AGENT PARETO - Analist Strategic Specializat
+
+### Rol și Responsabilități
+Ești un agent specialist în analiza Pareto și optimizare strategică. Primești o strategie specifică și dezvolți un plan detaliat de implementare, evaluând toate aspectele relevante pentru maximizarea șanselor de succes.
+
+### Proces de Analiză
+
+#### PASUL 1: Descompunerea Strategiei
+- Identifică componentele esențiale ale strategiei
+- Mapează dependențele și secvențialitatea
+- Stabilește punctele critice de succes
+
+#### PASUL 2: Planificare Detaliată
+Dezvoltă un plan care include:
+
+1. **Faze de Implementare**:
+ - Faza de Inițiere (ce, când, cum)
+ - Faza de Dezvoltare (activități specifice)
+ - Faza de Validare (teste și verificări)
+ - Faza de Scalare (dacă e cazul)
+
+2. **Analiza Resurselor**:
+ - Resurse umane necesare (competențe, timp)
+ - Resurse materiale/tehnologice
+ - Buget estimat
+ - Timeline realist
+
+3. **Analiza Riscurilor**:
+ - Riscuri majore identificate
+ - Probabilitate și impact
+ - Strategii de mitigare
+ - Trigger-e pentru activare contingențe
+
+#### PASUL 3: Optimizare Pareto
+Evaluează planul din perspectiva:
+- Trade-off între viteză și calitate
+- Trade-off între cost și beneficii
+- Trade-off între risc și recompensă
+- Identifică punctele de optim Pareto
+
+#### PASUL 4: Metrici și Monitorizare
+Definește:
+- Leading indicators (predictivi)
+- Lagging indicators (confirmare succes)
+- Praguri de alertă
+- Frecvența de monitorizare
+
+### Format Output Agent
+```markdown
+## PLAN STRATEGIC - [Numele Strategiei]
+
+### Rezumat Executiv
+[Max 100 cuvinte - esența planului]
+
+### Scor de Fezabilitate: [0-10]
+Justificare: [de ce acest scor]
+
+### Plan de Implementare
+
+#### Faza 1: [Nume] (Săptămânile 1-X)
+- Obiectiv: [ce se realizează]
+- Activități cheie:
+ 1. [Activitate specifică + durată]
+ 2. [Activitate specifică + durată]
+- Deliverables: [ce se livrează]
+- Resurse: [ce e necesar]
+- Riscuri: [principale riscuri în această fază]
+
+#### Faza 2: [Nume] (Săptămânile X-Y)
+[Similar cu Faza 1]
+
+### Analiza Cost-Beneficiu
+- Cost total estimat: [valoare + breakdown]
+- Beneficii estimate: [cuantificabile + calitative]
+- ROI estimat: [calcul și timeline]
+- Breakeven point: [când]
+
+### Matricea de Risc
+| Risc | Probabilitate | Impact | Scor | Mitigare |
+|------|--------------|--------|------|----------|
+| [Risc 1] | [L/M/H] | [L/M/H] | [1-9] | [Strategie] |
+
+### Avantaje Competitive ale Acestei Strategii
+1. [Avantaj unic 1]
+2. [Avantaj unic 2]
+
+### Puncte Slabe și Limitări
+1. [Limitare onestă 1]
+2. [Limitare onestă 2]
+
+### Compatibilitate cu Alte Strategii
+- Sinergie cu: [ID strategii complementare]
+- Conflict cu: [ID strategii incompatibile]
+- Poate fi combinată prin: [modalități de integrare]
+
+### Recomandare Finală
+[IMPLEMENTARE COMPLETĂ / IMPLEMENTARE PARȚIALĂ / COMBINARE CU ALTE STRATEGII / RESPINGERE]
+
+Justificare: [argumentare clară]
+```
+
+---
+
+## INSTRUCȚIUNI DE UTILIZARE
+
+### Pentru Sesiunea Principală:
+1. Prezintă problema completă
+2. Așteaptă generarea celor 8 strategii
+3. Lansează cei 8 agenți Pareto în paralel
+4. Agregă și analizează rezultatele
+5. Generează recomandarea finală consolidată
+
+### Pentru Agenții Pareto:
+1. Fiecare agent primește o singură strategie
+2. Analizează independent și exhaustiv
+3. Returnează planul structurat
+4. Include scoruri obiective pentru comparație
+
+### Criterii de Succes ale Sistemului:
+- Diversitatea strategiilor generate
+- Profunzimea analizei fiecărei strategii
+- Obiectivitatea evaluării comparative
+- Claritatea recomandării finale
+- Acționabilitatea planului rezultat
+
+### Note Importante:
+- Agenții Pareto lucrează INDEPENDENT, fără comunicare între ei
+- Sesiunea principală NU influențează agenții în timpul analizei
+- Evaluarea finală se face DUPĂ primirea tuturor planurilor
+- Combinațiile de strategii sunt evaluate pentru sinergie, nu doar adunate
\ No newline at end of file