Lot 1 — Sécurité réseau et fiabilité des collecteurs : plan d'implémentation

Rédigé le 2026-11-18 sur le code de production exact : backend 339a038 (worktree event-engine/), sources n8n a9f205b (worktree automations/), exports live du 18/11 (live/). Les références chemin:ligne renvoient à ces worktrees (préfixe event-engine/ ou automations/ omis quand le contexte est clair). Pour écrire ce plan, aucun fichier de code n'a été modifié et aucun système live n'a été appelé. Les seules exécutions sont des tests locaux hors ligne et une lecture des exports déjà présents dans wip/.

Corrigé le 18/11 au soir à partir de deux relectures (review/lot1-review.md, review/cross-lot-review.md) et des arbitrages transverses review/01-arbitrages.md (G1 à G9). Chaque constat a été revérifié dans le code. Le détail figure au §10.

En bref (pour Anthony)


1. Objectif et non-objectifs

Objectifs

  1. Un seul chemin de téléchargement public épinglé pour tous les téléchargements dont l'adresse vient d'une source :
  2. Un verrou d'exécution commun (src/services/collectors/run_lock.py). Les unlocks gardent leur comportement, sauf l'exemption éventuelle des dry runs (D-3b). Les rondes de conférences qui écrivent sont protégées.
  3. Une règle commune d'espacement des alertes d'échec (src/services/collectors/failure_report.py). Le comportement des conférences reste identique à l'octet près. Côté unlocks, la règle s'applique aux seules exceptions par token, avec un compte par code d'erreur (G1).
  4. Une clé de cache « sujet » des conférences qui couvre le prompt et le modèle.
  5. Une copie des modèles du Core dans le dépôt (core_models.py), lue par le constructeur de l'Unlock Collector. Une commande de contrôle (--check) compare cette copie au live, et un garde bloque le déploiement de l'Unlock Collector en cas d'écart.

Non-objectifs


2. Prémisses vérifiées

