pipcode 0.0.0-stage → 2.1.1

package/src/engine/domain-regex.js

@@ -0,0 +1,11 @@
+// src/engine/domain-regex.js — Helpers regex pour la détection de domaines métier.
+// Caractères « mot » : alphanumérique + accents FR (bornes lookahead/lookbehind
+// pour éviter les faux positifs de sous-chaîne : « ai » dans « utilitaire »).
+const WORD_CHARS = "a-z0-9àâäéèêëïîôöùûüçñ";
+/** @param {string} s @returns {string} */
+export const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** @param {string} kw @returns {RegExp} */
+export function keywordRegex(kw) {
+  return new RegExp(`(?<![${WORD_CHARS}])${escapeRe(kw)}(?![${WORD_CHARS}])`, "i");
+}
+// MODULE_COMPLETE

package/src/engine/exports.js

@@ -0,0 +1,35 @@
+// src/engine/exports.js — Surface publique du domaine engine (Phase 0, Auto
+// Mode, orchestration LLM, AST) : agrégation des re-exports consommés par les
+// tests via le hub index.js.
+export { orchestrateLLM } from "./orchestrator.js";
+export { defaultSteps } from "./default-steps.js";
+export { detectDomains, mapDomainsToSlugs } from "./detect-domains.js";
+export { analyzeUxDesign } from "./analyze-ux.js";
+export { analyzeNeed } from "./analyze-need.js";
+export { computeImpact } from "./compute-impact.js";
+export { riskLevel, deriveProjectName } from "./mission-helpers.js";
+export { sanitizePattern } from "./pattern-sanitize.js";
+export { extractMissionDeterministic } from "./extract-deterministic.js";
+export { normalizeExtraction } from "./normalize-extraction.js";
+export { parseJsonLoose } from "./parse-json-loose.js";
+export { extractMissionLLM, extractMission } from "./extract-llm.js";
+export { buildMissionMarkdown } from "./md-build.js";
+export { parseMissionMarkdown } from "./md-parse.js";
+export { scanPatchForViolations } from "./patch-scan.js";
+export { checkMissionGuard } from "./mission-guard.js";
+export { planMission } from "./plan-mission.js";
+export { formatPlanReply } from "./plan-reply.js";
+export { formatConsoleSummary } from "./plan-summary.js";
+export { readMissionContext, writeMission } from "./mission-store.js";
+export { logIteration } from "./mission-log.js";
+export { missionContextPrefix } from "./mission-context-prefix.js";
+export { loadAstRuntime, _resetAstRuntime } from "./ast-runtime.js";
+export { ensureDataLeakGuard, DATA_LEAK_VIOLATIONS } from "./ux-violations-leak.js";
+export { collectFrontendShellViolations, isFrontendFile } from "./patch-ui-guard.js";
+export { collectSecretTextViolations } from "./patch-secret-guard.js";
+export { collectGraphViolations } from "./ast-rules-graph.js";
+export { collectCheatViolations } from "./patch-scan-cheat.js";
+export { fileSections } from "./patch-file-sections.js";
+export { getRules, setRules, resetRules } from "../rules/rules-registry.js";
+export { ensureRules } from "../rules/rules-load.js";
+// MODULE_COMPLETE

package/src/engine/extract-deterministic.js

@@ -0,0 +1,33 @@
+// src/engine/extract-deterministic.js — Extracteur déterministe (hors-ligne, aucun LLM).
+import { analyzeNeed } from "./analyze-need.js";
+import { analyzeUxDesign } from "./analyze-ux.js";
+import { deriveProjectName } from "./mission-helpers.js";
+import { buildPersonas, buildConstraints } from "./det-builders-1.js";
+import { buildPitfalls, buildGlossary, buildImpact } from "./det-builders-2.js";
+
+// Produit un MissionPlan complet depuis le catalogue BUSINESS_DOMAINS + DOMAIN_PATTERNS/GLOSSARY.
+/** @param {string} needText @returns {MissionPlan} */
+export function extractMissionDeterministic(needText) {
+  const need = String(needText || "").trim();
+  const matrix = analyzeNeed(need);
+  const keys = matrix.domainKeys;
+  const projectName = deriveProjectName(need);
+  const personas = buildPersonas(matrix.domains);
+  const constraints = buildConstraints(matrix.domains, keys);
+  const pitfalls = buildPitfalls(matrix.domains, keys);
+  const glossary = buildGlossary(keys);
+  const impact = buildImpact(keys, matrix);
+  const { uxDirectives, designSystem } = analyzeUxDesign(keys);
+  return {
+    projectName, need, domainKeys: keys,
+    personas, constraints, pitfalls, glossary, impact,
+    uxDirectives, designSystem,
+    fiches: matrix.fiches,
+    autoMode: false,
+    createdAt: new Date().toISOString(),
+    validatedAt: null,
+    iterations: 0,
+    checkedSteps: impact.steps.map(() => false),
+  };
+}
+// MODULE_COMPLETE

package/src/engine/extract-llm.js

