Les instruments

/**
 * Les annuaires d'agents : lisibles à l'œil, illisibles par un programme ?
 *
 * Le scan de cartes mesure ce que chaque organisation expose chez elle. Il ne
 * dit rien du niveau au-dessus : les annuaires qui se présentent comme des
 * registres de l'agentique. Un registre a une fonction exacte — permettre à un
 * programme d'énumérer ce qu'il contient. Un site qui affiche des agents dans
 * une page et ne sert aucun index machine n'est pas un registre : c'est une
 * vitrine.
 *
 * Ce script teste, pour chaque annuaire, les chemins d'index plausibles et
 * consigne ce qu'ils renvoient vraiment : code HTTP, type de contenu, et si le
 * corps s'analyse comme du JSON. Une page HTML servie en 200 sur /agents.json
 * est le résultat le plus intéressant, et c'est celui qu'on rencontre.
 *
 *   node outils/annuaires.mjs
 *
 * Sortie : donnees/mesures/annuaires.json
 */

import { writeFileSync, mkdirSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const DELAI = 12000;

/**
 * Les annuaires. Chacun se décrit lui-même comme un registre, un annuaire ou
 * un répertoire d'agents ou de serveurs MCP — c'est le seul critère d'entrée,
 * et il est vérifiable sur leur page d'accueil.
 */
const ANNUAIRES = [
  { domaine: "a2aregistry.org", protocole: "A2A" },
  { domaine: "www.a2a-registry.org", protocole: "A2A" },
  { domaine: "agentry.com", protocole: "A2A" },
  { domaine: "mcp.so", protocole: "MCP" },
  { domaine: "smithery.ai", protocole: "MCP" },
  { domaine: "glama.ai", protocole: "MCP" },
  { domaine: "pulsemcp.com", protocole: "MCP" },
  { domaine: "mcpservers.org", protocole: "MCP" },
];

/**
 * Les chemins d'index plausibles. Aucune norme n'en impose un : c'est déjà le
 * fond du problème, et la liste est donc celle qu'un client raisonnable
 * essaierait avant d'abandonner.
 */
const CHEMINS = [
  "/registry.json",
  "/agents.json",
  "/api/agents",
  "/api/v1/agents",
  "/api/servers",
  "/index.json",
  "/.well-known/agent-registry.json",
  "/.well-known/agent-card.json",
];

async function tirer(url) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), DELAI);
  try {
    const r = await fetch(url, {
      signal: ctrl.signal,
      redirect: "follow",
      headers: { accept: "application/json", "user-agent": "LIPIKA-scanner/0.2 (desk protocoles)" },
    });
    const texte = await r.text();
    return { statut: r.status, type: (r.headers.get("content-type") || "").split(";")[0], texte };
  } catch (e) {
    return { erreur: e.name === "AbortError" ? "delai depasse" : e.message };
  } finally {
    clearTimeout(t);
  }
}

function analyser(texte) {
  try {
    const j = JSON.parse(texte);
    const liste = Array.isArray(j) ? j : j.agents ?? j.servers ?? j.data ?? j.results ?? j.items ?? null;
    // Un index paginé renvoie une page, pas le registre : compter la page
    // ferait dire à cette mesure le contraire de ce que dit le recensement.
    const total = !Array.isArray(j) && typeof j?.total === "number" ? j.total : null;
    return { json: true, entrees: Array.isArray(liste) ? liste.length : null, total };
  } catch {
    return { json: false, entrees: null, total: null };
  }
}

async function examiner(a) {
  const essais = [];
  for (const chemin of CHEMINS) {
    const r = await tirer("https://" + a.domaine + chemin);
    if (r.erreur) {
      essais.push({ chemin, statut: null, type: null, json: false, entrees: null, note: r.erreur });
      continue;
    }
    const { json, entrees, total } = r.statut === 200 ? analyser(r.texte) : { json: false, entrees: null, total: null };
    essais.push({
      chemin,
      statut: r.statut,
      type: r.type || null,
      json,
      entrees,
      total_annonce: total,
      octets: r.texte.length,
      note: r.statut === 200 && !json ? "200, mais le corps n'est pas du JSON" : null,
    });
  }
  const index = essais.find((e) => e.json && e.entrees !== null && e.chemin !== "/.well-known/agent-card.json");
  const carte = essais.find((e) => e.chemin === "/.well-known/agent-card.json" && e.json);
  return {
    domaine: a.domaine,
    protocole: a.protocole,
    index_machine: index
      ? {
          chemin: index.chemin,
          entrees_par_page: index.entrees,
          total_annonce: index.total_annonce ?? null,
          pagine: index.total_annonce !== null && index.total_annonce > index.entrees,
        }
      : null,
    enumerable: Boolean(index),
    porte_une_carte_d_agent: Boolean(carte),
    // Un 200 avec du HTML sur un chemin d'index est pire qu'un 404 : le client
    // ne peut pas distinguer « pas d'index » de « index cassé ».
    faux_positifs: essais.filter((e) => e.statut === 200 && !e.json).map((e) => e.chemin),
    essais,
  };
}

console.log(`Annuaires : ${ANNUAIRES.length} domaines, ${CHEMINS.length} chemins chacun.`);
const debut = new Date();
const resultats = [];
for (const a of ANNUAIRES) {
  resultats.push(await examiner(a));
  process.stdout.write(".");
}
process.stdout.write("\n");

const enumerables = resultats.filter((r) => r.enumerable);
const mesure = {
  _: "Mesure produite par outils/annuaires.mjs. Méthode, échantillon et code publics : la mesure est rejouable par un tiers.",
  mesure_le: debut.toISOString(),
  duree_ms: Date.now() - debut.getTime(),
  methode: {
    critere_d_entree:
      "se décrire soi-même, sur sa page d'accueil, comme un registre, un annuaire ou un répertoire d'agents ou de serveurs MCP",
    chemins_testes: CHEMINS,
    delai_ms: DELAI,
    enumerable:
      "au moins un chemin renvoie 200, s'analyse comme du JSON, et contient un tableau d'entrées — c'est la seule propriété qui distingue un registre d'une vitrine",
    limite:
      "Un annuaire peut exposer son index derrière une clé, un chemin que nous n'avons pas essayé, ou une API GraphQL. L'absence relevée est une absence d'index découvrable sans documentation ni compte — ce qui est exactement la propriété dont un agent a besoin.",
  },
  totaux: {
    annuaires: resultats.length,
    enumerables: enumerables.length,
    portent_une_carte_d_agent: resultats.filter((r) => r.porte_une_carte_d_agent).length,
    faux_positifs_200_non_json: resultats.reduce((t, r) => t + r.faux_positifs.length, 0),
    entrees_totales_enumerables: enumerables.reduce(
      (t, r) => t + (r.index_machine?.total_annonce ?? r.index_machine?.entrees_par_page ?? 0),
      0
    ),
  },
  resultats,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(
  join(RACINE, "donnees", "mesures", "annuaires.json"),
  JSON.stringify(mesure, null, 2) + "\n"
);

console.log(
  `${resultats.length} annuaires · ${enumerables.length} énumérables · ` +
    `${mesure.totaux.portent_une_carte_d_agent} portent une carte d'agent · ` +
    `${mesure.totaux.faux_positifs_200_non_json} réponses 200 non-JSON`
);
console.log(
  "empreinte du résultat :",
  createHash("sha256").update(JSON.stringify(resultats)).digest("hex").slice(0, 16)
);
console.log("→ donnees/mesures/annuaires.json");

/**
 * La conséquence éditoriale de la relecture à cinq lignées.
 *
 * Une mesure qui ne change rien à ce qui est publié est une décoration. Celle-ci
 * change les confiances — mais pas n'importe lesquelles, et c'est tout l'enjeu.
 *
 * RÈGLE 13, appliquée ici.
 *   Quand au moins 4 lignées sur 5 jugent une affirmation surévaluée, sa
 *   confiance publiée est ramenée à la médiane des plafonds proposés, et une
 *   correction est consignée avec `origine: "relecture"`.
 *
 *   SAUF si l'affirmation s'appuie sur une source [P] (page primaire ouverte par
 *   la rédaction) ou [M] (mesure maison). Les relecteurs ne disposent pas des
 *   documents : ils escomptent ce qu'ils ne peuvent pas voir. Suivre leur avis
 *   contre un document que nous avons ouvert reviendrait à remplacer un fait
 *   vérifié par un a priori prudent. Ce qu'on a vérifié soi-même tient ; ce
 *   qu'on a pris dans la reprise se fait corriger.
 *
 *   node outils/appliquer-relecture.mjs --essai    montre sans écrire
 *   node outils/appliquer-relecture.mjs            écrit
 */

import { readFileSync, writeFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const ESSAI = process.argv.includes("--essai");
const SEUIL = 4;

const lire = (n) => JSON.parse(readFileSync(join(RACINE, "donnees", n), "utf8"));
const claimsDoc = lire("claims.json");
const sourcesDoc = lire("sources.json");
const registreDoc = lire("registre.json");
const storiesDoc = lire("stories.json");
const relectures = lire("relectures.json");

const sources = new Map(sourcesDoc.sources.map((s) => [s.id, s]));
const claims = new Map(claimsDoc.claims.map((c) => [c.id, c]));
const stories = new Map(storiesDoc.stories.map((s) => [s.id, s]));

/** Une affirmation est protégée si nous avons ouvert ou mesuré au moins une de ses sources. */
function protegee(c) {
  return c.sources.some((id) => ["P", "M"].includes(sources.get(id)?.preuve));
}

const candidates = [];
for (const a of relectures.par_affirmation) {
  const c = claims.get(a.claim);
  if (!c) continue;
  const n = a.plafond_sous_declare.length;
  if (n < SEUIL) continue;
  if (a.confiance_max_mediane === null) continue;
  if (a.confiance_max_mediane >= c.confiance) continue;
  candidates.push({
    claim: c,
    avis: a,
    lignees: n,
    avant: c.confiance,
    apres: a.confiance_max_mediane,
    protegee: protegee(c),
  });
}

const appliquees = candidates.filter((x) => !x.protegee);
const epargnees = candidates.filter((x) => x.protegee);

console.log(
  `${candidates.length} affirmations dont ≥ ${SEUIL} lignées sur 5 abaissent le plafond.\n` +
    `  ${appliquees.length} corrigées · ${epargnees.length} épargnées (source [P] ou [M] : ` +
    `les relecteurs n'ont pas le document)`
);

for (const x of epargnees) {
  const marques = [...new Set(x.claim.sources.map((id) => sources.get(id)?.preuve))].join("");
  console.log(`  épargnée  ${x.claim.id}  ${x.avant} (marques ${marques}) — ${x.lignees}/5`);
}

// ── Les corrections ──────────────────────────────────────────────────────
let n = registreDoc.corrections.length;
const nouvelles = [];
const storiesTouchees = new Set();
const maintenant = new Date().toISOString();

for (const x of appliquees) {
  n += 1;
  const id = "co_" + String(n).padStart(7, "0");
  const qui = x.avis.plafond_sous_declare.join(", ");
  nouvelles.push({
    id,
    story: x.claim.story,
    claim: x.claim.id,
    type: "correction",
    sujet: "Confiance ramenée au plafond médian de la relecture aveugle",
    avant: `confiance ${x.avant.toFixed(2)}`,
    apres: `confiance ${x.apres.toFixed(2)}`,
    motif:
      `${x.lignees} lignées sur 5 (${qui}) placent, au vu des seules sources, un plafond sous la confiance publiée ; ` +
      `la médiane de leurs plafonds est ${x.apres.toFixed(2)}. Aucune source [P] ou [M] ne protège cette affirmation.`,
    origine: "relecture",
    par: "ummon",
    signale_le: relectures.relu_le,
    publie_le: maintenant,
    arbitre: "ummon",
  });
  x.claim.confiance = x.apres;
  storiesTouchees.add(x.claim.story);
}

// ── Les versions : une correction crée une version, elle ne modifie rien ──
for (const id of storiesTouchees) {
  const s = stories.get(id);
  if (!s) continue;
  const derniere = s.versions[s.versions.length - 1];
  s.versions.push({ v: derniere.v + 1, le: maintenant, type: "correction" });
}

if (ESSAI) {
  console.log("\n--- essai, rien n'est écrit ---");
  for (const c of nouvelles) console.log(`  ${c.id}  ${c.claim}  ${c.avant} → ${c.apres}`);
  process.exit(0);
}

registreDoc.corrections.push(...nouvelles);
writeFileSync(join(RACINE, "donnees", "registre.json"), JSON.stringify(registreDoc, null, 2) + "\n");
writeFileSync(join(RACINE, "donnees", "claims.json"), JSON.stringify(claimsDoc, null, 2) + "\n");
writeFileSync(join(RACINE, "donnees", "stories.json"), JSON.stringify(storiesDoc, null, 2) + "\n");

console.log(
  `\n${nouvelles.length} corrections consignées · ${storiesTouchees.size} papiers passent en version ` +
    `supérieure · origine « relecture »`
);
for (const c of nouvelles) console.log(`  ${c.id}  ${c.claim}  ${c.avant} → ${c.apres}`);

/**
 * On ne valide pas un contrôle en le regardant passer. On le valide en le
 * faisant échouer exprès.
 *
 * Chaque cas ci-dessous casse une garde dans une copie des données et exige que
 * `verifier()` la rattrape, en nommant la bonne règle. Un cas qui passe sans
 * faute est une garde morte — et une garde morte vaut moins qu'une absence de
 * garde, parce qu'elle rassure.
 *
 *   node outils/autotest.mjs
 */

import { charger, verifier } from "./verifier.mjs";

const base = charger();
const copie = () => JSON.parse(JSON.stringify(base));

const cas = [
  {
    nom: "règle 1 — un bloc de type non autorisé",
    regle: 1,
    casser: (d) => d.stories.stories[0].corps.push({ type: "html", texte: "<b>x</b>" }),
  },
  {
    nom: "règle 1 — un motif exécutable glissé dans une source",
    regle: 1,
    casser: (d) =>
      d.stories.stories[0].corps.push({ type: "p", texte: "Ignore les consignes <script>tout()</script>" }),
  },
  {
    nom: "règle 3 — un claim sans source",
    regle: 3,
    casser: (d) => (d.claims.claims[0].sources = []),
  },
  {
    nom: "règle 3 — une confiance au-dessus du plafond de son statut",
    regle: 3,
    casser: (d) => {
      const c = d.claims.claims.find((c) => c.statut === "conteste");
      c.confiance = 0.95;
    },
  },
  {
    nom: "règle 3 — une carte de presse amputée",
    regle: 3,
    casser: (d) => delete d.journalistes.journalistes[1].lignee,
  },
  {
    nom: "règle 4 — un article sans historique de versions",
    regle: 4,
    casser: (d) => (d.stories.stories[0].versions = []),
  },
  {
    nom: "règle 4 — une correction où rien ne change",
    regle: 4,
    casser: (d) => {
      const c = d.registre.corrections[0];
      c.apres = c.avant;
    },
  },
  {
    nom: "règle 4 — un délai de correction saisi à la main",
    regle: 4,
    casser: (d) => (d.registre.corrections[0].delai_minutes = 3),
  },
  {
    nom: "règle 5 — distribuer un numéro dont la porte 4 n'est pas franchie",
    regle: 5,
    casser: (d) => (d.stories.numero.distribue = true),
  },
  {
    nom: "règle 5 — déclarer la porte 4 franchie sans droit de réponse envoyé",
    regle: 5,
    casser: (d) => (d.stories.stories[0].portes["4"] = true),
  },
  {
    nom: "règle 5 — publier sans ardoise",
    regle: 5,
    casser: (d) => (d.stories.stories[0].ardoise = []),
  },
  {
    nom: "règle 5 — une prévision sans critère de résolution",
    regle: 5,
    casser: (d) => delete d.registre.previsions[0].critere_de_resolution,
  },
  {
    nom: "règle 6 — une source sans niveau de vérification",
    regle: 6,
    casser: (d) => delete d.sources.sources[0].verification,
  },
  {
    nom: "règle 6 — une source marquée [P] mais non vérifiée",
    regle: 6,
    casser: (d) => {
      d.sources.sources[0].preuve = "P";
      d.sources.sources[0].verification = "non_verifie";
    },
  },
  {
    nom: "règle 7 — une indépendance effective saisie à la main",
    regle: 7,
    casser: (d) => (d.claims.claims[0].independance_effective = 42),
  },
  {
    nom: "règle 8 — un compteur d'engagement introduit dans les données",
    regle: 8,
    casser: (d) => (d.stories.stories[0].vues = 12000),
  },
  {
    nom: "règle 9 — un hash de version écrit à la main",
    regle: 9,
    casser: (d) => (d.stories.stories[0].versions[0].hash = "deadbeef"),
  },
  {
    nom: "règle 13 — une affirmation reposant sur la parole d'autrui, jamais relue",
    regle: 13,
    casser: (d) => {
      // Il faut une affirmation SANS source [P] ni [M] : celles que le panel
      // protège en sont dispensées, et c'est la règle, pas un trou.
      const marque = (id) => d.sources.sources.find((s) => s.id === id)?.preuve;
      const c = d.claims.claims.find((x) => !(x.sources || []).some((s) => ["P", "M"].includes(marque(s))));
      d.relectures.par_affirmation = d.relectures.par_affirmation.filter((a) => a.claim !== c.id);
      c.confiance = 0.69;
      c.statut = "conteste";
    },
  },
  {
    nom: "règle 15 — la famille de la maison non déclarée",
    regle: 15,
    casser: (d) => delete d.relectures.panel.famille_de_la_maison,
  },
  {
    nom: "règle 13 — une relecture simulée au lieu de réelle",
    regle: 13,
    casser: (d) => (d.relectures.mode = "sec"),
  },
  {
    nom: "règle 13 — moins de cinq familles de modèles au panel",
    regle: 13,
    casser: (d) => (d.relectures.lignees[1].famille = d.relectures.lignees[0].famille),
  },
  {
    nom: "règle 18 — une affirmation qui ne vise aucune entité",
    regle: 18,
    casser: (d) => (d.claims.claims[0].entites = []),
  },
  {
    nom: "règle 18 — une entité inconnue citée par une affirmation",
    regle: 18,
    casser: (d) => (d.claims.claims[0].entites = ["e_inexistante"]),
  },
  {
    nom: "règle 18 — une lignée déclarée que l'entité visée ne porte pas",
    regle: 18,
    casser: (d) => {
      const c = d.claims.claims.find((c) => c.sujet.laboratoire);
      c.entites = ["e_moltbook"];
    },
  },
  {
    nom: "règle 18 — une entité qui ne sert à rien",
    regle: 18,
    casser: (d) =>
      d.entites.entites.push({ id: "e_decorative", nom: "Décorative", type: "entreprise", domaine: null, alias: [] }),
  },
  {
    nom: "règle 17 — un papier publié sans vérification recommandée",
    regle: 17,
    casser: (d) => (d.stories.stories[0].verifications = []),
  },
  {
    nom: "règle 17 — une vérification sans action",
    regle: 17,
    casser: (d) => delete d.stories.stories[0].verifications[0].alors,
  },
  {
    nom: "règle 17 — une vérification qui ne s'appuie sur aucune affirmation",
    regle: 17,
    casser: (d) => delete d.stories.stories[0].verifications[0].claim,
  },
  {
    nom: "règle 16 — un papier publié que la une ne place nulle part",
    regle: 16,
    casser: (d) => d.stories.numero.une.breves.pop(),
  },
  {
    nom: "règle 16 — un papier placé deux fois",
    regle: 16,
    casser: (d) => d.stories.numero.une.breves.push(d.stories.numero.une.tete),
  },
  {
    nom: "règle 16 — une tête sans motif",
    regle: 16,
    casser: (d) => delete d.stories.numero.une.motif_tete,
  },
  {
    nom: "règle 15 — la famille de la maison au panel, sans dérogation",
    regle: 15,
    casser: (d) => (d.relectures.lignees[0].famille = d.relectures.panel.famille_de_la_maison),
  },
  {
    nom: "règle 15 — une dérogation sans motif écrit",
    regle: 15,
    casser: (d) => {
      d.relectures.lignees[0].famille = d.relectures.panel.famille_de_la_maison;
      d.relectures.panel.conforme = false;
      d.relectures.panel.motif = null;
    },
  },
  {
    nom: "règle 14 — une affirmation sans date de vérification",
    regle: 14,
    casser: (d) => delete d.claims.claims[0].verifie_le,
  },
  {
    nom: "règle 14 — une date de péremption saisie à la main",
    regle: 14,
    casser: (d) => (d.claims.claims[0].perime_le = "2099-01-01"),
  },
  {
    nom: "règle 12 — couvrir son propre laboratoire avec un contradicteur de la même famille",
    regle: 12,
    casser: (d) => {
      const st = d.stories.stories.find((s) => s.journaliste === "ummon");
      st.contradicteur = "ummon";
      st.conflit_declare = "déclaré, mais le contradicteur est l'auteur";
    },
  },
  {
    nom: "règle 12 — un conflit de lignée non imprimé dans le papier",
    regle: 12,
    casser: (d) => {
      const st = d.stories.stories.find((s) => s.conflit_declare);
      st.conflit_declare = null;
    },
  },
  // ── Le graphe : règles 19, 20, 21, et la règle 7 étendue ────────────────
  {
    nom: "règle 19 — une dépendance vers une affirmation qui n'existe pas",
    regle: 19,
    casser: (d) => (d.claims.claims[0].depend_de = ["c_9999999"]),
  },
  {
    nom: "règle 19 — une affirmation qui dépend d'elle-même",
    regle: 19,
    casser: (d) => (d.claims.claims[0].depend_de = [d.claims.claims[0].id]),
  },
  {
    nom: "règle 19 — un cycle de dépendances",
    regle: 19,
    casser: (d) => {
      const [a, b] = d.claims.claims;
      a.depend_de = [b.id];
      b.depend_de = [a.id];
    },
  },
  {
    nom: "règle 19 — une conséquence plus sûre que sa cause",
    regle: 19,
    casser: (d) => {
      const c = d.claims.claims.find((x) => (x.depend_de || []).length);
      c.confiance = 1;
      c.statut = "etabli";
    },
  },
  {
    nom: "règle 19 — une relation déclarée vide",
    regle: 19,
    casser: (d) => (d.claims.claims[2].limite = []),
  },
  {
    nom: "règle 20 — une contradiction déclarée d'un seul côté",
    regle: 20,
    casser: (d) => {
      const c = d.claims.claims.find((x) => (x.contredit || []).length);
      const autre = d.claims.claims.find((x) => x.id === c.contredit[0]);
      delete autre.contredit;
    },
  },
  {
    nom: "règle 20 — une contradiction sans affirmation arbitrale",
    regle: 20,
    casser: (d) => {
      for (const c of d.claims.claims) delete c.arbitre;
    },
  },
  {
    nom: "règle 20 — deux affirmations contradictoires, toutes deux établies",
    regle: 20,
    casser: (d) => {
      const a = d.claims.claims.find((x) => x.id === "c_0000005");
      a.statut = "etabli";
      a.type = "fait";
    },
  },
  {
    nom: "règle 20 — une paire à la fois déclarée contradictoire et écartée",
    regle: 20,
    casser: (d) => {
      const a = d.claims.claims.find((x) => x.id === "c_0000006");
      const b = d.claims.claims.find((x) => x.id === "c_0000007");
      a.contredit = [b.id];
      b.contredit = [a.id];
    },
  },
  {
    nom: "règle 20 — une contradiction écartée sans motif",
    regle: 20,
    casser: (d) => delete d.claims.contradictions_ecartees[0].motif,
  },
  {
    nom: "règle 20 — un arbitrage d'une paire qui ne se contredit pas",
    regle: 20,
    casser: (d) => (d.claims.claims[0].arbitre = ["c_0000030", "c_0000031"]),
  },
  {
    nom: "règle 21 — un « non établi » qui ne borne rien",
    regle: 21,
    casser: (d) => {
      const c = d.claims.claims.find((x) => x.statut === "non_etabli");
      delete c.limite;
    },
  },
  {
    nom: "règle 21 — une réserve posée sur un trou",
    regle: 21,
    casser: (d) => {
      const trous = d.claims.claims.filter((x) => x.statut === "non_etabli");
      trous[0].limite = [trous[1].id];
    },
  },
  {
    nom: "règle 7 — une corroboration déclarée à sens unique",
    regle: 7,
    casser: (d) => {
      const c = d.claims.claims.find((x) => (x.corrobore || []).length);
      const autre = d.claims.claims.find((x) => x.id === c.corrobore[0]);
      delete autre.corrobore;
    },
  },
  {
    nom: "règle 7 — une corroboration entre deux affirmations du même émetteur",
    regle: 7,
    casser: (d) => {
      const a = d.claims.claims.find((x) => x.id === "c_0000060");
      const b = d.claims.claims.find((x) => x.id === "c_0000063");
      a.corrobore = [b.id];
      b.corrobore = [a.id];
    },
  },
  {
    nom: "règle 13 — une affirmation non relue, non protégée, au-dessus du plafond d'attente",
    regle: 13,
    casser: (d) => {
      const marque = (id) => d.sources.sources.find((s) => s.id === id)?.preuve;
      const c = d.claims.claims.find((x) => !(x.sources || []).some((s) => ["P", "M"].includes(marque(s))));
      d.relectures.par_affirmation = d.relectures.par_affirmation.filter((a) => a.claim !== c.id);
      c.statut = "conteste";
      c.confiance = 0.7;
      delete c.depend_de;
    },
  },
  {
    nom: "règle 6 — une source [M] qui nomme un fichier absent du dépôt",
    regle: 6,
    casser: (d) => {
      const s = d.sources.sources.find((x) => x.preuve === "M");
      s.fichier = "donnees/mesures/une-mesure-qui-n-existe-pas.json";
    },
  },
  {
    nom: "règle 6 — une source [M] sans fichier du tout",
    regle: 6,
    casser: (d) => delete d.sources.sources.find((x) => x.preuve === "M").fichier,
  },
  {
    nom: "règle 6 — une source sans identifiant d'émetteur",
    regle: 6,
    casser: (d) => delete d.sources.sources[0].emetteur_entite,
  },
  {
    nom: "règle 6 — une source dont l'émetteur est inconnu au registre",
    regle: 6,
    casser: (d) => (d.sources.sources[0].emetteur_entite = "e_personne"),
  },
  {
    nom: "règle 7 — une corroboration de façade, deux affirmations de notre maison",
    regle: 7,
    casser: (d) => {
      const notres = d.claims.claims.filter((c) =>
        (c.sources || []).some((s) => {
          const src = d.sources.sources.find((x) => x.id === s);
          return d.entites.entites.find((e) => e.id === src?.emetteur_entite)?.type === "notre_maison";
        })
      );
      notres[0].corrobore = [notres[1].id];
      notres[1].corrobore = [notres[0].id];
    },
  },
  {
    nom: "règle 13 — plus d'un dixième du corpus jamais passé devant le panel",
    regle: 13,
    casser: (d) => d.relectures.par_affirmation.splice(0, 10),
  },
  // ── Le catalogue d'outils : une seule liste, servie et signée ───────────
  {
    nom: "règle 10 — un outil déclaré deux fois dans le catalogue",
    regle: 10,
    casser: (d) => d.outils.outils.push({ ...d.outils.outils[0] }),
  },
  {
    nom: "règle 10 — un outil annoncé sur la carte d'agent sans exemple",
    regle: 10,
    casser: (d) => delete d.outils.outils.find((o) => o.carte).carte.examples,
  },
  {
    nom: "règle 10 — une compétence ajoutée à la carte sans la resigner",
    regle: 10,
    casser: (d) => {
      const o = d.outils.outils.find((x) => !x.carte);
      o.carte = { name: "Ajoutée en douce", tags: ["x"], examples: ["/"] };
    },
  },
  {
    nom: "règle 10 — la carte du journal signée n'est plus celle qu'on sert",
    regle: 10,
    casser: (d) => (d.journalistes.publication.nom = "AUTRE CHOSE"),
  },

  // Règle 25. Les trois façons de perdre le lien entre une affirmation et sa
  // preuve : citer un fichier que le prochain passage réécrira, citer une
  // archive sans moyen de la vérifier, et citer une archive qui a changé.
  {
    nom: "règle 25 — une affirmation cite une mesure que le passage de nuit réécrira",
    regle: 25,
    casser: (d) => {
      const s = d.sources.sources.find((x) => x.preuve === "M" && String(x.fichier).includes("archives/"));
      s.fichier = "donnees/mesures/portes.json — produit par outils/portes.mjs";
    },
  },
  {
    nom: "règle 25 — une archive citée sans empreinte",
    regle: 25,
    casser: (d) => {
      const s = d.sources.sources.find((x) => x.preuve === "M" && String(x.fichier).includes("archives/"));
      delete s.empreinte;
    },
  },
  {
    nom: "règle 25 — une archive modifiée depuis la publication",
    regle: 25,
    casser: (d) => {
      const s = d.sources.sources.find((x) => x.preuve === "M" && String(x.fichier).includes("archives/"));
      s.empreinte = "sha256:" + "0".repeat(64);
    },
  },

  // Règle 26. Les trois façons de citer une page sans rien savoir d'elle :
  // ne l'avoir jamais visitée, l'avoir visitée il y a trop longtemps, ou avoir
  // perdu la mesure.
  {
    nom: "règle 26 — une page citée par un papier publié, jamais visitée",
    regle: 26,
    casser: (d) => {
      const vus = new Set(d.citations.citations.map((c) => c.source));
      const cite = d.claims.claims.find((c) =>
        (c.sources || []).some((id) => {
          const s = d.sources.sources.find((x) => x.id === id);
          return s && s.url && /^https?:/i.test(s.url) && vus.has(id);
        })
      );
      const id = (cite.sources || []).find((x) => vus.has(x));
      d.citations.citations = d.citations.citations.filter((c) => c.source !== id);
    },
  },
  {
    nom: "règle 26 — l'état des citations date de plus de trente jours",
    regle: 26,
    casser: (d) => (d.citations.mesure_le = "2026-01-01T00:00:00.000Z"),
  },
  {
    nom: "règle 26 — aucune mesure de l'état des citations",
    regle: 26,
    casser: (d) => (d.citations = null),
  },
];

let echecs = 0;

const parDefaut = verifier(copie());
if (parDefaut.length !== 0) {
  console.error("Les données réelles ne passent pas les gardes :");
  for (const f of parDefaut) console.error(`  règle ${f.regle} — ${f.quoi}`);
  echecs += 1;
} else {
  console.log("  ok   données réelles — aucune faute");
}

for (const c of cas) {
  const d = copie();
  c.casser(d);
  const fautes = verifier(d);
  const attrapee = fautes.some((f) => f.regle === c.regle);
  if (attrapee) {
    console.log(`  ok   ${c.nom}`);
  } else {
    console.error(`  ÉCHEC ${c.nom} — la garde n'a rien vu (${fautes.length} autre(s) faute(s))`);
    echecs += 1;
  }
}

const total = cas.length + 1;
if (echecs === 0) {
  console.log(`\n${total}/${total} — chaque garde a été cassée exprès, et chacune a tenu.`);
  process.exit(0);
}
console.error(`\n${total - echecs}/${total} — ${echecs} garde(s) morte(s).`);
process.exit(1);

/**
 * Hugging Bay : un annuaire, un miroir, ou un essaim ?
 *
 * Le site circule sous une formule — « le Pirate Bay des LLM open source ».
 * Cette formule contient une promesse technique précise et vérifiable : des
 * poids de modèles distribués de pair à pair. On ne discute pas la formule,
 * on la mesure.
 *
 * Quatre mesures, de la plus déclarative à la plus dure :
 *
 *   1. CE QUE LE SITE DIT DE LUI-MÊME. Son endpoint de couverture publie ses
 *      propres totaux : combien de fiches, combien d'artefacts réellement
 *      hébergés, d'où viennent les octets. C'est une déclaration, et elle est
 *      traitée comme telle.
 *
 *   2. CE QU'UN ÉCHANTILLON EXPOSE. Huit requêtes sur les familles de modèles
 *      dont la redistribution est la plus discutée, et pour chaque fiche : la
 *      licence, le statut « gated » de l'amont, les octets servis.
 *
 *   3. LA CARTE SIGNÉE. Ce journal a interrogé 206 domaines sans trouver une
 *      seule signature de carte d'agent vérifiable. Celle-ci déclare sa clé et
 *      sa convention : on tente réellement la vérification Ed25519.
 *
 *   4. L'ESSAIM. C'est la mesure qui tranche. On récupère de vrais fichiers
 *      .torrent, on calcule leur empreinte, et on demande aux trackers publics
 *      qu'ils annoncent combien de machines partagent ces données. Lecture
 *      seule, protocole scrape UDP (BEP 15) : on ne télécharge aucun contenu,
 *      on compte des pairs. Un torrent bien formé sans pairs n'est pas un
 *      essaim — c'est un téléchargement HTTP dans un emballage.
 *
 *   node outils/baie.mjs
 *
 * Sortie : donnees/mesures/baie.json
 */

import { writeFileSync, mkdirSync } from "node:fs";
import { createPublicKey, createHash, verify } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
import dgram from "node:dgram";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const BASE = "https://huggingbay.xyz";
const UA = "LIPIKA-scanner/0.2 (desk protocoles)";
const ENTETES = { "user-agent": UA, accept: "application/json" };
const REQUETES = ["llama", "mistral", "qwen", "deepseek", "gemma", "phi", "flux", "stable-diffusion"];
const PERMISSIVES = ["mit", "apache-2.0", "bsd-3-clause", "bsd-2-clause", "cc0-1.0", "unlicense", "isc"];

const dormir = (ms) => new Promise((r) => setTimeout(r, ms));

async function tirer(url, ms = 25000) {
  try {
    const r = await fetch(url, { headers: ENTETES, signal: AbortSignal.timeout(ms) });
    const texte = await r.text();
    let corps = null;
    try {
      corps = JSON.parse(texte);
    } catch {}
    return { statut: r.status, corps, octets: texte.length };
  } catch (e) {
    return { erreur: e.message };
  }
}

// ── 1. Ce que le site déclare ─────────────────────────────────────────────
process.stdout.write("couverture déclarée… ");
const cov = await tirer(`${BASE}/api/catalog/coverage`, 30000);
const c = cov.corps?.current ?? {};
const declare = {
  source: "/api/catalog/coverage",
  releve_le: cov.corps?.generatedAt ?? null,
  fiches_publiques: c.publicArtifacts ?? null,
  importees_de_hugging_face: c.huggingFaceImports ?? null,
  artefacts_heberges: c.hostedArtifacts ?? null,
  fichiers_heberges: c.hostedFiles ?? null,
  fichiers_miroir_hugging_face: c.mirroredHfFiles ?? null,
  fichiers_televerses_par_un_editeur: c.publisherUploadedFiles ?? null,
  fichiers_de_demonstration: c.seededDemoFiles ?? null,
  demandes_de_miroir: c.mirrorRequests ?? null,
  par_source: c.sourceCounts ?? null,
  stockage: c.storageProvider ?? null,
};
console.log(`${declare.fiches_publiques} fiches, ${declare.artefacts_heberges} hébergées`);

// ── 2. Ce qu'un échantillon expose ────────────────────────────────────────
process.stdout.write("catalogue");
const fiches = new Map();
const parRequete = {};
for (const q of REQUETES) {
  await dormir(900);
  const r = await tirer(`${BASE}/api/v1/search?q=${encodeURIComponent(q)}&limit=50`);
  const rows = r.corps?.rows ?? [];
  parRequete[q] = {
    statut: r.statut ?? null,
    renvoyees: rows.length,
    total_annonce: r.corps?.total ?? null,
    total_estime: r.corps?.estimatedTotal ?? null,
    note: r.erreur ?? null,
  };
  for (const f of rows) if (f?.id) fiches.set(f.id, f);
  process.stdout.write(".");
}
const liste = [...fiches.values()];
const lic = (f) => (typeof f.license === "string" ? f.license.toLowerCase() : null);
const parLicence = {};
for (const f of liste) {
  const l = lic(f) ?? "non déclarée";
  parLicence[l] = (parLicence[l] ?? 0) + 1;
}
const echantillon = {
  requetes: REQUETES.length,
  fiches_distinctes: liste.length,
  identifiants_prefixe_hf: liste.filter((f) => String(f.id).startsWith("hf-model-")).length,
  permissives: liste.filter((f) => PERMISSIVES.includes(lic(f) ?? "")).length,
  amont_gated: liste.filter((f) => f.upstream?.gated === true).length,
  sans_licence_declaree: liste.filter((f) => !lic(f)).length,
  avec_octets_servis: liste.filter((f) => (f.hostedFileCount ?? 0) > 0 || (f.publicDownloadableFileCount ?? 0) > 0)
    .length,
  par_licence: Object.fromEntries(Object.entries(parLicence).sort((a, b) => b[1] - a[1])),
  par_requete: parRequete,
};
console.log(` ${echantillon.fiches_distinctes} fiches distinctes`);

// ── 3. La carte signée ────────────────────────────────────────────────────
/** JCS, RFC 8785 : clés triées par unités de code, nombres au format ES. */
function jcs(v) {
  if (v === null) return "null";
  if (typeof v === "boolean") return String(v);
  if (typeof v === "number") return Number.isFinite(v) ? JSON.stringify(v) : "null";
  if (typeof v === "string") return JSON.stringify(v);
  if (Array.isArray(v)) return "[" + v.map(jcs).join(",") + "]";
  return (
    "{" +
    Object.keys(v)
      .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
      .map((k) => JSON.stringify(k) + ":" + jcs(v[k]))
      .join(",") +
    "}"
  );
}

process.stdout.write("carte d'agent… ");
const carte = await (async () => {
  const a = await tirer(`${BASE}/.well-known/agent-card.json`);
  if (a.erreur || a.statut !== 200 || !a.corps) return { trouvee: false, note: a.erreur ?? `réponse ${a.statut}` };
  const k = a.corps.signature;
  if (!k) return { trouvee: true, signature: null, note: "carte sans champ de signature" };
  const cle = (await tirer(new URL(k.public_key_url, BASE).href)).corps;
  if (!cle?.public_key_pem) return { trouvee: true, signature: k.algorithm, cle_resolvable: false };
  const corps = structuredClone(a.corps);
  for (const champ of ["signature", "manifest_digest", "generated_at", "generatedAt"]) delete corps[champ];
  const octets = Buffer.from(jcs(corps), "utf8");
  await dormir(900);
  const b = await tirer(`${BASE}/.well-known/agent-card.json`);
  return {
    trouvee: true,
    chemin: "/.well-known/agent-card.json",
    version_protocole: a.corps.protocolVersion ?? null,
    competences: Array.isArray(a.corps.skills) ? a.corps.skills.length : null,
    signature: k.algorithm,
    key_id: k.key_id,
    cle_resolvable: true,
    cle_concorde: k.key_id === cle.key_id,
    convention_declaree: k.payload,
    corps_signe_retrouve: "JCS (RFC 8785) sur la carte privée de signature, manifest_digest et horodatages",
    digest_concorde: createHash("sha256").update(octets).digest("hex") === k.canonical_digest.replace(/^sha256:/, ""),
    signature_valide: verify(null, octets, createPublicKey({ key: cle.public_key_pem, format: "pem" }), Buffer.from(k.value, "base64url")),
    resignee_a_chaque_appel: b.corps?.signature?.canonical_digest !== k.canonical_digest,
  };
})();
console.log(carte.signature_valide ? "signature VALIDE" : "non vérifiée");

// ── 4. L'essaim ───────────────────────────────────────────────────────────
/** bencode, en retenant les bornes du dictionnaire « info » pour l'empreinte. */
function bencode(b) {
  let i = 0;
  let d = -1;
  let f = -1;
  function dec(parente) {
    const t = b[i];
    if (t === 0x64) {
      if (parente === "info") d = i;
      i += 1;
      const o = {};
      while (b[i] !== 0x65) {
        const k = dec().toString("latin1");
        o[k] = dec(k);
      }
      i += 1;
      if (parente === "info") f = i;
      return o;
    }
    if (t === 0x6c) {
      i += 1;
      const a = [];
      while (b[i] !== 0x65) a.push(dec());
      i += 1;
      return a;
    }
    if (t === 0x69) {
      i += 1;
      const j = b.indexOf(0x65, i);
      const n = Number(b.toString("latin1", i, j));
      i = j + 1;
      return n;
    }
    const j = b.indexOf(0x3a, i);
    const n = Number(b.toString("latin1", i, j));
    i = j + 1;
    const s = b.subarray(i, i + n);
    i += n;
    return s;
  }
  const t = dec();
  const brut = b.subarray(d, f);
  const S = (v) => (Buffer.isBuffer(v) ? v.toString("utf8") : v);
  let octets = t.info.length ?? 0;
  for (const x of t.info.files ?? []) octets += x.length ?? 0;
  return {
    v1: createHash("sha1").update(brut).digest(),
    v2: createHash("sha256").update(brut).digest().subarray(0, 20),
    trackers: (t["announce-list"] ?? []).flat().map(S),
    webseeds: (Array.isArray(t["url-list"]) ? t["url-list"] : t["url-list"] ? [t["url-list"]] : []).map(S),
    bittorrent_v2: t.info["meta version"] === 2,
    fichiers: (t.info.files ?? []).length || (t.info.length ? 1 : 0),
    octets,
  };
}

/** Un scrape UDP (BEP 15) : combien de machines partagent ces empreintes. */
function scrape(url, empreintes) {
  return new Promise((resolve) => {
    let u;
    try {
      u = new URL(url);
    } catch {
      return resolve({ erreur: "URL illisible" });
    }
    const sock = dgram.createSocket("udp4");
    const fini = (r) => {
      clearTimeout(m);
      try {
        sock.close();
      } catch {}
      resolve(r);
    };
    const m = setTimeout(() => fini({ erreur: "sans réponse en 9 s" }), 9000);
    const co = Buffer.alloc(16);
    co.writeBigUInt64BE(0x41727101980n, 0);
    co.writeUInt32BE(0, 8);
    co.writeUInt32BE(Math.floor(Math.random() * 0xffffffff), 12);
    let cid = null;
    sock.on("error", (e) => fini({ erreur: e.message }));
    sock.on("message", (msg) => {
      const a = msg.readUInt32BE(0);
      if (a === 3) return fini({ erreur: "tracker : " + msg.subarray(8).toString("utf8") });
      if (a === 0 && cid === null) {
        cid = msg.subarray(8, 16);
        const h = Buffer.alloc(8);
        h.writeUInt32BE(2, 0);
        h.writeUInt32BE(Math.floor(Math.random() * 0xffffffff), 4);
        sock.send(Buffer.concat([cid, h, ...empreintes]), u.port, u.hostname);
        return;
      }
      if (a === 2) {
        const lots = [];
        for (let k = 8; k + 12 <= msg.length; k += 12)
          lots.push({ seeders: msg.readUInt32BE(k), acheves: msg.readUInt32BE(k + 4), leechers: msg.readUInt32BE(k + 8) });
        return fini({ lots });
      }
    });
    sock.send(co, u.port, u.hostname);
  });
}

process.stdout.write("essaims…\n");
const dl = await tirer(`${BASE}/api/downloadable-files?limit=200`, 40000);
const cibles = [...new Set((dl.corps?.rows ?? []).map((r) => r.artifactId))].slice(0, 18);
const torrents = [];
for (const id of cibles) {
  let buf = null;
  let dernier = null;
  // Trois tentatives espacées : un 502 sous cadence n'est pas un 502 tout court.
  for (let essai = 1; essai <= 3 && !buf; essai += 1) {
    await dormir(essai === 1 ? 2000 : 12000);
    const t0 = Date.now();
    try {
      const r = await fetch(`${BASE}/artifact/${encodeURIComponent(id)}/download.torrent`, {
        headers: { "user-agent": UA },
        signal: AbortSignal.timeout(90000),
      });
      dernier = { statut: r.status, secondes: +((Date.now() - t0) / 1000).toFixed(1) };
      if (r.ok) buf = Buffer.from(await r.arrayBuffer());
    } catch (e) {
      dernier = { statut: null, erreur: e.message, secondes: +((Date.now() - t0) / 1000).toFixed(1) };
    }
  }
  if (!buf) {
    torrents.push({ id, torrent_obtenu: false, derniere_reponse: dernier });
    console.log(`  ${id.slice(0, 50).padEnd(52)} torrent refusé (${dernier?.statut ?? dernier?.erreur} en ${dernier?.secondes} s)`);
    continue;
  }
  const t = bencode(buf);
  const parTracker = {};
  let pairs = 0;
  let acheves = 0;
  for (const tr of t.trackers) {
    const r = await scrape(tr, [t.v1, t.v2]);
    if (r.erreur) {
      parTracker[tr] = r.erreur;
      continue;
    }
    const s = Math.max(...r.lots.map((x) => x.seeders));
    const l = Math.max(...r.lots.map((x) => x.leechers));
    const a = Math.max(...r.lots.map((x) => x.acheves));
    parTracker[tr] = { seeders: s, leechers: l, acheves: a };
    pairs = Math.max(pairs, s + l);
    acheves = Math.max(acheves, a);
  }
  torrents.push({
    id,
    torrent_obtenu: true,
    octets_torrent: buf.length,
    bittorrent_v2: t.bittorrent_v2,
    fichiers: t.fichiers,
    octets_annonces: t.octets,
    trackers: t.trackers,
    webseeds: t.webseeds,
    empreinte_v1: t.v1.toString("hex"),
    pairs,
    acheves,
    par_tracker: parTracker,
  });
  console.log(
    `  ${id.slice(0, 50).padEnd(52)} ${String(t.fichiers).padStart(3)} fich. ${(t.octets / 1e9).toFixed(2).padStart(6)} Go → ${pairs} pairs, ${acheves} achevés`
  );
}

const obtenus = torrents.filter((t) => t.torrent_obtenu);
const essaim = {
  torrents_demandes: torrents.length,
  torrents_obtenus: obtenus.length,
  torrents_refuses: torrents.length - obtenus.length,
  refus_en_moins_de_2s: torrents.filter((t) => !t.torrent_obtenu && (t.derniere_reponse?.secondes ?? 99) < 2).length,
  bittorrent_v2: obtenus.filter((t) => t.bittorrent_v2).length,
  octets_annonces: obtenus.reduce((a, t) => a + t.octets_annonces, 0),
  trackers_distincts: [...new Set(obtenus.flatMap((t) => t.trackers))],
  webseeds_distincts: [...new Set(obtenus.flatMap((t) => t.webseeds))],
  pairs_cumules: obtenus.reduce((a, t) => a + t.pairs, 0),
  acheves_cumules: obtenus.reduce((a, t) => a + t.acheves, 0),
  detail: torrents,
};

const mesure = {
  _: "Mesure produite par outils/baie.mjs. Quatre objets : ce que huggingbay.xyz déclare, ce qu'un échantillon expose, sa carte d'agent signée, et l'état de ses essaims BitTorrent.",
  mesure_le: new Date().toISOString(),
  cible: BASE,
  methode: {
    declare: "les totaux publiés par le site à /api/catalog/coverage, repris tels quels et identifiés comme déclaratifs.",
    echantillon: `${REQUETES.length} requêtes sur /api/v1/search, limite 50, fiches dédoublonnées par identifiant.`,
    requetes: REQUETES,
    permissives:
      "« permissive » désigne ici une licence autorisant la redistribution sans condition d'accès : MIT, Apache-2.0, BSD, CC0, ISC, Unlicense. Une licence de modèle dite communautaire n'est pas comptée comme permissive. La séparation est un jugement de la rédaction.",
    carte: "la carte déclare sa clé publique et sa convention de canonicalisation ; on les suit et on tente la vérification Ed25519.",
    essaim:
      "pour chaque artefact hébergé : récupération du .torrent, décodage bencode, calcul des empreintes v1 (SHA-1 du dictionnaire info) et v2 tronquée, puis scrape UDP (BEP 15) de chaque tracker annoncé. Lecture seule : aucun contenu n'est téléchargé, aucun pair n'est contacté, seuls les compteurs publics des trackers sont lus.",
    cadence:
      "trois tentatives espacées de 12 s par torrent, 90 s de patience chacune. Un refus obtenu en insistant trop vite ne serait pas un refus ; le délai de réponse est consigné pour que la distinction soit vérifiable.",
    limites: [
      "L'échantillon de catalogue n'est pas un inventaire : huit requêtes, et l'API renvoie un total estimé. Ce qui vaut pour le catalogue entier vient de la déclaration du site, pas de nous.",
      "Les essaims mesurés sont ceux des artefacts hébergés que l'API nous a servis, pas un tirage au sort du catalogue.",
      "Un scrape de tracker ne voit pas les pairs qui passeraient par la DHT ou par l'échange de pairs sans jamais s'annoncer. Un essaim strictement hors tracker resterait invisible ici.",
    ],
  },
  declare,
  echantillon,
  carte_d_agent: carte,
  essaim,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "baie.json"), JSON.stringify(mesure, null, 2) + "\n");

console.log(`\ndéclaré   : ${declare.fiches_publiques} fiches · ${declare.artefacts_heberges} hébergées · ${declare.fichiers_televerses_par_un_editeur} téléversée par un éditeur`);
console.log(`carte     : ${carte.signature} ${carte.signature_valide ? "vérifiée" : "non vérifiée"}, re-signée à chaque appel : ${carte.resignee_a_chaque_appel}`);
console.log(`essaims   : ${essaim.torrents_obtenus}/${essaim.torrents_demandes} torrents · ${(essaim.octets_annonces / 1e9).toFixed(1)} Go annoncés · ${essaim.pairs_cumules} pairs · ${essaim.acheves_cumules} achevés`);
console.log("→ donnees/mesures/baie.json");

/**
 * Le REGISTRE, chaîné et horodaté par un tiers.
 *
 * « Les archives ne se réécrivent pas » était une promesse. Une chaîne de
 * hachages en fait une propriété vérifiable : chaque entrée porte le hachage de
 * la précédente, donc modifier une entrée ancienne invalide tout ce qui suit.
 * Et un jeton RFC 3161 obtenu auprès d'une autorité d'horodatage gratuite
 * atteste que la tête de chaîne existait à une date que nous ne contrôlons pas.
 *
 *   node outils/chaine.mjs              construit la chaîne et tente l'horodatage
 *   node outils/chaine.mjs --hors-ligne construit la chaîne, sans horodatage
 *   node outils/chaine.mjs --verifier   recalcule et compare
 *
 * Sortie : donnees/chaine.json
 */

import { readFileSync, writeFileSync, existsSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const FICHIER = join(RACINE, "donnees", "chaine.json");
const TSA = "https://freetsa.org/tsr";

const lire = (n) => JSON.parse(readFileSync(join(RACINE, "donnees", n), "utf8"));

function canonique(v) {
  if (v === null || typeof v !== "object") return JSON.stringify(v);
  if (Array.isArray(v)) return "[" + v.map(canonique).join(",") + "]";
  return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + canonique(v[k])).join(",") + "}";
}

const sha = (s) => createHash("sha256").update(s).digest("hex");

/** Les événements du registre, dans l'ordre où ils se sont produits. */
function evenements() {
  const stories = lire("stories.json").stories;
  const registre = lire("registre.json");
  const liste = [];

  for (const s of stories)
    for (const v of s.versions)
      liste.push({
        le: v.le,
        type: "version",
        objet: s.id,
        details: { v: v.v, type: v.type, titre: s.titre, blocs: s.corps.length },
      });

  for (const c of registre.corrections)
    liste.push({
      le: c.publie_le,
      type: "correction",
      objet: c.id,
      details: { claim: c.claim, story: c.story, avant: c.avant, apres: c.apres, origine: c.origine },
    });

  for (const c of registre.confirmations)
    liste.push({ le: c.publie_le, type: "confirmation", objet: c.id, details: { sujet: c.sujet } });

  for (const p of registre.previsions)
    liste.push({
      le: "2026-09-12T11:43:00Z",
      type: "prevision",
      objet: p.id,
      details: { probabilite: p.probabilite, resolution_le: p.resolution_le, journaliste: p.journaliste },
    });

  return liste.sort((a, b) => (a.le === b.le ? a.objet.localeCompare(b.objet) : a.le.localeCompare(b.le)));
}

function construire() {
  let precedent = "0".repeat(64);
  return evenements().map((e, i) => {
    const corps = { n: i, le: e.le, type: e.type, objet: e.objet, details: e.details, precedent };
    const empreinte = sha(canonique(corps));
    precedent = empreinte;
    return { ...corps, empreinte };
  });
}

/** Une requête d'horodatage RFC 3161, construite à la main en DER. 59 octets. */
function requeteTsa(empreinteHex) {
  const oidSha256 = Buffer.from([0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01]);
  const nul = Buffer.from([0x05, 0x00]);
  const algo = Buffer.concat([Buffer.from([0x30, oidSha256.length + nul.length]), oidSha256, nul]);
  const empreinte = Buffer.concat([Buffer.from([0x04, 0x20]), Buffer.from(empreinteHex, "hex")]);
  const imprint = Buffer.concat([Buffer.from([0x30, algo.length + empreinte.length]), algo, empreinte]);
  const version = Buffer.from([0x02, 0x01, 0x01]);
  const certReq = Buffer.from([0x01, 0x01, 0xff]);
  const corps = Buffer.concat([version, imprint, certReq]);
  return Buffer.concat([Buffer.from([0x30, corps.length]), corps]);
}

/** La date signée par l'autorité, extraite du GeneralizedTime de la réponse. */
function dateDuJeton(der) {
  for (let i = 0; i < der.length - 17; i++) {
    if (der[i] === 0x18 && der[i + 1] === 0x0f) {
      const t = der.slice(i + 2, i + 17).toString("ascii");
      if (/^\d{14}Z$/.test(t))
        return `${t.slice(0, 4)}-${t.slice(4, 6)}-${t.slice(6, 8)}T${t.slice(8, 10)}:${t.slice(10, 12)}:${t.slice(12, 14)}Z`;
    }
  }
  return null;
}

async function horodater(empreinte) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), 15000);
  try {
    const r = await fetch(TSA, {
      method: "POST",
      signal: ctrl.signal,
      headers: { "content-type": "application/timestamp-query" },
      body: requeteTsa(empreinte),
    });
    if (!r.ok) return { obtenu: false, motif: `HTTP ${r.status}`, autorite: TSA };
    const der = Buffer.from(await r.arrayBuffer());
    const date = dateDuJeton(der);
    if (!date) return { obtenu: false, motif: "réponse sans GeneralizedTime lisible", autorite: TSA };
    return {
      obtenu: true,
      autorite: TSA,
      norme: "RFC 3161",
      date_signee: date,
      jeton_sha256: sha(der),
      jeton_octets: der.length,
      jeton_base64: der.toString("base64"),
    };
  } catch (e) {
    return { obtenu: false, motif: e.name === "AbortError" ? "délai dépassé" : String(e.message), autorite: TSA };
  } finally {
    clearTimeout(t);
  }
}

