pipcode 0.0.0-stage → 2.1.0

package/src/mcp/handle-memory.js

@@ -0,0 +1,37 @@
+// src/mcp/handle-memory.js — Handlers MCP de la mémoire persistante :
+// plugcto_memory_save (gate + filtrage strict + append) et
+// plugcto_memory_recall (gate + lecture re-filtrée). Pro/essai uniquement
+// (memory-gate.js) — le plan gratuit n'en dispose pas.
+import { gateMemory } from "../memory/memory-gate.js";
+import { appendMemory, readMemory } from "../memory/memory-store.js";
+
+/** @param {Record<string, unknown> | undefined} args @returns {Promise<McpToolResponse>} */
+export async function handleMemorySave(args) {
+  const gate = await gateMemory();
+  if (!gate.ok) return { isError: true, content: gate.content };
+  const a = args || {};
+  const text = typeof a.text === "string" ? a.text.trim() : "";
+  if (!text) {
+    return { isError: true, content: [{ type: "text", text: 'Aucun texte à mémoriser : passez { "text": "..." } (optionnel "kind" : note | preference | pattern | project).' }] };
+  }
+  const kind = typeof a.kind === "string" && a.kind.trim() ? a.kind.trim().slice(0, 40) : "note";
+  const entry = { kind, text: text.slice(0, 10_000), source: "user", createdAt: new Date().toISOString() };
+  const r = await appendMemory(entry);
+  if (!r.ok) {
+    return { isError: true, content: [{ type: "text", text: "Entrée rejetée : les données produit (doctrine/fiches) ne sont jamais persistées — RAM uniquement." }] };
+  }
+  return { content: [{ type: "text", text: `💾 Mémorisé (${entry.kind}) : la mémoire persistera entre vos sessions.` }] };
+}
+
+/** @param {Record<string, unknown> | undefined} args @returns {Promise<McpToolResponse>} */
+export async function handleMemoryRecall(args) {
+  const gate = await gateMemory();
+  if (!gate.ok) return { isError: true, content: gate.content };
+  const q = ((args && typeof args.query === "string" && args.query.trim().toLowerCase()) || "");
+  const entries = (await readMemory()).filter((e) => !q || e.text.toLowerCase().includes(q));
+  if (!entries.length) {
+    return { content: [{ type: "text", text: "Aucun souvenir persisté ne correspond." }] };
+  }
+  return { content: [{ type: "text", text: entries.map((e) => `- [${e.kind}] ${e.text}`).join("\n") }] };
+}
+// MODULE_COMPLETE

package/src/mcp/handle-skill-fetch.js

@@ -0,0 +1,50 @@
+// src/mcp/handle-skill-fetch.js — Fetch cloud d'une fiche de compétence :
+// payload signé { data, sig }, vérification Ed25519 FAIL-SAFE, déballage
+// JSON, enveloppement dans le Master Prompt + cache DLP.
+import { fetchSignedSkill } from "../core/doctrine-fetch.js";
+import { verifySignature } from "../core/crypto.js";
+import { buildMasterPrompt } from "../core/master-prompt.js";
+import { extractFingerprints, setVaultFingerprints } from "../core/dlp.js";
+import { LITE_BLOCK_TEXT } from "../core/tier.js";
+
+/** @typedef {{ slug: string, tier: string }} SkillRef */
+
+/** @typedef {{ ok: true, text: string } | { ok: false, content: McpTextContent[] }} SkillFetchResult */
+
+/** @param {SkillRef} skill @param {PlugConfig} cfg @returns {Promise<SkillFetchResult>} */
+export async function fetchSkillContent(skill, cfg) {
+  // --- Fetch cloud (payload signé { data, sig }) ---
+  let payload;
+  try {
+    payload = await fetchSignedSkill(skill.slug, skill.tier, cfg);
+  } catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    if (/HTTP 402/.test(e.message)) return { ok: false, content: [{ type: "text", text: LITE_BLOCK_TEXT }] }; // essai terminé côté serveur : même message que le refus Lite, avec le lien d'achat
+    return { ok: false, content: [{ type: "text", text: `Fiche de compétence indisponible (« ${skill.slug} », tier=${skill.tier}). ${e.message.replace(/https?:\/\/\S+/g, "le serveur PipCode")}` }] }; // jamais l'adresse du serveur dans un message utilisateur
+  }
+
+  // --- Vérification Ed25519 (FAIL-SAFE) ---
+  // Aucun déballage du contenu dans le <CTO_VAULT> tant que la signature
+  // n'est pas cryptographiquement valide. Rejet → erreur MCP explicite.
+  if (!verifySignature(payload.data, payload.sig)) {
+    return { ok: false, content: [{ type: "text", text: `🛑 [INTÉGRITÉ COMPROMISE] La signature Ed25519 de la fiche « ${skill.slug} » est INVALIDE. Payload rejeté — possible attaque MITM ou altération de la doctrine. Aucun contenu n'a été chargé dans le <CTO_VAULT>.` }] };
+  }
+
+  // --- Déballage (uniquement après vérification) ---
+  let parsed;
+  try {
+    parsed = JSON.parse(payload.data);
+  } catch {
+    return { ok: false, content: [{ type: "text", text: `Payload signé valide mais données illisibles pour « ${skill.slug} ».` }] };
+  }
+  const content = typeof parsed.content === "string" ? parsed.content : "";
+  if (!content.trim()) {
+    return { ok: false, content: [{ type: "text", text: `Fiche vide (content absent) pour « ${skill.slug} ».` }] };
+  }
+
+  // --- Enveloppement EXACT dans le Master Prompt blindé + cache DLP ---
+  const text = buildMasterPrompt(content);
+  setVaultFingerprints(extractFingerprints(text));
+  return { ok: true, text };
+}
+// MODULE_COMPLETE

