@openpond/evals 0.2.0 → 0.4.0

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, 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"]),
@@ -69,6 +61,21 @@ export const EvaluationResultContentSchema = z.object({
     metadata: MetadataSchema,
 }).strict();
 export const EvaluationResultSchema = EvaluationResultContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export const HarnessCompatibilityReceiptContentSchema = z.object({
+    schemaVersion: z.literal("openpond.harnessCompatibility.v1"),
+    id: ReleaseIdSchema,
+    baseHarnessRelease: ImmutableReleaseRefSchema,
+    candidateHarnessRelease: ImmutableReleaseRefSchema,
+    tasksetRelease: ImmutableReleaseRefSchema,
+    environmentHash: ReleaseHashSchema,
+    toolContractHash: ReleaseHashSchema,
+    policyHash: ReleaseHashSchema,
+    graderInterfaceHash: ReleaseHashSchema,
+    metadata: MetadataSchema,
+}).strict();
+export const HarnessCompatibilityReceiptSchema = HarnessCompatibilityReceiptContentSchema
+    .extend({ contentHash: ReleaseHashSchema })
+    .strict();
 export function createRunManifest(input) {
     const content = RunManifestContentSchema.parse(input);
     return RunManifestSchema.parse({ ...content, contentHash: contentHash(content) });
@@ -115,13 +122,26 @@ export function aggregateEvaluationReceipts(input) {
     });
     return EvaluationResultSchema.parse({ ...content, contentHash: contentHash(content) });
 }
