pipcode 0.0.0-stage → 2.1.0

package/src/core/llm-ollama.js

@@ -0,0 +1,42 @@
+// src/core/llm-ollama.js — Échange avec Ollama (LOCAL ou CLOUD, deux services distincts) par l'API NATIVE /api/chat en STREAMING : le flux est lu
+// au fil de l'eau par un parser à deux états (raisonnement / réponse) ; seul le texte de RÉPONSE est rendu, le raisonnement n'est transmis
+// qu'au chat (showThinking). L'usage réel (tokens) est relevé comme pour les autres fournisseurs.
+
+import { localFetch } from "../net/local-fetch.js";
+import { buildOllamaRequest } from "./llm-ollama-request.js";
+import { OllamaLineFeeder, parseOllamaStream } from "./ollama-lines.js";
+import { THINKING } from "./dual-stream-parser.js";
+import { thinkingBudgetError } from "./reasoning-cut.js";
+import { recordUsage } from "./usage-meter.js";
+
+export { buildOllamaRequest, parseOllamaStream };
+
+/** Cloud : corps lu morceau par morceau ; sans flux lisible (simulacre) : texte d'un bloc. @param {Response} res @param {OllamaLineFeeder} feeder */
+async function readInto(res, feeder) {
+  if (!res.body) { feeder.push(await res.text()); return; }
+  const decoder = new TextDecoder();
+  for await (const chunk of /** @type {AsyncIterable<Uint8Array>} */ (/** @type {unknown} */ (res.body))) feeder.push(decoder.decode(chunk, { stream: true }));
+}
+
+/** @param {{ provider: string, key?: string, cloud?: boolean, showThinking?: boolean, onDelta?: (text: string) => void, base: string, model: string, budget: number, systemPrompt: string, userText: string, stablePrefix: string, signal: AbortSignal, label: string }} p @returns {Promise<string>} */
+export async function exchangeOllama(p) {
+  const { url, init } = buildOllamaRequest(p);
+  const feeder = new OllamaLineFeeder(p.onDelta);
+  const res = /** @type {Response} */ (/** @type {unknown} */ (p.cloud ? await fetch(url, init) : await localFetch(url, init, (c) => feeder.push(c)))); // cloud : HTTPS ; local : IPv4 keepAlive
+  if (!res.ok) {
+    const body = await res.text();
+    /** @type {EnrichedError} */ const e = new Error(`${parseOllamaError(body) || `HTTP ${res.status}`} — ${p.label} (modèle ${p.model})`);
+    e.status = res.status; e.provider = p.provider; throw e;
+  }
+  if (p.cloud) await readInto(res, feeder);
+  const { text, thinking, state, input, output, doneReason } = feeder.result();
+  if (!text.trim()) throw thinking.trim() && (state === THINKING || doneReason === "length") ? thinkingBudgetError(`${p.label}, modèle ${p.model}`) : new Error(`Réponse vide de ${p.label} (modèle ${p.model}).`);
+  recordUsage(p.provider, p.model, p.base, JSON.stringify({ usage: { prompt_tokens: input, completion_tokens: output } }));
+  return p.showThinking && thinking.trim() ? `<think>${thinking.trim()}</think>\n${text}` : text; // raisonnement transmis SEULEMENT au chat
+}
+
+/** @param {string} body @returns {string} */
+function parseOllamaError(body) {
+  try { return String(JSON.parse(body).error || ""); } catch { return ""; } // corps non-JSON : statut HTTP seul
+}
+// MODULE_COMPLETE

package/src/core/llm-prompts.js

@@ -0,0 +1,14 @@
+// src/core/llm-prompts.js — Accès aux prompts d'orchestration (Phase 1 diagnostic, Phase 2 diff) + constantes
+// de warmup. Les TEXTES des prompts vivent sur le serveur PipCode (lots de règles signés) : ici seulement des
+// accesseurs lisant le registre mémoire. Sans règles chargées → RulesNotLoadedError (jamais de prompt inventé).
+
+import { getRules } from "../rules/rules-registry.js";
+
+/** @returns {string} prompt d'analyse (byte-stable pendant la durée de vie des règles en mémoire) */
+export const analysisPrompt = () => getRules().prompts.analysis;
+/** @returns {string} prompt de patch (lot Pro ; vide pour un compte gratuit) */
+export const patchPrompt = () => getRules().prompts.patch;
+
+export const WARMUP_USER_TEXT = "OK";
+export const WARMUP_MAX_TOKENS = 16;
+// MODULE_COMPLETE

package/src/core/llm-providers.js

