pipcode 0.0.0-stage → 2.1.0

package/src/net/proxy-env.js

@@ -0,0 +1,59 @@
+// src/net/proxy-env.js — Support des proxys d'entreprise (Point bloquant #3).
+// Node fetch (undici) ignore HTTP_PROXY par défaut ; l'indicateur natif
+// NODE_USE_ENV_PROXY (Node ≥ 24) n'est lu qu'AU DÉMARRAGE du process. Si un
+// proxy est détecté (variables standards ou variantes npm_config_*), le process
+// se relance donc lui-même avec l'env augmentée — execFile sur process.execPath,
+// jamais de shell. Garde anti-boucle PLUGCTO_PROXY_BOOT ; best-effort total.
+
+import { execFileSync } from "node:child_process";
+
+/** @typedef {Error & { code?: string, status?: number }} NodeErr */
+/** @typedef {{ env?: NodeJS.ProcessEnv, nodeMajor?: number, execPath?: string, argv?: string[], spawnTool?: (execPath: string, argv: string[], env: NodeJS.ProcessEnv) => void, exit?: (code: number) => void, warn?: (msg: string) => void }} ProxyOpts */
+
+// Config proxy normalisée : variables standards + variantes npm. null si aucun.
+/** @param {NodeJS.ProcessEnv} [env] @returns {{ http: string, https: string, noProxy: string } | null} */
+export function activeProxyConfig(env = process.env) {
+  const http = env.HTTP_PROXY || env.http_proxy || env.npm_config_proxy || "";
+  const https = env.HTTPS_PROXY || env.https_proxy || env.npm_config_https_proxy || http;
+  const noProxy = env.NO_PROXY || env.no_proxy || env.npm_config_noproxy || "";
+  if (!http && !https) return null;
+  return { http, https, noProxy };
+}
+
+// Relance synchrone de soi-même (stdio hérités : remplacement transparent).
+/** @param {string} execPath @param {string[]} argv @param {NodeJS.ProcessEnv} env @returns {void} */
+function relaunchSync(execPath, argv, env) {
+  execFileSync(execPath, argv, { stdio: "inherit", env });
+}
+
+// Active le support proxy par auto-relance unique. Retourne true si une relance
+// a été engagée. Gardes : aucun proxy, déjà amorcé (anti-boucle), Node < 24.
+/** @param {ProxyOpts} [opts] @returns {boolean} */
+export function ensureProxySupport(opts = {}) {
+  const env = opts.env || process.env;
+  const warn = opts.warn || console.error;
+  const exit = opts.exit || process.exit;
+  const cfg = activeProxyConfig(env);
+  if (!cfg || env.PLUGCTO_PROXY_BOOT || env.NODE_USE_ENV_PROXY === "1") return false;
+  const nodeMajor = opts.nodeMajor ?? Number(process.versions.node.split(".")[0]);
+  if (nodeMajor < 24) {
+    warn(`[pipcode] Proxy détecté mais Node ${nodeMajor}.x ne lit pas NODE_USE_ENV_PROXY (Node ≥ 24 requis) — appels réseau en direct.`);
+    return false;
+  }
+  const childEnv = { ...env, HTTP_PROXY: cfg.http, HTTPS_PROXY: cfg.https, NO_PROXY: cfg.noProxy,
+    NODE_USE_ENV_PROXY: "1", PLUGCTO_PROXY_BOOT: "1" };
+  try {
+    const spawn = opts.spawnTool || relaunchSync;
+    const execPath = opts.execPath || process.execPath;
+    const argv = opts.argv || process.argv.slice(1);
+    spawn(execPath, argv, childEnv);
+  } catch (err) {
+    const e = /** @type {NodeErr} */ (err);
+    if (typeof e.status === "number") { exit(e.status || 1); return true; }
+    warn(`[pipcode] Relance proxy impossible (${e.message}) — appels réseau en direct.`);
+    return false;
+  }
+  exit(0); // l'enfant a terminé (code 0) : le parent reflète puis s'arrête.
+  return true;
+}
+// MODULE_COMPLETE

package/src/project-memory/batches.js

@@ -0,0 +1,17 @@
+// src/project-memory/batches.js — Découpage SANS PERTE d'un texte plus grand que la fenêtre du modèle : parties successives sur des
+// fins de ligne (la concaténation des parties redonne exactement le texte). Aucun résumé, aucune troncature.
+
+/** Coupe un texte en morceaux ≤ max caractères, sur des fins de ligne (une ligne géante dépasse max seule : jamais coupée). @param {string} text @param {number} max @returns {Array<{ text: string, fromLine: number }>} */
+export function splitLossless(text, max) {
+  if (text.length <= max) return [{ text, fromLine: 1 }];
+  const out = [];
+  let cur = ""; let from = 1; let line = 1;
+  for (const l of text.split(/(?<=\n)/)) {
+    if (cur && cur.length + l.length > max) { out.push({ text: cur, fromLine: from }); cur = ""; from = line; }
+    cur += l; line++;
+  }
+  if (cur) out.push({ text: cur, fromLine: from });
+  return out;
+}
+
+// MODULE_COMPLETE

package/src/project-memory/cahiers.js

