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.
pinned_get) : l'adresse est vérifiée une fois, la connexion part vers cette adresse et nulle autre, seuls les ports 80 et 443 sont acceptés, chaque redirection est revérifiée, la taille est plafonnée. Chaque appelant garde ses limites et ses messages d'erreur actuels. Deux autres chemins non protégés existent dans le rendu des preuves, mais aucun workflow live ne les appelle. Ils sont protégés au passage, pour un coût faible (décision D-1).TRACKER_STALE, TOKENOMIST_UNREADABLE, DOSSIER_CHECK_FAILED, DOSSIER_UPDATE_REFUSED) restent signalées à chaque passage, conformément à la décision du 18/11. Leur assouplissement éventuel est proposé une seule fois, au lot 3.core_models.py). Une commande en lecture seule (--check) compare cette copie au Core live et à l'Unlock Collector live. Elle doit être lancée après chaque changement de modèle du Core, et le déploiement de l'Unlock Collector la lance d'office. On passe ainsi d'une copie manuelle à un contrôle, sans prétendre à une source unique.source_renderer/network.py et ses enveloppes, download_source_image, link_preview, video_frames ;_poster_luma, fetch_open_graph_preview.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.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).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.Read Official Sites d'Audit Social Sources : traité au lot 4, après le lot 2 (G4).network.py vers src/services/web/ : décision du lot 2 (D2). Le lot 1 corrige le fichier en place.TRACKER_STALE, TOKENOMIST_UNREADABLE, DOSSIER_CHECK_FAILED et DOSSIER_UPDATE_REFUSED : décision unique proposée au lot 3 (G1).core_models.py (G5).LogoFetcher (editorial_x_renderer/media.py) et les clients vers des hôtes fixes de confiance (X API, TweetAPI, CoinGecko, Tokenomist, OpenRouter).| # | 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) :
339a038) : 2 983 réussis, 70 ignorés, 6 échecs connus : tests/test_cascade.py::test_cascade_allows_existing_route_to_finish_after_two_slow_attempts[False|True], 3 cas de tests/test_editorial_x_visual_v2_4.py, tests/test_v4_review_runtime.py::test_raw_loader_rejects_rehashed_unsupported_role_topology. La liste de 7 échecs de memory/reference_event_engine_api.md:265 (637a3db) est périmée.ruff check src tests : 171 erreurs au départ (mesure de la relecture transversale). Ruff sert donc de comparaison : aucune erreur nouvelle sur les fichiers touchés, jamais « 0 erreur ».test_author_bio_candidates_change_only_the_bio_spans_and_the_expert_prompt, garde build_workflows.py:2674). Le sous-lot 4a le supprime : après 4a, on attend 0 échec.env -u OPENROUTER_API_KEY -u OPENAI_API_KEY …, commande T du lot 2).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).
T du lot 2 et ruff check src tests > ../baseline-ruff.txt.$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.sni_hostname (utilisée comme server_hostname pour le SNI et la vérification TLS) ; un en-tête Host explicite conservé (lu localement : httpx/_models.py:450-456, httpcore/_async/connection.py:107,117,151) ; trust_env=False (proxy et SSL_CERT_FILE/SSL_CERT_DIR, httpx/_config.py:34-37) ; follow_redirects=False ; Response.is_redirect contre has_redirect_location (httpx/_models.py:739-792) ; raise_for_status() sur une réponse en flux fermée ; copy_with(host=<IPv6>), qui met les crochets ; httpx.InvalidURL.Engine.connect(), Connection.execution_options(isolation_level="AUTOCOMMIT") à poser avant tout execute, et rétablissement du niveau d'isolation au retour dans le pool.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.
network.pyFichier : 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) :
pinned_get :host dans headers, quelle que soit la casse (ValueError), pour ne jamais produire deux en-têtes Host.public_url(url), puis addresses = await _public_addresses(current.host, current.port or (443 if https else 80)). Cette fonction est inchangée : toutes les adresses doivent être publiques, avec la préférence IPv6 Webflow, et elle lève source_resource_address_blocked.httpx.AsyncClient(trust_env=False, follow_redirects=False, timeout=timeout), appelé par l'attribut du module (les tests remplacent httpx.AsyncClient) ; client.stream("GET", current.copy_with(host=address), headers={**headers, "Host": current.netloc.decode()}, extensions={"sni_hostname": current.host}).try/except httpx.TransportError englobe aussi la lecture du corps, comme aujourd'hui (network.py:69-108). Au début de chaque adresse, body = bytearray(), size = 0 et, avec sink, sink.seek(0); sink.truncate(). Un essai sur l'adresse suivante ne peut donc jamais ajouter ses octets à un corps partiel.truncate, dès que size >= max_bytes, on s'arrête en gardant les octets lus (comme link_preview.py:87). Sinon, size > max_bytes lève une erreur (comme network.py:103). Avec sink, chaque morceau est écrit dans le fichier et body reste vide.sink (OSError) n'est pas une TransportError : elle remonte telle quelle, sans essai sur l'adresse suivante.pinned_fetch :public_url, puis check_hop, puis pinned_get(read_body=lambda r: r.is_success and allowed(_media_type(r))).REDIRECT_STATUSES : sans Location, ou si current.join(location) lève InvalidURL, ValueError("source_resource_redirect_invalid") ; sinon current = current.join(location).reply.response.raise_for_status() : l'exception garde response.headers (Retry-After, lu par blogs/collector.py:290-296) et request.headers["host"] (nom d'origine, lu par blogs/collector.py:624). Puis un type refusé lève ValueError("source_resource_type_blocked").ValueError("source_resource_redirect_limit"). _media_type(r) = r.headers.get("content-type", "").split(";")[0], comme network.py:91._fetch_public_resource (network.py:44-109) garde sa signature. Il est importé par unlocks/investigate.py:37 et remplacé dans tests/unlocks/test_discovery.py:221. Son corps devient async with asyncio.timeout(deadline_seconds): return await pinned_fetch(...), avec :headers = les en-têtes User-Agent et Accept de :77-80 (jamais Host) ;max_bytes=MAX_ASSET_BYTES ;allowed = les trois règles actuelles :92-97 ;check_hop = le contrôle article :59-62, si article_resource.:1-4, « renderer-local … unchanged », qui deviendrait faux) : le module est le chemin commun des téléchargements publics épinglés. C'est aussi une dépendance du collecteur X après la livraison B.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 :
source_resource_port_blocked. Aucune URL de ce type n'existe dans le code (grep https?://host:port sur src/, scripts/, migrations/), et Q2 le vérifie en base.http://x.com:8080/… lève port_blocked au lieu de source_article_resource_url_blocked. C'est sans effet, puisque aucun code ne lit ces chaînes.ValueError au lieu d'un InvalidURL brut.Tests (tests/test_source_renderer_network.py, à ajouter ; les 7 tests existants restent verts sans changement) :
test_pinned_get_resolves_once_and_connects_to_that_address. Un faux getaddrinfo compte ses appels : il répond une adresse publique au 1ᵉʳ appel et 127.0.0.1 ensuite (rebinding). On vérifie 1 seul appel, que le transport reçoit request.url.host == "8.8.8.8", Host et sni_hostname.test_non_public_answers_are_refused_without_a_request, paramétré sur 127.0.0.1, 10.0.0.1, 100.64.0.1, 169.254.169.254, 224.0.0.1, ::1, fd00::1, fe80::1, ::ffff:127.0.0.1, 64:ff9b::a00:1, ::10.0.0.1.test_only_ports_80_and_443_are_opened : :8080, :8443 et :22 refusés sans appel DNS ni requête ; :443 et :80 explicites acceptés.test_a_redirect_to_a_private_address_or_another_port_is_not_requested : 1 seule requête.test_too_large_raises_and_truncate_keeps_what_was_read.test_the_next_address_is_tried_after_a_transport_error.test_sink_is_rewound_when_the_next_address_is_tried : la 1ʳᵉ adresse envoie 3 octets puis lève httpx.ReadError ; le fichier final est égal au corps de la 2ᵉ adresse.test_a_sink_write_error_is_not_retried_on_the_next_address (un OSError(ENOSPC) remonte).test_a_redirect_or_refused_reply_is_not_read.test_http_error_keeps_response_headers_and_host (Retry-After et request.headers["host"]).test_a_host_header_from_the_caller_is_refused.test_an_unparsable_url_or_location_is_a_value_error.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.
download_source_image sur la primitiveFichier : 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 :
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.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.InvalidURL, aujourd'hui non rattrapée) devient MediaExtractionError("Invalid source image URL"). MediaExtractionError devient alors réellement le seul type levé.Tests :
test_source_image_download_enforces_network_and_content_boundaries (tests/test_v4_media_evidence.py:215-273) et test_source_image_ipv6_pinning_preserves_redirect_host_and_relative_path (:290-320) restent inchangés et verts."port" (« Unsupported source image port », sans DNS), "next_address" et "unparsable".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 :
MAX_VIDEO_BYTES, [], donc un tweet FILTERED X_VIDEO_MEDIA_UNAVAILABLE après la politique de retry. Avec 512 Mio, aucune vidéo observée n'est concernée ;[] au lieu d'une exception brute.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) :
test_download_is_pinned_and_streamed_to_the_file ;test_private_or_non_web_port_video_gives_no_frames_without_a_request ;test_redirect_to_private_gives_no_frames ;test_video_above_the_cap_gives_no_frames ;test_invalid_url_gives_no_frames ;test_a_disk_write_error_is_raised_not_turned_into_no_frames (un sink dont write lève OSError(errno.ENOSPC) : l'exception sort, pas []) ;test_a_retry_on_the_next_address_rewrites_the_file_from_zero.tests/test_v4_media_evidence.py:604 (« No frames extracted ») reste vert.
_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.
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) :
text/html ou application/xhtml+xml exigé ;Tests :
test_render_source_screenshot_enriches_empty_external_link_from_open_graph (tests/test_source_screenshot_endpoint.py:747-790). Il simule la page avec pytest-httpx sur l'URL du nom d'hôte. Avec la version épinglée, la requête part vers l'IP, la réponse simulée n'est jamais demandée et le test échoue (rejeu de la relecture). Le réécrire avec network._public_addresses et network.httpx.AsyncClient (MockTransport), et vérifier request.url.host, Host et sni_hostname.test_render_source_screenshot_does_not_fetch_open_graph_when_tweet_has_media (:824) reste vert, puisqu'il n'y a pas de requête.test_context_link_preview_is_pinned (lien privé : aucune requête, remaining décrémenté).SourceScreenshotRequest est confirmée sans usage, la supprimer plutôt que la garder renforcée. À vérifier d'abord dans les scripts de wip/ et les procédures d'audit.link_preview sur la primitive (code du collecteur X)Fichier : src/x_stream/link_preview.py.
_public_host (:50-59) et l'import ipaddress. Garder socket pour socket.gaierror.fetch_preview(url: str, *, client) devient fetch_preview(url: str). Le seul appelant est enrich_frames (:124), qui n'a plus de client partagé (:119). Dans one(), borner chaque URL : async with asyncio.timeout(PREVIEW_DEADLINE_SECONDS): cache[url] = await fetch_preview(url), avec PREVIEW_DEADLINE_SECONDS = 20. Un TimeoutError est un OSError, déjà rattrapé (:125) : le cache reçoit None. Ce plafond compense l'essai des adresses une par une, qui chacune a son propre délai de 6 s.SKIPPED_HOSTS, urlparse et urljoin de la bibliothèque standard ne changent pas : les chaînes unwound_url restent identiques à l'octet près. Chaque saut devient : 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 :
is_public_address (NAT64, ::/96, multicast en plus) ;SOCK_STREAM avec le port ;trust_env=False (proxy et certificats d'environnement ignorés, à vérifier au §5.3) ;user:pass@) est maintenant refusée (None), alors qu'elle était suivie ;Tests (tests/test_x_stream_tweetapi.py) :
:298-320 et :532-545 avec network._public_addresses et network.httpx.AsyncClient remplacés.:8080 donne None sans requête ; redirection vers une adresse privée donne None avec une seule requête ; redirection vers t.co donne {"unwound_url": …} ; corps de plus de 1 Mo avec un en-tête lisible donne un aperçu ; hôte inconnu donne None ; identifiants dans l'URL donnent None ; une URL lente au-delà du plafond donne None en cache.src/services/collectors/run_lock.pyNouveaux 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().
unlock_runner.py:630-649,657) : supprimer _RunLock et utiliser RunLock(RUN_LOCK_KEY, code="UNLOCK_RUN_IN_PROGRESS", phase="unlock_collector", message="Another unlock run holds the lock"). Clé 7_316_002_611 inchangée (:62). Le verrou reste pris en dry run, sauf si Anthony accepte D-3b. Dans ce cas, il ne sera plus pris qu'avec if not req.dry_run, comme pour les conférences. Changements invisibles : la connexion est fermée en toute erreur, il n'y a plus de transaction ouverte pendant la ronde, et un déverrouillage qui échoue invalide la connexion. Sans cela, avec le pool (src/db.py:14-15,25-31 : pool_recycle 3 600 s, pool_pre_ping), close() rendrait au pool une connexion qui tient encore le verrou, et les rondes suivantes recevraient un 503 pendant jusqu'à une heure. Le _RunLock actuel a déjà ce défaut (unlock_runner.py:646-649).conference_runner.py:969-1023) : ajouter RUN_LOCK_KEY = 7_316_002_612 # pg advisory lock of a writing conference round (the unlock run's is 7_316_002_611). Dans le try de la ligne 972, prendre RunLock(RUN_LOCK_KEY, code="CONFERENCE_RUN_IN_PROGRESS", phase="conference_collector", message="Another conference run holds the lock") seulement si not req.dry_run, avant _discover. Utiliser contextlib.nullcontext() pour un dry run. Relire le diff avec git diff -w. Un dry run n'écrit rien (conference_runner.py:6, _discover :332) et ne doit jamais pouvoir arrêter la ronde de nuit.first_batch_drafts pendant une ronde de nuit, ou une ronde relancée à la main. Il ne couvre pas les intervalles entre les rondes d'une même nuit, pendant la livraison des effets (Index Event jusqu'à 180 s, webhook, Telegram). Si une exécution manuelle qui écrit démarre dans cet intervalle, c'est la ronde suivante de la nuit qui reçoit le 503 : l'exécution de nuit s'arrête avec une alerte, et ses rondes restantes passent à la nuit suivante. Couvrir l'exécution entière demanderait un bail au-delà de l'appel HTTP, ce qui n'est pas retenu (D5). Consigne : ne pas lancer de run manuel qui écrit entre 01:20 et la fin de la ronde de conférences.7_316_002_612 est sûr. Clés bigint simples connues : 7_316_002_611 (unlocks) et 914_882_031 (website lib/developer/webhooks/dispatch.ts:29). Clés sha256 sur 64 bits : v4_review_drafts.py:170, lib/locks/pg-advisory-lock.ts:10-15. Clés hashtext int4, inférieures à 2³¹ : CoinGecko. L'espace à deux clés int4 (event_review_lifecycle.py:62, held-event-review-store.ts:198) ne recoupe pas l'espace à une clé (documentation PostgreSQL des advisory locks).Tests :
tests/collectors/__init__.py.tests/collectors/test_run_lock.py :dialect.name == "postgresql" dont pg_try_advisory_lock répond False : V4DomainError (code, phase, retryable=True), connexion fermée ;True : pg_advisory_unlock(key) en sortie, y compris si le bloc lève ;execute qui lève dans __enter__ : connexion fermée ;execute (faux moteur PostgreSQL) ;pg_advisory_unlock qui lève : invalidate() est appelé avant close(), l'exception n'est pas relancée et une erreur est journalisée ; avec un bloc qui a lui-même levé, c'est l'exception du bloc qui sort.tests/collectors/test_run_lock_postgres.py, actif seulement avec EVENT_ENGINE_TEST_DATABASE_URL : deux RunLock sur la même clé donnent un refus ; les clés des conférences et des unlocks ne se gênent pas ; pg_stat_activity.state du verrou vaut idle, pas idle in transaction ; après un déverrouillage qui échoue (simulé), un second RunLock sur la même clé réussit aussitôt (pg_locks vide pour la clé).tests/test_owned_events.py (près de :602) :test_a_second_writing_conference_round_gets_503_while_one_holds_the_lock ;test_a_conference_dry_run_never_takes_the_lock ;/collectors/unlocks/run.src/services/collectors/failure_report.pyNouveau 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) :
:78-79,84-85), puis importer FAILURE_REPORT_AFTER, reported_now, retrying_reason. Le commentaire de READ_MAX_AGE (:80-82) reste au-dessus de sa constante.:692-697 devient if reported_now(count, repairable=weekly or (expected and getattr(exc, "retryable", True))): return …FAILED…, puis return ConferenceRunResult(…, action="NO_CHANGE", reason=retrying_reason(count, reason)). Le cas weekly and count < FAILURE_REPORT_AFTER (:688-691) ne change pas. Le compteur des conférences (tout échec consécutif, _record_failure :602) ne change pas, et consecutive_count ne s'y applique pas.first = 2 if weekly or (expected and retryable) else 1 est exactement :692 ; le texte et la coupe à 1000 caractères sont ceux de :696.tests/test_owned_events.py:406 : importer les deux constantes depuis src.services.collectors.failure_report (même assertion).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__)
:676-693 ::684-690).count = consecutive_count(token.failure_count, (token.last_error or {}).get("code"), _failure_code(exc)), ou 0 sans exception._record_token(token.coin_id, now, error, count).reported_now(count, repairable=isinstance(exc, EventEngineServiceError) and getattr(exc, "retryable", True)), garder le résultat FAILED ; sinon le remplacer par result.model_copy(update={"action": "NO_CHANGE", "reason": retrying_reason(count, result.reason)})._record_token(coin_id, now, error, count) : row.failure_count = count. row.last_error reste identique à aujourd'hui : None sans exception, sinon {"code", "message": str(error)[:1000]}. Le calcul part de la ligne lue FOR UPDATE (consecutive_count(row.failure_count, row.last_error code, code)), qui fait foi hors dry run. En dry run, il part du token détaché, sans écriture.DOSSIER_CHECK_FAILED, DOSSIER_UPDATE_REFUSED, TRACKER_STALE (FAILED à chaque passage, compteur remis à 0 comme aujourd'hui puisque aucune exception), TOKENOMIST_UNREADABLE (chaque round), échec final de la découverte.event_engine_unlock_token.failure_count = nombre de passages consécutifs qui ont échoué par une exception du code last_error.code. Il vaut 0 après un passage sans exception.:1-6) : ajouter « a token's exception is reported like a conference's failure (collectors/failure_report.py), counted per error code ».plan_unlock_round.js:34-36 ne retient que FAILED, et NO_CHANGE fait partie de UnlockRunAction (src/api/unlock_schemas.py:14-25).| 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 :
tests/collectors/test_failure_report.py :(count, repairable) vers reported : 1/F oui, 8/F oui, 2/V oui, 9/V oui, 1/V non, 3/V non ;consecutive_count : même code +1, autre code donne 1 ;retrying_reason.tests/test_owned_events.py vert sans changement de comportement (notamment :386-398, :400-410, :1226).tests/unlocks/test_runner.py :test_a_repairable_token_exception_is_reported_from_the_second_pass_then_weekly (passages 2 et 9) ;test_an_unexpected_token_exception_is_reported_at_once_then_weekly (passages 1 et 8) ;test_a_new_exception_code_is_counted_from_one (code A pendant 3 passages, puis code B, inattendu : signalé au passage 4) ;test_a_new_exception_on_a_stale_token_is_reported_at_once ;test_tracker_stale_dossier_check_refused_and_tokenomist_unreadable_are_still_failed_every_pass (non-régression G1) ;test_a_pass_without_exception_resets_the_count ;test_a_held_exception_is_no_change_with_its_reason_and_kept_in_last_error ;test_a_dry_run_counts_without_writing.Fichiers : conferences/subject.py:39-42,73, conferences/llm.py, conferences/extract.py:620-623.
llm.py def model_identity(config) -> dict (config.model_dump(mode="json", include={"chat_provider", "openai_chat_model", "openrouter_chat_model", "openrouter_reasoning_effort"})). read_fingerprint l'utilise à la place de :620-623. Sa sortie doit rester identique à l'octet près, sinon toutes les lectures de pages Terra seraient refaites : test « golden » sur le sha256 d'un OfficialPage d'exemple calculé avant le changement. Le lot 3 modifiera ce test au lieu d'en ajouter un second.subject_key(facts, official_url, *, prompt: str, config) -> str : payload = [prompt, model_identity(config), norm(f"{facts.name} {facts.theme} {host}")], puis sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True).encode()).hexdigest()[:16]. Le prompt est passé en paramètre, pas lu dans une constante. En :73, key = subject_key(facts, official_url, prompt=SUBJECT_PROMPT, config=llm.config). C'est la même valeur que le prompt envoyé en :100. Le lot 3 n'aura qu'à changer d'où vient ce prompt (G7).SCHEDULED qui passe le seuil de taille (conference_runner.py:846), candidates() est recalculé sur la liste des coins du jour :linking, #15az).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.
CMC-automations)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 :N8nRestClient(cookie_file: Path | None = None) ;http.cookiejar.CookieJar() en mémoire et une seule connexion par processus (cache de module, car POST /rest/login est limité, memory/feedback_n8n.md:429), par POST /rest/login avec {"emailOrLdapLoginId": os.environ.get("N8N_PRO_EMAIL", "<e-mail de connexion n8n>"), "password": os.environ["N8N_PRO_PASSWORD"]}, comme plan/procedures.md §2.1. n8n-pro.env ne contient que N8N_PRO_PASSWORD (noms relus le 18/11) ; l'e-mail n'est pas un secret. Charger avec set -a; . ~/.local/state/coinmarketcal/n8n-pro.env; set +a dans la même commande ;cookie_file=args.cookie_file (accounting_wf1/3, tweetapi_source, gmail-support/*) ;DEFAULT_COOKIE_FILE supprimé. Les appelants sans argument (coingecko_common/deploy.py:155, failed_execs/deploy.py:38, x_stream_health/deploy.py:38, event_social_notifier/deploy.py:34, gmail-support/patch_neutral_llm_contract.py:89) passent du fichier mort à la connexion en mémoire. Aucun fichier n'est écrit.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 :
workflows/source_processor/tests/test_core_models.py :config.<x>_model|_reasoning_effort lues par nodes/build_core_decide_request.js (identique au live, vérifié le 18/11) est égal à {k for k in CORE_V4_MODELS if k.endswith(("_model", "_reasoning_effort"))}. Les clés de route que le lot 3 ajoutera ne cassent pas ce test ;check_live_core accepte un Core d'exemple aligné ;check_live_unlock_scorer refuse un modèle ou un prompt différent dans l'Unlock Collector.workflows/unlock_collector/tests/test_build_unlock_collector.py::test_generated_file_is_byte_identical ;workflows/conference_collector/tests/test_build_conference_collector.py::test_generated_file_is_byte_identical.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).
simplify sur le diff des deux dépôts, puis corriger.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')]".node --test.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).fix(security): one pinned public download path for every source URL (ports 80/443) (étapes 1-5) ;fix(x-stream): link previews through the pinned download path (étape 6) ;feat(collectors): shared run lock and failure report; writing conference rounds locked, unlock token exceptions spaced per code (étapes 7-8) ;fix(conferences): the subject answer is asked again when its prompt or model changes (étape 9) ;chore(models): repository record of the Core's model settings, a live check, and a guarded unlock collector deploy (étape 10).Ensuite, attendre « go push » ; puis un « go déploiement » pour chaque livraison (§5).
src/services/source_renderer/network.py : public_url, pinned_get, pinned_fetch, PinnedReply, WEB_PORTS, REDIRECT_STATUSES, plus les noms existants. Le lot 2 les déplace dans src/services/web/ sans module de compatibilité. Le collecteur X importe ce module.src/services/collectors/ : run_lock.RunLock ; failure_report.FAILURE_REPORT_AFTER, FAILURE_REMINDER_DAYS (en nombre d'échecs), reported_now(count, *, repairable), retrying_reason(count, reason), consecutive_count(previous_count, previous_code, code). Le lot 3 modifie tests/collectors/test_failure_report.py au lieu de le créer.failure_count et last_error.code (compte par code des exceptions, sans migration). Conférences : failure_count (tout échec consécutif), inchangé.subject_key(facts, official_url, *, prompt, config), llm.model_identity(config), test golden de read_fingerprint.automations/workflows/source_processor/core_models.py, avec --check, et workflows/unlock_collector/deploy.py, seul chemin de déploiement de l'Unlock Collector.339a038 / a9f205b)source_renderer/network.py : browser_egress.py:23 (_public_addresses), v4_media_evidence.py:37 (is_public_address, remplacé), unlocks/investigate.py:37,310,364 (_fetch_public_resource, signature gardée), blogs/collector.py:60,228,895, conferences/fetch.py:26,140,213, x_articles.py:14,247, capture.py:14,182, smart_tags.py:12,215, open_graph.py:87-91, blog_card.py:29,343. Nouveaux : video_frames.py, renderer.py (_fetch_public_resource), x_stream/link_preview.py. C'est la première dépendance du collecteur vers src/services/ : src/services/__init__.py est vide et source_renderer/__init__.py n'a qu'un docstring, donc l'import reste léger.network._public_addresses : test_source_renderer_network.py:27,58,79,96, test_source_renderer_capture.py:292,331, test_source_renderer_articles.py:181 ;network.httpx.AsyncClient : test_source_renderer_network.py:28-29,59-60,80,97 ;httpx.AsyncClient global et loop.getaddrinfo : test_v4_media_evidence.py:246-250,310-313 ; module.MAX_SOURCE_IMAGE_BYTES : :249-250 ;fetch._public_addresses : tests/conferences/test_fetch_remote.py:80,157 ;investigate._fetch_public_resource : tests/unlocks/test_discovery.py:221 ;download_source_image : test_v4_media_evidence.py:135,161,202,330, test_source_screenshot_endpoint.py:193,218,331,361, tests/blogs/test_collector.py:1080 ;renderer.extract_key_frames : test_source_screenshot_endpoint.py:231,866,900,932,963,985 ;link_preview._public_host : test_x_stream_tweetapi.py:306,538 (réécrits) ;runner.FAILURE_REPORT_AFTER/FAILURE_REMINDER_DAYS : test_owned_events.py:406 (import changé) ;pytest-httpx : test_source_screenshot_endpoint.py:747 (réécrit, étape 5) et :824 (inchangé).source_resource_* ne sont lues par aucun code src/ ;MediaExtractionError vont dans V4Failure.message sans être classés ;UNLOCK_RUN_IN_PROGRESS, TRACKER_STALE, DOSSIER_CHECK_FAILED, DOSSIER_UPDATE_REFUSED, TOKENOMIST_UNREADABLE ;source_resource_port_blocked, CONFERENCE_RUN_IN_PROGRESS, et RETRYING after failure N: … pour les exceptions retenues d'unlocks.plan_unlock_round.js:34-36 et plan_collector_round.js:31-33 filtrent FAILED ;Run * Collector sont retry=False : un 503 donne l'erreur du workflow czC8KCavR4mOvyygvWoxt ;/render-source-screenshot par {decision_ref} ou une demande de revue (jamais la requête directe des étapes 4-5) et /v4/decide (étapes 2-3, même contrat d'échec).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.
Les procédures communes sont dans plan/procedures.md (G2) : P-API, P-COLLECTEUR, P-GIT, P-N8N. Elles couvrent notamment :
<déployé>..<SHA> = nos seuls commits et <SHA>..origin/main vide ou compris ;/v4/decide, rendu de preuve, file, aucun blocked_alerted en x_context_execution_failed) ;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 ».
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;.
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 :
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.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.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) :
SELECT error_summary, count(*) FROM event_engine_processing_attempt WHERE failure_reason = 'V4_MEDIA_UNAVAILABLE' AND started_at > :deploy GROUP BY 1, comparé au même créneau de la veille, en particulier « Unsupported source image port », « Source image URL must resolve », « No frames extracted » et « Source image download failed ». Les logs ne suffisent pas : /v4/decide convertit l'erreur avant le handler qui journalise (v4_decision.py:663, main.py:70-73).images_unreadable stable ou en baisse dans le résumé.runs[0]) ; au plus Q3 with_subject appels de plus au modèle linking ; aucun CONFERENCE_RUN_IN_PROGRESS hors run manuel qui écrit.TRACKER_STALE/DOSSIER_*/TOKENOMIST_UNREADABLE sont toujours signalés comme avant. Les exceptions suivent la table de l'étape 8 (Q4 rejouée).docs/EVENT_ENGINE_PIPELINE.md : corriger l'entrée 5c55c3b (ligne 31, « À faire : rebuild de event-engine-api ») en « API : déployé (inclus dans 339a038) ; collecteur : en attente de D3 », et noter A2 « poussé, pas encore déployé (collecteur) ».Arrêt et retour arrière :
V4_MEDIA_UNAVAILABLE plus de 2 fois au-dessus de la veille, et un collecteur bloqué par *_RUN_IN_PROGRESS sans run concurrent.rollback-pre-lot1-<date> reste utilisable jusqu'à la livraison suivante de l'API (livraison 8, lot 2). Après, faire un git revert du commit fautif et reconstruire.prompts, refusé en 422 par une image plus ancienne). La limite effective est la plus proche des deux, donc la livraison 8.failure_count et facts.subject.key se recalculent, au prix d'une seconde série de questions sur le sujet.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) :
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.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 <réseau IPv6 interne>, 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 :
healthy, rules_in_sync, required_recovery_pending=false, tweetapi_last_success_at récent (src/x_stream/health.py:21-59), RestartCount à 0.unwound_url, title et description pour les liens publics : comparer 10 items avant et après.captured_at - source_created_at des nouveaux items comparé à la veille, pour surveiller l'effet des aperçus de liens plus lents.docker ps et docker network ls : aucun nouveau conteneur ni réseau en dehors de la recréation du collecteur.network.py (puis de web/network.py après le lot 2) : tout changement de ce module devient aussi un changement du collecteur.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).
CMC-automations (commit B1), rien en livePush après « go push ». Le jour même, relire les modèles du Core en live, puis lancer en lecture seule :
set -a; . ~/.local/state/coinmarketcal/n8n-pro.env; set +a; python -m workflows.source_processor.core_models --check : OK attendu ;python -m workflows.unlock_collector.deploy en mode rendu : preflight OK et candidate_hash égal à before_hash, ce qui prouve l'identité avec le live. Aucun --apply.La session n8n reste en mémoire : aucun fichier de cookie n'est créé, ni à supprimer.
| 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 |
git revert par thème si besoin.| 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 |
wip/. Leur suppression complète est une option à poser au lot 2 (#63), après vérification de ces usages.TRACKER_STALE et des autres alertes est présenté une seule fois, au lot 3.unlock_runner.py:408,452,564,592,665,692,695,698). Aujourd'hui, un dry run manuel lancé entre deux rondes de nuit peut faire échouer en 503 la ronde suivante et arrêter la nuit.would_ask appels GLM Flash, au plus with_subject.core_models.py, --check et deploy.py : recommandé oui.V4 Config + core_models.py (+ l'Unlock Collector pour le scorer), vérifiés par core_models --check ». Recommandé : oui, et le faire dès D2 (livraison 2) plutôt qu'à la livraison 15. La règle est vraie dès que l'outil existe, et sans elle la dérive reprend au prochain changement de modèle.5c55c3b et une image reconstruite, à recontrôler le jour même.5c55c3b.À chaque livraison :
docs/EVENT_ENGINE_PIPELINE.md : une entrée de journal (commits, image de retour arrière et sa validité, Q1-Q4, effets) ; ligne « Event Engine API » du tableau de l'état courant (D1) ; ligne « X stream collector » (D3) ; correction de l'entrée 5c55c3b dès D1 (§5.2). Compacter selon #64 si besoin.memory/project_event_engine_pipeline.md (fichier existant ; le dossier memory/ n'accepte pas de nouveau fichier, #64) : une ligne par livraison. Ajouter la requête d'audit des exceptions retenues : SELECT coin_id, failure_count, last_error FROM event_engine_unlock_token WHERE failure_count > 0. Puis lancer verify-agent-coherence.memory/reference_event_engine_api.md:265 : remplacer la liste des 7 échecs de 637a3db par les 6 échecs mesurés à G0.CMC-automations :workflows/unlock_collector/README.md : modèle du scorer pris dans core_models.py au lieu de « z-ai/glm-5.3-flash high », et usage de deploy.py ;workflows/source_processor/README.md : core_models.py et --check, à côté du paragraphe de impact_scorer_system_prompt.txt (:94-95).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 :
pinned_get/pinned_fetch (aujourd'hui source_renderer/network.py, après le lot 2 web/network.py) : adresse vérifiée une fois et connexion à cette adresse, ports 80/443, chaque redirection revérifiée, plafond d'octets. Le collecteur X en dépend aussi. »TOKENOMIST_UNREADABLE, TRACKER_STALE) » reste vraie après le lot 1, donc elle n'est pas modifiée. Ajouter : « une exception sur un token est signalée selon collectors/failure_report.py : réparable à partir du 2ᵉ passage consécutif du même code, sinon dès le 1ᵉʳ, puis tous les 7 ; ces passages retenus restent dans event_engine_unlock_token.failure_count/last_error ». Le lot 3 réécrira la phrase s'il change la règle.7316002612, CONFERENCE_RUN_IN_PROGRESS, par ronde et non par exécution ; un dry run ne le prend pas) ; la réponse sur le sujet est redemandée quand son prompt ou son modèle change ».V4 Config seul » par « Un swap de modèle = V4 Config + CMC-automations/workflows/source_processor/core_models.py (+ l'Unlock Collector pour le scorer), vérifiés par python -m workflows.source_processor.core_models --check ; le déploiement de l'Unlock Collector passe par workflows/unlock_collector/deploy.py, qui refuse un écart ».Nettoyage en fin de session de D1 et de D3 :
git worktree remove wip/lot1-net/event-engine (et automations), après avoir copié tout fichier ignoré à garder (#52) ;ssh root@<serveur Event Engine> "ps aux | grep '/tmp/' | grep -v grep", puis suppression des scripts temporaires (CLAUDE.md #10) ;simplify, suites, présentation pour « go commit ».src/services/web/, sans module de compatibilité. Il doit noter dans le journal que le collecteur n'est pas redéployé quand il touche link_preview.py ou web/network.py. Il complète src/services/collectors/ sans toucher run_lock.py ni failure_report.py. L'option de supprimer la requête directe SourceScreenshotRequest lui revient (D-1).FAILURE_REMINDER_DAYS en temps écoulé à partir des noms et champs du §3 « État laissé » (G1, G7) ;TRACKER_STALE et les autres alertes métier ;test_failure_report.py au lieu d'en créer ;unlock_collector/deploy.py.core_models.py parmi les sources canoniques (G5) et peut supprimer build_source_only_core_candidate. 4c passe après le lot 2. Read Official Sites reste à lui.Chaque constat a été revérifié dans le code ou dans les exports avant d'être appliqué.
Arbitrages review/01-arbitrages.md
consecutive_count). Les quatre alertes métier sont inchangées. D-3 est réécrit, et l'ancien tableau, qui espaçait TRACKER_STALE/DOSSIER_CHECK_FAILED, est retiré.rollback-pre-lot1-<date>, validité jusqu'à la livraison 8. plan/procedures.md n'existait pas encore à la relecture : renvoi par nom.00-plan-global.md ; une livraison par jour ; D3 pas le jour d'une autre intervention sur la voie X.core_models.py est repris par 4a ; les prompts du Core sont retirés du §6.subject_key reçoit le prompt en paramètre ; deploy.py est le seul chemin de déploiement de l'Unlock Collector.review/lot1-review.md
OSError d'écriture non réessayée, 2 tests.OSError large) : accepté. Vérifié en video_frames.py:58-65. Seuls socket.gaierror et les erreurs httpx donnent [], le fichier est ouvert hors du try, test ENOSPC ajouté.plan_collector_round.js:4-8 et dans les gardes dry run. Les conférences ne verrouillent pas en dry run ; l'exemption des unlocks devient la décision D-3b ; la portée du verrou par ronde est écrite.{decision_ref} ou une demande de revue (Select Screenshot Source), et aucun autre export ni le website n'appelle la route. Vrai aussi pour 1e. D-1 est reformulé.pytest-httpx cassé) : accepté. test_source_screenshot_endpoint.py:747 est réécrit et le fichier ajouté à la vérification de l'étape 1.git log bloquante au §5.3.deploy_stages.py:12-17 et par les updatedAt. Ajout de --check couvrant le Core et l'Unlock Collector, #15as remplacé et non complété, En bref reformulé.InvalidURL) : accepté. public_url et join le convertissent en ValueError.httpcore/_backends/anyio.py:114-115. Plafond de 20 s par URL et suivi après D3.trust_env et certificats) : accepté. Vérifié en httpx/_config.py:34-37. Contrôle des variables d'environnement sur les deux conteneurs.Host en double) : accepté. Clé host refusée, en-têtes précisés.bit_rate > 0, statement_timeout, timeout 60, would_ask présenté comme une estimation et with_subject comme la borne. Q4 est adaptée à G1.v4_decision.py:663. Suivi par event_engine_processing_attempt.error_summary.Claim Next Article et Claim Next Source Item sans retry. Anthony est prévenu ; ces alertes ne sont pas un critère d'arrêt.ipv6-egress en double) : partiellement. Le comportement exact dépend de la version de Compose, sans preuve locale. Le contrôle compose version + up --dry-run est ajouté par précaution.5c55c3b. Pour #15ba, la phrase existante reste vraie sous G1 et n'est donc pas réécrite.deploy.py) : accepté. Constantes REVIEWED_* vérifiées (c722384c…), procédure des cookies hors de wip/.5c55c3b) : accepté. Nettoyage au §8, test test_http_error_keeps_response_headers_and_host, description de 5c55c3b corrigée (tweetapi.py:76-79).review/cross-lot-review.md (points du lot 1)
TRACKER_STALE) : résolu par G1.docs/archive/event-engine-pipeline-history.md:95,105,107,109), et le piège SI145759 est consigné (:15). La phrase est retirée et P-API (avec drain) est imposée. Rendre l'erreur de transport relançable passe au backlog (§6).core_models élargi pour les futures clés de route.test_failure_report.py modifiés plus tard par le lot 3, 10.3 abandonnée, cookies alignés sur 4a.4.procedures.md §0 (voir F-14 plus bas).LogoFetcher va au backlog de fin de lot 4 ; x_context_execution_failed est désormais planifié en 4g (voir F-13 plus bas).network.py) : accepté. Écrit au §5.3, en #65 et dans la ligne d'état du collecteur.Dernier passage de vérification (review/final-pass.md §4), constats concernant le lot 1
src/db.py:14-15,25-31 (pool_recycle 3 600 s) ; close() rend la connexion au pool, et un pg_advisory_unlock qui échoue laisserait le verrou tenu jusqu'à une heure (même défaut dans le _RunLock actuel, unlock_runner.py:646-649). Étape 7 : conn.invalidate() en cas d'échec du déverrouillage, docstring corrigée, tests (f) et PostgreSQL ajoutés.N8N_PRO_EMAIL absent) : accepté. Vérifié par les seuls noms de variables : n8n-pro.env ne contient que N8N_PRO_PASSWORD. L'étape 10.4 reprend la connexion de procedures.md §2.1, avec l'e-mail non secret en valeur par défaut et le fichier de cookies hors de wip/.…/test_build_unlock_collector.py::test_generated_file_is_byte_identical et …/test_build_conference_collector.py::test_generated_file_is_byte_identical.procedures.md §0, relu après correction. Les numéros de livraison suivent 00-plan-global.md §3 : livraisons 1, 2, 3 ; image de retour arrière valable jusqu'à la livraison 8 ; documents à la livraison 15.wip/, constat F-2) ; x_context_execution_failed n'est plus au backlog mais au sous-lot 4g (livraison 5) ; « D4b » est remplacé par les livraisons 5 et 6b ; « D5/D6/D15 » par les livraisons 8, 9 et 15.N8nRestClient lit aujourd'hui un MozillaCookieJar depuis un fichier (deploy_workflow.py:431-441), avec un défaut mort sous /home/hapi (:14). La livraison 2 passant avant 4a, le premier point de 4a.4 (connexion en mémoire, même signature, une session par processus, e-mail non secret par défaut) est avancé à l'étape 10.0, avec ses tests. core_models --check et unlock_collector/deploy.py perdent --cookie-file, et le nettoyage de fichier de cookie disparaît. 4a.4 doit marquer ce point comme fait.