v0.1.1 : version et dist reconstruit

Patch (AGENTS règle 5 : correction, aucune sortie nouvelle — la quantité d'un
poste passe par `dimension`, qui existait). Étiquette et merge au checkpoint de
la session de pilotage ; montée dans reinnover le même jour (ouvre P1.2b).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Tgtn7bJxTLiL2fRCkQMgtR

dist/autonomie/noyau/algo.js

@@ -55,22 +55,40 @@ export function finaliseSelection(selection, budget_total, options, postes, inpu
     };
     let status_final = final_pre.status;
     let message_final = final_pre.message;
-    for (let passe = 0; passe < 2; passe++) {
+    // Correctif v0.1.1 (SPEC menu §12 n° 2 et 3) : `reajusteBudget` renvoie en
+    // écho le journal qu'il reçoit ; l'origine le ré-ajoutait à chaque tour (chaque
+    // FORCE apparaissait deux à quatre fois). Le journal ne s'enrichit que des
+    // lignes nouvelles de `appliqueCouplages`. La boucle ne se contentait que du
+    // dépassement : un réajustement qui lâche des accessoires forcés (principal
+    // retiré ou changé) laissait le total loin sous le budget sans rien recombler.
+    // Désormais : couplages → dans la bande [−underspend, +overrun] ? fin ;
+    // sinon réajuste (CAS A ou B) → couplages…, trois tours au plus, et toujours
+    // une passe couplages en dernier. Si le dernier forçage refranchit le seuil,
+    // le statut le dit.
+    const tol_under = (config.tolerances && config.tolerances.budget_underspend_pct) || 15;
+    const seuil_under = budget_total * (1 - tol_under / 100);
+    const dans_la_bande = (t) => t <= seuil_over && t >= seuil_under;
+    const prend = (avec) => {
+        etat = { axes: avec.axes, couplages_appliques: [...etat.couplages_appliques, ...(avec.couplages_appliques || [])] };
+    };
+    for (let passe = 0; passe < 3; passe++) {
         // IMPORTANT: appliqueCouplages attend selection = { eau, energie, alim } directement
-        const avec = appliqueCouplages(etat.axes, options, postes, reglages, false);
+        prend(appliqueCouplages(etat.axes, options, postes, reglages, false));
-        etat = {
+        if (dans_la_bande(sommeAxes(etat.axes)))
-            axes: avec.axes,
-            couplages_appliques: [...etat.couplages_appliques, ...(avec.couplages_appliques || [])],
-        };
-        if (sommeAxes(etat.axes) <= seuil_over)
             break;
         const re = reajusteBudget(etat, budget_total, options, postes, inputs, contexte, reglages, false);
-        etat = {
+        etat = { axes: re.axes, couplages_appliques: etat.couplages_appliques };
-            axes: re.axes,
-            couplages_appliques: [...etat.couplages_appliques, ...(re.couplages_appliques || [])],
-        };
         status_final = re.status;
         message_final = re.message;
+        // Bloqué (rien à ajouter, ou plancher atteint) ou dernier tour : une passe couplages et fin
+        if (passe === 2 || re.status !== 'OK') {
+            prend(appliqueCouplages(etat.axes, options, postes, reglages, false));
+            break;
+        }
+    }
+    if (sommeAxes(etat.axes) > seuil_over && status_final === 'OK') {
+        status_final = 'BUDGET_INSUFFISANT';
+        message_final = 'Budget insuffisant : les couplages requis portent le total à ' + sommeAxes(etat.axes) + ' EUR pour un budget de ' + Math.round(budget_total) + ' EUR.';
     }
     return {
         axes: etat.axes,

dist/autonomie/noyau/couplages.d.ts

@@ -3,6 +3,17 @@ export interface ResultatCouplages {
     axes: Selection;
     couplages_appliques: string[];
 }
+/** Codes requis (alias résolus) par les lignes NON forcées de la sélection. */
+export declare function codesRequisPar(axes: Selection, alias: Record<string, string>): Set<string>;
+/** Codes des lignes NON forcées (les choix de postes, par opposition aux accessoires forcés). */
+export declare function codesChoisis(axes: Selection): Set<string>;
+/**
+ * Retire EN PLACE les lignes forcées devenues inutiles et recalcule les
+ * sous-totaux : celles que plus aucune ligne ne requiert (orphelines), et
+ * celles dont la typologie est déjà le choix d'un poste (le requis est
+ * satisfait par ce choix, la ligne forcée est absorbée). Rend le journal.
+ */
+export declare function retireForcesOrphelins(axes: Selection, alias: Record<string, string>): string[];
 /**
  * Post-traitement déterministe des couplages.
  *

dist/autonomie/noyau/couplages.js

@@ -8,6 +8,13 @@
 // Note (origine, conservée) : le marqueur `_conflit_avec` de la passe 2 est
 // posé sur des copies de postes et n'atteint jamais la sortie ; le
 // « downgrade planifié » n'a donc jamais lieu. À corriger en patch, avec test.
+//
+// Correctif v0.1.1 (SPEC menu §12 n° 2 et 5) : une ligne forcée que plus
+// aucune ligne ne requiert est RETIRÉE (passe 0). À l'origine, un accessoire
+// forcé (conduit, ballon tampon, filière d'épuration) survivait au retrait ou
+// au downgrade de son principal, verrouillé pour toujours par
+// `force_par_couplage` — d'où des conduits sans poêle et des planchers de
+// coût infranchissables (statut INSUFFISANT à 6 000 € mais OK à 3 000 €).
 import { cout_typologie, dimension_optimale } from './dimension.js';
 function copieSelection(selection) {
     const copie = {};
@@ -20,6 +27,62 @@ function copieSelection(selection) {
     }
     return copie;
 }
+const AXES_LIST = ['eau', 'energie', 'alim'];
+/** Codes requis (alias résolus) par les lignes NON forcées de la sélection. */
+export function codesRequisPar(axes, alias) {
+    const requis = new Set();
+    for (const axe of AXES_LIST) {
+        for (const p of axes[axe]?.postes ?? []) {
+            if (p.force_par_couplage)
+                continue;
+            for (const r of p.couplages_requis || [])
+                requis.add(alias[r] || r);
+        }
+    }
+    return requis;
+}
+/** Codes des lignes NON forcées (les choix de postes, par opposition aux accessoires forcés). */
+export function codesChoisis(axes) {
+    const codes = new Set();
+    for (const axe of AXES_LIST)
+        for (const p of axes[axe]?.postes ?? [])
+            if (!p.force_par_couplage)
+                codes.add(p.typologie_choisie);
+    return codes;
+}
+/**
+ * Retire EN PLACE les lignes forcées devenues inutiles et recalcule les
+ * sous-totaux : celles que plus aucune ligne ne requiert (orphelines), et
+ * celles dont la typologie est déjà le choix d'un poste (le requis est
+ * satisfait par ce choix, la ligne forcée est absorbée). Rend le journal.
+ */
+export function retireForcesOrphelins(axes, alias) {
+    const requis = codesRequisPar(axes, alias);
+    const choisis = codesChoisis(axes);
+    const log = [];
+    for (const axe of AXES_LIST) {
+        const a = axes[axe];
+        if (!a)
+            continue;
+        const gardes = [];
+        for (const p of a.postes) {
+            if (p.force_par_couplage && !requis.has(p.typologie_choisie)) {
+                log.push('RETIRE "' + p.typologie_choisie + '" (plus requis par aucun poste) -' + (p.cout_eur_ht || 0) + 'EUR dans axe ' + axe);
+            }
+            else if (p.force_par_couplage && choisis.has(p.typologie_choisie)) {
+                log.push('ABSORBE "' + p.typologie_choisie + '" (déjà le choix d\'un poste) -' + (p.cout_eur_ht || 0) + 'EUR dans axe ' + axe);
+            }
+            else {
+                gardes.push(p);
+            }
+        }
+        if (gardes.length !== a.postes.length) {
+            a.postes = gardes;
+            a.sous_total_eur_ht = gardes.reduce((s, p) => s + (p.cout_eur_ht || 0), 0);
+        }
+    }
+    return log;
+}
 /**
  * Post-traitement déterministe des couplages.
  *
@@ -41,10 +104,11 @@ export function appliqueCouplages(selection_recue, options, postes, reglages, _d
     function resolveCode(code) {
         return alias[code] || code;
     }
-    const axes_list = ['eau', 'energie', 'alim'];
+    const axes_list = AXES_LIST;
+    // Passe 0 (v0.1.1) : lâcher les accessoires forcés dont le principal a disparu.
+    const couplages_log = retireForcesOrphelins(selection, alias);
     const tous_postes = axes_list.flatMap((axe) => (selection[axe] && selection[axe].postes ? selection[axe].postes : []).map((p) => Object.assign({}, p, { _axe: axe })));
     const codes_selectionnes = new Set(tous_postes.map((p) => p.typologie_choisie));
-    const couplages_log = [];
     // Passe 1 : couplages_requis
     for (const poste of tous_postes) {
         const requis_list = poste.couplages_requis || [];

dist/autonomie/noyau/index.d.ts

@@ -1,4 +1,5 @@
-export { selectionner } from './algo.js';
+export { selectionner, finaliseSelection } from './algo.js';
+export type { SelectionFinalisee } from './algo.js';
 export { dimension_optimale, cout_typologie } from './dimension.js';
 export { adequation_contexte } from './adequation.js';
 export type { AdequationDebug } from './adequation.js';
@@ -6,7 +7,7 @@ export { pondereAxes } from './pondere-axes.js';
 export type { PoidsDebug } from './pondere-axes.js';
 export { alloueBudget } from './alloue-budget.js';
 export { selectionnePoste } from './selectionne-poste.js';
-export { appliqueCouplages } from './couplages.js';
+export { appliqueCouplages, codesChoisis, codesRequisPar, retireForcesOrphelins } from './couplages.js';
 export type { ResultatCouplages } from './couplages.js';
 export { reajusteBudget } from './reajuste.js';
 export type { EntreeReajuste, ResultatReajuste } from './reajuste.js';

dist/autonomie/noyau/index.js

@@ -1,12 +1,12 @@
 // @transformer/moteurs/autonomie/noyau — le cœur V2 du simulateur autonomie,
 // pipeline complet (celui de calculs.trans-former.fr), sans singleton ni I/O.
-export { selectionner } from './algo.js';
+export { selectionner, finaliseSelection } from './algo.js';
 export { dimension_optimale, cout_typologie } from './dimension.js';
 export { adequation_contexte } from './adequation.js';
 export { pondereAxes } from './pondere-axes.js';
 export { alloueBudget } from './alloue-budget.js';
 export { selectionnePoste } from './selectionne-poste.js';
-export { appliqueCouplages } from './couplages.js';
+export { appliqueCouplages, codesChoisis, codesRequisPar, retireForcesOrphelins } from './couplages.js';
 export { reajusteBudget } from './reajuste.js';
 export { configPourAxes, auMoinsUnAxe } from './axes-actifs.js';
 export { clamp01, clamp, roundToStep, ZONE_BIOGEO_MAP, zoneRtToClass } from './calibrage.js';

dist/autonomie/noyau/reajuste.js

@@ -7,6 +7,21 @@
 // Note (origine, conservée) : les messages utilisent toLocaleString('fr-FR')
 // (Intl). Texte de présentation, non assert par les tests ; à sortir du noyau
 // en patch si l'octet-pour-octet inter-environnements devient un besoin.
+//
+// Correctifs v0.1.1 (SPEC menu §12 n° 1, 2, 3, 5, 7) :
+//  - CAS A : un downgrade ne cible jamais une typologie déjà présente (le conduit
+//    forcé se retrouvait en double) ; après chaque retrait ou downgrade, les
+//    accessoires forcés que plus rien ne requiert sont lâchés (le plancher de
+//    coût n'est plus verrouillé par des couplages orphelins).
+//  - CAS B, stratégie 1 : une ligne forcée n'est jamais « upgradée » (elle est
+//    une contrainte, pas un choix ; l'origine la triait en tête avec son score
+//    0,8 et la transformait, puis la passe suivante re-forçait l'original) ;
+//    la cible d'un upgrade n'est jamais une typologie déjà présente.
+//  - CAS B, stratégie 2 : un poste = une ligne. L'origine ajoutait une 2e, 3e…
+//    option au même poste (jusqu'à cinq `basse_planche_bec`), parce qu'elle
+//    testait le code et pas le poste, sur une liste figée avant la boucle.
+//    La quantité d'un poste est portée par `dimension`, pas par des lignes.
+import { codesChoisis, retireForcesOrphelins } from './couplages.js';
 import { cout_typologie, dimension_optimale } from './dimension.js';
 import { parseJsonArr } from './types.js';
 export function reajusteBudget(apres_couplages, budget_total, options, postes, inputs, contexte_derived, reglages, debug = false) {
@@ -15,11 +30,46 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
     const tolerances = config.tolerances || {};
     const overrun_seuil = 1 + (tolerances.budget_overrun_pct || 5) / 100;
     const underspend_seuil = 1 - (tolerances.budget_underspend_pct || 15) / 100;
+    const alias = config.couplages_alias || {};
     const axes = apres_couplages.axes;
     const axes_list = ['eau', 'energie', 'alim'];
     function getTousPostes() {
         return axes_list.flatMap((axe) => (axes[axe] && axes[axe].postes ? axes[axe].postes : []).map((p) => Object.assign({}, p, { _axe: axe })));
     }
+    /** Lâche les accessoires forcés orphelins ou absorbés ; vrai si quelque chose a bougé. */
+    function lacheOrphelins() {
+        const retires = retireForcesOrphelins(axes, alias);
+        if (retires.length && log)
+            log.push(...retires);
+        return retires.length > 0;
+    }
+    /**
+     * Coût des lignes forcées que lâcherait le passage de `ligne` à la typologie
+     * `nouveau` (null = retrait de la ligne) : ses requis que plus personne ne
+     * demande, et la ligne forcée que le nouveau choix absorbe. Sert aux
+     * arbitrages (CAS A « au plus près du budget », CAS B « tient dans le seuil »)
+     * pour que le total prévu soit celui que la passe couplages rendra.
+     */
+    function coutLibere(ligne, nouveau, instantane) {
+        const requis_autres = new Set();
+        for (const p of instantane) {
+            if (p.force_par_couplage || p === ligne || (p.typologie_choisie === ligne.typologie_choisie && p._axe === ligne._axe))
+                continue;
+            for (const r of p.couplages_requis || [])
+                requis_autres.add(alias[r] || r);
+        }
+        if (nouveau)
+            for (const r of parseJsonArr(nouveau.couplages_requis))
+                requis_autres.add(alias[r] || r);
+        let libere = 0;
+        for (const p of instantane) {
+            if (!p.force_par_couplage)
+                continue;
+            if (!requis_autres.has(p.typologie_choisie) || (nouveau && p.typologie_choisie === nouveau.code))
+                libere += p.cout_eur_ht || 0;
+        }
+        return libere;
+    }
     function calcTotal() {
         return axes_list.reduce((s, axe) => s + (axes[axe] ? axes[axe].sous_total_eur_ht || 0 : 0), 0);
     }
@@ -47,11 +97,15 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
             // seuil). Desormais : parmi TOUS les downgrades possibles on choisit
             // celui dont le total resultant est le plus proche du budget cible —
             // evite a la fois le surcout et le sous-equipement massif.
-            const tous = getTousPostes().filter((p) => !p.force_par_couplage && !p.manuel);
+            const instantane = getTousPostes();
+            const tous = instantane.filter((p) => !p.force_par_couplage && !p.manuel);
+            const choisis = codesChoisis(axes);
             const candidats = [];
             for (const poste_candidat of tous) {
                 const poste_id_num = _posteIdNum(poste_candidat, options);
-                const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie);
+                // v0.1.1 : jamais vers le choix d'un autre poste (une ligne forcée de ce
+                // code, elle, est absorbée par la passe couplages)
+                const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie && !choisis.has(o.code));
                 const alts_scored = alternatives
                     .map((alt) => {
                     const dim = dimension_optimale(alt, inputs, contexte_derived, coefficients);
@@ -63,7 +117,8 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                     candidats.push({
                         poste: poste_candidat,
                         alt: a,
-                        diff: (poste_candidat.cout_eur_ht || 0) - Math.round(a.cout),
+                        // v0.1.1 : la baisse réelle compte les accessoires forcés que ce changement lâche
+                        diff: (poste_candidat.cout_eur_ht || 0) - Math.round(a.cout) + coutLibere(poste_candidat, a.alt, instantane),
                     });
                 }
             }
@@ -88,17 +143,16 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                         typologie_choisie: meilleur.alt.code,
                         nom_affichage: meilleur.alt.nom,
                         description_pedago: meilleur.alt.description_pedago || '',
-                        dimension: meilleur.dim || p.dimension,
+                        dimension: dimensionDe(meilleur.alt, meilleur.dim),
                         cout_eur_ht: Math.round(meilleur.cout),
                         couplages_requis: parseJsonArr(meilleur.alt.couplages_requis),
                         couplages_exclus: parseJsonArr(meilleur.alt.couplages_exclus),
                         _downgraded: true,
                     });
                     recalcSousTotal(axe_poste);
