feat(erp): manifeste d'exercice — décrire les faits pour pouvoir les rejouer

Un exercice OUVERT n'a d'engagement envers personne : aucun compte déposé,
aucune liasse, aucun FEC remis. Tant qu'il en va ainsi, une erreur de
MODÉLISATION se corrige mieux en rejouant depuis les pièces qu'en la
contournant — la piste d'audit fiable demande que l'écriture reflète sa pièce,
et rejouer resserre ce lien là où une rustine le distend.

extractExercise.ts ne fait que LIRE. Il produit la description ordonnée des
faits : tiers, factures client et fournisseur avec leurs lignes et règlements,
et l'intégralité des mouvements bancaires.

Les mouvements bancaires sont le RÉFÉRENT : Qonto et Wise sont hors de
Dolibarr, on ne peut pas les réécrire. Le test d'acceptation d'un rejeu est
donc qu'ils soient retrouvés au centime et à la date.

La ligne de partage entre ce qui se rejoue et ce qui est figé n'est pas
technique mais juridique : est figé tout ce qu'un tiers détient — facture
client ENVOYÉE, dépôt au greffe, déclaration transmise — et tout exercice clos.
Les factures client sont donc extraites avec delivered:true : un rejeu les
reproduit à l'identique, il ne les recalcule pas.

Les exclusions sont DÉCLARATIVES ET MOTIVÉES, jamais codées en dur : un
auditeur doit lire pourquoi une référence manque sans avoir à le deviner. Deux
pièces sont écartées — FAC001-CL00001, dont la référence était malformée par un
défaut de masque, et l'avoir qui l'annulait. L'opérateur a établi qu'elle n'a
jamais quitté la société : KissMetrics a été facturé via Wise en février, et le
document qu'il détient référence FAC001-CL0001001. L'avoir ne documentait donc
qu'un faux pas interne. La séquence FAC reste continue (FAC001 à FAC008), la
réémission portant elle aussi FAC001 — rien à renuméroter.

Deux constats que l'extraction met au jour :

- 20 des 37 mouvements bancaires portent un libellé Dolibarr générique
  (« SupplierInvoicePayment », « CustomerInvoicePayment ») qui traverse le grand
  livre tel quel et y est illisible pour un repreneur comme pour un inspecteur ;
- FAF2025001 (OVH, 7,30 EUR) est datée du 24/10/2025, trois mois avant
  l'immatriculation, et NE FIGURE PAS à l'annexe 1 des statuts qui recense les
  actes accomplis pour le compte de la société en formation. Une dépense
  antérieure à l'existence de la société ne peut être supportée par elle que si
  elle est reprise par cet état ou ratifiée ensuite.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

fleet/profile/decisions/adc-011-tenue-comptable-et-discretion.md

@@ -40,10 +40,16 @@ Le document le dit expressément, et les pièces sont produites sur demande. La
 règle est donc *pouvoir répondre simplement en cas d'enquête*, jamais *anticiper
 l'enquête en publiant*.
 
-**Limite qui inverse la règle :** un flux financier entre la société et son
+**Limite qui inverse la règle — et elle est étroite :** ne se déclare, même non
-dirigeant se déclare, même non demandé, dès lors que le document porte
+demandé, que ce qui rendrait le document **faux** si on le taisait. Le critère
-précisément sur l'absence d'un tel flux. Taire ce qui contredirait le document
+est la véracité de ce qui est affirmé, pas l'exhaustivité.
-n'est pas de la discrétion, c'est une omission.
+
+Une attestation d'absence de rémunération n'a pas à mentionner une indemnité
+d'occupation : celle-ci n'est pas une rémunération, elle ne contredit donc rien.
+La mentionner, c'est publier une relation financière que personne n'a demandée —
+et un lecteur pressé y verrait une rémunération là où il n'y en a pas. Une
+première rédaction l'avait fait, en s'abritant derrière la transparence ; c'était
+une erreur d'analyse : la discrétion et la sincérité ne s'opposaient pas ici.
 
 ### 2. Permanence des méthodes
 

test/extractExercise.ts