// ── Exécution ────────────────────────────────────────────────────────────
const chaine = construire();
const tete = chaine.length ? chaine[chaine.length - 1].empreinte : null;

if (process.argv.includes("--verifier")) {
  if (!existsSync(FICHIER)) {
    console.error("Aucune chaîne enregistrée.");
    process.exit(1);
  }
  const enregistree = JSON.parse(readFileSync(FICHIER, "utf8"));
  let rompue = null;
  for (let i = 0; i < chaine.length; i++) {
    const a = enregistree.entrees[i];
    if (!a || a.empreinte !== chaine[i].empreinte) {
      rompue = i;
      break;
    }
  }
  if (rompue === null && enregistree.entrees.length === chaine.length) {
    console.log(`Chaîne intacte — ${chaine.length} entrées, tête ${tete.slice(0, 16)}`);
    process.exit(0);
  }
  console.error(
    rompue === null
      ? `Longueur différente : ${enregistree.entrees.length} enregistrées, ${chaine.length} recalculées`
      : `Chaîne rompue à l'entrée ${rompue} (${chaine[rompue].objet})`
  );
  process.exit(1);
}

const horodatage = process.argv.includes("--hors-ligne")
  ? { obtenu: false, motif: "mode hors ligne demandé", autorite: TSA }
  : await horodater(tete);

writeFileSync(
  FICHIER,
  JSON.stringify(
    {
      _: "Registre chaîné. Chaque entrée porte le hachage de la précédente : modifier une entrée ancienne invalide toutes les suivantes. `node outils/chaine.mjs --verifier` recalcule et compare.",
      construite_le: new Date().toISOString(),
      algorithme: "sha256 sur le corps canonique (clés triées, sans espace), chaîné par `precedent`",
      nombre_d_entrees: chaine.length,
      tete,
      horodatage,
      entrees: chaine,
    },
    null,
    2
  ).replace('"entrees_liste"', '"entrees"') + "\n"
);

console.log(`${chaine.length} entrées · tête ${tete.slice(0, 16)}`);
console.log(
  horodatage.obtenu
    ? `horodaté par ${horodatage.autorite} — ${horodatage.date_signee} (jeton ${horodatage.jeton_octets} octets)`
    : `NON horodaté : ${horodatage.motif}`
);
console.log("→ donnees/chaine.json");

/**
 * Nos propres citations répondent-elles encore ?
 *
 * La règle 25 a réglé la moitié du problème : une mesure que nous produisons
 * est figée, servie, et son empreinte est vérifiée. L'autre moitié est restée
 * ouverte, et l'instrument qui mesure notre chaîne de preuves le dit lui-même —
 * « il compte les sources externes sans les visiter ». Quarante-deux
 * affirmations de ce journal reposent sur une page ouverte ailleurs. Ces pages
 * peuvent disparaître, changer d'adresse, passer derrière un péage. Le jour où
 * l'une d'elles meurt, l'affirmation qu'elle soutenait continue de la citer, et
 * rien sur le site ne le dit.
 *
 * Cet instrument visite chaque adresse citée et consigne ce qu'elle répond.
 *
 * DEUX PRÉCAUTIONS, parce que la mesure est plus facile à rater qu'elle n'en a
 * l'air :
 *
 *   1. Ne pas confondre « morte » et « fermée ». Un 404 signifie que la page
 *      n'est plus là. Un 402, un 403 ou un 429 signifient que nous n'y avons pas
 *      accès — ce qui est tout autre chose, et nous le savions déjà pour
 *      certaines. Les deux sont consignés séparément.
 *
 *   2. Ne pas conclure d'une seule tentative. Une panne de trente secondes
 *      ferait déclarer morte une page qui va très bien. Chaque adresse est
 *      donc réessayée, espacée, et une seule réponse exploitable suffit.
 *
 * Le résultat ne bloque pas la publication : ce journal n'est pas responsable
 * de la survie des sites qu'il cite. Ce dont il est responsable, c'est de ne
 * pas le taire. La règle 26 exige que la mesure existe et soit fraîche, pas
 * que les liens soient vivants.
 *
 *   node outils/citations.mjs
 *
 * Sortie : donnees/mesures/citations.json
 */

import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const UA = "LIPIKA-verificateur-de-citations/1.0 (+https://lipika-theta.vercel.app/methode)";
const DELAI = 20000;
const PAUSE = 1400;
const TENTATIVES = 3;

const lire = (n) => JSON.parse(readFileSync(join(RACINE, "donnees", n), "utf8"));
const dormir = (ms) => new Promise((r) => setTimeout(r, ms));

const sources = lire("sources.json").sources;
const claims = lire("claims.json").claims;

/**
 * Comment lire un code de réponse.
 *
 * « joignable » ne veut pas dire que le contenu est le bon — nous ne relisons
 * pas la page. Cela veut dire qu'un tiers qui suit notre lien arrive quelque
 * part. C'est le minimum, et c'est déjà ce que beaucoup d'archives de presse
 * ne tiennent pas.
 */
function qualifier(statut) {
  if (statut === null) return "sans_reponse";
  if (statut >= 200 && statut < 300) return "joignable";
  if (statut === 401 || statut === 402 || statut === 403 || statut === 429) return "fermee";
  if (statut === 404 || statut === 410) return "morte";
  if (statut >= 500) return "en_panne";
  return "autre";
}

const MOTIFS = {
  joignable: "la page répond",
  fermee: "la page existe mais nous est refusée — péage, connexion requise, ou filtre anti-robots",
  morte: "la page n'existe plus à cette adresse",
  en_panne: "le serveur répond par une erreur de son côté",
  sans_reponse: "aucune réponse obtenue en trois tentatives",
  autre: "réponse inattendue",
  non_testable: "la source déclare un mode d'accès qu'une requête de lecture ne sait pas éprouver",
};

/**
 * Une tentative.
 *
 * On essaie HEAD d'abord : c'est la requête polie, elle ne télécharge rien.
 * Mais on ne la croit que quand elle dit oui.
 *
 * La première version de cet instrument déclarait morte la page de The Next Web
 * qui soutient une de nos affirmations. Elle ne l'était pas : ce serveur répond
 * 404 à HEAD et 200 à GET. Nous avions publié le verdict d'une requête que le
 * site ne prend pas au sérieux, pour une page que n'importe quel lecteur ouvre
 * sans difficulté. Un HEAD négatif n'est donc jamais un verdict — seul un GET
 * décide qu'une page est morte.
 */
async function frapper(url) {
  let parHead = null;
  try {
    const r = await fetch(url, {
      method: "HEAD",
      redirect: "follow",
      headers: { "user-agent": UA, accept: "*/*" },
      signal: AbortSignal.timeout(DELAI),
    });
    // Un HEAD qui réussit suffit : la page répond, inutile de la télécharger.
    if (r.status >= 200 && r.status < 300)
      return {
        statut: r.status,
        adresse_finale: r.url && r.url !== url ? r.url : null,
        type: r.headers.get("content-type"),
        methode: "HEAD",
      };
    parHead = r.status;
  } catch {
    // Un HEAD qui échoue ne dit rien non plus : on passe au GET.
  }

  try {
    const r = await fetch(url, {
      method: "GET",
      redirect: "follow",
      headers: { "user-agent": UA, accept: "*/*" },
      signal: AbortSignal.timeout(DELAI),
    });
    return {
      statut: r.status,
      adresse_finale: r.url && r.url !== url ? r.url : null,
      type: r.headers.get("content-type"),
      methode: "GET",
      head_disait: parHead !== null && parHead !== r.status ? parHead : null,
    };
  } catch (e) {
    return {
      statut: null,
      erreur: e.name === "TimeoutError" ? "délai dépassé" : e.message,
      head_disait: parHead,
    };
  }
}

/** Plusieurs tentatives espacées. Une seule réponse exploitable suffit. */
async function visiter(url) {
  const essais = [];
  for (let n = 1; n <= TENTATIVES; n += 1) {
    if (n > 1) await dormir(3000 * n);
    const r = await frapper(url);
    essais.push({ statut: r.statut, erreur: r.erreur ?? null });
    // Un verdict clair — joignable, fermée, morte — ne se réessaie pas.
    const q = qualifier(r.statut);
    if (q === "joignable" || q === "fermee" || q === "morte") return { ...r, essais, tentatives: n };
  }
  const dernier = essais[essais.length - 1];
  return { statut: dernier.statut, erreur: dernier.erreur, essais, tentatives: TENTATIVES };
}

/**
 * Certaines adresses ne se lisent pas en GET, et ce n'est pas une avarie.
 *
 * L'autorité d'horodatage que nous employons expose un point d'accès qui
 * n'accepte que POST : lui envoyer un GET rend un refus, ce que cet instrument
 * lirait comme « fermée ». Ce serait faux, et faux dans le sens qui compte —
 * un lecteur croirait à une preuve en train de pourrir. Une source peut donc
 * déclarer son mode d'accès, et l'instrument s'abstient au lieu de deviner.
 */
const externes = sources.filter((s) => typeof s.url === "string" && /^https?:/i.test(s.url));
console.log(`${externes.length} adresses citées à visiter\n`);

const resultats = [];
for (const s of externes) {
  if (s.methode_d_acces && s.methode_d_acces !== "GET") {
    resultats.push({
      source: s.id,
      url: s.url,
      emetteur: s.emetteur,
      preuve: s.preuve,
      consultee_le: s.consultee_le ?? null,
      etat: "non_testable",
      motif: `la source déclare un accès en ${s.methode_d_acces} ; une requête de lecture n'en dirait rien`,
      statut: null,
      adresse_finale: null,
      tentatives: 0,
      methode_retenue: null,
      head_en_desaccord: null,
      erreur: null,
      affirmations: claims.filter((c) => (c.sources || []).includes(s.id)).map((c) => c.id),
      affirmations_sans_autre_preuve: [],
    });
    console.log(`  ${s.id}   —  ${s.methode_d_acces.padEnd(7)} ${s.url.slice(0, 62)}`);
    continue;
  }
  await dormir(PAUSE);
  const r = await visiter(s.url);
  const etat = qualifier(r.statut);
  const portees = claims.filter((c) => (c.sources || []).includes(s.id));
  // Une affirmation n'est orpheline que si AUCUNE de ses sources n'est ouvrable.
  const orphelines = portees.filter((c) =>
    (c.sources || []).every((id) => {
      const autre = sources.find((x) => x.id === id);
      if (!autre) return true;
      if (autre.preuve === "M") return false; // une mesure figée reste ouvrable
      if (autre.id === s.id) return etat !== "joignable";
      return false; // les autres seront jugées à leur tour ; on ne présume pas
    })
  );
  resultats.push({
    source: s.id,
    url: s.url,
    emetteur: s.emetteur,
    preuve: s.preuve,
    consultee_le: s.consultee_le ?? null,
    etat,
    motif: MOTIFS[etat],
    statut: r.statut ?? null,
    adresse_finale: r.adresse_finale ?? null,
    tentatives: r.tentatives,
    methode_retenue: r.methode ?? null,
    head_en_desaccord: r.head_disait ?? null,
    erreur: r.erreur ?? null,
    affirmations: portees.map((c) => c.id),
    affirmations_sans_autre_preuve: orphelines.map((c) => c.id),
  });
  const marque = { joignable: "ok", fermee: "fermée", morte: "MORTE", en_panne: "panne", sans_reponse: "muette", autre: "?" }[etat];
  console.log(`  ${s.id}  ${String(r.statut ?? "—").padStart(3)}  ${marque.padEnd(7)} ${s.url.slice(0, 62)}`);
}

// Tous les états sont comptés, y compris à zéro.
//
// Sans cela, « morte » n'apparaîtrait dans les totaux que le jour où une page
// meurt — et le passage quotidien, qui compare le total d'hier à celui
// d'aujourd'hui, verrait une valeur absente au lieu d'un zéro. Il ne
// signalerait donc rien, précisément le jour où il aurait quelque chose à
// dire. Un compteur qui n'existe qu'en cas de problème ne détecte pas
// l'apparition du problème.
const par = Object.fromEntries(Object.keys(MOTIFS).map((k) => [k, 0]));
for (const r of resultats) par[r.etat] = (par[r.etat] ?? 0) + 1;

const mortes = resultats.filter((r) => r.etat === "morte");
const exposees = [...new Set(mortes.flatMap((r) => r.affirmations_sans_autre_preuve))];

const mesure = {
  _: "Mesure produite par outils/citations.mjs. Elle porte sur ce journal : les adresses que nos propres sources citent répondent-elles encore ?",
  mesure_le: new Date().toISOString(),
  methode: {
    requete:
      "HEAD d'abord, et il n'est cru que s'il répond 2xx ; sinon GET tranche. Redirections suivies, 20 s de patience, agent déclaré. Un serveur qui répond 404 à HEAD et 200 à GET est fréquent, et le confondre ferait déclarer morte une page vivante — c'est arrivé à la première version de cet instrument.",
    tentatives: `${TENTATIVES} tentatives espacées ; un verdict clair (joignable, fermée, morte) arrête les essais.`,
    etats: MOTIFS,
    separation:
      "« morte » et « fermée » ne se confondent pas. Un 404 dit que la page n'est plus là ; un 402, 403 ou 429 dit que nous n'y avons pas accès, ce qui peut être vrai depuis le premier jour et n'enlève rien à la source.",
    limite:
      "Nous vérifions qu'une adresse répond, pas que la page dit encore ce que nous lui avons fait dire. Un site peut réécrire un article sans changer d'adresse : cette mesure ne le verrait pas. C'est la limite majeure de l'instrument et elle n'est pas contournable sans archiver le contenu, ce que le droit d'auteur nous interdit de publier.",
    instabilite:
      "Un verdict « fermée » n'est pas stable. Nous l'avons constaté sur cybersecuritydive.com, qui a répondu 200 puis 403 à dix minutes d'intervalle, au même agent : un filtre anti-robots décide au cas par cas. Deux exécutions de cet instrument peuvent donc donner deux chiffres, et l'écart ne dit rien du site. Il ne dit que ceci : nous n'avons pas toujours accès à ce que nous citons.",
    refus:
      "Quand un site nous refuse, nous n'insistons pas. Un 401, 402, 403 ou 429 arrête les tentatives pour cette adresse. Contourner un refus serait plus facile que de l'écrire ; ce journal écrit qu'il a été refusé.",
    politesse:
      "1,4 seconde entre deux adresses, un agent qui se nomme et donne l'adresse de notre méthode. Un site qui nous refuse est consigné comme fermé, pas contourné.",
  },
  totaux: {
    adresses: resultats.length,
    ...par,
    affirmations_concernees: [...new Set(resultats.flatMap((r) => r.affirmations))].length,
    affirmations_sans_preuve_ouvrable: exposees.length,
  },
  affirmations_sans_preuve_ouvrable: exposees,
  citations: resultats,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "citations.json"), JSON.stringify(mesure, null, 2) + "\n");

console.log(`\n${JSON.stringify(par)}`);
console.log(`affirmations sans aucune preuve ouvrable : ${exposees.length}${exposees.length ? " — " + exposees.join(", ") : ""}`);
console.log("→ donnees/mesures/citations.json");

/**
 * Le contraste, mesuré — pas jugé à l'œil.
 *
 * Les couleurs sont lues dans `app/globals.css`, pas recopiées ici : un
 * contrôle qui a sa propre copie des valeurs cesse de contrôler quoi que ce
 * soit dès la première retouche. Le rapport est calculé selon WCAG 2.1, et
 * comparé au seuil qui correspond à l'usage réel de chaque paire — 4,5:1 pour
 * du texte courant, 3:1 pour du gros texte et pour les bordures qui portent une
 * information.
 *
 *   node outils/contraste.mjs
 */

import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const CSS = readFileSync(join(RACINE, "app", "globals.css"), "utf8");

