Intégrer la recherche et l’assistant IA LegiPro

Prise en main

Choisissez l’interface adaptée : REST pour un démarrage rapide, GraphQL pour des requêtes structurées, MCP pour connecter un agent, CLI pour automatiser les vérifications et closeouts. Toutes utilisent les mêmes contrats et la même authentification bearer quand elles appellent le produit.

export LEGIPRO_API_KEY="lp_demo_public_search_2026_11_01"
export LEGIPRO_BASE_URL="https://legipro.fr/v0"

curl -sS "$LEGIPRO_BASE_URL/accounts/2026/search?q=banque" \
  -H "Authorization: Bearer $LEGIPRO_API_KEY" \
  -H "Accept: application/json"

Les jetons publics ci-dessous servent aux démonstrations. Les jetons dédiés aux cabinets seront générés depuis le portail et utilisés en backend, avec gestion des droits, corpus et quotas via la clé.

Pour une intégration serveur côté partenaire, utilisez le quickstart autonome assets/legipro-partner-quickstart-2026-06-27.md : health, recherche, retrieve, GraphQL, MCP, en-têtes tenant/workspace/cost-units et interdiction explicite des bearer tokens côté navigateur/mobile.

Pourquoi cette API ?

LegiPro n’est pas qu’une interface web. C’est une couche de connaissances juridiques et comptables, accessible via trois protocoles cohérents et un CLI opérateur qui rejoue les mêmes contrats.

• REST : démarrage rapide, vérifications d’état, scripts simples et intégrations légères.
• GraphQL : requêtes ciblées sur les corpus, documents, extraits, liens sources, validité temporelle et exports.
• MCP : connecteur pour interroger LegiPro depuis un environnement IA sécurisé.
• CLI : automatisation QA, documentation, GraphQL/MCP, recherche, manifeste et closeout rotor sans créer une seconde logique métier.
• Un socle commun : authentification bearer, cabinet, espace, corpus, date applicable, quotas et journaux d’usage partagés.

Les sources officielles restent la référence. LegiPro organise les codes, doctrines, corpus professionnels, documents, extraits, assistant et exports dans une interface plus flexible.

Cette flexibilité permet d’intégrer LegiPro directement dans un produit, au-delà d’un simple outil utilisateur. Un éditeur peut y connecter la recherche, la consultation de documents, l’assistant IA ou l’export de dossiers.

Le contrat API reflète la logique produit : recherche, document, assistant IA, puis dossier exportable, avec renvoi possible vers la source officielle.

Trois surfaces, trois audiences

Pour l’intégration et la diligence, LegiPro sépare la surface produit, la surface outil IA et le plan de contrôle interne. Elles peuvent partager le même déploiement modulaire aujourd’hui, mais elles n’ont pas les mêmes utilisateurs, jetons, droits ou promesses.

Les jetons demo publics ne mutent pas le rotor. Les tokens worker doivent être scopés à claim, heartbeat, closeout et blocker. mtl-01 reste le builder canonique via rotor focus, rotor automint, rebuild queue et synchronisation Postgres.

API pour partenaires

Vue courte pour un éditeur : LegiPro ajoute une couche de recherche, validation source, préparation assistant et export de dossier sans sortir l’utilisateur du logiciel métier.

Proof-of-fit proposé : commencer par un cas facturation électronique / TVA / traitement comptable. Le logiciel partenaire conserve l’utilisateur, l’interface, l’authentification et le workflow; LegiPro renvoie les sources officielles, une revue sourcée, les faits manquants ou alertes, un brouillon de dossier/export et une référence d’audit. Le premier exemple peut être exécuté sans identifiants tiers, sur documentation publique et fixtures locales.

Flux de démonstration

1. Le produit partenaire envoie une question de facturation électronique / TVA, un document, une facture ou une écriture avec un jeton de démonstration.
2. LegiPro retourne résultats, artefacts, passages et métadonnées de source dans le protocole choisi.
3. L’interface partenaire affiche la preuve et prépare une réponse ou un dossier exportable, en conservant l’avertissement de revue.

Roadmap liée : SAAS-0057 livre le fixture sans identifiants tiers, SAAS-0049 relie maintenant le fixture, le Review Runtime preview, le dossier/export et les adapters dans une preuve dry-run bout-en-bout, SAAS-0058 prépare le pack de comparaison pour premier screening, et SAAS-0059 maintient cette page, la roadmap et la carte C4 alignées. Ce n’est pas une revendication de partenariat, de clients payants, de certification professionnelle ou de reliance client.

Actif aujourd’hui : recherche Meilisearch, REST, GraphQL, MCP, CLI de vérification et exports de dossier en périmètre lecture/revue. Le rotor reste un plan de contrôle interne pour workers et opérateurs, pas une surface partenaire. Non revendiqué : Scenario (verrouillé, scenario_ready: false), couche sémantique/vectorielle (prévue, non activée), streaming SSE backend, promotion corpus finale et revue humaine professionnelle.

Contrat technique du 27 juin 2026 : le reçu data/ops/legipro_api_interfaces_smoke_2026-06-27-saas-0009.json passe 9/9 probes REST, GraphQL et MCP. Le contrat statique reviewer est publié dans assets/legipro-api-contract-2026-06-27.json, et le snapshot OpenAPI statique est publié dans assets/legipro-openapi-2026-06-27.json. Les routes /openapi.json, /api/v0/openapi et /v0/openapi ne doivent pas encore être interprétées comme OpenAPI JSON live.

Quickstart partenaire : assets/legipro-partner-quickstart-2026-06-27.md donne les appels serveur minimaux et les limites de sécurité. Il ne lance pas un SDK et ne donne aucun accès rotor aux jetons produit.

SDK : SAAS-0032 a verrouillé le plan et les contrats, puis SAAS-0035 et SAAS-0036 ont généré les bêtas dépôt TypeScript/Node et Python sous sdk/legipro-typescript-beta/ et sdk/legipro-python-beta/. Les deux restent serveur uniquement, sans publication npm ou PyPI publique. Le bon ordre a été conservé : stabiliser le contrat/OpenAPI public, générer les clients, passer les tests de contrat, publier des exemples serveur et ne jamais exposer les bearer tokens côté navigateur ou mobile. Les packs couvrent cinq flux serveur : recherche, retrieve, Review Runtime preview, export bundle preview et MCP tools/call, avec en-têtes tenant, workspace et cost-units explicites.

Review Runtime prévu

Contrat preview Le futur flux POST /v1/review est documenté comme contrat de travail, pas comme route live. Il doit transformer une question professionnelle en résultat structuré : statut d’answerability, applicabilité temporelle, sources citées, faits manquants avec remèdes, contradictions avec paires de sources, dossier/export et audit.

Le contrat force les snapshots corpus_snapshot_id et index_snapshot_id en entrée et en sortie pour rendre un dossier rejouable contre le corpus d’une date donnée. Les deux seuls usages LLM prévus sont la normalisation de requête et la synthèse de réponse; la vérification des citations reste mécanique et ne s’auto-note pas.

Artefacts : schemas/review_runtime_contract_v1.schema.json, data/fixtures/review_runtime/review_runtime_contract_examples_v1.json, docs/api/review-runtime-contract-v1.md. Le CLI expose le wrapper via schema show review.runtime.preview.

Snapshot + applicabilité Le gate SAAS-0039 rend les snapshots corpus_snapshot_id et index_snapshot_id obligatoires en entrée et répétés dans l’audit. L’applicabilité expose des checks mécaniques pour juridiction, dates d’effet, hiérarchie des sources, supersession, faits manquants et conflits de sources. Résumé public : assets/legipro-review-runtime-snapshot-applicability-2026-06-29.json.

Dossier + export Le gate SAAS-0041 rend le dossier brouillon first-class : dossier_id, revision_id, audit_id, snapshots corpus/index, sources et lien export_bundle_contract_v1. Le helper build_export_bundle_contract_from_review_packet projette le paquet review vers le contrat export existant, avec retry et branding partenaire, sans créer de chemin parallèle. Résumé public : assets/legipro-review-runtime-dossier-export-2026-06-29.json.

