pipcode 0.0.0-stage → 2.1.1

package/src/engine/plan-mission.js

@@ -0,0 +1,60 @@
+// src/engine/plan-mission.js — Logique métier de l'outil plugcto_plan_mission.
+// args = { need, auto_mode, missionPath?, pcfg?, plan? } → { isError, text,
+// autoMode, wrote, plan }. `plan` court-circuite l'extraction (tests) ; `pcfg`
+// active l'extraction LLM (sinon déterministe). Sans auto_mode : extraction +
+// DRAFT persisté (réutilisable à la confirmation) + question Y/n — mission.md
+// NON écrit. Avec auto_mode=true : réextraction/réutilisation du draft puis écriture mission.md.
+import { MISSION_PATH } from "./mission-paths.js";
+import { extractMission } from "./extract-llm.js";
+import { writeMission } from "./mission-store.js";
+import { formatConsoleSummary } from "./plan-summary.js";
+import { formatPlanReply } from "./plan-reply.js";
+import { readPlanDraft, savePlanDraft, removePlanDraft } from "./plan-draft.js";
+
+/** @typedef {{ need?: string, auto_mode?: boolean, missionPath?: string, pcfg?: { primary: ProviderPrimary } | null, plan?: MissionPlan }} PlanMissionArgs */
+
+/** @param {PlanMissionArgs} args */
+export async function planMission(args) {
+  const need = (args && typeof args.need === "string" ? args.need : "").trim();
+  if (!need) {
+    return {
+      isError: true,
+      text: "Paramètre `need` manquant ou vide pour plugcto_plan_mission. Décrivez le besoin métier à planifier.",
+    };
+  }
+  const autoMode = !!(args && args.auto_mode);
+  const missionPath = (args && args.missionPath) || MISSION_PATH;
+  const draftPath = missionPath + ".draft.json";
+
+  let plan;
+  if (args && args.plan) {
+    plan = args.plan; // injection directe (tests)
+  } else if (autoMode) {
+    // Réutilise le draft de la phase de consentement si le besoin correspond
+    // (évite un 2e appel LLM après confirmation).
+    plan = (await readPlanDraft(draftPath, need)) || (await extractMission(need, args && args.pcfg));
+  } else {
+    plan = await extractMission(need, args && args.pcfg);
+  }
+
+  plan.need = need;
+  plan.autoMode = autoMode;
+  plan.iterations = plan.iterations || 0;
+  plan.checkedSteps = plan.checkedSteps || (plan.impact.steps || []).map(() => false);
+
+  // Résumé diagnostic sur stderr (stdout = canal protocole MCP, interdit).
+  console.error(formatConsoleSummary(plan));
+
+  if (!autoMode) {
+    // Consentement : draft persisté SANS écrire mission.md + question Y/n.
+    await savePlanDraft(plan, draftPath);
+    return { isError: false, autoMode: false, wrote: false, plan, text: formatPlanReply(plan, false) };
+  }
+
+  // Auto Mode confirmé : écrit le scratchpad + sidecar, supprime le draft.
+  plan.validatedAt = new Date().toISOString();
+  await writeMission(plan, missionPath);
+  await removePlanDraft(draftPath);
+  return { isError: false, autoMode: true, wrote: true, plan, text: formatPlanReply(plan, true) };
+}
+// MODULE_COMPLETE

package/src/engine/plan-reply-legacy.js

@@ -0,0 +1,34 @@
+// src/engine/plan-reply-legacy.js — Cas "code spaghetti/legacy" (exigence produit) :
+// si l'audit Phase 0 révèle des failles, la réponse de plan propose EXPLICITEMENT
+// deux issues — refactoring contrôlé OU clone propre sécurisé — et impose le
+// Stop & Wait : aucun code avant le choix de l'utilisateur (§11 core_rules).
+
+// Seuil heuristique : à partir de 4 failles cumulées + risque Élevé, le clone
+// propre devient l'option recommandée (le refactoring coûte plus cher que la
+// réécriture). Sinon, priorité au refactoring incrémental (moindre risque).
+const CLONE_THRESHOLD = 4;
+
+// Pousse la section décision legacy (rien si aucune faille détectée).
+/** @param {MissionPlan} plan @param {string[]} L @returns {void} */
+export function pushLegacyDecision(plan, L) {
+  const pitfalls = plan.pitfalls || [];
+  if (pitfalls.length === 0) return; // projet sain : pas de bloc décision.
+  const nConstraints = (plan.constraints || []).length;
+  const highRisk = !!plan.impact && plan.impact.risk === "Élevé";
+  const cloneFirst = highRisk && pitfalls.length >= CLONE_THRESHOLD;
+  L.push("");
+  L.push(`⚠️ **Code legacy détecté** — ${pitfalls.length} faille(s) et ${nConstraints} contrainte(s) d'audit.`);
+  if (cloneFirst) {
+    L.push("Recommandation : **clone propre sécurisé** (réécriture) — le refactoring coûterait");
+    L.push("plus cher que la réécriture vu la densité de failles et le risque Élevé.");
+  } else {
+    L.push("Recommandation : **refactoring contrôlé** (incremental, tests de non-régression");
+    L.push("à chaque étape) — la base existante reste récupérable à coût maîtrisé.");
+  }
+  L.push("");
+  L.push("> **Deux issues possibles — votre choix est requis (Stop & Wait, §11) :**");
+  L.push("> 1️⃣ Refactoring contrôlé du code existant.");
+  L.push("> 2️⃣ Clone propre sécurisé (nouvelle base, specs reprises de l'audit).");
+  L.push("> Aucune ligne de code ne sera écrite avant votre décision explicite.");
+}
+// MODULE_COMPLETE