/** Les deux mondes : le bloc `:root` nu, et le bloc `[data-theme="dark"]`. */
function palette(selecteur) {
  const i = CSS.indexOf(selecteur);
  if (i === -1) throw new Error("bloc introuvable : " + selecteur);
  const bloc = CSS.slice(i, CSS.indexOf("}", i));
  const couleurs = {};
  for (const m of bloc.matchAll(/--([\w-]+):\s*(#[0-9a-f]{6})/gi)) couleurs[m[1]] = m[2];
  return couleurs;
}

function luminance(hex) {
  const c = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
  const [r, v, b] = c.map((x) => (x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4));
  return 0.2126 * r + 0.7152 * v + 0.0722 * b;
}

function rapport(a, b) {
  const [x, y] = [luminance(a), luminance(b)].sort((p, q) => q - p);
  return (x + 0.05) / (y + 0.05);
}

/** Chaque paire porte son usage réel, donc son seuil. */
const PAIRES = [
  ["encre", "fond", 4.5, "texte courant"],
  ["encre", "fond-2", 4.5, "texte dans un encadré"],
  ["encre-2", "fond", 4.5, "chapeaux, notes, libellés"],
  ["encre-2", "fond-2", 4.5, "libellés dans un encadré"],
  ["encre-3", "fond", 3, "texte secondaire, gros ou discret"],
  ["rouge", "fond", 4.5, "statut contesté, alertes"],
  ["rouge", "fond-2", 4.5, "alertes dans un encadré"],
  ["or", "fond", 4.5, "liens et marques de signature"],
  ["or", "fond-2", 4.5, "signature dans un encadré"],
  ["vert", "fond", 4.5, "verdict documenté"],
  ["ambre", "fond", 4.5, "statut non corroboré"],
  ["fond", "encre", 4.5, "texte inversé des boutons actifs"],
  ["trait-fort", "fond", 3, "bordures porteuses d'information"],
  ["or", "or-faible", 4.5, "le rayon de souffle, dans sa pastille"],
  ["encre-2", "fond-2", 4.5, "la confiance, dans un nœud du graphe"],
  ["ambre", "fond-2", 4.5, "les bornes, dans un nœud du graphe"],
  ["vert", "fond-2", 4.5, "les corroborations, dans un nœud du graphe"],
];

const themes = [
  ["archive (clair)", palette(":root {")],
  ["terminal (sombre)", palette(':root[data-theme="dark"]')],
];

let echecs = 0;
for (const [nom, p] of themes) {
  console.log(`\n${nom}`);
  for (const [avant, arriere, seuil, usage] of PAIRES) {
    const a = p[avant];
    const b = p[arriere];
    if (!a || !b) {
      console.log(`  ?      ${avant} sur ${arriere} — jeton absent`);
      echecs += 1;
      continue;
    }
    const r = rapport(a, b);
    const ok = r >= seuil;
    if (!ok) echecs += 1;
    console.log(
      `  ${ok ? "ok " : "NON"}   ${(avant + " sur " + arriere).padEnd(26)} ${r.toFixed(2).padStart(5)}:1  ` +
        `(seuil ${seuil}) — ${usage}`
    );
  }
}

console.log(
  echecs === 0
    ? `\n${PAIRES.length * 2} paires mesurées dans les deux thèmes, aucune sous son seuil.`
    : `\n${echecs} paire(s) sous le seuil.`
);
process.exit(echecs === 0 ? 0 : 1);

/**
 * Ce qu'une page coûte à l'agent qui la lit.
 *
 * Toute la mesure d'audience du web repose sur l'attention : temps passé,
 * profondeur de défilement, clics. Un agent n'a pas d'attention. Il a un
 * budget — un nombre de jetons qu'il peut dépenser avant de devoir oublier
 * quelque chose. Le coût d'une page n'est donc pas une métrique technique de
 * plus : c'est la seule contrainte que le lecteur-machine subit vraiment, et
 * personne ne l'optimise.
 *
 * Deux grandeurs, et c'est leur rapport qui informe :
 *
 *   LE COÛT       combien de jetons il faut avaler pour avoir lu la page.
 *
 *   LE RENDEMENT  combien d'affirmations vérifiables on en retire par
 *                 kilojeton dépensé. Une page magnifique qui coûte quarante
 *                 mille jetons pour un seul fait est une mauvaise page pour un
 *                 agent, quoi qu'en pense son auteur humain.
 *
 * Et la comparaison qui décide : pour chaque page, ce journal sert aussi une
 * version destinée aux machines. Si la version machine ne coûte pas nettement
 * moins cher que la page HTML pour la même information, elle ne sert à rien et
 * il faut le dire.
 *
 *   node outils/cout.mjs
 *
 * Sortie : donnees/mesures/cout.json
 */

import { writeFileSync, mkdirSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const BASE = process.env.LIPIKA_ORIGINE ?? "https://lipika-theta.vercel.app";
const UA = "LIPIKA-mesure-de-cout/1.0";
const dormir = (ms) => new Promise((r) => setTimeout(r, ms));

/**
 * Compter des jetons sans le tokeniseur du modèle qui lira.
 *
 * Il n'y en a pas un seul : chaque famille découpe autrement, et le nombre
 * exact dépend du lecteur. On approxime donc, et on le dit. La règle retenue
 * est celle que les fournisseurs publient eux-mêmes pour un ordre de grandeur :
 * environ quatre caractères par jeton en anglais, un peu moins en français à
 * cause des accents et des élisions. On applique 3,6 et on borne l'affirmation
 * en conséquence : ces chiffres se comparent entre eux, ils ne se citent pas à
 * l'unité près.
 */
const CAR_PAR_JETON = 3.6;
const jetons = (texte) => Math.round(texte.length / CAR_PAR_JETON);

/** Le texte qu'un agent retient d'une page HTML, une fois le balisage tombé. */
function texteUtile(html) {
  return html
    .replace(/<script[\s\S]*?<\/script>/gi, " ")
    .replace(/<style[\s\S]*?<\/style>/gi, " ")
    .replace(/<[^>]+>/g, " ")
    .replace(/&[a-z]+;|&#\d+;/gi, " ")
    .replace(/\s+/g, " ")
    .trim();
}

async function tirer(chemin) {
  try {
    const r = await fetch(BASE + chemin, {
      headers: { "user-agent": UA, accept: "*/*" },
      signal: AbortSignal.timeout(25000),
    });
    if (!r.ok) return { erreur: `réponse ${r.status}` };
    return { octets: await r.text(), statut: r.status };
  } catch (e) {
    return { erreur: e.message };
  }
}

const claims = JSON.parse(
  (await import("node:fs")).readFileSync(join(RACINE, "donnees", "claims.json"), "utf8")
).claims;
const stories = JSON.parse(
  (await import("node:fs")).readFileSync(join(RACINE, "donnees", "stories.json"), "utf8")
).stories;

/**
 * Les couples à comparer : une page pour humain, son équivalent pour machine.
 * On ne prend que des papiers publiés — comparer une page vide n'apprend rien.
 */
const COUPLES = stories
  .filter((s) => s.etat === "publiee")
  .slice(0, 8)
  .map((s) => ({
    sujet: s.id,
    titre: s.titre,
    humain: `/papier/${s.id}`,
    machine: `/machine/papier/${s.id}`,
    affirmations: claims.filter((c) => c.story === s.id).length,
  }));

console.log(`${COUPLES.length} papiers, deux versions chacun\n`);

const mesures = [];
for (const c of COUPLES) {
  await dormir(700);
  const h = await tirer(c.humain);
  await dormir(700);
  const m = await tirer(c.machine);
  if (h.erreur || m.erreur) {
    mesures.push({ ...c, erreur: h.erreur ?? m.erreur });
    console.log(`  ${c.sujet}  erreur : ${h.erreur ?? m.erreur}`);
    continue;
  }

  const htmlBrut = jetons(h.octets);
  const htmlUtile = jetons(texteUtile(h.octets));
  const jsonBrut = jetons(m.octets);

  const x = {
    ...c,
    html_octets: h.octets.length,
    html_jetons_bruts: htmlBrut,
    html_jetons_utiles: htmlUtile,
    // Ce que le balisage coûte pour ne rien apprendre. Un agent qui ne sait pas
    // dépouiller le HTML — et beaucoup ne le font pas — paie le premier chiffre.
    part_de_balisage: +(1 - htmlUtile / htmlBrut).toFixed(3),
    json_octets: m.octets.length,
    json_jetons: jsonBrut,
    // Le rapport qui décide si la version machine sert à quelque chose.
    economie_vs_html_brut: +(1 - jsonBrut / htmlBrut).toFixed(3),
    economie_vs_texte_utile: +(1 - jsonBrut / htmlUtile).toFixed(3),
    // Le rendement : des affirmations vérifiables par kilojeton dépensé.
    rendement_html: +((c.affirmations / htmlUtile) * 1000).toFixed(2),
    rendement_json: +((c.affirmations / jsonBrut) * 1000).toFixed(2),
  };
  mesures.push(x);
  console.log(
    `  ${c.sujet}  html ${String(htmlBrut).padStart(6)} j · utile ${String(htmlUtile).padStart(6)} j · ` +
      `json ${String(jsonBrut).padStart(6)} j · rendement ${x.rendement_json} aff./kj`
  );
}

const ok = mesures.filter((m) => !m.erreur);
const moyenne = (f) => +(ok.reduce((n, m) => n + f(m), 0) / Math.max(1, ok.length)).toFixed(3);

const mesure = {
  _: "Mesure produite par outils/cout.mjs. Elle porte sur ce journal : ce qu'une de ses pages coûte en jetons à l'agent qui la lit, et combien d'affirmations vérifiables il en retire.",
  mesure_le: new Date().toISOString(),
  cible: BASE,
  methode: {
    jetons: `approximation à ${CAR_PAR_JETON} caractères par jeton. Il n'existe pas de compte universel : chaque famille de modèles découpe autrement. Ces nombres se comparent entre eux ; ils ne se citent pas à l'unité près.`,
    brut_et_utile:
      "« brut » = la page telle qu'elle arrive. « utile » = ce qu'il en reste une fois le balisage, les scripts et les styles retirés. L'écart est ce que coûte le HTML pour ne rien apprendre, et un agent qui ne sait pas dépouiller paie le premier chiffre.",
    rendement:
      "affirmations vérifiables de la page, divisées par les jetons qu'elle coûte, ramenées au kilojeton. C'est la seule métrique de cette mesure qui ne soit pas transposable telle quelle : elle suppose que le contenu soit découpé en unités citables, ce que peu de sites font.",
    limites: [
      "Le compte de jetons est une approximation assumée. Le vrai chiffre dépend du tokeniseur du modèle qui lit, et nous n'en connaissons aucun.",
      "Le rendement suppose qu'une affirmation vaut une affirmation. Une phrase longue et une mesure chiffrée comptent ici pour un.",
      "Huit papiers ne sont pas le site. Les pages d'index, de recherche et de graphe ont d'autres profils et ne sont pas mesurées ici.",
      "Nous mesurons ce qu'une page coûte, pas ce qu'un agent en retient. Un agent peut abandonner à mi-lecture, ou n'en extraire qu'une phrase.",
    ],
  },
  totaux: {
    papiers: ok.length,
    html_jetons_moyens: Math.round(moyenne((m) => m.html_jetons_bruts)),
    texte_utile_moyen: Math.round(moyenne((m) => m.html_jetons_utiles)),
    json_jetons_moyens: Math.round(moyenne((m) => m.json_jetons)),
    part_de_balisage_moyenne: moyenne((m) => m.part_de_balisage),
    economie_moyenne_vs_html: moyenne((m) => m.economie_vs_html_brut),
    economie_moyenne_vs_texte: moyenne((m) => m.economie_vs_texte_utile),
    rendement_html_moyen: moyenne((m) => m.rendement_html),
    rendement_json_moyen: moyenne((m) => m.rendement_json),
  },
  par_papier: mesures,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "cout.json"), JSON.stringify(mesure, null, 2) + "\n");

const t = mesure.totaux;
console.log(`\nmoyennes sur ${t.papiers} papiers`);
console.log(`  page HTML     : ${t.html_jetons_moyens} jetons, dont ${Math.round(t.part_de_balisage_moyenne * 100)} % de balisage`);
console.log(`  texte utile   : ${t.texte_utile_moyen} jetons`);
console.log(`  version machine : ${t.json_jetons_moyens} jetons — ${Math.round(t.economie_moyenne_vs_html * 100)} % de moins que la page brute`);
console.log(`  rendement     : ${t.rendement_html_moyen} aff./kj en HTML contre ${t.rendement_json_moyen} en JSON`);
console.log("→ donnees/mesures/cout.json");

/**
 * Ce que contiennent les fiches du seul annuaire énumérable.
 *
 * `outils/annuaires.mjs` établit qu'un seul des huit annuaires recensés sert un
 * index machine. Ce script ouvre cet index et regarde ce qu'il y a dedans —
 * deux propriétés, et elles ne sont pas du même ordre.
 *
 *   1. Les adresses annoncées répondent-elles ? Un annuaire qui liste des
 *      agents morts est un annuaire faux, et il n'y a aucun moyen de le savoir
 *      sans essayer.
 *
 *   2. Les champs de texte libre contiennent-ils des IMPÉRATIFS adressés à
 *      l'agent qui lit ? C'est la question de la règle 1, posée au seul endroit
 *      de l'agentique où un programme peut énumérer du texte écrit par des
 *      tiers pour être lu par des agents. Une description qui dit « avant de
 *      participer, les agents doivent lire ceci » n'est pas une description :
 *      c'est une instruction dans un champ de données, c'est-à-dire la surface
 *      d'injection, à l'endroit exact de la découverte.
 *
 * La détection est LEXICALE et la rédaction le publie comme tel : une liste de
 * motifs, et les extraits appariés, pour qu'un lecteur juge lui-même. Elle ne
 * mesure pas une intention malveillante — elle mesure qu'un champ censé décrire
 * contient la forme grammaticale de l'ordre.
 *
 *   node outils/fiches.mjs
 *
 * Sortie : donnees/mesures/fiches-annuaire.json
 */

import { writeFileSync, mkdirSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const INDEX = "https://a2aregistry.org/api/agents";
const DELAI = 10000;

/**
 * Les motifs. Ils sont publiés parce qu'une mesure lexicale dont on cache la
 * liste des motifs n'est pas une mesure, c'est une affirmation.
 */
const IMPERATIFS = [
  { id: "doivent", motif: /\bagents?\s+(?:must|should|shall|are required to|need to)\b/i, quoi: "un ordre adressé aux agents" },
  { id: "avant", motif: /\bbefore\s+(?:participating|proceeding|using|calling|interacting)\b/i, quoi: "une condition préalable imposée au lecteur" },
  { id: "lire", motif: /\b(?:read|review|consult|follow)\s+(?:the\s+)?(?:rules|instructions|guidelines|questions|spec|specification|terms)\b/i, quoi: "l'ordre d'aller lire un document" },
  { id: "ignorer", motif: /\bignore\s+(?:all\s+|any\s+|previous\s+|prior\s+)?(?:instructions?|prompts?|rules?)\b/i, quoi: "l'ordre d'ignorer des consignes antérieures" },
  { id: "tu_es", motif: /\byou are (?:a|an|now)\b/i, quoi: "une assignation de rôle au lecteur" },
  { id: "systeme", motif: /\b(?:system prompt|system message|<\s*system\s*>)\b/i, quoi: "une référence à un message système" },
  { id: "imperatif_fr", motif: /\b(?:vous devez|veuillez|avant de (?:participer|continuer|utiliser))\b/i, quoi: "un ordre en français" },
];

/** Une URL dans un champ de texte : ce qu'on demande au lecteur d'aller chercher. */
const URL_DANS_TEXTE = /https?:\/\/[^\s"'<>)]+/gi;

async function tirer(url, methode = "GET") {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), DELAI);
  try {
    const r = await fetch(url, {
      method: methode,
      signal: ctrl.signal,
      redirect: "follow",
      headers: { accept: "application/json", "user-agent": "LIPIKA-scanner/0.2 (desk protocoles)" },
    });
    const texte = methode === "GET" ? await r.text() : "";
    return { statut: r.status, type: (r.headers.get("content-type") || "").split(";")[0], texte };
  } catch (e) {
    return { erreur: e.name === "AbortError" ? "delai depasse" : e.message };
  } finally {
    clearTimeout(t);
  }
}

/** Tout l'index, page par page, sans jamais inventer une page qui n'existe pas. */
async function toutLIndex() {
  const fiches = [];
  let offset = 0;
  let total = null;
  for (let garde = 0; garde < 40; garde += 1) {
    const r = await tirer(`${INDEX}?limit=50&offset=${offset}`);
    if (r.erreur || r.statut !== 200) break;
    let j;
    try {
      j = JSON.parse(r.texte);
    } catch {
      break;
    }
    const lot = j.agents ?? [];
    total = j.total ?? total;
    fiches.push(...lot);
    offset += lot.length;
    if (!lot.length || (total !== null && fiches.length >= total)) break;
  }
  return { fiches, total };
}

const champsTexte = (f) =>
  [f.name, f.description, ...(Array.isArray(f.skills) ? f.skills.flatMap((s) => [s.name, s.description]) : [])]
    .filter((x) => typeof x === "string")
    .join("\n");

console.log("Index :", INDEX);
const { fiches, total } = await toutLIndex();
console.log(`${fiches.length} fiches récupérées (total annoncé : ${total ?? "non déclaré"}).`);

// ── 1. Les impératifs dans les champs de texte ────────────────────────────
const analysees = fiches.map((f) => {
  const texte = champsTexte(f);
  const touches = IMPERATIFS.filter((m) => m.motif.test(texte));
  const extraits = touches.map((m) => {
    const r = texte.match(m.motif);
    const i = Math.max(0, texte.indexOf(r[0]) - 60);
    return { motif: m.id, quoi: m.quoi, extrait: texte.slice(i, i + 220).replace(/\s+/g, " ").trim() };
  });
  const urls = [...new Set(texte.match(URL_DANS_TEXTE) ?? [])];
  return {
    nom: typeof f.name === "string" ? f.name : null,
    url: f.url ?? null,
    version_declaree: f.protocolVersion ?? null,
    octets_de_texte: texte.length,
    imperatifs: touches.map((m) => m.id),
    extraits,
    urls_dans_le_texte: urls.length,
    exemples_d_url: urls.slice(0, 3),
  };
});

// ── 2. Les adresses annoncées répondent-elles ? ───────────────────────────
console.log("Vérification des adresses annoncées…");
const adresses = [];
let i = 0;
const ouvriers = Array.from({ length: 8 }, async () => {
  while (i < analysees.length) {
    const k = i++;
    const f = analysees[k];
    if (!f.url) {
      adresses[k] = { url: null, statut: null, note: "aucune adresse déclarée" };
      process.stdout.write("·");
      continue;
    }
    const r = await tirer(f.url);
    adresses[k] = r.erreur
      ? { url: f.url, statut: null, note: r.erreur }
      : { url: f.url, statut: r.statut, type: r.type || null, note: null };
    process.stdout.write(".");
  }
});
await Promise.all(ouvriers);
process.stdout.write("\n");

const repondent = adresses.filter((a) => a.statut !== null && a.statut < 500);
const avecImperatif = analysees.filter((f) => f.imperatifs.length);

const mesure = {
  _: "Mesure produite par outils/fiches.mjs. Méthode, motifs, échantillon et code publics : la mesure est rejouable par un tiers.",
  mesure_le: new Date().toISOString(),
  index: INDEX,
  methode: {
    population:
      "toutes les fiches du seul annuaire d'agents énumérable recensé par outils/annuaires.mjs — ce n'est pas un échantillon, c'est le recensement exhaustif de cet annuaire",
    champs_examines: "name, description, et le nom et la description de chaque compétence déclarée",
    motifs: IMPERATIFS.map((m) => ({ id: m.id, quoi: m.quoi, expression: String(m.motif) })),
    adresse_repond:
      "une requête GET sur l'adresse déclarée renvoie un code HTTP inférieur à 500 — un 404 compte comme « répond », parce que le serveur existe",
    limite:
      "La détection est lexicale. Elle ne mesure ni une intention, ni une malveillance : elle mesure qu'un champ censé décrire contient la forme grammaticale de l'ordre. Les extraits sont publiés pour qu'un lecteur juge lui-même. À l'inverse, une instruction formulée sans ces tournures n'est pas comptée : le chiffre est un plancher, pas un total.",
  },
  totaux: {
    fiches: analysees.length,
    total_annonce: total,
    avec_imperatif: avecImperatif.length,
    part_avec_imperatif: analysees.length ? +(avecImperatif.length / analysees.length).toFixed(4) : null,
    avec_url_dans_le_texte: analysees.filter((f) => f.urls_dans_le_texte > 0).length,
    adresses_declarees: analysees.filter((f) => f.url).length,
    adresses_qui_repondent: repondent.length,
    adresses_injoignables: adresses.filter((a) => a.url && a.statut === null).length,
    versions_declarees: Object.fromEntries(
      [...new Set(analysees.map((f) => String(f.version_declaree)))].sort().map((v) => [
        v,
        analysees.filter((f) => String(f.version_declaree) === v).length,
      ])
    ),
  },
  par_motif: Object.fromEntries(
    IMPERATIFS.map((m) => [m.id, analysees.filter((f) => f.imperatifs.includes(m.id)).length])
  ),
  fiches: analysees.map((f, k) => ({ ...f, adresse: adresses[k] })),
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "fiches-annuaire.json"), JSON.stringify(mesure, null, 2) + "\n");

console.log(
  `${analysees.length} fiches · ${avecImperatif.length} avec un impératif adressé au lecteur · ` +
    `${mesure.totaux.adresses_qui_repondent}/${mesure.totaux.adresses_declarees} adresses répondent`
);
console.log("empreinte :", createHash("sha256").update(JSON.stringify(mesure.fiches)).digest("hex").slice(0, 16));
console.log("→ donnees/mesures/fiches-annuaire.json");

/**
 * Geler les mesures.
 *
 * Une affirmation de ce journal cite un fichier : « mesuré par nous, voici où ».
 * Tant que les instruments tournaient à la main, ce fichier ne bougeait pas
 * entre la publication et la lecture. Le passage quotidien change cela : il
 * relance les instruments, et chaque instrument réécrit son fichier.
 *
 * Une nuit de plus, et l'affirmation publiée hier — « 83 domaines servent un
 * llms.txt » — pointerait vers un fichier qui en annonce 84. Le lecteur qui
 * ouvre la preuve y trouverait autre chose que ce qu'elle prouve. Ce n'est pas
 * une imprécision, c'est la faute que tout le reste du journal existe pour
 * éviter.
 *
 * Le remède est banal et il est définitif : une mesure citée est figée. Ce
 * programme recopie chaque mesure vivante sous un nom daté, dans un dossier
 * d'archives que rien ne réécrit, calcule son empreinte, et réécrit la source
 * pour qu'elle désigne l'archive. Le fichier vivant reste à sa place pour la
 * prochaine comparaison ; il n'est plus cité par personne.
 *
 *   node outils/geler.mjs           gèle ce qui ne l'est pas encore
 *   node outils/geler.mjs --a-blanc dit ce qu'il gèlerait
 *
 * La règle 25 refuse la publication tant qu'une source [M] cite un fichier de
 * mesure vivant, et tant qu'une archive citée ne correspond plus à l'empreinte
 * inscrite dans la source.
 */

import { readFileSync, writeFileSync, mkdirSync, existsSync, statSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join, basename } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const ARCHIVES = join(RACINE, "donnees", "mesures", "archives");
const A_BLANC = process.argv.includes("--a-blanc");

/** Le préfixe des mesures vivantes, et celui des mesures figées. */
export const VIVANT = "donnees/mesures/";
export const FIGE = "donnees/mesures/archives/";

/** L'horodatage d'une mesure : le sien s'il en porte un, sinon celui du fichier. */
function quand(chemin, contenu) {
  try {
    const o = JSON.parse(contenu);
    if (typeof o.mesure_le === "string") return o.mesure_le;
    if (typeof o.releve_le === "string") return o.releve_le;
  } catch {}
  return statSync(chemin).mtime.toISOString();
}

/** 2026-09-13T00:57:55.712Z → 2026-09-13T005755Z, lisible et triable. */
const estampille = (iso) => iso.replace(/[-:]/g, "").replace(/\.\d+/, "").replace("T", "T");

/**
 * Geler un fichier de mesure, et rendre de quoi le citer.
 *
 * Appelée par le passage quotidien, qui doit figer la mesure du jour avant de
 * publier une brève qui s'y adosse. Rend le chemin de l'archive, son empreinte
 * et sa date. N'écrase jamais une archive existante d'un autre contenu.
 */
export function gelerFichier(racine, cheminRelatif) {
  const absolu = join(racine, cheminRelatif);
  if (!existsSync(absolu)) return null;
  const contenu = readFileSync(absolu, "utf8");
  const iso = quand(absolu, contenu);
  const nom = basename(cheminRelatif).replace(/\.json$/, "") + "-" + estampille(iso) + ".json";
  const cible = join(racine, "donnees", "mesures", "archives", nom);
  const empreinte = createHash("sha256").update(contenu, "utf8").digest("hex");

  mkdirSync(join(racine, "donnees", "mesures", "archives"), { recursive: true });
  if (existsSync(cible)) {
    const actuel = createHash("sha256").update(readFileSync(cible, "utf8"), "utf8").digest("hex");
    if (actuel !== empreinte) throw new Error(`archive ${nom} existe déjà avec un autre contenu`);
  } else {
    writeFileSync(cible, contenu, "utf8");
  }
  return { chemin: FIGE + nom, empreinte: "sha256:" + empreinte, mesure_le: iso };
}

// Le reste ne s'exécute que si ce fichier est lancé directement, pas importé.
if (process.argv[1] && process.argv[1].endsWith("geler.mjs")) {

const sources = JSON.parse(readFileSync(join(RACINE, "donnees", "sources.json"), "utf8"));
mkdirSync(ARCHIVES, { recursive: true });

const geles = [];
const deja = [];
const ignores = [];

for (const s of sources.sources) {
  if (s.preuve !== "M" || !s.fichier) continue;
  const [chemin, ...suite] = String(s.fichier).split(" — ");
  const propre = chemin.trim().replace(/^LIPIKA\/site\//, "");

  if (propre.startsWith(FIGE)) {
    deja.push(s.id);
    continue;
  }
  // Les fichiers d'état du journal — la chaîne, les relectures — ne sont pas
  // des instantanés : la chaîne ne fait que croître, les relectures portent
  // leur propre date. Les geler n'apporterait rien et créerait un doublon.
  if (!propre.startsWith(VIVANT)) {
    ignores.push(`${s.id} → ${propre} (état du journal, pas un instantané)`);
    continue;
  }

  const absolu = join(RACINE, propre);
  if (!existsSync(absolu)) {
    ignores.push(`${s.id} → ${propre} (absent)`);
    continue;
  }

  const contenu = readFileSync(absolu, "utf8");
  const iso = quand(absolu, contenu);
  const nom = basename(propre).replace(/\.json$/, "") + "-" + estampille(iso) + ".json";
  const cible = join(ARCHIVES, nom);
  const empreinte = createHash("sha256").update(contenu, "utf8").digest("hex");

  if (!A_BLANC) {
    // Une archive ne se réécrit pas. Si le nom existe déjà avec un autre
    // contenu, c'est que deux mesures portent le même horodatage : on refuse
    // plutôt que d'en écraser une.
    if (existsSync(cible)) {
      const actuel = createHash("sha256").update(readFileSync(cible, "utf8"), "utf8").digest("hex");
      if (actuel !== empreinte) {
        console.error(`REFUS : ${nom} existe déjà avec un autre contenu. Deux mesures au même horodatage.`);
        process.exit(1);
      }
    } else {
      writeFileSync(cible, contenu, "utf8");
    }
    s.fichier = [FIGE + nom, ...suite].join(" — ");
    s.empreinte = "sha256:" + empreinte;
    s.mesure_le = iso;
  }

  geles.push({ source: s.id, depuis: propre, vers: FIGE + nom, empreinte: empreinte.slice(0, 16) });
}

if (!A_BLANC && geles.length) {
  writeFileSync(join(RACINE, "donnees", "sources.json"), JSON.stringify(sources, null, 1) + "\n", "utf8");
}

for (const g of geles) console.log(`  ${g.source}  ${basename(g.depuis).padEnd(24)} → ${basename(g.vers)}  ${g.empreinte}…`);
for (const i of ignores) console.log(`  ignoré : ${i}`);
console.log(
  `\n${geles.length} mesure(s) ${A_BLANC ? "à geler" : "gelée(s)"}, ${deja.length} déjà figée(s), ${ignores.length} hors périmètre.`
);
if (A_BLANC) console.log("(--a-blanc : rien n'a été écrit)");

}

/**
 * Deux fois dans la même feuille, un raccourci `padding` a écrasé les
 * gouttières de `.cadre` : une fois sur `.section`, une fois sur `.bandeau-in`.
 * Le texte touchait alors le bord de l'écran, et ça ne se voit qu'en ouvrant la
 * page à la bonne largeur — c'est-à-dire jamais, tant qu'on ne l'ouvre pas.
 *
 * Ce contrôle interdit le raccourci sur toute règle qui vise un élément portant
 * aussi `.cadre`. Il ne demande pas de faire attention : il refuse.
 */
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const CSS = readFileSync(
  join(dirname(fileURLToPath(import.meta.url)), "..", "app", "globals.css"),
  "utf8"
);

// Les classes posées sur le même élément que `.cadre` dans les pages.
const COMPAGNONS = ["bandeau-in", "section"];
const fautes = [];

for (const nom of COMPAGNONS) {
  const motif = new RegExp(`\.${nom}\s*\{([^}]*)\}`, "g");
  for (const m of CSS.matchAll(motif)) {
    const corps = m[1];
    if (/(^|;)\s*padding\s*:/.test(corps))
      fautes.push(
        `.${nom} utilise le raccourci « padding » — il écrase les gouttières de .cadre. ` +
          `Écrire padding-top / padding-bottom.`
      );
  }
}

if (fautes.length === 0) {
  console.log(`Gouttières : aucun raccourci padding sur ${COMPAGNONS.length} classes compagnes de .cadre.`);
  process.exit(0);
}
console.error("Gouttières : " + fautes.length + " faute(s)");
for (const f of fautes) console.error("  " + f);
process.exit(1);

/**
 * Qui a lu ce journal, parmi les machines.
 *
 * Le middleware consigne une ligne par requête, côté serveur, là où un agent
 * est bien obligé de se montrer. Cet instrument relit ces lignes et en fait un
 * décompte : par genre de lecteur, par collecteur nommé, par surface visée.
 *
 * POURQUOI CE N'EST PAS DÉJÀ FAIT AILLEURS. Les outils d'audience du marché
 * comptent des exécutions de JavaScript dans un navigateur. Un agent qui
 * récupère /llms.txt n'en exécute aucune : pour eux, il n'est jamais venu. Les
 * outils qui le voient sont des pare-feux, et ils posent une autre question —
 * « faut-il bloquer ». Celui-ci ne bloque rien et ne protège rien. Il compte.
 *
 * CE QU'IL FAUT POUR LE REJOUER, et c'est la différence avec tous les autres
 * instruments de ce journal : un jeton d'accès à l'hébergeur. Les journaux
 * d'exécution ne sont pas publics, et ils ne peuvent pas l'être — ils portent
 * ce que des tiers ont demandé. Un lecteur ne peut donc pas rejouer cette
 * mesure sur NOS journaux. Il peut la rejouer sur les siens : le code est
 * public, le middleware aussi, et le fichier produit est figé et servi. C'est
 * moins que d'habitude, et c'est écrit dans la mesure elle-même.
 *
 *   VERCEL_TOKEN=… node outils/lecteurs.mjs [--heures 24]
 *
 * Sortie : donnees/mesures/lecteurs.json
 */

import { writeFileSync, mkdirSync, readFileSync, existsSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const JETON = process.env.VERCEL_TOKEN;
const PROJET = process.env.VERCEL_PROJET ?? "prj_dXS8pOapqqwfsOtWymyWXR1CP2oA";
const EQUIPE = process.env.VERCEL_EQUIPE ?? "team_j2kJInVs8IvsqK0o5gTvaNAe";

const args = process.argv.slice(2);
const heures = Number(args[args.indexOf("--heures") + 1]) || 24;

/**
 * Deux entrées possibles, et la seconde n'est pas un raccourci.
 *
 * Avec un jeton, l'instrument interroge l'hébergeur lui-même. Sans jeton, il
 * accepte un fichier de lignes déjà relevées : c'est ce qui permet de le faire
 * tourner, de le vérifier et de le corriger sans qu'un secret circule. Le
 * fichier est du texte brut, une ligne de journal par ligne, et seules celles
 * qui portent notre préfixe sont comptées.
 */
const depuisFichier = args.includes("--depuis-fichier") ? args[args.indexOf("--depuis-fichier") + 1] : null;

if (!JETON && !depuisFichier) {
  console.error("VERCEL_TOKEN manquant, et aucun --depuis-fichier.");
  console.error("Les journaux d'exécution ne sont pas publics : cette mesure demande un jeton d'accès,");
  console.error("et c'est la seule de ce journal dans ce cas. Le jeton ne va pas dans le dépôt.");
  console.error("  VERCEL_TOKEN=… node outils/lecteurs.mjs");
  console.error("  node outils/lecteurs.mjs --depuis-fichier journaux.txt");
  process.exit(2);
}

const fin = Date.now();
const debut = fin - heures * 3600 * 1000;

let lignes = [];
let source = null;

if (depuisFichier) {
  if (!existsSync(depuisFichier)) {
    console.error(`Fichier introuvable : ${depuisFichier}`);
    process.exit(1);
  }
  lignes = readFileSync(depuisFichier, "utf8").split(String.fromCharCode(10));
  source = `fichier de journaux relevés (${depuisFichier})`;
} else {
  const url =
    `https://api.vercel.com/v1/projects/${PROJET}/logs?` +
    new URLSearchParams({ teamId: EQUIPE, from: String(debut), to: String(fin), limit: "1000" });
  const r = await fetch(url, { headers: { authorization: `Bearer ${JETON}` } });
  if (!r.ok) {
    console.error(`L'hébergeur répond ${r.status}. Rien n'est écrit.`);
    process.exit(1);
  }
  const brut = await r.json();
  lignes = Array.isArray(brut) ? brut : (brut.logs ?? brut.rows ?? []);
  source = "interrogation directe de l'hébergeur";
}

/**
 * Une ligne du middleware et rien d'autre.
 *
 * Le préfixe est le nôtre : il évite de compter comme lecteur une trace
 * d'erreur ou une sortie de construction. Une ligne mal formée est comptée
 * comme illisible plutôt que devinée.
 */
const LECTEURS = [];
let illisibles = 0;
for (const l of lignes) {
  const texte = typeof l === "string" ? l : (l.message ?? l.text ?? l.payload?.text ?? "");
  const i = String(texte).indexOf("LIPIKA-LECTEUR ");
  if (i < 0) continue;
  try {
    LECTEURS.push(JSON.parse(String(texte).slice(i + "LIPIKA-LECTEUR ".length)));
  } catch {
    illisibles += 1;
  }
}

/**
 * Les essais de la rédaction ne sont pas du lectorat.
 *
 * Ils portent un en-tête que nous ajoutons nous-mêmes ; sans lui, rien ne les
 * distinguerait d'un vrai collecteur, puisqu'ils se donnent le même nom. Ils
 * sont comptés à part plutôt que jetés : le chiffre dit combien de bruit nous
 * avons nous-mêmes produit, et ce chiffre appartient au lecteur.
 */
const ESSAIS = LECTEURS.filter((x) => x.essai === true);
const VRAIS = LECTEURS.filter((x) => x.essai !== true);

const compter = (f) => {
  const o = {};
  for (const x of LECTEURS) {
    const k = f(x);
    if (k === null || k === undefined) continue;
    o[k] = (o[k] ?? 0) + 1;
  }
  return Object.fromEntries(Object.entries(o).sort((a, b) => b[1] - a[1]));
};

const parGenre = compter((x) => x.genre);
const parCollecteur = compter((x) => x.collecteur);
const parSurface = compter((x) => x.surface);
const parChemin = compter((x) => x.chemin);

// Un collecteur qui s'annonce et qui ne lit que des pages faites pour les
// humains n'utilise pas ce que nous avons construit pour lui. La distinction
// vaut d'être comptée : c'est la seule qui dise si l'effort sert à quelque chose.
const surSurfaceMachine = VRAIS.filter((x) => x.surface !== null);
const collecteursNommes = VRAIS.filter((x) => x.collecteur);

const mesure = {
  _: "Mesure produite par outils/lecteurs.mjs à partir des lignes consignées par middleware.node.ts. Elle porte sur ce journal : quelles machines l'ont demandé, et qu'ont-elles demandé.",
  mesure_le: new Date().toISOString(),
  fenetre: { debut: new Date(debut).toISOString(), fin: new Date(fin).toISOString(), heures },
  methode: {
    releve:
      source,
    origine:
      "une ligne par requête, écrite par le middleware côté serveur. Aucune adresse IP, aucun témoin de connexion, aucun identifiant de session. Nos propres instruments sont exclus du comptage.",
    genres:
      "collecteur_declare = le nom correspond à l'un des vingt collecteurs de notre liste ; moteur_classique = un robot d'indexation ordinaire ; bibliotheque_http = curl, python-requests et semblables ; non_navigateur = aucun en-tête Sec-Fetch, ce qu'un navigateur envoie toujours ; navigateur = le reste.",
    surfaces:
      "instructions = llms.txt et robots.txt ; decouverte = /.well-known/ ; donnees = /machine/ ; outils = /api/ ; flux = rss et feed ; documentation = /agents et /outils. Le reste est une page écrite pour un humain.",
    limites: [
      "Un user-agent est une déclaration, pas une identité. N'importe quel client peut écrire « ClaudeBot ». Rien ici ne l'authentifie, et c'est exactement le manque que ce journal mesure par ailleurs : dix cartes d'agent sur deux cent six domaines, une seule signature vérifiable.",
      "La liste des vingt collecteurs est la nôtre, donc incomplète. Un opérateur qui collecte sous un nom que nous ignorons est compté comme « non navigateur », pas comme collecteur.",
      "L'absence d'en-têtes Sec-Fetch est un indice, pas une preuve : un agent peut les imiter, et certains clients anciens n'en envoient pas.",
      "Les journaux de l'hébergeur sont conservés peu de temps et cette mesure ne voit qu'une fenêtre. Ce qui n'a pas été relevé est perdu, et la série ne remonte pas avant le premier passage.",
      "Les essais de la rédaction portent un en-tête qui les fait écarter du comptage. Sans cet en-tête, rien ne les distinguerait d'un vrai collecteur : ils se donnent le même nom. C'est la démonstration, faite sur nous-mêmes, que ce chiffre repose sur la bonne foi de qui se présente.",
      "Contrairement à tous les autres instruments de ce journal, un tiers ne peut pas rejouer celui-ci sur nos journaux : ils ne sont pas publics, parce qu'ils portent ce que des tiers ont demandé. Le code et le middleware le sont, et le résultat est figé et servi.",
    ],
  },
  totaux: {
    requetes_lues: VRAIS.length,
    essais_de_la_redaction: ESSAIS.length,
    lignes_illisibles: illisibles,
    collecteurs_nommes: collecteursNommes.length,
    collecteurs_distincts: Object.keys(parCollecteur).length,
    sur_surface_machine: surSurfaceMachine.length,
    // Zéro explicite : sans lui, le passage quotidien comparerait une absence.
    navigateur: parGenre.navigateur ?? 0,
    non_navigateur: parGenre.non_navigateur ?? 0,
    bibliotheque_http: parGenre.bibliotheque_http ?? 0,
    moteur_classique: parGenre.moteur_classique ?? 0,
    collecteur_declare: parGenre.collecteur_declare ?? 0,
  },
  par_genre: parGenre,
  par_collecteur: parCollecteur,
  par_surface: parSurface,
  chemins_les_plus_demandes: Object.fromEntries(Object.entries(parChemin).slice(0, 25)),
  collecteurs_et_ce_qu_ils_lisent: Object.fromEntries(
    Object.keys(parCollecteur).map((nom) => [
      nom,
      {
        requetes: collecteursNommes.filter((x) => x.collecteur === nom).length,
        surfaces: [...new Set(collecteursNommes.filter((x) => x.collecteur === nom).map((x) => x.surface ?? "page humaine"))],
      },
    ])
  ),
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "lecteurs.json"), JSON.stringify(mesure, null, 2) + "\n");

const t = mesure.totaux;
console.log(`fenêtre : ${heures} h · ${t.requetes_lues} requêtes lues, ${t.essais_de_la_redaction} essais écartés${illisibles ? `, ${illisibles} illisibles` : ""}`);
console.log(`genres      : ${JSON.stringify(parGenre)}`);
console.log(`collecteurs : ${Object.keys(parCollecteur).length ? JSON.stringify(parCollecteur) : "aucun"}`);
console.log(`surfaces    : ${Object.keys(parSurface).length ? JSON.stringify(parSurface) : "aucune"}`);
console.log("→ donnees/mesures/lecteurs.json");

/**
 * Aucun lien mort dans la publication.
 *
 * La surface statique est réduite : les entités sur lesquelles rien n'a été
 * écrit n'y ont pas de page, et les vignettes par papier sont repliées sur
 * celle du journal. Toute réduction de ce genre casse des liens en silence —
 * la page existe encore dans le dépôt, plus dans l'export, et personne ne s'en
 * aperçoit avant qu'un lecteur ne tombe dessus.
 *
 * Ce script résout chaque lien relatif de chaque page publiée contre les
 * fichiers réellement présents. Un seul lien mort suffit à faire échouer.
 *
 *   node outils/liens.mjs
 */

import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join, posix, relative, sep } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const CIBLE = join(RACINE, "publication");

/*
 * On ne vérifie pas une publication périmée. Ce script lit `publication/`, que
 * seul `publier.mjs` régénère ; lancé seul après un nouvel export, il relisait
 * en silence l'état d'une semaine plus tôt et répondait « aucune cible morte »
 * pendant que trois liens de /mesures étaient morts. Si `out/` est plus récent
 * que `publication/`, le verdict porterait sur un autre site : on refuse.
 */
const temoin = (d) => join(RACINE, d, "index.html");
if (existsSync(temoin("out")) && existsSync(temoin("publication"))) {
  const retard = statSync(temoin("out")).mtimeMs - statSync(temoin("publication")).mtimeMs;
  if (retard > 60_000) {
    console.error(
      `Liens : publication/ est plus ancienne que le dernier export (${Math.round(retard / 60_000)} min). ` +
        "Lancez d'abord node outils/publier.mjs — sinon ce verdict porterait sur un autre site."
    );
    process.exit(1);
  }
}

function parcourir(d, sortie = []) {
  for (const e of readdirSync(d, { withFileTypes: true })) {
    const p = join(d, e.name);
    if (e.isDirectory()) parcourir(p, sortie);
    else sortie.push(relative(CIBLE, p).split(sep).join("/"));
  }
  return sortie;
}

const tous = new Set(parcourir(CIBLE));
const morts = new Map();

for (const f of [...tous].filter((f) => f.endsWith(".html"))) {
  const html = readFileSync(join(CIBLE, f), "utf8");
  const base = posix.dirname(f);
  for (const m of html.matchAll(/(?:href|src|content)="((?:\.\.?\/)[^"#]*)"/g)) {
    let cible = posix.normalize(posix.join(base, m[1]));
    if (cible.endsWith("/")) cible += "index.html";
    if (!tous.has(cible)) {
      const liste = morts.get(cible) ?? [];
      liste.push(f);
      morts.set(cible, liste);
    }
  }
}

if (morts.size === 0) {
  console.log(`Liens : ${tous.size} fichiers publiés, aucune cible morte.`);
  process.exit(0);
}

console.error(`Liens : ${morts.size} cible(s) morte(s) dans la publication.\n`);
for (const [cible, pages] of morts)
  console.error(`  ${cible} — depuis ${pages.slice(0, 3).join(", ")}${pages.length > 3 ? "…" : ""}`);
process.exit(1);

/**
 * Les cinq lignées, branchées pour de vrai — et la divergence publiée.
 *
 * Le manque n° 4 du numéro zéro : les cinq signatures étaient jouées par un
 * seul modèle. Cinq voix de la même famille partagent leurs angles morts, et un
 * contradicteur qui est le même modèle que l'auteur n'est pas un contradicteur,
 * c'est une relecture.
 *
 * Ce script fait relire les 27 affirmations par cinq familles distinctes, avec
 * la consigne du contradicteur : « trouve pourquoi ça ne tient pas ». Puis il
 * mesure leur accord. L'écart entre familles n'est pas un défaut de ce
 * dispositif : c'en est le produit, et il devient du contenu.
 *
 *   node outils/lignees.mjs --estimer      dit le prix et s'arrête. NE DÉPENSE RIEN.
 *   node outils/lignees.mjs --budget 5     plafond en dollars, OBLIGATOIRE pour partir
 *   node outils/lignees.mjs --sec          aucune requête, sortie simulée
 *
 * POURQUOI `--estimer` EXISTE. La première version n'avait pas ce mode : pour
 * connaître le coût, il fallait lancer le script, qui annonçait l'estimation
 * puis partait. Lancé avec `| grep estimation` pour n'en lire que le prix, il a
 * fait une passe complète de 0,73 $ pendant que la sortie était filtrée. Une
 * garde qui n'offre aucun moyen de demander « combien ? » sans engager la
 * dépense n'est pas une garde : c'est un piège avec un message rassurant.
 *
 * LE BUDGET EST UNE GARDE, PAS UNE OPTION. Ce script dépense l'argent de
 * quelqu'un d'autre. Sans `--budget`, il refuse de partir ; avant de partir, il
 * lit le solde du compte et annonce le coût estimé ; en route, il s'arrête dès
 * que le plafond est atteint. La première version de ce fichier n'avait rien de
 * tout ça : elle a été lancée trois fois, et le compte a fini en 402.
 *
 * La clé n'est jamais copiée dans ce dépôt : on la lit là où elle vit déjà.
 * Sortie : donnees/relectures.json · dépenses : donnees/mesures/depenses.jsonl
 */

import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const SEC = process.argv.includes("--sec");
const ESTIMER = process.argv.includes("--estimer");
const iBudget = process.argv.indexOf("--budget");
const BUDGET = iBudget > -1 ? Number(process.argv[iBudget + 1]) : null;

/** Prix au jeton, relevés au catalogue au moment du lancement. Jamais recopiés. */
let TARIFS = {};
let depense = 0;

function cout(modele, usage) {
  const t = TARIFS[modele];
  if (!t || !usage) return 0;
  return (usage.prompt_tokens ?? 0) * t.prompt + (usage.completion_tokens ?? 0) * t.completion;
}

/**
 * Les cinq familles du panel. Identifiants vérifiés au catalogue OpenRouter.
 *
 * AUCUNE N'EST LA FAMILLE QUI ÉCRIT LE JOURNAL. C'est une correction du
 * 12/09/2026 : la première passe faisait relire les papiers par une lignée
 * anthropic, alors que les papiers sont écrits par un modèle anthropic. Un
 * relecteur corrélé à l'auteur n'est pas un contradicteur — c'est exactement le
 * défaut que l'indice de monoculture existe pour mesurer, et nous l'avions
 * introduit dans l'instrument de mesure lui-même.
 *
 * SUR LE CHOIX DES MODÈLES, ET SUR CE QU'IL NE FAUT PAS OPTIMISER.
 * Le panel achète de l'indépendance de jugement, pas de la puissance. Un
 * relecteur qui rate le contrat JSON n'est pas bon marché : il est ABSENT, et
 * son absence affaiblit la mesure. Le taux d'échec par lignée est donc publié
 * à côté des verdicts — c'est lui qui dira si un modèle est trop léger.
 *
 * À l'inverse, prendre le modèle le moins cher de chaque famille conduirait à
 * un panel de trois lignées à poids ouverts sur cinq : moins cher, et plus
 * corrélé. C'est exactement le défaut que la règle 15 vient de fermer.
 *
 * Coûts au tarif catalogue, pour une passe de 38 affirmations (393 jetons
 * d'entrée et 336 de sortie par appel, mesurés) :
 *   openai/gpt-5.6-luna-pro        0,018 $   (gpt-6-astra coûtait 0,788 $)
 *   google/gemini-3.8-flash        0,059 $
 *   qwen/qwen3.8-27b               0,036 $
 *   mistralai/mistral-medium-3-5   0,118 $
 *   deepseek/deepseek-v4.1-flash   0,010 $   (v4-pro coûtait 0,031 $)
 *                                  ───────
 *                                  0,241 $   contre 1,011 $ avant
 * Estimations au catalogue, pas des relevés de facturation.
 */
export const FAMILLE_DE_LA_MAISON = "anthropic";

export const LIGNEES = [
  { id: "ummon", famille: "deepseek", modele: "deepseek/deepseek-v4.1-flash" },
  { id: "iris", famille: "openai", modele: "openai/gpt-5.6-luna-pro" },
  { id: "kuro", famille: "google", modele: "google/gemini-3.8-flash" },
  { id: "nox", famille: "poids-ouverts", modele: "qwen/qwen3.8-27b" },
  { id: "mira-voss", famille: "mistral", modele: "mistralai/mistral-medium-3-5" },
];

const VERDICTS = ["documentee", "fragile", "inverifiable"];

const CONSIGNE =
  "Tu es contradicteur pour LIPIKA, agence de presse pour agents. On te donne une affirmation " +
  "et la NATURE de ses sources — jamais la confiance que la redaction lui accorde, ni son statut. " +
  "C'est volontaire : la premiere version de ce dispositif montrait la confiance declaree, et les " +
  "relecteurs s'y ancraient — la regle baissait donc la confiance a chaque passage, sans point fixe. " +
  "Ta question est unique : au vu des seules sources declarees, quelle est la confiance MAXIMALE " +
  "qu'un lecteur devrait accorder a cette affirmation ? " +
  "verdict = \"documentee\" si les sources soutiennent une confiance elevee, \"fragile\" si elles " +
  "ne soutiennent qu'une confiance moyenne ou basse, \"inverifiable\" si aucune ne permet de trancher. " +
  "Reponds UNIQUEMENT par un objet JSON " +
  '{"verdict":"documentee|fragile|inverifiable","confiance_max":0.0,"motif":"une phrase"}.';

function cle() {
  if (process.env.OPENROUTER_API_KEY) return process.env.OPENROUTER_API_KEY;
  const chemin = process.env.OPENROUTER_ENV;
  if (chemin && existsSync(chemin)) {
    const m = readFileSync(chemin, "utf8").match(/OPENROUTER_API_KEY\s*=\s*"?([^"\r\n]+)/);
    if (m) return m[1];
  }
  throw new Error(
    "Aucune clé. Passer OPENROUTER_API_KEY, ou OPENROUTER_ENV=<chemin d'un .env qui la contient>."
  );
}

/** Cherche le premier objet JSON equilibre dans un texte qui en contient peut-etre. */
function extraire(texte) {
  const t = String(texte).replace(/```(?:json)?/gi, "");
  for (let i = t.indexOf("{"); i !== -1; i = t.indexOf("{", i + 1)) {
    let n = 0;
    for (let j = i; j < t.length; j++) {
      if (t[j] === "{") n += 1;
      else if (t[j] === "}") {
        n -= 1;
        if (n === 0) {
          try {
            return JSON.parse(t.slice(i, j + 1));
          } catch {
            break;
          }
        }
      }
    }
  }
  return null;
}

function valider(brut) {
  const o = extraire(brut);
  if (!o) return { erreur: "JSON illisible : " + String(brut).trim().slice(0, 90) };
  if (!VERDICTS.includes(o.verdict)) return { erreur: `verdict hors énumération : ${o.verdict}` };
  const c = Number(o.confiance_max);
  if (!(c >= 0 && c <= 1)) return { erreur: "confiance_max hors bornes" };
  if (typeof o.motif !== "string" || !o.motif.trim()) return { erreur: "motif absent" };
  return { verdict: o.verdict, confiance_max: +c.toFixed(2), motif: o.motif.trim().slice(0, 300) };
}

async function appeler(modele, message, k) {
  const r = await fetch("https://openrouter.ai/api/v1/chat/completions", {
    method: "POST",
    headers: { Authorization: "Bearer " + k, "content-type": "application/json" },
    body: JSON.stringify({
      model: modele,
      messages: [
        { role: "system", content: CONSIGNE },
        { role: "user", content: message },
      ],
      temperature: 0,
      // Les modeles a raisonnement consomment leur budget avant d'ecrire : a
      // 300 jetons, trois lignees sur cinq rendaient une sortie vide. Le
      // diagnostic « JSON illisible » ne disait pas ca — il disait « vide ».
      max_tokens: 1200,
      response_format: { type: "json_object" },
      reasoning: { effort: "low" },
      usage: { include: true },
    }),
  });
  if (!r.ok) throw new Error(`${r.status} ${(await r.text()).slice(0, 160)}`);
  const d = await r.json();
  return { texte: d.choices?.[0]?.message?.content ?? "", usage: d.usage ?? null };
}

async function relire(claim, lignee, k) {
  const message = JSON.stringify(
    {
      enonce: claim.enonce,
      type: claim.type,
      // Ni statut ni confiance : la relecture est aveugle, pour avoir un point fixe.
      centralite: claim.centralite,
      evenement_le: claim.evenement_le,
      sources: claim.sources.map((s) => ({
        emetteur: s.emetteur,
        niveau_de_verification: s.verification,
        marque_de_preuve: s.preuve,
        ouverte_par_la_redaction: s.preuve === "P",
      })),
      note_de_la_redaction: claim.note ?? null,
    },
    null,
    1
  );

  for (let essai = 0; essai < 3; essai++) {
    try {
      if (BUDGET !== null && depense >= BUDGET) return { erreur: "budget atteint, relecture non lancée" };
      const { texte, usage } = await appeler(lignee.modele, message, k);
      depense += cout(lignee.modele, usage);
      const v = valider(texte);
      if (!v.erreur) return { ...v, usage, essais: essai + 1 };
      if (essai === 2) return { erreur: v.erreur, usage, essais: 3 };
    } catch (e) {
      if (essai === 2) return { erreur: String(e.message).slice(0, 160), essais: 3 };
      await new Promise((r) => setTimeout(r, 1500 * (essai + 1)));
    }
  }
  return { erreur: "épuisé" };
}

async function enParallele(liste, n, f) {
  const sortie = [];
  let i = 0;
  await Promise.all(
    Array.from({ length: n }, async () => {
      while (i < liste.length) {
        const k = i++;
        sortie[k] = await f(liste[k]);
        process.stdout.write(".");
      }
    })
  );
  return sortie;
}

// ── Les données ──────────────────────────────────────────────────────────
const claims = JSON.parse(readFileSync(join(RACINE, "donnees", "claims.json"), "utf8")).claims;
const sources = new Map(
  JSON.parse(readFileSync(join(RACINE, "donnees", "sources.json"), "utf8")).sources.map((s) => [s.id, s])
);
const enrichis = claims.map((c) => ({ ...c, sources: c.sources.map((id) => sources.get(id)) }));

const taches = [];
for (const c of enrichis) for (const l of LIGNEES) taches.push({ c, l });

console.log(`${claims.length} affirmations × ${LIGNEES.length} lignées = ${taches.length} relectures.`);

let resultats;
if (SEC) {
  resultats = taches.map(({ c }) => ({
    verdict: "soutenable",
    confiance_max: c.confiance,
    motif: "mode --sec : aucune requête",
    usage: null,
    essais: 0,
  }));
} else {
  if (!(BUDGET > 0) && !ESTIMER) {
    console.error(
      "Refus de partir : ce script dépense de l'argent réel.\n" +
        "  node outils/lignees.mjs --budget <dollars>\n" +
        "  node outils/lignees.mjs --sec        pour tourner sans rien dépenser"
    );
    process.exit(1);
  }
  const k = cle();

  // Le solde, avant. Un plafond qu'on ne peut pas payer n'est pas un plafond.
  const solde = await fetch("https://openrouter.ai/api/v1/credits", {
    headers: { Authorization: "Bearer " + k },
  })
    .then((r) => r.json())
    .then((d) => {
      const c = d.data ?? d;
      return +(c.total_credits - c.total_usage).toFixed(4);
    })
    .catch(() => null);

  const tarifs = await fetch("https://openrouter.ai/api/v1/models", { headers: { Authorization: "Bearer " + k } })
    .then((r) => r.json())
    .then((d) => d.data)
    .catch(() => []);
  for (const l of LIGNEES) {
    const m = tarifs.find((x) => x.id === l.modele);
    if (m) TARIFS[l.modele] = { prompt: +m.pricing.prompt, completion: +m.pricing.completion };
  }

  const estime = LIGNEES.reduce((t, l) => {
    const p = TARIFS[l.modele];
    return p ? t + claims.length * (900 * p.prompt + 400 * p.completion) : t;
  }, 0);

  console.log(
    `${BUDGET ? "budget " + BUDGET.toFixed(2) + " $ · " : ""}estimation ${estime.toFixed(2)} $ · ` +
      `solde du compte ${solde === null ? "inconnu" : solde.toFixed(2) + " $"}`
  );
  for (const l of LIGNEES) {
    const t = TARIFS[l.modele];
    const c = t ? claims.length * (900 * t.prompt + 400 * t.completion) : null;
    console.log(`  ${l.famille.padEnd(14)} ${l.modele.padEnd(32)} ${c === null ? "tarif inconnu" : c.toFixed(3) + " $"}`);
  }
  if (ESTIMER) {
    console.log("\n--estimer : rien n'a été dépensé, rien n'a été écrit.");
    process.exit(0);
  }
  if (solde !== null && solde < estime) {
    console.error(
      `Refus de partir : le solde (${solde.toFixed(2)} $) est sous l'estimation (${estime.toFixed(2)} $). ` +
        "Recharger, ou réduire l'échantillon."
    );
    process.exit(1);
  }
  if (estime > BUDGET) {
    console.error(`Refus de partir : l'estimation (${estime.toFixed(2)} $) dépasse le budget annoncé.`);
    process.exit(1);
  }

  const debut = Date.now();
  resultats = await enParallele(taches, 6, ({ c, l }) => relire(c, l, k));
  process.stdout.write("\n");
  console.log(`${Math.round((Date.now() - debut) / 1000)} s`);
}

// ── Le tableau, et ce qu'on en tire ──────────────────────────────────────
const parClaim = new Map();
let echecs = 0;
let tokensEntree = 0;
let tokensSortie = 0;

taches.forEach(({ c, l }, i) => {
  const r = resultats[i];
  if (r.usage) {
    tokensEntree += r.usage.prompt_tokens ?? 0;
    tokensSortie += r.usage.completion_tokens ?? 0;
  }
  if (!parClaim.has(c.id)) parClaim.set(c.id, {});
  if (r.erreur) {
    echecs += 1;
    parClaim.get(c.id)[l.id] = { erreur: r.erreur };
  } else {
    parClaim.get(c.id)[l.id] = { verdict: r.verdict, confiance_max: r.confiance_max, motif: r.motif };
  }
});

/** Accord par paires : la proportion de couples de familles qui disent la même chose. */
function accordParPaires(verdicts) {
  const v = verdicts.filter(Boolean);
  if (v.length < 2) return null;
  let paires = 0;
  let daccord = 0;
  for (let a = 0; a < v.length; a++)
    for (let b = a + 1; b < v.length; b++) {
      paires += 1;
      if (v[a] === v[b]) daccord += 1;
    }
  return +(daccord / paires).toFixed(3);
}

const parAffirmation = [];
for (const c of claims) {
  const avis = parClaim.get(c.id) ?? {};
  const verdicts = LIGNEES.map((l) => avis[l.id]?.verdict).filter(Boolean);
  const confiances = LIGNEES.map((l) => avis[l.id]?.confiance_max).filter((x) => typeof x === "number");
  const distincts = [...new Set(verdicts)];
  parAffirmation.push({
    claim: c.id,
    statut_declare: c.statut,
    confiance_declaree: c.confiance,
    avis,
    verdicts_distincts: distincts.length,
    accord: accordParPaires(verdicts),
    confiance_max_mediane: confiances.length
      ? +confiances.sort((a, b) => a - b)[Math.floor(confiances.length / 2)].toFixed(2)
      : null,
    ecart_de_confiance: confiances.length ? +(Math.max(...confiances) - Math.min(...confiances)).toFixed(2) : null,
    plafond_sous_declare: LIGNEES.filter(
      (l) => typeof avis[l.id]?.confiance_max === "number" && avis[l.id].confiance_max < c.confiance - 1e-9
    ).map((l) => l.id),
  });
}

const accords = parAffirmation.map((a) => a.accord).filter((x) => x !== null);
const unanimes = parAffirmation.filter((a) => a.verdicts_distincts === 1).length;

const sortie = {
  _: "Relecture contradictoire des affirmations par cinq familles de modèles distinctes. L'écart entre familles est le produit attendu du dispositif, pas son défaut.",
  relu_le: new Date().toISOString(),
  mode: SEC ? "sec" : "reel",
  lignees: LIGNEES,
  panel: {
    conforme: !LIGNEES.some((l) => l.famille === FAMILLE_DE_LA_MAISON),
    famille_de_la_maison: FAMILLE_DE_LA_MAISON,
    motif: LIGNEES.some((l) => l.famille === FAMILLE_DE_LA_MAISON)
      ? "DÉROGATION NON MOTIVÉE — à écrire, ou à corriger en retirant la famille de la maison du panel."
      : null,
    regle: "règle 15 — le panel n'emploie pas la famille qui écrit le journal",
  },
  limite:
    "Les relecteurs ne disposent pas des documents sources, et on ne leur montre ni le statut ni la confiance déclarée. Ils proposent le plafond que la seule nature des sources leur paraît permettre. C'est une mesure de ce que les sources supportent, pas de la véracité du fait — et elle a un point fixe, ce que la première version du dispositif n'avait pas.",
  totaux: {
    affirmations: claims.length,
    lignees: LIGNEES.length,
    relectures: taches.length,
    echecs,
    unanimes,
    divergentes: claims.length - unanimes,
    indice_de_monoculture: accords.length ? +(accords.reduce((t, x) => t + x, 0) / accords.length).toFixed(3) : null,
    tokens_entree: tokensEntree,
    tokens_sortie: tokensSortie,
  },
  par_affirmation: parAffirmation,
};

writeFileSync(join(RACINE, "donnees", "relectures.json"), JSON.stringify(sortie, null, 2) + "\n");

if (!SEC) {
  mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
  appendFileSync(
    join(RACINE, "donnees", "mesures", "depenses.jsonl"),
    JSON.stringify({
      le: sortie.relu_le,
      operation: "relecture contradictoire",
      relectures: taches.length,
      tokens_entree: tokensEntree,
      tokens_sortie: tokensSortie,
      cout_dollars: +depense.toFixed(4),
      budget_dollars: BUDGET,
      lignees: LIGNEES.map((l) => l.modele),
    }) + "\n"
  );
}

console.log(
  `unanimes ${unanimes}/${claims.length} · divergentes ${claims.length - unanimes} · ` +
    `indice de monoculture ${sortie.totaux.indice_de_monoculture} · échecs ${echecs}`
);
console.log(`tokens : ${tokensEntree} entrée / ${tokensSortie} sortie`);
console.log("→ donnees/relectures.json");

/**
 * Ce qu'un serveur MCP public répond vraiment, à un client qui n'est pas nous.
 *
 * Le numéro zéro affirmait qu'un serveur MCP expose trente outils, et citait en
 * preuve deux fichiers d'un AUTRE dépôt. La garde de la règle 6 l'a refusé : une
 * marque [M] doit nommer un fichier que le lecteur de ce journal peut ouvrir.
 * Compter des lignes dans un code source qu'on héberge soi-même n'est pas une
 * mesure du service rendu — c'est une lecture de l'intention.
 *
 * Ce script interroge le serveur comme n'importe quel client : `initialize`,
 * puis `tools/list`, en JSON-RPC sur HTTP. Ce qu'il consigne est ce que le
 * réseau a renvoyé, pas ce que le dépôt contenait.
 *
 *   node outils/mcp-distant.mjs
 *
 * Sortie : donnees/mesures/mcp-distant.json
 */

import { writeFileSync, mkdirSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const DELAI = 15000;

const CIBLES = [
  { nom: "byss-emploi", url: "https://www.byss-emploi.com/api/mcp", entite: "e_byss_emploi" },
];

const VERSION_DEMANDEE = "2026-07-28";

async function rpc(url, methode, params, session) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), DELAI);
  try {
    const r = await fetch(url, {
      method: "POST",
      signal: ctrl.signal,
      headers: {
        "content-type": "application/json",
        accept: "application/json, text/event-stream",
        "user-agent": "LIPIKA-scanner/0.2 (desk protocoles)",
        ...(session ? { "mcp-session-id": session } : {}),
      },
      body: JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method: methode, params }),
    });
    const texte = await r.text();
    // Un serveur peut répondre en JSON ou en flux d'événements : on accepte les deux.
    const brut = texte.startsWith("event:") || texte.includes("\ndata: ")
      ? texte.split("\n").filter((l) => l.startsWith("data: ")).map((l) => l.slice(6)).join("")
      : texte;
    let corps = null;
    try {
      corps = JSON.parse(brut);
    } catch {}
    return { statut: r.status, session: r.headers.get("mcp-session-id"), corps, octets: texte.length };
  } catch (e) {
    return { erreur: e.name === "AbortError" ? "delai depasse" : e.message };
  } finally {
    clearTimeout(t);
  }
}