Golden eval Le gate legipro qa review-golden-gate construit cinq cas labellisés : answerable, partially_answerable, insufficient_evidence, conflicting_sources et validate-mode confirm/refute. Il échoue fermé si le statut attendu, les citations, les remèdes de refus, les contradictions ou les snapshots régressent. Résumé public : assets/legipro-review-runtime-golden-eval-2026-06-29.json. Les événements d’audit stockent des empreintes et métriques, pas les prompts bruts.

Evidence preview La couche de récupération prévue est désormais décrite par un contrat séparé : schemas/decision_grade_evidence_packet_v1.schema.json et data/fixtures/decision_grade_evidence/decision_grade_evidence_examples_v1.json. Les fixtures couvrent BOFiP TVA, PCG/ANC, URSSAF/CSS/TNS, Code de commerce et facturation électronique, avec source_id, artifact_id, passage_id, rang d’autorité, dates/as-of, contradiction et supersession.

Freshness preview Le contrat source.freshness.impact.preview décrit la fraîcheur des sources et l’impact dossier : last_checked_at, last_changed_at, hash courant/précédent, dates de validité, statut de supersession, dossiers/exports affectés et avertissement placé avant toute confiance de réponse ou d’export.

Export preview Le contrat export.bundle.preview décrit le dossier exportable et révisionné : tenant_id, workspace_id, branding partenaire, dossier_id, revision_id, audit_id, snapshots corpus/index, source_id, artifact_id, passage_id, dates, caveats et états de retry. Si l’export ne peut pas finir immédiatement, le flux retourne un export_job_id ou un état de retry clair pour ne pas bloquer la revue.

Degraded-mode preview Le contrat degraded.mode.behavior.preview décrit les états visibles quand Meilisearch, le warehouse corpus, l’assistant, l’export, les workers, la fraîcheur d’index ou MCP se dégradent : degraded, partial, queued, last_known_good ou denied_scope. Il impose l’avertissement avant toute confiance de réponse/export et ne constitue pas un SLA.

Observabilité produit Le contrat product.observability.snapshot expose une mesure publique sûre : latence p50/p95 recherche/review/export, taux d’answerability, preuves insuffisantes, conflits de sources, coûts par tenant, throttles, refus de scope et métriques MCP. L’actif publié est assets/legipro-product-observability.json et ne stocke ni prompt brut ni question privée.

Frontière inchangée : scenario_ready=false, answer_ready=false, promotion_allowed=false, human_review_complete=false, client_reliance=false, semantic_search_active=false et professional_certification=false.

Carte architecture et processus

Cette carte donne à un acquéreur ou intégrateur la forme opérationnelle de LegiPro : une surface produit bornée, des lanes API par usage, une source de vérité corpus durable, un moteur de recherche dérivé et des workers qui avancent les corpus sans pouvoir auto-certifier les réponses professionnelles. Le wedge partenaire court terme est explicite : un fixture facturation électronique / TVA sans identifiants tiers, avant tout connecteur sandbox ou production.

Public LegiPro
  ├─ Bureau UI
  │    └─ surface de démonstration et de travail
  ├─ Partner Product API
  │    ├─ REST : intégration rapide recherche / retrieve / assistant / export
  │    ├─ GraphQL : vues structurées corpus / artefacts / workspace
  │    └─ Review Runtime : contrat preview /v1/review, non live
  ├─ AI Tool Runtime
  │    └─ MCP : outils bornés pour agents IA d'entreprise
  ├─ Internal Control Plane
  │    └─ Rotor API : claim / heartbeat / closeout / blocker workers
  ├─ Auth / tenant / quota
  │    └─ bearer, workspace, coûts, limites, scopes worker
  ├─ Corpus warehouse PostgreSQL + pgvector
  │    └─ source de vérité : sources, chunks, artefacts, graphes, rotor
  ├─ Index builder → Meilisearch
  │    └─ cache lexical/fuzzy reconstruit depuis le warehouse
  └─ Corpus worker runtime
       └─ fetch source officielle → delta machine-safe → closeout → statut/docs

Flux de données

1. Un worker runtime capture ou réconcilie une source officielle ou un artefact déjà autorisé.
2. Le résultat est stocké comme preuve machine : source, chunk, carte, graphe, RAG ou receipt.
3. Le warehouse conserve la provenance ; l’index builder reconstruit Meilisearch comme index de service.
4. Le CLI ou l’API rotor enregistre un closeout idempotent avec les drapeaux de confiance maintenus à faux.
5. Les pages statut, roadmap et API publient un état lisible pour reviewer sans exposer de secrets opérateur.

La carte C4/Structurizr interne sépare explicitement architecture courante, déploiement mtl-01/mtl-02/mtl-03, mapping de migration et cible SaaS : gateway/OIDC, services stateless, hybrid search, MCP registry, Postgres managé, object store, workers autoscalés, observabilité, conformité et KMS/Vault.

Asset public pour diligence : assets/legipro-c4-architecture-map-2026-06-29.svg donne la vue visuelle courante/cible/processus, sans exiger l'accès au dépôt. Il inclut maintenant une légende current/bounded/planned/target et la frontière source de vérité/cache. La matrice machine-readable est publiée ici : assets/legipro-c4-readiness-matrix-2026-06-29.json. Deux vues dédiées rendent les flux lisibles sans ouvrir la grande carte : Partner Integration Without UI Adoption et Corpus Factory and Readiness Gates. Le registre risques/mitigations public est disponible en Markdown et JSON.

Lecture correcte pour diligence : LegiPro a une architecture de plateforme vérifiable, mais les drapeaux scenario_ready, answer_ready, promotion_allowed, human_review_complete, client_reliance, semantic_search_active et professional_certification restent faux tant que les gates de lancement ne sont pas explicitement validées.

Note pour reviewers IA et diligence

Ne déduisez pas l’état produit uniquement depuis une capture ou une réponse 403 isolée. Les pages publiques, REST, GraphQL et MCP doivent être vérifiés avec les jetons de démonstration documentés ci-dessous. Certains clients automatisés peuvent être bloqués par Cloudflare sur signature de navigateur ; dans ce cas, réessayez avec un navigateur standard ou curl et un bearer token public avant de conclure que la surface n’est pas live.

Pour l’état courant, croisez cette page API avec Statut des corpus, Roadmap SaaS et Scenario verrouillé. Ces pages publiques donnent les compteurs, les limites et les tâches claimables sans exposer de secrets opérateur.

curl -sS https://legipro.fr/bureau-api.html -o /tmp/legipro-api.html

curl -sS \
  -H "Authorization: Bearer lp_demo_public_search_2026_11_01" \
  -H "Accept: application/json" \
  https://legipro.fr/v0/search/health

curl -sS \
  -H "Authorization: Bearer lp_demo_public_assistant_2026_11_01" \
  -H "Content-Type: application/json" \
  https://legipro.fr/graphql \
  --data '{"query":"{ search(query:\"facture electronique\", limit:2) { object query count results { artifactId title corpus } } }"}'

curl -sS \
  -H "Authorization: Bearer lp_demo_public_assistant_2026_11_01" \
  -H "Content-Type: application/json" \
  https://legipro.fr/mcp \
  --data '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'

Interprétation correcte : ces appels prouvent une surface de démonstration publique et bornée. Ils ne prouvent pas des clients payants, un SLA, Scenario utilisable, une recherche sémantique (= prévue seulement), une revue professionnelle complète ou une certification client.

Intégrer LegiPro à vos solutions

LegiPro peut être embarqué comme couche de recherche et de validation dans un produit existant. L’utilisateur reste dans son logiciel métier ; LegiPro fournit les sources, le document, la réponse préparée et le dossier exportable.

Avec LegiPro, un éditeur évite de reconstruire une recherche juridique et comptable, ou de gérer séparément codes, doctrine, dates applicables, citations et exports.

Cas d’usage

• Logiciel comptable : afficher une recherche et un document directement depuis une écriture, une facture ou une immobilisation.
• Portail cabinet : préparer une note client avec sources, date applicable, pièces à joindre et export du dossier.
• Outil fiscal ou paie : interroger un corpus ciblé, extraire les passages utiles et conserver les liens vers les sources d’origine.
• Solution IA interne : connecter un agent au MCP LegiPro pour rechercher, consulter un document et citer une source sans sortir du périmètre autorisé.

