@openpond/evals 0.11.14 → 0.11.16

package/CONTRACT.md

@@ -176,6 +176,15 @@ comparison requires equal dataset version, population, evaluators and execution
 contract. Harness comparison also requires the same component, evaluation
 definition and environment; candidate source/Harness revisions can differ.
 
+Qualified shared executors may declare `execution.compatibility` with the same
+protocol and target kind. For those pairs, comparison matches the package and
+metric policy while retaining each exact `runtimeTargetHash` as placement
+evidence. A missing declaration keeps the original exact-runtime comparison.
+For Profile targets the identical package binds environment semantics, while
+`source.environmentHash` retains the placement-specific preparation evidence.
+The declaration must match the admitted target kind; it does not bypass dataset,
+population, evaluator, component or definition checks.
+
 `compareExperiments` aligns cases and reports per-feedback eligibility, exclusion
 reasons and paired means/deltas. Only matching completed cases with scored
 numeric or Boolean feedback contribute. Failed, cancelled, absent or ungraded

package/dist/experiments.js

@@ -2,6 +2,9 @@ import { z } from "zod";
 import { ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, assertContentHash, contentHash, } from "@openpond/harness";
 import { ProfileEvaluationRunSourceSchema } from "./profile-evaluations.js";
 import { FeedbackKeySchema } from "./rewards.js";
