pipcode 0.0.0-stage → 2.1.1

package/src/engine/json-balance.js

@@ -0,0 +1,37 @@
+// src/engine/json-balance.js — Récupération d'un JSON TRONQUÉ (flux coupé par la limite de sortie) par équilibrage de pile.
+// 1) coupure juste après une valeur complète : on ferme les délimiteurs ouverts (] }) ; 2) coupure en pleine valeur : on revient au dernier
+// séparateur du niveau le plus haut et on ABANDONNE l'élément incomplet (jamais de guillemet refermé sur un texte coupé : une tâche au titre
+// tronqué serait fausse sans que personne le voie). La valeur rendue porte la marque TRUNCATED pour que l'appelant prévienne l'utilisateur.
+
+export const TRUNCATED = Symbol.for("vcto.json.truncated");
+
+/** @param {string} stack @returns {string} fermetures dans l'ordre inverse */
+const closers = (stack) => [...stack].reverse().map((c) => (c === "{" ? "}" : "]")).join("");
+
+/** @param {unknown} v @returns {unknown} */
+function mark(v) { if (v && typeof v === "object") Object.defineProperty(v, TRUNCATED, { value: true }); return v; }
+
+/** @param {string} s texte commençant par { ou [ @returns {unknown} valeur récupérée (marquée) ou null si rien d'exploitable */
+export function recoverTruncated(s) {
+  let stack = ""; let inStr = false; let esc = false;
+  /** @type {{ at: number, stack: string }[]} */ const commas = [];
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (inStr) { if (esc) esc = false; else if (c === "\\") esc = true; else if (c === '"') inStr = false; continue; }
+    if (c === '"') inStr = true;
+    else if (c === "{" || c === "[") stack += c;
+    else if (c === "}" || c === "]") stack = stack.slice(0, -1);
+    else if (c === ",") commas.push({ at: i, stack });
+  }
+  /** @type {string[]} */ const tries = [];
+  const trimmed = s.replace(/[\s,]+$/, "");
+  if (!inStr && /[}\]"]$/.test(trimmed)) tries.push(trimmed + closers(stack));
+  if (commas.length > 0) {
+    const top = Math.min(...commas.map((c) => c.stack.length));
+    const cut = /** @type {{ at: number, stack: string }} */ (commas.filter((c) => c.stack.length === top).at(-1));
+    tries.push(s.slice(0, cut.at) + closers(cut.stack));
+  }
+  for (const t of tries) { try { return mark(JSON.parse(t)); } catch { /* essai suivant */ } }
+  return null;
+}
+// MODULE_COMPLETE

package/src/engine/json-safe.js

@@ -0,0 +1,13 @@
+// src/engine/json-safe.js — Lecture JSON défensive : toute donnée de fichier est non fiable, rien n'est supposé (objet ou tableau vide plutôt qu'une exception).
+
+/** @param {unknown} v @returns {Record<string, unknown>} */
+export const asObj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? /** @type {Record<string, unknown>} */ (v) : {});
+
+/** @param {unknown} v @returns {unknown[]} */
+export const asArr = (v) => (Array.isArray(v) ? v : []);
+
+/** @param {string} text @returns {Record<string, unknown>} objet JSON ({} si illisible ou si ce n'est pas un objet) */
+export function jsonObject(text) {
+  try { return asObj(JSON.parse(text)); } catch { return {}; } // fichier corrompu : traité comme vide
+}
+// MODULE_COMPLETE

package/src/engine/line-numbers.js

