npm - pulseed - Versions diffs - 0.5.3 → 0.6.0 - Mend

pulseed 0.5.3 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (910) hide show

package/dist/tools/kaggle/KaggleExperimentTools.d.ts CHANGED Viewed

@@ -12,12 +12,358 @@ export declare const KaggleExperimentStartInputSchema: z.ZodObject<{
     task_id: z.ZodOptional<z.ZodString>;
     expected_metrics_path: z.ZodOptional<z.ZodString>;
     artifact_refs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    validation_contract: 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;
+    }>;
 }, "strict", z.ZodTypeAny, {
     artifact_refs: string[];
     command: string;
     workspace: string;
     args: string[];
     competition: string;
+    validation_contract: {
+        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;
+    };
     strategy_id?: string | undefined;
     task_id?: string | undefined;
     env?: Record<string, string> | undefined;
@@ -27,6 +373,52 @@ export declare const KaggleExperimentStartInputSchema: z.ZodObject<{
     command: string;
     workspace: string;
     competition: string;
+    validation_contract: {
+        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;
+    };
     strategy_id?: string | undefined;
     task_id?: string | undefined;
     artifact_refs?: string[] | undefined;
@@ -95,8 +487,8 @@ export declare const KaggleExperimentStopInputSchema: z.ZodEffects<z.ZodObject<{
     signal: z.ZodDefault<z.ZodEnum<["SIGTERM", "SIGINT", "SIGHUP", "SIGKILL"]>>;
     waitMs: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
     workspace: string;
+    signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
     waitMs: number;
     competition: string;
     session_id?: string | undefined;
@@ -109,8 +501,8 @@ export declare const KaggleExperimentStopInputSchema: z.ZodEffects<z.ZodObject<{
     waitMs?: number | undefined;
     experiment_id?: string | undefined;
 }>, {
-    signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
     workspace: string;
+    signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
     waitMs: number;
     competition: string;
     session_id?: string | undefined;
@@ -164,13 +556,13 @@ export declare const KaggleCompareExperimentsInputSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     workspace: string;
     competition: string;
-    experiment_ids?: string[] | undefined;
     metric_direction?: "maximize" | "minimize" | undefined;
+    experiment_ids?: string[] | undefined;
 }, {
     workspace: string;
     competition: string;
-    experiment_ids?: string[] | undefined;
     metric_direction?: "maximize" | "minimize" | undefined;
+    experiment_ids?: string[] | undefined;
 }>;
 export type KaggleCompareExperimentsInput = z.infer<typeof KaggleCompareExperimentsInputSchema>;
 declare abstract class KaggleToolBase<TInput> implements ITool<TInput> {
@@ -196,12 +588,358 @@ export declare class KaggleExperimentStartTool extends KaggleToolBase<KaggleExpe
         task_id: z.ZodOptional<z.ZodString>;
         expected_metrics_path: z.ZodOptional<z.ZodString>;
         artifact_refs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        validation_contract: 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;
+        }>;
     }, "strict", z.ZodTypeAny, {
         artifact_refs: string[];
         command: string;
         workspace: string;
         args: string[];
         competition: string;
+        validation_contract: {
+            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;
+        };
         strategy_id?: string | undefined;
         task_id?: string | undefined;
         env?: Record<string, string> | undefined;
@@ -211,6 +949,52 @@ export declare class KaggleExperimentStartTool extends KaggleToolBase<KaggleExpe
         command: string;
         workspace: string;
         competition: string;
+        validation_contract: {
+            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;
+        };
         strategy_id?: string | undefined;
         task_id?: string | undefined;
         artifact_refs?: string[] | undefined;
@@ -297,8 +1081,8 @@ export declare class KaggleExperimentStopTool extends KaggleToolBase<KaggleExper
         signal: z.ZodDefault<z.ZodEnum<["SIGTERM", "SIGINT", "SIGHUP", "SIGKILL"]>>;
         waitMs: z.ZodDefault<z.ZodNumber>;
     }, "strict", z.ZodTypeAny, {
-        signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
         workspace: string;
+        signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
         waitMs: number;
         competition: string;
         session_id?: string | undefined;
@@ -311,8 +1095,8 @@ export declare class KaggleExperimentStopTool extends KaggleToolBase<KaggleExper
         waitMs?: number | undefined;
         experiment_id?: string | undefined;
     }>, {
-        signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
         workspace: string;
+        signal: "SIGHUP" | "SIGINT" | "SIGKILL" | "SIGTERM";
         waitMs: number;
         competition: string;
         session_id?: string | undefined;
@@ -378,13 +1162,13 @@ export declare class KaggleCompareExperimentsTool extends KaggleToolBase<KaggleC
     }, "strict", z.ZodTypeAny, {
         workspace: string;
         competition: string;
-        experiment_ids?: string[] | undefined;
         metric_direction?: "maximize" | "minimize" | undefined;
+        experiment_ids?: string[] | undefined;
     }, {
         workspace: string;
         competition: string;
-        experiment_ids?: string[] | undefined;
         metric_direction?: "maximize" | "minimize" | undefined;
+        experiment_ids?: string[] | undefined;
     }>;
     description(): string;
     call(input: KaggleCompareExperimentsInput, _context: ToolCallContext): Promise<ToolResult>;