CLAUDE.md: sesiunea principala e doar orchestrator, plus hook de context la 250k

Cerut explicit de user: contextul principal e resursa rara, deci munca de
volum (citit transcrieri, scris sumarizari, convertit diagrame, cautari
largi) se da la agenti, iar sesiunea principala imparte munca, citeste
rapoartele, verifica prin sondaj si comite.

Adaugat:
- CLAUDE.md cu tabelul "ce faci tu vs. ce dai la agenti", regulile care se
  pun in promptul fiecarui agent (acelasi prag de context, raport scurt,
  fara commit, fara sub-agenti, domeniu clar, verificare in sarcina lui),
  si capcanele de orchestrare pe care le-am patit azi.
- .claude/hooks/context_guard.py: citeste usage din transcriere si anunta
  cand contextul trece de 250k, o singura data per prag. Testat pe payload
  sintetic (sub prag, peste prag, repetare, fara transcript) si live.
- .claude/settings.json: hook PostToolUse care il ruleaza.
- PROGRESS.md: pointer catre regulile astea.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01MtSTyTmt6AbCL9j5ajEDm1

.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()

.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"
+          }
+        ]
+      }
+    ]
+  }
+}

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`.

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