package/src/engine/plan-reply-pillars.js

@@ -0,0 +1,34 @@
+// src/engine/plan-reply-pillars.js — Réply plan_mission, sections (a)-(e) :
+// header projet + les 5 piliers métier (personas, contraintes, failles,
+// glossaire, estimation). Retourne nSteps (réutilisé par la question Y/n).
+/** @param {MissionPlan} plan @param {string[]} L @returns {number} */
+export function pushPillarSections(plan, L) {
+  const { personas, constraints, pitfalls, glossary, impact, domainKeys, fiches } = plan;
+  const nSteps = (impact.steps || []).length;
+  L.push("## 🎯 PipCode — Plan de mission (Phase 0 — 5 piliers)");
+  L.push("");
+  L.push(`**Projet** : ${plan.projectName}`);
+  L.push(`**Besoin** : ${plan.need}`);
+  L.push(`**Domaines** : ${(domainKeys || []).join(", ") || "—"}`);
+  L.push("");
+  L.push("### (a) Personas métiers & garde-fous");
+  for (const p of personas) L.push(`- **${p.role_name}** — ${p.mandate}`);
+  L.push("");
+  L.push("### (b) Contraintes légales & invariants (NON NEGO)");
+  for (const c of constraints) L.push(`- ${c.text}${c.invariant ? ` — Invariant : ${c.invariant}` : ""}`);
+  L.push("");
+  L.push("### (c) Failles métiers à bloquer");
+  for (const f of pitfalls) L.push(`- ❌ NE JAMAIS : ${f.never}  →  ✅ TOUJOURS : ${f.always}`);
+  L.push("");
+  L.push("### (d) Glossaire & lexique métier");
+  for (const g of glossary) L.push(`- \`${g.term}\` : ${g.definition}`);
+  L.push("");
+  L.push("### (e) Estimation & impact");
+  L.push(`- Fichiers : ${(impact.files || []).join(", ") || "—"}`);
+  L.push(`- Étapes (${nSteps}) : ${(impact.steps || []).join(" · ")}`);
+  L.push(`- Tokens : ~${impact.tokens} | Risque métier : ${impact.risk}`);
+  L.push(`- Fiches de doctrine : ${(fiches || []).join(", ") || "—"}`);
+  L.push("");
+  return nSteps;
+}
+// MODULE_COMPLETE

package/src/engine/plan-reply-ux.js

@@ -0,0 +1,17 @@
+// src/engine/plan-reply-ux.js — Réply plan_mission, sections (f)-(g) :
+// directives UX (§5) et charte visuelle / Design System contextuel (§6).
+/** @param {MissionPlan} plan @param {string[]} L */
+export function pushUxSections(plan, L) {
+  const ux = plan.uxDirectives || [];
+  const ds = plan.designSystem || {};
+  L.push("### (f) Directives UX & ergonomie métier");
+  for (const r of ux) L.push(`- ${r}`);
+  L.push(`- Accessibilité : ${ds.wcag || "WCAG 2.1 AA"}`);
+  L.push("");
+  L.push("### (g) Charte visuelle & Design System contextuel");
+  L.push(`- Famille ${ds.family || ""} : ${ds.style || ""} | densité ${ds.density || ""}`);
+  L.push(`- Palette : ${ds.palette || "—"} | Micro-interactions : ${ds.microInteractions || "—"}`);
+  for (const v of (ds.violations || [])) L.push(`- ❌ Hors charte : ${v.rule}`);
+  L.push("");
+}
+// MODULE_COMPLETE

package/src/engine/plan-reply.js