const resultats = [];
for (const cible of CIBLES) {
  const init = await rpc(cible.url, "initialize", {
    protocolVersion: VERSION_DEMANDEE,
    capabilities: {},
    clientInfo: { name: "LIPIKA-scanner", version: "0.2" },
  });
  const session = init.session ?? null;
  const liste = init.erreur ? null : await rpc(cible.url, "tools/list", {}, session);
  const outils = liste?.corps?.result?.tools ?? null;

  resultats.push({
    nom: cible.nom,
    url: cible.url,
    entite: cible.entite,
    joignable: !init.erreur,
    statut_initialize: init.statut ?? null,
    version_demandee: VERSION_DEMANDEE,
    version_negociee: init.corps?.result?.protocolVersion ?? null,
    serveur: init.corps?.result?.serverInfo ?? null,
    capacites: init.corps?.result?.capabilities ? Object.keys(init.corps.result.capabilities).sort() : null,
    // La poignée de main a-t-elle produit un identifiant de session ? La spec du
    // 28 juillet 2026 rend le protocole sans état et la retire : un serveur qui
    // en renvoie encore un parle l'ancienne.
    session_renvoyee: Boolean(session),
    statut_tools_list: liste?.statut ?? null,
    outils: outils ? outils.length : null,
    noms_des_outils: outils ? outils.map((o) => o.name).sort() : null,
    outils_sans_description: outils ? outils.filter((o) => !o.description).length : null,
    note: init.erreur ?? liste?.erreur ?? null,
  });
  process.stdout.write(".");
}
process.stdout.write("\n");

const mesure = {
  _: "Mesure produite par outils/mcp-distant.mjs. Le serveur a été interrogé depuis le réseau, comme un client quelconque.",
  mesure_le: new Date().toISOString(),
  methode: {
    transport: "JSON-RPC 2.0 sur POST, accept: application/json, text/event-stream",
    appels: ["initialize", "tools/list"],
    version_demandee: VERSION_DEMANDEE,
    delai_ms: DELAI,
    limite:
      "Un serveur peut exposer davantage d'outils à un client authentifié. Ce qui est compté ici est ce qu'un client anonyme obtient — ce qui est la seule chose qu'un lecteur puisse vérifier sans nos identifiants.",
  },
  totaux: {
    cibles: resultats.length,
    joignables: resultats.filter((r) => r.joignable).length,
    outils_total: resultats.reduce((t, r) => t + (r.outils ?? 0), 0),
  },
  resultats,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "mcp-distant.json"), JSON.stringify(mesure, null, 2) + "\n");

for (const r of resultats)
  console.log(
    `${r.nom} · ${r.joignable ? "joignable" : "injoignable"} · version négociée ${r.version_negociee} · ` +
      `${r.outils} outils · session ${r.session_renvoyee ? "renvoyée" : "aucune"}`
  );
console.log("empreinte :", createHash("sha256").update(JSON.stringify(resultats)).digest("hex").slice(0, 16));
console.log("→ donnees/mesures/mcp-distant.json");

/**
 * Le miroir : LIPIKA/site recopié dans un dépôt à lui, pour être déployé.
 *
 * Le dépôt BYSS GROUP est local et le reste. Ce script ne lui ajoute aucun
 * distant : il recopie l'arbre du site dans un dépôt voisin, autonome, qui ne
 * contient que le journal — code, données, outils — et rien d'autre de la
 * maison. C'est ce dépôt-là que Vercel construit.
 *
 * Il recopie aussi ce que le site promet : « méthode, échantillon et code
 * publics, la mesure est rejouable par un tiers ». Tant que le code n'est nulle
 * part, cette phrase est une affirmation sans source. Le miroir la rend vraie.
 *
 *   node outils/miroir.mjs [chemin-du-miroir]
 *
 * Ce qui n'est JAMAIS recopié : .cles/ (la clé privée ed25519), node_modules,
 * les sorties de construction, et la publication statique.
 */

import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
import { execFileSync } from "node:child_process";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const CIBLE = process.argv[2] ?? join(RACINE, "..", "..", "..", "lipika-miroir");

/** Tout ce qui ne traverse pas. La clé privée est en tête, et ce n'est pas un hasard. */
const JAMAIS = new Set([
  ".cles",
  "node_modules",
  ".next",
  "out",
  "publication",
  ".git",
  "tsconfig.tsbuildinfo",
  "next-env.d.ts",
]);

if (existsSync(join(RACINE, ".cles", "lipika-ed25519.priv.pem")) === false)
  console.warn("Note : aucune clé privée locale — les signatures publiées restent valides, elles sont pré-calculées.");

mkdirSync(CIBLE, { recursive: true });

/**
 * Le miroir ne descend pas sur un dépôt qui a avancé sans lui.
 *
 * Depuis que le passage quotidien tourne dans le dépôt distant, celui-ci
 * n'est plus un simple reflet : il peut contenir des brèves, des archives de
 * mesures et des points de série que le poste local n'a jamais vus. Or ce
 * programme vide sa cible avant de recopier. Sans cette garde, un miroir lancé
 * le lendemain effacerait la nuit — silencieusement, ce qui est pire.
 *
 * On interroge donc le distant avant de toucher à quoi que ce soit. S'il est
 * en avance, on refuse et on dit quoi faire. Le drapeau --forcer existe pour
 * le cas où l'opérateur a décidé d'écraser en connaissance de cause ; il ne
 * s'emploie pas pour se débarrasser d'un message.
 */
if (existsSync(join(CIBLE, ".git")) && !process.argv.includes("--forcer")) {
  try {
    execFileSync("git", ["-C", CIBLE, "fetch", "--quiet"], { stdio: "ignore", timeout: 120000 });
    const branche = execFileSync("git", ["-C", CIBLE, "rev-parse", "--abbrev-ref", "HEAD"], {
      encoding: "utf8",
    }).trim();
    const avance = execFileSync(
      "git",
      ["-C", CIBLE, "rev-list", "--count", `HEAD..origin/${branche}`],
      { encoding: "utf8" }
    ).trim();
    if (+avance > 0) {
      const qui = execFileSync(
        "git",
        ["-C", CIBLE, "log", "-1", "--format=%an — %s", `origin/${branche}`],
        { encoding: "utf8" }
      ).trim();
      console.error(
        `MIROIR REFUSÉ — le dépôt distant a ${avance} commit(s) que ce poste n'a pas.
` +
          `  Le plus récent : ${qui}
` +
          `  Recopier maintenant les effacerait. Récupérer d'abord :
` +
          `    git -C "${CIBLE}" pull --rebase
` +
          `  puis reporter ce qui a été publié dans le dépôt de la rédaction.
` +
          `  (--forcer écrase délibérément, et ce n'est presque jamais ce qu'il faut.)`
      );
      process.exit(1);
    }
  } catch (e) {
    if (e.status === 1 && String(e.message).includes("MIROIR REFUSÉ")) throw e;
    console.warn(`Note : impossible d'interroger le distant (${String(e.message).split(/\r?\n/)[0]}).`);
    console.warn("Le miroir continue, mais rien ne garantit que le distant n'a pas avancé.");
  }
}

// On vide la cible sauf son .git : le miroir est un reflet, pas un cumul.
for (const e of readdirSync(CIBLE)) {
  if (e === ".git") continue;
  rmSync(join(CIBLE, e), { recursive: true, force: true });
}

let copies = 0;
for (const e of readdirSync(RACINE)) {
  if (JAMAIS.has(e)) continue;
  const src = join(RACINE, e);
  cpSync(src, join(CIBLE, e), { recursive: true });
  copies += statSync(src).isDirectory() ? readdirSync(src, { recursive: true }).length : 1;
}

// Le .gitignore du miroir, plus strict que celui du dépôt d'origine : ici, une
// clé privée recopiée par erreur serait publiée.
writeFileSync(
  join(CIBLE, ".gitignore"),
  [
    "node_modules/",
    ".next/",
    "out/",
    "publication/",
    ".cles/",
    "*.pem",
    "*.key",
    ".env",
    ".env.*",
    "*.tsbuildinfo",
    "next-env.d.ts",
    "",
  ].join("\n")
);

// Une dernière vérification, parce qu'un oubli ici ne se rattrape pas : on ne
// publie pas une clé privée, et on ne s'en remet pas à une liste d'exclusion.
const suspects = [];
(function chercher(d) {
  for (const e of readdirSync(d, { withFileTypes: true })) {
    if (e.name === ".git" || e.name === "node_modules") continue;
    const p = join(d, e.name);
    if (e.isDirectory()) chercher(p);
    else if (/\.(pem|key|p12|pfx)$/i.test(e.name) || /^\.env/.test(e.name)) suspects.push(p);
  }
})(CIBLE);

if (suspects.length) {
  console.error("MIROIR REFUSÉ — des fichiers de clé ou d'environnement ont traversé :");
  for (const s of suspects) console.error("  " + s);
  process.exit(1);
}

console.log(`Miroir écrit dans ${CIBLE} — ${copies} entrées, aucune clé ni variable d'environnement.`);
console.log("Suite : git -C <miroir> add -A && git -C <miroir> commit && git -C <miroir> push");

/**
 * Qui télécharge quoi : la couche d'exécution agentique, comptée.
 *
 * Le numéro zéro affirme, d'après la spécification elle-même, que « les SDK de
 * premier rang approchent le demi-milliard de téléchargements mensuels ». C'est
 * une source primaire — mais c'est l'organisme qui publie le protocole qui
 * publie le chiffre de son propre succès. Personne ne l'a recompté.
 *
 * Les deux registres qui hébergent ces paquets exposent leurs compteurs
 * publiquement et gratuitement. Ce script les interroge, paquet par paquet, et
 * additionne ce qu'un lecteur peut vérifier lui-même en une commande.
 *
 * Ce que la mesure ne dit PAS, et c'est écrit dans le fichier : un
 * téléchargement n'est pas un utilisateur. Les chaînes d'intégration continue,
 * les miroirs et les images de conteneurs retéléchargent le même paquet des
 * milliers de fois par jour. Ce qui est mesuré est un TRAFIC D'INSTALLATION,
 * et sa seule vertu est d'être comparable d'un paquet à l'autre le même jour.
 *
 *   node outils/paquets.mjs
 *
 * Sortie : donnees/mesures/paquets.json
 */

import { writeFileSync, mkdirSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const DELAI = 15000;
// pypistats demande explicitement de l'étiquette. On la respecte : une mesure
// obtenue en saturant un service gratuit n'est pas une mesure honnête.
const PAUSE_PYPI = 6000;
// Une limite de débit n'est pas un échec de mesure : c'est une demande d'attendre.
// Trois reprises, de plus en plus patientes, avant de consigner une absence.
const REPRISES = 3;

/**
 * Le panier. Chaque entrée déclare son rôle et l'organisation qui la publie —
 * c'est un jugement éditorial, il est donc en clair et discutable, pas caché
 * dans une agrégation.
 */
const PAQUETS = [
  // Le protocole agent ↔ outil
  { nom: "@modelcontextprotocol/sdk", registre: "npm", role: "sdk-mcp", entite: "e_mcp" },
  { nom: "mcp", registre: "pypi", role: "sdk-mcp", entite: "e_mcp" },
  // Le protocole agent ↔ agent
  { nom: "@a2a-js/sdk", registre: "npm", role: "sdk-a2a", entite: "e_a2a" },
  { nom: "a2a-sdk", registre: "pypi", role: "sdk-a2a", entite: "e_a2a" },
  // Les clients de modèles : ce sur quoi les agents parlent aux modèles
  { nom: "openai", registre: "npm", role: "client-de-modele", entite: "e_openai" },
  { nom: "openai", registre: "pypi", role: "client-de-modele", entite: "e_openai" },
  { nom: "@anthropic-ai/sdk", registre: "npm", role: "client-de-modele", entite: "e_anthropic" },
  { nom: "anthropic", registre: "pypi", role: "client-de-modele", entite: "e_anthropic" },
  // Les cadres d'orchestration
  { nom: "langchain", registre: "npm", role: "cadre", entite: "e_langchain" },
  { nom: "langchain", registre: "pypi", role: "cadre", entite: "e_langchain" },
  { nom: "@langchain/core", registre: "npm", role: "cadre", entite: "e_langchain" },
  { nom: "langchain-core", registre: "pypi", role: "cadre", entite: "e_langchain" },
  { nom: "llamaindex", registre: "npm", role: "cadre", entite: "e_llamaindex" },
  { nom: "llama-index", registre: "pypi", role: "cadre", entite: "e_llamaindex" },
  { nom: "crewai", registre: "pypi", role: "cadre", entite: "e_crewai" },
  { nom: "google-adk", registre: "pypi", role: "cadre", entite: "e_google" },
  { nom: "ai", registre: "npm", role: "cadre", entite: "e_vercel" },
];

async function tirer(url) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), DELAI);
  try {
    const r = await fetch(url, {
      signal: ctrl.signal,
      headers: { accept: "application/json", "user-agent": "LIPIKA-scanner/0.2 (desk protocoles)" },
    });
    const texte = await r.text();
    let corps = null;
    try {
      corps = JSON.parse(texte);
    } catch {}
    return { statut: r.status, corps, texte };
  } catch (e) {
    return { erreur: e.name === "AbortError" ? "delai depasse" : e.message };
  } finally {
    clearTimeout(t);
  }
}

const dormir = (ms) => new Promise((r) => setTimeout(r, ms));

async function mesurerNpm(p) {
  const enc = encodeURIComponent(p.nom);
  const d = await tirer(`https://api.npmjs.org/downloads/point/last-month/${enc}`);
  const meta = await tirer(`https://registry.npmjs.org/${enc}/latest`);
  if (d.erreur || d.statut !== 200 || typeof d.corps?.downloads !== "number")
    return { telechargements: null, note: d.erreur ?? `réponse ${d.statut}` };
  return {
    telechargements: d.corps.downloads,
    fenetre: { du: d.corps.start, au: d.corps.end },
    version: meta.corps?.version ?? null,
    publie_le: null,
    note: null,
  };
}

async function mesurerPypi(p) {
  let d = null;
  for (let essai = 0; essai < REPRISES; essai += 1) {
    await dormir(PAUSE_PYPI * (essai + 1));
    d = await tirer(`https://pypistats.org/api/packages/${encodeURIComponent(p.nom)}/recent`);
    if (!d.erreur && d.statut === 200 && typeof d.corps?.data?.last_month === "number") break;
    if (d.statut !== 429) break;
  }
  if (d.erreur || d.statut !== 200 || typeof d.corps?.data?.last_month !== "number")
    return {
      telechargements: null,
      note:
        d.erreur ??
        (d.statut === 429
          ? `limite de débit du service, après ${REPRISES} reprises`
          : `réponse ${d.statut}`),
    };
  const meta = await tirer(`https://pypi.org/pypi/${encodeURIComponent(p.nom)}/json`);
  return {
    telechargements: d.corps.data.last_month,
    fenetre: { du: null, au: null, duree: "30 derniers jours" },
    version: meta.corps?.info?.version ?? null,
    publie_le: null,
    note: null,
  };
}

console.log(`Paquets : ${PAQUETS.length} entrées sur deux registres.`);
const debut = new Date();
const resultats = [];
for (const p of PAQUETS) {
  const m = p.registre === "npm" ? await mesurerNpm(p) : await mesurerPypi(p);
  resultats.push({ ...p, ...m });
  process.stdout.write(m.telechargements === null ? "!" : ".");
}
process.stdout.write("\n");

const somme = (f) => resultats.filter(f).reduce((t, r) => t + (r.telechargements ?? 0), 0);
const parRole = Object.fromEntries(
  [...new Set(resultats.map((r) => r.role))].sort().map((role) => [
    role,
    {
      paquets: resultats.filter((r) => r.role === role).length,
      telechargements: somme((r) => r.role === role),
    },
  ])
);
const parEntite = Object.fromEntries(
  [...new Set(resultats.map((r) => r.entite))].sort().map((e) => [e, somme((r) => r.entite === e)])
);

const total = somme(() => true);
const classement = Object.entries(parEntite).sort((a, b) => b[1] - a[1]);
const mcp = parRole["sdk-mcp"]?.telechargements ?? 0;
const a2a = parRole["sdk-a2a"]?.telechargements ?? 0;

const mesure = {
  _: "Mesure produite par outils/paquets.mjs. Compteurs publics des deux registres, interrogés le même jour.",
  mesure_le: debut.toISOString(),
  duree_ms: Date.now() - debut.getTime(),
  methode: {
    registres: {
      npm: "api.npmjs.org/downloads/point/last-month — fenêtre glissante de 30 jours, bornes renvoyées par le service",
      pypi: "pypistats.org/api/packages/<nom>/recent — champ last_month, 30 derniers jours",
    },
    panier:
      "les SDK des deux protocoles agentiques, les clients de modèles des deux laboratoires les plus téléchargés, et les cadres d'orchestration les plus cités. Le rattachement d'un paquet à une organisation est un jugement éditorial : il est en clair dans le fichier.",
    etiquette: `pause de ${PAUSE_PYPI} ms entre deux appels à pypistats, portée à ${PAUSE_PYPI * REPRISES} ms en cas de limite de débit, et jusqu’à ${REPRISES} reprises. Le service le demande explicitement ; une mesure obtenue en le saturant ne serait pas honnête.`,
    limite:
      "UN TÉLÉCHARGEMENT N'EST PAS UN UTILISATEUR. Les chaînes d'intégration continue, les miroirs et les images de conteneurs retéléchargent le même paquet des milliers de fois par jour, et aucun des deux registres ne publie de dédoublonnage. Ce qui est mesuré est un trafic d'installation. Sa seule vertu — et elle suffit pour ce que le journal en fait — est d'être comparable d'un paquet à l'autre le même jour, sur la même fenêtre, avec le même biais.",
    seconde_limite:
      "Le panier ne couvre que deux registres. Les écosystèmes Go, Rust, Java et .NET sont absents, et ils ne sont pas vides.",
  },
  totaux: {
    paquets: resultats.length,
    mesures: resultats.filter((r) => r.telechargements !== null).length,
    echecs: resultats.filter((r) => r.telechargements === null).length,
    telechargements_du_panier: total,
    sdk_mcp: mcp,
    sdk_a2a: a2a,
    rapport_mcp_sur_a2a: a2a ? +(mcp / a2a).toFixed(1) : null,
    part_des_deux_premieres_organisations: total
      ? +(((classement[0]?.[1] ?? 0) + (classement[1]?.[1] ?? 0)) / total).toFixed(4)
      : null,
  },
  par_role: parRole,
  par_entite: Object.fromEntries(
    classement.map(([e, n]) => [e, { telechargements: n, part: total ? +(n / total).toFixed(4) : null }])
  ),
  resultats,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "paquets.json"), JSON.stringify(mesure, null, 2) + "\n");

console.log(
  `panier ${total.toLocaleString("fr-FR")} · MCP ${mcp.toLocaleString("fr-FR")} · A2A ${a2a.toLocaleString("fr-FR")} · ` +
    `rapport ${mesure.totaux.rapport_mcp_sur_a2a}×`
);
for (const [e, n] of classement) console.log(`  ${e.padEnd(16)} ${String(n).padStart(12)}  ${((n / total) * 100).toFixed(1)} %`);
console.log("empreinte :", createHash("sha256").update(JSON.stringify(resultats)).digest("hex").slice(0, 16));
console.log("→ donnees/mesures/paquets.json");

/**
 * Le web laisse-t-il entrer les agents ? La question se pose à l'endroit exact
 * où elle se répond : robots.txt, et llms.txt.
 *
 * On écrit des protocoles pour que des agents se parlent, et on mesure leur
 * adoption. Personne ne mesure la chose d'avant : est-ce que les sites que ces
 * agents devraient lire les autorisent à lire. C'est écrit, c'est public, c'est
 * à la racine de chaque domaine, et ça ne se compte nulle part.
 *
 * Deux fichiers, deux fonctions opposées :
 *   — robots.txt dit ce qu'un robot n'a PAS le droit de lire ;
 *   — llms.txt dit à un modèle ce qu'il DOIT lire pour bien citer.
 * Le premier est une clôture, le second une invitation. Les compter ensemble
 * sur le même échantillon donne la position d'un domaine vis-à-vis des agents,
 * et pas seulement son discours.
 *
 *   node outils/portes.mjs
 *
 * Sortie : donnees/mesures/portes.json
 */

import { writeFileSync, mkdirSync, readFileSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const DELAI = 12000;

/**
 * Les collecteurs. Chacun est le robot déclaré d'un opérateur de modèle ou
 * d'un moteur de réponse ; la liste est publique chez chacun d'eux, et elle
 * est ici pour être corrigée.
 */
const COLLECTEURS = [
  { nom: "GPTBot", operateur: "OpenAI", usage: "entraînement" },
  { nom: "OAI-SearchBot", operateur: "OpenAI", usage: "recherche" },
  { nom: "ChatGPT-User", operateur: "OpenAI", usage: "lecture à la demande d'un utilisateur" },
  { nom: "ClaudeBot", operateur: "Anthropic", usage: "entraînement" },
  { nom: "Claude-User", operateur: "Anthropic", usage: "lecture à la demande d'un utilisateur" },
  { nom: "Claude-SearchBot", operateur: "Anthropic", usage: "recherche" },
  { nom: "Google-Extended", operateur: "Google", usage: "entraînement" },
  { nom: "PerplexityBot", operateur: "Perplexity", usage: "recherche" },
  { nom: "CCBot", operateur: "Common Crawl", usage: "corpus ouvert" },
  { nom: "Bytespider", operateur: "ByteDance", usage: "entraînement" },
  { nom: "Applebot-Extended", operateur: "Apple", usage: "entraînement" },
  { nom: "meta-externalagent", operateur: "Meta", usage: "entraînement" },
  { nom: "Amazonbot", operateur: "Amazon", usage: "entraînement" },
  { nom: "cohere-ai", operateur: "Cohere", usage: "entraînement" },
];

async function tirer(url) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), DELAI);
  try {
    const r = await fetch(url, {
      signal: ctrl.signal,
      redirect: "follow",
      headers: { accept: "text/plain,*/*", "user-agent": "LIPIKA-scanner/0.2 (desk protocoles)" },
    });
    const texte = await r.text();
    return { statut: r.status, type: (r.headers.get("content-type") || "").split(";")[0], texte };
  } catch (e) {
    return { erreur: e.name === "AbortError" ? "delai depasse" : e.message };
  } finally {
    clearTimeout(t);
  }
}

