LifePlay-Revival/Docs/Migration/etat/OUTC/OUTC-VAL-A.md

Fiche OUTC-T4a — Niveau N1 — Modèle prévu sonnet | utilisé claude-sonnet-5-5 — Agent lp-validator — Skills sk-protocol, sk-recount, debug-verification, lp-validate (invoqués), sk-windows-shell (non invoqué : pièges `pwsh -File` / `-Command` appliqués, voir § 3)
# OUTC-VAL-A : VAL indépendante de CopieEtat.ps1, UeState.ps1, FileCheck.ps1, EtatDir.ps1 (2026-10-11)

Périmètre : partie « a » du découpage de `fiches\OUTC-T4.md` (V1, V2, V3, V4, V5, V6, V11, V12 pour ces 4 fichiers). V7 à V10 et le verdict des 3 autres scripts : `OUTC-VAL-B.md` (T4b). Verdict global du lot = le pire des deux.
Sorties brutes : `OUTC-VAL-A_essais.txt` (3 400 lignes, même dossier). JSON de l'essai réel : `OUTC-VAL-A_copieetat.json`. Scripts d'essai : `<scratchpad>\OUTC-T4a\` (`h.ps1` harnais, `t1`, `t1b`, `t3a`, `t4`, `t5`, `t6`, `t7`, `bg.ps1`, dépôts factices sous `fx\`). Rien supprimé.
Copie `D:\Game\LifePlay-master 5.8`, branche `ue5.8`, HEAD `ae5d5e4`. MD5 des 4 scripts relevés à 07:07 puis inchangés (mtime 06:32 à 06:48) : `CopieEtat` `4A83F321…`, `UeState` `736FBF15…`, `FileCheck` `1FD13C70…`, `EtatDir` `5E18EC5B…` (= IMPL T1 et T6). Ancienne version (référence V2, V12) : `D:\Game\LifePlay_Backup_5.5\OUTC\Tools\` ; ses MD5 `A47107D5…`, `CA9CBA16…`, `28274CB7…` sont égaux à ceux du manifeste et à `git show HEAD:Tools/<f> | md5sum` (établi).

## 1. Fiches amont relues
Relues en entier : `fiches\OUTC-T4.md` (dont « Découpage »), `OUTC-SPEC.md` (§ 1 à 8), `OUTC-T1-IMPL.md`, `OUTC-T6-IMPL.md`, les 4 scripts (CopieEtat 460 l., UeState 167 l., FileCheck 203 l., EtatDir 62 l.), les 3 diffs `git diff -- Tools/UeState.ps1 Tools/FileCheck.ps1 Tools/EtatDir.ps1`, l'instantané `D:\Game\LifePlay_Backup_5.5\OUTC\manifest.csv`, `gabarits.md` (VAL).
Non relues, reportées à T4b : `OUTC-T2-IMPL.md` et `OUTC-T3-IMPL.md` (Verrou, Numero, GitEtat : hors du périmètre « a » ; l'ordre de l'orchestrateur ne les citait pas).

## 2. Points à confirmer des IMPL
`OUTC-T1-IMPL.md` § 5 :

| Point | Verdict | Preuve |
|---|---|---|
| V1 : LF, sans BOM, aucun octet > 0x7F dans CopieEtat | PASS | § 3 V1 |
| V2 : UeState et FileCheck identiques à l'ancienne version (sans paramètre, `-Brief`, `-Kind Editeur -Brief`, listes, `-Lot OUTC`, `-OnlyChanged`, introuvable, manifeste absent, dossier) | PASS | § 3 V2 : 14 cas + 4 cas de liste, octets de stdout, stderr et code égaux ; 1 seule différence de texte, attendue (trace d'exception, voir V2) |
| V3 / V4 sur la copie réelle, éditeur fermé : code 0, `modifies=0` | PASS (code 0 obtenu à 07:01:42, après la fermeture de l'éditeur PID 7972) | § 3 V3, V4 |
| V5 : codes 1 et type d'alerte `ASSET_ABSENT`, `ASSET_MODIFIE`, `GIT`, `PARASITE`, `PROC` | PASS | § 3 V5 |
| V6 : code 2 (`-Copie` inexistante, `-Reference` introuvable, copie hors table sans `-Addon`, copie non dépôt, `-Lot` absent, Modules introuvable) | PASS | § 3 V6 |
| Durée < 30 s | PASS | 4,1 à 5,8 s pwsh compris (`Measure-Command` 4,1 s) ; `duree_s` 4,6 |
| Filtre P9 : `5.8b` exclu, `/` accepté, `..` résolu, `-WaitExit -Copie` n'attend que la copie | PASS | § 3 V3 (processus factices) ; `..` aussi sur le vrai éditeur PID 7972 à 07:00 (UeState `-Copie` l'a retenu, colonne Copy `LifePlay-Sandbox-5.8`) |
| Ajouts Big Boss B1 à B5 dans la synthèse et le JSON | PASS (B1 `7z` sur copie factice seulement) | § 3 V3 |
| V11 : 3 diffs relus, aucune commande git d'écriture, aucun `Remove-Item` | PASS | § 3 V11 |

`OUTC-T6-IMPL.md` § 6 (V12) :

| Point | Verdict | Preuve |
|---|---|---|
| P1 : rejouer les 17 cas et les 2 absolus, comparer à l'ancienne version | PASS | § 3 V12 : 30 cas (17 de T6, 2 absolus, 11 en plus) |
| P2 : `Build.ps1`, `RunCommandlet.ps1`, `ReimportCorrectif.ps1` s'analysent sans erreur et dot-sourcent `EtatDir.ps1` sans le modifier | PASS-STATIC (aucun appel réel, interdit : ils lancent UBT ou l'éditeur) | § 3 V12 |
| P3 : diff lu en entier ; LF, sans BOM, ASCII | PASS | § 3 V1, V11 |

`OUTC-SPEC.md` § 8 (ajouts de Big Boss), pour mémoire : 1 `7z` PASS (copie factice), 2 `jeu_hors_docs` / `jeu_docs` PASS, 3 `head=` PASS, 4 `verrou=` PASS (libre réel, occupé factice avec `qui.txt` ; état `vide` non essayé), 5 `cpu=` PASS, 6 remplacement en une écriture PASS-STATIC (écriture passée : relevée seulement par `LastWriteTime`, MD5 de départ = instantané), 7 EtatDir PASS (V12).

## 3. Critères rejoués
Toutes les commandes sont lancées par `pwsh -NoProfile -File <script> …` depuis la copie 5.8, code relevé par `Process.ExitCode` (harnais `h.ps1`) ; les listes de fichiers de FileCheck par `pwsh -NoProfile -Command "& '<script>' a, b …; exit $LASTEXITCODE"` (un `-File a,b` arrive en une seule chaîne). Toutes les lignes brutes sont dans `OUTC-VAL-A_essais.txt` (repère `=== <nom d'essai>`).

