@openpond/evals 0.3.0 → 0.4.1

package/dist/compatibility.js

@@ -1,5 +1,5 @@
-import { assertContentHash, contentHash } from "./common.js";
-import { HarnessReleaseSchema, } from "./harness.js";
+import { assertContentHash, contentHash } from "@openpond/harness";
+import { HarnessReleaseSchema, } from "@openpond/harness";
 import { createHarnessCompatibilityReceipt, } from "./runs.js";
 import { TasksetReleaseSchema, } from "./tasksets.js";
 export function createVerifiedHarnessCompatibilityReceipt(input) {

package/dist/conformance.js

@@ -1,5 +1,4 @@
-import { contentHash, withContentHash } from "./common.js";
-import { createAgentSnapshot, createHarnessRelease } from "./harness.js";
+import { contentHash, createAgentSnapshot, createHarnessRelease, withContentHash, } from "@openpond/harness";
 import { createRunManifest } from "./runs.js";
 import { TasksetReleaseSchema } from "./tasksets.js";
 const EMPTY_HASH = contentHash("");

package/dist/evidence/authoring.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ImmutableReleaseRefSchema, ReleaseHashSchema } from "../common.js";
+import { ImmutableReleaseRefSchema, ReleaseHashSchema } from "@openpond/harness";
 import { EvidenceArtifactRefSchema, WorkEvidenceReceiptSchema, evidenceArtifactRef, } from "./contracts.js";
 import { WorkEvidenceEligibilitySchema } from "./eligibility.js";
 export const WorkEvidenceAuthoringInputSchema = z.object({

package/dist/evidence/conformance.js

@@ -1,4 +1,4 @@
-import { canonicalJson, contentHash } from "../common.js";
+import { canonicalJson, contentHash } from "@openpond/harness";
 import { createWorkEvidenceReceipt, createWorkFeedbackReceipt, createWorkProcessTrace, evidenceArtifactRef, workEvidenceReceiptRef, workSourceOpaqueRef, } from "./contracts.js";
 import { classifyWorkEvidence } from "./eligibility.js";
 const startedAt = "2026-08-04T12:00:00.000Z";

package/dist/evidence/contracts.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "../common.js";
-import { ModelRefSchema } from "../runs.js";
+import { ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, ModelRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "@openpond/harness";
 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";

package/dist/evidence/eligibility.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { contentHash, ReleaseHashSchema } from "../common.js";
+import { contentHash, ReleaseHashSchema } from "@openpond/harness";
 import { AttemptReceiptSchema, verifyAttemptReceipt } from "../runs.js";
 import { WORK_EVIDENCE_ELIGIBILITY_SCHEMA_VERSION, WorkFeedbackReceiptSchema, createWorkFeedbackReceipt, verifyWorkEvidenceReceipt, } from "./contracts.js";
 export const WorkEvidencePolicyStateSchema = z.enum([

package/dist/graders.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FailureClassSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash } from "./common.js";
+import { FailureClassSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash } from "@openpond/harness";
 export const GraderEvidenceContentSchema = z.object({
     schemaVersion: z.literal("openpond.graderEvidence.v1"),
     graderId: ReleaseIdSchema,

package/dist/harness.js

@@ -1,71 +1,6 @@
-import { z } from "zod";
-import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableAssetRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash, } from "./common.js";
-import { ToolDeclarationSchema } from "./tasksets.js";
-import { createAttemptReceipt } from "./runs.js";
-export const PortabilityReportSchema = z.object({
-    portable: z.boolean(),
-    blockers: z.array(z.string().trim().min(1).max(2_000)).max(1_000),
-    localOnlyAssetRefs: z.array(ReleaseIdSchema).max(10_000),
-    hostPrivateAssetRefs: z.array(ReleaseIdSchema).max(10_000),
-}).strict();
-export const AgentSnapshotContentSchema = z.object({
-    schemaVersion: z.literal("openpond.agentSnapshot.v2"),
-    id: ReleaseIdSchema,
-    sourceRelease: ImmutableReleaseRefSchema.nullable(),
-    instructions: z.array(ImmutableAssetRefSchema).max(10_000),
-    skills: z.array(ImmutableAssetRefSchema).max(10_000),
-    agents: z.array(ImmutableAssetRefSchema).max(10_000),
-    toolDeclarations: z.array(ToolDeclarationSchema).max(200),
-    capabilityRequirements: z.array(z.object({
-        id: ReleaseIdSchema,
-        required: z.boolean(),
-        scopes: z.array(z.string().trim().min(1).max(500)).max(100),
-    }).strict()).max(200),
-    dependencyLock: ImmutableAssetRefSchema,
-    portability: PortabilityReportSchema,
-    metadata: MetadataSchema,
-}).strict();
-export const AgentSnapshotSchema = AgentSnapshotContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-export const LifecycleContractSchema = z.object({
-    create: z.literal(true),
-    reset: z.literal(true),
-    step: z.literal(true),
-    collect: z.literal(true),
-    destroy: z.literal(true),
-    resetScope: z.enum(["task", "attempt"]),
-}).strict();
-export const GraderInterfaceContractSchema = z.object({
-    visibleEvidence: z.array(ReleaseIdSchema).max(1_000),
-    privilegedEvidence: z.array(ReleaseIdSchema).max(1_000),
-    privateVerifierIsolation: z.boolean(),
-}).strict();
-export const HarnessReleaseContentSchema = z.object({
-    schemaVersion: z.literal("openpond.harnessRelease.v2"),
-    id: ReleaseIdSchema,
-    agentSnapshot: ImmutableReleaseRefSchema,
-    program: ImmutableAssetRefSchema,
-    tools: z.array(ToolDeclarationSchema).max(200),
-    lifecycle: LifecycleContractSchema,
-    graderInterface: GraderInterfaceContractSchema,
-    files: z.array(ImmutableAssetRefSchema).max(100_000),
-    metadata: MetadataSchema,
-}).strict();
-export const HarnessReleaseSchema = HarnessReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
-export const ModelActionSchema = z.object({
-    id: ReleaseIdSchema,
-    turn: z.number().int().nonnegative(),
-    kind: z.enum(["message", "tool_call", "terminal"]),
-    name: ReleaseIdSchema.nullable(),
-    arguments: z.record(z.string(), z.unknown()),
-    content: z.string().max(1_000_000).nullable(),
-}).strict();
-export const ToolObservationSchema = z.object({
-    actionId: ReleaseIdSchema,
-    turn: z.number().int().nonnegative(),
-    terminal: z.boolean(),
-    output: z.record(z.string(), z.unknown()),
-    artifactRefs: z.array(ImmutableArtifactRefSchema).max(100_000),
-}).strict();
+import { HarnessTraceSchema, ModelActionSchema, ToolObservationSchema, contentHash, } from "@openpond/harness";
+import { createAttemptReceipt, } from "./runs.js";
+export * from "@openpond/harness/harness";
 export async function executeRuntimeProtocol(input) {
     const now = input.now ?? (() => new Date().toISOString());
     const startedAt = now();
@@ -84,12 +19,25 @@ export async function executeRuntimeProtocol(input) {
     let output = {};
     let artifactRefs = [];
     const event = (type, payload, metadata = {}) => {
-        events.push({ sequence: sequence++, type, payloadHash: contentHash(payload), metadata });
+        events.push({
+            sequence: sequence++,
+            type,
+            payloadHash: contentHash(payload),
+            metadata,
+        });
     };
     try {
-        lease = await input.runtime.create({ manifest: input.manifest, taskId: input.taskId, seed: input.seed, signal: controller.signal });
+        lease = await input.runtime.create({
+            manifest: input.manifest,
+            taskId: input.taskId,
+            seed: input.seed,
+            signal: controller.signal,
+        });
         event("created", { leaseId: lease.id });
-        await input.runtime.reset(lease, { seed: input.seed, signal: controller.signal });
+        await input.runtime.reset(lease, {
+            seed: input.seed,
+            signal: controller.signal,
+        });
         event("reset", { seed: input.seed });
         for (const candidate of input.actions.slice(0, input.manifest.limits.maxTurns)) {
             if (controller.signal.aborted)
@@ -152,12 +100,23 @@ export async function executeRuntimeProtocol(input) {
         failureClass,
         output,
     };
-    const trace = HarnessTraceSchema.parse({ ...traceContent, contentHash: contentHash(traceContent) });
+    const trace = HarnessTraceSchema.parse({
+        ...traceContent,
+        contentHash: contentHash(traceContent),
+    });
     const completedAt = now();
     const receipt = createAttemptReceipt({
         schemaVersion: "openpond.attemptReceipt.v1",
-        id: `attempt-${contentHash([input.manifest.contentHash, input.taskId, input.seed, trace.contentHash]).slice(0, 24)}`,
-        runManifest: { id: input.manifest.id, contentHash: input.manifest.contentHash },
+        id: `attempt-${contentHash([
+            input.manifest.contentHash,
+            input.taskId,
+            input.seed,
+            trace.contentHash,
+        ]).slice(0, 24)}`,
+        runManifest: {
+            id: input.manifest.id,
+            contentHash: input.manifest.contentHash,
+        },
         taskId: input.taskId,
         seed: input.seed,
         terminal,
@@ -175,30 +134,3 @@ export async function executeRuntimeProtocol(input) {
     });
     return { receipt, trace, output };
 }
-export function createAgentSnapshot(input) {
-    const content = AgentSnapshotContentSchema.parse(input);
-    return AgentSnapshotSchema.parse({ ...content, contentHash: contentHash(content) });
-}
-export function createHarnessRelease(input) {
-    const content = HarnessReleaseContentSchema.parse(input);
-    return HarnessReleaseSchema.parse({ ...content, contentHash: contentHash(content) });
-}
-export const HarnessLifecycleEventSchema = z.object({
-    sequence: z.number().int().nonnegative(),
-    type: z.enum(["created", "reset", "action", "observation", "terminal", "failure", "collected", "destroyed"]),
-    payloadHash: ReleaseHashSchema,
-    metadata: MetadataSchema,
-}).strict();
-export const HarnessTraceSchema = z.object({
-    schemaVersion: z.literal("openpond.harnessTrace.v1"),
-    manifest: ImmutableReleaseRefSchema,
-    taskId: ReleaseIdSchema,
-    seed: z.string().trim().min(1).max(500),
-    events: z.array(HarnessLifecycleEventSchema).max(1_000_000),
-    actions: z.array(ModelActionSchema).max(100_000),
-    observations: z.array(ToolObservationSchema).max(100_000),
-    terminal: z.boolean(),
-    failureClass: FailureClassSchema.nullable(),
-    output: z.record(z.string(), z.unknown()),
-    contentHash: ReleaseHashSchema,
-}).strict();

package/dist/index.js

@@ -1,9 +1,9 @@
-export * from "./common.js";
 export * from "./compatibility.js";
+export * from "./benchmarks.js";
 export * from "./evidence/index.js";
 export * from "./graders.js";
 export * from "./harness.js";
-export * from "./harness-improvements.js";
-export * from "./harness-workspaces.js";
 export * from "./runs.js";
+export * from "./model-improvement-qualification.js";
+export * from "./review-conformance.js";
 export * from "./tasksets.js";

package/dist/model-improvement-qualification.js

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import { HarnessReviewSourcePolicyRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ModelRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "@openpond/harness";
+const BoundedTextSchema = z.string().trim().min(1).max(100_000);
+export const ModelImprovementDecisionSchema = z.enum([
+    "no_training",
+    "sft",
+    "preference",
+    "rl",
+]);
+export const ModelImprovementSignalSchema = z
+    .object({
+    kind: z.enum(["none", "demonstrations", "chosen_rejected", "scalar_reward"]),
+    strength: z.enum(["absent", "weak", "usable"]),
+    calibrated: z.boolean(),
+    confounded: z.boolean(),
+    variance: z.number().finite().nonnegative().nullable(),
+    evidenceRefs: z.array(ImmutableReleaseRefSchema).max(100_000),
+})
+    .strict();
+export const ModelImprovementQualificationReceiptContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.modelImprovementQualificationReceipt.v1"),
+    id: ReleaseIdSchema,
+    review: ImmutableReleaseRefSchema,
+    harnessRelease: ImmutableReleaseRefSchema,
+    tasksetRelease: ImmutableReleaseRefSchema.nullable(),
+    baselineEvaluation: ImmutableReleaseRefSchema.nullable(),
+    model: ModelRefSchema,
+    environmentHash: ReleaseHashSchema.nullable(),
+    toolContractHash: ReleaseHashSchema.nullable(),
+    permissionContractHash: ReleaseHashSchema.nullable(),
+    policyHash: ReleaseHashSchema.nullable(),
+    verifierRef: ImmutableReleaseRefSchema.nullable(),
+    sourcePolicies: z.array(HarnessReviewSourcePolicyRefSchema).max(10_000),
+    trainingEvidenceRefs: z.array(ImmutableReleaseRefSchema).max(100_000),
+    frozenEvaluationEvidenceRefs: z.array(ImmutableReleaseRefSchema).max(100_000),
+    privacyApproval: ImmutableReleaseRefSchema.nullable(),
+    budgetApproval: ImmutableReleaseRefSchema.nullable(),
+    maximumCostUsd: z.number().finite().nonnegative(),
+    signal: ModelImprovementSignalSchema,
+    decision: ModelImprovementDecisionSchema,
+    reasons: z.array(BoundedTextSchema).min(1).max(100),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((receipt, context) => {
+    const trainingKeys = new Set(receipt.trainingEvidenceRefs.map(refKey));
+    if (receipt.frozenEvaluationEvidenceRefs.some((reference) => trainingKeys.has(refKey(reference)))) {
+        context.addIssue({
+            code: "custom",
+            message: "frozen Evaluation evidence cannot be used as training evidence",
+            path: ["frozenEvaluationEvidenceRefs"],
+        });
+    }
+    if (receipt.decision === "no_training")
+        return;
+    const missingGate = !receipt.tasksetRelease ||
+        !receipt.baselineEvaluation ||
+        !receipt.environmentHash ||
+        !receipt.toolContractHash ||
+        !receipt.permissionContractHash ||
+        !receipt.policyHash ||
+        !receipt.verifierRef ||
+        !receipt.privacyApproval ||
+        !receipt.budgetApproval ||
+        receipt.sourcePolicies.length === 0 ||
+        receipt.sourcePolicies.some((policy) => policy.state !== "authorized") ||
+        receipt.trainingEvidenceRefs.length === 0 ||
+        receipt.signal.strength !== "usable" ||
+        !receipt.signal.calibrated ||
+        receipt.signal.confounded;
+    if (missingGate) {
+        context.addIssue({
+            code: "custom",
+            message: "qualified model improvement requires frozen lineage, authorized signal, privacy, and budget gates",
+        });
+    }
+    if (receipt.decision === "sft" &&
+        receipt.signal.kind !== "demonstrations") {
+        context.addIssue({
+            code: "custom",
+            message: "SFT qualification requires demonstration signal",
+            path: ["signal", "kind"],
+        });
+    }
+    if (receipt.decision === "preference" &&
+        receipt.signal.kind !== "chosen_rejected") {
+        context.addIssue({
+            code: "custom",
+            message: "preference qualification requires chosen/rejected signal",
+            path: ["signal", "kind"],
+        });
+    }
+    if (receipt.decision === "rl" &&
+        (receipt.signal.kind !== "scalar_reward" ||
+            receipt.signal.variance === null ||
+            receipt.signal.variance <= 0)) {
+        context.addIssue({
+            code: "custom",
+            message: "RL qualification requires a usable scalar reward with variance",
+            path: ["signal"],
+        });
+    }
+});
+export const ModelImprovementQualificationReceiptSchema = ModelImprovementQualificationReceiptContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export function createModelImprovementQualificationReceipt(input) {
+    const content = ModelImprovementQualificationReceiptContentSchema.parse(input);
+    return ModelImprovementQualificationReceiptSchema.parse({
+        ...content,
+        contentHash: contentHash(content),
+    });
+}
+export function verifyModelImprovementQualificationReceipt(value) {
+    const parsed = ModelImprovementQualificationReceiptSchema.safeParse(value);
+    if (!parsed.success)
+        return false;
+    const { contentHash: actual, ...content } = parsed.data;
+    return (contentHash(ModelImprovementQualificationReceiptContentSchema.parse(content)) === actual);
+}
+function refKey(reference) {
+    return `${reference.id}:${reference.contentHash}`;
+}

package/dist/review-conformance.js

@@ -0,0 +1,209 @@
+import { contentHash, createHarnessEvaluationReviewReceipt, } from "@openpond/harness";
+import { createModelImprovementQualificationReceipt } from "./model-improvement-qualification.js";
+const createdAt = "2026-08-08T12:00:00.000Z";
+const harnessRelease = ref("harness-release");
+const sourcePolicy = {
+    policy: ref("source-policy"),
+    state: "authorized",
+    checkedAt: createdAt,
+};
+const evidence = (id, kind) => ({
+    evidence: ref(id),
+    kind,
+    sourceRef: `source-${id}`,
+    sourcePolicy,
+    occurrenceKey: contentHash(`occurrence-${id}`),
+    occurredAt: createdAt,
+});
+const watermark = {
+    cursor: contentHash("review-watermark"),
+    throughCreatedAt: createdAt,
+};
+const claim = (family, count = 3) => ({
+    fingerprint: contentHash(`claim-${family}`),
+    recurrenceFamily: family,
+    statement: `The ${family} behavior remains unresolved after smaller-layer triage.`,
+    independentOccurrences: count,
+    unresolvedOccurrences: count,
+});
+const noAction = createHarnessEvaluationReviewReceipt({
+    schemaVersion: "openpond.harnessEvaluationReviewReceipt.v1",
+    id: "review-no-action",
+    ownerScope: { kind: "personal", id: "owner-1" },
+    workspaceRef: "workspace-1",
+    harnessRelease,
+    previousWatermark: null,
+    nextWatermark: watermark,
+    selectedEvidence: [],
+    excludedEvidence: [],
+    claim: null,
+    classification: "no_action",
+    triage: [],
+    reason: "The bounded evidence window contains no unresolved reusable claim.",
+    nextAuthority: "none",
+    maxEstimatedCostUsd: 0,
+    tasksetProposal: null,
+    evaluation: null,
+    trainingQualification: null,
+    policyVersion: "harness-review-policy-v1",
+    createdAt,
+    metadata: {},
+});
+const runtime = createHarnessEvaluationReviewReceipt({
+    ...withoutHash(noAction),
+    id: "review-runtime",
+    selectedEvidence: [evidence("runtime-failure", "observation")],
+    claim: claim("runtime-transport-failure", 1),
+    classification: "runtime",
+    triage: [
+        {
+            layer: "runtime",
+            status: "unresolved",
+            reason: "The adapter failed before model policy could affect the result.",
+            evidenceRefs: [ref("runtime-failure")],
+        },
+    ],
+    reason: "A deterministic runtime regression is the smallest correct fix.",
+    nextAuthority: "runtime_service",
+});
+const product = createHarnessEvaluationReviewReceipt({
+    ...withoutHash(noAction),
+    id: "review-product",
+    selectedEvidence: [evidence("product-routing", "route_decision")],
+    claim: claim("product-routing-defect", 1),
+    classification: "product",
+    triage: [
+        {
+            layer: "product",
+            status: "unresolved",
+            reason: "The product selected an unrelated Skill for an ordinary Work turn.",
+            evidenceRefs: [ref("product-routing")],
+        },
+    ],
+    reason: "Product routing must be corrected before behavioral Evaluation.",
+    nextAuthority: "product_team",
+});
+const taskset = createHarnessEvaluationReviewReceipt({
+    ...withoutHash(noAction),
+    id: "review-taskset",
+    selectedEvidence: [
+        evidence("failure-1", "work_outcome"),
+        evidence("failure-2", "work_outcome"),
+        evidence("failure-3", "work_outcome"),
+    ],
+    claim: claim("search-budget-allocation"),
+    classification: "taskset",
+    triage: [
+        {
+            layer: "harness",
+            status: "unresolved",
+            reason: "The active research Skill did not resolve three independent failures.",
+            evidenceRefs: [ref("failure-1"), ref("failure-2"), ref("failure-3")],
+        },
+    ],
+    reason: "The repeated behavioral claim now needs controlled measurement.",
+    nextAuthority: "human_review",
+    tasksetProposal: ref("taskset-proposal"),
+    maxEstimatedCostUsd: 2,
+});
+const blockedRl = createModelImprovementQualificationReceipt({
+    schemaVersion: "openpond.modelImprovementQualificationReceipt.v1",
+    id: "qualification-rl-blocked",
+    review: reference(taskset),
+    harnessRelease,
+    tasksetRelease: ref("taskset-release"),
+    baselineEvaluation: ref("baseline-evaluation"),
+    model: modelRef(),
+    environmentHash: contentHash("environment"),
+    toolContractHash: contentHash("tools"),
+    permissionContractHash: contentHash("permissions"),
+    policyHash: contentHash("policy"),
+    verifierRef: ref("verifier"),
+    sourcePolicies: [sourcePolicy],
+    trainingEvidenceRefs: [ref("training-evidence")],
+    frozenEvaluationEvidenceRefs: [ref("frozen-evidence")],
+    privacyApproval: ref("privacy-approval"),
+    budgetApproval: ref("budget-approval"),
+    maximumCostUsd: 25,
+    signal: {
+        kind: "scalar_reward",
+        strength: "weak",
+        calibrated: true,
+        confounded: false,
+        variance: 0,
+        evidenceRefs: [ref("reward-audit")],
+    },
+    decision: "no_training",
+    reasons: ["The observed reward is constant and cannot support RL."],
+    createdAt,
+    metadata: { blockedMethod: "rl" },
+});
+const qualifiedRl = createModelImprovementQualificationReceipt({
+    ...withoutHash(blockedRl),
+    id: "qualification-rl-qualified",
+    signal: {
+        kind: "scalar_reward",
+        strength: "usable",
+        calibrated: true,
+        confounded: false,
+        variance: 0.18,
+        evidenceRefs: [ref("reward-audit")],
+    },
+    decision: "rl",
+    reasons: [
+        "The frozen baseline has usable variance and a calibrated sequential reward.",
+    ],
+});
+const modelImprovement = createHarnessEvaluationReviewReceipt({
+    ...withoutHash(noAction),
+    id: "review-model-improvement",
+    selectedEvidence: [
+        evidence("baseline-evaluation", "evaluation"),
+        evidence("qualification-rl-qualified", "training_qualification"),
+    ],
+    claim: claim("search-budget-allocation"),
+    classification: "model_improvement",
+    triage: [
+        {
+            layer: "model",
+            status: "unresolved",
+            reason: "Harness, runtime, product, retrieval, and tool triage left a qualified sequential policy gap.",
+            evidenceRefs: [ref("baseline-evaluation"), reference(qualifiedRl)],
+        },
+    ],
+    reason: "The qualified claim may proceed to a separately approved managed-training plan.",
+    nextAuthority: "training_system",
+    tasksetProposal: ref("taskset-proposal"),
+    evaluation: ref("baseline-evaluation"),
+    trainingQualification: reference(qualifiedRl),
+    maxEstimatedCostUsd: 25,
+});
+export const harnessEvaluationReviewConformance = {
+    noAction,
+    runtime,
+    product,
+    taskset,
+    blockedRl,
+    qualifiedRl,
+    modelImprovement,
+};
+function ref(id) {
+    return { id, contentHash: contentHash(id) };
+}
+function reference(value) {
+    return { id: value.id, contentHash: value.contentHash };
+}
+function withoutHash(value) {
+    const { contentHash: _contentHash, ...content } = value;
+    return content;
+}
+function modelRef() {
+    return {
+        provider: "openpond",
+        model: "openpond-chat",
+        revision: "model-revision-1",
+        artifactHash: contentHash("model-artifact"),
+        tokenizerRevision: "tokenizer-1",
+        chatTemplateHash: contentHash("chat-template"),
+    };
+}

package/dist/runs.js

@@ -1,13 +1,5 @@
 import { z } from "zod";
-import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, assertContentHash, contentHash, } from "./common.js";
-export const ModelRefSchema = z.object({
-    provider: ReleaseIdSchema,
-    model: ReleaseIdSchema,
-    revision: z.string().trim().min(1).max(500).nullable().default(null),
-    artifactHash: ReleaseHashSchema.nullable().default(null),
-    tokenizerRevision: z.string().trim().min(1).max(500).nullable().default(null),
-    chatTemplateHash: ReleaseHashSchema.nullable().default(null),
-}).strict();
+import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ModelRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, assertContentHash, contentHash, } from "@openpond/harness";
 export const RuntimeTargetBindingSchema = z.object({
     adapterId: ReleaseIdSchema,
     placement: z.enum(["local", "remote", "colocated", "provider_native"]),

package/dist/tasksets.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ImmutableAssetRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, assertContentHash, contentHash, } from "./common.js";
+import { CapabilityRequirementSchema, ImmutableAssetRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, ToolDeclarationSchema, assertContentHash, contentHash, } from "@openpond/harness";
 export const TaskSplitSchema = z.enum(["train", "validation", "test", "frozen_eval"]);
 export const PolicyBoundarySchema = z.object({
     policyVisibleFields: z.array(ReleaseIdSchema).max(1_000).default([]),
@@ -7,20 +7,6 @@ export const PolicyBoundarySchema = z.object({
     hiddenGraderRefs: z.array(ReleaseIdSchema).max(1_000).default([]),
     connectedAppScopes: z.array(ReleaseIdSchema).max(100).default([]),
 }).strict();
-export const ToolDeclarationSchema = z.object({
-    name: z.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
-    description: z.string().trim().min(1).max(2_000),
-    inputSchema: z.record(z.string(), z.unknown()),
-    inputSchemaHash: ReleaseHashSchema,
-    sideEffect: z.enum(["read", "write"]),
-    timeoutMs: z.number().int().positive().max(3_600_000),
-}).strict();
-export const CapabilityRequirementSchema = z.object({
-    id: ReleaseIdSchema,
-    required: z.boolean(),
-    scopes: z.array(z.string().trim().min(1).max(500)).max(100).default([]),
-    portability: z.enum(["portable", "host_adapter", "local_only", "hosted_only"]),
-}).strict();
 export const EnvironmentContractSchema = z.object({
     protocolVersion: z.literal("openpond.environment.v1"),
     kind: z.enum(["text", "agent", "work", "custom_program"]),
@@ -160,3 +146,4 @@ export function trainingPolicyTaskViews(taskset) {
         .filter((task) => task.split !== "frozen_eval")
         .map(policyTaskView);
 }
+export { CapabilityRequirementSchema, ToolDeclarationSchema, } from "@openpond/harness";