mcp-context-engineering/dist/src/mongodb/models/effectivenessMetrics.d.ts

The intelligent context optimization system for AI coding assistants. Built with Cole's PRP methodology, Context Portal knowledge graphs, and production-ready MongoDB architecture.

import { ObjectId } from 'mongodb';
import { z } from 'zod';
export declare const EffectivenessMeasurementSchema: z.ZodObject<{
    measurement_id: z.ZodString;
    context_pattern_id: z.ZodString;
    agent_type: z.ZodEnum<["cursor", "windsurf", "claude_code", "generic"]>;
    implementation_result: z.ZodObject<{
        success: z.ZodBoolean;
        quality_score: z.ZodNumber;
        time_to_completion: z.ZodOptional<z.ZodNumber>;
        iterations_required: z.ZodNumber;
        user_satisfaction: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        success?: boolean;
        quality_score?: number;
        iterations_required?: number;
        user_satisfaction?: number;
        time_to_completion?: number;
    }, {
        success?: boolean;
        quality_score?: number;
        iterations_required?: number;
        user_satisfaction?: number;
        time_to_completion?: number;
    }>;
    context_effectiveness: z.ZodObject<{
        relevance_score: z.ZodNumber;
        completeness_score: z.ZodNumber;
        clarity_score: z.ZodNumber;
        actionability_score: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        completeness_score?: number;
        relevance_score?: number;
        clarity_score?: number;
        actionability_score?: number;
    }, {
        completeness_score?: number;
        relevance_score?: number;
        clarity_score?: number;
        actionability_score?: number;
    }>;
    feedback: z.ZodObject<{
        what_worked: z.ZodArray<z.ZodString, "many">;
        what_failed: z.ZodArray<z.ZodString, "many">;
        missing_information: z.ZodArray<z.ZodString, "many">;
        suggestions: z.ZodArray<z.ZodString, "many">;
        agent_specific_notes: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        what_worked?: string[];
        what_failed?: string[];
        missing_information?: string[];
        suggestions?: string[];
        agent_specific_notes?: string;
    }, {
        what_worked?: string[];
        what_failed?: string[];
        missing_information?: string[];
        suggestions?: string[];
        agent_specific_notes?: string;
    }>;
    context_metadata: z.ZodObject<{
        feature_type: z.ZodString;
        complexity: z.ZodEnum<["low", "medium", "high"]>;
        project_type: z.ZodString;
        tech_stack: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        complexity?: "low" | "medium" | "high";
        tech_stack?: string[];
        feature_type?: string;
        project_type?: string;
    }, {
        complexity?: "low" | "medium" | "high";
        tech_stack?: string[];
        feature_type?: string;
        project_type?: string;
    }>;
    timestamp: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    timestamp?: Date;
    feedback?: {
        what_worked?: string[];
        what_failed?: string[];
        missing_information?: string[];
        suggestions?: string[];
        agent_specific_notes?: string;
    };
    agent_type?: "cursor" | "windsurf" | "claude_code" | "generic";
    implementation_result?: {
        success?: boolean;
        quality_score?: number;
        iterations_required?: number;
        user_satisfaction?: number;
        time_to_completion?: number;
    };
    measurement_id?: string;
    context_pattern_id?: string;
    context_effectiveness?: {
        completeness_score?: number;
        relevance_score?: number;
        clarity_score?: number;
        actionability_score?: number;
    };
    context_metadata?: {
        complexity?: "low" | "medium" | "high";
        tech_stack?: string[];
        feature_type?: string;
        project_type?: string;
    };
}, {
    timestamp?: Date;
    feedback?: {
        what_worked?: string[];
        what_failed?: string[];
        missing_information?: string[];
        suggestions?: string[];
        agent_specific_notes?: string;
    };
    agent_type?: "cursor" | "windsurf" | "claude_code" | "generic";
    implementation_result?: {
        success?: boolean;
        quality_score?: number;
        iterations_required?: number;
        user_satisfaction?: number;
        time_to_completion?: number;
    };
    measurement_id?: string;
    context_pattern_id?: string;
    context_effectiveness?: {
        completeness_score?: number;
        relevance_score?: number;
        clarity_score?: number;
        actionability_score?: number;
    };
    context_metadata?: {
        complexity?: "low" | "medium" | "high";
        tech_stack?: string[];
        feature_type?: string;
        project_type?: string;
    };
}>;
export declare const EffectivenessAnalyticsSchema: z.ZodObject<{
    pattern_id: z.ZodString;
    overall: z.ZodObject<{
        total_usages: z.ZodNumber;
        success_rate: z.ZodNumber;
        average_quality_score: z.ZodNumber;
        average_relevance: z.ZodNumber;
        trend: z.ZodEnum<["improving", "stable", "declining"]>;
    }, "strip", z.ZodTypeAny, {
        total_usages?: number;
        success_rate?: number;
        average_quality_score?: number;
        average_relevance?: number;
        trend?: "improving" | "stable" | "declining";
    }, {
        total_usages?: number;
        success_rate?: number;
        average_quality_score?: number;
        average_relevance?: number;
        trend?: "improving" | "stable" | "declining";
    }>;
    by_agent: z.ZodRecord<z.ZodString, z.ZodObject<{
        usage_count: z.ZodNumber;
        success_rate: z.ZodNumber;
        average_quality_score: z.ZodNumber;
        preferred_formats: z.ZodArray<z.ZodString, "many">;
        common_issues: z.ZodArray<z.ZodString, "many">;
        optimization_suggestions: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        preferred_formats?: string[];
        common_issues?: string[];
        optimization_suggestions?: string[];
    }, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        preferred_formats?: string[];
        common_issues?: string[];
        optimization_suggestions?: string[];
    }>>;
    by_project_type: z.ZodRecord<z.ZodString, z.ZodObject<{
        usage_count: z.ZodNumber;
        success_rate: z.ZodNumber;
        average_quality_score: z.ZodNumber;
        specific_adaptations: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        specific_adaptations?: string[];
    }, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        specific_adaptations?: string[];
    }>>;
    by_complexity: z.ZodRecord<z.ZodString, z.ZodObject<{
        usage_count: z.ZodNumber;
        success_rate: z.ZodNumber;
        average_completion_time: z.ZodOptional<z.ZodNumber>;
        common_challenges: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        usage_count?: number;
        success_rate?: number;
        average_completion_time?: number;
        common_challenges?: string[];
    }, {
        usage_count?: number;
        success_rate?: number;
        average_completion_time?: number;
        common_challenges?: string[];
    }>>;
    insights: z.ZodObject<{
        top_success_factors: z.ZodArray<z.ZodString, "many">;
        common_failure_points: z.ZodArray<z.ZodString, "many">;
        optimization_opportunities: z.ZodArray<z.ZodString, "many">;
        cross_agent_learnings: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        top_success_factors?: string[];
        common_failure_points?: string[];
        optimization_opportunities?: string[];
        cross_agent_learnings?: string[];
    }, {
        top_success_factors?: string[];
        common_failure_points?: string[];
        optimization_opportunities?: string[];
        cross_agent_learnings?: string[];
    }>;
    last_updated: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    pattern_id?: string;
    last_updated?: Date;
    overall?: {
        total_usages?: number;
        success_rate?: number;
        average_quality_score?: number;
        average_relevance?: number;
        trend?: "improving" | "stable" | "declining";
    };
    by_agent?: Record<string, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        preferred_formats?: string[];
        common_issues?: string[];
        optimization_suggestions?: string[];
    }>;
    by_project_type?: Record<string, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        specific_adaptations?: string[];
    }>;
    by_complexity?: Record<string, {
        usage_count?: number;
        success_rate?: number;
        average_completion_time?: number;
        common_challenges?: string[];
    }>;
    insights?: {
        top_success_factors?: string[];
        common_failure_points?: string[];
        optimization_opportunities?: string[];
        cross_agent_learnings?: string[];
    };
}, {
    pattern_id?: string;
    last_updated?: Date;
    overall?: {
        total_usages?: number;
        success_rate?: number;
        average_quality_score?: number;
        average_relevance?: number;
        trend?: "improving" | "stable" | "declining";
    };
    by_agent?: Record<string, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        preferred_formats?: string[];
        common_issues?: string[];
        optimization_suggestions?: string[];
    }>;
    by_project_type?: Record<string, {
        usage_count?: number;
        success_rate?: number;
        average_quality_score?: number;
        specific_adaptations?: string[];
    }>;
    by_complexity?: Record<string, {
        usage_count?: number;
        success_rate?: number;
        average_completion_time?: number;
        common_challenges?: string[];
    }>;
    insights?: {
        top_success_factors?: string[];
        common_failure_points?: string[];
        optimization_opportunities?: string[];
        cross_agent_learnings?: string[];
    };
}>;
export declare const CrossAgentLearningSchema: z.ZodObject<{
    learning_id: z.ZodString;
    source: z.ZodObject<{
        agent_type: z.ZodString;
        pattern_id: z.ZodString;
        success_factor: z.ZodString;
        context: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        agent_type?: string;
        pattern_id?: string;
        success_factor?: string;
        context?: string;
    }, {
        agent_type?: string;
        pattern_id?: string;
        success_factor?: string;
        context?: string;
    }>;
    applicability: z.ZodObject<{
        tested_agents: z.ZodArray<z.ZodString, "many">;
        success_rates: z.ZodRecord<z.ZodString, z.ZodNumber>;
        adaptation_requirements: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
        limitations: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        tested_agents?: string[];
        success_rates?: Record<string, number>;
        adaptation_requirements?: Record<string, string[]>;
        limitations?: string[];
    }, {
        tested_agents?: string[];
        success_rates?: Record<string, number>;
        adaptation_requirements?: Record<string, string[]>;
        limitations?: string[];
    }>;
    implementation: z.ZodObject<{
        universal_principle: z.ZodString;
        agent_specific_adaptations: z.ZodRecord<z.ZodString, z.ZodString>;
        validation_criteria: z.ZodArray<z.ZodString, "many">;
        expected_impact: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        expected_impact?: number;
        universal_principle?: string;
        agent_specific_adaptations?: Record<string, string>;
        validation_criteria?: string[];
    }, {
        expected_impact?: number;
        universal_principle?: string;
        agent_specific_adaptations?: Record<string, string>;
        validation_criteria?: string[];
    }>;
    validation: z.ZodObject<{
        tested: z.ZodBoolean;
        validation_results: z.ZodArray<z.ZodObject<{
            agent_type: z.ZodString;
            before_score: z.ZodNumber;
            after_score: z.ZodNumber;
            improvement: z.ZodNumber;
            confirmed: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            agent_type?: string;
            before_score?: number;
            after_score?: number;
            improvement?: number;
            confirmed?: boolean;
        }, {
            agent_type?: string;
            before_score?: number;
            after_score?: number;
            improvement?: number;
            confirmed?: boolean;
        }>, "many">;
        deployment_ready: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        tested?: boolean;
        validation_results?: {
            agent_type?: string;
            before_score?: number;
            after_score?: number;
            improvement?: number;
            confirmed?: boolean;
        }[];
        deployment_ready?: boolean;
    }, {
        tested?: boolean;
        validation_results?: {
            agent_type?: string;
            before_score?: number;
            after_score?: number;
            improvement?: number;
            confirmed?: boolean;
        }[];
        deployment_ready?: boolean;
    }>;
    created_at: z.ZodDate;
    updated_at: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    validation?: {
        tested?: boolean;
        validation_results?: {
            agent_type?: string;
            before_score?: number;
            after_score?: number;
            improvement?: number;
            confirmed?: boolean;
        }[];
        deployment_ready?: boolean;
    };
    implementation?: {
        expected_impact?: number;
        universal_principle?: string;
        agent_specific_adaptations?: Record<string, string>;
        validation_criteria?: string[];
    };
    created_at?: Date;
    updated_at?: Date;
    learning_id?: string;
    source?: {
        agent_type?: string;
        pattern_id?: string;
        success_factor?: string;
        context?: string;
    };
    applicability?: {
        tested_agents?: string[];
        success_rates?: Record<string, number>;
        adaptation_requirements?: Record<string, string[]>;
        limitations?: string[];
    };
}, {
    validation?: {
        tested?: boolean;
        validation_results?: {
            agent_type?: string;
            before_score?: number;
            after_score?: number;
            improvement?: number;
            confirmed?: boolean;
        }[];
        deployment_ready?: boolean;
    };
    implementation?: {
        expected_impact?: number;
        universal_principle?: string;
        agent_specific_adaptations?: Record<string, string>;
        validation_criteria?: string[];
    };
    created_at?: Date;
    updated_at?: Date;
    learning_id?: string;
    source?: {
        agent_type?: string;
        pattern_id?: string;
        success_factor?: string;
        context?: string;
    };
    applicability?: {
        tested_agents?: string[];
        success_rates?: Record<string, number>;
        adaptation_requirements?: Record<string, string[]>;
        limitations?: string[];
    };
}>;
export declare const EffectivenessTrackingSchema: z.ZodObject<{
    _id: z.ZodOptional<z.ZodType<ObjectId, z.ZodTypeDef, ObjectId>>;
    measurements: z.ZodArray<z.ZodObject<{
        measurement_id: z.ZodString;
        context_pattern_id: z.ZodString;
        agent_type: z.ZodEnum<["cursor", "windsurf", "claude_code", "generic"]>;
        implementation_result: z.ZodObject<{
            success: z.ZodBoolean;
            quality_score: z.ZodNumber;
            time_to_completion: z.ZodOptional<z.ZodNumber>;
            iterations_required: z.ZodNumber;
            user_satisfaction: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            success?: boolean;
            quality_score?: number;
            iterations_required?: number;
            user_satisfaction?: number;
            time_to_completion?: number;
        }, {
            success?: boolean;
            quality_score?: number;
            iterations_required?: number;
            user_satisfaction?: number;
            time_to_completion?: number;
        }>;
        context_effectiveness: z.ZodObject<{
            relevance_score: z.ZodNumber;
            completeness_score: z.ZodNumber;
            clarity_score: z.ZodNumber;
            actionability_score: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            completeness_score?: number;
            relevance_score?: number;
            clarity_score?: number;
            actionability_score?: number;
        }, {
            completeness_score?: number;
            relevance_score?: number;
            clarity_score?: number;
            actionability_score?: number;
        }>;
        feedback: z.ZodObject<{
            what_worked: z.ZodArray<z.ZodString, "many">;
            what_failed: z.ZodArray<z.ZodString, "many">;
            missing_information: z.ZodArray<z.ZodString, "many">;
            suggestions: z.ZodArray<z.ZodString, "many">;
            agent_specific_notes: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            what_worked?: string[];
            what_failed?: string[];
            missing_information?: string[];
            suggestions?: string[];
            agent_specific_notes?: string;
        }, {
            what_worked?: string[];
            what_failed?: string[];
            missing_information?: string[];
            suggestions?: string[];
            agent_specific_notes?: string;
        }>;
        context_metadata: z.ZodObject<{
            feature_type: z.ZodString;
            complexity: z.ZodEnum<["low", "medium", "high"]>;
            project_type: z.ZodString;
            tech_stack: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            complexity?: "low" | "medium" | "high";
            tech_stack?: string[];
            feature_type?: string;
            project_type?: string;
        }, {
            complexity?: "low" | "medium" | "high";
            tech_stack?: string[];
            feature_type?: string;
            project_type?: string;
        }>;
        timestamp: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        timestamp?: Date;
        feedback?: {
            what_worked?: string[];
            what_failed?: string[];
            missing_information?: string[];
            suggestions?: string[];
            agent_specific_notes?: string;
        };
        agent_type?: "cursor" | "windsurf" | "claude_code" | "generic";
        implementation_result?: {
            success?: boolean;
            quality_score?: number;
            iterations_required?: number;
            user_satisfaction?: number;
            time_to_completion?: number;
        };
        measurement_id?: string;
        context_pattern_id?: string;
        context_effectiveness?: {
            completeness_score?: number;
            relevance_score?: number;
            clarity_score?: number;
            actionability_score?: number;
        };
        context_metadata?: {
            complexity?: "low" | "medium" | "high";
            tech_stack?: string[];
            feature_type?: string;
            project_type?: string;
        };
    }, {
        timestamp?: Date;
        feedback?: {
            what_worked?: string[];
            what_failed?: string[];
            missing_information?: string[];
            suggestions?: string[];
            agent_specific_notes?: string;
        };
        agent_type?: "cursor" | "windsurf" | "claude_code" | "generic";
        implementation_result?: {
            success?: boolean;
            quality_score?: number;
            iterations_required?: number;
            user_satisfaction?: number;
            time_to_completion?: number;
        };
        measurement_id?: string;
        context_pattern_id?: string;
        context_effectiveness?: {
            completeness_score?: number;
            relevance_score?: number;
            clarity_score?: number;
            actionability_score?: number;
        };
        context_metadata?: {
            complexity?: "low" | "medium" | "high";
            tech_stack?: string[];
            feature_type?: string;
            project_type?: string;
        };
    }>, "many">;
    analytics: z.ZodObject<{
        pattern_id: z.ZodString;
        overall: z.ZodObject<{
            total_usages: z.ZodNumber;
            success_rate: z.ZodNumber;
            average_quality_score: z.ZodNumber;
            average_relevance: z.ZodNumber;
            trend: z.ZodEnum<["improving", "stable", "declining"]>;
        }, "strip", z.ZodTypeAny, {
            total_usages?: number;
            success_rate?: number;
            average_quality_score?: number;
            average_relevance?: number;
            trend?: "improving" | "stable" | "declining";
        }, {
            total_usages?: number;
            success_rate?: number;
            average_quality_score?: number;
            average_relevance?: number;
            trend?: "improving" | "stable" | "declining";
        }>;
        by_agent: z.ZodRecord<z.ZodString, z.ZodObject<{
            usage_count: z.ZodNumber;
            success_rate: z.ZodNumber;
            average_quality_score: z.ZodNumber;
            preferred_formats: z.ZodArray<z.ZodString, "many">;
            common_issues: z.ZodArray<z.ZodString, "many">;
            optimization_suggestions: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            preferred_formats?: string[];
            common_issues?: string[];
            optimization_suggestions?: string[];
        }, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            preferred_formats?: string[];
            common_issues?: string[];
            optimization_suggestions?: string[];
        }>>;
        by_project_type: z.ZodRecord<z.ZodString, z.ZodObject<{
            usage_count: z.ZodNumber;
            success_rate: z.ZodNumber;
            average_quality_score: z.ZodNumber;
            specific_adaptations: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            specific_adaptations?: string[];
        }, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            specific_adaptations?: string[];
        }>>;
        by_complexity: z.ZodRecord<z.ZodString, z.ZodObject<{
            usage_count: z.ZodNumber;
            success_rate: z.ZodNumber;
            average_completion_time: z.ZodOptional<z.ZodNumber>;
            common_challenges: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            usage_count?: number;
            success_rate?: number;
            average_completion_time?: number;
            common_challenges?: string[];
        }, {
            usage_count?: number;
            success_rate?: number;
            average_completion_time?: number;
            common_challenges?: string[];
        }>>;
        insights: z.ZodObject<{
            top_success_factors: z.ZodArray<z.ZodString, "many">;
            common_failure_points: z.ZodArray<z.ZodString, "many">;
            optimization_opportunities: z.ZodArray<z.ZodString, "many">;
            cross_agent_learnings: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            top_success_factors?: string[];
            common_failure_points?: string[];
            optimization_opportunities?: string[];
            cross_agent_learnings?: string[];
        }, {
            top_success_factors?: string[];
            common_failure_points?: string[];
            optimization_opportunities?: string[];
            cross_agent_learnings?: string[];
        }>;
        last_updated: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        pattern_id?: string;
        last_updated?: Date;
        overall?: {
            total_usages?: number;
            success_rate?: number;
            average_quality_score?: number;
            average_relevance?: number;
            trend?: "improving" | "stable" | "declining";
        };
        by_agent?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            preferred_formats?: string[];
            common_issues?: string[];
            optimization_suggestions?: string[];
        }>;
        by_project_type?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            specific_adaptations?: string[];
        }>;
        by_complexity?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_completion_time?: number;
            common_challenges?: string[];
        }>;
        insights?: {
            top_success_factors?: string[];
            common_failure_points?: string[];
            optimization_opportunities?: string[];
            cross_agent_learnings?: string[];
        };
    }, {
        pattern_id?: string;
        last_updated?: Date;
        overall?: {
            total_usages?: number;
            success_rate?: number;
            average_quality_score?: number;
            average_relevance?: number;
            trend?: "improving" | "stable" | "declining";
        };
        by_agent?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            preferred_formats?: string[];
            common_issues?: string[];
            optimization_suggestions?: string[];
        }>;
        by_project_type?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            specific_adaptations?: string[];
        }>;
        by_complexity?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_completion_time?: number;
            common_challenges?: string[];
        }>;
        insights?: {
            top_success_factors?: string[];
            common_failure_points?: string[];
            optimization_opportunities?: string[];
            cross_agent_learnings?: string[];
        };
    }>;
    cross_agent_learning: z.ZodArray<z.ZodObject<{
        learning_id: z.ZodString;
        source: z.ZodObject<{
            agent_type: z.ZodString;
            pattern_id: z.ZodString;
            success_factor: z.ZodString;
            context: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            agent_type?: string;
            pattern_id?: string;
            success_factor?: string;
            context?: string;
        }, {
            agent_type?: string;
            pattern_id?: string;
            success_factor?: string;
            context?: string;
        }>;
        applicability: z.ZodObject<{
            tested_agents: z.ZodArray<z.ZodString, "many">;
            success_rates: z.ZodRecord<z.ZodString, z.ZodNumber>;
            adaptation_requirements: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
            limitations: z.ZodArray<z.ZodString, "many">;
        }, "strip", z.ZodTypeAny, {
            tested_agents?: string[];
            success_rates?: Record<string, number>;
            adaptation_requirements?: Record<string, string[]>;
            limitations?: string[];
        }, {
            tested_agents?: string[];
            success_rates?: Record<string, number>;
            adaptation_requirements?: Record<string, string[]>;
            limitations?: string[];
        }>;
        implementation: z.ZodObject<{
            universal_principle: z.ZodString;
            agent_specific_adaptations: z.ZodRecord<z.ZodString, z.ZodString>;
            validation_criteria: z.ZodArray<z.ZodString, "many">;
            expected_impact: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            expected_impact?: number;
            universal_principle?: string;
            agent_specific_adaptations?: Record<string, string>;
            validation_criteria?: string[];
        }, {
            expected_impact?: number;
            universal_principle?: string;
            agent_specific_adaptations?: Record<string, string>;
            validation_criteria?: string[];
        }>;
        validation: z.ZodObject<{
            tested: z.ZodBoolean;
            validation_results: z.ZodArray<z.ZodObject<{
                agent_type: z.ZodString;
                before_score: z.ZodNumber;
                after_score: z.ZodNumber;
                improvement: z.ZodNumber;
                confirmed: z.ZodBoolean;
            }, "strip", z.ZodTypeAny, {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }, {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }>, "many">;
            deployment_ready: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            tested?: boolean;
            validation_results?: {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }[];
            deployment_ready?: boolean;
        }, {
            tested?: boolean;
            validation_results?: {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }[];
            deployment_ready?: boolean;
        }>;
        created_at: z.ZodDate;
        updated_at: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        validation?: {
            tested?: boolean;
            validation_results?: {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }[];
            deployment_ready?: boolean;
        };
        implementation?: {
            expected_impact?: number;
            universal_principle?: string;
            agent_specific_adaptations?: Record<string, string>;
            validation_criteria?: string[];
        };
        created_at?: Date;
        updated_at?: Date;
        learning_id?: string;
        source?: {
            agent_type?: string;
            pattern_id?: string;
            success_factor?: string;
            context?: string;
        };
        applicability?: {
            tested_agents?: string[];
            success_rates?: Record<string, number>;
            adaptation_requirements?: Record<string, string[]>;
            limitations?: string[];
        };
    }, {
        validation?: {
            tested?: boolean;
            validation_results?: {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }[];
            deployment_ready?: boolean;
        };
        implementation?: {
            expected_impact?: number;
            universal_principle?: string;
            agent_specific_adaptations?: Record<string, string>;
            validation_criteria?: string[];
        };
        created_at?: Date;
        updated_at?: Date;
        learning_id?: string;
        source?: {
            agent_type?: string;
            pattern_id?: string;
            success_factor?: string;
            context?: string;
        };
        applicability?: {
            tested_agents?: string[];
            success_rates?: Record<string, number>;
            adaptation_requirements?: Record<string, string[]>;
            limitations?: string[];
        };
    }>, "many">;
    system_insights: z.ZodObject<{
        most_effective_patterns: z.ZodArray<z.ZodString, "many">;
        agent_strengths: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
        universal_success_factors: z.ZodArray<z.ZodString, "many">;
        improvement_priorities: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        most_effective_patterns?: string[];
        agent_strengths?: Record<string, string[]>;
        universal_success_factors?: string[];
        improvement_priorities?: string[];
    }, {
        most_effective_patterns?: string[];
        agent_strengths?: Record<string, string[]>;
        universal_success_factors?: string[];
        improvement_priorities?: string[];
    }>;
    metadata: z.ZodObject<{
        last_analysis: z.ZodDate;
        next_analysis_due: z.ZodDate;
        analysis_version: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        next_analysis_due?: Date;
        analysis_version?: number;
        last_analysis?: Date;
    }, {
        next_analysis_due?: Date;
        analysis_version?: number;
        last_analysis?: Date;
    }>;
}, "strip", z.ZodTypeAny, {
    _id?: ObjectId;
    metadata?: {
        next_analysis_due?: Date;
        analysis_version?: number;
        last_analysis?: Date;
    };
    analytics?: {
        pattern_id?: string;
        last_updated?: Date;
        overall?: {
            total_usages?: number;
            success_rate?: number;
            average_quality_score?: number;
            average_relevance?: number;
            trend?: "improving" | "stable" | "declining";
        };
        by_agent?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            preferred_formats?: string[];
            common_issues?: string[];
            optimization_suggestions?: string[];
        }>;
        by_project_type?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            specific_adaptations?: string[];
        }>;
        by_complexity?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_completion_time?: number;
            common_challenges?: string[];
        }>;
        insights?: {
            top_success_factors?: string[];
            common_failure_points?: string[];
            optimization_opportunities?: string[];
            cross_agent_learnings?: string[];
        };
    };
    measurements?: {
        timestamp?: Date;
        feedback?: {
            what_worked?: string[];
            what_failed?: string[];
            missing_information?: string[];
            suggestions?: string[];
            agent_specific_notes?: string;
        };
        agent_type?: "cursor" | "windsurf" | "claude_code" | "generic";
        implementation_result?: {
            success?: boolean;
            quality_score?: number;
            iterations_required?: number;
            user_satisfaction?: number;
            time_to_completion?: number;
        };
        measurement_id?: string;
        context_pattern_id?: string;
        context_effectiveness?: {
            completeness_score?: number;
            relevance_score?: number;
            clarity_score?: number;
            actionability_score?: number;
        };
        context_metadata?: {
            complexity?: "low" | "medium" | "high";
            tech_stack?: string[];
            feature_type?: string;
            project_type?: string;
        };
    }[];
    cross_agent_learning?: {
        validation?: {
            tested?: boolean;
            validation_results?: {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }[];
            deployment_ready?: boolean;
        };
        implementation?: {
            expected_impact?: number;
            universal_principle?: string;
            agent_specific_adaptations?: Record<string, string>;
            validation_criteria?: string[];
        };
        created_at?: Date;
        updated_at?: Date;
        learning_id?: string;
        source?: {
            agent_type?: string;
            pattern_id?: string;
            success_factor?: string;
            context?: string;
        };
        applicability?: {
            tested_agents?: string[];
            success_rates?: Record<string, number>;
            adaptation_requirements?: Record<string, string[]>;
            limitations?: string[];
        };
    }[];
    system_insights?: {
        most_effective_patterns?: string[];
        agent_strengths?: Record<string, string[]>;
        universal_success_factors?: string[];
        improvement_priorities?: string[];
    };
}, {
    _id?: ObjectId;
    metadata?: {
        next_analysis_due?: Date;
        analysis_version?: number;
        last_analysis?: Date;
    };
    analytics?: {
        pattern_id?: string;
        last_updated?: Date;
        overall?: {
            total_usages?: number;
            success_rate?: number;
            average_quality_score?: number;
            average_relevance?: number;
            trend?: "improving" | "stable" | "declining";
        };
        by_agent?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            preferred_formats?: string[];
            common_issues?: string[];
            optimization_suggestions?: string[];
        }>;
        by_project_type?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_quality_score?: number;
            specific_adaptations?: string[];
        }>;
        by_complexity?: Record<string, {
            usage_count?: number;
            success_rate?: number;
            average_completion_time?: number;
            common_challenges?: string[];
        }>;
        insights?: {
            top_success_factors?: string[];
            common_failure_points?: string[];
            optimization_opportunities?: string[];
            cross_agent_learnings?: string[];
        };
    };
    measurements?: {
        timestamp?: Date;
        feedback?: {
            what_worked?: string[];
            what_failed?: string[];
            missing_information?: string[];
            suggestions?: string[];
            agent_specific_notes?: string;
        };
        agent_type?: "cursor" | "windsurf" | "claude_code" | "generic";
        implementation_result?: {
            success?: boolean;
            quality_score?: number;
            iterations_required?: number;
            user_satisfaction?: number;
            time_to_completion?: number;
        };
        measurement_id?: string;
        context_pattern_id?: string;
        context_effectiveness?: {
            completeness_score?: number;
            relevance_score?: number;
            clarity_score?: number;
            actionability_score?: number;
        };
        context_metadata?: {
            complexity?: "low" | "medium" | "high";
            tech_stack?: string[];
            feature_type?: string;
            project_type?: string;
        };
    }[];
    cross_agent_learning?: {
        validation?: {
            tested?: boolean;
            validation_results?: {
                agent_type?: string;
                before_score?: number;
                after_score?: number;
                improvement?: number;
                confirmed?: boolean;
            }[];
            deployment_ready?: boolean;
        };
        implementation?: {
            expected_impact?: number;
            universal_principle?: string;
            agent_specific_adaptations?: Record<string, string>;
            validation_criteria?: string[];
        };
        created_at?: Date;
        updated_at?: Date;
        learning_id?: string;
        source?: {
            agent_type?: string;
            pattern_id?: string;
            success_factor?: string;
            context?: string;
        };
        applicability?: {
            tested_agents?: string[];
            success_rates?: Record<string, number>;
            adaptation_requirements?: Record<string, string[]>;
            limitations?: string[];
        };
    }[];
    system_insights?: {
        most_effective_patterns?: string[];
        agent_strengths?: Record<string, string[]>;
        universal_success_factors?: string[];
        improvement_priorities?: string[];
    };
}>;
export type EffectivenessMeasurement = z.infer<typeof EffectivenessMeasurementSchema>;
export type EffectivenessAnalytics = z.infer<typeof EffectivenessAnalyticsSchema>;
export type CrossAgentLearning = z.infer<typeof CrossAgentLearningSchema>;
export type EffectivenessTracking = z.infer<typeof EffectivenessTrackingSchema>;