pipcode 0.0.0-stage → 2.1.0

package/src/cli/target-manual.js

@@ -0,0 +1,24 @@
+// src/cli/target-manual.js — Branche [M] du flux TTY : saisie manuelle des numéros.
+// "1, 3" → cibles valides via parsePicks, ou null si aucune sélection valide.
+
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { parsePicks } from "./target-select.js";
+
+/** @typedef {{ id: string, name: string, path: string, parentExists: boolean, configExists: boolean, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }} IdeConfigEntry */
+
+// [M] : saisie manuelle des numéros → cibles valides, ou null si aucune valide.
+/** @param {IdeConfigEntry[]} detected @returns {Promise<IdeConfigEntry[] | null>} */
+export async function manualSelect(detected) {
+  const rl3 = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const sel = (await rl3.question("  Saisir les numéros (ex: 1, 3) : ")).trim();
+    const targets = parsePicks(sel, detected);
+    if (targets.length === 0) {
+      console.log("\n  ⚠️  Aucun numéro valide saisi. Aucune configuration n'a été écrite.");
+      return null;
+    }
+    return targets;
+  } finally { rl3.close(); }
+}
+// MODULE_COMPLETE

package/src/cli/target-select.js

@@ -0,0 +1,51 @@
+// src/cli/target-select.js — Étape 4 : sélection granulaire Opt-in des cibles IDE.
+// [A] Tout (défaut) | [M] au cas par cas | [Q] Quitter. Seuls les détectés listés.
+// Retourne les cibles, ou null si arrêt (message imprimé). Non-TTY : détectés sinon candidats.
+
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { manualSelect } from "./target-manual.js";
+
+/** @typedef {{ id: string, name: string, path: string, parentExists: boolean, configExists: boolean, schema?: "mcpServers" | "servers" | "context_servers" | "toml" }} IdeConfigEntry */
+
+// Parse "1, 3" → indices valides uniques (filtrage des hors-range).
+/** @param {string} sel @param {IdeConfigEntry[]} detected @returns {IdeConfigEntry[]} */
+export function parsePicks(sel, detected) {
+  const picks = sel
+    .split(/[,\s]+/)
+    .map((s) => parseInt(s, 10))
+    .filter((n) => Number.isInteger(n) && n >= 1 && n <= detected.length);
+  return [...new Set(picks)].map((n) => detected[n - 1]).filter(Boolean);
+}
+
+// Flux TTY : liste les détectés, demande [A]/[M]/[Q], gère la sélection manuelle.
+/** @param {IdeConfigEntry[]} detected @returns {Promise<IdeConfigEntry[] | null>} */
+export async function selectTargetsInteractive(detected) {
+  if (detected.length === 0) {
+    console.log("\n  ℹ️  Aucun environnement IDE détecté sur cette machine.");
+    console.log("      Aucune configuration n'a été écrite. (Installe un IDE supporté puis relance `npx pipcode setup`.)");
+    console.log("\n  ✅ Configuration terminée (rien à écrire).");
+    return null;
+  }
+  console.log("\n  Environnements détectés :");
+  detected.forEach((c, i) => console.log(`    [${i + 1}] ${c.name}`));
+  console.log("\n  [A] Tout installer sur les environnements détectés  ← défaut (Entrée)");
+  console.log("  [M] Sélection au cas par cas (ex: 1, 3)");
+  console.log("  [Q] Quitter sans écrire");
+  const rl2 = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    const choice = (await rl2.question("\n  Choix [A / M / Q] (Entrée = A) : ")).trim().toLowerCase();
+    const norm = choice || "a";
+    if (norm === "q") { console.log("\n  ✋ Aucune configuration n'a été écrite (Q)."); return null; }
+    if (norm === "m") return await manualSelect(detected);
+    return detected; // [A] ou défaut
+  } finally { rl2.close(); }
+}
+
+// Dispatcher : TTY → sélection interactive ; non-TTY → détectés sinon candidats.
+/** @param {IdeConfigEntry[]} detected @param {IdeConfigEntry[]} candidates @param {boolean} isTTY @returns {Promise<IdeConfigEntry[] | null>} */
+export async function selectTargets(detected, candidates, isTTY) {
+  if (isTTY) return selectTargetsInteractive(detected);
+  return detected.length > 0 ? detected : candidates;
+}
+// MODULE_COMPLETE

package/src/cli/toml-merge.js