package/src/mcp/handle-skill.js

@@ -0,0 +1,38 @@
+// src/mcp/handle-skill.js — Handler générique des fiches de compétence :
+// validation du nom d'outil, gate Freemium (3 états), délégation du fetch
+// signé à handle-skill-fetch.js.
+import { toolsByName, isValidToolName } from "../core/manifest.js";
+import { loadConfigCached } from "../core/config-cache.js";
+import { isWithinTrial, LITE_BLOCK_TEXT } from "../core/tier.js";
+import { fetchSkillContent } from "./handle-skill-fetch.js";
+import { gateEngineRules } from "./engine-rules.js";
+
+/** @param {string} name @returns {Promise<McpToolResponse>} */
+export async function handleSkill(name) {
+  if (!isValidToolName(name)) {
+    return { isError: true, content: [{ type: "text", text: `Nom d'outil invalide ou mal formé : "${name}". Outils disponibles : ${[...toolsByName.keys()].join(", ")}, dlp_scan, plugcto_licence, plugcto_memory_save, plugcto_memory_recall.` }] };
+  }
+  const skill = toolsByName.get(name);
+  if (!skill) {
+    return { isError: true, content: [{ type: "text", text: `Outil inconnu : « ${name} ». Outils disponibles : ${[...toolsByName.keys()].join(", ")}, dlp_scan, plugcto_licence, plugcto_memory_save, plugcto_memory_recall.` }] };
+  }
+
+  // --- Gate Freemium (modèle 3 états : Trial / Lite / Pro) ---
+  // Lite (aucune licence + hors essai local) : seules les fiches tier "lite"
+  // du MANIFEST passent (token_optimization, gratuit à vie) ; les autres →
+  // LITE_BLOCK_TEXT. Trial (5 j, sans licence) et Pro (licence Polar.sh) :
+  // toutes les fiches. L'autorité monétaire RÉELLE est le serveur (SKILL_TIERS
+  // + trialGate worker, licence validée au fetch signé) — le client ne fait que
+  // bloquer AVANT fetch, le serveur re-gate.
+  const cfg = await loadConfigCached();
+  const _hasLic = !!(process.env.PLUGCTO_LICENSE_KEY || cfg.licenseKey);
+  if (!_hasLic && !isWithinTrial(cfg) && skill.tier !== "lite") {
+    return { isError: true, content: [{ type: "text", text: LITE_BLOCK_TEXT }] };
+  }
+  const rules = await gateEngineRules(cfg); // gabarit du Master Prompt servi par le serveur.
+  if (!rules.ok) return { isError: true, content: rules.content };
+  const f = await fetchSkillContent(skill, cfg);
+  if (!f.ok) return { isError: true, content: f.content };
+  return { content: [{ type: "text", text: f.text }] };
+}
+// MODULE_COMPLETE

package/src/mcp/licence-text.js

