pipcode 0.0.0-stage → 2.1.0

package/src/engine/context-fit.js

@@ -0,0 +1,28 @@
+// src/engine/context-fit.js — Placement SANS PERTE dans un budget : on ajoute des éléments ENTIERS tant qu'ils tiennent ; ce qui
+// ne tient pas est listé (le modèle sait ce qui lui manque). Un fichier plus grand que le budget restant est transmis par
+// parties successives (début d'abord) : le reste est annoncé, jamais coupé en silence.
+
+import { splitLossless } from "../project-memory/batches.js";
+
+/** Lignes entières dans le budget. @param {string[]} lines @param {number} budget @returns {{ text: string, omitted: number }} */
+export function fitLines(lines, budget) {
+  const kept = []; let used = 0;
+  for (const l of lines) { if (used + l.length + 1 > budget) break; used += l.length + 1; kept.push(l); }
+  return { text: kept.join("\n"), omitted: lines.length - kept.length };
+}
+
+/** Fichiers entiers (ou 1re partie) dans le budget ; `left` = fichiers/parties non chargés. @param {Array<{ path: string, text: string }>} files @param {number} budget @returns {{ blocks: string[], left: string[] }} */
+export function fitFiles(files, budget) {
+  const blocks = []; const left = []; let used = 0;
+  for (const f of files) {
+    const room = budget - used - f.path.length - 20;
+    if (f.text.length <= room) { blocks.push(`### ${f.path}\n${f.text}`); used += f.text.length + f.path.length + 10; continue; }
+    const parts = room > 500 && used === 0 ? splitLossless(f.text, room) : []; // seul le 1er élément (le plus pertinent) peut être servi par parties
+    if (parts.length) {
+      blocks.push(`### ${f.path} (partie 1/${parts.length}, lignes 1-${parts[0].text.split("\n").length - 1})\n${parts[0].text}`);
+      used = budget; left.push(`${f.path} (parties 2-${parts.length}, à partir de la ligne ${parts[1]?.fromLine})`);
+    } else left.push(f.path);
+  }
+  return { blocks, left };
+}
+// MODULE_COMPLETE

package/src/engine/context-margin.js

@@ -0,0 +1,37 @@
+// src/engine/context-margin.js — Marge de respiration contextuelle du modèle
+// local : 20 % de la fenêtre restent réservés (anti-saturation/anti-hallucination).
+// Estimation de tokens (~4 chars/token), fenêtre locale et seuil de sous-tâche
+// lourde configurables par env. Pur, aucune I/O.
+
+export const DEFAULT_LOCAL_WINDOW = 32768; // fenêtre locale par défaut (tokens).
+export const BREATHING_RATIO = 0.8;        // 20 % de marge de respiration réservée.
+export const DEFAULT_HEAVY_TOKENS = 6000;   // seuil de sous-tâche lourde (déport cloud).
+
+// Estimation prudente du nombre de tokens (~4 chars/token).
+/** @param {unknown} text @returns {number} */
+export function estimateTokens(text) {
+  const s = typeof text === "string" ? text : String(text ?? "");
+  return Math.ceil(s.length / 4);
+}
+
+// Capacité réelle du local = fenêtre × 0.8 (marge de respiration déduite).
+/** @param {number} windowTokens @returns {number} */
+export function localCapacity(windowTokens) {
+  const w = Number(windowTokens) > 0 ? Math.floor(Number(windowTokens)) : DEFAULT_LOCAL_WINDOW;
+  return Math.floor(w * BREATHING_RATIO);
+}
+
+// Fenêtre locale (env PLUGCTO_LOCAL_CONTEXT_WINDOW, défaut 32k).
+/** @param {Record<string, string | undefined>} [env] @returns {number} */
+export function readLocalWindow(env = process.env) {
+  const n = Number(env.PLUGCTO_LOCAL_CONTEXT_WINDOW);
+  return n > 0 ? Math.floor(n) : DEFAULT_LOCAL_WINDOW;
+}
+
+// Seuil de sous-tâche lourde (env PLUGCTO_HEAVY_TOKENS).
+/** @param {Record<string, string | undefined>} [env] @returns {number} */
+export function readHeavyTokens(env = process.env) {
+  const n = Number(env.PLUGCTO_HEAVY_TOKENS);
+  return n > 0 ? Math.floor(n) : DEFAULT_HEAVY_TOKENS;
+}
+// MODULE_COMPLETE

package/src/engine/context-relay.js

