pipcode 0.0.0-stage → 2.1.1

package/src/engine/orchestrate-route.js

@@ -0,0 +1,39 @@
+// src/engine/orchestrate-route.js — selectPhase : provider à utiliser pour chaque
+// phase d'orchestration (analyse = smart_model, patch = fast_model), selon le
+// routage hybride. Primaire cloud → comportement historique INCHANGÉ. Primaire
+// local (Ollama) + secondaire cloud → bascule conditionnelle (a)/(b)/(c).
+
+import { readSecondaryProvider } from "../core/llm-config-secondary.js";
+import { isLocalBase, decideRoute } from "./route-llm.js";
+import { readLocalWindow, localCapacity, readHeavyTokens } from "./context-margin.js";
+
+// Le modèle local gère-t-il l'orchestration multi-phase ? (défaut : oui)
+// PLUGCTO_LOCAL_CAN_MULTI_AGENT=false force la bascule cloud (condition a).
+/** @param {Record<string, string | undefined>} [env] @returns {boolean} */
+export function localCanMultiAgent(env = process.env) {
+  return String(env.PLUGCTO_LOCAL_CAN_MULTI_AGENT || "").toLowerCase() !== "false";
+}
+
+// Sélectionne le provider + les modèles d'une phase. Rétrocompatible.
+/** @param {{ primary: ProviderPrimary }} pcfg @param {"analysis" | "patch"} phase @param {number} promptTokens @returns {{ primary: ProviderPrimary, smartModel: string, fastModel: string, route: RouteDecision["route"], reason: string }} */
+export function selectPhase(pcfg, phase, promptTokens) {
+  const primary = pcfg && pcfg.primary;
+  if (!primary) {
+    const err = /** @type {EnrichedError} */ (new Error("Provider principal manquant."));
+    err.code = "no_provider";
+    throw err;
+  }
+  const local = isLocalBase(primary.base) ? primary : null;
+  if (!local) return { primary, smartModel: primary.smartModel || primary.model, fastModel: primary.fastModel || primary.model, route: "primary", reason: `${phase}:primary_cloud` };
+  const { secondary } = readSecondaryProvider();
+  if (!secondary) return { primary, smartModel: primary.smartModel || primary.model, fastModel: primary.fastModel || primary.model, route: "local", reason: `${phase}:local_only` };
+  const d = decideRoute({
+    local, secondary, promptTokens,
+    capacityTokens: localCapacity(readLocalWindow()),
+    localMultiAgent: localCanMultiAgent(),
+    heavyTokens: readHeavyTokens(),
+  });
+  const chosen = d.route === "cloud" ? secondary : primary;
+  return { primary: chosen, smartModel: chosen.smartModel || chosen.model, fastModel: chosen.fastModel || chosen.model, route: d.route, reason: `${phase}:${d.reason}` };
+}
+// MODULE_COMPLETE

package/src/engine/orchestrator-build.js

@@ -0,0 +1,37 @@
+// src/engine/orchestrator-build.js — Assemblage du userText d'orchestration (Phase 1 analyse).
+// Concatène contexte fichier + doctrine + lastDiff + correction + code dans le bloc DYNAMIQUE (user).
+// Le system prompt byte-stable reste isolé (prompt caching Anthropic intact).
+
+import { ANALYSIS_DOCTRINE, DOCTRINE_REMINDER, cachePrefixOf } from "./doctrine-prefix.js";
+
+// Construit le userText à partir des args (contexte + doctrine + correction + code).
+/** @param {OrchestratorArgs} args @returns {string} */
+export function buildOrchestrationUserText(args) {
+  const filePath = args.file_path || "";
+  const language = args.language || "";
+  const domain = args.domain || "";
+  const code = args.code || "";
+  const doctrine = (args.doctrine || "").trim();
+  const lastDiff = (args.lastDiff || "").trim();
+  const correction = (args.correction || "").trim();
+  const ctx = [
+    filePath && `Fichier: ${filePath}`,
+    language && `Langage: ${language}`,
+    domain && `Domaine: ${domain}`,
+  ].filter(Boolean).join("\n");
+  const userParts = [];
+  if (ctx) userParts.push(ctx);
+  if (doctrine) userParts.push("Doctrine (règles absolues à vérifier strictement):\n" + doctrine);
+  if (lastDiff) userParts.push("Diff du commit précédent (contexte continu — ne pas reciter):\n" + lastDiff);
+  if (correction) userParts.push("Correction requise (Hooks déterministes ont rejeté le patch précédent):\n" + correction);
+  userParts.push("Code:\n" + code);
+  return userParts.join("\n\n");
+}
+// Même contenu, autre ORDRE : doctrine (+ mission) en préfixe de cache, le reste (fichier, diff, correction, code) après, rappel en dernière ligne.
+/** @param {OrchestratorArgs} args @param {string} missionCtx @returns {{ prefix: string, rest: string }} */
+export function buildOrchestrationSplit(args, missionCtx) {
+  const doctrine = (args.doctrine || "").trim();
+  const rest = buildOrchestrationUserText({ ...args, doctrine: "" });
+  return { prefix: cachePrefixOf(ANALYSIS_DOCTRINE, doctrine, missionCtx), rest: doctrine ? rest + "\n\n" + DOCTRINE_REMINDER : rest };
+}
+// MODULE_COMPLETE

