Interpréter le dispositif d'un amendement parlementaire
Classifier les dispositifs d'amendements Assemblée et Sénat en suppression, insertion, substitution, rédaction globale, article additionnel ou opération complexe, afin de préparer une consolidation automatique fiable.
Contenu de la recette
Cette recette est indexée par Moulineuse et peut servir de point de départ pour vos explorations SQL, Typesense ou scripts agents.
Objectif
Classifier le dispositif d'un amendement pour savoir s'il peut être appliqué automatiquement à un texte pastillé.
Catégories principales :
- suppression ;
- insertion ;
- substitution ;
- rédaction globale ;
- article additionnel ;
- coordination ou opération complexe ;
- ambigu / non consolidable automatiquement.
Cette recette est nécessaire avant toute consolidation fiable : il ne suffit pas qu'un amendement soit adopté, il faut comprendre exactement quelle opération il porte, sur quel article, quels alinéas, quels mots et dans quel ordre.
Point clé
Le dispositif est la source normative principale. L'objet ou l'exposé sommaire peut aider à comprendre l'intention, mais ne doit pas être utilisé pour appliquer automatiquement une modification.
Toujours distinguer :
- la localisation structurée fournie par les données (
article,alinea,subid,mot) ; - l'opération écrite dans le dispositif ;
- le sort de l'amendement ;
- l'ordre de discussion ;
- la version rectifiée éventuellement adoptée.
Sources à utiliser
Assemblée nationale :
assemblee.amendements.data -> 'corps' -> 'contenuAuteur' ->> 'dispositif';assemblee.amendements.data -> 'corps' -> 'contenuAuteur' ->> 'exposeSommaire'seulement comme aide ;pointeurFragmentTexte.divisionetpointeurFragmentTexte.alineapour la localisation ;cycleDeVie.sortpour filtrer les amendements adoptés ;tripour l'ordre.
Sénat :
senat.ameli_amd.dispour le dispositif ;senat.ameli_amd.objseulement comme aide ;senat.ameli_amd.alinea,subpos,mot,subidetsenat.ameli_subpour la localisation ;senat.ameli_sor.libpour le sort ;senat.ameli_amd.ordpour l'ordre.
Recettes complémentaires :
assemblee_consolider_article_apres_amendements;senat_consolider_article_apres_amendements;assemblee_comparer_texte_support_et_texte_adopte;senat_comparer_texte_support_et_texte_adopte;retrouver_amendement_integral_seance_assemblee;retrouver_amendement_integral_seance_senat.
1. Récupérer le dispositif et le contexte
Assemblée nationale
SELECT
a.uid AS amendement_uid,
a.data ->> 'triAmendement' AS tri,
a.data -> 'identification' ->> 'numeroLong' AS numero,
a.data -> 'identification' ->> 'numeroRect' AS numero_rect,
a.data ->> 'texteLegislatifRef' AS texte_ref,
a.data -> 'pointeurFragmentTexte' -> 'division' ->> 'articleDesignationCourte' AS article_court,
a.data -> 'pointeurFragmentTexte' -> 'division' ->> 'articleDesignation' AS article,
a.data -> 'pointeurFragmentTexte' -> 'alinea' ->> 'numero' AS numero_alinea,
a.data -> 'pointeurFragmentTexte' -> 'alinea' ->> 'alineaDesignation' AS alinea,
a.data -> 'cycleDeVie' ->> 'sort' AS sort,
a.data -> 'corps' -> 'contenuAuteur' ->> 'dispositif' AS dispositif_html,
regexp_replace(
regexp_replace(a.data -> 'corps' -> 'contenuAuteur' ->> 'dispositif', '<[^>]+>', ' ', 'g'),
'\s+',
' ',
'g'
) AS dispositif_texte,
regexp_replace(
regexp_replace(a.data -> 'corps' -> 'contenuAuteur' ->> 'exposeSommaire', '<[^>]+>', ' ', 'g'),
'\s+',
' ',
'g'
) AS expose_sommaire_texte
FROM assemblee.amendements AS a
WHERE a.uid = $1;
Sénat
SELECT
a.id AS amendement_id,
trim(a.num) AS numero,
a.ord AS ordre_discussion,
a.txtid AS texte_ameli_id,
COALESCE(trim(sub.lib), trim(sub.lic), trim(a.mot)) AS article_ou_emplacement,
a.alinea,
a.subpos,
trim(sor.lib) AS sort_label,
a.dis AS dispositif_html,
regexp_replace(regexp_replace(COALESCE(a.dis, ''), '<[^>]+>', ' ', 'g'), '\s+', ' ', 'g') AS dispositif_texte,
regexp_replace(regexp_replace(COALESCE(a.obj, ''), '<[^>]+>', ' ', 'g'), '\s+', ' ', 'g') AS objet_texte
FROM senat.ameli_amd AS a
LEFT JOIN senat.ameli_sub AS sub
ON sub.id = a.subid
LEFT JOIN senat.ameli_sor AS sor
ON sor.id = a.sorid
WHERE a.id = $1;
2. Normaliser le dispositif
Normaliser pour la classification, mais conserver le HTML ou le texte original pour les citations.
function decodeBasicHtml(s) {
const named = {
nbsp: " ",
apos: "'",
quot: '"',
amp: "&",
lt: "<",
gt: ">",
oelig: "oe",
OElig: "OE",
}
return String(s ?? "")
.replace(/&#x([0-9a-fA-F]+);/g, (_, h) =>
String.fromCodePoint(parseInt(h, 16)),
)
.replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
.replace(/&([a-zA-Z]+);/g, (_, n) => named[n] ?? `&${n};`)
}
function normalizeDispositif(htmlOrText) {
return decodeBasicHtml(htmlOrText)
.replace(/<br\s*\/?>/gi, "\n")
.replace(/<\/p\s*>/gi, "\n")
.replace(/<[^>]+>/g, " ")
.normalize("NFKC")
.replace(/\u00a0/g, " ")
.replace(/[’']/g, "'")
.replace(/[«»]/g, '"')
.replace(/[ \t\r\n]+/g, " ")
.trim()
}
Normalisations utiles pour les patrons :
- convertir
premier,1er,I,IIseulement si nécessaire et sans perdre le libellé original ; - traiter
alinéaetalineacomme équivalents ; - traiter
après,apres,avant,à la fin,au début; - conserver les guillemets ou chevrons autour des mots remplacés, car ils délimitent souvent les chaînes à modifier.
3. Taxonomie des opérations
Suppression
Supprime un article, un alinéa, une phrase, des mots ou une référence.
Patrons fréquents :
Supprimer cet article.;Supprimer l'alinéa N.;Supprimer les alinéas N à M.;À l'alinéa N, supprimer les mots : "...";À la première phrase de l'alinéa N, supprimer les mots : "...".
Sortie structurée :
{
"operation": "suppression",
"target": {
"kind": "article|alinea|range_alineas|phrase|mots",
"article": "Article 3",
"alineas": [4],
"words": "..."
},
"confidence": "high"
}
Consolidation automatique possible si la cible est explicite et unique. Prudence si le dispositif supprime des mots présents plusieurs fois dans le même alinéa.
Insertion
Insère des mots, une phrase, un alinéa ou plusieurs alinéas dans un article existant.
Patrons fréquents :
Après l'alinéa N, insérer l'alinéa suivant : "...";Après le mot : "...", insérer les mots : "...";Compléter cet article par l'alinéa suivant : "...";À la fin de l'alinéa N, insérer les mots : "...";Au début de l'alinéa N, insérer les mots : "...".
Sortie structurée :
{
"operation": "insertion",
"target": {
"kind": "apres_alinea|avant_alinea|apres_mots|fin_alinea|debut_alinea",
"alinea": 5,
"anchor": "..."
},
"payload": {
"kind": "mots|phrase|alinea|alineas",
"text": "..."
},
"confidence": "high"
}
Consolidation automatique possible si l'ancre est unique et si le texte inséré est clairement délimité.
Substitution
Remplace des mots, une phrase, un alinéa ou une plage d'alinéas par un autre contenu.
Patrons fréquents :
Substituer au mot : "ancien" le mot : "nouveau";Substituer aux mots : "..." les mots : "...";À l'alinéa N, substituer aux mots : "..." les mots : "...";Substituer à l'alinéa N l'alinéa suivant : "...";Substituer aux alinéas N à M les alinéas suivants : "...".
Sortie structurée :
{
"operation": "substitution",
"target": {
"kind": "mot|mots|alinea|range_alineas",
"alinea": 2,
"oldText": "ancien"
},
"payload": {
"newText": "nouveau"
},
"confidence": "high"
}
Consolidation automatique possible si oldText apparaît une seule fois dans la cible. Si oldText apparaît plusieurs fois, demander validation ou utiliser le texte adopté comme contrôle.
Rédaction globale
Remplace tout un article, une subdivision ou une plage importante par une rédaction nouvelle.
Patrons fréquents :
Rédiger ainsi cet article : "...";L'article N est ainsi rédigé : "...";Rédiger ainsi l'alinéa N : "...";La section ... est ainsi rédigée : "...".
Sortie structurée :
{
"operation": "redaction_globale",
"target": {
"kind": "article|alinea|section",
"article": "Article 4"
},
"payload": {
"text": "..."
},
"confidence": "high"
}
Consolidation automatique possible pour remplacer l'article complet si les bornes de l'article sont connues. C'est souvent plus sûr que d'appliquer une série de substitutions fines.
Article additionnel
Crée un nouvel article avant ou après un article existant.
Patrons fréquents :
Après l'article N, insérer un article additionnel ainsi rédigé : "...";Après l'article N, il est inséré un article N bis ainsi rédigé : "...";Avant l'article N, insérer un article ainsi rédigé : "...";Après l'article N, insérer la division et l'article suivants : ....
Sortie structurée :
{
"operation": "article_additionnel",
"target": {
"kind": "apres_article|avant_article",
"article": "Article 3"
},
"payload": {
"articleLabel": "Article 3 bis",
"text": "..."
},
"confidence": "high"
}
Ne pas appliquer comme modification d'un article existant. Chercher l'article additionnel dans le texte adopté si disponible.
Coordination ou opération complexe
Cas où l'amendement contient plusieurs opérations ou des instructions dépendantes.
Exemples :
En conséquence, ...;- plusieurs I, II, III portant sur des articles différents ;
- coordination de références dans plusieurs codes ;
- dispositif conditionnel ;
- amendement de réécriture comprenant suppressions, substitutions et insertions.
Sortie structurée :
{
"operation": "complexe",
"subOperations": [
{ "operation": "suppression", "target": { "kind": "mots" } },
{ "operation": "insertion", "target": { "kind": "apres_alinea" } }
],
"confidence": "medium",
"requiresManualReview": true
}
Ne pas consolider automatiquement si toutes les sous-opérations ne sont pas interprétées avec certitude.
4. Ordre de classification recommandé
Appliquer les tests dans cet ordre pour éviter les faux positifs :
- article additionnel (
Après/Avant l'article ... insérer un article) ; - rédaction globale (
Rédiger ainsi cet article,est ainsi rédigé) ; - substitution (
substituer à/au/aux ...) ; - suppression (
supprimer ...) ; - insertion (
insérer,compléter,ajouter) ; - coordination ou complexe (
En conséquence, plusieurs opérations, plusieurs parties numérotées) ; - ambigu.
Raison : un article additionnel contient souvent le verbe insérer, et une rédaction globale peut contenir plusieurs alinéas qui ressemblent à des insertions.
5. Patrons JavaScript de classification
Ces patrons servent de première passe. Ils ne remplacent pas le contrôle juridique.
const patterns = [
{
operation: "article_additionnel",
confidence: "high",
regex:
/\b(?:apres|après|avant)\s+l['’]article\s+([^,.;]+).*\b(?:inserer|insérer|ajouter)\s+(?:un\s+)?article\b/i,
},
{
operation: "redaction_globale",
confidence: "high",
regex:
/\b(?:rediger|rédiger)\s+ainsi\s+(?:cet\s+article|l['’]article|l['’]alinea|l['’]alinéa)|\best\s+ainsi\s+(?:redige|rédigé)\b/i,
},
{
operation: "substitution",
confidence: "high",
regex: /\bsubstituer\s+(?:a|à|au|aux)\b/i,
},
{
operation: "suppression",
confidence: "high",
regex: /\bsupprimer\b|\best\s+supprime\b|\best\s+supprimé\b/i,
},
{
operation: "insertion",
confidence: "high",
regex: /\b(?:inserer|insérer|ajouter|completer|compléter)\b/i,
},
{
operation: "complexe",
confidence: "medium",
regex: /\ben\s+consequence\b|\ben\s+conséquence\b|\b[IVX]+\s*[\.\-–]/i,
},
]
function classifyDispositif(dispositif) {
const normalized = normalizeDispositif(dispositif).toLowerCase()
const matches = patterns.filter(({ regex }) => regex.test(normalized))
if (matches.length === 0) {
return {
operation: "ambigu",
confidence: "low",
requiresManualReview: true,
}
}
const first = matches[0]
const isComplex = matches.length > 1 || /\b[ivx]+\s*[\.\-–]/i.test(normalized)
return {
operation:
isComplex && first.operation !== "article_additionnel"
? "complexe"
: first.operation,
primaryOperation: first.operation,
detectedOperations: matches.map((match) => match.operation),
confidence: isComplex ? "medium" : first.confidence,
requiresManualReview: isComplex,
}
}
6. Extraire les paramètres utiles
La classification doit être enrichie par des paramètres extraits du dispositif et des métadonnées.
Localisation
À récupérer en priorité depuis les données structurées :
- Assemblée :
articleDesignationCourte,articleDesignation,numero_alinea,alineaDesignation; - Sénat :
ameli_sub.lib,ameli_sub.lic,a.mot,a.alinea,a.subpos.
À compléter depuis le dispositif :
function extractAlineaRange(text) {
const normalized = normalizeDispositif(text)
const range =
/(?:alineas|alinéas|alinea|alinéa)\s+(\d+)\s+(?:a|à)\s+(\d+)/i.exec(
normalized,
)
if (range) return { start: Number(range[1]), end: Number(range[2]) }
const single = /(?:alinea|alinéa)\s+(\d+)/i.exec(normalized)
if (single) return { start: Number(single[1]), end: Number(single[1]) }
return null
}
function extractQuotedParts(text) {
const normalized = normalizeDispositif(text)
return [...normalized.matchAll(/"([^"]+)"/g)].map((match) => match[1].trim())
}
Ancien et nouveau texte
Pour une substitution, convention utile :
- premier bloc cité : texte à remplacer ;
- second bloc cité : texte de remplacement.
Mais vérifier les formulations : certaines rédigent substituer les mots : "nouveau" aux mots : "ancien", donc l'ordre peut être inversé.
Patrons à distinguer :
substituer aux mots : "ancien" les mots : "nouveau"
substituer les mots : "nouveau" aux mots : "ancien"
Si le patron exact n'est pas reconnu, classer substitution avec confidence = medium et requiresManualReview = true.
7. Déterminer si l'amendement est consolidable automatiquement
Critères pour autoApplicable = true :
- amendement adopté ;
- dispositif classé avec
confidence = high; - une seule opération principale ;
- cible claire : article, alinéa, plage ou ancre textuelle unique ;
- payload clairement délimité ;
- pas de mention
En conséquencenon interprétée ; - pas de contradiction entre localisation structurée et dispositif ;
- pas de doublon ou amendement identique à ne pas appliquer deux fois.
Critères pour requiresManualReview = true :
- plusieurs opérations dans le même dispositif ;
- cible absente ou ambiguë ;
- mots à remplacer présents plusieurs fois ;
- rédaction conditionnelle ;
- coordination dans plusieurs articles ou codes ;
- amendement rectifié dont la version applicable n'est pas certaine ;
- dispositif contenant seulement une intention sans instruction normative claire.
8. Format de sortie recommandé
Pour chaque amendement :
{
"amendement": {
"chambre": "assemblee|senat",
"id": "...",
"numero": "756",
"sort": "Adopté",
"ordre": 123
},
"classification": {
"operation": "substitution",
"primaryOperation": "substitution",
"confidence": "high",
"autoApplicable": true,
"requiresManualReview": false
},
"target": {
"article": "Article 14",
"alineas": [5],
"anchor": "ancien texte"
},
"payload": {
"oldText": "ancien texte",
"newText": "nouveau texte"
},
"warnings": []
}
Si l'amendement n'est pas consolidable automatiquement :
{
"classification": {
"operation": "complexe",
"confidence": "medium",
"autoApplicable": false,
"requiresManualReview": true
},
"warnings": [
"Le dispositif contient plusieurs opérations.",
"La deuxième substitution ne précise pas un alinéa unique."
]
}
9. Ordre d'application dans une consolidation
Une fois les amendements classifiés :
Assemblée :
- appliquer seulement les amendements adoptés ;
- trier par
data ->> 'triAmendement' ASC NULLS LAST; - vérifier les amendements identiques ou en discussion commune ;
- conserver les numéros d'alinéas originaux et les positions courantes.
Sénat :
- appliquer seulement les amendements adoptés (
ameli_sor.lib ILIKE '%adopt%') ; - trier par
ord ASC NULLS LAST, id ASC; - utiliser
alineaetsubposcomme indices, mais vérifier le dispositif ; - contrôler les rectifications.
Ne pas appliquer automatiquement un amendement classé complexe, ambigu ou requiresManualReview = true sans contrôle humain ou comparaison avec le texte adopté.
10. Pièges fréquents
- Un amendement
Après l'article Nn'est pas une modification de l'article N : c'est souvent un article additionnel. - Une rédaction globale d'article remplace tout le bloc, même si elle contient des phrases proches du texte initial.
- Une substitution de mots échoue si les mots apparaissent plusieurs fois dans l'alinéa ciblé.
- Un dispositif peut contenir plusieurs parties
I.,II.,III.qui touchent des articles différents. - L'objet ou l'exposé sommaire peut être plus clair que le dispositif, mais il ne doit pas être appliqué comme norme.
- Les amendements rectifiés nécessitent de vérifier que le dispositif récupéré est bien la version adoptée.
- Certains amendements de coordination ne peuvent être validés qu'en comparant avec le texte adopté.
- Les alinéas peuvent être renumérotés après insertion ou suppression ; garder une table de correspondance.
Réponse utilisateur recommandée
Quand l'utilisateur demande une consolidation, annoncer le niveau de confiance :
J'ai classé les amendements adoptés avant consolidation.
| Amendement | Opération | Cible | Application auto | Réserve |
| ---------- | ------------------- | ------------------ | ---------------- | --------------------------------- |
| 756 | substitution | alinéa 5 | oui | ancre unique |
| 857 | article additionnel | après l'article 14 | non | à rechercher dans le texte adopté |
| 1306 | complexe | plusieurs alinéas | non | contrôle manuel requis |
Formule de prudence :
Je n'applique automatiquement que les dispositifs dont l'opération, la cible et le texte à insérer ou remplacer sont identifiés avec un niveau de confiance élevé. Les autres amendements sont listés séparément et doivent être contrôlés avec le texte adopté ou manuellement.
Workflow court
- Récupérer le dispositif, le sort, l'article, l'alinéa et l'ordre.
- Normaliser le dispositif pour la classification.
- Classer l'opération dans l'ordre recommandé.
- Extraire la cible et le payload.
- Déterminer
autoApplicableetrequiresManualReview. - Appliquer uniquement les amendements adoptés, simples et non ambigus.
- Contrôler le résultat avec le texte adopté quand il existe.
À propos de ces recettes
Les recettes Moulineuse documentent des requêtes et des méthodes réutilisables pour analyser les données juridiques et parlementaires avec les outils Tricoteuses. Elles servent aussi directement au serveur MCP Moulineuse pour guider les usages et les extractions possibles.
Voir le serveur MCP Moulineuse