JulesandClaude Fable 5.1
8465bf7204
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
379 lines
21 KiB
JavaScript
379 lines
21 KiB
JavaScript
// reajuste.ts — Étape 5 : réajustement budget global
|
|
// Spec: V2-algo-spec.md §Étape 5 — origine calculs/src/lib/autonomie/reajuste.js.
|
|
// Correction LOT P1.0 : `reglages` en paramètre (plus de getConfig()).
|
|
// Comportement d'origine conservé : la fonction modifie EN PLACE les axes
|
|
// reçus (qui sont déjà la copie produite par appliqueCouplages) et les renvoie.
|
|
//
|
|
// 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) {
|
|
const config = reglages.config;
|
|
const coefficients = reglages.coefficients;
|
|
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);
|
|
}
|
|
function recalcSousTotal(axe) {
|
|
const a = axes[axe];
|
|
if (a) {
|
|
a.sous_total_eur_ht = a.postes.reduce((s, p) => s + (p.cout_eur_ht || 0), 0);
|
|
}
|
|
}
|
|
let total = calcTotal();
|
|
let status = 'OK';
|
|
let message = '';
|
|
const log = debug ? [] : null;
|
|
// CAS A : overrun
|
|
if (total > budget_total * overrun_seuil) {
|
|
if (log)
|
|
log.push('CAS A : total ' + total + ' > seuil ' + Math.round(budget_total * overrun_seuil));
|
|
let iterations = 0;
|
|
while (total > budget_total * overrun_seuil && iterations < 80) {
|
|
iterations++;
|
|
// Correctif V3-1 (recalibrage) : downgrade "au plus pres du budget" au
|
|
// lieu du moins cher. Historiquement, le poste candidat sautait vers son
|
|
// alternative LA MOINS CHERE (ex : poele de masse -> rocket stove,
|
|
// -23 000 EUR la ou quelques centaines suffisaient a repasser sous le
|
|
// 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 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);
|
|
// 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);
|
|
const cout = cout_typologie(alt, dim, inputs);
|
|
return { alt, dim, cout };
|
|
})
|
|
.filter((a) => a.cout < (poste_candidat.cout_eur_ht || 0));
|
|
for (const a of alts_scored) {
|
|
candidats.push({
|
|
poste: poste_candidat,
|
|
alt: a,
|
|
// 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),
|
|
});
|
|
}
|
|
}
|
|
let choix = null;
|
|
if (candidats.length > 0) {
|
|
// total resultant le plus proche du budget (tiebreak : pire score d'abord)
|
|
candidats.sort((a, b) => Math.abs(total - a.diff - budget_total) - Math.abs(total - b.diff - budget_total) ||
|
|
(a.poste.score_final || 0) - (b.poste.score_final || 0));
|
|
choix = candidats[0];
|
|
}
|
|
let downgraded = false;
|
|
if (choix) {
|
|
const poste_candidat = choix.poste;
|
|
const meilleur = choix.alt;
|
|
const diff = choix.diff;
|
|
const axe_poste = poste_candidat._axe;
|
|
const ax = axes[axe_poste];
|
|
const idx = ax.postes.findIndex((p) => p.typologie_choisie === poste_candidat.typologie_choisie);
|
|
if (idx >= 0) {
|
|
const p = ax.postes[idx];
|
|
ax.postes[idx] = Object.assign({}, p, {
|
|
typologie_choisie: meilleur.alt.code,
|
|
nom_affichage: meilleur.alt.nom,
|
|
description_pedago: meilleur.alt.description_pedago || '',
|
|
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);
|
|
downgraded = true;
|
|
if (log)
|
|
log.push('Downgrade ' + poste_candidat.typologie_choisie + ' -> ' + meilleur.alt.code + ' -' + diff + 'EUR (accessoires compris)');
|
|
}
|
|
}
|
|
if (!downgraded) {
|
|
const optionnels = getTousPostes().filter((p) => !p.obligatoire && !p.force_par_couplage && !p.manuel);
|
|
optionnels.sort((a, b) => (a.score_final || 0) - (b.score_final || 0));
|
|
if (optionnels.length > 0) {
|
|
const pire = optionnels[0];
|
|
const axe_poste = pire._axe;
|
|
const ax = axes[axe_poste];
|
|
const idx = ax.postes.findIndex((p) => p.typologie_choisie === pire.typologie_choisie);
|
|
if (idx >= 0) {
|
|
ax.postes.splice(idx, 1);
|
|
recalcSousTotal(axe_poste);
|
|
downgraded = true;
|
|
if (log)
|
|
log.push('Retrait optionnel ' + pire.typologie_choisie);
|
|
}
|
|
}
|
|
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';
|
|
message =
|
|
'Budget insuffisant pour équiper tous les postes obligatoires. Estimation minimale : ' +
|
|
Math.round(total).toLocaleString('fr-FR') +
|
|
' EUR. Votre budget : ' +
|
|
Math.round(budget_total).toLocaleString('fr-FR') +
|
|
' EUR.';
|
|
if (log)
|
|
log.push('BUDGET_INSUFFISANT — toutes alternatives épuisées');
|
|
}
|
|
}
|
|
// CAS B : underspend
|
|
else if (total < budget_total * underspend_seuil) {
|
|
if (log)
|
|
log.push('CAS B : total ' + total + ' < seuil ' + Math.round(budget_total * underspend_seuil));
|
|
// Axes explicitement désactivés par l'utilisateur (V3 toggles d'axes) :
|
|
// 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 || []);
|
|
// Construire mapping poste_code → axe via postes BDD
|
|
const posteIdToAxe = {};
|
|
if (postes) {
|
|
for (const p of postes) {
|
|
const axe_norm = (p.axe === 'alimentation' ? 'alim' : p.axe);
|
|
posteIdToAxe[p.Id] = axe_norm;
|
|
}
|
|
}
|
|
let iterations = 0;
|
|
while (total < budget_total * underspend_seuil && iterations < 80) {
|
|
iterations++;
|
|
let upgraded = false;
|
|
// v0.1.1 : état réel à chaque tour (l'origine figeait la liste des codes
|
|
// 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 && !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
|
|
// (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;
|
|
for (const r of requis_list) {
|
|
const r_resolved = alias[r] || r;
|
|
if (!codes_sel.has(r) && !codes_sel.has(r_resolved)) {
|
|
const typo_req = options.find((o) => o.code === r_resolved || o.code === r);
|
|
if (typo_req) {
|
|
const dim_req = dimension_optimale(typo_req, inputs, contexte_derived, coefficients);
|
|
cout_couplages_requis += cout_typologie(typo_req, dim_req, inputs);
|
|
}
|
|
}
|
|
}
|
|
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) - coutLibere(poste_candidat, a.alt, instantane);
|
|
// 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);
|
|
const meilleur = alts_scored[0];
|
|
const diff = Math.round(meilleur.cout) - (poste_candidat.cout_eur_ht || 0);
|
|
const axe_poste = poste_candidat._axe;
|
|
const ax = axes[axe_poste];
|
|
const idx = ax.postes.findIndex((p) => p.typologie_choisie === poste_candidat.typologie_choisie);
|
|
if (idx >= 0) {
|
|
const p = ax.postes[idx];
|
|
ax.postes[idx] = Object.assign({}, p, {
|
|
typologie_choisie: meilleur.alt.code,
|
|
nom_affichage: meilleur.alt.nom,
|
|
description_pedago: meilleur.alt.description_pedago || '',
|
|
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),
|
|
couplages_exclus: parseJsonArr(meilleur.alt.couplages_exclus),
|
|
_upgraded: true,
|
|
});
|
|
recalcSousTotal(axe_poste);
|
|
total += diff;
|
|
upgraded = true;
|
|
if (log)
|
|
log.push('Upgrade ' + poste_candidat.typologie_choisie + ' -> ' + meilleur.alt.code + ' +' + diff + 'EUR');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// 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;
|
|
});
|
|
// Trier par rapport score/cout et taille raisonnable
|
|
const candidats_add = postes_manquants
|
|
.map((o) => {
|
|
const dim = dimension_optimale(o, inputs, contexte_derived, coefficients);
|
|
const cout = cout_typologie(o, dim, inputs);
|
|
return { opt: o, dim, cout };
|
|
})
|
|
.filter((a) => a.cout > 0 && total + a.cout <= budget_total * overrun_seuil);
|
|
candidats_add.sort((a, b) => a.cout - b.cout);
|
|
if (candidats_add.length > 0) {
|
|
const best = candidats_add[candidats_add.length - 1]; // le plus cher qui rentre
|
|
const axe_target = posteIdToAxe[best.opt.poste_id] || 'energie';
|
|
const ax = axes[axe_target];
|
|
if (ax) {
|
|
const valeur_dim = best.dim ? best.dim.valeur : best.opt.quantite_default || 1;
|
|
const unite_dim = best.dim ? best.dim.unite : best.opt.unite || '';
|
|
ax.postes.push({
|
|
poste_id: best.opt.poste_id,
|
|
poste_nom: best.opt.nom,
|
|
obligatoire: false,
|
|
budget_alloue_poste: Math.round(best.cout),
|
|
typologie_choisie: best.opt.code,
|
|
nom_affichage: best.opt.nom,
|
|
description_pedago: best.opt.description_pedago || '',
|
|
dimension: { valeur: valeur_dim, unite: unite_dim },
|
|
cout_eur_ht: Math.round(best.cout),
|
|
score_adequation: 0.6,
|
|
score_final: 0,
|
|
alternatives: [],
|
|
notes_techniques: best.opt.notes_techniques || '',
|
|
flag_diy: best.opt.flag_diy || false,
|
|
complexite_pose: best.opt.complexite_pose || 2,
|
|
// v0.1.1 : la ligne dit ce qu'elle requiert (l'origine écrivait [] :
|
|
// 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);
|
|
upgraded = true;
|
|
if (log)
|
|
log.push('Ajout optionnel ' + best.opt.code + ' +' + Math.round(best.cout) + 'EUR');
|
|
}
|
|
}
|
|
}
|
|
if (!upgraded) {
|
|
status = 'AJOUTER_OPTIONNEL';
|
|
message = 'Budget non consommé (' + Math.round(budget_total - total).toLocaleString('fr-FR') + ' EUR disponibles). Postes optionnels suggérés non inclus.';
|
|
if (log)
|
|
log.push('AJOUTER_OPTIONNEL — budget non consommable');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
total = calcTotal();
|
|
return {
|
|
axes,
|
|
total: Math.round(total),
|
|
status,
|
|
message,
|
|
couplages_appliques: apres_couplages.couplages_appliques ?? [],
|
|
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;
|
|
}
|