package/src/engine/orchestrator-phases.js

@@ -0,0 +1,55 @@
+// src/engine/orchestrator-phases.js — Sous-agents Phase 1 (analyse) + Phase 2 (patch).
+// Héritage de doctrine : le patch reçoit la même doctrine que l'analyse. Erreurs enrichies typées.
+import { callLLM } from "../core/llm-call.js";
+import { analysisPrompt, patchPrompt } from "../core/llm-prompts.js";
+import { withLanguage } from "../core/lang.js";
+import { patchMaxTokens } from "../core/constants.js";
+import { ANALYSIS_MAX_TOKENS } from "../core/constants.js";
+import { PATCH_DOCTRINE, DOCTRINE_REMINDER, cachePrefixOf } from "./doctrine-prefix.js";
+
+// Phase 1 : analyse (provider primaire, smart_model). Jette phase1_failed enrichie.
+/** @param {ProviderPrimary} primary @param {string} smartModel @param {string} userText @param {string} missionCtx @returns {Promise<string>} */
+export async function runAnalysisPhase(primary, smartModel, userText, missionCtx) {
+  try {
+    return await callLLM({
+      provider: primary.provider, key: primary.key,
+      model: smartModel, base: primary.base,
+      systemPrompt: withLanguage(analysisPrompt()), userText, cachePrefix: missionCtx,
+      maxTokens: ANALYSIS_MAX_TOKENS,
+    });
+  } catch (err) {
+    const e0 = /** @type {Error} */ (err);
+    const e = /** @type {EnrichedError} */ (new Error(`Échec Phase 1 (analyse, ${primary.provider}) : ${e0.message}`));
+    e.code = "phase1_failed";
+    e.provider = primary.provider;
+    throw e;
+  }
+}
+
+// Phase 2 : patch (clé unique globale, fast_model). Jette phase2_failed (rend le diagnostic).
+/** @param {ProviderPrimary} primary @param {string} fastModel @param {string} analysis @param {string} code @param {string} doctrine @param {string} correction @param {string} missionCtx @param {string} [askNote] @returns {Promise<string>} */
+export async function runPatchPhase(primary, fastModel, analysis, code, doctrine, correction, missionCtx, askNote = "") {
+  const patchParts = [`Diagnostic:\n${analysis}`, `Code:\n${code}`];
+  if (correction) patchParts.push("Correction requise:\n" + correction);
+  if (askNote) patchParts.push(askNote); // pause ASK_USER proposée au modèle (seulement si l'interface peut répondre)
+  if (doctrine.trim()) patchParts.push(DOCTRINE_REMINDER);
+  try {
+    const patch = await callLLM({
+      provider: primary.provider, key: primary.key,
+      model: fastModel, base: primary.base,
+      systemPrompt: patchPrompt(), cachePrefix: cachePrefixOf(PATCH_DOCTRINE, doctrine, missionCtx), // doctrine + mission en tête : préfixe de cache
+
+      maxTokens: patchMaxTokens(code.length),
+      userText: patchParts.join("\n\n"),
+    });
+    return patch.trim();
+  } catch (err) {
+    const e0 = /** @type {Error} */ (err);
+    const e = /** @type {EnrichedError} */ (new Error(`Échec Phase 2 (patch, ${primary.provider}) : ${e0.message}`));
+    e.code = "phase2_failed";
+    e.provider = primary.provider;
+    e.analysis = analysis;
+    throw e;
+  }
+}
+// MODULE_COMPLETE

package/src/engine/orchestrator.js