@@ -0,0 +1,26 @@
+// src/core/llm-providers.js — Catalogue providers + familles de modèles (smart/fast).
+// OpenRouter/Ollama/proxy passent par l'adaptateur openai mais ne sont PAS OpenAI natif.
+
+// Adresse (base URL) par défaut de chaque fournisseur. AUCUN modèle par défaut : le modèle est celui configuré par l'utilisateur.
+/** @type {Record<string, { base: string }>} */
+export const PROVIDER_DEFAULTS = {
+  openai:    { base: "https://api.openai.com/v1" },
+  anthropic: { base: "https://api.anthropic.com/v1" },
+  gemini:    { base: "https://generativelanguage.googleapis.com/v1beta" },
+  zhipu:     { base: "https://open.bigmodel.cn/api/paas/v4" },
+};
+
+/** @param {string} p @returns {boolean} */
+export function isValidProvider(p) {
+  return typeof p === "string" && Object.prototype.hasOwnProperty.call(PROVIDER_DEFAULTS, p);
+}
+
+// Normalise un host Ollama en base URL OpenAI-compatible (suffixe /v1, sans slash final).
+/** @param {string} host @returns {string} */
+export function normalizeOllamaBase(host) {
+  let h = String(host || "").trim().replace(/\/+$/, "");
+  if (!h) return "http://127.0.0.1:11434/v1";
+  if (!/\/v\d+$/.test(h)) h += "/v1";
+  return h;
+}
+// MODULE_COMPLETE

package/src/core/llm-request.js

@@ -0,0 +1,17 @@
+// src/core/llm-request.js — buildLLMRequest : dispatch vers le builder du provider
+// (scission audit hebdo). openai/zhipu (chat/completions), anthropic (messages +
+// cache_control ephemeral), gemini (generateContent). Builders : llm-builder-*.js.
+
+/** @typedef {{ base: string, key: string, model: string, budget: number, unbounded?: boolean, stream?: boolean, systemPrompt: string, userText: string, stablePrefix: string, signal: AbortSignal }} LLMParams */
+
+import { buildOpenAIStyle } from "./llm-builder-openai.js";
+import { buildAnthropicStyle } from "./llm-builder-anthropic.js";
+import { buildGeminiStyle } from "./llm-builder-gemini.js";
+
+/** @param {string} provider @param {LLMParams} p @returns {{ url: string, init: RequestInit }} */
+export function buildLLMRequest(provider, p) {
+  if (provider === "openai" || provider === "zhipu") return buildOpenAIStyle(p);
+  if (provider === "anthropic") return buildAnthropicStyle(p);
+  return buildGeminiStyle(p); // gemini (défaut)
+}
+// MODULE_COMPLETE

package/src/core/llm-retry-429.js

@@ -0,0 +1,23 @@
+// src/core/llm-retry-429.js — Dépassement de quota / fréquence (HTTP 429) chez N'IMPORTE QUEL fournisseur : 3 nouvelles tentatives avec délai
+// exponentiel + aléa (≈1 s, 2 s, 4 s), puis l'erreur d'origine est relancée, marquée « rateLimitExhausted » pour que les appelants ne
+// recommencent pas la même série. Les autres erreurs passent telles quelles (aucune nouvelle tentative ici).
+
+export const RETRY_429 = { retries: 3, baseMs: 1000, jitter: 0.25 };
+
+/** @param {number} ms @returns {Promise<void>} */
+const sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** @template T @param {() => Promise<T>} fn @param {{ sleep?: (ms: number) => Promise<void>, random?: () => number }} [deps] @returns {Promise<T>} */
+export async function retryOn429(fn, { sleep = sleepMs, random = Math.random } = {}) {
+  for (let attempt = 0; ; attempt++) {
+    try { return await fn(); }
+    catch (err) {
+      const e = /** @type {EnrichedError} */ (err);
+      if (e?.status !== 429) throw err;
+      if (attempt >= RETRY_429.retries) { e.rateLimitExhausted = true; throw err; }
+      const base = RETRY_429.baseMs * 2 ** attempt;
+      await sleep(Math.round(base * (1 - RETRY_429.jitter + random() * 2 * RETRY_429.jitter)));
+    }
+  }
+}
+// MODULE_COMPLETE

package/src/core/llm-stream-events.js

@@ -0,0 +1,29 @@
+// src/core/llm-stream-events.js — Un événement de flux (JSON) → texte de RÉPONSE, usage et erreur, selon la famille de fournisseur. Le raisonnement
+// (reasoning_content, parties « thought ») n'est JAMAIS du texte de réponse. Entrée non fiable : JSON illisible ignoré, champs vérifiés.
+
+/** @typedef {{ text: string, usage: Record<string, unknown> | null, error: string }} StreamAcc */
+
+/** @param {unknown} v @returns {string} */
+const str = (v) => (typeof v === "string" ? v : "");
+
+/** @param {string} provider @param {string} data événement brut (JSON) @param {StreamAcc} acc @returns {string} texte nouveau (peut être "") */
+export function applyStreamEvent(provider, data, acc) {
+  if (data.trim() === "[DONE]") return "";
+  /** @type {Record<string, any>} */ let j;
+  try { j = JSON.parse(data); } catch { return ""; } // morceau illisible : ignoré
+  if (j && typeof j === "object" && j.error) { acc.error = str(j.error.message) || "Erreur du fournisseur pendant le flux."; return ""; }
+  if (provider === "gemini") {
+    if (j.usageMetadata) acc.usage = { usageMetadata: j.usageMetadata };
+    const parts = j.candidates?.[0]?.content?.parts;
+    return Array.isArray(parts) ? parts.filter((x) => x && !x.thought).map((x) => str(x.text)).join("") : "";
+  }
+  if (provider === "anthropic") {
+    if (j.type === "message_start" && j.message?.usage) acc.usage = { usage: { ...j.message.usage } };
+    if (j.type === "message_delta" && j.usage) acc.usage = { usage: { ...(acc.usage?.usage ?? {}), ...j.usage } };
+    if (j.type === "error") acc.error = str(j.error?.message) || "Erreur du fournisseur pendant le flux.";
+    return j.type === "content_block_delta" && j.delta?.type === "text_delta" ? str(j.delta.text) : "";
+  }
+  if (j.usage) acc.usage = { usage: j.usage }; // OpenAI et compatibles (stream_options.include_usage)
+  return str(j.choices?.[0]?.delta?.content);
+}
+// MODULE_COMPLETE