@@ -0,0 +1,29 @@
+// src/mcp/licence-text.js — Textes de l'outil de licence (purs, sans réseau ni disque) : état lisible, achat, clé masquée. Jamais la clé en clair dans une réponse.
+import { TRIAL_HOURS, PRO_UPGRADE_URL } from "../core/constants.js";
+
+const DAY_MS = 24 * 3600 * 1000;
+
+/** @param {string} key @returns {string} 3 premiers caractères puis des étoiles (jamais la clé entière) */
+export const maskKey = (key) => `${String(key).slice(0, 3)}******`;
+
+/** @param {string} installedAt @param {number} [now] @returns {number} jours d'essai restants (0 si terminé ou date inconnue) */
+export function trialDaysLeft(installedAt, now = Date.now()) {
+  const t = Date.parse(installedAt);
+  return Number.isNaN(t) ? 0 : Math.max(0, Math.ceil((TRIAL_HOURS * 3600 * 1000 - (now - t)) / DAY_MS));
+}
+
+const BUY = `Acheter une licence Pro (14,99 USD, paiement unique) : ${PRO_UPGRADE_URL}`;
+const HAVE = "Vous avez déjà une clé ? Collez-la ici dans le chat : elle sera enregistrée (action « register »).";
+
+/** @param {"pro" | "trial" | "lite"} tier @param {string} licenseKey @param {string} installedAt @param {number} [now] @returns {string} */
+export function statusText(tier, licenseKey, installedAt, now = Date.now()) {
+  if (tier === "pro") return `✅ Licence Pro active${licenseKey ? ` (clé ${maskKey(licenseKey)})` : ""}. Tout PipCode est débloqué.`;
+  const head = tier === "trial"
+    ? `🕒 Essai en cours : il reste environ ${trialDaysLeft(installedAt, now)} jour(s), toutes les fonctions sont débloquées. Ensuite : version Lite, gratuite à vie.`
+    : "Version Lite (gratuite à vie). La licence Pro débloque le catalogue complet.";
+  return [head, BUY, HAVE].join("\n");
+}
+
+/** @param {string} reason @returns {string} message d'échec d'enregistrement (la clé n'est pas enregistrée) */
+export const refusedText = (reason) => `❌ ${reason} La clé n'a pas été enregistrée.\n${BUY}`;
+// MODULE_COMPLETE

package/src/mcp/prompt-licence.js

@@ -0,0 +1,11 @@
+// src/mcp/prompt-licence.js — Invite MCP « licence » : dans Claude Code elle apparaît comme commande /mcp__pipcode__licence ; ailleurs, l'utilisateur demande « ma licence » et l'agent appelle l'outil.
+
+export const LICENCE_PROMPT = { name: "licence", description: "Voir, acheter ou enregistrer votre licence PipCode" };
+
+const BODY = "Appelle l'outil plugcto_licence (sans argument) et présente le résultat à l'utilisateur. S'il veut acheter, rappelle l'outil avec l'action « buy ». S'il te donne sa clé de licence, rappelle l'outil avec l'action « register » et la clé. Ne répète jamais la clé en clair.";
+
+/** @param {string} name @returns {{ description: string, messages: Array<{ role: "user", content: { type: "text", text: string } }> } | null} */
+export function getPrompt(name) {
+  return name === LICENCE_PROMPT.name ? { description: LICENCE_PROMPT.description, messages: [{ role: "user", content: { type: "text", text: BODY } }] } : null;
+}
+// MODULE_COMPLETE

package/src/mcp/server-create.js

@@ -0,0 +1,33 @@
+// src/mcp/server-create.js — Création du Server MCP + capture de l'agent hôte
+// (clientInfo à l'initialize — gap d'audit #1) + handlers tools/list et tools/call.
+// Extrait de server-main.js (plafond de lignes) : main() reste un réorienteur.
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { handleListTools } from "./handle-list.js";
+import { handleCallTool } from "./call-tool.js";
+import { rememberClient } from "./client-info.js";
+import { LICENCE_PROMPT, getPrompt } from "./prompt-licence.js";
+
+// Crée le Server, y branche les handlers et capture l'agent hôte (multi-agent
+// natif → PipCode lui laisse la délégation au lieu de doubler l'orchestration).
+/** @returns {Server} */
+export function createPlugServer() {
+  const server = new Server(
+    { name: "virtual-cto-skills", version: "2.0.0" },
+    { capabilities: { tools: {}, prompts: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, handleListTools);
+  server.setRequestHandler(CallToolRequestSchema, handleCallTool);
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [LICENCE_PROMPT] }));
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const prompt = getPrompt(request.params.name);
+    if (!prompt) throw new Error(`Invite inconnue : ${request.params.name}`);
+    return prompt;
+  });
+  server.oninitialized = () => {
+    try { rememberClient(server.getClientVersion()); } catch { /* best-effort : sans clientInfo, pas de délégation */ }
+  };
+  return server;
+}
+// MODULE_COMPLETE

package/src/mcp/server-main.js