-                    total -= diff;
                     downgraded = true;
                     if (log)
-                        log.push('Downgrade ' + poste_candidat.typologie_choisie + ' -> ' + meilleur.alt.code + ' -' + diff + 'EUR');
+                        log.push('Downgrade ' + poste_candidat.typologie_choisie + ' -> ' + meilleur.alt.code + ' -' + diff + 'EUR (accessoires compris)');
                 }
             }
             if (!downgraded) {
@@ -110,7 +164,6 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                     const ax = axes[axe_poste];
                     const idx = ax.postes.findIndex((p) => p.typologie_choisie === pire.typologie_choisie);
                     if (idx >= 0) {
-                        total -= ax.postes[idx].cout_eur_ht || 0;
                         ax.postes.splice(idx, 1);
                         recalcSousTotal(axe_poste);
                         downgraded = true;
@@ -121,6 +174,10 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                 if (!downgraded)
                     break;
             }
+            // v0.1.1 : le principal a pu disparaître ou changer — ses accessoires forcés
+            // ne comptent plus dans le plancher.
+            lacheOrphelins();
+            total = calcTotal();
         }
         if (total > budget_total * overrun_seuil) {
             status = 'BUDGET_INSUFFISANT';
@@ -142,8 +199,6 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
         // ne jamais y réinjecter de postes optionnels. Marqueur posé par
         // axes-actifs.ts (configPourAxes). Absent = comportement historique inchangé.
         const axes_desactives = new Set(config._axes_desactives || []);
-        // Identifier les postes BDD non encore sélectionnés (optionnels manquants)
-        const codes_selectionnes = new Set(getTousPostes().map((p) => p.typologie_choisie));
         // Construire mapping poste_code → axe via postes BDD
         const posteIdToAxe = {};
         if (postes) {
@@ -156,18 +211,26 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
         while (total < budget_total * underspend_seuil && iterations < 80) {
             iterations++;
             let upgraded = false;
-            // Stratégie 1 : upgrader des typologies existantes
+            // v0.1.1 : état réel à chaque tour (l'origine figeait la liste des codes
-            const tous = getTousPostes().filter((p) => !p.manuel);
+            // avant la boucle et ne la mettait pas à jour après un upgrade)
+            const instantane = getTousPostes();
+            const codes_selectionnes = codesChoisis(axes);
+            const postes_occupes = new Set(instantane.map((p) => _posteIdNum(p, options)));
+            // Stratégie 1 : upgrader des typologies existantes (jamais une ligne forcée :
+            // c'est une contrainte, la passe couplages re-forcerait l'original)
+            const tous = instantane.filter((p) => !p.manuel && !p.force_par_couplage);
             tous.sort((a, b) => (b.score_adequation || 0) - (a.score_adequation || 0));
             for (const poste_candidat of tous) {
                 const poste_id_num = _posteIdNum(poste_candidat, options);
-                const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie);
+                const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie && !codes_selectionnes.has(o.code));
                 const alts_scored = alternatives
                     .map((alt) => {
                     const dim = dimension_optimale(alt, inputs, contexte_derived, coefficients);
                     const cout = cout_typologie(alt, dim, inputs);
                     // Estimer le coût des couplages requis non encore sélectionnés
-                    const codes_sel = new Set(getTousPostes().map((p) => p.typologie_choisie));
+                    // (v0.1.1 : la ligne qu'on remplace ne compte pas — un requis égal à
+                    // son code actuel devra être forcé après l'upgrade)
+                    const codes_sel = new Set(instantane.filter((p) => !(p.typologie_choisie === poste_candidat.typologie_choisie && p._axe === poste_candidat._axe)).map((p) => p.typologie_choisie));
                     const alias = (config && config.couplages_alias) || {};
                     const requis_list = parseJsonArr(alt.couplages_requis);
                     let cout_couplages_requis = 0;
@@ -184,10 +247,12 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                     return { alt, dim, cout, cout_couplages_requis };
                     // Ne conserver que les upgrades qui ne dépassent pas le budget global
                     // en incluant le coût estimé des couplages requis non encore satisfaits
+                    // (v0.1.1 : et en déduisant les accessoires forcés que le changement lâche)
                 })
                     .filter((a) => {
-                    const diff_potential = a.cout + a.cout_couplages_requis - (poste_candidat.cout_eur_ht || 0);
+                    const diff_potential = a.cout + a.cout_couplages_requis - (poste_candidat.cout_eur_ht || 0) - coutLibere(poste_candidat, a.alt, instantane);
-                    return a.cout > (poste_candidat.cout_eur_ht || 0) && total + diff_potential <= budget_total * overrun_seuil;
+                    // v0.1.1 : un « upgrade » dont l'effet net fait baisser le total n'en est pas un
+                    return a.cout > (poste_candidat.cout_eur_ht || 0) && diff_potential > 0 && total + diff_potential <= budget_total * overrun_seuil;
                 });
                 if (alts_scored.length > 0) {
                     alts_scored.sort((a, b) => a.cout - b.cout);
@@ -202,7 +267,7 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                             typologie_choisie: meilleur.alt.code,
                             nom_affichage: meilleur.alt.nom,
                             description_pedago: meilleur.alt.description_pedago || '',
-                            dimension: meilleur.dim || p.dimension,
+                            dimension: dimensionDe(meilleur.alt, meilleur.dim),
                             cout_eur_ht: Math.round(meilleur.cout),
                             // IMPORTANT: mettre à jour les couplages de la nouvelle typo (pas hériter ancienne)
                             couplages_requis: parseJsonArr(meilleur.alt.couplages_requis),
@@ -219,10 +284,13 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                 }
             }
             // Stratégie 2 : ajouter des postes optionnels non encore sélectionnés
+            // (v0.1.1 : un poste = une ligne ; la quantité passe par `dimension`)
             if (!upgraded) {
                 const postes_manquants = options.filter((o) => {
                     if (o.actif === false || codes_selectionnes.has(o.code))
                         return false;
+                    if (postes_occupes.has(o.poste_id))
+                        return false;
                     // Ne pas ajouter de poste appartenant à un axe désactivé (V3)
                     if (axes_desactives.size > 0 && posteIdToAxe[o.poste_id] && axes_desactives.has(posteIdToAxe[o.poste_id]))
                         return false;
@@ -260,14 +328,15 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
                             notes_techniques: best.opt.notes_techniques || '',
                             flag_diy: best.opt.flag_diy || false,
                             complexite_pose: best.opt.complexite_pose || 2,
-                            couplages_requis: [],
+                            // v0.1.1 : la ligne dit ce qu'elle requiert (l'origine écrivait [] :
-                            couplages_exclus: [],
+                            // un poêle ajouté ici n'aurait jamais eu son conduit)
+                            couplages_requis: parseJsonArr(best.opt.couplages_requis),
+                            couplages_exclus: parseJsonArr(best.opt.couplages_exclus),
                             manuel: false,
                             _added_cas_b: true,
                         });
                         ax.sous_total_eur_ht += Math.round(best.cout);
                         total += Math.round(best.cout);
-                        codes_selectionnes.add(best.opt.code);
                         upgraded = true;
                         if (log)
                             log.push('Ajout optionnel ' + best.opt.code + ' +' + Math.round(best.cout) + 'EUR');
@@ -293,6 +362,16 @@ export function reajusteBudget(apres_couplages, budget_total, options, postes, i
         debug_reajust: log,
     };
 }
+/**
+ * Dimension d'une ligne qui change de typologie : celle calculée pour la
+ * nouvelle option, sinon le forfait de l'option (même convention que
+ * selectionnePoste). v0.1.1 : l'origine héritait de la dimension de la ligne
+ * remplacée (une batterie au plomb affichée « 0,4 kWc », une chaudière « 6 ml »),
+ * et le taux de couverture énergie lisait ces kWc fantômes.
+ */
+function dimensionDe(alt, dim) {
+    return dim || { valeur: alt.quantite_default || 1, unite: alt.unite || '' };
+}
 function _posteIdNum(poste_result, options) {
     const typo = options.find((o) => o.code === poste_result.typologie_choisie);
     return typo ? typo.poste_id : -1;

dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.1.1";

dist/version.js

@@ -2,4 +2,4 @@
 // Doit être égale à "version" de package.json : un test le vérifie
 // (test/paquet.test.mjs). On ne lit pas package.json ici : le paquet ne fait
 // aucune I/O, et un JSON importé serait embarqué par les bundlers.
-export const VERSION = '0.1.0';
+export const VERSION = '0.1.1';

fixtures/ecarts-harmonisation-2026-09-28.json

@@ -1,535 +0,0 @@
-{
-  "_commentaire": "Écarts de sélection et de taux entre le jeu de coefficients d'origine et la table harmonisée, sur les trois profils de référence, figés le 2026-09-28. Un changement de coefficient ou de code qui modifie ces écarts casse test/decoupage.test.mjs : c'est voulu, on relit CONSTANTES.md avant de refiger.",
-  "date": "2026-09-28",
-  "ecarts": [
-    {
-      "profil": "A — Frugal urbain",
-      "mode": "taux (par_axe)",
-      "axe": "eau",
-      "origine": "23 %",
-      "harmonisee": "27 %"
-    },
-    {
-      "profil": "A — Frugal urbain",
-      "mode": "taux (global)",
-      "axe": "eau",
-      "origine": "23 %",
-      "harmonisee": "27 %"
-    },
-    {
-      "profil": "A — Frugal urbain",
-      "mode": "taux (par_axe)",
-      "axe": "energie",
-      "origine": "22 %",
-      "harmonisee": "6 %"
-    },
-    {
-      "profil": "A — Frugal urbain",
-      "mode": "taux (global)",
-      "axe": "energie",
-      "origine": "22 %",
-      "harmonisee": "6 %"
-    },
-    {
-      "profil": "B — Famille moyenne",
-      "mode": "taux (par_axe)",
-      "axe": "eau",
-      "origine": "24 %",
-      "harmonisee": "27 %"
-    },
-    {
-      "profil": "B — Famille moyenne",
-      "mode": "taux (global)",
-      "axe": "eau",
-      "origine": "24 %",
-      "harmonisee": "27 %"
-    },
-    {
-      "profil": "B — Famille moyenne",
-      "mode": "taux (par_axe)",
-      "axe": "energie",
-      "origine": "100 %",
-      "harmonisee": "80 %"
-    },
-    {
-      "profil": "C — Autonomie large",
-      "mode": "taux (par_axe)",
-      "axe": "eau",
-      "origine": "20 %",
-      "harmonisee": "23 %"
-    },
-    {
-      "profil": "C — Autonomie large",
-      "mode": "taux (global)",
-      "axe": "eau",
-      "origine": "20 %",
-      "harmonisee": "23 %"
-    },
-    {
-      "profil": "C — Autonomie large",
-      "mode": "taux (par_axe)",
-      "axe": "energie",
-      "origine": "10 %",
-      "harmonisee": "3 %"
-    },
-    {
-      "profil": "C — Autonomie large",
-      "mode": "taux (global)",
-      "axe": "energie",
-      "origine": "100 %",
-      "harmonisee": "63 %"
-    }
-  ],
-  "lignes": [
-    {
-      "profil": "A — Frugal urbain",
-      "jeu": "origine",
-      "global": {
-        "total": 15180,
-        "status": "OK",
-        "typologies": {
-          "eau": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_souple_5m3",
-            "distrib_gravitaire",
-            "eg_noue",
-            "eg_pedoepuration",
-            "eg_fpv_autoconstruit"
-          ],
-          "energie": [
-            "pv_batterie_plomb_5",
-            "th_ballon_500",
-            "bois_poele_double",
-            "emet_vannes_thermo",
-            "pil_home_assistant",
-            "bois_conduit_fumee"
-          ],
-          "alim": []
-        },
-        "taux": {
-          "eau": 23,
-          "energie": 22,
-          "alim": null
-        }
-      },
-      "par_axe": {
-        "eau": {
-          "typologies": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_souple_5m3",
-            "distrib_gravitaire",
-            "eg_pedoepuration",
-            "distrib_kit_double_reseau",
-            "eg_fpv_autoconstruit"
-          ],
-          "sous_total": 8130,
-          "status": "BUDGET_INSUFFISANT",
-          "taux": 23
-        },
-        "energie": {
-          "typologies": [
-            "pv_kit_beem_balcon",
-            "th_ballon_500",
-            "bois_poele_granules",
-            "emet_radiateur_acier",
-            "pil_routeur_ecs",
-            "bois_conduit_fumee"
-          ],
-          "sous_total": 7110,
-          "status": "OK",
-          "taux": 22
-        },
-        "alim": {
-          "typologies": [],
-          "sous_total": 0,
-          "status": "OK",
-          "taux": null
-        }
-      }
-    },
-    {
-      "profil": "A — Frugal urbain",
-      "jeu": "harmonisee",
-      "global": {
-        "total": 15180,
-        "status": "OK",
-        "typologies": {
-          "eau": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_souple_5m3",
-            "distrib_gravitaire",
-            "eg_noue",
-            "eg_pedoepuration",
-            "eg_fpv_autoconstruit"
-          ],
-          "energie": [
-            "pv_batterie_plomb_5",
-            "th_ballon_500",
-            "bois_poele_double",
-            "emet_vannes_thermo",
-            "pil_home_assistant",
-            "bois_conduit_fumee"
-          ],
-          "alim": []
-        },
-        "taux": {
-          "eau": 27,
-          "energie": 6,
-          "alim": null
-        }
-      },
-      "par_axe": {
-        "eau": {
-          "typologies": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_souple_5m3",
-            "distrib_gravitaire",
-            "eg_pedoepuration",
-            "distrib_kit_double_reseau",
-            "eg_fpv_autoconstruit"
-          ],
-          "sous_total": 8130,
-          "status": "BUDGET_INSUFFISANT",
-          "taux": 27
-        },
-        "energie": {
-          "typologies": [
-            "pv_kit_beem_balcon",
-            "th_ballon_500",
-            "bois_poele_granules",
-            "emet_radiateur_acier",
-            "pil_routeur_ecs",
-            "bois_conduit_fumee"
-          ],
-          "sous_total": 7110,
-          "status": "OK",
-          "taux": 6
-        },
-        "alim": {
-          "typologies": [],
-          "sous_total": 0,
-          "status": "OK",
-          "taux": null
-        }
-      }
-    },
-    {
-      "profil": "B — Famille moyenne",
-      "jeu": "origine",
-      "global": {
-        "total": 36661,
-        "status": "OK",
-        "typologies": {
-          "eau": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_souple_5m3",
-            "distrib_gravitaire",
-            "eg_noue",
-            "eg_pedoepuration",
-            "eg_fpv_autoconstruit"
-          ],
-          "energie": [
-            "pv_monitoring",
-            "th_ballon_500",
-            "bois_poele_masse_indus",
-            "emet_seche_serviette",
-            "pil_delesteur",
-            "bois_conduit_fumee"
-          ],
-          "alim": [
-            "etude_topo_ensoleil",
-            "haute_fruit_coque",
-            "moy_petit_fruit_3L",
-            "basse_compost_3bacs"
-          ]
-        },
-        "taux": {
-          "eau": 24,
-          "energie": null,
-          "alim": null
-        }
-      },
-      "par_axe": {
-        "eau": {
-          "typologies": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_pehd_enterree_5m3",
-            "distrib_gravitaire",
-            "eg_pedoepuration",
-            "eg_pedoepuration"
-          ],
-          "sous_total": 14645,
-          "status": "OK",
-          "taux": 24
-        },
-        "energie": {
-          "typologies": [
-            "pv_kit_3kwc_string",
-            "th_ballon_500",
-            "bois_poele_granules",
-            "emet_seche_serviette",
-            "pil_delesteur",
-            "bois_conduit_fumee"
-          ],
-          "sous_total": 13455,
-          "status": "OK",
-          "taux": 100
-        },
-        "alim": {
-          "typologies": [
-            "etude_analyse_labo",
-            "haute_plantation_pose_pro",
-            "moy_haie_biodiv_complete",
-            "basse_planche_bec",
-            "basse_planche_bec"
-          ],
-          "sous_total": 6985,
-          "status": "OK",
-          "taux": 50
-        }
-      }
-    },
-    {
-      "profil": "B — Famille moyenne",
-      "jeu": "harmonisee",
-      "global": {
-        "total": 36661,
-        "status": "OK",
-        "typologies": {
-          "eau": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_souple_5m3",
-            "distrib_gravitaire",
-            "eg_noue",
-            "eg_pedoepuration",
-            "eg_fpv_autoconstruit"
-          ],
-          "energie": [
-            "pv_monitoring",
-            "th_ballon_500",
-            "bois_poele_masse_indus",
-            "emet_seche_serviette",
-            "pil_delesteur",
-            "bois_conduit_fumee"
-          ],
-          "alim": [
-            "etude_topo_ensoleil",
-            "haute_fruit_coque",
-            "moy_petit_fruit_3L",
-            "basse_compost_3bacs"
-          ]
-        },
-        "taux": {
-          "eau": 27,
-          "energie": null,
-          "alim": null
-        }
-      },
-      "par_axe": {
-        "eau": {
-          "typologies": [
-            "captage_descente_directe",
-            "filtration_particulaire_simple",
-            "stockage_pehd_enterree_5m3",
-            "distrib_gravitaire",
-            "eg_pedoepuration",
-            "eg_pedoepuration"
-          ],
-          "sous_total": 14645,
-          "status": "OK",
-          "taux": 27
-        },
-        "energie": {
-          "typologies": [
-            "pv_kit_3kwc_string",
-            "th_ballon_500",
-            "bois_poele_granules",
-            "emet_seche_serviette",
-            "pil_delesteur",
-            "bois_conduit_fumee"
-          ],
-          "sous_total": 13455,
-          "status": "OK",
-          "taux": 80
-        },
-        "alim": {
-          "typologies": [
-            "etude_analyse_labo",
-            "haute_plantation_pose_pro",
-            "moy_haie_biodiv_complete",
-            "basse_planche_bec",
-            "basse_planche_bec"
-          ],
-          "sous_total": 6985,
-          "status": "OK",
-          "taux": 50
-        }
-      }
-    },
-    {
-      "profil": "C — Autonomie large",
-      "jeu": "origine",
-      "global": {
-        "total": 77465,
-        "status": "OK",
-        "typologies": {
-          "eau": [
-            "captage_capteur_sol",
-            "filtration_3_corps_uv",
-            "stockage_beton_5m3",
-            "distrib_gravitaire",
-            "eg_phytostation"
-          ],
-          "energie": [
-            "pv_kit_3kwc_micro",
-            "th_ballon_500",
-            "bois_chaudiere_granules",
-            "emet_vannes_thermo",
-            "pil_onduleur_hybride",
-            "bois_conduit_fumee"
-          ],
-          "alim": [
-            "etude_analyse_labo",
-            "haute_haute_tige",
-            "moy_haie_biodiv_complete",
-            "basse_planche_bec"
-          ]
-        },
-        "taux": {
-          "eau": 20,
-          "energie": 100,
-          "alim": 67
-        }
-      },
-      "par_axe": {
-        "eau": {
-          "typologies": [
-            "captage_capteur_sol",
-            "filtration_3_corps_uv",
-            "stockage_beton_5m3",
-            "distrib_per_bleu_interieur",
-            "eg_phytostation",
-            "eg_phytostation",
-            "eg_phytostation",
-            "eg_pedoepuration",
-            "distrib_kit_double_reseau"
-          ],
-          "sous_total": 41000,
-          "status": "OK",
-          "taux": 20
-        },
-        "energie": {
-          "typologies": [
-            "pv_batterie_plomb_5",
-            "th_ballon_500",
-            "bois_poele_hydro",
-            "emet_radiateur_acier",
-            "pil_routeur_ecs",
-            "bois_conduit_fumee"
-          ],
-          "sous_total": 19210,
-          "status": "OK",
-          "taux": 10
-        },
-        "alim": {
-          "typologies": [
-            "etude_analyse_labo",
-            "haute_haute_tige",
-            "moy_haie_biodiv_complete",
-            "basse_planche_bec",
-            "basse_planche_bec"
-          ],
-          "sous_total": 20855,
-          "status": "OK",
-          "taux": 67
-        }
-      }
-    },
-    {
-      "profil": "C — Autonomie large",
-      "jeu": "harmonisee",
-      "global": {
-        "total": 77465,
-        "status": "OK",
-        "typologies": {
-          "eau": [
-            "captage_capteur_sol",
-            "filtration_3_corps_uv",
-            "stockage_beton_5m3",
-            "distrib_gravitaire",
-            "eg_phytostation"
-          ],
-          "energie": [
-            "pv_kit_3kwc_micro",
-            "th_ballon_500",
-            "bois_chaudiere_granules",
-            "emet_vannes_thermo",
-            "pil_onduleur_hybride",
-            "bois_conduit_fumee"
-          ],
-          "alim": [
-            "etude_analyse_labo",
-            "haute_haute_tige",
-            "moy_haie_biodiv_complete",
-            "basse_planche_bec"
-          ]
-        },
-        "taux": {
-          "eau": 23,
-          "energie": 63,
-          "alim": 67
-        }
-      },
-      "par_axe": {
-        "eau": {
-          "typologies": [
-            "captage_capteur_sol",
-            "filtration_3_corps_uv",
-            "stockage_beton_5m3",
-            "distrib_per_bleu_interieur",
-            "eg_phytostation",
-            "eg_phytostation",
-            "eg_phytostation",
-            "eg_pedoepuration",
-            "distrib_kit_double_reseau"
-          ],
-          "sous_total": 41000,
-          "status": "OK",
-          "taux": 23
-        },
-        "energie": {
-          "typologies": [
-            "pv_batterie_plomb_5",
-            "th_ballon_500",
-            "bois_poele_hydro",
-            "emet_radiateur_acier",
-            "pil_routeur_ecs",
-            "bois_conduit_fumee"
-          ],
-          "sous_total": 19210,
-          "status": "OK",
-          "taux": 3
-        },
-        "alim": {
-          "typologies": [
-            "etude_analyse_labo",
-            "haute_haute_tige",
-            "moy_haie_biodiv_complete",
-            "basse_planche_bec",
-            "basse_planche_bec"
-          ],
-          "sous_total": 20855,
-          "status": "OK",
-          "taux": 67
-        }
-      }
-    }
-  ]
-}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transformer/moteurs",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Moteurs de calcul purs pour la rénovation et l'autonomie d'une maison, partagés par calculs.trans-former.fr et plateforme.trans-former.fr. Code et coefficients sourcés ; jamais de prix dans le paquet.",
   "type": "module",
   "license": "MIT",