@@ -0,0 +1,40 @@
+// src/engine/orchestrator.js — orchestrateLLM : orchestration Multi-LLM (BYOK)
+// avec ROUTAGE HYBRIDE par phase. Phase 1 analyse (smart_model) → Phase 2 patch
+// (fast_model) → Phase 3 contrôle/doute (modèle SECONDAIRE, 1 passage borné, si
+// configuré). Retourne { analysis, patch, models, route } + champs duo/control.
+import { buildOrchestrationUserText, buildOrchestrationSplit } from "./orchestrator-build.js";
+import { runPatchPhase } from "./orchestrator-phases.js";
+import { runAnalysisRelayed } from "./relay-analysis.js";
+import { selectPhase } from "./orchestrate-route.js";
+import { estimateTokens } from "./context-margin.js";
+import { runDuoControl } from "./control-duo.js";
+import { patchOrAsk } from "../auto/patch-ask.js";
+
+const NO_CONTROL = { duo: false, duoSameProvider: false, patch: "", control: { status: /** @type {const} */ ("skipped"), reason: "question_utilisateur", model: null } };
+
+// Orchestre Phase 1 + Phase 2 avec routage hybride local/cloud par phase.
+/** @param {OrchestratorArgs} args @param {{ primary: ProviderPrimary }} pcfg @returns {Promise<OrchestratorResult>} */
+export async function orchestrateLLM(args, pcfg) {
+  if (!pcfg || !pcfg.primary) {
+    const err = /** @type {EnrichedError} */ (new Error("Provider principal manquant."));
+    err.code = "no_provider";
+    throw err;
+  }
+  const missionCtx = args.missionContext || "";
+  const doctrine = (args.doctrine || "").trim();
+  const correction = (args.correction || "").trim();
+  const userText = buildOrchestrationUserText(args);
+  const selA = selectPhase(pcfg, "analysis", estimateTokens(userText));
+  const analysis = await runAnalysisRelayed(selA.primary, selA.smartModel, userText, missionCtx, undefined, buildOrchestrationSplit(args, missionCtx));
+  const patchTokens = estimateTokens(analysis) + estimateTokens(args.code || "") + estimateTokens(doctrine);
+  const selP = selectPhase(pcfg, "patch", patchTokens);
+  const { patch, asking } = await patchOrAsk((note) => runPatchPhase(selP.primary, selP.fastModel, analysis, args.code || "", doctrine, correction, missionCtx, note), !!args.canAsk, doctrine); // une vraie question n'est pas un patch : ni contrôle du Modèle 2, ni application
+  const duo = asking ? NO_CONTROL : await runDuoControl({ ...selP.primary, model: selP.fastModel }, args, analysis, patch, missionCtx, doctrine);
+  return {
+    analysis, patch: duo.patch,
+    models: { analysis: selA.smartModel, patch: selP.fastModel },
+    route: { analysis: selA.route, patch: selP.route, reason: `${selA.reason} | ${selP.reason}` },
+    duo: duo.duo, duo_same_provider: duo.duoSameProvider, control: duo.control, ...(asking ? { asking } : {}),
+  };
+}
+// MODULE_COMPLETE

package/src/engine/osv.js

@@ -0,0 +1,43 @@
+// src/engine/osv.js — Interrogation de la base publique OSV.dev (Google, gratuite, sans clé) : failles connues par dépendance. SEULS le nom, l'écosystème et la version des dépendances sont envoyés — jamais le code.
+// Toute panne (réseau, quota, réponse inattendue) lève une erreur typée : l'appelant dit « non vérifié », jamais « aucune faille ».
+import { asArr, asObj } from "./json-safe.js";
+
+const API = "https://api.osv.dev/v1";
+const BATCH = 500;
+const MAX_DETAILS = 40;
+const TIMEOUT_MS = 15_000;
+export const SEVERITY = /** @type {Record<string, string>} */ ({ CRITICAL: "critique", HIGH: "élevée", MODERATE: "moyenne", MEDIUM: "moyenne", LOW: "faible" });
+
+/** @typedef {{ ecosystem: string, name: string, version: string, pinned: boolean, priv?: boolean }} Dep */
+/** @typedef {{ id: string, cve: string, severity: string, fixed: string }} VulnInfo */
+
+/** @param {typeof fetch} f @param {string} url @param {RequestInit} [init] @returns {Promise<Record<string, unknown>>} */
+async function call(f, url, init) {
+  const r = await f(url, { ...init, signal: AbortSignal.timeout(TIMEOUT_MS) });
+  if (!r.ok) throw new Error(`OSV HTTP ${r.status}`);
+  return asObj(await r.json());
+}
+
+/** @param {typeof fetch} f @param {string} id @returns {Promise<VulnInfo>} */
+async function detail(f, id) {
+  const v = await call(f, `${API}/vulns/${encodeURIComponent(id)}`);
+  const sev = String(asObj(v.database_specific).severity ?? "").toUpperCase();
+  const fixed = asArr(v.affected).flatMap((a) => asArr(asObj(a).ranges)).flatMap((r) => asArr(asObj(r).events)).map((e) => asObj(e).fixed).find((x) => typeof x === "string" && /^\d[\w.+-]{0,19}$/.test(x)); // une version (jamais un code de commit)
+  return { id, cve: String(asArr(v.aliases).find((a) => /^CVE-/.test(String(a))) ?? ""), severity: SEVERITY[sev] ?? "inconnue", fixed: typeof fixed === "string" ? fixed : "" };
+}
+
+/** @param {Dep[]} deps @param {typeof fetch} [f] @returns {Promise<{ scanned: number, hits: Array<{ dep: Dep, ids: string[] }>, info: Map<string, VulnInfo> }>} */
+export async function osvScan(deps, f = fetch) {
+  const targets = deps.filter((d) => d.pinned && d.version && !d.priv); // un paquet privé ou local n'est JAMAIS envoyé
+  /** @type {Array<{ dep: Dep, ids: string[] }>} */ const hits = [];
+  for (let i = 0; i < targets.length; i += BATCH) {
+    const chunk = targets.slice(i, i + BATCH);
+    const body = JSON.stringify({ queries: chunk.map((d) => ({ package: { name: d.name, ecosystem: d.ecosystem }, version: d.version })) });
+    const j = await call(f, `${API}/querybatch`, { method: "POST", headers: { "content-type": "application/json" }, body });
+    asArr(j.results).forEach((res, k) => { const ids = asArr(asObj(res).vulns).map((v) => String(asObj(v).id ?? "")).filter(Boolean); if (ids.length) hits.push({ dep: chunk[k], ids }); });
+  }
+  const ids = [...new Set(hits.flatMap((h) => h.ids))].slice(0, MAX_DETAILS);
+  const infos = await Promise.all(ids.map((id) => detail(f, id).catch(() => ({ id, cve: "", severity: "inconnue", fixed: "" }))));
+  return { scanned: targets.length, hits, info: new Map(infos.map((x) => [x.id, x])) };
+}
+// MODULE_COMPLETE

