@openpond/evals 0.1.0 → 0.2.0

package/dist/evidence/contracts.js

@@ -0,0 +1,407 @@
+import { z } from "zod";
+import { ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "../common.js";
+import { ModelRefSchema } from "../runs.js";
+export const WORK_EVIDENCE_SCHEMA_VERSION = "openpond.workEvidenceReceipt.v1";
+export const WORK_PROCESS_TRACE_SCHEMA_VERSION = "openpond.workProcessTrace.v1";
+export const WORK_FEEDBACK_SCHEMA_VERSION = "openpond.workFeedbackReceipt.v1";
+export const WORK_EVIDENCE_ELIGIBILITY_SCHEMA_VERSION = "openpond.workEvidenceEligibility.v1";
+export const WorkSourceOpaqueRefSchema = z.string().regex(/^urn:openpond:work:[a-f0-9]{64}$/, "Work source references must be opaque SHA-256 URNs.");
+export const WorkWorkspaceOpaqueRefSchema = z.string().regex(/^urn:openpond:workspace:[a-f0-9]{64}$/, "Workspace references must be opaque SHA-256 URNs.");
+export const EvidenceArtifactIdSchema = z.string().regex(/^urn:openpond:artifact:[a-f0-9]{64}$/, "Evidence artifacts must use content-addressed SHA-256 URNs.");
+export const EvidenceArtifactRefSchema = ImmutableArtifactRefSchema.extend({
+    id: EvidenceArtifactIdSchema,
+}).strict().superRefine((artifact, context) => {
+    if (artifact.id !== evidenceArtifactId(artifact.contentHash)) {
+        context.addIssue({
+            code: "custom",
+            message: "Evidence artifact id must contain its content hash.",
+            path: ["id"],
+        });
+    }
+});
+export const WorkProcessStepKindSchema = z.enum([
+    "tool",
+    "validation",
+    "state_transition",
+    "approval",
+    "question",
+    "artifact",
+    "cleanup",
+]);
+export const WorkProcessLayerSchema = z.enum(["agent", "environment"]);
+export const WorkProcessActionSchema = z.enum([
+    "turn_started",
+    "turn_completed",
+    "turn_failed",
+    "turn_cancelled",
+    "turn_timed_out",
+    "tool_invoked",
+    "tool_completed",
+    "tool_failed",
+    "validation_completed",
+    "validation_failed",
+    "approval_requested",
+    "approval_resolved",
+    "question_asked",
+    "question_answered",
+    "question_dismissed",
+    "artifact_created",
+    "workspace_changed",
+    "environment_created",
+    "environment_reset",
+    "environment_destroyed",
+    "cleanup_completed",
+    "cleanup_failed",
+]);
+export const WorkProcessStepStatusSchema = z.enum([
+    "started",
+    "completed",
+    "failed",
+    "cancelled",
+]);
+export const WorkToolCategorySchema = z.enum([
+    "filesystem",
+    "source_control",
+    "command",
+    "browser",
+    "connected_app",
+    "sandbox",
+    "agent",
+    "other",
+]);
+export const WorkValidationKindSchema = z.enum([
+    "structural",
+    "visual",
+    "test",
+    "user_review",
+    "other",
+]);
+export const WorkTransitionStateSchema = z.enum([
+    "running",
+    "completed",
+    "failed",
+    "cancelled",
+    "timeout",
+]);
+export const WorkInterventionOutcomeSchema = z.enum([
+    "requested",
+    "approved",
+    "denied",
+    "answered",
+    "dismissed",
+]);
+export const WorkProcessErrorClassSchema = z.enum([
+    "policy",
+    "validation",
+    "environment",
+    "infrastructure",
+    "timeout",
+    "cancelled",
+    "unknown",
+]);
+export const WorkTraceIncompleteReasonSchema = z.enum([
+    "missing_start",
+    "missing_terminal",
+    "source_truncated",
+    "unsupported_events_dropped",
+    "uncorrelated_environment_step",
+    "artifact_unavailable",
+]);
+export const WorkProcessStepSchema = z.object({
+    sequence: z.number().int().nonnegative().max(1_000_000),
+    timestamp: ReleaseTimestampSchema,
+    layer: WorkProcessLayerSchema,
+    kind: WorkProcessStepKindSchema,
+    action: WorkProcessActionSchema,
+    status: WorkProcessStepStatusSchema,
+    inputHash: ReleaseHashSchema.nullable(),
+    outputHash: ReleaseHashSchema.nullable(),
+    receiptHash: ReleaseHashSchema.nullable(),
+    parentReceiptHash: ReleaseHashSchema.nullable(),
+    artifactRefs: z.array(EvidenceArtifactRefSchema).max(1_000),
+    attributes: z.object({
+        toolCategory: WorkToolCategorySchema.nullable(),
+        validationKind: WorkValidationKindSchema.nullable(),
+        transitionState: WorkTransitionStateSchema.nullable(),
+        interventionOutcome: WorkInterventionOutcomeSchema.nullable(),
+        artifactCount: z.number().int().nonnegative().max(100_000),
+        exitCode: z.number().int().min(-1).max(255).nullable(),
+        durationMs: z.number().int().nonnegative().max(31_536_000_000).nullable(),
+        cpuTimeMs: z.number().int().nonnegative().max(31_536_000_000).nullable(),
+        memoryPeakBytes: z.number().int().nonnegative().max(1_125_899_906_842_624).nullable(),
+        errorClass: WorkProcessErrorClassSchema.nullable(),
+    }).strict(),
+}).strict().superRefine((step, context) => {
+    if (step.layer === "agent" && step.parentReceiptHash !== null) {
+        context.addIssue({
+            code: "custom",
+            message: "Agent-layer steps cannot have a parent environment correlation.",
+            path: ["parentReceiptHash"],
+        });
+    }
+    if (step.layer === "environment" && step.parentReceiptHash === null) {
+        context.addIssue({
+            code: "custom",
+            message: "Environment steps must correlate to an Agent receipt.",
+            path: ["parentReceiptHash"],
+        });
+    }
+});
+export const WorkProcessTraceContentSchema = z.object({
+    schemaVersion: z.literal(WORK_PROCESS_TRACE_SCHEMA_VERSION),
+    sourceRevisionHash: ReleaseHashSchema,
+    sanitationPolicyVersion: ReleaseIdSchema,
+    incomplete: z.boolean(),
+    incompleteReasons: z.array(WorkTraceIncompleteReasonSchema).max(10),
+    droppedEventCount: z.number().int().nonnegative().max(1_000_000),
+    steps: z.array(WorkProcessStepSchema).max(100_000),
+}).strict().superRefine((trace, context) => {
+    if (trace.incomplete !== (trace.incompleteReasons.length > 0)) {
+        context.addIssue({
+            code: "custom",
+            message: "incomplete must match the presence of incompleteReasons.",
+            path: ["incomplete"],
+        });
+    }
+    for (let index = 0; index < trace.steps.length; index += 1) {
+        if (trace.steps[index].sequence !== index) {
+            context.addIssue({
+                code: "custom",
+                message: "Process trace sequences must be contiguous and zero-based.",
+                path: ["steps", index, "sequence"],
+            });
+        }
+    }
+});
+export const WorkProcessTraceSchema = WorkProcessTraceContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const WorkFailureClassSchema = z.enum([
+    "policy_failure",
+    "validation_failure",
+    "model_failure",
+    "environment_failure",
+    "infrastructure_failure",
+    "timeout",
+    "cancelled",
+    "unknown",
+]);
+export const WorkTerminalSchema = z.object({
+    status: z.enum(["completed", "failed", "cancelled", "timeout"]),
+    failureClass: WorkFailureClassSchema.nullable(),
+}).strict().superRefine((terminal, context) => {
+    if (terminal.status === "completed" && terminal.failureClass !== null) {
+        context.addIssue({ code: "custom", message: "Completed Work cannot carry a failure class.", path: ["failureClass"] });
+    }
+    if (terminal.status !== "completed" && terminal.failureClass === null) {
+        context.addIssue({ code: "custom", message: "Non-completed Work requires a failure class.", path: ["failureClass"] });
+    }
+    if (terminal.status === "cancelled" && terminal.failureClass !== "cancelled") {
+        context.addIssue({ code: "custom", message: "Cancelled Work must use the cancelled failure class.", path: ["failureClass"] });
+    }
+    if (terminal.status === "timeout" && terminal.failureClass !== "timeout") {
+        context.addIssue({ code: "custom", message: "Timed-out Work must use the timeout failure class.", path: ["failureClass"] });
+    }
+});
+export const WorkEvidenceReceiptContentSchema = z.object({
+    schemaVersion: z.literal(WORK_EVIDENCE_SCHEMA_VERSION),
+    id: z.string().regex(/^work-evidence-[a-f0-9]{24}$/),
+    source: z.object({
+        surface: z.enum(["desktop", "hosted"]),
+        experience: z.enum(["work", "development"]),
+        opaqueRef: WorkSourceOpaqueRefSchema,
+        revisionHash: ReleaseHashSchema,
+    }).strict(),
+    agentSnapshot: ImmutableReleaseRefSchema.nullable(),
+    model: ModelRefSchema,
+    runtime: z.object({
+        adapterId: ReleaseIdSchema,
+        adapterVersion: ReleaseIdSchema,
+        capabilityRef: EvidenceArtifactRefSchema.nullable(),
+    }).strict(),
+    inputHash: ReleaseHashSchema,
+    terminal: WorkTerminalSchema,
+    trace: z.object({
+        sanitizedRef: EvidenceArtifactRefSchema,
+        traceHash: ReleaseHashSchema,
+        sanitationPolicyVersion: ReleaseIdSchema,
+        incomplete: z.boolean(),
+    }).strict(),
+    outputRefs: z.array(EvidenceArtifactRefSchema).max(10_000),
+    artifactRefs: z.array(EvidenceArtifactRefSchema).max(100_000),
+    validationEvidenceRefs: z.array(EvidenceArtifactRefSchema).max(10_000),
+    interventions: z.object({
+        approvals: z.number().int().nonnegative().max(1_000_000),
+        questions: z.number().int().nonnegative().max(1_000_000),
+        steeringEvents: z.number().int().nonnegative().max(1_000_000),
+        otherUserInterventions: z.number().int().nonnegative().max(1_000_000),
+    }).strict(),
+    timing: z.object({
+        startedAt: ReleaseTimestampSchema,
+        completedAt: ReleaseTimestampSchema,
+        latencyMs: z.number().int().nonnegative().max(31_536_000_000),
+    }).strict(),
+    usage: z.object({
+        promptTokens: z.number().int().nonnegative().nullable(),
+        completionTokens: z.number().int().nonnegative().nullable(),
+        totalTokens: z.number().int().nonnegative().nullable(),
+    }).strict(),
+    costUsd: z.number().nonnegative().max(1_000_000).nullable(),
+    provenance: z.object({
+        consentReceiptRef: EvidenceArtifactRefSchema,
+        consentScope: z.literal("work_process_and_artifacts"),
+        consentGrantedAt: ReleaseTimestampSchema,
+        policyVersion: ReleaseIdSchema,
+        projectorVersion: ReleaseIdSchema,
+        disclosure: z.literal("portable_sanitized"),
+        ownershipScope: z.enum(["personal", "workspace"]),
+        workspaceRef: WorkWorkspaceOpaqueRefSchema.nullable(),
+        participantPolicy: z.enum(["creator_only", "all_participants"]),
+        retention: z.object({
+            policy: z.literal("source_bound"),
+            deleteWithSource: z.literal(true),
+            expiresAt: ReleaseTimestampSchema.nullable(),
+        }).strict(),
+    }).strict(),
+}).strict().superRefine((receipt, context) => {
+    if (receipt.trace.traceHash !== receipt.trace.sanitizedRef.contentHash) {
+        context.addIssue({
+            code: "custom",
+            message: "Sanitized trace reference must bind traceHash.",
+            path: ["trace", "traceHash"],
+        });
+    }
+    const elapsed = Date.parse(receipt.timing.completedAt) - Date.parse(receipt.timing.startedAt);
+    if (elapsed < 0 || elapsed !== receipt.timing.latencyMs) {
+        context.addIssue({
+            code: "custom",
+            message: "latencyMs must equal completedAt minus startedAt.",
+            path: ["timing", "latencyMs"],
+        });
+    }
+    if (receipt.provenance.ownershipScope === "workspace" && receipt.provenance.workspaceRef === null) {
+        context.addIssue({ code: "custom", message: "Workspace-owned evidence requires workspaceRef.", path: ["provenance", "workspaceRef"] });
+    }
+    if (receipt.provenance.ownershipScope === "personal" && receipt.provenance.workspaceRef !== null) {
+        context.addIssue({ code: "custom", message: "Personal evidence cannot carry workspaceRef.", path: ["provenance", "workspaceRef"] });
+    }
+    addDuplicateHashIssues(receipt.outputRefs, ["outputRefs"], context);
+    addDuplicateHashIssues(receipt.artifactRefs, ["artifactRefs"], context);
+    addDuplicateHashIssues(receipt.validationEvidenceRefs, ["validationEvidenceRefs"], context);
+});
+export const WorkEvidenceReceiptSchema = WorkEvidenceReceiptContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const WorkFeedbackVerdictSchema = z.enum([
+    "accepted",
+    "needs_correction",
+    "not_useful",
+]);
+export const WorkFeedbackReasonCodeSchema = z.enum([
+    "correct",
+    "complete",
+    "high_quality",
+    "incorrect",
+    "incomplete",
+    "wrong_format",
+    "unsafe",
+    "stale",
+    "irrelevant",
+    "other",
+]);
+export const WorkFeedbackReceiptContentSchema = z.object({
+    schemaVersion: z.literal(WORK_FEEDBACK_SCHEMA_VERSION),
+    id: z.string().regex(/^work-feedback-[a-f0-9]{24}$/),
+    evidenceReceiptRef: EvidenceArtifactRefSchema,
+    outputRevisionRef: EvidenceArtifactRefSchema.nullable(),
+    verdict: WorkFeedbackVerdictSchema,
+    reasonCodes: z.array(WorkFeedbackReasonCodeSchema).max(16),
+    correctionRef: EvidenceArtifactRefSchema.nullable(),
+    correctedOutputRevisionRef: EvidenceArtifactRefSchema.nullable(),
+    actor: z.literal("user"),
+    createdAt: ReleaseTimestampSchema,
+}).strict().superRefine((feedback, context) => {
+    if (new Set(feedback.reasonCodes).size !== feedback.reasonCodes.length) {
+        context.addIssue({ code: "custom", message: "Feedback reason codes must be unique.", path: ["reasonCodes"] });
+    }
+    if (feedback.verdict !== "needs_correction" && (feedback.correctionRef || feedback.correctedOutputRevisionRef)) {
+        context.addIssue({
+            code: "custom",
+            message: "Only needs_correction feedback may bind correction artifacts.",
+            path: ["verdict"],
+        });
+    }
+});
+export const WorkFeedbackReceiptSchema = WorkFeedbackReceiptContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export function evidenceArtifactId(hash) {
+    return `urn:openpond:artifact:${hash}`;
+}
+export function workSourceOpaqueRef(sourceIdentity) {
+    return `urn:openpond:work:${contentHash(sourceIdentity)}`;
+}
+export function workWorkspaceOpaqueRef(workspaceIdentity) {
+    return `urn:openpond:workspace:${contentHash(workspaceIdentity)}`;
+}
+export function evidenceArtifactRef(input) {
+    return EvidenceArtifactRefSchema.parse({
+        id: evidenceArtifactId(input.contentHash),
+        contentHash: input.contentHash,
+        mediaType: input.mediaType ?? null,
+        sizeBytes: input.sizeBytes ?? null,
+    });
+}
+export function createWorkProcessTrace(input) {
+    const trace = WorkProcessTraceContentSchema.parse(input);
+    return WorkProcessTraceSchema.parse({ ...trace, contentHash: contentHash(trace) });
+}
+export function createWorkEvidenceReceipt(input) {
+    const receipt = WorkEvidenceReceiptContentSchema.parse(input);
+    return WorkEvidenceReceiptSchema.parse({ ...receipt, contentHash: contentHash(receipt) });
+}
+export function createWorkFeedbackReceipt(input, evidence) {
+    const feedback = WorkFeedbackReceiptContentSchema.parse(input);
+    const receipt = WorkFeedbackReceiptSchema.parse({ ...feedback, contentHash: contentHash(feedback) });
+    if (evidence)
+        assertFeedbackTargetsEvidence(receipt, evidence);
+    return receipt;
+}
+export function verifyWorkProcessTrace(value) {
+    return verifyHashedValue(value, WorkProcessTraceSchema, WorkProcessTraceContentSchema);
+}
+export function verifyWorkEvidenceReceipt(value) {
+    return verifyHashedValue(value, WorkEvidenceReceiptSchema, WorkEvidenceReceiptContentSchema);
+}
+export function verifyWorkFeedbackReceipt(value) {
+    return verifyHashedValue(value, WorkFeedbackReceiptSchema, WorkFeedbackReceiptContentSchema);
+}
+export function workEvidenceReceiptRef(receipt) {
+    return evidenceArtifactRef({
+        contentHash: receipt.contentHash,
+        mediaType: "application/vnd.openpond.work-evidence+json",
+        sizeBytes: null,
+    });
+}
+export function assertFeedbackTargetsEvidence(feedback, evidence) {
+    if (feedback.evidenceReceiptRef.contentHash !== evidence.contentHash) {
+        throw new Error("Feedback targets a different Work evidence receipt.");
+    }
+    if (feedback.outputRevisionRef
+        && !evidence.outputRefs.some((output) => output.contentHash === feedback.outputRevisionRef.contentHash)) {
+        throw new Error("Feedback targets an output revision not bound by the Work evidence receipt.");
+    }
+}
+function verifyHashedValue(value, schema, contentSchema) {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        return false;
+    const { contentHash: actual, ...content } = parsed.data;
+    return contentHash(contentSchema.parse(content)) === actual;
+}
+function addDuplicateHashIssues(artifacts, path, context) {
+    const hashes = artifacts.map((artifact) => artifact.contentHash);
+    if (new Set(hashes).size !== hashes.length) {
+        context.addIssue({ code: "custom", message: "Artifact content hashes must be unique.", path });
+    }
+}

package/dist/evidence/eligibility.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import { contentHash, ReleaseHashSchema } from "../common.js";
+import { AttemptReceiptSchema, verifyAttemptReceipt } from "../runs.js";
+import { WORK_EVIDENCE_ELIGIBILITY_SCHEMA_VERSION, WorkFeedbackReceiptSchema, createWorkFeedbackReceipt, verifyWorkEvidenceReceipt, } from "./contracts.js";
+export const WorkEvidencePolicyStateSchema = z.enum([
+    "active",
+    "revoked",
+    "deleted",
+    "expired",
+]);
+export const WorkEvidenceUseSchema = z.enum([
+    "discovery_only",
+    "eval_candidate",
+    "demonstration_candidate",
+    "preference_candidate",
+    "reward_candidate",
+]);
+export const WorkEvidenceBlockerCodeSchema = z.enum([
+    "invalid_evidence_receipt",
+    "consent_revoked",
+    "source_deleted",
+    "retention_expired",
+    "trace_incomplete",
+    "terminal_not_completed",
+    "infrastructure_failure",
+    "agent_snapshot_missing",
+    "input_not_reconstructable",
+    "environment_not_reconstructable",
+    "output_missing",
+    "validation_evidence_missing",
+    "verifier_missing",
+    "accepted_feedback_missing",
+    "correction_pair_missing",
+    "attempt_receipt_missing",
+    "attempt_receipt_invalid",
+    "attempt_receipt_unbound",
+    "attempt_not_reward_eligible",
+]);
+export const WorkEvidenceDecisionSchema = z.object({
+    eligible: z.boolean(),
+    blockers: z.array(WorkEvidenceBlockerCodeSchema).max(32),
+}).strict().superRefine((decision, context) => {
+    if (decision.eligible === (decision.blockers.length > 0)) {
+        context.addIssue({ code: "custom", message: "Eligibility must be the inverse of blocker presence." });
+    }
+});
+export const WorkEvidenceEligibilityContentSchema = z.object({
+    schemaVersion: z.literal(WORK_EVIDENCE_ELIGIBILITY_SCHEMA_VERSION),
+    evidenceReceiptHash: ReleaseHashSchema,
+    policyState: WorkEvidencePolicyStateSchema,
+    decisions: z.object({
+        discovery_only: WorkEvidenceDecisionSchema,
+        eval_candidate: WorkEvidenceDecisionSchema,
+        demonstration_candidate: WorkEvidenceDecisionSchema,
+        preference_candidate: WorkEvidenceDecisionSchema,
+        reward_candidate: WorkEvidenceDecisionSchema,
+    }).strict(),
+}).strict();
+export const WorkEvidenceEligibilitySchema = WorkEvidenceEligibilityContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export function classifyWorkEvidence(input) {
+    const evidenceValid = verifyWorkEvidenceReceipt(input.evidence);
+    const validFeedback = (input.feedback ?? []).filter((feedback) => {
+        if (!WorkFeedbackReceiptSchema.safeParse(feedback).success)
+            return false;
+        try {
+            createWorkFeedbackReceipt(withoutHash(feedback), input.evidence);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    const policyBlockers = policyStateBlockers(input.policyState);
+    const discovery = [
+        ...(!evidenceValid ? ["invalid_evidence_receipt"] : []),
+        ...policyBlockers,
+    ];
+    const evaluation = [
+        ...discovery,
+        ...(input.evidence.trace.incomplete ? ["trace_incomplete"] : []),
+        ...(!input.evidence.agentSnapshot ? ["agent_snapshot_missing"] : []),
+        ...(!input.reconstructability.input ? ["input_not_reconstructable"] : []),
+        ...(!input.reconstructability.environment ? ["environment_not_reconstructable"] : []),
+        ...(!input.evidence.outputRefs.length ? ["output_missing"] : []),
+        ...(!input.reconstructability.verifier ? ["verifier_missing"] : []),
+    ];
+    const completed = input.evidence.terminal.status === "completed";
+    const accepted = validFeedback.some((feedback) => feedback.verdict === "accepted");
+    const demonstration = [
+        ...evaluation,
+        ...(!completed ? ["terminal_not_completed"] : []),
+        ...(input.evidence.terminal.failureClass === "infrastructure_failure" ? ["infrastructure_failure"] : []),
+        ...(!input.evidence.validationEvidenceRefs.length ? ["validation_evidence_missing"] : []),
+        ...(!accepted ? ["accepted_feedback_missing"] : []),
+    ];
+    const acceptedOutputs = new Set(validFeedback
+        .filter((feedback) => feedback.verdict === "accepted")
+        .flatMap((feedback) => feedback.outputRevisionRef?.contentHash ?? []));
+    const correctionPair = validFeedback.some((feedback) => feedback.verdict === "needs_correction"
+        && feedback.outputRevisionRef !== null
+        && feedback.correctedOutputRevisionRef !== null
+        && acceptedOutputs.has(feedback.correctedOutputRevisionRef.contentHash));
+    const preference = [
+        ...evaluation,
+        ...(!correctionPair ? ["correction_pair_missing"] : []),
+    ];
+    const replay = input.replay ?? null;
+    const replayParsed = replay ? AttemptReceiptSchema.safeParse(replay.attemptReceipt) : null;
+    const replayValid = replayParsed?.success === true && verifyAttemptReceipt(replayParsed.data);
+    const replayBound = replay?.sourceEvidenceReceiptHash === input.evidence.contentHash;
+    const replayEligible = replayValid
+        && replayBound
+        && replay.attemptReceipt.terminal
+        && replay.attemptReceipt.failureClass !== "infrastructure_failure"
+        && replay.attemptReceipt.failureClass !== "timeout"
+        && replay.attemptReceipt.failureClass !== "cancelled"
+        && replay.attemptReceipt.metadata.rewardEligible === true
+        && typeof replay.attemptReceipt.metadata.score === "number";
+    const reward = [
+        ...discovery,
+        ...(!replay ? ["attempt_receipt_missing"] : []),
+        ...(replay && !replayValid ? ["attempt_receipt_invalid"] : []),
+        ...(replay && !replayBound ? ["attempt_receipt_unbound"] : []),
+        ...(replay && replayValid && replayBound && !replayEligible ? ["attempt_not_reward_eligible"] : []),
+    ];
+    const report = WorkEvidenceEligibilityContentSchema.parse({
+        schemaVersion: WORK_EVIDENCE_ELIGIBILITY_SCHEMA_VERSION,
+        evidenceReceiptHash: input.evidence.contentHash,
+        policyState: input.policyState,
+        decisions: {
+            discovery_only: decision(discovery),
+            eval_candidate: decision(evaluation),
+            demonstration_candidate: decision(demonstration),
+            preference_candidate: decision(preference),
+            reward_candidate: decision(reward),
+        },
+    });
+    return WorkEvidenceEligibilitySchema.parse({ ...report, contentHash: contentHash(report) });
+}
+export function verifyWorkEvidenceEligibility(value) {
+    const parsed = WorkEvidenceEligibilitySchema.safeParse(value);
+    if (!parsed.success)
+        return false;
+    const { contentHash: actual, ...report } = parsed.data;
+    return contentHash(WorkEvidenceEligibilityContentSchema.parse(report)) === actual;
+}
+export function eligibleEvidenceUses(report) {
+    return WorkEvidenceUseSchema.options.filter((use) => report.decisions[use].eligible);
+}
+function policyStateBlockers(state) {
+    if (state === "revoked")
+        return ["consent_revoked"];
+    if (state === "deleted")
+        return ["source_deleted"];
+    if (state === "expired")
+        return ["retention_expired"];
+    return [];
+}
+function decision(blockers) {
+    const unique = [...new Set(blockers)];
+    return WorkEvidenceDecisionSchema.parse({ eligible: unique.length === 0, blockers: unique });
+}
+function withoutHash(value) {
+    const { contentHash: _contentHash, ...content } = value;
+    return content;
+}

package/dist/evidence/index.js

@@ -0,0 +1,4 @@
+export * from "./authoring.js";
+export * from "./conformance.js";
+export * from "./contracts.js";
+export * from "./eligibility.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./common.js";
+export * from "./evidence/index.js";
 export * from "./graders.js";
 export * from "./harness.js";
 export * from "./runs.js";

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

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAC7C,eAAO,MAAM,wBAAwB,YAAc,CAAC;AACpD,eAAO,MAAM,eAAe,aAAoC,CAAC;AACjE,eAAO,MAAM,iBAAiB,aAAqC,CAAC;AACpE,eAAO,MAAM,sBAAsB,aAAwC,CAAC;AAC5E,eAAO,MAAM,cAAc,sDAAgD,CAAC;AAE5E,eAAO,MAAM,yBAAyB;;;kBAG3B,CAAC;AAEZ,eAAO,MAAM,uBAAuB;;;;;;;;;;;kBAOzB,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;kBAK5B,CAAC;AAEZ,eAAO,MAAM,kBAAkB;;;;;;;EAO7B,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAEzD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAExG;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI/G;AAkBD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAC7C,eAAO,MAAM,wBAAwB,YAAc,CAAC;AACpD,eAAO,MAAM,eAAe,aAAoC,CAAC;AACjE,eAAO,MAAM,iBAAiB,aAAqC,CAAC;AACpE,eAAO,MAAM,sBAAsB,aAAwC,CAAC;AAC5E,eAAO,MAAM,cAAc,sDAAgD,CAAC;AAE5E,eAAO,MAAM,yBAAyB;;;kBAG3B,CAAC;AAEZ,eAAO,MAAM,uBAAuB;;;;;;;;;;;kBAOzB,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;kBAK5B,CAAC;AAEZ,eAAO,MAAM,kBAAkB;;;;;;;EAO7B,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAEzD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAExG;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI/G;AAkBD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../src/conformance.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}

package/dist/types/evidence/authoring.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { type WorkEvidenceReceipt } from "./contracts.js";
+import { type WorkEvidenceEligibility } from "./eligibility.js";
+export declare const WorkEvidenceAuthoringInputSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.workEvidenceAuthoringInput.v1">;
+    evidenceReceiptRef: z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    inputHash: z.ZodString;
+    agentSnapshot: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    sanitizedTraceRef: z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    outputRefs: z.ZodArray<z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    validationEvidenceRefs: z.ZodArray<z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    incomplete: z.ZodBoolean;
+    evalCandidate: z.ZodBoolean;
+    blockerCodes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare function toWorkEvidenceAuthoringInput(evidenceInput: WorkEvidenceReceipt, eligibilityInput: WorkEvidenceEligibility): WorkEvidenceAuthoringInput;
+export type WorkEvidenceAuthoringInput = z.infer<typeof WorkEvidenceAuthoringInputSchema>;
+//# sourceMappingURL=authoring.d.ts.map

package/dist/types/evidence/authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../../../../../src/evidence/authoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAiC,KAAK,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE/F,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWlC,CAAC;AAEZ,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,mBAAmB,EAClC,gBAAgB,EAAE,uBAAuB,GACxC,0BAA0B,CAuB5B;AAED,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC"}