@@ -0,0 +1,48 @@
+// src/engine/extract-llm.js — Extracteurs LLM (BYOK) + unifié (LLM puis repli déterministe).
+import { callLLM } from "../core/llm-call.js";
+import { getRules } from "../rules/rules-registry.js";
+import { withLanguage } from "../core/lang.js";
+import { EXTRACTION_MAX_TOKENS } from "../core/constants.js";
+import { parseJsonLoose } from "./parse-json-loose.js";
+import { normalizeExtraction } from "./normalize-extraction.js";
+import { extractMissionDeterministic } from "./extract-deterministic.js";
+
+// Appelle le provider primaire, parse le JSON, normalise. Jette en cas d'échec.
+/** @param {string} needText @param {{ primary: ProviderPrimary } | null} pcfg @returns {Promise<MissionPlan>} */
+export async function extractMissionLLM(needText, pcfg) {
+  const primary = pcfg && pcfg.primary;
+  if (!primary) {
+    const e = /** @type {EnrichedError} */ (new Error("Aucun provider primaire configuré pour l'extraction LLM."));
+    e.code = "no_provider";
+    throw e;
+  }
+  const text = await callLLM({
+    provider: primary.provider, key: primary.key,
+    model: primary.model, base: primary.base,
+    systemPrompt: withLanguage(getRules().prompts.mission),
+    maxTokens: EXTRACTION_MAX_TOKENS,
+    userText: String(needText || "").trim(),
+  });
+  const raw = parseJsonLoose(text);
+  if (!raw) {
+    const e = /** @type {EnrichedError} */ (new Error("Le LLM n'a pas retourné un JSON exploitable."));
+    e.code = "bad_json";
+    throw e;
+  }
+  return normalizeExtraction(raw, needText);
+}
+
+// Extracteur unifié : LLM si clés BYOK, sinon déterministe. Échec LLM → repli silencieux.
+/** @param {string} needText @param {{ primary: ProviderPrimary } | null} [pcfg] @returns {Promise<MissionPlan>} */
+export async function extractMission(needText, pcfg) {
+  if (pcfg && pcfg.primary) {
+    try {
+      return await extractMissionLLM(needText, pcfg);
+    } catch (err) {
+      const e = /** @type {EnrichedError} */ (err);
+      console.error(`[virtual-cto] Extraction LLM Phase 0 échouée (${e.code || e.message}) — repli déterministe.`);
+    }
+  }
+  return extractMissionDeterministic(needText);
+}
+// MODULE_COMPLETE

package/src/engine/facts-binary.js

@@ -0,0 +1,12 @@
+// src/engine/facts-binary.js — Fichiers que PipCode ne peut PAS lire en texte (binaires) : signalés comme non analysés, jamais passés sous silence. Blueprints Unreal (.uasset/.umap) : logique visuelle impossible à auditer ; seul le C++ voisin l'est.
+const KINDS = /** @type {Array<[RegExp, string]>} */ ([
+  [/\.(uasset|umap)$/i, "Blueprints et assets Unreal (.uasset/.umap) — logique visuelle, impossible à auditer en texte ; seul le C++ du projet est audité"],
+  [/\.(exe|dll|so|dylib|class|jar|apk|aab|ipa)$/i, "binaires compilés (.exe, .dll, .jar, .class…) — leur contenu n'est pas auditable ; fournir les sources"],
+]);
+
+/** @param {string[]} files @returns {string} ligne prête à injecter ("" s'il n'y a aucun binaire de ces familles) */
+export function binaryFacts(files) {
+  const rows = KINDS.map(([re, label]) => ({ n: files.filter((f) => re.test(f)).length, label })).filter((r) => r.n > 0);
+  return rows.length ? `Non analysables (binaires, jamais lus) : ${rows.map((r) => `${r.n} ${r.label}`).join(" ; ")}` : "";
+}
+// MODULE_COMPLETE

package/src/engine/facts-embedded.js