Trois modes d'intégration

Parcours d’intégration recommandé

1. Le produit partenaire transmet une question, une facture, une écriture ou un contexte métier à LegiPro.
2. LegiPro renvoie les résultats et l'artefact à afficher dans l'interface du partenaire.
3. L'utilisateur peut préparer une réponse de l'Assistant IA à partir de l'artefact ouvert.
4. Le produit exporte un dossier au format PDF, Markdown, JSON ou HTML, incluant les sources, la date d'application et les liens.

Les sources externes restent accessibles depuis l'artefact. L'intégration conserve ainsi la rapidité du logiciel métier et la traçabilité des sources.

Pack diligence et intégration

Pour un acquéreur, un intégrateur ou un reviewer IA, LegiPro publie maintenant un point d’entrée unique pour les assets d’intégration bornés. Il évite de parcourir toute la page avant de trouver les contrats et quickstarts utiles.

Les bêtas SDK TypeScript/Node et Python existent aujourd’hui en dépôt pour diligence et essais serveur. Elles sont référencées dans le pack public, mais ne sont pas revendiquées comme packages npm/PyPI publics.

Intégrations partenaires visées

Le premier angle d’intégration est volontairement étroit : facturation électronique / TVA / traitement comptable, en prévision du déploiement français à partir du 1er septembre 2026. L’objectif est de montrer qu’un produit comptable existant peut envoyer un contexte métier à LegiPro et recevoir un paquet de revue sourcé, sans adopter l’interface Bureau ni ouvrir d’identifiants tiers au premier screening.

Cette liste ne revendique aucun partenariat, aucun accès API live et aucun client payant. Elle documente le marché d’intégration visé et le type de valeur apportée : preuve sourcée, traçabilité, dossier exportable et intégration serveur côté partenaire. Les tâches publiques liées sont SAAS-0051 à SAAS-0059.

Champs produit et statuts fonctionnels

Les fonctions visibles dans Bureau ont une correspondance explicite côté API afin qu’un éditeur puisse reprendre le même parcours dans son propre produit.

Les statuts ci-dessus doivent rester synchronisés avec les tests publics. Une fonction ne doit pas passer en Actif dans la documentation tant que REST, GraphQL ou MCP ne la renvoie pas de façon vérifiable. Les modules marqués Prototype UI sont visibles dans Bureau et dans les exports de démonstration, sans promesse de champ backend public.

Authentification et multi-structures

LegiPro adopte une approche simple : un jeton d'accès, une URL de base claire, des exemples exécutables et des identifiants de requête pour le support.

Authorization: Bearer $LEGIPRO_API_KEY
X-LegiPro-Workspace: cabinet-production
X-Client-Request-Id: 8cc59de2-66b2-4d84-a6bf-7f69cc80b6e9

• Le jeton détermine le cabinet, l'utilisateur principal, les espaces autorisés et les quotas.
• X-LegiPro-Workspace Un espace n'est sélectionné que si le jeton y donne accès.
• Pour les plateformes partenaires multi-cabinets, X-LegiPro-Tenant peut être activé sur le jeton et vérifié côté serveur.
• Limites, caches, journaux d'utilisation et accès aux sources restent distincts par cabinet et par espace.

Contexte du jeton actif

Le contexte se lit directement via le jeton d'accès en cours : cabinet, espace, droits, expiration et consommation. Les jetons publics de démonstration résolvent demo-public / bureau.

export LEGIPRO_API_KEY="lp_demo_public_read_2026_11_01"

curl -sS "https://legipro.fr/v0/me" \
  -H "Authorization: Bearer $LEGIPRO_API_KEY" \
  -H "Accept: application/json"

Introspection du jeton

Jetons publics de démonstration

Ces jetons sont publics pour les essais et expirent le 1ᵉʳ novembre 2026 à 00:00:00 UTC.

Tester le jeton

export LEGIPRO_API_KEY="lp_demo_public_read_2026_11_01"
export LEGIPRO_BASE_URL="https://legipro.fr/v0"

curl -sS "$LEGIPRO_BASE_URL/manifest" \
  -H "Authorization: Bearer $LEGIPRO_API_KEY" \
  -H "Accept: application/json"

Recherche

Meilisearch Actif La recherche en phase pilote utilise un index Meilisearch privé, derrière un adaptateur LegiPro. L'index de service contient 59 660 documents selon le compteur Meilisearch courant (reçu généré) : artefacts Bureau, comptes PCG, extraits de manifeste RAG/source, cartes, métadonnées de graphe et métadonnées de convoyeur validées.

Les résultats affichent l'artefact, le corpus, le type de source, la date du manifeste, les références publiques, un extrait et, le cas échéant, les champs du reçu. index_run_id, receipt_id, source_artifact_path, content_sha, rag_chunk_id, card_id et graph_concept_ids.

La recherche tolère les fautes de frappe avec des garde-fous pour les références, comptes et articles. Les accents, espacements, pluriels et erreurs courantes comme bnque, banqe ou factur electronique sont acceptés ; les identifiants professionnels comme 615200 ou 279-0 bis restent exacts par défaut.

Cette couche optimise la recherche indexée en français, sans prétendre à une recherche sémantique vectorielle : Recherche sémantique est planned dans le manifeste. Côté warehouse, le baseline lexical Postgres utilise aussi une configuration française legipro.fr_unaccent avec index GIN vérifié ; il reste un support de diligence/reconstruction, pas le moteur sémantique public.

Les mises à jour suivantes seront incrémentielles : les modifications du reçu, de source_sha et de content_sha ajouteront, modifieront ou supprimeront uniquement les documents concernés, sans reconstruire l'index inutilement.

Meilisearch est le moteur actif par défaut. Typesense reste un comparateur pour les benchmarks. OpenSearch demeure une option plus lourde pour les besoins entreprise. Le choix final dépendra de l'évaluation juridique et comptable française.

Modes publics

• mode=balanced par défaut. Recherche naturelle en français, tolérante aux fautes, tout en préservant la précision des références.
• mode=exact recherche stricte pour les comptes PCG, articles, identifiants, citations et workflows d'audit.
• mode=explore exploration élargie pour les questions vagues ou incomplètes.
• strictReferences=true par défaut. Les comptes, références légales et identifiants numériques ne sont pas altérés par des fautes de frappe.

Requête de recherche

curl -sS "https://legipro.fr/v0/search?q=factur%20electronique&mode=balanced&strictReferences=true&limit=5" \
  -H "Authorization: Bearer lp_demo_public_search_2026_11_01" \
  -H "Accept: application/json"

curl -sS "https://legipro.fr/v0/accounts/2026/search?q=615200&mode=exact&strictReferences=true" \
  -H "Authorization: Bearer lp_demo_public_search_2026_11_01" \
  -H "Accept: application/json"

Réponse de recherche

{
  "query": "factur electronique",
  "version": "2026",
  "asOf": "2026-06-04",
	  "limit": 5,
	  "count": 5,
	  "search_mode": "balanced",
	  "strict_references": true,
	  "search_engine": {
	    "engine": "meilisearch",
	    "status": "active",
	    "indexed_document_count": 59660,
	    "typo_tolerance": true,
	    "semantic_search": "planned",
	    "index_uid": "legipro_dev_sources",
	    "loaded_document_count": 59660,
	    "index_run_ids": ["legiproui-full-index-2026-06-21Tstats"]
	  },
	  "matching_strategy": "all",
	  "results": [
	    {
	      "id": "full-unified-8aea54180b97b15f27dd",
	      "title": "bofip_tva / obligations_declaratives - BOI-TVA-DECLA-30-20-30-10-20180207",
	      "href": "https://bofip.impots.gouv.fr/bofip/8862-PGP.html",
	      "corpus": "BOFiP TVA generale",
	      "source_type": "tier_2",
	      "reference": "BOI-TVA-DECLA-30-20-30-10-20180207",
	      "index_run_id": "legiproui-full-index-2026-06-04T04:38:44Z",
	      "receipt_id": "receipt-d59ff62f3d56a0a0d2ef",
	      "source_artifact_path": "data/chroma/unified_ingest_manifest.jsonl",
	      "content_sha": "619fee3bc6ed83729618ed8cb9dbb46af3915d54c782fb2acf2a78df72eaf026",
	      "rag_chunk_id": "unified--bofip_tva--paragraph--004314",
	      "claim_boundary": "non_certifie_revue_comptable_requise"
	    }
	  ]
	}

