code_contracts:
  - module: state-machine
    owner_agent: agent-fsm
    interfaces:
      - transition(from_state, to_state) -> OK | REJECTED(reason)
      - is_terminal(state) -> boolean
      - get_allowed_transitions(state) -> list
    invariants:
      - "INV-293-09 : Seules les transitions listees en §5.2 sont autorisees"
      - "INV-293-10 : DONE, ABORTED, CRASHED, START_FAILED sont terminaux — aucune transition sortante"
      - "8 etats contractuels : STARTING, RUNNING, ESCALADED, PAUSED, DONE, ABORTED, CRASHED, START_FAILED"
    forbidden:
      - "Ajouter un etat non liste en §5.2 (ESCALADE_PENDING, ESCALADE_EXPIRED interdits en v1)"
      - "Accepter une transition non autorisee silencieusement (toujours rejeter + logguer)"
      - "Modifier les etats terminaux (is_terminal hardcode, pas configurable)"
    architectural_decisions:
      - decision: "Matrice de transitions en tableau associatif Bash (declare -A)"
        rationale: "Structure declarative lisible, O(1) lookup, coherent avec §5.2 sans logique conditionnelle."
        alternatives_considered:
          - "Case/switch imbriques (verbose, risque d'oubli de transition)"
          - "Fichier YAML externe parse par jq (overhead I/O pour chaque transition)"
        trade_offs:
          - "Avantage : deterministe, exhaustif, testable unitairement"
          - "Inconvenient : limite aux types Bash (string keys uniquement)"
    files:
      - "scripts/lib/lord-fsm.sh"

  - module: validator
    owner_agent: agent-validator
    interfaces:
      - validate_story_id(value) -> OK | ERROR(reason)
      - validate_project_code(value) -> OK | ERROR(reason)
      - validate_message_type(value) -> OK | ERROR(reason)
      - validate_timestamp(value) -> OK | ERROR(reason)
      - validate_peer_id(value) -> OK | ERROR(reason)
      - validate_escalade_text(value) -> OK | ERROR(reason)
      - validate_idempotency_key(value) -> OK | ERROR(reason)
      - validate_message(json_payload) -> OK | ERROR(reason)
    invariants:
      - "INV-293-05 : Tout message invalide est rejete de facon deterministe avec raison explicite"
      - "Regex story_id : ^PD-[0-9]{1,4}$ (source de verite unique, case-sensitive)"
      - "Timestamps : seuls Z et +00:00 acceptes (strictement UTC, decision plan §9.9)"
    forbidden:
      - "Accepter un message partiellement valide (tout-ou-rien)"
      - "Utiliser eval ou interpolation directe des valeurs validees dans du shell"
      - "Accepter des offsets non-UTC dans les timestamps (ex: +02:00)"
    architectural_decisions:
      - decision: "Fonctions de validation par champ avec regex Bash natif ([[ =~ ]])"
        rationale: "Zero dependance externe, performance native, coherent avec la stack shell du projet."
        alternatives_considered:
          - "jq pour validation JSON schema (necessite jq installe, overhead par appel)"
          - "Python script de validation (overhead subprocess pour chaque message)"
        trade_offs:
          - "Avantage : zero dependance, rapide, testable isolement"
          - "Inconvenient : regex complexes moins lisibles en Bash qu'en Python"
    files:
      - "scripts/lib/lord-validator.sh"

  - module: logger
    owner_agent: agent-logger
    interfaces:
      - log_event(event_type, fields...) -> void
      - log_rejection(peer_id, message_type, reason, story_id?) -> void
      - log_transition(story_id, from_state, to_state) -> void
      - log_alert(severity, message) -> void
    invariants:
      - "Format JSONL §6.1 : champs obligatoires timestamp, peer_id, message_type, reason pour les rejets"
      - "Timestamps RFC3339 UTC (suffixe Z)"
      - "Convention rejets commande Sovereign : peer_id='sovereign', message_type='COMMAND' (decision plan H-PLAN-02)"
    forbidden:
      - "Ecrire des logs dans un format autre que JSONL"
      - "Omettre un champ obligatoire dans un log de rejet"
      - "Logger le contenu complet de escalade_text (risque RGPD) — logger uniquement le motif de rejet et l'escalade_id"
    architectural_decisions:
      - decision: "Convention peer_id='sovereign' et message_type='COMMAND' pour les rejets CLI"
        rationale: "§6.1 impose peer_id et message_type pour tout rejet, mais ces champs ne sont pas definis pour les commandes Sovereign. Convention deterministe documentee."
        alternatives_considered:
          - "Omettre les champs (viole §6.1)"
          - "Utiliser des valeurs vides (non conforme minLength)"
        trade_offs:
          - "Avantage : conforme §6.1, testable, coherent"
          - "Inconvenient : valeur non canonique, a documenter pour auditeurs"
    files:
      - "scripts/lib/lord-logger.sh"

  - module: state-store
    owner_agent: agent-state
    interfaces:
      - load_state() -> GovLordState
      - save_state(state) -> void
      - count_active_stories() -> int
      - add_story(story_id, project_code) -> void
      - update_story_state(story_id, new_state) -> void
      - update_story_peer(story_id, peer_id, last_seen_at) -> void
      - enqueue_escalade(story_id, escalade_id, text, timestamp) -> void
      - dequeue_escalade(story_id) -> escalade | null
      - check_idempotency(key, payload_hash) -> HIT(result) | CONFLICT | NEW
      - store_idempotency(key, command, story_id, payload_hash, result_hash) -> void
      - purge_expired_idempotency() -> int
    invariants:
      - "INV-293-13 : escalade_queue est FIFO — dequeue retourne la plus ancienne OPEN de la story"
      - "INV-293-12 : idempotency_cache indexe par key, hash SHA-256 du payload, TTL 24h"
      - "Schema §5.4 respecte pour .gov-lord-state.json (version, updated_at, stories, escalade_queue, idempotency_cache)"
      - "Localisation : fichier dans le dossier epic (docs/epics/tooling/PD-293-one-ring-orchestration/), pas a la racine"
    forbidden:
      - "Ecrire dans un fichier autre que .gov-lord-state.json"
      - "Modifier l'ordre de la queue d'escalades (toujours FIFO par created_at)"
      - "Supprimer des entrees idempotency_cache avant expiration TTL (sauf purge explicite)"
      - "Stocker des credentials ou tokens dans le state"
    architectural_decisions:
      - decision: "Fichier JSON unique (.gov-lord-state.json) avec read-modify-write atomique via temp file + mv"
        rationale: "Coherent avec le schema §5.4. mv est atomique sur POSIX. Pas besoin de base de donnees pour 5 stories max."
        alternatives_considered:
          - "SQLite (overkill pour 5 entrees, ajout dependance)"
          - "Fichiers separes par story (fragmentation, pas de vue consolidee)"
        trade_offs:
          - "Avantage : schema unique, atomicite, zero dependance"
          - "Inconvenient : contention si acces concurrent (mitige par execution sequentielle One Ring)"
      - decision: "Valeur sentinelle '__pending__' pour peer_id en etat STARTING"
        rationale: "Le schema §5.4 impose peer_id required, mais en STARTING le peer n'est pas encore detecte. La sentinelle satisfait minLength:1 sans polluer le modele."
        alternatives_considered:
          - "Rendre peer_id optional dans le schema (viole §5.4)"
          - "Creer le peer avant l'ajout au state (race condition)"
        trade_offs:
          - "Avantage : conforme schema, semantiquement clair"
          - "Inconvenient : valeur magique a documenter"
    files:
      - "scripts/lib/lord-state.sh"

  - module: broker-adapter
    owner_agent: agent-broker
    interfaces:
      - broker_list_peers() -> peers[] | ERROR
      - broker_send_message(peer_id, message_json) -> OK | ERROR
      - broker_check_health() -> UP | DEGRADED | DOWN
      - broker_reconnect() -> OK | ERROR
    invariants:
      - "INV-293-02 : seul canal de communication entre One Ring et Ringbearers"
      - "Reconnexion exponentielle bornee : 1s, 2s, 4s, 8s, 10s max (§5.3 point 10)"
      - "Mode degrade explicite tant que broker indisponible (broker.status dans state)"
    forbidden:
      - "Communiquer avec les Ringbearers autrement que via broker (pas de fichier partage, pas de signal Unix)"
      - "Acceder aux repos cibles des stories (git, fichiers, API)"
      - "Ignorer silencieusement une erreur broker (toujours propager ou mode degrade)"
    architectural_decisions:
      - decision: "Appel claude-peers-mcp via MCP tools (use_mcp_tool) en subprocess"
        rationale: "claude-peers-mcp est un serveur MCP. L'appel via tools est le contrat d'interface standard."
        alternatives_considered:
          - "API REST directe sur le broker SQLite (contourne l'abstraction MCP, fragile)"
          - "CLI custom wrapping le broker (overhead de maintenance)"
        trade_offs:
          - "Avantage : interface stable, coherent avec l'ecosysteme MCP"
          - "Inconvenient : dependance sur disponibilite du serveur MCP"
    files:
      - "scripts/lib/lord-broker.sh"

  - module: supervisor
    owner_agent: agent-supervisor
    interfaces:
      - start_supervision_loop() -> void (boucle infinie)
      - poll_once() -> PollResult
      - check_liveness(story_id) -> ALIVE | MISSING(cycles)
      - reconcile() -> ReconciliationDelta
      - detect_crashes() -> crashed_stories[]
    invariants:
      - "INV-293-08 : crash detecte en <= 2 cycles (crash_detection_cycles_max = 2, non configurable)"
      - "INV-293-11 : reconciliation periodique a chaque cycle de polling"
      - "Derive SLA crash : 2 * peer_poll_interval (defaut 20s)"
    forbidden:
      - "Attendre plus de 2 cycles pour declarer un crash"
      - "Modifier l'etat d'une story terminale lors de la reconciliation"
      - "Ignorer un ecart detecte sans le logguer"
    architectural_decisions:
      - decision: "Boucle polling avec sleep peer_poll_interval entre chaque iteration"
        rationale: "Simple, deterministe, coherent avec les parametres contractuels §5.1."
        alternatives_considered:
          - "Event-driven via inotify/fswatch (complexite, pas de support natif MCP events)"
          - "Webhook callback du broker (claude-peers-mcp ne supporte pas les webhooks)"
        trade_offs:
          - "Avantage : simplicite, parametres contractuels respectes"
          - "Inconvenient : latence = peer_poll_interval (acceptable pour use case local)"
    files:
      - "scripts/lib/lord-supervisor.sh"

  - module: command-router
    owner_agent: agent-commands
    interfaces:
      - dispatch(command, args) -> Result
      - cmd_start(story_id, project_code, idempotency_key?) -> Result
      - cmd_status(story_id?) -> Result
      - cmd_stop(story_id, reason?, idempotency_key?) -> Result
      - cmd_escalade(story_id?) -> Result
      - cmd_respond(story_id, response, idempotency_key?) -> Result
      - cmd_pause(story_id, reason?, idempotency_key?) -> Result
      - cmd_resume(story_id, idempotency_key?) -> Result
    invariants:
      - "INV-293-01 : whitelist de commandes (start, status, stop, escalade, respond, pause, resume) — tout autre = rejet"
      - "INV-293-14 / §5.1 : start -> quota, idempotence, format. Autres -> idempotence, format (decision plan H-PLAN-01)"
      - "INV-293-04 : rejet si active >= max_ringbearers sur start"
    forbidden:
      - "Executer une action metier (lecture/ecriture code, build, tests, Jira, GitLab, Vault)"
      - "Accepter une commande hors whitelist"
      - "Modifier l'ordre des gardes"
      - "Lancer un Ringbearer sans passer par les 3 gardes de start"
    architectural_decisions:
      - decision: "Case/dispatch central avec gardes en fonctions separees"
        rationale: "Chaque commande a ses gardes specifiques (§5.1 points 3-4). Fonctions separees permettent test unitaire de chaque garde."
        alternatives_considered:
          - "Middleware chain (pattern overkill pour 7 commandes shell)"
          - "Fichier de config des gardes (over-engineering pour un ordre fixe)"
        trade_offs:
          - "Avantage : lisible, testable, ordre explicite"
          - "Inconvenient : duplication mineure entre start et autres (2 vs 3 gardes)"
    files:
      - "scripts/lib/lord-commands.sh"

  - module: skill-gov-lord
    owner_agent: agent-skill
    interfaces:
      - Parsing arguments CLI (/gov-lord <command> [args] [--flags])
      - Affichage consolide (tableaux, alertes, messages)
    invariants:
      - "INV-293-01 : le skill ne delegue qu'aux commandes connues de command-router"
      - "CA-06 : compatible /remote-control (iPhone/Safari) — pas de dependance UI specifique"
    forbidden:
      - "Executer du code metier directement dans le skill"
      - "Appeler des outils hors broker (pas de Read, Write, Bash sur repos cibles)"
      - "Hardcoder des paths de repos cibles"
    files:
      - ".claude/commands/gov-lord.md"

  - module: tests
    owner_agent: agent-tests
    interfaces:
      - Tests unitaires bats-core pour C1, C2, C3, C7 (gardes)
      - Tests integration bats-core pour C4 (complet), C5 (broker stubbe), C6, C7
      - Tests E2E pour TC-NOM-14 (start->RUNNING), TC-NR-01 (baseline /gov)
      - Tests negatifs TC-NEG-01..10
    invariants:
      - "Chaque TC-* de la spec a un test bats correspondant"
      - "Tests unitaires sans I/O reseau (broker stubbe)"
    forbidden:
      - "Mocker la machine d'etats (tester les vraies transitions)"
      - "Dependre d'un broker reel pour les tests unitaires"
      - "Sauter les tests negatifs TC-NEG-01..10"
    files:
      - "tests/lord/**"