package/src/core/llm-stream.js

@@ -0,0 +1,42 @@
+// src/core/llm-stream.js — UN échange en FLUX (SSE) avec OpenAI et compatibles, Anthropic ou Gemini natif : chaque morceau de réponse est remis à `onDelta`
+// pendant la génération (affichage jeton par jeton), le texte complet est rendu à la fin, l'usage réel relevé. Le raisonnement est écarté (parser à deux
+// états : balises <think> comprises). Erreur HTTP → mêmes messages que l'échange classique (parseLLMResponse) ; l'annulation passe par le signal.
+import { isLocalBase } from "./llm-label.js";
+import { localFetch } from "../net/local-fetch.js";
+import { buildLLMRequest } from "./llm-request.js";
+import { parseLLMResponse } from "./llm-extract.js";
+import { recordUsage } from "./usage-meter.js";
+import { SseParser } from "./sse-parser.js";
+import { applyStreamEvent } from "./llm-stream-events.js";
+import { DualStreamTokenParser } from "./dual-stream-parser.js";
+
+/** Corps lu morceau par morceau ; sans flux lisible (simulacre) : texte d'un bloc. @param {Response} res @param {SseParser} sse */
+async function readInto(res, sse) {
+  if (!res.body) { sse.push(await res.text()); return; }
+  const decoder = new TextDecoder();
+  for await (const chunk of /** @type {AsyncIterable<Uint8Array>} */ (/** @type {unknown} */ (res.body))) sse.push(decoder.decode(chunk, { stream: true }));
+}
+
+/** @param {{ provider: string, key: string, model: string, base: string, budget: number, unbounded?: boolean, systemPrompt: string, userText: string, stablePrefix: string, signal: AbortSignal, label: string, onDelta: (text: string) => void }} p @returns {Promise<string>} */
+export async function exchangeStream(p) {
+  const { url, init } = buildLLMRequest(p.provider, { ...p, stream: true });
+  /** @type {import("./llm-stream-events.js").StreamAcc} */ const acc = { text: "", usage: null, error: "" };
+  const answer = new DualStreamTokenParser();
+  let sent = 0;
+  const sse = new SseParser((data) => {
+    answer.content(applyStreamEvent(p.provider, data, acc)); // seul le texte de RÉPONSE avance (raisonnement écarté)
+    if (answer.payload.length > sent) { p.onDelta(answer.payload.slice(sent)); sent = answer.payload.length; }
+  });
+  const local = isLocalBase(p.base);
+  const res = /** @type {Response} */ (/** @type {unknown} */ (local ? await localFetch(url, init, (c) => sse.push(c)) : await fetch(url, init)));
+  if (!res.ok) { parseLLMResponse(p.provider, p.model, res, await res.text(), p.label, url); throw new Error(`HTTP ${res.status} de ${p.label} (modèle ${p.model}) — URL : ${url.split("?")[0]}`); }
+  if (!local) await readInto(res, sse);
+  sse.end();
+  const text = answer.end().payload;
+  if (acc.error) throw new Error(`${acc.error} — ${p.label} (modèle ${p.model})`);
+  if (!text.trim()) throw new Error(`Réponse vide de ${p.label} (modèle ${p.model}).`);
+  if (answer.payload.length > sent) p.onDelta(answer.payload.slice(sent)); // reste retenu par le parser (balise coupée en fin de flux)
+  if (acc.usage) recordUsage(p.provider, p.model, p.base, JSON.stringify(acc.usage));
+  return text;
+}
+// MODULE_COMPLETE

package/src/core/llm-unbounded.js

@@ -0,0 +1,15 @@
+// src/core/llm-unbounded.js — Échange SANS limite de sortie pour les modèles à raisonnement. Un modèle que la liste ne connaît pas mais qui
+// se fait couper PENDANT sa réflexion (erreur typée thinking_budget) est relancé UNE fois sans limite : jamais de limite de remplacement.
+import { exchange } from "./llm-exchange.js";
+import { isReasoningModel } from "./reasoning-models.js";
+
+/** @param {Parameters<typeof exchange>[0]} params @returns {Promise<string>} */
+export async function exchangeUnbounded(params) {
+  const known = isReasoningModel(params.model);
+  try { return await exchange({ ...params, unbounded: known }); }
+  catch (e) {
+    if (known || /** @type {EnrichedError} */ (e)?.code !== "thinking_budget") throw e;
+    return exchange({ ...params, unbounded: true });
+  }
+}
+// MODULE_COMPLETE

package/src/core/llm-warmup.js