@@ -0,0 +1,42 @@
+// src/project-memory/cahiers.js — Cahiers de la mémoire projet (UI/UX, fonctionnalités, architecture, infrastructure, vision,
+// général) : sections balisées <!-- vcto:section id sources --> ... <!-- /vcto:section -->. Chaque section cite les fichiers
+// sources avec leur empreinte : si un source change, la section est signalée PÉRIMÉE (jamais supprimée, jamais présentée comme
+// à jour). Une section COMPLÈTE le code, elle ne le remplace pas. Pur.
+
+/** @typedef {{ id: string, sources: Array<{ path: string, sha: string }>, body: string }} Section */
+
+export const CAHIERS = ["architecture", "fonctionnalites", "vision-objectifs", "cahier-general", "ui-ux", "infrastructure"];
+const SECTION_RE = /<!-- vcto:section id="([a-z0-9-]+)" sources="([^"]*)" -->\n([\s\S]*?)\n<!-- \/vcto:section -->/g;
+
+/** En-tête d'un fichier cahier neuf. @param {string} c @returns {string} */
+export const headerOf = (c) => `# Mémoire projet — ${c}
+
+> Généré par PipCode. Chaque section cite ses sources (empreinte) : une section dont un source a changé est PÉRIMÉE. Les décisions de l'utilisateur priment et ne sont jamais écrasées. Le code reste la référence.
+`;
+
+/** @param {Section} s @returns {string} */
+export function formatSection(s) {
+  const src = s.sources.map((x) => `${x.path}@${x.sha.slice(0, 12)}`).join(",");
+  return `<!-- vcto:section id="${s.id}" sources="${src}" -->\n${s.body.trim()}\n<!-- /vcto:section -->`;
+}
+
+/** @param {string} md @returns {Section[]} */
+export function parseSections(md) {
+  return [...md.matchAll(SECTION_RE)].map((m) => ({
+    id: m[1], body: m[3],
+    sources: m[2].split(",").filter(Boolean).map((x) => { const i = x.lastIndexOf("@"); return { path: x.slice(0, i), sha: x.slice(i + 1) }; }),
+  }));
+}
+
+/** Remplace la section de même id, sinon l'ajoute (le reste du fichier est conservé tel quel). @param {string} md @param {Section} s @returns {string} */
+export function upsertSection(md, s) {
+  const block = formatSection(s);
+  const re = new RegExp(`<!-- vcto:section id="${s.id}" sources="[^"]*" -->\n[\\s\\S]*?\n<!-- /vcto:section -->`);
+  return re.test(md) ? md.replace(re, () => block) : `${md.trimEnd()}\n\n${block}\n`;
+}
+
+/** Ids des sections dont un source a changé ou disparu. @param {Section[]} sections @param {import("./index-build.js").MemoryIndex} index @returns {string[]} */
+export function staleSections(sections, index) {
+  return sections.filter((s) => s.sources.some((x) => !index.files[x.path] || !index.files[x.path].sha.startsWith(x.sha))).map((s) => s.id);
+}
+// MODULE_COMPLETE

package/src/project-memory/decision-settle.js

@@ -0,0 +1,15 @@
+// src/project-memory/decision-settle.js — Verdict de l'utilisateur sur une proposition de PipCode (« ok », « je valide » / refus ou correction) : la décision « à confirmer »
+// devient « confirmée » ou « refusée ». Un refus garde les mots EXACTS de l'utilisateur pour que la proposition écartée ne soit jamais refaite (cahier des charges).
+import { CAHIERS } from "./cahiers.js";
+import { readMemoryFile, writeMemoryFile } from "./store.js";
+import { parseDecisions, recordDecision } from "./decisions.js";
+
+/** @param {string} root @param {string} cahier @param {"confirme" | "refuse"} verdict @param {string} userMessage @returns {Promise<void>} */
+export async function settleDecision(root, cahier, verdict, userMessage) {
+  if (!CAHIERS.includes(cahier)) return;
+  const md = (await readMemoryFile(root, `${cahier}.md`)) ?? "";
+  const open = parseDecisions(md).filter((d) => d.status === "a-confirmer").pop();
+  if (open) await writeMemoryFile(root, `${cahier}.md`, md.replace(`id="${open.id}" source="vcto" status="a-confirmer"`, `id="${open.id}" source="vcto" status="${verdict}"`));
+  if (verdict === "refuse") await recordDecision(root, cahier, { source: "utilisateur", status: "refuse", question: open ? `Proposition écartée : ${open.answer}` : "Proposition écartée par l'utilisateur", answer: userMessage });
+}
+// MODULE_COMPLETE

package/src/project-memory/decisions.js