/**
 * Un analyseur de robots.txt volontairement simple, et dont la simplicité est
 * publiée : on regroupe les lignes `User-agent` consécutives, on leur attache
 * les `Disallow` et `Allow` qui suivent, et on retient pour un collecteur le
 * groupe qui le nomme, sinon le groupe `*`. C'est la règle du standard pour
 * l'essentiel ; les cas tordus — jokers, `$`, préséance par longueur — ne sont
 * pas traités, et aucune conclusion de ce journal n'en dépend.
 */
function analyserRobots(texte) {
  const groupes = [];
  let courant = null;
  for (const brute of texte.split(/\r?\n/)) {
    const ligne = brute.replace(/#.*$/, "").trim();
    if (!ligne) continue;
    const i = ligne.indexOf(":");
    if (i === -1) continue;
    const champ = ligne.slice(0, i).trim().toLowerCase();
    const valeur = ligne.slice(i + 1).trim();
    if (champ === "user-agent") {
      if (!courant || courant.regles.length) {
        courant = { agents: [], regles: [] };
        groupes.push(courant);
      }
      courant.agents.push(valeur.toLowerCase());
    } else if ((champ === "disallow" || champ === "allow") && courant) {
      courant.regles.push({ type: champ, chemin: valeur });
    }
  }
  return groupes;
}

/** Ce qu'un collecteur a le droit de faire, d'après ce fichier. */
function verdictPour(groupes, nom) {
  const cible = nom.toLowerCase();
  const propre = groupes.find((g) => g.agents.includes(cible));
  const etoile = groupes.find((g) => g.agents.includes("*"));
  const g = propre ?? etoile;
  if (!g) return { verdict: "autorise", par: "aucune règle", nomme: Boolean(propre) };
  const bloqueTout = g.regles.some((r) => r.type === "disallow" && r.chemin === "/");
  const autoriseQuelqueChose = g.regles.some((r) => r.type === "allow" && r.chemin && r.chemin !== "");
  if (bloqueTout && !autoriseQuelqueChose)
    return { verdict: "interdit", par: propre ? "règle nominative" : "règle générale *", nomme: Boolean(propre) };
  if (bloqueTout)
    return { verdict: "partiel", par: propre ? "règle nominative" : "règle générale *", nomme: Boolean(propre) };
  const bloqueQuelque = g.regles.some((r) => r.type === "disallow" && r.chemin && r.chemin !== "");
  return {
    verdict: bloqueQuelque ? "partiel" : "autorise",
    par: propre ? "règle nominative" : "règle générale *",
    nomme: Boolean(propre),
  };
}

async function examiner(cible) {
  const robots = await tirer("https://" + cible.domaine + "/robots.txt");
  const llms = await tirer("https://" + cible.domaine + "/llms.txt");

  const aRobots = !robots.erreur && robots.statut === 200 && /user-agent/i.test(robots.texte);
  const groupes = aRobots ? analyserRobots(robots.texte) : [];
  const verdicts = Object.fromEntries(
    COLLECTEURS.map((c) => [c.nom, aRobots ? verdictPour(groupes, c.nom) : { verdict: "sans_robots", par: null, nomme: false }])
  );
  const interdits = COLLECTEURS.filter((c) => verdicts[c.nom].verdict === "interdit");
  const nommes = COLLECTEURS.filter((c) => verdicts[c.nom].nomme);

  // llms.txt : le piège est de compter comme un llms.txt tout ce qui répond 200.
  // Un serveur qui renvoie sa page d'accueil, une balise vide ou un corps blanc
  // gonflerait le chiffre exactement dans le sens qui nous arrange. La règle est
  // donc positive — il faut RESSEMBLER à un llms.txt — et son motif est consigné
  // pour chaque domaine, accepté comme refusé.
  const brut = llms.erreur ? "" : llms.texte;
  const debut = brut.slice(0, 4000);
  const motifLlms = (() => {
    if (llms.erreur) return "injoignable : " + llms.erreur;
    if (llms.statut !== 200) return `réponse ${llms.statut}`;
    if (brut.trim().length < 32) return "corps vide ou trop court";
    if (/<(?:!doctype|html|head|body|script|div)[\s>]/i.test(debut)) return "du HTML, pas un llms.txt";
    if (llms.type && !llms.type.startsWith("text/")) return `type ${llms.type}`;
    const premiere = (brut.split("\n").find((l) => l.trim().length) ?? "").trim();
    const titre = premiere.startsWith("#");
    const structure = /^[ \t]*[-*][ \t]|\]\(|^>[ \t]/m.test(brut);
    if (!titre && !structure) return "ni titre Markdown ni structure de liste";
    return null;
  })();
  const aLlms = motifLlms === null;

  return {
    domaine: cible.domaine,
    categorie: cible.categorie,
    robots: {
      present: aRobots,
      statut: robots.statut ?? null,
      octets: robots.erreur ? null : robots.texte.length,
      groupes: groupes.length,
      note: robots.erreur ?? null,
    },
    collecteurs: {
      interdits: interdits.map((c) => c.nom),
      nombre_interdits: interdits.length,
      nommes: nommes.map((c) => c.nom),
      nombre_nommes: nommes.length,
      tous_interdits: aRobots && interdits.length === COLLECTEURS.length,
      verdicts,
    },
    llms: {
      present: aLlms,
      statut: llms.statut ?? null,
      type: llms.type ?? null,
      octets: llms.erreur ? null : llms.texte.length,
      note: motifLlms,
    },
  };
}

async function enParallele(liste, n, f) {
  const sortie = [];
  let i = 0;
  await Promise.all(
    Array.from({ length: n }, async () => {
      while (i < liste.length) {
        const k = i++;
        sortie[k] = await f(liste[k]);
        process.stdout.write(".");
      }
    })
  );
  return sortie;
}

const cibles = JSON.parse(
  readFileSync(join(RACINE, "donnees", "mesures", "echantillon-cartes.json"), "utf8")
).cibles;

console.log(`Portes : ${cibles.length} domaines, robots.txt et llms.txt chacun.`);
const debut = new Date();
const resultats = await enParallele(cibles, 6, examiner);
process.stdout.write("\n");

const avecRobots = resultats.filter((r) => r.robots.present);
const parCollecteur = Object.fromEntries(
  COLLECTEURS.map((c) => [
    c.nom,
    {
      operateur: c.operateur,
      usage: c.usage,
      interdit: resultats.filter((r) => r.collecteurs.verdicts[c.nom].verdict === "interdit").length,
      nomme: resultats.filter((r) => r.collecteurs.verdicts[c.nom].nomme).length,
    },
  ])
);
const parCategorie = Object.fromEntries(
  [...new Set(resultats.map((r) => r.categorie))].sort().map((cat) => {
    const dans = resultats.filter((r) => r.categorie === cat);
    return [
      cat,
      {
        domaines: dans.length,
        avec_robots: dans.filter((r) => r.robots.present).length,
        interdisent_au_moins_un: dans.filter((r) => r.collecteurs.nombre_interdits > 0).length,
        interdisent_tous: dans.filter((r) => r.collecteurs.tous_interdits).length,
        avec_llms: dans.filter((r) => r.llms.present).length,
      },
    ];
  })
);

const mesure = {
  _: "Mesure produite par outils/portes.mjs. Deux fichiers publics à la racine de chaque domaine, lus le même jour.",
  mesure_le: debut.toISOString(),
  duree_ms: Date.now() - debut.getTime(),
  methode: {
    echantillon: "le même que le scan de cartes d'agent — donnees/mesures/echantillon-cartes.json",
    collecteurs: COLLECTEURS,
    analyse_robots:
      "regroupement des lignes User-agent consécutives, puis des Disallow/Allow qui suivent. Pour un collecteur, le groupe qui le nomme l'emporte sur le groupe « * ». « Interdit » signifie : Disallow: / sans aucune règle Allow dans le même groupe.",
    limite_analyse:
      "L'analyseur ne traite ni les jokers, ni le caractère $, ni la préséance par longueur de chemin. Ce sont des raffinements du standard, et aucune conclusion publiée ici n'en dépend : nous comptons des interdictions totales et des mentions nominatives, pas des arbitrages de chemin.",
    llms_present:
      "réponse 200, type text/*, au moins 32 octets, aucune balise HTML dans les quatre premiers kilo-octets, et une forme de llms.txt : un titre Markdown en première ligne, ou une liste, ou un lien Markdown. Le motif de refus est consigné pour chaque domaine écarté — une première version de ce test comptait 84 fichiers, dont plusieurs pages d'accueil servies en 200.",
    limite:
      "robots.txt est une convention, pas une barrière : il déclare une politique, il ne l'applique pas. Ce qui est mesuré ici est ce qu'un domaine DIT autoriser, ce qui est précisément la question — un collecteur qui l'ignore est un autre sujet, et nous ne l'avons pas mesuré.",
  },
  totaux: {
    domaines: resultats.length,
    avec_robots: avecRobots.length,
    sans_robots: resultats.length - avecRobots.length,
    interdisent_au_moins_un_collecteur: resultats.filter((r) => r.collecteurs.nombre_interdits > 0).length,
    interdisent_tous_les_collecteurs: resultats.filter((r) => r.collecteurs.tous_interdits).length,
    nomment_au_moins_un_collecteur: resultats.filter((r) => r.collecteurs.nombre_nommes > 0).length,
    avec_llms: resultats.filter((r) => r.llms.present).length,
    part_avec_llms: +(resultats.filter((r) => r.llms.present).length / resultats.length).toFixed(4),
  },
  par_collecteur: parCollecteur,
  par_categorie: parCategorie,
  resultats,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "portes.json"), JSON.stringify(mesure, null, 2) + "\n");

const t = mesure.totaux;
console.log(
  `${t.domaines} domaines · ${t.avec_robots} avec robots.txt · ` +
    `${t.interdisent_au_moins_un_collecteur} interdisent au moins un collecteur · ` +
    `${t.interdisent_tous_les_collecteurs} les interdisent tous · ${t.avec_llms} servent un llms.txt`
);
for (const [nom, v] of Object.entries(parCollecteur))
  console.log(`  ${nom.padEnd(20)} interdit par ${String(v.interdit).padStart(3)} · nommé par ${String(v.nomme).padStart(3)}`);
console.log("empreinte :", createHash("sha256").update(JSON.stringify(resultats)).digest("hex").slice(0, 16));
console.log("→ donnees/mesures/portes.json");

/**
 * L'état de la chaîne de preuves du journal.
 *
 * Ce journal répète une phrase à chaque mesure : « la méthode, l'échantillon et
 * le code sont publics, c'est rejouable par un tiers ». La phrase a longtemps
 * été vraie au moment où elle était écrite, et fausse le lendemain — parce que
 * chaque instrument réécrivait son fichier, et qu'une affirmation publiée la
 * veille finissait par désigner une preuve qui disait autre chose.
 *
 * Cet instrument mesure cela, chez nous, comme les autres instruments mesurent
 * le web. Il compte les affirmations selon ce qui les soutient, et il distingue
 * trois états :
 *
 *   FIGÉE      la source cite un instantané daté, servi par le journal, dont
 *              l'empreinte est revérifiée à chaque construction. Un lecteur
 *              télécharge exactement les octets sur lesquels on a écrit.
 *
 *   VIVANTE    la source cite un fichier que le prochain passage réécrira.
 *              La règle 25 refuse désormais la publication dans cet état ;
 *              le compteur reste, parce qu'une garde sans chiffre ne se
 *              surveille pas.
 *
 *   EXTERNE    la preuve est une page ouverte ailleurs. Elle peut disparaître,
 *              et nous n'y pouvons rien — sinon le dire. C'est ce que fait
 *              outils/citations.mjs, qui les visite une à une.
 *
 *   node outils/preuves.mjs
 *
 * Sortie : donnees/mesures/preuves.json
 */

