Rédigé le 2026-11-18 à partir du lot 4 §5, des relectures (review/lot1-review.md, review/lot4-review.md, review/cross-lot-review.md) et des arbitrages review/01-arbitrages.md (G2, G3). Les quatre noms P-GIT, P-API, P-COLLECTEUR, P-N8N sont stables : chaque lot y renvoie et ne garde que ses vérifications propres.
Conventions : Lisbonne = UTC en novembre. EE = CMC-event-engine, AU = CMC-automations. Serveur Pro = root@<serveur Event Engine>. Toute commande sur le serveur qui lance Python est préfixée par timeout ; les scripts copiés dans /tmp sont supprimés à la fin (ps aux | grep '/tmp/' | grep -v grep, CLAUDE.md #10, #11).
git log et versions live relus juste avant (P-GIT étape 1).docs/archive/event-engine-pipeline-history.md:15 : un redémarrage pendant Normalize/Enrich bloque la source en x_context_execution_failed).DATABASE_URL="sqlite://" env -u OPENROUTER_API_KEY <venv>/bin/python -m pytest -q (6 échecs attendus au 18/11) ; ruff check src tests --no-cache comparé à l'état de départ (171 erreurs au 18/11), jamais utilisé comme critère absolu ; automations python -m pytest -q tooling/n8n/tests workflows (1 échec connu, retiré par le lot 4a ; 0 attendu ensuite) et node --test sur les fichiers *.test.js|*.test.mjs (commande de la CI AU/.github/workflows/test.yml).Appelants de l'API relevés dans les exports live du 18/11 (recherche de event-engine-api:3282 dans live/*.json, puis accessibilité depuis chaque déclencheur) :
| Appelant de l'API | Horaires (Lisbonne = UTC) | Durée à prévoir |
|---|---|---|
| Process Source Queue → Process One Source, Normalize, Enrich, Core, X REST | toutes les 10 s | jusqu'à 30 min par source |
| Blog Collector : lecture / réclamation → Process One Source | 00:05, 06:05, 12:05, 18:05 / chaque minute | lecture jusqu'à 60 min |
| Conference Collector | 01:20 | jusqu'à ~4 h (12 rondes), 6 h au plus |
| Unlock Collector | 02:40 | jusqu'à ~5 h (16 rondes) |
| Audit Social Sources (via X REST) ; Reconcile X Stream Sources (appelle l'Audit) | 03:20 ; 05:02 | — |
| CoinGecko Maintain (via X REST) | 04:30 | — |
Editorial X Publisher (Render Editorial PNG → /render-editorial-x-image, WZBAd86SLDfK3ZXh, fuseau Europe/Lisbon) |
14:00, 15:00, 16:00, 18:00, jeudi 20:00 ; Schedule Watchlist Retry */5 (les 7 déclencheurs peuvent atteindre ce nœud) |
— |
| Editorial X Metrics (via X REST) | chaque heure à :25 | — |
| X REST Context Health | :00 et :30 | — |
| Repair Missing Embeddings | */5 |
— |
| Add Tweet Manually (manuel, Telegram) | à la demande | — |
Fenêtres qui évitent tous ces horaires :
Étape 1 — Coordination (avant de commencer, puis avant chaque push et chaque déploiement).
docs/EVENT_ENGINE_PIPELINE.md : aucune entrée « EN COURS » ou « PAS ENCORE DÉPLOYÉ » qui toucherait les mêmes fichiers ou composants ; ligne « Event Engine API » (et « X stream collector ») du tableau de l'état courant = commit attendu.git -C <repo> fetch origin && git -C <repo> log --oneline -20 origin/main : repérer les commits d'autres sessions depuis la dernière lecture.versionId == activeVersionId et valeur attendue (§5, N1).Étape 2 — Worktree. git -C <repo> worktree add --detach wip/worktrees/<lot>-<repo> origin/main (#52). Notes et preuves dans wip/<lot>/ ; copier ce qui doit survivre avant git worktree remove.
Étape 3 — Commits (« go commit »). Présenter à Anthony la liste des commits (titre, git diff --stat, tests passés, passe simplify faite) ; un commit de « checkpoint » après déploiement n8n (positions et version live, P-N8N étape 11) est annoncé dans la liste comme commit prévu, et son diff est montré avant d'être commité.
Étape 4 — Push (« go push »). git fetch origin ; si origin/main a bougé, rebaser nos commits seulement, relancer les tests, puis git push origin HEAD:main (avance rapide). Noter le SHA épinglé S.
Étape 5 — Contrôle de ce que la livraison emporte (avant « go déploiement »).
D = commit actuellement déployé (serveur : git -C /root/CMC-event-engine rev-parse HEAD ; pour n8n, version live).git log --oneline D..S : uniquement nos commits, ou des commits d'autres sessions déjà déployés ou explicitement compris et annoncés à Anthony. Sinon arrêt.git log --oneline S..origin/main : vide, ou compris (ils ne partent pas avec nous ; le noter dans le journal pour la session suivante).S, jamais origin/main non relu ; jamais git pull sur le serveur.Étape 6 — Après. Entrée datée en tête de docs/EVENT_ENGINE_PIPELINE.md (SHA, versions, tag de rollback, preuves wip/<lot>/), retrait des worktrees, nettoyage /tmp sur Hostinger.
event-engine-api)Étape 0 — Préalables. P-GIT 1-5 faits ; Context7 si httpx/Playwright/n8n touchés ; fenêtre §0 ; « go déploiement ».
Étape 1 — Lectures sur le serveur (bloquantes).
ssh root@<serveur Event Engine> 'cd /root/CMC-event-engine && git rev-parse --short HEAD && git status --short | head -3 \
&& docker inspect event-engine-api --format "{{.Image}} {{.State.StartedAt}}" \
&& (pgrep -af "compose (build|up)" || true) && docker compose images event-engine-api'
ssh root@<serveur Event Engine> 'docker run --rm --entrypoint pip "$(docker inspect --format "{{.Image}}" event-engine-api)" freeze' > wip/<lot>/pip-freeze-before.txt
ssh root@<serveur Event Engine> 'docker exec event-engine-api sh -c "env | cut -d= -f1 | grep -iE \"proxy|ssl_cert\" || true"'
Attendu : HEAD = D, arbre propre, conteneur démarré depuis plus de 30 min, aucun build en cours, aucune variable proxy ou certificat inattendue. Noter le nom réel de l'image du service (compose n'a pas de clé image: ; le nom vient du projet, EE/docker-compose.yml:2-4).
Étape 2 — Build et contrôles, sans toucher à la file (09:15-10:05).
cd /root/CMC-event-engine
docker tag "$(docker inspect --format '{{.Image}}' event-engine-api)" cmc-event-engine-api:rollback-pre-<lot>-<AAAAMMJJ>
git fetch origin main && git checkout --detach <S>
docker compose build --progress=plain event-engine-api 2>&1 | tee /root/build-<lot>-<AAAAMMJJ>.log # jamais --pull ni --no-cache
NEW=<image construite, lue par docker compose images event-engine-api>
docker run --rm --entrypoint pip "$NEW" freeze > /root/pip-freeze-after-<lot>.txt
for img in "$(docker inspect --format '{{.Image}}' event-engine-api)" "$NEW"; do
docker run --rm --entrypoint sh "$img" -c 'ffmpeg -version | head -1; python -m playwright --version; ls /ms-playwright'; done
Le conteneur en service n'est pas touché par le build.
Critère d'arrêt (dépendances non figées), avant tout drain. pyproject.toml n'a que des bornes >= (EE/pyproject.toml:6-23) et le Dockerfile installe le système (apt-get install ffmpeg), puis Python (pip install), puis Chromium (playwright install --with-deps), avant COPY src/ src/ (EE/Dockerfile). Règle :
COPY src/ src/ sont CACHED, l'image n'embarque aucune dépendance nouvelle : continuer ;pip freeze avant/après et les sorties ffmpeg -version, playwright --version et le dossier /ms-playwright (révision Chromium) des deux images : tout saut de version majeure de fastapi, uvicorn, pydantic, pydantic-settings, sqlalchemy, httpx, httpcore, openai, playwright, numpy, psycopg2-binary ou pillow, tout changement de version majeure de ffmpeg ou toute nouvelle révision de Chromium sans relecture → arrêt : ne pas lancer up, garder l'ancien conteneur, revenir vers Anthony.Étape 3 — Drain autour du seul redémarrage (10:06-10:08), réactivation garantie. Le drain n'enveloppe que docker compose up -d et l'attente de /health :
# commande passée au drain (une seule commande ssh)
ssh root@<serveur Event Engine> 'cd /root/CMC-event-engine && date -u +%T && docker compose up -d --no-deps event-engine-api \
&& until curl -fsS http://127.0.0.1:3282/health >/dev/null; do sleep 1; done && date -u +%T \
&& docker exec root-n8n-1 wget -qO- http://event-engine-api:3282/health'
running de Process One Source, Normalize, Enrich ni Core ne reste. Attente maximale : jusqu'à 10:08:00, pas plus (le plafond de 1 900 s du gabarit est remplacé par cette heure limite). Si la voie X est vide avant 10:06, attendre 10:06:00 pour lancer la commande ; entre 10:06 et 10:08, la lancer dès que la voie est vide.finally réactive la Queue et le Blog Collector sur leurs versions d'origine (relecture active: true, versionId == activeVersionId) ; sur le serveur, remettre l'état d'avant : docker tag cmc-event-engine-api:rollback-pre-<lot>-<AAAAMMJJ> <nom de l'image du service> (sinon un up -d d'une autre session lancerait la nouvelle image sans contrôle) et git checkout --detach D ; noter l'abandon dans le journal et recommencer P-API un autre jour, à l'étape 1. Ne jamais déplacer le redémarrage vers un autre horaire de la journée : il tomberait sur un appelant du tableau §0 (Editorial X Metrics à :25, X REST Context Health à :00 et :30, */5, Editorial X Publisher l'après-midi, collecteurs la nuit).up -d, l'attente de /health et sa lecture depuis n8n ; elle réactive ensuite chaque workflow sur sa version d'origine et relit active: true, versionId == activeVersionId. Noter la durée d'indisponibilité mesurée ; si /health ne répond pas en 120 s, appliquer l'étape 6 (rollback), le finally réactivant la file après.python -m workflows.source_processor.deploy drain --api-command "<commande ci-dessus>" (connexion en mémoire, réactivation dans un finally). Avant le lot 4a : wip/<lot>/drain_api.py (gabarit §2.1).Blog Article? → Build Core Input), mais sa réclamation de la minute échouerait pendant le redémarrage (alerte Failed Execs immédiate, seule la Queue a un délai de grâce) et son passage par le Core pendant la coupure n'a pas été vérifié : il est donc désactivé avec la Queue. Sans accord de la session blogs (--keep-blog), annoncer 1 ou 2 alertes.Repair Missing Embeddings (*/5) et Watchlist Retry (*/5) tournent à 10:05 et 10:10 : le redémarrage se fait entre les deux.up -d, dans la même commande, prouver running = 0 pour Normalize et Enrich (requête N3) ; le risque résiduel est accepté et vérifié à l'étape 5.
Jamais de docker compose down/up global ; ne pas toucher unlock-sandbox ni unlock-egress (--no-deps).Étape 4 — Signal positif après la réactivation : dans les 10 min, des attempts démarrent quand des éléments X sont éligibles (requête S1).
Étape 5 — Vérifications après, en lecture seule (voie touchée + voie X).
docker logs event-engine-api --since 15m | grep -E "Traceback|ERROR" | head sans hausse anormale.blocked_alerted avec failure_reason = 'x_context_execution_failed' depuis l'heure du redémarrage. Sinon : liste à Anthony, retraitement seulement après son accord.completed après le redémarrage (donc /v4/decide et /v4/apply répondent) ; une preuve rendue (/render-source-screenshot en 200 dans les logs) dès qu'un PUBLISH/UPDATE passe.Étape 6 — Rollback et validité de l'image.
docker tag cmc-event-engine-api:rollback-pre-<lot>-<AAAAMMJJ> <nom de l'image du service lu à l'étape 1> && docker compose up -d --no-deps --no-build event-engine-api, avec le même drain, puis git checkout --detach D dans le checkout pour que HEAD dise la vérité.prompts ; lot 4c : /social-audit/official-site-moves) ; (d) le code postérieur a écrit des données que l'ancien ne sait pas relire (ledgers). Au-delà : git revert du commit fautif sur main, nouveau build par P-API.drain_api.py (à écrire dans wip/<lot>/, avant le lot 4a)"""Drain the X lane around one `docker compose up -d`, always reactivate. Start at 09:56 UTC.
Usage: drain_api.py [--keep-blog] [--not-before 10:06] [--restart-by 10:08] -- <command...>"""
import datetime as dt, http.cookiejar, json, os, subprocess, sys, time, urllib.parse, urllib.request
B = "https://<instance n8n Pro>"
QUEUE, PROCESSOR, NORMALIZE, ENRICH, CORE, BLOG = ("o4cmp66lDjKDOF4v", "awrB2Ymt3iZPp14k", "9pA9xizup7Zcq846",
"nBnnkylOa2NRUegp", "1nswAXAfsck9e9uC", "mYAuzz1BuvjiJtEF")
op = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
def call(method, path, body=None):
r = urllib.request.Request(B + path, data=None if body is None else json.dumps(body).encode(), method=method,
headers={"Content-Type": "application/json", "Accept": "application/json"})
with op.open(r, timeout=120) as resp:
v = json.load(resp); return v.get("data", v)
call("POST", "/rest/login", {"emailOrLdapLoginId": os.environ.get("N8N_PRO_EMAIL", "<e-mail de connexion n8n>"), "password": os.environ["N8N_PRO_PASSWORD"]}) # n8n-pro.env ne contient que N8N_PRO_PASSWORD (vérifié 18/11)
def running(wid):
q = urllib.parse.urlencode({"limit": 50, "filter": json.dumps({"workflowId": wid, "status": ["running"]})})
return [r["id"] for r in call("GET", "/rest/executions?" + q).get("results", []) if r.get("stoppedAt") is None]
targets = [QUEUE] + ([] if "--keep-blog" in sys.argv else [BLOG])
saved = {w: call("GET", f"/rest/workflows/{w}") for w in targets}
assert all(d["active"] and d["versionId"] == d["activeVersionId"] for d in saved.values()), "unaligned before drain"
command = sys.argv[sys.argv.index("--") + 1:]
def today_at(flag, default):
hh, mm = (sys.argv[sys.argv.index(flag) + 1] if flag in sys.argv else default).split(":")
return dt.datetime.now(dt.UTC).replace(hour=int(hh), minute=int(mm), second=0, microsecond=0)
not_before, restart_by = today_at("--not-before", "10:06"), today_at("--restart-by", "10:08")
try:
for w in targets: call("POST", f"/rest/workflows/{w}/deactivate", {})
while any(running(w) for w in (PROCESSOR, NORMALIZE, ENRICH, CORE)) or dt.datetime.now(dt.UTC) < not_before:
if dt.datetime.now(dt.UTC) >= restart_by:
raise TimeoutError("X lane not drained by the restart limit: restart aborted for today")
time.sleep(5)
subprocess.run(command, check=True, timeout=180)
finally:
for w, d in saved.items():
call("POST", f"/rest/workflows/{w}/activate", {"versionId": d["activeVersionId"]})
back = call("GET", f"/rest/workflows/{w}")
print(w, back["active"], back["versionId"] == back["activeVersionId"] == d["activeVersionId"])
Lancer avec set -a; . ~/.local/state/coinmarketcal/n8n-pro.env; set +a dans la même commande ; le mot de passe n'apparaît ni en argument ni dans le fichier. Si le filtre status n'est pas accepté par n8n 2.47.3 (à vérifier une fois en lecture seule), filtrer côté client sur stoppedAt is None en paginant par cursor (limit=50, memory/feedback_n8n.md:430).
x-stream-collector, checkout /root/CMC-event-engine-x-stream)Reprend la procédure vérifiée de plan/lot1.md §5.3 et review/lot1-review.md (constats 8 et suivants), et docs/TOOLS.md:125-140.
Étape 0. P-GIT 1-5 ; « go déploiement » séparé de celui de l'API ; fenêtre 21:00-22:00, au moins 24 h après une livraison de l'API, pas le jour d'une autre intervention sur la voie X.
Étape 1 — Ce que la livraison emporte, recalculé le jour même (bloquant).
cd /root/CMC-event-engine-x-stream && git rev-parse --short HEAD && git status --short | head -3 # HEAD = commit documenté, arbre propre
git fetch origin main
git log --oneline <HEAD>..<S> -- 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
# après le lot 2, ajouter : src/services/web/__init__.py src/services/web/network.py
Liste de chemins identique à plan/lot1.md §5.3. Le résultat doit être égal à la liste relue par le lot ; sinon arrêt. La fermeture des imports de python -m src.x_stream est à recalculer si un lot l'a élargie (après le lot 1 livraison B : src.services.source_renderer.network, puis src.services.web.network après le lot 2).
Étape 2 — Contrôles. curl -fsS http://127.0.0.1:3284/health (healthy: true) ; docker exec x-stream-collector sh -c 'env | cut -d= -f1 | grep -iE "proxy|ssl_cert" || true' vide ; docker compose config --services ; docker compose version puis docker compose up --dry-run -d --no-deps x-stream-collector (détecte un « Pool overlaps » sur ipv6-egress) ; docker run --rm --entrypoint pip <image actuelle> freeze gardé.
Étape 3 — Build et redémarrage.
docker tag "$(docker inspect --format '{{.Image}}' x-stream-collector)" cmc-x-stream-collector:rollback-pre-<lot>-<AAAAMMJJ>
git checkout --detach <S>
docker compose build --progress=plain x-stream-collector 2>&1 | tee /root/build-collector-<lot>-<AAAAMMJJ>.log
docker run --rm --entrypoint pip <image construite> freeze # même critère d'arrêt que P-API étape 2 (couches avant `COPY src` CACHED, sinon pip, ffmpeg et Chromium comparés)
docker compose up -d --no-deps x-stream-collector
curl -fsS http://127.0.0.1:3284/health && docker exec root-n8n-1 wget -qO- http://x-stream-collector:3284/health
Ne lancer que ces deux commandes depuis ce dossier (son compose décrit aussi l'API et la sandbox : une commande globale créerait des doublons).
Étape 4 — Vérifications (15 min). healthy, rules_in_sync, required_recovery_pending=false, tweetapi_last_success_at récent ; RestartCount inchangé ; docker ps et docker network ls sans nouvel élément ; nouveaux Source Items X conformes aux attentes du lot ; X Stream Health sans alerte.
Étape 5 — Rollback. docker tag cmc-x-stream-collector:rollback-pre-<lot>-<AAAAMMJJ> <image du projet collecteur, docker compose images> && docker compose up -d --no-deps --no-build x-stream-collector, puis git checkout --detach <HEAD d'avant>. Tant qu'un commit utile au collecteur est déployé sur l'API mais pas sur le collecteur, l'écrire dans le journal : « poussé, pas encore déployé (collecteur) ».
Pour un workflow W, candidat C = fichier généré du dépôt, version live attendue V0, hash H0.
wip/) ; source canonique modifiée (R-STD, plan/lot4.md §3) ; simplify ; tests verts ; candidat régénéré ; P-GIT 3-5.deploy_guarded(..., apply=False) via le point d'entrée du paquet : garde editable_hash(live) == H0, versionId == activeVersionId == V0, liste des nœuds différents hors positions = exactement ceux attendus.deploy_guarded(..., apply=True, confirm_version=V0, publish=False), ou deploy_guarded_batch(..., publish=False) pour les paquets qui déploient par lot (coingecko_common/deploy.py) (modes ajoutés par le lot 4a) : PATCH, relecture du brouillon (versionId = V1, activeVersionId toujours V0, hash = C). La production continue sur V0. Avant le lot 4a : PATCH gardé équivalent (même lecture, même contrôle de version et de hash, PATCH, relecture), sans activate (#46 : un PATCH ne publie pas).Workflow Notes si besoin, couleur par défaut, taille ajustée au contenu rendu (.n8n-sticky → firstElementChild.firstElementChild.scrollHeight, memory/feedback_n8n.md:27), au-dessus du bord gauche avec un espacement régulier.wip/<lot>/screenshots/ ; chemin heureux de gauche à droite, erreurs en dessous, note bien placée, pas de grand vide. Pour un workflow en ordre d'exécution v1, noter si Tidy Up a changé l'ordre vertical de branches parallèles (n8n exécute les branches de haut en bas) et vérifier que c'est sans effet.position (paramètres, connexions, réglages, credentials, code, prompts, contenu de la note). Si l'éditeur a normalisé quelque chose (déjà vu : appendAttribution=false, method: GET, onError retirés), PATCH des valeurs exactes en gardant les positions finales, relire, recomparer. Contrôler chaque nœud Telegram un par un.POST /rest/workflows/W/activate {"versionId": <brouillon final>} (après 4a : publish_reviewed_draft, qui refait la comparaison de l'étape 9 avant d'activer).active: true, versionId == activeVersionId = version publiée.candidate_hash == live_hash. Commit de checkpoint (P-GIT 3-4).Drain : seulement si le lot l'exige (même mécanisme que P-API étape 3, autour de la seule publication). Une publication ne coupe pas une exécution en cours : l'exécution garde la définition chargée à son départ, et les appels suivants chargent la version publiée (Context7 /n8n-io/n8n-docs : « Production executions always point to the currently published version » ; constat local memory/feedback_n8n.md:158-166). Un workflow à déclencheur Telegram ou webhook réenregistre son déclencheur à la publication.
Rollback.
activate pour réaligner versionId == activeVersionId.live-preflight.json puis activate (deploy_workflow.py _rollback, :152-176) ; en urgence, POST /activate {"versionId": V0} (une version de l'historique est acceptée), puis PATCH de V0 pour réaligner.n8n (session unique par script : POST /rest/login est limité, memory/feedback_n8n.md:429).
GET /rest/workflows/<id> → active, versionId, activeVersionId.GET /rest/executions?limit=50&filter={"workflowId":"<id>","status":["running"]} pour ROCqWGUxAbIgtcHV, iPaKN8gRPFt4KyjQ, mYAuzz1BuvjiJtEF, N1ZmFfrgKQ5o0m83.awrB2Ymt3iZPp14k, 9pA9xizup7Zcq846, nBnnkylOa2NRUegp, 1nswAXAfsck9e9uC.GET /rest/executions?limit=50&filter={"status":["error"],"startedAfter":"<ISO>"} (pagination par cursor).Base produit (dans le conteneur API, timeout 60 docker exec -i event-engine-api python - <<'PY' ; from src.db import engine ; from sqlalchemy import text ; dans with engine.connect() as c:, exécuter d'abord SET TRANSACTION READ ONLY et SET LOCAL statement_timeout = '30s', puis la requête, puis c.rollback()) :
SELECT count(*) FROM event_engine_processing_attempt WHERE started_at >= now() - interval '10 minutes' et SELECT count(*), min(eligible_at) FROM event_engine_source_item WHERE source_type <> 'blog' AND status IN ('queued','retry_scheduled') AND eligible_at <= now() - interval '2 minutes' ; alerte si la seconde est non nulle depuis plus de 10 min et la première nulle.SELECT id, failure_reason, left(last_error, 200), blocked_at FROM event_engine_source_item WHERE blocked_at >= '<heure du redémarrage>' AND failure_reason = 'x_context_execution_failed'.SELECT status, count(*) FROM event_engine_processing_attempt WHERE started_at >= '<heure du redémarrage>' GROUP BY 1.