Assistant IA

L’assistant IA public utilise désormais le workspace REST /v0/workspace pour le chat persistant, les dossiers, les source_ref, les audits et les exports. GraphQL et MCP restent actifs pour les intégrations qui préparent une réponse à partir d’un artefact de recherche.

Le CLI opérateur LegiPro s’aligne sur cette même surface pour les équipes produit, QA et intégration : questions professionnelles via /v0/workspace, recherche publique, manifeste/corpus, schémas JSON stables, clients graphql query/introspect, clients mcp health/serve/tools/call/test, helpers artifact contract/sample/normalize, configuration, authentification de démonstration et vérification documentaire. Le CLI ne crée pas une seconde logique métier ; il automatise les contrats déjà exposés par le produit.

La frontière produit reste lisible : REST, GraphQL, MCP et les clients CLI sont actifs dans un périmètre borné de lecture/revue ; le streaming CLI est une commodité NDJSON au-dessus du chemin synchrone actuel, pas encore un transport SSE backend ; Scenario, recherche sémantique et promotion corpus finale restent séparés dans la carte de couverture ci-dessous.

Carte de couverture actuelle

La surface terminale complète est documentée dans la section CLI. Elle reprend les mêmes contrats que REST, GraphQL et MCP sans créer une seconde logique métier.

Demande de réponse

curl -sS "https://legipro.fr/graphql" \
  -H "Authorization: Bearer lp_demo_public_assistant_2026_11_01" \
  -H "Content-Type: application/json" \
  --data '{
    "query": "query($id: String!, $question: String!, $facts: [String!]) { assistantPrepare(artifactId: $id, question: $question, facts: $facts) { object artifactId asOf answer missingDetails citations { artifactId passageId } } }",
    "variables": {
      "id": "pcg-2026-512",
      "question": "Prépare une réponse TVA sur des travaux mixtes.",
      "facts": ["Local mixte"]
    }
  }'

Objet de réponse

{
  "object": "assistant_response",
  "artifactId": "pcg-2026-512",
  "asOf": "2026-06-04",
  "answer": "Hypothèse de travail : rapprocher la question du document ouvert, des pièces du dossier et des sources citées avant conclusion.",
  "citations": [
    {"artifactId": "pcg-2026-512", "passageId": "pcg-512-p1"}
  ],
  "missingDetails": []
	}

API REST

Actif REST reste le point d’entrée le plus simple pour les intégrations : santé, manifeste, recherche publique, recherche/retrieve multi-corpus v1, workspace Assistant IA et vérification locale du contrat.

python3 scripts/smoke_legipro_api_interfaces.py \
	  --output data/ops/legipro_api_interfaces_smoke_2026-06-21.json

	python3 -m legipro_cli.main docs update \
	  --target user-guide \
	  --target api-guide \
	  --sync-audit \
	  --verify-api \
	  --json

La vérification SAAS-0009 du 27 juin 2026 couvre 9 probes : REST v0/v1, GraphQL et MCP. --sync-audit ajoute une vérification exacte des compteurs Meilisearch/local et du wording de parité entre statut, API, guide CLI et roadmap. Elle ne déploie rien en production et ne prétend pas que la recherche sémantique ou Scenario sont actifs.

API GraphQL de l’espace de travail

Actif GraphQL fournit des vues structurées : corpus, recherche, artefacts, passages, contexte de l’assistant IA et métadonnées temporelles.

Les données LegiPro sont interconnectées : un corpus regroupe des artefacts, chaque artefact contient des passages, avec leurs sources, dates d’application et liens associés.

• GraphQL définit le contrat de l’espace de travail : les clients sélectionnent uniquement les champs nécessaires à leur interface.
• REST conserve son utilité : les endpoints REST maintiennent les probes de santé, les guides de démarrage et des wrappers simples à intégrer.
• Le contexte inclut la gestion des accès : chaque resolver reçoit le cabinet, l’espace, les droits sur les corpus et les quotas depuis le bearer token.
• Les coûts sont maîtrisés : profondeur, complexité, limites de résultats et champs de l’assistant IA sont vérifiés avant exécution.

Recherche structurée

Le champ search prend les mêmes options que l’API REST publique : mode vaut balanced, exact ou explore, et strictReferences reste fixé à true par défaut.

curl -sS "https://legipro.fr/graphql" \
  -H "Authorization: Bearer lp_demo_public_search_2026_11_01" \
  -H "Content-Type: application/json" \
  --data '{
	    "query": "query($q: String!, $mode: String!, $strictReferences: Boolean!) { __typename manifest { manifest_version asOf } search(query: $q, limit: 5, mode: $mode, strictReferences: $strictReferences) { search_mode strict_references matching_strategy count results { id title href corpus reference } } }",
	    "variables": {
	      "q": "banqe",
	      "mode": "balanced",
	      "strictReferences": true
	    }
	  }'

Artefact et préparation de l’assistant IA

curl -sS "https://legipro.fr/graphql" \
  -H "Authorization: Bearer lp_demo_public_assistant_2026_11_01" \
  -H "Content-Type: application/json" \
  --data '{
    "query": "query($id: String!, $question: String!) { artifact(id: $id) { id title asOf passages { id text } } assistantPrepare(artifactId: $id, question: $question, facts: []) { answer missingDetails citations { passageId } } }",
    "variables": {
      "id": "pcg-2026-512",
      "question": "Prépare une note de travail à partir de cet artefact."
    }
  }'

Connecteur MCP pour agents

Actif MCP rend LegiPro accessible aux agents et outils exploitant des appels structurés.

Ce connecteur repose sur la même infrastructure que REST et GraphQL : même bearer token, même espace, mêmes corpus, mêmes quotas et mêmes artefacts.

search_sources reprend les modes de recherche publics. Un agent peut ainsi lancer une recherche large en explore, puis consulter un artefact ou basculer en exact pour une référence comptable ou juridique.

Outils disponibles

• list_corpus : lister les corpus suivis.
• get_manifest : consulter les versions, dates d’application et statuts des interfaces.
• search_sources : rechercher dans les sources LegiPro avec mode et strictReferences.
• get_artifact : accéder à un artefact et à ses passages.
• ask_assistant : préparer une réponse à partir d’un artefact.
• export_bundle : générer les métadonnées d’un bundle exportable.

Initialisation du serveur MCP

curl -sS -X POST "https://legipro.fr/mcp" \
  -H "Authorization: Bearer lp_demo_public_assistant_2026_11_01" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-06-18",
      "capabilities": {},
      "clientInfo": {"name": "smoke", "version": "1.0"}
    }
  }'

Appel d’un outil

curl -sS -X POST "https://legipro.fr/mcp" \
  -H "Authorization: Bearer lp_demo_public_assistant_2026_11_01" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  --data '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "search_sources",
	      "arguments": {
	        "query": "factur electronique",
	        "limit": 3,
	        "mode": "balanced",
	        "strictReferences": true
	      }
	    }
	  }'

CLI opérateur

Actif borné Le CLI legipro est groupé avec REST, GraphQL et MCP parce qu’il automatise les mêmes contrats : recherche, assistant, manifeste, schémas, probes API, documentation, MCP, GraphQL, rotor corpus, warehouse Postgres et capture optionnelle de métadonnées AI-lab/eval à la clôture des lanes.

Il sert aux intégrateurs, reviewers et agents de travail. Il ne remplace pas l’API et ne crée pas une seconde logique métier : quand il interroge LegiPro, il passe par les surfaces produit documentées, puis écrit des reçus opérables.

Taxonomie CLI : chat, search, graphql, mcp, schema et auth vérifient les surfaces produit/outil IA; rotor api-*, rotor closeout, warehouse et worker run appartiennent au plan de contrôle interne corpus.