@@ -0,0 +1,16 @@
+// src/engine/line-numbers.js — Lignes d'un texte : décompte exact (un saut de ligne final ne crée pas de ligne en plus) et numérotation « 042│ code » pour que le modèle cite les lignes
+// d'après des numéros fournis, jamais comptés de tête.
+
+/** @param {string} text @returns {string[]} lignes sans la ligne vide fantôme d'un saut de ligne final */
+const linesOf = (text) => { const l = text.split("\n"); if (l.length > 1 && l[l.length - 1] === "") l.pop(); return l; };
+
+/** @param {string} text @returns {number} nombre de lignes (0 pour un texte vide) */
+export const countLines = (text) => (text === "" ? 0 : linesOf(text).length);
+
+/** @param {string} text @returns {string} le texte avec le numéro de chaque ligne en tête, aligné */
+export function numberLines(text) {
+  const lines = linesOf(text);
+  const w = String(lines.length).length;
+  return lines.map((l, i) => `${String(i + 1).padStart(w, "0")}│ ${l}`).join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/md-build-mid.js

@@ -0,0 +1,35 @@
+// src/engine/md-build-mid.js — Builders markdown sections 5-7 (UX, design, glossaire).
+/** @param {string[]} uxDirectives @param {DesignSystem} designSystem @returns {string[]} */
+export function mdSection5(uxDirectives, designSystem) {
+  const L = ["## 5. DIRECTIVES UX & ERGONOMIE MÉTIER"];
+  for (const r of (uxDirectives || [])) { L.push(`- ${r}`); }
+  L.push(`> Accessibilité : ${(designSystem && designSystem.wcag) || "WCAG 2.1 AA"} — focus visible, couleur jamais seule, ≥ 16px.`);
+  L.push("");
+  return L;
+}
+
+// Section 6 — Charte visuelle & Design System contextuel.
+/** @param {DesignSystem} designSystem @returns {string[]} */
+export function mdSection6(designSystem) {
+  const ds = designSystem || {};
+  const L = ["## 6. CHARTE VISUELLE & DESIGN SYSTEM CONTEXTUEL"];
+  L.push(`- Famille : ${ds.family || "—"}`);
+  L.push(`- Style : ${ds.style || "—"}`);
+  L.push(`- Densité : ${ds.density || "—"}`);
+  L.push(`- Palette : ${ds.palette || "—"}`);
+  L.push(`- Micro-interactions : ${ds.microInteractions || "—"}`);
+  L.push(`- Accessibilité : ${ds.wcag || "WCAG 2.1 AA"}`);
+  for (const v of (ds.violations || [])) { L.push(`- ❌ HORS CHARTE : ${v.rule}`); }
+  L.push("");
+  return L;
+}
+
+// Section 7 — Glossaire & lexique métier.
+/** @param {GlossaryEntry[]} glossary @returns {string[]} */
+export function mdSection7(glossary) {
+  const L = ["## 7. GLOSSAIRE & LEXIQUE MÉTIER"];
+  for (const g of (glossary || [])) { L.push(`- \`${g.term}\` : ${g.definition}`); }
+  L.push("");
+  return L;
+}
+// MODULE_COMPLETE

package/src/engine/md-build-top.js

@@ -0,0 +1,58 @@
+// src/engine/md-build-top.js — Builders markdown sections 1-4 + en-tete.
+/** @param {MissionPlan} plan @returns {string[]} */
+export function mdHeader(plan) {
+  const now = new Date().toISOString();
+  const { projectName, need, autoMode, createdAt, validatedAt, iterations } = plan;
+  return [
+    `# MISSION SCRATCHPAD — ${projectName || "Projet"}`,
+    `> Mode Autonome : ${autoMode ? "ACTIF" : "INACTIF"} | Validé par l'utilisateur le ${validatedAt ? validatedAt.slice(0, 10) : "—"}`,
+    `> Besoin : ${need || "_(non renseigné)_"}`,
+    `> Créé le ${createdAt ? createdAt.slice(0, 10) : now.slice(0, 10)} — Itérations : ${iterations || 0}`,
+    "",
+  ];
+}
+
+// Section 1 — Personas & garde-fous.
+/** @param {{ role_name: string, scope: string, mandate: string }[]} personas @returns {string[]} */
+export function mdSection1(personas) {
+  const L = ["## 1. PERSONAS MÉTIERS & GARDE-FOUS"];
+  for (const p of (personas || [])) {
+    L.push(`- **${p.role_name}** : ${p.mandate}`);
+    if (p.scope) L.push(`  - _Périmètre_ : ${p.scope}`);
+  }
+  L.push("");
+  return L;
+}
+
+// Section 2 — Norme & invariants réglementaires (NON NEGO).
+/** @param {DomainConstraint[]} constraints @returns {string[]} */
+export function mdSection2(constraints) {
+  const L = ["## 2. NORME & INVARIANTS RÉGLEMENTAIRES (NON NEGO)"];
+  for (const c of (constraints || [])) {
+    L.push(`- [ ] ${c.text}${c.invariant ? ` — Invariant : ${c.invariant}` : ""}`);
+  }
+  L.push("");
+  return L;
+}
+
+// Section 3 — Failles métiers à bloquer.
+/** @param {DomainPitfall[]} pitfalls @returns {string[]} */
+export function mdSection3(pitfalls) {
+  const L = ["## 3. FAILLES MÉTIERS À BLOQUER"];
+  for (const f of (pitfalls || [])) {
+    L.push(`- ❌ NE JAMAIS : ${f.never}`);
+    L.push(`  ✅ TOUJOURS : ${f.always}`);
+  }
+  L.push("");
+  return L;
+}
+
+// Section 4 — Checklist d'exécution technique (cochée par ultra_orchestrate).
+/** @param {string[]} steps @param {boolean[]} checked @returns {string[]} */
+export function mdSection4(steps, checked) {
+  const L = ["## 4. CHECKLIST D'EXÉCUTION TECHNIQUE"];
+  steps.forEach((s, i) => { L.push(`- [${checked[i] ? "x" : " "}] ${s}`); });
+  L.push("");
+  return L;
+}
+// MODULE_COMPLETE

package/src/engine/md-build.js

@@ -0,0 +1,36 @@
+// src/engine/md-build.js — Sections 8-9 + orchestrateur buildMissionMarkdown.
+import { mdHeader, mdSection1, mdSection2, mdSection3, mdSection4 } from "./md-build-top.js";
+import { mdSection5, mdSection6, mdSection7 } from "./md-build-mid.js";
+
+// Section 8 — Estimation & impact.
+/** @param {{ files: string[], tokens: number, risk: string }} impact @param {string[]} steps @param {string[]} [fiches] @returns {string[]} */
+export function mdSection8(impact, steps, fiches) {
+  const L = ["## 8. ESTIMATION & IMPACT"];
+  L.push(`- Fichiers prévus : ${(impact.files || []).join(", ") || "—"}`);
+  L.push(`- Étapes de livraison : ${steps.length}`);
+  L.push(`- Coût approximatif en tokens : ~${impact.tokens}`);
+  L.push(`- Niveau de risque métier : ${impact.risk}`);
+  L.push(`- Fiches de doctrine à charger : ${(fiches || []).join(", ") || "—"}`);
+  L.push("");
+  return L;
+}
+
+// Section 9 — Log d'itérations.
+/** @returns {string[]} */
+export function mdSection9() {
+  return ["## 9. LOG D'ITÉRATIONS ultra_orchestrate", "<!-- Une ligne par appel ultra_orchestrate (horodaté) ; checklist §4 cochée progressivement -->", ""];
+}
+
+// Génère le markdown du scratchpad mission.md selon le template strict.
+/** @param {MissionPlan} plan @returns {string} */
+export function buildMissionMarkdown(plan) {
+  const { personas, constraints, pitfalls, glossary, impact, uxDirectives, designSystem, fiches } = plan;
+  const steps = impact.steps || [];
+  const checked = Array.isArray(plan.checkedSteps) && plan.checkedSteps.length === steps.length ? plan.checkedSteps : steps.map(() => false);
+  return [
+    ...mdHeader(plan), ...mdSection1(personas), ...mdSection2(constraints), ...mdSection3(pitfalls),
+    ...mdSection4(steps, checked), ...mdSection5(uxDirectives, designSystem), ...mdSection6(designSystem),
+    ...mdSection7(glossary), ...mdSection8(impact, steps, fiches), ...mdSection9(),
+  ].join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/md-parse-helpers.js

@@ -0,0 +1,7 @@
+// src/engine/md-parse-helpers.js — Helper d'extraction de bloc markdown (section).
+/** @param {string} raw @param {string} re @returns {string} */
+export const blockOf = (raw, re) => {
+  const m = [...raw.matchAll(new RegExp(re, "g"))][0];
+  return m ? m[1] : "";
+};
+// MODULE_COMPLETE

package/src/engine/md-parse-pillars.js

@@ -0,0 +1,38 @@
+// src/engine/md-parse-pillars.js — Parse markdown : personas/contraintes/failles/glossaire.
+import { blockOf } from "./md-parse-helpers.js";
+
+/** @param {string} raw @returns {{ role_name: string, mandate: string, scope: string }[]} */
+export function parsePersonas(raw) {
+  return blockOf(raw, "## 1\\. PERSONAS MÉTIERS & GARDE-FOUS\\s*\\n([\\s\\S]*?)(?:\\n## )")
+    .split("\n").map((l) => l.match(/^- \*\*(.+?)\*\*\s*:\s*(.+?)$/))
+    .filter((m) => m !== null)
+    .map((m) => ({ role_name: m[1].trim(), mandate: m[2].trim(), scope: "" }));
+}
+
+/** @param {string} raw @returns {DomainConstraint[]} */
+export function parseConstraints(raw) {
+  return blockOf(raw, "## 2\\. NORME & INVARIANTS RÉGLEMENTAIRES \\(NON NEGO\\)\\s*\\n([\\s\\S]*?)(?:\\n## )")
+    .split("\n").map((l) => l.match(/^- \[[ x]\] (.+?)(?:\s*— Invariant : (.+))?$/))
+    .filter((m) => m !== null)
+    .map((m) => ({ text: m[1].trim(), invariant: (m[2] || "").trim(), patterns: [] }));
+}
+
+/** @param {string} raw @returns {DomainPitfall[]} */
+export function parsePitfalls(raw) {
+  const pitfalls = blockOf(raw, "## 3\\. FAILLES MÉTIERS À BLOQUER\\s*\\n([\\s\\S]*?)(?:\\n## )")
+    .split("\n").map((l) => l.match(/^- ❌ NE JAMAIS : (.+?)$/))
+    .filter((m) => m !== null)
+    .map((m) => ({ never: m[1].trim(), always: "", patterns: [] }));
+  const alwaysLines = [...raw.matchAll(/✅ TOUJOURS : (.+?)$/gm)].map((m) => m[1].trim());
+  pitfalls.forEach((p, i) => { if (alwaysLines[i]) p.always = alwaysLines[i]; });
+  return pitfalls;
+}
+
+/** @param {string} raw @returns {GlossaryEntry[]} */
+export function parseGlossary(raw) {
+  return blockOf(raw, "## 7\\. GLOSSAIRE & LEXIQUE MÉTIER\\s*\\n([\\s\\S]*?)(?:\\n## )")
+    .split("\n").map((l) => l.match(/^- `(.*?)` : (.+?)$/))
+    .filter((m) => m !== null)
+    .map((m) => ({ term: m[1].trim(), definition: m[2].trim() }));
+}
+// MODULE_COMPLETE

package/src/engine/md-parse-ux-design.js

@@ -0,0 +1,31 @@
+// src/engine/md-parse-ux-design.js — Parse markdown : directives UX + design system.
+import { blockOf } from "./md-parse-helpers.js";
+import { ensureDataLeakGuard } from "./ux-violations-leak.js";
+
+// Section 5 — Directives UX (tolérant : lignes `- …` hors blockquote, hors ❌).
+/** @param {string} raw @returns {string[]} */
+export function parseUxDirectives(raw) {
+  return blockOf(raw, "## 5\\. DIRECTIVES UX & ERGONOMIE MÉTIER\\s*\\n([\\s\\S]*?)(?:\\n## )")
+    .split("\n").map((l) => l.match(/^- (.+?)$/))
+    .filter((m) => m !== null)
+    .map((m) => m[1].trim())
+    .filter((s) => !s.startsWith("❌"));
+}
+
+// Section 6 — Charte visuelle & Design System.
+/** @param {string} raw @returns {{ family: string, style: string, density: string, palette: string, microInteractions: string, wcag: string, violations: DesignViolation[] }} */
+export function parseDesignSystem(raw) {
+  const dsBlock = blockOf(raw, "## 6\\. CHARTE VISUELLE & DESIGN SYSTEM CONTEXTUEL\\s*\\n([\\s\\S]*?)(?:\\n## )");
+  /** @param {string} label @returns {string} */
+  const dsLine = (label) => {
+    const m = dsBlock.match(new RegExp(`- ${label}\\s*:\\s*(.+?)$`, "m"));
+    return m ? m[1].trim() : "";
+  };
+  const violations = [...dsBlock.matchAll(/^- ❌ HORS CHARTE : (.+?)$/gm)].map((m) => ({ rule: m[1].trim(), patterns: [] }));
+  return {
+    family: dsLine("Famille"), style: dsLine("Style"), density: dsLine("Densité"),
+    palette: dsLine("Palette"), microInteractions: dsLine("Micro-interactions"),
+    wcag: dsLine("Accessibilité") || "WCAG 2.1 AA", violations: ensureDataLeakGuard(violations),
+  };
+}
+// MODULE_COMPLETE

package/src/engine/md-parse.js

@@ -0,0 +1,33 @@
+// src/engine/md-parse.js — parseMissionMarkdown : header + steps/impact + assembly.
+import { parsePersonas, parseConstraints, parsePitfalls, parseGlossary } from "./md-parse-pillars.js";
+import { parseUxDirectives, parseDesignSystem } from "./md-parse-ux-design.js";
+
+// Parse un mission.md (template strict) → plan structuré. Tolérant (null si vide/corrompu).
+// Les `patterns` (détection de violations) ne sont pas dans le markdown : lus depuis
+// le sidecar JSON par readMissionContext. Ce parser couvre l'absence de sidecar.
+/** @param {string} raw @returns {MissionPlan | null} */
+export function parseMissionMarkdown(raw) {
+  if (!raw || !raw.trim()) return null;
+  const autoMode = /Mode Autonome\s*:\s*ACTIF/i.test(raw);
+  const projectName = (raw.match(/# MISSION SCRATCHPAD\s*[—-]\s*(.+?)\s*$/m) || [])[1] || "Projet";
+  const need = (raw.match(/Besoin\s*:\s*(.+?)\s*$/m) || [])[1] || "";
+  const steps = [...raw.matchAll(/^- \[([ x])\] (.+?)$/gm)]
+    .filter((m) => m[2].startsWith("Etape "))
+    .map((m) => ({ label: m[2].trim(), checked: m[1] === "x" }));
+  const risk = (raw.match(/Niveau de risque métier\s*:\s*(Élevé|Moyen|Bas)/) || [])[1] || "Moyen";
+  const tokens = parseInt((raw.match(/Coût approximatif en tokens\s*:\s*~?(\d+)/) || [])[1] || "0", 10);
+  return {
+    autoMode, projectName, need,
+    personas: parsePersonas(raw),
+    constraints: parseConstraints(raw),
+    pitfalls: parsePitfalls(raw),
+    glossary: parseGlossary(raw),
+    uxDirectives: parseUxDirectives(raw),
+    designSystem: parseDesignSystem(raw),
+    impact: { steps: steps.map((s) => s.label), tokens, risk, files: [] },
+    checkedSteps: steps.map((s) => s.checked),
+    patternsLoaded: false, // false → scanner inactif (sidecar requis pour les patterns)
+    raw,
+  };
+}
+// MODULE_COMPLETE

package/src/engine/mission-context-prefix.js

@@ -0,0 +1,30 @@
+// src/engine/mission-context-prefix.js — Préfixe de contexte métier injecté dans ultra_orchestrate (Phase 1 +
+// Phase 2). Les GABARITS (intitulés, formulations d'instruction) sont servis par le serveur (lot Pro) : ici
+// seulement l'assemblage. Retourne "" si pas de mission, ou si les gabarits sont absents (compte gratuit).
+import { getRules } from "../rules/rules-registry.js";
+import { fmt } from "./rule-text.js";
+
+/** @param {MissionPlan | null} m @returns {string} */
+export function missionContextPrefix(m) {
+  const t = getRules().prefix;
+  if (!m || !t) return "";
+  const L = [t.open];
+  /** @template T @param {string} title @param {T[] | undefined} items @param {(x: T) => string} line */
+  const section = (title, items, line) => { if (items && items.length) { L.push(title); for (const x of items) L.push(line(x)); } };
+  if (m.projectName) L.push(fmt(t.project, { v: m.projectName }));
+  if (m.need) L.push(fmt(t.need, { v: m.need }));
+  section(t.personas, m.personas, (p) => fmt(t.persona, { role: p.role_name, mandate: p.mandate }));
+  section(t.constraints, m.constraints, (c) => fmt(c.invariant ? t.constraintInv : t.constraint, { text: c.text, inv: c.invariant || "" }));
+  section(t.pitfalls, m.pitfalls, (f) => fmt(t.pitfall, { never: f.never, always: f.always }));
+  section(t.glossary, m.glossary, (g) => fmt(t.term, { term: g.term, def: g.definition }));
+  section(t.ux, m.uxDirectives, (r) => fmt(t.uxRule, { v: r }));
+  if (m.designSystem) {
+    const ds = m.designSystem;
+    L.push(fmt(t.design, { style: ds.style || "", family: ds.family || "", density: ds.density || "", wcag: ds.wcag || "WCAG 2.1 AA" }));
+    section(t.violations, ds.violations, (v) => fmt(t.violation, { v: v.rule }));
+  }
+  if (m.impact) L.push(fmt(t.impact, { risk: String(m.impact.risk), tokens: String(m.impact.tokens) }));
+  L.push(t.close, "");
+  return L.join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/mission-guard.js

@@ -0,0 +1,36 @@
+// src/engine/mission-guard.js — Garde-fou Phase 0 (Auto Mode) : bloque le patch
+// Unified Diff d'une itération ultra_orchestrate non conforme au scratchpad
+// mission (anti-patterns §3, invariants réglo §2, Design System §6 sur patches
+// UI). Un patch non conforme n'est JAMAIS délivré : on renvoie le diagnostic
+// conservé + le rapport de violations + l'alternative conforme (pas
+// d'auto-retry — l'utilisateur re-soumet un patch corrigé). Fonction PURE
+// exportée : capture la logique testable du garde-fou (le handler
+// ultra_orchestrate vit dans src/mcp/handle-engine.js, invoquable isolément en test).
+import { scanPatchForViolations } from "./patch-scan.js";
+
+// Retourne { blocked, violations, message } — message null si non bloqué
+// (le caller journalise alors l'itération).
+/** @param {OrchestratorResult | null} result @param {MissionPlan | null} mission @returns {{ blocked: boolean, violations: Violation[], message: string | null }} */
+export function checkMissionGuard(result, mission) {
+  if (!mission) return { blocked: false, violations: [], message: null };
+  const violations = scanPatchForViolations(result ? result.patch : "", mission);
+  if (violations.length === 0) return { blocked: false, violations: [], message: null };
+  /** @param {string} k @returns {string} */
+  const kindLabel = (k) =>
+    k === "constraint" ? "Invariant réglo"
+    : k === "design" ? "Hors charte Design"
+    : k === "ast" ? "Sécurité (AST)"
+    : "Anti-pattern";
+  const vLines = violations.map((v) =>
+    `  • [${kindLabel(v.kind)}] ${v.rule}\n` +
+    `    → Alternative conforme : ${v.alternative || "—"}`
+  ).join("\n");
+  const message =
+    `🚫 **Mission : patch bloqué par Phase 0** (${violations.length} violation(s)).\n` +
+    `Le patch viole une règle du scratchpad \`.pipcode/mission.md\` — il n'est pas délivré.\n\n` +
+    `### Diagnostic conservé\n${(result && result.analysis) || ""}\n\n` +
+    `### Violations détectées dans le Unified Diff\n${vLines}\n\n` +
+    `Corrigez le patch selon les alternatives ci-dessus, puis régénérez le patch.`;
+  return { blocked: true, violations, message };
+}
+// MODULE_COMPLETE

package/src/engine/mission-helpers.js

@@ -0,0 +1,23 @@
+// src/engine/mission-helpers.js — Utilitaires mission : niveau de risque + nom de projet.
+
+// Niveau de risque métier selon les domaines détectés.
+/** @param {string[]} domainKeys @returns {string} */
+export function riskLevel(domainKeys) {
+  const high = ["sante", "finance_bancaire", "juridique_conformite"];
+  const mid = ["ecommerce", "cloud_archi", "securite_appsec", "data_ml"];
+  if (domainKeys.some((k) => high.includes(k))) return "Élevé";
+  if (domainKeys.some((k) => mid.includes(k))) return "Moyen";
+  return "Bas";
+}
+
+// Déduit un nom de projet court depuis le besoin.
+/** @param {string} need @returns {string} */
+export function deriveProjectName(need) {
+  const t = String(need || "").trim();
+  if (!t) return "Projet";
+  const words = t.split(/\s+/).filter((w) => w.replace(/[.:;,()]+$/, "").length > 2).slice(0, 5);
+  const name = words.join(" ").replace(/[.:;,]+$/, "").trim();
+  if (!name) return "Projet";
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+// MODULE_COMPLETE

package/src/engine/mission-log.js

@@ -0,0 +1,56 @@
+// src/engine/mission-log.js — Journalise une itération ultra_orchestrate (best-effort).
+import fs from "node:fs/promises";
+
+// Ajoute une ligne au log §9 (après le header de section, ou en crée un nouveau).
+/** @param {string} raw @param {string} line @returns {string} */
+function appendIterationLine(raw, line) {
+  const m = raw.match(/(## 9\. LOG D'ITÉRATIONS ultra_orchestrate\s*\n(?:<!--.*?-->\s*\n)?)/s);
+  if (m) {
+    const idx = /** @type {number} */ (m.index);
+    return raw.slice(0, idx + m[1].length) + line + "\n" + raw.slice(idx + m[1].length);
+  }
+  return raw + "\n## 9. LOG D'ITÉRATIONS ultra_orchestrate\n" + line + "\n";
+}
+
+// Coche la prochaine case « Etape » non cochée de la checklist §4.
+/** @param {string} next @returns {string} */
+function tickNextStep(next) {
+  let ticked = false;
+  return next.replace(/^- \[ \] (Etape .+?)$/m, (full, label) => {
+    if (ticked) return full;
+    ticked = true;
+    return `- [x] ${label}`;
+  });
+}
+
+// Met à jour le sidecar JSON (checkedSteps + iterations) pour garder scanner et
+// markdown cohérents. Best-effort (échec non bloquant).
+/** @param {MissionPlan | null} plan @param {string} planPath @returns {Promise<void>} */
+async function updateSidecar(plan, planPath) {
+  if (!plan) return;
+  plan.iterations = (plan.iterations || 0) + 1;
+  const steps = (plan.impact && plan.impact.steps) || [];
+  if (Array.isArray(plan.checkedSteps) && plan.checkedSteps.length === steps.length) {
+    const idx = plan.checkedSteps.findIndex((c) => !c);
+    if (idx >= 0) plan.checkedSteps[idx] = true;
+  }
+  try { await fs.writeFile(planPath, JSON.stringify(plan, null, 2), { encoding: "utf8", mode: 0o600 }); } catch { /* best-effort : échec non bloquant */ }
+}
+
+// Journalise une itération : ligne au log §9, coche la prochaine case non cochée
+// de la checklist §4, incrémente le compteur. Best-effort (échec non bloquant).
+/** @param {string} missionPath @param {string} summary @returns {Promise<void>} */
+export async function logIteration(missionPath, summary) {
+  const planPath = missionPath + ".plan.json";
+  /** @type {MissionPlan | null} */ let plan = null;
+  try { plan = /** @type {MissionPlan} */ (JSON.parse(await fs.readFile(planPath, "utf8"))); } catch { /* plan absent/corrompu : plan reste null */ }
+  let raw;
+  try { raw = await fs.readFile(missionPath, "utf8"); } catch { return; }
+  const line = `- [${new Date().toISOString()}] ultra_orchestrate : ${summary}`;
+  let next = appendIterationLine(raw, line);
+  next = tickNextStep(next);
+  next = next.replace(/(Itérations\s*:\s*)(\d+)/, (_, p, n) => p + (parseInt(n, 10) + 1));
+  try { await fs.writeFile(missionPath, next, { encoding: "utf8", mode: 0o600 }); } catch { /* best-effort : échec non bloquant */ }
+  await updateSidecar(plan, planPath);
+}
+// MODULE_COMPLETE

package/src/engine/mission-paths.js

@@ -0,0 +1,7 @@
+// src/engine/mission-paths.js — Chemins du scratchpad mission.md + sidecar JSON (surchargeables via env).
+import path from "node:path";
+
+export const MISSION_PATH =
+  process.env.PLUGCTO_MISSION_PATH || path.join(process.cwd(), ".pipcode", "mission.md");
+export const MISSION_PLAN_PATH = MISSION_PATH + ".plan.json";
+// MODULE_COMPLETE

package/src/engine/mission-store.js

@@ -0,0 +1,51 @@
+// src/engine/mission-store.js — Persistance du scratchpad mission.md + sidecar JSON.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { MISSION_PATH } from "./mission-paths.js";
+import { parseMissionMarkdown } from "./md-parse.js";
+import { buildMissionMarkdown } from "./md-build.js";
+
+// Lit le contexte mission : priorise le sidecar JSON (porte les patterns), sinon
+// parse le markdown. Retourne null si absent.
+/** @param {string} [missionPath] @returns {Promise<MissionPlan | null>} */
+export async function readMissionContext(missionPath = MISSION_PATH) {
+  const planPath = missionPath + ".plan.json";
+  try {
+    const raw = await fs.readFile(planPath, "utf8");
+    const plan = /** @type {MissionPlan} */ (JSON.parse(raw));
+    plan.patternsLoaded = true;
+    return plan;
+  } catch {
+    // Pas de sidecar : on parse le markdown (sans patterns → scanner inactif).
+  }
+  try {
+    const raw = await fs.readFile(missionPath, "utf8");
+    return parseMissionMarkdown(raw);
+  } catch {
+    return null;
+  }
+}
+
+// Écriture atomique : temp + rename, repli sur écriture directe si rename échoue.
+/** @param {string} filePath @param {string} data @returns {Promise<void>} */
+async function writeFileAtomic(filePath, data) {
+  const tmp = filePath + ".tmp-" + process.pid;
+  await fs.writeFile(tmp, data, { encoding: "utf8", mode: 0o600 });
+  try {
+    await fs.rename(tmp, filePath);
+  } catch {
+    await fs.writeFile(filePath, data, { encoding: "utf8", mode: 0o600 });
+    await fs.rm(tmp, { force: true });
+  }
+}
+
+// Écrit le scratchpad mission.md (template strict, atomic, 0600) + sidecar JSON
+// du plan structuré (porte les patterns de détection, 0600).
+/** @param {MissionPlan} plan @param {string} [missionPath] @returns {Promise<void>} */
+export async function writeMission(plan, missionPath = MISSION_PATH) {
+  const dir = path.dirname(missionPath);
+  await fs.mkdir(dir, { recursive: true });
+  await writeFileAtomic(missionPath, buildMissionMarkdown(plan));
+  await writeFileAtomic(missionPath + ".plan.json", JSON.stringify(plan, null, 2));
+}
+// MODULE_COMPLETE

package/src/engine/normalize-extraction.js

@@ -0,0 +1,35 @@
+// src/engine/normalize-extraction.js — Normalise/valide la sortie JSON du LLM vers un MissionPlan.
+import { arr, str } from "./coerce.js";
+import { extractMissionDeterministic } from "./extract-deterministic.js";
+import { normalizePersonas, normalizeConstraints, normalizePitfalls, normalizeGlossary } from "./normalize-pillars.js";
+import { normalizeImpact, normalizeDesignSystem } from "./normalize-impact-design.js";
+
+// Tolérant : comble les clés manquantes avec l'extracteur déterministe, coerce les types.
+/** @param {unknown} raw @param {string} needText @returns {MissionPlan} */
+export function normalizeExtraction(raw, needText) {
+  const need = String(needText || "").trim();
+  const fallback = extractMissionDeterministic(need);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fallback;
+  const r = /** @type {Record<string, unknown>} */ (raw);
+  const projectName = str(r.project_name) || fallback.projectName;
+  const personas = normalizePersonas(r);
+  const constraints = normalizeConstraints(r);
+  const pitfalls = normalizePitfalls(r);
+  const glossary = normalizeGlossary(r);
+  const impact = normalizeImpact(r, fallback.impact);
+  const uxDirectives = arr(r.ux_directives).map(str).filter(Boolean);
+  const designSystem = normalizeDesignSystem(r, fallback.designSystem);
+  return {
+    projectName, need, domainKeys: fallback.domainKeys,
+    personas: personas.length ? personas : fallback.personas,
+    constraints: constraints.length ? constraints : fallback.constraints,
+    pitfalls: pitfalls.length ? pitfalls : fallback.pitfalls,
+    glossary: glossary.length ? glossary : fallback.glossary,
+    impact,
+    uxDirectives: uxDirectives.length ? uxDirectives : fallback.uxDirectives,
+    designSystem, fiches: fallback.fiches,
+    autoMode: false, createdAt: new Date().toISOString(), validatedAt: null,
+    iterations: 0, checkedSteps: impact.steps.map(() => false),
+  };
+}
+// MODULE_COMPLETE

package/src/engine/normalize-impact-design.js

@@ -0,0 +1,39 @@
+// src/engine/normalize-impact-design.js — Normalisation LLM : impact + design system.
+import { str, arr, obj } from "./coerce.js";
+import { sanitizePatternsLLM } from "./pattern-sanitize.js";
+import { ensureDataLeakGuard } from "./ux-violations-leak.js";
+
+// Normalise la section impact (files/steps/tokens/risk) avec fallback déterministe.
+/** @param {Record<string, unknown>} r @param {{ files: string[], steps: string[], tokens: number, risk: string }} fb @returns {{ files: string[], steps: string[], tokens: number, risk: string }} */
+export function normalizeImpact(r, fb) {
+  const rawImpact = (r.impact && typeof r.impact === "object" && !Array.isArray(r.impact)) ? /** @type {Record<string, unknown>} */ (r.impact) : /** @type {Record<string, unknown>} */ ({});
+  const risk = ["Élevé", "Moyen", "Bas"].includes(/** @type {string} */ (rawImpact.risk)) ? /** @type {string} */ (rawImpact.risk) : fb.risk;
+  const tokens = Number.isFinite(rawImpact.tokens) ? Math.max(0, Math.round(/** @type {number} */ (rawImpact.tokens))) : fb.tokens;
+  const steps = arr(rawImpact.steps).map(str).filter(Boolean);
+  const files = arr(rawImpact.files).map(str).filter(Boolean);
+  return { files: files.length ? files : fb.files, steps: steps.length ? steps : fb.steps, tokens, risk };
+}
+
+// Normalise le design system ; violations de charte non négociables (fallback si omises).
+/** @param {Record<string, unknown>} r @param {{ family: string, style: string, density: string, palette: string, microInteractions: string, wcag: string, violations: DesignViolation[] }} fbDs @returns {{ family: string, style: string, density: string, palette: string, microInteractions: string, wcag: string, violations: DesignViolation[] }} */
+export function normalizeDesignSystem(r, fbDs) {
+  const rawDs = (r.design_system && typeof r.design_system === "object" && !Array.isArray(r.design_system)) ? /** @type {Record<string, unknown>} */ (r.design_system) : null;
+  if (!rawDs) return fbDs;
+  const designSystem = {
+    family: str(rawDs.family) || fbDs.family || "A",
+    style: str(rawDs.style) || fbDs.style || "",
+    density: str(rawDs.density) || fbDs.density || "",
+    palette: str(rawDs.palette) || fbDs.palette || "",
+    microInteractions: str(rawDs.microInteractions) || fbDs.microInteractions || "",
+    wcag: str(rawDs.wcag) || "WCAG 2.1 AA",
+    violations: ensureDataLeakGuard(arr(rawDs.violations).filter((v) => v && typeof v === "object").map((v) => {
+      const o = obj(v);
+      return { rule: str(o.rule), patterns: sanitizePatternsLLM(o.patterns) };
+    }).filter((v) => v.rule)),
+  };
+  if ((!designSystem.violations || designSystem.violations.length === 0) && fbDs.violations) {
+    designSystem.violations = fbDs.violations.map((v) => ({ rule: v.rule, patterns: [...(v.patterns || [])] }));
+  }
+  return designSystem;
+}
+// MODULE_COMPLETE

package/src/engine/normalize-pillars.js

@@ -0,0 +1,36 @@
+// src/engine/normalize-pillars.js — Normalisation des piliers LLM : personas/contraintes/failles/glossaire.
+import { str, arr, obj } from "./coerce.js";
+import { sanitizePatternsLLM } from "./pattern-sanitize.js";
+
+/** @param {Record<string, unknown>} r @returns {{ role_name: string, scope: string, mandate: string }[]} */
+export function normalizePersonas(r) {
+  return arr(r.personas).filter((p) => p && typeof p === "object").map((p) => {
+    const o = obj(p);
+    return { role_name: str(o.role_name) || "Expert métier", scope: str(o.scope), mandate: str(o.mandate) };
+  });
+}
+
+/** @param {Record<string, unknown>} r @returns {DomainConstraint[]} */
+export function normalizeConstraints(r) {
+  return arr(r.constraints).filter((p) => p && typeof p === "object").map((p) => {
+    const o = obj(p);
+    return { text: str(o.text), invariant: str(o.invariant), patterns: sanitizePatternsLLM(o.patterns) };
+  });
+}
+
+/** @param {Record<string, unknown>} r @returns {DomainPitfall[]} */
+export function normalizePitfalls(r) {
+  return arr(r.pitfalls).filter((p) => p && typeof p === "object").map((p) => {
+    const o = obj(p);
+    return { never: str(o.never), always: str(o.always), patterns: sanitizePatternsLLM(o.patterns) };
+  });
+}
+
+/** @param {Record<string, unknown>} r @returns {GlossaryEntry[]} */
+export function normalizeGlossary(r) {
+  return arr(r.glossary).filter((p) => p && typeof p === "object").map((p) => {
+    const o = obj(p);
+    return { term: str(o.term), definition: str(o.definition) };
+  });
+}
+// MODULE_COMPLETE