feat(glossary): add core glossarial taxonomy and foundational entries

Reviewed-on: #205

.gitea/workflows/anno-apply-pr.yml

@@ -17,7 +17,7 @@ defaults:
     shell: bash
 
 concurrency:
-  group: anno-apply-${{ github.event.issue.number || inputs.issue || 'manual' }}
+  group: anno-apply-${{ github.event.issue.number || github.event.issue.index || inputs.issue || 'manual' }}
   cancel-in-progress: true
 
 jobs:
@@ -37,7 +37,7 @@ jobs:
       - name: Derive context (event.json / workflow_dispatch)
         env:
           INPUT_ISSUE: ${{ inputs.issue }}
-          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE }}
+          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE || vars.FORGE_BASE_URL }}
         run: |
           set -euo pipefail
           export EVENT_JSON="/var/run/act/workflow/event.json"
@@ -81,10 +81,12 @@ jobs:
             throw new Error("No issue number in event.json or workflow_dispatch input");
           }
 
-          const labelName =
-            ev?.label?.name ||
-            ev?.label ||
-            "workflow_dispatch";
+          // label name: best-effort (non-bloquant)
+          let labelName = "workflow_dispatch";
+          const lab = ev?.label;
+          if (typeof lab === "string") labelName = lab;
+          else if (lab && typeof lab === "object" && typeof lab.name === "string") labelName = lab.name;
+          else if (ev?.label?.name) labelName = ev.label.name;
 
           const u = new URL(cloneUrl);
           const origin = u.origin;
@@ -109,19 +111,25 @@ jobs:
           echo "✅ context:"
           sed -n '1,120p' /tmp/anno.env
 
-      - name: Gate on label state/approved
+      - name: Early gate (label event fast-skip, but tolerant)
         run: |
           set -euo pipefail
           source /tmp/anno.env
 
-          if [[ "$LABEL_NAME" != "state/approved" && "$LABEL_NAME" != "workflow_dispatch" ]]; then
-            echo "ℹ️ label=$LABEL_NAME => skip"
+          echo "ℹ️ event label = $LABEL_NAME"
+
+          # Fast skip on obvious non-approved label events (avoid noise),
+          # BUT do NOT skip if label payload is weird/unknown.
+          if [[ "$LABEL_NAME" != "state/approved" && "$LABEL_NAME" != "workflow_dispatch" && "$LABEL_NAME" != "" && "$LABEL_NAME" != "[object Object]" ]]; then
+            echo "ℹ️ label=$LABEL_NAME => skip early"
             echo "SKIP=1" >> /tmp/anno.env
+            echo "SKIP_REASON=\"label_not_approved_event\"" >> /tmp/anno.env
             exit 0
           fi
-          echo "✅ proceed (issue=$ISSUE_NUMBER)"
 
-      - name: Fetch issue + gate on Type (skip Proposer)
+          echo "✅ continue to API gating (issue=$ISSUE_NUMBER)"
+
+      - name: Fetch issue + hard gate on labels + Type
         env:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
         run: |
@@ -131,16 +139,22 @@ jobs:
 
           test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
 
-          ISSUE_JSON="$(curl -fsS \
+          curl -fsS \
             -H "Authorization: token $FORGE_TOKEN" \
             -H "Accept: application/json" \
-            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER")"
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER" \
+            -o /tmp/issue.json
 
-          node --input-type=module - <<'NODE' "$ISSUE_JSON" >> /tmp/anno.env
-          const issue = JSON.parse(process.argv[1] || "{}");
+          node --input-type=module - <<'NODE' >> /tmp/anno.env
+          import fs from "node:fs";
+
+          const issue = JSON.parse(fs.readFileSync("/tmp/issue.json","utf8"));
           const title = String(issue.title || "");
           const body = String(issue.body || "").replace(/\r\n/g, "\n");
 
+          const labels = Array.isArray(issue.labels) ? issue.labels.map(l => String(l.name || "")).filter(Boolean) : [];
+          const hasApproved = labels.includes("state/approved");
+
           function pickLine(key) {
             const re = new RegExp(`^\\s*${key}\\s*:\\s*([^\\n\\r]+)`, "mi");
             const m = body.match(re);
@@ -157,6 +171,14 @@ jobs:
           out.push(`ISSUE_TITLE=${JSON.stringify(title)}`);
           out.push(`ISSUE_TYPE=${JSON.stringify(type)}`);
 
+          // HARD gate: must currently have state/approved (avoids depending on event payload)
+          if (!hasApproved) {
+            out.push(`SKIP=1`);
+            out.push(`SKIP_REASON=${JSON.stringify("not_approved_label_present")}`);
+            process.stdout.write(out.join("\n") + "\n");
+            process.exit(0);
+          }
+
           if (!type) {
             out.push(`SKIP=1`);
             out.push(`SKIP_REASON=${JSON.stringify("missing_type")}`);
@@ -173,7 +195,7 @@ jobs:
           process.stdout.write(out.join("\n") + "\n");
           NODE
 
-          echo "✅ issue type gating:"
+          echo "✅ gating result:"
           grep -E '^(ISSUE_TYPE|SKIP|SKIP_REASON)=' /tmp/anno.env || true
 
       - name: Comment issue if skipped (Proposer / unsupported / missing Type)
@@ -185,19 +207,24 @@ jobs:
           source /tmp/anno.env || true
 
           [[ "${SKIP:-0}" == "1" ]] || exit 0
-          [[ "$LABEL_NAME" == "state/approved" || "$LABEL_NAME" == "workflow_dispatch" ]] || exit 0
 
-          # message différent si Proposer
+          # IMPORTANT: do NOT comment for "not_approved_label_present" (avoid spam on other label events)
+          if [[ "${SKIP_REASON:-}" == "not_approved_label_present" || "${SKIP_REASON:-}" == "label_not_approved_event" ]]; then
+            echo "ℹ️ skip reason=${SKIP_REASON} -> no comment"
+            exit 0
+          fi
+
+          test -n "${FORGE_TOKEN:-}" || exit 0
+
           REASON="${SKIP_REASON:-}"
           TYPE="${ISSUE_TYPE:-}"
-          TITLE="${ISSUE_TITLE:-}"
 
           if [[ "$REASON" == proposer_type:* ]]; then
-            MSG="ℹ️ Ticket #${ISSUE_NUMBER} détecté comme **Proposer** (${TYPE}).\n\n- Ce type est **traité manuellement par les editors** (correction/fact-check + cat/*).\n- Le bot n'applique **jamais** Proposer et n'ajoute **jamais** state/approved automatiquement.\n\n✅ Action : traitement éditorial manuel."
+            MSG="ℹ️ Ticket #${ISSUE_NUMBER} détecté comme **Proposer** (${TYPE}).\n\n- Ce type est **traité manuellement par les editors**.\n✅ Aucun traitement automatique."
           elif [[ "$REASON" == unsupported_type:* ]]; then
-            MSG="ℹ️ Ticket #${ISSUE_NUMBER} ignoré : Type non supporté par le bot (${TYPE}).\n\nTypes supportés : type/media, type/reference, type/comment.\n✅ Action : traitement manuel si nécessaire."
+            MSG="ℹ️ Ticket #${ISSUE_NUMBER} ignoré : Type non supporté par le bot (${TYPE}).\n\nTypes supportés : type/media, type/reference, type/comment."
           else
-            MSG="ℹ️ Ticket #${ISSUE_NUMBER} ignoré : champ 'Type:' manquant ou illisible.\n\n✅ Action : corriger le ticket (ajouter 'Type: type/media|type/reference|type/comment') ou traiter manuellement."
+            MSG="ℹ️ Ticket #${ISSUE_NUMBER} ignoré : champ 'Type:' manquant ou illisible.\n\nAjoute : Type: type/media|type/reference|type/comment"
           fi
 
           PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
@@ -264,6 +291,7 @@ jobs:
           set -euo pipefail
           source /tmp/anno.env
           [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          test -d .git || { echo "❌ not a git repo (checkout failed)"; echo "APPLY_RC=90" >> /tmp/anno.env; exit 0; }
 
           test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
 
@@ -320,6 +348,8 @@ jobs:
             exit 0
           fi
 
+          test -n "${FORGE_TOKEN:-}" || exit 0
+
           if [[ -f /tmp/apply.log ]]; then
             BODY="$(tail -n 160 /tmp/apply.log | sed 's/\r$//')"
           else
@@ -335,27 +365,6 @@ jobs:
             "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
             --data-binary "$PAYLOAD"
 
-      - name: Comment issue if no-op (already applied)
-        if: ${{ always() }}
-        env:
-          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
-        run: |
-          set -euo pipefail
-          source /tmp/anno.env || true
-          [[ "${SKIP:-0}" != "1" ]] || exit 0
-
-          [[ "${APPLY_RC:-0}" == "0" ]] || exit 0
-          [[ "${NOOP:-0}" == "1" ]] || exit 0
-
-          MSG="ℹ️ Ticket #${ISSUE_NUMBER} : rien à appliquer (déjà présent / dédupliqué)."
-          PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
-
-          curl -fsS -X POST \
-            -H "Authorization: token $FORGE_TOKEN" \
-            -H "Content-Type: application/json" \
-            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
-            --data-binary "$PAYLOAD"
-
       - name: Push bot branch
         if: ${{ always() }}
         env:
@@ -367,6 +376,7 @@ jobs:
 
           [[ "${APPLY_RC:-0}" == "0" ]] || { echo "ℹ️ apply failed -> skip push"; exit 0; }
           [[ "${NOOP:-0}" == "0" ]] || { echo "ℹ️ no-op -> skip push"; exit 0; }
+          test -d .git || { echo "ℹ️ no git repo -> skip push"; exit 0; }
 
           AUTH_URL="$(node --input-type=module -e '
             const [clone, tok] = process.argv.slice(1);

.gitea/workflows/anno-reject.yml

@@ -17,7 +17,7 @@ defaults:
     shell: bash
 
 concurrency:
-  group: anno-reject-${{ github.event.issue.number || inputs.issue || 'manual' }}
+  group: anno-reject-${{ github.event.issue.number || github.event.issue.index || inputs.issue || 'manual' }}
   cancel-in-progress: true
 
 jobs:
@@ -35,7 +35,7 @@ jobs:
       - name: Derive context (event.json / workflow_dispatch)
         env:
           INPUT_ISSUE: ${{ inputs.issue }}
-          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE }}
+          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE || vars.FORGE_BASE_URL }}
         run: |
           set -euo pipefail
           export EVENT_JSON="/var/run/act/workflow/event.json"
@@ -75,10 +75,11 @@ jobs:
             throw new Error("No issue number in event.json or workflow_dispatch input");
           }
 
-          const labelName =
-            ev?.label?.name ||
-            ev?.label ||
-            "workflow_dispatch";
+          // label name: best-effort (non-bloquant)
+          let labelName = "workflow_dispatch";
+          const lab = ev?.label;
+          if (typeof lab === "string") labelName = lab;
+          else if (lab && typeof lab === "object" && typeof lab.name === "string") labelName = lab.name;
 
           let apiBase = "";
           if (process.env.FORGE_API && String(process.env.FORGE_API).trim()) {
@@ -103,19 +104,20 @@ jobs:
           echo "✅ context:"
           sed -n '1,120p' /tmp/reject.env
 
-      - name: Gate on label state/rejected only
+      - name: Early gate (fast-skip, tolerant)
         run: |
           set -euo pipefail
           source /tmp/reject.env
+          echo "ℹ️ event label = $LABEL_NAME"
 
-          if [[ "$LABEL_NAME" != "state/rejected" && "$LABEL_NAME" != "workflow_dispatch" ]]; then
-            echo "ℹ️ label=$LABEL_NAME => skip"
+          if [[ "$LABEL_NAME" != "state/rejected" && "$LABEL_NAME" != "workflow_dispatch" && "$LABEL_NAME" != "" && "$LABEL_NAME" != "[object Object]" ]]; then
+            echo "ℹ️ label=$LABEL_NAME => skip early"
             echo "SKIP=1" >> /tmp/reject.env
+            echo "SKIP_REASON=\"label_not_rejected_event\"" >> /tmp/reject.env
             exit 0
           fi
-          echo "✅ proceed (issue=$ISSUE_NUMBER)"
 
-      - name: Comment + close (only if not conflicting with state/approved)
+      - name: Comment + close (only if label state/rejected is PRESENT now, and no conflict)
         env:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
         run: |
@@ -126,14 +128,15 @@ jobs:
           test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
           test -n "${API_BASE:-}" || { echo "❌ Missing API_BASE"; exit 1; }
 
-          ISSUE_JSON="$(curl -fsS \
+          curl -fsS \
             -H "Authorization: token $FORGE_TOKEN" \
             -H "Accept: application/json" \
-            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER")"
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER" \
+            -o /tmp/reject.issue.json
 
-          # conflict guard: approved + rejected => do nothing, comment warning
-          node --input-type=module - <<'NODE' "$ISSUE_JSON" > /tmp/reject.flags
-          const issue = JSON.parse(process.argv[1] || "{}");
+          node --input-type=module - <<'NODE' > /tmp/reject.flags
+          import fs from "node:fs";
+          const issue = JSON.parse(fs.readFileSync("/tmp/reject.issue.json","utf8"));
           const labels = Array.isArray(issue.labels) ? issue.labels.map(l => String(l.name || "")).filter(Boolean) : [];
           const hasApproved = labels.includes("state/approved");
           const hasRejected = labels.includes("state/rejected");
@@ -142,6 +145,12 @@ jobs:
 
           source /tmp/reject.flags
 
+          # Do nothing unless state/rejected is truly present now (anti payload weird)
+          if [[ "${HAS_REJECTED:-0}" != "1" ]]; then
+            echo "ℹ️ state/rejected not present -> skip"
+            exit 0
+          fi
+
           if [[ "${HAS_APPROVED:-0}" == "1" && "${HAS_REJECTED:-0}" == "1" ]]; then
             MSG="⚠️ Conflit d'état sur le ticket #${ISSUE_NUMBER} : labels **state/approved** et **state/rejected** présents.\n\n➡️ Action manuelle requise : retirer l'un des deux labels avant relance."
             PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
@@ -154,7 +163,6 @@ jobs:
             exit 0
           fi
 
-          # comment reject
           MSG="❌ Ticket #${ISSUE_NUMBER} refusé (label state/rejected)."
           PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
 
@@ -164,7 +172,6 @@ jobs:
             "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
             --data-binary "$PAYLOAD"
 
-          # close issue
           curl -fsS -X PATCH \
             -H "Authorization: token $FORGE_TOKEN" \
             -H "Content-Type: application/json" \

.gitea/workflows/auto-label-issues.yml

@@ -4,22 +4,37 @@ on:
   issues:
     types: [opened, edited]
 
+concurrency:
+  group: auto-label-${{ github.event.issue.number || github.event.issue.index || 'manual' }}
+  cancel-in-progress: true
+
 jobs:
   label:
     runs-on: mac-ci
+    container:
+      image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
+
     steps:
       - name: Apply labels from Type/State/Category
         env:
-          FORGE_BASE: ${{ vars.FORGE_API || vars.FORGE_BASE }}
+          # IMPORTANT: préfère FORGE_BASE (LAN) si défini, sinon FORGE_API
+          FORGE_BASE: ${{ vars.FORGE_BASE || vars.FORGE_API || vars.FORGE_API_BASE }}
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
           REPO_FULL: ${{ gitea.repository }}
           EVENT_PATH: ${{ github.event_path }}
+          NODE_OPTIONS: --dns-result-order=ipv4first
         run: |
           python3 - <<'PY'
-          import json, os, re, urllib.request, urllib.error
+          import json, os, re, time, urllib.request, urllib.error, socket
+
+          forge = (os.environ.get("FORGE_BASE") or "").rstrip("/")
+          if not forge:
+              raise SystemExit("Missing FORGE_BASE/FORGE_API repo variable (e.g. http://192.168.1.20:3000)")
+
+          token = os.environ.get("FORGE_TOKEN") or ""
+          if not token:
+              raise SystemExit("Missing secret FORGE_TOKEN")
 
-          forge = os.environ["FORGE_BASE"].rstrip("/")
-          token = os.environ["FORGE_TOKEN"]
           owner, repo = os.environ["REPO_FULL"].split("/", 1)
           event_path = os.environ["EVENT_PATH"]
 
@@ -46,12 +61,9 @@ jobs:
           print("PARSED:", {"Type": t, "State": s, "Category": c})
 
           # 1) explicite depuis le body
-          if t:
-              desired.add(t)
-          if s:
-              desired.add(s)
-          if c:
-              desired.add(c)
+          if t: desired.add(t)
+          if s: desired.add(s)
+          if c: desired.add(c)
 
           # 2) fallback depuis le titre si Type absent
           if not t:
@@ -76,42 +88,56 @@ jobs:
               "Authorization": f"token {token}",
               "Accept": "application/json",
               "Content-Type": "application/json",
-              "User-Agent": "archicratie-auto-label/1.0",
+              "User-Agent": "archicratie-auto-label/1.1",
           }
 
-          def jreq(method, url, payload=None):
+          def jreq(method, url, payload=None, timeout=60, retries=4, backoff=2.0):
               data = None if payload is None else json.dumps(payload).encode("utf-8")
-              req = urllib.request.Request(url, data=data, headers=headers, method=method)
-              try:
-                  with urllib.request.urlopen(req, timeout=20) as r:
-                      b = r.read()
-                      return json.loads(b.decode("utf-8")) if b else None
-              except urllib.error.HTTPError as e:
-                  b = e.read().decode("utf-8", errors="replace")
-                  raise RuntimeError(f"HTTP {e.code} {method} {url}\n{b}") from e
+              last_err = None
+              for i in range(retries):
+                  req = urllib.request.Request(url, data=data, headers=headers, method=method)
+                  try:
+                      with urllib.request.urlopen(req, timeout=timeout) as r:
+                          b = r.read()
+                          return json.loads(b.decode("utf-8")) if b else None
+                  except urllib.error.HTTPError as e:
+                      b = e.read().decode("utf-8", errors="replace")
+                      raise RuntimeError(f"HTTP {e.code} {method} {url}\n{b}") from e
+                  except (TimeoutError, socket.timeout, urllib.error.URLError) as e:
+                      last_err = e
+                      # retry only on network/timeout
+                      time.sleep(backoff * (i + 1))
+              raise RuntimeError(f"Network/timeout after retries: {method} {url}\n{last_err}")
 
           # labels repo
-          labels = jreq("GET", f"{api}/repos/{owner}/{repo}/labels?limit=1000") or []
+          labels = jreq("GET", f"{api}/repos/{owner}/{repo}/labels?limit=1000", timeout=60) or []
           name_to_id = {x.get("name"): x.get("id") for x in labels}
 
           missing = [x for x in desired if x not in name_to_id]
           if missing:
               raise SystemExit("Missing labels in repo: " + ", ".join(sorted(missing)))
 
-          wanted_ids = [name_to_id[x] for x in desired]
+          wanted_ids = sorted({int(name_to_id[x]) for x in desired})
 
           # labels actuels de l'issue
-          current = jreq("GET", f"{api}/repos/{owner}/{repo}/issues/{number}/labels") or []
-          current_ids = {x.get("id") for x in current if x.get("id") is not None}
+          current = jreq("GET", f"{api}/repos/{owner}/{repo}/issues/{number}/labels", timeout=60) or []
+          current_ids = {int(x.get("id")) for x in current if x.get("id") is not None}
 
           final_ids = sorted(current_ids.union(wanted_ids))
 
-          # set labels = union (n'enlève rien)
+          # Replace labels = union (n'enlève rien)
           url = f"{api}/repos/{owner}/{repo}/issues/{number}/labels"
-          try:
-              jreq("PUT", url, {"labels": final_ids})
-          except Exception:
-              jreq("PUT", url, final_ids)
+
+          # IMPORTANT: on n'envoie JAMAIS une liste brute ici (ça a causé le 422)
+          jreq("PUT", url, {"labels": final_ids}, timeout=90, retries=4)
+
+          # vérif post-apply (anti "timeout mais appliqué")
+          post = jreq("GET", f"{api}/repos/{owner}/{repo}/issues/{number}/labels", timeout=60) or []
+          post_ids = {int(x.get("id")) for x in post if x.get("id") is not None}
+
+          missing_ids = [i for i in wanted_ids if i not in post_ids]
+          if missing_ids:
+              raise RuntimeError(f"Labels not applied after PUT (missing ids): {missing_ids}")
 
           print(f"OK labels #{number}: {sorted(desired)}")
           PY

.gitea/workflows/deploy-staging-live.yml

@@ -28,7 +28,7 @@ jobs:
   deploy:
     runs-on: nas-deploy
     container:
-      image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
+      image: localhost:5000/archicratie/nas-deploy-node22@sha256:fefa8bb307005cebec07796661ab25528dc319c33a8f1e480e1d66f90cd5cff6
 
     steps:
       - name: Tools sanity
@@ -47,105 +47,179 @@ jobs:
 
           node --input-type=module <<'NODE'
           import fs from "node:fs";
+
           const ev = JSON.parse(fs.readFileSync(process.env.EVENT_JSON, "utf8"));
           const repoObj = ev?.repository || {};
+
           const cloneUrl =
             repoObj?.clone_url ||
             (repoObj?.html_url ? (repoObj.html_url.replace(/\/$/,"") + ".git") : "");
           if (!cloneUrl) throw new Error("No repository clone_url/html_url in event.json");
 
           const defaultBranch = repoObj?.default_branch || "main";
-          const sha =
+
+          // Push-range (most reliable for change detection)
+          const before = String(ev?.before || "").trim();
+          const after =
             (process.env.GITHUB_SHA && String(process.env.GITHUB_SHA).trim()) ||
-            ev?.after ||
-            ev?.sha ||
-            ev?.head_commit?.id ||
-            ev?.pull_request?.head?.sha ||
-            "";
+            String(ev?.after || ev?.sha || ev?.head_commit?.id || ev?.pull_request?.head?.sha || "").trim();
 
           const shq = (s) => "'" + String(s).replace(/'/g, "'\\''") + "'";
+
           fs.writeFileSync("/tmp/deploy.env", [
             `REPO_URL=${shq(cloneUrl)}`,
             `DEFAULT_BRANCH=${shq(defaultBranch)}`,
-            `SHA=${shq(sha)}`
+            `BEFORE=${shq(before)}`,
+            `AFTER=${shq(after)}`
           ].join("\n") + "\n");
           NODE
 
           source /tmp/deploy.env
           echo "Repo URL:       $REPO_URL"
           echo "Default branch: $DEFAULT_BRANCH"
-          echo "SHA:            ${SHA:-<empty>}"
+          echo "BEFORE:         ${BEFORE:-<empty>}"
+          echo "AFTER:          ${AFTER:-<empty>}"
 
           rm -rf .git
           git init -q
           git remote add origin "$REPO_URL"
 
-          if [[ -n "${SHA:-}" ]]; then
-            git fetch --depth 1 origin "$SHA"
+          # Checkout AFTER (or default branch if missing)
+          if [[ -n "${AFTER:-}" ]]; then
+            git fetch --depth 50 origin "$AFTER"
             git -c advice.detachedHead=false checkout -q FETCH_HEAD
           else
-            git fetch --depth 1 origin "$DEFAULT_BRANCH"
+            git fetch --depth 50 origin "$DEFAULT_BRANCH"
             git -c advice.detachedHead=false checkout -q "origin/$DEFAULT_BRANCH"
-            SHA="$(git rev-parse HEAD)"
-            echo "SHA='$SHA'" >> /tmp/deploy.env
-            echo "Resolved SHA: $SHA"
+            AFTER="$(git rev-parse HEAD)"
+            echo "AFTER='$AFTER'" >> /tmp/deploy.env
+            echo "Resolved AFTER: $AFTER"
           fi
 
           git log -1 --oneline
 
-      - name: Gate — decide HOTPATCH vs FULL rebuild
+      - name: Gate — decide SKIP vs HOTPATCH vs FULL rebuild
         env:
           INPUT_FORCE: ${{ inputs.force }}
+          EVENT_JSON: /var/run/act/workflow/event.json
         run: |
           set -euo pipefail
           source /tmp/deploy.env
 
           FORCE="${INPUT_FORCE:-0}"
 
-          # liste fichiers touchés (utile pour copier les médias)
-          CHANGED="$(git show --name-only --pretty="" "$SHA" | sed '/^$/d' || true)"
-          printf "%s\n" "$CHANGED" > /tmp/changed.txt
+          # Lire before/after du push depuis event.json (merge-proof)
+          node --input-type=module <<'NODE'
+          import fs from "node:fs";
+          const ev = JSON.parse(fs.readFileSync(process.env.EVENT_JSON, "utf8"));
+          const before = ev?.before || "";
+          const after  = ev?.after  || ev?.sha || "";
+          const shq = (s) => "'" + String(s).replace(/'/g, "'\\''") + "'";
+          fs.writeFileSync("/tmp/gate.env", [
+            `EV_BEFORE=${shq(before)}`,
+            `EV_AFTER=${shq(after)}`
+          ].join("\n") + "\n");
+          NODE
 
-          echo "== changed files =="
-          echo "$CHANGED" | sed -n '1,260p'
+          source /tmp/gate.env
 
-          if [[ "$FORCE" == "1" ]]; then
-            echo "GO=1"   >> /tmp/deploy.env
-            echo "MODE='full'" >> /tmp/deploy.env
-            echo "✅ force=1 -> MODE=full (rebuild+restart)"
-            exit 0
+          BEFORE="${EV_BEFORE:-}"
+          AFTER="${EV_AFTER:-}"
+          if [[ -z "${AFTER:-}" ]]; then
+            AFTER="${SHA:-}"
           fi
 
-          # Auto mode: uniquement annotations/media => hotpatch only
-          if echo "$CHANGED" | grep -qE '^(src/annotations/|public/media/)'; then
-            echo "GO=1" >> /tmp/deploy.env
-            echo "MODE='hotpatch'" >> /tmp/deploy.env
+          echo "Gate ctx: BEFORE=${BEFORE:-<empty>} AFTER=${AFTER:-<empty>} FORCE=${FORCE}"
+
+          # Produire une liste CHANGED fiable :
+          # - si BEFORE/AFTER valides -> git diff before..after
+          # - sinon fallback -> diff parent1..after ou show after
+          CHANGED=""
+          Z40="0000000000000000000000000000000000000000"
+
+          if [[ -n "${BEFORE:-}" && "${BEFORE}" != "${Z40}" ]] \
+             && git cat-file -e "${BEFORE}^{commit}" 2>/dev/null \
+             && git cat-file -e "${AFTER}^{commit}"  2>/dev/null; then
+            CHANGED="$(git diff --name-only "${BEFORE}" "${AFTER}" || true)"
+          else
+            P1="$(git rev-parse "${AFTER}^" 2>/dev/null || true)"
+            if [[ -n "${P1:-}" ]] && git cat-file -e "${P1}^{commit}" 2>/dev/null; then
+              CHANGED="$(git diff --name-only "${P1}" "${AFTER}" || true)"
+            else
+              CHANGED="$(git show --name-only --pretty="" "${AFTER}" | sed '/^$/d' || true)"
+            fi
+          fi
+
+          printf "%s\n" "${CHANGED}" > /tmp/changed.txt
+
+          echo "== changed files (first 200) =="
+          sed -n '1,200p' /tmp/changed.txt || true
+
+          # Flags
+          HAS_FULL=0
+          HAS_HOTPATCH=0
+
+          # HOTPATCH si annotations/media touchés
+          if grep -qE '^(src/annotations/|public/media/)' /tmp/changed.txt; then
+            HAS_HOTPATCH=1
+          fi
+
+          # FULL si build-impacting (robuste)
+          # 1) Tout src/ SAUF src/annotations/
+          if grep -qE '^src/' /tmp/changed.txt && grep -qEv '^src/annotations/' /tmp/changed.txt; then
+            HAS_FULL=1
+          fi
+
+          # 2) scripts/
+          if grep -qE '^scripts/' /tmp/changed.txt; then
+            HAS_FULL=1
+          fi
+
+          # 3) Tout public/ SAUF public/media/
+          if grep -qE '^public/' /tmp/changed.txt && grep -qEv '^public/media/' /tmp/changed.txt; then
+            HAS_FULL=1
+          fi
+
+          # 4) fichiers racine qui changent le build / l’image
+          if grep -qE '^(package\.json|package-lock\.json|astro\.config\.mjs|tsconfig\.json|\.npmrc|\.nvmrc|Dockerfile|docker-compose\.yml|nginx\.conf)$' /tmp/changed.txt; then
+            HAS_FULL=1
+          fi
+
+          echo "Gate flags: HAS_FULL=${HAS_FULL} HAS_HOTPATCH=${HAS_HOTPATCH}"
+
+          # Décision
+          if [[ "${FORCE}" == "1" ]]; then
+            GO=1
+            MODE="full"
+            echo "✅ force=1 -> MODE=full (rebuild+restart)"
+          elif [[ "${HAS_FULL}" == "1" ]]; then
+            GO=1
+            MODE="full"
+            echo "✅ build-impacting change -> MODE=full (rebuild+restart)"
+          elif [[ "${HAS_HOTPATCH}" == "1" ]]; then
+            GO=1
+            MODE="hotpatch"
             echo "✅ annotations/media change -> MODE=hotpatch"
           else
-            echo "GO=0" >> /tmp/deploy.env
-            echo "MODE='skip'" >> /tmp/deploy.env
-            echo "ℹ️ no annotations/media change -> skip deploy"
+            GO=0
+            MODE="skip"
+            echo "ℹ️ no relevant change -> skip deploy"
           fi
 
-      - name: Install docker client + docker compose plugin (v2) + python yaml
+          echo "GO=${GO}" >> /tmp/deploy.env
+          echo "MODE='${MODE}'" >> /tmp/deploy.env
+
+      - name: Toolchain sanity + resolve COMPOSE_PROJECT_NAME
         run: |
           set -euo pipefail
           source /tmp/deploy.env
           [[ "${GO:-0}" == "1" ]] || { echo "ℹ️ skipped"; exit 0; }
 
-          apt-get -o Acquire::Retries=5 -o Acquire::ForceIPv4=true update
-          apt-get install -y --no-install-recommends ca-certificates curl docker.io python3 python3-yaml
-          rm -rf /var/lib/apt/lists/*
-
-          mkdir -p /usr/local/lib/docker/cli-plugins
-          curl -fsSL \
-            "https://github.com/docker/compose/releases/download/v${COMPOSE_VERSION}/docker-compose-linux-x86_64" \
-            -o /usr/local/lib/docker/cli-plugins/docker-compose
-          chmod +x /usr/local/lib/docker/cli-plugins/docker-compose
-
+          # tools are prebaked in the image
+          git --version
           docker version
           docker compose version
-          python3 --version
+          python3 -c 'import yaml; print("PyYAML OK")'
 
           # Reuse existing compose project name if containers already exist
           PROJ="$(docker inspect archicratie-web-blue --format '{{ index .Config.Labels "com.docker.compose.project" }}' 2>/dev/null || true)"

.gitea/workflows/proposer-apply-pr.yml

@@ -0,0 +1,395 @@
+name: Proposer Apply (PR)
+
+on:
+  issues:
+    types: [labeled]
+  workflow_dispatch:
+    inputs:
+      issue:
+        description: "Issue number to apply (Proposer: correction/fact-check)"
+        required: true
+
+env:
+  NODE_OPTIONS: --dns-result-order=ipv4first
+
+defaults:
+  run:
+    shell: bash
+
+concurrency:
+  group: proposer-apply-${{ github.event.issue.number || inputs.issue || 'manual' }}
+  cancel-in-progress: true
+
+jobs:
+  apply-proposer:
+    runs-on: mac-ci
+    container:
+      image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
+
+    steps:
+      - name: Tools sanity
+        run: |
+          set -euo pipefail
+          git --version
+          node --version
+          npm --version
+
+      - name: Derive context (event.json / workflow_dispatch)
+        env:
+          INPUT_ISSUE: ${{ inputs.issue }}
+          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE }}
+        run: |
+          set -euo pipefail
+          export EVENT_JSON="/var/run/act/workflow/event.json"
+          test -f "$EVENT_JSON" || { echo "❌ Missing $EVENT_JSON"; exit 1; }
+
+          node --input-type=module - <<'NODE' > /tmp/proposer.env
+          import fs from "node:fs";
+
+          const ev = JSON.parse(fs.readFileSync(process.env.EVENT_JSON, "utf8"));
+          const repoObj = ev?.repository || {};
+
+          const cloneUrl =
+            repoObj?.clone_url ||
+            (repoObj?.html_url ? (repoObj.html_url.replace(/\/$/,"") + ".git") : "");
+
+          if (!cloneUrl) throw new Error("No repository clone_url/html_url in event.json");
+
+          let owner =
+            repoObj?.owner?.login ||
+            repoObj?.owner?.username ||
+            (repoObj?.full_name ? repoObj.full_name.split("/")[0] : "");
+
+          let repo =
+            repoObj?.name ||
+            (repoObj?.full_name ? repoObj.full_name.split("/")[1] : "");
+
+          if (!owner || !repo) {
+            const m = cloneUrl.match(/[:/](?<o>[^/]+)\/(?<r>[^/]+?)(?:\.git)?$/);
+            if (m?.groups) { owner = owner || m.groups.o; repo = repo || m.groups.r; }
+          }
+          if (!owner || !repo) throw new Error("Cannot infer owner/repo");
+
+          const defaultBranch = repoObj?.default_branch || "main";
+
+          const issueNumber =
+            ev?.issue?.number ||
+            ev?.issue?.index ||
+            (process.env.INPUT_ISSUE ? Number(process.env.INPUT_ISSUE) : 0);
+
+          if (!issueNumber || !Number.isFinite(Number(issueNumber))) {
+            throw new Error("No issue number in event.json or workflow_dispatch input");
+          }
+
+          const labelName =
+            ev?.label?.name ||
+            ev?.label ||
+            "workflow_dispatch";
+
+          const u = new URL(cloneUrl);
+          const origin = u.origin;
+
+          const apiBase = (process.env.FORGE_API && String(process.env.FORGE_API).trim())
+            ? String(process.env.FORGE_API).trim().replace(/\/+$/,"")
+            : origin;
+
+          function sh(s){ return JSON.stringify(String(s)); }
+          process.stdout.write([
+            `CLONE_URL=${sh(cloneUrl)}`,
+            `OWNER=${sh(owner)}`,
+            `REPO=${sh(repo)}`,
+            `DEFAULT_BRANCH=${sh(defaultBranch)}`,
+            `ISSUE_NUMBER=${sh(issueNumber)}`,
+            `LABEL_NAME=${sh(labelName)}`,
+            `API_BASE=${sh(apiBase)}`
+          ].join("\n") + "\n");
+          NODE
+
+          echo "✅ context:"
+          sed -n '1,120p' /tmp/proposer.env
+
+      - name: Gate on label state/approved
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+
+          if [[ "$LABEL_NAME" != "state/approved" && "$LABEL_NAME" != "workflow_dispatch" ]]; then
+            echo "ℹ️ label=$LABEL_NAME => skip"
+            echo "SKIP=1" >> /tmp/proposer.env
+            exit 0
+          fi
+          echo "✅ proceed (issue=$ISSUE_NUMBER)"
+
+      - name: Fetch issue + API-hard gate on (state/approved present + proposer type)
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
+          test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
+
+          curl -fsS \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Accept: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER" \
+            -o /tmp/issue.json
+
+          node --input-type=module - <<'NODE' >> /tmp/proposer.env
+          import fs from "node:fs";
+          const issue = JSON.parse(fs.readFileSync("/tmp/issue.json","utf8"));
+          const title = String(issue.title || "");
+          const body = String(issue.body || "").replace(/\r\n/g, "\n");
+          const labels = Array.isArray(issue.labels) ? issue.labels.map(l => String(l.name||"")).filter(Boolean) : [];
+
+          function pickLine(key) {
+            const re = new RegExp(`^\\s*${key}\\s*:\\s*([^\\n\\r]+)`, "mi");
+            const m = body.match(re);
+            return m ? m[1].trim() : "";
+          }
+
+          const typeRaw = pickLine("Type");
+          const type = String(typeRaw || "").trim().toLowerCase();
+
+          const hasApproved = labels.includes("state/approved");
+          const proposer = new Set(["type/correction","type/fact-check"]);
+
+          const out = [];
+          out.push(`ISSUE_TITLE=${JSON.stringify(title)}`);
+          out.push(`ISSUE_TYPE=${JSON.stringify(type)}`);
+          out.push(`HAS_APPROVED=${hasApproved ? "1":"0"}`);
+
+          if (!hasApproved) {
+            out.push(`SKIP=1`);
+            out.push(`SKIP_REASON=${JSON.stringify("approved_not_present")}`);
+          } else if (!type) {
+            out.push(`SKIP=1`);
+            out.push(`SKIP_REASON=${JSON.stringify("missing_type")}`);
+          } else if (!proposer.has(type)) {
+            out.push(`SKIP=1`);
+            out.push(`SKIP_REASON=${JSON.stringify("not_proposer:"+type)}`);
+          }
+          process.stdout.write(out.join("\n") + "\n");
+          NODE
+
+          echo "✅ proposer gating:"
+          grep -E '^(ISSUE_TYPE|HAS_APPROVED|SKIP|SKIP_REASON)=' /tmp/proposer.env || true
+
+      - name: Comment issue if skipped
+        if: ${{ always() }}
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+
+          [[ "${SKIP:-0}" == "1" ]] || exit 0
+          [[ "$LABEL_NAME" == "state/approved" || "$LABEL_NAME" == "workflow_dispatch" ]] || exit 0
+
+          REASON="${SKIP_REASON:-}"
+          TYPE="${ISSUE_TYPE:-}"
+
+          if [[ "$REASON" == "approved_not_present" ]]; then
+            MSG="ℹ️ Proposer Apply: skip — le label **state/approved** n'est pas présent sur le ticket au moment du run (gate API-hard)."
+          elif [[ "$REASON" == "missing_type" ]]; then
+            MSG="ℹ️ Proposer Apply: skip — champ **Type:** manquant/illisible. Attendu: type/correction ou type/fact-check."
+          else
+            MSG="ℹ️ Proposer Apply: skip — Type non-Proposer (${TYPE}). (Ce workflow ne traite que correction/fact-check.)"
+          fi
+
+          PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
+          curl -fsS -X POST \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Content-Type: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
+            --data-binary "$PAYLOAD" || true
+
+      - name: Checkout default branch
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
+          rm -rf .git
+          git init -q
+          git remote add origin "$CLONE_URL"
+          git fetch --depth 1 origin "$DEFAULT_BRANCH"
+          git -c advice.detachedHead=false checkout -q FETCH_HEAD
+          git log -1 --oneline
+          echo "✅ workspace:"
+          ls -la | sed -n '1,120p'
+
+      - name: Detect app dir (repo-root vs ./site)
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
+          APP_DIR="."
+          if [[ -d "site" && -f "site/package.json" ]]; then
+            APP_DIR="site"
+          fi
+
+          echo "APP_DIR=$APP_DIR" >> /tmp/proposer.env
+          echo "✅ APP_DIR=$APP_DIR"
+          ls -la "$APP_DIR" | sed -n '1,120p'
+          test -f "$APP_DIR/package.json" || { echo "❌ package.json missing in APP_DIR=$APP_DIR"; exit 1; }
+          test -d "$APP_DIR/scripts" || { echo "❌ scripts/ missing in APP_DIR=$APP_DIR"; exit 1; }
+
+      - name: NPM harden (reduce flakiness)
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+          cd "$APP_DIR"
+          npm config set fetch-retries 5
+          npm config set fetch-retry-mintimeout 20000
+          npm config set fetch-retry-maxtimeout 120000
+          npm config set registry https://registry.npmjs.org
+
+      - name: Install deps (APP_DIR)
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          cd "$APP_DIR"
+          npm ci --no-audit --no-fund
+
+      - name: Build dist baseline (APP_DIR)
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          cd "$APP_DIR"
+          npm run build
+
+      - name: Apply ticket (alias + commit) on bot branch
+        continue-on-error: true
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+          BOT_GIT_NAME: ${{ secrets.BOT_GIT_NAME }}
+          BOT_GIT_EMAIL: ${{ secrets.BOT_GIT_EMAIL }}
+          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
+          git config user.name  "${BOT_GIT_NAME:-archicratie-bot}"
+          git config user.email "${BOT_GIT_EMAIL:-bot@archicratie.local}"
+
+          START_SHA="$(git rev-parse HEAD)"
+          TS="$(date -u +%Y%m%d-%H%M%S)"
+          BR="bot/proposer-${ISSUE_NUMBER}-${TS}"
+          echo "BRANCH=$BR" >> /tmp/proposer.env
+          git checkout -b "$BR"
+
+          export GITEA_OWNER="$OWNER"
+          export GITEA_REPO="$REPO"
+          export FORGE_BASE="$API_BASE"
+
+          LOG="/tmp/proposer-apply.log"
+          set +e
+          (cd "$APP_DIR" && node scripts/apply-ticket.mjs "$ISSUE_NUMBER" --alias --commit) >"$LOG" 2>&1
+          RC=$?
+          set -e
+
+          echo "APPLY_RC=$RC" >> /tmp/proposer.env
+
+          echo "== apply log (tail) =="
+          tail -n 200 "$LOG" || true
+
+          END_SHA="$(git rev-parse HEAD)"
+          if [[ "$RC" -ne 0 ]]; then
+            echo "NOOP=0" >> /tmp/proposer.env
+            exit 0
+          fi
+
+          if [[ "$START_SHA" == "$END_SHA" ]]; then
+            echo "NOOP=1" >> /tmp/proposer.env
+          else
+            echo "NOOP=0" >> /tmp/proposer.env
+            echo "END_SHA=$END_SHA" >> /tmp/proposer.env
+          fi
+
+      - name: Push bot branch
+        if: ${{ always() }}
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          [[ "${APPLY_RC:-0}" == "0" ]] || { echo "ℹ️ apply failed -> skip push"; exit 0; }
+          [[ "${NOOP:-0}" == "0" ]] || { echo "ℹ️ no-op -> skip push"; exit 0; }
+          [[ -n "${BRANCH:-}" ]] || { echo "ℹ️ BRANCH unset -> skip push"; exit 0; }
+
+          AUTH_URL="$(node --input-type=module -e '
+            const [clone, tok] = process.argv.slice(1);
+            const u = new URL(clone);
+            u.username = "oauth2";
+            u.password = tok;
+            console.log(u.toString());
+          ' "$CLONE_URL" "$FORGE_TOKEN")"
+
+          git remote set-url origin "$AUTH_URL"
+          git push -u origin "$BRANCH"
+
+      - name: Create PR + comment issue
+        if: ${{ always() }}
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          [[ "${APPLY_RC:-0}" == "0" ]] || exit 0
+          [[ "${NOOP:-0}" == "0" ]] || exit 0
+          [[ -n "${BRANCH:-}" ]] || { echo "ℹ️ BRANCH unset -> skip PR"; exit 0; }
+
+          PR_TITLE="proposer: apply ticket #${ISSUE_NUMBER}"
+          PR_BODY="PR auto depuis ticket #${ISSUE_NUMBER} (state/approved).\n\n- Branche: ${BRANCH}\n- Commit: ${END_SHA:-unknown}\n\nMerge si CI OK."
+
+          PR_PAYLOAD="$(node --input-type=module -e '
+            const [title, body, base, head] = process.argv.slice(1);
+            console.log(JSON.stringify({ title, body, base, head, allow_maintainer_edit: true }));
+          ' "$PR_TITLE" "$PR_BODY" "$DEFAULT_BRANCH" "${OWNER}:${BRANCH}")"
+
+          PR_JSON="$(curl -fsS -X POST \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Content-Type: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/pulls" \
+            --data-binary "$PR_PAYLOAD")"
+
+          PR_URL="$(node --input-type=module -e '
+            const pr = JSON.parse(process.argv[1] || "{}");
+            console.log(pr.html_url || pr.url || "");
+          ' "$PR_JSON")"
+
+          test -n "$PR_URL" || { echo "❌ PR URL missing. Raw: $PR_JSON"; exit 1; }
+
+          MSG="✅ PR Proposer créée pour ticket #${ISSUE_NUMBER} : ${PR_URL}"
+          C_PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
+
+          curl -fsS -X POST \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Content-Type: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
+            --data-binary "$C_PAYLOAD"
+
+      - name: Finalize (fail job if apply failed)
+        if: ${{ always() }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          RC="${APPLY_RC:-0}"
+          if [[ "$RC" != "0" ]]; then
+            echo "❌ apply failed (rc=$RC)"
+            exit "$RC"
+          fi
+          echo "✅ apply ok"

docs/OPS-DEPLOYMENT.md

@@ -25,6 +25,19 @@ Objectif : déployer une nouvelle version du site sur le NAS (DS220+) sans jamai
 
 ➡️ Déploiement = `docs/DEPLOY_PROD_SYNOLOGY_DS220.md` (procédure détaillée, à jour).
 
+## Mise à jour (2026-03-03) — Gate CI de déploiement (SKIP / HOTPATCH / FULL) + preuves A/B
+
+La procédure de déploiement “vivante” est désormais pilotée par **Gitea Actions** via le workflow :
+- `.gitea/workflows/deploy-staging-live.yml`
+
+Ce workflow décide automatiquement :
+- **FULL** (rebuild + restart blue + green) dès qu’un changement impacte le build (ex: `src/content/`, `src/pages/`, `scripts/`, `src/anchors/`, etc.)
+- **HOTPATCH** (patch JSON + copie media) quand le changement ne concerne que `src/annotations/` et/ou `public/media/`
+- **SKIP** sinon
+
+Les preuves et la procédure de test reproductible A/B sont documentées dans :
+➡️ `docs/runbooks/DEPLOY-BLUE-GREEN.md` → section “CI Deploy gate (merge-proof) + Tests A/B + preuve alias injection”.
+
 ## Schéma (résumé, sans commandes)
 
 - Ne jamais toucher au slot live.

docs/OPS_COCKPIT.md

@@ -202,4 +202,33 @@ docker compose logs --tail=200 web_blue
 docker compose logs --tail=200 web_green
 
 # Si tu veux suivre en live :
-docker compose logs -f web_green
+docker compose logs -f web_green
+
+
+## Historique synthétique (2026-03-03) — Stabilisation CI/CD “zéro surprise”
+
+### Problème initial observé
+- Déploiement parfois lancé en “hotpatch” alors qu’un rebuild était nécessaire.
+- Sur merge commits, la détection de fichiers modifiés pouvait être ambiguë.
+- Résultat : besoin de `force=1` manuel pour éviter des incohérences.
+
+### Correctif appliqué
+- Gate CI rendu **merge-proof** :
+  - lecture de `BEFORE` et `AFTER` depuis `event.json`
+  - calcul des fichiers modifiés via `git diff --name-only BEFORE AFTER`
+
+- Politique de décision stabilisée :
+  - FULL auto dès qu’un changement impacte build/runtime (content/pages/scripts/anchors/etc.)
+  - HOTPATCH auto uniquement pour annotations/media
+
+### Preuves
+- Test A (touch src/content) :
+  - Gate flags: HAS_FULL=1 HAS_HOTPATCH=0 → MODE=full
+- Test B (touch src/annotations) :
+  - Gate flags: HAS_FULL=0 HAS_HOTPATCH=1 → MODE=hotpatch
+
+### Audit post-déploiement (preuves côté NAS)
+- 8081 + 8082 répondent HTTP 200
+- `/para-index.json` + `/annotations-index.json` OK
+- Aliases injectés visibles dans HTML via `.para-alias` quand alias présent
+

docs/runbooks/DEPLOY-BLUE-GREEN.md

@@ -199,4 +199,348 @@ Ne jamais modifier dist/ “à la main” sur NAS.
 
 Si un hotfix prod est indispensable : documenter et backporter via PR Gitea.
 
-Le canonical dépend du build : PUBLIC_SITE doit être injecté (voir runbook ENV-PUBLIC_SITE).
+Le canonical dépend du build : PUBLIC_SITE doit être injecté (voir runbook ENV-PUBLIC_SITE).
+
+## 10) CI Deploy (Gitea Actions) — Gate SKIP / HOTPATCH / FULL (merge-proof) + preuves
+
+Cette section documente le comportement **canonique** du workflow :
+- `.gitea/workflows/deploy-staging-live.yml`
+
+Objectif : **zéro surprise**.
+On ne veut plus “penser à force=1”.
+Le gate doit décider automatiquement, y compris sur des **merge commits**.
+
+### 10.1 — Principe (ce que fait réellement le gate)
+
+Le job `deploy` calcule les fichiers modifiés entre :
+- `BEFORE` = commit précédent (avant le push sur main)
+- `AFTER`  = commit actuel (après le push / merge sur main)
+
+Puis il classe le déploiement dans un mode :
+
+- **MODE=full**
+  - rebuild image + restart `archicratie-web-blue` (8081) + `archicratie-web-green` (8082)
+  - warmup endpoints (para-index, annotations-index, pagefind.js)
+  - vérification canonical staging + live
+
+- **MODE=hotpatch**
+  - rebuild d’un `annotations-index.json` consolidé depuis `src/annotations/**`
+  - patch direct dans les conteneurs en cours d’exécution (blue+green)
+  - copie des médias modifiés `public/media/**` vers `/usr/share/nginx/html/media/**`
+  - smoke sur `/annotations-index.json` des deux ports
+
+- **MODE=skip**
+  - pas de déploiement (on évite le bruit)
+
+⚠️ Important : le mode “hotpatch” **ne rebuild pas** Astro.
+Donc toute modification de contenu, routes, scripts, anchors, etc. doit déclencher **full**.
+
+### 10.2 — Matrice de décision (règles officielles)
+
+Le gate définit deux flags :
+- `HAS_FULL=1` si changement “build-impacting”
+- `HAS_HOTPATCH=1` si changement “annotations/media only”
+
+Règle de priorité :
+1) Si `HAS_FULL=1` → **MODE=full**
+2) Sinon si `HAS_HOTPATCH=1` → **MODE=hotpatch**
+3) Sinon → **MODE=skip**
+
+#### 10.2.1 — Changements qui déclenchent FULL (build-impacting)
+
+Exemples typiques (non exhaustif, mais on couvre le cœur) :
+- `src/content/**` (contenu MD/MDX)
+- `src/pages/**` (routes Astro)
+- `src/anchors/**` (aliases d’ancres)
+- `scripts/**` (tooling postbuild : injection, index, tests)
+- `src/layouts/**`, `src/components/**`, `src/styles/**` (rendu et scripts inline)
+- `astro.config.mjs`, `package.json`, `package-lock.json`
+- `Dockerfile`, `docker-compose.yml`, `nginx.conf`
+- `.gitea/workflows/**` (changement infra CI/CD)
+
+=> On veut **full** pour garantir cohérence et éviter “site partiellement mis à jour”.
+
+#### 10.2.2 — Changements qui déclenchent HOTPATCH (sans rebuild)
+
+Uniquement :
+- `src/annotations/**` (shards YAML)
+- `public/media/**` (assets média)
+
+=> On veut hotpatch pour vitesse et éviter rebuild NAS.
+
+### 10.3 — “Merge-proof” : pourquoi on ne lit PAS seulement `git show $SHA`
+
+Sur un merge commit, `git show --name-only $SHA` peut être trompeur selon le contexte.
+La méthode robuste est :
+- utiliser `event.json` (Gitea Actions) pour récupérer `before` et `after`
+- calculer `git diff --name-only BEFORE AFTER`
+
+C’est ce qui rend le gate **merge-proof**.
+
+### 10.4 — Tests de preuve A/B (reproductibles)
+
+Ces tests valident le gate sans ambiguïté.
+But : vérifier que le mode choisi est EXACTEMENT celui attendu.
+
+#### Test A — toucher `src/content/...` (FULL auto)
+
+1) Créer une branche test
+2) Modifier 1 fichier dans `src/content/` (ex : ajouter une ligne de commentaire non destructive)
+3) PR → merge dans `main`
+4) Vérifier dans `deploy-staging-live.yml` :
+
+Attendus :
+- `Gate flags: HAS_FULL=1 HAS_HOTPATCH=0`
+- `✅ build-impacting change -> MODE=full (rebuild+restart)`
+- Les étapes FULL (blue puis green) s’exécutent réellement
+
+#### Test B — toucher `src/annotations/...` uniquement (HOTPATCH auto)
+
+1) Créer une branche test
+2) Modifier 1 fichier sous `src/annotations/**` (ex: un champ comment, ts, etc.)
+3) PR → merge dans `main`
+4) Vérifier dans `deploy-staging-live.yml` :
+
+Attendus :
+- `Gate flags: HAS_FULL=0 HAS_HOTPATCH=1`
+- `✅ annotations/media change -> MODE=hotpatch`
+- Les étapes FULL sont “skip” (durée 0s)
+- L’étape HOTPATCH s’exécute réellement
+
+### 10.5 — Preuve opérationnelle côté NAS (2 URLs + 2 commandes)
+
+But : prouver que staging+live servent bien les endpoints essentiels (et que le déploiement n’a pas “fait semblant”).
+
+#### 10.5.1 — Deux URLs à vérifier (staging et live)
+
+- Staging (blue) : `http://127.0.0.1:8081/`
+- Live (green)  : `http://127.0.0.1:8082/`
+
+#### 10.5.2 — Deux commandes minimales (zéro débat)
+
+```bash
+curl -fsSI http://127.0.0.1:8081/ | head -n 1
+curl -fsSI http://127.0.0.1:8082/ | head -n 1
+
+---
+
+## 10) CI Deploy (Gitea Actions) — Gate SKIP / HOTPATCH / FULL (merge-proof) + preuves
+
+Cette section documente le comportement **canonique** du workflow :
+- `.gitea/workflows/deploy-staging-live.yml`
+
+Objectif : **zéro surprise**.
+On ne veut plus “penser à force=1”.
+Le gate doit décider automatiquement, y compris sur des **merge commits**.
+
+### 10.1 — Principe (ce que fait réellement le gate)
+
+Le job `deploy` calcule les fichiers modifiés entre :
+- `BEFORE` = commit précédent (avant le push sur main)
+- `AFTER`  = commit actuel (après le push / merge sur main)
+
+Puis il classe le déploiement dans un mode :
+
+- **MODE=full**
+  - rebuild image + restart `archicratie-web-blue` (8081) + `archicratie-web-green` (8082)
+  - warmup endpoints (para-index, annotations-index, pagefind.js)
+  - vérification canonical staging + live
+
+- **MODE=hotpatch**
+  - rebuild d’un `annotations-index.json` consolidé depuis `src/annotations/**`
+  - patch direct dans les conteneurs en cours d’exécution (blue+green)
+  - copie des médias modifiés `public/media/**` vers `/usr/share/nginx/html/media/**`
+  - smoke sur `/annotations-index.json` des deux ports
+
+- **MODE=skip**
+  - pas de déploiement (on évite le bruit)
+
+⚠️ Important : le mode “hotpatch” **ne rebuild pas** Astro.
+Donc toute modification de contenu, routes, scripts, anchors, etc. doit déclencher **full**.
+
+### 10.2 — Matrice de décision (règles officielles)
+
+Le gate définit deux flags :
+- `HAS_FULL=1` si changement “build-impacting”
+- `HAS_HOTPATCH=1` si changement “annotations/media only”
+
+Règle de priorité :
+1) Si `HAS_FULL=1` → **MODE=full**
+2) Sinon si `HAS_HOTPATCH=1` → **MODE=hotpatch**
+3) Sinon → **MODE=skip**
+
+#### 10.2.1 — Changements qui déclenchent FULL (build-impacting)
+
+Exemples typiques (non exhaustif, mais on couvre le cœur) :
+- `src/content/**` (contenu MD/MDX)
+- `src/pages/**` (routes Astro)
+- `src/anchors/**` (aliases d’ancres)
+- `scripts/**` (tooling postbuild : injection, index, tests)
+- `src/layouts/**`, `src/components/**`, `src/styles/**` (rendu et scripts inline)
+- `astro.config.mjs`, `package.json`, `package-lock.json`
+- `Dockerfile`, `docker-compose.yml`, `nginx.conf`
+- `.gitea/workflows/**` (changement infra CI/CD)
+
+=> On veut **full** pour garantir cohérence et éviter “site partiellement mis à jour”.
+
+#### 10.2.2 — Changements qui déclenchent HOTPATCH (sans rebuild)
+
+Uniquement :
+- `src/annotations/**` (shards YAML)
+- `public/media/**` (assets média)
+
+=> On veut hotpatch pour vitesse et éviter rebuild NAS.
+
+### 10.3 — “Merge-proof” : pourquoi on ne lit PAS seulement `git show $SHA`
+
+Sur un merge commit, `git show --name-only $SHA` peut être trompeur selon le contexte.
+La méthode robuste est :
+- utiliser `event.json` (Gitea Actions) pour récupérer `before` et `after`
+- calculer `git diff --name-only BEFORE AFTER`
+
+C’est ce qui rend le gate **merge-proof**.
+
+### 10.4 — Tests de preuve A/B (reproductibles)
+
+Ces tests valident le gate sans ambiguïté.
+But : vérifier que le mode choisi est EXACTEMENT celui attendu.
+
+#### Test A — toucher `src/content/...` (FULL auto)
+
+1) Créer une branche test
+2) Modifier 1 fichier dans `src/content/` (ex : ajouter une ligne de commentaire non destructive)
+3) PR → merge dans `main`
+4) Vérifier dans `deploy-staging-live.yml` :
+
+Attendus :
+- `Gate flags: HAS_FULL=1 HAS_HOTPATCH=0`
+- `✅ build-impacting change -> MODE=full (rebuild+restart)`
+- Les étapes FULL (blue puis green) s’exécutent réellement
+
+#### Test B — toucher `src/annotations/...` uniquement (HOTPATCH auto)
+
+1) Créer une branche test
+2) Modifier 1 fichier sous `src/annotations/**` (ex: un champ comment, ts, etc.)
+3) PR → merge dans `main`
+4) Vérifier dans `deploy-staging-live.yml` :
+
+Attendus :
+- `Gate flags: HAS_FULL=0 HAS_HOTPATCH=1`
+- `✅ annotations/media change -> MODE=hotpatch`
+- Les étapes FULL sont “skip” (durée 0s)
+- L’étape HOTPATCH s’exécute réellement
+
+### 10.5 — Preuve opérationnelle côté NAS (2 URLs + 2 commandes)
+
+But : prouver que staging+live servent bien les endpoints essentiels (et que le déploiement n’a pas “fait semblant”).
+
+#### 10.5.1 — Deux URLs à vérifier (staging et live)
+
+- Staging (blue) : `http://127.0.0.1:8081/`
+- Live (green)  : `http://127.0.0.1:8082/`
+
+#### 10.5.2 — Deux commandes minimales (zéro débat)
+
+en bash :
+curl -fsSI http://127.0.0.1:8081/ | head -n 1
+curl -fsSI http://127.0.0.1:8082/ | head -n 1
+
+Attendu : HTTP/1.1 200 OK des deux côtés.
+
+10.6 — Preuve “alias injection” (ancre ancienne → nouvelle) sur une page
+
+Contexte : lorsqu’un paragraphe change (ex: ticket “Proposer” appliqué),
+l’ID de paragraphe peut changer, mais on doit préserver les liens anciens via :
+
+src/anchors/anchor-aliases.json
+
+injection build-time dans dist (span .para-alias)
+
+10.6.1 — Check rapide (staging + live)
+
+Remplacer OLD/NEW par tes ids réels :
+
+Attendu : HTTP/1.1 200 OK des deux côtés.
+
+10.6 — Preuve “alias injection” (ancre ancienne → nouvelle) sur une page
+
+Contexte : lorsqu’un paragraphe change (ex: ticket “Proposer” appliqué),
+l’ID de paragraphe peut changer, mais on doit préserver les liens anciens via :
+
+src/anchors/anchor-aliases.json
+
+injection build-time dans dist (span .para-alias)
+
+10.6.1 — Check rapide (staging + live)
+
+Remplacer OLD/NEW par tes ids réels :
+
+OLD="p-1-60c7ea48"
+NEW="p-1-a21087b0"
+
+for P in 8081 8082; do
+  echo "=== $P ==="
+  HTML="$(curl -fsS "http://127.0.0.1:${P}/archicrat-ia/chapitre-3/" | tr -d '\r')"
+  echo "OLD count: $(printf '%s' "$HTML" | grep -o "$OLD" | wc -l | tr -d ' ')"
+  echo "NEW count: $(printf '%s' "$HTML" | grep -o "$NEW" | wc -l | tr -d ' ')"
+  printf '%s\n' "$HTML" | grep -nE "$OLD|$NEW|class=\"para-alias\"" | head -n 40 || true
+done
+
+Attendu :
+
+présence d’un alias : <span id="$OLD" class="para-alias"...>
+
+présence du nouveau paragraphe : <p id="$NEW">...
+
+10.6.2 — Check “lien ancien ne casse pas” (HTTP 200)
+
+for P in 8081 8082; do
+  curl -fsSI "http://127.0.0.1:${P}/archicrat-ia/chapitre-3/#${OLD}" | head -n 1
+done
+
+Attendu : HTTP/1.1 200 OK et navigation fonctionnelle côté navigateur.
+
+10.7 — Troubleshooting gate (symptômes typiques)
+Symptom 1 : job bloqué “Set up job” très longtemps
+
+Causes fréquentes :
+
+runner indisponible / capacity saturée
+
+runner ne récupère pas les tâches (fetch_timeout trop court + réseau instable)
+
+erreur dans “Gate — decide …” qui casse bash (et donne l’impression d’un hang)
+
+Commandes NAS (diagnostic rapide) :
+
+docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Image}}' | grep -E 'gitea-act-runner|registry|archicratie-web'
+docker logs --since 30m --tail 400 gitea-act-runner | tail -n 200
+Symptom 2 : conditional binary operator expected
+
+Cause :
+
+test bash du type [[ "$X" == "1" && "$Y" == "2" ]] mal formé
+
+variable vide non quotée
+
+usage d’un opérateur non supporté dans la shell effective
+
+Fix :
+
+set -euo pipefail
+
+toujours quoter : [[ "${VAR:-}" == "..." ]]
+
+logguer BEFORE/AFTER/FORCE et s’assurer qu’ils ne sont pas vides
+
+Symptom 3 : le gate liste “trop de fichiers” alors qu’on a changé 1 seul fichier
+
+Cause :
+
+comparaison faite sur le mauvais range (ex: git show sur merge, ou mauvais parent)
+Fix :
+
+toujours utiliser git diff --name-only "$BEFORE" "$AFTER" (merge-proof)
+
+confirmer dans le log : Gate ctx: BEFORE=... AFTER=...
+

package-lock.json

@@ -9,7 +9,7 @@
       "version": "0.0.1",
       "dependencies": {
         "@astrojs/mdx": "^4.3.13",
-        "astro": "^5.17.3"
+        "astro": "^5.18.0"
       },
       "devDependencies": {
         "@astrojs/sitemap": "^3.7.0",
@@ -1247,9 +1247,9 @@
       "license": "MIT"
     },
     "node_modules/@rollup/rollup-android-arm-eabi": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.55.1.tgz",
-      "integrity": "sha512-9R0DM/ykwfGIlNu6+2U09ga0WXeZ9MRC2Ter8jnz8415VbuIykVuc6bhdrbORFZANDmTDvq26mJrEVTl8TdnDg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz",
+      "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==",
       "cpu": [
         "arm"
       ],
@@ -1260,9 +1260,9 @@
       ]
     },
     "node_modules/@rollup/rollup-android-arm64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.55.1.tgz",
-      "integrity": "sha512-eFZCb1YUqhTysgW3sj/55du5cG57S7UTNtdMjCW7LwVcj3dTTcowCsC8p7uBdzKsZYa8J7IDE8lhMI+HX1vQvg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz",
+      "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==",
       "cpu": [
         "arm64"
       ],
@@ -1273,9 +1273,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.55.1.tgz",
-      "integrity": "sha512-p3grE2PHcQm2e8PSGZdzIhCKbMCw/xi9XvMPErPhwO17vxtvCN5FEA2mSLgmKlCjHGMQTP6phuQTYWUnKewwGg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz",
+      "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==",
       "cpu": [
         "arm64"
       ],
@@ -1286,9 +1286,9 @@
       ]
     },
     "node_modules/@rollup/rollup-darwin-x64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.55.1.tgz",
-      "integrity": "sha512-rDUjG25C9qoTm+e02Esi+aqTKSBYwVTaoS1wxcN47/Luqef57Vgp96xNANwt5npq9GDxsH7kXxNkJVEsWEOEaQ==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz",
+      "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==",
       "cpu": [
         "x64"
       ],
@@ -1299,9 +1299,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-arm64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.55.1.tgz",
-      "integrity": "sha512-+JiU7Jbp5cdxekIgdte0jfcu5oqw4GCKr6i3PJTlXTCU5H5Fvtkpbs4XJHRmWNXF+hKmn4v7ogI5OQPaupJgOg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz",
+      "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==",
       "cpu": [
         "arm64"
       ],
@@ -1312,9 +1312,9 @@
       ]
     },
     "node_modules/@rollup/rollup-freebsd-x64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.55.1.tgz",
-      "integrity": "sha512-V5xC1tOVWtLLmr3YUk2f6EJK4qksksOYiz/TCsFHu/R+woubcLWdC9nZQmwjOAbmExBIVKsm1/wKmEy4z4u4Bw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz",
+      "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==",
       "cpu": [
         "x64"
       ],
@@ -1325,9 +1325,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.55.1.tgz",
-      "integrity": "sha512-Rn3n+FUk2J5VWx+ywrG/HGPTD9jXNbicRtTM11e/uorplArnXZYsVifnPPqNNP5BsO3roI4n8332ukpY/zN7rQ==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz",
+      "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==",
       "cpu": [
         "arm"
       ],
@@ -1338,9 +1338,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm-musleabihf": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.55.1.tgz",
-      "integrity": "sha512-grPNWydeKtc1aEdrJDWk4opD7nFtQbMmV7769hiAaYyUKCT1faPRm2av8CX1YJsZ4TLAZcg9gTR1KvEzoLjXkg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz",
+      "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==",
       "cpu": [
         "arm"
       ],
@@ -1351,9 +1351,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.55.1.tgz",
-      "integrity": "sha512-a59mwd1k6x8tXKcUxSyISiquLwB5pX+fJW9TkWU46lCqD/GRDe9uDN31jrMmVP3feI3mhAdvcCClhV8V5MhJFQ==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz",
+      "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==",
       "cpu": [
         "arm64"
       ],
@@ -1364,9 +1364,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-arm64-musl": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.55.1.tgz",
-      "integrity": "sha512-puS1MEgWX5GsHSoiAsF0TYrpomdvkaXm0CofIMG5uVkP6IBV+ZO9xhC5YEN49nsgYo1DuuMquF9+7EDBVYu4uA==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz",
+      "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==",
       "cpu": [
         "arm64"
       ],
@@ -1377,9 +1377,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-loong64-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.55.1.tgz",
-      "integrity": "sha512-r3Wv40in+lTsULSb6nnoudVbARdOwb2u5fpeoOAZjFLznp6tDU8kd+GTHmJoqZ9lt6/Sys33KdIHUaQihFcu7g==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz",
+      "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==",
       "cpu": [
         "loong64"
       ],
@@ -1390,9 +1390,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-loong64-musl": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.55.1.tgz",
-      "integrity": "sha512-MR8c0+UxAlB22Fq4R+aQSPBayvYa3+9DrwG/i1TKQXFYEaoW3B5b/rkSRIypcZDdWjWnpcvxbNaAJDcSbJU3Lw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz",
+      "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==",
       "cpu": [
         "loong64"
       ],
@@ -1403,9 +1403,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.55.1.tgz",
-      "integrity": "sha512-3KhoECe1BRlSYpMTeVrD4sh2Pw2xgt4jzNSZIIPLFEsnQn9gAnZagW9+VqDqAHgm1Xc77LzJOo2LdigS5qZ+gw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz",
+      "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==",
       "cpu": [
         "ppc64"
       ],
@@ -1416,9 +1416,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-ppc64-musl": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.55.1.tgz",
-      "integrity": "sha512-ziR1OuZx0vdYZZ30vueNZTg73alF59DicYrPViG0NEgDVN8/Jl87zkAPu4u6VjZST2llgEUjaiNl9JM6HH1Vdw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz",
+      "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==",
       "cpu": [
         "ppc64"
       ],
@@ -1429,9 +1429,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.55.1.tgz",
-      "integrity": "sha512-uW0Y12ih2XJRERZ4jAfKamTyIHVMPQnTZcQjme2HMVDAHY4amf5u414OqNYC+x+LzRdRcnIG1YodLrrtA8xsxw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz",
+      "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==",
       "cpu": [
         "riscv64"
       ],
@@ -1442,9 +1442,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-riscv64-musl": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.55.1.tgz",
-      "integrity": "sha512-u9yZ0jUkOED1BFrqu3BwMQoixvGHGZ+JhJNkNKY/hyoEgOwlqKb62qu+7UjbPSHYjiVy8kKJHvXKv5coH4wDeg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz",
+      "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==",
       "cpu": [
         "riscv64"
       ],
@@ -1455,9 +1455,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-s390x-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.55.1.tgz",
-      "integrity": "sha512-/0PenBCmqM4ZUd0190j7J0UsQ/1nsi735iPRakO8iPciE7BQ495Y6msPzaOmvx0/pn+eJVVlZrNrSh4WSYLxNg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz",
+      "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==",
       "cpu": [
         "s390x"
       ],
@@ -1468,9 +1468,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.55.1.tgz",
-      "integrity": "sha512-a8G4wiQxQG2BAvo+gU6XrReRRqj+pLS2NGXKm8io19goR+K8lw269eTrPkSdDTALwMmJp4th2Uh0D8J9bEV1vg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==",
       "cpu": [
         "x64"
       ],
@@ -1481,9 +1481,9 @@
       ]
     },
     "node_modules/@rollup/rollup-linux-x64-musl": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.55.1.tgz",
-      "integrity": "sha512-bD+zjpFrMpP/hqkfEcnjXWHMw5BIghGisOKPj+2NaNDuVT+8Ds4mPf3XcPHuat1tz89WRL+1wbcxKY3WSbiT7w==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz",
+      "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==",
       "cpu": [
         "x64"
       ],
@@ -1494,9 +1494,9 @@
       ]
     },
     "node_modules/@rollup/rollup-openbsd-x64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.55.1.tgz",
-      "integrity": "sha512-eLXw0dOiqE4QmvikfQ6yjgkg/xDM+MdU9YJuP4ySTibXU0oAvnEWXt7UDJmD4UkYialMfOGFPJnIHSe/kdzPxg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz",
+      "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==",
       "cpu": [
         "x64"
       ],
@@ -1507,9 +1507,9 @@
       ]
     },
     "node_modules/@rollup/rollup-openharmony-arm64": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.55.1.tgz",
-      "integrity": "sha512-xzm44KgEP11te3S2HCSyYf5zIzWmx3n8HDCc7EE59+lTcswEWNpvMLfd9uJvVX8LCg9QWG67Xt75AuHn4vgsXw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz",
+      "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==",
       "cpu": [
         "arm64"
       ],
@@ -1520,9 +1520,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-arm64-msvc": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.55.1.tgz",
-      "integrity": "sha512-yR6Bl3tMC/gBok5cz/Qi0xYnVbIxGx5Fcf/ca0eB6/6JwOY+SRUcJfI0OpeTpPls7f194as62thCt/2BjxYN8g==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz",
+      "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==",
       "cpu": [
         "arm64"
       ],
@@ -1533,9 +1533,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-ia32-msvc": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.55.1.tgz",
-      "integrity": "sha512-3fZBidchE0eY0oFZBnekYCfg+5wAB0mbpCBuofh5mZuzIU/4jIVkbESmd2dOsFNS78b53CYv3OAtwqkZZmU5nA==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz",
+      "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==",
       "cpu": [
         "ia32"
       ],
@@ -1546,9 +1546,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-gnu": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.55.1.tgz",
-      "integrity": "sha512-xGGY5pXj69IxKb4yv/POoocPy/qmEGhimy/FoTpTSVju3FYXUQQMFCaZZXJVidsmGxRioZAwpThl/4zX41gRKg==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
+      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
       "cpu": [
         "x64"
       ],
@@ -1559,9 +1559,9 @@
       ]
     },
     "node_modules/@rollup/rollup-win32-x64-msvc": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.55.1.tgz",
-      "integrity": "sha512-SPEpaL6DX4rmcXtnhdrQYgzQ5W2uW3SCJch88lB2zImhJRhIIK44fkUrgIV/Q8yUNfw5oyZ5vkeQsZLhCb06lw==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
+      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
       "cpu": [
         "x64"
       ],
@@ -1905,9 +1905,9 @@
       }
     },
     "node_modules/astro": {
-      "version": "5.17.3",
-      "resolved": "https://registry.npmjs.org/astro/-/astro-5.17.3.tgz",
-      "integrity": "sha512-69dcfPe8LsHzklwj+hl+vunWUbpMB6pmg35mACjetxbJeUNNys90JaBM8ZiwsPK689SAj/4Zqb1ayaANls9/MA==",
+      "version": "5.18.0",
+      "resolved": "https://registry.npmjs.org/astro/-/astro-5.18.0.tgz",
+      "integrity": "sha512-CHiohwJIS4L0G6/IzE1Fx3dgWqXBCXus/od0eGUfxrZJD2um2pE7ehclMmgL/fXqbU7NfE1Ze2pq34h2QaA6iQ==",
       "license": "MIT",
       "dependencies": {
         "@astrojs/compiler": "^2.13.0",
@@ -2883,9 +2883,9 @@
       }
     },
     "node_modules/devalue": {
-      "version": "5.6.2",
-      "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.2.tgz",
-      "integrity": "sha512-nPRkjWzzDQlsejL1WVifk5rvcFi/y1onBRxjaFMjZeR9mFpqu2gmAZ9xUB9/IEanEP/vBtGeGganC/GO1fmufg==",
+      "version": "5.6.3",
+      "resolved": "https://registry.npmjs.org/devalue/-/devalue-5.6.3.tgz",
+      "integrity": "sha512-nc7XjUU/2Lb+SvEFVGcWLiKkzfw8+qHI7zn8WYXKkLMgfGSHbgCEaR6bJpev8Cm6Rmrb19Gfd/tZvGqx9is3wg==",
       "license": "MIT"
     },
     "node_modules/devlop": {
@@ -5690,9 +5690,9 @@
       }
     },
     "node_modules/rollup": {
-      "version": "4.55.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.55.1.tgz",
-      "integrity": "sha512-wDv/Ht1BNHB4upNbK74s9usvl7hObDnvVzknxqY/E/O3X6rW1U1rV1aENEfJ54eFZDTNo7zv1f5N4edCluH7+A==",
+      "version": "4.59.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
+      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
       "license": "MIT",
       "dependencies": {
         "@types/estree": "1.0.8"
@@ -5705,31 +5705,31 @@
         "npm": ">=8.0.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.55.1",
-        "@rollup/rollup-android-arm64": "4.55.1",
-        "@rollup/rollup-darwin-arm64": "4.55.1",
-        "@rollup/rollup-darwin-x64": "4.55.1",
-        "@rollup/rollup-freebsd-arm64": "4.55.1",
-        "@rollup/rollup-freebsd-x64": "4.55.1",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.55.1",
-        "@rollup/rollup-linux-arm-musleabihf": "4.55.1",
-        "@rollup/rollup-linux-arm64-gnu": "4.55.1",
-        "@rollup/rollup-linux-arm64-musl": "4.55.1",
-        "@rollup/rollup-linux-loong64-gnu": "4.55.1",
-        "@rollup/rollup-linux-loong64-musl": "4.55.1",
-        "@rollup/rollup-linux-ppc64-gnu": "4.55.1",
-        "@rollup/rollup-linux-ppc64-musl": "4.55.1",
-        "@rollup/rollup-linux-riscv64-gnu": "4.55.1",
-        "@rollup/rollup-linux-riscv64-musl": "4.55.1",
-        "@rollup/rollup-linux-s390x-gnu": "4.55.1",
-        "@rollup/rollup-linux-x64-gnu": "4.55.1",
-        "@rollup/rollup-linux-x64-musl": "4.55.1",
-        "@rollup/rollup-openbsd-x64": "4.55.1",
-        "@rollup/rollup-openharmony-arm64": "4.55.1",
-        "@rollup/rollup-win32-arm64-msvc": "4.55.1",
-        "@rollup/rollup-win32-ia32-msvc": "4.55.1",
-        "@rollup/rollup-win32-x64-gnu": "4.55.1",
-        "@rollup/rollup-win32-x64-msvc": "4.55.1",
+        "@rollup/rollup-android-arm-eabi": "4.59.0",
+        "@rollup/rollup-android-arm64": "4.59.0",
+        "@rollup/rollup-darwin-arm64": "4.59.0",
+        "@rollup/rollup-darwin-x64": "4.59.0",
+        "@rollup/rollup-freebsd-arm64": "4.59.0",
+        "@rollup/rollup-freebsd-x64": "4.59.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
+        "@rollup/rollup-linux-arm64-musl": "4.59.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
+        "@rollup/rollup-linux-loong64-musl": "4.59.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-gnu": "4.59.0",
+        "@rollup/rollup-linux-x64-musl": "4.59.0",
+        "@rollup/rollup-openbsd-x64": "4.59.0",
+        "@rollup/rollup-openharmony-arm64": "4.59.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
+        "@rollup/rollup-win32-x64-gnu": "4.59.0",
+        "@rollup/rollup-win32-x64-msvc": "4.59.0",
         "fsevents": "~2.3.2"
       }
     },
@@ -6138,9 +6138,9 @@
       "license": "MIT"
     },
     "node_modules/underscore": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.7.tgz",
-      "integrity": "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==",
+      "version": "1.13.8",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.8.tgz",
+      "integrity": "sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ==",
       "dev": true,
       "license": "MIT"
     },

package.json

@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@astrojs/mdx": "^4.3.13",
-    "astro": "^5.17.3"
+    "astro": "^5.18.0"
   },
   "devDependencies": {
     "@astrojs/sitemap": "^3.7.0",

public/site.webmanifest

@@ -1 +1 @@
-{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}
+{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone","orientation":"any"}

scripts/import-docx.mjs

@@ -114,7 +114,6 @@ async function runMammoth(docxPath, assetsOutDirWebRoot) {
   );
 
   let html = result.value || "";
-
   // Mammoth gives relative src="image-xx.png" ; we will prefix later
   return html;
 }
@@ -182,6 +181,25 @@ async function exists(p) {
   try { await fs.access(p); return true; } catch { return false; }
 }
 
+/**
+ * ✅ compat:
+ * - ancien : collection="archicratie" + slug="archicrat-ia/chapitre-3"
+ * - nouveau : collection="archicrat-ia" + slug="chapitre-3"
+ *
+ * But : toujours écrire dans src/content/archicrat-ia/<slugSansPrefix>.mdx
+ */
+function normalizeDest(collection, slug) {
+  let outCollection = String(collection || "").trim();
+  let outSlug = String(slug || "").trim().replace(/^\/+|\/+$/g, "");
+
+  if (outCollection === "archicratie" && outSlug.startsWith("archicrat-ia/")) {
+    outCollection = "archicrat-ia";
+    outSlug = outSlug.replace(/^archicrat-ia\//, "");
+  }
+
+  return { outCollection, outSlug };
+}
+
 async function main() {
   const args = parseArgs(process.argv);
   const manifestPath = path.resolve(args.manifest);
@@ -203,11 +221,14 @@ async function main() {
 
   for (const it of selected) {
     const docxPath = path.resolve(it.source);
-    const outFile = path.resolve("src/content", it.collection, `${it.slug}.mdx`);
+
+    const { outCollection, outSlug } = normalizeDest(it.collection, it.slug);
+
+    const outFile = path.resolve("src/content", outCollection, `${outSlug}.mdx`);
     const outDir = path.dirname(outFile);
 
-    const assetsPublicDir = path.posix.join("/imported", it.collection, it.slug);
-    const assetsDiskDir = path.resolve("public", "imported", it.collection, it.slug);
+    const assetsPublicDir = path.posix.join("/imported", outCollection, outSlug);
+    const assetsDiskDir = path.resolve("public", "imported", outCollection, outSlug);
 
     if (!(await exists(docxPath))) {
       throw new Error(`Missing source docx: ${docxPath}`);
@@ -241,18 +262,20 @@ async function main() {
       html = rewriteLocalImageLinks(html, assetsPublicDir);
       body = html.trim() ? html : "<p>(Import vide)</p>";
     }
-  
+
     const defaultVersion = process.env.PUBLIC_RELEASE || "0.1.0";
 
+    // ✅ IMPORTANT: archicrat-ia partage edition/status avec archicratie (pas de migration frontmatter)
     const schemaDefaultsByCollection = {
-      archicratie: { edition: "archicratie", status: "modele_sociopolitique", level: 1 },
-      ia:         { edition: "ia",         status: "cas_pratique",           level: 1 },
-      traite:     { edition: "traite",     status: "ontodynamique",          level: 1 },
-      glossaire:  { edition: "glossaire",  status: "lexique",                level: 1 },
-      atlas:      { edition: "atlas",      status: "atlas",                  level: 1 },
+      archicratie:    { edition: "archicratie",  status: "modele_sociopolitique", level: 1 },
+      "archicrat-ia": { edition: "archicrat-ia", status: "essai_these",           level: 1 },
+      "cas-ia":       { edition: "cas-ia",       status: "application",           level: 1 },
+      traite:         { edition: "traite",       status: "ontodynamique",         level: 1 },
+      glossaire:      { edition: "glossaire",    status: "lexique",               level: 1 },
+      atlas:          { edition: "atlas",        status: "atlas",                 level: 1 },
     };
 
-    const defaults = schemaDefaultsByCollection[it.collection] || { edition: it.collection, status: "draft", level: 1 };
+    const defaults = schemaDefaultsByCollection[outCollection] || { edition: outCollection, status: "draft", level: 1 };
 
     const fm = [
       "---",
@@ -282,4 +305,4 @@ async function main() {
 main().catch((e) => {
   console.error("\nERROR:", e?.message || e);
   process.exit(1);
-});
+});

sources/manifest.yml

@@ -1,6 +1,15 @@
 version: 1
 
 docs:
+  # =========================
+  # Document d’entrée
+  # =========================
+  - source: sources/docx/commencer/document-de-presentation.docx
+    collection: commencer
+    slug: document-de-presentation
+    title: "Document de présentation"
+    order: 0
+
   # =========================
   # Archicratie — Essai-thèse "ArchiCraT-IA"
   # =========================
@@ -47,115 +56,68 @@ docs:
     order: 70
 
   # =========================
-  # IA — Cas pratique (1 page = 1 chapitre)
-  # NOTE: on n'inclut PAS le monolithe "Cas_IA-... .docx" dans le manifeste.
+  # Cas pratique — Gouvernance des systèmes IA
   # =========================
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Introduction_generale—Mettre_en_scene_un_systeme_IA.docx
-    collection: ia
-    slug: cas-pratique/introduction
-    title: "Cas pratique — Introduction générale : Mettre en scène un système IA"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Introduction.docx
+    collection: cas-ia
+    slug: introduction
+    title: "Introduction générale — Mettre un système d’IA en scène"
     order: 110
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_I—Epreuve_de_detectabilite.docx
-    collection: ia
-    slug: cas-pratique/chapitre-1
-    title: "Cas pratique — Chapitre I : Épreuve de détectabilité"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_1_Epreuve_de_detectabilite.docx
+    collection: cas-ia
+    slug: chapitre-1
+    title: "Chapitre I — Épreuve de détectabilité"
     order: 120
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_II—Epreuve_topologique.docx
-    collection: ia
-    slug: cas-pratique/chapitre-2
-    title: "Cas pratique — Chapitre II : Épreuve topologique"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_2_Epreuve_Topologique.docx
+    collection: cas-ia
+    slug: chapitre-2
+    title: "Chapitre II — Épreuve topologique"
     order: 130
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_III—Epreuve_archeogenetique.docx
-    collection: ia
-    slug: cas-pratique/chapitre-3
-    title: "Cas pratique — Chapitre III : Épreuve archéogénétique"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_3_Epreuve_archeogenetique.docx
+    collection: cas-ia
+    slug: chapitre-3
+    title: "Chapitre III — Épreuve archéogénétique"
     order: 140
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_IV—Epreuve_morphologique.docx
-    collection: ia
-    slug: cas-pratique/chapitre-4
-    title: "Cas pratique — Chapitre IV : Épreuve morphologique"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_4_Epreuve_Morphologique.docx
+    collection: cas-ia
+    slug: chapitre-4
+    title: "Chapitre IV — Épreuve morphologique"
     order: 150
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_V—Epreuve_historique.docx
-    collection: ia
-    slug: cas-pratique/chapitre-5
-    title: "Cas pratique — Chapitre V : Épreuve historique"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_5_Epreuve_Historique.docx
+    collection: cas-ia
+    slug: chapitre-5
+    title: "Chapitre V — Épreuve historique"
     order: 160
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_VI—Epreuve_de_co-viabilite.docx
-    collection: ia
-    slug: cas-pratique/chapitre-6
-    title: "Cas pratique — Chapitre VI : Épreuve de co-viabilité"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_6_Epreuve_de_Co-viabilite.docx
+    collection: cas-ia
+    slug: chapitre-6
+    title: "Chapitre VI — Épreuve de co-viabilité"
     order: 170
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_VII—Gestes_archicratiques_concrets_pour_un_systeme_IA.docx
-    collection: ia
-    slug: cas-pratique/chapitre-7
-    title: "Cas pratique — Chapitre VII : Gestes archicratiques concrets"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_7_Gestes_archicratiques_concrets_pour_un_systeme_IA.docx
+    collection: cas-ia
+    slug: chapitre-7
+    title: "Chapitre VII — Gestes archicratiques concrets pour un système d’IA"
     order: 180
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Conclusion.docx
-    collection: ia
-    slug: cas-pratique/conclusion
-    title: "Cas pratique — Conclusion"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Conclusion.docx
+    collection: cas-ia
+    slug: conclusion
+    title: "Conclusion"
     order: 190
 
-  - source: sources/docx/cas-ia/Cas_IA-Archicratie_et_gouvernance_des_systemes_IA-Annexe—Glossaire_archicratique_pour_audit_des_systemes_IA.docx
-    collection: ia
-    slug: cas-pratique/annexe-glossaire-audit
-    title: "Cas pratique — Annexe : Glossaire archicratique pour audit des systèmes IA"
+  - source: sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Annexe_Glossaire_Archicratique_Cas_IA.docx
+    collection: cas-ia
+    slug: annexe-glossaire-audit
+    title: "Annexe — Glossaire archicratique pour l’audit des systèmes d’IA"
     order: 195
 
-  # =========================
-  # Traité — Ontodynamique générative (1 page = 1 chapitre)
-  # NOTE: on n'inclut PAS le monolithe "Traite-...-version_officielle.docx" dans le manifeste.
-  # =========================
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Introduction-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/introduction
-    title: "Traité — Introduction"
-    order: 210
-
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Chapitre_1—Le_flux_ontogenetique-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/chapitre-1
-    title: "Traité — Chapitre 1 : Le flux ontogénétique"
-    order: 220
-
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Chapitre_2—economie_du_reel-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/chapitre-2
-    title: "Traité — Chapitre 2 : Économie du réel"
-    order: 230
-
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Chapitre_3—Le_reel_comme_systeme_regulateur-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/chapitre-3
-    title: "Traité — Chapitre 3 : Le réel comme système régulateur"
-    order: 240
-
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Chapitre_4—Arcalite-structures_formes_invariants-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/chapitre-4
-    title: "Traité — Chapitre 4 : Arcalité — structures, formes, invariants"
-    order: 250
-
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Chapitre_5-Cratialite-forces_flux_gradients-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/chapitre-5
-    title: "Traité — Chapitre 5 : Cratialité — forces, flux, gradients"
-    order: 260
-
-  - source: sources/docx/traite/Traite-Ontodynamique_Generative-Fondements_Archicratie-Chapitre_6—Archicration-version_officielle.docx
-    collection: traite
-    slug: ontodynamique/chapitre-6
-    title: "Traité — Chapitre 6 : Archicration"
-    order: 270
-
   # =========================
   # Glossaire / Lexique
   # =========================
@@ -169,4 +131,4 @@ docs:
     collection: glossaire
     slug: mini-glossaire-verbes
     title: "Mini-glossaire des verbes de la scène archicratique"
-    order: 910
+    order: 910

src/anchors/anchor-aliases.json

@@ -1,2 +1,5 @@
-{}
-  
+{
+  "/archicrat-ia/chapitre-3/": {
+    "p-1-60c7ea48": "p-1-a21087b0"
+  }
+}

src/annotations/archicrat-ia/chapitre-1/p-0-8d27a7f5.yml

@@ -1,10 +0,0 @@
-schema: 1
-page: archicrat-ia/chapitre-1
-paras:
-  p-0-8d27a7f5:
-    refs:
-      - url: https://auth.archicratie.trans-hands.synology.me/authenticated
-        label: Lien web
-        kind: (livre / article / vidéo / site / autre) Site
-        ts: 2026-02-27T12:34:31.704Z
-        fromIssue: 142

src/annotations/archicrat-ia/chapitre-1/p-1-8a6c18bf.yml

@@ -1,9 +0,0 @@
-schema: 1
-page: archicrat-ia/chapitre-1
-paras:
-  p-1-8a6c18bf:
-    comments_editorial:
-      - text: Yeaha
-        status: new
-        ts: 2026-02-27T12:40:39.462Z
-        fromIssue: 143

src/annotations/archicrat-ia/chapitre-3/p-0-ace27175.yml

@@ -1,12 +0,0 @@
-schema: 1
-page: archicrat-ia/chapitre-3
-paras:
-  p-0-ace27175:
-    media:
-      - type: image
-        src: /media/archicrat-ia/chapitre-3/p-0-ace27175/Capture_d_e_cran_2025-05-05_a_19.20.40.png
-        caption: "[Media] p-0-ace27175 — Chapitre 3 — Philosophies du pouvoir et
-          archicration"
-        credit: ""
-        ts: 2026-02-27T12:43:14.259Z
-        fromIssue: 144

src/annotations/archicrat-ia/chapitre-4.yml

@@ -1,30 +0,0 @@
-schema: 1
-page: archicrat-ia/chapitre-4
-paras:
-  p-2-31b12529:
-    media:
-      - type: image
-        src: /media/archicrat-ia/chapitre-4/p-2-31b12529/Capture_d_e_cran_2026-02-16_a_13.05.58.png
-        caption: "[Media] p-2-31b12529 — Chapitre 4 — Histoire archicratique des
-          révolutions industrielles"
-        credit: ""
-        ts: 2026-02-25T18:58:32.359Z
-        fromIssue: 115
-  p-7-1da4a458:
-    media:
-      - type: image
-        src: /media/archicrat-ia/chapitre-4/p-7-1da4a458/Capture_d_e_cran_2026-02-16_a_13.05.58.png
-        caption: "[Media] p-7-1da4a458 — Chapitre 4 — Histoire archicratique des
-          révolutions industrielles"
-        credit: ""
-        ts: 2026-02-25T19:11:32.634Z
-        fromIssue: 121
-  p-11-67c14c09:
-    media:
-      - type: image
-        src: /media/archicrat-ia/chapitre-4/p-11-67c14c09/Capture_d_e_cran_2026-02-16_a_13.07.35.png
-        caption: "[Media] p-11-67c14c09 — Chapitre 4 — Histoire archicratique des
-          révolutions industrielles"
-        credit: ""
-        ts: 2026-02-26T13:17:41.286Z
-        fromIssue: 129

src/annotations/archicrat-ia/chapitre-4/p-11-67c14c09.yml

@@ -1,19 +0,0 @@
-schema: 1
-page: archicrat-ia/chapitre-4
-paras:
-  p-11-67c14c09:
-    media:
-      - type: image
-        src: /media/archicrat-ia/chapitre-4/p-11-67c14c09/Capture_d_e_cran_2026-02-16_a_13.07.35.png
-        caption: "[Media] p-11-67c14c09 — Chapitre 4 — Histoire archicratique des
-          révolutions industrielles"
-        credit: ""
-        ts: 2026-02-26T13:17:41.286Z
-        fromIssue: 129
-      - type: image
-        src: /media/archicrat-ia/chapitre-4/p-11-67c14c09/Capture_d_e_cran_2025-05-05_a_19.20.40.png
-        caption: "[Media] p-11-67c14c09 — Chapitre 4 — Histoire archicratique des
-          révolutions industrielles"
-        credit: ""
-        ts: 2026-02-27T09:17:04.386Z
-        fromIssue: 127

src/annotations/archicrat-ia/prologue.yml

@@ -1,50 +0,0 @@
-schema: 1
-
-paras:
-  p-0-d7974f88:
-    refs:
-      - label: "Happycratie — (Cabanas & Illouz) via Cairn"
-        url: "https://shs.cairn.info/revue-ethnologie-francaise-2019-4-page-813?lang=fr"
-        kind: "article"
-      - label: "Techno-féodalisme — Variations (OpenEdition)"
-        url: "https://journals.openedition.org/variations/2290"
-        kind: "article"
-
-    authors:
-      - "Eva Illouz"
-      - "Yanis Varoufakis"
-
-    quotes:
-      - text: "Dans Happycratie, Edgar Cabanas et Eva Illouz..."
-        source: "Happycratie, p.1"
-      - text: "En eux-mêmes, les actifs ne sont ni féodaux ni capitalistes..."
-        source: "Entretien Morozov/Varoufakis — techno-féodalisme"
-
-    media:
-      - type: "image"
-        src: "/public/media/archicratie/archicrat-ia/prologue/p-0-d7974f88/schema-1.svg"
-        caption: "Tableau explicatif"
-        credit: "ChatGPT"
-      - type: "image"
-        src: "/public/media/archicratie/archicrat-ia/prologue/p-0-d7974f88/schema-2.svg"
-        caption: "Diagramme d’évolution"
-        credit: "Yanis Varoufakis"
-
-    comments_editorial:
-      - text: "TODO: nuancer / préciser — commentaire éditorial versionné (pas public)."
-        status: "draft"
-
-  p-1-2ef25f29:
-    refs:
-      - label: "Kafka et le pouvoir — Bernard Lahire (Cairn)"
-        url: "https://shs.cairn.info/franz-kafka--9782707159410-page-475?lang=fr"
-        kind: "book"
-
-    authors:
-      - "Bernard Lahire"
-
-    quotes:
-      - text: "Si l’on voulait chercher quelque chose comme une vision du monde chez Kafka..."
-        source: "Bernard Lahire, Franz Kafka, p.475+"
-
-    comments_editorial: []

src/components/EditionToc.astro

@@ -1,21 +1,22 @@
 ---
 import { getCollection } from "astro:content";
 
-const { currentSlug } = Astro.props;
+const {
+  currentSlug,
+  collection = "archicrat-ia",
+  basePath = "/archicrat-ia",
+  label = "Table des matières"
+} = Astro.props;
 
-const entries = (await getCollection("archicratie"))
-  .filter((e) => e.slug.startsWith("archicrat-ia/"))
+const entries = (await getCollection(collection))
   .sort((a, b) => (a.data.order ?? 0) - (b.data.order ?? 0));
 
-// ✅ On route l’Essai-thèse sur /archicrat-ia/<slug-sans-prefix>/
-// (Astro trailingSlash = always → on garde le "/" final)
-const strip = (s) => String(s || "").replace(/^archicrat-ia\//, "");
-const href = (slug) => `/archicrat-ia/${strip(slug)}/`;
+const href = (slug) => `${basePath}/${slug}/`;
 ---
 
-<nav class="toc-global" aria-label="Table des matières — ArchiCraT-IA">
+<nav class="toc-global" aria-label={label}>
   <div class="toc-global__head">
-    <div class="toc-global__title">Table des matières</div>
+    <div class="toc-global__title">{label}</div>
   </div>
 
   <ol class="toc-global__list">
@@ -163,4 +164,4 @@ const href = (slug) => `/archicrat-ia/${strip(slug)}/`;
   const active = document.querySelector(".toc-global .toc-item.is-active");
   if (active) active.scrollIntoView({ block: "nearest" });
 })();
-</script>
+</script>

src/components/SidePanel.astro

@@ -25,12 +25,12 @@
 
     {/* ✅ actions références en haut (niveau 2 uniquement) */}
     <div class="panel-top-actions level-2" aria-label="Actions références">
-    <div class="panel-actions">
+      <div class="panel-actions">
         <button class="panel-btn panel-btn--primary" id="panel-ref-submit" type="button">
-        Soumettre une référence (Gitea)
+          Soumettre une référence (Gitea)
         </button>
-    </div>
-    <div class="panel-msg" id="panel-ref-msg" hidden></div>
+      </div>
+      <div class="panel-msg" id="panel-ref-msg" hidden></div>
     </div>
 
     <section class="panel-block level-2" aria-label="Références et auteurs">
@@ -60,7 +60,7 @@
     </section>
   </div>
 
-  {/* ✅ Lightbox media (pop-up au-dessus du panel) */}
+  {/* ✅ Lightbox media (plein écran) */}
   <div class="panel-lightbox" id="panel-lightbox" hidden aria-hidden="true">
     <div class="panel-lightbox__overlay" data-close="1"></div>
     <div class="panel-lightbox__dialog" role="dialog" aria-modal="true" aria-label="Aperçu du média">
@@ -93,6 +93,9 @@
   const btnMediaSubmit = root.querySelector("#panel-media-submit");
   const msgMedia = root.querySelector("#panel-media-msg");
 
+  const btnRefSubmit = root.querySelector("#panel-ref-submit");
+  const msgRef = root.querySelector("#panel-ref-msg");
+
   const taComment = root.querySelector("#panel-comment-text");
   const btnSend = root.querySelector("#panel-comment-send");
   const msgComment = root.querySelector("#panel-comment-msg");
@@ -101,9 +104,6 @@
   const lbContent = root.querySelector("#panel-lightbox-content");
   const lbCaption = root.querySelector("#panel-lightbox-caption");
 
-  const btnRefSubmit = root.querySelector("#panel-ref-submit");
-  const msgRef = root.querySelector("#panel-ref-msg");
-
   const docTitle = document.body?.dataset?.docTitle || document.title || "Archicratie";
   const docVersion = document.body?.dataset?.docVersion || "";
 
@@ -114,6 +114,16 @@
   let currentParaId = "";
   let mediaShowAll = (localStorage.getItem("archicratie:panel:mediaAll") === "1");
 
+  // ===== cosmetics: micro flash “update” =====
+  let _flashT = 0;
+  function flashUpdate(){
+    try {
+      root.classList.add("is-updating");
+      if (_flashT) clearTimeout(_flashT);
+      _flashT = setTimeout(() => root.classList.remove("is-updating"), 180);
+    } catch {}
+  }
+
   // ===== globals =====
   function getG() {
     return window.__archiGitea || { ready: false, base: "", owner: "", repo: "" };
@@ -121,9 +131,6 @@
   function getAuthInfoP() {
     return window.__archiAuthInfoP || Promise.resolve({ ok: false, groups: [] });
   }
-  function isDev() {
-    return Boolean((window.__archiFlags && window.__archiFlags.dev) || /^(localhost|127\.0\.0\.1|\[::1\])$/i.test(location.hostname));
-  }
 
   const access = { ready: false, canUsers: false };
 
@@ -137,8 +144,7 @@
     return Array.isArray(groups) && groups.some((x) => String(x).toLowerCase() === gg);
   }
 
-  // ✅ règle mission : readers + editors peuvent soumettre médias + commentaires
-  // ✅ dev fallback : si /_auth/whoami n’existe pas, on autorise pour tester
+  // ✅ readers + editors peuvent soumettre médias + commentaires + refs
   getAuthInfoP().then((info) => {
     const groups = Array.isArray(info?.groups) ? info.groups : [];
     const canReaders = inGroup(groups, "readers");
@@ -152,7 +158,6 @@
     if (btnSend) btnSend.disabled = !access.canUsers;
     if (btnRefSubmit) btnRefSubmit.disabled = !access.canUsers;
 
-    // si pas d'accès, on informe (soft)
     if (!access.canUsers) {
       if (msgHead) {
         msgHead.hidden = false;
@@ -161,7 +166,6 @@
       }
     }
   }).catch(() => {
-    // fallback dev (cohérent: media + ref + comment)
     access.ready = true;
     if (Boolean(window.__archiFlags && window.__archiFlags.whoamiSkipped)) {
       access.canUsers = true;
@@ -213,7 +217,6 @@
         const res = await fetch("/annotations-index.json?_=" + Date.now(), { cache: "no-store" });
         if (res && res.ok) return await res.json();
       } catch {}
-      // ✅ antifragile: ne pas “cacher” un échec pour toujours (dev/HMR/boot race)
       _idxP = null;
       return null;
     })();
@@ -255,24 +258,22 @@
     return issue.toString();
   }
 
-  // Ouvre un nouvel onglet UNE SEULE FOIS (évite le double-open Safari/Firefox + noopener).
-    function openNewTab(url) {
-        try {
-            const a = document.createElement("a");
-            a.href = url;
-            a.target = "_blank";
-            a.rel = "noopener noreferrer";
-            a.style.display = "none";
-            document.body.appendChild(a);
-            a.click();
-            a.remove();
-            return true; // on ne peut pas détecter proprement un blocage sans retomber dans le double-open
-        } catch {
-            return false;
-        }
+  function openNewTab(url) {
+    try {
+      const a = document.createElement("a");
+      a.href = url;
+      a.target = "_blank";
+      a.rel = "noopener noreferrer";
+      a.style.display = "none";
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      return true;
+    } catch {
+      return false;
     }
+  }
 
-  // ====== GARDES ANTI-DOUBLONS ======
   const _openStamp = new Map();
   function openOnce(key, fn) {
     const now = Date.now();
@@ -301,13 +302,21 @@
   }
 
   // ===== Lightbox =====
+  function lockScroll(on) {
+    try {
+      document.documentElement.classList.toggle("archi-lb-open", !!on);
+    } catch {}
+  }
+
   function closeLightbox() {
     if (!lb) return;
     lb.hidden = true;
     lb.setAttribute("aria-hidden", "true");
     if (lbContent) clear(lbContent);
     if (lbCaption) { lbCaption.hidden = true; lbCaption.textContent = ""; }
+    lockScroll(false);
   }
+
   function openLightbox({ type, src, caption }) {
     if (!lb || !lbContent) return;
     clear(lbContent);
@@ -346,6 +355,7 @@
       else { lbCaption.hidden = true; lbCaption.textContent = ""; }
     }
 
+    lockScroll(true);
     lb.hidden = false;
     lb.setAttribute("aria-hidden", "false");
   }
@@ -363,7 +373,6 @@
     });
   }
 
-  // ===== Renders =====
   function renderLevel2(data) {
     clear(elL2);
     if (!elL2) return;
@@ -563,13 +572,16 @@
   async function updatePanel(paraId) {
     currentParaId = paraId || currentParaId || "";
     if (elId) elId.textContent = currentParaId || "—";
+
+    flashUpdate();
+
     hideMsg(msgHead);
     hideMsg(msgMedia);
     hideMsg(msgComment);
+    hideMsg(msgRef);
 
     const idx = await loadIndex();
 
-    // ✅ message soft si l’index est indisponible (sans écraser le message d’auth)
     if (!idx && msgHead && msgHead.hidden) {
       msgHead.hidden = false;
       msgHead.textContent = "Index annotations indisponible (annotations-index.json).";
@@ -583,7 +595,6 @@
     renderLevel4(data);
   }
 
-  // ===== media "voir tous" =====
   if (btnMediaAll) {
     bindClickOnce(btnMediaAll, (ev) => {
       ev.preventDefault();
@@ -595,7 +606,6 @@
     btnMediaAll.textContent = mediaShowAll ? "Réduire la liste" : "Voir tous les éléments";
   }
 
-  // ===== media submit (readers + editors) =====
   if (btnMediaSubmit) {
     bindClickOnce(btnMediaSubmit, (ev) => {
       ev.preventDefault();
@@ -638,27 +648,26 @@
     });
   }
 
-  // ===== référence submit (readers + editors) =====
-    if (btnRefSubmit) {
+  if (btnRefSubmit) {
     bindClickOnce(btnRefSubmit, (ev) => {
-        ev.preventDefault();
-        hideMsg(msgRef);
+      ev.preventDefault();
+      hideMsg(msgRef);
 
-        if (guardEventOnce(ev, "gitea_open_ref")) return;
+      if (guardEventOnce(ev, "gitea_open_ref")) return;
 
-        if (!currentParaId) return showMsg(msgRef, "Choisis d’abord un paragraphe (scroll / survol).", "warn");
-        if (!getG().ready) return showMsg(msgRef, "Gitea non configuré (PUBLIC_GITEA_*).", "error");
-        if (btnRefSubmit.disabled) return showMsg(msgRef, "Connexion requise (readers/editors).", "error");
+      if (!currentParaId) return showMsg(msgRef, "Choisis d’abord un paragraphe (scroll / survol).", "warn");
+      if (!getG().ready) return showMsg(msgRef, "Gitea non configuré (PUBLIC_GITEA_*).", "error");
+      if (btnRefSubmit.disabled) return showMsg(msgRef, "Connexion requise (readers/editors).", "error");
 
-        const pageUrl = new URL(location.href);
-        pageUrl.search = "";
-        pageUrl.hash = currentParaId;
+      const pageUrl = new URL(location.href);
+      pageUrl.search = "";
+      pageUrl.hash = currentParaId;
 
-        const paraTxt = getParaText(currentParaId);
-        const excerpt = paraTxt.length > FULL_TEXT_SOFT_LIMIT ? (paraTxt.slice(0, FULL_TEXT_SOFT_LIMIT) + "…") : paraTxt;
+      const paraTxt = getParaText(currentParaId);
+      const excerpt = paraTxt.length > FULL_TEXT_SOFT_LIMIT ? (paraTxt.slice(0, FULL_TEXT_SOFT_LIMIT) + "…") : paraTxt;
 
-        const title = `[Reference] ${currentParaId} — ${docTitle}`;
-        const body = [
+      const title = `[Reference] ${currentParaId} — ${docTitle}`;
+      const body = [
         `Chemin: ${location.pathname}`,
         `URL: ${pageUrl.toString()}`,
         `Ancre: #${currentParaId}`,
@@ -676,18 +685,16 @@
         ``,
         `---`,
         `Note: issue générée depuis le site (pré-remplissage).`,
-        ].join("\n");
+      ].join("\n");
 
-        const url = buildIssueURL({ title, body });
-        if (!url) return showMsg(msgRef, "Impossible de générer l’issue.", "error");
+      const url = buildIssueURL({ title, body });
+      if (!url) return showMsg(msgRef, "Impossible de générer l’issue.", "error");
 
-        const ok = openOnce(`ref:${currentParaId}`, () => openNewTab(url));
-        if (!ok) showMsg(msgRef, "Si rien ne s’ouvre : autorise les popups pour ce site.", "error");
+      const ok = openOnce(`ref:${currentParaId}`, () => openNewTab(url));
+      if (!ok) showMsg(msgRef, "Si rien ne s’ouvre : autorise les popups pour ce site.", "error");
     });
-    }
+  }
 
-
-  // ===== commentaire (readers + editors) =====
   if (btnSend) {
     bindClickOnce(btnSend, (ev) => {
       ev.preventDefault();
@@ -739,60 +746,31 @@
     });
   }
 
-  // ===== wiring: para courant (aligné sur le paragraphe sous le reading-follow) =====
-  function isPara(el) {
-    return Boolean(el && el.nodeType === 1 && el.matches && el.matches('.reading p[id^="p-"]'));
+  // ===== wiring: para courant (SOURCE OF TRUTH = EditionLayout) =====
+  function onCurrentPara(ev) {
+    try {
+      const id = ev?.detail?.id ? String(ev.detail.id) : "";
+      if (!id || !/^p-\d+-/i.test(id)) return;
+      if (id === currentParaId) return;
+      updatePanel(id);
+    } catch {}
   }
+  window.addEventListener("archicratie:currentPara", onCurrentPara);
 
-  function pickParaAtY(y) {
-    const x = Math.max(0, Math.round(window.innerWidth * 0.5));
-    const candidates = [
-      document.elementFromPoint(x, y),
-      document.elementFromPoint(Math.min(window.innerWidth - 1, x + 60), y),
-      document.elementFromPoint(Math.max(0, x - 60), y),
-    ].filter(Boolean);
+  const initial = String(location.hash || "").replace(/^#/, "").trim();
 
-    for (const c of candidates) {
-      if (isPara(c)) return c;
-      const p = c.closest ? c.closest('.reading p[id^="p-"]') : null;
-      if (isPara(p)) return p;
-    }
-    return null;
+  if (/^p-\d+-/i.test(initial)) {
+    updatePanel(initial);
+  } else if (window.__archiCurrentParaId && /^p-\d+-/i.test(String(window.__archiCurrentParaId))) {
+    updatePanel(String(window.__archiCurrentParaId));
+  } else {
+    setTimeout(() => {
+      try {
+        const id = String(window.__archiCurrentParaId || "").trim();
+        if (/^p-\d+-/i.test(id)) updatePanel(id);
+      } catch {}
+    }, 0);
   }
-
-  let _lastPicked = "";
-  function syncFromFollowLine() {
-    const off = Number(document.documentElement.style.getPropertyValue("--sticky-offset-px")) || 0;
-    const y = Math.round(off + 8);
-    const p = pickParaAtY(y);
-    if (!p || !p.id) return;
-    if (p.id === _lastPicked) return;
-    _lastPicked = p.id;
-
-    // met à jour l'app global (EditionLayout écoute déjà currentPara)
-    try { window.dispatchEvent(new CustomEvent("archicratie:currentPara", { detail: { id: p.id } })); } catch {}
-
-    // et met à jour le panel immédiatement (sans attendre)
-    updatePanel(p.id);
-  }
-
-  let ticking = false;
-  function onScroll() {
-    if (ticking) return;
-    ticking = true;
-    requestAnimationFrame(() => {
-      ticking = false;
-      syncFromFollowLine();
-    });
-  }
-
-  window.addEventListener("scroll", onScroll, { passive: true });
-  window.addEventListener("resize", onScroll);
-
-  // Initial: hash > sinon calc
-  const initial = String(location.hash || "").replace(/^#/, "");
-  if (/^p-\d+-/i.test(initial)) updatePanel(initial);
-  else setTimeout(() => { try { syncFromFollowLine(); } catch {} }, 0);
 })();
 </script>
 
@@ -805,6 +783,8 @@
     position: sticky;
     top: calc(var(--sticky-header-h) + var(--page-gap));
     align-self: start;
+
+    --thumb: 92px; /* ✅ taille des vignettes (80–110 selon goût) */
   }
 
   :global(body[data-reading-level="3"]) .page-panel{
@@ -922,28 +902,33 @@
   /* actions médias en haut */
   .panel-top-actions{ margin-top: 8px; }
 
-  /* ===== media thumbnails (150x150) ===== */
+  /* ===== media thumbnails (plus petits + plus denses) ===== */
   .panel-media-grid{
     display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
+    grid-template-columns: repeat(auto-fill, minmax(var(--thumb), 1fr));
     gap: 10px;
   }
 
   .panel-media-tile{
-    width: 150px;
-    max-width: 100%;
+    width: 100%;
     border: 1px solid rgba(127,127,127,.20);
     border-radius: 14px;
     padding: 8px;
     background: rgba(127,127,127,0.04);
     cursor: pointer;
     text-align: left;
+    transition: transform 120ms ease, background 120ms ease, border-color 120ms ease;
+  }
+
+  .panel-media-tile:hover{
+    transform: translateY(-1px);
+    background: rgba(127,127,127,0.07);
+    border-color: rgba(127,127,127,.32);
   }
 
   .panel-media-tile img{
-    width: 150px;
-    height: 150px;
-    max-width: 100%;
+    width: 100%;
+    height: var(--thumb);
     object-fit: cover;
     display: block;
     border-radius: 10px;
@@ -951,8 +936,8 @@
   }
 
   .panel-media-ph{
-    width: 150px;
-    height: 150px;
+    width: 100%;
+    height: var(--thumb);
     border-radius: 10px;
     display: grid;
     place-items: center;
@@ -995,7 +980,11 @@
     resize: vertical;
   }
 
-  /* ===== Lightbox ===== */
+  /* ===== Lightbox (plein écran “cinéma”) ===== */
+  :global(html.archi-lb-open){
+    overflow: hidden; /* ✅ empêche le scroll derrière */
+  }
+
   .panel-lightbox{
     position: fixed;
     inset: 0;
@@ -1005,58 +994,66 @@
   .panel-lightbox__overlay{
     position: absolute;
     inset: 0;
-    background: rgba(0,0,0,0.80);
-    backdrop-filter: blur(6px);
-    -webkit-backdrop-filter: blur(6px);
+    background: rgba(0,0,0,0.84);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
   }
 
   .panel-lightbox__dialog{
     position: absolute;
-    right: 24px;
-    top: calc(var(--sticky-header-h) + 16px);
-    width: min(520px, calc(100vw - 48px));
-    max-height: calc(100vh - (var(--sticky-header-h) + 32px));
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+
+    width: min(1100px, 92vw);
+    max-height: 92vh;
     overflow: auto;
 
-    border: 1px solid rgba(127,127,127,0.22);
-    border-radius: 16px;
-    background: rgba(255,255,255,0.10);
-    backdrop-filter: blur(10px);
-    -webkit-backdrop-filter: blur(10px);
-    padding: 12px;
-  }
+    border: 1px solid rgba(255,255,255,0.14);
+    border-radius: 18px;
 
-  @media (prefers-color-scheme: dark){
-    .panel-lightbox__dialog{
-      background: rgba(0,0,0,0.28);
-    }
+    background: rgba(20,20,20,0.55);
+    backdrop-filter: blur(14px);
+    -webkit-backdrop-filter: blur(14px);
+
+    padding: 16px;
+    box-shadow: 0 24px 70px rgba(0,0,0,0.55);
   }
 
   .panel-lightbox__close{
-    position: sticky;
-    top: 0;
-    margin-left: auto;
+    position: absolute;
+    top: 12px;
+    right: 12px;
+
     display: inline-flex;
     align-items: center;
     justify-content: center;
-    width: 34px;
-    height: 30px;
-    border-radius: 10px;
-    border: 1px solid rgba(127,127,127,0.35);
-    background: rgba(127,127,127,0.10);
+
+    width: 44px;
+    height: 40px;
+
+    border-radius: 14px;
+    border: 1px solid rgba(255,255,255,0.22);
+    background: rgba(255,255,255,0.10);
+
     cursor: pointer;
-    font-size: 18px;
+    font-size: 22px;
     font-weight: 900;
   }
 
+  .panel-lightbox__content{
+    margin-top: 36px;
+  }
+
   .panel-lightbox__content img,
   .panel-lightbox__content video{
     display: block;
     width: 100%;
-    height: auto;
-    max-width: 1400px;
-    margin: 0 auto;
-    border-radius: 12px;
+    max-height: calc(92vh - 160px);
+    object-fit: contain;
+
+    background: rgba(0,0,0,0.22);
+    border-radius: 14px;
   }
 
   .panel-lightbox__content audio{
@@ -1064,13 +1061,14 @@
   }
 
   .panel-lightbox__caption{
-    margin-top: 10px;
+    margin-top: 12px;
     font-size: 12px;
     font-weight: 800;
     opacity: .92;
+    color: rgba(255,255,255,0.92);
   }
 
   @media (max-width: 1100px){
     .page-panel{ display: none; }
   }
-</style>
+</style>

src/components/SiteNav.astro

@@ -1,11 +1,17 @@
 <nav class="site-nav" aria-label="Navigation principale">
-  <a href="/">Accueil</a><span aria-hidden="true"> · </span>
-  <a href="/editions/">Carte des œuvres</a><span aria-hidden="true"> · </span>
-  <a href="/methode/">Méthode</a><span aria-hidden="true"> · </span>
-  <a href="/recherche/">Recherche</a><span aria-hidden="true"> · </span>
-  <a href="/archicrat-ia/">Essai-thèse</a><span aria-hidden="true"> · </span>
-  <a href="/traite/">Traité</a><span aria-hidden="true"> · </span>
-  <a href="/ia/">Cas IA</a><span aria-hidden="true"> · </span>
-  <a href="/glossaire/">Glossaire</a><span aria-hidden="true"> · </span>
-  <a href="/atlas/">Atlas</a>
-</nav>
+
+<a href="/">Accueil</a>
+<span aria-hidden="true"> · </span>
+
+<a href="/archicrat-ia/">Essai-thèse</a>
+<span aria-hidden="true"> · </span>
+
+<a href="/cas-ia/">Cas IA</a>
+<span aria-hidden="true"> · </span>
+
+<a href="/glossaire/">Glossaire</a>
+<span aria-hidden="true"> · </span>
+
+<a href="/recherche/">Recherche</a>
+
+</nav>

src/content/archicrat-ia/chapitre-3.mdx

@@ -14,7 +14,7 @@ source:
 ---
 Ce chapitre se tient à un point nodal de notre essai-thèse : il ouvre un espace d’exploration systématique des formes conceptuelles et philosophiques à travers lesquelles le pouvoir se configure comme régime de régulation. Il ne s’agit pas ici de revenir une nouvelle fois sur les fondements de l’autorité, ni d’interroger la légitimité politique au sens classique du terme, ni même d’enquêter sur la genèse des institutions. L’ambition est autre, structurelle, transversale, morphologique, elle tentera d’arpenter, à même les dispositifs, les pensées, les théorisations et les expériences, les modalités différentiées par lesquelles s’instaurent, s’éprouvent et se disputent les formes de régulation du vivre-ensemble.
 
-Dès lors, ce chapitre ne postule aucun fondement, ne cherche aucun point d’origine, ne prétend restituer aucune ontologie stable du politique. Ce qu’il donne à lire, c’est une cartographie dynamique des régimes de régulation, traversée par des formes irréductibles, non homogènes, souvent conflictuelles, parfois incompatibles, mais toutes pensées comme des configurations singulières.
+Dès lors, ce chapitre ne postule aucun fondement, ne cherche aucun point d’origine, ne prétend restituer aucune ontologie stable du politique. Ce qu’il donne à lire, c’est une cartographie dynamique des régimes de régulation, traversée par des formes irréductibles, non homogènes, souvent conflictuelles, parfois incompatibles, mais toutes pensées comme des configurations singulières, et souvent complémentaires.
 
 Ainsi, loin d’être une galerie illustrative de théories politiques juxtaposées, le chapitre s’agence comme une topologie critique, une plongée stratigraphique dans les scènes où s’articule la régulation — entendue ici non comme stabilisation externe ou ajustement technico-fonctionnel, mais comme dispositif instituant, tension structurante, scène traversée de conflictualité et d’exigence normative. Car à nos yeux, la régulation n’est pas ce qui vient après le pouvoir, elle en est la forme même constitutive — son architecture, son rythme, son épaisseur. Elle est ce par quoi le pouvoir ne se contente pas d’être exercé, mais s’institue, se justifie, se dispute, se recompose.
 

src/content/archicratie/00-demarrage.mdx

@@ -1,42 +0,0 @@
----
-title: "Démarrage — Essai-thèse"
-edition: "archicratie"
-status: "modele_sociopolitique"
-level: 1
-version: "0.0.1"
-concepts: ["archicratie"]
-links:
-  - type: "definition"
-    target: "/glossaire/archicratie/"
-    note: "Terme canonique."
-order: 0
-summary: "Page de test (structure)."
----
-
-import Callout from "../../components/Callout.astro";
-import Term from "../../components/Term.astro";
-
-Ceci est une page de test pour valider la structure de l’**Essai-thèse**.
-
-<Callout kind="definition" title="Entrée minimale">
-  <p>
-    <Term term="Archicratie" slug="archicratie" /> : régime où l’instance régulatrice est tenue d’exposer ses prises,
-    ses critères et ses scènes d’épreuve.
-  </p>
-</Callout>
-
-<Callout kind="these" title="Ce que l’édition web doit rendre possible">
-  <p>Une lecture à plusieurs niveaux, sans confusion entre les productions, et une citabilité stable.</p>
-</Callout>
-
-<div class="level-2">
-  <Callout kind="objection" title="Objection (niveau 2)">
-    <p>Que gagne-t-on par rapport à une simple doctrine ? Réponse : la scène, la contrainte d’exposition, la pluralisation des prises.</p>
-  </Callout>
-</div>
-
-<div class="level-3">
-  <Callout kind="limite" title="Limite (niveau 3)">
-    <p>Tout schéma d’articulation doit préciser ses non-déductions (transpositions), sinon confusion Traité ↔ Archicratie.</p>
-  </Callout>
-</div>

src/content/atlas/00-demarrage.md

@@ -1,13 +0,0 @@
----
-title: "Démarrage — Atlas"
-edition: "atlas"
-status: "cartographie"
-level: 1
-version: "0.0.1"
-concepts: ["archicrates"]
-links: []
-order: 0
-summary: "Page de test (structure)."
----
-
-Ceci est une page de test pour valider la structure de l’**Atlas**.

src/content/cas-ia/annexe-glossaire-audit.mdx

@@ -0,0 +1,141 @@
+---
+title: "Annexe — Glossaire archicratique pour l’audit des systèmes d’IA"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 100
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Annexe_Glossaire_Archicratique_Cas_IA.docx"
+---
+# Annexe – Glossaire archicratique pour l’audit des systèmes d’IA
+
+Cette annexe propose un bref glossaire des notions archicratiques mobilisées dans l’audit de Système F. Elle n’a pas vocation à réexposer la théorie dans toute son ampleur, mais à fournir au lecteur du cas pratique quelques repères opératoires pour suivre le fil des analyses.
+
+## Arcalité
+
+On appelle *arcalité* la *dimension de tout ordre régulateur qui concerne ses fondements* : *ce qui l’autorise, ce qui le rend légitime, ce qui lui donne droit de décider*. L’*arcalité* est faite de *récits*, de *principes*, de *valeurs*, de *visées explicites ou implicites* : lutter contre la fraude, protéger l’État social, garantir la sécurité, promouvoir la santé, favoriser le “talent”, préserver la liberté d’expression, etc.
+
+Dans Système F, on distingue :
+
+- une *arcalité déclarée* : chartes d’“IA digne de confiance”, discours politiques sur la lutte contre la fraude, documents de marketing qui promettent d’“objectiver” le risque ou d’“optimiser” la sélection ;
+
+- une *arcalité implicite* : choix de variables (coûts de santé comme proxy des besoins, nationalité comme indicateur de risque), arbitrages entre faux positifs et faux négatifs, composition des jeux de données, sélection de critères de “talent” ou de “dangerosité”.
+
+L’enjeu archicratique n’est pas de moraliser *a posteriori* ces choix, mais de les *faire comparer sur scène* : *exposer les axiomes silencieux* (“nous considérons qu’il est plus grave de laisser passer un fraudeur que de punir un innocent”, etc.), *et permettre qu’ils soient discutés, contestés, révisés*.
+
+## Cratialité
+
+La *cratialité* désigne la dimension opératoire du pouvoir régulateur : la manière dont il s’applique concrètement, par quels instruments, quelles chaînes techniques, quelles procédures. C’est le “*par quoi*” et le “*comment*”.
+
+Dans Système F, la *cratialité* se déploie dans :
+
+- les *données mobilisées* (dossiers fiscaux, historiques de soins, casiers judiciaires, CV, contenus de plateformes) ;
+
+- les *pipelines* qui transforment des situations complexes en vecteurs numériques ;
+
+- les *modèles* eux-mêmes (architectures, paramètres, fonctions de coût, seuils de décision) ;
+
+- les *interfaces* (tableaux de bord, scores de risque, codes couleur, messages d’alerte) ;
+
+- les *procédures d’intégration* (règles internes qui imposent de suivre la recommandation ou d’en justifier tout écart).
+
+*Cratialité* n’est pas synonyme de “technique” : elle inclut aussi les *règles organisationnelles*, les *consignes*, les *scripts de travail*. L’audit archicratique ne se contente pas de repérer les algorithmes ; il suit les chaînes cratiales jusqu’aux guichets, aux tribunaux, aux services hospitaliers, aux départements RH, aux plateformes.
+
+## Archicration
+
+L’*archicration* est le troisième terme du triptyque : elle désigne la *scène d’épreuve où arcalité et cratialité sont amenées en visibilité, confrontées, mises à l’épreuve et, si nécessaire, transformées*.
+
+Sans *archicration*, les fondements restent fantômes, et le pouvoir opératoire devient autarcique.
+
+Une *archicration* digne de ce nom réunit quatre conditions minimales :
+
+1.  *Public(s) concerné(s) effectivement représentés* (et pas seulement des experts parlant “en leur nom”) ;
+
+2.  *Accès aux prises* : connaissance minimale des arcalités à l’œuvre (valeurs, finalités, proxies, fonctions de coût) et des cratialités (chaînes techniques, procédures, interfaces) ;
+
+3.  *Capacité de contestation* : possibilité d’interpeller les choix, de demander des modifications, de suspendre un dispositif ;
+
+4.  *Effet réel* : ce qui se dit sur la scène peut produire des transformations sur le système, pas seulement un “avis” consultatif.
+
+Dans Système F, la plupart des dispositifs existants – comités d’éthique, audits de biais, formulaires de recours – n’atteignent pas ce seuil : ce sont des *archicrations fantômes*, qui donnent l’allure de la scène sans en avoir la puissance.
+
+## Hypotopie, hypertopie, atopie
+
+Ces trois termes qualifient la topologie des scènes où la régulation IA apparaît (ou disparaît).
+
+- Une *hypotopie* est une *scène pauvre en prises, faiblement outillée, où les gens peuvent parler mais sans pouvoir effectivement infléchir la régulation*. Par exemple : un usager qui discute avec un agent de caisse sociale d’une décision prise en réalité par Système F, sans accès ni aux paramètres ni aux logs ; un formulaire de recours tellement opaque et lourd qu’il décourage toute contestation.
+
+- Une *hypertopie* est une *scène surdotée à huit-clos* : tout s’y joue – paramètres, seuils, choix de déploiement – mais entre un nombre très limité d’acteurs (directions, ingénieurs, juristes, consultants). *Les comités de pilotage où l’on décide d’intégrer ou non Système F dans la chaîne de décision, les réunions de design des modèles sont souvent des hypertopies*.
+
+- Une *atopie* est une *scène fantomatique* : elle mime le dispositif d’épreuve, sans donner prise réelle. Consultations publiques en ligne sans impact, “boîtes à idées” numériques, mécanismes de *feedback* qui alimentent surtout des métriques internes (satisfaction, engagement) sans reconfigurer la régulation.
+
+L’épreuve topologique, dans le cas IA, consiste à cartographier où se trouvent les *hypotopies, hypertopies, atopies*, et à inventer des scènes nouvelles qui rééquilibrent cette topologie.
+
+## Autarchicratie
+
+L’*autarchicratie* désigne un régime où la régulation devient son propre souverain : les dispositifs de mesure, de modélisation et de contrôle se gouvernent eux-mêmes à partir de leurs propres métriques, et ne reconnaissent plus que très marginalement des scènes externes d’épreuve.
+
+Dans Système F, l’*autarchicratie* prend plusieurs formes :
+
+- *modèles évalués principalement par leurs métriques internes* (perte, précision, indicateurs d’équité) ;
+
+- *dispositifs d’auto-audit et de reporting automatisé* qui servent de preuve de “responsabilité” sans ouvrir réellement le système à la contestation ;
+
+- *boucles de rétroaction fermées* où les décisions passées alimentent les données futures (ceux que le système considère comme “à risque” seront davantage contrôlés, et donc produiront plus de “preuves” de risque).
+
+L’*autarchicratie* est l’exact négatif de l’*archicratie* : *là où l’archicratie multiplie les scènes d’épreuve, l’autarchicratie les marginalise ou les simule*.
+
+## Co-viabilité
+
+Par *co-viabilité*, on entend la *capacité d’un ordre régulateur à rendre simultanément vivables plusieurs dimensions de l’existence* : sociale, écologique, symbolique, parfois économique.
+
+Dans le cas IA :
+
+- la *co-viabilité sociale* renvoie à l’*accès aux droits*, à la *protection contre l’arbitraire*, à la *dignité des personnes* (ne pas être réduit à un profil de risque opaque, pouvoir contester une décision qui affecte des prestations, des peines, des soins, un emploi) ;
+
+- la *co-viabilité écologique* concerne les *coûts matériels de l’infrastructure* (consommation énergétique, pressions sur les ressources, effets territoriaux des centres de données et des centres d’extraction) et la *possibilité de les mettre en scène* ;
+
+- la *co-viabilité symbolique* touche aux *représentations de la justice, du mérite, du risque, de la vérité*, et à la manière dont Système F contribue à les figer ou à les rouvrir.
+
+L’*épreuve de co-viabilité* ne se limite donc pas à mesurer des “impacts” ; elle demande : *quels types de scènes faut-il instituer pour que ces dimensions puissent être mises en balance, arbitrées et révisées ?*
+
+## Politique des épreuves viables
+
+La *politique des épreuves viables* est le nom donné à une *orientation normative minimale* : plutôt que de définir un modèle de justice idéal, elle consiste à organiser les épreuves auxquelles les dispositifs régulateurs doivent se soumettre pour rester archicratiques.
+
+Appliquée à l’IA, elle se traduit par une *série de gestes concrets* :
+
+- *droit au différé contradictoire* pour les décisions appuyées par un système ;
+
+- *journaux de justification* documentant les choix de modèles, de métriques, de proxies, d’usages ;
+
+- *visas d’affectation* qui autorisent ou interdisent certains usages de scores dans des décisions critiques ;
+
+- *coupe-circuits citoyens* permettant de suspendre un système en cas de dégâts massifs ;
+
+- *tribunaux de l’algorithme*, assemblées d’affectation, budgets scéniques pour financer le temps de la délibération et de la traduction ;
+
+- *révisions archicratives périodiques* s’accompagnant d’une *cartographie des scènes manquantes*.
+
+Dans le cas de Système F, ces gestes ne sont pas des ornements : ils définissent le seuil en deçà duquel il n’est plus raisonnable de parler de gouvernance archicratique de l’IA, mais d’*autarchicratie numérique*.
+
+## Système F
+
+Enfin, *Système F* n’est pas le nom d’un produit commercial, mais celui d’une figure composite : un modèle de fondation (LLM / modèle multimodal) accessible par API, intégré dans des flux de travail décisionnels de la protection sociale, de la santé, de la justice, des ressources humaines, des plateformes numériques.
+
+Il condense des caractéristiques empiriquement attestées :
+
+- *usage de systèmes de scoring* pour cibler des contrôles de fraude, évaluer des risques pénaux, gérer des programmes de soins, filtrer des candidatures, modérer des contenus ;
+
+- *insertion de modules d’IA dans des logiciels métier existants* ;
+
+- *dépendance à des fournisseurs privés de services cloud et de modèles* ;
+
+- *adoption de chartes d’“IA responsable” et de procédures d’audit parfois plus symboliques qu’effectives*.
+
+L’intérêt de Système F n’est donc pas de décrire un futur hypothétique, mais de donner un nom commun à une configuration déjà largement engagée, afin de lui appliquer, sans esquive, l’ensemble des épreuves archicratiques.

src/content/cas-ia/chapitre-1.mdx

@@ -0,0 +1,535 @@
+---
+title: "Chapitre I — Épreuve de détectabilité"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 20
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_1_Epreuve_de_detectabilite.docx"
+---
+# I. Épreuve de détectabilité : *arcalité / cratialité / archicration* dans un système d’IA
+
+L’épreuve de détectabilité ne consiste pas à ajouter une couche de vocabulaire au-dessus d’un dispositif déjà saturé de termes techniques. Elle exige, au contraire, un geste presque naïf : *où voit-on quelque chose ? Où peut-on désigner, avec un minimum de précision, ce qui fonde, ce qui opère et ce qui met en épreuve ?* Tant que ces trois prises restent indiscernables ou introuvables, l’*archicratie* n’est pas simplement déficitaire ; elle est empêchée. Appliquée à un grand système d’IA de fondation, l’épreuve de détectabilité commande une micro-cartographie patiente des lieux, des moments et des interfaces où Système F se rend effectivement présent – ou, plus souvent, se déploie sans se déclarer.
+
+## I.1. Scénarisation structurée du système IA
+
+L’enjeu de cette section n’est pas d’inventer un futur hypothétique, mais de composer un cas stylisé à partir d’éléments déjà avérés. Système F sera donc construit comme un agrégat abstrait de dispositifs bien documentés, provenant de plusieurs domaines (protection sociale, justice pénale, santé, recrutement, plateformes numériques). Chaque scène d’usage que nous décrirons ensuite reprend des traits explicitement attestés dans ces cas réels.
+
+### I.1.1. Les briques empiriques de Système F
+
+#### **Protection sociale : SyRI et le scandale des allocations familiales néerlandaises**
+
+Dans le domaine de la protection sociale, deux affaires néerlandaises forment un socle empirique très clair.
+
+Le système SyRI (*Systeem Risico Indicatie*) était un outil de détection de fraude aux prestations sociales, fondé sur le croisement massif de données issues de différentes administrations (assurance sociale, emploi, logement, fiscalité). En février 2020, le tribunal de district de La Haye a jugé que la législation encadrant SyRI violait l’article 8 de la Convention européenne des droits de l’homme (droit au respect de la vie privée), notamment en raison du manque de transparence sur le fonctionnement du système, de la faible proportionnalité et du ciblage de quartiers pauvres. Le tribunal a ordonné l’arrêt immédiat de l’utilisation de SyRI.
+
+Parallèlement, le scandale des allocations pour la garde d’enfants (*toeslagenaffaire*) a mis au jour un modèle de classification du risque utilisé par l’administration fiscale néerlandaise, qui a conduit à accuser à tort environ 26 000 parents de fraude. Ces familles ont été sommées de rembourser des montants importants de prestations, ce qui a provoqué des situations de surendettement massif, de pertes de logement et de détresse psychologique ; une part disproportionnée des victimes avaient un arrière-plan migratoire. Amnesty International a montré que des éléments comme la nationalité ou la double nationalité étaient utilisés comme facteurs de risque, produisant une boucle de discrimination systémique ; l’autorité néerlandaise de protection des données a conclu à un traitement discriminatoire.
+
+Ces deux cas attestent empiriquement que des systèmes de *scoring* algorithmique peuvent être intégrés au travail de guichet, cibler certaines catégories de population, fonctionner de manière opaque et produire des décisions automatiques de suspension ou de recouvrement, avec des voies de recours très limitées.
+
+#### **Justice pénale : l’algorithme COMPAS et l’affaire Loomis**
+
+Dans le champ pénal, l’algorithme COMPAS (Correctional Offender Management Profiling for Alternative Sanctions), développé par Northpointe/Equivant, est utilisé dans plusieurs États américains pour produire des scores de risque de récidive. Ces scores figurent dans des rapports d’aide à la décision destinés aux juges lors des phases de mise en liberté sous caution, de fixation de peine ou de libération conditionnelle.
+
+Dans l’affaire State v. Loomis (Cour suprême du Wisconsin, 2016), le prévenu a contesté l’usage de COMPAS en soutenant que la méthodologie était secrète (secret commercial) et qu’il ne pouvait donc ni en vérifier l’exactitude ni la contester. La Cour a maintenu la possibilité pour le juge d’utiliser COMPAS, mais à condition d’accompagner le score de mises en garde sur ses limites et en rappelant que la décision finale reste humaine, la méthode demeurant néanmoins non accessible à la défense.
+
+On dispose ainsi d’un cas où un score algorithmique chiffré s’inscrit explicitement dans la chaîne de la décision judiciaire, tout en restant largement opaque pour le justiciable et même pour le tribunal.
+
+#### **Santé : l’algorithme de gestion de risques analysé par Obermeyer et al. (Science, 2019)**
+
+Dans le système de santé américain, Ziad Obermeyer et ses co-auteurs ont étudié un algorithme commercial largement utilisé pour la gestion de programmes de “soins intensifs” destinés à des patients à haut risque.
+
+Cet algorithme produit, pour chaque patient, un score de risque ; ceux dont le score dépasse un seuil sont orientés vers des programmes qui mobilisent des ressources supplémentaires (suivi renforcé, coordination des soins, etc.).
+
+L’étude montre que, pour un niveau de risque donné selon l’algorithme, les patients noirs sont en moyenne beaucoup plus malades que les patients blancs (plus de pathologies non contrôlées, marqueurs biologiques plus dégradés).
+
+La raison identifiée est que l’algorithme ne prédit pas directement la morbidité, mais les coûts de santé futurs ; or, dans un système marqué par des inégalités d’accès aux soins, les patients noirs engendrent en moyenne moins de dépenses, à état de santé équivalent. Ce choix de variable (coûts comme proxy des besoins) introduit une biais structurel qui conduit à sous-orienter vers les programmes de soins renforcés des patients noirs qui en auraient le plus besoin.
+
+Ce cas illustre très précisément comment une fonction de coût et un choix de proxy peuvent incorporer une *arcalité implicite* (coûts ≈ besoins) et produire des *effets cratiaux massifs* sur l’accès aux ressources médicales.
+
+#### **Recrutement : l’outil de tri de CV d’Amazon**
+
+En 2018, Reuters a révélé qu’Amazon avait développé, puis abandonné, un outil interne de recrutement automatisé visant à classer des CV de candidat·es à des postes techniques. Entraîné sur une décennie d’historiques de recrutement dans un secteur très masculin, le système a “appris” que les profils masculins étaient plus souhaitables. Il pénalisait les CV comportant le mot “women’s” (comme “women’s chess club captain”) et déclassait les diplômées de certaines universités qualifiées de « féminines ».
+
+Confrontée à ces biais, l’entreprise a renoncé à déployer cet outil en production. Mais l’enquête montre qu’il est techniquement possible – et, en pratique, déjà réalisé – d’intégrer des modèles genrés de scoring dans la chaîne de sélection des candidatures, en laissant leur logique sous-jacente hors de la vue des candidat·es.
+
+#### **Plateformes numériques : modération et curation algorithmique**
+
+Enfin, dans le monde des plateformes, la documentation abondante sur Facebook/Meta, YouTube, TikTok ou X (ex-Twitter) montre que la modération des contenus et la curation algorithmique reposent massivement sur des systèmes automatisés, l’intervention humaine intervenant préférentiellement en seconde ligne ou pour les cas litigieux.
+
+Des guides destinés aux utilisateurs ou aux praticiens décrivent le fonctionnement général de ces dispositifs : chez Facebook, par exemple, l’IA est présentée comme “première ligne de défense”, qui scanne les contenus, détecte les possibles violations et les supprime directement ou les envoie à des modérateurs humains pour revue.
+
+Au niveau réglementaire, le Digital Services Act européen impose désormais aux grandes plateformes de publier des rapports annuels de transparence sur la modération de contenu, en distinguant explicitement les contenus supprimés ou limités suite à des décisions automatisées.  
+Le rapport 2022 de l’Agence des droits fondamentaux de l’UE sur les biais dans les algorithmes mentionne d’ailleurs l’usage croissant de systèmes de détection automatique de discours offensant, avec des risques de discrimination et de sur-modération de certaines communautés ou langues.
+
+En parallèle, la création de l’*Oversight Board* de Meta, doté d’un pouvoir de révision de certaines décisions de modération, confirme l’ampleur des enjeux : une instance quasi-juridictionnelle a été instituée pour examiner des cas emblématiques et problématiques, souvent issus de décisions initiales prises par des systèmes automatisés ou semi-automatisés.
+
+Ces éléments convergent : l’essentiel de ce qui se voit – ou ne se voit pas – sur les grandes plateformes est trié, promu, enfoui, suspendu par des combinaisons d’algorithmes de recommandation, de détection et de filtrage.
+
+### I.1.2. De ces cas à un système composite : définition structurée de “Système F”
+
+À partir de ces pièces empiriques, nous pouvons maintenant définir plus rigoureusement ce que nous appellerons Système F.
+
+#### **Un fournisseur de modèle de fondation accessible par API**
+
+Du côté de l’offre technique, il est désormais établi que des modèles de fondation (grands modèles de langage, modèles multimodaux) sont fournis sous la forme de services cloud accessibles via API. Le Comité européen de la protection des données (EDPB), par exemple, décrit explicitement le modèle “LLM as a Service” : un fournisseur héberge le modèle, en contrôle les poids et la formation, et donne accès aux utilisateurs par une interface de programmation, sans leur donner la main sur l’architecture interne.
+
+Des initiatives comme Azure OpenAI Service pour les administrations publiques américaines ou européennes, et des programmes dédiés comme “OpenAI for Government” ou “ChatGPT Gov”, illustrent l’extension de ce modèle au secteur public : les administrations peuvent appeler des modèles puissants pour traiter des textes, analyser des dossiers, générer des réponses, via des API sécurisées.
+
+L’Ada Lovelace Institute a documenté, dans un rapport dédié, l’usage déjà existant de modèles de fondation dans la sphère publique, intégrés à des outils “grand public” (moteurs de recherche, suites bureautiques, logiciels métiers) que les agents utilisent au quotidien.
+
+Dans notre scénarisation, Système F désigne donc un fournisseur de modèle de fondation (type LLM / modèle multimodal), hébergé dans le cloud, accessible via API, et mis à disposition d’acteurs publics et privés.
+
+#### **Des intégrateurs qui fabriquent des solutions verticales**
+
+Entre le fournisseur de modèle et les administrations, il y a des intégrateurs : grandes entreprises de services numériques, start-ups spécialisées, équipes internes “IA” de ministères ou d’agences. Leur rôle concret, pour l’instant, est bien attesté : adapter des briques de modèles génériques à des cas d’usage sectoriels (chatbots administratifs, aides à la rédaction de courriers, outils d’analyse de documents, systèmes de tri ou de priorisation).
+
+Les dispositifs de détection de fraude sociale, de *scoring* pénal, de gestion de risques en santé et de tri de CV mentionnés plus haut ne reposent pas tous sur des modèles de fondation au sens strict, mais ils incarnent déjà ce rôle d’intégrateur : transformer une capacité de calcul et de classification en un module prêt à l’emploi pour une administration précise. Système F se situe dans cette continuité : un modèle générique, repris et encapsulé par une diversité de prestataires qui construisent des “solutions” pour la protection sociale, la justice, la santé, le recrutement, la modération.
+
+#### **Des organisations utilisatrices : ministères, caisses, hôpitaux, tribunaux, entreprises, plateformes**
+
+Enfin, les utilisateurs institutionnels que nous considérons – caisses de prestations sociales, services fiscaux, tribunaux, hôpitaux, services RH, plateformes de réseaux sociaux – ne sont pas conjecturaux : ce sont précisément ceux qui, dans les affaires documentées, ont déjà recouru à des algorithmes de scoring, de tri ou de filtrage. Les études sur l’IA dans le secteur public montrent que les cas d’usage montent en puissance, notamment dans les fonctions de traitement de dossiers, de tri de demandes, de détection d’anomalies, d’assistance au recrutement et d’information au public.
+
+En agrégeant ces éléments, Système F désigne donc une chaîne socio-technique structurée en trois niveaux :
+
+- un fournisseur de modèle de fondation via API ;
+
+- des intégrateurs qui encapsulent ce modèle dans des solutions sectorielles ;
+
+- des organisations utilisatrices qui insèrent ces solutions dans leurs procédures quotidiennes.
+
+Cette structure n’est pas une vue de l’esprit : elle reflète l’architecture déjà mise en place par les grands fournisseurs d’IA et adoptée, progressivement, par des administrations publiques et des entreprises.
+
+### I.1.3. Quatre scènes typiques d’usage, stylisées mais ancrées
+
+Sur cette base, nous pouvons maintenant détailler quatre scènes d’usage de Système F, en indiquant à chaque fois les cas réels qui nourrissent la description.
+
+#### **L’agent de protection sociale et la liste des dossiers**
+
+Dans de nombreux pays européens, les systèmes de détection de fraude aux prestations prennent la forme de listes de dossiers accompagnées d’un score de risque. Les travaux sur SyRI et sur le scandale des allocations néerlandaises montrent que des fonctionnaires se voient présenter des listes de bénéficiaires classés par “profil de risque”, résultant de modèles qui croisent des données multiples (revenus, composition familiale, historique fiscal, etc.).
+
+Dans notre scène, l’agent·e d’une caisse sociale ouvre une application de gestion des dossiers : une file virtuelle apparaît, avec pour chaque dossier un score numérique et un code couleur. Le tri par défaut ne suit plus l’ordre chronologique de dépôt, mais la priorité calculée par un module issu de Système F, configuré pour combiner “risque de fraude” et “urgence” selon des paramètres fixés en amont. Cette configuration est directement inspirée des systèmes réels de risque de classement (*risk scoring*), même lorsqu’ils ne reposaient pas encore sur des modèles de fondation.
+
+#### **Le juge et le rapport de risque**
+
+L’expérience américaine avec COMPAS montre qu’un rapport de risque algorithmique peut être intégré au dossier judiciaire, sous la forme d’un document qui synthétise un score global et quelques facteurs aggravants ou atténuants. Dans l’affaire Loomis, le prévenu a été évalué comme “à haut risque” par COMPAS, et ce rapport a pesé dans la justification de la peine.
+
+Dans notre scène, le juge ne voit pas directement Système F, mais un rapport standardisé annexé au dossier : un score, une classe de risque, des éléments de langage justifiant ce score, issus d’un module pénal connecté au modèle de fondation. Ce schéma reprend les traits factuels de COMPAS (score, opacité de la méthode, statut “d’aide à la décision”) tout en les transposant dans une architecture de modèle de fondation accessible via API.
+
+#### **La médecin et la priorisation des patients**
+
+L’algorithme étudié par Obermeyer et al. montre comment un outil de gestion des risques en santé peut décider l’éligibilité à un programme de soins renforcés sur la base d’un score calculé à partir des coûts passés.
+
+Dans notre scène, un médecin hospitalier ouvre la liste des patients en attente d’un examen lourd ou d’une consultation spécialisée. L’interface, alimentée par un module de Système F, propose une “vue optimisée” : les patients sont ordonnés selon un indice de priorité calculé, avec un message qui signale lorsqu’elle s’écarte de cette priorisation (“vous vous écartez de la recommandation algorithmique, confirmez-vous ?”). La scène est stylisée, mais elle transpose directement la logique documentée : un score de risque conditionne l’accès à des ressources rares, et le praticien se voit suggérer un ordre “optimal”.
+
+#### **La plateforme et la visibilité des contenus**
+
+Les documents publics de Meta/Facebook reconnaissent que des systèmes automatisés scannent les contenus, les signalent, voire les suppriment directement en première intention. Les obligations de transparence du DSA confirment que les grandes plateformes utilisent des outils automatisés de modération et de recommandation à grande échelle.
+
+Dans notre scène, un utilisateur poste un contenu critique sur une politique publique ou un témoignage lié à des prestations sociales. Un module dérivé de Système F, intégré à la chaîne de modération et de recommandation, évalue ce contenu : il peut le classer comme “à risque” (discours haineux, désinformation présumée, “contenu limite”), réduire sa visibilité ou déclencher une revue humaine. L’utilisateur ne verra, le plus souvent, qu’un message laconique (“votre contenu a enfreint nos standards”) ou une chute d’audience difficilement interprétable.
+
+## I.2. *Arcalité déclarée* du système
+
+Par “*arcalité déclarée*”, nous désignerons l’ensemble des formules par lesquelles les acteurs qui conçoivent, diffusent ou utilisent des dispositifs algorithmiques disent ce qu’ils font et au nom de quoi ils le font. Il ne s’agit pas des détails techniques de l’implémentation, ni des effets réels que nous avons mis au jour dans les affaires de fraude sociale, de justice pénale, de santé, de recrutement ou de plateformes ; il s’agit des *justifications publiques*, telles qu’elles apparaissent dans les textes législatifs, les décisions de justice, les rapports d’autorités administratives, les documents d’entreprises, les chartes de “bonne conduite” et les programmes de régulation internationale. C’est cette couche discursive que l’épreuve archicratique doit d’abord prendre au sérieux, non pour la dénoncer en bloc comme “pure idéologie”, mais pour mesurer ce qu’elle rend visible et ce qu’elle tient pour acquis.
+
+Dans les cinq domaines où nous avons décrit des usages de Système F – protection sociale, justice pénale, santé, recrutement, plateformes numériques –, cette *arcalité déclarée* adopte des formes différentes, liées aux traditions propres de chaque champ, mais elle se rassemble autour d’une grammaire relativement stable : *lutte contre des menaces identifiées* (fraude, récidive, complications coûteuses, “mauvais recrutements”, contenus illégaux ou dangereux), *rationalisation de l’action publique ou privée*, *promesse d’objectivité*, *impératif de sécurité et de confiance*. À ce niveau, Système F apparaît d’abord comme un auxiliaire : l’algorithme n’est pas présenté comme un souverain qui se substituerait aux institutions, mais comme un instrument qui permettrait à celles-ci de mieux remplir leurs missions.
+
+### I.2.1. La fraude comme récit de fondation
+
+Dans le domaine de la protection sociale, l’*arcalité déclarée* est structurée par un récit désormais bien installé : *il s’agit de défendre l’intégrité de l’État social contre la fraude aux prestations, l’abus de droits et les détournements de fonds publics*. Comme l’a montré l’affaire SyRI et, plus encore, le scandale des allocations pour la garde d’enfants, la lutte contre la ‘*fraude*’ devient la matrice discursive qui justifie le recours à des systèmes de classements massifs et opaques.
+
+Dans ce cadre discursif, les termes techniques – *profil de risque*, *croisement de bases de données*, *ciblage des contrôles* – se présentent comme de simples moyens d’atteindre un but qui, lui, est posé comme incontestable : *protéger la “soutenabilité” des régimes de prestations en évitant qu’ils ne soient “vidés de leur substance” par des comportements abusifs*. L’essentiel de l’argument arcal se déploie dans un lexique de la vigilance et de la responsabilité : l’administration se doit, pour protéger les “vrais bénéficiaires”, de traquer les fraudeurs avec des outils modernes, proportionnés et ciblés.
+
+Du point de vue archicratique, on voit se dessiner ici une figure typique : la *fraude* devient le point focal de la justification. La question de savoir ce qu’est, concrètement, une erreur de bonne foi, un litige interprétatif, une situation de vulnérabilité structurelle, est reléguée à l’arrière-plan. La tension entre présomption d’innocence et présomption de suspicion est peu articulée ; le terme de “fraude” fonctionne comme un opérateur de condensation qui autorise des dispositifs de surveillance étendus, pourvu qu’ils soient décrits comme des moyens “nécessaires” à la sauvegarde de l’État social. L’*arcalité déclarée* est donc forte (*défense d’un bien collectif précieux*), mais très générale : elle ne descend guère au niveau des catégories fines qui seront effectivement travaillées par Système F.
+
+### I.2.2. Objectivation du risque et cohérence des peines
+
+Dans le champ de la justice pénale, l’*arcalité déclarée* s’appuie sur un autre récit, lui aussi bien identifié dans la littérature : celui de l’*évaluation actuarielle du risque* et de la “*cohérence*” *des décisions de justice*. Les guides destinés aux praticiens pour l’usage de COMPAS, par exemple, présentent l’outil comme une méthode “objective, standardisée, fondée sur la recherche” pour estimer la probabilité de récidive à partir d’un ensemble de facteurs psychosociaux et historiques.
+
+Dans l’arrêt *State v. Loomis*, la Cour suprême du Wisconsin accepte cette finalité : l’usage d’un instrument actuariel est recevable dès lors qu’il est clairement qualifié d’“aide à la décision” et que le juge conserve, en principe, la maîtrise de la peine. La Cour insiste sur la nécessité de rappeler les limites du système, mais elle ne remet pas en cause la légitimité de l’objectif affiché : rendre les décisions plus cohérentes, plus prévisibles, moins dépendantes des intuitions ou des préjugés des magistrats. L’*arcalité déclarée* articule ici un double horizon : *améliorer la justice distributive* (réduire les disparités de traitement) *et la sécurité publique* (anticiper les comportements futurs “à risque”).
+
+Ce discours s’inscrit dans une histoire plus longue de “gestion du risque” en droit pénal : montée des outils actuariels de probation, intérêt pour les “évaluations fondées sur la preuve”, critiques de l’arbitraire judiciaire. Il emprunte beaucoup au vocabulaire de la statistique, de la psychologie et du management du risque. L’algorithme n’est jamais présenté comme une source de normativité autonome ; il fournit des scores, des ratios, des catégories (“faible”, “moyen”, “élevé”) qui doivent éclairer des décisions qui, elles, demeurent juridiquement encadrées. L’*arcalité déclarée* est donc celle d’une *rationalisation du pouvoir de juger* : mettre la peine sous le signe du calcul et de l’expertise plutôt que du tâtonnement individuel.
+
+### I.2.3. Gestion de population et ciblage de ressources rares
+
+Dans le domaine de la santé, les algorithmes que nous avons retenus comme briques de Système F sont inscrits dans un lexique propre : celui de la “politique santé des populations”, de la “gestion de patients jugés à risque”, de la “prévention des hospitalisations évitables”. L’algorithme analysé par Obermeyer et al. est présenté par ses concepteurs et par les hôpitaux qui l’utilisent comme un outil permettant d’identifier les patients “aux besoins complexes” et de les orienter vers des programmes de gestion de soins intensifs.
+
+Les documents de promotion de ce type de systèmes insistent sur un double objectif : d’une part, “*améliorer la qualité des soins*” en offrant un suivi renforcé aux patients les plus vulnérables ; d’autre part, “*maîtriser les coûts*” en réduisant les complications graves, les ré-hospitalisations et les recours imprévus aux urgences. L’*arcalité déclarée* assume pleinement cette tension : il s’agit de *concilier des impératifs cliniques et budgétaires en allouant des ressources rares* (temps médical, programmes sophistiqués, coordination, technologies coûteuses) *de la “façon la plus efficiente possible*”.
+
+Sur le plan discursif, la notion de “*risque élevé*” est donc chargée d’une valeur positive : loin de stigmatiser les patients, elle leur ouvre l’accès à des dispositifs jugés bénéfiques. Le modèle d’IA est décrit comme un moyen de “repérer ce que l’œil humain ne voit pas facilement”, c’est-à-dire de *détecter en amont des trajectoires de dégradation de la santé*. À nouveau, l’*arcalité déclarée* en appelle à des valeurs fortes : *meilleure prise en charge, prévention, justice dans l’allocation des soins, soutenabilité financière des systèmes de santé*.
+
+### I.2.4. “Talent”, méritocratie et efficacité de la sélection
+
+Dans le secteur du recrutement, les systèmes de tri automatisé empruntent d’autres registres. Les discours qui entourent le projet de classement des CV développé par Amazon, ainsi que la littérature managériale plus large sur les “*talent analytics*”, convergent vers une même promesse : “*mécaniser la recherche des meilleurs talents*”, “*libérer les recruteurs des tâches répétitives*”, “*standardiser la sélection*” et “*réduire les biais individuels*” en confiant la première lecture des dossiers à un modèle.
+
+L’*arcalité déclarée* ici ne renvoie ni à l’État social ni à la justice pénale, mais à une certaine *représentation de la méritocratie en entreprise* : les “bons profils” seraient ceux qui maximisent la performance, la productivité, l’adéquation à la culture de l’organisation. Le système d’IA est présenté comme un “assistant impartial” capable de faire émerger des “signaux faibles” dans les CV, de repérer des trajectoires prometteuses, de réduire le poids des impressions fugitives et des “préjugés inconscients” des recruteurs.
+
+Ce discours est en résonance avec une tradition managériale qui valorise le *data-driven HR*, la capacité à “objectiver” des intuitions en les traduisant en scores, en *rankings*, en probabilités de succès. L’algorithme devient une sorte de miroir supposé neutre des “caractéristiques qui différencient les meilleurs employés des autres”, pour reprendre une formule fréquemment mobilisée dans ce champ. L’*arcalité déclarée* associe donc trois promesses : *gain d’efficacité*, *amélioration de la qualité des recrutements*, *réduction affichée des biais humains*.
+
+### I.2.5. Sécurité, “contenus illégaux” et transparence
+
+Dans l’univers des grandes plateformes, le Digital Services Act européen donne une formulation particulièrement nette de l’*arcalité déclarée*. Le DSA affirme vouloir “*réduire la distribution de contenus illégaux*”, protéger les utilisateurs contre diverses formes de risques en ligne, et instaurer des exigences nouvelles de transparence et de responsabilisation pour les intermédiaires.
+
+Les plateformes, de leur côté, ont développé depuis plusieurs années un lexique de sûreté et de réduction des risques : leurs règles de “standards communautaires” ou de “règles de la communauté” visent à “protéger” les utilisateurs contre les discours haineux, le harcèlement, la propagande terroriste, la désinformation dommageable, les images violentes ou sexualisées non consenties. Elles décrivent leurs systèmes d’IA comme une “*première ligne de défense*” qui filtre les contenus au moment de la mise en ligne, identifie les violations manifestes, et transmet les cas ambigus à des équipes de modération humaines.
+
+L’*arcalité déclarée* se trouve ici à la frontière entre droit et morale : les plateformes affirment respecter les législations nationales et européennes, mais elles revendiquent aussi la mise en œuvre de “standards de communauté” qui excèdent parfois les strictes obligations juridiques. Avec le DSA, une grammaire spécifique se stabilise : celle de la “*sécurité en ligne*” et de la “*transparence des décisions de modération*”, adossée à des *obligations concrètes* (mécanismes de signalement des contenus illégaux, justification des décisions de retrait ou de déréférencement, bases de données publiques d’actions de modération).
+
+Dans ce cadre, l’usage d’outils automatisés est présenté comme un moyen de faire face à des volumes massifs de contenus, de “réagir rapidement” à des menaces, de limiter l’exposition du public à des messages jugés dangereux. L’*arcalité déclarée* articule donc *protection des usagers, respect de la liberté d’expression* (au moins dans l’intention), *et exigence de transparence accrue.*
+
+### I.2.6. Principes transversaux : “*IA responsable*”, “*IA digne de confiance*”
+
+Au-dessus de ces légitimités sectorielles, une couche plus générale s’est constituée autour de l’idée d’“*IA responsable*” ou d’“*IA digne de confiance*”. Les Principes de l’OCDE sur l’intelligence artificielle, adoptés en 2019, affirment que les systèmes d’IA devraient “*bénéficier aux personnes et à la planète en favorisant une croissance inclusive, le développement durable et le bien-être*”, être conçus de manière à “*respecter l’état de droit, les droits de l’homme, les valeurs démocratiques et la diversité*”, et inclure des garanties appropriées (*intervention humaine, traçabilité, sécurité*).
+
+Les Lignes directrices européennes pour une IA digne de confiance, élaborées par le groupe d’experts de haut niveau sur l’IA, déclinent ces ambitions en sept “*exigences*” : agence humaine et contrôle, robustesse et sécurité techniques, gouvernance des données, transparence, diversité et équité, bien-être sociétal et environnemental, responsabilité. Elles sont assorties d’une liste d’auto-évaluation (ALTAI) destinée aux développeurs et aux utilisateurs pour vérifier que leurs systèmes s’y conforment.
+
+Les grands fournisseurs privés de modèles de fondation se sont, pour l’essentiel, alignés sur cette grammaire. Google a publié en 2018 ses “*AI Principles*”, qui insistent sur le fait que les applications d’IA doivent être “*socialement bénéfiques*”, “*éviter de créer ou de renforcer des biais injustes*”, être “*construites et testées pour la sécurité*”, “*être responsables devant les personnes*” et “*incorporer la vie privée dès la conception*”. Microsoft a formulé, quant à lui, un ensemble de principes analogues : *équité, fiabilité et sécurité, confidentialité et sécurité, transparence, responsabilité, inclusivité*, qui servent de base à son “*Responsible AI Standard*” interne.
+
+Cette couche transversale d’énoncés n’est pas anecdotique : elle fournit le vocabulaire dans lequel Système F doit, aujourd’hui, se présenter pour être légitime. Une administration qui lance un appel d’offres pour un module de détection de fraude ou d’aide à la décision judiciaire attend des fournisseurs qu’ils s’inscrivent dans ce registre ; une entreprise qui internalise un système de tri de CV est incitée à le faire sous la bannière de l’“IA responsable” et de la lutte contre la discrimination. L’*arcalité déclarée* de Système F est donc redoublée par ce *halo de principes généraux*, qui se veulent compatibles avec les droits fondamentaux et les valeurs démocratiques.
+
+### I.2.7. Une grammaire commune de légitimation
+
+Si l’on rassemble ces différents registres, une grammaire commune de l’*arcalité déclarée* apparaît assez nettement. Elle articule au moins quatre motifs récurrents.
+
+Le premier est celui de la *protection contre des menaces identifiées*. Dans la protection sociale, c’est la fraude aux prestations qui menace la viabilité du système ; dans la justice pénale, c’est la récidive qui met en danger la sécurité publique ; dans la santé, ce sont les complications évitables et les trajectoires de dégradation qui menacent la stabilité des systèmes de soins ; dans le recrutement, ce sont les “mauvais choix” qui mettent en péril la compétitivité de l’entreprise ; sur les plateformes, ce sont les contenus illégaux ou nocifs qui mettent en péril les usagers et l’espace public. L’algorithme est habilité à partir du moment où il est cadré comme une *barrière* supplémentaire contre ces risques.
+
+Le deuxième motif est celui de la *rationalisation* et de l’*efficience*. L’automatisation est décrite comme un moyen de traiter plus de dossiers, plus rapidement, avec moins de ressources humaines, de rendre les décisions plus cohérentes, de réduire l’arbitraire. Dans le langage des administrations sociales, cela se traduit par la promesse de “*ciblage des contrôles*” et de “*réduction des abus*” ; dans celui des hôpitaux, par la “*priorisation des patients à haut risque*” ; dans celui des services RH, par la “*gestion de volumes massifs de candidatures*” ; dans celui des plateformes, par la possibilité de *modérer des quantités de contenus impossibles à gérer manuellement*. Système F est ici la figure d’un auxiliaire rationnel, intensifiant les capacités habituelles des organisations.
+
+Le troisième motif est celui de l’*objectivité* – ou, à tout le moins, d’une réduction des biais imputés aux évaluations purement humaines. Dans la justice pénale, l’*évaluation actuarielle* se donne comme “*fondée sur la preuve*” plutôt que sur les intuitions ; dans la santé, le score de risque agrège des données cliniques et des historiques de dépenses ; dans le recrutement, l’algorithme promet d’être indifférent au genre, à l’origine, à l’apparence ; dans les plateformes, les modèles de détection de contenus haineux ou terroristes se présentent comme appliquant des critères constants. L’*arcalité déclarée* insiste sur l’idée que ces dispositifs ne font que *mesurer* ou *mettre en forme* *des régularités objectives déjà là*.
+
+Enfin, le quatrième motif est celui de la *sécurité* et de la *confiance*. Les discours sur l’“*IA digne de confiance*” et les documents de régulation européenne convergent : *pour être acceptable, un système doit être robuste, fiable, “sûr”, respecter la vie privée, être transparent et rendre des comptes*. Dans le langage des plateformes, la “*sûreté*” est un *produit que l’on fournit aux utilisateurs* ; dans les textes de l’OCDE et de l’Union européenne, la “*confiance*” est une *condition de possibilité du déploiement de l’IA dans des secteurs sensibles*.
+
+Cette grammaire n’est pas simplement un vernis. Elle structure les termes dans lesquels les acteurs peuvent se justifier devant les tribunaux, les autorités de régulation, les opinions publiques. Elle *détermine ce qui peut être publiquement défendu* et ce qui, au contraire, doit rester dans les coulisses (sélection des variables, choix des proxies, calibrage des seuils). Du point de vue archicratique, elle constitue bien une *arcalité* : *une manière d’exposer – au moins en principe – les finalités et les valeurs censées commander l’usage* de Système F.
+
+### I.2.8. Une *arcalité réelle*, mais *extra-scénique*
+
+Reste à savoir dans quelle mesure cette *arcalité déclarée*, riche et apparemment sophistiquée, remplit les conditions minimales d’une *arcalité* proprement archicratique, c’est-à-dire d’une mise en scène effective des fondements. La réponse, à ce stade de l’audit, est ambivalente.
+
+D’un côté, il serait excessif de considérer que les dispositifs que nous avons examinés seraient dépourvus de toute justification explicite. La lutte contre la fraude sociale, la recherche de cohérence dans les peines, la volonté de mieux prendre en charge des patients vulnérables, l’ambition de limiter les discriminations à l’embauche, la nécessité de réguler les contenus illégaux ou dangereux sur les grandes plateformes, la référence aux droits fondamentaux et aux valeurs démocratiques dans les textes internationaux : tout cela constitue un *socle normatif substantiel*. L’*arcalité déclarée* n’est pas un pur écran de fumée ; elle exprime des préoccupations réelles, souvent largement partagées.
+
+D’un autre côté, cette *arcalité* reste le plus souvent *extra-scénique*. Elle s’exprime dans des préambules de lois, des communiqués, des chartes, des rapports, mais elle n’est guère travaillée dans des scènes où les notions centrales – fraude, risque acceptable, mérite, besoin de soin, dangerosité, contenu nuisible – seraient définies, discutées, révisées en présence de ceux qui en subissent les effets. La définition pratique de la fraude, dans les dispositifs de protection sociale, n’est pas débattue en tant que telle avec les allocataires ; la hiérarchie entre erreurs acceptables et erreurs intolérables dans la justice pénale n’est pas posée frontalement aux justiciables ; le choix de prendre les coûts comme proxy des besoins en santé n’est pas soumis à une délibération spécifique avec les patients et les soignants ; les critères de “talent” dans le recrutement ou de “contenu nuisible” sur les plateformes ne donnent que rarement lieu à des dispositifs de confrontation structurée.
+
+L’effet archicratique de cette situation est double. D’une part, les *valeurs affichées* – protection de l’État social, prévention de la récidive, justice dans l’accès aux soins, égalité des chances, sécurité des espaces numériques, respect des droits fondamentaux – fonctionnent comme des *slogans d’arrière-plan* : elles justifient en bloc l’entrée de Système F dans les chaînes décisionnelles, sans que soient explicitées les manières concrètes dont elles sont traduites en paramètres, en seuils, en arbitrages d’erreurs. D’autre part, cette *faiblesse scénique* ouvre un espace où les véritables fondements opératoires tendent à se déplacer vers d’autres couches du dispositif : fonctions de coût, choix de proxies, sélection de variables, architecture des jeux de données.
+
+Autrement dit, l’*arcalité déclarée* de Système F est à la fois réelle et incomplète : elle pose des finalités, mais elle ne prend pas à bras-le-corps la question de leur implémentation normative fine. Elle ouvre un horizon de légitimation, mais elle laisse largement hors scène les fondements effectifs à partir desquels le système se met à discriminer, prioriser ou classer.
+
+C’est cette dissociation que la section suivante se propose d’examiner. En passant à l’*arcalité implicite*, nous quitterons les formulations officielles pour aller voir où se logent, dans Système F, les axiomes silencieux : ceux qui définissent en pratique ce qui compte comme fraude, comme risque tolérable, comme mérite, comme besoin, comme contenu acceptable. C’est là que se noue l’*oblitération archicratique* caractéristique des dispositifs contemporains : non pas absence de fondement, mais fuite du fondement derrière l’optimisation.
+
+## I.3. *Arcalité implicite*
+
+Avec l’*arcalité déclarée*, nous avons observé ce que les acteurs disent de Système F : protection de l’État social, objectivation du risque pénal, ciblage des soins, rationalisation du recrutement, sécurité des espaces numériques, “IA responsable” et “digne de confiance”. L’*arcalité implicite* se loge ailleurs : dans les *fonctions de coût*, les *proxies choisis*, les *métriques d’évaluation*, la *composition des jeux de données*, les *seuils*, les *arbitrages sur les erreurs*. C’est là que se décide, au sens fort, ce qu’est un “bon” résultat pour le système, ce qu’on est prêt à sacrifier, qui l’on accepte de sur-surveiller, qui l’on accepte de mal desservir.
+
+Du point de vue archicratique, chaque choix de ce type relève d’un acte de fondation silencieux : il fixe une hiérarchie entre injustices acceptables, il distribue les soupçons et les protections, il stabilise une certaine vision de ce qui compte. L’important n’est pas d’opposer un “pôle technique” neutre à un “pôle politique” chargé ; c’est de *reconnaître que le paramétrage lui-même a une portée normative*, et qu’il constitue une *arcalité effective* qui, le plus souvent, ne comparaît jamais en tant que telle. C’est ce régime des fondements non mis en scène que nous appellerons *arcalité implicite* ou *arcalité fantôme*.
+
+### I.3.1. Arbitrages d’erreurs et profilage social
+
+Dans les dispositifs de détection de fraude aux prestations qui composent la brique “protection sociale” de Système F, l’objectif opérationnel est de distinguer des dossiers “à risque” des autres. Techniquement, cela se traduit par une *fonction de coût qui pondère plusieurs objectifs* : *maximiser la détection des fraudes avérées*, *limiter les faux positifs*, *contenir les coûts d’enquête*, *éviter de suspendre abusivement des prestations*. En apparence, il s’agit d’*optimiser une procédure de contrôle* ; en réalité, on décide comment répartir la charge de l’erreur entre l’État et les allocataires.
+
+L’affaire néerlandaise des allocations pour la garde d’enfants, relue par Amnesty International dans son rapport *Xenophobic Machines*, a montré à quel point ces arbitrages implicites pouvaient devenir violents. Des dizaines de milliers de familles, très majoritairement à faibles revenus et souvent issues de l’immigration, ont été accusées à tort de fraude et soumises à des recouvrements massifs sur la base de profils de risque établis par un système automatisé. Amnesty documente l’usage de variables comme la nationalité ou la double nationalité dans la construction des profils, ce qui produisait un ciblage disproportionné de certains groupes ethniques et migratoires.
+
+Du point de vue archicratique, plusieurs axiomes implicites se donnent ici à voir. D’abord, l’idée selon laquelle il serait acceptable de concentrer un volume élevé de faux positifs sur des populations déjà précaires, au nom de la défense du budget public, sans scène où ces personnes puissent contester la hiérarchie ainsi instituée entre la protection des fonds et la protection des droits. Ensuite, l’idée qu’une caractéristique comme la nationalité puisse servir de proxy de suspicion, alors même que le droit non discriminatoire des États européens proscrit précisément ce type d’usage. Le rapport *Xenophobic Machines* parle de discrimination “intégrée” dans la conception même du système, non seulement dans ses usages déviants.
+
+La décision du tribunal de La Haye dans l’affaire SyRI confirme le diagnostic à un autre niveau. SyRI était un dispositif de profilage de risque en matière de sécurité sociale, fondé sur le croisement massif de données issues de multiples administrations et sur la production de “*rapports de risque*” transmis aux services d’inspection. Le tribunal a jugé que la législation encadrant SyRI violait l’article 8 de la Convention européenne des droits de l’homme, en raison notamment d’un déficit de transparence, de l’ampleur du traitement et du ciblage de quartiers défavorisés.
+
+Ce qui est en cause, là encore, n’est pas seulement une erreur de calibrage, mais une *arcalité implicite* : il serait considéré comme *tolérable de soumettre certains territoires à un profilage intensif*, *de croiser leurs données à grande échelle, de déclencher des enquêtes intrusives sur la base de scores opaques, au nom d’un “juste équilibre” entre lutte contre la fraude et respect de la vie privée*. Or ce “*juste équilibre*” n’a pas été déterminé sur une scène où l’on aurait mis en débat les types d’erreurs acceptables, les populations exposées, la nature des données croisées. Il a été fixé dans la fonction de coût globale du système, puis naturalisé sous la forme d’une procédure “moderne” de contrôle.
+
+L’*arcalité implicite* de Système F, dans ce segment social, prend donc la forme d’une *hiérarchisation silencieuse* : mieux vaut tolérer un nombre important de faux positifs concentrés sur des familles vulnérables que d’accepter une fraude résiduelle ; mieux vaut considérer certains profils nationaux ou résidentiels comme intrinsèquement plus suspects que d’ouvrir un débat public sur les causes structurelles des erreurs, des omissions ou des malentendus administratifs.
+
+### I.3.2. Le *proxy* “*coûts*” comme axiome de valeur
+
+L’algorithme de gestion des risques étudié par Ziad Obermeyer et ses co-auteurs offre un exemple paradigmatique d’*arcalité implicite*. Le système, largement utilisé dans les systèmes de santé américains, sert à déterminer quels patients doivent bénéficier de programmes de “*care management*” intensif : ceux dont le score dépasse un certain seuil se voient offrir un suivi renforcé, des ressources supplémentaires et une coordination accrue.
+
+Les auteurs montrent que, pour un même score de risque donné par l’algorithme, les patients noirs sont en moyenne bien plus malades que les patients blancs : davantage de pathologies chroniques non contrôlées, plus de complications, etc. La raison n’est pas une “erreur” de calcul, mais le choix du proxy : l’algorithme prédit les coûts de santé futurs plutôt que la morbidité elle-même. Or, dans un système marqué par des inégalités d’accès aux soins, on dépense historiquement moins pour les patients noirs que pour les patients blancs à état de santé comparable. En prenant les coûts comme substitut des besoins, l’algorithme sous-estime donc systématiquement les besoins des patients noirs, ce qui conduit à les orienter beaucoup plus rarement vers les programmes intensifs.
+
+Du point de vue archicratique, le choix du proxy “coûts” constitue un acte d’*arcalité implicite* majeur : il institue, sans jamais le dire, l’idée que *la meilleure approximation des besoins de santé d’un individu est ce que le système a déjà dépensé pour lui*. Dans un univers égalitaire et sans contraintes budgétaires, ce raccourci pourrait éventuellement se discuter ; dans un univers où l’accès aux soins est profondément inégal, il revient à considérer que les vies pour lesquelles on a historiquement le moins dépensé sont objectivement moins “à risque” et moins prioritaires. L’axiome est extraordinairement chargé sur le plan moral et politique, mais il n’est pas présenté comme un choix de justice : il est codé comme un paramètre d’optimisation raisonnable.
+
+Obermeyer et al. montrent qu’en remplaçant le proxy “coûts” par un proxy plus proche des besoins cliniques (par exemple le nombre de maladies chroniques non contrôlées), on pourrait presque tripler la part des patients noirs orientés vers les programmes intensifs.
+
+Autrement dit, un seul choix de variable suffit à faire basculer la répartition d’un dispositif de soin à grande échelle. Or ce choix n’a donné lieu ni à une controverse publique, ni à une délibération institutionnelle, ni à un dispositif d’*archicration* : il a été décidé en amont, au croisement de considérations pratiques (disponibilité des données, facilité de mesure) et de rationalités gestionnaires (coûts comme indicateur privilégié), puis diffusé comme allant de soi.
+
+Ce cas illustre avec une précision chirurgicale ce que nous nommons *arcalité fantôme* : l’*existence de fondements normatifs réels* – ici, une conception du besoin de santé traduite en coût – *qui pilotent une large distribution de ressources, sans jamais être convoqués sur une scène où ils devraient se justifier devant ceux qu’ils affectent*.
+
+### I.3.3. Hiérarchies des erreurs et justice des risques
+
+L’outil d’évaluation de risque pénal COMPAS, lorsqu’on le regarde à travers les débats suscités par l’enquête de ProPublica et les réponses de ses concepteurs, met en lumière un autre aspect de l’*arcalité implicite* : la gestion différenciée des faux positifs et des faux négatifs selon les groupes. ProPublica a montré en 2016 que, dans le comté de Broward, les accusés noirs étaient beaucoup plus souvent classés à tort comme “à haut risque” que les accusés blancs (faux positifs), tandis que les accusés blancs étaient plus souvent classés à tort comme “faible risque” alors qu’ils récidivaient (faux négatifs).
+
+Des chercheurs et les auteurs de COMPAS ont contesté la méthodologie de ProPublica, en soulignant qu’il est mathématiquement impossible de satisfaire simultanément plusieurs notions de “*justice algorithmique*” (par exemple égalité des taux de faux positifs et égalité de calibration) lorsque les taux de récidive diffèrent entre groupes.
+
+Mais, du point de vue archicratique, cette impossibilité mathématique ne dissout pas le problème : elle le reformule avec plus d’acuité. Si toutes les configurations sont impossibles simultanément, il faut choisir lesquelles on privilégie : *faut-il minimiser les faux négatifs* (ne pas laisser sortir un individu qui récidivera) *au prix d’un grand nombre de faux positifs* (maintenir en détention des personnes qui n’auraient pas récidivé) ? *Ou l’inverse ? Est-il acceptable que ces arbitrages se distribuent différemment selon les groupes racisés ?*
+
+En droit pénal, cette question n’est pas nouvelle : elle recoupe des débats de longue durée sur la *présomption d’innocence*, sur la maxime selon laquelle “*mieux vaut laisser dix coupables en liberté que condamner un innocent*”, sur la hiérarchie entre sécurité collective et protection contre l’erreur judiciaire. Ce que le recours à un outil actuariel comme COMPAS transforme, c’est le lieu où cette hiérarchie est fixée : au lieu d’être l’objet d’une discussion explicite – au Parlement, dans la doctrine, dans la jurisprudence – elle est réglée par la manière dont on écrit la fonction de coût, choisit les métriques d’évaluation, fixe les seuils de risque et paramètre la calibration. Les débats techniques sur les définitions de l’équité deviennent le substitut de débats normatifs sur ce que l’on juge plus grave : enfermer injustement ou libérer à tort.
+
+Là encore, l’*arcalité implicite* n’est pas l’absence de normativité, mais sa *relégation dans des micro-décisions techniques qui n’apparaissent jamais comme telles aux justiciables*. Un prévenu auquel on annonce un score de risque “élevé” ne voit pas la structure normative qui a présidé au calibrage des erreurs ; un juge qui consulte ce score ne voit pas davantage la hiérarchie implicite entre types d’injustice. La scène archicratique – celle où l’on discuterait ouvertement du partage admissible des risques d’erreurs – se trouve remplacée par une scène actuarielle limitée à quelques spécialistes.
+
+### I.3.4. Apprendre des hiérarchies sociales existantes
+
+Le système de tri de CV développé par Amazon, puis abandonné avant son déploiement, met au jour une autre dimension de l’*arcalité implicite* : *l’importation non critique de hiérarchies sociales existantes dans la définition de ce qui compte comme “talent”*. L’enquête de Jeffrey Dastin pour Reuters a montré que l’outil, entraîné sur une dizaine d’années d’historiques de recrutement dans des métiers techniques majoritairement masculins, avait “appris” à désavantager les CV féminins : il pénalisait les dossiers contenant le mot “women’s” et rétrogradait certains établissements fréquentés par des femmes.
+
+L’*arcalité implicite* ne réside pas seulement dans ces effets visibles, mais dans la décision initiale de prendre le passé des recrutements comme référence pour l’avenir. En faisant de la capacité à prédire “qui serait embauché” à partir des données historiques la fonction de coût principale, Amazon a installé comme norme ce que ses pratiques antérieures, déjà marquées par un déséquilibre de genre, considéraient comme un “*bon candidat*”. L’algorithme n’invente pas le biais ; il le systématise et le cristallise.
+
+Du point de vue archicratique, cette configuration revient à traiter les décisions passées – elles-mêmes situées dans des rapports de pouvoir, des routines, des préjugés – comme un “réel” à imiter. La question “qu’est-ce qu’un talent ?” n’est pas abordée comme une question ouverte, susceptible de révision, mais comme un pattern à extraire d’un corpus de CV, de trajectoires et de décisions. L’*arcalité implicite* associe trois éléments : *l’idée que la performance passée est la meilleure mesure du mérite futur* ; *la naturalisation de hiérarchies de genre, de diplôme, de style de CV* ; *la marginalisation de toute scène où ces hiérarchies pourraient être discutées par les personnes qu’elles affectent.*
+
+L’épisode se conclut par l’abandon du projet, une fois les biais mis au jour par les ingénieurs. Mais il illustre bien la logique de Système F : tant que l’algorithme fonctionne dans les coulisses, la question de la normativité de ses critères reste invisible. Ce n’est qu’au moment où l’outil “déraille” visiblement – ici, en supprimant presque mécaniquement les femmes du pool de candidats – que les questions archicratiques surgissent, sur un mode défensif.
+
+### I.3.5. Seuils de tolérance et architectures de la visibilité
+
+Dans le cas des plateformes numériques, l’*arcalité implicite* se manifeste dans un autre registre : celui des seuils de tolérance au contenu et des architectures de visibilité. Les textes de mise en œuvre du Digital Services Act, ainsi que les guides de transparence publiés par la Commission européenne et les analyses doctrinales récentes, montrent que les grandes plateformes sont désormais explicitement tenues de rendre compte de leurs décisions de modération, des outils automatisés qu’elles emploient et des risques systémiques qu’elles identifient.
+
+Les rapports de transparence de Meta, combinés aux travaux de l’*Oversight Board* et aux analyses critiques sur l’évolution des “*Community Standards*”, illustrent concrètement l’ampleur de la délégation faite à des systèmes d’IA pour détecter, classer et retirer des contenus. Meta reconnaît que des systèmes automatisés identifient et agissent sur une grande partie des contenus avant même qu’ils soient signalés, et l’*Oversight Board* rappelle que des millions d’utilisateurs font appel de décisions de retrait initialement prises par ces systèmes, souvent en expliquant que leur contenu relevait de l’information, de la satire ou du témoignage.
+
+Dans ce contexte, l’*arcalité implicite* ne se situe pas seulement dans la définition formelle des “discours haineux”, des “contenus terroristes” ou de la “désinformation”, ni même dans la distinction entre illégalité et simple non-conformité aux standards de communauté. Elle se loge dans la manière dont les systèmes automatisés et leurs opérateurs paramètrent les seuils : *à partir de quel degré d’ambiguïté un contenu est-il retiré préventivement ? jusqu’où privilégie-t-on la réduction du risque d’exposition au détriment de la préservation de la parole minoritaire ? comment traite-t-on les contenus dans des langues peu dotées, pour lesquelles les modèles sont moins précis ?* Les études récentes sur l’impact de ces choix dans le Sud global ou pour certaines communautés minorées montrent que les erreurs de classification et les suppressions abusives se concentrent souvent là où les ressources linguistiques et les contextes locaux sont les moins bien pris en compte.
+
+Le DSA impose aux très grandes plateformes la création de bases de données de décisions de modération et ouvre des accès à la recherche, ce qui, en principe, devrait permettre de rendre visibles ces arbitrages. Mais, tant que le débat reste centré sur la conformité globale aux obligations (rapports de transparence, existence de mécanismes de recours, descriptions qualitatives des systèmes automatisés), la question archicratique de fond – à savoir la hiérarchie implicite entre les types d’erreurs acceptables, les types de contenus sur-modérés ou sous-modérés, les publics plus ou moins protégés – demeure largement encapsulée dans les paramètres des modèles et dans les règles internes.
+
+### I.3.6. L’*arcalité fantôme* comme régime des fondements non mis en scène
+
+Les fragments que nous venons de parcourir permettent de préciser, sans métaphore, ce que nous nommons *arcalité implicite* ou *arcalité fantôme*.
+
+Nous appellerons *arcalité fantôme* l’*opérateur dont les fondements normatifs du dispositif ne disparaissent pas, mais se trouvent encapsulés dans des options de paramétrage* (fonctions de coût, proxies, métriques, seuils) *qui opèrent à l’intérieur de la cratialité, sans jamais être exposées comme telles sur une scène d’épreuve*.
+
+Dans la protection sociale, la *manière de calibrer les modèles de détection de fraude* – *choix des variables, des seuils, des quartiers ciblés, rapport accepté entre faux positifs et faux négatifs* – encode une *hiérarchie entre la lutte contre les abus et la protection des allocataires de bonne foi*, ainsi qu’une *distribution des soupçons selon des lignes de classe et d’origine*. Cette *hiérarchie* n’est en aucune manière discutée publiquement avec les personnes concernées ; elle est incorporée dans la fonction de coût globale du dispositif.
+
+Dans la santé, le *choix d’un proxy* comme les *coûts de santé* pour représenter *les besoins encode une conception implicite de la valeur des vies en fonction des dépenses déjà engagées*, *dans un contexte où ces dépenses sont ethniquement inégales*. Ce choix transforme une inégalité historique d’accès aux soins en différence “objective” de risque, puis en inégalité d’accès à des programmes intensifs supplémentaires.
+
+Dans la justice pénale, la définition d’un profil de risque et la manière de pondérer les erreurs entre différents groupes encode une hiérarchie des injustices supportables : mieux vaut enfermer trop de personnes qui ne récidiveront pas, ou libérer trop de personnes qui récidiveront, et pour quels groupes précisément ? La littérature sur COMPAS montre que, quelles que soient les positions prises dans le débat, un choix normatif irréductible doit être fait, mais qu’il est pris en pratique dans l’écriture de la fonction de coût et des métriques, non dans une scène de délibération pénale explicite.
+
+Dans le recrutement, la décision de prendre les pratiques passées comme guide principal encode une conception du mérite qui sanctuarise des hiérarchies sociales et de genre. L’outil d’Amazon a rendu visible ce mécanisme en produisant des effets suffisamment grossiers pour être politiquement indéfendables ; mais le mécanisme – apprentissage à partir d’historiques de décisions biaisées – demeure au cœur de nombreux systèmes d’“analyse de talents”.
+
+Sur les plateformes, enfin, les seuils de détection, la granularité des catégories de contenu, les modèles de risque assignés aux différentes langues et régions encodent une hiérarchie implicite entre la protection contre certains types de discours et la tolérance à d’autres, entre la visibilité accordée à certains groupes et la sur-modération d’autres. Les obligations du DSA ouvrent des voies de visibilité, mais ne constituent pas en elles-mêmes une scène où ces hiérarchies seraient mises en débat avec les publics concernés.
+
+Dans tous ces cas, on ne peut pas dire qu’il n’y ait pas de fondements : au contraire, ils sont nombreux, puissants, efficaces. Ils prennent la forme de fonctions de coût, de choix de proxies, de distributions de données, de métriques de performance, de seuils de décision. Simplement, ces fondements ne sont pas exposés comme tels ; ils n’apparaissent ni dans les chartes, ni dans les communiqués, ni dans les rapports de principe. Ils agissent dans la *cratialité* du système – dans son code, ses pipelines, ses paramétrages –, mais ils n’accèdent jamais au statut de fondements discutables.
+
+C’est en ce sens que nous parlons d’*arcalité fantôme* : non pas une absence d’*arcalité*, mais une *arcalité exilée hors de la scène*. La modernité algorithmique ne se caractérise pas seulement par une intensification de la capacité à calculer, à corréler, à prédire ; elle se caractérise par une dés-scénarisation des fondements, c’est-à-dire par le transfert des décisions normatives les plus décisives dans des couches techniques où elles ne sont plus identifiées comme telles.
+
+Au regard de l’*archicratie*, cela signifie que la promesse d’une “*IA responsable*” ou “*digne de confiance*” reste structurellement bancale tant que l’on ne ramène pas ces choix à la scène, c’est-à-dire tant qu’on ne crée pas de dispositifs archicratifs pour les rendre visibles, contestables, révisables. L’épreuve de détectabilité, dans sa dimension d’*arcalité implicite*, permet précisément de diagnostiquer ce défaut : là où les axiomes les plus lourds sont dissimulés derrière le langage de l’optimisation, l’*archicratie* n’est pas seulement déficitaire ; elle est *empêchée*. C’est sur cette base que pourra être menée, dans les sections ultérieures, l’analyse des *cratialités* de Système F et des *archicrations* – rares, fragmentaires, parfois fantomatiques – qui tentent déjà, dans certains secteurs, de réintroduire de la scène dans un ordre régulé par les modèles.
+
+## I.4. Cratialité du système IA
+
+Si l’*arcalité* répond à la question “*selon quoi ou qui ?*”, la *cratialité* répond à la question “*par quoi et comment ?*”. Dans Système F, ce “*par quoi et comment*” n’est pas un point, mais une chaîne : *collecte et circulation de données*, *construction d’attributs*, *entraînement du modèle*, *réglages successifs*, *mise en production*, *intégration dans des logiciels très ordinaires* et enfin *procédures d’usage*. Ce que l’*archicratie* appelle *cratialité*, c’est précisément cette chaîne, dès lors qu’elle ne se contente plus d’outiller une activité, mais *distribue de manière répétée des accès, des soupçons, des protections, des sanctions*.
+
+Dans un centre de données où tourne le modèle de fondation, dans le service informatique d’un ministère, dans une direction de l’innovation d’un hôpital, cette chaîne est documentée en détail : *diagrammes d’architecture*, *pipelines de données*, *journaux de traitement*. Mais pour l’agent de guichet qui consulte une file de dossiers triés, pour la médecin confrontée à une liste de patients “priorisés”, pour le juge qui reçoit un rapport chiffré, pour le recruteur ou l’équipe de modération qui voit un indicateur rouge, *cette cratialité est entièrement compacte* : un score, une couleur, un message, parfois une mention vague à un “outil d’analyse avancée”. L’épreuve de détectabilité conduit alors à remonter, autant que possible, cette chaîne invisible, en s’appuyant sur ce que les travaux existants documentent déjà.
+
+### I.4.1. Des archives régulatrices recyclées en carburant statistique
+
+La première strate de la *cratialité* de Système F, ce sont les *données*. Non pas des “matières premières” neutres, mais des *archives de décisions passées*.
+
+Ainsi, avec SyRI, la littérature juridique montre que le système a été conçu comme un *instrument de “couplage” massif entre fichiers administratifs* : *données fiscales, registres de sécurité sociale, informations sur l’emploi, le logement ou la dette, issues d’un ensemble d’organismes publics qui, jusque-là, n’étaient pas nécessairement interconnectés*. L’objet n’était pas simplement de consulter l’un ou l’autre fichier, mais de constituer un “*dépôt de risque*” où les trajectoires de vie des habitants de certains quartiers étaient recomposées en *profils susceptibles de déclencher un contrôle*. Les dossiers saisis par les ONG et la décision de La Haye insistent sur ce point : c’est bien cette concentration, ce couplage étendu et asymétrique des données qui a conduit le tribunal à juger que le dispositif ne respectait pas la vie privée.
+
+Dans le scandale des allocations pour la garde d’enfants, l’algorithme incriminé n’a pas été conçu *ex nihilo* : il reposait sur les dossiers fiscaux et sociaux accumulés par l’administration, sur les anciens contrôles, sur les historiques de remboursement, sur des métadonnées apparemment triviales (nationalité, double nationalité, type de crèche). Les enquêtes parlementaires et les analyses doctrinales montrent que la machine à profiler a, de ce fait, hérité d’une longue histoire de suspicion ciblée, pour la concentrer sur des familles à bas revenus, souvent issues de l’immigration.
+
+Dans ce dispositif précis de santé étudié par Obermeyer et ses co-auteurs, la base d’apprentissage est constituée de données de facturation : coûts passés, diagnostics, passages à l’hôpital, prescriptions, etc. L’algorithme ne “voit” pas les patients, il voit les dépenses que le système de santé a consenties pour eux. Quand le dispositif est ensuite utilisé pour sélectionner les patients éligibles à des programmes de soins intensifs, la *cratialité* de Système F prolonge ainsi une économie historique des soins : ceux dont on a peu dépensé pour eux sont moins visibles pour l’algorithme, même s’ils sont plus malades.
+
+Du côté pénal, les études sur COMPAS rappellent que les scores sont calculés à partir d’une combinaison d’éléments du casier judiciaire et des réponses à un questionnaire de 137 items, portant sur la trajectoire de vie, l’environnement social, l’emploi, la scolarité, le logement. Là encore, Système F ne “crée” pas les variables ; il hérite de la manière dont la police a arrêté, dont les tribunaux ont condamné, dont les services sociaux ont consigné des éléments de biographie, dans un contexte où ces histoires sont déjà fortement structurées par la race, la classe, le territoire.
+
+Dans le recrutement, l’outil d’Amazon décortiqué par Reuters a été entraîné sur une décennie de décisions de recrutement dans des métiers techniques, essentiellement occupés par des hommes. Les CV, lettres, diplômes et trajectoires de carrière qui composent cette base reflètent un champ professionnel déjà fortement genré ; c’est cette archive que le modèle prend pour horizon de référence.
+
+Enfin, sur les plateformes, les systèmes de modération et de recommandation ingèrent des flux continus de contenus, mais aussi des archives de signalements, de suppressions, de “likes”, de signalements de discours haineux ou terroristes. Les rapports de transparence imposés par le Digital Services Act et les documents publiés par Meta insistent sur le *rôle des systèmes automatisés dans la détection initiale des contenus, en se nourrissant précisément de cette mémoire d’interventions passées*.
+
+Dans tous ces cas, la *cratialité* de Système F commence donc par un *geste de reprise* : les *bases de données sur lesquelles repose l’entraînement et le fonctionnement du système sont déjà des condensés d’arbitrages régulateurs, de contrôles et de sélections, parfois de longues routines discriminatoires*. La chaîne cratiale ne se contente pas d’“absorber” la réalité sociale ; elle absorbe des archives de pouvoir.
+
+### I.4.2. Pipelines : transformer des vies en vecteurs
+
+La deuxième strate de la *cratialité* est moins visible encore : ce sont les chaînes de transformation qui convertissent ces données hétérogènes en représentations exploitables par le modèle. Les manuels de science des données et les guides sur l’usage de l’IA dans les administrations décrivent des étapes désormais classiques : nettoyage, normalisation, sélection ou construction de variables, agrégation, puis vectorisation.
+
+Dans le cas d’un dispositif de détection de fraude sociale, une succession de décisions apparemment techniques se met en place : faut-il coder la “nationalité” comme une variable binaire, ou comme une liste fine de pays ? Faut-il comptabiliser le nombre de déménagements sur cinq ans, ou sur dix ? Comment transformer des remarques écrites par des agents en indicateurs numériques ? Le rapport de la Commission d’enquête parlementaire néerlandaise sur le scandale des allocations montre que, dans la pratique, ces choix ont conduit à donner un poids particulier à certains marqueurs (double nationalité, erreurs mineures dans les formulaires), qui faisaient passer des familles entières du côté du “risque élevé”.
+
+Pour l’*algorithme de santé* analysé par Obermeyer et al., cette chaîne consiste à *agréger des années de dépenses en santé, de diagnostics et d’hospitalisations en un score unidimensionnel de “risque”, censé représenter les “besoins futurs” du patient*. Le fait d’opter pour les coûts plutôt que pour des indicateurs cliniques, puis de compresser ces informations en un score continu, est un *geste cratial* autant que statistique : il *rend possible l’intégration du système dans les tableaux de bord des gestionnaires*, et *autorise un tri automatique des patients à échelle industrielle*.
+
+Dans COMPAS, transformer 137 réponses et un casier judiciaire en un score de 1 à 10 suppose plusieurs *couches de prétraitement* : *recodage des réponses en catégories numériques*, *pondération de facteurs*, *combinaison en indices partiels*, puis en *score global*. Les études qui ont reconstruit partiellement la méthode à partir de données ouvertes montrent à quel point *cette chaîne incorpore des éléments contextuels* (code postal, stabilité résidentielle, entourage, historique de consommation de drogues) qui, une fois vectorisés, deviennent des *attributs apparemment neutres, mais fortement corrélés à des trajectoires socio-raciales différenciées*.
+
+L’*outil de tri de CV* d’Amazon, pour sa part, devait convertir des documents richement formatés en vecteurs de caractéristiques : *universités*, *mots-clés*, *expériences*, *engagements*, parfois même *tournures de phrases*. C’est dans cette phase que le système a “*appris*” à pénaliser des expressions comme “*women’s chess club*” ou des références à des universités connotées féminines, parce que ces traits coïncidaient, dans les données d’entraînement, avec des candidatures historiquement moins retenues.
+
+Enfin, les *pipelines de modération* et de *recommandation* transforment chaque message, image ou vidéo en une série de marqueurs : *langue, thème, tonalité, degré présumé de violence ou de haine, signaux de “fiabilité” de la source, etc.* Les documents de Meta et les analyses indépendantes montrent que ces *pipelines* combinent *détection automatisée*, *listes de mots*, *signaux issus de comportements passés*, avant de produire des étiquettes (“contenu à risque”, “contenu limite”) qui orientent la visibilité des publications bien en amont de toute décision humaine.
+
+Ce que la lecture archicratique met ici en avant, ce n’est pas seulement la technicité de ces *pipelines*, mais leur *effet de réduction* : *des vies, des trajectoires, des plaintes, des prises de parole sont ramenées à des vecteurs, des classes, des scores*. Cette réduction est nécessaire pour que Système F fonctionne ; elle n’est pas en soi illégitime. Mais elle constitue l’un des lieux où la *cratialité* fait passer un seuil : *ce qui devient calculable devient gouvernable*.
+
+### I.4.3. Modèles, paramètres, seuils : la mécanique fine des décisions
+
+La troisième strate de la *cratialité* de Système F est celle des *modèles* et de leurs *réglages*. Les manuels de *machine learning* parlent *d’architectures, de fonctions de perte, d’optimisation, d’hyperparamètres*. Pour l’*archicratie*, ces notions deviennent intéressantes lorsqu’elles cristallisent des *choix régulateurs*.
+
+Ainsi, *santé* étudié par Obermeyer et al., le modèle est paramétré pour *minimiser l’erreur globale de prédiction des coûts futurs*. Ce choix – minimiser une somme d’erreurs plutôt que de garantir un niveau de traitement minimal pour certains groupes – a pour effet d’optimiser la performance moyenne au prix d’une sous-protection systématique des patients noirs. Les auteurs montrent qu’en modifiant la fonction de coût pour intégrer explicitement des mesures de morbidité, le classement des patients noirs change radicalement.
+
+Dans COMPAS, les paramètres du modèle et la manière dont les scores sont répartis en catégories (“faible”, “moyen”, “élevé”) déterminent la proportion de personnes qui basculent dans chaque classe de risque. Les études empiriques indiquent que, pour un même score, la probabilité de récidive est similaire entre accusés noirs et blancs, mais que la distribution des erreurs (faux positifs, faux négatifs) diffère fortement selon les groupes. L’architecture et les réglages du modèle correspondent donc à un compromis implicite : il est jugé acceptable de produire davantage de faux positifs pour certains groupes, afin de maintenir une calibration globale satisfaisante.
+
+Les *systèmes de scoring* de fraude sociale fonctionnent de la même manière : la décision de fixer un seuil de déclenchement de contrôle à tel niveau plutôt qu’à tel autre se traduit immédiatement en nombre de dossiers réexaminés, en proportion de familles frappées par des procédures, en intensité de la surveillance sur certains quartiers. Les travaux juridiques sur SyRI insistent sur le fait que ce seuil, et les indicateurs qui y conduisent, n’étaient pas seulement inconnus du public, mais inaccessibles même aux personnes contrôlées.
+
+Dans le cas d’Amazon, l’architecture exacte du modèle n’a pas été publiée, mais les sources indiquent qu’il s’agissait d’un système d’apprentissage supervisé qui attribuait une note d’une à cinq étoiles aux CV, en imitant les décisions de recrutement passées. La simple existence d’une échelle discrète de 1 à 5, avec un tri automatique des dossiers en fonction de cette note, traduit un choix cratial : il n’y a plus de lecture directe de chaque CV, mais un filtrage basé sur un signal synthétique, qui décide de ce qui est vu ou non par les recruteurs.
+
+Dans tous ces cas, les modèles, les paramètres et les seuils ne sont pas seulement des composantes techniques ; ils sont les points précis où la chaîne cratiale se décide : *combien de personnes seront contrôlées, qui sera inclus dans un programme de soins, qui portera le stigmate d’un “haut risque”, qui sera vu par un recruteur ou par le public d’une plateforme*. La *cratialité* de Système F, c’est cette capacité à faire varier, par ajustement de quelques coefficients, la forme concrète de l’accès aux droits, aux ressources, à la visibilité.
+
+### I.4.4. Interfaces : là où la *cratialité IA* rencontre la *cratialité humaine*
+
+Pour les agents, juges, médecins, recruteurs, modérateurs, la *cratialité* n’apparaît cependant qu’à l’autre bout de la chaîne : dans les *interfaces*. C’est là que Système F devient visible – sous la forme d’une colonne de scores, d’un code couleur, d’un message d’alerte, d’une suggestion “recommandée par le système”.
+
+Les études sur les systèmes d’aide à la décision clinique montrent que la manière dont une recommandation est affichée (alerte intrusive, message discret, couleur, possibilité de justification) influence fortement la propension des praticiens à la suivre ou à la contourner. Les travaux sur les biais d’automation confirment que, lorsque l’interface présente une proposition algorithmique avec un fort statut d’autorité (icône de validation, texte en vert, mention “recommandé”), les opérateurs ont tendance à lui accorder plus de crédit qu’à leur propre jugement, surtout dans des contextes de charge de travail élevée.
+
+Transposé à Système F, cela signifie qu’un agent de caisse sociale, confronté à une liste de dossiers triés par un score rouge–orange–vert, sera incité à traiter en priorité les dossiers rouges, même si rien ne l’oblige formellement à suivre l’ordre proposé. Une médecin, devant une liste de patients ordonnés par un indice de “priorité” accompagné d’un avertissement lorsqu’elle s’en écarte, devra assumer de “désobéir” au système pour reclasser un patient. Un juge, lisant un rapport de risque pénal avec un score mis en avant et une série de formulations standardisées, sait que toute divergence devra être explicitée dans son jugement.
+
+Les interfaces de plateformes, elles, ne montrent souvent rien du tout : l’utilisateur voit que sa publication “marche moins bien”, ou bien reçoit un message standardisé lui indiquant que son contenu a “enfreint les standards”, sans que la contribution exact de Système F soit explicitée. Les rapports de transparence exigés par le DSA commencent à donner des indicateurs agrégés sur la proportion de décisions automatisées, mais ils ne modifient pas cette expérience élémentaire : pour l’usager, la *cratialité* se résume à un refus, une baisse de portée, un retrait.
+
+Du point de vue archicratique, ces interfaces sont des lieux décisifs : elles articulent la *cratialité IA* et la *cratialité humaine.* Selon la manière dont elles sont conçues – plus ou moins explicites, plus ou moins contraignantes, plus ou moins configurables – elles peuvent soit renforcer l’autorité de Système F au point d’en faire un quasi-oracle, soit ménager des marges de requalification, de contestation, de suspension. La matérialité du bouton, de la couleur, de l’alerte est ici pleinement politique.
+
+### I.4.5. Procédures d’intégration : scripts d’usage et effets disciplinaires
+
+Enfin, la *cratialité* de Système F se fixe dans les règles internes qui déterminent sa place dans les procédures de décision. Les études de cas sur l’IA dans les administrations et le droit de l’UE sur les décisions automatisées insistent sur ce point : la différence entre un système de “recommandation” et un système de “décision automatisée” tient souvent moins à la technique qu’aux scripts organisationnels qui encadrent son usage.
+
+Dans un service de protection sociale, il peut être écrit que “les dossiers marqués à haut risque doivent être examinés en priorité” ; dans un tribunal, que “le score de risque ne peut être le seul fondement d’une décision, mais que toute divergence substantielle doit être motivée”. Dans un hôpital, qu’“un patient proposé par l’algorithme pour un programme de soins intensifs ne peut être exclu qu’après justification”; dans un service de recrutement, que “seuls les CV classés au-dessus d’un certain seuil seront examinés humainement”.
+
+Chacune de ces règles transforme un score en quasi-obligation : l’agent, la médecin, le juge, le recruteur ne se contentent plus de consulter Système F ; ils doivent se positionner par rapport à lui, éventuellement s’en justifier. C’est là que se loge, souvent, l’“*humain dans la boucle*” invoqué par les chartes d’IA responsable : un humain reste dans la boucle, mais placé en position d’avoir à expliquer pourquoi il ne suit pas la recommandation, plutôt que de décider de manière primaire.
+
+Les travaux sur SyRI et sur le scandale des allocations montrent en outre que ces scripts ne sont pas toujours explicités, ni même stabilisés : certains agents témoignent d’une pression implicite à suivre les signaux produits par le système, sous peine d’être jugés “laxistes” ou “inefficaces”. Dans le cas de COMPAS, la décision Loomis autorise l’usage de l’outil comme aide à la décision, mais sans offrir de critères clairs sur la manière dont les juges devraient articuler le score avec leur appréciation propre : la *cratialité* *se faufile ainsi entre prescription et simple “support”, en laissant la responsabilité dernière porter par les individus*.
+
+Du point de vue de l’*archicratie*, cette couche procédurale est cruciale parce qu’elle fixe, en pratique, ce que “vaut” Système F : s’il doit être suivi par défaut, s’il peut être contredit, s’il déclenche automatiquement des contrôles ou des sanctions, s’il ouvre ou non un droit à un examen contradictoire. Dans de nombreuses configurations actuelles, cette valeur est déterminée par des circulaires internes, des guides utilisateurs, des formations *ad hoc*, rarement débattus sur une scène publique.
+
+### I.4.6. Une *cratialité hypertopique*
+
+*Reprise des archives régulatrices, pipelines de transformation, modèles et paramètres, interfaces, scripts d’usage* : si l’on assemble ces strates, la *cratialité* de Système F apparaît comme une *chaîne dense, continue, extraordinairement efficace*. Elle fait circuler des signaux depuis les bases de données jusqu’aux décisions prises au guichet, au tribunal, à l’hôpital, dans l’entreprise, sur la plateforme. Elle est fortement topologisée – située dans des centres de données, des services informatiques, des consoles administratives –, mais elle ne dispose pas, dans la plupart des cas, de lieux où elle se montre comme telle.
+
+Pour les personnes affectées – bénéficiaires, patients, justiciables, candidat·es, usagers – la *cratialité* de Système F se présente avant tout comme une force “*hypertopique*” : un *vecteur d’effets sans visibilité de sa propre structure*. On peut ressentir ses conséquences (un contrôle inattendu, une radiation, un refus de prestation, une incarcération prolongée, une non-sélection, un contenu invisibilisé), sans jamais pouvoir désigner précisément le “*par quoi et comment*” qui a conduit à la situation.
+
+L’*enjeu de l’épreuve de détectabilité*, appliquée à la *cratialité*, est dès lors double. D’une part, *rendre descriptible cette chaîne, en montrant qu’elle n’est ni magique ni diffuse, mais composée de décisions localisées, techniquement et institutionnellement situées*. D’autre part, *ouvrir la possibilité d’un déplacement : faire exister des scènes où cette cratialité peut être exposée, discutée, reconfigurée, et ne plus opérer de manière invisible*.
+
+C’est à cette condition seulement que la puissance calculatoire de Système F peut être insérée dans un ordre archicratique — c’est-à-dire dans un ordre où la manière dont le pouvoir prend forme dans les dispositifs reste, elle aussi, amenée à l’épreuve.
+
+## I.5. Archicration existante mais lacunaire
+
+Après l’*arcalité déclarée et implicite*, après la *cratialité* de Système F, reste à interroger ce qui tient lieu, aujourd’hui, d’*archicration* : des *scènes d’épreuve où l’on pourrait amener la régulation algorithmique en visibilité, la contester, la transformer*. Dans la grammaire de la thèse, une archicration n’est pas un simple “dispositif de contrôle” : c’est un *lieu institué où les fondements (arcalité) et les instruments (cratialité) peuvent être mis en discussion par des acteurs concernés, dans des formes réglées, avec des effets possibles sur l’architecture du système*.
+
+À première vue, l’écosystème de Système F semble en être riche : *comités d’éthique de l’IA*, *conseils de gouvernance des données*, *audits de biais*, *autorités de protection des données*, *agences sectorielles*, *juges*, *mécanismes de recours*, désormais complétés par les *obligations de transparence et de plainte du Digital Services Act*, par des lois sectorielles comme le *Local Law 144* de New York sur les outils automatisés de recrutement, ou par des dispositifs singuliers comme le *Meta Oversight Board*.
+
+Mais, dès qu’on reformule les questions dans les termes archicratiques — *qui peut voir quoi ? qui peut contester quoi ? avec quels effets sur le système lui-même ?* — le paysage se transforme. Beaucoup de ces dispositifs produisent des avis, des rapports, des sanctions ponctuelles, des formulaires de recours ; très peu organisent une véritable comparution de Système F devant ceux qu’il affecte.
+
+### I.5.1. Cartographie rapide des prétendants à la scène
+
+On peut, pour commencer, distinguer quatre grandes familles de dispositifs qui, chacune à leur manière, prétendent jouer un rôle d’instance d’épreuve pour l’IA :
+
+1.  *Comités, chartes, conseils d’experts*
+
+    Comités internes d’éthique de l’IA dans les grandes entreprises technologiques, commissions *ad hoc* dans les administrations, groupes d’experts de haut niveau comme celui qui a élaboré les Lignes directrices pour une IA digne de confiance au niveau européen. Ils produisent des principes, des recommandations, des “bonnes pratiques”.
+
+2.  *Audits et évaluations techniques*
+
+    Audits de biais sur les outils de recrutement imposés par le Local Law 144 à New York (obligation de réaliser un audit annuel, de publier un résumé, d’informer les candidats).
+
+    Évaluations d’impact sur les droits fondamentaux ou sur les risques, demandées par certains régulateurs et expérimentées dans le cadre de l’AI Act européen et de rapports comme *Algorithmic Rule* ou le *Handbook: AI and Public Administration*.
+
+3.  *Autorités de régulation et juridictions*
+
+    Autorités de protection des données, conseils pour l’égalité et organismes antidiscrimination, autorités sectorielles, institutions européennes (Commission, FRA, etc.) qui ont enquêté sur les systèmes de profilage dans le social, la police ou la fiscalité.
+
+    Cours nationales et européennes, comme le tribunal de La Haye dans SyRI, ou la chaîne de procédures qui a suivi le scandale des allocations familiales aux Pays-Bas.
+
+4.  *Voies de recours et mécanismes de réclamation*
+
+    Droit au recours des allocataires, des justiciables, des patients, des candidats à l’emploi, des utilisateurs de plateformes.
+
+    Mécanismes internes de plainte et de contestation imposés par le Digital Services Act (obligation pour les grandes plateformes de prévoir des procédures de traitement des signalements et des recours, de publier des rapports annuels sur la modération, en précisant notamment la part de décisions automatisées et les taux d’erreurs).
+
+    Dispositifs spécifiques comme le *Meta Oversight Board*, qui réexamine un nombre limité de décisions de modération emblématiques et publie des décisions motivées et des recommandations.
+
+Dans ce maillage, les éléments d’une *archicration authentique* sont présents : *lieux de délibération, expertises, procédures contradictoires, sanctions possibles*. Mais leur articulation et leur accessibilité restent profondément inégales. Surtout, la plupart de ces dispositifs s’adressent avant tout aux organisations et aux concepteurs, beaucoup moins aux personnes directement affectées par Système F.
+
+### I.5.2. Comités et chartes : scènes sans publics
+
+Les comités d’éthique de l’IA et les groupes d’experts ont joué un rôle central dans la formulation des grands principes qui structurent l’*arcalité déclarée des systèmes* — équité, transparence, robustesse, responsabilité, etc. Les AI Principles de Google et Microsoft, les Lignes directrices européennes pour une IA digne de confiance, ou encore les rapports nationaux sur “l’IA et les libertés” en sont des exemples typiques.
+
+Ces instances ont bien une dimension quasi archicratique : elles mettent en scène, dans un cercle de spécialistes, des questions de fond (“qu’est-ce qu’une IA digne de confiance ?”, “quels sont les risques majeurs pour les droits fondamentaux ?”). Elles produisent des textes publics, organisent des consultations, parfois invitent la société civile à réagir. Mais, du point de vue de Système F, elles restent à un niveau très général :
+
+- elles ne se prononcent que rarement sur un système concret inséré dans des chaînes cratiales spécifiques (fraude sociale, tri de CV, gestion des risques de santé, etc.) ;
+
+- elles ne réunissent qu’à la marge les personnes directement affectées par ces dispositifs (allocataires, patients, justiciables, candidats, usagers) ;
+
+- elles n’ont pas, sauf exception, de pouvoir d’injonction ou de suspension sur les systèmes en question.
+
+Autrement dit, ces comités produisent des scènes de discours normatif situées très en amont, mais ils n’organisent pas l’épreuve d’un Système F déterminé. Ils contribuent à la fondation discursive de l’“IA responsable”, sans pour autant mettre en visibilité la *cratialité effective* des dispositifs déjà déployés.
+
+### I.5.3. Audits de biais et évaluations d’impact : scènes confinées, biaisées par les conflits d’intérêts
+
+Une deuxième famille de dispositifs, plus proche des chaînes réelles de Système F, est celle des *audits de biais* et des *évaluations d’impact algorithmiques*. Dans de nombreux pays, cette famille est en plein essor : New York, avec le *Local Law 144*, impose des audits de biais pour les outils automatisés de recrutement ; le Canada a généralisé l’“*Algorithmic Impact Assessment*” pour les systèmes de décision automatisée dans l’administration ; des guides de bonnes pratiques, produits par des organisations internationales, des agences publiques et des *think tanks*, enjoignent désormais administrations et entreprises à “évaluer” leurs systèmes de profilage avant ou pendant leur déploiement.
+
+Dans l’esprit, on pourrait croire tenir enfin une *archicration* structurée : un tiers examine un système, mesure ses effets, formule des recommandations, éventuellement sous le regard de l’autorité ou du public. Un rapport est produit, parfois publié ; des chiffres sont discutés ; des engagements d’amélioration sont pris. Mais dès qu’on regarde de près *qui audite, sur quoi, avec quelles marges de manœuvre*, apparaissent des tensions lourdes, qui tiennent moins de la sophistication statistique que de la *configuration des intérêts en présence*.
+
+Premièrement, la plupart des régimes d’audit existants reposent sur un modèle classique de *relation client–prestataire*. C’est l’organisation qui déploie Système F – employeur, administration, plateforme – qui commande, finance et choisit son auditeur. Le *Local Law 144* de New York illustre bien cette logique : les employeurs doivent faire réaliser un audit annuel par un tiers “indépendant” de leurs outils de décision automatisée en matière d’emploi, et publier un résumé des résultats. Sur le papier, l’exigence d’indépendance est posée ; dans la pratique, rien n’empêche la constitution d’un marché de cabinets spécialisés dont la survie dépend de la capacité à produire des audits compatibles avec les attentes de leurs clients. Les premières analyses de ce régime soulignent un nombre limité d’audits effectivement réalisés, une tentation d’interpréter les exigences de manière minimaliste, et un *risque de* “*vice de conformité*” : *l’audit devient un examen du respect formel des prescriptions, non une épreuve substantielle du dispositif et de ses usages*.
+
+Deuxièmement, la montée en puissance d’une véritable “industrie de l’audit de l’IA” introduit un *conflit d’intérêts structurel*. De *grandes firmes de conseil* – parfois les mêmes qui développent, vendent ou intègrent des solutions d’IA – *se positionnent comme auditeurs des systèmes qu’elles contribuent par ailleurs à diffuser*. Des organismes de normalisation, comme le British Standards Institution, ont explicitement mis en garde contre cette situation : un nombre significatif d’acteurs qui commercialisent des audits d’IA sont aussi producteurs de technologies, ce qui alimente des doutes sur leur indépendance et sur la rigueur des évaluations ; des initiatives de standardisation cherchent désormais à encadrer ces pratiques. Dans le même sens, les appels à des audits “holistiques” – qui évalueraient non seulement les performances techniques, mais aussi les présupposés normatifs, les effets sociaux et les mécanismes de gouvernance – insistent sur la *nécessité d’auditeurs* “*libres de tout conflit d’intérêts*”, *sans quoi la procédure se réduit à une validation de façade*.
+
+Troisièmement, les *évaluations d’impact algorithmiques* mises en place dans le secteur public prolongent souvent, sous une forme plus sophistiquée, la *logique de l’auto-évaluation*. Lorsqu’un ministère ou une agence réalise lui-même “son” évaluation d’impact avant de déployer un système de profilage ou de tri, il se trouve en position de juger la pertinence d’un dispositif qu’il a conçu, financé, promu et qu’il espère présenter comme vecteur de modernisation. Les travaux pionniers sur les *Algorithmic Impact Assessments* insistent, à l’inverse, sur la nécessité de dispositifs véritablement contradictoires : participation forte des publics concernés, consultations publiques substantielles, possibilité pour des acteurs externes (ONG, chercheurs, journalistes) de demander des compléments ou de contester des évaluations jugées insuffisantes. Certaines analyses des cadres européens vont dans le même sens, en plaidant pour des droits d’accès aux données, aux modèles et aux documents de conception, faute de quoi aucun écosystème d’audit réellement indépendant ne peut émerger.
+
+Si l’on recompose ces éléments dans notre langue archicratique, on voit se dessiner une *typologie de conflits d’intérêts qui affectent directement la scène d’épreuve*. Les conflits sont *financiers*, lorsque l’auditeur dépend économiquement, de manière répétée, du client qu’il est censé contrôler ; *organisationnels*, lorsque l’audit est confié à des structures internes, à des filiales ou à des partenaires stratégiques qui partagent les mêmes objectifs de déploiement ; *cognitifs*, enfin, lorsque audités et auditeurs appartiennent au même petit milieu technico-juridique, avec des catégories de pensée, des indicateurs et des horizons de pertinence largement communs. Dans ces trois cas, *l’instance censée jouer le rôle de tiers contradicteur se trouve, à divers degrés, alignée avec les intérêts et les cadrages de ceux qui conçoivent et exploitent Système F*.
+
+Le cadrage même des audits accentue cette dérive. Les textes juridiques et les guides méthodologiques encouragent parfois une vision très étroite de l’objet audité. Le *Local Law 144*, par exemple, impose de mesurer des écarts de taux de sélection selon le genre et la “race/ethnicité” dans les outils de recrutement, mais ne couvre pas d’autres dimensions pourtant protégées par le droit (âge, handicap) ou manifestement pertinentes (origine sociale, statut migratoire, langue). Dans ce contexte, l’organisation a tout intérêt à limiter l’exercice à ce qui est strictement requis, à traiter l’audit comme une *check-list* de ratios, et à laisser hors champ les questions plus profondes de fonction de coût, de proxy ou de composition des jeux de données – c’est-à-dire précisément l’*arcalité implicite* que notre cas cherche à mettre au jour.
+
+Au terme de cette séquence, les *audits de biais* et *évaluations d’impact* apparaissent comme des *archicrations tronquées*. Il y a bien, formellement, une scène : un rapport est rédigé, parfois rendu public ; des chiffres sont produits ; des recommandations sont formulées. Mais les personnes directement affectées par Système F – allocataires, justiciables, patients, candidat·es, utilisateurs de plateformes – en sont largement absentes, ou réduites au statut de “parties prenantes” abstraites ; les choix les plus déterminants (fonctions de coût, proxies, seuils, composition des jeux de données) restent souvent hors du périmètre audité, au profit d’indicateurs aisément mesurables ; les *conflits d’intérêts structurels*, enfin, minent la capacité de l’auditeur à assumer le rôle de *tiers contradicteur* que l’*archicration* exigerait.
+
+Dans notre grammaire archicratique, ces dispositifs constituent donc des épreuves techniques sans scène véritable : l’algorithme est certes testé, mais la collectivité ne dispose pas d’un lieu institué où confronter les résultats, interroger les axiomes, contester les compromis retenus, exiger des transformations. L’audit remplit principalement une fonction de légitimation – “le système a été évalué” – plus qu’une fonction de mise en débat. Autrement dit : la *cratialité* de Système F est brièvement éclairée par quelques faisceaux d’expertise, mais l’*arcalité implicite* reste soustraite à la comparution, et la scène demeure largement capturée par ceux qui ont intérêt à maintenir le dispositif intact.
+
+### I.5.4. Autorités et tribunaux : scènes fortes, mais rares et *ex post*
+
+Les autorités de régulation et les juridictions offrent, à première vue, les formes les plus accomplies d’*archicration* : procédures contradictoires, auditions, décisions motivées, sanctions, parfois réparation.
+
+L’arrêt SyRI du tribunal de La Haye est emblématique : le dispositif de profilage de fraude aux prestations y est décrit, mis en rapport avec l’article 8 de la CEDH, et finalement jugé disproportionné, en raison notamment du manque de transparence, du ciblage de quartiers défavorisés et de la difficulté pour les personnes profilées de contester le système.  
+Dans le scandale des allocations pour la garde d’enfants, les enquêtes de l’Autorité de protection des données (AP), les rapports parlementaires et, finalement, la crise politique qui a conduit à la démission du gouvernement Rutte illustrent ce que peut être une scène d’épreuve à grande échelle : les pratiques de profilage, les critères utilisés (dont la double nationalité), les effets sur des milliers de familles sont mis au jour, décrits, condamnés, et donnent lieu à un vaste plan de compensation.
+
+Au niveau européen, le DSA commence à être appliqué comme base juridique pour sanctionner des plateformes qui manquent à leurs obligations de transparence, comme dans le cas récent de l’amende infligée à X (anciennement Twitter) pour violation de ses devoirs de transparence et de lutte contre les “*dark patterns*”.
+
+Ces scènes ont un effet archicratique réel : elles forcent les systèmes à comparaître, révèlent des pratiques jusque-là invisibles, imposent des réformes. Mais elles ont aussi des limites structurelles :
+
+- Elles interviennent tard, après des années d’usage, lorsque les dommages sont déjà massifs, comme dans le *toeslagenaffaire* (surendettement, perte de logement, placement d’enfants).
+
+- Elles restent focalisées sur certains aspects juridiques (vie privée, discrimination, transparence) sans pouvoir, à elles seules, reconfigurer l’ensemble de la chaîne cratiale de Système F.
+
+- Elles donnent une place indirecte aux personnes affectées (plaignants, associations, ONG), mais ces dernières n’ont ni la maîtrise de l’agenda, ni la garantie que la logique même du modèle sera transformée.
+
+On pourrait dire, en termes archicratiques, que ces procédures sont des *scènes de rattrapage* : elles produisent des effets puissants, mais elles ne transforment pas encore la régulation algorithmique en régime ordinaire de comparution. Système F n’y vient qu’en cas de crise, non comme un acteur continuellement justiciable.
+
+### I.5.5. Recours individuels et plaintes : scènes fermées, réponses standardisées
+
+Reste la question des recours : que peut faire, dans l’état actuel des choses, un individu ciblé par Système F ?
+
+Dans les politiques sociales, un allocataire qui voit sa prestation suspendue ou refusée peut en principe exercer un recours administratif ou contentieux. Pourtant, comme l’ont montré les enquêtes sur le scandale néerlandais, ces voies ont été largement inopérantes face à des décisions massives et standardisées, fondées sur des profils de risque opaques. Des parents ont multiplié les recours individuels sans succès, jusqu’à ce que des journalistes, des parlementaires et des autorités de contrôle parviennent à ouvrir le scandale au niveau systémique.  
+Le recours reste structuré comme si la décision avait été prise par un agent individuel, dans un dossier singulier ; il n’offre aucune prise pour contester la logique même du système de profilage.
+
+Dans le recrutement, des candidats peuvent saisir les autorités anti-discrimination ou engager des actions en justice, comme dans les affaires récentes où des candidats ont attaqué des fournisseurs d’outils de tri automatisé pour discrimination raciale ou fondée sur le handicap.
+
+Mais même les dispositifs les plus avancés, comme le *Local Law 144*, se concentrent sur le respect d’obligations de procédure (audit, transparence minimale), non sur l’ouverture d’une scène où les candidats pourraient discuter des critères incorporés dans l’outil. Une fois que l’employeur peut montrer qu’un audit a été réalisé et qu’un résumé est en ligne, la possibilité de contester la structure même de l’outil reste très limitée.
+
+Pour les plateformes, le DSA impose l’existence de *mécanismes internes de réclamation* et, pour les très grandes plateformes, la *mise en place de systèmes de traitement des notifications de contenus illégaux et de plaintes contre les décisions de modération*, ainsi que des *mécanismes de règlement extrajudiciaire des litiges*.
+
+En pratique, ces dispositifs prennent la forme de formulaires en ligne, de délais de réponse, de messages standardisés. Ils permettent parfois de corriger des erreurs manifestes (restauration d’un contenu, réouverture d’un compte), mais ils n’ouvrent presque jamais une discussion sur les critères de modération eux-mêmes. L’utilisateur reste face à une interface laconique ; le rôle de Système F dans la décision (score de toxicité, détection de désinformation, etc.) est rarement explicité.
+
+Le *Meta Oversight Board* constitue une exception partielle : il *publie des décisions motivées*, *analyse la conformité des politiques de Meta aux droits humains*, *formule des recommandations publiques*, parfois très critiques, sur certains *aspects de la modération* et de la *hiérarchisation des contenus*.
+
+Mais il ne traite qu’un nombre infime de cas, sélectionnés parce qu’ils soulèvent des questions emblématiques ; il n’a pas de pouvoir direct sur la conception des systèmes de recommandation ou sur l’ensemble des algorithmes qui régulent la visibilité. Sa scène est réelle, mais fortement débitée : quelques affaires par an, dans un océan de décisions automatisées quotidiennes.
+
+Dans la santé, enfin, les patients disposent de droits d’accès à leur dossier et, dans certains pays, peuvent saisir des médiateurs ou des commissions d’éthique clinique. Les travaux sur l’algorithme d’Obermeyer et al. montrent que la prise de conscience de ses effets discriminatoires est venue de chercheurs en épidémiologie et en médecine, non de recours individuels de patients.  
+Là encore, la scène d’épreuve reste centrée sur la relation médecin–patient ; Système F y apparaît, au mieux, comme un outil contextuel, rarement comme objet principal de la contestation.
+
+On voit se dessiner un trait commun : les mécanismes de recours existants permettent de contester les effets (une suspension de prestation, une peine, un refus d’embauche, un retrait de contenu), beaucoup plus difficilement le dispositif qui les produit. Ils ouvrent surtout des scènes de réclamation, non des scènes d’*archicration*.
+
+### I.5.6. *Archicrations fantômes* et *oblitération de la scène*
+
+Si l’on rassemble ces éléments, le diagnostic archicratique sur l’“*archicration existante*” de Système F devient plus précis.
+
+- Oui, il existe des *instances qui ressemblent à des scènes* : *comités d’experts, audits, autorités de régulation, tribunaux, mécanismes de plainte, organes comme l’Oversight Board*.
+
+- Oui, certaines de ces *instances produisent des effets tangibles* : *arrêt de SyRI, révélation et compensation dans le scandale des allocations, sanctions financières sous le DSA, ajustements ou abandons de certains outils* (comme le système de recrutement d’Amazon).
+
+- Mais, pour l’essentiel, ces *instances restent partielles, sectorisées, tardives et pauvres en participation directe des personnes affectées*.
+
+Du point de vue de l’*archicratie*, cela signifie que :
+
+- L’*arcalité* de Système F existe, mais elle demeure largement *fantomatique* : les fondements implicites (proxies, fonctions de coût, hiérarchies des erreurs) ne sont presque jamais mis en scène comme tels. Les grands principes d’“IA digne de confiance” ou de “lutte contre la fraude” sont proclamés, mais leurs traductions opératoires ne sont pas exposées devant ceux qu’elles engagent.
+
+- La *cratialité* est puissante, finement articulée, mais *hypertopique* : elle concentre ses opérations dans des architectures techniques et organisationnelles peu visibles, qui produisent des effets massifs sans qu’il soit possible, pour un individu, de remonter aisément la chaîne du “*par quoi et comment*”.
+
+- L’*archicration*, enfin, est *lacunaire* : elle se manifeste soit sous forme de procédures internes, d’audits, de comités qui ne sont pas de vraies scènes publiques ; soit sous forme de grandes affaires contentieuses ou de scandales médiatiques, qui jouent le rôle de scènes d’exception plutôt que d’instances ordinaires de mise à l’épreuve.
+
+On peut, avec la thèse, parler ici d’*archicrations fantômes* : des dispositifs qui empruntent l’allure des scènes (commissions, formulaires, recours), mais qui ne disposent ni de la consistance, ni de l’ouverture, ni de la réflexivité nécessaires pour faire effectivement comparaître Système F. Ils maintiennent l’impression d’une possibilité de recours, sans organiser véritablement la confrontation des fondements, des instruments et des effets.
+
+La première conclusion de l’épreuve de détectabilité est ainsi nette : dans l’état actuel des usages de Système F, la régulation algorithmique est, pour une large part, hors scène. Les scènes qui existent sont soit trop en amont (principes généraux), soit trop en aval (scandales, contentieux), soit trop étroites (audits techniques fermés, formulaires de plainte standardisés). La suite du cas d’étude consistera à replacer cette *oblitération archicratique* dans la longue histoire des régimes régulateurs, puis à examiner ce que pourrait signifier, pour un système d’IA de ce type, une véritable réouverture de la scène : non plus des reculs ponctuels, mais une politique explicite des épreuves, où Système F serait tenu de rendre des comptes, non seulement sur ses performances, mais sur les fondements et les formes de pouvoir qu’il met en œuvre.
+
+##

src/content/cas-ia/chapitre-2.mdx

@@ -0,0 +1,273 @@
+---
+title: "Chapitre II — Épreuve topologique"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 30
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_2_Epreuve_Topologique.docx"
+---
+# II. Épreuve topologique : hypotopies, hypertopies, atopies des scènes IA
+
+L’épreuve de détectabilité nous a permis de reconstituer, pour Système F, la distribution des trois prises archicratiques : *arcalités déclarées et implicites, cratialités en chaîne, archicrations rares et fragmentaires*. L’épreuve topologique déplace maintenant la focale : il ne s’agit plus seulement de savoir où se trouvent *arcalité, cratialité* et *archicration*, mais dans quels types de scènes elles se laissent – ou non – approcher. Elle interroge la configuration concrète des lieux où la régulation algorithmique apparaît, se dit, se discute, se justifie, se conteste. Autrement dit : non seulement *quoi* et *comment*, mais *où* et *avec qui*.
+
+Dans la thèse, la topologie archicratique désigne cette manière de lire un ordre régulateur à partir de la forme de ses scènes : *synchrotopies*, quand l’*archicration tient ensemble, de façon relativement stable, des prises arcalitaires et cratiales en présence de publics divers* ; *hypotopies*, quand la *scène existe, mais sous une forme tellement appauvrie qu’elle n’offre presque aucune prise réelle* ; *hypertopies*, lorsque la *scène est concentrée dans quelques lieux fermés où se décident l’essentiel des orientations, loin des personnes affectées* ; *atopies*, enfin, lorsque des *dispositifs jouent théâtralement la scène* (consultations, boîtes à idées, *feedbacks* symboliques), *sans connexion effective avec les lieux de décision*. La topologie n’est donc pas un simple “plan” des espaces physiques ou numériques : c’est une cartographie des situations scéniques où le pouvoir régulateur accepte – ou refuse – de se rendre visible.
+
+Or l’écosystème de Système F est typiquement un espace topologiquement différencié. D’un côté, des *scènes locales d’usage* : guichets transformés en interfaces, portails en ligne, tableaux de bord, applications mobiles, formulaires de recours, boutons “signaler” ou “noter”. *Ces scènes sont souvent les seuls lieux où les personnes affectées par Système F peuvent ressentir quelque chose de sa présence* : un score, un code couleur, un refus, une chute de visibilité, un message standardisé. Du point de vue archicratique, elles ressemblent à des *hypotopies* : ce sont bien des scènes – il y a une interface, parfois un droit de réclamation, un espace minimal d’adresse –, mais elles sont *pauvres en prises, déconnectées des lieux où se décident l’architecture du système, les choix de proxies, les fonctions de coût, les seuils*. Par endroits, elles basculent même dans l’*atopie* : *faux dialogues, consultations sans effet, boîtes à idées numériques dont les contributions ne remontent jamais vers les lieux de conception*.
+
+À l’autre extrémité, Système F se cristallise dans des *scènes institutionnelles* où se jouent les décisions structurantes : *comités de pilotage, boards techniques, réunions de design, arbitrages budgétaires, cellules “d’innovation” au sein des ministères ou des grandes entreprises, cabinets de conseil et de prestataires*. Ce sont des scènes très denses en prises cratiales : on y discute des architectures, des choix de déploiement, des objectifs d’optimisation, des métriques de performance, de la conformité juridique, parfois même des enjeux d’acceptabilité sociale. Mais ces *scènes* sont *fermées* : la plupart du temps, n’y participent que des *experts techniques, des responsables hiérarchiques, des juristes et quelques représentants institutionnels*. Les personnes directement affectées par Système F – allocataires, patients, justiciables, candidats, usagers – n’y apparaissent que sous la forme d’“utilisateurs finaux”, de “profils de risque” ou de “cas d’usage”. Ces lieux relèvent de l’*hypertopie cratiale* : ce sont des s*cènes effectives, mais concentrées, saturées de pouvoir, inaccessibles pour ceux qui subissent les décisions qui y sont prises*.
+
+Entre ces deux polarités, une troisième famille de scènes se dessine : les *scènes judiciaires et quasi-judiciaires*. Cours et tribunaux, autorités de protection des données, régulateurs sectoriels, instances comme l’*Oversight Board*, mécanismes de règlement extrajudiciaire des litiges instaurés par le Digital Services Act. Ce sont des lieux où Système F, ou certains de ses avatars, peuvent être introduits comme objet de litige : *refus de prestation sociale, décision automatisée contestée, modération de contenu jugée abusive, sélection algorithmique à l’embauche, pratiques discriminatoires en santé*. On y trouve des éléments majeurs d’*archicration* : *procédure contradictoire, possibilité de produire des preuves, décisions motivées, sanctions*. Mais ces scènes sont souvent tronquées du point de vue archicratique : le juge ou l’instance n’ont pas toujours accès aux paramètres, aux données, aux logs ; ils se heurtent au *secret commercial*, à l’*opacité technique*, à l’*indisponibilité de certaines informations*. L’algorithme apparaît alors dans la scène, mais partiellement : la chaîne cratiale reste, en grande partie, hors champ. La scène d’épreuve est réelle, mais incomplète.
+
+L’épreuve topologique appliquée à Système F va consister à organiser ce paysage, non pas en ajoutant un vocabulaire supplémentaire, mais en qualifiant les formes scéniques où la régulation algorithmique se manifeste. Dans un premier temps (II.1), nous prendrons au sérieux les scènes locales d’usage : guichets, interfaces, formulaires, dispositifs de “feedback”. Nous montrerons comment elles combinent, le plus souvent, *hypotopies* (scènes pauvres en prises) et *archicrations fantômes* (recours et consultations sans prise sur la structure du système). Dans un second temps (II.2), nous déplacerons le regard vers les *scènes institutionnelles de conception et de pilotage*, pour caractériser ce que l’on peut appeler une *hypertopie cratiale* : une *concentration scénique du pouvoir de configuration, sous forme de réunions, de comités et de boards largement fermés aux publics concernés*. Dans un troisième temps (II.3), nous interrogerons les *scènes judiciaires et quasi-judiciaires* où l’IA apparaît dans les contentieux, en demandant jusqu’où ces scènes parviennent – ou non – à recomposer une *archicration* complète incluant l’accès aux données, aux modèles et aux traces d’exécution.
+
+Au terme de cette épreuve, une synthèse topologique (II.4) permettra de rendre visible, sous une forme compacte, la manière dont Système F distribue ses scènes : lignes de guichet, interfaces numériques, comités techniques, tribunaux, chacune étant lue à travers les trois prises archicratique (*arcalité* / *cratialité* / *archicration*), le type topologique (*hypotopie, hypertopie, atopie*) et son *degré d’ouverture ou de fermeture*. L’objectif n’est pas de plaquer un schéma préexistant sur l’IA, mais de montrer, très concrètement, que ce type de dispositif tend à dégrader la scène : en multipliant les *pseudo-espaces d’expression sans effet, en concentrant la décision dans des hypertopies techniques, en laissant les arènes judiciaires lutter avec des objets partiellement invisibles*. C’est cette dégradation topologique que la suite du cas d’étude cherchera à caractériser et, surtout, à retourner : *que faudrait-il, pour que Système F soit inséré dans une topologie réellement archicratique des scènes ?*
+
+## II.1. Scènes locales d’usage : *hypotopies* et *archicrations fantômes*
+
+Là où Système F devient perceptible pour la plupart des personnes, ce n’est ni dans les *data centers*, ni dans les comités de pilotage, ni dans les rapports d’audit, mais dans des scènes beaucoup plus modestes : un écran de guichet, un portail en ligne, un SMS automatique, un formulaire de recours, un bouton “signaler”, une boîte de dialogue “évaluez votre expérience”. Ce sont des scènes, au sens strict : il y a une interface, une adresse possible, parfois un droit minimal de réponse. Mais ce sont des scènes pauvres, prises dans un rapport extrêmement dissymétrique avec les lieux où Système F est conçu, paramétré, déployé. Topologiquement, elles relèvent de l’*hypotopie* et, lorsqu’elles se contentent de simuler un dialogue sans prise réelle, de l’*atopie*.
+
+### II.1.1. Guichets devenus interfaces : la scène réduite au formulaire
+
+Dans les régimes de protection sociale que nous avons évoqués dans la Partie I, l’introduction de Système F ne supprime pas le guichet ; elle le transforme. Là où se trouvaient autrefois des bureaux, des agents, des piles de dossiers papier, on rencontre de plus en plus souvent des *interfaces* : *écran partagé entre l’agent et l’allocataire, portail sur lequel ce dernier doit déposer ses justificatifs, suivre l’avancement de son dossier, répondre à des notifications*.
+
+Du point de vue de l’allocataire, la scène se réduit à une *série d’actions codifiées* : *remplir des champs, téléverser des documents, cliquer sur “valider”, consulter un statut* (“en cours d’instruction”, “refusé”, “suspendu”), *parfois recevoir un message standardisé*. Système F est présent, mais en creux : il se manifeste par l’*ordre d’apparition des dossiers*, la *vitesse de traitement*, un *score de risque invisible*, un *basculement automatique d’un statut à un autre*.
+
+Du point de vue de l’agent de guichet, la scène a aussi changé : là où l’on triait les dossiers “à vue” ou selon des procédures explicites, l’écran présente désormais une *file de cas pré-classés*, souvent accompagnés de *codes couleur*, *de priorités*, *d’alertes*. L’agent peut parfois *ajouter une note*, *corriger un champ*, *signaler une anomalie* ; mais l’*architecture globale de la décision* (quels dossiers arrivent, dans quel ordre, avec quel niveau d’urgence) *lui échappe en grande partie*. La *cratialité* de Système F traverse la scène, sans y apparaître vraiment.
+
+Topologiquement, cette situation correspond à une *hypotopie* : il y a bien une scène – des personnes présentes, des échanges, une interface, des décisions qui se prennent – mais elle est pauvre en prises sur la régulation algorithmique. L’allocataire ne voit ni les variables qui le caractérisent dans Système F, ni le score qui a déclenché un contrôle ; l’agent lui-même n’a souvent qu’un accès très partiel aux raisons techniques du classement. La scène sert à exécuter des décisions déjà pré-structurées ailleurs, non à interroger la logique qui les organise.
+
+On pourrait imaginer, en théorie, un guichet où l’allocataire pourrait demander : “*quel rôle précis a joué le système automatique dans ma suspension ? quels critères ont été appliqués ? quels sont les taux d’erreur habituels ?*” En pratique, ces questions n’ont souvent pas de place dans la scène : ni l’interface, ni la formation des agents, ni les procédures n’ont prévu qu’on puisse les poser – et encore moins y répondre. L’*archicration reste hors champ*.
+
+### II.1.2. Recours numériques : de la réclamation au simulacre d’*archicration*
+
+Lorsque la décision est défavorable – une prestation suspendue, un dossier classé sans suite, un refus d’allocation, une radiation –, la scène se déplace vers les *procédures de recours*. Elles sont, de plus en plus, numérisées : *formulaires en ligne, espaces personnels où l’on peut “contester” une décision, champs de texte libre limité en nombre de caractères, cases à cocher pour indiquer un motif* (“erreur de calcul”, “changement de situation”, “décision injustifiée”, etc.).
+
+Sur le papier, ces dispositifs matérialisent une forme d’*archicration* : ils offrent à la personne concernée une *possibilité de s’adresser à l’institution*, de *présenter ses arguments*, d’*obtenir une révision*. Mais, lorsqu’on les lit à travers la grille archicratique, beaucoup apparaissent comme des *archicrations fantômes*.
+
+D’abord, parce qu’ils sont structurés pour traiter des réclamations individuelles sur le résultat, non pour ouvrir une discussion sur le dispositif. Le formulaire invite à dire “je n’aurais pas dû être suspendu”, “mes revenus ont été mal pris en compte”, “vous n’avez pas considéré tel document”, mais il n’offre aucune case, aucune catégorie, aucun canal pour dire : “l’algorithme qui m’a classé comme fraudeur repose sur des hypothèses inacceptables”, “la nationalité ne devrait pas être utilisée comme facteur de risque”, “les erreurs du système sont concentrées sur des personnes dans ma situation”. La scène est calibrée pour corriger des erreurs perçues comme accidentelles, non pour instruire des critiques sur la structure même de Système F.
+
+Ensuite, parce que la trajectoire de ces recours est souvent opaque. Une fois le formulaire envoyé, l’allocataire reçoit un accusé de réception automatique, puis une réponse laconique confirmant ou non la décision initiale. *Le recours a-t-il été lu par un humain ? Par un second modèle ? Par un agent qui ne fait que vérifier la présence de certains justificatifs ? Les éléments soumis ont-ils une chance de remonter vers les équipes qui conçoivent et paramètrent Système F ?* La scène existe, mais elle est décrochée de la chaîne cratiale.
+
+Enfin, parce qu’il n’y a pas, dans la plupart des cas, de *mise en publicité des recours* : ni statistiques agrégées sur le nombre de contestations liées aux décisions co-produites par Système F, ni analyses régulières des motifs de mécontentement, ni articulation explicite entre ces données et la reconfiguration des modèles. La *scène de recours reste cloisonnée*, sans devenir une scène où l’*arcalité implicite* et la *cratialité* pourraient être rejouées.
+
+Du point de vue topologique, ces dispositifs relèvent d’une forme mixte : *hypotopiques, parce qu’ils offrent très peu de prises réelles sur la régulation algorithmique* ; et déjà partiellement *atopiques*, dès lors qu’ils se contentent de *jouer le rôle de “voix des usagers” sans que cette voix rencontre des lieux de décision*. La scène est là, mais comme *décor procédural*, non comme espace d’épreuve.
+
+La scène de recours est donc globalement hypotopique : elle existe bien, mais avec une densité de prises tellement faible qu’elle ne peut presque jamais infléchir la régulation algorithmique. Il s’agit bien souvent au mieux d’une correction ponctuelle et discrète.
+
+### II.1.3. Feedbacks, étoiles, likes, boutons “signaler” : l’atopie comme style
+
+Un troisième type de scènes locales d’usage est celui des *dispositifs de feedback continu* : étoiles attribuées à un service, notation d’une interaction, boutons “j’aime” / “je n’aime pas”, icônes “signaler ce contenu”, “ce résultat est utile / ne l’est pas”, “résultats inappropriés”. Ils sont omniprésents dans les plateformes numériques, mais aussi de plus en plus dans les services publics et les applications professionnelles.
+
+À première vue, ces dispositifs prolongent une ambition archicratique : *rendre les systèmes sensibles à l’expérience des usagers, intégrer en continu des retours, corriger les dérives*. L’utilisateur de Système F – bénéficiaire, patient, conducteur ou passager d’une plateforme de mobilité, client d’un service, internaute exposé à des contenus – se voit offrir un petit geste : cliquer sur une étoile, cocher une case, rédiger un bref commentaire, signaler un abus. *Autant de micro-prises qui donnent l’impression d’une scène toujours disponible*.
+
+Mais là encore, la lecture topologique révèle souvent une *atopie* : *un usage du langage de la scène sans articulation réelle avec les lieux où la régulation se décide.* Dans les *systèmes de notation réciproque* (chauffeurs / passagers, vendeurs / acheteurs, travailleurs de plateforme / clients), l’étoile donnée par un individu est très rarement pensée comme un *acte de mise à l’épreuve d’une norme*. Elle est conçue comme un *signal quantifiable*, immédiatement intégré à un *score global* qui servira ensuite à ordonner des files d’attente, à attribuer des courses, à exclure des travailleurs jugés “peu fiables”. La *scène de feedback* n’est pas l’endroit où les critères de qualité de service se discutent ; elle est un *mécanisme de discipline diffuse* : chacun sait qu’il peut être “noté”, mais ne sait pas vraiment comment les notes sont agrégées, interprétées et utilisées.
+
+Sur les plateformes de contenus, le bouton “signaler” promet au contraire une *capacité à faire remonter des problèmes* : contenu haineux, illégal, trompeur, dangereux. En pratique, l’utilisateur ne voit presque jamais ce qu’il advient de son signalement : celui-ci part dans une chaîne cratiale obscure – combinaison de filtres automatisés, de priorisations, de requalifications humaines – pour revenir, parfois, sous la forme d’un message standard (“nous avons examiné votre signalement et décidé de…”), sans explication sur les critères appliqués, sur la place exacte de Système F dans la décision, ni sur la manière dont ce signalement contribue à reconfigurer les modèles.
+
+Sur les interfaces de certains outils d’IA, les boutons “pouce en haut / pouce en bas”, “utile / non utile”, “trop sévère / trop permissif” jouent un rôle similaire : ils promettent une *co-construction des comportements du modèle*, mais ne donnent ni visibilité sur la manière dont ces retours sont utilisés, ni possibilité d’élargir la scène à d’autres acteurs que l’utilisateur individuel. Là encore, nous sommes devant une scène minimale – un geste, un symbole, un canal – mais qui ne s’adosse à aucune *archicration* identifiable.
+
+Ce qui caractérise ces dispositifs, du point de vue archicratique, c’est donc leur ambiguïté : ils sont présentés comme des instruments de participation, alors qu’ils fonctionnent surtout comme des capteurs supplémentaires dans la chaîne cratiale de Système F. Ils peuvent améliorer certains paramètres (réduire des erreurs manifestes, affiner des modèles de recommandation), mais ils ne créent pas de scène où les fondements et les effets du système seraient mis à l’épreuve avec les publics concernés. *Ce sont des scènes sans monde : des atopies*.
+
+Lorsque le *feedback* se réduit à un geste symbolique sans trajectoire identifiable vers les lieux de décision, on ne se trouve alors plus seulement dans une *hypotopie*, mais dans une *atopie* : *une scène jouée pour elle-même, déconnectée des décisions effectives et des répercussions affectives*.
+
+### II.1.4. *Hypotopies* et *archicrations fantômes* : première coupe topologique
+
+Si l’on rassemble ces trois familles de scènes locales – *guichets devenus interfaces, recours numériques, dispositifs de feedback* –, un motif commun se dessine.
+
+1.  Elles sont *proches des personnes affectées* : c’est là que Système F est ressenti, au moment où un dossier bascule, où un contenu disparaît, où une notation tombe, où une décision est confirmée ou refusée.
+
+2.  Elles *offrent bien des formes de scène* : présence d’un agent, d’une interface, d’un canal de parole, d’un geste de notation ou de signalement.
+
+3.  Mais elles sont *décrochées des lieux où se configurent la cratialité et l’arcalité implicite du système* : les choix de proxies, de fonctions de coût, de seuils, de stratégies de déploiement, de politiques de modération ne sont presque jamais discutés ni requalifiés à partir de ce qui s’y joue.
+
+Topologiquement, ces scènes sont donc *hypotopiques* : elles existent, mais avec un *très faible nombre de prises effectives sur la régulation*. Et lorsqu’elles promettent une participation forte (*feedback* continu, consultations en ligne, enquêtes de satisfaction, boîtes à idées numériques) sans offrir de trajectoire identifiable des contributions vers les lieux de décision, elles basculent dans l’*atopie* : il y a bien un théâtre, des gestes, un vocabulaire de la co-construction, mais pas de connexion stable avec la chaîne cratiale qui la rend effective.
+
+C’est ce déficit topologique – cette combinaison de scènes pauvres en prises et de pseudo-scènes sans pouvoir réel – qui explique, pour une part, la persistance d’*archicrations fantômes* autour de Système F. La suite de la Partie II montrera que cette pauvreté n’est pas un simple problème “local” à corriger par quelques améliorations d’interface : elle est le reflet d’une configuration d’ensemble où la scène, au sens archicratique, est structurellement reléguée.
+
+## II.2. *Scènes institutionnelles* : *hypertopie cratiale*
+
+Les *scènes locales d’usage* donnent à voir Système F sous forme de *reflets* : un écran de guichet, un portail de recours, un bouton “signaler”. La véritable scène, celle où se combinent les choix de fondement et les décisions opératoires, se déplace ailleurs : dans des *salles de réunion*, des *comités de pilotage,* des *“boards” responsables de l’IA,* des *cellules de conformité ou d’innovation*. C’est là que se décide le *design du modèle*, le *périmètre des données*, les *fonctions de coût*, les *seuils*, les *conditions de déploiement*, les *mécanismes de supervision humaine*. Du point de vue topologique, ces lieux concentrent une *densité exceptionnelle de prises cratiales* et, de plus en plus, d’*énoncés arcaux explicites* – *principes, standards, matrices de risques*. Mais ils sont *fermés* : les publics affectés n’y sont presque jamais présents, ni même représentés autrement que sous la forme de “*personae*”. Ce sont des *hypertopies cratiales*.
+
+### II.2.1. Là où Système F se décide : comités, *workshops*, “*steering boards*”
+
+Dans une caisse sociale qui envisage d’intégrer un module de Système F pour prioriser les contrôles, la scène institutionnelle typique prend la forme d’un *comité projet* : autour de la table, des responsables métiers (fraude, prestation, contrôle), des informaticiens, un juriste spécialisé en protection des données, parfois un représentant de la direction de la stratégie ou de l’inspection interne. C’est dans cette configuration que l’on discute des “*cas d’usage*” envisagés, des *sources de données* que l’on estime mobilisables, des *critères de risque* jugés pertinents, des *modalités de “pilotage”* (périodes de test, indicateurs de performance, seuils de déclenchement des contrôles).
+
+Un schéma comparable se retrouve dans un hôpital qui veut déployer un outil de tri des patients à haut risque, dans un ministère de la justice qui envisage un système d’aide à la décision pénale, ou dans une grande entreprise qui souhaite industrialiser l’utilisation de Système F pour le tri des candidatures. Dans tous ces cas, *le cœur de la décision se situe dans des réunions internes* où l’on *arbitre entre plusieurs architectures possibles*, où l’on *discute des proxies envisageables* (historique de coûts, variables socio-démographiques, signaux comportementaux), où l’on *fixe des seuils de déclenchement et des règles d’escalade*. Les personnes dont les trajectoires seront directement affectées – allocataires, patients, justiciables, candidats – sont absentes ; au mieux, elles sont présentes sous forme de *catégories* (“usagers vulnérables”, “publics à risque”, “talents”) ou de *statistiques*.
+
+Cette structure se retrouve, à un autre niveau, chez les fournisseurs de Système F. Les grands acteurs du *cloud* et des modèles de fondation ont mis en place des comités internes de gouvernance de l’IA : chez Microsoft, le comité *Aether* (*AI, Ethics, and Effects in Engineering and Research*) conseille la direction sur les risques éthiques, juridiques et sociétaux, appuyé par un standard interne de “*Responsible AI*” que les équipes produits doivent respecter. Google décrit un processus de gouvernance couvrant le développement du modèle, le déploiement des applications et la surveillance post-lancement, avec des comités formels qui examinent les nouveaux projets au regard de ses *AI Principles*, complétés par des exercices de *red teaming* et des *revues croisées*.
+
+Dans ces scènes, les décisions structurantes sur Système F sont prises : *quel type de modèle sera proposé par API, avec quels garde-fous, quelles limitations de cas d’usage ; quels critères de “sensibilité” imposent une revue approfondie* ; *quelles demandes de clients (ministères, banques, hôpitaux) doivent être acceptées, négociées, refusées*. Là encore, les experts présents sont nombreux – ingénieurs, juristes, spécialistes de la conformité, parfois chercheurs en sciences sociales – mais les publics concernés sont absents en tant que tels.
+
+Topologiquement, on voit apparaître un *déplacement de la scène* : ce n’est plus au guichet, dans la salle d’audience, au bureau de recrutement que Système F se décide, mais dans ces *arènes internes où se tissent ensemble la stratégie, le droit, la technique, le marketing*.
+
+### II.2.2. Une gouvernance annoncée “*responsable*” comme *scène saturée* de *cratialité*
+
+Pour comprendre le caractère *hypertopique* de ces scènes institutionnelles, il faut prendre au sérieux la montée en puissance de la *gouvernance “responsable” de l’IA*. Au cours des dernières années, une littérature abondante a proposé des cadres de gouvernance articulant *principes éthiques*, *structures d’organisation* (comités, responsables IA, cellules d’accompagnement) *et procédures* (revues de risques, audits internes, évaluations d’impact).
+
+Les grands fournisseurs de Système F ont intégré ces cadres en interne. Microsoft insiste sur le fait que son *Responsible AI Standard* s’applique à toutes les équipes produits, que les cas d’usage “sensibles” doivent être portés devant des groupes de travail spécialisés, et que le comité *Aether* peut, en dernière instance, se prononcer sur des projets à haut risque, en lien direct avec la direction. Google met en avant des comités formels chargés de vérifier que les projets respectent ses *AI Principles*, qui couvrent notamment les questions de bénéfice social, d’évitement des biais injustes, de sécurité et de responsabilité.
+
+Dans le secteur public, des dispositifs analogues apparaissent : le gouvernement canadien a rendu obligatoire un *Algorithmic Impact Assessment* pour tout système de décision automatisée, sous la forme d’un questionnaire structuré qui détermine un niveau de risque et déclenche des exigences de gouvernance (revue par des comités, publication de résumés, documentation renforcée). Des organisations internationales et des ONG ont proposé des typologies de mécanismes d’“*algorithmic accountability*” — *responsabilité algorithmique* — dans le secteur public (audit, évaluations d’impact, transparence, consultations), qui se traduisent souvent par la *création de cellules transversales et de comités d’examen des projets*.
+
+Ces structures incarnent une *cratialité scénique* : elles sont des lieux où des personnes se réunissent, où des dossiers sont présentés, où des avis sont rendus, où certains projets sont acceptés, d’autres renvoyés, parfois abandonnés. Elles ne sont pas de simples scripts : ce sont des scènes où la trajectoire de Système F est effectivement infléchie. Mais elles fonctionnent selon une logique d’*hypertopie* :
+
+- elles *concentrent un grand nombre de prises* – définition des cas d’usage autorisés, choix des métriques de risque, arbitrages entre principes, décisions de go/no-go – dans un petit nombre de lieux fermés ;
+
+- elles *organisent l’accès à ces scènes selon des critères internes* (appartenance à l’entreprise, à l’administration, à une communauté de pratique) ;
+
+- les publics affectés ne sont présents qu’à travers des proxies (études d’impact, “voix de l’utilisateur” reportée par des intermédiaires), rarement comme participants directs ;
+
+- elles se *situent à l’interface entre la stratégie* (marchés, opportunités, cas d’usage), le *droit* (conformité au RGPD, à l’AI Act, aux directives sectorielles), et la *technique* (choix de modèles, d’architectures, de paramètres), de sorte que c’est là que s’articulent désormais *arcalité déclarée* (principes, chartes) *et cratialité* (instruments, procédures).
+
+Autrement dit, la gouvernance “responsable” de Système F n’est pas extérieure à la *cratialité* : elle en est une couche supplémentaire, qui déplace vers ces comités le pouvoir de décider ce qui est “acceptable”, “conforme”, “aligné avec les principes”. *La scène existe, mais elle est réservée aux experts.*
+
+### II.2.3. *Hypertopie régulatoire* : AI Act, autorités, AI Office
+
+À cette gouvernance interne s’ajoute une couche régulatoire qui, elle aussi, se concrétise dans des scènes institutionnelles fermées ou semi-fermées. L’AI Act européen organise un dispositif de gouvernance articulant un AI Office au sein de la Commission, des autorités nationales de surveillance du marché, des comités consultatifs d’experts et des mécanismes de coordination entre États membres.
+
+Pour les systèmes d’IA considérés comme “à haut risque”, les fournisseurs doivent mettre en place un système de gestion des risques couvrant tout le cycle de vie, documenter leurs modèles, assurer une gouvernance des données (représentativité, qualité, absence d’erreurs dans la mesure du possible), garantir des mécanismes de supervision humaine efficaces, tenir des journaux d’événements, et coopérer avec les autorités.
+
+Concrètement, ces obligations donnent lieu, dans les entreprises et les administrations, à la constitution de structures dédiées : responsables produit pour l’IA, unités de conformité, “*AI governance boards*” qui suivent l’état d’avancement des projets, examinent les dossiers techniques, préparent les échanges avec les régulateurs. Des guides récents pour la gouvernance de l’IA recommandent de définir des principes internes, de documenter l’ensemble des politiques relatives au design, au déploiement et à l’exploitation des modèles, et de coordonner ces efforts sous une instance de supervision dédiée.
+
+Là encore, la scène est réelle : des équipes se réunissent pour remplir des questionnaires d’évaluation d’impact, préparer des audits, décider si un cas d’usage tombe ou non dans une catégorie de risque, définir le périmètre des journaux à conserver, négocier avec les autorités sur la qualification d’un système ou la proportionnalité des obligations. Ce sont des lieux où l’architecture de Système F est littéralement “*mise en forme*” *pour répondre aux cadres juridiques*.
+
+Mais cette *hypertopie régulatoire* ne corrige pas spontanément le déficit archicratique des scènes locales. Elle peut renforcer, dans certains cas, l’exigence de documentation et de supervision humaine ; elle peut créer de nouveaux motifs de contentieux, comme on le voit déjà avec les premiers litiges autour de l’AI Act ou des obligations de transparence pour les plateformes.  
+Ce qu’elle ne fait pas, par elle-même, c’est ouvrir ces scènes aux publics affectés : les *procédures restent principalement l’affaire des fournisseurs, des intégrateurs, des régulateurs, éventuellement de quelques représentants de la société civile intégrés à des groupes d’experts*. Les allocataires, les patients, les justiciables, les candidats n’apparaissent qu’indirectement, via des évaluations d’impact ou des consultations ponctuelles.
+
+### II.2.4. Lecture topologique : la scène archicratique capturée par l’*hypertopie*
+
+Du point de vue de l’épreuve topologique, ces *scènes institutionnelles* présentent une configuration paradoxale.
+
+D’un côté, elles *rassemblent ce qui manque aux scènes locales* : ici, les fondements sont explicitement discutés (au moins sous la forme de principes et de matrices de risques), les instruments sont détaillés (modèles, données, paramètres), des arbitrages sont opérés, des décisions sont prises qui engagent la trajectoire de Système F. Ce sont, au sens archicratique, des scènes potentielles : on y parle de ce qui fonde, de ce qui opère, de ce qui est acceptable.
+
+De l’autre, elles sont fermées : la liste des participants est limitée, les publics concernés ne sont présents que sous forme d’abstractions, les conflits de normativité (par exemple entre les intérêts économiques du fournisseur, les objectifs politiques de l’administration et les droits des personnes affectées) sont réglés dans un cercle restreint. L’information circule de manière asymétrique : les expériences des scènes locales (erreurs, injustices, effets pervers) remontent peu, sauf lorsqu’elles éclatent en scandales ou en contentieux ; les décisions prises dans ces hypertopies redescendent sous la forme de modèles “prêts à l’emploi”, de paramètres par défaut, de seuils automatisés, de formulaires de recours formatés.
+
+On peut dire, en reprenant la terminologie de la thèse, que la scène archicratique a été capturée par l’hypertopie cratiale. Au lieu de s’organiser autour d’espaces où les différents mondes concernés par Système F se rencontreraient (bénéficiaires, praticiens, concepteurs, régulateurs, chercheurs, associations), la mise en forme du pouvoir algorithmique se joue dans des cénacles d’experts spécialisés, au croisement de la technique, du droit et de la gestion. La densité de prises y est maximale ; la pluralité des publics y est minimale.
+
+Ce constat ne signifie pas que ces scènes seraient inutiles ou purement cyniques : elles sont indispensables à la mise en conformité, à la réduction de certains risques, à la prise de conscience interne des enjeux. Mais, tant qu’elles restent organisées comme des hypertopies fermées, elles ne constituent pas des archicrations au sens plein : elles ne rendent pas Système F justiciable devant ceux qu’il affecte, elles ne transforment pas la gouvernance de l’IA en scène de confrontation des arcalités et des cratialités.
+
+La Partie II montrera que c’est précisément dans la tension entre ces hypertopies cratiales et les hypotopies/atopies des scènes locales que se dessine le paysage topologique propre aux systèmes d’IA contemporains : un paysage où la scène existe, mais où elle est à la fois concentrée (dans quelques arènes expertes) et dégradée (dans les lieux ordinaires où se jouent les vies).
+
+## II.3. Scènes judiciaires et quasi-judiciaires
+
+Les *scènes judiciaires et quasi-judiciaires* sont, en principe, les lieux par excellence de l’*archicration* : *espaces réglés où une décision peut être contestée, où des preuves sont produites, où des arguments s’affrontent, où une instance tranche en motivant son jugement*. Si Système F devait être mis en cause quelque part, ce serait ici : lorsqu’un refus de prestation sociale est contesté, lorsqu’une décision automatisée est attaquée, lorsqu’une suspension de compte ou un retrait de contenu est porté en justice ou devant une autorité indépendante.
+
+De fait, les systèmes d’IA et, plus largement, les dispositifs algorithmiques, apparaissent de plus en plus souvent dans ces scènes : dans les litiges autour des dispositifs de profilage social néerlandais, dans les recours contre des décisions automatisées au titre du RGPD, dans les affaires de modération de contenus tranchées par des tribunaux nationaux ou par l’*Oversight Board* de Meta, dans les procédures ouvertes par des autorités contre des plateformes qui manquent à leurs obligations de transparence ou de diligence. Mais, lorsque l’on regarde ces scènes à travers la grille archicratique, une question revient avec insistance : *le juge, ou l’instance quasi-judiciaire, voit-il vraiment Système F ? A-t-il accès aux paramètres, aux données, aux logs, aux arbitrages d’erreurs ?* Si la réponse est non ou partielle, la scène reste incomplète : l’*archicration est tronquée*.
+
+### II.3.1. Contentieux sociaux : le système est jugé… tard, et par morceaux
+
+Les affaires néerlandaises liées au profilage social sont exemplaires. Dans le’exemple de SyRI, le tribunal de district de La Haye a été saisi par une coalition d’ONG et de syndicats qui contestaient la conformité du système au droit au respect de la vie privée garanti par l’article 8 de la CEDH. Le jugement de 2020 décrit SyRI comme un *dispositif de croisement massif de données issues de multiples administrations, produisant des “rapports de risque” sur certaines zones ou populations, sans transparence suffisante ni garanties contre les discriminations*. Le tribunal conclut que la législation encadrant SyRI ne respecte pas le “*juste équilibre*” entre la lutte contre la fraude et la protection des droits, et en interdit l’usage.
+
+Dans le scandale des allocations pour la garde d’enfants, ce sont des années de litiges individuels, de plaintes, de rapports de l’Autorité de protection des données, d’enquêtes parlementaires qui ont fini par mettre au jour l’ampleur des *pratiques de profilage* : utilisation de la double nationalité comme facteur de risque, concentration des contrôles sur certaines familles, impossibilité pour les parents de comprendre pourquoi ils étaient ciblés et sommés de rembourser. Les contentieux ont fini par prendre une dimension quasi-systémique, conduisant à la démission du gouvernement et à un vaste plan de compensation.
+
+Ces *scènes judiciaires* ont un effet archicratique réel : elles *obligent l’administration à exposer, au moins partiellement, le fonctionnement de ses dispositifs* ; elles *rendent publics certains critères* ; elles *prononcent des condamnations* ; elles *engagent des réformes*. Mais elles interviennent tard, après la production de dommages parfois considérables, et elles restent souvent focalisées sur un segment de Système F (un système particulier de *scoring*, une catégorie de données, une base légale), sans reconstituer la chaîne cratiale entière.
+
+Du point de vue topologique, ces scènes sont donc fortes, mais intermittentes : ce sont des moments où Système F est forcé d’apparaître, mais seulement lorsqu’un scandale ou un contentieux de grande ampleur éclate. L’*archicration reste événementielle, non structurelle*.
+
+### II.3.2. Décisions automatisées et RGPD : une visibilité juridique sans visibilité technique
+
+Le RGPD et les droits qu’il consacre – *droit d’accès, droit à l’explication, droit d’opposition, droit de ne pas faire l’objet d’une décision exclusivement automatisée produisant des effets juridiques significatifs* – fournissent un autre cadre d’apparition des systèmes d’IA sur la scène judiciaire. Des individus contestent des décisions en invoquant le caractère automatisé du traitement, l’absence d’information claire sur la logique des algorithmes, la difficulté d’exercer effectivement leurs droits.
+
+Les autorités de protection des données ont commencé à instruire des dossiers où des systèmes de *scoring* ou de *profilage* sont au cœur du litige : *applications de notation sociale, systèmes de tri de candidatures, outils de ciblage publicitaire, plateformes de livraison ou de mobilité utilisant des algorithmes pour évaluer les performances et attribuer des tâches*. Dans certains cas, la justice est saisie après une décision de l’autorité, soit par les entreprises qui la contestent, soit par les plaignants qui estiment les mesures insuffisantes.
+
+Mais, dans la pratique, ces scènes se heurtent à un obstacle récurrent : le *fossé entre la visibilité juridique du traitement et la visibilité technique* de Système F. Le RGPD permet à la personne concernée d’obtenir des “*informations utiles quant à la logique*” d’un traitement automatisé ; les autorités peuvent *exiger des explications détaillées* ; les juges peuvent *ordonner la communication de documents techniques*. Cependant :
+
+- Les *informations fournies restent souvent très générales* (description de la finalité, liste de catégories de données, mention d’une utilisation de profilage), *sans entrer dans le détail des modèles, des proxies, des seuils, des arbitrages de coût*.
+
+- Les *entreprises invoquent fréquemment le secret des affaires pour limiter la divulgation de certains éléments* (architecture exacte du modèle, paramètres, méthodes de calibration), *ce qui restreint les capacités d’expertise contradictoire*.
+
+- Les *juges*, sauf à s’entourer d’experts techniques, *ne disposent pas toujours des outils pour interpréter les logs, les matrices de confusion, les rapports de validation qui leur seraient éventuellement communiqués.*
+
+La scène judiciaire existe, mais Système F n’y est présent qu’en silhouette : on connaît sa finalité, on sait qu’il y a un algorithme, on discute de sa base légale et de ses effets, mais on ne reconstitue pas intégralement la *cratialité*. L’*archicration* est, là encore, tronquée : c’est moins l’architecture du système qui comparaît que ses conséquences et son habillage juridique.
+
+### II.3.3. Modération de contenus, *Oversight Board* et DSA : scènes emblématiques mais parcellaires
+
+Dans le domaine de la modération et de la curation de contenus, les *scènes quasi-judiciaires* se multiplient : *recours d’utilisateurs contre des suspensions de compte*, *actions en justice contre des plateformes pour sur-modération ou sous-modération*, *recours devant les autorités au titre du droit à la liberté d’expression* ou de la *protection contre les contenus haineux*, *procédures instruits dans le cadre du Digital Services Act*.
+
+Le *Meta Oversight Board* occupe une position singulière : instance indépendante financée par un trust, composée d’experts et de personnalités diverses, chargée de réexaminer un petit nombre de décisions de modération de Facebook et Instagram, à la demande d’utilisateurs ou de la plateforme elle-même. Dans ces procédures, l’algorithme de recommandation ou les systèmes de détection automatique sont parfois explicitement mentionnés : ils ont pu déclencher une première étape de retrait, ou influencer la visibilité d’un contenu. Les décisions du Board analysent alors la conformité de la décision globale aux règles de la plateforme et aux standards internationaux des droits humains, et formulent des recommandations sur les politiques de modération et leur mise en œuvre.
+
+Le DSA, de son côté, crée des *obligations de transparence et de diligence pour les très grandes plateformes* : publication de rapports sur les contenus retirés ou limités, description des systèmes de recommandation, mise en place de mécanismes internes de plainte et de règlements extrajudiciaires des litiges, audits indépendants. Les premières affaires instruites au titre du DSA montrent que la Commission et les autorités nationales entendent examiner la manière dont les mesures automatisées sont utilisées pour détecter, hiérarchiser ou supprimer des contenus, notamment lorsqu’il s’agit de discours politique, de désinformation ou de contenus ciblant des groupes vulnérables.
+
+Ces dispositifs produisent des *scènes quasi-judiciaires* où les plateformes doivent expliquer – au moins partiellement – *comment leurs systèmes fonctionnent, pourquoi un contenu a été retiré ou maintenu, comment les utilisateurs peuvent contester ces décisions*. Mais ici aussi, la visibilité reste partielle :
+
+- Les *décisions de l’Oversight Board* portent sur un très petit nombre de cas, choisis en fonction de leur importance symbolique ; elles n’offrent qu’un éclairage ponctuel sur la manière dont les algorithmes de Meta structurent l’exposition aux contenus.
+
+- Les *rapports de transparence exigés* par le DSA agrègent des chiffres (nombre de contenus modérés, proportion de décisions automatisées vs humaines, volumes de recours) et décrivent les systèmes de manière très synthétique, sans exposer les paramètres concrets de Système F.
+
+- Les *mécanismes de plainte et de règlement extrajudiciaire* permettent de corriger des décisions individuelles, mais ils ne s’accompagnent pas automatiquement d’une capacité pour les plaignants à déclencher une révision profonde des modèles.
+
+L’impression, du point de vue archicratique, est celle de scènes emblématiques mais parcellaires : elles jouent un rôle de vitrine et peuvent générer des inflexions importantes, mais elles ne suffisent pas à constituer un régime ordinaire de comparution pour Système F.
+
+### II.3.4. Un accès incomplet à la *cratialité* : logs, données, paramètres en pointillés
+
+Ce qui traverse toutes ces scènes, c’est la question des conditions d’accès à la *cratialité*. Pour qu’une *archicration* soit complète, il ne suffit pas que la décision soit contestable en droit ; il faut que les instruments qui la produisent puissent être amenés sur scène dans leur *structure opérationnelle* : *données d’entraînement, variables choisies, fonctions de coût, seuils, logs d’exécution, métriques d’erreurs, modifications successives*.
+
+Or la plupart des contentieux impliquant Système F se heurtent à des barrières récurrentes :
+
+- *Secret des affaires et propriété intellectuelle* : les entreprises invoquent la protection de leurs secrets industriels pour refuser de divulguer certains éléments ; les juges doivent arbitrer entre cette protection et le droit à un procès équitable, sans toujours disposer de mécanismes robustes (experts tiers, accès limité mais réel, obligations de documentation approfondie).
+
+- *Fragmentation de l’information* : même lorsque des éléments sont communiqués, ils le sont souvent par fragments – un descriptif de la finalité, une liste de variables, des extraits de code, un rapport d’audit interne – sans qu’un travail de reconstitution complète de la chaîne cratiale soit réalisé dans la procédure.
+
+- *Capacités d’expertise* : juges, avocats, autorités, associations disposent de ressources inégales pour analyser les modèles, comprendre les rapports techniques, interpréter les logs ; les plaignants individuels, eux, n’ont généralement accès qu’à des informations très abstraites sur la “logique” du traitement.
+
+- *Temporalité* : les systèmes évoluent rapidement ; au moment où un contentieux est arrivé à maturité, le modèle a parfois été modifié, remplacé, recalibré, ce qui complique la tâche de statuer sur un état donné de Système F.
+
+Le résultat, du point de vue topologique, est que la *scène judiciaire* ou *quasi-judiciaire* voit Système F, mais comme à travers une vitre dépolie : on devine une architecture, on identifie certaines variables, on mesure des effets discriminatoires ou disproportionnés, mais la mécanique fine reste hors de portée. L’*archicration est ouverte en droit, mais entravée en fait.*
+
+### II.3.5. Topologie d’une *archicration tronquée*
+
+Si l’on replace ces *scènes judiciaires et quasi-judiciaires* dans la carte tracée par la Partie II, on obtient une image contrastée :
+
+- Par rapport aux *hypotopies* des guichets et des interfaces, les tribunaux, autorités et instances quasi-judiciaires constituent un gain net : ils *offrent des procédures, des droits, des possibilités de mise en publicité, des décisions motivées, parfois des sanctions et des réparations*.
+
+- Par rapport aux *hypertopies cratiales* des comités de gouvernance interne, ils *introduisent un élément extérieur, une mise en cause par des acteurs qui ne participent pas à la conception de Système F et peuvent, au moins en partie, l’obliger à se justifier*.
+
+Mais ces scènes portent les marques d’une *archicration tronquée* :
+
+- tronquée vers l’amont, faute d’un accès systématique aux choix de design, aux fonctions de coût et aux jeux de données qui structurent Système F ;
+
+- tronquée vers l’aval, car les décisions de justice ou les recommandations quasi-judiciaires n’entraînent pas toujours une transformation profonde et durable des systèmes, mais plutôt des ajustements circonscrits, des promesses de réforme, des mesures de compensation.
+
+Topologiquement, elles occupent une position intermédiaire entre l’*hypotopie* et la *synchrotopie* : des scènes fortes, mais fragmentaires ; des moments d’*archicration*, mais sans la continuité ni la profondeur nécessaires pour transformer l’ensemble de la configuration archicratique de Système F.
+
+C’est sur cette base que la synthèse topologique (II.4) pourra être conduite : en montrant comment, entre les *hypotopies locales*, les *hypertopies cratiales* et ces *archicrations partielles*, se dessine un paysage où la scène n’est ni absente ni pleinement instituée, mais morcelée, déphasée, décalée par rapport aux lieux où la régulation algorithmique déploie effectivement ses effets.
+
+## II.4. Synthèse topologique
+
+L’épreuve de détectabilité avait permis de montrer comment Système F distribue, dans ses différents segments, *arcalités déclarées et implicites*, *cratialités en chaîne* et *archicrations lacunaires*. L’épreuve topologique révèle maintenant que cette distribution n’est pas homogène : elle prend la forme d’une dégradation structurée de la scène. Si l’on reprend les catégories introduites au chapitre 1 – synchrotopies, hypotopies, hypertopies, atopies – on constate que Système F se déploie dans un espace où la synchrotopie archicratique (scènes tenues, denses en prises, ouvertes à des publics pluriels) est quasiment absente, tandis que trois configurations dominent :
+
+- *aux points de contact avec les personnes affectées* (guichets, interfaces, formulaires de recours, feedbacks), des *hypotopies* et des *atopies* : scènes pauvres en prises sur la régulation algorithmique, ou pseudo-scènes où l’on joue la participation sans prise réelle sur Système F ;
+
+- *au centre de gravité organisationnel* (comités de pilotage, boards techniques, cellules de gouvernance de l’IA, unités de conformité), des *hypertopies cratiales* : scènes très denses en prises, mais fermées, réservées à des cercles d’experts et de décideurs ;
+
+- dans les *arènes de mise en cause* (tribunaux, autorités, instances quasi-judiciaires), des *archicrations partielles* : scènes fortes mais fragmentaires, où Système F apparaît souvent en silhouette, faute d’accès complet à sa *cratialité*.
+
+Autrement dit, le système IA typifié par Système F est bien un dispositif scénique, mais topologiquement dégradé. La scène n’a pas disparu ; elle a été déplacée, concentrée, morcelée. Les *hypotopies locales* rendent la présence de Système F sensible (un refus, un classement, un retrait, une notation), sans offrir de prise pour contester la manière dont ces effets sont produits. Les *hypertopies institutionnelles* prennent en charge la “*mise en forme*” du pouvoir algorithmique (design, paramétrage, gestion des risques), mais en maintenant les publics affectés à distance. Les *scènes judiciaires et quasi-judiciaires* rouvrent ponctuellement l’espace de contestation, sans parvenir à transformer cette intermittence en régime ordinaire de comparution.
+
+Ce paysage répond exactement au diagnostic posé dans l’essai-thèse, concernant l’*autarchicratie* : un *méta-régime où la régulation tend à devenir son propre juge, où les appareils de calcul, de standardisation et de pilotage se ferment sur eux-mêmes, en reléguant la scène – au sens démocratique – à des marges appauvries (recours individuels, formulaires, feedbacks) ou à des épisodes de crise (scandales, contentieux emblématiques).* L’IA de fondation intégrée à des chaînes de décision publiques et privées ne crée pas *ex nihilo* cette configuration ; elle intensifie des tendances déjà à l’œuvre dans les méta-régimes techno-logistique, scripturo-bureaucratique et marchand : *externalisation des arbitrages dans des infrastructures techniques*, *multiplication de points de contact sans véritable scène*, *concentration des décisions structurantes dans des cénacles spécialisés*.
+
+Du point de vue archicratique, cette topologie a deux conséquences majeures. Premièrement, elle explique pourquoi la critique de Système F oscille souvent entre deux registres incomplets : une *dénonciation des effets* (biais, injustices, opacités) *qui reste prisonnière des hypotopies locales*, et une *focalisation sur les normes juridiques et les principes éthiques dans les hypertopies de gouvernance*, sans que les deux niveaux se rencontrent vraiment dans une scène commune.
+
+Deuxièmement, elle montre que la question d’une *politique des épreuves viables*, telle que proposée dans la conclusion de la thèse, ne peut pas se réduire à ajouter des procédures ou des principes ; elle suppose un *reprofilage topologique* : épaissir certaines scènes, en ouvrir d’autres, *désaturer les hypertopies*, *relier les archicrations judiciaires aux expériences des guichets et des interfaces*.
+
+On peut résumer cette configuration sous la forme d’un tableau, qui n’est pas une grille normative, mais une carte de travail pour la suite du cas pratique :
+
+| Type de scène | Rôle pour les personnes concernées | Prise arcalité (A) | Prise cratialité (C) | Prise archicration (A’) | Type topo | Ouverture / fermeture |
+|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
+| Guichet / interface de service (social, santé, justice, RH, plateformes) | Lieu où l’on dépose un dossier, consulte un statut, reçoit une réponse, subit un classement, voit un contenu disparaître ou être promu | A déclarée minimale (formules de mission, messages standard) ; A implicite invisible pour l’usager | C présente par ses effets (scores, priorités, codes couleur), mais non explicitable depuis la scène | A’ quasi absente : pas de mise en épreuve du dispositif, seulement des marges de contournement informelles | Hypotopie | Ouverte aux usagers, mais pauvre en prises sur Système F |
+| Recours numériques / feedbacks (formulaires, étoiles, “signaler”) | Lieu où l’on conteste une décision, où l’on exprime une insatisfaction, où l’on “note” un service ou un contenu | A réduite à des catégories pré-codées (“motifs de recours”, items de satisfaction) | C sollicitée comme capteur (les *feedbacks* alimentent Système F), mais non exposée comme telle | A’ fantomatique : l’idée de scène est mise en forme, sans garantie de remontée vers les lieux de décision | Hypotopie / Atopie | Ouverte, mais trajectoires des contributions opaques, pouvoir réel incertain |
+| Comités de projet, boards techniques, gouvernance “IA responsable”, conformité AI Act | Lieux où se décident les cas d’usage, les architectures, les proxies, les seuils, les stratégies de déploiement, la gestion des risques | A explicite (principes internes, matrices de risques, traductions locales de normes éthiques et juridiques) | C centrale : design du modèle, choix des données, paramétrage, intégration dans les procédures | A’ potentielle mais capturée : débats et arbitrages internes, sans présence directe des publics affectés | Hypertopie cratiale | Fermée, réservée à des experts et décideurs, forte capacité de décision |
+| Scènes judiciaires et quasi-judiciaires (tribunaux, autorités, régulateurs, Oversight Board) | Lieux où l’on conteste des effets de Système F (refus, discriminations, censures), où des obligations sont interprétées et imposées | A reconstituée a posteriori : qualification juridique, examen des finalités, rappel des droits fondamentaux | C partiellement accessible : éléments techniques communiqués par fragments, sous contraintes de secret et de compétence | A’ réelle mais tronquée : procédure contradictoire, décisions motivées, sans accès systématique à l’ensemble de la chaîne cratiale | Entre hypotopie et synchrotopie | Semi-ouverte : accès conditionné, forte institutionnalisation, capacité d’inflexion mais intermittente |
+
+Ce tableau ne remplace pas l’analyse, il la condense. Il fait apparaître, d’un seul coup d’œil, le motif central : Système F s’inscrit dans un régime où les *scènes ouvertes aux personnes concernées sont topologiquement appauvries* (*hypotopies* et *atopies*), tandis que les *scènes riches en prises se trouvent concentrées dans des hypertopies cratiales et régulatoires qui restent largement hors de leur portée*. Les *scènes judiciaires et quasi-judiciaires* jouent un rôle d’*intermédiation*, mais sans parvenir, dans l’état actuel des choses, à recomposer une *synchrotopie archicratique co-viable*.
+
+Cette carte topologique ne surgit pas de nulle part : elle condense des motifs déjà repérés dans les méta-régimes techno-logistique, scripturo-bureaucratique et marchand. La Partie III se donnera précisément pour tâche de replacer Système F dans cette archéogénèse, afin de montrer que l’IA n’inaugure pas un monde entièrement nouveau, mais recombine des puissances régulatrices déjà à l’œuvre – en les poussant vers un méta-régime *autarchicratique numérique*.
+
+La suite du cas pratique pourra s’appuyer sur cette synthèse topologique pour deux mouvements complémentaires : replacer ce paysage dans l’*archéogénèse des méta-régimes régulateurs* (Partie III), puis explorer ce que signifierait, concrètement, une réouverture archicratique de Système F, c’est-à-dire une transformation simultanée des prises (A/C/A’) et des lieux (topologie scénique) dans lesquels se joue sa puissance régulatrice.
+
+##

src/content/cas-ia/chapitre-3.mdx

@@ -0,0 +1,352 @@
+---
+title: "Chapitre III — Épreuve archéogénétique"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 40
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_3_Epreuve_archeogenetique.docx"
+---
+# III. Épreuve archéogénétique : dans quels méta-régimes s’inscrit l’IA ?
+
+La première et la deuxième épreuve ont traité Système F comme un *dispositif présent* : un système d’IA déjà à l’œuvre, que l’on peut décrire dans sa structure (*arcalité* / *cratialité* / *archicration*) et dans la forme de ses scènes (*hypotopies*, *hypertopies*, *atopies*). L’épreuve archéogénétique change de focale : il ne s’agit plus de dire *comment* Système F fonctionne aujourd’hui, mais *de quelle histoire régulatrice il procède*, à quels méta-régimes il emprunte ses formes, ses réflexes, ses manières de distribuer les prises.
+
+Dans notre thèse, l’archéogénèse désigne ce geste qui consiste à lire un *dispositif* comme une *sédimentation de régimes de co-viabilité* : on n’y cherche pas une origine unique, ni un “moment zéro” mythique, mais la composition singulière de matrices plus anciennes – techno-logistique, scripturo-bureaucratique, marchande, guerrière, sacrale, etc. – qui continuent d’agir sous des habits techniques nouveaux. Appliquée à Système F, l’épreuve archéogénétique doit donc répondre à une question simple, mais exigeante :
+
+*un grand système d’IA de fondation, intégré dans la décision sociale, sanitaire, pénale, organisationnelle, de quoi est-il le prolongement ?*
+
+La tentation, dans le débat public, est double. D’un côté, le *discours d’inédit radical* : l’IA serait une rupture absolue, un changement de civilisation sans précédent, qui rendrait caduques les catégories héritées. De l’autre, la *rhétorique de la simple continuité* : “au fond, ce n’est qu’une bureaucratie un peu plus automatisée”, “un marché un peu plus *data-driven*”, “une mise à jour technique de la *mégamachine*”. L’épreuve archéogénétique vise précisément à sortir de cette alternative : elle montre que Système F est à la fois héritier et re-composeur de plusieurs méta-régimes, sans se réduire à l’un d’eux.
+
+Dans le cas qui nous occupe, trois filiations sont particulièrement décisives.
+
+1.  La *filiation techno-logistique*  
+    La thèse a décrit le méta-régime techno-logistique comme celui de la *mégamachine* : un agencement où la priorité est donnée à la circulation des flux, à la coordination impersonnelle, aux chaînes d’acheminement et de traitement, plutôt qu’aux figures individuelles. Le pouvoir régulateur se manifeste par la capacité à organiser des flux de matières, de corps, d’informations, d’ordres, à travers des réseaux de transport, d’énergie, de communication.
+
+    De ce point de vue, Système F apparaît d’emblée comme un descendant direct : il opère en priorisant des flux de dossiers, de cas, de contenus, de candidatures ; il optimise des pipelines de traitement ; il pilote à partir d’indicateurs agrégés (scores de risque, taux de fraude détectée, coûts de santé anticipés, KPIs de modération ou d’engagement). L’IA, ici, ne vient pas “ajouter de l’intelligence” à un monde neutre : elle *prolonge et intensifie une logique techno-logistique* où l’important n’est pas tel allocataire, tel patient, tel justiciable, mais la *performance globale d’une chaîne de traitement*.
+
+2.  L’*hybridation scripturo-bureaucratique*.  
+    Un second méta-régime, présent de manière tout aussi centrale, est celui de la *scripturo-bureaucratie* : l’ordre qui se construit à partir de normes écrites, de formulaires, de dossiers, de grilles. Là où la *mégamachine* gère des flux, la *bureaucratie scripturale* *produit des dossiers* et des archives : des ensembles de traces écrites qui autorisent, refusent, indexent, codent les positions des individus et des collectifs.
+
+    Système F ne remplace pas cette logique ; il l’encode à un second degré. Les catégories, les critères, les rubriques, les codes qui structuraient les dossiers deviennent des variables dans des tables, des vecteurs dans des espaces de représentation, des *embeddings* dans des modèles. Les procédures écrites se transforment en *workflows* numériques ; les classifications manuelles en opérations de *clustering* et de *scoring*. La *cratialité scripturo-bureaucratique* n’est pas abolie : elle est internalisée dans les modèles eux-mêmes, qui apprennent à reproduire et à recomposer les distinctions produites par des décennies de pratique documentaire.
+
+3.  L’*inscription dans le méta-régime marchand*.  
+    Enfin, Système F s’inscrit pleinement dans le méta-régime marchand : pas seulement parce que de nombreux modèles sont fournis par des entreprises privées, via des services payants, mais parce que sa logique d’optimisation est souvent couplée à la monétisation des flux. Les plateformes l’utilisent pour segmenter des publics, orienter des trajectoires de consommation, maximiser l’engagement ; les entreprises y recourent pour ajuster leurs politiques de recrutement, de tarification, de gestion des risques ; les fournisseurs d’IA eux-mêmes modèlent leur offre en fonction de marchés, de contrats, de parts de clientèle.
+
+    L’IA ne vient pas “marchandiser” un espace neutre : elle s’insère dans des chaînes où la captation de valeur passe par la capacité à prédire, trier, profiler, personnaliser. Ce que Système F ajoute, c’est une *capacité généralisée à produire des scores, des profils, des recommandations qui deviennent immédiatement échangeables sur des marchés de services* : scoring de risque vendu à des administrations, API de modération vendues à des plateformes, modules de tri de CV vendus à des DRH.
+
+L’épreuve archéogénétique doit donc prendre acte de cette triangulation : Système F est un point de croisement intense entre *mégamachine* *techno-logistique*, *scripturo-bureaucratie* et régime *marchand*. Il ne naît pas dans le vide ; il recompose ces trois matrices en un dispositif qui, à son tour, exerce une force de restructuration sur elles.
+
+Mais l’enjeu de la Partie III n’est pas uniquement d’assigner Système F à ces trois parentés. Il est aussi de travailler l’hypothèse, esquissée dans la conclusion de la thèse, selon laquelle nous verrions se dessiner, avec ce type de dispositif, les traits d’un *méta-régime autarchicratique numérique*.
+
+Par *autarchicratie*, la thèse désigne un régime où la régulation tend à devenir son propre principe de légitimation : les indicateurs, modèles, standards et procédures ne se contentent plus d’appliquer des normes préexistantes ; ils deviennent eux-mêmes les critères de validité de l’ordre qu’ils instaurent. Les performances mesurées par les instruments suffisent à démontrer la pertinence des instruments ; les boucles d’audit restent à l’intérieur du dispositif ; les scènes externes de justification (parlement, espace public, conflits sociaux) sont reléguées à l’arrière-plan.
+
+L’hypothèse que nous allons explorer est la suivante :
+
+*en cristallisant la filiation techno-logistique, l’encodage scripturo-normative et l’ancrage marchand dans un système d’IA de fondation, Système F contribue à faire émerger une forme d’autarchicratie numérique, où les métriques internes (loss, accuracy, KPIs) deviennent la principale arcalité pratique, où les boucles de rétroaction se referment sur le dispositif lui-même, où les scènes externes d’épreuve sont marginalisées ou transformées en simulacres.*
+
+Dans ce cadre, la Partie III suit quatre fils étroitement entrelacés. Elle commence par ressaisir la filiation *techno-logistique* de Système F : la manière dont il s’inscrit dans la *mégamachine* des flux, des indicateurs et des priorisations, en prolongeant des formes de pilotage déjà bien installées. Elle se tourne ensuite vers la configuration *scripturo-normative*, en montrant comment des catégories juridiques et bureaucratiques sont traduites à un deuxième degré dans des espaces vectoriels, des fonctions de coût et des chaînes automatisées. Elle examine, en troisième lieu, l’ancrage *marchand* du dispositif, comme service vendu, comme infrastructure privée, comme opérateur de segmentation et de captation de valeur. Enfin, elle propose, à partir de cette triple inscription, une hypothèse archéogénétique plus risquée : celle d’un *méta-régime autarchicratique numérique*, où des dispositifs d’IA se jugent et s’ajustent de plus en plus à l’aune de leurs propres métriques, en marginalisant les scènes externes d’épreuve. L’enjeu n’est pas de décréter l’avènement spectaculaire d’un “nouveau régime”, mais de vérifier, au plus près des chaînes cratiales que nous avons décrites, si la composition singulière opérée par Système F justifie ou non que l’on parle d’un tournant *autarchicratique*, plutôt que d’un simple prolongement des régimes existants.
+
+## III.1. Filiation techno-logistique
+
+Dans la cartographie des méta-régimes établie par la thèse, le régime techno-logistique désigne un mode de *co-viabilité* où le pouvoir régulateur se formule d’abord comme art de la circulation : art de faire passer des flux – de marchandises, de corps, d’ordres, de données – à travers des réseaux et des infrastructures, en minimisant les frictions, les délais, les “pertes”. La figure de la *mégamachine* n’est pas ici un simple motif rhétorique : elle renvoie à ces *assemblages où des dispositifs matériels* (routes, voies ferrées, réseaux électriques, systèmes d’information), *des organisations* (entreprises, administrations, armées) *et des routines calculatoires* (plannings, calcul d’itinéraires, plans de charge, tableaux de bord) *se combinent pour piloter des flux à grande échelle*.
+
+Dans ce méta-régime, la *cratialité* se concentre dans des *chaînes de transport et de traitement* : chaînes logistiques, chaînes de production, chaînes de commande. L’*arcalité* pratique se résume souvent à quelques axiomes : fluidité, continuité, “juste à temps”, optimisation des capacités. Ce qui compte n’est pas telle personne, tel cas singulier, mais la *performance globale d’un enchaînement* : nombre de conteneurs déchargés par heure, longueur moyenne des files d’attente, taux de rotation des stocks, ponctualité des convois. Les scènes d’épreuve se déplacent vers des salles de contrôle où l’on surveille des courbes, des alarmes, des cartes, plutôt que vers des assemblées où des personnes viennent plaider leur cause.
+
+Système F, lu dans cette perspective, apparaît immédiatement comme un héritier direct de cette *rationalité techno-logistique* – mais transposée dans le domaine de la décision sociale, sanitaire, pénale, organisationnelle et informationnelle. Ce qu’il traite, ce ne sont plus des palettes ou des conteneurs, mais des flux de dossiers, de profils, de contenus : demandes de prestations, patients en attente, justiciables, candidats, messages et publications en ligne. Et ce qu’il promet, du point de vue de ses promoteurs, c’est précisément ce que la *mégamachine* promettait aux réseaux matériels : *réduire les encombrements, absorber des volumes croissants sans augmenter autant les moyens humains, orienter les flux vers les “bonnes” voies en temps quasi réel*.
+
+### III.1.1. Priorisation de flux : des dossiers et des contenus comme trafic à gérer
+
+Dans les scènes reconstruites en Partie I, Système F n’apparaît jamais comme un oracle solitaire ; il opère toujours dans une *file*. File de dossiers à instruire dans une caisse sociale, file de patients à voir dans un service hospitalier, file de cas judiciaires, file de candidatures à examiner, file de contenus à modérer ou à recommander. À chaque fois, la promesse implicite est la même : *ordonner cette file mieux que ne le feraient des règles fixes ou l’appréciation locale des agents*.
+
+Dans la protection sociale, un module dérivé de Système F réorganise la file des demandes ou des révisions : plutôt que de suivre strictement l’ordre chronologique, l’interface affiche les dossiers dans l’ordre d’un “*risque de fraude*” ou d’une “*urgence*” calculés. Dans la santé, la liste d’attente pour une consultation spécialisée ou un examen lourd est triée selon un *indice de priorité* : certains patients remontent, d’autres descendent. Dans les ressources humaines, des milliers de CV sont avalés par un pipeline d’analyse qui attribue des scores de “*pertinence*”, avant même qu’un recruteur ne pose les yeux sur une candidature. Sur les plateformes, les contenus sont continuellement rangés, promus, enfouis, retirés, sur la base de signaux agrégés et de modèles qui décident de ce qui doit être vu, par qui, et à quel moment.
+
+Ce mouvement de priorisation des flux constitue le cœur techno-logistique de Système F. La question n’est plus seulement “*qui a droit à quoi ?*”, “*quel contenu est licite ?*”, “*quel profil est qualifié ?*”, mais “*à quel rang ce dossier, ce contenu, cette personne doit-il se trouver dans la file que nous avons à traiter ?*”. La régulation prend la forme d’un tri continu, où la position relative dans une file – d’attente, de contrôle, de visibilité – devient la modalité concrète de l’accès aux droits, aux soins, aux opportunités, à la parole publique. Dans cette logique, *l’individu apparaît moins comme sujet de droit que comme un élément de trafic*, qu’il s’agit d’acheminer vers une issue ou une autre selon un calcul.
+
+Archicratiquement, on peut dire que Système F transpose dans le champ normatif la logique des grands centres de tri : ce qui était mis en file pour être livré devient mis en file pour être traité, contrôlé, exposé ou invisibilisé. Les flux priment sur les figures.
+
+### III.1.2. Optimisation de pipelines : de la procédure au “flux de traitement”
+
+La *mégamachine techno-logistique* n’optimise pas seulement des files ; elle assemble des chaînes : succession d’opérations, de nœuds, de relais, de délais, qui transforment des entrées en sorties. Cette logique se retrouve à nu dans les architectures de Système F.
+
+Pour qu’un dossier social devienne un vecteur numérique interprétable par un modèle, il traverse une *série de transformations* : *collecte initiale des informations, vérification de complétude, codage dans des formats standardisés, enrichissement par des données externes, extraction de caractéristiques* (*features*), *passage dans un ou plusieurs modèles, agrégation de scores, restitution dans un tableau de bord*. Il en va de même pour un historique médical, un cas judiciaire, un parcours professionnel, un flux de contenus : chaque trajectoire est *pipelinée* – *découpée en étapes où la matière première* (une situation vécue, une interaction, un récit) *est peu à peu transmutée en données, puis en signaux de décision*.
+
+Du point de vue des équipes techniques, le vocabulaire le dit sans détour : on parle de “*pipelines de données*”, de “*chaînes de traitement*”, d’“*orchestrateurs*” qui déclenchent automatiquement telle ou telle étape (nettoyage, normalisation, scoring, persistance dans une base, émission d’un événement, mise à jour d’un tableau de bord). La “*mise en production*” d’un modèle consiste à l’*inscrire dans un flux de traitements* où il deviendra une *étape parmi d’autres* : on lui fournit des entrées, il produit des sorties qui alimentent à leur tour d’autres opérations (alertes, reclassements, notifications, déclenchement de contrôles).
+
+C’est ici que la filiation techno-logistique devient particulièrement nette. Là où la bureaucratie scripturale se représentait plutôt sous la forme de procédures (succession de gestes codifiés, décrits dans des textes), la *rationalité techno-logistique*, reprise par Système F, se donne plutôt comme *gestion de flux* : on *conçoit des enchaînements automatiques où des paquets d’informations circulent de module en module, sous la surveillance d’indicateurs globaux de performance*.
+
+Cette *pipelinisation* a deux effets archicratiques majeurs. D’une part, elle *renforce la cratialité* : une fois le flux déroulé, l’espace de bifurcation laissé à l’appréciation locale se réduit, l’intervention humaine vient en “exception” (lorsqu’un score dépasse un seuil, lorsqu’une alerte est déclenchée, lorsqu’un cas est signalé comme atypique). D’autre part, elle rend encore plus difficile la *localisation de la responsabilité* : *où, dans un pipeline, se situe le moment où il aurait fallu décider autrement ? À quelle étape se loge l’arcalité implicite qui privilégie tel type d’erreur plutôt qu’un autre ?*
+
+Dans la filiation techno-logistique, la décision n’est plus un moment isolé dans un bureau ; elle devient propriété émergente d’un flux de traitement.
+
+### III.1.3. Pilotage par indicateurs : la *mégamachine* normative
+
+Enfin, la *mégamachine techno-logistique* se reconnaît à son attachement aux *indicateurs* : *temps moyen de traitement, taux d’utilisation d’une infrastructure, niveau de stock, “on time performance”*. C’est par ces indicateurs que les responsables évaluent, ajustent, justifient leurs choix. Système F n’échappe pas à cette logique ; il la pousse même à un degré supplémentaire.
+
+D’un côté, Système F est fabriqué à partir d’indicateurs. Les modèles sont optimisés en fonction de métriques (loss, accuracy, AUC, F1-score, etc.), qui condensent en un chiffre la qualité de la prédiction ou du classement. Les équipes comparent des versions de modèle en fonction de ces métriques, décident de déployer tel modèle plutôt qu’un autre, surveillent en production la dérive éventuelle de ces indicateurs. À ce niveau, les critères de succès sont eux-mêmes le produit d’une *arcalité implicite* : *ce que l’on cherche à minimiser* (une perte, un coût, un type d’erreur) *ou à maximiser* (un taux de détection, un gain, un engagement).
+
+De l’autre côté, Système F devient instrument de pilotage pour les organisations qui l’emploient. Les directions de caisses sociales se voient présenter des tableaux de bord indiquant le nombre de dossiers “à risque” détectés, la proportion de fraudes confirmées après contrôle, les économies budgétaires attendues. Les directions hospitalières suivent des indicateurs de “gestion de patientèle”, de flux aux urgences, de taux d’occupation des lits, couplés à des scores issus de modèles prédictifs. Les ministères de la justice peuvent consulter des distributions de scores de risque, des taux de récidive par catégorie, des comparaisons entre juridictions. Les responsables de plateformes examinent des métriques de contenus supprimés, de signalements traités, d’engagement des utilisateurs dans des contextes où les contenus sont plus ou moins fortement modérés ou recommandés.
+
+Dans ces configurations, l’IA ne se contente pas de “fournir une aide” à des décisions individuelles ; elle reconfigure les instruments de la décision collective. Ce qui devient discutable, dans les comités de direction et les arbitrages budgétaires, ce ne sont plus seulement des principes (“*faut-il renforcer la lutte contre la fraude ? réduire les inégalités d’accès aux soins ? favoriser la réinsertion ?*”) mais des courbes, des pourcentages, des écarts à des cibles. La scène où se décide la trajectoire de Système F est alors saturée d’indicateurs, issus… de Système F lui-même ou de dispositifs similaires.
+
+On touche ici du doigt la frontière avec l’*autarchicratie* que la section III.4 interrogera explicitement. La *filiation techno-logistique se manifeste dans ce phénomène : les indicateurs destinés à piloter les flux deviennent progressivement les critères de validité du dispositif*. Un système est jugé “bon” s’il améliore ses propres métriques – quitte à ce que ces métriques reflètent des arbitrages invisibles sur ce qu’il est acceptable de perdre, de détourner, de faire attendre, de rendre invisible.
+
+### III.1.4. Lecture archicratique de la filiation techno-logistique
+
+Lire Système F comme héritier du méta-régime techno-logistique ne revient donc pas à plaquer un vocabulaire de plus sur l’IA ; cela permet de comprendre pourquoi la régulation par IA prend cette forme particulière :
+
+- Une *régulation par files* : parcours des dossiers, des patients, des contenus, moins comme trajectoires de sujets que comme mouvements dans un trafic à gérer.
+
+- Une *régulation par chaînes* : pipelines de traitement où la décision résulte de l’enchaînement d’opérations disposées à distance les unes des autres.
+
+- Une *régulation par indicateurs* : instruments de pilotage qui condensent dans quelques chiffres des arbitrages normatifs lourds, tout en se présentant comme des mesures neutres.
+
+Archicratiquement, cette filiation explique au moins trois traits mis en évidence dans les parties I et II : la *puissance cratiale de Système F* (il est conçu pour agir massivement, en continu, sur des flux), la *pauvreté des scènes locales* (*hypotopies* du guichet et des interfaces, réduites à des points de passage dans un flux piloté ailleurs), et la *concentration des scènes d’arbitrage dans des hypertopies où l’on ajuste, en cercle restreint, les paramètres d’une mégamachine normative*.
+
+C’est à partir de ce socle techno-logistique que les sections III.2 et III.3 pourront montrer comment Système F encode la scripturo-bureaucratie et s’adosse au méta-régime marchand, avant que III.4 ne revienne sur la question centrale : l’agrégation de ces filiations suffit-elle à parler d’un nouveau *méta-régime autarchicratique numérique*, ou avons-nous affaire à une intensification extrême d’un techno-logisme déjà ancien ?
+
+## III.2. Filiation *scripturo-normative* : gouvernement par l’écrit et formes bureaucratiques
+
+La filiation techno-logistique de Système F éclaire sa manière de traiter des flux. Mais ces flux sont toujours déjà écrits : ils passent par des formulaires, des dossiers, des registres, des grilles, des systèmes d’information. Pour comprendre ce que fait l’IA au pouvoir régulateur, il faut donc la replacer dans l’*archicratie scripturo-normative*.
+
+### III.2.1. Le méta-régime scripturo-normatif : gouverner par l’écrit
+
+Dans la typologie de l’essai-thèse, l’*archicratie scripturo-normative* désigne le méta-régime où la régulation repose d’abord sur la *mise en écriture des obligations* : lois, codes, décrets, contrats, règlements, formulaires, décisions, procès-verbaux, grilles. La contrainte ne tient plus principalement au serment, à la présence rituelle, à l’incorporation charismatique ; elle tient à des *énoncés inscrits* et à la *capacité d’y rapporter des situations singulières*.
+
+La *cratialité* y prend la forme d’*appareils scripturaux* : bureaux, greffes, services d’archives, guichets, fichiers, systèmes de classification. On gouverne en prescrivant des textes, en collectant des pièces, en formant des dossiers, en apposant des visas, des tampons, des signatures. L’*arcalité* se loge dans la prétention de ces textes à dire le droit, à fixer les conditions légitimes d’accès à des prestations, à des ressources, à des statuts. L’*archicration* proprement *scripturo-normative* se déploie dans des scènes où l’on vient “avec son dossier” : contentieux, commissions, audiences, procédures de réclamation, où les écrits peuvent être produits, discutés, requalifiés.
+
+Les formes bureaucratiques modernes – administrations d’État, caisses de sécurité sociale, systèmes judiciaires codifiés, grandes organisations managériales – constituent une cristallisation historique particulièrement dense de cette *archicratie scripturo-normative* : *multiplication des formulaires*, des *codes*, des *fichiers*, des *grilles d’évaluation*, des *bases de données* qui prolongent les *registres* et les *archives*. C’est à l’intérieur de cette couche historique que Système F vient s’insérer.
+
+### III.2.2. Système F comme “scripturo-normativité de second degré”
+
+Empiriquement, Système F ne s’applique jamais à un monde brut : il intervient dans des environnements déjà structurés par des écritures normatives.
+
+- Dans la protection sociale, les conditions d’éligibilité, les types de prestations, les obligations déclaratives sont définies par des textes ; les demandes sont saisies dans des formulaires, conservées dans des systèmes de dossiers ; les contrôles laissent des traces écrites.
+
+- Dans la justice pénale, les qualifications juridiques, les peines, les mesures de sûreté sont encadrées par des codes ; les décisions sont motivées, rédigées, archivées.
+
+- Dans la santé, les droits des patients, les obligations des établissements, les modalités de remboursement sont fixés par des corpus normatifs ; les parcours de soins sont documentés dans des dossiers médicaux.
+
+- Dans le recrutement, les positions, les grilles de classification, les procédures d’embauche, les rapports d’évaluation sont également pris dans des scripts écrits, qu’ils soient juridiques, conventionnels ou managériaux.
+
+Lorsque Système F est introduit dans une caisse sociale, un tribunal, un hôpital, un service de ressources humaines, il commence par absorber ce monde *scripturo-normatif*. Les catégories administratives deviennent des champs dans des bases de données ; les rubriques des formulaires, des variables ; les décisions passées, des étiquettes (“accepté / refusé”, “fraude avérée / non avérée”, “libération accordée / refusée”) ; les textes libres (motivations, notes, comptes rendus), des corpus. Le modèle est entraîné sur ces matériaux : il apprend à associer des configurations de champs, de codes, de textes à des issues qui ont déjà été décidées.
+
+De ce point de vue, Système F ne supprime pas l’*archicratie scripturo-normative* ; il en opère une seconde couche. Là où les administrations mettaient en forme le monde social par des formulaires et des dossiers, Système F met en forme ces formulaires et ces dossiers eux-mêmes : il ne crée pas une régulation entièrement nouvelle, il produit une scripturo-normativité de second degré, qui prend pour objet les traces normatives accumulées.
+
+On pourrait dire, sans exagération, que Système F est un fonctionnaire qui a lu tous les dossiers – et qui, à partir de là, extrapole des manières de classer, de trier, de qualifier, sans repasser à chaque fois par la lecture humaine des textes normatifs.
+
+### III.2.3. Encodage de second degré : de la case au vecteur, du dossier au score
+
+Ce passage au second degré se joue dans les opérations d’encodage.
+
+Les univers *scripturo-normatifs* se présentent d’abord sous la forme de catégories explicites : types de famille, de contrat, de pathologie, de peine, de diplôme, de poste, définis et stabilisés dans des nomenclatures, des grilles, des instructions. Pour que Système F fonctionne, ces catégories sont traduites en *représentations numériques* : *variables binaires ou catégorielles*, *indicateurs agrégés* (nombre de passages aux urgences, montant total perçu, durée d’un contrat, etc.), mais aussi, de plus en plus, *représentations denses de textes* (paragraphe de motivation, lettre de candidature, observation sociale, note clinique) dans des espaces où la proximité n’est plus celle de la grammaire, mais celle de la *ressemblance statistique*.
+
+À ce premier niveau d’encodage s’ajoute un *niveau de classification et de scoring*. Système F apprend, à partir des décisions antérieures, à associer ces vecteurs à des issues : “demandes à contrôler en priorité”, “patients à inscrire dans un programme intensif”, “prévenus à haut risque de récidive”, “candidatures à retenir”, “contenus à signaler”. Là où la *scripturo-normativité* classique appliquait des catégories juridiques ou réglementaires, Système F produit des catégories probabilistes : des scores, des rangs, des clusters qui n’ont pas de définition explicite dans un texte, mais qui structurent néanmoins l’action.
+
+Ce double encodage – *des catégories explicites vers des vecteurs, des décisions passées vers des scores* – fait de Système F un moteur de *recomposition scripturo-normative*. Les distinctions juridiques et administratives continuent d’exister, mais elles se trouvent réinscrites dans un espace latent où elles sont pondérées, combinées, couplées à d’autres signaux. Les règles écrites cessent d’être le seul repère ; elles deviennent une composante d’un paysage plus large, où ce qui compte est ce que le modèle parvient à prédire.
+
+### III.2.4. Effets sur l’*arcalité* : des normes textuelles aux normes “apprises”
+
+Du point de vue archicratique, cela transforme la manière dont la fondation (*arcalité*) se manifeste.
+
+Dans l’*archicratie scripturo-normative* classique, la norme se donne sous la forme d’un texte : article de loi, clause contractuelle, règlement intérieur, circulaire, instruction. On peut remonter vers ce texte, l’interpréter, en opposer l’application, en discuter la légitimité située et spécifique. Même lorsque la norme est contestable, elle existe comme surface de projection du conflit : des acteurs peuvent s’affronter sur la lisibilité, la cohérence, la justice d’un énoncé inscrit.
+
+Avec Système F, une part croissante de la normativité se déplace vers des structures apprises. Les catégories administratives restent nécessaires – ce sont elles qui déterminent formellement les droits – mais les décisions concrètes sont de plus en plus médiées par des scores qui reflètent des arbitrages implicites : importance relative de certains critères, compromis entre types d’erreurs, usage de proxys, hiérarchie des risques.
+
+Ces *arbitrages* ne sont pas rédigés dans un texte. Ils résultent de *choix techniques* (fonctions d’objectif, métriques, paramètres) *pris dans des équipes mixtes* (juristes, statisticiens, informaticiens, managers), *puis stabilisés dans des modèles que l’on évalue en termes de performance globale*. L’*arcalité* pratique se trouve ainsi en partie réécrite : ce qui fonde, en fait, la décision, ce n’est plus seulement “l’article X de tel code”, mais “le modèle Y qui, compte tenu des données disponibles, optimise tel indicateur”.
+
+La filiation *scripturo-normative* ne disparaît pas – l’IA n’agit jamais sans cadre légal –, mais elle est secondarisée : *l’écrit juridique est relégué au rang de contrainte de bord, tandis que la vraie scène de fondation se joue dans la définition des objectifs de modèle, des jeux de données, des seuils de déclenchement*. L’*arcalité* se déplace de la page vers la *configuration d’un dispositif*, sans pour autant être reconnue comme telle.
+
+### III.2.5. Amplification de la *cratialité* scripturale et éloignement de la scène
+
+Sur le plan de la *cratialité*, Système F agit comme un formidable *amplificateur de l’archicratie scripturo-normative*. Tout ce qui était déjà scriptural – formulaires, dossiers, registres, archives – devient matière première pour une *redistribution automatisée des positions*. Là où, auparavant, des agents lisaient des dossiers au rythme limité d’un humain, les organisations peuvent désormais confier à des modèles le tri préliminaire, le repérage des “cas à risque”, la hiérarchisation des urgences, la détection des anomalies.
+
+Cette *amplification cratiale* se traduit par une *capacité accrue à intensifier des pratiques déjà existantes* : contrôles ciblés, priorisation de certains patients, filtrage de candidatures, modération de contenus. La *scripturo-normativité* ne perd rien de son emprise ; elle gagne au contraire en portée et en vitesse. Les catégories et les historiques accumulés par les bureaucraties deviennent les briques d’une normativité appliquée à grande échelle, en continu, par Système F.
+
+Mais ce gain de puissance se paie par un éloignement supplémentaire de la scène. Dans les scènes classiques de l’*archicration scripturo-normative* – audience, commission, recours – il était encore possible, au moins en principe, de mettre les écritures en jeu : demander à voir le barème, contester la pertinence d’une case, produire un document qui infirme un autre. Même si les inégalités de ressources rendaient cet idéal souvent inaccessible, la structure était là : la norme scripturale pouvait être convoquée, interprétée, attaquée.
+
+Avec Système F, une part décisive de la décision est prise dans un espace infra-textuel. L’agent qui annonce un refus, un classement à risque, une priorité abaissée, ne dispose pas toujours des éléments qui permettraient au citoyen, au patient, au justiciable, au candidat de questionner le dispositif. L’explication se réduit souvent à des formules vagues (“votre dossier a été considéré comme présentant un risque élevé”, “vous ne répondez pas aux critères d’éligibilité”, “votre dossier est en cours de traitement”) sans que les choix d’encodage, de pondération, de seuil puissent être explicités et mis en scène, et ce, malgré les FAQ et les assistants dits intelligents.
+
+L’*archicration scripturo-normative* se trouve ainsi désarticulée : la scène subsiste formellement (il existe encore des voies de recours, des audiences, des commissions), mais l’objet de la contestation échappe largement au cadre scriptural. *Ce n’est plus uniquement le texte qu’il faudrait discuter, mais la manière dont ce texte a été incorporé dans un modèle, associé à d’autres signaux, converti en score*. Or cette incorporation n’a pas, à ce stade, de scène propre.
+
+### III.2.6. Lecture archicratique de la filiation *scripturo-normative*
+
+Relue depuis la thèse, la filiation *scripturo-normative* de Système F peut donc se formuler ainsi :
+
+- Système F est intégralement pris dans l’*archicratie scripturo-normative* : il ne travaille que parce qu’il existe déjà des textes, des dossiers, des grilles, des archives. Il est un dispositif de second degré qui apprend à partir de ces écritures et les recompose.
+
+- Il *amplifie la cratialité scripturale* : capacité de classer, de filtrer, de corréler, de segmenter à partir d’écritures ; puissance accrue de l’État et des organisations à traiter des masses de dossiers, de cas, de contenus.
+
+- Il *déplace l’arcalité* : une part substantielle des fondements effectifs glisse des normes textuelles vers les objectifs et les architectures de modèles, sans être reconnue ni instituée comme telle.
+
+- Il *éloigne la scène* : ce qui pourrait faire l’objet d’une *archicration scripturo-normative* (discours public sur les catégories, les barèmes, les seuils) est partiellement *refoulé dans l’espace des configurations techniques, des métriques de performance, des arbitrages d’entraînement*.
+
+Cette filiation, jointe à la dimension techno-logistique dégagée en III.1, prépare directement l’analyse de III.3 : c’est parce que *la régulation devient à la fois flux et écriture vectorisée, pipeline et score sur des dossiers*, que Système F peut être offert comme service marchand et intégré dans des circuits de captation de valeur. La rencontre entre *archicratie scripturo-normative* et *méta-régime marchand* n’est pas contingente ; elle est au cœur de la configuration dans laquelle l’*autarchicratie numérique*, hypothèse de III.4, devient pensable.
+
+## III.3. *Marché* et extraction de valeur
+
+Avec la filiation techno-logistique (flux, pipelines, indicateurs) et la filiation scripturo-normative (textes, dossiers, catégories, archives), Système F pourrait déjà être décrit comme un dispositif typiquement étatique ou para-étatique. Ce serait oublier un troisième ancrage tout aussi décisif dans la typologie de la thèse : le méta-régime marchand, c’est-à-dire l’archicratie marchande qui organise, depuis plusieurs siècles, une part croissante des rapports sociaux sous la forme d’échanges monétarisés, de contrats, de marchés, de prix.
+
+### III.3.1. Le méta-régime marchand dans la grammaire archicratique
+
+Dans l’*archicratie marchande*, l’*arcalité* se cristallise autour d’un ensemble de *fictions structurantes* : la *valeur d’échange comme principe de commensurabilité* ; la *concurrence comme mécanisme d’ajustement* ; l’*égalité formelle des contractants* ; la *figure de l’“homo oeconomicus” rationnel, calculant, libre de ses choix*. Cette *arcalité* s’exprime dans des *doctrines* (de Smith à la théorie néoclassique), dans des *idéologies* (le marché comme instance d’allocation optimale, l’innovation comme moteur de croissance), dans des *récits politiques* (l’“économie de marché” et la “société de consommation” comme horizon indépassable).
+
+La *cratialité marchande* prend la forme de dispositifs très concrets : *monnaies, contrats, prix, instruments financiers, plateformes de transaction, organes de certification, infrastructures logistiques et informationnelles des marchés*. Ce sont des architectures où s’agrègent des ordres d’achat et de vente, des offres et des demandes, des flux de capitaux, des décisions d’investissement.
+
+L’*archicration marchande* se déploie là où ces dispositifs peuvent être mis en épreuve : *autorités de concurrence, régulateurs sectoriels* (télécoms, énergie, finance), *dispositifs de défense des consommateurs, syndicats, mobilisations collectives face aux “défaillances du marché”*. Mais, comme le montre la thèse, cette *archicration* reste souvent partielle et à être auto-référentielle : les marchés tendent à présenter leurs propres indicateurs (prix, volumes, indices, ratings) comme des justifications suffisantes, au risque de réduire la scène à un dialogue entre acteurs jargonnant déjà insérés dans le jeu marchand.
+
+C’est dans ce paysage que Système F vient se loger : non comme une simple technologie neutre, mais comme un bien marchand, un service payant, un actif dans des stratégies d’entreprise, un élément d’une chaîne de création de valeur.
+
+### III.3.2. Système F comme service marchand et infrastructure privée
+
+Du point de vue économique, Système F n’est pas un simple outil interne : il est offert, par les fournisseurs d’IA de fondation, sous la forme d’un service marchand. Un modèle de fondation hébergé dans le *cloud*, accessible via API, est un produit : il a un prix (par requête, par volume de données, par abonnement), il fait l’objet de contrats (niveaux de service, garanties, clauses de responsabilité), il est intégré dans des offres commerciales plus larges (suites logicielles, “solutions” sectorielles, programmes spécifiques pour le secteur public).
+
+Ainsi, lorsqu’une caisse de prestations sociales, un ministère, un hôpital, une grande entreprise, une plateforme numérique adoptent un module dérivé de Système F, ils n’acquièrent pas seulement une capacité technique ; ils achètent un service auprès d’un fournisseur, parfois monopolistique ou oligopolistique, et s’inscrivent dans une relation de dépendance contractuelle, technique et financière. L’*infrastructure* qui supporte Système F – *centres de données, réseaux, environnements logiciels* – est, pour l’essentiel, *privée* : elle appartient à des acteurs dont le modèle économique repose sur la vente de capacités computationnelles et d’API d’IA.
+
+Archicratiquement, cela signifie que la *cratialité régulatrice* (la capacité de trier des dossiers, de prioriser des patients, de filtrer des contenus) se trouve, pour une part, portée par une *cratialité marchande* : ce sont des entreprises qui détiennent les moyens de faire fonctionner Système F, qui décident du rythme des mises à jour, de la consistance des caractéristiques (*features*), du niveau de support, du degré d’ouverture ou de fermeture de l’architecture. Le pouvoir de dire comment l’algorithme “travaillera” dans quelques années est aussi un pouvoir de producteur sur son catalogue.
+
+### III.3.3. Monétisation des flux régulatoires : scoring comme service
+
+Le fait que Système F soit un service marchand a une conséquence directe : *la valorisation des capacités de scoring, de classement, de recommandation devient un enjeu économique central*.
+
+Lorsqu’un fournisseur propose à une administration sociale un module de détection de fraude ou de classement des dossiers par “risque”, ce qui se vend n’est pas seulement une optimisation technique ; c’est une *promesse de gain budgétaire* : *moins de prestations indûment versées, plus de récupérations, “efficacité” accrue des contrôles*. La capacité de produire un score devient une marchandise, négociée en termes de retour sur investissement : pour un certain coût par usage, l’institution espère une certaine économie globale.
+
+Dans le secteur de la santé, les algorithmes de gestion de risques sont commercialisés comme des solutions d’optimisation de la trajectoire de soin : orienter les patients vers les programmes les plus appropriés, éviter les hospitalisations coûteuses, gérer la “patientèle” de façon plus rentable. Là encore, le modèle de prédiction est valorisé comme un *instrument de maîtrise des coûts et des flux*.
+
+Dans le recrutement, les outils de tri de CV ou de “*matching*” candidat–poste sont vendus comme moyens de réduire les dépenses liées à des embauches jugées ratées, de diminuer le temps passé à examiner des candidatures, d’augmenter la “qualité” moyenne des recrutements.
+
+Dans les plateformes numériques, les systèmes de recommandation et de modération reposant sur l’IA sont au cœur du modèle d’affaires : ils conditionnent la captation de l’attention, la fidélisation des utilisateurs, l’attractivité pour les annonceurs. Un gain de quelques points de “rétention” ou de “temps passé” se traduit directement en revenus publicitaires supplémentaires.
+
+Dans toutes ces configurations, les mêmes fonctions – *scoring, priorisation, détection, recommandation* – qui sont au cœur de la *cratialité régulatrice* de Système F sont aussi les *supports d’une extraction de valeur*. La capacité de décider qui sera contrôlé, soigné en priorité, embauché, rendu visible, devient un actif commercial. *La frontière entre gouverner et vendre des services de gouvernement se brouille*.
+
+### III.3.4. Segmentation, adhésion, captation : les publics comme “portefeuilles”
+
+Le *méta-régime marchand* ne se contente pas de vendre des capacités ; il *organise la réalité en segments et en portefeuilles*. Les individus, les entreprises, les institutions sont envisagés comme des clients, des usagers, des audiences, des risques, des opportunités.
+
+Système F, inséré dans cette logique, devient un *instrument de segmentation fine des publics*. Dans une caisse sociale, il permet de distinguer les “*bénéficiaires à surveiller*” de ceux que l’on considère comme moins problématiques. Dans un système de santé, il ordonne les patients en “*priorités*” *d’intervention*. Dans une administration de justice, il classe les justiciables en *catégories de risque*. Dans une entreprise, il découpe les candidats ou les salariés en segments de “*performance attendue*”, de “*probabilité de départ*”, de “*compatibilité culturelle*”. Dans une plateforme, il isole des groupes d’utilisateurs selon leur propension à cliquer, partager, acheter, s’abonner.
+
+Cette *segmentation* n’est pas exclusivement descriptive ; elle est *performative*. Elle oriente des *politiques d’allocation de ressources* (*où va l’argent, où va le temps, où vont les efforts ?*) et des *stratégies d’adhésion (comment retenir certains publics, comment en décourager d’autres, comment ajuster les messages, les interfaces, les offres ?*).
+
+Du point de vue archicratique, cela signifie que *la scène sur laquelle les publics pourraient discuter des critères qui les segmentent se déplace vers des espaces où l’enjeu principal est la rentabilité de ces segmentations*. Les catégories deviennent des instruments de valorisation : un segment est intéressant parce qu’il est “monétisable”, “coûteux”, “porteur de risque”, “à fort potentiel”. Ce n’est plus d’abord en termes de justice, de droits, de besoins, que les groupes sont pensés, mais en termes de contribution au modèle économique du dispositif qui les classe.
+
+### III.3.5. Effets archicratiques de l’inscription marchande
+
+L’inscription de Système F dans l’*archicratie marchande* a plusieurs effets archicratiques structurants.
+
+D’abord, elle renforce la *cratialité privée* : une part du pouvoir régulateur – la *capacité de hiérarchiser les dossiers*, de *filtrer les contenus*, de *prioriser des patients*, de *trier des candidatures* – dépend de choix d’acteurs marchands, guidés par leurs propres contraintes (rentabilité, parts de marché, intérêts des actionnaires). Même lorsque l’IA est utilisée pour mettre en œuvre des politiques publiques, la *cratialité* qui la porte est *en partie régie par des logiques de produits et de contrats*.
+
+Ensuite, elle tend à capturer l’*archicration* dans des scènes économiques restreintes. Les décisions importantes sur la trajectoire de Système F – *niveau d’investissement, orientation de la recherche, arbitrages entre précision et coût, entre performances et contraintes réglementaires, entre ouverture et fermeture* – se prennent dans des *conseils d’administration*, des *comités de direction*, des *négociations commerciales*. Ce sont des scènes où les personnes directement affectées par les décisions (allocataires, patients, justiciables, salariés, usagers) sont, au mieux, représentées de façon indirecte, et où la métrique dominante est la performance économique.
+
+Enfin, l’inscription marchande contribue à naturaliser un certain type d’*arcalité* : *si un système est rentable, s’il se vend bien, s’il “trouve son marché”, cela est spontanément perçu comme une forme de validation*. La justesse du dispositif se mesure alors à la vigueur de ses flux commerciaux. Il devient difficile de distinguer l’argument : “ce système d’IA est efficace pour la lutte contre la fraude, la gestion du risque, la modération des contenus” de l’argument : “ce système d’IA trouve des clients”. *L’arcalité pratique se confond avec la réussite marchande*.
+
+### III.3.6. Triangulation : *techno-logistique, scripturo-normatif, marchand*
+
+À ce stade de l’épreuve archéogénétique, la configuration de Système F apparaît clairement comme une triangulation de trois méta-régimes :
+
+- Du *méta-régime techno-logistique*, il *hérite la priorité donnée aux flux, aux pipelines, aux indicateurs* : dossiers, cas et contenus sont traités comme des circulations à optimiser.
+
+- De l’*archicratie scripturo-normative*, il reprend la *centralité des écritures* – *formulaires, dossiers, décisions* – qu’il vectorise, recombine, convertit en scores, en opérant une *scripturalité de second degré*.
+
+- De l’*archicratie marchande*, il reçoit son statut de service payant, d’infrastructure privée, d’actif dans des stratégies d’entreprise ; il est *inséré dans des chaînes de valeur où ses fonctions régulatrices sont aussi des produits vendus, des segments de marché, des moteurs d’extraction de valeur*.
+
+Cette triangulation ne signifie pas que l’IA serait “réductible” au capitalisme, ni qu’elle serait un simple avatar de la bureaucratie, ni qu’elle ne serait qu’une mégamachine de flux. Elle indique que Système F est un point de convergence particulièrement dense de ces trois matrices :
+
+- les *flux régulatoires deviennent des occasions de monétisation* ;
+
+- les *dossiers scripturo-normatifs deviennent des gisements de données exploitables commercialement* ;
+
+- les *indicateurs de performance technique et économique se renforcent mutuellement*.
+
+C’est sur ce fond que la section III.4 pourra poser l’hypothèse d’un *méta-régime autarchicratique numérique* : un *régime où la régulation, portée par des dispositifs comme Système F, tend à se légitimer essentiellement par ses propres métriques internes, dans des scènes largement capturées par des intérêts techno-logistiques, scripturo-normatifs et marchands, au détriment d’archicrations ouvertes où la société pourrait, collectivement, remettre en jeu les fondements et les effets de ces dispositifs.*
+
+## III.4. Vers un *méta-régime autarchicratique numérique*
+
+Les trois filiations dégagées par l’épreuve archéogénétique – *techno-logistique, scripturo-normative, marchande* – suffiraient déjà à situer Système F dans la grande histoire des régimes de co-viabilité. Mais la thèse ne s’arrête pas à cette cartographie ; elle avance l’hypothèse plus exigeante d’une *autarchicratie* : un *régime où la régulation tend à devenir son propre principe de gouvernement*, *où les instruments qui mesurent, classent et ordonnent deviennent, pour une part, les seuls juges de leur propre validité*.
+
+L’enjeu de cette section n’est pas de décréter à la légère que “nous serions entrés” dans un méta-régime *autarchicratique numérique*, mais d’examiner, à partir de Système F, si des traits structurants de ce type de configuration sont effectivement observables : *métriques internes comme arcalité pratique, boucles de rétroaction fermées, marginalisation des scènes externes d’épreuve*.
+
+### III.4.1. Rappel de la notion d’*autarchicratie*
+
+Dans la grammaire de la thèse, l’*archicratie* désigne un ordre où l’on peut encore distinguer, même de façon conflictuelle, trois prises :
+
+- une *arcalité* – des formes de fondation, explicites ou implicites, qui prétendent légitimer un pouvoir régulateur ;
+
+- une *cratialité* – des dispositifs, des chaînes, des architectures par lesquelles ce pouvoir s’exerce ;
+
+- une *archicration* – des scènes d’épreuve où ces fondements et ces dispositifs peuvent comparaître, être contestés, infléchis.
+
+Un méta-régime est dit *autarchicratique* lorsque cet équilibre se défait au profit d’une *auto-référentialité de la régulation* : la *cratialité* ne se contente plus d’appliquer des normes, elle *tend à produire ses propres critères de validité* ; l’*arcalité* *se réduit à la performance mesurée par des instruments conçus par les mêmes acteurs qui les utilisent* ; l’*archicration* *se referme sur des scènes internes* (audits, comités, tableaux de bord) *où les questions d’efficacité et de conformité technique disqualifient, d’emblée, les questions plus larges de justice, de sens, de co-viabilité*.
+
+L’*autarchicratie* n’est pas l’absence de normes, ni le chaos ; au contraire, elle suppose une *densité extrême de normes, de procédures, de mesures*. *Ce qui disparaît, ce n’est pas la régulation, c’est la possibilité pour la société d’installer cette régulation sur une scène qui lui soit extérieure*.
+
+### III.4.2. Métriques internes comme *arcalité pratique*
+
+Dans Système F, un premier trait *autarchicratique* apparaît dans la manière dont des métriques internes se substituent, en pratique, à d’autres formes de fondation.
+
+Au niveau du développement du modèle, l’arbitrage se fait à travers quelques *indicateurs techniques* : *perte* (*loss*) *à minimiser*, *précision* (*accuracy*) ou AUC *à maximiser,* parfois une batterie de métriques d’« *équité »* (*fairness*) ou de robustesse. Une version de Système F est jugée “*meilleure*” qu’une autre *si ses courbes de performance s’améliorent sur des jeux de validation*. Les débats internes portent alors sur le choix des métriques, des jeux de test, des seuils jugés satisfaisants.
+
+Au niveau de l’*intégration produit*, d’autres métriques prennent le relais : *taux de fraude détectée*, *économies réalisées*, *réduction des délais de traitement*, *nombre de dossiers gérés par agent*, *taux d’occupation des lits*, *diminution des “no-shows”*, *amélioration des taux de clic* ou de *rétention sur une plateforme*. Un modèle “réussi” est celui qui fait remonter ces indicateurs dans le sens attendu. Là encore, *la discussion se focalise sur la lecture de la courbe* : la ligne qui monte ou descend, l’écart par rapport à une référence, la significativité d’une variation.
+
+Enfin, au niveau de la *gouvernance du dispositif*, des indicateurs plus globaux viennent boucler la boucle : *conformité aux cadres réglementaires, résultats d’audits, scores d’“IA responsable” sur des grilles internes, satisfaction des “clients” institutionnels*. L’acceptabilité de Système F est indexée sur sa *capacité à franchir ces batteries d’épreuves techniques et procédurales*.
+
+Dans cette configuration, les questions archicratiques fondamentales – *qu’est-ce qu’une fraude intolérable ? qu’est-ce qu’un risque acceptable ? quel type d’erreur est le plus grave, et pour qui ?* – sont partiellement réécrites sous la forme : *quel niveau de performance sur telle métrique jugeons-nous suffisant ?* La fondation pratique du dispositif se déplace vers des chiffres produits par le dispositif lui-même, ou par des instruments étroitement articulés à lui. L’arcalité devient, pour une part, une affaire de courbes qui se tiennent.
+
+### III.4.3. Boucles de rétroaction fermées
+
+Un second trait *autarchicratique* tient à la manière dont Système F *tend à être évalué par lui-même, au sein de boucles de rétroaction largement fermées*.
+
+Les performances du modèle sont mesurées sur des données issues du même univers qui a servi à l’entraîner : décisions passées, comportements observés, historiques d’usage. Les “*améliorations*” constatées – *baisse de la loss, hausse de la précision, meilleure “couverture” de certains cas* – sont validées par des tests construits à partir de ces mêmes données, ou de jeux de données très proches. Lorsque des critiques externes apparaissent (biais découverts, scandales, décisions de justice), la réponse typique consiste à intégrer ces critiques dans de nouvelles métriques : ajouter un indicateur, définir un score de “non-discrimination”, introduire une contrainte d’“équité” dans la fonction d’objectif.
+
+Autrement dit, la contestation est prise au sérieux, mais *à condition d’être traduisible en contrainte interne du modèle ou du processus d’ingénierie*. Elle devient un paramètre de plus dans l’*optimisation* : on *cherche un point où les performances techniques, les coûts économiques et les contraintes éthico-juridiques minimales sont “satisfaites”*. La critique n’ouvre pas nécessairement une scène où l’on pourrait remettre en cause, de l’extérieur, la finalité du dispositif ; elle *alimente une boucle de réglage*.
+
+Du côté des organisations utilisatrices, le même mouvement se reproduit. Les retours des agents de guichet, des médecins, des juges, des recruteurs, des modérateurs sont recueillis, lorsqu’ils le sont, sous la forme de *feedbacks intégrables* : *rapports d’usage, remontées d’“incidents”, ajustements de configurations*. Les effets sur les personnes concernées – allocataires, patients, justiciables, candidats, usagers – ne remontent que rarement sous la forme de controverses structurées ; ils apparaissent comme des “cas difficiles”, des anomalies, des coûts de gestion supplémentaires.
+
+Dans une *autarchicratie numérique*, la rétroaction est admise, mais à condition d’entrer par les *voies prévues* : *formulaires de recours, dispositifs de plainte, audits internes, consultations cadrées*. Les transformations qui en résultent restent, pour l’essentiel, internalisées dans les paramètres de Système F ou dans les réglages de son environnement. Les rares irruptions externes fortes – décisions de justice, mobilisations collectives, enquêtes médiatiques – conduisent à des révisions ponctuelles, des suspensions, des réécritures de procédures, sans pour autant rouvrir en grand la controverse des fins.
+
+### III.4.4. Marginalisation et simulation des scènes externes
+
+La topologie des scènes analysée en Partie II permet de préciser un troisième trait : *la marginalisation, voire la simulation, des scènes externes d’archicration*.
+
+Au niveau local, nous avons vu des *hypotopies* : scènes pauvres en prises, telles que les interfaces de recours en ligne ou les formulaires de contestation standardisés, où l’usager ne dispose que de très peu de leviers pour faire valoir un désaccord sur le rôle de l’IA.
+
+Au niveau institutionnel, des h*ypertopies* : *comités de pilotage, boards techniques, cellules “IA responsable”, où se concentrent, en cercle restreint, les décisions structurantes sur le paramétrage, la gouvernance, les critères de succès*. Ces scènes sont bien réelles, mais elles restent *largement fermées aux publics affectés* ; elles mettent en présence des *développeurs*, des *juristes*, des *managers*, *parfois des représentants de la conformité ou des régulateurs, rarement des usagers ou des collectifs concernés*.
+
+Autour de ces deux niveaux, se déploient souvent des *atopies* : *consultations publiques très encadrées, exercices de “dialogue” avec la société civile, enquêtes d’opinion, dispositifs de “participation” numérique* qui donnent forme à une scène de discussion sans que les résultats aient un poids décisif sur la trajectoire de Système F. *La scène existe, mais elle n’est raccordée qu’à la marge aux lieux où se jouent les choix déterminants*.
+
+Dans un tel paysage, l’*archicration* – au sens strict que la thèse donne à ce terme – se trouve *dégradée*. Les lieux où l’on pourrait confronter, publiquement et contradictoirement, l’*arcalité* (ce au nom de quoi l’IA règle des flux de vie) et la *cratialité* (ce par quoi elle agit effectivement) sont soit périphériques, soit absorbés dans des *formats qui privilégient l’expertise technique et la rationalité gestionnaire*. La scène externe est rejouée à blanc : on consulte, on explique, on publie des rapports, mais l’essentiel de l’ajustement se fait entre Système F et ses propres métriques.
+
+### III.4.5. Système F comme vecteur possible d’un *méta-régime autarchicratique numérique*
+
+Ces traits suffisent-ils à conclure à l’existence d’un nouveau *méta-régime autarchicratique numérique* ? La thèse invite à la prudence :
+
+- d’un côté, il serait abusif de décréter que la séquence techno-logistique, scripturo-normative, marchande serait déjà “dépassée” par une forme entièrement nouvelle ;
+
+- de l’autre, il serait aveugle de ne pas voir que la combinaison de ces régimes, autour de dispositifs tels que Système F, fait apparaître des configurations où la régulation tend à se gouverner elle-même, avec une marge de plus en plus réduite laissée aux scènes externes.
+
+L’*hypothèse d’un méta-régime autarchicratique numérique* peut alors se formuler ainsi :
+
+*Un ordre de co-viabilité où des dispositifs de la famille de Système F, hébergés sur des infrastructures principalement privées, configurés à partir de données issues de l’archicratie scripturo-normative, insérés dans des chaînes techno-logistiques de flux et couplés à des modèles économiques marchands, deviennent les points d’appui principaux de la régulation, tout en se donnant pour arcalité pratique leurs propres performances mesurées, et en reléguant les scènes d’archicration externe à des positions marginales, diluées ou simulées.*
+
+Dit autrement : *Système F* n’est pas qu’un instrument de plus dans des régimes déjà connus ; il est un *candidat à devenir scène et juge à la fois*. Ce qui fonde, ce qui opère, ce qui évalue, tend à se refermer dans un même ensemble socio-technique : modèles, indicateurs, pipelines, plateformes, contrats.
+
+Cette hypothèse reste falsifiable. Elle pourrait être infirmée si l’on observait, empiriquement, des configurations où :
+
+- les métriques internes sont durablement subordonnées à des scènes d’archicration fortes (parlements, tribunaux, controverses publiques structurées) ;
+
+- les paramètres de Système F sont effectivement redéfinis à la suite de conflits où des collectifs affectés disposent de moyens substantiels de contestation et de co-décision ;
+
+- des architectures scéniques nouvelles (tribunaux des algorithmes, budgets scéniques, droits au différé contradictoire, etc.) parviennent à imposer à Système F des transformations qui ne se réduisent pas à des ajustements internes.
+
+En l’état, l’épreuve archéogénétique suggère que beaucoup de trajectoires plausibles de Système F – surtout lorsqu’il est déployé de façon transversale dans les politiques sociales, la santé, la justice, le travail, les plateformes – convergent vers cette figure *autarchicratique* :
+
+- *les métriques deviennent le langage principal de la justification* ;
+
+- *les boucles de pilotage restent internes aux organisations et à leurs fournisseurs* ;
+
+- *les scènes externes peinent à se constituer autrement qu’en réaction ponctuelle à des scandales ou à des contentieux.*
+
+C’est précisément ce constat qui rend nécessaire la suite du cas pratique. Les épreuves morphologique, historique et de co-viabilité n’auront de sens que si elles permettent de dire, de façon plus précise, ce que l’*autarchicratie numérique* fait aux philosophies du pouvoir en place, comment elle redistribue les lignes des révolutions régulatrices, et quelles formes d’*archicration* effective pourraient être instituées pour que Système F cesse d’être un candidat au gouvernement par la régulation elle-même, et devienne un dispositif profondément démocratique.

src/content/cas-ia/chapitre-4.mdx

@@ -0,0 +1,209 @@
+---
+title: "Chapitre IV — Épreuve morphologique"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 50
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_4_Epreuve_Morphologique.docx"
+---
+# IV. Épreuve morphologique : philosophies du pouvoir relues par le cas IA
+
+L’introduction et les trois premières parties de ce cas pratique ont poursuivi un fil très simple, mais exigeant : prendre Système F au sérieux comme dispositif régulateur et le soumettre, successivement, aux grandes épreuves de la thèse sur l’*archicratie* – *détectabilité, topologie scénique, archéogénèse des méta-régimes*. Nous savons désormais *où il agit* (guichets, interfaces, comités, tribunaux, plateformes), *comment il agit* (scores, pipelines, fonctions de coût, procédures d’intégration), *de quoi il hérite* (*mégamachine techno-logistique*, *archicratie scripturo-normative*, *archicratie marchande*) *et vers quel type de configuration il tend* (une forme possible d’*autarchicratie numérique*, où la régulation se prend elle-même pour principe et scène).
+
+Il manque encore une épreuve, celle que le chapitre 3 de l’essai-thèse appelait *épreuve morphologique* : *confronter le paradigme archicratique à quelques grandes philosophies du pouvoir qui ont structuré, depuis un demi-siècle, notre manière de penser les dispositifs et les institutions*. Non pour faire une exégèse supplémentaire de Foucault, Habermas, Rancière, Boltanski & Thévenot, mais pour mettre à l’épreuve, devant eux, la forme même de ce que nous prétendons voir avec l’*archicratie*.
+
+Autrement dit : Système F ne doit pas seulement être lu “par nos propres concepts” ; il doit aussi être visible depuis d’autres grilles de lecture déjà reconnues comme puissantes, afin que l’*archicratie* ne soit ni redite, ni simple habillage, ni surplomb commode.
+
+Dans le chapitre 3 de la thèse, l’épreuve morphologique consistait à se demander, pour chaque grande philosophie du pouvoir :
+
+1.  *Quel type de scène privilégie-t-elle ?*
+
+    La *gouvernementalité* foucaldienne met en avant les dispositifs, les agencements de sécurité, les conduites à distance. L’*espace public* habermassien, quant à lui, privilégie les arènes de discussion, la formation intersubjective de la volonté. Le *dissensus* ranciérien insiste sur les interruptions, les surgissements de ceux qui ne comptent pas. Et concernant les *économies de la grandeur* de Boltanski & Thévenot, celles-ci décrivent des grammaires d’*épreuves de justification*.
+
+2.  *Quel rapport aux fondements et aux instruments y est présupposé ?*
+
+    *Où se loge ce qui tient lieu d’arcalité* (fondation, justification) : dans un savoir d’État, dans des normes de validité discursive, dans des partages sensibles, dans des “cités” de grandeur ?
+
+    *Comment la cratialité est-elle décrite* : *dispositifs disciplinaires et sécuritaires, systèmes administratifs, médias et infrastructures, formats d’épreuve, procédures* ?
+
+3.  *Quel traitement de la scène d’épreuve est proposé ?*
+
+    Y a-t-il une véritable archicration, au sens de la thèse, ou bien la scène est-elle présupposée (comme “l’espace public”), ou latente (comme “la politique” chez Rancière), ou dissoute dans des épreuves locales de justification ?
+
+L’objectif, dans la thèse, n’était pas de “corriger” ces philosophies, mais de montrer qu’elles décrivent chacune, de façon puissante, un versant morphologique particulier des régimes archicratiques : la *gouvernementalité* comme accent porté sur la *cratialité diffuse*, l’*espace public* comme théorie d’une certaine forme d’*archicration discursive*, le *dissensus* comme rappel de la *dimension conflictuelle de la scène*, l’*économie des grandeurs* comme analyse fine des *prises de justification*.
+
+Dans ce cas pratique, l’enjeu est légèrement différent : il s’agit d’appliquer à Système F un croisement entre ces philosophies et le paradigme archicratique, pour voir :
+
+- ce que Foucault, Habermas, Rancière, Boltanski & Thévenot rendent immédiatement visibles dans un grand système d’IA de fondation utilisé comme instrument régulateur ;
+
+- ce qu’ils laissent en retrait, notamment du point de vue de l’oblitération scénique mise en évidence par la thèse ;
+
+- ce que la notion d’*archicration* (au sens strict : *scène d’épreuve effective entre arcalité et cratialité*) permet d’ajouter, de déplacer, de préciser.
+
+On pourrait, en première apparence, se passer de ce détour : après tout, le cas Système F est déjà abondamment décrit avec les outils maison (*arcalité déclarée/implicite*, *cratialité*, topologie, archéogénèse). Pourtant, l’épreuve morphologique a une fonction cruciale : s’assurer que le paradigme archicratique ne “voit” pas moins que les autres, et qu’il apporte vraiment quelque chose de plus.
+
+Avec Foucault, la *gouvernementalité* nous rappelle que Système F ne se réduit pas à des décisions ponctuelles, mais compose un *régime de conduite à distance, par anticipation, par gestion des risques, par normalisation des comportements*. L’IA ne fait pas qu’exécuter des ordres ; elle *contribue à structurer un milieu de probabilités et de sécurisation*. L’épreuve morphologique consistera à montrer ce que le paradigme archicratique reprend de cette intuition – la *centralité des dispositifs*, la *dimension diffuse du pouvoir* – et ce qu’il déplace : la question de la scène d’épreuve que Foucault laisse, presque par principe, dans l’ombre.
+
+Avec Habermas, l’*espace public délibératif* permet de poser une autre question : *dans quelle mesure les systèmes d’IA qui peuplent les décisions publiques peuvent-ils être intégrés à des processus de formation de la volonté qui restent légitimes ?* Les LLM peuvent produire des arguments, simuler de la délibération, aider à rédiger des consultations, mais cela ne garantit en rien l’existence d’une scène où les personnes affectées discutent réellement des fondements des dispositifs. L’épreuve morphologique montrera que l’*archicratie* ne se contente pas d’opposer “communication vs stratégie”, mais demande un niveau supplémentaire : l’IA elle-même doit pouvoir être convoquée comme objet d’épreuve dans des scènes où l’on discute ce qu’elle fait aux droits, aux accès, aux hiérarchies.
+
+Avec Rancière, Boltanski & Thévenot, la focale se déplace vers les *épreuves* : *épreuves politiques de dissensus d’un côté, épreuves de justification de l’autre*. Système F organise déjà, silencieusement, des épreuves : être “à haut risque”, “éligible”, “prometteur”, “conforme” ou “non conforme” est une manière de trier, de classer, de faire tenir ou déchoir des positions. La question, ici, sera de savoir à *quelles grammaires de justification ces épreuves se réfèrent* (sécurité, efficacité, équité, innovation, responsabilité, etc.), *comment elles neutralisent ou rendent plus difficile le dissensus*, et comment la notion d’*archicration* permet de *penser des épreuves publiques, multi-répertoires, où plusieurs grandeurs et plusieurs régimes de légitimité peuvent être mobilisés* face à Système F.
+
+Ainsi, l’épreuve morphologique ne vient pas se surplomber aux parties précédentes comme une surcouche théorique supplémentaire ; elle se greffe sur elles pour tester simultanément deux choses. D’une part, la *robustesse du paradigme archicratique* : *est-il réellement capable de dialoguer avec ces grandes morphologies du pouvoir sans s’y dissoudre ni les répéter, en montrant ce qu’il ajoute précisément par la focalisation sur la scène d’épreuve ?* D’autre part, la *consistance du diagnostic* porté sur Système F : ce que nous avons décrit comme *oblitération scénique*, *arcalité fantôme*, *cratialité hypertopique*, tendance *autarchicratique* est-il corroboré, nuancé, déplacé lorsqu’on lit le même dispositif avec des lunettes différentes ? C’est à cette double condition – *confrontation à des terrains concrets et confrontation à des philosophies puissantes* – que le cas pratique peut prétendre, lui aussi, à un véritable grade archicratique : non pas produire un discours souverain sur l’IA, mais mettre en scène les différents régimes de description du pouvoir qui s’y jouent, et montrer comment le paradigme archicratique se tient, ou non, devant eux.
+
+## IV.1. *Gouvernementalité* et IA
+
+Parmi les morphologies du pouvoir mobilisées par l’essai-thèse, la *gouvernementalité foucaldienne* est sans doute celle qui offre le plus immédiatement une grille de lecture pour un dispositif comme Système F : *pouvoir à distance, dispositifs de sécurité, gestion probabiliste des populations*. Cette section propose donc de reprendre brièvement ce schème, puis de le confronter à la triade archicratique, afin de mesurer à la fois ce que cette tradition permet de voir de l’IA régulatrice et ce qu’elle tend à laisser en retrait, en particulier du côté de la scène d’épreuve.
+
+### IV.1.1. Reprendre la *gouvernementalité* comme morphologie du pouvoir
+
+Relire Système F avec Foucault, ce n’est pas plaquer un vocabulaire à la mode sur des technologies nouvelles ; c’est reprendre une intuition très précise : le pouvoir moderne ne s’exerce plus principalement par la loi qui interdit, ni par le supplice qui châtie, mais par des dispositifs de sécurité qui organisent des milieux, gèrent des risques, ajustent des populations à des normes. La *gouvernementalité*, telle que Foucault la déploie, désigne cette forme de pouvoir qui vise à “*conduire des conduites*” *à distance, en combinant des savoirs statistiques, des agencements matériels, des procédures d’anticipation*, plutôt qu’en s’adressant directement à un sujet souverain.
+
+Dans cette morphologie, le centre de gravité n’est ni la loi, ni le contrat, ni même l’idéologie ; ce sont des *dispositifs* : *dispositifs de police sanitaire, d’assurance, de contrôle des circulations, de gestion des populations.* Ils articulent des *séries de données* (naissances, décès, maladies, délits, déplacements), des *techniques de calcul* (probabilités, moyennes, distributions), des *infrastructures* (casernes, hôpitaux, écoles, prisons, bureaux) et des *routines administratives*. Le pouvoir s’exerce en modulant des paramètres – *seuils, tolérances, classes de risque* – plus qu’en décrétant ponctuellement des interdits.
+
+Le chapitre sur la *gouvernementalité*, dans l’essai-thèse, reprenait déjà cette intuition en la reformulant dans le langage archicratique : la *gouvernementalité* décrit une configuration particulière de *cratialité* (un maillage de dispositifs de sécurité) portée par une certaine *arcalité implicite* (la normalisation statistique comme horizon) et corrélée à des formes d’*archicration* souvent *faibles, fragmentaires, locales*. La question est désormais : une fois Système F installé dans l’appareil régulateur, que rend visible la focale foucaldienne – et que laisse-t-elle dans l’ombre ?
+
+### IV.1.2. Système F comme intensification gouvernementale
+
+Si l’on regarde Système F avec ces lunettes, une première chose saute aux yeux : il ne ressemble pas à une rupture totale avec la gouvernementalité, mais à une intensification très avancée de ses logiques.
+
+D’un côté, Système F *étend et raffine la dimension sécuritaire* : les dispositifs que nous avons déjà analysés – *scoring de risque social, modèles de gestion des risques en santé, évaluation actuarielle pénale, filtres de modération, outils de tri de CV* – sont autant de *machines à produire des distributions de probabilité, des cartes de vulnérabilité, des hiérarchies de dangerosité ou de* « *mérite* ». Là où les dispositifs foucaldiens travaillaient avec des séries relativement grossières (taux de mortalité, statistiques de délinquance, courbes épidémiologiques), Système F opère à un niveau beaucoup plus fin : il assigne des scores à des individus et des dossiers singuliers, mais toujours en fonction de profils et de corrélations extraits de populations entières.
+
+D’un autre côté, Système F accentue le caractère indirect et diffus de la *conduite des conduites*. La plupart du temps, il ne prescrit pas des comportements en toutes lettres ; il *module des environnements de décision*. Un agent de caisse sociale ne reçoit pas l’ordre “contrôle telle famille parce qu’elle est suspecte” ; il ouvre une interface où certains dossiers remontent en tête de liste, avec une couleur, un symbole, une mention de risque. Un médecin ne se voit pas dicter un diagnostic ; il consulte un tableau où des patients sont classés selon un indice de priorité, assorti d’alertes discrètes. Un juge ne reçoit pas une peine à prononcer, mais un rapport où un score de risque “recommande” implicitement une sévérité ou une prudence accrues. Les usagers de plateformes vivent dans un flux de contenus déjà trié, hiérarchisé, modulé par des modèles dérivés de Système F.
+
+Sous cet angle, la *gouvernementalité* foucaldienne permet donc de saisir immédiatement Système F comme un *dispositif de sécurité généralisé* : *continuité des séries de données, gestion probabiliste des comportements, modulation des milieux d’action* plutôt que commandement frontal. Elle montre que l’IA, intégrée à des politiques sociales, sanitaires, pénales, informationnelles, est un relais puissant du *passage du droit disciplinaire à la sécurité normalisatrice* : au lieu de punir après coup, on prévient, on sélectionne, on profile, on priorise.
+
+### IV.1.3. Ce que la focale foucaldienne rend visible
+
+Cette lecture a une vertu : elle évite de tomber dans deux pièges fréquents du discours sur l’IA. D’abord, elle empêche d’en faire une pure “*boîte noire*” technique, détachée des formes historiques de gouvernement. Système F apparaît comme un nouvel étage, extrêmement sophistiqué, d’une longue histoire de dispositifs de sécurité : il prend place dans une lignée qui va des recensements et des statistiques de mortalité aux systèmes d’assurance, puis aux premiers algorithmes de *scoring*, jusqu’aux modèles de fondation. Il n’est pas un météore, mais un produit avancé de cette *gouvernementalité*.
+
+Ensuite, la focale foucaldienne évite l’inverse : présenter Système F comme un simple instrument neutre, utilisable aussi bien pour renforcer l’État social que pour le fragiliser. En l’inscrivant dans la *gouvernementalité*, on voit que la cible principale de ces dispositifs n’est pas uniquement l’individu, mais une population toute entière : ce qui est en jeu, ce sont des distributions, des profils, des répartitions de risque et de ressources. Le modèle de gestion de risques en santé que nous analysons reconfigure une architecture de soins à l’échelle de groupes entiers, en sous-servant systématiquement certains. Le système de *scoring social* ne se contente pas d’“erreurs individuelles” ; il organise un régime de suspicion sur certaines catégories. *Le moteur de recommandation transforme un champ d’expérience partagé en paysage informationnel différencié*.
+
+Enfin, la *gouvernementalité* fournit une langue précise pour *décrire la structure cratiale* de Système F : un *assemblage d’institutions*, de *savoirs*, d’*architectures matérielles* et *logicielles* qui, ensemble, produisent des *effets de normalisation*. Elle résonne avec ta description de Système F comme *chaîne socio-technique composite* : *fournisseur de modèle, intégrateurs, organisations utilisatrices, scènes locales d’usage*. Foucault aurait sans doute reconnu là un agencement de dispositifs, au sens fort : non pas des outils isolés, mais un montage où des pouvoirs, des savoirs, des visibilités s’articulent.
+
+### IV.1.4. Le point aveugle : la scène d’épreuve manquante
+
+Mais c’est précisément à ce point que la confrontation morphologique devient décisive. Car ce que la lecture foucaldienne rend visible avec acuité – la *logique des dispositifs*, la *centralité des milieux*, le *caractère diffus de la conduite des conduites* – s’accompagne d’un angle mort que notre paradigme archicratique met en pleine lumière : l’absence quasi systématique d’une réflexion sur la scène d’épreuve.
+
+Dans le geste foucaldien, il y a une méfiance constitutive envers tout ce qui ressemble à une “scène” où le pouvoir serait sommé de se justifier : Foucault se tient délibérément à distance des philosophies du contrat, du droit, de la délibération. Son regard se porte sur les mécanismes, les visibilités, les normes incorporées, les dispositifs de savoir-pouvoir. Les moments où le pouvoir est contesté, mis en procès, ramené devant une instance, apparaissent chez lui principalement comme des résistances diffuses, des luttes, des contre-conduites – pas comme des scènes instituées d’*archicration*.
+
+Appliquée à Système F, cette orientation a une conséquence : elle permet de décrire avec une grande finesse comment l’IA participe à la *gouvernementalité*, mais elle laisse largement indéterminée la question : *où et comment cette gouvernementalité algorithmique pourrait-elle être amenée en visibilité, contestée, reconfigurée ?* Foucault montre comment les dispositifs de sécurité s’installent, se déplacent, se renforcent, mais très peu comment ils sont mis en demeure, sur quelle scène ils peuvent être sommés de répondre.
+
+Or, notre cas pratique montre justement que c’est là que se joue aujourd’hui une part décisive du problème : la *cratialité* de Système F est *massive*, son *inscription gouvernementale évidente*, mais l’*archicration* – au sens d’une scène où l’on vient demander des comptes – est soit absente, soit réduite à des recours administratifs, des contentieux, des audits internes, qui ne parviennent pas à ramener l’ensemble du dispositif sur scène. La focale foucaldienne capte à merveille l’extension des dispositifs ; elle est beaucoup plus discrète sur les conditions d’une mise en procès archicratique de ces dispositifs.
+
+### IV.1.5. Ce que l’*archicration* ajoute à la *gouvernementalité*
+
+Ce n’est donc pas un hasard si, dans notre lecture archicratique, la *gouvernementalité* se retrouve réinscrite comme une morphologie partielle de la *cratialité* : une manière spécifique de faire agir des dispositifs sur des populations à travers des milieux de sécurité. Ce que le paradigme archicratique ajoute, ce n’est pas une “morale” qui viendrait corriger Foucault ; c’est une exigence scénique : *toute configuration gouvernementale doit être interrogée à partir des lieux où elle accepte – ou refuse – de comparaître*.
+
+Pour Système F, la question n’est pas seulement : comment conduit-il des conduites par la prédiction et la normalisation douce ? Elle devient : *où, concrètement, cette conduite des conduites est-elle rendue visible, discutable et opposable ? Où peut-on amener en même temps l’arcalité* (les axiomes implicites sur la fraude, le risque, le mérite, la vulnérabilité), la *cratialité* (les chaînes de données, les modèles, les interfaces, les procédures) *et les expériences des personnes affectées ?*
+
+Sous ce rapport, l’épreuve morphologique foucaldienne et l’épreuve archicratique ne se contredisent pas ; elles se complètent et se tendent l’une l’autre. La première donne la figure générale de ce que fait Système F au pouvoir : il densifie une gouvernementalité de sécurité, de normalisation, de gestion probabiliste des populations. La seconde demande : *quelles archicrations manquent pour que cette gouvernementalité ne devienne pas pure autarchicratie, c’est-à-dire un gouvernement de la régulation par elle-même, refermé sur ses propres métriques ?*
+
+Ce déplacement est décisif pour la suite du cas pratique. Il permet de ne pas réduire la critique de l’IA à une dénonciation des “algorithmes de contrôle”, ni à un appel abstrait à des “droits fondamentaux” : il invite à concevoir, très concrètement, des scènes d’*archicration* où la gouvernementalité algorithmique puisse être travaillée – non pas seulement déjouée par des résistances dispersées, mais réinstituée dans des dispositifs de mise en épreuve. C’est à cette condition que la puissance descriptive de Foucault peut être conservée, tout en évitant que la *gouvernementalité*, une fois numérisée et massivement déployée, ne se fige en horizon indépassable de la régulation.
+
+## IV.2. *Espace public* et IA
+
+Au tournant de la *gouvernementalité* foucaldienne, la deuxième grande morphologie que notre thèse convoque est celle de l’*espace public* habermassien. Si Foucault nous aide à voir comment Système F prolonge un *art de gouverner par dispositifs et par sécurité*, Habermas nous oblige à poser une autre question : *dans quel monde communicationnel cette régulation se déroule-t-elle, et selon quelles formes de formation de la volonté prétend-on encore fonder la légitimité des décisions où Système F intervient ?* La section qui suit n’entend pas refaire toute la théorie de l’*agir communicationnel* ; elle vise à mesurer, au plus près de notre cas pratique, ce que cette tradition permet de voir – et ce que le paradigme archicratique vient requalifier.
+
+### **IV.2.1. Rappeler l’*espace public* comme scène de légitimation**
+
+Dans la perspective habermassienne, les sociétés modernes ne peuvent plus fonder la légitimité politique sur une transcendance extérieure (droit naturel, révélation, tradition sacrée) : elles doivent la produire immanquablement, à travers des procédures de délibération où des sujets libres et égaux échangent des arguments sous des conditions de symétrie, de publicité, de sincérité minimale. L’“*espace public*” est un *réseau d’arènes* – *médias, assemblées, forums, associations, controverses* – *où se forme, par confrontation, une opinion et une volonté qui peuvent prétendre à une validité rationnelle*.
+
+Cette *scène délibérative* est prise dans une tension structurante entre monde vécu et systèmes. Le monde vécu désigne les horizons d’expérience, de langage, de culture partagée ; les systèmes – administratif, économique, technologique – obéissent à d’autres logiques, réglées par l’argent, le pouvoir, l’efficacité. La grande inquiétude de Habermas tient dans la colonisation du monde vécu par ces systèmes : *lorsque les impératifs gestionnaires et technocratiques s’imposent au cœur même des domaines où devrait prévaloir l’agir communicationnel, la légitimité se vide de sa substance, sans que les procédures démocratiques disparaissent formellement*.
+
+Dans le langage de notre cadre théorique, l’*espace public* habermassien ressemble beaucoup à une forme spécifique d’*archicration* : une scène de mise en épreuve des fondements (*arcalité*) et des instruments (*cratialité*), où des arguments sont échangés, des objections formulées, des décisions justifiées devant un public. L’*agir communicationnel*, dans cette perspective, est une norme d’*archicration* : une manière de dire *comment, idéalement, une société devrait se donner les scènes où elle met à l’épreuve ses propres régulations*.
+
+### **IV.2.2. Système F du point de vue habermassien : colonisation algorithmique et simulation de la délibération**
+
+Si nous regardons Système F avec ces yeux-là, il apparaît d’abord très clairement du côté des systèmes. Il s’insère dans des appareils administratifs, économiques, médiatiques qui fonctionnent selon des logiques de performance, de réduction d’incertitude, de gestion des flux. Dans les politiques sociales, Système F prépare des décisions en assignant des scores de risque aux dossiers ; dans la santé, il organise l’accès à des programmes intensifs selon des proxies de coûts ; dans la justice, il fournit des évaluations actuarielles de récidive ; dans les plateformes, il filtre l’information par des algorithmes de recommandation.
+
+Du point de vue habermassien, il y a là une forme accrue de *colonisation technico-administrative* : *des décisions qui auraient pu être discutées dans des arènes délibératives* – *que signifie “fraude” dans un État social ? quel compromis entre sécurité et liberté dans telle politique pénale ? quelle répartition juste des ressources de santé* ? – se trouvent progressivement pré-formatées par des dispositifs techniques opérant en amont. Le juge, l’agent de caisse, la médecin, le recruteur, l’utilisateur de plateforme interviennent dans un environnement que Système F a déjà structuré : l’espace des possibles est réduit, les options les plus “raisonnables” ont été présélectionnées par des modèles, les controverses sont déplacées vers des paramètres.
+
+En parallèle, une autre dynamique se met en place : les grands systèmes d’IA, et en particulier les modèles de fondation, peuvent *simuler la délibération*. Ils produisent des textes argumentés, “équilibrés”, capables de mimer les formes du débat public ; ils peuvent être mis au service de consultations en ligne, de synthèses de contributions, de réécriture de documents politiques. Dès lors, l’espace public ne se contente plus d’être filtré par des systèmes : il est partiellement rédigé par eux. On peut imaginer – et l’on voit déjà émerger – des dispositifs où des contributions citoyennes sont agrégées, triées, résumées par des modèles ; où des prises de parole politiques sont assistées, préparées, calibrées par l’IA ; où la surface discursive de la démocratie est saturée de textes produits ou co-produits par des systèmes statistiques.
+
+Pour une lecture habermassienne, le risque est double. D’un côté, *la délibération est déplacée en amont vers des espaces technico-administratifs où des choix structurants sont effectués* (choix de proxies, de métriques, de seuils, de catégories) *sans scène publique adéquate*. De l’autre, elle est *simulée en aval par des dispositifs capables de produire des discours sans pour autant incarner un sujet, une expérience, une responsabilité*. L’espace public devient en partie une vitrine d’énoncés générés, tandis que les décisions les plus lourdes sont prises dans des couches techniques peu visibles.
+
+### **IV.2.3. Ce que la focale habermassienne fait apparaître – et ce qu’elle présuppose**
+
+La force de cette morphologie est de rappeler que la question ne se résume pas à celle des “biais” ou de la “transparence” des systèmes d’IA, mais se développe sur celle de leur insertion dans des processus de formation de la volonté collective. Elle nous oblige à demander : *quelles décisions sont encore susceptibles d’être discutées sur des scènes publiques, et lesquelles sont déjà encapsulées dans des architectures algorithmiques ?* *À quel moment, dans la trajectoire d’une politique, l’introduction de Système F est-elle soumise à un débat, et à quel moment devient-elle un fait accompli ?*
+
+Elle permet également de comprendre pourquoi les *chartes d’*“*IA responsable*”, les procédures de consultation autour de l’IA, les rapports publiés par les autorités peuvent donner une impression de circulation discursive sans pour autant rouvrir réellement la scène des choix. Du point de vue habermassien, il est tout à fait possible que la forme procédurale de la délibération soit respectée (consultations, livres blancs, auditions, débats médiatiques) tandis que la substance de la formation de la volonté – la capacité à peser sur les architectures de Système F – soit très limitée.
+
+Mais cette grille repose aussi sur un ensemble de présupposés que notre paradigme archicratique vient questionner. Habermas suppose, même de manière régulatrice, un *espace public doté d’une certaine cohérence, où des arguments circulent, où des institutions peuvent garantir des conditions minimales de participation et de publicité*. Or notre cas pratique montre une mosaïque de scènes : interfaces de recours en ligne, comités techniques fermés, tribunaux débordés, autorités spécialisées, arènes médiatiques fragmentées, plateformes algorithmiques. L’idée d’un espace public unifié masque en partie la topologie très dégradée que nous avons mise au jour : *hypotopies locales*, *hypertopies cratiales*, *atopies participatives*.
+
+Le modèle habermassien tend également à traiter les systèmes – au sens large – comme des environnements fonctionnels qui interfèrent avec le monde vécu, sans toujours les penser comme des acteurs scéniques à part entière. Dans le cas de Système F, pourtant, l’IA ne peut être qualifiée de “médium” neutre : elle produit des classements, des textes, des formes discursives qui interviennent dans la délibération elle-même. Elle est en quelque sorte un “*quasi-interlocuteur*” *sans visage et sans voix propre, qui conditionne ce qui est visible, plausible, activable*, et qui n’est pas conçue, dans la théorie habermassienne, comme pouvant être elle-même l’objet d’une mise en procès structurée.
+
+### **IV.2.4. Requalification archicratique : de la communication à la scène d’épreuve**
+
+C’est ici que notre paradigme archicratique vient requalifier la question. Là où Habermas distingue principalement entre *agir communicationnel* et *agir stratégique*, entre *monde vécu* et *systèmes*, nous introduisons une autre distinction : celle entre des *scènes d’archicration effectives*, où l’on peut amener ensemble *arcalité*, *cratialité* et *expériences vécues*, et des dispositifs où cette mise en épreuve est empêchée, fragmentée ou simulée.
+
+Appliqué à Système F, cela transforme le diagnostic. Il ne s’agit plus exclusivement de dire : les systèmes d’IA colonisent le monde vécu, ou la délibération est rendue plus difficile. Il s’agit de demander, très concrètement :
+
+- *Où existe-t-il des scènes où les axiomes de Système F* (ce qu’est une fraude, un risque acceptable, un besoin de santé, un talent, un contenu nuisible) *peuvent être explicitement interrogés ?*
+
+- *Où l’on peut faire comparaître, ensemble, les responsables politiques, les concepteurs, les organisations utilisatrices et les personnes affectées, avec des moyens d’accès aux données, aux modèles, aux effets ?*
+
+- *Où l’IA cesse d’être simplement un instrument des systèmes pour devenir un objet d’épreuve dans des arènes publiques dotées de prises réelles ?*
+
+Dans cette perspective, l’important ne se réduit plus à défendre un idéal d’agir communicationnel contre la colonisation systémique, mais de concevoir des architectures scéniques adaptées à Système F : tribunaux de l’algorithme, commissions mixtes dotées de pouvoirs d’enquête sur les modèles, budgets scéniques consacrés à la mise en visibilité de la *cratialité*, droits procéduraux au “différé contradictoire” lorsqu’une décision s’appuie sur l’IA.
+
+L’*espace public* habermassien demeure alors un repère normatif, mais il se trouve topologiquement reconfiguré : il ne s’agit plus d’un seul espace, mais d’un ensemble de scènes d’*archicration* à instituer, à articuler, à relier, pour que la parole ne porte pas seulement sur “l’IA en général”, mais sur les agencements précis où Système F reconfigure la *co-viabilité*.
+
+En ce sens, l’*épreuve morphologique* habermassienne ne s’oppose pas à notre paradigme archicratique ; elle le pousse à clarifier son ambition. Nous ne cherchons pas à déplorer une colonisation du monde vécu par les algorithmes, ni à idéaliser une délibération qui serait miraculeusement à l’abri des systèmes. Nous cherchons à savoir dans quelles scènes concrètes Système F peut être mis en épreuve comme dispositif archicratique – et *à quelles conditions ces scènes peuvent, réellement, peser sur l’arcalité et la cratialité qui le structurent*. C’est cette exigence, plus exigeante encore que la simple opposition entre communication et stratégie, qui orientera la suite de notre cas pratique.
+
+## **IV.3. Rancière, Boltanski–Thévenot et les épreuves**
+
+Avec Rancière d’un côté, Boltanski et Thévenot de l’autre, notre cas pratique rencontre deux traditions qui déplacent le regard : il ne s’agit plus d’abord de dispositifs ou d’espaces publics, mais d’*épreuves* – *au double sens de tests et de mises à l’épreuve*. La première insiste sur l’*irruption du dissensus*, sur la capacité de ceux qui ne comptaient pas pour reconfigurer la scène ; la seconde décrit, de façon minutieuse, les *grammaires de justification* au sein desquelles des personnes, des actes et des objets sont évalués. Pour un dispositif comme Système F, ces deux focales sont précieuses : elles nous obligent à voir comment l’IA organise déjà des épreuves silencieuses, et comment un paradigme archicratique digne de ce nom doit chercher à *les ramener dans des épreuves publiques, pluriellement justifiables*.
+
+### **IV.3.1. Le partage du sensible et les “sans-part” face à Système F**
+
+Chez Rancière, la politique n’est pas l’administration ordinaire des affaires communes ; elle n’est pas le “bon fonctionnement” des institutions. Elle surgit lorsqu’un *ordre donné* – qu’il appelle la *police* – est *mis en défaut par l’apparition de ceux qui n’y avaient pas de place, par la revendication d’une part pour des “sans-part” qui s’emparent d’un sujet*. La *police*, ici, n’est pas nécessairement l’institution policière ; c’est l’*ensemble des agencements qui distribuent les positions, les capacités de parler, les modes de visibilité* : qui est audible, qui ne l’est pas, quelles catégories sont reconnues, quelles existences restent hors champ. La politique, comme *dissensus*, consiste à *troubler ce partage du sensible*, à faire apparaître comme sujet politique celui qui n’était compté que comme bruit, charge, problème social.
+
+Si l’on transpose ce schème à Système F, la première chose qui apparaît est la *puissance de ce dispositif dans la production de partages* : partages entre “fraudeurs” et “bénéficiaires légitimes”, entre “patients à haut risque” et “patients ordinaires”, entre “candidatures prometteuses” et “profils faibles”, entre “contenus valables” et “contenus problématiques”. Chaque score, chaque seuil, chaque classification opère un tracé : qui mérite un contrôle prioritaire, qui peut entrer dans un programme de soins, qui a droit à une chance de recrutement, qui est montré et qui est enfoui dans un flux.
+
+Rancière nous aide à voir que ces opérations ne se réduisent pas à de simples décisions techniques ; elles participent d’un *partage du sensible*. Les familles injustement classées comme frauduleuses, les patients dont les besoins sont invisibilisés par un proxy de coût, les candidats déclassés par un apprentissage biaisé, les voix minoritaires surreprésentées dans les suspensions de contenus : toutes ces figures sont autant de “*sans-part*” *statistiques*. Elles apparaissent dans les bases de données comme des lignes, des vecteurs, des points dans un espace de caractéristiques ; mais leur *capacité à se présenter comme sujets, à raconter ce qui leur arrive, à contester la manière dont elles sont distribuées, est extrêmement limitée*.
+
+Dans cette perspective, les épreuves organisées par Système F sont des *épreuves de police* : des tests qui reconduisent et affinent la distribution existante des parts, sans ouvrir la possibilité pour ceux qui en sont les objets de se poser comme sujets. La politique, au sens ranciérien, supposerait ici que des personnes classées, scorées, profilées puissent émerger comme collectifs capables de dire : “nous ne voulons plus être simplement ces catégories-là ; nous ne voulons plus être gouvernés selon ces partages”. Or notre cas pratique montre que les configurations scéniques actuelles – guichets, interfaces de recours, comités, tribunaux – laissent très peu d’espace à ce type d’irruption : les “sans-part” de Système F sont dispersés, souvent isolés face à une décision individuelle, rarement en situation de produire un dissensus structuré.
+
+L’apport de Rancière, pour notre cas, est donc double. D’une part, il souligne que *Système F* n’est pas seulement un dispositif de calcul ; c’est un *opérateur de distribution des places et des voix*. D’autre part, il rappelle que toute scène d’*archicration* digne de ce nom doit *laisser une place à l’événement politique* : la *mise en défaut des catégories établies par des sujets qui se déclarent autrement que ce que le dispositif avait prévu*.
+
+### **IV.3.2. Grammaires de justification et formats d’épreuve**
+
+La perspective de Boltanski et Thévenot est d’une autre nature, complémentaire. Là où Rancière insiste sur la rupture, sur l’événement du dissensus, ils se concentrent sur les moments où des acteurs cherchent à justifier leurs positions, leurs décisions, leurs critiques. Dans *De la justification*, ils dégagent une série de “cités” ou économies de la grandeur – industrielle, marchande, domestique, civique, inspirée, de l’opinion, puis d’autres encore – qui fournissent autant de *grammaires de justice*. Chaque cité propose une *conception de ce qui compte comme grand, digne, justifiable* ; elle *s’accompagne de formats d’épreuve, d’objets de référence, de types de preuves* : tests de performance et indicateurs pour la cité industrielle, prix et contrats pour la cité marchande, procédures et droits pour la cité civique, etc.
+
+Du point de vue de notre cas, Système F apparaît comme un dispositif qui condense plusieurs de ces grammaires, mais sous une forme statistique et silencieuse. Lorsqu’un modèle est optimisé pour réduire la fraude sans “coûts excessifs”, la cité industrielle (efficacité, performance) et la cité civique (protection de l’équité, de la solidarité) sont mêlées dans une fonction de coût, sans que cette composition soit explicitée. Lorsqu’un algorithme de recrutement est calibré pour repérer les “meilleurs talents”, la cité industrielle (compétence, productivité) et la cité marchande (valeur sur le marché, attractivité) se combinent dans des scores, tandis que la cité civique (égalité, non-discrimination) reste à la marge, sous la forme de contraintes parfois ajoutées après coup. Lorsqu’un système de modération “assainit” un espace numérique, la cité civique (droits, sécurité), la cité de l’opinion (réputation, image) et parfois la cité inspirée (authenticité, expression) s’entrecroisent dans des politiques de plateforme.
+
+Ce que la focale Boltanski–Thévenot permet de voir, c’est que *Système F organise déjà des épreuves* : *épreuves de mérite, de risque, de respect des règles, de valeur économique*. Simplement, ces épreuves sont *encapsulées dans des architectures* : au lieu de se dérouler sous la forme de controverses où des acteurs invoquent explicitement l’une ou l’autre “cité” pour justifier leurs positions, elles se cristallisent dans des métriques et des seuils. On ne débat pas publiquement pour savoir si l’on accepte de privilégier la grandeur industrielle (efficacité) au détriment de la grandeur civique (égalité) dans tel dispositif de tri de dossiers ; on choisit un indicateur, un proxy, un algorithme d’optimisation, et le compromis est inscrit dans la machine.
+
+Dans ce sens, les *épreuves de Système F sont dépourvues de scène* : *elles ont lieu, mais elles n’ont pas d’arène de controverses*. Des personnes sont jugées “adaptées” ou “non adaptées”, des dossiers “éligibles” ou “non éligibles”, des contenus “autorisés” ou “retirés”, mais sans que les grammaires de justification qui sous-tendent ces jugements soient exposées, discutées, hiérarchisées en commun. Le paradigme des *économies de la grandeur* nous rappelle alors une exigence qui converge avec la nôtre : *toute justice sociale suppose la possibilité de pluraliser les registres de justification, de faire apparaître les tensions entre grandeurs, au lieu de les laisser se résoudre en silence dans des dispositifs techniques*.
+
+### **IV.3.3. Épreuves silencieuses et confiscation archicratique**
+
+En combinant ces deux apports, nous pouvons affiner encore notre diagnostic sur Système F. Les scores, seuils et classements ne sont pas seulement des outils techniques ; ce sont des *épreuves silencieuses*. Silencieuses au sens où elles *ne sont pas annoncées comme telles* : les personnes dont le dossier est trié ou dont le contenu est déclassé ne savent pas toujours qu’elles “passent un test”, ni selon quels critères. Silencieuses aussi au sens où les *formats d’épreuve* (les variables retenues, les marges d’erreur acceptées, les grandeurs privilégiées) *ne sont pas exposés*, ni réellement justifiables devant celles et ceux qui les subissent.
+
+Du point de vue ranciérien, ces épreuves silencieuses stabilisent un partage du sensible sans laisser de prise à ceux qui voudraient le contester. Du point de vue de Boltanski–Thévenot, elles court-circuitent la possibilité pour des acteurs de mobiliser plusieurs cités, de dire par exemple : “vous invoquez l’efficacité industrielle, mais ici la grandeur civique ou domestique devrait primer”, ou encore : “vous mesurez la performance économique, mais vous négligez la dignité, la santé, la reconnaissance”. Dans notre vocabulaire, elles participent d’une *confiscation archicratique* : *la mise en épreuve des fondements et des instruments est captée à l’intérieur des architectures de Système F, qui se substituent à des scènes d’archicration ouvertes*.
+
+Nous retrouvons ici, mais sous un angle différent, ce que les parties précédentes avaient décrit comme *oblitération scénique* et *tendance autarchicratique* : *la régulation s’évalue elle-même à l’intérieur de ses propres formats d’épreuve, en fonction de ses propres métriques de succès, sans s’exposer à des épreuves externes où d’autres grandeurs, d’autres parts, d’autres récits pourraient intervenir*.
+
+### **IV.3.4. L’*archicration* comme réouverture des épreuves, plurielle et instituée**
+
+C’est précisément à ce point que notre paradigme archicratique entend prolonger et déplacer ces deux traditions. Avec Rancière, nous retenons qu’il n’y a *pas de véritable scène sans possibilité de dissensus* : *sans capacité pour des “sans-part” de se déclarer, de troubler les partages établis*. Avec Boltanski et Thévenot, nous retenons qu’il n’y a *pas de justice sans pluralité des grammaires de justification et sans formats d’épreuve qui permettent de les confronter*.
+
+Mais l’*archicration*, telle que notre thèse la formule, ajoute une exigence propre : il ne suffit pas d’espérer des événements de dissensus, ni de décrire des cités de justice ; il faut *concevoir des scènes instituées où ces épreuves peuvent être rejouées face aux dispositifs eux-mêmes*. Pour Système F, cela signifie inventer des lieux, des procédures, des instruments où :
+
+- les *personnes affectées* ne sont plus seulement des objets de score, mais des *sujets d’énonciation capables de contester la manière dont elles sont distribuées* ;
+
+- les *différentes cités* – efficacité, sécurité, égalité, solidarité, dignité, soutenabilité – *puissent être mobilisées explicitement pour évaluer, critiquer, réviser les choix incorporés dans les modèles* ;
+
+- les *concepteurs*, les déc*ideurs*, les *agents*, les *usagers* soient *réunis dans des épreuves publiques où les architectures techniques elles-mêmes deviennent discutables* : que mesure-t-on, au juste ? Quelles erreurs accepte-t-on, pour qui ? Quelles parties de la population sont laissées hors du champ d’entraînement ? Quelles formes de vie, quels profils, sont systématiquement défavorisées ?
+
+Autrement dit, l’*archicration* ne vise pas à substituer un registre de justification unique à ceux que Rancière et Boltanski–Thévenot décrivent ; elle cherche à créer les conditions scéniques où ces registres peuvent se croiser, se confronter, se transformer au contact des dispositifs.
+
+Pour notre cas pratique, cette section clôt la boucle morphologique : *Système F* apparaît comme un *organisateur d’épreuves silencieuses qui figent des partages du sensible et des grandeurs de justice à l’intérieur de ses architectures*. L’enjeu archicratique est désormais clair : il s’agit de travailler à des *épreuves nouvelles*, *instituées*, *pluriellement justifiables*, *où les IA de fondation intégrées à la régulation cessent d’être les juges muets des vies et des trajectoires pour devenir, à leur tour, des objets de mise en épreuve*. C’est à cette condition que la puissance descriptive de Rancière et de Boltanski–Thévenot peut être intégrée à notre paradigme, sans le dissoudre, et que notre cas pratique sur Système F peut prétendre montrer concrètement ce que signifie “*remettre en scène*” des régulations qui, aujourd’hui, se testent elles-mêmes dans le secret de leurs modèles.
+
+##

src/content/cas-ia/chapitre-5.mdx

@@ -0,0 +1,135 @@
+---
+title: "Chapitre V — Épreuve historique"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 60
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_5_Epreuve_Historique.docx"
+---
+# V. Épreuve historique : IA, quatrième et cinquième révolutions régulatrices
+
+Les quatre premières parties de notre cas pratique ont traité Système F comme un dispositif déjà là, déjà actif : un système de décision distribué dans des guichets, des interfaces, des comités, des tribunaux ; une chaîne cratiale qui manipule scores, seuils, proxies ; un opérateur qui recompose des scènes d’épreuve sans jamais se donner vraiment comme tel. L’épreuve historique introduit un autre type de question : non plus seulement “*où et comment Système F régule-t-il aujourd’hui ?*”, mais “*dans quelle séquence régulatrice s’inscrit-il ? de quelle histoire prolongée est-il l’expression, et de quelle histoire possible est-il le laboratoire ?*”. Autrement dit, il s’agit de replacer ce que nous avons décrit, au fil des sections I à IV, dans la généalogie archicratique développée au chapitre 4 de l’essai-thèse : celle des révolutions industrielles relues comme révolutions régulatrices.
+
+Dans cette généalogie, chaque “*révolution industrielle*” n’est pas seulement une mutation de machines ou de sources d’énergie ; elle est la reconfiguration d’un régime de *co-viabilité*, d’un agencement spécifique entre *arcalité, cratialité* et *archicration*. La première révolution installe une *puissance thermo-mécanique* et un *capitalisme manufacturier* qui déplacent la scène de la régulation du village vers l’*usine* ; la deuxième organise les *grandes infrastructures*, les *empires* et les *États-nations* autour de *réseaux matériels et scripturaux* ; la troisième, *technoscientifique* et *mass-médiatique*, *sature le monde en normes, en statistiques, en dispositifs d’expertise qui travaillent à distance les populations*. La quatrième révolution, telle que nous l’avons formulée dans la thèse, ne se réduit pas à la “*numérisation*” au sens trivial ; elle se caractérise par une *clôture douce de la régulation* : pilotage par la donnée, indicateurs qui se présentent comme incontestables, scripts organisationnels qui encadrent les comportements sans que la scène du débat ne soit explicitement supprimée – elle est absorbée dans les interfaces, dans les formulaires, dans les tableaux de bord. C’est cette dynamique que nous retrouvons dans Système F : *datafication massive* *des existences*, *gouvernement par variables* et *fonctions de coût*, *absorption de la conflictualité potentielle dans des séquences d’optimisation*.
+
+L’épreuve historique que nous ouvrons maintenant a donc un premier objectif : vérifier si Système F doit être compris comme un simple produit avancé de cette quatrième révolution régulatrice, un degré supplémentaire de la logique “*numérisation intégrale* – *pilotage par indicateurs* – *script sans débat*”. Tout, dans sa configuration, semble y inviter : les flux de dossiers, de contenus, de CV, de patients sont convertis en vecteurs de caractéristiques ; des modèles de fondation compilent des régularités extraites d’archives scripturo-bureaucratiques et de traces marchandes ; la régulation se présente comme gestion anticipatrice de risques, de coûts et de performances. Sous cet angle, Système F est l’enfant exemplaire de la quatrième révolution : il ne détruit pas la scène, il la rend superflue en prétendant faire son travail à sa place, en continu, par des ajustements numériques.
+
+Mais la thèse ne s’arrête pas à ce constat. Au chapitre 4 et dans la conclusion générale, nous avons esquissé l’hypothèse d’une cinquième révolution régulatrice, que nous avons appelée *révolution scénique* : non pas une nouvelle vague d’automatisation ou de connectivité, mais une mutation dans le statut de la scène elle-même. Là où la quatrième révolution tend à rendre la régulation hors scène – traitements en arrière-plan, décisions pilotées par des métriques auto-référées, effacement du différé – la cinquième serait, si elle advient, une *révolution du faire-apparaître* : *réinstitution de scènes d’épreuve comme opérateurs centraux de la co-viabilité*, *promotion du différé comme droit et comme technique*, *reconnaissance de l’archicration comme condition de légitimité* et non comme supplément facultatif. Dans cette perspective, la question n’est plus : “l’IA est-elle une quatrième révolution de plus ?”, mais : “le développement de Système F rend-il nécessaire, pensable, exigible, une révolution scénique ?”.
+
+La Partie V se situe précisément dans cet entre-deux : elle doit à la fois prendre au sérieux Système F comme intensification de la quatrième révolution régulatrice, et tester la pertinence de l’hypothèse d’une cinquième. Dans un premier mouvement, nous montrerons comment le grand système d’IA de fondation condense tous les traits de la numérisation intégrale décrite dans l’essai-thèse : *généralisation de la datafication*, *gouvernance par indicateurs*, *clôture des boucles de rétroaction dans des métriques internes*, *absorption de la scène dans des interfaces* qui cadrent non seulement les décisions, mais aussi les possibilités de contestation. Dans un second mouvement, nous reformulerons, à partir de ce terrain, ce que pourrait signifier une révolution scénique appliquée à l’IA : non pas une simple “transparence” des modèles ou des codes, mais une reconfiguration des architectures scéniques autour de Système F – scènes où l’on pourrait convoquer les fonctions de coût, les proxies, les seuils, les choix d’entraînement, en présence des personnes affectées, dans des formes d’épreuve opposables.
+
+Enfin, la Partie V proposera des scénarios contrastés, comme instruments d’analyse : un scénario d’*autarchicratie numérique* avancée, où Système F devient l’infrastructure invisible de la régulation et où les scènes humaines ne sont plus que des façades ; un scénario de révolution scénique partielle, où quelques secteurs se dotent de tribunaux de l’algorithme, de droits au différé, de budgets scéniques, sans que la logique globale ne change ; et un scénario de réarmement archicratique transversal, où les exigences de mise en scène, de différé et de comparution deviennent des contraintes explicites pour tout déploiement d’IA. L’épreuve historique n’aura atteint son but que si elle permet de dire, de manière argumentée, où se situe aujourd’hui Système F dans cette constellation, et quelles marges de manœuvre restent ouvertes pour orienter, plutôt que subir, le régime régulateur dont il est l’un des vecteurs les plus puissants.
+
+## V.1. IA comme intensification de la quatrième révolution régulatrice
+
+Avant de formuler l’hypothèse d’une cinquième révolution régulatrice, il faut d’abord accepter de regarder Système F pour ce qu’il est déjà : un concentré de la quatrième révolution telle que nous l’avons décrite dans l’essai-thèse. Celle-ci ne se réduit ni à l’informatique, ni au “numérique” en général, mais à une reconfiguration de la régulation autour de trois traits solidaires : une *gouvernementalité par les nombres* qui tend à supplanter la référence explicite à la loi ; une *datafication massive des existences*, qui fait de la vie sociale un matériau statistique en continu ; une *absorption progressive de la scène dans des scripts et des interfaces*, qui assurent la clôture douce des arbitrages. Cette section a pour objet de montrer que Système F n’est pas une excroissance marginale de cette quatrième révolution, mais l’un de ses produits paradigmatique : il pousse au maximum la logique de gouvernance par indicateurs, il vit de la datafication intégrale des populations, et il organise la disparition de la scène derrière des écrans, des formulaires et des fonctions de coût.
+
+### V.1.1. Clôture douce et gouvernement par les nombres
+
+Dans notre généalogie archicratique, la quatrième révolution régulatrice s’annonçait par ce qu’Alain Supiot a nommé une “*gouvernance par les nombres*” : un déplacement progressif de la référence au droit vers des *dispositifs de pilotage qui prennent pour langage exclusif des objectifs chiffrés, des comparateurs, des indicateurs de performance*. Il ne s’agit pas exclusivement d’ajouter des chiffres à des politiques préexistantes, mais de *substituer au jugement juridico-politique l’évaluation permanente par des métriques qui se présentent comme neutres*. L’obéissance à la loi cède la place à la *conformité à des taux, des ratios, des scores* ; le travail des institutions consiste de plus en plus à “faire remonter” des indicateurs et à “tenir les objectifs”.
+
+La *socio-histoire de la quantification*, telle qu’Alain Desrosières l’a patiemment reconstruite, montre *comment cette montée des nombres comme instruments de gouvernement repose sur des conventions, des découpages, des classifications qui ne sont jamais purement techniques*. Les *statistiques* et *indicateurs* ne se contentent pas de refléter un état du monde : ils *organisent ce monde en catégories d’intervention* (chômeurs, fraudeurs, “patients à risque”, “bons élèves”, territoires en difficulté), *en ouvrant certaines options d’action et en omettant d’autres*. Mais là où, dans les phases antérieures, la construction de ces catégories restait liée à des scènes identifiables – commissions, négociations, débats, compromis législatifs –, la quatrième révolution régulatrice tend à disperser ce travail de construction dans des réseaux d’expertise, de consultants, de plateformes logicielles. C’est ce que Rouvroy et d’autres désignent comme une *gouvernementalité algorithmique* : un *mode de pouvoir qui opère à partir de masses de données et de corrélations, sans jamais avoir besoin d’énoncer explicitement la norme*.
+
+Système F condense cette dynamique. Dans tous les domaines où il intervient, l’objectif politique initial – protéger l’État social, réduire des risques sanitaires, limiter la récidive, améliorer la qualité du recrutement, assainir les espaces numériques – se trouve traduit en indicateurs internes et en fonctions de coût : taux de fraude détectée, économies réalisées, probabilité estimée de récidive, proportion de “bons” recrutements, volume de contenus “conformes”. Ces grandeurs ne sont pas que des compteurs ; elles deviennent la *norme incorporée du système*. À ce moment-là, la clôture douce décrite dans la thèse se manifeste pleinement : *la régulation n’est plus explicitement justifiée par un débat sur les finalités, elle se trouve présupposée par les objectifs chiffrés qu’on a assignés au dispositif et qu’il poursuit avec une forme d’obstination mathématique*.
+
+### V.1.2. *Datafication massive* : Système F dans la société des traces
+
+La quatrième révolution régulatrice se laisse aussi saisir à travers le *processus de datafication*, au sens où Mayer-Schönberger, Cukier et d’autres auteurs ont décrit l’*élargissement des sphères de la vie sociale transformées en données calculables*. Ce n’est plus seulement la production industrielle ou les flux financiers qui sont mesurés, mais les interactions sur les réseaux sociaux, les déplacements, les historiques d’achat, les usages des services publics, les comportements en ligne. Chaque geste laisse une trace ; chaque trace peut être agrégée, profilée, recombinée.
+
+Les travaux sur le “*digital welfare state*” menés sous l’égide des Nations unies, notamment par Philip Alston, montrent que les systèmes d’aide sociale sont devenus des laboratoires privilégiés de cette *datafication* : les États construisent de vastes infrastructures numériques pour collecter, croiser et analyser des données sur les populations vulnérables, avec des promesses d’efficacité et de ciblage, mais aussi des risques accrus de surveillance et de sanction automatisée. C’est exactement ce que nous avons vu dans les cas SyRI ou du scandale des allocations néerlandaises : la protection sociale se rejoue dans des systèmes qui reposent sur la multiplication des données et sur leur raccordement à des modules de profilage.
+
+*Système F*, sous cet angle, n’est pas une innovation isolée : il est la *forme “mature” d’un monde déjà datafié*. Il suppose l’*existence de corpus massifs et hétérogènes* : historiques de prestations, archives judiciaires, dossiers médicaux, CV et trajectoires professionnelles, flux de contenus numériques. Il ne se contente pas de puiser dans un registre ; il *rassemble, sous la forme d’un modèle de fondation, des régularités apprises sur des univers de données distincts*, qu’il *recompose dans des applications sectorielles*. La *datafication* cesse alors d’être un effet secondaire de la numérisation ; elle devient l’alimentation continue d’un dispositif qui, pour fonctionner, a besoin que les vies soient constamment converties en entrées et sorties de modèles. Ce n’est pas un hasard si les politiques contemporaines de l’IA, en Europe comme ailleurs, insistent tant sur l’accès aux “*données de qualité*” : sans ces flux, Système F ne pourrait ni être entraîné, ni être ajusté, ni être évalué.
+
+### V.1.3. Gouvernance par variables : l’indicateur devenu architecture interne
+
+L’un des apports de Desrosières à la compréhension des régimes contemporains de quantification est d’avoir montré que les *indicateurs publics* n’étaient pas de simples résumés, mais des *compromis incorporés entre des intérêts, des visions du monde, des techniques*. La quatrième révolution régulatrice se caractérise par le fait que ces *indicateurs* cessent de rester à la périphérie des décisions : ils deviennent la *langue même dans laquelle les décisions doivent être formulées pour être recevables dans les organisations*. La “bonne” politique est celle qui améliore les bons chiffres ; la “bonne” gestion, celle qui fait progresser les bons KPI.
+
+Dans Système F, cette logique est poussée à son point limite, car l’indicateur ne se réduit pas à un chiffre affiché dans un rapport, il est l’*élément constitutif d’une fonction de coût*. Dire que le système cherche à “*maximiser la détection de fraude tout en minimisant les faux positifs*” ou à “*cibler les patients à haut risque de manière efficiente*” signifie qu’on a *défini, quelque part dans son architecture, une combinaison de variables qui attribue une valeur à chaque décision possible, en fonction de quelques objectifs hiérarchisés*. Les variables qui entrent dans cette combinaison – nationalité, quartier, montant de l’allocation, coûts de santé passés, type de contrat, historique de navigation – ne sont pas de simples colonnes dans un tableau : elles sont les véhicules par lesquels se transmet une conception du risque, du mérite, de la vulnérabilité ou de la dangerosité.
+
+C’est ici que l’intensification propre à Système F devient visible. Dans les régimes de pilotage par indicateurs classiques, il restait possible de discuter un taux ou un ratio en séance : contester un chiffre, en proposer un autre, négocier les cibles. Dans un dispositif comme Système F, la plupart des indicateurs pertinents n’apparaissent jamais comme tels aux yeux des acteurs. Ils sont encapsulés dans des modèles et des proxies, traduits en pertes et en gradients dans l’espace abstrait de l’optimisation. Nous avons vu, avec l’algorithme de gestion des risques en santé étudié par Obermeyer et ses collègues, qu’un simple *choix de proxy* – utiliser les coûts de santé comme approximation des besoins cliniques – suffit à produire un *biais massif dans l’accès* à des programmes de soins intensifs pour des patients noirs, *sans que ce choix n’ait été mis en scène comme tel*. De ce point de vue, la *gouvernementalité par les nombres* se mue en *gouvernance par variables* : ce ne sont plus des indicateurs publics que l’on peut disputer, *ce sont des grandeurs internes au modèle, souvent inaccessibles, qui structurent l’allocation des ressources et des sanctions*.
+
+### V.1.4. Absorption de la scène dans les interfaces : la forme achevée de la clôture douce
+
+La quatrième révolution régulatrice, dans notre thèse, se distinguait enfin par l’*absorption progressive de la scène dans des dispositifs qui jouent à la fois le rôle de canal d’accès aux droits, de script de comportement et de filtre des contestations*. Les guichets devenus portails, les démarches transposées en formulaires en ligne, les espaces de débat réduits à des consultations numériques émaillées de questions fermées composent ce que nous avons appelé une *topologie de scènes appauvries* : *la possibilité d’un différé, d’une confrontation, d’une mise en procès y subsiste en droit, mais elle est rendue matériellement difficile, voire improbable*.
+
+Système F représente, de ce point de vue, la forme achevée de cette *clôture douce*. Pour les personnes affectées, la régulation se manifeste sous la forme d’une décision standardisée – une prestation suspendue, un refus motivé par une formule stéréotypée, un compte désactivé, une visibilité réduite – ou sous la forme d’un simple silence, lorsque la candidature n’est pas retenue ou que le post “ne prend pas”. Pour les agents, la présence de Système F se confond avec celle d’une interface qui propose des listes triées, des recommandations, des alertes colorées, des scripts de réponse. L’essentiel des arbitrages – choix des variables, des fonctions de coût, des seuils – se prend ailleurs, dans des *hypertopies techniques* où se croisent ingénieurs, juristes, managers, sans que ces espaces soient institués comme scènes d’*archicration*.
+
+L’épreuve historique permet alors de formuler plus nettement ce que nous n’avions, dans la thèse, qu’esquissé : Système F n’introduit pas une qualité totalement inédite de pouvoir, mais il réalise l’une des figures les plus avancées de la quatrième révolution régulatrice. Il condense dans un même dispositif la *gouvernance par les nombres* analysée par Supiot, la *politique des grands nombres* étudiée par Desrosières, la *datafication généralisée* décrite par Mayer-Schönberger et Cukier, et la *gouvernementalité algorithmique* théorisée par Rouvroy. C’est justement parce qu’il porte à ce point la logique de la quatrième révolution que Système F fait apparaître ses limites : la distance grandissante entre la puissance de la régulation et la pauvreté des scènes où elle peut être mise en épreuve. La section suivante pourra dès lors poser, de manière moins spéculative et plus ancrée, la question de ce que signifierait, dans ce paysage, une véritable révolution scénique appliquée à l’IA : non pas un supplément de visualisation, mais une *réinvention des architectures d’archicration autour des dispositifs mêmes qui gouvernent désormais nos formes de co-viabilité*.
+
+## V.2. Hypothèse de cinquième révolution scénique appliquée à l’IA
+
+L’épreuve historique ne s’achève pas avec le constat selon lequel Système F intensifie la quatrième révolution régulatrice. Elle ouvre au contraire une bifurcation conceptuelle : soit l’on considère que la numérisation intégrale, la gouvernance par variables et l’absorption de la scène dans les interfaces constituent l’horizon indépassable de la régulation contemporaine ; soit l’on prend au sérieux l’idée, esquissée dans l’essai-thèse, d’une cinquième révolution, non plus techno-industrielle, mais scénique. Cette hypothèse n’ajoute pas un gadget normatif de plus à un paysage déjà saturé de chartes ; elle propose un renversement du centre de gravité régulateur : *faire de la scène d’épreuve, du différé et de la comparution un opérateur structurel de la co-viabilité*, et non une simple couche de “transparence” déposée après coup sur des dispositifs déjà oblitérés. Cette section se consacre à préciser ce que signifie, dans le cas d’un grand système d’IA comme Système F, une telle révolution scénique : comment elle se distingue des demandes courantes de “transparence algorithmique”, comment elle reconfigure le triptyque archicratique, et en quel sens elle mérite le nom de révolution régulatrice plutôt que celui de réforme cosmétique.
+
+### V.2.1. Ce que nomme la “révolution scénique” dans l’essai-thèse
+
+Dans l’architecture générale de l’essai-thèse, la cinquième révolution régulatrice était introduite non comme une certitude historique, mais comme une hypothèse critique : après une séquence où les pouvoirs régulateurs se sont progressivement déportés vers des infrastructures techniques, des standards, des indicateurs et des algorithmes, il devient nécessaire d’imaginer une configuration où la scène n’est plus un reste résiduel, mais un opérateur principal. Par “révolution scénique”, nous n’entendons pas le retour nostalgique à des formes de publicité anciennes (agora, Parlement, place publique), mais l’*invention de nouveaux dispositifs de comparution* : *scènes où les fondements (arcalités) et les instruments (cratialités) de la régulation peuvent être amenés, réglés, contestés, dans des formats adaptés à l’épaisseur technique et globale des chaînes contemporaines*.
+
+Dans ce cadre, la scène n’est pas un simple décor où l’on “communique” sur ce qui a déjà été décidé ; elle est un lieu où l’on peut suspendre, différer, rejouer les décisions et les dispositifs. La révolution scénique désigne cette mutation où le *droit au différé*, la *possibilité d’un recours contradictoire*, *l’existence de tribunaux spécialisés*, de *budgets scéniques* et d’*instances de contre-expertise* ne sont plus des exceptions, mais des *conditions de validité de toute régulation ambitieuse*. Autrement dit : là où la quatrième révolution tend à fermer les boucles de régulation dans des circuits de données et de modèles auto-évalués, la cinquième consisterait à rouvrir ces boucles vers l’extérieur, en instituant des lieux où elles doivent rendre compte – et pas seulement se montrer.
+
+### V.2.2. Pourquoi l’IA rend la révolution scénique plus que spéculative
+
+Appliquée à Système F, l’hypothèse d’une cinquième révolution scénique n’est pas un simple exercice d’anticipation. Tout ce que nous avons reconstruit dans les parties I à IV pointe vers un même nœud : l’*écart croissant entre la puissance régulatrice de Système F et la pauvreté des scènes où cette puissance peut être mise en épreuve*. Les cas de la protection sociale, de la justice pénale, de la santé, du recrutement, des plateformes montrent que des pans entiers de la distribution des droits, des soins, des sanctions, des opportunités et de la visibilité sont désormais affectés par des *chaînes algorithmico-organisationnelles* dans lesquelles les personnes concernées ne disposent que d’une information mince et de recours faiblement outillés. Les configurations topologiques que nous avons décrites – *hypotopies locales, hypertopies expertes, archicrations fantômes* – ne sont pas des accidents : elles sont la forme concrète de la *clôture douce* propre à la quatrième révolution.
+
+Dans ce contexte, l’hypothèse d’une révolution scénique cesse d’être purement spéculative pour prendre la forme d’une nécessité négative : soit l’on accepte que des dispositifs comme Système F deviennent les lieux effectifs de la régulation, sans scènes à leur mesure, au prix de tensions croissantes sur la légitimité et la co-viabilité ; soit l’on travaille à *instituer des scènes capables d’accueillir ces dispositifs, de les examiner, de les contraindre*. La cinquième révolution régulatrice ne se pose pas ici comme un “progrès” automatique, mais comme une bifurcation : ou bien la quatrième révolution se durcit en *autarchicratie numérique*, où les modèles et les indicateurs deviennent leurs propres juges ; ou bien elle ouvre, par la conflictualité qu’elle suscite, la *possibilité de dispositifs d’archicration à une autre échelle*. L’IA n’est pas le seul terrain où cette alternative se joue, mais elle en est l’un des plus concentrés : parce qu’elle est à la fois l’emblème d’une puissance technique globale et le vecteur discret de micro-décisions quotidiennes.
+
+### V.2.3. Reconfiguration archicratique : ce que serait une révolution scénique de l’IA
+
+Dire qu’une cinquième révolution régulatrice serait scénique, dans le cas de Système F, c’est d’abord préciser ce que deviendraient, dans un tel régime, les trois prises archicratiques. Pour l’*arcalité*, une révolution scénique ne se résume pas à multiplier les “principes éthiques” et les déclarations de valeur : elle exigerait que les *choix fondamentaux qui orientent Système F – définition de la fraude, du risque acceptable, du besoin, du mérite, du contenu nuisible – soient exposés dans des arènes où ils peuvent être discutés, amendés, contestés par des acteurs qui ne sont pas uniquement les concepteurs, les intégrateurs et les régulateurs sectoriels*. Cela suppose non seulement des textes, mais des *procédures* : *qui peut demander la révision d’une fonction de coût ? qui décide d’autoriser ou d’interdire l’usage d’un proxy donné ? selon quelle procédure sont définis les critères d’éligibilité à un programme de soins ou à un dispositif social lorsqu’ils passent par Système F ?*
+
+Du côté de la *cratialité*, une révolution scénique n’impliquerait pas de démanteler les architectures techniques, mais de les soumettre à des régimes d’épreuve qui ne soient plus entièrement internes. Aujourd’hui, la plupart des ajustements de Système F se font dans des boucles fermées : collecte de données, entraînement, validation, déploiement, monitoring, ré-entraînement ; les seules scènes où ces chaînes apparaissent sont des comités techniques, des audits partiellement indépendants, des contentieux dispersés. Une architecture scénique de cinquième révolution supposerait des lieux où l’on peut demander la suspension d’un module, exiger la mise au jour des jeux de données et des pipelines, contester les critères d’évaluation d’un modèle, imposer des transformations structurelles – et pas seulement recommander des corrections à la marge.
+
+Quant à l’*archicration* elle-même, une révolution scénique signifierait qu’elle cesse d’être résiduelle pour devenir condition d’existence de Système F comme dispositif légitime. Concrètement, cela veut dire que l’on ne pourrait pas déployer un système de scoring social, de tri pénal, de gestion des risques en santé, de recrutement ou de modération à grande échelle sans qu’existent, en regard, des scènes instituées où ces systèmes puissent être mis en procès : *tribunaux de l’algorithme, commissions d’enquête dotées de pouvoirs d’accès, instances mixtes associant administrations, développeurs, syndicats, associations, chercheurs, où l’on examine les effets, les biais, les arbitrages, et où l’on peut exiger des transformations contraignantes*. La révolution scénique ne consisterait pas à faire “participer” symboliquement les publics ; elle consisterait à *rendre l’archicration opposable* : un dispositif aussi puissant que Système F ne pourrait se maintenir que s’il accepte périodiquement de comparaître, de se laisser suspendre, modifier, reconfigurer à la lumière de ces épreuves.
+
+### V.2.4. Au-delà de la “*transparence*” : du voir au faire-apparaître
+
+Il est essentiel, pour éviter les malentendus, de distinguer cette hypothèse de révolution scénique des discours aujourd’hui dominants sur la “transparence” de l’IA. La transparence est le plus souvent pensée comme un problème de visibilité : rendre les modèles explicables, documenter les flux de données, publier des fiches systèmes, ouvrir des interfaces de monitoring. Ces initiatives ne sont pas négligeables ; elles peuvent même être des conditions préalables nécessaires. Mais elles restent, dans la plupart des cas, *intracratiques* : elles *organisent la circulation de l’information à l’intérieur de mondes d’experts, ou vers des publics invités à “comprendre” ce qui a été fait, sans que cela n’ouvre véritablement un espace de mise en épreuve*.
+
+La révolution scénique, telle que nous la formulons, ne consiste pas à voir plus, elle consiste à faire apparaître autrement. Elle ne vise pas d’abord la lisibilité technique des modèles, mais leur comparution dans des scènes où l’on peut demander des comptes, faire valoir des expériences, opposer des récits, produire des contre-propositions. Dans un régime de transparence sans scène, Système F peut être abondamment documenté sans jamais être tenu ; dans un régime scénique, la documentation n’est qu’un matériau pour l’épreuve, un support pour l’argumentation, une condition pour la possibilité de la contestation. Ce qui change, ce n’est pas seulement ce qui est visible, c’est ce qui peut être fait de ce qui est rendu visible.
+
+Ainsi formulée, l’hypothèse d’une cinquième révolution régulatrice appliquée à l’IA reste volontairement tendue : elle ne décrit pas un futur programmatique déjà décidé, elle trace une ligne de fracture dans le présent. D’un côté, une trajectoire où Système F s’inscrit sans partage dans la logique de la quatrième révolution, en perfectionnant la *gouvernementalité par variables* et en approfondissant l’*oblitération archicratique* ; de l’autre, une trajectoire où la montée même de cette puissance algorithmique rend politiquement et socialement intenable la pauvreté des scènes, et suscite des expérimentations institutionnelles qui cherchent à faire de l’*archicration* un opérateur central. La section suivante, en déployant des scénarios contrastés, aura pour fonction de donner des formes plus précises à cette alternative, en montrant ce qu’elle implique pour la gouvernance concrète de systèmes comme Système F.
+
+## V.3. Scénarios contrastés
+
+L’épreuve historique, telle que nous l’avons engagée, ne débouche pas sur un verdict linéaire. Elle ouvre un éventail de trajectoires possibles, dont aucune n’est écrite d’avance. Pour ne pas céder à la fois au catastrophisme vague et au progressisme automatique, il est utile de formuler des scénarios : non pas comme des prophéties, mais comme des figures limites qui permettent de lire le présent. Chacun des trois scénarios qui suivent – *autarchicratie numérique avancée*, *révolution scénique partielle*, *réarmement archicratique transversal* – décrit une manière distincte d’articuler Système F à la série des révolutions régulatrices, et surtout une manière différente de traiter la question centrale qui traverse ce cas pratique : *que devient la scène lorsque la régulation passe par des architectures d’IA de fondation ?*
+
+### V.3.1. Scénario d’*autarchicratie numérique* *avancée* : la clôture réussie
+
+Dans le premier scénario, la dynamique que nous avons reconstruite à propos de la quatrième révolution régulatrice se poursuit sans inflexion majeure. Système F, loin de rester un assemblage expérimental, se stabilise comme une infrastructure diffuse de la régulation : ses modules de scoring social, de gestion des risques, de tri pénal, de recrutement et de modération sont intégrés à la plupart des grandes chaînes décisionnelles, sous des marques diverses, dans des solutions clés en main fournies par quelques acteurs dominants. Les politiques publiques et les stratégies d’entreprise intègrent Système F comme une évidence, de la même manière que l’on a fini par considérer l’existence d’un système d’information ou d’un ERP comme un préalable non négociable.
+
+Les scènes humaines ne disparaissent pas ; elles se transforment en façades procédurales. L’allocataire peut toujours déposer un recours, mais ce recours consiste d’abord à remplir un formulaire qui rebranche sa demande sur Système F ; le juge reste souverain en droit, mais ses marges de manœuvre sont resserrées par des rapports de risque standardisés qui font office de grammaire commune ; le médecin garde la responsabilité ultime, mais s’écarter de la priorisation proposée par l’algorithme suppose un coût symbolique et organisationnel élevé ; le recruteur conserve la possibilité de “suivre son intuition”, mais cette intuition doit désormais se justifier en référence à des scores pré-calculés. Les interfaces deviennent le lieu unique de contact avec la régulation, et elles sont configurées de telle sorte que suivre la recommandation de Système F soit la voie de moindre résistance.
+
+Du point de vue archicratique, on entre alors dans une *autarchicratie numérique assumée* : le gouvernement par la régulation elle-même, où indicateurs, modèles et standards deviennent leurs propres critères de validité. Les performances de Système F sont évaluées à l’aune de ses propres métriques (taux d’“erreurs”, gains de productivité, stabilité des modèles), éventuellement aménagées pour intégrer des contraintes d’équité ou de non-discrimination, mais sans que la configuration d’ensemble soit amenée sur une scène élargie. Les rares *archicrations effectives* – contentieux emblématiques, commissions d’enquête, décisions de justice comme celle qui a mis fin à SyRI – restent des événements exceptionnels, qui conduisent à des ajustements locaux, sans remise en cause du schéma général.
+
+Dans ce scénario, la *co-viabilité sociale et symbolique* est sous tension permanente. Les groupes le plus intensément profilés, contrôlés, filtrés – habitants de certains quartiers, minorités racisées, bénéficiaires de prestations, personnes au parcours professionnel discontinu – expérimentent au quotidien le caractère arbitraire de décisions qu’on leur présente comme neutres. Mais la possibilité de traduire cette expérience en conflit politique est affaiblie, parce que les lieux où se prennent les décisions pertinentes – *hypertopies techniques, comités d’architecture, directions de programmes* – ne sont ni configurés ni reconnus comme des scènes. La crise se manifeste par des scandales ponctuels, des controverses médiatiques, des fuites de documents, des mobilisations sectorielles ; elle n’arrive jamais vraiment à réunir, sur une même scène, les arènes de conception, d’exploitation et de contestation de Système F. La quatrième révolution régulatrice se prolonge alors en un régime où la clôture douce est, pour ainsi dire, réussie : l’IA devient le *médium ordinaire de la régulation*, et la scène politique se cantonne à commenter, à la marge, ses effets.
+
+### V.3.2. Scénario de révolution scénique partielle : des îlots d’*archicration* dans un océan algorithmique
+
+Le deuxième scénario suppose que la trajectoire *autarchicratique* rencontre des résistances suffisamment fortes pour produire des expérimentations institutionnelles, sans pour autant se transformer en basculement général. Sous l’effet combiné de scandales répétés, de mobilisations d’ONG, de décisions de justice, de prises de position d’autorités indépendantes et de réflexions internes à certaines administrations, des dispositifs d’*archicration* spécifiques sont mis en place autour de Système F, mais de manière fragmentée.
+
+Dans le champ de la protection sociale, on peut imaginer la création de “*tribunaux de l’algorithme*” compétents pour examiner les systèmes de scoring et de profilage utilisés par les caisses et les administrations fiscales : ces tribunaux seraient dotés d’un droit d’accès aux données, aux modèles, aux fonctions de coût, et pourraient suspendre ou interdire certains usages au vu de leurs effets. Dans la justice pénale, des règles de procédure nouvelles pourraient exiger que tout recours à un score algorithmique soit explicite, motivé et accompagnés de garanties contradictoires ; les justiciables auraient le droit de demander une contre-expertise indépendante du modèle utilisé. Dans la santé, des droits au différé seraient institués : la possibilité, pour un patient ou une association, de demander qu’un programme de gestion des risques soit mis en révision avant tout nouveau déploiement, en cas de soupçon étayé de biais. Sur les plateformes, enfin, des budgets scéniques – du temps, des personnels, des moyens dédiés à la gestion contradictoire des cas litigieux – seraient imposés, limitant la tentation de déléguer entièrement la modération à des systèmes automatisés.
+
+Dans ce scénario, l’hypothèse de cinquième révolution scénique trouve un début de réalisation locale. L’*arcalité* de Système F ne reste pas uniquement implicite ou « *sloganisée* » : certaines définitions de la fraude, du risque, du mérite, du contenu nuisible doivent être exposées et justifiées devant des instances spécialisées. La *cratialité algorithmique* *n’est plus totalement opaque* : *des audits réellement indépendants, des obligations d’explication contextualisée, des pouvoirs d’inspection technique élargis créent des brèches dans la boîte noire*. L’*archicration* cesse d’être purement fantomatique : il existe des scènes où les personnes affectées – directement ou par l’entremise de collectifs – peuvent faire valoir leur expérience, contester des arbitrages, exiger des transformations.
+
+Mais cette révolution scénique reste partielle. D’une part, elle ne touche pas tous les secteurs ni tous les usages de Système F : les domaines jugés “sensibles” (droits sociaux, justice, santé) sont mieux dotés en dispositifs de scène, tandis que d’autres (recrutement privé, scoring commercial, segmentation marketing, microciblage politique) continuent de fonctionner dans un quasi-vide archicratique. D’autre part, même dans les secteurs couverts, les scènes instituées risquent de rester enclavées : leur accès est difficile pour les plus vulnérables, le langage y demeure fortement technicisé, et les conflits d’intérêts y sont nombreux (experts issus des mêmes milieux que les concepteurs de Système F, pressions économiques et politiques). On obtient alors une sorte d’*archipel* : *des îlots d’archicration réelle dans un océan algorithmique largement autarchicratique*.
+
+Ce scénario n’est pas négligeable : il montre que l’hypothèse de cinquième révolution scénique n’est pas un tout ou rien. Il est possible de construire, pas à pas, des dispositifs qui rendent Système F partiellement opposable, qui ouvrent des scènes là où il n’y en avait pas. Mais en l’absence d’un *réarmement archicratique transversal*, ces avancées resteraient fragiles, exposées à des reconfigurations politiques défavorables, et susceptibles d’être contournées par des redéploiements techniques (délocalisation des décisions, externalisation vers des prestataires, changement de statuts des dispositifs).
+
+### V.3.3. Scénario de *réarmement archicratique transversal* : la scène comme condition de déploiement
+
+Le troisième scénario est le plus exigeant et, en un sens, le plus spéculatif : il décrit ce que signifierait un *réarmement archicratique transversal* si l’hypothèse de révolution scénique était prise au sérieux comme horizon d’organisation des régulations, et pas seulement comme correctif. Il ne s’agit plus, ici, d’ajouter quelques scènes à la marge de Système F, mais de conditionner l’existence même de dispositifs de cette ampleur à l’intégration, dès leur conception, de l’*arcalité*, de la *cratialité* et de l’*archicration* dans un cadre d’épreuve robuste.
+
+Dans un tel régime, aucun système IA de haut impact ne pourrait être déployé sans un dossier archicratique explicite : *exposition des fondements assumés* (définitions opérationnelles de la fraude, du risque, du besoin, du mérite, du préjudice), *description détaillée des chaînes cratiales* (données, modèles, pipelines, interfaces, procédures d’intégration), *et plan d’archicration* (scènes prévues pour la mise en épreuve, droits au différé, modalités de suspension, budgets scéniques). Ce dossier ne serait pas un simple document de conformité ; il serait le *point de départ obligé pour toute autorisation de déploiement, examiné par des instances composites associant, de manière structurée, des représentants des administrations, des développeurs, des professionnels de terrain, des personnes concernées, des juristes, des chercheurs*.
+
+Dans la vie courante de Système F, cela se traduirait par une *architecture scénique distribuée*. À chaque niveau où le système intervient – guichet social, service hospitalier, tribunal, direction des ressources humaines, plateforme numérique – seraient associés des *dispositifs de mise en épreuve adaptés* : journaux de décision consultables, droits au différé contradictoire, possibilités d’“appels scéniques” vers des instances de second niveau, obligation d’organiser périodiquement des revues publiques des effets du système avec des formats compréhensibles. Les *hypertopies techniques* ne disparaîtraient pas, mais elles perdraient leur privilège exclusif : les *espaces où se décident les choix d’architecture et de paramétrage seraient eux-mêmes soumis à des obligations de comparution, d’ouverture, de justification*.
+
+Dans ce scénario, l’*autarchicratie numérique* ne disparaît pas comme tentation ; les forces qui poussent à la clôture – recherche d’efficacité, de réduction des coûts, de simplification apparente – restent puissantes. Mais elles se heurtent à un cadre archicratique qui ne se laisse pas contourner facilement : la possibilité de suspendre, de refuser, de reconfigurer un module de Système F n’est plus un privilège rare, elle est un élément ordinaire de la vie des régulations. *Co-viabilité* sociale, écologique et symbolique cesse alors d’être un objectif proclamé sans prise ; elle devient un critère de jugement des architectures régulatrices, au même titre que leurs performances de court terme.
+
+Ce scénario n’est évidemment pas une projection naïve d’un futur harmonieux. Il suppose des conflits, des crises, des désaccords persistant sur ce que doit être un “bon” régime de *co-viabilité* ; il n’élimine pas les asymétries de pouvoir ni les inégalités d’accès à la scène. Mais il décrit un monde dans lequel l’épreuve archicratique ne se trouve plus en bout de chaîne, comme recours ultime et improbable, mais au cœur de la conception et du déploiement des dispositifs. Dans un tel monde, Système F ne serait ni diabolisé ni sacralisé ; il serait reconnu comme un opérateur puissant, dont l’usage est possible à la condition qu’il accepte, de manière régulière et organisée, de revenir sur scène de polémiques et de controverses.
+
+Ces trois scénarios n’épuisent pas le réel ; ils tracent des repères dans un espace de possibles. L’épreuve historique appliquée à Système F nous permet ainsi de reformuler le diagnostic de l’essai-thèse sous une forme plus chirurgicale : la question n’est pas de savoir si l’IA est “bonne” ou “mauvaise” en soi, ni si elle “remplace” ou non des humains, mais de déterminer dans quel régime régulateur elle s’inscrit. Le cas pratique montre qu’à configuration constante – sans révolution scénique – la trajectoire la plus probable tend vers une *autarchicratie numérique* plus ou moins aménagée. Il suggère aussi que d’autres trajectoires restent ouvertes, à condition de prendre au sérieux la scène, non comme une métaphore, mais comme un opérateur institutionnel à part entière, au cœur de la gouvernance des systèmes d’IA.

src/content/cas-ia/chapitre-6.mdx

@@ -0,0 +1,257 @@
+---
+title: "Chapitre VI — Épreuve de co-viabilité"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 70
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_6_Epreuve_de_Co-viabilite.docx"
+---
+# VI. Épreuve de co-viabilité : autarchicratie, désarchicration et politique des épreuves viables pour l’IA
+
+Avec la cinquième épreuve, celle de la *co-viabilité*, notre cas pratique arrive à un point où la description ne suffit plus. Les parties I à V ont rendu Système F lisible comme dispositif régulateur : nous avons repéré ses prises d’*arcalité explicite* et *implicite*, reconstruit sa *cratialité*, mis en évidence la *pauvreté de ses scènes* ; nous l’avons *cartographié topologiquement, inscrit dans la série des méta-régimes, confronté aux grandes morphologies du pouvoir, replacé dans la séquence des révolutions régulatrices*. Ce travail a fait apparaître, sous des angles différents, un même motif : une puissance de régulation considérable, distribuée dans des chaînes algorithmico-organisationnelles, et une raréfaction symétrique des lieux où cette puissance peut être mise en épreuve. L’épreuve de *co-viabilité* demande autre chose : non plus seulement voir et comparer, mais interroger les conditions sous lesquelles un dispositif comme Système F peut être toléré, ajusté, contesté dans un monde où les existences humaines, les milieux écologiques et les ordres symboliques sont déjà sous tension.
+
+Dans notre essai-thèse lié à ce cas pratique, la *co-viabilité* désigne précisément *ce seuil où un régime régulateur ne se juge plus seulement à l’aune de son efficacité fonctionnelle, mais à la façon dont il maintient, ou détruit, les possibilités de vie des collectifs qu’il traverse*. *Co-viabilité sociale* : *accès matériel aux ressources*, mais aussi *dignité, reconnaissance, capacité à se tenir comme sujet adressé*. *Co-viabilité écologique* : *conditions physiques de subsistance, intégrité des milieux, soutenabilité des infrastructures*. *Co-viabilité symbolique* : *intelligibilité des expériences, possibilité de nommer les injustices, de se raconter autrement que comme “cas” d’un modèle*. Appliquée à Système F, l’*épreuve de co-viabilité* revient à poser une question simple en apparence, mais redoutable : dans les formes concrètes qu’il prend aujourd’hui – *tri des dossiers, scoring pénal, gestion des risques en santé, filtrage des contenus, sélection des candidatures* – *contribue-t-il à élargir ou à rétrécir les possibilités de vie commune ?* *Est-il compatible avec une archicratie minimale, ou tend-il à consolider un régime d’autarchicratie numérique où tout fonctionne, mais presque rien ne s’expose ?*
+
+Pour répondre, la Partie VI ne se contentera pas d’ajouter une couche de “considérations éthiques” à un diagnostic déjà établi. Elle prolongera, jusqu’à leur point politique, les fils que nous avons tirés jusque-là. Du côté de la *co-viabilité sociale* (VI.1), il ne s’agira pas de dresser un inventaire moral des “bons” et “mauvais” usages de Système F, mais de *reconstruire, à partir des scènes stylisées que nous avons déjà travaillées, ce que deviennent l’accès aux droits, la dignité et la reconnaissance lorsque des décisions critiques* (suspension d’une prestation, classement au risque, refus de dossier, invisibilisation d’une parole) *sont prises ou préparées par des modules d’IA*. L’*épreuve de co-viabilité* demande ici que nous regardions jusqu’au bout si ces décisions peuvent, oui ou non, être justifiées publiquement, réclamées dans une scène, opposées dans un délai raisonnable, au sens propre de notre paradigme archicratique.
+
+Du côté de la *co-viabilité écologique* (VI.2), le cas pratique devra desserrer un angle mort. Dans la plupart des discours sur l’IA, les *enjeux environnementaux sont soit minimisés* (problème de “second rang” par rapport à la justice sociale), *soit réduits à des considérations d’optimisation* (rendre les modèles “plus sobres”). L’*épreuve de co-viabilité écologique*, elle, reformule la question en termes archicratiques : *quelles infrastructures matérielles et énergétiques Système F suppose-t-il et renforce-t-il ? quels milieux sont affectés par l’extraction de ressources, la construction des centres de données, la circulation des flux ?* et surtout : *existe-t-il des scènes où ces effets peuvent être mis en débat, arbitrés, opposés à d’autres exigences, ou bien cette dimension reste-t-elle entièrement hors-scène, traitée comme un paramètre technique secondaire ?* Là encore, ce n’est pas l’IA comme “technologie en général” qui nous intéresse, mais l’écosystème concret que Système F compose avec des réseaux électriques, des plateformes cloud, des chaînes logistiques, des politiques industrielles.
+
+C’est dans ce double éclairage – social et écologique – que la notion d’*autarchicratie numérique*, déjà élaborée dans la Partie III, va prendre une épaisseur supplémentaire (VI.3). Nous avons décrit l’*autarchicratie* comme un *gouvernement de la régulation par elle-même* : des dispositifs qui se jugent à l’aune de leurs propres métriques, des modèles qui définissent eux-mêmes ce que signifie “bien fonctionner”, des indicateurs qui se certifient en boucle fermée, des systèmes d’audit qui ne débouchent que sur des ajustements internes. L’*épreuve de co-viabilité* permet de voir que Système F est l’un des candidats centraux à un tel régime : ses modules peuvent continuer à faire tourner des chaînes de décision entières, en produisant des chiffres, des rapports, des tableaux de bord, alors même que les scènes où l’on pourrait mettre en balance leurs effets sociaux et écologiques se réduisent à des simulacres ou à des contentieux isolés. La question devient alors plus tranchante : *à partir de quel seuil d’autarchicratie numérique la co-viabilité est-elle mise en danger ?*
+
+Enfin, la Partie VI ne se limite pas à ce constat ; elle prépare le terrain de la dernière étape du cas pratique en esquissant, dans VI.4, une *politique des épreuves viables appliquée à l’IA*. Dans la conclusion de notre essai-thèse, nous avons formulé l’idée que l’acte régulateur proprement archicratique ne consiste pas d’abord à prescrire des normes substantielles, mais à *instituer des épreuves* : *des scènes, des procédures, des différés, des droits au recours, des dispositifs de confrontation entre régimes de justification, qui rendent possible la mise en cause des régulations elles-mêmes*. Transposée à Système F, cette *politique des épreuves viables* revient à requalifier ce que l’on appelle aujourd’hui “gouvernance de l’IA” : non plus gouverner l’IA au sens d’en organiser l’expansion avec quelques garde-fous, mais obliger tout système de ce type à se laisser apparaître dans des scènes ouvertes, opposables, répétées, où la *co-viabilité sociale*, *écologique et symbolique peut être effectivement exposée et mise en délibération*.
+
+L’*épreuve de co-viabilité* est donc, à la fois, une synthèse et un déplacement. Synthèse, parce qu’elle ressaisit, dans une même interrogation, les diagnostics de détectabilité, de topologie, d’archéogénèse, de morphologie et d’histoire : tous convergent vers la question de ce que Système F fait, concrètement, aux conditions de vie et de contestation. Déplacement, parce qu’elle contraint notre cas pratique à quitter le terrain du seul constat pour entrer, sans changer de langage, dans celui des exigences : *quelles configurations de scènes, de droits, de limites, de suspensions rendent un dispositif comme Système F vivable, ou au contraire destructeur de co-viabilité ?* C’est à cette exploration, orientée mais non réductible à un programme, que la Partie VI est désormais consacrée.
+
+## VI.1. *Co-viabilité sociale*
+
+L’*épreuve de co-viabilité sociale* prend Système F non plus du point de vue de son architecture, ni de ses scènes institutionnelles, mais depuis les trajectoires de celles et ceux qui s’y trouvent pris. Ce qui est en jeu n’est pas tant la “qualité” des modèles, ni la conformité de leurs usages au droit existant. La question est plus nue : *dans les domaines où Système F est désormais intégré – protection sociale, santé, justice, emploi, plateformes – rend-il la vie socialement habitable, ou bien organise-t-il des formes de tri, de suspicion et de silence qui finissent par fragiliser les conditions mêmes d’une vie digne pour certains groupes ?*
+
+### VI.1.1. Accès aux droits : quand le score devient seuil invisible
+
+Vu de loin, l’accès aux droits reste garanti : les textes existent, les formulaires sont en ligne, les procédures de recours sont théoriquement ouvertes. Mais dès que l’on resserre la focale sur les scènes que Système F traverse, on voit se multiplier des seuils invisibles qui reconfigurent en profondeur l’effectivité de ces droits.
+
+Dans la protection sociale, un module de scoring branché sur les dossiers ne supprime aucun droit formel ; il modifie la manière dont les demandes sont traitées. Certains dossiers passent en tête de file, d’autres sont envoyés d’office en contrôle, d’autres enfin sont “gelés” dans l’attente de pièces supplémentaires. Pour l’allocataire, le droit n’a pas disparu, mais il devient conditionnel à une évaluation algorithmique qu’il ne voit jamais. À l’échelle d’un territoire, cela suffit pour que des catégories entières de personnes – habitants de certains quartiers, familles nombreuses, foyers précaires – soient plus fréquemment freinées, contrôlées, retardées dans l’accès effectif à leurs prestations.
+
+Le même mécanisme se retrouve dans la santé lorsqu’un score d’IA intervient dans la priorisation de listes d’attente ou l’orientation vers des programmes de soins renforcés. Le droit proclamé à l’accès à des soins nécessaires n’est pas formellement remis en cause ; mais la décision de “qui passe avant qui” est partiellement déléguée à des modèles qui peuvent, comme on l’a vu, sous-estimer systématiquement les besoins de certains groupes. *De facto*, la frontière entre “éligible” et “non prioritaire” se déplace, sans jamais être nommée comme choix politique.
+
+Un troisième exemple apparaît dans le recrutement : lorsqu’un système dérivé de Système F trie des centaines de CV pour n’en faire remonter qu’une fraction, il ne modifie pas les lois du travail, mais il déplace la barrière d’entrée dans la relation d’emploi. Des profils considérés comme “instables”, “peu prometteurs” ou “atypiques” sont éliminés avant même d’avoir pu rencontrer un recruteur. Là encore, le droit formel à candidater subsiste, mais l’accès concret à une opportunité dépend d’un filtre que les personnes ne peuvent ni voir, ni discuter.
+
+Du point de vue de la *co-viabilité sociale*, ces trois scènes ont un trait commun : le *passage du droit explicite au droit conditionné par un score*. Ce passage n’est pas neutre. Il fabrique des *zones de non-recours de fait* : des personnes qui renoncent à faire valoir leurs droits après un premier refus incompréhensible ; des patients qui ne savent même pas qu’ils auraient pu prétendre à un programme plus intensif ; des candidat·es qui intègrent, en silence, que “ce n’est pas pour eux”. Système F ne supprime pas les droits ; il installe, en amont, des filtres non déclarés qui en modulent l’effectivité.
+
+### VI.1.2. Dignité : vivre sous un soupçon chiffré
+
+La *co-viabilité sociale* ne se résume pas à des indicateurs d’accès. Elle implique des *formes minimales de respect* : *ne pas être traité comme un fraudeur par défaut, ne pas être réduit à un risque abstrait, ne pas découvrir sa propre existence administrative à travers des sanctions automatiques*. Système F, tel qu’il se déploie aujourd’hui, met précisément à l’épreuve ces exigences.
+
+Lorsqu’une famille reçoit une notification de suspension de prestation à la suite d’un profilage algorithmique, la *perte monétaire* est une première atteinte. Mais ce qui se joue en même temps est une *atteinte symbolique* : *la relation à l’institution se renverse*. *On n’est plus bénéficiaire d’un droit, mais suspect à justifier*. Et ce renversement est d’autant plus violent qu’il est difficile de trouver un interlocuteur capable d’en répondre autrement qu’en renvoyant à “des contrôles automatisés” présentés comme des évidences techniques. La honte, la colère, le sentiment de ne pas être cru se combinent, sans que l’on puisse identifier un lieu où cette expérience puisse être entendue comme autre chose qu’un “cas problématique”.
+
+Dans la justice, l’introduction d’un score de risque dans un rapport peut aussi peser sur la *dignité de l’accusé ou du condamné*. Être classé “haut risque” par un dispositif dont le fonctionnement est inaccessible revient à porter une étiquette qui ne se laisse ni expliquer ni contester aisément. Là encore, ce qui blesse n’est pas seulement la sévérité de la peine, mais le fait que cette sévérité soit soutenue par une évaluation extérieure, chiffrée, opaque, qui place la personne dans une position de désajustement radical : *comment se défendre contre une probabilité ?*
+
+De manière plus diffuse, les dispositifs de tri de CV, de notation de clients ou de filtrage de contenus créent des populations pour lesquelles la norme devient l’invisibilité ou la défiance par défaut. La dignité est alors entamée non pas par un acte ouvertement humiliant, mais par une accumulation de signaux faibles : candidatures qui ne reçoivent aucune réponse, publications qui cessent d’être vues, dossiers que l’on sent “mal considérés” sans comprendre pourquoi. Système F construit des *hiérarchies silencieuses de respectabilité et de crédibilité*, sans scène où ces hiérarchies puissent être nommées.
+
+La *co-viabilité sociale* exige, à l’inverse, la *possibilité de répondre à ce type de classement, de demander des comptes, de transformer une suspicion abstraite en conflit explicite sur des raisons*. Tant que Système F installe du soupçon chiffré sans adresser à ceux qu’il cible une parole justifiable, il fabrique des zones de vie sous-dignes, où l’humiliation ne peut même plus se dire comme telle.
+
+### VI.1.3. Reconnaissance et voix : qui peut encore faire récit ?
+
+*Une société reste co-viable tant que ceux qui la composent peuvent, au moins par moments, transformer leurs expériences en récits partageables, en plaintes adressables, en revendications recevables*. Ce pouvoir de faire récit suppose des scènes – guichets, audiences, réunions, espaces publics – où la parole n’est pas purement décorative. L’insertion de Système F dans les chaînes décisionnelles modifie en profondeur cette géographie de la voix.
+
+*Au guichet devenu interface, l’usager ne raconte plus sa situation ; il remplit des champs*. Là où un agent pouvait, même dans un cadre contraint, reformuler, préciser, prendre en compte une particularité, l’interface se contente de transformer la situation en vecteur de variables. Si Système F signale un dossier comme “à risque”, la marge d’interprétation de l’agent se rétrécit : *il devient difficile de prendre au sérieux un récit qui ne “colle pas” avec les signaux remontés par le modèle*. *L’expérience vécue – dette imprévue, rupture familiale, maladie non documentée – reste en marge de ce que le système reconnaît comme information pertinente*.
+
+Dans la santé, un patient qui objecte à la priorisation proposée par un outil d’IA se heurte souvent à la solidité apparente des “données”. Son ressenti, ses craintes, ses connaissances propres de sa trajectoire n’entrent qu’à la marge dans les décisions d’orientation. *Le langage du risque calculé prend le pas sur le récit de la vulnérabilité*. La même logique se retrouve, à une autre échelle, lorsque des collectifs tentent de contester le fonctionnement d’un système de scoring : leur parole se heurte à des représentations agrégées des “comportements typiques” que le modèle prétend déjà synthétiser.
+
+Sur les plateformes, enfin, la reconnaissance est mise à l’épreuve d’une autre manière. Un utilisateur dont le contenu est systématiquement moins montré, ou régulièrement supprimé, peut, en principe, contester une décision. Mais cette contestation se fait au milieu de procédures standardisées, souvent sans motif précis, sans interlocuteur identifié. La possibilité de dire : “ce que vous qualifiez de contenu nuisible est, dans mon expérience, le seul moyen de rendre visible tel type d’injustice” reste largement théorique. La voix se heurte à une structure qui, tout en traitant massivement des discours, accorde très peu de place à la discussion sur les catégories qui décident ce qui mérite ou non d’être vu.
+
+Dans toutes ces scènes, Système F ne fabrique pas seulement des scores ; il redistribue les conditions de la parole efficace. Certains récits – ceux qui s’alignent sur les catégories du modèle, sur les formats déjà prévus – trouvent encore leur place. D’autres, plus dissonants, plus marginaux, plus complexes, se heurtent à une absence de prise. La *co-viabilité sociale* est menacée lorsque trop d’expériences ne trouvent plus aucun chemin pour apparaître autrement que comme anomalies à corriger ou résidus statistiques.
+
+### VI.1.4. Ce qu’impliquerait une *co-viabilité sociale* minimale pour Système F
+
+L’*épreuve de co-viabilité sociale* ne débouche pas immédiatement sur un programme de réformes exhaustif ; elle permet de préciser des conditions minimales pour qu’un dispositif comme Système F ne détruise pas, à moyen terme, les possibilités d’une vie sociale habitable.
+
+Une première condition tient à la *mise en visibilité des seuils* : partout où un score conditionne l’accès à un droit, à un service essentiel ou à une opportunité structurante, ce fait doit être explicite, et non enfoui dans la chaîne technique. Sans cette explicitation, il est impossible d’ouvrir un débat sur la légitimité de ces seuils, sur leur calibration, sur leurs effets différenciés.
+
+Une deuxième condition concerne la *possibilité de renverser la présomption*. Si Système F produit du soupçon (fraude, risque, non-mérite), ceux qui en sont l’objet doivent disposer de moyens concrets pour faire entendre un récit contraire, pour apporter des informations qualitatives, pour *demander que leur cas soit examiné autrement qu’à travers les seules variables enregistrées*. Cela suppose des procédures où la parole des personnes affectées ne soit pas purement rituelle, mais puisse effectivement *infléchir la décision*.
+
+Une troisième condition vise le *cumul des dispositifs*. La *co-viabilité sociale* est mise en danger lorsque les mêmes groupes se trouvent systématiquement du “mauvais côté” de plusieurs modules de Système F à la fois. Reconnaître cette *dimension cumulative* implique de regarder les effets non pas secteur par secteur, mais transversalement : *qui est, en pratique, surexposé au contrôle, au déclassement, à l’invisibilisation algorithmique ?* *Sans cette vue d’ensemble, la régulation se contente de corriger à la marge des injustices locales, tout en laissant intacte une architecture d’ensemble défavorable*.
+
+Enfin, une *co-viabilité sociale minimale* exige que l’on prévoit, dès la conception des dispositifs, des scènes de réparation : non pas seulement des formulaires de recours individuels, mais des *instances capables de reconnaître des torts systématiques, d’indemniser, de réformer, voire de démanteler* des modules de Système F qui produisent durablement des effets socialement destructeurs. Tant que de telles scènes restent exceptionnelles, improvisées après coup, la tentation restera forte de considérer les dommages comme des “effets collatéraux” inévitables.
+
+Dans toutes ces dimensions, l’enjeu n’est pas de rendre Système F “parfaitement juste” – horizon illusoire –, mais de s’assurer qu’il n’installe pas, au cœur même des politiques sociales, sanitaires, judiciaires, économiques, un régime où les droits deviennent des probabilités, la dignité un résidu, et la voix un bruit de fond. C’est à cette condition que la co-viabilité sociale pourra être, non garantie, mais au moins sérieusement réouverte.
+
+## VI.2. Co-viabilité écologique
+
+L’*épreuve de co-viabilité écologique* oblige à regarder Système F depuis un autre bord : celui de l’agencement matériel qui prélève de l’électricité, de l’eau, des métaux, des sols, et qui rejette de la chaleur, des déchets, des risques. Autrement dit : ce qui est apparu jusqu’ici comme un “modèle dans le *cloud*” doit être décrit comme une *chaîne de data centers, de réseaux électriques, de mines et de filières de déchets, inscrite dans des milieux concrets*. La question archicratique devient alors : *à quelles conditions un système d’IA de fondation intégré à la régulation sociale peut-il être écologiquement co-viable, et où se trouve aujourd’hui la scène où cette question est instruite ?*
+
+### VI.2.1. Du “*cloud*” aux milieux : rendre visible l’infrastructure
+
+Dans la scénarisation de Système F, nous avons distingué un fournisseur de modèle, des intégrateurs, des organisations utilisatrices. Il faut maintenant ajouter une couche supplémentaire : les infrastructures qui rendent possible cette chaîne. Un modèle de fondation n’existe pas sans centres de données où se concentrent des dizaines, voire centaines de milliers de processeurs, des systèmes de refroidissement, des batteries et onduleurs, reliés à des réseaux électriques de plus en plus puissants.
+
+Les estimations de l’Agence internationale de l’énergie indiquent que, en 2022, les centres de données consommaient déjà entre 240 et 340 TWh d’électricité par an, soit environ 1 à 1,3 % de la demande mondiale finale, hors cryptomonnaies. Des analyses récentes projettent, sous l’effet de la montée en puissance de l’IA, un doublement voire un quasi-triplement de cette demande d’ici 2030–2035, avec des *data centers hyperscale* dépassant régulièrement les 100 MW et pesant fortement sur des réseaux déjà fragilisés. En parallèle, des travaux sur les États-Unis estiment qu’en 2023 les *data centers* représentaient déjà 4,4 % de la consommation électrique du pays, avec une possible multiplication par trois d’ici 2028 si la trajectoire actuelle se poursuit.
+
+Système F, dans cette perspective, n’est pas une abstraction désincarnée : c’est un locataire majeur de cette capacité électrique mondiale. Chaque appel d’API dans un service social, chaque priorité de patient calculée dans un hôpital, chaque tri de CV ou de contenu sur une plateforme repose sur ce socle électro-matériel. Or ce socle est inégalement distribué : on voit se multiplier, dans certains territoires, des projets de “campus” de *data centers* dont la consommation équivaut à celle d’une ville moyenne, avec des demandes de raccordement qui questionnent la stabilité des réseaux locaux et les trajectoires climatiques nationales.
+
+Du point de vue archicratique, cette première mise au point a une conséquence simple : toute décision d’étendre Système F – par exemple en généralisant l’usage de modèles de fondation dans les politiques sociales ou de santé – est aussi une décision d’augmenter la part de l’infrastructure numérique dans les budgets énergétiques collectifs. Ne pas le dire ne supprime pas cet effet ; cela le rend seulement extra-scénique.
+
+### VI.2.2. Eau, chaleur et tensions hydriques
+
+L’électricité n’est qu’une partie de l’empreinte. Les centres de données nécessaires à Système F consomment aussi des volumes considérables d’eau pour le refroidissement, directement ou via des systèmes de production d’électricité. Des études sur les *data centers* en contexte de sécheresse rappellent qu’un seul site peut consommer des dizaines de millions de litres d’eau potable par jour – l’équivalent des besoins de plusieurs milliers de foyers ou d’une petite ville.
+
+La tension devient particulièrement aiguë là où l’IA est en train de redessiner des régions entières. Dans le Nevada, par exemple, des enquêtes récentes décrivent une véritable “ruée vers l’IA” autour d’un immense parc industriel, où se concentrent datacenters et infrastructures de calcul pour les grands acteurs du numérique. L’eau de la rivière Truckee, dont dépend la communauté autochtone Paiute, est également mobilisée pour le refroidissement de ces installations, ce qui nourrit des inquiétudes quant à la durabilité de ce partage de ressource dans un environnement aride.
+
+En Australie, les autorités de l’eau de Sydney et de Melbourne alertent désormais sur le fait que les demandes des opérateurs de *data centers* pourraient, d’ici une décennie, dépasser la consommation de villes entières ; des organisations environnementales appellent à interdire l’usage d’eau potable pour le refroidissement de ces infrastructures, ou à déplacer ces charges sur des systèmes de recyclage et de dessalement particulièrement coûteux. Des analyses globales estiment que l’eau utilisée directement par les *data centers* américains pourrait doubler ou quadrupler entre 2023 et 2028, sous l’effet de l’IA.
+
+Du côté des fournisseurs d’IA, des chiffres permettent déjà de prendre la mesure de ces ordres de grandeur : Google indique que la consommation de ses *data centers* en 2023 équivaut à l’usage annuel de plus de 200 000 personnes, et certains travaux projettent que la demande mondiale en eau liée à l’IA pourrait représenter, à l’horizon 2027, l’équivalent de la consommation annuelle de 30 à 47 millions de personnes.
+
+Pour l’instant, ces chiffres sont discutés dans des rapports techniques, des controverses locales, des enquêtes journalistiques ; ils restent rarement articulés à la décision d’utiliser Système F dans un domaine régulateur. On débat de l’équité d’un score de fraude ou de la performance d’un modèle de tri de dossiers sans interroger le fait qu’installer ces modèles, les maintenir et les faire croître implique de mobiliser, dans d’autres lieux, des volumes croissants d’eau et d’énergie. La *co-viabilité écologique* est ainsi entamée à distance, dans des bassins versants, des nappes et des réseaux, tandis que la scène où l’on discute de Système F se réduit à ses performances internes.
+
+### VI.2.3. Chaînes matérielles et déchets électroniques : l’aval invisible de Système F
+
+L’empreinte écologique de Système F ne se limite pas au fonctionnement des *data centers* ; elle *commence en amont, dans l’extraction et la transformation des matériaux, et se prolonge en aval, dans la gestion des déchets*. Concevoir, entraîner et déployer des modèles de fondation à grande échelle suppose des volumes croissants de puces spécialisées, de serveurs, de systèmes de stockage et de refroidissement. Chaque génération de matériel promet plus de puissance, mais implique aussi de nouvelles séries de wafers, de cartes, de racks – et donc de nouvelles mines, de nouveaux sites industriels, de nouvelles lignes de transport.
+
+Les chiffres globaux sur les déchets électroniques donnent un ordre de grandeur : selon le Global E-waste Monitor 2024, la planète a produit 62 millions de tonnes de déchets électroniques en 2022, soit une augmentation de 82 % par rapport à 2010, et cette masse pourrait atteindre 82 millions de tonnes en 2030. Moins d’un quart (environ 22 %) de ces déchets sont actuellement collectés et recyclés de manière documentée. Cela signifie que la majeure partie des équipements obsolètes – serveurs, baies de stockage, systèmes de climatisation, équipements de réseau – se disperse dans des filières opaques, avec des risques de pollution, d’exposition toxique et de pillage des ressources dans des régions souvent peu dotées en capacités de contrôle (RDC).
+
+Système F, comme tout grand système d’IA, accélère ces flux : montée en puissance rapide des GPU, réduction des cycles de vie des architectures, démultiplication des sites de calcul redondants. Or ce lien entre l’augmentation de la puissance régulatrice de Système F et l’augmentation mécanique des volumes de matériel à produire et à jeter reste, lui aussi, largement extra-scénique. Les utilisateurs d’un service d’aide au diagnostic ou d’un outil de tri de dossiers ne voient pas – et ne peuvent pas voir – les montagnes de composants qui rendront possible, dans quelques années, leurs mises à jour successives.
+
+Vu depuis la *co-viabilité écologique*, l’enjeu n’est pas de dénoncer abstraitement “le numérique” : il est de reconnaître que la régulation par Système F consomme une part croissante d’un budget matériel et énergétique global, dans un monde où les autres usages – chauffage, mobilité, agriculture, adaptation aux dérèglements climatiques – devront eux aussi être financés. Tant que ce conflit de destinations reste hors scène, il est réglé par défaut en faveur de l’expansion du calcul.
+
+### VI.2.4. Spatialisation des coûts : milieux gagnants, milieux perdants
+
+Les effets écologiques de Système F ne se répartissent pas uniformément dans l’espace. On voit se dessiner des géographies contrastées : d’un côté, des métropoles ou des agences publiques qui bénéficient des services – scoring social, IA médicale, outils de pilotage ; de l’autre, des territoires où se concentrent les infrastructures et leurs impacts.
+
+Les *data centers hyperscale* se localisent souvent dans des zones à foncier disponible, à proximité de nœuds électriques ou de sources d’eau, dans des régions qui offrent des avantages fiscaux ou réglementaires. Ils arrivent parfois dans des territoires déjà marqués par d’autres usages intensifs (agriculture irriguée, industrie lourde), ce qui crée des tensions locales : craintes d’augmentation des factures d’électricité, inquiétudes sur la disponibilité de l’eau pour les cultures ou la consommation domestique, opposition à la construction de nouvelles lignes à haute tension.
+
+Plus loin encore dans la chaîne, les zones d’extraction de métaux, de fabrication de composants, ou de réception des déchets électroniques sont rarement celles où l’on parle de “gouvernance de l’IA” dans un langage policé. Les coûts écologiques – terres dégradées, nappes polluées, corps exposés – sont portés par des populations qui n’apparaissent jamais comme “utilisateurs finaux” de Système F, mais qui supportent une part de plus en plus importante de son empreinte.
+
+Du point de vue de la *co-viabilité*, cette spatialisation pose une question simple : *peut-on considérer comme co-viable un régime où certaines populations profitent des gains d’efficacité de Système F dans la gestion des dossiers, des patients ou des contenus, tandis que d’autres voient leurs milieux durcis, contaminés, mis en tension pour alimenter cette puissance ?* La réponse archicratique tient moins dans une condamnation morale que dans un diagnostic : tant que ces relations restent invisibles, il n’existe aucune scène où elles puissent être mises en balance.
+
+### VI.2.5. *Archicration écologique* existante : procédures, rapports, controverses
+
+On pourrait objecter que l’empreinte écologique des infrastructures numériques n’est pas totalement ignorée. Des réglementations imposent déjà des formes de visibilité. L’Union européenne, par exemple, a introduit dans sa directive sur l’efficacité énergétique une obligation de reporting pour les centres de données au-delà d’un certain seuil de puissance, afin de suivre leur consommation, leur efficacité et certains indicateurs de durabilité ; la Commission doit publier des analyses régulières sur ces données agrégées. Par ailleurs, les grandes entreprises numériques et industrielles sont, pour les plus importantes d’entre elles, soumises à des obligations de reporting de durabilité (type CSRD), qui incluent des informations sur le mix énergétique et les émissions associées à leurs activités numériques.
+
+À l’échelle locale, chaque implantation de *centres de données* fait généralement l’objet d’études d’impact environnemental, voire d’enquêtes publiques où les habitants peuvent formuler des observations. Dans certains cas, des collectivités imposent des conditions : obligation d’utiliser de l’électricité décarbonée, interdiction de certaines technologies de refroidissement trop consommatrices, limitation des prélèvements d’eau potable. Des associations et collectifs écologistes mobilisent ces procédures pour contester des projets qu’ils jugent incompatibles avec la préservation des milieux.
+
+Il existe donc bien des éléments d’archicration écologique autour de Système F : des rapports, des chiffres, des consultations, des recours juridiques. Mais ces scènes présentent au moins trois limites archicratiques majeures :
+
+1.  Elles restent *sectorielles* : on évalue un *data center*, un projet d’extension, un plan d’investissement, sans jamais articuler ces décisions à la question plus globale de la part du budget énergétique et matériel que l’on consacre à la régulation algorithmique par rapport à d’autres besoins.
+
+2.  Elles sont largement *capturées par le langage des opérateurs et des experts* : les indicateurs de performance énergétique (PUE, WUE…), les scénarios de compensation, les engagements “net zéro” sont discutés dans un cadre technique qui laisse peu de place à une interrogation sur les fondements : pourquoi ce projet plutôt qu’un autre ? pourquoi maintenant ? pour quels bénéficiaires, à quel prix écologique pour quels autres ?
+
+3.  Elles sont *dissociées des scènes où l’on décide d’utiliser Système F dans les politiques sociales, sanitaires ou judiciaires* : les ministères, les caisses, les hôpitaux, les tribunaux qui adoptent ces outils ne délibèrent que rarement sur les conséquences écologiques de cette adoption ; les scènes environnementales et les scènes réglementaires restent juxtaposées.
+
+On se trouve donc en présence de ce que l’on pourrait appeler des *archicrations écologiques fragmentées* : *des lieux où certaines dimensions de l’empreinte sont examinées, parfois contestées, mais sans articulation explicite avec la question de savoir si, et à quelles conditions, Système F est un dispositif écologiquement acceptable pour organiser la co-viabilité sociale*.
+
+### VI.2.6. Conditions d’une co-viabilité écologique minimale pour Système F
+
+À ce stade, l’*épreuve de co-viabilité écologique* permet de formuler, non un cahier des charges exhaustif, mais quelques *exigences minimales pour qu’un système comme Système F ne contribue pas, silencieusement, à défaire les conditions écologiques de sa propre société*.
+
+La première est une *exigence de traçabilité opposable*. Tant que l’empreinte énergétique et matérielle de Système F reste agrégée au niveau de “l’industrie du *cloud*”, aucune scène ne peut instruire le conflit entre les bénéfices régulateurs obtenus et les coûts écologiques induits. *Une co-viabilité minimale suppose qu’à chaque grand déploiement* (par exemple l’intégration de Système F dans un régime d’assurance santé ou dans un système de protection sociale), *on puisse associer un profil d’empreinte – en termes d’électricité, d’eau, de matériel – et en débattre publiquement*.
+
+La deuxième est une *exigence de droit à la scène pour les territoires et les milieux affectés*. Il ne suffit pas que des indicateurs soient publiés ; encore faut-il que *les habitants des zones d’implantation, les travailleurs des chaînes matérielles et les collectifs concernés puissent disposer de lieux où contester un projet, exiger des modifications, demander des compensations, voire refuser purement et simplement l’installation d’une infrastructure jugée incompatible avec la préservation de leur milieu*. Une archicration écologique digne de ce nom ne se réduit pas à une étude d’impact ; elle implique la possibilité, pour ceux qui supportent les coûts, de peser réellement sur la décision.
+
+La troisième est une *exigence de mise en balance explicite*. Toute extension de Système F repose sur une promesse de gains – efficacité des politiques, réduction des fraudes, meilleure priorisation des soins, amélioration de la sécurité. Ces promesses doivent être, secteur par secteur, mises en regard des investissements écologiques nécessaires : quelle consommation supplémentaire d’énergie et d’eau ? quelle part du budget carbone national ? quels effets sur des milieux déjà fragilisés ? Tant que cette mise en balance reste implicite, elle est tranchée par la seule *cratialité* : ce qui est techniquement possible et économiquement rentable tend à être considéré comme légitime, indépendamment de ses conséquences écologiques.
+
+Enfin, une *co-viabilité écologique minimale* suppose que l’on résiste à un récit désormais fréquent : celui de Système F présenté comme solution “verte” en soi, au motif qu’il pourrait optimiser des réseaux, réduire certaines consommations, améliorer la maintenance ou la planification. Il est possible, et même probable, que certains usages de l’IA contribuent effectivement à réduire des impacts écologiques dans des secteurs précis. Mais ces bénéfices ne peuvent être posés d’emblée comme justification générale ; ils doivent eux aussi passer par des scènes d’épreuve, où l’on compare ce qu’ils font gagner ici et ce qu’ils font perdre ailleurs.
+
+Autrement dit, l’IA régulatrice n’échappe pas au registre de la co-viabilité écologique par sa seule promesse d’“optimisation”. Au contraire : en devenant un des principaux consommateurs de ressources énergétiques et hydriques, et un accélérateur des flux matériels, Système F devient un test décisif pour l’*archicratie*. Si l’on ne parvient pas à instituer des scènes où ses bénéfices régulateurs et ses coûts écologiques puissent être instruits ensemble, avec ceux qui les supportent et ceux qui en profitent, alors la dynamique autarchicratique se déploie aussi sur ce versant : la régulation par l’IA continuera de se renforcer en se prenant elle-même pour critère, tandis que les milieux qui la soutiennent seront gouvernés par pure nécessité matérielle, sans scène. C’est précisément ce nouage entre autarchicratie et effacement écologique que la section suivante (VI.3) devra rendre explicite.
+
+## VI.3. Autarchicratie numérique
+
+Les sections précédentes ont montré, chacune à leur façon, comment Système F organise des accès différenciés aux droits, installe des régimes de soupçon chiffré, redistribue silencieusement les conditions de la parole, tout en s’appuyant sur une infrastructure matérielle énergivore, hydrovore et productrice de déchets dont les coûts sont spatialement dissociés des bénéfices. La question qui se pose maintenant est la suivante : *quel type de régime régulateur se dessine lorsque ces dynamiques sociales et écologiques sont pilotées, évaluées, corrigées presque exclusivement à partir des instruments internes du système lui-même ?* C’est ce que nous appelons, dans le langage de la thèse, une *autarchicratie numérique* : un gouvernement de la régulation par elle-même, où modèles, indicateurs et procédures deviennent leurs propres critères de validité, en marginalisant les scènes externes d’épreuve.
+
+### VI.3.1. Quand les métriques deviennent fondement
+
+Dans Système F, presque tout ce qui compte – au sens littéral – prend la forme de métriques : taux de détection de fraude, précision des scores de risque, réduction des “erreurs” sur certains groupes, temps moyen de traitement d’un dossier, économies budgétaires, diminution des “fausses alertes” dans les hôpitaux, amélioration des “KPIs de modération” sur les plateformes, baisse annoncée des émissions associées par unité de calcul. De l’autre côté, du côté des fournisseurs de modèle et des intégrateurs, on trouve une autre famille d’indicateurs : fonctions de perte, accuracy, F1-score, courbes ROC, métriques de “fairness”, empreinte carbone par requête, efficacité énergétique des data centers.
+
+Pris séparément, aucun de ces indicateurs n’a quoi que ce soit d’illégitime : mesurer n’est pas en soi un problème. *L’autarchicratie commence lorsque ces métriques cessent d’être des instruments au service de décisions situées pour devenir, de fait, la seule arcalité pratique de Système F*. Dans les comités de pilotage, dans les rapports internes, dans les bilans de projet, une question domine : les indicateurs cibles se sont-ils améliorés ? Si la réponse est oui – si les taux de fraude détectée augmentent, si les écarts mesurés entre groupes se resserrent selon la métrique choisie, si la consommation électrique par opération diminue relativement à un référentiel antérieur –, alors le dispositif est réputé “sous contrôle”.
+
+Ce glissement a une conséquence décisive : les notions de fraude, de risque, de mérite, de besoin, de contenu nuisible, de bénéfice écologique sont progressivement reformulées en langage métrique. Ce qui vaut, ce qui est grave, ce qui est supportable se déplace vers ce qui améliore des courbes. Les valeurs explicites qui légitimaient Système F – protection de l’État social, accessibilité des soins, sécurité, inclusion, sobriété écologique – se voient en quelque sorte encapsulées dans des indicateurs techniques qui deviennent, à leur tour, les seuls fondements opérationnels de l’action. *L’arcalité déclarée subsiste dans les chartes, mais l’arcalité effective de la régulation est de plus en plus tenues par des tableaux de bord*.
+
+### VI.3.2. Boucles fermées d’évaluation : auto-audit et auto-justification
+
+À cette métrologie généralisée s’ajoute une seconde dynamique : la *boucle fermée de l’évaluation*. Pour répondre aux critiques, aux exigences réglementaires, aux principes d’“IA responsable”, les organisations qui déploient Système F se dotent de *dispositifs d’audit* : *matrices de risque, évaluations d’impact, rapports internes de biais, journaux de conformité, comités de gouvernance des données et de l’IA*. Sur le papier, ces dispositifs introduisent de la réflexivité. En pratique, ils sont le plus souvent conçus, alimentés et interprétés par les mêmes familles d’acteurs qui conçoivent, paramètrent et pilotent les systèmes.
+
+*L’audit devient alors un moment où le système se juge lui-même à partir des métriques qu’il a déjà choisies*. Les questions principales deviennent : avons-nous réduit l’écart de traitement entre tel et tel groupe selon la mesure d’équité retenue ? Avons-nous baissé la consommation énergétique par requête selon le calcul que nous avons défini ? Avons-nous diminué le nombre de recours en justice liés à tel module ? Lorsque les réponses sont positives, le système se déclare “amélioré”, “aligné avec les bonnes pratiques”, voire “digne de confiance”.
+
+L’*autarchicratie numérique* se cristallise là : dans cette capacité de Système F à *produire lui-même les instruments de sa propre absolution*. Les audits externes existent, nous l’avons vu, mais ils se déroulent souvent dans un espace déjà formaté par les catégories, les métriques et les scénarios d’usage fournis par les opérateurs. *Les autorités de régulation manquent fréquemment de moyens techniques pour contester ces cadrages, les personnes affectées ne sont pas intégrées à la définition des critères de succès, et les interrogations sur les effets sociaux et écologiques de long terme se trouvent réduites à des colonnes dans un registre de risques.* La scène d’épreuve tourne en vase clos : on ajuste les paramètres, on raffine les mesures, mais on discute rarement de ce qui devrait compter autrement que comme un “risque résiduel”.
+
+### VI.3.3. Marginalisation des scènes externes : droit, politique, publics
+
+Pendant que les métriques se referment sur elles-mêmes, les scènes externes – juridictions, parlements, corps intermédiaires, espaces publics – peinent à accéder aux prises nécessaires pour transformer Système F. Les tribunaux jugent des décisions individuelles, mais n’ont pas toujours la capacité d’instruire la structure du modèle qui a contribué à ces décisions ; ils peuvent sanctionner un usage manifestement discriminatoire, sans pour autant redessiner l’architecture globale des fonctions de coût. Les parlements votent des textes encadrant l’IA, mais ces textes restent souvent focalisés sur la transparence, la gouvernance des données, la documentation des systèmes, sans imposer de véritables scènes d’*archicration* où les configurations arcales et cratiales seraient travaillées avec les publics concernés.
+
+Les *espaces publics*, quant à eux, discutent de l’IA à coups de grandes oppositions – menace existentielle, opportunité économique, risque de surveillance, promesse d’innovation – sans toujours disposer des informations concrètes sur les usages effectifs de Système F dans les caisses sociales, les hôpitaux, les tribunaux, les entreprises. La discussion se déplace vers des enjeux spectaculaires (l’IA va-t-elle remplacer les travailleurs ? inventer des contenus trompeurs ? déstabiliser la démocratie ?), alors même que Système F s’installe silencieusement dans les couches les plus ordinaires de la régulation.
+
+Dans une *autarchicratie numérique*, ces scènes externes ne disparaissent pas ; elles deviennent décoratives. On les convoque pour valider a posteriori des choix déjà intégrés dans les métriques : consultation sur des principes, délibération sur des textes généraux, auditions d’experts qui décrivent des dispositifs dont les paramètres structurants sont fixés ailleurs. La capacité effective de ces scènes à contraindre, réorienter ou suspendre Système F se réduit, sauf crises majeures, à des ajustements marginaux.
+
+### VI.3.4. Système F comme candidat central à l’*autarchicratie*
+
+À ce point du cas pratique, l’hypothèse peut être formulée nettement : Système F est un candidat central au méta-régime d’*autarchicratie numérique*. Il agrège trois caractéristiques qui, prises ensemble, rendent ce régime particulièrement stable :
+
+1.  Une *cratialité profonde*, distribuée dans des architectures techniques puissantes, difficiles à reconfigurer une fois mises en place.
+
+2.  Une *arcalité pratique largement métrique*, qui tend à se suffire à elle-même : les bons chiffres deviennent la preuve de la bonne direction.
+
+3.  Des *archicrations fragmentées*, souvent fantomatiques, qui peinent à reconduire l’ensemble du dispositif sur une scène où ses fondements, ses effets sociaux et ses impacts écologiques pourraient être mis en procès.
+
+Lorsque Système F est utilisé pour classer des dossiers sociaux, il est évalué sur la rapidité du traitement, le nombre de fraudes détectées, la diminution des coûts administratifs, la réduction des écarts de traitement mesurés par certains indicateurs. Lorsque Système F est utilisé dans la santé, il est évalué sur la pertinence prédictive, la réduction de certaines hospitalisations, l’amélioration d’indicateurs de performance hospitalière. Lorsqu’il est mobilisé sur les plateformes, on regarde la baisse de certains contenus jugés nocifs, la stabilité des usages, la croissance de l’engagement. Dans chacun de ces domaines, les métriques à partir desquelles on juge le système sont déjà produites à l’intérieur de l’écosystème qu’il reconfigure : elles ne sont pas “fausses”, mais elles jouent un rôle de miroir.
+
+En parallèle, les coûts sociaux et écologiques mis en évidence par l’épreuve de co-viabilité – non-recours, humiliations silencieuses, invisibilisations, tensions hydriques, charges électriques, déchets – se retrouvent, lorsqu’ils se manifestent, retraduits en langage de risque : risques de réputation, risques de non-conformité, risques de contentieux, risques de conflit local autour d’un data center. Ils entrent alors, eux aussi, dans des matrices de gestion qui visent à les réduire à l’intérieur du dispositif sans en remettre en cause l’architecture générale.
+
+Ce qui caractérise l’*autarchicratie numérique* n’est donc pas l’absence totale de réaction aux problèmes, mais la tendance forte à les traiter sans jamais sortir de l’univers des instruments. La scène où l’on pourrait demander : “Faut-il, oui ou non, utiliser Système F pour classer des familles, hiérarchiser des vies, prioriser des milieux ? À quelles conditions ? Avec quels renoncements explicites ?” reste largement introuvable.
+
+### VI.3.5. Ce qui ne peut pas apparaître
+
+L’*autarchicratie numérique* se mesure enfin à ce qui, dans la vie sociale et écologique, ne parvient pas à entrer dans les circuits de Système F autrement que comme bruit ou résidu. Les récits de personnes qui vivent des suspensions incompréhensibles, les expériences de médecins pris entre leur jugement clinique et une recommandation algorithmique, les inquiétudes d’habitants devant un projet de centre de données qui menacera leur ressource en eau, les fatigues d’ingénieurs qui savent, de l’intérieur, que certaines métriques ne disent pas tout : toutes ces expériences existent, mais elles peinent à trouver des scènes où elles pourraient, ensemble, reconfigurer les fondements et les instruments du dispositif.
+
+Autrement dit, l’*autarchicratie numérique* ne se définit pas uniquement par la puissance de Système F ou par la sophistication de ses modèles ; elle se définit par la raréfaction des lieux où ceux qui vivent ses effets peuvent le faire apparaître, le faire répondre, le faire bouger. Tant que Système F continue à se perfectionner à partir de ses propres indicateurs, en ajustant sa *cratialité* et son empreinte au fil de ses audits internes, tandis que les scènes externes demeurent marginales ou ornementales, le régime qui s’installe ne sera pas seulement celui d’une “*gouvernance par les données*”, mais bien celui d’un pouvoir régulateur qui se gouverne lui-même.
+
+C’est ce régime que la dernière section de ce cas pratique devra affronter plus directement, en traduisant en termes opératoires la politique des épreuves viables : non plus seulement diagnostiquer l’*autarchicratie numérique* de Système F, mais *proposer des conditions précises pour que des scènes d’archicration robustes puissent s’y inscrire, socialement et écologiquement, et rouvrir la possibilité d’un gouvernement qui accepte, à nouveau, d’être gouverné*.
+
+## VI.4. Politique des épreuves viables pour l’IA
+
+L’*épreuve de co-viabilité* ne se contente pas de constater les dégâts ou de dresser un inventaire des déficits scéniques ; elle appelle une politique. Si Système F est en train de devenir un opérateur central de la régulation sociale et écologique, *quelles épreuves viables doit-on instituer autour de lui pour que sa puissance n’équivaille pas à une sortie hors scène du politique ?* *Comment transformer la “gouvernance de l’IA”, souvent réduite à un mélange de conformité réglementaire et de bonnes pratiques éthiques, en une obligation forte de se laisser apparaître, d’accepter d’être mis en cause, ralenti, mis en pause, reconfiguré ?*
+
+### VI.4.1. Redéfinir l’acte régulateur : décider, c’est aussi instituer la scène
+
+Dans l’univers de Système F, la tentation est constante de définir l’acte régulateur par sa seule face instrumentale : choisir un modèle, fixer des paramètres, rédiger un cahier des charges, signer un contrat, déployer un module dans un *workflow* existant. *Tout se passe comme si la décision politique consistait à arbitrer entre solutions techniques, à déterminer un niveau d’ambition* (“plus de lutte contre la fraude”, “moins de non-recours”, “meilleure priorisation des soins”) *et à laisser ensuite les chaînes cratiales faire leur œuvre*.
+
+La politique des épreuves viables renverse ce geste. Elle propose de dire qu’*il n’y a d’acte régulateur légitime qu’à la condition que soient instituées, en même temps, les scènes où cet acte pourra être mis en épreuve*. Décider d’introduire Système F dans un régime de prestations sociales, dans une architecture hospitalière, dans une justice pénale, dans une plateforme de contenus, ce n’est pas seulement choisir un outil ; c’est se lier à l’obligation d’ouvrir des lieux, des procédures, des temporalités où la configuration archicratique pourra être contestée par ceux qui en portent les effets.
+
+Concrètement, cela signifie que l’on ne devrait plus pouvoir parler de “gouvernance de l’IA” en termes purement internes (cycles d’amélioration continue, matrices de risques, audits périodiques), mais comme d’un *engagement à multiplier les prises scéniques* : *droit au différé, possibilités de réexamen, dispositifs contradictoires, scènes écologiques, scènes de restitution publique*. Une IA sans scène devient un opérateur d’*autarchicratie*.
+
+### VI.4.2. Scènes viables pour la co-viabilité sociale : différé, justification, contestation
+
+Pour la *co-viabilité sociale*, trois types d’épreuves viables s’imposent. La première est celle du *droit au différé contradictoire*. Dans un régime où Système F contribue à suspendre des prestations, à déclencher des contrôles, à classer des personnes comme “à risque” ou “non prioritaires”, aucun résultat ne devrait être tenu pour définitivement opposable sans qu’ait été ouverte une fenêtre temporelle où la personne concernée peut demander : “Qui m’a classé ainsi ? Sur quels critères ? À partir de quelles données ? Avec quelle marge d’erreur ?”. Ce droit au différé n’est pas un luxe procédural : c’est la condition minimale pour que la régulation par IA ne se confonde pas avec un verdict sans visage.
+
+La deuxième est celle du *journal de justification*. Tant que les décisions appuyées par Système F restent des enchaînements de scores et de seuils, on ne peut opposer au justiciable, au patient, à l’allocataire, au candidat qu’un résultat (“votre demande est refusée”, “vous êtes classé à haut risque”, “votre candidature n’a pas été retenue”). Un régime archicratique exige que chaque décision de ce type soit adossée à un dossier où l’on consigne, de manière intelligible, la contribution de Système F : quelles variables ont pesé, quels modèles ont été sollicités, quels paramètres ont été utilisés, quelles alternatives étaient possibles. Ce journal n’a de sens que s’il est accessible et contestable, directement ou par l’intermédiaire de soutiens (avocats, associations, syndicats, défenseurs des droits). Sans ce support écrit, la scène reste sans prises.
+
+La troisième est celle de la *scène contradictoire élargie*. Il ne suffit pas que chaque personne puisse, isolément, contester “sa” décision. Les effets de Système F sont structurels : ils produisent des séries d’exclusions, de désavantages concentrés sur certains groupes, de priorisations systématiques. Des scènes viables exigent donc des dispositifs où l’on puisse porter collectivement ces problèmes : recours collectifs, instances de plainte capables d’agréger des cas similaires, audiences publiques où des associations de quartier, des collectifs de patients, des syndicats de salariés peuvent faire valoir que, pour certains profils, Système F n’est pas seulement “biaisé”, mais incompatible avec une vie digne. C’est à cette échelle, et pas seulement au niveau des dossiers individuels, que l’on peut reconfigurer les fonctions de coût, les proxies, les seuils – bref, la cratialité elle-même.
+
+### VI.4.3. Scènes viables pour la *co-viabilité écologique* : territoire, traçabilité, refus
+
+Sur le versant écologique, la politique des épreuves viables implique un déplacement comparable. Tant que l’empreinte de Système F est exprimée en indicateurs agrégés – quelques chiffres sur la consommation électrique totale ou la “neutralité carbone” projetée –, la scène de décision reste abstraite, intouchable. L’épreuve viable demande au contraire que chaque projet significatif d’extension de Système F soit rattaché à des territoires précis, à des réseaux, à des bassins versants, et que ces lieux deviennent parties prenantes de la décision.
+
+Concrètement, cela suppose d’abord une *traçabilité écologique attachée au dispositif* : un hôpital, une caisse sociale, un ministère qui décideraient de recourir à Système F devraient être en mesure de présenter, non seulement le bilan attendu en termes de performances régulatrices, mais aussi une cartographie des centres de données mobilisés, du mix électrique, des besoins en eau, des renouvellements de matériel. Ce n’est qu’à cette condition qu’une collectivité locale, un parlement, une instance de régulation écologique peuvent évaluer si les bénéfices attendus justifient les coûts imposés aux milieux concernés.
+
+Ensuite, la politique des épreuves viables exige des scènes territoriales dotées d’un véritable pouvoir de refus ou de renégociation. Une enquête publique où l’on collecte des observations sans obligation d’y répondre n’est pas une scène viable ; c’est un rituel. Ce qui est en jeu, c’est la possibilité pour des habitants, des agriculteurs, des communautés affectées de dire : “Dans cet état, ce projet n’est pas compatible avec notre co-viabilité. Il devra être réduit, déplacé, compensé autrement, ou renoncé.” Une telle capacité de refus conditionne, là encore, la *qualification archicratique du dispositif* : sans elle, la régulation par Système F prend appui sur des milieux assignés au sacrifice sans scène d’arbitrage.
+
+Enfin, l’épreuve viable impose que les promesses écologiques de Système F – optimisation d’infrastructures, gains d’efficacité, réduction d’autres impacts – soient elles aussi rendues discutables. Il ne s’agit pas de les nier, mais de les faire passer par une scène où les mêmes territoires qui supportent les data centers, l’extraction, les déchets, puissent demander des preuves, exiger des comparaisons, refuser que des bénéfices lointains servent de justification indéfinie à des dommages au plus proche.
+
+### VI.4.4. Du “gouvernement par l’IA” à l’obligation de comparution
+
+Au total, la politique des épreuves viables appliquée à l’IA ne se réduit ni à une éthique des concepteurs, ni à un perfectionnement des audits, ni à un raffinement des indicateurs de performance. Elle consiste à déplacer le centre de gravité de la gouvernance : d’un gouvernement par l’IA – où les modèles et les métriques pilotent silencieusement des pans entiers de la *co-viabilité* – *vers un gouvernement de l’IA par des scènes instituées, ouvertes, opposables*.
+
+Dans un tel régime, aucune extension majeure de Système F ne pourrait être décidée sans que soient explicitement définis :
+
+- les scènes où les personnes affectées pourront contester les décisions et faire modifier les instruments ;
+
+- les scènes où les impacts écologiques seront instruits avec ceux qui vivent dans les milieux concernés ;
+
+- les conditions matérielles d’un droit au différé, à la justification, à la révision, dotées de moyens et de calendriers réalistes.
+
+Ce renversement ne garantit pas que Système F deviendra spontanément juste, sobre, parfaitement co-viable. Il garantit quelque chose de plus modeste et de plus décisif : que Système F ne pourra plus se déclarer lui-même juste en se contentant de présenter de bons chiffres, de beaux rapports et des chartes généreuses. Il devra accepter de se tenir devant des scènes où ces chiffres, ces rapports, ces chartes sont eux-mêmes mis en question par celles et ceux qui vivent les effets du dispositif.
+
+Autrement dit, une politique des épreuves viables pour l’IA ne promet pas la fin des conflits ; elle en promet la scène. C’est à cette condition, et à cette condition seulement, que la puissance régulatrice de Système F pourra cesser d’être le vecteur privilégié d’une *autarchicratie numérique* et devenir l’un des terrains où s’invente, peut-être, une réouverture archicratique à la hauteur des crises sociales et écologiques contemporaines.

src/content/cas-ia/chapitre-7.mdx

@@ -0,0 +1,602 @@
+---
+title: "Chapitre VII — Gestes archicratiques concrets pour un système d’IA"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 80
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Chapitre_7_Gestes_archicratiques_concrets_pour_un_systeme_IA.docx"
+---
+# VII. Gestes archicratiques concrets pour un système d’IA
+
+Jusqu’ici, notre cas pratique a surtout pris la forme d’un diagnostic : mettre Système F en scène, le suivre dans ses topologies de scènes pauvres ou hypertrophiées, le replacer dans la généalogie des méta-régimes, le confronter à de grandes morphologies du pouvoir, mesurer ses effets sur la *co-viabilité sociale et écologique*, et nommer la *tendance autarchicratique* qui en résulte. La Partie VII change légèrement de registre. Elle ne rajoute pas une couche de théorie, elle n’empile pas un “programme politique” sur un diagnostic déjà dense ; elle tente autre chose : prendre au sérieux les gestes archicratiques formulés par la thèse en les traduisant, point par point, dans l’architecture concrète d’un grand système d’IA.
+
+Dans la conclusion générale de l’essai-thèse, ces gestes – *droit au différé, journal de justification, visas d’affectation, coupe-circuits, tribunaux dédiés, assemblées d’affectation, budgets scéniques, principes de révision et cartographies des scènes manquantes* – étaient présentés comme des *manières de rouvrir la scène là où la régulation tend à se refermer sur ses propres instruments*. Ici, ils deviennent le cœur d’un manuel d’usage de Système F : non plus des principes abstraits, mais des dispositifs à instituer, des séquences à préciser, des contraintes à inscrire dans le droit, dans l’organisation, dans les interfaces elles-mêmes. L’enjeu n’est pas de moraliser l’IA par quelques garde-fous, mais de montrer ce que cela change, très concrètement, de poser qu’aucun module de scoring, aucun pipeline décisionnel, aucune métrique de performance ne peut être légitime sans les scènes où il accepte de comparaître.
+
+La Partie VII adopte donc un rythme différent : chaque section partira d’un geste archicratique déterminé et le déploiera dans le monde de Système F. Le *droit au différé contradictoire*, d’abord, sera formulé comme *exigence minimale autour de toute décision substantielle appuyée par IA*, avec la question des *délais*, des *instances* et des *modalités d’accès au dossier* (VII.1). Le *journal de justification* des modèles et de leurs déploiements, ensuite, sera envisagé comme *support matériel de la comparution* : *pourquoi ce modèle, pourquoi cette métrique, quelles alternatives écartées, quels effets anticipés* (VII.2). Le *visa d’affectation des scores* viendra déplacer le cœur de la décision : avant de laisser un score trier des dossiers, il faudra qu’une scène instituée ait discuté la *légitimité de cette affectation* (VII.3). Le *coupe-circuit citoyen*, le *tribunal de l’algorithme*, les *assemblées d’affectation* dotées de budgets scéniques, enfin, seront pensés comme autant de dispositifs qui donnent un contenu précis à l’idée de “*pouvoir arrêter, juger, rediriger*” *un système d’IA* lorsqu’il produit des dégâts massifs ou des injustices systématiques (VII.4 à VII.6), avant que le *principe de révision archicrative* et la *cartographie des scènes manquantes* ne ferment la boucle en imposant une *périodicité* et une *vision d’ensemble* (VII.7).
+
+Ce déplacement est décisif : il ne s’agit plus de demander abstraitement si une IA est “alignée” sur des principes éthiques, mais de rediriger la normativité vers la structure des scènes qu’elle doit accepter autour d’elle. Un Système F peut rester techniquement le même – mêmes modèles, mêmes proxys, mêmes pipelines – et néanmoins changer de régime dès lors qu’on lui impose le droit au différé contradictoire, l’obligation de journaliser ses justifications, l’exposition régulière de ses métriques devant des assemblées d’affectation, la possibilité de coupe-circuits extra-techniques. Inversement, aucune “amélioration des biais” ne suffira si ces gestes ne sont pas institués : on restera dans l’*autarchicratie numérique* diagnostiquée à la Partie VI, où la *régulation se juge elle-même à l’aune de ses propres indicateurs*.
+
+La Partie VII ne promet donc pas un “plan d’action clé en main” pour toutes les IA, ni un catéchisme de bonnes pratiques ; elle propose une *traduction opératoire* : *que devient chacun de nos gestes archicratiques lorsqu’on le laisse travailler à l’intérieur du cas Système F ? Quelles formes juridiques, organisationnelles, matérielles peut-il prendre ? Quelles résistances rencontrera-t-il ? Quelles conditions minimales sont nécessaires pour qu’il ne se réduise pas, à son tour, à une archicration fantôme ?* C’est à ces questions que nous commençons à répondre avec le premier geste, celui qui redonne du temps et de la prise face à des décisions automatisées : le droit au différé contradictoire pour les décisions appuyées par IA.
+
+## VII.1. Droit au différé contradictoire pour les décisions appuyées par IA
+
+Le premier geste archicratique, appliqué à Système F, vise quelque chose de très simple et de très radical à la fois : *empêcher qu’une décision appuyée par IA ne se ferme sur elle-même au moment même où elle tombe*. Là où la régulation algorithmique tend à comprimer le temps (score instantané, exécution immédiate, effets souvent irréversibles), il s’agit de *réintroduire un temps politique* : *un délai, un espace et des prises pour que la personne concernée puisse contester, comprendre, faire valoir d’autres éléments*. Ce droit au différé contradictoire n’est pas une simple déclinaison de l’“explication” ou du “recours” ; c’est un principe structurant : aucune décision substantielle appuyée par IA ne devrait pouvoir produire ses effets pleins sans avoir traversé une fenêtre de contestation organisée.
+
+Les régulations existantes esquissent déjà quelque chose de cet ordre. L’article 22 du RGPD reconnaît le *droit de ne pas être soumis à une décision produisant des effets juridiques, fondée exclusivement sur un traitement automatisé, et d’obtenir une intervention humaine, d’exprimer son point de vue, de contester la décision*. L’AI Act consacre, pour certaines décisions fondées sur des systèmes d’IA à haut risque, un droit à une explication “claire et significative” du rôle du système et des principaux éléments de la décision. Mais ces droits, tels qu’ils sont formulés, restent en grande partie défensifs : ils garantissent une possibilité d’intervention *ex post*, à l’intérieur d’un cadre que l’architecture de la décision continue de dominer. Le *droit au différé contradictoire*, tel que nous le formulons pour Système F, cherche à inverser la perspective : c’est à la décision de se mettre en attente devant la personne, pas l’inverse.
+
+### VII.1.1. Ce qu’est une “décision substantielle appuyée par IA”
+
+Pour ne pas verser dans le vœu pieux, il faut d’abord délimiter le champ. Nous appelons “*décision substantielle appuyée par IA*” toute décision qui répond à trois critères.
+
+Premièrement, elle *affecte de manière significative la situation de la personne*, au sens proche de l’article 22 du RGPD : *effets juridiques directs* (suspension ou refus de prestation, attribution ou retrait d’un statut, condamnation, détention, refus de titre de séjour, licenciement) ou *effets socio-économiques d’ampleur équivalente* (perte d’accès à un soin important, refus d’un crédit crucial, mise au chômage prolongé). Dans Système F, cela recouvre par exemple : la suspension d’une allocation logement à la suite d’un score de “risque de fraude”, la décision d’enquêter en priorité sur une famille plutôt qu’une autre, la non-inscription d’un patient dans un programme de soins renforcés, la classification d’un justiciable dans la catégorie “haut risque de récidive”, le rejet d’un dossier de candidature, le déréférencement d’un contenu qui conditionne fortement la visibilité d’une parole.
+
+Deuxièmement, la décision est appuyée par IA : le modèle n’agit pas nécessairement “seul”, mais son output (score, recommandation, classement, étiquette) est intégré de manière structurante dans la chaîne de décision. C’est bien ce que reconnaissent déjà, en creux, les régulations : le RGPD cible les décisions “fondées exclusivement” sur un traitement automatisé, mais la pratique montre que beaucoup de décisions “mixtes” restent en fait déterminées par la sortie d’un système, la marge de manœuvre humaine étant faible ou purement formelle. Système F est emblématique de ce cas : l’agent social, le médecin, le recruteur, le modérateur peuvent théoriquement s’écarter du score, mais tout, dans l’interface et les procédures, les incite à renoncer et à s’aligner.
+
+Troisièmement, il existe une asymétrie d’information et de prise telle que, sans geste archicratique spécifique, la personne concernée ne peut ni voir, ni comprendre, ni contester efficacement la contribution de l’IA. Là encore, les lignes directrices européennes sur le profilage et la décision automatisée constatent que l’opacité des modèles et la complexité des chaînes de traitement constituent un obstacle majeur à l’exercice effectif des droits. C’est cette asymétrie que le droit au différé contradictoire vise à entamer.
+
+### VII.1.2. Formulation archicratique du droit au différé contradictoire
+
+Formulé en langage archicratique, le geste est le suivant : *toute décision substantielle appuyée par IA doit être assortie d’un droit opposable au différé contradictoire*, c’est-à-dire d’un délai pendant lequel la personne :
+
+1.  est *informée de manière explicite de l’usage d’un système d’IA dans la décision* ;
+
+2.  *peut demander que la décision ne produise pas immédiatement tous ses effets, ou les produise sous une forme réversible* ;
+
+3.  *obtient l’ouverture d’une scène où elle peut confronter les raisons de la décision, présenter des éléments, demander un réexamen avec intervention humaine effective.*
+
+Ce droit ne vient pas remplacer les droits existants à l’explication, à la contestation ou à l’intervention humaine ; il les restructure. Le RGPD garantit déjà, au moins pour certaines décisions, la possibilité de demander une intervention humaine et de contester. L’AI Act ajoute, pour les systèmes à haut risque, un *droit à une explication claire du rôle de l’IA et des principaux éléments de la décision*. Nous faisons un pas de plus : nous posons que, *sans délai et sans suspension potentielle des effets, ces droits restent largement théoriques*. Une explication qui arrive après une expulsion locative, après une faillite, après une perte d’emploi, a une valeur symbolique mais ne constitue pas une véritable *archicration* ; elle intervient trop tard pour rouvrir la scène de la décision.
+
+À l’inverse, le *droit au différé contradictoire* introduit, dans la *cratialité* de Système F, une *zone de fragilité volontaire* : un *moment où la décision n’est pas encore close, où l’arcalité implicite du modèle et la cratialité des pipelines sont obligées de se prêter à la controverse*. Il ne s’agit pas de paralyser la régulation, mais de reconnaître que l’automatisation des décisions substantielle exige une compensation scénique : *plus la chaîne est rapide, plus le droit au différé doit être robuste*.
+
+### VII.1.3. Délais, suspension partielle et graduations sectorielles
+
+Ce principe doit ensuite être articulé à des paramètres concrets. Il serait illusoire – et peu archicratique – de fixer un délai unique pour tous les contextes. En revanche, on peut dégager plusieurs figures de temporalité qui se retrouvent dans la plupart des usages de Système F.
+
+Dans le champ social, un refus ou une suspension de prestation appuyé par un score de “risque de fraude” devrait, par principe, ne pas produire immédiatement ses effets les plus destructeurs. Autrement dit : l’administration pourrait signaler l’anomalie, déclencher un contrôle, mais un socle minimal de prestations devrait être maintenu pendant un certain délai, le temps que la personne puisse comprendre la situation, accéder à son dossier, demander un réexamen. Les expériences documentées de suspension massive de prestations sur base algorithmique montrent qu’en l’absence de cette temporisation, le dommage social (dettes, expulsions, déscolarisation) est très rapide, alors que la rectification juridique, elle, peut prendre des mois.
+
+Dans la santé, la temporalité est plus tendue : on ne peut pas différer indéfiniment une décision de priorisation d’accès à un soin. Mais on peut distinguer ce qui est irréversible de ce qui est révisable. Un triage de liste d’attente fondé sur Système F pourrait être appliqué immédiatement pour organiser l’ordre du jour médical, tout en restant explicitement révisable dans les jours qui suivent, si le patient ou un tiers fait valoir des éléments que le modèle n’a pas pris en compte. Ici, *le droit au différé se traduit moins par un gel des effets que par une réversibilité organisée* : la décision ne devient pleinement clôturée qu’après un laps de temps pendant lequel une réévaluation humaine est possible.
+
+Dans la justice pénale, les décisions qui mobilisent des scores de risque (détention provisoire, libération conditionnelle, mesures de sûreté) pourraient faire l’objet d’un mécanisme analogue : lorsque le score de Système F pèse de manière significative dans la décision, le justiciable devrait bénéficier d’un délai effectif pour demander la communication du rôle joué par l’IA et solliciter un réexamen, que ce soit dans le cadre d’un appel ou d’une procédure spécifique. Le droit procédural européen repose déjà sur l’exigence de motivation des décisions et sur la possibilité de recours ; il s’agirait ici de reconnaître explicitement que l’usage d’une IA est, en soi, un motif supplémentaire de différé, tant que son apport n’a pas été entièrement éclairci.
+
+Dans le recrutement, enfin, le *droit au différé* pourrait *interdire les rejets instantanés de candidatures sur la seule base d’un filtrage algorithmique* : toute candidature écartée à la suite d’un passage par Système F devrait, au minimum, pouvoir être réactivée par la personne sur la base d’une demande motivée (“je conteste que tel critère soit pertinent pour ce poste”) ; les délais seraient plus courts, mais la logique resterait la même : empêcher que le “non” algorithmique ne soit immédiatement absorbé par les procédures.
+
+Ce qui importe n’est pas de figer des durées identiques partout, mais de poser un *principe de graduation* : *plus les effets sont graves et irréversibles*, *plus le délai de différé doit être long et la suspension substantielle des effets garantie* ; *plus ils sont légers et réversibles, plus la temporalité peut être resserrée, mais jamais réduite à zéro*.
+
+### VII.1.4. Instances compétentes et accès effectif au dossier
+
+*Un différé sans interlocuteur identifié serait une parodie de droit*. Le geste archicratique suppose donc de désigner des *instances compétentes pour instruire le contradictoire*, et de *garantir un accès réel au dossier.*
+
+Dans une caisse sociale, il ne suffit pas de renvoyer l’allocataire vers un formulaire de réclamation générique. Il faut une *cellule de réexamen* qui ait à la fois la *compétence métier* (comprendre les règles de prestations), la *compétence technique* (lire un score, interpréter les variables, convoquer les logs de Système F) et la *capacité de décision*. Cette cellule doit pouvoir, le cas échéant, infirmer la décision initiale, corriger le modèle ou solliciter une expertise externe.
+
+Dans un hôpital, le contradictoire devrait être organisé autour d’une *instance éthique médicale* capable de revisiter, à la lumière des données cliniques et des contraintes organisationnelles, la priorisation proposée par Système F. Dans un tribunal, ce rôle revient, en dernier ressort, au juge lui-même, mais il pourrait être épaulé par des *experts indépendants*, sur le modèle des *amicus curiae* *techniques* que l’on commence à voir apparaître dans certains contentieux liés aux algorithmes — à l’image de la Suisse dans *Google c. CNIL (C-507/17)* – façonnant l’interprétation des règlements, notamment sur des questions de souveraineté numérique.
+
+Au-dessus de ces instances sectorielles, les autorités de protection des données, les autorités sectorielles et les organismes créés par l’AI Act pour superviser les systèmes à haut risque fournissent une architecture de recours externe : ils peuvent être saisis en cas de dysfonctionnement structurel, de défaut d’explication, de violation des droits procéduraux. Le droit au différé contradictoire demande que ces circuits soient articulés, de manière lisible, avec les recours de première ligne : l’allocataire, le patient, le justiciable, le candidat ne doivent pas avoir à deviner à qui s’adresser.
+
+Enfin, le contradictoire n’a de sens que si la personne accède à un dossier intelligible. Ici, l’articulation avec le droit à l’explication consacré par l’AI Act est centrale : la personne doit pouvoir obtenir une description claire du rôle joué par Système F dans la décision et des principaux éléments qui l’ont déterminée. Mais le geste archicratique ajoute deux exigences :
+
+- d’une part, que cette *explication soit fournie avant que la décision ne devienne irrévocable, pendant la période de différé* ;
+
+- d’autre part, qu’elle soit *accompagnée des informations nécessaires pour contester : nature des données utilisées, grandes lignes des critères de tri, existence de tests de biais, possibilités d’alternatives*.
+
+### VII.1.5. Effet structurant sur Système F : rouvrir la chaîne
+
+Du point de vue de Système F, le droit au différé contradictoire n’est pas un simple “dégât collatéral” à absorber ; c’est une *contrainte de design*. Il *oblige les concepteurs, intégrateurs et utilisateurs à prévoir, dans leurs pipelines, des points de réouverture* : *journaux d’exécution exploitables, interfaces de consultation, procédures de suspension, circuits de réexamen*. Il impose que la *cratialité* ne soit pas une chaîne fermée allant de la collecte de données à la décision, mais un *circuit avec, en son milieu, une scène d’exposition et de révision possible*.
+
+C’est en cela que ce premier geste archicratique est exemplaire : il montre que l’on peut déplacer la question de la “régulation de l’IA” loin des seules chartes éthiques ou des ajustements techniques de biais. Tant que les décisions substantielles appuyées par IA tomberont comme des verdicts instantanés, même les meilleurs principes resteront anti-scéniques. À l’inverse, *dès qu’un droit opposable au différé contradictoire est institué, même un Système F imparfait cesse d’être un pur opérateur d’autarchicratie* : il devient, par construction, *appelable et interpellant en scène*.
+
+## VII.2. Journal de justification des modèles et de leurs déploiements
+
+Le droit au différé contradictoire ouvre du temps. Mais un temps sans mémoire n’ouvre pas grand-chose : si, au moment où la décision est contestée, personne n’est en mesure de dire pourquoi tel modèle a été choisi plutôt qu’un autre, pourquoi telle métrique a été retenue, pourquoi tel seuil a été fixé à ce niveau et pas à un autre, la scène reste vide. Le deuxième geste archicratique consiste donc à arrimer ce temps au support qui lui manque : un *journal de justification* attaché à chaque déploiement de Système F, c’est-à-dire un document vivant où sont consignées, au fur et à mesure, les décisions structurantes relatives au modèle et à sa mise en œuvre – avec leurs raisons, leurs alternatives écartées, leurs effets anticipés.
+
+L’idée n’est pas de réinventer la documentation technique. Le règlement européen sur l’IA impose déjà, pour les systèmes à haut risque, la préparation et la mise à jour d’une documentation détaillée : description de l’architecture, des objectifs, des données, des tests, des performances, des procédures de gestion des risques. Le RGPD, de son côté, *oblige à documenter les analyses d’impact sur la protection des données* (AIPD) pour certains traitements sensibles. De nombreuses propositions issues de la communauté de recherche vont dans le même sens : *datasheets for datasets* pour décrire les jeux de données, *model cards* pour exposer les usages prévus, les *conditions d’évaluation* et les *performances différenciées des modèles*. Des standards de transparence algorithmique, comme le *Algorithmic Transparency Recording Standard* au Royaume-Uni ou les registres d’algorithmes en cours d’expérimentation dans plusieurs pays, invitent les administrations à publier des fiches descriptives de leurs outils.
+
+Nous ne partons donc pas de rien. Mais, du point de vue archicratique, ces instruments souffrent de deux limites : ils sont pensés depuis la conformité – démontrer que l’on remplit des exigences réglementaires – plus que depuis la *justification* , et ils restent trop souvent séparés de la scène : produits pour des autorités de contrôle ou des pairs techniques, rarement pour les personnes qui subissent les décisions. Le *journal de justification* que nous proposons pour Système F radicalise et reconfigure ces efforts : il s’agit de *produire un objet documentaire* qui soit, *dès l’origine, orienté vers le fait de pouvoir répondre de la présence d’un modèle dans une chaîne décisionnelle et rendre raison des choix effectués tout au long de sa vie*.
+
+### VII.2.1. De quoi un “*journal de justification*” est-il le nom ?
+
+Concrètement, un *journal de justification* n’est ni un rapport unique écrit une fois pour toutes, ni une simple base de logs techniques. C’est un *fil chronologique de décisions structurantes, chacune accompagnée de quatre éléments minimaux* : *qui* décide, *sur quoi* porte la décision, *au nom de quoi* elle est prise, *quelles alternatives* ont été envisagées et écartées.
+
+Ainsi, lorsque l’administration qui intègre Système F dans la détection de fraude sociale choisit un modèle de scoring plutôt qu’un autre, cet acte devrait apparaître sous forme d’entrée : date, acteurs impliqués, modèles comparés, critères de choix (performance globale, sensibilité aux faux positifs, contraintes budgétaires), éventuelles réserves formulées. De même pour la sélection des variables (inclusion ou exclusion de la nationalité, du code postal, de variables familiales), pour la définition de la fonction de coût (pondération relative des différents types d’erreurs), pour la fixation des seuils de “haut risque”, pour la mise en production dans tel ou tel territoire.
+
+Ce que des approches comme les *model cards* et les *datasheets* esquissent déjà – *documenter le contexte d’usage, les performances différenciées, les limites, les risques de biais* –, le *journal de justification le reprend*, mais en le reliant à deux exigences supplémentaires : la *traçabilité temporelle* (on doit pouvoir reconstituer la séquence des arbitrages qui ont conduit à la configuration actuelle — type *blockchain*) *et l’adressage scénique* (ce journal est conçu pour être lisible, au moins par médiation, par les personnes appelées à juger ou à contester Système F : juges, autorités, instances d’*archicration*, représentants ou portes-voix des publics affectés).
+
+### VII.2.2. Unifier les fragments : de la documentation dispersée à un support scénique
+
+Du point de vue de Système F, la documentation existe déjà, mais elle est éclatée : spécifications techniques du fournisseur, fiches d’architecture des intégrateurs, cahiers des charges publics, AIPD, dossiers d’homologation, notices d’utilisation. L’AI Act exige en outre des journaux de logs conservés plusieurs mois pour les systèmes à haut risque, afin d’enquêter en cas de dysfonctionnement. Les administrations commencent à publier des fiches de transparence sur les outils utilisés, parfois dans des registres publics.
+
+Le *journal de justification* ne vient pas s’ajouter comme une pièce de plus à ce puzzle ; il sert de charnière : il relie les différents documents existants en fonction d’une seule question directrice – *pourquoi ce système, ainsi configuré, dans ce contexte précis, est-il présenté comme acceptable ?* – et organise les fragments en vue d’un usage scénique. Il oblige, par exemple, à relier explicitement :
+
+- les *hypothèses formulées dans l’analyse d’impact initiale* (sur les risques de discrimination, les publics concernés, les scénarios de défaillance) ;
+
+- les *résultats des tests et audits de biais régulièrement effectués* ;
+
+- les *décisions de poursuivre, suspendre, ajuster le déploiement à la lumière de ces résultats*.
+
+Là où beaucoup de démarches d’“*IA responsable*” s’arrêtent à des rapports internes, ce journal est conçu pour être mobilisable : lorsqu’un *tribunal de l’algorithme* est saisi, lorsqu’une *autorité de contrôle enquête,* lorsqu’une *assemblée d’affectation demande des comptes*, ce n’est pas à des ingénieurs isolés de recomposer, dans l’urgence, la généalogie du système ; *c’est au journal d’offrir le matériau de la controverse*.
+
+### VII.2.3. Contenu minimal pour Système F : décisions, alternatives, anticipations
+
+Dans le cas qui nous occupe, on peut identifier, sans prétendre à l’exhaustivité, plusieurs nœuds de décision qui doivent nécessairement figurer dans le *journal de justification* de Système F.
+
+Le premier est le *choix même de recourir à une IA* : *pourquoi décider, dans un secteur donné, de confier à Système F une partie de la détection de fraude, du tri de dossiers, de la priorisation des soins, de la sélection de candidatures, de la modération de contenus ? Quelles autres options ont été envisagées (renforcement de moyens humains, améliorations de procédures, outils statistiques plus simples) et pourquoi ont-elles été jugées moins pertinentes ?* La littérature sur la responsabilité de l’IA rappelle que l’essentiel se joue souvent à ce niveau “pré-algorithmique” : la décision de *mettre* un algorithme au cœur du processus échappe largement aux instruments de contrôle classiques.
+
+Le second concerne la *définition des variables et des proxies* : pourquoi choisir les coûts de santé comme proxy des besoins cliniques, la nationalité comme signal de risque, l’historique de recrutements comme gabarit du “talent”, tel indicateur d’engagement comme substitut de la “qualité” des contenus ? Les travaux sur les biais algorithmiques, notamment dans les systèmes de santé et les dispositifs de recrutement, ont montré que ces choix peuvent reproduire ou amplifier des inégalités raciales et de genre tout en demeurant invisibles aux yeux des décideurs politiques. *Le journal doit faire apparaître les justifications invoquées, les mises en garde éventuelles, les alternatives envisagées* (d’autres proxies, d’autres combinaisons de variables) et *les raisons de leur rejet*.
+
+Le troisième porte sur la *fonction de coût et les métriques de performance* : *quel compromis a-t-on adopté entre faux positifs et faux négatifs dans un scoring pénal ou social ? Quelle priorité donne-t-on à la réduction globale des erreurs par rapport à la réduction des écarts entre groupes ? Quels indicateurs d’équité retient-on, parmi ceux – incompatibles entre eux – que la littérature a mis en évidence, et pourquoi ?*
+
+Le quatrième concerne la *mise en production* et les *conditions de déploiement* : *dans quels territoires, secteurs, catégories de dossiers commence-t-on à utiliser Système F ? Avec quelles mesures d’accompagnement (formation des agents, information des usagers, périodes de test sans effet direct sur les droits) ? Quelles limites explicites pose-t-on au système (par exemple : interdiction d’utilisation comme unique base décisionnelle pour une incarcération, un refus de titre de séjour, une radiation définitive) ?* Là encore, ces choix sont rarement documentés de manière structurée, alors qu’ils déterminent la matérialité des effets.
+
+Enfin, le journal doit contenir les *entrées liées aux révisions* : *incidents graves, résultats d’audits défavorables, décisions de justice, interpellations de collectifs, corrections apportées au modèle ou à ses usages*. Ce sont ces entrées qui permettent d’éviter ce que d’autres travaux appellent “*l’effacement organisationnel*” des problèmes : la tendance à oublier rapidement les controverses passées dès que le système a été légèrement ajusté, sans trace durable des raisons qui ont conduit à ces ajustements.
+
+### VII.2.4. Du point de vue archicratique : transformer une archive en scène potentielle
+
+Pourquoi, du point de vue de l’*archicratie*, insister autant sur cet objet documentaire ? Parce que le *journal de justification est le pont matériel entre l’arcalité implicite et l’archicration possible*.
+
+Tant que les choix de proxies, de métriques, de seuils et de contextes de déploiement restent dissous dans des réunions non documentées, des échanges d’e-mails ou des lignes de code, l’*arcalité* de Système F demeure *fantôme* : *elle agit mais ne laisse pas de trace discursive suffisamment consistante pour être ramenée sur une scène*. Lorsque survient un scandale – discriminations massives dans un système de prestations sociales, priorisation injuste de patients, biais structurels dans un outil de recrutement – les organisations se replient sur un récit lissé : “il y a eu des erreurs”, “nous avons corrigé le modèle”, “nous avons amélioré notre gouvernance”.
+
+Un *journal de justification* rigoureusement tenu empêche en partie cette réécriture. Il montre, par exemple, que telle mise en garde avait été formulée mais écartée, que telle alternative moins discriminante avait été jugée “trop coûteuse”, que telle métrique avait été choisie pour des raisons de commodité plus que de justice. Il ne se substitue pas au travail politique, juridique, médiatique de requalification ; il en fournit la matière. C’est ce que recherchent, sous d’autres formes, certains standards de transparence algorithmique : permettre à des tiers – parlementaires, journalistes, chercheurs, associations – de reconstruire la chaîne des décisions qui ont conduit à l’usage d’un système dans le secteur public.
+
+En ce sens, le *journal de justification* est déjà, en lui-même, une *mini-scène* : *un lieu où les acteurs parlent au futur contradicteur*. Il oblige les concepteurs et les décideurs à se positionner comme susceptibles d’être interrogés : “*si l’on nous demande demain pourquoi nous avons fait cela, qu’aurons-nous à répondre ?*”. Cette projection n’est pas une simple anticipation juridique ; elle est une première forme d’*archicration intériorisée*.
+
+### VII.2.5. Conditions de fiabilité : indépendance, sincérité, partage
+
+Évidemment, un *journal de justification* n’a de valeur archicratique que s’il n’est pas une pure pièce de communication. La littérature sur la responsabilité de l’IA en contexte public insiste sur la tentation permanente de transformer les instruments de transparence en vitrines, où l’on met en avant les bonnes pratiques et où l’on minimise les controverses réelles.
+
+Trois conditions minimales doivent donc être posées.
+
+La première est une *forme d’indépendance* : même si le journal est tenu au quotidien par les équipes en charge du système, son existence, sa structure et ses mises à jour doivent faire l’objet d’un contrôle externe (autorité de supervision, instance professionnelle, tribunal de l’algorithme) ; certaines entrées – notamment celles qui concernent des désaccords internes, des alertes, des alternatives écartées – ne doivent pas pouvoir être effacées ou réécrites unilatéralement.
+
+La deuxième est la *sincérité descriptive* : il ne s’agit pas d’exiger une confession morale, mais d’interdire les omissions grossières. Si une variable est maintenue malgré des doutes sérieux sur son caractère discriminant, si un audit de biais met en lumière des écarts massifs et que l’on décide malgré tout de poursuivre le déploiement, le journal doit le dire. Sans cette sincérité minimale, il redevient un outil de légitimation, non un support d’épreuve.
+
+La troisième est le *partage différencié* : tout ne peut pas être rendu public dans le détail (secrets commerciaux, risques d’ingénierie inversée, enjeux de sécurité). Mais il doit exister une version du journal accessible aux différents cercles de la scène : version intégrale pour les autorités de contrôle et les tribunaux, version détaillée mais non technique pour les assemblées d’affectation et les collectifs concernés, version synthétique pour le grand public. Les outils existants – registres d’algorithmes, modèle*s* de transparence, *model cards* publiques – offrent des exemples de cette gradation.
+
+Avec ce deuxième geste, notre cas pratique franchit un pas décisif : *Système F* cesse d’être seulement un ensemble de poids de réseau neuronal et de scripts d’intégration ; il devient aussi une *histoire documentée de choix régulateurs, susceptible d’être lue, interrogée, disputée*. *Le droit au différé contradictoire ouvre la brèche temporelle ; le journal de justification lui donne une mémoire et une matière*. Les gestes suivants – visa d’affectation, coupe-circuit, tribunal de l’algorithme, budget scénique – viendront préciser comment, à partir de cette mémoire, on institue des scènes où Système F ne se contente plus d’opérer, mais apprend à répondre.
+
+## VII.3. Visa d’affectation des métriques et des scores IA
+
+Avec le droit au différé contradictoire, nous avons rouvert le temps de la décision. Avec le journal de justification, nous avons commencé à documenter les choix structurants qui façonnent Système F. Le troisième geste archicratique change encore légèrement de focale : il ne porte plus sur le *modèle en général*, ni sur la *décision individuelle*, mais sur le moment précis où un score ou une métrique est affecté à une fonction régulatrice déterminée.
+
+Un même score issu de Système F peut, en effet, être utilisé pour des choses très différentes :
+
+- dans un système de santé, un indice de risque peut servir à *proposer* une surveillance renforcée, ou à *refuser* l’accès à un programme de soins coûteux ;
+
+- dans la justice pénale, un score de récidive peut être mobilisé comme élément parmi d’autres dans un rapport d’évaluation, ou devenir la condition quasi-mécanique d’une détention préventive ;
+
+- dans la protection sociale, un score de fraude peut simplement *déclencher un contrôle humain*, ou entraîner une *suspension automatique* de prestations ;
+
+- sur une plateforme, un score d’“engagement” peut être utilisé pour *adapter des recommandations* ou pour *rendre quasi invisible* une catégorie de contenus.
+
+Dans tous ces cas, le même artefact numérique – une probabilité, un rang, un indicateur – change de nature selon l’usage qui en est fait. C’est ce que reconnaissent implicitement plusieurs cadres récents : l’AI Act classe les systèmes d’IA comme “à haut risque” non pas en fonction de leur architecture interne, mais en fonction de leur *usage prévu* et des domaines où ils sont déployés (emploi, crédit, éducation, justice, migration, services essentiels, etc.). Le rapport du Conseil de l’Europe sur la régulation des systèmes algorithmiques insiste de son côté sur la nécessité de distinguer le “modèle” du “système socio-technique” concret, qui inclut le contexte d’utilisation et la nature des décisions prises sur sa base.
+
+Le geste archicratique que nous appelons *visa d’affectation* prend appui sur ces constats, mais les pousse plus loin : aucun score ni aucune métrique issue de Système F ne devrait être autorisé à structurer une décision substantielle sans avoir obtenu, pour cette affectation précise, un visa délivré à l’issue d’une scène instituée.
+
+### VII.3.1. Affecter un score, c’est décider de sa portée régulatrice
+
+Dans les régimes de régulation que l’AI Act qualifie de “haut risque”, le règlement impose déjà que le fournisseur définisse très clairement “l’usage prévu” du système et que l’utilisateur professionnel ne le détourne pas vers des usages non prévus ou plus intrusifs. Les lignes directrices sur les analyses d’impact algorithmiques, qu’elles soient canadiennes, néerlandaises ou britanniques, invitent également à qualifier, pour chaque projet, la “portée de la décision” et la “sensibilité du contexte”.
+
+Mais, en pratique, cette notion de “portée” reste floue. Elle est traitée comme un paramètre dans un formulaire d’impact, non comme un objet d’archicration. Le visa d’affectation, tel que nous le formulons pour Système F, consiste à faire de cette question un moment de scène à part entière :
+
+- *Ce score peut-il être utilisé pour classer des dossiers, mais pas pour suspendre un droit ?*
+
+- *Ce score de dangerosité peut-il légalement justifier une incarcération, ou seulement motiver une surveillance accrue ?*
+
+- *Ce score d’“engagement” peut-il servir à élever certains contenus, mais pas à enfouir des expressions politiques ou syndicales légitimes ?*
+
+- *Ce score de “probabilité de succès” peut-il trier des candidatures pour un entretien, mais pas justifier des refus définitifs sans examen humain ?*
+
+Affecter un score à une fonction, ce n’est pas une simple opération de paramétrage ; c’est attribuer une force normative à un indicateur : lui donner le pouvoir de faire basculer un dossier d’un côté ou de l’autre d’une frontière. Le visa d’affectation est le dispositif par lequel cette attribution est mise en scène, discutée, encadrée.
+
+### VII.3.2. Une instance scénique dédiée : qui délivre le visa ?
+
+Sur le plan institutionnel, le visa d’affectation suppose l’existence d’une instance scénique identifiable, différente à la fois des équipes techniques, des directions métiers et des autorités de contrôle généralistes. On retrouve ici des idées déjà en germe dans plusieurs expériences :
+
+- les *Algorithmic Impact Assessments* prévus par certaines administrations, qui doivent être examinés par des comités transversaux associant juristes, techniciens et représentants du public ;
+
+- les *ethics review boards* constitutionnels ou sectoriels, qui rendent des avis sur des projets de systèmes d’IA engagés dans des secteurs sensibles ;
+
+- les projets de “*comités d’algorithmes*” locaux, comme ceux expérimentés dans certaines villes pour évaluer les outils utilisés par la police, les services sociaux ou les transports.
+
+L’instance qui délivre le *visa d’affectation* doit réunir, a minima :
+
+1.  des *représentants des métiers* (agents sociaux, médecins, magistrats, recruteurs, modérateurs) qui comprennent ce que la décision signifie concrètement ;
+
+2.  des *personnes ayant une compétence technique indépendante* vis-à-vis de Système F, capables de lire les métriques, de comprendre les limitations du score, de pointer les effets potentiels sur certains groupes ;
+
+3.  des *représentants ou portes-voix des publics affectés* (associations d’usagers, collectifs de patients, syndicats, associations de défense des droits fondamentaux) qui apportent le point de vue de ceux qui seront classés, profilés, priorisés.
+
+Nous n’inventons pas *ex nihilo* cette composition : le Conseil de l’Europe et plusieurs rapports académiques plaident pour des *organes de gouvernance de l’IA pluridisciplinaires*, incluant systématiquement des représentants de la société civile dans les décisions structurantes sur les systèmes d’IA publics. Le *visa d’affectation* consiste à donner à ce type d’organe un pouvoir explicite sur la façon dont les scores sont utilisés.
+
+### VII.3.3. Une procédure : ce que contient une demande de visa d’affectation
+
+Pour qu’un visa ne soit pas une simple formalité, il faut que la *demande de visa d’affectation* contienne un minimum d’éléments substantiels. Dans le cas de Système F, quatre blocs sont indispensables.
+
+1.  *Description de la décision visée* : nature de la décision (accord / refus / suspension / priorisation / classement), domaine (social, santé, justice, emploi, plateforme), effets attendus, publics concernés. On rejoint ici les classifications par “domaines à risque élevé” du droit européen, mais en les reformulant depuis l’impact concret sur les personnes.
+
+2.  *Caractéristiques du score ou de la métrique* : type d’indicateur (probabilité, rang, catégorie), mode de calcul, performances globales et différenciées (par genre, origine, âge, territoire, handicap, etc.), incertitudes connues, tests de robustesse réalisés. La littérature sur les audits de biais rappelle que ce type d’informations est indispensable pour apprécier la légitimité d’utiliser un score comme base d’une décision substantielle.
+
+3.  *Proposition d’affectation* : quel rôle précis le score jouera-t-il (critère déterminant, filtre initial, signal de vigilance, recommandation non contraignante) ? À quel seuil fera-t-on basculer une personne d’une catégorie à une autre ? Le score pourra-t-il être compensé par d’autres éléments (par exemple des circonstances sociales, médicales, familiales) ? Quelle marge d’appréciation est laissée aux agents humains ?
+
+4.  *Analyse des risques et alternatives* : quels risques de discrimination, de stigmatisation, d’exclusion sont identifiés dans cette affectation ? Quelles autres modalités d’usage du score ont été envisagées (réservé à une deuxième lecture humaine, utilisé comme alerte secondaire, limité à des décisions moins lourdes) et pourquoi ont-elles été écartées ? Quels mécanismes correctifs (droit au différé, révision humaine systématique, monitoring continu des effets) seront mis en œuvre ?
+
+Ce type de contenu s’inspire des bonnes pratiques émergentes dans les analyses d’impact algorithmiques et les déclarations de transparence, mais le déplace au point précis où le score accède à la fonction régulatrice : l’affectation.
+
+### VII.3.4. Un visa toujours conditionnel : temporalité, révision, retrait
+
+Dans un régime archicratique, un visa n’est jamais un blanc-seing illimité. Il est conditionnel et révisable.
+
+Dans le cas de Système F, un *visa d’affectation pourrait être délivré pour une durée déterminée* (par exemple trois ans)*, assorti d’obligations de monitoring : suivi des effets sur différents groupes, remontée systématique des contestations et recours, surveillance des dérives d’usage* (extension du score à des décisions non prévues). L’AI Act impose déjà des obligations de surveillance post-marché pour les systèmes à haut risque, ainsi que des mises à jour en cas de modifications significatives du système. *Le visa archicratique s’appuie sur cette logique, mais la rend scénique* : *les rapports de monitoring et les incidents doivent revenir devant l’instance qui a délivré le visa ; ils peuvent conduire à des conditions supplémentaires, à une restriction de l’affectation ou, en dernier ressort, au retrait du visa*.
+
+La structure de Système F (services fournis via API, mises à jour fréquentes des modèles, redéploiements rapides dans de nouveaux contextes) rend cette révision d’autant plus nécessaire. Sans visa conditionnel, une affectation initiale relativement prudente peut, en peu de temps, se transformer en usage beaucoup plus intrusif : le score initialement destiné à aider au tri des dossiers peut devenir le critère principal de refus ; le score d’engagement peut être recyclé comme proxy de “fiabilité” de la parole, etc.
+
+Le visa d’affectation archicratique a pour fonction de ramener périodiquement ces glissements sur scène. Il oblige les responsables à dire : “nous avions prévu tel usage de ce score ; voici ce qu’il en est réellement aujourd’hui ; voici les effets constatés ; voici pourquoi nous estimons qu’il peut être prolongé, modifié ou retiré”.
+
+### VII.3.5. Effet de structure : dé-spectaculariser la métrique, re-politiser l’affectation
+
+Au fond, ce geste répond à un phénomène que de nombreux travaux critiques sur la quantification ont mis en évidence : la *spectacularisation des métriques*. Dès qu’un score existe, il tend à acquérir une aura particulière : il devient la “*mesure objective*” du risque, du mérite, de la pertinence, de la vulnérabilité. Dans cette logique, la question “*que vaut ce score ?*” écrase toutes les autres : on ne se demande plus *pour quoi* on l’utilise, *dans quelle proportion* il commande la décision, *quelles autres formes de jugement* il marginalise.
+
+Le *visa d’affectation*, au contraire, dé-spectacularise la métrique pour *re-politiser l’usage qui en est fait*. Il n’empêche pas l’existence de scores ni leur usage ; il interdit simplement qu’un score devienne, par glissement silencieux, la clé de voûte d’une décision substantielle sans que cette assignation ait été aménagée, discutée, limitée.
+
+Articulé au droit au différé contradictoire et au journal de justification, ce troisième geste archicratique transforme la manière dont Système F est inséré dans la régulation :
+
+- le *droit au différé protège la personne au moment où la décision tombe* ;
+
+- le *journal de justification conserve la mémoire des choix de conception et de déploiement* ;
+
+- le visa d’affectation place, sur le trajet du score vers la décision, une scène obligatoire où l’on doit répondre d’une question simple et redoutable : *qu’avons-nous décidé de faire faire à ce nombre ?*
+
+## VII.4. Coupe-circuit citoyen et suspension d’un système IA
+
+Avec le droit au différé, le journal de justification et le visa d’affectation, nous avons desserré les mailles de la décision ordinaire : ralentir, expliquer, encadrer. Reste pourtant une question que les scandales récents rendent brutalement concrète : que se passe-t-il lorsqu’un système comme Système F produit déjà, à grande échelle, des dégâts manifestes ? Lorsque les familles endettées, les patients mal orientés, les allocataires injustement ciblés sont déjà là, identifiables, et que le dispositif continue néanmoins de tourner ?
+
+C’est là qu’intervient le quatrième geste : le coupe-circuit citoyen. Il ne s’agit plus de mieux préparer l’usage d’un score, ni de garantir un recours individuel après coup, mais de reconnaître un droit collectif à suspendre provisoirement un système IA lorsque des indices sérieux montrent qu’il entame gravement la co-viabilité sociale ou les droits fondamentaux.
+
+### VII.4.1. Des scandales qui auraient pu être arrêtés plus tôt
+
+L’affaire SyRI aux Pays-Bas fournit un premier repère. Le système de profilage de fraude sociale, autorisé par la loi et déployé dans des quartiers pauvres, croisait de multiples bases de données pour produire des “indications de risque”. En février 2020, le tribunal de district de La Haye a jugé que le cadre légal de SyRI violait l’article 8 de la Convention européenne des droits de l’homme : manque de transparence, disproportion, atteinte excessive à la vie privée. Le tribunal a ordonné l’arrêt du système, mettant fin à des années d’utilisation expérimentale sur des populations déjà vulnérables.
+
+Dans le scandale des allocations pour la garde d’enfants, c’est un autre outil de classification du risque qui, pendant des années, a servi à accuser à tort des dizaines de milliers de parents de fraude, avec des conséquences dramatiques : dettes, expulsions, placements d’enfants, stigmatisation de familles majoritairement issues de l’immigration. Les analyses d’Amnesty International montrent que la nationalité ou la double nationalité ont été utilisées comme facteurs de risque, produisant une discrimination systémique que ni les garde-fous internes ni les procédures ordinaires de recours n’ont suffi à enrayer.
+
+Dans ces deux affaires, ce sont des coalitions associatives, des syndicats, des ONG de défense des droits qui ont joué le rôle de déclencheurs : mobilisations, enquêtes, recours collectifs, jusqu’au point où un juge ou un gouvernement reconnaît que “quelque chose ne va pas” et qu’il faut arrêter. Mais ce rôle est aujourd’hui exercé à la marge du dispositif, via des instruments de contentieux général (recours en annulation, actions en responsabilité, interpellations politiques) qui demandent des années, supposent des ressources militantes considérables et n’offrent aucun mécanisme d’arrêt provisoire.
+
+À l’autre bout du spectre, certaines villes ont décidé par voie politique de bannir ou de suspendre des technologies controversées. San Francisco, par exemple, a interdit en 2019 à ses services municipaux l’usage de la reconnaissance faciale, au nom des risques pour la vie privée et des biais discriminatoires éprouvés, dans le cadre d’une ordonnance plus large de contrôle des technologies de surveillance. Ici, le “coupe-circuit” a pris la forme d’une décision politique délibérée, issue d’un travail d’ONG, de juristes, de collectifs de quartier ; mais ce geste n’est ni généralisé ni inscrit comme droit opposable dans la plupart des régimes juridiques.
+
+Dans notre cas pratique, Système F condense précisément ce type de situations : systèmes de scoring déployés pendant des années avant l’intervention d’un tribunal ; outils de tri et de profilage qui affectent l’accès aux droits sans mécanisme d’arrêt rapide ; technologies de surveillance interdites localement mais autorisées ailleurs. Le constat archicratique est simple : les dispositifs existent pour arrêter un système IA, mais ils sont lents, asymétriques, réservés à des acteurs institutionnels (juges, ministres, autorités de surveillance). Ceux qui subissent au quotidien les effets de Système F n’ont pas, comme tels, de levier institutionnalisé pour dire : “stop, on suspend, on réexamine”.
+
+### VII.4.2. Qui actionne le coupe-circuit ? Conditions de déclenchement et légitimité
+
+Le *coupe-circuit citoyen* vise à combler cette asymétrie. Il consiste à *reconnaître, dans l’architecture même de la gouvernance de Système F, un droit de tirage collectif* : la faculté, pour des groupes clairement identifiés, de saisir une instance compétente afin de demander la suspension provisoire d’un système IA ou d’un de ses modules, lorsque des atteintes graves et répétées apparaissent.
+
+Les détenteurs de ce droit ne sont pas “les citoyens” au sens vague, mais des *collectifs capables de relier les effets de Système F à des situations concrètes* : *associations de bénéficiaires de prestations sociales, syndicats de travailleurs sociaux, organisations de défense des droits fondamentaux, ordres professionnels* (médecins, avocats, magistrats), *syndicats de salariés dans des secteurs massivement équipés en IA, associations de patients, collectifs de modération*. L’exemple des mobilisations syndicales et associatives autour de l’usage de l’IA dans la fonction publique de l’État de New York, où une loi impose désormais aux agences d’évaluer régulièrement l’impact des technologies génératives sur les décisions publiques et sur les conditions de travail, montre que ces acteurs sont déjà au cœur des mécanismes émergents de surveillance et d’alerte.
+
+Pour éviter la dérive vers un “référendum technologique permanent”, l’activation du coupe-circuit doit être encadrée par des *conditions de recevabilité* : *nombre minimal de plaignants lorsque des individus s’agrègent, mandat d’organisations reconnues, démonstration prima facie d’un dommage grave ou d’une atteinte sérieuse aux droits, fourniture d’éléments concrets* (séries de cas, analyses statistiques, témoignages convergents). L’objectif n’est ni de judiciariser chaque dysfonctionnement, ni de figer l’innovation, mais de donner une forme institutionnelle à ce qui, aujourd’hui, ne peut se dire que sous forme de scandale : “ce système ruine des vies, il faut l’arrêter”.
+
+### VII.4.3. Effets de la demande : suspension provisoire, enquête contradictoire, issue scénique
+
+Sur le plan procédural, le *coupe-circuit citoyen* ne se confond pas avec une action en responsabilité classique. Il ne vise pas d’abord l’indemnisation des victimes, même si celle-ci reste nécessaire ; il vise la *suspension rapide de l’usage d’un module* de Système F dans un contexte donné, *le temps d’une enquête contradictoire*.
+
+Concrètement, l’architecture que nous proposons s’articule à ce qui existe déjà dans les régimes de régulation de l’IA. L’AI Act prévoit que les autorités de surveillance du marché peuvent restreindre ou interdire la mise sur le marché ou l’utilisation d’un système d’IA à haut risque lorsque celui-ci présente un risque grave pour la santé, la sécurité ou les droits fondamentaux, et impose des obligations de surveillance post-déploiement aux “déployeurs” comme aux fournisseurs. Des évaluations d’impact sur les droits fondamentaux sont requises avant le premier usage de certains systèmes publics à haut risque, avec obligation de mise à jour si le système évolue.
+
+Le *coupe-circuit citoyen*, dans ce cadre, jouerait le *rôle de déclencheur formalisé d’une telle mesure de restriction ou de suspension*, lorsque les autorités ne se saisissent pas d’elles-mêmes :
+
+- la *réception d’une demande jugée recevable obligerait l’autorité compétente* (ou l’instance archicratique instituée au niveau national ou sectoriel) à décider, dans un délai bref, si elle prononce une suspension provisoire du système ou du module visé dans le contexte concerné ;
+
+- cette suspension, limitée dans le temps, serait assortie de l’*ouverture d’une enquête contradictoire* : audits indépendants, auditions des concepteurs, des déployeurs, des agents utilisateurs, des personnes affectées, analyses externes des données et des effets ;
+
+- à l’issue de cette enquête, plusieurs issues seraient possibles : remise en service sous conditions nouvelles (révision de la fonction de coût, restriction du champ d’usage, nouvelles garanties procédurales), retrait du système dans le contexte considéré, ou interdiction plus large si le risque est jugé systémique.
+
+Dans les faits, des décisions de ce type ont déjà été prises, mais sans dispositif archicratique explicite : le tribunal de La Haye a stoppé SyRI, le gouvernement néerlandais a fini par abandonner l’algorithme de profilage des familles bénéficiaires, des villes ont banni la reconnaissance faciale. Ce que le *coupe-circuit citoyen* propose, c’est de *transformer ces moments exceptionnels en procédure ordinaire, accessible, opposable, dotée de délais et de garanties*.
+
+### VII.4.4. Une archicration d’urgence : de la plainte dispersée à la scène instituée
+
+Du point de vue archicratique, le coupe-circuit citoyen n’est pas un simple mécanisme de précaution ; c’est une *forme particulière d’archicration d’urgence*. Là où le droit au différé protège l’individu face à une décision singulière, le coupe-circuit crée une scène pour les situations où la répétition des décisions injustes devient elle-même un fait social.
+
+Dans Système F, les plaintes se présentent souvent de manière dispersée : un allocataire ici, un justiciable là, un patient ailleurs, un candidat qui soupçonne un tri discriminatoire, un utilisateur de plateforme dont le contenu a disparu sans explication. Chacun peut, dans le meilleur des cas, exercer des recours individuels ou saisir une autorité. Mais tant que ces plaintes ne sont pas agrégées dans une scène commune, la cratialité IA conserve l’avantage : elle continue de produire ses effets à grande échelle, pendant que les victimes se débattent dossier par dossier.
+
+Le *coupe-circuit*, tel que nous le concevons, opère un double mouvement. Il *agrège des situations* – trente dossiers de suspension de prestations qui présentent les mêmes motifs, une série de décisions pénales manifestement corrélées à un score, des centaines de contenus militants effacés dans un contexte politique tendu – et il *convertit cette agrégation en droit scénique* : le droit de contraindre les autorités à organiser une comparution publique du système lui-même, non seulement des décisions prises en aval.
+
+Ce geste répond à la *dérive autarchicratique* identifiée plus haut. Dans un méta-régime où les modèles, les indicateurs et les tableaux de bord tendent à devenir leurs propres critères de validité, où les obligations de “monitoring” restent confinées dans des rapports techniques, le coupe-circuit citoyen réintroduit une *hétérotopie de contrôle* : un *lieu où ceux qui subissent ont la capacité de demander, et d’obtenir, que l’on débranche provisoirement la machine pour en examiner les fondements, les chaînes et les effets*.
+
+Articulé aux autres gestes – droit au différé, journal de justification, visa d’affectation, tribunaux de l’algorithme, budgets scéniques –, le coupe-circuit citoyen fait apparaître, au cœur même de la gouvernance de Système F, un principe simple et radical : *aucun système d’IA ne doit pouvoir continuer à gouverner des trajectoires humaines lorsque des preuves raisonnables montrent qu’il les détruit*. Il doit toujours exister, quelque part dans l’architecture, un bouton d’arrêt que les intéressés ne se contentent pas d’implorer, mais qu’ils ont le droit reconnu de demander à actionner.
+
+## VII.5. Tribunal de l’algorithme
+
+Dans la séquence des gestes archicratiques, le “tribunal de l’algorithme” est sans doute celui qui condense le plus nettement notre intuition centrale : sortir les systèmes d’IA de la pure gouvernementalité technique pour les faire comparaître devant une instance instituée, contradictoire, dotée d’une mémoire publique. Autrement dit : transformer un objet technico-organisationnel en partie prenante d’un contentieux politique, juridique et social explicite.
+
+### VII.5.1. De l’ombre des comités à une instance d’archicration instituée
+
+Nous disposons déjà, dans le paysage contemporain, de plusieurs esquisses d’instances quasi-judiciaires autour des dispositifs numériques :
+
+- le *Meta Oversight Board*, conçu comme organe indépendant de réexamen de décisions de modération de contenus, est couramment décrit comme un “*appareil para-judiciaire*” *de justice privée des plateformes* ;
+
+- les *mécanismes de règlement extrajudiciaire des litiges* prévus par le Digital Services Act pour certains types de contentieux de plateforme ;
+
+- diverses formes de médiateurs numériques, de commissions de médiation ou de panels d’experts.
+
+Ces dispositifs ont une vertu : ils prouvent qu’il est possible d’instituer des scènes de jugement autour de décisions techniques, en produisant des décisions motivées, publiées, parfois rétroactives. Mais ils illustrent aussi leurs *limites* : *périmètre très restreint* (contenus, non architectures), *dépendance structurelle vis-à-vis des acteurs privés, absence de pouvoir contraignant sur les modèles eux-mêmes*.
+
+Notre geste ne consiste pas à “copier” ces dispositifs, mais à en tirer une leçon archicratique : tant que l’IA reste traitée comme un simple facteur de contexte dans les litiges (un élément du dossier parmi d’autres), la scène judiciaire n’accède pas à sa dimension de régime régulateur. Le *tribunal de l’algorithme* vise au contraire à faire de l’IA – de Système F en particulier – un *objet principal de contentieux*, et non un décor.
+
+### VII.5.2. Mandat : juger des dispositifs, pas seulement des cas individuels
+
+Un *tribunal de l’algorithme* ne serait pas une juridiction parallèle qui se substituerait aux tribunaux ordinaires. Il serait une *instance spécialisée, dotée d’un mandat double* :
+
+1.  *Contentieux systémique* : *instruire des affaires qui portent sur le fonctionnement d’ensemble d’un système IA déployé dans un secteur donné* (protection sociale, santé, justice, plateformes, recrutement), *dès lors qu’il existe des indices sérieux d’atteintes répétées à des droits fondamentaux* (discrimination, opacité illégale, violation du droit au recours effectif, etc.). Sur ce point, l’expérience de la régulation européenne par “systèmes à haut risque” sous l’AI Act – où l’on sanctionne la mise sur le marché et l’usage d’un système non conforme – fournit un précédent partiel, mais sans scène publique contradictoire centrée sur ce système particulier.
+
+2.  *Contentieux de principes* : *examiner, à partir de cas emblématiques, la compatibilité des architectures de scoring, de profilage ou de recommandation avec une série de principes substantiels* (non-discrimination, proportionnalité des atteintes, respect de la présomption d’innocence, etc.), *en s’autorisant à formuler des injonctions structurelles* : modification de la fonction de coût, interdiction de certains proxies, obligation de créer des mécanismes de droit au différé, etc.
+
+Dans l’esprit archicratique, il s’agit de mettre en procès la configuration arcalité / cratialité / archicration de Système F chaque fois qu’elle produit, en série, des *effets de non co-viabilité*.
+
+### VII.5.3. Composition : pluralité de prises et indépendance exigeante
+
+Une telle instance ne gagne en légitimité archicratique que si sa composition rompt avec le face-à-face technicien / juriste. Les travaux récents sur les “technology courts” et les organes quasi-judiciaires privés montrent que la légitimité d’instances de ce type dépend fortement de leur indépendance vis-à-vis des entreprises et de la diversité des profils qui y siègent.
+
+Transposée à notre cas, cette exigence implique au minimum :
+
+- Un *pôle juridico-institutionnel* : magistrats, avocats, spécialistes du contentieux anti-discrimination, de la protection sociale, du droit de la santé ou du travail, *capables de traduire les atteintes produites par Système F dans les langages du droit existant* (procédural et substantiel).
+
+- Un *pôle technico-épistémique* : experts en apprentissage automatique, en science des données, mais aussi en métrologie et en évaluation des politiques publiques, pour *décortiquer la cratialité* IA : jeux de données, proxies, métriques, chaînes de traitement.
+
+- Un *pôle socio-politique et expérientiel* : représentants des groupes les plus exposés aux systèmes étudiés (allocataires, patients, minorités racialisées, travailleurs précaires, associations de défense), dont la présence n’est pas cantonnée à une consultation préliminaire, mais intégrée structurellement à la délibération.
+
+Cette composition ne garantit pas mécaniquement la justice, mais elle rend possible une *archicration réelle* : *la confrontation, dans une même scène, de la description technique du dispositif, des exigences juridiques de protection, et de l’expérience vécue des personnes affectées*.
+
+L’*indépendance*, elle, suppose : des *mandats suffisamment longs*, une *nomination par plusieurs autorités* (par exemple Parlement, autorités de régulation, organisations représentatives), un *financement pluriel et sécurisé* (éventuellement abondé par une fraction des amendes administratives prévues par l’AI Act, à la manière de certains fonds d’accès au droit). Sans cela, le tribunal de l’algorithme se réduirait à un comité d’entreprise sous un autre nom.
+
+### VII.5.4. Procédure : organiser le différé, le contradictoire, la publicité
+
+Sur le plan procédural, l’enjeu est de sortir d’une logique purement experte pour instituer une scène lisible. Plusieurs éléments sont décisifs.
+
+D’abord, la *saisine* : *l’instance doit pouvoir être saisie par des individus, des collectifs, des associations, mais aussi par des autorités publiques* (défenseur des droits, régulateurs sectoriels, autorités de protection des données) lorsqu’ils constatent des dommages répétés liés à un même système. Les expériences canadiennes de Directive sur la prise de décision automatisée, qui imposent des évaluations d’impact et des obligations de transparence proportionnées au niveau de risque, fournissent un socle intéressant, mais sans offrir à ce stade une instance scénique de jugement. Le tribunal de l’algorithme en serait le prolongement contentieux.
+
+Ensuite, l’*accès aux éléments techniques* : contrairement à de nombreux contentieux actuels où l’algorithme reste une boîte noire même pour le juge, l’instance doit *disposer d’un droit d’accès étendu aux documents techniques pertinents* : documentation sur les données, description de l’architecture, choix de proxies, logs d’exécution, rapports d’audit, communications internes pertinentes. *Le régime de secret industriel ne peut pas y servir de paravent général*, sauf à reconduire l’*oblitération archicratique* sous un langage juridique nouveau. Sur ce point, les débats autour de la possibilité d’une découverte électronique algorithmique ou de règles procédurales spécifiques aux plateformes montrent que le droit est en train de s’ouvrir, mais de façon encore très fragmentaire.
+
+Troisième élément : le *contradictoire élargi*. Le tribunal n’instruit pas seulement une opposition entre “demandeur” et “défendeur”, mais une *controverse sur la conception même du dispositif*. Une suspension provisoire d’un système ou d’un module de Système F – déclenchée par le geste de “*coupe-circuit*” décrit précédemment – pourrait *donner lieu à une audience regroupant concepteurs, décideurs politiques, usagers, experts, pour débattre publiquement des options de remédiation* : changer de proxy, ajuster la fonction de coût, renoncer à certains usages.
+
+Enfin, la *publicité* : les *décisions du tribunal de l’algorithme doivent être motivées, rendues publiques, indexées, afin de constituer, au fil du temps, une jurisprudence de l’IA*. De la même façon que le *Meta Oversight Board* publie des décisions détaillées et des recommandations sur les politiques de contenu, mais avec un *mandat élargi aux architectures*, le tribunal constituerait un répertoire de cas qui reconfigure progressivement ce qu’il est socialement acceptable de déléguer à Système F.
+
+### VII.5.5. Effets : de la justice réparatrice à la transformation des régimes
+
+Un *tribunal de l’algorithme*, pris au sérieux, ne serait ni une panacée, ni un simple label de “bonne gouvernance”. Dans notre perspective archicratique, son intérêt tient à trois types d’effets.
+
+D’abord, un *effet réparateur,* en offrant aux personnes affectées un lieu où formuler une plainte qui ne soit pas uniquement anticipée en langage actuariel. Une allocataire injustement stigmatisée comme fraudeuse, un patient systématiquement déclassé, une personne noircie par un score pénal, un candidat invisibilisé par un tri automatisé, un utilisateur dont les contenus sont constamment dépréciés, trouvent là un lieu où demander non seulement réparation, mais réforme du dispositif qui produit ces injustices.
+
+Ensuite, un *effet structurant* : *chaque contentieux emblématique conduit à des obligations de restructuration* de Système F – interdiction de certaines variables, modification des fonctions de coût, obligation de co-construire des scènes de justification, de renforcer les journaux de justification, d’ouvrir de nouveaux droits au différé. Ces décisions s’articulent avec les *exigences réglementaires plus générales* (AI Act, directives nationales, codes de conduite), mais en les traduisant dans une *grammaire concrète d’architectures et de procédures*.
+
+Enfin, un *effet symbolique et politique* : l’existence même de l’instance rappelle que les grands systèmes d’IA ne sont pas des fatalités technologiques mais des objets discutables. Elle contribue à déplacer le centre de gravité de la “gouvernance de l’IA” – aujourd’hui largement concentrée dans des arènes technico-administratives – vers des *scènes où les controverses sur les fondements et les effets deviennent visibles, argumentables, appropriables par d’autres que les seuls spécialistes*.
+
+On pourrait dire, en condensant : *le tribunal de l’algorithme est la forme archicratique de ce qui n’est, pour l’instant, qu’une exigence abstraite de “redevabilité”* (*accountability*). Là où les audits internes, les rapports de conformité, les codes de bonnes pratiques se déploient dans des *hypertopies fermées*, le tribunal réinstalle au centre un principe simple : *aucune régulation puissante ne doit rester sans scène où elle puisse être mise en cause, contrée, transformée*.
+
+Ce geste ne remplace pas les autres – droit au différé, journaux de justification, visas d’affectation, coupe-circuits, budgets scéniques – ; il les rassemble. Le *tribunal de l’algorithme* leur donne un *débouché commun* : *un lieu où les tensions accumulées dans les chaînes de décision appuyées par IA peuvent enfin être prises à bras-le-corps, dans une archicration instituée, durable, publiquement assumée*.
+
+## VII.6. Assemblées d’affectation et budget scénique IA
+
+*Avec le droit au différé, le journal de justification, le visa d’affectation, le coupe-circuit citoyen et le tribunal de l’algorithme, nous avons surtout travaillé la face “contrôle” de Système F : comment ralentir, contester, suspendre, juger*. Reste une autre question, plus discrète mais décisive : *où, dans la vie ordinaire des institutions, se décide ce que l’on va demander à l’IA de faire ?* *Qui fixe les usages jugés légitimes, les tâches à déléguer, les places qu’on refuse de céder ?*
+
+C’est à cette question que répond le geste des *assemblées d’affectation*, indissociable d’un *budget scénique IA* : tant que les décisions d’usage restent prises dans des cénacles techniques ou managériaux, la meilleure architecture de contrôle sera toujours en retard d’une bataille.
+
+### VII.6.1. Faire émerger les scènes amont : sortir l’affectation du huis clos managérial
+
+Dans le fonctionnement actuel de Système F, les grandes décisions d’affectation – “nous allons confier à l’IA le tri de ces dossiers”, “nous allons l’intégrer à cette étape de la procédure”, “nous allons laisser le modèle pré-prioriser les patients”, etc. – se prennent rarement sur une scène explicite.
+
+Elles sont le plus souvent le produit de trajectoires très ordinaires : un appel à projets ministériel, une offre de prestataire, un argumentaire d’“innovation”, quelques ateliers de co-design avec des agents “pilotes”, une validation en comité de direction. Au bout du processus, l’IA est là, dans l’écran ; les agents utilisateurs ne l’ont pas vraiment décidée, les publics concernés *a fortiori* encore moins.
+
+*Les assemblées d’affectation ont pour fonction de repolitiser ce moment amont* : avant de décider que Système F interviendra dans la chaîne de décision sociale, sanitaire, pénale, éducative, il faut l’avoir débattu, non pas à l’échelle abstraite de “l’IA en général”, mais au niveau très concret des tâches et des enjeux :
+
+- *Dans cette caisse sociale, veut-on vraiment que le classement des dossiers par “risque” soit automatisé ?*
+
+- *Dans cet hôpital, quelles décisions peuvent être assistées par un score sans porter atteinte à la relation clinique ?*
+
+- *Dans ce tribunal, jusqu’où accepte-t-on qu’un indice de récidive infléchisse les pratiques de peine ?*
+
+- *Dans cette entreprise, quelles étapes du recrutement doivent impérativement rester hors de portée d’un modèle ?*
+
+Le geste archicratique est simple : on ne délègue pas des segments entiers de souveraineté quotidienne à Système F sans qu’il y ait eu, quelque part, une scène où cette délégation a été assumée, discutée, encadrée.
+
+### VII.6.2. Assemblées d’affectation : composition et temporalité
+
+Une assemblée d’affectation n’est pas un “*focus group*” *marketing* ni un énième comité d’éthique consultatif. C’est un organe régulier de mise en scène des choix d’usage de l’IA dans un secteur donné.
+
+Dans un service de protection sociale, par exemple, elle réunirait périodiquement :
+
+- des *agents de guichet et de back-office*, qui savent comment les dossiers “vivent” réellement ;
+
+- des *responsables de service et des directions*, qui portent les contraintes budgétaires et organisationnelles ;
+
+- des *représentants des allocataires et des associations de soutien* (syndicats de chômeurs, collectifs de lutte contre la pauvreté, défenseurs des droits) ;
+
+- des *délégués des services numériques, internes ou prestataires*, capables d’exposer les possibilités et les limites techniques ;
+
+- éventuellement un *représentant de l’autorité de régulation compétente*.
+
+En santé, on recomposerait le cercle : équipes médicales et paramédicales, direction d’établissement, représentants des patients et de leurs familles, services informatiques, éventuellement assurance maladie. En justice, magistrats, avocats, greffiers, associations de justiciables, autorités de contrôle ; sur les plateformes, modérateurs, représentants d’usagers, associations de journalistes et de défense des libertés, équipes produit.
+
+Le mandat de l’assemblée n’est pas de réécrire le code, mais de décider des tâches que l’on confie ou non à Système F :
+
+- *quelles fonctions sont éligibles à l’automatisation partielle* (pré-tri, assistance à la rédaction, alerte) ;
+
+- *quelles fonctions doivent rester humaines* (décision finale, appréciation contextuelle, accueil, audition, annonce de décisions sensibles) ;
+
+- *quelles combinaisons sont acceptables* (par exemple : pré-classement algorithmique + revue systématique humaine pour les cas à fort enjeu) ;
+
+- *quelles affectations sont d’emblée exclues* (par exemple : suspension automatique de droits sans intervention humaine, tri de patients pour des soins vitaux selon une probabilité de “rentabilité”, etc.).
+
+Ces décisions ne sont pas flottantes : elles deviennent des *engagements opposables vecteurs de promesses*. Lorsqu’un module de Système F est ensuite introduit dans un flux de travail, son déploiement doit être conforme aux affectations décidées par l’assemblée – sous peine de contentieux et de révision.
+
+Ces assemblées doivent se réunir :
+
+- *en amont de tout projet important de déploiement ou d’extension* de Système F ;
+
+- *à intervalles réguliers* (par exemple trimestriels ou semestriels), pour *réexaminer les usages effectifs à partir de rapports d’impact, de plaintes, de données agrégées* ;
+
+- *de manière exceptionnelle, lorsque des signaux d’alerte* (recours massifs, activation d’un coupe-circuit, procédures devant un tribunal de l’algorithme) *révèlent un problème structurel*.
+
+Autrement dit, elles sont l’équivalent, dans la gouvernance de l’IA, de ce que sont les conférences de service, les conseils d’administration ou les comités d’entreprise pour d’autres dimensions de l’activité : des lieux où l’on décide à quelles conditions on accepte qu’un dispositif reconfigure le travail et les droits.
+
+### VII.6.3. Le budget scénique IA : financer le temps, la traduction, la contradiction
+
+Reste une question triviale et décisive : *qui paie pour tout cela ?*
+
+Car les assemblées d’affectation, les journaux de justification, les visas, les tribunaux de l’algorithme, les droits au différé, tout cela a un *coût* : *temps de réunion, d’enquête, d’audit ; travail de traduction entre les langages techniques, juridiques et ordinaires ; rémunération des intervenants extérieurs et des expertises critiques ; compensation du temps consacré par les représentants d’usagers ou de patients*.
+
+Si ces coûts sont laissés à la marge, ils seront mécaniquement rognés : la scène archicratique sera la première variable d’ajustement lorsque les budgets se tendront. Le *budget scénique* IA vise précisément à *empêcher cette évaporation silencieuse en consacrant une ligne budgétaire dédiée à la tenue des scènes archicratiques* autour de Système F.
+
+Très concrètement, cela signifie par exemple :
+
+- qu’une proportion fixe des budgets alloués aux projets d’IA publics (développement, intégration, licences, maintenance) est réservée, *ex ante*, aux dispositifs de scène : assemblées d’affectation, ateliers de restitution, traductions, expertises indépendantes, appuis juridiques ;
+
+- que les contrats passés avec les fournisseurs et intégrateurs de Système F incluent l’obligation de financer une partie de cette scène (par exemple, comme condition de référencement dans la commande publique) ;
+
+- que des fonds spécifiques – éventuellement alimentés par les amendes administratives liées aux manquements à la régulation de l’IA – peuvent abonder ce budget scénique pour garantir la participation de publics qui, autrement, n’auraient ni le temps ni les moyens de siéger (associations de terrain, syndicats de petites structures, collectifs de personnes concernées).
+
+Le *budget scénique* IA est une *composante constitutive du coût de la régulation*. Tant qu’on ne compte que les serveurs, les heures de développement et les licences logicielles, la scène sera structurellement sous-dotée. L’*archicratie oblige à requalifier la dépense* : *faire apparaître Système F, le discuter, le contrôler, fait partie de ce qu’il en coûte de l’utiliser*.
+
+### VII.6.4. Assemblées + budget : ramener la décision sur la scène, en amont
+
+Articulées aux gestes précédents, les assemblées d’affectation et le budget scénique IA produisent un effet de structure sur notre cas pratique.
+
+D’abord, elles déplacent la frontière entre “technique” et “politique” : décider que Système F interviendra uniquement comme aide à la décision dans certains cas, qu’il sera interdit pour d’autres, que certains usages seront soumis à conditions strictes, n’est plus une affaire de “feuille de route numérique”, mais un *objet de délibération collective récurrente*.
+
+Ensuite, elles stabilisent un espace où les compromis acceptables peuvent être explicités : à quel prix de faux positifs ou faux négatifs une communauté professionnelle accepte-t-elle de se doter d’un module de tri ? Quelles tâches gagne-t-on vraiment à transférer à Système F, et lesquelles doit-on maintenir dans un face-à-face humain, même au prix d’une moindre efficacité apparente ? Sans assemblées d’affectation, ces arbitrages restent diffus, dissous dans des grilles de priorisation et des études d’impact.
+
+Enfin, le *budget scénique* IA garantit que ces scènes ne sont pas une faveur, mais un *droit inscrit dans l’architecture financière même du système*. Il devient plus coûteux, politiquement et comptablement, de déployer Système F sans scène adéquate que de financer cette scène.
+
+Là où la trajectoire spontanée de Système F le pousse vers une *autarchicratie discrète* – *indicateurs qui se co-certifient, décisions d’usage prises dans des hybrides techno-managériaux, utilisateurs mis devant le fait accompli* –, le *couple assemblées d’affectation / budget scénique réintroduit, en amont, ce que tout le cas pratique cherche à réhabiliter : le droit de décider ensemble des formes de régulation que l’on veut bien se laisser imposer par les machines*.
+
+## VII.7. Principe de révision archicrative et cartographie des scènes manquantes
+
+Avec les gestes précédents, nous avons donné à Système F des *prises scéniques nouvelles* : *droit au différé, journaux de justification, visas d’affectation, coupe-circuits, tribunaux, assemblées, budgets scéniques*. Mais un dispositif régulateur n’est jamais figé : il se reparamètre, se re-déploie, change de données, migre vers d’autres usages, se voit couplé à de nouveaux indicateurs. Sans une *obligation explicite de révision archicrative*, tout ce que nous avons institué risque d’être contourné au fil des “mises à jour”, des “optimisations”, des “évolutions” de plateformes.
+
+Le *principe de révision archicrative* vise précisément cela : faire de la remise en scène périodique de Système F une exigence de droit, non une faveur occasionnelle. Et, pour que cette révision ne se contente pas de regarder ce qui existe déjà, il faut l’outiller par une cartographie systématique des scènes manquantes le long de la chaîne IA.
+
+### VII.7.1. La *révision archicrative*, ou l’obligation de rejouer la scène
+
+Dans l’univers des systèmes techniques, l’idée de révision n’a rien de nouveau : mises à jour logicielles, audits de sécurité, re-certifications, contrôles de conformité. Mais ces révisions se déroulent, le plus souvent, hors scène : entre ingénieurs, responsables de conformité, contre-experts mandatés, sans que le dispositif soit ramené, à intervalles réguliers, devant ceux qu’il affecte.
+
+La *révision archicrative* se distingue radicalement de ce modèle. Elle repose sur trois principes.
+
+**Premier principe : *la périodicité comme droit, non comme opportunité***
+
+Il ne s’agit pas de prévoir vaguement que “le système sera réévalué en cas de problème”, mais d’inscrire une périodicité minimale dans les textes qui encadrent l’usage de Système F. Par exemple : tout système IA classé à haut enjeu social (protection sociale, santé, justice, éducation, travail, logement) doit *faire l’objet, toutes les X années, d’une révision publique, quel que soit son état apparent de fonctionnement*. Cette périodicité peut être modulée selon le niveau de risque, mais elle ne peut pas être laissée à la discrétion de l’opérateur.
+
+**Deuxième principe : *la révision comme scène d’épreuve, et non comme simple “checklist”***
+
+Une *révision archicrative* n’est pas un contrôle de conformité supplémentaire où l’on coche des cases (“évaluation d’impact réalisé”, “biais évalués”, “documentation à jour”). C’est un moment où Système F est explicitement convoqué devant une instance qui ressemble davantage à une *assemblée* qu’à un bureau d’homologation :
+
+- on y *présente ce que le système fait réellement, là où il est déployé, avec des cas, des chiffres, des témoignages* ;
+
+- on y *examine les journaux de justification et les visas d’affectation* : *les décisions prises en amont ont-elles été respectées, contournées, dépassées ?*
+
+- on y *écoute les agents et les personnes affectées* : *quels effets inattendus, quelles injustices, quelles tensions ont émergé ?*
+
+- on y *remet en discussion les fondements implicites* (proxies, fonctions de coût, seuils) *à la lumière de ce qui a été appris depuis le déploiement*.
+
+**Troisième principe : *la révision comme possibilité assumée de renoncement***
+
+Un dispositif archicratique n’est pas obligé de se maintenir coûte que coûte. La *révision archicrative* doit explicitement ouvrir la *possibilité de déclassement* : décider que, malgré les investissements consentis, Système F n’est pas acceptable dans tel segment de la chaîne (par exemple pour la suspension automatique de droits, pour la priorisation de patients en situation de rareté extrême, pour le calcul d’un indice pénal). Sans cette possibilité de renoncement formalisée, la révision se réduit à une optimisation interne – l’*autarchicratie* continue sa course, simplement mieux calibrée.
+
+*L’obligation juridique de révision archicrative est donc un verrou contre la fuite en avant* : elle impose de rejouer périodiquement la scène, avec les acteurs concernés, au lieu de laisser Système F poursuivre sa trajectoire sous couvert de “maintenance” et de “modernisation”.
+
+### VII.7.2. Rythmes, déclencheurs et objets de la révision
+
+Pour que ce principe ne reste pas une formule, il faut le traduire dans une cinétique et dans des objets précis.
+
+Sur le plan des rythmes, la *révision archicrative* combine deux logiques :
+
+- une *révision ordinaire, programmée, qui a lieu à échéance fixe* (par exemple tous les trois ou six mois) pour chaque module de Système F utilisé dans un domaine sensible ;
+
+- une *révision extraordinaire, déclenchée par des signaux forts* : activation d’un coupe-circuit citoyen, accumulation de recours, constat d’effets discriminatoires massifs, alertes des autorités de contrôle, révélations d’enquêtes journalistiques ou scientifiques.
+
+Cette double temporalité évite le double écueil symétrique : l’endormissement des révisions formelles d’un côté (on reconduit tous les cinq ans ce que l’on faisait déjà), la gestion au coup par coup des scandales de l’autre.
+
+Sur le plan des objets, la révision archicrative doit se déployer sur l’ensemble de la chaîne IA, et non sur les seuls résultats. Cela implique au minimum :
+
+- Les *données* : composition des jeux d’entraînement et d’évaluation, trajectoires des données collectées depuis la précédente révision, corrections apportées (ou non) aux biais connus, décisions de conserver ou d’abandonner certaines sources.
+
+- Les *modèles* : architecture générale, modifications significatives (changement de modèle de fondation, fine-tuning sur de nouveaux corpus, ajustement majeur de la fonction de coût), performances mesurées sur différents groupes, incidence des changements sur les profils déjà identifiés comme vulnérables.
+
+- Les *usages* : extension des domaines où Système F est employé (par exemple un score conçu pour le tri interne des dossiers réutilisé pour déclencher automatiquement des contrôles), réaffectation des sorties du modèle (une recommandation devenue quasi-obligation), couplage à d’autres systèmes de décision.
+
+- Les *scènes déjà existantes* : fonctionnement du droit au différé, effectivité des voies de recours, usage réel des journaux de justification et des visas d’affectation, activation éventuelle de coupe-circuits ou de tribunaux de l’algorithme, tenue (ou non) des assemblées d’affectation.
+
+La révision archicrative ne se contente donc pas de demander : “le système est-il conforme au règlement ?” Elle pose une série de questions archicratiques : *les fondements sont-ils encore tenables ? La cratialité s’est-elle déplacée, intensifiée, hybridée ? Les archicrations prévues ont-elles vraiment joué leur rôle ?*
+
+### VII.7.3. Cartographier les scènes manquantes : du diagnostic à la programmation
+
+Toutefois, pour organiser efficacement ces révisions, il ne suffit pas de regarder là où la lumière existe déjà. Il faut aussi s’intéresser aux *zones d’ombre* : les *segments de la chaîne où aucune scène n’existe encore, où les décisions déterminantes se prennent sans jamais être mises en épreuve*. C’est l’objet de la *cartographie des scènes manquantes*.
+
+On peut la définir comme un travail en trois temps.
+
+Premier temps : dérouler finement la chaîne de Système F dans un contexte donné.  
+Il s’agit de décrire, avec une précision presque ethnographique, les étapes successives :
+
+- *formulation initiale du problème* (“nous voulons lutter contre la fraude”, “nous devons prioriser les patients à risque”, “nous voulons réduire les coûts de traitement des dossiers”) ;
+
+- *choix des données et construction des jeux d’entraînement* (quelles bases, quels filtres, quels critères d’inclusion et d’exclusion ?) ;
+
+- *définition des variables et des proxies* (ici les coûts de santé comme substitut des besoins, là la nationalité comme indicateur de risque, ailleurs le passé de recrutement comme modèle du talent) ;
+
+- *entraînement et validation du modèle* (quelles métriques optimisées, quelles notions de “performance” privilégiées, quels groupes utilisés pour tester l’équité ?) ;
+
+- *intégration dans des logiciels métier* (comment le score est-il présenté, à qui, sous quelle forme, avec quelles options d’acceptation ou de contournement ?) ;
+
+- *usage au guichet, au cabinet, à l’audience, à l’accueil* (qui voit quoi, à quel moment, avec quelle marge de manœuvre ?) ;
+
+- *voies de recours et de réexamen* (où les personnes peuvent-elles contester, avec quel délai, quelles informations, quelle chance réelle d’être entendues ?) ;
+
+- *instances de supervision et de régulation* (qui surveille le système, à partir de quels indicateurs, avec quels pouvoirs de modification ou de suspension ?).
+
+Deuxième temps : *superposer le maillage scénique*.  
+Pour chacun de ces segments, on demande : *existe-t-il une scène instituée où ce segment peut être mis en épreuve ?* Une scène où des acteurs multiples peuvent :
+
+- voir ce qui s’y joue ;
+
+- en contester les présupposés ;
+
+- exiger des modifications.
+
+Dans certains cas, la réponse sera positive : une assemblée d’affectation délibère sur les usages, un tribunal de l’algorithme peut être saisi des effets discriminatoires, des audiences publiques accompagnent les révisions. Dans d’autres, la réponse sera négative :
+
+- nulle part on ne discute publiquement du choix de proxy ;
+
+- nulle part les seuils de bascule entre “normal” et “à risque” ne sont mis en scène ;
+
+- nulle part les trajectoires de données (qui est entré, qui est sorti de l’entraînement) ne sont présentées aux personnes concernées.
+
+Ces absences ne sont pas des oublis anecdotiques : ce sont les points d’appui de l’autarchicratie. Là où aucune scène n’est prévue, les décisions de fond restent captives des seuls acteurs techniques et gestionnaires.
+
+Troisième temps : *programmer la création de scènes là où il n’y en a pas*.  
+La cartographie ne vaut que si elle débouche sur un plan de transformation. Une fois identifiées, les scènes manquantes doivent être assignées :
+
+- tel segment (choix des données, définition des proxies) relève d’une scène à construire au niveau des assemblées d’affectation, avec expertise indépendante et participation des groupes les plus exposés ;
+
+- tel autre (ajustement des métriques, modification des seuils) doit être rattaché au périmètre du tribunal de l’algorithme, qui pourra exiger leur reconfiguration ;
+
+- tel autre encore (modalités concrètes de recours, délais effectifs, formulation des lettres de décision) doit faire l’objet de scénographies de terrain : ateliers avec agents, juristes et usagers pour co-écrire des formes de communication et de notification compatibles avec les exigences archicratiques.
+
+La cartographie des scènes manquantes fonctionne ainsi comme une grille de programmation : elle dit non seulement où se trouvent les trous, mais quel type de scène doit venir les combler, avec quel mandat, quelle composition, quels liens avec les autres gestes.
+
+### VII.7.4. De la révision comme maintenance à la révision comme politique
+
+En combinant principe de révision archicrative et cartographie des scènes manquantes, nous faisons subir à Système F un déplacement décisif.
+
+Dans sa trajectoire spontanée, la révision de l’IA est traitée comme une affaire de maintenance : on met à jour le modèle, on corrige des bugs, on ajuste des paramètres, on réécrit quelques règles, on produit un rapport de conformité. La scène, lorsqu’elle existe, arrive en bout de chaîne, sous la forme de scandales ou de contentieux isolés.
+
+Dans la perspective archicratique, la révision devient une politique à part entière :
+
+- elle est périodique, instituée, attendue – pas seulement réactive ;
+
+- elle prend Système F comme objet central de l’épreuve, et non comme simple arrière-plan ;
+
+- elle s’adosse à une cartographie qui évite la myopie : on ne regarde plus seulement là où il y a déjà des procédures, mais aussi là où il n’y en a pas encore.
+
+Autrement dit, *la révision archicrative est le geste qui empêche les autres gestes de se fossiliser*. Sans elle, le droit au différé risque d’être lentement rogné, les journaux de justification transformés en formalité, les visas d’affectation contournés à coup de nouveaux cas d’usage, les tribunaux de l’algorithme cantonnés à quelques affaires exemplaires, les assemblées d’affectation reléguées au rôle de chambres d’enregistrement.
+
+Avec elle, Système F sait – ou plutôt : ceux qui le conçoivent, le déploient et le subissent savent – qu’il sera périodiquement rappelé sur scène, non seulement pour répondre de ses écarts, mais pour rediscuter les raisons mêmes pour lesquelles il a été introduit.
+
+C’est dans cette tension entre continuité des dispositifs et obligation de se ré-ouvrir à la scène que se joue, peut-être, la part la plus décisive de toute politique archicratique de l’IA : ne jamais laisser se refermer, dans le confort apparent de la régulation automatisée, la possibilité pour une société de redire ce qu’elle accepte – ou refuse – de déléguer à ses machines.

src/content/cas-ia/conclusion.mdx

@@ -0,0 +1,105 @@
+---
+title: "Conclusion"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 90
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Conclusion.docx"
+---
+# Conclusion : Ce que l’audit archicratique d’un système IA nous apprend
+
+On peut maintenant refermer le dossier de Système F, mais il serait trompeur de parler de “fin”. Ce cas pratique n’a jamais été conçu comme une étude de cas au sens faible – un exemple illustratif venu mettre un peu de chair sur une théorie déjà bouclée. Il a été traité comme un *laboratoire* : un lieu où le paradigme archicratique est mis à l’épreuve d’un dispositif particulièrement condensé de notre présent, un lieu où il est sommé de tenir ses promesses ou de montrer ses limites. La conclusion qui s’impose n’est donc pas un résumé, mais une mise en forme : *que nous a appris, en retour, l’exploration archicratique d’un grand système d’IA de fondation intégré à la régulation sociale ? Qu’a-t-elle révélé sur la nature des régimes qui nous gouvernent déjà, et sur les conditions de possibilité d’un réarmement archicratique crédible ?*
+
+D’un point de vue purement descriptif, la première leçon est presque brutale : Système F n’est pas un objet futuriste, mais la forme intensifiée de logiques déjà largement à l’œuvre. En le construisant comme un système composite – agrégat stylisé de dispositifs de scoring social, d’outils de gestion des risques en santé, de modules de tri de candidatures, de systèmes de recommandation et de modération de contenus, de services d’IA “as a Service” intégrés par API dans des guichets et des logiciels métier –, nous avons pris soin de ne rien lui attribuer qui ne soit déjà attesté, sous une forme ou une autre, dans des affaires documentées : scandale des allocations néerlandaises, algorithmes de risque pénal, gestion automatisée des patients à “haut risque”, outils de recrutement biaisés, plateformes dont la modération repose massivement sur des chaînes automatisées.
+
+Cette précaution n’est pas seulement méthodologique. Elle a une portée archicratique directe : ce qui fait problème dans Système F n’est pas l’IA en tant que telle, ni une supposée “intelligence” mystérieuse, mais la manière dont un ensemble de techniques statistiques et computationnelles vient s’insérer dans des chaînes de décision déjà existantes, et y redéployer de vieux régimes de soupçon, de hiérarchisation, de sélection. Le cas pratique a montré, pas à pas, que l’“innovation” ici consiste moins à inventer de nouveaux critères de jugement qu’à automatiser et disperser des critères anciens – ceux de la lutte contre la fraude, de la gestion des risques, de la recherche de “talent”, de la surveillance des comportements – en les encapsulant dans des dispositifs qui ne comparaissent plus.
+
+C’est précisément ce geste d’encapsulation que l’épreuve de détectabilité a mis en lumière. Sous le vocabulaire rassurant de l’“IA responsable”, de l’“objectivité” et de l’“efficacité”, nous avons distingué trois couches nettement différenciées.
+
+D’abord, l’*arcalité déclarée* : les justifications explicites, les objectifs affichés, les valeurs proclamées. Lutte contre la fraude pour “protéger l’État social”, objectivation actuarielle du risque pénal pour “harmoniser” les décisions, rationalisation de la gestion des soins pour “cibler les patients les plus vulnérables”, mécanisation de la recherche de talents au nom de l’“efficacité” et de la “méritocratie”, sécurisation des espaces numériques contre les contenus illégaux ou toxiques ; à cela s’ajoutent les grandes chartes d’“IA digne de confiance” qui mobilisent droits fondamentaux, non-discrimination, transparence, responsabilité. Cette couche n’est pas pure imposture : elle condense des préoccupations réelles, des valeurs substantiellement importantes, des promesses auxquelles beaucoup tiennent sincèrement.
+
+Ensuite, l’*arcalité implicite* : celle qui se niche dans les fonctions de coût, les proxies, la composition des jeux de données, les seuils de décision. C’est ici que se jouent les bascules lourdes : choix des coûts de santé comme approximant des besoins de soins, avec des effets racialisés massifs ; utilisation de la nationalité ou de la double nationalité comme variable de risque dans la détection de fraude ; apprentissage à partir de passés de recrutement structurellement masculins ; arbitrages entre faux positifs et faux négatifs distribués différemment selon les groupes. Au sens archicratique, chacun de ces choix est un axiome silencieux : une définition pratique de ce qui est grave ou tolérable, injuste mais accepté, suspect ou présumé innocent. L’épreuve de détectabilité a ici joué son rôle : montrer que ces axiomes existent bien, qu’ils produisent des effets massifs, mais qu’ils n’ont jamais été exposés comme tels.
+
+Enfin, la *cratialité* : la chaîne des instruments, des procédures, des interfaces, des règles d’usage par lesquelles Système F agit effectivement. Là encore, l’analyse détaillée a montré la *puissance de cette cratialité hypertopique* : pipelines qui transforment des trajectoires de vie en vecteurs numériques, tableaux de bord qui ordonnent les dossiers selon des scores calculés, logiciels hospitaliers qui proposent une “vue optimisée” des patients à traiter, modules de modération qui filtrent les contenus sans dire précisément sur quel fondement, procédures internes qui imposent de traiter d’abord les dossiers “rouges” ou de justifier toute divergence avec la recommandation. La plupart du temps, ce que voient les agents – case colorée, alerte, message – n’est que la pointe d’un iceberg cratial dont la structure reste inaccessible aux publics concernés.
+
+En termes archicratiques, le verdict est clair : Système F est massivement hors scène. Les fondements sont authentiques mais imperceptibles ; le pouvoir opératoire est intense mais opaque ; les archicrations existantes – comités d’éthique, audits de biais, évaluations d’impact, procédures de recours – sont en grande partie fantomatiques. Elles donnent la forme d’une scène, sans en avoir la puissance : elles examinent des indicateurs périphériques, produisent des recommandations non contraignantes, se déroulent entre experts aux intérêts parfois imbriqués, laissent les personnes affectées hors du cercle.
+
+L’épreuve topologique n’est pas venue ajouter une plainte de plus sur le “manque de transparence” : elle a montré que ce manque prend la forme d’une altération systématique de la scène elle-même. À force de suivre Système F au ras des guichets, des interfaces, des comités et des juridictions, une géographie récurrente s’est dessinée, presque obstinée : des *hypotopies locales*, des *hypertopies fermées*, des *atopies procédurales*.
+
+Du côté des *hypotopies*, on rencontre ces *scènes maigres, presque dénutries*, où l’on parle encore mais *sans véritable prise sur la régulation*. L’agent de caisse lit à haute voix une décision calculée en amont par un module IA, sans pouvoir ni en reconstituer la logique ni en infléchir le résultat ; le patient signe un formulaire de consentement standardisé dans un hôpital saturé de dispositifs numériques, sans que nul ne puisse lui montrer comment les algorithmes ont structuré son parcours de soins ; l’utilisateur de plateforme coche “je ne suis pas d’accord avec cette décision”, mais n’accède ni aux critères, ni aux scores, ni aux arbitrages qui ont conduit à la suppression ou au déréférencement de son contenu.
+
+À l’autre extrémité se trouvent les *hypertopies*, *scènes pleines mais fermées où se concentrent les décisions effectives*. *Les comités de pilotage des projets IA, les réunions de design, les arbitrages budgétaires entre directions métiers et prestataires, les séances de paramétrage des seuils et des métriques sont de véritables scènes, avec controverses, arguments, mises en tension*. Mais elles sont peuplées d’un petit nombre d’acteurs – dirigeants, ingénieurs, juristes, consultants – et la présence des allocataires, patients, justiciables, salariés, usagers y reste structurellement improbable. *La scène est alors riche en prises, mais sélective dans sa composition*.
+
+Entre ces deux pôles prolifèrent les *atopies*, scènes fantomatiques où l’on mime la mise en débat sans ouvrir réellement l’architecture des décisions. Consultations en ligne dont les conclusions n’engagent personne, boîtes à idées numériques qui nourrissent surtout des indicateurs d’“engagement”, dispositifs de “*retour* *utilisateur*” qui alimentent des tableaux de bord sans jamais déboucher sur une révision du modèle ou de ses usages : l’apparence de participation est là, mais la capacité de transformer la cratialité IA reste nulle ou marginale. La scène fonctionne comme décor, non comme opérateur.
+
+Le cas pratique montre, avec une régularité presque mécanique, que *Système F* tend à coloniser l’ensemble de ces topologies : il *étend sa présence dans les hypotopies* (interfaces de guichet, formulaires en ligne), *se renforce dans les hypertopies* (cénacles techno-managériaux où se décident modèles, proxies et seuils), *et se drape dans des atopies* (consultations, audits, panels, *feedbacks*) qui absorbent la contestation sans reconfigurer la régulation. Du point de vue archicratique, la question simple – “*où ce système peut-il être mis en procès ?*” – reçoit pour l’instant des réponses décevantes : *presque jamais au bon endroit, presque jamais au bon moment*.
+
+L’épreuve archéogénétique a donné à ce diagnostic une profondeur historique : elle a situé Système F au croisement de plusieurs méta-régimes déjà identifiés, tout en montrant en quoi ce croisement tend vers quelque chose comme un *méta-régime autarchicratique numérique*.
+
+Sur le versant *techno-logistique*, Système F apparaît comme l’héritier exacerbé de la *mégamachine* *des flux* : il *priorise* des dossiers, des contenus, des patients, des candidats, des alertes policières, *en orchestrant à grande vitesse des circuits d’information* ; il *intensifie la logique de pilotage par indicateurs et tableaux de bord*, où l’action publique et privée est évaluée à l’aune de courbes, de scores, de taux. Les *grandes infrastructures de données*, les *centres de calcul*, les *chaînes logicielles* sont la continuation, par d’autres moyens, de ces *architectures qui ont progressivement substitué à la décision située une régulation par flux*.
+
+Sur le versant *scripturo-normatif*, Système F n’abolit pas la bureaucratie, il la recode : *critères, grilles, formulaires, procédures de contrôle* sont désormais *incorporés dans des modèles qui manipulent des représentations vectorielles de ces mêmes catégories*. Le geste archicratique n’est pas d’opposer l’“ancien monde” bureaucratique au “nouveau monde” algorithmique, mais de montrer comment *l’algorithme encode et sur-détermine la bureaucratie, en naturalisant ses classifications, en les rendant plus difficiles à contester*.
+
+Sur le versant *marchand*, enfin, Système F s’inscrit pleinement dans le régime de *captation de valeur* : services d’IA vendus à des administrations, dépendance vis-à-vis de fournisseurs privés pour des fonctions critiques, monétisation de la prédiction et de la recommandation, optimisation des comportements de consommation et de participation. Le cas pratique a insisté sur le fait que rien de tout cela n’est accidentel : la structuration même de l’écosystème IA – grands acteurs du cloud, modèles de fondation, intégrateurs, consultants – fait du déploiement de Système F une affaire de marchés autant que de politiques publiques.
+
+Là où l’épreuve devient archéogénétique au sens fort, c’est lorsque ces trois dimensions – *techno-logistique, scripturo-normative, marchande* – sont articulées à la notion d’*autarchicratie* : un *méta-régime où la régulation se gouverne elle-même, où les dispositifs de mesure, de modélisation, de contrôle deviennent leurs propres critères de validité*. Système F condense cette tendance : il *repose sur des métriques* (perte, précision, métriques d’équité, indicateurs clés de performance) *qui s’auto-évalue à partir de ses propres sorties*, il *s’inscrit dans des circuits de reporting automatisés où les résultats produits servent à justifier le maintien ou l’extension du dispositif*. La boucle est bouclée : *les dispositifs se jugent eux-mêmes à l’aune des indicateurs qu’ils ont eux-mêmes contribué à fabriquer*, et les scènes externes, lorsqu’elles existent, peinent à se frayer un chemin dans ce cercle.
+
+L’épreuve morphologique, en confrontant Système F aux grandes philosophies du pouvoir, n’a pas seulement confirmé cette intuition ; elle l’a précisée en montrant ce que le paradigme archicratique ajoute à ces morphologies, et ce qu’il leur doit.
+
+L’angle foucaldien de la *gouvernementalité* a éclairé la manière dont Système F s’insère dans des dispositifs de sécurité, de normalisation, de gestion des populations : il permet de comprendre la *logique de la “conduite à distance”*, la *centralité de la prédiction et de l’anticipation*, la *rationalité des risques et des statistiques*. Mais cette grille laisse en retrait la question de la scène où ces dispositifs peuvent être publiquement discutés. Le cas pratique a montré que l’on peut maintenir la puissance descriptive de la gouvernementalité tout en déplaçant le centre de gravité : non plus seulement “comment le pouvoir circule-t-il à travers des dispositifs ?”, mais “*où ces dispositifs peuvent-ils être mis en épreuve ?*”. C’est ce décalage qui fait la spécificité archicratique.
+
+L’angle habermassien de l’*espace public délibératif* a éclairé d’autres tensions : circulation des informations, filtrage algorithmique des contenus, simulation de la délibération par des systèmes génératifs, colonisation de la formation de la volonté par des dispositifs technico-administratifs. Là encore, l’apport archicratique n’est pas de jeter Habermas par-dessus bord, mais de remplacer une opposition trop générale entre “communication” et “systèmes” par des questions plus concrètes : *quelles scènes précises permettent à des publics de contester les dispositifs qui filtrent leurs informations, orientent leurs possibilités de parole, catégorisent leurs demandes ? Où l’IA elle-même est-elle convoquée comme objet de discussion, plutôt que comme infrastructure silencieuse de la discussion ?*
+
+Avec Rancière et avec Boltanski-Thévenot, l’épreuve a pris encore une autre couleur : Système F a été lu comme un dispositif d’épreuves silencieuses. *Scores* qui décident qui est “éligible” ou non, “méritant” ou non, “à risque” ou non ; *grandeurs implicites qui hiérarchisent les êtres et les situations* (sécurité, efficacité, solvabilité, employabilité, conformité) ; *formats d’épreuves qui ne sont pas publics, mais encapsulés dans des modèles*. Le paradigme archicratique a ici joué un rôle de transposition : il a proposé de transformer ces épreuves silencieuses en épreuves instituées, plurivoques, multisectorielles, en inventant des scènes où les “sans-part” du numérique – ceux qui n’ont pas la main sur les modèles, qui ne sont visibles que comme données – peuvent demander des comptes.
+
+Ce dialogue morphologique a donc rempli son double objectif : montrer que le paradigme archicratique est capable d’entrer en conversation avec des philosophies puissantes sans s’y dissoudre, et, simultanément, montrer ce qu’il apporte en propre : un recentrage de la critique sur la question de la scène, du faire-apparaître, de la possibilité de rejouer les fondements et les instruments.
+
+L’épreuve historique a ensuite replacé Système F dans la séquence des révolutions régulatrices : non pas pour lui attribuer une place téléologique dans une marche du progrès, mais pour le situer comme intensification de la quatrième révolution (numérisation intégrale, pilotage par la donnée, clôture douce) et comme possible catalyseur d’une cinquième, scénique.
+
+Dans le cadre de la quatrième révolution, Système F apparaît comme l’outil par excellence de la “*clôture douce*” : tout est en apparence programmable, paramétrable, ajustable ; rien ne semble empêcher, en droit, de corriger les biais, de redéfinir les proxies, de changer les seuils. Mais cette *plasticité technique intriquée dans le secret des affaires rend plus difficile la réouverture de la scène : au lieu de se traduire spontanément en débats publics, elle se confine dans un univers d’experts qui manipulent les modèles sous clauses de non divulgation*. La promesse d’“amélioration continue” tend à remplacer l’obligation de justification.
+
+Face à cette dynamique, la cinquième révolution hypothétique – révolution du faire-apparaître, du différé, de la scène comme opérateur central – ne peut pas consister en une simple “transparence” au sens visuel (ouvrir les boîtes noires, documenter les algorithmes, publier des rapports). Le cas pratique a permis de préciser ce point : ce qui manque à Système F, ce n’est pas d’abord de la visibilité, mais des *scènes d’épreuve opposables*. Les gestes archicratiques que nous avons déclinés – *droit au différé contradictoire, journaux de justification, visas d’affectation, coupe-circuits, tribunaux, assemblées, budgets scéniques, révision périodique* – dessinent concrètement ce que pourrait signifier une telle révolution scénique dans le domaine de l’IA.
+
+Ils montrent aussi que cette révolution n’est pas acquise, ni même probable. L’épreuve de co-viabilité en a donné une image plus âpre : sous sa forme actuelle, Système F pèse fortement contre la *co-viabilité sociale et écologique*.
+
+Socialement, nous avons mis en évidence une *série de trajectoires de désarchicration* : décisions automatisées qui coupent des prestations sans scène préalable, profils de risque qui enferment des individus dans des catégories quasi indiscutables, refus de dossiers appuyés sur des scores invisibles, déploiements d’outils dans des environnements où les recours sont formellement ouverts mais pratiquement inaccessibles. Dans ce contexte, parler de *co-viabilité sociale* ne veut plus simplement dire “éviter les injustices individuelles”, mais *préserver la possibilité, pour des collectifs, d’habiter des institutions où les décisions qui les affectent peuvent encore être mises en débat*.
+
+Écologiquement, la *co-viabilité* est *compromise par l’ampleur matérielle et énergétique des infrastructure*s qui portent Système F : *consommations électriques des centres de données, pressions sur les réseaux, tensions sur la ressource en eau, accumulation de déchets électroniques, impacts sur des territoires précis où sont implantées les fermes de serveurs*. Là encore, le problème n’est pas que ces coûts soient ignorés dans l’absolu – les chiffres commencent à circuler –, mais qu’ils ne soient nulle part mis en épreuve sur des scènes où l’on pourrait décider : “*acceptons-nous de consacrer telle part de notre budget énergétique, de nos nappes, de nos terres rares, à ce type de dispositif régulateur ?*”.
+
+L’*autarchicratie numérique* apparaît ici comme le nom adéquat de cette double déliaison : un *méta-régime où la régulation par IA s’auto-entretient à partir de ses propres métriques*, *et où les coûts sociaux et écologiques sont externalisés hors des scènes où l’on pourrait en débattre*. Le cas pratique a montré que cette dynamique n’est pas une fatalité abstraite, mais un effet concret de l’absence de certaines scènes – absence que les gestes archicratiques se proposent de combler.
+
+C’est là que réside sans doute l’apport le plus immédiatement opératoire du cas pratique : la déclinaison des gestes archicratiques en “manuel d’usage” pour un système IA. *Droit au différé contradictoire, journaux de justification, visa d’affectation des scores, coupe-circuit citoyen, tribunal de l’algorithme, assemblées d’affectation et budgets scéniques, révision archicrative périodique et cartographie des scènes manquantes* : pris isolément, chacun de ces gestes pourrait sembler modeste, presque technique. Pris ensemble, reliés à l’architecture d’ensemble du cas, ils dessinent une autre manière d’aborder la régulation.
+
+D’abord parce qu’ils renversent le point de départ. Au lieu de demander : “comment rendre l’IA fiable, performante, moins biaisée ?”, ils demandent : “*à quelles conditions acceptons-nous de reconnaître à Système F un rôle régulateur dans nos institutions ?*”. La question n’est plus seulement celle des propriétés internes du modèle, mais celle de l’architecture scénique dans laquelle il est inséré. Un système qui ne tolère ni droit au différé, ni journal de justification, ni visa public des usages, ni coupe-circuit, ni tribunal, ni assemblées d’affectation, ni révision périodique est un système qui se place délibérément *hors archicratie, en tendance autarcique d’un pouvoir auto-référé et auto-référant confiné à un cercle de spécialistes et d’experts, seul capable de les fonder, de les activer et de les modifier*.
+
+Ensuite parce qu’ils rendent concrète la notion de “*politique des épreuves viables*”. Ce que le traité formulait en termes généraux – *nécessité d’instituer des épreuves où les régimes régulateurs peuvent être mis en discussion, condition d’une co-viabilité soutenable* – prend ici la forme de dispositifs précis, négociables, amendables. Le cas pratique ne fige pas ces gestes en dogmes ; il montre comment ils pourraient s’agencer, se renforcer, se contrôler mutuellement. Il propose une grammaire minimale pour toute tentative sérieuse de gouvernance des IA qui ne se résigne ni à l’*autarchicratie* ni à l’*illusion d’un simple “moratoire technologique”*.
+
+Enfin parce qu’ils donnent à voir une ligne de crête : comment résister à la tentation symétrique de la technophilie naïve et du luddisme impuissant. Le cas pratique ne conclut ni à l’abolition pure et simple des systèmes IA dans la régulation, ni à leur adoption sans réserve. Il soutient que des systèmes comme Système F peuvent, dans certains cas, contribuer à une meilleure coordination, à une meilleure allocation des ressources, à des gains réels d’intelligibilité ; mais à une condition stricte : que ces dispositifs soient eux-mêmes soumis, en permanence, à des scènes d’épreuve instituées, pluralisées, dotées de pouvoirs effectifs.
+
+Au terme de ce parcours, il est possible de dire ce que ce cas pratique apporte en retour au paradigme archicratique.
+
+Il confirme d’abord la capacité opératoire de la triade archicratique. Loin de rester un triptyque conceptuel abstrait, elle s’est révélée capable de guider une enquête dans un domaine techniquement complexe, de repérer des fondements silencieux là où l’on ne voyait que des arbitrages techniques, de décrire des pouvoirs opératoires là où l’on parlait seulement d’“assistance à la décision”, de qualifier des scènes comme inexistantes, fantomatiques, hypotopiques ou hypertopiques là où l’on croyait avoir des procédures suffisantes.
+
+Il nuance ensuite certaines tentations de simplification. Là où l’on aurait pu opposer trop brutalement “ancien” et “nouveau”, “humain” et “machine”, “politique” et “technique”, le cas pratique montre que la réalité est plus subtile : Système F n’est pas un intrus tombé dans un ordre régulateur par ailleurs homogène, il est un accélérateur et un condensateur de tendances déjà à l’œuvre. Reconnaître cette continuité n’amoindrit pas la critique ; au contraire, cela l’affine.
+
+Il approfondit, enfin, l’intuition d’une *bascule autarchicratique* propre à la configuration numérique contemporaine, en lui donnant un nom, un visage, des prises. Il ne s’agit pas de décréter que “nous serions déjà entrés dans un nouveau méta-régime” ; il s’agit de montrer que des dispositifs comme Système F présentent toutes les caractéristiques d’un régime où la régulation se gouverne elle-même, et que la seule manière de ne pas céder à cette pente est de multiplier les gestes de réouverture scénique.
+
+Que reste-t-il, alors, à la conclusion à dire qui ne soit ni simple paraphrase, ni montée en généralité gratuite ? Peut-être ceci : en entrant dans l’IA par la porte de la gouvernance archicratique plutôt que par celle de la seule performance calculatoire, nous avons déplacé le centre même de la question. Nous n’avons pas demandé jusqu’où les modèles pourraient aller, quelles tâches ils seraient capables de prendre en charge, quelle part d’intelligence humaine ils pourraient imiter ; nous avons demandé *jusqu’où nous sommes prêts à laisser disparaître les scènes où un monde commun se discute, se raconte, se règle*. Autrement dit : nous avons cessé de parler de l’IA comme d’un simple gain de capacités pour l’interroger comme un opérateur de monde : *quels horizons de vie ses dispositifs ouvrent-ils, quelles formes de présence ses dispositifs invisibilisent, quelles trajectoires ses dispositifs resserrent ou, au contraire, desserrent ?*
+
+Ce déplacement inverse la charge de la preuve. Ce n’est plus aux citoyens, aux allocataires, aux patients, aux justiciables, aux salariés, aux usagers – ni à la faune silencieuse des milieux, aux territoires énergétiquement mis à contribution, aux atmosphères saturées de chaleur résiduelle – de démontrer que l’IA serait dangereuse, injuste ou illégitime. *C’est aux dispositifs qui prétendent réguler leurs vies et leurs environnements de montrer qu’ils acceptent d’être mis en scène, ralentis, contredits, révisés*. *C’est aux promoteurs et régulateurs de Système F, publics comme privés, de prouver qu’ils ne cherchent pas seulement à optimiser des indicateurs, mais à s’inscrire dans un ordre archicratique où les fondements, les instruments et les effets du pouvoir régulateur demeurent exposables et disputables*. La question n’est plus : “l’IA est-elle utile ?”, mais : “*les mondes qu’elle configure sont-ils encore négociables, encore ouverts à l’adresse, encore habités par des voix qui ne se résument pas à des variables ?*”.
+
+Ce cas pratique n’a ni la vocation ni la prétention de résoudre d’un bloc un tel problème. Il s’est assigné une tâche plus modeste et, pour cette raison même, plus décisive : r*endre explicites des conditions minimales d’acceptabilité archicratique pour un grand système d’IA*, là où l’on se contentait le plus souvent de chartes, de principes génériques ou de diagnostics moraux. Il a permis d’écrire, presque ligne à ligne : pour un modèle de fondation intégré à des politiques publiques et privées, voici les scènes qu’il faut instituer, les gestes à prévoir, les droits à inscrire, les temps et les ressources à consentir si l’on veut autre chose qu’une régulation hors scène légèrement habillée de transparence. Il a tenté de montrer qu’une *cosmopolitique des systèmes techniques* commence par une *cosmopoétique* : par l’*art patient de décrire comment ces dispositifs redessinent les lignes de visibilité, d’audibilité, d’habitabilité entre humains, institutions et milieux*.
+
+Rien, dans ces pages, ne promet une “bonne IA” réconciliée avec tout et tous•tes. Rien n’annonce que cette réorientation pourrait se faire sans coût, sans conflits, sans renoncements – sans que certains usages soient abandonnés, certains automatismes démantelés, certaines promesses d’optimisation relativisées. Ce que le cas pratique affirme est plus nu, mais plus tranchant : *une société qui renonce à instituer de telles scènes autour de ses dispositifs régulateurs renonce, en vérité, à sa propre archicratie*. Elle accepte que la régulation devienne son propre souverain ; elle laisse des machines de classement décider sans jamais comparaître ; elle tolère que des métriques se cristallisent en dogmes, que des architectures techniques découpent silencieusement le partage entre vies recevables et vies marginalisées, entre milieux exploitables et milieux sacrifiés. Une telle société ne se contente pas d’adopter des systèmes d’IA : elle délègue son pouvoir d’instituer des mondes et se dépossède de la poétique de sa propre scène.
+
+L’inverse n’implique ni nostalgie technophobe, ni fantasme de contrôle intégral. Une société qui prend au sérieux ce que cette enquête propose – un *audit archicratique systématique*, une *politique des épreuves viables appliquée à l’IA*, un *ensemble de gestes concrets pour réarmer la scène* – *ne s’oppose pas à la technique*. Elle lui assigne une place. Elle refuse d’en faire le trône invisible de la régulation et lui confie, à chaque fois, un *rôle situé, provisoire, discutable, dans un ordre où le pouvoir d’instituer des scènes reste irréductiblement humain, social, écologique et politique*. Elle accepte que ses architectures numériques soient elles-mêmes prises dans une trame plus large de co-viabilité : qu’elles répondent devant les corps qu’elles classent, devant les institutions qu’elles structurent, devant les milieux qu’elles mobilisent. Elle reconnaît que chaque nouvelle couche d’IA est un geste cosmopoétique : un acte par lequel se recomposent ce qui compte, ce qui apparaît, ce qui peut être entendu.
+
+Si cinquième révolution régulatrice il doit y avoir, rien ne dit qu’elle sera spectaculaire, ni qu’elle portera son nom. Elle ne viendra pas des modèles eux-mêmes, mais de cette décision collective, lente et conflictuelle, de *faire de l’IA non plus le laboratoire d’une autarchicratie numérique, mais un terrain parmi d’autres pour refonder des scènes d’épreuve à la hauteur de nos co-viabilités*. À ce titre, Système F est un test. Il demande : *voulons-nous d’un monde où des dispositifs de ce type prolifèrent sans jamais avoir à comparaître, ou d’un monde où leur puissance même oblige à concevoir de nouvelles scénographies du commun, de nouveaux rites de justification, de nouveaux agencements entre calcul et récit ?*
+
+Dans cette mise à l’épreuve, le *paradigme archicratique* est lui-même sommé de tenir. Il ne se contente pas de dire ce que le pouvoir fait ; il *indique comment et où le faire comparaître, quels mondes il contribue à installer, quelles scènes il accepte encore de partager*. S’il y a, dans ce cas pratique, quelque chose comme une promesse, elle tient en peu de mots : *tant que des scènes pourront être instituées autour de nos systèmes techniques, tant que des épreuves pourront être inventées pour les faire répondre devant les vivants et les milieux qu’ils affectent, l’archicratie ne sera pas tout à fait perdue*. Elle restera disponible comme art de composer, parmi les possibles du calcul, des mondes encore habitables.

src/content/cas-ia/introduction.mdx

@@ -0,0 +1,57 @@
+---
+title: "Introduction générale — Mettre un système d’IA en scène"
+edition: "cas-ia"
+status: "application"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 110
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/cas-ia/Cas_Pratique-Archicratie_et_gouvernance_des_systemes_IA-Introduction.docx"
+---
+1.  Introduction générale — Mettre un système d’IA en scène
+
+Ce texte est un prolongement opératoire de l’essai-thèse sur l’*archicratie*. Il n’ajoute pas un nouveau pan théorique, ni un chapitre caché : il montre *comment* utiliser le paradigme archicratique pour instruire un cas concret, massif, déjà à l’œuvre. Il propose un audit archicratique d’un grand système d’intelligence artificielle de fondation, tel qu’il est intégré dans des dispositifs de décision publics et privés. Autrement dit : il s’agit d’examiner, avec les outils construits par la thèse, ce qui se passe quand un modèle d’IA ne se contente plus de produire des textes ou des prédictions dans l’abstrait, mais devient un opérateur régulateur au cœur des politiques sociales, des institutions de santé, des systèmes de justice, des ressources humaines, des plateformes d’information.
+
+Dans l’essai-thèse, l’*archicratie* est définie comme un *seuil* : le seuil à partir duquel un ordre de régulation cesse d’être une pure automatisation fonctionnelle et devient une régulation habitée, c’est-à-dire fondée, visible, opposable, révisable. Trois prises structurent ce seuil : l’*arcalité*, qui concerne les *formes de fondation, de justification, de symbolisation du pouvoir régulateur* ; la *cratialité*, qui rassemble les *dispositifs, instruments, chaînes d’exécution, architectures et procédures par lesquelles ce pouvoir "prend", s’applique, opère* ; et l’*archicration*, qui désigne la *scène d’épreuve où les deux premières prises peuvent être amenées en visibilité, en conflit, en révision*. Un ordre est archicratique non parce qu’il serait idéalement juste, mais parce qu’il se laisse amener en scène : on peut lui demander d’où il parle, comment il agit, ce qui est en jeu, à quelles conditions il accepte de se transformer.
+
+Le diagnostic contemporain que propose la thèse est celui d’une *oblitération archicratique* : les sociétés ne manquent ni de normes, ni de procédures, ni d’appareils de calcul ; elles manquent de scènes où ces normes, ces procédures, ces appareils peuvent comparaître. À mesure que la régulation se transfère dans des architectures techniques, dans des chaînes logistiques, dans des barèmes et des algorithmes, la scène tend à disparaître derrière la *cratialité*. Les décisions se prennent toujours, mais elles se prennent *ailleurs* : dans des centres de données, des plateformes logicielles, des systèmes d’information qui se présentent comme de simples moyens techniques, alors même qu’ils fabriquent des distributions de droits, des hiérarchies d’accès, des lignes de partage entre les vies recevables et les vies déclassées. La régulation ne disparaît pas : elle se déplace hors scène.
+
+Or les grands systèmes d’IA de fondation naissent précisément au point où ce déplacement est le plus avancé. Un modèle de fondation (*large language model*, modèle multimodal, etc.) est un système d’apprentissage automatique entraîné sur des masses considérables de données textuelles, visuelles, sonores, codées. Il apprend des régularités statistiques, des styles, des associations ; il devient capable de produire des réponses, des résumés, des classements, des prédictions, parfois plus rapidement et plus fluide­ment qu’un humain. Mis en accès par une interface de programmation (API), ce modèle peut être appelé silencieusement par d’autres logiciels : un portail de demande d’allocations, un système de gestion de dossiers médicaux, un outil de tri de CV, un module de modération de contenus, une console de supervision policière. L’IA ne se présente plus comme un objet séparé ; elle s’incruste dans des guichets, des formulaires, des tableaux de bord, des applications mobiles, sous la forme de suggestions, de scores, de couleurs, de classements.
+
+C’est cette incrustation que nous allons prendre pour terrain. Pour rendre l’analyse manipulable, nous poserons l’hypothèse d’un système composite — appelons-le Système F — qui condense des traits déjà largement présents dans le monde réel. Système F est un modèle de fondation accessible par API. Des entreprises de services numériques et des équipes internes l’ont intégré dans une série de flux de travail (*workflows*) de décision :
+
+- dans les politiques sociales, pour trier des dossiers, repérer des incohérences, classer les demandes par “risque de fraude” ou par “urgence” ;
+
+- dans la santé, pour aider à prioriser des patients sur des listes d’attente, suggérer des examens complémentaires, pré-classer des comptes rendus ;
+
+- dans la justice et la sécurité, pour produire des analyses de risque (probabilité de récidive, “dangerosité”), filtrer des signalements, croiser des informations ;
+
+- dans les ressources humaines, pour trier des CV, détecter des “signaux faibles” de démission, pré-évaluer des performances ;
+
+- dans la modération et la curation de contenus, pour filtrer des messages “toxiques”, recommander des publications, ajuster la visibilité de certains profils.
+
+Système F n’est pas un fantasme technologique éloigné : il agrège des fonctions déjà présentes, sous d’autres noms, dans de nombreux pays et secteurs. Des algorithmes de *scoring* de fraude sociale ont été utilisés dans des administrations de sécurité sociale, provoquant scandales et contentieux lorsqu’ils ciblaient de façon disproportionnée certains quartiers, certaines familles, certains types de parcours\* ; des systèmes d’évaluation de risque ont été intégrés à des décisions de justice pour proposer des peines ou des libérations conditionnelles ; des plateformes de recrutement recourent à des modèles d’IA pour pré-filtrer des milliers de candidatures en quelques minutes ; les systèmes de modération emploient depuis longtemps des modèles d’apprentissage pour détecter les propos violents, haineux, pornographiques. Système F est donc moins une fiction qu’un nom commun donné à un ensemble de tendances déjà engagées.
+
+Ce qui nous intéresse n’est pas l’IA “en général”, ni l’intelligence artificielle comme problème métaphysique. Ce qui nous intéresse, dans notre manière de voir les choses, c’est l’écosystème socio-technique dans lequel Système F est inséré : les chaînes cratiales qu’il tisse ou renforce, les formes d’arcalité explicite ou implicite qu’il véhicule, les archicrations qu’il rencontre, détourne ou évite. Un modèle appelé par API dans un formulaire de demande de logement n’est pas un objet neutre : il devient un segment de chaîne régulatrice qui affecte des droits à l’hébergement ; il participe à la décision de traiter un dossier en priorité, de le mettre en attente, de le faire basculer dans la catégorie “suspect”. De même, un modèle intégré au tri des CV dans une grande entreprise n’est pas un simple gain de temps : il devient un opérateur qui donne la forme concrète de l’accès à l’emploi.
+
+L’enjeu de ce texte est donc très précis : montrer comment le paradigme archicratique permet d’auditer un tel système. Auditer, ici, ne veut pas dire vérifier uniquement les performances techniques (taux de faux positifs, biais mesurés, robustesse aux attaques adversariales), ni cocher des cases éthiques (“non-discrimination”, “explicabilité”, “*privacy by design*”). Auditer signifie : reconstruire la distribution *arcalité* / *cratialité* / *archicration* dans laquelle Système F fonctionne ; décrire où se logent les fondements, où se concentrent les pouvoirs opératoires, où se tiennent (ou ne se tiennent pas) les scènes d’épreuve. Il s’agit d’évaluer si l’écosystème dans lequel Système F agit est, à un titre quelconque, archicratique, ou s’il participe à la dynamique d’*autarchicratie* et de *régulation hors scène* mise au jour dans notre essai-thèse.
+
+Pour ce faire, nous allons reprendre, un par un, les cinq types d’épreuves qui le structurent, et les appliquer à Système F.
+
+La première est l’épreuve de *détectabilité*. Elle consiste à savoir si, face à un dispositif donné, nous parvenons à distinguer et localiser ses *arcalités*, ses *cratialités* et ses *archicrations*, et à qualifier leur configuration : sont-elles clairement différenciées ou confondues ? La scène existe-t-elle vraiment, ou est-elle réduite à un décor procédural ? Certaines prises sont-elles hypertrophiées, d’autres atrophiées ? La topologie développée par la thèse — *synchrotopies* (scènes tenues), *hypotopies* (scènes pauvres), *hypertopies* (scènes concentrées), *atopies* (scènes fantomatiques) — servira ici de grille pour lire les multiples lieux où Système F intervient : guichet social, service hospitalier, cabinet de juge, bureau des ressources humaines, interface de modération.
+
+La deuxième est l’épreuve archéogénétique. Il s’agit de replacer Système F dans la série des méta-régimes régulateurs décrits par la thèse : techno-logistique, scripturo-bureaucratique, marchand, guerrier, etc. Nous demanderons : de quelle histoire Système F est-il le prolongement ? Relève-t-il d’une nouvelle étape radicalement inédite, ou vient-il composer plusieurs régimes existants — par exemple la mégamachine techno-logistique, la rationalité scripturo-bureaucratique et le régime marchand ? Quels “styles de régulation” anciens réactive-t-il sous une forme technique nouvelle ?
+
+La troisième est l’épreuve morphologique. Elle consiste à confronter Système F aux grandes philosophies du pouvoir auxquelles la thèse s’est mesurée : gouvernementalité foucaldienne, espace public habermassien, dissensus rancière, économies de la grandeur de Boltanski et Thévenot, etc. Que devient la gouvernementalité quand elle se dote d’un Système F ? Que devient l’espace public quand les contributions circulent à travers des filtres IA ? Comment les épreuves de justification se transforment-elles lorsque des modèles statistiques produisent des classements et des diagnostics à grande échelle ? Cette épreuve permettra de montrer ce que le paradigme archicratique voit que ces philosophies laissent en retrait : la question de la scène concrète où le pouvoir se justifie (ou ne se justifie pas).
+
+La quatrième est l’épreuve historique. Les révolutions industrielles ont été relues par la thèse comme des révolutions régulatrices : chaque vague technologique reconfigurant les agencements entre *arcalité, cratialité, archicration*. Nous montrerons en quoi Système F est un produit avancé de la quatrième révolution régulatrice (numérisation intégrale, pilotage par indicateurs) et en quoi il force à prendre au sérieux l’hypothèse d’une cinquième révolution scénique : non plus centrée sur l’extension de la puissance calculatoire, mais sur la réinstitution de la scène comme opérateur central du pouvoir.
+
+Enfin, la cinquième est l’épreuve de *co-viabilité*. Il s’agira d’analyser comment Système F affecte la *co-viabilité sociale* (accès aux droits, reconnaissance, dignité), *écologique* (consommation énergétique, infrastructures matérielles, impacts sur les milieux), *symbolique* (représentations du mérite, du risque, de la vérité), et dans quelle mesure il tend à renforcer un régime d’*autarchicratie* — un gouvernement par la régulation elle-même, où indicateurs, modèles et standards deviennent leurs propres juges. C’est dans cet effort que la politique des épreuves viables, telle qu’esquissée dans la conclusion de la thèse, sera traduite en propositions concrètes pour le cas IA : droit au différé contradictoire, journal de justification, tribunal de l’algorithme, budget scénique, cartographie des scènes manquantes.
+
+Ce texte n’est donc ni une monographie empirique exhaustive sur un système d’IA particulier, ni un manifeste normatif énonçant ce qu’il faudrait faire dans tous les détails. Il se présente comme un modèle d’audit archicratique, c’est-à-dire comme une manière structurée d’examiner un dispositif régulateur à l’aide des outils conçus par l’essai-thèse. Les hypothèses qui seront formulées sont testables : elles peuvent être confirmées, infirmées, nuancées par des enquêtes empiriques, par des analyses techniques, par des contre-exemples. L’objectif est double : montrer que le paradigme archicratique est réellement opératoire lorsqu’on le confronte à un terrain complexe, et ouvrir un chemin pour que d’autres puissent, à leur tour, mettre en scène les systèmes techniques qui reconfigurent déjà nos formes de *co-viabilité*.
+
+#

src/content/commencer/document-de-presentation.mdx

@@ -0,0 +1,435 @@
+---
+title: "Document de présentation"
+edition: "commencer"
+status: "draft"
+level: 1
+version: "0.1.0"
+concepts: []
+links: []
+order: 0
+summary: ""
+source:
+  kind: docx
+  path: "sources/docx/commencer/document-de-presentation.docx"
+---
+## I — L’angle mort de la théorie politique
+
+Depuis plusieurs siècles, la théorie politique s’efforce de comprendre comment les sociétés humaines s’organisent et se gouvernent. Elle s’est structurée autour de quelques questions fondamentales : qui exerce le pouvoir, au nom de qui, selon quelles règles, à travers quelles institutions.
+
+De la souveraineté chez Bodin à la séparation des pouvoirs chez Montesquieu, du contrat social chez Rousseau aux théories contemporaines de la démocratie représentative, l’essentiel de la réflexion politique moderne s’est concentré sur les formes visibles du pouvoir. Monarchies, républiques, démocraties, oligarchies : ces régimes ont constitué les catégories principales à travers lesquelles les sociétés ont cherché à penser leur propre organisation.
+
+Cette tradition a produit des analyses d’une grande richesse. Elle a permis de comprendre les mécanismes de la légitimité politique, les formes de la domination, les conditions de la représentation et les principes de l’autorité publique.
+
+Mais elle laisse dans l’ombre la question décisive.
+
+Les sociétés humaines ne tiennent pas seulement par leurs régimes politiques.
+
+Elles tiennent aussi — et souvent surtout — par des architectures matérielles, techniques, normatives et organisationnelles qui rendent la coexistence collective possible. Infrastructures de production et de circulation, systèmes administratifs, normes juridiques, instruments de mesure, dispositifs d’information, architectures techniques, procédures d’évaluation ou cadres cognitifs partagés : tous ces éléments participent à l’organisation concrète du monde social.
+
+Ces architectures ne sont pas de simples supports du pouvoir politique. Elles en conditionnent l’exercice et souvent la survie. Elles organisent la circulation des ressources, stabilisent les attentes collectives, encadrent les interactions sociales et permettent aux tensions qui traversent les sociétés de demeurer compatibles avec la continuité de l’ensemble.
+
+Autrement dit, elles assurent ce que l’on peut appeler la co-viabilité des sociétés humaines : leur capacité à absorber et à redistribuer les tensions internes sans se désagréger.
+
+Or cette dimension essentielle de la vie collective demeure étonnamment peu théorisée.
+
+La théorie politique s’est concentrée sur les institutions visibles du pouvoir. Les sciences sociales ont étudié les infrastructures techniques, les organisations administratives ou les dispositifs économiques. Mais ces analyses restent le plus souvent fragmentées, dispersées entre disciplines et objets distincts.
+
+Il manque encore un concept capable de désigner les architectures par lesquelles les sociétés organisent leur propre tenue.
+
+C’est pour nommer cette dimension que l’on peut introduire le concept d’archicratie.
+
+L’archicratie ne désigne pas un régime politique parmi d’autres. Elle désigne le méta-régime de régulation qui traverse et soutient les régimes politiques explicites. Là où les régimes politiques définissent les formes visibles du pouvoir, l’archicratie renvoie aux architectures plus profondes qui rendent possible la tenue du monde social.
+
+Comprendre les sociétés contemporaines suppose donc de déplacer partiellement le regard. Il ne s’agit plus seulement d’interroger les formes de gouvernement, mais d’analyser les architectures régulatrices qui permettent aux tensions sociales, économiques, techniques et écologiques de demeurer compatibles avec la continuité collective.
+
+C’est à l’exploration de cette dimension que se consacre la théorie de l’archicratie.
+
+## II — Pourquoi un nouveau concept est nécessaire
+
+Si l’on affirme que les sociétés humaines se maintiennent par des architectures régulatrices profondes, une objection surgit aussitôt : n’existe-t-il pas déjà des concepts pour penser cette dimension ?
+
+En effet, plusieurs traditions intellectuelles ont cherché à décrire les dispositifs par lesquels les sociétés organisent leur stabilité. Les notions de bureaucratie, de gouvernance, de régulation ou encore d’infrastructure institutionnelle semblent, à première vue, approcher cette réalité.
+
+Pourtant aucun de ces concepts n’en saisit pleinement la portée.
+
+La notion de bureaucratie, telle qu’elle apparaît chez Max Weber, désigne l’organisation administrative rationnelle propre aux États modernes. Elle permet de comprendre la structuration hiérarchique des appareils administratifs, la formalisation des règles et la rationalisation des procédures. Mais la bureaucratie ne constitue qu’un type particulier d’institution. Elle ne couvre ni l’ensemble des architectures techniques qui structurent les sociétés contemporaines, ni les dispositifs économiques, informationnels ou cognitifs qui participent à la régulation collective.
+
+La notion de gouvernance, largement utilisée dans les sciences sociales contemporaines, cherche quant à elle à décrire la pluralité des acteurs et des mécanismes impliqués dans la coordination des sociétés. Elle met l’accent sur les réseaux d’acteurs, les partenariats institutionnels ou les formes de pilotage indirect. Mais cette notion reste principalement descriptive : elle s’intéresse aux modes de coordination sans saisir pleinement les architectures matérielles et techniques qui rendent cette coordination possible.
+
+La notion de régulation, développée notamment dans l’économie politique, permet d’analyser les dispositifs par lesquels les systèmes économiques maintiennent une certaine stabilité malgré les tensions internes. Elle a notamment permis de comprendre les transformations du capitalisme à travers les formes institutionnelles qui organisent ses équilibres. Mais elle demeure largement centrée sur les mécanismes économiques et institutionnels, laissant en partie dans l’ombre les infrastructures techniques, informationnelles ou administratives qui structurent la vie sociale au-delà de l’économie.
+
+Enfin, les approches contemporaines qui s’intéressent aux infrastructures — qu’elles soient techniques, numériques ou organisationnelles — mettent en évidence l’importance des dispositifs matériels dans l’organisation des sociétés. Elles montrent comment les réseaux techniques, les systèmes d’information ou les architectures logistiques conditionnent les formes de la vie collective. Mais ces analyses restent souvent sectorielles : elles décrivent des infrastructures particulières sans toujours saisir la logique d’ensemble qui les articule.
+
+Chacun de ces concepts éclaire une dimension importante du fonctionnement social. Aucun cependant ne permet de saisir l’ensemble des architectures par lesquelles les sociétés organisent la régulation des tensions qui les traversent.
+
+C’est précisément cet ensemble que désigne le concept d’archicratie.
+
+L’archicratie ne se limite ni à l’administration, ni à la coordination entre acteurs, ni aux mécanismes économiques de régulation, ni aux seules infrastructures techniques. Elle désigne l’architecture globale par laquelle une société organise la co-viabilité de ses dynamiques internes.
+
+L’intérêt du concept est ainsi de permettre une lecture transversale des dispositifs qui structurent la vie collective. Il invite à considérer ensemble des éléments souvent étudiés séparément : institutions politiques, infrastructures matérielles, systèmes administratifs, architectures informationnelles, dispositifs techniques, instruments de mesure ou cadres normatifs.
+
+L’archicratie ne remplace pas les concepts existants ; elle les re-situe dans un cadre plus large.
+
+La bureaucratie devient alors l’une des formes possibles de l’archicratie administrative. Les infrastructures techniques apparaissent comme des composantes matérielles de l’archicratie. Les dispositifs économiques de régulation constituent certaines de ses modalités fonctionnelles.
+
+Ce déplacement permet de saisir les sociétés non plus seulement à partir de leurs institutions visibles, mais à partir de l’ensemble des architectures qui rendent leur co-viabilité possible.
+
+L’introduction du concept d’archicratie ne vise donc pas à multiplier les catégories théoriques. Elle répond à une nécessité analytique : disposer d’un concept capable de désigner le niveau fondamental où les sociétés organisent leur propre tenue.
+
+C’est à la clarification de ce niveau que doit maintenant se consacrer la définition conceptuelle de l’archicratie.
+
+## III — Définition conceptuelle de l’archicratie
+
+Si l’archicratie désigne le niveau profond par lequel les sociétés assurent leur propre tenue, il faut maintenant en préciser la structure.
+
+Par archicratie, il faut entendre l’ensemble des architectures par lesquelles une société organise la régulation des tensions qui la traversent afin de maintenir la co-viabilité de ses dynamiques collectives.
+
+Toute société humaine est traversée par une multiplicité de forces : dynamiques économiques, transformations techniques, conflits sociaux, mutations culturelles, pressions écologiques, innovations organisationnelles. Ces forces produisent des tensions permanentes. Elles peuvent accélérer, déséquilibrer ou fragmenter l’ordre social.
+
+La continuité d’une société dépend donc de sa capacité à organiser un traitement durable de ces tensions.
+
+Ce traitement ne repose pas uniquement sur des décisions politiques ponctuelles. Il s’appuie sur un ensemble beaucoup plus large de dispositifs stabilisateurs : institutions administratives, infrastructures matérielles, normes juridiques, architectures techniques, systèmes d’information, instruments de mesure, procédures organisationnelles, dispositifs d’évaluation ou encore cadres cognitifs partagés.
+
+Pris ensemble, ces dispositifs composent l’architecture régulatrice qui permet à une société de maintenir la co-viabilité de ses dynamiques internes.
+
+C’est cette architecture que désigne l’archicratie.
+
+Pour rendre compte de cette dynamique régulatrice, il est utile de distinguer trois dimensions fondamentales présentes dans toute organisation sociale complexe : l’arcalité, la cratialité et l’archicration.
+
+### L’arcalité : les structures stabilisatrices
+
+L’arcalité désigne l’ensemble des structures relativement durables qui stabilisent un système social.
+
+Elle comprend les institutions politiques, les cadres juridiques, les infrastructures matérielles, les architectures techniques, les dispositifs administratifs ou encore les normes organisationnelles qui encadrent les interactions sociales.
+
+Ces structures produisent de la stabilité. Elles définissent des règles, organisent des flux, instituent des contraintes et rendent certaines formes d’action possibles tandis que d’autres deviennent difficiles ou impossibles.
+
+L’arcalité constitue ainsi la dimension structurelle de la vie collective : le réseau de formes relativement persistantes qui organisent l’espace dans lequel les dynamiques sociales peuvent se déployer.
+
+### La cratialité : les dynamiques de transformation
+
+Face à ces structures stabilisatrices se déploient des forces dynamiques que l’on peut désigner sous le terme de cratialité.
+
+La cratialité renvoie à l’ensemble des dynamiques qui traversent les sociétés : flux économiques, innovations technologiques, transformations démographiques, conflits sociaux, mutations culturelles, pressions écologiques ou recompositions géopolitiques.
+
+Ces dynamiques exercent une pression constante sur les structures existantes. Elles déplacent les équilibres, modifient les rapports de force et introduisent de nouvelles tensions dans l’organisation sociale.
+
+Aucune société ne peut supprimer ces forces de transformation. Elles constituent au contraire la condition même du mouvement historique.
+
+La question centrale devient donc celle de leur régulation.
+
+### L’archicration : la régulation des tensions
+
+C’est ici qu’intervient la troisième dimension : l’archicration.
+
+L’archicration désigne l’ensemble des mécanismes par lesquels un système social régule les tensions entre ses structures stabilisatrices et ses dynamiques de transformation.
+
+Elle ne supprime pas les tensions. Elle les organise.
+
+Elle redistribue les contraintes, ajuste les équilibres, canalise les conflits, transforme certaines dynamiques et en ralentit d’autres afin de maintenir la compatibilité globale du système.
+
+Les dispositifs fiscaux, les mécanismes juridiques, les infrastructures de circulation, les systèmes d’information, les architectures techniques ou les instruments statistiques peuvent ainsi être compris comme autant d’opérateurs d’archicration : ils participent à la redistribution permanente des tensions collectives.
+
+### L’archicratie comme dynamique sociale globale
+
+L’archicratie est l’organisation sociale de cette dynamique tripartite.
+
+Elle peut être comprise comme l’ensemble des architectures par lesquelles une société articule :
+
+- ses structures stabilisatrices (arcalité),
+
+- ses forces de transformation (cratialité),
+
+- et les mécanismes de régulation qui les relient (archicration).
+
+Cette articulation constitue le niveau fondamental par lequel les sociétés maintiennent leur co-viabilité.
+
+Lorsque cette articulation fonctionne, les tensions collectives demeurent compatibles avec la continuité sociale. Les transformations peuvent être absorbées, redistribuées ou intégrées dans l’ordre existant.
+
+Lorsque cette articulation se fragilise, les tensions peuvent s’accumuler, se déplacer brutalement ou dépasser les capacités de régulation du système. Les crises politiques, économiques ou institutionnelles apparaissent alors comme des moments où les architectures archicratiques deviennent incapables de maintenir l’équilibre dynamique entre structures et forces.
+
+Dans cette perspective, l’archicratie ne désigne pas une institution particulière. Elle désigne une propriété structurelle des sociétés complexes : la manière dont elles organisent la régulation permanente des tensions qui les traversent.
+
+Toute société possède ainsi une forme d’archicratie. Mais les modalités de cette régulation varient profondément selon les contextes historiques, les configurations institutionnelles et les architectures techniques disponibles.
+
+C’est pourquoi l’archicratie doit également être pensée comme un phénomène historique.
+
+Les sociétés ne cessent de transformer les architectures par lesquelles elles assurent leur propre tenue.
+
+C’est à l’analyse de ces transformations que doit désormais se consacrer l’examen de l’archicratie dans l’histoire des sociétés humaines.
+
+## IV — L’archicratie dans l’histoire des sociétés humaines
+
+Si l’archicratie articule arcalité, cratialité et archicration, elle ne peut être réduite aux sociétés contemporaines. Elle constitue une dimension structurelle de toute organisation sociale complexe.
+
+L’histoire des sociétés humaines peut être relue comme une succession de configurations entre structures stabilisatrices, dynamiques de transformation et mécanismes de régulation.
+
+Dans toute société, une arcalité se met en place : un ensemble de structures relativement durables qui stabilisent l’ordre collectif. Ces structures peuvent prendre la forme d’institutions politiques, de systèmes juridiques, de normes religieuses, d’infrastructures matérielles ou d’organisations administratives. Elles définissent le cadre dans lequel les interactions sociales peuvent se déployer.
+
+Mais ces structures ne sont jamais immobiles. Elles sont constamment traversées par des forces dynamiques — économiques, techniques, démographiques ou culturelles — qui exercent une pression sur les formes établies. Ces forces constituent la cratialité des sociétés : l’ensemble des dynamiques qui déplacent les équilibres, introduisent de nouvelles tensions et transforment les conditions de l’existence collective.
+
+L’histoire sociale peut ainsi être comprise comme une tension permanente entre arcalité et cratialité.
+
+Cependant, cette tension ne conduit pas nécessairement à la rupture. Les sociétés développent des dispositifs capables d’absorber, de redistribuer ou de transformer ces tensions. Ces dispositifs constituent l’archicration : l’ensemble des mécanismes par lesquels un système social régule les dynamiques qui le traversent afin de maintenir sa co-viabilité.
+
+Dans les sociétés anciennes, l’archicration repose largement sur des dispositifs symboliques et institutionnels imbriqués : rites religieux, formes coutumières de droit, mécanismes de redistribution ou structures territoriales stabilisent les tensions produites par les dynamiques sociales.
+
+Avec l’émergence des États modernes, les architectures d’archicration se transforment. Les administrations permanentes, les systèmes fiscaux, les dispositifs juridiques formalisés ou les infrastructures de circulation deviennent des opérateurs majeurs de régulation. L’archicration se matérialise alors dans des architectures administratives capables de traiter des flux de population, de ressources et d’information à une échelle croissante.
+
+Les sociétés industrielles du XIXᵉ et du XXᵉ siècle développent à leur tour de nouvelles architectures archicratiques. Les réseaux de transport, les systèmes énergétiques, les dispositifs statistiques, les institutions de protection sociale ou les instruments de planification économique participent à la régulation des tensions produites par l’industrialisation, l’urbanisation et l’expansion des marchés.
+
+Chaque grande transformation historique peut ainsi être interprétée comme une reconfiguration de l’articulation entre arcalité, cratialité et archicration.
+
+Lorsque les dynamiques de transformation excèdent la capacité des architectures régulatrices à redistribuer les tensions, les sociétés entrent dans des phases de crise. Les structures stabilisatrices deviennent incapables d’absorber les forces qui les traversent. De nouvelles architectures doivent alors émerger pour rétablir une forme de co-viabilité.
+
+Dans cette perspective, l’histoire politique ne peut être comprise uniquement à partir de l’évolution des régimes visibles. Elle doit également être pensée comme une histoire des architectures archicratiques par lesquelles les sociétés organisent la régulation de leurs tensions internes.
+
+Or les transformations contemporaines semblent introduire une mutation particulière dans cette dynamique longue. Les dispositifs d’archicration deviennent de plus en plus intégrés à des infrastructures techniques et informationnelles complexes, capables de traiter les tensions sociales à travers des systèmes de calcul, de mesure et d’automatisation.
+
+Cette transformation ouvre la possibilité d’un déplacement majeur dans l’histoire de l’archicratie : le passage vers des configurations où les architectures régulatrices tendent à acquérir une autonomie croissante à l’égard des scènes politiques traditionnelles.
+
+C’est cette mutation contemporaine qu’il convient désormais d’examiner.
+
+## V — La mutation contemporaine : vers l’autarchicratie
+
+Si l’archicratie correspond à l’articulation entre arcalité, cratialité et archicration, alors chaque transformation majeure des infrastructures sociales modifie nécessairement la manière dont les sociétés régulent leurs tensions internes. L’histoire des sociétés humaines peut ainsi être comprise comme une succession de configurations archicratiques distinctes, dans lesquelles les structures stabilisatrices, les dynamiques de transformation et les mécanismes de régulation s’articulent selon des équilibres variables.
+
+Les sociétés contemporaines traversent aujourd’hui une mutation profonde de cette articulation.
+
+Depuis plusieurs décennies, les infrastructures techniques, informationnelles et organisationnelles qui structurent les sociétés connaissent une transformation d’une ampleur inédite. L’expansion des réseaux numériques, la circulation massive de données, la généralisation des dispositifs de mesure et l’intégration croissante de systèmes de calcul dans les processus décisionnels modifient profondément les architectures par lesquelles les tensions collectives sont traitées.
+
+Dans cette transformation, l’arcalité des sociétés se reconfigure. Aux structures institutionnelles et administratives héritées des sociétés industrielles s’ajoutent désormais des architectures techniques complexes : réseaux numériques globaux, infrastructures de données, systèmes algorithmiques, plateformes numériques, dispositifs automatisés de gestion et d’évaluation. Ces infrastructures deviennent progressivement des éléments constitutifs de l’environnement dans lequel se déploient les interactions sociales, économiques et politiques.
+
+Parallèlement, la cratialité des sociétés s’intensifie. Les flux économiques se mondialisent, les innovations technologiques se succèdent à un rythme accéléré, les transformations écologiques introduisent de nouvelles pressions systémiques, tandis que les dynamiques informationnelles multiplient les interactions et les rétroactions entre acteurs sociaux. Les sociétés contemporaines sont ainsi traversées par des dynamiques de transformation d’une densité et d’une vitesse inédites.
+
+Dans ce contexte, la fonction d’archicration — c’est-à-dire la capacité des sociétés à réguler les tensions entre structures et dynamiques — tend à se reconfigurer profondément.
+
+Traditionnellement, cette régulation reposait sur des dispositifs institutionnels relativement identifiables : administrations publiques, cadres juridiques, mécanismes politiques de décision, instruments économiques de régulation. Ces dispositifs rendaient visible, au moins partiellement, l’organisation de la régulation sociale. Ils pouvaient être contestés, modifiés ou réorientés à travers des procédures politiques ou institutionnelles.
+
+Or les architectures contemporaines d’archicration tendent de plus en plus à s’inscrire dans des infrastructures techniques distribuées. Les dispositifs de calcul, les modèles algorithmiques, les systèmes d’information et les architectures de données participent désormais directement à la régulation des flux économiques, des interactions sociales et des décisions collectives.
+
+Les dispositifs statistiques orientent les politiques publiques. Les indicateurs de performance conditionnent l’allocation des ressources. Les systèmes algorithmiques hiérarchisent l’accès à l’information, organisent la visibilité des contenus ou anticipent certains comportements sociaux. Les plateformes numériques structurent des espaces entiers d’interaction économique et culturelle.
+
+Ces dispositifs ne remplacent pas nécessairement les institutions politiques. Mais ils transforment profondément les conditions dans lesquelles celles-ci opèrent.
+
+La régulation des tensions collectives ne disparaît pas ; elle se déplace.
+
+Elle s’inscrit dans des architectures techniques, dans des chaînes de calcul, dans des infrastructures informationnelles et dans des systèmes de mesure qui orientent les dynamiques sociales sans apparaître toujours comme des lieux explicites de décision politique.
+
+Ce déplacement marque une mutation majeure de l’archicration contemporaine.
+
+À mesure que les architectures techniques deviennent plus complexes et plus intégrées, les mécanismes de régulation peuvent acquérir une forme d’autonomie relative par rapport aux scènes politiques dans lesquelles ils pourraient être discutés, contestés ou transformés. Les dispositifs continuent d’organiser la régulation des tensions collectives, mais leur fonctionnement devient plus difficile à appréhender dans sa totalité.
+
+C’est cette configuration particulière que l’on peut désigner par le terme d’autarchicratie.
+
+L’autarchicratie ne correspond pas à la disparition de l’archicratie. Elle désigne au contraire une situation dans laquelle les architectures régulatrices deviennent partiellement autonomes par rapport aux espaces publics de délibération et de décision. Les dispositifs techniques, administratifs ou informationnels continuent d’organiser la régulation sociale, mais ils tendent à se refermer sur leurs propres logiques opératoires.
+
+Dans une configuration autarchicratique, les mécanismes d’archicration demeurent actifs, mais leur intelligibilité collective se réduit. Les sociétés continuent de se réguler, mais elles perdent progressivement la capacité de comprendre, de discuter et d’orienter les architectures qui assurent cette régulation.
+
+La question politique contemporaine se déplace alors.
+
+Elle ne concerne plus seulement la distribution de l’autorité ou les formes institutionnelles du pouvoir. Elle concerne la capacité des sociétés à maintenir un rapport réflexif avec les architectures techniques, administratives et informationnelles qui structurent leur propre fonctionnement.
+
+Elle concerne la possibilité de faire comparaître l’archicratie dans l’espace du débat public.
+
+Car si l’archicratie désigne les architectures par lesquelles les sociétés organisent leur propre tenue, l’autarchicratie désigne la situation dans laquelle ces architectures cessent d’être pleinement exposées à la délibération et à la transformation collective.
+
+La mutation contemporaine de l’archicratie ne se réduit donc pas à l’expansion des technologies numériques. Elle correspond à une transformation plus profonde de l’articulation entre arcalité, cratialité et archicration.
+
+Les sociétés contemporaines doivent désormais réguler des dynamiques d’une intensité et d’une complexité croissantes à travers des architectures techniques qui tendent elles-mêmes à devenir des environnements structurants de l’action collective.
+
+Dans ce contexte, la question centrale n’est plus simplement celle du gouvernement des sociétés, mais celle de la maîtrise collective des architectures qui assurent leur co-viabilité.
+
+C’est dans cet écart entre archicratie et autarchicratie que se joue aujourd’hui une part décisive de l’avenir politique des sociétés humaines.
+
+## VI — Quatre scènes de gouvernance algorithmique
+
+Les transformations contemporaines de l’archicratie deviennent particulièrement visibles lorsqu’on observe certains dispositifs concrets qui participent désormais à la régulation quotidienne des sociétés. Loin de constituer de simples outils techniques, ces dispositifs s’insèrent dans les architectures d’archicration et contribuent directement à la redistribution des tensions collectives.
+
+Quatre scènes permettent d’en prendre la mesure.
+
+### 1 — Le score administratif : gouverner par le calcul
+
+Dans de nombreuses administrations contemporaines, la gestion des politiques publiques s’appuie désormais sur des dispositifs algorithmiques capables de traiter des volumes considérables de données.
+
+Les systèmes d’évaluation du risque de fraude, les modèles prédictifs d’attribution de prestations et les dispositifs de priorisation administrative agrègent une multitude d’informations : revenus déclarés, historique administratif, données territoriales, statistiques socio-économiques.
+
+Dans plusieurs pays, ces systèmes participent directement à la sélection des dossiers à contrôler ou à la hiérarchisation des demandes.
+
+L’arcalité se manifeste ici dans l’architecture administrative et juridique de l’État social. La cratialité apparaît dans la pression exercée par la massification des demandes, les contraintes budgétaires et les exigences d’efficacité bureaucratique. L’archicration se déplace alors vers des dispositifs de calcul capables d’orienter la gestion de ces tensions.
+
+La décision administrative reste officiellement humaine, mais le calcul configure de plus en plus l’espace dans lequel elle devient possible.
+
+### 2 — La visibilité algorithmique : organiser l’espace public informationnel
+
+Une seconde scène archicratique apparaît dans l’organisation contemporaine de la visibilité publique.
+
+Les grandes plateformes numériques — YouTube, TikTok, Facebook, X ou Instagram — reposent sur des systèmes de recommandation capables de sélectionner et de hiérarchiser les contenus à partir d’une multitude de paramètres : interactions passées, signaux d’engagement, comportements d’utilisateurs comparables, prédictions d’attention.
+
+Ces systèmes décident en grande partie de ce qui devient visible ou invisible dans l’espace informationnel.
+
+Dans cette configuration, l’arcalité réside dans l’infrastructure technique des plateformes et dans leurs architectures logicielles. La cratialité se manifeste dans la production massive de contenus et dans la compétition pour l’attention collective. L’archicration se déploie dans les algorithmes qui redistribuent l’attention sociale en hiérarchisant l’accès à la visibilité.
+
+Une part croissante de l’espace public contemporain est ainsi structurée par des architectures de calcul qui orientent la circulation des informations et la formation des opinions.
+
+### 3 — La régulation automatisée des flux économiques
+
+Une troisième scène archicratique apparaît dans la gestion algorithmique des flux économiques.
+
+Les plateformes de transport, les systèmes logistiques mondiaux, les marchés financiers automatisés ou les dispositifs de tarification dynamique reposent désormais sur des infrastructures capables d’ajuster en temps réel l’allocation de ressources.
+
+Les prix peuvent varier en fonction de la demande instantanée. Les trajets sont redistribués entre conducteurs et passagers par des algorithmes d’optimisation. Les marchés financiers voient circuler des flux de capitaux pilotés par des programmes capables d’exécuter des milliers d’opérations par seconde.
+
+Dans ces architectures, l’arcalité correspond aux infrastructures économiques et logistiques qui structurent les réseaux de production et d’échange. La cratialité se manifeste dans les fluctuations permanentes de l’offre, de la demande et de la concurrence. L’archicration se déploie dans les systèmes de calcul qui redistribuent en continu ces tensions.
+
+La régulation économique devient ainsi partiellement inscrite dans des architectures techniques capables d’organiser la circulation des flux à une vitesse et à une échelle inédites.
+
+### 4 — L’archicration sécuritaire : Palantir et la guerre algorithmique
+
+Une quatrième scène archicratique apparaît dans le domaine de la sécurité et de la guerre.
+
+Des systèmes d’analyse de données massives comme ceux développés par la société **Palantir** permettent aujourd’hui d’agréger d’immenses volumes d’informations provenant de sources multiples : bases administratives, données de surveillance, communications numériques, informations géographiques ou flux logistiques.
+
+Ces plateformes sont utilisées par des agences de renseignement, des forces de police ou des armées pour cartographier des réseaux, identifier des corrélations invisibles à l’œil humain et orienter des opérations de sécurité.
+
+Dans le même temps, le développement des **armes autonomes** et des systèmes militaires pilotés par intelligence artificielle introduit la possibilité d’une régulation partiellement automatisée de la violence organisée.
+
+Dans ces configurations, l’arcalité correspond aux infrastructures sécuritaires et militaires qui structurent les appareils d’État. La cratialité apparaît dans la complexité croissante des menaces, des conflits asymétriques et des flux d’information stratégiques. L’archicration se déploie dans des architectures de calcul capables d’intégrer et d’analyser des données à grande échelle afin d’orienter les décisions opérationnelles.
+
+L’archicration entre ainsi dans un domaine où les enjeux ne concernent plus seulement l’organisation de l’économie ou de l’information, mais la gestion même de la violence collective.
+
+### L’archicratie à l’ère des architectures de calcul
+
+Ces quatre scènes ne constituent pas des anomalies isolées. Elles illustrent une transformation structurelle des architectures archicratiques contemporaines.
+
+La régulation des tensions sociales, économiques, informationnelles et sécuritaires s’inscrit de plus en plus dans des infrastructures techniques capables de traiter des volumes d’information considérables et de redistribuer en temps réel les équilibres collectifs.
+
+Autrement dit, l’archicration tend désormais à se déployer au cœur même des architectures de calcul qui structurent les sociétés contemporaines.
+
+C’est précisément ce déplacement qui ouvre la possibilité d’une dérive autarchicratique : la situation dans laquelle les architectures de régulation deviennent progressivement moins visibles, moins intelligibles et moins contestables pour les sociétés qu’elles organisent.
+
+## VII — Ce que change le concept d’archicratie
+
+Introduire le concept d’archicratie ne consiste pas simplement à ajouter une notion supplémentaire au vocabulaire de la théorie politique. Cela implique un déplacement décisif : un changement de perspective sur ce qui fait réellement tenir les sociétés humaines.
+
+La tradition politique moderne s’est principalement construite autour de la question du pouvoir : qui gouverne, qui décide, selon quelles règles et au nom de quelle légitimité. Cette perspective a permis de penser les institutions politiques, les formes de la souveraineté, les mécanismes de la représentation et les conditions de la légitimité démocratique.
+
+Mais elle repose implicitement sur une hypothèse rarement interrogée : celle selon laquelle la stabilité des sociétés dépend principalement de leurs institutions politiques visibles.
+
+Or l’analyse archicratique montre que cette hypothèse est insuffisante.
+
+Les sociétés ne tiennent pas uniquement par leurs régimes politiques. Elles tiennent par l’ensemble des architectures matérielles, techniques, normatives et organisationnelles qui rendent possible la régulation des tensions collectives.
+
+Le concept d’archicratie permet ainsi de déplacer la focale de la théorie politique : du pouvoir visible vers les architectures de régulation qui structurent la co-viabilité sociale.
+
+Ce déplacement produit plusieurs conséquences importantes.
+
+### 1 — Déplacer l’objet de la théorie politique
+
+La première conséquence concerne l’objet même de la théorie politique.
+
+Traditionnellement, celle-ci s’intéresse aux institutions qui exercent explicitement le pouvoir : gouvernements, parlements, administrations, tribunaux, partis politiques.
+
+L’approche archicratique invite à élargir ce champ d’analyse.
+
+Les infrastructures techniques, les architectures informationnelles, les dispositifs statistiques, les systèmes de mesure ou les plateformes numériques deviennent également des objets pleinement politiques, dans la mesure où ils participent directement à la régulation des tensions collectives.
+
+Autrement dit, la politique ne se limite plus aux institutions qui gouvernent. Elle inclut les architectures qui organisent les conditions mêmes de la gouvernabilité des sociétés.
+
+### 2 — Repenser la crise politique contemporaine
+
+La seconde conséquence concerne l’interprétation des crises politiques contemporaines.
+
+Les analyses dominantes expliquent souvent ces crises par un déficit de représentation, une perte de confiance dans les institutions ou une fragmentation de l’espace public.
+
+Ces facteurs sont réels. Mais l’analyse archicratique suggère qu’ils ne suffisent pas à expliquer la situation actuelle.
+
+Les crises contemporaines peuvent également être interprétées comme des crises d’archicration : des situations dans lesquelles les architectures régulatrices existantes peinent à absorber les tensions produites par les transformations économiques, technologiques et écologiques.
+
+Lorsque l’articulation entre arcalité, cratialité et archicration se fragilise, les sociétés peuvent connaître des phases d’instabilité institutionnelle, de polarisation sociale ou de désorientation politique.
+
+Les tensions ne disparaissent pas ; elles deviennent simplement plus difficiles à réguler dans les architectures existantes.
+
+### 3 — Comprendre les transformations du pouvoir
+
+La troisième conséquence concerne la nature même du pouvoir dans les sociétés contemporaines.
+
+Dans la perspective classique, le pouvoir est principalement associé à la capacité de prendre des décisions contraignantes : voter une loi, imposer une règle, exercer une autorité.
+
+L’analyse archicratique montre qu’une part croissante du pouvoir contemporain s’exerce à travers la conception et l’organisation des architectures régulatrices.
+
+Définir les indicateurs qui orientent l’action publique, concevoir les systèmes d’information qui structurent les flux administratifs, paramétrer les algorithmes qui redistribuent la visibilité ou organiser les infrastructures qui pilotent les flux économiques constitue aujourd’hui une forme déterminante d’exercice du pouvoir.
+
+Le pouvoir ne disparaît pas ; il se déplace vers les architectures qui organisent les conditions mêmes de l’action collective.
+
+### 4 — Réouvrir la question politique
+
+Enfin, l’introduction du concept d’archicratie permet de reformuler la question politique elle-même.
+
+Si les sociétés se maintiennent par des architectures de régulation qui structurent leurs dynamiques internes, alors la question politique ne peut se limiter à la désignation des gouvernants ou à la distribution de l’autorité.
+
+Elle concerne également la capacité collective à comprendre, à discuter et à orienter les architectures qui assurent la co-viabilité sociale.
+
+Autrement dit, la politique devient aussi une question d’architecture.
+
+Il ne s’agit plus seulement de décider qui gouverne, mais de déterminer comment sont conçues, organisées et transformées les infrastructures matérielles, techniques et institutionnelles qui structurent la régulation des tensions collectives.
+
+### L’enjeu archicratique
+
+Dans cette perspective, l’enjeu central des sociétés contemporaines apparaît sous un jour nouveau.
+
+Il ne s’agit pas uniquement de préserver des institutions démocratiques formelles, mais de maintenir la capacité collective à faire comparaître les architectures régulatrices dans l’espace du débat public.
+
+Car si l’archicratie désigne les architectures par lesquelles les sociétés organisent leur propre tenue, l’autarchicratie désigne la situation dans laquelle ces architectures cessent d’être pleinement intelligibles et transformables pour les sociétés qu’elles structurent.
+
+La question politique contemporaine peut alors se formuler de manière simple :
+
+les sociétés humaines seront-elles capables de maintenir une maîtrise collective des architectures qui assurent leur co-viabilité, ou entreront-elles dans une phase où ces architectures fonctionneront de manière de plus en plus autonome ?
+
+C’est dans cet écart entre archicratie et autarchicratie que se joue aujourd’hui une part décisive de l’avenir politique du monde contemporain.
+
+## VIII — Conclusion
+
+### Faire comparaître les architectures qui nous gouvernent
+
+Les sociétés humaines ont longtemps pensé la politique à travers la question du pouvoir visible : qui gouverne, selon quelles règles et au nom de quelle légitimité. Cette interrogation demeure essentielle. Mais elle ne suffit plus à rendre intelligible la manière dont les sociétés contemporaines fonctionnent réellement.
+
+Car les sociétés ne tiennent pas uniquement par leurs institutions politiques explicites. Elles tiennent par les architectures matérielles, techniques, normatives et organisationnelles qui organisent la régulation permanente des tensions collectives. Ces architectures structurent la circulation des ressources, orientent les dynamiques économiques, redistribuent l’attention informationnelle et participent à la gestion des risques sociaux ou sécuritaires.
+
+C’est cet ensemble que désigne le concept d’archicratie.
+
+L’archicratie ne remplace pas les institutions politiques ; elle en constitue le soubassement opérationnel. Elle correspond au niveau où s’articulent les structures stabilisatrices, les dynamiques de transformation et les mécanismes de régulation qui permettent aux sociétés de maintenir leur co-viabilité.
+
+L’analyse archicratique invite ainsi à déplacer le regard. Elle conduit à considérer que les infrastructures techniques, les dispositifs administratifs, les architectures informationnelles ou les systèmes de calcul participent désormais directement à l’organisation du politique.
+
+Dans les sociétés contemporaines, une part croissante de la régulation collective s’inscrit dans ces architectures. Les indicateurs orientent les politiques publiques, les algorithmes redistribuent la visibilité informationnelle, les plateformes structurent les interactions économiques et les systèmes de calcul participent à la gestion des flux sociaux ou sécuritaires.
+
+La politique ne disparaît pas dans ces transformations ; elle change de lieu.
+
+Elle se déploie de plus en plus dans la conception et l’organisation des architectures qui structurent la régulation des sociétés.
+
+Mais ce déplacement ouvre également une tension nouvelle.
+
+Car à mesure que les architectures archicratiques deviennent plus complexes, plus techniques et plus intégrées à des infrastructures globales de calcul, elles peuvent progressivement s’éloigner des espaces où elles pourraient être comprises, discutées et transformées collectivement.
+
+C’est dans cette possibilité que réside le risque autarchicratique.
+
+Une société entre dans une configuration autarchicratique lorsque les architectures qui assurent sa régulation continuent de fonctionner tout en devenant de moins en moins intelligibles pour ceux qu’elles gouvernent. Les dispositifs demeurent efficaces, mais leur logique échappe progressivement à la délibération collective.
+
+La question politique centrale du XXIᵉ siècle pourrait bien se situer précisément à cet endroit.
+
+Il ne s’agit plus seulement de savoir qui gouverne, mais de déterminer si les sociétés humaines demeureront capables de comprendre, d’orienter et de transformer les architectures qui organisent leur propre tenue.
+
+Autrement dit : les architectures archicratiques continueront-elles de comparaître dans l’espace du débat collectif, ou entreront-elles dans une phase d’autonomisation où la régulation sociale se déploiera à travers des dispositifs de plus en plus opaques ?
+
+La théorie de l’archicratie ne prétend pas résoudre cette tension. Elle vise d’abord à la rendre visible.
+
+Nommer une réalité est souvent la première condition pour agir sur elle.
+
+En identifiant les architectures par lesquelles les sociétés organisent leur co-viabilité, le concept d’archicratie ouvre un nouveau champ d’analyse pour la théorie politique contemporaine. Il invite à penser ensemble les institutions visibles du pouvoir et les infrastructures plus profondes qui rendent leur fonctionnement possible.
+
+Comprendre l’archicratie, c’est ainsi reconnaître que la politique ne se joue pas seulement dans les lieux où l’autorité est proclamée, mais aussi dans les architectures où la régulation collective s’opère silencieusement.
+
+Faire comparaître ces architectures devient alors l’une des tâches essentielles de la pensée politique contemporaine.
+
+Car c’est dans leur capacité à comprendre et à orienter les architectures qui les gouvernent que se joue une part décisive de leur avenir.

src/content/config.ts

@@ -2,7 +2,7 @@ import { defineCollection, z } from "astro:content";
 
 const linkSchema = z.object({
   type: z.enum(["definition", "appui", "transposition"]),
-  target: z.string().min(1), // URL interne (ex: /glossaire/archicratie/) ou slug
+  target: z.string().min(1),
   note: z.string().optional()
 });
 
@@ -12,41 +12,38 @@ const baseTextSchema = z.object({
   version: z.string().min(1),
   concepts: z.array(z.string().min(1)).default([]),
   links: z.array(linkSchema).default([]),
-  // optionnels mais utiles dès maintenant
   order: z.number().int().nonnegative().optional(),
   summary: z.string().optional()
 });
 
 // Éditions (séparation stricte : edition + status verrouillés par collection)
-const traite = defineCollection({
-  type: "content",
-  schema: baseTextSchema.extend({
-    edition: z.literal("traite"),
-    status: z.literal("theorie_fondamentale")
-  })
-});
 
-const archicratie = defineCollection({
+const casIa = defineCollection({
   type: "content",
   schema: baseTextSchema.extend({
-    edition: z.literal("archicratie"),
-    status: z.literal("modele_sociopolitique")
-  })
-});
-
-const ia = defineCollection({
-  type: "content",
-  schema: baseTextSchema.extend({
-    edition: z.literal("ia"),
+    edition: z.literal("cas-ia"),
     status: z.literal("application")
   })
 });
 
-const atlas = defineCollection({
+const commencer = defineCollection({
   type: "content",
   schema: baseTextSchema.extend({
-    edition: z.literal("atlas"),
-    status: z.literal("cartographie")
+    edition: z.literal("commencer"),
+    status: z.union([z.literal("presentation"), z.literal("draft")])
+  })
+});
+
+// ✅ NOUVELLE collection : archicrat-ia (Essai-thèse)
+// NOTE : on accepte temporairement edition/status "archicratie/modele_sociopolitique"
+// si tes MDX n’ont pas encore été normalisés.
+// Quand tu voudras "strict", on passera à edition="archicrat-ia" status="essai_these"
+// + update frontmatter des 7 fichiers.
+const archicratIa = defineCollection({
+  type: "content",
+  schema: baseTextSchema.extend({
+    edition: z.union([z.literal("archicrat-ia"), z.literal("archicratie")]),
+    status: z.union([z.literal("essai_these"), z.literal("modele_sociopolitique")])
   })
 });
 
@@ -54,24 +51,28 @@ const atlas = defineCollection({
 const glossaire = defineCollection({
   type: "content",
   schema: z.object({
-    title: z.string().min(1), // Titre public (souvent identique au terme)
-    term: z.string().min(1),  // Terme canonique
+    title: z.string().min(1),
+    term: z.string().min(1),
     aliases: z.array(z.string().min(1)).default([]),
     edition: z.literal("glossaire"),
     status: z.literal("referentiel"),
     version: z.string().min(1),
-    // Micro-définition affichable en popover (courte, stable)
     definitionShort: z.string().min(1),
     concepts: z.array(z.string().min(1)).default([]),
-    // Liens typés (vers ouvrages ou autres termes)
-    links: z.array(linkSchema).default([])
+    links: z.array(linkSchema).default([]),
+
+    kind: z.enum(["concept", "topologie", "diagnostic", "verbe"]),
+    domain: z.enum(["transversal", "theorie", "cas-ia"]),
+    level: z.enum(["fondamental", "intermediaire", "avance"]),
+    related: z.array(z.string().min(1)).default([]),
+    opposedTo: z.array(z.string().min(1)).default([]),
+    seeAlso: z.array(z.string().min(1)).default([])
   })
 });
 
 export const collections = {
-  traite,
-  archicratie,
-  ia,
+  commencer,
+  "archicrat-ia": archicratIa,
+  "cas-ia": casIa,
   glossaire,
-  atlas
-};
+};

src/content/glossaire/arcalite.md

@@ -0,0 +1,41 @@
+---
+title: "Arcalité"
+term: "Arcalité"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Dimension structurelle d’un ordre social, institutionnel ou technique : ce qui stabilise, ordonne et cadre les formes d’action."
+concepts: ["arcalite", "archicratie", "archicration", "cratialite"]
+links: []
+kind: "concept"
+domain: "transversal"
+level: "fondamental"
+related: ["archicratie", "archicration", "cratialite"]
+opposedTo: []
+seeAlso: ["co-viabilite"]
+---
+
+L’arcalité désigne l’ensemble des structures relativement durables qui donnent consistance, forme et stabilité à un ordre social ou technique.
+
+## Distinction
+
+L’arcalité ne doit pas être confondue avec une simple institution isolée ni avec la totalité du pouvoir. Elle désigne la dimension structurante : règles, formes, dispositifs, cadres, organisations, infrastructures et invariants qui rendent certaines actions possibles et en contraignent d’autres.
+
+## Fonction dans le paradigme
+
+Dans le paradigme archicratique, l’arcalité correspond au pôle de structuration. Elle fournit la tenue, l’ordonnancement et la stabilité relative à l’intérieur desquels les dynamiques peuvent se déployer.
+
+## Usages
+
+Le terme permet d’analyser :
+- les formes de stabilisation institutionnelle ;
+- les architectures techniques ;
+- les dispositifs administratifs ;
+- les cadres normatifs et organisationnels.
+
+## Renvois
+
+- [Archicratie](/glossaire/archicratie/)
+- [Cratialité](/glossaire/cratialite/)
+- [Archicration](/glossaire/archicration/)

src/content/glossaire/archicratie.md

@@ -4,11 +4,39 @@ term: "Archicratie"
 aliases: ["Paradigme archicratique"]
 edition: "glossaire"
 status: "referentiel"
-version: "0.0.1"
-definitionShort: "Régime où l’instance régulatrice est tenue d’exposer ses prises, ses critères et ses scènes d’épreuve."
-concepts: ["archicratie"]
+version: "0.1.0"
+definitionShort: "Régime d’intelligibilité et d’analyse centré sur les architectures de régulation qui rendent possible la co-viabilité des sociétés complexes."
+concepts: ["archicratie", "arcalite", "cratialite", "archicration", "co-viabilite"]
 links: []
+kind: "concept"
+domain: "transversal"
+level: "fondamental"
+related: ["arcalite", "cratialite", "archicration", "co-viabilite"]
+opposedTo: ["autarchicratie"]
+seeAlso: ["scene-depreuve", "obliteration-archicratique"]
 ---
 
-Définition longue (à enrichir).  
-Ici, on mettra la définition complète, les usages, les distinctions, et des renvois typés.
+L’archicratie désigne le cadre théorique à partir duquel les sociétés sont analysées non seulement à travers leurs institutions visibles ou leurs régimes déclarés, mais à partir des architectures de régulation qui rendent possible leur tenue effective.
+
+## Distinction
+
+L’archicratie n’est pas un régime politique supplémentaire venant s’ajouter à la longue série des termes en *-cratie*. Elle ne désigne ni une forme constitutionnelle particulière, ni une simple technique de gouvernement. Elle sert à nommer un niveau plus profond : celui des architectures matérielles, normatives, organisationnelles, informationnelles et symboliques qui conditionnent l’exercice et la transformation du pouvoir.
+
+## Fonction dans le paradigme
+
+Le concept d’archicratie permet de déplacer l’analyse politique de la seule surface institutionnelle vers les conditions architecturales de la régulation collective. Il constitue le concept central du paradigme, celui qui articule l’arcalité, la cratialité et l’archicration.
+
+## Usages
+
+Le terme est mobilisé pour penser :
+- les architectures de régulation des sociétés complexes ;
+- la distribution des puissances d’agir ;
+- les conditions de co-viabilité ;
+- les transformations contemporaines du pouvoir.
+
+## Renvois
+
+- [Arcalité](/glossaire/arcalite/)
+- [Cratialité](/glossaire/cratialite/)
+- [Archicration](/glossaire/archicration/)
+- [Co-viabilité](/glossaire/co-viabilite/)

src/content/glossaire/archicration.md

@@ -0,0 +1,42 @@
+---
+title: "Archicration"
+term: "Archicration"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Scène de mise en visibilité, d’épreuve et de révision où arcalité et cratialité peuvent comparaître ensemble."
+concepts: ["archicration", "archicratie", "arcalite", "cratialite"]
+links: []
+kind: "concept"
+domain: "transversal"
+level: "fondamental"
+related: ["archicratie", "arcalite", "cratialite", "scene-depreuve"]
+opposedTo: ["obliteration-archicratique"]
+seeAlso: ["autarchicratie"]
+---
+
+L’archicration désigne la scène ou la configuration d’épreuve dans laquelle les structures d’un ordre et ses prises effectives peuvent être amenées ensemble en visibilité, en confrontation et en révision.
+
+## Distinction
+
+L’archicration n’est ni l’arcalité elle-même, ni la cratialité seule. Elle correspond à leur comparution conjointe : le lieu où peuvent être interrogés les fondements, les modes opératoires, les critères, les effets et les conditions de transformation d’un ordre régulateur.
+
+## Fonction dans le paradigme
+
+L’archicration joue un rôle central : elle rend possible l’intelligibilité critique d’une régulation. Sans archicration, l’ordre peut continuer à fonctionner, mais il tend à se soustraire à la scène d’épreuve.
+
+## Usages
+
+Le concept est mobilisé pour analyser :
+- les scènes de justification ;
+- les procédures de révision ;
+- les dispositifs de comparution ;
+- les conditions de visibilité du pouvoir régulateur.
+
+## Renvois
+
+- [Archicratie](/glossaire/archicratie/)
+- [Arcalité](/glossaire/arcalite/)
+- [Cratialité](/glossaire/cratialite/)
+- [Scène d’épreuve](/glossaire/scene-depreuve/)

src/content/glossaire/autarchicratie.md

@@ -0,0 +1,42 @@
+---
+title: "Autarchicratie"
+term: "Autarchicratie"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Tendance d’une architecture régulatrice à fonctionner selon sa propre logique opératoire en se soustrayant de plus en plus à la scène d’épreuve."
+concepts: ["autarchicratie", "archicratie", "archicration", "obliteration-archicratique"]
+links: []
+kind: "diagnostic"
+domain: "transversal"
+level: "fondamental"
+related: ["archicratie", "archicration", "obliteration-archicratique"]
+opposedTo: ["archicratie"]
+seeAlso: ["scene-depreuve"]
+---
+
+L’autarchicratie désigne la dynamique par laquelle une architecture de régulation tend à acquérir une autonomie croissante, au point de fonctionner selon ses propres logiques de reproduction et d’extension.
+
+## Distinction
+
+L’autarchicratie ne signifie pas nécessairement la disparition des institutions visibles. Elle désigne plus subtilement le déplacement du centre de gravité du pouvoir vers des architectures qui continuent d’opérer, même lorsque leur exposition critique devient faible ou fictive.
+
+## Fonction dans le paradigme
+
+Le concept permet de diagnostiquer un basculement : celui d’une régulation qui demeure efficace, mais qui se soustrait progressivement à la comparution, à la révision et à la visibilité.
+
+## Usages
+
+Il sert à analyser :
+- l’autonomisation des systèmes techniques ;
+- la fermeture des chaînes régulatrices ;
+- les logiques de pilotage automatisé ;
+- les tendances contemporaines à la régulation hors scène.
+
+## Renvois
+
+- [Archicratie](/glossaire/archicratie/)
+- [Archicration](/glossaire/archicration/)
+- [Scène d’épreuve](/glossaire/scene-depreuve/)
+- [Oblitération archicratique](/glossaire/obliteration-archicratique/)

src/content/glossaire/co-viabilite.md

@@ -0,0 +1,42 @@
+---
+title: "Co-viabilité"
+term: "Co-viabilité"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Capacité d’un ensemble social à maintenir compatibles ses dynamiques internes sans se désagréger."
+concepts: ["co-viabilite", "archicratie", "arcalite", "cratialite", "archicration"]
+links: []
+kind: "concept"
+domain: "transversal"
+level: "fondamental"
+related: ["archicratie", "arcalite", "cratialite", "archicration"]
+opposedTo: []
+seeAlso: ["autarchicratie"]
+---
+
+La co-viabilité désigne la capacité d’un système social à absorber, redistribuer et organiser les tensions qui le traversent de manière à préserver la continuité de la vie collective.
+
+## Distinction
+
+La co-viabilité ne désigne ni l’absence de conflit ni l’harmonie parfaite. Elle renvoie à une compatibilité dynamique entre forces hétérogènes, rendue possible par des architectures de régulation suffisamment robustes pour empêcher la désagrégation.
+
+## Fonction dans le paradigme
+
+La co-viabilité est l’un des critères centraux de l’analyse archicratique : elle permet d’évaluer la capacité d’une société à tenir malgré ses tensions.
+
+## Usages
+
+Le terme est mobilisé pour penser :
+- la stabilité dynamique des sociétés complexes ;
+- la régulation des tensions internes ;
+- la tenue des ordres sociaux ;
+- l’évaluation des architectures régulatrices.
+
+## Renvois
+
+- [Archicratie](/glossaire/archicratie/)
+- [Arcalité](/glossaire/arcalite/)
+- [Cratialité](/glossaire/cratialite/)
+- [Archicration](/glossaire/archicration/)

src/content/glossaire/cratialite.md

@@ -0,0 +1,41 @@
+---
+title: "Cratialité"
+term: "Cratialité"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Dimension opératoire et dynamique d’un ordre : ensemble des prises effectives, des chaînes d’action et des puissances d’exécution."
+concepts: ["cratialite", "archicratie", "archicration", "arcalite"]
+links: []
+kind: "concept"
+domain: "transversal"
+level: "fondamental"
+related: ["archicratie", "archicration", "arcalite"]
+opposedTo: []
+seeAlso: ["autarchicratie"]
+---
+
+La cratialité désigne la dimension effective, dynamique et opératoire d’un ordre : ce par quoi il agit, s’applique, se déploie et transforme la réalité sociale.
+
+## Distinction
+
+La cratialité ne se réduit ni à la seule force brute, ni à l’autorité juridique. Elle renvoie à l’ensemble des prises effectives : instruments, chaînes de décision, moyens d’exécution, dispositifs de calcul, procédures, flux et mécanismes par lesquels une régulation devient agissante.
+
+## Fonction dans le paradigme
+
+Dans le paradigme archicratique, la cratialité correspond au pôle d’effectuation. Là où l’arcalité stabilise, la cratialité opère, mobilise et redistribue les puissances d’action.
+
+## Usages
+
+Le terme sert à analyser :
+- les chaînes d’exécution ;
+- les dispositifs techniques et informationnels ;
+- les capacités effectives d’intervention ;
+- les modes opératoires de la régulation.
+
+## Renvois
+
+- [Archicratie](/glossaire/archicratie/)
+- [Arcalité](/glossaire/arcalite/)
+- [Archicration](/glossaire/archicration/)

src/content/glossaire/obliteration-archicratique.md

@@ -0,0 +1,42 @@
+---
+title: "Oblitération archicratique"
+term: "Oblitération archicratique"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Processus par lequel les scènes d’épreuve et les conditions de visibilité d’une régulation se trouvent effacées, neutralisées ou rendues inopérantes."
+concepts: ["obliteration-archicratique", "archicration", "autarchicratie", "scene-depreuve"]
+links: []
+kind: "diagnostic"
+domain: "transversal"
+level: "fondamental"
+related: ["archicration", "autarchicratie", "scene-depreuve"]
+opposedTo: []
+seeAlso: ["archicratie"]
+---
+
+L’oblitération archicratique désigne le processus par lequel un ordre régulateur continue de fonctionner tout en effaçant les conditions de sa propre comparution critique.
+
+## Distinction
+
+Il ne s’agit pas simplement d’un manque de transparence. L’oblitération archicratique renvoie à une perte plus profonde : celle des scènes où les prises, les critères et les effets d’une régulation pourraient être véritablement mis à l’épreuve.
+
+## Fonction dans le paradigme
+
+Ce concept permet de nommer l’une des pathologies majeures de l’époque contemporaine : la poursuite de régulations puissantes en dehors des formes effectives de visibilité et de révision.
+
+## Usages
+
+Le terme sert à analyser :
+- l’effacement des scènes de comparution ;
+- les régulations invisibilisées ;
+- les architectures qui opèrent sans exposition réelle ;
+- la montée de l’autarchicratie.
+
+## Renvois
+
+- [Archicration](/glossaire/archicration/)
+- [Scène d’épreuve](/glossaire/scene-depreuve/)
+- [Autarchicratie](/glossaire/autarchicratie/)
+- [Archicratie](/glossaire/archicratie/)

src/content/glossaire/scene-depreuve.md

@@ -0,0 +1,41 @@
+---
+title: "Scène d’épreuve"
+term: "Scène d’épreuve"
+aliases: []
+edition: "glossaire"
+status: "referentiel"
+version: "0.1.0"
+definitionShort: "Configuration dans laquelle un ordre, ses critères et ses prises peuvent être exposés, interrogés et mis à l’épreuve."
+concepts: ["scene-depreuve", "archicration", "archicratie"]
+links: []
+kind: "concept"
+domain: "transversal"
+level: "fondamental"
+related: ["archicration", "archicratie", "obliteration-archicratique"]
+opposedTo: []
+seeAlso: ["autarchicratie"]
+---
+
+La scène d’épreuve désigne le lieu, le dispositif ou la configuration dans laquelle une régulation peut comparaître et être soumise à une exigence de justification, de critique ou de révision.
+
+## Distinction
+
+Une scène d’épreuve n’est pas une simple formalité procédurale. Elle suppose qu’un ordre puisse être réellement exposé : ses critères, ses prises, ses effets et ses conditions d’action doivent pouvoir y être examinés.
+
+## Fonction dans le paradigme
+
+La scène d’épreuve est l’une des conditions concrètes de l’archicration. Là où elle manque, la régulation tend à s’opacifier et à se dérober à la critique.
+
+## Usages
+
+Le terme sert à analyser :
+- les lieux de comparution ;
+- les dispositifs de justification ;
+- les procédures de recours et de révision ;
+- la qualité critique d’un ordre régulateur.
+
+## Renvois
+
+- [Archicration](/glossaire/archicration/)
+- [Archicratie](/glossaire/archicratie/)
+- [Oblitération archicratique](/glossaire/obliteration-archicratique/)

src/content/ia/00-demarrage.md

@@ -1,13 +0,0 @@
----
-title: "Démarrage — Cas pratique IA"
-edition: "ia"
-status: "application"
-level: 1
-version: "0.0.1"
-concepts: ["gouvernance-ia"]
-links: []
-order: 0
-summary: "Page de test (structure)."
----
-
-Ceci est une page de test pour valider la structure du **Cas pratique IA**.

src/content/traite/00-demarrage.md

@@ -1,13 +0,0 @@
----
-title: "Démarrage — Traité"
-edition: "traite"
-status: "theorie_fondamentale"
-level: 1
-version: "0.0.1"
-concepts: ["ontodynamique-generative"]
-links: []
-order: 0
-summary: "Page de test (structure)."
----
-
-Ceci est une page de test pour valider la structure du **Traité**.

src/layouts/EditionLayout.astro

@@ -5,6 +5,7 @@ import LevelToggle from "../components/LevelToggle.astro";
 import BuildStamp from "../components/BuildStamp.astro";
 import SidePanel from "../components/SidePanel.astro";
 import "../styles/global.css";
+import "../styles/panel.css";
 
 const {
   title,
@@ -261,17 +262,24 @@ const WHOAMI_FORCE_LOCALHOST = (import.meta.env.PUBLIC_WHOAMI_FORCE_LOCALHOST ??
         padding: var(--page-gap) 16px 48px;
       }
 
+      /* ✅ Grille robustifiée + panel plus confortable (base) */
       .page-shell{
         --aside-w: 320px;
         --reading-w: 78ch;
-        --panel-w: 380px;
+        --panel-w: 420px;
         --gap: 18px;
 
-        max-width: calc(var(--aside-w) + var(--reading-w) + var(--panel-w) + (var(--gap) * 2));
+        max-width: min(
+          calc(var(--aside-w) + var(--reading-w) + var(--panel-w) + (var(--gap) * 2)),
+          calc(100vw - 32px)
+        );
         margin: 0 auto;
 
         display: grid;
-        grid-template-columns: var(--aside-w) minmax(0, var(--reading-w)) var(--panel-w);
+        grid-template-columns:
+          var(--aside-w)
+          minmax(0, var(--reading-w))
+          minmax(0, var(--panel-w));
         column-gap: var(--gap);
         align-items: start;
       }
@@ -346,23 +354,38 @@ const WHOAMI_FORCE_LOCALHOST = (import.meta.env.PUBLIC_WHOAMI_FORCE_LOCALHOST ??
       }
       :global(body[data-reading-level="1"]) .page-panel{ display: none !important; }
 
-      /* Niveau 3 : lecture plus étroite + panel large ; TOC masqué */
+      /* Niveau 3 : lecture plus étroite + panel LARGE ; TOC masqué */
       :global(body[data-reading-level="3"]) .page-shell{
-        --reading-w: 62ch;
-        --panel-w: 560px;
-        max-width: calc(var(--reading-w) + var(--panel-w) + (var(--gap) * 1));
-        grid-template-columns: minmax(0, var(--reading-w)) var(--panel-w);
+        --reading-w: 60ch;
+        --panel-w: clamp(720px, 48vw, 940px);
+
+        max-width: min(
+          calc(var(--reading-w) + var(--panel-w) + var(--gap)),
+          calc(100vw - 32px)
+        );
+
+        grid-template-columns:
+          minmax(0, var(--reading-w))
+          minmax(0, var(--panel-w));
       }
       :global(body[data-reading-level="3"]) .page-aside{ display: none; }
       :global(body[data-reading-level="3"]) .reading{ grid-column: 1; }
 
-      /* Niveau 4 : TOC à gauche + panel */
+      /* Niveau 4 : TOC à gauche + panel confortable */
       :global(body[data-reading-level="4"]) .page-shell{
         --aside-w: 320px;
         --reading-w: 64ch;
-        --panel-w: 520px;
-        max-width: calc(var(--aside-w) + var(--reading-w) + var(--panel-w) + (var(--gap) * 2));
-        grid-template-columns: var(--aside-w) minmax(0, var(--reading-w)) var(--panel-w);
+        --panel-w: clamp(520px, 36vw, 720px);
+
+        max-width: min(
+          calc(var(--aside-w) + var(--reading-w) + var(--panel-w) + (var(--gap) * 2)),
+          calc(100vw - 32px)
+        );
+
+        grid-template-columns:
+          var(--aside-w)
+          minmax(0, var(--reading-w))
+          minmax(0, var(--panel-w));
       }
       :global(body[data-reading-level="4"]) .page-aside{ display: block; }
       :global(body[data-reading-level="4"]) .reading{ grid-column: 2; }
@@ -1158,6 +1181,45 @@ const WHOAMI_FORCE_LOCALHOST = (import.meta.env.PUBLIC_WHOAMI_FORCE_LOCALHOST ??
     });
   });
 
+  /* ✅ NOUVEAU : clic paragraphe => snap sous reading-follow + SidePanel aligné */
+  safe("click-para-align", () => {
+    if (!reading) return;
+
+    reading.addEventListener("click", (ev) => {
+      try {
+        const t = ev.target;
+
+        // ne pas casser les boutons / liens / para-tools
+        if (t && t.closest && t.closest(".para-tools")) return;
+        const a = t && t.closest ? t.closest("a") : null;
+        if (a) return;
+
+        const p = t && t.closest ? t.closest('.reading p[id^="p-"]') : null;
+        if (!p || !p.id) return;
+
+        // si sélection texte en cours => ne pas snap
+        const sel = window.getSelection ? window.getSelection() : null;
+        if (sel && !sel.isCollapsed) return;
+
+        openDetailsIfNeeded(p);
+
+        // snap immédiat sous followbar
+        scrollToElWithOffset(p, 12, "auto");
+
+        // URL stable
+        history.replaceState(null, "", `${location.pathname}#${p.id}`);
+
+        // force la source de vérité (SidePanel suit via event archicratie:currentPara)
+        __hoverParaId = "";
+        __activeParaId = p.id;
+        setCurrentPara(p.id, "click");
+
+        writeLastSeen(p.id);
+        updateResumeButton();
+      } catch {}
+    }, { passive: true });
+  });
+
   // ===== Hash handling (robuste) =====
   function resolveParaIdFromEl(el) {
     if (!el) return "";
@@ -1281,8 +1343,6 @@ const WHOAMI_FORCE_LOCALHOST = (import.meta.env.PUBLIC_WHOAMI_FORCE_LOCALHOST ??
 
     const h1 = reading.querySelector("h1");
 
-    // ✅ FIX: ne pas dépendre du tag <span>; accepter .details-anchor quel que soit le tag,
-    // et utiliser <details> comme marker (top fiable) pour que rf-h2 s'affiche correctement.
     const h2Anchors = Array.from(reading.querySelectorAll(".details-anchor[id]"))
       .map((s) => {
         const d = (s.nextElementSibling && s.nextElementSibling.tagName === "DETAILS")
@@ -1572,4 +1632,4 @@ const WHOAMI_FORCE_LOCALHOST = (import.meta.env.PUBLIC_WHOAMI_FORCE_LOCALHOST ??
 })();
     </script>
   </body>
-</html>
+</html>

src/pages/annotations-index.json.ts

@@ -103,10 +103,16 @@ export const GET: APIRoute = async () => {
   const errors: Array<{ file: string; error: string }> = [];
 
   let files: string[] = [];
+  let missingRoot = false;
+
   try {
     files = await walk(ANNO_ROOT);
   } catch (e: any) {
-    throw new Error(`Missing annotations root: ${ANNO_ROOT} (${e?.message || e})`);
+    // ✅ FAIL-OPEN : pas d’annotations => index vide (ne casse pas la build)
+    missingRoot = true;
+    console.warn(`[annotations-index] Missing annotations root: ${ANNO_ROOT} (${e?.message || e})`);
+    files = [];
+    // ✅ surtout PAS d'errors.push ici
   }
 
   for (const fp of files) {
@@ -177,6 +183,14 @@ export const GET: APIRoute = async () => {
     pg.paras = next;
   }
 
+  const warnings: Array<{ where: string; warning: string }> = [];
+  if (missingRoot) {
+    warnings.push({
+      where: "src/pages/annotations-index.json.ts",
+      warning: `Missing annotations root "${ANNO_ROOT}" (treated as empty).`,
+    });
+  }
+
   const out = {
     schema: 1,
     generatedAt: new Date().toISOString(),
@@ -186,10 +200,13 @@ export const GET: APIRoute = async () => {
       paras: Object.values(pages).reduce((n, p) => n + Object.keys(p.paras || {}).length, 0),
       errors: errors.length,
     },
+    warnings,
     errors,
   };
 
-  if (errors.length) {
+  // ✅ FAIL-OPEN uniquement si le dossier manque.
+  // Si le dossier existe mais qu’un YAML est cassé -> fail-closed.
+  if (errors.length && !missingRoot) {
     throw new Error(`${errors[0].file}: ${errors[0].error}`);
   }
 

src/pages/archicrat-ia/[...slug].astro

@@ -5,12 +5,11 @@ import EditionToc from "../../components/EditionToc.astro";
 import LocalToc from "../../components/LocalToc.astro";
 
 export async function getStaticPaths() {
-  const entries = (await getCollection("archicratie"))
-    .filter((e) => e.slug.startsWith("archicrat-ia/"));
+  // ✅ Après migration : plus de filtre par prefix, on prend toute la collection
+  const entries = await getCollection("archicrat-ia");
 
   return entries.map((entry) => ({
-    // ✅ inline : jamais de helper externe (évite "stripPrefix is not defined")
-    params: { slug: entry.slug.replace(/^archicrat-ia\//, "") },
+    params: { slug: entry.slug },
     props: { entry },
   }));
 }
@@ -35,4 +34,4 @@ const { Content, headings } = await entry.render();
 
   <h1>{entry.data.title}</h1>
   <Content />
-</EditionLayout>
+</EditionLayout>

src/pages/archicrat-ia/index.astro

@@ -2,13 +2,12 @@
 import SiteLayout from "../../layouts/SiteLayout.astro";
 import { getCollection } from "astro:content";
 
-const entries = (await getCollection("archicratie"))
-  .filter((e) => e.slug.startsWith("archicrat-ia/"));
+// ✅ Après migration physique : collection = "archicrat-ia", slug = "chapitre-3" (sans prefix)
+const entries = await getCollection("archicrat-ia");
 
 entries.sort((a, b) => (a.data.order ?? 9999) - (b.data.order ?? 9999));
 
-const strip = (slug) => slug.replace(/^archicrat-ia\//, "");
-const href = (slug) => `/archicrat-ia/${strip(slug)}/`;
+const href = (slug) => `/archicrat-ia/${slug}/`;
 ---
 
 <SiteLayout title="Essai-thèse — ArchiCraT-IA">
@@ -19,4 +18,4 @@ const href = (slug) => `/archicrat-ia/${strip(slug)}/`;
       <li><a href={href(e.slug)}>{e.data.title}</a></li>
     ))}
   </ul>
-</SiteLayout>
+</SiteLayout>

src/pages/archicratie/index.astro

@@ -1,16 +0,0 @@
----
-import SiteLayout from "../../layouts/SiteLayout.astro";
-import { getCollection } from "astro:content";
-
-const entries = (await getCollection('archicratie'))
-  .filter((e) => e.slug !== "prologue");
-entries.sort((a, b) => (a.data.order ?? 9999) - (b.data.order ?? 9999));
----
-<SiteLayout title="Essai-thèse — Archicratie">
-  <h1>Essai-thèse — Archicratie</h1>
-  <ul>
-    {entries.map((e) => (
-      <li><a href={`/archicratie/${e.slug}/`}>{e.data.title}</a></li>
-    ))}
-  </ul>
-</SiteLayout>

src/pages/atlas/[...slug].astro

@@ -1,28 +0,0 @@
----
-import EditionLayout from "../../layouts/EditionLayout.astro";
-import { getCollection } from "astro:content";
-
-export async function getStaticPaths() {
-  const entries = await getCollection("atlas");
-  return entries.map((entry) => ({
-    params: { slug: entry.slug },
-    props: { entry },
-  }));
-}
-
-const { entry } = Astro.props;
-const { Content } = await entry.render();
----
-
-<EditionLayout
-  title={entry.data.title}
-  editionLabel="Atlas"
-  editionKey="atlas"
-  statusLabel="cartographie"
-  statusKey="cartographie"
-  level={entry.data.level}
-  version={entry.data.version}
->
-  <h1>{entry.data.title}</h1>
-  <Content />
-</EditionLayout>

src/pages/atlas/index.astro

@@ -1,15 +0,0 @@
----
-import SiteLayout from "../../layouts/SiteLayout.astro";
-import { getCollection } from "astro:content";
-
-const entries = await getCollection("atlas");
-entries.sort((a, b) => (a.data.order ?? 9999) - (b.data.order ?? 9999));
----
-<SiteLayout title="Atlas archicratique">
-  <h1>Atlas archicratique</h1>
-  <ul>
-    {entries.map((e) => (
-      <li><a href={`/atlas/${e.slug}/`}>{e.data.title}</a></li>
-    ))}
-  </ul>
-</SiteLayout>

src/pages/cas-ia/[slug].astro

@@ -1,15 +1,15 @@
 ---
 import EditionLayout from "../../layouts/EditionLayout.astro";
-import { getCollection } from "astro:content";
 import EditionToc from "../../components/EditionToc.astro";
 import LocalToc from "../../components/LocalToc.astro";
+import { getCollection } from "astro:content";
 
 export async function getStaticPaths() {
-  const entries = (await getCollection("archicratie"))
-    .filter((e) => !e.slug.startsWith("archicrat-ia/"));
+  const entries = await getCollection("cas-ia");
+
   return entries.map((entry) => ({
     params: { slug: entry.slug },
-    props: { entry },
+    props: { entry }
   }));
 }
 
@@ -19,18 +19,24 @@ const { Content, headings } = await entry.render();
 
 <EditionLayout
   title={entry.data.title}
-  editionLabel="Archicratie"
-  editionKey="archicratie"
-  statusLabel="modèle sociopolitique"
-  statusKey="modele_sociopolitique"
-  level={entry.data.level}
+  editionLabel="Cas pratique"
+  editionKey="cas-ia"
+  statusLabel="Application"
+  statusKey="application"
+  level={entry.data.level ?? 1}
   version={entry.data.version}
 >
   <Fragment slot="aside">
-    <EditionToc currentSlug={entry.slug} />
+    <EditionToc
+      currentSlug={entry.slug}
+      collection="cas-ia"
+      basePath="/cas-ia"
+      label="Table des matières — Cas pratique IA"
+    />
     <LocalToc headings={headings} />
   </Fragment>
 
   <h1>{entry.data.title}</h1>
+
   <Content />
-</EditionLayout>
+</EditionLayout>

src/pages/cas-ia/index.astro

@@ -2,14 +2,19 @@
 import SiteLayout from "../../layouts/SiteLayout.astro";
 import { getCollection } from "astro:content";
 
-const entries = await getCollection("ia");
+const entries = await getCollection("cas-ia");
+
 entries.sort((a, b) => (a.data.order ?? 9999) - (b.data.order ?? 9999));
+
+const href = (slug: string) => `/cas-ia/${slug}/`;
 ---
+
 <SiteLayout title="Cas pratique — Gouvernance des systèmes IA">
   <h1>Cas pratique — Gouvernance des systèmes IA</h1>
+
   <ul>
     {entries.map((e) => (
-      <li><a href={`/ia/${e.slug}/`}>{e.data.title}</a></li>
+      <li><a href={href(e.slug)}>{e.data.title}</a></li>
     ))}
   </ul>
-</SiteLayout>
+</SiteLayout>

src/pages/commencer/index.astro

@@ -0,0 +1,18 @@
+---
+import EditionLayout from "../../layouts/EditionLayout.astro";
+import DocumentDePresentation from "../../content/commencer/document-de-presentation.mdx";
+---
+
+<EditionLayout
+  title="Document de présentation"
+  editionLabel="Document d’entrée"
+  editionKey="commencer"
+  statusLabel="Présentation"
+  statusKey="presentation"
+  level={1}
+  version="0.1.0"
+>
+  <h1>Document de présentation</h1>
+
+  <DocumentDePresentation />
+</EditionLayout>

src/pages/editions/index.astro

@@ -1,7 +0,0 @@
----
-import SiteLayout from "../../layouts/SiteLayout.astro";
----
-<SiteLayout title="Carte des œuvres">
-  <h1>Carte des œuvres</h1>
-  <p>Cette page explicite la séparation stricte et l’articulation entre les éditions.</p>
-</SiteLayout>

src/pages/ia/[...slug].astro

@@ -1,28 +0,0 @@
----
-import EditionLayout from "../../layouts/EditionLayout.astro";
-import { getCollection } from "astro:content";
-
-export async function getStaticPaths() {
-  const entries = await getCollection("ia");
-  return entries.map((entry) => ({
-    params: { slug: entry.slug },
-    props: { entry },
-  }));
-}
-
-const { entry } = Astro.props;
-const { Content } = await entry.render();
----
-
-<EditionLayout
-  title={entry.data.title}
-  editionLabel="Cas IA"
-  editionKey="ia"
-  statusLabel="application"
-  statusKey="application"
-  level={entry.data.level}
-  version={entry.data.version}
->
-  <h1>{entry.data.title}</h1>
-  <Content />
-</EditionLayout>

src/pages/index.astro

@@ -1,19 +1,57 @@
 ---
 import SiteLayout from "../layouts/SiteLayout.astro";
 ---
-<SiteLayout title="Accueil">
-  <h1>Archicratie — Édition web</h1>
+
+<SiteLayout title="Archicratie — Édition web">
+
+  <h1>Archicratie</h1>
+
   <p>
-    Portail d’accès aux éditions : Traité (Ontodynamique générative), Essai-thèse (ArchiCraT-IA),
-    Cas pratique (IA), Glossaire, Atlas.
+    Ce site présente le noyau conceptuel du paradigme archicratique :
+    une théorie des architectures de régulation qui rendent possible la co-viabilité
+    des sociétés complexes.
   </p>
 
+  <hr />
+
+  <h2>Document d’entrée</h2>
+
+  <p>
+    Le document suivant propose une première entrée dans le paradigme archicratique.
+  </p>
+
+  <p>
+    👉 <a href="/commencer/">Lire le document de présentation</a>
+  </p>
+
+  <hr />
+
+  <h2>Accès principaux</h2>
+
   <ul>
-    <li><a href="/editions/">Carte des œuvres</a></li>
-    <li><a href="/archicrat-ia/">Essai-thèse — ArchiCraT-IA</a></li>
-    <li><a href="/traite/">Traité — Ontodynamique générative</a></li>
-    <li><a href="/ia/">Cas pratique — Gouvernance des systèmes IA</a></li>
-    <li><a href="/glossaire/">Glossaire archicratique</a></li>
-    <li><a href="/atlas/">Atlas archicratique</a></li>
+    <li>
+      <a href="/archicrat-ia/">
+        Essai-thèse — ArchiCraT-IA
+      </a>
+    </li>
+
+    <li>
+      <a href="/cas-ia/">
+        Cas pratique — Gouvernance des systèmes IA
+      </a>
+    </li>
+
+    <li>
+      <a href="/glossaire/">
+        Glossaire archicratique
+      </a>
+    </li>
+
+    <li>
+      <a href="/recherche/">
+        Recherche dans les textes
+      </a>
+    </li>
   </ul>
-</SiteLayout>
+
+</SiteLayout>

src/pages/methode/index.astro

@@ -1,38 +0,0 @@
----
-import SiteLayout from "../../layouts/SiteLayout.astro";
----
-<SiteLayout title="Méthode & statut des textes">
-  <h1>Méthode & statut des textes</h1>
-
-  <h2>1) Séparation stricte des productions</h2>
-  <ul>
-    <li><strong>Traité</strong> : ontodynamique générative (théorie fondamentale).</li>
-    <li><strong>Essai-thèse</strong> : archicratie (modèle sociopolitique).</li>
-    <li><strong>Cas pratique</strong> : gouvernance des systèmes IA (application).</li>
-    <li><strong>Glossaire</strong> : référentiel terminologique (définitions et renvois).</li>
-    <li><strong>Atlas</strong> : cartographie des archicrates (à venir).</li>
-  </ul>
-
-  <h2>2) Règle d’or : liens typés</h2>
-  <p>Tout lien important est explicitement typé :</p>
-  <ul>
-    <li><strong>definition</strong> : renvoi vers le glossaire (sens canonique).</li>
-    <li><strong>appui</strong> : renvoi argumentatif (support).</li>
-    <li><strong>transposition</strong> : analogie / déplacement non-déductif (anti-confusion Traité ↔ Archicratie).</li>
-  </ul>
-
-  <h2>3) Niveaux de lecture</h2>
-  <p>Le même texte peut contenir trois niveaux :</p>
-  <ul>
-    <li><strong>Niveau 1</strong> : lecture citoyenne (accès principal).</li>
-    <li><strong>Niveau 2</strong> : approfondissement.</li>
-    <li><strong>Niveau 3</strong> : niveau recherche.</li>
-  </ul>
-  <p>Techniquement : les blocs <code>.level-2</code> et <code>.level-3</code> sont masqués/affichés par le toggle, sans casser la lisibilité si JS est absent.</p>
-
-  <h2>4) Citabilité</h2>
-  <p>Chaque paragraphe reçoit un identifiant stable et peut être cité par ancre (bouton “Citer”).</p>
-
-  <h2>5) Statut éditorial</h2>
-  <p>Chaque page indique : Édition / Statut / Niveau / Version. Les versions servent à garantir la citabilité et l’historique.</p>
-</SiteLayout>

src/pages/traite/[...slug].astro

@@ -1,28 +0,0 @@
----
-import EditionLayout from "../../layouts/EditionLayout.astro";
-import { getCollection } from "astro:content";
-
-export async function getStaticPaths() {
-  const entries = await getCollection("traite");
-  return entries.map((entry) => ({
-    params: { slug: entry.slug },
-    props: { entry },
-  }));
-}
-
-const { entry } = Astro.props;
-const { Content } = await entry.render();
----
-
-<EditionLayout
-  title={entry.data.title}
-  editionLabel="Traité"
-  editionKey="traite"
-  statusLabel="théorie fondamentale"
-  statusKey="theorie_fondamentale"
-  level={entry.data.level}
-  version={entry.data.version}
->
-  <h1>{entry.data.title}</h1>
-  <Content />
-</EditionLayout>

src/pages/traite/index.astro

@@ -1,15 +0,0 @@
----
-import SiteLayout from "../../layouts/SiteLayout.astro";
-import { getCollection } from "astro:content";
-
-const entries = await getCollection("traite");
-entries.sort((a, b) => (a.data.order ?? 9999) - (b.data.order ?? 9999));
----
-<SiteLayout title="Traité — Ontodynamique générative">
-  <h1>Traité — Ontodynamique générative</h1>
-  <ul>
-    {entries.map((e) => (
-      <li><a href={`/traite/${e.slug}/`}>{e.data.title}</a></li>
-    ))}
-  </ul>
-</SiteLayout>

src/styles/global.css

@@ -27,17 +27,40 @@
   --rf-h3-size: 1.25rem;
   --rf-h3-lh: 1.25;
   --rf-h3-fw: 650;
+
+  /* ===== Polish (non destructif) ===== */
+  --ease-out: cubic-bezier(.2,.9,.2,1);
+  --ease-soft: cubic-bezier(.2,.8,.2,1);
+
+  --focus-ring: 2px solid rgba(140,140,255,0.60);
+  --focus-ring-offset: 2px;
 }
 
 body {
   margin: 0;
   font-family: system-ui, -apple-system, Segoe UI, Roboto, Arial, sans-serif;
   line-height: 1.6;
+
+  /* polish */
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
 }
 
 a { text-decoration: none; }
 a:hover { text-decoration: underline; }
 
+/* ===== Focus (accessibilité + feel premium) ===== */
+:focus { outline: none; }
+:focus-visible{
+  outline: var(--focus-ring);
+  outline-offset: var(--focus-ring-offset);
+}
+
+@media (prefers-reduced-motion: reduce){
+  *{ transition: none !important; animation: none !important; }
+}
+
 /* Header sticky */
 header{
   position: sticky;
@@ -61,15 +84,26 @@ main { padding: 0; }
 .reading {
   max-width: 78ch;
   margin: 0 auto;
+
+  /* polish */
+  font-size: 16px;
+  letter-spacing: 0.005em;
 }
 
 .reading h1 {
   line-height: 1.2;
   margin: 0 0 10px;
+
+  /* polish */
+  letter-spacing: -0.01em;
 }
 
 .reading p { margin: 0 0 12px; }
 
+/* petits ajustements de respiration */
+.reading h2 { margin-top: 18px; }
+.reading h3 { margin-top: 14px; }
+
 .edition-bar {
   display: flex;
   flex-wrap: wrap;
@@ -99,6 +133,11 @@ main { padding: 0; }
   border: 1px solid rgba(127,127,127,0.55);
   border-radius: 999px;
   padding: 5px 12px;
+  transition: transform 120ms var(--ease-out), background 120ms var(--ease-out);
+}
+.resume-btn:hover{
+  background: rgba(127,127,127,0.10);
+  transform: translateY(-1px);
 }
 
 /* Jump by paragraph id */
@@ -114,6 +153,11 @@ main { padding: 0; }
   border-radius: 999px;
   font-size: 13px;
   width: 320px;
+  transition: border-color 120ms var(--ease-out), box-shadow 120ms var(--ease-out);
+}
+.jump-input:focus-visible{
+  border-color: rgba(140,140,255,0.65);
+  box-shadow: 0 0 0 3px rgba(140,140,255,0.18);
 }
 .jump-input.is-error{
   outline: 2px solid rgba(127,127,127,0.55);
@@ -126,6 +170,11 @@ main { padding: 0; }
   border-radius: 999px;
   cursor: pointer;
   font-size: 13px;
+  transition: transform 120ms var(--ease-out), background 120ms var(--ease-out);
+}
+.jump-btn:hover{
+  background: rgba(127,127,127,0.10);
+  transform: translateY(-1px);
 }
 
 /* Toggle niveaux (legacy, non bloquant) */
@@ -137,6 +186,11 @@ main { padding: 0; }
   border-radius: 999px;
   cursor: pointer;
   font-size: 13px;
+  transition: transform 120ms var(--ease-out), background 120ms var(--ease-out), border-color 120ms var(--ease-out);
+}
+.lvl-btn:hover{
+  background: rgba(127,127,127,0.10);
+  transform: translateY(-1px);
 }
 .lvl-btn[aria-pressed="true"] {
   border-color: rgba(127,127,127,0.9);
@@ -211,6 +265,13 @@ body[data-reading-level="4"] .level-3 { display: none; }
   border-radius: 999px;
   padding: 2px 8px;
   background: transparent;
+  transition: transform 120ms var(--ease-out), background 120ms var(--ease-out);
+}
+.para-anchor:hover,
+.para-propose:hover,
+.para-cite:hover{
+  background: rgba(127,127,127,0.10);
+  transform: translateY(-1px);
 }
 .para-cite{ cursor: pointer; }
 
@@ -221,8 +282,13 @@ body[data-reading-level="4"] .level-3 { display: none; }
   padding: 4px 12px;
   background: transparent;
   cursor: pointer;
+  transition: transform 120ms var(--ease-out), background 120ms var(--ease-out);
+}
+.para-bookmark:hover{
+  background: rgba(127,127,127,0.10);
+  transform: translateY(-1px);
+  text-decoration: underline;
 }
-.para-bookmark:hover{ text-decoration: underline; }
 
 /* Highlight (jump / resume / arrivée hash) */
 .para-highlight{
@@ -420,3 +486,57 @@ html{ scroll-behavior: smooth; }
   padding: 0;
   background: transparent;
 }
+
+/* ==========================
+   Landscape boost (mobile/tablet)
+   CSS-only, non destructif
+   - iOS + Android
+   - élargit la lecture en paysage sur petits écrans
+   - ne touche pas au desktop
+   ========================== */
+
+/* 1) Quand on est en paysage sur “petits” devices,
+      on évite une colonne unique trop “étroite” et on retire le max-width 78ch. */
+      @media (orientation: landscape) and (max-width: 1024px){
+        /* La grille (EditionLayout) utilise .page-shell ; on la rend plus “fluide” */
+        .page-shell{
+          max-width: calc(100vw - 16px) !important; /* respire mais exploite la largeur */
+        }
+      
+        /* La lecture ne doit pas rester “bridée” à 78ch en paysage */
+        .reading{
+          max-width: none !important;
+          width: 100% !important;
+        }
+      }
+      
+      /* 2) Cas extrême : petits téléphones en paysage (hauteur faible).
+            On réduit légèrement les paddings pour gagner de la place utile. */
+      @media (orientation: landscape) and (max-width: 820px) and (max-height: 520px){
+        header{
+          padding-top: 10px;
+          padding-bottom: 10px;
+        }
+      
+        /* allège un peu la barre d’édition (sans la casser) */
+        .edition-bar{
+          margin-top: 8px;
+          padding-top: 8px;
+          gap: 8px 12px;
+        }
+      
+        /* champ jump un peu moins large, pour éviter de “manger” la nav */
+        .jump-input{
+          width: min(260px, 48vw);
+        }
+      }
+      
+      /* 3) iOS Safari : le viewport peut être “bizarre” en paysage (barres).
+            Cette règle aide à éviter des layouts coincés quand l’UI Safari bouge. */
+      @supports (height: 100dvh){
+        @media (orientation: landscape) and (max-width: 1024px){
+          .page-shell{
+            min-height: 100dvh;
+          }
+        }
+      }