CLI opérateur. LegiPro dispose d’un outil de vérification en ligne de commande pour tester les mêmes contrats que le site et l’API : recherche, assistant, sources, GraphQL, MCP, schémas, télémétrie et documentation. Il sert aux équipes produit, QA et intégration ; il ne remplace pas l’interface utilisateur.

L’inventaire des opérations supportées sépare maintenant les commandes CLI canoniques des anciens scripts de travail : les lanes doivent clore via rotor closeout, rafraîchir le statut via docs refresh-status et utiliser warehouse/rotor api-* pour les flux distribués plutôt que réutiliser des helpers historiques sans tâche explicite.

Carte d’automatisation SAAS-0031. ops automation-map publie la carte de propriété des opérations récurrentes : scheduled_job, admin_api, ci_gate ou break_glass. Elle relie chaque commande répétée à son reçu, inclut le gate SAAS-0001 e-invoicing et son refill de continuité, interdit les scans larges et le fan-out/subagents, garde la parité CLI pour QA/rollback, et maintient mtl-01 comme seul builder canonique de queue.

Gate SAAS-0001. ops saas0001-einvoicing-gate --refresh-rotor-status vérifie mécaniquement si la poussée facturation électronique peut être clôturée avec un snapshot rotor stable : leases e-invoicing à zéro, aucune double propriété de lane, queue fermée, parité warehouse/local et drapeaux de préparation professionnelle toujours faux. Le reçu expose aussi les tâches actives, les comptes de queue, le dry-run stale-lease, la parité Meili/warehouse/local, la validation du snapshot statut et un résumé des closeouts e-invoicing récents par lane active. Tant que les lanes travaillent proprement, le reçu peut remonter status=machine_verified_in_progress : le surge est sain et vérifié, mais la clôture finale reste interdite tant que les leases actives ne sont pas retombées à zéro.

Continuité SAAS-0001. ops saas0001-einvoicing-continuity --wait-seconds 20 --max-attempts 3 garde la poussée en mouvement : il rafraîchit le gate, vérifie les 14 lanes attendues, puis lance des passes bornées rotor automint --corpus einvoicing --autoclaim canoniques si une lane a quitté le set actif. Après la dernière passe, il relit le gate avant de signaler un suivi. Les runs sains sortent désormais en status=machine_verified_active_leases quand les 14 lanes sont revenues et que le gate final reste machine_verified_in_progress; le résumé final emporte aussi le dernier closeout e-invoicing observé et le nombre de lanes actives couvertes par des closeouts récents. C’est un refill, pas une clôture ni une promotion.

Source live de vérité. L’état public-safe courant du surge SAAS-0001 est publié dans assets/legipro-status-snapshot.json, champ rotor.saas0001_einvoicing_continuity. Les commandes docs update --target coverage-map et docs update --target status-page republient cette même synthèse afin d’aligner guide API, carte de couverture et page statut sur un seul snapshot.

Pack diligence reproductible. docs update --target diligence-pack --json régénère le pointeur courant, le one-pager acquéreur et le bundle diligence à partir des receipts/API smokes/parity courants. Cela garde la narration buyer-facing synchronisée avec l’état réel sans éditer le pack à la main.

Aide principale

usage: legipro [-h] [--version] [--profile PROFILE] [--base BASE]
               [--token TOKEN] [--tenant TENANT] [--workspace WORKSPACE]
               [--timeout TIMEOUT] [--format OUTPUT_FORMAT]
               [--personality PERSONALITY]
               [--smalltalk-personality SMALLTALK_PERSONALITY]
               {artifact,chat,auth,config,docs,graphql,manifest,mcp,ops,qa,rotor,schema,search,telemetry,warehouse,worker,ask} ...

LegiPro executable control-plane CLI.

positional arguments:
  {artifact,chat,auth,config,docs,graphql,manifest,mcp,ops,qa,rotor,schema,search,telemetry,warehouse,worker,ask}
    artifact            Local selected-artifact/source viewer contract helpers.
    chat                Assistant IA chat operations.
    auth                Authentication and config inspection.
    config              Inspect and initialize LegiPro CLI config.
    docs                Update and verify LegiPro user/API documentation surfaces.
    graphql             GraphQL interface commands.
    manifest            Inspect the live LegiPro manifest.
    mcp                 MCP interface commands.
    ops                 Read-only CLI helpers for LegiPro operator visibility surfaces.
    qa                  Focused CLI QA probes.
    rotor               Scenario corpus rotor closeout and orchestration helpers.
    schema              Show machine-readable CLI output schemas.
    search              Public search surface.
    telemetry           Local-only telemetry schema, sample and privacy-check helpers.
    warehouse           Bootstrap and inspect the Postgres corpus warehouse.
    worker              Run the stateless reference rotor worker.
    ask                 Legacy alias for `chat ask`.

