/**
 * Observability / Tracing — registra cada execução do runtime em disco (JSON).
 *
 * Cada run gera um arquivo `.izanagi/state/traces/<runId>.json` com spans
 * estruturados: task, decisões, agentes, skills, tools, modelo, tokens,
 * latência, retries, falhas, artefatos, avaliação e score final.
 */
import type { RunTrace, TraceSpan } from '../types.js';
import { EventBus, type IzanagiEvent } from './events.js';
export declare const TRACE_DIR_REL: string;
export interface TraceStoreOptions {
    baseDir: string;
}
/**
 * Store de traces em disco. Thread-safe o suficiente para CLI single-process.
 */
export declare class TraceStore {
    private readonly opts;
    private readonly dir;
    constructor(opts: TraceStoreOptions);
    get directory(): string;
    ensure(): void;
    /** Gera um novo run id legível (izanagi-YYYYMMDD-HHMMSS-xxxx). */
    static newRunId(): string;
    private fileFor;
    /** Persiste um trace completo. */
    save(trace: RunTrace): string;
    /** Carrega um trace pelo runId (ou path). */
    load(runId: string): RunTrace | null;
    /** Lista traces, mais recentes primeiro. */
    list(limit?: number): RunTrace[];
}
export interface TraceContext {
    runId: string;
    task: string;
    command: string;
    startedAt: string;
    agents: Set<string>;
    skills: Set<string>;
    tools: Set<string>;
    retries: number;
    failures: number;
    spans: TraceSpan[];
}
/**
 * Sessão de tracing ativa durante um run. Fecha o span ao finalizar e
 * produz um RunTrace persistível.
 */
export declare class Tracer {
    private readonly ctx;
    private readonly store;
    private readonly seq;
    private tokensIn;
    private tokensOut;
    /** Event System — pub/sub em tempo real do ciclo de vida deste run (ver observability/events.ts). */
    readonly events: EventBus;
    constructor(store: TraceStore, opts: {
        runId?: string;
        task: string;
        command: string;
        onEvent?: (event: IzanagiEvent) => void;
    });
    get runId(): string;
    get task(): string;
    /**
     * Abre um span; retorna uma função close(ok?, error?) que registra duração.
     */
    span(name: string, type: TraceSpan['type'], metadata?: Record<string, unknown>): (ok?: boolean, error?: string) => void;
    /** Persiste um snapshot parcial do run em andamento (ver nota de crash-safety em `span()`). */
    flush(): void;
    markAgent(agent: string): void;
    markSkill(skill: string): void;
    markTool(tool: string): void;
    addTokens(input: number, output: number): void;
    /**
     * Finaliza a sessão e devolve o RunTrace montado. Também usado por `flush()`
     * para snapshots parciais — nesse caso `endedAt`/`durationMs` refletem "como
     * estava no momento do flush", não o fim real (ausência de `evaluation` é o
     * sinal de que o run ainda está em andamento).
     */
    finish(extra?: Partial<RunTrace>): RunTrace;
    /** Finaliza e persiste. Retorna o runId. */
    finishAndSave(extra?: Partial<RunTrace>): {
        trace: RunTrace;
        file: string;
    };
}
//# sourceMappingURL=tracer.d.ts.map