+import { StandaloneHarnessExperimentSourceSchema } from "./harness-experiment-source.js";
+export { StandaloneHarnessExperimentSourceSchema, STANDALONE_EXPERIMENT_MAX_POLICY_CALLS, STANDALONE_EXPERIMENT_READ_TOOLS, standaloneHarnessExperimentTools, harnessExperimentSourceRequiresProfile, harnessExperimentReadToolDeclarations, } from "./harness-experiment-source.js";
+export { NativeHarnessExperimentEvidenceSchema, NativeHarnessExperimentAttemptContentSchema, NativeHarnessExperimentAttemptSchema, createNativeHarnessExperimentAttempt, verifyNativeHarnessExperimentAttempt, } from "./native-harness-experiment-attempt.js";
 const MoneySchema = z.number().finite().nonnegative();
 export const ExperimentTargetSchema = z.discriminatedUnion("kind", [
     z.object({
@@ -14,6 +17,11 @@ export const ExperimentTargetSchema = z.discriminatedUnion("kind", [
         source: ProfileEvaluationRunSourceSchema,
         model: z.object({ modelId: ReleaseIdSchema, configurationHash: ReleaseHashSchema }).strict(),
     }).strict(),
+    z.object({
+        kind: z.literal("agent"),
+        source: StandaloneHarnessExperimentSourceSchema,
+        model: z.object({ modelId: ReleaseIdSchema, configurationHash: ReleaseHashSchema }).strict(),
+    }).strict(),
     z.object({ kind: z.literal("fixture"), configurationHash: ReleaseHashSchema }).strict(),
 ]);
 export const ExperimentEvaluatorSchema = z.object({
@@ -51,7 +59,17 @@ export const ExperimentManifestContentSchema = z.object({
     maximumCostUsd: MoneySchema.nullable(),
     dataset: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict(),
     target: ExperimentTargetSchema,
-    execution: z.object({ packageHash: ReleaseHashSchema, runtimeTargetHash: ReleaseHashSchema, metricPolicyHash: ReleaseHashSchema }).strict().optional(),
+    execution: z.object({
+        packageHash: ReleaseHashSchema,
+        /** Exact placement/adapter evidence; retained even across compatible locations. */
+        runtimeTargetHash: ReleaseHashSchema,
+        metricPolicyHash: ReleaseHashSchema,
+        /** Only qualified shared executors declare this placement-independent protocol. */
+        compatibility: z.object({
+            protocol: z.literal("openpond.evaluation-execution.v1"),
+            targetKind: z.enum(["model", "agent", "harness", "fixture"]),
+        }).strict().optional(),
+    }).strict().optional(),
     lineage: z.object({
         definition: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict().nullable(),
         execution: ImmutableReleaseRefSchema,
@@ -61,6 +79,8 @@ export const ExperimentManifestContentSchema = z.object({
     population: z.array(ExperimentCaseIdentitySchema).min(1).max(10_000),
     createdAt: ReleaseTimestampSchema,
 }).strict().superRefine((value, context) => {
+    if (value.execution?.compatibility && value.execution.compatibility.targetKind !== value.target.kind)
+        context.addIssue({ code: "custom", path: ["execution", "compatibility"], message: "Execution compatibility differs from its admitted target kind." });
     if (value.lineage && value.id !== (value.lineage.scoringPassId ?? value.lineage.execution.id))
         context.addIssue({ code: "custom", path: ["lineage"], message: "Experiment identity must match its execution or independent scoring pass." });
     if (new Set(value.population.map(experimentCaseKey)).size !== value.population.length)
@@ -172,14 +192,24 @@ export function compareExperiments(baseline, candidate) {
         reasons.push("different_dataset_version");
     if (baseline.manifest.target.kind !== candidate.manifest.target.kind)
         reasons.push("different_target_kind");
-    if (contentHash(baseline.manifest.execution ?? null) !== contentHash(candidate.manifest.execution ?? null))
+    const executionContract = (manifest) => {
+        const execution = manifest.execution;
+        if (!execution?.compatibility)
+            return execution ?? null;
+        const { runtimeTargetHash: _placementEvidence, ...semantic } = execution;
+        return semantic;
+    };
+    if (contentHash(executionContract(baseline.manifest)) !== contentHash(executionContract(candidate.manifest)))
         reasons.push("different_execution_contract");
     if (baseline.manifest.target.kind === "harness" && candidate.manifest.target.kind === "harness") {
         const a = baseline.manifest.target.source;
         const b = candidate.manifest.target.source;
         if (a.profileId !== b.profileId || contentHash(a.target) !== contentHash(b.target))
             reasons.push("different_component");
-        if (a.environmentHash !== b.environmentHash)
+        const sharedEnvironment = baseline.manifest.execution?.compatibility
+            && candidate.manifest.execution?.compatibility
+            && baseline.manifest.execution.packageHash === candidate.manifest.execution.packageHash;
+        if (a.environmentHash !== b.environmentHash && !sharedEnvironment)
             reasons.push("different_environment");
         if (a.definitionId !== b.definitionId || a.definitionHash !== b.definitionHash)
             reasons.push("different_evaluation_definition");

package/dist/harness-experiment-source.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { contentHash, ImmutableReleaseRefSchema, ReleaseHashSchema } from "@openpond/harness";
+/** A standalone Agent/Harness closure has no incidental Profile binding.
+ * The execution host resolves and verifies these exact published bytes. */
+export const StandaloneHarnessExperimentSourceSchema = z.object({
+    harnessRelease: ImmutableReleaseRefSchema,
+    agentSnapshot: ImmutableReleaseRefSchema,
+    sourcePackageHash: ReleaseHashSchema,
+}).strict();
+export const STANDALONE_EXPERIMENT_MAX_POLICY_CALLS = 64;
+export function harnessExperimentSourceRequiresProfile(source) {
+    return [source.agentSnapshot.metadata, source.harnessRelease.metadata].some(metadata => typeof metadata.profileRepositoryId === "string" || metadata.profile !== undefined && metadata.profile !== null);
+}
+/** Qualified case-local implementations read this immutable closure or its
+ * retained context. Other capabilities need an independently admitted world. */
+export const STANDALONE_EXPERIMENT_READ_TOOLS = new Set([
+    "harness_inspect", "skill_inspect", "profile_skill_read", "context_read",
+]);
+export function standaloneHarnessExperimentTools(source) {
+    if (harnessExperimentSourceRequiresProfile(source))
+        throw new Error("This source is bound to a Profile; select Model + Harness + Profile.");
+    return harnessExperimentReadToolDeclarations(source);
+}
+/** Profile-owned callers must establish exact Profile authority first. This
+ * function qualifies only tools; it does not grant source or Profile access. */
+export function harnessExperimentReadToolDeclarations(source) {
+    const required = source.agentSnapshot.capabilityRequirements.find(capability => capability.required);
+    if (required)
+        throw new Error(`Standalone Harness capability requires an admitted case environment: ${required.id}.`);
+    const declarations = new Map();
+    for (const declaration of [...source.agentSnapshot.toolDeclarations, ...source.harnessRelease.tools]) {
+        if (!STANDALONE_EXPERIMENT_READ_TOOLS.has(declaration.name) || declaration.sideEffect !== "read")
+            throw new Error(`Standalone Harness tool requires an admitted case environment: ${declaration.name}.`);
+        if (contentHash(declaration.inputSchema) !== declaration.inputSchemaHash)
+            throw new Error(`Standalone Harness tool schema differs from its declaration: ${declaration.name}.`);
+        const prior = declarations.get(declaration.name);
+        if (prior && contentHash(prior) !== contentHash(declaration))
+            throw new Error(`Standalone Harness has conflicting tool declarations: ${declaration.name}.`);
+        declarations.set(declaration.name, declaration);
+    }
+    return [...declarations.values()];
+}

package/dist/native-harness-experiment-attempt.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { contentHash, ReleaseHashSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { StandaloneHarnessExperimentSourceSchema } from "./harness-experiment-source.js";
+import { assertBoundedTaskJson } from "./task-schema.js";
+const EvidenceIdSchema = z.string().trim().min(1).max(200);
+/** Owner-recorded native turn identities. Raw runtime events remain in the
+ * authorized execution store; this receipt retains their exact references. */
+export const NativeHarnessExperimentEvidenceSchema = z.object({
+    sessionId: EvidenceIdSchema,
+    turnId: EvidenceIdSchema,
+    source: StandaloneHarnessExperimentSourceSchema,
+    admissionHash: ReleaseHashSchema,
+    modelConfigurationHash: ReleaseHashSchema,
+    traceHash: ReleaseHashSchema,
+    runtimeEventRefs: z.array(EvidenceIdSchema).max(10_000),
+    startedAt: ReleaseTimestampSchema,
+    completedAt: ReleaseTimestampSchema,
+    outputHash: ReleaseHashSchema,
+    partialOutputAvailable: z.boolean(),
+}).strict().superRefine((value, context) => {
+    if (new Set(value.runtimeEventRefs).size !== value.runtimeEventRefs.length)
+        context.addIssue({ code: "custom", path: ["runtimeEventRefs"], message: "Native event references must be unique." });
+    if (Date.parse(value.completedAt) < Date.parse(value.startedAt))
+        context.addIssue({ code: "custom", path: ["completedAt"], message: "Native completion precedes its start." });
+});
+/** This qualified standalone contract is for text Datasets. A prepared task
+ * needs its independently qualified environment receipt, not a null snapshot
+ * presented as evidence that its environment ran. */
+export const NativeHarnessExperimentAttemptContentSchema = z.object({
+    schemaVersion: z.literal("openpond.nativeHarnessExperimentAttempt.v1"),
+    taskId: z.string().min(1).max(500),
+    status: z.enum(["completed", "cancelled", "timed_out", "policy_failure"]),
+    output: z.string().max(8_388_608).nullable(),
+    error: z.string().max(2_000).nullable(),
+    messages: z.array(z.unknown()).max(4_002),
+    collected: z.boolean(),
+    environmentCleanupComplete: z.literal(true),
+    snapshot: z.null(),
+    native: NativeHarnessExperimentEvidenceSchema,
+}).strict().superRefine((value, context) => {
+    const completed = value.status === "completed";
+    if (completed !== value.collected || completed !== (value.output !== null)
+        || completed !== (value.error === null))
+        context.addIssue({ code: "custom", message: "Native status, output, collection and error must agree." });
+    if (completed && (value.native.partialOutputAvailable || value.native.outputHash !== contentHash(value.output)))
+        context.addIssue({ code: "custom", path: ["native", "outputHash"], message: "Native output differs from its retained evidence." });
+});
+export const NativeHarnessExperimentAttemptSchema = NativeHarnessExperimentAttemptContentSchema
+    .extend({ contentHash: ReleaseHashSchema }).strict();
+export function createNativeHarnessExperimentAttempt(input) {
+    assertBoundedTaskJson(input, 16_777_216);
+    const content = NativeHarnessExperimentAttemptContentSchema.parse(input);
+    return NativeHarnessExperimentAttemptSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+/** Artifact access and trace ownership are enforced by the host. Verification
+ * binds the artifact bytes to that host's independently admitted case. */
+export function verifyNativeHarnessExperimentAttempt(value, context) {
+    assertBoundedTaskJson(value, 16_777_216);
+    const result = NativeHarnessExperimentAttemptSchema.parse(value);
+    const { contentHash: hash, ...content } = result;
+    if (contentHash(content) !== hash || result.taskId !== context.taskId
+        || contentHash(result.native.source) !== contentHash(StandaloneHarnessExperimentSourceSchema.parse(context.source))
+        || result.native.admissionHash !== context.admissionHash
+        || result.native.modelConfigurationHash !== context.modelConfigurationHash
+        || result.native.traceHash !== context.traceHash)
+        throw new Error("Native Harness attempt differs from its admitted case or retained trace.");
+    return result;
+}

package/dist/types/experiments.d.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+export { StandaloneHarnessExperimentSourceSchema, STANDALONE_EXPERIMENT_MAX_POLICY_CALLS, STANDALONE_EXPERIMENT_READ_TOOLS, standaloneHarnessExperimentTools, harnessExperimentSourceRequiresProfile, harnessExperimentReadToolDeclarations, type StandaloneHarnessExperimentSource, } from "./harness-experiment-source.js";
+export { NativeHarnessExperimentEvidenceSchema, NativeHarnessExperimentAttemptContentSchema, NativeHarnessExperimentAttemptSchema, createNativeHarnessExperimentAttempt, verifyNativeHarnessExperimentAttempt, type NativeHarnessExperimentEvidence, type NativeHarnessExperimentAttempt, } from "./native-harness-experiment-attempt.js";
 export declare const ExperimentTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"model">;
     modelId: z.ZodString;
@@ -33,6 +35,23 @@ export declare const ExperimentTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         modelId: z.ZodString;
         configurationHash: z.ZodString;
     }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent">;
+    source: z.ZodObject<{
+        harnessRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        agentSnapshot: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        sourcePackageHash: z.ZodString;
+    }, z.core.$strict>;
+    model: z.ZodObject<{
+        modelId: z.ZodString;
+        configurationHash: z.ZodString;
+    }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"fixture">;
     configurationHash: z.ZodString;
@@ -105,6 +124,23 @@ export declare const ExperimentManifestContentSchema: z.ZodObject<{
             modelId: z.ZodString;
             configurationHash: z.ZodString;
         }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        source: z.ZodObject<{
+            harnessRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            agentSnapshot: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            sourcePackageHash: z.ZodString;
+        }, z.core.$strict>;
+        model: z.ZodObject<{
+            modelId: z.ZodString;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"fixture">;
         configurationHash: z.ZodString;
@@ -113,6 +149,15 @@ export declare const ExperimentManifestContentSchema: z.ZodObject<{
         packageHash: z.ZodString;
         runtimeTargetHash: z.ZodString;
         metricPolicyHash: z.ZodString;
+        compatibility: z.ZodOptional<z.ZodObject<{
+            protocol: z.ZodLiteral<"openpond.evaluation-execution.v1">;
+            targetKind: z.ZodEnum<{
+                agent: "agent";
+                model: "model";
+                fixture: "fixture";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     lineage: z.ZodOptional<z.ZodObject<{
         definition: z.ZodNullable<z.ZodObject<{
@@ -194,6 +239,23 @@ export declare const ExperimentManifestSchema: z.ZodObject<{
             modelId: z.ZodString;
             configurationHash: z.ZodString;
         }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        source: z.ZodObject<{
+            harnessRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            agentSnapshot: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            sourcePackageHash: z.ZodString;
+        }, z.core.$strict>;
+        model: z.ZodObject<{
+            modelId: z.ZodString;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"fixture">;
         configurationHash: z.ZodString;
@@ -202,6 +264,15 @@ export declare const ExperimentManifestSchema: z.ZodObject<{
         packageHash: z.ZodString;
         runtimeTargetHash: z.ZodString;
         metricPolicyHash: z.ZodString;
+        compatibility: z.ZodOptional<z.ZodObject<{
+            protocol: z.ZodLiteral<"openpond.evaluation-execution.v1">;
+            targetKind: z.ZodEnum<{
+                agent: "agent";
+                model: "model";
+                fixture: "fixture";
+                harness: "harness";
+            }>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     lineage: z.ZodOptional<z.ZodObject<{
         definition: z.ZodNullable<z.ZodObject<{
@@ -550,6 +621,23 @@ export declare function verifyExperimentEvidence(input: {
                 modelId: string;
                 configurationHash: string;
             };
+        } | {
+            kind: "agent";
+            source: {
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                agentSnapshot: {
+                    id: string;
+                    contentHash: string;
+                };
+                sourcePackageHash: string;
+            };
+            model: {
+                modelId: string;
+                configurationHash: string;
+            };
         } | {
             kind: "fixture";
             configurationHash: string;
@@ -576,6 +664,10 @@ export declare function verifyExperimentEvidence(input: {
             packageHash: string;
             runtimeTargetHash: string;
             metricPolicyHash: string;
+            compatibility?: {
+                protocol: "openpond.evaluation-execution.v1";
+                targetKind: "agent" | "model" | "fixture" | "harness";
+            } | undefined;
         } | undefined;
         lineage?: {
             definition: {

package/dist/types/experiments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"experiments.d.ts","sourceRoot":"","sources":["../../../../src/experiments.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"experiments.d.ts","sourceRoot":"","sources":["../../../../src/experiments.ts"],"names":[],"mappings":"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"}

package/dist/types/harness-experiment-source.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { type AgentSnapshot, type HarnessRelease, type ToolDeclaration } from "@openpond/harness";
+/** A standalone Agent/Harness closure has no incidental Profile binding.
+ * The execution host resolves and verifies these exact published bytes. */
+export declare const StandaloneHarnessExperimentSourceSchema: z.ZodObject<{
+    harnessRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    agentSnapshot: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    sourcePackageHash: z.ZodString;
+}, z.core.$strict>;
+export type StandaloneHarnessExperimentSource = z.infer<typeof StandaloneHarnessExperimentSourceSchema>;
+export declare const STANDALONE_EXPERIMENT_MAX_POLICY_CALLS = 64;
+export declare function harnessExperimentSourceRequiresProfile(source: {
+    agentSnapshot: AgentSnapshot;
+    harnessRelease: HarnessRelease;
+}): boolean;
+/** Qualified case-local implementations read this immutable closure or its
+ * retained context. Other capabilities need an independently admitted world. */
+export declare const STANDALONE_EXPERIMENT_READ_TOOLS: ReadonlySet<string>;
+export declare function standaloneHarnessExperimentTools(source: {
+    agentSnapshot: AgentSnapshot;
+    harnessRelease: HarnessRelease;
+}): ToolDeclaration[];
+/** Profile-owned callers must establish exact Profile authority first. This
+ * function qualifies only tools; it does not grant source or Profile access. */
+export declare function harnessExperimentReadToolDeclarations(source: {
+    agentSnapshot: AgentSnapshot;
+    harnessRelease: HarnessRelease;
+}): ToolDeclaration[];
+//# sourceMappingURL=harness-experiment-source.d.ts.map

package/dist/types/harness-experiment-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-experiment-source.d.ts","sourceRoot":"","sources":["../../../../src/harness-experiment-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAA6D,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAE7J;2EAC2E;AAC3E,eAAO,MAAM,uCAAuC;;;;;;;;;;kBAIzC,CAAC;AACZ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uCAAuC,CAAC,CAAC;AACxG,eAAO,MAAM,sCAAsC,KAAK,CAAC;AAEzD,wBAAgB,sCAAsC,CAAC,MAAM,EAAE;IAAE,aAAa,EAAE,aAAa,CAAC;IAAC,cAAc,EAAE,cAAc,CAAA;CAAE,GAAG,OAAO,CAGxI;AAED;gFACgF;AAChF,eAAO,MAAM,gCAAgC,EAAE,WAAW,CAAC,MAAM,CAE/D,CAAC;AAEH,wBAAgB,gCAAgC,CAAC,MAAM,EAAE;IACvD,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;CAChC,GAAG,eAAe,EAAE,CAIpB;AAED;gFACgF;AAChF,wBAAgB,qCAAqC,CAAC,MAAM,EAAE;IAC5D,aAAa,EAAE,aAAa,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;CAChC,GAAG,eAAe,EAAE,CAepB"}

package/dist/types/native-harness-experiment-attempt.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { type StandaloneHarnessExperimentSource } from "./harness-experiment-source.js";
+/** Owner-recorded native turn identities. Raw runtime events remain in the
+ * authorized execution store; this receipt retains their exact references. */
+export declare const NativeHarnessExperimentEvidenceSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    source: z.ZodObject<{
+        harnessRelease: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        agentSnapshot: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        sourcePackageHash: z.ZodString;
+    }, z.core.$strict>;
+    admissionHash: z.ZodString;
+    modelConfigurationHash: z.ZodString;
+    traceHash: z.ZodString;
+    runtimeEventRefs: z.ZodArray<z.ZodString>;
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+    outputHash: z.ZodString;
+    partialOutputAvailable: z.ZodBoolean;
+}, z.core.$strict>;
+export type NativeHarnessExperimentEvidence = z.infer<typeof NativeHarnessExperimentEvidenceSchema>;
+/** This qualified standalone contract is for text Datasets. A prepared task
+ * needs its independently qualified environment receipt, not a null snapshot
+ * presented as evidence that its environment ran. */
+export declare const NativeHarnessExperimentAttemptContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.nativeHarnessExperimentAttempt.v1">;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        policy_failure: "policy_failure";
+        cancelled: "cancelled";
+        timed_out: "timed_out";
+    }>;
+    output: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    messages: z.ZodArray<z.ZodUnknown>;
+    collected: z.ZodBoolean;
+    environmentCleanupComplete: z.ZodLiteral<true>;
+    snapshot: z.ZodNull;
+    native: z.ZodObject<{
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        source: z.ZodObject<{
+            harnessRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            agentSnapshot: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            sourcePackageHash: z.ZodString;
+        }, z.core.$strict>;
+        admissionHash: z.ZodString;
+        modelConfigurationHash: z.ZodString;
+        traceHash: z.ZodString;
+        runtimeEventRefs: z.ZodArray<z.ZodString>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        outputHash: z.ZodString;
+        partialOutputAvailable: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NativeHarnessExperimentAttemptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.nativeHarnessExperimentAttempt.v1">;
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        policy_failure: "policy_failure";
+        cancelled: "cancelled";
+        timed_out: "timed_out";
+    }>;
+    output: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    messages: z.ZodArray<z.ZodUnknown>;
+    collected: z.ZodBoolean;
+    environmentCleanupComplete: z.ZodLiteral<true>;
+    snapshot: z.ZodNull;
+    native: z.ZodObject<{
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        source: z.ZodObject<{
+            harnessRelease: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            agentSnapshot: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            sourcePackageHash: z.ZodString;
+        }, z.core.$strict>;
+        admissionHash: z.ZodString;
+        modelConfigurationHash: z.ZodString;
+        traceHash: z.ZodString;
+        runtimeEventRefs: z.ZodArray<z.ZodString>;
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        outputHash: z.ZodString;
+        partialOutputAvailable: z.ZodBoolean;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NativeHarnessExperimentAttempt = z.infer<typeof NativeHarnessExperimentAttemptSchema>;
+export declare function createNativeHarnessExperimentAttempt(input: z.input<typeof NativeHarnessExperimentAttemptContentSchema>): NativeHarnessExperimentAttempt;
+/** Artifact access and trace ownership are enforced by the host. Verification
+ * binds the artifact bytes to that host's independently admitted case. */
+export declare function verifyNativeHarnessExperimentAttempt(value: unknown, context: {
+    taskId: string;
+    source: StandaloneHarnessExperimentSource;
+    admissionHash: string;
+    modelConfigurationHash: string;
+    traceHash: string;
+}): NativeHarnessExperimentAttempt;
+//# sourceMappingURL=native-harness-experiment-attempt.d.ts.map

package/dist/types/native-harness-experiment-attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-harness-experiment-attempt.d.ts","sourceRoot":"","sources":["../../../../src/native-harness-experiment-attempt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAA2C,KAAK,iCAAiC,EAAE,MAAM,gCAAgC,CAAC;AAKjI;8EAC8E;AAC9E,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;kBAiBhD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG;;qDAEqD;AACrD,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBtD,CAAC;AACH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACK,CAAC;AACvD,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAElG,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,GACjE,8BAA8B,CAIhC;AAED;0EAC0E;AAC1E,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,iCAAiC,CAAC;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,8BAA8B,CAWjC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpond/evals",
-  "version": "0.11.14",
+  "version": "0.11.16",
   "description": "Portable Tasksets, graders, evaluation runs, receipts, conformance fixtures, and Work evidence for OpenPond Harnesses",
   "license": "MIT",
   "type": "module",