@@ -0,0 +1,245 @@
+/*
+  Extrait d'une instance Dolibarr le MANIFESTE D'UN EXERCICE : la description
+  complète et ordonnée des faits qui le composent.
+
+  POURQUOI. Un exercice ouvert n'a d'engagement envers personne — aucun compte
+  déposé, aucune liasse, aucun FEC remis. Tant qu'il en va ainsi, une erreur de
+  MODÉLISATION (mauvais compte, auxiliaire manquant, libellé illisible) se
+  corrige mieux en rejouant depuis les pièces qu'en la contournant : la piste
+  d'audit fiable demande que l'écriture reflète sa pièce, et rejouer resserre ce
+  lien là où une rustine le distend.
+
+  Ce fichier ne fait que LIRE. Il produit le manifeste ; le rejeu est un autre
+  outil, et il ne s'exécute que sur une cible vierge.
+
+  CE QUI EST REJOUABLE, ET CE QUI NE L'EST PAS. La ligne de partage n'est pas
+  technique, elle est juridique :
+
+    rejouable  : factures fournisseur enregistrées, lignes bancaires, paiements
+                 divers, charges sociales, tiers — tout ce qui est interne ;
+    FIGÉ       : toute pièce déjà remise à un tiers (facture client ENVOYÉE,
+                 dépôt au greffe, déclaration transmise) et tout exercice clos.
+
+  Une facture partie chez le client existe chez lui : aucun rejeu ne l'efface.
+  Le manifeste les extrait quand même — il décrit l'exercice — mais les marque
+  `delivered: true`, et le rejeu devra les reproduire à l'identique plutôt que
+  les recalculer.
+
+  LE RÉFÉRENT DE VÉRIFICATION. Les mouvements bancaires sont la seule partie de
+  l'exercice qu'on ne peut pas réécrire : Qonto et Wise sont hors de Dolibarr.
+  Le manifeste les embarque donc intégralement, et le test d'acceptation d'un
+  rejeu est qu'ils soient retrouvés au centime et à la date.
+
+  Usage :
+    DENO_TLS_CA_STORE=system \
+    DOLIBARR_URL=https://erp.arcodange.lab DOLAPIKEY=$(cat test/....key) \
+      deno run -A test/extractExercise.ts --year 2026 --out manifest.json
+
+  `DENO_TLS_CA_STORE=system` n'est pas décoratif : les hôtes du lab portent un
+  certificat signé par une autorité interne, présente dans le trousseau système
+  mais absente du magasin que Deno embarque. Sans lui, `fetch` échoue sur
+  « invalid peer certificate: UnknownIssuer » — alors que curl et Playwright,
+  qui lisent le trousseau système, passent sans rien dire.
+*/
+import "load_dotenv";
+
+const argv = Deno.args;
+const pick = (f: string, d = "") => (argv.includes(f) ? argv[argv.indexOf(f) + 1] : d);
+
+const base = pick("--url", Deno.env.get("DOLIBARR_URL") ?? "https://erp.arcodange.lab");
+const key = Deno.env.get("DOLAPIKEY") ?? "";
+const year = Number(pick("--year", "2026"));
+const out = pick("--out", `manifest-${year}.json`);
+
+/**
+ * Pièces volontairement écartées du rejeu, avec leur motif.
+ *
+ * Une exclusion n'est légitime que si la pièce N'A JAMAIS ÉTÉ REMISE À UN TIERS.
+ * Le motif est consigné dans le manifeste : un auditeur doit pouvoir lire
+ * pourquoi une référence manque, sans avoir à le deviner ni à nous croire.
+ */
+const EXCLUSIONS: Record<string, string> = {
+  "FAC001-CL00001":
+    "Référence malformée (CL00001 au lieu de CL0001001) — défaut de configuration du masque. "
+    + "JAMAIS REMISE AU CLIENT : vérifié le 2026-08-14, aucune trace d'envoi ; KissMetrics a été "
+    + "facturé via Wise en février 2026, et le document qu'il détient référence FAC001-CL0001001. "
+    + "La séquence FAC reste continue (FAC001 à FAC008), la réémission portant elle aussi FAC001.",
+  "AVC001-CL0001001":
+    "Avoir émis le 24/02/2026 pour annuler FAC001-CL00001. Sans objet dès lors que la facture "
+    + "annulée n'a jamais quitté la société : il ne documentait qu'un faux pas interne, non un "
+    + "événement commercial. La séquence AVC devient vide.",
+};
+
+if (!key) {
+  console.error("DOLAPIKEY requis (lecture seule).");
+  Deno.exit(2);
+}
+
+async function api<T>(path: string): Promise<T | null> {
+  const r = await fetch(`${base}/api/index.php${path}`, { headers: { DOLAPIKEY: key } });
+  if (!r.ok) return null;
+  try {
+    return await r.json() as T;
+  } catch {
+    return null;
+  }
+}
+
+/** Dolibarr rend des epochs ; on les fige en ISO dans le fuseau du serveur. */
+const iso = (ts: unknown): string | null => {
+  const n = Number(ts);
+  if (!n) return null;
+  return new Date(n * 1000).toISOString().slice(0, 10);
+};
+
+const inYear = (ts: unknown) => {
+  const d = iso(ts);
+  return !!d && d.startsWith(String(year));
+};
+
+type Any = Record<string, unknown>;
+
+console.log(`source   : ${base}`);
+console.log(`exercice : ${year}\n`);
+
+// --- tiers ------------------------------------------------------------------
+const tiers = (await api<Any[]>("/thirdparties?limit=500") ?? []).map((t) => ({
+  id: t.id,
+  name: t.name,
+  code_client: t.code_client,
+  code_fournisseur: t.code_fournisseur,
+  client: t.client,
+  fournisseur: t.fournisseur,
+  country_id: t.country_id,
+  tva_intra: t.tva_intra,
+  code_compta: t.code_compta,
+  code_compta_fournisseur: t.code_compta_fournisseur,
+}));
+console.log(`tiers                 : ${tiers.length}`);
+
+// --- factures client --------------------------------------------------------
+// `delivered: true` : elles sont parties chez le client. Un rejeu les reproduit
+// à l'identique — référence, date, montant — il ne les recalcule pas.
+const invoices = [];
+const excluded: Any[] = [];
+for (const f of await api<Any[]>("/invoices?limit=500") ?? []) {
+  if (!inYear(f.date)) continue;
+  const motif = EXCLUSIONS[String(f.ref)];
+  if (motif) {
+    excluded.push({ ref: f.ref, date: iso(f.date), total_ttc: f.total_ttc, motif });
+    continue;
+  }
+  const payments = await api<Any[]>(`/invoices/${f.id}/payments`) ?? [];
+  invoices.push({
+    ref: f.ref,
+    socid: f.socid,
+    date: iso(f.date),
+    date_lim_reglement: iso(f.date_lim_reglement),
+    type: f.type,
+    total_ht: f.total_ht,
+    total_tva: f.total_tva,
+    total_ttc: f.total_ttc,
+    multicurrency_code: f.multicurrency_code,
+    statut: f.statut,
+    paye: f.paye,
+    delivered: true,
+    lines: (f.lines as Any[] ?? []).map((l) => ({
+      desc: l.desc, subprice: l.subprice, qty: l.qty, tva_tx: l.tva_tx, product_type: l.product_type,
+    })),
+    payments: payments.map((p) => ({ amount: p.amount, type: p.type, date: p.date, ref: p.ref })),
+  });
+}
+console.log(`factures client       : ${invoices.length}  (figées — déjà remises au client)`);
+for (const e of excluded) console.log(`   ⊘ exclue : ${e.ref} (${e.total_ttc} EUR) — ${String(e.motif).slice(0, 72)}…`);
+
+// --- factures fournisseur ---------------------------------------------------
+const supplierInvoices = [];
+for (const f of await api<Any[]>("/supplierinvoices?limit=500") ?? []) {
+  if (!inYear(f.date)) continue;
+  const payments = await api<Any[]>(`/supplierinvoices/${f.id}/payments`) ?? [];
+  supplierInvoices.push({
+    ref: f.ref,
+    ref_supplier: f.ref_supplier,
+    socid: f.socid,
+    date: iso(f.date),
+    total_ht: f.total_ht,
+    total_tva: f.total_tva,
+    total_ttc: f.total_ttc,
+    statut: f.statut,
+    paye: f.paye,
+    lines: (f.lines as Any[] ?? []).map((l) => ({
+      desc: l.desc, subprice: l.subprice, qty: l.qty, tva_tx: l.tva_tx, product_type: l.product_type,
+    })),
+    payments: payments.map((p) => ({ amount: p.amount, type: p.type, date: p.date, ref: p.ref })),
+  });
+}
+console.log(`factures fournisseur  : ${supplierInvoices.length}`);
+
+// --- comptes et mouvements bancaires ---------------------------------------
+// LE RÉFÉRENT. Tout le reste se vérifie contre ces lignes.
+const accounts = [];
+let bankLineCount = 0;
+for (const a of await api<Any[]>("/bankaccounts") ?? []) {
+  const lines = (await api<Any[]>(`/bankaccounts/${a.id}/lines?limit=1000`) ?? [])
+    .map((l) => ({
+      date: iso(l.datev ?? l.dateo),
+      amount: Number(l.amount),
+      label: l.label,
+      // Les libellés générés par Dolibarr — « SupplierInvoicePayment »,
+      // « CustomerInvoicePayment » — traversent le grand livre tels quels et y
+      // sont illisibles. Le rejeu doit les remplacer par le libellé de la pièce.
+      generic_label: /^\(?(Customer|Supplier)InvoicePayment\)?$/.test(String(l.label ?? "")),
+      num_releve: l.num_releve,
+    }))
+    .filter((l) => l.date)
+    .sort((x, y) => String(x.date).localeCompare(String(y.date)));
+  bankLineCount += lines.length;
+  accounts.push({
+    id: a.id,
+    label: a.label,
+    ref: a.ref,
+    account_number: a.account_number,
+    accountancy_journal: a.accountancy_journal,
+    currency_code: a.currency_code,
+    balance: Number(lines.reduce((s, l) => s + l.amount, 0).toFixed(2)),
+    lines,
+  });
+}
+console.log(`comptes bancaires     : ${accounts.length}  (${bankLineCount} mouvements — référent de vérification)`);
+
+const generics = accounts.flatMap((a) => a.lines).filter((l) => l.generic_label).length;
+
+const manifest = {
+  meta: {
+    exercice: year,
+    source: base,
+    extracted_at: new Date().toISOString(),
+    // Un exercice clos ne se rejoue pas : la clôture est la limite dure.
+    replayable: true,
+    note: "Manifeste d'exercice — description des faits, non des écritures comptables. "
+      + "Les factures client sont marquées delivered:true : elles existent chez le client "
+      + "et se reproduisent à l'identique, jamais ne se recalculent.",
+  },
+  exclusions: excluded,
+  anomalies: {
+    libelles_generiques: generics,
+    detail: generics
+      ? "lignes bancaires portant un libellé Dolibarr générique — à remplacer au rejeu"
+      : "aucune",
+  },
+  tiers,
+  invoices,
+  supplierInvoices,
+  accounts,
+};
+
+await Deno.writeTextFile(out, JSON.stringify(manifest, null, 2));
+
+const totalClient = invoices.reduce((s, f) => s + Number(f.total_ttc ?? 0), 0);
+const totalFourn = supplierInvoices.reduce((s, f) => s + Number(f.total_ttc ?? 0), 0);
+console.log(`\n--- récapitulatif ---`);
+console.log(`  produits facturés   : ${totalClient.toFixed(2)} EUR`);
+console.log(`  achats facturés     : ${totalFourn.toFixed(2)} EUR`);
+for (const a of accounts) console.log(`  ${String(a.label).padEnd(32)} ${a.balance.toFixed(2)} EUR`);
+console.log(`  libellés génériques : ${generics}  ← à corriger au rejeu`);
+console.log(`\nmanifeste écrit : ${out}`);