chore(repo): remove obsolete graph files from root

Reviewed-on: #349

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

@@ -41,7 +41,7 @@ jobs:
         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";
@@ -66,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");
 
@@ -81,7 +84,6 @@ jobs:
             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;
@@ -95,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)}`,
@@ -108,7 +110,7 @@ jobs:
           ].join("\n") + "\n");
           NODE
 
-          echo "✅ context:"
+          echo "context:"
           sed -n '1,120p' /tmp/anno.env
 
       - name: Early gate (label event fast-skip, but tolerant)
@@ -116,18 +118,16 @@ jobs:
           set -euo pipefail
           source /tmp/anno.env
 
-          echo "ℹ️ event label = $LABEL_NAME"
+          echo "event label = $LABEL_NAME"
 
-          # Fast skip on obvious non-approved label events (avoid noise),
-          # BUT do NOT skip if label payload is weird/unknown.
           if [[ "$LABEL_NAME" != "state/approved" && "$LABEL_NAME" != "workflow_dispatch" && "$LABEL_NAME" != "" && "$LABEL_NAME" != "[object Object]" ]]; then
-            echo "ℹ️ label=$LABEL_NAME => skip early"
+            echo "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 "✅ continue to API gating (issue=$ISSUE_NUMBER)"
+          echo "continue to API gating (issue=$ISSUE_NUMBER)"
 
       - name: Fetch issue + hard gate on labels + Type
         env:
@@ -135,9 +135,9 @@ jobs:
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || { echo "skipped"; exit 0; }
 
-          test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
+          test -n "${FORGE_TOKEN:-}" || { echo "Missing secret FORGE_TOKEN"; exit 1; }
 
           curl -fsS \
             -H "Authorization: token $FORGE_TOKEN" \
@@ -148,11 +148,12 @@ jobs:
           node --input-type=module - <<'NODE' >> /tmp/anno.env
           import fs from "node:fs";
 
-          const issue = JSON.parse(fs.readFileSync("/tmp/issue.json","utf8"));
-          const title = String(issue.title || "");
+          const 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 labels = Array.isArray(issue.labels)
+            ? issue.labels.map(l => String(l.name || "")).filter(Boolean)
+            : [];
           const hasApproved = labels.includes("state/approved");
 
           function pickLine(key) {
@@ -164,14 +165,12 @@ jobs:
           const typeRaw = pickLine("Type");
           const type = String(typeRaw || "").trim().toLowerCase();
 
-          const allowed = new Set(["type/media","type/reference","type/comment"]);
-          const proposer = new Set(["type/correction","type/fact-check"]);
+          const allowedAnno = new Set(["type/media", "type/reference", "type/comment"]);
+          const proposerTypes = new Set(["type/correction", "type/fact-check"]);
 
           const out = [];
-          out.push(`ISSUE_TITLE=${JSON.stringify(title)}`);
           out.push(`ISSUE_TYPE=${JSON.stringify(type)}`);
 
-          // HARD gate: must currently have state/approved (avoids depending on event payload)
           if (!hasApproved) {
             out.push(`SKIP=1`);
             out.push(`SKIP_REASON=${JSON.stringify("not_approved_label_present")}`);
@@ -182,23 +181,23 @@ jobs:
           if (!type) {
             out.push(`SKIP=1`);
             out.push(`SKIP_REASON=${JSON.stringify("missing_type")}`);
-          } else if (allowed.has(type)) {
+          } else if (allowedAnno.has(type)) {
             // proceed
-          } else if (proposer.has(type)) {
+          } else if (proposerTypes.has(type)) {
             out.push(`SKIP=1`);
-            out.push(`SKIP_REASON=${JSON.stringify("proposer_type:"+type)}`);
+            out.push(`SKIP_REASON=${JSON.stringify("proposer_type:" + type)}`);
           } else {
             out.push(`SKIP=1`);
-            out.push(`SKIP_REASON=${JSON.stringify("unsupported_type:"+type)}`);
+            out.push(`SKIP_REASON=${JSON.stringify("unsupported_type:" + type)}`);
           }
 
           process.stdout.write(out.join("\n") + "\n");
           NODE
 
-          echo "✅ gating result:"
+          echo "gating result:"
           grep -E '^(ISSUE_TYPE|SKIP|SKIP_REASON)=' /tmp/anno.env || true
 
-      - name: Comment issue if skipped (Proposer / unsupported / missing Type)
+      - name: Comment issue if skipped (unsupported / missing Type only)
         if: ${{ always() }}
         env:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
@@ -208,9 +207,13 @@ jobs:
 
           [[ "${SKIP:-0}" == "1" ]] || exit 0
 
-          # IMPORTANT: do NOT comment for "not_approved_label_present" (avoid spam on other label events)
           if [[ "${SKIP_REASON:-}" == "not_approved_label_present" || "${SKIP_REASON:-}" == "label_not_approved_event" ]]; then
-            echo "ℹ️ skip reason=${SKIP_REASON} -> no comment"
+            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
 
@@ -219,15 +222,13 @@ jobs:
           REASON="${SKIP_REASON:-}"
           TYPE="${ISSUE_TYPE:-}"
 
-          if [[ "$REASON" == proposer_type:* ]]; then
-            MSG="ℹ️ Ticket #${ISSUE_NUMBER} détecté comme **Proposer** (${TYPE}).\n\n- Ce type est **traité manuellement par les editors**.\n✅ Aucun traitement automatique."
-          elif [[ "$REASON" == unsupported_type:* ]]; then
-            MSG="ℹ️ Ticket #${ISSUE_NUMBER} ignoré : Type non supporté par le bot (${TYPE}).\n\nTypes supportés : type/media, type/reference, type/comment."
+          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} ignoré : champ 'Type:' manquant ou illisible.\n\nAjoute : Type: type/media|type/reference|type/comment"
+            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")"
+          PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1] || ""}))' "$MSG")"
 
           curl -fsS -X POST \
             -H "Authorization: token $FORGE_TOKEN" \
@@ -239,7 +240,7 @@ jobs:
         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
@@ -252,16 +253,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 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
           }
@@ -270,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
 
           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
@@ -290,10 +291,10 @@ jobs:
         run: |
           set -euo pipefail
           source /tmp/anno.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
-          test -d .git || { echo "❌ not a git repo (checkout failed)"; echo "APPLY_RC=90" >> /tmp/anno.env; exit 0; }
+          [[ "${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}"
@@ -340,11 +341,11 @@ jobs:
         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 "ℹ️ no failure detected"
+            echo "no failure detected"
             exit 0
           fi
 
@@ -356,8 +357,8 @@ jobs:
             BODY="(no apply log found)"
           fi
 
-          MSG="❌ apply-annotation-ticket a échoué (rc=${RC}).\n\n\`\`\`\n${BODY}\n\`\`\`\n"
-          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" \
@@ -374,9 +375,9 @@ jobs:
           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; }
-          test -d .git || { echo "ℹ️ no git repo -> 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);
@@ -398,8 +399,8 @@ jobs:
           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."
@@ -420,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" \
@@ -431,7 +432,7 @@ 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() }}
@@ -439,11 +440,11 @@ jobs:
           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/deploy-staging-live.yml

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

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

@@ -1,13 +1,16 @@
-name: Proposer Apply (PR)
+name: Proposer Apply (Queue)
 
 on:
   issues:
     types: [labeled]
+  push:
+    branches: [main]
   workflow_dispatch:
     inputs:
       issue:
-        description: "Issue number to apply (Proposer: correction/fact-check)"
-        required: true
+        description: "Issue number to prioritize (optional)"
+        required: false
+        default: ""
 
 env:
   NODE_OPTIONS: --dns-result-order=ipv4first
@@ -17,8 +20,8 @@ defaults:
     shell: bash
 
 concurrency:
-  group: proposer-apply-${{ github.event.issue.number || inputs.issue || 'manual' }}
-  cancel-in-progress: true
+  group: proposer-queue-main
+  cancel-in-progress: false
 
 jobs:
   apply-proposer:
@@ -34,14 +37,15 @@ jobs:
           node --version
           npm --version
 
-      - name: Derive context (event.json / workflow_dispatch)
+      - 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; }
+          test -f "$EVENT_JSON" || { echo "Missing $EVENT_JSON"; exit 1; }
 
           node --input-type=module - <<'NODE' > /tmp/proposer.env
           import fs from "node:fs";
@@ -51,7 +55,7 @@ jobs:
 
           const cloneUrl =
             repoObj?.clone_url ||
-            (repoObj?.html_url ? (repoObj.html_url.replace(/\/$/,"") + ".git") : "");
+            (repoObj?.html_url ? (repoObj.html_url.replace(/\/$/, "") + ".git") : "");
 
           if (!cloneUrl) throw new Error("No repository clone_url/html_url in event.json");
 
@@ -66,8 +70,12 @@ 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");
 
           const defaultBranch = repoObj?.default_branch || "main";
@@ -75,25 +83,30 @@ jobs:
           const issueNumber =
             ev?.issue?.number ||
             ev?.issue?.index ||
-            (process.env.INPUT_ISSUE ? Number(process.env.INPUT_ISSUE) : 0);
-
-          if (!issueNumber || !Number.isFinite(Number(issueNumber))) {
-            throw new Error("No issue number in event.json or workflow_dispatch input");
-          }
+            (process.env.INPUT_ISSUE ? Number(process.env.INPUT_ISSUE) : 0) ||
+            0;
 
           const labelName =
             ev?.label?.name ||
-            ev?.label ||
-            "workflow_dispatch";
+            (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;
+          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));
+          }
 
-          function sh(s){ return JSON.stringify(String(s)); }
           process.stdout.write([
             `CLONE_URL=${sh(cloneUrl)}`,
             `OWNER=${sh(owner)}`,
@@ -101,82 +114,230 @@ jobs:
             `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,120p' /tmp/proposer.env
+          echo "Context:"
+          sed -n '1,200p' /tmp/proposer.env
 
-      - name: Gate on label state/approved
+      - name: Early gate (tolerant on empty issue label payload)
         run: |
           set -euo pipefail
           source /tmp/proposer.env
 
-          if [[ "$LABEL_NAME" != "state/approved" && "$LABEL_NAME" != "workflow_dispatch" ]]; then
-            echo "ℹ️ label=$LABEL_NAME => skip"
-            echo "SKIP=1" >> /tmp/proposer.env
-            exit 0
-          fi
-          echo "✅ proceed (issue=$ISSUE_NUMBER)"
+          echo "event=$EVENT_NAME label=${LABEL_NAME:-<empty>}"
 
-      - name: Fetch issue + API-hard gate on (state/approved present + proposer type)
+          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; }
+          [[ "${SKIP:-0}" != "1" ]] || { echo "Skipped"; exit 0; }
 
-          test -n "${FORGE_TOKEN:-}" || { echo "❌ Missing secret FORGE_TOKEN"; exit 1; }
+          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/issues/$ISSUE_NUMBER" \
-            -o /tmp/issue.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 issue = JSON.parse(fs.readFileSync("/tmp/issue.json","utf8"));
-          const title = String(issue.title || "");
-          const body = String(issue.body || "").replace(/\r\n/g, "\n");
-          const labels = Array.isArray(issue.labels) ? issue.labels.map(l => String(l.name||"")).filter(Boolean) : [];
 
-          function pickLine(key) {
-            const re = new RegExp(`^\\s*${key}\\s*:\\s*([^\\n\\r]+)`, "mi");
-            const m = body.match(re);
-            return m ? m[1].trim() : "";
-          }
+          const pulls = JSON.parse(fs.readFileSync("/tmp/open_pulls.json", "utf8"));
+          const issues = String(process.env.TARGET_ISSUES || "")
+            .trim()
+            .split(/\s+/)
+            .filter(Boolean);
 
-          const typeRaw = pickLine("Type");
-          const type = String(typeRaw || "").trim().toLowerCase();
+          const batchBranch = String(process.env.BATCH_BRANCH || "");
+          const batchKey = String(process.env.BATCH_KEY || "");
 
-          const hasApproved = labels.includes("state/approved");
-          const proposer = new Set(["type/correction","type/fact-check"]);
+          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 = [];
-          out.push(`ISSUE_TITLE=${JSON.stringify(title)}`);
-          out.push(`ISSUE_TYPE=${JSON.stringify(type)}`);
-          out.push(`HAS_APPROVED=${hasApproved ? "1":"0"}`);
 
-          if (!hasApproved) {
-            out.push(`SKIP=1`);
-            out.push(`SKIP_REASON=${JSON.stringify("approved_not_present")}`);
-          } else if (!type) {
-            out.push(`SKIP=1`);
-            out.push(`SKIP_REASON=${JSON.stringify("missing_type")}`);
-          } else if (!proposer.has(type)) {
-            out.push(`SKIP=1`);
-            out.push(`SKIP_REASON=${JSON.stringify("not_proposer:"+type)}`);
+          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") + "\n");
+
+          process.stdout.write(out.join("\n") + (out.length ? "\n" : ""));
           NODE
 
-          echo "✅ proposer gating:"
-          grep -E '^(ISSUE_TYPE|HAS_APPROVED|SKIP|SKIP_REASON)=' /tmp/proposer.env || true
+      - name: Guard on remote batch branch before heavy work
+        run: |
+          set -euo pipefail
+          source /tmp/proposer.env
+          [[ "${SKIP:-0}" != "1" ]] || { echo "Skipped"; exit 0; }
 
-      - name: Comment issue if skipped
+          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 }}
@@ -185,122 +346,149 @@ jobs:
           source /tmp/proposer.env || true
 
           [[ "${SKIP:-0}" == "1" ]] || exit 0
-          [[ "$LABEL_NAME" == "state/approved" || "$LABEL_NAME" == "workflow_dispatch" ]] || exit 0
+          [[ "${EVENT_NAME:-}" != "push" ]] || exit 0
 
-          REASON="${SKIP_REASON:-}"
-          TYPE="${ISSUE_TYPE:-}"
-
-          if [[ "$REASON" == "approved_not_present" ]]; then
-            MSG="ℹ️ Proposer Apply: skip — le label **state/approved** n'est pas présent sur le ticket au moment du run (gate API-hard)."
-          elif [[ "$REASON" == "missing_type" ]]; then
-            MSG="ℹ️ Proposer Apply: skip — champ **Type:** manquant/illisible. Attendu: type/correction ou type/fact-check."
-          else
-            MSG="ℹ️ Proposer Apply: skip — Type non-Proposer (${TYPE}). (Ce workflow ne traite que correction/fact-check.)"
+          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
 
-          PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
+          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_NUMBER/comments" \
-            --data-binary "$PAYLOAD" || true
+            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_TO_COMMENT/comments" \
+            --data-binary @/tmp/proposer.skip.comment.json || true
 
-      - name: Checkout default branch
-        run: |
-          set -euo pipefail
-          source /tmp/proposer.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
-
-          rm -rf .git
-          git init -q
-          git remote add origin "$CLONE_URL"
-          git fetch --depth 1 origin "$DEFAULT_BRANCH"
-          git -c advice.detachedHead=false checkout -q FETCH_HEAD
-          git log -1 --oneline
-          echo "✅ workspace:"
-          ls -la | sed -n '1,120p'
-
-      - name: Detect app dir (repo-root vs ./site)
-        run: |
-          set -euo pipefail
-          source /tmp/proposer.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
-
-          APP_DIR="."
-          if [[ -d "site" && -f "site/package.json" ]]; then
-            APP_DIR="site"
-          fi
-
-          echo "APP_DIR=$APP_DIR" >> /tmp/proposer.env
-          echo "✅ APP_DIR=$APP_DIR"
-          ls -la "$APP_DIR" | sed -n '1,120p'
-          test -f "$APP_DIR/package.json" || { echo "❌ package.json missing in APP_DIR=$APP_DIR"; exit 1; }
-          test -d "$APP_DIR/scripts" || { echo "❌ scripts/ missing in APP_DIR=$APP_DIR"; exit 1; }
-
-      - name: NPM harden (reduce flakiness)
+      - 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 (APP_DIR)
+      - name: Install deps
         run: |
           set -euo pipefail
           source /tmp/proposer.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
           cd "$APP_DIR"
           npm ci --no-audit --no-fund
 
-      - name: Build dist baseline (APP_DIR)
+      - name: Build dist baseline
         run: |
           set -euo pipefail
           source /tmp/proposer.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || exit 0
+
           cd "$APP_DIR"
           npm run build
 
-      - name: Apply ticket (alias + commit) on bot branch
+      - 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 }}
-          FORGE_API: ${{ vars.FORGE_API || vars.FORGE_BASE }}
         run: |
           set -euo pipefail
           source /tmp/proposer.env
-          [[ "${SKIP:-0}" != "1" ]] || { echo "ℹ️ skipped"; exit 0; }
+          [[ "${SKIP:-0}" != "1" ]] || { echo "Skipped"; exit 0; }
 
-          git config user.name  "${BOT_GIT_NAME:-archicratie-bot}"
+          git config user.name "${BOT_GIT_NAME:-archicratie-bot}"
           git config user.email "${BOT_GIT_EMAIL:-bot@archicratie.local}"
 
           START_SHA="$(git rev-parse HEAD)"
-          TS="$(date -u +%Y%m%d-%H%M%S)"
-          BR="bot/proposer-${ISSUE_NUMBER}-${TS}"
+          BR="$BATCH_BRANCH"
           echo "BRANCH=$BR" >> /tmp/proposer.env
           git checkout -b "$BR"
 
           export GITEA_OWNER="$OWNER"
           export GITEA_REPO="$REPO"
-          export FORGE_BASE="$API_BASE"
+          export FORGE_API="$API_BASE"
 
           LOG="/tmp/proposer-apply.log"
-          set +e
-          (cd "$APP_DIR" && node scripts/apply-ticket.mjs "$ISSUE_NUMBER" --alias --commit) >"$LOG" 2>&1
-          RC=$?
-          set -e
+          : > "$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 200 "$LOG" || true
+          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
@@ -313,7 +501,34 @@ jobs:
             echo "END_SHA=$END_SHA" >> /tmp/proposer.env
           fi
 
-      - name: Push bot branch
+      - 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 }}
@@ -322,9 +537,86 @@ jobs:
           source /tmp/proposer.env || true
           [[ "${SKIP:-0}" != "1" ]] || exit 0
 
-          [[ "${APPLY_RC:-0}" == "0" ]] || { echo "ℹ️ apply failed -> skip push"; exit 0; }
-          [[ "${NOOP:-0}" == "0" ]] || { echo "ℹ️ no-op -> skip push"; exit 0; }
-          [[ -n "${BRANCH:-}" ]] || { echo "ℹ️ BRANCH unset -> skip push"; exit 0; }
+          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);
@@ -337,7 +629,7 @@ jobs:
           git remote set-url origin "$AUTH_URL"
           git push -u origin "$BRANCH"
 
-      - name: Create PR + comment issue
+      - name: Create PR + comment issues + close issues
         if: ${{ always() }}
         env:
           FORGE_TOKEN: ${{ secrets.FORGE_TOKEN }}
@@ -345,51 +637,152 @@ jobs:
           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; }
+          [[ -n "${BRANCH:-}" ]] || { echo "BRANCH unset -> skip PR"; exit 0; }
 
-          PR_TITLE="proposer: apply ticket #${ISSUE_NUMBER}"
-          PR_BODY="PR auto depuis ticket #${ISSUE_NUMBER} (state/approved).\n\n- Branche: ${BRANCH}\n- Commit: ${END_SHA:-unknown}\n\nMerge si CI OK."
+          test -n "${FORGE_TOKEN:-}" || { echo "Missing FORGE_TOKEN"; exit 1; }
 
-          PR_PAYLOAD="$(node --input-type=module -e '
-            const [title, body, base, head] = process.argv.slice(1);
-            console.log(JSON.stringify({ title, body, base, head, allow_maintainer_edit: true }));
-          ' "$PR_TITLE" "$PR_BODY" "$DEFAULT_BRANCH" "${OWNER}:${BRANCH}")"
+          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 "$PR_PAYLOAD")"
+            --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")"
+          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; }
+          test -n "$PR_URL" || {
+            echo "PR URL missing. Raw: $PR_JSON"
+            exit 1
+          }
 
-          MSG="✅ PR Proposer créée pour ticket #${ISSUE_NUMBER} : ${PR_URL}"
-          C_PAYLOAD="$(node --input-type=module -e 'console.log(JSON.stringify({body: process.argv[1]||""}))' "$MSG")"
+          for ISSUE in $TARGET_ISSUES; do
+            export ISSUE PR_URL
 
-          curl -fsS -X POST \
-            -H "Authorization: token $FORGE_TOKEN" \
-            -H "Content-Type: application/json" \
-            "$API_BASE/api/v1/repos/$OWNER/$REPO/issues/$ISSUE_NUMBER/comments" \
-            --data-binary "$C_PAYLOAD"
+            node --input-type=module -e '
+              import fs from "node:fs";
 
-      - name: Finalize (fail job if apply failed)
+              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
 
-          RC="${APPLY_RC:-0}"
-          if [[ "$RC" != "0" ]]; then
-            echo "❌ apply failed (rc=$RC)"
-            exit "$RC"
+          if [[ "${APPLY_RC:-0}" != "0" ]]; then
+            echo "Apply failed (rc=${APPLY_RC})"
+            exit "${APPLY_RC}"
           fi
-          echo "✅ apply ok"
+
+          if [[ "${REBASE_RC:-0}" != "0" ]]; then
+            echo "Rebase failed (rc=${REBASE_RC})"
+            exit "${REBASE_RC}"
+          fi
+
+          echo "Proposer queue 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,14 @@
+{
+  "accepted_resets": {
+    "archicrat-ia/prologue/index.html": "Reset intentionnel des ancres après réimport DOCX et révision substantielle du prologue depuis la source officielle. Site neuf, sans annotations ni compatibilité descendante à préserver.",
+    "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.",
+    "archicrat-ia/chapitre-5/index.html": "Reset intentionnel des ancres après réimport DOCX et stabilisation doctrinale substantielle du chapitre 5 depuis la source officielle. Site neuf, sans annotations ni compatibilité descendante à préserver.",
+    "archicrat-ia/conclusion/index.html": "Reset intentionnel des ancres après réimport DOCX et révision substantielle de la conclusion depuis la source officielle. Site neuf, sans annotations ni compatibilité descendante à préserver."
+  },
+  "accepted_prefixes": {
+    "glossaire/": "Reset intentionnel des ancres après révision substantielle des fiches paradigmes et doctrines du glossaire. Site neuf, sans annotations ni compatibilité descendante à préserver."
+  }
+}

docs/GLOSSARY-GRAPH-GOVERNANCE.md

@@ -0,0 +1,152 @@
+# Gouvernance du graphe du glossaire
+
+## Lois actuelles vérifiées automatiquement
+
+- Aucune fiche sans navigation.
+- Aucun `primaryNext` mort.
+- Aucun cycle direct.
+- Aucun `primaryNext` vers soi-même.
+- Aucune famille sans defaults.
+- Aucun hub `primaryNext` au-dessus du seuil 5.
+- Les paths effectifs tiennent compte des defaults famille.
+
+## Liens `primaryNext` à surveiller qualitativement
+
+- `contractualisme-hobbesien → droit-naturel-et-propriete`
+- `exception-souveraine → droit-naturel-et-propriete`
+- `regime-de-co-viabilite → gouvernance-des-communs`
+- `memoire-symbolique-et-instantaneite-computationnelle → meta-regime`
+- `scene-darchicration → co-viabilite`
+
+## Critère de décision
+
+Un `primaryNext` est bon s’il produit au moins l’un des effets suivants :
+
+- déplier la notion ;
+- changer de niveau ;
+- rendre opératoire ;
+- mettre en tension ;
+- concrétiser.
+
+Un `primaryNext` est faible s’il est seulement voisin, décoratif ou encyclopédique.
+
+---
+
+## Dynamique réelle du graphe (niveau avancé)
+
+### 1. Attracteurs
+
+L’audit de convergence effective met en évidence des nœuds fortement attractifs :
+
+* dispositifs méthodologiques (audit, cartographie)
+* concepts fondamentaux (co-viabilité, tension, archicration)
+
+Ces nœuds structurent la circulation globale du glossaire.
+
+---
+
+### 2. Bassins de convergence
+
+Le graphe ne se distribue pas uniformément.
+
+Il tend à s’organiser en bassins :
+
+* bassin conceptuel central
+* bassin méthodologique
+* bassins secondaires (paradigmes, pathologies)
+
+Un bassin est défini comme un ensemble de parcours convergeant vers un même noyau.
+
+---
+
+### 3. Risque de surconvergence
+
+Lorsque trop de parcours convergent vers les mêmes nœuds :
+
+* les parcours deviennent redondants
+* la navigation perd en différenciation
+* l’expérience de lecture devient monotone
+
+Ce phénomène ne constitue pas une erreur technique, mais un déséquilibre structurel.
+
+---
+
+### 4. Bifurcation effective
+
+Les nœuds à forte bifurcation jouent un rôle clé :
+
+* ils ouvrent des trajectoires multiples
+* ils structurent la diversité des parcours
+
+Ils doivent être préservés comme points d’expansion.
+
+---
+
+### 5. Principe de régulation avancée
+
+L’objectif n’est pas de supprimer les attracteurs, mais de :
+
+* limiter leur domination excessive
+* maintenir plusieurs bassins actifs
+* garantir des trajectoires réellement distinctes
+
+---
+
+### 6. Règle pratique
+
+Avant toute modification :
+
+* vérifier l’impact sur les convergences effectives
+* éviter d’ajouter un lien vers un nœud déjà dominant
+* privilégier l’ouverture de nouvelles zones de circulation
+
+---
+
+### 7. Nature du système
+
+Le glossaire ne doit pas être compris comme :
+
+* un index
+* ni un arbre
+
+mais comme :
+
+→ un graphe dynamique de circulation conceptuelle
+
+dont la structure influence directement la pensée du lecteur.
+
+
+
+# la première désaturation a déplacé les attracteurs vers scene-depreuve, journal-de-justification, regime-de-co-viabilite
+
+## Attracteurs structurels du graphe
+
+Certains nœuds présentent une forte convergence effective. Cela ne constitue pas un défaut, mais une propriété structurelle du modèle.
+
+### Attracteurs assumés
+
+- scene-depreuve (scène)  
+  → cœur opératoire de mise à l’épreuve des régulations  
+  → point de passage légitime pour une grande partie des parcours
+
+- audit-archicratique (dispositif méthodologique)  
+  → point d’entrée opératoire vers l’analyse des régulations
+
+- cartographie-des-scenes-manquantes (dispositif méthodologique)  
+  → prolongement naturel de l’audit vers l’identification des lacunes
+
+- co-viabilite (concept fondamental)  
+  → horizon de stabilisation des tensions
+
+### Principe
+
+Un attracteur est acceptable si :
+
+- il correspond à un changement de niveau (concept → scène → dispositif)
+- il rend opératoire une notion
+- il constitue un passage obligé théoriquement justifié
+
+Un attracteur devient problématique s’il :
+
+- absorbe sans transformation
+- remplace une articulation par une répétition

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/graph.dot

@@ -0,0 +1,100 @@
+digraph G {
+  rankdir="LR";
+  node [shape=box, style="rounded"];
+  "agencement-machinique" -> "cratialite";
+  "arcalite" -> "cratialite";
+  "archeogenese" -> "meta-regime-archicratique";
+  "archicratie" -> "arcalite";
+  "archicration-obliteree" -> "hypercratialite";
+  "archicration" -> "scene-depreuve";
+  "archicrations-differentielles-et-formes-hybrides" -> "co-viabilisation";
+  "archicrations-epistemiques" -> "archicrations-differentielles-et-formes-hybrides";
+  "archicrations-esthetico-symboliques" -> "archicrations-historiographiques";
+  "archicrations-guerrieres" -> "archicrations-normativo-politiques";
+  "archicrations-historiographiques" -> "archicrations-epistemiques";
+  "archicrations-marchandes" -> "archicrations-techno-logistiques";
+  "archicrations-normativo-politiques" -> "archicrations-marchandes";
+  "archicrations-proto-symboliques" -> "archicrations-sacrales-non-etatiques";
+  "archicrations-sacrales-non-etatiques" -> "archicrations-scripturo-cosmologiques";
+  "archicrations-scripturo-cosmologiques" -> "archicrations-scripturo-normatives";
+  "archicrations-scripturo-normatives" -> "archicrations-normativo-politiques";
+  "archicrations-techno-logistiques" -> "archicrations-differentielles-et-formes-hybrides";
+  "archicrations-theologiques" -> "archicrations-normativo-politiques";
+  "archicratisation" -> "co-viabilisation";
+  "archidiagnostic" -> "cartographie-des-scenes-manquantes";
+  "audit-archicratique" -> "cartographie-des-scenes-manquantes";
+  "autarchicratie" -> "autarchicration";
+  "autarchicration" -> "obliteration-archicratique";
+  "biopolitique" -> "gouvernementalite-algorithmique";
+  "budget-scenique" -> "visa-daffectation";
+  "cartographie-des-scenes-manquantes" -> "scene-manquante";
+  "co-viabilisation" -> "regime-de-co-viabilite";
+  "co-viabilite" -> "tension";
+  "coexistence-ontologique-et-necessite-regulatrice" -> "formes-de-vie-et-cadres-dhabitabilite";
+  "conatus-et-multitude" -> "configuration-et-interdependance";
+  "configuration-et-interdependance" -> "transduction-et-individuation";
+  "contractualisme-hobbesien" -> "droit-naturel-et-propriete";
+  "cosmopolitique" -> "technodiversite-et-cosmotechnie";
+  "coupe-circuit-citoyen" -> "droit-au-differe-contradictoire";
+  "cratialite" -> "archicration";
+  "cybernetique" -> "gouvernementalite-algorithmique";
+  "decisionnisme-souverain" -> "exception-souveraine";
+  "democratie-deliberative" -> "dissensus-politique";
+  "desarchicration" -> "desarchicratisation";
+  "desarchicratisation" -> "autarchicratie";
+  "dissensus-politique" -> "lieu-vide-du-pouvoir";
+  "domination-legale-rationnelle" -> "democratie-deliberative";
+  "droit-au-differe-contradictoire" -> "tribunal-de-lalgorithme";
+  "droit-naturel-et-propriete" -> "volonte-generale";
+  "egalisation-normative-et-differenciation-singuliere" -> "dissensus-politique";
+  "exception-souveraine" -> "droit-naturel-et-propriete";
+  "fait-social-total" -> "configuration-et-interdependance";
+  "formes-de-vie-et-cadres-dhabitabilite" -> "subsistance-vivante-et-captation-capitalistique";
+  "gouvernance-des-communs" -> "co-viabilite";
+  "gouvernementalite-algorithmique" -> "preemption-algorithmique";
+  "gouvernementalite" -> "biopolitique";
+  "grammatisation-et-proletarisation-cognitive" -> "pharmacologie-technique";
+  "habitus-et-violence-symbolique" -> "obliteration-archicratique";
+  "hyperarcalite" -> "desarchicration";
+  "hypercratialite" -> "hyperarcalite";
+  "inertie-sociale-symbolique" -> "habitus-et-violence-symbolique";
+  "institution-invisible" -> "scene-depreuve";
+  "journal-de-justification" -> "droit-au-differe-contradictoire";
+  "liberte-daction-et-regimes-de-securite-algorithmique" -> "preemption-algorithmique";
+  "lieu-vide-du-pouvoir" -> "visibilite-mediatique-et-reconnaissance-symbolique";
+  "memoire-symbolique-et-instantaneite-computationnelle" -> "meta-regime";
+  "meta-regime-archicratique" -> "archicrations-differentielles-et-formes-hybrides";
+  "meta-regime" -> "meta-regime-archicratique";
+  "monde-instituable" -> "scene-manquante";
+  "obliteration-archicratique" -> "archicration-obliteree";
+  "pensee-complexe" -> "configuration-et-interdependance";
+  "pharmacologie-technique" -> "technodiversite-et-cosmotechnie";
+  "pluralite-natalite-action" -> "dissensus-politique";
+  "preemption-algorithmique" -> "droit-au-differe-contradictoire";
+  "regime-de-co-viabilite" -> "gouvernance-des-communs";
+  "regulation-morphogenetique-des-interdependances" -> "transduction-et-individuation";
+  "regulation-technique-et-legitimation-democratique" -> "tribunal-de-lalgorithme";
+  "regulations-fondatrices" -> "regulations-incorporees";
+  "regulations-incorporees" -> "regulations-procedurales";
+  "regulations-procedurales" -> "regulations-techniques";
+  "regulations-relationnelles" -> "regime-de-co-viabilite";
+  "regulations-techniques" -> "regulations-relationnelles";
+  "resonance-sociale" -> "visibilite-mediatique-et-reconnaissance-symbolique";
+  "scene-darchicration" -> "co-viabilite";
+  "scene-depreuve" -> "scene-darchicration";
+  "scene-empechee" -> "institution-invisible";
+  "scene-manquante" -> "scene-empechee";
+  "souverainetes-territoriales-et-interdependances-globales" -> "gouvernance-des-communs";
+  "subsistance-vivante-et-captation-capitalistique" -> "travail-vivant-et-abstraction-de-la-valeur";
+  "technodiversite-et-cosmotechnie" -> "regime-de-co-viabilite";
+  "tension" -> "regime-de-co-viabilite";
+  "theorie-de-la-justification" -> "journal-de-justification";
+  "theorie-de-la-resonance" -> "resonance-sociale";
+  "theorie-de-lacteur-reseau" -> "agencement-machinique";
+  "transduction-et-individuation" -> "archeogenese";
+  "travail-vivant-et-abstraction-de-la-valeur" -> "grammatisation-et-proletarisation-cognitive";
+  "tribunal-de-lalgorithme" -> "budget-scenique";
+  "visa-daffectation" -> "scene-depreuve";
+  "visibilite-mediatique-et-reconnaissance-symbolique" -> "cartographie-des-scenes-manquantes";
+  "volonte-generale" -> "democratie-deliberative";
+}