@@ -0,0 +1,44 @@
+// src/core/llm-warmup.js — warmupCache : pré-charge les préfixes byte-stables (Anthropic prompt caching).
+// Amorce le cache ephemeral au boot (ANALYSIS/PATCH prompts + missionContext). Best-effort, silencieux.
+import { callLLM } from "./llm-call.js";
+import { analysisPrompt, patchPrompt, WARMUP_USER_TEXT, WARMUP_MAX_TOKENS } from "./llm-prompts.js";
+
+// Pré-charge le cache prompt Anthropic. Inactif si PLUGCTO_CACHE_WARMUP=0 ou pas d'Anthropic.
+/** @param {{ primary: ProviderPrimary } | null} pcfg @param {{ callLLM?: typeof callLLM, missionContext?: string }} [opts] @returns {Promise<WarmupResult>} */
+export async function warmupCache(pcfg, opts = {}) {
+  const call = typeof opts.callLLM === "function" ? opts.callLLM : callLLM;
+  const missionContext = typeof opts.missionContext === "string" ? opts.missionContext : "";
+  if (process.env.PLUGCTO_CACHE_WARMUP === "0") {
+    return { warmed: false, reason: "disabled", primed: [] };
+  }
+  const providers = /** @type {ProviderPrimary[]} */ ([pcfg && pcfg.primary].filter((p) => p && p.provider === "anthropic"));
+  if (providers.length === 0) {
+    return { warmed: false, reason: "no_anthropic", primed: [] };
+  }
+  /** @type {{ name: string, systemPrompt: string }[]} */ let targets;
+  try { targets = [{ name: "analysis", systemPrompt: analysisPrompt() }, { name: "patch", systemPrompt: patchPrompt() }].filter((t) => t.systemPrompt); }
+  catch { return { warmed: false, reason: "rules_not_loaded", primed: [] }; }
+  /** @type {WarmupPrimedEntry[]} */
+  const primed = [];
+  const tasks = [];
+  for (const p of providers) {
+    for (const t of targets) {
+      tasks.push(
+        Promise.resolve()
+          .then(() => call({
+            provider: "anthropic", key: p.key, model: p.model, base: p.base,
+            systemPrompt: t.systemPrompt, cachePrefix: missionContext,
+            userText: WARMUP_USER_TEXT, maxTokens: WARMUP_MAX_TOKENS,
+          }))
+          .then(() => primed.push({ provider: "anthropic", model: p.model, target: t.name, ok: true }))
+          .catch((err) => primed.push({
+            provider: "anthropic", model: p.model, target: t.name, ok: false,
+            error: (err && err.message) || String(err),
+          }))
+      );
+    }
+  }
+  await Promise.all(tasks);
+  return { warmed: primed.some((p) => p.ok), reason: "done", primed };
+}
+// MODULE_COMPLETE

package/src/core/manifest.js

@@ -0,0 +1,42 @@
+// src/core/manifest.js — Catalogue statique d'outils MCP (métadonnées hors-ligne).
+// Une entrée = un outil MCP. slug → fetch cloud signé ; tier = étiquette MIROIR
+// de src/worker/skill-tiers.js (anti-désynchronisation : test miroir).
+// Gate client réelle : sans licence, isWithinTrial (horloge locale, UX SEULEMENT)
+// ouvre tout ; hors essai → seules les fiches tier "lite" passent (handle-skill.js).
+// L'autorité monétaire RÉELLE est le serveur (SKILL_TIERS + trialGate worker) —
+// cette étiquette ne fait que refléter le catalogue payant, jamais accorder.
+
+/** @typedef {{ name: string, slug: string, tier: string, title: string }} ManifestEntry */
+
+/** @type {ManifestEntry[]} */
+export const MANIFEST = [
+  { name: "enforce_readme", slug: "README", tier: "pro", title: "Skills — Virtual CTO (Standard V-CTO, extrait cognitif)" },
+  { name: "enforce_core_rules", slug: "core_rules", tier: "pro", title: "Règles Absolues du CTO — Standard V-CTO (couches Rules)" },
+  { name: "enforce_cto_pillars", slug: "cto_pillars", tier: "pro", title: "Les 7 Piliers du CTO — Grille d'audit interne" },
+  { name: "enforce_orchestration_pipeline", slug: "orchestration_pipeline", tier: "pro", title: "Pipeline d'Orchestration & Cycle DevSecOps — 5 Agents" },
+  { name: "enforce_security_auditor", slug: "security_auditor", tier: "pro", title: "Persona : Auditeur DevSecOps — Traque des Vulnérabilités avant Production" },
+  { name: "enforce_persona_architect", slug: "persona_architect", tier: "pro", title: "Persona : Architecte Backend & Auditeur DevSecOps (CTO Virtuel)" },
+  { name: "enforce_persona_intake", slug: "persona_intake", tier: "pro", title: "Persona : Directeur Technique d'Agence Web (Intake)" },
+  { name: "enforce_persona_sql_architect", slug: "persona_sql_architect", tier: "pro", title: "Persona : Architecte SQL Automatisé" },
+  { name: "enforce_persona_game_dev_router", slug: "persona_game_dev_router", tier: "pro", title: "Persona : CTO Routeur Game Development Engineering" },
+  { name: "enforce_game_dev_standards", slug: "game_dev_standards", tier: "pro", title: "Standards Game Development Engineering — 5 Sous-Rôles" },
+  { name: "enforce_standards_by_category", slug: "standards_by_category", tier: "pro", title: "Standards par Catégorie de Projet" },
+  { name: "enforce_token_optimization", slug: "token_optimization", tier: "lite", title: "Optimisation des Tokens — Prompt Caching Statique & Context Trimming" },
+  { name: "enforce_defensive_engineering", slug: "defensive_engineering", tier: "pro", title: "Ingénierie Défensive — Couche d'Anticipation des Bugs & Sécurisation" },
+  { name: "enforce_appsec_compliance", slug: "appsec_compliance", tier: "pro", title: "AppSec & Conformité — Intégration Sécurité Logicielle et Cadres Réglementaires" },
+  { name: "enforce_data_mlops_pipeline", slug: "data_mlops_pipeline", tier: "pro", title: "Data & MLOps Pipeline — Ingénierie des Données et Cycle de Vie des Modèles" },
+  { name: "enforce_devex_documentation", slug: "devex_documentation", tier: "pro", title: "Developer Experience & Documentation — Doc-as-Code et Onboarding Mesurable" },
+  { name: "enforce_finops_governance", slug: "finops_governance", tier: "pro", title: "FinOps & Governance — Maîtrise des Coûts Cloud et Gouvernance Technique" },
+  { name: "enforce_delivery_scale", slug: "delivery_scale", tier: "pro", title: "Delivery & Scale — Livraison Continue, Observabilité et Scalabilité" },
+  { name: "enforce_design_ux", slug: "design_ux", tier: "pro", title: "Design & Interface — Direction Visuelle, Accessibilité et Vérification du Rendu" },
+];
+
+/** @type {Map<string, ManifestEntry>} */
+export const toolsByName = new Map(MANIFEST.map((m) => [m.name, m]));
+
+// Valide le nom d'un outil MCP (anti-injection de nom : préfixe enforce_ + [a-z0-9_]).
+/** @param {string} name @returns {boolean} */
+export function isValidToolName(name) {
+  return typeof name === "string" && /^enforce_[a-z0-9_]+$/.test(name);
+}
+// MODULE_COMPLETE

