//! Cliente del bus de agente + bucle agéntico (Fase 6). Ver `docs/08-ai-integration.md`.
//!
//! Tres piezas:
//!
//! 1. [`client`] — `AgentClient`: envoltorio síncrono de `/run/agent.sock`. Hace el
//!    handshake, envía comandos y devuelve eventos. Diseñado para que el orquestador
//!    pueda esperar a un `BuildReady` específico tras un `Compile`.
//! 2. [`translator`] — Trait `IntentTranslator` + `MockTranslator`: convierte una intención
//!    en lenguaje natural a un `.swm`. El traductor real (LLM) se conecta detrás del trait;
//!    el mock cubre los tests y los smoke en el host de desarrollo.
//! 3. [`orchestrator`] — El bucle plan→build→try→apply→verify→propose. Aplica las
//!    mutaciones a un overlay (o a un prefix para tests), valida postcondiciones y
//!    devuelve un `Proposal` que el humano usa para decidir `commit`.
//!
//! Decisión de diseño: el cliente es **bloqueante** (std::sync), no async. La cadencia
//! agéntica es de comandos/seg, no de RPS; y un cliente sync es 5× menos código y debuggable
//! con un breakpoint normal. Cuando aparezca un caso real de N agentes concurrentes,
//! evaluamos tokio.

pub mod client;
pub mod orchestrator;
pub mod translator;

pub use client::{AgentClient, ClientError, Welcome};
pub use orchestrator::{Orchestrator, Proposal, VerifyCheck};
pub use translator::{IntentCatalog, IntentTranslator, MockTranslator, SystemContext, TranslateError};

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("client: {0}")]
    Client(#[from] ClientError),
    #[error("translator: {0}")]
    Translate(#[from] TranslateError),
    #[error("orchestrator: {0}")]
    Orchestrate(String),
    #[error("io: {0}")]
    Io(#[from] std::io::Error),
    #[error("overlay: {0}")]
    Overlay(#[from] hammer_overlay::Error),
    #[error("apply: {0}")]
    Apply(#[from] hammer_core::apply::ApplyError),
    #[error("core: {0}")]
    Core(#[from] hammer_core::Error),
}

pub type Result<T> = std::result::Result<T, Error>;