@@ -0,0 +1,60 @@
+// src/engine/context-relay.js — Relais de contexte « zone de confort » (PUR).
+// Dès que le contexte approche la capacité confortable (fenêtre × 0.8), un nouvel
+// agent LLM vierge prend le relais. MAX_RELAYS = terminaison garantie ; au-delà,
+// erreur typée "relay_limit" honnête — jamais de troncature silencieuse.
+import { localCapacity, readLocalWindow } from "./context-margin.js";
+
+export const MAX_RELAYS = 8; // Plafond prudent : ~9 agents × zone de confort.
+export const FRAGMENT_RATIO = 0.55; // Part de la capacité pour le fragment (reste = digest).
+
+// Budget tokens d'un fragment (le digest de passation occupe le reste).
+/** @param {number} capacityTokens @returns {number} */
+export function fragmentBudget(capacityTokens) {
+  return Math.max(1, Math.floor((Number(capacityTokens) || 0) * FRAGMENT_RATIO));
+}
+
+// Nombre de relais (agents SUPPLÉMENTAIRES) : 0 si tout tient en un seul agent.
+/** @param {number} totalTokens @param {number} perAgentTokens @returns {number} */
+export function countRelays(totalTokens, perAgentTokens) {
+  const cap = Math.max(1, Math.floor(Number(perAgentTokens) || 0));
+  const total = Math.max(0, Math.floor(Number(totalTokens) || 0));
+  return total === 0 ? 0 : Math.max(0, Math.ceil(total / cap) - 1);
+}
+
+// Erreur typée de plafond dépassé (analyse incomplète assumée, jamais feinte).
+/** @param {number} relays @param {number} capacityTokens @param {number} totalTokens @returns {EnrichedError} */
+export function relayLimitError(relays, capacityTokens, totalTokens) {
+  const err = /** @type {EnrichedError} */ (new Error(
+    `Limite de relais dépassée (${relays} > ${MAX_RELAYS}) : ${totalTokens} tokens accumulés pour une zone de confort de ${capacityTokens}. L'analyse est INCOMPLÈTE par design — refusez la tâche ou augmentez PLUGCTO_LOCAL_CONTEXT_WINDOW.`
+  ));
+  err.code = "relay_limit";
+  return err;
+}
+
+/** Décision de relais : requis ? combien au total ?
+ * @param {number} totalTokens @param {number} [capacityTokens] @returns {{ relayRequired: boolean, relays: number, agents: number, capacity: number, fragmentTokens: number }} */
+export function planRelay(totalTokens, capacityTokens = localCapacity(readLocalWindow())) {
+  const cap = Number(capacityTokens) > 0 ? Math.floor(Number(capacityTokens)) : localCapacity(readLocalWindow());
+  const frag = fragmentBudget(cap);
+  const relays = countRelays(totalTokens, frag);
+  if (relays > MAX_RELAYS) throw relayLimitError(relays, cap, Math.max(0, Math.floor(Number(totalTokens) || 0)));
+  return { relayRequired: relays > 0, relays, agents: relays + 1, capacity: cap, fragmentTokens: frag };
+}
+
+// Découpe un texte en fragments ≤ fragmentTokens (frontières de ligne préservées).
+/** @param {string} text @param {number} fragmentTokens @returns {string[]} */
+export function splitRelayFragments(text, fragmentTokens) {
+  const s = typeof text === "string" ? text : "";
+  const budget = Math.max(1, Math.floor(Number(fragmentTokens) || 0)) * 4; // ~4 chars/token.
+  if (s.length <= budget) return [s];
+  const out = [];
+  let cur = "";
+  for (const line of s.split("\n")) {
+    if (cur && cur.length + line.length + 1 > budget) { out.push(cur); cur = ""; }
+    cur = cur ? `${cur}\n${line}` : line;
+    while (cur.length > budget) { out.push(cur.slice(0, budget)); cur = cur.slice(budget); }
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/control-duo.js

@@ -0,0 +1,38 @@
+// src/engine/control-duo.js — Décision du duo (Phase 3) : si un provider
+// SECONDAIRE est configuré, UN passage de contrôle borné relit le patch draft
+// (incarnation doctrine §11 Doubt : le second modèle corrige les failles du
+// premier). Sinon repli honnête : duo:false, comportement strictement identique
+// au moteur historique — aucun faux « duo ». Secondaire identique au provider du
+// patch = autorisé mais étiqueté (auto-doute, pas un duo distinct).
+import { readSecondaryProvider } from "../core/llm-config-secondary.js";
+import { runCheckpointControl } from "./checkpoint-control.js";
+import { runSelfAssessment } from "./self-assessment.js";
+
+// Applique (ou non) le contrôle duo : patch final + métadonnées honnêtes.
+/** @param {ProviderPrimary} patchProvider provider ayant produit le draft
+ *  @param {OrchestratorArgs} args
+ *  @param {string} analysis @param {string} draftPatch
+ *  @param {string} missionCtx @param {string} doctrine
+ *  @param {Record<string, string | undefined>} [env]
+ *  @param {(a: CallLLMArgs) => Promise<string>} [llmCall]
+ *  @returns {Promise<DuoOutcome>} */
+export async function runDuoControl(patchProvider, args, analysis, draftPatch, missionCtx, doctrine, env = process.env, llmCall) {
+  const { secondary } = readSecondaryProvider(env);
+  if (!secondary) {
+    return {
+      duo: false, duoSameProvider: false, patch: draftPatch,
+      control: { status: "not_configured", reason: "controle_non_configure", model: null },
+    };
+  }
+  const bilan = await runSelfAssessment({ writer: patchProvider, analysis, patch: draftPatch, missionContext: missionCtx, llmCall });
+  const outcome = await runCheckpointControl({
+    secondary, missionContext: missionCtx, doctrine, analysis, draftPatch,
+    code: args.code || "", selfAssessment: bilan.text, doubts: bilan.state === "doubts", llmCall,
+  });
+  return {
+    duo: true, patch: outcome.patch,
+    duoSameProvider: secondary.provider === patchProvider.provider && secondary.base === patchProvider.base,
+    control: { status: outcome.status, reason: outcome.reason, model: outcome.model, checkpoints: outcome.checkpoints, selfAssessment: bilan.state },
+  };
+}
+// MODULE_COMPLETE

package/src/engine/control-phase.js

@@ -0,0 +1,32 @@
+// src/engine/control-phase.js — Phase 3 duo : UN seul passage de contrôle borné
+// (jamais de boucle) où le modèle SECONDAIRE relit le patch draft via callLLM
+// (clé du secondaire en header, jamais dans le prompt). Échec LLM → fail-safe :
+// draft conservé + raison typée (aucun crash, aucun catch vide).
+import { callLLM } from "../core/llm-call.js";
+import { patchMaxTokens } from "../core/constants.js";
+import { controlPrompt, buildControlUserText } from "./control-prompt.js";
+import { parseControlVerdict } from "./control-verdict.js";
+
+// Exécute le passage de contrôle. Retourne TOUJOURS un patch sûr : le draft est
+// conservé en cas d'échec LLM ou de verdict rejeté ; seul un verdict validé le remplace.
+/** @param {{ secondary: ProviderPrimary, missionContext?: string, doctrine?: string, analysis: string, draftPatch: string, code: string, selfAssessment?: string, llmCall?: (a: CallLLMArgs) => Promise<string> }} v
+ *  @returns {Promise<ControlPhaseOutcome>} */
+export async function runControlPhase({ secondary, missionContext, doctrine, analysis, draftPatch, code, selfAssessment, llmCall = callLLM }) {
+  const userText = buildControlUserText({ missionContext, doctrine, analysis, draftPatch, code, selfAssessment });
+  const model = secondary.smartModel || secondary.model;
+  let raw;
+  try {
+    raw = await llmCall({
+      provider: secondary.provider, key: secondary.key, model, base: secondary.base,
+      systemPrompt: controlPrompt(), cachePrefix: (missionContext || "").trim(),
+      maxTokens: patchMaxTokens(code.length), userText,
+    });
+  } catch (err) {
+    const e0 = /** @type {Error} */ (err);
+    return { status: "failed", reason: `controle_echec_llm: ${e0.message}`.slice(0, 200), model, patch: draftPatch };
+  }
+  const verdict = parseControlVerdict(raw);
+  const patch = verdict.status === "corrected" && verdict.patch ? verdict.patch : draftPatch;
+  return { status: verdict.status, reason: verdict.reason, model, patch };
+}
+// MODULE_COMPLETE

package/src/engine/control-prompt.js

@@ -0,0 +1,25 @@
+// src/engine/control-prompt.js — Phase 3 duo : prompt de contrôle/doute (byte-stable
+// pour prompt caching). Le modèle SECONDAIRE reçoit demande + diagnostic + patch
+// draft + code, et doit produire un verdict STRICT (OK ou patch corrigé). Aucune
+// clé n'y figure jamais : uniquement des textes (anti-fuite BYOK).
+
+import { getRules } from "../rules/rules-registry.js";
+
+/** Prompt de contrôle (texte servi par le serveur, lot Pro) — byte-stable tant que les règles sont en mémoire. @returns {string} */
+export const controlPrompt = () => getRules().prompts.control;
+
+// userText du contrôle : demande (mission) + doctrine + diagnostic + draft + code.
+/** @param {{ missionContext?: string, doctrine?: string, analysis: string, draftPatch: string, code: string, selfAssessment?: string }} v @returns {string} */
+export function buildControlUserText({ missionContext, doctrine, analysis, draftPatch, code, selfAssessment }) {
+  const parts = [];
+  const mission = (missionContext || "").trim();
+  const rules = (doctrine || "").trim();
+  if (mission) parts.push("Demande (mission):\n" + mission);
+  if (rules) parts.push("Doctrine (règles absolues):\n" + rules);
+  parts.push("Diagnostic (IA de cadrage):\n" + analysis);
+  if (selfAssessment) parts.push("Autobilan du Modèle 1 (déclaratif : une indication à vérifier, jamais une preuve):\n" + selfAssessment);
+  parts.push("Patch proposé (draft de l'IA de patch, à contrôler):\n" + draftPatch);
+  parts.push("Code:\n" + code);
+  return parts.join("\n\n");
+}
+// MODULE_COMPLETE

package/src/engine/control-verdict.js

@@ -0,0 +1,36 @@
+// src/engine/control-verdict.js — Validation STRICTE de la sortie du contrôle
+// (frontière externe LLM, Zero Trust) : format « VERDICT: OK » / « VERDICT: PATCH »
+// + Unified Diff. Toute sortie non conforme est REJETÉE : le draft est conservé,
+// une sortie non validée n'est JAMAIS appliquée.
+
+export const VERDICT_OK = "VERDICT: OK";
+export const VERDICT_PATCH = "VERDICT: PATCH";
+
+// Raisons typées remontées honnêtement dans les métadonnées (jamais de vague silence).
+export const REJECT_NON_TEXT = "controle_sortie_non_texte";
+export const REJECT_EMPTY = "controle_sortie_vide";
+export const REJECT_NO_VERDICT = "controle_sans_verdict";
+export const REJECT_NO_DIFF = "controle_patch_corrige_absent";
+export const OK_REASON = "controle_ok";
+export const CORRECTED_REASON = "controle_patch_corrige";
+
+/** @param {string} reason @returns {ControlVerdict} */
+function rejected(reason) {
+  return { status: "rejected", reason, patch: null };
+}
+
+// Parse la sortie du contrôle. Strict : casse exacte, verdict unique, diff réel (@@).
+/** @param {unknown} raw @returns {ControlVerdict} */
+export function parseControlVerdict(raw) {
+  if (typeof raw !== "string") return rejected(REJECT_NON_TEXT);
+  const text = raw.trim();
+  if (!text) return rejected(REJECT_EMPTY);
+  const nl = text.indexOf("\n");
+  const first = (nl === -1 ? text : text.slice(0, nl)).trim();
+  const rest = nl === -1 ? "" : text.slice(nl + 1).trim();
+  if (first === VERDICT_OK) return { status: "ok", reason: OK_REASON, patch: null };
+  if (first !== VERDICT_PATCH) return rejected(REJECT_NO_VERDICT);
+  if (!rest || !rest.includes("@@")) return rejected(REJECT_NO_DIFF);
+  return { status: "corrected", reason: CORRECTED_REASON, patch: rest };
+}
+// MODULE_COMPLETE

package/src/engine/default-steps.js

@@ -0,0 +1,7 @@
+// src/engine/default-steps.js — Étapes canoniques du plan mission (checklist 4) : TEXTE servi par le serveur
+// (lot de base, accessible à tous les comptes) ; ici seulement l'accès au registre mémoire.
+import { getRules } from "../rules/rules-registry.js";
+
+/** @returns {string[]} */
+export const defaultSteps = () => getRules().plan.steps;
+// MODULE_COMPLETE

package/src/engine/deps-parse-js.js

@@ -0,0 +1,49 @@
+// src/engine/deps-parse-js.js — Dépendances npm : package-lock.json (versions EXACTES, transitives comprises) ou package.json (versions déclarées, approximatives). Texte → liste, jamais d'exécution ; JSON invalide = liste vide.
+// Paquet PRIVÉ ou local (priv) : téléchargé hors du registre public, lien local, ou nom à portée (@x/…) sans verrou pour prouver sa source → jamais envoyé à OSV.
+import { asObj, jsonObject } from "./json-safe.js";
+/** @typedef {{ ecosystem: string, name: string, version: string, pinned: boolean, priv?: boolean }} Dep */
+
+const PUBLIC_REGISTRY = /^https:\/\/registry\.(?:npmjs\.org|yarnpkg\.com)\//;
+
+/** @param {string} name @param {unknown} raw entrée du verrou @returns {Dep | null} */
+function lockEntry(name, raw) {
+  const v = asObj(raw);
+  return typeof v.version === "string" ? { ecosystem: "npm", name, version: v.version, pinned: true, priv: v.link === true || !PUBLIC_REGISTRY.test(String(v.resolved ?? "")) } : null;
+}
+
+/** @param {Record<string, unknown>} tree @param {Dep[]} out @returns {void} package-lock v1 : arbre « dependencies » imbriqué */
+function walkV1(tree, out) {
+  for (const [name, raw] of Object.entries(tree)) {
+    const d = lockEntry(name, raw);
+    if (d) out.push(d);
+    walkV1(asObj(asObj(raw).dependencies), out);
+  }
+}
+
+/** @param {string} text @returns {Dep[]} */
+export function parsePackageLock(text) {
+  const j = jsonObject(text);
+  /** @type {Dep[]} */ const out = [];
+  if (j.packages) {
+    for (const [k, raw] of Object.entries(asObj(j.packages))) {
+      const m = /(?:^|\/)node_modules\/((?:@[^/]+\/)?[^/]+)$/.exec(k);
+      const d = m ? lockEntry(m[1], raw) : null;
+      if (d) out.push(d);
+    }
+  } else walkV1(asObj(j.dependencies), out);
+  return out;
+}
+
+/** @param {string} text @returns {Dep[]} version = première version lisible de l'intervalle (« ^1.2.3 » → 1.2.3), « pinned » seulement si exacte */
+export function parsePackageJson(text) {
+  const j = jsonObject(text);
+  /** @type {Dep[]} */ const out = [];
+  for (const section of ["dependencies", "devDependencies"]) {
+    for (const [name, spec] of Object.entries(asObj(j[section]))) {
+      const v = /\d+\.\d+\.\d+(?:[-+][\w.]+)?/.exec(String(spec))?.[0] ?? "";
+      out.push({ ecosystem: "npm", name, version: v, pinned: v !== "" && String(spec).trim() === v, priv: name.startsWith("@") });
+    }
+  }
+  return out;
+}
+// MODULE_COMPLETE

package/src/engine/deps-parse-more.js

@@ -0,0 +1,30 @@
+// src/engine/deps-parse-more.js — Dépendances PHP (composer.lock), Go (go.mod), Ruby (Gemfile.lock). Texte → liste, jamais d'exécution.
+// Paquet PRIVÉ (priv) : téléchargé hors d'un hébergeur public, module du même propriétaire que le projet, section Git/chemin ou serveur de gemmes privé → jamais envoyé à OSV.
+import { asArr, asObj, jsonObject } from "./json-safe.js";
+/** @typedef {{ ecosystem: string, name: string, version: string, pinned: boolean, priv?: boolean }} Dep */
+
+const PUBLIC_HOST = /^https:\/\/(?:api\.github\.com|github\.com|codeload\.github\.com|gitlab\.com|bitbucket\.org)\//;
+
+/** @param {string} text @returns {Dep[]} */
+export function parseComposerLock(text) {
+  const j = jsonObject(text);
+  return [...asArr(j.packages), ...asArr(j["packages-dev"])].map(asObj).filter((p) => typeof p.name === "string" && typeof p.version === "string")
+    .map((p) => ({ ecosystem: "Packagist", name: String(p.name), version: String(p.version).replace(/^v/, ""), pinned: true, priv: !PUBLIC_HOST.test(String(asObj(p.dist).url ?? "")) }));
+}
+
+/** @param {string} text @returns {Dep[]} un module du même propriétaire que le projet (github.com/acme/…) ou du même domaine est considéré privé */
+export function parseGoMod(text) {
+  const own = /^module\s+(\S+)/m.exec(text)?.[1] ?? "";
+  const parts = own.split("/");
+  const ownPrefix = parts[0] && /^(?:github\.com|gitlab\.com|bitbucket\.org)$/.test(parts[0]) ? parts.slice(0, 2).join("/") : parts[0];
+  return [...text.matchAll(/^\s*(?:require\s+)?([\w.~/-]+\.[\w.~/-]+)\s+v(\d[\w.+-]*)/gm)].map((m) => ({ ecosystem: "Go", name: m[1], version: m[2], pinned: true, priv: !!ownPrefix && (m[1] === ownPrefix || m[1].startsWith(`${ownPrefix}/`)) }));
+}
+
+/** @param {string} text @returns {Dep[]} seule la section GEM du serveur public rubygems.org est publique (GIT, PATH, autres serveurs = privés) */
+export function parseGemfileLock(text) {
+  return text.split(/\n(?=[A-Z]+\n)/).flatMap((sec) => {
+    const pub = sec.startsWith("GEM") && /remote: https:\/\/rubygems\.org\/?\s*$/m.test(sec);
+    return [...sec.matchAll(/^ {4}([\w.-]+) \((\d[\w.]*)\)$/gm)].map((m) => ({ ecosystem: "RubyGems", name: m[1], version: m[2], pinned: true, priv: !pub }));
+  });
+}
+// MODULE_COMPLETE

package/src/engine/deps-parse-other.js

@@ -0,0 +1,41 @@
+// src/engine/deps-parse-other.js — Dépendances Python (requirements.txt, Pipfile.lock, poetry.lock) et Rust (Cargo.lock). Texte → liste, jamais d'exécution.
+// Paquet PRIVÉ (priv) : index privé déclaré, dépôt Git, chemin local, source autre que le registre public → jamais envoyé à OSV.
+import { asObj, jsonObject } from "./json-safe.js";
+/** @typedef {{ ecosystem: string, name: string, version: string, pinned: boolean, priv?: boolean }} Dep */
+
+/** @param {string} n @returns {string} nom PyPI normalisé (PEP 503) */
+const pypi = (n) => n.toLowerCase().replace(/[_.]+/g, "-");
+const PRIVATE_INDEX = /^\s*(?:--index-url|--extra-index-url|-i)[\s=]+(?!https?:\/\/(?:[\w-]+\.)?pypi\.org)/m;
+
+/** @param {string} text @returns {Dep[]} « nom==1.2.3 » est épinglée ; autre opérateur ou aucune version = non vérifiable ; index privé déclaré dans le fichier = tout le fichier privé */
+export function parseRequirements(text) {
+  /** @type {Dep[]} */ const out = [];
+  const priv = PRIVATE_INDEX.test(text);
+  for (const raw of text.split("\n")) {
+    const line = raw.split("#")[0].trim();
+    const m = /^([A-Za-z0-9][A-Za-z0-9_.-]*)(?:\[[^\]]*\])?\s*(==|>=|<=|~=|!=|>|<)?\s*([\w.+!*-]*)/.exec(line);
+    if (!m) continue;
+    const pinned = m[2] === "==" && m[3] !== "" && !m[3].includes("*");
+    out.push({ ecosystem: "PyPI", name: pypi(m[1]), version: pinned ? m[3] : "", pinned, priv: priv || /@\s*(?:git\+|https?:|file:)/.test(line) });
+  }
+  return out;
+}
+
+/** @param {string} text @returns {Dep[]} */
+export function parsePipfileLock(text) {
+  const j = jsonObject(text);
+  return ["default", "develop"].flatMap((s) => Object.entries(asObj(j[s])).map(([name, v]) => ({ name, p: asObj(v) })))
+    .filter((x) => String(x.p.version ?? "").startsWith("==")).map((x) => ({ ecosystem: "PyPI", name: pypi(x.name), version: String(x.p.version).slice(2), pinned: true,
+      priv: (x.p.index !== undefined && x.p.index !== "pypi") || "git" in x.p || "path" in x.p || "file" in x.p || x.p.editable === true }));
+}
+
+/** @param {string} text @param {string} ecosystem « PyPI » (poetry.lock) ou « crates.io » (Cargo.lock) @returns {Dep[]} blocs « [[package]] » ; poetry : un bloc [package.source] est privé ; Cargo : privé sans source de registre public */
+export function parseTomlPackages(text, ecosystem) {
+  return text.split("[[package]]").slice(1).flatMap((block) => {
+    const m = /name = "([^"]+)"\s*\nversion = "([^"]+)"/.exec(block);
+    if (!m) return [];
+    const priv = ecosystem === "PyPI" ? /\[package\.source\]/.test(block) : !/source = "(?:registry\+https:\/\/github\.com\/rust-lang\/crates\.io-index|sparse\+https:\/\/index\.crates\.io)/.test(block);
+    return [{ ecosystem, name: ecosystem === "PyPI" ? pypi(m[1]) : m[1], version: m[2], pinned: true, priv }];
+  });
+}
+// MODULE_COMPLETE

package/src/engine/deps-parse.js

@@ -0,0 +1,31 @@
+// src/engine/deps-parse.js — Lit les fichiers de dépendances du projet (npm, PyPI, Packagist, Go, crates.io, RubyGems) et en tire la liste « écosystème / nom / version ». Lecture seule, bornée ; un package.json
+// qui a son verrou voisin est ignoré (le verrou donne les versions exactes). Gestionnaires non pris en charge (Maven, Gradle, NuGet…) : signalés, jamais devinés.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { parsePackageLock, parsePackageJson } from "./deps-parse-js.js";
+import { parseRequirements, parsePipfileLock, parseTomlPackages } from "./deps-parse-other.js";
+import { parseComposerLock, parseGoMod, parseGemfileLock } from "./deps-parse-more.js";
+
+/** @typedef {{ ecosystem: string, name: string, version: string, pinned: boolean, priv?: boolean }} Dep */
+const MAX_DEPS = 3000;
+const MAX_MANIFESTS = 12;
+/** @type {Array<[RegExp, (text: string) => Dep[]]>} */
+const PARSERS = [
+  [/(^|\/)package-lock\.json$/, parsePackageLock], [/(^|\/)package\.json$/, parsePackageJson], [/(^|\/)requirements[\w.-]*\.txt$/, parseRequirements],
+  [/(^|\/)Pipfile\.lock$/, parsePipfileLock], [/(^|\/)poetry\.lock$/, (t) => parseTomlPackages(t, "PyPI")], [/(^|\/)composer\.lock$/, parseComposerLock],
+  [/(^|\/)go\.mod$/, parseGoMod], [/(^|\/)Cargo\.lock$/, (t) => parseTomlPackages(t, "crates.io")], [/(^|\/)Gemfile\.lock$/, parseGemfileLock],
+];
+const UNSUPPORTED = /(^|\/)(pom\.xml|build\.gradle(\.kts)?|packages\.config|pubspec\.yaml|mix\.exs)$|\.csproj$/;
+
+/** @param {string} root @param {string[]} files chemins relatifs « / » @returns {Promise<{ deps: Dep[], sources: string[], unsupported: string[] }>} */
+export async function readDeps(root, files) {
+  const set = new Set(files);
+  const manifests = files.filter((f) => PARSERS.some(([re]) => re.test(f)) && !(f.endsWith("package.json") && set.has(f.replace(/package\.json$/, "package-lock.json")))).slice(0, MAX_MANIFESTS);
+  /** @type {Map<string, Dep>} */ const seen = new Map();
+  for (const f of manifests) {
+    const text = (await fs.readFile(path.join(root, f), "utf8").catch(() => "")).slice(0, 5_000_000);
+    for (const d of (PARSERS.find(([re]) => re.test(f))?.[1] ?? (() => []))(text)) seen.set(`${d.ecosystem}|${d.name}|${d.version}`, d);
+  }
+  return { deps: [...seen.values()].slice(0, MAX_DEPS), sources: manifests, unsupported: files.filter((f) => UNSUPPORTED.test(f)).slice(0, 5) };
+}
+// MODULE_COMPLETE

package/src/engine/det-builders-1.js

@@ -0,0 +1,38 @@
+// src/engine/det-builders-1.js — Builders déterministes : personas + contraintes.
+import { getRules } from "../rules/rules-registry.js";
+
+// (a) Personas : un par rôle, mandate = première règle du domaine du rôle.
+/** @param {{ key: string, label: string, roles: string[], regles: string[], contraintes: string[], failles: string[] }[]} domains @returns {{ role_name: string, scope: string, mandate: string }[]} */
+export function buildPersonas(domains) {
+  const personas = [];
+  for (const d of domains) {
+    for (const role of d.roles) {
+      personas.push({
+        role_name: role,
+        scope: `${d.label} — périmètre projet`,
+        mandate: d.regles[0] || "Respecter la doctrine métier ; refuser tout shortcut non conforme.",
+      });
+    }
+  }
+  return personas;
+}
+
+// (b) Contraintes : textes (contraintes) + invariants (règles), enrichis des
+// patterns d'extraction par domaine.
+/** @param {{ key: string, label: string, regles: string[], contraintes: string[] }[]} domains @param {string[]} keys @returns {DomainConstraint[]} */
+export function buildConstraints(domains, keys) {
+  /** @type {DomainConstraint[]} */
+  const constraints = [];
+  for (const d of domains) {
+    d.contraintes.forEach((c, i) => {
+      constraints.push({ text: c, invariant: d.regles[i] || d.regles[0] || "", patterns: [] });
+    });
+  }
+  for (const k of keys) {
+    for (const c of (getRules().patterns[k]?.constraints || [])) {
+      if (!constraints.some((x) => x.text === c.text)) constraints.push({ ...c });
+    }
+  }
+  return constraints;
+}
+// MODULE_COMPLETE

package/src/engine/det-builders-2.js

@@ -0,0 +1,50 @@
+// src/engine/det-builders-2.js — Builders déterministes : failles + glossaire + impact.
+import { getRules } from "../rules/rules-registry.js";
+import { defaultSteps } from "./default-steps.js";
+import { computeImpact } from "./compute-impact.js";
+import { riskLevel } from "./mission-helpers.js";
+
+// (c) Failles : never (failles) + always (règles), enrichies des patterns.
+/** @param {{ key: string, regles: string[], failles: string[] }[]} domains @param {string[]} keys @returns {DomainPitfall[]} */
+export function buildPitfalls(domains, keys) {
+  /** @type {DomainPitfall[]} */
+  const pitfalls = [];
+  for (const d of domains) {
+    d.failles.forEach((f, i) => {
+      pitfalls.push({ never: f, always: d.regles[i] || d.regles[0] || "", patterns: [] });
+    });
+  }
+  for (const k of keys) {
+    for (const p of (getRules().patterns[k]?.pitfalls || [])) {
+      if (!pitfalls.some((x) => x.never === p.never)) pitfalls.push({ ...p });
+    }
+  }
+  return pitfalls;
+}
+
+// (d) Glossaire : termes exacts par domaine détecté.
+/** @param {string[]} keys @returns {GlossaryEntry[]} */
+export function buildGlossary(keys) {
+  /** @type {GlossaryEntry[]} */
+  const glossary = [];
+  for (const k of keys) {
+    for (const g of (getRules().glossary[k] || [])) {
+      if (!glossary.some((x) => x.term === g.term)) glossary.push({ ...g });
+    }
+  }
+  return glossary;
+}
+
+// (e) Impact : fichiers, étapes, tokens, risque.
+/** @param {string[]} keys @param {{ domains: { roles: string[], regles: string[], contraintes: string[], failles: string[] }[], roles: string[], regles: string[], contraintes: string[], failles: string[], fiches: string[] }} matrix @returns {{ files: string[], steps: string[], tokens: number, risk: string }} */
+export function buildImpact(keys, matrix) {
+  const imp = computeImpact(matrix);
+  const files = keys.flatMap((k) => [`src/${k}/schema.sql`, `src/${k}/service.js`]).slice(0, imp.fichiers);
+  return {
+    files: files.length ? files : ["src/main.js"],
+    steps: [...defaultSteps()],
+    tokens: imp.tokens,
+    risk: riskLevel(keys),
+  };
+}
+// MODULE_COMPLETE

package/src/engine/detect-domains.js

@@ -0,0 +1,27 @@
+// src/engine/detect-domains.js — Détection des domaines mobilisés + mapping slugs doctrine.
+import { keywordRegex } from "./domain-regex.js";
+import { getRules } from "../rules/rules-registry.js";
+
+// Détecte les domaines mobilisés par un besoin (toujours au moins le domaine de repli).
+/** @param {string} needText @returns {string[]} */
+export function detectDomains(needText) {
+  const t = String(needText || "").toLowerCase();
+  const domains = getRules().domains;
+  const matched = Object.keys(domains).filter((k) => {
+    if (k === "logiciel_generique") return false; // repli géré séparément
+    return domains[k].keywords.some((kw) => keywordRegex(kw).test(t));
+  });
+  if (matched.length === 0) return ["logiciel_generique"];
+  return matched;
+}
+
+// Mappe les domaines vers les slugs de fiches de doctrine (dédupliqués, présents au catalogue).
+/** @param {string[]} domainKeys @returns {string[]} */
+export function mapDomainsToSlugs(domainKeys) {
+  const slugs = new Set();
+  for (const k of domainKeys) {
+    for (const s of getRules().domains[k].fiches || []) slugs.add(s);
+  }
+  return [...slugs];
+}
+// MODULE_COMPLETE

package/src/engine/diff-files.js

@@ -0,0 +1,35 @@
+// src/engine/diff-files.js — Patch (Unified Diff) découpé PAR FICHIER, recomposé, et fusion ciblée d'un correctif. Pur, sans I/O.
+
+/** @param {string} line @returns {string} */
+const cleanPath = (line) => line.slice(4).split("\t")[0].trim().replace(/^[ab]\//, "");
+
+/** @param {string} patch @returns {DiffSection[]} */
+export function splitDiff(patch) {
+  /** @type {{ lines: string[], minus: string, plus: string }[]} */
+  const raw = [];
+  /** @type {{ lines: string[], minus: string, plus: string } | null} */ let cur = null;
+  for (const line of String(patch).split("\n")) {
+    const fresh = line.startsWith("diff ") || (line.startsWith("--- ") && (!cur || cur.minus !== ""));
+    if (fresh) { cur = { lines: [], minus: "", plus: "" }; raw.push(cur); }
+    if (!cur) continue;
+    if (line.startsWith("--- ")) cur.minus = cleanPath(line);
+    else if (line.startsWith("+++ ")) cur.plus = cleanPath(line);
+    cur.lines.push(line);
+  }
+  return raw.filter((r) => r.minus || r.plus).map((r) => {
+    const added = r.lines.filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1));
+    const removed = r.lines.filter((l) => l.startsWith("-") && !l.startsWith("---")).length;
+    return { path: r.plus && r.plus !== "/dev/null" ? r.plus : r.minus, text: r.lines.join("\n"), added, changed: added.length + removed };
+  });
+}
+
+/** @param {DiffSection[]} sections @returns {string} */
+export const joinDiff = (sections) => sections.map((s) => s.text).join("\n");
+
+/** Remplace, dans `base`, les fichiers de `paths` par leur version corrigée ; null si le correctif n'en contient aucun. */
+/** @param {DiffSection[]} base @param {string} corrected @param {Set<string>} paths @returns {string | null} */
+export function mergeDiff(base, corrected, paths) {
+  const fixes = new Map(splitDiff(corrected).filter((s) => paths.has(s.path)).map((s) => [s.path, s.text]));
+  return fixes.size === 0 ? null : base.map((s) => fixes.get(s.path) ?? s.text).join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/doc-suite.js

@@ -0,0 +1,39 @@
+// src/engine/doc-suite.js — Socle partagé du trio documentaire client (anti-
+// redondance : noms de fichiers, écriture atomique et en-tête de mission vivent
+// ICI, une seule fois — les 3 générateurs ne dupliquent aucune logique commune).
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+
+// Source unique de vérité des noms — aucun générateur n'en durcode un autre.
+/** @type {{ readme: string, architecture: string, runbook: string }} */
+export const DOC_FILES = {
+  readme: "README.md",
+  architecture: "GUIDE_ARCHITECTURE_CODE.md",
+  runbook: "RUNBOOK.md",
+};
+
+// Écrit (ou met à jour) UN document client : tmp entropie + rename (atomique).
+/** @param {string} projectPath @param {string} name @param {string} content @returns {Promise<void>} */
+export async function writeDoc(projectPath, name, content) {
+  const file = path.join(projectPath, name);
+  const tmp = `${file}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+  await fs.writeFile(tmp, content, "utf8");
+  try { await fs.rename(tmp, file); }
+  catch { await fs.writeFile(file, content, "utf8"); await fs.rm(tmp, { force: true }); }
+}
+
+// En-tête commun des 3 documents (projet, mission, run, progression, date).
+/** @param {string} title @param {AutoState} state @param {MissionPlan | null} mission @returns {string} */
+export function docHeader(title, state, mission) {
+  const done = state.tasks.filter((t) => t.status === "done").length;
+  const name = (mission && mission.projectName) || path.basename(state.projectPath);
+  return [
+    `# ${title}`, "",
+    `- **Projet** : ${name}`,
+    `- **Mission** : ${(mission && mission.need) || "—"}`,
+    `- **Run Auto** : \`${state.runId}\` — ${done}/${state.tasks.length} tâches — statut \`${state.status}\``,
+    `- **Généré le** : ${new Date().toISOString()} par PipCode (mise à jour automatique)`, "",
+  ].join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/doctrine-prefix.js

@@ -0,0 +1,13 @@
+// src/engine/doctrine-prefix.js — La doctrine (stable d'un appel à l'autre) est envoyée EN TÊTE de la requête, comme préfixe de cache, avant tout ce qui change (fichier, diagnostic, code) :
+// le fournisseur la réutilise au lieu de la retraiter à chaque tâche. Même texte, même consigne, autre ordre. Phases d'analyse et de patch (communes au mode solo et à l'orchestration).
+export const ANALYSIS_DOCTRINE = "Doctrine (règles absolues à vérifier strictement):\n";
+export const PATCH_DOCTRINE = "Doctrine (règles absolues à respecter dans le patch):\n";
+/** Rappel final : la doctrine est loin devant le code, on la rappelle en une ligne à la fin de la requête. */
+export const DOCTRINE_REMINDER = "Rappel : applique strictement la doctrine fournie en tête de cette requête.";
+
+/** @param {string} label @param {string} doctrine @param {string} [missionCtx] @returns {string} préfixe = doctrine (globale) puis mission (propre à la mission) */
+export function cachePrefixOf(label, doctrine, missionCtx = "") {
+  const rules = (doctrine || "").trim();
+  return [rules ? label + rules : "", (missionCtx || "").trim()].filter(Boolean).join("\n\n");
+}
+// MODULE_COMPLETE