@@ -0,0 +1,18 @@
+// src/engine/facts-embedded.js — Scripts JavaScript écrits DANS une page (balises <script> d'un .html, .vue, .svelte) : leur texte et la ligne où ils commencent, pour mesurer leurs fonctions comme celles d'un fichier .js.
+// Les scripts externes (src=…), les modèles et les données (JSON, gabarits) sont ignorés. Motifs seulement.
+const SCRIPT = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+
+/** @param {string} attrs @returns {boolean} script exécutable en JavaScript (sans type, « module », « javascript ») */
+const isJs = (attrs) => !/\bsrc\s*=/i.test(attrs) && (!/\btype\s*=/i.test(attrs) || /\btype\s*=\s*["']?(?:module|text\/javascript|application\/javascript)/i.test(attrs));
+
+/** @param {string} text @returns {Array<{ text: string, start: number }>} start = numéro de la première ligne du script (1 = première ligne du fichier) */
+export function embeddedScripts(text) {
+  const out = [];
+  for (const m of text.matchAll(SCRIPT)) {
+    if (!isJs(m[1])) continue;
+    const before = text.slice(0, (m.index ?? 0) + m[0].indexOf(">") + 1);
+    out.push({ text: m[2], start: before.split("\n").length });
+  }
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/facts-functions.js

@@ -0,0 +1,21 @@
+// src/engine/facts-functions.js — Fonctions d'un fichier et leur longueur, pour tous les langages de facts-lang.js. Estimation par motifs, jamais d'exécution ; langage absent de la table = aucune mesure.
+import { LANGS } from "./facts-lang.js";
+import { braceLength, endLength, indentLength } from "./facts-measure.js";
+
+/** @param {string} file @returns {boolean} la mesure des fonctions existe pour ce langage */
+export const isMeasured = (file) => LANGS.some(([re]) => re.test(file));
+
+/** @param {string} file @param {string} text @returns {Array<{ name: string, line: number, lines: number }>} */
+export function functionLengths(file, text) {
+  const lang = LANGS.find(([re]) => re.test(file))?.[1];
+  if (!lang) return [];
+  const lines = text.split("\n");
+  const measure = lang.kind === "indent" ? indentLength : lang.kind === "end" ? endLength : braceLength;
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const name = lang.find(lines[i]);
+    if (name) out.push({ name, line: i + 1, lines: measure(lines, i) });
+  }
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/facts-html.js

@@ -0,0 +1,22 @@
+// src/engine/facts-html.js — Comptes objectifs sur les pages HTML (attributs manquants, médias, scripts tiers, liens non chiffrés). Un indice chiffré par motif, jamais un rendu : le modèle en tire les conséquences.
+// Motifs seulement ; chaque compte vient d'une lecture de texte, jamais d'un rendu.
+const PAGE = /\.html?$/i;
+
+/** @param {Array<{ file: string, text: string }>} entries @returns {string} ligne prête à injecter ("" sans page HTML) */
+export function htmlFacts(entries) {
+  const pages = entries.filter((e) => PAGE.test(e.file));
+  if (pages.length === 0) return "";
+  const names = (/** @type {(t: string) => boolean} */ bad) => pages.filter((p) => bad(p.text)).map((p) => p.file);
+  const count = (/** @type {RegExp} */ re) => pages.reduce((n, p) => n + (p.text.match(re) ?? []).length, 0);
+  const noLang = names((t) => /<html\b/i.test(t) && !/<html\b[^>]*\blang\s*=/i.test(t));
+  const noTitle = names((t) => /<html\b/i.test(t) && !/<title\b[^>]*>\s*\S/i.test(t));
+  const noViewport = names((t) => /<html\b/i.test(t) && !/<meta\b[^>]*name\s*=\s*["']viewport/i.test(t));
+  const extScripts = pages.flatMap((p) => [...p.text.matchAll(/<script\b[^>]*\bsrc\s*=\s*["'](https?:\/\/[^"']+)["'][^>]*>/gi)]);
+  const noSri = extScripts.filter((m) => !/\bintegrity\s*=/i.test(m[0])).length;
+  const hosts = [...new Set(pages.flatMap((p) => [...p.text.matchAll(/<(?:link|script|img|iframe|source|video|audio)\b[^>]*\b(?:href|src)\s*=\s*["']https?:\/\/([^/"':?#]+)/gi)].map((m) => m[1].toLowerCase())))].sort();
+  const list = (/** @type {string[]} */ a) => (a.length ? `${a.length} (${a.slice(0, 4).join(", ")}${a.length > 4 ? ", …" : ""})` : "aucune");
+  return [`Pages HTML : ${pages.length} — sans attribut de langue : ${list(noLang)} ; sans titre : ${list(noTitle)} ; sans adaptation mobile (viewport) : ${list(noViewport)}`,
+    `- Images sans texte alternatif : ${count(/<img\b(?![^>]*\balt\s*=)[^>]*>/gi)} ; gestionnaires dans le balisage (onclick…) : ${count(/\son(?:click|load|error|submit|change|mouse\w+)\s*=/gi)} ; scripts externes : ${extScripts.length} dont ${noSri} sans signature d'intégrité ; ressources en clair http:// : ${count(/(?:src|href)\s*=\s*["']http:\/\//gi)}`,
+    `- Ressources de tiers chargées par la page (hôtes ; données visiteur transmises à ces tiers) : ${hosts.length ? hosts.join(", ") : "aucune"}`].join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/facts-inventory.js

@@ -0,0 +1,33 @@
+// src/engine/facts-inventory.js — Inventaire COMPLET des fichiers du projet (toutes extensions : html, css, txt, md, tout langage), pour qu'un audit ne déclare jamais « absent » un fichier qui existe.
+// Noms seulement : le contenu des fichiers sensibles (.env, clés) n'est jamais lu. Dossiers lourds exclus ; borné en profondeur et en nombre.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { SKIP_DIRS, isSecretPath } from "../auto/fs-list.js";
+
+export const MAX_FILES = 600;
+const MAX_DEPTH = 6;
+
+/** @param {string} root @param {string} rel @param {number} depth @param {string[]} out @returns {Promise<void>} */
+async function walk(root, rel, depth, out) {
+  const entries = await fs.readdir(path.join(root, rel), { withFileTypes: true }).catch(() => []);
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (out.length >= MAX_FILES) return;
+    const r = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory() && depth < MAX_DEPTH && !SKIP_DIRS.has(e.name)) await walk(root, r, depth + 1, out);
+    else if (e.isFile()) out.push(r);
+  }
+}
+
+/** @param {string} root @returns {Promise<string[]>} chemins relatifs « / » de tous les fichiers (sensibles compris : à ne jamais lire) */
+export async function walkFiles(root) {
+  /** @type {string[]} */ const out = [];
+  await walk(root, "", 0, out);
+  return out;
+}
+
+/** @param {string[]} files @returns {string} ligne d'inventaire prête à injecter */
+export function inventoryFacts(files) {
+  const list = files.map((f) => (isSecretPath(f) ? `${f} (sensible, contenu jamais lu)` : f));
+  return `Inventaire complet des fichiers (${files.length}${files.length >= MAX_FILES ? ", limite atteinte" : ""}) — un fichier listé ici EXISTE, ne le déclare jamais absent : ${list.join(", ") || "(dossier vide)"}`;
+}
+// MODULE_COMPLETE

package/src/engine/facts-lang.js

@@ -0,0 +1,34 @@
+// src/engine/facts-lang.js — Familles de langages mesurées (début de fonction, mode de fin) : accolades (JS/TS, Go, Rust, PHP, Java, C#, Kotlin, Scala, Swift, C/C++, shell, PowerShell), indentation (Python), mots-clés « end » (Ruby).
+// Détection par motifs de ligne : estimation, jamais d'exécution. Un langage absent de cette table n'a pas de mesure de fonctions (jamais d'invention).
+const CONTROL = new Set(["if", "else", "for", "while", "switch", "catch", "do", "try", "return", "new", "throw", "await", "yield", "case", "delete", "typeof", "using", "lock", "foreach", "synchronized", "elif", "when", "defer", "go", "sizeof", "assert", "print", "echo"]);
+const JS = /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function\*?\s+([A-Za-z_$][\w$]*)|(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[\w$]+)\s*=>)/;
+const MODS = "(?:(?:public|private|protected|internal|static|final|abstract|override|open|suspend|inline|operator|async|virtual|unsafe|extern|const|pub(?:\\([^)]*\\))?|mutating|class|implicit|fileprivate|synchronized)\\s+)*";
+const word = (/** @type {string} */ kw, /** @type {string} */ nameRe = "(\\w+)") => new RegExp(`^\\s*${MODS}${kw}\\s+${nameRe}`);
+
+/** Java / C# / C / C++ : « type nom(…) » sans « ; » final, jamais un mot de contrôle. @param {string} line @returns {string | undefined} */
+function clike(line) {
+  const t = line.trimEnd();
+  if (t.endsWith(";") || t.trimStart().startsWith("//")) return undefined;
+  const m = /^\s*(?:[A-Za-z_][\w<>[\],.?*&:]*\s+)+?([A-Za-z_]\w*)\s*\(/.exec(t);
+  const first = /^\s*([A-Za-z_]\w*)/.exec(t)?.[1] ?? "";
+  return m && !CONTROL.has(first) && !CONTROL.has(m[1]) ? m[1] : undefined;
+}
+
+/** @typedef {{ kind: "brace" | "indent" | "end", find: (line: string) => string | undefined }} Lang */
+/** @type {Array<[RegExp, Lang]>} */
+export const LANGS = [
+  [/\.(js|mjs|cjs|ts|mts|cts|tsx|jsx)$/i, { kind: "brace", find: (l) => { const m = JS.exec(l); return m ? m[1] || m[2] : undefined; } }],
+  [/\.go$/i, { kind: "brace", find: (l) => /^func\s+(?:\([^)]*\)\s*)?(\w+)\s*[([]/.exec(l)?.[1] }],
+  [/\.rs$/i, { kind: "brace", find: (l) => word("fn").exec(l)?.[1] }],
+  [/\.php$/i, { kind: "brace", find: (l) => word("function", "&?(\\w+)\\s*\\(").exec(l)?.[1] }],
+  [/\.swift$/i, { kind: "brace", find: (l) => word("func").exec(l)?.[1] }],
+  [/\.(kt|kts)$/i, { kind: "brace", find: (l) => word("fun", "(?:<[^>]+>\\s*)?(?:[\\w.]+\\.)?(\\w+)").exec(l)?.[1] }],
+  [/\.scala$/i, { kind: "brace", find: (l) => word("def").exec(l)?.[1] }],
+  [/\.(java|cs|c|cpp|cc|h|hpp|m|mm|dart|groovy)$/i, { kind: "brace", find: clike }],
+  [/\.(sh|bash)$/i, { kind: "brace", find: (l) => /^\s*(?:function\s+)?([\w-]+)\s*\(\)\s*\{?\s*$|^\s*function\s+([\w-]+)/.exec(l)?.slice(1).find(Boolean) }],
+  [/\.ps1$/i, { kind: "brace", find: (l) => /^\s*function\s+([\w-]+)/i.exec(l)?.[1] }],
+  [/\.py$/i, { kind: "indent", find: (l) => /^\s*(?:async\s+)?def\s+([A-Za-z_]\w*)/.exec(l)?.[1] }],
+  [/\.gd$/i, { kind: "indent", find: (l) => /^\s*(?:static\s+)?func\s+([A-Za-z_]\w*)/.exec(l)?.[1] }], // GDScript (Godot) : indentation comme Python
+  [/\.rb$/i, { kind: "end", find: (l) => /^\s*def\s+(?:self\.)?([\w?!=]+)/.exec(l)?.[1] }],
+];
+// MODULE_COMPLETE

package/src/engine/facts-measure.js

@@ -0,0 +1,43 @@
+// src/engine/facts-measure.js — Mesure de la longueur d'une fonction (lignes UTILES : ni vides ni commentaire) selon la façon dont le langage la délimite : indentation, accolades, mots-clés « end ». Estimation par motifs.
+const COMMENT = /^\s*(\/\/|#|\/\*|\*|--)/;
+const OPEN = /^\s*(?:def|class|module|if|unless|while|until|case|begin|for)\b|\bdo(?:\s*\|[^|]*\|)?\s*$/;
+
+/** @param {string} line @returns {boolean} */
+const useful = (line) => line.trim() !== "" && !COMMENT.test(line);
+const indentOf = (/** @type {string} */ l) => (/^\s*/.exec(l) ?? [""])[0].length;
+
+/** @param {string[]} lines @param {number} from @returns {number} jusqu'à la première ligne moins indentée */
+export function indentLength(lines, from) {
+  const base = indentOf(lines[from]); let n = 1;
+  for (let j = from + 1; j < lines.length; j++) {
+    if (lines[j].trim() === "") continue;
+    if (indentOf(lines[j]) <= base) break;
+    if (useful(lines[j])) n++;
+  }
+  return n;
+}
+
+/** @param {string[]} lines @param {number} from @returns {number} accolades équilibrées ; instruction terminée sans accolade, ou aucune dans les 3 premières lignes = corps en expression ou déclaration (1 ligne) */
+export function braceLength(lines, from) {
+  let depth = 0; let opened = false; let n = 0;
+  for (let j = from; j < lines.length; j++) {
+    if (useful(lines[j])) n++;
+    for (const c of lines[j]) { if (c === "{") { depth++; opened = true; } else if (c === "}") depth--; }
+    if (!opened && (lines[from].trimEnd().endsWith(";") || j >= from + 2)) return 1;
+    if (opened && depth <= 0) return n;
+  }
+  return n;
+}
+
+/** @param {string[]} lines @param {number} from @returns {number} Ruby : jusqu'au « end » qui équilibre les ouvertures */
+export function endLength(lines, from) {
+  let depth = 0; let n = 0;
+  for (let j = from; j < lines.length; j++) {
+    if (useful(lines[j])) n++;
+    if (OPEN.test(lines[j])) depth++;
+    if (/^\s*end\b/.test(lines[j])) depth--;
+    if (depth <= 0 && j > from) return n;
+  }
+  return n;
+}
+// MODULE_COMPLETE

package/src/engine/facts-patterns.js

@@ -0,0 +1,28 @@
+// src/engine/facts-patterns.js — Motifs de risque repérés ligne par ligne (secrets en dur MASQUÉS, appels dangereux, erreurs avalées, dette signalée). Motifs seulement : un indice, pas une preuve.
+const RULES = /** @type {Array<[string, RegExp]>} */ ([
+  ["secrets", /\b([A-Za-z_]*(?:password|passwd|secret|api_?key|token)[A-Za-z_]*)\s*[:=]\s*["']([^"'\s]{4,})["']/i],
+  ["dangereux", /\b(eval\s*\(|new\s+Function\s*\(|os\.system\s*\(|shell\s*=\s*True|subprocess\.(?:call|run|Popen)\s*\(|child_process|innerHTML\s*=|dangerouslySetInnerHTML|pickle\.loads?\s*\()/],
+  ["erreurs-avalees", /(catch\s*(?:\([^)]*\))?\s*\{\s*\}|except\s*:\s*(?:pass)?\s*$|except\s+\w+(?:\s+as\s+\w+)?\s*:\s*pass\b)/],
+  ["dette", /\b(TODO|FIXME|HACK|XXX)\b/],
+]);
+const SHOWN = 8;
+
+/** @param {string} v @returns {string} valeur masquée : jamais le secret en clair dans les faits */
+const mask = (v) => `${v.slice(0, 2)}…`;
+
+/** @param {Array<{ file: string, text: string }>} entries @returns {Record<string, { total: number, shown: string[] }>} */
+export function patternFacts(entries) {
+  /** @type {Record<string, { total: number, shown: string[] }>} */ const out = Object.fromEntries(RULES.map(([k]) => [k, { total: 0, shown: [] }]));
+  for (const { file, text } of entries) {
+    text.split("\n").forEach((line, i) => {
+      for (const [kind, re] of RULES) {
+        const m = re.exec(line);
+        if (!m) continue;
+        out[kind].total++;
+        if (out[kind].shown.length < SHOWN) out[kind].shown.push(`${file}:${i + 1}` + (kind === "secrets" ? ` ${m[1]} = "${mask(m[2])}"` : kind === "dangereux" ? ` ${m[1].trim()}` : ""));
+      }
+    });
+  }
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/facts-project.js

@@ -0,0 +1,26 @@
+// src/engine/facts-project.js — Présence (ou absence) des éléments qui rendent un projet livrable : dépendances déclarées et verrouillées, tests, intégration continue, conteneur, configuration d'exemple, documentation.
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const MANIFESTS = ["package.json", "requirements.txt", "pyproject.toml", "Pipfile", "composer.json", "Gemfile", "go.mod", "Cargo.toml", "pom.xml", "build.gradle"];
+const LOCKS = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "poetry.lock", "Pipfile.lock", "composer.lock", "Gemfile.lock", "go.sum", "Cargo.lock"];
+const CI = [".github/workflows", ".gitlab-ci.yml", ".circleci", "azure-pipelines.yml", "Jenkinsfile"];
+const TEST_FILE = /(^|[\\/])(test_[^\\/]+|[^\\/]+_test|[^\\/]+\.(?:test|spec))\.[a-z]+$|(^|[\\/])(tests?|__tests__)[\\/]/i;
+
+/** @param {string} root @param {string[]} names @returns {Promise<string[]>} ceux qui existent */
+async function present(root, names) {
+  const ok = await Promise.all(names.map((n) => fs.access(path.join(root, n)).then(() => true, () => false)));
+  return names.filter((_, i) => ok[i]);
+}
+
+/** @param {string} root @param {string[]} files fichiers source déjà listés @returns {Promise<{ manifests: string[], locks: string[], ci: string[], docker: boolean, envExample: boolean, gitignore: "absent" | "sans-env" | "ok", readme: boolean, tests: number }>} */
+export async function projectFacts(root, files) {
+  const [manifests, locks, ci, docker, envEx, readme, gi] = await Promise.all([
+    present(root, MANIFESTS), present(root, LOCKS), present(root, CI), present(root, ["Dockerfile", "docker-compose.yml", "compose.yaml"]),
+    present(root, [".env.example", ".env.sample", "env.example"]), present(root, ["README.md", "README", "readme.md", "README.rst"]),
+    fs.readFile(path.join(root, ".gitignore"), "utf8").catch(() => null),
+  ]);
+  return { manifests, locks, ci, docker: docker.length > 0, envExample: envEx.length > 0, readme: readme.length > 0,
+    gitignore: gi === null ? "absent" : /^\s*\.env\b/m.test(gi) ? "ok" : "sans-env", tests: files.filter((f) => TEST_FILE.test(f)).length };
+}
+// MODULE_COMPLETE

package/src/engine/facts-size.js

@@ -0,0 +1,26 @@
+// src/engine/facts-size.js — Tailles du code : fichiers (norme PipCode ≤ 60 lignes) et fonctions (≤ 30 lignes utiles), y compris les fonctions écrites dans les balises <script> des pages HTML, Vue et Svelte.
+// Une page HTML n'est pas jugée sur sa longueur (c'est du balisage) : seules ses fonctions JavaScript le sont. Estimation par motifs.
+import { functionLengths, isMeasured } from "./facts-functions.js";
+import { embeddedScripts } from "./facts-embedded.js";
+import { countLines } from "./line-numbers.js";
+
+export const MAX_FILE_LINES = 60;
+export const MAX_FN_LINES = 30;
+export const CODE = /\.(js|mjs|cjs|ts|mts|cts|tsx|jsx|py|gd|go|rs|java|kt|kts|scala|groovy|rb|php|cs|c|cc|cpp|h|hpp|m|mm|swift|dart|lua|pl|r|ex|exs|hs|jl|vue|svelte|sh|bash|ps1)$/i;
+const PAGE = /\.(html?|vue|svelte)$/i;
+
+/** @param {string} file @param {string} text @returns {Array<{ name: string, line: number, lines: number }>} */
+function fnsOf(file, text) {
+  const own = functionLengths(file, text);
+  return PAGE.test(file) ? [...own, ...embeddedScripts(text).flatMap((s) => functionLengths("inline.js", s.text).map((f) => ({ ...f, line: f.line + s.start - 1 })))] : own;
+}
+
+/** @param {Array<{ file: string, text: string }>} entries @returns {{ code: number, total: number, bigFiles: Array<{ file: string, lines: number }>, bigFns: Array<{ name: string, file: string, line: number, lines: number }>, unmeasured: string[] }} */
+export function sizeFacts(entries) {
+  const code = entries.filter((e) => CODE.test(e.file));
+  const sized = code.map((e) => ({ file: e.file, lines: countLines(e.text) })).sort((a, b) => b.lines - a.lines);
+  const bigFns = entries.filter((e) => CODE.test(e.file) || PAGE.test(e.file)).flatMap((e) => fnsOf(e.file, e.text).filter((f) => f.lines > MAX_FN_LINES).map((f) => ({ ...f, file: e.file }))).sort((a, b) => b.lines - a.lines);
+  const unmeasured = [...new Set(code.filter((e) => !isMeasured(e.file) && !PAGE.test(e.file)).map((e) => e.file.slice(e.file.lastIndexOf(".")).toLowerCase()))];
+  return { code: code.length, total: sized.reduce((n, s) => n + s.lines, 0), bigFiles: sized.filter((s) => s.lines > MAX_FILE_LINES), bigFns, unmeasured };
+}
+// MODULE_COMPLETE

package/src/engine/facts-wordpress.js

@@ -0,0 +1,36 @@
+// src/engine/facts-wordpress.js — Projets WordPress (thèmes, extensions, blocs Gutenberg, widgets Elementor) : détection et règles de sécurité propres à WordPress. Le contenu des pages vit en base de données : seuls les FICHIERS sont audités.
+// Motifs seulement : un indice à confirmer en lisant le code, jamais une preuve.
+import { jsonObject } from "./json-safe.js";
+
+const HEADER = /(?:Theme Name|Plugin Name)\s*:/;
+const INPUT = /\$_(?:GET|POST|REQUEST|COOKIE)\b/;
+const CLEAN = /sanitize_|absint|intval|esc_|wp_unslash|\(int\)|isset\(|empty\(|wp_verify_nonce/;
+const SQL = /\$wpdb->(?:query|get_results|get_var|get_row|get_col)\s*\(\s*["'][^)]*\$/;
+
+/** @param {string[]} a @returns {string} */
+const list = (a) => (a.length ? `${a.length} (${a.slice(0, 4).join(", ")}${a.length > 4 ? ", …" : ""})` : "aucun");
+
+/** @param {Array<{ file: string, text: string }>} entries @returns {string} bloc prêt à injecter ("" si le projet n'est pas WordPress) */
+export function wordpressFacts(entries) {
+  const php = entries.filter((e) => /\.php$/i.test(e.file));
+  const blocks = entries.filter((e) => /(^|\/)block\.json$/.test(e.file));
+  const widgets = php.filter((e) => /extends\s+\\?(?:Elementor\\)?Widget_Base\b/.test(e.text));
+  const templates = entries.filter((e) => /\.json$/i.test(e.file) && /"elType"\s*:/.test(e.text));
+  const theme = entries.some((e) => /(^|\/)style\.css$/.test(e.file) && HEADER.test(e.text.slice(0, 8000)));
+  const plugin = php.some((e) => HEADER.test(e.text.slice(0, 8000)));
+  const config = php.find((e) => /(^|\/)wp-config\.php$/.test(e.file));
+  if (!theme && !plugin && !config && !blocks.length && !widgets.length && !templates.length) return "";
+  const own = php.filter((e) => e !== config && !/(^|\/)index\.php$/.test(e.file));
+  const noGuard = own.filter((e) => /\b(?:function|class)\s/.test(e.text) && !/ABSPATH|WPINC/.test(e.text)).map((e) => e.file);
+  const lines = (/** @type {RegExp[]} */ [bad, ...ok]) => own.flatMap((e) => e.text.split("\n").map((l, i) => ({ at: `${e.file}:${i + 1}`, l })).filter((x) => bad.test(x.l) && !ok.some((o) => o.test(x.l)))).map((x) => x.at);
+  const unclean = lines([INPUT, CLEAN]);
+  const sql = lines([SQL, /prepare\(/]);
+  const ajax = own.filter((e) => /add_action\(\s*["']wp_ajax_/.test(e.text) && !/check_ajax_referer|wp_verify_nonce|current_user_can/.test(e.text)).map((e) => e.file);
+  const badBlocks = blocks.filter((b) => { const j = jsonObject(b.text); return typeof j.name !== "string" || j.apiVersion === undefined; }).map((b) => b.file);
+  const cfg = config ? [/put your unique phrase here/.test(config.text) && "clés de sécurité non personnalisées", /define\(\s*["']WP_DEBUG["']\s*,\s*true/.test(config.text) && "WP_DEBUG activé", /DB_PASSWORD["']\s*,\s*["'](?:|root|password|123456)["']/.test(config.text) && "mot de passe de base faible ou vide"].filter(Boolean) : [];
+  return ["--- WordPress (fichiers du thème et des extensions ; le contenu en base de données n'est pas audité) ---",
+    `Détecté : ${[theme && "thème", plugin && "extension", blocks.length && `${blocks.length} bloc(s) Gutenberg (block.json)`, widgets.length && `${widgets.length} widget(s) Elementor`, templates.length && `${templates.length} modèle(s) Elementor exporté(s) en JSON`, config && "wp-config.php"].filter(Boolean).join(", ")}`,
+    `- Fichiers PHP sans garde d'accès direct (ABSPATH) : ${list(noGuard)} ; entrées utilisateur non assainies : ${list(unclean)} ; requêtes SQL non préparées : ${list(sql)} ; actions AJAX sans nonce ni contrôle de droits : ${list(ajax)}`,
+    `- block.json incomplets (name, apiVersion) : ${list(badBlocks)} ; wp-config.php : ${cfg.length ? cfg.join(", ") : config ? "rien d'anormal repéré" : "absent"}`].join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/generate-architecture-guide.js

@@ -0,0 +1,46 @@
+// src/engine/generate-architecture-guide.js — Boussole technique client :
+// GUIDE_ARCHITECTURE_CODE.md (cartographie des modules, « Où modifier quoi ? »,
+// flux d'exécution). Accents : refactoring → découpage & dépendances ; création → choix initiaux.
+import { DOC_FILES, writeDoc, docHeader } from "./doc-suite.js";
+
+// Tableau « Où modifier quoi ? » : une ligne par tâche de la mission.
+/** @param {AutoTask[]} tasks @returns {string} */
+function whereToEditTable(tasks) {
+  const rows = tasks.map((t) =>
+    `| \`${t.file}\` | ${t.title} | ${t.isNew ? "créé" : "modifié"} | ${t.commit ? "`" + t.commit.slice(0, 7) + "`" : "—"} |`);
+  return ["## Où modifier quoi ?", "",
+    "| Fichier | Rôle / Objectif | Nature | Commit |", "| :--- | :--- | :--- | :--- |",
+    ...rows, ""].join("\n");
+}
+
+// Section d'accent selon le mode de mission (données réelles du state/mission).
+/** @param {AutoTask[]} tasks @param {MissionPlan | null} mission @param {DocMode} mode @returns {string} */
+function modeSection(tasks, mission, mode) {
+  const created = tasks.filter((t) => t.isNew).length;
+  if (mode === "creation") {
+    const domains = (mission && (mission.domainKeys || []).join(", ")) || "—";
+    return "## Choix d'architecture initiaux\n\n" +
+      `- Domaines métier identifiés : ${domains}\n` +
+      `- Modules créés à l'installation : ${created}/${tasks.length}\n` +
+      `- Contraintes de conception posées : ${(mission && mission.constraints || []).length} règles\n`;
+  }
+  return "## Découpage modulaire & restructuration\n\n" +
+    `- Fichiers créés : ${created} — fichiers restructurés : ${tasks.length - created}\n` +
+    "- Chaque fichier garde une responsabilité unique (SRP) — voir tableau ci-dessous.\n" +
+    "- État des dépendances : tout import pointe vers un module listé ci-dessous.\n";
+}
+
+// Génère GUIDE_ARCHITECTURE_CODE.md — n'écrit QUE ce fichier (jamais les deux autres).
+/** @param {string} projectPath @param {AutoState} state @param {MissionPlan | null} mission @param {DocMode} mode @returns {Promise<void>} */
+export async function generateArchitectureGuide(projectPath, state, mission, mode) {
+  const flow = state.tasks.map((t, i) =>
+    `${i + 1}. \`${t.file}\` — ${t.status}${t.commit ? ` (commit ${t.commit.slice(0, 7)})` : ""}`);
+  const body = [
+    docHeader("Boussole technique du code", state, mission),
+    modeSection(state.tasks, mission, mode),
+    whereToEditTable(state.tasks),
+    "## Flux d'exécution de la mission", "", ...flow, "",
+  ].join("\n");
+  await writeDoc(projectPath, DOC_FILES.architecture, body);
+}
+// MODULE_COMPLETE

package/src/engine/generate-readme.js

@@ -0,0 +1,38 @@
+// src/engine/generate-readme.js — Vitrine client : README.md (vue d'ensemble +
+// démarrage rapide). Accents : création → installation & 1er déploiement ;
+// refactoring → état de la structure & reprise après restructuration.
+import { DOC_FILES, writeDoc, docHeader } from "./doc-suite.js";
+
+// Section « démarrage rapide » adaptée au mode de mission.
+/** @param {DocMode} mode @returns {string} */
+function quickstart(mode) {
+  if (mode === "creation") {
+    return "## Démarrage rapide (projet créé de zéro)\n\n" +
+      "1. `npm install` — installer les dépendances.\n" +
+      "2. `npm test` — vérifier la base de départ au vert.\n" +
+      "3. Suivre `RUNBOOK.md` — section « Premier déploiement ».\n";
+  }
+  return "## Démarrage rapide (structure restructurée)\n\n" +
+    "1. `npm test` — confirmer aucune régression après restructuration.\n" +
+    "2. Ouvrir `GUIDE_ARCHITECTURE_CODE.md` — cartographie « Où modifier quoi ? ».\n" +
+    "3. Consulter `RUNBOOK.md` — procédure de rollback de la mission.\n";
+}
+
+// Génère README.md — n'écrit QUE ce fichier (jamais les deux autres).
+/** @param {string} projectPath @param {AutoState} state @param {MissionPlan | null} mission @param {DocMode} mode @returns {Promise<void>} */
+export async function generateReadme(projectPath, state, mission, mode) {
+  const roles = (mission && (mission.personas || []).map((p) => p.role_name).join(", ")) || "—";
+  const body = [
+    docHeader("Vitrine du projet", state, mission),
+    "## Vue d'ensemble", "",
+    mission && mission.need ? `**Besoin** : ${mission.need}` : "Projet piloté par PipCode (Mode Auto).",
+    "", `**Rôles clés** : ${roles}`, "",
+    quickstart(mode),
+    "## Documents associés", "",
+    "- `GUIDE_ARCHITECTURE_CODE.md` — boussole technique du code.",
+    "- `RUNBOOK.md` — déploiement, exploitation, rollback.",
+    "",
+  ].join("\n");
+  await writeDoc(projectPath, DOC_FILES.readme, body);
+}
+// MODULE_COMPLETE

package/src/engine/generate-runbook.js

@@ -0,0 +1,47 @@
+// src/engine/generate-runbook.js — Manuel d'exploitation client : RUNBOOK.md
+// (variables d'environnement, build/release, healthchecks, logs, rollback).
+// Accents : création → premier déploiement ; refactoring → vérification post-restructuration.
+import { DOC_FILES, writeDoc, docHeader } from "./doc-suite.js";
+
+// Procédure de release selon le mode de mission.
+/** @param {DocMode} mode @returns {string} */
+function releaseSection(mode) {
+  if (mode === "creation") {
+    return "## Premier déploiement\n\n" +
+      "1. `npm test` — base au vert.\n" +
+      "2. `git tag v0.1.0` — poser le jalon initial.\n" +
+      "3. Déployer via votre canal habituel (CI, PaaS…) — vérifier les healthchecks.\n";
+  }
+  return "## Build & release (post-restructuration)\n\n" +
+    "1. `npm test` — confirmer zéro régression de la restructuration.\n" +
+    "2. `git tag <version>` — jalon de la restructuration.\n" +
+    "3. Déployer ; en cas de régression → section Rollback ci-dessous.\n";
+}
+
+// Génère RUNBOOK.md — n'écrit QUE ce fichier (jamais les deux autres).
+/** @param {string} projectPath @param {AutoState} state @param {MissionPlan | null} mission @param {DocMode} mode @returns {Promise<void>} */
+export async function generateRunbook(projectPath, state, mission, mode) {
+  const commits = state.tasks.flatMap((t) => (t.commit ? ["`" + t.commit.slice(0, 7) + "`"] : []));
+  const body = [
+    docHeader("Runbook — déploiement & exploitation", state, mission),
+    "## Variables d'environnement", "",
+    "| Variable | Rôle | Source |", "| :--- | :--- | :--- |",
+    "| À compléter | Variables propres au projet | `.env` / plateforme |", "",
+    releaseSection(mode),
+    "## Healthchecks", "",
+    "- `npm test` — suite au vert avant toute release.",
+    "- `git status` — arbre propre (aucun diff non commité).",
+    "",
+    "## Logs & artefacts PipCode", "",
+    "- `.pipcode/mission.md` — journal de la mission (itérations).",
+    "- `.pipcode/auto-state.json` — checkpoint (reprise sur crash).",
+    "",
+    "## Rollback", "",
+    `- Commits de la mission (ordre d'exécution) : ${commits.join(", ") || "—"}`,
+    "- Retour arrière ciblé : `git revert --no-edit <commit>`.",
+    "- Mission entière (si commits contigus) : `git revert --no-edit <premier>^..<dernier>`.",
+    "",
+  ].join("\n");
+  await writeDoc(projectPath, DOC_FILES.runbook, body);
+}
+// MODULE_COMPLETE

package/src/engine/git-facts.js

@@ -0,0 +1,16 @@
+// src/engine/git-facts.js — Faits Git réels pour l'audit (lecture seule) : dépôt présent ?, modifications non validées, derniers commits.
+// git via execFile sans shell ; tout échec (git absent, pas un dépôt) → constat honnête, jamais d'exception.
+import { gitExec } from "../auto/git.js";
+
+const MAX_LINES = 20;
+
+/** @param {string} projectPath @returns {Promise<string>} bloc texte prêt à injecter */
+export async function gitFacts(projectPath) {
+  const inside = await gitExec(projectPath, ["rev-parse", "--is-inside-work-tree"]).catch(() => "");
+  if (inside !== "true") return "--- État Git ---\nAucun dépôt Git détecté dans ce dossier (ou git indisponible).";
+  const status = (await gitExec(projectPath, ["status", "--porcelain"]).catch(() => "")).split("\n").filter(Boolean);
+  const log = (await gitExec(projectPath, ["log", "-n", "8", "--pretty=format:%h %s"]).catch(() => "")).split("\n").filter(Boolean);
+  const changes = status.length ? `${status.length} fichier(s) modifié(s) ou non suivi(s) :\n${status.slice(0, MAX_LINES).join("\n")}${status.length > MAX_LINES ? `\n[… ${status.length - MAX_LINES} autres]` : ""}` : "Arbre de travail propre (aucune modification non validée).";
+  return `--- État Git ---\nDépôt Git présent.\n${changes}\nDerniers commits :\n${log.length ? log.join("\n") : "(aucun commit)"}`;
+}
+// MODULE_COMPLETE

package/src/engine/history-purge.js

@@ -0,0 +1,16 @@
+// src/engine/history-purge.js — Le raisonnement des modèles n'est JAMAIS réinjecté dans un prompt : blocs repliables « :::steps … ::: » du chat
+// (non fermé = jusqu'à la fin) et balises <think>. Préserve la fenêtre d'attention et le budget de tokens. Pur.
+import { stripReasoning } from "../core/dual-stream-parser.js";
+
+/** @param {string} text @returns {string} */
+export function purgeReasoning(text) {
+  const kept = [];
+  let inside = false;
+  for (const line of String(text).split("\n")) {
+    if (!inside && line.trim() === ":::steps") { inside = true; continue; }
+    if (inside) { if (line.trim() === ":::") inside = false; continue; }
+    kept.push(line);
+  }
+  return stripReasoning(kept.join("\n"));
+}
+// MODULE_COMPLETE