# PD-293-code-contracts.yaml
# Frontières de code entre agents — PD-293 One Ring Orchestration
# Cohérent avec le plan d'implémentation v2

code_contracts:
  - module: state-machine
    owner_agent: agent-fsm
    interfaces:
      - "lord_transition(story_id, from_state, to_state) -> OK | REJECTED"
      - "lord_is_terminal(state) -> true | false"
      - "lord_allowed_transitions(from_state) -> list[to_state]"
    invariants:
      - "INV-293-09 : Toutes transitions non listees en §5.2 sont rejetees."
      - "INV-293-10 : Etats terminaux (DONE, ABORTED, CRASHED, START_FAILED) n'acceptent aucune transition sortante."
      - "INV-293-06 : Depuis ESCALADED, seules les transitions vers RUNNING (PO_RESPONSE), ABORTED et CRASHED sont autorisees."
    forbidden:
      - "Ajouter un etat non contractuel (ex: ESCALADE_PENDING, ESCALADE_EXPIRED)."
      - "Accepter une transition non listee dans la matrice §5.2."
      - "Modifier un etat terminal apres qu'il a ete atteint."
    architectural_decisions:
      - decision: "Matrice de transitions en tableau associatif Bash (declare -A)"
        rationale: "Bash 5+ supporte les tableaux associatifs. Lookup O(1) par cle 'FROM->TO'. Plus maintenable qu'une cascade de if/case."
        alternatives_considered:
          - "Case/switch imbriques (lisible mais verbose, risque d'oubli d'un cas)"
          - "Fichier YAML externe parse par yq (overhead inutile pour une matrice statique)"
        trade_offs:
          - "Avantage : Lookup O(1), matrice exhaustive verifiable par diff avec §5.2"
          - "Inconvenient : Requiert Bash 5+ (brew install bash)"
    files:
      - "scripts/lib/lord-state-machine.sh"

  - module: validator
    owner_agent: agent-validator
    interfaces:
      - "lord_validate_story_id(value) -> OK | REJECTED"
      - "lord_validate_project_code(value) -> OK | REJECTED"
      - "lord_validate_message_type(value) -> OK | REJECTED"
      - "lord_validate_peer_id(value) -> OK | REJECTED"
      - "lord_validate_timestamp(value) -> OK | REJECTED"
      - "lord_validate_escalade_text(value) -> OK | REJECTED"
      - "lord_validate_summary_text(value) -> OK | REJECTED"
      - "lord_validate_idempotency_key(value) -> OK | REJECTED"
      - "lord_log_rejection(timestamp, peer_id, message_type, reason, story_id, event) -> void"
    invariants:
      - "INV-293-05 : Chaque champ est valide selon §5.1 (regex, enum, bornes). Rejet deterministe et journalise en JSONL §6.1."
      - "Timestamp RFC3339 strictement UTC : seul le suffixe Z est accepte (decision H-TECH-08)."
      - "Les rejets de commandes Sovereign utilisent peer_id='sovereign' et message_type=nom de la commande en majuscules (decision spec-review §6.1)."
    forbidden:
      - "Accepter un champ invalide sans log de rejet §6.1."
      - "Accepter un timestamp avec offset non-Z (ex: +02:00)."
      - "Valider partiellement un message (tous les champs obligatoires doivent etre verifies)."
    architectural_decisions:
      - decision: "Validation par regex Bash natif ([[ =~ ]]) sauf peer_id/escalade_text (grep -P)"
        rationale: "Les regex §5.1 simples (story_id, project_code, etc.) sont faisables en Bash natif. peer_id et escalade_text necessitent Unicode property class \p{C} via grep -P (GNU grep)."
        alternatives_considered:
          - "Python script dedie (overhead de process pour chaque validation)"
          - "jq schema validation (ne supporte pas les regex)"
        trade_offs:
          - "Avantage : Zero dependance pour 6/8 validateurs, performance native"
          - "Inconvenient : Necessite GNU grep installe pour 2 validateurs (H-TECH-04)"
    files:
      - "scripts/lib/lord-validator.sh"

  - module: broker-adapter
    owner_agent: agent-broker
    interfaces:
      - "lord_broker_list_peers() -> json_array | ERROR"
      - "lord_broker_send_message(peer_id, message_type, payload) -> OK | ERROR"
      - "lord_broker_get_messages(peer_id) -> json_array | ERROR"
      - "lord_broker_status() -> UP | DEGRADED | DOWN"
      - "lord_broker_reconnect() -> OK | STILL_DEGRADED"
    invariants:
      - "INV-293-02 : Toute communication One Ring <-> Ringbearer passe par le broker. Aucun acces direct aux repos cibles."
      - "Reconnexion exponentielle bornee : 1s, 2s, 4s, 8s, 10s (plafond). Mode DEGRADED explicite tant que indisponible."
      - "Les messages recus sont valides par C2 (lord-validator) avant traitement dans C5."
    forbidden:
      - "Acceder directement a un repo cible (cd, git, curl vers GitLab/Jira/Vault)."
      - "Communiquer avec un Ringbearer sans passer par le broker."
      - "Ignorer silencieusement une erreur broker (toute erreur doit basculer en DEGRADED)."
    architectural_decisions:
      - decision: "Couche d'abstraction Bash wrappant claude-peers-mcp MCP tools"
        rationale: "Isole le risque H-TECH-01/02. Si l'API differe, seul ce module est adapte. Mockable pour tests."
        alternatives_considered:
          - "Appels MCP directs dans l'orchestrateur (couplage fort, impossible a mocker)"
          - "IPC par fichiers partages (fallback si broker indisponible — hors scope v1)"
        trade_offs:
          - "Avantage : Abstraction propre, testable, isolee"
          - "Inconvenient : Overhead d'une couche supplementaire"
    files:
      - "scripts/lib/lord-broker.sh"

  - module: persistence
    owner_agent: agent-persistence
    interfaces:
      - "lord_state_read() -> json_object"
      - "lord_state_write(json_object) -> OK | ERROR"
      - "lord_count_active_stories() -> integer"
      - "lord_create_story(story_id, project_code, state, peer_id) -> OK | ERROR"
      - "lord_update_story(story_id, updates) -> OK | ERROR"
      - "lord_get_story(story_id) -> json_object | NONE"

