npm - openpond-sdk - Versions diffs - 0.10.0 → 0.11.2 - Mend

openpond-sdk 0.10.0 → 0.11.2

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 (263) hide show

package/dist/types/packages/sdk/src/advanced-refiner-evaluations.d.ts ADDED Viewed

@@ -0,0 +1,2682 @@
+import { type EvaluationCoordinationAccess } from "./evaluation-coordination-http.js";
+import { z } from "zod";
+export declare const AdvancedRefinerEvaluationPinSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
+    operationId: z.ZodString;
+    actorId: z.ZodString;
+    teamId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        review_quality: "review_quality";
+        downstream_adaptation: "downstream_adaptation";
+    }>;
+    profileRef: z.ZodObject<{
+        source: z.ZodEnum<{
+            local: "local";
+            github: "github";
+            openpond_git: "openpond_git";
+        }>;
+        repositoryId: z.ZodString;
+        profileId: z.ZodString;
+    }, z.core.$strict>;
+    sourceRevision: z.ZodString;
+    baselineRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    refinerRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    externalDatasetBinding: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        packageHash: z.ZodString;
+        profileId: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"profile">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"workflow">;
+            workflowId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"skill">;
+            skillPath: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent_action">;
+            actionId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+        protectedProfileClosureHash: z.ZodString;
+        recordedOrigin: z.ZodOptional<z.ZodObject<{
+            execution: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            originalEvidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            members: z.ZodArray<z.ZodObject<{
+                caseId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodString;
+                sourceId: z.ZodString;
+                snapshotHash: z.ZodString;
+                boundaryRevisionHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        gradingSource: z.ZodOptional<z.ZodObject<{
+            pass: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        split: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        population: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            seed: z.ZodString;
+            fixtureId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        evaluators: z.ZodArray<z.ZodObject<{
+            release: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>;
+            feedbackKey: z.ZodString;
+            configurationHash: z.ZodString;
+            output: z.ZodEnum<{
+                boolean: "boolean";
+                score: "score";
+                category: "category";
+            }>;
+            categories: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        fieldMappingsHash: z.ZodString;
+        fieldMappings: z.ZodArray<z.ZodObject<{
+            graderId: z.ZodString;
+            fields: z.ZodArray<z.ZodObject<{
+                destination: z.ZodEnum<{
+                    output: "output";
+                    input: "input";
+                    expectedOutput: "expectedOutput";
+                    evaluatorContext: "evaluatorContext";
+                }>;
+                path: z.ZodArray<z.ZodString>;
+                source: z.ZodEnum<{
+                    output: "output";
+                    input: "input";
+                    expectedOutput: "expectedOutput";
+                    evaluatorContext: "evaluatorContext";
+                }>;
+                sourcePath: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        environmentHash: z.ZodString;
+        privateDatasetClosureHash: z.ZodString;
+        criterion: z.ZodObject<{
+            minimumPassRate: z.ZodNumber;
+            requireComplete: z.ZodBoolean;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    adaptationDatasetBinding: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        packageHash: z.ZodString;
+        profileId: z.ZodString;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"profile">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"workflow">;
+            workflowId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"skill">;
+            skillPath: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent_action">;
+            actionId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+        protectedProfileClosureHash: z.ZodString;
+        recordedOrigin: z.ZodOptional<z.ZodObject<{
+            execution: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            originalEvidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            members: z.ZodArray<z.ZodObject<{
+                caseId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodString;
+                sourceId: z.ZodString;
+                snapshotHash: z.ZodString;
+                boundaryRevisionHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        gradingSource: z.ZodOptional<z.ZodObject<{
+            pass: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        split: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        population: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            seed: z.ZodString;
+            fixtureId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        evaluators: z.ZodArray<z.ZodObject<{
+            release: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>;
+            feedbackKey: z.ZodString;
+            configurationHash: z.ZodString;
+            output: z.ZodEnum<{
+                boolean: "boolean";
+                score: "score";
+                category: "category";
+            }>;
+            categories: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        fieldMappingsHash: z.ZodString;
+        fieldMappings: z.ZodArray<z.ZodObject<{
+            graderId: z.ZodString;
+            fields: z.ZodArray<z.ZodObject<{
+                destination: z.ZodEnum<{
+                    output: "output";
+                    input: "input";
+                    expectedOutput: "expectedOutput";
+                    evaluatorContext: "evaluatorContext";
+                }>;
+                path: z.ZodArray<z.ZodString>;
+                source: z.ZodEnum<{
+                    output: "output";
+                    input: "input";
+                    expectedOutput: "expectedOutput";
+                    evaluatorContext: "evaluatorContext";
+                }>;
+                sourcePath: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        environmentHash: z.ZodString;
+        privateDatasetClosureHash: z.ZodString;
+        criterion: z.ZodObject<{
+            minimumPassRate: z.ZodNumber;
+            requireComplete: z.ZodBoolean;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    privateClosureHash: z.ZodString;
+    adaptationTaskIds: z.ZodArray<z.ZodString>;
+    holdoutTaskIds: z.ZodArray<z.ZodString>;
+    adaptationSplit: z.ZodEnum<{
+        train: "train";
+        validation: "validation";
+        test: "test";
+        frozen_eval: "frozen_eval";
+    }>;
+    holdoutSplit: z.ZodEnum<{
+        train: "train";
+        validation: "validation";
+        test: "test";
+        frozen_eval: "frozen_eval";
+    }>;
+    environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"resettable">;
+        environmentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"frozen_observations">;
+        environmentHash: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    maximumCostUsd: z.ZodNumber;
+    maximumDurationMs: z.ZodNumber;
+    maximumModelSteps: z.ZodNumber;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type AdvancedRefinerEvaluationPin = z.infer<typeof AdvancedRefinerEvaluationPinSchema>;
+export declare function verifyAdvancedRefinerEvaluationPin(raw: unknown): {
+    schemaVersion: "openpond.advancedRefinerEvaluation.v1";
+    operationId: string;
+    actorId: string;
+    teamId: string;
+    projectId: string | null;
+    mode: "review_quality" | "downstream_adaptation";
+    profileRef: {
+        source: "local" | "github" | "openpond_git";
+        repositoryId: string;
+        profileId: string;
+    };
+    sourceRevision: string;
+    baselineRelease: {
+        id: string;
+        contentHash: string;
+    };
+    refinerRelease: {
+        id: string;
+        contentHash: string;
+    };
+    evidence: {
+        id: string;
+        contentHash: string;
+    };
+    externalDatasetBinding: {
+        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        packageHash: string;
+        profileId: string;
+        target: {
+            kind: "profile";
+        } | {
+            kind: "workflow";
+            workflowId: string;
+        } | {
+            kind: "skill";
+            skillPath: string;
+        } | {
+            kind: "agent_action";
+            actionId: string;
+        };
+        declaredProfileCatalogHash: string | null;
+        protectedProfileClosureHash: string;
+        split: "train" | "validation" | "test" | "frozen_eval";
+        population: {
+            taskId: string;
+            seed: string;
+            fixtureId: string | null;
+        }[];
+        evaluators: {
+            release: {
+                id: string;
+                contentHash: string;
+                revision: string | number;
+            };
+            feedbackKey: string;
+            configurationHash: string;
+            output: "boolean" | "score" | "category";
+            categories: string[];
+        }[];
+        fieldMappingsHash: string;
+        fieldMappings: {
+            graderId: string;
+            fields: {
+                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                path: string[];
+                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                sourcePath: string[];
+            }[];
+        }[];
+        environmentHash: string;
+        privateDatasetClosureHash: string;
+        criterion: {
+            minimumPassRate: number;
+            requireComplete: boolean;
+        };
+        contentHash: string;
+        recordedOrigin?: {
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            originalEvidence: {
+                id: string;
+                contentHash: string;
+            };
+            members: {
+                caseId: string;
+                seed: string;
+                fixtureId: string;
+                sourceId: string;
+                snapshotHash: string;
+                boundaryRevisionHash: string;
+            }[];
+        } | undefined;
+        gradingSource?: {
+            pass: {
+                id: string;
+                contentHash: string;
+            };
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+        } | undefined;
+    };
+    adaptationDatasetBinding: {
+        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        packageHash: string;
+        profileId: string;
+        target: {
+            kind: "profile";
+        } | {
+            kind: "workflow";
+            workflowId: string;
+        } | {
+            kind: "skill";
+            skillPath: string;
+        } | {
+            kind: "agent_action";
+            actionId: string;
+        };
+        declaredProfileCatalogHash: string | null;
+        protectedProfileClosureHash: string;
+        split: "train" | "validation" | "test" | "frozen_eval";
+        population: {
+            taskId: string;
+            seed: string;
+            fixtureId: string | null;
+        }[];
+        evaluators: {
+            release: {
+                id: string;
+                contentHash: string;
+                revision: string | number;
+            };
+            feedbackKey: string;
+            configurationHash: string;
+            output: "boolean" | "score" | "category";
+            categories: string[];
+        }[];
+        fieldMappingsHash: string;
+        fieldMappings: {
+            graderId: string;
+            fields: {
+                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                path: string[];
+                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                sourcePath: string[];
+            }[];
+        }[];
+        environmentHash: string;
+        privateDatasetClosureHash: string;
+        criterion: {
+            minimumPassRate: number;
+            requireComplete: boolean;
+        };
+        contentHash: string;
+        recordedOrigin?: {
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            originalEvidence: {
+                id: string;
+                contentHash: string;
+            };
+            members: {
+                caseId: string;
+                seed: string;
+                fixtureId: string;
+                sourceId: string;
+                snapshotHash: string;
+                boundaryRevisionHash: string;
+            }[];
+        } | undefined;
+        gradingSource?: {
+            pass: {
+                id: string;
+                contentHash: string;
+            };
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+        } | undefined;
+    };
+    privateClosureHash: string;
+    adaptationTaskIds: string[];
+    holdoutTaskIds: string[];
+    adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+    holdoutSplit: "train" | "validation" | "test" | "frozen_eval";
+    environmentPolicy: {
+        kind: "resettable";
+        environmentHash: string;
+    } | {
+        kind: "frozen_observations";
+        environmentHash: string;
+    };
+    maximumCostUsd: number;
+    maximumDurationMs: number;
+    maximumModelSteps: number;
+    contentHash: string;
+};
+export declare function sealAdvancedRefinerEvaluationPin(body: Omit<AdvancedRefinerEvaluationPin, "contentHash">): {
+    schemaVersion: "openpond.advancedRefinerEvaluation.v1";
+    operationId: string;
+    actorId: string;
+    teamId: string;
+    projectId: string | null;
+    mode: "review_quality" | "downstream_adaptation";
+    profileRef: {
+        source: "local" | "github" | "openpond_git";
+        repositoryId: string;
+        profileId: string;
+    };
+    sourceRevision: string;
+    baselineRelease: {
+        id: string;
+        contentHash: string;
+    };
+    refinerRelease: {
+        id: string;
+        contentHash: string;
+    };
+    evidence: {
+        id: string;
+        contentHash: string;
+    };
+    externalDatasetBinding: {
+        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        packageHash: string;
+        profileId: string;
+        target: {
+            kind: "profile";
+        } | {
+            kind: "workflow";
+            workflowId: string;
+        } | {
+            kind: "skill";
+            skillPath: string;
+        } | {
+            kind: "agent_action";
+            actionId: string;
+        };
+        declaredProfileCatalogHash: string | null;
+        protectedProfileClosureHash: string;
+        split: "train" | "validation" | "test" | "frozen_eval";
+        population: {
+            taskId: string;
+            seed: string;
+            fixtureId: string | null;
+        }[];
+        evaluators: {
+            release: {
+                id: string;
+                contentHash: string;
+                revision: string | number;
+            };
+            feedbackKey: string;
+            configurationHash: string;
+            output: "boolean" | "score" | "category";
+            categories: string[];
+        }[];
+        fieldMappingsHash: string;
+        fieldMappings: {
+            graderId: string;
+            fields: {
+                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                path: string[];
+                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                sourcePath: string[];
+            }[];
+        }[];
+        environmentHash: string;
+        privateDatasetClosureHash: string;
+        criterion: {
+            minimumPassRate: number;
+            requireComplete: boolean;
+        };
+        contentHash: string;
+        recordedOrigin?: {
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            originalEvidence: {
+                id: string;
+                contentHash: string;
+            };
+            members: {
+                caseId: string;
+                seed: string;
+                fixtureId: string;
+                sourceId: string;
+                snapshotHash: string;
+                boundaryRevisionHash: string;
+            }[];
+        } | undefined;
+        gradingSource?: {
+            pass: {
+                id: string;
+                contentHash: string;
+            };
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+        } | undefined;
+    };
+    adaptationDatasetBinding: {
+        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        packageHash: string;
+        profileId: string;
+        target: {
+            kind: "profile";
+        } | {
+            kind: "workflow";
+            workflowId: string;
+        } | {
+            kind: "skill";
+            skillPath: string;
+        } | {
+            kind: "agent_action";
+            actionId: string;
+        };
+        declaredProfileCatalogHash: string | null;
+        protectedProfileClosureHash: string;
+        split: "train" | "validation" | "test" | "frozen_eval";
+        population: {
+            taskId: string;
+            seed: string;
+            fixtureId: string | null;
+        }[];
+        evaluators: {
+            release: {
+                id: string;
+                contentHash: string;
+                revision: string | number;
+            };
+            feedbackKey: string;
+            configurationHash: string;
+            output: "boolean" | "score" | "category";
+            categories: string[];
+        }[];
+        fieldMappingsHash: string;
+        fieldMappings: {
+            graderId: string;
+            fields: {
+                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                path: string[];
+                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                sourcePath: string[];
+            }[];
+        }[];
+        environmentHash: string;
+        privateDatasetClosureHash: string;
+        criterion: {
+            minimumPassRate: number;
+            requireComplete: boolean;
+        };
+        contentHash: string;
+        recordedOrigin?: {
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            originalEvidence: {
+                id: string;
+                contentHash: string;
+            };
+            members: {
+                caseId: string;
+                seed: string;
+                fixtureId: string;
+                sourceId: string;
+                snapshotHash: string;
+                boundaryRevisionHash: string;
+            }[];
+        } | undefined;
+        gradingSource?: {
+            pass: {
+                id: string;
+                contentHash: string;
+            };
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+        } | undefined;
+    };
+    privateClosureHash: string;
+    adaptationTaskIds: string[];
+    holdoutTaskIds: string[];
+    adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+    holdoutSplit: "train" | "validation" | "test" | "frozen_eval";
+    environmentPolicy: {
+        kind: "resettable";
+        environmentHash: string;
+    } | {
+        kind: "frozen_observations";
+        environmentHash: string;
+    };
+    maximumCostUsd: number;
+    maximumDurationMs: number;
+    maximumModelSteps: number;
+    contentHash: string;
+};
+export declare const AdvancedRefinerEvaluationStartSchema: z.ZodObject<{
+    pin: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
+        operationId: z.ZodString;
+        actorId: z.ZodString;
+        teamId: z.ZodString;
+        projectId: z.ZodNullable<z.ZodString>;
+        mode: z.ZodEnum<{
+            review_quality: "review_quality";
+            downstream_adaptation: "downstream_adaptation";
+        }>;
+        profileRef: z.ZodObject<{
+            source: z.ZodEnum<{
+                local: "local";
+                github: "github";
+                openpond_git: "openpond_git";
+            }>;
+            repositoryId: z.ZodString;
+            profileId: z.ZodString;
+        }, z.core.$strict>;
+        sourceRevision: z.ZodString;
+        baselineRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        refinerRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        externalDatasetBinding: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            packageHash: z.ZodString;
+            profileId: z.ZodString;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"workflow">;
+                workflowId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"skill">;
+                skillPath: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent_action">;
+                actionId: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+            protectedProfileClosureHash: z.ZodString;
+            recordedOrigin: z.ZodOptional<z.ZodObject<{
+                execution: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                originalEvidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                members: z.ZodArray<z.ZodObject<{
+                    caseId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodString;
+                    sourceId: z.ZodString;
+                    snapshotHash: z.ZodString;
+                    boundaryRevisionHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            gradingSource: z.ZodOptional<z.ZodObject<{
+                pass: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                evidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            population: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            evaluators: z.ZodArray<z.ZodObject<{
+                release: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>;
+                feedbackKey: z.ZodString;
+                configurationHash: z.ZodString;
+                output: z.ZodEnum<{
+                    boolean: "boolean";
+                    score: "score";
+                    category: "category";
+                }>;
+                categories: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            fieldMappingsHash: z.ZodString;
+            fieldMappings: z.ZodArray<z.ZodObject<{
+                graderId: z.ZodString;
+                fields: z.ZodArray<z.ZodObject<{
+                    destination: z.ZodEnum<{
+                        output: "output";
+                        input: "input";
+                        expectedOutput: "expectedOutput";
+                        evaluatorContext: "evaluatorContext";
+                    }>;
+                    path: z.ZodArray<z.ZodString>;
+                    source: z.ZodEnum<{
+                        output: "output";
+                        input: "input";
+                        expectedOutput: "expectedOutput";
+                        evaluatorContext: "evaluatorContext";
+                    }>;
+                    sourcePath: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            environmentHash: z.ZodString;
+            privateDatasetClosureHash: z.ZodString;
+            criterion: z.ZodObject<{
+                minimumPassRate: z.ZodNumber;
+                requireComplete: z.ZodBoolean;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        adaptationDatasetBinding: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            packageHash: z.ZodString;
+            profileId: z.ZodString;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"profile">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"workflow">;
+                workflowId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"skill">;
+                skillPath: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent_action">;
+                actionId: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+            protectedProfileClosureHash: z.ZodString;
+            recordedOrigin: z.ZodOptional<z.ZodObject<{
+                execution: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                originalEvidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                members: z.ZodArray<z.ZodObject<{
+                    caseId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodString;
+                    sourceId: z.ZodString;
+                    snapshotHash: z.ZodString;
+                    boundaryRevisionHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            gradingSource: z.ZodOptional<z.ZodObject<{
+                pass: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                evidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            population: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            evaluators: z.ZodArray<z.ZodObject<{
+                release: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>;
+                feedbackKey: z.ZodString;
+                configurationHash: z.ZodString;
+                output: z.ZodEnum<{
+                    boolean: "boolean";
+                    score: "score";
+                    category: "category";
+                }>;
+                categories: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            fieldMappingsHash: z.ZodString;
+            fieldMappings: z.ZodArray<z.ZodObject<{
+                graderId: z.ZodString;
+                fields: z.ZodArray<z.ZodObject<{
+                    destination: z.ZodEnum<{
+                        output: "output";
+                        input: "input";
+                        expectedOutput: "expectedOutput";
+                        evaluatorContext: "evaluatorContext";
+                    }>;
+                    path: z.ZodArray<z.ZodString>;
+                    source: z.ZodEnum<{
+                        output: "output";
+                        input: "input";
+                        expectedOutput: "expectedOutput";
+                        evaluatorContext: "evaluatorContext";
+                    }>;
+                    sourcePath: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            environmentHash: z.ZodString;
+            privateDatasetClosureHash: z.ZodString;
+            criterion: z.ZodObject<{
+                minimumPassRate: z.ZodNumber;
+                requireComplete: z.ZodBoolean;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        privateClosureHash: z.ZodString;
+        adaptationTaskIds: z.ZodArray<z.ZodString>;
+        holdoutTaskIds: z.ZodArray<z.ZodString>;
+        adaptationSplit: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        holdoutSplit: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>;
+        environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"resettable">;
+            environmentHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"frozen_observations">;
+            environmentHash: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        maximumCostUsd: z.ZodNumber;
+        maximumDurationMs: z.ZodNumber;
+        maximumModelSteps: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    modelId: z.ZodString;
+    profileId: z.ZodString;
+    model: z.ZodObject<{
+        providerId: z.ZodEnum<{
+            openpond: "openpond";
+            codex: "codex";
+            "claude-code": "claude-code";
+            "grok-build": "grok-build";
+            opencode: "opencode";
+            anthropic: "anthropic";
+            openai: "openai";
+            xai: "xai";
+            google: "google";
+            openrouter: "openrouter";
+            deepseek: "deepseek";
+            zai: "zai";
+            moonshot: "moonshot";
+            together: "together";
+            groq: "groq";
+            "custom-openai-compatible": "custom-openai-compatible";
+        }>;
+        modelId: z.ZodString;
+    }, z.core.$strip>;
+    seed: z.ZodNumber;
+    reasoningEffort: z.ZodNullable<z.ZodEnum<{
+        none: "none";
+        high: "high";
+        low: "low";
+        off: "off";
+        medium: "medium";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+}, z.core.$strict>;
+export declare const AdvancedRefinerEvaluationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"start">;
+    request: z.ZodObject<{
+        pin: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
+            operationId: z.ZodString;
+            actorId: z.ZodString;
+            teamId: z.ZodString;
+            projectId: z.ZodNullable<z.ZodString>;
+            mode: z.ZodEnum<{
+                review_quality: "review_quality";
+                downstream_adaptation: "downstream_adaptation";
+            }>;
+            profileRef: z.ZodObject<{
+                source: z.ZodEnum<{
+                    local: "local";
+                    github: "github";
+                    openpond_git: "openpond_git";
+                }>;
+                repositoryId: z.ZodString;
+                profileId: z.ZodString;
+            }, z.core.$strict>;
+            sourceRevision: z.ZodString;
+            baselineRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            refinerRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            externalDatasetBinding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            adaptationDatasetBinding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            privateClosureHash: z.ZodString;
+            adaptationTaskIds: z.ZodArray<z.ZodString>;
+            holdoutTaskIds: z.ZodArray<z.ZodString>;
+            adaptationSplit: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            holdoutSplit: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"resettable">;
+                environmentHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"frozen_observations">;
+                environmentHash: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            maximumCostUsd: z.ZodNumber;
+            maximumDurationMs: z.ZodNumber;
+            maximumModelSteps: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        modelId: z.ZodString;
+        profileId: z.ZodString;
+        model: z.ZodObject<{
+            providerId: z.ZodEnum<{
+                openpond: "openpond";
+                codex: "codex";
+                "claude-code": "claude-code";
+                "grok-build": "grok-build";
+                opencode: "opencode";
+                anthropic: "anthropic";
+                openai: "openai";
+                xai: "xai";
+                google: "google";
+                openrouter: "openrouter";
+                deepseek: "deepseek";
+                zai: "zai";
+                moonshot: "moonshot";
+                together: "together";
+                groq: "groq";
+                "custom-openai-compatible": "custom-openai-compatible";
+            }>;
+            modelId: z.ZodString;
+        }, z.core.$strip>;
+        seed: z.ZodNumber;
+        reasoningEffort: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            high: "high";
+            low: "low";
+            off: "off";
+            medium: "medium";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodEnum<{
+        read: "read";
+        resume: "resume";
+        cancel: "cancel";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"list">;
+}, z.core.$strict>], "operation">;
+export declare const AdvancedRefinerReviewCaseReceiptSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    sourceCaseHash: z.ZodString;
+    reviewSessionId: z.ZodString;
+    reviewTurnId: z.ZodString;
+    inputHarness: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    trigger: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    decision: z.ZodEnum<{
+        no_action: "no_action";
+        route_deterministically: "route_deterministically";
+        queue_refiner: "queue_refiner";
+    }>;
+    outcome: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    proposal: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    validations: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    grade: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        passed: z.ZodBoolean;
+        failureClass: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    resetComplete: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AdvancedRefinerReviewReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.advancedRefinerReviewReceipt.v1">;
+    id: z.ZodString;
+    runId: z.ZodString;
+    pinHash: z.ZodString;
+    ownerActorId: z.ZodString;
+    teamId: z.ZodString;
+    privateClosureHash: z.ZodString;
+    refinerRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    cases: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        sourceCaseHash: z.ZodString;
+        reviewSessionId: z.ZodString;
+        reviewTurnId: z.ZodString;
+        inputHarness: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        trigger: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        decision: z.ZodEnum<{
+            no_action: "no_action";
+            route_deterministically: "route_deterministically";
+            queue_refiner: "queue_refiner";
+        }>;
+        outcome: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        proposal: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        validations: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        grade: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            score: z.ZodNullable<z.ZodNumber>;
+            passed: z.ZodBoolean;
+            failureClass: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        resetComplete: z.ZodBoolean;
+    }, z.core.$strict>>;
+    reviewScore: z.ZodNullable<z.ZodNumber>;
+    completedCases: z.ZodNumber;
+    noActionCases: z.ZodNumber;
+    routedCases: z.ZodNumber;
+    proposalCases: z.ZodNumber;
+    costUsd: z.ZodNullable<z.ZodNumber>;
+    cleanupComplete: z.ZodBoolean;
+    createdAt: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type AdvancedRefinerReviewReceipt = z.infer<typeof AdvancedRefinerReviewReceiptSchema>;
+export declare function sealAdvancedRefinerReviewReceipt(body: Omit<AdvancedRefinerReviewReceipt, "contentHash">): {
+    schemaVersion: "openpond.advancedRefinerReviewReceipt.v1";
+    id: string;
+    runId: string;
+    pinHash: string;
+    ownerActorId: string;
+    teamId: string;
+    privateClosureHash: string;
+    refinerRelease: {
+        id: string;
+        contentHash: string;
+    };
+    cases: {
+        taskId: string;
+        sourceCaseHash: string;
+        reviewSessionId: string;
+        reviewTurnId: string;
+        inputHarness: {
+            id: string;
+            contentHash: string;
+        };
+        trigger: {
+            id: string;
+            contentHash: string;
+        };
+        decision: "no_action" | "route_deterministically" | "queue_refiner";
+        outcome: {
+            id: string;
+            contentHash: string;
+        } | null;
+        proposal: {
+            id: string;
+            contentHash: string;
+        } | null;
+        validations: {
+            id: string;
+            contentHash: string;
+        }[];
+        grade: {
+            id: string;
+            contentHash: string;
+            score: number | null;
+            passed: boolean;
+            failureClass: string | null;
+        };
+        resetComplete: boolean;
+    }[];
+    reviewScore: number | null;
+    completedCases: number;
+    noActionCases: number;
+    routedCases: number;
+    proposalCases: number;
+    costUsd: number | null;
+    cleanupComplete: boolean;
+    createdAt: string;
+    contentHash: string;
+};
+export declare const AdvancedRefinerEvaluationOptionsSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    scoring: z.ZodOptional<z.ZodObject<{
+        sourcePass: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        graders: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            graderId: z.ZodString;
+            fields: z.ZodArray<z.ZodObject<{
+                destination: z.ZodEnum<{
+                    input: "input";
+                    output: "output";
+                    expectedOutput: "expectedOutput";
+                    evaluatorContext: "evaluatorContext";
+                }>;
+                path: z.ZodArray<z.ZodString>;
+                source: z.ZodEnum<{
+                    input: "input";
+                    output: "output";
+                    expectedOutput: "expectedOutput";
+                    evaluatorContext: "evaluatorContext";
+                }>;
+                sourcePath: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        maximumCostUsd: z.ZodNumber;
+    }, z.core.$strict>>;
+    profiles: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        profileRef: z.ZodObject<{
+            source: z.ZodEnum<{
+                local: "local";
+                github: "github";
+                openpond_git: "openpond_git";
+            }>;
+            repositoryId: z.ZodString;
+            profileId: z.ZodString;
+        }, z.core.$strict>;
+        ownerWorkspaceId: z.ZodString;
+        ownerRevision: z.ZodNumber;
+        baseRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        profileSourceRevision: z.ZodString;
+        components: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                skill: "skill";
+                workflow: "workflow";
+                agent: "agent";
+                instruction: "instruction";
+            }>;
+            path: z.ZodString;
+            agentId: z.ZodOptional<z.ZodString>;
+            workflowId: z.ZodOptional<z.ZodString>;
+            label: z.ZodString;
+            binding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            adaptationSplits: z.ZodArray<z.ZodObject<{
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                taskIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            environmentHash: z.ZodString;
+            resettable: z.ZodBoolean;
+            reviewQuality: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    refinerReleases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    activeRefiner: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        profileId: z.ZodString;
+        name: z.ZodString;
+        location: z.ZodEnum<{
+            local: "local";
+            hosted: "hosted";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const AdvancedRefinerEvaluationPrepareSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"prepare">;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    profileOptionId: z.ZodString;
+    componentLabel: z.ZodString;
+    mode: z.ZodEnum<{
+        review_quality: "review_quality";
+        downstream_adaptation: "downstream_adaptation";
+    }>;
+    adaptationSplit: z.ZodEnum<{
+        train: "train";
+        validation: "validation";
+        test: "test";
+        frozen_eval: "frozen_eval";
+    }>;
+    operationId: z.ZodString;
+    refinerRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    maximumCostUsd: z.ZodNumber;
+    maximumDurationMs: z.ZodNumber;
+    maximumModelSteps: z.ZodNumber;
+}, z.core.$strict>;
+export declare const AdvancedRefinerEvaluationSetupCommandSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"start">;
+    request: z.ZodObject<{
+        pin: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.advancedRefinerEvaluation.v1">;
+            operationId: z.ZodString;
+            actorId: z.ZodString;
+            teamId: z.ZodString;
+            projectId: z.ZodNullable<z.ZodString>;
+            mode: z.ZodEnum<{
+                review_quality: "review_quality";
+                downstream_adaptation: "downstream_adaptation";
+            }>;
+            profileRef: z.ZodObject<{
+                source: z.ZodEnum<{
+                    local: "local";
+                    github: "github";
+                    openpond_git: "openpond_git";
+                }>;
+                repositoryId: z.ZodString;
+                profileId: z.ZodString;
+            }, z.core.$strict>;
+            sourceRevision: z.ZodString;
+            baselineRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            refinerRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            externalDatasetBinding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            adaptationDatasetBinding: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                dataset: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                packageHash: z.ZodString;
+                profileId: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                protectedProfileClosureHash: z.ZodString;
+                recordedOrigin: z.ZodOptional<z.ZodObject<{
+                    execution: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    originalEvidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    members: z.ZodArray<z.ZodObject<{
+                        caseId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodString;
+                        sourceId: z.ZodString;
+                        snapshotHash: z.ZodString;
+                        boundaryRevisionHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                gradingSource: z.ZodOptional<z.ZodObject<{
+                    pass: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+                population: z.ZodArray<z.ZodObject<{
+                    taskId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                evaluators: z.ZodArray<z.ZodObject<{
+                    release: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    feedbackKey: z.ZodString;
+                    configurationHash: z.ZodString;
+                    output: z.ZodEnum<{
+                        boolean: "boolean";
+                        score: "score";
+                        category: "category";
+                    }>;
+                    categories: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                fieldMappingsHash: z.ZodString;
+                fieldMappings: z.ZodArray<z.ZodObject<{
+                    graderId: z.ZodString;
+                    fields: z.ZodArray<z.ZodObject<{
+                        destination: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        path: z.ZodArray<z.ZodString>;
+                        source: z.ZodEnum<{
+                            output: "output";
+                            input: "input";
+                            expectedOutput: "expectedOutput";
+                            evaluatorContext: "evaluatorContext";
+                        }>;
+                        sourcePath: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                environmentHash: z.ZodString;
+                privateDatasetClosureHash: z.ZodString;
+                criterion: z.ZodObject<{
+                    minimumPassRate: z.ZodNumber;
+                    requireComplete: z.ZodBoolean;
+                }, z.core.$strict>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            privateClosureHash: z.ZodString;
+            adaptationTaskIds: z.ZodArray<z.ZodString>;
+            holdoutTaskIds: z.ZodArray<z.ZodString>;
+            adaptationSplit: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            holdoutSplit: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            environmentPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"resettable">;
+                environmentHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"frozen_observations">;
+                environmentHash: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            maximumCostUsd: z.ZodNumber;
+            maximumDurationMs: z.ZodNumber;
+            maximumModelSteps: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        modelId: z.ZodString;
+        profileId: z.ZodString;
+        model: z.ZodObject<{
+            providerId: z.ZodEnum<{
+                openpond: "openpond";
+                codex: "codex";
+                "claude-code": "claude-code";
+                "grok-build": "grok-build";
+                opencode: "opencode";
+                anthropic: "anthropic";
+                openai: "openai";
+                xai: "xai";
+                google: "google";
+                openrouter: "openrouter";
+                deepseek: "deepseek";
+                zai: "zai";
+                moonshot: "moonshot";
+                together: "together";
+                groq: "groq";
+                "custom-openai-compatible": "custom-openai-compatible";
+            }>;
+            modelId: z.ZodString;
+        }, z.core.$strip>;
+        seed: z.ZodNumber;
+        reasoningEffort: z.ZodNullable<z.ZodEnum<{
+            none: "none";
+            high: "high";
+            low: "low";
+            off: "off";
+            medium: "medium";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodEnum<{
+        read: "read";
+        resume: "resume";
+        cancel: "cancel";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"list">;
+}, z.core.$strict>], "operation">, z.ZodObject<{
+    operation: z.ZodLiteral<"prepare">;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    profileOptionId: z.ZodString;
+    componentLabel: z.ZodString;
+    mode: z.ZodEnum<{
+        review_quality: "review_quality";
+        downstream_adaptation: "downstream_adaptation";
+    }>;
+    adaptationSplit: z.ZodEnum<{
+        train: "train";
+        validation: "validation";
+        test: "test";
+        frozen_eval: "frozen_eval";
+    }>;
+    operationId: z.ZodString;
+    refinerRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    maximumCostUsd: z.ZodNumber;
+    maximumDurationMs: z.ZodNumber;
+    maximumModelSteps: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"options">;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type AdvancedRefinerEvaluationOptions = z.infer<typeof AdvancedRefinerEvaluationOptionsSchema>;
+export declare const AdvancedRefinerEvaluationAccountingSchema: z.ZodObject<{
+    modelRequests: z.ZodNumber;
+    knownSpendUsd: z.ZodNumber;
+    totalSpendUsd: z.ZodNullable<z.ZodNumber>;
+    heldUsd: z.ZodNumber;
+    uncertainRequests: z.ZodNumber;
+}, z.core.$strict>;
+/** The owner's canonical ModelRun remains intact in readback. This boundary
+ * validates its retained advanced pin rather than manufacturing results. */
+export declare class OpenPondAdvancedRefinerEvaluationClient {
+    private readonly transport;
+    constructor(access: EvaluationCoordinationAccess);
+    command(raw: z.input<typeof AdvancedRefinerEvaluationSetupCommandSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        evidence: {
+            id: string;
+            contentHash: string;
+        };
+        profiles: {
+            id: string;
+            name: string;
+            profileRef: {
+                source: "local" | "github" | "openpond_git";
+                repositoryId: string;
+                profileId: string;
+            };
+            ownerWorkspaceId: string;
+            ownerRevision: number;
+            baseRelease: {
+                id: string;
+                contentHash: string;
+            };
+            profileSourceRevision: string;
+            components: {
+                kind: "skill" | "workflow" | "agent" | "instruction";
+                path: string;
+                label: string;
+                binding: {
+                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                    dataset: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    packageHash: string;
+                    profileId: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    declaredProfileCatalogHash: string | null;
+                    protectedProfileClosureHash: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    population: {
+                        taskId: string;
+                        seed: string;
+                        fixtureId: string | null;
+                    }[];
+                    evaluators: {
+                        release: {
+                            id: string;
+                            contentHash: string;
+                            revision: string | number;
+                        };
+                        feedbackKey: string;
+                        configurationHash: string;
+                        output: "boolean" | "score" | "category";
+                        categories: string[];
+                    }[];
+                    fieldMappingsHash: string;
+                    fieldMappings: {
+                        graderId: string;
+                        fields: {
+                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            path: string[];
+                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            sourcePath: string[];
+                        }[];
+                    }[];
+                    environmentHash: string;
+                    privateDatasetClosureHash: string;
+                    criterion: {
+                        minimumPassRate: number;
+                        requireComplete: boolean;
+                    };
+                    contentHash: string;
+                    recordedOrigin?: {
+                        execution: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        originalEvidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        members: {
+                            caseId: string;
+                            seed: string;
+                            fixtureId: string;
+                            sourceId: string;
+                            snapshotHash: string;
+                            boundaryRevisionHash: string;
+                        }[];
+                    } | undefined;
+                    gradingSource?: {
+                        pass: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        evidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                    } | undefined;
+                };
+                adaptationSplits: {
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    taskIds: string[];
+                }[];
+                environmentHash: string;
+                resettable: boolean;
+                reviewQuality: boolean;
+                agentId?: string | undefined;
+                workflowId?: string | undefined;
+            }[];
+        }[];
+        refinerReleases: {
+            id: string;
+            contentHash: string;
+        }[];
+        activeRefiner: {
+            id: string;
+            contentHash: string;
+        } | null;
+        models: {
+            id: string;
+            profileId: string;
+            name: string;
+            location: "local" | "hosted";
+        }[];
+        scoring?: {
+            sourcePass: {
+                id: string;
+                contentHash: string;
+            };
+            graders: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            }[];
+            maximumCostUsd: number;
+            mappings?: {
+                graderId: string;
+                fields: {
+                    destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                    path: string[];
+                    source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                    sourcePath: string[];
+                }[];
+            }[] | undefined;
+        } | undefined;
+    } | {
+        items: {
+            id: string;
+            status: "succeeded" | "cancelled" | "failed" | "running" | "prepared";
+            mode: "review_quality" | "downstream_adaptation";
+            startedAt: string | null;
+            completedAt: string | null;
+            failure: string | null;
+        }[];
+    } | {
+        id: string;
+        status: "succeeded" | "cancelled" | "failed" | "running" | "prepared";
+    } | {
+        [x: string]: unknown;
+        schemaVersion: "openpond.modelRun.v1";
+        id: string;
+        kind: "evaluation";
+        modelId: string;
+        profileId: string;
+        evaluation: {
+            [x: string]: unknown;
+            benchmarkId: "harness-refiner";
+            advancedEvaluation: {
+                schemaVersion: "openpond.advancedRefinerEvaluation.v1";
+                operationId: string;
+                actorId: string;
+                teamId: string;
+                projectId: string | null;
+                mode: "review_quality" | "downstream_adaptation";
+                profileRef: {
+                    source: "local" | "github" | "openpond_git";
+                    repositoryId: string;
+                    profileId: string;
+                };
+                sourceRevision: string;
+                baselineRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                refinerRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                evidence: {
+                    id: string;
+                    contentHash: string;
+                };
+                externalDatasetBinding: {
+                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                    dataset: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    packageHash: string;
+                    profileId: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    declaredProfileCatalogHash: string | null;
+                    protectedProfileClosureHash: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    population: {
+                        taskId: string;
+                        seed: string;
+                        fixtureId: string | null;
+                    }[];
+                    evaluators: {
+                        release: {
+                            id: string;
+                            contentHash: string;
+                            revision: string | number;
+                        };
+                        feedbackKey: string;
+                        configurationHash: string;
+                        output: "boolean" | "score" | "category";
+                        categories: string[];
+                    }[];
+                    fieldMappingsHash: string;
+                    fieldMappings: {
+                        graderId: string;
+                        fields: {
+                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            path: string[];
+                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            sourcePath: string[];
+                        }[];
+                    }[];
+                    environmentHash: string;
+                    privateDatasetClosureHash: string;
+                    criterion: {
+                        minimumPassRate: number;
+                        requireComplete: boolean;
+                    };
+                    contentHash: string;
+                    recordedOrigin?: {
+                        execution: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        originalEvidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        members: {
+                            caseId: string;
+                            seed: string;
+                            fixtureId: string;
+                            sourceId: string;
+                            snapshotHash: string;
+                            boundaryRevisionHash: string;
+                        }[];
+                    } | undefined;
+                    gradingSource?: {
+                        pass: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        evidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                    } | undefined;
+                };
+                adaptationDatasetBinding: {
+                    schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                    dataset: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    packageHash: string;
+                    profileId: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    declaredProfileCatalogHash: string | null;
+                    protectedProfileClosureHash: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    population: {
+                        taskId: string;
+                        seed: string;
+                        fixtureId: string | null;
+                    }[];
+                    evaluators: {
+                        release: {
+                            id: string;
+                            contentHash: string;
+                            revision: string | number;
+                        };
+                        feedbackKey: string;
+                        configurationHash: string;
+                        output: "boolean" | "score" | "category";
+                        categories: string[];
+                    }[];
+                    fieldMappingsHash: string;
+                    fieldMappings: {
+                        graderId: string;
+                        fields: {
+                            destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            path: string[];
+                            source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                            sourcePath: string[];
+                        }[];
+                    }[];
+                    environmentHash: string;
+                    privateDatasetClosureHash: string;
+                    criterion: {
+                        minimumPassRate: number;
+                        requireComplete: boolean;
+                    };
+                    contentHash: string;
+                    recordedOrigin?: {
+                        execution: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        originalEvidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        members: {
+                            caseId: string;
+                            seed: string;
+                            fixtureId: string;
+                            sourceId: string;
+                            snapshotHash: string;
+                            boundaryRevisionHash: string;
+                        }[];
+                    } | undefined;
+                    gradingSource?: {
+                        pass: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        evidence: {
+                            id: string;
+                            contentHash: string;
+                        };
+                    } | undefined;
+                };
+                privateClosureHash: string;
+                adaptationTaskIds: string[];
+                holdoutTaskIds: string[];
+                adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+                holdoutSplit: "train" | "validation" | "test" | "frozen_eval";
+                environmentPolicy: {
+                    kind: "resettable";
+                    environmentHash: string;
+                } | {
+                    kind: "frozen_observations";
+                    environmentHash: string;
+                };
+                maximumCostUsd: number;
+                maximumDurationMs: number;
+                maximumModelSteps: number;
+                contentHash: string;
+            };
+        };
+    } | {
+        pin: {
+            schemaVersion: "openpond.advancedRefinerEvaluation.v1";
+            operationId: string;
+            actorId: string;
+            teamId: string;
+            projectId: string | null;
+            mode: "review_quality" | "downstream_adaptation";
+            profileRef: {
+                source: "local" | "github" | "openpond_git";
+                repositoryId: string;
+                profileId: string;
+            };
+            sourceRevision: string;
+            baselineRelease: {
+                id: string;
+                contentHash: string;
+            };
+            refinerRelease: {
+                id: string;
+                contentHash: string;
+            };
+            evidence: {
+                id: string;
+                contentHash: string;
+            };
+            externalDatasetBinding: {
+                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                packageHash: string;
+                profileId: string;
+                target: {
+                    kind: "profile";
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                } | {
+                    kind: "skill";
+                    skillPath: string;
+                } | {
+                    kind: "agent_action";
+                    actionId: string;
+                };
+                declaredProfileCatalogHash: string | null;
+                protectedProfileClosureHash: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                population: {
+                    taskId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                }[];
+                evaluators: {
+                    release: {
+                        id: string;
+                        contentHash: string;
+                        revision: string | number;
+                    };
+                    feedbackKey: string;
+                    configurationHash: string;
+                    output: "boolean" | "score" | "category";
+                    categories: string[];
+                }[];
+                fieldMappingsHash: string;
+                fieldMappings: {
+                    graderId: string;
+                    fields: {
+                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        path: string[];
+                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        sourcePath: string[];
+                    }[];
+                }[];
+                environmentHash: string;
+                privateDatasetClosureHash: string;
+                criterion: {
+                    minimumPassRate: number;
+                    requireComplete: boolean;
+                };
+                contentHash: string;
+                recordedOrigin?: {
+                    execution: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    originalEvidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    members: {
+                        caseId: string;
+                        seed: string;
+                        fixtureId: string;
+                        sourceId: string;
+                        snapshotHash: string;
+                        boundaryRevisionHash: string;
+                    }[];
+                } | undefined;
+                gradingSource?: {
+                    pass: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    evidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | undefined;
+            };
+            adaptationDatasetBinding: {
+                schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                dataset: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                packageHash: string;
+                profileId: string;
+                target: {
+                    kind: "profile";
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                } | {
+                    kind: "skill";
+                    skillPath: string;
+                } | {
+                    kind: "agent_action";
+                    actionId: string;
+                };
+                declaredProfileCatalogHash: string | null;
+                protectedProfileClosureHash: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                population: {
+                    taskId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                }[];
+                evaluators: {
+                    release: {
+                        id: string;
+                        contentHash: string;
+                        revision: string | number;
+                    };
+                    feedbackKey: string;
+                    configurationHash: string;
+                    output: "boolean" | "score" | "category";
+                    categories: string[];
+                }[];
+                fieldMappingsHash: string;
+                fieldMappings: {
+                    graderId: string;
+                    fields: {
+                        destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        path: string[];
+                        source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                        sourcePath: string[];
+                    }[];
+                }[];
+                environmentHash: string;
+                privateDatasetClosureHash: string;
+                criterion: {
+                    minimumPassRate: number;
+                    requireComplete: boolean;
+                };
+                contentHash: string;
+                recordedOrigin?: {
+                    execution: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    originalEvidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    members: {
+                        caseId: string;
+                        seed: string;
+                        fixtureId: string;
+                        sourceId: string;
+                        snapshotHash: string;
+                        boundaryRevisionHash: string;
+                    }[];
+                } | undefined;
+                gradingSource?: {
+                    pass: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    evidence: {
+                        id: string;
+                        contentHash: string;
+                    };
+                } | undefined;
+            };
+            privateClosureHash: string;
+            adaptationTaskIds: string[];
+            holdoutTaskIds: string[];
+            adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+            holdoutSplit: "train" | "validation" | "test" | "frozen_eval";
+            environmentPolicy: {
+                kind: "resettable";
+                environmentHash: string;
+            } | {
+                kind: "frozen_observations";
+                environmentHash: string;
+            };
+            maximumCostUsd: number;
+            maximumDurationMs: number;
+            maximumModelSteps: number;
+            contentHash: string;
+        };
+    }>;
+}
+//# sourceMappingURL=advanced-refiner-evaluations.d.ts.map