package/src/core/master-prompt.js

@@ -0,0 +1,11 @@
+// src/core/master-prompt.js — Master Prompt blindé (séparation des privilèges, sandboxing <CTO_VAULT>,
+// anti-fuite). Le GABARIT vit sur le serveur PipCode (lot de règles signé) ; ici seulement l'insertion de la
+// fiche à l'emplacement prévu. Aucune interpolation dynamique hors skillContent (préfixe byte-stable).
+import { getRules } from "../rules/rules-registry.js";
+import { SKILL_PLACEHOLDER } from "../rules/rules-validate.js";
+
+/** split/join : le contenu de la fiche est inséré tel quel (aucun motif `$&` interprété). @param {string} skillContent @returns {string} */
+export function buildMasterPrompt(skillContent) {
+  return getRules().prompts.master.split(SKILL_PLACEHOLDER).join(skillContent);
+}
+// MODULE_COMPLETE

package/src/core/model-id.js

@@ -0,0 +1,19 @@
+// src/core/model-id.js — Identifiant de modèle ASSAINI juste avant toute requête : Google liste ses modèles « models/gemini-… » (liste
+// OpenAI-compatible comprise) mais n'accepte que « gemini-… » dans le corps de la requête ET dans l'URL native (qui contient déjà /models/) ;
+// le préfixe provoquait des 404. Le préfixe « google/ » (OpenRouter) est retiré de la même façon, mais UNIQUEMENT pour l'hôte Google : chez OpenRouter
+// « google/gemini-… » est l'identifiant légitime et doit rester intact.
+
+/** @param {string} rawModel @returns {string} identifiant nu, « gemini-… » */
+export function sanitizeGeminiModelId(rawModel) {
+  if (!rawModel) return "";
+  return String(rawModel).trim().replace(/^(models\/|google\/)+/i, "").trim();
+}
+
+/** @param {string} base adresse du fournisseur @param {string} model @returns {string} */
+export function sanitizeModelId(base, model) {
+  const id = String(model ?? "").trim();
+  let host = "";
+  try { host = new URL(String(base)).hostname; } catch { return id; } // adresse illisible : identifiant inchangé
+  return host === "generativelanguage.googleapis.com" ? sanitizeGeminiModelId(id) : id;
+}
+// MODULE_COMPLETE

package/src/core/ollama-lines.js