docs/runbooks/DEPLOY-BLUE-GREEN.md

@@ -320,4 +320,227 @@ But : prouver que staging+live servent bien les endpoints essentiels (et que le
 
 ```bash
 curl -fsSI http://127.0.0.1:8081/ | head -n 1
-curl -fsSI http://127.0.0.1:8082/ | 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,10 +10,12 @@
     "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",
+    "audit:glossary": "node scripts/audit-glossary-navigation.mjs",
     "build:para-index": "node scripts/build-para-index.mjs",
     "build:annotations-index": "node scripts/build-annotations-index.mjs",
     "test:aliases": "node scripts/check-anchor-aliases.mjs",
@@ -25,11 +27,11 @@
     "ci": "CI=1 npm test"
   },
   "dependencies": {
-    "@astrojs/mdx": "^4.3.13",
-    "astro": "^5.18.0"
+    "@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",

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/audit-glossary-navigation.mjs

@@ -0,0 +1,232 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+
+const ROOT = "src/content/glossaire";
+const DEFAULTS_FILE = "src/lib/glossary-navigation-defaults.ts";
+const HUB_LIMIT = 5;
+const EFFECTIVE_TOP_LIMIT = 10;
+const PATH_KEYS = ["understand", "deepen", "compare", "apply"];
+
+const defaultsRaw = fs.readFileSync(DEFAULTS_FILE, "utf-8");
+
+const defaultFamilies = new Set(
+  [...defaultsRaw.matchAll(/^\s{4}"?([a-z0-9-]+)"?\s*:/gm)].map((m) => m[1]),
+);
+
+const defaultPathKeysByFamily = new Map();
+const defaultTargetsByFamily = new Map();
+
+for (const match of defaultsRaw.matchAll(
+  /^\s{4}"?([a-z0-9-]+)"?\s*:\s*\{([\s\S]*?)^\s{4}\},/gm,
+)) {
+  const family = match[1];
+  const body = match[2];
+  const keys = new Set();
+  const targetsByKey = new Map();
+
+  for (const key of PATH_KEYS) {
+    const pathMatch = body.match(new RegExp(`\\b${key}\\s*:\\s*\\[([^\\]]*)\\]`));
+    const targets = pathMatch
+      ? pathMatch[1]
+          .split(",")
+          .map((x) => x.trim().replace(/^["']|["']$/g, ""))
+          .filter(Boolean)
+      : [];
+
+    if (targets.length > 0) keys.add(key);
+    targetsByKey.set(key, targets);
+  }
+
+  defaultPathKeysByFamily.set(family, keys);
+  defaultTargetsByFamily.set(family, targetsByKey);
+}
+
+const files = fs.readdirSync(ROOT).filter((f) => f.endsWith(".md"));
+const slugs = new Set(files.map((f) => f.replace(".md", "")));
+
+const entries = [];
+
+for (const file of files) {
+  const full = path.join(ROOT, file);
+  const raw = fs.readFileSync(full, "utf-8");
+  const slug = file.replace(".md", "");
+
+  if (!raw.startsWith("---")) {
+    entries.push({ slug, data: {}, noFrontmatter: true });
+    continue;
+  }
+
+  const frontmatter = raw.split("---", 3)[1];
+  const data = yaml.load(frontmatter) || {};
+  entries.push({ slug, data, noFrontmatter: false });
+}
+
+const missingNavigation = [];
+const missingReason = [];
+const weakPaths = [];
+const selfLoops = [];
+const deadPrimaryNext = [];
+const directCycles = [];
+const edges = {};
+const incoming = {};
+const families = new Set();
+
+const effectiveOutgoing = new Map();
+const effectiveIncoming = new Map();
+
+function addEffectiveEdge(from, to) {
+  if (!from || !to || from === to || !slugs.has(to)) return;
+
+  if (!effectiveOutgoing.has(from)) effectiveOutgoing.set(from, new Set());
+  if (!effectiveIncoming.has(to)) effectiveIncoming.set(to, new Set());
+
+  effectiveOutgoing.get(from).add(to);
+  effectiveIncoming.get(to).add(from);
+}
+
+for (const { slug, data, noFrontmatter } of entries) {
+  if (noFrontmatter) continue;
+
+  if (data.family) families.add(data.family);
+
+  const nav = data.navigation;
+
+  if (!nav) {
+    missingNavigation.push(slug);
+    continue;
+  }
+
+  const next = nav.primaryNext;
+
+  if (next) {
+    edges[slug] = next;
+    incoming[next] = (incoming[next] || 0) + 1;
+    addEffectiveEdge(slug, next);
+
+    if (next === slug) selfLoops.push(slug);
+    if (!slugs.has(next)) deadPrimaryNext.push(`${slug} → ${next}`);
+
+    if (!nav.primaryReason) missingReason.push(slug);
+  }
+
+  const explicitPaths = nav.paths || {};
+  const familyDefaults = defaultPathKeysByFamily.get(data.family) || new Set();
+  const familyDefaultTargets = defaultTargetsByFamily.get(data.family) || new Map();
+
+  const pathCount = PATH_KEYS.filter((key) => {
+    const explicit = Array.isArray(explicitPaths[key]) && explicitPaths[key].length > 0;
+    const fromDefault = familyDefaults.has(key);
+    return explicit || fromDefault;
+  }).length;
+
+  if (pathCount < 2) weakPaths.push(slug);
+
+  for (const key of PATH_KEYS) {
+    const explicitTargets = Array.isArray(explicitPaths[key]) ? explicitPaths[key] : [];
+    const defaultTargets = familyDefaultTargets.get(key) || [];
+
+    for (const target of [...explicitTargets, ...defaultTargets]) {
+      addEffectiveEdge(slug, target);
+    }
+  }
+}
+
+const seenPairs = new Set();
+
+for (const [a, b] of Object.entries(edges)) {
+  if (edges[b] === a) {
+    const pair = [a, b].sort().join(" <-> ");
+    if (!seenPairs.has(pair)) {
+      seenPairs.add(pair);
+      directCycles.push(`${a} <-> ${b}`);
+    }
+  }
+}
+
+const missingDefaults = [...families].filter((f) => !defaultFamilies.has(f));
+
+const bigHubs = Object.entries(incoming)
+  .filter(([, count]) => count > HUB_LIMIT)
+  .sort((a, b) => b[1] - a[1]);
+
+console.log("\n🔍 Glossary navigation audit");
+
+if (missingNavigation.length > 0) {
+  console.log("\n❌ Missing navigation:");
+  missingNavigation.forEach((s) => console.log(" -", s));
+}
+
+console.log("\n🔍 Direct cycles:");
+if (directCycles.length) directCycles.forEach((c) => console.log(" -", c));
+else console.log(" (none)");
+
+console.log("\n📊 Top hubs:");
+Object.entries(incoming)
+  .sort((a, b) => b[1] - a[1])
+  .slice(0, 10)
+  .forEach(([slug, n]) => {
+    if (n > HUB_LIMIT) console.log(`⚠️ ${slug}: ${n}`);
+    else console.log(`  ${slug}: ${n}`);
+  });
+
+console.log("\n🔗 Checking dead primaryNext:");
+if (deadPrimaryNext.length) deadPrimaryNext.forEach((x) => console.log("❌", x));
+else console.log(" (none)");
+
+if (missingDefaults.length) {
+  console.log("\n❌ Families without defaults:");
+  missingDefaults.forEach((f) => console.log(" -", f));
+}
+
+if (bigHubs.length) {
+  console.log(`\n⚠️ Hubs above limit (${HUB_LIMIT}):`);
+  bigHubs.forEach(([slug, n]) => console.log(` - ${slug}: ${n}`));
+}
+
+if (missingReason.length) {
+  console.log("\n⚠️ Missing primaryReason:");
+  missingReason.forEach((s) => console.log(" -", s));
+}
+
+if (weakPaths.length) {
+  console.log("\n⚠️ Weak path coverage (<2):");
+  weakPaths.forEach((s) => console.log(" -", s));
+}
+
+if (selfLoops.length) {
+  console.log("\n❌ Self-referencing primaryNext:");
+  selfLoops.forEach((s) => console.log(" -", s));
+}
+
+console.log(`\n📊 Effective convergence top ${EFFECTIVE_TOP_LIMIT}:`);
+[...effectiveIncoming.entries()]
+  .map(([slug, sources]) => [slug, sources.size])
+  .sort((a, b) => b[1] - a[1])
+  .slice(0, EFFECTIVE_TOP_LIMIT)
+  .forEach(([slug, n]) => {
+    console.log(`  ${n} ${slug}`);
+  });
+
+console.log(`\n📊 Effective branching top ${EFFECTIVE_TOP_LIMIT}:`);
+[...effectiveOutgoing.entries()]
+  .map(([slug, targets]) => [slug, targets.size])
+  .sort((a, b) => b[1] - a[1])
+  .slice(0, EFFECTIVE_TOP_LIMIT)
+  .forEach(([slug, n]) => {
+    console.log(`  ${n} ${slug}`);
+  });
+
+const hardFailures =
+  missingNavigation.length +
+  directCycles.length +
+  deadPrimaryNext.length +
+  missingDefaults.length +
+  selfLoops.length;
+
+if (hardFailures > 0) {
+  console.log(`\n❌ Audit failed: ${hardFailures} hard issue(s)`);
+  process.exitCode = 1;
+} else {
+  console.log("\n✅ Audit done");
+}

scripts/check-anchors.mjs

@@ -14,6 +14,9 @@ const DIST_DIR = getArg("--dist", "dist");
 const BASELINE = getArg("--baseline", path.join("tests", "anchors-baseline.json"));
 const UPDATE = args.has("--update");
 
+const ACCEPT_GLOSSARY_RESETS =
+  process.env.ACCEPT_GLOSSARY_ANCHOR_RESETS === "1";
+
 // Ex: 0.2 => 20%
 const THRESHOLD = Number(getArg("--threshold", process.env.ANCHORS_THRESHOLD ?? "0.2"));
 const MIN_PREV = Number(getArg("--min-prev", process.env.ANCHORS_MIN_PREV ?? "10"));
@@ -74,7 +77,42 @@ function loadAllowMissing() {
   return new Set(arr.map(String));
 }
 
+function loadAnchorChurnAllowlist() {
+  const p = path.resolve("config/anchor-churn-allowlist.json");
+  if (!fssync.existsSync(p)) return { acceptedResets: {}, acceptedPrefixes: {} };
+  const raw = fssync.readFileSync(p, "utf8").trim();
+  if (!raw) return { acceptedResets: {}, acceptedPrefixes: {} };
+  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 acceptedResets = data.accepted_resets || {};
+  if (!acceptedResets || typeof acceptedResets !== "object" || Array.isArray(acceptedResets)) {
+    throw new Error("anchor-churn-allowlist.json: accepted_resets must be an object");
+  }
+
+  const acceptedPrefixes = data.accepted_prefixes || {};
+  if (!acceptedPrefixes || typeof acceptedPrefixes !== "object" || Array.isArray(acceptedPrefixes)) {
+    throw new Error("anchor-churn-allowlist.json: accepted_prefixes must be an object");
+  }
+
+  return { acceptedResets, acceptedPrefixes };
+}
+
+function acceptedResetReasonForPage(page) {
+  if (ACCEPTED_RESETS[page]) return ACCEPTED_RESETS[page];
+
+  for (const [prefix, reason] of Object.entries(ACCEPTED_PREFIXES)) {
+    if (page.startsWith(prefix)) return reason;
+  }
+
+  return null;
+}
+
 const ALLOW_MISSING = loadAllowMissing();
+const { acceptedResets: ACCEPTED_RESETS, acceptedPrefixes: ACCEPTED_PREFIXES } =
+  loadAnchorChurnAllowlist();
 
 async function buildSnapshot() {
   const absDist = path.resolve(DIST_DIR);
@@ -139,6 +177,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 +211,7 @@ function diffPage(prevIds, curIds) {
     const prevN = prevIds.length || 1;
     const churn = (added.length + removed.length) / prevN;
     const removedRatio = removed.length / prevN;
+    const acceptedReason = acceptedResetReasonForPage(p);
 
     console.log(
       `~ ${p} prev=${prevIds.length} now=${curIds.length}` +
@@ -182,11 +222,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/convert_docx_to_mdx.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("Erreur : PyYAML n'est pas installé. Lance : pip3 install pyyaml")
+    sys.exit(1)
+
+
+EDITION = "archicrat-ia"
+STATUS = "essai_these"
+VERSION = "0.1.0"
+
+
+ORDER_MAP = {
+    "prologue": 10,
+    "chapitre-1": 20,
+    "chapitre-2": 30,
+    "chapitre-3": 40,
+    "chapitre-4": 50,
+    "chapitre-5": 60,
+    "conclusion": 70,
+}
+
+
+TITLE_MAP = {
+    "prologue": "Prologue — Fondation, finalité sociopolitique et historique",
+    "chapitre-1": "Chapitre 1 — Fondements épistémologiques et modélisation",
+    "chapitre-2": "Chapitre 2 — Archéogenèse des régimes de co-viabilité",
+    "chapitre-3": "Chapitre 3 — Philosophies du pouvoir et archicration",
+    "chapitre-4": "Chapitre 4 — Histoire archicratique des révolutions industrielles",
+    "chapitre-5": "Chapitre 5 — Tensions, co-viabilités et régulations",
+    "conclusion": "Conclusion — ArchiCraT-IA",
+}
+
+
+def slugify_name(path: Path) -> str:
+    stem = path.stem.lower().strip()
+
+    replacements = {
+        " ": "-",
+        "_": "-",
+        "—": "-",
+        "–": "-",
+        "é": "e",
+        "è": "e",
+        "ê": "e",
+        "ë": "e",
+        "à": "a",
+        "â": "a",
+        "ä": "a",
+        "î": "i",
+        "ï": "i",
+        "ô": "o",
+        "ö": "o",
+        "ù": "u",
+        "û": "u",
+        "ü": "u",
+        "ç": "c",
+        "'": "",
+        "’": "",
+    }
+
+    for old, new in replacements.items():
+        stem = stem.replace(old, new)
+
+    stem = re.sub(r"-+", "-", stem).strip("-")
+
+    # normalisations spécifiques
+    stem = stem.replace("chapitre-1-fondements-epistemologiques-et-modelisation-archicratie-version-officielle-revise", "chapitre-1")
+    stem = stem.replace("chapitre-2", "chapitre-2")
+    stem = stem.replace("chapitre-3", "chapitre-3")
+    stem = stem.replace("chapitre-4", "chapitre-4")
+    stem = stem.replace("chapitre-5", "chapitre-5")
+
+    if "prologue" in stem:
+        return "prologue"
+    if "chapitre-1" in stem:
+        return "chapitre-1"
+    if "chapitre-2" in stem:
+        return "chapitre-2"
+    if "chapitre-3" in stem:
+        return "chapitre-3"
+    if "chapitre-4" in stem:
+        return "chapitre-4"
+    if "chapitre-5" in stem:
+        return "chapitre-5"
+    if "conclusion" in stem:
+        return "conclusion"
+
+    return stem
+
+
+def extract_title_from_markdown(md_text: str) -> str | None:
+    for line in md_text.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if line.startswith("# "):
+            return line[2:].strip()
+    return None
+
+
+def remove_first_h1(md_text: str) -> str:
+    lines = md_text.splitlines()
+    out = []
+    removed = False
+
+    for line in lines:
+        if not removed and line.strip().startswith("# "):
+            removed = True
+            continue
+        out.append(line)
+
+    text = "\n".join(out).lstrip()
+    return text
+
+
+def clean_markdown(md_text: str) -> str:
+    text = md_text.replace("\r\n", "\n").replace("\r", "\n")
+
+    # nettoyer espaces multiples
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    # supprimer éventuels signets/artefacts de liens internes Pandoc
+    text = re.sub(r"\[\]\(#.*?\)", "", text)
+
+    # convertir astérismes parasites
+    text = re.sub(r"[ \t]+$", "", text, flags=re.MULTILINE)
+
+    return text.strip() + "\n"
+
+
+def compute_level(slug: str) -> int:
+    if slug == "prologue":
+        return 1
+    if slug.startswith("chapitre-"):
+        return 1
+    if slug == "conclusion":
+        return 1
+    return 1
+
+
+def convert_one_file(input_docx: Path, output_dir: Path, source_root: Path):
+    slug = slugify_name(input_docx)
+    output_mdx = output_dir / f"{slug}.mdx"
+
+    cmd = [
+        "pandoc",
+        str(input_docx),
+        "-f",
+        "docx",
+        "-t",
+        "gfm+smart",
+    ]
+
+    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    md_text = result.stdout
+
+    detected_title = extract_title_from_markdown(md_text)
+    md_body = remove_first_h1(md_text)
+    md_body = clean_markdown(md_body)
+
+    title = TITLE_MAP.get(slug) or detected_title or input_docx.stem
+    order = ORDER_MAP.get(slug, 999)
+    level = compute_level(slug)
+
+    relative_source = input_docx
+    try:
+        relative_source = input_docx.relative_to(source_root)
+    except ValueError:
+        relative_source = input_docx.name
+
+    frontmatter = {
+        "title": title,
+        "edition": EDITION,
+        "status": STATUS,
+        "level": level,
+        "version": VERSION,
+        "concepts": [],
+        "links": [],
+        "order": order,
+        "summary": "",
+        "source": {
+            "kind": "docx",
+            "path": str(relative_source),
+        },
+    }
+
+    yaml_block = yaml.safe_dump(
+        frontmatter,
+        allow_unicode=True,
+        sort_keys=False,
+        default_flow_style=False,
+    ).strip()
+
+    final_text = f"---\n{yaml_block}\n---\n{md_body if md_body.startswith(chr(10)) else chr(10) + md_body}"
+    output_mdx.write_text(final_text, encoding="utf-8")
+    print(f"✅ {input_docx.name} -> {output_mdx.name}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convertit un dossier DOCX en MDX avec frontmatter.")
+    parser.add_argument("input_dir", help="Dossier source contenant les DOCX")
+    parser.add_argument("output_dir", help="Dossier de sortie pour les MDX")
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir).expanduser().resolve()
+    output_dir = Path(args.output_dir).expanduser().resolve()
+
+    if not shutil.which("pandoc"):
+        print("Erreur : pandoc n'est pas installé. Lance : brew install pandoc")
+        sys.exit(1)
+
+    if not input_dir.exists() or not input_dir.is_dir():
+        print(f"Erreur : dossier source introuvable : {input_dir}")
+        sys.exit(1)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    docx_files = sorted(input_dir.glob("*.docx"))
+    if not docx_files:
+        print(f"Aucun DOCX trouvé dans : {input_dir}")
+        sys.exit(1)
+
+    for docx_file in docx_files:
+        convert_one_file(docx_file, output_dir, input_dir)
+
+    print()
+    print("Conversion DOCX -> MDX terminée.")
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_mdx_to_docx.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+import argparse
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+import zipfile
+
+try:
+    import yaml
+except ImportError:
+    print("Erreur : PyYAML n'est pas installé. Lance : pip3 install pyyaml")
+    sys.exit(1)
+
+try:
+    from docx import Document
+except ImportError:
+    print("Erreur : python-docx n'est pas installé. Lance : pip3 install python-docx")
+    sys.exit(1)
+
+
+def split_frontmatter(text: str):
+    if not text.startswith("---\n"):
+        return {}, text
+
+    match = re.match(r"^---\n(.*?)\n---\n(.*)$", text, flags=re.DOTALL)
+    if not match:
+        return {}, text
+
+    yaml_block = match.group(1)
+    body = match.group(2)
+
+    try:
+        metadata = yaml.safe_load(yaml_block) or {}
+    except Exception as e:
+        print(f"Avertissement : frontmatter YAML illisible : {e}")
+        metadata = {}
+
+    return metadata, body
+
+
+def strip_mdx_artifacts(text: str):
+    # imports / exports MDX
+    text = re.sub(r"^\s*(import|export)\s+.+?$", "", text, flags=re.MULTILINE)
+
+    # composants autofermants : <Component />
+    text = re.sub(r"<[A-Z][A-Za-z0-9._-]*\b[^>]*\/>", "", text)
+
+    # composants bloc : <Component ...>...</Component>
+    text = re.sub(
+        r"<([A-Z][A-Za-z0-9._-]*)\b[^>]*>.*?</\1>",
+        "",
+        text,
+        flags=re.DOTALL,
+    )
+
+    # accolades seules résiduelles sur ligne
+    text = re.sub(r"^\s*{\s*}\s*$", "", text, flags=re.MULTILINE)
+
+    # lignes vides multiples
+    text = re.sub(r"\n{3,}", "\n\n", text)
+
+    return text.strip() + "\n"
+
+
+def inject_h1_from_title(metadata: dict, body: str):
+    title = metadata.get("title", "")
+    if not title:
+        return body
+
+    if re.match(r"^\s*#\s+", body):
+        return body
+
+    return f"# {title}\n\n{body.lstrip()}"
+
+
+def find_style_by_candidates(doc, candidates):
+    # Cherche d'abord par nom visible
+    for style in doc.styles:
+        for candidate in candidates:
+            if style.name == candidate:
+                return style
+
+    # Puis par style_id Word interne
+    for style in doc.styles:
+        style_id = getattr(style, "style_id", "")
+        if style_id in {"BodyText", "Heading1", "Heading2", "Heading3", "Heading4"}:
+            for candidate in candidates:
+                if candidate in {"Body Text", "Corps de texte"} and style_id == "BodyText":
+                    return style
+                if candidate in {"Heading 1", "Titre 1"} and style_id == "Heading1":
+                    return style
+                if candidate in {"Heading 2", "Titre 2"} and style_id == "Heading2":
+                    return style
+                if candidate in {"Heading 3", "Titre 3"} and style_id == "Heading3":
+                    return style
+                if candidate in {"Heading 4", "Titre 4"} and style_id == "Heading4":
+                    return style
+    return None
+
+def strip_leading_paragraph_numbers(text: str):
+    """
+    Supprime les numéros de paragraphe du type :
+    2. Texte...
+    11. Texte...
+    101. Texte...
+    sans toucher aux titres Markdown (#, ##, ###).
+    """
+    fixed_lines = []
+
+    for line in text.splitlines():
+        stripped = line.lstrip()
+
+        # Ne jamais toucher aux titres Markdown
+        if stripped.startswith("#"):
+            fixed_lines.append(line)
+            continue
+
+        # Supprime un numéro de paragraphe en début de ligne
+        line = re.sub(r"^\s*\d+\.\s+", "", line)
+        fixed_lines.append(line)
+
+    return "\n".join(fixed_lines) + "\n"
+
+def normalize_non_heading_paragraphs(docx_path: Path):
+    """
+    Force tous les paragraphes non-titres en Body Text / Corps de texte.
+    On laisse intacts les Heading 1-4.
+    """
+    doc = Document(str(docx_path))
+
+    body_style = find_style_by_candidates(doc, ["Body Text", "Corps de texte"])
+    if body_style is None:
+        print(f"Avertissement : style 'Body Text / Corps de texte' introuvable dans {docx_path.name}")
+        return
+
+    heading_names = {
+        "Heading 1", "Heading 2", "Heading 3", "Heading 4",
+        "Titre 1", "Titre 2", "Titre 3", "Titre 4",
+    }
+    heading_ids = {"Heading1", "Heading2", "Heading3", "Heading4"}
+
+    changed = 0
+
+    for para in doc.paragraphs:
+        text = para.text.strip()
+        if not text:
+            continue
+
+        current_style = para.style
+        current_name = current_style.name if current_style else ""
+        current_id = getattr(current_style, "style_id", "") if current_style else ""
+
+        if current_name in heading_names or current_id in heading_ids:
+            continue
+
+        # Tout le reste passe en Body Text
+        para.style = body_style
+        changed += 1
+
+    doc.save(str(docx_path))
+    print(f"   ↳ normalisation styles : {changed} paragraphe(s) mis en 'Body Text / Corps de texte'")
+
+def remove_word_bookmarks(docx_path: Path):
+    """
+    Supprime les bookmarks Word (signets) du DOCX.
+    Ce sont eux qui apparaissent comme crochets gris dans LibreOffice/Word
+    quand l'affichage des signets est activé.
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+
+        # Dézipper le docx
+        with zipfile.ZipFile(docx_path, "r") as zin:
+            zin.extractall(tmpdir)
+
+        xml_targets = [
+            tmpdir / "word" / "document.xml",
+            tmpdir / "word" / "footnotes.xml",
+            tmpdir / "word" / "endnotes.xml",
+            tmpdir / "word" / "comments.xml",
+        ]
+
+        removed = 0
+
+        for xml_file in xml_targets:
+            if not xml_file.exists():
+                continue
+
+            text = xml_file.read_text(encoding="utf-8")
+
+            # enlever <w:bookmarkStart .../> et <w:bookmarkEnd .../>
+            text, c1 = re.subn(r"<w:bookmarkStart\b[^>]*/>", "", text)
+            text, c2 = re.subn(r"<w:bookmarkEnd\b[^>]*/>", "", text)
+
+            removed += c1 + c2
+            xml_file.write_text(text, encoding="utf-8")
+
+        # Rezipper
+        tmp_output = docx_path.with_suffix(".cleaned.docx")
+        with zipfile.ZipFile(tmp_output, "w", zipfile.ZIP_DEFLATED) as zout:
+            for file in tmpdir.rglob("*"):
+                if file.is_file():
+                    zout.write(file, file.relative_to(tmpdir))
+
+        tmp_output.replace(docx_path)
+        print(f"   ↳ suppression signets : {removed} balise(s) supprimée(s)")
+
+def convert_one_file(input_path: Path, output_path: Path, reference_doc: Path | None):
+    raw = input_path.read_text(encoding="utf-8")
+    metadata, body = split_frontmatter(raw)
+    body = strip_mdx_artifacts(body)
+    body = strip_leading_paragraph_numbers(body)
+    body = inject_h1_from_title(metadata, body)
+
+    with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False, encoding="utf-8") as tmp:
+        tmp.write(body)
+        tmp_md = Path(tmp.name)
+
+    cmd = [
+        "pandoc",
+        str(tmp_md),
+        "-f",
+        "markdown",
+        "-o",
+        str(output_path),
+    ]
+
+    if reference_doc:
+        cmd.extend(["--reference-doc", str(reference_doc)])
+
+    try:
+        subprocess.run(cmd, check=True)
+    finally:
+        try:
+            tmp_md.unlink()
+        except FileNotFoundError:
+            pass
+
+    normalize_non_heading_paragraphs(output_path)
+    remove_word_bookmarks(output_path)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convertit des fichiers MDX en DOCX en conservant H1/H2/H3/H4 et en forçant le corps en Body Text."
+    )
+    parser.add_argument("input_dir", help="Dossier contenant les .mdx")
+    parser.add_argument(
+        "--output-dir",
+        default=str(Path.home() / "Desktop" / "archicrat-ia-docx"),
+        help="Dossier de sortie DOCX"
+    )
+    parser.add_argument(
+        "--reference-doc",
+        default=None,
+        help="DOCX modèle Word à utiliser comme reference-doc"
+    )
+
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir)
+    output_dir = Path(args.output_dir)
+    reference_doc = Path(args.reference_doc) if args.reference_doc else None
+
+    if not shutil.which("pandoc"):
+        print("Erreur : pandoc n'est pas installé. Installe-le avec : brew install pandoc")
+        sys.exit(1)
+
+    if not input_dir.exists() or not input_dir.is_dir():
+        print(f"Erreur : dossier introuvable : {input_dir}")
+        sys.exit(1)
+
+    if reference_doc and not reference_doc.exists():
+        print(f"Erreur : reference-doc introuvable : {reference_doc}")
+        sys.exit(1)
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    mdx_files = sorted(input_dir.glob("*.mdx"))
+    if not mdx_files:
+        print(f"Aucun fichier .mdx trouvé dans : {input_dir}")
+        sys.exit(1)
+
+    print(f"Conversion de {len(mdx_files)} fichier(s)...")
+    print(f"Entrée  : {input_dir}")
+    print(f"Sortie  : {output_dir}")
+    if reference_doc:
+        print(f"Modèle  : {reference_doc}")
+    print()
+
+    for mdx_file in mdx_files:
+        docx_name = mdx_file.with_suffix(".docx").name
+        out_file = output_dir / docx_name
+        print(f"→ {mdx_file.name} -> {docx_name}")
+        convert_one_file(mdx_file, out_file, reference_doc)
+
+    print()
+    print("✅ Conversion terminée.")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -205,12 +205,28 @@ async function main() {
   const manifestPath = path.resolve(args.manifest);
 
   const items = await readManifest(manifestPath);
-  const selected = args.all ? items : items.filter(it => args.only.includes(it.slug));
+  const selected = args.all
+    ? items
+    : items.filter((it) => {
+        const rawSlug = String(it.slug || "").trim();
+        const rawCollection = String(it.collection || "").trim();
+        const qualified = `${rawCollection}/${rawSlug}`;
+        return args.only.includes(rawSlug) || args.only.includes(qualified);
+      });
 
-  if (!args.all && selected.length !== args.only.length) {
-    const found = new Set(selected.map(s => s.slug));
-    const missing = args.only.filter(s => !found.has(s));
-    throw new Error(`Some --only slugs not found in manifest: ${missing.join(", ")}`);
+  if (!args.all) {
+    const found = new Set(
+      selected.flatMap((s) => {
+        const rawSlug = String(s.slug || "").trim();
+        const rawCollection = String(s.collection || "").trim();
+        return [rawSlug, `${rawCollection}/${rawSlug}`];
+      })
+    );
+
+    const missing = args.only.filter((s) => !found.has(s));
+    if (missing.length > 0) {
+      throw new Error(`Some --only slugs not found in manifest: ${missing.join(", ")}`);
+    }
   }
 
   const pandocOk = havePandoc();
@@ -267,15 +283,30 @@ async function main() {
 
     // ✅ IMPORTANT: archicrat-ia partage edition/status avec archicratie (pas de migration frontmatter)
     const schemaDefaultsByCollection = {
-      archicratie:   { edition: "archicratie", status: "modele_sociopolitique", level: 1 },
-      "archicrat-ia": { edition: "archicrat-ia", status: "essai_these", 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[outCollection] || { edition: outCollection, 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 = [
       "---",

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,161 +1,123 @@
 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"
+    collection: archicrat-ia
+    slug: prologue
+    title: "Prologue — Fondation, finalité sociopolitique et historique"
     order: 10
 
   - source: sources/docx/archicrat-ia/Chapitre_1—Fondements_epistemologiques_et_modelisation_Archicratie-version_officielle.docx
-    collection: archicratie
-    slug: archicrat-ia/chapitre-1
+    collection: archicrat-ia
+    slug: chapitre-1
     title: "Chapitre 1 — Fondements épistémologiques et modélisation"
     order: 20
 
   - source: sources/docx/archicrat-ia/Chapitre_2–Archeogenese_des_regimes_de_co-viabilite-version_officielle.docx
-    collection: archicratie
-    slug: archicrat-ia/chapitre-2
+    collection: archicrat-ia
+    slug: chapitre-2
     title: "Chapitre 2 — Archéogenèse des régimes de co-viabilité"
     order: 30
 
   - source: sources/docx/archicrat-ia/Chapitre_3—Philosophies_du_pouvoir_et_Archicration-pour_une_topologie_differenciee_des_regimes_regulateurs-version_officielle.docx
-    collection: archicratie
-    slug: archicrat-ia/chapitre-3
+    collection: archicrat-ia
+    slug: chapitre-3
     title: "Chapitre 3 — Philosophies du pouvoir et archicration"
     order: 40
 
   - source: sources/docx/archicrat-ia/Chapitre_4—Vers_une_histoire_archicratique_des_revolutions_industrielles-version_officielle.docx
-    collection: archicratie
-    slug: archicrat-ia/chapitre-4
+    collection: archicrat-ia
+    slug: chapitre-4
     title: "Chapitre 4 — Histoire archicratique des révolutions industrielles"
     order: 50
 
   - source: sources/docx/archicrat-ia/Chapitre_5—Problematiques_des_tensions_des_co-viabilites_et_des_regulations_archicratiques-version_officielle.docx
-    collection: archicratie
-    slug: archicrat-ia/chapitre-5
+    collection: archicrat-ia
+    slug: chapitre-5
     title: "Chapitre 5 — Tensions, co-viabilités et régulations"
     order: 60
 
   - source: sources/docx/archicrat-ia/Conclusion-Archicrat-IA-version_officielle.docx
-    collection: archicratie
-    slug: archicrat-ia/conclusion
+    collection: archicrat-ia
+    slug: conclusion
     title: "Conclusion — ArchiCraT-IA"
     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,5 +1 @@
-{
-  "/archicrat-ia/chapitre-3/": {
-    "p-1-60c7ea48": "p-1-a21087b0"
-  }
-}
+{}

src/components/EditionToc.astro

@@ -1,48 +1,80 @@
 ---
 import { getCollection } from "astro:content";
 
-const { currentSlug } = Astro.props;
+const {
+  currentSlug,
+  collection = "archicrat-ia",
+  basePath = "/archicrat-ia",
+  label = "Table des matières"
+} = Astro.props;
 
-// ✅ Après migration : TOC = collection "archicrat-ia"
-const entries = (await getCollection("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)}/`;
 