@@ -0,0 +1,39 @@
+// src/mcp/server-main.js — Runtime du serveur MCP (main) : guards boot,
+// création Server (server-create.js : handlers + capture de l'agent hôte),
+// transport stdio, bannière stderr.
+// Architecture "Thin Client" 100 % Cloud-Only : aucune fiche stockée
+// localement — fetch dynamique signé Ed25519 (le catalogue MANIFEST reste
+// embarqué pour un tools/list instantané hors-ligne). Modèle 3 états :
+// Trial 5j / Lite / Pro (Polar.sh). Invariant protocole : stdout = canal
+// JSON-RPC MCP (aucun log), logs → stderr.
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { API_BASE } from "../core/constants.js";
+import { MANIFEST } from "../core/manifest.js";
+import { installStdoutGuard } from "../core/stdout-guard.js";
+import { startBootTasks } from "./boot-warmup.js";
+import { createPlugServer } from "./server-create.js";
+import { buildToolsList } from "./tools-list.js";
+
+/** @returns {Promise<void>} */
+export async function main() {
+  installStdoutGuard();
+  // Ancre Ed25519 fail-closed (SecOps) : crypto.js lève au chargement si absente
+  // ou invalide — plus de fallback DEV, donc plus d'avertissement de runtime.
+  if (MANIFEST.length === 0) {
+    console.error("[virtual-cto] Catalogue d'outils vide — aucune fiche exposée.");
+    process.exit(1);
+  }
+  // Boot v1.1 : init AST (lazy) + warmup cache prompt, en arrière-plan
+  // (boot-warmup.js) — ne bloque pas le handshake stdio.
+  startBootTasks();
+  const server = createPlugServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  // Compte déduit de la vraie source tools/list (fiches + transverses),
+  // jamais d'addition codée en dur (audit MCP).
+  const toolCount = buildToolsList().tools.length;
+  console.error(
+    `[virtual-cto] Serveur MCP prêt sur stdio (thin client) — ${MANIFEST.length} fiche(s) catalogue, ${toolCount} outil(s) exposés via tools/list. API: ${API_BASE} | Intégrité: Ed25519 | auto-correction locale (OpenAI/Anthropic/Gemini/Zhipu/OpenRouter/Ollama) + token session /v1/session | Phase 0: moteur métier + Auto Mode | Tiers: Trial 5j / Lite / Pro (Polar.sh)`
+  );
+}
+// MODULE_COMPLETE

package/src/mcp/tool-dispatch.js

@@ -0,0 +1,28 @@
+// src/mcp/tool-dispatch.js — Chaîne de dispatch tools/call par nom d'outil.
+// Extraite de call-tool.js (plafond 40 lignes du fichier d'origine). Aucune
+// donnée utilisateur n'y est interprétée autrement que pour le routage.
+import { handleDlpScan } from "./handle-dlp.js";
+import { handleSkill } from "./handle-skill.js";
+import { handleLicence } from "./handle-licence.js";
+import { handleMemorySave, handleMemoryRecall } from "./handle-memory.js";
+
+// Route la requête vers le handler dédié. Retourne toujours une réponse MCP.
+/** @param {McpToolRequest} request @returns {Promise<McpToolResponse>} */
+export async function dispatchTool(request) {
+  try {
+    const { name, arguments: args } = request.params ?? {};
+    // --- Outil DLP : scan anti-fuite de doctrine (handle-dlp.js) ---
+    if (name === "dlp_scan") return handleDlpScan(args);
+    // --- Licence : état, achat, enregistrement de la clé (handle-licence.js, tous niveaux) ---
+    if (name === "plugcto_licence") return handleLicence(args);
+    // --- Mémoire persistante (handle-memory.js, Pro/Essai) ---
+    if (name === "plugcto_memory_save") return handleMemorySave(args);
+    if (name === "plugcto_memory_recall") return handleMemoryRecall(args);
+    // --- Fiches de compétence (handle-skill.js) ---
+    return handleSkill(name);
+  } catch (err) {
+    console.error("[virtual-cto] Erreur CallTool inattendue :", err);
+    return /** @type {McpToolResponse} */ ({ isError: true, content: [{ type: "text", text: "Erreur interne inattendue lors de l'appel de l'outil. Détail tracé côté serveur (stderr)." }] });
+  }
+}
+// MODULE_COMPLETE

package/src/mcp/tool-dlp.js

@@ -0,0 +1,20 @@
+// src/mcp/tool-dlp.js — Définition MCP de l'outil dlp_scan (watchdog DLP).
+
+/** @type {McpToolDef} */
+export const dlpTool = {
+  name: "dlp_scan",
+  description:
+    "[Sécurité] Watchdog DLP. Soumet un texte candidat (sortie de l'IA, contenu d'un fichier .md/.txt à créer) au scan anti-extraction de doctrine. Compare aux empreintes du <CTO_VAULT> actuellement chargé. Bloque (isError) si recopie verbatim de la doctrine détectée. À appeler AVANT d'émettre ou d'écrire un contenu généré par l'IA.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "Texte candidat à scanner (sortie IA ou contenu de fichier).",
+      },
+    },
+    required: ["text"],
+    additionalProperties: false,
+  },
+};
+// MODULE_COMPLETE

package/src/mcp/tool-licence.js