# Constat de l'audit Verdict Preuve
1a _fetch_public_resource épingle le DNS et vérifie les redirections, mais ne limite pas les ports VRAI src/services/source_renderer/network.py:57-65 (contrôle du schéma, de l'hôte et des identifiants, puis _public_addresses(current.host, current.port or …) : tout port est accepté) ; épinglage et redirections manuelles :70-89 ; plafond de 20 Mio :12,100-104. Le navigateur est déjà limité à 80/443 (src/services/browser_egress.py, règle #65). Nuance : l'absence de limite de port touche tous les utilisateurs du fichier : blog_card.py:343, capture.py:182 (route_image), x_articles.py:247, smart_tags.py:215, open_graph.py:91, conferences/fetch.py:140, blogs/collector.py:228,895, unlocks/investigate.py:310,364.
1b download_source_image est une deuxième implémentation épinglée (80/443, première adresse seulement, son propre plafond, 15 s) VRAI src/services/v4_media_evidence.py:69-105 : 4 requêtes :75, ports 80/443 :78-80, toutes les adresses vérifiées mais seule la première utilisée :81-84, 12 Mio :43,98, échéance de 15 s :72, timeout de 10 s :73. Tout 3xx est traité comme une redirection :91 (dans httpx, is_redirect couvre 300-399 : site-packages/httpx/_status_codes.py:60-64). Aucun contrôle du type de contenu ; les octets sont validés :101. Appelants : v4_media_evidence.py:374, renderer.py:91, blogs/collector.py:455. Nuance : httpx.InvalidURL n'est ni un HTTPError ni un ValueError (httpx/_exceptions.py:74,271). Il sort donc aujourd'hui tel quel de la fonction.
1b' Les messages de MediaExtractionError pourraient changer la famille de retry FAUX (sans risque) v4_decision.py:659-663 transforme toute MediaExtractionError en V4DomainError("V4_MEDIA_UNAVAILABLE", "media", str(exc), retryable=True). source_retry_policy.py:57-60 classe par phase media (et par le seul code PRESCREEN_MEDIA_ASSET_TOO_LARGE), jamais par le message. Le handler HTTP renvoie un texte fixe (main.py:70-73). Aucun consommateur de ces textes, ni en Python (grep : tests seulement) ni dans les exports n8n. Les messages sont quand même conservés (D4).
1c link_preview vérifie les adresses puis laisse httpx se reconnecter (fenêtre de rebinding DNS), sans limite de port VRAI src/x_stream/link_preview.py:50-59 : socket.getaddrinfo(host, None) avec le seul test is_global (sans NAT64 ni multicast, contrairement à network.py:24-28), puis une nouvelle résolution par httpx :78. Aucun contrôle de port :70-77. Redirections manuelles, sur tout 3xx :79-81. unwound_url gardé :65-67,95. SKIPPED_HOSTS :22,74-75. Corps tronqué à 1 Mo (pas d'erreur) :19,84-88. 6 s par opération, sans échéance totale :20,119. Nuances : client partagé avec trust_env par défaut (proxy, SSL_CERT_FILE/SSL_CERT_DIR suivis : httpx/_config.py:34-37) :119. httpcore essaie toutes les adresses d'un hôte dans un seul délai de connexion (anyio, httpcore/_backends/anyio.py:114-115). Code exécuté dans le collecteur (tweetapi_poller.py:15,194).
1c' Le collecteur tourne depuis un checkout séparé sur f422879 VRAI docs/EVENT_ENGINE_PIPELINE.md:53, docs/TOOLS.md:125-140. Ce que livrerait un redéploiement : à recalculer le jour de la livraison B (§5.3).
1d extract_key_frames suit les redirections sans contrôle d'adresse et garde tout le corps en mémoire VRAI src/services/video_frames.py:58-65 : follow_redirects=True (20 redirections par défaut, httpx/_config.py:248), resp.content entier, 30 s par opération, sans échéance totale. Seul httpx.HTTPError est rattrapé : une erreur d'écriture (disque plein) sort de la fonction et fait échouer /v4/decide de façon visible. Les adresses vidéo viennent de la variante mp4 au plus petit débit positif des médias X : x_context/primitives.py:286-296, :355-361, merge_referenced_threads.py:119-123, conversion TweetAPI avec duration_ms x_stream/tweetapi.py:290-303. Le comportement bruyant (#15i) est vérifié : [] → VideoMediaUnavailableError (v4_media_evidence.py:311-316) → FILTERED X_VIDEO_MEDIA_UNAVAILABLE, seulement si media_failure_should_skip (v4_decision.py:271-293, 660-662). Autres appelants : renderer.py:133,427,451.
1e _poster_luma suit les redirections sans garde VRAI, mais sans appelant live renderer.py:409-422. Seul _maybe_replace_dark_video_poster l'appelle (:446), via hydrate_video_posters (:500-504), atteint uniquement par une requête SourceScreenshotRequest directe (src/api/source_screenshot.py:45-46 → renderer.py:739) ou par le chemin historique (source_screenshot.py:103). Ce dernier construit un RenderTweet sans vidéo, donc la fonction n'y fait rien. Process One Source n'envoie que {decision_ref} ou une demande de revue (export awrB2Ymt3iZPp14k, nœud Select Screenshot Source). Ces deux formes mènent à render_resolution_screenshot/capture_review (source_screenshot.py:39-79), qui ne l'appellent pas. Aucun autre workflow live n'appelle /render-source-screenshot (grep sur les 32 exports et sur CMC-website).
1f (non listé par l'audit) fetch_open_graph_preview sans garde VRAI, mais sans appelant live (prémisse « atteint en production » de la 1ʳᵉ version : FAUSSE) renderer.py:592 → open_graph.py:65-82 : follow_redirects=True, aucun contrôle d'adresse ni de port, aucun plafond. Atteint seulement par hydrate_source_link_previews (renderer.py:610-616,740 ; chemin historique source_screenshot.py:104, sans liens, donc sans effet). Même chemin d'accès que 1e. Le chemin de résolution utilise déjà la version gardée fetch_public_open_graph_preview (renderer.py:197,549 ; open_graph.py:85-92). Des scripts manuels de wip/ (ex. wip/fp-deep-debug.py) peuvent appeler la requête directe. Correction gardée comme renforcement peu coûteux (étapes 4-5, D-1).
2 Les unlocks ont un verrou pg_try_advisory_lock, pas les conférences, et maxConcurrency est ignoré VRAI unlock_runner.py:62,630-649,656-657 ; conference_runner.py:969-1023 n'a aucun verrou ; #15ad. Verrou pris : V4DomainError("UNLOCK_RUN_IN_PROGRESS", "unlock_collector", …, retryable=True) → main.py:122-142 → HTTP 503 avec V4FailureResponse → le nœud Run Unlock Collector, sans retry (unlock_collector/build_workflow.py:220-227), échoue → errorWorkflow czC8KCavR4mOvyygvWoxt. Run Conference Collector est aussi retry=False (conference_collector/build_workflow.py:325). Nuances : (i) le verrou vaut pour une ronde (un appel HTTP), pas pour l'exécution : la nuit enchaîne jusqu'à 12 rondes de conférences et 16 d'unlocks, entrecoupées de la livraison des effets (plan_collector_round.js:4-8, plan_unlock_round.js:4-8,39) ; (ii) les unlocks prennent aujourd'hui le verrou même en dry run, alors qu'un dry run n'écrit rien (unlock_runner.py:408,452,564,592,665,692,695,698) ; il en va de même du dry run des conférences (conference_runner.py:6, _discover :332). Le dry run est le mode manuel enregistré par défaut des deux workflows (unlock_collector/build_workflow.py:25, plan_collector_round.js:5-6). (iii) Aucun test ne couvre le verrou des unlocks ; en SQLite, il ne fait rien (unlock_runner.py:635-639). Les tests PostgreSQL ne tournent qu'avec EVENT_ENGINE_TEST_DATABASE_URL (tests/test_conference_collector_postgres.py:19-22) et remplacent runner.SessionLocal, pas engine. Il n'y a pas de PostgreSQL local. (iv) En SQLAlchemy 2.0, la connexion du verrou ouvre une transaction implicite et reste « idle in transaction » toute la ronde. Elle occupe une place du pool (3 + 2, config.py:38-40, db.py:25-31).
3 failure_count des unlocks est écrit mais jamais lu, et une exception par token alerte chaque nuit VRAI (défaut causal retenu par G1) Écriture unlock_runner.py:613-621. Aucun lecteur (grep src/ et website). Chemin n8n : plan_unlock_round.js:34-36 (action === 'FAILED') → Token Failures? (build_workflow.py:229) → Report Token Failures stopAndError (:231-242) → workflow d'erreur. Contexte : il y a cinq sources de FAILED. (i) Exception :682-691, la seule qui incrémente failure_count. (ii) DOSSIER_CHECK_FAILED :427-431. (iii) DOSSIER_UPDATE_REFUSED :436-445. (iv) TRACKER_STALE :516-524. (v) TOKENOMIST_UNREADABLE :667-675. Pour (ii) à (iv), _record_token(…, None) remet le compteur à 0 (:617-618,679,692-693). Selon G1, le lot 1 ne touche que (i) ; (ii) à (v) restent signalés à chaque passage, conformément à la décision d'Anthony du 18/11 pour TRACKER_STALE/TOKENOMIST_UNREADABLE. Une exception arrête le traitement du token (les résultats déjà ajoutés sont perdus, comme aujourd'hui) : il y a donc au plus une exception par token et par passage. Pour la compter « par code », il suffit d'un compteur par code consécutif (étape 8), sans migration. Échec final de la découverte : déjà espacé (unlocks/discovery.py:315-320). Nuance B (pour le lot 3) : chez les conférences, le compte est par vérification. Il est quotidien pour une édition normale (CHECK_INTERVAL 23 h, conference_runner.py:60), hebdomadaire pour une proposition web ou une candidate (SMALL_CHECK_INTERVAL, :70,686).
3' Comment un échec pas encore signalé apparaît chez les conférences Établi _failed (conference_runner.py:665-697) renvoie ConferenceRunResult(action="NO_CHANGE", reason="RETRYING after failure {count}: {code}: {msg}") (:695-697), ou "WEB_PROPOSAL_FAILED: …" pour un premier échec de proposition web (:688-691). n8n ne compte que FAILED (plan_collector_round.js:31-33) : pas de Stop and Error, donc pas d'alerte. La trace reste dans edition.failure_count/last_error (:602-605) et dans le résumé de ronde retrying (:940-945). Le compteur des conférences compte tout échec consécutif, quel que soit son code. Il est gardé tel quel.
4 subject_key omet le prompt et le modèle, contrairement à read_fingerprint VRAI conferences/subject.py:39-42 : sha256(norm(name theme host))[:16]. conferences/extract.py:613-631 inclut GATE_VERSION, EXTRACTION_PROMPT et le modèle (chat_provider, openai_chat_model, openrouter_chat_model, openrouter_reasoning_effort). Le llm reçu est un ConferenceLLM qui porte .config (conferences/llm.py:50-56), passé par collector.py:152-156 depuis req.models.linking (conference_runner.py:659). Le prompt réellement envoyé est SUBJECT_PROMPT (subject.py:100).
5 Le modèle du scorer est configuré à deux endroits ; le constructeur du Core ne pose pas scorer, identity, prescreen ni cascade VRAI, avec nuance importante V4 Config live (1nswAXAfsck9e9uC, 2a0ea21b publié) : 15 clés de modèle (étape 10). Le constructeur build_workflows.py:890-900 ne pose que expert, reconciliation et media_fallback, plus provider_attempts/contract_version, absents du live. Ce constructeur est historique : lancé hors ligne sur l'export live, il échoue (build_workflows.py:925-928). La dérive réelle vient des scripts ponctuels qui modifient le Core en direct : le 18/11, wip/sol62-switch-20261118/deploy_stages.py:12-17 a changé à la fois le Core et le Request Collector Config de l'Unlock Collector (updatedAt 20:30:24 et 20:30:25 dans les exports). Si l'Unlock Collector est oublié, rien ne le détecte. Côté unlocks, SCORER_MODEL (unlock_collector/build_workflow.py:31) n'est comparé qu'à lui-même (:317-318). L'Unlock Collector live (45705cb2, editable_hash c722384c9c58…) est identique au JSON généré. Le prompt du scorer est identique dans le Core live, le fichier du dépôt et l'Unlock Collector (sha256 4b4498d2…). Le README est périmé (« z-ai/glm-5.3-flash high »). CLAUDE.md #15as dit « Un swap de modèle = changement de V4 Config seul », ce que le lot doit corriger (§8).

Points de départ des tests (à remesurer une seule fois à l'étape commune G0 de la séquence globale, puis après chaque livraison) :


3. Étapes

Toutes les étapes se font dans des worktrees propres, jamais dans les checkouts principaux (#52) :

git -C CMC-event-engine fetch origin
git -C CMC-event-engine worktree add --detach wip/lot1-net/event-engine origin/main
git -C CMC-automations fetch origin
git -C CMC-automations worktree add --detach wip/lot1-net/automations origin/main
V=wip/venvs/event-engine-v4-production

Git (G3, P-GIT de plan/procedures.md) : aucun git commit avant un « go commit » d'Anthony. Ce « go » peut couvrir la série annoncée à l'étape 11. Viennent ensuite un « go push », puis un « go déploiement » pour chaque livraison. Aucun message ne porte d'attribution IA (#5b).

Étape 0 — Préparation (aucun changement)

  1. Reprendre l'état de départ de G0 (§2). Si G0 n'a pas été fait, le mesurer dans le worktree avec la commande T du lot 2 et ruff check src tests > ../baseline-ruff.txt.
  2. Automations : $V/bin/python -m pytest -q workflows/unlock_collector workflows/conference_collector workflows/source_processor && node --test workflows/unlock_collector/tests/collector_nodes.test.js.
  3. Context7, obligatoire (G2) :

Noter tout écart avec ce plan avant de coder. 4. Faire les requêtes SQL en lecture seule du §5.1, ou reprendre leur résultat de G0. Elles conditionnent le plafond vidéo (D-2) et confirment l'absence d'URL sur un port non standard.

Étape 1 — La primitive commune dans network.py

Fichier : src/services/source_renderer/network.py (corrigé en place, D2). Noms publics, pour que le lot 2 puisse les déplacer :

WEB_PORTS = frozenset({80, 443})
REDIRECT_STATUSES = frozenset({301, 302, 303, 307, 308})  # httpx has_redirect_location

def public_url(url: str | httpx.URL) -> httpx.URL:
    """http(s), a host, no credentials, port 80 or 443; else ValueError(source_resource_url_blocked |
    source_resource_port_blocked). An unparsable URL (httpx.InvalidURL) is source_resource_url_blocked. No lookup."""

@dataclass(frozen=True, slots=True)
class PinnedReply:
    url: httpx.URL           # the URL asked for, with its host name
    response: httpx.Response # status and headers; stream closed; response.url is the pinned address
    body: bytes = b""
    size: int = 0            # bytes read, also counted when written to a sink
    truncated: bool = False

async def pinned_get(
    url: str | httpx.URL, *, headers: Mapping[str, str], timeout: httpx.Timeout | float, max_bytes: int,
    truncate: bool = False, read_body: Callable[[httpx.Response], bool] = lambda response: True,
    sink: BinaryIO | None = None,
) -> PinnedReply:
    """One GET to an address verified public, never a redirect followed: public_url, then _public_addresses once,
    then each address in turn (next one only on httpx.TransportError, starting the body again from zero), with the
    original Host header and TLS name. A redirect (REDIRECT_STATUSES) or a response read_body refuses comes back
    without its body. Above max_bytes: ValueError(source_resource_too_large), or with truncate the bytes read so far."""

async def pinned_fetch(
    url: str | httpx.URL, *, headers: Mapping[str, str], timeout, max_bytes: int, allowed: Callable[[str], bool],
    max_hops: int = 5, check_hop: Callable[[httpx.URL], None] = lambda url: None, sink: BinaryIO | None = None,
) -> tuple[bytes, str, str]:
    """pinned_get across at most max_hops requests, each redirect target checked again (public_url, check_hop,
    addresses). Returns (body, media type, final URL)."""

Détails à respecter (l'équivalence avec le code actuel en dépend) :

Comportement conservé : messages, 5 requêtes, repli sur les adresses suivantes, Webflow, en-têtes, 20 Mio, valeurs de retour de toutes les enveloppes. Changements volontaires :

Tests (tests/test_source_renderer_network.py, à ajouter ; les 7 tests existants restent verts sans changement) :

Vérification : DATABASE_URL="sqlite://" $V/bin/python -m pytest -q tests/test_source_renderer_network.py tests/test_source_renderer_articles.py tests/test_source_renderer_smart_tags.py tests/test_source_renderer_polish.py tests/test_blog_source_proof.py tests/test_source_renderer_capture.py tests/test_source_screenshot_endpoint.py tests/conferences/test_fetch_remote.py tests/unlocks/test_discovery.py tests/blogs.

Étape 2 — download_source_image sur la primitive

Fichier : src/services/v4_media_evidence.py:69-105. Retirer import socket (:10, seul usage :81) et remplacer l'import is_public_address (:37) par pinned_fetch.

_DOWNLOAD_ERRORS = {  # the messages raised before the shared path (D4)
    "source_resource_url_blocked": "Invalid source image URL",
    "source_resource_port_blocked": "Unsupported source image port",
    "source_resource_address_blocked": "Source image URL must resolve to public addresses",
    "source_resource_too_large": "Source image exceeds byte limit",
    "source_resource_redirect_limit": "Source image redirect limit exceeded",
}
async def download_source_image(url: str) -> bytes:   # signature unchanged
    try:
        async with asyncio.timeout(15):
            body, _, _ = await pinned_fetch(url, headers={}, timeout=10, max_bytes=MAX_SOURCE_IMAGE_BYTES,
                                            allowed=lambda _: True, max_hops=4)
    except ValueError as exc:
        raise MediaExtractionError(_DOWNLOAD_ERRORS.get(str(exc), "Source image download failed")) from exc
    except (httpx.HTTPError, TimeoutError, OSError, KeyError) as exc:
        raise MediaExtractionError("Source image download failed") from exc
    source_image_data_uri(body)
    return body

MAX_SOURCE_IMAGE_BYTES est lu au moment de l'appel (test_v4_media_evidence.py:249-250 le remplace). Ici, OSError reste rattrapé comme aujourd'hui : la fonction n'écrit pas sur disque.

Conservé : 4 requêtes, 12 Mio, 15 s et 10 s, aucun contrôle de type, validation des octets, tous les messages, en-têtes httpx par défaut. Changements volontaires, à documenter :

  1. Les adresses suivantes sont essayées après une erreur de transport.
  2. Préférence IPv6 Webflow quand le DNS répond 198.202.211.1. Effet visible et positif : une image d'article hébergée sur l'adresse principale de Webflow devient lisible pour les blogs.
  3. Un 300/304/305/306 avec Location n'est plus suivi et donne « Source image download failed ». C'est la définition de httpx has_redirect_location, et c'est rarissime.
  4. Une URL illisible (InvalidURL, aujourd'hui non rattrapée) devient MediaExtractionError("Invalid source image URL"). MediaExtractionError devient alors réellement le seul type levé.

Tests :

Étape 3 — extract_key_frames sur la primitive (écriture directe sur disque)

Fichier : src/services/video_frames.py:50-65.

MAX_VIDEO_BYTES = 512 * 1024 * 1024  # D-2: above the largest X video seen (§5.1 Q1), streamed to disk

        with video_path.open("wb") as sink:          # opened outside the try: a disk error stays loud
            try:
                await pinned_fetch(video_url, headers={}, timeout=30.0, max_bytes=MAX_VIDEO_BYTES,
                                   allowed=lambda _: True, sink=sink)
            except (httpx.HTTPError, ValueError, socket.gaierror, TimeoutError) as e:
                logger.error("Failed to download video %s: %s", video_url, e)
                return []

Seules les erreurs de réseau et d'adresse donnent []. socket.gaierror est le seul OSError du chemin réseau, puisque httpx enveloppe les erreurs de socket dans httpx.TransportError. Une erreur d'écriture (disque plein, OSError non gaierror) remonte comme aujourd'hui (video_frames.py:58-65 ne rattrape que httpx.HTTPError). /v4/decide échoue alors de façon visible au lieu de produire un faux X_VIDEO_MEDIA_UNAVAILABLE (#15i).

Conservé : 30 s par opération, aucune échéance totale, aucun contrôle de type, même message de log, [] pour un échec de téléchargement (donc VideoMediaUnavailableError puis la politique #15i inchangée ; SourceScreenshotError côté capture, renderer.py:425-439). Le disque plein reste une exception. Changements volontaires :

Preuve pour le plafond. Lecture hors ligne de 7 786 vidéos X distinctes dans les exports de wip/ (variante mp4 au plus petit débit × duration_ms / 8) : | Mesure | Valeur | |---|---| | p50 | 1,1 Mo | | p90 | 5,0 Mo | | p99 | 64,3 Mo | | maximum | 380 Mo (3 h 18) | | débit | médiane 256 kb/s, maximum 800 kb/s | | durée | médiane 27 s, p99 33,5 min |

L'échantillon n'est pas garanti représentatif : Q1 (§5.1) le confirme en production.

Tests (nouveau tests/test_video_frames.py, ffmpeg remplacé par un faux) :

tests/test_v4_media_evidence.py:604 (« No frames extracted ») reste vert.

Étape 4 — _poster_luma sur la primitive (renforcement, sans appelant live : D-1)

Fichier : renderer.py:409-422. Remplacer le client par body, _, _ = await _fetch_public_resource(preview_url, deadline_seconds=10, timeout=10) (mode image). Rattraper (ValueError, OSError, TimeoutError, httpx.HTTPError) (pas d'écriture disque ici) pour garder le même log info et None. Conservé : None en cas d'échec, donc l'affiche d'origine est gardée (:446-448). Changements volontaires (cosmétiques) : type image ou octet-stream exigé (un corps non image donnait déjà None par _mean_luma), 20 Mio, 5 requêtes, 10 s au total, en-tête navigateur. Test (tests/test_source_screenshot_endpoint.py) : test_poster_luma_refuses_private_poster_without_request et un test qui lit une affiche publique avec network._public_addresses et network.httpx.AsyncClient remplacés.

Étape 5 — fetch_open_graph_preview remplacé par la version gardée (renforcement, sans appelant live : D-1)

Fichiers : renderer.py:44 (import) et :592, open_graph.py:65-82. Remplacer fetch_open_graph_preview par fetch_public_open_graph_preview en :592, puis supprimer fetch_open_graph_preview (seul appelant : grep src/ et tests/). L'except Exception de :593-595 reste. Changements volontaires (présentation seulement) :

Tests :

Étape 6 — link_preview sur la primitive (code du collecteur X)

Fichier : src/x_stream/link_preview.py.

        try:
            reply = await pinned_get(current, headers={"User-Agent": USER_AGENT}, timeout=TIMEOUT_SECONDS,
                                     max_bytes=MAX_BYTES, truncate=True,
                                     read_body=lambda r: not r.is_redirect and r.status_code < 400
                                     and "html" in r.headers.get("content-type", ""))
        except ValueError as exc:
            if str(exc) in _BLOCKED:   # url, port or address blocked: as before, no preview at all
                return None
            raise
        except socket.gaierror:       # unknown host: as before (_public_host returned False)
            return None
        response = reply.response
        if response.is_redirect:
            current = urljoin(current, response.headers.get("location", ""))
            continue
        if response.status_code >= 400 or "html" not in response.headers.get("content-type", ""):
            return destination()
        body = reply.body

Conservé : valeurs de retour, destination(), troncature à 1 Mo, 6 s par opération, 5 sauts, sauts ignorés, except d'enrich_frames. Changements volontaires :

Tests (tests/test_x_stream_tweetapi.py) :

Étape 7 — Verrou commun src/services/collectors/run_lock.py

Nouveaux fichiers : src/services/collectors/__init__.py (docstring : « Shared kit of the referential collectors (conferences, unlocks) », D1) et run_lock.py :

class RunLock:
    """One writing round at a time: a PostgreSQL session-level advisory lock taken on one pooled connection set to
    AUTOCOMMIT (no transaction stays open), released by pg_advisory_unlock before the connection goes back to the pool;
    if the unlock fails, the connection is invalidated (really closed), so that the server drops the lock instead of
    the pool keeping it until pool_recycle. Nothing elsewhere (SQLite tests). It covers one HTTP round, not a whole
    n8n execution: a round that finds it held fails as retryable (HTTP 503), n8n reports it through the workflow's
    error workflow and stops that execution."""
    def __init__(self, key: int, *, code: str, phase: str, message: str, bind: Engine | None = None): ...
    def __enter__(self):
        # conn = (bind or engine).connect(); on postgresql only: conn.execution_options(isolation_level="AUTOCOMMIT")
        # before any execute; pg_try_advisory_lock(key) false -> close, V4DomainError(code, phase, message, retryable=True).
        # Any exception inside __enter__ (database down) closes the connection before re-raising.
    def __exit__(self, *exc): ...
        # postgres: try pg_advisory_unlock(key); on any exception: logger.exception, conn.invalidate() (the server ends
        # the session and drops the lock), not re-raised: the round's own outcome stands. finally: conn.close().

Tests :

Étape 8 — Règle commune d'alerte src/services/collectors/failure_report.py

Nouveau fichier :

"""When a collector's failure is reported. A failure a later read may repair is reported from its
FAILURE_REPORT_AFTER-th consecutive failure; one the same read would repeat, or an unexpected error, at once. Either is
reported again every FAILURE_REMINDER_DAYS failures while it lasts; in between, it is kept as a retry."""
FAILURE_REPORT_AFTER = 2
FAILURE_REMINDER_DAYS = 7  # counted in failures (one check a day for most items): lot 3 converts it to elapsed time

def reported_now(count: int, *, repairable: bool) -> bool:
    first = FAILURE_REPORT_AFTER if repairable else 1
    return count >= first and (count - first) % FAILURE_REMINDER_DAYS == 0

def retrying_reason(count: int, reason: str) -> str:
    return f"RETRYING after failure {count}: {reason}"[:1000]

def consecutive_count(previous_count: int, previous_code: str | None, code: str) -> int:
    """Consecutive failures of one code: a code that was not the previous failure starts again at 1."""
    return previous_count + 1 if previous_code == code else 1

Conférences, identité à l'octet près (conference_runner.py:78-85,665-697) :

Unlocks : seules les exceptions par token (G1) (unlock_runner.py:613-621,676-693) :

from src.services.collectors.failure_report import consecutive_count, reported_now, retrying_reason
from src.services.exceptions import EventEngineServiceError

def _failure_code(exc: Exception) -> str:
    return getattr(exc, "code", type(exc).__name__)
Exception Réparable ? Signalée Exemple
EventEngineServiceError réessayable oui 2ᵉ passage consécutif du même code, puis tous les 7 scorer V4DomainError(exc.code, "impact", retryable=exc.retryable) (:287), OWNED_STATE_CHANGED (:346)
autre (inattendue, non réessayable) non 1ᵉʳ passage, puis tous les 7 Playwright, S3, EditorialXRenderError (RuntimeError, editorial_x_renderer/errors.py:4), bug

Tests :

Étape 9 — Clé du sujet des conférences

Fichiers : conferences/subject.py:39-42,73, conferences/llm.py, conferences/extract.py:620-623.

Le nombre d'appels est estimé par Q3 would_ask. Ce n'est pas une borne : une réponse « no coin named … » stockée sur l'ancienne liste de coins peut maintenant avoir des candidats. La borne haute est Q3 with_subject. La nouvelle clé est ensuite stockée à chaque application (conference_runner.py:563-568). Un retour arrière de A4 relancerait une seconde série de questions, avec l'ancienne clé. - Effet de bord possible : la nouvelle réponse peut différer de l'ancienne. Cela donne un UPDATE des coins de l'event (:847-849), un webhook events.updated et une réindexation. Le Notifier n'édite pas un post pour un changement de coins sur une conférence (#15aa). Un coin refusé à la main n'est jamais rajouté (REFUSED_COINS_KEY).

Tests (tests/conferences/test_subject.py) : l'existant reste vert ; ajouter test_a_new_model_or_prompt_asks_again. Ajouter le test golden de read_fingerprint dans tests/conferences/test_extract.py.

Étape 10 — Modèles du Core : copie dans le dépôt, contrôle, garde au déploiement des unlocks (CMC-automations)

  1. Connexion n8n en mémoire (tooling/n8n/deploy_workflow.py:431-441, aujourd'hui MozillaCookieJar chargé depuis un fichier, défaut DEFAULT_COOKIE_FILE sous /home/hapi, chemin mort, :14). La livraison 2 passe avant le sous-lot 4a (livraison 4), alors que les outils du lot 1 ne doivent exiger aucun fichier de cookie (C-2 du contrôle de clôture). Le lot 1 avance donc le premier point de 4a.4, à l'identique :

Le lot 4 (4a.4) prend ce point comme fait. Il garde le reste : deploy_manifest.py, mode brouillon, deactivate, et la suppression proposée des deux cookies de wip/. Tests (tooling/n8n/tests/test_deploy_workflow.py) : test_in_memory_login_without_cookie_file (faux opener : un seul POST /rest/login pour plusieurs appels, aucun fichier créé), test_cookie_file_still_loads_when_given, test_no_default_cookie_path_under_wip_or_home_hapi. 1. Nouveau workflows/source_processor/core_models.py. Il ne dépend que de la bibliothèque standard, plus tooling.n8n.deploy_workflow (N8nRestClient() en mémoire) pour le mode --check.

"""The Core's model settings (V4 Config of "Event Engine - Core Decision Pipeline") as live, recorded in the repository.

V4 Config stays what production runs (#15as). This record is read by the unlock collector builder and compared with
both live workflows by `python -m workflows.source_processor.core_models --check` (read-only, in-memory n8n login),
which must pass after any model change of the Core and before any deploy of the unlock collector."""
CORE_V4_MODELS = {  # live 2a0ea21b, 2026-11-18
    "prescreen_model": "z-ai/glm-5.3-flash", "prescreen_reasoning_effort": "high",
    "cascade_model": "z-ai/glm-5.3-flash", "cascade_reasoning_effort": "high",
    "expert_model": "openai/gpt-6.2-sol", "expert_reasoning_effort": "medium",
    "identity_model": "openai/gpt-6.2-sol", "identity_reasoning_effort": "medium",
    "scorer_model": "openai/gpt-6.2-sol", "scorer_reasoning_effort": "medium",
    "reconciliation_model": "openai/gpt-6.2-sol", "reconciliation_reasoning_effort": "medium",
    "media_fallback_model": "z-ai/glm-5.3-flash", "media_fallback_reasoning_effort": "high",
    "embedding_model": "text-embedding-3-small",
}
def check_live_core(core: dict, names=tuple(CORE_V4_MODELS)) -> None: ...        # versionId == activeVersionId, V4 Config == record
def check_live_unlock_scorer(unlock: dict, core: dict, prompt: str) -> None: ...   # scorer keys + Core prompt == file == Unlock
def main() -> None: ...  # --check: N8nRestClient() in memory, GET both workflows (read-only), run both checks, print OK or the differences

Les valeurs viennent de l'export live (§2, 5). Les relire juste avant le commit (GET en lecture seule), car une autre session les a changées le 18/11. 2. workflows/unlock_collector/build_workflow.py:31 devient SCORER_MODEL = {name: CORE_V4_MODELS[name] for name in ("scorer_model", "scorer_reasoning_effort")}. L'ordre des clés est gardé, donc le JSON généré est identique à l'octet près. Le message de :317-318 est gardé et devient vrai. 3. (Supprimé après relecture.) Le constructeur historique build_source_only_core_candidate n'est pas modifié. Il ne s'applique plus au Core live, et le sous-lot 4a.6 peut le supprimer. 4. Nouveau workflows/unlock_collector/deploy.py, environ 60 lignes, sur le modèle de workflows/x_stream_health/deploy.py : - constantes WORKFLOW_ID = "iPaKN8gRPFt4KyjQ", REVIEWED_VERSION = "45705cb2-348b-4840-a75c-b5611b8b19b2", REVIEWED_HASH = "c722384c9c582d55f88479664c46d8f83b2b19f435d9eee35a2d20c8286b43da" (valeurs vérifiées sur l'export et égales à editable_hash(build_workflow())). Toute livraison n8n future les met à jour dans le même changement ; - preflight(client) : client.workflow(CORE_ID) (CORE_ID importé de build_workflows.py:15) et client.workflow(WORKFLOW_ID), puis check_live_core(core, names=("scorer_model", "scorer_reasoning_effort")) et check_live_unlock_scorer(...), avant toute écriture ; - main : --apply, --confirm-version, --artifact-root ; aucune option de cookie : N8nRestClient() se connecte en mémoire (étape 10.0). Puis preflight, candidate = build_workflow() | {"id": WORKFLOW_ID}, et deploy_guarded(…, expected_version=REVIEWED_VERSION, expected_hash=REVIEWED_HASH). Par défaut, mode rendu en lecture seule ; - docstring : seul chemin permis pour déployer ce workflow (le lot 3 l'utilise, G7) ; tout déploiement réel suit P-N8N (DoD #61, restauration des nœuds du constructeur, #15ba) ; - session n8n : uniquement en mémoire (étape 10.0), aucun fichier de cookie créé ni demandé, aucun secret dans wip/. 5. README : voir le §8.

Comportement live : aucun, puisque aucune différence n'est générée (D3). Tests :

Chacun vérifie OUTPUT.read_bytes() == (json.dumps(build_workflow(), ensure_ascii=False, indent=2) + "\n").encode(). Les deux sont vrais aujourd'hui (vérifié). Les tests existants test_generated_files_are_current (:39 et :25) comparent des dictionnaires et restent en place. Le lot 2 A1 fait passer ces deux tests par son render_workflow au lieu d'en recréer un ; le lot 3 cite ces noms (et non test_generated_file_is_the_builders_exact_output). - workflows/unlock_collector/tests/test_deploy.py : un faux client avec un Core ou un Unlock divergent fait lever preflight sans patch ni activate ; avec un client aligné, deploy_guarded tourne en mode rendu. - Vérification : suites automations de l'étape 0, avec le même échec antérieur (0 après 4a).

Étape 11 — Simplify, suites, relecture, puis « go commit »

  1. Lancer le skill simplify sur le diff des deux dépôts, puis corriger.
  2. Backend : commande T du lot 2 (sans clé de modèle), avec les mêmes 6 échecs que G0 et aucun nouveau. ruff check est comparé à l'état de départ (aucune erreur nouvelle sur les fichiers touchés). python -c "import ast, pathlib; [ast.parse(f.read_text()) for f in pathlib.Path('src').rglob('*.py')]".
  3. Automations : suites de l'étape 0 et node --test.
  4. grep -rn "follow_redirects=True" src/ ne doit plus montrer que les hôtes fixes du §6 (unlock_runner.py:179, unlocks/discovery.py:103).
  5. Présenter à Anthony le diff et la série de commits prévue, puis attendre « go commit » (G3) :

Ensuite, attendre « go push » ; puis un « go déploiement » pour chaque livraison (§5).

État laissé aux lots 2 et 3 (pour qu'ils s'écrivent dessus, G7)


4. Inventaire des points d'impact (grep sur 339a038 / a9f205b)

Aucun JSON n8n ne change. - Base de données : aucune migration. Écritures modifiées : event_engine_unlock_token.failure_count (compte par code des exceptions) et event_engine_conference_edition.facts.subject.key (16 caractères hexadécimaux dans les deux cas). - Site web : aucune lecture de event_engine_unlock_token ni de facts.subject.


5. Déploiement

Les procédures communes sont dans plan/procedures.md (G2) : P-API, P-COLLECTEUR, P-GIT, P-N8N. Elles couvrent notamment :

Ce §5 ne garde que ce qui est propre au lot 1. Calendrier : plan/00-plan-global.md §3, qui reprend la séquence G4. Dans ce plan, D1 = livraison 1 (A, API), D2 = livraison 2 (C, dépôt seul), D3 = livraison 3 (B, collecteur X). La livraison suivante de l'API est la livraison 8 (lot 2). Au plus une livraison de production par jour, au plus une intervention par jour sur la voie X. Fenêtres : celles de plan/procedures.md §0, « Fenêtres ».

5.1 Requêtes SQL de vérification (lecture seule ; faites à G0)

Par le conteneur API : timeout 60 docker exec event-engine-api python -c … avec settings.database_url, en tête de transaction SET TRANSACTION READ ONLY; SET LOCAL statement_timeout = '60s';. Vérifier d'abord le chemin JSON sur une ligne.

WITH m AS (
  SELECT si.id, (x->>'duration_ms')::bigint AS ms,
         (SELECT min((v->>'bit_rate')::bigint) FROM jsonb_array_elements(x->'variants') v
           WHERE v->>'content_type' = 'video/mp4' AND (v->>'bit_rate')::bigint > 0) AS bps
  FROM event_engine_source_item si, jsonb_array_elements(COALESCE(si.raw_includes->'media', '[]'::jsonb)) x
  WHERE si.captured_at > now() - interval '90 days' AND x->>'type' IN ('video', 'animated_gif'))
SELECT count(*), percentile_disc(ARRAY[0.5, 0.9, 0.99, 0.999, 1]) WITHIN GROUP (ORDER BY ms * bps / 8000) AS est_bytes
FROM m WHERE ms IS NOT NULL AND bps IS NOT NULL;

Ne pas déployer si le maximum dépasse 0,8 × MAX_VIDEO_BYTES : relever le plafond et en informer Anthony. - Q2, URL avec port explicite (doit renvoyer 0 ligne) :

SELECT 'conference' AS src, edition_key AS ref, official_url AS url FROM event_engine_conference_edition WHERE official_url ~ '^https?://[^/]+:[0-9]+'
UNION ALL SELECT 'blog', source_key, metadata::text FROM event_engine_source_cursor WHERE source_type = 'blog_coin' AND metadata::text ~ 'https?://[^/"]+:[0-9]+'
UNION ALL SELECT 'unlock', coin_id, documents::text FROM event_engine_unlock_token WHERE documents::text ~ 'https?://[^/" ]+:[0-9]+';
SELECT count(*) FILTER (WHERE facts ? 'subject') AS with_subject,
       count(*) FILTER (WHERE facts ? 'subject' AND facts->'subject'->>'key' <> ''
                        AND facts->'subject'->>'reason' IS DISTINCT FROM 'no coin named by the name, theme or address') AS would_ask
FROM event_engine_conference_edition WHERE human_deleted IS FALSE AND status IN ('CANDIDATE', 'ACTIVE', 'CANCEL_PENDING');
SELECT coin_id, failure_count, last_error->>'code' AS code, last_checked_at
FROM event_engine_unlock_token WHERE failure_count > 0 ORDER BY failure_count DESC;

Ce sont les tokens dont l'alerte change. Sur ces lignes, failure_count compte déjà des exceptions consécutives : consecutive_count les reprend sans transition. - Durée des rondes de conférences (risque du pool, §6) : SELECT r->>'at', r->>'seconds' FROM event_engine_source_cursor, jsonb_array_elements(metadata->'runs') r WHERE source_type = 'conference' AND source_key = 'collector' LIMIT 40;.

5.2 Livraison A, D1 : API (commits A1, A3, A4 ; A2 poussé mais inactif)

Procédure : P-API (avec drain), sur le SHA de A4. Tag de rollback cmc-event-engine-api:rollback-pre-lot1-<AAAAMMJJ>. Fenêtre canonique de procedures.md §0 (relue à 23:27) : build, comparaison des dépendances et contrôles entre 09:15 et 10:05, redémarrage de l'API à 10:06-10:08 (juste après un passage */5, loin de :25 et :30), vérifications jusqu'à 11:00. Demander à Anthony de ne pas utiliser Add Tweet Manually pendant le redémarrage. Elle évite les nuits de collecteurs, les lectures des blogs (06:05, 12:05) et Editorial X Publisher (14:00-16:00), qui appelle l'API. Vérifications propres au lot, avant :

  1. Q1 à Q4 acceptables.
  2. docker exec event-engine-api sh -c 'env | cut -d= -f1 | grep -iE "proxy|ssl_cert" || true' doit être vide. Sinon, le passage à trust_env=False (étapes 3 à 5) change la route ou les certificats : arrêt et analyse.
  3. n8n, en lecture seule : versionId == activeVersionId et versions attendues pour le Conference Collector (64f457a9) et l'Unlock Collector (45705cb2), en plus des versions de la voie X vérifiées par P-API.
  4. Prévenir Anthony qu'une à trois alertes Failed Execs peuvent arriver pendant le redémarrage. Claim Next Article du Blog Collector tourne chaque minute sans retry (live/mYAuzz1BuvjiJtEF.json, déclencheur * * * * *), si P-API ne le met pas en pause. Ces alertes ne sont pas un critère d'arrêt.

Vérifications propres au lot, après (lecture seule) :

Arrêt et retour arrière :

5.3 Livraison B, D3 : collecteur X (commit A2), fenêtre et « go » séparés

Procédure : P-COLLECTEUR, sur le même SHA que l'API en production. Tag cmc-x-stream-collector:rollback-pre-lot1-<AAAAMMJJ>, utilisable jusqu'au prochain redéploiement du collecteur ; ensuite, git revert et reconstruction. Fenêtre de procedures.md §0 : 21:00-22:00 UTC, au moins 24 h et une nuit de collecteurs sans anomalie après D1, et pas le même jour qu'une autre intervention sur la voie X : ni la livraison 5 (4g, Process One Source), ni la 6b (X Stream Health). Vérifications propres au lot, avant (bloquantes) :

  1. cd /root/CMC-event-engine-x-stream && git rev-parse --short HEAD doit valoir f422879, arbre propre ; curl -fsS http://127.0.0.1:3284/health doit répondre healthy: true.
  2. Ce que la livraison emporte, recalculé le jour même :
git log --oneline f422879..<SHA> -- src/x_stream src/config.py src/db.py src/models/__init__.py src/models/source_inbox.py \
  src/__init__.py src/services/__init__.py src/services/source_renderer/__init__.py src/services/source_renderer/network.py \
  Dockerfile pyproject.toml docker-compose.yml docker

Le résultat doit être exactement la liste relue ci-dessous, plus A1/A2 (et, après le lot 2, ses commits sur src/services/web/). Sinon, arrêt et relecture. Si un nouveau module du collecteur importe autre chose, recalculer la fermeture d'imports (AST de src.x_stream.__main__). Liste relue le 18/11 sur f422879..339a038 : - 5c55c3b : _tweets_of écarte désormais tout post à id non numérique, sur tous les appels TweetAPI (tweetapi.py:76-79), et plus seulement les posts cités. Effet attendu : les faux posts unavailable disparaissent aussi des lectures directes ; - src/config.py : réglages de traduction des blogs, unlock_sandbox_url, cloudflare_*, non lus par le collecteur ; - Dockerfile (23009b0) : PLAYWRIGHT_BROWSERS_PATH, utilisateur app, chmod. Le collecteur reste root (docker-compose.yml:61-74, sans user:) ; - pyproject.toml : ajout de pypdf, inutilisé ici ; - docker-compose.yml : nouveaux services et réseaux de l'API. 3. docker compose version puis docker compose up --dry-run -d --no-deps x-stream-collector depuis le checkout du collecteur. Le compose y déclare désormais ipv6-egress avec le sous-réseau fixe &lt;réseau IPv6 interne&gt;, déjà pris par le projet cmc-event-engine (docker-compose.yml:85-90). Si la version de Compose crée les réseaux inutilisés, la création échoue (« Pool overlaps ») : arrêt, analyse, pas de commande globale. 4. docker exec x-stream-collector sh -c 'env | cut -d= -f1 | grep -iE "proxy|ssl_cert" || true' doit être vide. 5. Comparer pip freeze entre l'ancienne et la nouvelle image (P-COLLECTEUR ; arrêt sur un saut de version majeure de httpx, pydantic ou SQLAlchemy).

Vérifications propres au lot, après :

Arrêt et retour arrière : ceux de P-COLLECTEUR (retag de l'image vers le nom lu par docker compose images, up -d --no-deps --no-build, checkout f422879).

5.4 Livraison C, D2 : CMC-automations (commit B1), rien en live

Push après « go push ». Le jour même, relire les modèles du Core en live, puis lancer en lecture seule :

La session n8n reste en mémoire : aucun fichier de cookie n'est créé, ni à supprimer.

5.5 Ordre interne et lots de déploiement

Ordre Contenu Où ça agit Dépendance
1 Étape 1 (primitive) API, et collecteur à D3 aucune
2 Étapes 2 et 3 API, en production 1
3 Étapes 4 et 5 (si D-1 = oui) API, chemins sans appelant live 1
4 Étape 6 collecteur 1 ; code poussé avec A, actif seulement à D3
5 Étapes 7 puis 8 API aucune
6 Étape 9 API aucune
7 Étape 10 dépôt automations seulement aucune

6. Risques et parades

Risque Parade
Une source légitime sur un port non standard est coupée Q2 (0 ligne attendue) ; requête de suivi du §5.2 ; une seule constante (WEB_PORTS) à revoir après décision
Le plafond vidéo filtre des tweets Écriture sur disque avec 512 Mio, au-dessus du maximum observé (380 Mo) ; Q1 ; docker exec event-engine-api df -h /tmp doit dépasser 2 Go
Une vidéo corrompue par un repli sur l'adresse suivante Fichier remis à zéro à chaque adresse (étape 1), avec test dédié
Un disque plein maquillé en « média indisponible » OSError d'écriture non rattrapé (étape 3), avec test dédié
unwound_url change de forme urlparse/urljoin de la bibliothèque standard gardés ; test d'égalité ; comparaison de 10 items à D3
Aperçus de liens plus lents (adresses essayées une à une) Plafond de 20 s par URL ; délai de capture surveillé après D3
Un run manuel qui écrit arrête la nuit de conférences (verrou par ronde) Dry runs exemptés ; consigne : pas de run manuel qui écrit pendant la nuit des collecteurs ; l'arrêt reste bruyant (alerte)
Pool PostgreSQL saturé (verrous + trafic X, pool 3+2) AUTOCOMMIT : pas de transaction ouverte. Lire DATABASE_POOL_SIZE/DATABASE_MAX_OVERFLOW (noms seuls) et la durée des rondes (§5.1). Si les nuits de conférences et d'unlocks se recouvrent, le signaler à Anthony
Une exception réparable d'unlock vue avec un jour de retard (une fiche nouvelle créée un jour plus tard sans alerte) Même règle que les conférences. Trace dans event_engine_unlock_token.failure_count/last_error, requête d'audit au §8. n8n ne garde pas les exécutions réussies (saveDataSuccessExecution=none)
La nouvelle réponse sur le sujet change les coins d'une conférence Un appel par édition ; UPDATE sans réédition des posts ; coins refusés protégés
Une autre session déploie en même temps P-API, P-COLLECTEUR et P-GIT (SHA épinglé, journal et git log relus juste avant)
Dérive des dépendances au build Contrôle de P-API et P-COLLECTEUR
Modèles du Core changés en direct sans la copie du dépôt core_models --check obligatoire après tout changement de modèle (#15as corrigé, §8) ; garde au déploiement de l'Unlock Collector
Sémantique httpx ou SQLAlchemy mal comprise Context7 à l'étape 0 ; tests sur request.url.host, headers["host"], extensions["sni_hostname"], IPv6 et AUTOCOMMIT
Restes hors périmètre (backlog de fin de lot 4) LogoFetcher (editorial_x_renderer/media.py:32-74,108-140, contrôle DNS puis connexion séparée, HTTPS:443, URL de notre base) ; clients vers des hôtes fixes (unlock_runner.py:179, unlocks/discovery.py:103,142,237, unlocks/investigate.py:400, x_stream/*) ; x_context_execution_failed sur une coupure de l'API : planifié au lot 4, sous-lot 4g (livraison 5), et non plus au backlog. En attendant, le drain de P-API protège les livraisons du lot 1

7. Décisions à demander à Anthony


8. Documentation et mémoire

À chaque livraison :

CLAUDE.md et AGENTS.md, à l'identique. Ces textes sont écrits une seule fois sur l'état final, à la livraison 15 du calendrier global, sauf #15as que D-5 recommande dès D2 (livraison 2). Chaque phrase remplace la phrase existante concernée au lieu de s'y ajouter :

Nettoyage en fin de session de D1 et de D3 :


9. Estimation et dépendances


10. Journal des corrections (relecture du 18/11)

Chaque constat a été revérifié dans le code ou dans les exports avant d'être appliqué.

Arbitrages review/01-arbitrages.md

review/lot1-review.md

review/cross-lot-review.md (points du lot 1)

Dernier passage de vérification (review/final-pass.md §4), constats concernant le lot 1