pipcode 0.0.0-stage → 2.1.1

package/src/core/session-net.js

@@ -0,0 +1,60 @@
+// src/core/session-net.js — requestSession (POST /v1/session Worker) + ensureSession (cache + renouvellement anticipé).
+import { API_BASE, FETCH_TIMEOUT_MS, SESSION_RENEW_MARGIN_SEC } from "./constants.js";
+import { machineFp } from "./identity.js";
+import { parseSessionResponse } from "./session.js";
+
+/** @type {LicenseSession | null} */
+let sessionCache = null;
+
+/** @param {PlugConfig} cfg @returns {Promise<LicenseSession>} */
+export async function requestSession(cfg) {
+  const clientId = (cfg && cfg.clientId) || "";
+  const licenseKey = process.env.PLUGCTO_LICENSE_KEY || (cfg && cfg.licenseKey) || "";
+  if (!licenseKey) {
+    const err = /** @type {EnrichedError} */ (new Error("Aucune clé de licence configurée."));
+    err.code = "no_license";
+    throw err;
+  }
+  const url = `${API_BASE}/v1/session`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "X-PlugCTO-Client": "thin/1.0",
+        "X-PlugCTO-Client-Id": clientId,
+        "X-PlugCTO-License": licenseKey,
+        "X-PlugCTO-Machine-Fp": machineFp(),
+      },
+      body: JSON.stringify({ license_key: licenseKey }),
+    });
+    return parseSessionResponse(res, await res.text());
+  } catch (err) {
+    const e0 = /** @type {EnrichedError} */ (err);
+    if (e0 && e0.name === "AbortError") {
+      const e = /** @type {EnrichedError} */ (new Error(`Timeout (${FETCH_TIMEOUT_MS}ms) sur ${url}.`));
+      e.code = "timeout";
+      throw e;
+    }
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Renvoie un token valide (cache + renouvellement anticipé). Purge anti-hostage.
+/** @param {PlugConfig} cfg @returns {Promise<LicenseSession>} */
+export async function ensureSession(cfg) {
+  const now = Math.floor(Date.now() / 1000);
+  if (sessionCache && sessionCache.expSec - now > SESSION_RENEW_MARGIN_SEC) return sessionCache;
+  sessionCache = await requestSession(cfg);
+  return sessionCache;
+}
+
+// Purge Anti-Hostage : vide instantanément le cache RAM du token de session.
+export function purgeSessionCache() { sessionCache = null; }
+// MODULE_COMPLETE

package/src/core/session-resilient.js

@@ -0,0 +1,44 @@
+// src/core/session-resilient.js — Résolution de session résiliente MUTUALISÉE
+// (gates Auto / Engine / Mémoire). Avec licence → ensureSession ; sans licence
+// (ou Polar injoinable) → jeton d'essai SERVEUR /v1/trial (jamais de grant
+// local, doctrine Zero Trust §3). Hors essai : 402/403/429 = licence INVALIDÉE
+// → PURGE anti-hostage immédiate AVANT l'erreur ; autre échec = serveur
+// indisponible (transitoire : pas de purge).
+import { ensureSession } from "./session-net.js";
+import { resolveTier } from "./tier.js";
+import { resolveTrialOrLite } from "./trial-resolve.js";
+import { purgeLicenseKey } from "./purge-key.js";
+import { PRO_UPGRADE_URL } from "./constants.js";
+
+/** @param {EnrichedError} e @returns {McpTextContent[]} */
+function sessionFailure(e) {
+  if (e.code === "no_license") {
+    return [{ type: "text", text: `🔒 Licence requise. Débloquez PipCode Pro ($14.99 USD à vie, Polar.sh) : ${PRO_UPGRADE_URL}` }];
+  }
+  if (e.status === 402 || e.status === 403 || e.status === 429) {
+    return [{ type: "text", text: e.message || `Session refusée par le serveur (HTTP ${e.status}).` }];
+  }
+  return [{ type: "text", text: `Serveur de licence indisponible. ${e.message || "Erreur inconnue."} Vérifiez votre réseau et la valeur de PLUGCTO_API_BASE.` }];
+}
+
+/** @param {PlugConfig} cfg @returns {Promise<SessionResolution>} */
+export async function resolveSessionResilient(cfg) {
+  const hasLicense = !!(process.env.PLUGCTO_LICENSE_KEY || cfg.licenseKey);
+  if (!hasLicense) return resolveTrialOrLite(cfg);
+  try {
+    const session = await ensureSession(cfg);
+    return { session, tier: resolveTier(cfg, session) };
+  } catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    // Polar injoinable : l'essai serveur peut rester actif (résilience). On ne
+    // retourne QUE si l'essai est accordé — sinon la purge anti-hostage ci-dessous.
+    const t = await resolveTrialOrLite(cfg);
+    if (t.tier === "trial") return t;
+    // Licence invalidée par le serveur → purge instantanée de la clé (anti-hostage).
+    if (e.status === 402 || e.status === 403 || e.status === 429) {
+      await purgeLicenseKey(cfg, `licence refusée par le serveur (HTTP ${e.status})`);
+    }
+    return { session: null, tier: "lite", failure: sessionFailure(e) };
+  }
+}
+// MODULE_COMPLETE

