pulseed 0.5.4 → 0.6.0

package/dist/tools/kaggle/metrics.d.ts

@@ -1,6 +1,519 @@
 import { z } from "zod";
 export declare const KaggleMetricDirectionSchema: z.ZodEnum<["maximize", "minimize"]>;
 export type KaggleMetricDirection = z.infer<typeof KaggleMetricDirectionSchema>;
+export declare const KAGGLE_VALIDATION_CHECKLIST: readonly ["competition_metric_from_rules", "cv_split_strategy_declared", "oof_predictions_present_and_leak_checked", "target_encoding_and_stacking_are_oof_only", "seed_or_fold_stability_recorded", "train_test_drift_checked", "submission_portfolio_slot_declared", "final_report_separates_local_cv_public_lb_private_uncertainty"];
+export declare const KaggleValidationContractSchema: z.ZodObject<{
+    competition_metric: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        direction: z.ZodEnum<["maximize", "minimize"]>;
+        source: z.ZodDefault<z.ZodEnum<["competition_rules", "inferred", "manual"]>>;
+    }, "strict", z.ZodTypeAny, {
+        source: "manual" | "competition_rules" | "inferred";
+        name: string;
+        direction: "maximize" | "minimize";
+    }, {
+        name: string;
+        direction: "maximize" | "minimize";
+        source?: "manual" | "competition_rules" | "inferred" | undefined;
+    }>>;
+    cv: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodString;
+        fold_count: z.ZodOptional<z.ZodNumber>;
+        repeated_seed_count: z.ZodOptional<z.ZodNumber>;
+        stratified: z.ZodOptional<z.ZodBoolean>;
+        group_aware: z.ZodOptional<z.ZodBoolean>;
+        time_aware: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    }, {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    }>>;
+    oof: z.ZodOptional<z.ZodObject<{
+        present: z.ZodBoolean;
+        path: z.ZodOptional<z.ZodString>;
+        rows: z.ZodOptional<z.ZodNumber>;
+        coverage: z.ZodOptional<z.ZodNumber>;
+        leak_checked: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    }, {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    }>>;
+    leak_checks: z.ZodOptional<z.ZodObject<{
+        target_encoding_oof_only: z.ZodOptional<z.ZodBoolean>;
+        stacking_oof_only: z.ZodOptional<z.ZodBoolean>;
+        train_test_boundary_checked: z.ZodOptional<z.ZodBoolean>;
+        duplicate_or_id_leak_checked: z.ZodOptional<z.ZodBoolean>;
+        notes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        notes: string[];
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    }, {
+        notes?: string[] | undefined;
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    }>>;
+    stability: z.ZodOptional<z.ZodObject<{
+        repeated_seed_count: z.ZodOptional<z.ZodNumber>;
+        fold_score_min: z.ZodOptional<z.ZodNumber>;
+        fold_score_max: z.ZodOptional<z.ZodNumber>;
+        seed_score_std: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    }, {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    }>>;
+    train_test_drift: z.ZodOptional<z.ZodObject<{
+        checked: z.ZodBoolean;
+        adversarial_validation_auc: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    }, {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    }>>;
+    public_leaderboard: z.ZodOptional<z.ZodObject<{
+        score: z.ZodOptional<z.ZodNumber>;
+        submission_id: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    }, {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    stability?: {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    } | undefined;
+    competition_metric?: {
+        source: "manual" | "competition_rules" | "inferred";
+        name: string;
+        direction: "maximize" | "minimize";
+    } | undefined;
+    cv?: {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    } | undefined;
+    oof?: {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    } | undefined;
+    leak_checks?: {
+        notes: string[];
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    } | undefined;
+    train_test_drift?: {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    } | undefined;
+    public_leaderboard?: {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    } | undefined;
+}, {
+    stability?: {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    } | undefined;
+    competition_metric?: {
+        name: string;
+        direction: "maximize" | "minimize";
+        source?: "manual" | "competition_rules" | "inferred" | undefined;
+    } | undefined;
+    cv?: {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    } | undefined;
+    oof?: {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    } | undefined;
+    leak_checks?: {
+        notes?: string[] | undefined;
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    } | undefined;
+    train_test_drift?: {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    } | undefined;
+    public_leaderboard?: {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    } | undefined;
+}>;
+export type KaggleValidationContract = z.infer<typeof KaggleValidationContractSchema>;
+export declare const KaggleLongRunValidationContractSchema: z.ZodEffects<z.ZodObject<{
+    competition_metric: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        direction: z.ZodEnum<["maximize", "minimize"]>;
+        source: z.ZodDefault<z.ZodEnum<["competition_rules", "inferred", "manual"]>>;
+    }, "strict", z.ZodTypeAny, {
+        source: "manual" | "competition_rules" | "inferred";
+        name: string;
+        direction: "maximize" | "minimize";
+    }, {
+        name: string;
+        direction: "maximize" | "minimize";
+        source?: "manual" | "competition_rules" | "inferred" | undefined;
+    }>>;
+    cv: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodString;
+        fold_count: z.ZodOptional<z.ZodNumber>;
+        repeated_seed_count: z.ZodOptional<z.ZodNumber>;
+        stratified: z.ZodOptional<z.ZodBoolean>;
+        group_aware: z.ZodOptional<z.ZodBoolean>;
+        time_aware: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    }, {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    }>>;
+    oof: z.ZodOptional<z.ZodObject<{
+        present: z.ZodBoolean;
+        path: z.ZodOptional<z.ZodString>;
+        rows: z.ZodOptional<z.ZodNumber>;
+        coverage: z.ZodOptional<z.ZodNumber>;
+        leak_checked: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    }, {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    }>>;
+    leak_checks: z.ZodOptional<z.ZodObject<{
+        target_encoding_oof_only: z.ZodOptional<z.ZodBoolean>;
+        stacking_oof_only: z.ZodOptional<z.ZodBoolean>;
+        train_test_boundary_checked: z.ZodOptional<z.ZodBoolean>;
+        duplicate_or_id_leak_checked: z.ZodOptional<z.ZodBoolean>;
+        notes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        notes: string[];
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    }, {
+        notes?: string[] | undefined;
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    }>>;
+    stability: z.ZodOptional<z.ZodObject<{
+        repeated_seed_count: z.ZodOptional<z.ZodNumber>;
+        fold_score_min: z.ZodOptional<z.ZodNumber>;
+        fold_score_max: z.ZodOptional<z.ZodNumber>;
+        seed_score_std: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    }, {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    }>>;
+    train_test_drift: z.ZodOptional<z.ZodObject<{
+        checked: z.ZodBoolean;
+        adversarial_validation_auc: z.ZodOptional<z.ZodNumber>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    }, {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    }>>;
+    public_leaderboard: z.ZodOptional<z.ZodObject<{
+        score: z.ZodOptional<z.ZodNumber>;
+        submission_id: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    }, {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    stability?: {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    } | undefined;
+    competition_metric?: {
+        source: "manual" | "competition_rules" | "inferred";
+        name: string;
+        direction: "maximize" | "minimize";
+    } | undefined;
+    cv?: {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    } | undefined;
+    oof?: {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    } | undefined;
+    leak_checks?: {
+        notes: string[];
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    } | undefined;
+    train_test_drift?: {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    } | undefined;
+    public_leaderboard?: {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    } | undefined;
+}, {
+    stability?: {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    } | undefined;
+    competition_metric?: {
+        name: string;
+        direction: "maximize" | "minimize";
+        source?: "manual" | "competition_rules" | "inferred" | undefined;
+    } | undefined;
+    cv?: {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    } | undefined;
+    oof?: {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    } | undefined;
+    leak_checks?: {
+        notes?: string[] | undefined;
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    } | undefined;
+    train_test_drift?: {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    } | undefined;
+    public_leaderboard?: {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    } | undefined;
+}>, {
+    stability?: {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    } | undefined;
+    competition_metric?: {
+        source: "manual" | "competition_rules" | "inferred";
+        name: string;
+        direction: "maximize" | "minimize";
+    } | undefined;
+    cv?: {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    } | undefined;
+    oof?: {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    } | undefined;
+    leak_checks?: {
+        notes: string[];
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    } | undefined;
+    train_test_drift?: {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    } | undefined;
+    public_leaderboard?: {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    } | undefined;
+}, {
+    stability?: {
+        repeated_seed_count?: number | undefined;
+        fold_score_min?: number | undefined;
+        fold_score_max?: number | undefined;
+        seed_score_std?: number | undefined;
+    } | undefined;
+    competition_metric?: {
+        name: string;
+        direction: "maximize" | "minimize";
+        source?: "manual" | "competition_rules" | "inferred" | undefined;
+    } | undefined;
+    cv?: {
+        strategy: string;
+        fold_count?: number | undefined;
+        repeated_seed_count?: number | undefined;
+        stratified?: boolean | undefined;
+        group_aware?: boolean | undefined;
+        time_aware?: boolean | undefined;
+    } | undefined;
+    oof?: {
+        present: boolean;
+        path?: string | undefined;
+        coverage?: number | undefined;
+        rows?: number | undefined;
+        leak_checked?: boolean | undefined;
+    } | undefined;
+    leak_checks?: {
+        notes?: string[] | undefined;
+        target_encoding_oof_only?: boolean | undefined;
+        stacking_oof_only?: boolean | undefined;
+        train_test_boundary_checked?: boolean | undefined;
+        duplicate_or_id_leak_checked?: boolean | undefined;
+    } | undefined;
+    train_test_drift?: {
+        checked: boolean;
+        summary?: string | undefined;
+        adversarial_validation_auc?: number | undefined;
+    } | undefined;
+    public_leaderboard?: {
+        notes?: string | undefined;
+        score?: number | undefined;
+        observed_at?: string | undefined;
+        submission_id?: string | undefined;
+    } | undefined;
+}>;
+export type KaggleLongRunValidationContract = z.infer<typeof KaggleLongRunValidationContractSchema>;
 export declare const KaggleMetricsSchema: z.ZodObject<{
     experiment_id: z.ZodString;
     competition: z.ZodString;
@@ -27,47 +540,373 @@ export declare const KaggleMetricsSchema: z.ZodObject<{
         model?: string | undefined;
         submission?: string | undefined;
     }>;
+    validation: z.ZodOptional<z.ZodObject<{
+        competition_metric: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            direction: z.ZodEnum<["maximize", "minimize"]>;
+            source: z.ZodDefault<z.ZodEnum<["competition_rules", "inferred", "manual"]>>;
+        }, "strict", z.ZodTypeAny, {
+            source: "manual" | "competition_rules" | "inferred";
+            name: string;
+            direction: "maximize" | "minimize";
+        }, {
+            name: string;
+            direction: "maximize" | "minimize";
+            source?: "manual" | "competition_rules" | "inferred" | undefined;
+        }>>;
+        cv: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodString;
+            fold_count: z.ZodOptional<z.ZodNumber>;
+            repeated_seed_count: z.ZodOptional<z.ZodNumber>;
+            stratified: z.ZodOptional<z.ZodBoolean>;
+            group_aware: z.ZodOptional<z.ZodBoolean>;
+            time_aware: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            strategy: string;
+            fold_count?: number | undefined;
+            repeated_seed_count?: number | undefined;
+            stratified?: boolean | undefined;
+            group_aware?: boolean | undefined;
+            time_aware?: boolean | undefined;
+        }, {
+            strategy: string;
+            fold_count?: number | undefined;
+            repeated_seed_count?: number | undefined;
+            stratified?: boolean | undefined;
+            group_aware?: boolean | undefined;
+            time_aware?: boolean | undefined;
+        }>>;
+        oof: z.ZodOptional<z.ZodObject<{
+            present: z.ZodBoolean;
+            path: z.ZodOptional<z.ZodString>;
+            rows: z.ZodOptional<z.ZodNumber>;
+            coverage: z.ZodOptional<z.ZodNumber>;
+            leak_checked: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            present: boolean;
+            path?: string | undefined;
+            coverage?: number | undefined;
+            rows?: number | undefined;
+            leak_checked?: boolean | undefined;
+        }, {
+            present: boolean;
+            path?: string | undefined;
+            coverage?: number | undefined;
+            rows?: number | undefined;
+            leak_checked?: boolean | undefined;
+        }>>;
+        leak_checks: z.ZodOptional<z.ZodObject<{
+            target_encoding_oof_only: z.ZodOptional<z.ZodBoolean>;
+            stacking_oof_only: z.ZodOptional<z.ZodBoolean>;
+            train_test_boundary_checked: z.ZodOptional<z.ZodBoolean>;
+            duplicate_or_id_leak_checked: z.ZodOptional<z.ZodBoolean>;
+            notes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            notes: string[];
+            target_encoding_oof_only?: boolean | undefined;
+            stacking_oof_only?: boolean | undefined;
+            train_test_boundary_checked?: boolean | undefined;
+            duplicate_or_id_leak_checked?: boolean | undefined;
+        }, {
+            notes?: string[] | undefined;
+            target_encoding_oof_only?: boolean | undefined;
+            stacking_oof_only?: boolean | undefined;
+            train_test_boundary_checked?: boolean | undefined;
+            duplicate_or_id_leak_checked?: boolean | undefined;
+        }>>;
+        stability: z.ZodOptional<z.ZodObject<{
+            repeated_seed_count: z.ZodOptional<z.ZodNumber>;
+            fold_score_min: z.ZodOptional<z.ZodNumber>;
+            fold_score_max: z.ZodOptional<z.ZodNumber>;
+            seed_score_std: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            repeated_seed_count?: number | undefined;
+            fold_score_min?: number | undefined;
+            fold_score_max?: number | undefined;
+            seed_score_std?: number | undefined;
+        }, {
+            repeated_seed_count?: number | undefined;
+            fold_score_min?: number | undefined;
+            fold_score_max?: number | undefined;
+            seed_score_std?: number | undefined;
+        }>>;
+        train_test_drift: z.ZodOptional<z.ZodObject<{
+            checked: z.ZodBoolean;
+            adversarial_validation_auc: z.ZodOptional<z.ZodNumber>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            checked: boolean;
+            summary?: string | undefined;
+            adversarial_validation_auc?: number | undefined;
+        }, {
+            checked: boolean;
+            summary?: string | undefined;
+            adversarial_validation_auc?: number | undefined;
+        }>>;
+        public_leaderboard: z.ZodOptional<z.ZodObject<{
+            score: z.ZodOptional<z.ZodNumber>;
+            submission_id: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodOptional<z.ZodString>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            notes?: string | undefined;
+            score?: number | undefined;
+            observed_at?: string | undefined;
+            submission_id?: string | undefined;
+        }, {
+            notes?: string | undefined;
+            score?: number | undefined;
+            observed_at?: string | undefined;
+            submission_id?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        stability?: {
+            repeated_seed_count?: number | undefined;
+            fold_score_min?: number | undefined;
+            fold_score_max?: number | undefined;
+            seed_score_std?: number | undefined;
+        } | undefined;
+        competition_metric?: {
+            source: "manual" | "competition_rules" | "inferred";
+            name: string;
+            direction: "maximize" | "minimize";
+        } | undefined;
+        cv?: {
+            strategy: string;
+            fold_count?: number | undefined;
+            repeated_seed_count?: number | undefined;
+            stratified?: boolean | undefined;
+            group_aware?: boolean | undefined;
+            time_aware?: boolean | undefined;
+        } | undefined;
+        oof?: {
+            present: boolean;
+            path?: string | undefined;
+            coverage?: number | undefined;
+            rows?: number | undefined;
+            leak_checked?: boolean | undefined;
+        } | undefined;
+        leak_checks?: {
+            notes: string[];
+            target_encoding_oof_only?: boolean | undefined;
+            stacking_oof_only?: boolean | undefined;
+            train_test_boundary_checked?: boolean | undefined;
+            duplicate_or_id_leak_checked?: boolean | undefined;
+        } | undefined;
+        train_test_drift?: {
+            checked: boolean;
+            summary?: string | undefined;
+            adversarial_validation_auc?: number | undefined;
+        } | undefined;
+        public_leaderboard?: {
+            notes?: string | undefined;
+            score?: number | undefined;
+            observed_at?: string | undefined;
+            submission_id?: string | undefined;
+        } | undefined;
+    }, {
+        stability?: {
+            repeated_seed_count?: number | undefined;
+            fold_score_min?: number | undefined;
+            fold_score_max?: number | undefined;
+            seed_score_std?: number | undefined;
+        } | undefined;
+        competition_metric?: {
+            name: string;
+            direction: "maximize" | "minimize";
+            source?: "manual" | "competition_rules" | "inferred" | undefined;
+        } | undefined;
+        cv?: {
+            strategy: string;
+            fold_count?: number | undefined;
+            repeated_seed_count?: number | undefined;
+            stratified?: boolean | undefined;
+            group_aware?: boolean | undefined;
+            time_aware?: boolean | undefined;
+        } | undefined;
+        oof?: {
+            present: boolean;
+            path?: string | undefined;
+            coverage?: number | undefined;
+            rows?: number | undefined;
+            leak_checked?: boolean | undefined;
+        } | undefined;
+        leak_checks?: {
+            notes?: string[] | undefined;
+            target_encoding_oof_only?: boolean | undefined;
+            stacking_oof_only?: boolean | undefined;
+            train_test_boundary_checked?: boolean | undefined;
+            duplicate_or_id_leak_checked?: boolean | undefined;
+        } | undefined;
+        train_test_drift?: {
+            checked: boolean;
+            summary?: string | undefined;
+            adversarial_validation_auc?: number | undefined;
+        } | undefined;
+        public_leaderboard?: {
+            notes?: string | undefined;
+            score?: number | undefined;
+            observed_at?: string | undefined;
+            submission_id?: string | undefined;
+        } | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     status: "running" | "completed" | "failed";
     created_at: string;
     direction: "maximize" | "minimize";
+    metric_name: string;
     artifacts: {
         log: string;
         model?: string | undefined;
         submission?: string | undefined;
     };
     seed: number;
+    cv_score: number;
     experiment_id: string;
     competition: string;
-    metric_name: string;
-    cv_score: number;
     cv_std: number | null;
     holdout_score: number | null;
     train_rows: number;
     valid_rows: number;
+    validation?: {
+        stability?: {
+            repeated_seed_count?: number | undefined;
+            fold_score_min?: number | undefined;
+            fold_score_max?: number | undefined;
+            seed_score_std?: number | undefined;
+        } | undefined;
+        competition_metric?: {
+            source: "manual" | "competition_rules" | "inferred";
+            name: string;
+            direction: "maximize" | "minimize";
+        } | undefined;
+        cv?: {
+            strategy: string;
+            fold_count?: number | undefined;
+            repeated_seed_count?: number | undefined;
+            stratified?: boolean | undefined;
+            group_aware?: boolean | undefined;
+            time_aware?: boolean | undefined;
+        } | undefined;
+        oof?: {
+            present: boolean;
+            path?: string | undefined;
+            coverage?: number | undefined;
+            rows?: number | undefined;
+            leak_checked?: boolean | undefined;
+        } | undefined;
+        leak_checks?: {
+            notes: string[];
+            target_encoding_oof_only?: boolean | undefined;
+            stacking_oof_only?: boolean | undefined;
+            train_test_boundary_checked?: boolean | undefined;
+            duplicate_or_id_leak_checked?: boolean | undefined;
+        } | undefined;
+        train_test_drift?: {
+            checked: boolean;
+            summary?: string | undefined;
+            adversarial_validation_auc?: number | undefined;
+        } | undefined;
+        public_leaderboard?: {
+            notes?: string | undefined;
+            score?: number | undefined;
+            observed_at?: string | undefined;
+            submission_id?: string | undefined;
+        } | undefined;
+    } | undefined;
 }, {
     status: "running" | "completed" | "failed";
     created_at: string;
     direction: "maximize" | "minimize";
+    metric_name: string;
     artifacts: {
         log: string;
         model?: string | undefined;
         submission?: string | undefined;
     };
     seed: number;
+    cv_score: number;
     experiment_id: string;
     competition: string;
-    metric_name: string;
-    cv_score: number;
     cv_std: number | null;
     holdout_score: number | null;
     train_rows: number;
     valid_rows: number;
+    validation?: {
+        stability?: {
+            repeated_seed_count?: number | undefined;
+            fold_score_min?: number | undefined;
+            fold_score_max?: number | undefined;
+            seed_score_std?: number | undefined;
+        } | undefined;
+        competition_metric?: {
+            name: string;
+            direction: "maximize" | "minimize";
+            source?: "manual" | "competition_rules" | "inferred" | undefined;
+        } | undefined;
+        cv?: {
+            strategy: string;
+            fold_count?: number | undefined;
+            repeated_seed_count?: number | undefined;
+            stratified?: boolean | undefined;
+            group_aware?: boolean | undefined;
+            time_aware?: boolean | undefined;
+        } | undefined;
+        oof?: {
+            present: boolean;
+            path?: string | undefined;
+            coverage?: number | undefined;
+            rows?: number | undefined;
+            leak_checked?: boolean | undefined;
+        } | undefined;
+        leak_checks?: {
+            notes?: string[] | undefined;
+            target_encoding_oof_only?: boolean | undefined;
+            stacking_oof_only?: boolean | undefined;
+            train_test_boundary_checked?: boolean | undefined;
+            duplicate_or_id_leak_checked?: boolean | undefined;
+        } | undefined;
+        train_test_drift?: {
+            checked: boolean;
+            summary?: string | undefined;
+            adversarial_validation_auc?: number | undefined;
+        } | undefined;
+        public_leaderboard?: {
+            notes?: string | undefined;
+            score?: number | undefined;
+            observed_at?: string | undefined;
+            submission_id?: string | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 export type KaggleMetrics = z.infer<typeof KaggleMetricsSchema>;
+export interface KaggleValidationDiscipline {
+    oof_present: boolean;
+    oof_leak_checked: boolean;
+    cv_stability_available: boolean;
+    cv_std: number | null;
+    public_lb_score: number | null;
+    public_lb_gap: number | null;
+    drift_checked: boolean;
+    drift_risk: "unknown" | "low" | "high";
+    leak_risks: string[];
+    warnings: string[];
+    risk_level: "low" | "medium" | "high";
+    robust_penalty: number;
+}
+export interface KaggleMetricsCompatibilityFallback {
+    experiment_id?: string;
+    competition?: string;
+    created_at?: string;
+    log_path?: string;
+    submission_path?: string;
+    model_path?: string;
+}
 export type KaggleMetricParseResult = {
     ok: true;
     metrics: KaggleMetrics;
+    source_schema: "strict" | "loose";
+    warnings: string[];
 } | {
     ok: false;
     reason: "missing" | "malformed";
@@ -84,6 +923,8 @@ export interface MetricThresholdHint {
 }
 export declare function metricThresholdHintForDirection(metricName: string, direction: KaggleMetricDirection): MetricThresholdHint;
 export declare function parseKaggleMetrics(value: unknown): KaggleMetricParseResult;
+export declare function parseKaggleMetricsCompatible(value: unknown, fallback?: KaggleMetricsCompatibilityFallback): KaggleMetricParseResult;
 export declare function normalizedMetricScore(metrics: KaggleMetrics): number;
 export declare function compareMetricScores(a: KaggleMetrics, b: KaggleMetrics): number;
+export declare function summarizeKaggleValidation(metrics: KaggleMetrics): KaggleValidationDiscipline;
 //# sourceMappingURL=metrics.d.ts.map