exec
/bin/zsh -lc "sed -n '520,920p' docs/epics/tooling/PD-293-one-ring-orchestration/PD-293-plan.md" in /Users/loic/Developpement/ProbatioVault/ProbatioVault-ia-governance
 succeeded in 698ms:
pyenv: cannot rehash: /Users/loic/.pyenv/shims isn't writable
pyenv: cannot rehash: /Users/loic/.pyenv/shims isn't writable
      - "lord_get_story(story_id) -> json_object | NONE"
      - "lord_enqueue_escalade(story_id, escalade_id, text, timestamp) -> OK | ERROR"
      - "lord_dequeue_oldest_escalade(story_id) -> escalade_json | NONE"
      - "lord_count_open_escalades(story_id) -> integer"
      - "lord_check_idempotency(key, payload_hash) -> NEW | REPLAY(result_hash) | CONFLICT"
      - "lord_record_idempotency(key, command, story_id, payload_hash, result_hash, ttl) -> OK"
      - "lord_purge_expired_idempotency() -> count_purged"
    invariants:
      - "INV-293-13 : escalade_queue est un tableau FIFO ordonne par created_at. dequeue retire l'element OPEN le plus ancien pour la story cible."
      - "INV-293-12 : Idempotency cache verifie key + payload_hash. Meme key + meme payload = REPLAY. Meme key + payload different = CONFLICT."
      - "Le fichier .gov-lord-state.json est conforme au schema JSON §5.4 a chaque ecriture."
      - "Purge des entrees idempotency expirees a chaque demarrage et a chaque lecture du cache."
      - "Ecriture atomique : fichier temporaire + mv (meme filesystem)."
      - "Acces concurrent protege par flock."
    forbidden:
      - "Ecrire un fichier .gov-lord-state.json non conforme au schema §5.4."
      - "Stocker escalade_text dans les logs d'audit (uniquement escalade_id + story_id)."
      - "Acceder a des donnees d'une story depuis une autre story sans indexation explicite par story_id."
      - "Ecrire directement le fichier state sans passer par fichier temporaire + mv."
    architectural_decisions:
      - decision: "JSON manipule par jq + ecriture atomique tmp+mv + flock"
        rationale: "jq est le standard JSON en shell. L'ecriture atomique empeche la corruption. flock protege les acces concurrents entre supervision loop et commandes CLI."
        alternatives_considered:
          - "Python json module (plus puissant mais overhead de process)"
          - "SQLite (overkill pour 5 stories max)"
        trade_offs:
          - "Avantage : Expressif, robuste, large adoption, pas de corruption"
          - "Inconvenient : Dependance jq (H-TECH-05)"
      - decision: "Stockage a la racine du repo ia-governance (pas dans un epic)"
        rationale: "Etat runtime global, pas un artefact de story. Ajoute au .gitignore."
    files:
      - "scripts/lib/lord-persistence.sh"
      - ".gov-lord-state.json"
      - ".gov-lord-audit.jsonl"

  - module: orchestrator
    owner_agent: agent-orchestrator
    interfaces:
      - "lord_start(story_id, project_code, idempotency_key) -> OK | ERROR"
      - "lord_status(story_id?) -> json_output"
      - "lord_escalade(story_id?) -> json_output"
      - "lord_respond(story_id, response_text, idempotency_key) -> OK | ERROR"
      - "lord_pause(story_id, reason?, idempotency_key) -> OK | ERROR"
      - "lord_resume(story_id, idempotency_key) -> OK | ERROR"
      - "lord_stop(story_id, reason?, idempotency_key) -> OK | ERROR"
      - "lord_supervision_loop() -> never_returns"
    invariants:
      - "INV-293-14 : Ordre des gardes pour start : quota -> idempotence -> format -> story non-dupliquee."
      - "INV-293-14 : Ordre des gardes pour stop/respond/pause/resume : idempotence -> format."
      - "INV-293-08 : Crash detecte en <= 2 cycles de polling (missed_polls >= crash_detection_cycles_max)."
      - "INV-293-11 : Reconciliation periodique entre etat local (C4) et peers observes (C3) a chaque cycle."
      - "INV-293-01 : Aucune action hors interface/routage. Aucun acces direct aux repos cibles."
      - "Multi-escalade : transition ESCALADED->RUNNING uniquement quand TOUTES les escalades OPEN de la story sont traitees."
    forbidden:
      - "Executer une commande systeme hors perimetre (cd vers repo, git, curl Jira/GitLab/Vault)."
      - "Contourner l'ordre des gardes contractuel."
      - "Modifier l'etat d'une story sans passer par C1 (state-machine)."
      - "Communiquer avec un Ringbearer sans passer par C3 (broker-adapter)."
      - "Lire ou ecrire le state sans passer par C4 (persistence)."
      - "Importer jira-api.sh, state.sh, ou tout module du workflow /gov existant."
    architectural_decisions:
      - decision: "Boucle de supervision en background avec trap + sleep interruptible"
        rationale: "Le One Ring doit tourner en continu. Trap SIGINT/SIGTERM pour persistance propre. Sleep via 'sleep N & wait $!' pour reactivite signal."
        alternatives_considered:
          - "Cron job (trop lent pour SLA 5s)"
          - "Daemon launchd (overhead infra pour outil dev local)"
        trade_offs:
          - "Avantage : Simple, pas d'infra additionnelle"
          - "Inconvenient : Depend du terminal ouvert (acceptable MacBook local)"
    files:
      - "scripts/gov-lord.sh"

  - module: commands
    owner_agent: agent-skill
    interfaces:
      - "Skill Claude Code /gov-lord : parse arguments, delegue a C5"
    invariants:
      - "INV-293-01 : Whitelist de 7 commandes (start, status, escalade, respond, pause, resume, stop). Toute autre commande retourne un message de blocage explicite."
      - "CA-05 : Message de blocage coherent et systematique pour les commandes hors scope."
    forbidden:
      - "Ajouter une commande qui execute une action metier (lecture repo, build, Jira, GitLab)."
      - "Deleguer une commande non reconnue a C5 sans blocage."
    files:
      - ".claude/commands/gov-lord.md"

  - module: tests
    owner_agent: agent-tests
    interfaces:
      - "Suites BATS : tests/lord/state-machine.bats, tests/lord/validator.bats, tests/lord/persistence.bats, tests/lord/orchestrator.bats, tests/lord/integration.bats, tests/lord/negative.bats, tests/lord/non-regression.bats"
    invariants:
      - "Chaque test produit un resultat deterministe (pas de dependance a l'horloge reelle sauf TC-NOM-04)."
      - "Les tests utilisent un mock broker (pas de dependance a claude-peers-mcp en CI)."
      - "TC-INV-01 teste exhaustivement la matrice 8x8 (64 paires) de transitions."
    forbidden:
      - "Tester avec un broker reel sans fallback mock."
      - "Ignorer un test d'invariant (TC-INV-*) ou de non-regression (TC-NR-*)."
      - "Dependre de fichiers ou d'etat existant dans .gov-lord-state.json entre tests (setup/teardown obligatoire)."
    architectural_decisions:
      - decision: "BATS (Bash Automated Testing System) avec mock broker en fichier"
        rationale: "BATS est le standard de facto pour Bash. Le mock broker est un ensemble de fonctions shell qui simulent list_peers/send_message/get_messages via fichiers JSON temporaires."
        alternatives_considered:
          - "shunit2 (moins maintenu)"
          - "pytest + subprocess (overhead Python pour Bash)"
        trade_offs:
          - "Avantage : Natif Bash, large communaute, TAP output, facile CI"
          - "Inconvenient : Dependance externe bats-core (H-TECH-06)"
    files:
      - "tests/lord/**/*.bats"
      - "tests/lord/mocks/**"
      - "tests/lord/fixtures/**"