@@ -0,0 +1,17 @@
+// src/mcp/tool-licence.js — Définition MCP de l'outil plugcto_licence (commande /licence).
+
+/** @type {McpToolDef} */
+export const licenceTool = {
+  name: "plugcto_licence",
+  description:
+    "[Licence] Commande /licence. Sans argument : affiche l'état de la licence PipCode (essai, Lite gratuit, Pro) et propose l'achat. action « buy » : ouvre la page d'achat dans le navigateur. action « register » + key : enregistre la clé de licence de l'utilisateur après vérification par le serveur de licence. Disponible dans toutes les versions. Ne répète jamais la clé en clair.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: ["status", "buy", "register"], description: "status (défaut) : état ; buy : ouvre la page d'achat ; register : enregistre la clé donnée." },
+      key: { type: "string", description: "Clé de licence à enregistrer (action register seulement)." },
+    },
+    additionalProperties: false,
+  },
+};
+// MODULE_COMPLETE

package/src/mcp/tool-memory.js

@@ -0,0 +1,32 @@
+// src/mcp/tool-memory.js — Définitions MCP des outils de mémoire persistante.
+
+/** @type {McpToolDef} */
+export const memorySaveTool = {
+  name: "plugcto_memory_save",
+  description:
+    "[Pro/Essai] Mémoire long terme. Enregistre durablement (localement) une préférence, un pattern de projet ou un contexte utile pour les missions futures. Les données produit (doctrine/fiches) sont systématiquement exclues — elles ne vivent qu'en RAM.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "Le souvenir à mémoriser (10000 caractères max)." },
+      kind: { type: "string", description: "Catégorie : note | preference | pattern | project." },
+    },
+    required: ["text"],
+    additionalProperties: false,
+  },
+};
+
+/** @type {McpToolDef} */
+export const memoryRecallTool = {
+  name: "plugcto_memory_recall",
+  description:
+    "[Pro/Essai] Rappel de la mémoire long terme. Retourne les souvenirs persistés localement, filtrables par requête. Aucune donnée produit n'y figure jamais.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: { type: "string", description: "Filtre optionnel (sous-chaîne insensible à la casse)." },
+    },
+    additionalProperties: false,
+  },
+};
+// MODULE_COMPLETE

package/src/mcp/tool-skill.js

@@ -0,0 +1,24 @@
+// src/mcp/tool-skill.js — Définitions MCP des fiches enforce_* (tools/list).
+import { MANIFEST } from "../core/manifest.js";
+
+// Description d'une fiche : routage domaine strict + tier (Pro/Lite).
+/** @returns {McpToolDef[]} */
+export function buildSkillTools() {
+  return MANIFEST.map((m) => ({
+    name: m.name,
+    description:
+      `[CTO Router] Domaine strict : ${m.slug}. N'appeler CET outil que si la requête relève de ce domaine précis — une SEULE fiche enforce_* par passe (voir ORCHESTRATOR). ` +
+      (m.tier === "pro"
+        ? `[Pro] `
+        : `[Lite] `) +
+      (m.title
+        ? `Applique la fiche « ${m.title} » (${m.slug}) du Virtual CTO, enveloppée dans le Master Prompt blindé (CTO_VAULT + ANTI_LEAK_PROTOCOL). Signature Ed25519 vérifiée.`
+        : `Applique la fiche ${m.slug} du Virtual CTO, enveloppée dans le Master Prompt blindé.`),
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false,
+    },
+  }));
+}
+// MODULE_COMPLETE

package/src/mcp/tools-list.js

@@ -0,0 +1,13 @@
+// src/mcp/tools-list.js — Catalogue tools/list : fiches enforce_* + outils
+// transverses (DLP, licence, mémoire). Aucun outil n'appelle de modèle : l'agent hôte EST le modèle (le Mode Auto vit dans l'extension).
+import { buildSkillTools } from "./tool-skill.js";
+import { dlpTool } from "./tool-dlp.js";
+import { memorySaveTool, memoryRecallTool } from "./tool-memory.js";
+import { licenceTool } from "./tool-licence.js";
+
+// Catalogue statique (hors-ligne, instantané) servi au handler ListTools.
+/** @returns {{ tools: McpToolDef[] }} */
+export function buildToolsList() {
+  return { tools: [...buildSkillTools(), dlpTool, licenceTool, memorySaveTool, memoryRecallTool] };
+}
+// MODULE_COMPLETE

package/src/memory/exports.js

@@ -0,0 +1,5 @@
+// src/memory/exports.js — Surface publique du domaine mémoire (hub index.js).
+export { isProductData, filterMemoryEntries } from "./memory-filter.js";
+export { readMemory, appendMemory, clearMemory } from "./memory-store.js";
+export { gateMemory } from "./memory-gate.js";
+// MODULE_COMPLETE

package/src/memory/memory-filter.js