src/autonomie/noyau/algo.ts

@@ -82,21 +82,40 @@ export function finaliseSelection(
   let status_final: Statut = final_pre.status
   let message_final = final_pre.message
 
-  for (let passe = 0; passe < 2; passe++) {
+  // Correctif v0.1.1 (SPEC menu §12 n° 2 et 3) : `reajusteBudget` renvoie en
+  // écho le journal qu'il reçoit ; l'origine le ré-ajoutait à chaque tour (chaque
+  // FORCE apparaissait deux à quatre fois). Le journal ne s'enrichit que des
+  // lignes nouvelles de `appliqueCouplages`. La boucle ne se contentait que du
+  // dépassement : un réajustement qui lâche des accessoires forcés (principal
+  // retiré ou changé) laissait le total loin sous le budget sans rien recombler.
+  // Désormais : couplages → dans la bande [−underspend, +overrun] ? fin ;
+  // sinon réajuste (CAS A ou B) → couplages…, trois tours au plus, et toujours
+  // une passe couplages en dernier. Si le dernier forçage refranchit le seuil,
+  // le statut le dit.
+  const tol_under = (config.tolerances && config.tolerances.budget_underspend_pct) || 15
+  const seuil_under = budget_total * (1 - tol_under / 100)
+  const dans_la_bande = (t: number) => t <= seuil_over && t >= seuil_under
+  const prend = (avec: { axes: Selection; couplages_appliques: string[] }) => {
+    etat = { axes: avec.axes, couplages_appliques: [...etat.couplages_appliques, ...(avec.couplages_appliques || [])] }
+  }
+
+  for (let passe = 0; passe < 3; passe++) {
     // IMPORTANT: appliqueCouplages attend selection = { eau, energie, alim } directement
-    const avec = appliqueCouplages(etat.axes, options, postes, reglages, false)
+    prend(appliqueCouplages(etat.axes, options, postes, reglages, false))
-    etat = {
+    if (dans_la_bande(sommeAxes(etat.axes))) break
-      axes: avec.axes,
-      couplages_appliques: [...etat.couplages_appliques, ...(avec.couplages_appliques || [])],
-    }
-    if (sommeAxes(etat.axes) <= seuil_over) break
     const re = reajusteBudget(etat, budget_total, options, postes, inputs, contexte, reglages, false)
-    etat = {
+    etat = { axes: re.axes, couplages_appliques: etat.couplages_appliques }
-      axes: re.axes,
-      couplages_appliques: [...etat.couplages_appliques, ...(re.couplages_appliques || [])],
-    }
     status_final = re.status
     message_final = re.message
+    // Bloqué (rien à ajouter, ou plancher atteint) ou dernier tour : une passe couplages et fin
+    if (passe === 2 || re.status !== 'OK') {
+      prend(appliqueCouplages(etat.axes, options, postes, reglages, false))
+      break
+    }
+  }
+  if (sommeAxes(etat.axes) > seuil_over && status_final === 'OK') {
+    status_final = 'BUDGET_INSUFFISANT'
+    message_final = 'Budget insuffisant : les couplages requis portent le total à ' + sommeAxes(etat.axes) + ' EUR pour un budget de ' + Math.round(budget_total) + ' EUR.'
   }
 
   return {

src/autonomie/noyau/couplages.ts

@@ -8,6 +8,13 @@
 // Note (origine, conservée) : le marqueur `_conflit_avec` de la passe 2 est
 // posé sur des copies de postes et n'atteint jamais la sortie ; le
 // « downgrade planifié » n'a donc jamais lieu. À corriger en patch, avec test.
+//
+// Correctif v0.1.1 (SPEC menu §12 n° 2 et 5) : une ligne forcée que plus
+// aucune ligne ne requiert est RETIRÉE (passe 0). À l'origine, un accessoire
+// forcé (conduit, ballon tampon, filière d'épuration) survivait au retrait ou
+// au downgrade de son principal, verrouillé pour toujours par
+// `force_par_couplage` — d'où des conduits sans poêle et des planchers de
+// coût infranchissables (statut INSUFFISANT à 6 000 € mais OK à 3 000 €).
 
 import { cout_typologie, dimension_optimale } from './dimension.js'
 import type { Axe, AxeResultat, Option, Poste, PosteResultat, Reglages, Selection } from './types.js'
@@ -28,6 +35,58 @@ function copieSelection(selection: Selection): Selection {
   return copie
 }
 
+const AXES_LIST: Axe[] = ['eau', 'energie', 'alim']
+
+/** Codes requis (alias résolus) par les lignes NON forcées de la sélection. */
+export function codesRequisPar(axes: Selection, alias: Record<string, string>): Set<string> {
+  const requis = new Set<string>()
+  for (const axe of AXES_LIST) {
+    for (const p of axes[axe]?.postes ?? []) {
+      if (p.force_par_couplage) continue
+      for (const r of p.couplages_requis || []) requis.add(alias[r] || r)
+    }
+  }
+  return requis
+}
+
+/** Codes des lignes NON forcées (les choix de postes, par opposition aux accessoires forcés). */
+export function codesChoisis(axes: Selection): Set<string> {
+  const codes = new Set<string>()
+  for (const axe of AXES_LIST) for (const p of axes[axe]?.postes ?? []) if (!p.force_par_couplage) codes.add(p.typologie_choisie)
+  return codes
+}
+
+/**
+ * Retire EN PLACE les lignes forcées devenues inutiles et recalcule les
+ * sous-totaux : celles que plus aucune ligne ne requiert (orphelines), et
+ * celles dont la typologie est déjà le choix d'un poste (le requis est
+ * satisfait par ce choix, la ligne forcée est absorbée). Rend le journal.
+ */
+export function retireForcesOrphelins(axes: Selection, alias: Record<string, string>): string[] {
+  const requis = codesRequisPar(axes, alias)
+  const choisis = codesChoisis(axes)
+  const log: string[] = []
+  for (const axe of AXES_LIST) {
+    const a = axes[axe]
+    if (!a) continue
+    const gardes: PosteResultat[] = []
+    for (const p of a.postes) {
+      if (p.force_par_couplage && !requis.has(p.typologie_choisie)) {
+        log.push('RETIRE "' + p.typologie_choisie + '" (plus requis par aucun poste) -' + (p.cout_eur_ht || 0) + 'EUR dans axe ' + axe)
+      } else if (p.force_par_couplage && choisis.has(p.typologie_choisie)) {
+        log.push('ABSORBE "' + p.typologie_choisie + '" (déjà le choix d\'un poste) -' + (p.cout_eur_ht || 0) + 'EUR dans axe ' + axe)
+      } else {
+        gardes.push(p)
+      }
+    }
+    if (gardes.length !== a.postes.length) {
+      a.postes = gardes
+      a.sous_total_eur_ht = gardes.reduce((s, p) => s + (p.cout_eur_ht || 0), 0)
+    }
+  }
+  return log
+}
+
 /**
  * Post-traitement déterministe des couplages.
  *
@@ -52,13 +111,16 @@ export function appliqueCouplages(selection_recue: Selection, options: Option[],
     return alias[code] || code
   }
 
-  const axes_list: Axe[] = ['eau', 'energie', 'alim']
+  const axes_list: Axe[] = AXES_LIST
+
+  // Passe 0 (v0.1.1) : lâcher les accessoires forcés dont le principal a disparu.
+  const couplages_log: string[] = retireForcesOrphelins(selection, alias)
+
   const tous_postes: PosteResultat[] = axes_list.flatMap((axe) =>
     (selection[axe] && selection[axe].postes ? selection[axe].postes : []).map((p) => Object.assign({}, p, { _axe: axe })),
   )
 
   const codes_selectionnes = new Set(tous_postes.map((p) => p.typologie_choisie))
-  const couplages_log: string[] = []
 
   // Passe 1 : couplages_requis
   for (const poste of tous_postes) {

src/autonomie/noyau/index.ts

@@ -1,6 +1,7 @@
 // @transformer/moteurs/autonomie/noyau — le cœur V2 du simulateur autonomie,
 // pipeline complet (celui de calculs.trans-former.fr), sans singleton ni I/O.
-export { selectionner } from './algo.js'
+export { selectionner, finaliseSelection } from './algo.js'
+export type { SelectionFinalisee } from './algo.js'
 export { dimension_optimale, cout_typologie } from './dimension.js'
 export { adequation_contexte } from './adequation.js'
 export type { AdequationDebug } from './adequation.js'
@@ -8,7 +9,7 @@ export { pondereAxes } from './pondere-axes.js'
 export type { PoidsDebug } from './pondere-axes.js'
 export { alloueBudget } from './alloue-budget.js'
 export { selectionnePoste } from './selectionne-poste.js'
-export { appliqueCouplages } from './couplages.js'
+export { appliqueCouplages, codesChoisis, codesRequisPar, retireForcesOrphelins } from './couplages.js'
 export type { ResultatCouplages } from './couplages.js'
 export { reajusteBudget } from './reajuste.js'
 export type { EntreeReajuste, ResultatReajuste } from './reajuste.js'

src/autonomie/noyau/reajuste.ts

@@ -7,7 +7,22 @@
 // Note (origine, conservée) : les messages utilisent toLocaleString('fr-FR')
 // (Intl). Texte de présentation, non assert par les tests ; à sortir du noyau
 // en patch si l'octet-pour-octet inter-environnements devient un besoin.
+//
+// Correctifs v0.1.1 (SPEC menu §12 n° 1, 2, 3, 5, 7) :
+//  - CAS A : un downgrade ne cible jamais une typologie déjà présente (le conduit
+//    forcé se retrouvait en double) ; après chaque retrait ou downgrade, les
+//    accessoires forcés que plus rien ne requiert sont lâchés (le plancher de
+//    coût n'est plus verrouillé par des couplages orphelins).
+//  - CAS B, stratégie 1 : une ligne forcée n'est jamais « upgradée » (elle est
+//    une contrainte, pas un choix ; l'origine la triait en tête avec son score
+//    0,8 et la transformait, puis la passe suivante re-forçait l'original) ;
+//    la cible d'un upgrade n'est jamais une typologie déjà présente.
+//  - CAS B, stratégie 2 : un poste = une ligne. L'origine ajoutait une 2e, 3e…
+//    option au même poste (jusqu'à cinq `basse_planche_bec`), parce qu'elle
+//    testait le code et pas le poste, sur une liste figée avant la boucle.
+//    La quantité d'un poste est portée par `dimension`, pas par des lignes.
 
+import { codesChoisis, retireForcesOrphelins } from './couplages.js'
 import { cout_typologie, dimension_optimale } from './dimension.js'
 import type { Autodiag, Axe, Contexte, Dimension, Option, Poste, PosteResultat, Reglages, Selection, Statut } from './types.js'
 import { parseJsonArr } from './types.js'
@@ -41,6 +56,7 @@ export function reajusteBudget(
   const tolerances = config.tolerances || {}
   const overrun_seuil = 1 + (tolerances.budget_overrun_pct || 5) / 100
   const underspend_seuil = 1 - (tolerances.budget_underspend_pct || 15) / 100
+  const alias = config.couplages_alias || {}
 
   const axes = apres_couplages.axes
   const axes_list: Axe[] = ['eau', 'energie', 'alim']
@@ -49,6 +65,35 @@ export function reajusteBudget(
     return axes_list.flatMap((axe) => (axes[axe] && axes[axe].postes ? axes[axe].postes : []).map((p) => Object.assign({}, p, { _axe: axe })))
   }
 
+  /** Lâche les accessoires forcés orphelins ou absorbés ; vrai si quelque chose a bougé. */
+  function lacheOrphelins(): boolean {
+    const retires = retireForcesOrphelins(axes, alias)
+    if (retires.length && log) log.push(...retires)
+    return retires.length > 0
+  }
+
+  /**
+   * Coût des lignes forcées que lâcherait le passage de `ligne` à la typologie
+   * `nouveau` (null = retrait de la ligne) : ses requis que plus personne ne
+   * demande, et la ligne forcée que le nouveau choix absorbe. Sert aux
+   * arbitrages (CAS A « au plus près du budget », CAS B « tient dans le seuil »)
+   * pour que le total prévu soit celui que la passe couplages rendra.
+   */
+  function coutLibere(ligne: PosteResultat, nouveau: Option | null, instantane: PosteResultat[]): number {
+    const requis_autres = new Set<string>()
+    for (const p of instantane) {
+      if (p.force_par_couplage || p === ligne || (p.typologie_choisie === ligne.typologie_choisie && p._axe === ligne._axe)) continue
+      for (const r of p.couplages_requis || []) requis_autres.add(alias[r] || r)
+    }
+    if (nouveau) for (const r of parseJsonArr(nouveau.couplages_requis)) requis_autres.add(alias[r] || r)
+    let libere = 0
+    for (const p of instantane) {
+      if (!p.force_par_couplage) continue
+      if (!requis_autres.has(p.typologie_choisie) || (nouveau && p.typologie_choisie === nouveau.code)) libere += p.cout_eur_ht || 0
+    }
+    return libere
+  }
+
   function calcTotal(): number {
     return axes_list.reduce((s, axe) => s + (axes[axe] ? axes[axe].sous_total_eur_ht || 0 : 0), 0)
   }
@@ -80,12 +125,16 @@ export function reajusteBudget(
       // seuil). Desormais : parmi TOUS les downgrades possibles on choisit
       // celui dont le total resultant est le plus proche du budget cible —
       // evite a la fois le surcout et le sous-equipement massif.
-      const tous = getTousPostes().filter((p) => !p.force_par_couplage && !p.manuel)
+      const instantane = getTousPostes()
+      const tous = instantane.filter((p) => !p.force_par_couplage && !p.manuel)
+      const choisis = codesChoisis(axes)
 
       const candidats: { poste: PosteResultat; alt: { alt: Option; dim: Dimension | null; cout: number }; diff: number }[] = []
       for (const poste_candidat of tous) {
         const poste_id_num = _posteIdNum(poste_candidat, options)
-        const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie)
+        // v0.1.1 : jamais vers le choix d'un autre poste (une ligne forcée de ce
+        // code, elle, est absorbée par la passe couplages)
+        const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie && !choisis.has(o.code))
 
         const alts_scored = alternatives
           .map((alt) => {
@@ -99,7 +148,8 @@ export function reajusteBudget(
           candidats.push({
             poste: poste_candidat,
             alt: a,
-            diff: (poste_candidat.cout_eur_ht || 0) - Math.round(a.cout),
+            // v0.1.1 : la baisse réelle compte les accessoires forcés que ce changement lâche
+            diff: (poste_candidat.cout_eur_ht || 0) - Math.round(a.cout) + coutLibere(poste_candidat, a.alt, instantane),
           })
         }
       }
@@ -129,16 +179,15 @@ export function reajusteBudget(
             typologie_choisie: meilleur.alt.code,
             nom_affichage: meilleur.alt.nom,
             description_pedago: meilleur.alt.description_pedago || '',
-            dimension: meilleur.dim || p.dimension,
+            dimension: dimensionDe(meilleur.alt, meilleur.dim),
             cout_eur_ht: Math.round(meilleur.cout),
             couplages_requis: parseJsonArr(meilleur.alt.couplages_requis),
             couplages_exclus: parseJsonArr(meilleur.alt.couplages_exclus),
             _downgraded: true,
           })
           recalcSousTotal(axe_poste)
-          total -= diff
           downgraded = true
-          if (log) log.push('Downgrade ' + poste_candidat.typologie_choisie + ' -> ' + meilleur.alt.code + ' -' + diff + 'EUR')
+          if (log) log.push('Downgrade ' + poste_candidat.typologie_choisie + ' -> ' + meilleur.alt.code + ' -' + diff + 'EUR (accessoires compris)')
         }
       }
 
@@ -151,7 +200,6 @@ export function reajusteBudget(
           const ax = axes[axe_poste]!
           const idx = ax.postes.findIndex((p) => p.typologie_choisie === pire.typologie_choisie)
           if (idx >= 0) {
-            total -= ax.postes[idx].cout_eur_ht || 0
             ax.postes.splice(idx, 1)
             recalcSousTotal(axe_poste)
             downgraded = true
@@ -160,6 +208,11 @@ export function reajusteBudget(
         }
         if (!downgraded) break
       }
+
+      // v0.1.1 : le principal a pu disparaître ou changer — ses accessoires forcés
+      // ne comptent plus dans le plancher.
+      lacheOrphelins()
+      total = calcTotal()
     }
 
     if (total > budget_total * overrun_seuil) {
@@ -183,9 +236,6 @@ export function reajusteBudget(
     // axes-actifs.ts (configPourAxes). Absent = comportement historique inchangé.
     const axes_desactives = new Set<Axe>(config._axes_desactives || [])
 
-    // Identifier les postes BDD non encore sélectionnés (optionnels manquants)
-    const codes_selectionnes = new Set(getTousPostes().map((p) => p.typologie_choisie))
-
     // Construire mapping poste_code → axe via postes BDD
     const posteIdToAxe: Record<number, Axe> = {}
     if (postes) {
@@ -201,20 +251,29 @@ export function reajusteBudget(
 
       let upgraded = false
 
-      // Stratégie 1 : upgrader des typologies existantes
+      // v0.1.1 : état réel à chaque tour (l'origine figeait la liste des codes
-      const tous = getTousPostes().filter((p) => !p.manuel)
+      // avant la boucle et ne la mettait pas à jour après un upgrade)
+      const instantane = getTousPostes()
+      const codes_selectionnes = codesChoisis(axes)
+      const postes_occupes = new Set(instantane.map((p) => _posteIdNum(p, options)))
+
+      // Stratégie 1 : upgrader des typologies existantes (jamais une ligne forcée :
+      // c'est une contrainte, la passe couplages re-forcerait l'original)
+      const tous = instantane.filter((p) => !p.manuel && !p.force_par_couplage)
       tous.sort((a, b) => (b.score_adequation || 0) - (a.score_adequation || 0))
 
       for (const poste_candidat of tous) {
         const poste_id_num = _posteIdNum(poste_candidat, options)
-        const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie)
+        const alternatives = options.filter((o) => o.poste_id === poste_id_num && o.actif !== false && o.code !== poste_candidat.typologie_choisie && !codes_selectionnes.has(o.code))
 
         const alts_scored = alternatives
           .map((alt) => {
             const dim = dimension_optimale(alt, inputs, contexte_derived, coefficients)
             const cout = cout_typologie(alt, dim, inputs)
             // Estimer le coût des couplages requis non encore sélectionnés
-            const codes_sel = new Set(getTousPostes().map((p) => p.typologie_choisie))
+            // (v0.1.1 : la ligne qu'on remplace ne compte pas — un requis égal à
+            // son code actuel devra être forcé après l'upgrade)
+            const codes_sel = new Set(instantane.filter((p) => !(p.typologie_choisie === poste_candidat.typologie_choisie && p._axe === poste_candidat._axe)).map((p) => p.typologie_choisie))
             const alias = (config && config.couplages_alias) || {}
             const requis_list = parseJsonArr(alt.couplages_requis)
             let cout_couplages_requis = 0
@@ -231,10 +290,12 @@ export function reajusteBudget(
             return { alt, dim, cout, cout_couplages_requis }
             // Ne conserver que les upgrades qui ne dépassent pas le budget global
             // en incluant le coût estimé des couplages requis non encore satisfaits
+            // (v0.1.1 : et en déduisant les accessoires forcés que le changement lâche)
           })
           .filter((a) => {
-            const diff_potential = a.cout + a.cout_couplages_requis - (poste_candidat.cout_eur_ht || 0)
+            const diff_potential = a.cout + a.cout_couplages_requis - (poste_candidat.cout_eur_ht || 0) - coutLibere(poste_candidat, a.alt, instantane)
-            return a.cout > (poste_candidat.cout_eur_ht || 0) && total + diff_potential <= budget_total * overrun_seuil
+            // v0.1.1 : un « upgrade » dont l'effet net fait baisser le total n'en est pas un
+            return a.cout > (poste_candidat.cout_eur_ht || 0) && diff_potential > 0 && total + diff_potential <= budget_total * overrun_seuil
           })
 
         if (alts_scored.length > 0) {
@@ -250,7 +311,7 @@ export function reajusteBudget(
               typologie_choisie: meilleur.alt.code,
               nom_affichage: meilleur.alt.nom,
               description_pedago: meilleur.alt.description_pedago || '',
-              dimension: meilleur.dim || p.dimension,
+              dimension: dimensionDe(meilleur.alt, meilleur.dim),
               cout_eur_ht: Math.round(meilleur.cout),
               // IMPORTANT: mettre à jour les couplages de la nouvelle typo (pas hériter ancienne)
               couplages_requis: parseJsonArr(meilleur.alt.couplages_requis),
@@ -267,9 +328,11 @@ export function reajusteBudget(
       }
 
       // Stratégie 2 : ajouter des postes optionnels non encore sélectionnés
+      // (v0.1.1 : un poste = une ligne ; la quantité passe par `dimension`)
       if (!upgraded) {
         const postes_manquants = options.filter((o) => {
           if (o.actif === false || codes_selectionnes.has(o.code)) return false
+          if (postes_occupes.has(o.poste_id)) return false
           // Ne pas ajouter de poste appartenant à un axe désactivé (V3)
           if (axes_desactives.size > 0 && posteIdToAxe[o.poste_id] && axes_desactives.has(posteIdToAxe[o.poste_id])) return false
           return true
@@ -309,14 +372,15 @@ export function reajusteBudget(
               notes_techniques: best.opt.notes_techniques || '',
               flag_diy: best.opt.flag_diy || false,
               complexite_pose: best.opt.complexite_pose || 2,
-              couplages_requis: [],
+              // v0.1.1 : la ligne dit ce qu'elle requiert (l'origine écrivait [] :
-              couplages_exclus: [],
+              // un poêle ajouté ici n'aurait jamais eu son conduit)
+              couplages_requis: parseJsonArr(best.opt.couplages_requis),
+              couplages_exclus: parseJsonArr(best.opt.couplages_exclus),
               manuel: false,
               _added_cas_b: true,
             })
             ax.sous_total_eur_ht += Math.round(best.cout)
             total += Math.round(best.cout)
-            codes_selectionnes.add(best.opt.code)
             upgraded = true
             if (log) log.push('Ajout optionnel ' + best.opt.code + ' +' + Math.round(best.cout) + 'EUR')
           }
@@ -344,6 +408,17 @@ export function reajusteBudget(
   }
 }
 
+/**
+ * Dimension d'une ligne qui change de typologie : celle calculée pour la
+ * nouvelle option, sinon le forfait de l'option (même convention que
+ * selectionnePoste). v0.1.1 : l'origine héritait de la dimension de la ligne
+ * remplacée (une batterie au plomb affichée « 0,4 kWc », une chaudière « 6 ml »),
+ * et le taux de couverture énergie lisait ces kWc fantômes.
+ */
+function dimensionDe(alt: Option, dim: Dimension | null): Dimension {
+  return dim || { valeur: alt.quantite_default || 1, unite: alt.unite || '' }
+}
+
 function _posteIdNum(poste_result: PosteResultat, options: Option[]): number {
   const typo = options.find((o) => o.code === poste_result.typologie_choisie)
   return typo ? typo.poste_id : -1

src/version.ts

@@ -2,4 +2,4 @@
 // Doit être égale à "version" de package.json : un test le vérifie
 // (test/paquet.test.mjs). On ne lit pas package.json ici : le paquet ne fait
 // aucune I/O, et un JSON importé serait embarqué par les bundlers.
-export const VERSION = '0.1.0'
+export const VERSION = '0.1.1'

test/correctifs-v0.1.1.test.mjs

@@ -0,0 +1,147 @@
+// Correctifs v0.1.1 — SPEC menu branches fiches §12, n° 1, 2, 3, 5 et 7.
+// Chaque test ÉCHOUE sur v0.1.0 (vérifié sur master 648015a) et passe après le
+// correctif. Jeux : la maison d'essai du 02/10 (3 personnes, toit 90 m² sud,
+// parcelle 600 m², CP 31000, 30 ml de haie, temps 2), la maison B de P1.2 à
+// 6 000 € (toit 89 m², parcelle 457 m², sans personnes ni orientation, temps 1)
+// et le profil de référence A. Coefficients harmonisés du paquet.
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { eau, energie, alimentation, contexte as moteurContexte, autonomie, COEFFICIENTS } from '../dist/index.js'
+
+const lire = (f) => JSON.parse(readFileSync(new URL(`../fixtures/${f}`, import.meta.url), 'utf8'))
+const options = lire('options.json')
+const postes = lire('postes.json')
+const france_climat = lire('france_climat.json')
+const algo_config = lire('algo-config.json')
+const profils = lire('profils-reference.json')
+const donnees = { postes, options, algo_config, france_climat }
+const MOTEURS = { eau, energie, alim: alimentation }
+const alias = algo_config.couplages_alias
+
+const ESSAI = { code_postal: '31000', nb_personnes: 3, surface_toit_m2: 90, orientation_toit: 'sud', surface_parcelle_m2: 600, pente_toit_deg: 30, metres_haie_possibles: 30, temps_dispo: 2 }
+const MAISON_B = { code_postal: '31000', surface_toit_m2: 89, pente_toit_deg: 30, temps_dispo: 1, surface_parcelle_m2: 457 }
+const ctx31 = moteurContexte.calculer({ code_postal: '31000' }, { france_climat }).sorties
+const calcule = (axe, autodiag, budget) => MOTEURS[axe].calculer({ autodiag, budget_axe: budget, contexte: ctx31 }, donnees).sorties
+
+const requisDe = (code) => {
+  const o = options.find((x) => x.code === code)
+  return o ? autonomie.noyau.parseJsonArr(o.couplages_requis).map((r) => alias[r] || r) : []
+}
+/** Lignes forcées que plus aucune ligne non forcée ne requiert. */
+const orphelins = (s) => s.postes.filter((p) => p.force_par_couplage && !s.postes.some((y) => !y.force_par_couplage && requisDe(y.typologie_choisie).includes(p.typologie_choisie))).map((p) => p.typologie_choisie)
+const doublons = (s) => s.typologies.filter((c, i) => s.typologies.indexOf(c) !== i)
+const postesMultiples = (s) => {
+  const n = {}
+  for (const p of s.postes) if (!p.force_par_couplage) n[p.poste_id] = (n[p.poste_id] || 0) + 1
+  return Object.entries(n).filter(([, k]) => k > 1).map(([k]) => k)
+}
+
+test('n° 1 — une typologie n\'est jamais retenue deux fois dans un axe, un poste n\'a qu\'une ligne (essai : eau 15 000 et 25 000, énergie 6 000, jardin 15 000)', () => {
+  for (const [axe, budget] of [['eau', 15000], ['eau', 25000], ['energie', 6000], ['alim', 15000], ['alim', 40000]]) {
+    const s = calcule(axe, ESSAI, budget)
+    assert.deepEqual(doublons(s), [], `${axe} ${budget} : doublons`)
+    assert.deepEqual(postesMultiples(s), [], `${axe} ${budget} : plusieurs lignes pour un poste`)
+  }
+})
+
+test('n° 2 — le journal des couplages n\'écrit chaque FORCE qu\'une fois, et un poste déjà retenu n\'est pas re-forcé (B de P1.2, énergie 6 000 ; A, eau 7 500)', () => {
+  for (const [axe, autodiag, budget] of [['energie', MAISON_B, 6000], ['eau', profils[0].inputs, 7500], ['energie', ESSAI, 10000]]) {
+    const s = calcule(axe, autodiag, budget)
+    const force = s.couplages.filter((l) => l.startsWith('FORCE'))
+    assert.equal(new Set(force).size, force.length, `${axe} ${budget} : FORCE répété — ${force.join(' | ')}`)
+    const forces = s.postes.filter((p) => p.force_par_couplage).map((p) => p.typologie_choisie)
+    for (const code of forces) assert.equal(s.typologies.filter((c) => c === code).length, 1, `${axe} ${budget} : ${code} forcé alors qu'il est déjà là`)
+    assert.equal(s.sous_total_eur_ht, s.postes.reduce((a, p) => a + p.cout_eur_ht, 0), 'sous-total = somme des lignes')
+  }
+  // RECAP-LOT-P1.2 §5 ① : sur B à 6 000 € le conduit sortait deux fois (5 320 € au lieu de 3 940 €)
+  const b = calcule('energie', MAISON_B, 6000)
+  assert.equal(b.typologies.filter((c) => c === 'bois_conduit_fumee').length, 1, 'un seul conduit')
+})
+
+test('n° 3 — EAU : correcte à 3 000 €, elle ne devient pas « budget insuffisant » à 6 000 € (essai) ni à 5 500-7 500 € (A, B)', () => {
+  const e3 = calcule('eau', ESSAI, 3000)
+  const e6 = calcule('eau', ESSAI, 6000)
+  assert.equal(e3.status, 'OK')
+  assert.notEqual(e6.status, 'BUDGET_INSUFFISANT', e6.message_status)
+  for (const p of profils.slice(0, 2)) {
+    for (const b of [5500, 6000, 6500, 7000, 7500]) {
+      const ctx = moteurContexte.calculer({ code_postal: p.inputs.code_postal }, { france_climat }).sorties
+      const s = eau.calculer({ autodiag: p.inputs, budget_axe: b, contexte: ctx }, donnees).sorties
+      assert.notEqual(s.status, 'BUDGET_INSUFFISANT', `${p.nom} eau ${b} : ${s.message_status}`)
+    }
+  }
+})
+
+test('n° 5 — aucun accessoire forcé sans son principal (conduit sans poêle, ballon sans poêle hydro, filière sans noue) : essai et A, tous budgets', () => {
+  for (const [nom, autodiag] of [['essai', ESSAI], ['A', profils[0].inputs], ['B-P1.2', MAISON_B]]) {
+    for (const axe of ['eau', 'energie']) {
+      for (const b of [3000, 4000, 6000, 7500, 10000, 15000, 18000, 25000]) {
+        const s = calcule(axe, autodiag, b)
+        assert.deepEqual(orphelins(s), [], `${nom} ${axe} ${b} : accessoire forcé orphelin`)
+      }
+    }
+  }
+})
+
+test('n° 5 — noyau : appliqueCouplages lâche une ligne forcée dont le principal a disparu ; un downgrade du principal lâche ses accessoires', () => {
+  const reglages = { config: autonomie.noyau.configPourAxes(algo_config, { eau: false, energie: true, alim: false }), coefficients: COEFFICIENTS }
+  const vide = () => ({ postes: [], sous_total_eur_ht: 0, budget_alloue: 0, poids: 0 })
+  const sel = { eau: vide(), alim: vide(), energie: autonomie.noyau.selectionnePoste(25000, ESSAI, ctx31, options, postes, 'energie', reglages) }
+  // Le poste chauffage prend le poêle hydro (il requiert conduit + ballon tampon)
+  const typo = options.find((o) => o.code === 'bois_poele_hydro')
+  const cout = Math.round(autonomie.noyau.cout_typologie(typo, null, ESSAI))
+  const i = sel.energie.postes.findIndex((p) => p.poste_id === 'energie_chauffage_bois')
+  sel.energie.postes[i] = { ...sel.energie.postes[i], typologie_choisie: typo.code, nom_affichage: typo.nom, cout_eur_ht: cout, couplages_requis: autonomie.noyau.parseJsonArr(typo.couplages_requis), couplages_exclus: [] }
+  sel.energie.sous_total_eur_ht = sel.energie.postes.reduce((a, p) => a + p.cout_eur_ht, 0)
+  const c1 = autonomie.noyau.appliqueCouplages(sel, options, postes, reglages)
+  const forces = c1.axes.energie.postes.filter((p) => p.force_par_couplage).map((p) => p.typologie_choisie)
+  assert.ok(forces.includes('bois_conduit_fumee'), 'conduit forcé')
+  // Le principal disparaît : la passe suivante retire ses accessoires, et le sous-total suit
+  const sans = { ...c1.axes, energie: { ...c1.axes.energie, postes: c1.axes.energie.postes.filter((p) => p.typologie_choisie !== 'bois_poele_hydro') } }
+  sans.energie.sous_total_eur_ht = sans.energie.postes.reduce((a, p) => a + p.cout_eur_ht, 0)
+  const c2 = autonomie.noyau.appliqueCouplages(sans, options, postes, reglages)
+  assert.ok(c2.couplages_appliques.some((l) => l.startsWith('RETIRE "bois_conduit_fumee"')), c2.couplages_appliques.join(' | '))
+  assert.ok(!c2.axes.energie.postes.some((p) => p.force_par_couplage && p.typologie_choisie === 'bois_conduit_fumee'))
+  assert.equal(c2.axes.energie.sous_total_eur_ht, c2.axes.energie.postes.reduce((a, p) => a + p.cout_eur_ht, 0))
+  // CAS A sur un budget trop petit : le poêle hydro redescend, le conduit forcé ne reste pas verrouillé
+  const r = autonomie.noyau.reajusteBudget(c1, 8000, options, postes, ESSAI, ctx31, reglages, false)
+  const fin = autonomie.noyau.appliqueCouplages(r.axes, options, postes, reglages).axes.energie
+  assert.deepEqual(orphelins({ postes: fin.postes }), [], 'après réajustement, aucun accessoire orphelin')
+})
+
+test('n° 2 (journal) — finaliseSelection n\'additionne pas son propre journal à chaque tour', () => {
+  const reglages = { config: autonomie.noyau.configPourAxes(algo_config, { eau: true, energie: false, alim: false }), coefficients: COEFFICIENTS }
+  const vide = () => ({ postes: [], sous_total_eur_ht: 0, budget_alloue: 0, poids: 0 })
+  const sel = { energie: vide(), alim: vide(), eau: autonomie.noyau.selectionnePoste(7500, profils[0].inputs, ctx31, options, postes, 'eau', reglages) }
+  const fin = autonomie.noyau.finaliseSelection(sel, 7500, options, postes, profils[0].inputs, ctx31, reglages)
+  const force = fin.couplages.filter((l) => l.startsWith('FORCE'))
+  assert.equal(new Set(force).size, force.length, fin.couplages.join(' | '))
+})
+
+test('trouvé en chemin (n° 6) — une ligne remplacée par le réajustement porte SA dimension, pas celle de la ligne remplacée', () => {
+  for (const [axe, autodiag, budgets] of [['energie', ESSAI, [6000, 10000, 40000]], ['eau', ESSAI, [6000, 15000]], ['alim', profils[2].inputs, [21600]]]) {
+    for (const b of budgets) {
+      const s = calcule(axe, autodiag, b)
+      for (const p of s.postes) {
+        const o = options.find((x) => x.code === p.typologie_choisie)
+        const attendu = autonomie.noyau.dimension_optimale(o, autodiag, ctx31, COEFFICIENTS) || { valeur: o.quantite_default || 1, unite: o.unite || '' }
+        assert.deepEqual({ valeur: p.dimension.valeur, unite: p.dimension.unite }, { valeur: attendu.valeur, unite: attendu.unite }, `${axe} ${b} : ${p.typologie_choisie}`)
+      }
+      if (axe === 'energie' && !s.postes.some((p) => p.dimension.unite === 'kWc')) assert.equal(s.taux_couverture, null, `${b} : sans kWc, pas de taux`)
+    }
+  }
+})
+
+test('n° 7 — jardin : plus de lignes répétées, la quantité d\'un poste est sa dimension (essai 15 000, B 7 000)', () => {
+  const s = calcule('alim', ESSAI, 15000)
+  assert.deepEqual(doublons(s), [])
+  const planche = s.postes.find((p) => p.typologie_choisie === 'basse_planche_bec')
+  assert.ok(planche && planche.dimension.unite === 'm²' && planche.dimension.valeur > 0, 'la planche porte sa surface')
+  assert.equal(s.postes.length, 4, 'quatre postes, quatre lignes')
+  const ctxB = moteurContexte.calculer({ code_postal: profils[1].inputs.code_postal }, { france_climat }).sorties
+  const b = alimentation.calculer({ autodiag: profils[1].inputs, budget_axe: 7000, contexte: ctxB }, donnees).sorties
+  assert.deepEqual(doublons(b), [])
+  // Le budget que les répétitions consommaient reste disponible, et le statut le dit
+  assert.equal(b.status, 'AJOUTER_OPTIONNEL')
+})

test/monotonie.test.mjs

@@ -0,0 +1,44 @@
+// Monotonie en fonction du budget (SPEC menu branches fiches §12, v0.1.1) : sur
+// les trois profils de référence et les trois axes, de 1 000 à 40 000 € par pas
+// de 500 €, le statut ne repasse jamais de « correct » à « budget insuffisant »,
+// et le sous-total ne décroît pas au-delà de la tolérance de dépassement
+// (`budget_overrun_pct`, 5 % du budget). La stricte croissance n'est pas tenue
+// par l'heuristique (l'étape 3 choisit poste par poste, par paliers ; constaté
+// −4,4 % au plus sur A/énergie, voir RECAP-LOT-v0.1.1) : la borne retenue est
+// la bande de tolérance, celle que l'habitant voit déjà comme « correct ».
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { eau, energie, alimentation, contexte as moteurContexte } from '../dist/index.js'
+
+const lire = (f) => JSON.parse(readFileSync(new URL(`../fixtures/${f}`, import.meta.url), 'utf8'))
+const options = lire('options.json')
+const postes = lire('postes.json')
+const france_climat = lire('france_climat.json')
+const algo_config = lire('algo-config.json')
+const profils = lire('profils-reference.json')
+const donnees = { postes, options, algo_config, france_climat }
+const MOTEURS = { eau, energie, alim: alimentation }
+const tol = (algo_config.tolerances.budget_overrun_pct || 5) / 100
+
+const BUDGETS = []
+for (let b = 1000; b <= 40000; b += 500) BUDGETS.push(b)
+
+for (const profil of profils) {
+  const ctx = moteurContexte.calculer({ code_postal: profil.inputs.code_postal }, { france_climat }).sorties
+  for (const [axe, moteur] of Object.entries(MOTEURS)) {
+    test(`${profil.nom} / ${axe} : statut jamais OK → INSUFFISANT, sous-total jamais en baisse au-delà de la tolérance (1 000 → 40 000 € par 500)`, () => {
+      const serie = BUDGETS.map((b) => {
+        const s = moteur.calculer({ autodiag: profil.inputs, budget_axe: b, contexte: ctx }, donnees).sorties
+        assert.equal(s.sous_total_eur_ht, s.postes.reduce((a, p) => a + p.cout_eur_ht, 0), `${b} : sous-total = somme des lignes`)
+        return { b, status: s.status, st: s.sous_total_eur_ht }
+      })
+      for (let i = 1; i < serie.length; i++) {
+        const p = serie[i - 1]
+        const c = serie[i]
+        assert.ok(!(p.status !== 'BUDGET_INSUFFISANT' && c.status === 'BUDGET_INSUFFISANT'), `statut ${p.status} à ${p.b} € puis BUDGET_INSUFFISANT à ${c.b} €`)
+        assert.ok(c.st >= p.st - c.b * tol, `sous-total ${p.st} € à ${p.b} € puis ${c.st} € à ${c.b} € (baisse > ${tol * 100} % du budget)`)
+      }
+    })
+  }
+}