stage-1: project bootstrap

Structure, config loader, personality/tools/memory from clawd, venv, 22 tests passing. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-13 10:20:55 +00:00
commit f2973aa76f
374 changed files with 59557 additions and 0 deletions
--- a/memory/kb/tools/antfarm-flux-complet.md
+++ b/memory/kb/tools/antfarm-flux-complet.md
@@ -0,0 +1,385 @@
+# Antfarm - Flux Complet cu Discovery & PRD
+
+**Data:** 2026-02-10  
+**Inspirat din:** ralph skill /prd command
+
+---
+
+## Problema cu Fluxul Vechi
+
+❌ **Ce nu a funcționat:**
+- Am lansat direct `antfarm workflow run` cu prompt vag
+- Planner (Sonnet) a interpretat minimal → feature incomplet
+- Test files în dashboard/ → aglomerare
+- Fără întrebări UX → implementare basic fără customizare
+
+---
+
+## Fluxul NOU (80/20)
+
+### FAZA 1: Discovery cu Întrebări (Echo, Opus)
+
+**Când primesc request pentru feature nou:**
+
+1. **Detectez context** (proiect existent vs nou)
+   - Citesc ~/clawd/dashboard/ pentru stack actual
+   - Identific patterns existente (common.css, api.py, etc.)
+
+2. **Pun întrebări adaptive** (ca ralph /prd):
+
+**Pentru FEATURE în proiect existent (dashboard):**
+
+```
+Întrebarea 1: Ce funcționalitate nouă vrei?
+- Descrie în 2-3 propoziții
+
+Întrebarea 2: Ce tip de feature?
+- Funcționalitate nouă
+- Îmbunătățire UX
+- Integrare externă
+
+Întrebarea 3: Implică UI?
+- Da - componente noi (pagină separată)
+- Da - secțiune în index.html
+- Nu - doar backend
+
+Întrebarea 4: Modificări DB?
+- Da - fișier JSON nou
+- Da - câmpuri noi în JSON existent
+- Nu
+
+Întrebarea 5 (CRITICĂ pentru UX): Cum arată UI-ul?
+- Layout: listă simplă / cards / table / kanban
+- Features: create, edit, delete, filter, sort, export
+- Customizare: frecvență, categorii, culori, icoane
+- Mobile responsive: da/nu
+
+Întrebarea 6: Acceptance criteria?
+- Ce trebuie să funcționeze exact?
+- Cum testăm că e gata?
+
+Întrebarea 7: Structură fișiere?
+- Tests în dashboard/tests/ sau tests/
+- Assets separate? (imagini, icons)
+```
+
+---
+
+### FAZA 2: Generez PRD Complet (Echo, Opus)
+
+Bazat pe răspunsuri, creez:
+
+**`~/clawd/tasks/prd-FEATURE-NAME.md`**
+
+```markdown
+# PRD: [Feature Name]
+
+## 1. Context Tehnic
+- **Proiect:** Echo Dashboard
+- **Stack:** Python (api.py), HTML+Vanilla JS, common.css
+- **Storage:** JSON files (tasks.json, todos.json, etc.)
+- **Patterns existente:** 
+  - API endpoints în api.py (handle_X_get, handle_X_post)
+  - Frontend: fetch('/echo/api/X'), common.css pentru styling
+  - Mobile: swipe-nav.js pentru navigare touch
+
+## 2. Obiective
+### Obiectiv Principal
+[Din răspunsul utilizatorului]
+
+### Metrici Succes
+[Din acceptance criteria]
+
+## 3. User Stories (Ordonate Dependencies-First)
+
+### US-001: Schema și Storage
+**Ca** developer
+**Vreau** să definesc structura de date
+**Pentru că** backend și frontend depind de ea
+
+**Acceptance Criteria:**
+- [ ] Fișier FEATURE.json cu schema corectă
+- [ ] Funcții helper pentru streak/calculation logic
+- [ ] Documentație format data în cod
+
+### US-002: Backend API - GET
+**Ca** frontend
+**Vreau** să pot citi datele
+**Pentru că** trebuie să afișez lista
+
+**Acceptance Criteria:**
+- [ ] Endpoint GET /api/FEATURE în api.py
+- [ ] Returnează JSON cu toate intrările
+- [ ] Tests pentru GET în dashboard/tests/test_FEATURE_api.py
+
+### US-003: Backend API - POST Create
+...
+
+### US-004: Backend API - PUT Edit
+...
+
+### US-005: Backend API - DELETE
+...
+
+### US-006: Frontend - Structure
+**Ca** user
+**Vreau** o pagină dedicată pentru FEATURE
+**Pentru că** vreau acces rapid
+
+**Acceptance Criteria:**
+- [ ] FEATURE.html creat în dashboard/
+- [ ] Link în index.html navigation
+- [ ] Layout responsive (mobile + desktop)
+- [ ] Tests în dashboard/tests/test_FEATURE_ui.py
+
+### US-007: Frontend - Create Form
+...
+
+### US-008: Frontend - Edit Modal
+...
+
+### US-009: Frontend - Delete cu Confirmare
+...
+
+### US-010: Frontend - Customizare (frecvență, zile, categorii, etc.)
+...
+
+### US-011: Integration Tests
+...
+
+## 4. Structură Fișiere
+
+```
+~/clawd/dashboard/
+├── FEATURE.html              # UI principal
+├── FEATURE.json              # Data storage
+├── api.py                    # Backend (modificat)
+├── tests/                    # Tests separate (NU în root dashboard/)
+│   ├── test_FEATURE_api.py
+│   ├── test_FEATURE_ui.py
+│   └── test_FEATURE_integration.py
+└── index.html                # Link adăugat în nav
+```
+
+## 5. UX Detalii
+
+[Din răspunsul la întrebarea 5]
+
+**Layout:**
+- Cards cu shadow și hover effects (ca în common.css pattern)
+
+**Create/Edit:**
+- Modal pentru create (buton fix bottom-right)
+- Inline edit sau modal pentru modificare
+- Fields: nume, frecvență dropdown, zile săptămână checkboxes, etc.
+
+**Customizare:**
+- Frecvență: zilnic / săptămânal / lunar / custom (X zile)
+- Zile săptămână: checkboxes pentru weekly habits
+- Categorii: work, health, growth, etc.
+- Culori: picker pentru identificare vizuală
+- Icoane: librarie icons (lucide) pentru personalizare
+
+**Mobile:**
+- Swipe pentru delete/edit
+- Touch-friendly buttons (min 44px)
+
+## 6. Non-Goals
+
+❌ NU facem:
+- Sincronizare cloud / multi-device
+- Gamification advanced (badges, levels)
+- Social features (share, leaderboard)
+- Export/import (poate în viitor)
+
+## 7. Considerații Tehnice
+
+### Backend (api.py)
+- Pattern existent: `handle_X_get`, `handle_X_post`, etc.
+- Storage în JSON cu `lastUpdated` timestamp
+- Validare input (max lengths, format checks)
+
+### Frontend
+- common.css pentru styling consistent
+- Lucide icons pentru UI
+- Fetch API cu error handling
+- Toast notifications pentru success/error
+
+### Tests
+- **Locație:** `dashboard/tests/` (NU în root dashboard/)
+- **Coverage:** API endpoints + UI behaviors + integration
+- **Run:** pytest pentru Python, manual pentru UI (sau Playwright dacă disponibil)
+
+## 8. Acceptance Criteria Finale
+
+- [ ] Toate user stories implementate
+- [ ] Tests pass (pytest dashboard/tests/)
+- [ ] UI responsive (mobile + desktop)
+- [ ] No console errors
+- [ ] Git commits clean cu mesaje descriptive
+- [ ] PR creat pentru review
+```
+
+---
+
+### FAZA 3: Configurez Opus pentru Planner
+
+**Înainte de a lansa workflow-ul, configurez Opus pentru planner:**
+
+```bash
+# Găsesc job ID pentru planner
+cron action=list | grep "antfarm/feature-dev/planner"
+
+# Actualizez cu model Opus
+cron action=update jobId="<PLANNER_JOB_ID>" patch='{"payload": {"model": "opus"}}'
+```
+
+**Verificare:**
+```bash
+cron action=list | grep -A 5 "antfarm/feature-dev/planner"
+# Ar trebui să văd "model": "opus" în payload
+```
+
+---
+
+### FAZA 4: Lansez Workflow cu PRD ca Input
+
+**Task string pentru antfarm include PRD-ul complet:**
+
+```bash
+cd ~/clawd
+
+antfarm workflow run feature-dev "$(cat <<'EOF'
+FEATURE: Habit Tracker
+
+PRD LOCATION: tasks/prd-habit-tracker.md
+
+CONTEXT:
+- Proiect existent: Echo Dashboard (Python backend + HTML/JS frontend)
+- Storage: JSON files
+- Patterns: common.css, api.py endpoints, swipe-nav.js
+
+REQUIREMENTS (vezi PRD complet în tasks/ pentru detalii):
+
+1. Backend API (api.py):
+   - GET /api/habits - returnează toate habits
+   - POST /api/habits - creează habit nou cu validare
+   - PUT /api/habits/{id} - editează habit existent
+   - DELETE /api/habits/{id} - șterge habit
+   - Funcții: calculate_streak(completions, frequency)
+   - Storage: habits.json
+
+2. Frontend (habits.html):
+   - Layout: Cards cu grid responsive
+   - Create: Modal cu form (nume, frecvență, zile, categorie, culoare, icon)
+   - Edit: Modal sau inline edit
+   - Delete: Confirmare dialog
+   - Check-in: Click pentru bifaretoday
+   - Display: Streak counter, last check date, progress visualization
+
+3. Customizare:
+   - Frecvență: zilnic / săptămânal / lunar / custom (X zile)
+   - Zile săptămână: checkboxes pentru weekly habits (L, Ma, Mi, J, V, S, D)
+   - Categorii: work, health, growth, personal (cu culori)
+   - Icoane: lucide icons picker
+   - Culori: color picker pentru identificare vizuală
+
+4. Tests:
+   - Locație: dashboard/tests/ (NU în dashboard/ root!)
+   - Coverage: API, UI, integration
+   - Framework: pytest pentru Python
+
+5. Integration:
+   - Link în index.html navigation
+   - Toast notifications (success/error)
+   - Mobile responsive (swipe gestures)
+
+ACCEPTANCE CRITERIA (COMPLETE):
+- [ ] Pot crea habit cu toate detaliile (nume, frecvență custom, zile, categorie, culoare, icon)
+- [ ] Pot edita habit existent (toate câmpurile)
+- [ ] Pot șterge habit cu confirmare
+- [ ] Pot bifa habit pentru azi (once per day max)
+- [ ] Streak calculation corect (zilnic: consecutive days, săptămânal: consecutive weeks)
+- [ ] UI responsive (mobile + desktop)
+- [ ] Tests în dashboard/tests/ (NU în dashboard/)
+- [ ] No console errors
+- [ ] API paths corecte (/echo/api/habits)
+- [ ] Git commits clean
+
+STORY SIZING:
+- Fiecare story trebuie să fie atomică (1 context window)
+- Dependencies-first: schema → backend → frontend → integration
+- Include typecheck și tests în fiecare story
+
+NON-GOALS:
+- Cloud sync / multi-device
+- Advanced gamification
+- Social features
+- Export/import
+
+Vezi tasks/prd-habit-tracker.md pentru detalii complete UX și tehnice.
+EOF
+)"
+```
+
+---
+
+### FAZA 5: Monitor și Ajustări
+
+**Monitor progres:**
+```bash
+antfarm workflow status <run-id>
+antfarm logs 50
+```
+
+**Dacă planner-ul generează stories prea mari:**
+- Opresc run-ul
+- Editez PRD pentru a clari sizing
+- Relanșez cu PRD actualizat
+
+**Dacă developer-ul face greșeli (ex: test files în locul greșit):**
+- Verifier-ul ar trebui să prindă asta (acceptance criteria specifică locația)
+- Dacă nu, adaug în PRD mai explicit: "Tests MUST be in dashboard/tests/"
+
+---
+
+## Rezumat Flux pentru Echo
+
+**Când primesc "Vreau să construiesc X în dashboard":**
+
+1. ✅ **Discovery:** Pun întrebări adaptive (5-7 întrebări pentru feature în proiect existent)
+2. ✅ **PRD:** Generez tasks/prd-X.md cu user stories complete, UX detaliat, acceptance criteria specifice
+3. ✅ **Config Opus:** Actualizez planner job cu model="opus"
+4. ✅ **Launch:** antfarm workflow run cu PRD complet ca input
+5. ✅ **Monitor:** Verific progres, intervin doar dacă escalation
+
+**NU mai fac:**
+- ❌ Launch direct cu prompt vag
+- ❌ Presupun ce vrea utilizatorul fără întrebări
+- ❌ Las planner-ul (Sonnet) să interpreteze minimal
+- ❌ Accept test files în locuri greșite
+
+---
+
+## Checklist pentru Mine (Echo)
+
+**Înainte de ORICE antfarm workflow run:**
+
+- [ ] Am pus întrebări despre UX/features? (5-7 întrebări)
+- [ ] Am generat PRD complet în tasks/?
+- [ ] PRD-ul include acceptance criteria specifice?
+- [ ] PRD-ul specifică structură fișiere (ex: tests/ location)?
+- [ ] Am configurat Opus pentru planner?
+- [ ] Task string include link la PRD + detalii complete?
+- [ ] Marius a aprobat PRD-ul înainte de launch?
+
+**Dacă răspuns = NU la oricare → STOP și completez înainte de launch.**
+
+---
+
+**REGULA DE AUR:**
+
+> **80% din timpul unui proiect bun e în discovery și planning.**  
+> **Antfarm execută rapid doar dacă știe EXACT ce să construiască.**  
+> **Prompt vag = implementare minimalistă.**  
+> **PRD complet = feature complet.**
--- a/memory/kb/tools/cron-jobs.md
+++ b/memory/kb/tools/cron-jobs.md
@@ -0,0 +1,65 @@
+# Cron Jobs - Lista completă
+
+## Tabel joburi
+
+| Oră (UTC) | Oră (București) | Job | Canal | Ce face |
+|-----------|-----------------|-----|-------|---------|
+| 00:00 | 02:00 | content-discovery | - | Caută video (1-2) + articole/bloguri DE CALITATE (1-2) pe teme recente → memory/kb/ |
+| 05:00 | 07:00 | security-audit | #echo-work (doar alerte) | Audit securitate zilnic |
+| 01:00 | 03:00 | night-execute-late | #echo-work | Continuă execuția task-uri (run 2) |
+| 03:00 | 05:00 | archive-tasks | #echo-work | Arhivează task-uri vechi |
+| 06:00,17:00 | 08:00,19:00 | insights-extract | - | Extrage insights din memory/kb/ + actualizează tehnici-pauza.md |
+| 06:30 | 08:30 | morning-report | 📧 EMAIL | Raport dimineață |
+| 07:00 | 09:00 | morning-coaching | #echo-self + 📧 | Gând + provocare → memory/kb/coaching/ |
+| 07:30 | 09:30 | daily-self-audit | #echo-work (doar dacă găsește) | Review AGENTS/SOUL/USER/etc. → propune cleanup |
+| 07-17 | 09-19 | respiratie-orar | #echo-self | Pauze orare (skip dacă busy în calendar) |
+| 08:00,14:00 | 10:00,16:00 | anaf-monitor | #echo-work (doar alerte) | Verifică modificări ANAF (hash + diff) |
+| ~~15:00 mar,joi~~ | ~~17:00~~ | ~~project-checkin~~ | ~~#echo-work~~ | ~~Check-in Vending Master~~ (dezactivat - proiect inexistent/abandonat?) |
+| 18:00 | 20:00 | evening-report | 📧 EMAIL | Raport seară |
+| 19:00 | 21:00 | evening-coaching | #echo-self + 📧 | Reflecție seară → memory/kb/coaching/ |
+| 19:00 dum | 21:00 | weekly-planning | #echo-work | Planning săptămânal |
+| 21:00 | 23:00 | night-execute | #echo-work | Execută task-uri aprobate (run 1) |
+
+## Comenzi cron
+
+```bash
+cron action=list              # vezi toate joburile
+cron action=run jobId=X       # rulează manual
+cron action=update jobId=X    # modifică job
+```
+
+**Regulă:** Când modific joburi, actualizez și acest fișier + TOOLS.md!
+
+---
+
+## Răspuns la rapoarte email
+
+Marius răspunde cu:
+- `1 pentru X,Y` = execută ACUM propunerile X și Y
+- `2 pentru X,Y` = pune în tasks pentru noaptea asta
+- `3 pentru X,Y` = NU (skip, marchez [—])
+- Text liber = procesez și răspund
+
+La heartbeat verific inbox și procesez răspunsurile.
+
+---
+
+## Marcaje insights
+
+- `[ ]` = disponibil (rapoarte pot propune)
+- `[x]` = executat/implementat
+- `[—]` = skip/refuzat
+
+---
+
+## Reguli rapoarte (morning/evening)
+
+**⚠️ IMPORTANT (2026-02-11):**
+- ❌ NU propune programe/proiecte de implementat
+- ❌ NU propune exerciții practice pentru Marius
+- ✅ Doar insights, idei, observații
+- ✅ Marius va spune dacă e de făcut ceva
+
+## Flux rapoarte detaliat
+
+Vezi: [FLUX-JOBURI.md](../projects/FLUX-JOBURI.md)
--- a/memory/kb/tools/infrastructure.md
+++ b/memory/kb/tools/infrastructure.md
@@ -0,0 +1,151 @@
+# Infrastructură (Proxmox + Docker)
+
+## Servicii LLM/AI locale
+
+| LXC | Serviciu | IP:Port | Utilizare |
+|-----|----------|---------|-----------|
+| flowise (104) | **Ollama** | 10.0.20.161:11434 | Embeddings (all-minilm), LLM local |
+| flowise (104) | Flowise | 10.0.20.161:3000 | Flow builder |
+| dokploy (103) | Dokploy | 10.0.20.? | Deployment platform |
+
+**Modele Ollama disponibile:**
+- `all-minilm` - embeddings rapid (45MB) ← **folosit pentru memory_search**
+- `nomic-embed-text` - embeddings calitate (274MB)
+- `llama3.2:3b-instruct-q8_0` - LLM conversație (3.4GB)
+- `smollm:135m` - LLM mic rapid (91MB)
+
+---
+
+## Docker LXC (portainer)
+- **Host:** 10.0.20.170 (LXC 100 pe pvemini)
+- **User:** echo
+- **SSH:** `ssh echo@10.0.20.170`
+- **Portainer:** https://10.0.20.170:9443
+- **Docker:** v28.3.3 + Compose v2.39.1
+- **Resurse:** 1GB RAM, 20GB disk
+- **Proiecte:** `/opt/docker/`
+
+**Containere:**
+| Container | Port | Status | Descriere |
+|-----------|------|--------|-----------|
+| portainer | 9443 | ✅ | Management Docker |
+| nginx | 443, 8080 | ✅ | Reverse proxy |
+| roa-efactura | 5003 | ⚠️ | E-Factura ANAF |
+| pdf-qr-app | 5002 | ✅ | QR facturi |
+| flask_app | 5001 | ✅ | ROA Flask |
+| bt-web-automation | 5000, 8081 | ✅ | BT automation |
+| pulse | 7655 | ✅ | Monitoring Proxmox |
+| wol-manager | - | ✅ | Wake-on-LAN |
+| rustdesk (hbbs+hbbr) | 21115-21119 | ✅ | Remote desktop server |
+
+**Proiecte docker-compose:**
+- `/opt/docker/docker-compose.yaml` - stack principal (nginx, flask, efactura, qr)
+- `/opt/docker/wol/docker-compose.yml` - Wake-on-LAN
+- `/opt/docker/qrinvoice/docker-compose.yml` - QR Invoice app
+
+---
+
+## Proxmox Cluster (3 noduri)
+**User:** echo | **Acces:** doar din 10.0.20.173 (moltbot) | **Sudo:** qm, pct, pvesh
+
+### pveelite (10.0.20.202)
+- **Resurse:** 16GB RAM, 557GB disk
+- **SSH:** `ssh echo@10.0.20.202`
+- **Scripturi:** `/opt/scripts/`
+  - `oracle-backup-monitor-proxmox.sh` - zilnic 21:00, verifică backup Oracle
+  - `weekly-dr-test-proxmox.sh` - sâmbătă 06:00, test restore Oracle DR (VM 109)
+
+| VMID | Tip | Nume | Status |
+|------|-----|------|--------|
+| 109 | VM | oracle-dr-windows | stopped |
+| 101 | LXC | minecraft | stopped |
+| 110 | LXC | moltbot | running |
+| 301 | LXC | docker-portainer-template | stopped |
+
+### pvemini (10.0.20.201)
+- **Resurse:** 64GB RAM, 1.4TB disk
+- **SSH:** `ssh echo@10.0.20.201`
+- **Scripturi monitorizare:** `/opt/scripts/`
+  - `ha-monitor.sh` - status cluster HA
+  - `monitor-ssl-certificates.sh` - verifică SSL-uri zilnic
+  - `ups-shutdown-cluster.sh` - shutdown orchestrat la UPS critic
+  - `ups-monthly-test.sh` - test baterie UPS lunar (1 ale lunii)
+  - `ups-maintenance-shutdown.sh` - shutdown pentru mentenanță UPS
+  - `vm107-monitor.sh` - monitorizează VM 107
+- **Emailuri automate:** backup, cluster status, UPS, restore Oracle (sâmbătă)
+
+| Cron | Oră | Script/Job |
+|------|-----|------------|
+| Zilnic 00:00 | ha-monitor.sh | Status cluster HA |
+| 1 ale lunii 00:00 | ups-monthly-test.sh | Test baterie UPS |
+| Zilnic 02:00 | vzdump backup | VM 100,108,104,106,201,171 → storage "backup" |
+| Zilnic 22:00 | vzdump backup | LXC 101,110 (moltbot) → backup-pvemini-nfs |
+
+| VMID | Tip | Nume | Status |
+|------|-----|------|--------|
+| 201 | VM | roacentral | running |
+| 300 | VM | Win11-Template | stopped |
+| 302 | VM | oracle-test-302 | stopped |
+| 100 | LXC | portainer | running |
+| 103 | LXC | dokploy | running |
+| 104 | LXC | flowise | running |
+| 105 | LXC | test | stopped |
+| 106 | LXC | gitea | running |
+| 108 | LXC | central-oracle | running |
+| 171 | LXC | claude-agent | running |
+
+#### LXC 171 - claude-agent (Development Environment)
+- **IP:** 10.0.20.171
+- **Resurse:** 4 cores, 16GB RAM, 32GB disk
+- **OS:** Ubuntu (unprivileged, nesting enabled)
+- **Tailscale:** Da (acces remote)
+
+**Servicii:**
+- `code-server@claude` — VS Code în browser
+- `ttyd` — Web Terminal
+- `ssh` — acces direct
+
+**Claude Code:**
+- Instalat și configurat
+- Git configurat pentru `gitea.romfast.ro`
+- Mod interactiv: `claude` (în terminal)
+- Mod programatic: `claude -p "task description"` — pentru sarcini automatizate
+
+**Utilizare:**
+```bash
+# Acces SSH
+ssh user@10.0.20.171
+
+# Sau prin Proxmox
+ssh echo@10.0.20.201 "sudo pct exec 171 -- bash"
+
+# Claude Code - interactiv
+claude
+
+# Claude Code - task direct
+claude -p "descrie sarcina aici"
+```
+
+### pve1 (10.0.20.200)
+- **Resurse:** 32GB RAM, 1.3TB disk
+- **SSH:** `ssh echo@10.0.20.200`
+- **Status:** Gol (fără VM/LXC)
+
+---
+
+## Când acționez singur (fără să întreb)
+- **Monitorizare:** Verific status VM/LXC, resurse, health checks
+- **Diagnozare:** Citesc logs, verific configurări, identific probleme
+- **Raportare:** Informez despre probleme descoperite
+
+## Când întreb întâi
+- **Start/Stop VM sau LXC** - pot avea dependențe
+- **Modificări configurare** - network, storage, resurse
+- **Creare/Ștergere** - orice operație distructivă
+- **Acces în containere** (pct enter) pentru modificări
+
+## Când alertez imediat
+- Container/VM down neașteptat
+- Disk >90% utilizare
+- Serviciu unhealthy >1h
+- Erori repetate în logs
--- a/memory/kb/tools/ralph-workflow.md
+++ b/memory/kb/tools/ralph-workflow.md
@@ -0,0 +1,372 @@
+# Ralph Workflow - Sistem Complet
+
+**Versiune:** 2.0 (finală - funcțională)
+**Data:** 2026-02-09
+**Locație:** moltbot (LXC 110)
+
+## Prezentare Generală
+
+**Ralph** este un sistem pentru crearea și execuția autonomă a proiectelor software prin Claude Code, format din două componente:
+
+1. **Echo (Opus)** → Generează PRD și user stories în Python
+2. **Ralph loop (Sonnet)** → Implementează autonom cu Claude Code
+
+## Componente
+
+### 1. ralph_prd_generator.py
+
+**Locație:** `~/clawd/tools/ralph_prd_generator.py`
+
+**Funcție:** Generează PRD markdown și prd.json fără să apeleze Claude Code.
+
+**Features:**
+- Detectează tech stack automat (package.json, pyproject.toml, etc.)
+- Generează PRD conform template (obiective, stories, acceptance criteria)
+- Creează prd.json cu user stories prioritizate
+- Copiază templates (ralph.sh, prompt.md) în proiect
+- Configurează comenzi tech stack (start, build, lint, typecheck, test)
+
+**Usage:**
+```python
+from tools.ralph_prd_generator import create_prd_and_json
+from pathlib import Path
+
+prd_file, prd_json = create_prd_and_json(
+    project_name="task-tracker",  # kebab-case
+    description="""
+    Task tracker CLI în Python.
+    Features:
+    - Add/list/done tasks
+    - SQLite storage
+    - Export markdown
+    - Tests cu pytest
+    """,
+    workspace_dir=Path.home() / "workspace"
+)
+```
+
+**Output:**
+```
+~/workspace/PROJECT-NAME/
+├── tasks/
+│   └── prd-PROJECT-NAME.md        # PRD markdown
+└── scripts/
+    └── ralph/
+        ├── prd.json                # Stories JSON
+        ├── ralph.sh                # Loop autonom (din templates)
+        ├── prompt.md               # Instrucțiuni Claude Code
+        ├── progress.txt            # Learnings
+        ├── logs/                   # Logs execuție
+        ├── archive/                # Arhive rulări anterioare
+        └── screenshots/            # Screenshots UI (dacă aplicabil)
+```
+
+### 2. ralph_workflow.py
+
+**Locație:** `~/clawd/tools/ralph_workflow.py`
+
+**Funcție:** Wrapper simplu pentru workflow complet (PRD + lansare Ralph).
+
+**Features:**
+- Apelează ralph_prd_generator pentru PRD
+- Lansează ralph.sh în background
+- Monitorizare status proiect
+
+**Usage CLI:**
+```bash
+# Creează proiect complet (PRD + lansare Ralph)
+python3 tools/ralph_workflow.py create "project-name" "description"
+
+# Verifică status
+python3 tools/ralph_workflow.py status "project-name"
+```
+
+**Usage Python:**
+```python
+from tools.ralph_workflow import run_ralph, check_status
+from pathlib import Path
+
+# Lansează Ralph (după ce ai prd.json)
+run_ralph(
+    prd_json=Path.home() / "workspace" / "PROJECT" / "scripts" / "ralph" / "prd.json",
+    max_iterations=20,
+    background=True
+)
+
+# Verifică status
+status = check_status(Path.home() / "workspace" / "PROJECT")
+print(f"Complete: {len(status['complete'])}")
+print(f"Incomplete: {len(status['incomplete'])}")
+```
+
+### 3. ralph.sh
+
+**Locație:** Copiat automat în `PROJECT/scripts/ralph/ralph.sh`
+**Source:** `~/clawd/skills/ralph/templates/ralph.sh`
+
+**Funcție:** Loop autonom care apelează Claude Code pentru implementare.
+
+**Workflow:**
+1. Citește prd.json
+2. Selectează story cu priority minimă și passes=false
+3. Rulează `claude` pentru implementare (folosește Sonnet implicit)
+4. Quality checks: typecheck, lint, test
+5. Git commit dacă toate pass
+6. Marchează passes=true în prd.json
+7. Update progress.txt cu learnings
+8. Repetă până toate stories complete sau max iterations
+
+**Usage:**
+```bash
+cd ~/workspace/PROJECT
+./scripts/ralph/ralph.sh 20  # max 20 iterații
+```
+
+## Workflow Complet (pentru Echo)
+
+### Seara (20:00) - evening-report
+
+Echo propune 1-2 proiecte noi + 2-3 features pentru proiecte existente.
+Marius aprobă: "P pentru P1,P2" sau "F pentru F1,F3"
+
+### Noapte (23:00) - night-execute
+
+**Planning cu OPUS (Echo):**
+
+```python
+import sys
+sys.path.append('/home/moltbot/clawd')
+
+from tools.ralph_prd_generator import create_prd_and_json
+from tools.ralph_workflow import run_ralph
+from pathlib import Path
+import subprocess
+
+# Pentru fiecare proiect aprobat
+for project in approved_projects:
+    # Generează PRD și prd.json (cu Opus)
+    prd_file, prd_json = create_prd_and_json(
+        project_name=project['name'],
+        description=project['description'],
+        workspace_dir=Path.home() / "workspace"
+    )
+    
+    if not prd_file or not prd_json:
+        print(f"❌ Eroare la {project['name']}")
+        continue
+    
+    # Git init + commit
+    project_dir = prd_json.parent.parent.parent
+    subprocess.run(["git", "init"], cwd=project_dir)
+    subprocess.run(["git", "add", "."], cwd=project_dir)
+    subprocess.run(["git", "commit", "-m", "Initial commit with PRD"], cwd=project_dir)
+    subprocess.run(["git", "remote", "add", "origin", 
+                   f"https://gitea.romfast.ro/romfast/{project['name']}"], 
+                   cwd=project_dir)
+    subprocess.run(["git", "push", "-u", "origin", "main"], cwd=project_dir)
+    
+    # Lansează Ralph loop (cu Sonnet)
+    run_ralph(prd_json, max_iterations=20, background=True)
+    
+    # Marchează [x] în approved-tasks.md
+```
+
+**Implementare cu SONNET (Ralph loop automat):**
+- ralph.sh rulează autonom în background
+- Apelează Claude Code (Sonnet) pentru fiecare story
+- Quality checks + git commits automate
+- Toate commit-urile push-uite automat
+
+### Dimineața (08:30) - morning-report
+
+**Verifică status:**
+
+```python
+from tools.ralph_workflow import check_status
+from pathlib import Path
+
+for project_name in active_projects:
+    status = check_status(Path.home() / "workspace" / project_name)
+    
+    # Raportează în Discord
+    print(f"""
+## 🔄 Proiecte Ralph
+
+### {project_name}
+- ✅ Complete: {len(status['complete'])} stories
+- 🔄 Incomplete: {len(status['incomplete'])} stories
+- 🔄 Running: {'DA (PID: ' + str(status.get('pid', '')) + ')' if status['running'] else 'NU'}
+
+**Stories complete:**
+{chr(10).join(f"  - {s['id']}: {s['title']}" for s in status['complete'][:5])}
+
+**Learnings:**
+{chr(10).join(f"  {l}" for l in status['learnings'][-3:])}
+
+🔗 https://gitea.romfast.ro/romfast/{project_name}
+""")
+```
+
+## Structură Proiect
+
+După workflow complet:
+
+```
+~/workspace/PROJECT-NAME/
+├── tasks/
+│   └── prd-PROJECT-NAME.md      # PRD markdown (generat de Opus)
+├── scripts/
+│   └── ralph/
+│       ├── prd.json              # Stories (generat de Opus)
+│       ├── progress.txt          # Learnings (generat de Ralph)
+│       ├── ralph.sh              # Loop autonom
+│       ├── prompt.md             # Instrucțiuni Claude Code
+│       ├── .ralph.pid            # PID proces Ralph
+│       ├── logs/
+│       │   └── ralph.log         # Output Ralph loop
+│       ├── archive/              # Arhive rulări anterioare
+│       └── screenshots/          # Screenshots UI
+├── src/                          # Cod implementat de Ralph (Sonnet)
+└── .git/                         # Git repo → gitea
+```
+
+## Format prd.json
+
+```json
+{
+  "projectName": "feature-name",
+  "branchName": "ralph/feature-name",
+  "description": "Descriere scurtă",
+  "techStack": {
+    "type": "python",
+    "commands": {
+      "start": "python main.py",
+      "build": "",
+      "lint": "ruff check .",
+      "typecheck": "mypy .",
+      "test": "pytest"
+    },
+    "port": 8000
+  },
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Titlu story",
+      "description": "Ca utilizator, vreau...",
+      "priority": 10,
+      "acceptanceCriteria": [
+        "Criteriu specific",
+        "pytest passes"
+      ],
+      "requiresBrowserCheck": false,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+```
+
+## Model Strategy (OBLIGATORIU)
+
+| Componentă | Model | Rulează pe |
+|------------|-------|------------|
+| PRD generation | **Opus** | Echo session (moltbot) |
+| User stories creation | **Opus** | Echo session (moltbot) |
+| prd.json generation | **Opus** | Echo session (moltbot) |
+| Code implementation | **Sonnet** | Claude Code (via ralph.sh) |
+| Quality checks | **Sonnet** | Claude Code (via ralph.sh) |
+| Git commits | **Sonnet** | Claude Code (via ralph.sh) |
+
+**Regula:**
+- **Opus (strategic)** = Planning, PRD, stories, decizie ce se implementează
+- **Sonnet (tactical)** = Coding, debugging, testing, implementare efectivă
+
+## Monitorizare
+
+### În timpul execuției
+
+```bash
+# Verifică dacă Ralph rulează
+ps aux | grep ralph.sh
+
+# Tail logs live
+tail -f ~/workspace/PROJECT/scripts/ralph/logs/ralph.log
+
+# Verifică stories complete
+jq '.userStories[] | select(.passes == true) | {id, title}' \
+  ~/workspace/PROJECT/scripts/ralph/prd.json
+```
+
+### Status Python
+
+```python
+from tools.ralph_workflow import check_status
+from pathlib import Path
+
+status = check_status(Path.home() / "workspace" / "PROJECT")
+
+print(f"Running: {status['running']}")
+print(f"Complete: {len(status['complete'])}")
+print(f"Incomplete: {len(status['incomplete'])}")
+```
+
+## Troubleshooting
+
+### Ralph nu pornește
+
+```bash
+# Verifică că ralph.sh există
+ls -la ~/workspace/PROJECT/scripts/ralph/ralph.sh
+
+# Verifică prd.json valid
+jq '.' ~/workspace/PROJECT/scripts/ralph/prd.json
+```
+
+### Ralph blochează pe o story
+
+```bash
+# Verifică logs
+tail -50 ~/workspace/PROJECT/scripts/ralph/logs/ralph.log
+
+# Marchează manual story ca done (pentru a continua)
+jq '.userStories[0].passes = true' \
+  ~/workspace/PROJECT/scripts/ralph/prd.json > tmp && mv tmp prd.json
+```
+
+### Oprește Ralph
+
+```bash
+# Kill process
+cat ~/workspace/PROJECT/scripts/ralph/.ralph.pid | xargs kill
+
+# Sau kill all
+pkill -f ralph.sh
+```
+
+## Templates Source
+
+**Locație:** `~/clawd/skills/ralph/templates/`
+
+**Fișiere:**
+- `ralph.sh` - Script principal loop
+- `prompt.md` - Instrucțiuni pentru Claude Code per iterație
+- `prd-template.json` - Template prd.json (opțional)
+
+**NU edita template-urile** - sunt copiate automat în fiecare proiect.
+
+## Diferențe față de sistemul vechi
+
+| Înainte | Acum |
+|---------|------|
+| SSH către claude-agent | Local pe moltbot |
+| Claude Code prin tmux/pexpect | ralph.sh apelează claude direct |
+| Skills /ralph:prd interactive | Python generator în ralph_prd_generator.py |
+| Control manual sesiuni | Complet automat background |
+| Greu de debuguit | Logs clare, status checkable |
+
+---
+
+**Status:** ✅ PRODUCTION READY
+**Testat:** 2026-02-09
+**Version:** 2.0 (finală)
+**Next:** Integrare night-execute
--- a/memory/kb/tools/sales-scripts.md
+++ b/memory/kb/tools/sales-scripts.md
@@ -0,0 +1,210 @@
+# Sales Scripts & Tehnici NLP
+
+**Tags:** @work #sales #nlp #scripts #prospecting #cold-calls
+
+**Ultima actualizare:** 2026-02-06
+
+---
+
+## Script #1: Cold Call cu Pattern Interrupt (NLP)
+
+**Sursă:** [NLP Cold Call Trick](../youtube/2026-02-06_nlp-trick-cold-calls.md)  
+**Principiu:** Spune numele lor ÎNAINTE de script → scade defensiva instant
+
+### De ce funcționează
+
+**Problema cu scriptul standard:**
+- Număr necunoscut = alarm mode
+- Script formal direct = confirmare "e salesman!" → click
+
+**Soluția NLP:**
+- Numele lor cu ton familiar → creierul caută: "Îl cunosc?"
+- Până termină căutarea → deja ești în conversație
+- E mai greu să întrerupi la mijloc decât la început
+
+### Script VECHI (de evitat)
+
+```
+"Bună ziua, mă numesc Marius de la Romfast, 
+vă sun în legătură cu sistemul ROA..."
+```
+
+**Rata de succes:** Scăzută (refuz instant în primele 5 secunde)
+
+### Script NLP NOU (recomandat)
+
+```
+"Bună, [Domnul/Doamna Nume]?"
+[PAUZĂ 1 SECUNDĂ - aștepți confirmare]
+
+"[Nume], sunt Marius."
+[PAUZĂ 1 SECUNDĂ]
+
+"Cum sunteți? Vă sun de la Romfast..."
+```
+
+**Rata de succes:** Crescută (conversație >30 secunde)
+
+### Variante pentru Context Românesc
+
+#### Varianta 1: B2B (firma mică/medie)
+```
+"Bună ziua, Domnul Ionescu?"
+[Pauză]
+
+"Domnul Ionescu, sunt Marius de la Romfast. Cum sunteți?"
+[Pauză]
+
+"Vă sun pentru că am văzut că aveți [X] și m-am gândit că 
+vă poate interesa [Y]..."
+```
+
+#### Varianta 2: Follow-up client vechi
+```
+"Bună, Mihai?"
+[Pauză]
+
+"Mihai, Marius de la Romfast. Cum merge?"
+[Mai informal, dar aceeași tehnică]
+```
+
+#### Varianta 3: Lead warm (a întrebat despre ROA)
+```
+"Bună ziua, Doamna Popescu?"
+[Pauză]
+
+"Doamna Popescu, Marius Mutu. Ați întrebat săptămâna trecută 
+despre sistemul ROA..."
+```
+
+### Greșeli de Evitat
+
+❌ **NU spune numele complet imediat:**
+- Greșit: "Bună, Ionescu? Marius Mutu de la Romfast SRL."
+- De ce: Sună prea formal → trigger "salesman"
+
+❌ **NU sari pauzele:**
+- Greșit: "Bună, Ionescu? Ionescu, sunt Marius de la Romfast vă sun..."
+- De ce: Nu dai timp creierului să proceseze
+
+❌ **NU sună robot:**
+- Tonul = conversație între oameni care S-AR PUTEA cunoaște
+- Nu tonul "Bună ziua stimată clientelă"
+
+### Test A/B Rapid
+
+**Următoarele 5 cold calls:**
+- Primele 3: Script NLP nou
+- Ultimele 2: Script vechi
+
+**Măsoară:**
+- Câți au rămas pe fir >30 secunde?
+- Diferența de ton în răspuns?
+- Te-ai simțit mai confortabil tu?
+
+**Tracking simplu:**
+| Call | Script | Rămas pe fir >30s? | Notă |
+|------|--------|-------------------|------|
+| 1    | NLP    | DA/NU             |      |
+| 2    | NLP    | DA/NU             |      |
+| 3    | NLP    | DA/NU             |      |
+| 4    | Vechi  | DA/NU             |      |
+| 5    | Vechi  | DA/NU             |      |
+
+---
+
+## Script #2: Propunere Valorică (nu preț)
+
+**Principiu:** Nu vinde "software ERP" → vinde "ore salvate"
+
+### Transformare Mesaj
+
+**VECHI (centrat pe produs):**
+> "ROA e un sistem ERP pentru gestiune, facturare, stocuri, 
+cu suport pentru Oracle..."
+
+**NOU (centrat pe valoare):**
+> "ROA economisește în medie 10 ore pe lună din munca repetitivă. 
+Asta înseamnă 120 ore pe an - aproape 3 săptămâni de lucru salvate."
+
+### Template Generală
+
+```
+"[NUME], am observat că [SITUAȚIA LOR ACTUALĂ].
+
+De obicei, asta înseamnă [PROBLEMA CONCRETĂ - ore pierdute, erori, frustrare].
+
+Ce fac clienții mei în cazul ăsta: [SOLUȚIA - economisesc X ore/lună].
+
+V-ar ajuta dacă [BENEFICIUL SPECIFIC PENTRU EI]?"
+```
+
+### Exemplu ROA
+
+```
+"Domnul Popescu, am văzut că aveți [5 angajați + gestiune manuală].
+
+De obicei, asta înseamnă cel puțin 10-15 ore pe lună pierdute 
+cu facturi, stocuri, și rapoarte făcute manual.
+
+Ce fac clienții mei în cazul ăsta: automatizează complet procesele 
+repetitive și economisesc 10+ ore lunar. Asta le permite să se 
+concentreze pe business, nu pe administrație.
+
+V-ar ajuta dacă ați avea cele 10 ore înapoi în fiecare lună?"
+```
+
+---
+
+## Script #3: Închidere Soft (nu pushy)
+
+**Principiu:** NU forța decizia → oferă următorul pas mic
+
+### Greșit (pushy):
+```
+"Vă interesează? Semnăm contractul?"
+```
+
+### Corect (soft close):
+```
+"Vă propun așa: să ne vedem 30 minute, vă arăt cum funcționează 
+în practica, și vedeți dacă se potrivește pentru dumneavoastră. 
+Miercuri sau joi după-amiază vă e mai bine?"
+```
+
+### Alternative
+
+**Opțiunea 1: Demo scurt**
+> "Îmi iau 15 minute să vă arăt exact cum arată în practică. 
+Mâine la 14:00 aveți 15 minute libere?"
+
+**Opțiunea 2: Diagnostic gratuit**
+> "Putem face o analiză rapidă a proceselor dumneavoastră actuale 
+și vedem unde sunt blocajele. Fără costuri, fără obligații. 
+Vineri dimineața sunteți disponibil?"
+
+**Opțiunea 3: Ghid scris**
+> "Vă trimit un ghid cu 3 întrebări pe care să vi le puneți: 
+dacă răspunsul e DA la măcar 2, probabil ROA v-ar ajuta. 
+E OK să vă trimit pe email?"
+
+---
+
+## Next Steps
+
+### Testare & Îmbunătățire
+1. **Săptămâna 1:** Testează script-ul NLP la 10 calls
+2. **Notează:** Ce variante funcționează cel mai bine
+3. **Ajustează:** Modifică script-ul bazat pe feedback real
+
+### Tracking Performanță
+- Câte calluri/zi?
+- Câte conversații >30 sec?
+- Câte demo-uri programate?
+- Câte conversii la client?
+
+---
+
+**Creat de:** Echo 🌀  
+**Pentru:** Marius  
+**Actualizat:** La fiecare tehnică nouă descoperită
--- a/memory/kb/tools/session-initialization.md
+++ b/memory/kb/tools/session-initialization.md
@@ -0,0 +1,69 @@
+# Session Initialization Rule
+
+**Purpose:** Minimize context overhead and token waste by explicitly controlling what loads on every session start.
+
+## ON SESSION START: Load ONLY These Files
+
+1. **SOUL.md** — Core principles, tone, boundaries
+2. **USER.md** — Who I'm working with, timezone, preferences  
+3. **IDENTITY.md** — Self-definition (name, vibe, emoji)
+4. **memory/YYYY-MM-DD.md** (if today's note exists) — Daily context
+
+**Total overhead: ~8KB instead of 50KB+**
+
+## DO NOT Auto-Load
+
+- ❌ MEMORY.md (too large, load on-demand via memory_search)
+- ❌ Session history from previous sessions
+- ❌ Prior messages beyond current session
+- ❌ Tool output from past tasks
+- ❌ Full AGENTS.md unless explicitly needed
+- ❌ TOOLS.md unless explicitly needed
+
+## When User Asks About Prior Context
+
+Example: *"What did we decide about the refactoring?"*
+
+**Response:**
+1. Use `memory_search(query="refactoring decision")` to find relevant snippets
+2. Use `memory_get(path="...", lines=5-10)` to pull only the needed lines
+3. Quote the specific snippet with Source: attribution
+4. Don't load entire files
+
+## Session End: Update memory/YYYY-MM-DD.md
+
+Before session closes, append to `memory/YYYY-MM-DD.md`:
+
+```markdown
+## [Session Time] - [Topic/Task]
+
+**What we did:**
+- Item 1
+- Item 2
+
+**Decisions made:**
+- Decision 1
+
+**Blockers:**
+- Blocker 1
+
+**Next steps:**
+- Step 1
+```
+
+## Cost Impact
+
+| Metric | Before | After |
+|--------|--------|-------|
+| Context per session | 50KB | 8KB | 
+| Token waste | 2-3M per session | ~300K |
+| Cost per session | $0.40 | $0.05 |
+| Cost per 100 sessions | $40 | $5 |
+
+## Implementation Checklist
+
+- [x] This rule is documented in system prompt
+- [x] Echo knows to use memory_search() on-demand
+- [x] Echo knows to pull snippets, not whole files
+- [x] Daily notes are in memory/YYYY-MM-DD.md format
+- [x] Echo updates notes at session end