<!-- plan sub /autoplan -->
# PRD 5.14 — Mapare automata operatii service prin distilare LLM

**Stare**: inchis (2026-06-28; CLOSE dupa `/code-review high` -> embeddings „mort dar scump" reparat + WIRE functional la decizia user: corpus din nomenclator gated pe `AUTOPASS_EMBEDDINGS_ENABLED`; marime model corectata ~50MB->~230MB; regresie 1256 passed)

## Stories de executie (decompozitie lead, 2026-06-28)

> PRD-ul a fost aprobat prin /autoplan ca DESIGN (Decision Audit Trail #11-20). Aici lead-ul
> il sparge in stories atomice executabile (ROADMAP §5.4), FARA a re-deschide deciziile.
> **Secventiere fata de 5.15 (D9 + cerinta user "prioritate design 5.15"):** partile DISJUNCTE
> de fisier ruleaza in PARALEL cu 5.15 acum; integrarea in editor (`mapping.py`/`routes.py`)
> ASTEAPTA 5.15 si se aplica PESTE designul 5.15, fara sa-l suprascrie.

| Story | Tip | Fisiere (disjunct?) | Depinde de |
|-------|-----|---------------------|-----------|
| **L14-S1** Layer 1 etichetator offline | tool | `tools/mapare-llm/or_label.py` + teste (mock OpenRouter) — DISJUNCT | — |
| **L14-S2** Temporal holdout (GATE Premisa 1) | tool | `tools/mapare-llm/holdout.py` + raport — DISJUNCT | — |
| **L14-S3** Schema suggestions + shared store | backend | `app/schema.sql` (aditiv), store module nou, seeder, teste — owns schema.sql | — |
| **L14-S4** Modul embeddings in-proces | backend | `app/embeddings.py` NOU + teste — DISJUNCT (modul; fara wiring) | — |
| **L14-S5** Set held-out eval (BLOCANT auto-send) | tool | `tools/mapare-llm/heldout_eval.py` + metodologie — DISJUNCT | — |
| **L14-S6** Integrare Layer 2/3 in editor | backend+UI | `app/mapping.py`, `app/web/routes.py` (editor) — **DUPA 5.15** | L14-S3,S4; 5.15 US-007/US-009 |

**Invariante de respectat (din Decision Audit Trail):** auto-send DOAR GOLD propriu (F-A/#11);
silver in tabela SEPARATA, niciodata in resolve_prestatii (#13); seeder INSERT OR IGNORE, nu
clobber uman (#2); scrub PII inainte de LLM (#3); NUL = ancore negative + supresie (#4);
provenance source/confidence (#5); embeddings doar SUGESTIE + degradare gratioasa (#16b);
held-out etichetat de OM = blocant pt orice auto-send peste GOLD (#19); tier "Inalta" sters din v1 (#17).

**Rezultat GATE Premisa 1 (L14-S2, 2026-06-28) — VERDICT: SLABA.** Validarea temporala STRICTA e
imposibila (CSV-urile `docs/operatii-service/*.csv` au doar frecvente agregate, fara timestamp). Proxy
Zipf + leave-first-out pe 155.195 operatii: pentru 90% acoperire de volum e nevoie de **4.368 denumiri
distincte (25.4% din total)**, nu "cateva sute"; leave-first-out (limita superioara de stationaritate)
= **88.9% agregat, SUB 90%**. Implicatie: etichetarea offline (L14-S1) trebuie sa proceseze ordine de
MII de denumiri per client; coada `needs_mapping` ramane semnificativa chiar dupa bootstrap. Premisa nu e
falsa, dar randamentul auto-rezolvarii e mai mic decat estima PRD-ul. NU blocheaza build-ul (piesele sunt
utile + auto-send ramane conservator pe GOLD), dar recalibreaza asteptarile de acoperire. Tool: `tools/mapare-llm/holdout.py`.

**Raport VERIFY 5.14** (subagent independent context curat, 2026-06-28) — **VERDICT: PASS, zero FAIL,
zero regresie 5.15.** `pytest -q -m "not live"` → **1245 passed, 0 failed**. Invariante confirmate cu cod+test:
- **F1/#11/#17 auto-send DOAR GOLD propriu**: `load_mapping` citeste EXCLUSIV `operations_mapping` al
  contului; `resolve_prestatii` nu atinge DB (primeste `mapping` dict); singura cale spre `queued` =
  GOLD propriu. SILVER/GOLD-partajat/embedding = sugestie. Teste `test_f1_*` PASS. Tier "Inalta" sters (#17).
- **#13 separare structurala**: grep confirma — `shared_store`/`mapping_suggestions`/`shared_mappings`
  apar DOAR in `enrich_suggestions` (apelat din `pending_unmapped`), niciodata in `resolve_prestatii`/`load_mapping`.
- **#16b degradare gratioasa**: `is_available()=False` → `suggest_nearest=[]` fara exceptie; ingestia nu se blocheaza.
- **#2** seeder INSERT OR IGNORE (nu clobber uman); **#4** NUL nu devine cod; **#5** provenance source/confidence;
  **#3** scrub PII nr/VIN inainte de LLM (`or_common.scrub`); **#19** held-out cu `cod_gold` GOL + kill-criterion
  (`wrong_code_rate<0.5%` AND `coverage>50%`) — toate PASS cu teste.
- **GATE Premisa 1**: verdict **SLABA** documentat onest (proxy Zipf, fara pretentie de validare temporala).
- fastembed 0.8.0 INSTALAT; testul real de embedding trece.

**Riscuri reziduale (LOW, non-blocant)**: (1) fastembed 0.8.0 foloseste mean-pooling (warning) — relevant doar
daca se persista corpusul de vectori intre versiuni (acum re-indexat la nevoie din nomenclator); (2) `record_human_validation`
ON CONFLICT nu suprascrie `cod_prestatie` (by design — corectie = override per-cont sau DELETE explicit);
(3) lazy-load fastembed la prima cerere `/mapari` cand `AUTOPASS_EMBEDDINGS_ENABLED=true` (~230MB, cateva
zeci de secunde daca modelul nu e in cache — acceptat la decizia CLOSE). **CLOSE 2026-06-28: embeddings WIRE-uit
functional** (era „mort dar scump"): `ensure_embeddings_corpus(conn)` construieste corpusul din nomenclator
(`nume_prestatie`->`cod_prestatie`), apelat in `pending_unmapped` + `_nemapate_pentru_submission` inainte de
bucla, gated pe `AUTOPASS_EMBEDDINGS_ENABLED` (default OFF). Re-index doar la schimbarea semnaturii
nomenclatorului. Corpusul se construieste din nomenclator (18 coduri largi), NU per-confirmare umana — sugestia
embedding e similaritate denumire-prezentare vs. nume_prestatie RAR.

---

## Problema

La ingestie (canal API si import web), o prestatie poate veni cu `cod_op_service`
+ `denumire` in loc de `cod_prestatie` RAR. Daca nu exista mapare, submission-ul
intra in `needs_mapping` si asteapta confirmare umana. Service-urile reale au
**volume mari de denumiri particulare** (masurat: 17.435 denumiri DISTINCTE in 4
CSV-uri de clienti reali — `automotive` 13.170, `sigma` 3.743, `clever` 1.668,
`south` 875). Maparea manuala a acestora, prin editorul `needs_mapping`, e
prohibitiva: zeci de mii de operatii × confirmare umana.

Nomenclatorul RAR are doar **18 coduri** foarte largi (REPARATIE, INTRETINERE,
REVIZIE PERIODICA, etc. — `nomenclator_seed.py`). Deci problema nu e potrivire de
sinonime, ci **clasificare** a mii de operatii granulare in 18 categorii abstracte
+ detectare de „gunoi" (linii care nu sunt operatii: `ITP CT 12 ABC`, `DISCOUNT
MATERIALE 5%`, `MANOPERA`, nr. inmatriculare).

## Viziune (pivot 2026-06-28)

LLM-ul **NU ruleaza la runtime**. Rol unic: **etichetator offline** care
construieste un set de date (denumire -> cod). La runtime ruleaza un **clasificator
local mic, fara API** (similaritate / fuzzy / embeddings), „distilat" din etichetele
LLM + maparile validate de oameni. Trei straturi:

1. **Etichetare offline (LLM, periodic):** acopera denumirile cu cele mai multe
   aparitii (frecventa) si grupeaza denumirile asemanatoare ca sa eticheteze ieftin.
2. **Clasificator runtime (fara AI):** exact -> fuzzy/substring -> similaritate
   semantica (embeddings) peste baza de cunostinte. Zero cost per cerere, ruleaza pe
   LXC.
3. **Baza de cunostinte PARTAJATA:** maparile validate de oameni din TOATE conturile
   de service contribuie la clasificare (strat „gold" comun), peste etichetele LLM
   („silver" bootstrap). Munca de validare a unui service ajuta toate service-urile.

Viitor (nu acum): un LLM generativ local pe LXC. Pasul curent foloseste un model de
**embedding** (nu generativ): mic, CPU, milisecunde/text.

## Premise

1. **Volumul de denumiri distincte e finit si se schimba lent.** Odata etichetate,
   90%+ din traficul viitor sunt repetari ale acelorasi denumiri (service-ul
   refoloseste propriul vocabular). Lege Zipf: top 100 denumiri = 43.6% volum,
   top 500 = 67.7%, top 1000 = 76.2% (din 155.195 operatii totale).
2. **RAR accepta NUMAI coduri din nomenclator.** Un cod necunoscut -> HTTP 500
   (`ORA-12899`) + record PARTIAL FINALIZATA (terminal). Deci orice cod propus de
   un sistem automat TREBUIE validat fata de nomenclator inainte de enqueue
   (invariant existent in `resolve_prestatii(..., valid_codes)`).
3. **Maparea gresita are cost asimetric:** un cod gresit trimis = FINALIZATA
   ireversibil la RAR. Deci pragul de auto-trimitere ramane conservator; incertul
   ramane `needs_mapping` cu om in bucla. Etichetele LLM NEVALIDATE = sugestie, nu
   auto-trimitere (vezi scara de incredere).
4. **Hardware LLM local generativ e prea lent acum** (masurat: Ollama LXC 104
   generativ 180-320s/op). Embeddings locale insa sunt rapide pe CPU si suficiente
   pentru similaritate la runtime.
5. **Datele nu sunt sensibile** (confirmat utilizator): denumirile de operatii pot
   merge la API-uri cloud pentru etichetare. PII incidental (nr. inmatriculare/VIN)
   se face scrub inainte de trimitere (F3).

## Masuratori

### Bootstrap (anterior, Groq)
- Groq `llama-3.3-70b`: 28ms/op, acord 94% cu heuristica pe cazuri clare, detectare
  gunoi excelenta (`NUL`). Abandonat ca furnizor: cap zilnic free atins + cheie expusa.

### OpenRouter free — NVIDIA Nemotron (masurat 2026-06-28)
Furnizor nou pentru etichetare: cheie utilizator, modele GRATUITE, date ne-sensibile.

- **Capcane de cont (rezolvate):** modelele free dau initial `404 No allowed
  providers` din cauza unui allowlist de provideri pe cont (venice/together/fireworks/
  atlas-cloud) — `open-inference`/`google-ai-studio`/`nvidia` erau excluse. Fix:
  eliminat restrictia in Settings -> Preferences + activat toggle-ul de privacy
  „free endpoints may publish/train". WAF: User-Agent `Mozilla/5.0` obligatoriu.
- **Set fiabil = familia NVIDIA Nemotron.** Restul modelelor sunt 429 (rate-limited
  upstream, partajat global: llama-3.3-70b, qwen3-next, gemma, hermes, dolphin) sau
  404 (gpt-oss). Cap free tier ~50 cereri/zi fara credit.
- **Test ensemble pe top 120 dupa frecventa (46.4% din volum), 2026-06-28:**

  | Model | ms/op | parse-fail | acord vs Groq (overlap) |
  |---|---|---|---|
  | nemotron-3-super-120b | 1463 | 0 | 100% |
  | nemotron-nano-9b-v2 | 1248 | 0 | 100% |
  | nemotron-3-ultra-550b | 6450 | 0 | 100% |

  Acord ensemble ponderat pe volum: **3/3 unanim = 87% volum**, 2/3 = 13%, dezacord
  total = **0%**. Din unanim: 7 NUL (gunoi), 100 coduri reale.
- **Decizie model:** pastram `super-120b` + `nano-9b`; **aruncam `ultra-550b`**
  (4-5x mai lent, zero castig de acuratete). Caveat: ensemble din aceeasi familie
  NVIDIA -> acordul supraestimeaza increderea fata de un ensemble cross-family.
- **Dezacordurile (13%) sunt cazuri de granita taxonomica reala**, nu zgomot:
  `REGLAT DIRECTIE/FARURI` (OE-2 intretinere vs OE-4 reglare), `MANOPERA
  TINICHIGERIE` (NUL vs OE-1), `DEZECHIPAT usa/bara` (pas de demontare), `INLOCUIT
  FILTRU AER` (OE-1 vs OE-3). Astea trebuie sa cada in `needs_mapping`.

## Solutia

### Stratul 1 — Etichetare offline (LLM, fara cod runtime)

Tool CLI (`tools/mapare-llm/`, stil `tools/apikey`). Etichetatorul OpenRouter
(`or_common.py` + `or_label.py`) clasifica denumirile in cele 18 coduri RAR + `NUL`:

1. **Prioritizare pe FRECVENTA (NR), nu alfabetic.** Etichetam intai denumirile cu
   cele mai multe aparitii (acopera cel mai mult volum per apel).
2. **Grupare pe similaritate inainte de etichetare.** Denumirile aproape identice
   (`REGLAT DIRECTIE` / `REGLAT DIRECTIA` / `REGLARE DIRECTIE`) se grupeaza; LLM
   eticheteaza doar **reprezentantul grupului**, codul se propaga la tot grupul.
   Maximizeaza acoperirea per apel LLM (critic pe cap free de ~50 cereri/zi).
3. **Ensemble NVIDIA** (`super-120b` + `nano-9b`): acord -> incredere mai mare;
   dezacord -> ramane pentru `needs_mapping`. Vot pe coduri, nu self-confidence.
4. **Scrub PII** (regex nr. inmatriculare/VIN) inainte de trimitere (F3, exista).
5. Output: dataset etichetat cu `denumire, cod, sursa, confidence` (provenienta).
   `NUL` marcat separat (ancore negative + supresie), NU se promoveaza la cod RAR.

Prompt cu reguli explicite (avarii grave DOAR la accident; vopsire = reparatie;
ulei+filtru = revizie; gunoi -> NUL). Batch mare (cap free tier), retry/backoff pe
429, respecta `Retry-After`.

### Stratul 2 — Clasificator runtime (FARA AI, fara API)

Pentru o denumire din prezentare (canal API sau import), in `app/mapping.py`:

1. **Exact** in baza de cunostinte (`operations_mapping` + strat partajat) -> cod direct.
2. **Fuzzy/substring** (`operation_text_rules`, `rapidfuzz`) — exista deja.
3. **Similaritate semantica (embeddings)** — NOU: model multilingv mic (ex.
   `intfloat/multilingual-e5-small` sau `paraphrase-multilingual-MiniLM`), CPU.
   Vectorizam baza etichetata o data; la runtime vectorizam denumirea noua si luam
   cel mai apropiat vecin (sau top-k cu vot). Optional: clasificator `scikit-learn`
   (regresie logistica / kNN) antrenat pe (embedding -> cod) pentru generalizare
   dincolo de vecinul exact. „Antrenarea pe datele de test" = acest pas, secunde,
   ruleaza oriunde.
4. Cod propus -> validat OBLIGATORIU `valid_codes` (garda ORA-12899). Peste pragul
   de incredere -> conform scarii; altfel `needs_mapping`.

Decizie de gazduire runtime: ramane deschisa pentru reviziile plan (in-proces in
gateway vs microserviciu pe LXC/Flowise). Default propus: in-proces (cel mai simplu).

### Stratul 3 — Baza de cunostinte PARTAJATA cross-account

**Schimbare fata de versiunea anterioara** (care izola corpusul per cont):

- **Strat GOLD partajat:** maparile **validate de oameni** (din `needs_mapping`, in
  ORICE cont) intra intr-un store partajat `denumire_normalizata -> cod`. Astfel
  validarea facuta de un service ridica increderea pentru toate. Cheia = denumire
  normalizata (scrub PII, lower, strip), nu textul brut.
- **Strat SILVER:** etichetele LLM (bootstrap) — sugestii, NU auto-trimitere.
- **Override per-cont:** daca un cont mapeaza explicit o denumire la alt cod decat
  cel partajat (conflict legitim de vocabular), override-ul contului castiga pentru
  acel cont. Conflictele inter-cont se rezolva cu provenienta + (optional) majoritate.

Confirmarile umane curg organic prin folosirea normala a editorului `needs_mapping`
— FARA sesiune separata de adjudecare manuala (cerinta utilizator).

### Scara de incredere (runtime, per operatie din prezentare)

| Treapta | Sursa | Actiune | Frictiune |
|---|---|---|---|
| Certa | exact in stratul GOLD (validat de om, orice cont) sau override cont | auto-trimite | zero |
| Inalta | embedding NN cu similaritate FOARTE inalta la o mapare GOLD + ensemble LLM unanim | auto-trimite (prag calibrat) | zero |
| Medie | LLM silver / similaritate medie | `needs_mapping` cu sugestie pre-completata -> 1 click | minima |
| Joasa | similaritate slaba / coduri apropiate | `needs_mapping` manual | normala |
| NUL | non-operatie (ITP, discount, nr. inmatriculare) | marcat „nu e operatie", suprimat | — |

**Invariant F1 (pastrat):** o eticheta pur-LLM NEVALIDATA nu auto-trimite singura;
auto-send cere ori GOLD (validat de om), ori treapta „inalta" calibrata. Tensiunea
centrala (utilizatorul se bazeaza pe LLM, dar FINALIZATA e ireversibil) = intrebarea
cheie pentru reviziile plan: unde fix se aseaza bara treptei „inalta".

## Integrare

- Stratul 1: tool CLI offline `tools/mapare-llm/` (exista: `or_common.py`,
  `or_modeltest.py`; de adaugat `or_label.py` cu grupare + propagare).
- Stratul 2: similaritate embeddings in `app/mapping.py` (`enrich_suggestions` ->
  `suggest_nearest`), apelata in `pending_unmapped` / `_nemapate_pentru_submission`
  pentru sugestia din editor. Corpusul se construieste din nomenclator via
  `ensure_embeddings_corpus` (gated pe `AUTOPASS_EMBEDDINGS_ENABLED`, default off):
  lazy-load model fastembed/ONNX (~230MB) la prima cerere /mapari cand flagul e activ,
  re-index doar la schimbarea nomenclatorului (semnatura). Off -> no-op (cade pe
  GOLD/SILVER + fuzzy). SUGGESTION-ONLY: NU intra in resolve_prestatii/enqueue (#13).
- Stratul 3: store partajat (tabela noua `shared_mappings` sau coloana de scope pe
  `operations_mapping`), seed la confirmare umana; override per-cont.
- Validare `valid_codes` pe tot lantul (exista).

## Non-obiective

- Nu inlocuim confirmarea umana pentru cazuri incerte.
- Nu trimitem automat coduri sub prag / etichete LLM nevalidate.
- Nu adaugam dependenta cloud la RUNTIME (LLM doar offline pentru etichetare).
- Nu antrenam un LLM generativ local acum (viitor).

## Riscuri

- Etichete LLM gresite tratate ca adevar daca scapa garda F1 (seed direct in GOLD).
- Ensemble aceeasi familie (NVIDIA) -> acord corelat-gresit; supraestimare incredere.
- Strat partajat cross-account: o denumire poate insemna lucruri diferite la
  service-uri diferite -> conflict; mitigat prin override per-cont + provenienta.
- Drift: denumiri noi neacoperite; embeddings ajuta dar nu elimina.
- Free tier OpenRouter flaky (429/404, cap 50/zi) -> etichetarea bulk e lenta;
  e offline, deci tolerabil, dar nu pe calea critica de productie.
- Model embedding ales: calitate pe limba romana de verificat empiric.

<!-- AUTONOMOUS DECISION LOG -->
## Decision Audit Trail

| # | Faza | Decizie | Clasificare | Principiu | Rationament | Respins |
|---|------|---------|-------------|-----------|-------------|---------|
| 1 | Eng | Seed-ul NU intra direct in stratul auto-send; etichetele LLM = strat SILVER (sugestii). Auto-send cere GOLD (validat de om) sau treapta inalta calibrata | TASTE (critic) | P1, P5 | `resolve_prestatii`->`queued` direct => seed auto = AUTO-TRIMITERE ghiciri la FINALIZATA ireversibil (Premisa 3) | seed direct in auto-send |
| 2 | Eng | Seeder = `INSERT OR IGNORE` / refuza overwrite pe randuri validate de om | MECHANICAL | P1 | re-rularea ar clobber-ui maparile umane cu ghiciri LLM | ON CONFLICT UPDATE |
| 3 | Eng | Scrub regex (nr. inmatriculare/VIN) inainte de trimitere la LLM | TASTE | P1 | gunoiul contine `ITP CT 12 ABC` = nr. inmatriculare = PII | trimitere text brut |
| 4 | Eng | NUL = ancore negative in corpus + lista supresie | MECHANICAL | P1 | altfel gunoiul recurent reintra mereu in needs_mapping si fuzzy ii da cod gresit | exclude NUL |
| 5 | Eng | Coloana `source`/`confidence` (provenienta) pe baza de cunostinte | MECHANICAL | P1 | audit + rollback batch model prost + safe re-seed | fara provenienta |
| 6 | Eng | Runtime = embeddings + clasificator mic (sklearn), NU LLM generativ | TASTE | P3, P5 | LLM generativ local prea lent (Premisa 4); embeddings CPU suficiente + rapide | LLM la runtime |
| 8 | Eng | **SUPERSEDED:** corpus partajat cross-account (strat GOLD comun), NU per-cont izolat; override per-cont pe conflict | TASTE | P1, P2 | cerinta utilizator: validarea unui service ajuta toate; muncă compusa. Conflictul de vocabular rezolvat prin override + provenienta | (vechi: corpus strict per-cont) |
| 9 | Eng | Furnizor etichetare = OpenRouter free, ensemble NVIDIA (super-120b + nano-9b); aruncat ultra-550b | MECHANICAL | P3 | masurat 2026-06-28: doar NVIDIA routeaza fiabil; ultra 4-5x lent fara castig | Groq (cap atins) / ultra |
| 10 | Eng | Etichetare prioritizata pe frecventa + grupare pe similaritate (eticheteaza reprezentant, propaga) | MECHANICAL | P2 | acopera mult mai mult volum per apel; critic pe cap free ~50/zi | etichetare alfabetica |
| 11 | CEO | **F-A: cross-account GOLD = suggestion-only**, nu auto-send cross-cont; doar GOLD PROPRIU (validat de omul contului) auto-trimite | GATE (user) | P1 | prima-intalnire cross-cont = FINALIZATA gresit ireversibil; override per-cont e post-hoc | cross-account auto-send (PRD scris) |
| 12 | CEO | Premisa 1 (90% repeat) validata cu **temporal holdout INAINTE** de build | GATE (user) | P1 | concentrare-in-corpus != future-repeats-past; ieftin de verificat | build pe asumtie |
| 13 | Eng | **Strat SILVER in TABELA SEPARATA** (mapping_suggestions), citita DOAR de suggest_codes/pending_unmapped; NICIODATA de load_mapping/resolve_prestatii | MECHANICAL | P5,P1 | scope-column pe operations_mapping auto-trimite silver (8+ call-site); separare structurala | scope column pe operations_mapping |
| 14 | Eng | Shared store = tabela noua pe cheia `denumire_normalizata` (NU coloana pe operations_mapping: cheie diferita cod_op_service + UNIQUE) | MECHANICAL | P5 | spatii de chei diferite; conflict UNIQUE | scope column |
| 15 | Eng | **Embeddings Layer 2 RAMANE in v1** (utilizatorul a respins amanarea la gate; mentine Decision #6). Recomandarea ambelor voci era amanare la v2 | USER CHALLENGE -> override user | P3,P5 | voci: 2GB pe ipoteza nemasurata, 18 clase acoperite de exact+fuzzy. User: vrea castig pe coada RO + control infra | (amanare v2) |
| 16 | Eng | Embeddings = **IN-PROCES fastembed/ONNX** (~230MB pe disc, ONNX quantizat, fara torch; estimarea initiala de ~50MB a fost gresita — modelul multilingv `paraphrase-multilingual-MiniLM-L12-v2` are ~231MB chiar quantizat), in procesul API; model BAKED in imaginea Docker (sau volum cache) -> ZERO dependenta de retea la runtime. NU serviciu separat. Lazy-load la pornire, nu pe /healthz; worker NU incarca modelul | TASTE (user, revizuit) | P5,P3 | user: "embedding in interiorul aplicatiei, nu mai depind de alte resurse". Mai simplu + mai robust decat serviciu HTTP; ruleaza identic local si in Docker/LXC | serviciu separat Ollama/HTTP (revocat) / sentence-transformers+torch |
| 16b | Eng | **Degradare gratioasa**: daca modelul nu se incarca -> ingestia NU se blocheaza, NU auto-trimite; cade pe exact+fuzzy, incertul -> needs_mapping. Embeddings raman doar SUGESTIE (consecinta F-A), in afara verdictului de enqueue (invariant dry-run/commit, Eng-F8) | MECHANICAL | P1 | esecul incarcarii modelului nu trebuie sa rupa coada; fara retea la runtime | block ingest pe model lipsa |
| 17 | Eng | **Tier "Inalta" auto-send STERS din v1**; GOLD auto-trimite, restul (silver/NN/LLM-unanim) = needs_mapping 1-click | MECHANICAL | P1 | fara ground-truth; unanimitate same-family = eroare corelata, nu validitate | tier Inalta pe unanimitate LLM |
| 18 | Eng | sklearn classifier scos din v1 | MECHANICAL | P5 | al doilea artefact antrenabil + pickle, castig marginal pe 18 clase | sklearn in v1 |
| 19 | Eng | **Set held-out etichetat de OM = BLOCANT** pt orice tier auto-send peste GOLD propriu | MECHANICAL | P1 | "antrenare pe test" invalideaza orice precizie raportata | prag din etichete LLM |
| 20 | CEO | OpenRouter: free OK pt bootstrap unic; credit mic ($5-20) pt drift steady-state (nu arhitecta pe cap 50/zi) | TASTE | P3 | juggling free > cost credit in timp eng | totul pe free tier |

## Istoric review (pre-pivot)

Versiunea anterioara a trecut prin `/autoplan` (mod SELECTIVE EXPANSION, subagent-only,
Codex indisponibil). Constatari portante atunci: **F1 CRITIC** (seed=auto-send),
F2/F3/F4 HIGH (idempotenta seed, scrub PII, ancore NUL), F5/F6/F7/F8 MEDIUM. Acele
decizii sunt incorporate in Decision Audit Trail de mai sus. Pivotul 2026-06-28
(LLM offline-only + runtime embeddings + strat partajat cross-account) NECESITA o
noua rulare de review (CEO / Eng / Design) — de aceea sectiunea GSTACK REVIEW REPORT
e goala momentan si se completeaza la urmatoarea rulare.

## GSTACK REVIEW REPORT

Rulat prin `/autoplan` 2026-06-28 (SELECTIVE EXPANSION). Voci: Claude subagent independent
(CEO + Eng) + analiza orchestrator pe cod. **Codex INDISPONIBIL** (usage limit, reset 18 iul)
-> mod single-reviewer. UI scope: NU (editorul needs_mapping exista deja). DX scope: borderline
(CLI intern operator) -> Phase 3.5 sarit, considerente DX in Eng.

### Decizii GATE (confirmate de utilizator)
- **F-A: cross-account = suggestion-only.** Maparile validate de orice cont PRE-COMPLETEAZA
  editorul needs_mapping (1-click) dar NU auto-trimit. Doar exact-match pe GOLD-ul PROPRIU
  (validat de omul contului) auto-trimite. Elimina riscul de FINALIZATA gresit cross-tenant.
- **Premisa 1 validata cu temporal holdout INAINTE de build** (corpus primele N luni/client ->
  hit-rate exact pe lunile urmatoare). Ieftin, datele exista.

### Consens CEO (single-reviewer; Codex N/A)
| Dimensiune | Claude | Verdict |
|---|---|---|
| Premise valide | NO (P1, P5) | flagged |
| Problema corecta | PARTIAL | flagged |
| Scope calibrat | NO (over-eng) | flagged |
| Alternative explorate | NO | flagged |
| Riscuri piata | PARTIAL | flagged |
| Traiectorie 6 luni | AT RISK | flagged |

### Consens Eng (single-reviewer; Codex N/A)
| Dimensiune | Claude | Verdict |
|---|---|---|
| Arhitectura | PARTIAL | flagged |
| Acoperire teste | NO | flagged |
| Footprint/perf | NO (2GB torch) | flagged |
| Siguranta F1 | INTENT-OK | flagged |
| Cai de eroare | PARTIAL | flagged |
| Risc deploy | NO | flagged |

### Constatari portante (severitate)
- **F-A / Eng-F1 (CRITIC):** auto-send DOAR pe GOLD. Strat SILVER in TABELA SEPARATA
  (`mapping_suggestions`), citita doar de suggest_codes/pending_unmapped, NICIODATA de
  load_mapping/resolve_prestatii. `auto_send` col e moarta (mapping.py:436); singura cale
  spre `queued` (auto-send, mapping.py:414) trebuie sa fie GOLD. Separarea = structurala.
- **F-B (CRITIC):** toate masuratorile sunt ACORD (100% vs Groq, 87% unanim), nu ACURATETE
  vs ground-truth. Same-family NVIDIA = eroare corelata. Niciun tier auto-send peste GOLD
  pana nu exista set held-out etichetat de OM (esantion aleator stratificat).
- **Eng-F2 (HIGH):** shared store pe cheia `denumire_normalizata` (NU `cod_op_service`) ->
  tabela noua obligatorie; precedenta override pinnata: account override > account GOLD >
  shared GOLD > text rules > unmapped.
- **F-C / Eng-F3 (HIGH):** embeddings Layer 2 = over-engineering pe 18 clase Zipf-head.
  AMANAT v2. Daca se construieste: fastembed/ONNX (~230MB pe disc, ONNX quantizat;
  estimarea initiala de ~50MB a fost gresita), API-process-only, lazy, nu pe
  /healthz. NU in resolve_prestatii (altfel worker-ul ar avea nevoie de torch).
- **Eng-F4 (HIGH):** tier "Inalta" sters din v1 (consecinta F-A + lipsa ground-truth).
- **F-D (HIGH):** Premisa 1 nevalidata temporal -> gate (rezolvat).
- **F-E (HIGH):** fara metrica de succes/baseline/kill-criterion -> de instrumentat
  (% linii auto-rezolvate la rata cod-gresit < 0.X%).
- **MEDIUM:** NUL short-circuit inainte de suggest_codes + structura separata (Eng-F6);
  OpenRouter 429 resumabil + group radius conservator + provenance (Eng-F7); divergenta
  dry-run/commit (Eng-F8); credit mic vs free-tier (F-F); omisiune silentioasa NUL (F-G);
  calitate embedding RO de verificat (F-H); versionare cheie normalizare; drop sklearn v1.

### Teme cross-faza (semnalate independent in ambele faze)
1. Auto-send DOAR GOLD; silver/embeddings/unanimitate-LLM = sugestie (CEO F-A/F-B + Eng F1/F4).
2. Embeddings over-engineered pe 18 clase; amana sau fastembed (CEO F-C + Eng F3).
3. Fara set ground-truth; masoara precizia inainte de orice tier auto-send (CEO F-B/F-E + Eng F4).

### NU in scope (amanat)
- **sklearn classifier** peste embeddings (v2; embeddings raman doar NN suggestion in v1).
- Orice tier auto-send peste exact-match GOLD propriu (pana la set held-out).
- LLM generativ local la runtime (deja non-obiectiv PRD).
- Tier "Inalta" calibrat (re-introdus doar cu eval cross-family + ground-truth).

**Embeddings Layer 2 RAMANE in v1** (override user la gate), IN-PROCES (fastembed/ONNX,
model baked in imagine), DOAR sugestie, cu fallback gratios pe exact+fuzzy daca modelul nu
incarca. Zero dependenta de retea la runtime. Vezi audit #15/#16/#16b.

### Ce exista deja (de refolosit, nu rescris)
- `resolve_prestatii` / `classify_prezentare` / `reresolve_account` (mapping.py): precedenta
  cod direct > exact mapping > text rules > unmapped; garda valid_codes (ORA-12899).
- `suggest_codes` (rapidfuzz token_sort) + `pending_unmapped`: punct de injectie sugestii.
- `operation_text_rules` (substring) + `operations_mapping` (GOLD per-cont).
- `tools/mapare-llm/` (or_common.py, or_modeltest.py) + pattern `*-partial.json` resumabil.
- Scrub PII (F3), `normalize_for_match`, seed nomenclator (18 coduri).

### Artefact test plan
`~/.gstack/projects/romfast-rar-autopass/mmarius-main-test-plan-20260628.md`
(test F1-regression CRITIC + precedenta override + NUL + idempotenta seed + held-out eval).

### Stare review
Aprobat prin `/autoplan` (vezi Decision Audit Trail #11-20 + #16b). Plan livrabil:
v1 = Layer 1 (etichetare offline) + Layer 2 (embeddings ca SERVICIU SEPARAT configurabil,
doar sugestie, fallback gratios) + Layer 3 (GOLD propriu auto-send + shared suggestion-only)
+ exact/fuzzy existent + temporal holdout + metrica de succes + set held-out (blocant pt
orice auto-send peste GOLD). v2 = sklearn classifier (dupa masurare).
