fix(archicrat-ia): remove duplicated chapitre 4 heading

Reviewed-on: #318

.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

@@ -6,7 +6,7 @@ on:
   workflow_dispatch:
     inputs:
       force:
-        description: "Force deploy even if gate would skip (1=yes, 0=no)"
+        description: "Force FULL deploy (rebuild+restart) even if gate would hotpatch-only (1=yes, 0=no)"
         required: false
         default: "0"
 
@@ -14,6 +14,7 @@ env:
   NODE_OPTIONS: --dns-result-order=ipv4first
   DOCKER_API_VERSION: "1.43"
   COMPOSE_VERSION: "2.29.7"
+  ASTRO_TELEMETRY_DISABLED: "1"
 
 defaults:
   run:
@@ -25,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
@@ -46,98 +47,181 @@ 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 — auto deploy only on annotations/media changes
+      - 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}"
-          if [[ "$FORCE" == "1" ]]; then
-            echo "✅ force=1 -> bypass gate -> deploy allowed"
-            echo "GO=1" >> /tmp/deploy.env
-            exit 0
+
+          # 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
+
+          source /tmp/gate.env
+
+          BEFORE="${EV_BEFORE:-}"
+          AFTER="${EV_AFTER:-}"
+          if [[ -z "${AFTER:-}" ]]; then
+            AFTER="${SHA:-}"
           fi
 
-          CHANGED="$(git show --name-only --pretty="" "$SHA" | sed '/^$/d' || true)"
-          echo "== changed files =="
-          echo "$CHANGED" | sed -n '1,240p'
+          echo "Gate ctx: BEFORE=${BEFORE:-<empty>} AFTER=${AFTER:-<empty>} FORCE=${FORCE}"
 
-          if echo "$CHANGED" | grep -qE '^(src/annotations/|public/media/)'; then
-            echo "GO=1" >> /tmp/deploy.env
-            echo "✅ deploy allowed (annotations/media change detected)"
+          # 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
-            echo "GO=0" >> /tmp/deploy.env
-            echo "ℹ️ no annotations/media change -> skip deploy"
+            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
 
-      - name: Install docker client + docker compose plugin (v2)
+          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
+            GO=0
+            MODE="skip"
+            echo "ℹ️ no relevant change -> skip deploy"
+          fi
+
+          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
-          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 -c 'import yaml; print("PyYAML OK")'
 
-          # 🔥 KEY FIX: reuse existing compose project name if containers already exist
+          # 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)"
           if [[ -z "${PROJ:-}" ]]; then
             PROJ="$(docker inspect archicratie-web-green --format '{{ index .Config.Labels "com.docker.compose.project" }}' 2>/dev/null || true)"
@@ -146,7 +230,12 @@ jobs:
           echo "COMPOSE_PROJECT_NAME='$PROJ'" >> /tmp/deploy.env
           echo "✅ Using COMPOSE_PROJECT_NAME=$PROJ"
 
-      - name: Assert required vars (PUBLIC_GITEA_*)
+          # Assert target containers exist (hotpatch needs them)
+          for c in archicratie-web-blue archicratie-web-green; do
+            docker inspect "$c" >/dev/null 2>&1 || { echo "❌ missing container $c"; exit 5; }
+          done
+
+      - name: Assert required vars (PUBLIC_GITEA_*) — only needed for MODE=full
         env:
           PUBLIC_GITEA_BASE: ${{ vars.PUBLIC_GITEA_BASE }}
           PUBLIC_GITEA_OWNER: ${{ vars.PUBLIC_GITEA_OWNER }}
@@ -155,24 +244,26 @@ jobs:
           set -euo pipefail
           source /tmp/deploy.env
           [[ "${GO:-0}" == "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${MODE:-hotpatch}" == "full" ]] || { echo "ℹ️ hotpatch mode -> vars not required"; exit 0; }
 
           test -n "${PUBLIC_GITEA_BASE:-}"  || { echo "❌ missing repo var PUBLIC_GITEA_BASE"; exit 2; }
           test -n "${PUBLIC_GITEA_OWNER:-}" || { echo "❌ missing repo var PUBLIC_GITEA_OWNER"; exit 2; }
           test -n "${PUBLIC_GITEA_REPO:-}"  || { echo "❌ missing repo var PUBLIC_GITEA_REPO"; exit 2; }
           echo "✅ vars OK"
 
-      - name: Assert deploy files exist
+      - name: Assert deploy files exist — only needed for MODE=full
         run: |
           set -euo pipefail
           source /tmp/deploy.env
           [[ "${GO:-0}" == "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${MODE:-hotpatch}" == "full" ]] || { echo "ℹ️ hotpatch mode -> files not required"; exit 0; }
 
           test -f docker-compose.yml
           test -f Dockerfile
           test -f nginx.conf
           echo "✅ deploy files OK"
 
-      - name: Build + deploy staging (blue) then smoke
+      - name: FULL — Build + deploy staging (blue) then warmup+smoke
         env:
           PUBLIC_GITEA_BASE: ${{ vars.PUBLIC_GITEA_BASE }}
           PUBLIC_GITEA_OWNER: ${{ vars.PUBLIC_GITEA_OWNER }}
@@ -181,34 +272,69 @@ jobs:
           set -euo pipefail
           source /tmp/deploy.env
           [[ "${GO:-0}" == "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${MODE:-hotpatch}" == "full" ]] || { echo "ℹ️ MODE=$MODE -> skip full rebuild"; exit 0; }
+
           PROJ="${COMPOSE_PROJECT_NAME:-archicratie-web}"
 
+          wait_url() {
+            local url="$1"
+            local label="$2"
+            local tries="${3:-60}"
+            for i in $(seq 1 "$tries"); do
+              if curl -fsS --max-time 4 "$url" >/dev/null; then
+                echo "✅ $label OK ($url)"
+                return 0
+              fi
+              echo "… warmup $label ($i/$tries)"
+              sleep 1
+            done
+            echo "❌ timeout $label ($url)"
+            return 1
+          }
+
           TS="$(date -u +%Y%m%d-%H%M%S)"
           echo "TS='$TS'" >> /tmp/deploy.env
           docker image tag archicratie-web:blue  "archicratie-web:blue.BAK.${TS}"  || true
           docker image tag archicratie-web:green "archicratie-web:green.BAK.${TS}" || true
 
-          # ✅ use cache (DO NOT --no-cache)
+          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
-
-          # ✅ hard fix: remove existing container if name conflicts
           docker rm -f archicratie-web-blue || true
-
           docker compose -p "$PROJ" -f docker-compose.yml up -d --force-recreate --remove-orphans web_blue
 
-          curl -fsS "http://127.0.0.1:8081/para-index.json" >/dev/null
-          curl -fsS "http://127.0.0.1:8081/annotations-index.json" >/dev/null
-          curl -fsS "http://127.0.0.1:8081/pagefind/pagefind.js" >/dev/null
+          # warmup endpoints
+          wait_url "http://127.0.0.1:8081/para-index.json"        "blue para-index"
+          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"
 
-          CANON="$(curl -fsS "http://127.0.0.1:8081/archicrat-ia/chapitre-1/" | grep -oE 'rel="canonical" href="[^"]+"' | head -n1 || true)"
+          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/' || {
-            echo "❌ staging canonical mismatch"; exit 3;
+            echo "❌ staging canonical mismatch"
+            docker logs --tail 120 archicratie-web-blue || true
+            exit 3
           }
 
           echo "✅ staging OK"
 
-      - name: Build + deploy live (green) then smoke + rollback if needed
+      - name: FULL — Build + deploy live (green) then warmup+smoke + rollback if needed
         env:
           PUBLIC_GITEA_BASE: ${{ vars.PUBLIC_GITEA_BASE }}
           PUBLIC_GITEA_OWNER: ${{ vars.PUBLIC_GITEA_OWNER }}
@@ -217,9 +343,27 @@ jobs:
           set -euo pipefail
           source /tmp/deploy.env
           [[ "${GO:-0}" == "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${MODE:-hotpatch}" == "full" ]] || { echo "ℹ️ MODE=$MODE -> skip full rebuild"; exit 0; }
+
           PROJ="${COMPOSE_PROJECT_NAME:-archicratie-web}"
           TS="${TS:-$(date -u +%Y%m%d-%H%M%S)}"
 
+          wait_url() {
+            local url="$1"
+            local label="$2"
+            local tries="${3:-60}"
+            for i in $(seq 1 "$tries"); do
+              if curl -fsS --max-time 4 "$url" >/dev/null; then
+                echo "✅ $label OK ($url)"
+                return 0
+              fi
+              echo "… warmup $label ($i/$tries)"
+              sleep 1
+            done
+            echo "❌ timeout $label ($url)"
+            return 1
+          }
+
           rollback() {
             echo "⚠️ rollback green -> previous image tag (best effort)"
             docker image tag "archicratie-web:green.BAK.${TS}" archicratie-web:green || true
@@ -227,21 +371,243 @@ jobs:
             docker compose -p "$PROJ" -f docker-compose.yml up -d --force-recreate --remove-orphans web_green || true
           }
 
-          set +e
-          docker compose -p "$PROJ" -f docker-compose.yml build web_green
+          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
+          fi
 
           docker rm -f archicratie-web-green || true
           docker compose -p "$PROJ" -f docker-compose.yml up -d --force-recreate --remove-orphans web_green
 
-          curl -fsS "http://127.0.0.1:8082/para-index.json" >/dev/null
-          curl -fsS "http://127.0.0.1:8082/annotations-index.json" >/dev/null
-          curl -fsS "http://127.0.0.1:8082/pagefind/pagefind.js" >/dev/null
+          # warmup endpoints
+          if ! wait_url "http://127.0.0.1:8082/para-index.json"        "green para-index"; then rollback; exit 4; fi
+          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
 
-          CANON="$(curl -fsS "http://127.0.0.1:8082/archicrat-ia/chapitre-1/" | grep -oE 'rel="canonical" href="[^"]+"' | head -n1 || true)"
+          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/' || {
-            echo "❌ live canonical mismatch"; rollback; exit 4;
+            echo "❌ live canonical mismatch"
+            docker logs --tail 120 archicratie-web-green || true
+            rollback
+            exit 4
           }
 
           echo "✅ live OK"
