/**
 * Terminal-Bench Adapter for UAM
 *
 * Assumptions:
 * - Target: Compare UAM-enabled agents vs naive agents on terminal-style tasks
 * - Tasks require knowledge of project structure, past decisions, and patterns
 * - UAM provides persistent memory across task sessions
 *
 * What this handles:
 * - Benchmark task definitions
 * - Memory-enabled agent wrapper
 * - Performance comparison framework
 * - Results aggregation and reporting
 *
 * What this does NOT handle:
 * - Full Terminal-Bench framework integration (use tb run CLI for that)
 * - Real Docker environment sandboxing
 * - Multi-agent coordination (future enhancement)
 */
import { z } from 'zod';
export declare const BenchmarkTaskSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    description: z.ZodString;
    instruction: z.ZodString;
    difficulty: z.ZodEnum<["easy", "medium", "hard"]>;
    category: z.ZodEnum<["memory", "coordination", "code-quality", "performance", "testing"]>;
    verify: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
        success: z.ZodBoolean;
        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    }, "strip", z.ZodTypeAny, {
        success: boolean;
        details?: Record<string, any> | undefined;
    }, {
        success: boolean;
        details?: Record<string, any> | undefined;
    }>>>;
    estimatedMinutes: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    name: string;
    description: string;
    id: string;
    category: "memory" | "coordination" | "testing" | "code-quality" | "performance";
    verify: (...args: unknown[]) => Promise<{
        success: boolean;
        details?: Record<string, any> | undefined;
    }>;
    instruction: string;
    difficulty: "medium" | "easy" | "hard";
    estimatedMinutes?: number | undefined;
}, {
    name: string;
    description: string;
    id: string;
    category: "memory" | "coordination" | "testing" | "code-quality" | "performance";
    verify: (...args: unknown[]) => Promise<{
        success: boolean;
        details?: Record<string, any> | undefined;
    }>;
    instruction: string;
    difficulty: "medium" | "easy" | "hard";
    estimatedMinutes?: number | undefined;
}>;
export type BenchmarkTask = z.infer<typeof BenchmarkTaskSchema>;
export declare const AgentExecutionSchema: z.ZodObject<{
    taskId: z.ZodString;
    agent: z.ZodString;
    startTime: z.ZodNumber;
    endTime: z.ZodNumber;
    durationMs: z.ZodNumber;
    success: z.ZodBoolean;
    attempts: z.ZodNumber;
    memoryQueries: z.ZodOptional<z.ZodNumber>;
    tokensUsed: z.ZodOptional<z.ZodNumber>;
    errors: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    success: boolean;
    errors: string[];
    durationMs: number;
    taskId: string;
    agent: string;
    startTime: number;
    endTime: number;
    attempts: number;
    tokensUsed?: number | undefined;
    memoryQueries?: number | undefined;
}, {
    success: boolean;
    errors: string[];
    durationMs: number;
    taskId: string;
    agent: string;
    startTime: number;
    endTime: number;
    attempts: number;
    tokensUsed?: number | undefined;
    memoryQueries?: number | undefined;
}>;
export type AgentExecution = z.infer<typeof AgentExecutionSchema>;
export declare const BenchmarkResultSchema: z.ZodObject<{
    taskId: z.ZodString;
    taskName: z.ZodString;
    results: z.ZodArray<z.ZodObject<{
        taskId: z.ZodString;
        agent: z.ZodString;
        startTime: z.ZodNumber;
        endTime: z.ZodNumber;
        durationMs: z.ZodNumber;
        success: z.ZodBoolean;
        attempts: z.ZodNumber;
        memoryQueries: z.ZodOptional<z.ZodNumber>;
        tokensUsed: z.ZodOptional<z.ZodNumber>;
        errors: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        success: boolean;
        errors: string[];
        durationMs: number;
        taskId: string;
        agent: string;
        startTime: number;
        endTime: number;
        attempts: number;
        tokensUsed?: number | undefined;
        memoryQueries?: number | undefined;
    }, {
        success: boolean;
        errors: string[];
        durationMs: number;
        taskId: string;
        agent: string;
        startTime: number;
        endTime: number;
        attempts: number;
        tokensUsed?: number | undefined;
        memoryQueries?: number | undefined;
    }>, "many">;
    summary: z.ZodObject<{
        uamSuccessRate: z.ZodNumber;
        naiveSuccessRate: z.ZodNumber;
        uamAvgDuration: z.ZodNumber;
        naiveAvgDuration: z.ZodNumber;
        improvement: z.ZodObject<{
            successDelta: z.ZodNumber;
            speedup: z.ZodNumber;
            memoryQueries: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            memoryQueries: number;
            successDelta: number;
            speedup: number;
        }, {
            memoryQueries: number;
            successDelta: number;
            speedup: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        uamSuccessRate: number;
        naiveSuccessRate: number;
        uamAvgDuration: number;
        naiveAvgDuration: number;
        improvement: {
            memoryQueries: number;
            successDelta: number;
            speedup: number;
        };
    }, {
        uamSuccessRate: number;
        naiveSuccessRate: number;
        uamAvgDuration: number;
        naiveAvgDuration: number;
        improvement: {
            memoryQueries: number;
            successDelta: number;
            speedup: number;
        };
    }>;
}, "strip", z.ZodTypeAny, {
    summary: {
        uamSuccessRate: number;
        naiveSuccessRate: number;
        uamAvgDuration: number;
        naiveAvgDuration: number;
        improvement: {
            memoryQueries: number;
            successDelta: number;
            speedup: number;
        };
    };
    taskId: string;
    taskName: string;
    results: {
        success: boolean;
        errors: string[];
        durationMs: number;
        taskId: string;
        agent: string;
        startTime: number;
        endTime: number;
        attempts: number;
        tokensUsed?: number | undefined;
        memoryQueries?: number | undefined;
    }[];
}, {
    summary: {
        uamSuccessRate: number;
        naiveSuccessRate: number;
        uamAvgDuration: number;
        naiveAvgDuration: number;
        improvement: {
            memoryQueries: number;
            successDelta: number;
            speedup: number;
        };
    };
    taskId: string;
    taskName: string;
    results: {
        success: boolean;
        errors: string[];
        durationMs: number;
        taskId: string;
        agent: string;
        startTime: number;
        endTime: number;
        attempts: number;
        tokensUsed?: number | undefined;
        memoryQueries?: number | undefined;
    }[];
}>;
export type BenchmarkResult = z.infer<typeof BenchmarkResultSchema>;
export declare const OverallBenchmarkStatsSchema: z.ZodObject<{
    totalTasks: z.ZodNumber;
    uamSuccess: z.ZodNumber;
    naiveSuccess: z.ZodNumber;
    uamSuccessRate: z.ZodNumber;
    naiveSuccessRate: z.ZodNumber;
    uamAvgDuration: z.ZodNumber;
    naiveAvgDuration: z.ZodNumber;
    overallSpeedup: z.ZodNumber;
    byDifficulty: z.ZodRecord<z.ZodString, z.ZodObject<{
        count: z.ZodNumber;
        uamSuccess: z.ZodNumber;
        naiveSuccess: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }>>;
    byCategory: z.ZodRecord<z.ZodString, z.ZodObject<{
        count: z.ZodNumber;
        uamSuccess: z.ZodNumber;
        naiveSuccess: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    uamSuccessRate: number;
    naiveSuccessRate: number;
    uamAvgDuration: number;
    naiveAvgDuration: number;
    totalTasks: number;
    uamSuccess: number;
    naiveSuccess: number;
    overallSpeedup: number;
    byDifficulty: Record<string, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }>;
    byCategory: Record<string, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }>;
}, {
    uamSuccessRate: number;
    naiveSuccessRate: number;
    uamAvgDuration: number;
    naiveAvgDuration: number;
    totalTasks: number;
    uamSuccess: number;
    naiveSuccess: number;
    overallSpeedup: number;
    byDifficulty: Record<string, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }>;
    byCategory: Record<string, {
        count: number;
        uamSuccess: number;
        naiveSuccess: number;
    }>;
}>;
export type OverallBenchmarkStats = z.infer<typeof OverallBenchmarkStatsSchema>;
export declare const BenchmarkConfigSchema: z.ZodObject<{
    maxAttempts: z.ZodDefault<z.ZodNumber>;
    timeoutMs: z.ZodDefault<z.ZodNumber>;
    agents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    memoryEnabled: z.ZodDefault<z.ZodBoolean>;
    verbose: z.ZodDefault<z.ZodBoolean>;
    outputDir: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    agents: string[];
    verbose: boolean;
    maxAttempts: number;
    timeoutMs: number;
    memoryEnabled: boolean;
    outputDir: string;
}, {
    agents?: string[] | undefined;
    verbose?: boolean | undefined;
    maxAttempts?: number | undefined;
    timeoutMs?: number | undefined;
    memoryEnabled?: boolean | undefined;
    outputDir?: string | undefined;
}>;
export type BenchmarkConfig = z.infer<typeof BenchmarkConfigSchema>;
//# sourceMappingURL=benchmark.d.ts.map