| # | Commande (abrégée) | Code relevé | Attendu | Verdict |
|---|---|---|---|---|
| V1 | octets des 4 fichiers + `FileCheck.ps1 Tools\CopieEtat.ps1, Tools\UeState.ps1, Tools\FileCheck.ps1, Tools\EtatDir.ps1` + `git ls-files --eol` | FileCheck 0 | LF, sans BOM, ASCII | PASS |
| V2 | ancien (Backup) vs neuf : UeState ×6, FileCheck ×8 en `-File`, ×4 listes en `-Command` (18 paires) | codes égaux dans les 18 paires : UeState 1, 1, 1, 0, 0, 2 ; FileCheck 2, 1 (jetons), 0, 0, 2, 2, 0, 1 ; listes 0, 2, 0, 0 | sorties et codes identiques | PASS |
| V3 | `CopieEtat.ps1 -Lot OUTC -Assets Content\BPs\GI.uasset,Content\BPs\GM.uasset -Autorise <3 fichiers addon> -Sortie …\OUTC-VAL-A_copieetat.json` | 0 à 07:01:42 (4,6 s) ; avant, à 07:00 : 1 `PROC,GIT`, puis 1 `PROC` | 0 si rien ne tourne et état déclaré | PASS |
| V4 | idem `-Reference <json V3>` (texte, `-Json`, + `-Autorise`) | 0, 0, 0 à 07:02 ; `modifies=0` | 0, `modifies=0` | PASS |
| V5 | `ASSET_ABSENT`, `ASSET_MODIFIE`, `GIT`, `PARASITE`, `PROC` | 1 à chaque cas | 1 et type d'alerte | PASS |
| V6 | `-Copie` inexistante, `-Reference` introuvable, etc. | 2 ×11 | 2 | PASS |
| V11 | `git diff` ×3 lu en entier ; CopieEtat lu en entier ; Grep | — | aucune commande git d'écriture, aucun `Remove-Item` | PASS |
| V12 | `Resolve-LPEtatDir … -NoCreate`, ancien vs neuf, 30 cas | 0 / 0 | différences = table de T6 § 4 | PASS |

