@openpond/evals 0.3.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, 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";

package/dist/types/compatibility.d.ts

@@ -1,4 +1,4 @@
-import { type HarnessRelease } from "./harness.js";
+import { type HarnessRelease } from "@openpond/harness";
 import { type HarnessCompatibilityReceipt } from "./runs.js";
 import { type TasksetRelease } from "./tasksets.js";
 export declare function createVerifiedHarnessCompatibilityReceipt(input: {

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

@@ -1 +1 @@
-{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../../../src/compatibility.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AACtB,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"}
+{"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

@@ -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;
@@ -308,6 +309,7 @@ export declare const marketingPortfolioConformance: {
             id: string;
             required: boolean;
             scopes: string[];
+            portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
         }[];
         dependencyLock: {
             id: 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,8 +9,8 @@ export declare const completeWorkProcessTraceFixture: {
         sequence: number;
         timestamp: string;
         layer: "agent" | "environment";
-        kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
-        action: "turn_completed" | "turn_started" | "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";
+        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;
         outputHash: string | null;
@@ -23,7 +23,7 @@ export declare const completeWorkProcessTraceFixture: {
             id: string;
         }[];
         attributes: {
-            toolCategory: "agent" | "connected_app" | "filesystem" | "source_control" | "command" | "browser" | "sandbox" | "other" | null;
+            toolCategory: "agent" | "filesystem" | "source_control" | "command" | "browser" | "connected_app" | "sandbox" | "other" | null;
             validationKind: "test" | "other" | "structural" | "visual" | "user_review" | null;
             transitionState: "timeout" | "cancelled" | "failed" | "completed" | "running" | null;
             interventionOutcome: "requested" | "approved" | "denied" | "answered" | "dismissed" | 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;
@@ -41,7 +41,7 @@ export declare const completeWorkEvidenceFixture: {
     schemaVersion: "openpond.workEvidenceReceipt.v1";
     id: string;
     source: {
-        surface: "hosted" | "desktop";
+        surface: "desktop" | "hosted";
         experience: "work" | "development";
         opaqueRef: string;
         revisionHash: string;
@@ -186,8 +186,8 @@ export declare const incompleteWorkProcessTraceFixture: {
         sequence: number;
         timestamp: string;
         layer: "agent" | "environment";
-        kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
-        action: "turn_completed" | "turn_started" | "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";
+        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;
         outputHash: string | null;
@@ -200,7 +200,7 @@ export declare const incompleteWorkProcessTraceFixture: {
             id: string;
         }[];
         attributes: {
-            toolCategory: "agent" | "connected_app" | "filesystem" | "source_control" | "command" | "browser" | "sandbox" | "other" | null;
+            toolCategory: "agent" | "filesystem" | "source_control" | "command" | "browser" | "connected_app" | "sandbox" | "other" | null;
             validationKind: "test" | "other" | "structural" | "visual" | "user_review" | null;
             transitionState: "timeout" | "cancelled" | "failed" | "completed" | "running" | null;
             interventionOutcome: "requested" | "approved" | "denied" | "answered" | "dismissed" | 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;
@@ -273,7 +273,7 @@ export declare const revokedWorkEvidenceEligibilityFixture: {
 export declare const invalidRawEvidenceFixture: {
     source: {
         opaqueRef: string;
-        surface: "hosted" | "desktop";
+        surface: "desktop" | "hosted";
         experience: "work" | "development";
         revisionHash: string;
     };
@@ -392,8 +392,8 @@ export declare const workEvidenceConformance: {
             sequence: number;
             timestamp: string;
             layer: "agent" | "environment";
-            kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
-            action: "turn_completed" | "turn_started" | "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";
+            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;
             outputHash: string | null;
@@ -406,7 +406,7 @@ export declare const workEvidenceConformance: {
                 id: string;
             }[];
             attributes: {
-                toolCategory: "agent" | "connected_app" | "filesystem" | "source_control" | "command" | "browser" | "sandbox" | "other" | null;
+                toolCategory: "agent" | "filesystem" | "source_control" | "command" | "browser" | "connected_app" | "sandbox" | "other" | null;
                 validationKind: "test" | "other" | "structural" | "visual" | "user_review" | null;
                 transitionState: "timeout" | "cancelled" | "failed" | "completed" | "running" | null;
                 interventionOutcome: "requested" | "approved" | "denied" | "answered" | "dismissed" | 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;
@@ -424,7 +424,7 @@ export declare const workEvidenceConformance: {
         schemaVersion: "openpond.workEvidenceReceipt.v1";
         id: string;
         source: {
-            surface: "hosted" | "desktop";
+            surface: "desktop" | "hosted";
             experience: "work" | "development";
             opaqueRef: string;
             revisionHash: string;
@@ -625,8 +625,8 @@ export declare const workEvidenceConformance: {
             sequence: number;
             timestamp: string;
             layer: "agent" | "environment";
-            kind: "validation" | "artifact" | "approval" | "tool" | "state_transition" | "question" | "cleanup";
-            action: "turn_completed" | "turn_started" | "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";
+            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;
             outputHash: string | null;
@@ -639,7 +639,7 @@ export declare const workEvidenceConformance: {
                 id: string;
             }[];
             attributes: {
-                toolCategory: "agent" | "connected_app" | "filesystem" | "source_control" | "command" | "browser" | "sandbox" | "other" | null;
+                toolCategory: "agent" | "filesystem" | "source_control" | "command" | "browser" | "connected_app" | "sandbox" | "other" | null;
                 validationKind: "test" | "other" | "structural" | "visual" | "user_review" | null;
                 transitionState: "timeout" | "cancelled" | "failed" | "completed" | "running" | null;
                 interventionOutcome: "requested" | "approved" | "denied" | "answered" | "dismissed" | 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;
@@ -656,7 +656,7 @@ export declare const workEvidenceConformance: {
     readonly invalidRawEvidence: {
         source: {
             opaqueRef: string;
-            surface: "hosted" | "desktop";
+            surface: "desktop" | "hosted";
             experience: "work" | "development";
             revisionHash: 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";
@@ -26,8 +26,8 @@ export declare const WorkProcessLayerSchema: z.ZodEnum<{
     environment: "environment";
 }>;
 export declare const WorkProcessActionSchema: z.ZodEnum<{
-    turn_completed: "turn_completed";
     turn_started: "turn_started";
+    turn_completed: "turn_completed";
     turn_failed: "turn_failed";
     turn_cancelled: "turn_cancelled";
     turn_timed_out: "turn_timed_out";
@@ -57,11 +57,11 @@ export declare const WorkProcessStepStatusSchema: z.ZodEnum<{
 }>;
 export declare const WorkToolCategorySchema: z.ZodEnum<{
     agent: "agent";
-    connected_app: "connected_app";
     filesystem: "filesystem";
     source_control: "source_control";
     command: "command";
     browser: "browser";
+    connected_app: "connected_app";
     sandbox: "sandbox";
     other: "other";
 }>;
@@ -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,17 +111,17 @@ 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";
         cleanup: "cleanup";
     }>;
     action: z.ZodEnum<{
-        turn_completed: "turn_completed";
         turn_started: "turn_started";
+        turn_completed: "turn_completed";
         turn_failed: "turn_failed";
         turn_cancelled: "turn_cancelled";
         turn_timed_out: "turn_timed_out";
@@ -162,11 +162,11 @@ export declare const WorkProcessStepSchema: z.ZodObject<{
     attributes: z.ZodObject<{
         toolCategory: z.ZodNullable<z.ZodEnum<{
             agent: "agent";
-            connected_app: "connected_app";
             filesystem: "filesystem";
             source_control: "source_control";
             command: "command";
             browser: "browser";
+            connected_app: "connected_app";
             sandbox: "sandbox";
             other: "other";
         }>>;
@@ -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,17 +229,17 @@ 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";
             cleanup: "cleanup";
         }>;
         action: z.ZodEnum<{
-            turn_completed: "turn_completed";
             turn_started: "turn_started";
+            turn_completed: "turn_completed";
             turn_failed: "turn_failed";
             turn_cancelled: "turn_cancelled";
             turn_timed_out: "turn_timed_out";
@@ -280,11 +280,11 @@ export declare const WorkProcessTraceContentSchema: z.ZodObject<{
         attributes: z.ZodObject<{
             toolCategory: z.ZodNullable<z.ZodEnum<{
                 agent: "agent";
-                connected_app: "connected_app";
                 filesystem: "filesystem";
                 source_control: "source_control";
                 command: "command";
                 browser: "browser";
+                connected_app: "connected_app";
                 sandbox: "sandbox";
                 other: "other";
             }>>;
@@ -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,17 +348,17 @@ 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";
             cleanup: "cleanup";
         }>;
         action: z.ZodEnum<{
-            turn_completed: "turn_completed";
             turn_started: "turn_started";
+            turn_completed: "turn_completed";
             turn_failed: "turn_failed";
             turn_cancelled: "turn_cancelled";
             turn_timed_out: "turn_timed_out";
@@ -399,11 +399,11 @@ export declare const WorkProcessTraceSchema: z.ZodObject<{
         attributes: z.ZodObject<{
             toolCategory: z.ZodNullable<z.ZodEnum<{
                 agent: "agent";
-                connected_app: "connected_app";
                 filesystem: "filesystem";
                 source_control: "source_control";
                 command: "command";
                 browser: "browser";
+                connected_app: "connected_app";
                 sandbox: "sandbox";
                 other: "other";
             }>>;
@@ -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";
             }>>;
@@ -479,8 +479,8 @@ export declare const WorkEvidenceReceiptContentSchema: z.ZodObject<{
     id: z.ZodString;
     source: z.ZodObject<{
         surface: z.ZodEnum<{
-            hosted: "hosted";
             desktop: "desktop";
+            hosted: "hosted";
         }>;
         experience: z.ZodEnum<{
             work: "work";
@@ -609,8 +609,8 @@ export declare const WorkEvidenceReceiptSchema: z.ZodObject<{
     id: z.ZodString;
     source: z.ZodObject<{
         surface: z.ZodEnum<{
-            hosted: "hosted";
             desktop: "desktop";
+            hosted: "hosted";
         }>;
         experience: z.ZodEnum<{
             work: "work";