@openpond/evals 0.11.11 → 0.11.13

package/CONTRACT.md

@@ -162,3 +162,27 @@ Node subprocess for hosts without Node worker APIs. It strips authored TypeScrip
 inside its deadline, evaluates the verified source in the same deterministic
 isolate, and exits before success, failure or cancellation settles. Importing
 the metrics entrypoint does not require Node's type-stripping API on the host.
+
+## Portable Experiment comparison
+
+`verifyExperimentEvidence` verifies the manifest hash, result hash, complete
+case population and exact evaluator bindings. Historical runs without a whole
+execution ceiling report `maximumCostUsd: null`. Dataset-authored graders retain
+their actual version string and implementation hash; reusable Rewards retain
+their numeric release revision. Authored fixture checks use a fixture target.
+
+Hosts can pin package, runtime and metric-policy hashes in `execution`. Shared
+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.
+
+`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
+cases never become zero-valued measurements. Categorical feedback remains
+inspectable without a numeric delta. This operation reads retained evidence and
+has no execution, grading or billing authority.
+
+## Retained Profile case evidence
+
+Profile execution may return an installation-owned `retainedEvidenceRef` with its exact session and turn identities. The runner validates it and binds it into immutable receipt metadata. A reference grants no access: the installation resolves it through its owner-scoped store and checks the source, member, output and trace hashes before inspection. Full outputs and bounded trace pages stay separate from private grading inputs. Missing historic references remain unavailable rather than reconstructed from a newer source.

package/dist/experiments.js

@@ -13,10 +13,15 @@ export const ExperimentTargetSchema = z.discriminatedUnion("kind", [
         kind: z.literal("harness"),
         source: ProfileEvaluationRunSourceSchema,
     }).strict(),
+    z.object({ kind: z.literal("fixture"), configurationHash: ReleaseHashSchema }).strict(),
 ]);
 export const ExperimentEvaluatorSchema = z.object({
-    release: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict(),
+    // A reusable Reward has a numeric revision; a dataset-authored GraderSpec
+    // has its exact version string and implementation hash. Neither is invented.
+    release: ImmutableReleaseRefSchema.extend({ revision: z.union([z.number().int().positive(), z.string().trim().min(1).max(200)]) }).strict(),
     feedbackKey: FeedbackKeySchema,
+    /** Binds field mappings and admitted scorer settings without changing the Reward's release hash. */
+    configurationHash: ReleaseHashSchema.optional(),
     output: z.enum(["boolean", "score", "category"]),
     /** Category labels are meaningful only for category output. */
     categories: z.array(z.string().trim().min(1).max(120)).max(50),
@@ -41,13 +46,22 @@ export const ExperimentManifestContentSchema = z.object({
     name: z.string().trim().min(1).max(500),
     teamId: ReleaseIdSchema,
     operationId: ReleaseIdSchema,
-    maximumCostUsd: MoneySchema,
+    /** Historical imported runs may have no admitted whole-run ceiling. */
+    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(),
+    lineage: z.object({
+        definition: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict().nullable(),
+        execution: ImmutableReleaseRefSchema,
+        scoringPassId: ReleaseIdSchema.nullable(),
+    }).strict().optional(),
     evaluators: z.array(ExperimentEvaluatorSchema).max(100),
     population: z.array(ExperimentCaseIdentitySchema).min(1).max(10_000),
     createdAt: ReleaseTimestampSchema,
 }).strict().superRefine((value, context) => {
+    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)
         context.addIssue({ code: "custom", path: ["population"], message: "Experiment cases must be unique." });
     if (new Set(value.evaluators.map((item) => item.feedbackKey)).size !== value.evaluators.length)
@@ -59,6 +73,7 @@ export const ExperimentFeedbackSchema = z.object({
     evaluator: ExperimentEvaluatorSchema.shape.release,
     status: z.enum(["scored", "unavailable", "failed", "pending"]),
     value: z.union([z.boolean(), z.number().finite(), z.string().max(120)]).nullable(),
+    passed: z.boolean().nullable().optional(),
     reasoning: z.string().max(20_000).nullable(),
     evidenceRefs: z.array(ImmutableArtifactRefSchema).max(1_000),
 }).strict();
@@ -125,21 +140,27 @@ export function createExperimentResult(input, manifest) {
                     || (evaluator.output === "score" && (feedback.value < 0 || feedback.value > 1)))
                     throw new Error("Experiment feedback value violates its output contract.");
             }
-            else if (feedback.value !== null)
-                throw new Error("Unscored experiment feedback cannot claim a value.");
+            else if (feedback.value !== null || feedback.passed !== null && feedback.passed !== undefined)
+                throw new Error("Unscored experiment feedback cannot claim a value or pass decision.");
         }
     }
     if (seen.size !== expected.size)
         throw new Error("Experiment result omits admitted cases.");
     return ExperimentResultSchema.parse({ ...value, contentHash: contentHash(value) });
 }
+export function verifyExperimentEvidence(input) {
+    const manifest = ExperimentManifestSchema.parse(input.manifest);
+    const result = ExperimentResultSchema.parse(input.result);
+    const { contentHash: hash, ...content } = result;
+    if (contentHash(content) !== hash)
+        throw new Error("Experiment result integrity failed.");
+    createExperimentResult(content, manifest);
+    return { manifest, result };
+}
 /** A comparison reads retained results; it never executes or regrades a case. */
 export function compareExperiments(baseline, candidate) {
     for (const pair of [baseline, candidate]) {
-        const { contentHash: hash, ...value } = ExperimentResultSchema.parse(pair.result);
-        if (contentHash(value) !== hash)
-            throw new Error("Experiment result integrity failed.");
-        createExperimentResult(value, pair.manifest);
+        verifyExperimentEvidence(pair);
     }
     const reasons = [];
     if (baseline.manifest.teamId !== candidate.manifest.teamId)
@@ -150,20 +171,73 @@ 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.evaluators) !== contentHash(candidate.manifest.evaluators))
+    if (contentHash(baseline.manifest.execution ?? null) !== contentHash(candidate.manifest.execution ?? null))
+        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)
+            reasons.push("different_environment");
+        if (a.definitionId !== b.definitionId || a.definitionHash !== b.definitionHash)
+            reasons.push("different_evaluation_definition");
+    }
+    const orderedEvaluators = (manifest) => [...manifest.evaluators].sort((a, b) => a.feedbackKey.localeCompare(b.feedbackKey));
+    if (contentHash(orderedEvaluators(baseline.manifest)) !== contentHash(orderedEvaluators(candidate.manifest)))
         reasons.push("different_evaluators");
     const left = new Map(baseline.result.cases.map((item) => [experimentCaseKey(item.identity), item]));
     const right = new Map(candidate.result.cases.map((item) => [experimentCaseKey(item.identity), item]));
     const keys = [...new Set([...left.keys(), ...right.keys()])].sort();
     if (left.size !== right.size || keys.some((key) => !left.has(key) || !right.has(key)))
         reasons.push("different_population");
+    const comparable = reasons.length === 0;
+    const cases = keys.map((key) => {
+        const baselineCase = left.get(key) ?? null;
+        const candidateCase = right.get(key) ?? null;
+        const baselineFeedback = new Map(baselineCase?.feedback.map(item => [item.feedbackKey, item]) ?? []);
+        const candidateFeedback = new Map(candidateCase?.feedback.map(item => [item.feedbackKey, item]) ?? []);
+        return {
+            identity: (baselineCase ?? candidateCase).identity,
+            baseline: baselineCase,
+            candidate: candidateCase,
+            feedback: baseline.manifest.evaluators.map(evaluator => {
+                const a = baselineFeedback.get(evaluator.feedbackKey);
+                const b = candidateFeedback.get(evaluator.feedbackKey);
+                const reason = !comparable ? "incompatible_experiments"
+                    : !baselineCase || !candidateCase ? "missing_case"
+                        : baselineCase.status !== "completed" || candidateCase.status !== "completed" || baselineCase.error || candidateCase.error ? "case_not_completed"
+                            : !a || !b || a.status !== "scored" || b.status !== "scored" ? "feedback_unavailable"
+                                : evaluator.output === "category" ? "categorical_feedback" : null;
+                const numeric = (item) => typeof item?.value === "boolean" ? Number(item.value)
+                    : typeof item?.value === "number" ? item.value : null;
+                const av = reason ? null : numeric(a);
+                const bv = reason ? null : numeric(b);
+                const pass = (item) => reason ? null : typeof item?.value === "boolean" ? item.value : item?.passed ?? null;
+                return { feedbackKey: evaluator.feedbackKey, eligible: reason === null, reason,
+                    baseline: av, candidate: bv, delta: av === null || bv === null ? null : bv - av,
+                    baselinePassed: pass(a), candidatePassed: pass(b) };
+            }),
+        };
+    });
+    const metrics = baseline.manifest.evaluators.map((evaluator, index) => {
+        const eligible = cases.map(item => item.feedback[index]).filter(value => value.eligible);
+        const mean = (field) => eligible.length
+            ? eligible.reduce((sum, value) => sum + value[field], 0) / eligible.length : null;
+        const a = mean("baseline");
+        const b = mean("candidate");
+        const passRate = (field) => eligible.length && eligible.every(value => value[field] !== null)
+            ? eligible.reduce((sum, value) => sum + Number(value[field]), 0) / eligible.length : null;
+        const ap = passRate("baselinePassed");
+        const bp = passRate("candidatePassed");
+        return { feedbackKey: evaluator.feedbackKey, eligibleCount: eligible.length, excludedCount: cases.length - eligible.length,
+            baseline: a, candidate: b, delta: a === null || b === null ? null : b - a,
+            baselinePassRate: ap, candidatePassRate: bp, passRateDelta: ap === null || bp === null ? null : bp - ap };
+    });
     return {
-        comparable: reasons.length === 0,
+        comparable,
         reasons,
-        cases: keys.map((key) => ({
-            identity: (left.get(key) ?? right.get(key)).identity,
-            baseline: left.get(key) ?? null,
-            candidate: right.get(key) ?? null,
-        })),
+        cases,
+        metrics,
     };
 }

package/dist/profile-evaluation-execution.js

@@ -4,6 +4,13 @@ import { aggregateTasksetRunReceipts, assertTasksetMetricSource } from "./metric
 import { createAttemptReceipt, verifyAttemptReceipt } from "./runs.js";
 import { assertProfileEvaluationRunAdmission } from "./taskset-run-contract.js";
 import { policyTaskView } from "./tasksets.js";
+import { z } from "zod";
+/** An installation-owned policy trace. Access remains with that installation;
+ * the immutable receipt binds the reference without copying private graders. */
+export const ProfileEvaluationEvidenceRefSchema = z.object({
+    sessionId: z.string().trim().min(1).max(500),
+    turnId: z.string().trim().min(1).max(500),
+}).strict();
 /** The installation owns execution, tools, approvals and storage. This runner
  * owns frozen population dispatch and private grading for both Desktop and web. */
 export async function executeProfileEvaluationRun(input) {
@@ -78,6 +85,9 @@ export async function executeProfileEvaluationRun(input) {
                 sourceRevision: source.sourceRevision,
                 definitionHash: source.definitionHash,
                 environmentHash: source.environmentHash,
+                ...(execution.retainedEvidenceRef ? {
+                    retainedEvidenceRef: ProfileEvaluationEvidenceRefSchema.parse(execution.retainedEvidenceRef),
+                } : {}),
             },
         });
         await input.saveReceipt(receipt);

package/dist/types/experiments.d.ts

@@ -29,14 +29,18 @@ export declare const ExperimentTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
         }, z.core.$strict>], "kind">;
         environmentHash: z.ZodString;
     }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"fixture">;
+    configurationHash: z.ZodString;
 }, z.core.$strict>], "kind">;
 export declare const ExperimentEvaluatorSchema: z.ZodObject<{
     release: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
-        revision: z.ZodNumber;
+        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
     }, z.core.$strict>;
     feedbackKey: z.ZodString;
+    configurationHash: z.ZodOptional<z.ZodString>;
     output: z.ZodEnum<{
         boolean: "boolean";
         score: "score";
@@ -57,7 +61,7 @@ export declare const ExperimentManifestContentSchema: z.ZodObject<{
     name: z.ZodString;
     teamId: z.ZodString;
     operationId: z.ZodString;
-    maximumCostUsd: z.ZodNumber;
+    maximumCostUsd: z.ZodNullable<z.ZodNumber>;
     dataset: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
@@ -93,14 +97,35 @@ export declare const ExperimentManifestContentSchema: z.ZodObject<{
             }, z.core.$strict>], "kind">;
             environmentHash: z.ZodString;
         }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fixture">;
+        configurationHash: z.ZodString;
     }, z.core.$strict>], "kind">;
+    execution: z.ZodOptional<z.ZodObject<{
+        packageHash: z.ZodString;
+        runtimeTargetHash: z.ZodString;
+        metricPolicyHash: z.ZodString;
+    }, z.core.$strict>>;
+    lineage: z.ZodOptional<z.ZodObject<{
+        definition: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        execution: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        scoringPassId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
     evaluators: z.ZodArray<z.ZodObject<{
         release: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
-            revision: z.ZodNumber;
+            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
         }, z.core.$strict>;
         feedbackKey: z.ZodString;
+        configurationHash: z.ZodOptional<z.ZodString>;
         output: z.ZodEnum<{
             boolean: "boolean";
             score: "score";
@@ -121,7 +146,7 @@ export declare const ExperimentManifestSchema: z.ZodObject<{
     name: z.ZodString;
     teamId: z.ZodString;
     operationId: z.ZodString;
-    maximumCostUsd: z.ZodNumber;
+    maximumCostUsd: z.ZodNullable<z.ZodNumber>;
     dataset: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
@@ -157,14 +182,35 @@ export declare const ExperimentManifestSchema: z.ZodObject<{
             }, z.core.$strict>], "kind">;
             environmentHash: z.ZodString;
         }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"fixture">;
+        configurationHash: z.ZodString;
     }, z.core.$strict>], "kind">;
+    execution: z.ZodOptional<z.ZodObject<{
+        packageHash: z.ZodString;
+        runtimeTargetHash: z.ZodString;
+        metricPolicyHash: z.ZodString;
+    }, z.core.$strict>>;
+    lineage: z.ZodOptional<z.ZodObject<{
+        definition: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        execution: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        scoringPassId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
     evaluators: z.ZodArray<z.ZodObject<{
         release: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
-            revision: z.ZodNumber;
+            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
         }, z.core.$strict>;
         feedbackKey: z.ZodString;
+        configurationHash: z.ZodOptional<z.ZodString>;
         output: z.ZodEnum<{
             boolean: "boolean";
             score: "score";
@@ -186,7 +232,7 @@ export declare const ExperimentFeedbackSchema: z.ZodObject<{
     evaluator: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
-        revision: z.ZodNumber;
+        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
     }, z.core.$strict>;
     status: z.ZodEnum<{
         pending: "pending";
@@ -195,6 +241,7 @@ export declare const ExperimentFeedbackSchema: z.ZodObject<{
         unavailable: "unavailable";
     }>;
     value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+    passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     reasoning: z.ZodNullable<z.ZodString>;
     evidenceRefs: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -232,7 +279,7 @@ export declare const ExperimentCaseResultSchema: z.ZodObject<{
         evaluator: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
-            revision: z.ZodNumber;
+            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
         }, z.core.$strict>;
         status: z.ZodEnum<{
             pending: "pending";
@@ -241,6 +288,7 @@ export declare const ExperimentCaseResultSchema: z.ZodObject<{
             unavailable: "unavailable";
         }>;
         value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+        passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
         reasoning: z.ZodNullable<z.ZodString>;
         evidenceRefs: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -298,7 +346,7 @@ export declare const ExperimentResultContentSchema: z.ZodObject<{
             evaluator: z.ZodObject<{
                 id: z.ZodString;
                 contentHash: z.ZodString;
-                revision: z.ZodNumber;
+                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
             }, z.core.$strict>;
             status: z.ZodEnum<{
                 pending: "pending";
@@ -307,6 +355,7 @@ export declare const ExperimentResultContentSchema: z.ZodObject<{
                 unavailable: "unavailable";
             }>;
             value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+            passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
             reasoning: z.ZodNullable<z.ZodString>;
             evidenceRefs: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -366,7 +415,7 @@ export declare const ExperimentResultSchema: z.ZodObject<{
             evaluator: z.ZodObject<{
                 id: z.ZodString;
                 contentHash: z.ZodString;
-                revision: z.ZodNumber;
+                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
             }, z.core.$strict>;
             status: z.ZodEnum<{
                 pending: "pending";
@@ -375,6 +424,7 @@ export declare const ExperimentResultSchema: z.ZodObject<{
                 unavailable: "unavailable";
             }>;
             value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+            passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
             reasoning: z.ZodNullable<z.ZodString>;
             evidenceRefs: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -412,9 +462,175 @@ export type ExperimentComparison = {
         identity: ExperimentCaseIdentity;
         baseline: ExperimentCaseResult | null;
         candidate: ExperimentCaseResult | null;
+        feedback: ExperimentFeedbackComparison[];
     }>;
+    metrics: ExperimentComparisonMetric[];
 };
 export type ExperimentCaseResult = z.infer<typeof ExperimentCaseResultSchema>;
+export type ExperimentFeedbackComparison = {
+    feedbackKey: string;
+    eligible: boolean;
+    reason: "incompatible_experiments" | "missing_case" | "case_not_completed" | "feedback_unavailable" | "categorical_feedback" | null;
+    baseline: number | null;
+    candidate: number | null;
+    delta: number | null;
+    baselinePassed: boolean | null;
+    candidatePassed: boolean | null;
+};
+export type ExperimentComparisonMetric = {
+    feedbackKey: string;
+    eligibleCount: number;
+    excludedCount: number;
+    baseline: number | null;
+    candidate: number | null;
+    delta: number | null;
+    baselinePassRate: number | null;
+    candidatePassRate: number | null;
+    passRateDelta: number | null;
+};
+export declare function verifyExperimentEvidence(input: {
+    manifest: unknown;
+    result: unknown;
+}): {
+    manifest: {
+        schemaVersion: "openpond.experimentManifest.v1";
+        id: string;
+        name: string;
+        teamId: string;
+        operationId: string;
+        maximumCostUsd: number | null;
+        dataset: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        target: {
+            kind: "model";
+            modelId: string;
+            configurationHash: string;
+        } | {
+            kind: "harness";
+            source: {
+                profileId: string;
+                sourceRevision: string;
+                harnessRelease: {
+                    id: string;
+                    contentHash: string;
+                };
+                catalogHash: string;
+                definitionId: string;
+                definitionHash: string;
+                target: {
+                    kind: "profile";
+                } | {
+                    kind: "workflow";
+                    workflowId: string;
+                } | {
+                    kind: "skill";
+                    skillPath: string;
+                } | {
+                    kind: "agent_action";
+                    actionId: string;
+                };
+                environmentHash: string;
+            };
+        } | {
+            kind: "fixture";
+            configurationHash: string;
+        };
+        evaluators: {
+            release: {
+                id: string;
+                contentHash: string;
+                revision: string | number;
+            };
+            feedbackKey: string;
+            output: "boolean" | "score" | "category";
+            categories: string[];
+            configurationHash?: string | undefined;
+        }[];
+        population: {
+            caseId: string;
+            seed: string;
+            fixtureId: string | null;
+        }[];
+        createdAt: string;
+        contentHash: string;
+        execution?: {
+            packageHash: string;
+            runtimeTargetHash: string;
+            metricPolicyHash: string;
+        } | undefined;
+        lineage?: {
+            definition: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | null;
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            scoringPassId: string | null;
+        } | undefined;
+    };
+    result: {
+        schemaVersion: "openpond.experimentResult.v1";
+        manifest: {
+            id: string;
+            contentHash: string;
+        };
+        status: "failed" | "completed" | "cancelled";
+        cases: {
+            identity: {
+                caseId: string;
+                seed: string;
+                fixtureId: string | null;
+            };
+            status: "failed" | "completed" | "cancelled" | "unavailable";
+            output: unknown;
+            error: {
+                code: string;
+                message: string;
+            } | null;
+            feedback: {
+                feedbackKey: string;
+                evaluator: {
+                    id: string;
+                    contentHash: string;
+                    revision: string | number;
+                };
+                status: "pending" | "failed" | "scored" | "unavailable";
+                value: string | number | boolean | null;
+                reasoning: string | null;
+                evidenceRefs: {
+                    id: string;
+                    contentHash: string;
+                    mediaType: string | null;
+                    sizeBytes: number | null;
+                }[];
+                passed?: boolean | null | undefined;
+            }[];
+            usage: {
+                inputTokens: number | null;
+                outputTokens: number | null;
+                totalTokens: number | null;
+                costUsd: number | null;
+                latencyMs: number | null;
+            };
+            traceRef: {
+                id: string;
+                contentHash: string;
+                mediaType: string | null;
+                sizeBytes: number | null;
+            } | null;
+            startedAt: string | null;
+            completedAt: string | null;
+        }[];
+        completedAt: string;
+        contentHash: string;
+    };
+};
 /** A comparison reads retained results; it never executes or regrades a case. */
 export declare function compareExperiments(baseline: {
     manifest: ExperimentManifest;

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

@@ -1 +1 @@
-{"version":3,"file":"experiments.d.ts","sourceRoot":"","sources":["../../../../src/experiments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUjC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;kBAWpC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;kBAI9B,CAAC;AACZ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,MAAM,CAG1E;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiB1C,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsF,CAAC;AAC5H,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;kBAO1B,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;kBAUhC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAU5B,CAAC;AAEZ,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM/B,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAoF,CAAC;AACxH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,GAAG,kBAAkB,CAGnH;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,EAAE,QAAQ,EAAE,kBAAkB,GAAG,gBAAgB,CAgC3I;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,sBAAsB,CAAC;QAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAAC;QAAC,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CACnI,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,iFAAiF;AACjF,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE;IAAE,QAAQ,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,EACpE,SAAS,EAAE;IAAE,QAAQ,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,GACpE,oBAAoB,CA0BtB"}
+{"version":3,"file":"experiments.d.ts","sourceRoot":"","sources":["../../../../src/experiments.ts"],"names":[],"mappings":"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"}

package/dist/types/learning/repository.d.ts

@@ -1890,12 +1890,12 @@ export declare const LearningResourceKindSchema: z.ZodEnum<{
     source: "source";
     asset: "asset";
     binding: "binding";
+    definition: "definition";
     decision: "decision";
     grade: "grade";
     dispatch: "dispatch";
     batch: "batch";
     schedule: "schedule";
-    definition: "definition";
     draft: "draft";
     iteration: "iteration";
     reward_check: "reward_check";

package/dist/types/learning/transport.d.ts

@@ -1594,12 +1594,12 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         source: "source";
         asset: "asset";
         binding: "binding";
+        definition: "definition";
         decision: "decision";
         grade: "grade";
         dispatch: "dispatch";
         batch: "batch";
         schedule: "schedule";
-        definition: "definition";
         draft: "draft";
         iteration: "iteration";
         reward_check: "reward_check";
@@ -1622,12 +1622,12 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         source: "source";
         asset: "asset";
         binding: "binding";
+        definition: "definition";
         decision: "decision";
         grade: "grade";
         dispatch: "dispatch";
         batch: "batch";
         schedule: "schedule";
-        definition: "definition";
         draft: "draft";
         iteration: "iteration";
         reward_check: "reward_check";

package/dist/types/profile-evaluation-execution.d.ts

@@ -5,6 +5,13 @@ import { type AttemptReceipt } from "./runs.js";
 import { type TasksetRunManifest } from "./taskset-run-contract.js";
 import { policyTaskView, type TasksetRelease } from "./tasksets.js";
 import type { ProfileEvaluationCatalog, ProfileEvaluationRunSource } from "./profile-evaluations.js";
+import { z } from "zod";
+/** An installation-owned policy trace. Access remains with that installation;
+ * the immutable receipt binds the reference without copying private graders. */
+export declare const ProfileEvaluationEvidenceRefSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+}, z.core.$strict>;
 type PolicyTask = ReturnType<typeof policyTaskView>;
 /** The installation owns execution, tools, approvals and storage. This runner
  * owns frozen population dispatch and private grading for both Desktop and web. */
@@ -20,6 +27,7 @@ export declare function executeProfileEvaluationRun(input: {
     }) => Promise<{
         evidence: AttemptEvidence;
         traceHash: string;
+        retainedEvidenceRef?: z.infer<typeof ProfileEvaluationEvidenceRefSchema>;
         artifactRefs: ImmutableArtifactRef[];
         startedAt: string;
         completedAt: string;

package/dist/types/profile-evaluation-execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"profile-evaluation-execution.d.ts","sourceRoot":"","sources":["../../../../src/profile-evaluation-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEvG,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,KAAK,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1J,OAAO,EAA0D,KAAK,qBAAqB,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC5I,OAAO,EAA8C,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAC5F,OAAO,EAAuC,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAErG,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAEpD;mFACmF;AACnF,wBAAsB,2BAA2B,CAAC,KAAK,EAAE;IACvD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,wBAAwB,CAAC;IAClC,OAAO,EAAE,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,UAAU,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,0BAA0B,CAAC;QACnC,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,KAAK,OAAO,CAAC;QACZ,QAAQ,EAAE,eAAe,CAAC;QAC1B,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,oBAAoB,EAAE,CAAC;QACrC,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,QAAQ,EAAE,OAAO,CAAC;QAClB,YAAY,CAAC,EAAE,cAAc,CAAC,cAAc,CAAC,CAAC;KAC/C,CAAC,CAAC;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC/D,WAAW,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD;mFAC+E;IAC/E,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC;QAC7F,OAAO,EAAE,cAAc,CAAC;QACxB,KAAK,EAAE,SAAS,CAAC;KAClB,GAAG,IAAI,CAAC,CAAC;IACV,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,CAAC;IACV,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAwFD"}
+{"version":3,"file":"profile-evaluation-execution.d.ts","sourceRoot":"","sources":["../../../../src/profile-evaluation-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEvG,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,KAAK,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1J,OAAO,EAA0D,KAAK,qBAAqB,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC5I,OAAO,EAA8C,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAC5F,OAAO,EAAuC,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACzG,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACrG,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;gFACgF;AAChF,eAAO,MAAM,kCAAkC;;;kBAGpC,CAAC;AAEZ,KAAK,UAAU,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAEpD;mFACmF;AACnF,wBAAsB,2BAA2B,CAAC,KAAK,EAAE;IACvD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,wBAAwB,CAAC;IAClC,OAAO,EAAE,CAAC,MAAM,EAAE;QAChB,IAAI,EAAE,UAAU,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,0BAA0B,CAAC;QACnC,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,KAAK,OAAO,CAAC;QACZ,QAAQ,EAAE,eAAe,CAAC;QAC1B,SAAS,EAAE,MAAM,CAAC;QAClB,mBAAmB,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;QACzE,YAAY,EAAE,oBAAoB,EAAE,CAAC;QACrC,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,QAAQ,EAAE,OAAO,CAAC;QAClB,YAAY,CAAC,EAAE,cAAc,CAAC,cAAc,CAAC,CAAC;KAC/C,CAAC,CAAC;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC/D,WAAW,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD;mFAC+E;IAC/E,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC;QAC7F,OAAO,EAAE,cAAc,CAAC;QACxB,KAAK,EAAE,SAAS,CAAC;KAClB,GAAG,IAAI,CAAC,CAAC;IACV,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,cAAc,CAAC,EAAE,oBAAoB,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GAAG,OAAO,CAAC;IACV,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CA2FD"}

package/package.json

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