package/src/engine/parse-json-loose.js

@@ -0,0 +1,36 @@
+// src/engine/parse-json-loose.js — Extrait le JSON d'une réponse LLM (tolère fences + texte autour).
+// Par défaut : premier OBJET (comportement historique). opts.arrays : un tableau racine est accepté. opts.recover : un JSON tronqué est
+// rattrapé par équilibrage de pile (json-balance.js) et marqué TRUNCATED.
+import { TRUNCATED, recoverTruncated } from "./json-balance.js";
+
+export { TRUNCATED };
+
+/** @param {string} body @param {number} start @returns {number} index de fermeture, -1 si le texte s'arrête avant */
+function matchEnd(body, start) {
+  let depth = 0, inStr = false, esc = false;
+  for (let i = start; i < body.length; i++) {
+    const c = body[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === '"') inStr = false;
+    } else if (c === '"') inStr = true;
+    else if (c === "{" || c === "[") depth++;
+    else if (c === "}" || c === "]") { depth--; if (depth === 0) return i; }
+  }
+  return -1;
+}
+
+/** @param {string} text @param {{ arrays?: boolean, recover?: boolean }} [opts] @returns {unknown} */
+export function parseJsonLoose(text, opts = {}) {
+  if (!text) return null;
+  const t = String(text).trim();
+  const fenced = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const body = fenced ? fenced[1] : t;
+  const start = body.search(opts.arrays ? /[{[]/ : /\{/);
+  if (start === -1) return null;
+  const end = matchEnd(body, start);
+  if (end === -1) return opts.recover ? recoverTruncated(body.slice(start)) : null;
+  try { return JSON.parse(body.slice(start, end + 1)); } catch { return null; }
+}
+// MODULE_COMPLETE

package/src/engine/patch-file-sections.js

@@ -0,0 +1,28 @@
+// src/engine/patch-file-sections.js — Découpage d'un patch Unified Diff en
+// sections par fichier : chemin, lignes ajoutées (+) et supprimées (-),
+// isNew (header `--- /dev/null` = fichier créé par ce patch). Les lignes de
+// contexte sont ignorées ; les headers +++/--- ne comptent jamais comme code.
+
+// Sections fichier du patch, dans l'ordre d'apparition des headers.
+/** @param {string} patch @returns {Section[]} */
+export function fileSections(patch) {
+  /** @type {Section[]} */ const out = [];
+  /** @type {Section | null} */ let cur = null;
+  let fromNull = false;
+  for (const l of String(patch).split("\n")) {
+    if (l.startsWith("--- ")) { fromNull = l.startsWith("--- /dev/null"); continue; }
+    if (l.startsWith("+++ b/")) {
+      cur = {
+        file: l.slice(6).trim().replace(/"/g, "").replace(/\\/g, "/"),
+        added: [], removed: [], isNew: fromNull,
+      };
+      out.push(cur);
+      continue;
+    }
+    if (!cur) continue;
+    if (l.startsWith("+")) cur.added.push(l.slice(1));
+    else if (l.startsWith("-")) cur.removed.push(l.slice(1));
+  }
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/patch-scan-cheat.js

@@ -0,0 +1,52 @@
+// src/engine/patch-scan-cheat.js — Floor guard anti-triche (NON NEGO) sur les diffs produits : un patch qui rend
+// les tests verts SANS implémenter est rejeté. 5 gestes : (1) assertion affaiblie/supprimée, (2) catch vide,
+// (3) test skippé ou commenté, (4) résultat codé en dur, (5) stub TODO/FIXME. Analyse PAR FICHIER : gestes 1 et 4
+// comparent lignes supprimées vs ajoutées. Motifs et TEXTES servis par le serveur (lot Pro) — ici la mécanique.
+import { fileSections } from "./patch-file-sections.js";
+import { getRules } from "../rules/rules-registry.js";
+
+/** @type {WeakMap<object, Record<string, RegExp>>} */
+const compiled = new WeakMap();
+/** Compile (une fois par lot de règles) les motifs reçus du serveur. @param {ScanRules["cheat"]} c @returns {Record<string, RegExp>} */
+function patterns(c) {
+  let p = compiled.get(c);
+  if (!p) { p = { file: new RegExp(c.testFile, "i"), tauto: new RegExp(c.tauto), assert: new RegExp(c.assert), empty: new RegExp(c.emptyCatch), skip: new RegExp(c.skip), commented: new RegExp(c.commented), call: new RegExp(c.callAssign, "g"), stub: new RegExp(c.stub, "i") }; compiled.set(c, p); }
+  return p;
+}
+
+/** Les 5 gestes, dans l'ordre des règles du serveur. @param {ScanRules["cheat"]} c @returns {((s: Section) => boolean)[]} */
+function gestures(c) {
+  const p = patterns(c);
+  const isTest = (/** @type {Section} */ s) => p.file.test(s.file);
+  return [
+    (s) => s.added.some((l) => p.tauto.test(l)) || (isTest(s) && s.removed.some((l) => p.assert.test(l)) && s.added.length > 0 && !s.added.some((l) => p.assert.test(l))),
+    (s) => p.empty.test(s.added.join("\n")),
+    (s) => isTest(s) && (s.added.some((l) => p.skip.test(l)) || s.added.filter((l) => p.commented.test(l)).length >= c.commentedMin),
+    (s) => {
+      const names = new Set();
+      for (const l of s.removed) for (const m of l.matchAll(p.call)) names.add(m[1]);
+      if (!names.size || isTest(s)) return false;
+      const lit = new RegExp(`(?:const|let|var)\\s+(?:${[...names].join("|")})\\s*=\\s*(?:["'\`]|-?\\d)`);
+      return s.added.some((l) => lit.test(l));
+    },
+    (s) => s.added.some((l) => p.stub.test(l)),
+  ];
+}
+
+// Scanne le patch PAR FICHIER : une violation max par règle (jamais un déluge). Lot Pro absent : aucune règle.
+/** @param {string} patch @param {Violation[]} out */
+export function collectCheatViolations(patch, out) {
+  const scan = getRules().scan;
+  if (!scan) return;
+  const checks = gestures(scan.cheat);
+  const seen = checks.map(() => false);
+  for (const s of fileSections(patch)) {
+    checks.forEach((check, i) => {
+      if (seen[i] || !check(s)) return;
+      seen[i] = true;
+      const r = scan.cheat.rules[i];
+      if (r) out.push({ kind: "constraint", rule: r.rule, alternative: r.alt, matched: "cheat" });
+    });
+  }
+}
+// MODULE_COMPLETE

package/src/engine/patch-scan-prep.js

@@ -0,0 +1,37 @@
+// src/engine/patch-scan-prep.js — Préparation de l'entrée du scanner de patch
+// (extraction des lignes ajoutées + détection de patch UI).
+
+// Limite de taille de l'entrée soumise au scanner (~10 KB de lignes ajoutées).
+// Garde-fou anti-ReDoS : borne le coût maximal d'une regex même si un pattern
+// douteux passait la sanitization.
+const MAX_SCAN_INPUT_CHARS = 10240;
+
+// Extrait les lignes ajoutées du patch (préfixe `+`, hors `+++` headers) et
+// retourne l'entrée de scan, ou null si le patch n'ajoute rien de significatif.
+// `added` conserve le préfixe `+` (patterns regex métier) ; `addedClean` le
+// retire (parser AST — sinon il reçoit `+const x = …` malformé → perte des
+// déclarations en error-recovery).
+/** @param {string} patch @returns {{ lines: string[], added: string, addedClean: string } | null} */
+export function extractScanInput(patch) {
+  const lines = String(patch).split("\n");
+  const addedRaw = lines.filter((l) => l.startsWith("+") && !l.startsWith("+++"));
+  const addedFull = addedRaw.join("\n");
+  if (!addedFull.trim()) return null;
+  return {
+    lines,
+    added: addedFull.slice(0, MAX_SCAN_INPUT_CHARS),
+    addedClean: addedRaw.map((l) => l.slice(1)).join("\n").slice(0, MAX_SCAN_INPUT_CHARS),
+  };
+}
+
+// Détection d'un patch UI : headers `+++ b/...ext` de présentation.
+/** @param {string[]} lines @returns {boolean} */
+export function isUiPatch(lines) {
+  const uiExt = /\.(css|scss|sass|less|jsx|tsx|vue|svelte|html|htm)(\s|$)/i;
+  return lines.some((l) => {
+    if (!l.startsWith("+++ b/")) return false;
+    const p = l.slice(7).trim();
+    return uiExt.test(p);
+  });
+}
+// MODULE_COMPLETE

package/src/engine/patch-scan-rules.js

@@ -0,0 +1,51 @@
+// src/engine/patch-scan-rules.js — Violations métier du scanner de patch :
+// anti-patterns (§3), invariants réglementaires (§2), Design System (§6).
+import { sanitizePattern } from "./pattern-sanitize.js";
+import { getRules } from "../rules/rules-registry.js";
+
+// Teste des patterns regex (assainis via sanitizePattern, anti-ReDoS) contre le
+// code ajouté. Retourne true au premier pattern qui matche.
+/** @param {string[] | undefined} patterns @param {string} added @returns {boolean} */
+export const testPatterns = (patterns, added) => (patterns || []).some((p) => {
+  const safe = sanitizePattern(p);
+  if (!safe) return false;
+  try { return new RegExp(safe, "i").test(added); } catch { return false; }
+});
+
+// Anti-patterns métier (§3 du scratchpad).
+/** @param {MissionPlan} mission @param {string} added @param {Violation[]} out */
+export function collectPitfallViolations(mission, added, out) {
+  for (const f of (mission.pitfalls || [])) {
+    if (testPatterns(f.patterns, added)) {
+      out.push({ kind: "pitfall", rule: f.never, alternative: f.always, matched: "pitfall" });
+    }
+  }
+}
+
+// Invariants réglementaires (§2 du scratchpad) — NON NEGO.
+/** @param {MissionPlan} mission @param {string} added @param {Violation[]} out */
+export function collectConstraintViolations(mission, added, out) {
+  for (const c of (mission.constraints || [])) {
+    if (testPatterns(c.patterns, added)) {
+      out.push({ kind: "constraint", rule: c.text, alternative: c.invariant, matched: "constraint" });
+    }
+  }
+}
+
+// Design System (§6) : invalide tout patch UI générique hors charte visuelle
+// métier (animations distrayantes en famille A, focus retiré WCAG, etc.).
+/** @param {MissionPlan} mission @param {string} added @param {Violation[]} out */
+export function collectDesignViolations(mission, added, out) {
+  const ds = mission.designSystem || {};
+  for (const v of (ds.violations || [])) {
+    if (testPatterns(v.patterns, added)) {
+      out.push({
+        kind: "design",
+        rule: v.rule,
+        alternative: getRules().scan?.design.charterAlt ?? "",
+        matched: "design",
+      });
+    }
+  }
+}
+// MODULE_COMPLETE

package/src/engine/patch-scan.js

@@ -0,0 +1,38 @@
+// src/engine/patch-scan.js — Scanner de patch Unified Diff : garde-fous AST
+// génériques (sécurité langage) + patterns métier du scratchpad (§2/§3/§6).
+import { extractScanInput, isUiPatch } from "./patch-scan-prep.js";
+import { collectPitfallViolations, collectConstraintViolations, collectDesignViolations } from "./patch-scan-rules.js";
+import { collectFrontendShellViolations } from "./patch-ui-guard.js";
+import { collectSecretTextViolations } from "./patch-secret-guard.js";
+import { collectGraphViolations } from "./ast-rules-graph.js";
+import { collectCheatViolations } from "./patch-scan-cheat.js";
+import { detectAstLang } from "./ast-lang.js";
+import { scanAstViolations } from "./ast-scan.js";
+
+// Scanne un patch Unified Diff contre la mission. Ne considère que les lignes
+// ajoutées (préfixe `+`, hors `+++` headers). Retourne [{ kind:"ast"|"pitfall"|
+// "constraint"|"design", rule, alternative, matched }]. Fallback implicite vers
+// regex si la langue n'est pas supportée par le parser AST (detectAstLang →
+// null) ou si le runtime WASM n'est pas prêt. Inactif si la mission n'a pas
+// chargé ses patterns (sidecar absent) — évite les faux positifs.
+/** @param {string} patch @param {MissionPlan | null} mission @returns {Violation[]} */
+export function scanPatchForViolations(patch, mission) {
+  if (!patch || !mission) return [];
+  if (mission.patternsLoaded === false) return [];
+  const input = extractScanInput(patch);
+  if (!input) return [];
+  /** @type {Violation[]} */ const violations = [];
+  const astLang = detectAstLang(input.lines);
+  if (astLang) {
+    for (const v of scanAstViolations(input.addedClean, astLang)) violations.push(v);
+  }
+  collectPitfallViolations(mission, input.added, violations);
+  collectConstraintViolations(mission, input.added, violations);
+  if (isUiPatch(input.lines)) collectDesignViolations(mission, input.added, violations);
+  collectFrontendShellViolations(patch, violations);
+  collectSecretTextViolations(patch, violations);
+  collectGraphViolations(patch, violations);
+  collectCheatViolations(patch, violations);
+  return violations;
+}
+// MODULE_COMPLETE

package/src/engine/patch-secret-guard.js

@@ -0,0 +1,50 @@
+// src/engine/patch-secret-guard.js — RÈGLE ZERO_SECRET, modèle de sécurité
+// RELATIF « Concepteur vs Public » : tout ce qui est exposé au PUBLIC final
+// (UI, front-end web/webview, toasts, logs clients) subit le blocage STRICT
+// des secrets de conception (chemins locaux absolus, formats de credentials).
+// Les surfaces du CONCEPTEUR (backend/serveur, configuration métier, documents
+// de conception .md, scratchpads) ne sont PAS bloquées : elles portent les
+// secrets d'architecture et les directives nécessaires au développement. La
+// détection de surface publique est partagée avec patch-ui-guard
+// (isFrontendFile) : un seul modèle de périmètre, zéro divergence.
+import { isFrontendFile } from "./patch-ui-guard.js";
+import { testPatterns } from "./patch-scan-rules.js";
+
+// Règles réservées aux surfaces PUBLIQUES (aucun groupe (?:…) quantifié —
+// compatible sanitizePattern anti-ReDoS).
+/** @type {{ rule: string, patterns: string[], alternative: string }[]} */
+const SECRET_RULES = [
+  {
+    rule: "ZERO_SECRET (Public) — chemin local absolu de l'utilisateur exposé au Public (UI/front-end, toast, log client) : interdit.",
+    patterns: ["[A-Za-z]:[\\\\/]+Users", "/home/[A-Za-z0-9._-]+/", "/Users/"],
+    alternative: "Côté Public : chemin relatif, racine configurable ou placeholder masqué. Côté Concepteur : les chemins internes restent libres (jamais exposés).",
+  },
+  {
+    rule: "ZERO_SECRET (Public) — clé API/licence/jeton en dur exposé au Public (UI/front-end, toast, log client) : interdit.",
+    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,}", "AKIA[0-9A-Z]{16}", "xoxb-[A-Za-z0-9-]{10,}",
+      "PLUGCTO-[A-Za-z0-9-]{8,}", "Bearer\\s+[A-Za-z0-9._-]{16,}",
+    ],
+    alternative: "Côté Public : env/coffre et placeholders masqués (<VOTRE_CLÉ_API>). Côté Concepteur : les secrets d'architecture restent internes, jamais exposés au Public.",
+  },
+];
+
+// Scanne le patch PAR FICHIER : seules les lignes ajoutées des fichiers de
+// surface PUBLIQUE sont testées — les surfaces du Concepteur passent librement.
+// Dédoublonné par règle : jamais un déluge.
+/** @param {string} patch @param {Violation[]} out */
+export function collectSecretTextViolations(patch, out) {
+  const seen = SECRET_RULES.map(() => false);
+  let isPublic = false;
+  for (const l of String(patch).split("\n")) {
+    if (l.startsWith("+++ b/")) { isPublic = isFrontendFile(l.slice(6)); continue; }
+    if (!isPublic || !l.startsWith("+") || l.startsWith("+++")) continue;
+    SECRET_RULES.forEach((r, i) => {
+      if (seen[i] || !testPatterns(r.patterns, l)) return;
+      seen[i] = true;
+      out.push({ kind: "constraint", rule: r.rule, alternative: r.alternative, matched: "constraint" });
+    });
+  }
+}
+// MODULE_COMPLETE

package/src/engine/patch-ui-guard.js

@@ -0,0 +1,49 @@
+// src/engine/patch-ui-guard.js — RÈGLE ZERO_TRUST_UI : interdit formellement
+// spawn/exec/child_process dans le code FRONT-END (Webview/UI). Détection
+// PAR FICHIER : extensions de présentation, ou .js/.ts dans un répertoire
+// front-end explicite (webview, renderer, client, public, browser…) — un
+// fichier back-end n'est JAMAIS concerné. Pure, testable en Node.
+import { getRules } from "../rules/rules-registry.js";
+import { testPatterns } from "./patch-scan-rules.js";
+
+// Extensions de présentation (miroir patch-scan-prep isUiPatch).
+const UI_EXT = /\.(css|scss|sass|less|jsx|tsx|vue|svelte|html|htm)(\s|$)/i;
+// Segments de chemin front-end pour .js/.ts (comparaison par SEGMENT exact —
+// jamais par sous-chaîne : « webhook.js » n'est pas « web »).
+const FRONTEND_DIR = /^(webview|web|www|front[-_]?end|renderer|client|browser|public|ui|views?|pages|panels?|widgets?|components?)$/i;
+
+// Un fichier du patch est-il front-end ? (extension UI, ou .js/.ts sous un
+// répertoire front-end explicite).
+/** @param {string} headerPath @returns {boolean} */
+export function isFrontendFile(headerPath) {
+  const p = String(headerPath).trim().replace(/"/g, "");
+  if (UI_EXT.test(p)) return true;
+  if (!/\.(js|ts|mjs|cjs)(\s|$)/i.test(p)) return false;
+  return p.split(/[\\/]/).some((seg) => FRONTEND_DIR.test(seg));
+}
+
+// Scanne le patch PAR FICHIER : toute ligne ajoutée d'un fichier front-end qui
+// spawn/exécute un script terminal → violation design (une par règle, jamais
+// un déluge), bloquée par mission-guard avec l'alternative postMessage. Règles et texte servis par le serveur.
+/** @param {string} patch @param {Violation[]} out */
+export function collectFrontendShellViolations(patch, out) {
+  const scan = getRules().scan;
+  if (!scan) return; // lot Pro absent (compte gratuit) : pas de règle « shell dans l'UI ».
+  const rules = scan.design.shellInUi;
+  let frontend = false;
+  const seen = rules.map(() => false);
+  for (const l of String(patch).split("\n")) {
+    if (l.startsWith("+++ b/")) { frontend = isFrontendFile(l.slice(6)); continue; }
+    if (!frontend || !l.startsWith("+") || l.startsWith("+++")) continue;
+    rules.forEach((r, i) => {
+      if (seen[i] || !testPatterns(r.patterns, l)) return;
+      seen[i] = true;
+      out.push({
+        kind: "design", rule: r.rule,
+        alternative: scan.design.shellAlt,
+        matched: "design",
+      });
+    });
+  }
+}
+// MODULE_COMPLETE

package/src/engine/pattern-sanitize.js

@@ -0,0 +1,23 @@
+// src/engine/pattern-sanitize.js — Assainissement regex anti-ReDoS (patterns LLM/sidecar).
+// Les quantificateurs imbriqués (ex: (.+)+, (.*)*) créent des chemins exponentiels :
+// pattern valide mais gèle le serveur. On REJETTE ces patterns. Limite aussi la longueur.
+
+// Assainit un pattern regex : retourne la chaîne saine, ou null si dangereuse/invalide.
+/** @param {unknown} p @returns {string | null} */
+export function sanitizePattern(p) {
+  if (typeof p !== "string") return null;
+  const s = p.trim();
+  if (!s) return null;
+  if (s.length > 200) return null;
+  if (/\([^()]*[+*?][^()]*\)[+*?{]/.test(s)) return null;
+  if (/\([^()]*[+*?][^()]*\)\{\d/.test(s)) return null;
+  return s;
+}
+
+// Mappe un tableau de patterns LLM vers des patterns assainis (ReDoS filtrés).
+/** @param {unknown} patterns @returns {string[]} */
+export function sanitizePatternsLLM(patterns) {
+  if (!Array.isArray(patterns)) return [];
+  return patterns.map(sanitizePattern).filter((p) => typeof p === "string");
+}
+// MODULE_COMPLETE

package/src/engine/plan-draft.js

@@ -0,0 +1,37 @@
+// src/engine/plan-draft.js — Persistance du draft de consentement de
+// plugcto_plan_mission (le scratchpad mission.md n'est écrit qu'après Y/n).
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// Lit le draft persisté lors du consentement ; null si absent/corrompu ou si le
+// besoin a changé (le draft ne vaut que pour le `need` qui l'a produit).
+/** @param {string} draftPath @param {string} need @returns {Promise<MissionPlan | null>} */
+export async function readPlanDraft(draftPath, need) {
+  try {
+    const draft = JSON.parse(await fs.readFile(draftPath, "utf8"));
+    return draft && draft.need === need ? /** @type {MissionPlan} */ (draft) : null;
+  } catch {
+    return null; // absent ou corrompu → réextraction (fail-safe)
+  }
+}
+
+// Persiste le draft (réutilisable à la confirmation) SANS écrire mission.md.
+/** @param {MissionPlan} plan @param {string} draftPath @returns {Promise<void>} */
+export async function savePlanDraft(plan, draftPath) {
+  try {
+    await fs.mkdir(path.dirname(draftPath), { recursive: true });
+    await fs.writeFile(draftPath, JSON.stringify(plan, null, 2), { encoding: "utf8", mode: 0o600 });
+  } catch {
+    // Best-effort : l'échec de persistance du draft n'invalide pas le
+    // diagnostic (la réextraction reste possible à la confirmation).
+  }
+}
+
+// Supprime le draft après confirmation Auto Mode (mission.md devient la vérité).
+/** @param {string} draftPath @returns {Promise<void>} */
+export async function removePlanDraft(draftPath) {
+  try { await fs.rm(draftPath, { force: true }); } catch {
+    // Best-effort : un draft résiduel sera écrasé à la prochaine planification.
+  }
+}
+// MODULE_COMPLETE