@@ -0,0 +1,36 @@
+// src/project-memory/decisions.js — Décisions de l'UTILISATEUR (et choix proposés par PipCode) dans les cahiers : sections balisées
+// <!-- vcto:decision ... -->, textes conservés TELS QUELS (aucun résumé). Elles priment sur le code, ne sont jamais écrasées par la
+// mémoire générée, jamais périmées. Un choix de PipCode est « a-confirmer » avec son estimation de réussite (estimation, pas mesure).
+// Les balises présentes dans les textes sont neutralisées (un utilisateur ne peut pas forger une section). Pur + écriture via store.
+
+import { createHash } from "node:crypto";
+import { CAHIERS, headerOf } from "./cahiers.js";
+import { readMemoryFile, writeMemoryFile } from "./store.js";
+
+/** @typedef {{ source: "utilisateur" | "vcto", status: "confirme" | "a-confirmer" | "refuse", confidence?: number, question: string, answer: string }} Decision */
+const RE = /<!-- vcto:decision id="([a-f0-9]+)" source="(utilisateur|vcto)" status="(confirme|a-confirmer|refuse)" confidence="(\d*)" -->\n### Question\n([\s\S]*?)\n### Réponse\n([\s\S]*?)\n<!-- \/vcto:decision -->/g;
+
+/** @param {string} s @returns {string} */
+const safe = (s) => String(s).replace(/<!--/g, "&lt;!--").replace(/-->/g, "--&gt;").replace(/^### /gm, "#### ").replace(/\r\n/g, "\n").trim();
+/** @param {Decision} d @returns {string} */
+export const decisionId = (d) => createHash("sha256").update(`${d.source}\n${d.question}\n${d.answer}`).digest("hex").slice(0, 10);
+
+/** @param {Decision} d @returns {string} */
+export function formatDecision(d) {
+  const conf = Number.isInteger(d.confidence) && /** @type {number} */ (d.confidence) >= 0 && /** @type {number} */ (d.confidence) <= 100 ? String(d.confidence) : "";
+  return `<!-- vcto:decision id="${decisionId(d)}" source="${d.source}" status="${d.status}" confidence="${conf}" -->\n### Question\n${safe(d.question)}\n### Réponse\n${safe(d.answer)}\n<!-- /vcto:decision -->`;
+}
+
+/** @param {string} md @returns {Array<Decision & { id: string }>} */
+export function parseDecisions(md) {
+  return [...md.matchAll(RE)].map((m) => ({ id: m[1], source: /** @type {Decision["source"]} */ (m[2]), status: /** @type {Decision["status"]} */ (m[3]), confidence: m[4] ? Number(m[4]) : undefined, question: m[5], answer: m[6] }));
+}
+
+/** Enregistre (idempotent : même contenu = même id, pas de doublon) dans le cahier ; cahier inconnu = erreur typée. @param {string} root @param {string} cahier @param {Decision} d @returns {Promise<void>} */
+export async function recordDecision(root, cahier, d) {
+  if (!CAHIERS.includes(cahier)) throw new Error(`Cahier inconnu : ${cahier}`);
+  const md = (await readMemoryFile(root, `${cahier}.md`)) ?? headerOf(cahier);
+  if (parseDecisions(md).some((x) => x.id === decisionId(d))) return;
+  await writeMemoryFile(root, `${cahier}.md`, `${md.trimEnd()}\n\n${formatDecision(d)}\n`);
+}
+// MODULE_COMPLETE

package/src/project-memory/index-build.js

@@ -0,0 +1,35 @@
+// src/project-memory/index-build.js — Carte EXACTE du projet (déterministe, sans LLM, sans perte) : par fichier, empreinte
+// sha256, taille, nombre de lignes, symboles déclarés AVEC leur ligne, imports résolus. C'est l'inventaire de ce qui existe ;
+// il ne remplace jamais le code (le chat recharge le source exact).
+
+import { createHash } from "node:crypto";
+import { parseFile } from "../engine/code-graph.js";
+import { declarations } from "../engine/code-decls.js";
+import { safeRead } from "../engine/context-files.js";
+
+/** @typedef {{ sha: string, bytes: number, lines: number, symbols: Array<{ name: string, line: number }>, imports: Array<{ to: string, names: string[] }> }} FileEntry */
+/** @typedef {{ version: 1, files: Record<string, FileEntry> }} MemoryIndex */
+
+/** @param {string} root @param {string[]} paths @returns {Promise<MemoryIndex>} */
+export async function buildIndex(root, paths) {
+  const known = new Set(paths);
+  /** @type {Record<string, FileEntry>} */ const files = {};
+  for (const p of paths) {
+    const text = await safeRead(root, p);
+    if (text === null) continue;
+    files[p] = {
+      sha: createHash("sha256").update(text).digest("hex"), bytes: Buffer.byteLength(text), lines: text.split("\n").length,
+      symbols: declarations(p, text), imports: parseFile(p, text, known).imports,
+    };
+  }
+  return { version: 1, files };
+}
+
+/** Écarts entre deux cartes : fichiers ajoutés, modifiés (empreinte différente), supprimés. @param {MemoryIndex | null} prev @param {MemoryIndex} next @returns {{ added: string[], changed: string[], removed: string[] }} */
+export function diffIndex(prev, next) {
+  const before = prev ? prev.files : {};
+  const added = Object.keys(next.files).filter((f) => !before[f]);
+  const changed = Object.keys(next.files).filter((f) => before[f] && before[f].sha !== next.files[f].sha);
+  return { added, changed, removed: Object.keys(before).filter((f) => !next.files[f]) };
+}
+// MODULE_COMPLETE

package/src/project-memory/memory-build.js

@@ -0,0 +1,16 @@
+// src/project-memory/memory-build.js — Carte exacte du projet écrite dans .pipcode/memoire/index.json (gratuit : aucun LLM,
+// aucun réseau). Retourne aussi les écarts depuis la carte précédente (ajoutés / modifiés / supprimés).
+
+import { listProjectFiles } from "../auto/project-files.js";
+import { NOISE_FILE } from "../engine/context-files.js";
+import { buildIndex, diffIndex } from "./index-build.js";
+import { readIndex, writeMemoryFile } from "./store.js";
+
+/** @param {string} root @returns {Promise<{ index: import("./index-build.js").MemoryIndex, diff: ReturnType<typeof diffIndex> }>} */
+export async function indexProject(root) {
+  const paths = (await listProjectFiles(root)).filter((f) => !NOISE_FILE.test(f)).sort();
+  const [prev, index] = [await readIndex(root), await buildIndex(root, paths)];
+  await writeMemoryFile(root, "index.json", JSON.stringify(index, null, 1));
+  return { index, diff: diffIndex(prev, index) };
+}
+// MODULE_COMPLETE

package/src/project-memory/memory-tags.js

@@ -0,0 +1,40 @@
+// src/project-memory/memory-tags.js — Mémoire écrite DANS la réponse de l'IA (une seule requête, aucun second appel) : bloc
+// [[vcto:memory cahier="architecture" sources="src/a.js,src/b.js"]]contenu[[/vcto:memory]]. Le moteur l'extrait, l'enregistre
+// comme section du cahier (sources = fichiers RÉELS de la carte, empreintes figées) et le RETIRE du texte montré à l'utilisateur.
+// Sortie du modèle = donnée non fiable : cahier connu, sources existantes (≤ 20), contenu borné.
+
+import { createHash } from "node:crypto";
+import { CAHIERS, headerOf, upsertSection } from "./cahiers.js";
+import { readIndex, readMemoryFile, writeMemoryFile } from "./store.js";
+
+const TAG = /\[\[vcto:memory\s+cahier="([a-z-]+)"\s+sources="([^"]{1,2000})"\s*\]\]([\s\S]*?)\[\[\/vcto:memory\]\]/g;
+const MAX_BODY = 20_000;
+const MAX_SOURCES = 20;
+
+/** @param {string} raw @returns {{ visible: string, items: Array<{ cahier: string, sources: string[], body: string }> }} */
+export function parseMemoryTags(raw) {
+  /** @type {Array<{ cahier: string, sources: string[], body: string }>} */ const items = [];
+  const visible = String(raw).replace(TAG, (_m, cahier, src, body) => {
+    const text = String(body).trim();
+    if (CAHIERS.includes(cahier) && text && text.length <= MAX_BODY) items.push({ cahier, sources: String(src).split(",").map((s) => s.trim()).filter(Boolean).slice(0, MAX_SOURCES), body: text });
+    return "";
+  });
+  return { visible: visible.replace(/\n{3,}/g, "\n\n").trim(), items };
+}
+
+/** Enregistre les sections valides (sources présentes dans la carte) ; retourne les ids écrits. @param {string} root @param {Array<{ cahier: string, sources: string[], body: string }>} items @returns {Promise<string[]>} */
+export async function recordMemory(root, items) {
+  const index = await readIndex(root);
+  if (!index) return [];
+  const written = [];
+  for (const it of items) {
+    const known = [...new Set(it.sources)].filter((p) => Object.hasOwn(index.files, p));
+    if (known.length === 0) continue;
+    const id = `${it.cahier}-m${createHash("sha256").update([...known].sort().join("\n")).digest("hex").slice(0, 8)}`;
+    const md = (await readMemoryFile(root, `${it.cahier}.md`)) ?? headerOf(it.cahier);
+    await writeMemoryFile(root, `${it.cahier}.md`, upsertSection(md, { id, sources: known.map((path) => ({ path, sha: index.files[path].sha })), body: it.body }));
+    written.push(id);
+  }
+  return written;
+}
+// MODULE_COMPLETE

package/src/project-memory/pending.js

@@ -0,0 +1,24 @@
+// src/project-memory/pending.js — Questions posées à l'utilisateur et pas encore tranchées (.pipcode/memoire/pending.json) :
+// lecture validée (donnée non fiable), au plus MAX questions, une par cahier et par texte. Sert à ne pas reposer la même question
+// et à rattacher la réponse (mots exacts de l'utilisateur) au bon cahier.
+
+import { CAHIERS } from "./cahiers.js";
+import { readMemoryFile, writeMemoryFile } from "./store.js";
+
+const MAX = 6;
+
+/** @param {string} root @returns {Promise<Array<{ cahier: string, text: string }>>} */
+export async function readPending(root) {
+  try {
+    const v = JSON.parse((await readMemoryFile(root, "pending.json")) ?? "[]");
+    return Array.isArray(v) ? v.filter((x) => x && CAHIERS.includes(x.cahier) && typeof x.text === "string" && x.text.length < 2000).slice(0, MAX) : [];
+  } catch { return []; } // fichier corrompu : aucune question en attente
+}
+
+/** @param {string} root @param {Array<{ cahier: string, text: string }>} list @returns {Promise<void>} */
+export async function writePending(root, list) {
+  const seen = new Set();
+  const unique = list.filter((x) => { const k = `${x.cahier}|${x.text}`; return seen.has(k) ? false : (seen.add(k), true); }).slice(-MAX);
+  await writeMemoryFile(root, "pending.json", JSON.stringify(unique, null, 1));
+}
+// MODULE_COMPLETE

package/src/project-memory/qa-apply.js

@@ -0,0 +1,39 @@
+// src/project-memory/qa-apply.js — Applique le dialogue après la réponse de l'IA : la réponse de l'utilisateur est enregistrée
+// MOT POUR MOT (aucun appel modèle de plus) sur la question en attente qu'elle tranche ; un choix « choisis pour moi » est
+// enregistré « à confirmer » avec son estimation ; les nouvelles questions deviennent « en attente ». Retourne le texte à montrer.
+
+import { parseQaTags } from "./qa-tags.js";
+import { readPending, writePending } from "./pending.js";
+import { recordDecision } from "./decisions.js";
+import { settleDecision } from "./decision-settle.js";
+import { parseMemoryTags, recordMemory } from "./memory-tags.js";
+
+/** Texte montré sans aucune balise (repli si l'enregistrement échoue). @param {string} raw @returns {string} */
+export const stripTags = (raw) => parseQaTags(parseMemoryTags(raw).visible).visible;
+
+/** Bloc donné à l'IA : questions en attente (pour ne pas les reposer et reconnaître la réponse). @param {string} root @returns {Promise<string>} */
+export async function pendingBlock(root) {
+  const p = await readPending(root);
+  return p.length ? `--- Questions déjà posées à l'utilisateur, en attente de réponse ---\n${p.map((x) => `[${x.cahier}] ${x.text}`).join("\n")}` : "";
+}
+
+/** @param {string} root @param {string} userMessage @param {string} rawAnswer @returns {Promise<string>} texte visible */
+export async function applyQa(root, userMessage, rawAnswer) {
+  const mem = parseMemoryTags(rawAnswer);
+  await recordMemory(root, mem.items); // mémoire du projet écrite depuis CETTE réponse (aucun autre appel)
+  const { visible, asks, answered, choices, settled } = parseQaTags(mem.visible);
+  let pending = await readPending(root);
+  for (const c of answered) {
+    for (const q of pending.filter((x) => x.cahier === c)) await recordDecision(root, c, { source: "utilisateur", status: "confirme", question: q.text, answer: userMessage });
+    pending = pending.filter((x) => x.cahier !== c);
+  }
+  for (const ch of choices) {
+    const q = pending.find((x) => x.cahier === ch.cahier);
+    await recordDecision(root, ch.cahier, { source: "vcto", status: "a-confirmer", confidence: ch.confidence, question: q ? q.text : userMessage, answer: ch.text });
+    pending = pending.filter((x) => x.cahier !== ch.cahier);
+  }
+  for (const s of settled) await settleDecision(root, s.cahier, s.verdict, userMessage); // « ok / je valide » ou refus : la proposition de PipCode est tranchée
+  await writePending(root, [...pending, ...asks]);
+  return visible;
+}
+// MODULE_COMPLETE

package/src/project-memory/qa-tags.js

@@ -0,0 +1,28 @@
+// src/project-memory/qa-tags.js — Balises de dialogue que l'IA place dans sa réponse : question posée (ask), question tranchée par
+// l'utilisateur (answered, balise vide), choix proposé par PipCode avec estimation de réussite (choice). Le moteur les lit puis les
+// RETIRE du texte montré (le texte intérieur reste visible). Sortie du modèle = donnée non fiable : cahier connu, confiance 0–100.
+
+import { CAHIERS } from "./cahiers.js";
+
+const TAG = /\[\[vcto:(ask|answered|choice|validated|rejected)\s+cahier="([a-z-]+)"(?:\s+confidence="(\d{1,3})")?\s*\]\](?:([\s\S]*?)\[\[\/vcto:\1\]\])?/g;
+
+/** @typedef {{ cahier: string, text: string, confidence?: number }} QaItem */
+
+/** @param {string} raw @returns {{ visible: string, asks: QaItem[], answered: string[], choices: QaItem[], settled: Array<{ cahier: string, verdict: "confirme" | "refuse" }> }} */
+export function parseQaTags(raw) {
+  /** @type {QaItem[]} */ const asks = [];
+  /** @type {QaItem[]} */ const choices = [];
+  /** @type {string[]} */ const answered = [];
+  /** @type {Array<{ cahier: string, verdict: "confirme" | "refuse" }>} */ const settled = [];
+  const visible = String(raw).replace(TAG, (_m, kind, cahier, conf, inner = "") => {
+    const text = String(inner).trim();
+    if (!CAHIERS.includes(cahier)) return text;
+    if (kind === "ask" && text) asks.push({ cahier, text });
+    else if (kind === "answered") answered.push(cahier);
+    else if (kind === "validated" || kind === "rejected") settled.push({ cahier, verdict: kind === "validated" ? "confirme" : "refuse" });
+    else if (kind === "choice" && text) choices.push({ cahier, text, confidence: conf !== undefined && Number(conf) <= 100 ? Number(conf) : undefined });
+    return text;
+  });
+  return { visible: visible.replace(/\n{3,}/g, "\n\n").trim(), asks, answered, choices, settled };
+}
+// MODULE_COMPLETE

package/src/project-memory/recall.js

@@ -0,0 +1,38 @@
+// src/project-memory/recall.js — Rappel de la mémoire pour le chat : sections des cahiers pertinentes pour la question (sources
+// ouvertes, mots de la question), vision/cahier général toujours en tête. Sections ENTIÈRES (jamais coupées) dans un budget ;
+// ce qui ne tient pas est listé, pas perdu. Une section périmée est marquée comme telle.
+
+import { CAHIERS, parseSections, staleSections } from "./cahiers.js";
+import { parseDecisions } from "./decisions.js";
+import { readIndex, readMemoryFile } from "./store.js";
+
+const ANCHORS = ["vision-objectifs", "cahier-general"];
+/** @param {string} q @returns {string[]} */
+const words = (q) => [...new Set(q.toLowerCase().split(/[^\p{L}\p{N}_]+/u).filter((w) => w.length >= 4))];
+
+/** @param {string} root @param {string} question @param {string[]} open @param {number} budget @returns {Promise<{ text: string, omitted: string[] }>} */
+export async function recallSections(root, question, open, budget) {
+  const index = await readIndex(root);
+  const kw = words(question);
+  const items = [];
+  for (const c of CAHIERS) {
+    const md = (await readMemoryFile(root, `${c}.md`)) ?? "";
+    for (const d of parseDecisions(md)) items.push({ score: 1000, label: d.source === "utilisateur" ? `Décision de l'utilisateur (${c})` : `Choix proposé par PipCode, à confirmer (${c}${d.confidence !== undefined ? `, ≈ ${d.confidence} % estimé` : ""})`, body: `Question : ${d.question}
+Réponse : ${d.answer}` });
+    const sections = parseSections(md);
+    const stale = new Set(index ? staleSections(sections, index) : []);
+    for (const s of sections) {
+      const hay = `${s.id} ${s.body}`.toLowerCase();
+      const score = (ANCHORS.includes(c) ? 100 : 0) + s.sources.filter((x) => open.includes(x.path)).length * 5 + kw.filter((w) => hay.includes(w)).length;
+      if (score > 0) items.push({ score, label: `${s.id}${stale.has(s.id) ? " [PÉRIMÉE : un source a changé]" : ""}`, body: s.body });
+    }
+  }
+  const blocks = []; const omitted = []; let used = 0;
+  for (const it of items.sort((a, b) => b.score - a.score)) {
+    const block = `### Mémoire — ${it.label}\n${it.body}`;
+    if (used + block.length > budget) { omitted.push(it.label); continue; }
+    used += block.length; blocks.push(block);
+  }
+  return { text: blocks.join("\n\n"), omitted };
+}
+// MODULE_COMPLETE

package/src/project-memory/store.js

@@ -0,0 +1,37 @@
+// src/project-memory/store.js — Dossier mémoire du projet (.pipcode/memoire/) : lecture VALIDÉE (donnée non fiable : un fichier
+// édité à la main ne doit jamais casser ni détourner) et écriture ATOMIQUE (fichier temporaire puis renommage). Seul ce dossier
+// est écrit ; le nom de fichier est contrôlé (liste fermée / motif sûr), jamais un chemin reçu.
+
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const SAFE_NAME = /^[a-z0-9][a-z0-9-]{0,40}\.(md|json)$/;
+
+/** @param {string} root @returns {string} */
+export const memoryDir = (root) => path.join(root, ".pipcode", "memoire");
+
+/** Lecture d'un fichier mémoire ; null si absent/illisible/nom refusé. @param {string} root @param {string} name @returns {Promise<string | null>} */
+export async function readMemoryFile(root, name) {
+  if (!SAFE_NAME.test(name)) return null;
+  return fs.readFile(path.join(memoryDir(root), name), "utf8").catch(() => null);
+}
+
+/** Écriture atomique ; nom invalide = erreur typée. @param {string} root @param {string} name @param {string} content @returns {Promise<void>} */
+export async function writeMemoryFile(root, name, content) {
+  if (!SAFE_NAME.test(name)) throw new Error(`Nom de fichier mémoire refusé : ${name}`);
+  const dir = memoryDir(root);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path.join(dir, `.${name}.${process.pid}.tmp`);
+  await fs.writeFile(tmp, content, "utf8");
+  await fs.rename(tmp, path.join(dir, name));
+}
+
+/** Carte lue et validée (forme minimale) ; null sinon. @param {string} root @returns {Promise<import("./index-build.js").MemoryIndex | null>} */
+export async function readIndex(root) {
+  const raw = await readMemoryFile(root, "index.json");
+  try {
+    const v = JSON.parse(raw ?? "");
+    return v && v.version === 1 && v.files && typeof v.files === "object" && !Array.isArray(v.files) ? v : null;
+  } catch { return null; } // JSON corrompu : carte considérée absente (reconstruite)
+}
+// MODULE_COMPLETE

package/src/project-memory/window.js

@@ -0,0 +1,13 @@
+// src/project-memory/window.js — Taille de la fenêtre de contexte (en caractères) : PLUGCTO_CONTEXT_CHARS (donnée non fiable :
+// entier borné), sinon valeur par défaut. Le contexte du chat se place dans cette fenêtre (rien n'est coupé en silence).
+
+export const DEFAULT_CONTEXT_CHARS = 120_000;
+const MIN = 4_000; const MAX = 2_000_000;
+
+/** @param {Record<string, string | undefined>} [env] @returns {number} */
+export function contextChars(env = process.env) {
+  const n = Number.parseInt(env.PLUGCTO_CONTEXT_CHARS || "", 10);
+  return Number.isFinite(n) && n >= MIN && n <= MAX ? n : DEFAULT_CONTEXT_CHARS;
+}
+
+// MODULE_COMPLETE

package/src/rules/rules-advisor.js

@@ -0,0 +1,17 @@
+// src/rules/rules-advisor.js — Bloc <ADVISOR_RULES> du lot « pro » servi par le serveur : périmètres que l'utilisateur oublie
+// (comptes, données, argent, sécurité, légal, fiabilité, exploitation, expérience, croissance). Extraction par les balises
+// (structure, aucun texte de règle ici). Non chargé (serveur injoignable, compte gratuit) → "" : jamais de texte inventé.
+import { getRules } from "./rules-registry.js";
+
+const OPEN = "<ADVISOR_RULES>";
+const CLOSE = "</ADVISOR_RULES>";
+
+/** @returns {string} */
+export function advisorRules() {
+  let decomp;
+  try { decomp = getRules().prompts.decomp; } catch { return ""; }
+  const a = decomp.indexOf(OPEN);
+  const b = decomp.indexOf(CLOSE);
+  return a >= 0 && b > a ? decomp.slice(a, b + CLOSE.length) : "";
+}
+// MODULE_COMPLETE

package/src/rules/rules-frugality.js

@@ -0,0 +1,17 @@
+// src/rules/rules-frugality.js — Bloc <FRUGALITY_RULES> (principes de réalisation, en langage clair) du gabarit maître servi par le serveur (lot de base, tous les
+// comptes) : injecté dans le prompt système du chat. Extraction par les balises (structure, pas de texte de règle ici).
+// Règles non chargées (serveur injoignable) → "" : le chat répond sans (jamais de texte de frugalité inventé).
+import { getRules } from "./rules-registry.js";
+
+const OPEN = "<FRUGALITY_RULES>";
+const CLOSE = "</FRUGALITY_RULES>";
+
+/** @returns {string} */
+export function frugalityRules() {
+  let master;
+  try { master = getRules().prompts.master; } catch { return ""; }
+  const a = master.indexOf(OPEN);
+  const b = master.indexOf(CLOSE);
+  return a >= 0 && b > a ? master.slice(a, b + CLOSE.length) : "";
+}
+// MODULE_COMPLETE

package/src/rules/rules-load.js

@@ -0,0 +1,56 @@
+// src/rules/rules-load.js — Chargement des règles métier depuis le serveur PipCode (fiches signées Ed25519,
+// même chemin que la doctrine : essai/licence tranchés par le serveur). Lot « base » obligatoire (comptes
+// gratuits inclus) ; lot « pro » (UX, prompt de patch) : refus 402 = lot absent (le plan reste utilisable),
+// toute autre panne = échec honnête. Mémoire seulement, requête dédupliquée (single-flight).
+
+import { fetchSignedSkill } from "../core/doctrine-fetch.js";
+import { verifySignature } from "../core/crypto.js";
+import { setRules, rulesAreFresh } from "./rules-registry.js";
+import { parseBaseRules, parseProRules } from "./rules-validate.js";
+
+export class RulesUnavailableError extends Error {
+  /** @param {string} message @param {boolean} denied */
+  constructor(message, denied) { super(message); this.name = "RulesUnavailableError"; this.denied = denied; }
+}
+
+/** @param {string} raw @returns {string} */
+const explain = (raw) => (/HTTP 404/.test(raw)
+  ? "Les règles PipCode ne sont pas encore disponibles sur le serveur."
+  : `Le serveur PipCode est injoignable (${raw.slice(0, 140)}). Une connexion est requise.`) + " Aucune requête n'a été envoyée au modèle.";
+
+/** @param {string} slug @param {string} tier @param {PlugConfig} cfg @param {{ fetchSkill: typeof fetchSignedSkill, verify: typeof verifySignature }} d @returns {Promise<string>} */
+async function readBundle(slug, tier, cfg, d) {
+  let payload;
+  try { payload = await d.fetchSkill(slug, tier, cfg); }
+  catch (e) { const m = /** @type {Error} */ (e).message; throw new RulesUnavailableError(explain(m), /HTTP 402/.test(m)); }
+  if (!d.verify(payload.data, payload.sig)) throw new RulesUnavailableError("Signature des règles PipCode INVALIDE : contenu rejeté.", false);
+  /** @type {{ slug?: unknown, content?: unknown }} */ let p = {};
+  try { p = JSON.parse(payload.data); } catch { /* corps illisible : rejeté juste dessous */ }
+  if (p.slug !== slug || typeof p.content !== "string") throw new RulesUnavailableError("Règles PipCode inattendues (fiche vide ou différente).", false);
+  return p.content;
+}
+
+/** @param {PlugConfig} cfg @param {{ fetchSkill: typeof fetchSignedSkill, verify: typeof verifySignature }} d */
+async function load(cfg, d) {
+  // Les deux lots sont demandés EN MÊME TEMPS (avant : l'un après l'autre = deux allers-retours cumulés à chaque message).
+  const baseText = readBundle("rules_base", "lite", cfg, d);
+  const proText = readBundle("rules_pro", "pro", cfg, d);
+  proText.catch(() => undefined); // l'échec du lot pro est traité plus bas ; jamais de rejet non observé si le lot de base échoue d'abord
+  const base = parseBaseRules(await baseText);
+  /** @type {{ ux: EngineRules["ux"], patch: string, decomp: string, control: string, prefix: Record<string, string> | null, scan: ScanRules | null }} */
+  let pro = { ux: { design: {}, universal: [] }, patch: "", decomp: "", control: "", prefix: null, scan: null };
+  try { pro = parseProRules(await proText); }
+  catch (e) { if (!(e instanceof RulesUnavailableError && e.denied)) throw e; }
+  setRules({ domains: base.domains, patterns: base.patterns, glossary: base.glossary, ux: pro.ux, prompts: { analysis: base.analysis, mission: base.mission, patch: pro.patch, master: base.master, decomp: pro.decomp, control: pro.control }, plan: base.plan, pricing: base.pricing, prefix: pro.prefix, scan: pro.scan });
+}
+
+/** @type {Promise<void> | null} */
+let inflight = null;
+
+/** Garantit des règles fraîches en mémoire (réseau seulement si absentes/périmées). @param {PlugConfig} cfg @param {{ fetchSkill?: typeof fetchSignedSkill, verify?: typeof verifySignature }} [deps] @returns {Promise<void>} */
+export function ensureRules(cfg, { fetchSkill = fetchSignedSkill, verify = verifySignature } = {}) {
+  if (rulesAreFresh()) return Promise.resolve();
+  inflight ??= load(cfg, { fetchSkill, verify }).finally(() => { inflight = null; });
+  return inflight;
+}
+// MODULE_COMPLETE

package/src/rules/rules-project.js

@@ -0,0 +1,16 @@
+// src/rules/rules-project.js — Bloc <PROJECT_RULES> du lot « pro » servi par le serveur : type de projet, lieu de mise en ligne (proposé, jamais imposé) et suivi des erreurs en production.
+// Extraction par les balises (structure, aucun texte de règle ici). Non chargé (serveur injoignable, compte gratuit) → "" : jamais de texte inventé.
+import { getRules } from "./rules-registry.js";
+
+const OPEN = "<PROJECT_RULES>";
+const CLOSE = "</PROJECT_RULES>";
+
+/** @returns {string} */
+export function projectRules() {
+  let decomp;
+  try { decomp = getRules().prompts.decomp; } catch { return ""; }
+  const a = decomp.indexOf(OPEN);
+  const b = decomp.indexOf(CLOSE);
+  return a >= 0 && b > a ? decomp.slice(a, b + CLOSE.length) : "";
+}
+// MODULE_COMPLETE

package/src/rules/rules-registry.js

@@ -0,0 +1,32 @@
+// src/rules/rules-registry.js — Registre MÉMOIRE des règles métier servies par le serveur (domaines, UX,
+// prompts d'analyse). Jamais écrit sur disque, jamais embarqué dans le paquet : sans chargement, tout
+// accès échoue par une erreur typée honnête (le moteur ne devine rien). TTL : une licence qui change
+// (essai → Pro) est reprise au rechargement suivant.
+
+export const RULES_TTL_MS = 3_600_000;
+
+export class RulesNotLoadedError extends Error {
+  constructor() {
+    super("Les règles PipCode ne sont pas chargées (connexion au serveur PipCode requise). Aucune requête n'a été envoyée au modèle.");
+    this.name = "RulesNotLoadedError";
+  }
+}
+
+/** @type {EngineRules | null} */
+let current = null;
+let loadedAt = 0;
+
+/** @param {EngineRules} rules @param {number} [now] */
+export function setRules(rules, now = Date.now()) { current = rules; loadedAt = now; }
+
+/** @returns {EngineRules} */
+export function getRules() {
+  if (!current) throw new RulesNotLoadedError();
+  return current;
+}
+
+/** @param {number} [now] @returns {boolean} */
+export const rulesAreFresh = (now = Date.now()) => current !== null && now - loadedAt < RULES_TTL_MS;
+
+export function resetRules() { current = null; loadedAt = 0; }
+// MODULE_COMPLETE

package/src/rules/rules-validate-pricing.js

@@ -0,0 +1,22 @@
+// src/rules/rules-validate-pricing.js — Grille tarifaire servie par le serveur (USD / million de tokens) : forme stricte,
+// nombres finis ≥ 0, taille bornée. Absente → null (le coût reste alors inconnu, jamais supposé). Erreur typée sinon.
+
+const isObj = (/** @type {unknown} */ v) => !!v && typeof v === "object" && !Array.isArray(v);
+const price = (/** @type {unknown} */ v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v < 100_000;
+
+/** @param {unknown} raw @returns {PricingGrid | null} */
+export function parsePricing(raw) {
+  if (raw === undefined) return null;
+  const g = /** @type {{ asOf?: unknown, currency?: unknown, models?: unknown }} */ (raw);
+  const bad = (/** @type {string} */ m) => new Error(`Règles PipCode invalides (grille tarifaire : ${m}).`);
+  if (!isObj(raw) || typeof g.asOf !== "string" || g.asOf.length > 40 || g.currency !== "USD" || !isObj(g.models)) throw bad("forme");
+  const models = /** @type {Record<string, { in?: unknown, out?: unknown, cachedIn?: unknown, cacheWriteIn?: unknown, note?: unknown }>} */ (g.models);
+  const ids = Object.keys(models);
+  if (ids.length > 2000) throw bad("taille");
+  for (const id of ids) {
+    const p = models[id];
+    if (id.length > 200 || !isObj(p) || !price(p.in) || !price(p.out) || (p.cachedIn !== undefined && !price(p.cachedIn)) || (p.cacheWriteIn !== undefined && !price(p.cacheWriteIn)) || (p.note !== undefined && (typeof p.note !== "string" || p.note.length > 60))) throw bad(`modèle ${id.slice(0, 40)}`);
+  }
+  return /** @type {PricingGrid} */ (raw);
+}
+// MODULE_COMPLETE