-          set -e
+
+      - name: HOTPATCH — deep merge shards -> annotations-index + copy changed media into blue+green
+        run: |
+          set -euo pipefail
+          source /tmp/deploy.env
+          [[ "${GO:-0}" == "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+
+          python3 - <<'PY'
+          import os, re, json, glob
+          import yaml
+          import datetime as dt
+
+          ROOT = os.getcwd()
+          ANNO_ROOT = os.path.join(ROOT, "src", "annotations")
+
+          def is_obj(x): return isinstance(x, dict)
+          def is_arr(x): return isinstance(x, list)
+
+          def iso_dt(x):
+            if isinstance(x, dt.datetime):
+              if x.tzinfo is None:
+                return x.isoformat()
+              return x.astimezone(dt.timezone.utc).isoformat().replace("+00:00","Z")
+            if isinstance(x, dt.date):
+              return x.isoformat()
+            return None
+
+          def normalize(x):
+            s = iso_dt(x)
+            if s is not None: return s
+            if isinstance(x, dict):
+              return {str(k): normalize(v) for k, v in x.items()}
+            if isinstance(x, list):
+              return [normalize(v) for v in x]
+            return x
+
+          def key_media(it): return str((it or {}).get("src",""))
+          def key_ref(it):
+            it = it or {}
+            return "||".join([str(it.get("url","")), str(it.get("label","")), str(it.get("kind","")), str(it.get("citation",""))])
+          def key_comment(it): return str((it or {}).get("text","")).strip()
+
+          def dedup_extend(dst_list, src_list, key_fn):
+            seen = set(); out = []
+            for x in (dst_list or []):
+              x = normalize(x); k = key_fn(x)
+              if k and k not in seen: seen.add(k); out.append(x)
+            for x in (src_list or []):
+              x = normalize(x); k = key_fn(x)
+              if k and k not in seen: seen.add(k); out.append(x)
+            return out
+
+          def deep_merge(dst, src):
+            src = normalize(src)
+            for k, v in (src or {}).items():
+              if k in ("media","refs","comments_editorial") and is_arr(v):
+                if k == "media": dst[k] = dedup_extend(dst.get(k, []), v, key_media)
+                elif k == "refs": dst[k] = dedup_extend(dst.get(k, []), v, key_ref)
+                else: dst[k] = dedup_extend(dst.get(k, []), v, key_comment)
+                continue
+
+              if is_obj(v):
+                if not is_obj(dst.get(k)): dst[k] = {}
+                deep_merge(dst[k], v)
+                continue
+
+              if is_arr(v):
+                cur = dst.get(k, [])
+                if not is_arr(cur): cur = []
+                seen = set(); out = []
+                for x in cur:
+                  x = normalize(x)
+                  s = json.dumps(x, sort_keys=True, ensure_ascii=False)
+                  if s not in seen: seen.add(s); out.append(x)
+                for x in v:
+                  x = normalize(x)
+                  s = json.dumps(x, sort_keys=True, ensure_ascii=False)
+                  if s not in seen: seen.add(s); out.append(x)
+                dst[k] = out
+                continue
+
+              v = normalize(v)
+              if k not in dst or dst.get(k) in (None, ""):
+                dst[k] = v
+
+          def para_num(pid):
+            m = re.match(r"^p-(\d+)-", str(pid))
+            return int(m.group(1)) if m else 10**9
+
+          def sort_lists(entry):
+            for k in ("media","refs","comments_editorial"):
+              arr = entry.get(k)
+              if not is_arr(arr): continue
+              def ts(x):
+                x = normalize(x)
+                try:
+                  s = str((x or {}).get("ts",""))
+                  return dt.datetime.fromisoformat(s.replace("Z","+00:00")).timestamp() if s else 0
+                except Exception:
+                  return 0
+              arr = [normalize(x) for x in arr]
+              arr.sort(key=lambda x: (ts(x), json.dumps(x, sort_keys=True, ensure_ascii=False)))
+              entry[k] = arr
+
+          if not os.path.isdir(ANNO_ROOT):
+            raise SystemExit(f"Missing annotations root: {ANNO_ROOT}")
+
+          pages = {}
+          errors = []
+
+          files = sorted(glob.glob(os.path.join(ANNO_ROOT, "**", "*.yml"), recursive=True))
+          for fp in files:
+            try:
+              with open(fp, "r", encoding="utf-8") as f:
+                doc = yaml.safe_load(f) or {}
+              doc = normalize(doc)
+              if not isinstance(doc, dict) or doc.get("schema") != 1:
+                continue
+
+              page = str(doc.get("page","")).strip().strip("/")
+              paras = doc.get("paras") or {}
+              if not page or not isinstance(paras, dict):
+                continue
+
+              pg = pages.setdefault(page, {"paras": {}})
+              for pid, entry in paras.items():
+                pid = str(pid)
+                if pid not in pg["paras"] or not isinstance(pg["paras"].get(pid), dict):
+                  pg["paras"][pid] = {}
+                if isinstance(entry, dict):
+                  deep_merge(pg["paras"][pid], entry)
+                sort_lists(pg["paras"][pid])
+
+            except Exception as e:
+              errors.append({"file": os.path.relpath(fp, ROOT), "error": str(e)})
+
+          for page, obj in pages.items():
+            keys = list((obj.get("paras") or {}).keys())
+            keys.sort(key=lambda k: (para_num(k), k))
+            obj["paras"] = {k: obj["paras"][k] for k in keys}
+
+          out = {
+            "schema": 1,
+            "generatedAt": dt.datetime.utcnow().replace(tzinfo=dt.timezone.utc).isoformat().replace("+00:00","Z"),
+            "pages": pages,
+            "stats": {
+              "pages": len(pages),
+              "paras": sum(len(v.get("paras") or {}) for v in pages.values()),
+              "errors": len(errors),
+            },
+            "errors": errors,
+          }
+
+          with open("/tmp/annotations-index.json", "w", encoding="utf-8") as f:
+            json.dump(out, f, ensure_ascii=False)
+
+          print("OK: wrote /tmp/annotations-index.json pages=", out["stats"]["pages"], "paras=", out["stats"]["paras"], "errors=", out["stats"]["errors"])
+          PY
+
+          # patch JSON into running containers
+          for c in archicratie-web-blue archicratie-web-green; do
+            echo "== patch annotations-index.json into $c =="
+            docker cp /tmp/annotations-index.json "${c}:/usr/share/nginx/html/annotations-index.json"
+          done
+
+          # copy changed media files into containers (so new media appears without rebuild)
+          if [[ -s /tmp/changed.txt ]]; then
+            while IFS= read -r f; do
+              [[ -n "$f" ]] || continue
+              if [[ "$f" == public/media/* ]]; then
+                dest="/usr/share/nginx/html/${f#public/}"   # => /usr/share/nginx/html/media/...
+                for c in archicratie-web-blue archicratie-web-green; do
+                  echo "== copy media into $c: $f -> $dest =="
+                  docker exec "$c" sh -lc "mkdir -p \"$(dirname "$dest")\""
+                  docker cp "$f" "$c:$dest"
+                done
+              fi
+            done < /tmp/changed.txt
+          fi
+
+          # smoke after patch
+          for p in 8081 8082; do
+            echo "== smoke annotations-index on $p =="
+            curl -fsS --max-time 6 "http://127.0.0.1:${p}/annotations-index.json" \
+              | python3 -c 'import sys,json; j=json.load(sys.stdin); print("generatedAt:", j.get("generatedAt")); print("pages:", len(j.get("pages") or {})); print("paras:", j.get("stats",{}).get("paras"))'
+          done
+
+          echo "✅ hotpatch done"
+
+      - name: Debug on failure (containers status/logs)
+        if: ${{ failure() }}
+        run: |
+          set -euo pipefail
+          echo "== docker ps =="
+          docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Image}}' | sed -n '1,80p' || true
+          for c in archicratie-web-blue archicratie-web-green; do
+            echo "== logs $c (tail 200) =="
+            docker logs --tail 200 "$c" || true
+          done

.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,8 @@
+{
+  "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.",
+    "archicrat-ia/chapitre-2/index.html": "Reset intentionnel des ancres après restauration doctrinale substantielle du chapitre 2 depuis la bonne source officielle. Site neuf, sans annotations ni compatibilité descendante à préserver.",
+    "archicrat-ia/chapitre-3/index.html": "Reset intentionnel des ancres après réimport DOCX et perfectionnement doctrinal substantiel du chapitre 3 depuis la source officielle. Site neuf, sans annotations ni compatibilité descendante à préserver.",
+    "archicrat-ia/chapitre-4/index.html": "Reset intentionnel des ancres après réimport DOCX et stabilisation doctrinale substantielle du chapitre 4 depuis la source officielle. 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-annotation-ticket.mjs

@@ -1,9 +1,18 @@
 #!/usr/bin/env node
 // scripts/apply-annotation-ticket.mjs
-// Applique un ticket Gitea "type/media | type/reference | type/comment" vers src/annotations + public/media
-// Robuste, idempotent, non destructif
 //
-// DRY RUN par défaut si --dry-run
+// Applique un ticket Gitea "type/media | type/reference | type/comment" vers:
+//
+//   ✅ src/annotations/<oeuvre>/<chapitre>/<paraId>.yml   (sharding par paragraphe)
+//   ✅ public/media/<oeuvre>/<chapitre>/<paraId>/<file>
+//
+// Compat rétro : lit (si présent) l'ancien monolithe:
+//   src/annotations/<oeuvre>/<chapitre>.yml
+// et deep-merge NON destructif dans le shard lors d'une nouvelle application,
+// pour permettre une migration progressive sans perte.
+//
+// Robuste, idempotent, non destructif.
+// DRY RUN si --dry-run
 // Options: --dry-run --no-download --verify --strict --commit --close
 //
 // Env requis:
@@ -36,7 +45,7 @@ import YAML from "yaml";
 
 function usage(exitCode = 0) {
   console.log(`
-apply-annotation-ticket — applique un ticket SidePanel (media/ref/comment) vers src/annotations/
+apply-annotation-ticket — applique un ticket SidePanel (media/ref/comment) vers src/annotations/ (shard par paragraphe)
 
 Usage:
   node scripts/apply-annotation-ticket.mjs <issue_number> [--dry-run] [--no-download] [--verify] [--strict] [--commit] [--close]
@@ -44,9 +53,9 @@ Usage:
 Flags:
   --dry-run      : n'écrit rien (affiche un aperçu)
   --no-download  : n'essaie pas de télécharger les pièces jointes (media)
-  --verify       : tente de vérifier que (page, ancre) existent (baseline/dist si dispo)
-  --strict       : refuse si URL ref invalide (http/https) OU caption media vide
-  --commit       : git add + git commit (le script commit dans la branche courante)
+  --verify       : vérifie que (page, ancre) existent (dist/para-index.json si dispo, sinon baseline)
+  --strict       : refuse si URL ref invalide (http/https) OU caption media vide OU verify impossible
+  --commit       : git add + git commit (commit dans la branche courante)
   --close        : ferme le ticket (nécessite --commit)
 
 Env requis:
@@ -57,7 +66,7 @@ Env optionnel:
   GITEA_OWNER / GITEA_REPO  (sinon auto-détecté via git remote)
   ANNO_DIR    (défaut: src/annotations)
   PUBLIC_DIR  (défaut: public)
-  MEDIA_ROOT  (défaut URL: /media)  -> écrit dans public/media/...
+  MEDIA_ROOT  (défaut URL: /media)
 
 Exit codes:
   0 ok
@@ -102,6 +111,8 @@ const ANNO_DIR = path.join(CWD, process.env.ANNO_DIR || "src", "annotations");
 const PUBLIC_DIR = path.join(CWD, process.env.PUBLIC_DIR || "public");
 const MEDIA_URL_ROOT = String(process.env.MEDIA_ROOT || "/media").replace(/\/+$/, "");
 
+/* --------------------------------- helpers -------------------------------- */
+
 function getEnv(name, fallback = "") {
   return (process.env[name] ?? fallback).trim();
 }
@@ -123,7 +134,12 @@ function runQuiet(cmd, args, opts = {}) {
 }
 
 async function exists(p) {
-  try { await fs.access(p); return true; } catch { return false; }
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function inferOwnerRepoFromGit() {
@@ -140,6 +156,371 @@ function gitHasStagedChanges() {
   return r.status === 1;
 }
 
+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 pickSection(body, markers) {
+  const text = String(body || "").replace(/\r\n/g, "\n");
+  const idx = 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);
+
+  const stops = ["\n## ", "\n---", "\nJustification", "\nProposition", "\nSources"];
+  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();
+}
+
+function normalizeChemin(chemin) {
+  let c = String(chemin || "").trim();
+  if (!c) return "";
+  if (!c.startsWith("/")) c = "/" + c;
+  if (!c.endsWith("/")) c = c + "/";
+  c = c.replace(/\/{2,}/g, "/");
+  return c;
+}
+
+function normalizePageKeyFromChemin(chemin) {
+  // ex: /archicrat-ia/chapitre-4/ => archicrat-ia/chapitre-4
+  return normalizeChemin(chemin).replace(/^\/+|\/+$/g, "");
+}
+
+function normalizeAnchorId(s) {
+  let a = String(s || "").trim();
+  if (a.startsWith("#")) a = a.slice(1);
+  return a;
+}
+
+function assert(cond, msg, code = 1) {
+  if (!cond) {
+    const e = new Error(msg);
+    e.__exitCode = code;
+    throw e;
+  }
+}
+
+function isPlainObject(x) {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
+
+function paraIndexFromId(id) {
+  const m = String(id).match(/^p-(\d+)-/i);
+  return m ? Number(m[1]) : Number.NaN;
+}
+
+function isHttpUrl(u) {
+  try {
+    const x = new URL(String(u));
+    return x.protocol === "http:" || x.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function stableSortByTs(arr) {
+  if (!Array.isArray(arr)) return;
+  arr.sort((a, b) => {
+    const ta = Date.parse(a?.ts || "") || 0;
+    const tb = Date.parse(b?.ts || "") || 0;
+    if (ta !== tb) return ta - tb;
+    return JSON.stringify(a).localeCompare(JSON.stringify(b));
+  });
+}
+
+function normPage(s) {
+    let x = String(s || "").trim();
+    if (!x) return "";
+    // retire origin si on a une URL complète
+    x = x.replace(/^https?:\/\/[^/]+/i, "");
+    // enlève query/hash
+    x = x.split("#")[0].split("?")[0];
+    // enlève index.html
+    x = x.replace(/index\.html$/i, "");
+    // enlève slashs de bord
+    x = x.replace(/^\/+/, "").replace(/\/+$/, "");
+    return x;
+  }
+
+/* ------------------------------ para-index (verify + order) ------------------------------ */
+
+async function loadParaOrderFromDist(pageKey) {
+    const distIdx = path.join(CWD, "dist", "para-index.json");
+    if (!(await exists(distIdx))) return null;
+  
+    let j;
+    try {
+      j = JSON.parse(await fs.readFile(distIdx, "utf8"));
+    } catch {
+      return null;
+    }
+  
+    const want = normPage(pageKey);
+  
+    // Support A) { items:[{id,page,...}, ...] } (ou variantes)
+    const items = Array.isArray(j?.items)
+      ? j.items
+      : Array.isArray(j?.index?.items)
+        ? j.index.items
+        : null;
+  
+    if (items) {
+      const ids = [];
+      for (const it of items) {
+        // page peut être dans plein de clés différentes
+        const pageCand = normPage(
+          it?.page ??
+          it?.pageKey ??
+          it?.path ??
+          it?.route ??
+          it?.href ??
+          it?.url ??
+          ""
+        );
+  
+        // id peut être dans plein de clés différentes
+        let id = String(it?.id ?? it?.paraId ?? it?.anchorId ?? it?.anchor ?? "");
+        if (id.startsWith("#")) id = id.slice(1);
+  
+        if (pageCand === want && id) ids.push(id);
+      }
+      if (ids.length) return ids;
+    }
+  
+    // Support B) { byId: { "p-...": { page:"...", ... }, ... } }
+    if (j?.byId && typeof j.byId === "object") {
+      const ids = Object.keys(j.byId)
+        .filter((id) => {
+          const meta = j.byId[id] || {};
+          const pageCand = normPage(meta.page ?? meta.pageKey ?? meta.path ?? meta.route ?? meta.url ?? "");
+          return pageCand === want;
+        });
+  
+      if (ids.length) {
+        ids.sort((a, b) => {
+          const ia = paraIndexFromId(a);
+          const ib = paraIndexFromId(b);
+          if (Number.isFinite(ia) && Number.isFinite(ib) && ia !== ib) return ia - ib;
+          return String(a).localeCompare(String(b));
+        });
+        return ids;
+      }
+    }
+  
+    // Support C) { pages: { "archicrat-ia/chapitre-4": { ids:[...] } } } (ou variantes)
+    if (j?.pages && typeof j.pages === "object") {
+      // essaie de trouver la bonne clé même si elle est /.../ ou .../index.html
+      const keys = Object.keys(j.pages);
+      const hit = keys.find((k) => normPage(k) === want);
+      if (hit) {
+        const pg = j.pages[hit];
+        if (Array.isArray(pg?.ids)) return pg.ids.map(String);
+        if (Array.isArray(pg?.paras)) return pg.paras.map(String);
+      }
+    }
+  
+    return null;
+  }
+
+  async function tryVerifyAnchor(pageKey, anchorId) {
+    // 1) dist/para-index.json : order complet si possible
+    const order = await loadParaOrderFromDist(pageKey);
+    if (order) return order.includes(anchorId);
+  
+    // 1bis) dist/para-index.json : fallback “best effort” => recherche brute (IDs quasi uniques)
+    const distIdx = path.join(CWD, "dist", "para-index.json");
+    if (await exists(distIdx)) {
+      try {
+        const raw = await fs.readFile(distIdx, "utf8");
+        if (raw.includes(`"${anchorId}"`) || raw.includes(`"#${anchorId}"`)) {
+          return true;
+        }
+      } catch {
+        // ignore
+      }
+    }
+  
+    // 2) tests/anchors-baseline.json (fallback)
+    const base = path.join(CWD, "tests", "anchors-baseline.json");
+    if (await exists(base)) {
+      try {
+        const j = JSON.parse(await fs.readFile(base, "utf8"));
+        const candidates = [];
+        if (j?.pages && typeof j.pages === "object") {
+          for (const [k, v] of Object.entries(j.pages)) {
+            if (!Array.isArray(v)) continue;
+            if (normPage(k).includes(normPage(pageKey))) candidates.push(...v);
+          }
+        }
+        if (Array.isArray(j?.entries)) {
+          for (const it of j.entries) {
+            const p = String(it?.page || "");
+            const ids = it?.ids;
+            if (Array.isArray(ids) && normPage(p).includes(normPage(pageKey))) candidates.push(...ids);
+          }
+        }
+        if (candidates.length) return candidates.some((x) => String(x) === anchorId);
+      } catch {
+        // ignore
+      }
+    }
+  
+    return null; // cannot verify
+  }
+
+/* ----------------------------- deep merge helpers (non destructive) ----------------------------- */
+
+function keyMedia(x) {
+  return String(x?.src || "");
+}
+function keyRef(x) {
+  return `${x?.url || ""}||${x?.label || ""}||${x?.kind || ""}||${x?.citation || ""}`;
+}
+function keyComment(x) {
+  return String(x?.text || "").trim();
+}
+
+function uniqUnion(dstArr, srcArr, keyFn) {
+  const out = Array.isArray(dstArr) ? [...dstArr] : [];
+  const seen = new Set(out.map((x) => keyFn(x)));
+  for (const it of (Array.isArray(srcArr) ? srcArr : [])) {
+    const k = keyFn(it);
+    if (!k) continue;
+    if (!seen.has(k)) {
+      seen.add(k);
+      out.push(it);
+    }
+  }
+  return out;
+}
+
+function deepMergeEntry(dst, src) {
+  if (!isPlainObject(dst) || !isPlainObject(src)) return;
+
+  for (const [k, v] of Object.entries(src)) {
+    if (k === "media" && Array.isArray(v)) {
+      dst.media = uniqUnion(dst.media, v, keyMedia);
+      continue;
+    }
+    if (k === "refs" && Array.isArray(v)) {
+      dst.refs = uniqUnion(dst.refs, v, keyRef);
+      continue;
+    }
+    if (k === "comments_editorial" && Array.isArray(v)) {
+      dst.comments_editorial = uniqUnion(dst.comments_editorial, v, keyComment);
+      continue;
+    }
+
+    if (isPlainObject(v)) {
+      if (!isPlainObject(dst[k])) dst[k] = {};
+      deepMergeEntry(dst[k], v);
+      continue;
+    }
+
+    if (Array.isArray(v)) {
+      const cur = Array.isArray(dst[k]) ? dst[k] : [];
+      const seen = new Set(cur.map((x) => JSON.stringify(x)));
+      const out = [...cur];
+      for (const it of v) {
+        const s = JSON.stringify(it);
+        if (!seen.has(s)) {
+          seen.add(s);
+          out.push(it);
+        }
+      }
+      dst[k] = out;
+      continue;
+    }
+
+    // scalar: set only if missing/empty
+    if (!(k in dst) || dst[k] == null || dst[k] === "") {
+      dst[k] = v;
+    }
+  }
+}
+
+/* ----------------------------- annotations I/O ----------------------------- */
+
+async function loadAnnoDocYaml(fileAbs, pageKey) {
+  if (!(await exists(fileAbs))) {
+    return { schema: 1, page: pageKey, paras: {} };
+  }
+
+  const raw = await fs.readFile(fileAbs, "utf8");
+  let doc;
+  try {
+    doc = YAML.parse(raw);
+  } catch (e) {
+    throw new Error(`${path.relative(CWD, fileAbs)}: parse failed: ${String(e?.message ?? e)}`);
+  }
+
+  assert(isPlainObject(doc), `${path.relative(CWD, fileAbs)}: doc must be an object`, 2);
+  assert(doc.schema === 1, `${path.relative(CWD, fileAbs)}: schema must be 1`, 2);
+  assert(isPlainObject(doc.paras), `${path.relative(CWD, fileAbs)}: missing object key "paras"`, 2);
+
+  if (doc.page != null) {
+    const got = String(doc.page).replace(/^\/+/, "").replace(/\/+$/, "");
+    assert(got === pageKey, `${path.relative(CWD, fileAbs)}: page mismatch (page="${doc.page}" vs path="${pageKey}")`, 2);
+  } else {
+    doc.page = pageKey;
+  }
+
+  return doc;
+}
+
+function sortParasObject(paras, order) {
+  const keys = Object.keys(paras || {});
+  const idx = new Map();
+  if (Array.isArray(order)) order.forEach((id, i) => idx.set(String(id), i));
+
+  keys.sort((a, b) => {
+    const ha = idx.has(a);
+    const hb = idx.has(b);
+    if (ha && hb) return idx.get(a) - idx.get(b);
+    if (ha && !hb) return -1;
+    if (!ha && hb) return 1;
+
+    const ia = paraIndexFromId(a);
+    const ib = paraIndexFromId(b);
+    if (Number.isFinite(ia) && Number.isFinite(ib) && ia !== ib) return ia - ib;
+    return String(a).localeCompare(String(b));
+  });
+
+  const out = {};
+  for (const k of keys) out[k] = paras[k];
+  return out;
+}
+
+async function saveAnnoDocYaml(fileAbs, doc, order = null) {
+  await fs.mkdir(path.dirname(fileAbs), { recursive: true });
+
+  doc.paras = sortParasObject(doc.paras, order);
+
+  for (const e of Object.values(doc.paras || {})) {
+    if (!isPlainObject(e)) continue;
+    stableSortByTs(e.media);
+    stableSortByTs(e.refs);
+    stableSortByTs(e.comments_editorial);
+  }
+
+  const out = YAML.stringify(doc);
+  await fs.writeFile(fileAbs, out, "utf8");
+}
+
 /* ------------------------------ gitea helpers ------------------------------ */
 
 function apiBaseNorm(forgeApiBase) {
@@ -167,7 +548,7 @@ async function fetchIssue({ forgeApiBase, owner, repo, token, issueNum }) {
 }
 
 async function fetchIssueAssets({ forgeApiBase, owner, repo, token, issueNum }) {
-  // ✅ Gitea: /issues/{index}/assets
+  // Gitea: /issues/{index}/assets
   const url = `${apiBaseNorm(forgeApiBase)}/api/v1/repos/${owner}/${repo}/issues/${issueNum}/assets`;
   try {
     const json = await giteaGET(url, token);
@@ -215,200 +596,43 @@ async function closeIssue({ forgeApiBase, owner, repo, token, issueNum, comment
   }
 }
 
-/* ------------------------------ parsing helpers ---------------------------- */
+/* ------------------------------ media helpers ------------------------------ */
 
-function escapeRegExp(s) {
-  return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function inferMediaTypeFromFilename(name) {
+  const n = String(name || "").toLowerCase();
+  if (/\.(png|jpe?g|webp|gif|svg)$/.test(n)) return "image";
+  if (/\.(mp4|webm|mov|m4v)$/.test(n)) return "video";
+  if (/\.(mp3|wav|ogg|m4a)$/.test(n)) return "audio";
+  return "link";
 }
 
-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 sanitizeFilename(name) {
+  return String(name || "file")
+    .replace(/[\/\\]/g, "_")
+    .replace(/[^\w.\-]+/g, "_")
+    .replace(/_+/g, "_")
+    .slice(0, 180);
 }
 
-function pickSection(body, markers) {
-  const text = String(body || "").replace(/\r\n/g, "\n");
-  const idx = 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);
-
-  const stops = [
-    "\n## ",
-    "\n---",
-    "\nJustification",
-    "\nProposition",
-    "\nSources",
-  ];
-  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();
-}
-
-function normalizeChemin(chemin) {
-  let c = String(chemin || "").trim();
-  if (!c) return "";
-  if (!c.startsWith("/")) c = "/" + c;
-  if (!c.endsWith("/")) c = c + "/";
-  c = c.replace(/\/{2,}/g, "/");
-  return c;
-}
-
-function normalizePageKeyFromChemin(chemin) {
-  return normalizeChemin(chemin).replace(/^\/+|\/+$/g, "");
-}
-
-function normalizeAnchorId(s) {
-  let a = String(s || "").trim();
-  if (a.startsWith("#")) a = a.slice(1);
-  return a;
-}
-
-function assert(cond, msg, code = 1) {
-  if (!cond) {
-    const e = new Error(msg);
-    e.__exitCode = code;
-    throw e;
-  }
-}
-
-function isPlainObject(x) {
-  return !!x && typeof x === "object" && !Array.isArray(x);
-}
-
-/* ----------------------------- verify helpers ------------------------------ */
-
-function paraIndexFromId(id) {
-  const m = String(id).match(/^p-(\d+)-/i);
-  return m ? Number(m[1]) : Number.NaN;
-}
-
-async function tryVerifyAnchor(pageKey, anchorId) {
-  // 1) dist/para-index.json (si build déjà faite)
-  const distIdx = path.join(CWD, "dist", "para-index.json");
-  if (await exists(distIdx)) {
-    const raw = await fs.readFile(distIdx, "utf8");
-    const idx = JSON.parse(raw);
-    const byId = idx?.byId;
-    if (byId && typeof byId === "object" && byId[anchorId] != null) return true;
-  }
-
-  // 2) tests/anchors-baseline.json (si dispo)
-  const base = path.join(CWD, "tests", "anchors-baseline.json");
-  if (await exists(base)) {
-    const raw = await fs.readFile(base, "utf8");
-    const j = JSON.parse(raw);
-
-    // tolérant: cherche un array d'ids associé à la page
-    const candidates = [];
-
-    // cas 1: j.pages[...]
-    if (j?.pages && typeof j.pages === "object") {
-      for (const [k, v] of Object.entries(j.pages)) {
-        if (!Array.isArray(v)) continue;
-        // on matche large: pageKey inclus dans le path
-        if (String(k).includes(pageKey)) candidates.push(...v);
-      }
-    }
-
-    // cas 2: j.entries = [{page, ids}]
-    if (Array.isArray(j?.entries)) {
-      for (const it of j.entries) {
-        const p = String(it?.page || "");
-        const ids = it?.ids;
-        if (Array.isArray(ids) && p.includes(pageKey)) candidates.push(...ids);
-      }
-    }
-
-    if (candidates.length) {
-      return candidates.some((x) => String(x) === anchorId);
-    }
-  }
-
-  // impossible à vérifier
-  return null;
-}
-
-/* ----------------------------- annotations I/O ----------------------------- */
-
-async function loadAnnoDoc(fileAbs, pageKey) {
-  if (!(await exists(fileAbs))) {
-    return { schema: 1, page: pageKey, paras: {} };
-  }
-
-  const raw = await fs.readFile(fileAbs, "utf8");
-  let doc;
-  try {
-    doc = YAML.parse(raw);
-  } catch (e) {
-    throw new Error(`${path.relative(CWD, fileAbs)}: parse failed: ${String(e?.message ?? e)}`);
-  }
-
-  assert(isPlainObject(doc), `${path.relative(CWD, fileAbs)}: doc must be an object`);
-  assert(doc.schema === 1, `${path.relative(CWD, fileAbs)}: schema must be 1`);
-  assert(isPlainObject(doc.paras), `${path.relative(CWD, fileAbs)}: missing object key "paras"`);
-
-  if (doc.page != null) {
-    const got = String(doc.page).replace(/^\/+/, "").replace(/\/+$/, "");
-    assert(got === pageKey, `${path.relative(CWD, fileAbs)}: page mismatch (page="${doc.page}" vs path="${pageKey}")`);
-  } else {
-    doc.page = pageKey;
-  }
-
-  return doc;
-}
-
-function sortParasObject(paras) {
-  const keys = Object.keys(paras || {});
-  keys.sort((a, b) => {
-    const ia = paraIndexFromId(a);
-    const ib = paraIndexFromId(b);
-    if (Number.isFinite(ia) && Number.isFinite(ib) && ia !== ib) return ia - ib;
-    return String(a).localeCompare(String(b));
+async function downloadToFile(url, token, destAbs) {
+  const res = await fetch(url, {
+    headers: {
+      Authorization: `token ${token}`,
+      "User-Agent": "archicratie-apply-annotation/1.0",
+    },
+    redirect: "follow",
   });
-  const out = {};
-  for (const k of keys) out[k] = paras[k];
-  return out;
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    throw new Error(`download failed HTTP ${res.status}: ${url}\n${t}`);
+  }
+  const buf = Buffer.from(await res.arrayBuffer());
+  await fs.mkdir(path.dirname(destAbs), { recursive: true });
+  await fs.writeFile(destAbs, buf);
+  return buf.length;
 }
 
-async function saveAnnoDocYaml(fileAbs, doc) {
-  await fs.mkdir(path.dirname(fileAbs), { recursive: true });
-  doc.paras = sortParasObject(doc.paras);
-  const out = YAML.stringify(doc);
-  await fs.writeFile(fileAbs, out, "utf8");
-}
-
-/* ------------------------------ apply per type ----------------------------- */
-
-function ensureEntry(doc, paraId) {
-  if (!doc.paras[paraId] || !isPlainObject(doc.paras[paraId])) doc.paras[paraId] = {};
-  return doc.paras[paraId];
-}
-
-function uniqPush(arr, item, keyFn) {
-  const k = keyFn(item);
-  const exists = arr.some((x) => keyFn(x) === k);
-  if (!exists) arr.push(item);
-  return !exists;
-}
-
-function stableSortByTs(arr) {
-  if (!Array.isArray(arr)) return;
-  arr.sort((a, b) => {
-    const ta = Date.parse(a?.ts || "") || 0;
-    const tb = Date.parse(b?.ts || "") || 0;
-    if (ta !== tb) return ta - tb;
-    return JSON.stringify(a).localeCompare(JSON.stringify(b));
-  });
-}
+/* ------------------------------ type parsers ------------------------------ */
 
 function parseReferenceBlock(body) {
   const block =
@@ -431,50 +655,6 @@ function parseReferenceBlock(body) {
   };
 }
 
-function inferMediaTypeFromFilename(name) {
-  const n = String(name || "").toLowerCase();
-  if (/\.(png|jpe?g|webp|gif|svg)$/.test(n)) return "image";
-  if (/\.(mp4|webm|mov|m4v)$/.test(n)) return "video";
-  if (/\.(mp3|wav|ogg|m4a)$/.test(n)) return "audio";
-  return "link";
-}
-
-function sanitizeFilename(name) {
-  return String(name || "file")
-    .replace(/[\/\\]/g, "_")
-    .replace(/[^\w.\-]+/g, "_")
-    .replace(/_+/g, "_")
-    .slice(0, 180);
-}
-
-function isHttpUrl(u) {
-  try {
-    const x = new URL(String(u));
-    return x.protocol === "http:" || x.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-async function downloadToFile(url, token, destAbs) {
-  const res = await fetch(url, {
-    headers: {
-      // la plupart des /attachments sont publics, mais on garde le token “au cas où”
-      Authorization: `token ${token}`,
-      "User-Agent": "archicratie-apply-annotation/1.0",
-    },
-    redirect: "follow",
-  });
-  if (!res.ok) {
-    const t = await res.text().catch(() => "");
-    throw new Error(`download failed HTTP ${res.status}: ${url}\n${t}`);
-  }
-  const buf = Buffer.from(await res.arrayBuffer());
-  await fs.mkdir(path.dirname(destAbs), { recursive: true });
-  await fs.writeFile(destAbs, buf);
-  return buf.length;
-}
-
 /* ----------------------------------- main ---------------------------------- */
 
 async function main() {
@@ -511,29 +691,53 @@ async function main() {
   const pageKey = normalizePageKeyFromChemin(chemin);
   assert(pageKey, "Ticket: impossible de dériver pageKey.", 2);
 
+  const paraOrder = DO_VERIFY ? await loadParaOrderFromDist(pageKey) : null;
+
   if (DO_VERIFY) {
     const ok = await tryVerifyAnchor(pageKey, ancre);
     if (ok === false) {
       throw Object.assign(new Error(`Ticket verify: ancre introuvable pour page "${pageKey}" => ${ancre}`), { __exitCode: 2 });
     }
     if (ok === null) {
-      // pas de source de vérité dispo
-      if (STRICT) throw Object.assign(new Error(`Ticket verify (strict): impossible de vérifier (pas de baseline/dist)`), { __exitCode: 2 });
-      console.warn("⚠️  verify: impossible de vérifier (pas de baseline/dist) — on continue.");
+      if (STRICT) {
+        throw Object.assign(
+          new Error(`Ticket verify (strict): impossible de vérifier (pas de dist/para-index.json ou baseline)`),
+          { __exitCode: 2 }
+        );
+      }
+      console.warn("⚠️  verify: impossible de vérifier (pas de dist/para-index.json ou baseline) — on continue.");
     }
   }
 
-  const annoFileAbs = path.join(ANNO_DIR, `${pageKey}.yml`);
-  const annoFileRel = path.relative(CWD, annoFileAbs).replace(/\\/g, "/");
+  // ✅ shard path: src/annotations/<pageKey>/<paraId>.yml
+  const shardAbs = path.join(ANNO_DIR, ...pageKey.split("/"), `${ancre}.yml`);
+  const shardRel = path.relative(CWD, shardAbs).replace(/\\/g, "/");
 
-  console.log("✅ Parsed:", { type, chemin, ancre: `#${ancre}`, pageKey, annoFile: annoFileRel });
+  // legacy monolith: src/annotations/<pageKey>.yml (read-only, for migration)
+  const legacyAbs = path.join(ANNO_DIR, `${pageKey}.yml`);
 
-  const doc = await loadAnnoDoc(annoFileAbs, pageKey);
-  const entry = ensureEntry(doc, ancre);
+  console.log("✅ Parsed:", { type, chemin, ancre: `#${ancre}`, pageKey, annoFile: shardRel });
+
+  // load shard doc
+  const doc = await loadAnnoDocYaml(shardAbs, pageKey);
+  if (!isPlainObject(doc.paras[ancre])) doc.paras[ancre] = {};
+  const entry = doc.paras[ancre];
+
+  // merge legacy entry into shard in-memory (non destructive) to keep compat + enable progressive migration
+  if (await exists(legacyAbs)) {
+    try {
+      const legacy = await loadAnnoDocYaml(legacyAbs, pageKey);
+      const legacyEntry = legacy?.paras?.[ancre];
+      if (isPlainObject(legacyEntry)) {
+        deepMergeEntry(entry, legacyEntry);
+      }
+    } catch {
+      // ignore legacy parse issues; shard still applies new data
+    }
+  }
 
   const touchedFiles = [];
   const notes = [];
-
   let changed = false;
   const nowIso = new Date().toISOString();
 
@@ -545,16 +749,19 @@ async function main() {
     if (!Array.isArray(entry.comments_editorial)) entry.comments_editorial = [];
     const item = { text, status: "new", ts: nowIso, fromIssue: issueNum };
 
-    const added = uniqPush(entry.comments_editorial, item, (x) => `${(x?.text || "").trim()}`);
-    if (added) { changed = true; notes.push(`+ comment added (len=${text.length})`); }
-    else notes.push(`~ comment already present (dedup)`);
-
+    const before = entry.comments_editorial.length;
+    entry.comments_editorial = uniqUnion(entry.comments_editorial, [item], keyComment);
+    if (entry.comments_editorial.length !== before) {
+      changed = true;
+      notes.push(`+ comment added (len=${text.length})`);
+    } else {
+      notes.push(`~ comment already present (dedup)`);
+    }
     stableSortByTs(entry.comments_editorial);
   }
 
   else if (type === "type/reference") {
     const ref = parseReferenceBlock(body);
-
     assert(ref.url || ref.label, "Ticket reference: renseigne au moins - URL: ou - Label: dans le ticket.", 2);
 
     if (STRICT && ref.url && !isHttpUrl(ref.url)) {
@@ -571,34 +778,35 @@ async function main() {
     };
     if (ref.citation) item.citation = ref.citation;
 
-    const added = uniqPush(entry.refs, item, (x) => `${x?.url || ""}||${x?.label || ""}||${x?.kind || ""}||${x?.citation || ""}`);
-    if (added) { changed = true; notes.push(`+ reference added (${item.url ? "url" : "label"})`); }
-    else notes.push(`~ reference already present (dedup)`);
-
+    const before = entry.refs.length;
+    entry.refs = uniqUnion(entry.refs, [item], keyRef);
+    if (entry.refs.length !== before) {
+      changed = true;
+      notes.push(`+ reference added (${item.url ? "url" : "label"})`);
+    } else {
+      notes.push(`~ reference already present (dedup)`);
+    }
     stableSortByTs(entry.refs);
   }
 
   else if (type === "type/media") {
     if (!Array.isArray(entry.media)) entry.media = [];
 
-    const atts = NO_DOWNLOAD ? [] : await fetchIssueAssets({ forgeApiBase, owner, repo, token, issueNum });
-
-    if (!atts.length) {
-      notes.push("! no assets found (nothing to download).");
+    const caption = (title || "").trim();
+    if (STRICT && !caption) {
+      throw Object.assign(new Error("Ticket media (strict): caption vide (titre de ticket requis)."), { __exitCode: 2 });
     }
+    const captionFinal = caption || ".";
+
+    const atts = NO_DOWNLOAD ? [] : await fetchIssueAssets({ forgeApiBase, owner, repo, token, issueNum });
+    if (!atts.length) notes.push("! no assets found (nothing to download).");
 
     for (const a of atts) {
       const name = sanitizeFilename(a?.name || `asset-${a?.id || "x"}`);
       const dl = a?.browser_download_url || a?.download_url || "";
       if (!dl) { notes.push(`! asset missing download url: ${name}`); continue; }
 
-      // caption = title du ticket (fallback ".")
-      const caption = (title || "").trim() || ".";
-      if (STRICT && !caption.trim()) {
-        throw Object.assign(new Error("Ticket media (strict): caption vide."), { __exitCode: 2 });
-      }
-
-      const mediaDirAbs = path.join(PUBLIC_DIR, "media", pageKey, ancre);
+      const mediaDirAbs = path.join(PUBLIC_DIR, "media", ...pageKey.split("/"), ancre);
       const destAbs = path.join(mediaDirAbs, name);
       const urlPath = `${MEDIA_URL_ROOT}/${pageKey}/${ancre}/${name}`.replace(/\/{2,}/g, "/");
 
@@ -608,21 +816,24 @@ async function main() {
         const bytes = await downloadToFile(dl, token, destAbs);
         notes.push(`+ downloaded ${name} (${bytes} bytes) -> ${urlPath}`);
         touchedFiles.push(path.relative(CWD, destAbs).replace(/\\/g, "/"));
+        changed = true;
       } else {
         notes.push(`(dry) would download ${name} -> ${urlPath}`);
+        changed = true;
       }
 
       const item = {
         type: inferMediaTypeFromFilename(name),
         src: urlPath,
-        caption,
+        caption: captionFinal,
         credit: "",
         ts: nowIso,
         fromIssue: issueNum,
       };
 
-      const added = uniqPush(entry.media, item, (x) => String(x?.src || ""));
-      if (added) changed = true;
+      const before = entry.media.length;
+      entry.media = uniqUnion(entry.media, [item], keyMedia);
+      if (entry.media.length !== before) changed = true;
     }
 
     stableSortByTs(entry.media);
@@ -640,7 +851,7 @@ async function main() {
 
   if (DRY_RUN) {
     console.log("\n--- DRY RUN (no write) ---");
-    console.log(`Would update: ${annoFileRel}`);
+    console.log(`Would update: ${shardRel}`);
     for (const n of notes) console.log("  ", n);
     console.log("\nExcerpt (resulting entry):");
     console.log(YAML.stringify({ [ancre]: doc.paras[ancre] }).trimEnd());
@@ -648,10 +859,10 @@ async function main() {
     return;
   }
 
-  await saveAnnoDocYaml(annoFileAbs, doc);
-  touchedFiles.unshift(annoFileRel);
+  await saveAnnoDocYaml(shardAbs, doc, paraOrder);
+  touchedFiles.unshift(shardRel);
 
-  console.log(`✅ Updated: ${annoFileRel}`);
+  console.log(`✅ Updated: ${shardRel}`);
   for (const n of notes) console.log("  ", n);
 
   if (DO_COMMIT) {
@@ -685,4 +896,4 @@ main().catch((e) => {
   const code = e?.__exitCode || 1;
   console.error("💥", e?.message || e);
   process.exit(code);
-});
+});

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/audit-docx-source.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import sys
+import unicodedata
+import xml.etree.ElementTree as ET
+from zipfile import ZipFile
+
+NS = {"w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"}
+
+FORBIDDEN = [
+    "coviabilité",
+    "sacroinstitutionnelle",
+    "technologistique",
+    "scripturonormative",
+    "textesrepères",
+    "ellemême",
+    "opérateur de d’archicration",
+    "systèmes plusieurs statuts",
+    "celle-ci se donne à voir",
+    "Pour autant il serait",
+    "Telles peuvent être le cas de",
+    "la co-viabilité devient ,",
+]
+
+
+def norm(s: str) -> str:
+    return unicodedata.normalize("NFC", s or "")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Audit simple d’un DOCX source officiel.")
+    parser.add_argument("docx", help="Chemin du fichier .docx")
+    args = parser.parse_args()
+
+    try:
+        with ZipFile(args.docx) as zf:
+            data = zf.read("word/document.xml")
+    except FileNotFoundError:
+        print(f"ECHEC: fichier introuvable: {args.docx}", file=sys.stderr)
+        return 2
+    except KeyError:
+        print("ECHEC: word/document.xml introuvable dans le DOCX.", file=sys.stderr)
+        return 2
+    except Exception as e:
+        print(f"ECHEC: impossible d’ouvrir le DOCX: {e}", file=sys.stderr)
+        return 2
+
+    root = ET.fromstring(data)
+    found = False
+
+    for i, p in enumerate(root.findall(".//w:p", NS), start=1):
+        txt = "".join(t.text or "" for t in p.findall(".//w:t", NS))
+        txt_n = norm(txt)
+        hits = [needle for needle in FORBIDDEN if needle in txt_n]
+        if hits:
+            found = True
+            print(f"\n[paragraphe {i}]")
+            print("Hits :", ", ".join(hits))
+            print(txt_n)
+
+    if found:
+        print("\nECHEC: formes interdites encore présentes dans le DOCX.")
+        return 1
+
+    print("OK: aucune forme interdite trouvée dans le DOCX.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/build-annotations-index.mjs

@@ -1,28 +1,106 @@
+#!/usr/bin/env node
 // scripts/build-annotations-index.mjs
+// Construit dist/annotations-index.json à partir de src/annotations/**/*.yml
+// Supporte:
+//   - monolith : src/annotations/<pageKey>.yml
+//   - shard    : src/annotations/<pageKey>/<paraId>.yml   (paraId = p-<n>-...)
+// Invariants:
+//   - doc.schema === 1
+//   - doc.page (si présent) == pageKey déduit du chemin
+//   - shard: doc.paras doit contenir EXACTEMENT la clé paraId (sinon fail)
+//
+// Deep-merge non destructif (media/refs/comments dédupliqués), tri stable.
+
 import fs from "node:fs/promises";
 import path from "node:path";
 import YAML from "yaml";
 
-function parseArgs(argv) {
-  const out = {
-    inDir: "src/annotations",
-    outFile: "dist/annotations-index.json",
-  };
+const ROOT = process.cwd();
+const ANNO_ROOT = path.join(ROOT, "src", "annotations");
+const DIST_DIR = path.join(ROOT, "dist");
+const OUT = path.join(DIST_DIR, "annotations-index.json");
 
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg);
+}
 
-    if (a === "--in" && argv[i + 1]) out.inDir = argv[++i];
-    else if (a.startsWith("--in=")) out.inDir = a.slice("--in=".length);
+function isObj(x) {
+  return !!x && typeof x === "object" && !Array.isArray(x);
+}
+function isArr(x) {
+  return Array.isArray(x);
+}
 
-    if (a === "--out" && argv[i + 1]) out.outFile = argv[++i];
-    else if (a.startsWith("--out=")) out.outFile = a.slice("--out=".length);
+function normPath(s) {
+  return String(s || "")
+    .replace(/\\/g, "/")
+    .replace(/^\/+|\/+$/g, "");
+}
+
+function paraNum(pid) {
+  const m = String(pid).match(/^p-(\d+)-/i);
+  return m ? Number(m[1]) : Number.POSITIVE_INFINITY;
+}
+
+function stableSortByTs(arr) {
+  if (!Array.isArray(arr)) return;
+  arr.sort((a, b) => {
+    const ta = Date.parse(a?.ts || "") || 0;
+    const tb = Date.parse(b?.ts || "") || 0;
+    if (ta !== tb) return ta - tb;
+    return JSON.stringify(a).localeCompare(JSON.stringify(b));
+  });
+}
+
+function keyMedia(x) { return String(x?.src || ""); }
+function keyRef(x) {
+  return `${x?.url || ""}||${x?.label || ""}||${x?.kind || ""}||${x?.citation || ""}`;
+}
+function keyComment(x) { return String(x?.text || "").trim(); }
+
+function uniqUnion(dst, src, keyFn) {
+  const out = isArr(dst) ? [...dst] : [];
+  const seen = new Set(out.map((x) => keyFn(x)));
+  for (const it of (isArr(src) ? src : [])) {
+    const k = keyFn(it);
+    if (!k) continue;
+    if (!seen.has(k)) {
+      seen.add(k);
+      out.push(it);
+    }
   }
   return out;
 }
 
-async function exists(p) {
-  try { await fs.access(p); return true; } catch { return false; }
+function deepMergeEntry(dst, src) {
+  if (!isObj(dst) || !isObj(src)) return;
+
+  for (const [k, v] of Object.entries(src)) {
+    if (k === "media" && isArr(v)) { dst.media = uniqUnion(dst.media, v, keyMedia); continue; }
+    if (k === "refs" && isArr(v)) { dst.refs = uniqUnion(dst.refs, v, keyRef); continue; }
+    if (k === "comments_editorial" && isArr(v)) { dst.comments_editorial = uniqUnion(dst.comments_editorial, v, keyComment); continue; }
+
+    if (isObj(v)) {
+      if (!isObj(dst[k])) dst[k] = {};
+      deepMergeEntry(dst[k], v);
+      continue;
+    }
+
+    if (isArr(v)) {
+      const cur = isArr(dst[k]) ? dst[k] : [];
+      const seen = new Set(cur.map((x) => JSON.stringify(x)));
+      const out = [...cur];
+      for (const it of v) {
+        const s = JSON.stringify(it);
+        if (!seen.has(s)) { seen.add(s); out.push(it); }
+      }
+      dst[k] = out;
+      continue;
+    }
+
+    // scalar: set only if missing/empty
+    if (!(k in dst) || dst[k] == null || dst[k] === "") dst[k] = v;
+  }
 }
 
 async function walk(dir) {
@@ -30,111 +108,116 @@ async function walk(dir) {
   const ents = await fs.readdir(dir, { withFileTypes: true });
   for (const e of ents) {
     const p = path.join(dir, e.name);
-    if (e.isDirectory()) out.push(...(await walk(p)));
-    else out.push(p);
+    if (e.isDirectory()) out.push(...await walk(p));
+    else if (e.isFile() && /\.ya?ml$/i.test(e.name)) out.push(p);
   }
   return out;
 }
 
-function inferPageKeyFromFile(inDirAbs, fileAbs) {
-  // src/annotations/<page>.yml -> "<page>"
-  const rel = path.relative(inDirAbs, fileAbs).replace(/\\/g, "/");
-  return rel.replace(/\.(ya?ml|json)$/i, "");
+function inferExpectedFromRel(relNoExt) {
+  const parts = relNoExt.split("/").filter(Boolean);
+  const last = parts.at(-1) || "";
+  const isShard = parts.length > 1 && /^p-\d+-/i.test(last); // ✅ durcissement
+  const pageKey = isShard ? parts.slice(0, -1).join("/") : relNoExt;
+  const paraId = isShard ? last : null;
+  return { isShard, pageKey, paraId };
 }
 
-function assert(cond, msg) {
-  if (!cond) throw new Error(msg);
-}
+function validateAndNormalizeDoc(doc, relFile, expectedPageKey, expectedParaId) {
+  assert(isObj(doc), `${relFile}: doc must be an object`);
+  assert(doc.schema === 1, `${relFile}: schema must be 1`);
+  assert(isObj(doc.paras), `${relFile}: missing object key "paras"`);
 
-function isPlainObject(x) {
-  return !!x && typeof x === "object" && !Array.isArray(x);
-}
+  const gotPage = doc.page != null ? normPath(doc.page) : "";
+  const expPage = normPath(expectedPageKey);
 
-function normalizePageKey(s) {
-  // pas de / en tête/fin
-  return String(s || "").replace(/^\/+/, "").replace(/\/+$/, "");
-}
-
-function validateAndNormalizeDoc(doc, pageKey, fileRel) {
-  assert(isPlainObject(doc), `${fileRel}: document must be an object`);
-  assert(doc.schema === 1, `${fileRel}: schema must be 1`);
-  if (doc.page != null) {
+  if (gotPage) {
     assert(
-      normalizePageKey(doc.page) === pageKey,
-      `${fileRel}: page mismatch (page="${doc.page}" vs path="${pageKey}")`
+      gotPage === expPage,
+      `${relFile}: page mismatch (page="${doc.page}" vs path="${expectedPageKey}")`
+    );
+  } else {
+    doc.page = expPage;
+  }
+
+  if (expectedParaId) {
+    const keys = Object.keys(doc.paras || {}).map(String);
+    assert(
+      keys.includes(expectedParaId),
+      `${relFile}: shard mismatch: must contain paras["${expectedParaId}"]`
+    );
+    assert(
+      keys.length === 1 && keys[0] === expectedParaId,
+      `${relFile}: shard invariant violated: shard file must contain ONLY paras["${expectedParaId}"] (got: ${keys.join(", ")})`
     );
   }
-  assert(isPlainObject(doc.paras), `${fileRel}: missing object key "paras"`);
 
-  const parasOut = Object.create(null);
-
-  for (const [paraId, entry] of Object.entries(doc.paras)) {
-    assert(/^p-\d+-/i.test(paraId), `${fileRel}: invalid para id "${paraId}"`);
-
-    // entry peut être vide, mais doit être un objet si présent
-    assert(entry == null || isPlainObject(entry), `${fileRel}: paras.${paraId} must be an object`);
-
-    const e = entry ? { ...entry } : {};
-
-    // Sanity checks (non destructifs : on n’écrase pas, on vérifie juste les types)
-    if (e.refs != null) assert(Array.isArray(e.refs), `${fileRel}: paras.${paraId}.refs must be an array`);
-    if (e.authors != null) assert(Array.isArray(e.authors), `${fileRel}: paras.${paraId}.authors must be an array`);
-    if (e.quotes != null) assert(Array.isArray(e.quotes), `${fileRel}: paras.${paraId}.quotes must be an array`);
-    if (e.media != null) assert(Array.isArray(e.media), `${fileRel}: paras.${paraId}.media must be an array`);
-    if (e.comments_editorial != null) assert(Array.isArray(e.comments_editorial), `${fileRel}: paras.${paraId}.comments_editorial must be an array`);
-
-    parasOut[paraId] = e;
-  }
-
-  return parasOut;
-}
-
-async function readDoc(fileAbs) {
-  const raw = await fs.readFile(fileAbs, "utf8");
-  if (/\.json$/i.test(fileAbs)) return JSON.parse(raw);
-  return YAML.parse(raw);
+  return doc;
 }
 
 async function main() {
-  const { inDir, outFile } = parseArgs(process.argv.slice(2));
-  const CWD = process.cwd();
+  const pages = {};
+  const errors = [];
 
-  const inDirAbs = path.isAbsolute(inDir) ? inDir : path.join(CWD, inDir);
-  const outAbs = path.isAbsolute(outFile) ? outFile : path.join(CWD, outFile);
+  await fs.mkdir(DIST_DIR, { recursive: true });
 
-  // antifragile
-  if (!(await exists(inDirAbs))) {
-    console.log(`ℹ️  annotations-index: skip (input missing): ${inDir}`);
-    process.exit(0);
-  }
+  const files = await walk(ANNO_ROOT);
 
-  const files = (await walk(inDirAbs)).filter((p) => /\.(ya?ml|json)$/i.test(p));
-  if (!files.length) {
-    console.log(`ℹ️  annotations-index: skip (no .yml/.yaml/.json found in): ${inDir}`);
-    process.exit(0);
-  }
+  for (const fp of files) {
+    const rel = normPath(path.relative(ANNO_ROOT, fp));
+    const relNoExt = rel.replace(/\.ya?ml$/i, "");
+    const { isShard, pageKey, paraId } = inferExpectedFromRel(relNoExt);
 
-  const pages = Object.create(null);
-  let paraCount = 0;
-
-  for (const f of files) {
-    const fileRel = path.relative(CWD, f).replace(/\\/g, "/");
-    const pageKey = normalizePageKey(inferPageKeyFromFile(inDirAbs, f));
-    assert(pageKey, `${fileRel}: cannot infer page key`);
-
-    let doc;
     try {
-      doc = await readDoc(f);
+      const raw = await fs.readFile(fp, "utf8");
+      const doc = YAML.parse(raw) || {};
+
+      if (!isObj(doc) || doc.schema !== 1) continue;
+
+      validateAndNormalizeDoc(
+        doc,
+        `src/annotations/${rel}`,
+        pageKey,
+        isShard ? paraId : null
+      );
+
+      const pg = (pages[pageKey] ??= { paras: {} });
+
+      if (isShard) {
+        const entry = doc.paras[paraId];
+        if (!isObj(pg.paras[paraId])) pg.paras[paraId] = {};
+        if (isObj(entry)) deepMergeEntry(pg.paras[paraId], entry);
+
+        stableSortByTs(pg.paras[paraId].media);
+        stableSortByTs(pg.paras[paraId].refs);
+        stableSortByTs(pg.paras[paraId].comments_editorial);
+      } else {
+        for (const [pid, entry] of Object.entries(doc.paras || {})) {
+          const p = String(pid);
+          if (!isObj(pg.paras[p])) pg.paras[p] = {};
+          if (isObj(entry)) deepMergeEntry(pg.paras[p], entry);
+
+          stableSortByTs(pg.paras[p].media);
+          stableSortByTs(pg.paras[p].refs);
+          stableSortByTs(pg.paras[p].comments_editorial);
+        }
+      }
     } catch (e) {
-      throw new Error(`${fileRel}: parse failed: ${String(e?.message ?? e)}`);
+      errors.push({ file: `src/annotations/${rel}`, error: String(e?.message || e) });
     }
+  }
 
-    const paras = validateAndNormalizeDoc(doc, pageKey, fileRel);
-
-    // 1 fichier = 1 page (canon)
-    assert(!pages[pageKey], `${fileRel}: duplicate page "${pageKey}" (only one file per page)`);
-    pages[pageKey] = { paras };
-    paraCount += Object.keys(paras).length;
+  for (const [pageKey, pg] of Object.entries(pages)) {
+    const keys = Object.keys(pg.paras || {});
+    keys.sort((a, b) => {
+      const ia = paraNum(a);
+      const ib = paraNum(b);
+      if (Number.isFinite(ia) && Number.isFinite(ib) && ia !== ib) return ia - ib;
+      return String(a).localeCompare(String(b));
+    });
+    const next = {};
+    for (const k of keys) next[k] = pg.paras[k];
+    pg.paras = next;
   }
 
   const out = {
@@ -143,17 +226,21 @@ async function main() {
     pages,
     stats: {
       pages: Object.keys(pages).length,
-      paras: paraCount,
+      paras: Object.values(pages).reduce((n, p) => n + Object.keys(p.paras || {}).length, 0),
+      errors: errors.length,
     },
+    errors,
   };
 
-  await fs.mkdir(path.dirname(outAbs), { recursive: true });
-  await fs.writeFile(outAbs, JSON.stringify(out), "utf8");
+  if (errors.length) {
+    throw new Error(`${errors[0].file}: ${errors[0].error}`);
+  }
 
-  console.log(`✅ annotations-index: pages=${out.stats.pages} paras=${out.stats.paras} -> ${path.relative(CWD, outAbs)}`);
+  await fs.writeFile(OUT, JSON.stringify(out), "utf8");
+  console.log(`✅ annotations-index: pages=${out.stats.pages} paras=${out.stats.paras} -> dist/annotations-index.json`);
 }
 
 main().catch((e) => {
-  console.error("FAIL: build-annotations-index crashed:", e);
+  console.error(`FAIL: build-annotations-index crashed: ${e?.stack || 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/check-annotations-media.mjs

@@ -48,6 +48,9 @@ async function main() {
   let missing = 0;
   const notes = [];
 
+  // Optim: éviter de vérifier 100 fois le même fichier media
+  const seenMedia = new Set(); // src string
+
   for (const f of files) {
     const rel = path.relative(CWD, f).replace(/\\/g, "/");
     const raw = await fs.readFile(f, "utf8");
@@ -70,6 +73,10 @@ async function main() {
         const src = String(m?.src || "");
         if (!src.startsWith("/media/")) continue; // externes ok, ou autres conventions futures
 
+        // dédupe
+        if (seenMedia.has(src)) continue;
+        seenMedia.add(src);
+
         checked++;
         const p = toPublicPathFromUrl(src);
         if (!p) continue;
@@ -94,4 +101,4 @@ async function main() {
 main().catch((e) => {
   console.error("FAIL: check-annotations-media crashed:", e);
   process.exit(1);
-});
+});

scripts/check-annotations.mjs

@@ -27,11 +27,6 @@ function escRe(s) {
   return String(s).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function inferPageKeyFromFile(fileAbs) {
-  const rel = path.relative(ANNO_DIR, fileAbs).replace(/\\/g, "/");
-  return rel.replace(/\.(ya?ml|json)$/i, "");
-}
-
 function normalizePageKey(s) {
   return String(s || "").replace(/^\/+/, "").replace(/\/+$/, "");
 }
@@ -40,6 +35,31 @@ function isPlainObject(x) {
   return !!x && typeof x === "object" && !Array.isArray(x);
 }
 
+function isParaId(s) {
+  return /^p-\d+-/i.test(String(s || ""));
+}
+
+/**
+ * Supporte:
+ * - monolith: src/annotations/<pageKey>.yml -> pageKey = rel sans ext
+ * - shard   : src/annotations/<pageKey>/<paraId>.yml -> pageKey = dirname(rel), paraId = basename
+ *
+ * shard seulement si le fichier est dans un sous-dossier (anti cas pathologique).
+ */
+function inferFromFile(fileAbs) {
+  const rel = path.relative(ANNO_DIR, fileAbs).replace(/\\/g, "/");
+  const relNoExt = rel.replace(/\.(ya?ml|json)$/i, "");
+  const parts = relNoExt.split("/").filter(Boolean);
+  const base = parts[parts.length - 1] || "";
+  const dirParts = parts.slice(0, -1);
+
+  const isShard = dirParts.length > 0 && isParaId(base);
+  const pageKey = isShard ? dirParts.join("/") : relNoExt;
+  const paraId = isShard ? base : "";
+
+  return { pageKey: normalizePageKey(pageKey), paraId };
+}
+
 async function loadAliases() {
   if (!(await exists(ALIASES_PATH))) return {};
   try {
@@ -83,7 +103,11 @@ async function main() {
   const aliases = await loadAliases();
   const files = (await walk(ANNO_DIR)).filter((p) => /\.(ya?ml|json)$/i.test(p));
 
-  let pages = 0;
+  // perf: cache HTML par page (shards = beaucoup de fichiers pour 1 page)
+  const htmlCache = new Map();        // pageKey -> html
+  const missingDistPage = new Set();  // pageKey
+
+  let pagesSeen = new Set();
   let checked = 0;
   let failures = 0;
   const notes = [];
@@ -107,7 +131,7 @@ async function main() {
       continue;
     }
 
-    const pageKey = normalizePageKey(inferPageKeyFromFile(f));
+    const { pageKey, paraId: shardParaId } = inferFromFile(f);
 
     if (doc.page != null && normalizePageKey(doc.page) !== pageKey) {
       failures++;
@@ -121,20 +145,44 @@ async function main() {
       continue;
     }
 
+    // shard invariant (fort) : doit contenir paras[paraId]
+    if (shardParaId) {
+      if (!Object.prototype.hasOwnProperty.call(doc.paras, shardParaId)) {
+        failures++;
+        notes.push(`- SHARD MISMATCH: ${rel} (expected paras["${shardParaId}"] present)`);
+        continue;
+      }
+      // si extras -> warning (non destructif)
+      const keys = Object.keys(doc.paras);
+      if (!(keys.length === 1 && keys[0] === shardParaId)) {
+        notes.push(`- WARN shard has extra paras: ${rel} (expected only "${shardParaId}", got ${keys.join(", ")})`);
+      }
+    }
+
+    pagesSeen.add(pageKey);
+
     const distFile = path.join(DIST_DIR, pageKey, "index.html");
     if (!(await exists(distFile))) {
-      failures++;
-      notes.push(`- MISSING PAGE: dist/${pageKey}/index.html (from ${rel})`);
+      if (!missingDistPage.has(pageKey)) {
+        missingDistPage.add(pageKey);
+        failures++;
+        notes.push(`- MISSING PAGE: dist/${pageKey}/index.html (from ${rel})`);
+      } else {
+        notes.push(`- WARN missing page already reported: dist/${pageKey}/index.html (from ${rel})`);
+      }
       continue;
     }
 
-    pages++;
-    const html = await fs.readFile(distFile, "utf8");
+    let html = htmlCache.get(pageKey);
+    if (!html) {
+      html = await fs.readFile(distFile, "utf8");
+      htmlCache.set(pageKey, html);
+    }
 
     for (const paraId of Object.keys(doc.paras)) {
       checked++;
 
-      if (!/^p-\d+-/i.test(paraId)) {
+      if (!isParaId(paraId)) {
         failures++;
         notes.push(`- INVALID ID: ${rel} (${paraId})`);
         continue;
@@ -158,6 +206,7 @@ async function main() {
   }
 
   const warns = notes.filter((x) => x.startsWith("- WARN"));
+  const pages = pagesSeen.size;
 
   if (failures > 0) {
     console.error(`FAIL: annotations invalid (pages=${pages} checked=${checked} failures=${failures})`);
@@ -172,4 +221,4 @@ async function main() {
 main().catch((e) => {
   console.error("FAIL: annotations check crashed:", e);
   process.exit(1);
-});
+});

scripts/fix-docx-source.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import shutil
+import tempfile
+import unicodedata
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from zipfile import ZIP_DEFLATED, ZipFile
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+XML_NS = "http://www.w3.org/XML/1998/namespace"
+NS = {"w": W_NS}
+
+ET.register_namespace("w", W_NS)
+
+
+REPLACEMENTS = {
+    "coviabilité": "co-viabilité",
+    "sacroinstitutionnelle": "sacro-institutionnelle",
+    "technologistique": "techno-logistique",
+    "scripturonormative": "scripturo-normative",
+    "textesrepères": "textes-repères",
+    "ellemême": "elle-même",
+    "opérateur de d’archicration": "opérateur d’archicration",
+    "systèmes plusieurs statuts": "systèmes à plusieurs statuts",
+    "celle-ci se donne à voir": "Celle-ci se donne à voir",
+    "Pour autant il serait": "Pour autant, il serait",
+    "Telles peuvent être le cas de": "Tels peuvent être les cas de",
+}
+
+# volontairement NON auto-corrigé : "la co-viabilité devient ,"
+# ce cas demande une décision éditoriale humaine.
+
+
+def qn(tag: str) -> str:
+    prefix, local = tag.split(":")
+    if prefix != "w":
+        raise ValueError(tag)
+    return f"{{{W_NS}}}{local}"
+
+
+def norm(s: str) -> str:
+    return unicodedata.normalize("NFC", s or "")
+
+
+def paragraph_text(p: ET.Element) -> str:
+    return "".join(t.text or "" for t in p.findall(".//w:t", NS))
+
+
+def replaced_text(s: str) -> str:
+    out = norm(s)
+    for bad, good in REPLACEMENTS.items():
+        out = out.replace(bad, good)
+    return out
+
+
+def rewrite_paragraph_text(p: ET.Element, new_text: str) -> None:
+    ppr = p.find("w:pPr", NS)
+
+    for child in list(p):
+        if ppr is not None and child is ppr:
+            continue
+        p.remove(child)
+
+    r = ET.Element(qn("w:r"))
+    t = ET.SubElement(r, qn("w:t"))
+    t.set(f"{{{XML_NS}}}space", "preserve")
+    t.text = new_text
+    p.append(r)
+
+
+def process_document_xml(xml_path: Path) -> int:
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+
+    changed = 0
+
+    for p in root.findall(".//w:p", NS):
+        old = paragraph_text(p)
+        new = replaced_text(old)
+        if new != old:
+            rewrite_paragraph_text(p, new)
+            changed += 1
+
+    tree.write(xml_path, encoding="utf-8", xml_declaration=True)
+    return changed
+
+
+def repack_docx(tmpdir: Path, out_docx: Path) -> None:
+    tmp_out = out_docx.with_suffix(out_docx.suffix + ".tmp")
+    with ZipFile(tmp_out, "w", ZIP_DEFLATED) as zf:
+        for p in sorted(tmpdir.rglob("*")):
+            if p.is_file():
+                zf.write(p, p.relative_to(tmpdir))
+    shutil.move(tmp_out, out_docx)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Répare mécaniquement certaines scories DOCX.")
+    parser.add_argument("docx", help="Chemin du DOCX")
+    parser.add_argument("--in-place", action="store_true", help="Réécrit le DOCX en place")
+    args = parser.parse_args()
+
+    src = Path(args.docx)
+    if not src.exists():
+        print(f"ECHEC: fichier introuvable: {src}", file=sys.stderr)
+        return 2
+
+    out = src if args.in_place else src.with_name(src.stem + ".fixed.docx")
+
+    with tempfile.TemporaryDirectory(prefix="docx-fix-") as td:
+        td_path = Path(td)
+        with ZipFile(src) as zf:
+            zf.extractall(td_path)
+
+        document_xml = td_path / "word" / "document.xml"
+        if not document_xml.exists():
+            print("ECHEC: word/document.xml absent.", file=sys.stderr)
+            return 2
+
+        changed = process_document_xml(document_xml)
+        repack_docx(td_path, out)
+
+    print(f"OK: DOCX réparé par réécriture paragraphe/XML. Paragraphes modifiés: {changed}")
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+    raise SystemExit(main())

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/refresh-chapter2.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+DOCX="sources/docx/archicrat-ia/Chapitre_2–Archeogenese_des_regimes_de_co-viabilite-version_officielle.docx"
+MANIFEST="sources/manifest.yml"
+ONLY="archicrat-ia/chapitre-2"
+
+echo "== Audit source avant fix =="
+if ! python3 scripts/audit-docx-source.py "$DOCX"; then
+  echo
+  echo "== Fix source =="
+  python3 scripts/fix-docx-source.py --in-place "$DOCX"
+
+  echo
+  echo "== Audit source après fix =="
+  python3 scripts/audit-docx-source.py "$DOCX"
+fi
+
+echo
+echo "== Réimport =="
+node scripts/import-docx.mjs --manifest "$MANIFEST" --only "$ONLY" --force
+
+echo
+echo "== Build =="
+npm run build
+
+echo
+echo "== Tests =="
+npm test

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-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/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,37 +12,46 @@ 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.
+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 comme s’il n’avait plus à se déclarer, régule sur des justifications faiblement exposables, et agit dans des configurations où la mise en débat est neutralisée, comprimée ou vidée de prise. Il est devenu ce que nous proposons de nommer archicratistique — c’est-à-dire qu’il agit selon un régime de régulation autonome où la scène d’épreuve se trouve neutralisée, mimée, relocalisée hors d’atteinte ou rendue pratiquement inopérante ; où les justifications demeurent faiblement exposables ou inopposables pour les affectés ; où le délai de la dispute est comprimé, fictif ou supprimé dans les faits ; et où la temporalité contradictoire n’est plus tenue comme scène praticable de reprise. 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. Cela ne signifie pas que toute scène praticable ait disparu ; cela signifie plutôt que leur repérage, leur préservation et leur réactivation deviennent le problème politique décisif de notre temps.
 
-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.
+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ée. 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.
+À rebours de l’archicratie, nous appelons désarchicration le processus par lequel 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 à certains dispositifs : non comme accident, mais comme condition de fonctionnement. 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 dans laquelle l’arcalité et la cratialité continuent d’opérer tandis que l’archicration se trouve neutralisée, relocalisée hors d’atteinte, ou rendue pratiquement inopérante, 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 ?
+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.
+Ce que nous vivons, ce que nous subissons parfois, ce que nous habitons souvent sans le voir, ce n’est pas la montée silencieuse de “régimes archicratiques” au sens fort, mais la prolifération de configurations désarchicratiques et archicratistiques, parfois portées jusqu’à la dérive autarchicratique. Il s’agit de dispositifs de régulation où la scène devient difficilement praticable, neutralisée ou relocalisée hors d’atteinte ; où les fondements deviennent faiblement invoqués, euphémisés ou difficilement exposables ; où les décisions sont de moins en moins motivées de manière opposable ; et où le temps du différé se trouve comprimé, vidé de sa prise ou rendu fictif.
 
-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.
+Il ne s’agit pas nécessairement de régimes de domination au sens classique, mais de formes de régulation administrative dans lesquelles l’épreuve est neutralisée, mimée ou rendue pratiquement inopérante, tandis que le théâtre politique s’affaiblit, se vide de sa prise ou se trouve relocalisé hors d’atteinte. Il ne s’agit donc pas ici de l’archicratie comme méta-régime viable de régulation, mais de son envers pratique : des dispositifs qui continuent d’opérer tout en neutralisant les conditions de leur propre mise en discussion. Se déploient ainsi des chaînes de décision où l’administration algorithmique des droits, la codification silencieuse des trajectoires et la performativité de normes automatiques dont le contradictoire est neutralisé ou vidé de prise tendent à soustraire la régulation à l’épreuve plutôt qu’à l’instituer.
 
-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.
+Il nous faut alors un paradigme, non pour idéaliser une alternative, mais pour diagnostiquer cette configuration, pour la rendre intelligible, 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 lorsque les légitimations deviennent faiblement visibles, lorsque les scènes instituées sont neutralisées, vidées ou relocalisées hors d’atteinte, et lorsque les temporalités différées de la décision se trouvent comprimées, fictives ou pratiquement supprimées. Il s’agit de rendre compte des zones grises, des seuils, des bifurcations et des fonctions qui régulent sans jamais statuer.
 
-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.
+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.
 
-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.
+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, et un levier de critique effective des dispositifs. C’est interroger ce qui gouverne à débat neutralisé, ce qui ordonne sur des justifications difficilement exposables, ce qui affecte en se soustrayant aux formes ordinaires de visibilité, de contestation et de reprise. C’est rouvrir la possibilité d’une pensée politique critique du réel.
 
-À 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.
+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.
 
-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.
+Or, ce que nous observons aujourd’hui dans la majorité des dispositifs régulateurs, c’est une crise de la souveraineté représentative non pas tant dans sa légitimité déclarée 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 souvent à peser sur les déterminations majeures ; les figures institutionnelles traditionnelles persistent, mais elles ne sont plus toujours les lieux effectifs de production, de justification et de révision des normes. Ce déphasage — structurel, et non conjoncturel — ne signifie pas la disparition du politique, mais la transformation de ses modes de régulation.
 
-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.
+À cette crise de la souveraineté s’ajoute l’épuisement des grilles de lecture fondées sur le sujet autonome, contractuel et 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 et de participer à une volonté générale informée, n’a plus de prise suffisante sur des architectures décisionnelles automatisées, sur des normes codifiées par délégation, sur des processus algorithmiques opérant à distance ou sans concertation réelle. Le sujet y est souvent affecté avant même d’avoir été informé ; inclus sans être consulté ; contraint sans pouvoir formuler un désaccord effectivement opposable. La subjectivité politique classique se trouve ainsi contournée par des formats de décision qui n’appellent plus nécessairement ni la volonté, ni la délibération, ni même la conscience explicite des sujets affectés.
 
-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.
+Mais cette crise des catégories héritées n’est pas une vacance. Elle signale au contraire l’émergence de formes de régulation dont les prises réelles se redistribuent selon des logiques techno-fonctionnelles, administratives, protocolaires ou computationnelles. Ce ne sont pas des formes qu’il faut appeler archicratiques au sens fort, dès lors qu’elles tendent précisément à soustraire la régulation à la scène d’épreuve ; elles relèvent plutôt de dynamiques de désarchicration, d’archicratistique, ou, lorsqu’elles se referment durablement sur leur propre logique d’exécution, de dérives autarchicratiques.
 
-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.
+Ce que nous voyons proliférer, ce sont des régulations discrètes, réparties, non centralisées, opérant par la norme, le calcul, la procédure, le protocole, l’interface ou le flux : décisions à fondement peu visible, à justification faible, à énonciateur diffus, qui se donnent comme évidences procédurales, injonctions techniques ou impératifs statistiques. L’ordre n’y est plus principalement commandé ; il est implémenté. Il ne se fonde plus toujours dans une loi explicitement débattue ; il s’inscrit dans des chaînes opératoires, des standards, des métriques, des architectures logicielles ou des agencements institutionnels partiellement soustraits à l’épreuve.
 
-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.
+Cette montée autarchicratique 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 effective. Ce sont des formes de régulation qui ne sont pas nécessairement illégales, mais qui échappent progressivement à une mise en scène démocratique substantielle. Le débat n’y est pas frontalement supprimé : il est rendu inopérant. Les délais ne sont pas toujours abolis : ils deviennent insuffisants, fictifs ou impraticables. Les voies de recours ne sont pas nécessairement closes en droit : elles cessent d’être effectivement opposables. L’autarchicratie ne désigne donc pas ici un méta-régime symétrique de l’archicratie, mais la dérive par laquelle des architectures régulatrices continuent d’opérer tout en se soustrayant à la scène d’épreuve, en affaiblissant l’exposition de leurs fondements et en comprimant le politique dans l’exécution performative de leurs propres procédures.
+
+Mais cette prolifération n’épuise pas le champ des régulations contemporaines : elle rend d’autant plus décisif le repérage des scènes encore tenables, des médiations encore opposables et des prises susceptibles d’être réinstituées.
+
+Dès lors, ce que ce chapitre propose, ce n’est pas de rebaptiser “archicratie” la non-scène contemporaine, mais de construire un paradigme capable de la diagnostiquer. Le paradigme archicratique n’est pas un paradigme de la non-scène ; il est une grammaire critique permettant de repérer les conditions sous lesquelles une régulation devient fondée, opérante et révisable — ou, au contraire, dérive vers l’opacité, l’indisputabilité et la fermeture, c’est-à-dire l’autarchicratie. Il ne vise donc pas à célébrer une mutation silencieuse du pouvoir, mais à rendre visibles, pensables et opposables les écarts entre une régulation pleinement archicratique, articulant arcalité, cratialité et archicration, et des dispositifs qui, tout en continuant d’opérer, se soustraient à la scène de leur propre épreuve. C’est à cette condition qu’un tel paradigme peut prétendre à une véritable portée diagnostique, critique et politique.
+
+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 neutralisées, mimées ou relocalisées hors d’atteinte ; fondements opacifiés, euphémisés ou difficilement exposables ; délais comprimés, fictifs ou pratiquement 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, avec des délais comprimés et un contradictoire fortement réduit ; régulations sociales massives imposées par décret, par indicateurs, par plateformes ; gouvernance par courbe épidémique, avec des justifications largement internalisées dans la logique de l’anticipation sanitaire. 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 à travers des chaînes de décision faiblement visibles, à scène d’épreuve comprimée ou relocalisée, et à fondements difficilement exposables pour ceux qu’ils affectent. Ce n’est pas la fin du politique, c’est sa mutation silencieuse. Et c’est cette mutation que le paradigme archicratique nous permet de penser, de cartographier et de critiquer — à condition qu’il se dote d’une architecture rigoureuse, d’une typologie opératoire, d’une exigence de validation et d’un langage partagé.
 
 ## 1.1 — Hypothèse fondatrice : L’archicratie comme paradigme triadique de régulation
 
@@ -52,11 +61,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 +101,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 +117,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 +131,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 +201,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 +223,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 +235,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 +253,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 +265,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 +283,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 +305,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 +313,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 +321,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 +366,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 +382,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 +396,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 +414,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 +492,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 +502,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 +566,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 +588,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 +629,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 +641,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 +657,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 +731,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 +759,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 +851,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 +913,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 +969,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 +1017,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 +1101,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 +1117,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 +1143,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 +1153,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 +1167,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 +1220,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 +1239,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 +1289,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 +1361,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 +1371,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 +1437,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 +1475,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 +1495,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 +1537,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,7 @@ source:
   kind: docx
   path: "sources/docx/archicrat-ia/Chapitre_2–Archeogenese_des_regimes_de_co-viabilite-version_officielle.docx"
 ---
+
 À 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.
@@ -62,53 +63,63 @@ L’histoire des communautés et sociétés humaines, si elle se laisse parfois
 
 Il ne s’agit pas de reconstruire une chronologie historique, mais de mettre au jour les mécanismes canoniques de la régulation, ces *morphologies fondamentales* par lesquelles les groupes humains ont inscrit, encodé, différé ou orchestré leurs équilibres de pouvoir, de normativité et d’organisation des conflits. Chacun de ces mécanismes constitue une forme conceptuellement stabilisée, susceptible de structurer la pensée des *co-viabilités* sociales selon les trois pôles de l’*archicratie* : *arcalité*, *cratialité* et *archicration*.
 
-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 :
+Nous allons donc développer une typologie de douze méta-régimes archicratiques spécifiques, chacun incarnant une logique d’agencement particulière entre les trois vecteurs fondamentaux du pouvoir régulateur ; cette typologie sera ensuite prolongée par un treizième plan différentiel-hybride, consacré aux compositions instables, mixtes ou saisonnières des régimes. Ces douze 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 ;
+- méta-régime archicratique 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é ;
+- méta-régime archicratique sacro-institutionnelle non étatique, 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 ;
+- méta-régime archicratique 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 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 ;
+- méta-régime archicratique 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‑cosmologique*, où la forme régulatrice prend appui sur un ordre du monde fixé par l’écriture, et où les structures sociales se calquent sur la grammaire cosmique consignée dans le texte sacré, garantissant l’homologie entre le céleste, le terrestre et le politique ;
+- *méta-régime archicratique scripturo-cosmologique*, où la forme régulatrice prend appui sur un ordre du monde stabilisé par l’écriture, et où les structures sociales se calquent sur une grammaire cosmique consignée dans un texte cosmographique de référence, garantissant l’homologie entre le céleste, le terrestre et le politique ;
 
 
 
-- L’*archicratie théologique*, fondée sur la révélation comme source immédiate d’obligation, où la parole divine, reçue, transmise et commentée, devient principe de légitimation en soi. L’autorité y procède d’une instance transcendante, et la régulation s’exerce par médiation interprétative — prophétique, doctrinale ou exégétique — sans que la norme ait besoin d’autre justification que sa provenance ;
+- *méta-régime archicratique théologique*, fondé sur la révélation comme source immédiate d’obligation, où la parole divine, reçue, transmise et commentée, devient principe de légitimation en soi. L’autorité y procède d’une instance transcendante, et la régulation s’exerce par médiation interprétative — prophétique, doctrinale ou exégétique — sans que la norme ait besoin d’autre justification que sa provenance ;
 
 
 
-- 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 ;
+- méta-régime archicratique 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 ;
+- méta-régime archicratique épistémique, dans lequel 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 esthético‑symbolique*, qui opère par l’ajustement du champ sensible, canonise certaines formes comme convenables ou désirables, et instaure l’ordre à travers la stabilisation des styles perceptifs, sans passage par le discours ni par l’injonction explicite ;
+- méta-régime archicratique esthético-symbolique, qui opère par l’ajustement du champ sensible, canonise certaines formes comme convenables ou désirables, et instaure l’ordre à travers la stabilisation des styles perceptifs, sans passage par le discours ni par l’injonction explicite ;
 
 
 
-- Les *archicrations différentielles et hybrides*, plus contemporaines, instables et multi‑situées, où les méta‑régimes coexistent, se chevauchent, s’annulent ou s’intensifient selon les contextes, sans stabilisation systémique.
+- méta-régime archicratique normativo-politique, dans lequel la co-viabilité se règle par l’institution explicite de normes politiques, de procédures de légitimation, de droits, de souverainetés et de scènes publiques de délibération, de contentieux ou de représentation ;
+
+
+
+- méta-régime archicratique marchand, où l’échange, le prix, la solvabilité, le contrat et l’arbitrage concurrentiel deviennent les opérateurs principaux de régulation des conduites, des accès et des priorités ;
+
+
+
+- méta-régime archicratique guerrier, dans lequel l’ordre se construit autour de l’épreuve, de l’honneur, du commandement, de la discipline, de la menace organisée et de la violence armée réglée comme scène d’appartenance et de hiérarchisation.
+
+  À ces douze méta-régimes archicratiques spécifiques s’ajoute un treizième plan différentiel-hybride, consacré aux compositions instables, mixtes, saisonnières ou composites des régimes, sans que ces configurations constituent pour autant un méta-régime spécifique supplémentaire.
 
 L’ordre d’exposition n’est pas une flèche historique : chaque méta-régime est un attracteur de *co-viabilité* propre susceptible de récurrences, d’emboîtements et d’hybridations. Aucun ne “remplace” les autres ; tous se recomposent tout au long de l’évolution des sociétés humaines.
 
-Il convient de préciser avec clarté que l’*archicratie cybernético-calculatoire* — bien que porteur d’une dynamique de régulation hautement originale — n’est pas ici intégré à cette typologie en tant qu’archétype. Sa singularité ne réside pas tant dans sa forme pure que dans sa configuration contemporaine, historiquement située et techniquement circonscrite. Pour cette raison, son analyse détaillée est reportée en fin de chapitre.
+Il convient de préciser avec clarté que l’*archicratie cybernético-calculatoire* — bien que porteuse d’une dynamique de régulation hautement originale — n’est pas ici intégrée à cette typologie en tant qu’archétype. Sa singularité ne réside pas tant dans sa forme pure que dans sa configuration contemporaine, historiquement située et techniquement circonscrite. Pour cette raison, son analyse détaillée est reportée en fin de chapitre.
 
 Ce détour typologique constitue le socle conceptuel et la grille d’intelligibilité permettant d’analyser les régimes régulateurs historiquement réalisés. Sans cette abstraction structurante, l’analyse risquerait de s’abîmer dans un empirisme sans principes ; à l’inverse, sans mise à l’épreuve historico-comparative, le modèle archicratique courrait le risque de rester suspendu dans l’abstraction.
 
-Les *archicrations* décrites ci-après constituent une cartographie d’archétypes irréductibles. Chacun se définit par la conjonction d’un opérateur de validité (ce qui fait tenir le méta-régime), d’un locus de scène (où se joue l’épreuve) et d’une temporalité régulatrice (rythmes du faire, de l’attente et de la relance). Notre visée n’est ni l’exhaustivité ni la chronologie, mais la mise au jour de formes de consistance qui, dans des contextes hétérogènes, assurent la tenue d’un ordre. Avant d’introduire un nom, nous appliquons un test d’irréductibilité : à défaut de cumul des trois critères, la configuration est traitée intra-section comme variante (signalée par encadré) ou comme composition différentielle (2.2.10). Cette discipline nomenclaturale évite l’inflation de catégories et garantit la lisibilité des discontinuités conceptuelles. Les pages qui suivent doivent ainsi être lues comme un atlas de mécanismes canoniques — non comme un inventaire fermé.
+Les *archicrations* décrites ci-après constituent une cartographie d’archétypes irréductibles. Chacun se définit par la conjonction d’un opérateur de validité (ce qui fait tenir le méta-régime), d’un locus de scène (où se joue l’épreuve) et d’une temporalité régulatrice (rythmes du faire, de l’attente et de la relance). Notre visée n’est ni l’exhaustivité ni la chronologie, mais la mise au jour de formes de consistance qui, dans des contextes hétérogènes, assurent la tenue d’un ordre. Avant d’introduire un nom, nous appliquons un test d’irréductibilité : à défaut de cumul des trois critères, la configuration est traitée intra-section comme variante (signalée par encadré) ou comme composition différentielle (2.2.13). Cette discipline nomenclaturale évite l’inflation de catégories et garantit la lisibilité des discontinuités conceptuelles. Les pages qui suivent doivent ainsi être lues comme un atlas de mécanismes canoniques — non comme un inventaire fermé.
 
 ### 2.2.1 — *Archicrations proto-symboliques —* gestuelles et linguistiques
 
@@ -120,7 +131,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 +141,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 +370,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
 
@@ -503,7 +514,7 @@ Ce qui s’invente ici, c’est une forme d’intelligence collective, non chari
 
 C’est en ce sens que la *mégamachine* dévoile ici que la régulation peut se passer de voix et de récit fondateur — mais non de trame, de rythme et d’agencement. Elle révèle que le politique peut être entièrement disséminé dans les contraintes matérielles, dans les architectures opératoires et dans les successions normalisées d’actions coordonnées.
 
-En cela, l*e régime techno-logistique* légitime sa propre autorité par la viabilité reproductible qu’elle assure, par la stabilité qu’elle permet et par l’efficience qu’elle distribue. Elle fonde un ordre qui repose sur l’interopérabilité maintenue et généralisable ; un lien social qui ne se raconte plus, mais qui s’ajuste et se répète dans les activités pour assurer la viabilité collective.
+En cela, l*e régime techno-logistique* légitime sa propre autorité par la viabilité reproductible qu’il assure, par la stabilité qu’elle permet et par l’efficience qu’elle distribue. Il fonde un ordre qui repose sur l’interopérabilité maintenue et généralisable ; un lien social qui ne se raconte plus, mais qui s’ajuste et se répète dans les activités pour assurer la viabilité collective.
 
 De plus, ce régime incarne une organisation non représentée, un pouvoir disséminé, une intelligence structurelle dont la robustesse tient précisément à son retrait du symbolique et à son efficacité immanente et concrète. Pour autant, il ne s’agit pas ici d’idéaliser la *mégamachine* — ni de masquer ses asymétries, ses saturations et ses vulnérabilités. Il s’agit plutôt de reconnaître qu’elle représente une modalité complète et cohérente du politique, dont la force tient à ce qu’elle ne se présente jamais comme telle. C’est là l’un de ses paradoxes majeurs : elle ne dit pas qu’elle régule et pourtant elle régule ; elle ne représente pas le pouvoir bien qu’elle distribue des gestes, des charges et des cadences.
 
@@ -521,7 +532,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*
 
@@ -611,7 +622,7 @@ Ce processus de reconnaissance repose enfin sur une *économie des supports*. La
 
 Ainsi, l’*archicration scripturo-normative* s’exerce dans la scène d’invocation d’inscription : celle qui lie un acte, des supports, des parties prenantes et une situation. L’écrit ne tranche pas en soi, c’est l’agencement circonstancié qui le rend *tranchant*. Autrement dit : ce n’est pas l’énonciation d’un écrit en lui-même qui décide d’un cas de dette ou d’héritage, mais l’agencement de multiples éléments situés : la présence d’un duplicata authentifié, la concordance d’un sceau, voire l’attestation par témoins convoqués dans un lieu reconnu de délibération, comme le montre par exemple la tablette M768 de Larsa (Charpin, 2006). Ce qui est en jeu, à chaque conflit, à chaque réclamation, à chaque revendication statutaire, c’est la possibilité de faire reconnaître la validité d’un lien au travers de la textualité disponible. Ainsi, l’écriture ne garantit pas l’ordre, mais le rend *disponible à la reconnaissance*, sous réserve de conditions précises de mobilisation.
 
-Si ce méta-régime produit une nouvelle modalité de régulation, ce n’est pas uniquement par la codification explicite des obligations, ni par la stabilité différée des statuts, mais par la capacité qu’elle déploie à structurer une *co-viabilité* étendue sans centralité imposée. Cette modalité spécifique de régulation archicratique n’a pas toujours besoin d’une instance souveraine incarnée, ni d’un dogme normatif partagé. Il organise, surtout et avant tout, la coexistence sociale par l’articulation de lien d’inscriptions, de supports et de pratiques d’activation. Il propose une manière d’ajuster les rapports humains sans avoir à les harmoniser idéologiquement ou à les soumettre à un pouvoir visible. Il règle sans mythifier, il reconnaît sans sacraliser. En cela, il est performatif.
+Si ce méta-régime produit une nouvelle modalité de régulation, ce n’est pas uniquement par la codification explicite des obligations, ni par la stabilité différée des statuts, mais par la capacité qu’elle déploie à structurer une *co-viabilité* étendue sans centralité imposée. Cette modalité spécifique de régulation archicratique n’a pas toujours besoin d’une instance souveraine incarnée, ni d’un dogme normatif partagé. Elle organise, surtout et avant tout, la coexistence sociale par l’articulation de lien d’inscriptions, de supports et de pratiques d’activation. Il propose une manière d’ajuster les rapports humains sans avoir à les harmoniser idéologiquement ou à les soumettre à un pouvoir visible. Il règle sans mythifier, il reconnaît sans sacraliser. En cela, il est performatif.
 
 De plus, cette capacité à maintenir une stabilité relationnelle à travers des documents activables repose sur une infrastructure scripturale qui transcende les sites de production. L’écriture se déploie dans un réseau d’inscriptions qui permet à une société de maintenir des régularités sans recourir à la mémoire collective, ni à un arbitre omniprésent. Le cœur de sa puissance régulatrice réside dans sa disposition à créer des médiations trans-situationnelles, c’est-à-dire à produire des effets là où le contexte immédiat ne suffit pas à trancher tout en permettant l’adaptation aux cas rencontrés.
 
@@ -623,7 +634,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.
 
@@ -1006,7 +1017,7 @@ Cette logique est particulièrement visible dans les régimes où l’histoire o
 
 Ainsi que l’a étudié Yuri Pines, l’historiographie impériale chinoise, loin d’être descriptive, « produit de la normativité en articulant le présent à un passé exemplaire, selon une logique rituelle et politique du modèle transmis » (*The Everlasting Empire*, 2012). On retrouve cette même logique dans les livres mérovingiens, où la *Chronique de Frédégaire* reconstruit la succession dynastique autour de la maison royale légitime, ou encore dans les livres impériaux japonais (Nihon Shoki), où les mythes d’origine sont tressés avec les règnes historiques pour fonder la légitimité de l’empereur par filiation divine.
 
-Cette régulation est à la fois non sacrée (au sens théologique) et non légale (au sens normatif) : il repose sur une autre forme de régularité qui est celle de la reconduction ordonnée du pouvoir par mémoire racontée. La norme naît ici de la densité narrative des précédents : parce que tel geste fut accompli par tel souverain canonisé, parce que tel règne est tenu pour fondateur, parce que telle conquête est inscrite comme légitime, alors s’impose une obligation implicite d’inscription, de conformité et d’alignement.
+Cette régulation est à la fois non sacrée (au sens théologique) et non légale (au sens normatif) : elle repose sur une autre forme de régularité qui est celle de la reconduction ordonnée du pouvoir par mémoire racontée. La norme naît ici de la densité narrative des précédents : parce que tel geste fut accompli par tel souverain canonisé, parce que tel règne est tenu pour fondateur, parce que telle conquête est inscrite comme légitime, alors s’impose une obligation implicite d’inscription, de conformité et d’alignement.
 
 En ce sens, l’*arcalité historiographique* est une *arcalité* indirecte bien que puissante : elle fonde l’obligation non en la formulant, mais en racontant le lieu, la manière et les figures à travers lesquelles cette obligation a opéré dans le passé. Non à travers le temps cyclique du cosmos, ni par le temps eschatologique de la révélation, mais le temps linéarisé, daté, stratifié, inscrit dans des chaînes de transmission intériorisées. Ce méta-régime produit donc un type d’*arcalité* spécifique : non pas fondée sur un fondement extérieur, mais sur l’accumulation scripturaire de ce qui fut. L’ordre n’est pas donné : il est hérité, raconté, enregistré — cette mémoire devient le sol de la régulation.
 
@@ -1021,7 +1032,7 @@ Ainsi, l’autorité historiographique agit par une puissance de précédent : l
 
 Ce mécanisme produit un effet d’entraînement. L’action présente ne prend sens qu’à travers l’alignement sur une chaîne de précédents. De sorte qu’être légitime, c’est apparaître comme le prolongement d’un récit déjà institué. Comme l’a montré Michel de Certeau, l’historiographie est une technique d’encadrement du présent par le passé. (*L’écriture de l’histoire*, 1975).
 
-Dans ce méta-régime, la contrainte est douce, mais réelle. Elle se manifeste par la naturalisation progressive de certaines figures et de certaines trajectoires comme les seules valables. Le récit impose moins qu’il n’organise, en cela qu’elle circonscrit le pensable, oriente les loyautés, modèle les attentes. Il devient alors difficile d’agir sans se référer à un précédent, ou de penser en dehors de la séquence reconnue.
+Dans ce méta-régime, la contrainte est douce, mais réelle. Elle se manifeste par la naturalisation progressive de certaines figures et de certaines trajectoires comme les seules valables. Le récit impose moins qu’il n’organise, en ce qu’il circonscrit le pensable, oriente les loyautés, modèle les attentes. Il devient alors difficile d’agir sans se référer à un précédent, ou de penser en dehors de la séquence reconnue.
 
 Ce qui fait autorité ici, ce n’est pas la véracité du récit, mais sa capacité à produire de la valorisation et du suivi. Comme l’a souligné Paul Veyne dans *Les Grecs ont-ils cru à leurs mythes ?* (1983), ce qui compte dans ces récits, ce n’est pas leur vérité historique, mais leur efficacité dans la structuration de ce que l’on croit devoir reproduire. Elle repose sur une économie de la fidélité aux figures racontées qui s’exerce par une mémoire scripturale qui agit non par argument, mais par filiation, par continuité, par actualisation d’un passé raconté comme porteur d’autorité.
 
@@ -1045,15 +1056,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 +1185,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 +1229,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 +1316,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 +1340,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.
 
@@ -2073,15 +2084,18 @@ Ce tableau rend visible ce qui, sans lui, resterait épars : la capacité des so
 
 C’est ce que cette dernière sous-section nous a permis de comprendre : l’*archicratie* ne relève pas d’un principe de stabilité ontologique, mais d’un agencement toujours renouvelé, parfois paradoxal, souvent inattendu, entre des vecteurs fondamentaux qui se recomposent dans l’épaisseur des pratiques sociales. Le politique, ainsi entendu, n’est jamais réduit à l’État, à la loi ou au contrat : il est ce tissu complexe, fragile et tenace, par lequel les sociétés organisent la possibilité de vivre ensemble — même lorsque les formes de cette organisation échappent aux catégories usuelles.
 
-La section 2.2 s’achève donc ici, dans l’élargissement de notre carte conceptuelle : après les méta-régimes chimiquement purs, elle intègre les méta-régimes marginaux, mixtes, alternatifs — sans céder ni à la confusion, ni au relativisme. La scène est désormais posée pour le basculement que préparera le chapitre suivant : celui d’une topologie comparée des philosophies du pouvoir, où il s’agira non plus de cartographier des formes de régulation, mais de penser leurs principes d’intelligibilité, leurs axiologies et leurs conditions ontologiques de légitimation.
+La section 2.2 s’achève donc ici, dans l’élargissement de notre carte conceptuelle : après les méta-régimes les plus nettement différenciés, elle intègre les méta-régimes marginaux, mixtes, alternatifs — sans céder ni à la confusion, ni au relativisme. La scène est désormais posée pour le basculement que préparera le chapitre suivant : celui d’une topologie comparée des philosophies du pouvoir, où il s’agira non plus de cartographier des formes de régulation, mais de penser leurs principes d’intelligibilité, leurs axiologies et leurs conditions ontologiques de légitimation.
 
 ### Typologie archéogénétique des méta-régimes régulateurs
 
 Au terme de ce parcours analytique, la typologie que nous avons rigoureusement établie ne saurait être interprétée comme une classification figée, ni comme un inventaire empirique des régulations observables dans l’histoire humaine. Elle doit être comprise comme une cartographie ontologique des formes de co-viabilité possibles — c’est-à-dire comme une formalisation des modes par lesquels une société institue les conditions de son maintien, de sa reproduction, de sa transformation.
 
-En distinguant treize *méta-régimes archicratiques* — chacun structuré selon une *composition singulière entre arcalité, cratialité et archicration* — nous avons dégagé des formes pures de régulation, parfois chimiquement distinctes, parfois différentielles ou hybrides. Ces treize méta-régimes — proto-symbolique, sacral non étatique, techno-logistique, scripturo-normatif, scripturo-cosmologique, théologique, historiographique, épistémique, esthético-symbolique, normativo-politique, marchand, guerrier, ainsi que les configurations différentielles et hybrides — constituent les pôles structurants de cette archétypologie. Ces formes ne sont pas des époques, ni des stades évolutifs, ni des seuils de complexité : elles sont des matrices de cohérence régulatrice, des agencements symboliques et politiques par lesquels un ordre peut s’instituer, se maintenir, se réguler sans nécessairement recourir à la souveraineté étatique, à la transcendance divine ou à l'efficacité technocratique.
+En distinguant douze méta-régimes archicratiques spécifiques — chacun structuré selon une composition singulière entre arcalité, cratialité et archicration — puis en ouvrant un treizième plan différentiel-hybride, nous avons dégagé des formes de régulation nettement distinctes, mais aussi des configurations composites, instables ou saisonnières.  
+Ces douze méta-régimes spécifiques — proto-symbolique, sacral non étatique, techno-logistique, scripturo-normatif, scripturo-cosmologique, théologique, historiographique, épistémique, esthético-symbolique, normativo-politique, marchand et guerrier — constituent les pôles structurants de cette archétypologie ; le plan différentiel-hybride en marque l’ouverture composite, sans constituer pour autant un méta-régime spécifique supplémentaire.
 
-Certains régimes archicratiques reposent sur une *mimesis* rituelle (*proto-symbolique*) ou sur l’autorité sacrale (*sacral non étatique* et *théologique*) ; d’autres sur l’ingénierie *techno-logistique* des flux, sur la *scripturalité normée* et l’inscription du droit dans un ordre cosmologique explicite (*scripturo-normatif* et *scripturo-cosmologique*), sur l’épreuve marchande, sur le combat d’honneur (*guerrier*) ou sur la juridicisation *normativo-politique* ; d’autres encore sur des régimes de savoir (*épistémiques*) et de style sensible (*esthético-symboliques*), où la codification affective, le jeu, le don ou le silence structurent la *co-viabilité*. Tous ont en commun d’articuler, selon des tensions spécifiques, une forme (*arcalité*), une force (*cratialité*), et une scène (*archicration*). Et c’est cette trialectique dynamique — jamais hiérarchique, jamais univoque — qui constitue le cœur du modèle archicratique.
+Ces formes ne sont pas des époques, ni des stades évolutifs, ni des seuils de complexité : elles sont des matrices de cohérence régulatrice, des agencements symboliques et politiques par lesquels un ordre peut s’instituer, se maintenir, se réguler sans nécessairement recourir à la souveraineté étatique, à la transcendance divine ou à l'efficacité technocratique.
+
+Certains régimes archicratiques reposent sur une *mimesis* rituelle (*proto-symbolique*) ou sur l’autorité sacrale (*sacral non étatique* et *théologique*) ; d’autres sur l’ingénierie techno-logistique des flux, sur la scripturalité normée (*scripturo-normatif*) et sur l’inscription d’un ordre cosmologique dans des textualités de référence (*scripturo-cosmologique*), sur l’épreuve marchande, sur le combat d’honneur (*guerrier*) ou sur la juridicisation *normativo-politique* ; d’autres encore sur des régimes de savoir (*épistémiques*) et de style sensible (*esthético-symboliques*), où la codification affective, le jeu, le don ou le silence structurent la *co-viabilité*. Tous ont en commun d’articuler, selon des tensions spécifiques, une forme (*arcalité*), une force (*cratialité*), et une scène (*archicration*). Et c’est cette trialectique dynamique — jamais hiérarchique, jamais univoque — qui constitue le cœur du modèle archicratique.
 
 L’ambition n’est pas ici d’expliquer l’histoire universelle des formes politiques, mais de fournir une grammaire généalogique permettant de penser la pluralité des régulations humaines sans les réduire à un modèle unique. Il ne s’agit pas de dire *ce qui a été*, mais de rendre intelligible *comment un ordre peut advenir, persister ou se dissoudre, en fonction de configurations archicratiques localisées*. En cela, la typologie n’est ni descriptive ni normative : elle est structurante — c’est-à-dire apte à saisir les régularités formelles qui sous-tendent des réalités empiriques hétérogènes.
 
@@ -2776,7 +2790,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 variable d’optimisation, 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.
 
@@ -2814,17 +2828,17 @@ Ce régime ne dispose d’aucune souveraineté visible, mais déploie une souver
 
 Enfin, ce régime pose des questions inédites aux cadres analytiques classiques. Il appelle à une révision profonde des outils de la pensée politique, juridique, sociologique, écologique. Non pas pour statuer sur sa valeur, mais pour en comprendre les logiques internes, en cartographier les dynamiques, en explorer les tensions constitutives. L’*archicratie numérique* — cybernético-calculatoire dans son expression dominante — ne peut être pensée ni comme une simple continuité, ni comme une rupture absolue. Elle doit être analysée comme une mutation régulatrice paradigmatique, située à l’intersection d’infrastructures matérielles, de processus computationnels et de conditions épistémiques spécifiques à l’ère contemporaine.
 
-Ce que cette section aura tenté de mettre au jour, c’est précisément cette dynamique composite : *un régime régulateur sans visage, mais pas sans effet ; sans souverain, mais pas sans souveraineté ; sans centre, mais non sans ordre*. Une *archicratie* d’un nouveau genre, qui ne se déclare jamais comme telle, mais qui *opère* — et qui, pour cette raison même, requiert un outillage conceptuel à la mesure de sa complexité silencieuse.
+Ce que cette section aura tenté de mettre au jour, c’est précisément cette dynamique composite : *un régime régulateur sans visage explicite, mais non sans effets ; sans souverain identifiable, mais non sans logique de souveraineté ; sans centre unifié, mais non sans ordre*. On peut y reconnaître une configuration archicratique spécifique, qui ne se déclare pas comme telle mais opère effectivement, et qui requiert pour cette raison un outillage conceptuel ajusté à sa complexité.
 
 ##  
 
 ## **Conclusion du chapitre 2 — Archéologie des régimes régulateurs et stabilisation du paradigme archicratique**
 
-Ce deuxième chapitre avait une tâche précise, à la fois modeste et redoutable : vérifier, sur la longue durée historique et à travers des configurations hétérogènes, si l’hypothèse archicratique formulée au chapitre 1 tient lorsqu’on la confronte aux formes effectives de viabilisation des sociétés humaines. Il ne s’agissait ni de substituer à l’histoire politique classique une “grande histoire” de l’*archicratie*, ni de dresser un inventaire encyclopédique des pouvoirs passés, mais de répondre à une question plus simple et plus exigeante : si l’on regarde les sociétés humaines non plus à partir de la souveraineté, de la loi ou du marché, mais à partir de leurs régimes de régulation, la triade *arcalité* / *cratialité* / *archicration* permet-elle réellement de décrire, de discriminer et de comparer leurs manières de “*faire tenir ensemble*” des existences ? C’est ce double geste – archéologique et comparatif – qu’il nous fallait conduire, en refusant d’emblée les trois dérives qui guettent toute ambition de ce genre : l’évolutionnisme naïf (*du rite à l’algorithme*), l’étato-centrisme (l’illusion que l’État serait la forme ultime de régulation) et l’économicisme réducteur (l’idée que les marchés suffiraient à tout ordonner).
+Ce deuxième chapitre avait une tâche précise et exigeante : vérifier, sur la longue durée historique et à travers des configurations hétérogènes, si l’hypothèse archicratique formulée au chapitre 1 tient lorsqu’on la confronte aux formes effectives de viabilisation des sociétés humaines. Il ne s’agissait ni de substituer à l’histoire politique classique une “grande histoire” de l’*archicratie*, ni de dresser un inventaire encyclopédique des pouvoirs passés, mais de répondre à une question plus simple et plus exigeante : si l’on regarde les sociétés humaines non plus à partir de la souveraineté, de la loi ou du marché, mais à partir de leurs régimes de régulation, la triade *arcalité* / *cratialité* / *archicration* permet-elle réellement de décrire, de discriminer et de comparer leurs manières de “*faire tenir ensemble*” des existences ? C’est ce double geste – archéologique et comparatif – qu’il nous fallait conduire, en refusant d’emblée les trois dérives qui guettent toute ambition de ce genre : l’évolutionnisme naïf (*du rite à l’algorithme*), l’étato-centrisme (l’illusion que l’État serait la forme ultime de régulation) et l’économicisme réducteur (l’idée que les marchés suffiraient à tout ordonner).
 
-Le chapitre 2 a ainsi constitué le laboratoire historique du paradigme archicratique. Avec la section 2.1, nous avons fixé le cadre méthodologique : archéologie plutôt qu’histoire continue, comparaison plutôt que récit, attention aux dispositifs concrets plutôt qu’aux seules institutions formelles. Avec 2.2, nous avons proposé une archétypologie des méta-régimes régulateurs, qui ne sont pas des “stades” de développement, mais des profils de composition archicratique possibles. Enfin, avec 2.3, nous avons montré comment ces profils se recombinent dans des régimes historiques situés – cités grecques, empires, configurations religieuses médiévales, monarchies renaissantes, régimes disciplinaires, totalitaires, démocratico-providentiels, cybernétiques –, composant une histoire stratifiée des *co-viabilités*, et non une marche ascendante vers un quelconque accomplissement. C’est l’ensemble de ce parcours que cette conclusion doit maintenant resserrer : non pour en faire un résumé linéaire, mais pour dégager ce que cette archéogenèse nous permet désormais d’affirmer, et ce qu’elle nous interdit de prétendre.
+Le chapitre 2 a ainsi fonctionné comme laboratoire historique du paradigme archicratique. Avec la section 2.1, nous avons fixé le cadre méthodologique : archéologie plutôt qu’histoire continue, comparaison plutôt que récit, attention aux dispositifs concrets plutôt qu’aux seules institutions formelles. Avec 2.2, nous avons proposé une archétypologie des méta-régimes régulateurs, qui ne sont pas des “stades” de développement, mais des profils de composition archicratique possibles. Enfin, avec 2.3, nous avons montré comment ces profils se recombinent dans des régimes historiques situés – cités grecques, empires, configurations religieuses médiévales, monarchies renaissantes, régimes disciplinaires, totalitaires, démocratico-providentiels, cybernétiques –, composant une histoire stratifiée des *co-viabilités*, et non une marche ascendante vers un quelconque accomplissement. C’est l’ensemble de ce parcours que cette conclusion doit maintenant resserrer : non pour en faire un résumé linéaire, mais pour dégager ce que cette archéogenèse nous permet désormais d’affirmer, et ce qu’elle nous interdit de prétendre.
 
-Du côté de la typologie 2.2, le chapitre 2 a d’abord fait apparaître que les régimes de *co-viabilité* ne se laissent pas ranger dans quelques grandes catégories politiques (cité, empire, État, démocratie), mais qu’ils engagent des modes d’articulation très différenciés entre formes, forces et scènes d’épreuve. Les treize méta-régimes proposés – de l’archicratie proto-symbolique à l’archicratie différentiel-hybride, en passant par les formalisations sacrales non-étatiques, techno-logistiques, scripturo-normatives, scripturo-cosmologiques, théologiques, historiographiques, normativo-politiques, épistémiques, esthético-symboliques, marchandes ou guerrières – ne décrivent pas des “étapes”. Ils configurent un espace de possibilités morphologiques, où chaque combinaison attribue un rôle distinct à l’*arcalité* (ce qui donne forme, durée, hiérarchie et limite), à la *cratialité* (ce qui transforme, contraint, propulse, perturbe) et à l’*archicration* (ce qui organise la scène de leur confrontation réglée).
+Du côté de la typologie 2.2, le chapitre 2 a d’abord fait apparaître que les régimes de *co-viabilité* ne se laissent pas ranger dans quelques grandes catégories politiques (cité, empire, État, démocratie), mais qu’ils engagent des modes d’articulation très différenciés entre formes, forces et scènes d’épreuve. Les douze méta-régimes spécifiques proposés — du proto-symbolique au guerrier prolongés par un treizième plan différentiel-hybride — ne décrivent pas des “étapes”. Ils configurent un espace de possibilités morphologiques, où chaque combinaison attribue un rôle distinct à l’arcalité (ce qui donne forme, durée, hiérarchie et limite), à la cratialité (ce qui transforme, contraint, propulse, perturbe) et à l’archicration (ce qui organise la scène de leur confrontation réglée).
 
 Certaines configurations privilégient des *arcalités* incorporées, sensibles, rituelles : c’est le cas des méta-régimes proto-symboliques où la mémoire vive, les gestes, les rythmes et les tabous structurent la *co-viabilité* sans passer par des textualités formalisées ; c’est aussi le cas de formes sacrales non étatiques, où l’ordre cosmique se traduit en interdits, en séquences rituelles, en topologies sacrées du territoire. D’autres reposent sur des arcalités scripturales ou discursives : scripturo-normatives, lorsque la loi écrite, le code, la constitution, la réglementation bureaucratique deviennent les principaux supports de la forme ; scripturo-cosmologiques lorsqu’un récit d’origine, une cosmogonie, une historiographie sacrale produisent une arcalité narrative ; théologiques lorsqu’une révélation, des dogmes, un droit canonique encadrent l’ensemble de la *cratialité* sociale ; épistémiques lorsque ce sont des disciplines de savoir, des protocoles de preuve, des dispositifs d’expertise qui organisent la scène. À la charnière de ces registres, les régimes techno-logistiques font jouer comme *arcalité* les architectures matérielles et les réseaux d’acheminement – routes, ports, canaux, cadastres, grilles de circulation – qui spatialement ordonnent la *co-viabilité*, souvent en articulation étroite avec des dispositifs scripturaux. D’autres méta-régimes encore se définissent par une *cratialité* infra-matérielle, transactionnelle, où l’échange marchand, la menace guerrière, l’alliance, la dette, la logique des flux logistiques – au cœur des régimes techno-logistiques impériaux ou administratifs – deviennent les vecteurs centraux de la régulation, sans pour autant effacer toute *arcalité* ni toute scène.
 

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

@@ -16,39 +16,41 @@ Parmi les mythes historiographiques tenaces, inscrits au plus profond des repré
 
 Or, ce récit est une illusion. Pire : il est un *écran de fumée* qui masque les véritables logiques à l’œuvre dans les grandes métamorphoses de la modernité. Ce que l’on nomme “révolution industrielle” n’est pas un événement technologique en soi. C’est une *mutation profonde des régimes de régulation du monde*, un *reformatage des structures de viabilité collective*, une *refondation du tissu archicratique* dans lequel s’inscrivent et se négocient les conditions mêmes de l’existence humaine.
 
-Il nous faut donc, à ce point de notre démonstration, opérer une inflexion radicale du regard, un renversement de perspective, un dépassement conscient de la mythologie technicienne. Notre projet ne consiste pas à produire une énième périodisation de l’histoire industrielle selon les phases de l’innovation. Il s’agit de reformuler l’ensemble du problème, de déplacer la focale : non plus partir de l’innovation technique pour analyser ses conséquences sociales, mais interroger l’industrialisation comme moment de reconfiguration de la régulation archicratique. *Ce que chaque “révolution industrielle” transforme, ce n’est pas seulement la manière de produire, mais la manière de vivre, de percevoir, de gouverner, d’obéir, de résister, d’espérer*.
+Il nous faut donc, à ce point de notre démonstration, déplacer radicalement le regard et dépasser la mythologie technicienne. Notre projet ne consiste pas à produire une énième périodisation de l’histoire industrielle selon les phases de l’innovation. Il s’agit de reformuler l’ensemble du problème, de déplacer la focale : non plus partir de l’innovation technique pour analyser ses conséquences sociales, mais interroger l’industrialisation comme moment de reconfiguration de la régulation archicratique. *Ce que chaque “révolution industrielle” transforme, ce n’est pas seulement la manière de produire, mais la manière de vivre, de percevoir, de gouverner, d’obéir, de résister, d’espérer*.
 
 C’est ici que prend pleinement sens la grille analytique tripolaire que nous avons élaborée dans les chapitres précédents : chaque configuration historique peut être comprise comme l’articulation dynamique — et toujours tensionnelle — de trois dimensions constitutives du *fait social total* que nous nommons Archicratie :
 
-*l’arcalité*, soit les *formes d’institution symbolique et matérielle du monde vécu* (temps, espace, milieux, rythmes, représentations, inscription des existences) ;
+- *l’arcalité*, soit les *formes d’institution symbolique et matérielle du monde vécu* (temps, espace, milieux, rythmes, représentations, inscription des existences) ;
 
-*la cratialité*, soit les *modes d’imposition, de canalisation et de déploiement de la puissance* (extraction, commandement, discipline, optimisation, anticipation) ;
+- *la cratialité*, soit les *modes d’imposition, de canalisation et de déploiement de la puissance* (extraction, commandement, discipline, optimisation, anticipation) ;
 
-*l’archicration*, enfin, comme *scène de régulation*, *soit les dispositifs, les normes, les architectures cognitives et symboliques par lesquels une société rend viable — ou invivable — l’agencement tensionnel de ses structures arcalo-cratiales*.
+- *l’archicration*, enfin, comme *scène de régulation*, *soit les dispositifs, les normes, les architectures cognitives et symboliques par lesquels une société rend viable — ou invivable — l’agencement tensionnel de ses structures arcalo-cratiales*.
 
 C’est à partir de ce cadre, et de lui seul, que nous pouvons entreprendre une véritable histoire archicratique des révolutions industrielles. Chacune d’entre elles devient alors un moment différent de recomposition du triptyque, une phase de reformulation de l’équilibre régulateur, un nœud civilisationnel où se rejouent, sous des formes renouvelées, les grandes tensions constitutives du vivre-ensemble.
 
 Nous montrerons ainsi, dans les sections suivantes, comment :
 
-la première révolution industrielle (1780–1850) ne fut pas seulement l’âge du charbon et de la vapeur, mais l’instauration d’une *arcalité disciplinaire*, d’une *cratialité de l’effort musculaire domestiqué*, et d’une *archicration fondatrice centrée sur le contrat, la mesure du temps et la loi salariale* ;
+- la première révolution industrielle (1780–1850) ne fut pas seulement l’âge du charbon et de la vapeur, mais l’instauration d’une *arcalité disciplinaire*, d’une *cratialité de l’effort musculaire domestiqué*, et d’une *archicration fondatrice centrée sur le contrat, la mesure du temps et la loi salariale* ;
 
-la seconde révolution industrielle (1870–1945) opéra une rationalisation infrastructurelle, mettant en place une *archicration institutionnelle*, *qui connut aussi bien des versions sociales* (pacte fordiste, sécurité sociale) *que des dérives exterminatrices* (machinerie totalitaire, Holocauste) ;
+- la seconde révolution industrielle (1870–1945) opéra une rationalisation infrastructurelle, mettant en place une *archicration institutionnelle*, *qui connut aussi bien des versions sociales* (pacte fordiste, sécurité sociale) *que des dérives exterminatrices* (machinerie totalitaire, Holocauste) ;
 
-la troisième révolution industrielle (1950–1990) inaugura l’ère des systèmes, des flux, des protocoles interconnectés, avec une *archicration dispersée, cybernétique, post-étatique*, où l’État devient un nœud parmi d’autres dans un tissu algorithmique naissant ;
+- la troisième révolution industrielle (1973–2015) inaugura l’ère des systèmes, des flux, des protocoles interconnectés, avec une archicration dispersée, cybernétique, post-étatique, où l’État devient un nœud parmi d’autres dans un tissu algorithmique naissant ;
 
-la quatrième révolution industrielle (1990–2025) consacre la montée en puissance d’une *bio-algocratie*, où l’*arcalité devient invisible*, où la *cratialité anticipe et capte l’attention*, et où l’*archicration est effacée, dissimulée, désubjectivée* — nous basculons dans une régulation sans scène, sans sujet, sans épreuve explicite.
+- la quatrième révolution industrielle (2010–2025) consacre la montée en puissance d’une bio-algocratie, où l’arcalité devient invisible, où la cratialité anticipe et capte l’attention, et où l’archicration est effacée, dissimulée, désubjectivée — nous basculons dans une régulation sans scène, sans sujet, sans épreuve explicite.
+
+Les sections 4.2 à 4.5 suivent ainsi des séquences d’émergence historico-régulatrices ; la matrice synthétique proposée en 4.6, quant à elle, condense des régimes longs de domination relative, partiellement chevauchants, afin de rendre lisibles leurs continuités structurelles sans les rabattre sur une chronologie linéaire.
 
 Mais plus encore : ce chapitre vise à cartographier les logiques différentes de ces régimes successifs, à identifier les points de bascule, les continuités silencieuses, les effets de retour, les seuils critiques, et à interroger l’hypothèse d’une *cinquième révolution* à venir, non pas technologique, mais proprement régulatoire : l’*instauration consciente de la scène archicratique elle-même*.
 
-Ce serait là la révolution réflexive par excellence : non plus un ajout d’innovation technique, mais une mutation épistémologique du rapport à la régulation ; non plus un progrès par l’effacement du politique, mais une *réinstauration de la scène du conflit, du commun, du normatif explicite, une archicration qui s’assume comme telle*. Loin d’un programme utopique, cette hypothèse s’ancre dans la nécessité même de penser une *viabilité collective* qui ne soit plus dictée par des architectures opaques ou des algorithmes prédictifs, mais *rendue visible, disputée, pluralisée, et reconfigurable*.
+Ce serait là une révolution réflexive : non plus un ajout d’innovation technique, mais une mutation du rapport à la régulation ; non plus un progrès par l’effacement du politique, mais une réinstauration de la scène du conflit, du commun et du normatif explicite — une archicration qui s’assume comme telle. Loin d’un programme utopique, cette hypothèse s’ancre dans la nécessité même de penser une *viabilité collective* qui ne soit plus dictée par des architectures opaques ou des algorithmes prédictifs, mais *rendue visible, disputée, pluralisée, et reconfigurable*.
 
-Ainsi, ce chapitre 4 ne propose pas une histoire de l’industrie, mais une *généalogie des régimes de régulation tensionnelle que la modernité industrielle a successivement cristallisés, imposés, et parfois oblitérés*. Il est la scène d’une déconstruction méthodique et d’une recomposition critique. Il est, pour notre thèse-essai sur l’Archicratie, le pivot historique, le point d’inflexion, le révélateur d’une *épistémologie de la régulation incarnée*.
+Ainsi, ce chapitre 4 ne propose pas une histoire de l’industrie, mais une *généalogie des régimes de régulation tensionnelle que la modernité industrielle a successivement cristallisés, imposés, et parfois oblitérés*. Il est la scène d’une déconstruction méthodique et d’une recomposition critique. Il constitue, pour notre essai-thèse sur l’*archicratie*, un pivot historique et un révélateur d’une épistémologie incarnée de la régulation.
 
-Et c’est pourquoi, à rebours de toute lecture téléologique, nous affirmons ceci : les révolutions industrielles n’ont jamais été d’abord techniques. Elles ont toujours été régulatoires. Et l’*Archicratie*, comme concept opératoire, comme modèle heuristique, comme hypothèse civilisationnelle, est la clef d’intelligibilité de cette histoire.
+Et c’est pourquoi, à rebours de toute lecture téléologique, nous affirmons ceci : les révolutions industrielles n’ont jamais été d’abord techniques. Elles ont toujours été régulatoires. Et l’*archicratie*, comme concept opératoire, comme modèle heuristique, comme hypothèse civilisationnelle, est la clef d’intelligibilité de cette histoire.
 
 ## **4.1 — Prélude méthodologique : penser l’industrialisation comme régime archicratique**
 
-Penser l’industrialisation autrement, non comme simple intensification des techniques, mais comme *configuration régulatoire globale*, exige de défaire plusieurs couches d’enfouissement historiographique. Car le terme même de « révolution industrielle », aujourd’hui si couramment mobilisé qu’il paraît aller de soi, est le produit d’une construction idéologique spécifique, forgée dans une temporalité elle-même saturée d’intérêts politiques, économiques, et épistémiques. Loin de désigner un processus objectif, il constitue un *acte de nomination normatif*, qui attribue à certains événements ou innovations une valeur de rupture, en leur conférant une centralité quasi messianique dans le récit du progrès moderne.
+Penser l’industrialisation autrement, non comme simple intensification des techniques, mais comme *configuration régulatoire globale*, exige de défaire plusieurs couches d’enfouissement historiographique. Car le terme même de « révolution industrielle », aujourd’hui si couramment mobilisé qu’il paraît aller de soi, est le produit d’une construction idéologique spécifique, forgée dans une temporalité elle-même saturée d’intérêts politiques, économiques, et épistémiques. Loin de désigner un processus objectif, il constitue un acte de nomination normatif attribuant à certains événements ou innovations une valeur de rupture, et leur conférant une centralité quasi messianique dans le récit du progrès moderne.
 
 La catégorie de *révolution industrielle* est ainsi, dès son origine, profondément téléologique et européocentrée. Elle suppose un mouvement cumulatif d’accroissement des capacités productives, rendu possible par l’inventivité humaine, la rationalité instrumentale et l’organisation économique. Depuis Arnold Toynbee — qui popularisa l’expression dans ses *Lectures on the Industrial Revolution in England* publiées à titre posthume en 1884 — jusqu’à David Landes, Eric Hobsbawm ou Robert C. Allen, la littérature dominante a tendu à faire des révolutions industrielles des objets d’analyse essentiellement économicistes, téléologiques et fonctionnalistes, en les arrimant à des ruptures techniques sans interroger suffisamment les régimes de régulation, de conflictualité et de symbolisation qu’elles recomposaient. Il conviendra aux lecteurs ayant suivi l’évolution de notre pensée que nous ne pouvons nous satisfaire d’une telle réduction. En effet, ce qui importe davantage à nos yeux pourrait se résumer en cette question méta-réflexive : Qu’est-ce qui a été réellement révolutionné dans ces révolutions ?
 
@@ -58,7 +60,7 @@ Il est alors nécessaire de poser une distinction fondatrice entre technique com
 
 Mais avant de modéliser les quatre grandes phases que la doxa désigne comme “révolutions industrielles”, encore faut-il souligner un point central trop souvent occulté : la *pluralité des temporalités techno-régulatrices*. Aucune des mutations industrielles ne se produit dans un temps homogène, universel, linéaire. Le récit linéaire, quasi-légendaire, selon lequel l’Angleterre invente, l’Europe généralise, le monde suit, est une image d’épinal. La diffusion d’un dispositif industriel ne suit jamais un seul axe de propagation, mais s’inscrit dans des hétérochronies, des zones de friction, des sédimentations différenciées selon les régimes symboliques, politiques et économiques locaux.
 
-Ainsi, au sein même d’une période donnée — disons, la deuxième révolution industrielle — coexistent des régimes arcalo-cratialo-archicratiques très différents selon les lieux : ce que l’on observe dans la Ruhr ne correspond pas à ce qui se joue au Japon, à Buenos Aires ou en URSS. Penser l’industrialisation comme régime archicratique, c’est donc la désoccidentaliser, la désynchroniser, la désobjectiver. Il ne s’agit plus de décrire une série de faits techniques mais de cartographier une pluralité de régimes de régulation qui se recomposent, s’affrontent, s’imitent ou se parasitent. La notion même de “révolution” devient alors suspecte : trop brutale, trop unifiante, trop idéologique. Nous lui préférons celle de *recomposition régulatoire tensionnelle*.
+Ainsi, au sein même d’une période donnée — disons, la deuxième révolution industrielle — coexistent des régimes arcalo-cratialo-archicratiques très différents selon les lieux : ce que l’on observe dans la Ruhr ne correspond pas à ce qui se joue au Japon, à Buenos Aires ou en URSS. Penser l’industrialisation comme régime archicratique, c’est donc la désoccidentaliser, la désynchroniser et la dénaturaliser comme évidence historique. Il ne s’agit plus de décrire une série de faits techniques mais de cartographier une pluralité de régimes de régulation qui se recomposent, s’affrontent, s’imitent ou se parasitent. La notion même de “révolution” devient alors suspecte : trop brutale, trop unifiante, trop idéologique. Nous lui préférons celle de *recomposition régulatoire tensionnelle*.
 
 Cette approche, que nous appelons archicratique, ne se contente pas de surplomber la réalité par une grille conceptuelle abstraite. Elle s’ancre dans une tradition intellectuelle exigeante, dont nous assumons l’héritage critique. Déjà *Lewis Mumford*, dans *Technique and Civilization* (1934), montrait que l’âge de la machine ne commence pas avec le moteur à vapeur mais avec l’invention de la régulation horaire, de la synchronisation du travail et de la domestication du rythme corporel. *Simondon*, dans *Du mode d’existence des objets techniques* (1958), invitait à penser la technique comme milieu associé, c’est-à-dire comme médiation collective structurante. *André Gorz*, dans *Métamorphoses du travail* (1988), rappelait que le passage à la société industrielle repose avant tout sur la normalisation de la subjectivité productive. Plus récemment, *Bruno Latour*, à travers sa théorie des agencements sociotechniques, a permis de penser la technologie non comme outil, mais comme acteur régulateur dans des réseaux hybrides de pouvoir.
 
@@ -70,7 +72,7 @@ On a trop souvent raconté la première révolution industrielle comme une épop
 
 Ce que nous appelons ici « première révolution industrielle » doit être repensé, non comme une *révolution technicienne*, mais comme l’*émergence d’une nouvelle archicration,* c’est-à-dire une configuration encore instable, mais décisive, d’une régulation sociotechnique centrée sur notre triptyque tensionnel. Il ne s’agit pas simplement d’un saut quantitatif dans la production, mais d’un basculement qualitatif dans les modalités de viabilité collective, où le temps, le corps, le contrat, le geste, la fatigue, la norme et l’espace se trouvent redéployés dans une grammaire régulatoire entièrement nouvelle.
 
-Ce n’est pas la machine qui fait la révolution. C’est l’institutionnalisation de ses conditions d’usage, de ses temporalités, de ses subjectivations, de ses régimes d’obéissance. Autrement dit, ce qui fonde la modernité industrielle dans sa première phase, ce n’est pas le charbon, le fer ou l’acier, mais la mise en scène régulatoire d’un monde productif discipliné — où le pouvoir ne réside pas tant dans l’État que dans la capacité d’extraire, de mesurer, de synchroniser et de normaliser le corps laborieux. C’est la naissance du *régime usinier* comme scène d’imposition du temps, d’administration des gestes et de contractualisation de l’effort.
+Ce n’est pas la machine qui fait la révolution, mais l’institutionnalisation de ses conditions d’usage, de ses temporalités, de ses subjectivations et de ses régimes d’obéissance. Autrement dit, ce qui fonde la modernité industrielle dans sa première phase, ce n’est pas le charbon, le fer ou l’acier, mais la mise en scène régulatoire d’un monde productif discipliné — où le pouvoir ne réside pas tant dans l’État que dans la capacité d’extraire, de mesurer, de synchroniser et de normaliser le corps laborieux. C’est la naissance du *régime usinier* comme scène d’imposition du temps, d’administration des gestes et de contractualisation de l’effort.
 
 Il faut donc ici reformuler radicalement les catégories. Nous ne parlerons pas d’innovations technologiques, mais de transferts de légitimité régulatoire vers des dispositifs machinés ; nous ne dénombrerons pas les brevets, mais cartographierons les formes de stabilisation normative qui rendent possible une production répétée, interchangeable, anonymisée. C’est ainsi que *la figure du salarié apparaît*, que *le temps devient mesure*, que *l’effort devient ressource*, que *la discipline devient infrastructure*.
 
@@ -78,11 +80,11 @@ Cette phase — que nous délimitons entre 1780 et 1850, non par arbitraire chro
 
 La suite de cette section analysera, en trois temps distincts mais intégrés, cette proto-archicration mécanisée à travers notre triptyque constitutif :
 
-une *arcalité disciplinaire*, faite de temps uniformisé, d’espaces clos et de rythmes segmentés ;
+- une *arcalité disciplinaire*, faite de temps uniformisé, d’espaces clos et de rythmes segmentés ;
 
-une *cratialité extractive*, centrée sur l’effort canalisé, l’obéissance incorporée et la force productivisée ;
+- une *cratialité extractive*, centrée sur l’effort canalisé, l’obéissance incorporée et la force productivisée ;
 
-une *archicration fondatrice*, où émergent le contrat, le salaire, la norme, et où l’ordre industriel commence à se donner comme totalité régulatrice.
+- une *archicration fondatrice*, où émergent le contrat, le salaire, la norme, et où l’ordre industriel commence à se donner comme totalité régulatrice.
 
 Nous prolongerons cette lecture par un cas paradigmatique, celui de Manchester, non pas comme “berceau” de l’industrie, mais comme dispositif historique de régulation mécanisée, avant de conclure sur les tensions, instabilités et apories qui marquent cette phase de fondation, encore partielle et conflictuelle, de l’*archicratie industrielle*.
 
@@ -94,7 +96,7 @@ Ces auteurs, bien que parfois critiques à l’égard du capitalisme, participen
 
 C’est cette lacune, épistémologique et politique, que nous entendons combler. Car nous faisons l’hypothèse que la révolution industrielle, dans sa première phase, est d’abord l’instauration d’un régime disciplinaire de la productivité. Non au sens d’un ordre brutalement imposé, mais comme émergence d’un mode de régulation spécifique, où la production répétée, segmentée, quantifiée, mesurée du travail humain devient la clé de voûte de la viabilité collective. Ce n’est pas l’abondance des techniques qui produit l’industrie, c’est la mise en place d’un dispositif de synchronisation, de canalisation et de normativité qui permet à ces techniques d’être stabilisées, répétées, généralisées, opérantes. Autrement dit, l’infrastructure industrielle est d’abord une infrastructure régulatoire, et non uniquement matérielle.
 
-Nous appellons proto-archicration cette configuration émergente. Le préfixe *proto-* indique que nous avons affaire à une forme naissante, partielle, encore instable de régulation archicratique. Celle-ci ne dispose pas encore d’un État organisé autour d’un projet industriel centralisé. Elle ne s’incarne pas dans un appareil bureaucratique normatif, ni dans une ingénierie sociale pleinement développée. Elle réside dans un ensemble de dispositifs discontinus mais convergents : l’atelier transformé en fabrique, la fabrique transformée en usine ; la mesure du temps devenue discipline ; le contrat salarial émergent ; les premières tentatives de juridicisation du travail ; les premiers contremaîtres, les premières normes, les premières résistances. La proto-archicration désigne donc cette phase où l’industrialisation devient régulation du monde sans encore pouvoir se nommer comme telle.
+Nous appelons proto-archicration cette configuration émergente. Le préfixe *proto-* indique que nous avons affaire à une forme naissante, partielle, encore instable de régulation archicratique. Celle-ci ne dispose pas encore d’un État organisé autour d’un projet industriel centralisé. Elle ne s’incarne pas dans un appareil bureaucratique normatif, ni dans une ingénierie sociale pleinement développée. Elle réside dans un ensemble de dispositifs discontinus mais convergents : l’atelier transformé en fabrique, la fabrique transformée en usine ; la mesure du temps devenue discipline ; le contrat salarial émergent ; les premières tentatives de juridicisation du travail ; les premiers contremaîtres, les premières normes, les premières résistances. La proto-archicration désigne donc cette phase où l’industrialisation devient régulation du monde sans encore pouvoir se nommer comme telle.
 
 Le choix d’inscrire cette proto-archicration dans une période allant de 1780 à 1850 ne relève pas d’un arbitraire. Il est fondé sur des repères précis, à la fois historiographiques et régulatoires. 1780 marque le début de l’accélération des innovations techniques, avec l’amélioration de la machine à vapeur par James Watt, la généralisation de la mule-jenny, la montée en puissance des manufactures textiles, notamment autour de Manchester. Mais c’est surtout à partir de cette date que les formes d’organisation du travail commencent à se codifier durablement, que la synchronisation horaire devient impératif collectif, que le rapport salarial se sédimente comme condition de survie. De l’autre côté de la séquence, la décennie 1840–1850 marque plusieurs seuils régulateurs décisifs : les Factory Acts de 1833 et 1847 en Angleterre, la montée des luttes ouvrières, la généralisation du discours hygiéniste et productiviste, mais aussi, à l’échelle européenne, les insurrections de 1848, qui signent la fin d’une époque d’institution informelle de la régulation, et le début d’une institutionnalisation partielle du social par l’État.
 
@@ -186,7 +188,7 @@ La cratialité extractive qui s’impose dans les premières fabriques industrie
 
 À la différence des formes de pouvoir monarchique, bureaucratique ou théologico-politique, la cratialité industrielle naissante ne repose ni sur un principe de légitimité transcendante, ni sur une codification juridique universelle. Elle procède d’une logique d’efficience : celui qui garantit la production décide ; celui qui fait travailler, commande ; celui qui organise le rendement, gouverne sans en avoir le titre. Cette délégation du commandement à l’entrepreneur, que Max Weber analysera plus tard dans *Wirtschaft und Gesellschaft* (1922) comme une forme de rationalisation fonctionnelle, préfigure déjà la dissociation entre autorité légitime et autorité opérationnelle. Le pouvoir devient *réseau, outil, mécanisme* : il ne dit plus, il fait faire.
 
-Cette dynamique est particulièrement visible dans les dispositifs patronaux de type paternaliste — comme ceux d’Robert Owen à New Lanark, de Titus Salt à Saltaire, ou des familles Peel et Strutt dans le Derbyshire. Le patron y assume un rôle de régulateur global : il loge, surveille, réprimande, éduque, moralise. Mais ce rôle ne relève pas d’un mandat public. Il est *propriétaire du sol, de l’usine, des machines, des maisons, et par extension, des corps*. Cette privatisation du pouvoir est sans précédent dans l’histoire européenne moderne : elle transfère à l’entrepreneur la capacité de déterminer le quotidien, le temps, la norme, la règle, le seuil de tolérance. Ce pouvoir n’est pas juridiquement institué, mais économiquement advenu : il procède de la conjonction entre propriété privée des moyens de production et dépendance vitale des individus au revenu de subsistance. Il en résulte une capacité normative sans inscription étatique, que nous pouvons qualifier de souveraineté d’usage, sans reconnaissance symbolique.
+Cette dynamique est particulièrement visible dans les dispositifs patronaux de type paternaliste — comme ceux de Robert Owen à New Lanark, de Titus Salt à Saltaire, ou des familles Peel et Strutt dans le Derbyshire. Le patron y assume un rôle de régulateur global : il loge, surveille, réprimande, éduque, moralise. Mais ce rôle ne relève pas d’un mandat public. Il est *propriétaire du sol, de l’usine, des machines, des maisons, et par extension, des corps*. Cette privatisation du pouvoir est sans précédent dans l’histoire européenne moderne : elle transfère à l’entrepreneur la capacité de déterminer le quotidien, le temps, la norme, la règle, le seuil de tolérance. Ce pouvoir n’est pas juridiquement institué, mais économiquement advenu : il procède de la conjonction entre propriété privée des moyens de production et dépendance vitale des individus au revenu de subsistance. Il en résulte une capacité normative sans inscription étatique, que nous pouvons qualifier de souveraineté d’usage, sans reconnaissance symbolique.
 
 Comme le souligne l’historienne Emma Griffin dans *Liberty’s Dawn: A People's History of the Industrial Revolution* (2013), ce pouvoir privé s’est étendu par la simple logique du marché, sans qu’aucune révolution juridique ou politique ne vienne l’encadrer véritablement. Ce n’est qu’au milieu du XIXe siècle, avec la montée des luttes ouvrières et l’extension partielle du droit du travail (notamment avec le *Factory Act* de 1847), que l’État commence timidement à réintégrer la régulation cratiale. Mais jusque-là, la gouvernance des efforts, des gestes, des rythmes est entièrement confiée au capital privé.
 
@@ -300,7 +302,7 @@ Enfin, la synchronisation temporelle impose à l’individu une unification ryth
 
 En croisant ces trois dispositifs, nous pouvons désormais définir l’archicration fondatrice comme *le régime régulatoire qui stabilise la domination industrielle par une codification contractuelle, une valuation salariale et une homogénéisation temporelle*. Elle fonde un ordre sans spectaculaire, un pouvoir sans effusion, une autorité sans emblème. Elle institue un monde où le travail vivant est *encadré, mesuré, valorisé*, non à travers des symboles ou des lois visibles, mais par l’agencement minutieux de dispositifs techniques et sociaux opérant à bas bruit. C’est ce que nous désignons comme *fondation régulatoire par intégration fonctionnelle*.
 
-Elle représente ainsi la phase culminante de l’institution archicratique de l’ère industrielle : le moment où la force n’est plus seulement extraite (cratialité), où l’espace-temps n’est plus seulement structuré (arcalité), mais où l’ensemble du système de production sociale est légitimé, naturalisé et généralisé par la coalescence de dispositifs régulateurs devenus *formes de vie*. Il ne s’agit plus de produire sous contrainte, mais de vivre dans la norme. Ce monde est clos non parce qu’il est coercitif, mais parce qu’il est *autoévident*. Il n’appelle pas à l’adhésion — il ne laisse pas d’alternative.
+Elle représente ainsi la phase culminante de l’institution archicratique de l’ère industrielle : le moment où la force n’est plus seulement extraite (cratialité), où l’espace-temps n’est plus seulement structuré (arcalité), mais où l’ensemble du système de production sociale est légitimé, naturalisé et généralisé par la coalescence de dispositifs régulateurs devenus *formes de vie*. Il ne s’agit plus de produire sous contrainte, mais de vivre dans la norme. Ce monde est clos non parce qu’il est coercitif, mais parce qu’il est *auto-référent, évident, sans extériorité pensable*. Il ne cherche pas l’adhésion ; il ne laisse aucune alternative.
 
 Cette stabilisation par la contractualisation, la mensualisation et la synchronisation constitue ce que nous devons reconnaître comme le socle normatif dur de l’archicration industrielle. Il ne s’agit plus ici de coordonner des flux, ni d’encadrer des gestes, mais de produire un sujet apte à l’intégration régulée. Le travailleur devient l’unité fondamentale de cette grammaire, non parce qu’il serait biologiquement déterminé à produire, mais parce qu’il est désormais *socialement défini* par sa capacité à signer, à pointer, à fournir un rendement quantifiable.
 
@@ -308,11 +310,11 @@ L’archicration fondatrice marque ainsi une rupture décisive dans l’histoire
 
 Et c’est sur cette assise, désormais installée, que pourra se construire la dynamique suivante : celle de l’expansion archicratique dans la société marchande et contractuelle étendue, à partir des années 1870. Mais ceci relève d’un autre régime, et d’un autre moment de notre essai.
 
-### 4.2.5 – *Exemple paradigmatique : Manchester, berceau de la régulation mécanisée*
+### 4.2.5 – Exemple paradigmatique : Manchester, laboratoire de la régulation mécanisée
 
-Manchester n’est pas une simple ville industrielle parmi d’autres ; elle constitue un opérateur paradigmatique dans l’histoire de la régulation archicratique. Ce n’est pas une exagération rhétorique que d’affirmer qu’entre 1780 et 1850, Manchester fonctionne comme un laboratoire de transformation du monde vécu, au sens fort que donne Foucault à l’*épistémè* : une structure implicite de savoir, d’organisation et de pouvoir, qui rend possible certaines formes de visibilité et d’action tout en en excluant d’autres (*Les mots et les choses*, 1966). Manchester matérialise ainsi, dans la texture même de ses usines, rues et horaires, l’émergence d’un régime régulatoire intégral, où s’articulent *arcalité disciplinaire*, *cratialité extractive* et *archicration fondatrice* — dans une convergence maximale des trois régimes définis au §4.1.
+Manchester n’est pas ici pensée comme une origine absolue de l’industrialisation, mais comme un laboratoire paradigmatique dans l’histoire de la régulation archicratique. Entre 1780 et 1850, elle fonctionne comme un opérateur de transformation du monde vécu, au sens fort où s’y cristallisent des formes nouvelles de visibilité, d’obéissance, de mesure et d’organisation. Elle matérialise ainsi, dans la texture même de ses usines, de ses rues et de ses horaires, l’émergence d’un régime régulatoire intensif, où s’articulent arcalité disciplinaire, cratialité extractive et archicration fondatrice.
 
-Ce qui se joue à Manchester n’est donc pas simplement une augmentation de la production, ni même une concentration de l’industrie textile : c’est l’instauration d’un nouveau monde régulé, où les dimensions du temps, de l’espace, du geste, de la valeur et de l’autorité sont restructurées dans une logique d’efficience machinique. Ce n’est pas un lieu ; c’est un opérateur d’ontologie sociale.
+Ce qui se joue à Manchester ne représente donc pas une augmentation de la production, ni même une concentration de l’industrie textile : c’est l’instauration d’un nouveau monde régulé, où les dimensions du temps, de l’espace, du geste, de la valeur et de l’autorité sont restructurées dans une logique d’efficience machinique. Ce n’est pas un lieu ; c’est un opérateur d’ontologie sociale.
 
 Engels, dans *La situation de la classe laborieuse en Angleterre* (1845), consacre à Manchester une analyse saisissante, non pas tant pour dénoncer les conditions d’existence (ce qu’il fait) que pour identifier l’émergence d’un monde nouveau, dans lequel les rapports sociaux sont soumis à une rationalité d’extraction. Il y observe une transformation de l’espace urbain : « Des quartiers entiers construits selon une géométrie rigide, destinée non à l’habitation mais à la circulation de la force de travail » (éd. française, Maspero, 1969, p. 112). La ville n’est pas un milieu de vie, mais une machine de transit et de commandement : la rue conduit à l’usine, l’usine au dortoir, le dortoir à la fatigue. Ce quadrillage urbain fonctionne comme une *grille disciplinaire*, au sens foucaldien : les corps y sont localisés, assignés, rendus opératoires.
 
@@ -406,7 +408,7 @@ Et c’est cette compréhension approfondie, rigoureuse, critique et articulée
 
 ### **4.3.1 – Arcalité infrastructurelle : réseaux techniques, standardisation d’État, gouvernance par les normes**
 
-Ce que la seconde révolution industrielle inaugure, dans le prolongement mais aussi dans la mutation des régimes régulatoires du XIXe siècle, c’est une transformation radicale du rôle joué par les *infrastructures techniques* dans l’organisation du monde social. L’arcalité, que nous avions définie dans les sections précédentes comme *forme de régulation du pensable, du visible et du faisable*, s’y matérialise dans des dispositifs massifs, standardisés, étendus, qui ne se contentent plus de modeler les pratiques — mais reconfigurent désormais *l’armature même du réel*.
+Ce que la seconde révolution industrielle inaugure, dans le prolongement et aussi dans la mutation des régimes régulatoires du XIXe siècle, c’est une transformation radicale du rôle joué par les *infrastructures techniques* dans l’organisation du monde social. L’arcalité, que nous avions définie dans les sections précédentes comme *forme de régulation du pensable, du visible et du faisable*, s’y matérialise dans des dispositifs massifs, standardisés, étendus, qui ne se contentent plus de modeler les pratiques — mais reconfigurent désormais *l’armature même du réel*.
 
 L’arcalité devient *infrastructurelle* : c’est-à-dire qu’elle s’incarne dans des formes spatiales, matérielles, technologiques, étatiques, qui organisent non plus seulement la discipline des corps (comme dans le régime manchestérien), mais la *condition d’accès au monde* — au sens le plus littéral : routes, rails, canaux, réseaux électriques, normes d’ingénierie, protocoles de mesure, standardisation des unités et des formats, grilles cadastrales, cartes topographiques, lignes de transmission, systèmes postaux, télégraphiques, téléphoniques. C’est une *archéification des milieux*, dans laquelle ce n’est plus le geste local qui est régulé, mais l’environnement structurant dans lequel tout geste peut avoir lieu. L’arcalité cesse d’être un encadrement disciplinaire pour devenir une infrastructure de la possibilité. Il est ici nécessaire de préciser que cette transformation ne relève pas seulement d’un changement de format technique ou de support matériel, mais d’un basculement épistémologique au sens fort. En reprenant la notion foucaldienne d’*épistémè* — entendue comme structure des conditions de possibilité du savoir — l’arcalité infrastructurelle apparaît comme un dispositif non pas seulement logistique, mais cognitif-normatif : elle structure ce qui peut être dit, vu, mesuré, donc pensé. Mais là où Foucault (dans *Les mots et les choses*) décrit des régimes de visibilité historiquement situés, il nous faut ici compléter avec la perspective de Canguilhem, pour qui la norme est toujours déjà à la fois biologique, sociale et technique, c’est-à-dire *vivante*. La normativité arcalitaire ne relève donc pas d’un simple cadre technique : elle est une *milieuformung* — une formation du monde — qui configure les possibilités du vivant à travers des formes normatives intégrées. Cette rationalisation par la norme rejoint enfin ce que Supiot identifie, dans *La gouvernance par les nombres*, comme une ontologie de la mesure : celle dans laquelle le réel ne vaut que s’il est quantifiable. Autrement dit, l’arcalité infrastructurelle ne régule pas le réel : elle définit ce qui peut être réel.
 
@@ -618,7 +620,7 @@ Dans ce contexte, le compromis social devient une technique de gouvernement. Il
 
 Enfin, cette archicration étatique du compromis social s’accompagne d’un *pacte implicite de croissance et de discipline*. Les syndicats, intégrés dans la gouvernance des dispositifs, acceptent de contenir les revendications en échange d’une redistribution partielle de la richesse. C’est l’essence du fordisme politique : la paix sociale contre la consommation garantie ; la docilité collective contre la stabilité prévisionnelle. Ce n’est pas la fin du conflit — c’est sa translation dans un théâtre régulé.
 
-L’archicration institutionnelle négociée, que nous avons décrite dans les blocs précédents comme une ingénierie stabilisatrice des antagonismes sociaux, ne constitue nullement une suppression des tensions : elle en organise la gestion différentielle, en redistribue les seuils d’acceptabilité, et surtout en **désactive les foyers de conflictualité non compatibles avec l’ordre calculé**. Ce n’est pas une pacification, c’est une *mise en forme* des tensions — dont l’effet structurel est de **normaliser la conflictualité acceptable** tout en reléguant dans l’indicible, l’invisible ou l’illégitime, toutes les formes de dissensus inassimilables.
+L’archicration institutionnelle négociée, que nous avons décrite dans les blocs précédents comme une ingénierie stabilisatrice des antagonismes sociaux, ne constitue nullement une suppression des tensions : elle en organise la gestion différentielle, en redistribue les seuils d’acceptabilité, et surtout en désactive les foyers de conflictualité non compatibles avec l’ordre calculé. Ce n’est pas une pacification, c’est une *mise en forme* des tensions — dont l’effet structurel est de normaliser la conflictualité acceptable tout en reléguant dans l’indicible, l’invisible ou l’illégitime, toutes les formes de dissensus inassimilables.
 
 Le paradoxe fondamental tient dans le fait que la reconnaissance étatique des revendications collectives — à travers la sécurité sociale, les conventions collectives, les négociations paritaires — fonctionne comme opérateur de neutralisation politique. Là où une lutte pouvait être vécue comme insurrectionnelle ou radicalement antagoniste (grèves sauvages, occupations, refus du travail), elle est reconfigurée en différend technique, soluble dans un dialogue d’experts, de représentants et d’instances. L’État ne pacifie pas : il dés-politise. Il transforme les rapports de forces en paramètres d’ajustement.
 
@@ -732,7 +734,7 @@ Nous structurerons cette section en quatre moments fondamentaux, correspondant
 
 *Archicration dispersée* : désétatisation, gestion par interfaces, rationalité modulaire — émergence d’un pouvoir sans centre.
 
-*Études de cas* : ARPANET, Toyotisme, marchés financiers — trois scènes paradigmatique du basculement cybernétique.
+*Études de cas* : ARPANET, Toyotisme, marchés financiers — trois scènes paradigmatiques du basculement cybernétique.
 
 À travers cette architecture, nous poursuivrons notre thèse centrale : l’archicration est un opérateur tensionnel, ni intrinsèquement libérateur ni nécessairement oppressif, mais configuré par les milieux régulateurs. Or ici, c’est le système lui-même — *autorégulé, automatique, invisible* — qui devient le milieu.
 
@@ -1278,23 +1280,23 @@ La suite de notre essai-thèse devra donc affronter une question centrale : *com
 
 La séquence ouverte par la quatrième révolution industrielle — bio-algocratique, machinique, post-normative — ne s’achève pas dans la clôture d’un monde intégralement régulé, entièrement automatisé, parfaitement lissé. Bien au contraire : plus la régulation devient silencieuse, plus elle suscite, en miroir, *des formes de résistance inédites, des gestes d’insoumission latente, des percées critiques imprévisibles*. Car toute oblitération appelle son contre-effet : toute forme de dissolution de la scène régulatoire visible appelle une *refiguration du dissensus*, une réinvention du conflit dans les interstices du système.
 
-Il nous faut ici prendre la pleine mesure d’une hypothèse forte : *le régime archicratique oblitéré n’annule pas la conflictualité — il la déplace*. Il ne supprime pas l’épreuve — il la rend illisible. Et ce déplacement génère *un nouveau régime de luttes*, fondé non plus sur l’opposition frontale à une autorité identifiable, mais sur *l’exhumation des infrastructures, la désobfuscation des codes, la réactivation des corps*. Dans cette configuration, les figures critiques ne sont plus des représentants institués, des porte-voix organiques ou des opposants identifiés : *elles sont des événements, des gestes, des hacks, des fissures*.
+Il nous faut ici prendre la pleine mesure d’une hypothèse forte : *le régime archicratique oblitéré n’annule pas la conflictualité — il la déplace*. Il ne supprime pas l’épreuve — il la rend illisible. Et ce déplacement génère *un nouveau régime de luttes*, fondé non plus sur l’opposition frontale à une autorité identifiable, mais sur *l’exhumation des infrastructures, la désobfuscation des codes, la réactivation des corps*. Dans cette configuration, les figures critiques ne sont plus principalement des représentants institués, des porte-voix organiques ou des opposants identifiables : elles prennent la forme de gestes, d’interventions, de brèches ou de contre-dispositifs ponctuels.
 
-Ainsi se dessine une constellation mouvante de *résistances émergentes*, que nous devons analyser non comme un catalogue de pratiques, mais comme des tentatives plus ou moins coordonnées de *repolitisation de l’archicration par sa re-visibilisation*. Cette refiguration prend plusieurs formes, que nous allons déployer ici comme autant de figures paradigmiques de la contre-archicration contemporaine. Car là où le pouvoir se retire derrière l’écran, la plateforme ou l’algorithme, *c’est dans le geste de dévoilement que réside l’acte politique*.
+Ainsi se dessine une constellation mouvante de *résistances émergentes*, que nous devons analyser non comme un catalogue de pratiques, mais comme des tentatives plus ou moins coordonnées de *repolitisation de l’archicration par sa restauration visible*. Cette re-figuration prend plusieurs formes, que nous allons déployer ici comme autant de figures paradigmatiques de la contre-archicration contemporaine. Car là où le pouvoir se retire derrière l’écran, la plateforme ou l’algorithme, *c’est dans le geste de dévoilement que réside l’acte politique*.
 
 Dans cette perspective, la présente section abordera successivement :
 
-La figure du lanceur d’alerte (*whistleblower*) comme brèche dans la souveraineté opaque : Edward Snowden, Chelsea Manning, Julian Assange, et les formes contemporaines de dévoilement comme reconstruction de l’espace public.
+La figure du *lanceur d’alerte* (*whistleblower*) comme brèche dans la souveraineté opaque : Edward Snowden, Chelsea Manning, Julian Assange, et les formes contemporaines de dévoilement comme reconstruction de l’espace public.
 
-La figure du pirate informatique (*hacker*) comme forçage du code archicratique : pratiques de désobéissance numérique, sabotage algorithmique, cryptographie militante, décentralisation autogérée.
+La figure du *pirate informatique* (*hacker*) comme forçage du code archicratique : pratiques de désobéissance numérique, sabotage algorithmique, cryptographie militante, décentralisation autogérée.
 
-La figure du commun insurgé comme refus de la captation privative : mouvements des ZAD, squats numériques, logiciels libres, plateformes alternatives, infrastructures post-capitalistes.
+La figure du *commun insurgé* comme refus de la captation privative : mouvements des ZAD, squats numériques, logiciels libres, plateformes alternatives, infrastructures post-capitalistes.
 
-La figure du soulèvement situé comme réinscription du conflit dans l’expérience vécue : luttes antiracistes, féministes, écoféministes, décoloniales et intersectionnelles, qui réinjectent de la chair, du lieu, du récit, de la voix là où le système archicratique tend à disqualifier l’expérience.
+La figure du *soulèvement situé* comme réinscription du conflit dans l’expérience vécue : luttes antiracistes, féministes, écoféministes, décoloniales et intersectionnelles, qui réinjectent de la chair, du lieu, du récit, de la voix là où le système archicratique tend à disqualifier l’expérience.
 
 Chacune de ces figures ne peut être comprise isolément. *Elles forment un réseau de contre-pouvoirs, souvent fragmenté, parfois contradictoire, mais convergeant dans leur effort commun : rendre à nouveau visible ce que l’archicration avait dissimulé* ; réinsuffler de l’épreuve là où ne restait que la norme automatisée ; *déstabiliser la prétention au sans-faille, au sans-friction, au sans-discussion*.
 
-Ce sont elles qui tracent, dans les failles du régime, *les lignes de fuite vers une archicration réhumanisée*. Car ce n’est pas l’archicration elle-même qui est à abolir — mais *son effacement comme épreuve*. La politique ne commence pas où s’arrête la régulation, mais *là où elle redevient visible, discutable, disputable*.
+Elles ouvrent, dans les failles du régime, des possibilités de réouverture archicrative. Car ce n’est pas l’archicration elle-même qui est à abolir — mais *son effacement comme épreuve*. La politique ne commence pas où s’arrête la régulation, mais *là où elle redevient visible et discutable*.
 
 Ce n’est pas un hasard si, à mesure que le pouvoir devient technique, dispersé, silencieux, les figures de la dissidence migrent elles aussi vers les marges de l’infrastructure. Dans l’univers de l’archicration oblitérée — où la régulation s’effectue sans scène, sans garant, sans confrontation explicite — la dissidence ne peut plus se loger dans les formes classiques de l’antagonisme institutionnel. Elle doit frapper au cœur de l’opacité systémique. *C’est là que surgit la figure du whistleblower : non pas simplement comme lanceur d’alerte, mais comme opérateur de vérité dans un monde saturé de gouvernance opaque*.
 
@@ -1302,13 +1304,13 @@ Edward Snowden, Chelsea Manning, Julian Assange : autant de noms qui, bien au-de
 
 Ce qui s’opère ici, c’est une désobfuscation du réel : là où le pouvoir numérique repose sur l’invisibilité de ses mécanismes, le lanceur d’alerte brise le charme opaque du système. Il met en échec ce que Byung-Chul Han nomme *l'inaccessibilité des dispositifs algorithmiques* (cf. *Psychopolitique*, 2014), à savoir l’impossibilité structurelle, pour le citoyen ordinaire, de comprendre ou même de soupçonner les logiques réelles de régulation à l’œuvre. De sorte que le *whistleblower transforme cette opacité en événement de dévoilement*. Il politise ce qui était présenté comme pur dispositif technique.
 
-Mais cette politisation opère sans organe représentatif, sans cadre délibératif classique. Elle est *sans médiation*. Elle traverse le corps du dissident, le lie immédiatement à l’infrastructure numérique, et *court-circuite les scènes conventionnelles de la démocratie libérale*. Ce que Snowden révèle en 2013, ce n’est pas seulement l’existence de programmes de surveillance massifs comme PRISM ou XKeyscore, c’est l’annulation pratique de toute distinction entre contrôle étatique et gouvernance privée, entre surveillance extérieure et extraction permanente de données. *Il ne dénonce pas : il démontre*. Il ne propose pas une réforme : il met en crise l’architecture même de la régulation contemporaine.
+Mais cette politisation opère sans organe représentatif, sans cadre délibératif classique. Elle est *sans médiation*. Elle traverse le corps du dissident, le lie immédiatement à l’infrastructure numérique, et *court-circuite les scènes conventionnelles de la démocratie libérale*. Ce que Snowden révèle en 2013, ce n’est pas seulement l’existence de programmes de surveillance massifs comme PRISM ou XKeyscore, c’est l’annulation pratique de toute distinction entre contrôle étatique et gouvernance privée, entre surveillance extérieure et extraction permanente de données. Son geste ne se réduit pas à la dénonciation : il documente et met au jour une architecture de régulation contemporaine. Il ne propose pas à lui seul une réforme, mais il oblige à requalifier les conditions mêmes de visibilité du pouvoir technique.
 
-Ce geste constitue en soi une épreuve archicratique. En révélant les mécanismes régulateurs dissimulés, le whistleblower redonne une scène à l’épreuve. Il fait apparaître *l’infrastructure comme lieu du politique*. Dans ce sens, il ne s’oppose pas frontalement à une loi ou à un décret : *il oppose la visibilité à l’opacité, la parole à l’automatisation, la subjectivation à la captation*. Il démasque la *fausse neutralité* neutre, il perturbe le pouvoir qui prétend ne pas en être un.
+Ce geste constitue en soi une épreuve archicratique. En révélant les mécanismes régulateurs dissimulés, le *lanceur d’alerte* redonne une scène à l’épreuve. Il fait apparaître *l’infrastructure comme lieu du politique*. Dans ce sens, il ne s’oppose pas frontalement à une loi ou à un décret : *il oppose la visibilité à l’opacité, la parole à l’automatisation, la subjectivation à la captation*. Il démasque la *fausse neutralité* neutre, il perturbe le pouvoir qui prétend ne pas en être un.
 
 Mais ce geste est aussi radicalement dangereux. Car en révélant l’architecture invisible de l’archicration, il menace *la fiction fondamentale de la gouvernance post-normative* : celle selon laquelle il n’y aurait plus d’autorité, mais seulement des flux, des interfaces, des paramètres. *Il réintroduit la possibilité d’une conflictualité là où l’on prétendait avoir pacifié le monde*. D’où les châtiments qui frappent ces figures : exils, enfermements, diffamations, harcèlements judiciaires, neutralisation symbolique. La démocratie libérale, en théorie fondée sur la transparence, se révèle ici comme *hostile à ceux qui dévoilent la régulation réelle*. Elle protège l’opacité sous couvert de stabilité.
 
-Le *whistleblower* n’est donc pas un héros romantique ou un martyr moral : *il est un opérateur critique de premier ordre dans la guerre archicratique contemporaine*. Il révèle que le régime archicratique oblitéré n’est pas post-politique — il est anti-politique. Et que *la seule manière d’en reprendre la maîtrise passe par la révélation de ses architectures*. Le whistleblower opère une refiguration de l’espace public : il *remet en scène* les dispositifs, *réinscrit* la conflictualité là où elle avait été oblitérée, *relance* l’épreuve là où elle avait été dissoute.
+Le *whistleblower* n’est donc pas un héros romantique ou un martyr moral : *il est un opérateur critique de premier ordre dans la guerre archicratique contemporaine*. Il révèle que le régime archicratique oblitéré n’est pas post-politique — il est anti-politique. Et que *la seule manière d’en reprendre la maîtrise passe par la révélation de ses architectures*. En cela, le lanceur d’alerte opère une re-figuration de l’espace public : il *remet en scène* les dispositifs, *réinscrit* la conflictualité là où elle avait été oblitérée, *relance* l’épreuve là où elle avait été dissoute.
 
 Si le *lanceur d’alerte* incarne la figure du dévoilement, le *pirate informatique* (*hacker*), quant à lui, incarne celle du *forçage*. Là où le premier ouvre à la visibilité ce qui était tenu dans l’ombre, le second *intervient au cœur du dispositif*, non pour l’exposer, mais pour *le détourner, le dérégler, le subvertir de l’intérieur*. Le *hacker* est à la fois opérateur technique, acteur politique et *esthète de l’incongru numérique*. Il ne s’oppose pas frontalement au pouvoir ; *il infiltre son code source*, il le déjoue, il l’attaque en sa syntaxe même. En cela, il constitue une figure majeure du dissensus dans les régimes d’*archicration oblitérée*.
 
@@ -1352,17 +1354,17 @@ En cela, cette phase terminale de la régulation numérique ne signe pas la fin
 
 Nous voici donc face à un carrefour : soit l’archicration se referme dans la transparence automatisée de son propre silence ; soit elle s’ouvre à nouveau comme scène, comme adresse, comme espace disputable. Et cette ouverture, nul ne peut l’imposer — elle ne peut surgir que des gestes critiques, des insurrections infra-politiques, des bifurcations institutionnelles et technologiques que nous avons commencé ici à tracer. Il nous reste désormais à penser, dans le chapitre suivant, les conditions *archistratégiques* d’un tel retournement : comment réinstituer une archicration *exposable*, *habitable*, *négociable* — c’est-à-dire, au fond, pourrait-on dire *humaine* ?!?
 
-Contre la désincarnation du pouvoir, contre la neutralisation algorithmique des différences, contre la réduction du monde vécu à des variables techniques, surgit une figure profondément transgressive : celle du *soulèvement situé*. Non pas une révolution abstraite, universelle, téléguidée, mais un cri, un geste, un ancrage — une insurrection qui part du corps, du lieu, de l’histoire vécue, et qui refuse de se laisser réduire à une ligne de code, un score comportemental ou un indicateur de performance. Cette figure, éclatée mais persistante, prend forme dans les luttes **antiracistes**, **féministes**, **écoféministes**, **décoloniales**, **intersectionnelles**, là où l’archicration contemporaine prétend précisément avoir *résolu* le conflit par *l’intégration*, *l’inclusion*, ou *l’efficience*.
+Contre la désincarnation du pouvoir, contre la neutralisation algorithmique des différences, contre la réduction du monde vécu à des variables techniques, surgit une figure profondément transgressive : celle du *soulèvement situé*. Non pas une révolution abstraite, universelle, téléguidée, mais un cri, un geste, un ancrage — une insurrection qui part du corps, du lieu, de l’histoire vécue, et qui refuse de se laisser réduire à une ligne de code, un score comportemental ou un indicateur de performance. Cette figure, éclatée mais persistante, prend forme dans les luttes antiracistes, féministes, écoféministes, décoloniales, intersectionnelles, là où l’archicration contemporaine prétend précisément avoir *résolu* le conflit par *l’intégration*, *l’inclusion*, ou *l’efficience*.
 
 Ce que ces luttes déploient, c’est *l’irréductibilité du vécu au format régulatoire*. Elles disent : l’injustice n’est pas seulement un déséquilibre quantifiable — c’est une *blessure située*. Elles rappellent que toute régulation est aussi un *récit*, qu’elle découpe le monde selon des lignes de visibilité et d’invisibilité, de dignité et d’indignité. Et c’est précisément dans ces marges que le soulèvement situé opère son *renversement de focale* : il fait remonter l’histoire des corps niés, des voix disqualifiées, des mémoires oblitérées.
 
-La figure du soulèvement situé est donc radicalement **anti-algorithmique**. Elle refuse l’abstraction, la dislocation, la dissociation. Elle est une réinscription. Elle réintroduit le *poids du lieu*, *la texture du corps*, *la densité du temps*. Les **mouvements féministes intersectionnels**, par exemple, montrent que la norme ne s’impose jamais de manière neutre : elle frappe différemment selon les croisements de race, de genre, de classe, de sexualité, de capacité. Comme l’a montré bell hooks dans *Ain’t I a Woman?* (1981), l’universel abstrait n’est souvent que le nom dissimulé d’une exclusion fondée. Ce que produisent ces luttes, c’est donc une **critique de l’universalité régulatoire** : elles mettent à nu les biais inscrits dans les structures, dans les algorithmes, dans les indicateurs, dans les dispositifs soi-disant neutres.
+La figure du soulèvement situé est donc radicalement anti-algorithmique. Elle refuse l’abstraction, la dislocation, la dissociation. Elle est une réinscription. Elle réintroduit le *poids du lieu*, *la texture du corps*, *la densité du temps*. Les mouvements féministes intersectionnels, par exemple, montrent que la norme ne s’impose jamais de manière neutre : elle frappe différemment selon les croisements de race, de genre, de classe, de sexualité, de capacité. Comme l’a montré bell hooks dans *Ain’t I a Woman?* (1981), l’universel abstrait n’est souvent que le nom dissimulé d’une exclusion fondée. Ce que produisent ces luttes, c’est donc une critique de l’universalité régulatoire : elles mettent à nu les biais inscrits dans les structures, dans les algorithmes, dans les indicateurs, dans les dispositifs soi-disant neutres.
 
-Les **luttes écoféministes** en particulier incarnent ce lien essentiel entre **le corps et le territoire**, entre **la dépossession écologique** et **la domination genrée**. Vandana Shiva, dans *Staying Alive: Women, Ecology, and Development* (1988), montre comment la logique extractiviste de l’économie mondiale repose sur une archicration qui invisibilise les savoirs situés, les soins invisibles, les agricultures de subsistance, les formes locales de résilience. Face à cela, le soulèvement situé ne propose pas une nouvelle machine de pouvoir : il propose une **régulation par réinscription**, une archicration réparatrice, lente, polyphonique, incarnée.
+Les luttes écoféministes en particulier incarnent ce lien essentiel entre le corps et le territoire, entre la dépossession écologique et la domination genrée. Vandana Shiva, dans *Staying Alive: Women, Ecology, and Development* (1988), montre comment la logique extractiviste de l’économie mondiale repose sur une archicration qui invisibilise les savoirs situés, les soins invisibles, les agricultures de subsistance, les formes locales de résilience. Face à cela, le soulèvement situé ne propose pas une nouvelle machine de pouvoir : il propose une régulation par réinscription, une archicration réparatrice, lente, polyphonique, incarnée.
 
-Enfin, les **mouvements décoloniaux**, en Amérique latine, en Afrique, dans les diasporas, dans les banlieues postcoloniales, posent la question la plus radicale : *Qui décide de la norme ?* Qui possède le pouvoir de réguler ? Qui est vu comme acteur politique, et qui est réduit à une cible de gouvernance ? Cette interrogation est centrale, comme le rappelle Frantz Fanon dans *Les damnés de la terre* (1961) : la violence coloniale n’est pas seulement militaire ou économique — elle est *normative*. Elle impose *ce qui compte*, *ce qui vaut*, *ce qui existe*. Les soulèvements situés viennent désactiver cette violence, non par la prise du pouvoir, mais par *la reconstitution d’un monde habitable* — un monde dans lequel la norme n’est plus une abstraction venue d’en haut, mais un **tissage situé de récits, de voix, de vécus**.
+Enfin, les mouvements décoloniaux, en Amérique latine, en Afrique, dans les diasporas, dans les banlieues postcoloniales, posent la question la plus radicale : *Qui décide de la norme ?* Qui possède le pouvoir de réguler ? Qui est vu comme acteur politique, et qui est réduit à une cible de gouvernance ? Cette interrogation est centrale, comme le rappelle Frantz Fanon dans *Les damnés de la terre* (1961) : la violence coloniale n’est pas seulement militaire ou économique — elle est *normative*. Elle impose *ce qui compte*, *ce qui vaut*, *ce qui existe*. Les soulèvements situés viennent désactiver cette violence, non par la prise du pouvoir, mais par *la reconstitution d’un monde habitable* — un monde dans lequel la norme n’est plus une abstraction venue d’en haut, mais un tissage situé de récits, de voix, de vécus.
 
-Ainsi, loin d’être des revendications secondaires ou périphériques, ces figures du soulèvement situé constituent la **ligne de fuite la plus radicale** contre l’archicration oblitérée. Elles en révèlent les angles morts, les fractures, les impensés. Elles n’abolissent pas la régulation — elles la **redéfinissent depuis les marges**. Et c’est précisément là que réside leur puissance critique, mais aussi leur capacité à nourrir une **archicration alternative**, pluraliste, réflexive, traversée par la conflictualité du monde réel.
+Ainsi, loin d’être des revendications secondaires ou périphériques, ces figures du soulèvement situé constituent la ligne de fuite la plus radicale contre l’archicration oblitérée. Elles en révèlent les angles morts, les fractures, les impensés. Elles n’abolissent pas la régulation — elles la redéfinissent depuis les marges. Et c’est précisément là que réside leur puissance critique, mais aussi leur capacité à nourrir une archicration alternative, pluraliste, réflexive, traversée par la conflictualité du monde réel.
 
 ## **4.6 — Archidiagnostic, bilan tensionnel et projections d’instauration : vers une cinquième révolution régulatoire consciente**
 
@@ -1370,20 +1372,22 @@ Ainsi, loin d’être des revendications secondaires ou périphériques, ces fig
 
 Ce chapitre 4.6 ne se propose pas comme une synthèse terminale, encore moins comme une fermeture. Il est archidiagnostique, au sens fort : il vise à rendre intelligible, par une analyse stratifiée, *la logique proprement différentielle* des régimes de régulation que nous avons mis en évidence — leurs cohérences internes, leurs écarts fondamentaux, leurs continuités invisibles, leurs seuils de tension critique. Il ne s’agit pas d’énoncer des successions linéaires, mais de tracer la courbure dynamique des dispositifs archicratiques, en montrant comment arcalité, cratialité et archicration se recombinent à chaque phase historique selon des ratios distincts de visibilité, d’universalité, de coercition, de légitimité.
 
-Mais cette cartographie ne serait rien si elle n’ouvrait pas aussi une bifurcation spéculative, rigoureusement fondée, vers une cinquième configuration régulatoire possible : non plus subie, non plus technique, non plus automatisée ni masquée, mais explicite, située, consciente, instituante. Ce que nous appelons ici « cinquième révolution régulatoire » n’est pas un fantasme téléologique, ni une projection technicienne. C’est l’hypothèse d’une reconfiguration réflexive de la régulation, dans laquelle la scène elle-même — scène de l’autorité, scène de la décision, scène du commun — est restaurée comme espace d’épreuve, comme forme visible, comme infrastructure politique instituée et discutable.
+Mais cette cartographie serait incomplète si elle n’ouvrait pas aussi une bifurcation spéculative, rigoureusement fondée, vers une cinquième configuration régulatoire possible : non plus subie, non plus technique, non plus automatisée ni masquée, mais explicite, située, consciente, instituante. Ce que nous appelons ici « cinquième révolution régulatoire » n’est pas un fantasme téléologique, ni une projection technicienne. C’est l’hypothèse d’une reconfiguration réflexive de la régulation, dans laquelle la scène elle-même — scène de l’autorité, scène de la décision, scène du commun — est restaurée comme espace d’épreuve, comme forme visible, comme infrastructure politique instituée et discutable.
 
 Cette cinquième révolution ne sera pas automatique : elle suppose un diagnostic clair de ce qui, dans les régimes antérieurs, a conduit à l’effondrement de la scène, à la déshumanisation de la norme, à l’abstraction des épreuves. Elle exige de penser ensemble les figures de la vulnérabilité structurelle (fragilité des systèmes, opacité algorithmique, déconnexion sociale) et celles du dissensus instituant (lanceurs d’alerte, pirates informatiques, luttes situées, formes de réinscription politique). Elle impose de comprendre que réguler, aujourd’hui, ne peut plus signifier masquer ou automatiser — mais au contraire : *exposer, rendre contestable, instituer*.
 
-Ainsi, la section 4.6 sera structuré selon une triple visée : d’abord, rendre lisible la matrice triptyque A–C–A’ à travers les quatre régimes précédemment étudiés ; ensuite, dénouer les points de bascule, les seuils d’instabilité, les contradictions internes qui rendent la continuation du régime actuel insoutenable ; enfin, formuler une projection consciente, non prescriptive mais exploratoire, vers une cinquième archicration possible, définie non par sa technicité mais par sa capacité à réinstaurer l’espace du commun comme scène de régulation explicite.
+Ainsi, la section 4.6 sera structurée selon une triple visée : d’abord, rendre lisible la matrice triptyque A–C–A’ à travers les quatre séquences historico-régulatrices précédemment étudiées ; ensuite, dénouer les points de bascule, les seuils d’instabilité et les contradictions internes qui rendent la continuation du régime actuel insoutenable ; enfin, formuler une projection consciente, non prescriptive mais exploratoire, vers une cinquième archicration possible, définie non par sa technicité mais par sa capacité à réinstaurer l’espace du commun comme scène de régulation explicite.
 
-La tâche est immense. Mais elle est surtout devenue urgente.
+Il convient toutefois de préciser que les sections 4.2 à 4.5 ont suivi des séquences d’émergence historico-régulatrices, tandis que la matrice qui suit condense des régimes longs de domination relative, partiellement chevauchants, afin d’en faire apparaître la logique structurelle plutôt que d’en reconduire une lecture linéaire.
 
-### 4.6.1 — Cartographie des régimes archicratiques : matrice A–C–A’
+### **4.6.1 — Cartographie des régimes archicratiques : matrice A–C–A’**
 
 L’enjeu ici n’est pas seulement classificatoire. Il est *épistémogénétique*. Ce que nous avons désigné tout au long de notre essai-thèse comme *Archicratie* ne peut désormais plus être pensé comme un concept figé, ni comme une fonction invariante du pouvoir, mais comme une structure évolutive, dont les configurations historiques concrètes sont articulées selon trois dimensions fondamentales : l’*arcalité* (formes d’infrastructure du pensable et du faisable), la *cratialité* (formes d’activation de la puissance régulatrice), et l’*archicration* proprement dite (niveaux d’intégration, d’exposition, de délibération, ou d’effacement de la scène régulatrice).
 
 Il ne s’agit donc pas ici de répéter ce qui a été dit, mais de recomposer une lecture différentielle des quatre grands régimes que nous avons dégagés, à travers une matrice systémique triptyque A–C–A’. Cette triple entrée permet de faire émerger non seulement les contrastes, mais aussi les dynamiques de tension, de translation, de refoulement, ou d’exacerbation qui affectent les régimes de régulation dans le temps long de la modernité industrielle et post-industrielle.
 
+Cette matrice ne doit donc pas être lue comme un tableau de successions closes ni comme un récit de substitution aux périodisations historiques classiques, mais comme un outil de condensation heuristique permettant de faire apparaître, dans la longue durée, des régimes de domination relative dont les frontières demeurent poreuses, chevauchées et historiquement réversibles.
+
 #### **I. Le régime proto-industriel (env. 1780–1914) — Régulation disciplinaire-visible**
 
 Dans ce premier régime, que l’on peut rattacher à la première révolution industrielle et à la montée du pouvoir disciplinaire (Michel Foucault, *Surveiller et punir*, 1975), l’*arcalité* est *matérielle et visible*. Elle s’incarne dans des formes spatiales localisées : usines, casernes, hospices, prisons, écoles. L’espace est compartimenté, l’ordre est topographié. Les dispositifs de surveillance et de distribution (panoptisme, inspection, quadrillage) constituent les armatures visibles de la régulation.
@@ -1392,10 +1396,10 @@ La *cratialité*, quant à elle, repose sur *la force individuelle modulée*, su
 
 Enfin, l’*archicration* se donne encore *comme scène explicite* : le pouvoir est visible, incarné, hiérarchisé ; la régulation est *disciplinaire, située, incarnée* dans des corps de métiers, des figures d’autorité, des lieux d’enfermement. L’autorité est identifiable, le commandement localisé, l’épreuve régulatoire vécue comme interpellation directe.
 
-→ *Matrice A–C–A’* (1780–1914) :  
-*Arcalité* : visible, localisée, spatialisée  
-*Cratialité* : corporelle, disciplinaire, gestuelle  
-*Archicration* : incarnée, explicite, hiérarchique
+> → *Matrice A–C–A’* (1780–1914) :  
+> *Arcalité* : visible, localisée, spatialisée  
+> *Cratialité* : corporelle, disciplinaire, gestuelle  
+> *Archicration* : incarnée, explicite, hiérarchique
 
 #### **II. Le régime fordo-planificateur (env. 1918–1973) — Régulation technobureaucratique-planifiée**
 
@@ -1403,12 +1407,12 @@ Ce régime, forgé dans les feux croisés de la rationalisation fordiste, de la
 
 La *cratialité* s’institue *sur le mode collectif* : elle mobilise des masses, des corps agrégés, des gestes synchronisés par la division scientifique du travail. Taylorisme et fordisme sont les matrices de cette *cratialité systémique*, productiviste, disciplinante à large échelle.
 
-L’*archicration*, dans ce régime, devient *stabilisatrice et concertée* : elle repose sur des compromis historiques (pacte fordiste, conventions collectives, co-gestion syndicale), qui donnent lieu à des *formes de régulation formalisées, visibles, négociées*. Le conflit social est reconnu, encadré, régulé. La scène régulatoire est organisée par des institutions politiques, économiques et sociales qui en assurent la visibilité, la représentation, l’intelligibilité.
+L’*archicration*, dans ce régime, devient *stabilisatrice et concertée* : elle repose sur des compromis historiques (pacte fordiste, conventions collectives, co-gestion syndicale), qui donnent lieu à des formes de *régulation formalisées, visibles, négociées*. Le conflit social est reconnu, encadré, régulé. La scène régulatoire est organisée par des institutions politiques, économiques et sociales qui en assurent la visibilité, la représentation, l’intelligibilité.
 
-→ *Matrice A–C–A’* (1918–1973) :  
-*Arcalité* : technobureaucratique, infrastructurelle, standardisée  
-*Cratialité* : collectivisée, synchronisée, encadrée  
-*Archicration* : institutionnalisée, délibérée, stabilisatrice
+> → *Matrice A–C–A’* (1918–1973) :  
+> *Arcalité* : technobureaucratique, infrastructurelle, standardisée  
+> *Cratialité* : collectivisée, synchronisée, encadrée  
+> *Archicration* : institutionnalisée, délibérée, stabilisatrice
 
 #### **III. Le régime néolibéral-cybernétique (env. 1973–2010) — Régulation algorithmique-distribuée**
 
@@ -1418,10 +1422,10 @@ La *cratialité*, ici, se loge dans le *signal*. Elle cesse d’être l’activa
 
 L’*archicration* se *disperse et s’efface*. Le pouvoir se loge dans les interfaces, les algorithmes, les conventions techniques. Il n’est plus visible, ni même situé. La scène régulatrice se retire derrière les infrastructures : elle devient *gouvernance sans garant, gestion sans politique, régulation sans représentation*. Le pouvoir opère sans apparaître.
 
-→ *Matrice A–C–A’* (1973–2010) :  
-*Arcalité* : réticulaire, systémique, logique  
-*Cratialité* : signalétique, inférentielle, informationnelle  
-*Archicration* : oblitérée, automatisée, dépolitisée
+> → *Matrice A–C–A’* (1973–2010) :  
+> *Arcalité* : réticulaire, systémique, logique  
+> *Cratialité* : signalétique, inférentielle, informationnelle  
+> *Archicration* : oblitérée, automatisée, dépolitisée
 
 #### **IV. Le régime algorithmique-oblitérant (env. 2010–2025) — Régulation prédictive-effacée**
 
@@ -1431,14 +1435,14 @@ La *cratialité*, elle, devient *anticipatoire*. *Elle vise à prédire, pré-co
 
 L’*archicration*, dans cette configuration, est *oblitérée à un niveau tel qu’il n’y a plus de scène*. Il n’y a plus de conflit représentable, plus d’épreuve négociable, plus de contradiction visible. La norme n’est plus énoncée : elle est *encodée*. Le sujet n’est plus interpellé : il est filtré, mesuré, noté, profilé. C’est le règne de la *régulation sans preuve ni procès*, selon l’expression qu’il faut désormais consacrer.
 
-→ *Matrice A–C–A’* (2010–2025) :  
-*Arcalité* : invisible, architecturale, codée  
-*Cratialité* : prédictive, comportementale, probabiliste  
-*Archicration* : effacée, désincarnée, silencieuse
+> → *Matrice A–C–A’* (2010–2025) :  
+> *Arcalité* : invisible, architecturale, codée  
+> *Cratialité* : prédictive, comportementale, probabiliste  
+> *Archicration* : effacée, désincarnée, silencieuse
 
 Ce schéma triptyque, cette matrice dynamique A–C–A’, constitue le socle fondamental de la section suivante. Il rend possible une lecture en écarts et tensions, en transitions et basculements. Car ce que cette cartographie fait émerger, au-delà des différences, c’est l’accélération de l’effacement : à mesure que les régimes se perfectionnent techniquement, la scène du pouvoir se dérobe, s’efface, s’automatise — jusqu’à oblitérer l’expérience même du conflit. C’est là le seuil critique. C’est là que doit être pensée l’hypothèse nécessaire d’un retournement conscient.
 
-### 4.6.2 — Tensions, bifurcations, seuils d’instabilité : pour une trialectique régulatoire
+### **4.6.2 — Tensions, bifurcations, seuils d’instabilité : pour une trialectique régulatoire**
 
 Il ne suffit pas d’identifier des séquences historiques de la régulation pour en comprendre la dynamique profonde. Il faut saisir ce qui dans chaque régime en vient à excéder ses propres dispositifs, à disjoindre ses fondements internes, à faire imploser ses structures de légitimation. Ce que nous appelons ici *bifurcation* n’est donc ni un tournant linéaire, ni un simple glissement conjoncturel, mais un moment d’instabilité radicale où la triade *arcalité–cratialité–archicration* se déséquilibre au point de rendre impossible le maintien du régime sans reconfiguration complète. Chaque mutation historique correspond alors à un seuil de tension maximale, où les dispositifs régulatoires en place ne parviennent plus à absorber ni à articuler les contradictions qu’ils ont eux-mêmes engendrées. Il nous faut ici construire une *trialectique régulatoire des crises*, non pas comme succession, mais comme *épuisement d’un modèle de régulation*.
 
@@ -1460,15 +1464,15 @@ Ce moment n’est pas un retour au libéralisme classique : c’est une mutation
 
 #### Crise post-2008 et effondrement différé du régime néolibéral : vers l’archicration oblitérée
 
-La dernière grande inflexion, celle que nous vivons encore, prend sa source dans la **crise financière globale de 2008**. La bulle spéculative des subprimes, l’effondrement de Lehman Brothers, les plans de sauvetage massifs et la reprise de la planche à billets (quantitative easing) exposent au grand jour les fragilités du système néolibéral. Pourtant, cette fois-ci, aucun régime alternatif ne parvient à s’imposer. L’État revient brièvement comme agent de stabilisation, mais il ne propose plus d’architecture régulatrice substantielle. Il n’y a plus de New Deal. Plus de grand récit. Plus d’utopie fédératrice.
+La dernière grande inflexion, celle que nous vivons encore, prend sa source dans la crise financière globale de 2008. La bulle spéculative des subprimes, l’effondrement de Lehman Brothers, les plans de sauvetage massifs et la reprise de la planche à billets (quantitative easing) exposent au grand jour les fragilités du système néolibéral. Pourtant, cette fois-ci, aucun régime alternatif ne parvient à s’imposer. L’État revient brièvement comme agent de stabilisation, mais il ne propose plus d’architecture régulatrice substantielle. Il n’y a plus de New Deal. Plus de grand récit. Plus d’utopie fédératrice.
 
-C’est ici que s’installe ce que nous avons nommé, dans tout le chapitre 4.5, **l’archicration oblitérée**. La scène de régulation n’est pas abolie : elle est dissimulée. Elle s’automatise, s’encapsule, se déterritorialise dans les data centers, les architectures de cloud, les IA prédictives, les nudges comportementaux, les plateformes souveraines. La régulation s’effectue, mais *hors de toute scène identifiable, discutable ou incarnée*.
+C’est ici que s’installe ce que nous avons nommé, dans tout le chapitre 4.5, l’archicration oblitérée. La scène de régulation n’est pas abolie : elle est dissimulée. Elle s’automatise, s’encapsule, se déterritorialise dans les data centers, les architectures de cloud, les IA prédictives, les nudges comportementaux, les plateformes souveraines. La régulation s’effectue, mais *hors de toute scène identifiable, discutable ou incarnée*.
 
 Cette configuration repose sur un triple effacement : de la légitimité explicite, de la souveraineté politique, de la conflictualité reconnue. L’arcalité devient invisible, la cratialité anticipatoire, l’archicration dissoute. Ce régime n’est pas moins performant — il est plus dangereux. Car il rend la critique structurellement inaudible, la résistance presque illisible, la reconfiguration politique impraticable.
 
-En somme, à travers ces trois seuils d’instabilité (1929, 1973, 2008), se dessine une logique plus profonde que celle d’une simple succession : **la logique des bifurcations archicratiques**. Chaque régime ne meurt pas de ses ennemis, mais de ses contradictions internes ; chaque transition ne procède pas d’un renversement idéologique, mais d’une **crise immanente de la capacité régulatrice**, selon les trois axes de notre trialectique. C’est cette structure que nous devons désormais rendre pleinement opératoire — pour penser la possibilité, la nécessité, et peut-être l’urgence d’un *cinquième régime régulatoire*, conscient, exposé, institué comme *scène archicratique ouverte*.
+En somme, à travers ces trois seuils d’instabilité (1929, 1973, 2008), se dessine une logique plus profonde que celle d’une simple succession : la logique des bifurcations archicratiques. Chaque régime ne meurt pas de ses ennemis, mais de ses contradictions internes ; chaque transition ne procède pas d’un renversement idéologique, mais d’une crise immanente de la capacité régulatrice, selon les trois axes de notre trialectique. C’est cette structure que nous devons désormais rendre pleinement opératoire — pour penser la possibilité, la nécessité, et peut-être l’urgence d’un *cinquième régime régulatoire*, conscient, exposé, institué comme *scène archicratique ouverte*.
 
-### 4.6.3 — Critique de la régulation automatisée : du fantasme d’auto-pilotage à la décomposition de la scène politique
+### **4.6.3 — Critique de la régulation automatisée : du fantasme d’auto-pilotage à la décomposition de la scène politique**
 
 Ce que la quatrième configuration archicratique contemporaine a porté à son point d’intensité maximal, c’est moins une stabilisation efficiente du monde par la technologie qu’un fantasme technogénétique d’auto-pilotage régulatoire — un rêve cybernétique devenu dogme gestionnaire : celui selon lequel un monde complexe pourrait être gouverné sans sujet, sans instance tierce, sans conflit, sans institution. L’illusion, ici, n’est pas tant celle d’une surpuissance technique, que celle d’une *autorégulation sans scène*, où tout se jouerait dans la fluence des flux, la continuité des données, la plasticité des ajustements instantanés. C’est cette croyance dans l’auto-équilibrage algorithmique du social qui, aujourd’hui, manifeste ses effets délétères les plus profonds : fragilité structurelle, défaillance systémique, dépolitisation radicale et oblitération du dissensus.
 

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.