-export function assertComparableRunManifests(base, candidate) {
-    if (base.harnessRelease.contentHash !== candidate.harnessRelease.contentHash) {
-        throw new Error("Evaluation runs use different Harness Releases.");
-    }
+export function createHarnessCompatibilityReceipt(input) {
+    const content = HarnessCompatibilityReceiptContentSchema.parse(input);
+    return HarnessCompatibilityReceiptSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+export function assertComparableRunManifests(base, candidate, compatibility) {
     if (base.tasksetRelease.contentHash !== candidate.tasksetRelease.contentHash) {
         throw new Error("Evaluation runs use different Taskset Releases.");
     }
+    if (base.harnessRelease.contentHash === candidate.harnessRelease.contentHash)
+        return;
+    if (!compatibility) {
+        throw new Error("Evaluation runs use different Harness Releases without a compatibility receipt.");
+    }
+    const receipt = HarnessCompatibilityReceiptSchema.parse(compatibility);
+    assertContentHash(receipt, "Harness compatibility receipt");
+    if (receipt.baseHarnessRelease.contentHash !== base.harnessRelease.contentHash
+        || receipt.candidateHarnessRelease.contentHash !== candidate.harnessRelease.contentHash
+        || receipt.tasksetRelease.contentHash !== base.tasksetRelease.contentHash) {
+        throw new Error("Harness compatibility receipt does not match the compared runs.");
+    }
 }
 export function rewardEligibleReceipts(receipts) {
     return receipts.filter((receipt) => receipt.terminal

package/dist/tasksets.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, 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"]),
@@ -77,10 +63,9 @@ export const TaskRecordSchema = z.object({
     tags: z.array(ReleaseIdSchema).max(100).default([]),
 }).strict();
 export const TasksetReleaseContentSchema = z.object({
-    schemaVersion: z.literal("openpond.tasksetRelease.v1"),
+    schemaVersion: z.literal("openpond.tasksetRelease.v2"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
-    harnessRelease: ImmutableReleaseRefSchema,
     policy: PolicyBoundarySchema,
     environment: EnvironmentContractSchema,
     tools: z.array(ToolDeclarationSchema).max(200),
@@ -161,3 +146,4 @@ export function trainingPolicyTaskViews(taskset) {
         .filter((task) => task.split !== "frozen_eval")
         .map(policyTaskView);
 }
+export { CapabilityRequirementSchema, ToolDeclarationSchema, } from "@openpond/harness";

package/dist/types/compatibility.d.ts

@@ -0,0 +1,11 @@
+import { type HarnessRelease } from "@openpond/harness";
+import { type HarnessCompatibilityReceipt } from "./runs.js";
+import { type TasksetRelease } from "./tasksets.js";
+export declare function createVerifiedHarnessCompatibilityReceipt(input: {
+    id: string;
+    baseHarnessRelease: HarnessRelease;
+    candidateHarnessRelease: HarnessRelease;
+    tasksetRelease: TasksetRelease;
+    metadata?: Record<string, unknown>;
+}): HarnessCompatibilityReceipt;
+//# sourceMappingURL=compatibility.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../../../src/compatibility.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,WAAW,CAAC;AACnB,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AAEvB,wBAAgB,yCAAyC,CAAC,KAAK,EAAE;IAC/D,EAAE,EAAE,MAAM,CAAC;IACX,kBAAkB,EAAE,cAAc,CAAC;IACnC,uBAAuB,EAAE,cAAc,CAAC;IACxC,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,GAAG,2BAA2B,CA4C9B"}

package/dist/types/conformance.d.ts

@@ -1,8 +1,8 @@
 export declare const genericToolConformance: {
     snapshot: {
-        schemaVersion: "openpond.agentSnapshot.v1";
+        schemaVersion: "openpond.agentSnapshot.v2";
         id: string;
-        profileRelease: {
+        sourceRelease: {
             id: string;
             contentHash: string;
         } | null;
@@ -42,6 +42,7 @@ export declare const genericToolConformance: {
             id: string;
             required: boolean;
             scopes: string[];
+            portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
         }[];
         dependencyLock: {
             id: string;
@@ -61,7 +62,7 @@ export declare const genericToolConformance: {
         contentHash: string;
     };
     harness: {
-        schemaVersion: "openpond.harnessRelease.v1";
+        schemaVersion: "openpond.harnessRelease.v2";
         id: string;
         agentSnapshot: {
             id: string;
@@ -75,16 +76,6 @@ export declare const genericToolConformance: {
             mediaType: string;
             visibility: "policy" | "verifier" | "host_private";
         };
-        environment: {
-            protocolVersion: "openpond.environment.v1";
-            kind: "text" | "agent" | "work" | "custom_program";
-            entrypoint: string;
-            stateful: boolean;
-            deterministicSeeds: boolean;
-            lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
-            networkPolicy: "none" | "declared_read_only" | "declared_scoped";
-            defaultTimeoutMs: number;
-        };
         tools: {
             name: string;
             description: string;
@@ -106,12 +97,6 @@ export declare const genericToolConformance: {
             privilegedEvidence: string[];
             privateVerifierIsolation: boolean;
         };
-        policy: {
-            policyVisibleFields: string[];
-            privilegedFields: string[];
-            hiddenGraderRefs: string[];
-            connectedAppScopes: string[];
-        };
         files: {
             id: string;
             path: string;
@@ -124,13 +109,9 @@ export declare const genericToolConformance: {
         contentHash: string;
     };
     taskset: {
-        schemaVersion: "openpond.tasksetRelease.v1";
+        schemaVersion: "openpond.tasksetRelease.v2";
         id: string;
         revision: number;
-        harnessRelease: {
-            id: string;
-            contentHash: string;
-        };
         policy: {
             policyVisibleFields: string[];
             privilegedFields: string[];
@@ -286,9 +267,9 @@ export declare const genericToolConformance: {
 };
 export declare const marketingPortfolioConformance: {
     snapshot: {
-        schemaVersion: "openpond.agentSnapshot.v1";
+        schemaVersion: "openpond.agentSnapshot.v2";
         id: string;
-        profileRelease: {
+        sourceRelease: {
             id: string;
             contentHash: string;
         } | null;
@@ -328,6 +309,7 @@ export declare const marketingPortfolioConformance: {
             id: string;
             required: boolean;
             scopes: string[];
+            portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
         }[];
         dependencyLock: {
             id: string;
@@ -347,7 +329,7 @@ export declare const marketingPortfolioConformance: {
         contentHash: string;
     };
     harness: {
-        schemaVersion: "openpond.harnessRelease.v1";
+        schemaVersion: "openpond.harnessRelease.v2";
         id: string;
         agentSnapshot: {
             id: string;
@@ -361,16 +343,6 @@ export declare const marketingPortfolioConformance: {
             mediaType: string;
             visibility: "policy" | "verifier" | "host_private";
         };
-        environment: {
-            protocolVersion: "openpond.environment.v1";
-            kind: "text" | "agent" | "work" | "custom_program";
-            entrypoint: string;
-            stateful: boolean;
-            deterministicSeeds: boolean;
-            lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
-            networkPolicy: "none" | "declared_read_only" | "declared_scoped";
-            defaultTimeoutMs: number;
-        };
         tools: {
             name: string;
             description: string;
@@ -392,12 +364,6 @@ export declare const marketingPortfolioConformance: {
             privilegedEvidence: string[];
             privateVerifierIsolation: boolean;
         };
-        policy: {
-            policyVisibleFields: string[];
-            privilegedFields: string[];
-            hiddenGraderRefs: string[];
-            connectedAppScopes: string[];
-        };
         files: {
             id: string;
             path: string;
@@ -410,13 +376,9 @@ export declare const marketingPortfolioConformance: {
         contentHash: string;
     };
     taskset: {
-        schemaVersion: "openpond.tasksetRelease.v1";
+        schemaVersion: "openpond.tasksetRelease.v2";
         id: string;
         revision: number;
-        harnessRelease: {
-            id: string;
-            contentHash: string;
-        };
         policy: {
             policyVisibleFields: string[];
             privilegedFields: string[];

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":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}

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

@@ -9,7 +9,7 @@ export declare const completeWorkProcessTraceFixture: {
         sequence: number;
         timestamp: string;
         layer: "agent" | "environment";
-        kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
+        kind: "approval" | "validation" | "artifact" | "tool" | "state_transition" | "question" | "cleanup";
         action: "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";
         status: "cancelled" | "failed" | "started" | "completed";
         inputHash: string | null;
@@ -32,7 +32,7 @@ export declare const completeWorkProcessTraceFixture: {
             durationMs: number | null;
             cpuTimeMs: number | null;
             memoryPeakBytes: number | null;
-            errorClass: "unknown" | "policy" | "timeout" | "cancelled" | "validation" | "environment" | "infrastructure" | null;
+            errorClass: "unknown" | "timeout" | "cancelled" | "validation" | "policy" | "environment" | "infrastructure" | null;
         };
     }[];
     contentHash: string;
@@ -186,7 +186,7 @@ export declare const incompleteWorkProcessTraceFixture: {
         sequence: number;
         timestamp: string;
         layer: "agent" | "environment";
-        kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
+        kind: "approval" | "validation" | "artifact" | "tool" | "state_transition" | "question" | "cleanup";
         action: "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";
         status: "cancelled" | "failed" | "started" | "completed";
         inputHash: string | null;
@@ -209,7 +209,7 @@ export declare const incompleteWorkProcessTraceFixture: {
             durationMs: number | null;
             cpuTimeMs: number | null;
             memoryPeakBytes: number | null;
-            errorClass: "unknown" | "policy" | "timeout" | "cancelled" | "validation" | "environment" | "infrastructure" | null;
+            errorClass: "unknown" | "timeout" | "cancelled" | "validation" | "policy" | "environment" | "infrastructure" | null;
         };
     }[];
     contentHash: string;
@@ -392,7 +392,7 @@ export declare const workEvidenceConformance: {
             sequence: number;
             timestamp: string;
             layer: "agent" | "environment";
-            kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
+            kind: "approval" | "validation" | "artifact" | "tool" | "state_transition" | "question" | "cleanup";
             action: "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";
             status: "cancelled" | "failed" | "started" | "completed";
             inputHash: string | null;
@@ -415,7 +415,7 @@ export declare const workEvidenceConformance: {
                 durationMs: number | null;
                 cpuTimeMs: number | null;
                 memoryPeakBytes: number | null;
-                errorClass: "unknown" | "policy" | "timeout" | "cancelled" | "validation" | "environment" | "infrastructure" | null;
+                errorClass: "unknown" | "timeout" | "cancelled" | "validation" | "policy" | "environment" | "infrastructure" | null;
             };
         }[];
         contentHash: string;
@@ -625,7 +625,7 @@ export declare const workEvidenceConformance: {
             sequence: number;
             timestamp: string;
             layer: "agent" | "environment";
-            kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
+            kind: "approval" | "validation" | "artifact" | "tool" | "state_transition" | "question" | "cleanup";
             action: "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";
             status: "cancelled" | "failed" | "started" | "completed";
             inputHash: string | null;
@@ -648,7 +648,7 @@ export declare const workEvidenceConformance: {
                 durationMs: number | null;
                 cpuTimeMs: number | null;
                 memoryPeakBytes: number | null;
-                errorClass: "unknown" | "policy" | "timeout" | "cancelled" | "validation" | "environment" | "infrastructure" | null;
+                errorClass: "unknown" | "timeout" | "cancelled" | "validation" | "policy" | "environment" | "infrastructure" | null;
             };
         }[];
         contentHash: string;

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

@@ -13,9 +13,9 @@ export declare const EvidenceArtifactRefSchema: z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strict>;
 export declare const WorkProcessStepKindSchema: z.ZodEnum<{
+    approval: "approval";
     validation: "validation";
     artifact: "artifact";
-    approval: "approval";
     tool: "tool";
     state_transition: "state_transition";
     question: "question";
@@ -88,10 +88,10 @@ export declare const WorkInterventionOutcomeSchema: z.ZodEnum<{
 }>;
 export declare const WorkProcessErrorClassSchema: z.ZodEnum<{
     unknown: "unknown";
-    policy: "policy";
     timeout: "timeout";
     cancelled: "cancelled";
     validation: "validation";
+    policy: "policy";
     environment: "environment";
     infrastructure: "infrastructure";
 }>;
@@ -111,9 +111,9 @@ export declare const WorkProcessStepSchema: z.ZodObject<{
         environment: "environment";
     }>;
     kind: z.ZodEnum<{
+        approval: "approval";
         validation: "validation";
         artifact: "artifact";
-        approval: "approval";
         tool: "tool";
         state_transition: "state_transition";
         question: "question";
@@ -198,10 +198,10 @@ export declare const WorkProcessStepSchema: z.ZodObject<{
         memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
         errorClass: z.ZodNullable<z.ZodEnum<{
             unknown: "unknown";
-            policy: "policy";
             timeout: "timeout";
             cancelled: "cancelled";
             validation: "validation";
+            policy: "policy";
             environment: "environment";
             infrastructure: "infrastructure";
         }>>;
@@ -229,9 +229,9 @@ export declare const WorkProcessTraceContentSchema: z.ZodObject<{
             environment: "environment";
         }>;
         kind: z.ZodEnum<{
+            approval: "approval";
             validation: "validation";
             artifact: "artifact";
-            approval: "approval";
             tool: "tool";
             state_transition: "state_transition";
             question: "question";
@@ -316,10 +316,10 @@ export declare const WorkProcessTraceContentSchema: z.ZodObject<{
             memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
             errorClass: z.ZodNullable<z.ZodEnum<{
                 unknown: "unknown";
-                policy: "policy";
                 timeout: "timeout";
                 cancelled: "cancelled";
                 validation: "validation";
+                policy: "policy";
                 environment: "environment";
                 infrastructure: "infrastructure";
             }>>;
@@ -348,9 +348,9 @@ export declare const WorkProcessTraceSchema: z.ZodObject<{
             environment: "environment";
         }>;
         kind: z.ZodEnum<{
+            approval: "approval";
             validation: "validation";
             artifact: "artifact";
-            approval: "approval";
             tool: "tool";
             state_transition: "state_transition";
             question: "question";
@@ -435,10 +435,10 @@ export declare const WorkProcessTraceSchema: z.ZodObject<{
             memoryPeakBytes: z.ZodNullable<z.ZodNumber>;
             errorClass: z.ZodNullable<z.ZodEnum<{
                 unknown: "unknown";
-                policy: "policy";
                 timeout: "timeout";
                 cancelled: "cancelled";
                 validation: "validation";
+                policy: "policy";
                 environment: "environment";
                 infrastructure: "infrastructure";
             }>>;