**V1.** Octets lus par `[IO.File]::ReadAllBytes` : CopieEtat 24 300 o, CR 0, LF 460, > 0x7F 0, BOM non ; UeState 6 964 o, CR 0, LF 167 ; FileCheck 10 895 o, CR 0, LF 203 ; EtatDir 3 697 o, CR 0, LF 62 ; dernier octet 10 partout (`FileCheck.ps1` : `LF=4 alertes=0`). `git ls-files --eol` : `i/lf w/lf` pour UeState, FileCheck, EtatDir ; CopieEtat (non suivi, `-o`) `w/lf`. Grep `[^\x00-\x7F]` non rejoué (les octets > 0x7F sont comptés à 0). Analyse syntaxique Windows PowerShell 5.1.26100 : 0 erreur pour les 4.

**V2.** Baseline vérifiée (MD5 de Backup = manifeste = `HEAD`). Comparaison stdout + stderr + code (+ MD5 de la concaténation) pour : `UeState` défaut, `-Brief`, `-Kind Editeur -Brief`, `-Kind Jeu`, `-Kind Jeu -WaitExit -TimeoutSeconds 5`, `-Kind Editeur -WaitExit -TimeoutSeconds 3 -Brief` (code 2, éditeur PID 7972 vivant) ; `FileCheck` (avec `-ProjectRoot` explicite, sinon l'ancienne version prendrait le dossier Backup) `Tools\Build.ps1,Tools\Snapshot.ps1` (une chaîne : introuvable, code 2), deux jetons (erreur de liaison, code 1), `-Lot OUTC`, `-Lot OUTC -OnlyChanged`, introuvable, manifeste absent, dossier, sans argument ; listes `-Command` : `Build, Snapshot` (0), avec introuvable (2), 4 fichiers `-Lot OUTC` (0), `-OnlyChanged` (0). 17 paires sur 18 identiques octet pour octet. La dernière (sans argument, `throw 'Indiquer des fichiers…'`, code 1) ne diffère que par la trace d'exception : chemin du script et numéro de ligne (111 → 127, lignes ajoutées plus haut) ; après neutralisation du chemin, de la ligne et des séquences ANSI, stderr est identique, stdout identique (`Projet    : …`), même code. Alertes de FileCheck (code 1) prouvées sur un lot factice : `-Lot LOTX -BackupRoot <scratch>` fichier LF passé en CRLF → `ALERTE FINS`, code 1, ancien = neuf ; `g-mixte.txt` → `MIXTE`, code 1, ancien = neuf. `FileCheck -Json` (hors V2, SPEC § 3.1) : JSON seul valide, codes 0 (fichier propre : MD5, `Taille`, `Modifie` = `Get-FileHash` / `Get-Item`), 1 (`FINS`, `MIXTE`), 2 (introuvable listé dans `introuvables`, manifeste absent `{erreur, code=2}`), `-Lot OUTC` : 7 MD5 du JSON = 7 MD5 du texte, même ordre.

**V3.** Essai réel, copie 5.8, HEAD `ae5d5e4`. Chronologie : 06:57 UeState : éditeur `UnrealEditor.exe` PID 7972 (lancé 06:44:21 par un tiers, `-game`, chemin relatif `LifePlay-Sandbox-5.8\Tools\debug\..\..\..`) vivant ; 07:00 CopieEtat sans `-Autorise` : code 1, `alertes=PROC,GIT` (3 entrées addon non déclarées : `LPSandboxModWrappers.cpp` `[ M]`, `LPSandboxCharGenMod.cpp` et `.h` `[??]`, identiques à `git status` de `D:\Game\LifePlay-Sandbox-5.8` relevé au même moment) ; avec `-Autorise` des 3 : code 1, `alertes=PROC` seul. Sonde `UeState -Copie` toutes les 60 s : 07:00:34 code 1, 07:01:35 code 0 (l'éditeur a disparu entre les deux sans mon intervention). 07:01:42 : code 0.
Synthèse (1 ligne) : `COPIE OK lot=OUTC copie=LifePlay-master 5.8 proc=0 assets=2 absents=0 modifies=0 git=1/3/0 hors_declares=0 parasites=0 jeu_hors_docs=8 jeu_docs=106 head=ae5d5e4/22dd7c3/c8661cd verrou=95:libre cpu=29% alertes=aucune`.
JSON `OUTC-VAL-A_copieetat.json` : 16 275 o, sans BOM, CR 0, ASCII, `ConvertFrom-Json` OK, champs `synthese, horodatage, duree_s, lot, copie, depots, processus, assets, git, parasites, verrou, cpu, alertes, code` (`code`=0). Contrôles croisés :
- MD5 : GI `FE4406A0294A8001F612CD03EE2C20CC` et GM `DAC10494BFE32F708CCD1FE427E6DD48` identiques dans le JSON de CopieEtat, dans `FileCheck.ps1 -Json` et dans `Get-FileHash -Algorithm MD5` (une seule fois, contre-preuve) ; taille (52 553 784 et 21 349) et date égales à `Get-Item`.
- B2 : `jeu_hors_docs=8`, `jeu_docs=106` = `git status --porcelain --untracked-files=all` du jeu (114 = 8 + 106, relevé à 07:00 et à 07:07) ; `git=1/3/0` = jeu `Content Config Source` 1 (GI), addon 3, Modules 0.
- B3 : `head=` jeu `ae5d5e4` (branche `ue5.8`), addon `22dd7c3` (`ue5.8`), Modules `c8661cd` (`main`) = `git rev-parse --short HEAD` / `branch --show-current` des 3 dépôts.
- B4 : `verrou=95:libre` à 07:01:42 ; le dossier réel a ensuite reçu `96` (07:03:18) et `96-libre` (07:03:46) d'une autre session ; je n'ai rien écrit dans `VERROU` (lecture seule dans CopieEtat). Cas occupé sur copie factice (`9`, `9-libre`, `10` sans `-libre`) : `verrou=10:occupe`, `qui` lu (ordre numérique, pas alphabétique).
- B5 : `cpu=29%` (échantillon instantané, `Win32_Processor.LoadPercentage` ; 0 % relevé à la main plus tard : valeur de charge, non comparable).
- B1 : sur copie factice `fx\copie-x`, avec 6 processus factices (copies de `cmd.exe` dans le scratchpad, `ping -n`, fin spontanée en 14 à 45 s) : `7z.exe` dont la ligne de commande cite la copie → `processus.copie` + alerte `PROC` (PID 11008, `Start`, `Exe` renseigné) ; `7z.exe` hors copie → `processus.autres` ; sur la copie réelle aucun 7z à ce moment (non rejoué en réel pour ne pas fausser les CopieEtat des autres sessions).
- P9 : 3 `LifePlayFauxT4a.exe` citant la copie factice par chemin direct, par `…/Content` entre guillemets, par `…\sub\..\copie-x\…` : retenus (`UeState -Copie fx -Kind Jeu -Json` : `compte='processus=3 jeu=3'`) ; le 4e citant `copie-xb` : exclu (dans `autres` de CopieEtat) ; racine en MAJUSCULES avec `/` final : mêmes 3 PID. `-WaitExit -Copie` : code 0 après 17 s alors que le processus `copie-xb` tournait encore (45 s). `UeState -Copie "D:/Game/LifePlay-master 5.5/" -Json` : 0 processus, code 0. `-WaitExit -Json` expiré (`-TimeoutSeconds 3`) : code 2, `attente='expiree apres 4 s …'`, stdout = JSON seul.
- Instantané : avec le manifeste `OUTC` (Tools\*), `instantane` = `modifie` (UeState, EtatDir), `nouveau` (CopieEtat), `pas sauvegarde` (Build.ps1 et un fichier absent) ; sans alerte propre.
- Durées : 4,1 à 5,8 s pwsh compris (7 mesures de CopieEtat réel), `Measure-Command` 4,1 s ; `duree_s` 4,6.
Le fichier livré est une copie (`Copy-Item`, `bg.ps1`) de `bg-v3.json`, écrit par `-Sortie` du même appel de code 0 ; une version de code 1 (07:00, `alertes=PROC`) avait été écrite d'abord au même chemin par `-Sortie` et a été écrasée (sa synthèse est dans `OUTC-VAL-A_essais.txt`, `=== V3-reel-avec-Autorise`).

**V4.** 07:02 : `-Reference <json V3>` : code 0, `modifies=0`, `hors_declares=0` (texte) ; `-Json` : 0 ; avec `-Autorise` : 0. Rejeu à 07:08 : V3 frais avec `-Autorise` (5 chemins : 2 nouveaux fichiers addon `LPSandboxScene.cpp` et `.h` `[ M]` apparus entre-temps) code 0 ; `-Reference <ce V3 frais>` code 0 `modifies=0`. `-Reference <OUTC-VAL-A_copieetat.json>` à 07:08 : code 1, `modifies=0`, `hors_declares=2`, `alertes=GIT` : les deux fichiers de `LPSandboxScene` ne figuraient pas dans la référence de 07:01 (changement réel d'un autre lot), alerte correcte, pas un défaut. La référence livrée est donc périmée dès que d'autres lots modifient l'addon, par conception de la SPEC (Q1).

**V5.** Copie factice `fx\copie-x` (dépôts `git init` du scratchpad, nom hors table : `-Addon`, `-ModulesGitDir`) ; cas, code et alertes (texte) :
- `F0` propre (avec/sans `-Assets`, `-Reference`, `-Json`) : 0 ×4, `alertes=aucune` (code 0 sur dépôts propres).
- `ASSET_ABSENT` (`-Assets A.uasset,Content\BPs\Absent_T4a.uasset`) : 1, `absents=1`.
- `ASSET_MODIFIE` : `-Reference` à MD5 falsifié (32 zéros) : 1, `modifies=1`, `(md5 0000… -> 43BDFDB8…)` ; + `-Autorise Content/BPs/A.uasset` : 0 (`modifies=1`, pas d'alerte) ; modification réelle du fichier après la référence : 1, `ASSET_MODIFIE`.
- `GIT` : fichier non suivi dans le jeu (`jeu [??] Content/x-nondecl.txt`) : 1 ; `-Autorise` : 0 ; `-Reference` d'une sortie qui le contenait : 0 ; fichiers non suivis dans l'addon et dans Modules : 1 (`addon [??]`, `modules [??] M1/nouveau.txt`) ; `-Autorise` avec jokers (`Content/Modules/M1/*`) : 0.
- État réel non déclaré : copie 5.8, 07:00 et 07:08 : 1 `GIT` (3 puis 5 entrées addon d'autres lots), rapproché de `git status` de l'addon ; avec `-Autorise` : 0.
- `PARASITE` : `etat\X\etat`, `etat\Y\Docs\Migration`, `etat\Z\Migration`, `etat\U58\etat\deep\etat` : 1, `parasites=4` (`U58\etat`, `X\etat`, `Y\Docs`, `Z\Migration` : le plus haut seulement) ; `publication\PUB2\neutral\Docs\Modding` présent et non compté.
- `PROC` : copie 5.8, 07:00 : 1, `ALERTE PROC : Editeur PID 7972 UnrealEditor.exe depuis 2026-10-11T06:44:21 LifePlay-Sandbox-5.8` (éditeur réel, rattaché par la règle `..`) ; copie factice : 3 `Jeu` + 1 `7z` citant la copie : 1, `proc=4`.

**V6.** Code 2, texte puis `-Json` (`code`=2 dans le JSON) : `-Copie` inexistante ; `-Reference` introuvable ; `-Reference` illisible (JSON invalide) ; sans `-Lot` ; `-Lot 'a b/c'` ; copie hors table sans `-Addon` ; `-Sortie` dans un dossier inexistant (aucun dossier créé : `Test-Path` faux) ; Modules introuvable ; copie qui n'est pas un dépôt ; asset qui est un dossier ; argument orphelin (`-Assets a b`, sans virgule finale). `-Assets 'a,' b` (liste en deux jetons) accepté : `assets=2`. Aucun fichier JSON n'est écrit en code 2.

**V11.** Relu en entier : les 3 diffs (EtatDir 21 lignes, FileCheck 49, UeState 66 ; `git diff --stat` : 125 insertions, 11 suppressions) et `CopieEtat.ps1` (460 l.). Les 11 lignes retirées sont réécrites sous garde `-not $Json` ou étendues : `[string]$BackupRoot…,`, le test du manifeste, les lignes `Lot` et `Projet`, `introuvable` (FileCheck, 5) ; `[switch]$Brief` et deux lignes d'attente (UeState, 3) ; la ligne de doc `-EtatDir`, `$dir = if …`, la règle `OUT\d*` (EtatDir, 3). Grep `Remove-Item|\brm\b|Set-Content|Out-File|git (add|commit|reset|checkout|restore|push|rm|mv|tag|stash|merge|rebase)|'(add|commit|…)'` sur les 4 : aucune occurrence. Les seules sous-commandes git de CopieEtat sont `status --porcelain=v1 -z --untracked-files=all`, `rev-parse --short HEAD`, `rev-parse --show-toplevel` et `branch --show-current` (l. 173, 181, 182, 192). Seule écriture : `-Sortie` (l. 451, `WriteAllText` UTF-8 sans BOM, dossier existant exigé). Aucune ligne hors périmètre.

**V12.** `Resolve-LPEtatDir … -NoCreate` sur 30 cas, ancienne vs nouvelle version (script `etatdir-test.ps1`) : 17 identiques (U8, STE, OUT1, OUTC, OUTX2, ZZZ, PUB2, ETAT2, PROP, SK, L7i, `-EtatDir OUTC`, `publication\PUB2\neutral\Docs`, `D:\Temp\abs`, absolu `…\etat\OUTC`, lot invalide, `OUT*`) et 13 différents, tous conformes à `OUTC-T6-IMPL.md` § 4 : `OUTC-T1` et `OUTC-T4a` → `etat\OUTC` (avant `etat\OUTC-T1`, `etat\OUTC-T4a`) ; `Docs\Migration\etat\OUTC`, `Docs/Migration/etat/U58/U8`, `etat\OUTC`, `.\etat\OUTC`, `ETAT\OUTC`, `docs\migration\ETAT\OUTC` → dossier propre (avant : parasites) ; `U58\etat\U8`, `…\Docs\Migration\etat\Docs\Migration\etat\X`, absolu `…\etat\U58\etat` → exception « dossier parasite refusé » ; `etat` et absolu `…\Docs\Migration\etat` → exception (racine). Création réelle sur racine factice : `ZZ9` (avertissement « hors table ») et `OUTC-T9` → `etat\OUTC` créés ; `U58\etat\Q` refusé et `etat\U58` non créé. P2 : `Parser::ParseFile` 0 erreur pour `Build.ps1`, `RunCommandlet.ps1`, `ReimportCorrectif.ps1` (pwsh 7) et `Build.ps1` (5.1) ; `git diff --stat` de ces 3 : vide ; ils appellent `Resolve-LPEtatDir $ProjectRoot $Lot $EtatDir [-NoCreate]` (`Build.ps1:51-52`, `RunCommandlet.ps1:38-39`, `ReimportCorrectif.ps1:37-39`), signature inchangée. Non rejoué : un appel réel de ces trois scripts.

## 4. Diff lu en entier
- 3 fichiers modifiés : `Tools/EtatDir.ps1` (+18 −3), `Tools/FileCheck.ps1` (+44 −5, les 5 retirées réécrites sous garde), `Tools/UeState.ps1` (+63 −3), total 125 insertions, 11 suppressions (`git diff --stat`, recompté). UeState + FileCheck = 107 insertions et 8 suppressions : égal au compte de T1.
- 1 fichier neuf lu en entier : `Tools/CopieEtat.ps1` (460 lignes, non suivi).
- Écriture hors périmètre : aucune constatée ; `git status --porcelain -- Tools` : `M` EtatDir, FileCheck, UeState ; `??` CopieEtat, GitEtat, Numero, Verrou (les trois derniers : T4b).

## 5. Verdict
**PASS** pour la partie « a » (V1, V2, V3, V4, V5, V6, V11, V12) : tous les critères rejoués conformes, codes 0, 1 et 2 prouvés pour chacun des scripts qui en ont (CopieEtat 0/1/2 ; UeState 0/1/2 ; FileCheck 0/1/2, texte et `-Json` ; EtatDir : exceptions, pas de code), essai réel de V3 fait sur la copie 5.8 avec code 0 à 07:01:42. Réserves sans effet sur le verdict : § Constats 1 à 5.

## 6. Points à confirmer par l'utilisateur
- [ ] Le changement de comportement d'`EtatDir.ps1` (`OUTC-Tn` → `etat\OUTC\` ; un `-EtatDir` désignant la racine ou un parasite lève une exception) est accepté : il était voulu par Big Boss (T6 § 2), mais il touche `Build.ps1`, `RunCommandlet.ps1` et `ReimportCorrectif.ps1`, jamais exécutés ici.
- [ ] Les deux écarts de procédure de la fiche (Constats 1 et 2) sont acceptés.
- [ ] Un essai de `CopieEtat` avec un vrai `7z.exe` citant la copie réelle n'est pas demandé (couvert par processus factices sur copie factice).

Tours : 30 / 40 (compte propre, à recouper par `python -I Tools/FicheStats.py --lot OUTC`)

## Constats
1. **Critère d'arrêt de la fiche (rubrique 9) : processus Unreal de la copie 5.8 pendant l'essai.** L'éditeur PID 7972 tournait au début de mes essais (06:57 à 07:00:34) ; je n'y ai pas touché et j'ai suivi le § 4 de la fiche (sonde toutes les 60 s) : il a disparu seul avant 07:01:35 ; les critères qui n'en dépendent pas ont été poursuivis, conformément au § 4. Le code 1 `PROC` constaté à 07:00 est une preuve réelle du code 1.
2. **Critère d'arrêt : le vrai verrou a changé pendant l'essai** : `96` créé à 07:03:18 et `96-libre` à 07:03:46 par une autre session (gardien), `95:libre` relevé par CopieEtat à 07:01:42. Noté. Je n'ai pas arrêté mes essais de V3/V4/V5/V6/V12, qui n'écrivent pas dans `VERROU` (V7 et V8 sont de T4b) ; l'orchestrateur décide si ce changement invalide quelque chose.
3. **`git status` et index** (estimé, non essayé) : `Invoke-LPGit` (`CopieEtat.ps1:144-157`) ne met pas `GIT_OPTIONAL_LOCKS=0` ; un `git status` peut rafraîchir l'index et prendre `index.lock` un instant, au risque d'une collision avec un commit du gardien lancé en même temps. À trancher par l'orchestrateur ; essai qui tranche : lancer CopieEtat pendant un `git commit` de test sur dépôt factice. (Corrigé par OUTC-T7, voir « Reprise T7 ».)
4. **Listes sous `pwsh -File`** : `FileCheck.ps1 a,b` arrive en une chaîne (introuvable) et `a b` donne une erreur de liaison (code 1 de pwsh) : comportement ancien, identique avant / après, hors périmètre. CopieEtat appelle FileCheck dans le processus avec un tableau, donc non concerné. `CopieEtat -Assets a b` (sans virgule finale) : code 2 explicite.
5. **Règle de la racine suivie d'un blanc** (`UeState.ps1:68`, `CopieEtat.ps1:123`) : `(?:\\|\s|$)` fait aussi retenir une ligne de commande où la racine est suivie d'un blanc puis de texte (p. ex. `…\LifePlay-master 5.8 fichier`) : voulu (ligne de commande), mais `…5.8 backup\x` serait aussi retenu ; cas rare, non essayé.
6. **Non essayé** : état `vide` du verrou ; entrées git renommées (`R`) ; chemins non ASCII ; CopieEtat sur la copie 5.5 ; `-Autorise` absolu ; `-Sortie` sur un fichier existant autrement que par l'écrasement du V3 ; `7z` sur la copie réelle ; `FileCheck -Json` sur un dossier avec `-Recurse`.
7. **Processus que j'ai lancés** (scratchpad seulement, copies de `cmd.exe` renommées `LifePlayFauxT4a.exe` et `7z.exe`, `ping -n 14 à 45`, fin spontanée constatée `HasExited`) : aucun processus existant touché ; pendant ces fenêtres (07:04 environ et 07:06) un `UeState` complet d'une autre session les aurait listés en famille `Jeu`.
8. **Fichiers à commiter** (dépôt jeu, `D:\Game\LifePlay-master 5.8`, branche `ue5.8`) : `A Docs/Migration/etat/OUTC/OUTC-VAL-A.md` (`.md` sous `etat\` : suivi). `OUTC-VAL-A_essais.txt` et `OUTC-VAL-A_copieetat.json` : ignorés par git (`.gitignore:75`, `check-ignore -v`), non commités. Aucun script modifié par moi ; les 4 scripts restent à commiter par le gardien comme annoncé par T1 et T6. Aucune écriture git de ma part.

## Reprise T7 (2026-10-11, après `OUTC-T7-IMPL.md`)

Objet : `CopieEtat.ps1` modifié par OUTC-T7 (`--no-optional-locks` ajouté à `Invoke-LPGit`), en réponse au Constat 3. Lu en entier : `OUTC-T7-IMPL.md`. Version installée : MD5 `5E441FA06F05B1F1D91B91DCAC5B023F` (= IMPL T7), mtime 07:11:44, `git ls-files --eol -o` : `w/lf`. Sorties brutes ajoutées en fin de `OUTC-VAL-A_essais.txt` (section `essais-t7.txt`) ; scripts `t8.ps1`, `t9.ps1` du scratchpad `OUTC-T4a\`. L'orchestrateur a accepté le suivi de la sonde du § 4 (Constat 1), le changement d'`EtatDir.ps1` et la référence périmée (V4) : ces points sont clos.

| Point | Verdict | Preuve |
|---|---|---|
| P1 : diff réduit à `Invoke-LPGit` | PASS | `diff CopieEtat.avant.ps1 Tools\CopieEtat.ps1` : 2 hunks seulement, l. 143 (commentaire, 1 ligne devenue 2) et l. 146-147 (`@('--no-optional-locks', '-c', 'core.quotePath=false')`). Le MD5 de `CopieEtat.avant.ps1` est `4A83F321…` = celui que j'ai validé en T4a. |
| P2 : `.git\index` non touché par `git status` de CopieEtat | PASS (dépôt factice) ; sans objet probant sur la copie réelle | Dépôt `fx\copie-x`, index rendu périmé (mtime d'un fichier suivi modifié, contenu identique) : version T1 (`CopieEtat.avant.ps1`) : index 07:01:37 → 07:14:54 (réécrit) ; version T7 : 07:14:54 → 07:14:54 (inchangé) ; `git status` classique (contre-preuve) : 07:14:54 → 07:15:01 (réécrit). Copie réelle, version T7 : `.git\index` 07:14:44.529 avant et après, 154 927 o, pas d'`index.lock` après. L'index réel n'était pas périmé : cet essai seul ne prouve rien, c'est le cas factice qui prouve. |
| P3 : V3 et V5 rejoués, mêmes codes | PASS pour V5, V6, V3/V4 hors code 0 réel ; **BLOCKED-PROC** pour le code 0 de V3/V4 sur la copie réelle | voir ci-dessous |

P3, détail (version installée) :
- V5 sur `fx\copie-x` : `ASSET_ABSENT` code 1 (`alertes=ASSET_ABSENT,GIT,PARASITE`), `ASSET_MODIFIE` avec `-Reference ref0.json` code 1 (`ASSET_MODIFIE,GIT,PARASITE`), `GIT,PARASITE` code 1. V6 : copie inexistante code 2, `-Reference` introuvable code 2. Mêmes codes et mêmes types qu'en T4a.
- V3/V4 code 0 : dépôts factices propres `fx2` (version T7) : `COPIE OK … alertes=aucune` code 0 (V3), et avec `-Reference` code 0, `modifies=0` (V4).
- V3/V4 sur la copie réelle 5.8 : un nouvel éditeur tourne (PID 28332, `UnrealEditor.exe`, lancé 07:13:28, `LifePlay-master 5.8` d'après `UeState -Copie`). Sans `-Autorise` : code 1, `alertes=PROC,GIT` (11 entrées addon d'un autre lot ; HEAD jeu `a7350fc`, plus `ae5d5e4`) ; avec `-Autorise` des 11 : code 1, `alertes=PROC` seul, `hors_declares=0`, `modifies=0` ; `-Reference` : code 1, `alertes=PROC` seul, `modifies=0`. Le code 0 réel avec la version T7 n'a donc pas pu être rejoué : l'orchestrateur le fera rejouer quand l'éditeur sera fermé. Le code 0 réel de la version T1 reste celui de 07:01:42 (§ 3 V3) ; le diff T7 ne touche que les arguments git.
- Constat relevé en passant : `verrou=99:occupe` puis `99:libre` entre deux appels (autre session, lecture seule chez moi).

**Verdict de la reprise T7 : PASS** (P1 et P2 PASS, P3 PASS sauf le code 0 réel de V3/V4, BLOCKED-PROC). Verdict de la partie « a » inchangé : **PASS**. Le Constat 3 est levé.

Tours de la reprise : 6 / 10