acces email Thunderbird + tabela de provenienta la top segmente in diagnosticul de spatiu

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0113YoHU5anRC7gbtgHvE6UY

.gitignore

@@ -92,6 +92,9 @@ log.txt
 LOG.txt
 *.lnk
 Thumbs.db
+# capturi de ecran lipite din clipboard (nume GUID), nu fac parte din proiect
+{*}.png
+{*}.PNG
 Desktop.ini
 bash.exe.stackdump
 
@@ -100,6 +103,8 @@ bash.exe.stackdump
 
 # --- Notite locale neversionate (credentiale, specifice masinii) ---
 docs/local/
+docs/progres.md
+docs/diff_runda*.patch
 
 # --- Subversion (working copy paralela) ---
 .svn/

CLAUDE.md

@@ -26,24 +26,38 @@ Git rulează în paralel cu SVN-ul legacy, nu îl înlocuiește. SVN rămâne su
 
 - Repo-ul principal (rădăcina acestui folder) e propriul lui `.git`, cu remote `git@gitea.romfast.ro:romfast/roagest.git`. `.gitignore` exclude `COMUN/` (gestionat separat, vezi mai jos), `.svn/`, artefactele VFP compilate (`*.fxp`, `*.bak`, `*.mpr`, `*.exe`, …) și fișierele Windows uzuale.
 - `COMUN/` are propriul `.git` separat, cu remote `git@gitea.romfast.ro:romfast/comun.git` — **același repo partajat de toate aplicațiile ROA** (ROAACNPRO, ROAIMOB, etc.). O modificare împinsă acolo afectează toate proiectele. Nu face `push --force` peste `comun.git` fără aprobare explicită — ar șterge istoric comun tuturor proiectelor.
-- Căutarea în cod VFP binar (`.vcx`/`.scx`) pentru acest proiect folosește `vcx2txt.ps1` parametrizat pentru ROAGEST (vezi secțiunea de mai jos) — cache separat, `D:\ROA\_vfp_textcache\roagest`, nu-l amesteca cu cache-urile altor proiecte.
+- Căutarea în cod VFP binar (`.vcx`/`.scx`) pentru acest proiect folosește textul `.??2` generat în arbore, lângă fiecare binar (vezi secțiunea de mai jos) — reîmprospătat cu `git_sync.ps1 -ProjectRoot D:\ROA\ROAGEST`, nu un cache separat.
 
 ## Searching code inside `.vcx`/`.scx` (binary) libraries
 
-Most class/form code lives **inside binaries** (`.vcx`+`.vct`, `.scx`+`.sct`, …), not in `.prg`, so plain grep can't read it cleanly. To search method/procedure bodies, convert the binaries to their TEXT form first and grep the text, using the shared `foxbin2prg` tool already built at `D:\ROA\UTIL\foxbin2prg\FoxBin2Prg.EXE`:
+Most class/form code lives **inside binaries** (`.vcx`+`.vct`, `.scx`+`.sct`, …), not in `.prg`, so plain grep can't read it cleanly. Git tracks the **FoxBin2Prg text versions** of these binaries (`.vc2`/`.sc2`/`.fr2`/`.mn2`, plus `.lb2`/`.pj2`/`.dc2`/`.db2`), generated in-tree next to each binary — not the binaries themselves, which are git-ignored. Refresh with `git_sync.ps1` (folder-mode, recursive, incremental):
 
 ```powershell
-& 'D:\ROA\UTIL\foxbin2prg\vcx2txt.ps1' -Project 'D:\ROA\ROAGEST\roagest.pjx' -ProjectRoot 'D:\ROA\ROAGEST' -CacheRoot 'D:\ROA\_vfp_textcache\roagest' -Types vcx,scx,frx,mnx
+powershell -ExecutionPolicy Bypass -File D:\ROA\UTIL\foxbin2prg\git_sync.ps1 -ProjectRoot D:\ROA\ROAGEST
 ```
 