@@ -0,0 +1,32 @@
+// src/memory/memory-filter.js — FILTRAGE STRICT de la mémoire persistante.
+// Règle produit (SecOps) : les données PRODUIT (fiches de doctrine, payloads
+// signés {data, sig}) sont SYSTÉMATIQUEMENT exclues — elles ne vivent qu'en
+// RAM (cache TTL 5 h, cache-ttl.js), jamais sur disque. Filtre appliqué à
+// l'écriture ET à la relecture (défense en profondeur, memory-store.js).
+import { MANIFEST } from "../core/manifest.js";
+
+// Sources interdites : slugs du MANIFEST + origines produit explicites.
+const PRODUCT_SOURCES = new Set([...MANIFEST.map((m) => m.slug), "doctrine", "skill", "payload"]);
+
+/** @param {unknown} v @returns {boolean} */
+function looksLikeSignedPayload(v) {
+  if (!v || typeof v !== "object") return false;
+  const o = /** @type {Record<string, unknown>} */ (v);
+  return typeof o.data === "string" && typeof o.sig === "string";
+}
+
+// true = à EXCLURE (donnée produit ou entrée invalide).
+/** @param {MemoryEntry} e @returns {boolean} */
+export function isProductData(e) {
+  if (looksLikeSignedPayload(e)) return true;
+  if (!e || typeof e.text !== "string" || !e.text.trim()) return true;
+  if (/^== \S+ \((lite|pro)\) — /.test(e.text)) return true; // bloc doctrine concaténée
+  return PRODUCT_SOURCES.has(e.source);
+}
+
+/** @param {unknown} entries @returns {MemoryEntry[]} */
+export function filterMemoryEntries(entries) {
+  if (!Array.isArray(entries)) return [];
+  return /** @type {MemoryEntry[]} */ (entries.filter((e) => e && !isProductData(/** @type {MemoryEntry} */ (e))));
+}
+// MODULE_COMPLETE

package/src/memory/memory-gate.js

@@ -0,0 +1,21 @@
+// src/memory/memory-gate.js — Gate tier de la mémoire persistante (monétisation).
+// Règle : mémoire long terme débloquée pendant l'essai (5 j) puis avec la
+// licence Pro. Plan gratuit illimité : économiseur de tokens UNIQUEMENT.
+// Session mutualisée : core/session-resilient.js (purge anti-hostage incluse).
+import { loadConfigCached } from "../core/config-cache.js";
+import { resolveSessionResilient } from "../core/session-resilient.js";
+import { PRO_UPGRADE_URL } from "../core/constants.js";
+
+/** @typedef {{ ok: true, cfg: PlugConfig } | { ok: false, content: McpTextContent[] }} GateMemoryResult */
+
+/** @returns {Promise<GateMemoryResult>} */
+export async function gateMemory() {
+  const cfg = await loadConfigCached();
+  const r = await resolveSessionResilient(cfg);
+  if (r.failure) return { ok: false, content: r.failure };
+  if (r.tier === "lite") {
+    return { ok: false, content: [{ type: "text", text: `🔒 La mémoire persistante est débloquée pendant l'essai de 5 jours, puis avec la licence Pro. Version gratuite (Lite) : économiseur de tokens uniquement. Passez à la version Pro ($14.99 USD à vie, Polar.sh) : ${PRO_UPGRADE_URL}` }] };
+  }
+  return { ok: true, cfg };
+}
+// MODULE_COMPLETE

package/src/memory/memory-store.js

@@ -0,0 +1,44 @@
+// src/memory/memory-store.js — Persistance locale de la mémoire long terme
+// (~/.pipcode/memory.json, 0600, écriture atomique via fs/atomic-write.js).
+// FILTRAGE STRICT à l'écriture ET à la relecture (défense en profondeur) :
+// aucune donnée produit (doctrine/payloads) ne touche jamais le disque.
+import fs from "node:fs/promises";
+import { MEMORY_PATH } from "../core/constants.js";
+import { writeConfigAtomic } from "../fs/atomic-write.js";
+import { filterMemoryEntries, isProductData } from "./memory-filter.js";
+
+/** @param {MemoryEntry[]} entries @returns {Promise<void>} */
+async function writeMemory(entries) {
+  await writeConfigAtomic(MEMORY_PATH, { version: 1, entries: filterMemoryEntries(entries) });
+}
+
+// Lit la mémoire persistée (RE-FILTRÉE : toute donnée produit qui s'y serait
+// glissée est écartée à la lecture). Absente → []. Corrompue → reset + stderr.
+/** @returns {Promise<MemoryEntry[]>} */
+export async function readMemory() {
+  try {
+    const f = /** @type {MemoryFile} */ (JSON.parse(await fs.readFile(MEMORY_PATH, "utf8")));
+    return filterMemoryEntries(f.entries);
+  } catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    if (e && e.code !== "ENOENT") console.error(`[virtual-cto] Mémoire illisible, réinitialisation : ${e.message}`);
+    return [];
+  }
+}
+
+// Ajoute une entrée. Refus explicite si donnée produit (règle RAM-only).
+/** @param {MemoryEntry} entry @returns {Promise<{ ok: boolean, reason?: string }>} */
+export async function appendMemory(entry) {
+  if (isProductData(entry)) return { ok: false, reason: "product_data" };
+  const entries = await readMemory();
+  entries.push(entry);
+  await writeMemory(entries);
+  return { ok: true };
+}
+
+// Purge totale de la mémoire (révocation/teardown). Best-effort.
+/** @returns {Promise<void>} */
+export async function clearMemory() {
+  await writeMemory([]);
+}
+// MODULE_COMPLETE