@@ -0,0 +1,48 @@
+// src/core/ollama-lines.js — Flux Ollama (une ligne JSON par morceau) → parser à deux états. Alimenté au fil de l'eau (télémétrie du
+// raisonnement) ou d'un coup. Une ligne illisible est ignorée ; une ligne d'erreur d'Ollama est retenue et levée à result().
+import { DualStreamTokenParser, THINKING } from "./dual-stream-parser.js";
+import { emitProgress } from "./progress-emit.js";
+
+export class OllamaLineFeeder {
+  /** @param {(text: string) => void} [onText] texte de RÉPONSE au fil de l'eau (jamais le raisonnement) */
+  constructor(onText) { this.onText = onText; this.sent = 0; this.parser = new DualStreamTokenParser(); this.buf = ""; this.input = 0; this.output = 0; this.doneReason = ""; this.error = ""; this.last = ""; }
+
+  /** @param {string} chunk */
+  push(chunk) {
+    const lines = (this.buf + chunk).split("\n");
+    this.buf = lines.pop() ?? "";
+    for (const line of lines) this.#line(line);
+  }
+
+  /** @param {string} raw */
+  #line(raw) {
+    if (!raw.trim()) return;
+    /** @type {{ error?: string, done_reason?: string, message?: { content?: string, thinking?: string }, prompt_eval_count?: number, eval_count?: number }} */ let o;
+    try { o = JSON.parse(raw); } catch { return; } // ligne illisible : ignorée
+    if (o.error) { this.error = String(o.error); return; }
+    this.parser.reason(o.message?.thinking ?? "");
+    this.parser.content(o.message?.content ?? "");
+    if (this.onText && this.parser.payload.length > this.sent) { this.onText(this.parser.payload.slice(this.sent)); this.sent = this.parser.payload.length; }
+    this.input = o.prompt_eval_count ?? this.input; this.output = o.eval_count ?? this.output; this.doneReason = o.done_reason ?? this.doneReason;
+    if (this.parser.state === THINKING) emitProgress({ k: "thinking", n: Math.round(this.parser.thinking.length / 4) });
+    else { emitProgress({ k: "tick" }); if (this.last === THINKING) emitProgress({ k: "payload" }); }
+    this.last = this.parser.state;
+  }
+
+  /** @returns {{ text: string, thinking: string, state: string, input: number, output: number, doneReason: string }} */
+  result() {
+    this.#line(this.buf); this.buf = "";
+    if (this.error) throw new Error(this.error);
+    const r = this.parser.end();
+    return { text: r.payload, thinking: r.thinking, state: r.state, input: this.input, output: this.output, doneReason: this.doneReason };
+  }
+}
+
+/** Corps complet → { text, thinking, input, output } ; une ligne d'erreur d'Ollama lève. @param {string} body @returns {{ text: string, thinking: string, input: number, output: number }} */
+export function parseOllamaStream(body) {
+  const f = new OllamaLineFeeder();
+  f.push(body);
+  const { text, thinking, input, output } = f.result();
+  return { text, thinking, input, output };
+}
+// MODULE_COMPLETE

package/src/core/ollama.js

@@ -0,0 +1,43 @@
+// src/core/ollama.js — Ollama (127.0.0.1:11434) : détection, racine de l'API native, fenêtre de contexte demandée (num_ctx) et budget
+// de prompt réduit. Un modèle local évalue le prompt lentement : on lui envoie le STRICT utile. num_ctx est choisi pour que le prompt
+// et la réponse tiennent (jamais de troncature silencieuse par Ollama), par défaut 8192 (PLUGCTO_OLLAMA_NUM_CTX : 4096 à 131072).
+import { ipv4Loopback } from "../net/loopback.js";
+
+const MIN_CTX = 4096; const MAX_CTX = 131_072; const DEFAULT_CTX = 8192;
+const CHARS_PER_TOKEN = 3; // prudent : sous-estimer les caractères par token évite la troncature
+
+/** Serveur Ollama = boucle locale IPv4 sur le port 11434. @param {string} base @returns {boolean} */
+export function isOllamaBase(base) {
+  try { const u = new URL(ipv4Loopback(String(base))); return u.hostname === "127.0.0.1" && u.port === "11434"; } catch { return false; } // adresse illisible : pas Ollama
+}
+
+/** Ollama CLOUD (ollama.com) : service distinct d'Ollama local — clé API, API native en HTTPS. @param {string} base @returns {boolean} */
+export function isOllamaCloudBase(base) {
+  try { return /^(www\.)?ollama\.com$/i.test(new URL(String(base)).hostname); } catch { return false; } // adresse illisible : pas Ollama cloud
+}
+
+/** « http://127.0.0.1:11434/v1 » ou « https://ollama.com/api » → racine de l'API native. @param {string} base @returns {string} */
+export const ollamaRoot = (base) => ipv4Loopback(String(base)).replace(/\/+$/, "").replace(/\/(v\d+|api)$/, "");
+
+/** @param {Record<string, string | undefined>} [env] @returns {number} fenêtre de base demandée */
+export function baseNumCtx(env = process.env) {
+  const n = Number.parseInt(env.PLUGCTO_OLLAMA_NUM_CTX || "", 10);
+  return Number.isFinite(n) && n >= MIN_CTX && n <= MAX_CTX ? n : DEFAULT_CTX;
+}
+
+/** num_ctx suffisant pour ce prompt + la réponse (arrondi au Ko), jamais sous la base. @param {number} promptChars @param {number} predict @returns {number} */
+export function numCtxFor(promptChars, predict) {
+  const needed = Math.ceil(promptChars / CHARS_PER_TOKEN) + predict;
+  return Math.min(MAX_CTX, Math.max(baseNumCtx(), Math.ceil(needed / 1024) * 1024));
+}
+
+/** Budget (caractères) du CONTEXTE PROJET injecté dans le chat pour Ollama : ~1/4 de la fenêtre (le reste : consignes, historique, réponse). @returns {number} */
+export const ollamaPromptChars = () => Math.floor(baseNumCtx() * CHARS_PER_TOKEN * 0.25);
+
+/** Garde les lignes les plus RÉCENTES dans la limite. @param {string} text @param {number} max @returns {string} */
+export function keepRecentLines(text, max) {
+  const kept = []; let used = 0;
+  for (const l of text.split("\n").reverse()) { if (used + l.length + 1 > max) break; used += l.length + 1; kept.unshift(l); }
+  return kept.join("\n");
+}
+// MODULE_COMPLETE