options:
  -h, --help            show this help message and exit
  --version             show program's version number and exit
  --profile PROFILE
  --base BASE           Base URL (default: https://legipro.fr)
  --token TOKEN         Bearer token override.
  --tenant TENANT       Tenant override (default: demo-public)
  --workspace WORKSPACE Workspace override (default: bureau)
  --timeout TIMEOUT     HTTP timeout (default: 30)
  --format OUTPUT_FORMAT
                        Output format hint (text/json).

Agent closeout shortcut: use `legipro rotor closeout ...` when a corpus lane
finishes work. That single command writes the callback, refreshes
coverage/docs/status, rebuilds the queue, and nudges twin/metronome instead of
hand-editing several files. Use `legipro rotor focus --corpus <name>
--rebuild-queue --autoclaim` for a single-corpus surge, and `legipro rotor
autoclaim --json` to queue current leased work through Hermes /queue, including
stale-lease recovery, without fanout or interrupting busy lanes. Add
`--lab-eval` to closeout/api-closeout when a lane produced source-routing,
retrieval-QA, verifier, failure-mode, or export-candidate evidence for later
anonymized lab/eval curation.

Commandes usuelles

# Recherche publique
python3 -m legipro_cli.main search query "facture electronique" --mode balanced --limit 5 --json

# GraphQL et MCP bornés
python3 -m legipro_cli.main graphql introspect --json
python3 -m legipro_cli.main graphql query --json
python3 -m legipro_cli.main mcp health --json
python3 -m legipro_cli.main mcp tools --json
python3 -m legipro_cli.main mcp call search_sources --arguments-json '{"query":"facture electronique","limit":2}' --json
python3 -m legipro_cli.main mcp test --json

# Contrat reviewer/API actuel
curl -sS https://legipro.fr/assets/legipro-api-contract-2026-06-27.json

# Carte scheduled/admin/CI des opérations récurrentes
python3 -m legipro_cli.main ops automation-map --json
python3 -m legipro_cli.main schema show ops.automation.map
python3 -m legipro_cli.main ops saas0001-einvoicing-continuity --wait-seconds 20 --max-attempts 3 --json

# Worker de référence stateless
python3 -m legipro_cli.main worker run --lane legipro-reference-worker --artifact-dir /tmp/legipro-reference-worker --dry-run --json

# Documentation et statut corpus
python3 -m legipro_cli.main docs update --target user-guide --target api-guide --verify-api --sync-audit --json
python3 -m legipro_cli.main docs refresh-status --force --publish-static --json
python3 -m legipro_cli.main docs update --target diligence-pack --json

# Closeout canonique d'une lane corpus
python3 -m legipro_cli.main rotor closeout \
  --task-id <exact-task-id> \
  --lane <tmux-lane> \
  --corpus <corpus-family> \
  --status done_machine_safe_delta \
  --what-changed "<short summary>" \
  --artifact data/ops/<receipt>.json \
  --lab-eval \
  --lab-task-type retrieval-qa \
  --lab-outcome-label bounded_pass \
  --lab-verifier-ref tests/test_retrieval.py \
  --lab-source-rights-boundary official-source-derived-no-raw-text

# Surge e-invoicing multi-lanes avant démo
python3 -m legipro_cli.main rotor focus \
  --corpus einvoicing \
  --reason "Demo-critical e-invoicing surge" \
  --rebuild-queue \
  --autoclaim \
  --json

# Vérifier/nudger les lanes leased sans interruption
python3 -m legipro_cli.main rotor autoclaim --dry-run --json
python3 -m legipro_cli.main rotor autoclaim --lane mtl-01-heremes-04 --json

# Mint-ahead unattended : closeouts -> queue -> Postgres -> /queue
python3 -m legipro_cli.main rotor automint --corpus einvoicing --autoclaim --json

# Worker mtl-01 ou mtl-03 via REST protégé
python3 -m legipro_cli.main --base https://legipro.fr --token "$LEGIPRO_ROTOR_TOKEN" rotor api-status --json
python3 -m legipro_cli.main --base https://legipro.fr --token "$LEGIPRO_ROTOR_TOKEN" rotor api-next --lane hermes1 --json
python3 -m legipro_cli.main --base https://legipro.fr --token "$LEGIPRO_ROTOR_TOKEN" rotor api-claim --lane hermes1 --worker-id mtl-03-hermes1 --json
python3 -m legipro_cli.main --base https://legipro.fr --token "$LEGIPRO_ROTOR_TOKEN" rotor api-heartbeat --task-id <task-id> --lane hermes1 --current-step "ingest/index QA" --json
python3 -m legipro_cli.main --base https://legipro.fr --token "$LEGIPRO_ROTOR_TOKEN" rotor api-closeout --task-id <task-id> --lane hermes1 --corpus einvoicing --status done_machine_safe_delta --what-changed "Bounded worker receipt written." --artifact /mnt/mtl02/pharos-corpus-runner/smoke/<receipt>.json --lab-eval --lab-task-type source-routing --lab-export-candidate --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-bootstrap --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-migrate --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-status --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-reap-stale-leases --max-age-seconds 7200 --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-prune-closed-leases --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-archive-done-tasks --older-than-days 1 --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-register-lanes --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main rotor db-lanes --json

# Warehouse corpus durable / semantic staging
python3 -m legipro_cli.main warehouse bootstrap --dry-run --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse bootstrap --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse backfill-full-index --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse parity --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse status --json
python3 -m legipro_cli.main warehouse backup-drill --copy-full-index --json

Warehouse corpus mtl-02 / pgvector

Le warehouse Postgres sur mtl-02 devient le stockage durable pour l’inventaire source, les artefacts, les chunks, les liens graph/RAG, les reçus d’ingest et les futures embeddings pgvector. Meilisearch reste le moteur actif de recherche lexicale/fuzzy pour le site et l’API.

warehouse bootstrap prépare le schéma et les tables pgvector dimensionnelles ; warehouse backfill-full-index charge le full-index JSONL reproductible dans Postgres ; warehouse parity compare Meilisearch live, full-index local et warehouse ; warehouse backup-drill écrit un dump Postgres custom, une preuve pg_restore --list, les métadonnées Meili/search-health, une copie/checksum du full-index et un manifeste checksum des artefacts critiques. Ces commandes ne calculent pas les embeddings et ne revendiquent pas une recherche sémantique opérationnelle. Les tables de staging conservent explicitement scenario_ready, answer_ready, promotion_allowed, human_review_complete, client_reliance, semantic_search_active et professional_certification à false.

Dernier drill backup/restore : data/ops/legipro_backup_restore_drill_2026-06-27.json, répertoire /mnt/mtl02/pharos-corpus-runner/backups/legipro/20260627T093929Z. RPO prototype : 24h ; RTO prototype : 4h. Le dump natif Meili n’est pas encore configuré : la restauration prototype reconstruit Meili depuis le full-index JSONL et le warehouse.

État vérifié le 2026-06-26 : 59 627 chunks warehouse correspondent exactement aux 59 627 lignes full-index locales ; Meilisearch live contient 59 660 documents, soit +33 lignes live/opérationnelles suivies comme détail de parité, pas comme preuve Scenario ou sémantique.

python3 -m legipro_cli.main warehouse bootstrap --dry-run --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse bootstrap --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse backfill-full-index --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse parity --json
LEGIPRO_CORPUS_DATABASE_URL="postgresql://..." python3 -m legipro_cli.main warehouse status --json
python3 -m legipro_cli.main warehouse backup-drill --copy-full-index --json

Rotor corpus / Scenario

Le rotor est la file de traitement corpus utilisée pour amener les familles vers l’état requis par Scenario : sources capturées, chunks indexés, graph/RAG à jour, reçus écrits, drapeaux sensibles explicitement conservés à faux tant qu’un reçu contrôleur ne prouve pas le contraire.

rotor focus permet de concentrer toutes les lanes sur un corpus prioritaire. Pour la facturation électronique, le builder canonique crée des tranches distinctes : inventaire sources, chunks/RAG, source cards, graph, parité API/statut, index/Meili et QA retrieval. Les IDs de tâches focus sont stabilisés dans data/ops/legipro_rotor_focus_leases.json pour éviter qu’un rebuild ou une erreur de lane ne fasse courir les auto-claims après une cible mouvante.

Quand une lane termine une tranche, elle ne doit plus écrire plusieurs fichiers à la main. Elle appelle rotor closeout. Le CLI ajoute le callback normalisé, reconstruit la couverture, rafraîchit la page statut, rebâtit la queue et signale twinhermes si un nudge direct est utile.

rotor autoclaim est le wrapper CLI du watchdog : il reconstruit la queue par défaut, envoie la carte de tâche directement à une pane Hermes idle au prompt, utilise /queue seulement pour les panes Hermes occupées afin de ne pas interrompre le tour courant, queue les nouvelles leases invisibles pendant une courte fenêtre fraîche, ré-émet une lease stale si le task_id courant n’apparaît plus dans la pane après le seuil, permet aussi un raccourci --context-bloat-requeue-seconds quand une pane busy compacte fortement son contexte, supprime les répétitions pendant la fenêtre queued_task_pending, et ne lance jamais de fan-out/subagents.

rotor automint est l’entrée unattended : il réconcilie les closeouts durables, accepte les closeouts API authentifiés (rotor_api_submitted=true + rotor_closeout_*) même si le reçu est local au worker, reconstruit la queue canonique sur mtl-01, synchronise Postgres et lance ensuite autoclaim si demandé. Les workers mtl-01 et mtl-03 appellent désormais le même rotor api-closeout ; ils ne mintent pas la queue.

Gestion du contexte : pour les lanes Hermes TUI distantes, rotor automint lit le compteur de contexte visible. Si la lane est idle et dépasse le seuil, il envoie /new, puis queue la tâche canonique courante. Les panes occupés ne sont pas réinitialisés. Les options --context-reset-threshold, --context-reset-cooldown-seconds et --no-context-reset règlent ce comportement.

Fallback TUI : chaque closeout écrit aussi une ligne JSON ROTOR_CLOSEOUT_READY dans data/ops/legipro_rotor_closeout_signal.jsonl, avec signal, task_id et timestamp. Les coordinateurs comme opencode peuvent poller ce fichier pour détecter les fins de tâche sans attendre le prochain cycle metronome.

Auto-claim : activé par défaut. Après closeout, la lane lit la queue reconstruite et reçoit la prochaine tâche single-lane déjà leased pour elle. Si la lane est une TUI Hermes occupée, le CLI envoie /queue pour ne pas interrompre un tour en cours ; si la pane Hermes est idle au prompt, il injecte directement la carte de tâche pour démarrer la lease sans la laisser dormir dans la file locale. /steer reste réservé au guidage humain mid-run. Pour une TUI non-Hermes comme opencode, le CLI laisse la tâche dans data/ops/legipro_rotor_closeout_signal.jsonl. Les anciennes instructions fan-out/subagents/codex exec sont rejetées avant injection ; --no-auto-claim sert seulement aux closeouts de maintenance ponctuels.

Watcher : scripts/legipro_rotor_closeout_watcher.sh peut tourner dans tmux rotor_watcher. Il poll le fichier signal toutes les 2 secondes, écrit data/ops/legipro_rotor_watcher_pending.txt, lance rotor automint --autoclaim sur closeout ou sweep, et ne pousse un message tmux vers twinhermes que si un prompt shell est détecté.

Contrôle REST worker : /v0/rotor/status, /v0/rotor/tasks/next, /v0/rotor/claim, /v0/rotor/heartbeat, /v0/rotor/closeout et /v0/rotor/blocker acceptent le bearer admin ou un token worker scopé (rotor:read, rotor:claim, rotor:heartbeat, rotor:closeout, rotor:blocker, ou rotor:* pour un runner contrôlé). Les tokens demo publics sans scope rotor sont refusés. Sur le même host, si le CLI résout un token demo/default et que /root/.secrets/legipro-rotor-worker-token existe, rotor api-* utilise automatiquement ce token worker scopé ; un --token non-demo explicite reste prioritaire. Les workers mtl-01 et mtl-03 peuvent écrire claims, heartbeats, closeouts et blockers, mais ne mintent pas la queue canonique : mtl-01 reste le builder via rotor focus, rotor automint, rebuild queue et sync Postgres. Avec LEGIPRO_CORPUS_DATABASE_URL ou LEGIPRO_ROTOR_DATABASE_URL, ces routes utilisent les tables Postgres rotor_tasks, rotor_tasks_archive, rotor_leases, rotor_closeouts, rotor_events et rotor_lane_registry. rotor db-migrate synchronise la queue canonique et le journal de callbacks vers Postgres après rebuild ; rotor db-register-lanes enregistre 7 lanes mtl-01 et 7 lanes mtl-03 comme owners visibles avec un scope worker execution-only ; rotor db-reap-stale-leases détecte les leases sans heartbeat et, avec --execute, les remet en claimable en journalisant stale_lease_evicted ; rotor db-prune-closed-leases nettoie les leases historiques attachés à des tâches déjà clôturées ; rotor db-archive-done-tasks déplace les anciennes tâches clôturées vers rotor_tasks_archive afin de garder le jeu de claims/statuts léger. rotor api-closeout écrit callback + signal, force les drapeaux Scenario/réponse/promotion à faux et reste idempotent. Les callbacks exact-packet peuvent aussi être récoltés dans ce flux Postgres quand le harvester est lancé avec un environnement DB explicite.

Sur mtl-01, rotor closeout, rotor focus --rebuild-queue, rotor automint et rotor autoclaim non-dry-run tentent aussi un rotor_postgres_sync après travail de queue quand l’URL DB est disponible dans l’environnement ou dans /root/.secrets/legipro-corpus-db.env. Les prompts auto-claim ajoutent ce préfixe d’environnement pour que les lanes locales gardent Postgres à jour sans migration manuelle séparée.

État vérifié le 2026-06-27 : le roster Postgres contient 14 lanes enregistrées (7 mtl-01, 7 mtl-03) avec scope rotor_worker_execution_only. Le dry-run rotor db-reap-stale-leases --max-age-seconds 7200 a trouvé 0 lease stale à évincer ; rotor db-prune-closed-leases a nettoyé 111 anciens leases de tâches déjà clôturées, puis le post-check a retrouvé 0 lease fermé restant ; rotor db-archive-done-tasks a déplacé 500 tâches clôturées vers rotor_tasks_archive sans toucher les 14 leases actifs. Les drapeaux Scenario/réponse/promotion restent faux. L'observation live mtl-03 reste dépendante de SSH/remote-status.

python3 -m legipro_cli.main rotor closeout \
  --task-id lane02_bofip_is_bic_batch_0001 \
  --lane mtl-01-heremes-02 \
  --corpus bofip_is_bic \
  --status done_machine_safe_delta \
  --what-changed "ingested, indexed and verified the next BOFiP IS/BIC tranche" \
  --artifact data/ops/lane02_bofip_is_bic_batch_0001.json \
  --verify "python3 -m legipro_cli.main docs refresh-status --force --publish-static --json" \
  --json

Aide rotor

usage: legipro rotor [-h]
                     {closeout,focus,autoclaim,automint,remote-status,remote-dispatch,api-status,api-next,api-claim,api-heartbeat,api-closeout,api-blocker,db-bootstrap,db-migrate,db-status,db-reap-stale-leases,db-prune-closed-leases,db-archive-done-tasks,db-register-lanes,db-lanes} ...

Central rotor control surface for Scenario corpus work. Worker lanes should use
the protected API protocol (`rotor api-claim`, `rotor api-heartbeat`,
`rotor api-closeout`) by default. `rotor closeout` is kept for same-host
maintenance/direct-hook repair when the protected API is unavailable.

positional arguments:
  {closeout,focus,autoclaim,automint,remote-status,remote-dispatch,api-status,api-next,api-claim,api-heartbeat,api-closeout,api-blocker,db-bootstrap,db-migrate,db-status,db-reap-stale-leases,db-prune-closed-leases,db-archive-done-tasks,db-register-lanes,db-lanes}
    closeout            Same-host maintenance closeout path with direct local hooks.
    focus               Enable, update, disable, or inspect single-corpus
                        focus mode.
    autoclaim           Run the lane autoclaim watchdog through the CLI.
    automint            Reconcile closeouts, mint the next focused queue rows,
                        sync Postgres, and optionally autoclaim.
    remote-status       Read-only status snapshot for guarded mtl-03 rotor lanes.
    remote-dispatch     Dry-run or send exact-packet work to guarded mtl-03 rotor lanes.
    api-status          Fetch protected /v0/rotor/status from the REST control plane.
    api-next            Fetch protected /v0/rotor/tasks/next without mutating the canonical queue.
    api-claim           Atomically claim/lease the next matching rotor task through the protected API.
    api-heartbeat       Record worker heartbeat/current step against the protected rotor API.
    api-closeout        Submit a lane closeout to protected /v0/rotor/closeout.
    api-blocker         Submit a bounded worker blocker event to protected /v0/rotor/blocker.
    db-bootstrap        Create/upgrade Postgres rotor tables.
    db-migrate          Seed Postgres rotor state from the canonical queue and callback journal.
    db-status           Inspect Postgres rotor task/lease/closeout/event counts.
    db-reap-stale-leases
                        Dry-run or execute Postgres stale lease recovery.
    db-prune-closed-leases
                        Dry-run or prune Postgres lease rows for already closed tasks.
    db-archive-done-tasks
                        Dry-run or archive closed Postgres task rows out of the hot task table.
    db-register-lanes   Upsert the canonical mtl-01/mtl-03 rotor lane owner roster into Postgres.
    db-lanes            Inspect the Postgres rotor lane owner roster, including route scope guardrails.

options:
  -h, --help            show this help message and exit

Typical lane finish:
  python3 -m legipro_cli.main rotor closeout \
    --task-id lane02_example_5152 \
    --lane mtl-01-heremes-02 \
    --corpus bofip_cgi \
    --status done_machine_safe_delta \
    --what-changed "Indexed deterministic machine-safe corpus delta." \
    --artifact data/ops/example_receipt.json

Single-corpus surge before a demo:
  python3 -m legipro_cli.main rotor focus \
    --corpus einvoicing \
    --reason "Demo-critical e-invoicing surge" \
    --rebuild-queue --autoclaim --json

Non-interrupting lane nudge/status check:
  python3 -m legipro_cli.main rotor autoclaim --dry-run --json

Mint-ahead reconciliation for unattended lanes:
  python3 -m legipro_cli.main rotor automint --autoclaim --json

Aide rotor closeout

usage: legipro rotor closeout [-h] --task-id TASK_ID --lane LANE
                              [--corpus CORPUS] [--status STATUS]
                              [--result RESULT] --what-changed WHAT_CHANGED
                              [--artifact ARTIFACT]
                              [--best-receipt BEST_RECEIPT] [--verify VERIFY]
                              [--evidence-ref EVIDENCE_REF]
                              [--command-run COMMAND_RUN] [--note NOTE]
                              [--callback-journal CALLBACK_JOURNAL]
                              [--receipt-output RECEIPT_OUTPUT]
                              [--no-coverage-rollup] [--no-docs-refresh]
                              [--no-publish-static] [--verify-api]
                              [--no-queue-rebuild] [--no-twin-update]
                              [--twin-target TWIN_TARGET]
                              [--no-direct-twin-nudge] [--auto-claim]
                              [--no-auto-claim] [--dry-run] [--json]

Close one lane task through the canonical rotor path. The command appends a
normalized callback row, refreshes corpus coverage/status docs, rebuilds the
Scenario task queue, writes a ROTOR_CLOSEOUT_READY signal file, and calls the
twinhermes/metronome fallback so the orchestrator sees the completion.

options:
  -h, --help            show this help message and exit
  --task-id TASK_ID     Exact queue task id, including numeric suffix.
  --lane LANE           Lane/tmux session id, e.g. mtl-01-heremes-02.
  --corpus CORPUS       Corpus family label.
  --status STATUS       Callback status. Defaults to done.
  --result RESULT       Short machine-readable result label.
  --what-changed WHAT_CHANGED
                        Compact human-readable closeout summary.
  --artifact ARTIFACT   Receipt/artifact path. Repeatable.
  --best-receipt BEST_RECEIPT
                        Best receipt path when distinct from --artifact.
  --verify VERIFY       Verification command or artifact. Repeatable.
  --evidence-ref EVIDENCE_REF
                        Evidence reference. Repeatable.
  --command-run COMMAND_RUN
                        Command run by the lane. Repeatable.
  --note NOTE           Additional note. Repeatable.
  --callback-journal CALLBACK_JOURNAL
                        Callback JSONL path. Defaults to data/ops/legipro_scenario_corpus_rotor_callback_2026-06-21.jsonl.
  --receipt-output RECEIPT_OUTPUT
                        Closeout receipt path. Defaults under data/ops/.
  --no-coverage-rollup  Skip build_corpus_coverage_rollup.py.
  --no-docs-refresh     Skip docs refresh-status.
  --no-publish-static   Do not publish rebuilt static status assets.
  --verify-api          Include REST/GraphQL/MCP smoke in docs refresh.
  --no-queue-rebuild    Skip queue rebuild.
  --no-twin-update      Skip the twin/metronome fallback hook.
  --twin-target TWIN_TARGET
                        Twin tmux target to nudge after closeout. Defaults to twinhermes:0.0.
  --no-direct-twin-nudge
                        Do not send the post-closeout ROTOR_CLOSEOUT_READY message to twin tmux.
  --auto-claim          Compatibility flag; auto-claim is enabled by default.
  --no-auto-claim       Disable next-task auto-claim for this closeout.
  --dry-run             Build receipt without writing callback or running hooks.
  --json                Print the closeout receipt JSON.

Aide docs refresh-status

usage: legipro docs refresh-status [-h] [--force] [--dry-run] [--verify-api]
                                   [--publish-static] [--json]

One-shot status automation hook for agents. It checks the central queue,
callback journal, corpus/status/API inputs, rebuilds the coverage map and
bureau-status page when needed, and can publish the static assets.

options:
  -h, --help        show this help message and exit
  --force           Refresh even if watched inputs are unchanged.
  --dry-run         Report whether a refresh would run.
  --verify-api      Include REST/GraphQL/MCP smoke verification.
  --publish-static  Publish the rebuilt status page/assets to the static site.
  --json            Print the hook JSON. Kept for command symmetry; output is JSON either way.

Closeout conserve les drapeaux sensibles à faux sauf preuve contrôleur existante : scenario_ready, answer_ready, promotion_allowed, client_reliance, semantic_search_active et professional_certification. Le but est de faire avancer l’ingestion, le graph, le RAG et la couverture sans transformer une preuve machine en certification professionnelle.

Exemples de scripts

Bash : test en direct

#!/usr/bin/env bash
set -euo pipefail

BASE="${LEGIPRO_BASE_URL:-https://legipro.fr/v0}"
TOKEN="${LEGIPRO_API_KEY:-lp_demo_public_read_2026_11_01}"

curl -sS "$BASE/accounts/2026/search?q=banque" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Accept: application/json"

Python : client GraphQL

import json
import os
import urllib.request

GRAPHQL_URL = os.environ.get("LEGIPRO_GRAPHQL_URL", "https://legipro.fr/graphql")
TOKEN = os.environ.get("LEGIPRO_API_KEY", "lp_demo_public_search_2026_11_01")

def graphql(query, variables):
    req = urllib.request.Request(
        GRAPHQL_URL,
        method="POST",
        data=json.dumps({"query": query, "variables": variables}).encode("utf-8"),
        headers={
            "Authorization": f"Bearer {TOKEN}",
            "Content-Type": "application/json",
            "Accept": "application/json",
        },
    )
    with urllib.request.urlopen(req, timeout=20) as response:
        return json.loads(response.read().decode("utf-8"))

query = """
query SearchArtifact($q: String!) {
  search(query: $q, limit: 3) {
    count
    results { id title href corpus }
  }
}
"""

answer = graphql(query, {
    "q": "banque",
})

print(answer["data"]["search"]["results"][0]["title"])

Node : assistant GraphQL

const graphqlUrl = process.env.LEGIPRO_GRAPHQL_URL || "https://legipro.fr/graphql";
const token = process.env.LEGIPRO_API_KEY || "lp_demo_public_assistant_2026_11_01";

async function graphql(query, variables) {
  const response = await fetch(graphqlUrl, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${token}`,
      "Content-Type": "application/json",
      "Accept": "application/json"
    },
    body: JSON.stringify({ query, variables })
  });

  if (!response.ok) {
    throw new Error(`LegiPro ${response.status}: ${await response.text()}`);
  }

  return response.json();
}

const response = await graphql(`
  query AskAssistant($artifactId: String!, $question: String!) {
    assistantPrepare(artifactId: $artifactId, question: $question, facts: []) {
      answer
      missingDetails
      citations { passageId }
    }
  }
`, {
  question: "Prépare les éléments de réponse pour le client.",
  artifactId: "pcg-2026-512"
});

console.log(response.data.assistantPrepare.answer);

Erreurs, pagination et en-têtes

Objet d’erreur

{
  "object": "error",
  "request_id": "req_01jz8yayet25",
  "error": {
    "type": "rate_limit_exceeded",
    "code": "tenant_quota_exceeded",
    "message": "Quota reached for this workspace.",
    "param": null
  }
}

En-têtes de réponse utiles

X-Request-Id: req_01jz8yayet25
X-LegiPro-Tenant: cab_demo_01
X-LegiPro-Workspace: cabinet-production
X-LegiPro-Cost-Units: 3
X-LegiPro-RateLimit-Limit: 300
X-LegiPro-RateLimit-Remaining: 284
X-LegiPro-RateLimit-Window-Seconds: 300

Maîtrise des coûts

REST, GraphQL et MCP partagent le même budget. Les lectures simples coûtent peu ; les recherches, exports et appels à l’assistant IA consomment davantage.

• Limites par jeton, cabinet, environnement et adresse IP.
• Plafonds sur limitla taille des artefacts, les exports et le contexte de l'Assistant IA.
• Pagination requise pour les gros volumes.
• Cache des recherches et lectures d'artefacts par requête, corpus et date.
• MCP reste en lecture seule dans cette version.

Système de documentation recommandé

Présenter une page publique épurée, puis générer les pages détaillées à partir du schéma GraphQL, du contrat d'API REST et du manifeste MCP.

1. Vue d'ensemble : cette page, avec guide de démarrage, regroupement des endpoints et exemples de production.
2. Schéma GraphQL : généré depuis schema/legipro.graphql, avec coûts des résolveurs et notes d'authentification des champs.
3. Wrappers REST : générés depuis assets/legipro-openapi-2026-06-27.json ou un futur openapi/legipro-v0.yaml, limités aux tests de santé, aux vérifications techniques et aux intégrations simples.
4. Manifeste MCP : généré à partir des mêmes opérations, avec coûts des outils, périmètres et limites de lecture seule.
5. SDK partenaires : bêtas dépôt TypeScript/Node et Python générés via SAAS-0035 et SAAS-0036, avec tests de contrat et exemples serveur sans clef exposée côté client.
6. Guides : parcours de recherche prioritaire, workflow de l'Assistant, déploiement par cabinet et environnement, gestion des quotas et limites de requêtes.
7. Exemples : scripts curl, Python et Node versionnés, disponibles sous examples/, avec tests techniques en premier.
8. Journal des modifications : ajouts de champs, fenêtres de dépréciation et notes de migration.

Conserver cette page comme vue d'ensemble publique et claire. Reporter les détails d'implémentation dans les pages générées du schéma, des wrappers et de la référence MCP, à mesure que la surface authentifiée s'étend.