-const href = (slug) => `/archicrat-ia/${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);
+});
+
+const tocId = `toc-global-${collection}-${String(basePath).replace(/[^\w-]+/g, "-")}`;
 ---
 
-<nav class="toc-global" aria-label="Table des matières — ArchiCraT-IA">
-  <div class="toc-global__head">
-    <div class="toc-global__title">Table des matières</div>
-  </div>
+<nav
+  class="toc-global"
+  data-mobile-default="closed"
+  aria-label={label}
+  data-toc-global
+  data-toc-key={`global:${collection}:${basePath}`}
+>
+  <button
+    class="toc-global__head toc-global__toggle"
+    type="button"
+    aria-expanded="false"
+    aria-controls={tocId}
+  >
+    <span class="toc-global__title">{label}</span>
+    <span class="toc-global__chevron" aria-hidden="true">▾</span>
+  </button>
 
-  <ol class="toc-global__list">
-    {entries.map((e) => {
-      const active = e.slug === currentSlug;
-      return (
-        <li class={`toc-item ${active ? "is-active" : ""}`}>
-          <a class="toc-link" href={href(e.slug)} aria-current={active ? "page" : undefined}>
-            <span class="toc-link__row">
-              {active ? (
-                <span class="toc-active-indicator" aria-hidden="true">👉</span>
-              ) : (
-                <span class="toc-active-spacer" aria-hidden="true"></span>
-              )}
+  <div class="toc-global__body-clip" id={tocId} hidden>
+    <div class="toc-global__body">
+      <ol class="toc-global__list">
+        {entries.map((e) => {
+          const slug = slugOf(e);
+          const active = slug === currentSlug;
 
-              <span class="toc-link__title">{e.data.title}</span>
+          return (
+            <li class={`toc-item ${active ? "is-active" : ""}`}>
+              <a class="toc-link" href={hrefOf(e)} aria-current={active ? "page" : undefined}>
+                <span class="toc-link__row">
+                  <span class={`toc-active-mark ${active ? "is-on" : ""}`} aria-hidden="true">
+                    <span class="toc-active-mark__dot"></span>
+                  </span>
 
-              {active && (
-                <span class="toc-badge" aria-label="Chapitre en cours">
-                  En cours
+                  <span class="toc-link__title">{e.data.title}</span>
+
+                  {active && (
+                    <span class="toc-badge" aria-label="Chapitre en cours">
+                      En cours
+                    </span>
+                  )}
                 </span>
-              )}
-            </span>
 
-            {active && <span class="toc-underline" aria-hidden="true"></span>}
-          </a>
-        </li>
-      );
-    })}
-  </ol>
+                {active && <span class="toc-underline" aria-hidden="true"></span>}
+              </a>
+            </li>
+          );
+        })}
+      </ol>
+    </div>
+  </div>
 </nav>
 
 <style>
@@ -53,7 +85,22 @@ const href = (slug) => `/archicrat-ia/${slug}/`;
     background: rgba(127,127,127,0.06);
   }
 
+  .toc-global__toggle{
+    width: 100%;
+    appearance: none;
+    border: 0;
+    background: transparent;
+    color: inherit;
+    text-align: left;
+    padding: 0;
+    cursor: pointer;
+  }
+
   .toc-global__head{
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
     margin-bottom: 10px;
     padding-bottom: 10px;
     border-bottom: 1px dashed rgba(127,127,127,0.25);
@@ -66,11 +113,36 @@ const href = (slug) => `/archicrat-ia/${slug}/`;
     opacity: .88;
   }
 
+  .toc-global__chevron{
+    font-size: 12px;
+    opacity: .7;
+    transition: transform 180ms ease;
+  }
+
+  .toc-global__body-clip{
+    display: grid;
+    grid-template-rows: 1fr;
+    transition:
+      grid-template-rows 220ms ease,
+      opacity 160ms ease,
+      margin-top 220ms ease;
+  }
+
+  .toc-global__body{
+    min-height: 0;
+    overflow: hidden;
+  }
+
   .toc-global__list{
     list-style: none;
     margin: 0;
     padding: 0;
+    max-height: 44vh;
+    overflow: auto;
+    padding-right: 8px;
+    scrollbar-gutter: stable;
   }
+
   .toc-global__list li::marker{ content: ""; }
 
   .toc-item{ margin: 6px 0; }
@@ -96,13 +168,33 @@ const href = (slug) => `/archicrat-ia/${slug}/`;
     align-items: center;
   }
 
-  .toc-active-indicator{
-    font-size: 14px;
-    line-height: 1;
+  .toc-active-mark{
+    width: 14px;
+    height: 14px;
+    display: inline-grid;
+    place-items: center;
+    border-radius: 999px;
+    border: 1px solid transparent;
+    opacity: .55;
   }
 
-  .toc-active-spacer{
-    width: 14px;
+  .toc-active-mark__dot{
+    width: 5px;
+    height: 5px;
+    border-radius: 999px;
+    background: currentColor;
+    opacity: .65;
+  }
+
+  .toc-active-mark.is-on{
+    border-color: rgba(127,127,127,0.34);
+    opacity: 1;
+  }
+
+  .toc-active-mark.is-on .toc-active-mark__dot{
+    width: 6px;
+    height: 6px;
+    opacity: 1;
   }
 
   .toc-link__title{
@@ -140,11 +232,70 @@ const href = (slug) => `/archicrat-ia/${slug}/`;
     border-radius: 999px;
   }
 
-  .toc-global__list{
-    max-height: 44vh;
-    overflow: auto;
-    padding-right: 8px;
-    scrollbar-gutter: stable;
+  @media (max-width: 980px){
+    .toc-global{
+      padding: 10px 12px;
+      border-radius: 14px;
+    }
+
+    .toc-global__head{
+      margin-bottom: 0;
+      padding-bottom: 0;
+      border-bottom: 0;
+      min-height: 28px;
+    }
+
+    .toc-global__title{
+      font-size: 13px;
+    }
+
+    .toc-global__body-clip{
+      margin-top: 10px;
+    }
+
+    .toc-global.is-collapsed .toc-global__body-clip{
+      grid-template-rows: 0fr;
+      opacity: 0;
+      margin-top: 0;
+    }
+
+    .toc-global__body{
+      min-height: 0;
+      overflow: hidden;
+      transition: opacity 180ms ease;
+    }
+
+    .toc-global.is-collapsed .toc-global__body{
+      opacity: 0;
+    }
+
+    .toc-global.is-collapsed .toc-global__chevron{
+      transform: rotate(-90deg);
+    }
+
+    .toc-link{
+      padding: 7px 9px;
+      border-radius: 12px;
+    }
+
+    .toc-link__title{
+      font-size: 12.5px;
+      line-height: 1.22;
+    }
+
+    .toc-badge{
+      font-size: 10px;
+      padding: 2px 7px;
+    }
+
+    .toc-global__list{
+      max-height: min(42vh, 360px);
+      padding-right: 4px;
+    }
+
+    .toc-global__body-clip[hidden]{
+      display: none !important;
+    }
   }
 
   @media (prefers-color-scheme: dark){
@@ -152,12 +303,95 @@ const href = (slug) => `/archicrat-ia/${slug}/`;
     .toc-link:hover{ background: rgba(255,255,255,0.06); }
     .toc-item.is-active .toc-link{ background: rgba(255,255,255,0.06); }
     .toc-badge{ background: rgba(255,255,255,0.06); }
+    .toc-active-mark.is-on{ border-color: rgba(255,255,255,0.22); }
   }
 </style>
 
 <script is:inline>
 (() => {
-  const active = document.querySelector(".toc-global .toc-item.is-active");
-  if (active) active.scrollIntoView({ block: "nearest" });
+  function init() {
+    document.querySelectorAll("[data-toc-global]").forEach((nav) => {
+      if (nav.dataset.tocReady === "1") return;
+      nav.dataset.tocReady = "1";
+
+      const toggle = nav.querySelector(".toc-global__toggle");
+      const bodyClip = nav.querySelector(".toc-global__body-clip");
+      const active = nav.querySelector(".toc-item.is-active");
+      const mq = window.matchMedia("(max-width: 980px)");
+      const key = `archicratie:${nav.dataset.tocKey || "toc-global"}`;
+
+      if (!toggle || !bodyClip) return;
+
+      const read = () => {
+        try {
+          const v = localStorage.getItem(key);
+          if (v === "open") return true;
+          if (v === "closed") return false;
+        } catch {}
+        return null;
+      };
+
+      const write = (open) => {
+        try { localStorage.setItem(key, open ? "open" : "closed"); } catch {}
+      };
+
+      const setOpen = (open, { persist = true } = {}) => {
+        const isMobile = mq.matches;
+        const effectiveOpen = isMobile ? open : true;
+
+        nav.classList.toggle("is-collapsed", isMobile && !effectiveOpen);
+        toggle.setAttribute("aria-expanded", effectiveOpen ? "true" : "false");
+
+        if (bodyClip) {
+          bodyClip.hidden = isMobile && !effectiveOpen;
+        }
+
+        if (persist && isMobile) write(effectiveOpen);
+      };
+
+      const initState = () => {
+        if (!mq.matches) {
+          setOpen(true, { persist: false });
+          if (active) active.scrollIntoView({ block: "nearest" });
+          return;
+        }
+
+        const stored = read();
+        const open = stored == null ? false : stored;
+        setOpen(open, { persist: false });
+
+        if (open && active) active.scrollIntoView({ block: "nearest" });
+      };
+
+      toggle.addEventListener("click", () => {
+        const open = toggle.getAttribute("aria-expanded") !== "true";
+        setOpen(open);
+        if (open && active) active.scrollIntoView({ block: "nearest" });
+
+        if (open) {
+          window.dispatchEvent(new CustomEvent("archicratie:tocGlobalOpen"));
+        }
+      });
+
+      window.addEventListener("archicratie:tocLocalOpen", () => {
+        if (!mq.matches) return;
+        setOpen(false);
+      });
+
+      if (mq.addEventListener) {
+        mq.addEventListener("change", initState);
+      } else if (mq.addListener) {
+        mq.addListener(initState);
+      }
+
+      initState();
+    });
+  }
+
+  if (document.readyState === "loading") {
+    window.addEventListener("DOMContentLoaded", init, { once: true });
+  } else {
+    init();
+  }
 })();
 </script>

src/components/GlossaryAside.astro

@@ -0,0 +1,529 @@
+---
+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>
+
+  <details class="glossary-aside__block glossary-aside__disclosure">
+    <summary class="glossary-aside__summary">
+      <span class="glossary-aside__heading">Portails</span>
+      <span class="glossary-aside__chevron" aria-hidden="true">▾</span>
+    </summary>
+
+    <div class="glossary-aside__panel">
+      <ul class="glossary-aside__list">
+        {portalLinks.map((item) => (
+          <li><a href={item.href}>{item.label}</a></li>
+        ))}
+      </ul>
+    </div>
+  </details>
+
+  {showNoyau && (
+    <details class="glossary-aside__block glossary-aside__disclosure">
+      <summary class="glossary-aside__summary">
+        <span class="glossary-aside__heading">Noyau archicratique</span>
+        <span class="glossary-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-aside__panel">
+        <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>
+      </div>
+    </details>
+  )}
+
+  {showSameFamily && (
+    <details class="glossary-aside__block glossary-aside__disclosure">
+      <summary class="glossary-aside__summary">
+        <span class="glossary-aside__heading">{sameFamilyTitle}</span>
+        <span class="glossary-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-aside__panel">
+        <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>
+      </div>
+    </details>
+  )}
+
+  {relationSections.length > 0 && (
+    <details class="glossary-aside__block glossary-aside__disclosure">
+      <summary class="glossary-aside__summary">
+        <span class="glossary-aside__heading">Autour de cette fiche</span>
+        <span class="glossary-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-aside__panel">
+        {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>
+          </>
+        ))}
+      </div>
+    </details>
+  )}
+
+  {contextualTheory.length > 0 && (
+    <details class="glossary-aside__block glossary-aside__disclosure">
+      <summary class="glossary-aside__summary">
+        <span class="glossary-aside__heading">Paysage théorique</span>
+        <span class="glossary-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-aside__panel">
+        <ul class="glossary-aside__list">
+          {contextualTheory.map((entry) => (
+            <li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
+          ))}
+        </ul>
+      </div>
+    </details>
+  )}
+</nav>
+
+<style>
+  .glossary-aside{
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+    min-width: 0;
+  }
+
+  .glossary-aside__block{
+    border: 1px solid rgba(127,127,127,0.22);
+    border-radius: 16px;
+    padding: 14px;
+    background: rgba(127,127,127,0.05);
+    min-width: 0;
+  }
+
+  .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: 18px;
+    font-weight: 850;
+    letter-spacing: .1px;
+    line-height: 1.22;
+  }
+
+  .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;
+    min-width: 0;
+  }
+
+  .glossary-aside__pill--family{
+    border-color: rgba(127,127,127,0.38);
+    font-weight: 800;
+  }
+
+  .glossary-aside__disclosure{
+    padding: 0;
+    overflow: hidden;
+  }
+
+  .glossary-aside__summary{
+    list-style: none;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    padding: 14px;
+    cursor: pointer;
+    user-select: none;
+  }
+
+  .glossary-aside__summary::-webkit-details-marker{
+    display: none;
+  }
+
+  .glossary-aside__summary:hover{
+    background: rgba(127,127,127,0.035);
+  }
+
+  .glossary-aside__heading{
+    margin: 0;
+    font-size: 16px;
+    font-weight: 850;
+    line-height: 1.28;
+    opacity: .97;
+  }
+
+  .glossary-aside__chevron{
+    flex: 0 0 auto;
+    font-size: 14px;
+    line-height: 1;
+    opacity: .72;
+    transform: rotate(0deg);
+    transition: transform 160ms ease, opacity 160ms ease;
+  }
+
+  .glossary-aside__disclosure[open] .glossary-aside__chevron{
+    transform: rotate(180deg);
+    opacity: .96;
+  }
+
+  .glossary-aside__panel{
+    padding: 0 14px 14px;
+  }
+
+  .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;
+    word-break: break-word;
+  }
+
+  .glossary-aside__list a.is-active{
+    font-weight: 800;
+  }
+
+  @media (max-width: 860px){
+    .glossary-aside{
+      gap: 10px;
+    }
+
+    .glossary-aside__block{
+      border-radius: 14px;
+    }
+
+    .glossary-aside__block--intro{
+      padding: 12px;
+    }
+
+    .glossary-aside__back{
+      margin-bottom: 8px;
+      font-size: 13px;
+      line-height: 1.28;
+    }
+
+    .glossary-aside__title{
+      font-size: 19px;
+      line-height: 1.18;
+    }
+
+    .glossary-aside__pills{
+      gap: 6px;
+      margin-top: 8px;
+    }
+
+    .glossary-aside__pill{
+      padding: 4px 9px;
+      font-size: 12px;
+      line-height: 1.26;
+    }
+
+    .glossary-aside__summary{
+      padding: 12px;
+    }
+
+    .glossary-aside__heading{
+      font-size: 17px;
+      line-height: 1.2;
+    }
+
+    .glossary-aside__panel{
+      padding: 0 12px 12px;
+    }
+
+    .glossary-aside__subheading{
+      margin: 10px 0 6px;
+      font-size: 11.5px;
+      line-height: 1.26;
+    }
+
+    .glossary-aside__list li{
+      margin: 5px 0;
+    }
+
+    .glossary-aside__list a{
+      font-size: 14px;
+      line-height: 1.34;
+    }
+
+    .glossary-aside__disclosure:not([open]) .glossary-aside__panel{
+      display: none;
+    }
+  }
+
+  @media (max-width: 860px){
+    .glossary-aside__disclosure{
+      background: rgba(127,127,127,0.045);
+    }
+
+    .glossary-aside__disclosure[open] .glossary-aside__summary{
+      border-bottom: 1px solid rgba(127,127,127,0.12);
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-aside{
+      gap: 8px;
+    }
+
+    .glossary-aside__block{
+      border-radius: 12px;
+    }
+
+    .glossary-aside__block--intro{
+      padding: 10px 11px;
+    }
+
+    .glossary-aside__back{
+      margin-bottom: 6px;
+      font-size: 12px;
+      line-height: 1.2;
+    }
+
+    .glossary-aside__title{
+      font-size: 16px;
+      line-height: 1.14;
+    }
+
+    .glossary-aside__pills{
+      gap: 5px;
+      margin-top: 7px;
+    }
+
+    .glossary-aside__pill{
+      padding: 3px 8px;
+      font-size: 11px;
+      line-height: 1.2;
+    }
+
+    .glossary-aside__summary{
+      padding: 10px 11px;
+    }
+
+    .glossary-aside__heading{
+      font-size: 15px;
+      line-height: 1.16;
+    }
+
+    .glossary-aside__panel{
+      padding: 0 11px 10px;
+    }
+
+    .glossary-aside__subheading{
+      margin: 8px 0 5px;
+      font-size: 11px;
+      line-height: 1.18;
+    }
+
+    .glossary-aside__list li{
+      margin: 4px 0;
+    }
+
+    .glossary-aside__list a{
+      font-size: 13px;
+      line-height: 1.28;
+    }
+  }
+
+  @media (orientation: portrait) and (max-width: 1024px) and (pointer: coarse){
+    .glossary-aside{
+      gap: 10px;
+    }
+
+    .glossary-aside__disclosure{
+      background: rgba(127,127,127,0.045);
+    }
+
+    .glossary-aside__disclosure:not([open]) .glossary-aside__panel{
+      display: none;
+    }
+
+    .glossary-aside__summary{
+      cursor: pointer;
+    }
+
+    .glossary-aside__chevron{
+      display: inline;
+    }
+  }
+
+  @media (min-width: 861px) and (hover: hover) and (pointer: fine){
+    .glossary-aside__summary{
+      cursor: default;
+    }
+
+    .glossary-aside__chevron{
+      display: none;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-aside__block,
+    .glossary-aside__pill{
+      background: rgba(255,255,255,0.04);
+    }
+
+    .glossary-aside__summary:hover{
+      background: rgba(255,255,255,0.03);
+    }
+  }
+</style>
+
+<script is:inline>
+  (() => {
+    const syncMobileDisclosure = () => {
+      const mobile = window.matchMedia(
+        "(max-width: 860px), ((orientation: portrait) and (max-width: 1024px) and (pointer: coarse))"
+      ).matches;
+      const smallLandscape = window.matchMedia(
+        "(orientation: landscape) and (max-width: 920px) and (max-height: 520px)"
+      ).matches;
+
+      const compact = mobile || smallLandscape;
+
+      document
+        .querySelectorAll(".glossary-aside__disclosure")
+        .forEach((el, index) => {
+          if (!(el instanceof HTMLDetailsElement)) return;
+
+          if (compact) {
+            if (!el.dataset.mobileInit) {
+              el.open = false;
+              el.dataset.mobileInit = "true";
+            }
+          } else {
+            el.open = true;
+          }
+        });
+    };
+
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", syncMobileDisclosure, { once: true });
+    } else {
+      syncMobileDisclosure();
+    }
+
+    window.addEventListener("resize", syncMobileDisclosure);
+    window.addEventListener("pageshow", syncMobileDisclosure);
+  })();
+</script>

src/components/GlossaryCardGrid.astro

@@ -0,0 +1,110 @@
+---
+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: 12px;
+  }
+
+  .glossary-card{
+    display: flex;
+    flex-direction: column;
+    gap: 7px;
+    padding: 13px 14px;
+    border: 1px solid var(--glossary-border);
+    border-radius: 16px;
+    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.02rem;
+    line-height: 1.24;
+  }
+
+  .glossary-card span{
+    color: inherit;
+    font-size: .98rem;
+    line-height: 1.46;
+    opacity: .94;
+  }
+
+  @media (max-width: 760px){
+    .glossary-cards{
+      grid-template-columns: 1fr;
+      gap: 10px;
+      margin-top: 10px;
+    }
+
+    .glossary-card{
+      gap: 6px;
+      padding: 12px 12px;
+      border-radius: 14px;
+    }
+
+    .glossary-card strong{
+      font-size: .98rem;
+    }
+
+    .glossary-card span{
+      font-size: .94rem;
+      line-height: 1.42;
+    }
+
+    .glossary-card--wide{
+      grid-column: auto;
+    }
+  }
+
+  @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,26 @@
+<div class="glossary-entry-body">
+  <slot />
+</div>
+
+<style>
+  .glossary-entry-body{
+    margin-bottom: 16px;
+  }
+
+  .glossary-entry-body > :last-child{
+    margin-bottom: 0;
+  }
+
+  @media (max-width: 760px){
+    .glossary-entry-body{
+      margin-bottom: 12px;
+    }
+  }
+
+  :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,264 @@
+---
+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: var(--sticky-header-h, 0px);
+    z-index: 11;
+    margin: 0 0 22px;
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 24px;
+    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;
+
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 4;
+    overflow: hidden;
+  }
+
+  .glossary-entry-signals{
+    display: flex;
+    flex-wrap: wrap;
+    gap: 7px;
+    margin: 0;
+    transition: gap 180ms ease;
+  }
+
+  .glossary-pill{
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    padding: 5px 9px;
+    border: 1px solid rgba(127,127,127,0.24);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.05);
+    font-size: 12.5px;
+    line-height: 1.28;
+    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: 13.5px;
+    line-height: 1.45;
+  }
+
+  .glossary-entry-meta p + p{
+    margin-top: 6px;
+  }
+
+  @media (max-width: 860px){
+    .glossary-entry-head{
+      position: static;
+      border-radius: 18px;
+      margin-bottom: 16px;
+    }
+
+    .glossary-entry-head__title{
+      padding: 12px 12px 10px;
+    }
+
+    .glossary-entry-summary{
+      gap: 9px;
+      padding: 10px 12px 12px;
+    }
+
+    .glossary-entry-dek{
+      max-width: none;
+      -webkit-line-clamp: 3;
+    }
+
+    .glossary-entry-signals{
+      gap: 6px;
+    }
+
+    .glossary-pill{
+      font-size: 12px;
+      padding: 4px 8px;
+    }
+  }
+
+  @media (max-width: 520px){
+    .glossary-entry-head{
+      border-radius: 16px;
+      margin-bottom: 14px;
+    }
+
+    .glossary-entry-head__title{
+      padding: 10px 10px 9px;
+    }
+
+    .glossary-entry-summary{
+      gap: 9px;
+      padding: 9px 10px 11px;
+    }
+
+    .glossary-entry-dek{
+      display: block;
+      max-width: none;
+      overflow: visible;
+      -webkit-line-clamp: unset;
+      -webkit-box-orient: unset;
+    }
+
+    .glossary-pill{
+      font-size: 11.5px;
+      padding: 3px 7px;
+    }
+  }
+
+  @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,291 @@
+<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)");
+      const mqSmallLandscape = window.matchMedia(
+        "(orientation: landscape) and (max-width: 920px) and (max-height: 520px)"
+      );
+
+      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 isCompactViewport = () =>
+        mqMobile.matches || mqSmallLandscape.matches;
+
+      const heroHeight = () => {
+        const rect = hero.getBoundingClientRect();
+        return Math.max(0, Math.round(rect.height || 0));
+      };
+
+      const neutralizeGlobalFollowIfCompact = () => {
+        if (!isCompactViewport()) {
+          follow.style.display = "";
+          return;
+        }
+
+        follow.classList.remove("is-on");
+        follow.setAttribute("aria-hidden", "true");
+        follow.style.display = "none";
+        root.style.setProperty("--followbar-h", "0px");
+      };
+
+      const computeFollowOn = () =>
+        !isCompactViewport() &&
+        follow.classList.contains("is-on") &&
+        follow.style.display !== "none" &&
+        follow.getAttribute("aria-hidden") !== "true";
+
+      const syncFollowState = () => {
+        const on = computeFollowOn();
+
+        if (on) {
+          if (lastFollowOn === true) return;
+          lastFollowOn = true;
+          body.classList.add(FOLLOW_ON_CLASS);
+          return;
+        }
+
+        if (lastFollowOn === false) return;
+        lastFollowOn = false;
+        body.classList.remove(FOLLOW_ON_CLASS);
+      };
+
+      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 = isCompactViewport() ? 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 syncAll = () => {
+        neutralizeGlobalFollowIfCompact();
+        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);
+      }
+
+      if (mqSmallLandscape.addEventListener) {
+        mqSmallLandscape.addEventListener("change", schedule);
+      } else if (mqSmallLandscape.addListener) {
+        mqSmallLandscape.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-head h1){
+    letter-spacing: -.03em;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-summary){
+    gap: 8px;
+    padding-top: 10px;
+    padding-bottom: 8px;
+    border-top-color: rgba(127,127,127,0.10);
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-dek){
+    display: block;
+    -webkit-line-clamp: unset;
+    overflow: visible;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-signals){
+    gap: 5px;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-pill){
+    gap: 4px;
+    padding: 3px 7px;
+    font-size: 11px;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-meta){
+    padding: 0;
+    border-color: transparent;
+    max-height: 0;
+    opacity: 0;
+    overflow: hidden;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on #reading-follow){
+    transform: none;
+  }
+
+  :global(body.is-glossary-entry-page.glossary-entry-follow-on #reading-follow .reading-follow__inner){
+    margin-top: 0;
+    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 #reading-follow),
+    :global(body.is-glossary-entry-page #reading-follow .reading-follow__inner){
+      display: none !important;
+      opacity: 0 !important;
+      pointer-events: none !important;
+      visibility: hidden !important;
+    }
+
+    :global(body.is-glossary-entry-page){
+      --followbar-h: 0px !important;
+      --sticky-offset-px: calc(var(--sticky-header-h, 0px) + var(--page-gap, 12px)) !important;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-head){
+      margin-bottom: 18px;
+      border-radius: 20px;
+      box-shadow: none;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-summary){
+      gap: 6px;
+      padding-top: 8px;
+      padding-bottom: 8px;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-dek){
+      display: block;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-signals){
+      gap: 5px;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-pill){
+      padding: 3px 6px;
+      font-size: 10.5px;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    :global(body.is-glossary-entry-page #reading-follow),
+    :global(body.is-glossary-entry-page #reading-follow .reading-follow__inner){
+      display: none !important;
+      opacity: 0 !important;
+      pointer-events: none !important;
+      visibility: hidden !important;
+    }
+
+    :global(body.is-glossary-entry-page){
+      --followbar-h: 0px !important;
+      --sticky-offset-px: calc(var(--sticky-header-h, 0px) + var(--page-gap, 12px)) !important;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-head){
+      margin-bottom: 14px;
+      border-radius: 16px;
+      box-shadow: none;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-summary){
+      gap: 5px;
+      padding-top: 6px;
+      padding-bottom: 6px;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-entry-dek){
+      display: none;
+    }
+
+    :global(body.is-glossary-entry-page.glossary-entry-follow-on .glossary-pill){
+      padding: 2px 6px;
+      font-size: 10px;
+    }
+  }
+</style>

src/components/GlossaryHomeAside.astro

@@ -0,0 +1,382 @@
+---
+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>
+
+  <details class="glossary-home-aside__block glossary-home-aside__disclosure" open>
+    <summary class="glossary-home-aside__summary">
+      <span class="glossary-home-aside__heading">Parcours du glossaire</span>
+      <span class="glossary-home-aside__chevron" aria-hidden="true">▾</span>
+    </summary>
+
+    <div class="glossary-home-aside__panel">
+      <ul class="glossary-home-aside__list">
+        {portalLinks.map((item) => (
+          <li><a href={item.href}>{item.label}</a></li>
+        ))}
+      </ul>
+    </div>
+  </details>
+
+  {fondamentaux.length > 0 && (
+    <details class="glossary-home-aside__block glossary-home-aside__disclosure" open>
+      <summary class="glossary-home-aside__summary">
+        <span class="glossary-home-aside__heading">Noyau archicratique</span>
+        <span class="glossary-home-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-home-aside__panel">
+        <ul class="glossary-home-aside__list">
+          {fondamentaux.map((entry) => (
+            <li><a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a></li>
+          ))}
+        </ul>
+      </div>
+    </details>
+  )}
+</nav>
+
+<style>
+  .glossary-home-aside{
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+    min-width: 0;
+  }
+
+  .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);
+    min-width: 0;
+  }
+
+  .glossary-home-aside__block--intro{
+    padding-top: 13px;
+    padding-bottom: 13px;
+  }
+
+  .glossary-home-aside__title{
+    font-size: 18px;
+    font-weight: 850;
+    letter-spacing: .1px;
+    line-height: 1.22;
+  }
+
+  .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;
+    min-width: 0;
+  }
+
+  .glossary-home-aside__disclosure{
+    padding: 0;
+    overflow: hidden;
+  }
+
+  .glossary-home-aside__summary{
+    list-style: none;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    padding: 14px;
+    cursor: pointer;
+    user-select: none;
+  }
+
+  .glossary-home-aside__summary::-webkit-details-marker{
+    display: none;
+  }
+
+  .glossary-home-aside__summary:hover{
+    background: rgba(127,127,127,0.035);
+  }
+
+  .glossary-home-aside__heading{
+    margin: 0;
+    font-size: 16px;
+    font-weight: 850;
+    line-height: 1.28;
+    opacity: .97;
+  }
+
+  .glossary-home-aside__chevron{
+    flex: 0 0 auto;
+    font-size: 14px;
+    line-height: 1;
+    opacity: .72;
+    transform: rotate(0deg);
+    transition: transform 160ms ease, opacity 160ms ease;
+  }
+
+  .glossary-home-aside__disclosure[open] .glossary-home-aside__chevron{
+    transform: rotate(180deg);
+    opacity: .96;
+  }
+
+  .glossary-home-aside__panel{
+    padding: 0 14px 14px;
+  }
+
+  .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.42;
+    word-break: break-word;
+  }
+
+  @media (max-width: 860px){
+    .glossary-home-aside{
+      gap: 10px;
+    }
+
+    .glossary-home-aside__block{
+      border-radius: 14px;
+    }
+
+    .glossary-home-aside__block--intro{
+      padding: 12px;
+    }
+
+    .glossary-home-aside__title{
+      font-size: 19px;
+      line-height: 1.18;
+    }
+
+    .glossary-home-aside__meta{
+      margin-top: 6px;
+      font-size: 12px;
+      line-height: 1.32;
+    }
+
+    .glossary-home-aside__pills{
+      gap: 6px;
+      margin-top: 9px;
+    }
+
+    .glossary-home-aside__pill{
+      padding: 4px 9px;
+      font-size: 12px;
+      line-height: 1.28;
+    }
+
+    .glossary-home-aside__summary{
+      padding: 12px;
+    }
+
+    .glossary-home-aside__heading{
+      font-size: 17px;
+      line-height: 1.2;
+    }
+
+    .glossary-home-aside__panel{
+      padding: 0 12px 12px;
+    }
+
+    .glossary-home-aside__list li{
+      margin: 5px 0;
+    }
+
+    .glossary-home-aside__list a{
+      font-size: 14px;
+      line-height: 1.34;
+    }
+
+    .glossary-home-aside__disclosure:not([open]) .glossary-home-aside__panel{
+      display: none;
+    }
+  }
+
+  @media (max-width: 860px){
+    .glossary-home-aside__disclosure{
+      background: rgba(127,127,127,0.045);
+    }
+
+    .glossary-home-aside__disclosure[open] .glossary-home-aside__summary{
+      border-bottom: 1px solid rgba(127,127,127,0.12);
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-home-aside{
+      gap: 8px;
+    }
+
+    .glossary-home-aside__block{
+      border-radius: 12px;
+    }
+
+    .glossary-home-aside__block--intro{
+      padding: 10px 11px;
+    }
+
+    .glossary-home-aside__title{
+      font-size: 16px;
+      line-height: 1.14;
+    }
+
+    .glossary-home-aside__meta{
+      font-size: 11px;
+      line-height: 1.26;
+      margin-top: 5px;
+    }
+
+    .glossary-home-aside__pills{
+      gap: 5px;
+      margin-top: 8px;
+    }
+
+    .glossary-home-aside__pill{
+      padding: 3px 8px;
+      font-size: 11px;
+      line-height: 1.2;
+    }
+
+    .glossary-home-aside__summary{
+      padding: 10px 11px;
+    }
+
+    .glossary-home-aside__heading{
+      font-size: 15px;
+      line-height: 1.16;
+    }
+
+    .glossary-home-aside__panel{
+      padding: 0 11px 10px;
+    }
+
+    .glossary-home-aside__list li{
+      margin: 4px 0;
+    }
+
+    .glossary-home-aside__list a{
+      font-size: 13px;
+      line-height: 1.28;
+    }
+  }
+
+  @media (min-width: 861px){
+    .glossary-home-aside__summary{
+      cursor: default;
+    }
+
+    .glossary-home-aside__chevron{
+      display: none;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-home-aside__block,
+    .glossary-home-aside__pill{
+      background: rgba(255,255,255,0.04);
+    }
+
+    .glossary-home-aside__summary:hover{
+      background: rgba(255,255,255,0.03);
+    }
+  }
+</style>
+
+<script is:inline>
+  (() => {
+    const syncMobileDisclosure = () => {
+      const mobile = window.matchMedia("(max-width: 860px)").matches;
+      const smallLandscape = window.matchMedia(
+        "(orientation: landscape) and (max-width: 920px) and (max-height: 520px)"
+      ).matches;
+
+      const compact = mobile || smallLandscape;
+
+      document
+        .querySelectorAll(".glossary-home-aside__disclosure")
+        .forEach((el, index) => {
+          if (!(el instanceof HTMLDetailsElement)) return;
+
+          if (compact) {
+            if (!el.dataset.mobileInit) {
+              el.open = index === 0;
+              el.dataset.mobileInit = "true";
+            }
+          } else {
+            el.open = true;
+          }
+        });
+    };
+
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", syncMobileDisclosure, { once: true });
+    } else {
+      syncMobileDisclosure();
+    }
+
+    window.addEventListener("resize", syncMobileDisclosure);
+    window.addEventListener("pageshow", syncMobileDisclosure);
+  })();
+</script>

src/components/GlossaryHomeHero.astro

@@ -0,0 +1,460 @@
+---
+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>
+
+  <div class="glossary-hero__collapsible">
+    <p
+      class="glossary-intro"
+      id="glossary-hero-intro"
+      aria-hidden="false"
+    >
+      {intro}
+    </p>
+
+    <button
+      class="glossary-hero__toggle"
+      id="glossary-hero-toggle"
+      type="button"
+      aria-controls="glossary-hero-intro"
+      aria-expanded="false"
+      hidden
+    >
+      lire la suite
+    </button>
+  </div>
+
+  <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:
+      padding 220ms cubic-bezier(.22,.8,.22,1),
+      border-radius 220ms cubic-bezier(.22,.8,.22,1),
+      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;
+    min-width: 0;
+    overflow: clip;
+  }
+
+  .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;
+    transition:
+      font-size 220ms cubic-bezier(.22,.8,.22,1),
+      line-height 220ms cubic-bezier(.22,.8,.22,1);
+    min-width: 0;
+  }
+
+  .glossary-hero__collapsible{
+    display: grid;
+    row-gap: 6px;
+    min-width: 0;
+  }
+
+  .glossary-intro{
+    margin: 0;
+    max-width: 72ch;
+    font-size: 1.05rem;
+    line-height: 1.55;
+    opacity: .94;
+    min-width: 0;
+    transition:
+      font-size 220ms cubic-bezier(.22,.8,.22,1),
+      line-height 220ms cubic-bezier(.22,.8,.22,1),
+      max-height 220ms cubic-bezier(.22,.8,.22,1),
+      opacity 180ms ease;
+  }
+
+  :global(body[data-edition-key="glossaire"] .glossary-hero p#glossary-hero-intro){
+    padding-right: 0;
+    scroll-margin-top: 0;
+  }
+
+  .glossary-hero__toggle{
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: fit-content;
+    min-height: 30px;
+    padding: 3px 0;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    color: inherit;
+    font-size: 12px;
+    line-height: 1.2;
+    letter-spacing: .01em;
+    opacity: .72;
+    cursor: pointer;
+    text-decoration: underline;
+    text-decoration-thickness: 1px;
+    text-underline-offset: 2px;
+    transition:
+      opacity 120ms ease,
+      transform 120ms ease;
+  }
+
+  .glossary-hero__toggle:hover{
+    opacity: .92;
+    transform: translateY(-1px);
+  }
+
+  .glossary-hero__toggle:focus-visible{
+    outline: 2px solid rgba(0,217,255,0.24);
+    outline-offset: 4px;
+    border-radius: 4px;
+  }
+
+  .glossary-hero__toggle[hidden]{
+    display: none !important;
+  }
+
+  .glossary-hero-follow{
+    margin: 2px 0 0;
+    min-height: var(--glossary-follow-height);
+    display: block;
+    max-width: min(100%, 22ch);
+    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;
+    min-width: 0;
+  }
+
+  .glossary-hero-follow.is-visible{
+    opacity: 1;
+    transform: translateY(0) scale(1);
+    filter: blur(0);
+  }
+
+  :global(body.glossary-home-follow-on) .glossary-hero{
+    padding: 12px 14px 14px;
+    border-bottom-left-radius: 18px;
+    border-bottom-right-radius: 18px;
+  }
+
+  :global(body.glossary-home-follow-on) .glossary-hero h1{
+    font-size: clamp(1.7rem, 3.2vw, 2.2rem);
+    line-height: 1.02;
+  }
+
+  :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-intro{
+    font-size: .94rem;
+    line-height: 1.34;
+    max-height: 2.7em;
+    overflow: hidden;
+    display: -webkit-box;
+    -webkit-box-orient: vertical;
+    -webkit-line-clamp: 2;
+  }
+
+  :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-hero__toggle{
+    display: inline-flex;
+  }
+
+  @media (max-width: 760px){
+    .glossary-hero{
+      top: calc(var(--glossary-sticky-top) - 2px);
+      padding: 12px 14px 16px;
+      border-radius: 22px;
+      row-gap: 10px;
+    }
+
+    .glossary-hero h1{
+      font-size: clamp(1.9rem, 8vw, 2.45rem);
+      line-height: 1.02;
+      letter-spacing: -.03em;
+    }
+
+    .glossary-hero__collapsible{
+      row-gap: 7px;
+    }
+
+    .glossary-intro{
+      max-width: 100%;
+      width: 100%;
+      font-size: .98rem;
+      line-height: 1.44;
+    }
+
+    :global(body.glossary-home-follow-on) .glossary-hero{
+      padding: 10px 13px 12px;
+      border-radius: 18px;
+    }
+
+    :global(body.glossary-home-follow-on) .glossary-hero h1{
+      font-size: clamp(1.45rem, 6vw, 1.8rem);
+    }
+
+    :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-intro{
+      max-width: 100%;
+      width: 100%;
+      font-size: .86rem;
+      line-height: 1.24;
+      max-height: 2.48em;
+      -webkit-line-clamp: 2;
+      opacity: .9;
+    }
+
+    .glossary-hero__toggle{
+      min-height: 28px;
+      font-size: 11.5px;
+    }
+
+    .glossary-hero-follow{
+      max-width: min(100%, 24ch);
+    }
+  }
+
+  @media (max-width: 520px){
+    .glossary-hero{
+      padding: 11px 12px 14px;
+      border-radius: 20px;
+    }
+
+    .glossary-intro{
+      max-width: 100%;
+      width: 100%;
+      font-size: .94rem;
+      line-height: 1.4;
+    }
+
+    :global(body.glossary-home-follow-on) .glossary-hero{
+      padding: 9px 11px 11px;
+    }
+
+    :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-intro{
+      max-width: 100%;
+      width: 100%;
+      font-size: .84rem;
+      line-height: 1.22;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-hero{
+      padding: 10px 12px 12px;
+      border-radius: 16px;
+      row-gap: 8px;
+    }
+
+    .glossary-kicker{
+      font-size: 10px;
+      letter-spacing: .1em;
+    }
+
+    .glossary-hero h1{
+      font-size: clamp(1.35rem, 4vw, 1.8rem);
+      line-height: 1;
+    }
+
+    .glossary-intro{
+      font-size: .84rem;
+      line-height: 1.24;
+    }
+
+    :global(body.glossary-home-follow-on) .glossary-hero{
+      padding: 9px 11px 10px;
+      border-radius: 16px;
+    }
+
+    :global(body.glossary-home-follow-on) .glossary-hero h1{
+      font-size: clamp(1.1rem, 3vw, 1.35rem);
+    }
+
+    :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-intro{
+      font-size: .8rem;
+      line-height: 1.18;
+      max-height: 2.36em;
+      -webkit-line-clamp: 2;
+      opacity: .88;
+    }
+
+    .glossary-hero__toggle{
+      min-height: 24px;
+      font-size: 11px;
+    }
+
+    .glossary-hero-follow{
+      max-width: min(100%, 26ch);
+    }
+  }
+
+    @media (max-width: 860px){
+    .glossary-hero{
+      position: static !important;
+      top: auto !important;
+      z-index: auto !important;
+      margin-bottom: 18px !important;
+    }
+
+    .glossary-hero-follow{
+      display: none !important;
+      min-height: 0 !important;
+      opacity: 0 !important;
+      transform: none !important;
+      filter: none !important;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-hero{
+      position: static !important;
+      top: auto !important;
+      z-index: auto !important;
+      margin-bottom: 14px !important;
+    }
+
+    .glossary-hero-follow{
+      display: none !important;
+      min-height: 0 !important;
+      opacity: 0 !important;
+      transform: none !important;
+      filter: none !important;
+    }
+  }
+
+  /* Neutralisation mobile/tablette : le hero n'est plus sticky, donc aucun état condensé. */
+  @media (max-width: 860px){
+    .glossary-hero{
+      position: static !important;
+      top: auto !important;
+      z-index: auto !important;
+      margin-bottom: 18px !important;
+      padding: 12px 14px 16px !important;
+      border-radius: 22px !important;
+      row-gap: 8px !important;
+    }
+
+    .glossary-hero h1,
+    :global(body.glossary-home-follow-on) .glossary-hero h1{
+      font-size: clamp(2rem, 6.2vw, 2.75rem) !important;
+      line-height: 1.04 !important;
+      letter-spacing: -.035em !important;
+      max-width: 100%;
+      overflow-wrap: normal;
+      word-break: normal;
+      hyphens: none;
+      text-wrap: balance;
+    }
+
+    .glossary-intro,
+    :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-intro{
+      max-width: 100% !important;
+      width: 100% !important;
+      max-height: none !important;
+      overflow: visible !important;
+      display: block !important;
+      -webkit-line-clamp: unset !important;
+      -webkit-box-orient: unset !important;
+      font-size: .94rem !important;
+      line-height: 1.4 !important;
+      opacity: .94 !important;
+      padding-right: 0 !important;
+      scroll-margin-top: 0 !important;
+    }
+
+    .glossary-hero__toggle,
+    .glossary-hero-follow{
+      display: none !important;
+    }
+  }
+
+  /* Mobile paysage compact : même logique, mais plus dense. */
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-hero{
+      padding: 8px 10px 9px !important;
+      border-radius: 14px !important;
+      row-gap: 5px !important;
+      margin-bottom: 10px !important;
+    }
+
+    .glossary-kicker{
+      font-size: 9px !important;
+      letter-spacing: .11em !important;
+    }
+
+    .glossary-hero h1,
+    :global(body.glossary-home-follow-on) .glossary-hero h1{
+      font-size: clamp(1.55rem, 4.2vw, 1.9rem) !important;
+      line-height: 1.03 !important;
+      letter-spacing: -.025em !important;
+    }
+
+    .glossary-intro,
+    :global(body.glossary-home-follow-on:not(.glossary-home-hero-expanded)) .glossary-intro{
+      font-size: .72rem !important;
+      line-height: 1.18 !important;
+    }
+  }
+
+  /* Tablette large / iPad landscape : le follow reste lisible, jamais tronqué brutalement. */
+  @media (min-width: 861px) and (max-width: 1240px){
+    .glossary-hero h1{
+      font-size: clamp(2.35rem, 4.2vw, 3.05rem) !important;
+      line-height: 1.03 !important;
+    }
+
+    .glossary-hero-follow{
+      max-width: 100% !important;
+      white-space: normal !important;
+      overflow: visible !important;
+      text-overflow: clip !important;
+      font-size: clamp(1.55rem, 3.1vw, 2.05rem) !important;
+      line-height: 1.08 !important;
+    }
+  }
+</style>

src/components/GlossaryHomeSection.astro

@@ -0,0 +1,133 @@
+---
+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: 34px;
+    scroll-margin-top: calc(var(--glossary-sticky-top) + 150px);
+  }
+
+  .glossary-section__head{
+    display: flex;
+    justify-content: space-between;
+    align-items: start;
+    gap: 14px;
+    flex-wrap: wrap;
+    margin-bottom: 12px;
+  }
+
+  .glossary-section h2{
+    margin: 0;
+    font-size: clamp(1.8rem, 3vw, 2.55rem);
+    line-height: 1.06;
+    letter-spacing: -.03em;
+    font-weight: 800;
+  }
+
+  .glossary-intro{
+    margin: 0;
+    max-width: 72ch;
+    font-size: 1rem;
+    line-height: 1.52;
+    opacity: .94;
+  }
+
+  .glossary-section__head .glossary-intro{
+    margin-top: 8px;
+  }
+
+  .glossary-cta{
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 38px;
+    border: 1px solid var(--glossary-border-strong);
+    border-radius: 999px;
+    padding: 6px 13px;
+    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{
+      margin-top: 24px;
+      scroll-margin-top: calc(var(--glossary-sticky-top) + 110px);
+    }
+
+    .glossary-section__head{
+      flex-direction: column;
+      align-items: stretch;
+      gap: 10px;
+      margin-bottom: 10px;
+    }
+
+    .glossary-section h2{
+      font-size: clamp(1.45rem, 6vw, 1.95rem);
+      line-height: 1.05;
+    }
+
+    .glossary-intro{
+      font-size: .95rem;
+      line-height: 1.42;
+    }
+
+    .glossary-section__head .glossary-intro{
+      margin-top: 6px;
+    }
+
+    .glossary-cta{
+      width: fit-content;
+      min-height: 35px;
+      padding: 5px 12px;
+      font-size: .95rem;
+    }
+  }
+</style>

src/components/GlossaryPortalAside.astro

@@ -0,0 +1,286 @@
+---
+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 && (
+    <details class="glossary-portal-aside__block glossary-portal-aside__disclosure">
+      <summary class="glossary-portal-aside__summary">
+        <span class="glossary-portal-aside__heading">Dans cette page</span>
+        <span class="glossary-portal-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-portal-aside__panel">
+        <ul class="glossary-portal-aside__list">
+          {pageItems.map((item) => (
+            <li><a href={item.href}>{item.label}</a></li>
+          ))}
+        </ul>
+      </div>
+    </details>
+  )}
+
+  {usefulLinks.length > 0 && (
+    <details class="glossary-portal-aside__block glossary-portal-aside__disclosure">
+      <summary class="glossary-portal-aside__summary">
+        <span class="glossary-portal-aside__heading">Renvois utiles</span>
+        <span class="glossary-portal-aside__chevron" aria-hidden="true">▾</span>
+      </summary>
+
+      <div class="glossary-portal-aside__panel">
+        <ul class="glossary-portal-aside__list">
+          {usefulLinks.map((item) => (
+            <li><a href={item.href}>{item.label}</a></li>
+          ))}
+        </ul>
+      </div>
+    </details>
+  )}
+</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: 14px;
+    background: rgba(127,127,127,0.05);
+  }
+
+  .glossary-portal-aside__back{
+    display: inline-block;
+    margin-bottom: 10px;
+    font-size: 14px;
+    font-weight: 700;
+    line-height: 1.35;
+    text-decoration: none;
+  }
+
+  .glossary-portal-aside__title{
+    font-size: 16px;
+    font-weight: 800;
+    letter-spacing: .2px;
+    line-height: 1.3;
+  }
+
+  .glossary-portal-aside__meta{
+    margin-top: 8px;
+    font-size: 13px;
+    line-height: 1.4;
+    opacity: .8;
+  }
+
+  .glossary-portal-aside__heading{
+    margin: 0 0 11px;
+    font-size: 14px;
+    font-weight: 800;
+    line-height: 1.35;
+    opacity: .94;
+  }
+
+  .glossary-portal-aside__list{
+    list-style: none;
+    margin: 0;
+    padding: 0;
+  }
+
+  .glossary-portal-aside__list li{
+    margin: 7px 0;
+  }
+
+  .glossary-portal-aside__list a{
+    text-decoration: none;
+    font-size: 14px;
+    line-height: 1.4;
+  }
+
+  @media (max-width: 980px){
+    .glossary-portal-aside{
+      gap: 12px;
+    }
+
+    .glossary-portal-aside__block{
+      padding: 12px;
+      border-radius: 14px;
+    }
+  }
+
+  @media (max-width: 760px){
+    .glossary-portal-aside{
+      gap: 10px;
+    }
+
+    .glossary-portal-aside__block{
+      padding: 11px 12px;
+      border-radius: 14px;
+    }
+
+    .glossary-portal-aside__back{
+      margin-bottom: 8px;
+      font-size: 13px;
+    }
+
+    .glossary-portal-aside__title{
+      font-size: 15px;
+      line-height: 1.22;
+    }
+
+    .glossary-portal-aside__meta{
+      margin-top: 6px;
+      font-size: 12px;
+      line-height: 1.32;
+    }
+
+    .glossary-portal-aside__heading{
+      margin-bottom: 8px;
+      font-size: 13px;
+      line-height: 1.22;
+    }
+
+    .glossary-portal-aside__list li{
+      margin: 5px 0;
+    }
+
+    .glossary-portal-aside__list a{
+      font-size: 12.5px;
+      line-height: 1.3;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-portal-aside{
+      gap: 8px;
+    }
+
+    .glossary-portal-aside__block{
+      padding: 9px 10px;
+      border-radius: 12px;
+    }
+
+    .glossary-portal-aside__back{
+      margin-bottom: 6px;
+      font-size: 12px;
+    }
+
+    .glossary-portal-aside__title{
+      font-size: 14px;
+      line-height: 1.18;
+    }
+
+    .glossary-portal-aside__meta{
+      margin-top: 4px;
+      font-size: 11px;
+      line-height: 1.24;
+    }
+
+    .glossary-portal-aside__heading{
+      margin-bottom: 6px;
+      font-size: 12px;
+      line-height: 1.18;
+    }
+
+    .glossary-portal-aside__list li{
+      margin: 4px 0;
+    }
+
+    .glossary-portal-aside__list a{
+      font-size: 11.5px;
+      line-height: 1.22;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-aside__block{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+
+  .glossary-portal-aside__disclosure{
+    padding: 0;
+    overflow: hidden;
+  }
+
+  .glossary-portal-aside__summary{
+    list-style: none;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    padding: 14px;
+    cursor: pointer;
+    user-select: none;
+  }
+
+  .glossary-portal-aside__summary::-webkit-details-marker{
+    display: none;
+  }
+
+  .glossary-portal-aside__summary .glossary-portal-aside__heading{
+    margin: 0;
+  }
+
+  .glossary-portal-aside__disclosure:not([open]) .glossary-portal-aside__panel{
+    display: none;
+  }
+
+  .glossary-portal-aside__chevron{
+    flex: 0 0 auto;
+    font-size: 14px;
+    line-height: 1;
+    opacity: .72;
+    transition: transform 160ms ease, opacity 160ms ease;
+  }
+
+  .glossary-portal-aside__disclosure[open] .glossary-portal-aside__chevron{
+    transform: rotate(180deg);
+    opacity: .96;
+  }
+
+  .glossary-portal-aside__panel{
+    padding: 0 14px 14px;
+  }
+
+  @media (max-width: 980px){
+    .glossary-portal-aside__summary{
+      padding: 12px;
+    }
+
+    .glossary-portal-aside__panel{
+      padding: 0 12px 12px;
+    }
+  }
+</style>

src/components/GlossaryPortalCta.astro

@@ -0,0 +1,67 @@
+---
+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;
+    min-height: 40px;
+    padding: 7px 14px;
+    border: 1px solid rgba(127,127,127,0.24);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.05);
+    text-decoration: none;
+    line-height: 1.2;
+    transition:
+      transform 120ms ease,
+      background 120ms ease,
+      border-color 120ms ease;
+  }
+
+  .glossary-portal-cta:hover{
+    transform: translateY(-1px);
+    background: rgba(127,127,127,0.08);
+    border-color: rgba(0,217,255,0.18);
+    text-decoration: none;
+  }
+
+  .glossary-portal-cta:focus-visible{
+    outline: 2px solid rgba(0,217,255,0.28);
+    outline-offset: 3px;
+  }
+
+  @media (max-width: 760px){
+    .glossary-portal-cta{
+      min-height: 36px;
+      padding: 6px 12px;
+      font-size: 12px;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-portal-cta{
+      min-height: 32px;
+      padding: 5px 10px;
+      font-size: 11px;
+    }
+  }
+</style>

src/components/GlossaryPortalGrid.astro

@@ -0,0 +1,118 @@
+---
+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: 12px;
+    margin-top: 12px;
+  }
+
+  .glossary-portal-card{
+    display: flex;
+    flex-direction: column;
+    gap: 7px;
+    padding: 14px 15px;
+    border: 1px solid var(--glossary-border);
+    border-radius: 16px;
+    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.04rem;
+    line-height: 1.24;
+  }
+
+  .glossary-portal-card span{
+    color: inherit;
+    font-size: .98rem;
+    line-height: 1.46;
+    opacity: .94;
+  }
+
+  .glossary-portal-card small{
+    color: var(--glossary-accent);
+    font-size: .9rem;
+    line-height: 1.28;
+    opacity: .9;
+  }
+
+  @media (max-width: 760px){
+    .glossary-portals{
+      grid-template-columns: 1fr;
+      gap: 10px;
+      margin-top: 10px;
+    }
+
+    .glossary-portal-card{
+      padding: 12px 12px;
+      border-radius: 14px;
+      gap: 6px;
+    }
+
+    .glossary-portal-card strong{
+      font-size: .98rem;
+    }
+
+    .glossary-portal-card span{
+      font-size: .94rem;
+      line-height: 1.42;
+    }
+
+    .glossary-portal-card small{
+      font-size: .85rem;
+    }
+  }
+
+  @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,260 @@
+---
+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 = "70ch",
+  followIntroMaxWidth = "62ch",
+  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-secondary-max-h:${moreMaxHeight};`}
+>
+  <p class="glossary-portal-hero__kicker">{kicker}</p>
+
+  <h1>{title}</h1>
+
+  <p class="glossary-portal-hero__intro glossary-portal-hero__intro--lead">
+    {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 glossary-portal-hero__intro--more">
+            {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: var(--glossary-sticky-top);
+    z-index: 12;
+    margin-bottom: var(--portal-hero-margin-bottom, 28px);
+    padding:
+      var(--portal-hero-pad-top, 20px)
+      var(--portal-hero-pad-x, 18px)
+      var(--portal-hero-pad-bottom, 22px);
+    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(980px 260px at 18% 0%, rgba(0,217,255,0.08), transparent 60%);
+    backdrop-filter: blur(10px);
+    -webkit-backdrop-filter: blur(10px);
+    display: grid;
+    row-gap: var(--portal-hero-gap, 16px);
+    min-width: 0;
+    overflow: hidden;
+    transition:
+      background 280ms cubic-bezier(.22,.8,.22,1),
+      border-color 220ms cubic-bezier(.22,.8,.22,1),
+      box-shadow 220ms cubic-bezier(.22,.8,.22,1),
+      border-radius 220ms ease,
+      padding 220ms ease,
+      row-gap 220ms ease,
+      margin-bottom 220ms ease;
+    box-shadow:
+      inset 0 1px 0 rgba(255,255,255,0.02),
+      0 10px 26px rgba(0,0,0,0.08);
+  }
+
+  .glossary-portal-hero__kicker{
+    margin: 0;
+    font-size: var(--portal-kicker-size, 12px);
+    line-height: var(--portal-kicker-lh, 1.2);
+    letter-spacing: var(--portal-kicker-spacing, .14em);
+    text-transform: uppercase;
+    font-weight: 650;
+    opacity: .74;
+  }
+
+  .glossary-portal-hero h1{
+    margin: 0;
+    font-size: var(--portal-hero-h1-size, clamp(3rem, 4.8vw, 4.15rem));
+    line-height: var(--portal-hero-h1-lh, .98);
+    letter-spacing: var(--portal-hero-h1-spacing, -.045em);
+    font-weight: 850;
+    text-wrap: balance;
+    transition:
+      font-size 180ms ease,
+      line-height 180ms ease,
+      letter-spacing 180ms ease;
+  }
+
+  .glossary-portal-hero__intro{
+    margin: 0;
+    max-width: var(--portal-hero-intro-max-w, 70ch);
+    font-size: var(--portal-hero-intro-size, 1.06rem);
+    line-height: var(--portal-hero-intro-lh, 1.6);
+    text-wrap: pretty;
+    transition:
+      font-size 180ms ease,
+      line-height 180ms ease,
+      max-width 180ms ease,
+      opacity 180ms ease;
+  }
+
+  .glossary-portal-hero__intro--lead{ opacity: .95; }
+  .glossary-portal-hero__intro--more{ opacity: .89; }
+
+  .glossary-portal-hero__collapsible{
+    display: grid;
+    row-gap: 8px;
+    min-width: 0;
+  }
+
+  .glossary-portal-hero__more{
+    display: grid;
+    gap: 12px;
+    max-height: var(--portal-hero-secondary-max-h, 20em);
+    overflow: hidden;
+    opacity: var(--portal-hero-secondary-opacity, .92);
+    min-width: 0;
+    transition:
+      max-height 220ms ease,
+      opacity 180ms ease;
+  }
+
+  .glossary-portal-hero__toggle{
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: fit-content;
+    min-height: 34px;
+    padding: 5px 0;
+    border: 0;
+    border-radius: 0;
+    background: transparent;
+    color: inherit;
+    font-size: 12.5px;
+    line-height: 1.2;
+    letter-spacing: .01em;
+    opacity: .72;
+    cursor: pointer;
+    text-decoration: underline;
+    text-decoration-thickness: 1px;
+    text-underline-offset: 2px;
+    transition:
+      opacity 120ms ease,
+      transform 120ms ease;
+  }
+
+  .glossary-portal-hero__toggle:hover{
+    opacity: .92;
+    transform: translateY(-1px);
+  }
+
+  .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: 980px){
+    .glossary-portal-hero{
+      border-radius: 24px;
+    }
+
+    .glossary-portal-hero h1{
+      text-wrap: pretty;
+    }
+
+    .glossary-portal-hero__more{
+      gap: 10px;
+    }
+  }
+
+  @media (max-width: 860px){
+    .glossary-portal-hero{
+      position: static !important;
+      top: auto !important;
+      z-index: auto !important;
+      margin-bottom: 18px !important;
+      width: 100% !important;
+      max-width: 100% !important;
+      min-width: 0 !important;
+    }
+
+    .glossary-portal-hero h1,
+    .glossary-portal-hero__intro,
+    .glossary-portal-hero__more,
+    .glossary-portal-hero__collapsible{
+      min-width: 0 !important;
+      max-width: 100% !important;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-portal-hero{
+      position: static !important;
+      top: auto !important;
+      z-index: auto !important;
+      margin-bottom: 14px !important;
+      width: 100% !important;
+      max-width: 100% !important;
+      min-width: 0 !important;
+      border-radius: 16px !important;
+    }
+
+    .glossary-portal-hero h1,
+    .glossary-portal-hero__intro,
+    .glossary-portal-hero__more,
+    .glossary-portal-hero__collapsible{
+      min-width: 0 !important;
+      max-width: 100% !important;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-hero{
+      box-shadow:
+        inset 0 1px 0 rgba(255,255,255,0.02),
+        0 14px 34px rgba(0,0,0,0.16);
+    }
+  }
+</style>

src/components/GlossaryPortalPanel.astro

@@ -0,0 +1,127 @@
+---
+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: 10px;
+  }
+
+  .glossary-portal-panel--surface{
+    padding:
+      var(--portal-panel-pad-y, 16px)
+      var(--portal-panel-pad-x, 16px);
+    border: 1px solid var(--glossary-border, rgba(127,127,127,0.18));
+    border-radius: var(--portal-panel-radius, 18px);
+    background:
+      var(--glossary-bg-soft, rgba(127,127,127,0.035));
+  }
+
+  .glossary-portal-panel__head{
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 10px;
+    flex-wrap: wrap;
+  }
+
+  .glossary-portal-panel__head h3{
+    margin: 0;
+    font-size: var(--portal-local-h3-size, clamp(1.35rem, 2vw, 1.7rem));
+    line-height: var(--portal-local-h3-lh, 1.15);
+    letter-spacing: -.02em;
+  }
+
+  .glossary-portal-panel__count{
+    display: inline-flex;
+    align-items: center;
+    min-height: 26px;
+    padding: 0 9px;
+    border: 1px solid rgba(127,127,127,0.20);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.04);
+    font-size: 11.5px;
+    line-height: 1.2;
+    opacity: .8;
+    white-space: nowrap;
+  }
+
+  .glossary-portal-panel__intro{
+    margin: 0;
+    font-size: var(--portal-card-text-size, 14px);
+    line-height: var(--portal-card-text-lh, 1.45);
+    opacity: .92;
+  }
+
+  @media (max-width: 760px){
+    .glossary-portal-panel{
+      gap: 8px;
+    }
+
+    .glossary-portal-panel__head{
+      gap: 8px;
+    }
+
+    .glossary-portal-panel__count{
+      min-height: 23px;
+      padding: 0 8px;
+      font-size: 10.5px;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-portal-panel{
+      gap: 6px;
+    }
+
+    .glossary-portal-panel__head{
+      gap: 6px;
+    }
+
+    .glossary-portal-panel__count{
+      min-height: 21px;
+      padding: 0 7px;
+      font-size: 10px;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-portal-panel--surface{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossaryPortalSection.astro

@@ -0,0 +1,143 @@
+---
+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: 30px;
+  }
+
+  .glossary-portal-section h2{
+    margin: 0;
+    font-size: clamp(1.8rem, 3vw, 2.35rem);
+    line-height: 1.05;
+    letter-spacing: -.03em;
+    font-weight: 800;
+  }
+
+  .glossary-portal-section__head{
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 12px;
+    flex-wrap: wrap;
+    margin-bottom: 10px;
+  }
+
+  .glossary-portal-section__count{
+    display: inline-flex;
+    align-items: center;
+    min-height: 28px;
+    padding: 0 10px;
+    border: 1px solid rgba(127,127,127,0.20);
+    border-radius: 999px;
+    background: rgba(127,127,127,0.04);
+    font-size: 12px;
+    line-height: 1.2;
+    opacity: .8;
+    white-space: nowrap;
+  }
+
+  .glossary-portal-section__intro{
+    margin: 0;
+    max-width: 76ch;
+    font-size: var(--portal-body-size, 1rem);
+    line-height: var(--portal-body-lh, 1.55);
+    opacity: .94;
+  }
+
+  .glossary-portal-section--final{
+    margin-top: 34px;
+  }
+
+  @media (max-width: 980px){
+    .glossary-portal-section{
+      margin-top: 24px;
+    }
+
+    .glossary-portal-section h2{
+      font-size: clamp(1.6rem, 4.4vw, 2rem);
+      line-height: 1.04;
+    }
+  }
+
+  @media (max-width: 760px){
+    .glossary-portal-section{
+      margin-top: 20px;
+    }
+
+    .glossary-portal-section__head{
+      gap: 8px;
+      margin-bottom: 8px;
+    }
+
+    .glossary-portal-section h2{
+      font-size: clamp(1.34rem, 6.5vw, 1.72rem);
+      line-height: 1.04;
+      letter-spacing: -.022em;
+    }
+
+    .glossary-portal-section__count{
+      min-height: 24px;
+      padding: 0 8px;
+      font-size: 11px;
+    }
+
+    .glossary-portal-section--final{
+      margin-top: 24px;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    .glossary-portal-section{
+      margin-top: 16px;
+    }
+
+    .glossary-portal-section__head{
+      gap: 6px;
+      margin-bottom: 6px;
+    }
+
+    .glossary-portal-section h2{
+      font-size: clamp(1.12rem, 4.2vw, 1.34rem);
+      line-height: 1.02;
+    }
+
+    .glossary-portal-section__count{
+      min-height: 22px;
+      padding: 0 7px;
+      font-size: 10px;
+    }
+
+    .glossary-portal-section--final{
+      margin-top: 18px;
+    }
+  }
+</style>

src/components/GlossaryPortalStickySync.astro

@@ -0,0 +1,487 @@
+---
+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 CONDENSED_CLASS = "glossary-portal-hero-condensed";
+
+      const mqMobile = window.matchMedia(`(max-width: ${mobileBreakpoint}px)`);
+      const mqSmallLandscape = window.matchMedia(
+        "(orientation: landscape) and (max-width: 920px) and (max-height: 520px)"
+      );
+
+      let expandedAtY = null;
+      let lastScrollY = window.scrollY || 0;
+      let raf = 0;
+      let lastFollowOn = null;
+      let lastCondensed = null;
+      let lastHeroHeight = -1;
+
+      body.classList.add(BODY_CLASS);
+
+      const isCompactViewport = () =>
+        mqMobile.matches || mqSmallLandscape.matches;
+
+      const stripLocalSticky = () => {
+        document.querySelectorAll(sectionHeadSelector).forEach((el) => {
+          el.classList.remove("is-sticky");
+          el.removeAttribute("data-sticky-active");
+        });
+      };
+
+      const readStickyTop = () => {
+        const raw = getComputedStyle(document.documentElement)
+          .getPropertyValue("--glossary-sticky-top")
+          .trim();
+        const n = Number.parseFloat(raw);
+        return Number.isFinite(n) ? n : 64;
+      };
+
+      const computeFollowOn = () =>
+        !isCompactViewport() &&
+        follow.classList.contains("is-on") &&
+        follow.style.display !== "none" &&
+        follow.getAttribute("aria-hidden") !== "true";
+
+      const computeCondensed = () => {
+        if (isCompactViewport()) return false;
+
+        const heroRect = hero.getBoundingClientRect();
+        const stickyTop = readStickyTop();
+
+        return heroRect.top <= stickyTop + 2;
+      };
+
+      const measureHeroHeight = () =>
+        Math.max(0, Math.round(hero.getBoundingClientRect().height || 0));
+
+      const PIN_EPS = 3;
+
+      const isHeroPinned = () => {
+        if (isCompactViewport()) return false;
+
+        const rect = hero.getBoundingClientRect();
+        const stickyTop = readStickyTop();
+        const cs = getComputedStyle(hero);
+
+        if (cs.position !== "sticky") return false;
+
+        const pinnedOnRail = Math.abs(rect.top - stickyTop) <= PIN_EPS;
+        const stillVisible = rect.bottom > stickyTop + 24;
+
+        return pinnedOnRail && stillVisible;
+      };
+
+      const applyLocalStickyHeight = () => {
+        const h = isHeroPinned() ? measureHeroHeight() : 0;
+        if (h === lastHeroHeight) return;
+        lastHeroHeight = 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) {
+          lastFollowOn = on;
+          body.classList.toggle(FOLLOW_ON_CLASS, on);
+        }
+
+        return on;
+      };
+
+      const syncCondensedState = () => {
+        const condensed = computeCondensed();
+
+        if (condensed !== lastCondensed) {
+          lastCondensed = condensed;
+          body.classList.toggle(CONDENSED_CLASS, condensed);
+        }
+
+        return condensed;
+      };
+
+      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 = (condensed) => {
+        const expanded = body.classList.contains(EXPANDED_CLASS);
+        const collapsed = condensed && !expanded;
+
+        if (isCompactViewport() || !condensed) {
+          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 (isCompactViewport()) {
+          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();
+
+        if (isCompactViewport()) {
+          body.classList.remove(FOLLOW_ON_CLASS);
+          body.classList.remove(CONDENSED_CLASS);
+          body.classList.remove(EXPANDED_CLASS);
+
+          lastFollowOn = false;
+          lastCondensed = false;
+          expandedAtY = null;
+
+          if (heroMore) {
+            heroMore.setAttribute("aria-hidden", "false");
+          }
+
+          if (heroToggle) {
+            heroToggle.hidden = true;
+            heroToggle.setAttribute("aria-expanded", "false");
+          }
+
+          requestAnimationFrame(() => {
+            applyLocalStickyHeight();
+            try {
+              window.__archiUpdateFollow?.();
+            } catch {}
+          });
+
+          return;
+        }
+
+        const condensed = syncCondensedState();
+        syncHeroState(condensed);
+
+        requestAnimationFrame(() => {
+          applyLocalStickyHeight();
+          syncFollowState();
+          try {
+            window.__archiUpdateFollow?.();
+          } catch {}
+        });
+
+        requestAnimationFrame(() => {
+          applyLocalStickyHeight();
+          try {
+            window.__archiUpdateFollow?.();
+          } catch {}
+        });
+      };
+
+      const schedule = () => {
+        if (raf) return;
+        raf = requestAnimationFrame(() => {
+          raf = 0;
+          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);
+      }
+
+      if (mqSmallLandscape.addEventListener) {
+        mqSmallLandscape.addEventListener("change", schedule);
+      } else if (mqSmallLandscape.addListener) {
+        mqSmallLandscape.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;
+  }
+
+  /* Le hero se condense dès qu’il devient sticky */
+  :global(body.is-glossary-portal-page.glossary-portal-hero-condensed .glossary-portal-hero){
+    padding:
+      var(--portal-hero-pad-top-condensed, 14px)
+      var(--portal-hero-pad-x-condensed, 16px)
+      var(--portal-hero-pad-bottom-condensed, 16px);
+    row-gap: var(--portal-hero-gap-condensed, 10px);
+    box-shadow:
+      inset 0 1px 0 rgba(255,255,255,0.02),
+      0 8px 20px rgba(0,0,0,0.12);
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-hero-condensed .glossary-portal-hero h1){
+    font-size: var(--portal-hero-h1-size-condensed, clamp(2.05rem, 3.15vw, 2.7rem));
+    line-height: var(--portal-hero-h1-lh-condensed, 1);
+    letter-spacing: var(--portal-hero-h1-spacing-condensed, -.04em);
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-hero-condensed .glossary-portal-hero__intro){
+    max-width: var(--portal-hero-follow-intro-max-w, 62ch);
+    font-size: var(--portal-hero-intro-size-condensed, .98rem);
+    line-height: var(--portal-hero-intro-lh-condensed, 1.46);
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-hero-condensed .glossary-portal-hero__kicker){
+    opacity: .68;
+  }
+
+  /* Le more se replie dès l’état condensé */
+  :global(body.is-glossary-portal-page.glossary-portal-hero-condensed: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-hero-condensed:not(.glossary-portal-hero-expanded) .glossary-portal-hero__toggle){
+    display: inline-flex;
+  }
+
+  /* L’accolage hero + follow n’arrive que quand le follow est actif */
+  :global(body.is-glossary-portal-page.glossary-portal-hero-condensed.glossary-portal-follow-on .glossary-portal-hero){
+    margin-bottom: 0;
+    border-bottom-left-radius: 0;
+    border-bottom-right-radius: 0;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on #reading-follow .reading-follow__inner){
+    margin-top: -1px;
+    border-top-left-radius: 0;
+    border-top-right-radius: 0;
+  }
+
+  :global(body.is-glossary-portal-page.glossary-portal-follow-on #reading-follow .rf-h2){
+    letter-spacing: -.02em;
+  }
+
+  :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;
+  }
+
+  @media (max-width: 860px){
+    :global(body.is-glossary-portal-page #reading-follow),
+    :global(body.is-glossary-portal-page #reading-follow .reading-follow__inner){
+      display: none !important;
+      opacity: 0 !important;
+      visibility: hidden !important;
+      pointer-events: none !important;
+    }
+
+    :global(body.is-glossary-portal-page){
+      --followbar-h: 0px !important;
+      --sticky-offset-px: calc(var(--sticky-header-h, 0px) + var(--page-gap, 12px)) !important;
+    }
+
+    :global(body.is-glossary-portal-page .glossary-portal-hero){
+      margin-bottom: var(--portal-hero-margin-bottom, 18px);
+      border-radius: 20px !important;
+      box-shadow: none !important;
+    }
+
+    :global(body.is-glossary-portal-page .glossary-portal-hero__more){
+      max-height: none !important;
+      opacity: 1 !important;
+      overflow: visible !important;
+      pointer-events: auto !important;
+    }
+
+    :global(body.is-glossary-portal-page .glossary-portal-hero__toggle){
+      display: none !important;
+    }
+  }
+
+  @media (orientation: landscape) and (max-width: 920px) and (max-height: 520px){
+    :global(body.is-glossary-portal-page #reading-follow),
+    :global(body.is-glossary-portal-page #reading-follow .reading-follow__inner){
+      display: none !important;
+      opacity: 0 !important;
+      visibility: hidden !important;
+      pointer-events: none !important;
+    }
+
+    :global(body.is-glossary-portal-page){
+      --followbar-h: 0px !important;
+      --sticky-offset-px: calc(var(--sticky-header-h, 0px) + var(--page-gap, 12px)) !important;
+    }
+
+    :global(body.is-glossary-portal-page .glossary-portal-hero){
+      margin-bottom: var(--portal-hero-margin-bottom, 12px);
+      border-radius: 16px !important;
+      box-shadow: none !important;
+    }
+
+    :global(body.is-glossary-portal-page .glossary-portal-hero__more){
+      max-height: none !important;
+      opacity: 1 !important;
+      overflow: visible !important;
+      pointer-events: auto !important;
+    }
+
+    :global(body.is-glossary-portal-page .glossary-portal-hero__toggle){
+      display: none !important;
+    }
+  }
+</style>

src/components/GlossaryRelationCards.astro

@@ -0,0 +1,132 @@
+---
+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: 14px;
+    padding-top: 14px;
+    border-top: 1px solid rgba(127,127,127,0.18);
+  }
+
+  @media (max-width: 760px){
+    .glossary-relations{
+      margin-top: 12px;
+      padding-top: 12px;
+    }
+  }
+
+  .glossary-relations h2{
+    margin: 0 0 12px;
+    font-size: clamp(1.35rem, 3vw, 1.8rem);
+    line-height: 1.08;
+  }
+
+  .glossary-relations-grid{
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 10px;
+  }
+
+  .glossary-relations-card{
+    border: 1px solid rgba(127,127,127,0.20);
+    border-radius: 14px;
+    padding: 12px 13px;
+    background: rgba(127,127,127,0.05);
+  }
+
+  .glossary-relations-card h3{
+    margin: 0 0 8px;
+    font-size: 14px;
+    line-height: 1.3;
+  }
+
+  .glossary-relations-card ul{
+    margin: 0;
+    padding-left: 16px;
+  }
+
+  .glossary-relations-card li{
+    margin-bottom: 7px;
+    font-size: 13.5px;
+    line-height: 1.42;
+  }
+
+  .glossary-relations-card li:last-child{
+    margin-bottom: 0;
+  }
+
+  .glossary-relations-card span{
+    opacity: .88;
+  }
+
+  @media (max-width: 760px){
+    .glossary-relations{
+      margin-top: 18px;
+      padding-top: 12px;
+    }
+
+    .glossary-relations h2{
+      margin-bottom: 10px;
+      font-size: 1.3rem;
+    }
+
+    .glossary-relations-grid{
+      grid-template-columns: 1fr;
+      gap: 8px;
+    }
+
+    .glossary-relations-card{
+      padding: 11px 11px;
+      border-radius: 13px;
+    }
+
+    .glossary-relations-card h3{
+      font-size: 13px;
+      margin-bottom: 7px;
+    }
+
+    .glossary-relations-card li{
+      font-size: 13px;
+      line-height: 1.38;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-relations-card{
+      background: rgba(255,255,255,0.04);
+    }
+  }
+</style>

src/components/GlossarySmartNav.astro

@@ -0,0 +1,307 @@
+---
+import type { GlossarySmartNavigation } from "../lib/glossary";
+import { hrefOfGlossaryEntry } from "../lib/glossary";
+
+interface Props {
+  smartNavigation?: GlossarySmartNavigation;
+}
+
+const { smartNavigation } = Astro.props;
+
+const hasPrimary = Boolean(smartNavigation?.primaryNext);
+const paths = smartNavigation?.paths ?? [];
+const flows = smartNavigation?.flows ?? [];
+const hasPaths = paths.length > 0;
+const hasFlows = flows.length > 0;
+---
+
+{(hasPrimary || hasPaths || hasFlows) && (
+  <section class="glossary-smart-nav" aria-label="Navigation guidée du glossaire">
+    <div class="glossary-smart-nav__eyebrow">Explorer les prolongements</div>
+
+    {smartNavigation?.primaryNext && (
+      <div class="glossary-smart-nav__primary">
+        <span class="glossary-smart-nav__label">Étape suivante</span>
+        <a href={hrefOfGlossaryEntry(smartNavigation.primaryNext)}>
+          {smartNavigation.primaryNext.data.term}
+        </a>
+
+        {smartNavigation.primaryReason && (
+          <p>{smartNavigation.primaryReason}</p>
+        )}
+      </div>
+    )}
+
+    {hasFlows && (
+    <div class="glossary-smart-nav__flows" aria-label="Parcours contextuels">
+        <span class="glossary-smart-nav__label">Parcours contextuels</span>
+
+        <div class="glossary-smart-nav__flow-list">
+        {flows.map((flow) => (
+            flow.primaryNext && (
+            <a class="glossary-smart-nav__flow" href={hrefOfGlossaryEntry(flow.primaryNext)}>
+                <span class="glossary-smart-nav__flow-label">{flow.label}</span>
+                <strong>{flow.primaryNext.data.term}</strong>
+                {flow.primaryReason && <span>{flow.primaryReason}</span>}
+            </a>
+            )
+        ))}
+        </div>
+    </div>
+    )}
+
+    {hasPaths && (
+      <div class="glossary-smart-nav__paths" aria-label="Parcours de lecture">
+        {paths.map((path) => {
+          const panelId = `smart-nav-${path.key}`;
+
+          return (
+            <div class="glossary-smart-nav__path">
+              <button
+                class="glossary-smart-nav__path-button"
+                type="button"
+                aria-expanded="false"
+                aria-controls={panelId}
+              >
+                <span>{path.label}</span>
+                <span class="glossary-smart-nav__chevron" aria-hidden="true">▾</span>
+              </button>
+
+              <ul id={panelId} class="glossary-smart-nav__path-panel" hidden>
+                {path.entries.map((entry) => (
+                  <li>
+                    <a href={hrefOfGlossaryEntry(entry)}>{entry.data.term}</a>
+                  </li>
+                ))}
+              </ul>
+            </div>
+          );
+        })}
+      </div>
+    )}
+  </section>
+)}
+
+<style>
+  .glossary-smart-nav{
+    margin: 14px 0 18px;
+    padding: 14px;
+    border: 1px solid rgba(127,127,127,0.20);
+    border-radius: 18px;
+    background: rgba(127,127,127,0.045);
+  }
+
+  .glossary-smart-nav__primary{
+    display: grid;
+    gap: 5px;
+    margin-bottom: 10px;
+  }
+
+  .glossary-smart-nav__label{
+    font-size: 13px;
+    font-weight: 800;
+    opacity: .76;
+  }
+
+  .glossary-smart-nav__primary a{
+    width: fit-content;
+    font-size: clamp(1.05rem, 2vw, 1.22rem);
+    font-weight: 900;
+    line-height: 1.18;
+    text-decoration: none;
+  }
+
+  .glossary-smart-nav__primary p{
+    max-width: 72ch;
+    margin: 0;
+    font-size: 14px;
+    line-height: 1.45;
+    opacity: .88;
+  }
+
+  .glossary-smart-nav__paths{
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-start;
+    gap: 8px;
+    margin-top: 12px;
+    }
+
+  .glossary-smart-nav__path{
+    align-self: flex-start;
+    min-width: min(180px, 100%);
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 14px;
+    background: rgba(127,127,127,0.035);
+    overflow: hidden;
+  }
+
+  .glossary-smart-nav__path-button{
+    width: 100%;
+    border: 1px solid rgba(127,127,127,0.18);
+    background: rgba(127,127,127,0.06);
+    color: inherit;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    padding: 8px 12px;
+    cursor: pointer;
+    font: inherit;
+    font-size: 13px;
+    font-weight: 850;
+    line-height: 1.25;
+    text-align: left;
+    user-select: none;
+    border-radius: 999px;
+  }
+
+  .glossary-smart-nav__path-button:hover{
+    background: rgba(127,127,127,0.10);
+  }
+
+  .glossary-smart-nav__path-button:active{
+    transform: scale(0.98);
+  }
+
+  .glossary-smart-nav__chevron{
+    flex: 0 0 auto;
+    font-size: 13px;
+    line-height: 1;
+    opacity: .72;
+    transform: rotate(0deg);
+    transition: transform 160ms ease, opacity 160ms ease;
+  }
+
+  .glossary-smart-nav__path-button[aria-expanded="true"] .glossary-smart-nav__chevron{
+    transform: rotate(180deg);
+    opacity: .96;
+  }
+
+  .glossary-smart-nav__path-panel{
+    margin: 0;
+    padding: 0 11px 10px 24px;
+  }
+
+  .glossary-smart-nav__path-panel[hidden]{
+    display: none;
+  }
+
+  .glossary-smart-nav__path-panel li{
+    margin: 5px 0;
+    font-size: 13px;
+    line-height: 1.32;
+  }
+
+  .glossary-smart-nav__path-panel a{
+    text-decoration: none;
+  }
+
+  .glossary-smart-nav__flows{
+    display: grid;
+    gap: 8px;
+    margin-top: 12px;
+    margin-bottom: 6px;
+  }
+  
+  .glossary-smart-nav__flow-list{
+    display: grid;
+    gap: 8px;
+  }
+
+  .glossary-smart-nav__flow{
+    display: grid;
+    gap: 3px;
+    padding: 10px 11px;
+    border: 1px solid rgba(127,127,127,0.18);
+    border-radius: 14px;
+    background: rgba(127,127,127,0.035);
+    text-decoration: none;
+  }
+
+  .glossary-smart-nav__flow-label{
+    font-size: 12px;
+    font-weight: 850;
+    letter-spacing: .04em;
+    text-transform: uppercase;
+    opacity: .72;
+  }
+
+  .glossary-smart-nav__flow strong{
+    font-size: 14px;
+    line-height: 1.25;
+  }
+
+  .glossary-smart-nav__flow span:last-child{
+    font-size: 13px;
+    line-height: 1.35;
+    opacity: .84;
+  }
+
+  .glossary-smart-nav__eyebrow{
+    margin-bottom: 8px;
+    font-size: 12px;
+    font-weight: 850;
+    letter-spacing: .08em; /* légèrement augmenté */
+    text-transform: uppercase;
+    opacity: .78; /* un poil plus visible */
+  }
+
+  @media (max-width: 760px){
+    .glossary-smart-nav{
+      margin: 12px 0 16px;
+      padding: 12px;
+      border-radius: 16px;
+    }
+
+    .glossary-smart-nav__paths{
+      display: grid;
+      grid-template-columns: 1fr;
+      gap: 7px;
+    }
+
+    .glossary-smart-nav__path{
+      width: 100%;
+    }
+  }
+
+  @media (prefers-color-scheme: dark){
+    .glossary-smart-nav{
+      background: rgba(255,255,255,0.04);
+    }
+
+    .glossary-smart-nav__path{
+      background: rgba(255,255,255,0.035);
+    }
+
+    .glossary-smart-nav__flow{
+      background: rgba(255,255,255,0.035);
+    }
+  }
+</style>
+
+<script is:inline>
+  (() => {
+    document.querySelectorAll(".glossary-smart-nav").forEach((nav) => {
+      nav
+        .querySelectorAll(".glossary-smart-nav__path-button")
+        .forEach((button) => {
+          button.addEventListener("click", () => {
+            const panelId = button.getAttribute("aria-controls");
+            const panel = panelId ? document.getElementById(panelId) : null;
+            if (!panel || !nav.contains(panel)) return;
+
+            const expanded = button.getAttribute("aria-expanded") === "true";
+            const nextExpanded = !expanded;
+
+            button.setAttribute("aria-expanded", nextExpanded ? "true" : "false");
+            panel.hidden = !nextExpanded;
+
+            button
+              .closest(".glossary-smart-nav__path")
+              ?.classList.toggle("is-open", nextExpanded);
+          });
+        });
+    });
+  })();
+</script>

src/components/LevelToggle.astro

@@ -68,7 +68,6 @@ const { initialLevel = 1 } = Astro.props;
     } catch {}
   }
 
-  // init : storage > initialLevel
   let start = clampLevel(initialLevel);
   try {
     const stored = localStorage.getItem(KEY);
@@ -77,13 +76,11 @@ const { initialLevel = 1 } = Astro.props;
 
   applyLevel(start, { persist: false });
 
-  // clicks
   wrap.addEventListener("click", (ev) => {
     const btn = ev.target?.closest?.("button[data-level]");
     if (!btn) return;
     ev.preventDefault();
 
-    // ✅ crucial : on capture la position AVANT le reflow lié au changement de niveau
     captureBeforeLevelSwitch();
     applyLevel(btn.dataset.level);
   });
@@ -95,6 +92,8 @@ const { initialLevel = 1 } = Astro.props;
     display: inline-flex;
     gap: 8px;
     align-items: center;
+    flex-wrap: wrap;
+    max-width: 100%;
   }
 
   .level-btn{
@@ -106,6 +105,7 @@ const { initialLevel = 1 } = Astro.props;
     cursor: pointer;
     user-select: none;
     transition: filter .12s ease, transform .12s ease, background .12s ease, border-color .12s ease;
+    white-space: nowrap;
   }
 
   .level-btn:hover{
@@ -125,4 +125,21 @@ const { initialLevel = 1 } = Astro.props;
   .level-btn:active{
     transform: translateY(1px);
   }
-</style>
+
+  @media (max-width: 980px){
+    .level-toggle{
+      gap: 6px;
+    }
+
+    .level-btn{
+      padding: 5px 9px;
+      font-size: 12px;
+    }
+  }
+
+  @media (max-width: 760px){
+    .level-toggle{
+      display: none;
+    }
+  }
+</style>

src/components/LocalToc.astro

@@ -3,49 +3,128 @@ const { headings } = Astro.props;
 
 // H2/H3 seulement
 const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
+const tocId = `toc-local-${Math.random().toString(36).slice(2, 9)}`;
 ---
 
 {items.length > 0 && (
-  <nav class="toc-local" aria-label="Dans ce chapitre">
-    <div class="toc-local__title">Dans ce chapitre</div>
+  <nav class="toc-local" aria-label="Dans ce chapitre" data-toc-local data-mobile-default="closed">
+    <button
+      class="toc-local__head toc-local__toggle"
+      type="button"
+      aria-expanded="false"
+      aria-controls={tocId}
+    >
+      <span class="toc-local__title">Dans ce chapitre</span>
+      <span class="toc-local__chevron" aria-hidden="true">▾</span>
+    </button>
 
-    <ol class="toc-local__list">
-      {items.map((h) => (
-        <li
-          class={`toc-local__item d${h.depth}`}
-          data-toc-item
-          data-depth={h.depth}
-          data-id={h.slug}
-        >
-          <a href={`#${h.slug}`} data-toc-link data-slug={h.slug}>
-            {h.text}
-          </a>
-        </li>
-      ))}
-    </ol>
+    <div class="toc-local__body-clip" id={tocId} hidden>
+      <div class="toc-local__body">
+        <ol class="toc-local__list">
+          {items.map((h) => (
+            <li
+              class={`toc-local__item d${h.depth}`}
+              data-toc-item
+              data-depth={h.depth}
+              data-id={h.slug}
+            >
+              <a href={`#${h.slug}`} data-toc-link data-slug={h.slug}>
+                <span class="toc-local__mark" aria-hidden="true"></span>
+                <span class="toc-local__text">{h.text}</span>
+              </a>
+            </li>
+          ))}
+        </ol>
+      </div>
+    </div>
   </nav>
 )}
 
 <script is:inline>
 (() => {
   function init() {
-    const toc = document.querySelector(".toc-local");
-    if (!toc) return;
+    const toc = document.querySelector(".toc-local[data-toc-local]");
+    if (!toc || toc.dataset.tocReady === "1") return;
+    toc.dataset.tocReady = "1";
+
+    const toggle = toc.querySelector(".toc-local__toggle");
+    const bodyClip = toc.querySelector(".toc-local__body-clip");
+    const mq = window.matchMedia("(max-width: 980px)");
+    const KEY = `archicratie:toc-local:${window.location.pathname}`;
+
+    if (!toggle || !bodyClip) return;
+
+    const readState = () => {
+      try {
+        const v = localStorage.getItem(KEY);
+        if (v === "open") return true;
+        if (v === "closed") return false;
+      } catch {}
+      return null;
+    };
+
+    const writeState = (open) => {
+      try { localStorage.setItem(KEY, open ? "open" : "closed"); } catch {}
+    };
+
+    const setOpen = (open, { persist = true, emit = true } = {}) => {
+      const isMobile = mq.matches;
+      const effectiveOpen = isMobile ? open : true;
+
+      toc.classList.toggle("is-collapsed", isMobile && !effectiveOpen);
+      toggle.setAttribute("aria-expanded", effectiveOpen ? "true" : "false");
+
+      if (bodyClip) {
+        bodyClip.hidden = isMobile && !effectiveOpen;
+      }
+
+      if (persist && isMobile) writeState(effectiveOpen);
+
+      if (emit && effectiveOpen && isMobile) {
+        window.dispatchEvent(new CustomEvent("archicratie:tocLocalOpen"));
+      }
+    };
+
+    const initAccordion = () => {
+      if (!mq.matches) {
+        setOpen(true, { persist: false, emit: false });
+        return;
+      }
+      const stored = readState();
+      setOpen(stored == null ? false : stored, { persist: false, emit: false });
+    };
+
+    toggle.addEventListener("click", () => {
+      const next = toggle.getAttribute("aria-expanded") !== "true";
+      setOpen(next);
+    });
+
+    if (mq.addEventListener) {
+      mq.addEventListener("change", initAccordion);
+    } else if (mq.addListener) {
+      mq.addListener(initAccordion);
+    }
 
     const itemEls = Array.from(toc.querySelectorAll("[data-toc-item]"));
-    if (!itemEls.length) return;
+    if (!itemEls.length) {
+      initAccordion();
+      return;
+    }
 
     const ordered = itemEls
       .map((li) => {
         const a = li.querySelector("a[data-toc-link]");
         const id = li.getAttribute("data-id") || a?.dataset.slug || "";
         const depth = Number(li.getAttribute("data-depth") || "0");
-        const el = id ? document.getElementById(id) : null; // span.details-anchor OU h3[id]
+        const el = id ? document.getElementById(id) : null;
         return (a && id && el) ? { id, depth, li, a, el } : null;
       })
       .filter(Boolean);
 
-    if (!ordered.length) return;
+    if (!ordered.length) {
+      initAccordion();
+      return;
+    }
 
     const clear = () => {
       for (const t of ordered) {
@@ -55,14 +134,29 @@ const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
     };
 
     const openDetailsIfNeeded = (el) => {
-      const d = el?.closest?.("details");
-      if (d && !d.open) d.open = true;
+      try {
+        if (!el) return;
+
+        let d = el.closest?.("details") || null;
+
+        if (!d && el.classList?.contains("details-anchor")) {
+          const n = el.nextElementSibling;
+          if (n && n.tagName === "DETAILS") d = n;
+        }
+
+        if (!d) {
+          const s = el.closest?.("summary");
+          if (s && s.parentElement && s.parentElement.tagName === "DETAILS") d = s.parentElement;
+        }
+
+        if (d && d.tagName === "DETAILS" && !d.open) d.open = true;
+      } catch {}
     };
 
     let current = "";
 
-    const setCurrent = (id) => {
-      if (!id || id === current) return;
+    const setCurrent = (id, { autoOpen = true } = {}) => {
+      if (!id) return;
       const t = ordered.find((x) => x.id === id);
       if (!t) return;
 
@@ -74,17 +168,22 @@ const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
       t.a.setAttribute("aria-current", "true");
       t.li.classList.add("is-current");
 
-      // ✅ IMPORTANT: plus de scrollIntoView ici
-      // sinon ça scroll l'aside pendant le scroll du reading => TOC global “disparaît”.
+      // Sur mobile/tablette, le suivi actif ne doit pas rouvrir automatiquement la TOC.
+      if (!mq.matches && autoOpen && toc.classList.contains("is-collapsed")) {
+        setOpen(true);
+      }
+
+      window.dispatchEvent(
+        new CustomEvent("archicratie:tocLocalActive", { detail: { id } })
+      );
     };
 
     const computeActive = () => {
       const visible = ordered.filter((t) => {
         const d = t.el.closest?.("details");
         if (d && !d.open) {
-          // Si l'élément est dans <summary>, il reste visible même details fermé
           const inSummary = !!t.el.closest?.("summary");
-          if (!inSummary) return false;
+          if (!inSummary && !t.el.classList?.contains("details-anchor")) return false;
         }
         return true;
       });
@@ -102,7 +201,7 @@ const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
       }
 
       if (!best) best = visible[0];
-      setCurrent(best.id);
+      if (best && best.id !== current) setCurrent(best.id, { autoOpen: true });
     };
 
     let ticking = false;
@@ -117,11 +216,14 @@ const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
 
     const syncFromHash = () => {
       const id = (location.hash || "").slice(1);
-      if (!id) { computeActive(); return; }
+      if (!id) {
+        computeActive();
+        return;
+      }
 
       const el = document.getElementById(id);
       if (el) openDetailsIfNeeded(el);
-      setCurrent(id);
+      setCurrent(id, { autoOpen: false });
     };
 
     toc.addEventListener("click", (ev) => {
@@ -133,13 +235,14 @@ const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
       const el = document.getElementById(id);
       if (el) openDetailsIfNeeded(el);
 
-      setCurrent(id);
+      setCurrent(id, { autoOpen: true });
     });
 
     window.addEventListener("scroll", onScroll, { passive: true });
     window.addEventListener("resize", onScroll);
     window.addEventListener("hashchange", syncFromHash);
 
+    initAccordion();
     syncFromHash();
     onScroll();
   }
@@ -153,30 +256,187 @@ const items = (headings || []).filter((h) => h.depth >= 2 && h.depth <= 3);
 </script>
 
 <style>
-  .toc-local{margin-top:12px;border:1px solid rgba(127,127,127,.25);border-radius:16px;padding:12px}
-  .toc-local__title{font-size:13px;opacity:.85;margin-bottom:8px}
-
-  .toc-local__list{list-style:none;margin:0;padding:0}
-  .toc-local__item::marker{content:""}
-  .toc-local__item{margin:6px 0}
-  .toc-local__item.d3{margin-left:12px;opacity:.9}
-
-  .toc-local__item.is-current > a{
-    font-weight: 750;
-    text-decoration: underline;
+  .toc-local{
+    margin-top: 12px;
+    border: 1px solid rgba(127,127,127,.25);
+    border-radius: 16px;
+    padding: 12px;
+    background: rgba(127,127,127,0.03);
   }
 
-  .toc-local a{
-    display:inline-block;
-    max-width:100%;
-    text-decoration:none;
+  .toc-local__toggle{
+    width: 100%;
+    appearance: none;
+    border: 0;
+    background: transparent;
+    color: inherit;
+    text-align: left;
+    padding: 0;
+    cursor: pointer;
   }
-  .toc-local a:hover{ text-decoration: underline; }
+
+  .toc-local__head{
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    margin-bottom: 8px;
+  }
+
+  .toc-local__title{
+    font-size: 13px;
+    opacity: .85;
+  }
+
+  .toc-local__chevron{
+    font-size: 12px;
+    opacity: .72;
+    transition: transform 180ms ease;
+  }
+
+  .toc-local__body-clip{
+    display: grid;
+    grid-template-rows: 1fr;
+    transition:
+      grid-template-rows 220ms ease,
+      opacity 160ms ease,
+      margin-top 220ms ease;
+  }
+
+  .toc-local__body{
+    min-height: 0;
+    overflow: hidden;
+  }
+
   .toc-local__list{
+    list-style: none;
+    margin: 0;
+    padding: 0;
     max-height: 44vh;
     overflow: auto;
     padding-right: 8px;
     scrollbar-gutter: stable;
   }
 
-</style>
+  .toc-local__item::marker{ content:""; }
+  .toc-local__item{ margin: 6px 0; }
+
+  .toc-local__item.d3{
+    margin-left: 14px;
+    opacity: .94;
+  }
+
+  .toc-local a{
+    display: grid;
+    grid-template-columns: auto 1fr;
+    gap: 8px;
+    align-items: start;
+    max-width: 100%;
+    text-decoration: none;
+  }
+
+  .toc-local a:hover{
+    text-decoration: none;
+  }
+
+  .toc-local__mark{
+    width: 10px;
+    height: 10px;
+    margin-top: .36em;
+    border-radius: 999px;
+    border: 1px solid rgba(127,127,127,.34);
+    background: transparent;
+    opacity: .68;
+  }
+
+  .toc-local__text{
+    line-height: 1.28;
+  }
+
+  .toc-local__item.is-current > a{
+    font-weight: 760;
+  }
+
+  .toc-local__item.is-current > a .toc-local__mark{
+    background: currentColor;
+    border-color: currentColor;
+    box-shadow: 0 0 0 3px rgba(127,127,127,.10);
+    opacity: 1;
+  }
+
+  @media (max-width: 980px){
+    .toc-local{
+      padding: 10px 12px;
+      border-radius: 14px;
+    }
+
+    .toc-local__head{
+      margin-bottom: 0;
+      min-height: 28px;
+    }
+
+    .toc-local__body-clip{
+      margin-top: 10px;
+    }
+
+    .toc-local.is-collapsed .toc-local__body-clip{
+      grid-template-rows: 0fr;
+      opacity: 0;
+      margin-top: 0;
+    }
+
+    .toc-local__body{
+      min-height: 0;
+      overflow: hidden;
+      transition: opacity 180ms ease;
+    }
+
+    .toc-local.is-collapsed .toc-local__body{
+      opacity: 0;
+    }
+
+    .toc-local.is-collapsed .toc-local__chevron{
+      transform: rotate(-90deg);
+    }
+
+    .toc-local__title{
+      font-size: 13px;
+    }
+
+    .toc-local__list{
+      max-height: min(42vh, 360px);
+      padding-right: 4px;
+    }
+
+    .toc-local__item{
+      margin: 5px 0;
+    }
+
+    .toc-local__item.d2 > a .toc-local__text{
+      font-size: 12.9px;
+      line-height: 1.24;
+      font-weight: 680;
+    }
+
+    .toc-local__item.d3{
+      margin-left: 12px;
+    }
+
+    .toc-local__item.d3 > a .toc-local__text{
+      font-size: 12.1px;
+      line-height: 1.22;
+      opacity: .95;
+    }
+
+    .toc-local__item.d3 > a .toc-local__mark{
+      width: 8px;
+      height: 8px;
+      margin-top: .42em;
+      opacity: .55;
+    }
+
+    .toc-local__body-clip[hidden]{
+      display: none !important;
+    }
+  }
+</style>

src/components/SidePanel.astro

@@ -382,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";
@@ -390,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);

src/components/SiteNav.astro

@@ -1,11 +1,24 @@
+---
+const path = Astro.url.pathname;
+
+const isActive = (href: string) => {
+  if (href === "/") return path === "/";
+  return path === href || path.startsWith(href);
+};
+---
+
 <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="/" aria-current={isActive("/") ? "page" : undefined}>Accueil</a>
+  <span aria-hidden="true"> · </span>
+
+  <a href="/archicrat-ia/" aria-current={isActive("/archicrat-ia/") ? "page" : undefined}>Essai-thèse — ArchiCraT-IA</a>
+  <span aria-hidden="true"> · </span>
+
+  <a href="/cas-ia/" aria-current={isActive("/cas-ia/") ? "page" : undefined}>Cas pratique — Gouvernance IA</a>
+  <span aria-hidden="true"> · </span>
+
+  <a href="/glossaire/" aria-current={isActive("/glossaire/") ? "page" : undefined}>Glossaire</a>
+  <span aria-hidden="true"> · </span>
+
+  <a href="/recherche/" aria-current={isActive("/recherche/") ? "page" : undefined}>Recherche</a>
+</nav>

src/content.config.ts

@@ -0,0 +1,145 @@
+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")])
+  })
+});
+
+const glossaryNavigationFlowSchema = z.object({
+  label: z.string().min(1),
+  primaryNext: z.string().min(1).optional(),
+  primaryReason: z.string().min(1).optional(),
+});
+
+const glossaryNavigationSchema = z.object({
+  primaryNext: z.string().min(1).optional(),
+  primaryReason: z.string().min(1).optional(),
+  paths: z
+    .object({
+      understand: z.array(z.string().min(1)).default([]),
+      deepen: z.array(z.string().min(1)).default([]),
+      compare: z.array(z.string().min(1)).default([]),
+      apply: z.array(z.string().min(1)).default([]),
+    })
+    .default({
+      understand: [],
+      deepen: [],
+      compare: [],
+      apply: [],
+    }),
+  flows: z
+    .record(z.string(), glossaryNavigationFlowSchema)
+    .default({}),
+  relationWeights: z
+    .record(z.string(), z.number().int().nonnegative())
+    .default({}),
+});
+
+// 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",
+      "dispositif-methodologique",
+      "dispositif-documentaire",
+      "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([]),
+    navigation: glossaryNavigationSchema.optional()
+  })
+});
+
+export const collections = {
+  commencer,
+  "archicrat-ia": archicratIa,
+  "cas-ia": casIa,
+  glossaire,
+};

src/content/archicrat-ia/conclusion.mdx

@@ -1,251 +1,417 @@
 ---
-title: "Conclusion — ArchiCraT-IA"
-edition: "archicratie"
-status: "modele_sociopolitique"
+title: Conclusion — ArchiCraT-IA
+edition: archicrat-ia
+status: essai_these
 level: 1
-version: "0.1.0"
+version: 0.1.0
 concepts: []
 links: []
 order: 70
-summary: ""
+summary: ''
 source:
   kind: docx
-  path: "sources/docx/archicrat-ia/Conclusion-Archicrat-IA-version_officielle.docx"
+  path: sources/docx/archicrat-ia/Conclusion-Archicrat-IA-version_officielle.docx
 ---
-Nous n’assistons ni à un retour primordial du désordre ni à une raréfaction du pouvoir. Nous assistons à autre chose, plus discret et plus décisif : la montée en régime d’une régulation sans scène, où la plupart des décisions qui engagent nos vies sont prises et appliquées sans lieu institué d’énonciation, sans temps de différé, sans exposition reconnaissable de leurs auteurs. La conflictualité ne disparaît pas, elle est déportée : reconfigurée en flux, en scores, en interfaces, en procédures qui se présentent comme de simples enchaînements techniques, alors même qu’elles opèrent des choix normatifs massifs.
 
-Ce manque n’est pas un vide. Il ne signifie ni l’absence de normes, ni l’effondrement du pouvoir, mais ce que nous avons appelé, dans cet essai-thèse, une *oblitération archicratique* : le recouvrement progressif de la scène par la seule *cratialité*, c’est-à-dire par des dispositifs d’exécution qui se substituent à la mise en débat des fondements et des effets. Ce n’est pas le pouvoir qui manque, c’est la possibilité de le voir, de le nommer, de l’adresser. La régulation se donne alors comme évidence fonctionnelle, là où elle devrait apparaître comme ce qu’elle est toujours : un ordre situé, contestable et révisable en respect des promesses démocratiques.
-
-La thèse défendue ici n’est pas que toute scène aurait disparu, ni que l’histoire se réduirait à un glissement univoque vers l’automatisation intégrale. Elle est plus précise et plus falsifiable : dans les principaux dispositifs contemporains – sociaux, écologiques, numériques –, les conditions d’existence d’une scène archicrative sont systématiquement affaiblies, fragmentées, reléguées à la marge. Là où l’on pouvait autrefois identifier un lieu, un temps, des personnes et des procédures pour organiser et mettre à l’épreuve les décisions, nous rencontrons désormais, de manière récurrente, des agencements où l’énonciation s’efface derrière la mesure, la simulation, la plateformisation et l’automatisation.
-
-C’est pourquoi nous avons forgé la notion d’*oblitération archicratique* : non pas l’absence de tout recours, mais la tendance structurelle à produire de la norme hors scène, à démultiplier les dispositifs auto-référés – architectures, algorithmes, barèmes, chaînes logistiques – les supports d’une régulation qui se déclare purement opératoire, *autarchicratique*. Cette hypothèse est réfutable : elle serait démentie si l’on observait, de façon durable, que les grandes décisions collectives demeurent adossées à des scènes d’épreuve robustes, effectives, où les fondements et les effets peuvent être mis en discussion. Elle gagnerait, inversement, en pertinence si des enquêtes empiriques mettent en évidence l’inaccessibilité des recours, l’ineffectivité des délibérations politiques, la surdétermination des décisions par des scripts non publics protégés par le droit des affaires.
-
-Dans cette perspective, l’*archicratie* n’est ni un idéal abstrait, ni un type de régime supplémentaire qu’il s’agirait d’ajouter à la liste déjà longue des formes politiques. Elle désigne la *condition minimale pour que la régulation soit habitable* : la possibilité, pour une société, d’instituer et de maintenir un seuil où l’*arcalité* (ce qui fonde et justifie), la *cratialité* (ce qui opère et exécute) et l’*archicration* (ce qui met en épreuve, suspend, requalifie) demeurent distinctes, articulées et exposées. Un ordre est archicratique en ce sens précis : non parce qu’il serait juste ou égalitaire par essence, mais parce qu’il se laisse amener en scène, devant des instances où ses prétentions peuvent être critiquées, ses instruments retravaillés, ses effets révisés.
-
-L’enjeu de cette conclusion est de formuler une hypothèse régulatrice : la *co-viabilité* des collectifs humains et non-humains dépend de la capacité à maintenir, à rouvrir, à inventer des scènes d’épreuve où l’on puisse adresser le pouvoir qui nous affecte. En nommant l’*archicratie*, nous ne sacralisons pas un modèle ; nous désignons un seuil au-dessous duquel la régulation se dégrade en pure opération, et au-dessus duquel elle devient au moins discutable, opposable, révisable, modifiable, différant.
-
-C’est là seulement que prend sens le projet d’une “cinquième révolution régulatrice”. Non pas un nouvel âge d’or, ni une résolution miraculeuse des contradictions, mais un changement de régime dans la manière même de fabriquer la régulation : un tournant où la scène – longtemps tenue pour « simple décor du pouvoir », ou pour « luxe démocratique » – redeviendrait son opérateur central. L’ambition de ce texte n’est pas de prédire cette révolution, et moins encore de la prescrire. Il s’agit de montrer en quel sens elle est pensable, souhaitable, et sous quelles conditions elle pourrait être mise à l’épreuve et mise en pratique.
-
-Ce que nous observons n’est ni une défaillance accidentelle du cadre démocratique, ni une déviation autoritaire des gouvernances contemporaines, mais une mutation profonde des formes de régulation effective qui tendent à se configurer hors-scène démocratique instituée. Dans ce modèle, le pouvoir tend à se déporter hors scène instituée : privatisé, déterritorialisé, encapsulé, automatisé, rendu algorithme, crypté, incompréhensible et incritiquable du fait de sa propre efficacité. Il ne s’explique plus, il fonctionne. Il ne s’adresse plus, il déclenche. Il ne fonde plus, il applique. Et la régulation tend à se déporter hors scène instituée, tandis que persistent des scènes partielles, alternatives ou multilatérales qu’il faut reconnaître et saluer. Que ce soit la méta-fédération des soulèvements de la Terre, ou l’initiative internationale PauseIA, pour ne nommer que ces deux, leurs discours et leurs expertises apportent informations et discernements sur les enjeux écologiques et les développements d’intelligences artificielles.
-
-Le processus est d’autant plus difficile à saisir qu’il est continu, fonctionnel, présenté comme neutre. Les interfaces remplacent les guichets, les tableaux de bord supplantent les délibérations, les retours algorithmiques prennent la place de la justification publique. Le conflit est désamorcé au nom de la fluidité. Le délai est perçu comme dysfonction. L’exposition est dégradée en transparence visuelle sans énoncé.
-
-Le terme d’oblitération archicratique, proposé et conceptualisé dans les chapitres précédents, désigne exactement cette dynamique : une substitution douce, mais décisive, de la scène par l’exécution, du différé par l’automaticité, de l’énonciation par la trace, de l’épreuve par la donnée. Cette oblitération ne se donne pas comme rupture, mais comme évidence : elle agit dans la logique même des dispositifs, dans leur conception, leur design, leur temporalité.
-
-Il faut ici refuser toute simplification. Si la scène instituée se raréfie, des scènes latérales, résiduelles ou émergentes persistent (communautés locales, contre-institutions, pratiques rituelles), il est grand temps de les reconnaître et de les légitimer au lieu de les folkloriser. Ce monde sans scène n’est ni totalement anarchique, ni totalement chaotique, ni même nécessairement injuste dans ses effets immédiats. Il est, en revanche, injustifiable. Il est insoutenable dans le temps, car il est aveugle à sa propre normativité. Il ne dispose d’aucun espace dans lequel ses propres décisions peuvent être rejouées, exposées, interrogées, rediscutées ou reformulées.
-
-Cette régulation sans scène est une régulation sans mémoire, sans récit, sans réversibilité. Elle fonctionne, et souvent très efficacement. Mais elle ne critique rien, ne se confronte à rien, ne se relance jamais à partir de ses propres limites. Elle produit de la norme sans fondement énoncé, du pilotage sans institution, de la gouvernance sans fondation, un pouvoir simulé à tout moment proche du simulacre.
-
-Les conséquences sont majeures. On croit pouvoir protester, mais l’interlocuteur est absent. On tente un recours, mais le délai est dépassé avant même d’avoir commencé. On cherche le fondement d’une décision, mais on ne trouve qu’un critère, un score, une règle d’application sans justification. Derrière la façade d’efficacité, ce qui s’installe, c’est un monde post-scénique, dans lequel les gouvernés n’ont plus d’espace institué pour adresser la régulation qui les constitue.
-
-Ce diagnostic n’est pas une vérité révélée, mais une hypothèse régulatrice : il postule que, dans les principaux dispositifs contemporains (sociaux, écologiques, numériques), l’instance scénique a été reléguée au profit d’une *cratialité autarcique*. Il pourrait être réfuté par des recherches qui montreraient l’inverse, par exemple des domaines où des scènes archicratives fortes subsistent et structurent réellement les décisions. Il serait confirmé, au contraire, par des enquêtes qui objectiveraient l’inaccessibilité des scènes, l’ineffectivité des recours, la pure performativité des algorithmes.
-
-Et c’est précisément là que s’ouvre une nécessité, celle de refonder la scène comme condition première de toute co-viabilité. Une scène véritable : espace différé, public, opposable, fondé — nullement décorative ni consultative. Une scène où la décision peut être relancée. Où le fondement peut être demandé. Où le délai est un droit. Où l’épreuve est reconnue comme condition de la légitimité.
-
-Cette scène, c’est ce que nous avons nommé, construit, modélisé et mis à l’épreuve : l’*archicration*. Et c’est depuis son absence — criante et tout à la fois quasi imperceptible — que la cinquième révolution régulatrice devient pensable et indispensable.
-
-Au seuil d’une ère où la capacité à ordonner, à segmenter, à attribuer ou à refuser se maintient sans que jamais ces gestes soient exposés à une scène d’épreuve instituée, la nécessité d’un concept opératoire, capable de désigner la forme régulatrice minimale d’un monde habitable, s’impose. Ce concept, l’*archicratie*, nous l’avons forgé, au-delà de la nécessité d’invention lexicale, comme condensation critique d’un constat systémique.
-
-L’*archicratie* ne renvoie ni à un type de régime spécifique, ni à une forme de gouvernement, ni même à une institution particulière. Elle ne se laisse classer dans aucune catégorie traditionnelle de la philosophie politique, car elle opère en amont des structures représentatives, et en-deça et au-delà des appareils juridiques. Elle est le mode de consistance scénique d’une régulation soutenable, c’est-à-dire d’un ordre qui accepte d’être mis en épreuve, d’être différé dans son exécution, d’être reconfiguré à partir de sa propre exposition sous critères de viabilité. Il s’agit donc du régime d’apparition du pouvoir fondé, là où une décision peut être tenue, dans le temps et dans l’espace, devant ceux qu’elle affecte, au sein d’une scène constituée pour qu’elle puisse être questionnée, retardée, amendée, voire annulée.
-
-Dans cette perspective, l’*archicratie* n’est ni utopie ni abstraction : elle fixe la condition de viabilité de tout dispositif qui prétend réguler — affecter des conduites, orienter des possibles, ouvrir/fermer des accès — sans se refermer sur une logique exclusivement opératoire. Il ne s’agit pas ici de défendre une figure morale du pouvoir, mais de poser une exigence structurelle : aucune régulation n’est légitime si elle ne peut être exposée à son propre fondement. Et aucune scène d’exposition n’est opérante si elle ne permet pas la convocation des énonciateurs, la traçabilité des instruments, la suspension des effets, la confrontation des justifications et la reconfiguration des décisions.
-
-L’*archicratie* devient ainsi le seuil entre une régulation purement fonctionnelle, capable d’exécuter des procédures, de reproduire des normes, de gérer des flux automatisés et une régulation fondée, visible, opposable, justifiable, révisable — c’est-à-dire co-viable décidée par des humains.
-
-Comme annoncé dans le Prologue, cette conclusion opère la remontée critique à partir des cinq épreuves de notre essai-thèse : (1) l’épreuve de détectabilité des régimes (chapitre 1), (2) l’archéogenèse des formes scéniques de régulation (chapitre 2), (3) la morphologie des régimes de pouvoir (chapitre 3), (4) la généalogie des révolutions régulatrices (chapitre 4), et (5) les tensions de co-viabilité au sein des dispositifs contemporains (chapitre 5).
-
-Pour penser ce seuil, notre essai-thèse a posé les conditions de détection d’une régulation minimale, structurée autour de trois prises fondamentales, dont la coprésence différenciée et articulée constitue la grammaire de toute régulation habitée. Ces trois prises — *arcalité, cratialité, archicration* — ne sont pas des dimensions logiques. Elles sont des formes d’existence différenciées de l’ordre régulateur.
-
-Comme nous l’avons vu, l’*arcalité* désigne la condition d’énonciation du pouvoir. Elle ne se réduit pas à une source légale ou à une tradition instituée. Elle renvoie à la capacité d’un dispositif à exposer son propre fondement comme fondement, à dire : "voici sur quoi nous agissons, pourquoi, selon quelle vision du monde, selon quelle fiction ou axiome opératoire". Dans une régulation archicratique, l’*arcalité* est convoquée, nommée, rendue visible, tenue.
-
-La *cratialité*, quant à elle, n’est pas simplement l’opérativité technique. Elle est l’ensemble des vecteurs concrets d’application du pouvoir, qu’il s’agisse de normes, d’algorithmes, de barèmes, de codes juridiques, de métriques ou d’interfaces. C’est le pouvoir dans sa matérialité d’exécution. Loin de n’être qu’un détail de mise en œuvre, la *cratialité* constitue une scène en elle-même : celle où les affects se traduisent en effets, celle où le monde se divise, s’organise, se hiérarchise. Toute *cratialité* rendue opaque tend à devenir *hypertopique*.
-
-Enfin, l’*archicration* désigne la scène elle-même : l’espace-temps de l’épreuve régulatrice. Il ne se réduit pas à un dispositif de concertation ou à un droit de recours formel, mais bien plus à une scène effective, où le délai est institué, où les énoncés sont exposés, où les décisions sont suspendues, et où les parties affectées peuvent agir sur les termes mêmes de la régulation. Une *archicration* est une scène fondée, différée, ouverte, documentée, capable de transformer ce qu’elle expose. Elle se doit donc d’être publique et aucunement privée.
-
-Ces trois prises ne sont jamais données d’emblée. Elles sont inégalement distribuées, plus ou moins visibles, plus ou moins consolidées. Ce que permet l’*archicratie*, c’est d’en faire un modèle d’analyse différentielle, capable d’évaluer non ce que les institutions disent d’elles-mêmes, mais ce qu’elles rendent effectivement détectable, contestable, modifiable.
-
-C’est à ce titre que nous avons élaboré une axiomatique de la détectabilité régulatrice, qui ne repose pas sur la conformité juridique, mais sur des critères structurels : la coprésence des prises ; leur différenciation fonctionnelle ; la publicité du fondement ; l’opposabilité des normes ; la révision périodique ; le droit au différé contradictoire.
-
-Ce modèle ne s’oppose pas aux régimes existants. Il les requalifie selon une grammaire de viabilité. Il ne dit pas ce qui est souhaitable. Il indique ce qui est soutenable.
-
-Au terme de ce parcours, notre essai-thèse propose d’abord une *grammaire minimale de la régulation habitable*, en distinguant rigoureusement *arcalité, cratialité* et *archicration* comme trois prises irréductibles mais articulables du pouvoir. Il offre ensuite une archéogenèse comparée des méta-régimes régulateurs, qui permet de lire des configurations très hétérogènes – proto-symboliques, scripturaires, marchandes, guerrières, techno-logistiques – sans les rabattre sur le seul État, le seul marché ou la seule souveraineté. Il recompose en outre les “révolutions industrielles” comme des *révolutions régulatrices*, c’est-à-dire comme des histoires différentielles de la scène et de son oblitération, jusqu’au diagnostic contemporain d’*autarchicratie* et de *régulation hors scène*. Enfin, il élabore une politique des épreuves viables, en substituant à la fiction de la durabilité le paradigme de la *co-viabilité archicratique*, et en proposant quelques gestes concrets par lesquels cette exigence pourrait être mise à l’épreuve dans les institutions, les territoires et les dispositifs numériques.
-
-Là réside le geste décisif : faire de l’*archicratie* une condition de lisibilité du pouvoir, dans un monde où les décisions sont de plus en plus produites sans fondement explicité, en accès et décision privés, appliquées sans seuil d’entrée et exécutées sans scène d’exposition explicite (algorithmes de recommandations, IA générative, etc.).
-
-En nommant l’*archicratie*, ce que nous faisons, ce n’est pas inventer une utopie : c’est dégager, à partir des marges critiques de la modernité régulatrice, un principe de consistance qui permet de discerner ce qui peut encore être appelé régulation — et ce qui ne relève plus que de l’automatisation du monde, son *autarchicratie*.
-
-Comme l’écrivait Claude Lefort, “le lieu du pouvoir est vide, et le pouvoir est un lieu duquel personne ne peut s’arroger la propriété” : c’est ce vide fondateur qui, sans scène, devient mutisme algorithmique. L’archicration ne cherche pas à combler ce vide, mais à en réinstituer l’adresse. Car l’*archicratie* n’est pas l’alternative à un système. Elle est ce qui rend possible le fait même qu’un système puisse tenir, mais aussi être interrompu, contesté et refondé. Elle est la condition minimale de tout ordre qui ne veut pas être sa propre clôture et sa pure et propre reproduction sociale.
-
-Ce que nous avons appelé scène n’est ni une métaphore théâtrale, ni un artifice rhétorique, ni un dispositif de communication. Elle n’est pas le lieu décoratif du pouvoir. Elle n’est pas ce que l’on ajoute, une fois la régulation pensée, pour en valider symboliquement l’acceptabilité. Elle est, à l’inverse, la matrice originaire d’où émerge toute forme de régulation vivable, bien avant l’État, bien avant le droit, et en dehors des grammaires modernes du gouvernement.
-
-L’histoire politique des sociétés humaines ne commence pas avec l’institution étatique. Elle commence par l’apparition de lieux différés dans lesquels le pouvoir se donne à voir, se laisse convoquer, se met en épreuve. Partout où l’on observe la mise en forme de relations collectives durables, on trouve, en amont de la codification, des scènes d’ajournement et de dispute — des espaces de rituel, de conseil, de circulation de paroles, de suspension du geste immédiat.
-
-Les premières figures de la régulation ne sont pas des lois, mais des cercles. Ce sont des feux autour desquels on raconte ce qui a été fait, ce qui pourrait être fait autrement, ce qui doit être décidé ensemble. Ce sont des seuils marqués, des temps de deuil ou de conflit ajourné, des prises de parole dans l’épure, où l’événement est reconvoqué dans un espace plus grand que lui. C’est ici que s’institue, sans formalisation juridique, la première *archicration* : une scène anthropologique de différé, de dispute et de co-présence du conflit.
-
-L’archéogenèse de la scène, telle que nous l’avons retracé, ne vise pas à plaquer une origine sur le concept d’*archicratie*. Elle permet de montrer que l’exposition du pouvoir au regard des autres n’est pas un luxe moderne, mais une fonction vitale de toute organisation collective. On ne fonde pas une cité parce que l’on a établi une loi ; on fonde une cité parce que l’on a produit un lieu dans lequel des lois pouvaient être explicitées, différées, adressées et même révisées.
-
-Les régimes que nous considérons comme proto-politiques ne reposent pas sur des appareils coercitifs permanents, mais sur des dispositifs de régulation publique des différends. Ce que l’on appelait jadis “conseil des anciens”, “assemblée des vivants”, “place de palabres”, “moment du jugement”, sont autant de scènes dans lesquelles une communauté suspend l’exécution brute des normes pour produire, en commun, un réexamen des conditions du vivre-ensemble.
-
-Il y a ici un renversement majeur : ce n’est pas la violence qui précède l’ordre, mais la scène qui ajourne la violence par son existence et son efficience. Loin d’être un ornement cérémoniel, la scène permet de transformer une décision en acte politique, en la soumettant à un espace d’apparition partagé. On ne gouverne pas parce qu’on détient un pouvoir, on gouverne parce que l’on accepte d’exposer le pouvoir dans un lieu où il peut être contesté.
-
-Et ce geste ne disparaît pas avec la modernité : il se déplace, se reconfigure, parfois se cache. Les formes scéniques de l’époque moderne — parlements, tribunaux, conseils, consultations — ne sont pas des innovations *ex nihilo*, mais des transpositions institutionnelles d’une exigence anthropologique fondamentale : rendre le pouvoir visible dans un espace différé, public, contradictoire pour le légitimer dans son autorité.
-
-Ce que nous appelons aujourd’hui *archicratie*, à travers le triptyque *arcalité-cratialité-archicration*, ne naît donc pas avec la gouvernance algorithmique, ni avec la crise contemporaine des institutions : c’est le nom que nous donnons à une exigence anthropologique longue — rendre le pouvoir visible dans un espace différé, public, contradictoire — que les mutations modernes ont partiellement codifiée, mais jamais totalement effacée. Même les régimes autoritaires, même les appareils technocratiques les plus opaques, tentent de simuler la scène, d’en mimer les apparences, comme si toute régulation devait, d’une manière ou d’une autre, s’appuyer sur une forme scénique minimale, fût-elle falsifiée, spectaculaire, dé-saisissante ou accablante.
-
-L’effondrement actuel, tel que nous le décrivons, ne réside pas dans une rupture historique absolue, mais dans une disjonction cumulative, où la régulation devient performative, prédictive, auto-exécutive, tout en prétendant conserver l’apparence de la scène. Ce que les plateformes administratives, les interfaces de recours, les simulateurs d’opinion, les visualisations de données simulent, ce n’est pas la norme — c’est le différé. Ce n’est pas la décision — c’est la contestation.
-
-En ce sens, réinstituer la scène aujourd’hui revient à réactiver une fonction anthropologique enfouie, plutôt qu’à restaurer une forme passée enfouie sous les couches technocratiques, une fonction sans laquelle aucun ordre collectif ne peut être su, ajusté, ni corrigé, ni habité. Nous ne parlons pas ici de restauration, plutôt d’un geste de fondation renouvelé : retrouver la capacité de construire des espaces différés d’apparition du pouvoir, où la norme peut être visible, où la décision peut être suspendue, où l’effet peut être discuté, et où le fondement peut être relancé.
-
-L’histoire de la scène est celle de l’ajournement du pouvoir brut au nom d’une *co-présence* instituée du conflit. Et c’est à cette hauteur anthropologique que l’*archicratie* trouve son origine : non dans une forme constitutionnelle, mais dans la structure même du fait politique, dès lors qu’il accepte de s’exposer à autre chose que sa propre exécution.
-
-Ce que nous appelons *co-viabilité* n’est pensable que dans cette tension : entre un pouvoir qui affecte, et un espace où cette affectation peut être exposée. La scène est le seul lieu où cette tension devient habitable, c’est-à-dire vivable, réformable, traversable. Sans scène, ce sont alors des processus, des opérations, des machines qui dominent.
-
-C’est pourquoi, dans notre essai-thèse, l’*archicration* n’est jamais une solution institutionnelle, ni une forme de gouvernement. Elle est la condition minimale d’un monde capable de s’interrompre pour se refonder. Elle est ce qui permet, encore et toujours, de revenir sur ce qui est en train de s’imposer. Elle est le lieu de surgissement de la viabilité.
-
-Et c’est à partir de cette scène — non comme décor, mais comme forme originaire de la dispute différée — que peut se penser la cinquième révolution régulatrice, non comme innovation technologique, mais comme retour conscient à une exigence anthropologique que l’histoire n’a jamais pu dissoudre.
-
-Il n’est désormais plus possible d’analyser la question de la régulation sans la confronter à ses deux périls contemporains les plus massifs, les plus urgents, les plus irréversibles : la désintégration sociale et l’inhabitation écologique. Ces deux lignes de fracture ne constituent pas des petits “sujets” parmi d’autres, ni même des crises externes au champ de la régulation. Elles sont les lieux mêmes où se joue la soutenabilité du monde commun, et à partir desquels se manifeste avec la plus grande intensité la nécessité d’une scène archicratique instituée.
-
-D’un côté, les sociétés contemporaines sont travaillées par une fragmentation socio-économique accélérée, où les droits, les protections, les accès aux ressources, à la santé, à l’habitat, au travail, à la dignité même, sont de plus en plus conditionnés par des régimes de critères invisibles, des barèmes automatisés, des normes silencieuses dont la contestation n’a ni lieu ni délai. Ce que produit cette fragmentation, ce n’est pas simplement de l’injustice – c’est une dés-institution du social, un abandon de la possibilité de fonder l’ordre sur une scène où les règles peuvent être exposées, comprises, opposées, amendées.
-
-De l’autre côté, l’environnement planétaire est soumis à un processus de désintégration physique, chimique, biologique, systémique, dont les causes sont connues, mesurées, modélisées — mais dont la régulation demeure hors scène. Les grands instruments du pilotage écologique (quotas carbone, marché de droits d’émission, régulations incitatives, taxonomies vertes, solutions technologiques à haute intensité énergétique) ne répondent pas à une scène fondée de délibération environnementale. Ils opèrent à partir d’indicateurs pré-déterminés, de modèles économétriques rendus irréfutables, d’institutions fermées dont les critères ne sont ni exposés, ni opposables.
-
-Dans les deux cas, ce que l’on appelle régulation n’est souvent rien d’autre qu’un régime d’administration automatique de la catastrophe, une façon de moduler les seuils d’acceptabilité de l’inacceptable, de stabiliser temporairement des déséquilibres massifs sans jamais exposer les choix, les arbitrages, les priorités, à une scène d’épreuve collective.
-
-Le mot “durabilité”, en ce sens, est devenu l’un des opérateurs les plus puissants de cette fiction régulatrice. Il donne à croire qu’un monde peut être maintenu dans son état actuel par l’ajustement de ses paramètres – sans refondation, sans débat, sans conflit institué. On parle de transition, mais sans définir qui en décide, selon quels délais, avec quelles conséquences, sur quels critères effectifs et crédibles. On évoque l’empreinte carbone, sans jamais dire ce que cela signifie politiquement, historiquement, anthropologiquement. Le terme de “durabilité” produit ainsi un effet de clôture : il neutralise la conflictualité fondatrice de toute scène régulatrice, en la remplaçant par un récit d’optimisation continue, une fable pseudo-scientifique.
-
-Ce que notre essai-thèse oppose à cette fiction, ce n’est pas une autre gestion du risque, ni une autre version du développement : c’est une refondation de la question régulatrice à partir du paradigme de la co-viabilité. Et cette refondation ne peut s’opérer que dans une configuration archicratique, c’est-à-dire dans une scène fondée où la viabilité ne se décrète pas, mais s’éprouve, se dispute, se rejoue, se transforme.
-
-Celle-ci ne peut être réduite à la compatibilité des intérêts humains et non-humains, ni à une coexistence pacifiée entre agents différenciés. Elle n’est pas un horizon harmonique. Elle est un régime d’épreuves instituées, dans lequel les formes du vivant, des milieux, des infrastructures, des symboles, peuvent être convoquées dans des scènes de régulation explicite, différée, révisable.
-
-Ce que cela signifie, très concrètement, c’est que les arbitrages sur l’eau, l’énergie, la mobilité, le territoire, la réparation, le soin, ne peuvent plus être externalisés dans des modèles d’impact ou des courbes d’efficacité. Ils doivent être rapportés à une scène, où l’on peut interroger non seulement les effets des décisions, mais leurs fondements, leurs seuils, leurs instruments, leurs alternatives.
-
-L’*archicration* écologique prend corps dans des scènes territoriales où les habitants font apparaître les conditions d’habitabilité, contestent les infrastructures et proposent des configurations de subsistance — bien au-delà des conférences quinquennales et des tableaux de bord numériques d’objectifs carbone ; elle suppose une arcalisation du vivant (reconnaissance des entités existantes), une cratialisation des milieux (identification des champs de forces et d’agissements), une archicration du conflit, autrement dit une politisation complète de ce qui, trop longtemps, a été traité comme données environnementales inertes.
-
-Sur le plan social, la logique est la même. Là où les critères d’attribution des droits deviennent des scripts inaccessibles, là où les plateformes d’accès remplacent les guichets, là où les aides sociales sont suspendues sans énoncé, là où les publics fragiles sont évalués par des algorithmes de “comportement à risque”, le droit s’automatise, la scène disparaît, la dignité s’efface.
-
-Ce n’est pas une question d’inefficacité, ni même d’injustice procédurale : c’est une désactivation du régime de reconnaissance. Car un droit qui ne peut plus être justifié publiquement, réclamé dans une scène, opposé dans un délai, contesté par une présence, n’est plus un droit. C’est une variable. Une allocation. Un flux à tout moment suspensif.
-
-Réinstituer l’*archicration* sociale, c’est donc reconstruire la scène de l’accès au droit — non pas à travers des démarches participatives formelles, mais à travers des dispositifs d’exposition des critères, des formes de visibilité des seuils, des délais contradictoires obligatoires, des lieux de confrontation réels, soutenus, équipés, où l’on peut dire : “Ce n’est pas acceptable. Voici pourquoi. Voici ce que je propose.” C’est là, dans ces scènes de l’interpellation, que la co-viabilité sociale devient pensable.
-
-Il ne s’agit donc pas de “réconcilier” social et écologie, mais de comprendre qu’ils sont deux effets d’une même oblitération scénique, et que leur relance ne peut passer que par la reconstruction des conditions archicratiques du désaccord institué.
-
-C’est ici que l’hypothèse archicratique devient non plus un outil critique, mais une proposition civilisationnelle. Car un monde durablement privé de scènes archicratives tend à devenir aveugle à sa propre destinée. Un monde incapable de suspendre ce qu’il fait. Incapable d’en répondre. Incapable de s’ajuster depuis elles et ceux qu’il affecte.
-
-À cette cécité organisée, la *co-viabilité* oppose la lumière rugueuse de l’exposition et du différé, la présence irréductible des vivants, la scène ouverte des conflits fondateurs canalisés par les récits de vie. Et c’est à partir de cette tension — vitale et irréductible — que peut encore s’inventer un devenir commun concerté fondé sur nos vulnérabilités, nos résiliences et nos robustesses conscientisées et politisées.
-
-La régulation contemporaine, dans sa formulation dominante, se présente sous les atours rassurants d’un horizon consensuel : celui de la durabilité. Ce terme, devenu mantra technico-politique, irrigue désormais l’intégralité des champs du discours institutionnel — des traités internationaux aux chartes locales, des stratégies d’entreprise aux programmes éducatifs, des plans d’action gouvernementaux aux critères d’investissement privé. Il semble à la fois évident et indiscutable, fédérateur et apaisant. À son contact, les conflits s’effacent, les alternatives se suspendent, la temporalité se normalise, et la gouvernance acquiert une forme de légitimité indolore, anesthésiante, presque tautologique. Au point que ce qui est durable est ce qui mérite de durer.
-
-Sous sa surface consensuelle, la “durabilité” se ferme à l’épreuve : elle transforme le dissensus en anomalie et recode la régulation en pilotage continu d’indicateurs non révisables. Le problème n’est pas l’objectif écologique en lui-même, mais la structure régulatrice qui l’impose hors scène, et surtout, dans bien des cas, hors-sol, et bien plus, par cœur ou par calcul. Contre cette clôture, la politique des épreuves viables et soutenables substitue à l’optimisation des variables la publicité des critères recevables, au pilotage continu automatisé le jeu et le différé contradictoire, à la gestion d’impacts et de risques l’énonciation de leurs fondements pour éveiller les raisons — conditions pour que les décisions redeviennent adressables et opposables sous critères de discernement.
-
-Car jusqu’à présent, les stratégies dites “durables” fonctionnent selon un régime algorithmique d’autorité, où les seuils d’acceptabilité sont déterminés en amont, les priorités dictées par les logiques d’efficience, les variables manipulées sans scène d’exposition. On y parle de neutralité carbone, de trajectoires optimales, de plans de transition, mais jamais de fondement public de ces trajectoires, ni de scène dans laquelle elles pourraient être tenues devant ceux qu’elles affectent. C’est dans cette évacuation de la scène — plus encore que dans le contenu des politiques — que réside le cœur du problème. Ce n’est pas l’objectif de durabilité qui est en cause, c’est la structure régulatrice silencieuse qui le porte, le légitime et l’impose.
-
-Pour rendre ce mécanisme visible, rappelons-nous que toute régulation suppose deux opérations irréductibles : d’une part, une *normativité explicite* (ce qui doit être régulé, pourquoi, selon quels principes) ; d’autre part, une *opérativité outillée* (comment cette norme s’applique, à travers quels instruments, sur quels objets). Mais entre les deux, il faut une troisième instance, que la durabilité contemporaine tend précisément à effacer : la *scène d’épreuve*. C’est cette scène — différée, fondée, contradictoire — qui permet aux décisions de ne pas s’exécuter à l’abri du regard, aux critères d’être rendus publics, aux seuils d’être contestés, aux affects d’être entendus, aux représentations de monde d’être opposables contre tout arbitraire.
-
-En ce sens, la durabilité n’est pas qu’une fiction apolitique : elle est le récit qui permet l’exécution sans scène, la régulation sans fondement, la gouvernance sans convocation. Elle naturalise les instruments, en les présentant comme neutres. Elle réduit les choix à des données. Elle transforme la dispute en friction technique. Et ce faisant, elle désarme les communautés, les privant du droit d’ajourner, de relancer, de reformuler ce qui les affecte.
-
-La politique des épreuves viables, telle que nous la proposons ici, ne consiste pas à rejeter les impératifs écologiques et sociaux. Elle ne nie pas la nécessité de limites, ni l’urgence de transformations structurelles. Elle refuse simplement que ces transformations soient imposées hors scène, dans le silence d’une régulation désaffectée. Elle postule que toute décision ayant un impact majeur sur les conditions de vie, de subsistance, d’habitation, doit passer par une épreuve fondée, différée, partagée. Elle postule que ce qui n’est pas disputé ne peut être dit durable.
-
-Une politique des épreuves viables suppose donc une ré-institution intégrale des conditions archicratiques de la décision. Plutôt qu’une réforme des indicateurs, une amélioration des consultations ou une simple transparence des données, il faut une scénarisation complète de la régulation selon une grammaire fondée sur quatre principes irréductibles, que nous avons articulés dans le cadre de notre modèle archicratique.
-
-Quatre exigences, déjà inscrites dans notre axiomatique, organisent la politique des épreuves viables : le *différé contradictoire*, qui rend l’exécution ajournable ; la *publicité des critères*, qui reconduit tout seuil à son fondement ; l’*opposabilité réelle*, qui ouvre la décision à l’intervention des affectés avant, pendant et après son application ; la *révision périodique*, qui interdit la clôture. Ces exigences ne sont pas des ajouts déontologiques : elles matérialisent l’axiome de détectabilité, confirment la disjonction fonctionnelle des prises arcales, cratiales et archicratiques et prolongent l’épreuve critique comme norme de vitalité du régime.
-
-Mais ces principes ne peuvent exister qu’à une condition : qu’il y ait une scène. Une scène qui ne se contente ni de spectacle, ni de consultation décorative, ni de simple mise en visibilité : mais bien une scène où le pouvoir se fonde en apparaissant, où l’épreuve est instituée, où la transformation s’engage réellement depuis ceux qu’elle affecte.
-
-L’exemple des politiques climatiques l’illustre avec une clarté glaçante. Les objectifs de réduction d’émissions sont fixés par des trajectoires macroéconomiques, sans fondement ontologique débattu. Les instruments de marché (droits d’émission, taxes, incitations) sont conçus dans des enceintes d’expertise, sans contre-scène démocratique. Les seuils sont négociés entre États et industries, sans présence des vivants affectés. Résultat : une régulation performante sur le papier, mais fondamentalement désarchicratique. Elle s’exécute sans différé, sans dispute, sans publicité explicite des choix de monde. Là encore, la matrice d’audit du chapitre 1 s’applique : hypotopies (prises faibles sous-déterminantes), hypertopies (prises surdéterminantes), atopies (pseudo-scènes indéterminées), permettant de situer les déficits scéniques des dispositifs climatiques.
-
-Ce que nous appelons épreuve viable, c’est ce qui manque ici : la possibilité d’exposer les décisions à une scène où le fondement devient enjeu, où les milieux parlent, où les vivants contestent, où les représentations s’affrontent, dans un cadre institué, soutenu, non clôturé.
-
-Dans les politiques sociales, le mécanisme est identique. Les aides sont attribuées selon des barèmes automatisés, les exclusions sont déclenchées sans justification explicite, les critères de mérite, de comportement, de mobilité sont intégrés dans des scripts sans adresse. On parle d’insertion, d’autonomie, de parcours. *Mais où est la scène ?* Où est l’espace où une personne peut dire : « ce critère est inacceptable » ; « cette décision ne me reconnaît pas » ; « je demande une autre forme de régulation » ?
-
-Dans bien des dispositifs sociaux, la scène formelle d’accès au droit s’est amincie ou s’est déportée dans des circuits techniques ; elle persiste toutefois sous des formes intermittentes, fragiles ou latérales — commissions locales, permanences associatives, médiations juridictionnelles *ad hoc*. Le problème n’est donc pas l’absence pure et simple, mais la dégradation topologique de la scène : hypotopies (prises faibles ou non reliées), hypertopies (cratialité sur-déterminante) et atopies (simulacres participatifs). Comme nous l’avons établi au chapitre 1, cette typologie ne renvoie pas à un argument d’autorité mais à une matrice d’audit : elle sert à objectiver les prises, à situer les déficits et à rouvrir la possibilité d’une scène tenue, opposable et révisable.
-
-Face à cela, une politique des épreuves viables implique une redéfinition complète de l’acte régulateur : non plus l’ajustement d’un système fermé, mais l’institution d’une scène ouverte. Elle transforme le pouvoir de gouverner en obligation de se laisser apparaître. Elle transforme le savoir d’expert en condition de fondation publique. Elle transforme la gestion en exposition contradictoire.
-
-Nous nommons *autarchicratie* la concrétisation achevée de la désarchicration : le méta-régime dans lequel la *cratialité se met en autarcie*. Il ne s’agit pas d’un gouvernement de la société par elle-même, mais d’un *gouvernement de la régulation par elle-même* : indicateurs, modèles de risque, scripts algorithmiques et procédures de contrôle deviennent leurs propres critères de validité, sans plus devoir passer par des scènes d’épreuve archicratives praticables. La *cratialité* s’y auto-référence et s’y auto-certifie, dans des boucles où tout fonctionne — calculs, audits, *reporting* — mais où plus rien ne se laisse vraiment contester ni même énoncer. Cette mise en autarcie de la régulation prolonge, jusqu’à son point de bascule, les tendances déjà repérées dans la gouvernementalité néolibérale, la rationalisation managériale et la numérisation intégrale des prises.
-
-L’*autarchicratie* n’est donc pas une fiction dystopique : c’est une destination possible, et déjà en partie à l’œuvre, de nos régimes contemporains. Nous en avons suivi les lignes de force dans l’histoire des révolutions industrielles (chapitre 4), lorsque la scène archicrative se trouve progressivement oblitérée au profit de modèles prédictifs et de dispositifs d’automatisation normative. Nous en avons observé les manifestations concrètes dans les politiques climatiques, sociales et numériques (chapitre 5), sous la forme de *pseudo-archicrations fantômes* et de pilotages algorithmiques où les circuits de décision se suffisent à eux-mêmes. Dans tous ces cas, la régulation subsiste juridiquement et techniquement, mais elle se maintient hors seuil d’opposabilité : scènes inaccessibles, délais inopérants, motifs indisponibles, paramètres non auditables. Tout fonctionne ; mais plus rien ne s’expose ni ne s’explique.
-
-Dès lors, le péril n’est pas l’*archicratie* elle-même — qui institue la scène et rend contestables les effets —, mais sa disparition performative dans l’*autarchicratie*. Ainsi, refaire monter la scène n’est pas un supplément procédural : c’est revenir au seuil où la décision cesse d’être instrument et redevient fondation ; c’est rétablir, contre l’autarcie régulatrice, la possibilité d’un différé, d’une justification opposable, d’une réversibilité des effets — conditions sans lesquelles il n’y a plus de politique, mais seulement à terme des processus automatiques ou des pratiques machinales.
-
-Or c’est bien cela que permet encore le concept d’*archicratie* — refonder la régulation comme scène, comme institution de l’interruption, de la dispute, du différé, de la relance — puisqu’elle permet de nommer ce qui auparavant était pour bonne part occulté bien que présent. Les épreuves viables posent ainsi la question de ce qui fait tenir un monde — et à quelles conditions il mérite encore de tenir.
-
-Si la scène constitue, comme nous l’avons montré, la matrice fondamentale de toute régulation archicratique, alors son absence appelle autre chose qu’un tragique constat critique ou une nostalgie institutionnelle. Elle appelle un geste pleinement instituant, une projection agissante, un surgissement conceptuel doublé d’un projet matériel. Il ne suffit pas de rappeler que les normes s’appliquent aujourd’hui sans exposition, que les seuils gouvernent sans adresse, que les décisions s’exécutent sans différé. Il faut désormais concevoir les formes par lesquelles cette dérive peut être arrêtée, inversée, transformée depuis son propre cœur. Cela ne relève ni du réformisme, ni de l’utopie, mais d’un geste proprement archicratique : instituer une scène là où il n’y a plus que des tentations de scripts ou de prompts.
-
-Car l’absence de scène ne signifie pas une absence de régulation. Celle-ci se manifeste au contraire par un trop-plein de formes technico-administratives, de logiques procédurales, de chaînes opératoires sans seuil de réflexivité. Elle ne manque pas d’arènes, de plateformes, de forums, de simulateurs. Par contre, elle manque de lieux où l’on peut exprimer que ce pouvoir n’est pas encore justifié ; que cette norme ne peut pas encore s’appliquer ; que cette décision doit être suspendue tant qu’elle n’a pas été tenue devant celles et ceux qu’elle transforme. La scène n’est donc pas une instance supplémentaire : elle est ce sans quoi toute instance devient violence déguisée et insidieuse. Elle ne s’ajoute pas au dispositif ; elle en est la condition de légitimité. Et pour cette raison, elle doit être conçue, pensée, projetée et instituée.
-
-Toutefois, réinstituer les scènes ne consiste pas nécessairement à restaurer les formes d’assemblée du passé. Il ne s’agit pas non plus de réanimer les dispositifs dévitalisés de la représentation, ni de raviver des formes symboliques inertes. Il s’agit de penser des espaces dans lesquels une décision devient apparente avant d’être exécutoire, dans lesquels le temps retrouve sa densité, dans lesquels le pouvoir accepte d’être différé, exposé, débattu, amendé, contredit. Cela implique une refondation des infrastructures de la régulation, dans leur matérialité comme dans leur temporalité.
-
-Il faudra donc des lieux, des calendriers, des organisations, des compétences, des statuts, des rôles, des budgets, des procédures, mais aussi des rituels, des langues, des gestes, des seuils symboliques. Car la scène est un dispositif complexe : elle n’émerge pas d’elle-même, elle ne se décrète pas, elle s’institue par un ensemble cohérent de formes, d’espaces, d’affects et de récits. Et c’est ce tissu qu’il faut aujourd’hui remailler.
-
-Là où les politiques publiques s’élaborent aujourd’hui dans les anti-chambres des ministères ou la clôture des cabinets d’audit, il faudra ouvrir des délais formels et irréductibles à la consultation. Là où les plateformes déploient leurs standards d’usage sur des populations entières sans épreuve fondatrice, il faudra bâtir des scènes où le code peut être ajourné, explicité, confronté. Là où les territoires sont remodelés par des logiques d’optimisation, il faudra des lieux où l’habitabilité puisse être requalifiée, où les milieux puissent apparaître, où les formes de vie puissent être représentées dans leur altérité. Là où les seuils d’attribution, de sanction, d’accès ou d’aide s’appliquent par automatisme, il faudra instituer des régimes où la décision elle-même devienne visible, révisable, reconductible à partir d’une épreuve contradictoire menée par des humains. Et cela ne se fera pas par décret. Cela exigera de nouveaux dispositifs, de nouvelles instances, de nouvelles formes, à inventer depuis le cœur même de la crise scénique contemporaine, probablement au plus près des acteurs de l’économie sociale et solidaire et des professions intermédiaires.
-
-Qu’on admette alors ceci : bien comprendre la scène dans l’ordonnancement archicratique n’est pas une option procédurale. Elle est l’un des opérateurs décisifs par lesquels une décision cesse d’être purement instrumentale pour devenir fondatrice. C’est dans la scène que le pouvoir se redéploie en se laissant affecter. C’est dans la scène que la temporalité s’épaissit, que les conséquences deviennent lisibles, que les fondements peuvent être relancés. C’est là que peut émerger une *co-viabilité régulatrice*. Il ne s’agit donc pas d’ajouter de la transparence, de la participation ou de la communication. Il s’agit de concevoir des scènes dans lesquelles l’ordre peut être temporairement suspendu, afin d’être à nouveau institué depuis ceux qu’il affecte.
-
-Ce travail d’institution scénique ne peut être séparé de la question de l’échelle. Il devra se jouer à tous les niveaux : au sein des écoles, des collectivités, des juridictions, des plateformes, des infrastructures, des régulations techniques, des politiques sociales, des gouvernances écologiques... Chaque strate et lieu de l’*archicratie* doit trouver sa scène d’apparition, adaptée à sa texture propre, mais reliée par une même exigence : qu’*aucune décision structurante et agissante ne puisse advenir sans être tenue devant celles et ceux qu’elle engage.* Cela implique un effort considérable de conception, de financement, de formation, mais surtout un déplacement ontologique de ce qu’on appelle “gouverner”. Gouverner ne consistera plus à appliquer avec justesse des normes bien conçues, mais à rendre ces normes ajournables, discutables, contestables, et davantage réformables sous conditions de *co-viabilité* sociale et écologique.
-
-Il faudra, pour cela, concevoir de nouveaux lieux : des espaces où l’on entre sans savoir ce qui va en sortir, mais où chacun peut venir avec ses preuves, ses objections, ses propositions, ses arguments. Des scènes sans clôture prédéterminée, mais avec un cadre fort. Des scènes traversées par les conflits, mais équipées pour les soutenir. Des scènes lentes, où l’on prend le temps de tout reprendre. Des scènes modestes, parfois, mais constantes. Des scènes qui ne soient pas des moments exceptionnels, mais des rythmes d’institution continue. Des scènes enfin que l’on peut convoquer, non pour donner son avis, mais pour rouvrir le monde.
-
-Et plus encore que des lieux, il faudra forger une culture. Une culture du différé, une culture de la justification, une culture de l’apparition fondée. Il faudra former à la convocation des énonciateurs, à la reconstruction des axiomes, à la mise en tension des critères. Il faudra réapprendre à interrompre sans détruire, à disputer sans humilier, à exposer sans désincarner. Il faudra bâtir des formes dans lesquelles le pouvoir n’aura plus peur d’être vu, entendu, relancé. Mais cela, aucun règlement ne pourra le prescrire. Ce sera l’œuvre d’une génération entière, qui ne se contentera pas de revendiquer des droits, mais qui acceptera de se constituer comme puissance politique — non dans l’éclat du spectaculaire, mais dans la densité fondatrice d’un monde à relancer avant effondrement déjà annoncée.
-
-À ce niveau, réinstituer la scène n’est plus un programme. C’est un appel. Un appel à cesser de gérer les régulations comme si elles pouvaient s’auto-référencer indéfiniment. Un appel à rouvrir l’espace du pouvoir comme espace d’épreuve, non de domination. Un appel à instituer un régime dans lequel les décisions cessent d’être des faits pour redevenir des actes. C’est ainsi que l’*archicratie* prendra sens comme projet. Non comme forme de gouvernement, mais comme respiration de toute société qui veut encore se gouverner elle-même dans son évolution pour assurer son avenir.
-
-Toute régulation s’inscrit dans une histoire. Non seulement dans l’histoire des régimes politiques ou des institutions juridiques, mais dans une histoire plus profonde encore : celle des formes d’articulation entre pouvoir, savoir, énergie et monde, autrement dit, celle des configurations systémiques au sein desquelles l’humain, le vivant, le milieu, la technique et le symbolique se tiennent dans un certain rapport. Ce que nous appelons ici “révolution régulatrice” ne renvoie donc pas à un événement politique localisé, ni à une invention technologique isolée, mais à une transformation systémique de la manière dont un monde se produit, se reproduit, se règle et se légitime.
-
-Les quatre grandes révolutions qui scandent la modernité industrielle – mécanisation disciplinaire, organisation taylorienne-fordiste, cybernétisation néolibérale, numérisation généralisée – ne sont pas seulement des séquences techniques. Chacune a reconfiguré, à sa manière, le rapport entre *arcalité*, *cratialité* et *archicration* : nouvelles promesses de légitimation, nouveaux dispositifs d’exécution, nouvelles formes – ou nouvelles défausses – de scène. La quatrième, celle de la numérisation intégrale des systèmes de décision, pousse à l’extrême un mouvement amorcé de longue date : la possibilité de faire fonctionner la régulation sans passer par des lieux reconnaissables d’épreuve.
-
-C’est précisément contre cette clôture systémique que se dessine ce que nous proposons d’appeler, par convention, une cinquième révolution régulatrice. Elle ne consisterait pas en un supplément d’automatisation ni en une sophistication accrue des instruments. Elle tiendrait dans un déplacement plus radical : le fait de considérer que l’instance décisive n’est plus l’outil, ni le flux, ni la procédure, mais la scène où ces éléments deviennent adressables, critiquables, reconfigurables. Là où les révolutions précédentes ont privilégié l’extension des capacités de calcul, de production ou de circulation, celle-ci privilégierait la capacité à exposer ces capacités, à en faire l’objet d’une épreuve publique.
-
-Dire qu’il s’agit d’une “cinquième révolution” ne signifie pas que l’histoire suivrait un cours nécessaire et linéaire. Le terme n’a ici qu’une valeur heuristique : il sert à concentrer, sous un même nom, des processus multiples, hétérochrones et dispersés – luttes pour la transparence effective des algorithmes, revendications de recours opposables, demandes de traçabilité des décisions, inventions de nouvelles assemblées scéniques. Il serait erroné de croire que cette révolution viendra s’ajouter, comme une étape finale, à une série déjà écrite. Elle pourrait tout aussi bien rester avortée, partielle, récupérée par les dispositifs qu’elle prétend contraindre.
-
-C’est pourquoi l’idée de cinquième révolution doit être explicitement soumise à épreuve. Elle serait infirmée si l’on constatait que les scènes existantes continuent de se vider de toute capacité effective, que les espaces de recours se réduisent à des simulacres sans impact sur les décisions, que les tentatives de réinstitutions scéniques se réduisent à des mises en récit sans prise sur les cratialités. Elle gagnerait en consistance, au contraire, si des pratiques, même locales, montraient que la création de nouvelles scènes – dans les hôpitaux, les écoles, les plateformes, les politiques écologiques – modifie réellement la manière dont les décisions sont justifiées, prises et requalifiées pour assurer la co-viabilité.
-
-Nous parlons donc de “cinquième révolution” moins comme d’un avenir promis que comme d’un horizon de travail : une invitation à relire les conflits présents à partir de la question scénique. Chaque fois qu’un collectif lutte pour un délai, pour un droit au différé, pour la présence d’énonciateurs identifiables, pour un droit de regard sur les paramètres qui le gouvernent, quelque chose de cette révolution est mis en jeu. Chaque fois qu’il s’en remet au contraire à la seule fluidité des ajustements automatiques, il s’en éloigne. Le paradigme archicratique propose de tenir ensemble ces expériences, de les comparer, de les instruire, sans décider à l’avance de leur issue.
-
-Cette cinquième révolution n’est pas un futur abstrait : elle advient chaque fois qu’un seuil est suspendu, qu’un fondement est reconvoqué, qu’un recours devient opérant, qu’une voix exclue trouve scène, délai et adresse ; chaque fois que la transparence cesse d’être visualisation pour redevenir publicité des critères, que la participation quitte la consultation pour rejoindre l’épreuve, que la gouvernance s’efface devant la fondation.
-
-Nous parlons de “cinquième révolution” par convention, en pleine conscience que l’histoire effective procède par recompositions régulatrices hétérochrones, stratifiées, feuilletées, sérialisées, désynchronisées selon les régimes symboliques et techniques ; de sorte que l’“événement” est devenu une prise de pouvoir de la scène dans l’architecture des dispositifs industriels.
-
-Dans un monde où les infrastructures et les superstructures établissent les nouvelles normes, où les plateformes sont devenues de nouveaux territoires de nos êtres, où les systèmes d’intelligence artificielle s’inventent comme nouveaux gouvernants, seule une révolution scénique permettrait au politique de ne pas s’effacer. Mais celle-ci ne se décrète pas : elle se sculpte par des décisions, des dispositifs, des pratiques et des langages ; elle requiert des artisans, des architectes, des dramaturges du politique ; elle accepte de perdre en fluidité ce qu’elle gagne en légitimité. Et c’est cela, précisément, que nomme l’*archicration* : une révolution régulatrice en acte, bien plus que le modèle institutionnel qu’elle instaurerait en conscience — l’*archicratie*.
-
-Il faut aujourd’hui prononcer un appel ancré dans le vivant, là où les institutions ne font plus apparaître les polémiques, là où les discordes tendent à se faire taire. Un appel qui ne soit ni un cri, ni un mot d’ordre, ni un acte de foi, mais une *archicration vivante* : c’est-à-dire l’apparition d’énoncés fondés, publics, discutables, adressables, révisables — une parole instituante, dans ce sens précis et exigeant que nous redonnons au mot “politique”. Le droit de vivre ! De tous vivre ! De chacun selon ses capacités, et à chacun selon ses besoins…
-
-Car ce que notre monde ne sait plus faire advenir, ce ne sont pas les règles ou les normes en elles-mêmes, mais la capacité populaire à les exposer, à les critiquer, à les instituer grâce à des formes collectives constituées par celles et ceux qui les subissent en premier lieu. Cette incapacité n’est ni technique, ni conjoncturelle. Elle est le symptôme d’un effondrement structurel qui au-delà de produire de l’injustice, nous conduit à une crise de viabilité civilisationnelle.
-
-Nous vivons dans un monde où l’humain et le non-humain sont liés par une même absence de considération. Le vivant, dans son immense diversité de formes, d’agencements, de langages, de résistances, est soustrait à la parole, au temps et à la forme. Et ce que notre thèse a permis de penser, c’est que ce processus d’invisibilisation n’est pas un effet secondaire des logiques économiques, mais une conséquence directe de la disparition de la scène de confrontation. Là où il n’y a plus de scène, il ne peut y avoir ni représentant, ni interpellation, ni suspension, ni réparation. Le vivant devient bruit, excès, variable et externalité à occulter.
-
-Il faut donc le dire avec toute la solennité nécessaire. Un monde sans *archicration* rend le vivant politiquement illisible, donc indéfendable : le conflit perd sa scène et le temps son droit de retour ; or le vivant a besoin d’un lieu d’apparition où les règles qui le concernent sont convoquées, tenues et différées. Parce qu’il a besoin d’une scène comme condition de reconnaissance mutuelle inscrite dans le temps. Parce qu’il ne peut être gouverné sans être d’abord entendu, représenté, institué dans la durée de conflits assumés, dans la densité d’un désaccord soutenu qui permette tout de même la *co-viabilité*.
-
-Ce n’est pas tant un supplément de conscience écologique que requiert notre temps, qu’une réinscription du vivant dans le cœur même de la procédure régulatrice. Il faut que le vivant retrouve la capacité de faire épreuve comme acteur instituant. Cela implique de convoquer de nouveaux formats d’apparition, de nouvelles figures de représentation, de nouvelles juridictions du milieu, de nouveaux porte-paroles, mais aussi de nouvelles scènes, de nouveaux délais et de nouveaux seuils. Et c’est là que l’*archicration*, en tant que forme d’institution de la régulation, redevient notre outil premier, notre geste inaugural, notre obligation radicale.
-
-Mais ce ne sont pas uniquement les vivants non-humains qui exigent ce retour à la scène. Ce sont les humains eux-mêmes, dans leur diversité traversée de douleurs, de silences, de disparitions, de récits corrompus ou interrompus. Ce sont les corps précarisés, expulsés, captés, mécanisés, racisés, discriminés. Ce sont les voix sans adresse, les luttes étouffées, les demandes restées lettres mortes, les souffrances converties en statistiques, les communautés disqualifiées ou reléguées. Là encore, ce n’est pas un “plus de participation” qu’il faut : c’est un *acte fondateur de refondation*. Ce n’est pas une réforme du droit d’accès à la parole : c’est l’institution d’un droit d’épreuve et de reconnaissance. Encore une fois d’*archicrations* !
-
-Et ce droit n’est pas métaphysique. Il est scénique. Il s’inscrit dans des formes précises, différées, structurées. Il suppose des lieux, des interlocuteurs, des procédures, des archives, des délais, des énonciateurs. Il suppose des scènes que l’on peut habiter, relancer, réinterroger. Il suppose que la parole soit tenue, mais aussi reçue, exposée, contredite, reformulée. Il suppose, enfin, que cette parole soit retenue dans l’architecture même de la régulation. Qu’il ne soit pas juste documenté, mais qu’il puisse reconfigurer le pouvoir sous condition de recevabilité.
-
-Nous appelons donc, à ce stade ultime de notre œuvre, à un réarmement du commun par la scène. Rien d’un théâtre idéologique bien plutôt une architecture du vivre-ensemble, régulatrice, opposable, fondée. Car il ne peut y avoir de monde commun sans scène, pas de scène sans différé, et pas de différé sans pouvoir qui accepte de suspendre son exécution pour se reformuler devant celles et ceux qu’il engage. Ce geste — si simple en apparence, si révolutionnaire en pratique — est le cœur de toute *archicration*. Et c’est à ce titre probablement à tout le moins l’une des rares voies régulatrices encore tenables et viables à nos yeux.
-
-À ce point de saturation du monde — saturation des flux, des normes, des récits, des simulacres de participation — une respiration possible reste celle du moratoire et du différé. La seule densité politique entendable est celle de l’épreuve et des preuves. La seule fondation encore pensable est celle qui accepte de se laisser instituer à nouveau, à se laisser revisiter, en pleine conscience. C’est cela, notre appel : reconvoquer le vivant dans la scène, refaire de l’apparition, de l’information, de l’opinion un droit, refonder la régulation politique en processus d’*archicrations*. Il ne s’agit pas d’ajouter un modèle de plus, mais de rendre à l’histoire ce dont elle a été amputée, faute d’occultation et faute d’impensé : ses scènes fondatrices, émancipatrices et régulatrices qui font tenir les mondes.
-
-Ce que notre époque appelle, est bien plus qu’un ajustement marginal des politiques existantes, bien plus qu’une moralisation incrémentale des comportements individuels. C’est une réinvention des conditions mêmes d’apparition et de mobilisation du pouvoir : des lieux, des temps, des procédures, des mémoires où les décisions qui nous engagent puissent être amenées en scène, instruites, contestées, requalifiées. Les dix gestes qui suivent n’ont pas valeur de programme clos ni de plan de réforme. Ils constituent des hypothèses archicratiques : des propositions de formes scéniques minimales, destinées à être discutées, expérimentées, corrigées. Ils n’ont de sens que s’ils deviennent eux-mêmes objets d’épreuve.
-
-Premier geste : *instaurer un droit universel au différé contradictoire*. Un tel droit ne viserait pas à ralentir indistinctement toute décision, mais à garantir que toute mesure qui affecte substantiellement une existence – allocation, sanction, fermeture, expulsion, tri automatique – puisse être suspendue dans un temps institué, devant une instance capable d’en reconsidérer les motifs et les effets. Ce droit ne se confond pas avec un simple droit au recours individuel : il institue le temps scénique comme composante non négociable de la régulation.
-
-Deuxième geste : *fonder, pour chaque grand dispositif de régulation, un journal de justification*. Il ne s’agirait pas d’ajouter un rapport de plus aux archives administratives, mais d’exiger que toute décision structurante (création d’un algorithme, d’un barème, d’un standard) soit accompagnée d’un récit argumenté de ses raisons, des alternatives écartées, des effets anticipés. Ce journal ne sanctifie pas la décision ; il la rend adressable. Il crée une mémoire publique du fondement, à partir de laquelle critiques, révisions et contre-propositions peuvent être formulées.
-
-Troisième geste : *instituer un visa d’affectation pour les principaux instruments de calcul et de qualification*. Chaque indicateur, chaque score, chaque seuil ne serait plus un simple paramètre technique, mais devrait porter trace de ses finalités déclarées et des collectifs qui en ont débattu. Ce visa n’autorise pas seulement l’utilisation d’un outil ; il inscrit l’outil dans une adresse éthique et politique : qui décide que telle métrique est légitime pour mesurer telle réalité, avec quelles garanties, pour combien de temps ?
-
-Quatrième geste : *instaurer un coupe-circuit citoyen*. Il s’agirait de prévoir, dans les dispositifs institutionnels, des mécanismes par lesquels des collectifs – citoyens, usagers, travailleurs, habitants – puissent suspendre temporairement l’application d’une décision lorsque des contradictions graves, des effets non prévus ou des injustices manifestes apparaissent. Ce geste n’est pas un droit d’obstruction généralisée ; il est la traduction procédurale du principe selon lequel aucune *cratialité* ne doit se déployer sans possibilité d’interruption scénique.
-
-Cinquième geste : *instituer un tribunal de l’algorithme*. Non pas un organe chargé de valider ou d’interdire abstraitement la technique, mais une scène d’épreuve où les architectures computationnelles qui organisent l’accès aux droits, à l’information, aux ressources, soient rendues comparables, critiquables, reformulables. Un tel tribunal devrait être doté de compétences mixtes – juridiques, techniques, sociales – et travailler à partir de cas concrets. Il ne s’agit pas d’ajouter une couche de contrôle symbolique ; il s’agit de ramener l’algorithme en scène.
-
-Sixième geste : *rétablir des assemblées d’affectation là où les décisions sont aujourd’hui dispersées dans des chaînes opaques*. Dans les hôpitaux, les écoles, les agences sociales, les plateformes, ces assemblées seraient chargées d’instruire publiquement la manière dont les ressources, les priorités, les charges et les risques sont distribués. Elles ne se substituent pas aux institutions existantes ; elles en constituent le moment scénique, là où les critères implicites peuvent être explicités, contestés, ajustés.
-
-Septième geste : *rendre révocables les mandats au sein des institutions qui conçoivent, paramètrent et pilotent les dispositifs de régulation*, qu’il s’agisse d’instances publiques, de régulateurs indépendants ou de structures privées investies de missions d’intérêt général. La révocabilité ne signifie pas l’instabilité permanente, mais la possibilité, pour les collectifs concernés, de mettre fin à un mandat lorsqu’il apparaît que l’*archicration* est durablement contournée, que les fondements ne sont plus adressés, que la *cratialité* s’est autonomisée.
-
-Huitième geste : *instaurer, dans chaque budget institutionnel d’importance, un budget scénique*. Il ne s’agirait pas d’un poste décoratif, mais d’une ligne dédiée au financement des dispositifs d’épreuve : temps de délibération, traduction, médiation, expertise contradictoire, dispositifs de restitution. Un budget sans scène est un budget sans adresse. Reconnaître un budget scénique, c’est faire de la scène non plus un coût superflu, mais une condition de validité de la dépense.
-
-Neuvième geste : *inscrire dans le droit un principe général de révision archicrative*. Ce principe reconnaîtrait que toute architecture régulatrice – loi, norme, algorithme, accord institutionnel – doit pouvoir être réexaminée à intervalles déterminés, à partir d’instances où les personnes affectées, les savoirs concernés, les effets constatés sont convoqués. Il ne s’agit pas d’instaurer une instabilité chronique, mais de consacrer le fait que la *co-viabilité* ne se maintient qu’au prix d’une disponibilité organisée à la révision.
-
-Dixième geste : *construire des cartographies des scènes manquantes.* Au lieu de se contenter d’analyses sectorielles, il s’agirait de repérer, sur un territoire ou dans une chaîne de valeur, les lieux où des décisions structurantes sont prises sans scène identifiable, où les personnes affectées n’ont ni adresse, ni délai, ni recours. De telles cartographies ne sont pas un exercice académique de plus : elles constituent un instrument politique central pour orienter l’invention des scènes à venir, pour ne pas laisser invisible ce que la seule *cratialité* préfère absorber.
-
-Ces dix gestes n’épuisent pas la gamme des formes possibles d’*archicration*. Ils ne valent pas comme une doctrine à appliquer, mais comme une invitation à la mise à l’épreuve : ils devront être discutés, critiqués, complétés, remplacés, parfois abandonnés. Leur seule prétention est de montrer que l’*archicratie*, loin d’être un mot abstrait, peut se traduire en dispositifs concrets, situés, qui redonnent aux collectifs la capacité d’adresser le pouvoir qui les traverse. Et c’est à ce niveau que nous posons notre ouvrage, moins une doctrine qu’une mise à l’épreuve publique, moins un programme qu’une fondation différée : l’invitation à restaurer la capacité institutionnelle de refonder le “pouvoir de” et le “pouvoir sur” nos vies, à hauteur de la *téra-machine* en constitution*.*
+Nous n'assistons ni à un retour primordial du désordre ni à une
+raréfaction du pouvoir. Ce qui se transforme, plus discrètement mais de
+manière décisive, ce sont les conditions mêmes sous lesquelles la
+régulation peut apparaître. Ce qui se reconfigure sous nos yeux n'est
+pas d'abord la quantité de pouvoir à l'œuvre dans nos sociétés, mais la
+manière dont ce pouvoir se rend — ou ne se rend plus — visible,
+adressable, contestable. La conflictualité ne disparaît pas ; elle
+change de régime d'existence. Là où elle trouvait autrefois à se
+formuler dans des lieux identifiables, à se différer dans des
+temporalités instituées, à se confronter dans des espaces d'énonciation
+reconnus, elle se trouve de plus en plus distribuée dans des chaînes
+opératoires qui se présentent comme de simples enchaînements techniques.
+Flux, scores, interfaces, barèmes, protocoles : autant de formes qui
+n'abolissent pas les décisions, mais en modifient profondément les
+conditions d'apparition. Ce qui relevait d'une épreuve devient
+traitement. Ce qui relevait d'une adresse devient calcul. Ce qui
+relevait d'une justification devient paramétrage.
+
+Ce déplacement est d'autant plus difficile à saisir qu'il ne se donne
+pas comme rupture. Il s'installe dans la continuité apparente des
+dispositifs, dans l'amélioration de leur efficacité, dans la promesse
+d'une gestion plus rapide, plus fluide, plus objective des situations.
+Le conflit y est désamorcé au nom de la performance. Le différé y est
+perçu comme ralentissement. L'exposition y est remplacée par une
+visibilité sans interlocution, où tout semble disponible sans que rien
+ne soit véritablement tenu. Il ne s'agit pas d'un vide. Il ne s'agit pas
+d'un monde sans normes ni d'un effondrement du pouvoir. Il s'agit d'un
+recouvrement. Ce que cet essai-thèse a nommé oblitération archicratique
+désigne cette dynamique précise : la substitution progressive de la
+scène par l'exécution, du différé par l'automaticité, de l'énonciation
+par la trace, de l'épreuve par la donnée.
+
+Le pouvoir ne cesse pas d'opérer ; il cesse de comparaître. Les
+décisions continuent d'être prises ; elles cessent d'être tenues. Elles
+ne disparaissent pas ; elles se soustraient aux formes où elles
+pourraient être rapportées à leurs fondements, confrontées à leurs
+effets, reprises à partir de ce qu'elles affectent.
+
+Ce qui caractérise ainsi notre situation n'est pas une crise de la
+conflictualité, mais une crise de sa tenue. Non l'absence de dissensus,
+mais l'altération des formes capables de le porter. Non la disparition
+du politique, mais sa désarticulation progressive hors des scènes où il
+pouvait encore apparaître comme tel. À ce niveau, ce que nous appelons
+crise ne relève plus d'un dysfonctionnement partiel, ni d'une dérive
+simplement sectorielle. Elle engage les conditions même dans lesquelles
+un monde peut encore faire apparaître, soutenir et transformer ce qui le
+traverse.
+
+Ce déplacement du regard a commandé tout le parcours accompli. Il a
+d'abord fallu apprendre à voir. Distinguer ce qui fonde de ce qui opère,
+ce qui opère de ce qui met à l'épreuve. Rompre avec les confusions qui
+font passer l'exécution pour la justification, la visibilité pour
+l'opposabilité, la procédure pour la scène. Sans cette discipline de
+détectabilité, le présent demeure illisible et la critique se dissout
+dans des généralités. L'une des ambitions premières de ce travail aura
+donc été de donner des prises : non pas inventer un vocabulaire pour le
+plaisir de l'invention, mais rendre discernable ce que les descriptions
+ordinaires du pouvoir, de la gouvernance et de l'administration laissent
+trop souvent se confondre.
+
+Encore fallait-il que ce vocabulaire n'usurpe pas sa propre nécessité.
+L'archicratie ne vaut pas parce qu'elle pourrait tout redire dans sa
+langue ; elle vaut seulement là où elle permet de discerner quelque
+chose qui, sans elle, resterait confondu, euphémisé ou inaperçu. Elle ne
+constitue donc ni une théorie totale du politique, ni une clef
+universelle des mondes historiques, mais un instrument critique situé,
+tenu à une obligation de retenue : se taire là où il n'apporte aucun
+gain de lisibilité, et répondre de ses distinctions là où il prétend en
+produire. C'est à cette condition seulement qu'un paradigme cesse d'être
+un idiome de surplomb pour devenir une épreuve réelle de connaissance.
+
+Il a fallu ensuite remonter plus loin. Reconnaître que les formes
+d'épreuve ne sont ni des raffinements tardifs des modernités
+représentatives, ni des suppléments ajoutés à des ordres déjà
+constitués, mais des conditions plus profondes de la tenue des mondes
+humains. Avant les États, avant les bureaucraties, avant les
+codifications juridiques stabilisées, des collectifs ont dû inventer des
+manières de différer, de ritualiser, d'exposer ce qui les traversait.
+L'histoire du politique ne commence pas avec la souveraineté constituée
+; elle commence avec la nécessité, pour un monde traversé de forces
+hétérogènes, de ne pas s'abandonner à leur pure immédiateté. Elle
+commence là où quelque chose comme une reprise devient possible, là où
+ce qui affecte peut être reconduit à une forme d'exposition, si
+rudimentaire, violente ou dissymétrique soit-elle. La scène n'est donc
+pas un luxe moderne. Elle appartient à la structure même des mondes qui
+tiennent.
+
+Il a fallu également traverser les grandes pensées du pouvoir, non pour
+les annuler, ni pour les annexer de force à un nouveau système, mais
+pour en mesurer les prises et les limites. Certaines ont privilégié le
+fondement, d'autres l'opération, d'autres encore la conflictualité, la
+dispersion des dispositifs, l'individuation, la justification ou le
+dissensus. Toutes ont saisi quelque chose de réel ; aucune n'a tenu
+entièrement ensemble les conditions d'une régulation habitable. Ce que
+cette traversée a rendu possible, ce n'est pas une synthèse des
+doctrines, mais une méta-grammaire du politique, capable de les relire à
+partir de ce qu'elles permettent — ou non — de penser : comment un
+ordre se fonde, comment il opère, comment il accepte d'être mis à
+l'épreuve.
+
+Il a fallu enfin éprouver cette grammaire dans l'histoire effective des
+transformations modernes, là où les capacités de régulation ont atteint
+une intensité inédite. Ce qui apparaît alors n'est pas seulement une
+succession d'innovations techniques, mais une série de reconfigurations
+du rapport entre fondement, opération et épreuve. Chaque révolution
+industrielle a redessiné ce triangle ; chacune a accru certaines
+puissances tout en décalant, fragmentant ou fragilisant les formes
+capables de les soutenir. L'histoire moderne n'apparaît plus comme celle
+d'un progrès simplement technique ; elle devient lisible comme celle des
+déplacements successifs du lieu où le pouvoir se rend — ou cesse de se
+rendre — comparable, contestable, révisable.
+
+C'est au point le plus brûlant du présent que cette exigence se révèle
+avec la plus grande netteté. Les tensions contemporaines ne se laissent
+pas comprendre comme des crises séparées, ni comme des anomalies
+sectorielles. Elles manifestent, chacune à leur manière, la difficulté
+croissante à instituer des formes dans lesquelles ce qui est affecté par
+les décisions peut être reconduit à une épreuve. Ce qui manque n'est pas
+la capacité à produire des normes, des infrastructures, des critères,
+des instruments. Ce qui manque, de plus en plus, c'est l'habileté à les
+porter. De là la nécessité d'un déplacement conceptuel décisif :
+substituer au lexique lisse de la durabilité la notion de co-viabilité.
+Non pas un équilibre supposé entre intérêts déjà constitués, ni la
+correction technocratique d'externalités, mais l'institution toujours
+fragile, toujours révisable, toujours conflictuelle, des conditions sous
+lesquelles des formes de vie hétérogènes peuvent encore tenir ensemble
+sans destruction irréversible.
+
+Ce qui se dégage ainsi de l'ensemble n'est pas une doctrine
+supplémentaire, encore moins un système clos. C'est une condition — qui ne garantit ni harmonie ni salut, mais sans laquelle aucune
+régulation ne peut être tenue comme monde. Cette condition peut
+désormais être formulée simplement : une régulation ne devient habitable
+qu'à la mesure où ce qui la fonde, ce qui l'opère et ce qui la met à
+l'épreuve demeurent distinguables, articulés et exposables. Toute la
+difficulté tient alors à ceci : maintenir cette distinction sans les
+dissocier, et cette articulation sans les confondre. Là où ces
+dimensions se confondent, se disjoignent ou se dérobent à l'exposition,
+la régulation peut continuer à fonctionner ; elle cesse de se tenir.
+
+C'est cette condition minimale que nous avons nommée archicratie. Ni
+régime parmi d'autres, ni forme institutionnelle déterminée, ni idéal
+moral à incarner : un seuil. Le seuil au-dessous duquel la régulation se
+réduit à sa propre opérativité, et au-dessus duquel elle devient, au
+moins en droit, habitable, parce qu'elle laisse ouverte la possibilité
+de sa reprise. L'archicratie ne désigne ni la justice, ni la bonté, ni
+la douceur des décisions ; elle désigne la condition sans laquelle ces
+questions elles-mêmes cessent de pouvoir être posées politiquement.
+
+Ce qui fonde une régulation ne se confond ni avec une autorité
+abstraite, ni avec un texte, ni avec une tradition invoquée une fois
+pour toutes ; cela renvoie à la capacité d'un ordre à exposer ses
+raisons comme telles. Ce qui opère désigne les instruments, procédures
+et dispositifs par lesquels le monde est effectivement découpé,
+distribué, transformé. Ce qui met à l'épreuve, enfin, ne relève ni d'une
+consultation formelle ni d'un recours marginal, mais de formes
+instituées où fondements, opérations et effets peuvent être suspendus,
+confrontés, repris.
+
+Ces prises ne sont jamais données à l'état pur. Elles se recouvrent, se
+déplacent, se distribuent inégalement selon les configurations. Mais
+leur coprésence différenciée constitue la condition minimale d'une
+régulation vivable. Là où l'opération se déploie sans être reconduite à
+ses raisons, là où les décisions s'appliquent sans passer par des
+épreuves effectives, la régulation bascule vers une forme de fermeture
+qui ne relève ni du chaos ni du retrait du pouvoir, mais de son
+auto-suffisance. Dans une telle configuration, le pouvoir ne se retire
+pas ; il s'accomplit sans comparution. Il produit des effets, parfois
+avec une grande précision, mais sans se laisser reprendre dans des
+formes où ces effets pourraient être rapportés à des raisons
+discutables. Il opère, mais ne s'expose plus. Il décide, mais ne se
+laisse plus adresser. Tout fonctionne ; mais plus rien ne s'expose ni ne
+s'explique.
+
+La différence décisive se situe là. Entre une régulation capable
+d'exécuter des procédures, de reproduire des normes, de gérer des flux,
+et une régulation capable de se rapporter à elle-même à partir de ce
+qu'elle affecte, la différence ne tient pas à l'intensité du pouvoir,
+mais à la possibilité de sa mise à l'épreuve. Ce qui rend un monde
+habitable n'est ni l'absence de tensions, ni la stabilité de ses
+équilibres, ni la pure efficacité de ses dispositifs. C'est la forme
+dans laquelle ce qui le traverse peut être porté sans être nié, différé
+sans être dissous, exposé sans être annihilé.
+
+À partir de là, la question n'est plus d'abord celle d'un bon régime,
+mais celle d'un monde qui tient. Non d'un monde pacifié, homogène ou
+réconcilié, mais d'un monde capable de porter ce qui le traverse sans
+s'abolir dans sa propre exécution. Un monde qui ne tient ni par inertie,
+ni par répétition, ni par l'évidence supposée de ses fondements. Il
+tient parce qu'il est capable de porter ce qui le traverse sans le nier,
+de différer ce qui l'affecte sans le dissoudre, d'exposer ce qui le
+gouverne sans s'effondrer sous sa propre mise en question. Habiter un
+monde ne signifie pas simplement y vivre. Cela signifie pouvoir y
+comparaître. Pouvoir y demander d'où parle ce qui décide. Pouvoir y
+identifier ce qui opère. Pouvoir y rouvrir le temps lorsque l'exécution
+tend à se refermer sur elle-même. Pouvoir y faire apparaître ce qui,
+sans cela, demeurerait converti en variable, en score, en flux.
+
+La scène prend ici son sens le plus fort. Elle n'est ni un supplément
+institutionnel, ni un décor ajouté au pouvoir pour en améliorer
+l'acceptabilité, ni une métaphore commode pour désigner des espaces de
+parole. Elle est l'une des formes à travers lesquelles un ordre cesse
+d'être purement opératoire pour devenir politiquement tenable. Là où il
+y a scène au sens fort — c'est-à-dire espace différé, documenté,
+institué, capable de suspendre et de requalifier — la régulation ne se
+contente pas d'agir : elle accepte de comparaître. C'est dans cette
+comparution que se joue la possibilité, pour un monde, de ne pas se
+réduire à ce qu'il exécute.
+
+Il faut ici maintenir une distinction que tout ce travail a jugée
+décisive. Dire que la scène est condition de viabilité ne signifie
+nullement que toute scène serait en elle-même juste, démocratique ou
+émancipatrice. L'histoire des formes politiques, juridiques,
+religieuses, administratives, guerrières, marchandes ou sacrificielles
+montre au contraire que des scènes peuvent être violentes,
+dissymétriques, inquisitoriales, spectaculaires, capturées. La scène
+n'est pas bonne parce qu'elle apparaît ; elle devient politiquement
+décisive lorsqu'elle institue réellement l'épreuve de ce qu'elle expose.
+Ce qui compte n'est pas l'existence abstraite d'un lieu d'apparition,
+mais la possibilité effective qu'il ouvre : peut-on y demander les
+fondements ? Les instruments peuvent-ils y être rendus visibles ? Les
+effets peuvent-ils y être rapportés à ceux qu'ils affectent ? Le différé
+est-il réel ou purement fictif ? La suspension a-t-elle une force
+transformatrice ou n'est-elle qu'un rite sans prise ?
+
+Il n'en demeure pas moins que, sans scène, la régulation se dégrade
+qualitativement. Elle peut continuer à fonctionner ; elle peut même
+gagner en efficacité apparente. Mais elle perd sa mémoire, sa
+réversibilité, sa capacité à se rapporter à elle-même autrement que par
+recalibrage interne. Elle applique, classe, répartit, déclenche, module
+; mais elle ne se reprend plus. Elle produit des normes sans en exposer
+les raisons, des décisions sans en instituer l'épreuve, des effets sans
+en organiser le retour. Elle tient encore ; mais elle ne sait plus
+répondre de la manière dont elle tient. C'est en ce point qu'un monde
+sans scène devient injustifiable. Non pas nécessairement injuste dans
+chacun de ses effets immédiats ; non pas chaotique ; non pas dépourvu de
+cohérence locale. Il peut très bien fonctionner, produire des résultats,
+stabiliser provisoirement des situations, maintenir des chaînes
+d'obéissance ou d'adaptation. Mais il devient injustifiable parce qu'il
+ne dispose plus des formes dans lesquelles ses propres décisions peuvent
+être rejouées, exposées, interrogées, reformulées.
+
+On comprend alors ce que la co-viabilité signifie exactement. Elle ne
+désigne ni la simple coexistence de formes de vie différentes, ni leur
+compatibilité gestionnaire, ni un optimum de répartition des ressources
+ou des charges. Elle désigne la capacité, toujours fragile, toujours
+située, toujours révisable, d'un monde à instituer des formes dans
+lesquelles les hétérogènes qui le traversent peuvent être mis en tension
+sans être soit mutuellement détruits, soit administrativement
+neutralisés. Elle est moins un état qu'un régime d'épreuves. Elle ne se
+mesure pas seulement à l'efficacité des ajustements ; elle se mesure à
+la possibilité qu'un ordre laisse ouvert sa propre reprise à partir de
+ce qu'il affecte.
+
+C'est à ce niveau que le diagnostic du présent trouve sa formulation la
+plus nette. Non dans l'idée d'un monde privé de régulation, mais dans
+celle d'un monde où la régulation tend à se déployer hors des formes qui
+permettaient de la tenir. Qu'il s'agisse des droits sociaux, de
+l'habitabilité écologique des milieux ou des architectures numériques de
+décision, la même logique se renforce : les dispositifs deviennent plus
+puissants au moment même où les formes capables d'en soutenir l'épreuve
+deviennent plus fragiles, plus tardives, plus périphériques. Ce ne sont
+pas les décisions qui disparaissent ; ce sont les manières dont elles
+pourraient être tenues.
+
+Les droits, dans de nombreuses configurations sociales, se trouvent
+intermédiés par des procédures dont la logique demeure difficilement
+accessible à ceux qu'elles affectent ; les décisions qui concernent
+l'habitabilité écologique des milieux se trouvent portées par des
+instruments puissants, mais rarement rapportées à des espaces où leurs
+fondements pourraient être disputés ; les architectures numériques et
+algorithmiques rendent possible une distribution fine des traitements,
+des classements, des accès, sans rendre aisément localisable le lieu de
+leur mise à l'épreuve. Ces dimensions ne doivent pas être comprises
+comme des sphères séparées. Elles constituent les expressions
+différenciées d'un même processus : celui par lequel la régulation tend
+à se déployer hors des formes d'épreuve qui permettaient de la tenir
+comme monde.
+
+C'est en ce sens que l'autarchicratie peut être nommée comme la
+contre-figure terminale de l'archicratie. Non un régime au sens
+classique, ni une idéologie, ni un type d'État, mais une configuration
+dans laquelle la régulation tend à se refermer sur sa propre
+opérativité, à produire ses propres critères de validité, à
+s'auto-justifier sans passer par des épreuves effectives. Dans une telle
+configuration, les instruments, les modèles, les indicateurs, les
+procédures deviennent à la fois ce qui opère et ce qui justifie. Les
+boucles se ferment. Les ajustements se font à partir de leurs propres
+résultats. Les audits vérifient la conformité à des critères produits
+par les systèmes eux-mêmes. La régulation devient auto-référentielle.
+
+Cette bascule ne doit pas être dramatisée comme si elle était totale,
+homogène, déjà accomplie. Des scènes subsistent, parfois robustes,
+parfois fragiles. Des espaces de contestation, de délibération, de
+reprise continuent d'exister. Mais ils apparaissent souvent comme
+disjoints des lieux où les décisions se prennent effectivement. La
+tension se joue moins entre présence et absence de scène qu'entre leur
+centralité et leur marginalisation. Le problème décisif n'est pas de
+savoir si toute scène a disparu ; il est de comprendre que la dynamique
+dominante tend à rendre optionnelle l'épreuve dont dépend pourtant la
+viabilité de la régulation.
+
+C'est ici que la distinction entre durabilité et co-viabilité prend
+toute sa force. La durabilité, telle qu'elle s'est imposée dans les
+discours contemporains, ne doit pas être critiquée d'abord pour ses
+intentions, mais pour sa forme. Elle tend à fonctionner comme un
+opérateur de neutralisation de la conflictualité : en posant comme
+objectif la préservation ou l'ajustement de certains équilibres, elle
+déplace l'attention vers la gestion des variables, l'optimisation des
+paramètres, la correction des trajectoires. Ce déplacement n'est pas
+illégitime en soi ; il le devient lorsqu'il s'accompagne d'une
+évacuation des formes dans lesquelles les choix qui structurent ces
+trajectoires pourraient être discutés. La durabilité peut alors
+s'accommoder d'une régulation sans scène. La co-viabilité, elle, en fait
+une impossibilité.
+
+La différence est décisive. La première tend à organiser la continuité
+des systèmes ; la seconde à instituer les conditions de leur reprise. La
+première privilégie l'ajustement des variables ; la seconde la mise à
+l'épreuve des fondements. La première peut se satisfaire d'une
+gouvernance qui corrige des déséquilibres ; la seconde exige des formes
+dans lesquelles les conditions mêmes de ces corrections peuvent être
+adressées, contestées, transformées. Ainsi comprise, la co-viabilité ne
+constitue pas un idéal abstrait. Elle désigne le régime minimal dans
+lequel un monde peut continuer à se transformer sans se soustraire à sa
+propre interrogation. Elle n'abolit pas les tensions ; elle en organise
+la tenue. Elle n'élimine pas les conflits ; elle en rend l'épreuve
+possible. Elle ne garantit pas la justice ; elle rend au moins pensable
+sa recherche.
+
+Il reste alors à comprendre ce qui, en dernière instance, est affecté
+par cette transformation. Non pas seulement des institutions, des
+règles, des procédures, mais des formes d'existence. Des vies. Des
+milieux. Des devenirs. Si l'archicratie prend finalement une telle
+importance, ce n'est pas parce qu'elle offrirait une théorie plus
+satisfaisante du pouvoir ; c'est parce qu'elle reconduit l'analyse à ce
+qui, sans scène, devient politiquement illisible. Là où la régulation se
+déploie sous forme de flux, de calculs, de traitements, le vivant tend à
+être reconduit à des variables. Les milieux deviennent des stocks ou des
+contraintes. Les corps deviennent des profils, des trajectoires, des
+cas. Les expériences deviennent des données d'ajustement. Ce processus
+n'est pas nécessairement intentionnel. Il résulte de la logique même des
+dispositifs qui, pour fonctionner, doivent simplifier, catégoriser,
+standardiser. Mais cette simplification a un effet décisif : elle
+désinscrit le vivant de la scène. Elle le rend opérable sans qu'il ait à
+apparaître.
+
+Le vivant ne disparaît pas ; il devient politiquement illisible. Il est
+là, partout affecté, mobilisé, transformé — mais de moins en moins
+capable de faire retour sur ce qui l'affecte. Un monde sans archicration
+est un monde dans lequel le vivant est présent sans être représentable,
+affecté sans être adressable, engagé sans être entendu. Il est pris dans
+des opérations, mais il ne peut plus apparaître comme ce à partir de
+quoi celles-ci devraient être interrogées.
+
+C'est en ce sens que l'oblitération archicratique produit une crise de
+reconnaissance. Non pas au sens restreint d'une reconnaissance morale ou
+symbolique, mais au sens plus fondamental d'une reconnaissance comme
+condition d'apparition dans un espace où l'on peut être pris en compte.
+Reconnaître ne signifie pas simplement identifier ou décrire. Cela
+signifie instituer des formes dans lesquelles ce qui est affecté peut
+être reconduit à une scène, où il peut être exposé, où il peut entrer en
+relation avec ce qui décide. Sans cette reconnaissance, le vivant peut
+être protégé, géré, optimisé ; il ne peut pas être politiquement tenu.
+
+Il faut alors comprendre que la question de la scène n'est pas
+extérieure à celle de la liberté. Elle en constitue l'une des conditions
+minimales. Non la liberté comme autonomie absolue, mais comme
+possibilité d'intervenir sur les conditions qui nous affectent. Une
+société qui ne dispose plus de formes dans lesquelles ses propres
+régulations puissent être interrogées tend à se percevoir comme soumise
+à des nécessités. Elle perd la capacité de distinguer ce qui relève de
+contraintes inévitables et ce qui relève de choix. À l'inverse, une
+société qui institue des épreuves se dote de la possibilité de se
+rapporter à elle-même comme à un ensemble de décisions révisables. Elle
+ne supprime pas les contraintes, mais elle les inscrit dans des formes
+où elles peuvent être discutées.
+
+À ce point, aucune réponse définitive ne peut être apportée. Aucun
+modèle achevé ne peut être proposé. Mais une exigence demeure, désormais
+visible et irréductible. Un monde ne devient inhabitable ni parce qu'il
+est traversé de tensions, ni parce qu'il doit décider dans
+l'incertitude, ni parce qu'il affronte des contraintes puissantes. Il le
+devient lorsqu'il ne dispose plus des formes capables de porter ce qui
+le traverse autrement que par la pure exécution. Ce qui est en jeu n'est
+ni la suppression du conflit, ni l'optimisation des dispositifs, ni la
+stabilisation d'un équilibre. Ce qui est en jeu, c'est la possibilité de
+maintenir ouvertes les formes dans lesquelles un monde peut se rapporter
+à lui-même à partir de ce qu'il affecte. La possibilité, toujours
+fragile, toujours menacée, de ne pas confondre ce qui fonctionne avec ce
+qui se tient.
+
+Rendre à la régulation les formes dans lesquelles elle peut encore être
+tenue comme monde : telle est l'exigence à laquelle reconduit l'ensemble
+de ce parcours. Non comme un programme, ni comme une promesse, mais
+comme ce sans quoi aucune transformation ne peut être habitée. Car ce
+n'est jamais l'ordre seul qui fait tenir un monde. C'est la possibilité,
+pour cet ordre, d'être interrompu, exposé, repris. Là où cette
+possibilité se ferme, le monde peut continuer à marcher ; il cesse peu à
+peu d'être habitable. Là où elle demeure ouverte, fût-ce dans le
+conflit, sous contrainte, précairement, quelque chose du politique
+subsiste encore : non la paix, ni l'innocence, ni l'harmonie, mais la
+capacité d'un monde à ne pas se confondre avec sa propre exécution.

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,139 @@
+---
+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"
+---
+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,533 @@
+---
+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"
+---
+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,271 @@
+---
+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"
+---
+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,350 @@
+---
+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"
+---
+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.