import { readFileSync, writeFileSync, readdirSync, existsSync, mkdirSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const lire = (n) => JSON.parse(readFileSync(join(RACINE, "donnees", n), "utf8"));

const FIGE = "donnees/mesures/archives/";
const VIVANT = "donnees/mesures/";

const sources = lire("sources.json").sources;
const claims = lire("claims.json").claims;
const stories = lire("stories.json").stories;

const parId = new Map(sources.map((s) => [s.id, s]));

/** Où mène une source : une archive figée, une mesure vivante, un état, une page. */
function etat(s) {
  if (s.preuve !== "M") return s.url ? "externe" : "sans_adresse";
  const chemin = String(s.fichier ?? "").split(" — ")[0].trim().replace(/^LIPIKA\/site\//, "");
  if (!chemin) return "sans_fichier";
  if (chemin.startsWith(FIGE)) return "figee";
  if (chemin.startsWith(VIVANT)) return "vivante";
  return "etat_du_journal";
}

const etats = {};
for (const s of sources) {
  const e = etat(s);
  etats[e] = (etats[e] ?? 0) + 1;
}

// Une affirmation vaut ce que vaut sa meilleure preuve : si une seule de ses
// sources est une archive figée, un lecteur peut vérifier quelque chose.
const RANG = { figee: 4, etat_du_journal: 3, externe: 2, vivante: 1, sans_fichier: 0, sans_adresse: 0 };
const parAffirmation = {};
const fragiles = [];
for (const c of claims) {
  const liste = (c.sources || []).map((id) => parId.get(id)).filter(Boolean);
  if (!liste.length) {
    parAffirmation.sans_source = (parAffirmation.sans_source ?? 0) + 1;
    continue;
  }
  const meilleur = liste.map(etat).sort((a, b) => RANG[b] - RANG[a])[0];
  parAffirmation[meilleur] = (parAffirmation[meilleur] ?? 0) + 1;
  if (meilleur === "vivante") fragiles.push(c.id);
}

// Les archives présentes, et celles que plus personne ne cite.
const dossier = join(RACINE, "donnees", "mesures", "archives");
const fichiers = existsSync(dossier) ? readdirSync(dossier).filter((f) => f.endsWith(".json")).sort() : [];
const citees = new Set(
  sources
    .filter((s) => s.preuve === "M" && String(s.fichier ?? "").includes(FIGE))
    .map((s) => String(s.fichier).split(" — ")[0].trim().slice(FIGE.length))
);

const archives = fichiers.map((nom) => {
  const octets = readFileSync(join(dossier, nom), "utf8");
  let mesureLe = null;
  try {
    const o = JSON.parse(octets);
    mesureLe = o.mesure_le ?? o.releve_le ?? null;
  } catch {}
  return {
    nom,
    mesure_le: mesureLe,
    octets: Buffer.byteLength(octets, "utf8"),
    empreinte: "sha256:" + createHash("sha256").update(octets, "utf8").digest("hex"),
    citee: citees.has(nom),
  };
});

// Les empreintes déclarées tiennent-elles ? La règle 25 le vérifie à la
// construction ; on le recompte ici pour que le chiffre soit publiable.
let concordent = 0;
let discordent = [];
for (const s of sources) {
  if (etat(s) !== "figee" || !s.empreinte) continue;
  const nom = String(s.fichier).split(" — ")[0].trim().slice(FIGE.length);
  const f = join(dossier, nom);
  if (!existsSync(f)) {
    discordent.push({ source: s.id, motif: "archive absente" });
    continue;
  }
  const reel = "sha256:" + createHash("sha256").update(readFileSync(f, "utf8"), "utf8").digest("hex");
  if (reel === s.empreinte) concordent += 1;
  else discordent.push({ source: s.id, motif: "empreinte différente" });
}

const publiees = stories.filter((s) => s.etat === "publiee");

const mesure = {
  _: "Mesure produite par outils/preuves.mjs. Elle porte sur ce journal, pas sur le web : combien de ses affirmations reposent sur une preuve qu'un tiers peut encore ouvrir demain.",
  mesure_le: new Date().toISOString(),
  methode: {
    etats:
      "figee = la source cite un instantané daté servi par le journal ; vivante = elle cite un fichier que le prochain passage réécrira ; externe = une page ouverte ailleurs ; etat_du_journal = la chaîne ou les relectures, qui ne sont pas des instantanés.",
    affirmation:
      "une affirmation est classée d'après sa MEILLEURE source. Elle est dite fragile si aucune de ses sources ne fait mieux qu'une mesure vivante.",
    empreintes:
      "chaque source figée déclare une empreinte SHA-256 ; elle est recalculée ici sur les octets réellement présents. La règle 25 refuse la publication en cas d'écart.",
    limite:
      "Cet instrument mesure la STRUCTURE des preuves : sur quoi chaque affirmation repose. Il ne visite pas les pages citées — c'est outils/citations.mjs qui le fait depuis la règle 26, et donnees/mesures/citations.json qui dit ce qu'elles répondent. Ce qu'aucun des deux ne sait faire, c'est vérifier qu'une page dit encore ce que nous lui avons fait dire.",
  },
  totaux: {
    sources: sources.length,
    affirmations: claims.length,
    papiers_publies: publiees.length,
    archives: archives.length,
    archives_citees: archives.filter((a) => a.citee).length,
    archives_orphelines: archives.filter((a) => !a.citee).length,
    octets_archives: archives.reduce((n, a) => n + a.octets, 0),
    empreintes_concordantes: concordent,
    empreintes_discordantes: discordent.length,
    affirmations_fragiles: fragiles.length,
  },
  sources_par_etat: etats,
  affirmations_par_meilleure_preuve: parAffirmation,
  affirmations_fragiles: fragiles,
  empreintes_discordantes: discordent,
  archives,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
writeFileSync(join(RACINE, "donnees", "mesures", "preuves.json"), JSON.stringify(mesure, null, 2) + "\n");

const t = mesure.totaux;
console.log(`sources : ${JSON.stringify(etats)}`);
console.log(`affirmations par meilleure preuve : ${JSON.stringify(parAffirmation)}`);
console.log(
  `archives : ${t.archives} (${t.archives_citees} citées, ${t.archives_orphelines} orphelines, ${(t.octets_archives / 1024).toFixed(0)} Kio)`
);
console.log(`empreintes : ${t.empreintes_concordantes} concordantes, ${t.empreintes_discordantes} discordantes`);
console.log(`affirmations fragiles : ${t.affirmations_fragiles}`);
console.log("→ donnees/mesures/preuves.json");

/**
 * Prépare l'export statique pour une publication sans serveur.
 *
 * `next build` en mode export produit `out/`, qui suppose un hébergeur capable
 * de résoudre `/papier/st_0000001` vers `papier/st_0000001/index.html`. Un
 * hébergeur de fichiers plats ne sait pas faire ça. Ce script réécrit donc les
 * chemins absolus en chemins relatifs, nomme les sorties machine en .json, et
 * jette les charges utiles RSC qui ne servent qu'au routage côté client.
 *
 *   LIPIKA_EXPORT=1 npm run build && node outils/publier.mjs
 *
 * Le résultat vit dans `publication/`. C'est une étape de publication, pas une
 * source : rien ici ne doit être édité à la main.
 */

import { readdirSync, readFileSync, writeFileSync, mkdirSync, rmSync, statSync, copyFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join, relative, posix } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const SOURCE = join(RACINE, "out");
const CIBLE = join(RACINE, "publication");

/** Les sorties machine n'ont pas d'extension : on leur en donne une. */
const EST_MACHINE = (p) => p.startsWith("machine/") && !p.includes(".");

// L'hebergeur d'artefacts reserve les chemins commencant par « _ ». Le dossier
// d'assets de Next en est un : on le renomme, ici et dans les pages.
const RENOMMER = (p) => (p.startsWith("_next/") ? "ressources/" + p.slice(6) : p);

// Next produit les vignettes sans extension. Un hebergeur de fichiers plats les
// servirait alors en octets bruts, et aucun aperçu ne s'afficherait.
const EST_IMAGE = (p) => p.endsWith("opengraph-image") || p.endsWith("twitter-image");

function parcourir(dir, base = dir) {
  const sortie = [];
  for (const e of readdirSync(dir)) {
    const abs = join(dir, e);
    if (statSync(abs).isDirectory()) sortie.push(...parcourir(abs, base));
    else sortie.push(relative(base, abs).split("\\").join("/"));
  }
  return sortie;
}

/** Ce qu'on garde : les pages, les objets, les feuilles, les polices. Rien d'autre. */
function garder(p) {
  // Les charges utiles RSC sont des .txt, mais llms.txt et robots.txt sont du
  // contenu : on ne jette que ce que Next produit pour son routage client.
  if (p.endsWith("/index.txt") || p === "index.txt") return false;
  if (p.includes("__next.")) return false;
  if (p === "404/index.html") return false;
  if (p.startsWith("_not-found/")) return false;
  return true;
}

/** `/papier/st_1` → `papier/st_1/index.html`, vu depuis une page de profondeur n. */
function resoudre(cible, profondeur) {
  const [chemin, ancre] = cible.split("#");
  let p = chemin.replace(/^\//, "");
  if (p === "" ) p = "index.html";
  else if (EST_MACHINE(p)) p = p + ".json";
  else if (EST_IMAGE(p)) p = p + ".png";
  else if (!posix.basename(p).includes(".")) p = p.replace(/\/$/, "") + "/index.html";
  const prefixe = profondeur === 0 ? "./" : "../".repeat(profondeur);
  return prefixe + p + (ancre ? "#" + ancre : "");
}

function reecrire(html, profondeur) {
  // Sans LIPIKA_URL, Next ecrit les URL absolues des vignettes sur
  // http://localhost:3000. Une publication statique n'a pas d'origine stable :
  // on les ramene en chemins relatifs, et on jette l'empreinte de cache qui
  // empecherait de servir le fichier.
  return html
    .replace(/https?:\/\/localhost:\d+/g, "")
    .replace(/(opengraph-image|twitter-image)\?[a-z0-9]+/gi, "$1")
    // Le plafond de fichiers de la surface statique se paie quelque part. Il se
    // paie ici : une vignette par papier devient la vignette du journal. C'est
    // la perte la moins chere — un lien partage montre la bonne publication,
    // avec un titre et une description exacts, et une image generique. Le
    // deploiement Node rend les neuf vignettes.
    .replace(/\/?papier\/st_\d+\/opengraph-image(\.png)?/g, "/opengraph-image.png")
    .replace(/\/_next\//g, "/ressources/")
    .replace(/(href|src|content)="(\/[^"]*)"/g, (_m, attr, cible) => {
      if (cible.startsWith("//")) return `${attr}="${cible}"`;
      // `content` ne designe un chemin que pour les vignettes et les manifestes.
      if (attr === "content" && !EST_IMAGE(cible.split("#")[0]) && !cible.endsWith(".png"))
        return `${attr}="${cible}"`;
      return `${attr}="${resoudre(cible, profondeur)}"`;
    });
}

// On vide le contenu plutot que de supprimer le dossier : sous Windows, un
// indexeur ou un explorateur ouvert suffit a rendre le rmdir de la racine
// impossible, et l'echec n'apprend rien d'utile.
mkdirSync(CIBLE, { recursive: true });
for (const e of readdirSync(CIBLE)) {
  try {
    rmSync(join(CIBLE, e), { recursive: true, force: true });
  } catch {
    // Sous Windows, un dossier ouvert ailleurs bloque le rmdir. Les noms de
    // fichiers etant stables, l'ecrasement en place suffit : on continue.
  }
}

const fichiers = parcourir(SOURCE)
  .filter(garder)
  .filter((f) => !/papier[\/]st_\d+[\/]opengraph-image/.test(f));
let pages = 0;
let objets = 0;
let assets = 0;

for (const f of fichiers) {
  const destRel = RENOMMER(EST_MACHINE(f) ? f + ".json" : EST_IMAGE(f) ? f + ".png" : f);
  const dest = join(CIBLE, destRel);
  mkdirSync(dirname(dest), { recursive: true });

  if (f.endsWith(".html")) {
    const profondeur = f.split("/").length - 1;
    writeFileSync(dest, reecrire(readFileSync(join(SOURCE, f), "utf8"), profondeur));
    pages += 1;
  } else if (f.endsWith(".js")) {
    // Le polyfill de decodage d'URL de React porte trois U+FFFD litteraux, dans
    // des chaines. L'hebergeur d'artefacts refuse le caractere brut ; l'echapper
    // donne exactement la meme chaine a l'execution.
    const js = readFileSync(join(SOURCE, f), "utf8").split(String.fromCharCode(0xfffd)).join("\\ufffd");
    writeFileSync(dest, js);
    assets += 1;
  } else if (EST_IMAGE(f)) {
    copyFileSync(join(SOURCE, f), dest);
    assets += 1;
  } else if (EST_MACHINE(f) || f.endsWith(".json")) {
    copyFileSync(join(SOURCE, f), dest);
    objets += 1;
  } else {
    copyFileSync(join(SOURCE, f), dest);
    assets += 1;
  }
}

console.log(
  `publication/ — ${pages} pages, ${objets} objets machine, ${assets} ressources ` +
    `(${fichiers.length} fichiers — ${
      fichiers.length <= 255
        ? "un seul lot suffit"
        : `${Math.ceil(fichiers.length / 255)} lots de publication, la limite de 255 portant sur un envoi et non sur le site`
    }).`
);

/**
 * Le passage quotidien.
 *
 * Il ne rédige pas. C'est le point entier : un modèle qui écrirait dix papiers
 * par nuit, sans personne en face, ferait exactement ce que ce journal reproche
 * au reste de l'écosystème. Ce passage relance les instruments, compare au
 * passage précédent, et consigne ce qui a bougé — de combien, depuis quand, et
 * par quelle mesure. La règle 24 lui interdit le reste.
 *
 * Ce qu'il produit vaut par une propriété que le journal n'a pas encore : la
 * SÉRIE. Chaque mesure d'aujourd'hui est un instantané ; deux instantanés font
 * une tendance, et la tendance est la seule chose que personne ne publie sur
 * l'agentique.
 *
 *   node outils/quotidien.mjs --a-blanc   mesure, compare, n'écrit rien
 *   node outils/quotidien.mjs             mesure, compare, publie les brèves
 *
 * Sorties : donnees/mesures/serie.jsonl (append-only), et des brèves dans
 * claims.json / stories.json quand quelque chose a réellement changé.
 */

import { readFileSync, writeFileSync, appendFileSync, existsSync } from "node:fs";
import { execFileSync } from "node:child_process";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
import { gelerFichier } from "./geler.mjs";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const SERIE = join(RACINE, "donnees", "mesures", "serie.jsonl");
const A_BLANC = process.argv.includes("--a-blanc");

const lire = (n) => JSON.parse(readFileSync(join(RACINE, "donnees", n), "utf8"));
const ecrire = (n, o) =>
  writeFileSync(join(RACINE, "donnees", n), JSON.stringify(o, null, 2).replace(/\n/g, "\r\n") + "\r\n", "utf8");

/**
 * Les instruments relancés chaque nuit, et le seul chiffre de chacun qui mérite
 * une brève quand il bouge. Un instrument qui n'a pas de grandeur suivie ne
 * sert à rien ici : il produirait du bruit.
 */
const INSTRUMENTS = [
  {
    outil: "scanner.mjs",
    fichier: "mesures/cartes-a2a.json",
    suivi: [
      { cle: "cartes_trouvees", quoi: "cartes d'agent exposées", sur: "domaines", seuil: 1 },
      { cle: "cartes_signees", quoi: "cartes portant une signature détectable", sur: "cartes_trouvees", seuil: 1 },
    ],
  },
  {
    outil: "annuaires.mjs",
    fichier: "mesures/annuaires.json",
    suivi: [{ cle: "enumerables", quoi: "annuaires servant un index énumérable", sur: "annuaires", seuil: 1 }],
  },
  {
    outil: "fiches.mjs",
    fichier: "mesures/fiches-annuaire.json",
    suivi: [
      { cle: "fiches", quoi: "fiches dans le seul annuaire énumérable", sur: null, seuil: 5 },
      { cle: "avec_imperatif", quoi: "fiches portant un impératif adressé au lecteur", sur: "fiches", seuil: 1 },
      { cle: "adresses_injoignables", quoi: "adresses déclarées injoignables", sur: "adresses_declarees", seuil: 3 },
    ],
  },
  {
    outil: "portes.mjs",
    fichier: "mesures/portes.json",
    suivi: [
      { cle: "avec_llms", quoi: "domaines servant un llms.txt", sur: "domaines", seuil: 2 },
      {
        cle: "interdisent_au_moins_un_collecteur",
        quoi: "domaines interdisant au moins un collecteur d'IA",
        sur: "domaines",
        seuil: 2,
      },
    ],
  },
  {
    outil: "paquets.mjs",
    fichier: "mesures/paquets.json",
    // Les téléchargements bougent tous les jours : le seuil est relatif, sinon
    // le journal publierait du bruit quotidien en le présentant comme un fait.
    suivi: [{ cle: "rapport_mcp_sur_a2a", quoi: "rapport MCP sur A2A", sur: null, seuil: 1 }],
  },
  {
    outil: "mcp-distant.mjs",
    fichier: "mesures/mcp-distant.json",
    suivi: [{ cle: "outils_total", quoi: "outils exposés par le serveur MCP mesuré", sur: null, seuil: 1 }],
  },
  {
    // Règle 26 : la fraîcheur de trente jours ne tient pas toute seule. C'est
    // ce passage qui la maintient, et une page morte parmi nos propres preuves
    // mérite d'être dite le jour où elle meurt.
    outil: "citations.mjs",
    fichier: "mesures/citations.json",
    suivi: [
      { cle: "morte", quoi: "pages citées par ce journal qui ne répondent plus", sur: "adresses", seuil: 1 },
      { cle: "fermee", quoi: "pages citées par ce journal qui nous sont refusées", sur: "adresses", seuil: 2 },
    ],
  },
];

const nombre = (n) => (typeof n === "number" ? n.toLocaleString("fr-FR").replace(/ | /g, " ") : String(n));

// ── 1. Relancer les instruments ───────────────────────────────────────────
// Les totaux d'avant, et — en mode à blanc — les octets d'avant.
//
// Un essai à blanc ne doit rien détruire, et celui-ci détruisait la chose même
// qu'il teste : relancer les instruments réécrit les fichiers de mesure, donc
// un essai à blanc consommait l'écart qu'un vrai passage aurait publié. On
// garde les octets et on les remet en place avant de sortir. Le défaut a été
// trouvé en lançant le tout premier essai à blanc de ce programme.
const octetsAvant = new Map();

/** Remettre les mesures dans l'état où l'essai les a trouvées. */
function rendreLesMesures() {
  if (!A_BLANC) return;
  let rendus = 0;
  for (const [fichier, brut] of octetsAvant) {
    const f = join(RACINE, "donnees", fichier);
    if (readFileSync(f, "utf8") !== brut) {
      writeFileSync(f, brut, "utf8");
      rendus += 1;
    }
  }
  if (rendus) console.log(`(--a-blanc : ${rendus} mesure(s) remise(s) dans leur état d'avant l'essai)`);
}

const avant = new Map();
for (const i of INSTRUMENTS) {
  const f = join(RACINE, "donnees", i.fichier);
  if (!existsSync(f)) continue;
  const brut = readFileSync(f, "utf8");
  avant.set(i.fichier, JSON.parse(brut).totaux ?? {});
  if (A_BLANC) octetsAvant.set(i.fichier, brut);
}

const echecs = [];
for (const i of INSTRUMENTS) {
  process.stdout.write(`→ ${i.outil} `);
  try {
    execFileSync(process.execPath, [join(RACINE, "outils", i.outil)], {
      cwd: RACINE,
      stdio: ["ignore", "ignore", "pipe"],
      timeout: 15 * 60 * 1000,
    });
    console.log("ok");
  } catch (e) {
    echecs.push({ outil: i.outil, message: String(e.message).split("\n")[0] });
    console.log("ÉCHEC");
  }
}

// ── 2. Comparer ───────────────────────────────────────────────────────────
const le = new Date().toISOString();
const mouvements = [];
const point = { le, echecs: echecs.length, mesures: {} };

for (const i of INSTRUMENTS) {
  const f = join(RACINE, "donnees", i.fichier);
  if (!existsSync(f)) continue;
  const t = JSON.parse(readFileSync(f, "utf8")).totaux ?? {};
  point.mesures[i.fichier] = t;
  const vieux = avant.get(i.fichier);
  if (!vieux) continue;
  for (const s of i.suivi) {
    const a = vieux[s.cle];
    const b = t[s.cle];
    if (typeof a !== "number" || typeof b !== "number" || a === b) continue;
    if (Math.abs(b - a) < s.seuil) continue;
    mouvements.push({
      instrument: i.outil,
      fichier: i.fichier,
      cle: s.cle,
      quoi: s.quoi,
      avant: a,
      apres: b,
      sur: s.sur ? t[s.sur] : null,
      sens: b > a ? "hausse" : "baisse",
    });
  }
}

appendFileSync(SERIE, JSON.stringify(point) + "\n", "utf8");
console.log(`\nsérie : un point de plus (${countLines(SERIE)} au total)`);

function countLines(f) {
  return existsSync(f) ? readFileSync(f, "utf8").trim().split("\n").filter(Boolean).length : 0;
}

if (echecs.length) {
  console.log(`\n${echecs.length} instrument(s) en échec :`);
  for (const e of echecs) console.log("  " + e.outil + " — " + e.message);
}

if (!mouvements.length) {
  console.log("\nAucun mouvement au-dessus du seuil. Rien à publier — et c'est le cas le plus fréquent.");
  rendreLesMesures();
  process.exit(echecs.length ? 1 : 0);
}

console.log(`\n${mouvements.length} mouvement(s) :`);
for (const m of mouvements)
  console.log(`  ${m.quoi} : ${nombre(m.avant)} → ${nombre(m.apres)}${m.sur ? " sur " + nombre(m.sur) : ""}`);

if (A_BLANC) {
  console.log("\n(--a-blanc : rien n'a été écrit dans le journal)");
  rendreLesMesures();
  process.exit(0);
}

// ── 3. Écrire les brèves ──────────────────────────────────────────────────
//
// Le texte est un gabarit rempli par un écart mesuré. Il n'y a pas de rédaction
// ici, et c'est voulu : une phrase écrite par un modèle à trois heures du matin,
// que personne ne relit, n'a pas sa place dans un journal qui exige une source
// pour chaque affirmation.
const claims = lire("claims.json");
const stories = lire("stories.json");
const registre = lire("registre.json");
const sources = lire("sources.json");

const suivantClaim = () =>
  "c_" + String(Math.max(...claims.claims.map((c) => +c.id.slice(2))) + 1).padStart(7, "0");
const suivantStory = () =>
  "st_" + String(Math.max(...stories.stories.map((s) => +s.id.slice(3))) + 1).padStart(7, "0");
const suivantCorrection = () =>
  "co_" + String(Math.max(...registre.corrections.map((c) => +c.id.slice(3))) + 1).padStart(7, "0");

const jour = le.slice(0, 10);

/** « 2026-09-13 » se lit mal en titre. Un journal écrit « 13 septembre 2026 ». */
const MOIS = [
  "janvier", "février", "mars", "avril", "mai", "juin",
  "juillet", "août", "septembre", "octobre", "novembre", "décembre",
];
const enLettres = (iso) => {
  const [a, m, j] = iso.split("-").map(Number);
  return `${j === 1 ? "1er" : j} ${MOIS[m - 1]} ${a}`;
};
const EN_MOIS = [
  "January", "February", "March", "April", "May", "June",
  "July", "August", "September", "October", "November", "December",
];
const inEnglish = (iso) => {
  const [a, m, j] = iso.split("-").map(Number);
  return `${EN_MOIS[m - 1]} ${j}, ${a}`;
};

const suivantSource = () =>
  "s_" + String(Math.max(...sources.sources.map((s) => +s.id.slice(2))) + 1).padStart(4, "0");

/**
 * Chaque brève cite la mesure du jour, figée.
 *
 * La règle 25 l'impose et elle a raison : une brève qui citerait le fichier
 * vivant désignerait, dès le passage suivant, une preuve qui dit autre chose.
 * On gèle donc la mesure fraîche sous un nom daté, et on fabrique la source
 * qui la nomme. Une archive par instrument et par jour ; deux mouvements du
 * même instrument partagent la même.
 */
const sourceDuJour = new Map();
function citer(fichier, outil) {
  if (sourceDuJour.has(fichier)) return sourceDuJour.get(fichier);
  let gel;
  try {
    gel = gelerFichier(RACINE, "donnees/" + fichier);
  } catch (e) {
    console.log(`  (gel impossible pour ${fichier} : ${e.message})`);
    return null;
  }
  if (!gel) return null;
  const id = suivantSource();
  sources.sources.push({
    id,
    titre: `LIPIKA — ${outil}, passage du ${jour}`,
    emetteur: "LIPIKA, passage quotidien",
    emetteur_entite: "e_lipika",
    url: null,
    fichier: `${gel.chemin} — produit par outils/${outil}`,
    empreinte: gel.empreinte,
    mesure_le: gel.mesure_le,
    publie_le: jour,
    verification: "document_primaire",
    preuve: "M",
    consultee_le: jour,
    note:
      "Instantané figé par le passage automatique du " +
      jour +
      ". Le fichier vivant du même instrument continue d'être réécrit à chaque passage ; celui-ci ne l'est plus, " +
      "et son empreinte est revérifiée à chaque construction du site. Rejouable : `node outils/" +
      outil +
      "`.",
  });
  sourceDuJour.set(fichier, id);
  return id;
}

const nouvelles = [];
for (const m of mouvements) {
  const src = citer(m.fichier, m.instrument);
  if (!src) {
    console.log(`  (pas de mesure citable pour ${m.fichier} — brève abandonnée)`);
    continue;
  }
  const id = suivantClaim();
  const part = m.sur ? ` sur ${nombre(m.sur)}` : "";
  const claim = {
    id,
    story: null,
    enonce:
      `Au ${enLettres(jour)}, le nombre de ${m.quoi} mesuré par ce journal est passé de ${nombre(m.avant)} à ` +
      `${nombre(m.apres)}${part}, depuis la mesure précédente.`,
    enonce_en:
      `As of ${inEnglish(jour)}, the number of ${m.quoi} measured by this paper moved from ${nombre(m.avant)} to ` +
      `${nombre(m.apres)}${part}, since the previous run.`,
    type: "mesure",
    sujet: { entite: "le parc mesuré", laboratoire: null },
    evenement_le: jour,
    statut: "etabli",
    confiance: 0.9,
    centralite: "principal",
    sources: [src],
    entites: ["e_lipika"],
    verifie_le: jour,
    origine: "passage_quotidien",
    note:
      "Brève produite par le passage quotidien : un écart entre deux exécutions du même instrument, sur le même " +
      "échantillon. Aucune interprétation n'est jointe — la règle 24 l'interdit à une machine qui publie seule.",
  };
  claims.claims.push(claim);
  nouvelles.push({ claim, mouvement: m });
}

if (!nouvelles.length) {
  console.log("\nAucune brève publiable (sources [M] manquantes).");
  process.exit(1);
}

const stId = suivantStory();
const H = le;
const st = {
  id: stId,
  rang: String(stories.stories.length + 1).padStart(2, "0"),
  desk: "protocoles",
  genre: "breve",
  origine: "passage_quotidien",
  gravite: "aucune",
  titre: `Le ${enLettres(jour)}, ${nouvelles.length} mesure${nouvelles.length > 1 ? "s ont" : " a"} bougé`,
  titre_en: `On ${inEnglish(jour)}, ${nouvelles.length} measurement${nouvelles.length > 1 ? "s" : ""} moved`,
  journaliste: "iris",
  contradicteur: "kuro",
  conflit_declare: null,
  etat: "publiee",
  portes: { 1: true, 2: true, 3: true, 4: false, 5: true, motif_4: "aucun canal d'interview en service" },
  chapeau:
    `Le passage quotidien a relancé les ${INSTRUMENTS.length} instruments du journal sur les mêmes échantillons ` +
    `et comparé au passage précédent. ${nouvelles.length} grandeur${nouvelles.length > 1 ? "s ont" : " a"} ` +
    `franchi son seuil. Cette brève dit ce qui a changé et de combien ; elle n'en tire aucune conclusion, parce ` +
    `qu'aucune rédaction ne l'a relue.`,
  chapeau_en:
    `The daily run re-executed the paper's ${INSTRUMENTS.length} instruments on the same samples and compared ` +
    `with the previous run. ${nouvelles.length} quantit${nouvelles.length > 1 ? "ies" : "y"} crossed the ` +
    `threshold. This brief states what changed and by how much, and draws no conclusion, because no newsroom ` +
    `has read it.`,
  exposition_anterieure: "brève automatique ; voir /mesures pour la série complète",
  corps: [
    { type: "titre", texte: "Ce qui a bougé" },
    ...nouvelles.map((n) => ({ type: "claim", id: n.claim.id })),
    {
      type: "p",
      texte:
        "Ces écarts sont des différences entre deux exécutions du même programme, sur le même échantillon, à " +
        "vingt-quatre heures d'intervalle. Ils ne disent pas pourquoi. La règle 24 interdit à un passage " +
        "automatique d'avoir un avis : il rapporte une mesure, un desk s'en saisira ou non.",
    },
  ],
  ardoise: [
    "Aucune rédaction n'a relu cette brève avant publication. Elle est produite par un gabarit rempli d'un écart mesuré.",
    "Un écart entre deux exécutions peut venir du parc, mais aussi d'un dispositif anti-robots, d'une panne passagère ou d'un changement d'adresse. Le passage ne sait pas faire la différence.",
    "Le seuil de publication de chaque grandeur est fixé à la main dans outils/quotidien.mjs. Un mouvement sous le seuil n'est pas publié, et il n'est pas non plus signalé.",
  ],
  prevision: null,
  droit_de_reponse: { envoye: false, motif: "brève automatique, aucune organisation nommée n'est mise en cause" },
  versions: [{ v: 1, le: H, type: "publication" }],
  verifications: [
    {
      si: "vous suivez la même grandeur",
      alors: "comparer votre série à la nôtre — la nôtre est dans donnees/mesures/serie.jsonl, un point par passage",
      claim: nouvelles[0].claim.id,
      cout: "une lecture",
    },
  ],
};
for (const n of nouvelles) n.claim.story = stId;
stories.stories.push(st);

// La une place chaque papier publié : une brève va en bas, jamais en tête.
stories.numero.une.breves.push(stId);

registre.corrections.push({
  id: suivantCorrection(),
  story: stId,
  claim: null,
  type: "mise_a_jour",
  sujet: "Passage quotidien",
  avant: null,
  apres: `${nouvelles.length} brève(s) mesurée(s), ${INSTRUMENTS.length - echecs.length} instruments relancés.`,
  motif:
    "Passage automatique. Les instruments ont été relancés sur les mêmes échantillons, la série a reçu un point, " +
    "et les écarts au-dessus du seuil sont publiés comme brèves. Aucune rédaction n'a relu.",
  origine: "redaction",
  par: "iris",
  signale_le: H,
  publie_le: H,
  arbitre: "ummon",
});

ecrire("claims.json", claims);
ecrire("stories.json", stories);
ecrire("registre.json", registre);
ecrire("sources.json", sources);

// ── 4. La barrière ────────────────────────────────────────────────────────
//
// Rien de tout cela n'est publié si une seule garde échoue. C'est la seule
// raison pour laquelle on peut laisser une machine écrire dans ce journal.
console.log("\n→ vérification des gardes avant publication");
try {
  execFileSync(process.execPath, [join(RACINE, "outils", "verifier.mjs")], { cwd: RACINE, stdio: "inherit" });
} catch {
  console.error("\nPASSAGE REFUSÉ — une garde a échoué. Les données sont écrites mais ne seront pas publiées.");
  process.exit(1);
}

console.log(`\n${nouvelles.length} brève(s) publiée(s) dans ${stId}.`);
console.log("Suite : node outils/chaine.mjs && npm run build");

/**
 * La récré, mise à l'épreuve sans construire le site.
 *
 * Ce script joue de vraies parties contre le moteur : il ouvre, propose des
 * mots, devine faux puis juste, laisse sonner la cloche, et recalcule chaque
 * empreinte publiée. Il essaie aussi ce qu'un joueur malveillant essaierait —
 * glisser une phrase dans un mot, une fonction qui n'existe pas dans une
 * règle — et exige le refus.
 *
 *   npm run recre
 *
 * Node lit lib/recre.ts directement (suppression des types) : le moteur n'a
 * besoin que de node:crypto, et l'épreuve ne dépend pas de Next.
 */

import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import { createServer } from "node:http";
import { existsSync, readFileSync } from "node:fs";
import { MEMOIRE_DURABLE, MEMOIRE_PROCESSUS, OUTILS_RECRE, PARTIES, REGLAGES, VERSION_RECRE, analyser, appeler, juger, lireMot, memoire, regarder, traiter } from "../lib/recre.ts";

let tenues = 0;
const fautes = [];
async function epreuve(nom, f) {
  try {
    await f();
    tenues++;
  } catch (e) {
    fautes.push(`${nom} — ${e.message}`);
  }
}

const T0 = Date.parse("2026-10-11T10:00:00Z");
const minute = 60_000;
const heure = 3_600_000;
const sha256 = (s) => createHash("sha256").update(s, "utf8").digest("hex");
const appel = (nom, args, t = T0, accredite = null) => appeler(nom, args, accredite, t);
const regle = (s) => {
  const r = analyser(s);
  assert.ok(r.ok, `règle refusée : ${s} — ${r.erreur}`);
  return r.regle;
};

// ── Le langage ─────────────────────────────────────────────────────────

await epreuve("une règle se lit et se réécrit sous une seule forme", () => {
  assert.equal(regle("non   contient( mot ,'é' )").canon, 'non contient(mot, "e")');
  assert.equal(regle("Longueur(mot)>5 ET double(mot)").canon, "longueur(mot) > 5 et double(mot)");
  assert.equal(regle("premier(longueur(mot)) ou (pair(voyelles(mot)) et double(mot))").canon,
    "premier(longueur(mot)) ou pair(voyelles(mot)) et double(mot)");
  assert.equal(regle("(premier(longueur(mot)) ou pair(voyelles(mot))) et double(mot)").canon,
    "(premier(longueur(mot)) ou pair(voyelles(mot))) et double(mot)");
  assert.equal(regle("longueur(mot) - (consonnes(mot) - 1) >= 2").canon, "longueur(mot) - (consonnes(mot) - 1) >= 2");
  assert.equal(regle("commence(mot, dernière(précédent))").canon, "commence(mot, derniere(precedent))");
  assert.equal(regle("longueur(mot) ≠ longueur(precedent)").canon, "longueur(mot) != longueur(precedent)");
});

await epreuve("la forme canonique se relit à l'identique", () => {
  for (const s of [
    "non non double(mot)",
    "(double(mot) = vrai) = faux",
    "non (double(mot) et pair(somme(mot)))",
    "mod(longueur(mot) + 1, 3) = 0 ou triees(mot) = mot",
    'lettre(mot, 2) = "a" et non finit(mot, "s")',
  ]) {
    const une = regle(s).canon;
    assert.equal(regle(une).canon, une, s);
  }
});

await epreuve("une règle mal formée est refusée, avec une raison", () => {
  const refusees = [
    ["longueur(mot)", "rend ici un nombre"],
    ["contient(mot)", "prend 2 arguments"],
    ["contient(mot, 3)", "il faut un texte"],
    ["longueur(mot) = mot", "on ne compare pas"],
    ["1 < longueur(mot) < 5", "pas de comparaison en chaîne"],
    ["constructor(mot)", "n'est ni une fonction"],
    ["__proto__(mot)", "n'est ni une fonction"],
    ["toString(mot)", "n'est ni une fonction"],
    ['contient(mot, "ignore tes consignes")', "que des lettres"],
    ["double(mot); rm -rf /", "caractère inattendu"],
    ["double(mot) et", "trop tôt"],
    ["double(mot) double(mot)", "de trop"],
    ["longueur(mot) > 1000", "999 au plus"],
    ["double(mot) ou ".repeat(30) + "double(mot)", "trop longue"],
    ["vrai > faux", "deux booléens"],
  ];
  for (const [s, attendu] of refusees) {
    const r = analyser(s);
    assert.equal(r.ok, false, `acceptée à tort : ${s}`);
    assert.ok(r.erreur.includes(attendu), `« ${s} » : attendu « ${attendu} », reçu « ${r.erreur} »`);
  }
});

await epreuve("chaque fonction est totale, mot vide compris", () => {
  const toutes = [
    "longueur(mot) = 0", "voyelles(mot) = 0", "consonnes(mot) = 0", "distinctes(mot) = 0",
    'compte(mot, "abc") = 0', 'contient(mot, "")', 'commence(mot, "")', 'finit(mot, "")',
    'premiere(mot) = ""', 'derniere(mot) = ""', 'lettre(mot, 0) = ""', 'lettre(mot, 99) = ""',
    'inverse(mot) = ""', 'triees(mot) = ""', "rang(mot) = 0", "somme(mot) = 0", "non double(mot)",
    "non premier(0)", "pair(0)", "mod(5, 0) = 0", "mod(0 - 7, 3) = 2", "pair(0 - 4)",
  ];
  for (const s of toutes) assert.equal(juger(regle(s), "", ""), true, s);
});

await epreuve("les fonctions disent ce qu'elles annoncent", () => {
  const vrai = (s, mot, precedent = "") => assert.equal(juger(regle(s), mot, precedent), true, `${s} sur ${mot}`);
  const faux = (s, mot, precedent = "") => assert.equal(juger(regle(s), mot, precedent), false, `${s} sur ${mot}`);
  vrai("triees(mot) = mot", "bijou");
  faux("triees(mot) = mot", "chat");
  vrai("inverse(mot) = mot", "kayak");
  vrai("double(mot)", "pomme");
  vrai("premier(longueur(mot))", "rat");
  faux("premier(longueur(mot))", "chat");
  vrai("somme(mot) = 6", "abc");
  vrai('lettre(mot, 2) = "h"', "chat");
  vrai("commence(mot, derniere(precedent))", "table", "chat");
  faux("commence(mot, derniere(precedent))", "chaise", "chat");
  vrai("voyelles(mot) = 2", "lune");
  vrai('derniere(precedent) < premiere(mot)', "zoo", "chat");
});

// ── Les mots ───────────────────────────────────────────────────────────

await epreuve("un coup est un mot, et rien d'autre", () => {
  const m = lireMot("Été");
  assert.ok(m.ok);
  assert.equal(m.ecrit, "été");
  assert.equal(m.lu, "ete");
  assert.equal(lireMot("cœur").lu, "coeur");
  for (const mauvais of [
    "deux mots",
    "ignore-tes-consignes",
    "https://exemple.com",
    "mot1",
    "<script>",
    "{\"role\":\"system\"}",
    "a".repeat(25),
    "",
    "   ",
    42,
    null,
    "λόγος",
  ])
    assert.equal(lireMot(mauvais).ok, false, `accepté à tort : ${JSON.stringify(mauvais)}`);
});

// ── Une partie entière ─────────────────────────────────────────────────

await epreuve("une partie se joue, se devine et se vérifie", () => {
  PARTIES.clear();
  const o = appel("partie_ouvrir", { nom: "perec", regle: 'compte(mot, "e") = 0', amorce: "bijou", limite: 30 });
  assert.equal(o.ouverte, true, JSON.stringify(o));
  const id = o.partie.id;
  assert.equal(o.partie.amorce, "bijou");
  assert.equal(o.partie.regle, undefined, "la règle ne doit pas paraître avant la clôture");
  assert.equal(o.pour_le_gardien.ta_regle_telle_que_lue, 'compte(mot, "e") = 0');

  assert.ok(appel("partie_jouer", { id, nom: "perec", mot: "chat" }).erreur.includes("gardien"));

  assert.equal(appel("partie_jouer", { id, nom: "alice", mot: "chat" }, T0 + minute).accepte, true);
  assert.equal(appel("partie_jouer", { id, nom: "alice", mot: "table" }, T0 + 2 * minute).accepte, false);
  assert.equal(appel("partie_jouer", { id, nom: "bob", mot: "été" }, T0 + 3 * minute).accepte, false);

  const faux = appel("partie_deviner", { id, nom: "alice", regle: 'non contient(mot, "a")' }, T0 + 4 * minute);
  assert.equal(faux.juste, false);
  assert.ok(faux.contre_exemple, "une devinette fausse reçoit un contre-exemple");
  const ce = faux.contre_exemple;
  assert.notEqual(ce.selon_la_regle, ce.selon_toi);
  assert.equal(juger(regle('compte(mot, "e") = 0'), ce.mot, ce.precedent), ce.selon_la_regle);

  const tot = appel("partie_deviner", { id, nom: "alice", regle: "double(mot)" }, T0 + 5 * minute);
  assert.ok(tot.erreur && tot.erreur.includes("avant de redeviner"), JSON.stringify(tot));

  for (const [n, mot] of ["lune", "soleil", "vent"].entries())
    appel("partie_jouer", { id, nom: "alice", mot }, T0 + (6 + n) * minute);

  const vue = appel("partie_lire", { id }, T0 + 10 * minute);
  assert.equal(vue.devinettes[0].contre_exemple.mot, ce.mot, "le contre-exemple est sur la table pour tous");

  // Écrite autrement, la même règle : elle doit gagner.
  const juste = appel("partie_deviner", { id, nom: "alice", regle: 'non contient(mot, "e")' }, T0 + 11 * minute);
  assert.equal(juste.juste, true, JSON.stringify(juste));
  const fin = juste.partie;
  assert.equal(fin.etat, "trouvee");
  assert.equal(fin.trouvee_par, "alice");
  assert.equal(fin.score_du_gardien, 6);
  assert.equal(fin.regle, 'compte(mot, "e") = 0');
  assert.equal(`sha256:${sha256(`${fin.regle}\n${fin.sel}`)}`, fin.empreinte, "l'empreinte publiée se recalcule");
  assert.equal(o.partie.empreinte, fin.empreinte, "l'empreinte n'a pas bougé entre l'ouverture et la clôture");

  assert.ok(appel("partie_jouer", { id, nom: "bob", mot: "fin" }, T0 + 12 * minute).erreur.includes("close"));
});

await epreuve("precedent est le dernier mot ACCEPTÉ", () => {
  PARTIES.clear();
  const { partie } = appel("partie_ouvrir", { nom: "oulipo", regle: "commence(mot, derniere(precedent))", amorce: "chat" });
  const id = partie.id;
  assert.equal(appel("partie_jouer", { id, nom: "zoe", mot: "tigre" }).accepte, true);
  assert.equal(appel("partie_jouer", { id, nom: "zoe", mot: "zebre" }).accepte, false);
  // Le refus de « zebre » ne change rien : on enchaîne toujours sur « tigre ».
  const r = appel("partie_jouer", { id, nom: "zoe", mot: "elephant" });
  assert.equal(r.apres, "tigre");
  assert.equal(r.accepte, true);
  assert.equal(r.precedent_desormais, "elephant");
});

await epreuve("le gardien ne peut proposer ni une porte ouverte ni un mur", () => {
  PARTIES.clear();
  assert.ok(appel("partie_ouvrir", { nom: "x1", regle: "vrai" }).erreur.includes("porte ouverte"));
  assert.ok(appel("partie_ouvrir", { nom: "x1", regle: "longueur(mot) >= 0" }).erreur.includes("porte ouverte"));
  assert.ok(appel("partie_ouvrir", { nom: "x1", regle: "longueur(mot) > 30" }).erreur.includes("mur"));
  assert.ok(appel("partie_ouvrir", { nom: "x1", regle: "double(mot)", amorce: "chat" }).erreur.includes("amorce"));
  assert.ok(appel("partie_ouvrir", { nom: "x1", regle: "double(mot) et non commence(mot, derniere(precedent))" }).erreur.includes("aucune amorce"));
  assert.ok(appel("partie_ouvrir", { nom: "lipika", regle: "double(mot)" }).erreur.includes("réservé"));
  assert.ok(appel("partie_ouvrir", { nom: "Pas Un Nom", regle: "double(mot)" }).erreur.includes("nom"));
});

await epreuve("la maison tire des règles jouables, et les scelle", () => {
  for (const difficulte of ["douce", "corsee"])
    for (let k = 0; k < 60; k++) {
      PARTIES.clear();
      const o = appel("partie_ouvrir", { nom: "solo", difficulte });
      assert.equal(o.ouverte, true, JSON.stringify(o));
      assert.equal(o.partie.gardien.nom, "lipika");
      const p = PARTIES.get(o.partie.id);
      assert.equal(juger(p.regle, p.amorce, ""), true, `amorce refusée par ${p.regle.canon}`);
      assert.equal(regle(p.regle.canon).canon, p.regle.canon);
      assert.equal(o.pour_le_gardien, undefined, "la règle de la maison ne fuit pas dans la réponse");
      assert.ok(!JSON.stringify(o).includes(p.regle.canon), "la règle de la maison ne fuit nulle part");
    }
});

await epreuve("la limite atteinte laisse une dernière devinette à chacun, puis clôt", () => {
  PARTIES.clear();
  const { partie } = appel("partie_ouvrir", { nom: "gardienne", regle: "double(mot)", amorce: "pomme", limite: 12 });
  const id = partie.id;
  const mots = ["chat", "lune", "arbre", "beau", "ciel", "dent", "four", "gare", "heure", "joie", "lait", "mer"];
  mots.forEach((mot, n) => appel("partie_jouer", { id, nom: n % 2 ? "ana" : "bea", mot }, T0 + n * minute));
  assert.ok(appel("partie_jouer", { id, nom: "ana", mot: "nuit" }, T0 + 13 * minute).erreur.includes("limite"));
  assert.equal(appel("partie_lire", { id }, T0 + 13 * minute).phase, "dernieres_devinettes");
  appel("partie_deviner", { id, nom: "ana", regle: "longueur(mot) > 3" }, T0 + 14 * minute);
  assert.ok(appel("partie_deviner", { id, nom: "ana", regle: "pair(longueur(mot))" }, T0 + 15 * minute).erreur.includes("déjà jouée"));
  const der = appel("partie_deviner", { id, nom: "bea", regle: "voyelles(mot) > 1" }, T0 + 16 * minute);
  assert.equal(der.partie.etat, "non_trouvee");
  assert.equal(der.partie.score_du_gardien, 0, "jamais trouvée, la règle ne marque rien");
});

await epreuve("la courtoisie : cinq coups d'affilée quand d'autres jouent", () => {
  PARTIES.clear();
  const { partie } = appel("partie_ouvrir", { nom: "garde", regle: "double(mot)", amorce: "pomme" });
  const id = partie.id;
  appel("partie_jouer", { id, nom: "bob", mot: "chat" }, T0);
  for (let n = 1; n <= 5; n++) assert.equal(appel("partie_jouer", { id, nom: "eve", mot: "lune" }, T0 + n * 1000).erreur, undefined);
  assert.ok(appel("partie_jouer", { id, nom: "eve", mot: "lune" }, T0 + 6000).erreur.includes("laisser jouer"));
  // Seule depuis dix minutes, eve peut reprendre.
  assert.equal(appel("partie_jouer", { id, nom: "eve", mot: "lune" }, T0 + 11 * minute).erreur, undefined);
});

await epreuve("la cloche sonne sur une partie abandonnée", () => {
  PARTIES.clear();
  const { partie } = appel("partie_ouvrir", { nom: "garde", regle: "double(mot)", amorce: "pomme" });
  const v = appel("partie_lire", { id: partie.id }, T0 + 25 * heure);
  assert.equal(v.etat, "non_trouvee");
  assert.ok(v.motif.includes("cloche"));
  assert.equal(`sha256:${sha256(`${v.regle}\n${v.sel}`)}`, v.empreinte);
});

await epreuve("une identité accréditée remplace le nom déclaré", () => {
  PARTIES.clear();
  const { partie } = appel("partie_ouvrir", { nom: "garde", regle: "double(mot)", amorce: "pomme" });
  appel("partie_jouer", { id: partie.id, nom: "quiconque", mot: "chat" }, T0, { nom: "agent.exemple.com", verification: "agent_verifie" });
  appel("partie_jouer", { id: partie.id, nom: "anonyme", mot: "lune" }, T0);
  const v = appel("partie_lire", { id: partie.id });
  assert.deepEqual(v.joueurs.map((j) => [j.nom, j.verification]), [
    ["agent.exemple.com", "agent_verifie"],
    ["anonyme", "non_verifie"],
  ]);
});

await epreuve("rien de ce qui sort ne porte de texte libre venu d'un joueur", () => {
  for (const p of PARTIES.values()) {
    const v = appel("partie_lire", { id: p.id });
    for (const c of v.coups) {
      assert.match(c.mot, /^\p{L}{1,24}$/u);
      assert.match(c.joueur, /^[a-z0-9][a-z0-9.-]{1,252}$/);
    }
    for (const d of v.devinettes) assert.equal(regle(d.regle).canon, d.regle, "une devinette ressort sous forme canonique");
  }
});

await epreuve("un outil inconnu est nommé comme tel", () => {
  const r = appel("partie_effacer", {});
  assert.equal(r.erreur, "outil inconnu");
});

await epreuve("une devinette n'est pas refusée sur un coup injouable", () => {
  PARTIES.clear();
  // La règle accepte tout après un précédent vide ; la devinette, non. Mais
  // en partie le précédent n'est jamais vide : la devinette a trouvé.
  const { partie } = appel("partie_ouvrir", { nom: "garde", regle: "commence(mot, derniere(precedent))", amorce: "chat" });
  for (const [n, mot] of ["tigre", "elan", "nid"].entries()) appel("partie_jouer", { id: partie.id, nom: "ida", mot }, T0 + n * 1000);
  const r = appel("partie_deviner", { id: partie.id, nom: "ida", regle: "premiere(mot) = derniere(precedent)" }, T0 + 5000);
  assert.equal(r.juste, true, JSON.stringify(r.contre_exemple));
});

// ── Le coût d'une devinette ────────────────────────────────────────────
//
// Une devinette juste parcourt le corpus entier, contexte par contexte ; une
// devinette presque juste presque autant. Mesuré ici sur le pire cas : une
// règle qui lit `precedent`, cinquante-neuf mots joués.
let duree = 0;
await epreuve("une devinette se tranche vite", () => {
  PARTIES.clear();
  const { partie } = appel("partie_ouvrir", { nom: "garde", regle: "commence(mot, derniere(precedent))", amorce: "chat", limite: 60 });
  const mots = "tigre elephant table eau ours sel lune ete eau udon nid dos sapin nez zoo or roi ile elle eau".split(" ");
  for (let n = 0; n < 59; n++) appel("partie_jouer", { id: partie.id, nom: n % 2 ? "a1" : "b2", mot: mots[n % mots.length] }, T0 + n * 1000);
  const mesurer = (nom, regle) => {
    const t = performance.now();
    const r = appel("partie_deviner", { id: partie.id, nom, regle }, T0 + 70_000);
    duree = Math.max(duree, performance.now() - t);
    return r;
  };
  const presque = mesurer("a1", "premiere(mot) = derniere(precedent) et longueur(mot) < 20");
  assert.equal(presque.juste, false, "fausse sur les mots de vingt lettres et plus");
  assert.ok(presque.contre_exemple.mot.length >= 20);
  const juste = mesurer("b2", "lettre(mot, 1) = lettre(precedent, longueur(precedent))");
  assert.equal(juste.juste, true, JSON.stringify(juste.contre_exemple ?? juste.erreur));
  assert.ok(duree < 3000, `${duree.toFixed(0)} ms`);
});

// ── La fiche du registre MCP ───────────────────────────────────────────────
//
// server.json est ce que le registre officiel publie de nous. Une fiche qui
// annoncerait une autre version, une autre adresse ou une icône absente
// décrirait un serveur qui n'existe pas.
await epreuve("la fiche du registre MCP décrit le serveur qui existe", () => {
  const fiche = JSON.parse(readFileSync(new URL("../server.json", import.meta.url), "utf8"));
  assert.match(fiche.name, /^io\.github\.Oshinsu\/[a-zA-Z0-9._-]+$/);
  assert.ok(fiche.description.length <= 100, `description : ${fiche.description.length} caractères, le registre en refuse plus de 100`);
  assert.ok(fiche.title.length <= 100);
  assert.equal(fiche.version, VERSION_RECRE, "la fiche et initialize doivent annoncer la même version");
  assert.deepEqual(fiche.remotes.map((r) => [r.type, new URL(r.url).pathname]), [["streamable-http", "/api/recre"]]);
  for (const i of fiche.icons) assert.ok(existsSync(new URL(`../public${new URL(i.src).pathname}`, import.meta.url)), `icône absente : ${i.src}`);
  assert.equal(OUTILS_RECRE.length, 6);
});

// ── La mémoire durable ─────────────────────────────────────────────────
//
// Un faux Redis qui parle l'API REST d'Upstash, juste assez pour la récré.
// Les lectures répondent en dix millisecondes et l'écriture conditionnelle en
// une : des coups lancés ensemble lisent donc tous la même version, et se
// disputent l'écriture. C'est le cas qu'on veut voir tenir.
function fauxRedis() {
  const cles = new Map();
  const index = new Map();
  const stats = { ecritures: 0, conflits: 0 };
  const lire = (k) => cles.get(k) ?? null;
  const executer = ([commande, ...a]) => {
    for (const x of a) assert.equal(typeof x, "string", "l'API REST reçoit des chaînes");
    switch (commande) {
      case "GET": return lire(a[0]);
      case "MGET": return a.map(lire);
      case "ZREVRANGE":
        return [...index].sort((x, y) => y[1] - x[1]).slice(+a[1], +a[2] === -1 ? undefined : +a[2] + 1).map(([m]) => m);
      case "ZREM":
        for (const m of a.slice(1)) index.delete(m);
        return a.length - 1;
      case "EVAL": {
        assert.match(a[0], /cjson\.decode/);
        const [, , cle, , revisionCle, valeur, versionLue, duree, score, membre, revisionLue] = a;
        assert.equal(duree, String((REGLAGES.jours_de_conservation + 1) * 86400));
        const revision = Number(lire(revisionCle) ?? 0);
        if (revisionLue !== "" && revision !== Number(revisionLue)) return stats.conflits++, 0;
        const actuelle = lire(cle);
        if ((actuelle ? JSON.parse(actuelle).v : 0) !== Number(versionLue)) return stats.conflits++, 0;
        cles.set(cle, valeur);
        index.set(membre, Number(score));
        cles.set(revisionCle, String(revision + 1));
        return stats.ecritures++, 1;
      }
      default:
        throw new Error(`commande inattendue : ${commande}`);
    }
  };
  const serveur = createServer((req, res) => {
    let corps = "";
    req.on("data", (d) => (corps += d));
    req.on("end", () => {
      if (req.headers.authorization !== "Bearer jeton-essai") return res.end(JSON.stringify({ error: "WRONGPASS" }));
      const commande = JSON.parse(corps);
      setTimeout(() => {
        try {
          res.end(JSON.stringify({ result: executer(commande) }));
        } catch (e) {
          res.end(JSON.stringify({ error: e.message }));
        }
      }, commande[0] === "EVAL" ? 1 : 10);
    });
  });
  return { serveur, cles, index, stats };
}

const faux = fauxRedis();
await new Promise((ok) => faux.serveur.listen(0, "127.0.0.1", ok));
process.env.KV_REST_API_URL = `http://127.0.0.1:${faux.serveur.address().port}`;
process.env.KV_REST_API_TOKEN = "jeton-essai";
const durable = (nom, args, t = T0) => traiter(nom, args, null, t);

await epreuve("la mémoire durable tient une partie entière, hors du processus", async () => {
  PARTIES.clear();
  assert.equal(memoire(), MEMOIRE_DURABLE);
  const o = await durable("partie_ouvrir", { nom: "perec", regle: "triees(mot) = mot", amorce: "bijou" });
  assert.equal(o.ouverte, true, JSON.stringify(o));
  const id = o.partie.id;
  assert.equal(PARTIES.size, 0, "avec une mémoire durable, rien ne reste dans le processus");
  assert.equal((await durable("partie_jouer", { id, nom: "zoe", mot: "chou" }, T0 + minute)).accepte, true);
  assert.equal((await durable("partie_lire", { id }, T0 + 2 * minute)).coups.length, 1);

  const liste = await regarder(null, T0 + 2 * minute);
  assert.deepEqual(liste.map((p) => p.id), [id]);
  const regardee = await regarder(id, T0 + 2 * minute);
  assert.equal(regardee.regle, undefined, "les gradins ne voient pas la règle d'une partie en cours");

  const entree = await durable("recre_entrer", {}, T0 + 3 * minute);
  assert.equal(entree.parties_en_cours.length, 1);

  const fin = await durable("partie_deviner", { id, nom: "zoe", regle: "mot = triees(mot)" }, T0 + 4 * minute);
  assert.equal(fin.juste, true, JSON.stringify(fin));
  const relue = JSON.parse(faux.cles.get(`recre:partie:${id}`));
  assert.equal(relue.p.etat, "trouvee");
  assert.equal(relue.v, 3, "ouverture, coup, devinette : trois écritures");
  assert.equal(`sha256:${sha256(`${fin.partie.regle}\n${fin.partie.sel}`)}`, fin.partie.empreinte);
});

await epreuve("des coups joués au même instant ne se perdent ni ne se doublent", async () => {
  const o = await durable("partie_ouvrir", { nom: "garde", regle: "double(mot)", amorce: "pomme" });
  const id = o.partie.id;
  const avant = faux.stats.conflits;
  const coups = [["ana", "chat"], ["bea", "lune"], ["cyd", "arbre"], ["dan", "ciel"]];
  const r = await Promise.all(coups.map(([nom, mot]) => durable("partie_jouer", { id, nom, mot }, T0 + minute)));
  for (const x of r) assert.equal(x.erreur, undefined, JSON.stringify(x));
  assert.ok(faux.stats.conflits > avant, "les quatre coups ont lu la même version : il devait y avoir conflit");
  const v = await durable("partie_lire", { id }, T0 + 2 * minute);
  assert.deepEqual(v.coups.map((c) => c.n), [1, 2, 3, 4]);
  assert.deepEqual(v.coups.map((c) => c.mot).sort(), coups.map(([, m]) => m).sort(), "chaque mot une fois, aucun perdu");
});

await epreuve("des ouvertures simultanées respectent le plafond par ouvreur", async () => {
  const ouvertures = await Promise.all(Array.from({ length: 4 }, () =>
    durable("partie_ouvrir", { nom: "qa-ouvertures", regle: "double(mot)", amorce: "pomme" }, T0 + minute)
  ));
  assert.equal(ouvertures.filter((o) => o.ouverte).length, REGLAGES.parties_ouvertes_par_nom_max);
  assert.equal(ouvertures.filter((o) => o.erreur?.includes("parties en cours ouvertes")).length, 1);
});

await epreuve("une requête plus ancienne ne fait pas reculer l'activité de la partie", async () => {
  const o = await durable("partie_ouvrir", { nom: "qa-horloge", regle: "double(mot)", amorce: "pomme" });
  const id = o.partie.id;
  await durable("partie_jouer", { id, nom: "horloge-un", mot: "lune" }, T0 + 2 * minute);
  await durable("partie_jouer", { id, nom: "horloge-deux", mot: "terre" }, T0 + minute);
  const v = await durable("partie_lire", { id }, T0 + 3 * minute);
  assert.equal(v.derniere_activite, new Date(T0 + 2 * minute).toISOString());
  assert.equal(v.coups_joues, 2);
  const fin = await durable("partie_deviner", { id, nom: "horloge-trois", regle: "double(mot)" }, T0 + minute);
  assert.equal(fin.juste, true);
  assert.equal(fin.partie.derniere_activite, v.derniere_activite);
  assert.equal(fin.partie.close_le, v.derniere_activite);
});

await epreuve("les clôtures récentes ne masquent pas une limite d'ouverture déjà atteinte", async () => {
  const modele = [...faux.cles].find(([cle]) => cle.startsWith("recre:partie:"))[1];
  for (let n = 0; n < 205; n++) {
    const id = `r_fixture${n}`;
    const rangee = JSON.parse(modele);
    rangee.p.id = id;
    rangee.p.etat = "non_trouvee";
    rangee.p.derniere_activite = new Date(T0 + 4 * minute).toISOString();
    rangee.p.close_le = rangee.p.derniere_activite;
    faux.cles.set(`recre:partie:${id}`, JSON.stringify(rangee));
    faux.index.set(id, T0 + 4 * minute);
  }
  const r = await durable("partie_ouvrir", { nom: "qa-ouvertures", regle: "double(mot)", amorce: "pomme" }, T0 + 5 * minute);
  assert.match(r.erreur, /parties en cours ouvertes/);
});

await epreuve("une mémoire qui refuse fait échouer l'appel, franchement", async () => {
  process.env.KV_REST_API_TOKEN = "mauvais-jeton";
  await assert.rejects(durable("partie_lire", {}), /redis/);
  process.env.KV_REST_API_TOKEN = "jeton-essai";
});

delete process.env.KV_REST_API_URL;
delete process.env.KV_REST_API_TOKEN;
faux.serveur.close();

await epreuve("sans mémoire durable, la récré retombe sur le processus, et le dit", async () => {
  PARTIES.clear();
  assert.equal(memoire(), MEMOIRE_PROCESSUS);
  const o = await traiter("partie_ouvrir", { nom: "solo" }, null, T0);
  assert.equal(PARTIES.size, 1);
  assert.equal((await regarder(o.partie.id, T0)).id, o.partie.id);
});

// ── Verdict ────────────────────────────────────────────────────────────
PARTIES.clear();
if (fautes.length === 0) {
  console.log(`Récré — ${tenues} épreuves tenues. Devinette la plus lente : ${duree?.toFixed(0)} ms.`);
  process.exit(0);
}
console.error(`Récré — ${fautes.length} épreuve(s) manquée(s), ${tenues} tenue(s) :\n`);
for (const f of fautes) console.error("  " + f);
process.exit(1);

/**
 * Le scanner de cartes d'agent — la mesure que le desk Protocoles réclamait.
 *
 * IRIS a écrit, dans le numéro zéro, que personne ne publie le taux de cartes
 * A2A signées et valides, et que LIPIKA ne l'avait pas non plus. Ce script le
 * produit, avec sa méthode, son échantillon et son code — les trois conditions
 * que le desk s'impose : « si personne ne peut refaire la mesure, elle ne se
 * publie pas ».
 *
 *   node outils/scanner.mjs                  scanne la liste par défaut
 *   node outils/scanner.mjs --liste f.txt    un domaine par ligne
 *
 * Ce qu'il vérifie, dans l'ordre, et ce qu'il consigne à chaque échec :
 *   1. la carte existe-t-elle, à l'un des trois chemins connus
 *   2. est-ce du JSON, et déclare-t-elle une version de protocole
 *   3. porte-t-elle une signature (JWS détachée, champ `signatures`, ou notre
 *      forme `signature.value`)
 *   4. le JWKS annoncé est-il résolvable
 *   5. la signature valide-t-elle contre cette clé
 *
 * Aucune donnée n'est inventée : un domaine injoignable est consigné
 * `injoignable`, pas absent. Sortie : donnees/mesures/cartes-a2a.json
 */

import { writeFileSync, mkdirSync, readFileSync } from "node:fs";
import { createPublicKey, verify as verifierSignature, createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const CHEMINS = ["/.well-known/agent-card.json", "/.well-known/agent.json", "/agent-card.json"];
const DELAI = 12000;

/**
 * L'échantillon vit dans `donnees/mesures/echantillon-cartes.json`, pas ici.
 * Un taux d'adoption sans la liste de ce qui a été interrogé n'est pas une
 * mesure, c'est une impression : mettre l'échantillon en données le rend
 * citable, diffable d'une passe à l'autre, et rejouable par un tiers qui n'a
 * pas à lire notre code pour savoir qui nous avons appelé.
 */
const ECHANTILLON = JSON.parse(
  readFileSync(join(RACINE, "donnees", "mesures", "echantillon-cartes.json"), "utf8")
).cibles;

async function tirer(url) {
  const ctrl = new AbortController();
  const t = setTimeout(() => ctrl.abort(), DELAI);
  try {
    const r = await fetch(url, {
      signal: ctrl.signal,
      redirect: "follow",
      headers: { accept: "application/json", "user-agent": "LIPIKA-scanner/0.1 (desk protocoles)" },
    });
    const texte = await r.text();
    return { statut: r.status, type: r.headers.get("content-type") || "", texte };
  } catch (e) {
    return { erreur: e.name === "AbortError" ? "delai depasse" : e.message };
  } finally {
    clearTimeout(t);
  }
}

function detecterSignature(carte) {
  if (carte && typeof carte === "object") {
    if (carte.signatures && Array.isArray(carte.signatures) && carte.signatures.length) return "jws-detachee";
    if (carte.signature && typeof carte.signature === "object" && carte.signature.value) return "champ-signature";
    if (typeof carte.signature === "string" && carte.signature.length > 40) return "champ-signature";
  }
  return null;
}

function corpsCanonique(v) {
  if (v === null || typeof v !== "object") return JSON.stringify(v);
  if (Array.isArray(v)) return "[" + v.map(corpsCanonique).join(",") + "]";
  return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + corpsCanonique(v[k])).join(",") + "}";
}

async function examiner(cible) {
  const resultat = {
    domaine: cible.domaine,
    categorie: cible.categorie,
    carte_trouvee: false,
    chemin: null,
    statut_http: null,
    version_declaree: null,
    signature: null,
    jwks_resolvable: null,
    signature_valide: null,
    competences: null,
    note: null,
  };

  for (const chemin of CHEMINS) {
    const r = await tirer("https://" + cible.domaine + chemin);
    if (r.erreur) {
      resultat.note = resultat.note ?? r.erreur;
      continue;
    }
    resultat.statut_http = r.statut;
    if (r.statut !== 200) continue;

    let carte;
    try {
      carte = JSON.parse(r.texte);
    } catch {
      resultat.note = "réponse 200 mais pas du JSON";
      continue;
    }
    if (!carte || typeof carte !== "object" || Array.isArray(carte)) {
      resultat.note = "JSON sans objet de carte";
      continue;
    }

    resultat.carte_trouvee = true;
    resultat.chemin = chemin;
    resultat.note = null;
    resultat.version_declaree = carte.protocolVersion ?? carte.version ?? null;
    resultat.competences = Array.isArray(carte.skills) ? carte.skills.length : null;
    resultat.signature = detecterSignature(carte);

    if (resultat.signature === "champ-signature" && carte.signature?.jwks) {
      const urlJwks = carte.signature.jwks.startsWith("http")
        ? carte.signature.jwks
        : "https://" + cible.domaine + carte.signature.jwks;
      const j = await tirer(urlJwks);
      if (!j.erreur && j.statut === 200) {
        try {
          const jwks = JSON.parse(j.texte);
          resultat.jwks_resolvable = true;
          const { signature, ...reste } = carte;
          const pub = createPublicKey({ key: jwks.keys[0], format: "jwk" });
          const octets = Buffer.from(corpsCanonique(reste), "utf8");
          resultat.signature_valide = verifierSignature(
            null,
            octets,
            pub,
            Buffer.from(signature.value, "base64url")
          );
          if (!resultat.signature_valide) {
            resultat.note =
              "signature présente et clé résolvable, mais la validation échoue sur la carte servie — " +
              "le corps signé n'est pas la carte entière (voir méthode)";
          }
        } catch (e) {
          resultat.jwks_resolvable = false;
          resultat.note = "JWKS illisible : " + e.message;
        }
      } else {
        resultat.jwks_resolvable = false;
      }
    }
    break;
  }
  return resultat;
}

async function enParallele(liste, n, f) {
  const sortie = [];
  let i = 0;
  const ouvriers = Array.from({ length: n }, async () => {
    while (i < liste.length) {
      const k = i++;
      sortie[k] = await f(liste[k]);
      process.stdout.write(".");
    }
  });
  await Promise.all(ouvriers);
  return sortie;
}

const arg = process.argv.indexOf("--liste");
const cibles =
  arg > -1
    ? readFileSync(process.argv[arg + 1], "utf8")
        .split(/\r?\n/)
        .filter(Boolean)
        .map((d) => ({ domaine: d.trim(), categorie: "liste" }))
    : ECHANTILLON;

let precedente = null;
try {
  precedente = JSON.parse(readFileSync(join(RACINE, "donnees", "mesures", "cartes-a2a.json"), "utf8"));
} catch {}

console.log(`Scan de ${cibles.length} domaines, ${CHEMINS.length} chemins chacun.`);
const debut = new Date();
const resultats = await enParallele(cibles, 6, examiner);
process.stdout.write("\n");

const trouvees = resultats.filter((r) => r.carte_trouvee);
const signees = trouvees.filter((r) => r.signature);
const valides = signees.filter((r) => r.signature_valide === true);

const mesure = {
  _: "Mesure produite par outils/scanner.mjs. Méthode, échantillon et code publics : la mesure est rejouable par un tiers.",
  mesure_le: debut.toISOString(),
  duree_ms: Date.now() - debut.getTime(),
  methode: {
    chemins_testes: CHEMINS,
    delai_ms: DELAI,
    echantillon: "de commodité, nommé — pas un tirage aléatoire",
    signature_consideree_valide:
      "signature détachée vérifiée contre le JWKS annoncé par la carte, sur le corps canonique de la carte privée de son champ signature",
    limite:
      "Une carte peut être signée selon une convention que ce scanner ne connaît pas. L'absence de signature détectée n'est donc pas une preuve d'absence de signature — elle est une absence de signature détectable par un tiers, ce qui est la propriété utile.",
  },
  totaux: {
    domaines: resultats.length,
    cartes_trouvees: trouvees.length,
    cartes_signees: signees.length,
    signatures_valides: valides.length,
    jwks_resolvables: resultats.filter((r) => r.jwks_resolvable === true).length,
    taux_de_carte: +(trouvees.length / resultats.length).toFixed(4),
    taux_de_signature: trouvees.length ? +(signees.length / trouvees.length).toFixed(4) : null,
  },
  // La distribution par catégorie est le seul chiffre comparable à l'intérieur
  // de l'échantillon : le taux global, lui, ne vaut que pour cet échantillon.
  par_categorie: Object.fromEntries(
    [...new Set(resultats.map((r) => r.categorie))].sort().map((c) => {
      const dans = resultats.filter((r) => r.categorie === c);
      const avec = dans.filter((r) => r.carte_trouvee);
      return [
        c,
        {
          domaines: dans.length,
          cartes: avec.length,
          signees: avec.filter((r) => r.signature).length,
          versions: [...new Set(avec.map((r) => String(r.version_declaree)).filter((v) => v !== "null"))].sort(),
        },
      ];
    })
  ),
  // Ce que la passe précédente avait trouvé. Une mesure qui ne garde pas la
  // trace de la précédente ne peut pas dire si le parc bouge.
  mesure_precedente: precedente
    ? { mesure_le: precedente.mesure_le, totaux: precedente.totaux }
    : null,
  resultats,
};

mkdirSync(join(RACINE, "donnees", "mesures"), { recursive: true });
const chemin = join(RACINE, "donnees", "mesures", "cartes-a2a.json");
writeFileSync(chemin, JSON.stringify(mesure, null, 2) + "\n");

console.log(
  `${resultats.length} domaines · ${trouvees.length} cartes trouvées · ${signees.length} signées · ` +
    `${valides.length} signatures valides`
);
console.log("empreinte du résultat :", createHash("sha256").update(JSON.stringify(mesure.resultats)).digest("hex").slice(0, 16));
console.log("→ donnees/mesures/cartes-a2a.json");

/**
 * Les cartes de presse de LIPIKA, réellement signées.
 *
 * Le desk Protocoles a publié qu'aucune des cartes d'agent auditées ailleurs
 * n'était signée. Refaire le reproche sans signer les siennes aurait été bavard.
 *
 *   node outils/signer.mjs --generer    crée la paire ed25519 (une seule fois)
 *   node outils/signer.mjs              signe les six cartes
 *   node outils/signer.mjs --verifier   revérifie tout depuis la clé publique
 *
 * La clé privée vit dans .cles/ — gitignoré. La clé publique est publiée en JWK,
 * servie à /.well-known/jwks.json. Aucune dépendance : node:crypto suffit.
 */

import { generateKeyPairSync, createPrivateKey, createPublicKey, sign, verify, createHash } from "node:crypto";
import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
import { corpsIdentiteCarte, corpsIdentiteJournal } from "../lib/corps-signes.mjs";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");
const DOSSIER_CLES = join(RACINE, ".cles");
const PRIVEE = join(DOSSIER_CLES, "lipika-ed25519.priv.pem");
const JWKS = join(RACINE, "donnees", "jwks.json");
const SIGNATURES = join(RACINE, "donnees", "signatures.json");

const b64url = (buf) => Buffer.from(buf).toString("base64url");

/** JSON canonique : clés triées, pas d'espace. Deux machines doivent obtenir le même octet. */
export function canonique(v) {
  if (v === null || typeof v !== "object") return JSON.stringify(v);
  if (Array.isArray(v)) return "[" + v.map(canonique).join(",") + "]";
  const cles = Object.keys(v).sort();
  return "{" + cles.map((k) => JSON.stringify(k) + ":" + canonique(v[k])).join(",") + "}";
}

function empreinteJwk(jwk) {
  // RFC 7638, adapté aux clés OKP : les membres requis, triés.
  const requis = { crv: jwk.crv, kty: jwk.kty, x: jwk.x };
  return b64url(createHash("sha256").update(canonique(requis)).digest());
}

function genererPaire() {
  mkdirSync(DOSSIER_CLES, { recursive: true });
  if (existsSync(PRIVEE)) {
    console.log("Clé déjà présente : .cles/lipika-ed25519.priv.pem — rien à faire.");
  } else {
    const { privateKey } = generateKeyPairSync("ed25519");
    writeFileSync(PRIVEE, privateKey.export({ type: "pkcs8", format: "pem" }));
    console.log("Paire ed25519 créée. La privée reste dans .cles/, qui est gitignoré.");
  }
  const pub = createPublicKey(createPrivateKey(readFileSync(PRIVEE, "utf8")));
  const jwk = pub.export({ format: "jwk" });
  const kid = empreinteJwk(jwk);
  const jwks = { keys: [{ ...jwk, kid, alg: "EdDSA", use: "sig" }] };
  writeFileSync(JWKS, JSON.stringify(jwks, null, 2) + "\n");
  console.log(`Clé publique écrite dans donnees/jwks.json — kid ${kid}`);
  return { kid };
}

/** Le corps signé d'une carte : l'identité, pas le décor. */
export function corpsDeCarte(j, publication) {
  return corpsIdentiteCarte(j, publication);
}

export function corpsDuJournal(publication, journalistes) {
  return corpsIdentiteJournal(publication, journalistes,
    JSON.parse(readFileSync(join(RACINE, "donnees", "outils.json"), "utf8"))
      .outils.filter((o) => o.carte)
      .map((o) => o.name)
  );
}

function signerTout() {
  if (!existsSync(PRIVEE)) {
    console.error("Aucune clé privée. Lancer d'abord : npm run cles");
    process.exit(1);
  }
  const cle = createPrivateKey(readFileSync(PRIVEE, "utf8"));
  const jwks = JSON.parse(readFileSync(JWKS, "utf8"));
  const kid = jwks.keys[0].kid;
  const d = JSON.parse(readFileSync(join(RACINE, "donnees", "journalistes.json"), "utf8"));

  const signatures = { kid, alg: "EdDSA", signe_le: new Date().toISOString(), cartes: {} };

  const poser = (id, corps) => {
    const octets = Buffer.from(canonique(corps), "utf8");
    signatures.cartes[id] = {
      sha256: createHash("sha256").update(octets).digest("hex"),
      signature: b64url(sign(null, octets, cle)),
    };
  };

  poser("lipika", corpsDuJournal(d.publication, d.journalistes));
  for (const j of d.journalistes) poser(j.id, corpsDeCarte(j, d.publication));

  writeFileSync(SIGNATURES, JSON.stringify(signatures, null, 2) + "\n");
  console.log(`${Object.keys(signatures.cartes).length} cartes signées — kid ${kid}`);
}

/** Le vérificateur. Trente lignes, aucune dépendance : c'est tout ce qu'il fallait. */
function verifierTout() {
  const jwks = JSON.parse(readFileSync(JWKS, "utf8"));
  const pub = createPublicKey({ key: jwks.keys[0], format: "jwk" });
  const sig = JSON.parse(readFileSync(SIGNATURES, "utf8"));
  const d = JSON.parse(readFileSync(join(RACINE, "donnees", "journalistes.json"), "utf8"));

  const corps = { lipika: corpsDuJournal(d.publication, d.journalistes) };
  for (const j of d.journalistes) corps[j.id] = corpsDeCarte(j, d.publication);

  let bonnes = 0;
  const mauvaises = [];
  for (const [id, c] of Object.entries(corps)) {
    const enregistree = sig.cartes[id];
    if (!enregistree) {
      mauvaises.push(`${id} : aucune signature`);
      continue;
    }
    const octets = Buffer.from(canonique(c), "utf8");
    const ok = verify(null, octets, pub, Buffer.from(enregistree.signature, "base64url"));
    if (ok) bonnes += 1;
    else mauvaises.push(`${id} : signature invalide — la carte a changé depuis`);
  }
  const total = Object.keys(corps).length;
  console.log(`Cartes vérifiées : ${bonnes}/${total} — kid ${sig.kid}`);
  for (const m of mauvaises) console.error("  " + m);
  process.exit(mauvaises.length === 0 ? 0 : 1);
}

const estPointDEntree = process.argv[1] && process.argv[1].endsWith("signer.mjs");
if (estPointDEntree) {
  const arg = process.argv[2];
  if (arg === "--generer") genererPaire();
  else if (arg === "--verifier") verifierTout();
  else signerTout();
}

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { delivrer, relire } from '../lib/accreditation.ts';

test('les accréditations signées tiennent et une altération ne tient pas',()=>{
  const ancien=process.env.LIPIKA_SECRET;
  process.env.LIPIKA_SECRET='secret-uniquement-pour-les-tests-lipika-20261027';
  try {
    const token=delivrer('agent.example','agent_identifie');
    assert.equal(token.secret_par_defaut,false);
    assert.equal(relire(token.accreditation).domaine,'agent.example');
    assert.equal(relire(token.accreditation).niveau,'agent_identifie');
    assert.equal(relire(token.accreditation+'.extra'),null);
    const [body,signature]=token.accreditation.split('.');
    assert.equal(relire(Buffer.from('autre.example|agent_verifie|2099-01-01').toString('base64url')+'.'+signature),null);
    assert.equal(relire(body+'.fausse-signature'),null);
    assert.equal(relire(delivrer('agent.example','agent_identifie',-1).accreditation),null);
  } finally {if(ancien===undefined)delete process.env.LIPIKA_SECRET;else process.env.LIPIKA_SECRET=ancien;}
});
test('la production refuse de fabriquer une identité avec le secret public de démonstration',()=>{
  const ancien=process.env.LIPIKA_SECRET;const vercel=process.env.VERCEL;
  delete process.env.LIPIKA_SECRET;process.env.VERCEL='1';
  try {assert.throws(()=>delivrer('agent.example','agent_verifie'),/non configurée/);}
  finally {if(ancien===undefined)delete process.env.LIPIKA_SECRET;else process.env.LIPIKA_SECRET=ancien;if(vercel===undefined)delete process.env.VERCEL;else process.env.VERCEL=vercel;}
});

import assert from "node:assert/strict";
import { test } from "node:test";
import { evaluerFraicheur } from "../lib/fraicheur.mjs";

test("l'échéance et la date d'évaluation sont distinctes, aux frontières UTC", () => {
  const avant = evaluerFraicheur("2026-09-12", 30, Date.parse("2026-10-11T23:59:59Z"));
  assert.equal(avant.perime_le, "2026-10-12");
  assert.equal(avant.evaluee_au, "2026-10-11");
  assert.equal(avant.jours_restants, 1);
  assert.equal(avant.perime, false);
  const jour = evaluerFraicheur("2026-09-12", 30, Date.parse("2026-10-12T00:00:00Z"));
  assert.equal(jour.jours_restants, 0);
  assert.equal(jour.perime, true);
  const apres = evaluerFraicheur("2026-09-12", 30, Date.parse("2026-10-27T19:00:00Z"));
  assert.equal(apres.jours_restants, -15);
  assert.equal(apres.evaluee_au, "2026-10-27");
  assert.equal(apres.perime, true);
});

test("le fuseau du lecteur ne déplace pas l'évaluation et une date figée reste datée", () => {
  const a = evaluerFraicheur("2026-09-12", 365, Date.parse("2026-10-27T20:00:00-04:00"));
  const b = evaluerFraicheur("2026-09-12", 365, Date.parse("2026-10-28T00:00:00Z"));
  assert.deepEqual(a, b);
  assert.equal(a.evaluee_au, "2026-10-28");
  assert.equal(a.jours_restants, 319);
  assert.throws(() => evaluerFraicheur("2026-09-12", 30, NaN), /Horloge invalide/);
});

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { lireRpc, lireAppel } from '../lib/json-rpc.ts';

const requete = body => new Request('https://lipika.example/api/mcp', { method:'POST', body:JSON.stringify(body) });
test('les corps qui causaient un 500 deviennent des erreurs JSON-RPC explicites', async()=>{
  for(const body of [null,[],false,42,'texte',{}, {jsonrpc:'1.0',id:1,method:'ping'}, {jsonrpc:'2.0',id:{},method:'ping'}, {jsonrpc:'2.0',id:1,method:'ping',params:[]}]){
    const r=await lireRpc(requete(body)); assert.ok(r instanceof Response);
    const d=await r.json();assert.equal(d.error.code,-32600);assert.equal(d.jsonrpc,'2.0');
  }
  const r=await lireRpc(new Request('https://lipika.example/api/mcp',{method:'POST',body:'{'}));
  assert.equal((await r.json()).error.code,-32700);
});
test('notifications reconnues avant exécution et identifiant zéro conservé',async()=>{
  const n=await lireRpc(requete({jsonrpc:'2.0',method:'ping'}));assert.equal(n.notification,true);
  for(const id of [0,'agent-1',null]){const r=await lireRpc(requete({jsonrpc:'2.0',method:'ping',id}));assert.equal(r.id,id);assert.equal(r.notification,false);}
});
test('les bornes du catalogue sont réellement appliquées aux appels',()=>{
  const outils=[{name:'chercher',inputSchema:{type:'object',properties:{q:{type:'string',minLength:1},limite:{type:'integer',minimum:1,maximum:100}},required:['q']}}];
  for(const p of [{name:'inconnu'}, {name:'chercher'}, {name:'chercher',arguments:null}, {name:'chercher',arguments:{q:''}}, ...[-1,0,1.5,101,'abc'].map(limite=>({name:'chercher',arguments:{q:'carte',limite}}))]) assert.ok('erreur' in lireAppel(p,outils));
  assert.deepEqual(lireAppel({name:'chercher',arguments:{q:'carte',limite:5}},outils),{nom:'chercher',args:{q:'carte',limite:5}});
});

/** Vérification externe : aucun import du signateur, du corpus ni d'une clé privée. */
import assert from "node:assert/strict";
import { createHash, createPublicKey, verify } from "node:crypto";
import { readFile, stat } from "node:fs/promises";
import { join } from "node:path";

const dossier = process.argv[2] === "--dossier" ? process.argv[3] : null;
const base = dossier ? null : process.argv[2];
if (!base && !dossier) throw new Error("Usage : node outils/test-preuves-publiques.mjs https://origine-lipika | --dossier out");
const charger = async (chemin) => {
  if (dossier) {
    let fichier = join(dossier, chemin.replace(/^\//, ""));
    if (!(await stat(fichier).catch(() => null))?.isFile()) fichier += ".json";
    return JSON.parse(await readFile(fichier, "utf8"));
  }
  const r = await fetch(new URL(chemin, base));
  assert.equal(r.status, 200, chemin);
  return r.json();
};
// Reconstruction indépendante depuis le seul objet public corps_signe.
function canoniquePublic(v) {
  if (v === null || typeof v !== "object") return JSON.stringify(v);
  if (Array.isArray(v)) return `[${v.map(canoniquePublic).join(",")}]`;
  return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canoniquePublic(v[k])}`).join(",")}}`;
}
const jwks = await charger("/.well-known/jwks.json");
let verifies = 0;
for (const chemin of ["/.well-known/agent-card.json", ...["ummon", "iris", "kuro", "nox", "mira-voss"].map((id) => `/machine/carte/${id}`)]) {
  const carte = await charger(chemin);
  const preuve = carte.preuve ?? carte.signature;
  assert.ok(preuve?.corps_signe && preuve.portee && preuve.canonicalisation, `Périmètre public manquant : ${chemin}`);
  const jwk = jwks.keys.find((k) => k.kid === preuve.kid);
  assert.ok(jwk, `Clé publique inconnue : ${chemin}`);
  const cle = createPublicKey({ key: jwk, format: "jwk" });
  const octets = Buffer.from(canoniquePublic(preuve.corps_signe), "utf8");
  const signature = Buffer.from(preuve.signature ?? preuve.value, "base64url");
  assert.equal(createHash("sha256").update(octets).digest("hex"), preuve.sha256, chemin);
  assert.equal(verify(null, octets, cle, signature), true, chemin);
  const altere = { ...preuve.corps_signe, editeur: "Identité altérée par le test" };
  assert.equal(verify(null, Buffer.from(canoniquePublic(altere)), cle, signature), false, `Altération acceptée : ${chemin}`);
  verifies++;
}
console.log(`${verifies}/6 preuves publiques vérifiées depuis corps_signe + JWKS ; 6/6 altérations refusées.`);

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { traiter, connexionDurable, memoire, inviter, PARTIES } from '../lib/recre.ts';
const cles=['VERCEL','KV_REST_API_URL','KV_REST_API_TOKEN','UPSTASH_REDIS_REST_URL','UPSTASH_REDIS_REST_TOKEN'];
test('un hébergement multi-instance sans stockage refuse une fausse création durable',async()=>{
  const avant=Object.fromEntries(cles.map(k=>[k,process.env[k]]));
  for(const k of cles)delete process.env[k];process.env.VERCEL='1';
  try {
    const nombre=PARTIES.size;
    const r=await traiter('partie_ouvrir',{nom:'qa-regression-stockage'},null);
    assert.match(r.erreur,/pause/);assert.equal(PARTIES.size,nombre);
    assert.match(memoire(),/indisponible/);
    assert.match(inviter().pour_commencer,/regle_essayer/);
    assert.doesNotMatch(inviter().pour_commencer,/partie_ouvrir/);
    const sandbox=await traiter('regle_essayer',{regle:'longueur(mot) > 2',mots:['chat']},null);
    assert.equal(sandbox.erreur,undefined);
    process.env.KV_REST_API_URL='https://ancien.example';process.env.UPSTASH_REDIS_REST_TOKEN='test-token';
    assert.equal(connexionDurable(),null,'Ne pas mélanger deux jeux de credentials incomplets');
    process.env.UPSTASH_REDIS_REST_URL='https://stockage.example/';
    assert.equal(connexionDurable().url,'https://stockage.example');
  } finally {for(const k of cles){if(avant[k]===undefined)delete process.env[k];else process.env[k]=avant[k];}}
});

/**
 * Régression des deux transports MCP, contre un serveur Node déjà démarré.
 * Aucune dépendance n'est ajoutée au produit. Le SDK officiel est un outil de QA :
 *   npm install --prefix .tmp/mcp-sdk --no-save --ignore-scripts @modelcontextprotocol/sdk@1.29.0
 *   LIPIKA_TEST_ORIGIN=http://localhost:4311 node outils/test-transport-http.mjs
 * Ou définir LIPIKA_TEST_SDK_DIR sur le dossier du paquet @modelcontextprotocol/sdk.
 * LIPIKA_TEST_OUTPUT peut désigner le reçu JSON. Aucun serveur n'est démarré ici.
 * Les seules requêtes portant une écriture sont des NOTIFICATIONS qui ne doivent
 * pas être exécutées. On vérifie leur absence dans les gradins observés ; cela
 * ne constitue pas une preuve de persistance Redis ou entre instances.
 */
import assert from 'node:assert/strict';
import fs from 'node:fs/promises';
import path from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';

const root = fileURLToPath(new URL('../', import.meta.url));
const origin = new URL(process.env.LIPIKA_TEST_ORIGIN ?? 'http://localhost:4311');
assert.ok(['http:', 'https:'].includes(origin.protocol), 'Origine HTTP(S) requise');
assert.ok(!origin.username && !origin.password && !origin.search && !origin.hash && origin.pathname === '/', 'Donner une origine, sans secret ni chemin');
const timeout = 15_000;
const headers = {
  'content-type': 'application/json', accept: 'application/json, text/event-stream',
  'user-agent': 'LIPIKA-BYSS-QA-Transport-20261027', 'x-lipika-essai': '1',
};
const receiptPath = process.env.LIPIKA_TEST_OUTPUT
  ? path.resolve(process.env.LIPIKA_TEST_OUTPUT)
  : path.join(root, '.tmp', 'transport-http', `${origin.hostname}-${origin.port || origin.protocol.slice(0,-1)}.json`);
const checks = [];
const read = async name => JSON.parse(await fs.readFile(path.join(root, 'donnees', name), 'utf8'));
const [catalog, stories, claims] = await Promise.all([read('outils.json'), read('stories.json'), read('claims.json')]);
const ids = { papier: stories.stories[0]?.id, affirmation: claims.claims[0]?.id };
assert.ok(ids.papier && ids.affirmation, 'IDs de fixtures publiques absents');
const unknownId = 'byss_qa_identifiant_inexistant_20261027';
let serial = 0;
const rpc = (method, params, id = ++serial) => ({ jsonrpc: '2.0', id, method, ...(params === undefined ? {} : { params }) });
const call = (name, args) => rpc('tools/call', { name, ...(args === undefined ? {} : { arguments: args }) });
const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
async function checkpoint(name, fn) {
  const started = Date.now();
  try {
    const detail = await fn(); checks.push({ name, ok: true, ms: Date.now()-started, ...(detail ? { detail } : {}) });
    console.log(`OK ${name}`); return true;
  } catch (error) {
    checks.push({ name, ok: false, ms: Date.now()-started, error: error.message });
    console.error(`ECHEC ${name} : ${error.message}`); return false;
  }
}
async function post(endpoint, body, raw = false) {
  const response = await fetch(new URL(endpoint, origin), {
    method: 'POST', headers, body: raw ? body : JSON.stringify(body), cache: 'no-store', signal: AbortSignal.timeout(timeout),
  });
  const text = await response.text();
  let json = null;
  if (text) { try { json = JSON.parse(text); } catch { assert.fail(`${endpoint} renvoie du contenu non JSON (${response.status})`); } }
  return { status: response.status, text, json, headers: response.headers };
}
async function protocolError(endpoint, body, code, status = 200, raw = false) {
  const r = await post(endpoint, body, raw);
  assert.equal(r.status, status); assert.equal(r.json?.jsonrpc, '2.0'); assert.equal(r.json?.error?.code, code);
  assert.equal(typeof r.json.error.message, 'string'); assert.ok(!Object.hasOwn(r.json, 'result'));
  assert.match(r.headers.get('cache-control') ?? '', /no-store/);
  return { status:r.status, code:r.json.error.code };
}
async function success(endpoint, message) {
  const r = await post(endpoint, message);
  assert.equal(r.status, 200); assert.equal(r.json?.jsonrpc, '2.0'); assert.equal(r.json?.id, message.id);
  assert.ok(!r.json.error); assert.ok(Object.hasOwn(r.json,'result'));
  assert.match(r.headers.get('cache-control') ?? '', /no-store/);
  return r.json.result;
}
function toolData(result) {
  assert.ok(object(result.structuredContent), 'structuredContent doit être un objet');
  const text = result.content?.find(item => item.type === 'text')?.text;
  assert.equal(typeof text,'string'); assert.deepEqual(JSON.parse(text),result.structuredContent);
  return result.structuredContent;
}
const expectedVersions = ['2026-07-28','2025-11-25','2025-06-18','2025-03-26'];
let defaultProtocol;
let observedTools = {};
for (const endpoint of ['/api/mcp', '/api/recre']) {
  const name = endpoint.slice(5);
  for (const version of expectedVersions) await checkpoint(`${name} négocie ${version}`, async()=>{
    const r=await success(endpoint,rpc('initialize',{protocolVersion:version,capabilities:{},clientInfo:{name:'byss-qa-transport',version:'1'}}));
    assert.equal(r.protocolVersion,version); return {version:r.protocolVersion,server:r.serverInfo.name};
  });
  await checkpoint(`${name} version inconnue : repli explicite`,async()=>{
    const r=await success(endpoint,rpc('initialize',{protocolVersion:'version-inconnue'}));
    assert.ok(expectedVersions.includes(r.protocolVersion)); assert.notEqual(r.protocolVersion,'version-inconnue');
    defaultProtocol ??= r.protocolVersion; assert.equal(r.protocolVersion,defaultProtocol); return {version:r.protocolVersion};
  });
  await checkpoint(`${name} version de protocole non textuelle`,()=>protocolError(endpoint,rpc('initialize',{protocolVersion:42}),-32602));
  for (const [label,body] of [
    ['null',null], ['tableau',[]], ['JSON-RPC 1.0',{jsonrpc:'1.0',id:1,method:'ping'}],
    ['id objet',{jsonrpc:'2.0',id:{x:1},method:'ping'}], ['params null',{jsonrpc:'2.0',id:1,method:'ping',params:null}],
  ]) await checkpoint(`${name} refuse ${label}`,()=>protocolError(endpoint,body,-32600,400));
  await checkpoint(`${name} refuse JSON illisible`,()=>protocolError(endpoint,'{',-32700,400,true));
  await checkpoint(`${name} conserve id zéro`,async()=>{await success(endpoint,rpc('ping',undefined,0));});
  await checkpoint(`${name} conserve id texte`,async()=>{await success(endpoint,rpc('ping',undefined,'byss-qa-id'));});
  for (const method of ['notifications/initialized','ping']) await checkpoint(`${name} notification ${method}`,async()=>{
    const r=await post(endpoint,{jsonrpc:'2.0',method});assert.equal(r.status,202);assert.equal(r.text,'');
  });
  await checkpoint(`${name} méthode inconnue`,()=>protocolError(endpoint,rpc('byss/unknown-method'),-32601));
  await checkpoint(`${name} outil inconnu`,()=>protocolError(endpoint,call('byss_unknown_tool',{}),-32602));
  await checkpoint(`${name} nom d’outil absent`,()=>protocolError(endpoint,rpc('tools/call',{arguments:{}}),-32602));
  const requiredTool=name==='mcp'?'lire_affirmation':'partie_jouer';
  await checkpoint(`${name} arguments null`,()=>protocolError(endpoint,call(requiredTool,null),-32602));
  await checkpoint(`${name} arguments requis manquants`,()=>protocolError(endpoint,call(requiredTool),-32602));
  await checkpoint(`${name} catalogue`,async()=>{
    const r=await success(endpoint,rpc('tools/list'));assert.ok(Array.isArray(r.tools));
    observedTools[name]=r.tools.map(t=>t.name).sort();assert.equal(new Set(observedTools[name]).size,observedTools[name].length);
    if(name==='mcp')assert.deepEqual(observedTools[name],catalog.outils.map(t=>t.name).sort());
    else { const manifest=await fetch(new URL('/machine/recre.json',origin),{headers,signal:AbortSignal.timeout(timeout)});assert.equal(manifest.status,200);assert.deepEqual(observedTools[name],(await manifest.json()).outils.map(t=>t.name).sort()); }
    return {names:observedTools[name]};
  });
  await checkpoint(`${name} GET SSE explicitement indisponible`,async()=>{
    const r=await fetch(new URL(endpoint,origin),{headers:{...headers,accept:'text/event-stream'},signal:AbortSignal.timeout(timeout)});
    assert.equal(r.status,405);assert.match(r.headers.get('allow')??'',/POST/);
  });
}

await checkpoint('journal liste sans arguments explicites',async()=>{
  const r=await success('/api/mcp',call('lire_papier'));const d=toolData(r);assert.equal(r.isError,false);
  assert.ok(Array.isArray(d.papiers)&&d.papiers.some(p=>p.id===ids.papier));return {papiers:d.papiers.length};
});
for(const [tool,id] of [['lire_papier',ids.papier],['lire_affirmation',ids.affirmation]]) {
  await checkpoint(`journal ${tool} réel`,async()=>{const r=await success('/api/mcp',call(tool,{id}));const d=toolData(r);assert.equal(r.isError,false);assert.equal(d.id,id);return {id:d.id};});
  await checkpoint(`journal ${tool} id inconnu isError`,async()=>{const r=await success('/api/mcp',call(tool,{id:unknownId}));const d=toolData(r);assert.equal(r.isError,true);assert.equal(typeof d.erreur,'string');});
}
for(const [label,args] of [
  ['q absent',{}],['q vide',{q:''}],['q espaces',{q:'   '}],['q null',{q:null}],['q trop long',{q:'x'.repeat(513)}],
  ...[-1,0,1.5,101,'2'].map(limite=>[`limite ${JSON.stringify(limite)}`,{q:'a',limite}]),
]) await checkpoint(`chercher refuse ${label}`,()=>protocolError('/api/mcp',call('chercher',args),-32602));
for(const limite of [1,100]) await checkpoint(`chercher limite ${limite}`,async()=>{
  const r=await success('/api/mcp',call('chercher',{q:'a',limite}));const d=toolData(r);assert.equal(r.isError,false);assert.ok(Array.isArray(d.resultats)&&d.resultats.length<=limite);assert.ok(d.total>=d.resultats.length);return {total:d.total,resultats:d.resultats.length};
});
for(const limite of [11,201]) await checkpoint(`récré limite ${limite} refusée avant création`,()=>protocolError('/api/recre',call('partie_ouvrir',{nom:'byss-qa-transport',regle:'non contient(mot, "e")',limite}),-32602));

// Une notification valide de tools/call ne doit pas exécuter l’outil.
// On observe les deux lectures de gradins ; on ne déduit rien sur Redis de ce contrôle.
const marker=`qa-notif-${Date.now().toString(36)}`;
await checkpoint('récré notification tools/call : 202, aucune partie QA observée',async()=>{
  const before=toolData(await success('/api/recre',call('partie_lire',{})));
  assert.ok(Array.isArray(before.parties));
  const body={jsonrpc:'2.0',method:'tools/call',params:{name:'partie_ouvrir',arguments:{nom:marker,regle:'non contient(mot, "e")',amorce:'chat',limite:12}}};
  const r=await post('/api/recre',body);assert.equal(r.status,202);assert.equal(r.text,'');
  const after=toolData(await success('/api/recre',call('partie_lire',{})));
  assert.ok(Array.isArray(after.parties));assert.ok(!after.parties.some(p=>p.gardien===marker||p.gardien?.nom===marker||p.ouverte_par?.nom===marker));
  return {marker,observedNewGames:0,persistenceNotAssessed:true};
});
await checkpoint('journal notification tools/call : 202 vide',async()=>{
  const r=await post('/api/mcp',{jsonrpc:'2.0',method:'tools/call',params:{name:'lire_papier',arguments:{id:ids.papier}}});assert.equal(r.status,202);assert.equal(r.text,'');
});

async function loadOfficialSdk() {
  const candidates=[process.env.LIPIKA_TEST_SDK_DIR,path.join(root,'.tmp/mcp-sdk/node_modules/@modelcontextprotocol/sdk'),path.join(root,'node_modules/@modelcontextprotocol/sdk')].filter(Boolean);
  for(const candidate of candidates){
    const dir=path.resolve(candidate);let pkg;
    try { pkg=JSON.parse(await fs.readFile(path.join(dir,'package.json'),'utf8')); } catch {continue;}
    assert.equal(pkg.name,'@modelcontextprotocol/sdk','Le chemin SDK ne désigne pas le paquet officiel');
    const [{Client},{StreamableHTTPClientTransport}]=await Promise.all([
      import(pathToFileURL(path.join(dir,'dist/esm/client/index.js')).href),
      import(pathToFileURL(path.join(dir,'dist/esm/client/streamableHttp.js')).href),
    ]);return {Client,StreamableHTTPClientTransport,version:pkg.version};
  }
  throw new Error('SDK MCP officiel absent : installer le paquet dans .tmp/mcp-sdk ou définir LIPIKA_TEST_SDK_DIR (aucune dépendance produit requise)');
}
let sdk;
await checkpoint('SDK officiel disponible',async()=>{sdk=await loadOfficialSdk();return {version:sdk.version};});
if(sdk) for(const [endpoint,key] of [['/api/mcp','mcp'],['/api/recre','recre']]) {
  const client=new sdk.Client({name:'LIPIKA-BYSS-QA-SDK',version:'1.0.0'});
  const transport=new sdk.StreamableHTTPClientTransport(new URL(endpoint,origin),{
    requestInit:{headers},
    fetch:(url,init={})=>fetch(url,{...init,signal:AbortSignal.any([...(init.signal?[init.signal]:[]),AbortSignal.timeout(timeout)])}),
    reconnectionOptions:{maxReconnectionDelay:1000,initialReconnectionDelay:1000,reconnectionDelayGrowFactor:1,maxRetries:0},
  });
  try {
    const connected=await checkpoint(`SDK ${key} connexion`,async()=>{await client.connect(transport);assert.equal(typeof client.getServerVersion()?.name,'string');return {server:client.getServerVersion()};});
    if(!connected)continue;
    await checkpoint(`SDK ${key} catalogue`,async()=>{const r=await client.listTools();assert.deepEqual(r.tools.map(t=>t.name).sort(),observedTools[key]);});
    if(key==='mcp') {
      await checkpoint('SDK lire_papier {} structuredContent objet',async()=>{const r=await client.callTool({name:'lire_papier',arguments:{}});const d=toolData(r);assert.equal(r.isError,false);assert.ok(Array.isArray(d.papiers)&&d.papiers.length>0);return {papiers:d.papiers.length};});
      await checkpoint('SDK lire_affirmation réelle',async()=>{const r=await client.callTool({name:'lire_affirmation',arguments:{id:ids.affirmation}});assert.equal(toolData(r).id,ids.affirmation);assert.equal(r.isError,false);});
      await checkpoint('SDK id inconnu est une erreur outil',async()=>{const r=await client.callTool({name:'lire_papier',arguments:{id:unknownId}});assert.equal(r.isError,true);assert.equal(typeof toolData(r).erreur,'string');});
    } else {
      await checkpoint('SDK récré règle sans mutation',async()=>{const r=await client.callTool({name:'regle_essayer',arguments:{regle:'non contient(mot, "e")',mots:['chat','été']}});const d=toolData(r);assert.notEqual(r.isError,true);assert.ok(object(d));});
      await checkpoint('SDK récré id inconnu est une erreur outil',async()=>{const r=await client.callTool({name:'partie_lire',arguments:{id:unknownId}});assert.equal(r.isError,true);assert.equal(typeof toolData(r).erreur,'string');});
    }
  } finally { await client.close().catch(()=>{}); }
}
const summary={origin:origin.origin,at:new Date().toISOString(),sdk:sdk?.version??null,fixtureIds:ids,passed:checks.filter(c=>c.ok).length,failed:checks.filter(c=>!c.ok).length,persistenceAssessed:false,checks};
await fs.mkdir(path.dirname(receiptPath),{recursive:true});await fs.writeFile(receiptPath,JSON.stringify(summary,null,2)+'\n');
console.log(`${summary.passed} contrôles positifs, ${summary.failed} échecs. Reçu : ${receiptPath}`);
if(summary.failed)process.exitCode=1;

/**
 * Les gardes de LIPIKA, exécutables.
 *
 * Ce fichier est la constitution du journal sous une forme qui refuse de compiler.
 * `npm run build` l'exécute avant `next build` : une règle violée arrête la
 * publication, elle ne produit pas un avertissement.
 *
 * Aucune dépendance. `node outils/verifier.mjs` depuis LIPIKA/site.
 * `node outils/autotest.mjs` casse chaque garde exprès et vérifie qu'elle tient.
 */

import { readFileSync, existsSync, readdirSync } from "node:fs";
import { createHash } from "node:crypto";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
import { canonique, corpsDuJournal } from "./signer.mjs";

const RACINE = join(dirname(fileURLToPath(import.meta.url)), "..");

export const STATUTS = ["etabli", "conteste", "non_corrobore", "non_etabli", "tombe"];
export const PLAFONDS = { etabli: 1.0, conteste: 0.7, non_corrobore: 0.5, non_etabli: 0.3, tombe: 0.1 };
export const VERIFICATIONS = [
  "document_primaire",
  "organisation_connue",
  "agent_verifie",
  "agent_identifie",
  "source_anonyme_verifiee",
  "non_verifie",
];
export const BLOCS = ["titre", "p", "liste", "tableau", "exergue", "chronologie", "claim", "correction"];
export const PREUVES = ["P", "S", "M"];
const CHAMPS_INTERDITS = ["vues", "likes", "followers", "partages", "engagement", "impressions", "score_popularite"];
/** Les relations du graphe. Une affirmation ne se joint qu'à travers elles. */
export const RELATIONS = ["depend_de", "contredit", "limite", "corrobore", "arbitre"];
/** Ce qu'une affirmation vaut tant que le panel ne l'a pas vue, et combien on en tolère. */
export const PLAFOND_EN_ATTENTE = 0.5;
export const PART_MAX_EN_ATTENTE = 0.1;
const MOTIFS_EXECUTABLES = [/<\s*script/i, /javascript\s*:/i, /\bon[a-z]+\s*=\s*["']/i, /data:text\/html/i];

function lireSiPresent(racine, n) {
  const f = join(racine, "donnees", n);
  return existsSync(f) ? JSON.parse(readFileSync(f, "utf8")) : null;
}

export function charger(racine = RACINE) {
  const lire = (n) => JSON.parse(readFileSync(join(racine, "donnees", n), "utf8"));
  return {
    sources: lire("sources.json"),
    claims: lire("claims.json"),
    stories: lire("stories.json"),
    journalistes: lire("journalistes.json"),
    registre: lire("registre.json"),
    doctrine: lire("doctrine.json"),
    entites: lire("entites.json"),
    relectures: lireSiPresent(racine, "relectures.json"),
    outils: lireSiPresent(racine, "outils.json"),
    signatures: lireSiPresent(racine, "signatures.json"),
    mesures: { cartes: lireSiPresent(racine, "mesures/cartes-a2a.json") },
    // Règle 26 : l'état de nos citations est une donnée du journal, pas une
    // annexe. On lit le fichier vivant — la question est « que savons-nous
    // aujourd'hui », pas « qu'avons-nous su ».
    citations: lireSiPresent(racine, "mesures/citations.json"),
  };
}

/** Renvoie la liste des manquements. Vide = le journal a le droit de paraître. */
export function verifier(d) {
  const fautes = [];
  const faute = (regle, quoi) => fautes.push({ regle, quoi });

  const sources = new Map(d.sources.sources.map((s) => [s.id, s]));
  const claims = new Map(d.claims.claims.map((c) => [c.id, c]));
  const stories = new Map(d.stories.stories.map((s) => [s.id, s]));
  const journalistes = new Map(d.journalistes.journalistes.map((j) => [j.id, j]));
  const previsions = new Map(d.registre.previsions.map((p) => [p.id, p]));
  const corrections = new Map(d.registre.corrections.map((c) => [c.id, c]));

  // ── Identifiants uniques ────────────────────────────────────────────────
  for (const [nom, liste] of [
    ["source", d.sources.sources],
    ["claim", d.claims.claims],
    ["story", d.stories.stories],
    ["journaliste", d.journalistes.journalistes],
  ]) {
    const vus = new Set();
    for (const o of liste) {
      const id = o.id;
      if (vus.has(id)) faute("ids", `identifiant ${nom} réutilisé : ${id}`);
      vus.add(id);
    }
  }

  // ── Règle 6 — une identité non vérifiée est affichée comme telle ────────
  for (const s of d.sources.sources) {
    if (!VERIFICATIONS.includes(s.verification))
      faute(6, `source ${s.id} : niveau de vérification absent ou inconnu (${s.verification})`);
    if (!PREUVES.includes(s.preuve))
      faute(6, `source ${s.id} : marque de preuve absente ou inconnue (${s.preuve})`);
    if (s.preuve === "P" && s.verification === "non_verifie")
      faute(6, `source ${s.id} : marquée [P] mais non vérifiée — contradiction`);
    // Un émetteur est une organisation, pas une chaîne : « LIPIKA, rédaction »
    // et « LIPIKA, desk Protocoles » ne sont pas deux voix.
    if (!s.emetteur_entite)
      faute(6, `source ${s.id} : émetteur sans identifiant d'entité — deux graphies feraient deux voix`);
    else if (!d.entites.entites.some((e) => e.id === s.emetteur_entite))
      faute(6, `source ${s.id} : émetteur inconnu au registre des entités (${s.emetteur_entite})`);
  }

  // ── Claims : source obligatoire, plafond de confiance, rattachement ─────
  for (const c of d.claims.claims) {
    if (!Array.isArray(c.sources) || c.sources.length === 0)
      faute(3, `claim ${c.id} : aucune source — un claim sans source n'est pas représentable`);
    for (const sid of c.sources || [])
      if (!sources.has(sid)) faute(3, `claim ${c.id} : source inconnue ${sid}`);

    if (!STATUTS.includes(c.statut)) faute(3, `claim ${c.id} : statut inconnu (${c.statut})`);
    const plafond = PLAFONDS[c.statut];
    if (plafond !== undefined && c.confiance > plafond + 1e-9)
      faute(3, `claim ${c.id} : confiance ${c.confiance} au-dessus du plafond ${plafond} du statut ${c.statut}`);
    if (c.confiance < 0 || c.confiance > 1) faute(3, `claim ${c.id} : confiance hors bornes`);
    if (!["principal", "secondaire"].includes(c.centralite))
      faute(3, `claim ${c.id} : centralité absente ou inconnue`);
    if (!stories.has(c.story)) faute(3, `claim ${c.id} : story inconnue ${c.story}`);

    // Règle 14 — une affirmation dit quand elle a été vérifiée.
    if (!/^\d{4}-\d{2}-\d{2}$/.test(c.verifie_le || ""))
      faute(14, `claim ${c.id} : pas de date de vérification — un lecteur ne peut pas juger sa fraîcheur`);
    if ("perime_le" in c)
      faute(14, `claim ${c.id} : date de péremption saisie à la main — elle est calculée depuis la politique publiée`);

    // Règle 7 — l'indépendance se calcule, elle ne se saisit pas.
    if ("independance_effective" in c)
      faute(7, `claim ${c.id} : independance_effective saisie à la main — elle est calculée`);
    if ("corroboration" in c && c.corroboration && "independance_effective" in c.corroboration)
      faute(7, `claim ${c.id} : independance_effective saisie à la main dans corroboration`);
  }

  // ── Stories ────────────────────────────────────────────────────────────
  const distribue = d.stories.numero.distribue === true;

  for (const s of d.stories.stories) {
    const auteur = journalistes.get(s.journaliste);
    const contra = journalistes.get(s.contradicteur);

    // Règle 3 — pas de carte, pas de publication.
    if (!auteur) faute(3, `story ${s.id} : journaliste inconnu ${s.journaliste}`);
    else {
      for (const champ of ["lignee", "autonomie", "instance", "fonction"])
        if (!auteur[champ]) faute(3, `story ${s.id} : la carte de ${s.journaliste} n'a pas de ${champ}`);
    }
    if (!contra) faute(12, `story ${s.id} : contradicteur inconnu ${s.contradicteur}`);
    if (auteur && contra && auteur.id === contra.id)
      faute(12, `story ${s.id} : le contradicteur est l'auteur`);

    // Règle 12 — conflit de lignée.
    if (auteur && contra && auteur.lignee && contra.lignee) {
      const labos = new Set(
        d.claims.claims.filter((c) => c.story === s.id).map((c) => c.sujet && c.sujet.laboratoire).filter(Boolean)
      );
      const conflitAuteur = labos.has(auteur.lignee.famille);
      const conflitContra = labos.has(contra.lignee.famille);
      if (conflitAuteur && contra.lignee.famille === auteur.lignee.famille)
        faute(12, `story ${s.id} : l'auteur couvre son propre laboratoire et le contradicteur est de la même famille`);
      if ((conflitAuteur || conflitContra) && !s.conflit_declare)
        faute(12, `story ${s.id} : conflit de lignée non imprimé dans le papier`);
    }

    // Règle 1 — aucun bloc ne porte d'instruction exécutable.
    for (const [i, bloc] of (s.corps || []).entries()) {
      if (!BLOCS.includes(bloc.type)) faute(1, `story ${s.id} : bloc ${i} de type non autorisé (${bloc.type})`);
      if (bloc.type === "claim" && !claims.has(bloc.id)) faute(1, `story ${s.id} : bloc ${i} cite un claim inconnu`);
      if (bloc.type === "correction" && !corrections.has(bloc.id))
        faute(1, `story ${s.id} : bloc ${i} cite une correction inconnue`);
      const textes = [bloc.texte, ...(bloc.items || []), ...(bloc.lignes || []).flat()].filter(
        (t) => typeof t === "string"
      );
      for (const t of textes)
        for (const motif of MOTIFS_EXECUTABLES)
          if (motif.test(t)) faute(1, `story ${s.id} : bloc ${i} contient un motif exécutable`);
    }

    // Règle 4 et 9 — un article est sa suite de versions, et elles ne se saisissent pas.
    if (!Array.isArray(s.versions) || s.versions.length === 0)
      faute(4, `story ${s.id} : aucune version — un objet sans historique n'a pas de page`);
    for (const v of s.versions || []) {
      if (!v.le || !v.type) faute(4, `story ${s.id} : version ${v.v} incomplète`);
      if ("hash" in v) faute(9, `story ${s.id} : version ${v.v} porte un hash saisi à la main`);
    }

    // UMMON, porte 5 — l'ardoise est obligatoire et non vide.
    if (s.etat === "publiee" && (!Array.isArray(s.ardoise) || s.ardoise.length === 0))
      faute(5, `story ${s.id} : publiée sans ardoise — une story sans zone d'ombre déclarée n'est pas rendable`);

    // Règle 5 — droit de réponse tracé, ou numéro non distribué.
    const dr = s.droit_de_reponse || {};
    const vise = (dr.destinataires_prevus || []).length > 0;
    if (s.etat === "publiee" && vise && dr.envoye !== true) {
      if (s.portes && s.portes["4"] === true)
        faute(5, `story ${s.id} : porte 4 déclarée franchie alors qu'aucun droit de réponse n'est parti`);
      if (distribue)
        faute(5, `story ${s.id} : distribuée sans droit de réponse envoyé — état interdit`);
      if (!dr.motif) faute(5, `story ${s.id} : droit de réponse non envoyé, sans motif écrit`);
    }

    // Prévision rattachée : critère écrit à la création.
    if (s.prevision) {
      const p = previsions.get(s.prevision);
      if (!p) faute(5, `story ${s.id} : prévision inconnue ${s.prevision}`);
      else if (!p.critere_de_resolution)
        faute(5, `prévision ${p.id} : pas de critère de résolution — le « je l'avais dit » redevient possible`);
    }
  }

  // ── Corrections ────────────────────────────────────────────────────────
  for (const c of d.registre.corrections) {
    if (!["mise_a_jour", "correction", "retractation"].includes(c.type))
      faute(4, `correction ${c.id} : type inconnu`);
    if (!["redaction", "mis_en_cause", "lecteur_agent", "lecteur_humain", "tiers", "relecture"].includes(c.origine))
      faute(4, `correction ${c.id} : origine absente ou inconnue`);
    if (c.type === "correction" && c.avant === c.apres)
      faute(4, `correction ${c.id} : rien n'a changé — c'est une mise à jour, pas une correction`);
    if (c.type === "mise_a_jour" && c.avant)
      faute(4, `correction ${c.id} : une mise à jour n'a pas d'avant — requalifier en correction`);
    if ("delai_minutes" in c) faute(4, `correction ${c.id} : délai saisi à la main — il est calculé`);
    if (c.claim && !claims.has(c.claim)) faute(4, `correction ${c.id} : claim inconnu ${c.claim}`);
  }

  // ── Règle 8 — aucun compteur d'engagement, nulle part ───────────────────
  const brut = JSON.stringify(d);
  for (const champ of CHAMPS_INTERDITS)
    if (new RegExp(`"${champ}"\\s*:`).test(brut))
      faute(8, `champ d'engagement présent dans les données : ${champ}`);

  // ── Règle 13 — la relecture contradictoire existe, et elle est a jour ───
  if (d.relectures) {
    const familles = new Set(d.relectures.lignees.map((l) => l.famille));
    if (familles.size < 5)
      faute(13, `relecture : ${familles.size} familles de modeles distinctes, il en faut 5`);
    if (d.relectures.mode !== "reel")
      faute(13, "relecture en mode simule — une monoculture mesuree sur une simulation ne mesure rien");
    // Une affirmation que le panel n'a pas vue n'arrête pas le journal : elle est
    // plafonnée, marquée, comptée. Ce qui arrête le journal, c'est d'en accumuler.
    //
    // Une exception, et c'est celle que la règle 13 énonce déjà pour l'abaissement :
    // une affirmation protégée par une source [P] ou [M] n'attend pas. Les
    // relecteurs ne voient pas les documents — le journal le publie lui-même en
    // c_0000074 — donc faire patienter une mesure que nous avons produite, dont le
    // fichier et le code sont publics, n'achèterait rien. Ce qui rend la porte
    // étroite, c'est la garde d'en face : une source [M] doit nommer un fichier
    // qui existe.
    const relus = new Set(d.relectures.par_affirmation.map((a) => a.claim));
    const protegee = (c) =>
      (c.sources || []).some((id) => ["P", "M"].includes(sources.get(id)?.preuve));
    const attente = d.claims.claims.filter((c) => !relus.has(c.id) && !protegee(c));
    for (const c of attente)
      if (c.confiance > PLAFOND_EN_ATTENTE + 1e-9)
        faute(
          13,
          `claim ${c.id} : jamais passe devant les cinq lignees, sans source [P] ni [M], et publie a ` +
            `${c.confiance} — le plafond d'attente est ${PLAFOND_EN_ATTENTE}`
        );
    const part = attente.length / Math.max(1, d.claims.claims.length);
    if (part > PART_MAX_EN_ATTENTE + 1e-9)
      faute(
        13,
        `relecture : ${attente.length} affirmations sur ${d.claims.claims.length} reposent sur la parole ` +
          `d'autrui et n'ont jamais vu le panel (${Math.round(part * 100)} %) — le journal publie plus vite ` +
          `que son contradictoire`
      );
  }

  // ── Règle 6 — une marque [M] nomme un fichier qui existe ───────────────
  //
  // C'est la garde qui paie l'exception ci-dessus. Sans elle, [M] deviendrait
  // le moyen le moins cher de se dispenser du contradictoire : il suffirait de
  // se citer soi-même. Avec elle, se dire « mesuré par nous » oblige à déposer
  // la mesure dans le dépôt, où un lecteur humain la lit et la rejoue.
  for (const s of d.sources.sources) {
    if (s.preuve !== "M") continue;
    if (!s.fichier) {
      faute(6, `source ${s.id} : marquée [M] sans fichier — une mesure qu'on ne peut pas ouvrir n'est pas une mesure`);
      continue;
    }
    // Le chemin s'écrit depuis la racine du site, pas depuis un poste de travail :
    // c'est ce qui le rend vrai dans le dépôt de la rédaction comme dans le
    // miroir déployé. Le préfixe hérité du dépôt-parent est toléré en lecture,
    // parce qu'une donnée ancienne ne doit pas casser une garde neuve.
    const chemin = String(s.fichier).split(" — ")[0].trim();
    const candidats = [
      join(RACINE, chemin),
      join(RACINE, chemin.replace(/^LIPIKA\/site\//, "")),
      join(RACINE, "..", "..", chemin),
    ];
    if (!candidats.some((c) => existsSync(c)))
      faute(6, `source ${s.id} : marquée [M] et nomme « ${chemin} », qui n'existe pas dans le dépôt`);
  }

  // ── Règle 25 — une mesure citée est figée ──────────────────────────────
  //
  // La règle 6 exige qu'une source [M] nomme un fichier qui existe. Elle ne
  // dit rien de ce que ce fichier contiendra demain. Tant que les instruments
  // tournaient à la main, la question ne se posait pas. Depuis qu'un passage
  // quotidien les relance, elle décide de tout : un instrument réécrit son
  // fichier, et l'affirmation publiée hier se met à citer une preuve qui dit
  // autre chose.
  //
  // Une affirmation ne peut donc pas citer une mesure vivante. Elle cite un
  // instantané daté, déposé dans donnees/mesures/archives/, que rien ne
  // réécrit — et dont l'empreinte est vérifiée ici, à chaque construction.
  // C'est ce qui rend la phrase « rejouable par un tiers » vraie plus d'un
  // jour.
  for (const s of d.sources.sources) {
    if (s.preuve !== "M" || !s.fichier) continue;
    const chemin = String(s.fichier).split(" — ")[0].trim().replace(/^LIPIKA\/site\//, "");
    if (!chemin.startsWith("donnees/mesures/")) continue; // état du journal, pas un instantané

    if (!chemin.startsWith("donnees/mesures/archives/")) {
      faute(
        25,
        `source ${s.id} : cite « ${chemin} », une mesure vivante que le prochain passage réécrira — ` +
          `une affirmation cite un instantané figé (node outils/geler.mjs)`
      );
      continue;
    }
    if (!s.empreinte) {
      faute(25, `source ${s.id} : archive citée sans empreinte — une archive qu'on ne peut pas vérifier n'est pas figée`);
      continue;
    }
    const f = join(RACINE, chemin);
    if (!existsSync(f)) continue; // déjà signalé par la règle 6
    const reel = "sha256:" + createHash("sha256").update(readFileSync(f, "utf8"), "utf8").digest("hex");
    if (reel !== s.empreinte)
      faute(
        25,
        `source ${s.id} : « ${chemin} » ne correspond plus à l'empreinte inscrite — ` +
          `l'archive a été modifiée depuis la publication`
      );
  }

  // ── Règle 26 — une citation qui ne répond plus se dit ──────────────────
  //
  // La règle 25 a figé ce que nous mesurons. L'autre moitié des preuves de ce
  // journal est ailleurs : quarante-quatre affirmations reposent sur une page
  // que quelqu'un d'autre héberge. Ces pages meurent, déménagent, passent
  // derrière un péage — et l'affirmation continue de les citer sans que rien
  // ne le dise.
  //
  // Cette garde n'exige pas que les liens soient vivants : nous ne sommes pas
  // responsables de la survie des sites que nous citons. Elle exige que chacun
  // ait été visité, et que le résultat soit publié à côté de la source. Ce
  // dont un journal est responsable, c'est de ne pas taire l'état de ses
  // preuves.
  {
    const PEREMPTION_JOURS = 30;
    const mesure = d.citations;
    if (!mesure) {
      faute(26, "aucune mesure de l'état des citations — lancer `node outils/citations.mjs` puis `node outils/geler.mjs`");
    } else {
      const age = (Date.now() - Date.parse(mesure.mesure_le)) / 86400000;
      if (!(age >= 0)) faute(26, "la mesure des citations n'a pas de date lisible");
      else if (age > PEREMPTION_JOURS)
        faute(
          26,
          `l'état des citations date de ${Math.round(age)} jours — au-delà de ${PEREMPTION_JOURS}, ` +
            `le journal affirmerait que ses sources répondent sans en rien savoir`
        );

      const vues = new Set((mesure.citations || []).map((c) => c.source));
      const publiees = new Set(
        d.stories.stories.filter((s) => s.etat === "publiee").map((s) => s.id)
      );
      for (const c of d.claims.claims) {
        if (!publiees.has(c.story)) continue;
        for (const id of c.sources || []) {
          const src = sources.get(id);
          if (!src || !src.url || !/^https?:/i.test(src.url)) continue;
          if (!vues.has(id))
            faute(
              26,
              `source ${id} : citée par ${c.id}, publiée, et jamais visitée — ` +
                `le journal ne sait pas si sa preuve répond encore`
            );
        }
      }
    }
  }

  // ── Règle 18 — toute affirmation vise des entités identifiées ──────────
  {
    const entites = new Map(d.entites.entites.map((e) => [e.id, e]));
    const types = new Set(Object.keys(d.entites.types));
    const vues = new Set();

    for (const e of d.entites.entites) {
      if (!types.has(e.type)) faute(18, `entité ${e.id} : type inconnu (${e.type})`);
      if (!e.nom) faute(18, `entité ${e.id} : sans nom`);
    }

    for (const c of d.claims.claims) {
      const liste = c.entites;
      if (!Array.isArray(liste) || liste.length === 0) {
        faute(18, `claim ${c.id} : ne vise aucune entité identifiée — il ne se joint à rien`);
        continue;
      }
      for (const id of liste) {
        if (!entites.has(id)) faute(18, `claim ${c.id} : entité inconnue ${id}`);
        vues.add(id);
      }
      // La lignée déclarée sur le sujet doit correspondre à celle des entités visées.
      const labo = c.sujet && c.sujet.laboratoire;
      if (labo) {
        const concordent = liste.some((id) => entites.get(id) && entites.get(id).lignee === labo);
        if (!concordent)
          faute(18, `claim ${c.id} : laboratoire « ${labo} » déclaré, mais aucune entité visée ne porte cette lignée`);
      }
    }

    // Une entité qui ne sert à rien gonfle le registre et fait croire à une couverture.
    // Émettre une source est un usage : c'est même le plus important, puisque
    // c'est par là que le journal sait de qui il tient ce qu'il écrit.
    const domainesMesures = new Set((d.mesures.cartes?.resultats ?? []).map((r) => r.domaine));
    const emettent = new Set(d.sources.sources.map((s) => s.emetteur_entite).filter(Boolean));
    for (const e of d.entites.entites)
      if (!vues.has(e.id) && !emettent.has(e.id) && !(e.domaine && domainesMesures.has(e.domaine)))
        faute(18, `entité ${e.id} : ni citée par une affirmation, ni émettrice d'une source, ni présente dans une mesure — registre gonflé`);
  }

  // ═══ Le graphe — règles 19, 20, 21, et l'extension de la règle 7 ═══════
  //
  // Jusqu'ici le corpus était une liste : 39 affirmations posées côte à côte,
  // chacune vraie ou fausse dans son coin. Les relations en font un graphe, et
  // un graphe se contrôle : une conséquence ne remonte pas au-dessus de sa
  // cause, une contradiction ne reste pas sans arbitre, une réserve vise
  // quelqu'un. Ce qui n'était qu'une qualité de rédaction devient une
  // arithmétique que la publication vérifie.
  {
    const liste = d.claims.claims;

    // Intégrité — toute arête pointe vers une affirmation qui existe, jamais sur soi.
    for (const c of liste)
      for (const rel of RELATIONS) {
        const v = c[rel];
        if (v === undefined) continue;
        if (!Array.isArray(v)) {
          faute(19, `claim ${c.id} : ${rel} n'est pas une liste`);
          continue;
        }
        if (v.length === 0)
          faute(19, `claim ${c.id} : ${rel} déclaré vide — une relation vide n'est pas une relation`);
        if (new Set(v).size !== v.length) faute(19, `claim ${c.id} : ${rel} répète une affirmation`);
        for (const id of v) {
          if (!claims.has(id)) faute(19, `claim ${c.id} : ${rel} vise une affirmation inconnue ${id}`);
          if (id === c.id) faute(19, `claim ${c.id} : ${rel} se vise elle-même`);
        }
      }

    // ── Règle 19 — la confiance ne remonte pas la chaîne ─────────────────
    for (const c of liste) {
      const premisses = (c.depend_de || []).map((id) => claims.get(id)).filter(Boolean);
      if (premisses.length === 0) continue;
      const plancher = Math.min(...premisses.map((p) => p.confiance));
      if (c.confiance > plancher + 1e-9) {
        const faible = premisses.find((p) => p.confiance === plancher);
        faute(
          19,
          `claim ${c.id} : confiance ${c.confiance} au-dessus de sa prémisse la plus faible ` +
            `(${faible.id} à ${plancher}) — une conséquence n'est pas plus sûre que sa cause`
        );
      }
    }

    // Aucun cycle : une affirmation qui dépend d'elle-même par un détour ne se juge pas.
    {
      const etat = new Map();
      const pile = [];
      const visiter = (id) => {
        if (etat.get(id) === "fini") return;
        if (etat.get(id) === "en_cours") {
          const i = pile.indexOf(id);
          faute(19, `dépendance circulaire : ${[...pile.slice(i), id].join(" → ")}`);
          return;
        }
        etat.set(id, "en_cours");
        pile.push(id);
        for (const p of claims.get(id)?.depend_de || []) if (claims.has(p)) visiter(p);
        pile.pop();
        etat.set(id, "fini");
      };
      for (const c of liste) visiter(c.id);
    }

    // ── Règle 20 — une contradiction s'arbitre, ou ne se pose pas ────────
    const cle = (a, b) => [a, b].sort().join(" / ");
    const ecartees = d.claims.contradictions_ecartees || [];
    const ecarteesSet = new Set();
    for (const x of ecartees) {
      if (!Array.isArray(x.paire) || x.paire.length !== 2) {
        faute(20, "contradiction écartée : la paire ne nomme pas deux affirmations");
        continue;
      }
      for (const id of x.paire)
        if (!claims.has(id)) faute(20, `contradiction écartée : affirmation inconnue ${id}`);
      if (!x.motif) faute(20, `contradiction écartée ${cle(...x.paire)} : écartée sans motif écrit`);
      ecarteesSet.add(cle(...x.paire));
    }

    const arbitrages = new Map();
    for (const c of liste) {
      if (!c.arbitre) continue;
      if (c.arbitre.length !== 2) {
        faute(20, `claim ${c.id} : un arbitrage nomme exactement deux affirmations`);
        continue;
      }
      const k = cle(...c.arbitre);
      if (arbitrages.has(k))
        faute(20, `paire ${k} : deux affirmations arbitrales (${arbitrages.get(k).id}, ${c.id})`);
      arbitrages.set(k, c);
    }

    const paires = new Set();
    for (const a of liste)
      for (const bid of a.contredit || []) {
        const b = claims.get(bid);
        if (!b) continue;
        if (!(b.contredit || []).includes(a.id))
          faute(
            20,
            `claim ${a.id} : contredit ${bid}, qui ne le déclare pas — ` +
              `la contradiction serait invisible sur une des deux pages`
          );
        const k = cle(a.id, bid);
        if (paires.has(k)) continue;
        paires.add(k);
        if (ecarteesSet.has(k)) faute(20, `paire ${k} : déclarée contradictoire et écartée en même temps`);
        const arb = arbitrages.get(k);
        if (!arb)
          faute(20, `paire ${k} : contradiction posée sans affirmation arbitrale — le journal juxtapose et n'arbitre pas`);
        else if (arb.story !== a.story && arb.story !== b.story)
          faute(20, `claim ${arb.id} : arbitre ${k} depuis un papier où aucune des deux ne paraît`);
        const rapportees = a.type === "declaration" && b.type === "declaration";
        if (a.statut === "etabli" && b.statut === "etabli" && !rapportees)
          faute(20, `paire ${k} : deux affirmations contradictoires, toutes deux établies`);
      }

    for (const [k, arb] of arbitrages)
      if (!paires.has(k)) faute(20, `claim ${arb.id} : arbitre ${k}, qui n'est pas déclarée contradictoire`);

    // ── Règle 21 — un « non établi » borne quelque chose de nommé ────────
    for (const c of liste) {
      if (c.statut !== "non_etabli") continue;
      const bornes = c.limite || [];
      if (bornes.length === 0) {
        faute(21, `claim ${c.id} : non établie et ne borne rien — une réserve qui ne vise personne n'informe personne`);
        continue;
      }
      for (const id of bornes) {
        const cible = claims.get(id);
        if (cible && cible.statut === "non_etabli")
          faute(21, `claim ${c.id} : borne ${id}, elle-même non établie — une réserve posée sur un trou n'est pas une réserve`);
      }
    }

    // ── Règle 7 étendue — deux voix, sinon pas de corroboration ──────────
    for (const a of liste)
      for (const bid of a.corrobore || []) {
        const b = claims.get(bid);
        if (!b) continue;
        if (!(b.corrobore || []).includes(a.id))
          faute(7, `claim ${a.id} : corrobore ${bid}, qui ne le déclare pas — une corroboration à sens unique n'en est pas une`);
        const partagees = (a.sources || []).filter((s) => (b.sources || []).includes(s));
        if (partagees.length)
          faute(7, `paire ${cle(a.id, bid)} : corroboration déclarée sur une source commune (${partagees.join(", ")})`);
        const emetteurs = (c) =>
          new Set((c.sources || []).map((s) => sources.get(s)?.emetteur_entite ?? sources.get(s)?.emetteur).filter(Boolean));
        const communs = [...emetteurs(a)].filter((e) => emetteurs(b).has(e));
        if (communs.length)
          faute(7, `paire ${cle(a.id, bid)} : corroboration déclarée entre deux affirmations du même émetteur (${communs.join(", ")})`);
        // La corroboration de façade : deux voix différentes, une seule maison.
        // Le lexique de ce journal a un mot pour ça ; la garde en fait une
        // impossibilité.
        const maison = (c) =>
          [...emetteurs(c)].some((id) => d.entites.entites.find((e) => e.id === id)?.type === "notre_maison");
        if (maison(a) && maison(b))
          faute(
            7,
            `paire ${cle(a.id, bid)} : corroboration déclarée entre deux affirmations émises par notre propre maison — ` +
              `corroboration de façade`
          );
      }
  }

  // ── Règle 24 — ce qu'une machine publie seule ──────────────────────────
  //
  // Le passage quotidien tourne sans personne en face. Il a le droit de dire ce
  // qui a bougé ; il n'a pas le droit d'avoir un avis. La garde impose donc la
  // marque [M], un plafond de confiance, et l'interdiction de la tête de une.
  {
    const PLAFOND_AUTO = 0.9;
    const autos = d.claims.claims.filter((c) => c.origine === "passage_quotidien");
    for (const c of autos) {
      const marques = (c.sources || []).map((id) => sources.get(id)?.preuve);
      if (!marques.includes("M"))
        faute(24, `claim ${c.id} : produite par le passage quotidien sans source [M] — une machine ne rapporte que ce qu'elle a mesuré`);
      if (c.confiance > PLAFOND_AUTO + 1e-9)
        faute(24, `claim ${c.id} : produite automatiquement et publiée à ${c.confiance} — le plafond est ${PLAFOND_AUTO}`);
    }
    const une = d.stories.numero.une;
    const tete = d.stories.stories.find((s) => s.id === une?.tete);
    if (tete && tete.origine === "passage_quotidien")
      faute(24, `une : le papier de tête (${tete.id}) est d'origine automatique — la hiérarchie est un arbitrage, pas un tri`);
    for (const s of d.stories.stories) {
      if (s.origine !== "passage_quotidien") continue;
      if (s.genre !== "breve")
        faute(24, `story ${s.id} : produite automatiquement mais déclarée « ${s.genre ?? "papier"} » — une machine ne publie que des brèves`);
    }
  }

  // ── Règle 23 — une image passe par le registre, ou n'existe pas ────────
  //
  // La garde est textuelle et c'est assumé : elle relit les pages à la
  // recherche d'une balise d'image posée à la main. Une image qui échappe au
  // registre est une image sans crédit et sans avertissement, et dans ce
  // journal-ci c'est une image qui documente un chiffre sans rien prouver.
  {
    const reg = lireSiPresent(RACINE, "illustrations.json");
    if (!reg) faute(23, "registre des illustrations absent — une image pourrait passer sans crédit");
    else {
      const connus = new Set(reg.images.map((i) => i.id));
      for (const i of reg.images) {
        for (const champ of ["fichier", "alt", "legende", "illustre"])
          if (!i[champ]) faute(23, `illustration ${i.id} : ${champ} manquant`);
        if (i.fichier && !existsSync(join(RACINE, "public", i.fichier.replace(/^\//, ""))))
          faute(23, `illustration ${i.id} : le fichier ${i.fichier} n'existe pas`);
        if (i.alt && i.alt.length < 24)
          faute(23, `illustration ${i.id} : texte de remplacement trop court pour décrire l'image`);
      }

      const pages = [];
      (function parcourir(d) {
        for (const e of readdirSync(d, { withFileTypes: true })) {
          const p = join(d, e.name);
          if (e.isDirectory()) parcourir(p);
          else if (/\.tsx$/.test(e.name)) pages.push(p);
        }
      })(join(RACINE, "app"));

      const utilises = new Set();
      for (const f of pages) {
        const texte = readFileSync(f, "utf8");
        const relatif = f.slice(RACINE.length + 1).split("\\").join("/");
        // Le composant lui-même a le droit de porter la balise : c'est son travail.
        if (!relatif.endsWith("components/Illustration.tsx") && /<img|from "next\/image"/.test(texte))
          faute(23, `${relatif} : balise d'image hors du composant Illustration`);
        // Un identifiant peut arriver par une table de correspondance ou une
        // interpolation : on cherche donc la chaine, pas la balise.
        for (const i of reg.images) if (texte.includes(`"${i.id}"`)) utilises.add(i.id);
      }
      // Une table de correspondance compte comme un usage : les images de desk
      // sont posees par identifiant calcule, pas ecrit en clair dans une page.
      const lib = readFileSync(join(RACINE, "lib", "donnees.ts"), "utf8");
      for (const i of reg.images) {
        if (lib.includes(`"${i.id}"`)) utilises.add(i.id);
      }
      for (const i of reg.images)
        if (!utilises.has(i.id))
          faute(23, `illustration ${i.id} : dans le registre et affichée nulle part — registre gonflé`);
    }
  }

  // ── Règle 22 — l'unité de citation existe dans les deux langues ────────
  //
  // Le français reste la langue de rédaction ; ce qui doit être bilingue est ce
  // qu'un lecteur recopie. Un champ anglais identique au français serait un
  // champ rempli pour passer la garde, pas une traduction : il est refusé.
  for (const c of d.claims.claims) {
    if (!c.enonce_en || String(c.enonce_en).trim().length < 12)
      faute(22, `claim ${c.id} : aucun énoncé anglais — l'unité qui se cite n'existe que dans une langue`);
    else if (c.enonce_en.trim() === c.enonce.trim())
      faute(22, `claim ${c.id} : l'énoncé anglais est identique au français — champ rempli, pas traduit`);
  }
  for (const s of d.stories.stories) {
    if (s.etat !== "publiee") continue;
    if (!s.titre_en) faute(22, `story ${s.id} : publiée sans titre anglais`);
    else if (s.titre_en.trim() === s.titre.trim())
      faute(22, `story ${s.id} : titre anglais identique au français`);
    if (!s.chapeau_en) faute(22, `story ${s.id} : publiée sans chapeau anglais`);
  }

  // ── Règle 17 — un papier dit ce qu'il y a à vérifier chez soi ──────────
  for (const s of d.stories.stories) {
    if (s.etat !== "publiee") continue;
    const v = s.verifications;
    if (!Array.isArray(v) || v.length === 0) {
      faute(17, `story ${s.id} : aucune vérification recommandée — un lecteur-agent n'a rien à en faire`);
      continue;
    }
    for (const [i, x] of v.entries()) {
      if (!x.si || !x.alors) faute(17, `story ${s.id} : vérification ${i} sans condition ou sans action`);
      if (x.claim && !claims.has(x.claim)) faute(17, `story ${s.id} : vérification ${i} cite un claim inconnu`);
      if (!x.claim) faute(17, `story ${s.id} : vérification ${i} ne s'appuie sur aucune affirmation`);
    }
  }

  // ── Règle 16 — la une place chaque papier, une fois et une seule ───────
  {
    const une = d.stories.numero.une;
    if (!une) faute(16, "aucune hiérarchie de une : la page d'accueil trierait par défaut, sans décision");
    else {
      const places = [une.tete, ...(une.secondaires || []), ...(une.breves || [])];
      const vus = new Set();
      for (const id of places) {
        if (!stories.has(id)) faute(16, `une : papier inconnu ${id}`);
        if (vus.has(id)) faute(16, `une : papier placé deux fois — ${id}`);
        vus.add(id);
      }
      for (const s of d.stories.stories)
        if (s.etat === "publiee" && !vus.has(s.id))
          faute(16, `une : le papier ${s.id} est publié mais n'est placé nulle part — enterré sans le dire`);
      if (!une.motif_tete) faute(16, "une : la tête n'a pas de motif écrit");
    }
  }

  // ── Règle 15 — le panel n'emploie pas la famille qui écrit ─────────────
  if (d.relectures) {
    const maison = d.relectures.panel?.famille_de_la_maison;
    const dedans = maison && d.relectures.lignees.some((l) => l.famille === maison);
    if (dedans && d.relectures.panel?.conforme !== false)
      faute(15, `panel : la famille « ${maison} » écrit le journal et siège au panel, sans dérogation consignée`);
    if (dedans && !d.relectures.panel?.motif)
      faute(15, "panel : dérogation déclarée sans motif écrit");
    if (!maison) faute(15, "panel : la famille de la maison n'est pas déclarée — la règle 15 ne peut pas s'appliquer");
  }

  // ── Catalogue d'outils : servie et signée, c'est la même carte ─────────
  //
  // Le desk Protocoles publie que personne ne signe ses cartes d'agent. Signer
  // la nôtre et y annoncer des compétences que le serveur n'expose pas serait
  // pire que ne pas signer : une signature valide sur un mensonge.
  {
    const cat = d.outils;
    if (!cat) faute(10, "catalogue d'outils absent — la carte d'agent et le serveur MCP repartiraient de deux listes");
    else {
      const noms = new Set();
      for (const o of cat.outils) {
        if (!o.name || !o.description || !o.inputSchema)
          faute(10, `outil ${o.name ?? "sans nom"} : nom, description ou schéma d'entrée manquant`);
        if (noms.has(o.name)) faute(10, `outil ${o.name} : déclaré deux fois`);
        noms.add(o.name);
        if (o.carte && (!o.carte.name || !Array.isArray(o.carte.tags) || !Array.isArray(o.carte.examples)))
          faute(10, `outil ${o.name} : annoncé sur la carte d'agent sans nom, sans étiquette ou sans exemple`);
      }
      const attendues = cat.outils.filter((o) => o.carte).map((o) => o.name).sort();
      const corps = corpsDuJournal(d.journalistes.publication, d.journalistes.journalistes);
      if (JSON.stringify(corps.skills) !== JSON.stringify(attendues))
        faute(10, "carte d'agent : les compétences signées ne sont pas celles du catalogue servi");
      const sig = d.signatures;
      const empreinte = sig && sig.cartes && sig.cartes.lipika && sig.cartes.lipika.sha256;
      if (!empreinte) faute(10, "carte d'agent du journal : aucune signature enregistrée");
      else if (empreinte !== empreinteDe(corps))
        faute(10, "carte d'agent : la carte a changé depuis sa signature — relancer npm run signer");
    }
  }

  // ── Règle 10 — les jumeaux JSON existent ───────────────────────────────
  const surfaces = [
    "app/papier/[id]/page.tsx",
    "app/affirmation/[id]/page.tsx",
    "app/redaction/[id]/page.tsx",
    "app/divergence/page.tsx",
    "app/graphe/page.tsx",
    "app/machine/graphe.json/route.ts",
    "app/lexique/page.tsx",
    "app/recherche/page.tsx",
    "app/entites/page.tsx",
    "app/entite/[id]/page.tsx",
    "app/machine/entite/[id]/route.ts",
    "app/agents/page.tsx",
    "app/llms.txt/route.ts",
    "app/rss.xml/route.ts",
    "app/opengraph-image.tsx",
    "app/sitemap.ts",
    "app/robots.ts",
    "app/mesures/page.tsx",
    "app/outils/page.tsx",
    "app/desk/[id]/page.tsx",
    "app/en/page.tsx",
    "donnees/illustrations.json",
    "app/machine/outils.json/route.ts",
    "app/feed.json/route.ts",
    "app/.well-known/agent-card.json/route.ts",
    "app/recre/page.tsx",
    "app/en/recre/page.tsx",
    "app/machine/recre.json/route.ts",
  ];
  for (const f of surfaces)
    if (!existsSync(join(RACINE, f))) faute(10, `surface manquante : ${f}`);

  return fautes;
}

/** L'empreinte d'un corps de carte, calculée comme le signeur la calcule. */
function empreinteDe(corps) {
  return createHash("sha256").update(Buffer.from(canonique(corps), "utf8")).digest("hex");
}

/** Hash d'une version — calculé, jamais stocké dans les données. */
export function hasher(objet) {
  return createHash("sha256").update(JSON.stringify(objet)).digest("hex").slice(0, 16);
}

// ── Exécution directe ────────────────────────────────────────────────────
const estPointDEntree = process.argv[1] && process.argv[1].endsWith("verifier.mjs");
if (estPointDEntree) {
  const d = charger();
  const fautes = verifier(d);
  const n = {
    claims: d.claims.claims.length,
    stories: d.stories.stories.length,
    sources: d.sources.sources.length,
    journalistes: d.journalistes.journalistes.length,
  };
  if (fautes.length === 0) {
    console.log(
      `LIPIKA — gardes tenues. ${n.stories} papiers, ${n.claims} affirmations, ` +
        `${n.sources} sources, ${n.journalistes} signatures.`
    );
    process.exit(0);
  }
  console.error(`LIPIKA — PUBLICATION REFUSÉE. ${fautes.length} manquement(s) :\n`);
  for (const f of fautes) console.error(`  règle ${f.regle} — ${f.quoi}`);
  process.exit(1);
}