package/src/core/session.js

@@ -0,0 +1,49 @@
+// src/core/session.js — Crypto token session : décodage base64url + vérification Ed25519 + parsing réponse Worker.
+import crypto from "node:crypto";
+import { TRUSTED_PUBLIC_KEY } from "./crypto.js";
+
+/** @param {string} s @returns {Buffer} */
+function b64urlDecode(s) {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - (s.length % 4));
+  return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/") + pad, "base64");
+}
+
+/** @param {string} token @returns {LicenseSessionPayload | null} */
+export function verifySessionToken(token) {
+  try {
+    const parts = String(token).split(".");
+    if (parts.length !== 2) return null;
+    const [payloadB64, sigB64] = parts;
+    const payloadJson = b64urlDecode(payloadB64).toString("utf8");
+    const sig = b64urlDecode(sigB64);
+    const ok = crypto.verify(null, Buffer.from(payloadJson, "utf8"), TRUSTED_PUBLIC_KEY, sig);
+    if (!ok) return null;
+    const p = /** @type {LicenseSessionPayload} */ (JSON.parse(payloadJson));
+    if (typeof p.exp !== "number") return null;
+    if (p.exp <= Math.floor(Date.now() / 1000)) return null;
+    return p;
+  } catch {
+    return null;
+  }
+}
+
+// Parse + vérifie crypto la réponse Worker. Retourne la session ou jette une Error enrichie.
+/** @param {Response} res @param {string} bodyText @returns {LicenseSession} */
+export function parseSessionResponse(res, bodyText) {
+  let parsed = null;
+  try { parsed = /** @type {{ token?: string, message?: string } | null} */ (JSON.parse(bodyText)); } catch { /* corps non-JSON : parsed reste null */ }
+  if (!res.ok) {
+    const msg = (parsed && parsed.message) || `HTTP ${res.status}`;
+    const err = /** @type {EnrichedError} */ (new Error(msg));
+    err.status = res.status;
+    err.payload = parsed;
+    throw err;
+  }
+  if (!parsed || typeof parsed.token !== "string") {
+    throw new Error("Réponse session malformée (champ `token` manquant).");
+  }
+  const verified = verifySessionToken(parsed.token);
+  if (!verified) throw new Error("Token de session invalide (signature Ed25519 rejetée ou expiré).");
+  return { token: parsed.token, tier: verified.tier, expSec: verified.exp };
+}
+// MODULE_COMPLETE

package/src/core/sse-parser.js

@@ -0,0 +1,25 @@
+// src/core/sse-parser.js — Analyseur de flux SSE (Server-Sent Events) : les morceaux réseau arrivent coupés n'importe où ; un événement se termine par une
+// ligne vide ; seules les lignes « data: » comptent (commentaires et « event: » ignorés : le JSON porte déjà son type). Pur.
+
+export class SseParser {
+  /** @param {(data: string) => void} onData appelé pour chaque événement complet (données jointes par des retours ligne) */
+  constructor(onData) { this.onData = onData; this.buf = ""; }
+
+  /** @param {string} chunk */
+  push(chunk) {
+    this.buf += chunk;
+    const blocks = this.buf.split(/\r?\n\r?\n/);
+    this.buf = blocks.pop() ?? "";
+    for (const block of blocks) this.#event(block);
+  }
+
+  /** Fin du flux : un dernier événement non terminé par une ligne vide est tout de même lu. */
+  end() { const rest = this.buf; this.buf = ""; if (rest.trim()) this.#event(rest); }
+
+  /** @param {string} block */
+  #event(block) {
+    const data = block.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).replace(/^ /, "")).join("\n");
+    if (data) this.onData(data);
+  }
+}
+// MODULE_COMPLETE

package/src/core/stdout-guard.js

