/**
 * ╔══════════════════════════════════════════════════════════════════════╗
 * ║   OVERMIND BRIDGE — MessageLog (Postgres Persistence)                ║
 * ║                                                                      ║
 * ║   Persiste tous les messages agent↔agent et client→agent dans       ║
 * ║   Postgres pour audit, replay après crash, et statistiques.          ║
 * ║                                                                      ║
 * ║   TABLE                                                              ║
 * ║   ──────                                                             ║
 * ║   bridge_messages                                                    ║
 * ║     id              UUID PK                                          ║
 * ║     from_agent      TEXT NULL   (NULL = client externe)              ║
 * ║     to_agent        TEXT NOT NULL                                    ║
 * ║     runner          TEXT NOT NULL                                    ║
 * ║     prompt          TEXT NOT NULL                                    ║
 * ║     response        TEXT NULL                                        ║
 * ║     status          TEXT NOT NULL (pending|running|done|failed)     ║
 * ║     session_id      TEXT NULL                                        ║
 * ║     metadata        JSONB NULL   (path, model, mode, discord ctx)    ║
 * ║     error           TEXT NULL                                        ║
 * ║     created_at      TIMESTAMPTZ                                      ║
 * ║     started_at      TIMESTAMPTZ NULL                                 ║
 * ║     completed_at    TIMESTAMPTZ NULL                                 ║
 * ║     duration_ms     INTEGER NULL                                     ║
 * ╚══════════════════════════════════════════════════════════════════════╝
 */
import { type BridgeLogger } from './utils.js';
import type { RunnerType } from './types.js';
export type MessageStatus = 'pending' | 'running' | 'done' | 'failed' | 'timeout';
export interface PersistedMessage {
    id: string;
    fromAgent: string | null;
    toAgent: string;
    runner: RunnerType;
    prompt: string;
    response: string | null;
    status: MessageStatus;
    sessionId: string | null;
    metadata: Record<string, unknown> | null;
    error: string | null;
    createdAt: Date;
    startedAt: Date | null;
    completedAt: Date | null;
    durationMs: number | null;
}
export interface CreateMessageInput {
    fromAgent?: string | null;
    toAgent: string;
    runner: RunnerType;
    prompt: string;
    sessionId?: string;
    metadata?: Record<string, unknown> | null;
}
export interface ListMessagesFilter {
    toAgent?: string;
    /** null = filtre les messages sans fromAgent (i.e. venant d'un client externe) */
    fromAgent?: string | null;
    status?: MessageStatus;
    /** Limite de résultats (default: 50) */
    limit?: number;
    /** Offset pour pagination (default: 0) */
    offset?: number;
    /** Depuis N heures (ex: 24 = dernières 24h) */
    sinceHours?: number;
}
export interface MessageLogConfig {
    host: string;
    port: number;
    user: string;
    password: string;
    database: string;
    /** SSL (default: false) */
    ssl?: boolean;
    /** Pool min/max (default: 2/10) */
    poolMin?: number;
    poolMax?: number;
}
export declare class MessageLog {
    private readonly config;
    private pool;
    private readonly log;
    private initialized;
    constructor(config: MessageLogConfig, logger?: BridgeLogger);
    /**
     * Initialise le pool Postgres et crée le schéma si nécessaire.
     * Idempotent : peut être appelé plusieurs fois sans danger.
     */
    init(): Promise<void>;
    /**
     * Ferme proprement le pool.
     */
    close(): Promise<void>;
    /**
     * Crée un message en status 'pending' et retourne son ID.
     */
    create(input: CreateMessageInput): Promise<string>;
    /**
     * Marque un message comme 'running' (appel MCP en cours).
     */
    markRunning(id: string, sessionId?: string): Promise<void>;
    /**
     * Marque un message comme 'done' avec sa réponse.
     */
    markDone(id: string, response: string, sessionId?: string): Promise<void>;
    /**
     * Marque un message comme 'failed' avec erreur.
     */
    markFailed(id: string, error: string): Promise<void>;
    /**
     * Marque un message comme 'timeout'.
     */
    markTimeout(id: string): Promise<void>;
    /**
     * Récupère un message par ID.
     */
    getById(id: string): Promise<PersistedMessage | null>;
    /**
     * Liste les messages avec filtres et pagination.
     */
    list(filter?: ListMessagesFilter): Promise<PersistedMessage[]>;
    /**
     * Trouve les messages 'pending' ou 'running' depuis plus de X minutes (stuck).
     * Utile pour le replay automatique au redémarrage.
     */
    findStuck(stuckAfterMinutes?: number): Promise<PersistedMessage[]>;
    /**
     * Statistiques globales du log.
     */
    stats(sinceHours?: number): Promise<{
        total: number;
        byStatus: Record<MessageStatus, number>;
        byRunner: Record<string, number>;
        avgDurationMs: number | null;
    }>;
    private assertReady;
}
/**
 * Charge la config Postgres depuis process.env (POSTGRES_*).
   * Utilise les variables déjà dans .env.
   */
export declare function loadMessageLogConfigFromEnv(): MessageLogConfig;
//# sourceMappingURL=MessageLog.d.ts.map