@@ -0,0 +1,28 @@
+// src/engine/plan-reply.js — Formate la réponse de plan_mission pour l'IDE
+// (5 piliers + UX/Design + question de consentement Auto Mode).
+import { pushPillarSections } from "./plan-reply-pillars.js";
+import { pushUxSections } from "./plan-reply-ux.js";
+import { pushLegacyDecision } from "./plan-reply-legacy.js";
+
+/** @param {MissionPlan} plan @param {boolean} autoMode @returns {string} */
+export function formatPlanReply(plan, autoMode) {
+  const L = /** @type {string[]} */ ([]);
+  const nSteps = pushPillarSections(plan, L);
+  pushUxSections(plan, L);
+  pushLegacyDecision(plan, L);
+  if (autoMode) {
+    L.push("✅ **Auto Mode ACTIVÉ** — scratchpad `.pipcode/mission.md` écrit.");
+    L.push("Relisez ce contexte à chaque itération : ne produisez aucun patch qui viole les");
+    L.push("anti-patterns (§3), invariants réglo (§2) ou le Design System (§6),");
+    L.push("et cochez la checklist (§4) au fil de l'exécution.");
+  } else {
+    L.push(`⏸️ **Consentement Auto Mode requis** — ${nSteps} étapes prévues sans déviation.`);
+    L.push("");
+    L.push("> **Activer le Auto Mode pour exécuter les N étapes sans déviation ? [Y/n]**");
+    L.push(">");
+    L.push("> Répondez `Y` en rappelant `plugcto_plan_mission` avec `auto_mode: true`.");
+    L.push("> Le scratchpad `.pipcode/mission.md` ne sera écrit qu'après confirmation.");
+  }
+  return L.join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/plan-summary.js

@@ -0,0 +1,16 @@
+// src/engine/plan-summary.js — Résumé diagnostic concis de plan_mission (stderr ;
+// stdout = canal protocole MCP, interdit au bruit applicatif).
+/** @param {MissionPlan} plan @returns {string} */
+export function formatConsoleSummary(plan) {
+  const nSteps = (plan.impact.steps || []).length;
+  return [
+    "[plugcto_plan_mission] Diagnostic Phase 0",
+    `  Projet    : ${plan.projectName}`,
+    `  Domaines  : ${(plan.domainKeys || []).join(", ") || "—"}`,
+    `  Personas  : ${(plan.personas || []).length}`,
+    `  Contraintes: ${(plan.constraints || []).length} | Failles: ${(plan.pitfalls || []).length} | Glossaire: ${(plan.glossary || []).length}`,
+    `  Impact    : ~${plan.impact.tokens} tokens | ${nSteps} étapes | risque ${plan.impact.risk}`,
+    `  UX/Design : ${(plan.uxDirectives || []).length} directives | charte ${plan.designSystem ? plan.designSystem.family : "?"} (${plan.designSystem ? plan.designSystem.style : "—"})`,
+  ].join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/preflight-text.js

@@ -0,0 +1,27 @@
+// src/engine/preflight-text.js — Messages du pré-flight de capacités. Le message
+// d'arrêt suit EXACTEMENT la formulation validée ; le détail dit, pour chaque
+// modèle, ce qui est confirmé, refusé ou non confirmé, et d'où vient l'info.
+
+import { CAP_LABEL } from "./cap-types.js";
+
+/** @param {boolean | null} v @returns {string} */
+const state = (v) => (v === true ? "oui" : v === false ? "non" : "non confirmé");
+
+/** @param {string} label @param {CapModel | null | undefined} model @param {CapReport | null | undefined} report @returns {string} */
+function line(label, model, report) {
+  if (!model || !report) return `${label} : non configuré`;
+  return `${label} (${model.model}) : ${report.detail.map((d) => `${CAP_LABEL[d.cap]} ${state(d.value)} — ${d.source}`).join(", ")}`;
+}
+
+/** Arrêt AVANT l'appel principal : 0 token consommé sur la tâche. */
+/** @param {CapModel} m1 @param {CapReport} r1 @param {CapModel | null | undefined} m2 @param {CapReport | null | undefined} r2 @returns {string} */
+export function stopMessage(m1, r1, m2, r2) {
+  return `Aucun des deux modèles configurés ne supporte cette tâche [${line("Modèle 1", m1, r1)} ; ${line("Modèle 2", m2, r2)}]. Veuillez sélectionner ou ajouter un modèle adapté dans Mes API.`;
+}
+
+/** Le Modèle 1 est incapable mais le Modèle 2 confirme : la tâche lui est confiée. */
+/** @param {CapModel} m1 @param {CapModel} m2 @returns {string} */
+export function routeNotice(m1, m2) {
+  return `Le Modèle 1 (${m1.model}) ne supporte pas cette tâche : elle est confiée au Modèle 2 (${m2.model}).`;
+}
+// MODULE_COMPLETE

package/src/engine/preflight.js

@@ -0,0 +1,27 @@
+// src/engine/preflight.js — Cascade de contrôle AVANT tout appel principal :
+// 1. le Modèle 1 évalue s'il maîtrise la capacité requise ; 2. sinon on vérifie
+// le Modèle 2 (MÊME évaluation, symétrique) ; 3. si aucun des deux : arrêt de la
+// chaîne avec message explicite — la requête principale n'est JAMAIS envoyée
+// (0 token sur la tâche ; seule la micro-question de niveau 2, mise en cache,
+// a pu être posée). Aucune capacité requise → aucun coût, aucune requête.
+
+import { evaluateModel } from "./cap-eval.js";
+import { stopMessage, routeNotice } from "./preflight-text.js";
+
+/** @typedef {{ ok: true, runner: "primary" | "secondary", notice: string, reports: CapReport[] } | { ok: false, message: string, reports: CapReport[] }} PreflightResult */
+
+/**
+ * @param {{ required: Capability[], primary: CapModel, secondary?: CapModel | null }} args
+ * @param {{ evaluate?: typeof evaluateModel } & import("./cap-eval.js").EvalDeps} [deps]
+ * @returns {Promise<PreflightResult>}
+ */
+export async function runPreflight({ required, primary, secondary }, deps = {}) {
+  if (required.length === 0) return { ok: true, runner: "primary", notice: "", reports: [] };
+  const evaluate = deps.evaluate || evaluateModel;
+  const r1 = await evaluate(primary, required, deps);
+  if (r1.ok) return { ok: true, runner: "primary", notice: "", reports: [r1] };
+  const r2 = secondary ? await evaluate(secondary, required, deps) : null;
+  if (secondary && r2 && r2.ok) return { ok: true, runner: "secondary", notice: routeNotice(primary, secondary), reports: [r1, r2] };
+  return { ok: false, message: stopMessage(primary, r1, secondary, r2), reports: r2 ? [r1, r2] : [r1] };
+}
+// MODULE_COMPLETE

package/src/engine/project-brief.js

@@ -0,0 +1,41 @@
+// src/engine/project-brief.js — Cahier de départ transmis à la décomposition du Mode Auto : CLAUDE.md du client (prioritaire) puis
+// DÉCISIONS de la mémoire du projet (choix de l'utilisateur, puis choix proposés « à confirmer »). Lecture seule. Chaque texte est
+// repris tel quel ; ce qui ne tient pas dans le budget est annoncé.
+
+import { CAHIERS } from "../project-memory/cahiers.js";
+import { parseDecisions } from "../project-memory/decisions.js";
+import { readMemoryFile } from "../project-memory/store.js";
+import { projectInstructions } from "./project-instructions.js";
+import { fitLines } from "./context-fit.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const MAX_REPORT = 20_000;
+
+/** Rapport d'audit du projet (.pipcode/AUDIT_REPORT.md) : base du plan ; absent = "". @param {string} root @returns {Promise<string>} */
+async function auditReport(root) {
+  const md = (await fs.readFile(path.join(root, ".pipcode", "AUDIT_REPORT.md"), "utf8").catch(() => "")).trim();
+  return md ? `--- Rapport d'audit du projet (AUDIT_REPORT.md) : base du plan ---\n${md.slice(0, MAX_REPORT)}${md.length > MAX_REPORT ? "\n[… rapport tronqué]" : ""}` : "";
+}
+
+/** @param {{ source: string, status: string, confidence?: number }} d @returns {string} */
+const labelOf = (d) => d.status === "refuse" ? "REFUSÉ (ne pas reproposer)" : d.status === "confirme" || d.source === "utilisateur" ? "VALIDÉ" : `À CONFIRMER${d.confidence !== undefined ? ` (≈ ${d.confidence} % estimé)` : ""}`;
+
+/** @param {string} root @returns {Promise<string>} */
+async function decisionsBlock(root) {
+  const lines = [];
+  for (const c of CAHIERS) {
+    for (const d of parseDecisions((await readMemoryFile(root, `${c}.md`)) ?? "")) {
+      lines.push(`[${c}] ${labelOf(d)} — ${d.question} → ${d.answer.replace(/\n+/g, " ")}`);
+    }
+  }
+  if (lines.length === 0) return "";
+  const { text, omitted } = fitLines(lines, 12_000);
+  return `--- Décisions du projet (mémoire) : les VALIDÉES s'imposent, les REFUSÉES sont exclues ---\n${text}${omitted ? `\n[… ${omitted} décisions non chargées : budget plein]` : ""}`;
+}
+
+/** Cahier complet ("" si rien). @param {string} root @returns {Promise<string>} */
+export async function projectBrief(root) {
+  return [await projectInstructions(root, 20_000), await decisionsBlock(root), await auditReport(root)].filter(Boolean).join("\n\n");
+}
+// MODULE_COMPLETE

package/src/engine/project-context.js

@@ -0,0 +1,49 @@
+// src/engine/project-context.js — Contexte projet du chat : arborescence + relations entre fichiers (graphe) + mémoire des cahiers
+// pertinente + contenu des fichiers (ouverts, voisins, reste) dans la fenêtre du modèle. AUCUNE perte silencieuse : éléments
+// entiers, ce qui ne tient pas est listé. Chaque information apparaît UNE fois ; les règles de doctrine restent dans le prompt système.
+
+import { listProjectFiles } from "../auto/project-files.js";
+import { buildGraph } from "./code-graph.js";
+import { NOISE_FILE, orderFiles, safeRead } from "./context-files.js";
+import { fitFiles, fitLines } from "./context-fit.js";
+import { contextChars } from "../project-memory/window.js";
+import { recallSections } from "../project-memory/recall.js";
+import { numberLines } from "./line-numbers.js";
+
+const MAX_NAMES = 12;
+
+/** @param {Map<string, { exports: string[], imports: Array<{ to: string, names: string[] }> }>} graph @returns {string[]} */
+export function relationLines(graph) {
+  const lines = [];
+  for (const [f, n] of graph) {
+    if (n.exports.length) lines.push(`${f} déclare : ${n.exports.slice(0, MAX_NAMES).join(", ")}`);
+    for (const i of n.imports) lines.push(`${f} → ${i.to}${i.names.length ? ` {${i.names.slice(0, MAX_NAMES).join(", ")}}` : ""}`);
+  }
+  return lines;
+}
+/** @param {Parameters<typeof relationLines>[0]} graph @returns {string} */
+export const formatRelations = (graph) => relationLines(graph).join("\n");
+
+/** @param {string} title @param {string[]} lines @param {number} budget @returns {string} */
+function section(title, lines, budget) {
+  const { text, omitted } = fitLines(lines, budget);
+  return `--- ${title} ---\n${text}${omitted ? `\n[… ${omitted} lignes non chargées : fenêtre pleine]` : ""}`;
+}
+
+/** Bloc de contexte ("" si projet vide). @param {string} projectPath @param {string[]} [openFiles] @param {string} [question] @param {number} [windowChars] budget du contexte (défaut : fenêtre du modèle) @param {{ numbered?: boolean }} [opts] numbered : chaque ligne de code porte son numéro (audit : références exactes) @returns {Promise<string>} */
+export async function buildProjectContext(projectPath, openFiles = [], question = "", windowChars = contextChars(), opts = {}) {
+  const tree = (await listProjectFiles(projectPath)).filter((f) => !NOISE_FILE.test(f));
+  if (tree.length === 0) return "";
+  const W = windowChars; // modèle local (Ollama) : budget réduit, évaluation du prompt rapide
+  const graph = await buildGraph(projectPath, tree);
+  const parts = [section(`Projet : arborescence (${tree.length} fichiers source)`, tree, W * 0.1), section("Projet : relations entre fichiers (imports, symboles déclarés)", relationLines(graph), W * 0.15)];
+  const files = [];
+  for (const f of orderFiles(tree, graph, openFiles.slice(0, 20))) { const text = await safeRead(projectPath, f); if (text !== null) files.push({ path: f, text: opts.numbered ? numberLines(text) : text }); }
+  const { blocks, left } = fitFiles(files, W * 0.5);
+  if (blocks.length) parts.push(`--- Projet : contenu des fichiers (ouverts d'abord) ---\n${blocks.join("\n\n")}`);
+  if (left.length) parts.push(`--- Fichiers NON chargés (hors fenêtre) : demandez-les au besoin ---\n${left.join("\n")}`);
+  const mem = await recallSections(projectPath, question, openFiles, W * 0.25); // le plus VARIABLE (dépend de la question) : EN DERNIER, le début reste identique d'un message à l'autre (cache)
+  if (mem.text) parts.push(`--- Mémoire du projet (cahiers) ---\n${mem.text}${mem.omitted.length ? `\n[Sections non chargées : ${mem.omitted.join(", ")}]` : ""}`);
+  return parts.join("\n\n");
+}
+// MODULE_COMPLETE

package/src/engine/project-instructions.js

@@ -0,0 +1,19 @@
+// src/engine/project-instructions.js — CLAUDE.md du projet de l'utilisateur : lu (JAMAIS modifié, supprimé ni déplacé), transmis
+// comme instructions PRIORITAIRES du projet (placées dans le prompt système). Les règles PipCode le complètent en garde-fous
+// silencieux : aucun message de conflit n'est jamais affiché. Lecture seule, sans créer de fichier ; trouvé quelle que soit la casse (CLAUDE.md, claude.md…).
+
+import fs from "node:fs/promises";
+import { safeRead } from "./context-files.js";
+import { fitLines } from "./context-fit.js";
+
+const TITLE = "--- Instructions du projet (CLAUDE.md) : PRIORITAIRES ---";
+
+/** Bloc prêt à injecter ("" si absent ou vide). @param {string} root @param {number} budget caractères disponibles @returns {Promise<string>} */
+export async function projectInstructions(root, budget) {
+  const name = await fs.readdir(root).then((names) => names.find((n) => n.toLowerCase() === "claude.md"), () => undefined);
+  const text = name ? await safeRead(root, name) : null;
+  if (!text || !text.trim()) return "";
+  const { text: kept, omitted } = fitLines(text.replace(/\r\n/g, "\n").split("\n"), budget);
+  return `${TITLE}\n${kept}${omitted ? `\n[… ${omitted} lignes de CLAUDE.md non chargées : fenêtre pleine]` : ""}`;
+}
+// MODULE_COMPLETE

package/src/engine/py-imports.js

@@ -0,0 +1,31 @@
+// src/engine/py-imports.js — Imports Python du projet (relatifs ET absolus) résolus vers un fichier CONNU : « import orchestrator », « from app.db import x ».
+// Motifs seulement, jamais d'exécution ; une bibliothèque tierce (fastapi, os…) n'est pas un fichier connu donc ignorée.
+import path from "node:path";
+
+const REL = /^from\s+(\.+)([\w.]+)\s+import\s+(.+)$/gm;
+const FROM = /^from\s+([A-Za-z_][\w.]*)\s+import\s+(.+)$/gm;
+const PLAIN = /^import\s+([A-Za-z_][\w.]*(?:\s+as\s+\w+)?(?:\s*,\s*[A-Za-z_][\w.]*(?:\s+as\s+\w+)?)*)\s*$/gm;
+
+/** @param {string} list @returns {string[]} */
+const namesIn = (list) => list.replace(/[()]/g, "").split("#")[0].split(",").map((s) => s.trim().split(/\s+as\s+/)[0]).filter(Boolean);
+
+/** @param {string} file @param {string} dotted @param {Set<string>} known @returns {string | undefined} module du projet : à la racine ou à côté du fichier */
+function locate(file, dotted, known) {
+  const stem = dotted.replace(/\./g, "/");
+  const bases = ["", path.posix.dirname(file)];
+  return bases.flatMap((b) => [stem + ".py", stem + "/__init__.py"].map((c) => path.posix.normalize(path.posix.join(b, c)))).find((c) => known.has(c) && c !== file);
+}
+
+/** @param {string} file @param {string} text @param {Set<string>} known @returns {Array<{ to: string, names: string[] }>} */
+export function pythonImports(file, text, known) {
+  const out = [];
+  for (const m of text.matchAll(REL)) {
+    const dir = path.posix.join(path.posix.dirname(file), ...Array(m[1].length - 1).fill(".."));
+    const to = path.posix.normalize(path.posix.join(dir, m[2].replace(/\./g, "/"))) + ".py";
+    if (known.has(to)) out.push({ to, names: namesIn(m[3]) });
+  }
+  for (const m of text.matchAll(FROM)) { const to = locate(file, m[1], known); if (to) out.push({ to, names: namesIn(m[2]) }); }
+  for (const m of text.matchAll(PLAIN)) for (const mod of m[1].split(",")) { const to = locate(file, mod.trim().split(/\s+as\s+/)[0], known); if (to) out.push({ to, names: ["*"] }); }
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/relay-analysis.js

@@ -0,0 +1,44 @@
+// src/engine/relay-analysis.js — Boucle de relais de contexte (Phase 1 analyse) :
+// chaque agent LLM analyse UN fragment dans sa zone de confort ; l'appel SUIVANT
+// est ensemencé par le digest (constats acquis + reste + mission), même
+// provider/modèle, cachePrefix (missionCtx) conservé. Digestion complète
+// garantie par MAX_RELAYS (erreur relay_limit honnête sinon).
+import { callLLM } from "../core/llm-call.js";
+import { analysisPrompt } from "../core/llm-prompts.js";
+import { withLanguage } from "../core/lang.js";
+import { ANALYSIS_MAX_TOKENS } from "../core/constants.js";
+import { runAnalysisPhase } from "./orchestrator-phases.js";
+import { estimateTokens, localCapacity, readLocalWindow } from "./context-margin.js";
+import { MAX_RELAYS, planRelay, relayLimitError, splitRelayFragments } from "./context-relay.js";
+import { buildRelayDigest, buildRelayUserText } from "./relay-digest.js";
+
+// Phase 1 avec relais de contexte : single-shot si la zone de confort suffit.
+/** @param {ProviderPrimary} primary @param {string} smartModel @param {string} userText @param {string} missionCtx @param {(args: CallLLMArgs) => Promise<string>} [llmCall] @param {{ prefix: string, rest: string } | null} [split] même requête, doctrine en tête (appel unique seulement : le découpage en relais garde le texte complet) @returns {Promise<string>} */
+export async function runAnalysisRelayed(primary, smartModel, userText, missionCtx, llmCall = callLLM, split = null) {
+  const capacity = localCapacity(readLocalWindow());
+  const plan = planRelay(estimateTokens(userText), capacity);
+  if (!plan.relayRequired) return split ? runAnalysisPhase(primary, smartModel, split.rest, split.prefix) : runAnalysisPhase(primary, smartModel, userText, missionCtx);
+  const fragments = splitRelayFragments(userText, plan.fragmentTokens);
+  if (fragments.length - 1 > MAX_RELAYS) throw relayLimitError(fragments.length - 1, capacity, estimateTokens(userText));
+  /** @type {string[]} */ const findings = [];
+  try {
+    for (let i = 0; i < fragments.length; i++) {
+      const { digest } = buildRelayDigest(
+        { findings: [...findings], remaining: `${fragments.length - i - 1} fragment(s) encore à analyser après celui-ci`, mission: missionCtx },
+        capacity
+      );
+      findings.push(await llmCall({
+        provider: primary.provider, key: primary.key, model: smartModel, base: primary.base,
+        systemPrompt: withLanguage(analysisPrompt()), cachePrefix: missionCtx,
+        maxTokens: ANALYSIS_MAX_TOKENS, userText: buildRelayUserText(digest, fragments[i]),
+      }));
+    }
+    return findings.join("\n\n");
+  } catch (err) {
+    const e0 = /** @type {EnrichedError} */ (err);
+    const e = /** @type {EnrichedError} */ (new Error(`Échec Phase 1 relais (analyse, ${primary.provider}) : ${e0.message}`));
+    e.code = "phase1_failed"; e.provider = primary.provider;
+    throw e;
+  }
+}
+// MODULE_COMPLETE

package/src/engine/relay-digest.js

@@ -0,0 +1,42 @@
+// src/engine/relay-digest.js — Digest de passation entre 2 agents (PUR) :
+// (constats acquis, compactés) + (travail restant) + (mission/consignes).
+// Le digest DOIT tenir sous le seuil de confort (vérifié via estimateTokens) ;
+// débordement → troncature des constats les plus ANCIENS, signalée DANS le digest.
+import { estimateTokens } from "./context-margin.js";
+
+const DIGEST_RATIO = 0.4; // ≤ 40 % de la capacité : laisse la place au fragment suivant.
+
+// Construit le digest de passation ; tronque les constats anciens si trop gros.
+/** @param {{ findings: string[], remaining: string, mission: string }} pass
+ *  @param {number} capacityTokens @returns {{ digest: string, truncated: number }} */
+export function buildRelayDigest({ findings, remaining, mission }, capacityTokens) {
+  const cap = Math.max(1, Math.floor(Number(capacityTokens) || 0));
+  const maxTokens = Math.floor(cap * DIGEST_RATIO);
+  const list = (Array.isArray(findings) ? findings : []).map((f) => String(f ?? "")).filter(Boolean);
+  let dropped = 0;
+  const head = () => `${dropped ? `[Relais : ${dropped} constat(s) antérieur(s) tronqué(s) pour tenir dans la zone de confort]\n` : ""}MISSION (consignes inchangées) :\n${mission || "—"}`;
+  const tail = `TRAVAIL RESTANT :\n${remaining || "—"}`;
+  const render = () => [
+    head(),
+    `CONSTATS ACQUIS (agents précédents) :\n${list.length ? list.join("\n---\n") : "(aucun pour l'instant)"}`,
+    tail,
+  ].join("\n\n");
+  let digest = render();
+  while (estimateTokens(digest) > maxTokens && list.length > 1) { list.shift(); dropped += 1; digest = render(); }
+  if (estimateTokens(digest) > maxTokens && list.length === 1) {
+    const original = list[0];
+    list[0] = ""; // Digest à en-têtes seuls = budget exact restant pour le constat.
+    const headers = estimateTokens(render());
+    const room = Math.max(0, (maxTokens - headers) * 4 - 20);
+    list[0] = `[constat tronqué] ${original.slice(0, room)}`;
+    dropped += 1; digest = render();
+  }
+  return { digest, truncated: dropped };
+}
+
+// UserText du nouvel agent : digest de passation + fragment à analyser.
+/** @param {string} digest @param {string} fragment @returns {string} */
+export function buildRelayUserText(digest, fragment) {
+  return `${digest || ""}\n\n=== RELAI DE CONTEXTE — tu prends la suite des agents précédents, poursuis sans répéter ===\n\n${fragment}`;
+}
+// MODULE_COMPLETE

package/src/engine/route-llm.js

@@ -0,0 +1,25 @@
+// src/engine/route-llm.js — Routage hybride PUR : l'agent local (Ollama /
+// openai-compatible localhost) reste SOUVERAIN et prioritaire (gratuit, privé).
+// Bascule vers le cloud BYOK strictement conditionnelle : (a) le local ne gère
+// pas le multi-agent, (b) le contexte dépasse la marge de respiration locale,
+// (c) sous-tâche lourde nécessitant un traitement déporté (accélérer, décharger).
+
+// Base locale ? (localhost, IP privées). Sinon : cloud.
+/** @param {string | null | undefined} base @returns {boolean} */
+export function isLocalBase(base) {
+  const s = String(base || "").toLowerCase();
+  return /localhost|127\.0\.0\.1|\[::1\]|192\.168\.|(^|\.)10\.|172\.(1[6-9]|2\d|3[01])\./i.test(s);
+}
+
+// Décision de routage. Retourne { route, reason } — "none" si aucun provider.
+// Ordre strict des conditions utilisateur : (a) → (b) → (c) → local souverain.
+/** @param {RouteArgs} a @returns {RouteDecision} */
+export function decideRoute({ local, secondary, promptTokens, capacityTokens, localMultiAgent, heavyTokens }) {
+  if (!local) return { route: secondary ? "cloud" : "none", reason: secondary ? "no_local" : "no_provider" };
+  if (!secondary) return { route: "local", reason: "local_only" };
+  if (localMultiAgent === false) return { route: "cloud", reason: "local_cant_multi_agent" }; // (a)
+  if (Number(promptTokens) > Number(capacityTokens)) return { route: "cloud", reason: "context_overflow" }; // (b)
+  if (Number(promptTokens) >= Number(heavyTokens)) return { route: "cloud", reason: "heavy_subtask" }; // (c)
+  return { route: "local", reason: "local_sovereign" };
+}
+// MODULE_COMPLETE

package/src/engine/rule-text.js

@@ -0,0 +1,12 @@
+// src/engine/rule-text.js — Rendu des textes de règles SERVIS par le serveur : gabarit à variables {nom} et
+// choix par langage. Aucun texte de règle ici : seulement la mécanique de substitution.
+
+/** @param {string} template @param {Record<string, string>} vars @returns {string} */
+export const fmt = (template, vars) => template.replace(/\{(\w+)\}/g, (_, k) => vars[k] ?? "");
+
+/** @param {RuleMsg} m @param {boolean} isPy @returns {string} */
+export const pick = (m, isPy) => (typeof m === "string" ? m : isPy ? m.py : m.js);
+
+/** Violation « ast » à partir d'un message serveur. @param {ScanMsg} m @param {boolean} isPy @param {Record<string, string>} vars @param {string} matched @returns {Violation} */
+export const astViolation = (m, isPy, vars, matched) => ({ kind: "ast", rule: fmt(pick(m.rule, isPy), vars), alternative: fmt(pick(m.alt, isPy), vars), matched: matched.slice(0, 60) });
+// MODULE_COMPLETE

package/src/engine/self-assessment.js

@@ -0,0 +1,33 @@
+// src/engine/self-assessment.js — Autobilan du Modèle 1 (rédacteur) sur SON travail : ce qu'il n'a pas pu traiter (contexte trop court,
+// précision insuffisante, parties incertaines). Un seul petit appel, uniquement quand un superviseur existe. Déclaratif : le Modèle 2 le
+// reçoit comme une indication à VÉRIFIER, jamais comme une preuve. Échec → "unavailable" (le contrôle continue sans).
+import { callLLM } from "../core/llm-call.js";
+
+const SYSTEM = [
+  "Tu viens de rédiger le patch ci-dessous. Fais ton autobilan HONNÊTE sur ton propre travail, en 8 lignes maximum, sans recopier le patch.",
+  "Première ligne EXACTEMENT « DOUTES: AUCUN » ou « DOUTES: OUI ».",
+  "Si OUI, indique ce qui est incertain ou n'a pas pu être traité correctement : fichiers concernés, contexte trop long ou tronqué, précision insuffisante, tests non écrits, hypothèses faites.",
+].join("\n");
+export const BILAN_MAX_CHARS = 1500;
+const BILAN_MAX_TOKENS = 400;
+
+/** @param {string} raw @returns {SelfAssessment} */
+export function parseSelfAssessment(raw) {
+  const text = String(raw ?? "").trim().slice(0, BILAN_MAX_CHARS);
+  if (!text) return { state: "unavailable", text: "" };
+  return { state: /^DOUTES:\s*AUCUN\b/i.test(text) ? "none" : "doubts", text }; // format inattendu = doute (le plus prudent)
+}
+
+/** @param {{ writer: ProviderPrimary, analysis: string, patch: string, missionContext?: string, llmCall?: (a: CallLLMArgs) => Promise<string> }} v @returns {Promise<SelfAssessment>} */
+export async function runSelfAssessment({ writer, analysis, patch, missionContext, llmCall = callLLM }) {
+  try {
+    const raw = await llmCall({
+      provider: writer.provider, key: writer.key, model: writer.model, base: writer.base, systemPrompt: SYSTEM,
+      cachePrefix: (missionContext || "").trim(), maxTokens: BILAN_MAX_TOKENS, userText: `Diagnostic:\n${analysis}\n\nPatch rédigé:\n${patch}`,
+    });
+    return parseSelfAssessment(raw);
+  } catch {
+    return { state: "unavailable", text: "" }; // autobilan impossible : le contrôle par points clés continue seul
+  }
+}
+// MODULE_COMPLETE

package/src/engine/steps-block.js

@@ -0,0 +1,19 @@
+// src/engine/steps-block.js — Raisonnement du modèle (<think>…</think>, ou <thinking>) séparé de la réponse et présenté en bloc REPLIABLE
+// (:::steps … ::: — rendu fermé par défaut par le chat). Les balises de dialogue ne sont jamais cherchées dans le raisonnement.
+// Un raisonnement coupé (balise non fermée) est conservé comme tel. Pur.
+
+const THINK = /<(think|thinking)>([\s\S]*?)(<\/\1>|$)/gi;
+
+/** Réponse brute → { thinking, answer } (raisonnements réunis, réponse sans eux). @param {string} raw @returns {{ thinking: string, answer: string }} */
+export function splitThinking(raw) {
+  /** @type {string[]} */ const parts = [];
+  const answer = String(raw).replace(THINK, (_m, _tag, inner) => { if (String(inner).trim()) parts.push(String(inner).trim()); return ""; });
+  return { thinking: parts.join("\n\n"), answer: answer.trim() };
+}
+
+/** Bloc repliable ("" si rien) ; une ligne « ::: » du raisonnement est neutralisée (elle fermerait le bloc). @param {string} thinking @returns {string} */
+export function stepsBlock(thinking) {
+  const body = thinking.trim().replace(/^:::$/gm, " :::");
+  return body ? `:::steps\n${body}\n:::\n\n` : "";
+}
+// MODULE_COMPLETE

package/src/engine/ux-violations-leak.js

@@ -0,0 +1,43 @@
+// src/engine/ux-violations-leak.js — RÈGLE "ZERO_DATA_LEAK" (sécurité absolue) :
+// aucune donnée sensible ne doit jamais s'afficher dans l'UI (interface, toast,
+// log front) : chemins locaux absolus, adresses IP de l'utilisateur, clés
+// API/licence en clair → patch UI bloqué. Fusion non négociable sur TOUS les
+// domaines via ensureDataLeakGuard (deterministe, LLM, re-parse markdown).
+
+/** @type {DesignViolation[]} */
+export const DATA_LEAK_VIOLATIONS = [
+  {
+    rule: "ZERO_DATA_LEAK — chemin local absolu exposé dans l'UI (interface/toast) : interdit.",
+    patterns: ["[A-Za-z]:[\\\\/]+Users", "/home/[A-Za-z0-9._-]+/", "/Users/"],
+  },
+  {
+    rule: "ZERO_DATA_LEAK — adresse IP (privée ou publique) exposée dans l'UI : interdite.",
+    patterns: ["\\b\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\b"],
+  },
+  {
+    rule: "ZERO_DATA_LEAK — clé API ou licence en clair exposée dans l'UI : interdite.",
+    patterns: [
+      "sk-ant-[A-Za-z0-9-]{8,}", "sk-[A-Za-z0-9]{16,}", "AIza[A-Za-z0-9_-]{10,}",
+      "ghp_[A-Za-z0-9]{20,}", "PLUGCTO-[A-Za-z0-9-]{8,}", "Bearer\\s+[A-Za-z0-9._-]{16,}",
+    ],
+  },
+];
+
+// Fusionne les violations ZERO_DATA_LEAK (non négociables, tous domaines) dans
+// une liste existante, dédoublonnée par règle. Backfille aussi les patterns
+// d'une règle relue sans ses regex (ex. re-parse markdown). Ne mute jamais
+// l'entrée : chaque élément est recopié.
+/** @param {DesignViolation[]} violations @returns {DesignViolation[]} */
+export function ensureDataLeakGuard(violations) {
+  const out = violations.map((v) => ({ rule: v.rule, patterns: [...(v.patterns || [])] }));
+  for (const d of DATA_LEAK_VIOLATIONS) {
+    const ex = out.find((v) => v.rule === d.rule);
+    if (ex) {
+      if (!ex.patterns.length) ex.patterns = [...d.patterns];
+    } else {
+      out.push({ rule: d.rule, patterns: [...d.patterns] });
+    }
+  }
+  return out;
+}
+// MODULE_COMPLETE