content(archicrat-ia): refresh official chapitre 2 docx

Reviewed-on: #308

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

@@ -16,9 +16,13 @@ defaults:
   run:
     shell: bash
 
+concurrency:
+  group: anno-apply-${{ github.event.issue.number || github.event.issue.index || inputs.issue || 'manual' }}
+  cancel-in-progress: true
+
 jobs:
   apply-approved:
-    runs-on: ubuntu-latest
+    runs-on: mac-ci
     container:
       image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
 
@@ -29,16 +33,15 @@ jobs:
           git --version
           node --version
           npm --version
-          npm ping --registry=https://registry.npmjs.org
 
       - 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"
-          test -f "$EVENT_JSON" || { echo "❌ Missing $EVENT_JSON"; exit 1; }
+          test -f "$EVENT_JSON" || { echo "Missing $EVENT_JSON"; exit 1; }
 
           node --input-type=module - <<'NODE' > /tmp/anno.env
           import fs from "node:fs";
@@ -63,7 +66,10 @@ jobs:
 
           if (!owner || !repo) {
             const m = cloneUrl.match(/[:/](?<o>[^/]+)\/(?<r>[^/]+?)(?:\.git)?$/);
-            if (m?.groups) { owner = owner || m.groups.o; repo = repo || m.groups.r; }
+            if (m?.groups) {
+              owner = owner || m.groups.o;
+              repo = repo || m.groups.r;
+            }
           }
           if (!owner || !repo) throw new Error("Cannot infer owner/repo");
 
@@ -78,10 +84,11 @@ jobs:
             throw new Error("No issue number in event.json or workflow_dispatch input");
           }
 
-          const labelName =
-            ev?.label?.name ||
-            ev?.label ||
-            "workflow_dispatch";
+          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;
@@ -90,7 +97,7 @@ jobs:
             ? String(process.env.FORGE_API).trim().replace(/\/+$/,"")
             : origin;
 
-          function sh(s){ return JSON.stringify(String(s)); }
+          function sh(s) { return JSON.stringify(String(s)); }
 
           process.stdout.write([
             `CLONE_URL=${sh(cloneUrl)}`,
@@ -103,25 +110,137 @@ jobs:
           ].join("\n") + "\n");
           NODE
 
-          echo "✅ context:"
+          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"
+
+          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)"
+
+          echo "continue to API gating (issue=$ISSUE_NUMBER)"
+
+      - name: Fetch issue + hard gate on labels + Type
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/anno.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/anno.env
+          import fs from "node:fs";
+
+          const issue = JSON.parse(fs.readFileSync("/tmp/issue.json", "utf8"));
+          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);
+            return m ? m[1].trim() : "";
+          }
+
+          const typeRaw = pickLine("Type");
+          const type = String(typeRaw || "").trim().toLowerCase();
+
+          const allowedAnno = new Set(["type/media", "type/reference", "type/comment"]);
+          const proposerTypes = new Set(["type/correction", "type/fact-check"]);
+
+          const out = [];
+          out.push(`ISSUE_TYPE=${JSON.stringify(type)}`);
+
+          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")}`);
+          } else if (allowedAnno.has(type)) {
+            // proceed
+          } else if (proposerTypes.has(type)) {
+            out.push(`SKIP=1`);
+            out.push(`SKIP_REASON=${JSON.stringify("proposer_type:" + type)}`);
+          } else {
+            out.push(`SKIP=1`);
+            out.push(`SKIP_REASON=${JSON.stringify("unsupported_type:" + type)}`);
+          }
+
+          process.stdout.write(out.join("\n") + "\n");
+          NODE
+
+          echo "gating result:"
+          grep -E '^(ISSUE_TYPE|SKIP|SKIP_REASON)=' /tmp/anno.env || true
+
+      - name: Comment issue if skipped (unsupported / missing Type only)
+        if: ${{ always() }}
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/anno.env || true
+
+          [[ "${SKIP:-0}" == "1" ]] || exit 0
+
+          if [[ "${SKIP_REASON:-}" == "not_approved_label_present" || "${SKIP_REASON:-}" == "label_not_approved_event" ]]; then
+            echo "skip reason=${SKIP_REASON} -> no comment"
+            exit 0
+          fi
+
+          if [[ "${SKIP_REASON:-}" == proposer_type:* ]]; then
+            echo "proposer ticket detected -> anno stays silent"
+            exit 0
+          fi
+
+          test -n "${FORGE_TOKEN:-}" || exit 0
+
+          REASON="${SKIP_REASON:-}"
+          TYPE="${ISSUE_TYPE:-}"
+
+          if [[ "$REASON" == unsupported_type:* ]]; then
+            MSG="Ticket #${ISSUE_NUMBER} ignored: unsupported Type (${TYPE}). Supported types: type/media, type/reference, type/comment."
+          else
+            MSG="Ticket #${ISSUE_NUMBER} ignored: missing or unreadable 'Type:'. Expected: type/media|type/reference|type/comment"
+          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"
 
       - name: Checkout default branch
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
 
           rm -rf .git
           git init -q
@@ -134,16 +253,16 @@ jobs:
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
-          npm ci
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
+          npm ci --no-audit --no-fund
 
       - name: Check apply script exists
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
           test -f scripts/apply-annotation-ticket.mjs || {
-            echo "❌ missing scripts/apply-annotation-ticket.mjs on $DEFAULT_BRANCH"
+            echo "missing scripts/apply-annotation-ticket.mjs on $DEFAULT_BRANCH"
             ls -la scripts | sed -n '1,200p' || true
             exit 1
           }
@@ -152,16 +271,16 @@ jobs:
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
 
-          npm run build:clean
+          npm run build
 
           test -f dist/para-index.json || {
-            echo "❌ missing dist/para-index.json after build"
+            echo "missing dist/para-index.json after build"
             ls -la dist | sed -n '1,200p' || true
             exit 1
           }
-          echo "✅ dist/para-index.json present"
+          echo "dist/para-index.json present"
 
       - name: Apply ticket on bot branch (strict+verify, commit)
         continue-on-error: true
@@ -172,9 +291,10 @@ jobs:
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${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; }
+          test -n "${FORGE_TOKEN:-}" || { echo "Missing secret FORGE_TOKEN"; exit 1; }
 
           git config user.name  "${BOT_GIT_NAME:-archicratie-bot}"
           git config user.email "${BOT_GIT_EMAIL:-bot@archicratie.local}"
@@ -220,40 +340,25 @@ jobs:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
         run: |
           set -euo pipefail
-          source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          source /tmp/anno.env || true
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
 
           RC="${APPLY_RC:-0}"
           if [[ "$RC" == "0" ]]; then
-            echo "ℹ️ no failure detected"
+            echo "no failure detected"
             exit 0
           fi
 
-          BODY="$(tail -n 160 /tmp/apply.log | sed 's/\r$//')"
-          MSG="❌ apply-annotation-ticket a échoué (rc=${RC}).\n\n\`\`\`\n${BODY}\n\`\`\`\n"
+          test -n "${FORGE_TOKEN:-}" || exit 0
 
-          PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
+          if [[ -f /tmp/apply.log ]]; then
+            BODY="$(tail -n 160 /tmp/apply.log | sed 's/\r$//')"
+          else
+            BODY="(no apply log found)"
+          fi
 
-          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: Comment issue if no-op (already applied)
-        if: ${{ always() }}
-        env:
-          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
-        run: |
-          set -euo pipefail
-          source /tmp/anno.env
-          [[ "${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")"
+          MSG="apply-annotation-ticket failed (rc=${RC}).\n\n\`\`\`\n${BODY}\n\`\`\`\n"
+          PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1] || ""}))' "$MSG")"
 
           curl -fsS -X POST \
             -H "Authorization: token $FORGE_TOKEN" \
@@ -267,11 +372,12 @@ jobs:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
         run: |
           set -euo pipefail
-          source /tmp/anno.env
+          source /tmp/anno.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; }
+          [[ "${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);
@@ -290,11 +396,11 @@ jobs:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
         run: |
           set -euo pipefail
-          source /tmp/anno.env
+          source /tmp/anno.env || true
           [[ "${SKIP:-0}" != "1" ]] || exit 0
 
-          [[ "${APPLY_RC:-0}" == "0" ]] || { echo "ℹ️ apply failed -> skip PR"; exit 0; }
-          [[ "${NOOP:-0}" == "0" ]] || { echo "ℹ️ no-op -> skip PR"; exit 0; }
+          [[ "${APPLY_RC:-0}" == "0" ]] || { echo "apply failed -> skip PR"; exit 0; }
+          [[ "${NOOP:-0}" == "0" ]] || { echo "no-op -> skip PR"; exit 0; }
 
           PR_TITLE="anno: apply ticket #${ISSUE_NUMBER}"
           PR_BODY="PR auto depuis ticket #${ISSUE_NUMBER} (state/approved).\n\n- Branche: ${BRANCH}\n- Commit: ${END_SHA}\n\nMerge si CI OK."
@@ -315,10 +421,10 @@ jobs:
             console.log(pr.html_url || pr.url || "");
           ' "$PR_JSON")"
 
-          test -n "$PR_URL" || { echo "❌ PR URL missing. Raw: $PR_JSON"; exit 1; }
+          test -n "$PR_URL" || { echo "PR URL missing. Raw: $PR_JSON"; exit 1; }
 
-          MSG="✅ PR créée pour ticket #${ISSUE_NUMBER} : ${PR_URL}"
-          C_PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
+          MSG="PR created for 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" \
@@ -326,18 +432,19 @@ jobs:
             "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
             --data-binary "$C_PAYLOAD"
 
-          echo "✅ PR: $PR_URL"
+          echo "PR: $PR_URL"
 
       - name: Finalize (fail job if apply failed)
         if: ${{ always() }}
         run: |
           set -euo pipefail
           source /tmp/anno.env || true
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
 
           RC="${APPLY_RC:-0}"
           if [[ "$RC" != "0" ]]; then
-            echo "❌ apply failed (rc=$RC)"
+            echo "apply failed (rc=$RC)"
             exit "$RC"
           fi
-          echo "✅ apply ok"
+          echo "apply ok"

.gitea/workflows/anno-reject.yml

@@ -1,8 +1,13 @@
-name: Anno Reject
+name: Anno Reject (close issue)
 
 on:
   issues:
     types: [labeled]
+  workflow_dispatch:
+    inputs:
+      issue:
+        description: "Issue number to reject/close"
+        required: true
 
 env:
   NODE_OPTIONS: --dns-result-order=ipv4first
@@ -11,14 +16,26 @@ defaults:
   run:
     shell: bash
 
+concurrency:
+  group: anno-reject-${{ github.event.issue.number || github.event.issue.index || inputs.issue || 'manual' }}
+  cancel-in-progress: true
+
 jobs:
   reject:
-    runs-on: ubuntu-latest
+    runs-on: mac-ci
     container:
       image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
 
     steps:
-      - name: Derive context
+      - name: Tools sanity
+        run: |
+          set -euo pipefail
+          node --version
+
+      - name: Derive context (event.json / workflow_dispatch)
+        env:
+          INPUT_ISSUE: ${{ inputs.issue }}
+          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"
@@ -29,58 +46,122 @@ jobs:
 
           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 url");
 
           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) {
+          if ((!owner || !repo) && cloneUrl) {
             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 issueNumber = ev?.issue?.number || ev?.issue?.index;
-          if (!issueNumber) throw new Error("No issue number");
+          const issueNumber =
+            ev?.issue?.number ||
+            ev?.issue?.index ||
+            (process.env.INPUT_ISSUE ? Number(process.env.INPUT_ISSUE) : 0);
 
-          const labelName = ev?.label?.name || ev?.label || "";
-          const u = new URL(cloneUrl);
+          if (!issueNumber || !Number.isFinite(Number(issueNumber))) {
+            throw new Error("No issue number in event.json or workflow_dispatch input");
+          }
+
+          // 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()) {
+            apiBase = String(process.env.FORGE_API).trim().replace(/\/+$/,"");
+          } else if (cloneUrl) {
+            apiBase = new URL(cloneUrl).origin;
+          } else {
+            apiBase = "";
+          }
 
           function sh(s){ return JSON.stringify(String(s)); }
+
           process.stdout.write([
             `OWNER=${sh(owner)}`,
             `REPO=${sh(repo)}`,
             `ISSUE_NUMBER=${sh(issueNumber)}`,
             `LABEL_NAME=${sh(labelName)}`,
-            `API_BASE=${sh(u.origin)}`
+            `API_BASE=${sh(apiBase)}`
           ].join("\n") + "\n");
           NODE
 
-      - name: Gate on label state/rejected
+          echo "✅ context:"
+          sed -n '1,120p' /tmp/reject.env
+
+      - name: Early gate (fast-skip, tolerant)
         run: |
           set -euo pipefail
           source /tmp/reject.env
-          if [[ "$LABEL_NAME" != "state/rejected" ]]; then
-            echo "ℹ️ label=$LABEL_NAME => skip"
+          echo "ℹ️ event label = $LABEL_NAME"
+
+          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 "✅ reject issue=$ISSUE_NUMBER"
 
-      - name: Comment + close issue
+      - name: Comment + close (only if label state/rejected is PRESENT now, and no conflict)
         env:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
         run: |
           set -euo pipefail
           source /tmp/reject.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
           test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
+          test -n "${API_BASE:-}" || { echo "❌ Missing API_BASE"; 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/reject.issue.json
+
+          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");
+          process.stdout.write(`HAS_APPROVED=${hasApproved ? "1":"0"}\nHAS_REJECTED=${hasRejected ? "1":"0"}\n`);
+          NODE
+
+          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")"
+            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"
+            echo "ℹ️ conflict => stop"
+            exit 0
+          fi
 
           MSG="❌ Ticket #${ISSUE_NUMBER} refusé (label state/rejected)."
           PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
@@ -95,4 +176,6 @@ jobs:
             -H "Authorization: token $FORGE_TOKEN" \
             -H "Content-Type: application/json" \
             "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER" \
-            --data-binary '{"state":"closed"}'
+            --data-binary '{"state":"closed"}'
+
+          echo "✅ rejected+closed"

.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: ubuntu-latest
+    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/ci.yaml

@@ -3,7 +3,7 @@ name: CI
 on:
   push:
   pull_request:
-    branches: [master]
+    branches: [main]
   workflow_dispatch:
 
 env:
@@ -15,7 +15,7 @@ defaults:
 
 jobs:
   build-and-anchors:
-    runs-on: ubuntu-latest
+    runs-on: mac-ci
     container:
       image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
 

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

@@ -26,9 +26,9 @@ concurrency:
 
 jobs:
   deploy:
-    runs-on: ubuntu-latest
+    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)"
@@ -223,6 +297,19 @@ jobs:
           docker image tag archicratie-web:blue  "archicratie-web:blue.BAK.${TS}"  || true
           docker image tag archicratie-web:green "archicratie-web:green.BAK.${TS}" || true
 
+          BUILD_TIME_RAW="$(TZ=Europe/Paris date '+%Y-%m-%dT%H:%M:%S%z')"
+          BUILD_TIME="${BUILD_TIME_RAW:0:${#BUILD_TIME_RAW}-2}:${BUILD_TIME_RAW:${#BUILD_TIME_RAW}-2}"
+
+          PUBLIC_OPS_ENV=staging \
+          PUBLIC_OPS_UPSTREAM=web_blue \
+          PUBLIC_BUILD_SHA="${AFTER}" \
+          PUBLIC_BUILD_TIME="${BUILD_TIME}" \
+          node scripts/write-ops-health.mjs
+
+          test -f public/__ops/health.json
+          echo "=== public/__ops/health.json (blue/staging) ==="
+          cat public/__ops/health.json
+
           docker compose -p "$PROJ" -f docker-compose.yml build web_blue
           docker rm -f archicratie-web-blue || true
           docker compose -p "$PROJ" -f docker-compose.yml up -d --force-recreate --remove-orphans web_blue
@@ -232,6 +319,11 @@ jobs:
           wait_url "http://127.0.0.1:8081/annotations-index.json" "blue annotations-index"
           wait_url "http://127.0.0.1:8081/pagefind/pagefind.js"   "blue pagefind.js"
 
+          wait_url "http://127.0.0.1:8081/__ops/health.json" "blue ops health"
+
+          curl -fsS --max-time 6 "http://127.0.0.1:8081/__ops/health.json" \
+            | python3 -c 'import sys, json; j=json.load(sys.stdin); print("env=", j.get("env")); print("upstream=", j.get("upstream")); print("buildSha=", j.get("buildSha")); print("builtAt=", j.get("builtAt"))'
+
           CANON="$(curl -fsS --max-time 6 "http://127.0.0.1:8081/archicrat-ia/chapitre-1/" | grep -oE 'rel="canonical" href="[^"]+"' | head -n1 || true)"
           echo "canonical(blue)=$CANON"
           echo "$CANON" | grep -q 'https://staging\.archicratie\.trans-hands\.synology\.me/' || {
@@ -279,6 +371,19 @@ jobs:
             docker compose -p "$PROJ" -f docker-compose.yml up -d --force-recreate --remove-orphans web_green || true
           }
 
+          BUILD_TIME_RAW="$(TZ=Europe/Paris date '+%Y-%m-%dT%H:%M:%S%z')"
+          BUILD_TIME="${BUILD_TIME_RAW:0:${#BUILD_TIME_RAW}-2}:${BUILD_TIME_RAW:${#BUILD_TIME_RAW}-2}"
+
+          PUBLIC_OPS_ENV=prod \
+          PUBLIC_OPS_UPSTREAM=web_green \
+          PUBLIC_BUILD_SHA="${AFTER}" \
+          PUBLIC_BUILD_TIME="${BUILD_TIME}" \
+          node scripts/write-ops-health.mjs
+
+          test -f public/__ops/health.json
+          echo "=== public/__ops/health.json (green/prod) ==="
+          cat public/__ops/health.json
+
           # build/restart green
           if ! docker compose -p "$PROJ" -f docker-compose.yml build web_green; then
             echo "❌ build green failed"; rollback; exit 4
@@ -292,6 +397,11 @@ jobs:
           if ! wait_url "http://127.0.0.1:8082/annotations-index.json" "green annotations-index"; then rollback; exit 4; fi
           if ! wait_url "http://127.0.0.1:8082/pagefind/pagefind.js"   "green pagefind.js"; then rollback; exit 4; fi
 
+          if ! wait_url "http://127.0.0.1:8082/__ops/health.json" "green ops health"; then rollback; exit 4; fi
+
+          curl -fsS --max-time 6 "http://127.0.0.1:8082/__ops/health.json" \
+            | python3 -c 'import sys, json; j=json.load(sys.stdin); print("env=", j.get("env")); print("upstream=", j.get("upstream")); print("buildSha=", j.get("buildSha")); print("builtAt=", j.get("builtAt"))'
+
           CANON="$(curl -fsS --max-time 6 "http://127.0.0.1:8082/archicrat-ia/chapitre-1/" | grep -oE 'rel="canonical" href="[^"]+"' | head -n1 || true)"
           echo "canonical(green)=$CANON"
           echo "$CANON" | grep -q 'https://archicratie\.trans-hands\.synology\.me/' || {

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

@@ -0,0 +1,788 @@
+name: Proposer Apply (Queue)
+
+on:
+  issues:
+    types: [labeled]
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      issue:
+        description: "Issue number to prioritize (optional)"
+        required: false
+        default: ""
+
+env:
+  NODE_OPTIONS: --dns-result-order=ipv4first
+
+defaults:
+  run:
+    shell: bash
+
+concurrency:
+  group: proposer-queue-main
+  cancel-in-progress: false
+
+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 / push)
+        env:
+          INPUT_ISSUE: ${{ inputs.issue }}
+          EVENT_NAME_IN: ${{ github.event_name }}
+          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) ||
+            0;
+
+          const labelName =
+            ev?.label?.name ||
+            (typeof ev?.label === "string" ? ev.label : "") ||
+            "";
+
+          const eventName =
+            String(process.env.EVENT_NAME_IN || "").trim() ||
+            (ev?.issue ? "issues" : (ev?.before || ev?.after ? "push" : "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)}`,
+            `EVENT_NAME=${sh(eventName)}`,
+            `API_BASE=${sh(apiBase)}`
+          ].join("\n") + "\n");
+          NODE
+
+          echo "Context:"
+          sed -n '1,200p' /tmp/proposer.env
+
+      - name: Early gate (tolerant on empty issue label payload)
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+
+          echo "event=$EVENT_NAME label=${LABEL_NAME:-<empty>}"
+
+          if [[ "$EVENT_NAME" == "issues" ]]; then
+            if [[ -n "${LABEL_NAME:-}" && "$LABEL_NAME" != "state/approved" ]]; then
+              echo "issues/labeled with explicit non-approved label=$LABEL_NAME -> skip"
+              echo 'SKIP=1' >> /tmp/proposer.env
+              echo 'SKIP_REASON="label_not_state_approved_event"' >> /tmp/proposer.env
+              exit 0
+            fi
+          fi
+
+          echo "Proceed to API-based selection/gating"
+
+      - 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
+
+      - 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"
+
+          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: Select next proposer batch (by path)
+        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
+          }
+
+          export GITEA_OWNER="$OWNER"
+          export GITEA_REPO="$REPO"
+          export FORGE_API="$API_BASE"
+
+          cd "$APP_DIR"
+
+          test -f scripts/pick-proposer-issue.mjs || {
+            echo "missing scripts/pick-proposer-issue.mjs in APP_DIR=$APP_DIR"
+            ls -la scripts | sed -n '1,200p' || true
+            exit 1
+          }
+
+          node scripts/pick-proposer-issue.mjs "${ISSUE_NUMBER:-0}" > /tmp/proposer.pick.env
+          cat /tmp/proposer.pick.env >> /tmp/proposer.env
+          source /tmp/proposer.pick.env
+
+          if [[ "${TARGET_FOUND:-0}" != "1" ]]; then
+            echo 'SKIP=1' >> /tmp/proposer.env
+            echo "SKIP_REASON=${TARGET_REASON:-no_target}" >> /tmp/proposer.env
+            echo "No target batch"
+            exit 0
+          fi
+
+          echo "Target batch:"
+          grep -E '^(TARGET_PRIMARY_ISSUE|TARGET_ISSUES|TARGET_COUNT|TARGET_CHEMIN)=' /tmp/proposer.env
+
+      - name: Derive deterministic batch identity
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "Skipped"; exit 0; }
+
+          export TARGET_ISSUES TARGET_CHEMIN
+
+          node --input-type=module - <<'NODE'
+          import fs from "node:fs";
+          import crypto from "node:crypto";
+
+          const issues = String(process.env.TARGET_ISSUES || "")
+            .trim()
+            .split(/\s+/)
+            .filter(Boolean)
+            .sort((a, b) => Number(a) - Number(b));
+
+          const chemin = String(process.env.TARGET_CHEMIN || "").trim();
+          const keySource = `${chemin}::${issues.join(",")}`;
+          const hash = crypto.createHash("sha1").update(keySource).digest("hex").slice(0, 12);
+          const primary = issues[0] || "0";
+          const batchBranch = `bot/proposer-${primary}-${hash}`;
+
+          fs.appendFileSync(
+            "/tmp/proposer.env",
+            [
+              `BATCH_KEY=${JSON.stringify(keySource)}`,
+              `BATCH_HASH=${JSON.stringify(hash)}`,
+              `BATCH_BRANCH=${JSON.stringify(batchBranch)}`
+            ].join("\n") + "\n"
+          );
+          NODE
+
+          echo "Batch identity:"
+          grep -E '^(BATCH_KEY|BATCH_HASH|BATCH_BRANCH)=' /tmp/proposer.env
+
+      - name: Inspect open proposer PRs
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "Skipped"; exit 0; }
+
+          curl -fsS \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Accept: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/pulls?state=open&limit=100" \
+            -o /tmp/open_pulls.json
+
+          export TARGET_ISSUES="${TARGET_ISSUES:-}"
+          export BATCH_BRANCH="${BATCH_BRANCH:-}"
+          export BATCH_KEY="${BATCH_KEY:-}"
+
+          node --input-type=module - <<'NODE' >> /tmp/proposer.env
+          import fs from "node:fs";
+
+          const pulls = JSON.parse(fs.readFileSync("/tmp/open_pulls.json", "utf8"));
+          const issues = String(process.env.TARGET_ISSUES || "")
+            .trim()
+            .split(/\s+/)
+            .filter(Boolean);
+
+          const batchBranch = String(process.env.BATCH_BRANCH || "");
+          const batchKey = String(process.env.BATCH_KEY || "");
+
+          const proposerOpen = Array.isArray(pulls)
+            ? pulls.filter((pr) => String(pr?.head?.ref || "").startsWith("bot/proposer-"))
+            : [];
+
+          const sameBatch = proposerOpen.find((pr) => {
+            const ref = String(pr?.head?.ref || "");
+            const title = String(pr?.title || "");
+            const body = String(pr?.body || "");
+
+            if (batchBranch && ref === batchBranch) return true;
+            if (batchKey && body.includes(`Batch-Key: ${batchKey}`)) return true;
+
+            return issues.some((n) =>
+              ref.startsWith(`bot/proposer-${n}-`) ||
+              title.includes(`#${n}`) ||
+              body.includes(`#${n}`) ||
+              body.includes(`ticket #${n}`)
+            );
+          });
+
+          const out = [];
+
+          if (sameBatch) {
+            out.push("SKIP=1");
+            out.push(`SKIP_REASON=${JSON.stringify("issue_already_has_open_pr")}`);
+            out.push(`OPEN_PR_URL=${JSON.stringify(String(sameBatch.html_url || sameBatch.url || ""))}`);
+            out.push(`OPEN_PR_BRANCH=${JSON.stringify(String(sameBatch?.head?.ref || ""))}`);
+          } else if (proposerOpen.length > 0) {
+            const first = proposerOpen[0];
+            out.push("SKIP=1");
+            out.push(`SKIP_REASON=${JSON.stringify("queue_busy_open_proposer_pr")}`);
+            out.push(`OPEN_PR_URL=${JSON.stringify(String(first.html_url || first.url || ""))}`);
+            out.push(`OPEN_PR_BRANCH=${JSON.stringify(String(first?.head?.ref || ""))}`);
+          }
+
+          process.stdout.write(out.join("\n") + (out.length ? "\n" : ""));
+          NODE
+
+      - name: Guard on remote batch branch before heavy work
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "Skipped"; exit 0; }
+
+          if git ls-remote --exit-code --heads origin "$BATCH_BRANCH" >/dev/null 2>&1; then
+            echo 'SKIP=1' >> /tmp/proposer.env
+            echo 'SKIP_REASON="batch_branch_exists_without_pr"' >> /tmp/proposer.env
+            echo "OPEN_PR_BRANCH=${BATCH_BRANCH}" >> /tmp/proposer.env
+            echo "Remote batch branch already exists -> skip duplicate materialization"
+            exit 0
+          fi
+
+          echo "Remote batch branch is free"
+
+      - name: Comment issue if queued / skipped
+        if: ${{ always() }}
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+
+          [[ "${SKIP:-0}" == "1" ]] || exit 0
+          [[ "${EVENT_NAME:-}" != "push" ]] || exit 0
+
+          if [[ "${SKIP_REASON:-}" == "label_not_state_approved_event" || "${SKIP_REASON:-}" == "label_not_state_approved" ]]; then
+            echo "Skip reason=${SKIP_REASON} -> no comment"
+            exit 0
+          fi
+
+          test -n "${FORGE_TOKEN:-}" || exit 0
+
+          ISSUE_TO_COMMENT="${ISSUE_NUMBER:-0}"
+          if [[ "$ISSUE_TO_COMMENT" == "0" || -z "$ISSUE_TO_COMMENT" ]]; then
+            ISSUE_TO_COMMENT="${TARGET_PRIMARY_ISSUE:-0}"
+          fi
+          [[ "$ISSUE_TO_COMMENT" != "0" ]] || exit 0
+
+          case "${SKIP_REASON:-}" in
+            queue_busy_open_proposer_pr)
+              MSG="Ticket queued in proposer queue. An open proposer PR already exists: ${OPEN_PR_URL:-"(URL unavailable)"}. The workflow will resume after merge on main."
+              ;;
+            issue_already_has_open_pr)
+              MSG="This batch already has an open proposer PR: ${OPEN_PR_URL:-"(URL unavailable)"}"
+              ;;
+            batch_branch_exists_without_pr)
+              MSG="This batch already has a remote batch branch (${OPEN_PR_BRANCH:-"(unknown branch)"}). Manual inspection is required before any new proposer PR is created."
+              ;;
+            batch_branch_already_materialized)
+              MSG="This batch was already materialized by another run on branch ${OPEN_PR_BRANCH:-"(unknown branch)"}. No duplicate PR was created."
+              ;;
+            explicit_issue_missing_chemin)
+              MSG="Proposer Apply: cannot process this ticket automatically because field Chemin is missing or unreadable."
+              ;;
+            explicit_issue_missing_type)
+              MSG="Proposer Apply: cannot process this ticket automatically because field Type is missing or unreadable."
+              ;;
+            explicit_issue_not_approved)
+              MSG="Proposer Apply: this ticket is not currently labeled state/approved."
+              ;;
+            explicit_issue_rejected)
+              MSG="Proposer Apply: this ticket has state/rejected and is not eligible for the proposer queue."
+              ;;
+            no_open_approved_proposer_issue)
+              MSG="No approved proposer ticket is currently waiting."
+              ;;
+            *)
+              MSG="Proposer Apply: skip - ${SKIP_REASON:-unspecified reason}."
+              ;;
+          esac
+
+          export MSG
+          node --input-type=module - <<'NODE' > /tmp/proposer.skip.comment.json
+          const msg = process.env.MSG || "";
+          process.stdout.write(JSON.stringify({ body: msg }));
+          NODE
+
+          curl -fsS -X POST \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Content-Type: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_TO_COMMENT/comments" \
+            --data-binary @/tmp/proposer.skip.comment.json || true
+
+      - name: NPM harden
+        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
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          cd "$APP_DIR"
+          npm ci --no-audit --no-fund
+
+      - name: Build dist baseline
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          cd "$APP_DIR"
+          npm run build
+
+      - name: Apply proposer batch 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 }}
+        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)"
+          BR="$BATCH_BRANCH"
+          echo "BRANCH=$BR" >> /tmp/proposer.env
+          git checkout -b "$BR"
+
+          export GITEA_OWNER="$OWNER"
+          export GITEA_REPO="$REPO"
+          export FORGE_API="$API_BASE"
+
+          LOG="/tmp/proposer-apply.log"
+          : > "$LOG"
+
+          RC=0
+          FAILED_ISSUE=""
+
+          for ISSUE in $TARGET_ISSUES; do
+            echo "" >> "$LOG"
+            echo "== ticket #$ISSUE ==" >> "$LOG"
+
+            set +e
+            (cd "$APP_DIR" && node scripts/apply-ticket.mjs "$ISSUE" --alias --commit) >> "$LOG" 2>&1
+            STEP_RC=$?
+            set -e
+
+            if [[ "$STEP_RC" -ne 0 ]]; then
+              RC="$STEP_RC"
+              FAILED_ISSUE="$ISSUE"
+              break
+            fi
+          done
+
+          echo "APPLY_RC=$RC" >> /tmp/proposer.env
+          echo "FAILED_ISSUE=${FAILED_ISSUE}" >> /tmp/proposer.env
+
+          echo "Apply log (tail):"
+          tail -n 220 "$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: Rebase bot branch on latest main
+        continue-on-error: true
+        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
+
+          LOG="/tmp/proposer-apply.log"
+
+          git fetch origin "$DEFAULT_BRANCH"
+
+          set +e
+          git rebase "origin/$DEFAULT_BRANCH" >> "$LOG" 2>&1
+          RC=$?
+          set -e
+
+          if [[ "$RC" -ne 0 ]]; then
+            git rebase --abort || true
+          fi
+
+          echo "REBASE_RC=$RC" >> /tmp/proposer.env
+
+          echo "Rebase log (tail):"
+          tail -n 220 "$LOG" || true
+
+      - name: Comment issues on failure
+        if: ${{ always() }}
+        env:
+          FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          APPLY_RC="${APPLY_RC:-0}"
+          REBASE_RC="${REBASE_RC:-0}"
+
+          if [[ "$APPLY_RC" == "0" && "$REBASE_RC" == "0" ]]; then
+            echo "No failure detected"
+            exit 0
+          fi
+
+          test -n "${FORGE_TOKEN:-}" || exit 0
+
+          if [[ -f /tmp/proposer-apply.log ]]; then
+            BODY="$(tail -n 160 /tmp/proposer-apply.log | sed 's/\r$//')"
+          else
+            BODY="(no proposer log found)"
+          fi
+
+          export BODY APPLY_RC REBASE_RC FAILED_ISSUE
+
+          if [[ "$APPLY_RC" != "0" ]]; then
+            export FAILURE_KIND="apply"
+          else
+            export FAILURE_KIND="rebase"
+          fi
+
+          node --input-type=module - <<'NODE' > /tmp/proposer.failure.comment.json
+          const body = process.env.BODY || "";
+          const applyRc = process.env.APPLY_RC || "0";
+          const rebaseRc = process.env.REBASE_RC || "0";
+          const failedIssue = process.env.FAILED_ISSUE || "unknown";
+          const kind = process.env.FAILURE_KIND || "apply";
+
+          const msg =
+            kind === "apply"
+              ? `Batch proposer failed on ticket #${failedIssue} (rc=${applyRc}).\n\n\`\`\`\n${body}\n\`\`\`\n`
+              : `Rebase proposer failed on main (rc=${rebaseRc}).\n\n\`\`\`\n${body}\n\`\`\`\n`;
+
+          process.stdout.write(JSON.stringify({ body: msg }));
+          NODE
+
+          for ISSUE in ${TARGET_ISSUES:-}; do
+            curl -fsS -X POST \
+              -H "Authorization: token $FORGE_TOKEN" \
+              -H "Content-Type: application/json" \
+              "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE/comments" \
+              --data-binary @/tmp/proposer.failure.comment.json || true
+          done
+
+      - name: Late guard against duplicate batch materialization
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+          [[ "${APPLY_RC:-0}" == "0" ]] || exit 0
+          [[ "${REBASE_RC:-0}" == "0" ]] || exit 0
+          [[ "${NOOP:-0}" == "0" ]] || exit 0
+
+          REMOTE_SHA="$(git ls-remote --heads origin "$BATCH_BRANCH" | awk 'NR==1 {print $1}')"
+
+          if [[ -n "${REMOTE_SHA:-}" && "${REMOTE_SHA}" != "${END_SHA:-}" ]]; then
+            echo 'SKIP=1' >> /tmp/proposer.env
+            echo 'SKIP_REASON="batch_branch_already_materialized"' >> /tmp/proposer.env
+            echo "OPEN_PR_BRANCH=${BATCH_BRANCH}" >> /tmp/proposer.env
+            echo "Remote batch branch already exists at $REMOTE_SHA -> skip duplicate push/PR"
+            exit 0
+          fi
+
+          echo "Late guard OK"
+
+      - 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; }
+          [[ "${REBASE_RC:-0}" == "0" ]] || { echo "Rebase 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 issues + close issues
+        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
+          [[ "${REBASE_RC:-0}" == "0" ]] || exit 0
+          [[ "${NOOP:-0}" == "0" ]] || exit 0
+          [[ -n "${BRANCH:-}" ]] || { echo "BRANCH unset -> skip PR"; exit 0; }
+
+          test -n "${FORGE_TOKEN:-}" || { echo "Missing FORGE_TOKEN"; exit 1; }
+
+          OPEN_PRS_JSON="$(curl -fsS \
+            -H "Authorization: token $FORGE_TOKEN" \
+            -H "Accept: application/json" \
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/pulls?state=open&limit=100")"
+
+          export OPEN_PRS_JSON BATCH_BRANCH BATCH_KEY
+
+          EXISTING_PR_URL="$(node --input-type=module -e '
+            const pulls = JSON.parse(process.env.OPEN_PRS_JSON || "[]");
+            const branch = String(process.env.BATCH_BRANCH || "");
+            const key = String(process.env.BATCH_KEY || "");
+            const current = Array.isArray(pulls)
+              ? pulls.find((pr) => {
+                  const ref = String(pr?.head?.ref || "");
+                  const body = String(pr?.body || "");
+                  return (branch && ref === branch) || (key && body.includes(`Batch-Key: ${key}`));
+                })
+              : null;
+            process.stdout.write(current ? String(current.html_url || current.url || "") : "");
+          ')"
+
+          if [[ -n "${EXISTING_PR_URL:-}" ]]; then
+            echo "PR already exists for this batch: $EXISTING_PR_URL"
+            exit 0
+          fi
+
+          if [[ "${TARGET_COUNT:-0}" == "1" ]]; then
+            PR_TITLE="proposer: apply ticket #${TARGET_PRIMARY_ISSUE}"
+          else
+            PR_TITLE="proposer: apply ${TARGET_COUNT} tickets on ${TARGET_CHEMIN}"
+          fi
+
+          export PR_TITLE TARGET_CHEMIN TARGET_ISSUES BRANCH END_SHA DEFAULT_BRANCH OWNER BATCH_KEY
+
+          node --input-type=module -e '
+            import fs from "node:fs";
+
+            const issues = String(process.env.TARGET_ISSUES || "")
+              .trim()
+              .split(/\s+/)
+              .filter(Boolean);
+
+            const body = [
+              `PR auto depuis ticket${issues.length > 1 ? "s" : ""} ${issues.map((n) => `#${n}`).join(", ")} (state/approved).`,
+              "",
+              `- Chemin: ${process.env.TARGET_CHEMIN || "(inconnu)"}`,
+              "- Tickets:",
+              ...issues.map((n) => `  - #${n}`),
+              `- Branche: ${process.env.BRANCH || ""}`,
+              `- Commit: ${process.env.END_SHA || "unknown"}`,
+              `- Batch-Key: ${process.env.BATCH_KEY || ""}`,
+              "",
+              "Merge si CI OK."
+            ].join("\n");
+
+            fs.writeFileSync(
+              "/tmp/proposer.pr.json",
+              JSON.stringify({
+                title: process.env.PR_TITLE || "proposer: apply tickets",
+                body,
+                base: process.env.DEFAULT_BRANCH || "main",
+                head: `${process.env.OWNER}:${process.env.BRANCH}`,
+                allow_maintainer_edit: true
+              })
+            );
+          '
+
+          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 @/tmp/proposer.pr.json)"
+
+          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
+          }
+
+          for ISSUE in $TARGET_ISSUES; do
+            export ISSUE PR_URL
+
+            node --input-type=module -e '
+              import fs from "node:fs";
+
+              const issue = process.env.ISSUE || "";
+              const url = process.env.PR_URL || "";
+              const msg =
+                `PR proposer creee pour le ticket #${issue} : ${url}\n\n` +
+                `Le ticket est cloture automatiquement ; la discussion peut se poursuivre dans la PR.`;
+
+              fs.writeFileSync(
+                "/tmp/proposer.issue.close.comment.json",
+                JSON.stringify({ body: msg })
+              );
+            '
+
+            curl -fsS -X POST \
+              -H "Authorization: token $FORGE_TOKEN" \
+              -H "Content-Type: application/json" \
+              "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE/comments" \
+              --data-binary @/tmp/proposer.issue.close.comment.json
+
+            curl -fsS -X PATCH \
+              -H "Authorization: token $FORGE_TOKEN" \
+              -H "Content-Type: application/json" \
+              "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE" \
+              --data-binary '{"state":"closed"}'
+
+            ISSUE_STATE="$(curl -fsS \
+              -H "Authorization: token $FORGE_TOKEN" \
+              -H "Accept: application/json" \
+              "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE" | \
+              node --input-type=module -e 'let s=""; process.stdin.on("data", d => s += d); process.stdin.on("end", () => { const j = JSON.parse(s || "{}"); process.stdout.write(String(j.state || "")); });')"
+
+            [[ "$ISSUE_STATE" == "closed" ]] || {
+              echo "Issue #$ISSUE is still not closed after PATCH"
+              exit 1
+            }
+          done
+
+          echo "PR: $PR_URL"
+
+      - name: Finalize
+        if: ${{ always() }}
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env || true
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
+          if [[ "${APPLY_RC:-0}" != "0" ]]; then
+            echo "Apply failed (rc=${APPLY_RC})"
+            exit "${APPLY_RC}"
+          fi
+
+          if [[ "${REBASE_RC:-0}" != "0" ]]; then
+            echo "Rebase failed (rc=${REBASE_RC})"
+            exit "${REBASE_RC}"
+          fi
+
+          echo "Proposer queue OK"

.gitea/workflows/smoke.yml

@@ -3,7 +3,7 @@ on: [push, workflow_dispatch]
 
 jobs:
   smoke:
-    runs-on: ubuntu-latest
+    runs-on: mac-ci
     steps:
       - run: node -v && npm -v
       - run: echo "runner OK"

.gitignore

@@ -28,3 +28,7 @@ public/favicon_io.zip
 
 # macOS
 .DS_Store
+
+# local temp workspace
+.tmp/
+public/__ops/health.json

astro.config.mjs

@@ -86,6 +86,10 @@ function rehypeDedupeIds() {
 }
 
 export default defineConfig({
+  legacy: {
+    collectionsBackwardsCompat: true,
+  },
+  
   output: "static",
   trailingSlash: "always",
   site: process.env.PUBLIC_SITE ?? "http://localhost:4321",

config/anchor-churn-allowlist.json

@@ -0,0 +1,5 @@
+{
+  "accepted_resets": {
+    "archicrat-ia/chapitre-1/index.html": "Reset intentionnel des ancres après révision doctrinale substantielle du chapitre 1. Site neuf, sans annotations ni compatibilité descendante à préserver."
+  }
+}

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/START-HERE.md

@@ -1,51 +1,147 @@
-# START-HERE — Archicratie / Édition Web (v2)
-> Onboarding + exploitation “nickel chrome” (DEV → Gitea → CI → Release → Blue/Green → Edge/SSO)
+# START-HERE — Archicratie / Édition Web (v3)
+> Onboarding + exploitation “nickel chrome” (DEV → Gitea → CI → Release → Blue/Green → Edge/SSO → localhost auto-sync)
 
 ## 0) TL;DR (la règle d’or)
-- **Gitea = source canonique**.  
-- **main est protégé** : toute modification passe par **branche → PR → CI → merge**.  
-- **Le NAS n’est pas la source** : si un hotfix est fait sur NAS, on **backporte** via PR immédiatement.
-- **Le site est statique Astro** : la prod sert du HTML (nginx), l’accès est contrôlé au niveau reverse-proxy (Traefik + Authelia).
+
+- **Gitea = source canonique**.
+- **`main` est protégée** : toute modification passe par **branche → PR → CI → merge**.
+- **Le NAS n’est pas la source** : si un hotfix est fait sur NAS, il doit être **backporté immédiatement** via PR.
+- **Le site est statique Astro** : la prod sert du HTML via nginx ; l’accès est contrôlé au niveau reverse-proxy (Traefik + Authelia).
+- **Le localhost automatique n’est pas le repo de dev** : il tourne depuis un **worktree dédié**, synchronisé sur `origin/main`.
+
+---
 
 ## 1) Architecture mentale (ultra simple)
-- **DEV (Mac Studio)** : édition + tests + commit + push
-- **Gitea** : dépôt canon + PR + CI (CI.yaml)
-- **NAS (DS220+)** : déploiement “blue/green”
-  - `web_blue` (staging upstream) → `127.0.0.1:8081`
-  - `web_green` (live upstream) → `127.0.0.1:8082`
-- **Edge (Traefik)** : route les hosts
+
+- **DEV canonique (Mac Studio)** : édition, dev, tests, commits, pushes
+- **Gitea** : dépôt canonique, PR, CI, workflows éditoriaux
+- **NAS (DS220+)** : déploiement blue/green
+  - `web_blue` → staging upstream → `127.0.0.1:8081`
+  - `web_green` → live upstream → `127.0.0.1:8082`
+- **Edge (Traefik)** : routage des hosts
   - `staging.archicratie...` → 8081
   - `archicratie...` → 8082
   - **Authelia** devant, via middleware `chain-auth@file`
+- **Localhost auto-sync**
+  - un **repo canonique de développement**
+  - un **worktree localhost miroir de `origin/main`**
+  - un **agent de sync**
+  - un **agent Astro**
+
+---
 
 ## 2) Répertoires & conventions (repo)
+
 ### 2.1 Contenu canon (édition)
-- `src/content/**` : contenu MD / MDX canon (Astro content collections)
-- `src/pages/**` : routes Astro (index, [...slug], etc.)
-- `src/components/**` : composants UI (SiteNav, TOC, SidePanel, etc.)
-- `src/layouts/**` : layouts (EditionLayout, SiteLayout)
+
+- `src/content/**` : contenu MD / MDX canon
+- `src/pages/**` : routes Astro
+- `src/components/**` : composants UI
+- `src/layouts/**` : layouts
 - `src/styles/**` : CSS global
 
 ### 2.2 Annotations (pré-Édition “tickets”)
+
 - `src/annotations/<workKey>/<slug>.yml`
-  - Exemple : `src/annotations/archicrat-ia/prologue.yml`
-- Objectif : stocker “Références / Médias / Commentaires” par page et par paragraphe (`p-...`).
+- Exemple :
+  `src/annotations/archicrat-ia/prologue.yml`
+
+Objectif :
+stocker “Références / Médias / Commentaires” par page et par paragraphe (`p-...`).
 
 ### 2.3 Scripts (tooling / build)
-- `scripts/inject-anchor-aliases.mjs` : injection aliases dans dist
-- `scripts/dedupe-ids-dist.mjs` : retire IDs dupliqués dans dist
-- `scripts/build-para-index.mjs` : index paragraphes (postbuild / predev)
-- `scripts/build-annotations-index.mjs` : index annotations (postbuild / predev)
-- `scripts/check-anchors.mjs` : contrat stabilité d’ancres (CI)
+
+- `scripts/inject-anchor-aliases.mjs` : injection aliases dans `dist`
+- `scripts/dedupe-ids-dist.mjs` : retrait IDs dupliqués
+- `scripts/build-para-index.mjs` : index paragraphes
+- `scripts/build-annotations-index.mjs` : index annotations
+- `scripts/check-anchors.mjs` : contrat stabilité d’ancres
 - `scripts/check-annotations*.mjs` : sanity YAML + médias
 
-> Important : les scripts sont **partie intégrante** de la stabilité (IDs/ancres/indexation).  
-> On évite “la magie” : tout est scripté + vérifié.
+> Important : ces scripts ne sont pas accessoires.  
+> Ils font partie du contrat de stabilité éditoriale.
 
-## 3) Workflow Git “pro” (main protégé)
-### 3.1 Cycle standard (toute modif)
-en bash :
+---
 
+## 3) Les trois espaces à ne jamais confondre
+
+### 3.1 Repo canonique de développement
+
+```text
+/Volumes/FunIA/dev/archicratie-edition/site
+```
+
+Usage :
+
+- développement normal
+- branches de travail
+- nouvelles fonctionnalités
+- corrections manuelles
+- commits
+- pushes
+- PR
+
+### 3.2 Worktree localhost miroir de `main`
+
+```text
+/Users/s-funia/ops-local/archicratie/localhost-worktree
+```
+
+Branche attendue :
+
+```text
+localhost-sync
+```
+
+Usage :
+
+- exécuter le localhost automatique
+- refléter `origin/main`
+- ne jamais servir d’espace de développement
+
+### 3.3 Ops local hors repo
+
+```text
+/Users/s-funia/ops-local/archicratie
+```
+
+Usage :
+
+- scripts d’exploitation
+- état
+- logs
+- automatisation `launchd`
+
+---
+
+## 4) Pourquoi cette séparation existe
+
+Il ne faut pas utiliser le repo canonique de développement comme serveur localhost permanent.
+
+Sinon on mélange :
+
+- travail en cours
+- commits non poussés
+- essais temporaires
+- état réellement publié sur `main`
+
+Le résultat devient ambigu.
+
+La séparation retenue est donc :
+
+- **repo canonique** = espace de développement
+- **worktree localhost** = miroir exécutable de `origin/main`
+- **ops local** = scripts et automatisation
+
+C’est cette séparation qui rend le système lisible, robuste et opérable.
+
+---
+
+## 5) Workflow Git “pro” (main protégée)
+
+### 5.1 Cycle standard (toute modif)
+
+```bash
 git checkout main
 git pull --ff-only
 
@@ -60,37 +156,48 @@ npm run test:anchors
 git add -A
 git commit -m "xxx: description claire"
 git push -u origin "$BR"
+```
 
-### 3.2 PR vers main
+### 5.2 PR vers `main`
 
-Ouvrir PR dans Gitea
+- ouvrir une PR dans Gitea
+- attendre une CI verte
+- merger
+- laisser les workflows faire le reste
 
-CI doit être verte
+### 5.3 Cas spécial : hotfix prod (NAS)
 
-Merge PR → main
+On peut faire un hotfix d’urgence côté NAS si nécessaire.
 
-### 3.3 Cas spécial : hotfix prod (NAS)
+Mais l’état final doit toujours revenir dans Gitea :
 
-On peut faire un hotfix “urgence” en prod/staging si nécessaire…
+- branche
+- PR
+- CI
+- merge
 
-MAIS : l’état final doit revenir dans Gitea : branche → PR → CI → merge.
+---
 
-## 4) Déploiement (NAS) — principe
-### 4.1 Release pack
+## 6) Déploiement (NAS) — principe
 
-On génère un pack “reproductible” (source + config + scripts) puis on déploie.
+### 6.1 Release pack
 
-### 4.2 Blue/Green
+On génère un pack reproductible, puis on déploie.
 
-web_blue = staging upstream (8081)
+### 6.2 Blue/Green
 
-web_green = live upstream (8082)
+- `web_blue` = staging (`8081`)
+- `web_green` = live (`8082`)
 
-Edge Traefik sélectionne quel host pointe vers quel upstream.
+Le reverse-proxy choisit l’upstream selon le host demandé.
 
-## 5) Check-list “≤ 10 commandes” (happy path complet)
-### 5.1 DEV (Mac)
+---
 
+## 7) Happy path complet
+
+### 7.1 DEV (Mac)
+
+```bash
 git checkout main && git pull --ff-only
 git checkout -b chore/my-change-$(date +%Y%m%d)
 
@@ -99,55 +206,258 @@ rm -rf .astro node_modules/.vite dist
 npm run build
 npm run test:anchors
 npm run dev
+```
 
-### 5.2 Push + PR
+### 7.2 Push + PR
 
+```bash
 git add -A
 git commit -m "chore: my change"
 git push -u origin chore/my-change-YYYYMMDD
-# ouvrir PR dans Gitea
+```
 
-### 5.3 Déploiement NAS (résumé)
+Puis ouvrir la PR dans Gitea.
 
-Voir docs/runbooks/DEPLOY-BLUE-GREEN.md.
+### 7.3 Déploiement NAS
 
-## 6) Problèmes “classiques” + diagnostic rapide
-### 6.1 “Le staging ne ressemble pas au local”
+Voir :
 
-# Comparer upstream direct 8081 vs 8082 :
+```text
+docs/runbooks/DEPLOY-BLUE-GREEN.md
+```
 
+---
+
+## 8) Localhost auto-sync — ce qu’il faut retenir
+
+Le localhost automatique sert à voir **la vérité de `main`**, pas à développer du neuf.
+
+### 8.1 Scripts principaux
+
+#### Script de sync
+
+```text
+~/ops-local/archicratie/auto-sync-localhost.sh
+```
+
+Rôle :
+
+- fetch `origin/main`
+- réaligner le worktree localhost
+- lancer `npm ci` si besoin
+- redéclencher l’agent Astro si nécessaire
+
+#### Script Astro
+
+```text
+~/ops-local/archicratie/run-astro-localhost.sh
+```
+
+Rôle :
+
+- lancer `astro dev`
+- depuis le bon worktree
+- avec le bon runtime Node
+- sur `127.0.0.1:4321`
+
+> Oui : ce script est nécessaire.  
+> Il isole proprement le lancement du serveur Astro dans un contexte `launchd` stable.
+
+### 8.2 LaunchAgents
+
+#### Agent sync
+
+```text
+~/Library/LaunchAgents/me.archicratie.localhost-sync.plist
+```
+
+#### Agent Astro
+
+```text
+~/Library/LaunchAgents/me.archicratie.localhost-astro.plist
+```
+
+### 8.3 Document de référence
+
+Pour tout le détail d’exploitation du localhost automatique, lire :
+
+```text
+docs/OPS-LOCALHOST-AUTO-SYNC.md
+```
+
+---
+
+## 9) Règle d’or : il y a deux usages locaux distincts
+
+### 9.1 Voir ce qui est réellement sur `main`
+
+Utiliser :
+
+```text
+http://127.0.0.1:4321
+```
+
+Ce localhost doit être considéré comme :
+
+**un miroir local exécutable de `origin/main`**
+
+### 9.2 Développer / tester une nouvelle fonctionnalité
+
+Utiliser le repo canonique :
+
+```bash
+cd /Volumes/FunIA/dev/archicratie-edition/site
+npm run dev
+```
+
+Donc :
+
+- **localhost auto-sync** = vérité de `main`
+- **localhost de dev manuel** = expérimentation en cours
+
+Il ne faut pas les confondre.
+
+---
+
+## 10) Ce qu’il ne faut pas faire
+
+### 10.1 Ne pas développer dans le worktree localhost
+
+Le worktree localhost est piloté automatiquement.
+
+Il peut être :
+
+- réaligné
+- nettoyé
+- redémarré
+
+Donc :
+
+- pas de commits dedans
+- pas de dev feature dedans
+- pas d’expérimentation de fond dedans
+
+### 10.2 Ne pas utiliser le repo canonique comme miroir auto-sync
+
+Sinon on mélange :
+
+- espace de dev
+- état publié
+- serveur local permanent
+
+### 10.3 Ne pas remettre les scripts ops sur un volume externe
+
+Les scripts d’ops doivent rester sous `HOME`.
+
+Le fait de les mettre sous `/Volumes/...` a déjà provoqué des erreurs du type :
+
+```text
+Operation not permitted
+```
+
+### 10.4 Ne pas supprimer `run-astro-localhost.sh`
+
+Ce script fait partie de l’architecture actuelle.
+Le supprimer reviendrait à réintroduire le flou entre sync Git et exécution d’Astro.
+
+---
+
+## 11) Commandes de contrôle essentielles
+
+### 11.1 État global
+
+```bash
+~/ops-local/archicratie/doctor-localhost.sh
+```
+
+### 11.2 État Git
+
+```bash
+git -C ~/ops-local/archicratie/localhost-worktree rev-parse HEAD
+git -C /Volumes/FunIA/dev/archicratie-edition/site ls-remote origin refs/heads/main
+git -C ~/ops-local/archicratie/localhost-worktree branch --show-current
+```
+
+### 11.3 État LaunchAgents
+
+```bash
+launchctl print "gui/$(id -u)/me.archicratie.localhost-sync" | sed -n '1,160p'
+launchctl print "gui/$(id -u)/me.archicratie.localhost-astro" | sed -n '1,160p'
+```
+
+### 11.4 État logs
+
+```bash
+tail -n 120 ~/ops-local/archicratie/logs/auto-sync-localhost.log
+tail -n 120 ~/ops-local/archicratie/logs/astro-localhost.log
+tail -n 80 ~/Library/Logs/archicratie-localhost-sync.err.log
+tail -n 80 ~/Library/Logs/archicratie-localhost-astro.err.log
+```
+
+### 11.5 État serveur
+
+```bash
+lsof -nP -iTCP:4321 -sTCP:LISTEN
+PID="$(lsof -tiTCP:4321 -sTCP:LISTEN | head -n 1)"
+ps -p "$PID" -o pid=,command=
+lsof -a -p "$PID" -d cwd
+```
+
+### 11.6 Vérification contenu
+
+```bash
+curl -s http://127.0.0.1:4321/archicrat-ia/prologue/ | grep -n "taxe Zucman"
+```
+
+---
+
+## 12) Problèmes classiques + diagnostic
+
+### 12.1 “Le staging ne ressemble pas au local”
+
+Comparer les upstream directs :
+
+```bash
 curl -sS http://127.0.0.1:8081/ | head -n 2
 curl -sS http://127.0.0.1:8082/ | head -n 2
+```
 
-# Vérifier quel routeur edge répond (header diag) :
+Vérifier le routeur edge :
 
+```bash
 curl -sSI -H 'Host: staging.archicratie.trans-hands.synology.me' http://127.0.0.1:18080/ \
  | grep -iE 'HTTP/|location:|x-archi-router'
+```
 
-# Lire docs/runbooks/EDGE-TRAEFIK.md.
+Voir :
 
-### 6.2 Canonical incorrect (localhost en prod)
+```text
+docs/runbooks/EDGE-TRAEFIK.md
+```
 
-Cause racine : site dans Astro = PUBLIC_SITE non injecté au build.
+### 12.2 Canonical incorrect
 
-Fix canonique : voir docs/runbooks/ENV-PUBLIC_SITE.md.
+Cause probable : `PUBLIC_SITE` mal injecté au build.
 
 Test :
 
+```bash
 curl -sS http://127.0.0.1:8082/ | grep -oE 'rel="canonical" href="[^"]+"' | head -1
+```
 
-### 6.3 Contrat “anchors” en échec après migration d’URL
+Voir :
 
-Quand on déplace des routes (ex: /archicratie/archicrat-ia/* → /archicrat-ia/*), le test d’ancres peut échouer même si les IDs n’ont pas changé, car les pages ont changé de chemin.
+```text
+docs/runbooks/ENV-PUBLIC_SITE.md
+```
 
-# Procédure safe :
+### 12.3 Contrat anchors en échec après migration d’URL
 
-Backup baseline :
+Procédure safe :
 
+```bash
 cp -a tests/anchors-baseline.json /tmp/anchors-baseline.json.bak.$(date +%F-%H%M%S)
 
-Mettre à jour les clés (chemins) sans toucher aux IDs :
-
 node - <<'NODE'
 import fs from 'fs';
 const p='tests/anchors-baseline.json';
@@ -161,16 +471,213 @@ fs.writeFileSync(p, JSON.stringify(out,null,2)+'\n');
 console.log('updated keys:', Object.keys(j).length, '->', Object.keys(out).length);
 NODE
 
-Re-run :
-
 npm run test:anchors
+```
 
-## 7) Ce que l’étape 9 doit faire (orientation)
+### 12.4 “Le localhost auto-sync ne montre pas les dernières modifs”
 
-Stabiliser le pipeline “tickets → YAML annotations”
+Commande réflexe :
 
-Formaliser la spec YAML + merge + anti-doublon (voir docs/EDITORIAL-ANNOTATIONS-SPEC.md)
+```bash
+~/ops-local/archicratie/doctor-localhost.sh
+```
 
-Durcir l’onboarding (ce START-HERE + runbooks)
+Puis :
 
-Éviter les régressions par tests (anchors / annotations / smoke)
+```bash
+git -C ~/ops-local/archicratie/localhost-worktree rev-parse HEAD
+git -C /Volumes/FunIA/dev/archicratie-edition/site ls-remote origin refs/heads/main
+```
+
+Si les SHA diffèrent :
+- le sync n’a pas tourné
+- ou l’agent sync a un problème
+
+### 12.5 “Le SHA est bon mais le contenu web est faux”
+
+Vérifier quel Astro écoute réellement :
+
+```bash
+lsof -nP -iTCP:4321 -sTCP:LISTEN
+PID="$(lsof -tiTCP:4321 -sTCP:LISTEN | head -n 1)"
+ps -p "$PID" -o pid=,command=
+lsof -a -p "$PID" -d cwd
+```
+
+Attendu :
+- commande contenant `astro dev`
+- cwd = `~/ops-local/archicratie/localhost-worktree`
+
+### 12.6 Erreur `EBADENGINE`
+
+Cause probable :
+- Node 23 utilisé au lieu de Node 22
+
+Résolution :
+- forcer `node@22` dans les scripts et les LaunchAgents
+
+### 12.7 Erreur `Operation not permitted`
+
+Cause probable :
+- scripts d’ops placés sous `/Volumes/...`
+
+Résolution :
+- garder les scripts sous :
+
+```text
+~/ops-local/archicratie
+```
+
+### 12.8 Erreur `EPERM` sur `astro.mjs`
+
+Cause probable :
+- ancien worktree sur volume externe
+- ancien chemin résiduel
+- Astro lancé depuis un mauvais emplacement
+
+Résolution :
+- worktree localhost sous :
+
+```text
+~/ops-local/archicratie/localhost-worktree
+```
+
+- scripts cohérents avec ce chemin
+- réinstallation propre via :
+
+```bash
+~/ops-local/archicratie/install-localhost-sync.sh
+```
+
+---
+
+## 13) Redémarrage machine
+
+Après reboot, le comportement attendu est :
+
+1. le LaunchAgent sync se recharge
+2. le LaunchAgent Astro se recharge
+3. le worktree localhost est réaligné
+4. Astro redémarre sur `127.0.0.1:4321`
+
+### Vérification rapide après reboot
+
+```bash
+~/ops-local/archicratie/doctor-localhost.sh
+```
+
+Si nécessaire :
+
+```bash
+~/ops-local/archicratie/install-localhost-sync.sh
+```
+
+---
+
+## 14) Procédure de secours manuelle
+
+### Forcer un sync
+
+```bash
+~/ops-local/archicratie/auto-sync-localhost.sh
+```
+
+### Réinstaller proprement le dispositif local
+
+```bash
+~/ops-local/archicratie/install-localhost-sync.sh
+```
+
+### Diagnostic complet
+
+```bash
+~/ops-local/archicratie/doctor-localhost.sh
+```
+
+---
+
+## 15) Décision d’exploitation finale
+
+La politique retenue est la suivante :
+
+- **repo canonique** = espace de développement
+- **worktree localhost** = miroir automatique de `main`
+- **ops sous HOME** = scripts, logs, automation
+- **LaunchAgent sync** = réalignement Git
+- **LaunchAgent Astro** = exécution stable du serveur local
+- **Astro local** = lancé uniquement depuis le worktree localhost
+
+Cette séparation rend le dispositif plus :
+
+- lisible
+- robuste
+- opérable
+- antifragile
+
+---
+
+## 16) Résumé opératoire
+
+### Pour voir la vérité de `main`
+
+Ouvrir :
+
+```text
+http://127.0.0.1:4321
+```
+
+Le serveur doit provenir de :
+
+```text
+/Users/s-funia/ops-local/archicratie/localhost-worktree
+```
+
+### Pour développer
+
+Travailler dans :
+
+```text
+/Volumes/FunIA/dev/archicratie-edition/site
+```
+
+avec les commandes habituelles.
+
+### Pour réparer vite
+
+```bash
+~/ops-local/archicratie/doctor-localhost.sh
+~/ops-local/archicratie/auto-sync-localhost.sh
+```
+
+---
+
+## 17) Mémoire courte
+
+Si un jour plus rien n’est clair, repartir de ces commandes :
+
+```bash
+~/ops-local/archicratie/doctor-localhost.sh
+git -C ~/ops-local/archicratie/localhost-worktree rev-parse HEAD
+git -C /Volumes/FunIA/dev/archicratie-edition/site ls-remote origin refs/heads/main
+lsof -nP -iTCP:4321 -sTCP:LISTEN
+```
+
+Puis lire :
+
+```bash
+tail -n 120 ~/ops-local/archicratie/logs/auto-sync-localhost.log
+tail -n 120 ~/ops-local/archicratie/logs/astro-localhost.log
+```
+
+---
+
+## 18) Statut actuel visé
+
+Quand tout fonctionne correctement :
+
+- le worktree localhost pointe sur le même SHA que `origin/main`
+- `astro dev` écoute sur `127.0.0.1:4321`
+- son cwd est `~/ops-local/archicratie/localhost-worktree`
+- le contenu servi correspond au contenu mergé sur `main`
+
+C’est l’état de référence à préserver.

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.json

@@ -10,7 +10,8 @@
     "clean": "rm -rf dist",
     "build": "astro build",
     "build:clean": "npm run clean && npm run build",
-    "postbuild": "node scripts/inject-anchor-aliases.mjs && node scripts/dedupe-ids-dist.mjs && node scripts/build-para-index.mjs && node scripts/build-annotations-index.mjs && node scripts/purge-dist-dev-whoami.mjs && npx pagefind --site dist",
+    "build:search": "pagefind --site dist",
+    "postbuild": "node scripts/inject-anchor-aliases.mjs && node scripts/dedupe-ids-dist.mjs && node scripts/build-para-index.mjs && node scripts/build-annotations-index.mjs && node scripts/purge-dist-dev-whoami.mjs && npm run build:search",
     "import": "node scripts/import-docx.mjs",
     "apply:ticket": "node scripts/apply-ticket.mjs",
     "audit:dist": "node scripts/audit-dist.mjs",
@@ -25,11 +26,11 @@
     "ci": "CI=1 npm test"
   },
   "dependencies": {
-    "@astrojs/mdx": "^4.3.13",
-    "astro": "^5.17.3"
+    "@astrojs/mdx": "^5.0.0",
+    "astro": "^6.0.2"
   },
   "devDependencies": {
-    "@astrojs/sitemap": "^3.7.0",
+    "@astrojs/sitemap": "^3.7.1",
     "mammoth": "^1.11.0",
     "pagefind": "^1.4.0",
     "rehype-autolink-headings": "^7.1.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/apply-ticket.mjs

@@ -9,8 +9,9 @@ import { spawnSync } from "node:child_process";
  *
  * Conçu pour:
  * - prendre un ticket [Correction]/[Fact-check] (issue) avec Chemin + Ancre + Proposition
- * - retrouver le bon paragraphe dans le .mdx
+ * - retrouver le bon paragraphe dans le .mdx/.md
  * - remplacer proprement
+ * - ne JAMAIS toucher au frontmatter
  * - optionnel: écrire un alias d’ancre old->new (build-time) dans src/anchors/anchor-aliases.json
  * - optionnel: committer automatiquement
  * - optionnel: fermer le ticket (après commit)
@@ -39,7 +40,7 @@ Env (recommandé):
 
 Notes:
   - Si dist/<chemin>/index.html est absent, le script lance "npm run build" sauf si --no-build.
-  - Sauvegarde automatique: <fichier>.bak.issue-<N> (uniquement si on écrit)
+  - Sauvegarde automatique: .tmp/apply-ticket/<fichier>.bak.issue-<N> (uniquement si on écrit)
   - Avec --alias : le script rebuild pour identifier le NOUVEL id, puis écrit l'alias old->new.
   - Refuse automatiquement les Pull Requests (PR) : ce ne sont pas des tickets éditoriaux.
 `);
@@ -89,6 +90,7 @@ const CWD = process.cwd();
 const CONTENT_ROOT = path.join(CWD, "src", "content");
 const DIST_ROOT = path.join(CWD, "dist");
 const ALIASES_FILE = path.join(CWD, "src", "anchors", "anchor-aliases.json");
+const BACKUP_ROOT = path.join(CWD, ".tmp", "apply-ticket");
 
 /* -------------------------- utils texte / matching -------------------------- */
 
@@ -136,31 +138,26 @@ function scoreText(candidate, targetText) {
   let hit = 0;
   for (const w of tgtSet) if (blkSet.has(w)) hit++;
 
-  // Bonus si un long préfixe ressemble
   const tgtNorm = normalizeText(stripMd(targetText));
   const blkNorm = normalizeText(stripMd(candidate));
   const prefix = tgtNorm.slice(0, Math.min(180, tgtNorm.length));
   const prefixBonus = prefix && blkNorm.includes(prefix) ? 1000 : 0;
 
-  // Ratio bonus (0..100)
   const ratio = hit / Math.max(1, tgtSet.size);
   const ratioBonus = Math.round(ratio * 100);
 
   return prefixBonus + hit + ratioBonus;
 }
 
-function bestBlockMatchIndex(blocks, targetText) {
-  let best = { i: -1, score: -1 };
-  for (let i = 0; i < blocks.length; i++) {
-    const sc = scoreText(blocks[i], targetText);
-    if (sc > best.score) best = { i, score: sc };
-  }
-  return best;
-}
-
-function splitParagraphBlocks(mdxText) {
-  const raw = String(mdxText ?? "").replace(/\r\n/g, "\n");
-  return raw.split(/\n{2,}/);
+function rankedBlockMatches(blocks, targetText, limit = 5) {
+  return blocks
+    .map((b, i) => ({
+      i,
+      score: scoreText(b, targetText),
+      excerpt: stripMd(b).slice(0, 140),
+    }))
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
 }
 
 function isLikelyExcerpt(s) {
@@ -172,6 +169,89 @@ function isLikelyExcerpt(s) {
   return false;
 }
 
+/* --------------------------- frontmatter / structure ------------------------ */
+
+function normalizeNewlines(s) {
+  return String(s ?? "").replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+}
+
+function splitMdxFrontmatter(src) {
+  const text = normalizeNewlines(src);
+  const m = text.match(/^---\n[\s\S]*?\n---\n?/);
+
+  if (!m) {
+    return {
+      hasFrontmatter: false,
+      frontmatter: "",
+      body: text,
+    };
+  }
+
+  const frontmatter = m[0];
+  const body = text.slice(frontmatter.length);
+
+  return {
+    hasFrontmatter: true,
+    frontmatter,
+    body,
+  };
+}
+
+function joinMdxFrontmatter(frontmatter, body) {
+  if (!frontmatter) return String(body ?? "");
+  return String(frontmatter) + String(body ?? "");
+}
+
+function assertFrontmatterIntegrity({ hadFrontmatter, originalFrontmatter, finalText, filePath }) {
+  if (!hadFrontmatter) return;
+
+  const text = normalizeNewlines(finalText);
+
+  if (!text.startsWith("---\n")) {
+    throw new Error(`Frontmatter perdu pendant la mise à jour de ${filePath}`);
+  }
+
+  if (!text.startsWith(originalFrontmatter)) {
+    throw new Error(`Frontmatter altéré pendant la mise à jour de ${filePath}`);
+  }
+}
+
+function splitParagraphBlocksPreserve(bodyText) {
+  const text = normalizeNewlines(bodyText);
+
+  if (!text) {
+    return { blocks: [], separators: [] };
+  }
+
+  const blocks = [];
+  const separators = [];
+
+  const re = /(\n{2,})/g;
+  let last = 0;
+  let m;
+
+  while ((m = re.exec(text))) {
+    blocks.push(text.slice(last, m.index));
+    separators.push(m[1]);
+    last = m.index + m[1].length;
+  }
+
+  blocks.push(text.slice(last));
+
+  return { blocks, separators };
+}
+
+function joinParagraphBlocksPreserve(blocks, separators) {
+  if (!Array.isArray(blocks) || blocks.length === 0) return "";
+
+  let out = "";
+  for (let i = 0; i < blocks.length; i++) {
+    out += blocks[i];
+    if (i < separators.length) out += separators[i];
+  }
+  return out;
+}
+
 /* ------------------------------ utils système ------------------------------ */
 
 function run(cmd, args, opts = {}) {
@@ -251,7 +331,9 @@ function pickSection(body, markers) {
     .map((m) => ({ m, i: text.toLowerCase().indexOf(m.toLowerCase()) }))
     .filter((x) => x.i >= 0)
     .sort((a, b) => a.i - b.i)[0];
+
   if (!idx) return "";
+
   const start = idx.i + idx.m.length;
   const tail = text.slice(start);
 
@@ -266,11 +348,13 @@ function pickSection(body, markers) {
     "\n## Proposition",
     "\n## Problème",
   ];
+
   let end = tail.length;
   for (const s of stops) {
     const j = tail.toLowerCase().indexOf(s.toLowerCase());
     if (j >= 0 && j < end) end = j;
   }
+
   return tail.slice(0, end).trim();
 }
 
@@ -298,8 +382,6 @@ function extractAnchorIdAnywhere(text) {
 
 function extractCheminFromAnyUrl(text) {
   const s = String(text || "");
-  // Exemple: http://localhost:4321/archicratie/prologue/#p-3-xxxx
-  // ou: /archicratie/prologue/#p-3-xxxx
   const m = s.match(/(\/[a-z0-9\-]+\/[a-z0-9\-\/]+\/)#p-\d+-[0-9a-f]{8}/i);
   return m ? m[1] : "";
 }
@@ -400,7 +482,7 @@ async function fetchIssue({ forgeApiBase, owner, repo, token, issueNum }) {
     headers: {
       Authorization: `token ${token}`,
       Accept: "application/json",
-      "User-Agent": "archicratie-apply-ticket/2.0",
+      "User-Agent": "archicratie-apply-ticket/2.1",
     },
   });
   if (!res.ok) {
@@ -416,7 +498,7 @@ async function closeIssue({ forgeApiBase, owner, repo, token, issueNum, comment
     Authorization: `token ${token}`,
     Accept: "application/json",
     "Content-Type": "application/json",
-    "User-Agent": "archicratie-apply-ticket/2.0",
+    "User-Agent": "archicratie-apply-ticket/2.1",
   };
 
   if (comment) {
@@ -425,7 +507,11 @@ async function closeIssue({ forgeApiBase, owner, repo, token, issueNum, comment
   }
 
   const url = `${base}/api/v1/repos/${owner}/${repo}/issues/${issueNum}`;
-  const res = await fetch(url, { method: "PATCH", headers, body: JSON.stringify({ state: "closed" }) });
+  const res = await fetch(url, {
+    method: "PATCH",
+    headers,
+    body: JSON.stringify({ state: "closed" }),
+  });
 
   if (!res.ok) {
     const t = await res.text().catch(() => "");
@@ -529,10 +615,9 @@ async function main() {
   console.log(`🔎 Fetch ticket #${issueNum} from ${owner}/${repo} …`);
   const issue = await fetchIssue({ forgeApiBase, owner, repo, token, issueNum });
 
-  // Guard PR (Pull Request = "Demande d'ajout" = pas un ticket éditorial)
   if (issue?.pull_request) {
     console.error(`❌ #${issueNum} est une Pull Request (demande d’ajout), pas un ticket éditorial.`);
-    console.error(`➡️ Ouvre un ticket [Correction]/[Fact-check] depuis le site (Proposer), puis relance apply-ticket sur ce numéro.`);
+    console.error("➡️ Ouvre un ticket [Correction]/[Fact-check] depuis le site (Proposer), puis relance apply-ticket sur ce numéro.");
     process.exit(2);
   }
 
@@ -553,7 +638,6 @@ async function main() {
   ancre = (ancre || "").trim();
   if (ancre.startsWith("#")) ancre = ancre.slice(1);
 
-  // fallback si ticket mal formé
   if (!ancre) ancre = extractAnchorIdAnywhere(title) || extractAnchorIdAnywhere(body);
 
   chemin = normalizeChemin(chemin);
@@ -592,7 +676,6 @@ async function main() {
   const distHtmlPath = path.join(DIST_ROOT, chemin.replace(/^\/+|\/+$/g, ""), "index.html");
   await ensureBuildIfNeeded(distHtmlPath);
 
-  // Texte cible: préférence au texte complet (ticket), sinon dist si extrait probable
   let targetText = texteActuel;
   let distText = "";
 
@@ -609,21 +692,24 @@ async function main() {
     throw new Error("Impossible de reconstruire le texte du paragraphe (ni texte actuel, ni dist html).");
   }
 
-  const original = await fs.readFile(contentFile, "utf-8");
-  const blocks = splitParagraphBlocks(original);
+  const originalRaw = await fs.readFile(contentFile, "utf-8");
+  const { hasFrontmatter, frontmatter, body: originalBody } = splitMdxFrontmatter(originalRaw);
 
-  const best = bestBlockMatchIndex(blocks, targetText);
+  const split = splitParagraphBlocksPreserve(originalBody);
+  const blocks = split.blocks;
+  const separators = split.separators;
+
+  if (!blocks.length) {
+    throw new Error(`Aucun bloc éditorial exploitable dans ${path.relative(CWD, contentFile)}`);
+  }
+
+  const ranked = rankedBlockMatches(blocks, targetText, 5);
+  const best = ranked[0] || { i: -1, score: -1, excerpt: "" };
+  const runnerUp = ranked[1] || null;
 
-  // seuil de sécurité
   if (best.i < 0 || best.score < 40) {
     console.error("❌ Match trop faible: je refuse de remplacer automatiquement.");
     console.error(`➡️  Score=${best.score}. Recommandation: ticket avec 'Texte actuel (copie exacte du paragraphe)'.`);
-
-    const ranked = blocks
-      .map((b, i) => ({ i, score: scoreText(b, targetText), excerpt: stripMd(b).slice(0, 140) }))
-      .sort((a, b) => b.score - a.score)
-      .slice(0, 5);
-
     console.error("Top candidates:");
     for (const r of ranked) {
       console.error(`  #${r.i + 1} score=${r.score}  ${r.excerpt}${r.excerpt.length >= 140 ? "…" : ""}`);
@@ -631,12 +717,34 @@ async function main() {
     process.exit(2);
   }
 
+  if (runnerUp) {
+    const ambiguityGap = best.score - runnerUp.score;
+    if (ambiguityGap < 15) {
+      console.error("❌ Match ambigu: le meilleur candidat est trop proche du second.");
+      console.error(`➡️  best=${best.score} / second=${runnerUp.score} / gap=${ambiguityGap}`);
+      console.error("Top candidates:");
+      for (const r of ranked) {
+        console.error(`  #${r.i + 1} score=${r.score}  ${r.excerpt}${r.excerpt.length >= 140 ? "…" : ""}`);
+      }
+      process.exit(2);
+    }
+  }
+
   const beforeBlock = blocks[best.i];
   const afterBlock = proposition.trim();
 
   const nextBlocks = blocks.slice();
   nextBlocks[best.i] = afterBlock;
-  const updated = nextBlocks.join("\n\n");
+
+  const updatedBody = joinParagraphBlocksPreserve(nextBlocks, separators);
+  const updatedRaw = joinMdxFrontmatter(frontmatter, updatedBody);
+
+  assertFrontmatterIntegrity({
+    hadFrontmatter: hasFrontmatter,
+    originalFrontmatter: frontmatter,
+    finalText: updatedRaw,
+    filePath: path.relative(CWD, contentFile),
+  });
 
   console.log(`🧩 Matched block #${best.i + 1}/${blocks.length} score=${best.score}`);
 
@@ -650,13 +758,15 @@ async function main() {
     return;
   }
 
-  // backup uniquement si on écrit
-  const bakPath = `${contentFile}.bak.issue-${issueNum}`;
+  const relContentFile = path.relative(CWD, contentFile);
+  const bakPath = path.join(BACKUP_ROOT, `${relContentFile}.bak.issue-${issueNum}`);
+  await fs.mkdir(path.dirname(bakPath), { recursive: true });
+
   if (!(await fileExists(bakPath))) {
-    await fs.writeFile(bakPath, original, "utf-8");
+    await fs.writeFile(bakPath, originalRaw, "utf-8");
   }
 
-  await fs.writeFile(contentFile, updated, "utf-8");
+  await fs.writeFile(contentFile, updatedRaw, "utf-8");
   console.log("✅ Applied.");
 
   let aliasChanged = false;
@@ -677,13 +787,13 @@ async function main() {
 
     if (aliasChanged) {
       console.log(`✅ Alias ajouté: ${chemin} ${ancre} -> ${newId}`);
-      // MàJ dist sans rebuild complet (inject seulement)
       run("node", ["scripts/inject-anchor-aliases.mjs"], { cwd: CWD });
     } else {
       console.log(`ℹ️ Alias déjà présent ou inutile (${ancre} -> ${newId}).`);
     }
 
-    // garde-fous rapides
+    run("node", ["scripts/check-anchor-aliases.mjs"], { cwd: CWD });
+    run("node", ["scripts/verify-anchor-aliases-in-dist.mjs"], { cwd: CWD });
     run("npm", ["run", "test:anchors"], { cwd: CWD });
     run("node", ["scripts/check-inline-js.mjs"], { cwd: CWD });
   }
@@ -713,7 +823,6 @@ async function main() {
     return;
   }
 
-  // mode manuel
   console.log("Next (manuel) :");
   console.log(`  git diff -- ${path.relative(CWD, contentFile)}`);
   console.log(
@@ -730,4 +839,4 @@ async function main() {
 main().catch((e) => {
   console.error("💥", e?.message || e);
   process.exit(1);
-});
+});

scripts/check-anchors.mjs

@@ -74,7 +74,24 @@ function loadAllowMissing() {
   return new Set(arr.map(String));
 }
 
+function loadAcceptedResets() {
+  const p = path.resolve("config/anchor-churn-allowlist.json");
+  if (!fssync.existsSync(p)) return {};
+  const raw = fssync.readFileSync(p, "utf8").trim();
+  if (!raw) return {};
+  const data = JSON.parse(raw);
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("anchor-churn-allowlist.json must be an object");
+  }
+  const accepted = data.accepted_resets || {};
+  if (!accepted || typeof accepted !== "object" || Array.isArray(accepted)) {
+    throw new Error("anchor-churn-allowlist.json: accepted_resets must be an object");
+  }
+  return accepted;
+}
+
 const ALLOW_MISSING = loadAllowMissing();
+const ACCEPTED_RESETS = loadAcceptedResets();
 
 async function buildSnapshot() {
   const absDist = path.resolve(DIST_DIR);
@@ -139,6 +156,7 @@ function diffPage(prevIds, curIds) {
 
   let failed = false;
   let changedPages = 0;
+  let acceptedPages = 0;
 
   for (const p of pages) {
     const prevIds = base[p] || null;
@@ -172,6 +190,7 @@ function diffPage(prevIds, curIds) {
     const prevN = prevIds.length || 1;
     const churn = (added.length + removed.length) / prevN;
     const removedRatio = removed.length / prevN;
+    const acceptedReason = ACCEPTED_RESETS[p] || null;
 
     console.log(
       `~ ${p} prev=${prevIds.length} now=${curIds.length}` +
@@ -182,11 +201,23 @@ function diffPage(prevIds, curIds) {
       console.log(`  removed: ${removed.slice(0, 20).join(", ")}${removed.length > 20 ? " …" : ""}`);
     }
 
-    if (prevIds.length >= MIN_PREV && churn > THRESHOLD) failed = true;
-    if (prevIds.length >= MIN_PREV && removedRatio > THRESHOLD) failed = true;
+    const exceeds =
+      (prevIds.length >= MIN_PREV && churn > THRESHOLD) ||
+      (prevIds.length >= MIN_PREV && removedRatio > THRESHOLD);
+
+    if (exceeds && acceptedReason) {
+      acceptedPages += 1;
+      console.log(`  ✅ accepted reset: ${acceptedReason}`);
+      continue;
+    }
+
+    if (exceeds) failed = true;
   }
 
-  console.log(`\nSummary: pages compared=${pages.length}, pages changed=${changedPages}`);
+  console.log(
+    `\nSummary: pages compared=${pages.length}, pages changed=${changedPages}, accepted resets=${acceptedPages}`
+  );
+
   if (failed) {
     console.error(`FAIL: anchor churn above threshold (threshold=${pct(THRESHOLD)} minPrev=${MIN_PREV})`);
     process.exit(1);

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,35 @@ 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 };
+    // Compat legacy :
+    // manifest collection="archicratie" + slug="archicrat-ia/..."
+    // => on écrit bien dans src/content/archicrat-ia/...
+    // => mais on conserve edition/status historiques de type archicratie/modele_sociopolitique
+    const defaultsKey =
+      String(it.collection || "").trim() === "archicratie" &&
+      String(it.slug || "").trim().startsWith("archicrat-ia/")
+        ? "archicratie"
+        : outCollection;
+
+    const defaults =
+      schemaDefaultsByCollection[defaultsKey] || {
+        edition: defaultsKey,
+        status: "draft",
+        level: 1,
+      };
 
     const fm = [
       "---",
@@ -282,4 +320,4 @@ async function main() {
 main().catch((e) => {
   console.error("\nERROR:", e?.message || e);
   process.exit(1);
-});
+});

scripts/pick-proposer-issue.mjs

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import process from "node:process";
+
+function getEnv(name, fallback = "") {
+  return String(process.env[name] ?? fallback).trim();
+}
+
+function sh(value) {
+  return JSON.stringify(String(value ?? ""));
+}
+
+function escapeRegExp(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function pickLine(body, key) {
+  const re = new RegExp(`^\\s*${escapeRegExp(key)}\\s*:\\s*([^\\n\\r]+)`, "mi");
+  const m = String(body || "").match(re);
+  return m ? m[1].trim() : "";
+}
+
+function pickHeadingValue(body, headingKey) {
+  const re = new RegExp(
+    `^##\\s*${escapeRegExp(headingKey)}[^\\n]*\\n([\\s\\S]*?)(?=\\n##\\s|\\n\\s*$)`,
+    "mi"
+  );
+  const m = String(body || "").match(re);
+  if (!m) return "";
+  const lines = m[1].split(/\r?\n/).map((l) => l.trim());
+  for (const l of lines) {
+    if (!l) continue;
+    if (l.startsWith("<!--")) continue;
+    return l.replace(/^\/?/, "/").trim();
+  }
+  return "";
+}
+
+function normalizeChemin(chemin) {
+  let c = String(chemin || "").trim();
+  if (!c) return "";
+  if (!c.startsWith("/")) c = "/" + c;
+  if (!c.endsWith("/")) c += "/";
+  return c;
+}
+
+function extractCheminFromAnyUrl(text) {
+  const s = String(text || "");
+  const m = s.match(/(\/[a-z0-9\-]+\/[a-z0-9\-\/]+\/)#p-\d+-[0-9a-f]{8}/i);
+  return m ? m[1] : "";
+}
+
+function inferType(issue) {
+  const title = String(issue?.title || "");
+  const body = String(issue?.body || "").replace(/\r\n/g, "\n");
+  const fromBody = String(pickLine(body, "Type") || "").trim().toLowerCase();
+  if (fromBody) return fromBody;
+
+  if (title.startsWith("[Correction]")) return "type/correction";
+  if (title.startsWith("[Fact-check]") || title.startsWith("[Vérification]")) return "type/fact-check";
+  return "";
+}
+
+function inferChemin(issue) {
+  const title = String(issue?.title || "");
+  const body = String(issue?.body || "").replace(/\r\n/g, "\n");
+
+  return normalizeChemin(
+    pickLine(body, "Chemin") ||
+      pickHeadingValue(body, "Chemin") ||
+      extractCheminFromAnyUrl(body) ||
+      extractCheminFromAnyUrl(title)
+  );
+}
+
+function labelsOf(issue) {
+  return Array.isArray(issue?.labels)
+    ? issue.labels.map((l) => String(l?.name || "")).filter(Boolean)
+    : [];
+}
+
+function issueNumber(issue) {
+  return Number(issue?.number || issue?.index || 0);
+}
+
+function parseMeta(issue) {
+  const labels = labelsOf(issue);
+  const type = inferType(issue);
+  const chemin = inferChemin(issue);
+  const number = issueNumber(issue);
+
+  const hasApproved = labels.includes("state/approved");
+  const hasRejected = labels.includes("state/rejected");
+  const isProposer = type === "type/correction" || type === "type/fact-check";
+  const isOpen = String(issue?.state || "open") === "open";
+  const isPR = Boolean(issue?.pull_request);
+
+  const eligible =
+    number > 0 &&
+    isOpen &&
+    !isPR &&
+    hasApproved &&
+    !hasRejected &&
+    isProposer &&
+    Boolean(chemin);
+
+  return {
+    issue,
+    number,
+    type,
+    chemin,
+    labels,
+    hasApproved,
+    hasRejected,
+    eligible,
+  };
+}
+
+async function fetchJson(url, token) {
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `token ${token}`,
+      Accept: "application/json",
+      "User-Agent": "archicratie-pick-proposer-issue/1.0",
+    },
+  });
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} ${url}\n${t}`);
+  }
+  return await res.json();
+}
+
+async function fetchIssue(apiBase, owner, repo, token, n) {
+  const url = `${apiBase}/api/v1/repos/${owner}/${repo}/issues/${n}`;
+  return await fetchJson(url, token);
+}
+
+async function listOpenIssues(apiBase, owner, repo, token) {
+  const out = [];
+  let page = 1;
+  const limit = 100;
+
+  while (true) {
+    const url = `${apiBase}/api/v1/repos/${owner}/${repo}/issues?state=open&page=${page}&limit=${limit}`;
+    const batch = await fetchJson(url, token);
+    if (!Array.isArray(batch) || batch.length === 0) break;
+    out.push(...batch);
+    if (batch.length < limit) break;
+    page += 1;
+  }
+
+  return out;
+}
+
+function emitNone(reason) {
+  process.stdout.write(
+    [
+      `TARGET_FOUND="0"`,
+      `TARGET_REASON=${sh(reason)}`,
+      `TARGET_PRIMARY_ISSUE=""`,
+      `TARGET_ISSUES=""`,
+      `TARGET_COUNT="0"`,
+      `TARGET_CHEMIN=""`,
+    ].join("\n") + "\n"
+  );
+}
+
+async function main() {
+  const token = getEnv("FORGE_TOKEN");
+  const owner = getEnv("GITEA_OWNER");
+  const repo = getEnv("GITEA_REPO");
+  const apiBase = (getEnv("FORGE_API") || getEnv("FORGE_BASE")).replace(/\/+$/, "");
+  const explicit = Number(process.argv[2] || 0);
+
+  if (!token) throw new Error("Missing FORGE_TOKEN");
+  if (!owner || !repo) throw new Error("Missing GITEA_OWNER / GITEA_REPO");
+  if (!apiBase) throw new Error("Missing FORGE_API / FORGE_BASE");
+
+  let metas = [];
+
+  if (explicit > 0) {
+    const issue = await fetchIssue(apiBase, owner, repo, token, explicit);
+    const meta = parseMeta(issue);
+
+    if (!meta.eligible) {
+      emitNone(
+        !meta.hasApproved
+          ? "explicit_issue_not_approved"
+          : meta.hasRejected
+            ? "explicit_issue_rejected"
+            : !meta.type
+              ? "explicit_issue_missing_type"
+              : !meta.chemin
+                ? "explicit_issue_missing_chemin"
+                : "explicit_issue_not_eligible"
+      );
+      return;
+    }
+
+    const openIssues = await listOpenIssues(apiBase, owner, repo, token);
+    metas = openIssues.map(parseMeta).filter((m) => m.eligible && m.chemin === meta.chemin);
+  } else {
+    const openIssues = await listOpenIssues(apiBase, owner, repo, token);
+    metas = openIssues.map(parseMeta).filter((m) => m.eligible);
+
+    if (metas.length === 0) {
+      emitNone("no_open_approved_proposer_issue");
+      return;
+    }
+
+    metas.sort((a, b) => a.number - b.number);
+    const first = metas[0];
+    metas = metas.filter((m) => m.chemin === first.chemin);
+  }
+
+  metas.sort((a, b) => a.number - b.number);
+
+  if (metas.length === 0) {
+    emitNone("no_batch_for_path");
+    return;
+  }
+
+  const primary = metas[0];
+  const issues = metas.map((m) => String(m.number));
+
+  process.stdout.write(
+    [
+      `TARGET_FOUND="1"`,
+      `TARGET_REASON="ok"`,
+      `TARGET_PRIMARY_ISSUE=${sh(primary.number)}`,
+      `TARGET_ISSUES=${sh(issues.join(" "))}`,
+      `TARGET_COUNT=${sh(issues.length)}`,
+      `TARGET_CHEMIN=${sh(primary.chemin)}`,
+    ].join("\n") + "\n"
+  );
+}
+
+main().catch((e) => {
+  console.error("💥 pick-proposer-issue:", e?.message || e);
+  process.exit(1);
+});

scripts/write-ops-health.mjs

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const outDir = path.join(root, "public", "__ops");
+const outFile = path.join(outDir, "health.json");
+
+const payload = {
+  service: "archicratie-site",
+  env: process.env.PUBLIC_OPS_ENV || "unknown",
+  upstream: process.env.PUBLIC_OPS_UPSTREAM || "unknown",
+  buildSha: process.env.PUBLIC_BUILD_SHA || "unknown",
+  builtAt: process.env.PUBLIC_BUILD_TIME || new Date().toISOString(),
+};
+
+fs.mkdirSync(outDir, { recursive: true });
+fs.writeFileSync(outFile, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+
+console.log(`✅ ops health written: ${outFile}`);
+console.log(payload);

sources/manifest.yml

@@ -1,13 +1,22 @@
 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"
   # =========================
   - source: sources/docx/archicrat-ia/Prologue—Archicratie-fondation_et_finalite_sociopolitique_et_historique-version_officielle.docx
     collection: archicratie
     slug: archicrat-ia/prologue
-    title: "Prologue — Fondation et finalité sociopolitique et historique"
+    title: "Prologue — Fondation, finalité sociopolitique et historique"
     order: 10
 
   - source: sources/docx/archicrat-ia/Chapitre_1—Fondements_epistemologiques_et_modelisation_Archicratie-version_officielle.docx
@@ -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 @@
 {}
-  

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-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,29 +1,42 @@
 ---
 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/"))
-  .sort((a, b) => (a.data.order ?? 0) - (b.data.order ?? 0));
+const slugOf = (entry) => String(entry.id).replace(/\.(md|mdx)$/i, "");
+const hrefOf = (entry) => `${basePath}/${slugOf(entry)}/`;
 
-// ✅ 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 collator = new Intl.Collator("fr", { sensitivity: "base", numeric: true });
+
+const entries = [...await getCollection(collection)].sort((a, b) => {
+  const ao = Number(a.data.order ?? 9999);
+  const bo = Number(b.data.order ?? 9999);
+  if (ao !== bo) return ao - bo;
+
+  const at = String(a.data.title ?? a.data.term ?? slugOf(a));
+  const bt = String(b.data.title ?? b.data.term ?? slugOf(b));
+  return collator.compare(at, bt);
+});
 ---
 
-<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">
     {entries.map((e) => {
-      const active = e.slug === currentSlug;
+      const slug = slugOf(e);
+      const active = slug === currentSlug;
+
       return (
         <li class={`toc-item ${active ? "is-active" : ""}`}>
-          <a class="toc-link" href={href(e.slug)} aria-current={active ? "page" : undefined}>
+          <a class="toc-link" href={hrefOf(e)} aria-current={active ? "page" : undefined}>
             <span class="toc-link__row">
               {active ? (
                 <span class="toc-active-indicator" aria-hidden="true">👉</span>
@@ -163,4 +176,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/GlossaryAside.astro

@@ -0,0 +1,237 @@
+---
+import {
+  getGlossaryEntryAsideData,
+  getGlossaryPortalLinks,
+  hrefOfGlossaryEntry,
+  slugOfGlossaryEntry,
+} from "../lib/glossary";
+
+const {
+  currentEntry,
+  allEntries = [],
+} = Astro.props;
+
+const currentSlug = slugOfGlossaryEntry(currentEntry);
+
+const {
+  displayFamily,
+  displayDomain,
+  displayLevel,
+  showNoyau,
+  showSameFamily,
+  fondamentaux,
+  sameFamilyTitle,
+  sameFamilyEntries,
+  relationSections,
+  contextualTheory,
+} = getGlossaryEntryAsideData(currentEntry, allEntries);
+
+const portalLinks = getGlossaryPortalLinks();
+---
+
+<nav class="glossary-aside" aria-label="Navigation du glossaire">
+  <div class="glossary-aside__block glossary-aside__block--intro">
+    <a class="glossary-aside__back" href="/glossaire/">← Retour au glossaire</a>
+    <div class="glossary-aside__title">Glossaire archicratique</div>
+
+    <div class="glossary-aside__pills" aria-label="Repères de lecture">
+      <span class="glossary-aside__pill glossary-aside__pill--family">
+        {displayFamily}
+      </span>
+
+      {displayDomain && (
+        <span class="glossary-aside__pill">{displayDomain}</span>
+      )}
+
+      {displayLevel && (
+        <span class="glossary-aside__pill">{displayLevel}</span>
+      )}
+    </div>
+  </div>
+
+  <section class="glossary-aside__block">
+    <h2 class="glossary-aside__heading">Portails</h2>
+    <ul class="glossary-aside__list">
+      {portalLinks.map((item) => (
+        <li><a href={item.href}>{item.label}</a></li>
+      ))}
+    </ul>
+  </section>
+
+  {showNoyau && (
+    <section class="glossary-aside__block">
+      <h2 class="glossary-aside__heading">Noyau archicratique</h2>
+      <ul class="glossary-aside__list">
+        {fondamentaux.map((entry) => {
+          const active = slugOfGlossaryEntry(entry) === currentSlug;
+          return (
+            <li>
+              <a
+                href={hrefOfGlossaryEntry(entry)}
+                aria-current={active ? "page" : undefined}
+                class={active ? "is-active" : undefined}
+              >
+                {entry.data.term}
+              </a>
+            </li>
+          );
+        })}
+      </ul>
+    </section>
+  )}
+
+  {showSameFamily && (
+    <section class="glossary-aside__block">
+      <h2 class="glossary-aside__heading">{sameFamilyTitle}</h2>
+      <ul class="glossary-aside__list">
+        {sameFamilyEntries.map((entry) => {
+          const active = slugOfGlossaryEntry(entry) === currentSlug;
+          return (
+            <li>
+              <a
+                href={hrefOfGlossaryEntry(entry)}
+                aria-current={active ? "page" : undefined}
+                class={active ? "is-active" : undefined}
+              >
+                {entry.data.term}
+              </a>
+            </li>
+          );
+        })}
+      </ul>
+    </section>
+  )}
+
+  {relationSections.length > 0 && (
+    <section class="glossary-aside__block">
+      <h2 class="glossary-aside__heading">Autour de cette fiche</h2>
+
+      {relationSections.map((section) => (
+        <>
+          <h3 class="glossary-aside__subheading">{section.title}</h3>
+          <ul class="glossary-aside__list">
+            {section.items.map((entry) => (
+              <li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
+            ))}
+          </ul>
+        </>
+      ))}
+    </section>
+  )}
+
+  {contextualTheory.length > 0 && (
+    <section class="glossary-aside__block">
+      <h2 class="glossary-aside__heading">Paysage théorique</h2>
+      <ul class="glossary-aside__list">
+        {contextualTheory.map((entry) => (
+          <li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
+        ))}
+      </ul>
+    </section>
+  )}
+</nav>
+
+<style>
+  .glossary-aside{
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+  }
+
+  .glossary-aside__block{
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 16px;
+    padding: 14px;
+    background: rgba(127,127,127,0.05);
+  }
+
+  .glossary-aside__block--intro{
+    padding-top: 13px;
+    padding-bottom: 13px;
+  }
+
+  .glossary-aside__back{
+    display: inline-block;
+    margin-bottom: 10px;
+    font-size: 14px;
+    font-weight: 700;
+    line-height: 1.35;
+    text-decoration: none;
+  }
+
+  .glossary-aside__title{
+    font-size: 16px;
+    font-weight: 800;
+    letter-spacing: .2px;
+    line-height: 1.3;
+  }
+
+  .glossary-aside__pills{
+    display: flex;
+    flex-wrap: wrap;
+    gap: 7px;
+    margin-top: 10px;
+  }
+
+  .glossary-aside__pill{
+    display: inline-flex;
+    align-items: center;
+    padding: 5px 10px;
+    border: 1px solid rgba(127,127,127,0.24);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.04);
+    font-size: 13px;
+    line-height: 1.35;
+    opacity: .92;
+  }
+
+  .glossary-aside__pill--family{
+    border-color: rgba(127,127,127,0.38);
+    font-weight: 800;
+  }
+
+  .glossary-aside__heading{
+    margin: 0 0 11px;
+    font-size: 14px;
+    font-weight: 800;
+    line-height: 1.35;
+    opacity: .94;
+  }
+
+  .glossary-aside__subheading{
+    margin: 13px 0 8px;
+    font-size: 12.5px;
+    font-weight: 800;
+    line-height: 1.35;
+    opacity: .82;
+    text-transform: uppercase;
+    letter-spacing: .04em;
+  }
+
+  .glossary-aside__list{
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .glossary-aside__list li{
+    margin: 7px 0;
+  }
+
+  .glossary-aside__list a{
+    text-decoration: none;
+    font-size: 14px;
+    line-height: 1.4;
+  }
+
+  .glossary-aside__list a.is-active{
+    font-weight: 800;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-aside__block,
+    .glossary-aside__pill{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryCardGrid.astro

@@ -0,0 +1,83 @@
+---
+import { hrefOfGlossaryEntry, type GlossaryEntry } from "../lib/glossary";
+
+export interface Props {
+  entries?: GlossaryEntry[];
+  wide?: boolean;
+}
+
+const {
+  entries = [],
+  wide = false,
+} = Astro.props;
+---
+
+<div class="glossary-cards">
+  {entries.map((entry) => (
+    <a
+      class:list={[
+        "glossary-card",
+        wide && "glossary-card--wide",
+      ]}
+      href={hrefOfGlossaryEntry(entry)}
+    >
+      <strong>{entry.data.term}</strong>
+      <span>{entry.data.definitionShort}</span>
+    </a>
+  ))}
+</div>
+
+<style>
+  .glossary-cards{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 12px;
+    margin-top: 14px;
+  }
+
+  .glossary-card{
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    padding: 14px 16px;
+    border: 1px solid var(--glossary-border);
+    border-radius: 18px;
+    background: var(--glossary-bg-soft);
+    text-decoration: none;
+    transition: transform 120ms ease, background 120ms ease, border-color 120ms ease;
+  }
+
+  .glossary-card:hover{
+    transform: translateY(-1px);
+    background: var(--glossary-bg-soft-strong);
+    border-color: rgba(0,217,255,0.16);
+    text-decoration: none;
+  }
+
+  .glossary-card--wide{
+    grid-column: 1 / -1;
+  }
+
+  .glossary-card strong{
+    color: var(--glossary-accent);
+    font-size: 1.04rem;
+    line-height: 1.28;
+  }
+
+  .glossary-card span{
+    color: inherit;
+    font-size: 1rem;
+    line-height: 1.5;
+    opacity: .94;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-card{
+      background: rgba(255,255,255,0.04);
+    }
+
+    .glossary-card:hover{
+      background: rgba(255,255,255,0.07);
+    }
+  }
+</style>

src/components/GlossaryEntryBody.astro

@@ -0,0 +1,16 @@
+<div class="glossary-entry-body">
+  <slot />
+</div>
+
+<style>
+  .glossary-entry-body{
+    margin-bottom: 28px;
+  }
+
+  :global(.glossary-entry-body h2),
+  :global(.glossary-entry-body h3),
+  :global(.glossary-relations h2),
+  :global(.glossary-relations h3){
+    scroll-margin-top: calc(var(--sticky-offset-px, 96px) + 18px);
+  }
+</style>

src/components/GlossaryEntryHero.astro

@@ -0,0 +1,230 @@
+---
+interface Props {
+  term: string;
+  definitionShort: string;
+  displayFamily: string;
+  displayDomain?: string;
+  displayLevel?: string;
+  mobilizedAuthors?: string[];
+  comparisonTraditions?: string[];
+}
+
+const {
+  term,
+  definitionShort,
+  displayFamily,
+  displayDomain = "",
+  displayLevel = "",
+  mobilizedAuthors = [],
+  comparisonTraditions = [],
+} = Astro.props;
+
+const hasScholarlyMeta =
+  mobilizedAuthors.length > 0 ||
+  comparisonTraditions.length > 0;
+---
+
+<header class="glossary-entry-head" data-ge-hero>
+  <div class="glossary-entry-head__title">
+    <h1>{term}</h1>
+  </div>
+
+  <div class="glossary-entry-summary">
+    <p class="glossary-entry-dek">
+      <em>{definitionShort}</em>
+    </p>
+
+    <div class="glossary-entry-signals" aria-label="Repères de lecture">
+      <span class="glossary-pill glossary-pill--family">
+        <strong>Famille :</strong> {displayFamily}
+      </span>
+
+      {displayDomain && (
+        <span class="glossary-pill">
+          <strong>Domaine :</strong> {displayDomain}
+        </span>
+      )}
+
+      {displayLevel && (
+        <span class="glossary-pill">
+          <strong>Niveau :</strong> {displayLevel}
+        </span>
+      )}
+    </div>
+
+    {hasScholarlyMeta && (
+      <div class="glossary-entry-meta">
+        {mobilizedAuthors.length > 0 && (
+          <p>
+            <strong>Auteurs mobilisés :</strong> {mobilizedAuthors.join(" / ")}
+          </p>
+        )}
+
+        {comparisonTraditions.length > 0 && (
+          <p>
+            <strong>Traditions de comparaison :</strong> {comparisonTraditions.join(" / ")}
+          </p>
+        )}
+      </div>
+    )}
+  </div>
+</header>
+
+<style>
+  .glossary-entry-head{
+    position: sticky;
+    top: calc(var(--sticky-header-h, 0px) + var(--page-gap, 12px));
+    z-index: 11;
+    margin: 0 0 24px;
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 28px;
+    background:
+      linear-gradient(180deg, rgba(0,0,0,0.60), rgba(0,0,0,0.92)),
+      radial-gradient(900px 240px at 20% 0%, rgba(0,217,255,0.08), transparent 60%);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    overflow: hidden;
+    transition:
+      border-radius 180ms ease,
+      box-shadow 180ms ease,
+      border-color 180ms ease;
+  }
+
+  .glossary-entry-head__title{
+    padding:
+      var(--entry-hero-pad-top, 18px)
+      var(--entry-hero-pad-x, 18px)
+      calc(var(--entry-hero-pad-top, 18px) - 2px);
+    transition: padding 180ms ease;
+  }
+  
+  .glossary-entry-head h1{
+    margin: 0;
+    font-size: var(--entry-hero-h1-size, clamp(2.2rem, 4vw, 3.15rem));
+    line-height: 1.02;
+    letter-spacing: -.04em;
+    font-weight: 850;
+    transition: font-size 180ms ease;
+  }
+
+  .glossary-entry-summary{
+    display: grid;
+    gap: var(--entry-hero-gap, 14px);
+    padding:
+      calc(var(--entry-hero-pad-bottom, 18px) - 2px)
+      var(--entry-hero-pad-x, 18px)
+      var(--entry-hero-pad-bottom, 18px);
+    border-top: 1px solid rgba(127,127,127,0.14);
+    background: rgba(255,255,255,0.02);
+    transition: gap 180ms ease, padding 180ms ease;
+  }
+
+  .glossary-entry-dek{
+    margin: 0;
+    max-width: var(--entry-hero-dek-maxw, 76ch);
+    font-size: var(--entry-hero-dek-size, 1.04rem);
+    line-height: var(--entry-hero-dek-lh, 1.55);
+    opacity: .94;
+    transition:
+      max-width 180ms ease,
+      font-size 180ms ease,
+      line-height 180ms ease;
+  }
+
+  .glossary-entry-signals{
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin: 0;
+    transition: gap 180ms ease;
+  }
+
+  .glossary-pill{
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 5px 10px;
+    border: 1px solid rgba(127,127,127,0.24);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.05);
+    font-size: 13px;
+    line-height: 1.35;
+    transition:
+      padding 180ms ease,
+      font-size 180ms ease,
+      background 120ms ease,
+      border-color 120ms ease;
+  }
+
+  .glossary-pill--family{
+    border-color: rgba(127,127,127,0.36);
+    font-weight: 700;
+  }
+
+  .glossary-entry-meta{
+    margin: 0;
+    padding: 10px 12px;
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 12px;
+    background: rgba(127,127,127,0.04);
+    max-height: var(--entry-hero-meta-max-h, 12rem);
+    opacity: var(--entry-hero-meta-opacity, 1);
+    overflow: hidden;
+    transition:
+      max-height 180ms ease,
+      opacity 140ms ease,
+      padding 180ms ease,
+      border-color 180ms ease;
+  }
+
+  .glossary-entry-meta p{
+    margin: 0;
+    font-size: 14px;
+    line-height: 1.5;
+  }
+
+  .glossary-entry-meta p + p{
+    margin-top: 6px;
+  }
+
+  @media (max-width: 720px){
+    .glossary-entry-signals{
+      gap: 6px;
+    }
+
+    .glossary-pill{
+      font-size: 12px;
+    }
+  }
+
+  @media (max-width: 860px){
+    .glossary-entry-head{
+      position: static;
+      border-radius: 22px;
+      margin-bottom: 20px;
+    }
+
+    .glossary-entry-head__title{
+      padding: 14px 14px 12px;
+    }
+
+    .glossary-entry-summary{
+      gap: 12px;
+      padding: 14px;
+    }
+
+    .glossary-entry-dek{
+      max-width: none;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-entry-meta{
+      background: rgba(255,255,255,0.03);
+    }
+
+    .glossary-pill{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryEntryLegacyNote.astro

@@ -0,0 +1,31 @@
+---
+interface Props {
+  canonicalHref: string;
+  term: string;
+}
+
+const { canonicalHref, term } = Astro.props;
+---
+
+<p class="glossary-legacy-note">
+  Cette entrée a été renommée. L’intitulé canonique est :
+  <a href={canonicalHref}>{term}</a>.
+</p>
+
+<style>
+  .glossary-legacy-note{
+    padding: 10px 12px;
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 12px;
+    background: rgba(127,127,127,0.05);
+    font-size: 14px;
+    line-height: 1.45;
+    margin-bottom: 18px;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-legacy-note{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryEntryStickySync.astro

@@ -0,0 +1,185 @@
+<script is:inline>
+  (() => {
+    const boot = () => {
+      const body = document.body;
+      const root = document.documentElement;
+      const hero = document.querySelector("[data-ge-hero]");
+      const follow = document.getElementById("reading-follow");
+      const mqMobile = window.matchMedia("(max-width: 860px)");
+
+      if (!body || !root || !hero || !follow) return;
+
+      const BODY_CLASS = "is-glossary-entry-page";
+      const FOLLOW_ON_CLASS = "glossary-entry-follow-on";
+
+      let lastHeight = -1;
+      let lastFollowOn = null;
+      let raf = 0;
+
+      body.classList.add(BODY_CLASS);
+
+      const heroHeight = () =>
+        Math.max(0, Math.round(hero.getBoundingClientRect().height || 0));
+
+      const computeFollowOn = () =>
+        !mqMobile.matches &&
+        follow.classList.contains("is-on") &&
+        follow.style.display !== "none" &&
+        follow.getAttribute("aria-hidden") !== "true";
+
+      const stripLocalSticky = () => {
+        document
+          .querySelectorAll(
+            ".glossary-entry-body h2, .glossary-entry-body h3, .glossary-relations h2, .glossary-relations h3"
+          )
+          .forEach((el) => {
+            el.classList.remove("is-sticky");
+            el.removeAttribute("data-sticky-active");
+          });
+      };
+
+      const applyLocalStickyHeight = () => {
+        const h = mqMobile.matches ? 0 : heroHeight();
+        if (h === lastHeight) return;
+        lastHeight = h;
+
+        if (typeof window.__archiSetLocalStickyHeight === "function") {
+          window.__archiSetLocalStickyHeight(h);
+        } else {
+          root.style.setProperty("--glossary-local-sticky-h", `${h}px`);
+        }
+      };
+
+      const syncFollowState = () => {
+        const on = computeFollowOn();
+        if (on === lastFollowOn) return;
+        lastFollowOn = on;
+        body.classList.toggle(FOLLOW_ON_CLASS, on);
+      };
+
+      const syncAll = () => {
+        stripLocalSticky();
+        syncFollowState();
+        applyLocalStickyHeight();
+      };
+
+      const schedule = () => {
+        if (raf) return;
+        raf = requestAnimationFrame(() => {
+          raf = 0;
+          syncAll();
+        });
+      };
+
+      const followObserver = new MutationObserver(schedule);
+      followObserver.observe(follow, {
+        attributes: true,
+        attributeFilter: ["class", "style", "aria-hidden"],
+        subtree: false,
+      });
+
+      const heroResizeObserver =
+        typeof ResizeObserver !== "undefined"
+          ? new ResizeObserver(schedule)
+          : null;
+
+      heroResizeObserver?.observe(hero);
+
+      window.addEventListener("resize", schedule);
+      window.addEventListener("pageshow", schedule);
+
+      if (document.fonts?.ready) {
+        document.fonts.ready.then(schedule).catch(() => {});
+      }
+
+      if (mqMobile.addEventListener) {
+        mqMobile.addEventListener("change", schedule);
+      } else if (mqMobile.addListener) {
+        mqMobile.addListener(schedule);
+      }
+
+      schedule();
+    };
+
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", boot, { once: true });
+    } else {
+      boot();
+    }
+  })();
+</script>
+
+<style>
+  :global(body.is-glossary-entry-page #reading-follow){
+    z-index: 10;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-signals){
+    gap: 6px;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-head){
+    margin-bottom: 0;
+    border-bottom-left-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-summary){
+    gap: 10px;
+    padding-top: 12px;
+    padding-bottom: 10px;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-dek){
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 2;
+    overflow: hidden;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-pill){
+    padding: 4px 8px;
+    font-size: 12px;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-meta){
+    padding: 0;
+    border-color: transparent;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on #reading-follow){
+    transform: translateY(-1px);
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on #reading-follow .reading-follow__inner){
+    margin-top: -1px;
+    border-top-left-radius: 0;
+    border-top-right-radius: 0;
+  }
+
+  :global(body.is-glossary-entry-page .glossary-entry-body h2.is-sticky),
+  :global(body.is-glossary-entry-page .glossary-entry-body h2[data-sticky-active="true"]),
+  :global(body.is-glossary-entry-page .glossary-entry-body h3.is-sticky),
+  :global(body.is-glossary-entry-page .glossary-entry-body h3[data-sticky-active="true"]),
+  :global(body.is-glossary-entry-page .glossary-relations h2.is-sticky),
+  :global(body.is-glossary-entry-page .glossary-relations h2[data-sticky-active="true"]),
+  :global(body.is-glossary-entry-page .glossary-relations h3.is-sticky),
+  :global(body.is-glossary-entry-page .glossary-relations h3[data-sticky-active="true"]){
+    position: static !important;
+    top: auto !important;
+    z-index: auto !important;
+    padding: 0 !important;
+    border: 0 !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    backdrop-filter: none !important;
+    -webkit-backdrop-filter: none !important;
+  }
+
+  @media (max-width: 860px){
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-head){
+      margin-bottom: 20px;
+      border-radius: 22px;
+    }
+  }
+</style>

src/components/GlossaryHomeAside.astro

@@ -0,0 +1,143 @@
+---
+import {
+  getFondamentaux,
+  getGlossaryHomeStats,
+  getGlossaryPortalLinks,
+  hrefOfGlossaryEntry,
+} from "../lib/glossary";
+
+const {
+  allEntries = [],
+} = Astro.props;
+
+const fondamentaux = getFondamentaux(allEntries);
+const portalLinks = getGlossaryPortalLinks();
+
+const {
+  totalEntries,
+  paradigmesCount,
+  doctrinesCount,
+  metaRegimesCount,
+} = getGlossaryHomeStats(allEntries);
+---
+
+<nav class="glossary-home-aside" aria-label="Navigation du portail du glossaire">
+  <div class="glossary-home-aside__block glossary-home-aside__block--intro">
+    <div class="glossary-home-aside__title">Glossaire archicratique</div>
+    <div class="glossary-home-aside__meta">
+      portail de lecture · cartographie conceptuelle
+    </div>
+
+    <div class="glossary-home-aside__pills" aria-label="Repères de navigation">
+      <span class="glossary-home-aside__pill">{totalEntries} entrées</span>
+      <span class="glossary-home-aside__pill">{metaRegimesCount} méta-régimes</span>
+      <span class="glossary-home-aside__pill">
+        {doctrinesCount} doctrine{doctrinesCount > 1 ? "s" : ""} · {paradigmesCount} paradigme{paradigmesCount > 1 ? "s" : ""}
+      </span>
+    </div>
+  </div>
+
+  <section class="glossary-home-aside__block">
+    <h2 class="glossary-home-aside__heading">Parcours du glossaire</h2>
+    <ul class="glossary-home-aside__list">
+      {portalLinks.map((item) => (
+        <li><a href={item.href}>{item.label}</a></li>
+      ))}
+    </ul>
+  </section>
+
+  {fondamentaux.length > 0 && (
+    <section class="glossary-home-aside__block">
+      <h2 class="glossary-home-aside__heading">Noyau archicratique</h2>
+      <ul class="glossary-home-aside__list">
+        {fondamentaux.map((entry) => (
+          <li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
+        ))}
+      </ul>
+    </section>
+  )}
+</nav>
+
+<style>
+  .glossary-home-aside{
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+  }
+
+  .glossary-home-aside__block{
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 16px;
+    padding: 14px;
+    background: rgba(127,127,127,0.05);
+  }
+
+  .glossary-home-aside__block--intro{
+    padding-top: 13px;
+    padding-bottom: 13px;
+  }
+
+  .glossary-home-aside__title{
+    font-size: 16px;
+    font-weight: 800;
+    letter-spacing: .2px;
+    line-height: 1.3;
+  }
+
+  .glossary-home-aside__meta{
+    margin-top: 8px;
+    font-size: 13px;
+    line-height: 1.4;
+    opacity: .8;
+  }
+
+  .glossary-home-aside__pills{
+    display: flex;
+    flex-wrap: wrap;
+    gap: 7px;
+    margin-top: 11px;
+  }
+
+  .glossary-home-aside__pill{
+    display: inline-flex;
+    align-items: center;
+    padding: 5px 10px;
+    border: 1px solid rgba(127,127,127,0.24);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.04);
+    font-size: 13px;
+    line-height: 1.35;
+    opacity: .92;
+  }
+
+  .glossary-home-aside__heading{
+    margin: 0 0 11px;
+    font-size: 14px;
+    font-weight: 800;
+    line-height: 1.35;
+    opacity: .94;
+  }
+
+  .glossary-home-aside__list{
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .glossary-home-aside__list li{
+    margin: 7px 0;
+  }
+
+  .glossary-home-aside__list a{
+    text-decoration: none;
+    font-size: 14px;
+    line-height: 1.4;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-home-aside__block,
+    .glossary-home-aside__pill{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryHomeHero.astro

@@ -0,0 +1,103 @@
+---
+export interface Props {
+  kicker?: string;
+  title?: string;
+  intro?: string;
+}
+
+const {
+  kicker = "Référentiel terminologique",
+  title = "Glossaire archicratique",
+  intro = "Ce glossaire n’est pas seulement un index de définitions. Il constitue une porte d’entrée dans la pensée archicratique : une cartographie raisonnée des concepts fondamentaux, des scènes, des dynamiques et des méta-régimes à partir desquels une société peut être décrite comme organisation de tensions et recherche de co-viabilité.",
+} = Astro.props;
+---
+
+<header class="glossary-hero" id="glossary-hero">
+  <p class="glossary-kicker">{kicker}</p>
+  <h1>{title}</h1>
+  <p class="glossary-intro">{intro}</p>
+  <h2
+    class="glossary-hero-follow"
+    id="glossary-hero-follow"
+    aria-hidden="true"
+  ></h2>
+</header>
+
+<style>
+  .glossary-hero{
+    position: sticky;
+    top: var(--glossary-sticky-top);
+    z-index: 12;
+    margin-bottom: 28px;
+    padding: 14px 16px 18px;
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 28px;
+    background:
+      linear-gradient(180deg, rgba(0,0,0,0.60), rgba(0,0,0,0.90)),
+      radial-gradient(900px 240px at 20% 0%, rgba(0,217,255,0.08), transparent 60%);
+    transition:
+      background 300ms cubic-bezier(.22,.8,.22,1),
+      border-color 300ms cubic-bezier(.22,.8,.22,1),
+      box-shadow 300ms cubic-bezier(.22,.8,.22,1);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    display: grid;
+    row-gap: 12px;
+  }
+
+  .glossary-kicker{
+    margin: 0;
+    font-size: 12px;
+    letter-spacing: .12em;
+    text-transform: uppercase;
+    opacity: .72;
+  }
+
+  .glossary-hero h1{
+    margin: 0;
+    font-size: clamp(2.2rem, 4vw, 3.15rem);
+    line-height: 1.02;
+    letter-spacing: -.04em;
+    font-weight: 850;
+  }
+
+  .glossary-intro{
+    margin: 0;
+    max-width: 72ch;
+    font-size: 1.05rem;
+    line-height: 1.55;
+    opacity: .94;
+  }
+
+  .glossary-hero-follow{
+    margin: 2px 0 0;
+    min-height: var(--glossary-follow-height);
+    display: flex;
+    align-items: flex-end;
+    opacity: 0;
+    transform: translateY(10px) scale(.985);
+    filter: blur(6px);
+    transition:
+      opacity 220ms cubic-bezier(.22,1,.36,1),
+      transform 320ms cubic-bezier(.22,1,.36,1),
+      filter 320ms cubic-bezier(.22,1,.36,1);
+    pointer-events: none;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    will-change: opacity, transform, filter;
+  }
+
+  .glossary-hero-follow.is-visible{
+    opacity: 1;
+    transform: translateY(0) scale(1);
+    filter: blur(0);
+  }
+
+  @media (max-width: 760px){
+    .glossary-hero{
+      top: calc(var(--glossary-sticky-top) - 2px);
+      padding: 12px 14px 16px;
+    }
+  }
+</style>

src/components/GlossaryHomeSection.astro

@@ -0,0 +1,109 @@
+---
+export interface Props {
+  id?: string;
+  title: string;
+  intro?: string;
+  followSection?: string;
+  ctaHref?: string;
+  ctaLabel?: string;
+}
+
+const {
+  id,
+  title,
+  intro,
+  followSection,
+  ctaHref,
+  ctaLabel,
+} = Astro.props;
+
+const resolvedFollowSection = (followSection || title || "").trim();
+const showCta = Boolean(ctaHref && ctaLabel);
+---
+
+<section id={id} class="glossary-section">
+  <div class="glossary-section__head">
+    <div>
+      <h2 data-follow-section={resolvedFollowSection}>{title}</h2>
+
+      {intro && (
+        <p class="glossary-intro">{intro}</p>
+      )}
+    </div>
+
+    {showCta && (
+      <a class="glossary-cta" href={ctaHref}>
+        {ctaLabel}
+      </a>
+    )}
+  </div>
+
+  <slot />
+</section>
+
+<style>
+  .glossary-section{
+    margin-top: 42px;
+    scroll-margin-top: calc(var(--glossary-sticky-top) + 190px);
+  }
+
+  .glossary-section__head{
+    display: flex;
+    justify-content: space-between;
+    align-items: start;
+    gap: 16px;
+    flex-wrap: wrap;
+    margin-bottom: 14px;
+  }
+
+  .glossary-section h2{
+    margin: 0;
+    font-size: clamp(2rem, 3vw, 2.55rem);
+    line-height: 1.06;
+    letter-spacing: -.03em;
+    font-weight: 800;
+  }
+
+  .glossary-intro{
+    margin: 0;
+    max-width: 72ch;
+    font-size: 1.05rem;
+    line-height: 1.55;
+    opacity: .94;
+  }
+
+  .glossary-section__head .glossary-intro{
+    margin-top: 10px;
+  }
+
+  .glossary-cta{
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 40px;
+    border: 1px solid var(--glossary-border-strong);
+    border-radius: 999px;
+    padding: 7px 14px;
+    color: var(--glossary-accent);
+    text-decoration: none;
+    white-space: nowrap;
+    transition: transform 120ms ease, background 120ms ease;
+  }
+
+  .glossary-cta:hover{
+    background: var(--glossary-bg-soft-strong);
+    text-decoration: none;
+    transform: translateY(-1px);
+  }
+
+  @media (max-width: 760px){
+    .glossary-section__head{
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .glossary-cta{
+      width: fit-content;
+    }
+  }
+</style>

src/components/GlossaryPortalAside.astro

@@ -0,0 +1,122 @@
+---
+interface LinkItem {
+  href: string;
+  label: string;
+}
+
+interface Props {
+  ariaLabel: string;
+  title: string;
+  meta?: string;
+  backHref?: string;
+  backLabel?: string;
+  pageItems?: LinkItem[];
+  usefulLinks?: LinkItem[];
+}
+
+const {
+  ariaLabel,
+  title,
+  meta,
+  backHref = "/glossaire/",
+  backLabel = "← Retour au glossaire",
+  pageItems = [],
+  usefulLinks = [],
+} = Astro.props;
+---
+
+<nav class="glossary-portal-aside" aria-label={ariaLabel}>
+  <div class="glossary-portal-aside__block">
+    <a class="glossary-portal-aside__back" href={backHref}>{backLabel}</a>
+    <div class="glossary-portal-aside__title">{title}</div>
+    {meta && <div class="glossary-portal-aside__meta">{meta}</div>}
+  </div>
+
+  {pageItems.length > 0 && (
+    <div class="glossary-portal-aside__block">
+      <h2 class="glossary-portal-aside__heading">Dans cette page</h2>
+      <ul class="glossary-portal-aside__list">
+        {pageItems.map((item) => (
+          <li><a href={item.href}>{item.label}</a></li>
+        ))}
+      </ul>
+    </div>
+  )}
+
+  {usefulLinks.length > 0 && (
+    <div class="glossary-portal-aside__block">
+      <h2 class="glossary-portal-aside__heading">Renvois utiles</h2>
+      <ul class="glossary-portal-aside__list">
+        {usefulLinks.map((item) => (
+          <li><a href={item.href}>{item.label}</a></li>
+        ))}
+      </ul>
+    </div>
+  )}
+</nav>
+
+<style>
+  .glossary-portal-aside{
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+  }
+
+  .glossary-portal-aside__block{
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 16px;
+    padding: 12px;
+    background: rgba(127,127,127,0.05);
+  }
+
+  .glossary-portal-aside__back{
+    display: inline-block;
+    margin-bottom: 8px;
+    font-size: 13px;
+    font-weight: 700;
+    text-decoration: none;
+  }
+
+  .glossary-portal-aside__title{
+    font-size: 14px;
+    font-weight: 800;
+    letter-spacing: .2px;
+    line-height: 1.25;
+  }
+
+  .glossary-portal-aside__meta{
+    margin-top: 8px;
+    font-size: 12px;
+    line-height: 1.35;
+    opacity: .78;
+  }
+
+  .glossary-portal-aside__heading{
+    margin: 0 0 10px;
+    font-size: 13px;
+    font-weight: 800;
+    opacity: .9;
+  }
+
+  .glossary-portal-aside__list{
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .glossary-portal-aside__list li{
+    margin: 6px 0;
+  }
+
+  .glossary-portal-aside__list a{
+    text-decoration: none;
+    font-size: 13px;
+    line-height: 1.3;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-aside__block{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryPortalCta.astro

@@ -0,0 +1,87 @@
+---
+export interface Props {
+  href: string;
+  label: string;
+  icon?: string;
+  className?: string;
+}
+
+const {
+  href,
+  label,
+  icon = "↗",
+  className,
+} = Astro.props;
+---
+
+<a class:list={["glossary-portal-cta", className]} href={href}>
+  <span>{label}</span>
+  <span aria-hidden="true">{icon}</span>
+</a>
+
+<style>
+  .glossary-portal-cta{
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    min-height: 40px;
+    padding: 0 14px;
+    border: 1px solid rgba(0,217,255,0.24);
+    border-radius: 999px;
+    background:
+      linear-gradient(180deg, rgba(0,217,255,0.10), rgba(0,217,255,0.04)),
+      rgba(127,127,127,0.06);
+    box-shadow:
+      inset 0 1px 0 rgba(255,255,255,0.05),
+      0 0 0 1px rgba(0,217,255,0.04);
+    text-decoration: none;
+    font-size: 12px;
+    font-weight: 800;
+    letter-spacing: .01em;
+    white-space: nowrap;
+    transition:
+      transform 120ms ease,
+      background 120ms ease,
+      border-color 120ms ease,
+      box-shadow 120ms ease;
+  }
+
+  .glossary-portal-cta:hover{
+    transform: translateY(-1px);
+    border-color: rgba(0,217,255,0.34);
+    background:
+      linear-gradient(180deg, rgba(0,217,255,0.14), rgba(0,217,255,0.06)),
+      rgba(127,127,127,0.08);
+    box-shadow:
+      inset 0 1px 0 rgba(255,255,255,0.06),
+      0 0 0 1px rgba(0,217,255,0.08),
+      0 10px 28px rgba(0,0,0,0.18);
+    text-decoration: none;
+  }
+
+  .glossary-portal-cta:focus-visible{
+    outline: 2px solid rgba(0,217,255,0.28);
+    outline-offset: 4px;
+  }
+
+  @media (max-width: 720px){
+    .glossary-portal-cta{
+      width: 100%;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-cta{
+      background:
+        linear-gradient(180deg, rgba(0,217,255,0.12), rgba(0,217,255,0.05)),
+        rgba(255,255,255,0.04);
+    }
+
+    .glossary-portal-cta:hover{
+      background:
+        linear-gradient(180deg, rgba(0,217,255,0.16), rgba(0,217,255,0.07)),
+        rgba(255,255,255,0.06);
+    }
+  }
+</style>

src/components/GlossaryPortalGrid.astro

@@ -0,0 +1,91 @@
+---
+export type GlossaryPortalGridItem = {
+  href: string;
+  title: string;
+  description: string;
+  meta: string;
+};
+
+export interface Props {
+  items?: GlossaryPortalGridItem[];
+  secondary?: boolean;
+}
+
+const {
+  items = [],
+  secondary = false,
+} = Astro.props;
+---
+
+<div
+  class:list={[
+    "glossary-portals",
+    secondary && "glossary-portals--secondary",
+  ]}
+>
+  {items.map((item) => (
+    <a class="glossary-portal-card" href={item.href}>
+      <strong>{item.title}</strong>
+      <span>{item.description}</span>
+      <small>{item.meta}</small>
+    </a>
+  ))}
+</div>
+
+<style>
+  .glossary-portals{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+    gap: 14px;
+    margin-top: 14px;
+  }
+
+  .glossary-portal-card{
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    padding: 16px 18px;
+    border: 1px solid var(--glossary-border);
+    border-radius: 18px;
+    background: var(--glossary-bg-soft);
+    text-decoration: none;
+    transition: transform 120ms ease, background 120ms ease, border-color 120ms ease;
+  }
+
+  .glossary-portal-card:hover{
+    transform: translateY(-1px);
+    background: var(--glossary-bg-soft-strong);
+    border-color: rgba(0,217,255,0.16);
+    text-decoration: none;
+  }
+
+  .glossary-portal-card strong{
+    color: var(--glossary-accent);
+    font-size: 1.08rem;
+    line-height: 1.28;
+  }
+
+  .glossary-portal-card span{
+    color: inherit;
+    font-size: 1rem;
+    line-height: 1.5;
+    opacity: .94;
+  }
+
+  .glossary-portal-card small{
+    color: var(--glossary-accent);
+    font-size: .94rem;
+    line-height: 1.35;
+    opacity: .9;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-card{
+      background: rgba(255,255,255,0.04);
+    }
+
+    .glossary-portal-card:hover{
+      background: rgba(255,255,255,0.07);
+    }
+  }
+</style>

src/components/GlossaryPortalHero.astro

@@ -0,0 +1,190 @@
+---
+interface Props {
+  prefix: string;
+  kicker: string;
+  title: string;
+  intro: string;
+  moreParagraphs?: string[];
+  introMaxWidth?: string;
+  followIntroMaxWidth?: string;
+  moreMaxHeight?: string;
+}
+
+const {
+  prefix,
+  kicker,
+  title,
+  intro,
+  moreParagraphs = [],
+  introMaxWidth = "72ch",
+  followIntroMaxWidth = "68ch",
+  moreMaxHeight = "18rem",
+} = Astro.props;
+---
+
+<div
+  class="glossary-portal-hero glossary-page-hero"
+  data-glossary-portal-hero
+  style={`--portal-hero-intro-max-w:${introMaxWidth}; --portal-hero-follow-intro-max-w:${followIntroMaxWidth}; --portal-hero-more-max-h:${moreMaxHeight};`}
+>
+  <p class="glossary-portal-hero__kicker">{kicker}</p>
+  <h1>{title}</h1>
+
+  <p class="glossary-portal-hero__intro">
+    {intro}
+  </p>
+
+  {moreParagraphs.length > 0 && (
+    <div class="glossary-portal-hero__collapsible">
+      <div
+        class="glossary-portal-hero__more"
+        id={`${prefix}-hero-more`}
+        data-glossary-portal-more
+        aria-hidden="false"
+      >
+        {moreParagraphs.map((paragraph) => (
+          <p class="glossary-portal-hero__intro">{paragraph}</p>
+        ))}
+      </div>
+
+      <button
+        class="glossary-portal-hero__toggle"
+        id={`${prefix}-hero-toggle`}
+        data-glossary-portal-toggle
+        type="button"
+        aria-controls={`${prefix}-hero-more`}
+        aria-expanded="false"
+        hidden
+      >
+        lire la suite
+      </button>
+    </div>
+  )}
+</div>
+
+<style>
+  .glossary-portal-hero{
+    position: sticky;
+    top: calc(var(--sticky-header-h, 0px) + var(--page-gap, 12px));
+    z-index: 11;
+    margin: 0 0 24px;
+    padding: 18px 18px 20px;
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 28px;
+    background:
+      linear-gradient(180deg, rgba(0,0,0,0.60), rgba(0,0,0,0.92)),
+      radial-gradient(900px 240px at 20% 0%, rgba(0,217,255,0.08), transparent 60%);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    display: grid;
+    row-gap: 14px;
+    transition:
+      margin-bottom 180ms ease,
+      border-radius 180ms ease,
+      padding 180ms ease,
+      row-gap 180ms ease;
+  }
+
+  .glossary-portal-hero__kicker{
+    margin: 0;
+    font-size: 12px;
+    letter-spacing: .08em;
+    text-transform: uppercase;
+    opacity: .72;
+  }
+
+  .glossary-portal-hero h1{
+    margin: 0;
+    font-size: clamp(2.2rem, 4vw, 3.15rem);
+    line-height: 1.02;
+    letter-spacing: -.04em;
+    font-weight: 850;
+    transition: font-size 180ms ease;
+  }
+
+  .glossary-portal-hero__intro{
+    margin: 0;
+    max-width: var(--portal-hero-intro-max-w);
+    font-size: 1.04rem;
+    line-height: 1.55;
+    opacity: .94;
+    transition:
+      font-size 180ms ease,
+      line-height 180ms ease,
+      max-width 180ms ease;
+  }
+
+  .glossary-portal-hero__collapsible{
+    display: grid;
+    row-gap: 6px;
+  }
+
+  .glossary-portal-hero__more{
+    display: grid;
+    row-gap: 14px;
+    max-height: var(--portal-hero-more-max-h);
+    overflow: hidden;
+    opacity: 1;
+    transition:
+      max-height 220ms ease,
+      opacity 180ms ease;
+  }
+
+  .glossary-portal-hero__toggle{
+    display: none;
+    align-self: flex-start;
+    width: fit-content;
+    margin: 0;
+    padding: 0;
+    border: 0;
+    background: transparent;
+    color: inherit;
+    font: inherit;
+    font-size: 11px;
+    line-height: 1.2;
+    letter-spacing: .01em;
+    opacity: .56;
+    cursor: pointer;
+    text-decoration: underline;
+    text-underline-offset: .12em;
+    text-decoration-thickness: 1px;
+  }
+
+  .glossary-portal-hero__toggle:hover{
+    opacity: .84;
+  }
+
+  .glossary-portal-hero__toggle:focus-visible{
+    outline: 2px solid rgba(0,217,255,0.24);
+    outline-offset: 4px;
+    border-radius: 4px;
+  }
+
+  .glossary-portal-hero__toggle[hidden]{
+    display: none !important;
+  }
+
+  @media (max-width: 860px){
+    .glossary-portal-hero{
+      position: static;
+      border-radius: 22px;
+      margin-bottom: 20px;
+      padding: 14px 14px 16px;
+      row-gap: 12px;
+    }
+
+    .glossary-portal-hero__intro{
+      max-width: none;
+    }
+
+    .glossary-portal-hero__more{
+      max-height: none;
+      opacity: 1;
+      overflow: visible;
+    }
+
+    .glossary-portal-hero__toggle{
+      display: none !important;
+    }
+  }
+</style>

src/components/GlossaryPortalPanel.astro

@@ -0,0 +1,96 @@
+---
+export interface Props {
+  id?: string;
+  title: string;
+  count?: string;
+  intro?: string;
+  surface?: boolean;
+  className?: string;
+}
+
+const {
+  id,
+  title,
+  count,
+  intro,
+  surface = false,
+  className,
+} = Astro.props;
+---
+
+<div
+  class:list={[
+    "glossary-portal-panel",
+    surface && "glossary-portal-panel--surface",
+    className,
+  ]}
+>
+  <div class="glossary-portal-panel__head">
+    <h3 id={id}>{title}</h3>
+    {count && <span class="glossary-portal-panel__count">{count}</span>}
+  </div>
+
+  {intro && <p class="glossary-portal-panel__intro">{intro}</p>}
+
+  <slot />
+</div>
+
+<style>
+  .glossary-portal-panel{
+    display: grid;
+    gap: 12px;
+  }
+
+  .glossary-portal-panel--surface{
+    padding: 18px 18px 16px;
+    border: 1px solid var(--glossary-border, rgba(127,127,127,0.18));
+    border-radius: 18px;
+    background:
+      linear-gradient(180deg, rgba(255,255,255,0.02), rgba(255,255,255,0.01)),
+      var(--glossary-bg-soft, rgba(127,127,127,0.035));
+  }
+
+  .glossary-portal-panel__head{
+    display: flex;
+    align-items: baseline;
+    justify-content: space-between;
+    gap: 12px;
+    flex-wrap: wrap;
+  }
+
+  .glossary-portal-panel__head h3{
+    margin: 0;
+    font-size: 15px;
+    line-height: 1.3;
+    scroll-margin-top: calc(var(--sticky-offset-px, 96px) + 36px);
+  }
+
+  .glossary-portal-panel__count{
+    display: inline-flex;
+    align-items: center;
+    min-height: 24px;
+    padding: 0 10px;
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 999px;
+    font-size: 12px;
+    line-height: 1.2;
+    opacity: .78;
+    white-space: nowrap;
+  }
+
+  .glossary-portal-panel__intro{
+    max-width: 78ch;
+    margin: 0;
+    font-size: 14px;
+    line-height: 1.5;
+    opacity: .9;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-panel--surface{
+      background:
+        linear-gradient(180deg, rgba(255,255,255,0.02), rgba(255,255,255,0.01)),
+        rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryPortalSection.astro

@@ -0,0 +1,67 @@
+---
+interface Props {
+  id: string;
+  title: string;
+  count?: string;
+  intro?: string;
+  final?: boolean;
+  className?: string;
+}
+
+const {
+  id,
+  title,
+  count,
+  intro,
+  final = false,
+  className,
+} = Astro.props;
+---
+
+<section class:list={["glossary-portal-section", final && "glossary-portal-section--final", className]}>
+  <div class="glossary-portal-section__head">
+    <h2 id={id}>{title}</h2>
+    {count && <span class="glossary-portal-section__count">{count}</span>}
+  </div>
+
+  {intro && <p class="glossary-portal-section__intro">{intro}</p>}
+
+  <slot />
+</section>
+
+<style>
+  .glossary-portal-section{
+    margin-top: 34px;
+    scroll-margin-top: calc(var(--sticky-offset-px, 96px) + 28px);
+  }
+
+  .glossary-portal-section h2{
+    scroll-margin-top: calc(var(--sticky-offset-px, 96px) + 28px);
+  }
+
+  .glossary-portal-section__head{
+    display: flex;
+    align-items: baseline;
+    justify-content: space-between;
+    gap: 12px;
+    flex-wrap: wrap;
+    margin-bottom: 10px;
+    position: static;
+  }
+
+  .glossary-portal-section__count{
+    font-size: 13px;
+    opacity: .72;
+    white-space: nowrap;
+  }
+
+  .glossary-portal-section__intro{
+    max-width: 78ch;
+    margin: 0;
+    opacity: .92;
+  }
+
+  .glossary-portal-section--final{
+    margin-top: 42px;
+  }
+</style>

src/components/GlossaryPortalStickySync.astro

@@ -0,0 +1,294 @@
+---
+interface Props {
+  heroMoreId: string;
+  heroToggleId: string;
+  sectionHeadSelector?: string;
+  mobileBreakpoint?: number;
+  autoCollapseDelta?: number;
+}
+
+const {
+  heroMoreId,
+  heroToggleId,
+  sectionHeadSelector = ".glossary-portal-section__head",
+  mobileBreakpoint = 860,
+  autoCollapseDelta = 160,
+} = Astro.props;
+---
+
+<script
+  is:inline
+  define:vars={{ heroMoreId, heroToggleId, sectionHeadSelector, mobileBreakpoint, autoCollapseDelta }}
+>
+  (() => {
+    const boot = () => {
+      const body = document.body;
+      const root = document.documentElement;
+      const hero = document.querySelector("[data-glossary-portal-hero]");
+      const follow = document.getElementById("reading-follow");
+      const heroMore = document.getElementById(heroMoreId);
+      const heroToggle = document.getElementById(heroToggleId);
+
+      if (!body || !root || !hero || !follow) return;
+
+      const BODY_CLASS = "is-glossary-portal-page";
+      const FOLLOW_ON_CLASS = "glossary-portal-follow-on";
+      const EXPANDED_CLASS = "glossary-portal-hero-expanded";
+      const mqMobile = window.matchMedia(`(max-width: ${mobileBreakpoint}px)`);
+
+      let expandedAtY = null;
+      let lastScrollY = window.scrollY || 0;
+      let raf = 0;
+
+      body.classList.add(BODY_CLASS);
+
+      const heroHeight = () =>
+        Math.max(0, Math.round(hero.getBoundingClientRect().height || 0));
+
+      const stripLocalSticky = () => {
+        document.querySelectorAll(sectionHeadSelector).forEach((el) => {
+          el.classList.remove("is-sticky");
+          el.removeAttribute("data-sticky-active");
+        });
+      };
+
+      const computeFollowOn = () =>
+        !mqMobile.matches &&
+        follow.classList.contains("is-on") &&
+        follow.style.display !== "none" &&
+        follow.getAttribute("aria-hidden") !== "true";
+
+      const applyLocalStickyHeight = () => {
+        const h = mqMobile.matches ? 0 : heroHeight();
+
+        if (typeof window.__archiSetLocalStickyHeight === "function") {
+          window.__archiSetLocalStickyHeight(h);
+        } else {
+          root.style.setProperty("--glossary-local-sticky-h", `${h}px`);
+        }
+      };
+
+      const syncFollowState = () => {
+        const on = computeFollowOn();
+        body.classList.toggle(FOLLOW_ON_CLASS, on);
+        return on;
+      };
+
+      const collapseHero = () => {
+        if (!body.classList.contains(EXPANDED_CLASS)) return;
+
+        body.classList.remove(EXPANDED_CLASS);
+        expandedAtY = null;
+
+        if (heroMore) {
+          heroMore.setAttribute("aria-hidden", "true");
+        }
+
+        if (heroToggle) {
+          heroToggle.hidden = false;
+          heroToggle.setAttribute("aria-expanded", "false");
+        }
+
+        try {
+          window.__archiUpdateFollow?.();
+        } catch {}
+
+        schedule();
+      };
+
+      const expandHero = () => {
+        body.classList.add(EXPANDED_CLASS);
+        expandedAtY = window.scrollY || 0;
+
+        if (heroMore) {
+          heroMore.setAttribute("aria-hidden", "false");
+        }
+
+        if (heroToggle) {
+          heroToggle.hidden = true;
+          heroToggle.setAttribute("aria-expanded", "true");
+        }
+
+        try {
+          window.__archiUpdateFollow?.();
+        } catch {}
+
+        schedule();
+      };
+
+      const syncHeroState = () => {
+        const followOn = computeFollowOn();
+        const expanded = body.classList.contains(EXPANDED_CLASS);
+        const collapsed = followOn && !expanded;
+
+        if (!followOn || mqMobile.matches) {
+          body.classList.remove(EXPANDED_CLASS);
+          expandedAtY = null;
+
+          if (heroMore) {
+            heroMore.setAttribute("aria-hidden", "false");
+          }
+
+          if (heroToggle) {
+            heroToggle.hidden = true;
+            heroToggle.setAttribute("aria-expanded", "false");
+          }
+
+          return;
+        }
+
+        if (heroMore) {
+          heroMore.setAttribute("aria-hidden", collapsed ? "true" : "false");
+        }
+
+        if (heroToggle) {
+          heroToggle.hidden = !collapsed;
+          heroToggle.setAttribute("aria-expanded", expanded ? "true" : "false");
+        }
+      };
+
+      const maybeAutoCollapseOnScroll = () => {
+        if (mqMobile.matches) {
+          lastScrollY = window.scrollY || 0;
+          return;
+        }
+
+        if (!computeFollowOn()) {
+          lastScrollY = window.scrollY || 0;
+          return;
+        }
+
+        if (!body.classList.contains(EXPANDED_CLASS)) {
+          lastScrollY = window.scrollY || 0;
+          return;
+        }
+
+        if (expandedAtY == null) {
+          lastScrollY = window.scrollY || 0;
+          return;
+        }
+
+        const currentY = window.scrollY || 0;
+        const scrollingDown = currentY > lastScrollY;
+        const delta = currentY - expandedAtY;
+
+        if (scrollingDown && delta >= autoCollapseDelta) {
+          collapseHero();
+        }
+
+        lastScrollY = currentY;
+      };
+
+      const syncAll = () => {
+        stripLocalSticky();
+        syncFollowState();
+        syncHeroState();
+        applyLocalStickyHeight();
+      };
+
+      const schedule = () => {
+        if (raf) return;
+        raf = requestAnimationFrame(() => {
+          raf = 0;
+          requestAnimationFrame(syncAll);
+        });
+      };
+
+      heroToggle?.addEventListener("click", expandHero);
+
+      const onScroll = () => {
+        maybeAutoCollapseOnScroll();
+        schedule();
+      };
+
+      const followObserver = new MutationObserver(schedule);
+      followObserver.observe(follow, {
+        attributes: true,
+        attributeFilter: ["class", "style", "aria-hidden"],
+        subtree: false,
+      });
+
+      const heroResizeObserver =
+        typeof ResizeObserver !== "undefined"
+          ? new ResizeObserver(schedule)
+          : null;
+
+      heroResizeObserver?.observe(hero);
+
+      window.addEventListener("scroll", onScroll, { passive: true });
+      window.addEventListener("resize", schedule);
+      window.addEventListener("pageshow", schedule);
+
+      if (document.fonts?.ready) {
+        document.fonts.ready.then(schedule).catch(() => {});
+      }
+
+      if (mqMobile.addEventListener) {
+        mqMobile.addEventListener("change", schedule);
+      } else if (mqMobile.addListener) {
+        mqMobile.addListener(schedule);
+      }
+
+      schedule();
+    };
+
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", boot, { once: true });
+    } else {
+      boot();
+    }
+  })();
+</script>
+
+<style>
+  :global(body.is-glossary-portal-page #reading-follow){
+    z-index: 10;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on .glossary-portal-hero){
+    margin-bottom: 0;
+    padding: 12px 16px 14px;
+    row-gap: 10px;
+    border-bottom-left-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on .glossary-portal-hero h1){
+    font-size: clamp(1.9rem, 3.2vw, 2.55rem);
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on .glossary-portal-hero__intro){
+    max-width: var(--portal-hero-follow-intro-max-w, 68ch);
+    font-size: .98rem;
+    line-height: 1.48;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on:not(.glossary-portal-hero-expanded) .glossary-portal-hero__more){
+    max-height: 0;
+    opacity: 0;
+    overflow: hidden;
+    pointer-events: none;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on:not(.glossary-portal-hero-expanded) .glossary-portal-hero__toggle){
+    display: inline-flex;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on #reading-follow .reading-follow__inner){
+    border-top-left-radius: 0;
+    border-top-right-radius: 0;
+  }
+
+  :global(body.is-glossary-portal-page .glossary-portal-section__head.is-sticky),
+  :global(body.is-glossary-portal-page .glossary-portal-section__head[data-sticky-active="true"]){
+    position: static !important;
+    top: auto !important;
+    z-index: auto !important;
+    padding: 0 !important;
+    border: 0 !important;
+    background: transparent !important;
+    box-shadow: none !important;
+    backdrop-filter: none !important;
+    -webkit-backdrop-filter: none !important;
+  }
+</style>

src/components/GlossaryRelationCards.astro

@@ -0,0 +1,92 @@
+---
+import type { GlossaryRelationBlock } from "../lib/glossary";
+import { hrefOfGlossaryEntry } from "../lib/glossary";
+
+interface Props {
+  relationBlocks: GlossaryRelationBlock[];
+}
+
+const { relationBlocks = [] } = Astro.props;
+const relationsHeadingId = "relations-conceptuelles";
+---
+
+{relationBlocks.length > 0 && (
+  <section
+    class="glossary-relations"
+    aria-labelledby={relationsHeadingId}
+  >
+    <h2 id={relationsHeadingId}>Relations conceptuelles</h2>
+    <div class="glossary-relations-grid">
+      {relationBlocks.map((block) => (
+        <section class={`glossary-relations-card ${block.className}`}>
+          <h3>{block.title}</h3>
+          <ul>
+            {block.items.map((item) => (
+              <li>
+                <a href={hrefOfGlossaryEntry(item)}>{item.data.term}</a>
+                <span> — {item.data.definitionShort}</span>
+              </li>
+            ))}
+          </ul>
+        </section>
+      ))}
+    </div>
+  </section>
+)}
+
+<style>
+  .glossary-relations{
+    margin-top: 26px;
+    padding-top: 18px;
+    border-top: 1px solid rgba(127,127,127,0.18);
+  }
+
+  .glossary-relations h2{
+    margin-bottom: 14px;
+  }
+
+  .glossary-relations-grid{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+    gap: 12px;
+  }
+
+  .glossary-relations-card{
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 16px;
+    padding: 14px 16px;
+    background: rgba(127,127,127,0.05);
+  }
+
+  .glossary-relations-card h3{
+    margin-top: 0;
+    margin-bottom: 10px;
+    font-size: 15px;
+    line-height: 1.35;
+  }
+
+  .glossary-relations-card ul{
+    margin: 0;
+    padding-left: 18px;
+  }
+
+  .glossary-relations-card li{
+    margin-bottom: 8px;
+    font-size: 14px;
+    line-height: 1.45;
+  }
+
+  .glossary-relations-card li:last-child{
+    margin-bottom: 0;
+  }
+
+  .glossary-relations-card span{
+    opacity: .9;
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-relations-card{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

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;
@@ -373,7 +382,7 @@
       return;
     }
 
-    if (Array.isArray(data.authors) && data.authors.length) {
+    if (Array.isArray(data.mobilizedAuthors) && data.mobilizedAuthors.length) {
       const h = document.createElement("h3");
       h.className = "panel-subtitle";
       h.textContent = "Auteurs";
@@ -381,7 +390,7 @@
 
       const ul = document.createElement("ul");
       ul.className = "panel-list";
-      for (const a of data.authors) {
+      for (const a of data.mobilizedAuthors) {
         const li = document.createElement("li");
         li.textContent = esc(a);
         ul.appendChild(li);
@@ -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.config.ts

@@ -0,0 +1,112 @@
+import { defineCollection, z } from "astro:content";
+
+const linkSchema = z.object({
+  type: z.enum(["definition", "appui", "transposition"]),
+  target: z.string().min(1),
+  note: z.string().optional()
+});
+
+const baseTextSchema = z.object({
+  title: z.string().min(1),
+  level: z.union([z.literal(1), z.literal(2), z.literal(3)]).default(1),
+  version: z.string().min(1),
+  concepts: z.array(z.string().min(1)).default([]),
+  links: z.array(linkSchema).default([]),
+  order: z.number().int().nonnegative().optional(),
+  summary: z.string().optional()
+});
+
+// Éditions (séparation stricte : edition + status verrouillés par collection)
+
+const casIa = defineCollection({
+  type: "content",
+  schema: baseTextSchema.extend({
+    edition: z.literal("cas-ia"),
+    status: z.literal("application")
+  })
+});
+
+const commencer = defineCollection({
+  type: "content",
+  schema: baseTextSchema.extend({
+    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")])
+  })
+});
+
+// Glossaire (référentiel terminologique)
+const glossaire = defineCollection({
+  type: "content",
+  schema: z.object({
+    title: z.string().min(1),
+    term: z.string().min(1),
+    aliases: z.array(z.string().min(1)).default([]),
+    urlAliases: z
+      .array(z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/))
+      .default([]),
+    mobilizedAuthors: z.array(z.string().min(1)).default([]),
+    comparisonTraditions: z.array(z.string().min(1)).default([]),
+    edition: z.literal("glossaire"),
+    status: z.literal("referentiel"),
+    version: z.string().min(1),
+    definitionShort: z.string().min(1),
+    concepts: z.array(z.string().min(1)).default([]),
+    links: z.array(linkSchema).default([]),
+
+    kind: z.enum([
+      "concept",
+      "topologie",
+      "diagnostic",
+      "verbe",
+      "paradigme",
+      "doctrine",
+      "dispositif",
+      "figure",
+      "qualification",
+      "epistemologie",
+    ]),
+    family: z.enum([
+        "concept-fondamental",
+        "scene",
+        "dynamique",
+        "pathologie",
+        "topologie",
+        "meta-regime",
+        "paradigme",
+        "doctrine",
+        "verbe",
+        "dispositif-ia",
+        "tension-irreductible",
+        "figure",
+        "qualification",
+        "epistemologie",
+      ]
+    )
+    .optional(),
+    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 = {
+  commencer,
+  "archicrat-ia": archicratIa,
+  "cas-ia": casIa,
+  glossaire,
+};

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

@@ -12,38 +12,7 @@ source:
   kind: docx
   path: "sources/docx/archicrat-ia/Chapitre_1—Fondements_epistemologiques_et_modelisation_Archicratie-version_officielle.docx"
 ---
-Si les sciences politiques ont longtemps trouvé leur ancrage et leur légitimité dans l’analyse des institutions formelles du pouvoir – souveraineté, contrat, autorité, représentation – c’est que le politique y était toujours présumé se manifester à travers une scène, un lieu, un sujet, un régime. Le pouvoir y avait des signes, des corps, des textes ; il procédait d’un fondement — Dieu, la volonté générale, la loi, la nation — et d’un opérateur identifié : le prince, le peuple, le juge, l’État. De la théorie de Hobbes à celle de Rawls, en passant par Rousseau, Kant ou Habermas, les paradigmes de légitimation sont fondés sur une ontologie de la centralité, de la scène constituante, et d’un sujet instituant dont l’autonomie garantit la normativité du pouvoir.
-
-Or, ce que nos régimes contemporains de régulation mettent désormais en crise, ce n’est pas tant la scène elle-même, que la possibilité de sa tenue effective. La scène subsiste, peut-être, mais elle est vidée, ritualisée, simulée, remplacée, saturée ou dissoute dans des procédures techniques, des protocoles logistiques, des décisions sans auteurs, des gouvernances algorithmiques. Le pouvoir opère sans se déclarer, régule sans se justifier, agit sans se mettre en débat. Il est devenu ce que nous proposons de nommer *archicratistique* — c’est-à-dire qu’il agit selon un régime de régulation autonome sans scène, sans justification visible, sans délai institué pour la dispute, sans temporalité contradictoire. Non pas qu’il soit tyrannique, autoritaire ou caché au sens classique, mais parce qu’il *ne se donne plus à la critique* selon les formes instituées de l’opposabilité politique.
-
-L’ambition de ce chapitre est donc de fonder ce paradigme nouveau, ou plus exactement, de nommer et d’outiller une forme ancienne mais non encore pensée du pouvoir — la régulation contradictoire institué. Cette forme, nous la nommons *archicratie*, non pour désigner un régime de plus, mais pour désigner un méta-régime viable de régulation lorsqu’une triade — *arcalité* (fondation déclarable), *cratialité* (opération traçable), *archicration* (épreuve instituée différée) — se tient en tenségrité, c’est-à-dire en tension dynamique métastable l’un à l’autre.
-
-À rebours de l’*archicratie*, nous appelons désarchicration la configuration où la scène est dissoute, court-circuitée ou relocalisée hors d’atteinte, tandis que les régulations se poursuivent néanmoins. Il ne s’agit pas de prétendre que tout deviendrait opaque, mais de constater que l’opacité est structurelle aux dispositifs : non comme accident, mais comme condition de fonctionnement (secret industriel, non-auditabilité des modèles, dilution des responsabilités). Les algorithmes de notation d’allocataires, les règles budgétaires qui déclenchent mécaniquement des fermetures, les protocoles d’ajustement fiscal ou de police sanitaire sont légalement institués, techniquement rationalisés, mais politiquement indisponibles à l’opposition procédurale. Cette indisponibilité se mesure : absence de canal de saisine opposable, délai non garanti pour contester, motifs non accessibles ni réutilisables par les contestataires, paramètres non traçables ni réversibles. Ce n’est pas une archicratie (qui suppose la tenue d’une scène), mais son inverse : une désarchicration où la cratialité et l’arcalité se conjuguent sans archicration, produisant des décisions *indiscutables* de fait, parce que non opposables en temps et en raison.
-
-Les paradigmes classiques — qu’ils soient contractualistes, décisionnistes ou délibératifs — échouent désormais à rendre compte de ces formes. Le pouvoir n’est plus localisé dans un lieu, il ne procède plus d’une scène constituante unique, il n’est plus incarné par un sujet identifiable. Il opère à travers une multiplicité de dispositifs hétérogènes, qui se soutiennent les uns les autres sans principe transcendant, selon une logique de capture, de redondance, de saturation ou d’euphémisation. Michel Foucault l’avait annoncé dès la fin des années 1970 avec son analyse de la gouvernementalité : « ce qui se met en place, ce n’est plus le droit de faire mourir ou de laisser vivre, mais le pouvoir de faire vivre et de laisser mourir » (1976). Hannah Arendt, bien avant lui, avait déjà diagnostiqué que « la disparition de la scène publique, c’est la disparition de la politique elle-même » (1958). Claude Lefort, dans *L’Invention démocratique*, avait désigné le pouvoir démocratique comme un lieu vide — précisément parce que sa légitimité dépend de la possibilité constante de remise en scène, de re-questionnement, de re-distribution. Mais que reste-t-il lorsque cette vacance est non plus instituante, mais neutralisée par des automatismes ? Lorsque la scène est formellement prévue mais substantiellement empêchée ? Lorsque les voies de recours sont techniques, absconses, et différées jusqu’à l’oubli ?
-
-Ce que nous vivons, ce que nous subissons parfois, ce que nous habitons souvent sans le voir, c’est la montée silencieuse des régimes archicratiques : dispositifs de régulation où la scène est inaccessible, où les fondements ne sont plus invoqués, où les décisions ne sont plus motivées, où le temps du différé est supprimé. Ce ne sont pas des régimes de domination au sens fort ; ce sont des régimes d’administration sans épreuve, des formes d’ordonnancement sans théâtre. L’archicratie ne se pense ni contre la démocratie, ni comme sa dégénérescence, mais comme sa marginalisation structurelle : elle s’installe dans les interstices, dans les écarts, dans les non-lieux du politique. Elle est l’administration algorithmique des droits, la codification silencieuse des trajectoires, la performativité sans contradictoire des normes automatiques.
-
-Il nous faut alors un paradigme, non pour idéaliser une alternative, mais pour diagnostiquer cette configuration, pour la rendre visible, pensable, opposable. Car c’est bien cela qui définit un paradigme : sa capacité à faire apparaître ce qui était jusque-là neutralisé. Le paradigme archicratique ne vise pas à remplacer les théories classiques du pouvoir, mais à leur adjoindre une grammaire supplémentaire, permettant de nommer ce qui échappait à leurs catégories. Il ne s’agit plus seulement de savoir *qui* gouverne, mais *comment* se tiennent les régulations, *malgré* l’absence de légitimation visible, *malgré* l’effondrement des scènes instituées, *malgré* la disparition des temporalités différées de la décision. Il s’agit de rendre compte des zones grises, des seuils, des bifurcations, des objets métonymiques de l’ordre, des fonctions qui régulent sans jamais statuer.
-
-Dans cette perspective, ce chapitre se donne pour tâche de poser les fondements épistémologiques, conceptuels et politiques du paradigme archicratique. Nous y exposerons son architecture théorique tripolaire — *arcalité* (ce qui fonde), *cratialité* (ce qui opère), *archicration* (ce qui permet la dispute) — ainsi que sa grammaire topologique interne/externe, ses objets de repérage concrets (fonctions, seuils, porteurs, signes, temporalités), et enfin ses critères de validité. Nous chercherons à produire une cartographie intelligible des formes de régulation contemporaine, sans tomber dans le cynisme ni dans l’utopie, mais en nommant avec précision les tensions, les prises, les scènes, les ruptures, les points aveugles.
-
-Car penser l’archicratie, ce n’est pas inventer un concept : c’est l’extraire du réel pour en faire un outil de diagnostic, un test de viabilité des régulations, un instrument de critique effective des dispositifs. C’est interroger ce qui gouverne sans débat, ce qui ordonne sans justification, ce qui affecte sans se montrer. C’est rouvrir la possibilité d’une pensée politique critique du réel.
-
-Si la modernité politique a trouvé dans la souveraineté représentative son axe structurant, sa fiction fondatrice et sa promesse régulatrice, cette architecture intellectuelle et institutionnelle semble aujourd’hui en proie à une désynchronisation profonde avec les formes effectives de la régulation contemporaine. La souveraineté, dans sa formulation classique — qu’elle s’incarne dans le peuple, la nation, l’État, le contrat ou la loi — présuppose une centralité décisionnelle, une légitimité visible, une continuité symbolique entre le fondement et l’exercice du pouvoir. Or, ce que nous observons aujourd’hui dans la majorité des dispositifs régulateurs, c’est une crise de cette souveraineté représentative non pas tant dans sa légitimité que dans sa capacité à structurer les prises réelles sur le monde. La scène parlementaire subsiste, mais elle est fréquemment contournée ; les mécanismes électoraux se perpétuent, mais ils échouent à produire une autorité agissante sur les déterminations majeures ; les figures institutionnelles traditionnelles persistent, mais elles ne sont plus les lieux d’où se décident ni les normes, ni les trajectoires. Ce déphasage — structurel, et non conjoncturel — signe l’obsolescence progressive d’un régime de pensée : celui qui identifie le pouvoir à une source souveraine, incarnée, stable, légitimée.
-
-À cette crise de la souveraineté s’ajoute l’épuisement des grilles de lecture fondées sur le sujet autonome, contractuel, rationnel — figure centrale de la philosophie politique moderne. La fiction du citoyen-individu, maître de lui-même, capable d’entrer en délibération avec autrui, producteur d’une volonté générale informée, n’a plus de prise réelle sur les architectures décisionnelles automatisées, sur les normes codifiées par délégation, sur les processus algorithmiques opérant sans concertation. L’idéal contractualiste — au fondement des démocraties libérales occidentales — repose sur une scène d’égalité juridique, d’information partagée, de temporalité différée. Or les régulations actuelles, dans le champ fiscal, sanitaire, technologique, éducatif ou même sécuritaire, se déploient sans que ces conditions soient réunies. Le sujet y est affecté avant même d’avoir été informé ; il y est inclus sans qu’on le consulte ; il y est contraint sans avoir la possibilité d’émettre un désaccord opposable. La subjectivité politique classique — cette figure du citoyen capable de comprendre, d’argumenter, de consentir ou de refuser — est contournée par des formats de décision qui n’appellent plus ni la volonté, ni la délibération, ni même la conscience. L’archicratie commence précisément là où le pouvoir ne passe plus par le sujet.
-
-Mais cette crise des catégories héritées n’est pas une vacance : elle est immédiatement occupée par des formes nouvelles de régulation — que nous appelons ici *archicratiques*. Car ce n’est pas l’absence de pouvoir qui domine, mais sa redistribution silencieuse selon des régimes techno-fonctionnels. Nous assistons à une montée en régime de ce que Foucault nommait déjà *les dispositifs de gouvernementalité* : régulations discrètes, réparties, non centralisées, opérant par la norme, le calcul, la procédure, le protocole, l’interface, le flux. Ce sont des décisions sans fondement visible, sans discours justificatif, sans énonciateur identifiable. La décision se donne comme évidence procédurale, comme injonction technique, comme impératif statistique. L’ordre n’est plus commandé, il est implémenté ; il ne se fonde plus dans la loi, mais dans l’algorithme ; il ne se légitime plus par le débat, mais par le chiffre.
-
-Cette montée archicratique s’observe dans la prolifération de gouvernances sans contre-pouvoir : agences indépendantes, plateformes numériques, circuits de certification, autorités administratives sans délibération parlementaire. Ce sont des formes de régulation qui ne sont pas illégales, mais qui échappent à toute mise en scène démocratique. Le débat n’est pas supprimé : il est rendu impossible. Les délais ne sont pas raccourcis : ils sont supprimés. Les voies de recours ne sont pas fermées : elles sont devenues impraticables. L’archicratie est ce régime où la décision opère sans justification explicite, où l’ordre normatif n’a plus besoin de fondation symbolique, et où le politique est remplacé par la régulation performative.
-
-Dès lors, ce que ce chapitre propose, c’est un paradigme non pas alternatif mais *diagnostic* : il ne s’agit pas d’imaginer une nouvelle utopie du pouvoir juste, mais de produire une grille d’intelligibilité critique des régulations sans scène. Car un paradigme n’est pas une hypothèse théorique isolée ; il est une manière de rendre pensable ce qui échappait jusqu’alors aux catégories existantes. Dans notre cas, il s’agit de rendre visibles, pensables et opposables les formes de régulation qui opèrent *en dehors* des critères classiques du politique. Le paradigme archicratique est un paradigme de la non-scène : il suppose l’effectivité sans justification, la décision sans énonciateur, la procédure sans fondement, la régulation sans contradictoire.
-
-Or, pour être valide, un tel paradigme doit être opposable. C’est-à-dire qu’il doit permettre de formuler un diagnostic vérifiable, contestable, falsifiable, reproductible. Il doit désigner des objets de repérage : scènes absentes, fondements éteints, délais supprimés, procédures automatiques, figures d’intercession techniques. Il doit nommer des configurations typiques : régimes où tout semble fonctionnel, mais où rien ne peut plus être remis en cause. Il doit permettre une lecture différenciée du réel, et non une généralisation rhétorique. C’est à cette condition — à la fois théorique, épistémique et politique — que le paradigme archicratique peut s’imposer comme une nouvelle grammaire critique de la régulation contemporaine.
-
-La crise sanitaire du COVID-19, à cet égard, a constitué une épreuve paradigmatique : décisions exceptionnelles prises en Conseil de défense, sans publication des débats, sans délais, sans contradictoire ; régulations sociales massives imposées par décret, par indicateurs, par plateformes ; gouvernance par courbe épidémique, sans justification autre que l’anticipation algorithmique. Dans ce moment extrême, le paradigme archicratique a révélé sa capacité à lire ce que les catégories classiques ne permettaient plus d’interpréter. De même, dans la gouvernance algorithmique des aides sociales, dans la notation automatique des élèves ou dans la gestion budgétaire par règles européennes automatiques, nous observons des dispositifs où *la régulation opère sans pouvoir visible, sans scène explicite, sans fondement justifié*. Ce n’est pas la fin du politique, c’est sa mutation silencieuse. Et c’est cette mutation que l’archicratie nous permet de penser, de cartographier, de critiquer — à condition que le paradigme se dote d’une architecture rigoureuse, d’une typologie opératoire, d’une exigence de validation, et d’un langage partagé. Ce chapitre en jette les fondements.
-
+# **CHAPITRE 1 — FONDEMENTS ÉPISTÉMOLOGIQUES, STATUT POLITIQUE ET VALIDATION DU PARADIGME ARCHICRATIQUE**
 ## 1.1 — Hypothèse fondatrice : L’archicratie comme paradigme triadique de régulation
 
 Si toute société humaine connaît des formes d’organisation, toute société politique, en revanche, ne devient pensable comme telle qu’à partir du moment où elle institue non seulement des ordres, mais des épreuves de l’ordre. Il ne suffit pas qu’un ordre fonctionne pour être légitime, il faut qu’il soit soutenu par un fondement déclarable, une force opérante, et une scène de dispute. Ce trépied invisible — dont l’oubli ou la dissociation produit la dérive — constitue le socle conceptuel du paradigme archicratique. Il ne s’agit pas ici d’additionner des dimensions empiriques hétérogènes, mais de poser une hypothèse fondatrice : toute régulation, pour être viable, discernable, contestable, et transmissible, articule nécessairement trois registres distincts mais indissociables. C’est cette *structure tripolaire* que nous proposons de désigner comme l’ossature régulatoire de l’archicratie.
@@ -52,11 +21,11 @@ Le premier pôle est celui de *l’arcalité*. L’arcalité n’est ni une simp
 
 Le second pôle est celui de *la cratialité*. La cratialité désigne la capacité effective d’un dispositif à produire des effets dans le monde : son opérativité, sa puissance d’action, sa capacité à structurer, à contraindre, à transformer. Elle inclut les infrastructures matérielles (bâtiments, réseaux, plateformes), les dispositifs techniques (logiciels, bases de données, interfaces), les procédures (circulaires, décrets, codifications), les corps organisés (administrations, directions, opérateurs), ainsi que les flux (budgétaires, logistiques, cognitifs) qui permettent à la régulation de s’effectuer. La cratialité n’est pas nécessairement visible, mais elle est toujours active. Elle est la force sans laquelle la norme reste lettre morte, la capacité sans laquelle le fondement demeure incantation. C’est la force de transformation, mais aussi, potentiellement, celle de capture, de verrouillage ou d’effacement de la scène politique.
 
-Le troisième pôle, enfin, est celui de *l’archicration*. Ce néologisme désigne la capacité d’un ordre à se rendre *disputable* : c’est-à-dire à instituer une scène, un moment, un dispositif, où l’ordre peut être mis en épreuve, critiqué, reformulé, contesté, amendé. L’archicration est ce qui rend le pouvoir *opposable*, non dans un sens antagonique, mais dans un sens procédural, différé, dialogique. Elle prend la forme d’un contradictoire institué, d’un recours possible, d’un délai interprétatif, d’un droit de parole, d’un espace de reconfiguration. Là où l’arcalité fonde, où la cratialité opère, l’archicration dispute — et en disputant, elle garantit la *viabilité politique* du dispositif. Sans elle, la régulation devient une pure mécanique ; avec elle, elle devient une architecture habitable.
+Le troisième pôle, enfin, est celui de *l’archicration*. Ce néologisme désigne la capacité d’un ordre à se rendre *disputable* : c’est-à-dire à instituer une scène, un moment, un dispositif, où l’ordre peut être mis en épreuve, critiqué, reformulé, contesté, amendé. L’archicration est ce qui rend le pouvoir *opposable*, non dans un sens antagonique, mais dans un sens procédural, différé, dialogique. Elle prend la forme d’un contradictoire institué, d’un recours possible, d’un délai interprétatif, d’un droit de parole, d’un espace de reconfiguration. Là où l’arcalité fonde, où la cratialité opère, l’archicration dispute — et en disputant, elle garantit la *viabilité politique* du dispositif.
 
-Mais ce qui fait la force heuristique du paradigme archicratique, c’est que ces trois pôles ne sont pas des catégories séparées, ni des moments successifs, mais des *dimensions co-présentes* de tout dispositif. Chacun peut dominer, se retrancher, se dissoudre, ou se substituer aux autres, mais leur tension constitue le *champ de régulation*. Ce trépied constitue ainsi une véritable *grille différentielle de lecture* des régulations : il permet de repérer ce qui fonde sans agir, ce qui agit sans fonder, ce qui opère sans être disputé — et, symétriquement, ce qui fonde tout en opérant, ce qui opère tout en permettant la contestation, ce qui conteste à partir d’un fondement consistant.
+Mais ce qui fait la force heuristique du paradigme archicratique, c’est que ces trois pôles ne sont pas des catégories séparées, ni des moments successifs, mais des *dimensions co-présentes* de tout dispositif. Chacun peut dominer, se retrancher, se dissoudre, ou se substituer aux autres, mais leur tension constitue le *champ de régulation*. Ce trépied constitue ainsi une véritable *grille différentielle de lecture* des régulations : il permet de repérer ce qui fonde sans prise opératoire suffisante, ce qui agit sur fondement peu exposable, ce qui opère sous archicration neutralisée ou rendue pratiquement inopérante — et, symétriquement, ce qui fonde tout en opérant, ce qui opère tout en laissant place à la contestation, ce qui conteste à partir d’un fondement consistant.
 
-Ce paradigme triadique ne repose donc pas sur une essence du politique, mais sur une condition de possibilité de la régulation. Il ne dit pas ce que *doit être* un bon régime, mais ce qui fait qu’un ordre peut être dit *politique*, c’est-à-dire exposé à l’épreuve, fondé dans un sens, et transformateur d’une réalité. Dans un contexte où la scène politique se disloque, où les régulations deviennent silencieuses, où les fondements sont euphémisés et les disputes neutralisées, la force de ce paradigme est de *restituer une cartographie* du fait politique. Il ne suffit plus d’invoquer la légitimité, ni de dénoncer la technicisation : il faut *déplier* chaque dispositif en ses composantes fondamentales — fondation, opération, régulation — et en comprendre les combinaisons, les déséquilibres, les absences, les ruptures.
+Ce paradigme triadique ne repose donc pas sur une essence du politique, mais sur une condition de possibilité de la régulation. Il ne dit pas ce que *doit être* un bon régime, mais ce qui fait qu’un ordre peut être dit *politique*, c’est-à-dire exposé à l’épreuve, fondé dans un sens, et transformateur d’une réalité. Dans un contexte où la scène politique se disloque, où les régulations deviennent silencieuses, où les fondements sont euphémisés et les disputes neutralisées, la force de ce paradigme est de *restituer une cartographie* du fait politique. Il ne suffit plus d’invoquer la légitimité, ni de dénoncer la technicisation : il faut *déplier* chaque dispositif en ses composantes fondamentales — fondation, opération, régulation — et en comprendre les combinaisons, les déséquilibres, les mises en latence, les neutralisations et les ruptures d’articulation.
 
 C’est sur cette base que se construiront, dans les sections suivantes, une typologie des arcalités, des cratialités et des archicrations, une cartographie interne/externe de leurs interactions, ainsi qu’une analyse critique de leurs configurations pathologiques. Ce triptyque constitue la structure paradigmatique minimale pour analyser les dispositifs politiques en dehors des grilles souverainistes, contractualistes ou fonctionnalistes. Et c’est précisément en les confrontant à la réalité — textes, objets, fonctions, temporalités, cas d’usage — que nous en testerons la robustesse.
 
@@ -92,7 +61,7 @@ Le terme de cratialité comme nous l’avons vu en préambule dérive ici du rad
 
 Dans les régimes politiques classiques, on identifie la *cratialité* à l’exécutif : ministère, force publique, budget, bras armé. Mais cette lecture est à la fois trop réductrice et historiquement datée. La *cratialité* contemporaine excède largement les figures classiques du pouvoir d’État. Elle s’incarne dans des *algorithmes*, des *tableaux de bord*, des *logiciels d’évaluation*, des *systèmes de logistique globale*, des *normes ISO*, des *actes administratifs unilatéraux*, des *marchés publics automatisés*, des *protocoles cryptés*, des *formulaires numériques inaccessibles*. Elle peut être discrète, discrétionnaire, distribuée, voire disséminée jusqu’à devenir opaque. Mais elle est toujours active : elle fait advenir un effet de régulation.
 
-C’est pourquoi la *cratialité* ne saurait être conçue comme un simple rouage intermédiaire entre la fondation (*arcalité*) et la révision (*archicration*). Elle n’est ni instrument, ni exécution pure. Elle possède sa logique propre, ses effets d’autonomisation, ses inerties internes, ses formes d’expansion ou de court-circuit. Elle peut fonctionner sans justification — c’est le cas des algorithmes non documentés — et sans épreuve — c’est le cas des procédures automatiques non opposables. C’est en cela qu’elle constitue l’un des points névralgiques du basculement archicratique : là où la *cratialité* devient *indépendante*, *autosuffisante*, *désarrimée*, elle cesse d’être un vecteur de régulation pour devenir un vecteur de domination silencieuse.
+C’est pourquoi la *cratialité* ne saurait être conçue comme un simple rouage intermédiaire entre la fondation (*arcalité*) et la révision (*archicration*). Elle n’est ni instrument, ni exécution pure. Elle possède sa logique propre, ses effets d’autonomisation, ses inerties internes, ses formes d’expansion ou de court-circuit. Elle peut fonctionner comme si elle n’avait plus à répondre explicitement de ses justifications — c’est le cas des algorithmes non documentés — et comme si la scène d’épreuve n’avait plus de prise effective sur son cours ordinaire — c’est le cas des procédures automatiques rendues pratiquement non opposables. C’est en cela qu’elle constitue l’un des points névralgiques du basculement archicratique : là où la *cratialité* devient *indépendante*, *autosuffisante*, *désarrimée*, elle cesse d’être un vecteur de régulation pour devenir un vecteur de domination silencieuse.
 
 Or, comme l’*arcalité*, la *cratialité* se donne elle aussi selon une double topologie : interne et externe. Une *cratialité* est dite *interne* lorsqu’elle repose sur les moyens d’action propres au dispositif : administration, personnels, processus décisionnels, procédures codifiées, infrastructures spécifiques. Elle est dite *externe* lorsqu’elle mobilise des ressources extérieures : cabinets de conseil, normes transnationales, plateformes numériques privées, logistiques externalisées, financements conditionnés, technologies exogènes. Ce clivage interne/externe n’est pas secondaire : il est décisif pour comprendre les asymétries de pouvoir, les dépendances structurelles, les logiques de capture. Un hôpital, par exemple, peut être cratialisé de l’intérieur par son système de codage et ses tableaux d’affectation, ou de l’extérieur par des normes budgétaires européennes ou des logiciels achetés à des firmes privées.
 
@@ -108,11 +77,11 @@ Ce n’est pas la performance qui fait la validité politique d’une *cratialit
 
 #### **L’*archicration* : ce qui dispute, conteste, met en épreuve, arbitre**
 
-L’*archicration* constitue le troisième pôle du paradigme archicratique et, à bien des égards, son point d’incandescence politique : c’est elle qui transforme une régulation en un ordre véritablement *politique*. Là où l’*arcalité* fonde et où la *cratialité* opère, l’*archicration* institue l’épreuve, ouvre la dispute, rend possible la contestation organisée, et par là confère à l’ordre de régulation une dimension dialogique et réflexive. Sans *archicration*, une régulation n’est qu’un flux ; le pouvoir n’est qu’un automatisme ; le politique s’efface derrière la procédure. L’*archicration* est donc la scène instituée du différé, du contradictoire, du droit de regard et de la reprise.
+L’archicration constitue le troisième pôle du paradigme archicratique et, à bien des égards, son point d’incandescence politique : c’est elle qui transforme une régulation en un ordre véritablement politique. Là où l’arcalité fonde et où la cratialité opère, l’archicration institue l’épreuve, ouvre la dispute, rend possible la contestation organisée, et confère à l’ordre de régulation une dimension dialogique et réflexive. Lorsqu’elle est neutralisée, mimée, relocalisée hors d’atteinte ou rendue pratiquement inopérante, la régulation tend à devenir une pure mécanique ; lorsqu’elle est tenue comme scène effective de reprise, elle devient une architecture habitable.
 
 Le terme lui-même est construit à partir de *ἀρχὴ* (principe, origine, autorité) et *κρατέω* (être ou devenir le maître). Il désigne donc la capacité d’un dispositif de régulation à se rendre *opposable et amendable* dans un cadre institué : une instance, un rituel, une temporalité qui permet aux acteurs concernés de formuler, argumenter, contester, reconfigurer. C’est l’anti-mimétisme de la scène : non pas faire semblant d’écouter, mais *produire les conditions réelles* de l’écoute, du délai, du recours, de la révision. L’*archicration* n’est pas une option morale, ni un supplément d’âme procédural ; elle est la condition même de l’habitation politique d’un ordre, le fait d’en être maître, d’en devenir autorité.
 
-Historiquement, les sociétés se sont dotées de formes d’*archicration* très variées : tribunaux, parlements, assemblées populaires, chambres de recours, médiations rituelles, procédures de droit coutumier, juridictions supra-étatiques. Ce sont des *scènes instituantes* qui ralentissent l’acte, l’exposent, l’ouvrent à la pluralité, et, ce faisant, lui confèrent une légitimité durable. Mais ces scènes peuvent se fermer, se vider, se fragmenter, ou être capturées. Dans les dispositifs archicratiques contemporains, l’*archicration* est souvent absente, mimée ou neutralisée. On convoque une « consultation publique » dont les résultats sont déjà fixés ; on ouvre une « plateforme participative » dont les algorithmes filtrent les réponses ; on institue des « délais de recours » dont la brièveté ou la complexité les rend impraticables. Il en résulte un effet d’évanescence de la scène : elle est là en apparence, mais elle n’opère plus en réalité.
+Historiquement, les sociétés se sont dotées de formes d’*archicration* très variées : tribunaux, parlements, assemblées populaires, chambres de recours, médiations rituelles, procédures de droit coutumier, juridictions supra-étatiques. Ce sont des *scènes instituantes* qui ralentissent l’acte, l’exposent, l’ouvrent à la pluralité, et, ce faisant, lui confèrent une légitimité durable. Mais ces scènes peuvent se fermer, se vider, se fragmenter, ou être capturées. Dans les dispositifs archicratiques contemporains, l’archicration est souvent neutralisée, mimée, relocalisée hors d’atteinte ou rendue pratiquement inopérante. On convoque une « consultation publique » dont les résultats sont déjà fixés ; on ouvre une « plateforme participative » dont les algorithmes filtrent les réponses ; on institue des « délais de recours » dont la brièveté ou la complexité les rend impraticables. Il en résulte un effet d’évanescence de la scène : elle est là en apparence, mais elle n’opère plus en réalité.
 
 C’est pourquoi l’analyse archicratique exige de penser l’*archicration* en tant que *dimension constitutive*, et non comme simple accessoire. Comme pour l’*arcalité* et la *cratialité*, l’*archicration* se déploie selon une double topologie : elle peut être interne — lorsqu’un dispositif institue en son sein des mécanismes de contestation et d’ajustement (conseils délibératifs, commissions de médiation, audits internes, organes de gouvernance participative) — ou externe — lorsqu’il est soumis à des scènes de contrôle ou d’épreuve extérieures (juridictions supranationales, contre-pouvoirs citoyens, presse, ONG, instances internationales). Ces deux modalités sont cruciales : un dispositif peut être très opposable en externe mais totalement fermé en interne, ou inversement. La santé démocratique d’une régulation se mesure à la combinaison des deux.
 
@@ -122,7 +91,7 @@ L’*archicration* ne se limite pas à ce qui autorise la critique ; elle est ce
 
 Enfin, comme pour l’*arcalité* et la *cratialité*, l’*archicration* doit pouvoir être mesurée, qualifiée, falsifiée. Il ne suffit pas d’affirmer qu’une scène existe ; il faut interroger sa qualité : est-elle accessible, proportionnée, pluraliste, transparente, effective ? Est-elle un véritable lieu de remise en cause ou une simple mise en scène ? Ces questions sont au cœur de l’analyse archicratique. Elles seront systématisées dans la section 1.6, où nous formulerons des critères d’opposabilité et d’authentification, et testées empiriquement dans les études de cas du chapitre.
 
-Ainsi, l’*archicration* complète le triptyque fondateur du paradigme archicratique. Sans elle, la régulation n’est qu’un flux technique ; avec elle, elle redevient un ordre politique. Elle n’est pas un supplément éthique, mais une condition de viabilité. Elle n’est pas un idéal abstrait, mais une variable concrète, observable, localisable, qui signe la différence entre un dispositif gouvernant et un dispositif administrant. Et c’est précisément parce qu’elle est aujourd’hui menacée, neutralisée ou mimée que le paradigme archicratique s’impose : pour rendre visible ce qui se perd, pour diagnostiquer ce qui persiste, et pour imaginer ce qui pourrait s’instituer.
+Ainsi, l’*archicration* complète le triptyque fondateur du paradigme archicratique. Privée d’archicration effective, la régulation tend à n’être plus qu’un flux technique ; lorsqu’une scène de reprise demeure praticable, elle redevient un ordre politique. Elle n’est pas un supplément éthique, mais une condition de viabilité. Elle n’est pas un idéal abstrait, mais une variable concrète, observable, localisable, qui signe la différence entre un dispositif gouvernant et un dispositif administrant. Et c’est précisément parce qu’elle est aujourd’hui menacée, neutralisée ou mimée que le paradigme archicratique s’impose : pour rendre visible ce qui se perd, pour diagnostiquer ce qui persiste, et pour imaginer ce qui pourrait s’instituer.
 
 Les trois prises ne se subsument jamais l’une l’autre : l’*arcalité* fonde, la *cratialité* oblige, l’*archicration* met en controverse réglée. Aucune ne vaut sans les deux autres ; toute lecture binaire serait régressive.
 
@@ -192,9 +161,9 @@ Les *objets archicratifs* sont ceux qui manifestent — ou masquent — l’exis
 
 Ces objets n’ont pas pour fonction de produire un effet régulateur direct. Mais ils changent tout au monde politique, car ils transforment un ordre de fait en un ordre contestable, c’est-à-dire potentiellement réversible. Là réside leur pouvoir propre : ils inscrivent la norme dans le champ de la délibération. Ils ne gouvernent pas, mais ils rendent le gouvernement visible, énonçable et amendable.
 
-Un simple registre de saisine citoyenne — tenu à jour, accessible, lisible — est un puissant *objet d’archicration*. Il permet à une décision d’être rouverte, à une politique d’être contestée, à un dispositif d’être réévalué. Une décision administrative motivée — dont les motifs sont publiés, les délais indiqués, les voies de recours explicitement mentionnées — devient, en ce sens, un support d’opposabilité. Inversement, son absence signe une forme d’autoritarisme silencieux, une neutralisation de la scène. De même, un procès-verbal d’audition contradictoire — où les arguments des différentes parties sont repris, répondus, hiérarchisés — est un *objet archicratif* à haute valeur politique. Il permet mise en visibilité d’une épreuve, une documentation de l’écoute, une matérialisation de la scène.
+Un simple registre de saisine citoyenne — tenu à jour, accessible, lisible — est un puissant *objet d’archicration*. Il permet à une décision d’être rouverte, à une politique d’être contestée, à un dispositif d’être réévalué. Une décision administrative motivée — dont les motifs sont publiés, les délais indiqués, les voies de recours explicitement mentionnées — devient, en ce sens, un support d’opposabilité. Inversement, son absence signe une forme d’autoritarisme silencieux, une neutralisation de la scène. De même, un procès-verbal d’audition contradictoire — où les arguments des différentes parties sont repris, répondus, hiérarchisés — est un *objet archicratif* à haute valeur politique. Il rend visible une épreuve, documente l’écoute et matérialise la scène.
 
-Mais comme pour les *objets arcaux et cratiaux*, la puissance politique d’un *objet archicratif* ne tient pas à sa simple existence formelle. Encore faut-il qu’il soit effectif, accessible, activable. Une plateforme de consultation publique qui n’est ni analysée, ni suivie d’effet, ni même modérée de manière transparente, n’est pas un objet d’archicration — c’est une *simulacre archicratique*. Un délai de recours de 24 heures sans possibilité d’assistance juridique n’est pas un mécanisme de contradictoire, mais un leurre procédural. Il en va de même pour un registre de doléances enfermé dans une armoire, jamais traité, jamais rendu public, n’ouvrant aucune scène, ne garantissant aucun différé. Il mime l’ouverture archicrative, tout en l’empêchant.
+Mais comme pour les *objets arcaux et cratiaux*, la puissance politique d’un *objet archicratif* ne tient pas à sa simple existence formelle. Encore faut-il qu’il soit effectif, accessible, activable. Une plateforme de consultation publique qui n’est ni analysée, ni suivie d’effet, ni même modérée de manière transparente, n’est pas un objet d’archicration — c’est *un simulacre archicratique*. Un délai de recours de 24 heures sans possibilité d’assistance juridique n’est pas un mécanisme de contradictoire, mais un leurre procédural. Il en va de même pour un registre de doléances enfermé dans une armoire, jamais traité, jamais rendu public, n’ouvrant aucune scène, ne garantissant aucun différé. Il mime l’ouverture archicrative, tout en l’empêchant.
 
 Ainsi, les *objets d’archicration* sont hautement vulnérables à la capture, au vide symbolique, à la neutralisation rituelle. Ce sont les objets les plus spectaculaires, mais aussi les plus faciles à rendre ineffectifs, car leur forme suffit à donner l’illusion de la dispute. D’où l’importance, dans le paradigme archicratique, de ne jamais les considérer de manière formelle ou nominale, mais toujours selon une grille d’évaluation substantielle :
 
@@ -214,9 +183,9 @@ Chaque *objet d’archicration* doit donc être interrogé selon ces critères.
 
 Enfin, il convient d’insister sur la topologie des *objets archicratifs*. Ils peuvent être internes : conseils délibératifs, comités d’éthique, médiateurs, dispositifs de saisine interne, commissions de réexamen. Ils peuvent être externes : recours juridictionnels, mobilisation d’instances indépendantes (Défenseur des droits, Conseil d’État, Autorité de régulation), interventions médiatiques documentées, pétitions publiques structurées, tribunaux populaires. Un système politique robuste combine les deux : il s’auto-dispute en interne, mais se rend aussi disputable de l’extérieur.
 
-Dans des configurations archicratiques, les *objets d’archicration* sont souvent mimés en interne — pour donner l’illusion de la scène — tandis que les dispositifs externes d’opposabilité sont rendus inopérants, dilués ou purement formels. Ce n’est pas qu’un régime serait ouvertement archicratique ; c’est que certaines fonctions, certaines séquences ou certains vecteurs de régulation se déploient de manière archicratique : par neutralisation de l’épreuve, occultation des fondements et saturation opératoire. L’*archicratie* ne désigne donc pas une oligarchie instituée, mais une modalité silencieuse de la régulation qui peut traverser tous les régimes, tous les secteurs, et dont certains groupes sociaux ou fonctions deviennent les porteurs structurels — sans en revendiquer pour autant le nom. Nous les appelons ici : les *archicrates*.
+Dans des configurations autarchicratiques, les objets d’archicration sont souvent mimés en interne — pour donner l’illusion de la scène — tandis que les dispositifs externes d’opposabilité sont rendus inopérants, dilués ou purement formels. Ce n’est pas qu’un régime serait ouvertement autarchicratique ; c’est que certaines fonctions, certaines séquences ou certains vecteurs de régulation se déploient selon une logique autarchicratique : par neutralisation de l’épreuve, occultation des fondements et saturation opératoire. L’autarchicratie ne désigne donc pas une oligarchie instituée, mais une dérive silencieuse de la régulation qui peut traverser tous les régimes, tous les secteurs, et dont certains groupes sociaux ou certaines fonctions deviennent les porteurs structurels — sans en revendiquer pour autant le nom. Nous les appellerons ici, si l’on veut les nommer rigoureusement : des porteurs de fermeture autarchique.
 
-Car c’est bien cela qui est en jeu : non pas l’existence théorique d’une contestation, mais sa possibilité instituée, régulée, documentée. Là où l’archicration est absente, le pouvoir devient indiscutable — non par tyrannie explicite, mais par dissolution des conditions de la scène. Là où elle est simulée, le politique devient un théâtre d’ombres. Là où elle est instituée, explicite, traçable, elle redonne au pouvoir sa dimension dialogique, sa dimension temporelle, sa dimension politique.
+Car c’est bien cela qui est en jeu : non pas l’existence théorique d’une contestation, mais sa possibilité instituée, régulée, documentée. Là où l’archicration est neutralisée, mimée, relocalisée hors d’atteinte ou rendue pratiquement inopérante, le pouvoir tend à devenir indiscutable — non par tyrannie explicite, mais par dissolution des conditions effectives de la scène. Là où elle est simulée, le politique devient un théâtre d’ombres. Là où elle est instituée, explicite, traçable et opposable, elle redonne au pouvoir sa dimension dialogique, sa dimension temporelle, sa dimension politique.
 
 Les *objets archicratifs* ne sont donc ni accessoires ni résiduels : ils sont la clef de voûte du politique comme épreuve. Ce sont eux qui assurent qu’une norme n’est pas un destin, qu’une régulation peut être reconfigurée, qu’un ordre n’est pas clos. Ce sont eux qui, au sein de la structure archicratique, permettent que le pouvoir soit tenu pour comptable, et donc transformable.
 
@@ -226,7 +195,7 @@ Il est nécessaire mais non suffisant d’identifier des principes abstraits —
 
 Un badge d’accès, un formulaire de recours, un tableau de bord algorithmique, une charte d’éthique, une convocation à une commission, un registre de délibération, un logiciel de pilotage budgétaire ou un protocole de saisine sont autant d’objets d’apparence neutre — mais qui, situés dans un écosystème de régulation, expriment une position archicratique : ils sont les métonymies de la structure, au sens où chaque objet, bien qu’apparemment partiel, renvoie à l’ensemble du régime dont il procède.
 
-Un badge sans nom, sans fonction lisible, sans statut accessible ne signale pas seulement un problème d’accès : il objective une dissociation entre *cratialité* et *archicration*, en empêchant la formulation de toute contestation localisée. Une charte d’entreprise affichée dans un hall, non opposable juridiquement, manifeste une *arcalité* de façade, sans ancrage normatif. Un algorithme qui produit des décisions sans en publier les règles institue une *cratialité* opaque, sans archicration possible. Ce sont là des objets discrets — mais qui configurent le pouvoir, organisent l’action, orientent la reconnaissance, verrouillent les possibilités de mise en cause.
+Un badge sans nom, sans fonction lisible, sans statut accessible ne signale pas seulement un problème d’accès : il objective une dissociation entre *cratialité* et *archicration*, en empêchant la formulation de toute contestation localisée. Une charte d’entreprise affichée dans un hall, non opposable juridiquement, manifeste une *arcalité* de façade, sans ancrage normatif. Un algorithme qui produit des décisions sans en publier les règles institue une *cratialité* opaque, sans archicration effective possible. Ce sont là des objets discrets — mais qui configurent le pouvoir, organisent l’action, orientent la reconnaissance, verrouillent les possibilités de mise en cause.
 
 Lire une régulation politiquement, c’est donc lire les objets qui la rendent possible, et interroger la grammaire que ces objets rendent visible ou invisible. Or, cette grammaire ne peut être saisie qu’en articulant trois dimensions :
 
@@ -244,11 +213,11 @@ Mais cette lecture métonymique ne s’oppose pas à une lecture systémique : a
 
 Si le paradigme archicratique repose sur cette tripartition fondamentale, il serait erroné d’en faire une grille statique ou une typologie figée. Ce qui fait sa valeur heuristique ne se résume pas en la distinction de ces trois pôles, mais dans la mise en tension dynamique qui les relie, les contraint, les déséquilibre ou les ajuste dans toute situation de régulation. Loin d’être des sphères séparées, ces trois dimensions n’existent que dans leur interaction mutuelle, dans une dialectique structurante où chacune affecte la viabilité des deux autres. C’est cette logique d’interdépendance — parfois harmonieuse, souvent tendue, parfois rompue — qui constitue la véritable mécanique différentielle de l’analyse archicratique.
 
-L’*arcalité* peut exister sans *cratialité* : c’est le cas des idéaux solennels sans effectuation, des textes fondateurs devenus vestiges, des récits politiques non suivis d’action. La *cratialité* peut se déployer sans *arcalité* : c’est le régime du pur instrument, de la machine sans justification, du dispositif opératoire sans horizon. L’*archicration* peut être instituée sans prise réelle : c’est la critique sans effet, le recours sans impact, la procédure désarmée. Chacun de ces désajustements produit des formes pathologiques de régulation, non par la faute d’un défaut total, mais par la déconnexion des pôles entre eux. L’*archicratie* ne devient intelligible qu’en mesurant le degré d’articulation effective — et non déclarative — entre ces trois dimensions.
+L’arcalité peut subsister à l’état de vestige, de référence peu opérante ou de fondement faiblement mobilisé ; la cratialité peut s’autonomiser sur fond d’arcalité peu exposable ou faiblement assumée ; l’archicration peut être formellement instituée tout en restant sans prise réelle sur la trajectoire décisionnelle. Chacun de ces désajustements produit des formes pathologiques de régulation, non par la faute d’un défaut absolu, mais par la déconnexion ou la dégradation des pôles entre eux. L’archicratie ne devient intelligible qu’en mesurant le degré d’articulation effective — et non simplement déclarative — entre ces trois dimensions.
 
-Pour cette raison, il est nécessaire de substituer à la figure du triangle une figure tensorielle, où les forces de chaque pôle exercent une poussée, un rappel ou un affaissement sur les deux autres. Toute régulation produit ainsi un champ de forces, qui peut être tendu, équilibré, instable ou disjoint. L’*arcalité* oriente le sens ; la *cratialité* donne prise au réel ; l’*archicration* introduit le différé, le possible, l’inédit. Leur co-présence est la condition minimale d’un ordre politique habitable. Leur absence ou leur domination univoque constitue, à l’inverse, le signe d’un régime appauvri, voire fermé et autoritaire.
+Pour cette raison, il est nécessaire de substituer à la figure du triangle une figure tensorielle, où les forces de chaque pôle exercent une poussée, un rappel ou un affaissement sur les deux autres. Toute régulation produit ainsi un champ de forces, qui peut être tendu, équilibré, instable ou disjoint. L’*arcalité* oriente le sens ; la *cratialité* donne prise au réel ; l’*archicration* introduit le différé, le possible, l’inédit. Leur co-présence est la condition minimale d’un ordre politique habitable. Leur neutralisation, leur mise en latence ou leur domination univoque constitue, à l’inverse, le signe d’un régime appauvri, voire fermé et autoritaire.
 
-Ce n’est donc pas la présence de chacun des trois pôles, pris isolément, qui garantit la qualité politique d’une régulation, mais la manière dont ils se répondent, se nourrissent, se corrigent ou s’affrontent. Une *arcalité* active, mais non révisable, produit du dogmatisme. Une *cratialité* hyper-efficiente sans fondement engendre de la brutalité technicienne. Une *archicration* procédurale sans fondation partagée tourne à vide sans adhésion dans le pur arbitraire. L’analyse archicratique repose alors sur un principe de consistance dynamique : *toute régulation politiquement viable est un régime où la légitimité fondatrice, la puissance opératoire et la scène contradictoire s’équilibrent par ajustements réciproques.*
+Ce n’est donc pas la présence de chacun des trois pôles, pris isolément, qui garantit la qualité politique d’une régulation, mais la manière dont ils se répondent, se nourrissent, se corrigent ou s’affrontent. Une *arcalité* active, mais non révisable, produit du dogmatisme. Une *cratialité* hyper-efficiente à fondement peu exposable ou désarrimé engendre de la brutalité technicienne. Une *archicration* procédurale sans fondation partagée tourne à vide sans adhésion dans le pur arbitraire. L’analyse archicratique repose alors sur un principe de consistance dynamique : *toute régulation politiquement viable est un régime où la légitimité fondatrice, la puissance opératoire et la scène contradictoire s’équilibrent par ajustements réciproques.*
 
 Cette dynamique se lit dans la manière dont une règle renvoie à une doctrine, dont un instrument laisse place à une critique, dont une norme peut évoluer par révision. Prenons un exemple : un protocole sanitaire. Il peut être fondé (*arcalité* scientifique ou juridique), appliqué (*cratialité* technique et administrative), mais si aucune révision n’est possible en cas de controverse, l’*archicration* fait défaut — et le dispositif devient pure contrainte et imposition. À l’inverse, une procédure ouverte à la contestation qui ne serait pas adossée à un fondement clair produirait du désordre, du flottement ou de l’épuisement normatif.
 
@@ -256,17 +225,17 @@ Il importe alors de penser la régulation non comme une mécanique fluide, mais
 
 C’est pourquoi la cartographie archicratique ne vise pas à repérer des dispositifs « purs », mais à diagnostiquer des régimes de composition : *comment s’agencent, dans tel ou tel secteur, l’arcalité, la cratialité et l’archicration ? Quelle est la qualité de leur articulation ? Quels seuils de domination ou de carence observe-t-on ?* Cette dynamique nous conduit directement à la section 1.1.4, où nous décrirons les premiers cas limites — ces régulations déséquilibrées où un seul pôle l’emporte, où les autres se retirent, où l’ordre se fige ou s’effondre. Ce sont ces cas extrêmes qui révéleront, par contraste, ce qui fait la cohérence — ou la défaillance — d’une régulation.
 
-Ainsi, loin de reposer sur une addition de fonctions ou un empilement de principes, le paradigme archicratique se fonde sur l’analyse différentielle de l’articulation dynamique entre fondement, opération et épreuve. C’est cette tension constitutive — ni soluble, ni effaçable — qui fait de la régulation un fait politique, et non une simple organisation. Et c’est par l’analyse rigoureuse de cette dynamique que nous pourrons, dans les sections ultérieures, établir une typologie des régimes (1.5), des déséquilibres (1.6), des porteurs (1.7), des temporalités (1.8), et des cas empiriques (1.9).
+Ainsi, loin de reposer sur une addition de fonctions ou un empilement de principes, le paradigme archicratique se fonde sur l’analyse différentielle de l’articulation dynamique entre fondement, opération et épreuve. C’est cette tension constitutive — ni soluble, ni effaçable — qui fait de la régulation un fait politique, et non une simple organisation. Et c’est par l’analyse rigoureuse de cette dynamique que nous pourrons, dans les sections ultérieures, préciser les premiers déséquilibres (1.1.4), puis plus tard dans le chapitre, les formes dynamiques de la tenue archicratique (1.5), les repères heuristiques (1.6) et les morphologies opérantes (1.7).
 
 ### 1.1.4 — Premiers cas limites : déséquilibres, courts-circuitages et régulations instables
 
 Encore faut-il que notre construction tripartite permette de repérer les régulations qui échouent, non par absence de dispositifs, mais par déséquilibre interne entre les trois pôles constitutifs du paradigme. C’est précisément dans ces cas limites — ces régimes pathologiques où un seul pôle écrase ou court-circuite les autres — que la robustesse analytique du paradigme archicratique peut se vérifier. Ce ne sont pas des anomalies anecdotiques, mais des figures structurantes de la régulation contemporaine, des formes typiques de désarticulation qui signent l’entrée dans une zone grise du politique : ni complètement illégitime, ni ouvertement dictatoriale, mais oblitérant l’opposabilité.
 
-La première configuration critique est celle de la *cratialité* orpheline, où la puissance d’agir est autonome, sans fondement clair, ni scène d’épreuve possible. On y observe des chaînes d’exécution hautement performantes — plateformes logistiques, tableaux de pilotage budgétaire, algorithmes décisionnels, procédures automatisées — qui fonctionnent sans invocation fondatrice (*arcalité*) et sans recours institué (*archicration*). La décision devient impersonnelle, inattaquable, et souvent non négociable. La puissance technique se substitue à la justification et à l’épreuve.
+La première configuration critique est celle de la cratialité orpheline, où la puissance d’agir tend à s’autonomiser sur fond d’arcalité faiblement exposable et d’archicration neutralisée, comprimée ou rendue pratiquement inopérante. On y observe des chaînes d’exécution hautement performantes — plateformes logistiques, tableaux de pilotage budgétaire, algorithmes décisionnels, procédures automatisées — qui fonctionnent avec des fondements peu explicités pour les affectés et avec des voies de reprise, de contestation ou de recours soit relocalisées hors d’atteinte, soit fictives, soit matériellement impraticables. La décision y devient impersonnelle, difficilement attaquable, et souvent non négociable dans les faits. Ce qui caractérise cette configuration n’est donc pas l’absence absolue de fondement ou de scène, mais leur dégradation opératoire : l’arcalité subsiste sous forme implicite, technique ou déléguée ; l’archicration subsiste comme possibilité affaiblie, mimée ou neutralisée ; tandis que la cratialité, elle, concentre l’effectivité.
 
 La seconde figure limite est celle de l’*arcalité* désincarnée, où les récits fondateurs subsistent — parfois en majesté — mais ne produisent plus d’effet régulateur. Constitutions vénérées, serments solennels, principes éthiques, déclarations universelles sont mobilisés dans les discours, affichés dans les chartes, mais ne traversent plus les dispositifs opératoires. Il en résulte un régime de performativité déconnectée : les institutions prétendent être fondées en droit ou en humanisme, mais leur fonctionnement réel s’émancipe totalement de ce socle. L’*arcalité* devient alors décorative, voire cyniquement instrumentalisée : c’est le cas des appels républicains dans des politiques autoritaires, des valeurs affichées dans des dispositifs inaccessibles, ou des codes d’éthique utilisés pour justifier des dispositifs de surveillance. Ce désajustement génère une forme de désorientation politique profonde, où la norme déclarée et la norme opératoire ne se rejoignent plus.
 
-La troisième pathologie est celle de l’*archicration* fictive, où des scènes de dispute sont instaurées, mais sans effectivité réelle. Le dispositif donne l’apparence d’un contradictoire — consultation publique, boîte à idées, forum participatif, convention citoyenne, droit de recours — mais en réalité, aucune des conditions de l’opposabilité n’est remplie : délais trop courts, opacité des motifs, non-publication des réponses, filtrage des revendications, absence de prise sur la décision finale. Cette forme de mise en scène procédurale produit une illusion de démocratie régulée, où la scène d’épreuve est ritualisée sans effet. L’*archicration* existe ici comme spectacle, non comme épreuve, et contribue paradoxalement à renforcer l’irréversibilité des décisions prises. C’est le cas par exemple de certaines concertations environnementales menées en urgence, où les contributions citoyennes sont enregistrées, mais sans être prises en compte ni motivées dans les décisions finales.
+La troisième pathologie est celle de l’*archicration* fictive, où des scènes de dispute sont instaurées, mais sans effectivité palpable. Le dispositif donne l’apparence d’un contradictoire — consultation publique, boîte à idées, forum participatif, convention citoyenne, droit de recours — mais en réalité, aucune des conditions de l’opposabilité n’est remplie : délais trop courts, opacité des motifs, non-publication des réponses, filtrage des revendications, absence de prise sur la décision finale. Cette forme de mise en scène procédurale produit une illusion de démocratie régulée, où la scène d’épreuve est ritualisée sans effet. L’*archicration* existe ici comme spectacle, non comme épreuve, et contribue paradoxalement à renforcer l’irréversibilité des décisions prises. C’est le cas par exemple de certaines concertations environnementales menées en urgence, où les contributions citoyennes sont enregistrées, mais sans être prises en compte ni motivées dans les décisions finales.
 
 Mais il existe aussi des cas où un seul pôle détourne ou capture les deux autres. On parlera alors de court-circuit paradigmatique, ou d’effet de surcodage. Ainsi, une cratialité surpuissante peut simuler un fondement (en produisant des justifications pseudo-techniques ou tautologiques : « c’est la procédure », « l’algorithme l’a déterminé »), tout en neutralisant la scène de l’épreuve (« ce n’est pas contestable, car c’est automatisé »). Nous nommons ce type de dérive : *régime hypercratial*.
 
@@ -274,9 +243,11 @@ Mais il existe aussi des cas où un seul pôle détourne ou capture les deux aut
 
 Enfin, une *archicration* *hypertrophiée* — une société saturée de recours, d’instances, de médiations — peut empêcher toute effectuation : c’est la régulation paralysée par la sur-opposabilité, la scène d’épreuve transformée en labyrinthe.
 
-Ces cas limites ne sont pas simplement pathologiques : ils sont heuristiquement structurants. Ils montrent comment l’équilibre entre les pôles ne relève ni d’une essence ni d’une norme, mais d’un jeu d’ajustement toujours instable, toujours à documenter. C’est dans leur désajustement que se révèlent les conditions minimales de viabilité politique d’un dispositif. Car un ordre peut survivre longtemps sans fondement (arcalité), ou sans épreuve (archicration), ou même sans action (cratialité), mais il cesse alors d’être un ordre politique habitable : il devient un régime bloqué de contrainte, de vacance ou d’impuissance.
+Ces cas limites ne sont pas simplement pathologiques : ils sont heuristiquement structurants. Ils montrent comment l’équilibre entre les pôles ne relève ni d’une essence ni d’une norme, mais d’un jeu d’ajustement toujours instable, toujours à documenter. C’est dans leur désajustement que se révèlent les conditions minimales de viabilité politique d’un dispositif. Car une formation collective peut se maintenir durablement sous déficit d’arcalité, sous atrophie de l’archicration, ou sous affaissement de la cratialité ; mais elle cesse alors d’être un ordre politique pleinement habitable. Elle persiste au prix d’une dégradation de sa co-viabilité, et tend à devenir un régime bloqué de contrainte, de vacance ou d’impuissance.
 
-Enfin, ces déséquilibres ne doivent pas être lus comme des erreurs de conception ou des dysfonctionnements ponctuels. Ils signalent souvent des régimes intentionnels de régulation, où l’absence de fondement, la fermeture de la dispute ou la saturation de l’opération sont stratégiquement construits pour éviter l’épreuve politique. C’est ici que le paradigme archicratique déploie sa force critique : en rendant visibles ces dispositifs qui, tout en étant fonctionnels, se soustraient à la critique, à la scène, à l’épreuve.
+À l’inverse, ces cas-limites valent aussi comme révélateurs d’une exigence positive : ils indiquent, par contraste, ce qu’une tenue archicratique minimale doit préserver pour qu’une régulation demeure habitable, révisable et politiquement soutenable.
+
+Enfin, ces déséquilibres ne doivent pas être lus comme des erreurs de conception ou des dysfonctionnements ponctuels. Ils signalent souvent des régimes intentionnels de régulation, où le défaut d’exposition du fondement, la neutralisation de la dispute ou la saturation de l’opération sont stratégiquement construits pour éviter l’épreuve politique. C’est ici que le paradigme archicratique déploie sa force critique : en rendant visibles ces dispositifs qui, tout en étant fonctionnels, se soustraient à la critique, à la scène, à l’épreuve.
 
 Mais d’ores et déjà, cette exploration des désajustements initiaux nous permet de poser une hypothèse structurante : une régulation devient politiquement problématique non lorsqu’un pôle manque absolument, mais lorsque ses interactions avec les autres sont rompues, perverties, neutralisées. Ce sont ces configurations, ces bifurcations, ces effets de bascule que l’analyse archicratique doit pouvoir capter, nommer, décrire et critiquer.
 
@@ -294,7 +265,7 @@ Et c’est dans cette tension — entre diagnostic et normativité, entre transv
 
 ### 1.2.1 — Régime, forme, structure : clarification des niveaux d’analyse
 
-Penser le politique suppose toujours, à un moment donné, de se situer dans une hiérarchie conceptuelle : quels sont les niveaux auxquels se déploient les régulations ? Où s’arrête la description ? Où commence la structure ? Quand l’analyse quitte-t-elle l’empirisme des formes visibles pour formuler une hypothèse sur les conditions de possibilité elles-mêmes ? Le paradigme archicratique, en tant qu’hypothèse structurante, impose de clarifier cette gradation. Car on ne peut pas l’identifier ni en mesurer la portée sans distinguer trois plans souvent confondus : le régime, la forme et la structure.
+Pour mesurer la portée du paradigme archicratique, il faut d’abord distinguer trois plans souvent confondus : le régime, la forme et la structure. Penser le politique suppose toujours, à un moment donné, de se situer dans une hiérarchie conceptuelle : à quels niveaux se déploient les régulations ? où s’arrête la description ? où commence l’hypothèse sur leurs conditions de possibilité ?
 
 Un régime, au sens classique des sciences politiques (depuis Aristote jusqu’à Linz, Sartori ou Bobbio), désigne un type de gouvernement fondé sur une certaine configuration d’institutions, de normes et de principes de légitimation. Démocratie représentative, monarchie constitutionnelle, autoritarisme plébiscitaire, théocratie — autant de régimes qui décrivent des architectures institutionnelles différenciées, avec leurs acteurs, leurs règles du jeu, leurs modes de reproduction. Le régime est donc un ensemble visible, énonçable, formalisé, que l’on peut inscrire dans une histoire constitutionnelle, dans un droit positif, dans une morphologie institutionnelle repérable.
 
@@ -302,7 +273,7 @@ La forme, en revanche, relève d’un niveau intermédiaire. Elle désigne les m
 
 Mais en-dessous de ces formes, il y a la structure régulatrice : un plan plus profond, plus transversal, plus déterminant, qui ne désigne ni les institutions ni les pratiques, mais les conditions même de possibilité de la régulation politique. Cette structure est ce qui permet — ou non — qu’un ordre se rende visible, controversable, habitable. Elle ne renvoie pas à une architecture constitutionnelle, mais à une configuration d’agencement entre ce qui fonde, ce qui opère, et ce qui permet d’en discuter. C’est là que se situe l’hypothèse archicratique : non au niveau des régimes ou des formes, mais au niveau de la structure régulatrice profonde, ce que l’on pourrait appeler, en empruntant à Lévi-Strauss ou à Althusser, un *inconscient politique de la régulation*.
 
-L’*archicratie* n’est donc pas un régime de plus. Elle n’est pas la cousine néolibérale de la démocratie, ni une dérive technocratique de l’État-nation. Elle est le nom donné à une structure de régulation sans scène instituée, sans fondement invocable, sans épreuve contradictoire formelle. Et à ce titre, elle peut traverser différents régimes, s’y superposer, y introduire des failles ou des inerties, s’y agglomérer comme un parasitage silencieux. Un régime peut être démocratique en apparence, mais archicratique dans sa structure opératoire réelle. Inversement, certaines formes autoritaires peuvent ménager des archicrations ponctuelles, permettant une conflictualité politique minimale. C’est ce qui rend l’archicratie si difficile à identifier, et si nécessaire à penser : elle ne se lit pas dans les institutions, mais dans la manière dont un ordre rend — ou non — la régulation opposable, différée, arbitrable.
+L’autarchicratie n’est donc pas un régime politique de plus. Elle n’est ni la cousine néolibérale de la démocratie, ni une simple dérive technocratique de l’État-nation. Elle désigne la dérive par laquelle des architectures régulatrices continuent d’opérer tout en se soustrayant progressivement à la scène d’épreuve : les fondements ne disparaissent pas nécessairement, mais deviennent de moins en moins susceptibles d’exposition ; les procédures contradictoires peuvent subsister, mais se vident, se simulent ou deviennent inopérantes ; et la régulation tend à se refermer sur sa propre logique d’exécution. À ce titre, l’autarchicratie peut traverser différents régimes politiques, s’y superposer, y introduire des inerties, des fermetures ou des parasitages silencieux. Un régime peut ainsi être démocratique en apparence, tout en dérivant vers une structure opératoire autarchicratique. Inversement, certaines formes autoritaires peuvent encore ménager des archicrations ponctuelles, permettant le maintien d’une conflictualité politique minimale. C’est ce qui rend l’autarchicratie difficile à identifier, et pourtant nécessaire à penser : elle ne se lit pas seulement dans les institutions, mais dans la manière dont un ordre rend — ou non — sa régulation exposable, opposable, différable et révisable.
 
 Cette distinction entre régime, forme, et structure n’est pas simplement académique. Elle est politiquement décisive. Car c’est elle qui permet d’éviter deux écueils fréquents : le fétichisme institutionnel (croire qu’un régime démocratique suffit à garantir une régulation juste), et le scepticisme cynique (penser que toute régulation est toujours déjà close, dominée, irréformable). L’*archicratie* introduit un plan d’analyse transversal, qui oblige à questionner non ce que les institutions prétendent, mais ce qu’elles permettent réellement en termes de fondement, d’opération, et de dispute. Elle ouvre une lecture différentielle du politique, fondée non sur l’étiquette (démocratie ou non), mais sur la qualité régulatrice de l’ordre.
 
@@ -310,34 +281,36 @@ En clarifiant ce niveau d’analyse, on peut désormais définir l’*archicrati
 
 ### 1.2.2 — L’archicratie comme méta-régime transversal de la régulation
 
-Comme nous l’avons étayé l’*archicratie* n’est pas un type de régime politique au sens classique du terme. Elle n’est ni une démocratie, ni une autocratie, ni une technocratie, ni une bureaucratie au sens formel. Elle n’est pas définie par un mode d’accès au pouvoir, une forme de représentation, ou une structure constitutionnelle donnée. Elle ne se substitue pas aux régimes : elle les traverse, les parasite, les reconfigure, les dilue ou les redouble. Ce que le paradigme archicratique propose, ce n’est donc pas d’ajouter une étiquette à la typologie déjà saturée des formes politiques, mais de formuler une hypothèse forte sur la structure profonde qui rend possible — ou impossible — la régulation politique dans ses dimensions fondamentales.
+Comme nous l’avons établi, l’archicratie n’est pas un type de régime politique au sens classique du terme. Elle n’est ni une démocratie, ni une autocratie, ni une technocratie, ni une bureaucratie au sens formel. Elle n’est pas définie par un mode d’accès au pouvoir, une forme de représentation, ou une structure constitutionnelle donnée. Elle ne se substitue pas aux régimes : elle les traverse, les reconfigure, parfois les parasite ou les redouble. Ce que le paradigme archicratique propose, ce n’est donc pas d’ajouter une étiquette à la typologie déjà saturée des formes politiques, mais de formuler une hypothèse forte sur la structure profonde qui rend possible — ou impossible — la régulation politique dans ses dimensions fondamentales.
 
 C’est en ce sens que nous définissons l’*archicratie comme un méta-régime de régulation*.
 
-Un méta-régime n’est pas une catégorie de surface. Il ne désigne pas un type d’organisation institutionnelle, ni même un modèle de gouvernement parmi d’autres. Il opère à un niveau plus profond : celui des conditions de possibilité de la régulation, celui de l’articulation — ou de la disjonction — entre les trois dimensions constitutives que nous avons décrites : l’*arcalité* (fondement), la *cratialité* (opération), et l’*archicration* (épreuve). Là où les régimes désignent des structures politiques historiquement repérables, le méta-régime désigne la manière dont ces structures rendent (ou non) leurs propres régulations visibles, discutables, contestables et révisables.
+Un méta-régime n’est pas une catégorie de surface. Il ne désigne pas un type d’organisation institutionnelle, ni même un modèle de gouvernement parmi d’autres. Il opère à un niveau plus profond : celui des conditions de possibilité de la régulation, celui de l’articulation — ou de la disjonction — entre les trois dimensions constitutives que nous avons décrites : l’*arcalité* (fondement), la *cratialité* (opération), et l’*archicration* (épreuve). Là où les régimes désignent des structures politiques historiquement repérables, le méta-régime désigne la manière dont ces structures rendent (ou non) leurs propres régulations exposables à la contradiction, à la reprise et à la révision.
 
-Dit autrement, un *méta-régime* n’est pas une forme politique particulière, mais un rapport entre les formes, un *agencement systémique entre ce qui fonde, ce qui opère, et ce qui rend opposable*. Il ne se lit pas dans les discours publics, ni même dans les textes constitutionnels : il se repère dans la cohérence (ou l’incohérence) d’un dispositif de régulation. Ce que propose le paradigme archicratique, c’est donc une grille d’intelligibilité transversale : un outil analytique permettant de diagnostiquer des états de régulation dans toute configuration politique donnée, en interrogeant non pas leur légalité ou leur conformité, mais leur tenue archicrative effective.
+Dit autrement, un *méta-régime* n’est pas une forme politique particulière, mais un rapport entre les formes, un *agencement systémique entre ce qui fonde, ce qui opère, et ce qui rend opposable*. Il ne se lit pas dans les discours publics, ni même dans les textes constitutionnels : il se repère dans la cohérence (ou l’incohérence) d’un dispositif de régulation. Ce que propose le paradigme archicratique, c’est donc un analyseur transversal des états de régulation dans toute configuration politique donnée, en interrogeant non pas leur légalité ou leur conformité, mais leur tenue archicrative effective.
 
 Cette grille permet par exemple de comparer un dispositif d’allocation d’aides sociales dans une démocratie représentative, un protocole sanitaire dans une dictature *soft*, ou un mécanisme d’ajustement budgétaire dans une structure supra-étatique. Ce qui compte, ce n’est pas l’étiquette politique du régime, mais la qualité de sa régulation au regard des trois critères fondamentaux : le fondement mobilisé (*arcalité*), les moyens d’effectuation (*cratialité*), et les possibilités instituées de contestation (*archicration*). L’*archicratie* devient ainsi un analyseur paradigmatique, c’est-à-dire une manière de lire des dispositifs en détectant ce qui s’y fonde, ce qui y opère, et ce qui s’y dispute — ou non.
 
-Cette approche n’est pas purement descriptive. Elle est diagnostique, critique, opposable. Elle permet de dire : « ici, l’ordre régulateur semble robuste, mais il est archicratique en ce sens qu’il est devenu indisputable » ; ou bien : « ce dispositif mobilise un fondement fort, mais il est cratialisé sans contrôle, et sans scène de recours ». En ce sens, l’*archicratie* n’est pas un concept mollement critique : elle est une épreuve conceptuelle pour les régimes existants, un test de viabilité démocratique ou politique, une mise à nu des écarts entre l’invocation des principes et la structure réelle de la régulation.
+Cette approche n’est pas purement descriptive. Elle est diagnostique, critique, opposable. Elle permet de dire : « ici, l’ordre régulateur semble robuste, mais il fonctionne désormais sur un mode autarchicratique, en ce qu’il devient indisputable » ; ou bien : « ce dispositif mobilise un fondement fort, mais sa cratialité se déploie avec un contrôle affaibli et une scène de recours neutralisée, comprimée ou rendue pratiquement inopérante ». En ce sens, l’archicratie n’est pas un concept mollement critique : elle est une épreuve conceptuelle pour les régimes existants, un test de viabilité politique, une mise à nu des écarts entre l’invocation des principes et la structure réelle de la régulation.
 
 Mais surtout, cette conceptualisation du *méta-régime archicratique* permet de dépasser deux impasses majeures des théories politiques classiques. La première, *normative*, qui suppose qu’un régime est légitime parce qu’il respecte formellement certaines règles (élections, séparation des pouvoirs, État de droit). Or, ces règles peuvent subsister tandis que la régulation réelle devient opaque, automatique ou imperméable à la contestation.
 
 La seconde, que nous nommons *contextualisée*, qui affirme que chaque régime porte sa cohérence interne, ses normes propres, son rythme historique. Certes. Mais le paradigme archicratique montre que certaines tensions traversent tous les régimes : celle entre ce qui fonde, ce qui opère, et ce qui conteste. Et que c’est dans cette tension que se joue la co-viabilité politique réelle d’un ordre.
 
-En ce sens, on peut dire que le paradigme archicratique relève d’une démarche post-weberienne : il ne cherche pas à classer les régimes d’autorité selon des types idéaux de légitimation (traditionnelle, charismatique, légale-rationnelle), mais à analyser les conditions concrètes de l’opposabilité des régulations, indépendamment de leurs formes déclarées. Il reformule la question du pouvoir non en termes de commandement, mais en termes de co-présence entre les dimensions de fondation, d’effectuation, et de mise en épreuve.
+En ce sens, on peut dire que le paradigme archicratique relève d’une démarche post-wébérienne : il ne cherche pas à classer les régimes d’autorité selon des types idéaux de légitimation (traditionnelle, charismatique, légale-rationnelle), mais à analyser les conditions concrètes de l’opposabilité des régulations, indépendamment de leurs formes déclarées. Il reformule la question du pouvoir non en termes de commandement, mais en termes de co-présence entre les dimensions de fondation, d’effectuation, et de mise en épreuve.
 
 C’est cette transversalité — au-delà des régimes, des époques, des configurations — qui fonde l’*archicratie* comme méta-régime analytique. Elle ne se substitue pas aux typologies existantes, mais les traverse. Elle n’invalide pas les concepts de démocratie, d’État, de représentation, mais les reconfigure en introduisant une dimension de *régulation par tensions de co-viabilité*.
 
-Pour cette raison, l’archicratie peut être mobilisée à la fois comme hypothèse heuristique, comme outil critique, et comme grille de diagnostic différentiel. Elle ne prétend pas tout expliquer, mais elle permet de poser cette question décisive : *dans un régime donné, qui peut invoquer quoi ? Qui peut agir sur quoi ? Qui peut contester quoi ? Et selon quelles formes, sous quels délais, avec quelle effectivité ?*
+Pour cette raison, l’archicratie peut être mobilisée à la fois comme hypothèse heuristique, comme outil critique, et comme cadre de diagnostic différentiel. Elle ne prétend pas tout expliquer, mais elle permet de poser cette question décisive : *dans un régime donné, qui peut invoquer quoi ? Qui peut agir sur quoi ? Qui peut contester quoi ? Et selon quelles formes, sous quels délais, avec quelle effectivité ?*
 
 Autrement dit : le pouvoir régule — *mais est-il régulé ?*  
-Et si, non : *où est passée la scène ?*
+Et, si ce n’est pas le cas, où est passée la scène ?
+
+Inversement, lorsqu’une scène tient encore, même localement, est-ce elle qui rend de nouveau possible la suspension, la comparution et la requalification des prises régulatrices.
 
 ### 1.2.3 — Les critères de validité paradigmatique : fécondité, puissance et opposabilité
 
-Ce qui rend un paradigme légitime, c’est sa capacité à soutenir la pensée, à générer de nouvelles distinctions, à organiser l’intelligibilité du réel, mais surtout à s’exposer à l’épreuve, c’est-à-dire à la mise en tension critique, à la validation empirique, à la falsifiabilité théorique et à la réversibilité herméneutique. À cette aune, le paradigme archicratique ne saurait se contenter d’être une intuition éclairante ou une métaphore suggestive ; il doit se doter d’un ensemble de critères de validité, rigoureusement définis, qui justifient son usage comme instrument analytique, son efficience comme outil heuristique, et sa robustesse comme cadre de pensée politique. Un paradigme sert à rendre visible ce qui était jusqu’alors obscurci, dispersé, méconnu ou neutralisé.
+Ce qui rend un paradigme légitime, c’est sa capacité à soutenir la pensée, à générer de nouvelles distinctions, à organiser l’intelligibilité du réel, mais surtout à s’exposer à l’épreuve, c’est-à-dire à la mise à l’épreuve contradictoire, à la validation empirique, à la falsifiabilité théorique et à la réversibilité herméneutique. À cette aune, le paradigme archicratique ne saurait se contenter d’être une intuition éclairante ou une métaphore suggestive ; il doit se doter d’un ensemble de critères de validité, précisément définis, qui justifient son usage comme instrument analytique, son efficience comme outil heuristique, et sa robustesse comme cadre de pensée politique. Un paradigme sert à rendre visible ce qui était jusqu’alors obscurci, dispersé, méconnu ou neutralisé.
 
 Trois conditions principales structurent cette exigence de validité : la fécondité analytique, la puissance explicative, et surtout l’opposabilité empirique — cette dernière constituant le seuil le plus élevé de toute ambition théorique sérieuse. En cela, la validité paradigmatique ne relève ni du consensus idéologique, ni de la cohérence formelle interne : elle engage une éthique épistémique, un devoir de rigueur, un engagement de réfutabilité qui doit orienter l’ensemble de notre construction.
 
@@ -353,7 +326,7 @@ Il devient ainsi possible, grâce à cette grille tripolaire, de qualifier des r
 
 Mais encore faut-il que le paradigme soit explicatif, c’est-à-dire capable de rapprocher des phénomènes épars, de construire des séries intelligibles, de réduire la contingence apparente à des configurations discernables. Là encore, le paradigme archicratique s’impose par sa puissance intégratrice : il permet d’embrasser dans une même grille d’analyse des réalités qui, jusque-là, semblaient hétérogènes — parce que dispersées dans des domaines sectoriels (fiscalité, santé, climat, numérique, sécurité), ou parce qu’enveloppées dans des langages spécialisés (juridique, économique, algorithmique).
 
-C’est précisément cette capacité à unifier sans uniformiser, à articuler sans réduire, qui signe la force d’un paradigme. En *archicratie*, des phénomènes aussi variés que — la gouvernance sanitaire par indicateurs ; la régulation budgétaire par règles automatiques ; la gestion algorithmique des droits sociaux ; l’application de standards techniques globaux sans débat local ; ou encore la prolifération des plateformes numériques de notification unilatérale — peuvent être reliés, compris, comparés à l’aune d’une même question : *cette régulation est-elle fondée, opérante et opposable ?* Si l’un de ces trois pôles fait défaut, la régulation devient fragile, injustifiable ou autoritaire. Ainsi, ce que le paradigme archicratique rend possible, c’est une lecture transversale, critique, intersectorielle du politique contemporain — non plus à partir des formes visibles de pouvoir, mais à partir de ses pratiques effectives de régulation, de ses vecteurs techniques, et de ses seuils de dispute.
+C’est précisément cette capacité à unifier sans uniformiser, à articuler sans réduire, qui signe la force d’un paradigme. En *archicratie*, des phénomènes aussi variés que — la gouvernance sanitaire par indicateurs ; la régulation budgétaire par règles automatiques ; la gestion algorithmique des droits sociaux ; l’application de standards techniques globaux sans discussion locale ; ou encore la prolifération des plateformes numériques de notification unilatérale — peuvent être reliés, compris, comparés à l’aune d’une même question : *cette régulation est-elle fondée, opérante et opposable ?* Si l’un de ces trois pôles fait défaut, la régulation devient fragile, injustifiable ou autoritaire. Ainsi, ce que le paradigme archicratique rend possible, c’est une lecture transversale, critique, intersectorielle du politique contemporain — non plus à partir des formes visibles de pouvoir, mais à partir de ses pratiques effectives de régulation, de ses vecteurs techniques, et de ses seuils de dispute.
 
 #### Une opposabilité empirique : falsifiabilité, indicateurs et critères de lecture
 
@@ -369,13 +342,13 @@ Ces critères sont au nombre de quatre, que nous avons déjà évoqués en filig
 
 - La *possibilité de recours effectif* : une norme est politique si elle peut être contestée dans un délai raisonnable, devant une instance compétente, selon une procédure intelligible et des modalités non excluantes. Le formalisme du recours ne suffit pas ; c’est sa praticabilité qui importe.
 
-Ces quatre indicateurs peuvent être mesurés, étayés et comparés. Ils permettent d’objectiver le diagnostic archicratique, d’en délivrer une cartographie différenciée, et d’en circonscrire les seuils. Ils rendent la critique opératoire et la théorie falsifiable. Car il est tout à fait possible qu’un dispositif tienne sans scène, sans délai, sans recours, sans fondement clair — dans ce cas, notre paradigme devra s’avouer inopérant. C’est précisément cette possibilité qui fonde sa valeur scientifique.
+Ces quatre indicateurs peuvent être mesurés, étayés et comparés. Ils permettent d’objectiver le diagnostic archicratique, d’en délivrer une cartographie différenciée, et d’en circonscrire les seuils. Ils rendent la critique opératoire et la théorie falsifiable. Car il est tout à fait possible qu’un dispositif tienne avec une scène neutralisée ou relocalisée hors d’atteinte, avec des délais fictifs ou comprimés, avec des recours formellement ouverts mais pratiquement impraticables, avec des fondements difficiles à exposer ou à opposer. Dans ce cas, notre paradigme n’a pas à s’avouer inopérant : il doit précisément décrire, qualifier et mesurer cette neutralisation, cette compression, cette inopérance ou cette opacification. C’est précisément cette possibilité qui fonde sa valeur scientifique.
 
-Par ailleurs, ce paradigme pourra être confronté à des contre-exemples méthodiques — ce que nous ferons dans la section 1.10 — afin de tester la puissance de sa réfutabilité. Il ne s’agit pas de tout faire entrer dans le moule archicratique, mais de tester la pertinence du moule face à des réalités rétives, résistantes, voire incompatibles. C’est cela, l’esprit de la critique : ne pas chercher la confirmation, mais la disjonction révélatrice.
+Par ailleurs, ce paradigme pourra être confronté à des contre-exemples méthodiques — ce qui devra être éprouvé dans les usages empiriques ultérieurs du paradigme — afin de tester la puissance de sa réfutabilité. Il ne s’agit pas de tout faire entrer dans le moule archicratique, mais de tester la pertinence du moule face à des réalités rétives, résistantes, voire incompatibles. C’est cela, l’esprit de la critique : ne pas chercher la confirmation, mais la disjonction révélatrice.
 
-En définitive, le paradigme archicratique ne vaut que par sa capacité à rendre visible ce qui opère sans justification, à déplier ce qui agit sans être discuté, à donner langue à ce qui neutralise le contradictoire. Il ne se présente pas comme une nouvelle théorie normative, ni comme un surplomb idéologique, mais comme une grille de détection des régulations silencieuses — celles qui se passent de scène, de délai, de motifs, de recours, et qui, de ce fait, court-circuitent la possibilité même du politique.
+En définitive, le paradigme archicratique ne vaut que par sa capacité à élucider ce qui opère à travers des justifications faiblement exposables, à déplier ce qui agit à travers des scènes comprimées, mimées ou relocalisées, à donner langue à ce qui neutralise le contradictoire sans jamais l’abolir purement et simplement. Il ne se présente pas comme une nouvelle théorie normative, ni comme un surplomb idéologique, mais comme un opérateur de détection des régulations silencieuses — celles où la scène se vide, où les délais deviennent fictifs, où les motifs deviennent inopposables, où les recours cessent d’être pratiquement saisissables, et qui, de ce fait, court-circuitent la possibilité même du politique.
 
-En ce sens, il est un paradigme à la fois critique et méthodique : critique, car il met à nu les absences, les évasions, les courts-circuits ; méthodique, puisqu’il les mesure, les nomme, les cartographie, et les expose à l’épreuve. Ce n’est qu’à cette double condition — fécondité analytique et opposabilité empirique — que le paradigme archicratique pourra prétendre à une légitimité scientifique, académique et politique. Et c’est sur cette base, et cette base seulement, qu’il pourra accompagner l’effort critique contemporain pour penser ce qui régule sans qu’on le voie, ce qui gouverne sans qu’on le dise, ce qui décide sans qu’on puisse le conteste.
+En ce sens, il est un paradigme à la fois critique et méthodique : critique, car il met à nu les neutralisations, les évasions, les courts-circuits ; méthodique, puisqu’il les mesure, les nomme, les cartographie, et les expose à l’épreuve. Ce n’est qu’à cette double condition — fécondité analytique et opposabilité empirique — que le paradigme archicratique pourra prétendre à une légitimité scientifique, académique et politique.
 
 ## **1.3 —** Les axiomes régulateurs du paradigme archicratique
 
@@ -383,7 +356,7 @@ La construction conceptuelle que nous avons amorcée ne pourra véritablement ê
 
 Ce que nous proposons ici n’est donc pas une compilation de principes abstraits ou de normes morales : il s’agit d’une *charte de validité*. Les axiomes qui suivent assurent la cohérence interne de la proposition archicratique. Ils ne valent pas comme protocole d’évaluation ni comme grille de classement. Ils orientent la lecture conceptuelle des cas, sans prétendre à une mesure. Ces axiomes ont principalement une triple fonction.
 
-D’abord, ils stabilisent le cadre : ils garantissent que le paradigme archicratique ne dérive pas en inflation métaphorique, ni en concept de substitution. Ensuite, ils rendent le paradigme opératoire : en définissant les conditions de son application, ils permettent une lecture outillée et rigoureuse des régulations réelles. Enfin, ils l’exposent à la critique : chacun de ces axiomes peut être discuté, révoqué, confronté, ce qui constitue l’indice de leur légitimité et non de leur fragilité.
+D’abord, ils stabilisent le cadre : ils garantissent que le paradigme archicratique ne dérive pas en inflation métaphorique, ni en concept de substitution. Ensuite, ils en rendent possible la mise en œuvre analytique : en définissant les conditions de son application, ils permettent une lecture outillée et rigoureuse des régulations réelles. Enfin, ils l’exposent à la critique : chacun de ces axiomes peut être discuté, révoqué, confronté, ce qui constitue l’indice de leur légitimité et non de leur fragilité.
 
 Il faut ici rappeler les grandes exigences posées par les théoriciens de la science : Karl Popper (1934) insistait sur la falsifiabilité comme critère de démarcation entre science et idéologie ; Imre Lakatos (1978) montrait que tout programme de recherche scientifique devait contenir un noyau dur protégé par un ensemble de conditions négociables — c’est-à-dire une structure qui permet à la fois la stabilité théorique et l’ouverture à la révision. À leur suite, mais dans un champ spécifique — celui de la philosophie politique — nous affirmons qu’un paradigme doit se rendre intelligible par sa propre explicitation méthodique, sous peine de sombrer dans la circularité ou dans le fétichisme terminologique.
 
@@ -401,7 +374,9 @@ Ce premier axiome constitue le socle ontologique minimal du paradigme archicrati
 
 Poser cet axiome, c’est affirmer que ces trois dimensions — même lorsqu’elles sont invisibles, réduites, capturées ou en dormance — sont toujours présentes, repérables, détectables, au moins de façon latente ou implicite. Autrement dit, on ne peut pas penser une régulation sans ce tripode, même si celui-ci est déséquilibré, distordu ou saboté. Un dispositif qui n’aurait ni *arcalité* (aucun principe fondateur ou récit de justification), ni *cratialité* (aucune opération effective, aucun vecteur d’action), ni *archicration* (aucun lieu ou possibilité de contestation ou de révision), ne serait pas un dispositif régulateur : ce serait un chaos, une contingence brute, un pur hasard ou un agrégat sans structure.
 
-Ce que cet axiome implique immédiatement, c’est un changement de regard épistémique. Il ne suffit pas de repérer les structures visibles du pouvoir (institutions, lois, autorités) : il faut traquer les trois prises constitutives dans tout agencement régulateur — y compris ceux qui prétendent ne pas être politiques, comme par exemple, les régulations algorithmiques, les logiques d’attribution budgétaire, les procédures hospitalières, les normes de conformité technique. Même là, il y a fondement, opération, et possibilité de contestation — et, au pire, leur mise en invisibilité stratégique. De sorte que ce n’est pas parce que l’*arcalité* est devenue silencieuse (par exemple : une légitimation implicite par la science ou par la nécessité technique), ni parce que l’*archicration* est éteinte (absence de scène de recours), que ces dimensions sont absentes : elles sont alors refoulées, verrouillées, court-circuitées — mais leur absence relative est elle-même un indice paradigmatique.
+Ce que cet axiome implique immédiatement, c’est un changement de regard épistémique. Il ne suffit pas de repérer les structures visibles du pouvoir (institutions, lois, autorités) : il faut traquer les trois prises constitutives dans tout agencement régulateur — y compris ceux qui prétendent ne pas être politiques, comme par exemple, les régulations algorithmiques, les logiques d’attribution budgétaire, les procédures hospitalières, les normes de conformité technique. Même là, il y a fondement, opération, et possibilité de contestation — et, au pire, leur mise en invisibilité stratégique. De sorte que ce n’est pas parce que l’*arcalité* est devenue silencieuse (par exemple : une légitimation implicite par la science ou par la nécessité technique), ni parce que l’*archicration* est neutralisée, verrouillée, relocalisée hors d’atteinte ou rendue pratiquement inopérante (absence de scène de recours), que ces dimensions sont absentes : elles sont alors refoulées, verrouillées, court-circuitées — mais leur absence relative est elle-même un indice paradigmatique.
+
+Toute régulation effective comporte, en acte ou en puissance, une arcalité, une cratialité et une archicration ; les pathologies contemporaines n’abolissent pas cette tripolarité, mais en opacifient les fondements, en autonomisent les opérations et en neutralisent, miment ou relocalisent la scène d’épreuve, jusqu’à la dérive autarchicratique.
 
 L’*axiome de coprésence* a donc une valeur heuristique fondamentale. Il permet de penser les situations où une régulation semble purement technique ou exclusivement administrative (*cratialité*) comme étant toujours aussi fondée dans un imaginaire (*arcalité*) et exposée ou soustraite à une épreuve (*archicration*). Il impose ainsi une lecture structurale de tout dispositif, qu’il soit juridique, logistique, algorithmique, sanitaire, éducatif, écologique ou financier. C’est une invitation à lire dans la matière du monde les tripodes de la régulation.
 
@@ -477,7 +452,7 @@ Dans la section 1.4, nous déploierons une cartographie systémique de ces objet
 
 Cet axiome tire toutes les conséquences analytiques et politiques de ce que nous avons établi comme architecture fondatrice du paradigme archicratique : la régulation politique ne repose pas sur un centre unique d’autorité, ni sur une mécanique univoque d’exécution, ni sur une utopie dialogique sans ancrage. Elle repose sur une tenue dynamique entre trois fonctions irréductibles : fonder, opérer, disputer.
 
-Mais plus encore que leur distinction, c’est leur non-substituabilité qui constitue le cœur de l’axiome ici énoncé. Ce que nous affirmons, c’est que chacun des trois pôles est nécessaire, mais aucun n’est suffisant. Pris isolément, chacun génère une forme de déséquilibre radical, une défaillance politique, un court-circuit de la régulation. Le paradigme archicratique, dès lors, ne repose pas sur une addition bien plus sur une *disjonction fonctionnelle stricte* : les trois fonctions doivent être tenues ensemble, sans qu’aucune ne puisse se substituer aux deux autres.
+Mais plus encore que leur distinction, c’est leur non-substituabilité qui constitue le cœur de l’axiome ici énoncé. Ce que nous affirmons, c’est que chacun des trois pôles est nécessaire, mais aucun n’est suffisant. Pris isolément, chacun génère une forme de déséquilibre radical, une défaillance politique, un court-circuit de la régulation. Le paradigme archicratique, dès lors, ne repose pas sur une simple addition, mais bien sur une disjonction fonctionnelle stricte : les trois fonctions doivent être tenues ensemble, sans qu’aucune ne puisse se substituer aux deux autres.
 
 Ce principe a une portée théorique majeure. Il interdit toute régression vers une ontologie mono-polaire du politique. Il récuse les réductions trop souvent opérées dans l’analyse des dispositifs. Lorsque le politique est saisi uniquement comme fondement, valeur, idéal ou texte, la régulation devient pur symbolisme. C’est le règne du mythe ou du droit sans effets. Les chartes sont proclamées, mais rien ne les rend opératoires. La Constitution devient un fétiche ; la norme, un leurre. Cette sur-arcalisation engendre des régimes rhétoriques, où le fondement reste sans effet.
 
@@ -487,9 +462,9 @@ Autre réduction, lorsque tout est renvoyé à la dispute, à la consultation,
 
 L’histoire politique moderne offre de nombreux exemples de ces régimes déséquilibrés : républiques fondées sur des textes constitutionnels irréprochables, mais pratiquement inopérantes ; dictatures fonctionnelles et performantes bien que sans légitimité ni controverse possible ; démocraties dites « délibératives » paralysées par l’inflation des consultations sans pouvoir réel. Chaque fois qu’un pôle tend à se substituer aux deux autres, la régulation se dégrade — soit en simulacre, soit en oppression, soit en chaos.
 
-Ce que l’a*xiome de disjonction fonctionnelle* impose, c’est une lecture différentielle, exigeante, des configurations régulatrices. Il oblige à penser non seulement la présence des trois pôles, mais surtout leur non-confusion. Il n’est pas rare, en effet, que des dispositifs affichent un fondement alors qu’il ne s’agit que d’un effet de langage cratial ; qu’ils prétendent à la dispute alors qu’ils ne permettent aucun recours réel ; qu’ils opèrent à vide sans principe ni scène. L’*archicratie* elle-même, dans ses formes les plus avancées, mime les trois pôles tout en les court-circuitant — comme le montrent certaines plateformes de participation citoyenne entièrement encadrées par des algorithmes de tri et d’euphémisation, dites de modération.
+Ce que l’axiome de disjonction fonctionnelle impose, c’est une lecture différentielle, exigeante, des configurations régulatrices. Il oblige à penser non seulement la présence des trois pôles, mais surtout leur non-confusion. Il n’est pas rare, en effet, que des dispositifs affichent un fondement alors qu’il ne s’agit que d’un effet de langage cratial ; qu’ils prétendent à la dispute alors qu’ils ne permettent aucun recours réel ; qu’ils opèrent à vide sans principe exposable ni scène praticable. Ce ne sont pas là des formes accomplies de l’archicratie, mais des configurations autarchicratiques ou archicratistiques dans lesquelles les trois pôles sont mimés, exhibés ou stylisés tout en étant partiellement court-circuités — comme le montrent certaines plateformes de participation citoyenne entièrement encadrées par des algorithmes de tri, de hiérarchisation ou d’euphémisation.
 
-Autrement dit, ce que l’on croit parfois être une régulation équilibrée peut en réalité relever d’un effondrement fonctionnel déguisé, d’une substitution abusive, d’une délégation simulée. L’*axiome de disjonction fonctionnelle* agit alors comme outil de discernement critique : il permet de tester si un dispositif tient ensemble les trois fonctions, ou s’il glisse vers un monolithe politique — source de désajustement systémique.
+Autrement dit, ce que l’on croit parfois être une régulation équilibrée peut en réalité relever d’un effondrement fonctionnel déguisé, d’une substitution abusive, d’une délégation simulée. L’axiome de disjonction fonctionnelle (1.3.4) vient ensuite avertir que l’effacement, la neutralisation ou l’hypertrophie d’un seul pôle conduit nécessairement à une régulation pathologique. De sorte qu’un ordre privé de fondement exposable, de scène d’épreuve praticable ou de capacité opératoire effective n’est ni pleinement viable, ni légitime, ni habitable.
 
 Mais cet axiome a aussi une portée épistémologique et méthodologique. Il oblige l’analyste à disjoindre ce que la régulation tend à confondre. Il impose de ne pas se satisfaire d’un indicateur unique ou d’une déclaration de principe. Il exige de chercher, pour chaque dispositif : *Quelle est la source réelle de l’arcalité invoquée ? Quelle est la structure effective de la cratialité mobilisée ? Quelle est la scène concrète d’archicration instituée ?*
 
@@ -551,7 +526,7 @@ Cet axiome fonde également la dimension anti-dogmatique du paradigme archicrati
 
 **Tout paradigme qui prétend décrire les régulations politiques doit rendre possible sa propre mise à l’épreuve. Il doit produire des instruments de falsifiabilité, de critique interne et de différenciation analytique. Un paradigme non falsifiable est un dogme ; un cadre non différenciateur est un slogan.**
 
-Une régulation n’est réputée archicratique qu’à la condition d’instituer une scène contradictoire où les prétentions arcale et cratiale peuvent être opposées, arbitrées et révisées selon des procédures publiques et des indicateurs déclarés.
+Une régulation n’est réputée pleinement archicratique qu’à la condition de rendre possible une scène d’épreuve où les prétentions arcale et cratiale puissent être opposées, arbitrées et révisées selon des formes de contestation effectives, lesquelles peuvent être publiques, instituées, rituelles, situées ou faiblement codifiées, pourvu qu’elles soient praticables, opposables et capables d’infléchir la régulation.
 
 Il est une exigence trop oubliée des sciences sociales : un paradigme critique n’est pas une grille qui se plaque partout, mais une matrice qui se teste, qui s’affine, qui peut échouer. Toute proposition théorique sur le pouvoir, la régulation, l’opposabilité doit se soumettre à une exigence que Karl Popper formulait dès 1934 : la condition de scientificité minimale d’un énoncé est sa capacité à être réfuté. Autrement dit, un paradigme qui s’applique partout, tout le temps, sans jamais rencontrer de cas-limite, ne serait pas robuste : il serait vide.
 
@@ -573,7 +548,7 @@ Ce que cet axiome protège, en somme, c’est la vitalité épistémique du para
 
 **Un paradigme n’est valable que s’il résiste à l’épreuve des régimes. Un outil d’analyse n’est robuste que s’il traverse les configurations hétérogènes — monarchies, démocraties, technocraties, gouvernances hybrides — sans s’effondrer dans la généralité vide ou la contradiction interne. Le paradigme archicratique doit démontrer sa capacité d’opérabilité transversale : il doit s’appliquer à la diversité des dispositifs politiques sans renoncer à sa grammaire.**
 
-L’*archicratie* n’est pas une forme de régime politique — elle n’est pas un type au sens de la typologie wébérienne (monarchie, démocratie, autoritarisme). Elle ne désigne ni une structure institutionnelle, ni une idéologie, ni une culture politique. Elle est une modalité de régulation, un style d’agencement entre trois pôles — *arcalité, cratialité, archicration* — qui peut être observé à travers une variété de formes politiques. Ce que cet axiome affirme, c’est que le paradigme archicratique doit pouvoir être mobilisé comme méta-régimes de régulation :
+L’*archicratie* n’est pas une forme de régime politique — elle n’est pas un type au sens de la typologie wébérienne (monarchie, démocratie, autoritarisme). Elle ne désigne ni une structure institutionnelle, ni une idéologie, ni une culture politique. Elle est une modalité de régulation, un style d’agencement entre trois pôles — *arcalité, cratialité, archicration* — qui peut être observé à travers une variété de formes politiques. Ce que cet axiome affirme, c’est que le paradigme archicratique doit pouvoir être mobilisé comme méta-régime de régulation :
 
 - dans des régimes démocratiques libéraux (ex. UE, États-Unis) : où l’*arcalité* est pluraliste, la *cratialité* technicisée, et l’*archicration* souvent mimée ou saturée ;
 
@@ -614,7 +589,7 @@ L’*axiome de coprésence* (1.3.1) rappelle que tout dispositif de régulation,
 
 L’*axiome de détectabilité* (1.3.3) pose que chaque pôle laisse des traces situées : visibles ou occultées, explicites ou latentes, mais toujours repérables dans des objets, des pratiques, des structures ou des langages. C’est cet ancrage dans des matérialités documentaires qui permet de différencier l’analyse archicratique de toute spéculation sans prise sur le réel.
 
-L’*axiome de disjonction fonctionnelle* (1.3.4) vient ensuite avertir que l’absence ou l’hypertrophie d’un seul pôle conduit nécessairement à une régulation pathologique. De sorte qu’un ordre sans fondement, sans régulation ou sans opération n’est ni viable, ni légitime, ni habitable.
+L’axiome de disjonction fonctionnelle (1.3.4) vient ensuite avertir que la neutralisation, la mise en latence ou l’hypertrophie d’un seul pôle conduit nécessairement à une régulation pathologique. De sorte qu’un ordre privé de fondement exposable, de scène d’épreuve praticable ou de capacité opératoire effective n’est ni viable, ni légitime, ni habitable.
 
 Les axiomes suivants assurent la robustesse transversale du paradigme. L’*axiome de variabilité différentielle* (1.3.5) affirme que les formes prises par les trois pôles sont historiquement, culturellement, politiquement, technologiquement variables — sans que cela invalide leur structure minimale. L’*axiome d’incomplétude systémique* (1.3.6), quant à lui, soutient qu’aucune régulation n’est jamais entièrement close sur elle-même : il y a toujours un reste, un vide, un point de fuite, une indétermination — condition de la critique comme de l’invention.
 
@@ -626,7 +601,7 @@ Ces huit axiomes dessinent ensemble une épistémologie forte, souple, rigoureus
 
 En cela, cette section s’est attelée à instituer une discipline de pensée. Bien plus encore, une exigence de probité intellectuelle qui sera maintenue dans les sections suivantes : qu’il s’agisse d’explorer la topologie interne/externe des pôles (section 1.4), de qualifier les formes dynamiques de tenues archicratiques (section 1.5), de présenter des repères de l’archicratie (section 1.6), ou d’en cartographier les morphologies opérantes (sections 1.7), c’est toujours à l’aune de ces axiomes que nos propositions devront être jugées.
 
-Ce chapitre ne vise pas à fonder un dogme, mais à instituer un outil. Et tout outil digne de ce nom devait commencer par l’exposé rigoureux de ses conditions de validité.
+Ces huit axiomes fixent la discipline de pensée du paradigme archicratique. C’est à leur lumière qu’il faut désormais lire sa grammaire topologique, ses formes dynamiques, ses repères heuristiques et ses morphologies opérantes.
 
 ## **1.4 —** La grammaire topologique interne/externe de l’*archicratie*
 
@@ -642,7 +617,7 @@ Pour comprendre cette architecture mouvante, nous devons prendre appui sur trois
 
 À partir de cette triple assise théorique, nous pouvons affirmer que la grammaire topologique constitue le pivot méthodologique du paradigme archicratique. Elle permet d’analyser chaque pôle de la régulation — *arcalité, cratialité, archicration* — comme une structure positionnelle, où l’interne et l’externe ne sont pas des essences, mais des effets de configuration, des prises, des agencements différenciés. Une *arcalité* peut être interne lorsqu’elle émane du récit propre d’une communauté politique, mais elle peut devenir externe si elle est dictée par des normes globales imposées. Une *cratialité* peut être locale et maîtrisée, mais aussi captée par des infrastructures techniques venues d’ailleurs. Une *archicration* peut se déployer dans une scène instituée par les acteurs concernés, ou leur être imposée depuis une juridiction externe, un tribunal arbitral, une plateforme d’arbitrage privée.
 
-C’est cette plasticité topologique — cette capacité à circuler, à migrer, à se dissimuler — qui fait à la fois la richesse et la dangerosité des régimes archicratiques. Car une régulation peut fonctionner en mimant l’interne tout en étant totalement dépendante d’un externe invisible. Elle peut se présenter comme autonome, participative, située, alors qu’elle est en réalité structurée par des standards qui échappent à toute contestation locale. Le risque est alors celui de la dépolitisation radicale, d’une perte de repères critiques, d’une désorientation normative. Ce que la grammaire topologique rend possible, c’est précisément de restaurer cette lisibilité perdue : de retrouver les fils, de remonter les chaînes, de cartographier les prises.
+C’est cette plasticité topologique — cette capacité à circuler, à migrer, à se dissimuler — qui fait à la fois la richesse analytique du paradigme et la dangerosité de certaines configurations désarchicratiques ou autarchicratiques. Car une régulation peut fonctionner en mimant l’interne tout en étant totalement dépendante d’un externe invisible. Elle peut se présenter comme autonome, participative, située, alors qu’elle est en réalité structurée par des standards qui échappent à toute contestation locale. Le risque est alors celui de la dépolitisation radicale, d’une perte de repères critiques, d’une désorientation normative. Ce que la grammaire topologique rend possible, c’est précisément de restaurer cette lisibilité perdue : retrouver les fils, remonter les chaînes, cartographier les prises.
 
 C’est pourquoi, dans les sections qui suivent, nous déploierons une analyse détaillée de chacun des trois pôles — *arcalité, cratialité, archicration* — en les examinant à travers leurs configurations internes et externes. Nous montrerons comment ces modalités se combinent, se transforment, se superposent. Nous analyserons les effets de ces agencements sur la viabilité, la lisibilité et l’opposabilité des dispositifs. Et nous préparerons ainsi le terrain pour une typologie opératoire des régimes de régulation — une typologie qui ne se contente pas de décrire, mais qui permet de diagnostiquer, de contester, de transformer.
 
@@ -716,15 +691,15 @@ En ce sens, l’analyse archicratique exige une vigilance accrue sur les conditi
 
 Ainsi, l’inertie d’une *arcalité externe* n’est pas seulement un échec technique ou politique : c’est le symptôme d’une absence de portage humain effectif. À l’inverse, sa puissance régulatrice dépend de sa capacité à être habitée, interprétée, mobilisée, par des professionnels, des agents publics, des collectifs intermédiaires ou des figures institutionnelles. Il y a une condition anthropologique de l’*arcalité* : sans corps vivant, pas de fondement durable.
 
-Lorsque ces fondements exogènes sont naturalisés, dépolitisés, non contestables, ils deviennent des vecteurs privilégiés du régime archicratique : leur autorité prétendue neutre masque l’impossibilité de les discuter, de les traduire, de les opposer. Ce n’est pas leur contenu qui pose problème, mais leur mode d’énonciation : sans scène de justification, sans délai, sans dispositif de médiation, ces *arcalités* deviennent des injonctions performatives opaques. Elles gouvernent sans débat, fondent sans s’exposer, et neutralisent la discorde.
+Lorsque ces fondements exogènes sont naturalisés, dépolitisés ou rendus difficilement contestables, ils deviennent des vecteurs privilégiés de dérives autarchicratiques ou archicratistiques : leur autorité prétendue neutre masque l’impossibilité pratique de les discuter, de les traduire ou de les opposer. Ce n’est pas leur contenu qui pose problème, mais leur mode d’énonciation : lorsque la scène de justification est neutralisée, lorsque les délais de médiation sont comprimés ou rendus fictifs, lorsque les dispositifs de traduction deviennent inopérants, ces arcalités tendent à devenir des injonctions performatives opaques.
 
 C’est pourquoi le paradigme archicratique impose une exigence méthodologique claire : documenter le statut, le portage, l’activation et la contestation des *arcalités externes*. *Qui les invoque ? Qui les traduit ? Qui les fait vivre ? Sont-elles révisables ? Opposables ? Intégrées dans une scène ou dissoutes dans le dogme ?* La critique archicratique ne vise pas à disqualifier l’externe, mais à rendre visibles ses conditions d’incarnation.
 
-Une *arcalité externe* bien internalisée, portée par une communauté compétente, disputée dans ses effets, rendue visible dans ses limites, peut renforcer un ordre démocratique. Mais une *arcalité* exogène désincarnée, mimée, figée, peut devenir le vecteur sourd d’un pouvoir sans scène. Le facteur humain, ici encore, est la clef de l’*arcalité vivante*.
+Une *arcalité externe* bien internalisée, portée par une communauté compétente, disputée dans ses effets, rendue visible dans ses limites, peut renforcer un ordre démocratique. Mais une *arcalité* exogène désincarnée, mimée, figée, peut devenir le vecteur sourd d’un pouvoir à scène neutralisée, relocalisée hors d’atteinte ou rendue pratiquement inopérante. Le facteur humain, ici encore, est la clef de l’*arcalité vivante*.
 
 ### 1.4.3 — *Cratialités internes* : opérativité endogène, chaînes d’exécution incarnées et pouvoir discret sans extériorité
 
-La *cratialité interne* constitue l’un des points névralgiques du paradigme archicratique. Elle ne se résume ni à l’action technique, ni à la simple application de normes venues d’ailleurs. Elle désigne la capacité d’un dispositif régulateur à produire lui-même, depuis l’intérieur, sa propre puissance opératoire, sans recourir explicitement à une légitimation transcendante (*arcalité*) ni à une scène d’épreuve (*archicration*). En ce sens, l’interne n’est pas un dedans organique, mais une position topologique de clôture opératoire : là où la régulation se suffit à elle-même, là où l’ordre d’exécution s’impose par la seule inertie du dispositif, là où le pouvoir se fait sans être dit.
+La *cratialité interne* constitue l’un des points névralgiques du paradigme archicratique. Elle ne se résume ni à l’action technique, ni à la simple application de normes venues d’ailleurs. Elle désigne la capacité d’un dispositif régulateur à produire lui-même, depuis l’intérieur, sa propre puissance opératoire, sans mobiliser explicitement une légitimation transcendante, et avec une scène d’épreuve devenue marginale, reléguée à l’arrière-plan ou pratiquement inopérante dans le cours ordinaire de l’exécution. En ce sens, l’interne n’est pas un dedans organique, mais une position topologique de clôture opératoire : là où la régulation tend à se suffire à elle-même, là où l’ordre d’exécution s’impose par l’inertie du dispositif, et là où le pouvoir agit comme s’il n’avait plus à se dire, à se justifier ni à se laisser reprendre.
 
 Ce qui distingue fondamentalement la *cratialité interne*, c’est son auto-suffisance apparente. Elle repose sur la densité cumulative des routines, des instruments, des protocoles, des langages, des procédures et — ce qui est décisif — des humains qui les activent, les maintiennent, les modulent. Car la *cratialité interne* n’est jamais une abstraction systémique désincarnée. Elle est portée par des agents, des métiers, des savoir-faire, qui donnent forme, corps et continuité à l’action régulatrice. Elle est faite de mains, de gestes, de réflexes, de scripts mentaux, de hiérarchies tacites, de cultures professionnelles. Elle n’est pas simplement un logiciel ou un organigramme : elle est le produit vivant de celles et ceux qui opèrent.
 
@@ -744,7 +719,7 @@ Il convient alors de distinguer plusieurs formes typologiques de *cratialité in
 
 - *Langagières et discursives* : ici, le pouvoir tient au langage : aux jargons techniques, aux syntaxes normalisées, aux grilles d’expression. Il est détenu par ceux qui maîtrisent le langage de l’institution — rédacteurs administratifs, formateurs, communicants, traducteurs techniques, qui donnent forme intelligible à la régulation.
 
-Ce qui fait la puissance silencieuse de cette *cratialité interne*, c’est qu’elle ne demande pas à être légitimée. Elle ne requiert ni fondement transcendant (*arcalité*), ni mise en épreuve contradictoire (*archicration*). Elle opère par inertie, par habitude, par flux. Tout y est déjà cadré, validé, formaté. La régulation se fait d’elle-même — non parce qu’elle est juste, mais parce qu’elle est possible, rapide, fluide.
+Ce qui fait la puissance silencieuse de cette cratialité interne, c’est qu’elle peut fonctionner comme si elle n’avait plus à répondre explicitement de ses justifications, et comme si la scène d’épreuve n’avait plus de prise effective sur son cours ordinaire ; c’est le cas des algorithmes non documentés et des procédures automatiques rendues pratiquement inopposables. Tout y est déjà cadré, validé, formaté. La régulation se fait d’elle-même — non parce qu’elle serait absolument sans arcalité ni sans archicration, mais parce que celles-ci deviennent peu exposables, reléguées à l’arrière-plan, ou pratiquement inopérantes dans le cours ordinaire de l’exécution.
 
 Mais c’est précisément cette fluidité sans extériorité qui peut poser problème. Car elle rend toute remise en cause difficile. Il n’y a pas de scène où s’adresser, pas de personne clairement responsable, pas de temporalité pour l’amendement. Ce n’est pas l’illégalité qui menace ici, mais la fermeture autoréférentielle : le dispositif fonctionne, donc il est. Le pouvoir s’exécute, donc il n’a pas besoin de s’expliquer.
 
@@ -836,7 +811,7 @@ C’est ici que le paradigme archicratique prend toute sa valeur : il rend lisib
 
 Autrement dit, l’*archicration interne* est ce qui maintient le pouvoir habitable, parce qu’elle le rend réversible, explicable, explicite et amendable. Elle ne garantit pas la vérité, ni la justice — elle garantit la possibilité d’un autrement.
 
-Mais lorsqu’elle se dissout dans l’inaction, lorsqu’elle est mise en scène sans effets, ou déportée vers des figures incapables d’assumer l’épreuve de la contestation, elle devient un artefact démocratique, un simulacre de dispute, une mise en forme de l’illusion délibérative. C’est là que l’*archicratie* s’installe : non comme domination explicite, mais comme court-circuit silencieux de la possibilité de reprise.
+Mais lorsqu’elle se dissout dans l’inaction, lorsqu’elle est mise en scène sans effets, ou déportée vers des figures incapables d’assumer l’épreuve de la contestation, elle devient un artefact démocratique, un simulacre de dispute, une mise en forme de l’illusion délibérative. C’est là que s’installe non l’archicratie, mais son envers : une désarchicration susceptible de dériver vers l’autarchicratie, c’est-à-dire un court-circuit silencieux de la possibilité de reprise.
 
 ### 1.4.6 — *Archicrations externes* : scènes surplombantes, interpellations dissidentes et figures de contre-institution
 
@@ -898,7 +873,7 @@ C’est aussi, plus tragiquement, le lieu où se manifeste l’effondrement des
 
 Si l’on a distingué, jusqu’ici, les prises internes et externes pour chacun des trois pôles du paradigme archicratique — *arcalité, cratialité, archicration* —, cette cartographie ne saurait être figée. Car les dispositifs régulateurs réels ne sont pas des blocs isolés ; ce sont des ensembles dynamiques, traversés par des circulations, des transferts, des reconfigurations. Autrement dit, l’interne et l’externe sont des positions politiques et stratégiques, dont les objets, les fonctions, les signes et les effets peuvent migrer, se dissimuler ou se renverser.
 
-C’est précisément dans cette dynamique migratoire que se déploie toute la plasticité — mais aussi toute l’ambiguïté — des régulations contemporaines. L’*archicratie* ne se limite pas à une absence de scène ou à une saturation cratiale ; elle procède souvent par reconfiguration des prises : ce qui était externe devient interne (capture), ce qui était interne devient externe (délestage), et ce qui devrait être visible est rendu opaque par changement de topologie. Ainsi, la logique archicratique se manifeste autant par ce qui est dit que par l’endroit d’où cela est dit, tout autant par ce qui est fait que par l’endroit d’où cela est imposé.
+C’est précisément dans cette dynamique migratoire que se déploie toute la plasticité — mais aussi toute l’ambiguïté — des régulations contemporaines. Les dérives autarchicratiques ne se réduisent pas à une simple absence de scène ou à une saturation cratiale ; elles procèdent souvent par reconfiguration des prises : ce qui était externe devient interne (capture), ce qui était interne devient externe (délestage), et ce qui devrait être visible est rendu opaque par changement de topologie. Ainsi, la dérive autarchicratique se manifeste autant par ce qui est dit que par l’endroit d’où cela est dit, tout autant par ce qui est fait que par l’endroit d’où cela est imposé.
 
 #### ***Migrations arcales* : du mythe incorporé au fondement importé**
 
@@ -954,7 +929,7 @@ L’excès d’internalité produit des régulations opaques, fermées, surcodé
 
 Mais c’est précisément entre ces deux pôles extrêmes que se noue la possibilité d’un dispositif politiquement viable : c’est-à-dire ni totalement clos, ni intégralement hétéronome, mais articulé dans une dialectique régulée entre interne et externe. Cette *co-viabilité* repose sur la capacité du dispositif à *maintenir une tension active entre ses composantes*, à autoriser la critique venue de l’extérieur sans se dissoudre dans une dépendance pure, et à mobiliser des justifications internes sans basculer dans l’auto-légitimation close.
 
-Cette tension est particulièrement cruciale dans les formes de régulation dites « silencieuses » — c’est-à-dire sans théâtre, sans acteurs identifiables, sans justification publique explicite. Là où l’interne l’emporte, le risque est celui d’une saturation normative : plus rien ne peut venir troubler le cycle opératoire du dispositif. Là où l’externe l’emporte, c’est l’évaporation du sens qui guette : plus rien ne fonde localement la régulation, plus rien ne la rend habitable.
+Cette tension est particulièrement cruciale dans les formes de régulation dites « silencieuses » — c’est-à-dire à théâtre affaibli ou neutralisé, à acteurs difficilement identifiables, et à justification publique faiblement exposable. Là où l’interne l’emporte, le risque est celui d’une saturation normative : plus rien ne peut venir troubler le cycle opératoire du dispositif. Là où l’externe l’emporte, c’est l’évaporation du sens qui guette : plus rien ne fonde localement la régulation, plus rien ne la rend habitable.
 
 Le paradigme archicratique n’a pas pour vocation de désigner un juste milieu abstrait entre ces deux extrêmes, mais de fournir les instruments critiques pour repérer les points de bascule, les seuils de rupture, les zones où la régulation cesse d’être lieu de confrontation parce que ses prises deviennent illisibles. Ces seuils de *co-viabilité* doivent être pensés à partir de critères politiques précis : *existe-t-il un différé ? Un recours ? Une scène ? Une instance d’interpellation ? Une capacité d’amendement ?* Ces questions ne sont pas secondaires : elles sont les conditions minimales de soutenabilité d’un ordre régulateur dans une société qui se dit démocratique.
 
@@ -1002,25 +977,27 @@ C’est dans ces configurations que l’analyse archicratique prend tout son sen
 
 En somme, penser la *co-viabilité* d’un dispositif régulateur, c’est penser sa tenue dans le différé, son ouverture à l’extériorité, sa capacité de reconfiguration, sans perdre son ancrage ni dissoudre sa légitimité. Ce n’est ni un équilibre idéal, ni une norme absolue : c’est une exigence politique minimale. Et c’est à cette exigence que répond, dans sa vocation critique, le paradigme archicratique.
 
-## **1.5 — Formes dynamiques de tenues archicratiques**
+## **1.5 — Formes dynamiques de la tenue archicratique**
 
 Penser un paradigme relationnel, c’est refuser de figer les configurations dans des états fixes, des catégories stables ou des oppositions binaires. Le paradigme archicratique ne cherche pas à déterminer si un système est équilibré ou déréglé, mais à analyser comment il tient, par quelles prises, dans quelle configuration de relations entre *arcalité, cratialité et archicration*, et surtout, jusqu’où cette tenue est vivable, soutenable, opposable. La régulation n’est pas un état ; c’est une forme — toujours en tension, toujours en transformation.
 
 Ce que nous proposons dans cette section, c’est une typologie des formes de tenue archicratique — autrement dit, une modélisation des manières dont les trois pôles du paradigme s’articulent ou se désarticulent dans les dispositifs réels. Car toute régulation effective engage nécessairement ces trois dimensions, mais elle le fait selon des équilibres hétérogènes, des désajustements partiels, des déséquilibres provisoirement tenus, des saturations masquées ou des ajustements régénérants.
 
-Nous nommerons ici forme de tenue archicratique toute configuration empirique ou modélisable dans laquelle les trois pôles sont en relation active, selon des degrés de présence, d’articulation, de visibilité et d’effectivité différenciés. Certaines formes permettent la viabilité démocratique du dispositif — nous les qualifierons de *synchrotopiques* : elles maintiennent la tension entre les pôles dans un espace de co-viabilité. D’autres sont marquées par l’hypertrophie d’un pôle, l’effacement d’un autre, ou la déconnexion entre niveaux — elles conduisent à des formes dites *hypertopiques* ou *entropiques*. Enfin, certaines configurations ne relèvent d’aucune pathologie manifeste, mais laissent émerger des signes cliniques faibles de désarticulation : perte de scène, opacité opérative, ritualisation creuse des fondements, etc.
+Nous nommerons ici forme de tenue archicratique toute configuration empirique ou modélisable dans laquelle les trois pôles sont en relation active, selon des degrés de présence, d’articulation, de visibilité et d’effectivité différenciés. Certaines formes permettent la viabilité démocratique du dispositif — nous les qualifierons de *synchrotopiques* : elles maintiennent la tension entre les pôles dans un espace de co-viabilité. D’autres sont marquées par l’hypertrophie d’un pôle, l’effacement d’un autre, ou la déconnexion entre niveaux — elles conduisent à des formes dites hypertopiques, hypotopiques ou atopiques. Enfin, certaines configurations ne relèvent d’aucune pathologie manifeste, mais laissent émerger des signes cliniques faibles de désarticulation : perte de scène, opacité opérative, ritualisation creuse des fondements, etc.
 
-Ces formes de tenues ne valent ni comme jugement moral, ni comme idéal-type figé. Elles doivent être comprises comme des formes observables et évolutives. Elles ne sont pas des essences, mais des positions dans un espace de viabilité régulatoire. Et leur analyse permet, dans chaque cas empirique, de répondre à la question fondamentale : *qu’est-ce qui tient ici ? Comment ? À quel prix ? Et pour combien de temps ?*
+Ces configurations de tenue ne valent ni comme jugement moral, ni comme idéal-type figé. Elles doivent être comprises comme des formes observables et évolutives. Elles ne sont pas des essences, mais des positions dans un espace de viabilité régulatoire. Et leur analyse permet, dans chaque cas empirique, de répondre à la question fondamentale : *qu’est-ce qui tient ici ? Comment ? À quel prix ? Et pour combien de temps ?*
 
-Il ne s’agit donc pas de réhabiliter une typologie figée (équilibré vs déséquilibré), ni de fantasmer un modèle harmonieux. Il s’agit de fournir une cartographie critique, ancrée, falsifiable, capable de guider l’analyse empirique des dispositifs de régulation contemporaine, sans céder à l’abstraction ni au moralisme.
+Il ne s’agit donc pas de réhabiliter une typologie figée (équilibré vs déséquilibré), ni de fantasmer un modèle harmonieux.
 
-Dans les sous-sections qui suivent, nous distinguerons trois grandes formes dynamiques de tenue archicratique :
+Dans les sous-sections qui suivent, nous distinguerons quatre grandes formes dynamiques de tenue archicratique :
 
-1.  La *forme synchrotopique* : tension vivable, différenciation claire des pôles, articulation régulée — une régulation habitable.
+La forme *synchrotopique* : tension vivable, différenciation claire des pôles, articulation régulée — une régulation habitable.
 
-2.  La *forme hypertopique* : domination d’un pôle archicratique, avec effets de blocage, d’asymétrie ou de dévitalisation.
+La forme *hypertopique* : domination d’un pôle archicratique, avec effets de blocage, d’asymétrie ou de dévitalisation.
 
-3.  La *forme entropique* : perte de liaison, saturation, effondrement de la dispute, invisibilisation des fondements, opacité des instruments.
+La forme *hypotopique* : effacements, désaffiliations, mises en latence ou désarrimages des prises régulatrices.
+
+La forme *atopique* : mimétisme des pôles, vacuité des prises, spectralisation de la régulation.
 
 Chacune de ces formes sera décrite avec ses critères de reconnaissance, ses symptômes internes, ses objets d’épreuve et ses points de bascule potentiels.
 
@@ -1084,15 +1061,15 @@ En cela, les *formes hypertopiques* nous enseignent ce que devient une régulati
 
 Il est des régulations dont la fragilité réside dans le défaut même d’articulation, dans la carence silencieuse d’un ou plusieurs pôles, non pas dominance mais par manquements, effacements, indéterminations. Ces régimes ne sont pas saturés — ils sont désarrimés, désaffiliés, incomplètement ancrés. Ce sont les *formes hypotopiques* : configurations où la triade archicratique ne parvient pas à s’incarner pleinement, soit par inachèvement historique, soit par délitement structurel, soit par marginalisation sociale. Non point des régimes de déséquilibre manifeste — mais de décrochements latents.
 
-Dans ces situations, ce n’est pas la force excessive d’un pôle qui domine, mais l’effacement progressif ou brutal de l’un de ses vecteurs constitutifs. Cela peut être l’arcalité qui fait défaut, lorsqu’une régulation se poursuit sans fondement explicite, sans justification reconnue, sans principe commun. Cela peut être la *cratialité* qui s’effondre, lorsque les moyens d’opération sont absents, disjoints ou dysfonctionnels. Cela peut être l’*archicration* qui se dissout, lorsque plus aucune scène ne permet l’expression du différend, la mise en tension, la confrontation réglée.
+Dans ces situations, ce n’est pas la force excessive d’un pôle qui domine, mais l’effacement progressif ou brutal de l’un de ses vecteurs constitutifs. Cela peut être l’arcalité qui fait défaut, lorsqu’une régulation se poursuit sous des fondements implicites, peu exposables ou dépourvus de justification reconnue. Cela peut être la cratialité qui s’effondre, lorsque les moyens d’opération sont absents, disjoints ou dysfonctionnels. Cela peut être l’archicration qui se dissout, lorsqu’aucune scène effective ne permet plus l’expression du différend, la mise en tension ou la confrontation réglée.
 
-Un exemple manifeste d’*hypoarcalité* se retrouve dans les dispositifs provisoires ou de crise, où l’action publique se déploie sans fondement explicite, dans une zone grise entre droit et exception. L’état d’urgence sanitaire prolongé, la gestion dérogatoire des flux migratoires ou encore les expérimentations territoriales non encadrées sont autant de cas où la *cratialité* et parfois l’*archicration* existent, mais où l’*arcalité* est suspendu, implicite ou réduit à un vague impératif de « nécessité ». Dans ces cas, la légitimité régulatrice s’efface, non pas par volonté autoritaire, mais par inachèvement ou déni de sa propre condition normative. Le pouvoir continue d’agir, mais sans adossement symbolique, éthique ou juridique pleinement assumé.
+Un exemple manifeste d’*hypoarcalité* se retrouve dans les dispositifs provisoires ou de crise, où l’action publique se déploie sur fondement implicite, suspendu ou faiblement exposable, dans une zone grise entre droit et exception. L’état d’urgence sanitaire prolongé, la gestion dérogatoire des flux migratoires ou encore les expérimentations territoriales non encadrées sont autant de cas où la *cratialité* et parfois l’*archicration* existent, mais où l’*arcalité* est suspendu, implicite ou réduit à un vague impératif de « nécessité ». Dans ces cas, la légitimité régulatrice s’efface, non pas par volonté autoritaire, mais par inachèvement ou déni de sa propre condition normative. Le pouvoir continue d’agir, mais sur un adossement symbolique, éthique ou juridique faiblement assumé, peu explicité ou difficilement opposable.
 
 À l’inverse, certaines configurations présentent une *hypocratialité* : les intentions sont fortes, les textes abondants, les dispositifs délibératifs multiples — mais l’opérativité est absente ou déficiente. Ce sont les dispositifs de « papier », sur-institutionnalisés et sous-dotés, où les *arcalités* sont proclamées, les *archicrations* ouvertes, mais rien ne se passe. Les plans de transition écologique sans moyens, les comités citoyens sans budget, les programmes d’inclusion numérique sans matériel sont des formes classiques de cette dérive. Le geste politique est performé, mais peu outillé. L’action régulatrice meurt d’épuisement, faute d’infrastructure ou de continuité d’exécution. Le pôle cratial se délite, et avec lui, la consistance de tout l’édifice.
 
 Il existe enfin des *régimes hypoarchicratifs*, dans lesquels les tensions sont étouffées, non par répression ou simulation, mais par désertion. Les scènes de dispute s’éteignent non faute d’autorisation, mais faute de participants, faute de prise, faute d’appel possible. La démocratie locale peut en être le symptôme : dans certains conseils municipaux ruraux, toutes les délibérations sont publiques, les procès-verbaux accessibles, les voies de recours en théorie ouvertes — mais personne n’y vient, personne ne les utilise. L’espace de la critique devient désert, non pas parce qu’on l’empêche, mais parce qu’il n’a plus d’effet. On ne conteste plus ce que l’on ne croit plus modifiable. L’usure de la dispute devient une forme d’abstention persistante.
 
-Ces *régulations hypotopiques* sont redoutables précisément parce qu’elles ne suscitent pas d’alarme immédiate. Elles n’ont ni l’éclat tyrannique des régimes autoritaires, ni le chaos visible des formes délibératives défaillantes. Elles perdurent, parfois longtemps, dans une grande stabilité apparente, faute de tension, de friction, de dispute. Mais c’est une stabilité vide, une paix sans enjeu, un ordre sans scène.
+Ces *régulations hypotopiques* sont redoutables précisément parce qu’elles ne suscitent pas d’alarme immédiate. Elles n’ont ni l’éclat tyrannique des régimes autoritaires, ni le chaos visible des formes délibératives défaillantes. Elles perdurent, parfois longtemps, dans une grande stabilité apparente, faute de tension, de friction, de dispute. Mais c’est une stabilité vide, une paix sans enjeu, un ordre à scène désertée, neutralisée ou pratiquement inopérante.
 
 Le paradigme archicratique nous invite ici à une vigilance particulière : il ne suffit pas de vérifier la présence formelle des trois pôles. Il faut en interroger l’effectivité, la consistance, la vitalité, dans la durée et dans la conflictualité. Une *arcalité* proclamée mais jamais invoquée est un décor. Une *cratialité* active mais sans prise humaine est un automatisme. Une *archicration* ouverte mais inopérante est une illusion procédurale. Ce qui fait régulation n’est pas l’énumération des fonctions, mais leur co-présence dynamique, différenciée, habitée.
 
@@ -1100,9 +1077,11 @@ Les *formes hypotopiques* sont les signes d’une dérégulation par effacement,
 
 ### 1.5.4 — *Formes atopiques* : déréalisations, vacuités et simulacres
 
-Il est des dispositifs de régulation où les formes sont présentes, les fonctions identifiables, les terminologies stabilisées — mais où la consistance topologique fait défaut. Ni déséquilibre (hypertopie), ni carence (hypotopie), ni tension co-viable (synchrotopie), ces configurations appartiennent à un tout autre régime : celui de l’*irréalité régulatrice*. La structure semble intacte, parfois même sophistiquée, mais aucun des pôles archicratiques n’est substantiellement ancré, ni dans la scène, ni dans les corps, ni dans les pratiques. Ce sont des *formes atopiques* — c’est-à-dire des régulations sans lieu, sans effectivité, sans consistance — qui simulent l’existence d’un ordre tout en ne le rendant ni habitable, ni contestable, ni opératoire.
+Il est des dispositifs de régulation où les formes sont présentes, les fonctions identifiables, les terminologies stabilisées — mais où la consistance topologique fait défaut. Ni déséquilibre (hypertopie), ni carence (hypotopie), ni tension co-viable (synchrotopie), ces configurations appartiennent à un autre régime : celui de l’irréalité régulatrice. La structure semble intacte, parfois même sophistiquée, mais les pôles archicratiques n’y trouvent plus qu’un ancrage vidé, mimé, stylisé ou rendu artefact, sans consistance vivante ni effectivité praticable. L’arcalité y est mimée plutôt qu’exposée, la cratialité y est stylisée plutôt que véritablement rendue opérante, l’archicration y est figurée plutôt qu’instituée comme scène de reprise. Nous n’avons plus affaire à une régulation tenue, mais à une scénographie vide de la régulation.
 
-L’*atopie* n’est pas l’absence pure et simple. Elle est une présence vide, une figuration institutionnelle déconnectée de tout processus régulateur vivant. Elle repose souvent sur des artefacts de légitimation, des outils de pilotage automatisés, des consultations protocolaires — mais dont l’impact sur le réel est nul ou illisible. Tout y est là, en apparence : des fondements (arcalité), des instruments (cratialité), des scènes de discussion (archicration) — mais sans prise, sans contrepartie, sans transformation. L’infrastructure normative est creuse, le pilotage est aveugle, la dispute est factice. On y maintient les gestes, les rites, les discours — mais sans monde.
+L’*atopie* n’est pas l’absence pure et simple. Elle est une présence vide, une figuration institutionnelle déconnectée de tout processus régulateur vivant. Elle repose souvent sur des artefacts de légitimation, des outils de pilotage automatisés, des consultations protocolaires — mais dont l’impact sur le réel est nul ou illisible. Tout y est — en apparence : des fondements, des instruments, des scènes de discussion — mais sous des formes vidées de prise, privées de contrepartie effective et incapables de transformation réelle. L’infrastructure normative est creuse, le pilotage est aveugle, la dispute est factice. On y maintient les gestes, les rites, les discours — mais sans prise vivante sur le monde qu’ils prétendent réguler.
+
+L’atopie ne décrit donc pas une régulation effective amputée de ses pôles, mais un simulacre régulatif dans lequel les prises ne subsistent plus qu’à l’état mimé, vidé ou rendu artefact.
 
 Cette atopie peut se manifester selon plusieurs figures typiques.
 
@@ -1124,7 +1103,7 @@ Enfin, l’atopie peut prendre la forme d’un usage symbolique, rhétorique ou
 
 Ce que révèle l’analyse archicratique, c’est que la vacuité ne s’oppose pas frontalement au pouvoir : elle peut en être la forme la plus stable. Le simulacre est parfois plus durable que l’autoritarisme, car moins repérable, moins conflictuel, plus fluide. Une démocratie peut périr dans l’atopie sans jamais suspendre le droit de vote. Une administration peut devenir autistique sans jamais violer la procédure. Un dispositif de participation peut être déserté par saturation symbolique, non par coercition.
 
-L’*atopie* est donc le point aveugle de la critique classique. Elle ne se manifeste pas par l’excès de pouvoir, ni par son absence, mais par sa *simulation creuse*. Elle est ce moment où les fonctions sont remplies, mais où aucune scène n’est réellement investie, aucun lien n’est réellement actif, aucun différé n’est institué.
+L’*atopie* est donc le point aveugle de la critique classique. Elle ne se manifeste pas par l’excès de pouvoir, ni par son absence, mais par sa *simulation creuse*. Elle est ce moment où les fonctions sont remplies, mais où les scènes ne sont plus réellement investies, où les liens deviennent inactifs ou purement formels, et où le différé n’est plus institué comme prise effective de reprise, mais seulement figuré ou neutralisé.
 
 ### Cartographier la tenue régulatrice : vers une pragmatique des formes archicratiques
 
@@ -1134,9 +1113,9 @@ Nous avons désigné par *forme synchrotopique* la configuration rare bien que d
 
 Les *formes hypertopiques*, quant à elles, rendent visible la plasticité parfois toxique du paradigme : lorsque l’un ou deux des pôles submergent les autres, soit par hégémonie fondatrice (*hyperarcalité*), soit par captation instrumentale (*hypercratialité*), soit par saturation participative (archicration sans opérativité), la régulation se bloque, s’étiole ou se pervertit. Les dérives y sont patentes, mais leur diagnostic exige plus que des jugements de valeur : il réclame une lecture structurelle, patiente, stratifiée.
 
-Avec les *formes hypotopiques*, le paradigme archicratique affronte une tout autre pathologie : celle de l’effacement, du désarrimage, de la déprise. Il ne s’agit plus ici d’excès, mais de manque : manque de justification, d’effectuation, de dispute. Ce n’est plus la sur-présence d’un pôle qui menace, mais l’absence réelle ou feinte de tout principe actif de régulation. Ce sont des régulations en dormance, en rétraction, ou en dissociation.
+Avec les *formes hypotopiques*, le paradigme archicratique affronte une tout autre pathologie : celle de l’effacement, du désarrimage, de la déprise. Il ne s’agit plus ici d’excès, mais de manque : manque de justification, d’effectuation, de dispute. Ce n’est plus la sur-présence d’un pôle qui menace, mais l’effacement, la mise en dormance ou la désactivation apparente des principes actifs de régulation.
 
-Enfin, les *formes atopiques* révèlent la possibilité la plus troublante, et sans doute la plus contemporaine : celle de régulations sans réalité, où les pôles sont mimés, stylisés, formalisés — mais sans consistance, sans scène, sans prise. Ce ne sont plus des déséquilibres, mais des simulacres. Non plus des régimes problématiques, mais des dispositifs qui tiennent sans fonder, sans opérer, sans disputer. Ce sont les formes vides du pouvoir sans régulation véritable — celles qui appellent une reconstitution critique urgente du politique.
+Enfin, les formes atopiques révèlent la possibilité la plus troublante, et sans doute la plus contemporaine : celle de configurations où les pôles sont stylisés et formalisés, mais avec des prises mimées, vidées, à ancrage vivant introuvable, à scène devenue impraticable, et à effectivité régulatrice non soutenable. Ils ne “tiennent” pas au sens fort d’une régulation viable ; ils se maintiennent comme artefacts, comme figures creuses, comme apparences d’ordre. Ce sont les formes vides du pouvoir sans régulation habitable — celles qui appellent une reconstitution critique urgente du politique.
 
 Ce qui se donne à voir, à travers cette cartographie dynamique des tenues régulatrices, c’est donc une topologie active du paradigme archicratique : un modèle théorique qui permet de penser non seulement les composants, mais leur manière d’apparaître, de s’ordonner, de se désordonner, de se figer, de se dissoudre. Il s’agit d’un dispositif critique, qui articule diagnostic, description et problématisation, en donnant au lecteur — et plus encore, au chercheur, au praticien, au citoyen — des outils de repérage, de discernement, d’action.
 
@@ -1148,8 +1127,8 @@ Cette section 1.5 constitue ainsi un tournant dans notre essai-thèse. Car elle
 |:--:|:--:|:--:|:--:|:--:|:--:|:--:|
 | **Synchrotopique** | Trois pôles présents, différenciés, articulés | Équilibre différé et co-tendu | Régulation habitée, amendable, soutenable | — (forme idéale) | Maximal : habitable, critique, stable | Capacité de ralentir, d’ajuster, de contester |
 | **Hypertopique** | Un ou deux pôles hégémoniques (ex. arcalité absolue ou cratialité saturante) | Tension écrasée, figée ou court-circuitée | Régulation asymétrique, autoréférente ou verrouillée | Sur-arcalisation, technogestion, théâtralisation participative | Moyen à faible, selon la plasticité restante | Blocage d’un pôle, exclusion d’un autre, saturation opératoire |
-| **Hypotopique** | Un ou plusieurs pôles effacés, désaffiliés ou en veille | Tension suspendue, inopérante | Régulation dévitalisée, bancale ou inerte | Disparition des fondements, perte d’efficacité, vide contestataire | Faible, sauf réactivation coordonnée | Absence de scènes, silence des agents, désancrage narratif |
-| **Atopique** | Trois pôles présents mais sans ancrage réel | Tension fantomatique ou mimée | Régulation spectrale, simulée ou décorative | Déréalisation, fétichisation, vacuité procédurale | Nul à toxique : simulacre paralysant | Aucun effet de scène, aucune reprise, vacuité masquée par la forme |
+| **Hypotopique** | Un ou plusieurs pôles effacés, désaffiliés ou en veille | Tension suspendue, inopérante | Régulation dévitalisée, bancale ou inerte | Effacement, mise en latence ou faible exposition des fondements ; perte d’efficacité ; dévitalisation contestataire | Faible, sauf réactivation coordonnée | Scènes désertées, neutralisées ou pratiquement inopérantes ; silence des agents ; désancrage narratif |
+| **Atopique** | Trois pôles mimés, stylisés ou artefactuels, sans ancrage vivant soutenable | Tension fantomatique ou mimée | Régulation spectrale, simulée ou décorative | Déréalisation, fétichisation, vacuité procédurale | Nul à toxique : simulacre paralysant | Scène figurée sans prise, reprise neutralisée, vacuité masquée par la forme |
 
 Chaque ligne de ce tableau constitue un cadre analytique complet : il peut être utilisé comme outil de diagnostic dans les chapitres suivants, pour évaluer des dispositifs empiriques sectoriels, repérer des évolutions topologiques, ou cartographier des formes de capture et de libération régulatrice.
 
@@ -1201,7 +1180,7 @@ En somme, la détectabilité est ici un geste critique et herméneutique : recon
 
 L’*archicratie*, destinée à saisir autrement les modalités différenciées, évolutives et souvent opaques de la régulation dans les sociétés humaines, n’entend pas livrer ici un instrument de mesure, mais proposer une grammaire de discernement — ancrée dans la triade *arcalité–cratialité–archicration* — pour éclairer de réelles situations situées. L’ambition est heuristique : offrir des points d’ancrage et de repérage capables de décrire, de discriminer et de problématiser, sans sacrifier la pluralité des expériences ni la conflictualité inhérente à toute *co-viabilité*.
 
-Nous vivons un moment où l’« opérativité » est souvent dévoyée par la prolifération de mesures pseudo-scientifiques érigées en dispositifs de vérité sans scène : tableaux de bord, indicateurs de performance, grilles d’évaluation, algorithmes prédictifs et plateformes de pilotage normant l’action en amont et rétrécissant les marges du possible en aval. Sous prétexte de rationalisation, s’étend une régulation sans scène : sans explicitation des sources, sans exposition des mécanismes, sans différé d’interprétation. La mesure devient sa propre justification, neutralisant le conflit constitutif du social et sapant les conditions d’une *archicration* effective.
+Nous vivons un moment où l’opérativité est fréquemment dévoyée par la prolifération de mesures pseudo-scientifiques élevées au rang de dispositifs de vérité à scène neutralisée, comprimée ou relocalisée hors d’atteinte. Tableaux de bord, indicateurs de performance, grilles d’évaluation, algorithmes prédictifs et plateformes de pilotage étendent ainsi une régulation dont la scène d’épreuve se trouve neutralisée : les sources demeurent insuffisamment explicitées, les mécanismes ne sont pas pratiquement exposables, et le différé interprétatif devient fictif ou inopérant. Sous prétexte de rationalisation, ces dispositifs normaient l’action en amont et resserrent en aval les marges du possible. La mesure tend alors à se faire sa propre justification, neutralisant le conflit constitutif du social et minant les conditions mêmes d’une archicration effective.
 
 Face à cette saturation instrumentale, la tâche du paradigme archicratique est plus modeste et plus exigeante : non pas proposer un outil de pilotage alternatif, ni concurrencer les instruments existants sur leur terrain, mais offrir des repères heuristiques pour identifier des formes différenciées de légitimation, d’opération et de contestation dans des contextes socio-politiques, historiques et institutionnels situés. Ces repères ne visent ni universalité formelle ni exclusivité, mais pertinence contextualisée. Ils se proposent comme scène d’interprétation ouverte, susceptible d’être discutée et ajustée par les acteurs. Ils forment une matrice de discernement, non un schéma d’application.  
 Nota bene : la conversion de ces repères en protocoles d’évaluation relève d’un programme ultérieur, non traité dans l’ouvrage.
@@ -1220,7 +1199,7 @@ Prenons un service public numérisé où les usagers passent par un portail en l
 
 Enfin, l’*archicration* constitue le point névralgique de la lecture archicratique. Elle ne se réduit ni au droit au recours formel ni à une contradiction abstraite : elle désigne la scène instituée, différée, située, où le pouvoir se laisse interroger, où la décision devient amendable, où le fondement redevient discours. Instance juridictionnelle, médiation, espace de débat, conseil pluraliste, rituel, forum numérique, procédure contradictoire, délai suspensif : la forme importe moins que la possibilité effective pour les agents affectés de faire entendre leur voix, demander des comptes, suspendre, raconter une autre version, transformer le dispositif en scène contradictoire.
 
-Une régulation sans *archicration* est une régulation sans visage. Une décision sans différé est une décision sans interlocuteur. Là où le contradictoire disparaît, vacille non seulement la démocratie, mais la capacité d’une société à se représenter comme traversée de conflits et de désaccords potentiellement féconds. La lecture archicratique consiste à repérer, dans chaque dispositif, les conditions minimales d’une telle scène, à diagnostiquer les formes de son effacement et à préfigurer les moyens de sa réapparition. L’*archicration* n’est pas un luxe : c’est la condition de possibilité de toute régulation viable.
+Une régulation privée d’archicration effective est une régulation sans visage. Une décision sans différé praticable est une décision sans interlocuteur. Là où le contradictoire disparaît ou devient inopérant, vacille non seulement la démocratie, mais la capacité d’une société à se représenter comme traversée de conflits et de désaccords potentiellement féconds. La lecture archicratique consiste à repérer, dans chaque dispositif, les conditions minimales d’une telle scène, à diagnostiquer les formes de son effacement et à préfigurer les moyens de sa réapparition. L’archicration n’est pas un luxe : elle est la condition de possibilité de toute régulation viable.
 
 Une telle lecture ne peut être univoque ni standardisée. Elle suppose une approche située, transversale, dialogique, mobilisant des savoirs institutionnels, juridiques, techniques, mais aussi ethnographiques, narratifs, subjectifs. Elle engage des compétences et lectures croisées, et exige que les sujets soient parties prenantes de l’interprétation. C’est dans les récits, résistances, bifurcations, plaintes et silences que la régulation — ou son absence — devient visible. C’est dans les marges, interstices et incidents que l’*archicratie* trouve sa matière vive.
 
@@ -1270,13 +1249,13 @@ De ce point de vue, l’archicration n’est pas un protocole à décliner, mais
 
 À ce stade du chapitre, le paradigme archicratique s’est exposé dans ses principes, dans ses conditions de lisibilité, d’usage et d’épreuve, dans ses *seuils critiques* (détectabilité, repérage, ouverture critique), ainsi que dans ses *ancrages différés* (scènes, seuils, temporalités). Mais il reste à en consolider la prise morphologique : non plus sous l’angle de ses conditions de possibilité générales, mais à travers l’analyse concrète de ses formes d’incarnation, de ses figures empiriques, de ses variations structurelles. Car une régulation ne se donne jamais dans le vide : elle se trame, se matérialise, se temporalise, et surtout s’expérimente. Le moment morphologique constitue donc le point de bascule entre la formulation du paradigme et sa puissance heuristique dans les régimes concrets.
 
-Ce chantier ne répète en rien ce qui a été posé jusqu’ici. Il s’en distingue par son objet, sa méthode et sa finalité. La section 1.1 posait le cadre d’intelligibilité général du paradigme : la triade *arcalité-cratialité-archicration*, pensée comme structure de fondation, de mise en œuvre et de reprise d’un ordre. La section 1.4 déployait l’architecture du paradigme dans sa forme purement théorique : triptyque de prises, logique de différenciation, schéma des articulations internes. Ce que propose à présent la section 1.7, c’est une *approche stratifiée*, *située*, *matérielle* et *expérientielle* de ces trois prises, telles qu’elles apparaissent, circulent, se figent ou s’ouvrent dans les régimes de régulation réels — avec toute la diversité, la conflictualité, l’hétérogénéité et l’imperfection que cela suppose. Il ne s’agit donc plus de conceptualiser les pôles, mais d’en cartographier les formes.
+Ce chantier ne répète en rien ce qui a été posé jusqu’ici. Il s’en distingue par son objet, sa méthode et sa finalité. La section 1.1 posait le cadre d’intelligibilité général du paradigme : la triade *arcalité-cratialité-archicration*, pensée comme structure de fondation, de mise en œuvre et de reprise d’un ordre. La section 1.4 déployait l’architecture du paradigme dans sa forme purement théorique : triptyque de prises, logique de différenciation, schéma des articulations internes. Les sections 1.5 et 1.6 en ont ensuite éprouvé les formes dynamiques et dégagé les premiers repères heuristiques ; la section 1.7 peut dès lors en proposer la cartographie morphologique. Une *approche stratifiée*, *située*, *matérielle* et *expérientielle* de ces trois prises, telles qu’elles apparaissent, circulent, se figent ou s’ouvrent dans les régimes de régulation réels — avec toute la diversité, la conflictualité, l’hétérogénéité et l’imperfection que cela suppose. Il ne s’agit donc plus de conceptualiser les pôles, mais d’en cartographier les formes.
 
 Car ce qui fait valeur dans un paradigme critique, ce n’est pas sa seule élégance morphologique, mais sa capacité à discerner des régularités, à documenter des bifurcations, à nommer des fractures — non pour assigner, mais pour ouvrir la possibilité d’une lecture située. Une forme d’*arcalité* n’est pas un idéal-type, mais une configuration référentielle historiquement, symboliquement et techniquement composée. Une *cratialité* ne vaut pas par sa fidélité à un protocole d’exécution, mais par l’agencement spécifique de ses opérateurs, de ses instruments, de ses temporalités d’action. Une *archicration* ne se mesure pas à l’existence nominale d’un droit au recours, mais à la consistance vécue de la scène qu’elle institue ou qu’elle empêche. C’est à ces formes multiples — *opérantes, affaiblies, désincarnées, empêchées, contournées* — que nous allons désormais nous confronter.
 
 Ce travail de morphologie opérante repose sur trois exigences conjuguées. D’abord, une *exigence* *référentielle* : comprendre à partir de quels énoncés, objets, récits, modèles, figures ou principes un ordre prétend se légitimer. Ensuite, une *exigence opératoire* : analyser les mécanismes, supports, outils, interfaces, organigrammes, temporalités et frictions par lesquels une règle produit ses effets. Enfin, une *exigence expérientielle* : restituer la manière dont ces formes sont vécues, comprises, redoutées, contournées ou investies par celles et ceux qui y sont exposés. C’est dans cette articulation — du sémantique, du matériel et du sensible — que réside la puissance diagnostique du paradigme.
 
-Mais il nous faut aller plus loin encore, car cette typologie stratifiée ne peut se limiter à un inventaire. Elle constitue davantage le socle critique de l’épreuve archicratique. En effet, une *arcalité* peut exister sans être compréhensible ni contestable ; une *cratialité* peut opérer sans être localisable ni amendable ; une *archicration* peut être instituée sans jamais devenir praticable. Le paradigme archicratique n’exige pas que ces prises soient parfaites — il exige qu’elles soient rendues lisibles dans leur état, qu’elles soient exposées dans leur morphologie effective, et surtout qu’elles soient analysées pour ce qu’elles permettent ou empêchent en termes d’adresse, de comparution et de remédiation.
+Mais il nous faut aller plus loin encore, car cette typologie stratifiée ne peut se limiter à un inventaire. Elle constitue davantage le socle critique de l’épreuve archicratique. En effet, une arcalité peut subsister en demeurant difficilement compréhensible ou contestable ; une cratialité peut opérer tout en restant peu localisable ou faiblement amendable ; une archicration peut être instituée tout en devenant pratiquement impraticable. Le paradigme archicratique n’exige pas que ces prises soient parfaites — il exige qu’elles soient rendues lisibles dans leur état, qu’elles soient exposées dans leur morphologie effective, et surtout qu’elles soient analysées pour ce qu’elles permettent ou empêchent en termes d’adresse, de comparution et de remédiation.
 
 Il s’agit ici d’un pas décisif vers l’observation située, vers la formalisation graduée des régimes, vers une grammaire analytique capable de faire apparaître les formes ténues ou massives, explicites ou latentes, ouvertes ou fermées, des prises archicratiques. C’est un appel à regarder autrement ce qui fait régulation. Et cet appel passe par la reconnaissance des formes — même mutilées, même silencieuses — que prennent nos fondements, nos opérations et nos scènes.
 
@@ -1342,9 +1321,9 @@ Elle peut se déployer dans des *régimes centralisés* — un portail numériqu
 
 Il faut ici récuser toute vision gestionnaire ou techniciste. La *cratialité* ne se résume pas à un processus d’optimisation. Elle n’a pas pour finalité d’assurer l’efficacité d’un dispositif, mais de rendre intelligible les formes d’effectuation concrète d’un ordre. Une chaîne de traitement peut être rapide, fluide, bien documentée — et pourtant rigide, incompréhensible, impitoyable. À l’inverse, une *cratialité* peut être lente, manuelle, fragmentée — mais ménager des seuils d’ajustement, des lieux d’appel, des moments d’interruption qui la rendent habitable. Ce n’est pas le style de l’opération qui compte, mais sa capacité à articuler des effets dans une configuration régulatrice spécifique.
 
-Cette articulation engage la matérialité des infrastructures comme la plasticité des rôles. Un *geste cratial* est conditionné par une forme, un outil, une procédure, un délai, un seuil, un langage. Lorsqu’un distributeur automatique refuse un retrait parce que le compte est bloqué, il ne fait qu’opérer un effet déjà inscrit ailleurs dans une chaîne bancaire : encodage d’un score de risque, clôture discrète d’un accès, préemption sur des soldes en litige. Le geste, ici, est purement machinique, mais sa *cratialité* est pleine : il transforme une trajectoire, conditionne une action, produit un effet de contrainte — sans justification visible et hors de toute scène explicite.
+Cette articulation engage la matérialité des infrastructures comme la plasticité des rôles. Un *geste cratial* est conditionné par une forme, un outil, une procédure, un délai, un seuil, un langage. Lorsqu’un distributeur automatique refuse un retrait parce que le compte est bloqué, il ne fait qu’opérer un effet déjà inscrit ailleurs dans une chaîne bancaire : encodage d’un score de risque, clôture discrète d’un accès, préemption sur des soldes en litige. Le geste, ici, est purement machinique, mais sa *cratialité* est pleine : il transforme une trajectoire, conditionne une action, produit un effet de contrainte — sur une justification faiblement visible et dans une scène d’épreuve neutralisée, reléguée ou pratiquement hors de portée.
 
-C’est précisément cette possibilité d’absence de scène qui rend la *cratialité* décisive dans notre paradigme. Car elle travaille en amont de toute possible contestation et en aval de tout fondement. Elle agit avant la réclamation et après le principe. Elle ne parle pas, mais elle configure les possibilités d’action : ce que l’on peut faire, ce que l’on doit fournir, où l’on peut passer, avec qui l’on peut parler, à quel moment une procédure ou une démarche est susceptible de relance ou s’avère réellement close. En cela, ce sont les chaînes opératoires — non pas les discours — qui rendent compte du régime véritable d’un ordre. En quelque sorte, elle en révèle *sa conduite* et *son conduit*.
+C’est précisément cette possibilité de neutralisation, de relocalisation ou d’inopérance de la scène qui rend la cratialité décisive dans notre paradigme. Car elle travaille en amont de toute possible contestation et en aval de tout fondement. Elle agit avant la réclamation et après le principe. Elle ne parle pas, mais elle configure les possibilités d’action : ce que l’on peut faire, ce que l’on doit fournir, où l’on peut passer, avec qui l’on peut parler, à quel moment une procédure ou une démarche est susceptible de relance ou s’avère réellement close. En cela, ce sont les chaînes opératoires — non pas les discours — qui rendent compte du régime véritable d’un ordre. En quelque sorte, elle en révèle *sa conduite* et *son conduit*.
 
 Dans les pratiques sociales ordinaires, la *cratialité* se manifeste sans protocole formel. Lorsqu’un étudiant s’adresse à un secrétariat, lorsqu’un réfugié tente d’accéder à un guichet saturé, lorsqu’un malade cherche un rendez-vous sur Doctolib, ce ne sont pas les normes écrites qui produisent la régulation, mais les séquences d’opérations réelles : les créneaux disponibles, la tolérance de l’agent, la posture du guichet, l’existence ou non d’un canal alternatif, la résilience du dispositif face à la surcharge. Une *cratialité* se reconnaît au fait que le sujet modifie son agir en fonction de la chaîne d’effectuation perçue ou anticipée — même s’il n’en connaît ni la structure ni les règles exactes.
 
@@ -1352,7 +1331,7 @@ On ne saurait confiner la *cratialité* à l’espace institutionnel. Dans les
 
 Dans les logiques environnementales, la *cratialité* peut prendre la forme de barrières physiques (clôtures, canaux), d’interdictions de prélèvement, de modulations de quota, de déclencheurs de dispositifs d’alerte. De sorte qu’un niveau de pollution franchi peut suspendre le trafic, rediriger des flux, interdire l’usage d’une zone — par l’effet combiné d’instruments de mesure, de seuils préprogrammés et de dispositifs de verrouillage. Cette régulation ne suppose ni acteur visible ni débat public. Elle agit par chaîne. Et c’est cette chaîne — non sa justification — qui par exemple constitue le *régime cratial* de la gestion écologique — dans les faits.
 
-On retrouve ce même mécanisme dans les mécanismes migratoires : un dispositif de visa, un fichier de police, une fermeture administrative, une alerte biométrique, un fichier d’exclusion partagé de ressortissants entre États. Chacun de ces gestes — souvent silencieux, parfois automatisé — transforme l’état d’un sujet sans jamais apparaître comme une décision. Il ne s’agit pas d’arbitraire, mais de *cratialité brute et opaque* : une régulation agissant par action différée, sans scène, sans fondement explicite.
+On retrouve ce même mécanisme dans les mécanismes migratoires : un dispositif de visa, un fichier de police, une fermeture administrative, une alerte biométrique, un fichier d’exclusion partagé de ressortissants entre États. Chacun de ces gestes — souvent silencieux, parfois automatisé — transforme l’état d’un sujet sans jamais apparaître comme une décision. Il ne s’agit pas d’arbitraire, mais de *cratialité brute et opaque* : une régulation agissant par action différée, à scène neutralisée ou relocalisée, et à fondement implicite, euphémisé ou difficilement exposable.
 
 Le problème fondamental n’est donc pas à nos yeux de savoir si une régulation est automatisée ou humaine, numérique ou analogique. Ce qui importe, c’est la morphologie de la chaîne d’effectuation : *peut-on en reconstituer les étapes ? Qui ou qu’est-ce qui a agi durant celles-ci ? Au nom de quoi ? Quelles ont été concrètement les actions conduites ? Quels en ont été leurs effets ? Au profit ou au détriment de qui ? Existe-t-il des seuils de suspension ? des marges de correction ? des points d’interruption ?* Voilà autant de questions qui constituent la tenue d’une enquête sur la *cratialité*. C’est ce à quoi le paradigme archicratique s’attèle, et ce qu’elle entend *in fine* saisir : une topologie factuelle des régimes opératoires prise dans des situations effectives.
 
@@ -1418,11 +1397,11 @@ Il y a ensuite les *scènes retournées*, plus pernicieuses encore. Celles-ci ne
 
 Autre figure : la *scène saturée*. Ici, le dysfonctionnement ne vient pas de l’absence, mais de l’excès non médié. Trop d’accès, pas de filtrage, pas de traduction. Trop de voix, pas d’écoute structurée. Trop d’injonctions, pas de temporalité. La scène devient invivable : le volume d’interpellation y déborde toute capacité de traitement, la comparution s’y dilue dans le chaos, la réversibilité devient illisible. Ce sont les grandes plateformes numériques d’évaluation, les forums de “libre expression”, ou encore certaines réunions communautaires où tout le monde parle sans qu’aucune écoute mutuelle ne tienne. La scène donne lieu au vacarme. Le seuil d’entrée s’avère ouvert, mais l’agencement archicratique se voit détruit. La critique y meurt de sa propre profusion non canalisée.
 
-Plus troublante encore est la *scène spectrale*. Là, il ne s’agit plus d’un simulacre d’écoute ni d’un excès d’expression mais d’un ajournement indéfini. Le sujet n’est pas exclu ; il demeure suspendu. On lui dit : “bientôt”, “encore un peu de patience”, “votre demande est en cours de traitement”. Mais celui-ci ne vient jamais. La scène est invoquée, toujours repoussée, jamais tenue. C’est le règne de la régulation par la latence, où le temps devient instrument d’usure et d’effacement sans brutalité. Dans les politiques d’asile, dans les systèmes de demande de logement, dans les chaînes d’approbation administratives, on trouve ce type de *scènes spectrales* : le dossier est bien présent, mais ne trouve jamais place dans la scène. Ce qui est produit alors est une suspension sans mémoire, une attente sans comparution, une adresse sans réponse. Le différé se mue dès lors en forme de pouvoir.
+Plus troublante encore est la *scène spectrale*. Là, il ne s’agit plus d’un simulacre d’écoute ni d’un excès d’expression mais d’un ajournement indéfini. Le sujet n’est pas exclu ; il demeure suspendu. On lui dit : “bientôt”, “encore un peu de patience”, “votre demande est en cours de traitement”. Mais celui-ci ne vient jamais. La scène est invoquée, toujours repoussée, jamais tenue. C’est le règne de la régulation par la latence, où le temps devient instrument d’usure et d’effacement sans brutalité. Dans les politiques d’asile, dans les systèmes de demande de logement, dans les chaînes d’approbation administratives, on trouve ce type de *scènes spectrales* : le dossier est bien présent, mais ne trouve jamais place dans la scène. Ce qui est produit alors est une suspension sans mémoire, une attente à comparution différée jusqu’à l’inopérance, une adresse privée de réponse effectivement opposable. Le différé se mue dès lors en forme de pouvoir.
 
 Face à cela, il existe des régulations qui s’ajustent sans jamais organiser de nouvelles scènes. Ce sont les *formes post-interpellatives*. L’ordre y intègre la mémoire de scènes passées — plaintes, mobilisations, controverses — pour reconfigurer silencieusement ses opérations. On peut compter dans cette catégorie : un algorithme modifié sans annonce, un seuil déplacé sans justification, une interface ajustée après une vague de critiques. Il n’y a pas de comparution, mais une mémoire agissante. Ce n’est pas une archicration au sens strict, mais une archicratialisation par effet de sédimentation critique. Ce régime peut être fécond, mais aussi inquiétant, car il soustrait à la vue des concernés les litiges et les dérives établis : *qui contrôle que l’ajustement a bien eu lieu ?, qui mémorise la scène absente ?, qui peut rejouer l’interpellation si elle reste sans forme ?* La critique y est intégrée, donne lieu à évolution d’arcalités et de cratialités, mais la polémique est désamorcée.
 
-Par *archicratialisation*, nous désignons ce régime post-interpellatif par lequel une régulation intègre la mémoire d’épreuves passées (plaintes, controverses, mobilisations) sans pour autant rouvrir de scène : les critiques sédimentent et se transmutent silencieusement en ajustements d’*arcalité* (fondements, critères, axiomes) et de *cratialité* (procédures, seuils, algorithmes, interfaces), sans comparution, sans publicité, sans délai contradictoire nouvellement institué. L’*archicratialisation* n’est donc pas l’*archicration* (qui expose et oppose), mais son après-coup opératoire : une auto-réforme qui peut corriger, parfois avec finesse, tout en déplaçant hors scène le litige qui l’a rendue nécessaire ; d’où son ambivalence. Elle peut être féconde si elle demeure traçable et ré-ouvrable, mais devient inquiétante si elle neutralise la polémique en retirant aux concernés la possibilité d’une réinterpellation opposable.
+Par *archicratialisation*, nous désignons ce régime post-interpellatif par lequel une régulation intègre la mémoire d’épreuves passées (plaintes, controverses, mobilisations) sans pour autant rouvrir de scène effective : les critiques sédimentent et se transmutent silencieusement en ajustements d’*arcalité* (fondements, critères, axiomes) et de *cratialité* (procédures, seuils, algorithmes, interfaces), sans comparution véritablement praticable, sans publicité opposable, sans délai contradictoire nouvellement institué et opérant. L’*archicratialisation* n’est donc pas l’*archicration* (qui expose et oppose), mais son après-coup opératoire : une auto-réforme qui peut corriger, parfois avec finesse, tout en déplaçant hors scène le litige qui l’a rendue nécessaire ; d’où son ambivalence. Elle peut être féconde si elle demeure traçable et ré-ouvrable, mais devient inquiétante si elle neutralise la polémique en retirant aux concernés la possibilité d’une réinterpellation opposable.
 
 Enfin, il existe ce que nous nommons les *contre-scènes auto-organisées*, ou *pré-archicrations*. Là, ce n’est plus l’ordre institué qui ouvre une scène, mais les sujets eux-mêmes qui la fabriquent, à même leurs expériences. Ce sont des collectifs d’écoute mutuelle, des cercles d’entraide communautaire, des réunions de colocataires qui instituent des modalités de parole, de suspension, de reconnaissance, de réparation. Ces scènes ne contestent pas toujours l’ordre en bloc : elles déploient un à-côté, un écart, une grammaire marginale de la régulation. Elles tissent leurs propres conditions de comparution, de mémoire, de reprise — et parfois, dans un second temps, elles viennent frapper à la porte de l’institution pour l’obliger à s’ajuster.
 
@@ -1456,7 +1435,7 @@ Elle est ce qui empêche l’ordre de se refermer dans la tautologie de ses prop
 
 ## **Conclusion du chapitre 1 — La théorie archicratique : régulation politique, plasticité critique et scène de requalification**
 
-Le paradigme archicratique ne se présente ni comme une doctrine politique parmi d’autres, ni comme une méthode normative de classement des régimes. Il n’ajoute pas une théorie supplémentaire à celles de la souveraineté, de la gouvernance ou de l’autorité. Ce qu’il propose, c’est un cadre d’intelligibilité critique, ancré dans une grammaire morphologique du politique qui ne repose ni sur des catégories fixes, ni sur une logique de fondement ultime. Il s’agit d’un *outillage rigoureux pour rendre lisibles les formes concrètes de la régulation, dans leur articulation spécifique entre arcalité, cratialité et archicration dans des contextes tout à fait situés*.
+Cette conclusion ne referme pas une doctrine ; elle resserre les conditions sous lesquelles le paradigme archicratique peut valoir comme cadre d’intelligibilité critique du politique. Il ne s’ajoute ni comme typologie supplémentaire, ni comme méthode normative de classement des régimes ; il propose un outillage morphologique pour rendre lisibles les formes concrètes de la régulation dans l’articulation située de l’arcalité, de la cratialité et de l’archicration.
 
 Le paradigme archicratique n’impose pas une grille préexistante à des réalités déjà constituées ; il permet d’analyser, depuis leurs tensions propres, les manières dont ces réalités se composent, se désarticulent, se reconfigurent. En ce sens, il relève d’une dynamique transductive, au sens où chaque régulation est saisie non comme un objet figé, mais comme une configuration en devenir, traversée de forces, de seuils, de mémoires et de requalifications. La transduction, ici, ne désigne pas un raisonnement par analogie (au sens psychologique), mais un processus d’individuation progressive, au contact des tensions internes d’un système. Le paradigme ne se veut pas surplombant mais co-engendré par les régimes qu’il examine.
 
@@ -1476,7 +1455,7 @@ Dans cette perspective, l’*archicratie* devient la forme intelligible de cette
 
 C’est en ce sens qu’il s’agit d’un paradigme non pas normatif, mais épistémologiquement productif. Il ne dit pas ce que doit être un bon régime : il rend lisible ce qui rend une régulation habitable, amendable, transformable — et ce qui, à l’inverse, la ferme sur ses effets, la fige dans ses gestes, la condamne à se répéter et à terme à péricliter. Il propose une forme critique non doctrinale, une manière d’identifier des seuils, de qualifier des scènes, de repérer des tensions, sans présumer a priori d’un idéal de société. En cela, il s’adresse autant à des régimes démocratiques qu’à des régulations algorithmiques, à des dispositifs communautaires qu’à des configurations bureaucratiques. C’est un instrument d’écoute morphologique, un opérateur d’exposition et de traduction entre ce qui agit et ce qui peut être corrigé.
 
-Mais cette productivité critique engage aussi une exigence : si un régime se donne à lire archicratiquement, alors il accepte d’être adressé, de comparaître, d’être reconfiguré depuis ce qu’il fait. Et c’est là, précisément, que la valence politique du paradigme se précise. Car un pouvoir peut bien se proclamer légitime, équitable, nécessaire — il ne devient habitable que s’il peut être mis à l’épreuve de sa propre scène. La *scène archicrative*, au cœur du paradigme, est ce lieu où le pouvoir ne s’effondre pas quand il est exposé : il s’y rend recevable. Il y gagne en consistance ce qu’il perd en clôture. Il y devient politique non par proclamation, mais par acceptation de sa propre reformulation.
+Mais cette productivité critique engage aussi une exigence : si un régime se donne à lire archicratiquement, alors il accepte d’être adressé, de comparaître, d’être reconfiguré depuis ce qu’il fait. Et c’est là que la valence politique du paradigme se précise. Cette précision n’érige pas l’archicratie en idéal normatif préalable ; elle indique seulement le seuil à partir duquel une régulation cesse d’être purement fonctionnelle pour devenir politiquement habitable. Car un pouvoir peut bien se proclamer légitime, équitable, nécessaire — il ne devient habitable que s’il peut être mis à l’épreuve de sa propre scène. La *scène archicrative*, au cœur du paradigme, est ce lieu où le pouvoir ne s’effondre pas quand il est exposé : il s’y rend recevable. Il y gagne en consistance ce qu’il perd en clôture. Il y devient politique non par proclamation, mais par acceptation de sa propre reformulation.
 
 Il fallait dès lors que cette modélisation ne se contente pas d’une intuition politique, d’un geste polémique, ou d’un effet d’annonce critique. Elle devait pouvoir fonder une validité épistémologique solide, à même de garantir que la grille archicratique ne dérive ni en système doctrinaire, ni en méthodologie molle. C’est à cette exigence que ce premier chapitre a voulu répondre, en établissant les conditions épistémologiques, morphologiques et fonctionnelles d’un paradigme rigoureux — autrement dit : sa possibilité scientifique, sa cohérence structurale et son opérabilité critique.
 
@@ -1518,8 +1497,8 @@ Dans cette optique, le chapitre 2 constituera l’épreuve originelle. En retra
 
 Ce qui s’ouvre alors est un laboratoire de différenciation régulatrice. Le paradigme archicratique, tel qu’il a été posé ici dans sa topologie formelle, trouvera dans le chapitre 2 les premières scènes d’épreuve de sa pertinence différentielle : il y montrera qu’il est capable de rendre intelligible ce qui varie réellement d’un régime à l’autre — selon la manière dont il fonde, opère, ou se laisse interroger. Loin d’imposer ses catégories, il s’y laissera *moduler* par les formes historiques, dans une dynamique de transduction critique : non pour valider son propre appareil conceptuel, mais pour en éprouver les seuils, les écarts, les tensions fécondes.
 
-Car si l’*arcalité* ne précède pas toujours la *cratialité*, si la scène d’*archicration* n’est pas partout instituée, si certaines *co-viabilités* se tiennent sans fondement explicite, sans suspension déclarée, sans mémoire stabilisée, alors il faut reconnaître que le paradigme ne détermine pas les régimes qu’il analyse : il s’expose à leur complexité. Il n’est pas un moule, mais un geste de lecture — une manière de faire apparaître les points de tension, de redistribution et de transformation. Le chapitre 2 montrera alors comment des configurations archaïques ou proto-politiques, souvent considérées comme « pré-étatiques », témoignent en réalité de formes complexes de régulation différée, de justification rituelle, d’adresse symbolique, de seuils narratifs ou d’épreuves collectives. Il révélera que l’*archicration* ne coïncide pas nécessairement avec la démocratie formelle, pas plus que la *cratialité* avec la souveraineté étatique, ni l’*arcalité* avec la seule Loi écrite : les régimes de viabilité se sont déployés à travers des architectures plus hétérogènes, plus fragiles, plus inventives qu’on ne le suppose.
+Car si l’arcalité ne précède pas toujours la cratialité, si la scène d’archicration n’est pas partout formellement instituée, si certaines co-viabilités se soutiennent à travers des fondements implicites, des suspensions peu codifiées ou des mémoires faiblement stabilisées, alors il faut reconnaître que le paradigme ne détermine pas les régimes qu’il analyse : il s’expose à leur complexité. Il n’est pas un moule, mais un geste de lecture — une manière de faire apparaître les points de tension, de redistribution et de transformation. Le chapitre 2 montrera alors comment des configurations archaïques ou proto-politiques, souvent considérées comme « pré-étatiques », témoignent en réalité de formes complexes de régulation différée, de justification rituelle, d’adresse symbolique, de seuils narratifs ou d’épreuves collectives. Il révélera que l’archicration ne coïncide pas nécessairement avec la démocratie formelle, pas plus que la cratialité avec la souveraineté étatique, ni l’arcalité avec la seule Loi écrite : les régimes de viabilité se sont déployés à travers des architectures plus hétérogènes, plus fragiles, plus inventives qu’on ne le suppose.
 
 C’est donc une archéologie morphologique qui s’ouvrira. Non pas pour remonter à un commencement, mais pour différencier les formes premières de régulation tenue, et ainsi éprouver en retour — par contraste, par confrontation, par amplification — la validité opératoire du paradigme archicratique. Car ce n’est qu’en le confrontant à ces régimes situés qui n’avaient pas encore nos institutions, nos catégories, ni nos grammaires politiques, que nous pourrons établir qu’il s’agit bien d’un paradigme de lecture différenciateur, et non d’un système normatif reconduit à rebours.
 
-Ainsi se clôt ce chapitre 1 : non dans la certitude d’un modèle à dérouler, mais dans l’ouverture d’un champ d’épreuve critique. Car si l’*archicration*, comme nous l’avons montré, constitue bien la condition d’habitabilité d’un ordre, alors c’est aussi elle qui nous oblige à interroger chaque régulation depuis ses effets, ses manques, ses devenirs, et non depuis nos catégories héritées. Ce que le chapitre 2 vient éprouver, c’est donc moins l’origine du paradigme que sa capacité à rendre compte, sans réduction, des formes historiques de la viabilité collective, autrement dit, sa *co-viabilité*.
+Ainsi se clôt ce chapitre 1 : non dans la certitude d’un modèle à dérouler, mais dans l’ouverture d’un champ d’épreuve critique. Car si l’archicration constitue bien la condition d’habitabilité d’un ordre, encore faut-il reconnaître qu’elle ne se donne pas partout sous la forme d’une scène pleinement formalisée, stable ou juridiquement instituée. Elle peut être diffuse, rituelle, intermittente, faiblement codifiée ; mais partout où elle est durablement neutralisée, vidée de sa prise, relocalisée hors d’atteinte ou rendue pratiquement inopérante, la régulation se ferme, devient indisponible à ses affectés et compromet sa propre co-viabilité. C’est pourquoi chaque ordre doit être interrogé depuis les formes concrètes par lesquelles il rend ses décisions, ses justifications et ses tensions exposables, discutables et révisables, plutôt que depuis nos seules catégories héritées. Ce que le chapitre 2 vient alors éprouver, ce n’est pas l’origine pure du paradigme, mais sa capacité à rendre compte, sans réduction, de la diversité historique des formes de viabilité collective — autrement dit, de leur co-viabilité.

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

@@ -12,6 +12,8 @@ source:
   kind: docx
   path: "sources/docx/archicrat-ia/Chapitre_2–Archeogenese_des_regimes_de_co-viabilite-version_officielle.docx"
 ---
+# **Chapitre 2 – Archéogenèse des régimes de co-viabilité**
+
 À ce stade de notre essai, l’*archicratie* a été définie, formalisée et modélisée comme une *structure dynamique de co-viabilité tensionnelle*, articulant trois pôles fondamentaux : l’*arcalité* (ce qui fonde), la *cratialité* (ce qui opère) et l’*archicration* (ce qui régule). Le chapitre 1 a montré que l’*archicratie* n’est pas une fiction idéologique ni une utopie normative, mais un système intelligible, repérable, heuristique et herméneutique. Ce système, avons-nous démontré, constitue un *régime d’intelligibilité politique générale*, susceptible d’unifier les lectures hétérogènes du pouvoir, de la gouvernance, de l’organisation sociale et de la dynamique historique.
 
 Mais toute théorie du politique qui se veut universelle doit, pour être complète, affronter le sol rugueux de l’empirique. C’est précisément ce que vise ce deuxième chapitre. Ici, le centre de gravité se déplace de l’épistémologique vers l’historique, du théorique vers l’archéologique, de l’abstraction vers la sédimentation. Il s’agit de retracer, sur la longue durée, la manière dont les sociétés humaines ont historiquement construit, adopté, incarné, ritualisé, sacralisé, scripturalisé, technicisé et algorithmisé leurs dispositifs de régulation.
@@ -64,19 +66,19 @@ Il ne s’agit pas de reconstruire une chronologie historique, mais de mettre au
 
 Nous allons donc développer une typologie en cinq profils de régulation archicratique, chacun incarnant une logique d’agencement particulière entre les trois vecteurs fondamentaux du pouvoir régulateur. Ces cinq formes sont :
 
-- L’*archicratie proto-symbolique*, caractéristique des sociétés paléolithiques ou dites « à mémoire vive », où la co‑viabilité repose sur l’incorporation rituelle, la mémoire affective et la structuration mimétique des appartenances ;
+- L’archicratie proto-symbolique, caractéristique des sociétés paléolithiques ou dites « à mémoire vive », où la co-viabilité repose sur l’incorporation rituelle, la mémoire affective et la structuration mimétique des appartenances ;
 
 
 
-- L’*archicratie sacro‑institutionnelle*, propre aux sociétés religieuses ou théocratiques, dans lesquelles l’invisible structure le visible et où l’autorité se différencie radicalement de la souveraineté ;
+- L’archicratie sacro-institutionnelle, propre aux sociétés religieuses ou théocratiques, dans lesquelles l’invisible structure le visible et où l’autorité se différencie radicalement de la souveraineté ;
 
 
 
-- L’*archicratie techno‑logistique*, fondée sur l’idée de mégamachine, dans laquelle la coordination impersonnelle précède le commandement et où les flux prennent le pas sur les figures ;
+- L’archicratie techno-logistique, fondé sur l’idée de mégamachine, dans laquelle la coordination impersonnelle précède le commandement et où les flux prennent le pas sur les figures ;
 
 
 
-- L’*archicratie scripturo‑normative*, qui institue la norme dans l’écrit, fait de l’archive un vecteur d’autorité différée, et de la procédure un opérateur de légitimation ;
+- L’archicratie scripturo-normative, qui institue la norme dans l’écrit, fait de l’archive un vecteur d’autorité différée, et de la procédure un opérateur de légitimation ;
 
 
 
@@ -88,11 +90,11 @@ Nous allons donc développer une typologie en cinq profils de régulation archic
 
 
 
-- L’*archicratie historiographique*, qui fonde la légitimité sur l’activation d’un récit collectif institué, consigné dans des textes‑repères, et réactualisé par des protocoles publics de lecture, de commémoration ou de transmission. L’ordre y repose sur la fidélité narrative à une mémoire partagée, toujours réécrite et rituellement réactivée ;
+- L’archicratie historiographique, qui fonde la légitimité sur l’activation d’un récit collectif institué, consigné dans des textes-repères, et réactualisé par des protocoles publics de lecture, de commémoration ou de transmission. L’ordre y repose sur la fidélité narrative à une mémoire partagée, toujours réécrite et rituellement réactivée ;
 
 
 
-- L’*archicratie épistémique*, dans laquelle l’autorité procède de la preuve, de la démonstration et de la formalisation objective, et où la co‑viabilité se construit par la validation critique, la reproductibilité et la neutralisation des points de vue dans un espace de raison partagée ;
+- L’archicratie épistémique, dans laquelle l’autorité procède de la preuve, de la démonstration et de la formalisation objective, et où la co-viabilité se construit par la validation critique, la reproductibilité et la neutralisation des points de vue dans un espace de raison partagée ;
 
 
 
@@ -120,7 +122,7 @@ Ce que nous appelons ici *régulation proto-symbolique* ne désigne pas une phas
 
 Il s’agit ici de montrer, à partir de données archéologiques certifiées et d’analyses anthropologiques convergentes, que ces sociétés ont su distribuer des formes et des forces dans des configurations stables, différenciées et évolutives. L’*archicratie*, dans ce cadre, constitue le politique en régime d’apparition, dès lors que le collectif humain suspend la violence, institue un seuil et met en forme ce qui pourrait dissoudre le lien. C’est cette grammaire que nous allons maintenant déplier dans quelques figures concrètes, ancrées dans les sols, les corps et les signes du Paléolithique.
 
-Les *sépultures* paléolithiques, au-delà de représenter des gestes d’inhumation, sont les premières scènes différées où la communauté s’éprouve elle‑même comme sujet régulé. Là où l’animal abandonne ou dissimule la dépouille, l’humain préhistorique institue un lieu, un temps, un geste : il fait du corps éteint un point de passage, un opérateur d’ordre. Les archéologues qui ont rouvert ces tombes ont trouvé la trace d’une grammaire structurée de la mémoire, où se tissent les trois prises de l’*archicratie* : le fondement (*arcalité*), la puissance agissante (*cratialité*) et la mise en scène (*archicration*).
+Les sépultures paléolithiques, au-delà de représenter des gestes d’inhumation, sont les premières scènes différées où la communauté s’éprouve elle-même comme sujet régulé. Là où l’animal abandonne ou dissimule la dépouille, l’humain préhistorique institue un lieu, un temps, un geste : il fait du corps éteint un point de passage, un opérateur d’ordre. Les archéologues qui ont rouvert ces tombes ont trouvé la trace d’une grammaire structurée de la mémoire, où se tissent les trois prises de l’archicratie : le fondement (arcalité), la puissance agissante (cratialité) et la mise en scène (archicration).
 
 Découvert en 1955 à l’est de Moscou, le site de Sungir (culture gravettienne) a livré deux sépultures exceptionnelles : un adulte et deux enfants âgés d’environ dix ans, inhumés tête‑bêche, leurs corps couverts de plus de 10 000 perles d’ivoire de mammouth finement taillées, accompagnées de pointes en os, de disques et de bracelets (Trinkaus & Buzhilova, 2018). Les analyses isotopiques ont montré qu’un même groupe d’individus a consacré des centaines d’heures à la fabrication des parures caractérisant un travail collectif différé, un investissement rituel sans finalité utilitaire.
 
@@ -130,7 +132,7 @@ En termes archicratiques, Sungir manifeste une *arcalité saturée* de signes
 
 En Moravie, à Dolní Věstonice, une triple sépulture datée de 28 000 ans (Svoboda, 2015) présente trois jeunes individus déposés côte à côte, orientés vers l’est, l’un partiellement recouvert d’ocre rouge, les mains croisées sur le bassin. Autour, un vaste habitat de huttes semi‑souterraines, des fours d’argile, et des figurines animales et humaines — dont la célèbre Vénus en terre cuite, l’une des plus anciennes céramiques connues.
 
-Olga Soffer y lit une « invention de la symbolisation partagée » : la céramique — objet de régulation — est un moyen de fixer, de différer et de transformer le geste collectif. Dans cette configuration, la *cratialité* se manifeste dans la fabrication (la main, la chaleur, la matière), l’*arcalité* dans la codification du lieu et des orientations, l’*archicration* dans la cérémonie funéraire elle‑même, qui lie le feu, l’ocre et le corps pour donner forme à la perte.
+Olga Soffer y lit une « invention de la symbolisation partagée » : la céramique — objet de régulation — est un moyen de fixer, de différer et de transformer le geste collectif. Dans cette configuration, la cratialité se manifeste dans la fabrication (la main, la chaleur, la matière), l’arcalité dans la codification du lieu et des orientations, l’archicration dans la cérémonie funéraire elle-même, qui lie le feu, l’ocre et le corps pour donner forme à la perte.
 
 Alain Testart (*Critique du don*, 2007, p. 83‑90), quant à lui, rappelle que l’ocre et le feu appartiennent au même champ symbolique de la transformation : « on ne rend pas la vie, on la traduit ». Ici, la traduction devient scène de régulation, où la société se confronte à la finitude en la modulant rituellement.
 
@@ -359,7 +361,7 @@ Ce qui nous intéresse alors, c’est leur puissance de modulation du lien, leur
 
 En cela, ces méta-régimes sacrés sans État nous lèguent une leçon politique d’une rare intensité : l’ordre n’est pas toujours là où on croit le voir. Il peut résider dans ce qui ne se montre pas, dans ce qui ne se dit pas, dans ce qui ne se décide pas — mais qui se manifeste, se transmet, se déploie à travers une constellation rituelle de formes, de rythmes, de paroles et de silences partagés. Et c’est cette grammaire spécifique que nous reconnaissons aussi dans notre paradigme comme *archicratique* : un pouvoir qui peut se donner sans accaparement, qui peut régler sans règne et qui peut moduler sans imposition.
 
-Cette compréhension est absolument capitale pour notre théorie : elle montre que la mise en ordre rituelle, différée, symbolique — sans instance souveraine — est historiquement attestée et empiriquement documentée. Elle éclaire, par contraste, les dispositifs contemporains de régulation distribuée — algorithmes, consensus décentralisés, structures non-hiérarchiques — qui, sans en reproduire la forme sacrale, en partagent une proximité structurelle : une orchestration de la *co‑viabilité* sans pouvoir constitué et centralisé.
+Cette compréhension est absolument capitale pour notre théorie : elle montre que la mise en ordre rituelle, différée, symbolique — sans instance souveraine — est historiquement attestée et empiriquement documentée. Elle éclaire, par contraste, les dispositifs contemporains de régulation distribuée — algorithmes, consensus décentralisés, structures non-hiérarchiques — qui, sans en reproduire la forme sacrale, en partagent une proximité structurelle : une orchestration de la co-viabilité sans pouvoir constitué et centralisé.
 
 Tableau de synthèse — régulation sacrée non-étatique
 
@@ -521,7 +523,7 @@ Tableau de synthèse — *Mégamachines : régulation techno-logistique*
 | **Standards métriques et calendaires** (unités de poids, de volume, calendriers) | Harmonisation des flux et des cycles | Archicration métrique et cyclique | Mesure comme opérateur d’universalité logistique | Temporisation des gestes, régulation des cadences | Compatibilité des rythmes, régularité des échanges, fluidité opératoire |
 | **Agencements opératoires** (plans urbains, séquençage des tâches, structures productives) | Séquençage et optimisation des fonctions sociales | Archicration procédurale par compatibilité structurelle | Organisation géométrique des espaces, circulation modulée | Répartition des efforts, cadencement des énergies | Co-viabilité par interopérabilité des segments et synchronisation des gestes |
 
-Ce tableau synthétique met en lumière, la spécificité du régime techno-logistique en tant que forme historique pleinement archicratique. Chaque composante fonctionnelle y est à la fois opérateur de d’*archicration*, vecteur d’*arcalité* ou de *cratialité*, et inducteur d’une forme de *co-viabilité* calibrée, extensible et durable. Ce qui frappe ici, c’est que la régulation ne réside plus dans une figure, un récit ou un interdit, mais dans l’*agencement fonctionnel des dispositifs* — des murs, des outils, des axes, des calculs, des activités — dont l’*efficacité performative* suffit à assurer la pérennité du lien collectif. En cela, la *mégamachine* cristallise une mutation ontopolitique majeure puisque la régulation opère ici par infrastructure, par ordre distribué et par opérationnalité. Ce modèle constitue un archétype régulateur autonome, dont la fécondité heuristique sera déterminante pour la suite de notre enquête archicratique.
+Ce tableau synthétique met en lumière, la spécificité du régime techno-logistique en tant que forme historique pleinement archicratique. Chaque composante fonctionnelle y est à la fois opérateur d’archicration, vecteur d’arcalité ou de cratialité, et inducteur d’une forme de co-viabilité calibrée, extensible et durable. Ce qui frappe ici, c’est que la régulation ne réside plus dans une figure, un récit ou un interdit, mais dans l’agencement fonctionnel des dispositifs — des murs, des outils, des axes, des calculs, des activités — dont l’efficacité performative suffit à assurer la pérennité du lien collectif. En cela, la mégamachine cristallise une mutation ontopolitique majeure puisque la régulation opère ici par infrastructure, par ordre distribué et par opérationnalité. Ce modèle constitue un archétype régulateur autonome, dont la fécondité heuristique sera déterminante pour la suite de notre enquête archicratique.
 
 ### 2.2.4 — *Archicrations scripturo-normatives*
 
@@ -623,7 +625,7 @@ Cela signifie que la vérité régulatrice repose sur une configuration et une c
 
 C’est cette temporalité non linéaire stratifiée qui permet au système d’absorber les conflits sans rupture systémique : à tout litige peut correspondre une trace antérieure à requalifier, un précédent à convoquer ou un statut à préciser. Les énoncés deviennent ainsi matrices de référence et de continuité normative, non pas parce qu’ils imposent, mais parce qu’ils permettent la reprise, la comparaison et la relance sous couvert d’égalité formelle de traitement.
 
-Cette capacité d’adaptation, de souplesse et de requalification confère à la régulation *scripturo-normative* une forme de plasticité procédurale : il peut fonctionner dans des contextes à faible centralisation étatique, dans des systèmes plusieurs statuts, ou même dans des structures palatiales partiellement disjointes. Il suffit qu’existe une infrastructure d’écriture, de classement et d’activation pour que la *co-viabilité* soit maintenue. Et de fait, comme le prouvent les travaux récents de Piotr Michalowski (*The Correspondence of the Kings of Ur*, 2006), certaines cités sumériennes parvenaient à articuler des réseaux de reconnaissance sans administration hiérarchique forte, mais avec une chaîne de tablettes, de messagers et d’archives interreliées.
+Cette capacité d’adaptation, de souplesse et de requalification confère à la régulation *scripturo-normative* une forme de plasticité procédurale : il peut fonctionner dans des contextes à faible centralisation étatique, dans des systèmes à plusieurs statuts, ou même dans des structures palatiales partiellement disjointes. Il suffit qu’existe une infrastructure d’écriture, de classement et d’activation pour que la *co-viabilité* soit maintenue. Et de fait, comme le prouvent les travaux récents de Piotr Michalowski (*The Correspondence of the Kings of Ur*, 2006), certaines cités sumériennes parvenaient à articuler des réseaux de reconnaissance sans administration hiérarchique forte, mais avec une chaîne de tablettes, de messagers et d’archives interreliées.
 
 Ce régime ne suppose donc pas une verticalité absolue. Il peut opérer latéralement, par circulation des documents, par interconnexion des archives, par activation circonstanciée des écrits. Il s’agit d’une architecture de reconnaissance, dont les piliers sont des fragments de texte, des sceaux, des signatures, des clauses, des lieux de dépôt. Ce que la *co-viabilité* gagne ici, c’est une forme de stabilité dans l’ajustement différé, une régulation qui n’impose pas d’uniformité, mais qui encadre la pluralité des situations dans un maillage d’inscriptions mobilisables.
 
@@ -1045,15 +1047,15 @@ Cette ambivalence entre narration structurante et analyse réflexive s’incarne
 
 Cette méthode, fondée sur l’enquête (*historia*), ne relève pas encore de la critique moderne, mais elle constitue un moment décisif de l’*archicration* : en confrontant plusieurs récits, Hérodote produit un lieu de régulation où ce qui peut être retenu comme histoire devient objet de débat, de composition, voire de hiérarchisation. Il ne s’agit pas seulement de transmettre un récit fondateur, mais de rendre possible une régulation par confrontation de versions. En cela, Hérodote opère à la jonction entre l’activation de figures exemplaires (le courage des Spartiates, la ruse d’Ulysse) et l’*archicration* des récits divergents (sur les origines du conflit, la nature du pouvoir perse ou les mœurs des Scythes).
 
-Dans tous ces cas, l’archicration historiographique ne se confond ni avec la censure, ni avec un acte d’écriture. Elle suppose un dispositif de confrontation, un lieu de régulation, un arbitrage — explicite ou implicite — des formes narratives reconnues comme valides pour assurer la *co-viabilité* politique. celle-ci se donne à voir dans des lieux précis : la chancellerie où l’on compile les chroniques, la cour impériale où l’on statue sur les versions divergentes d’une conquête, l’académie où l’on débat des filiations légitimes, l’assemblée où l’on statue parfois sur ce qui doit être enseigné comme vérité officielle. Ces espaces sont des institutions de mémoire autorisée.
+Dans tous ces cas, l’archicration historiographique ne se confond ni avec la censure, ni avec un acte d’écriture. Elle suppose un dispositif de confrontation, un lieu de régulation, un arbitrage — explicite ou implicite — des formes narratives reconnues comme valides pour assurer la co-viabilité politique. Celle-ci se donne à voir dans des lieux précis : la chancellerie où l’on compile les chroniques, la cour impériale où l’on statue sur les versions divergentes d’une conquête, l’académie où l’on débat des filiations légitimes, l’assemblée où l’on statue parfois sur ce qui doit être enseigné comme vérité officielle. Ces espaces sont des institutions de mémoire autorisée.
 
-Cette histoire politique devient alors une sorte de grammaire en acte : on n’oblige pas en décrétant, mais en décidant collectivement quel passé fait autorité. Pour autant il serait erroné de réduire la fonction archicratique à la simple réactivation rituelle du passé. La normativité narrative naît de l’épreuve du débat régulateur. En effet, l’histoire ne contraint qu’en tant qu’elle a été validée par une instance — formelle ou diffuse — de mise en cohérence, d’arbitrage et de filtration mémorielle. L’*archicration historiographique* ne consiste donc pas à répéter, mais à décider ce qui, dans le passé raconté, continue de fonder la possibilité du vivre ensemble.
+Cette histoire politique devient alors une sorte de grammaire en acte : on n’oblige pas en décrétant, mais en décidant collectivement quel passé fait autorité. Pour autant, il serait erroné de réduire la fonction archicratique à la simple réactivation rituelle du passé. La normativité narrative naît de l’épreuve du débat régulateur. En effet, l’histoire ne contraint qu’en tant qu’elle a été validée par une instance — formelle ou diffuse — de mise en cohérence, d’arbitrage et de filtration mémorielle. L’*archicration historiographique* ne consiste donc pas à répéter, mais à décider ce qui, dans le passé raconté, continue de fonder la possibilité du vivre ensemble.
 
 Dans le méta-régime historiographique, l’autorité se perpétue surtout par une grammaire implicite de la légitimité, progressivement intériorisée par les figures de pouvoir, les élites dirigeantes, les héritiers du trône ou les gardiens de l’ordre social. Cette transmission relève d’une pédagogie de la souveraineté et d’une logique aristocratique : on apprend à gouverner en lisant l’histoire, on s’oriente dans le présent en relisant les gestes des fondateurs, on se légitime en s’inscrivant dans la lignée des précédents perçus ou reconnus comme exemplaires.
 
 Ce régime de régulation repose sur une codification implicite, dans laquelle le texte historique fonctionne comme miroir normatif — pour orienter, calibrer, formater les attentes liées à l’exercice du pouvoir. C’est pourquoi, dans de nombreuses traditions politiques, l’apprentissage du pouvoir passe par la lecture d’œuvres historiographiques tenues pour canoniques, organisées non comme savoirs passés, mais comme réservoirs de modèles opératoires à mobiliser.
 
-Cette transmission n’emprunte pas uniquement les voies du texte écrit ou de l’enseignement formel : elle peut aussi s’incarner dans des supports iconiques, rituels ou performatifs, qui assurent la continuité normative par d’autres formes de répétition régulatrice. Telles peuvent être le cas de fresques murales, stèles commémoratives, bas-reliefs dynastiques, chants narratifs ou cycles iconographiques. Ces dispositifs, bien qu’extra-textuels, structurent eux aussi des trames de légitimation fondées sur la mémoire séquencée. Ils contribuent à stabiliser visuellement ou rituellement les figures exemplaires, en les insérant publiquement dans une scénographie permanente du pouvoir hérité. En cela, ils participent pleinement de la *cratialité historiographique*, et parfois de son activation archicratique, dès lors que ces images ou récits chantés sont sélectionnés, ritualisés ou modifiés dans un cadre d’arbitrage politique.
+Cette transmission n’emprunte pas uniquement les voies du texte écrit ou de l’enseignement formel : elle peut aussi s’incarner dans des supports iconiques, rituels ou performatifs, qui assurent la continuité normative par d’autres formes de répétition régulatrice. Tel peut être le cas de fresques murales, stèles commémoratives, bas-reliefs dynastiques, chants narratifs ou cycles iconographiques. Ces dispositifs, bien qu’extra-textuels, structurent eux aussi des trames de légitimation fondées sur la mémoire séquencée. Ils contribuent à stabiliser visuellement ou rituellement les figures exemplaires, en les insérant publiquement dans une scénographie permanente du pouvoir hérité. En cela, ils participent pleinement de la *cratialité historiographique*, et parfois de son activation archicratique, dès lors que ces images ou récits chantés sont sélectionnés, ritualisés ou modifiés dans un cadre d’arbitrage politique.
 
 C’est pourquoi de nombreuses cultures recourent à des formes non textuelles d’historiographie — fresques murales, stèles commémoratives, chants épiques ou cycles iconographiques — pour insérer les figures exemplaires dans une scénographie publique du pouvoir hérité. Ces dispositifs visuels ou oraux ne transmettent pas simplement un souvenir : ils stabilisent, incarnent, et ritualisent la légitimité par la répétition figurative.
 
@@ -1174,7 +1176,7 @@ C’est pourquoi, à son niveau le plus abstrait, l’*arcalité épistémique*
 
 Comme l’écrivait Foucault dans *Les mots et les choses*, ce savoir est référentiel sans transcendance : il fonctionne par agencements, grilles, séries, catégories, sans appel à une révélation, un principe supérieur ou un ordre sacré. Il construit un régime d’objectivité qui fait obligation par sa structure, non par son origine.
 
-Il convient toutefois de noter que certains régimes de transmission orale, bien que rattachés à des méta-régimes théologiques ou cosmologiques (comme la récitation védique, les hadiths ou les canons bouddhiques), manifestent des degrés très élevés de formalisation cognitive : chaînes de validation orale, protocoles mnémotechniques, systèmes de correction. Ces dispositifs ne relèvent pas directement de l’*archicration épistémique*, mais en partagent certaines structures formelles : ils construisent des matrices d’ordre tout aussi rigoureuses, assurant une co‑viabilité cognitive sans inscription graphique. La parole y est régulée par des protocoles mnémotechniques, des chaînes de validation orale et des systèmes de correction collective. Ce sont là des formes d’*arcalité* formelle sans écriture, où la parole elle‑même devient structure.
+Il convient toutefois de noter que certains régimes de transmission orale, bien que rattachés à des méta-régimes théologiques ou cosmologiques (comme la récitation védique, les hadiths ou les canons bouddhiques), manifestent des degrés très élevés de formalisation cognitive : chaînes de validation orale, protocoles mnémotechniques, systèmes de correction. Ces dispositifs ne relèvent pas directement de l’archicration épistémique, mais en partagent certaines structures formelles : ils construisent des matrices d’ordre tout aussi rigoureuses, assurant une co-viabilité cognitive sans inscription graphique. La parole y est régulée par des protocoles mnémotechniques, des chaînes de validation orale et des systèmes de correction collective. Ce sont là des formes d’arcalité formelle sans écriture, où la parole elle-même devient structure.
 
 En cela, le savoir institué constitue une source d’ordre, à la manière d’un cosmos intellectuel. Il ne renvoie pas à un Dieu, à une Nature ou à une Loi, mais à une grammaire interne de cohérence, qui oblige parce qu’elle est reçue comme logique, opératoire et reproductible.
 
@@ -1218,7 +1220,7 @@ En Inde ancienne, un même processus de filtration s’opère à travers les éc
 
 Une autre forme d’*archicration épistémique* consiste dans l’opération de clôture canonique, c’est-à-dire la définition d’un corpus considéré comme recevable — par exclusion de ce qui est jugé erroné, apocryphe, ou non conforme. C’est ici que se joue le cœur normatif du régime : non pas transmettre tout ce qui est su, mais décider de ce qui mérite de l’être et d’exclure le reste.
 
-L’exemple de l’Académie de Platon (fondée vers 387 av. J.-C.) est, à cet égard, éclairant. Les dialogues de Platon ne forment pas à eux seuls un système, mais c’est au sein de l’Académie que va s’élaborer, par reprises, commentaires et enseignements, un canon de lectures platoniciennes, au détriment d’autres traditions concurrentes (pythagoricienne, sophistique, cynique). Ce que nous considérons aujourd’hui comme la « pensée platonicienne » est donc déjà un résultat archicratique : une sélection stabilisée, enseignée, réinterprétée dans un cadre d’autorité. Le savoir devient ainsi le lieu d’un arbitrage régulateur collectif, assurant la *co‑viabilité* cognitive des sociétés savantes.
+L’exemple de l’Académie de Platon (fondée vers 387 av. J.-C.) est, à cet égard, éclairant. Les dialogues de Platon ne forment pas à eux seuls un système, mais c’est au sein de l’Académie que va s’élaborer, par reprises, commentaires et enseignements, un canon de lectures platoniciennes, au détriment d’autres traditions concurrentes (pythagoricienne, sophistique, cynique). Ce que nous considérons aujourd’hui comme la « pensée platonicienne » est donc déjà un résultat archicratique : une sélection stabilisée, enseignée, réinterprétée dans un cadre d’autorité. Le savoir devient ainsi le lieu d’un arbitrage régulateur collectif, assurant la co-viabilité cognitive des sociétés savantes.
 
 Plus tard, au XIIIe siècle, l’université de Paris fournit un autre exemple majeur. Comme l’a montré Alain de Libera (*La philosophie médiévale*, 1993), le corpus aristotélicien avait alors fait l’objet d’une sélection et d’une régulation dans les facultés des arts et de théologie. Certains textes étaient interdits à l’enseignement, d’autres réservés à des commentaires précis. Le pouvoir ne s’exerce plus ici en interdisant l’accès aux livres, mais en fixant les modalités acceptables de leur usage — et donc, en orientant leur pouvoir régulateur.
 
@@ -1305,7 +1307,7 @@ Le régime épistémique moderne trouve son prolongement dans les formes contemp
 | **Appareils de validation** | Filtrer et formaliser la légitimité des savoirs transmis | *Archicration* de la reconnaissance (canon, exclusion, agrément) | Constitution de corpus clos, reconnaissance institutionnelle du vrai enseignable | Production de seuils cognitifs (examens, autorisations, habilitations) | Définition institutionnelle du dicible cognitif |
 | **Obligation cognitive** | Créer une forme d’adhésion sans coercition | Archicration par standardisation des formats de vérité | Obligation par structure (cohérence démonstrative, opérabilité logique) | Contrainte douce par régularité formelle et reproductibilité | Cohésion par alignement intellectuel, non par commandement explicite |
 
-L’*archicration épistémique* s’impose comme un régime autonome de régulation, où l’obligation ne procède ni d’un commandement transcendant, ni d’une mémoire collective, ni d’un récit dynastique, mais de la structuration formalisée du pensable. L’*arcalité* y repose sur l’objectivation du réel dans des corpus cohérents et transmissibles ; la *cratialité* s’y exerce par la maîtrise technique de ces systèmes par des figures lettrées, experts, scribes ou maîtres ; l’*archicration*, enfin, s’y manifeste à travers les dispositifs collectifs de certification, de canonisation, de sélection des interprètes autorisés et de filtrage des corpus valides. Ce régime fonde une *co-viabilité cognitive* non pas en prescrivant des comportements, mais en stabilisant des opérations mentales partagées. L’ordre y devient synonyme d’intelligibilité. En retour, cette co‑viabilité cognitive conditionne la co‑viabilité sociale puisque la société se maintient dans la mesure où ses acteurs partagent un langage commun de preuves, d’arguments et de raisons.
+L’archicration épistémique s’impose comme un régime autonome de régulation, où l’obligation ne procède ni d’un commandement transcendant, ni d’une mémoire collective, ni d’un récit dynastique, mais de la structuration formalisée du pensable. L’arcalité y repose sur l’objectivation du réel dans des corpus cohérents et transmissibles ; la cratialité s’y exerce par la maîtrise technique de ces systèmes par des figures lettrées, experts, scribes ou maîtres ; l’archicration, enfin, s’y manifeste à travers les dispositifs collectifs de certification, de canonisation, de sélection des interprètes autorisés et de filtrage des corpus valides. Ce régime fonde une co-viabilité cognitive non pas en prescrivant des comportements, mais en stabilisant des opérations mentales partagées. L’ordre y devient synonyme d’intelligibilité. En retour, cette co-viabilité cognitive conditionne la co-viabilité sociale puisque la société se maintient dans la mesure où ses acteurs partagent un langage commun de preuves, d’arguments et de raisons.
 
 Il existe un dernier méta-régime, tout aussi structurant, à traiter : l’*archicration esthético-symbolique*. Ici, l’efficacité régulatrice ne réside ni dans l’explication, ni dans la déduction, mais dans la capacité de certaines formes — visuelles, rythmiques, architecturales, stylistiques — à produire de l’adhésion, de l’évidence ou de l’ajustement. Celui-ci repose sur une économie des formes sensibles, où la régulation opère par saturation symbolique, par allégeance stylistique, par alignement affectif et émotionnel. Il ne se contente pas de transmettre un contenu : il façonne une atmosphère normative.
 
@@ -1329,7 +1331,7 @@ Un phénomène similaire, mais plus élaboré, se retrouve dans l’usage des ti
 
 Cette *arcalité* par la forme sensible s’incarne également dans les textiles à motifs normés, dans les cultures andines de Chavín, Paracas ou Nasca (900–200 av. J.-C.), où ils remplissaient une fonction de signalisation statutaire. Le vêtement y devient code social : chaque figure — zigzags, losanges, condors stylisés — n’est pas un simple ornement, mais une balise de visibilité sociale, comme l’a démontré Anne Paul dans ses travaux sur les textiles Paracas. La reconnaissance ne passe pas par l’individu, mais par l’agencement formel du tissu. L’adhésion naît du port du motif légitime : ce n’est pas le sens qui impose la forme, mais la conformité de la forme qui engendre la reconnaissance.
 
-Cette logique *esthético-symbolique* s’incarne également dans les gestes stylisés, les postures codifiées, les chorégraphies ritualisées. Dans de nombreuses sociétés anciennes, les danses collectives, les processions réglées ou les attitudes corporelles prescrites — comme le port du buste incliné, la marche hiérarchisée ou l’étirement des bras en croix — ne traduisent pas une habitude spontanée, mais un dispositif de régulation symbolique par l’ajustement rythmique des corps. On en trouve des attestations dans les frises cérémonielles de la vallée de l’Indus, dans les fresques de Beni Hasan (Égypte, Moyen Empire), ou dans les rituels dansés des sociétés andines. Le geste devient ici forme instituée, et la posture elle-même, une syntaxe silencieuse de la hiérarchie ou de la convenance. Il ne s’agit pas d’une chorégraphie libre, mais d’un langage gestuel chargé de régulation symbolique. Et cela, bien souvent, sans que les participants en aient une conscience articulée : les postures s’apprennent par immersion, les rythmes s’incorporent par mimétisme, et la justesse du geste se mesure moins à l’intention qu’à l’aisance à s’y conformer. La *co‑viabilité* naît alors de cette capacité collective à reproduire des intensités collectivement synchronisées, inscrites dans une grammaire sensorielle incorporée.
+Cette logique esthético-symbolique s’incarne également dans les gestes stylisés, les postures codifiées, les chorégraphies ritualisées. Dans de nombreuses sociétés anciennes, les danses collectives, les processions réglées ou les attitudes corporelles prescrites — comme le port du buste incliné, la marche hiérarchisée ou l’étirement des bras en croix — ne traduisent pas une habitude spontanée, mais un dispositif de régulation symbolique par l’ajustement rythmique des corps. On en trouve des attestations dans les frises cérémonielles de la vallée de l’Indus, dans les fresques de Beni Hasan (Égypte, Moyen Empire), ou dans les rituels dansés des sociétés andines. Le geste devient ici forme instituée, et la posture elle-même, une syntaxe silencieuse de la hiérarchie ou de la convenance. Il ne s’agit pas d’une chorégraphie libre, mais d’un langage gestuel chargé de régulation symbolique. Et cela, bien souvent, sans que les participants en aient une conscience articulée : les postures s’apprennent par immersion, les rythmes s’incorporent par mimétisme, et la justesse du geste se mesure moins à l’intention qu’à l’aisance à s’y conformer. La co-viabilité naît alors de cette capacité collective à reproduire des intensités collectivement synchronisées, inscrites dans une grammaire sensorielle incorporée.
 
 L’*arcalité esthético-symbolique* agit aussi par évidence partagée de la forme stabilisée. Le tracé récurrent, l’agencement bordant, la répétition chorégraphique, la gradation chromatique — tous participent d’un monde ordonné par la forme, où le visible devient vecteur de légitimité. Comme le souligne l’anthropologue britannique Tim Ingold, dans *Lines: A Brief History* (2007), les lignes que les sociétés tracent, dans l’espace, sur les objets ou sur les corps, ne délimitent pas seulement des zones : elles organisent les comportements. Elles prescrivent sans énoncer, elles disposent sans contraindre. Ces lignes ne sont pas uniquement des repères : elles activent une normativité perceptive qui conditionne la reconnaissance conjointe du convenable. Ce qui est perçu comme correct ne passe pas par le jugement, mais par l’ajustement du corps à une morphologie autorisée.
 
@@ -2776,7 +2778,7 @@ Si l’infrastructure machinique forme le soubassement matériel du méta-régim
 
 C’est ici qu’il nous faut reconfigurer le concept même d’*archicration*. Dans ses formes traditionnelles — juridiques, théologiques, bureaucratiques — la régulation procédait par inscription : lois, normes, rites, règles explicites, lisibles, opposables. L’*archicration téra-machinique*, elle, procède par anticipation silencieuse : *elle module au lieu de normer, elle prévient au lieu de contraindre*. Dans ce régime, le pouvoir n’a plus besoin d’interdire : il rend improbable, il redirige l’attention, il pré-filtre les possibles. Il n’émet pas de signal fort : il *corrige en amont*, par suggestion, par structuration de l’environnement. Ce que Deleuze, dans son célèbre *Post-scriptum sur les sociétés de contrôle* (1990), anticipait déjà comme la substitution du *moulage* disciplinaire par la *modulation* *continue* trouve ici son actualisation et sa plénitude. La modulation devient la forme propre de l’*archicration prédictive*, *mais en plus d’être continue, elle en devient discrète*.
 
-Les *algorithmes prédictifs* — qu’ils s’appliquent à la gestion des flux logistiques, à l’attribution de crédits bancaires, à la surveillance policière prédictive, à la prescription culturelle ou aux plateformes de recrutement — n’imposent pas, mais *orchestrent*. Ils régulent non pas par la règle, mais par le poids statistique du comportement probable. C’est là que réside la spécificité du pouvoir machinique : il repose sur l’agrégation des passés, sur la projection automatisée de futurs, sur l’optimisation probabiliste des présents. Cette orchestration prédictive n’est pas que politique ou cognitive : elle est également financière. Dans les méta-régimes *cybernético-calculatoires* contemporains, les algorithmes prédictifs s’insèrent dans des circuits d’anticipation économique — marchés de la donnée, monétisation du trafic attentionnel, rentabilisation des trajectoires comportementales. Ce que Shoshana Zuboff a nommé le *capitalisme de surveillance* (2019) n’est pas simplement un modèle marchand : c’est un méta-régime archicratique où la valeur est produite par la prédictibilité elle-même. Plus une conduite est modélisable, plus elle devient exploitable économiquement. Ainsi, la régulation algorithmique opère une fusion silencieuse entre *normativité adaptative* et *captation de valeur* : la *co-viabilité* devient , le social devient dérivé comportemental, la subjectivité devient matière première prédictive. La *temporalité archicratique* est ici transformée : le pouvoir ne s’exerce plus dans l’instant de la décision, mais dans la continuité d’un *temps anticipé*, *continuellement recalculé, potentiellement monétisable*.
+Les algorithmes prédictifs — qu’ils s’appliquent à la gestion des flux logistiques, à l’attribution de crédits bancaires, à la surveillance policière prédictive, à la prescription culturelle ou aux plateformes de recrutement — n’imposent pas, mais orchestrent. Ils régulent non pas par la règle, mais par le poids statistique du comportement probable. C’est là que réside la spécificité du pouvoir machinique : il repose sur l’agrégation des passés, sur la projection automatisée de futurs, sur l’optimisation probabiliste des présents. Cette orchestration prédictive n’est pas que politique ou cognitive : elle est également financière. Dans les méta-régimes cybernético-calculatoires contemporains, les algorithmes prédictifs s’insèrent dans des circuits d’anticipation économique — marchés de la donnée, monétisation du trafic attentionnel, rentabilisation des trajectoires comportementales. Ce que Shoshana Zuboff a nommé le capitalisme de surveillance (2019) n’est pas simplement un modèle marchand : c’est un méta-régime archicratique où la valeur est produite par la prédictibilité elle-même. Plus une conduite est modélisable, plus elle devient exploitable économiquement. Ainsi, la régulation algorithmique opère une fusion silencieuse entre normativité adaptative et captation de valeur : la co-viabilité devient elle-même un gisement de valorisation, le social devient dérivé comportemental, la subjectivité devient matière première prédictive. La temporalité archicratique est ici transformée : le pouvoir ne s’exerce plus dans l’instant de la décision, mais dans la continuité d’un temps anticipé, continuellement recalculé, potentiellement monétisable.
 
 Cette reconfiguration du pouvoir par la prédiction appelle à la convocation d’une autre penseuse majeure de notre époque : *Antoinette Rouvroy*, en collaboration avec *Thomas Berns*, a forgé le concept de *gouvernementalité algorithmique* (2009), qui constitue une des formulations les plus éclairantes de cette nouvelle archicration. Selon eux, l’algorithme ne cherche pas à produire de la subjectivité, mais au contraire à *court-circuiter* le sujet. Il ne s’adresse pas à des individus, mais à des profils, à des tendances statistiques, à des *corpus d’actions passées* devenus modèles opératoires. L’archicration n’est plus interpellation, mais *captation anonyme*. Elle est dé-subjectivante par essence, parce qu’elle opère dans l’inconscient computationnel du système, sans interaction réflexive.
 

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/archicrat-ia/prologue.mdx

@@ -12,26 +12,26 @@ source:
   kind: docx
   path: "sources/docx/archicrat-ia/Prologue—Archicratie-fondation_et_finalite_sociopolitique_et_historique-version_officielle.docx"
 ---
-Nous vivons dans une époque saturée de diagnostics sur les formes de domination, les mutations du pouvoir, les détournements de la souveraineté. Depuis une vingtaine d’années, les appellations s’accumulent : *démocratie illibérale*, *ploutocratie*, *happycratie*, *gouvernement algorithmique*, *démocrature*… À travers ces tentatives de nommer le désordre du présent, un fait se répète, de manière sourde : la scène politique semble désorientée. Les catégories héritées — *État*, *pouvoir*, *représentation*, *volonté générale*, *contrat social* — apparaissent de moins en moins capables de décrire ce qui nous gouverne effectivement.
+Nous vivons une époque saturée de diagnostics sur les formes de domination, les mutations du pouvoir, les détournements de la souveraineté. Depuis une vingtaine d’années, les appellations s’accumulent : *démocratie illibérale*, *ploutocratie*, *happycratie*, *gouvernement algorithmique*, *démocrature*… À travers ces tentatives de nommer le désordre du présent, un fait se répète, de manière sourde : la scène politique semble désorientée. Les catégories héritées — *État*, *pouvoir*, *représentation*, *volonté générale*, *contrat social* — apparaissent de moins en moins capables de décrire ce qui nous gouverne effectivement.
 
 C’est cette perte de prise sur le réel que ce livre souhaite prendre au sérieux. Non pour lui ajouter un terme de plus au lexique fatigué des contre-pouvoirs ou des impuissances, mais pour repartir d’un point plus fondamental, presque en-deçà de la question politique classique. Ce point, c’est celui de la *tenue d’un monde commun* — c’est-à-dire la possibilité, pour des êtres dissemblables, vulnérables, inégaux, traversés de contradictions et situés dans des temporalités hétérogènes, de coexister sans s’annihiler.
 
 Cette tenue du monde n’équivaut ni à la paix civile, ni à la stabilité des institutions, ni à l’ordre établi. C’est une difficulté conceptuelle que d’envisager *la possibilité pour un ordre de durer sans s’effondrer*, alors même qu’il est traversé en permanence par des forces et des légitimités qui le travaillent, l’éprouvent, le modifient, l’usent, le contestent, le prolongent ou le sapent. Cette possibilité de tenir le monde commun, nous la nommons *co-viabilité*.
 
-Le terme n’est pas trivial. Il ne s’agit pas simplement d’une viabilité partagée, ni d’une coexistence pacifique, ni même d’une durabilité écologique élargie. Il s’agit d’un état dynamique, instable, fragile, dans lequel un ensemble — une société, d’un système biologique, d’une formation historique, d’un milieu technique ou d’un monde institué — parvient à maintenir une *existence viable*, *malgré et grâce à ses tensions constitutives*.
+Le terme n’est pas trivial. Il ne désigne ni une simple viabilité partagée, ni une coexistence pacifiée, ni une durabilité écologique élargie. Il renvoie à la possibilité, toujours fragile, pour un monde hétérogène de maintenir une existence viable en travaillant, sans les abolir, les tensions qui le traversent.
 
-La *co-viabilité* ne désigne ni un état d’équilibre, ni une finalité normative. Elle nomme un état dynamique et instable, dans lequel un monde — société, milieu technique, formation historique — tient non pas par homogénéité ou harmonie, mais parce qu’il parvient à réguler ce qui le menace sans se détruire lui-même. Il compose entre des éléments hétérogènes — forces d’inertie et d’innovation, attachements profonds et ruptures nécessaires — sans chercher à les unifier. C’est cette disposition active, faite de compromis fragiles et d’ajustements toujours révisables, que nous tenons pour première, et non dérivée.
+La *co-viabilité* ne désigne ni un état d’équilibre, ni une finalité normative. Elle nomme un état dynamique et instable, dans lequel un ensemble — une société, un système biologique, une formation historique, un milieu technique ou un monde institué — tient non pas par homogénéité ou harmonie, mais parce qu’il parvient à réguler ce qui le menace sans se détruire lui-même. Il compose entre des éléments hétérogènes — forces d’inertie et d’innovation, attachements profonds et ruptures nécessaires — sans chercher à les unifier. C’est cette disposition active, faite de compromis fragiles et d’ajustements toujours révisables, que nous tenons pour première, et non dérivée.
 
-Ce qui revient à dire que la question politique — au sens fort — n’a peut-être jamais été qui commande ? Mais bien plus : *Comment un ordre tient-il malgré ce qui le défait ?* *Quels sont les dispositifs qui permettent à une société de ne pas se désagréger sous l’effet de ses propres contradictions ?* *Comment sont régulées les tensions qui traversent le tissu du monde commun sans le déchirer ?*  
-Cette bascule de perspective prolonge des intuitions anciennes. Max Weber (*Économie et société*, 1922) rappelait que ce qui fait tenir un ordre, ce n’est pas seulement la force ou la loi, mais les « chances de validité » socialement reconnues. Norbert Elias (*La dynamique de l’Occident*, 1939/1975) montrait, quant à lui, que les sociétés se maintiennent par des équilibres toujours précaires entre interdépendances, rivalités et pacifications. Notre démarche s’inscrit dans ce sillage : travailler cette interrogation sur les *conditions de viabilité d’un monde commun*.
+Ce qui revient à dire que la question politique — au sens fort — n’a peut-être jamais été : qui commande ? Mais, plus profondément : *Comment un ordre tient-il malgré ce qui le défait ?* *Quels sont les dispositifs qui permettent à une société de ne pas se désagréger sous l’effet de ses propres contradictions ?* *Comment sont régulées les tensions qui traversent le tissu du monde commun sans le déchirer ?*  
+Cette bascule de perspective prolonge des intuitions anciennes. Max Weber (*Économie et société*, 1922) rappelait que ce qui fait tenir un ordre, ce n’est pas seulement la force ou la loi, mais les « chances de validité » socialement reconnues. Norbert Elias (*La dynamique de l’Occident*, 1939/1975) montrait, quant à lui, que les sociétés se maintiennent par des équilibres toujours précaires entre interdépendances, rivalités et pacifications. Notre démarche s’inscrit dans ce sillage : travailler cette interrogation sur les *conditions de viabilité d’un monde commun*.
 
 Ce changement de perspective implique une rupture profonde dans la manière même de poser la question politique. Pendant des siècles, les sociétés ont pensé le politique à partir de principes transcendants — Dieu, Nature, Volonté générale, Pacte social. Ces principes, supposés extérieurs aux conflits du présent, garantissaient l’ordre en surplomb. Comme le rappelle Michel Foucault, il n’y a pas de principe extérieur au jeu des forces : seulement des rapports de pouvoir situés, modulés, réversibles. C’est précisément cette exigence — trouver dans les relations elles-mêmes les ressources nécessaires pour maintenir des mondes vivables — qui définit notre époque.
 
-Ce qui émerge n’est pas de nouveaux principes, ni une nouvelle idéologie, mais une exigence beaucoup plus modeste, mais aussi beaucoup plus difficile à satisfaire : celle de trouver dans les relations elles-mêmes — entre groupes, entre institutions, entre individus, entre temporalités — les ressources nécessaires pour maintenir leurs mondes viables. Autrement dit : c’est *dans* les tensions, *à même* les conflits, *au sein* des alliances, *au cœur* des désaccords et des polémiques, que semble se construire la régulation. Non plus *au-dessus*, par un décret transcendant, mais *au-dedans*, par un agencement toujours révisable. C’est cela que nous voulons dire — sans technicité inutile — quand nous parlons d’un déplacement vers une *instance de régulation située de co-viabilité* : un espace commun où les forces hétérogènes, souvent antagonistes, peuvent coexister, se contredire, se confronter, s’éprouver, sans se détruire mutuellement.
+Ce qui émerge, ce ne sont pas de nouveaux principes ni une nouvelle idéologie, mais une exigence beaucoup plus modeste, et aussi beaucoup plus difficile à satisfaire : celle de trouver dans les relations elles-mêmes — entre groupes, entre institutions, entre individus, entre temporalités — les ressources nécessaires pour maintenir leurs mondes viables. Autrement dit : c’est *dans* les tensions, *à même* les conflits, *au sein* des alliances, *au cœur* des désaccords et des polémiques, que semble se construire la régulation. Non plus *au-dessus*, par un décret transcendant, mais *au-dedans*, par un agencement toujours révisable. C’est cela que nous voulons dire — sans technicité inutile — quand nous parlons d’un déplacement vers une *instance de régulation située de co-viabilité* : un espace commun où les forces hétérogènes, souvent antagonistes, peuvent coexister, se contredire, se confronter, s’éprouver, sans se détruire mutuellement.
 
 Penser le politique depuis cette approche, c’est renoncer à l’idée même qu’un ordre puisse se fonder définitivement, une fois pour toutes. C’est reconnaître que ce qui fait tenir une société n’est jamais un principe unique, un commandement souverain, une légitimité première, mais *un espace d’épreuve toujours rejoué* où se négocient, se recadrent, s’opposent, s’ajustent des forces hétérogènes dont l’accord est constamment partiel, toujours temporaire, perpétuellement instable.
 
-Par conséquent, un ordre durerait moins par ses fondements proclamés que par ses *capacités régulatrices effectives*. Autant dire que ce sont les dispositifs, les formats, les médiations — parfois massifs, parfois imperceptibles — par lesquels un ordre parvient à faire coexister ce qui, en droit, pourrait s’exclure : des intérêts antagonistes, des affects discordants, des récits historiques incompatibles, des régimes de valeur irréconciliables, des temporalités sociales déphasées, des exigences contradictoires en matière de justice, d'efficacité, de mémoire ou d'avenir.
+Par conséquent, un ordre durerait moins par ses fondements proclamés que par ses *capacités régulatrices effectives*. Autant dire que ce sont les dispositifs, les formats, les médiations — parfois massifs, parfois imperceptibles — par lesquels un ordre parvient à faire coexister ce qui, en droit, pourrait s’exclure : des intérêts antagonistes, des affects discordants, des récits historiques incompatibles, des régimes de valeur irréconciliables, des temporalités sociales déphasées, des exigences contradictoires en matière de justice, d’efficacité, de mémoire ou d’avenir.
 
 Cet ordre ne les efface pas. Il ne les réconcilie pas dans un consensus fictif. Il ne les fusionne pas dans une synthèse idéologique illusoire. Il les tient ensemble sans les résoudre, par des équilibres instables, des arrangements contingents, des formats d’ajustement plus ou moins durables. C’est là que se situe toute la puissance — et la fragilité — de la régulation : tenir sans annuler, moduler sans effacer, organiser sans clore.
 
@@ -47,21 +47,21 @@ Cela ne veut pas dire que le politique ait disparu, mais plutôt qu’il tend pe
 
 C’est un marché carbone qui, au nom de seuils agrégés à l’échelle continentale, conduit à la fermeture d’un site industriel local, sans qu’aucune figure politique ne puisse rendre visible ni opposable l’arbitrage opéré. C’est un algorithme de régulation hospitalière qui, face à une tension budgétaire ou épidémiologique, déprogramme automatiquement des interventions chirurgicales — sans qu’aucun médecin, aucun patient, aucun responsable politique ne puisse véritablement en discuter les critères. C’est une plateforme numérique de traitement des titres de séjour qui suspend une demande pour “anomalie de saisie”, sans contact humain, sans justification claire, sans voie de recours instituée. C’est un logiciel de pilotage budgétaire, adossé à des indicateurs d’efficience, qui impose la réduction d’une politique sociale sans passage par une arène délibérative. C’est aussi un score algorithmique de risque bancaire qui écarte discrètement une famille d’un prêt, bien avant qu’elle ait pu formuler son projet.
 
-Contrairement aux apparences, ce qui s’offre au regard n’est plus la figure massive du pouvoir trônant dans la clarté de ses apparats, mais la trame patiente d’une régulation en mouvement. Disparues, les instances fixes ; effacée, la demeure solennelle de l’autorité. Le réel geste de gouvernance s’insinue insidieusement dans des protocoles, se glisse sournoisement dans la routine, s’entrelace irrémédiablement dans les habitudes, se ramifie inextricablement dans d’innombrables appareils sans visage. Nul acte inaugural n’en marque ostensiblement la naissance, nulle proclamation n’en scande les rythmes. On constate seulement que la régulation avance sans fracas, tisse patiemment la toile discrète sur laquelle se déplacent nos vies. Ce n’est plus tant le décret ni la loi qui pèsent, bien plus les enchevêtrements de normes, l’imperceptible maillage de procédures et l’ajustement continu de directives flexibles.
+Contrairement aux apparences, ce qui s’offre au regard n’est plus la figure massive du pouvoir trônant dans la clarté de ses apparats, mais la trame patiente d’une régulation en mouvement. Les instances fixes ont disparu ; la demeure solennelle de l’autorité s’est effacée. Le geste réel de gouvernance s’insinue dans des protocoles, se glisse dans la routine, s’entrelace dans les habitudes, se ramifie dans d’innombrables appareils sans visage. Nul acte inaugural n’en marque ostensiblement la naissance, nulle proclamation n’en scande les rythmes. On constate seulement que la régulation avance sans fracas et tisse patiemment la toile discrète sur laquelle se déplacent nos vies. Ce ne sont plus tant le décret ou la loi qui pèsent que les enchevêtrements de normes, l’imperceptible maillage de procédures et l’ajustement continu de directives flexibles.
 
-La contrainte n’accable plus par l’ostentation de l’ordre, mais s’inocule par la subtilité des systèmes. Ainsi, il s’agit désormais de façonner, par l’agencement soigné d’équilibres, de données, de flux, où chacun se trouve relié, indexé, impliqué à même cette dentelle administrative, sans jamais croiser le centre, sans jamais savoir nommer celui ou ce qui agit. La régulation moderne tresse ainsi un univers de seuils mobiles et d’agencements souples, où l’on ne peut jamais tout à fait fixer le moment ni le lieu du pouvoir agissant — mais où, à chaque pli de la vie collective, se lit l’empreinte d’une architecture invisible.
+La contrainte n’accable plus par l’ostentation de l’ordre, mais s’inocule par la subtilité des systèmes. Désormais, l’agencement d’équilibres, de données et de flux façonne un monde où chacun se trouve relié, indexé, impliqué dans cette dentelle administrative, sans jamais croiser le centre, sans jamais savoir nommer celui ou ce qui agit. La régulation moderne tresse ainsi un univers de seuils mobiles et d’agencements souples, où l’on ne peut jamais tout à fait fixer le moment ni le lieu du pouvoir agissant — mais où, à chaque pli de la vie collective, se lit l’empreinte d’une architecture invisible.
 
-La difficulté d’y résister tient moins à une violence perceptible qu’à leur ontologie d’évidence. Elles ne s’avancent pas comme autorités, ne se proclament pas comme pouvoir : elles fonctionnent, nous relient et donc elles opèrent. Et cette opération sans légitimation démocratique — pouvoir sans figure, contrainte sans théâtre — rend caduques nos anciennes grilles d’interprétation. Désormais, ce qui nous affecte le plus ne s’énonce plus, il s’impose sans discours jusqu’au plus intime.
+La difficulté d’y résister tient moins à une violence perceptible qu’à leur évidence ontologique. Elles ne s’avancent pas comme des autorités, ne se proclament pas comme pouvoir : elles fonctionnent, nous relient et, ce faisant, opèrent. Et cette opération sans légitimation démocratique — pouvoir sans figure, contrainte sans théâtre — rend caduques nos anciennes grilles d’interprétation. Désormais, ce qui nous affecte le plus ne s’énonce plus ; il s’impose sans discours jusqu’au plus intime.
 
 Cela signifie que le politique s’est décousu de ses formes historiques. Il continue d’agir, de décider, d’orienter — mais sous d’autres modalités, dans d’autres lieux, avec d’autres instruments, selon des régimes d’opérativité qu’aucune des catégories anciennes ne parvient plus à saisir, à rendre intelligible et à traduire sans trahir.
 
-Autrement dit, nous avons changé d’époque sans encore avoir pu changé de lexique. Nous continuons de penser avec des formes obsolètes ce qui s’active sous nos yeux. Nous employons les mots d’hier pour décrire des processus qui les excèdent de toutes parts. Nous parlons de gouvernements, là où il faudrait parler de structures de régulation composite. Nous discutons de lois, là où il faudrait décrire des protocoles, des seuils, des scénographies d’ajustement, des mécanismes de *feedback* algorithmique, des normes sans normalisateurs.
+Autrement dit, nous avons changé d’époque sans encore avoir pu changer de lexique. Nous continuons de penser avec des formes obsolètes ce qui s’active sous nos yeux. Nous employons les mots d’hier pour décrire des processus qui les excèdent de toutes parts. Nous parlons de gouvernements, là où il faudrait parler de structures de régulation composite. Nous discutons de lois, là où il faudrait décrire des protocoles, des seuils, des scénographies d’ajustement, des mécanismes de *feedback* algorithmique, des normes sans normalisateurs.
 
 Cette disjonction entre l’expérience vécue de la contrainte et le vocabulaire disponible pour la dire n’est pas qu’un problème théorique. Elle produit une désorientation profonde. Elle empêche de penser le réel, de localiser les responsabilités et rend inopérantes les critiques. Elle altère la capacité collective à formuler des exigences, jusqu’à dissoudre les repères et les registres d’action.
 
 Cette impuissance démocratique généralisée à nommer, situer, orienter les formes réelles de la régulation se donne parfois à voir dans des situations d’apparente clarté — et c’est peut-être là le plus troublant. Prenons un exemple rendu brûlant par l’actualité française en 2025 : la proposition de ce que l’on appelle la *taxe Zucman*. Formulée par l’éminent économiste Gabriel Zucman, cette mesure vise à instaurer un impôt minimal annuel sur le patrimoine des ultra-riches — en France et dans le monde — au-delà d’un seuil (autour de 100 millions d’euros). Le taux proposé est d’environ 2 % sur la valeur totale du patrimoine net, qu’il soit liquide ou partiellement non liquide (actions non cotées, participations, biens immobiliers), ce qui pose des défis de paiement et d’évaluation.
 
-L’idée est de corriger ce que Zucman identifie comme un déséquilibre fiscal majeur : les très grandes fortunes paient aujourd’hui, proportionnellement, beaucoup moins que ce que permettrait une imposition équitable et progressive, notamment en raison de l’évasion fiscale, de la mise sous structures opaques par *holding*, du transfert du patrimoine privée en patrimoine professionnel ou de la dissociation entre richesse effective et revenu imposable.
+L’idée est de corriger ce que Zucman identifie comme un déséquilibre fiscal majeur : les très grandes fortunes paient aujourd’hui, proportionnellement, beaucoup moins que ce que permettrait une imposition équitable et progressive, notamment en raison de l’évasion fiscale, de la mise en structures opaques via des *holdings*, du transfert du patrimoine privé en patrimoine professionnel ou de la dissociation entre richesse effective et revenu imposable.
 
 Si cette proposition est débattue publiquement — soutenue dans certains milieux politiques, évoquée dans les médias, portée par des organisations internationales — elle ne s’est pourtant pas traduite jusqu’à présent en un espace de régulation pleinement opérationnel : pas de dispositif stable, pas de mécanisme universel, pas d’instance de coordination internationale suffisamment puissante ni opposable pour rendre cette taxe effective à l’échelle voulue.
 
@@ -73,7 +73,7 @@ Ce hiatus, cette fracture, ce décrochage entre l’enjeu perceptible dans l’e
 
 Et face à cette évanescence, deux réflexes s’affrontent. L’un, nostalgique, cherche à réhabiliter les anciennes figures du pouvoir : l’autorité, la loi, la souveraineté, comme si elles pouvaient encore réactiver un ordre en désagrégation. L’autre, sceptique, postule qu’il n’y a plus rien à faire — que nous vivons l’épuisement définitif de l’arène politique, sa disparition dans le flux, le calcul, le désordre entropique des systèmes.
 
-Pour autant quelque chose continue d’agir, de structurer, de différencier, même en l’absence de pouvoir identifiable. Ce quelque chose, c’est la manière dont une société régule ses tensions internes : non plus en les effaçant, mais en les tenant, en les exposant, en les configurant dans des dispositifs — visibles ou non — capables de contenir sans abolir, de moduler sans figer, de différer sans éluder.
+Pour autant, quelque chose continue d’agir, de structurer, de différencier, même en l’absence de pouvoir identifiable. Ce quelque chose, c’est la manière dont une société régule ses tensions internes : non plus en les effaçant, mais en les tenant, en les exposant, en les configurant dans des dispositifs — visibles ou non — capables de contenir sans abolir, de moduler sans figer, de différer sans éluder.
 
 Nous devons donc reprendre à neuf la question la plus enfouie de la politique : *qu’est-ce qui fait qu’un monde collectif tient ?* Non plus dans l’abstrait, mais dans la matérialité de ses pratiques, la texture de ses conflits, l’architecture de ses médiations. *Par quels agencements tient-il ?* *À travers quelles épreuves ? Selon quelles temporalités ? Et sous quelles conditions de réversibilité ?*
 
@@ -85,7 +85,7 @@ Or ce qui s’efface désormais, c’est la capacité collective à en formuler
 
 Ces termes politiques s’organisent autour de deux grands suffixes — *-archie* et *-cratie* — forgés dans les débats de la Grèce antique, et largement sédimentés dans les lexiques modernes. Les suffixes en -*archie* désignent un *pouvoir fondé sur un principe premier* (*arkhè*), une origine ou une légitimité verticale : monarchie, oligarchie, etc. Ceux en -*cratie* désignent plutôt les *modalités pratiques d’exercice du pouvoir* (*kratos*) : démocratie, technocratie, bureaucratie, etc.
 
-Cette distinction entre fondement et exercice, légitimation et opération, traverse toute la modernité politique. Cependant cette séparation ne permet plus aujourd’hui de saisir la réalité des régulations effectives. Car les scènes d’*arkhè* se sont en grande partie effondrées sans être remplacées, tandis que les *kratos* contemporains tendent à s’exercer sans adresse, sans représentation, sans théâtre. L’on disserte sur les vertus de la démocratie, mais le *dèmos* n’a plus de lieu de confrontation effective : *serait-ce la rue ? Seraient-ce les réseaux sociaux ? Seraient-ce les médias ? Serait-ce le Parlement ?* Force est de constater qu’il n’en est rien : la première est réprimée ; les seconds sont filtrés et compartimentés ; les suivants sont contrôlés par une poignée de milliardaires ; et ce dernier est loin de représenter l’entièreté de la société. L’on invoque la République, mais la *res publica* — la chose publique, appellation la plus vague et la plus creuse que l’on puisse donner de l’espace politique — se dissout dans des logiques qui échappent à toute délibération commune : absence de débat, passage en force, brutalisme institutionnel. Quant au langage politique, il continue d’énoncer des structures et des projets, mais il ne parvient pas à décrire les opérations effectives de régulation tant le système socio-économique, en plus de s’être libéralisé et privatisé, s’est étendu et complexifié tout en confiant les leviers d’action au niveau supranational.
+Cette distinction entre fondement et exercice, légitimation et opération, traverse toute la modernité politique. Cependant, cette séparation ne permet plus aujourd’hui de saisir la réalité des régulations effectives. Car les scènes d’*arkhè* se sont en grande partie effondrées sans être remplacées, tandis que les *kratos* contemporains tendent à s’exercer sans adresse, sans représentation, sans théâtre. L’on disserte sur les vertus de la démocratie, mais le *dèmos* n’a plus de lieu de confrontation effective : *serait-ce la rue ? Seraient-ce les réseaux sociaux ? Seraient-ce les médias ? Serait-ce le Parlement ?* Force est de constater qu’il n’en est rien : la première est réprimée ; les seconds sont filtrés et compartimentés ; les troisièmes sont contrôlés par une poignée de milliardaires ; et ce dernier est loin de représenter l’ensemble de la société. L’on invoque la République, mais la *res publica* — la chose publique, appellation la plus vague et la plus creuse que l’on puisse donner de l’espace politique — se dissout dans des logiques qui échappent à toute délibération commune : absence de débat, passage en force, brutalisme institutionnel. Quant au langage politique, il continue d’énoncer des structures et des projets, mais il ne parvient pas à décrire les opérations effectives de régulation, tant le système socio-économique, en plus de s’être libéralisé et privatisé, s’est étendu et complexifié tout en confiant les leviers d’action au niveau supranational.
 
 C’est précisément cette disjonction — entre les principes supposés légitimer le pouvoir, et les dispositifs qui en assurent l’effectuation — qui produit aujourd’hui notre impuissance à penser la régulation. Car aucun de ces termes ne dit où se tiennent les tensions, comment elles sont traitées, par quelles instances elles sont articulées. Aucune *-archie* ne garantit aujourd’hui la dispute de ses fondements. Aucune *-cratie* n’organise les conditions de son opposabilité. Et pendant que nous nous obstinons à nommer des formes de régime, les processus réels de régulation — eux — échappent à tout espace visible d’épreuve. Jusqu’à présent, ils opèrent privés de contradictoire, dépourvus de délai, amputés d’institutions de réversibilité. Autrement dit : nous sommes gouvernés sans être gouvernés, régulés sans régulation légitimée, affectés sans instance délibérative.
 
@@ -93,57 +93,57 @@ Cette dissociation — entre pouvoir nommé et régulation agissante — peut se
 
 Cet épisode, souvent évoqué sur le ton de l’anecdote, mérite d’être considéré ici comme un symptôme politique majeur. Il indique que la régulation ne passe plus nécessairement par la verticalité du pouvoir, mais par des dispositifs latents, des agencements structurels, des inerties normatives et des coordinations transversales ou distribuées. Il montre qu’un ordre peut fonctionner sans fondement renouvelé, tenir sans pilotage, résister sans commande visible. Pierre Rosanvallon le soulignait (*La Légitimité démocratique*, 2008), en affirmant que les sociétés reposent aussi sur des « formes de légitimité latentes », moins spectaculaires que le vote ou la loi, mais non moins décisives. L’expérience belge illustre avec force cette persistance d’une régulation sans gouvernement explicite. Ce phénomène suggère que l’architecture régulatrice n’est plus identifiable aux lieux habituels de la souveraineté.
 
-Pour autant, le pouvoir n’a pas disparu ; il s’exerce désormais depuis d’autres formes que celles qui le légitimaient. C’est qu’il s’est délocalisé, désinstitutionnalisé, déréférencé— tout en continuant à structurer silencieusement la vie collective. Et c’est dans cet écart grandissant — entre l’absence de gouvernement et la persistance d’une régulation — que se dessine le cœur de la problématique contemporain : pour nombre d’entre nous, nous continuons à chercher le pouvoir là où il n’est plus, et à négliger les régulations implicites là où elles deviennent de plus en plus décisives.
+Pour autant, le pouvoir n’a pas disparu ; il s’exerce désormais depuis d’autres formes que celles qui le légitimaient. Il s’est délocalisé, désinstitutionnalisé, déréférencé — tout en continuant à structurer silencieusement la vie collective. Et c’est dans cet écart grandissant — entre l’absence de gouvernement et la persistance d’une régulation — que se dessine le cœur de la problématique contemporaine : pour nombre d’entre nous, nous continuons à chercher le pouvoir là où il n’est plus, et à négliger les régulations implicites là où elles deviennent de plus en plus décisives.
 
-Pour que ces dispositifs puissent fonctionner ainsi, discrètement et efficacement, sans qu’on puisse les identifier ni les contester, il faut d’abord que les lieux où ils auraient pu être exposés, discutés ou débattus soient neutralisés, effacés, disqualifiés ou rendus inutiles. Les lieux de pouvoir s’évaporent progressivement, les moyens d’expression se désagrègent, et les cadres d’appel à la responsabilité deviennent in-entendables. L’arène du politique ne disparaît pas brutalement, elle se désagrège lentement à mesure que ses conditions d’existence — la mise en scène, la confrontation et la mise à l’épreuve — se retirent.
+Pour que ces dispositifs puissent fonctionner ainsi, discrètement et efficacement, sans qu’on puisse les identifier ni les contester, il faut d’abord que les lieux où ils auraient pu être exposés, discutés ou débattus soient neutralisés, effacés, disqualifiés ou rendus inutiles. Les lieux de pouvoir s’évaporent progressivement, les moyens d’expression se désagrègent, et les cadres d’appel à la responsabilité deviennent inaudibles. L’arène du politique ne disparaît pas brutalement, elle se désagrège lentement à mesure que ses conditions d’existence — la mise en scène, la confrontation et la mise à l’épreuve — se retirent.
 
-Les anciens espaces d’exposition — Parlement, place publique, journal, commission, agora, tribune — ne remplissent plus leur fonction instituante. Non qu’elles soient abolies : elles subsistent, mais tournent à vide par éléments de langage superposés, par logiques oblitératrices, par interruptions des moments d’interpellation et des déploiements de pensées contre-propositionnelles. Elles parlent sans prise. Elles évoquent sans effet. Elles promettent sans adossement réel. En somme, elles hypnotisent et désactivent. Et tandis qu’elles persistent comme formes, les lieux effectifs de la régulation — là où s’arbitrent réellement les seuils, s’ajustent véritablement les normes, se décident les niveaux de tolérance ou d’exclusion — se déplacent hors de la portée de tous.
+Les anciens espaces d’exposition — Parlement, place publique, journal, commission, agora, tribune — ne remplissent plus leur fonction instituante. Non qu’ils aient été abolis : ils subsistent, mais tournent à vide, pris dans la superposition d’éléments de langage, dans des logiques oblitératrices, dans l’interruption des moments d’interpellation et dans l’empêchement des pensées contre-propositionnelles. Ils parlent sans prise. Ils évoquent sans effet. Ils promettent sans adossement réel. En somme, ils hypnotisent et désactivent. Et tandis qu’ils persistent comme formes, les lieux effectifs de la régulation — là où s’arbitrent réellement les seuils, s’ajustent véritablement les normes, se décident les niveaux de tolérance ou d’exclusion — se déplacent hors de la portée de tous.
 
-Cette désactivation des anciennes scènes de visibilité ne relève pas d’une abstraction — elle a connu, en France, un moment décisif et révélateur : le référendum de 2005 sur le traité constitutionnel européen (TCE). Ce vote ayant pourtant agrégé près de 55 % de refus, n’a pas produit les effets régulateurs que l’on aurait pu attendre. Deux ans plus tard, son contenu central était repris dans le traité de Lisbonne, adopté par voie parlementaire à Versailles, sans jamais redonner la parole aux citoyens.
+Cette désactivation des anciennes scènes de visibilité ne relève pas d’une abstraction — elle a connu, en France, un moment décisif et révélateur : le référendum de 2005 sur le traité constitutionnel européen (TCE). Ce vote, qui a pourtant recueilli près de 55 % de refus, n’a pas produit les effets régulateurs que l’on aurait pu attendre. Deux ans plus tard, son contenu central était repris dans le traité de Lisbonne, adopté par voie parlementaire à Versailles, sans jamais redonner la parole aux citoyens.
 
 Ce court-circuitage du résultat du référendum n’a pas seulement provoqué un malaise démocratique : il a signalé l’obsolescence d’une arène politique qui prétend encore incarner la souveraineté populaire, tout en s’ajustant aux impératifs d’une régulation supranationale désindexée de tout espace de débat. Depuis, les grandes décisions se prennent largement hors scène, dans des configurations qui échappent aux rituels de la légitimation représentative. L’épisode du TCE fut ainsi moins une exception qu’un révélateur : la souveraineté n’a pas disparu, elle s’est déplacée et s’est muée ; et ce sont les lieux traditionnels de confrontation — qui permettaient de la contester — qui perdent peu à peu de leur puissance.
 
-Il en résulte aujourd’hui ce que l’on pourrait nommer *une vacance des figures politiques*. Non pas un vide institutionnel — les appareils demeurent — ni un abandon total du pouvoir — les décisions continuent de tomber — mais bien un effacement progressif des repères identifiables à travers lesquelles ce pouvoir pouvait encore être *pensé*, *nommé*, *interrogé*, *disputé ou dénoncé*. Ce qui fait défaut, ce ne sont ni les procédures, ni les organigrammes, ni les énoncés de façade ; le pouvoir ne parvient plus à lui donner horizon partagé, épreuve contradictoire et adresse signifiante.
+Il en résulte aujourd’hui ce que l’on pourrait nommer une vacance des figures politiques. Non pas un vide institutionnel — les appareils demeurent — ni un abandon total du pouvoir — les décisions continuent de tomber — mais un effacement progressif des repères identifiables à travers lesquels ce pouvoir pouvait encore être pensé, nommé, interrogé, disputé ou dénoncé. Ce qui fait défaut, ce ne sont ni les procédures, ni les organigrammes, ni les énoncés de façade, mais les conditions mêmes d’un horizon partagé, d’une épreuve contradictoire et d’une adresse signifiante du pouvoir.
 
-Les institutions demeurent et fonctionnent. Des lois sont encore votées, des ordonnances promulguées, des discours prononcés dans des formes toujours codifiées. Pourtant, ces énoncés institutionnels, malgré leur constance formelle, peinent à produire de l’attachement, du conflit réglé, du récit commun. Il faut dire que lorsque les grandes directives sont déjà prises ailleurs, et qu’une tutelle s’exerce sur les marges de manœuvre budgétaire et les politiques publiques, tout programme de rupture avec l’existant ne peut advenir sans discrédit. Ceci conduit jusqu’à présent à entériner et à traduire en terme juridique les grands principes issus des institutions européennes. Ainsi nos partis politiques et nos institutions s’amenuisent et perdent de leur influence : elles peinent à percer les seuils et à générer des événements rassembleurs. Ils surviennent, puis s’évanouissent — rarement débattus, rarement disputés. Ils tentent néanmoins de transformer mais restent peu crédibles. La vie démocratique ne parvient plus à infléchir ledit pouvoir dans une visée d’horizon partagé puisque sa souveraineté s’est vue entachée.
+Les institutions demeurent et fonctionnent. Des lois sont encore votées, des ordonnances promulguées, des discours prononcés dans des formes toujours codifiées. Pourtant, ces énoncés institutionnels, malgré leur constance formelle, peinent à produire de l’attachement, du conflit réglé et du récit commun. Lorsque les grandes directives sont déjà prises ailleurs, et qu’une tutelle s’exerce sur les marges de manœuvre budgétaire et les politiques publiques, tout programme de rupture avec l’existant se trouve d’emblée frappé de discrédit. Il en résulte une tendance à entériner et à traduire en termes juridiques les grands principes issus des institutions européennes. Ainsi, nos partis politiques et nos institutions s’amenuisent et perdent de leur influence : ils peinent à ouvrir des brèches, à franchir des seuils, à générer des événements rassembleurs. Les moments qu’ils produisent surviennent puis s’évanouissent — rarement débattus, rarement disputés. Ils prétendent encore transformer, mais peinent de plus en plus à convaincre. La vie démocratique ne parvient plus à infléchir ledit pouvoir dans une visée d’horizon partagé puisque sa souveraineté se voit entachée.
 
 Peut-être faut-il alors suspendre un instant le flux de l’analyse pour ouvrir la perspective : entendre ce que cette disparition fait à nos imaginaires. Car perdre les lieux de confrontation, ce n’est pas perdre uniquement un espace politique — c’est voir s’effacer le langage commun de la mise en tension, de l’épreuve contradictoire, du désaccord rendu partageable. En somme, celui-ci n’est pas qu’un cadre, mais aussi une forme sensible, un rythme, un tempo, un théâtre où pouvaient s’exprimer les dissensus, mais aussi se nouer des alliances, des compromis, des co-habitations et des promesses de coexistence. C’est cette mise en forme qui vacille aujourd’hui — et avec elle, notre capacité à rendre visibles les lignes de fracture, les régimes d’attachement, les besoins vitaux et leurs modalités d’arbitrage.
 
-Depuis les élections se succèdent, mais l’offre programmatique s’uniformise. En France, lors des campagnes présidentielles de 2022, plusieurs observateurs ont noté une quasi-absence de débats contradictoires sur les infrastructures écologiques, la gestion de l’eau, les algorithmes de tri social ou les seuils budgétaires européens — sujets pourtant structurants et centraux des problématiques actuelles. La parole politique reste intense, mais elle survole en ignorant les points réels d’adhérence et de discordance. Elle n’expose ni la texture du monde vécu ni la réalité du tissu productif. Elle ne donne plus à saisir ni la forme ni la scène où les arbitrages s’opèrent. Elle devient commentaire sans impact, phrase choc ou viralité polémique sans colonne vertébrale permettant de se figurer les problématiques.
+Depuis lors, les élections se succèdent, mais l’offre programmatique s’uniformise. En France, lors des campagnes présidentielles de 2022, plusieurs observateurs ont noté une quasi-absence de débats contradictoires sur les infrastructures écologiques, la gestion de l’eau, les algorithmes de tri social ou les seuils budgétaires européens — sujets pourtant structurants et centraux. La parole politique reste intense, mais elle survole en ignorant les points réels d’adhérence et de discordance. Elle n’expose ni la texture du monde vécu ni la réalité du tissu productif. Elle ne donne plus à saisir ni la forme ni la scène où les arbitrages s’opèrent. Elle devient commentaire sans impact, phrase choc ou viralité polémique, sans colonne vertébrale permettant de se figurer les problématiques.
 
-Côté médias, le constat est plus ambivalent, mais tout aussi troublant. D’un côté, l’information est surabondante ; de l’autre, les controverses s’enlisent dans le flux. On discute des intentions, rarement des formats. On spécule sur les effets, sans jamais problématiser les dispositifs. Un exemple emblématique en est l’émission télévisée *“Face à Baba”*, ou le “Grand Débat National” post-Gilets Jaunes qui suscita beaucoup de prises de parole, tout en ayant peu de prise sur le réel. Il y eut certes des paroles fortes, mais sans aucune structure d’intégration. Il y eut des opinions tranchées, mais sans l’énonciation d’une architecture délibérative. De sorte que la parole a circulé, mais elle n’avait pas autorité à s’instituer. Elle n’était pas dans le bon lieu. Le plateau télévisé n’ayant pour autre vocation que l’audience.
+Côté médias, le constat est plus ambivalent, mais tout aussi troublant. D’un côté, l’information est surabondante ; de l’autre, les controverses s’enlisent dans le flux. On discute des intentions, rarement des formats. On spécule sur les effets, sans jamais problématiser les dispositifs. L’émission télévisée « Face à Baba » ou le « Grand Débat national » post-Gilets jaunes en offrent des exemples emblématiques : ils ont suscité de nombreuses prises de parole, tout en ayant peu de prise sur le réel. Il y eut certes des paroles fortes, mais sans véritable structure d’intégration. Il y eut des opinions tranchées, mais sans l’énonciation d’une architecture délibérative. De sorte que la parole a circulé, mais elle n’avait pas autorité à s’instituer. Elle n’était pas dans le bon lieu : le plateau télévisé n’a d’autre vocation que l’audience.
 
-Même les commissions d’enquête, qui historiquement cristallisaient un moment de vérité ou de remaniement, semblent affectées. Le rapport de l’Assemblée nationale sur la gestion de la pandémie de Covid-19, par exemple, a bien été publié en 2022. Il formule des dizaines de propositions. Mais pourtant, peu d’entre elles ont fait l’objet d’une reprise effective, ni dans la sphère politique, ni dans la sphére médiatique, ni dans la transformation des pratiques administratives. Là encore, la procédure opère — mais sans relai, sans engagement, sans espace de transformation. Même s’il faut le reconnaître, certaines analyses ont néanmoins nourri un débat plus large sur l’état de la santé publique, contribuant à renforcer la vigilance citoyenne sur les infrastructures hospitalières.
+Même les commissions d’enquête, qui, historiquement, cristallisaient un moment de vérité ou de remaniement, semblent affectées. Le rapport de l’Assemblée nationale sur la gestion de la pandémie de Covid-19, par exemple, a bien été publié en 2022. Il formule des dizaines de propositions. Pourtant, peu d’entre elles ont fait l’objet d’une reprise effective, ni dans la sphère politique, ni dans la sphère médiatique, ni dans la transformation des pratiques administratives. Là encore, la procédure opère — mais sans relais, sans engagement, sans espace de transformation. Même s’il faut le reconnaître, certaines analyses ont néanmoins nourri un débat plus large sur l’état de la santé publique, contribuant à renforcer la vigilance citoyenne sur les infrastructures hospitalières.
 
 Un autre exemple, plus récent encore, illustre avec une intensité toute particulière ce décalage entre mise en scène délibérative et opérativité réelle : celui de la Convention Citoyenne pour le Climat, initiée en France en 2019 à la suite du mouvement des Gilets Jaunes. Ce dispositif inédit proposait à 150 citoyennes et citoyens, tirés au sort, de formuler des propositions concrètes pour réduire les émissions de gaz à effet de serre (GES) dans un esprit de justice sociale. La procédure fut longue, exigeante, documentée. Les membres furent encadrés par des scientifiques, des spécialistes, des juristes, des praticiens. Leurs recommandations — 149 au total — furent saluées, y compris par les experts du climat, comme ambitieuses, sérieuses, largement compatibles avec les engagements climatiques de la France. Le président de la République s’était engagé à les transmettre « sans filtre ».
 
-Et pourtant. À l’issue de la convention, la grande majorité des propositions furent vidées de leur substance, renvoyées en commissions, ou transformées jusqu’à l’inverse de leur logique initiale. Certaines furent reprises à la marge dans la loi « Climat et Résilience », d’autres enterrées sans débat, d’autres encore tournées en dérision. L’expression « sans filtre » fut rapidement abandonnée, remplacée par des formules dilatoires. L’instance réflexive a existé, mais elle n’a pas su instituer. La parole a circulé, mais elle n’a pas performé. La procédure bien que dense, n’a pas permis là encore l’instauration d’une architecture de régulation efficiente.
+Et pourtant. À l’issue de la convention, la grande majorité des propositions furent vidées de leur substance, renvoyées en commissions ou transformées jusqu’à l’inverse de leur logique initiale. Certaines furent reprises à la marge dans la loi « Climat et Résilience », d’autres enterrées sans débat, d’autres encore tournées en dérision. L’expression « sans filtre » fut rapidement abandonnée, remplacée par des formules dilatoires. L’instance réflexive a existé, mais elle n’a pas su instituer. La parole a circulé, mais elle n’a pas performé. La procédure, bien que dense, n’a pas permis, là encore, l’instauration d’une architecture de régulation efficiente.
 
 En ce sens, la Convention n’a pas échoué parce qu’elle était utopique ; elle a échoué parce qu’elle n’a pas trouvé d’ancrage régulateur dans l’architecture politique réelle. Cet exemple montre bien comment un dispositif peut produire de la parole et de la visibilité, sans pour autant parvenir à instituer une régulation opérante. Ce n’est donc pas un lieu de confrontation sans conflit, mais une instance délibérative qui n’a pas donné suite. Et c’est ce type d’effacement — non spectaculaire, mais systémique — qui constitue aujourd’hui le symptôme d’une archéologie du politique désamarrée de ses obligations démocratiques.
 
-Contrairement au discours du sens commun pointant la responsabilité du chef de l’État, nous pensons que le pouvoir s’est désincarné. Bien que les figures de l’autorité demeurent — titres, fonctions, attributs symboliques — elles ne rassemblent plus ni contestation structurée (opposant), ni reconnaissance affective (popularité), ni légitimation opérante (autorité). Pendant ce temps, la conflictualité n’a jamais autant submergé le tissu social : désaccords éthiques, désynchronisations temporelles, fractures territoriales, crises multifactorielles, paupérisation systémique, violences symboliques ou physiques. Et malgré nous, cette conflictualité ne trouve plus les lieux où s’exprimer sans exploser. Elle ne se problématise plus dans des dispositifs communs, mais éclate en formes de colère dispersées, parfois illisibles, parfois délégitimées avant même d’avoir trouvé son expression stabilisée. Tel fut le cas du mouvement des Gilets Jaunes.
+Contrairement au discours du sens commun, qui pointe la responsabilité du chef de l’État, nous pensons que le pouvoir s’est désincarné. Bien que les figures de l’autorité demeurent — titres, fonctions, attributs symboliques —, elles ne cristallisent plus ni contestation structurée, ni reconnaissance affective, ni légitimation opérante. Pendant ce temps, la conflictualité n’a jamais autant submergé le tissu social : désaccords éthiques, désynchronisations temporelles, fractures territoriales, crises multifactorielles, paupérisation systémique, violences symboliques ou physiques. Et, pourtant, cette conflictualité ne trouve plus les lieux où s’exprimer sans exploser. Elle ne se problématise plus dans des dispositifs communs, mais éclate en formes de colère dispersées, parfois illisibles, parfois délégitimées avant même d’avoir trouvé une expression stabilisée. Tel fut le cas du mouvement des Gilets jaunes.
 
-Et pendant ce temps, les décisions, elles, se ramassent à la pelle : fermeture d’un service hospitalier, recentrage budgétaire, ajustement d’un seuil d’éligibilité, réforme à marche forcée du régime des retraites, réforme de l’assurance chômage, redéfinition d’indicateurs d’évaluation du marché de l’emploi, déremboursements médicaux, désindexation d’aide sociale, etc., etc. Ces décisions viennent, mais sans adresse explicite, sans exposition des arbitrages effectués, sans procès public, sans contradictoire. Elles sont le fruit d’instances spécifiques rendues opaques et qui n’apparaissent pas, ou n’assument pas leur fonction politique. Elles opèrent sous couvert de technique, mais agissent comme pouvoir — sans l’assumer publiquement.
+Et pendant ce temps, les décisions, elles, s’accumulent : fermeture d’un service hospitalier, recentrage budgétaire, ajustement d’un seuil d’éligibilité, réforme à marche forcée du régime des retraites, réforme de l’assurance chômage, redéfinition d’indicateurs d’évaluation du marché de l’emploi, déremboursements médicaux, désindexation d’aide sociale, etc. Ces décisions adviennent sans adresse explicite, sans exposition des arbitrages effectués, sans procès public, sans contradictoire. Elles sont le fruit d’instances spécifiques rendues opaques, qui n’apparaissent pas ou n’assument pas leur fonction politique. Elles opèrent sous couvert de technique, mais agissent comme pouvoir — sans l’assumer publiquement.
 
-Ainsi, ce n’est pas la *capacité d’agir* qui fait défaut — comme nous le voyons les régulations persistent — mais la *possibilité de rendre visible ce qui agit*. Ce qui tend à s’effacer, ce n’est pas le politique comme mécanisme de régulation, mais comme *espace de mise à l’épreuve*. Nous habitons un monde saturé de normes, mais privé de figures crédibles de justification. Les arbitrages se multiplient sans explication, sans délibération, sans lieu d’arbitrage démocratiquement établi.
+Ainsi, ce n’est pas la capacité d’agir qui fait défaut — les régulations persistent, comme nous le voyons bien —, mais la possibilité de rendre visible ce qui agit. Ce qui tend à s’effacer, ce n’est pas le politique comme mécanisme de régulation, mais le politique comme espace de mise à l’épreuve. Nous habitons un monde saturé de normes, mais privé de figures crédibles de justification. Les arbitrages se multiplient sans explication, sans délibération, sans lieu d’arbitrage démocratiquement établi.
 
 Et c’est précisément cette disparition d’espaces de controverses et de confrontation — cette disparition des lieux où se mettait en forme le différend, où s’exposait le conflit, où se partageait le sensible — qui constitue une perte capitale. Car c’est par la mise en scène des dissensus que les sociétés humaines ont, pendant des siècles, pu penser ensemble ce qui les liait, les divisait, les orientait. C’est sur cette instance d’épreuve qu’étaient rendues visibles les visions du monde qui s’affrontaient, les justifications qui s’opposaient, les intérêts qui s’exprimaient. Supprimez la scène d’exposition — et ce n’est pas le pouvoir qui disparaît, mais la possibilité d’en débattre. De sorte que la régulation dans les faits ne s’interrompt jamais : c’est la possibilité même qu’elle devienne affaire publique qui s’efface. Quant à l’ordre des choses, il ne se dissout pas, il se mue. Et c’est notre capacité collective à le mettre en cause qui se délite faute de compréhension et de préhension.
 
-Privés de lieux publics partagés, devenus propriétés privées, nous sommes aussi privés d’une mise en conflit visible et compréhensible. Pourtant, les tensions sont nombreuses, mais elles restent muettes, sans récit commun ni cadre d’expression. Ce qui nous divise cesse d’apparaître clairement. Ce qui nous déchire n’a plus de langage partagé performatif. Ce qui devrait susciter débat et polémique s’efface dans l’indifférence ou se réduit à une simple gestion technique de l’opinion et de la propagande. Le jeu politique ne dispute plus l’ordre du monde, car il semble ne plus le pouvoir, elle en devient seulement le décor figé, répétant sans contradiction les mêmes ritournelles idéologiques.
+Privés de lieux publics partagés, devenus propriétés privées, nous sommes aussi privés d’une mise en conflit visible et compréhensible. Pourtant, les tensions sont nombreuses, mais elles restent muettes, sans récit commun ni cadre d’expression. Ce qui nous divise cesse d’apparaître clairement. Ce qui nous déchire n’a plus de langage partagé performatif. Ce qui devrait susciter débat et polémique s’efface dans l’indifférence ou se réduit à une simple gestion technique de l’opinion et de la propagande. Le jeu politique ne dispute plus l’ordre du monde, car il ne semble même plus pouvoir le contester ; il en devient seulement le décor figé, répétant sans contradiction les mêmes ritournelles idéologiques.
 
-Or, sans polémique et sans cadre robuste de pensée, il n’y a plus de politique au sens fort. Il y a de la décision, de la gestion, de la réaction, du pilotage. Mais il n’y a plus d’espace où les fins pourraient être débattues, les normes interrogées, les tensions rendues visibles. Ce qui demeure, c’est une sorte de théâtre spectral — où le pouvoir mime encore ses rituels, mais sans adossement, sans prise, sans mise en jeu. Et ce décor fantomatique maintient en vie un imaginaire périmé : celui d’un pouvoir situé, identifiable, contestable. Mais cet imaginaire n’opère plus. Il flotte comme une relique, un fantasme d’époque révolue. C’est tout du moins ce que nous pensons.
+Or, sans polémique et sans cadre robuste de pensée, il n’y a plus de politique au sens fort. Il y a de la décision, de la gestion, de la réaction, du pilotage. Mais il n’y a plus d’espace où les fins pourraient être débattues, les normes interrogées, les tensions rendues visibles. Ce qui demeure, c’est une sorte de théâtre spectral — où le pouvoir mime encore ses rituels, mais sans adossement, sans prise, sans mise en jeu. Et ce décor fantomatique maintient en vie un imaginaire périmé : celui d’un pouvoir situé, identifiable, contestable. Mais cet imaginaire n’opère plus. Il flotte comme une relique, un fantasme d’époque révolue. C’est du moins ce que nous pensons.
 
 Ce qui se prépare alors — sans être encore nommé —, c’est un changement de condition politique. Une métamorphose souterraine, silencieuse, mais décisive. Nous traversons un déplacement du sol même sur lequel reposait notre compréhension du pouvoir, du conflit, de la régulation. Et ce déplacement appelle un autre langage. Non pas un mot de plus dans une série — mais un geste de pensée qui permette de reconfigurer les coordonnées même à partir desquelles nous pourrions analyser ce qui fait tenir les mondes. Ce changement de condition politique n’est pas une abstraction. Il s’est incarné historiquement, idéologiquement, structurellement. Et l’un de ses vecteurs majeurs — rarement interrogé comme tel — fut le tournant néolibéral du XXᵉ siècle.
 
-Avec son avènement, ce qui mute, c'est la fabrique même de la régulation. Ce qui s’est déplacé, ce sont les modalités par lesquelles un ordre devient opérant, ajusté, imposable — sans jamais se dire tel. Le néolibéralisme, en ce sens, décompose les conditions mêmes de la conflictualité démocratique. Il n’a pas réduit les règles : il a effacé les lieux de confrontation où l’on pouvait encore les contester. Il a opéré une reconfiguration des coordonnées fondamentales du politique : *qui agit ? selon quelles justifications ? selon quels formats ? Et où peut-on encore l’interroger ?*
+Avec son avènement, ce qui mute, c’est la fabrique même de la régulation. Ce qui s’est déplacé, ce sont les modalités par lesquelles un ordre devient opérant, ajusté, imposable — sans jamais se dire tel. Le néolibéralisme, en ce sens, décompose les conditions mêmes de la conflictualité démocratique. Il n’a pas réduit les règles : il a effacé les lieux de confrontation où l’on pouvait encore les contester. Il a opéré une reconfiguration des coordonnées fondamentales du politique : *qui agit ? selon quelles justifications ? selon quels formats ? Et où peut-on encore l’interroger ?*
 
-Nous voici donc au bord d’un tournant : bien plus qu’un langage politique qui s’épuise, ce sont les gestes mêmes qui permettaient de nommer, de rendre visible, de mettre à l’épreuve les régulations. Il nous faut donc changer de focale. Non plus partir des régimes connus, des formes visibles du pouvoir, des catégories héritées. Mais remonter au plus près des gestes primitifs qui configurent toute forme de régulation : ce qui fonde, ce qui fait agir, et ce qui articule les deux dans des formes tangibles, contestables, visibles et viables qui pourraient expliquer le mouvement évolutif des sociétés.
+Nous voici donc à l’orée d’un tournant : plus encore qu’un langage politique qui s’épuise, ce sont les gestes mêmes qui permettaient de nommer, de rendre visible, de mettre à l’épreuve les régulations qui se défont. Il nous faut donc changer de focale. Non plus partir des régimes connus, des formes visibles du pouvoir, des catégories héritées, mais remonter au plus près des gestes primitifs qui configurent toute forme de régulation : ce qui fonde, ce qui fait agir, et ce qui articule les deux dans des formes tangibles, contestables, visibles et viables, susceptibles d’éclairer le mouvement évolutif des sociétés.
 
 Dans notre analyse, le moment néolibéral a précisément perturbé cette articulation. Il a introduit un brouillage entre l’origine du pouvoir et ses effets, entre ce qui autorise et ce qui contraint, entre ce qui se dit et ce qui agit. Et c’est dans ce brouillage que se loge aujourd’hui l’impensé du politique contemporain.
 
 Pour en sortir, il faut retrouver les gestes fondamentaux à partir desquels un monde collectif peut encore être rendu lisible et vivable. Ce geste, nous le nommons ici : *archéologie de la régulation*. Si l’on veut comprendre ce qui se défait dans les régulations contemporaines — non pas de manière conjoncturelle, mais de façon structurelle —, il est impératif de remonter en amont des formes politiques connues, jusqu’aux forces sémantiques primitives que notre lexique transporte souvent à son insu.
 
-C’est en reprenant le fil depuis ses origines étymologiques que nous pourrons reconstituer la force d’arrachement de ces termes, les faire parler à nouveau — non comme vestiges, mais comme opérateurs toujours actifs, toujours présents, sous des formes multiples et plurielles. Ce détour par la langue n’est pas un exercice érudit. C’est une tentative de ré-accorder le langage à l’expérience vécu, de ressaisir les prises fondamentales du pouvoir à travers leurs gestes constituants et fondateurs.
+C’est en reprenant le fil depuis ses origines étymologiques que nous pourrons reconstituer la force d’arrachement de ces termes, les faire parler à nouveau — non comme vestiges, mais comme opérateurs toujours actifs, toujours présents, sous des formes multiples et plurielles. Ce détour par la langue n’est pas un exercice érudit. C’est une tentative de réaccorder le langage à l’expérience vécue, de ressaisir les prises fondamentales du pouvoir à travers leurs gestes constituants et fondateurs.
 
 Ainsi, les suffixes en *-archie* et en *-cratie*, que nous avons évoqués plus haut comme désignations de régimes, sont bien plus que des marqueurs grammaticaux, ils condensent des opérations fondamentales du politique. Plus précisément, ils signalent deux gestes constitutifs et irréductibles dans toute structuration collective : *celui du fondement* (*arkhè*) *et celui de l’exercice* (*kratos*). Le premier désigne l’*origine légitime* ; le second, la *puissance agissante*. Mais dans leur réduction lexicale, ces deux gestes ont été figés et dissociés en formes de régime, perdant de vue leur fonction dynamique et conjointe dans tout ordre social : *fonder* et *faire agir.* C’est pour restituer leur opérativité conceptuelle que nous introduisons ici les termes d’*arcalité* et de *cratialité*.
 
@@ -157,7 +157,7 @@ Alors pourquoi introduire le mot *arcalité*, au risque du néologisme ? Parce q
 
 L’*arcalité* est donc un concept transversal et multiple : elle traverse les époques, les cultures, les régimes — tout en changeant de visage et de figures. Elle peut prendre la forme d’un texte sacré, d’un contrat social, d’une Constitution, d’un mythe fondateur, d’une promesse technoscientifique, ou même d’un jeu d’indicateurs économiques. Elle peut être verticalement imposée ou horizontalement négociée. Elle peut être stabilisée dans le droit ou émerger dans la rue. Mais dans tous les cas, elle opère comme ce qui justifie le pouvoir, ce qui lui donne son aura d’évidence, ce qui naturalise ses opérations en les rendant pensables et acceptables.
 
-Mais au-delà de ces premiers assertions, l’*arcalité* se présente aussi comme un outil épistémologique pour l’analyse des régimes de légitimation — elle peut servir comme *opérateur heuristique* pour lire les sociétés dans leurs *structures de croyance, de reconnaissance, de justification*. Elle permet d’analyser des situations aussi différentes que la réforme d’un système de retraite, le recours à une IA dans la sélection universitaire ou la fondation d’un État théocratique, non pas en fonction de leur contenu normatif, mais en fonction de *ce qui est supposé justifier leur existence*, *ce qui les autorise à s’imposer*.
+Mais au-delà de ces premières assertions, l’arcalité se présente aussi comme un outil épistémologique pour l’analyse des régimes de légitimation — elle peut servir d’opérateur heuristique pour lire les sociétés dans leurs structures de croyance, de reconnaissance, de justification. Elle permet d’analyser des situations aussi différentes que la réforme d’un système de retraite, le recours à une IA dans la sélection universitaire ou la fondation d’un État théocratique, non pas en fonction de leur contenu normatif, mais en fonction de ce qui est supposé justifier leur existence et de ce qui les autorise à s’imposer.
 
 Pour commencer à en saisir la portée, il nous faut sommairement déplier l’*arcalité* dans ses déclinaisons historiques et symboliques. Elle ne renvoie pas à un type de régime, mais à *ce qui autorise un pouvoir à s’exercer sans être récusé* : une scène de légitimation, explicite ou tacite. Ainsi, sous l’Ancien Régime, l’autorité du roi n’était pas justifiée par sa compétence, mais par une *sacralité divine incarnée dans le sang, la lignée, le rite* — une *arcalité théologico-politique* où l’*arkhè* se vivait du trône jusqu’à l’autel.
 
@@ -171,9 +171,9 @@ Ainsi, dans la *Déclaration des droits de la Pachamama* (Bolivie, 2010), la Ter
 
 Dans les technostructures contemporaines, comme les agences de notation, les protocoles de régulation algorithmique, ou les plateformes numériques, l’*arcalité* devient *data* : ce sont les chiffres, les indicateurs, les modèles prédictifs qui justifient l’action. L’autorité repose sur la *robustesse du calcul*, la *neutralité supposée du code*, la *précision des seuils*. Ce que Yuval Noah Harari (*Homo deus, une brève histoire du futur*, 2017) appelle le “*dataïsme”* en est une figure actualisée exemplaire, où le flux des données devient source même de vérités.
 
-Enfin, dans certaines configurations capitalistiques contemporaines, l’*arcalité* prend une forme radicalement *autoréférentielle* : elle ne s’appuie plus sur une extériorité normative, ni même sur une validation juridique ou démocratique, mais sur la seule *performance passée érigée en légitimité présente*. C’est ce que l’on pourrait appeler une *arcalité autogénérative*, où le succès ne demande plus de justification externe — il en révèle sa propre preuve. Une entreprise qui attire des investissements massifs, une plateforme dont la valorisation boursière croît de manière exponentielle, une *startup* qui atteint le statut de “licorne” (plus d’un milliard de dollars de capitalisation), n’a plus besoin de se légitimer par un utilité sociale, une finalité collective ou un adossement institutionnel : *le simple fait d’avoir réussi* suffit à valider l’ensemble des choix stratégiques. Elle s’impose précisément parce qu’elle se donne à voir comme ayant *toujours déjà* fonctionné.
+Enfin, dans certaines configurations capitalistiques contemporaines, l’*arcalité* prend une forme radicalement *autoréférentielle* : elle ne s’appuie plus sur une extériorité normative, ni même sur une validation juridique ou démocratique, mais sur la seule *performance passée érigée en légitimité présente*. C’est ce que l’on pourrait appeler une *arcalité autogénérative*, où le succès ne demande plus de justification externe — il en révèle sa propre preuve. Une entreprise qui attire des investissements massifs, une plateforme dont la valorisation boursière croît de manière exponentielle, une *startup* qui atteint le statut de “licorne” (plus d’un milliard de dollars de capitalisation), n’a plus besoin de se légitimer par une utilité sociale, une finalité collective ou un adossement institutionnel : *le simple fait d’avoir réussi* suffit à valider l’ensemble des choix stratégiques. Elle s’impose précisément parce qu’elle se donne à voir comme ayant *toujours déjà* fonctionné.
 
-Mais l’*arcalité* dans ses multiples manifestations, si décisive soit-elle, ne suffit pas à faire tenir un monde. Car un ordre social, quel qu’il soit, ne repose jamais uniquement sur ses principes le légitimant. Il doit aussi pouvoir opérer, agir, décider, trancher, maintenir — parfois même contraindre ou punir. Il ne suffit pas qu’un pouvoir soit justifié ; encore faut-il qu’il se déploie, qu’il prenne forme dans des pratiques, des formats, des opérateurs. En somme, il ne suffit pas qu’un ordre se dise fondé ; il faut encore qu’il s’exerce.
+Mais l’arcalité, dans ses multiples manifestations, si décisive soit-elle, ne suffit pas à faire tenir un monde. Car un ordre social, quel qu’il soit, ne repose jamais uniquement sur les principes qui le légitiment. Il doit aussi pouvoir opérer, agir, décider, trancher, maintenir — parfois même contraindre ou punir. Il ne suffit pas qu’un pouvoir soit justifié ; encore faut-il qu’il se déploie, qu’il prenne forme dans des pratiques, des formats, des opérateurs. En somme, il ne suffit pas qu’un ordre se dise fondé ; il faut encore qu’il s’exerce.
 
 Il faut pour cela un autre registre, un autre plan de la régulation : celui de l’action. C’est ici qu’intervient ce que nous nommons la *cratialité* — terme forgé comme pour les régimes en -cratie — à partir de *kratos* (κράτος), qui désigne en grec ancien la force, la puissance agissante, la capacité à faire advenir quelque chose dans le réel. Si l’*arcalité est ce qui autorise*, la *cratialité est ce qui opère*. L’une pose les conditions de validité, l’autre produit les effets. L’une fonde, l’autre exerce.
 
@@ -197,7 +197,7 @@ Dans de nombreux États postcoloniaux, la *cratialité* conserve en grande parti
 
 À l’ère écologique, la *cratialité* passe par la *norme chiffrée* : marchés du carbone, seuils ISO, critères ESG. Le droit à polluer se négocie, se calcule, s’échange. Il s’agit moins de régulation morale que d’un *pilotage algorithmique* des équilibres. Bien que la Terre devienne une *arcalité*, sa régulation, elle, repose sur une *cratialité technico-financière*, opaque, désarrimée de tout débat public.
 
-Enfin, dans les régimes numériques contemporains, la *cratialité* se dissout dans les infrastructures : IA décisionnelles, *scoring* social, plateformes automatisées. Comme l’écrit Shoshana Zuboff, nous sommes entrés dans l’ère du *capitalisme de surveillance*, où la gouvernance s’exerce sans discours et sans voie de recours. Byung-Chul Han y voit un “pouvoir transparent total” où celui-ci n’est plus énoncé — il agit, module, filtre et exclut.
+Enfin, dans les régimes numériques contemporains, la cratialité se dissout dans les infrastructures : IA décisionnelles, scoring social, plateformes automatisées. Comme l’écrit Shoshana Zuboff, nous sommes entrés dans l’ère du capitalisme de surveillance, où la gouvernance s’exerce sans discours et sans voie de recours. Byung-Chul Han y voit un « pouvoir transparent total », où le pouvoir n’est plus énoncé — il agit, module, filtre et exclut.
 
 Après ce tour d’horizon des *cratialités* à travers l’espace et le temps, s’il fallait justifier, en dernière instance, l’introduction d*e* ce concept, ce serait en raison d’un vide analytique que les cadres existants ne parviennent plus à combler. La question n’est pas tant de créer un terme de plus, que de rendre dicible une opération fondamentale du pouvoir : celle qui consiste à *agir sans autorité explicite*, à contraindre sans justification, à réguler sans discours. En ce sens, la *cratialité* ne s’oppose pas à l’*arcalité*, elles se complètent. Elles révèlent l’une à l’autre leur limite. Car il est possible d’agir sans légitimer, de structurer sans fonder, d’opérer sans lieu de confrontation ni narration instituante.
 
@@ -205,9 +205,9 @@ Le concept de *cratialité* nous offre le terme pour penser ce pouvoir qui ne se
 
 C’est pourquoi la *cratialité* ne se confond ni avec la domination, ni avec le pouvoir institutionnel, ni même avec la technique. Elle traverse les formes, en tant qu’*opérativité sans fondement*. Elle n’explique pas pourquoi un ordre existe — elle permet de comprendre comment il s’exerce effectivement. Et c’est là sa puissance critique : déloger le politique de ses seules figures visibles, pour révéler les régulations silencieuses, les contraintes discrètes, les mécanismes délégués, les automatisations sans autorité véritablement légitime. Elle ouvre ainsi une contre-archéologie du pouvoir, attentive à ce qui agit sans se dire, à ce qui règle sans apparaître.
 
-Sur le plan épistémologique, la *cratialité* permet donc un déplacement décisif : elle nous extrait du dualisme éculé entre légitimité et illégitimité, démocratie et anarchie, État et société civile. Elle invite à penser un entre-deux, un “tiers-opératoire” : là où le politique s’institue non par la Loi ou par le Chaos, mais par l’*agencement de dispositifs producteurs de réalité*. Ce pouvoir-là ne commande pas : il invente et configure. Il ne tranche pas : il jauge et module. Il ne s’expose pas : il infiltre et s’impose. Et c’est pourquoi il faut un mot pour le désigner — non pas pour l’isoler, mais pour en cartographier les régimes, les formats, les seuils d’acceptabilité.
+Sur le plan épistémologique, la cratialité permet donc un déplacement décisif : elle nous extrait du dualisme éculé entre légitimité et illégitimité, démocratie et anarchie, État et société civile. Elle invite à penser un entre-deux, un « tiers opératoire » : là où le politique s’institue non par la Loi ou par le Chaos, mais par l’agencement de dispositifs producteurs de réalité. Ce pouvoir-là ne commande pas : il invente et configure. Il ne tranche pas : il jauge et module. Il ne s’expose pas : il infiltre et s’impose. Et c’est pourquoi il faut un mot pour le désigner — non pas pour l’isoler, mais pour en cartographier les régimes, les formats, les seuils d’acceptabilité.
 
-Sur le plan critique, la *cratialité* permet aussi de distinguer l’effet de l’auteur : ce n’est pas parce que personne ne commande que rien ne s’impose. Ce n’est pas parce qu’une norme n’a pas été votée qu’elle n’opère pas, et à l’opposé, ce n’est pas parce qu’une norme est appliquée qu’elle opère nécessairement. C’est toute la différence entre l’ordre prescrit et l’ordre effectif — différence aujourd’hui cruciale, tant la puissance régulatrice des systèmes dépasse celle des gouvernements.
+Sur le plan critique, la cratialité permet aussi de distinguer l’effet de l’auteur : ce n’est pas parce que personne ne commande que rien ne s’impose. Ce n’est pas parce qu’une norme n’a pas été votée qu’elle n’opère pas et, inversement, ce n’est pas parce qu’une norme est appliquée qu’elle opère nécessairement. C’est toute la différence entre l’ordre prescrit et l’ordre effectif — différence aujourd’hui cruciale, tant la puissance régulatrice des systèmes dépasse celle des gouvernements.
 
 Enfin, sur le plan opératoire, la *cratialité* fournit une grille de lecture transversale des phénomènes contemporains : du design d’une application mobile à la réorganisation d’un hôpital, du protocole logistique d’un port à la normalisation de la parole publique, du filtrage des contenus en ligne à la gestion algorithmique de l’emploi. Partout où quelque chose agit sans se dire comme pouvoir, sans se nommer comme décision, sans s’assumer comme contrainte, la *cratialité* est à l’œuvre.
 
@@ -217,65 +217,65 @@ Mais si ces deux pôles — celui du fondement (*arcalité*) et celui de l’op
 
 Et c’est précisément ce point d’articulation que nous voulons nommer, penser et problématiser ici.
 
-Si l’*arcalité* est *ce qui légitime*, et la *cratialité* *ce qui exerce*, alors l’*archicration* est le *nœud de leur articulation effective*. Elle désigne cette opération composite, toujours située, par laquelle un pouvoir donné fonde son action et agit selon son fondement — ou, inversement, agit tout en produisant sa propre légitimation — à la condition de se laisser exposer dans une scène d’épreuve. L’*archicration* est ce *point de nouage où se rejoignent la question du pourquoi* (*pourquoi ce pouvoir est-il reconnu ?*) *et celle du comment* (*comment ce pouvoir opère-t-il effectivement ?*), là où cette rencontre devient publiquement opposable. Non pas deux dimensions juxtaposées, mais deux régimes co-constitutifs de toute scène régulatrice.
+Si l’arcalité désigne ce au nom de quoi un ordre prétend agir, et la cratialité les chaînes par lesquelles il agit effectivement, alors l’archicration désigne la scène instituée où cet ordre expose, à sa manière, ses fondements et ses dispositifs à une épreuve, à une contestation, à une confirmation ou à une reconfiguration.
 
-Ainsi, de la fusion des deux termes (*arkhè* et *krateîn*) naît l’*archicration* : *l’acte de fonder en agissant, ou d’agir en fondant*. Factuellement, dans les régulations politiques concrètes, il n’y a jamais de pouvoir qui se contente de dire sans faire, ni d’agir sans justifier. Tout dispositif un tant soit peu structurant articule, à sa manière, un *arkhè* *qui justifie* et un *krateîn qui effectue*.
+L’archicration est la scène dans laquelle se rejoignent la question du pourquoi (pourquoi ce pouvoir est-il reconnu ?) et celle du comment (comment ce pouvoir opère-t-il effectivement ?), lorsque cette rencontre devient exposable, disputable et publiquement opposable. Il ne s’agit pas de deux dimensions juxtaposées, mais de deux régimes dont l’articulation ne devient politiquement décisive qu’à travers une épreuve instituée.
+
+Ainsi comprise, l’archicration ne nomme pas la totalité de l’acte politique, mais la scène où un ordre se rend à nouveau adressable, en exposant ses fondements et ses opérations à une épreuve réglée. Factuellement, dans les régulations politiques concrètes, il n’y a jamais de pouvoir qui se contente de dire sans faire, ni d’agir sans justifier. Tout dispositif un tant soit peu structurant articule, à sa manière, un *arkhè* *qui justifie* et un *krateîn qui effectue*.
 
 La force heuristique du concept d’*archicration*, c’est donc de réinscrire dans un même geste ce que la modernité politique avait tendance à dissocier : d’un côté, la légitimation (par le droit, le peuple, Dieu, la science…), de l’autre, l’effectuation (par les lois, les institutions, les techniques, les procédures…). Le pouvoir moderne s’est souvent construit sur une prétention à l’extériorité : l’action devait découler d’un principe, comme si l’on pouvait d’abord fonder, ensuite agir. Cette dissociation était une fiction structurante, utile pour l’ordre symbolique, mais inopérante pour une lecture du réel.
 
-En vérité, les régulations contemporaines — et peut-être une grande partie des régulations passées, cela reste à être étayé — peuvent être relues comme des agencements archicratifs, plus ou moins explicites, plus ou moins stables, mais toujours composite : l’État-nation est une *archicration* qui articule une *arcalité constitutionnelle* (la souveraineté populaire) à des *cratialités institutionnelles* (le gouvernement, l’administration, la police, l’armée, etc.). Il en va de même pour les grandes plateformes numériques qui articulent des *arcalités technoscientifiques* (la promesse de l’innovation, la rationalité du code, la neutralité de l’algorithme) à des *cratialités infra-visibles* (le filtrage, l’instrumentation, la captation de données, la modulation du comportement). Même un ordre religieux — ou un régime dit théocratique — n’échappe pas à cette logique : il articule des *arcalités transcendantes* (le texte révélé, la Loi divine, les prophètes, le Messie) à des *cratialités rituelles et doctrinales* (l’interprétation, la sanction, le commandement, la discipline).
+En vérité, les régulations contemporaines peuvent être relues comme des configurations archicratiques, c’est-à-dire comme des agencements variables d’arcalité, de cratialité et d’archicration. L’État-nation, par exemple, articule une arcalité constitutionnelle à des cratialités institutionnelles, et n’institue des archicrations qu’à travers certaines scènes déterminées — assemblées, tribunaux, procédures de recours, controverses publiques, dispositifs de révision. Même un ordre religieux — ou un régime dit théocratique — n’échappe pas à cette logique : il articule des *arcalités transcendantes* (le texte révélé, la Loi divine, les prophètes, le Messie) à des *cratialités rituelles et doctrinales* (l’interprétation, la sanction, le commandement, la discipline).
 
-L’*archicration* ne désigne donc pas un régime parmi d’autres. Elle nomme, selon toute hypothèse, le nœud vivant d’une régulation politique qui accepte de se rendre visible, différée et contestable, dès lors qu’elle vise à perdurer. De sorte qu’un pouvoir qui échoue à fonder ce qu’il opère s’expose à l’arbitraire ; un pouvoir qui échoue à opérer ce qu’il fonde s’épuise dans l’impuissance. De même, le simulacre surgit quand l’*arcalité* se dissocie de toute effectuation ; l’instabilité s’installe quand la *cratialité* ne s’adosse à aucun principe partagé. Ce que nous appelons *archicration*, c’est donc ce point de tension active et scénique où s’articulent — ou se désarticulent — le fondement et l’opération, la forme et la force, la justification et l’exécution.
+L’archicration ne désigne pas un régime parmi d’autres. Elle nomme la scène instituée où une régulation expose, selon des formes variables — parfois ouvertes, parfois captées, parfois violentes ou asymétriques — l’articulation de ses fondements et de ses opérations à une épreuve réglée, dès lors qu’elle vise à perdurer. De sorte qu’un pouvoir qui échoue à fonder ce qu’il opère s’expose à l’arbitraire ; un pouvoir qui échoue à opérer ce qu’il fonde s’épuise dans l’impuissance. De même, le simulacre surgit quand l’*arcalité* se dissocie de toute effectuation ; l’instabilité s’installe quand la *cratialité* ne s’adosse à aucun principe partagé. Ce que nous appelons archicration, c’est donc la scène instituée où s’articulent — ou se désarticulent — le fondement et l’opération, la forme et la force, la justification et l’exécution, sous la possibilité d’une épreuve réglée.
 
-Or, c’est lorsque cette articulation devient asymétrique, disjointe, ou captée, que le politique mute en profondeur — non plus sous la forme d’un changement visible de régime, mais d’un glissement silencieux des coordonnées de la régulation. Et parmi les figures contemporaines de cette désarticulation archicrative, le moment néolibéral occupe une place stratégique, tant par son étendue historique que par sa profondeur de reconfiguration. Non qu’il ait aboli la régulation — il l’a redéployée. Non qu’il ait supprimé le politique — il l’a déplacé, technicisé, encodé, rendu algorithme.
+Or, c’est lorsque cette articulation devient asymétrique, disjointe ou captée, que le politique mute en profondeur — non plus sous la forme d’un changement visible de régime, mais d’un glissement silencieux des coordonnées de la régulation. Et parmi les figures contemporaines de cette désarticulation archicrative, le moment néolibéral occupe une place stratégique, tant par son étendue historique que par sa profondeur de reconfiguration. Non qu’il ait aboli la régulation — il l’a redéployée. Non qu’il ait supprimé le politique — il l’a déplacé, technicisé, encodé, rendu algorithme.
 
-À partir des années 1970, sous l’impulsion d’intellectuels comme Friedrich Hayek et Milton Friedman, relayés par les *Chicago Boys,* amplifiés par les politiques de Ronald Reagan et Margaret Thatcher, puis par les prescriptions des grandes organisations transnationales (FMI, Banque mondiale, OMC), le néolibéralisme s’est imposé sans conquête déclarée, par glissement, par ruse, par standardisation. Il n’a pas remplacé les institutions du politique, il les a désactivés en douceur ; il n’a pas détruit l’État, il a recodé ses prérogatives régulatrices selon une nouvelle logique : celles de l’efficience, du marché, du seuil, du calcul et d’un retour sur ses fonctions régaliennes.
+À partir des années 1970, dans un contexte de mondialisation, de financiarisation croissante, de désindustrialisation occidentale et de crise des médiations collectives, le néolibéralisme s’est imposé sans conquête déclarée, par glissement, par ruse et par standardisation. Il n’a pas remplacé les institutions du politique : il les a désactivées en douceur ; il n’a pas détruit l’État : il a recodé ses prérogatives régulatrices selon une logique d’efficience, de marché, de seuil, de calcul et de recentrage sur ses fonctions régaliennes.
 
 D’un côté, cette idéologie a déplacé l’*arcalité* : le principe de fondement ne repose plus sur la souveraineté populaire, la loi, ou la délibération publique, mais sur l’*efficience marchande*. Le marché libre est présenté comme naturel, universel, neutre — et se promeut comme seul critère de légitimité. C’est ce que nous appelons ici *arcalité performative* : le fondement est produit par la performance elle-même. Le succès vaut justification. La croissance devient norme. L’indicateur remplace le débat.
 
 D’un autre côté, elle redéfinit la *cratialité* : la régulation ne passe plus par des institutions politiques visibles, mais par une gouvernance par les normes, les seuils, les indicateurs, les standards, les classements (*rankings*) et les interfaces. La décision n’est plus revendiquée ; elle s’élabore en algorithme opérationnel. Le pouvoir module, ajuste, et encode. Ce que Wendy Brown a appelé, dans *Undoing the Demos*, la “rationalité néolibérale” ne se résume pas à un discours ou à une doctrine — c’est une *cratialité généralisée*, une *logique de fonctionnement incorporée* dans les infrastructures mêmes du quotidien, où toute alternative devient impensable.
 
-Le mot d’ordre de “dérégulation” prôné par les tenants du néolibéralisme masquaient en réalité un déplacement massif de la régulation et non son annihilation. Ce qui a disparu peu à peu, ce ne sont pas les règles — elles pullulent — mais les scènes d’arbitrage où l’on pouvait encore en contester le sens, la pertinence, les effets. Les espaces publics de reconnaissance où elles pouvaient encore être mises à l’épreuve se sont effacés ou disséminés. Ainsi, chaque réforme — des retraites, de l’assurance chômage, de l’université, de l’hôpital ou de la fiscalité — est dès lors présentée non comme un choix idéologique, mais comme une évidence technico-financière, une réponse dite “rationnelle” à une contrainte supposée incontournable.
+Le mot d’ordre de “dérégulation” prôné par les tenants du néolibéralisme masquait en réalité un déplacement massif de la régulation, et non son annihilation. Ce qui a disparu peu à peu, ce ne sont pas les règles — elles pullulent — mais les scènes d’arbitrage où l’on pouvait encore en contester le sens, la pertinence, les effets. Les espaces publics de reconnaissance où elles pouvaient encore être mises à l’épreuve se sont effacés ou disséminés. Ainsi, chaque réforme — des retraites, de l’assurance chômage, de l’université, de l’hôpital ou de la fiscalité — est dès lors présentée non comme un choix idéologique, mais comme une évidence technico-financière, une réponse dite “rationnelle” à une contrainte supposée incontournable.
 
-Ce qui s’impose alors est une reconfiguration radicale des conditions d’existence. Le pouvoir n’est ni aboli ni dissimulé — il est redistribué dans des registres et des protocoles privés, encodé dans des métriques non explicites, traduit dans des novlangues tout en se distillant dans des environnements régulateurs où la fabrique du politique a été méthodiquement neutralisée. Ce que le *néolibéralisme* installe, c’est donc une *pseudo-archicration sans scène*, là où la délibération démocratique est dessaisie. Il produit un agencement dans lequel la légitimation ne s’édicte plus, mais s’infiltre sous forme de performance antérieure ; dans lequel la régulation ne tranche plus publiquement, mais opère en souterrain, au travers d’indicateurs, de seuils, d’algorithmes, de traités supranationaux, de conventions de marché.
+Ce qui s’impose alors est une reconfiguration radicale des conditions d’existence. Le pouvoir n’est ni aboli ni dissimulé — il est redistribué dans des registres et des protocoles privés, encodé dans des métriques non explicites, traduit dans des novlangues tout en se distillant dans des environnements régulateurs où la fabrique du politique a été méthodiquement neutralisée. Ce que le néolibéralisme installe, ce n’est pas une dérégulation au sens strict, mais une désarchicration tendancielle : les opérations se poursuivent, les justifications circulent, tandis que les scènes où elles pourraient être réellement éprouvées sont neutralisées, mimées ou confisquées. Il produit un agencement dans lequel la légitimation ne s’édicte plus, mais s’infiltre sous forme de performance antérieure ; dans lequel la régulation ne tranche plus publiquement, mais opère en souterrain, au travers d’indicateurs, de seuils, d’algorithmes, de traités supranationaux, de conventions de marché.
 
-Arrêtons-nous un instant pour bien préciser les termes de notre propos. Par *scène*, nous entendons l’*instance d’épreuve où des* *forces*, des *acteurs*, des *registres* ou des *institutions* d’ordres différents *se confrontent sous règles explicites.* Il ne s’agit donc pas uniquement du seul théâtre institutionnel ; nous parlons ici d’un espace d’apparition conflictuelle, où puisse se rendre audible les dissensus (Jacques Rancière, *La Mésentente*, 1995).
+Arrêtons-nous un instant pour bien préciser les termes de notre propos. Par scène, nous entendons l’instance d’épreuve où des forces, des acteurs, des registres ou des institutions d’ordres différents se confrontent sous des règles explicites. Il ne s’agit donc pas du seul théâtre institutionnel ; nous parlons ici d’un espace d’apparition conflictuelle, où peuvent se rendre audibles les dissensus (Jacques Rancière, *La Mésentente*, 1995).
 
-Dès lors, penser l’*archicration*, c’est chercher à rendre lisible le point de tension vive où un ordre se constitue en tenant ensemble des forces hétérogènes. Ce que nous proposons ici n’est pas un modèle, mais un geste : un mode d’attention aux lignes d’opération du pouvoir, une manière de cartographier les régulations en acte, une tentative de réouverture d’espaces démocratiques. L’objectif étant de refonder la possibilité d’épreuves là où l’opacité et l’occultation s’est installée, et pour rouvrir un espace de visibilité critique là où l’efficacité s’auto-justifie et prétend se suffire à elle-même.
+Dès lors, penser l’archicration, c’est chercher à rendre lisible la scène où un ordre se constitue en exposant à l’épreuve réglée l’articulation de forces hétérogènes. Ce que nous proposons ici n’est pas un modèle, mais un geste : un mode d’attention aux lignes d’opération du pouvoir, une manière de cartographier les régulations en acte, une tentative de réouverture d’espaces démocratiques. L’enjeu est de refonder la possibilité d’épreuves là où l’opacité et l’occultation se sont installées, et de rouvrir un espace de visibilité critique là où l’efficacité s’autojustifie et prétend se suffire à elle-même.
 
 Sous notre prisme d’analyse, l’*archicration* s’éprouve comme une réalité concrète, un espace vivant traversé de tensions permanentes, où se cherche sans cesse un fragile *équilibre entre des formes d’assise, des forces productives et des vulnérabilités constitutives*. Or, cet équilibre n’a rien de garanti : il peut basculer, se rompre, se déformer.
 
-Que faut-il entendre par là ? Certaines *configurations archicratives* tendent à surinvestir l’*affectation* — entendu par là, les dimensions idéologique, symbolique, émotionnelle qui prétendent donner sens et légitimer un ordre — tout en négligeant l’*effectuation,* soit la capacité de traduire ces principes en dispositifs opératoires stables et durables. L’exemple de la République jacobine de 1793 en fournit une illustration saisissante : exaltée par la fiction d’une souveraineté populaire absolue, elle n’a pas su consolider ses mécanismes de régulation pour perdurer. L’énergie de l’idéal a vite été dévorée par l’incapacité d’instaurer des équilibres viables, précipitant le régime dans la Terreur et l’épuisement institutionnel.
+Que faut-il entendre par là ? Certaines configurations archicratives tendent à surinvestir l’affectation — entendue ici comme l’ensemble des dimensions idéologiques, symboliques et émotionnelles qui prétendent donner sens et légitimer un ordre — tout en négligeant l’effectuation, soit la capacité de traduire ces principes en dispositifs opératoires stables et durables.
 
-D’autres *archicrations*, à l’inverse, s’enferment dans l’*effectuation* en oubliant tout récit justificatif. L’Union européenne en fournit un cas exemplaire : sa gouvernance repose sur une accumulation de normes techniques, de seuils budgétaires, de critères de convergence, d’indicateurs chiffrés (3 % de déficit, 60 % de dette, pactes de stabilité, règles de concurrence, standards environnementaux...). Ce régime régulateur, d’une efficacité incontestable dans sa capacité à contraindre les États membres, opère par une effectuation puissante, mais trop souvent déliée d’un langage politique partagé. Les décisions se justifient au nom de la « rationalité économique » ou de la « soutenabilité financière », sans se traduire dans un récit de légitimité accessible aux citoyens. C’est cette asymétrie — abondance de dispositifs opératoires, rareté des justifications symboliques — qui alimente le sentiment d’un déficit démocratique chronique, relevé par de nombreux observateurs et confirmé par les épisodes de rejet populaire (référendum français de 2005, Brexit, poussées eurosceptiques). Ici, l’*archicration* s’épuise dans l’opération : elle agit, ajuste, module, mais peine à convaincre et à rassembler.
+D’autres *archicrations*, à l’inverse, s’enferment dans l’*effectuation* en oubliant tout récit justificatif. L’Union européenne en fournit un cas exemplaire : sa gouvernance repose sur une accumulation de normes techniques, de seuils budgétaires, de critères de convergence, d’indicateurs chiffrés (3 % de déficit, 60 % de dette, pactes de stabilité, règles de concurrence, standards environnementaux…). Ce régime régulateur, d’une efficacité incontestable dans sa capacité à contraindre les États membres, opère par une effectuation puissante, mais trop souvent déliée d’un langage politique partagé. Les décisions se justifient au nom de la « rationalité économique » ou de la « soutenabilité financière », sans se traduire dans un récit de légitimité accessible aux citoyens. C’est cette asymétrie — abondance de dispositifs opératoires, rareté des justifications symboliques — qui alimente le sentiment d’un déficit démocratique chronique, relevé par de nombreux observateurs et confirmé par les épisodes de rejet populaire (référendum français de 2005, Brexit, poussées eurosceptiques). Ici, l’*archicration* s’épuise dans l’opération : elle agit, ajuste, module, mais peine à convaincre et à rassembler.
 
-À l’autre extrême, certaines *archicrations* se construisent sur une *fausse fusion* entre fondement et opération. Les régimes autoritaires modernes, comme ceux de la Russie de Vladimir Poutine ou de la Turquie de Recep Tayyip Erdogan, en offrent des incarnations saisissantes. L’*arkhè* proclamé — la Nation, la Tradition, la Religion, parfois la Civilisation — est érigé en principe indiscutable, en vérité d’origine inattaquable. Mais cette légitimation abstraite fonctionne comme paravent et sert de couverture à des pratiques de régulation brutales, des répressions ciblées, des ajustements institutionnels opportunistes, des captations oligarchiques et des dispositifs de contrôle opaque. L’illusion d’une concordance parfaite entre fondement et action masque en réalité une dissociation : le fondement est vidé de son contenu normatif, réduit à une invocation rituelle, tandis que l’effectuation se déploie dans la violence, l’arbitraire ou la manipulation technique. Dans ce type d’*archicration captée*, l’absence de véritable contradictoire — presse muselée, opposition criminalisée, société civile réduite — empêche toute mise à l’épreuve du pouvoir. Au lieu d’être travaillé dans une tension féconde, l’équilibre *arcalité/cratialité* est réduit à un simulacre qui absolutise le principe pour mieux immuniser l’action.
+À l’autre extrême, certaines *archicrations* se construisent sur une *fausse fusion* entre fondement et opération. Les régimes autoritaires modernes, comme ceux de la Russie de Vladimir Poutine ou de la Turquie de Recep Tayyip Erdogan, en offrent des incarnations saisissantes. L’*arkhè* proclamé — la Nation, la Tradition, la Religion, parfois la Civilisation — est érigé en principe indiscutable, en vérité d’origine inattaquable. Mais cette légitimation abstraite fonctionne comme paravent et sert de couverture à des pratiques de régulation brutales, des répressions ciblées, des ajustements institutionnels opportunistes, des captations oligarchiques et des dispositifs de contrôle opaque. L’illusion d’une concordance parfaite entre fondement et action masque en réalité une dissociation : le fondement est vidé de son contenu normatif, réduit à une invocation rituelle, tandis que l’effectuation se déploie dans la violence, l’arbitraire ou la manipulation technique. Dans ce type de configuration régulatrice à archicration captée, l’absence de véritable contradictoire — presse muselée, opposition criminalisée, société civile réduite — empêche toute mise à l’épreuve du pouvoir. Au lieu d’être travaillé dans une tension féconde, l’équilibre *arcalité/cratialité* est réduit à un simulacre qui absolutise le principe pour mieux immuniser l’action.
 
 C’est pourquoi penser la régulation politique à travers le prisme de l’*archicration*, ce n’est pas inventer un nouveau régime ni esquisser une utopie institutionnelle. C’est surtout déplacer le regard. Refuser de prendre les formes pour des essences, les régimes pour des totalités closes ou les normes pour des évidences. C’est ouvrir une autre cartographie du pouvoir, fondée non sur les déclarations, mais sur les agencements ; non seulement sur les formes héritées, mais aussi sur les opérations effectives. Une cartographie qui permette d’interroger chaque configuration politique en termes d’articulation concrète entre ce qui justifie (l’*arcalité*) et ce qui agit (la *cratialité*).
 
 C’est là le cœur du geste archicratique : restituer aux sociétés la lisibilité critique de leurs propres agencements, là où le pouvoir cherche à effacer ses fondements, et sa régulation à se rendre inattaquable.
 
-Mais allons plus loin. Si l’*archicration* désigne, dans une régulation, le moment où l’articulation mouvante de la légitimation et de l’opération devient scénique, explicite et publiquement opposable, alors l’*archicratie* peut être pensée comme la configuration historique dominante dans laquelle cette articulation s’effectue aujourd’hui sous condition de défiguration, de dissimulation et de dissémination.
+Mais allons plus loin. Si l’archicration désigne, dans une régulation, la scène instituée où l’articulation entre arcalité et cratialité devient exposable, différable et opposable, alors l’archicratie nomme le seuil à partir duquel une configuration politique devient habitable parce qu’elle maintient distinctes, articulées et exposables l’arcalité, la cratialité et l’archicration. La gouvernementalité contemporaine, telle que Michel Foucault en a dégagé la logique dans ses cours au Collège de France (*Sécurité, territoire, population*, 1977–1978 ; *Naissance de la biopolitique*, 1978–1979), éclaire au contraire l’un des empêchements majeurs de ce seuil : dissémination technique de l’opération, fragilisation des fondements exposables, compression ou neutralisation des scènes d’épreuve. Ce n’est donc pas l’archicratie que nous voyons proliférer aujourd’hui, mais des formes désarchicratiques, archicratistiques ou autarchicratiques, dans lesquelles la régulation se poursuit tandis que sa mise en scène contradictoire devient de plus en plus difficile, fictive ou captée.
 
-Par *archicratie*, nous entendons une forme contemporaine de *gouvernementalité désancrée* — au sens où Michel Foucault a dégagé, dans ses cours au Collège de France, comme *méta-régime de rationalité politique* qui déportent l’exercice du pouvoir vers des dispositifs et des techniques (Sécurité, territoire, population, 1977–1978 ; Naissance de la biopolitique, 1978–1979) — dans laquelle l’arène politique est défaite, le fondement rendu flottant, et l’opération disséminée dans des dispositifs qui ne se laissent plus nommer, ni questionner. Il ne s’agit ni d’un type de régime, ni d’un idéal-type ; c’est une *condition régulatrice dépolitisée* — où l’*arcalité* est rendue *automatisée* (par et pour la data) et où, l’*archicration* étant *oblitérée*, la *cratialité* s’exerce *hors de toute instance publique* (algorithme, protocole, contrat, externalisation).
+Cette entrée en matière vise à dégager le lieu exact où se joue aujourd’hui notre impuissance politique. Cette situation n’est pas un déficit de principes ni un excès de pouvoir ; c’est le dérèglement adémocratique des régimes de régulation, rendu illisible faute de scènes délibératives et d’instruments partagés.
 
-Cette entrée en matière aura eu comme visée de dégager le lieu exact où se joue aujourd’hui notre impuissance politique. Cette situation n’est pas un déficit de principes ni un excès de pouvoir ; c’est le dérèglement a-démocratique des régimes de régulation, rendu illisible faute de scènes délibératives et d’instruments partagés.
+C’est en remontant aux rouages primitifs du pouvoir — l’*arcalité*, polarité des formes d’affectation, et la *cratialité*, polarité des forces d’effectuation — que nous déplaçons la question politique des figures du gouvernement vers les prises différenciées de sa régulation.
 
-C’est en remontant aux rouages primitifs du pouvoir — l’*arcalité*, *polarité des formes d’affectation* ; la *cratialité*, *polarité des forces d’effectuation* — que nous déplaçons la question politique des figures du gouvernement vers les prises différenciées de sa régulation.
+En nommant archicration non pas l’articulation en général entre fondement et opération, mais la scène instituée où cette articulation devient visible, éprouvable et partiellement opposable, nous nous donnons une première grille de lecture des configurations contemporaines, où les dispositifs agissent sans toujours se légitimer, et où les fondements proclamés — droits humains, droits du travail, droits du vivant — voient décroître leur force d’obligation effective, au profit d’agencements opératoires qui ne se légitiment plus qu’à la marge.
 
-En nommant *archicration* cette *articulation dynamique* — souvent instable — *entre ce qui affecte le pouvoir et ce qui en déploie les effets*, nous avons pu construire une première grille de lecture propre aux configurations contemporaines, où les dispositifs agissent sans toujours se légitimer, et où les fondements proclamés — droits humains, droits du travail, droits du vivant — voient décroître leur force d’obligation effective, au profit d’agencements opératoires qui ne se légitiment plus qu’à la marge.
-
-Ce que cette notion permet de mettre au jour, ne se limite pas au fonctionnement des régulations, mais aux difficultés croissantes à les voir être interrogées, éprouvées, exposées au contradictoire. Loin de n’être qu’une propriété secondaire, cette mise à distance de toute possibilité de contestation structurée constitue désormais un trait central de notre condition politique. Ce qui agit n’est plus exposé qu’à la marge de la discussion publique et ce qui régule dorénavant s’exerce de plus en plus en silence, dans l’ombre, à l’abri des regards, dans un retrait radical du débat sur ses formes, ses conditions, ses seuils, ses formats.
+Ce que cette notion permet de mettre au jour ne se limite pas au fonctionnement des régulations, mais concerne aussi les difficultés croissantes à les voir interrogées, éprouvées, exposées au contradictoire. Loin de n’être qu’une propriété secondaire, cette mise à distance de toute possibilité de contestation structurée constitue désormais un trait central de notre condition politique. Ce qui agit n’est plus exposé qu’aux marges de la discussion publique, et ce qui régule s’exerce désormais de plus en plus en silence, dans l’ombre, à l’abri des regards, dans un retrait radical du débat sur ses formes, ses conditions, ses seuils, ses formats.
 
 Mais ce geste inaugural — critique, archéologique, modélisateur — ne restera légitime et significatif que s’il s’éprouve. Et c’est justement à cette mise à l’épreuve que se consacreront les chapitres à venir. Car le paradigme archicratique n’est pas pur appareillage conceptuel, il est avant tout une méthode de dévoilement, une topologie des régimes régulateurs, un cadre opératoire pour penser la viabilité politique en situation.
 
-Le chapitre I en établira le socle épistémologique rigoureux, en articulant les trois prises fondamentales du modèle — *arcalité, cratialité, archicration* — à une grammaire formelle et symbolique, pensée comme modèle falsifiable, susceptible de simulation et d’interprétation. Il posera la structure tripolaire comme condition d’une intelligibilité systémique, traversable tant par l’histoire que par la technique ou la psychologie collective.
+Le chapitre I en établira le socle épistémologique rigoureux, en articulant les trois prises fondamentales du modèle — arcalité, cratialité, archicration — à une grammaire formelle et symbolique, pensée comme modèle falsifiable, susceptible de formalisation et d’interprétation. Il posera la structure tripolaire comme condition d’une intelligibilité systémique, traversable tant par l’histoire que par la technique ou la psychologie collective.
 
 Le chapitre II délaissera toute abstraction normative pour réinscrire le politique dans la généalogie profonde des régimes de co-viabilité. Il retracera, de manière située et incarnée, les formes empiriques de régulation, depuis les dispositifs totémiques mésolithiques jusqu’aux technorégulations cryptographiques contemporaines. Il tentera de montrer que toute société se constitue d’abord comme régime de *co-viabilité* régulée — dont certaines configurations seulement atteignent un seuil proprement archicratique — bien avant de se penser comme État, comme droit, ou comme nation.
 
 Le chapitre III, d’inspiration philosophique, viendra tester l’*archicratie* comme outil de relecture des grandes pensées du pouvoir. Plutôt que de les aligner par écoles ou doctrines, il les confrontera à une grille archicratique : *quelle arcalité y opère ? Quelle cratialité s’y manifeste ? Quelle scène d’épreuve, d’opposition, ou de captation y est rendue possible ou empêchée ?* Ce faisant, il opérera un déplacement crucial passant de la justification du pouvoir à la morphologie des régimes de régulation.
 
-Le chapitre IV, d’orientation techno-historique, incarnera ces tensions dans l’histoire matérielle même de la modernité. Il ne se contentera pas de relire les révolutions industrielles comme des ruptures productives, mais comme des reconfigurations archicratiques profondes. Chaque mutation technique — de la vapeur à l’électricité, du numérique à l’automatisme — a transformé la manière dont un pouvoir se légitime, agit, se distribue ou se dérobe. La technologie, dans sa manifestation même, devient une instance cratiale, et parfois une matrice d’*archicration* détournée, empêchée ou rendu invisible. C’est donc à une lecture de la régulation des bifurcations industrielles que ce chapitre s’attachera, afin d’en révéler les architectures implicites de pouvoir.
+Le chapitre IV, d’orientation techno-historique, incarnera ces tensions dans l’histoire matérielle même de la modernité. Il ne se contentera pas de relire les révolutions industrielles comme des ruptures productives, mais comme des reconfigurations archicratiques profondes. Chaque mutation technique — de la vapeur à l’électricité, du numérique à l’automatisme — a transformé la manière dont un pouvoir se légitime, agit, se distribue ou se dérobe. La technologie, dans sa manifestation même, devient une instance cratiale, et parfois une matrice d’archicration détournée, empêchée ou rendue invisible. C’est donc à une lecture de la régulation des bifurcations industrielles que ce chapitre s’attachera, afin d’en révéler les architectures implicites de pouvoir.
 
 Enfin, le chapitre V affrontera la conflictualité maximale de notre temps : celle des tensions de co-viabilité. Il abordera, l’une après l’autre, les grandes scènes critiques — économique, écologique, sociale, médiatique, psychique, politique, technologique, géopolitique, cosmopolitique et culturelle — en les traitant non comme objets disciplinaires, mais comme *archicrations* problématiques. Chaque tension y sera relue comme une bifurcation possible : vers une régulation viable, une impasse pathologique ou une captation silencieuse. Ce chapitre constituera le point de bascule, le test ultime du paradigme archicratique : *permet-il de nous aider à discerner, sans dogme, ce qui tient un monde debout — ou le fait vaciller ?*
 

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: 195
+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: 120
+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: 130
+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: 140
+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: 150
+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: 160
+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: 170
+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: 180
+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: 190
+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,56 @@
+---
+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"
+---
+
+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, é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é*.
+
+#