@@ -0,0 +1,56 @@
+// src/cli/toml-merge.js — Fusion PRUDENTE de l'entrée MCP `pipcode` dans le
+// config.toml de Codex, sans dépendance. On ne sait écrire/retirer QUE nos deux
+// tables ([mcp_servers.plugcto] et sa sous-table .env) : tout le reste du fichier
+// est conservé à l'octet près. Ce n'est pas un parseur TOML complet → fail-safe :
+// un fichier contenant des chaînes multilignes (""" ou ''') est REFUSÉ (jamais de
+// réécriture à l'aveugle). Valeurs échappées en chaînes TOML de base (JSON.stringify
+// produit des échappements TOML valides). Pur (aucun I/O).
+
+const BARE_KEY = /^[A-Za-z0-9_-]+$/;
+const HEADER = /^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(?:#.*)?$/;
+const STARTUP_TIMEOUT_SEC = 30;
+const TOOL_TIMEOUT_SEC = 600; // Mode auto : outils longs (défaut Codex = 60 s)
+
+/** @param {string} s @returns {string} */
+const q = (s) => JSON.stringify(String(s));
+/** @param {string} s @returns {string} */
+const key = (s) => (BARE_KEY.test(s) ? s : q(s));
+
+/** @param {string} text @param {string} name @returns {string} */
+export function stripServerTables(text, name) {
+  if (/"""|'''/.test(text)) {
+    throw new Error("config.toml contient des chaînes multilignes : PipCode ne le modifie pas à l'aveugle. Ajoutez le serveur manuellement (Codex : `codex mcp add`).");
+  }
+  const own = new Set([`mcp_servers.${name}`, `mcp_servers.${name}.env`]);
+  let skipping = false;
+  return text.split("\n").filter((line) => {
+    const m = HEADER.exec(line.replace(/\r$/, ""));
+    if (m) skipping = own.has(m[1].replace(/"/g, "").trim());
+    return !skipping;
+  }).join("\n");
+}
+
+/** @param {string} name @param {{ command: string, args: string[], env?: Record<string, string> }} entry @returns {string} */
+export function renderServerTables(name, entry) {
+  const k = key(name);
+  const lines = [`[mcp_servers.${k}]`, `command = ${q(entry.command)}`, `args = [${entry.args.map(q).join(", ")}]`,
+    `startup_timeout_sec = ${STARTUP_TIMEOUT_SEC}`, `tool_timeout_sec = ${TOOL_TIMEOUT_SEC}`];
+  const env = Object.entries(entry.env || {});
+  if (env.length) lines.push("", `[mcp_servers.${k}.env]`, ...env.map(([n, v]) => `${key(n)} = ${q(v)}`));
+  return lines.join("\n") + "\n";
+}
+
+/** Texte final : ancien bloc PipCode retiré, nouveau bloc ajouté en fin (idempotent). */
+/** @param {string} text @param {string} name @param {{ command: string, args: string[], env?: Record<string, string> }} entry @returns {string} */
+export function mergeToml(text, name, entry) {
+  const base = stripServerTables(text, name).replace(/\s+$/, "");
+  return (base ? base + "\n\n" : "") + renderServerTables(name, entry);
+}
+
+/** Texte sans le bloc PipCode (désinstallation) ; `changed` = un bloc existait. */
+/** @param {string} text @param {string} name @returns {{ text: string, changed: boolean }} */
+export function removeToml(text, name) {
+  const stripped = stripServerTables(text, name);
+  return { text: stripped.replace(/\s+$/, "") + (stripped.trim() ? "\n" : ""), changed: stripped !== text };
+}
+// MODULE_COMPLETE

package/src/cli/trial-check.js

@@ -0,0 +1,15 @@
+// src/cli/trial-check.js — `pipcode trial` : demande au serveur l'état de l'essai et l'écrit en UNE
+// ligne `PLUGCTO_TRIAL <json>` (lue par l'extension VS Code ; lisible par un humain). Aucun secret,
+// aucune écriture. Fin par process.exitCode (jamais process.exit après le réseau : crash Windows).
+
+import { loadConfig } from "../core/config.js";
+import { trialStatus } from "../core/trial-status.js";
+
+export const TRIAL_LINE_PREFIX = "PLUGCTO_TRIAL ";
+
+export async function runTrialCheck() {
+  const status = await trialStatus(await loadConfig());
+  console.log(TRIAL_LINE_PREFIX + JSON.stringify(status));
+  process.exitCode = status.state === "error" ? 1 : 0;
+}
+// MODULE_COMPLETE

package/src/cli/welcome.js

@@ -0,0 +1,7 @@
+// src/cli/welcome.js — Message d'accueil préenregistré (exigence produit :
+// après installation, le plug se présente SANS consommer de token — chaîne
+// statique, jamais générée par un LLM). Jumeau exact de
+// vscode-extension/src/logic.ts (WELCOME_MESSAGE) : modifier les DEUX ensemble.
+
+export const WELCOME_MESSAGE = "🤖 Votre assistant PipCode à votre service — j'écoute votre demande.";
+// MODULE_COMPLETE

package/src/core/abort-signal.js

@@ -0,0 +1,38 @@
+// src/core/abort-signal.js — Disjoncteur d'arrêt du moteur : UN AbortController par processus. L'interface écrit « ABORT » sur l'entrée standard du
+// moteur (un signal d'arrêt n'exécute aucun gestionnaire sous Windows) ; le signal annule les requêtes réseau en cours (appels de modèle), les
+// commandes de vérification (tests) et fait sortir proprement la boucle d'exécution, qui sauvegarde l'état et se met en PAUSE. Actif seulement si
+// l'interface l'a demandé (PLUGCTO_ABORT_CHANNEL=1) : un moteur lancé à la main n'écoute rien.
+import { createInterface } from "node:readline";
+
+export const ABORT_LINE = "ABORT";
+export const CANCELLED_MARK = "@@VCTO_CANCELLED@@";
+const controller = new AbortController();
+
+/** Signal unique du processus (annule fetch / execFile). */
+export const runSignal = controller.signal;
+export const isRunAborted = () => controller.signal.aborted;
+export const abortRun = () => controller.abort();
+
+/** Erreur typée : l'utilisateur a demandé l'arrêt (jamais traitée comme une panne). */
+export class RunAbortedError extends Error {
+  constructor() { super("Exécution interrompue par l'utilisateur."); this.name = "RunAbortedError"; this.code = "aborted"; }
+}
+
+/** Relie un AbortController local (un appel réseau) au signal du processus. @param {AbortController} local */
+export function linkAbort(local) {
+  if (controller.signal.aborted) local.abort();
+  else controller.signal.addEventListener("abort", () => local.abort(), { once: true });
+}
+
+/** Écoute « ABORT » sur l'entrée standard ; ne retient pas le processus. @param {NodeJS.ReadableStream} [input] @param {boolean} [enabled] @returns {boolean} */
+export function listenForAbort(input = process.stdin, enabled = process.env.PLUGCTO_ABORT_CHANNEL === "1") {
+  if (!enabled) return false;
+  createInterface({ input }).on("line", (line) => {
+    if (line.trim() !== ABORT_LINE || controller.signal.aborted) return;
+    process.stderr.write(`${CANCELLED_MARK}\n`); // repère lisible par l'interface même si le moteur sort par une erreur
+    abortRun();
+  });
+  /** @type {{ unref?: () => void }} */ (input).unref?.();
+  return true;
+}
+// MODULE_COMPLETE

package/src/core/auto-deps.js

@@ -0,0 +1,29 @@
+// src/core/auto-deps.js — Auto Mode : factory de dépendances (réutilisée par
+// le dispatch MCP et le shell CLI bin/setup.js). Centralise le binding des
+// helpers → auto.js reste autonome (aucun import d'index.js, zéro cycle) et
+// testable avec mocks.
+import { ANALYSIS_MAX_TOKENS, patchMaxTokens } from "./constants.js";
+import { callLLM } from "./llm-call.js";
+import { loadDoctrine } from "./doctrine.js";
+import { loadAllDoctrine } from "./doctrine-all.js";
+import { orchestrateLLM } from "../engine/orchestrator.js";
+import { parseJsonLoose } from "../engine/parse-json-loose.js";
+import { loadAstRuntime } from "../engine/ast-runtime.js";
+import { checkMissionGuard } from "../engine/mission-guard.js";
+import { scanPatchForViolations } from "../engine/patch-scan.js";
+import { missionContextPrefix } from "../engine/mission-context-prefix.js";
+import { computeImpact } from "../engine/compute-impact.js";
+import { extractMission } from "../engine/extract-llm.js";
+import { readMissionContext, writeMission } from "../engine/mission-store.js";
+import { logIteration } from "../engine/mission-log.js";
+
+export function createAutoDeps() {
+  return {
+    orchestrateLLM, callLLM, loadDoctrine, loadAllDoctrine,
+    checkMissionGuard, scanPatchForViolations, missionContextPrefix,
+    computeImpact, extractMission, readMissionContext, writeMission, logIteration,
+    loadAstRuntime, parseJsonLoose, patchMaxTokens,
+    ANALYSIS_MAX_TOKENS,
+  };
+}
+// MODULE_COMPLETE

package/src/core/cache-ttl.js

@@ -0,0 +1,21 @@
+// src/core/cache-ttl.js — TTL des caches RAM de doctrine : 5 h, RAM-ONLY.
+// Garantie anti-persistance (règle produit) : les données produit (fiches
+// signées Ed25519) ne vivent QUE dans ces caches mémoire, TTL 5 h maximum —
+// JAMAIS écrites sur disque (la mémoire persistante les exclue par filtrage
+// strict, memory-filter.js). Surcharge test : PLUGCTO_DOCTRINE_TTL_MS.
+
+export const DOCTRINE_TTL_MS = process.env.PLUGCTO_DOCTRINE_TTL_MS !== undefined
+  ? Math.max(0, Number(process.env.PLUGCTO_DOCTRINE_TTL_MS) || 0)
+  : 5 * 3600 * 1000;
+
+/** @param {DoctrineCache | null} cache @returns {cache is DoctrineCache} */
+export function isCacheFresh(cache) {
+  return !!cache && typeof cache.content === "string" && !!cache.content.trim()
+    && Date.now() - cache.cachedAt < DOCTRINE_TTL_MS;
+}
+
+/** @param {string} content @returns {DoctrineCache} */
+export function freshCache(content) {
+  return { content, cachedAt: Date.now() };
+}
+// MODULE_COMPLETE

package/src/core/config-base.js

@@ -0,0 +1,38 @@
+// src/core/config-base.js — Primitives de config client (création + persistance).
+// freshConfig : nouvelle config (clientId UUID). ensureConfigDir : mkdir ~/.pipcode.
+// saveConfig : écriture restreinte 0600 (config contient licenseKey). Base sans cycle.
+
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import { CONFIG_DIR, CONFIG_PATH } from "./constants.js";
+
+// Nouvelle config vierge (installedAt + clientId UUID persistant).
+/** @returns {PlugConfig} */
+export function freshConfig() {
+  return { installedAt: new Date().toISOString(), clientId: crypto.randomUUID(), licenseKey: "", email: "", trialExpiredNotified: false };
+}
+
+// Crée le dossier de config (best-effort, échec non silencieux : on relance).
+/** @returns {Promise<void>} */
+export async function ensureConfigDir() {
+  try { await fs.mkdir(CONFIG_DIR, { recursive: true }); }
+  catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    console.error(`[virtual-cto] Impossible de créer ${CONFIG_DIR} : ${e.message}`);
+    throw err;
+  }
+}
+
+// Écrit la config en 0600 (licenseKey non lisible par les autres utilisateurs).
+/** @param {PlugConfig} cfg @returns {Promise<void>} */
+export async function saveConfig(cfg) {
+  try {
+    await ensureConfigDir();
+    await fs.writeFile(CONFIG_PATH, JSON.stringify(cfg, null, 2), { encoding: "utf8", mode: 0o600 });
+  } catch (err) {
+    const e = /** @type {Error} */ (err);
+    console.error(`[virtual-cto] Impossible d'écrire la config ${CONFIG_PATH} : ${e.message}`);
+    // Non fatal : on continue sans persister (quota recalculé au prochain démarrage).
+  }
+}
+// MODULE_COMPLETE

package/src/core/config-cache.js

@@ -0,0 +1,50 @@
+// src/core/config-cache.js — Cache TTL RAM de la config (audit hot path tools/call).
+// Pattern cache-ttl.js : TTL court surchargeable (PLUGCTO_CONFIG_TTL_MS, défaut
+// 3 s). Sort l'I/O disque du chemin tools/call : au plus UNE lecture (et UNE
+// migration-réécriture) par fenêtre TTL. Cohérence : les écritures IN-PROCESS
+// (notice d'essai, purge anti-hostage) mutent l'OBJET CACHÉ lui-même avant
+// saveConfig → le cache reste toujours vrai ; une réécriture par un AUTRE
+// processus (CLI) est rattrapée à l'expiration du TTL (déviation de gate
+// BORNÉE au TTL, jamais permanente). Single-flight : un seul loadConfig en vol.
+
+import { loadConfig } from "./config.js";
+
+export const CONFIG_TTL_MS = process.env.PLUGCTO_CONFIG_TTL_MS !== undefined
+  ? Math.max(0, Number(process.env.PLUGCTO_CONFIG_TTL_MS) || 0)
+  : 3000;
+
+/** @typedef {{ cfg: PlugConfig, cachedAt: number }} ConfigCacheEntry */
+/** @type {ConfigCacheEntry | null} */
+let entry = null;
+/** @type {Promise<PlugConfig> | null} */
+let inFlight = null;
+
+/** @param {ConfigCacheEntry | null} e @returns {e is ConfigCacheEntry} */
+function isFresh(e) {
+  return !!e && Date.now() - e.cachedAt < CONFIG_TTL_MS;
+}
+
+/** @param {PlugConfig} cfg */
+function settle(cfg) { entry = { cfg, cachedAt: Date.now() }; inFlight = null; return cfg; }
+
+/** @param {unknown} err @returns {never} */
+function fail(err) { inFlight = null; throw err; }
+
+// Lecture réelle (unique par fenêtre) ; dédoublonne les appels concurrents.
+/** @returns {Promise<PlugConfig>} */
+function loadOnce() {
+  if (!inFlight) inFlight = loadConfig().then(settle, fail);
+  return inFlight;
+}
+
+// Invalidation explicite : rattrape immédiatement une réécriture externe.
+/** @returns {void} */
+export function invalidateConfigCache() { entry = null; }
+
+// Chargeur du hot path : RAM si frais, lecture disque sinon.
+/** @returns {Promise<PlugConfig>} */
+export async function loadConfigCached() {
+  if (isFresh(entry)) return entry.cfg;
+  return loadOnce();
+}
+// MODULE_COMPLETE

package/src/core/config.js

@@ -0,0 +1,58 @@
+// src/core/config.js — loadConfig (lecture + parsing + migration additive).
+// readConfigRaw : readFile + premier lancement (ENOENT/I/O → fresh). parseConfigRaw :
+// JSON.parse + validation installedAt. migrateConfig : garantit clientId/licenseKey/
+// email/trialExpiredNotified sans casser l'existant. Charge config-base (anti-cycle).
+
+import fs from "node:fs/promises";
+import crypto from "node:crypto";
+import { CONFIG_PATH } from "./constants.js";
+import { freshConfig, saveConfig } from "./config-base.js";
+
+// Lit le fichier config. Retourne { raw } ou { cfg } (fresh sauvée si absent/illisible).
+/** @returns {Promise<{ raw?: string, cfg?: PlugConfig }>} */
+async function readConfigRaw() {
+  try { return { raw: await fs.readFile(CONFIG_PATH, "utf8") }; }
+  catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    if (!(e && e.code === "ENOENT")) console.error(`[virtual-cto] Config illisible, réinitialisation : ${e.message}`);
+    const cfg = freshConfig(); await saveConfig(cfg); return { cfg };
+  }
+}
+
+// Parse + valide raw. Retourne { cfg } ou { cfg, resave } (fresh si corrompue).
+/** @param {string} raw @returns {{ cfg: PlugConfig, resave?: boolean }} */
+function parseConfigRaw(raw) {
+  try {
+    const cfg = /** @type {PlugConfig} */ (JSON.parse(raw));
+    if (typeof cfg.installedAt !== "string") throw new Error("installedAt manquant");
+    return { cfg };
+  } catch (err) {
+    const e = /** @type {Error} */ (err);
+    console.error(`[virtual-cto] Config corrompue, réinitialisation : ${e.message}`);
+    return { cfg: freshConfig(), resave: true };
+  }
+}
+
+// Migration additive : garantit les champs nouveaux sans casser l'existant.
+/** @param {PlugConfig} cfg @returns {{ cfg: PlugConfig, migrated: boolean }} */
+function migrateConfig(cfg) {
+  let migrated = false;
+  if (typeof cfg.clientId !== "string" || !cfg.clientId) { cfg.clientId = crypto.randomUUID(); migrated = true; }
+  if (typeof cfg.licenseKey !== "string") { cfg.licenseKey = ""; migrated = true; }
+  if (typeof cfg.trialExpiredNotified !== "boolean") { cfg.trialExpiredNotified = false; migrated = true; }
+  if (typeof cfg.email !== "string") { cfg.email = ""; migrated = true; }
+  return { cfg, migrated };
+}
+
+// Charge la config : read → parse → migrate. Crée/migre au premier lancement.
+/** @returns {Promise<PlugConfig>} */
+export async function loadConfig() {
+  const read = await readConfigRaw();
+  if (read.cfg) return read.cfg;
+  const parsed = parseConfigRaw(/** @type {string} */ (read.raw));
+  if (parsed.resave) await saveConfig(parsed.cfg);
+  const mig = migrateConfig(parsed.cfg);
+  if (mig.migrated) await saveConfig(mig.cfg);
+  return mig.cfg;
+}
+// MODULE_COMPLETE

package/src/core/constants.js

@@ -0,0 +1,31 @@
+// src/core/constants.js — Constantes de configuration globales + budget tokens.
+// Toutes surchargeables via env (PLUGCTO_API_BASE, PLUGCTO_PRO_URL, PLUGCTO_MAX_TOKENS,
+// PLUGCTO_CONFIG_DIR) pour tests/staging. patchMaxTokens : budget patch échelonné.
+
+import path from "node:path";
+import { resolvePlugctoRoot } from "../fs/home-root.js";
+
+// Adresse du serveur PipCode (surchargeable par PLUGCTO_API_BASE).
+export const API_BASE = process.env.PLUGCTO_API_BASE || "https://api.pipcode.app";
+export const PRO_UPGRADE_URL = process.env.PLUGCTO_PRO_URL || "https://buy.polar.sh/polar_cl_ZB8s48w6kpT0pP1L4YD8EuuOZAhk4QF7FMh1x0mkEkX";
+export const TRIAL_HOURS = 120; // 5 jours d'essai, 100 % fonctions débloquées.
+export const FETCH_TIMEOUT_MS = 10_000;
+export const LLM_TIMEOUT_MS = 60_000; // BYOK cloud : timeout pour un provider muet.
+export const LLM_LOCAL_TIMEOUT_MS = 300_000; // modèle local : silence maximal toléré sur le socket (5 min) ; en streaming des octets arrivent en continu
+export const LLM_LOCAL_TOTAL_MS = 1_800_000; // modèle local : durée totale maximale d'une génération (30 min)
+export const DEFAULT_MAX_TOKENS = Math.max(256, Number(process.env.PLUGCTO_MAX_TOKENS) || 4096);
+export const ANALYSIS_MAX_TOKENS = 1024;
+export const EXTRACTION_MAX_TOKENS = 4096;
+export const SESSION_RENEW_MARGIN_SEC = 60;
+export const SESSION_GRACE_SEC = 300; // marge d'horloge client/serveur (anti-rollback du jeton d'essai).
+export const CONFIG_DIR = resolvePlugctoRoot(); // résilient : repli tmpdir si profil verrouillé
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+export const MEMORY_PATH = path.join(CONFIG_DIR, "memory.json"); // mémoire long terme (Pro)
+
+// Budget patch : min 768 (retouche minimale), max DEFAULT_MAX_TOKENS, ~1 token / 3 chars.
+/** @param {number} codeLen @returns {number} */
+export function patchMaxTokens(codeLen) {
+  const n = Math.max(0, Number(codeLen) || 0);
+  return Math.min(DEFAULT_MAX_TOKENS, Math.max(768, Math.ceil(n / 3)));
+}
+// MODULE_COMPLETE

package/src/core/crypto.js

@@ -0,0 +1,45 @@
+// src/core/crypto.js — Intégrité cryptographique Ed25519 (trust anchor client).
+// Ancre : env PLUGCTO_TRUSTED_PUBLIC_X (rotation/staging) sinon clé publique
+// PROD embarquée (trusted-key.js). FAIL-CLOSED (SecOps) : AUCUN fallback DEV —
+// ancre absente ou JWK invalide → exception explicite, arrêt net du serveur.
+
+import crypto from "node:crypto";
+import { PROD_TRUSTED_PUBLIC_X } from "../auth/trusted-key.js";
+
+// Résout l'ancre de confiance ou lève une Error explicite (fail-closed, testable).
+/** @param {string | undefined} envX @param {string} anchorX @returns {string} */
+export function resolveTrustAnchor(envX, anchorX) {
+  const x = envX || anchorX;
+  if (!x || typeof x !== "string") {
+    throw new Error(
+      "Ancre Ed25519 absente : PLUGCTO_TRUSTED_PUBLIC_X non fixé et ancre PROD " +
+      "embarquée manquante. Arrêt immédiat (fail-closed).",
+    );
+  }
+  return x;
+}
+
+export const TRUSTED_PUBLIC_X = resolveTrustAnchor(process.env.PLUGCTO_TRUSTED_PUBLIC_X, PROD_TRUSTED_PUBLIC_X);
+
+// Clé publique de vérification — JWK invalide → arrêt net (aucun fallback toléré).
+export const TRUSTED_PUBLIC_KEY = (() => {
+  try {
+    return crypto.createPublicKey({ key: { kty: "OKP", crv: "Ed25519", x: TRUSTED_PUBLIC_X }, format: "jwk" });
+  } catch (err) {
+    const e = /** @type {Error} */ (err);
+    throw new Error(`Ancre Ed25519 invalide ("${TRUSTED_PUBLIC_X.slice(0, 12)}…") : ${e.message}. Arrêt immédiat (fail-closed).`);
+  }
+})();
+
+// Vérifie la signature Ed25519 d'un payload signé (dataStr + sigB64). true si valide.
+/** @param {string} dataStr @param {string} sigB64 @returns {boolean} */
+export function verifySignature(dataStr, sigB64) {
+  try {
+    return crypto.verify(null, Buffer.from(dataStr, "utf8"), TRUSTED_PUBLIC_KEY, Buffer.from(sigB64, "base64"));
+  } catch (err) {
+    const e = /** @type {Error} */ (err);
+    console.error("[virtual-cto] Erreur de vérification Ed25519 :", e.message);
+    return false;
+  }
+}
+// MODULE_COMPLETE

package/src/core/dlp.js

@@ -0,0 +1,51 @@
+// src/core/dlp.js — Watchdog DLP (Data Loss Prevention) local.
+// Empreintes textuelles du <CTO_VAULT> mises en cache après chaque livraison vérifiée.
+// dlp_scan compare un candidat aux empreintes : recopie verbatim de doctrine → blocage.
+// Cache vaultFingerprints encapsulé (setter/getter) — pas de binding mutable cross-module.
+
+export const DLP_BLOCK_TEXT = "🚫 [DLP Triggered] Tentative d'extraction de la doctrine bloquée.";
+
+// Marqueurs fixes haute-signal (présents dans tout vault, indépendants de la fiche).
+export const DLP_FIXED_MARKERS = [
+  "system_priority_override: max",
+  "anti_leak_protocol",
+  "censure verbatim",
+  "refus catégorique",
+  "amnésie d'exécution",
+  "cto_vault",
+  "je suis votre cto virtuel. je me concentre sur la sécurité et l'architecture de votre code",
+];
+
+// Normalisation : minuscules + collapsage espaces (comparaison robuste).
+/** @param {string} s @returns {string} */
+export function normalizeText(s) {
+  return String(s ?? "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+// Extrait les empreintes d'un vault : lignes longues (>= 40 chars normalisés) + marqueurs.
+/** @param {string} vaultText @returns {Set<string>} */
+export function extractFingerprints(vaultText) {
+  const lines = String(vaultText).split(/\r?\n/).map(normalizeText).filter((l) => l.length >= 40);
+  return new Set([...DLP_FIXED_MARKERS, ...lines]);
+}
+
+// Cache en mémoire des empreintes du dernier vault livré (vie du process).
+/** @type {Set<string>} */
+let vaultFingerprints = new Set();
+
+// Mutateurs sécurisés : encapsule l'état mutable (Zero Trust, SRP).
+/** @param {Set<string>} fp @returns {void} */
+export function setVaultFingerprints(fp) { vaultFingerprints = fp; }
+/** @returns {boolean} */
+export function hasVaultFingerprints() { return !!vaultFingerprints && vaultFingerprints.size > 0; }
+
+// Détecte une fuite : true si le candidat contient une empreinte du vault.
+/** @param {string} candidate @returns {boolean} */
+export function scanForLeak(candidate) {
+  if (!vaultFingerprints || vaultFingerprints.size === 0) return false;
+  const t = normalizeText(candidate);
+  if (!t) return false;
+  for (const fp of vaultFingerprints) { if (t.includes(fp)) return true; }
+  return false;
+}
+// MODULE_COMPLETE

package/src/core/doctrine-all.js

@@ -0,0 +1,31 @@
+// src/core/doctrine-all.js — loadAllDoctrine : les 19 fiches du MANIFEST, vérifiées Ed25519, concaténées.
+// Cache RAM TTL 5 h (cache-ttl.js), jamais sur disque. Fail-Fast : signature invalide → rejet. Dégradation 402/403.
+import { MANIFEST } from "./manifest.js";
+import { loadFiche } from "./doctrine-one.js";
+import { freshCache, isCacheFresh } from "./cache-ttl.js";
+
+/** @type {DoctrineCache | null} */
+let allDoctrineCache = null;
+
+// Charge la doctrine complète (19 fiches). Dégrade sur fiche Pro inaccessible (trial sans licence).
+/** @param {PlugConfig} cfg @returns {Promise<string>} */
+export async function loadAllDoctrine(cfg) {
+  if (isCacheFresh(allDoctrineCache)) return allDoctrineCache.content;
+  const blocks = [];
+  for (const m of MANIFEST) {
+    const block = await loadFiche(m, cfg);
+    if (block) blocks.push(block);
+  }
+  if (!blocks.length) {
+    throw new Error("Doctrine complète (19 fiches) indisponible — aucune fiche accessible.");
+  }
+  const content = blocks.join("\n\n");
+  allDoctrineCache = freshCache(content);
+  return content;
+}
+
+// Test-only : réinitialise le cache des 19 fiches.
+export function resetAllDoctrineCache() {
+  allDoctrineCache = null;
+}
+// MODULE_COMPLETE

package/src/core/doctrine-caches.js

@@ -0,0 +1,10 @@
+// src/core/doctrine-caches.js — Test-only : réinitialise les caches de
+// doctrine (core_rules + 19 fiches).
+import { resetDoctrineCache } from "./doctrine.js";
+import { resetAllDoctrineCache } from "./doctrine-all.js";
+
+export function __resetDoctrineCachesForTest() {
+  resetDoctrineCache();
+  resetAllDoctrineCache();
+}
+// MODULE_COMPLETE

package/src/core/doctrine-fetch.js

@@ -0,0 +1,49 @@
+// src/core/doctrine-fetch.js — fetchSignedSkill : fetch cloud d'une fiche signée (thin client).
+// Séparation fetch / verify pour des messages d'erreur distincts. Timeout AbortController.
+import { API_BASE, FETCH_TIMEOUT_MS } from "./constants.js";
+import { machineFp } from "./identity.js";
+
+// Fetche une fiche signée (slug) depuis le Worker. Retourne { data, sig } ou jette une Error.
+/** @param {string} slug @param {string} tier @param {PlugConfig} cfg @returns {Promise<SignedSkillPayload>} */
+export async function fetchSignedSkill(slug, tier, cfg) {
+  const installedAt = (cfg && cfg.installedAt) || "";
+  const clientId = (cfg && cfg.clientId) || "";
+  const licenseKey = process.env.PLUGCTO_LICENSE_KEY || (cfg && cfg.licenseKey) || "";
+  const url = `${API_BASE}/skills/${encodeURIComponent(slug)}?tier=${encodeURIComponent(tier)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json",
+        "X-PlugCTO-Client": "thin/1.0",
+        "X-PlugCTO-Installed-At": installedAt,
+        "X-PlugCTO-Tier": tier,
+        "X-PlugCTO-Client-Id": clientId,
+        "X-PlugCTO-License": licenseKey,
+        "X-PlugCTO-Machine-Fp": machineFp(),
+      },
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText} sur ${url}`);
+    const body = await res.text();
+    if (!body || !body.trim()) throw new Error(`Réponse vide pour "${slug}" (tier=${tier})`);
+    let payload;
+    try {
+      payload = /** @type {SignedSkillPayload} */ (JSON.parse(body));
+    } catch {
+      throw new Error(`Réponse non-JSON pour "${slug}" (payload signé attendu)`);
+    }
+    if (typeof payload.data !== "string" || typeof payload.sig !== "string") {
+      throw new Error(`Payload signé malformé pour "${slug}" (champs data/sig manquants)`);
+    }
+    return payload;
+  } catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    if (e && e.name === "AbortError") throw new Error(`Timeout (${FETCH_TIMEOUT_MS}ms) sur ${url}`);
+    throw new Error(`Échec fetch ${url} : ${e.message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+// MODULE_COMPLETE

package/src/core/doctrine-one.js

@@ -0,0 +1,18 @@
+// src/core/doctrine-one.js — loadFiche : UNE fiche du MANIFEST récupérée en payload signé, vérifiée Ed25519 puis dépaquetée. Partagé par la doctrine complète (Auto) et le chat.
+// Fiche Pro inaccessible (essai terminé, quota, réseau) → "" ; signature invalide ou données illisibles → erreur (Fail-Fast).
+import { fetchSignedSkill } from "./doctrine-fetch.js";
+import { verifySignature } from "./crypto.js";
+
+/** @param {import("./manifest.js").ManifestEntry} m @param {PlugConfig} cfg @param {{ fetchSkill?: typeof fetchSignedSkill }} [deps] @returns {Promise<string>} bloc « == slug (tier) — titre == » + contenu, ou "" */
+export async function loadFiche(m, cfg, { fetchSkill = fetchSignedSkill } = {}) {
+  let payload;
+  try { payload = await fetchSkill(m.slug, m.tier, cfg); } catch { return ""; }
+  if (!verifySignature(payload.data, payload.sig)) {
+    throw new Error(`Signature Ed25519 de la fiche "${m.slug}" INVALIDE — doctrine rejetée. Cause probable : ancre de confiance (PLUGCTO_TRUSTED_PUBLIC_X) ≠ clé privée du Worker.`);
+  }
+  let parsed;
+  try { parsed = /** @type {SkillPayloadContent} */ (JSON.parse(payload.data)); } catch { throw new Error(`Fiche "${m.slug}" : payload signé valide mais données illisibles.`); }
+  const content = typeof parsed.content === "string" ? parsed.content : "";
+  return content.trim() ? `== ${m.slug} (${m.tier}) — ${m.title} ==\n${content}` : "";
+}
+// MODULE_COMPLETE