openpond-sdk 0.3.3 → 0.4.0

package/dist/types/packages/sdk/src/taskset-package-projection.d.ts

@@ -0,0 +1,1514 @@
+import { type TasksetPackage } from "./taskset-package-contracts.js";
+/** Local identity includes Profile and provenance; portable identity stays in
+ * the receipt. Downloading does not approve targets, privacy or licensing. */
+export declare function prepareImportedTasksetPackage(input: {
+    package: TasksetPackage;
+    profileId: string;
+    name: string;
+    createdAt: string;
+}): {
+    package: {
+        schemaVersion: "openpond.tasksetPackage.v1";
+        taskset: {
+            schemaVersion: "openpond.tasksetRelease.v2";
+            id: string;
+            revision: number;
+            policy: {
+                policyVisibleFields: string[];
+                privilegedFields: string[];
+                hiddenGraderRefs: string[];
+                connectedAppScopes: string[];
+            };
+            environment: {
+                protocolVersion: "openpond.environment.v1";
+                kind: "text" | "work" | "agent" | "custom_program";
+                entrypoint: string;
+                stateful: boolean;
+                deterministicSeeds: boolean;
+                lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+                networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                defaultTimeoutMs: number;
+            };
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilities: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+            }[];
+            tasks: {
+                id: string;
+                clusterKey: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                input: Record<string, unknown>;
+                expectedOutput: Record<string, unknown> | null;
+                policyVisibleContext: Record<string, unknown>;
+                privilegedContextRef: string | null;
+                artifactRefs: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                }[];
+                tags: string[];
+                requiredOutputs?: {
+                    path: string;
+                    mediaType: string;
+                    schemaRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    } | null;
+                    maxBytes: number | null;
+                    metadata: Record<string, unknown>;
+                }[] | undefined;
+            }[];
+            graders: ({
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "state" | "content" | "schema" | "artifact" | "runtime_event";
+                config: Record<string, unknown>;
+            } | {
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "model_judge";
+                rubricRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                calibrationStatus: "failed" | "pending" | "passed";
+                model?: {
+                    providerId: string;
+                    modelId: string;
+                    revision: string | null;
+                } | undefined;
+                temperature?: number | undefined;
+            } | {
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "custom_verifier";
+                verifierRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                timeoutMs: number;
+                networkPolicy: "none";
+                exportName?: string | undefined;
+            } | {
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "human";
+                rubricRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                reviewerRole: string;
+            })[];
+            metadata: Record<string, unknown>;
+            contentHash: string;
+            environmentRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+            verifierSetRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+            metrics?: {
+                schemaVersion: "openpond.tasksetMetricPolicy.v1";
+                primaryMetric: string;
+                aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
+                missingReward: "zero" | "exclude";
+                customAggregator: {
+                    module: string;
+                    exportName: string;
+                    contentHash: string;
+                    timeoutMs: number;
+                    networkPolicy: "none";
+                } | null;
+                taskWeights?: Record<string, number> | undefined;
+            } | undefined;
+        };
+        environment: {
+            schemaVersion: "openpond.environmentRelease.v1";
+            id: string;
+            revision: number;
+            contract: {
+                protocolVersion: "openpond.environment.v1";
+                kind: "text" | "work" | "agent" | "custom_program";
+                entrypoint: string;
+                stateful: boolean;
+                deterministicSeeds: boolean;
+                lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+                networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                defaultTimeoutMs: number;
+            };
+            actionSchemaRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            } | null;
+            observationSchemaRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            } | null;
+            stateSchemaRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            } | null;
+            artifactCollection: {
+                maxArtifacts: number;
+                maxTotalBytes: number;
+            };
+            adapterConformanceHashes: Record<string, string>;
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        verifierSet: {
+            schemaVersion: "openpond.verifierSetRelease.v1";
+            id: string;
+            revision: number;
+            graders: ({
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "state" | "content" | "schema" | "artifact" | "runtime_event";
+                config: Record<string, unknown>;
+            } | {
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "model_judge";
+                rubricRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                calibrationStatus: "failed" | "pending" | "passed";
+                model?: {
+                    providerId: string;
+                    modelId: string;
+                    revision: string | null;
+                } | undefined;
+                temperature?: number | undefined;
+            } | {
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "custom_verifier";
+                verifierRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                timeoutMs: number;
+                networkPolicy: "none";
+                exportName?: string | undefined;
+            } | {
+                id: string;
+                version: string;
+                weight: number;
+                hardGate: boolean;
+                rewardEligible: boolean;
+                privileged: boolean;
+                kind: "human";
+                rubricRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                reviewerRole: string;
+            })[];
+            isolation: {
+                processBoundary: "same_process" | "isolated_process" | "container";
+                networkPolicy: "none";
+                defaultTimeoutMs: number;
+            };
+            calibrationReceiptRefs: {
+                id: string;
+                contentHash: string;
+            }[];
+            metadata: Record<string, unknown>;
+            contentHash: string;
+        };
+        files: {
+            asset: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            base64: string;
+        }[];
+        contentHash: string;
+        modelResources?: {
+            taskDefinition: {
+                schemaVersion: "openpond.taskDefinition.v1";
+                id: string;
+                revision: number;
+                name: string;
+                description: string;
+                instructions: string;
+                category: "custom" | "structured" | "question_answering" | "coding" | "tool_workflow";
+                familyNamespace: string;
+                inputSchema: Record<string, unknown>;
+                outputSchema: Record<string, unknown>;
+                rewardBinding: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                harness: {
+                    id: string;
+                    contentHash: string;
+                } | null;
+                execution: {
+                    policy: {
+                        policyVisibleFields: string[];
+                        privilegedFields: string[];
+                        hiddenGraderRefs: string[];
+                        connectedAppScopes: string[];
+                    };
+                    environment: {
+                        protocolVersion: "openpond.environment.v1";
+                        kind: "text" | "work" | "agent" | "custom_program";
+                        entrypoint: string;
+                        stateful: boolean;
+                        deterministicSeeds: boolean;
+                        lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+                        networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                        defaultTimeoutMs: number;
+                    };
+                    tools: {
+                        name: string;
+                        description: string;
+                        inputSchema: Record<string, unknown>;
+                        inputSchemaHash: string;
+                        sideEffect: "read" | "write";
+                        timeoutMs: number;
+                    }[];
+                    capabilities: {
+                        id: string;
+                        required: boolean;
+                        scopes: string[];
+                        portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+                    }[];
+                    environmentRelease?: {
+                        id: string;
+                        contentHash: string;
+                    } | undefined;
+                    verifierSetRelease?: {
+                        id: string;
+                        contentHash: string;
+                    } | undefined;
+                };
+                contentHash: string;
+            };
+            rewardBinding: {
+                schemaVersion: "openpond.rewardBinding.v1";
+                id: string;
+                revision: number;
+                sources: {
+                    graderId: string;
+                    reward: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    role: "evaluation" | "training";
+                    normalization: {
+                        kind: "identity";
+                    } | {
+                        kind: "linear";
+                        minimum: number;
+                        maximum: number;
+                        direction: "higher" | "lower";
+                    };
+                    weight: number;
+                    required: boolean;
+                    hardGate: boolean;
+                    privileged: boolean;
+                    fixtureRefs: {
+                        id: string;
+                        contentHash: string;
+                    }[];
+                }[];
+                aggregation: "weighted_mean";
+                unscorable: "exclude_optional_require_all_required";
+                contentHash: string;
+                name?: string | undefined;
+                description?: string | undefined;
+                recipeRef?: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | undefined;
+            };
+            assets: {
+                schemaVersion: "openpond.learningTextAsset.v1";
+                id: string;
+                revision: 1;
+                asset: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                text: string;
+                contentHash: string;
+            }[];
+            rewards: {
+                schemaVersion: "openpond.rewardRelease.v1";
+                id: string;
+                revision: number;
+                name: string;
+                description: string;
+                implementation: {
+                    kind: "state" | "content" | "schema" | "artifact" | "runtime_event";
+                    config: Record<string, unknown>;
+                } | {
+                    kind: "model_judge";
+                    rubricRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    calibrationStatus: "failed" | "pending" | "passed";
+                    model?: {
+                        providerId: string;
+                        modelId: string;
+                        revision: string | null;
+                    } | undefined;
+                    temperature?: number | undefined;
+                } | {
+                    timeoutMs: number;
+                    networkPolicy: "none";
+                    kind: "custom_verifier";
+                    verifierRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    exportName?: string | undefined;
+                } | {
+                    kind: "human";
+                    rubricRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    reviewerRole: string;
+                } | {
+                    kind: "learned_model";
+                    modelVersion: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    inputContract: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                };
+                rawScore: {
+                    minimum: number;
+                    maximum: number;
+                };
+                assets: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                }[];
+                contentHash: string;
+                fixtureSetRef?: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                } | undefined;
+            }[];
+            execution?: {
+                environment: {
+                    schemaVersion: "openpond.environmentRelease.v1";
+                    id: string;
+                    revision: number;
+                    contract: {
+                        protocolVersion: "openpond.environment.v1";
+                        kind: "text" | "work" | "agent" | "custom_program";
+                        entrypoint: string;
+                        stateful: boolean;
+                        deterministicSeeds: boolean;
+                        lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+                        networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                        defaultTimeoutMs: number;
+                    };
+                    actionSchemaRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    } | null;
+                    observationSchemaRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    } | null;
+                    stateSchemaRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    } | null;
+                    artifactCollection: {
+                        maxArtifacts: number;
+                        maxTotalBytes: number;
+                    };
+                    adapterConformanceHashes: Record<string, string>;
+                    metadata: Record<string, unknown>;
+                    contentHash: string;
+                };
+                verifierSet: {
+                    schemaVersion: "openpond.verifierSetRelease.v1";
+                    id: string;
+                    revision: number;
+                    graders: ({
+                        id: string;
+                        version: string;
+                        weight: number;
+                        hardGate: boolean;
+                        rewardEligible: boolean;
+                        privileged: boolean;
+                        kind: "state" | "content" | "schema" | "artifact" | "runtime_event";
+                        config: Record<string, unknown>;
+                    } | {
+                        id: string;
+                        version: string;
+                        weight: number;
+                        hardGate: boolean;
+                        rewardEligible: boolean;
+                        privileged: boolean;
+                        kind: "model_judge";
+                        rubricRef: {
+                            id: string;
+                            path: string;
+                            contentHash: string;
+                            sizeBytes: number;
+                            mediaType: string;
+                            visibility: "policy" | "verifier" | "host_private";
+                        };
+                        calibrationStatus: "failed" | "pending" | "passed";
+                        model?: {
+                            providerId: string;
+                            modelId: string;
+                            revision: string | null;
+                        } | undefined;
+                        temperature?: number | undefined;
+                    } | {
+                        id: string;
+                        version: string;
+                        weight: number;
+                        hardGate: boolean;
+                        rewardEligible: boolean;
+                        privileged: boolean;
+                        kind: "custom_verifier";
+                        verifierRef: {
+                            id: string;
+                            path: string;
+                            contentHash: string;
+                            sizeBytes: number;
+                            mediaType: string;
+                            visibility: "policy" | "verifier" | "host_private";
+                        };
+                        timeoutMs: number;
+                        networkPolicy: "none";
+                        exportName?: string | undefined;
+                    } | {
+                        id: string;
+                        version: string;
+                        weight: number;
+                        hardGate: boolean;
+                        rewardEligible: boolean;
+                        privileged: boolean;
+                        kind: "human";
+                        rubricRef: {
+                            id: string;
+                            path: string;
+                            contentHash: string;
+                            sizeBytes: number;
+                            mediaType: string;
+                            visibility: "policy" | "verifier" | "host_private";
+                        };
+                        reviewerRole: string;
+                    })[];
+                    isolation: {
+                        processBoundary: "same_process" | "isolated_process" | "container";
+                        networkPolicy: "none";
+                        defaultTimeoutMs: number;
+                    };
+                    calibrationReceiptRefs: {
+                        id: string;
+                        contentHash: string;
+                    }[];
+                    metadata: Record<string, unknown>;
+                    contentHash: string;
+                };
+                javascript: {
+                    schemaVersion: "openpond.javascriptEnvironment.v1";
+                    id: string;
+                    revision: number;
+                    module: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    };
+                    tools: {
+                        name: string;
+                        description: string;
+                        inputSchema: Record<string, unknown>;
+                        inputSchemaHash: string;
+                        sideEffect: "read" | "write";
+                        timeoutMs: number;
+                    }[];
+                    maxSteps: number;
+                    maxStateBytes: number;
+                    maxObservationBytes: number;
+                    operationTimeoutMs: number;
+                    contentHash: string;
+                    executionServices?: ({
+                        kind: "sqlite.v1";
+                        sql: {
+                            scope: "input" | "state" | "arguments" | "initialState";
+                            path: string[];
+                        };
+                        snapshot: {
+                            scope: "input" | "state" | "arguments" | "initialState";
+                            path: string[];
+                        };
+                        maxRows: number;
+                        maxResultBytes: number;
+                        id: string;
+                        operation: "step" | "collect";
+                        timeoutMs: number;
+                        toolName?: string | undefined;
+                    } | {
+                        kind: "javascript.v1";
+                        source: {
+                            scope: "input" | "state" | "arguments" | "initialState";
+                            path: string[];
+                        };
+                        cases: {
+                            scope: "input" | "state" | "arguments" | "initialState";
+                            path: string[];
+                        };
+                        exportName: string;
+                        maxCases: number;
+                        maxResultBytes: number;
+                        id: string;
+                        operation: "step" | "collect";
+                        timeoutMs: number;
+                        toolName?: string | undefined;
+                    })[] | undefined;
+                };
+            } | undefined;
+        } | undefined;
+        learningResources?: {
+            batch: {
+                schemaVersion: "openpond.taskBatch.v1";
+                id: string;
+                revision: 1;
+                taskDefinition: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                rewardBinding: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                purpose: "evaluation" | "supervised_training" | "reward_training";
+                examples: {
+                    evidence: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    decision: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    familyKey: string;
+                    inputHash: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                }[];
+                sealedAt: string;
+                sealedBy: string;
+                contentHash: string;
+            };
+            evidence: {
+                schemaVersion: "openpond.taskEvidence.v1";
+                id: string;
+                revision: number;
+                source: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                submission: {
+                    schemaVersion: "openpond.taskExample.v1";
+                    sourceId: string;
+                    idempotencyKey: string;
+                    taskDefinition: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    exampleId: string;
+                    attemptId: string;
+                    occurredAt: string;
+                    familyKey: string | null;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    input: Record<string, import("zod").JSONType>;
+                    observedOutput: Record<string, import("zod").JSONType> | null;
+                    expected: Record<string, import("zod").JSONType> | null;
+                    evaluatorContext: Record<string, import("zod").JSONType> | null;
+                    assets: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    }[];
+                    provenance: {
+                        sourceRecordRef: string | null;
+                        mappingHash: string | null;
+                    };
+                };
+                supersedes: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                correctionFeedbackId: string | null;
+                receivedAt: string;
+                contentHash: string;
+            }[];
+            decisions: {
+                schemaVersion: "openpond.taskAdmissionDecision.v1";
+                id: string;
+                revision: number;
+                evidence: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                supersedes: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                actor: {
+                    kind: "human" | "qualified_policy";
+                    id: string;
+                    policy: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    } | null;
+                };
+                evidenceValidity: "pending" | "valid" | "invalid";
+                taskAdmissibility: "pending" | "rejected" | "approved";
+                observedQuality: "failed" | "passed" | "unavailable" | "unscored";
+                targetApproval: "pending" | "rejected" | "approved" | "not_required";
+                approvedTarget: Record<string, import("zod").JSONType> | null;
+                grade: {
+                    schemaVersion: "openpond.rewardComposition.v1";
+                    binding: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    taskHash: string;
+                    outputHash: string;
+                    results: {
+                        graderId: string;
+                        reward: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        role: "evaluation" | "training";
+                        status: "failed" | "pending" | "unavailable" | "scored";
+                        rawScore: number | null;
+                        normalizedScore: number | null;
+                        passed: boolean | null;
+                        evidenceHashes: string[];
+                        message: string | null;
+                    }[];
+                    training: {
+                        status: "unscorable" | "scored" | "not_configured";
+                        score: number | null;
+                        passed: boolean | null;
+                    };
+                    evaluation: {
+                        status: "unscorable" | "scored" | "not_configured";
+                        score: number | null;
+                        passed: boolean | null;
+                    };
+                    contentHash: string;
+                } | null;
+                targetGrade: {
+                    schemaVersion: "openpond.rewardComposition.v1";
+                    binding: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    taskHash: string;
+                    outputHash: string;
+                    results: {
+                        graderId: string;
+                        reward: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        role: "evaluation" | "training";
+                        status: "failed" | "pending" | "unavailable" | "scored";
+                        rawScore: number | null;
+                        normalizedScore: number | null;
+                        passed: boolean | null;
+                        evidenceHashes: string[];
+                        message: string | null;
+                    }[];
+                    training: {
+                        status: "unscorable" | "scored" | "not_configured";
+                        score: number | null;
+                        passed: boolean | null;
+                    };
+                    evaluation: {
+                        status: "unscorable" | "scored" | "not_configured";
+                        score: number | null;
+                        passed: boolean | null;
+                    };
+                    contentHash: string;
+                } | null;
+                note: string;
+                decidedAt: string;
+                contentHash: string;
+            }[];
+            sources: {
+                schemaVersion: "openpond.learningSource.v1";
+                id: string;
+                revision: number;
+                name: string;
+                kind: "work" | "provider" | "direct" | "benchmark" | "opentelemetry";
+                taskDefinition: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                enabled: boolean;
+                allowedSplits: ("train" | "validation" | "test" | "frozen_eval")[];
+                mapping: {
+                    schemaVersion: "openpond.taskSourceMapping.v1";
+                    exampleId: string;
+                    attemptId: string;
+                    occurredAt: string;
+                    input: string;
+                    observedOutput: string | null;
+                    expected: string | null;
+                    evaluatorContext: string | null;
+                    familyKey: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                } | null;
+                adapterVersion: string | null;
+                contentHash: string;
+                reviewOrigin?: {
+                    modelId: string;
+                    packageHash: string;
+                    taskset: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    batch: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    rewardBinding: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                } | undefined;
+            }[];
+            assets: {
+                schemaVersion: "openpond.learningTextAsset.v1";
+                id: string;
+                revision: 1;
+                asset: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                };
+                text: string;
+                contentHash: string;
+            }[];
+        } | undefined;
+    };
+    taskset: {
+        schemaVersion: "openpond.taskset.v1";
+        id: string;
+        revision: number;
+        profileId: string;
+        createImproveRunId: string | null;
+        name: string;
+        objective: string;
+        purpose: "benchmark" | "general";
+        benchmark: {
+            schemaVersion: "openpond.tasksetBenchmark.v1";
+            definitionId: string;
+            releaseId: string;
+            releaseHash: string;
+            managedReleasePath: string;
+            adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+            evaluationSplit: "train" | "validation" | "test" | "frozen_eval";
+            primaryMetric: "foreground_tokens" | "success_rate" | "latency_ms" | "cost_usd";
+            qualityGate: "none" | "non_regression" | "all_pass";
+            source: "builtin" | "imported";
+            metadata: Record<string, unknown>;
+        } | null;
+        preferenceComparison: {
+            schemaVersion: "openpond.tasksetPreferenceComparisonBinding.v1";
+            releaseId: string;
+            releaseHash: string;
+            publishedAt: string;
+            metadata: Record<string, unknown>;
+        } | null;
+        status: "failed" | "archived" | "ready" | "draft" | "awaiting_disclosure_approval" | "awaiting_materialization_approval" | "materializing" | "validating" | "needs_review" | "baselining" | "blocked";
+        sourceRefs: ({
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.huggingFaceDatasetSource.v1";
+            kind: "huggingface";
+            repositoryId: string;
+            repositoryUrl: string;
+            revision: string;
+            configuration: string;
+            upstreamSplits: string[];
+            gated: boolean;
+            private: boolean;
+            declaredLicense: string | null;
+            sourceFileHashes: string[];
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.uploadedFileDatasetSource.v1";
+            kind: "uploaded_file";
+            originalFileNames: string[];
+            mediaTypes: string[];
+            sourceFileHashes: string[];
+            totalBytes: number;
+            parserVersion: string;
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.generatedDatasetSource.v1";
+            kind: "generated";
+            generatorId: string;
+            generatorVersion: string;
+            seed: number;
+            generatorHash: string;
+        } | {
+            id: string;
+            profileId: string;
+            title: string;
+            sourceHash: string;
+            occurredAt: string;
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            metadata: Record<string, unknown>;
+            schemaVersion: "openpond.learningBatchDatasetSource.v1";
+            kind: "learning_batch";
+            batch: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            taskDefinition: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            admittedBy: string;
+        } | {
+            schemaVersion: "openpond.trainingSource.v1";
+            id: string;
+            profileId: string;
+            sessionId: string;
+            turnIds: string[];
+            workspaceId: string | null;
+            sourceHash: string;
+            clusterKey: string;
+            title: string;
+            occurredAt: string;
+            consent: {
+                status: "pending" | "granted" | "denied" | "revoked";
+                scope: "metadata_only" | "selected_turns" | "full_session";
+                grantedBy: string | null;
+                grantedAt: string | null;
+                purpose: "task_authoring_and_evaluation";
+            };
+            connectedAppIds: string[];
+            secretScanStatus: "pending" | "passed" | "blocked";
+            piiScanStatus: "pending" | "review" | "passed" | "blocked";
+            licensingStatus: "pending" | "review" | "approved" | "blocked";
+            metadata: Record<string, unknown>;
+        })[];
+        policy: {
+            policyVisibleFields: string[];
+            privilegedFields: string[];
+            hiddenGraderRefs: string[];
+            connectedAppScopes: string[];
+        };
+        environment: {
+            protocolVersion: "openpond.taskEnvironment.v1";
+            kind: "work" | "agent" | "chat" | "program" | "stateful_harness";
+            entrypoint: string;
+            stateful: boolean;
+            deterministicSeeds: boolean;
+            toolNames: string[];
+            lifecycle: ("cleanup" | "create" | "grade" | "reset" | "step")[];
+            defaultTimeoutMs: number;
+            networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+            metadata: Record<string, unknown>;
+            actionBindings?: {
+                schemaVersion: "openpond.harnessActionBinding.v1";
+                actionId: string;
+                modelToolName: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                actionSchemaHash: string;
+                agentRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                implementationHash: string;
+                runtimeBindingId: string;
+                capabilityReceiptHash: string;
+                sideEffect: "read" | "write";
+                studentVisible: boolean;
+                timeoutMs: number;
+                episodeArgumentBindings: {
+                    argument: string;
+                    source: "case_id";
+                }[];
+            }[] | undefined;
+            resources?: {
+                id: string;
+                kind: "file" | "catalog" | "configuration" | "code_module";
+                path: string;
+                visibility: "privileged" | "policy_visible" | "policy_hidden";
+                required: boolean;
+                metadata: Record<string, unknown>;
+                mediaType?: string | null | undefined;
+            }[] | undefined;
+        };
+        capabilities: {
+            schemaVersion: "openpond.tasksetCapabilities.v1";
+            taskKind: "custom_program" | "chat" | "single_agent" | "multi_agent";
+            supportedSignals: ("label" | "reward" | "feedback" | "preference" | "demonstration" | "correction")[];
+            compatibleMethods: ("none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval")[];
+            rewardKinds: ("none" | "model_judge" | "human" | "deterministic" | "exact")[];
+            requiresTools: boolean;
+            requiresState: boolean;
+            requiresPrivilegedGrading: boolean;
+            environmentPlacements: ("local" | "remote" | "colocated" | "provider_native")[];
+            exportable: boolean;
+            portabilityBlockers: string[];
+        };
+        tasks: {
+            schemaVersion: "openpond.taskData.v1";
+            id: string;
+            clusterKey: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, unknown>;
+            expectedOutput: Record<string, unknown> | null;
+            policyVisibleContext: Record<string, unknown>;
+            privilegedContextRef: string | null;
+            sourceRefs: string[];
+            tags: string[];
+            metadata: Record<string, unknown>;
+            assets?: {
+                id: string;
+                sourceRefId: string;
+                artifactRef: string;
+                fileName: string;
+                mediaType: string;
+                sha256: string;
+                sizeBytes: number;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+            resourceRefs?: string[] | undefined;
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                metadata: Record<string, unknown>;
+                schemaRef?: string | null | undefined;
+                maxBytes?: number | undefined;
+            }[] | undefined;
+        }[];
+        graders: ({
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "file" | "state" | "test" | "content" | "schema" | "runtime_event" | "diff";
+            config: Record<string, unknown>;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "model_judge";
+            rubric: string;
+            judge: {
+                providerId: "openpond" | "codex" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq" | "custom-openai-compatible";
+                modelId: string;
+            };
+            calibrationFixtureRefs: string[];
+            calibrationStatus: "failed" | "pending" | "passed";
+            temperature: number;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "human";
+            rubric: string;
+            reviewerRole: string;
+        } | {
+            id: string;
+            version: string;
+            label: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            metadata: Record<string, unknown>;
+            kind: "custom_verifier";
+            module: string;
+            exportName: string;
+            timeoutMs: number;
+            networkPolicy: "none";
+        })[];
+        graderFixtures: {
+            id: string;
+            taskId: string;
+            label: "infrastructure_failure" | "positive" | "negative" | "boundary" | "adversarial" | "prompt_injection";
+            output: Record<string, unknown>;
+            infrastructureError: string | null;
+            expectedPassed: boolean;
+            expectedRewardEligible: boolean;
+            metadata: Record<string, unknown>;
+        }[];
+        learningSignals: {
+            demonstrations: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "demonstration";
+                prompt: string | null;
+                response: string | null;
+            }[];
+            preferences: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "preference";
+                prompt: string;
+                chosen: string;
+                rejected: string;
+                rationale: string | null;
+            }[];
+            corrections: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "correction";
+                original: string;
+                corrected: string;
+                rationale: string | null;
+            }[];
+            feedback: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "feedback";
+                feedback: string;
+                polarity: "neutral" | "positive" | "negative" | "mixed";
+            }[];
+            rewards: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "reward";
+                task: string;
+                rules: {
+                    id: string;
+                    points: number;
+                    condition: string;
+                }[];
+                otherwisePoints: number;
+                executable: boolean;
+            }[];
+            labels: {
+                id: string;
+                taskId: string | null;
+                sourceRefs: string[];
+                artifactRef: string;
+                approved: boolean;
+                confidence: number;
+                metadata: Record<string, unknown>;
+                kind: "label";
+                labelKind: "rubric";
+                task: string;
+                criteria: {
+                    id: string;
+                    label: string;
+                    description: string;
+                }[];
+                calibrationExamples: {
+                    positive: string;
+                    negative: string;
+                    boundary: string;
+                };
+            }[];
+        };
+        authoringProvenance: {
+            schemaVersion: "openpond.taskAuthoringProvenance.v1";
+            model: {
+                providerId: "openpond" | "codex" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq" | "custom-openai-compatible";
+                modelId: string;
+            } | null;
+            modelConfig: Record<string, unknown>;
+            skillHash: string;
+            promptTemplateVersion: string;
+            buildIntent: "rubric" | "demonstrations" | "preferences" | "verifiable_reward" | "discovery";
+            buildSpecification: {
+                kind: "demonstrations";
+                behavior: string;
+                examples: {
+                    id: string;
+                    prompt: string;
+                    response: string;
+                }[];
+            } | {
+                kind: "preferences";
+                preference: string;
+                pairs: {
+                    id: string;
+                    prompt: string;
+                    chosen: string;
+                    rejected: string;
+                    rationale: string;
+                }[];
+            } | {
+                kind: "verifiable_reward";
+                task: string;
+                rules: {
+                    id: string;
+                    points: number;
+                    condition: string;
+                }[];
+                otherwisePoints: number;
+            } | {
+                kind: "rubric";
+                task: string;
+                criteria: {
+                    id: string;
+                    label: string;
+                    description: string;
+                }[];
+                positiveExample: string;
+                negativeExample: string;
+                boundaryExample: string;
+            } | null;
+            evidenceHashes: string[];
+            tasksetSdkVersion: string;
+            sourceCommit: string | null;
+            repairHistory: {
+                attempt: number;
+                summary: string;
+                createdAt: string;
+            }[];
+            createdAt: string;
+        };
+        readiness: {
+            schemaVersion: "openpond.tasksetReadiness.v1";
+            tasksetId: string;
+            tasksetHash: string;
+            ready: boolean;
+            recommendedMethod: "none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval";
+            trainingPath: {
+                primaryMethod: "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opsd" | "sdpo";
+                bootstrap: {
+                    method: "sft";
+                    purpose: "trajectory_bootstrap";
+                    demonstrationRefs: string[];
+                    limitations: string[];
+                } | null;
+            } | null;
+            methodReadiness: {
+                method: "sft" | "dpo" | "grpo" | "ppo";
+                status: "recommended" | "compatible" | "needs_dataset_work";
+                reasonCodes: ("taskset_not_ready" | "demonstrations_missing" | "preference_pairs_missing" | "preference_pairs_invalid" | "executable_reward_missing" | "reward_not_calibrated" | "reward_model_missing" | "value_model_required" | "frozen_eval_missing")[];
+                reasons: string[];
+            }[];
+            compatibleDestinationClasses: ("custom" | "export" | "hosted_managed")[];
+            blockers: {
+                code: string;
+                message: string;
+                path: string | null;
+            }[];
+            advisories: {
+                code: string;
+                message: string;
+                path: string | null;
+            }[];
+            warnings: string[];
+            generatedAt: string;
+        } | null;
+        contentHash: string;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, unknown>;
+        profileRelease?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null | undefined;
+        datasetArtifact?: {
+            schemaVersion: "openpond.datasetArtifact.v1";
+            id: string;
+            tasksetId: string;
+            tasksetRevision: number;
+            contentHash: string;
+            format: "parquet";
+            schema: {
+                schemaVersion: "openpond.datasetSemanticSchema.v1";
+                fields: {
+                    name: string;
+                    semanticRole: "metadata" | "prompt" | "reward" | "feedback" | "rejected" | "messages" | "row_id" | "cluster_id" | "demonstration" | "chosen" | "expected_output" | "privileged_context" | "tag";
+                    logicalType: "string" | "boolean" | "messages" | "integer" | "float" | "json";
+                    nullable: boolean;
+                    policy: "metadata" | "privileged" | "visible";
+                }[];
+                schemaHash: string;
+            };
+            shards: {
+                id: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                path: string;
+                contentHash: string;
+                schemaHash: string;
+                sizeBytes: number;
+                rowCount: number;
+                rowGroupCount: number;
+            }[];
+            rowCount: number;
+            splitCounts: Record<"train" | "validation" | "test" | "frozen_eval", number>;
+            sourceReceiptRefs: string[];
+            mappingHash: string;
+            qualityReportHash: string;
+            createdAt: string;
+        } | null | undefined;
+        metrics?: {
+            schemaVersion: "openpond.tasksetMetricPolicy.v1";
+            primaryMetric: string;
+            aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
+            missingReward: "zero" | "exclude";
+            customAggregator: {
+                module: string;
+                exportName: string;
+                contentHash: string;
+                timeoutMs: number;
+                networkPolicy: "none";
+            } | null;
+            taskWeights?: Record<string, number> | undefined;
+        } | undefined;
+    };
+    generatedFiles: {
+        path: string;
+        role: "environment" | "verifier" | "fixture";
+        content: string;
+    }[];
+};
+export type PreparedImportedTasksetPackage = ReturnType<typeof prepareImportedTasksetPackage> & {
+    reuseExisting?: boolean;
+};
+/** Stable source identity; it is never an authorization or object-store pointer. */
+export declare function tasksetPackageSourceId(profileId: string, packageHash: string): string;
+//# sourceMappingURL=taskset-package-projection.d.ts.map