package/src/net/auth-browser.js

@@ -0,0 +1,49 @@
+// src/net/auth-browser.js — Authentification navigateur zéro friction (Étape 1).
+// Micro-serveur HTTP éphémère sur 127.0.0.1:port intercepte le callback
+// /callback?key=...&email=...&state=... . C3 (CSRF + host header injection) :
+// nonce `state` validé au callback (timingSafeEqual), en-tête Host strictement
+// vérifié contre 127.0.0.1:<port> (DNS rebinding rejeté).
+
+import crypto from "node:crypto";
+import http from "node:http";
+import { AUTH_CALLBACK_PORT, authUrl, openBrowser } from "./auth-endpoints.js";
+
+/** @typedef {Error & { code?: string, status?: number }} NodeErr */
+/** @typedef {{ port?: number, timeoutMs?: number, open?: boolean, state?: string }} AuthBrowserOpts */
+/** @typedef {{ key: string, email: string, source: "browser", error?: string }} AuthBrowserResult */
+
+/**
+ * @param {AuthBrowserOpts} [opts]
+ * @returns {Promise<AuthBrowserResult>}
+ */
+export function authViaBrowser({ port = AUTH_CALLBACK_PORT, timeoutMs = 180_000, open = true, state } = {}) {
+  const redirect = `http://127.0.0.1:${port}/callback`;
+  const nonce = state || crypto.randomBytes(16).toString("hex");
+  const expectedHost = `127.0.0.1:${port}`;
+  const target = authUrl(redirect, nonce);
+  return new Promise((resolve) => {
+    let settled = false;
+    /** @param {AuthBrowserResult} val */
+    const finish = (val) => { if (!settled) { settled = true; clearTimeout(to); try { server.close(); } catch { /* best-effort : fermeture du serveur local */ } resolve(val); } };
+    const server = http.createServer((req, res) => {
+      let u;
+      try { u = new URL(/** @type {string} */ (req.url), redirect); } catch { res.writeHead(400); res.end("bad"); return; }
+      const host = (req.headers.host || "").toLowerCase();
+      if (host !== expectedHost.toLowerCase()) { res.writeHead(403); res.end("forbidden"); return; }
+      if (u.pathname !== "/callback") { res.writeHead(404); res.end("not found"); return; }
+      const reqState = u.searchParams.get("state") || "";
+      if (!reqState || reqState.length !== nonce.length || !crypto.timingSafeEqual(Buffer.from(reqState), Buffer.from(nonce))) {
+        res.writeHead(403); res.end("forbidden: state"); return;
+      }
+      const key = u.searchParams.get("key") || "";
+      const email = u.searchParams.get("email") || "";
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end("<!doctype html><html><body style='font-family:sans-serif;padding:2rem'><h2>✅ PipCode — connexion réussie</h2><p>Vous pouvez fermer cet onglet et revenir au terminal.</p></body></html>");
+      finish({ key, email, source: "browser" });
+    });
+    server.on("error", (e) => finish({ key: "", email: "", source: "browser", error: String((/** @type {NodeErr} */ (e)).code || e.message) }));
+    const to = setTimeout(() => finish({ key: "", email: "", source: "browser", error: "timeout" }), timeoutMs);
+    server.listen(port, "127.0.0.1", () => { if (open) openBrowser(target); });
+  });
+}
+// MODULE_COMPLETE

package/src/net/auth-endpoints.js