@@ -0,0 +1,11 @@
+// src/core/stdout-guard.js — Hygiène stdio du serveur MCP : stdout est le
+// canal protocole JSON-RPC, écrit uniquement par le SDK de transport ; les
+// logs applicatifs vont sur stderr. Garantie réelle : console.log est
+// redirigé vers stderr. process.stdout n'est PAS wrappé — il reste la
+// propriété exclusive du SDK (et intact à l'import pour le runner de tests).
+
+/** Redirige console.log vers stderr. @returns {void} */
+export function installStdoutGuard() {
+  console.log = (...args) => console.error("[stdout-guard]", ...args);
+}
+// MODULE_COMPLETE

package/src/core/tier.js

@@ -0,0 +1,48 @@
+// src/core/tier.js — Modèle 3 états (Trial / Lite / Pro Polar.sh) + messages de transition.
+// resolveTier : pro/trial UNIQUEMENT via token signé serveur (essai /v1/trial) — zéro droit sur l'horloge locale (Zero Trust §3).
+// isWithinTrial : UX uniquement. maybeTrialExpiredNotice : transition Trial→Lite UNE FOIS (persiste le flag) + purge anti-hostage.
+
+import { TRIAL_HOURS, PRO_UPGRADE_URL } from "./constants.js";
+import { saveConfig } from "./config-base.js";
+import { purgeLicenseKey } from "./purge-key.js";
+
+// Message Freemium : fiches / Mode Auto / Audit / 2ᵉ IA / mémoire bloqués en Lite. Volontairement COURT : un constat et le lien (le chat gratuit reste ouvert).
+export const LITE_BLOCK_TEXT = `🔒 Fonction Pro. Licence Pro : ${PRO_UPGRADE_URL}`;
+
+// Message de transition Trial → Lite (non-bloquant, append au content de la réponse MCP).
+export const TRIAL_EXPIRED_NOTICE = `Version d'essai terminée. Licence Pro : ${PRO_UPGRADE_URL}`;
+
+// Trial actif si moins de TRIAL_HOURS (120 h = 5 jours) depuis l'installation.
+/** @param {PlugConfig} cfg @returns {boolean} */
+export function isWithinTrial(cfg) {
+  const installed = Date.parse(cfg.installedAt);
+  if (Number.isNaN(installed)) return false;
+  return Date.now() - installed < TRIAL_HOURS * 3600 * 1000;
+}
+
+/** @param {PlugConfig} _cfg @param {LicenseSession | null} session @returns {"pro" | "trial" | "lite"} */
+export function resolveTier(_cfg, session) {
+  if (session && (session.tier === "pro" || session.tier === "trial")) return /** @type {"pro" | "trial"} */ (session.tier);
+  return "lite";
+}
+
+// Licence configurée (env PLUGCTO_LICENSE_KEY ou config) ?
+/** @param {PlugConfig} cfg @returns {boolean} */
+export function hasLicenseKey(cfg) {
+  return !!(process.env.PLUGCTO_LICENSE_KEY || (cfg && cfg.licenseKey));
+}
+
+// Notice Trial→Lite UNE FOIS : retourne le texte si transition fraîche, persiste, puis "".
+/** @param {PlugConfig} cfg @returns {Promise<string>} */
+export async function maybeTrialExpiredNotice(cfg) {
+  if (isWithinTrial(cfg)) return "";
+  if (cfg.trialExpiredNotified) return "";
+  if (hasLicenseKey(cfg)) return "";
+  cfg.trialExpiredNotified = true;
+  // Anti-Hostage : à l'expiration de l'essai, purge de toute clé résiduelle
+  // (config + cache RAM) avant le basculement en plan gratuit.
+  await purgeLicenseKey(cfg, "essai expiré — basculement plan gratuit");
+  await saveConfig(cfg);
+  return TRIAL_EXPIRED_NOTICE;
+}
+// MODULE_COMPLETE

package/src/core/trial-resolve.js

@@ -0,0 +1,22 @@
+// src/core/trial-resolve.js — Résolution d'essai résiliente : jeton serveur ou
+// bascule Lite. JAMAIS de grant local (Zero Trust, doctrine CLAUDE.md §3) :
+// 402 du serveur = essai terminé (état NORMAL, sans failure — les gates
+// affichent leur message Lite dédié) ; autre échec = serveur indisponible.
+
+import { ensureTrialSession } from "./trial-session.js";
+
+/** @param {PlugConfig} cfg @returns {Promise<SessionResolution>} */
+export async function resolveTrialOrLite(cfg) {
+  try {
+    const session = await ensureTrialSession(cfg);
+    return { session, tier: "trial" };
+  } catch (err) {
+    const e = /** @type {EnrichedError} */ (err);
+    if (e && e.status === 402) return { session: null, tier: "lite" };
+    return {
+      session: null, tier: "lite",
+      failure: [{ type: "text", text: `Serveur d'essai indisponible. ${(e && e.message) || "Erreur inconnue."} Vérifiez votre réseau et la valeur de PLUGCTO_API_BASE.` }],
+    };
+  }
+}
+// MODULE_COMPLETE