-This reads the file list straight from `roagest.pjx`, so it only converts the `.vcx`/`.scx`/`.frx`/`.mnx` this project actually references — not all of `COMUN\` (most of which is unused by any one app). It's incremental and safe to re-run after IDE edits. Output lands in `D:\ROA\_vfp_textcache\roagest\` as `.vc2`/`.sc2`/`.fr2`/`.mn2` text mirrors — `Grep` those.
+Run it **at the start of every session and before any `git commit`** so the text matches the binaries. It converts in a temp staging area and copies back only the text, continues past per-file failures, and exits nonzero on any failure: **do not commit while `git_sync` reports unexplained failures.** Then search the `.??2` files in-tree with `Grep` (e.g. `PROCEDURE do_salvare`), citing `file:line`.
 
 For `.vcx`/`.scx`, code edits no longer require the VFP IDE — the flow is now:
 
-1. Refresh the cache (`vcx2txt.ps1` above), especially if a VFP IDE session ran since the last refresh (IDE changes make the cache stale).
+1. Refresh the in-tree text (`git_sync.ps1` above), especially if a VFP IDE session ran since the last refresh (IDE changes make the text stale).
 2. Edit the `.vc2`/`.sc2` text directly (position-sensitive format — don't reflow lines; properties are alphabetized).
 3. Review the diff on the text file like any other source change.
-4. Write back with `txt2vcx.ps1` (`D:\ROA\UTIL\foxbin2prg\txt2vcx.ps1 -TextFile <path\to\file.vc2> -ProjectRoot 'D:\ROA\ROAGEST' -CacheRoot 'D:\ROA\_vfp_textcache\roagest'`) — it regenerates and recompiles the binary in a staging folder, fidelity-checks it against the edited text, then copies it into the project only if that check passes.
+4. Write back with `txt2vcx.ps1` (`D:\ROA\UTIL\foxbin2prg\txt2vcx.ps1 -TextFile <path\to\file.vc2> -ProjectRoot 'D:\ROA\ROAGEST'`) — it regenerates and recompiles the binary in a staging folder, fidelity-checks it against the edited text, then copies it into the project only if that check passes.
+
+Grep can't tell **which class/method** a hit inside a `.vc2` belongs to (the class header may be thousands of lines above it, and ~2/3 of the file is properties/metadata). `vfp_symbols.ps1` indexes the line range of every class/method/procedure and labels hits with their owner — use it before any `txt2vcx.ps1` edit to get the exact line range of the method you are changing. Its built-in defaults target ROAACNPRO, so always pass ROAGEST's paths:
+
+```powershell
+$s = 'D:\ROA\UTIL\foxbin2prg\vfp_symbols.ps1'
+$c = @('-CacheRoot', 'D:\ROA\ROAGEST', '-ProjectRoot', 'D:\ROA\ROAGEST', '-IndexFile', 'D:\ROA\_vfp_textcache\roagest\_symbols.tsv')
+
+powershell -ExecutionPolicy Bypass -File $s @c -Grep '<expresie>' -CodeOnly   # hits labeled class.method, code only
+powershell -ExecutionPolicy Bypass -File $s @c -Where '<fisier>.vc2:<linie>'  # who owns this line
+powershell -ExecutionPolicy Bypass -File $s @c -Find '<nume>'                 # where it is DEFINED
+powershell -ExecutionPolicy Bypass -File $s @c -Class '<nume_clasa>'          # inheritance chain + methods
+```
+
+The index (`_symbols.tsv`) rebuilds itself when the text is newer, so refresh the in-tree text first (`git_sync.ps1`) — it can't see IDE edits that were never converted. Full search guide: **`COMUN\docs\cautare_vcx_vct.md`**.
 
 `.mnx`/`.frx` stay **read-only** in this flow (menus still need GENMENU in the IDE; reports are too fragile to round-trip) — edit those in the VFP IDE as before. Targets under `COMUN\` need `-AllowComun` plus explicit approval, since a change there affects every ROA app. See `D:\ROA\UTIL\foxbin2prg\CLAUDE.md` for full details and `COMUN\docs\flux-editare-vfp-text.md` for the shared per-round workflow (baseline backups, review patches, fidelity check) plus the per-project parameters (including ROAGEST's).
 
@@ -112,13 +126,31 @@ ROAGEST - 2.11.5
 
 Tags in use: `:nou:` (new feature), `:modificare:` (change), `:eroare:` (bug fix), and occasionally `:adaugare:` (addition) — match this exact tag vocabulary (a lone historical `:modfiicare:` typo exists; don't repeat it). Bump the `MAJOR.MINOR.PATCH` version (currently `2.11.5`) when you add an entry. The app checks for updates on startup (`COMUN/programe/oupdate.prg`, `wwcodeupdate.prg`) against `versiune_db.txt`'s schema stamp; the runtime reads its own version from the built `.exe`'s file version resource.
 
+**Intrările sunt simple și compacte — doar strictul necesar pentru utilizatori.** O singură intrare
+consolidată per livrare (versiunea o dă Marius), fără pași intermediari, fără runde, fără mecanisme
+interne și fără erori apărute și corectate în interiorul aceleiași lucrări nelivrate.
+
 ## Mod de lucru: delegare către subagenți + review înainte de commit
 
 Preferințele lui Marius pentru sesiunile pe acest proiect:
 
 - **Orchestrare pe misiuni lungi**: niciodată un singur subagent care acumulează context pe multe sarcini înlănțuite — sesiunea principală orchestrează subagenți proaspeți per sarcină (prag: max ~200–250k tokens per subagent, apoi handoff + agent nou), cu handoff compact pe disc; regula comună tuturor proiectelor ROA: `COMUN\docs\orchestrare-subagenti.md`.
 - **Delegare**: modificările de cod de volum/rutină (aplicarea unei propuneri din `docs/propuneri_*.md`, editări pe cache-ul text + write-back, actualizări de documentație, rulări de teste) se deleagă către **subagenți Sonnet care lucrează în background** (team agents — Agent tool cu `model: sonnet`, lane-uri paralele unde e posibil), iar sesiunea principală doar orchestrează și monitorizează: împarte planul pe lane-uri, transmite constatările între agenți, verifică rezultatele (diff, teste, fidelity) și intervine direct doar la deblocări (procese agățate), decizii și verificări.
-- **Fără commit fără review**: nu da commit din proprie inițiativă pe modificări de cod — Marius vrea întâi să **vadă diff-ul**. Pentru binarele VFP (`.vcx`/`.scx`), diff-ul lizibil se face pe forma text: regenerează textul din binarul vechi (HEAD din git) cu `vcx2txt.ps1 -Source` și compară-l cu textul editat din cache (`git diff --no-index`). Commit doar după ce Marius confirmă pe diff.
+- **Fără commit fără review**: nu da commit din proprie inițiativă pe modificări de cod — Marius vrea întâi să **vadă diff-ul**. Pentru binarele VFP (`.vcx`/`.scx`), diff-ul lizibil se vede direct cu `git diff` pe textul `.vc2`/`.sc2` din arbore (rulează întâi `git_sync.ps1`, ca textul să corespundă binarelor). Commit doar după ce Marius confirmă pe diff.
+- **Curățenie înainte de commit**: se rulează `powershell -File COMUN\utile\curatenie.ps1` (`-DryRun` doar listează) — șterge patch-urile de review, handoff-urile/planurile de rundă, backup-urile `*.pre_runda*.bak` (proiect, `COMUN`, cache text) și artefactele de test (`screenshots*/`, `uisync*/`, `*.fxp`, `*.err`, loguri), sărind fișierele urmărite de git. Faptul că sunt în `.gitignore` nu le scutește: se șterg de pe disc. Abia apoi commit.
+
+## Stil de raspuns: scurt si concret
+
+Marius vrea raspunsuri **clare, concise, fara vorbarie**. Regula, nu preferinta.
+
+- **Starea si ce urmeaza, nu povestea.** Ce e gata, ce e stricat, ce trebuie decis, ce urmeaza —
+  in liste scurte, cu fisier si linie. Fara reconstituirea drumului pana la rezultat.
+- **Fara naratiune de proces**: ce a raportat fiecare agent, cine ce a corectat, cum au fost
+  coordonate benzile. Intra in `docs/`, nu in raspuns.
+- **Fara laude si fara reluari.** Nu repeta ce s-a spus deja in conversatie.
+- Detaliile tehnice lungi (dovezi, iesiri de test, metodologie) se scriu in fisier si se
+  **trimite la el**, nu se copiaza in raspuns.
+- Cand e ceva de decis: enunta decizia si optiunile in cateva randuri, cu recomandarea ta.
 
 ## Reguli de lucru si testare
 

Programe/roagest.prg

@@ -128,6 +128,7 @@ lcPath = gcAppPath + 'Date;' + ;
 	gcAppPath + 'COMUN\UTILE\HPDF\REPORTOUTPUT;' + ;			
 	gcAppPath + 'COMUN\UTILE\WEB;' + ;
 	gcAppPath + 'COMUN\UTILE\EXCEL;' + ;
+	gcAppPath + 'COMUN\UTILE\NFJSON;' + ;
 	Addbs(Substr(gcAppPath,1,Rat([\],gcAppPath,2)))+[COMUNROA\]
 	
 *!*Set Path To Date;Include;FERESTRE;GRAFICE;Help;CLASE;MENIURI;PROGRAME;RAPOARTE;PROGS;LIBS

changelog_roagest.txt

@@ -1,4 +1,33 @@
 <!--
+03/08/2026
+ROAGEST - 2.11.14
+
+:nou:
+  Registru jurnal. Numarul NIR se poate modifica direct in tabelul notei; valoarea se propaga pe toata nota si pe rulajele legate de ea.
+  Pe notele de inventar numarul NIR ramane blocat.
+
+:eroare:
+  Marfa > Achizitie import. Linia de diferenta de valoare (6xx) nu mai primeste cod de taxa SAF-T; acesta ramane doar pe liniile de baza, de TVA si de discount.
+-->
+<!--
+02/08/2026
+ROAGEST - 2.11.13
+
+:nou:
+  La alegerea partenerului se verifica codul fiscal la ANAF si se arata starea lui.
+  Verificarea apare si la achizitia din import, la finalizarea NIR-ului si la schimbarea furnizorului pe rulaj.
+-->
+<!--
+01/08/2026
+ROAGEST - 2.11.12
+
+:nou:
+  Marfa > Achizitie import. Discount financiar pe factura: TVA-ul se calculeaza pe suma diminuata, marfa ramane la valoarea integrala, discountul se inregistreaza pe 767.
+  Marfa > Achizitie import. TVA-ul de pe DVI poate avea valuta si curs proprii, diferite de ale facturii.
+  Marfa > Achizitie import. Facturile cu articole pe cote de TVA diferite se impart automat pe cote.
+  Marfa > Achizitie import. Culorile din tabelul de note grupeaza liniile pe documente: fiecare factura are culoarea si eticheta ei (F1, F2, ...), inclusiv liniile de TVA si de discount.
+-->
+<!--
 25/07/2026
 ROAGEST - 2.11.11
 

docs/CLAUDE.md

@@ -2,31 +2,30 @@
 
 ## Modificare cod VFP binar (.vcx/.scx) — flux write-back pe text
 
-Din 07.2026 Claude aplică singur modificările pe `.vcx`/`.scx` prin fluxul text→bin.
-Pașii per rundă (refresh cache, baseline `.pre_runda<N>.bak`, editare byte-safe CP1252,
-patch de review, write-back cu fidelity-check) + capcanele + parametrii per proiect (inclusiv
-ROAGEST): **`COMUN\docs\flux-editare-vfp-text.md`**.
+Claude aplică singur modificările pe `.vcx`/`.scx` prin fluxul text→bin. Pașii per rundă (refresh
+cache, baseline `.pre_runda<N>.bak`, editare byte-safe CP1252, patch de review, write-back cu
+fidelity-check) + capcanele + parametrii per proiect (inclusiv ROAGEST): **`COMUN\docs\flux-editare-vfp-text.md`**.
 
 1. Claude investighează pe cache-ul text, propune modificarea și **așteaptă acordul lui Marius
-   pe abordare** înainte să editeze.
-   La propunere/plan: scaneaza intai conventiile si functiile/clasele COMUNE existente si
-   foloseste-le cu prioritate (nu reinventa) - inventar compact: COMUN\docs\inventar-comun.md.
+   pe abordare** înainte să editeze. La propunere/plan: scaneaza intai conventiile si
+   functiile/clasele COMUNE existente si foloseste-le cu prioritate — inventar:
+   COMUN\docs\inventar-comun.md.
 2. **Commit doar după ce Marius confirmă pe diff și testează în IDE.** Editările de volum se
    deleagă la subagenți Sonnet în background; sesiunea principală orchestrează și verifică.
-3. **Teste finale obligatorii pe cerința inițială** — regulă comună tuturor proiectelor VFP,
-   pasul 6 din `COMUN\docs\flux-editare-vfp-text.md`; pe ROAGEST cu harness-ul din
-   `COMUN\utile\Teste` (`COMUN\docs\testare-ui-vfp.md`).
-4. După implementare: changelog, ștergerea fișierului de propunere/patch-ului, iar insight-urile
-   durabile se mută în notițe `docs/flux-*.md` / `docs/pachet-*.md`.
+3. **Teste finale obligatorii pe cerința inițială** — pasul 6 din
+   `COMUN\docs\flux-editare-vfp-text.md`; pe ROAGEST cu harness-ul din `COMUN\utile\Teste`
+   (`COMUN\docs\testare-ui-vfp.md`).
+4. După implementare: changelog, ștergerea fișierului de propunere/patch-ului, insight-urile
+   durabile mutate în `docs/flux-*.md` / `docs/pachet-*.md`.
 
-Excepții rămase pe VFP IDE: `.mnx` (GENMENU) și `.frx` (fragile la round-trip) — pentru ele
-rămâne valabil fluxul vechi cu fișier de propunere `docs/propuneri_<subiect>.md` aplicat de
-Marius în IDE. Când Marius a început deja o implementare, Claude compară codul lui cu originalul
-și listează explicit diferențele/cazurile netratate (nu rescrie orbește).
+Excepții pe VFP IDE: `.mnx` (GENMENU) și `.frx` (fragile la round-trip) — flux vechi cu fișier de
+propunere `docs/propuneri_<subiect>.md` aplicat de Marius în IDE. Când Marius a început deja o
+implementare, Claude compară codul lui cu originalul și listează explicit diferențele/cazurile
+netratate (nu rescrie orbește).
 
 ## Acces direct la baza de date Oracle
 
 Claude are acces read la baza de date de dezvoltare și **își face singur exporturile** de surse
-PL/SQL (pachete, view-uri) — nu se mai cer exporturi manuale. Detalii de conexiune și comanda de
-export: `COMUN\docs\oracle_export.md`. Parola: `docs/local/oracle.md` (neversionat).
-Exportul de referință `PACK_CONTAFIN.pck` stă în `COMUN\docs\` și se reîmprospătează la nevoie.
+PL/SQL (pachete, view-uri). Detalii de conexiune și comanda de export: `COMUN\docs\oracle_export.md`.
+Parola: `COMUN\docs\local\oracle.md` (neversionat în git). Exportul de referință `PACK_CONTAFIN.pck` stă în
+`COMUN\docs\` și se reîmprospătează la nevoie.

docs/README.md

@@ -1,23 +1,27 @@
 # Documentatie tehnica ROAGEST
 
-Notite concise despre structura interna a proiectului (fluxuri, pachete, tabele), descoperite in timp ce se lucreaza la sarcini concrete. Completeaza CLAUDE.md — nu il inlocuieste si nu duplica ce e deja evident din cod.
+Notite concise despre structura interna a proiectului (fluxuri, pachete, tabele), descoperite lucrand la sarcini concrete. Completeaza CLAUDE.md — nu duplica ce e deja evident din cod.
 
 ## Index
 
 - [CLAUDE.md](CLAUDE.md) — modul de lucru Claude ↔ Marius (propuneri de cod pentru VFP IDE, acces Oracle direct).
 - [flux-achizitie-import.md](flux-achizitie-import.md) — lantul achizitie import: gestiuni.vcx → achizitie_import → import_nota → import_nir → PACK_CONTAFIN; capcane (ptva bruta vs proc_tva, import_nota_original mort, 4427/401).
 - [git-svn-crlf.md](git-svn-crlf.md) — modificari fantoma in git dupa svn update (CRLF/mtime); fix cu `.gitattributes` (`* -text`) la radacina fiecarui repo.
-- `local/` — notite neversionate (credentiale Oracle etc., in .gitignore).
+- Credentialele Oracle stau in `COMUN\docs\local\oracle.md` (neversionat in git, exista in SVN).
 
-Vezi si, in `COMUN\docs\` (instructiuni general valabile pentru proiectele VFP):
-`flux-editare-vfp-text.md` (fluxul de editare pe text .vc2/.sc2 — pasi per runda, capcane,
-parametri per proiect inclusiv ROAGEST), `testare-vfp-mcp.md` (testare vizuala prin vfp9.exe
-interpretat + windows-mcp), `testare-ui-vfp.md` (harness headless pentru teste UI pe o singura
-clasa, cu screenshots), `oracle_export.md` (export surse PL/SQL, PACK_CONTAFIN.pck) si
-`scripturi-migrare-db.md` (unde stau scripturile de migrare a schemei Oracle si modelele lor).
+Vezi si, in `COMUN\docs\` (valabile pentru toate proiectele VFP): `flux-editare-vfp-text.md`
+(editare text .vc2/.sc2 — pasi per runda, capcane, parametri per proiect inclusiv ROAGEST),
+`testare-vfp-mcp.md` (testare vizuala vfp9.exe interpretat + windows-mcp), `testare-ui-vfp.md`
+(harness headless teste UI pe o singura clasa, screenshots), `oracle_export.md` (export surse
+PL/SQL, PACK_CONTAFIN.pck), `scripturi-migrare-db.md` (scripturile de migrare a schemei Oracle),
+`depanare-pack-update.md` (**procesul de depanare a actualizarii bazei de date** pe serverul unui
+client: `UPD_ISTORIC` → `UPD_LOG` → `C:\DMPDIR\script_master.log` prin `UTL_FILE`),
+`depanare-spatiu-oracle.md` (spatiu plin la clienti: tablespace, audit, alert log, FRA),
+`email-thunderbird.md` (citirea emailurilor de pe conturile romfast, cu `COMUN\utile\citeste_email.ps1`).
 
 ## Cand actualizezi
 
-Adauga sau corecteaza o notita aici ori de cate ori descoperi ceva nou si ne-evident despre structura proiectului in timpul rezolvarii unei sarcini (un flux ascuns, o capcana, o conventie, un pachet sau tabel cheie). Nu documenta ce oricine ar afla citind codul in 30 de secunde — scopul e sa scurtezi investigatii viitoare similare, nu sa duplici codul.
+Adauga/corecteaza o notita cand descoperi ceva nou si ne-evident despre structura proiectului (flux ascuns, capcana, conventie, pachet sau tabel cheie) rezolvand o sarcina. Nu documenta ce oricine ar afla citind codul in 30 de secunde — scopul e sa scurtezi investigatii viitoare, nu sa duplici codul.
 
-Organizeaza notitele in fisiere separate pe subiect (nu un singur fisier uriaș), ex: `flux-<nume-flux>.md`, `pachet-<nume-pachet>.md`, `tabele.md`.
+Fisiere separate pe subiect (nu un singur fisier uriaș): `flux-<nume-flux>.md`, `pachet-<nume-pachet>.md`, `tabele.md`.
+- [progres.md](progres.md) — fisier master de progres: de unde se reia lucrarea curenta (regula 10 din COMUN/docs/reguli_lucru.md)

docs/flux-achizitie-import.md

@@ -1,65 +1,58 @@
 # Flux: Achiziție din import (NIR import)
 
-Lanțul complet (descoperit la sesizarea „achiziție import", 07.2026):
-
 - **Intrare**: `Clase\gestiuni.vcx` (`gestiuni.vc2:2045-2171`) → meniu „Achizitie din import /
   Achizitie interna" → `DO achizitie_import WITH <id_set>, llIntern IN ointroduceri.prg`.
-  Id-uri de set: **208/209 = import**, **220/221 = intern** (perechi pe tip de operație).
+  Id-uri de set: **208/209 = import**, **220/221 = intern**.
 - **`achizitie_import`** (`COMUN\programe\ointroduceri.prg:1435-1617`):
-  - antetul facturii = `poAct` (SCATTER din `actactan`, structura din `pmenu.prg:281-307`,
-    tabelul `ACT`) — o singură pereche `id_valuta` + `curs` pe act;
+  - antetul facturii = `poAct` (SCATTER din `actactan`, structură `pmenu.prg:281-307`, tabelul
+    `ACT`) — o singură pereche `id_valuta`+`curs` pe act;
   - liniile de notă = cursorul **`introdc`** (din view `vnote_contabile` filtrat pe `id_set`),
-    fiecare rând moștenește `id_valuta`/`curs`/`dataact`/`tva_incasare` din `poAct`; rândurile merg
-    în perechi **impar = linia de bază, par = linia de TVA**;
-  - cursorul **`jtva_coloane2`** (explicații TVA, cu rând 0 gol) — sursa dropdown-ului de explicație;
-  - deschide forma **`import_nota`** (`COMUN\clase\ointroduceri.vcx`). Atenție:
-    **`import_nota_original` din același .vcx NU e instanțiat nicăieri — e copie de rezervă.**
-- **Modelul de documente**: un NIR de import = factura principală de achiziție (marfă și/sau
-  imobilizări; valuta/cursul ei = `poAct.id_valuta`/`poAct.Curs`, referința de conversie) + opțional
-  factura de transport (poate fi altă valută/curs) + opțional factura de taxe vamale + DVI
-  (declarația vamală, cu TVA-urile fiecărei facturi, plătite în lei). Toate devin linii în `introdc`,
-  apartenența la document fiind per rând: `nract`/`serie_act`/`id_fact` (rândurile au și `id_valuta`/
-  `curs` proprii, dar istoric codul folosește doar `poAct.Curs`).
-- **`import_nota`** (nota contabilă a facturii): grila pe `introdc`; transport/alte taxe se introduc
-  ca linii de notă suplimentare cu flagurile `in_valuta` (suma e în valută) și `participa_valuta`
-  (linia intră în valoarea de intrare a mărfii). `do_executa` calculează procentele de repartizare
-  (stocate în `explicatia4`/`explicatia5`); `inainte_de_do_termin` sumează bazele
-  (lei/valută, liniile în lei se împart la `poAct.Curs`) și lansează **`import_nir`** cu
-  `procent_lei/procent_val/ncurs`.
-- **`import_nir`** (grila de articole): `do_adauga` → `viz_catalog_articole()`
-  (`oproceduri_articole.prg:62`, câmpul `in_stoc` = „Gestionabil") filtrat pe conturile `scd` din
-  notă; prețul de intrare per articol = preț valută × `procent_val`, apoi × `ncurs` × `procent_lei`
-  (transportul „umflă" procentele peste 100). Diferența reziduală devine linia „DIFERENTE".
-  `do_modiparam` = preluare articole din XLS (creează articole noi prin `pack_preturi.adauga_articol`,
-  cont implicit 371).
-- **Salvare**: `oscrie_in_fisiere` → tabelele temporare `ACT_TEMP`/`RUL_TEMP` → pachetul Oracle
-  **`PACK_CONTAFIN`** (`SCRIE_IN_ACT`, `SCRIE_IN_RUL`, `SCRIE_IN_STOC`, …). `SCRIE_IN_RUL` inserează
-  în `RUL` **exact** conținutul `RUL_TEMP` (nu derivă din ACT) — orice filtrare de rulaje se face în
-  clientul VFP. Sursa pachetului: `COMUN\docs\PACK_CONTAFIN.pck` (vezi `COMUN\docs\oracle_export.md`).
-- **Articole negestionabile** (`nom_articole.in_stoc = 0`): modelul canonic e în clasa **`nir`**
-  (NIR-ul obișnuit, același `ointroduceri.vcx`), mecanism din 2009 — articolul intră normal în grilă
-  și participă la calcule, iar în `inainte_de_do_termin`, chiar înainte de scriere, se face
-  `Delete From rul_temp Where in_stoc = 0` (valoarea rămâne doar pe nota contabilă, nu ajunge în
-  `RUL`/`STOC`). Din v2.11.6 `import_nir` e aliniat la același model, cu un cursor temporar
-  (`crsNegest`) care readaugă rândurile șterse în grilă dacă `oscrie_in_fisiere` eșuează.
-  Cursorul `rul_temp` are coloana `in_stoc` pentru că e creat din view-ul `vrul` (`where 1=2`);
-  la `do_adauga` coloana se umple prin `GATHER NAME loArt` din cursorul catalogului, la
-  `do_modiparam` (XLS) explicit din selectul pe `nom_articole`.
-- **Explicație TVA**: dropdown istoric `Grid1.cExplicatieTva.Combo1` (RowSource `jtva_coloane2`);
-  modelul alternativ cu formular de căutare = `frm_modific2024.do_modifica_explicatie_tva`
-  (`omodificari.vcx`) → `caut_explicatie_tva()` (`ocautare.prg:1934`, view `vjtva_coloane`,
-  întoarce DOAR `id_jtva_coloana, denumire, cota_tva`). Capcane: în `introdc.ptva` se ține **cota
-  brută** (21), pe când în registru jurnal `proc_tva` = (cota+100)/100; comutarea 4427/401 pe linia
-  de TVA se face prin SEEK în cursorul `cJtvaCol4427`.
+    fiecare rând moștenește `id_valuta`/`curs`/`dataact`/`tva_incasare` din `poAct`; rândurile
+    merg în perechi **impar = linia de bază, par = linia de TVA**;
+  - cursorul **`jtva_coloane2`** (explicații TVA, rând 0 gol) = sursa dropdown-ului de explicație;
+  - deschide forma **`import_nota`** (`COMUN\clase\ointroduceri.vcx`). **`import_nota_original`**
+    din același .vcx NU e instanțiat nicăieri — copie de rezervă.
+- **Modelul de documente**: un NIR de import = factura principală (marfă și/sau imobilizări;
+  valuta/cursul ei = `poAct.id_valuta`/`poAct.Curs`, referința de conversie) + opțional factură de
+  transport (poate fi altă valută/curs) + opțional factură de taxe vamale + DVI (TVA-urile fiecărei
+  facturi, plătite în lei). Toate devin linii în `introdc`, apartenența pe document = per rând
+  (`nract`/`serie_act`/`id_fact`; rândurile au și `id_valuta`/`curs` proprii, dar codul istoric
+  folosește doar `poAct.Curs`).
+- **`import_nota`**: grilă pe `introdc`; transport/taxe = linii de notă suplimentare cu flagurile
+  `in_valuta` (suma e în valută) și `participa_valuta` (linia intră în valoarea de intrare a
+  mărfii). `do_executa` calculează procentele de repartizare (`explicatia4`/`explicatia5`);
+  `inainte_de_do_termin` sumează bazele (liniile în lei se împart la `poAct.Curs`) și lansează
+  **`import_nir`** cu `procent_lei/procent_val/ncurs`.
+- **`import_nir`**: `do_adauga` → `viz_catalog_articole()` (`oproceduri_articole.prg:62`, câmp
+  `in_stoc`="Gestionabil") filtrat pe conturile `scd` din notă; preț de intrare = preț valută ×
+  `procent_val`, apoi × `ncurs` × `procent_lei` (transportul „umflă" procentele peste 100).
+  Diferența reziduală → linia „DIFERENTE". `do_modiparam` = preluare articole din XLS (creează
+  articole noi prin `pack_preturi.adauga_articol`, cont implicit 371).
+- **Salvare**: `oscrie_in_fisiere` → `ACT_TEMP`/`RUL_TEMP` → pachet Oracle **`PACK_CONTAFIN`**
+  (`SCRIE_IN_ACT`, `SCRIE_IN_RUL`, `SCRIE_IN_STOC`). `SCRIE_IN_RUL` inserează în `RUL` **exact**
+  `RUL_TEMP` (nu derivă din ACT) — filtrarea de rulaje se face în clientul VFP. Sursă pachet:
+  `COMUN\docs\PACK_CONTAFIN.pck` (`COMUN\docs\oracle_export.md`).
+- **Articole negestionabile** (`nom_articole.in_stoc=0`): model canonic în clasa **`nir`** (NIR
+  obișnuit) — articolul intră normal în grilă, iar `inainte_de_do_termin` face
+  `Delete From rul_temp Where in_stoc=0` (valoarea rămâne doar pe nota contabilă). Din v2.11.6
+  `import_nir` e aliniat la același model, cu cursor temporar `crsNegest` care readaugă rândurile
+  șterse în grilă dacă `oscrie_in_fisiere` eșuează. `rul_temp` are coloana `in_stoc` din view-ul
+  sursă `vrul`; la `do_adauga` se umple prin `GATHER NAME loArt`, la `do_modiparam` (XLS) din
+  select pe `nom_articole`.
+- **Explicație TVA**: dropdown `Grid1.cExplicatieTva.Combo1` (RowSource `jtva_coloane2`); variantă
+  cu căutare = `frm_modific2024.do_modifica_explicatie_tva` (`omodificari.vcx`) →
+  `caut_explicatie_tva()` (`ocautare.prg:1934`, view `vjtva_coloane`, întoarce DOAR
+  `id_jtva_coloana, denumire, cota_tva`). Capcane: `introdc.ptva` ține **cota brută** (21), în
+  registru jurnal `proc_tva`=(cota+100)/100; comutarea 4427/401 pe linia de TVA = SEEK în
+  `cJtvaCol4427`.
 
-Căutarea generică: `cauta_alfa()` (`COMUN\programe\cauta_alfa.prg`) → forma `cauta_alfa_form_plus`.
+Căutare generică: `cauta_alfa()` (`COMUN\programe\cauta_alfa.prg`) → forma `cauta_alfa_form_plus`.
 
-## Structura reală a șablonului `vnote_contabile` (verificat 11.07.2026)
+## Șablon `vnote_contabile`
 
-Cursorul `introdc` NU pornește cu „2 linii" — se încarcă cu **toate** perechile-șablon din
-`vnote_contabile` pentru `id_set`. Numărul de linii pe baza de dev (`MARIUSM_AUTO`):
-**208 = 10 linii, 209 = 10, 220 = 10, 221 = 6**. Cele 10 linii ale setului de import (208) =
-**5 perechi pre-alocate (bază+TVA) = 5 sloturi de document**:
+Cursorul `introdc` NU pornește cu „2 linii" — se încarcă cu toate perechile-șablon din
+`vnote_contabile` pentru `id_set`. Pe dev (`MARIUSM_AUTO`): **208=10 linii, 209=10, 220=10,
+221=6**. Cele 10 linii ale setului 208 = **5 perechi pre-alocate (bază+TVA) = 5 sloturi**:
 
 | Pereche (ordine) | SCD/SCC bază | SCD/SCC TVA | Ce e |
 |---|---|---|---|
@@ -69,91 +62,187 @@ Cursorul `introdc` NU pornește cu „2 linii" — se încarcă cu **toate** per
 | 4 (7-8) | 3028/446 | 4426/446 | vamă/DVI (pe dev) |
 | 5 (9-10) | 3028/446 | 4426/446 | slot repetat (gol) |
 
-Model CONT2000: în loc să adaugi rânduri, ai **sloturi goale pre-alocate** pe care le completezi.
-Factura principală = perechea 1 (2 linii); restul sunt sloturi pentru facturi suplimentare (3 marfă)
-+ DVI (2). Un „document" = o pereche cu date.
+Model CONT2000: sloturi goale pre-alocate, nu rânduri adăugate. Factura principală = perechea 1;
+restul = sloturi pentru facturi suplimentare (3 marfă) + DVI (2). Un „document" = o pereche cu date.
 
-**Corecție importantă (Marius, verificat pe bază reală de producție):** conturile 446 din setul 208
-de pe dev **NU sunt reprezentative**. În realitate și DVI-ul vamă folosește **4426 = 401** (nu 446).
-`vnote_contabile` e **configurabil per firmă**, deci șablonul variază — nu hardcoda conturile, ci
-clonează perechea-șablon reală a setului. Practic: **un singur pattern de conturi** (bază 3028/401 +
-TVA 4426/4427 sau 4426/401) acoperă și marfă, și DVI (DVI diferă doar prin partener/unde e plătit
-TVA, nu prin conturi).
+**Conturile 446 din setul 208 de pe dev NU sunt reprezentative** — pe producție DVI-ul vamă
+folosește **4426=401** (nu 446). `vnote_contabile` e configurabil per firmă, nu hardcoda conturile:
+clonează perechea-șablon reală a setului (un singur pattern 3028/401 + 4426/4427 sau 4426/401
+acoperă și marfă și DVI — DVI diferă doar prin partener/unde e plătit TVA).
 
-## DECIZIE 11.07.2026 — pivot la „Direcția A" (rescriere flux introducere)
+## Plan: pivot la „Direcția A" (rescriere flux introducere, scop M2, neimplementat)
 
-Marius a decis să se **abandoneze modelul cu 10 sloturi pre-alocate**. Noul model (de implementat
-într-o sesiune viitoare, e scop **M2**, mai mare decât runda 1 M1/M3/M6):
+Model țintă, abandonează cele 10 sloturi pre-alocate:
 
-1. **`achizitie_import`**: `introdc` pornește **gol** (0 rânduri de document); se păstrează perechea-
-   șablon (bază+TVA, cu conturile reale din `vnote_contabile` ale setului) ca **sursă de clonare**.
-   Nu se mai încarcă cele 10 sloturi.
-2. **Buton „Adaugă factură" + dialog (M2)**: clonează perechea-șablon, o completează cu datele
-   facturii, o adaugă în `introdc`. Se folosește **și pentru factura principală**, și pentru DVI
-   (radio-ul furnizor/DVI/fără schimbă doar partenerul/unde e plătit TVA, nu conturile).
-3. **M1 (culori)**: rămâne cum e — fiecare factură adăugată = o pereche = un document = o culoare
-   (F1, F2, …), incremental, cheie `serie+nr+id_fdoc`. Codul M1 deja aplicat merge neschimbat pe
-   acest model.
+1. `achizitie_import`: `introdc` pornește **gol**; se păstrează perechea-șablon (bază+TVA, conturi
+   reale din `vnote_contabile`) doar ca sursă de clonare.
+2. Buton „Adaugă factură" + dialog: clonează perechea-șablon, o completează, o adaugă în
+   `introdc`. Folosit și pentru factura principală, și pentru DVI (radio-ul furnizor/DVI/fără
+   schimbă doar partenerul/unde e plătit TVA, nu conturile).
+3. M1 (culori) rămâne neschimbat: fiecare factură adăugată = o pereche = un document = o culoare
+   (F1, F2, …), cheie `serie+nr+id_fdoc`.
 
-Avertismente: atinge `COMUN` (blast radius: 22 `.pjx` referă `ointroduceri`) și **schimbă
-comportamentul pentru toți userii de import** (nu mai văd sloturi pre-completate) — testare atentă,
-dare în funcțiune deliberată.
+Atinge `COMUN` (22 `.pjx` referă `ointroduceri`) și schimbă comportamentul pentru toți userii de
+import (nu mai văd sloturi pre-completate) — testare atentă.
 
-## Model curent `import_nota` (după rundele 8–12, 07.2026, necomis)
+## Model curent `import_nota`
 
-- **`doc_key` e unic per document**: prefix `nr_doc` (contor intern) + câmpurile de business
+- **`doc_key` unic per document**: prefix `nr_doc` (contor intern) + câmpuri business
   (`calc_doc_key`). Rândul T al unei facturi cu TVA pe DVI poartă câmpurile vamei
-  (partener/nract/4426) dar **păstrează doc_key-ul facturii-mamă** — identitatea nu se mai
-  amestecă între documentele care partajează același nr. DVI (cauza istorică a: explicație TVA
-  scrisă pe T-ul altui document, suma T=0, ștergere în grup, propagare `copiaza_valoare` între
-  documente străine).
+  (partener/nract/4426) dar **păstrează doc_key-ul facturii-mamă** — identitatea nu se amestecă
+  între documente care partajează același nr. DVI.
 - **Spargerea principalei** (`sparge_document`/`creeaza_rand_s`): grupare `rul_temp` pe
   `cont+acont`; analiticul articolului merge direct în `ascd` al rândului S (fallback
   `assign_analitic` doar când nu e furnizat).
-- **Procentele per rând** (`explicatia4`/`explicatia5` = coloanele "Procent lei/valuta"): scrise
-  de `sincronizeaza()` după spargere (nu de `do_executa`, care nu mai scrie procente), numitor =
-  baza documentului principal (`This.nbazaprincipala_lei/_val`, calculate în `recalculeaza`).
-  Principala = 100.00; celelalte = pondere lei și valută (convertit la `oact.Curs` dacă e în lei).
+- **Procentele per rând** (`explicatia4`/`explicatia5` = „Procent lei/valuta"): scrise de
+  `sincronizeaza()` după spargere (nu de `do_executa`), numitor = baza documentului principal
+  (`This.nbazaprincipala_lei/_val`, din `recalculeaza`). Principala=100.00; celelalte = pondere
+  lei/valută (convertit la `oact.Curs` dacă e în lei).
 - **Ștergere/copiere**: `do_sterge` = meniu Da(document, pe doc_key)/Nu(doar linia)/Cancel;
-  `do_copiaza_nota` (buton „Copiază") = același meniu; copiază doar B+T cu `nr_doc`/`doc_key`
-  noi (S/D se regenerează la sincronizare). Capcană rezolvată acolo: `Calculate` mută pointerul
-  la EOF → poziția sursă se salvează/restaurează înainte de `Scatter`.
-- **Rândul TOTAL** de sub grila notelor: `TxtFtvaLei`/`TxtFtvaVal` (fără TVA) lângă
-  `Text2`/`Text3` (cu TVA), setate în `actualizeaza_banda`.
-- **Test e2e de referință**: `COMUN\utile\Teste\test_scenariu_dvi_complet.prg` (scenariul complet
-  cu 3 documente pe același DVI + articole 212/1 și 371/4 + ștergere/copiere).
-- **Valori manuale protejate (r16)**: `mod_manual=1` se setează și pe rândul T (Valid-urile
-  `cSuma`/`cSumaVal`); `do_executa` nu rescrie T manual, `sparge_document` nu-l șterge și nu
-  creează duplicat pe aceeași cotă (`ptva`). Nimic nu resetează `mod_manual` pe rând existent.
-- **`nOldVal` unic (r15)**: o singură proprietate pentru valoarea la intrarea în celulă
-  (GotFocus) — Valid/LostFocus ies devreme la valoare nemodificată (`cSuma`, `cSumaVal`,
-  `cCotaTva`, `cPretFactura`). `do_calculeaza_diferente` restaurează poziția `rul_temp` de la
-  intrarea în procedură (`tnRecNo` nu mai poziționează); `do_reface` repoziționează explicit.
-- **Totaluri articole (r17)**: `_grdfooter1` (clasa `_grdfooter` din `_grd_base.vcx`) atașat la
+  `do_copiaza_nota` (buton „Copiază") = același meniu; copiază doar B+T cu `nr_doc`/`doc_key` noi
+  (S/D se regenerează la sincronizare). `Calculate` mută pointerul la EOF → poziția sursă se
+  salvează/restaurează înainte de `Scatter`.
+- **Rândul TOTAL** sub grila notelor: `TxtFtvaLei`/`TxtFtvaVal` (fără TVA) lângă `Text2`/`Text3`
+  (cu TVA), setate în `actualizeaza_banda`.
+- **Test e2e de referință**: `COMUN\utile\Teste\test_scenariu_dvi_complet.prg` (3 documente pe
+  același DVI + articole 212/1 și 371/4 + ștergere/copiere).
+- **Valori manuale protejate**: `mod_manual=1` se setează și pe rândul T (Valid-urile
+  `cSuma`/`cSumaVal`); `do_executa` nu-l rescrie, `sparge_document` nu-l șterge/duplică pe aceeași
+  cotă (`ptva`). Nimic nu resetează `mod_manual` pe rând existent.
+- **`nOldVal` unic**: o singură proprietate pentru valoarea la GotFocus — Valid/LostFocus ies
+  devreme la valoare nemodificată (`cSuma`, `cSumaVal`, `cCotaTva`, `cPretFactura`).
+  `do_calculeaza_diferente` restaurează poziția `rul_temp` de la intrare; `do_reface`
+  repoziționează explicit.
+- **Totaluri articole**: `_grdfooter1` (clasa `_grdfooter` din `_grd_base.vcx`) atașat la
   `GridArt` la finalul `Init`; sume pe `cValoareValutaFactura`/`cValoareValutaCalculat`/
   `cValoareLeiCalculat` din `rul_temp`, recalculate în `actualizeaza_banda` +
-  `do_calculeaza_diferente`. Vechile `Clb_leiftva/leitva/valftva/valtva` (dublau totalurile
-  notelor) au fost eliminate de pe `import_nota`. Totalurile de sub grila notelor rămân din
-  `introdc`; Diferențe lei = bază note − Σ articole.
-- **Test scenariul TVA manual + footer**: `COMUN\utile\Teste\test_manual_tva_footer.prg`.
-- **TVA pe creditori și la secundare (r30)**: `sparge_document` regrupează T-urile nemanuale ale
+  `do_calculeaza_diferente`. Totalurile de sub grila notelor rămân din `introdc`; Diferențe lei =
+  bază note − Σ articole.
+- **Test TVA manual + footer**: `COMUN\utile\Teste\test_manual_tva_footer.prg`.
+- **TVA pe creditori și la secundare**: `sparge_document` regrupează T-urile nemanuale ale
   documentelor secundare pe creditorii (scc/ascc) rândurilor S proprii, proporțional cu sumele S
   (conservă totalul T, inclusiv TVA tastat la DVI); `recalc_tva_document` aplică aceeași pondere
   (fără S-uri: împărțire egală 1/N); `uneste_document` reunește T-urile sparte când documentul
-  revine la B. Armarea resincronizării din `cScc/cAscc.Valid` se face pe garda `nOldVal` (nu pe
-  comparația cu câmpul — grila poate scrie câmpul înaintea Valid-ului, ex. Enter) + gardă `lInSync`
-  contra Valid-urilor re-declanșate de regenerare. Test: `COMUN\utile\Teste\test_tva_secundare.prg`.
+  revine la B. Resincronizarea din `cScc/cAscc.Valid` se armează pe garda `nOldVal` (nu pe
+  comparația cu câmpul — grila poate scrie câmpul înaintea Valid-ului, ex. Enter) + gardă
+  `lInSync` contra Valid-urilor re-declanșate de regenerare. Test:
+  `COMUN\utile\Teste\test_tva_secundare.prg`.
+- **Rândul D (diferență 6xx)** e clonat prin `Scatter`/`Gather` din rândul de bază, deci
+  `recalc_diferente` trebuie să golească explicit tot ce ține de TVA: `id_jtva_coloana`, `ptva`,
+  `cu_tva` și `taxcode` (cod SAF-T). Codul de taxă stă doar pe liniile de bază, TVA și discount.
+  `oscrie_in_fisiere.prg:260` scrie `NULL` în `ACT` pentru `taxcode` gol.
 
-## Ștergere note — model istoric pe paritate (înlocuit de rundele de mai sus)
+## TVA DVI cu valută proprie + discount financiar
 
-- Butonul `But_sterge1` (clasa `but_sterge`) șterge nota curentă = **perechea bază+TVA**, de pe
-  oricare din cele două linii (`lnBaza = Recno() - Iif(Mod(Recno(),2)=0,1,0)`, apoi `Delete Next 2`).
-  Dispatch-ul butonului trece prin `inainte_de_do_sterge`, condiționat de `lactiv4` — setat `.T.`
-  în `Init`.
-- Ștergerea e **logică**, nu fizică: `SET DELETED ON` (roagest.prg:28) ascunde perechea din grid și
-  din toate `Scan`/`Sum`-urile fluxului, iar Recno-urile rămase nu se schimbă → paritatea impar/par
-  se păstrează (perechile se șterg mereu împreună, deci și `Skip`-urile peste liniile șterse cad
-  corect). `Append Blank` ulterior continuă tot pe paritate corectă.
-- **Capcană generală VFP: niciodată `ZAP` (sau închidere/recreare) pe cursorul-sursă al unui
-  grid** — Zap închide și recreează cursorul, grid-ul își pierde sursa și rămâne blank. Varianta
-  „copiez rândurile rămase + Zap + Append la loc" e greșită exact din acest motiv.
+- **Două coloane client-side pe `introdc`** (fără migrare Oracle): `rand_dvi` (identitate — 1 pe
+  rândul T scris de ramura DVI a `do_adauga_factura`) și `valuta_proprie` (1 când acel rând T are
+  valută/curs diferite de ale documentului, setat la creare sau din grilă). Nu s-a refolosit
+  `mod_manual` — e supraîncărcat semantic (`sparge_document` face match pe el pentru alte
+  scopuri, ar da duplicate/omisiuni de rânduri T).
+- **Rând „protejat"** = `Nvl(valuta_proprie,0)=1` (helper `Thisform.rand_protejat()`). Ocolit de
+  `copiaza_valoare` (câmpurile valutare nu se propagă pe el, câmpurile de identitate nu se propagă
+  pe orice rând `rand_dvi=1`), `do_executa`, `recalc_tva_document`, `uneste_document`,
+  `sparge_document` și handlerele de grilă `cCurs`/`cInValuta`/`cValuta` (editare locală, fără
+  propagare). Re-alegerea valutei documentului pe rândul protejat resetează `valuta_proprie=0`
+  (revert). Un DVI cu valuta facturii rămâne `valuta_proprie=0` și urmează factura la propagări.
+- **Spargerea T-ului protejat** (`sparge_tva_protejat`, din `sparge_document`): când TOATE
+  rândurile T ale documentului sunt protejate, TVA-ul facturii e integral cel de pe DVI — nu se
+  fabrică rânduri T din rândul de bază. Varianta `loRandT = loBaza` dădea TVA dublă (rândul
+  protejat rămânea, plus un T nou cu conturile bazei în valuta facturii). Acum totalul protejat se
+  sparge pe cotele articolelor (pondere `bază_cotă × cotă`, rest de rotunjire pe |suma| maximă),
+  păstrând prin `Gather` identitatea vamală/valuta proprie/`rand_dvi`/`valuta_proprie`. O singură
+  cotă = niciun rând atins.
+- **Discount financiar pe factură**: un rând `tip_rand='G'` (401=767, suma=discount fără TVA),
+  același `doc_key`/`nr_doc` cu factura, `participa_valuta=.F.`. Marfa (3028) și prețurile
+  articolelor rămân la valoarea integrală — discountul schimbă doar baza TVA: `T=(b-d)*p/100`,
+  sold 401 = `b + (b-d)*p/100 - d`. Ordine la creare: B → G → T. Excluse din bazele
+  TVA/diferență/spargere prin filtrele deja existente pe `Inlist(tip_rand,'B','S')`/`'T'` — un
+  singur loc nu filtra pe `tip_rand` (suma valută din footer, `do_executa`), a primit
+  `And tip_rand<>'G'`. Punct unic de adevăr: `disc_document(doc_key, tlValuta)`. Se scade DIRECT
+  în `do_executa`/`recalc_tva_document` (același `doc_key`), dar se REPARTIZEAZĂ prin factor în
+  `sparge_document` (bazele vin din `crsGrupCota`, nu din `suma_doc`). Factorul e clampat la 0
+  (discountul poate depăși baza articolelor când rămâne rest pe rândul de diferențe → altfel TVA
+  negativă). `suma_doc`/`suma_doc_val` rămân BRUTE (`sparge_document` repartizează toată baza pe
+  S, `verifica_sincronizare` compară `Suma(S)` cu `suma_doc`). `do_adauga_factura` citește
+  `toDlg.disc_baza_lei` sub gardă `Type(...)<>'U'` — apelabil programatic cu `toDlg` minimal
+  (import e-Factura/XLS). Limită cunoscută: rândurile create ulterior de
+  `sparge_document`/`recalc_tva_document` se adaugă la finalul cursorului — ordinea vizuală B/G/T
+  nu mai e garantată (grila nu are sortare).
+- **Bifa „Valuta" pe secțiunea TVA DVI** (`chkDviInValuta`): pornește după factură (bifată când
+  factura e în valută), rămâne pe alegerea manuală prin `ldviinvalutadirty` (ca `linvalutadirty`
+  la bază). Scoasă → ascunde valuta/cursul/TVA-ul valutar al DVI, forțează `nDviCurs=1`,
+  `nDviTvaVal=0`. Ramura din `recalc_tva` trebuie să includă bifa, nu doar
+  `dvi_valuta_efectiva()` (întoarce valuta facturii, nu știe de bifă — fără ea se scrie
+  `dvi_tva_val` nenul cu `dvi_in_valuta=.F.`). „Factură în valută, DVI doar în lei" dă
+  `dvi_valuta_proprie=1`.
+- **Concordanța cotelor pe factură multi-cotă**: rândurile S se generează pe
+  `cont+analitic+cota_tva` (doar la documentul principal), primesc cota articolelor —
+  `creeaza_rand_s` are parametrul `tnCota`, scrie `ptva`+`id_jtva_coloana`/`explicatie_tva` prin
+  `gaseste_jtva_cota` (familia = coloana bazei). Rândul G se sparge la fel, proporțional pe bazele
+  pe cotă (`sparge_discount`, din `sparge_document` după `calc_baze_cota_creditor`), păstrând
+  totalul discountului; idempotentă. Fără astea, baza (S) și discountul (G) rămâneau pe cota
+  facturii în timp ce T-urile erau deja sparte pe cotele articolelor — jurnalul de TVA ieșea cu
+  baza pe altă cotă decât TVA-ul. Articolele fără cotă proprie preiau cota documentului înainte de
+  grupare.
+- **`nOldVal` e NUMERIC**: coloanele caracter din grilă (`cScc`/`cAscc`) folosesc `cOldVal`. O
+  singură proprietate partajată dădea „Operator/operand type mismatch" în `cSuma.Text1.Valid`
+  când Valid se re-declanșa fără GotFocus. `cSuma`/`cSumaVal.Valid` au primit și garda `lInSync`.
+- **Două reprezentări ale „RON"**: rândul din picker (`caut_valuta`/`vnom_valute`) e REAL cu
+  `id_valuta` nenul (`moneda_nationala=1`); sentinela „fără valută" din `introdc`/`ACT` e
+  `id_valuta=0`, `nume_val=''`. Comparațiile trebuie pe valuta EFECTIVĂ
+  (`Empty(nume) Or Upper(nume)=='RON'`), nu pe id brut — altfel `dvi_valuta_proprie` ar da fals 1.
+- **`copiaza_valoare` și rândul DVI — gardă în ambele sensuri**: rândul T al DVI păstrează
+  `doc_key`-ul facturii-mamă, deci propagarea pe grup îl include. Trebuie sărit ca țintă
+  (identitatea facturii nu-l atinge) și ca sursă (numărul/data/partenerul vamal nu ajung pe
+  factură) — fără garda pe sursă, o trecere prin celula „Nr" a rândului DVI scria numărul DVI
+  peste toată factura (B/G/S) și, la Terminat, în `ACT`/`RUL.nract`. Rândul D scapă (își moștenește
+  antetul o singură dată, la creare). `copiaza_valoare` nu face refresh de grilă — coruperea e
+  invizibilă până la salvare. Propagarea de partener are flux propriu
+  (`Grid1.cPartC.Text1.Valid`), aceeași gardă.
+- **`ControlSource` calificat la runtime**: `This.Parent.ControlSource` întoarce `introdc.nract`,
+  nu `nract`. Orice `Inlist`/comparație pe nume de câmp cu valoarea din Valid-urile de grilă
+  trebuie să normalizeze întâi (taie prefixul până la ultimul punct) — altfel garda arată corect
+  scrisă și nu se activează niciodată. Test:
+  `COMUN\utile\Teste\achizitie_import\test_diag_controlsource_calificat.prg`.
+- **Rebindarea unei coloane de grilă din `Init`**: VFP califică `Column.ControlSource` cu aliasul
+  o singură dată, la legarea grilei; o atribuire ulterioară rămâne exact cum a fost scrisă. Un nume
+  de câmp necalificat se afișează și se scrie programatic corect, dar celula nu acceptă tastare.
+  Atribuie mereu `This.<grid>.RecordSource + ".<camp>"`. Test:
+  `COMUN\utile\Teste\achizitie_import\test_repro_pret_lei_intern.prg`.
+
+## Ștergere note — model VECHI pe paritate, înlocuit de `doc_key`
+
+- `But_sterge1` (clasa `but_sterge`) șterge perechea bază+TVA curentă, de pe oricare linie
+  (`lnBaza = Recno() - Iif(Mod(Recno(),2)=0,1,0)`, apoi `Delete Next 2`), prin
+  `inainte_de_do_sterge` sub `lactiv4` (`.T.` în `Init`).
+- Ștergere logică (`SET DELETED ON`, `roagest.prg:28`) — Recno-urile rămân, paritatea impar/par
+  se păstrează.
+- Capcană generală VFP: niciodată `ZAP`/recreare pe cursorul-sursă al unui grid — grid-ul își
+  pierde sursa și rămâne blank.
+
+## Explicații TVA pe factură multi-cotă
+
+- **Perechea bază/TVA din nomenclator** (`jtva_coloane2.id_tva`); trecerea între cote în aceeași
+  familie = pe **semnătura coloanei** (`coloana_jc` fără cifre: `FO21B`→`FOB`, `FO21T`→`FOT`,
+  `gaseste_jtva_cota`). Potrivirea pe primele 2 caractere confunda baza cu TVA.
+- **Alinierea T → S** (`aliniaza_tva_la_baza`, final `sparge_document`): fiecare T primește
+  perechea de TVA a S-ului de aceeași cotă, doar dacă explicația S-ului chiar are cota rândului.
+  Fără ea, o explicație din altă serie pe S (ex. `CE11CTB`) muta T-urile în seria CE, în timp ce
+  S se re-alinia la familia documentului (`FO`) la resincronizare.
+- **`expl_manual`** (coloană client-side, lângă `mod_manual`): 1 când utilizatorul alege explicit
+  explicația pe un rând T; rândurile marcate nu se aliniază. Nu s-a refolosit `mod_manual`
+  (înseamnă „nu recalcula suma", ar fi înghețat și sumele). Peste regenerarea T-urilor eticheta se
+  păstrează prin snapshot pe cotă (`crsExplT`, luat înainte de ștergere, reaplicat după); la
+  `sparge_tva_protejat` rămâne doar pe cota rândului original.
+- **Gol de nomenclator la 11%**: importul de bunuri nu avea perechea 11% (`FO11B`/`FO11T` =
+  236/237, adăugate 30.07.2026). Fără pereche, `sparge_document` lasă în `cmesajsync` „Documentul
+  <fdoc> are marfă la <cotă>%, dar nu există explicație TVA de <cotă>% în seria '<serie>'" și
+  finalizarea rămâne blocată; utilizatorul poate ocoli alegând manual o explicație de 11% din altă
+  serie.
+- **`tlIntern` în `achizitie_import`**: `Createobject('IMPORT_nota', tlIntern)` primește
+  parametrul, dar codul din clasă citește `Thisform.lIntern` — o referință la `tlIntern` dintr-o
+  metodă a formularului prinde variabila PRIVATE a apelantului doar cât timp acesta e pe stivă
+  (în `inainte_de_do_termin` era deja ieșit).
+- **Fixture-uri de test**: cele 32 de teste din `COMUN\utile\Teste\achizitie_import` își creează
+  `introdc` prin `CREATE CURSOR` — orice coloană nouă folosită în SQL-ul din clasă trebuie
+  adăugată și acolo, altfel „SQL: Column '<X>' is not found".

docs/git-svn-crlf.md

@@ -6,10 +6,9 @@ desi continutul e identic.
 Cauza: SVN scrie CRLF nativ si atinge mtime la fiecare update; `core.autocrlf=true`
 face git sa (re)verifice/converteasca EOL-urile si sa le raporteze ca dirty.
 
-Fix (2026-07-15): `.gitattributes` cu `* -text` la radacina fiecarui repo (ROAGEST,
-COMUN, ROAAUTO, ROACONT, ROAIMOB, ROAACNPRO) — opreste normalizarea CRLF/LF a git,
-SVN ramane autoritatea EOL. Pe repo nou cu acelasi tipar svn+git, copiaza acelasi
-`.gitattributes`.
+Fix: `.gitattributes` cu `* -text` la radacina fiecarui repo (ROAGEST, COMUN, ROAAUTO,
+ROACONT, ROAIMOB, ROAACNPRO) — opreste normalizarea CRLF/LF a git, SVN ramane autoritatea
+EOL. Pe repo nou cu acelasi tipar svn+git, copiaza acelasi `.gitattributes`.
 
 Capcana: `-text` opreste doar conversia *viitoare* — blob-urile deja in git (LF)
 tot difera de ce scrie SVN (CRLF), deci diferenta reala reapare o data. Fix unic:

roa_sync.bat

@@ -1 +1,2 @@
-powershell -ExecutionPolicy Bypass -File D:\ROA\UTIL\foxbin2prg\roa_sync.ps1 -ProjectRoot "%~dp0."
+@echo off
+powershell -ExecutionPolicy Bypass -File "%~dp0COMUN\scripts\roa_sync.ps1" -ProjectRoot "%~dp0."

roagest.pj2

@@ -25,7 +25,7 @@ _LegalTrademark = ""
 _ProductName = "ROA - Gestiune generala"
 _MajorVer = "2"
 _MinorVer = "11"
-_Revision = "8"
+_Revision = "14"
 _LanguageID = "Romana"
 _AutoIncrement = "0"
 *</DevInfo>

todo.txt

@@ -43,3 +43,13 @@ import unificat - preview tiparit al notei inainte de salvare (E7, amanat)
 import unificat - persistenta pozitiei splitterului per user (amanat)
 import unificat - dupa 1-2 luni de productie: stergere clase moarte import_nir si import_nota_original din ointroduceri.vcx (F6)
 import unificat v2 - id_fact per articol + extinderea modelului B/S/T/D la NIR-ul intern clasic
+conturi discount factura import (667/4426) configurabile - daca mai cere o firma (acum: 401 preluat de pe randul B, 667/4426 fixe; plan aprobat 27.07.2026)
+stergere 'doar linia curenta' pe randul B al unei facturi de import lasa randuri G (discount) / T orfane care se scriu in ACT - de curatat (comportament preexistent la T)
+
+achizitie import - de verificat (gasite la runda DVI/discount, in afara scopului):
+  - lSuprimaDirty e declarat si verificat in txtCurs.Valid dar NICIODATA setat pe .T. - suprimare moarta;
+    txtCurs.Valid si txtSumaLei.Valid marcheaza dirty la orice pierdere de focus, nu doar la modificare
+    (acelasi defect reparat la campurile DVI cu tiparul nOldVal/GotFocus).
+  - conturi discount configurabile (acum fixe in cod: 401=667 / 4426=401).
+  - stergere 'doar linia curenta' pe randul B lasa randuri G orfane (identic cu comportamentul randului T azi).
+nomenclator explicatii TVA - CE11CTB/CTT/FTB/FTT si XX11TIB/TIT au AFISAT=0 si ORDINE null, spre deosebire de perechile lor de 21%: de decis daca trebuie sa apara in jurnalul de TVA

versiune_db.txt

@@ -1 +1 @@
-2026_01_21_02
+2026_08_02_06