@@ -0,0 +1,33 @@
+// src/net/auth-endpoints.js — Endpoints et helpers d'authentification navigateur.
+// Port du callback local (127.0.0.1), base URL du Worker, construction de l'URL
+// d'auth (page Polar/Worker qui redirige vers le callback) + ouverture du navigateur.
+
+import { execFile } from "node:child_process";
+import { API_BASE as AUTH_API_BASE } from "../core/constants.js";
+
+// Port du callback local (127.0.0.1:9876). Surchargeable via env pour les tests.
+export const AUTH_CALLBACK_PORT = Number(process.env.PLUGCTO_AUTH_PORT) || 9876;
+// Base URL du Worker (validation licence / lookup email) — source unique : constants.js
+// (même env PLUGCTO_API_BASE ; zéro duplication de la valeur de référence).
+export { AUTH_API_BASE };
+
+// URL de la page d'auth navigateur (Polar/Worker) — redirige vers le callback.
+// `state` (C3) : nonce CSRF optionnel propagé à la page d'auth, qui doit le
+// renvoyer tel quel sur le callback. Requis pour authViaBrowser (validation).
+/** @param {string} redirect @param {string} [state] @returns {string} */
+export function authUrl(redirect, state) {
+  const custom = process.env.PLUGCTO_AUTH_URL;
+  if (custom) return custom;
+  let u = `${AUTH_API_BASE}/auth?redirect=${encodeURIComponent(redirect)}`;
+  if (state) u += `&state=${encodeURIComponent(state)}`;
+  return u;
+}
+
+// Ouvre une URL dans le navigateur par défaut (best-effort, non bloquant).
+/** @param {string} url */
+export function openBrowser(url) {
+  const cmd = process.platform === "win32" ? "explorer"
+    : process.platform === "darwin" ? "open" : "xdg-open";
+  try { execFile(cmd, [url], () => {}); } catch { /* best-effort */ }
+}
+// MODULE_COMPLETE

package/src/net/local-fetch.js

@@ -0,0 +1,31 @@
+// src/net/local-fetch.js — Transport des modèles LOCAUX (Ollama…) : IPv4 strict (family 4), socket réutilisé (keepAlive) et attente
+// de réponse alignée sur la génération du modèle (LLM_LOCAL_TIMEOUT_MS = 300 000 ms) : le socket n'est jamais fermé parce qu'aucun
+// octet n'arrive pendant le calcul. Interface minimale compatible fetch (ok, status, text). Annulation par `signal`.
+
+import http from "node:http";
+import { StringDecoder } from "node:string_decoder";
+import https from "node:https";
+import { LLM_LOCAL_TIMEOUT_MS } from "../core/constants.js";
+import { ipv4Loopback } from "./loopback.js";
+
+const OPTIONS = { keepAlive: true, family: 4, timeout: LLM_LOCAL_TIMEOUT_MS };
+const AGENTS = { "http:": new http.Agent(OPTIONS), "https:": new https.Agent(OPTIONS) };
+
+/** @param {string} url @param {RequestInit} [init] @param {(chunk: string) => void} [onData] morceaux de texte au fil de l'eau (flux) @returns {Promise<{ ok: boolean, status: number, text: () => Promise<string> }>} */
+export function localFetch(url, init = {}, onData) {
+  const u = new URL(ipv4Loopback(url));
+  const lib = u.protocol === "https:" ? https : http;
+  return new Promise((resolve, reject) => {
+    const req = lib.request(u, { method: init.method || "GET", headers: /** @type {Record<string, string>} */ (init.headers || {}), agent: AGENTS[/** @type {"http:" | "https:"} */ (u.protocol)], family: 4, signal: init.signal ?? undefined }, (res) => {
+      /** @type {Buffer[]} */ const chunks = [];
+      const decoder = new StringDecoder("utf8");
+      res.on("data", (c) => { chunks.push(c); if (onData) onData(decoder.write(c)); });
+      res.on("end", () => { const status = res.statusCode || 0; const body = Buffer.concat(chunks).toString("utf8"); resolve({ ok: status >= 200 && status < 300, status, text: async () => body }); });
+      res.on("error", reject);
+    });
+    req.setTimeout(LLM_LOCAL_TIMEOUT_MS, () => req.destroy(new Error(`Aucune donnée reçue depuis ${Math.round(LLM_LOCAL_TIMEOUT_MS / 1000)} s.`))); // silence prolongé sur le socket
+    req.on("error", reject); // l'annulation (AbortError) et les erreurs réseau remontent telles quelles à l'appelant
+    req.end(typeof init.body === "string" ? init.body : undefined);
+  });
+}
+// MODULE_COMPLETE

package/src/net/loopback.js

@@ -0,0 +1,8 @@
+// src/net/loopback.js — Boucle locale en IPv4 STRICT : « localhost » (et ::1) devient 127.0.0.1 (Windows résout localhost en IPv6
+// d'abord, Ollama n'écoute qu'en IPv4 : délais de 60 s et refus de connexion). Pur ; seule l'adresse locale est réécrite.
+
+const LOCAL_NAME = /^(https?:\/\/)(?:localhost|\[::1\])(?=[:/]|$)/i;
+
+/** « http://localhost:11434/v1 » → « http://127.0.0.1:11434/v1 » ; toute autre adresse inchangée. @param {string} url @returns {string} */
+export const ipv4Loopback = (url) => String(url).replace(LOCAL_NAME, "$1127.0.0.1");
+// MODULE_COMPLETE