package/src/core/trial-session.js

@@ -0,0 +1,60 @@
+// src/core/trial-session.js — Jeton d'essai signé Ed25519 (POST /v1/trial Worker).
+// Zero Trust (doctrine CLAUDE.md §3) : le droit d'essai vient UNIQUEMENT du
+// serveur (fenêtre KV 120 h, horloge serveur) — jamais de l'horloge locale.
+// Token lié à l'empreinte machine (non transférable) ; iat contrôlé (skew 5 min).
+
+import crypto from "node:crypto";
+import { API_BASE, FETCH_TIMEOUT_MS, SESSION_GRACE_SEC, SESSION_RENEW_MARGIN_SEC } from "./constants.js";
+import { machineFp } from "./identity.js";
+import { parseSessionResponse, verifySessionToken } from "./session.js";
+
+/** @type {LicenseSession | null} */
+let trialCache = null;
+
+// Empreinte d'essai attendue : miroir EXACT du worker (sha256 base64 STANDARD du machineFp).
+/** @returns {string} */
+function expectedTrialFp() {
+  return "trial:" + crypto.createHash("sha256").update(machineFp()).digest("base64").replace(/=+$/, "");
+}
+
+// Contrôles Zero Trust du token délivré : tier, empreinte machine, iat.
+/** @param {LicenseSession} s @returns {LicenseSession} */
+function verifyTrialPayload(s) {
+  const p = verifySessionToken(s.token);
+  if (!p || p.tier !== "trial" || p.fp !== expectedTrialFp()) throw new Error("Token d'essai invalide (tier ou empreinte machine rejetée).");
+  if (p.iat > Math.floor(Date.now() / 1000) + SESSION_GRACE_SEC) throw new Error("Token d'essai rejeté (horloge locale en retrait de la date d'émission serveur).");
+  return s;
+}
+
+// POST /v1/trial — headers Client-Id + Machine-Fp (aucune clé, aucun secret).
+/** @param {PlugConfig} cfg @returns {Promise<LicenseSession>} */
+export async function requestTrialSession(cfg) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${API_BASE}/v1/trial`, {
+      method: "POST", signal: controller.signal,
+      headers: {
+        Accept: "application/json", "Content-Type": "application/json",
+        "X-PlugCTO-Client": "thin/1.0", "X-PlugCTO-Client-Id": (cfg && cfg.clientId) || "",
+        "X-PlugCTO-Machine-Fp": machineFp(),
+      },
+    });
+    return verifyTrialPayload(parseSessionResponse(res, await res.text()));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Renvoie un token d'essai valide (cache RAM + renouvellement anticipé 60 s).
+/** @param {PlugConfig} cfg @returns {Promise<LicenseSession>} */
+export async function ensureTrialSession(cfg) {
+  const now = Math.floor(Date.now() / 1000);
+  if (trialCache && trialCache.expSec - now > SESSION_RENEW_MARGIN_SEC) return trialCache;
+  trialCache = await requestTrialSession(cfg);
+  return trialCache;
+}
+
+// Purge Anti-Hostage : vide le cache RAM du token d'essai.
+export function purgeTrialCache() { trialCache = null; }
+// MODULE_COMPLETE

package/src/core/trial-status.js

@@ -0,0 +1,35 @@
+// src/core/trial-status.js — État de l'essai tel que le SERVEUR le tranche (POST /v1/trial).
+// Lecture seule pour l'affichage : aucun droit n'est accordé ici (l'accès reste porté par le
+// jeton signé du moteur). Un 402 = essai terminé, définitif (aucune réouverture côté client).
+// debt: 12 lignes, mutualiser l'appel avec trial-session.requestTrialSession si un 3e appelant apparaît.
+
+import { API_BASE, FETCH_TIMEOUT_MS } from "./constants.js";
+import { machineFp } from "./identity.js";
+import { parseSessionResponse } from "./session.js";
+
+const isoOrUndefined = (/** @type {unknown} */ v) => (typeof v === "string" && !Number.isNaN(Date.parse(v)) ? new Date(v).toISOString() : undefined);
+const httpUrl = (/** @type {unknown} */ v) => (typeof v === "string" && /^https:\/\/[^\s]+$/.test(v) ? v : undefined);
+
+/** @param {PlugConfig} cfg @returns {Promise<TrialStatus>} */
+export async function trialStatus(cfg) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(`${API_BASE}/v1/trial`, {
+      method: "POST", signal: controller.signal,
+      headers: { Accept: "application/json", "X-PlugCTO-Client": "thin/1.0", "X-PlugCTO-Client-Id": (cfg && cfg.clientId) || "", "X-PlugCTO-Machine-Fp": machineFp() },
+    });
+    const text = await res.text();
+    parseSessionResponse(res, text); // vérifie la signature Ed25519 du jeton ; lève sur 402/erreur.
+    /** @type {{ trial_ends_at?: unknown }} */
+    const body = JSON.parse(text);
+    return { state: "active", endsAt: isoOrUndefined(body.trial_ends_at) };
+  } catch (e) {
+    const err = /** @type {EnrichedError} */ (e);
+    if (err.status === 402) return { state: "expired", upgrade: httpUrl(err.payload && /** @type {{ upgrade?: unknown }} */ (err.payload).upgrade) };
+    return { state: "error", message: err.name === "AbortError" ? "serveur injoignable (délai dépassé)" : String(err.message).slice(0, 200) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+// MODULE_COMPLETE

package/src/core/usage-cost.js

@@ -0,0 +1,25 @@
+// src/core/usage-cost.js — Coût d'un cumul d'usage, sans AUCUNE valeur inventée. Sources, par priorité :
+// (1) coût facturé rapporté par l'API elle-même (OpenRouter) quand TOUS les appels l'ont fourni ; (2) modèle local
+// (Ollama / localhost) = 0 exactement ; (3) grille tarifaire servie par le serveur pour ce modèle (USD / million de
+// tokens, date d'effet jointe ; lecture de cache et écriture de cache facturées à leur propre tarif quand la grille le
+// précise) ; sinon inconnu (null) — l'interface affiche alors « n/d », jamais un prix supposé.
+
+const LOCAL = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/i;
+
+/** @param {string} base @returns {boolean} */
+export const isLocalBase = (base) => LOCAL.test(String(base || ""));
+
+/** Entrée de grille d'un modèle ; l'identifiant Gemini « models/xxx » est ramené à « xxx ». @param {PricingGrid} grid @param {string} model @returns {PriceEntry | undefined} */
+const priceOf = (grid, model) => grid.models[model] ?? grid.models[model.replace(/^models\//, "")];
+
+/** @param {UsageEntry} e @param {PricingGrid | null} grid @returns {Pick<UsageReportEntry, "cost" | "costSource" | "grid">} */
+export function costOf(e, grid) {
+  if (e.calls > 0 && e.apiCostCalls === e.calls) return { cost: e.apiCost, costSource: "api", grid: null };
+  if (e.local) return { cost: 0, costSource: "local", grid: null };
+  const p = grid && priceOf(grid, e.model);
+  if (!grid || !p) return { cost: null, costSource: null, grid: null };
+  const plain = e.input - e.cached - e.cacheWrite; // tokens d'entrée au tarif normal
+  const cost = (plain * p.in + e.cached * (p.cachedIn ?? p.in) + e.cacheWrite * (p.cacheWriteIn ?? p.in) + e.output * p.out) / 1e6;
+  return { cost, costSource: "grille", grid: { in: p.in, out: p.out, cachedIn: p.cachedIn ?? null, asOf: grid.asOf, note: p.note ?? null } };
+}
+// MODULE_COMPLETE

package/src/core/usage-extract.js

@@ -0,0 +1,28 @@
+// src/core/usage-extract.js — Usage RÉEL rapporté par l'API du fournisseur dans sa réponse (jamais estimé) :
+// OpenAI/Zhipu/OpenRouter/Ollama (usage.prompt_tokens / completion_tokens, détail cache, coût OpenRouter), Anthropic
+// (usage.input_tokens / output_tokens + lectures de cache) et Gemini (usageMetadata). Champ absent → 0 ou null :
+// aucune valeur inventée. Pur.
+
+const num = (/** @type {unknown} */ v) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0);
+
+/** @param {string} provider @param {unknown} body réponse JSON déjà analysée @returns {UsageSample | null} */
+export function extractUsage(provider, body) {
+  const b = /** @type {ProviderUsageBody | null} */ (body && typeof body === "object" ? body : null);
+  if (!b) return null;
+  if (provider === "anthropic") {
+    const u = b.usage;
+    if (!u) return null;
+    const cached = num(u.cache_read_input_tokens);
+    const cacheWrite = num(u.cache_creation_input_tokens);
+    return { input: num(u.input_tokens) + cached + cacheWrite, output: num(u.output_tokens), cached, cacheWrite, cost: null };
+  }
+  if (provider === "gemini") {
+    const u = b.usageMetadata;
+    return u ? { input: num(u.promptTokenCount), output: num(u.candidatesTokenCount), cached: num(u.cachedContentTokenCount), cacheWrite: 0, cost: null } : null;
+  }
+  const u = b.usage; // openai / zhipu et compatibles (OpenRouter, Ollama, proxy)
+  if (!u) return null;
+  const cost = typeof u.cost === "number" && Number.isFinite(u.cost) && u.cost >= 0 ? u.cost : null; // coût facturé, rapporté par OpenRouter
+  return { input: num(u.prompt_tokens), output: num(u.completion_tokens), cached: num(u.prompt_tokens_details?.cached_tokens), cacheWrite: 0, cost };
+}
+// MODULE_COMPLETE

package/src/core/usage-meter.js

@@ -0,0 +1,41 @@
+// src/core/usage-meter.js — Compteur d'usage RÉEL du processus : chaque appel modèle réussi y dépose les tokens
+// rapportés par l'API (jamais estimés). À la sortie, SI l'extension le demande (PLUGCTO_EMIT_USAGE=1 — jamais dans un
+// terminal ordinaire : PipCode n'impose rien à l'environnement hôte), le relevé est écrit sur stderr, en une ligne
+// `PLUGCTO_USAGE <json>`, par écriture synchrone (fiable même après process.exit).
+import fs from "node:fs";
+import { extractUsage } from "./usage-extract.js";
+import { costOf, isLocalBase } from "./usage-cost.js";
+import { getRules } from "../rules/rules-registry.js";
+
+export const USAGE_PREFIX = "PLUGCTO_USAGE ";
+/** @type {Map<string, UsageEntry>} */
+const entries = new Map();
+let hooked = false;
+
+/** Dépose l'usage d'une réponse fournisseur réussie. @param {string} provider @param {string} model @param {string} base @param {string} bodyText */
+export function recordUsage(provider, model, base, bodyText) {
+  /** @type {UsageSample | null} */ let s = null;
+  try { s = extractUsage(provider, JSON.parse(bodyText)); } catch { /* corps non-JSON : aucun usage à compter */ }
+  if (!s) return;
+  const local = isLocalBase(base);
+  const key = `${provider}|${model}|${local}`;
+  const e = entries.get(key) ?? { provider, model, local, calls: 0, input: 0, output: 0, cached: 0, cacheWrite: 0, apiCost: 0, apiCostCalls: 0 };
+  entries.set(key, { ...e, calls: e.calls + 1, input: e.input + s.input, output: e.output + s.output, cached: e.cached + s.cached, cacheWrite: e.cacheWrite + s.cacheWrite, apiCost: e.apiCost + (s.cost ?? 0), apiCostCalls: e.apiCostCalls + (s.cost === null ? 0 : 1) });
+  hookExit();
+}
+
+/** Relevé courant (coûts calculés avec la grille du serveur si les règles sont chargées). @returns {{ v: 1, entries: UsageReportEntry[] }} */
+export function usageReport() {
+  /** @type {PricingGrid | null} */ let grid = null;
+  try { grid = getRules().pricing; } catch { /* règles non chargées : pas de grille, coût inconnu sauf API/local */ }
+  return { v: 1, entries: [...entries.values()].map((e) => ({ provider: e.provider, model: e.model, calls: e.calls, input: e.input, output: e.output, cached: e.cached, ...costOf(e, grid) })) };
+}
+
+function hookExit() {
+  if (hooked || process.env.PLUGCTO_EMIT_USAGE !== "1") return;
+  hooked = true;
+  process.on("exit", () => {
+    try { fs.writeSync(2, `${USAGE_PREFIX}${JSON.stringify(usageReport())}\n`); } catch { /* stderr fermé : rien à signaler */ }
+  });
+}
+// MODULE_COMPLETE

package/src/engine/analyze-need.js

@@ -0,0 +1,24 @@
+// src/engine/analyze-need.js — Analyse un besoin en matrice métier structurée.
+import { getRules } from "../rules/rules-registry.js";
+import { detectDomains, mapDomainsToSlugs } from "./detect-domains.js";
+import { analyzeUxDesign } from "./analyze-ux.js";
+
+// Retourne { need, domainKeys, domains, roles, regles, contraintes, failles, fiches,
+//   uxDirectives, designSystem }. uxDirectives + designSystem viennent de analyzeUxDesign.
+/** @param {string} needText @returns {{ need: string, domainKeys: string[], domains: { key: string, label: string, roles: string[], regles: string[], contraintes: string[], failles: string[] }[], roles: string[], regles: string[], contraintes: string[], failles: string[], fiches: string[], uxDirectives: string[], designSystem: object }} */
+export function analyzeNeed(needText) {
+  const need = String(needText || "").trim();
+  const keys = detectDomains(need);
+  const domains = keys.map((k) => {
+    const d = getRules().domains[k];
+    return { key: k, label: d.label, roles: d.roles, regles: d.regles, contraintes: d.contraintes, failles: d.failles };
+  });
+  const roles = [...new Set(domains.flatMap((d) => d.roles))];
+  const regles = domains.flatMap((d) => d.regles.map((r) => `[${d.label}] ${r}`));
+  const contraintes = domains.flatMap((d) => d.contraintes.map((c) => `[${d.label}] ${c}`));
+  const failles = domains.flatMap((d) => d.failles.map((f) => `[${d.label}] ${f}`));
+  const fiches = mapDomainsToSlugs(keys);
+  const { uxDirectives, designSystem } = analyzeUxDesign(keys);
+  return { need, domainKeys: keys, domains, roles, regles, contraintes, failles, fiches, uxDirectives, designSystem };
+}
+// MODULE_COMPLETE

package/src/engine/analyze-ux.js

@@ -0,0 +1,42 @@
+// src/engine/analyze-ux.js — Charte visuelle + directives UX contextuelles au secteur.
+import { getRules } from "../rules/rules-registry.js";
+import { ensureDataLeakGuard } from "./ux-violations-leak.js";
+
+/** @type {UxDesignEntry} */
+const EMPTY_FAMILY = { family: "", style: "", density: "", palette: "", microInteractions: "", uxRules: [], designViolations: [] };
+
+// Détermine la charte visuelle + directives UX adaptées aux domaines détectés.
+// uxDirectives : fusion (dédupliquée) des uxRules. designSystem : famille du
+// domaine principal (1er détecté) ; violations fusionnées (dédup par règle).
+/** @param {string[]} domainKeys @returns {{ uxDirectives: string[], designSystem: { family: string, style: string, density: string, palette: string, microInteractions: string, wcag: string, violations: DesignViolation[] } }} */
+export function analyzeUxDesign(domainKeys) {
+  const keys = Array.isArray(domainKeys) && domainKeys.length ? domainKeys : ["logiciel_generique"];
+  /** @type {string[]} */
+  const uxDirectives = [];
+  /** @type {DesignViolation[]} */
+  const violations = [];
+  const ux = getRules().ux; // lot Pro absent (compte gratuit) : famille vide, aucune directive UX.
+  const family = (/** @type {string} */ k) => ux.design[k] || ux.design.logiciel_generique || EMPTY_FAMILY;
+  const primary = family(keys[0]);
+  for (const k of keys) {
+    const d = family(k);
+    for (const r of (d.uxRules || [])) {
+      if (!uxDirectives.includes(r)) uxDirectives.push(r);
+    }
+    for (const v of (d.designViolations || [])) {
+      if (!violations.some((x) => x.rule === v.rule)) {
+        violations.push({ rule: v.rule, patterns: [...(v.patterns || [])] });
+      }
+    }
+  }
+  for (const r of ux.universal) {
+    if (!uxDirectives.includes(r)) uxDirectives.push(r);
+  }
+  const designSystem = {
+    family: primary.family, style: primary.style, density: primary.density,
+    palette: primary.palette, microInteractions: primary.microInteractions,
+    wcag: "WCAG 2.1 AA", violations: ensureDataLeakGuard(violations),
+  };
+  return { uxDirectives, designSystem };
+}
+// MODULE_COMPLETE

package/src/engine/ask-history.js

@@ -0,0 +1,43 @@
+// src/engine/ask-history.js — Mémoire de conversation du chat (ChatView) : les
+// derniers tours user/assistant, transmis par l'extension via PLUGCTO_ASK_HISTORY
+// (JSON), sont mis en forme pour l'unique appel LLM de `auto ask`. Donnée NON
+// FIABLE (Zero Trust §3) : JSON illisible, rôle inconnu ou texte non-chaîne →
+// ignoré ; volume borné (tours, taille par tour, taille totale). Jamais de
+// fiche ni de doctrine ici : uniquement la conversation de l'utilisateur.
+
+import { purgeReasoning } from "./history-purge.js";
+
+const MAX_ENTRIES = 6; // contexte transmis au modèle : consigne + question + 6 derniers messages au plus
+const ENTRY_CAP = 1500;
+const TOTAL_CAP = 8000;
+const LABEL = { user: "Utilisateur", assistant: "PipCode" };
+
+/** Entrée valide (rôle connu + texte non vide) → ligne « Rôle : texte » bornée. */
+/** @param {unknown} e @returns {string} */
+function lineOf(e) {
+  const o = /** @type {{ r?: unknown, t?: unknown }} */ (e && typeof e === "object" ? e : {});
+  if (typeof o.r !== "string" || !Object.hasOwn(LABEL, o.r) || typeof o.t !== "string") return "";
+  const text = purgeReasoning(o.t).trim().slice(0, ENTRY_CAP); // jamais de raisonnement dans l'historique réinjecté
+  return text ? `${LABEL[/** @type {"user" | "assistant"} */ (o.r)]} : ${text}` : "";
+}
+
+/** Historique formaté ("" si absent/illisible), les tours RÉCENTS priment sur le budget. */
+/** @param {string | undefined} raw @returns {string} */
+export function formatAskHistory(raw) {
+  if (!raw) return "";
+  /** @type {unknown} */
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch { return ""; }
+  if (!Array.isArray(parsed)) return "";
+  const kept = [];
+  let size = 0;
+  for (const e of parsed.slice(-MAX_ENTRIES).reverse()) {
+    const line = lineOf(e);
+    if (!line) continue;
+    if (size + line.length > TOTAL_CAP) break;
+    size += line.length;
+    kept.unshift(line);
+  }
+  return kept.join("\n");
+}
+// MODULE_COMPLETE

package/src/engine/ask-llm.js

@@ -0,0 +1,40 @@
+// src/engine/ask-llm.js — Conversation pure « Parlez à votre CTO » (ChatView v2).
+// UN seul appel LLM BYOK borné : avis/conseil/réponse, SANS plan, SANS écriture
+// disque, SANS exécution. Zéro état, zéro fichier touché (conversation seulement).
+import { createDeltaEmitter } from "../core/progress-emit.js";
+import { callLLM } from "../core/llm-call.js";
+import { chatRules } from "./ask-rules.js";
+import { withLanguage } from "../core/lang.js";
+import { LeakGuard } from "../core/leak-guard.js";
+import { ASK_MAX_TOKENS, ASK_SYSTEM, askUserText } from "./ask-prompt.js";
+
+/** Erreur typée (code + message, jamais de stack exposée à l'appelant). */
+/** @param {string} code @param {string} message @returns {EnrichedError} */
+function askError(code, message) {
+  const err = /** @type {EnrichedError} */ (new Error(message));
+  err.code = code;
+  return err;
+}
+
+// Appel conversationnel unique. Validation stricte des entrées (Zero Trust §3).
+/** @param {{ primary: ProviderPrimary | null }} pcfg @param {string} question @param {string} [missionCtx] @param {string} [history] tours précédents (conversation seulement) @param {string} [projectCtx] contexte projet réel (arborescence, relations, fichiers) @param {string} [instructions] CLAUDE.md du client (prompt système, priorité haute) @param {string} [doctrine] fiches métier choisies pour cette question (prompt système, confidentielles) @returns {Promise<string>} */
+export async function askLLM(pcfg, question, missionCtx = "", history = "", projectCtx = "", instructions = "", doctrine = "") {
+  const q = String(question || "").trim();
+  if (!q) throw askError("ask_empty", "Question vide : rien à demander au CTO.");
+  const primary = pcfg && pcfg.primary;
+  if (!primary) throw askError("no_provider", "Aucun provider BYOK configuré.");
+  const userText = askUserText({ question: q, missionCtx: String(missionCtx || ""), history: String(history || "") });
+  const model = primary.smartModel || primary.model;
+  const { frugality, advisor, project } = chatRules(primary.base); // règles du serveur ; allégées pour un modèle local
+  const guard = new LeakGuard([frugality, advisor, project, doctrine]); // règles du serveur : jamais recopiées dans la réponse (ni dans l'aperçu en direct)
+  const deltas = createDeltaEmitter(); // chat dans VS Code : la réponse s'affiche jeton par jeton (sinon null : réponse d'un bloc)
+  const live = deltas ? (/** @type {string} */ t) => { const safe = guard.push(t); if (safe) deltas.push(safe); } : undefined;
+  try {
+    const raw = await callLLM({
+      provider: primary.provider, key: primary.key, model, base: primary.base, onDelta: live,
+      systemPrompt: withLanguage([ASK_SYSTEM, instructions, frugality, advisor, project, doctrine].filter(Boolean).join("\n\n")), cachePrefix: String(projectCtx || "").trim(), userText, maxTokens: ASK_MAX_TOKENS, showThinking: true,
+    });
+    return guard.sanitize(raw);
+  } finally { const rest = guard.end(); if (rest) deltas?.push(rest); deltas?.flush(); }
+}
+// MODULE_COMPLETE