diff --git a/.claude/hooks/context_guard.py b/.claude/hooks/context_guard.py
new file mode 100755
index 0000000..bf52429
--- /dev/null
+++ b/.claude/hooks/context_guard.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Anunță când contextul sesiunii depășește un prag, ca să se predea sesiunea.
+
+Userul a cerut asta pe 13.09.2026: la ~250k tokeni, sesiunea salvează
+PROGRESS.md și se oprește, iar munca o continuă o sesiune nouă. Fără un
+semnal automat, pragul se ratează — contextul crește în tăcere.
+
+Rulează ca hook PostToolUse. Primește pe stdin JSON-ul hook-ului, citește
+`usage` din ultimul mesaj al transcrierii și, dacă totalul depășește pragul,
+injectează un mesaj în context. Anunță o singură dată per prag, ca să nu
+umple contextul chiar el.
+"""
+
+import json
+import os
+import sys
+
+THRESHOLD = int(os.environ.get("CTX_GUARD_THRESHOLD", "250000"))
+STEP = 50_000          # re-anunță din 50k în 50k peste prag
+STATE_DIR = os.path.expanduser("~/.claude/ctx_guard")
+
+MSG = """[context guard] Contextul sesiunii a ajuns la ~{tokens:,} de tokeni (prag: {threshold:,}).
+
+Conform instrucțiunilor userului, acum:
+1. Salvează starea în PROGRESS.md — ce s-a făcut, ce a rămas, ce rulează.
+2. Comite și fă push.
+3. Oprește agenții care au terminat (SendMessage cu shutdown_request).
+4. Spune userului că sesiunea e gata de predat și oprește-te.
+
+Nu începe o sarcină nouă mare. Dacă un agent încă lucrează, cere-i raportul
+parțial și notează în PROGRESS.md ce rămâne de reluat."""
+
+
+def total_tokens(transcript_path: str) -> int:
+    """Suma din ultimul `usage` găsit în transcriere — aproximarea contextului."""
+    try:
+        with open(transcript_path, "r", encoding="utf-8") as fh:
+            lines = fh.readlines()
+    except OSError:
+        return 0
+
+    for line in reversed(lines):
+        try:
+            usage = json.loads(line).get("message", {}).get("usage")
+        except (json.JSONDecodeError, AttributeError):
+            continue
+        if not usage:
+            continue
+        return (usage.get("input_tokens", 0)
+                + usage.get("cache_read_input_tokens", 0)
+                + usage.get("cache_creation_input_tokens", 0)
+                + usage.get("output_tokens", 0))
+    return 0
+
+
+def already_warned(session_id: str, bucket: int) -> bool:
+    """Marcăm pragul atins, ca să nu repetăm anunțul la fiecare tool call."""
+    os.makedirs(STATE_DIR, exist_ok=True)
+    path = os.path.join(STATE_DIR, f"{session_id}.txt")
+    try:
+        with open(path) as fh:
+            if int(fh.read().strip() or 0) >= bucket:
+                return True
+    except (OSError, ValueError):
+        pass
+    with open(path, "w") as fh:
+        fh.write(str(bucket))
+    return False
+
+
+def main() -> None:
+    try:
+        payload = json.load(sys.stdin)
+    except (json.JSONDecodeError, ValueError):
+        return
+
+    transcript = payload.get("transcript_path")
+    session_id = payload.get("session_id", "unknown")
+    if not transcript:
+        return
+
+    tokens = total_tokens(transcript)
+    if tokens < THRESHOLD:
+        return
+
+    bucket = THRESHOLD + ((tokens - THRESHOLD) // STEP) * STEP
+    if already_warned(session_id, bucket):
+        return
+
+    text = MSG.format(tokens=tokens, threshold=THRESHOLD)
+    print(json.dumps({
+        "systemMessage": f"Context la ~{tokens:,} tokeni — salvează PROGRESS.md și predă sesiunea.",
+        "hookSpecificOutput": {
+            "hookEventName": payload.get("hook_event_name", "PostToolUse"),
+            "additionalContext": text,
+        },
+    }))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 0000000..9c877ad
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/context_guard.py\" 2>/dev/null || true",
+            "timeout": 10,
+            "statusMessage": "verific contextul"
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..8b1f353
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,88 @@
+# Reguli de lucru în atm-curs-dl
+
+Cerute explicit de user pe 13.09.2026, după o sesiune în care contextul
+principal s-a umplut cu muncă ce putea fi delegată.
+
+## OBLIGATORIU: sesiunea principală e doar orchestrator
+
+**Nu executa tu munca de volum. Lansează agenți.** Contextul principal e
+resursa rară: odată umplut, sesiunea se pierde și predarea costă timp.
+
+| Faci TU, în sesiunea principală | Dai la AGENȚI |
+|---|---|
+| împarți munca și scrii prompturile | citit transcrieri (20-35 mii de cuvinte) |
+| citești rapoartele agenților | scris sumarizări |
+| verificare prin sondaj: 1-2 screenshot-uri per lot | generat și verificat diagrame |
+| `git add` pe foldere, commit, push | verificat cifre față de transcriere |
+| actualizezi `PROGRESS.md` și `INDEX_TEMATIC.md` | căutări largi prin repo |
+| decizi ce e corect când doi agenți se contrazic | audit + render + screenshot |
+
+Concret: nu citi o transcriere întreagă ca să scrii tu un sumar. Nu converti
+tu 60 de diagrame. Nu căuta tu prin toate fișierele. Pentru fiecare din
+astea, scrie un prompt și lansează un agent.
+
+**Ce rămâne al tău, indiferent de cât delegi:** commit-urile și mesajele
+lor, deciziile de conținut, și verificarea prin sondaj a ce raportează
+agenții. Un raport de agent nu e dovadă — verifică în repo.
+
+## Pragul de context: 250k
+
+Un hook (`.claude/hooks/context_guard.py`, configurat în
+`.claude/settings.json`) anunță când contextul trece de 250.000 de tokeni.
+Când apare anunțul:
+
+1. Salvează starea în `PROGRESS.md`: ce s-a făcut, ce a rămas, ce rulează.
+2. Comite și fă push.
+3. Închide agenții care au terminat (`SendMessage` cu `shutdown_request`).
+4. Spune userului că sesiunea e gata de predat și oprește-te.
+
+Nu începe o sarcină nouă mare după prag. Dacă un agent încă lucrează,
+cere-i raportul parțial și notează în `PROGRESS.md` de unde se reia.
+
+## Reguli pentru agenți (pune-le în fiecare prompt)
+
+- **Același prag de context.** „Dacă ajungi la ~250k tokeni, oprește-te,
+  raportează ce ai făcut și ce a rămas, și nu începe altceva."
+- **Raport scurt.** Cere lista de probleme cu dovezi, nu povestea muncii.
+  „ok" pe o linie pentru categoriile curate.
+- **Fără commit.** Agenții lasă fișierele modificate; comiți tu, pe foldere,
+  după ce raportează. Altfel prinzi munca în zbor a altui agent.
+- **Fără sub-agenți**, dacă nu ai cerut explicit — altfel doi agenți scriu
+  în aceleași fișiere și nu mai știi a cui e versiunea din repo.
+- **Domeniu clar:** dă-i fișierele lui, scrie „nu atinge nimic din afara
+  lor", și nu suprapune două domenii.
+- **Verificare în sarcina lui:** audit + render + screenshot pe care să le
+  **citească** efectiv, nu doar să le genereze.
+
+## Verificarea se face tot cu agenți
+
+După orice lot de muncă, lansează un agent de verificare separat de cel
+care a produs-o. Pe 13.09.2026 au găsit 14 probleme reale pe care auditul
+mecanic nu le prinde (etichete de R greșite, cifre inventate, un stop
+etichetat −9% care era −12.6%, contradicții între secțiuni).
+
+Promptul care a funcționat e în `PROGRESS.md`, secțiunea „VERIFICARE CU
+AGENȚI".
+
+## Monitor pentru cozile de transcriere
+
+Cozile de transcriere (local + moltbot) merg ore întregi. Nu le verifica
+prin polling — există un monitor care raportează în sesiune când se termină
+un fișier. Când vine anunțul, lansează agentul de sumarizare pentru
+transcrierea nouă.
+
+## Capcane de orchestrare, pățite
+
+- `git add -A` cât timp agenții lucrează prinde fișiere pe jumătate scrise.
+  Comite pe foldere, doar după raport.
+- Panourile tmux se termină (~10 agenți concurenți). Închide-i pe cei
+  terminați înainte să lansezi alții.
+- Un agent care raportează „am terminat" poate avea un sub-agent care încă
+  scrie. Verifică `git status` înainte să comiți.
+
+## Restul regulilor
+
+- Format și conținut pentru sumarizări: `STYLE.md`.
+- Starea proiectului și ce e de făcut: `PROGRESS.md`.
+- Diagramele de preț: `STYLE.md`, secțiunea „Cum trebuie să arate un grafic
+  de preț"; referința de copiat e `gen/exemplu_grafic_real.py`.
diff --git a/PROGRESS.md b/PROGRESS.md
index 50c24de..a8e999d 100644
--- a/PROGRESS.md
+++ b/PROGRESS.md
@@ -166,6 +166,19 @@ Rezultate Clienți Mentorat (3), Live Trading Room (5).
 
 ---
 
+# CUM SE LUCREAZĂ (citește `CLAUDE.md` din repo)
+
+Userul a cerut pe 13.09.2026, explicit: **sesiunea principală e doar
+orchestrator**. Nu citi tu transcrieri întregi, nu converti tu diagrame în
+serie, nu căuta tu prin tot repo-ul — lansează agenți și citește rapoartele.
+Regulile complete, inclusiv ce se pune în promptul fiecărui agent, sunt în
+`CLAUDE.md`.
+
+**Prag de context: 250k.** Un hook (`.claude/hooks/context_guard.py`) anunță
+când s-a depășit. Atunci: salvezi `PROGRESS.md`, comiți, închizi agenții
+terminați, predai sesiunea. Aceeași instrucțiune se pune și în promptul
+agenților.
+
 # DIAGRAME: standardul nou (cerut de user pe 13.09.2026)
 
 Userul citește diagramele ca să vadă **trendul** și să facă analogie cu un