Pour les alternatives Skill, curl et git-clone, ainsi que les systèmes PEP 668 et la configuration du masquage des secrets, consultez le [guide d'installation complet](https://github.com/prismorsec/prismor/blob/main/docs/installation.md).

---

## Capacités<a name="capabilities" />

![Architecture Prismor](https://assets.kitploit.com/production/public/readmes/13903/0e84c7211b3275de581182b7f69c44d8224142323b43220dd1234eee17616757.png)

- 🛡️ [Prismor](https://github.com/prismorsec/prismor/blob/main/docs/prismor-runtime.md) couvre le moteur de politiques, les journaux de session, l'audit de sécurité et la référence CLI
- 📦 [Chaîne d'approvisionnement](https://github.com/prismorsec/prismor/blob/main/docs/supply-chain.md) couvre l'application des règles à l'installation, la correspondance des IOC et le calcul du score de risque
- 🛜 [Isolation réseau](https://github.com/prismorsec/prismor/blob/main/docs/network-isolation.md) couvre le contrôle de sortie piloté par politique, la détection d'IP brutes et le blocage des tunnels
- 🔍 [Scanner de Skills](https://github.com/prismorsec/prismor/blob/main/docs/skill-scanner.md) couvre l'analyse des risques des serveurs MCP et des skills sur les agents pris en charge
- 🚦 [Garde-fous MCP](https://github.com/prismorsec/prismor/blob/main/docs/prismor-runtime.md#custom-guardrails-for-mcp-tools) vous permettent de bloquer un serveur ou un outil MCP spécifique, ou d'exiger une approbation humaine avant que l'agent ne l'appelle, avec une règle de politique que vous écrivez vous-même
- 🛰️ [Passerelle MCP](https://github.com/prismorsec/prismor/blob/main/docs/mcp-gateway.md) est un connecteur MCP unique qui se place devant tous les autres serveurs MCP que vous utilisez — chaque `tools/call` est évalué par la politique avant d'être transmis et chaque réponse est analysée pour détecter les injections avant que le modèle ne la voie, de sorte qu'un résultat d'outil empoisonné ne devienne jamais du contexte. `prismor mcp-gateway install` déplace un `.mcp.json` existant derrière elle
- 🛤️ [Proxy LLM](https://github.com/prismorsec/prismor/blob/main/docs/llm-proxy.md) gouverne un agent que Prismor ne peut pas intercepter, via la seule chose que tout agent possède : son trafic vers le modèle. Pointez-le vers `prismor proxy` avec `ANTHROPIC_BASE_URL`, `OPENAI_BASE_URL`, ou `HttpOptions(base_url=...)` du SDK Google Gen AI et rien d'autre ne change pour l'agent. Chaque appel d'outil que le modèle *propose* — `tool_use` d'Anthropic, `tool_calls` d'OpenAI, `functionCall` de Gemini — est reformé en un événement identique à celui produit par un hook `Bash` et jugé par la même règle, les appels en streaming étant retenus jusqu'à ce qu'ils puissent être jugés
- [Hooks d'inférence Claude](https://github.com/prismorsec/prismor/blob/main/docs/inference-hook.md) fait de Prismor le serveur de sécurité IA derrière Claude Enterprise : Anthropic envoie chaque prompt gouverné depuis claude.ai, Claude Code et Cowork à `prismor inference-hook serve`, qui exécute votre politique sur la transcription et répond allow/deny avant que le modèle ne s'exécute — requêtes signées (Standard Webhooks), fail-closed, mode shadow, rien à installer sur les appareils des utilisateurs. `prismor inference-hook test` envoie des trames d'exemple signées pour vérifier le câblage
- 🏷️ [Étiquettes d'outils](https://github.com/prismorsec/prismor/blob/main/docs/tool-tags.md) classifient les outils par capacité (read, write, network, exec) afin qu'une règle puisse dire « rien qui lit des données privées ne peut aussi atteindre le réseau » au lieu de nommer chaque outil un par un — les outils MCP se déclarent eux-mêmes via `_meta`, et `prismor tags` liste, teste et vérifie les expressions de règles
- 🔐 [Sweep et Cloak](https://github.com/prismorsec/prismor/blob/main/docs/sweep-and-cloak.md) couvre la prévention des secrets aux frontières des outils, la configuration pratique, les bonnes pratiques, le modèle de menace et le nettoyage des secrets divulgués
- 🦞 [Intégration OpenClaw](https://github.com/prismorsec/prismor/blob/main/docs/openclaw.md) couvre les hooks d'exécution, l'analyse des injections de prompt et la configuration au niveau projet ou utilisateur pour OpenClaw
- 🤖 [Masquage de l'agent Hermes](https://github.com/prismorsec/prismor/blob/main/docs/hermes.md) couvre le masquage des secrets spécifique à Hermes avec l'auto-découverte des points d'entrée pip, l'installation sur le système de fichiers et le garde-fou de collage pre_gateway_dispatch
- ☁️ [VM d'agents hébergés](https://github.com/prismorsec/prismor/blob/main/docs/cloud-agents.md) gouverne les agents qui s'exécutent sur une machine sur laquelle vous ne vous connectez jamais (Claude Code sur le web, agents cloud Cursor, agent de codage Copilot, OpenHands Cloud, Codex cloud, Replicas) : le script d'installation de la plateforme installe le binaire, et `install-hooks --portable` écrit une configuration de hooks qui peut être commitée sans risque
- 🧠 [Garde sémantique](https://github.com/prismorsec/prismor/blob/main/docs/semantic-guard.md) : couche hybride optionnelle qui ajoute une vérification d'intention assistée par LLM pour les tentatives d'injection de prompt paraphrasées que les règles regex ne peuvent pas détecter
- 🪤 [Canary](https://github.com/prismorsec/prismor/blob/main/docs/canary.md) plante des fichiers d'identifiants honeytoken qui déclenchent une alerte CRITICAL dès qu'un agent les lit, détectant ainsi les comportements de reconnaissance
- 🪪 [IAM](https://github.com/prismorsec/prismor/blob/main/docs/iam.md) donne à chaque agent une identité nommée et un profil de permissions à moindre privilège lorsque plusieurs agents partagent un espace de travail
- 🧩 [Agents de frameworks](https://github.com/prismorsec/prismor/blob/main/docs/frameworks-overview.md) protège les agents de production (OpenAI Agents SDK, LangChain/LangGraph en Python et JS, CrewAI, browser-use, Pydantic AI, AutoGen Core, Agno, Semantic Kernel, Google ADK, BeeAI, Claude Agent SDK, Vercel AI SDK, Mastra) avec un seul appel — enveloppez chaque requête dans `use_subject("user:alice")` et un agent multi-tenant obtient une attribution par utilisateur, des profils IAM par utilisateur et une suspension par utilisateur
- 🎯 [Agent à portée limitée](https://github.com/prismorsec/prismor/blob/main/docs/scoped-agent.md) synthétise des règles minimales et spécifiques à la tâche par session afin qu'un pivot hors tâche injecté soit bloqué
- 🧬 [Apprentissage](https://github.com/prismorsec/prismor/blob/main/docs/learning.md) exploite l'historique des sessions pour proposer de nouvelles règles, signaler les faux positifs et détecter les contournements
- ⚖️ [Politiques en couches et exemptions](https://github.com/prismorsec/prismor/blob/main/docs/policy-layers-and-exemptions.md) couvre le mode observe/enforce par règle, le plancher non contournable et les exemptions accordées par un administrateur et limitées dans le temps à travers les couches org / projet / dépôt
- 🔐 [Sélection explicite de l'enforce et fenêtre de déverrouillage](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md#choosing-what-blocks) — la configuration de l'enforce commence sans rien bloquer et vous choisissez l'ensemble ; `prismor allow` crée des exceptions étroites, et `prismor unlock` ouvre une fenêtre protégée par mot de passe et limitée dans le temps pendant laquelle un agent peut modifier la politique (jamais les règles d'auto-protection qui gardent Prismor lui-même)
- 📡 [Télémétrie en direct](https://github.com/prismorsec/prismor/blob/main/docs/live-telemetry.md) couvre la liaison optionnelle au plan de contrôle d'entreprise — enrôlement des appareils, politique distante signée et télémétrie expurgée transmise en flux vers un tableau de bord d'organisation auto-hébergé
- 🔌 [Récepteurs de télémétrie](https://github.com/prismorsec/prismor/blob/main/docs/telemetry-sinks.md) transmettent chaque détection vers ce que vous utilisez déjà — un collecteur OpenTelemetry (logs OTLP/HTTP), Splunk HEC, Datadog, syslog, un webhook, ou un fichier local en JSON/CEF/OCSF — envoyé avant la décision de blocage et jamais capable de bloquer un appel d'outil
- 📊 [Tableau de bord](https://github.com/prismorsec/prismor/blob/main/docs/dashboard.md) couvre les tableaux de bord terminal et web local ainsi que la forensique de session, avec `prismor tokens` détaillant où le contexte et les dépenses de tokens d'une session sont réellement allés
- 🩺 [Santé et récupération](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md) — `prismor doctor` vérifie l'état de chaque sous-système (hooks, signature de politique, enrôlement, récepteur de télémétrie, état de la chaîne), et `prismor pause` / `pause-hard` suspend *uniquement l'enforce* pour un humain pendant un incident tandis que la journalisation en mode observe continue de fonctionner
- 🧾 [Piste d'audit signée](https://github.com/prismorsec/prismor/blob/main/docs/audit-trail.md) chaîne par hachage et signe avec Ed25519 chaque action d'agent localement, de sorte que `prismor trail verify` prouve que l'historique n'a pas été modifié, supprimé ou réécrit
- 🔖 [Reçus de télémétrie signés](https://github.com/prismorsec/prismor/blob/main/docs/telemetry-receipts.md) est le schéma de transmission des enregistrements qu'un appareil rapporte — octets canoniques, les deux couches d'intégrité et un vérificateur de référence sans dépendance, afin qu'un SIEM ou un auditeur puisse vérifier un reçu sans Prismor
- 📑 [Bundle d'attestation](https://github.com/prismorsec/prismor/blob/main/docs/attestation-bundle.md) regroupe la posture, l'inventaire des agents, la découverte des hôtes, la couverture du contrôle des frameworks (OWASP LLM/Agentic, NIST AI RMF, EU AI Act) et l'ancre de la piste dans un seul fichier signé Ed25519 qu'un auditeur revérifie avec `prismor attest verify`
- 🔦 [Découverte des hôtes](https://github.com/prismorsec/prismor/blob/main/docs/attestation-bundle.md#host-discovery) balaie la machine avec `prismor discover` et signale tout agent IA fonctionnant sans hooks Prismor (shadow AI)
- ⏪ [Ingestion de transcriptions](https://github.com/prismorsec/prismor/blob/main/docs/transcript-ingest.md) reconstruit ce que vos agents ont fait *avant* l'installation de Prismor — `prismor ingest --discover` rejoue les transcriptions de session sur disque à travers le moteur de politiques en direct, de sorte que le tableau de bord soit peuplé dès le premier jour et que vous puissiez voir exactement ce qu'aurait bloqué le passage d'une règle en enforce, plus `--coverage` pour les sessions qui ont tourné sans surveillance
- 🗺️ [Revue d'architecture IA agentique](https://github.com/prismorsec/prismor/blob/main/docs/agentic-architecture-review.md) est une liste de contrôle de conception pour les systèmes multi-agents/utilisant des outils — portée des permissions, intégrité de la mémoire, confiance inter-agents, placement de la supervision humaine — chaque élément étant mappé à un ID de contrôle réel et, lorsqu'il existe, à la règle Prismor qui le soutient
- 🐳 [Docker et conteneurs](https://github.com/prismorsec/prismor/blob/main/docs/docker.md) couvre le durcissement des conteneurs, les prérequis et les limitations connues

Carte complète des commandes pour chaque capacité : [Référence CLI](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md).

Ces capacités correspondent au [OWASP Top 10 for LLM Applications](https://genai.owasp.org/llm-top-10/) - couvrant l'injection de prompt (LLM01), la divulgation d'informations sensibles (LLM02), la chaîne d'approvisionnement (LLM03), la gestion inappropriée des sorties (LLM05) et l'agence excessive (LLM06).

---

## Scénarios et cas d'usage<a name="scenarios-and-use-cases" />

Des workflows réels avec les commandes et la configuration qui les font fonctionner — l'intégration d'une équipe en mode observe, l'attribution IAM par utilisateur pour les pipelines multi-agents et de frameworks, la découverte du shadow AI, l'approbation renforcée pour les opérations à enjeux élevés, et la génération d'un bundle d'attestation signé pour un audit de conformité. Voir [USE_CASES.md](https://github.com/prismorsec/prismor/blob/main/USE_CASES.md).

---

## Configuration<a name="configuration" />

### Référence des commandes

Carte complète des commandes : [docs/cli-reference.md](https://github.com/prismorsec/prismor/blob/main/docs/cli-reference.md).

### Modes de gouvernance

`prismor setup` vous demande de choisir une posture au lieu de configurer six axes de politique à la main. Chacune se compile dans `.prismor/policy.yaml` — enforce, egress, accès aux outils, règles d'étiquettes, sandbox et frontière de données ensemble.

![Modes de gouvernance Prismor](https://raw.githubusercontent.com/prismorsec/prismor/main/assets/prismor-modes.png)

| Mode | Pour | Couverture | Friction |
|---|---|---|---|
| `dev-safe` | Travail sur des fonctionnalités dans du code que vous n'avez pas lu | 31% | 9% |
| `trusted-workspace` | Dépôts internes de confiance, travail Docker local | 34% | 9% |
| `regulated-airgap` | PII/PHI, SOC 2, EU AI Act — pas de réseau, pas de shell | 100% | 90% |```bash
prismor mode list                            # compare the three
prismor mode explain dev-safe                # the trade, including what it does NOT stop
prismor mode apply dev-safe                  # compile it into this workspace
prismor mode apply regulated-airgap --observe   # what it would block, blocking nothing

### Un seul moteur de politiques, toutes les surfaces d'application

L'étape 1 possède plus d'une porte, et c'est délibéré : aucun point d'interposition
unique ne couvre tous les agents. Les hooks sont les plus larges, mais tous les hôtes
n'en proposent pas ; MCP est le seul endroit où certains agents peuvent être interceptés
du tout ; les agents de frameworks de production s'exécutent là où il n'y a aucun hôte
à hooker.

Ainsi, chaque surface normalise ce qu'elle a vu en un événement canonique unique et
demande le même évaluateur pour un verdict. Une règle écrite une fois couvre la même
action quelle que soit la façon dont elle arrive.

| surface | ce qu'elle gouverne | refuser | réécrire l'entrée | masquer la sortie |
|---|---|:--:|:--:|:--:|
| Hooks d'agents de codage | toute la surface d'outils d'un agent | oui | Claude/Qwen | non |
| Passerelle MCP | chaque serveur MCP derrière un connecteur | oui | oui | oui |
| Built-ins mis en miroir | les propres Bash/Read/Write de l'agent, via MCP | oui | oui | oui |
| Adaptateurs de SDK de frameworks | agents in-process (13 frameworks) | oui | non | non |
| `prismor eval-server` | appelants non-Python, proxys externes | oui | oui | oui |
| Canal d'inference-hook | webhook de tour de transcription hébergé | oui | non | non |

« Masquer la sortie » est la raison d'être du miroir : un hook pré-action ne peut que
*refuser* une lecture de fichier, tandis qu'une surface qui transporte la réponse peut
retourner le fichier avec le credential masqué.

Ceci est vérifié plutôt qu'affirmé — `tests/test_surface_conformance.py`
rejoue une action à travers le normaliseur propre à chaque surface et échoue s'ils
divergent sur le verdict ou la règle.

Voir [le contrat de décision](https://github.com/prismorsec/prismor/blob/main/docs/decision-contract.md) pour la forme de l'événement et
le vocabulaire des verdicts, et [les surfaces de gouvernance](https://github.com/prismorsec/prismor/blob/main/docs/governance-surfaces.md) pour
savoir quelle surface utiliser selon l'agent.

---

## Capacités sélectionnées, détaillées<a name="selected-capabilities-walked-through" />

Trois modules issus de [Capacités](#capabilities), avec configuration, sortie et résultats.

### Défense hybride sémantique contre l'injection de prompt<a name="hybrid-semantic-prompt-injection-defense" />

Les règles regex attrapent les formes d'injection connues. Le garde sémantique ajoute une couche sensible à l'intention : un pré-filtre heuristique traite les cas évidents en <1 ms, et les entrées incertaines sont escaladées vers un juge LLM qui détient le verdict dans tous les cas — il confirme les attaques paraphrasées que la regex n'a vues qu'à moitié et disculpe le texte bénin qui a déclenché un signal de revendication d'autorité. Testé sur plus de 800 cas — **+30 % de rappel** sans faux positifs supplémentaires, y compris les injections paraphrasées et dans les fichiers qui contournent la regex.

![Résultats du garde sémantique](https://assets.kitploit.com/production/public/readmes/13903/a32297d3549c5ff60690c8dca14490f1d53a17a253d912bcb2187414dea3d018.png)

Le juge s'exécute sur un login que vous possédez déjà — aucune clé API nécessaire. `prismor setup` le demande à son étape **LLM judge** ; en script :```bash
prismor setup --non-interactive --judge claude   # Claude Code CLI, your Claude login
prismor setup --non-interactive --judge codex    # Codex CLI, your ChatGPT login
prismor setup --non-interactive --judge api --judge-model gpt-4o-mini   # any litellm model + key

# Démarrer le serveur MCP
mcp-server --port 8080

# Se connecter à un serveur distant
mcp-client --server http://remote-server:8080 --token YOUR_TOKEN

# Exécuter avec un fichier de configuration
mcp-server --config /path/to/config.yaml

# Activer la journalisation verbeuse
mcp-server --verbose

# Définir un délai d'expiration personnalisé
mcp-client --timeout 60 --retry 5

# config.yaml
server:
  host: "0.0.0.0"
  port: 8080
  timeout: 30
  retry: 3

auth:
  enabled: true
  token: "your-secret-token"
  expires_in: 3600

logging:
  level: "info"
  format: "json"
  output: "stdout"

tools:
  enabled:
    - "file-read"
    - "file-write"
    - "http-request"
  disabled:
    - "shell-exec"

security:
  allowed_paths:
    - "/home/user/data"
    - "/tmp/mcp"
  max_file_size: 10485760  # 10MB
  rate_limit:
    enabled: true
    requests_per_minute: 60

from mcp_server import Tool, ToolParameter

class CustomTool(Tool):
    name = "custom-tool"
    description = "Description de l'outil personnalisé"

    parameters = [
        ToolParameter(
            name="input",
            type="string",
            description="Paramètre d'entrée",
            required=True
        )
    ]

    async def execute(self, input: str) -> str:
        # Implémentez votre logique ici
        return f"Résultat : {input}"

# Authentification par jeton Bearer
curl -H "Authorization: Bearer YOUR_TOKEN" http://localhost:8080/api/tools

# Authentification par clé API
curl -H "X-API-Key: YOUR_API_KEY" http://localhost:8080/api/tools

security:
  allowed_paths:
    - "/home/user/data"
    - "/tmp/mcp"
  denied_paths:
    - "/etc"
    - "/root"

security:
  rate_limit:
    enabled: true
    requests_per_minute: 60
    burst: 10

# Cloner le dépôt
git clone https://github.com/example/mcp-server.git
cd mcp-server

# Créer un environnement virtuel
python -m venv venv
source venv/bin/activate  # Sous Windows : venv\Scripts\activate

# Installer les dépendances
pip install -r requirements.txt

# Installer en mode développement
pip install -e .

# Exécuter tous les tests
pytest

# Exécuter avec couverture
pytest --cov=mcp_server --cov-report=html

# Exécuter des tests spécifiques
pytest tests/test_server.py -v

# Formater le code
black mcp_server/

# Vérifier le code
flake8 mcp_server/

# Vérification des types
mypy mcp_server/

# Construire l'image
docker build -t mcp-server:latest .

# Exécuter le conteneur
docker run -d \
  --name mcp-server \
  -p 8080:8080 \
  -e MCP_TOKEN=your-secret-token \
  -v /path/to/config.yaml:/app/config.yaml \
  mcp-server:latest

version: '3.8'

services:
  mcp-server:
    build: .
    ports:
      - "8080:8080"
    environment:
      - MCP_TOKEN=your-secret-token
      - MCP_LOG_LEVEL=info
    volumes:
      - ./config.yaml:/app/config.yaml
      - ./data:/app/data
    restart: unless-stopped

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-server
  template:
    metadata:
      labels:
        app: mcp-server
    spec:
      containers:
      - name: mcp-server
        image: mcp-server:latest
        ports:
        - containerPort: 8080
        env:
        - name: MCP_TOKEN
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: token
``````yaml
# .prismor/policy.yaml
settings:
  semantic_guard:
    provider: codex   # api | claude | codex
    model: ""         # "" = that CLI's default model

# Requête GET de base
./tool -s http://localhost:8080

# Requête POST avec données
./tool -s http://localhost:8080 -X POST -d '{"key":"value"}'

# Avec authentification par jeton
./tool -s http://localhost:8080 -t "your-token-here"

# Avec en-têtes personnalisés
./tool -s http://localhost:8080 -H "X-Custom: value" -H "Accept: application/json"

# Via un proxy
./tool -s http://localhost:8080 -p http://127.0.0.1:8080

# Sortie au format tableau
./tool -s http://localhost:8080 -f table

server: http://localhost:8080
token: your-token-here
proxy: http://127.0.0.1:8080
insecure: false
verbose: false
format: json

# Cloner le dépôt
git clone https://github.com/example/tool.git
cd tool

# Installer les dépendances
go mod download

# Compiler
go build -o tool ./cmd/tool

# Ou utiliser make
make build

# Exécuter tous les tests
go test ./...

# Avec couverture
go test -cover ./...

# Tests d'intégration
go test -tags=integration ./...

tool/
├── cmd/
│   └── tool/
│       └── main.go
├── internal/
│   ├── client/
│   ├── config/
│   └── output/
├── pkg/
│   └── api/
├── go.mod
├── go.sum
└── README.md

Verdicts : `< 30` autoriser · `30–59` avertir · `≥ 60` bloquer. Une correspondance IOC bloque toujours. Créez un alias pour vos gestionnaires de paquets afin de filtrer automatiquement chaque installation.

`prismor supplychain harden` écrit les paramètres de verrouillage dans `.npmrc` / `.yarnrc.yml` / `pip.conf` / `.cargo/config.toml` afin que le gestionnaire de paquets les applique même lorsque l'alias est contourné (CI, plugins IDE).```bash
prismor supplychain harden           # apply to current directory
prismor supplychain harden --dry-run

`--scope` a pour valeur par défaut `project`. **Les portées project et user modifient des fichiers différents** — exécuter uniquement `--scope user` ne touche *pas* les hooks locaux d'un workspace, et inversement :

| Agent | Portée project | Portée user |
|---|---|---|
| Claude Code | `<workspace>/.claude/settings.json` | `~/.claude/settings.json` |
| Cursor | `<workspace>/.cursor/hooks.json` | `~/.cursor/hooks.json` |
| Windsurf | `<workspace>/.windsurf/hooks.json` | `~/.codeium/windsurf/hooks.json` |
| OpenClaw | `<workspace>/.openclaw/plugins.json` | `~/.openclaw/config.json` |
| Hermes | `<workspace>/.hermes/plugins.json` | `~/.hermes/config.json` |
| Codex | `<workspace>/.codex/hooks.json` | `~/.codex/hooks.json` |
| Copilot | `<workspace>/.github/copilot/hooks.json` | `~/.copilot/hooks.json` |
| Grok Build | `<workspace>/.grok/hooks/prismor.json` | `~/.grok/hooks/prismor.json` |
| Kiro CLI | `<workspace>/.kiro/agents/kiro_default.json` | `~/.kiro/agents/kiro_default.json` |
| Crush | `<workspace>/crush.json` | `~/.config/crush/crush.json` |
| OpenHands | `<workspace>/.openhands/hooks.json` | `~/.openhands/hooks.json` |
| Qwen Code | `<workspace>/.qwen/settings.json` | `~/.qwen/settings.json` |
| Continue CLI | `<workspace>/.continue/settings.json` | `~/.continue/settings.json` |
| Goose | `<workspace>/.agents/plugins/prismor/hooks/hooks.json` | `~/.agents/plugins/prismor/hooks/hooks.json` |

Si vous n'exécutez qu'une seule portée, les hooks de l'autre (s'ils sont installés) continuent de se déclencher. Exécutez les deux si vous voulez que Prismor soit complètement hors jeu pour un agent.

Une session en cours a déjà chargé sa configuration de hooks — une désinstallation en cours de session ne prendra effet qu'au démarrage d'une nouvelle session.

Si `prismor uninstall-hooks` signale un succès mais que les hooks se déclenchent toujours, vous utilisez probablement une installation obsolète — par exemple une copie installée via `pipx` qui est un instantané périmé d'un checkout de développement. Vérifiez `which immunity` et, si cela pointe vers un venv `pipx`, réinstallez depuis la source actuelle (`pipx install --force <path-or-package>`) avant de relancer la désinstallation. En dernier recours, modifiez directement le fichier de configuration des hooks à la main.

### 2. Désactivation douce : mode observe + dry-run

Gardez les hooks installés mais empêchez-les de bloquer :```bash
prismor install-hooks --agent all --scope project --mode observe
PRISMOR_LOCAL_DRY_RUN=1   # set in your shell/session env