package/src/core/pkg-manager.js

@@ -0,0 +1,35 @@
+// src/core/pkg-manager.js — Agnosticisme des gestionnaires de paquets (Point #3).
+// Détection via npm_config_user_agent (renseigné par npm/pnpm/yarn/bun). Jamais
+// de conditionnement exclusif à npm : les routines setup/teardown sont 100 %
+// Node.js pur — la détection ne sert qu'à l'affichage et à l'aide contextuelle.
+
+/** @typedef {"npm" | "pnpm" | "yarn" | "bun" | "unknown"} PmName */
+/** @typedef {{ name: PmName, label: string }} PmInfo */
+
+// Étiquettes affichables + équivalent de `npx` par gestionnaire (aide dynamique).
+/** @type {{ [k: string]: { label: string, run: string } }} */
+const PM_META = {
+  npm: { label: "npm", run: "npx" },
+  pnpm: { label: "pnpm", run: "pnpm dlx" },
+  yarn: { label: "yarn", run: "yarn dlx" },
+  bun: { label: "bun", run: "bunx" },
+};
+
+// Détecte le gestionnaire actif : npm_config_user_agent commence par "<pm>/<version>".
+/** @param {NodeJS.ProcessEnv} [env] @returns {PmInfo} */
+export function detectPackageManager(env = process.env) {
+  const ua = String(env.npm_config_user_agent || "");
+  const name = (ua.match(/^(npm|pnpm|yarn|bun)\//) || [])[1] || "unknown";
+  const meta = PM_META[name];
+  return meta
+    ? { name: /** @type {PmName} */ (name), label: meta.label }
+    : { name: "unknown", label: "non détecté" };
+}
+
+// Commande d'exécution équivalente à `npx` pour le gestionnaire détecté.
+/** @param {PmInfo} [pm] @returns {string} */
+export function pmRunCommand(pm = detectPackageManager()) {
+  const meta = PM_META[pm.name];
+  return meta ? meta.run : "npx";
+}
+// MODULE_COMPLETE

package/src/core/process-guards.js

@@ -0,0 +1,47 @@
+// src/core/process-guards.js — Handlers process : aucun crash silencieux,
+// aucun survie en état incohérent : exception ou rejet non géré → log stderr
+// puis exit 1 (fail-fast, aligné sur uncaughtException).
+
+// Enregistre les handlers globaux une seule fois (drapeau interne : un double
+// appel n'empilerait pas des listeners en doublon).
+let _installed = false;
+
+// Nettoyage best-effort armé par le mode Auto pendant une opération git
+// critique (apply/commit) : un Ctrl+C déclenche le gitRestore de secours.
+/** @type {(() => Promise<void>) | null} */
+let _interruptCleanup = null;
+
+/** Arme (ou désarme avec null) le nettoyage d'interruption. @param {(() => Promise<void>) | null} fn */
+export function setInterruptCleanup(fn) {
+  _interruptCleanup = fn;
+}
+
+// Exécute le nettoyage armé puis sort (codes convention shell : 130 SIGINT,
+// 143 SIGTERM). Best-effort : un nettoyage qui échoue ne masque pas l'exit.
+/** @param {NodeJS.Signals} signal @param {(code: number) => void} [exit] @returns {Promise<void>} */
+export async function runInterruptCleanup(signal, exit = process.exit) {
+  const code = signal === "SIGTERM" ? 143 : 130;
+  if (_interruptCleanup) {
+    try { await _interruptCleanup(); } catch (err) {
+      console.error(`[virtual-cto] Nettoyage ${signal} échoué (best-effort) :`, err);
+    }
+  }
+  exit(code);
+}
+
+export function installProcessGuards() {
+  if (_installed) return;
+  _installed = true;
+  process.on("unhandledRejection", (reason) => {
+    console.error("[virtual-cto] Rejet non géré (unhandledRejection) :", reason);
+    process.exit(1);
+  });
+  process.on("uncaughtException", (err) => {
+    console.error("[virtual-cto] Exception non capturée (uncaughtException) :", err);
+    process.exit(1);
+  });
+  // SIGINT/SIGTERM : nettoyage armé de secours avant exit (codes 130/143).
+  process.on("SIGINT", () => { void runInterruptCleanup("SIGINT"); });
+  process.on("SIGTERM", () => { void runInterruptCleanup("SIGTERM"); });
+}
+// MODULE_COMPLETE

package/src/core/progress-emit.js

@@ -0,0 +1,25 @@
+// src/core/progress-emit.js — Télémétrie ÉPHÉMÈRE moteur → interface : une ligne « @@VCTO_PROGRESS@@{json} » sur stderr, seulement si
+// l'interface l'a demandé (PLUGCTO_PROGRESS=1). Jamais le contenu du raisonnement : uniquement son avancement (tokens estimés). Limitée à 1/s.
+
+export const PROGRESS_PREFIX = "@@VCTO_PROGRESS@@";
+const THROTTLE_MS = 1000;
+/** @type {Record<string, number>} */ const last = {};
+
+/** @typedef {{ k: "thinking", n: number } | { k: "payload" } | { k: "tick" } | { k: "stage", s: "rules" | "project" | "sheets" | "model" } | { k: "delta", t: string } | { k: "task", state: "start" | "done" | "failed", id: string, title: string, n: number, total: number }} ProgressEvent */
+
+/** @param {ProgressEvent} event @param {number} [now] @param {{ write: (s: string) => unknown }} [out] */
+export function emitProgress(event, now = Date.now(), out = process.stderr) {
+  if (process.env.PLUGCTO_PROGRESS !== "1") return;
+  if (event.k === "thinking" || event.k === "tick") { if (now - (last[event.k] ?? 0) < THROTTLE_MS) return; last[event.k] = now; }
+  out.write(`${PROGRESS_PREFIX}${JSON.stringify(event)}\n`);
+}
+
+/** Morceaux de réponse regroupés (≈ 40 ms) en un seul événement « delta » : un jeton par ligne saturerait le canal. Sans demande de l'interface : null.
+ *  @param {(event: ProgressEvent) => void} [emit] @param {() => number} [now] @returns {{ push: (text: string) => void, flush: () => void } | null} */
+export function createDeltaEmitter(emit = emitProgress, now = Date.now) {
+  if (process.env.PLUGCTO_PROGRESS !== "1") return null;
+  let buf = ""; let last = 0;
+  const flush = () => { if (buf) { emit({ k: "delta", t: buf }); buf = ""; } last = now(); };
+  return { push: (text) => { buf += text; if (now() - last >= 40) flush(); }, flush };
+}
+// MODULE_COMPLETE

package/src/core/purge-key.js

@@ -0,0 +1,20 @@
+// src/core/purge-key.js — Purge Anti-Hostage (SecOps monétisation).
+// Essai expiré ou licence invalidée (402/403/429 du Worker) → effacement
+// INSTANTANÉ de la clé de licence de TOUT stockage : config.json
+// (licenseKey) + cache RAM du token de session. Idempotent. La clé BYOK
+// provider n'est JAMAIS touchée (propriété de l'utilisateur).
+
+import { saveConfig } from "./config-base.js";
+import { purgeSessionCache } from "./session-net.js";
+import { purgeTrialCache } from "./trial-session.js";
+
+/** @param {PlugConfig} cfg @param {string} reason @returns {Promise<void>} */
+export async function purgeLicenseKey(cfg, reason) {
+  purgeSessionCache(); // cache RAM du token : vidé avant toute autre action.
+  purgeTrialCache();   // cache RAM du jeton d'essai : vidé lui aussi (anti-hostage).
+  if (!cfg || !cfg.licenseKey) return;
+  cfg.licenseKey = "";
+  await saveConfig(cfg);
+  console.error(`[virtual-cto] Licence purgée du stockage (anti-hostage) : ${reason}`);
+}
+// MODULE_COMPLETE

package/src/core/reasoning-cut.js

@@ -0,0 +1,19 @@
+// src/core/reasoning-cut.js — Réponse OpenAI-compatible coupée PAR LA LIMITE (finish_reason « length ») alors que le modèle en était encore à
+// réfléchir (raisonnement présent, réponse vide) : message dédié plutôt qu'un « réponse vide » trompeur.
+
+export const THINKING_BUDGET_MESSAGE = "Dépassement du budget de réflexion initial. Réessayez sans bridage de tokens.";
+
+/** Erreur typée « budget de réflexion » : l'appelant peut relancer SANS limite. @param {string} where @returns {EnrichedError} */
+export function thinkingBudgetError(where) {
+  /** @type {EnrichedError} */ const e = new Error(`${THINKING_BUDGET_MESSAGE} (${where})`);
+  e.code = "thinking_budget";
+  return e;
+}
+
+/** @param {unknown} parsed réponse JSON du fournisseur @returns {boolean} */
+export function cutWhileThinking(parsed) {
+  const choice = /** @type {{ choices?: { finish_reason?: unknown, message?: { reasoning_content?: unknown, reasoning?: unknown } }[] }} */ (parsed)?.choices?.[0];
+  const reasoning = choice?.message?.reasoning_content ?? choice?.message?.reasoning;
+  return choice?.finish_reason === "length" && typeof reasoning === "string" && reasoning.trim() !== "";
+}
+// MODULE_COMPLETE

package/src/core/reasoning-models.js

@@ -0,0 +1,8 @@
+// src/core/reasoning-models.js — Modèles à RAISONNEMENT (GLM, DeepSeek-R1, Kimi, gpt-oss, QwQ, Qwen3, Gemini 2.5/3…) : ils dépensent des tokens à
+// réfléchir AVANT de répondre ; toute limite de sortie les laisse sans réponse. Pour eux AUCUNE limite n'est envoyée (voir les builders).
+
+const REASONING = /(glm[-_]?[4-9]|deepseek[-_]?(r1|reasoner)|kimi|k2[-_]?thinking|qwq|qwen3|gpt[-_]?oss|thinking|reasoner|gemini[-_]?(2\.5|3)|(^|[^a-z0-9])o[134](-|$))/i;
+
+/** @param {unknown} model @returns {boolean} */
+export const isReasoningModel = (model) => typeof model === "string" && REASONING.test(model);
+// MODULE_COMPLETE