@openpond/evals 0.2.0 → 0.3.0

package/dist/harness-workspaces.js

@@ -0,0 +1,368 @@
+import { z } from "zod";
+import { contentHash, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, } from "./common.js";
+const MetadataSchema = z.record(z.string(), z.unknown()).default({});
+const RevisionSchema = z.number().int().nonnegative();
+const BoundedTextSchema = z.string().trim().min(1).max(100_000);
+export const HarnessOwnerScopeSchema = z
+    .object({
+    kind: z.enum(["personal", "team"]),
+    id: ReleaseIdSchema,
+})
+    .strict();
+export const HarnessCurrentChannelSchema = z
+    .object({
+    name: ReleaseIdSchema,
+    release: ImmutableReleaseRefSchema.nullable(),
+    revision: RevisionSchema,
+})
+    .strict();
+/**
+ * Mutable, host-owned authoring state. Portable runs never consume this object;
+ * they consume the immutable release selected from currentChannel.
+ */
+export const HarnessWorkspaceSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessWorkspace.v1"),
+    id: ReleaseIdSchema,
+    ownerScope: HarnessOwnerScopeSchema,
+    name: z.string().trim().min(1).max(240),
+    location: z.enum(["local", "hosted"]),
+    sourceRevision: z.string().trim().min(1).max(500),
+    revision: RevisionSchema,
+    dirty: z.boolean(),
+    currentChannel: HarnessCurrentChannelSchema,
+    createdAt: ReleaseTimestampSchema,
+    updatedAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict();
+export const HarnessImprovementRouteSchema = z.enum([
+    "runtime",
+    "memory",
+    "prompt",
+    "skill",
+    "agent",
+    "product",
+    "taskset",
+    "training",
+]);
+export const HarnessChangeEffectSchema = z.enum([
+    "text_instruction",
+    "memory",
+    "dependency_selection",
+    "executable_code",
+    "business_logic",
+    "financial_logic",
+    "permission",
+    "connected_app",
+    "publication",
+    "deployment",
+    "training",
+    "model_binding",
+    "team_or_global",
+]);
+export const HarnessOverlayEditSchema = z
+    .object({
+    id: ReleaseIdSchema,
+    route: HarnessImprovementRouteSchema,
+    operation: z.enum(["create", "update", "delete"]),
+    target: z.string().trim().min(1).max(2_000),
+    summary: z.string().trim().min(1).max(2_000),
+    content: z.string().max(1_000_000).nullable(),
+    contentHash: ReleaseHashSchema.nullable(),
+    effects: z.array(HarnessChangeEffectSchema).min(1).max(20),
+})
+    .strict()
+    .superRefine((edit, context) => {
+    if (edit.operation === "delete") {
+        if (edit.content !== null || edit.contentHash !== null) {
+            context.addIssue({
+                code: "custom",
+                message: "delete edits cannot include replacement content",
+                path: ["content"],
+            });
+        }
+        return;
+    }
+    if (edit.content === null || edit.contentHash === null) {
+        context.addIssue({
+            code: "custom",
+            message: "create and update edits require content and contentHash",
+            path: ["content"],
+        });
+        return;
+    }
+    const expected = contentHash(edit.content);
+    if (edit.contentHash !== expected) {
+        context.addIssue({
+            code: "custom",
+            message: `edit contentHash is ${edit.contentHash}; expected ${expected}`,
+            path: ["contentHash"],
+        });
+    }
+});
+export const HarnessWorkspaceRevisionRefSchema = z
+    .object({
+    workspaceId: ReleaseIdSchema,
+    revision: RevisionSchema,
+    sourceRevision: z.string().trim().min(1).max(500),
+    channelRevision: RevisionSchema,
+})
+    .strict();
+export const HarnessOverlaySnapshotRefSchema = z
+    .object({
+    id: ReleaseIdSchema,
+    revision: RevisionSchema,
+    contentHash: ReleaseHashSchema,
+})
+    .strict();
+export const HarnessTurnSnapshotSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessTurnSnapshot.v1"),
+    workspaceId: ReleaseIdSchema,
+    workspaceRevision: RevisionSchema,
+    sourceRevision: z.string().trim().min(1).max(500),
+    channelName: ReleaseIdSchema,
+    channelRevision: RevisionSchema,
+    harnessRelease: ImmutableReleaseRefSchema,
+    overlay: HarnessOverlaySnapshotRefSchema.nullable().optional().default(null),
+})
+    .strict();
+export const HarnessRunOverlayContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessRunOverlay.v1"),
+    id: ReleaseIdSchema,
+    runId: ReleaseIdSchema,
+    baseHarnessRelease: ImmutableReleaseRefSchema,
+    workspace: HarnessWorkspaceRevisionRefSchema,
+    revision: RevisionSchema,
+    status: z.enum(["active", "frozen", "abandoned"]),
+    edits: z.array(HarnessOverlayEditSchema).max(1_000),
+    createdAt: ReleaseTimestampSchema,
+    updatedAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict();
+export const HarnessRunOverlaySchema = HarnessRunOverlayContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const HarnessProposalEvidenceRefSchema = z
+    .object({
+    kind: z.enum([
+        "tool_event",
+        "recovery",
+        "validation",
+        "user_correction",
+        "work_output",
+        "work_receipt",
+    ]),
+    id: ReleaseIdSchema,
+    contentHash: ReleaseHashSchema.nullable(),
+})
+    .strict();
+export const HarnessValidationPlanItemSchema = z
+    .object({
+    id: ReleaseIdSchema,
+    kind: z.enum([
+        "dependency",
+        "schema",
+        "package",
+        "file_render",
+        "skill",
+        "prompt",
+        "business_formula",
+        "targeted_evaluation",
+        "observed_recovery",
+    ]),
+    description: BoundedTextSchema,
+    required: z.boolean(),
+})
+    .strict();
+export const HarnessImprovementProposalContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessImprovementProposal.v1"),
+    id: ReleaseIdSchema,
+    overlay: HarnessOverlaySnapshotRefSchema,
+    baseHarnessRelease: ImmutableReleaseRefSchema,
+    expectedWorkspace: HarnessWorkspaceRevisionRefSchema,
+    requestedScope: z.enum(["personal", "team", "global"]),
+    route: HarnessImprovementRouteSchema,
+    risk: z.enum(["low", "review", "restricted"]),
+    effects: z.array(HarnessChangeEffectSchema).min(1).max(20),
+    evidence: z.array(HarnessProposalEvidenceRefSchema).min(1).max(1_000),
+    edits: z.array(HarnessOverlayEditSchema).min(1).max(1_000),
+    validationPlan: z.array(HarnessValidationPlanItemSchema).min(1).max(100),
+    expectedOutcome: BoundedTextSchema,
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((proposal, context) => {
+    const declaredEffects = new Set(proposal.effects);
+    for (const [index, edit] of proposal.edits.entries()) {
+        if (edit.route !== proposal.route) {
+            context.addIssue({
+                code: "custom",
+                message: "every edit route must match the proposal route",
+                path: ["edits", index, "route"],
+            });
+        }
+        for (const effect of edit.effects) {
+            if (!declaredEffects.has(effect)) {
+                context.addIssue({
+                    code: "custom",
+                    message: `edit effect ${effect} is missing from proposal effects`,
+                    path: ["edits", index, "effects"],
+                });
+            }
+        }
+    }
+    if (new Set(proposal.validationPlan.map((item) => item.id)).size !== proposal.validationPlan.length) {
+        context.addIssue({
+            code: "custom",
+            message: "validation plan ids must be unique",
+            path: ["validationPlan"],
+        });
+    }
+});
+export const HarnessImprovementProposalSchema = HarnessImprovementProposalContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const HarnessTargetedValidationReceiptContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessTargetedValidationReceipt.v1"),
+    id: ReleaseIdSchema,
+    proposal: ImmutableReleaseRefSchema,
+    validationId: ReleaseIdSchema,
+    kind: HarnessValidationPlanItemSchema.shape.kind,
+    status: z.enum(["passed", "failed", "blocked", "skipped"]),
+    summary: BoundedTextSchema,
+    evidenceRefs: z.array(HarnessProposalEvidenceRefSchema).max(1_000),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict();
+export const HarnessTargetedValidationReceiptSchema = HarnessTargetedValidationReceiptContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const HarnessAdvanceDecisionSchema = z.enum([
+    "advanced",
+    "retained",
+    "conflict",
+    "rolled_back",
+]);
+export const HarnessAdvanceReceiptContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessAdvanceReceipt.v1"),
+    id: ReleaseIdSchema,
+    workspaceId: ReleaseIdSchema,
+    ownerScope: HarnessOwnerScopeSchema,
+    proposal: ImmutableReleaseRefSchema.nullable(),
+    expectedWorkspaceRevision: RevisionSchema,
+    observedWorkspaceRevision: RevisionSchema,
+    previousChannelRevision: RevisionSchema,
+    nextChannelRevision: RevisionSchema,
+    previousRelease: ImmutableReleaseRefSchema.nullable(),
+    nextRelease: ImmutableReleaseRefSchema.nullable(),
+    validationReceipts: z.array(ImmutableReleaseRefSchema).max(100),
+    decision: HarnessAdvanceDecisionSchema,
+    reason: BoundedTextSchema,
+    rollbackOf: ImmutableReleaseRefSchema.nullable(),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((receipt, context) => {
+    const changed = receipt.nextChannelRevision === receipt.previousChannelRevision + 1;
+    if (["advanced", "rolled_back"].includes(receipt.decision) !== changed) {
+        context.addIssue({
+            code: "custom",
+            message: "only successful advancement or rollback increments the channel revision",
+            path: ["nextChannelRevision"],
+        });
+    }
+    if (receipt.decision === "rolled_back" && receipt.rollbackOf === null) {
+        context.addIssue({
+            code: "custom",
+            message: "rollback receipts require rollbackOf",
+            path: ["rollbackOf"],
+        });
+    }
+    if (receipt.decision !== "rolled_back" && receipt.rollbackOf !== null) {
+        context.addIssue({
+            code: "custom",
+            message: "rollbackOf is only valid for rollback receipts",
+            path: ["rollbackOf"],
+        });
+    }
+});
+export const HarnessAdvanceReceiptSchema = HarnessAdvanceReceiptContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const HarnessOverlayMergeReceiptContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessOverlayMergeReceipt.v1"),
+    id: ReleaseIdSchema,
+    workspaceId: ReleaseIdSchema,
+    baseHarnessRelease: ImmutableReleaseRefSchema,
+    leftOverlay: HarnessOverlaySnapshotRefSchema,
+    rightOverlay: HarnessOverlaySnapshotRefSchema,
+    decision: z.enum(["merged", "conflict"]),
+    mergedOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
+    conflictTargets: z.array(z.string().trim().min(1).max(2_000)).max(1_000),
+    requiresRevalidation: z.literal(true),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((receipt, context) => {
+    if ((receipt.decision === "merged") !== (receipt.mergedOverlay !== null)) {
+        context.addIssue({
+            code: "custom",
+            message: "merged decisions require a merged overlay; conflicts cannot provide one",
+            path: ["mergedOverlay"],
+        });
+    }
+    if ((receipt.decision === "conflict") !== (receipt.conflictTargets.length > 0)) {
+        context.addIssue({
+            code: "custom",
+            message: "conflict decisions require conflict targets and merged decisions cannot include them",
+            path: ["conflictTargets"],
+        });
+    }
+});
+export const HarnessOverlayMergeReceiptSchema = HarnessOverlayMergeReceiptContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export function createHarnessRunOverlay(content) {
+    const parsed = HarnessRunOverlayContentSchema.parse(content);
+    return HarnessRunOverlaySchema.parse({ ...parsed, contentHash: contentHash(parsed) });
+}
+export function createHarnessImprovementProposal(content) {
+    const parsed = HarnessImprovementProposalContentSchema.parse(content);
+    return HarnessImprovementProposalSchema.parse({
+        ...parsed,
+        contentHash: contentHash(parsed),
+    });
+}
+export function createHarnessTargetedValidationReceipt(content) {
+    const parsed = HarnessTargetedValidationReceiptContentSchema.parse(content);
+    return HarnessTargetedValidationReceiptSchema.parse({
+        ...parsed,
+        contentHash: contentHash(parsed),
+    });
+}
+export function createHarnessAdvanceReceipt(content) {
+    const parsed = HarnessAdvanceReceiptContentSchema.parse(content);
+    return HarnessAdvanceReceiptSchema.parse({
+        ...parsed,
+        contentHash: contentHash(parsed),
+    });
+}
+export function createHarnessOverlayMergeReceipt(content) {
+    const parsed = HarnessOverlayMergeReceiptContentSchema.parse(content);
+    return HarnessOverlayMergeReceiptSchema.parse({
+        ...parsed,
+        contentHash: contentHash(parsed),
+    });
+}

package/dist/harness.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableAssetRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash, } from "./common.js";
-import { EnvironmentContractSchema, PolicyBoundarySchema, ToolDeclarationSchema } from "./tasksets.js";
+import { ToolDeclarationSchema } from "./tasksets.js";
 import { createAttemptReceipt } from "./runs.js";
 export const PortabilityReportSchema = z.object({
     portable: z.boolean(),
@@ -9,9 +9,9 @@ export const PortabilityReportSchema = z.object({
     hostPrivateAssetRefs: z.array(ReleaseIdSchema).max(10_000),
 }).strict();
 export const AgentSnapshotContentSchema = z.object({
-    schemaVersion: z.literal("openpond.agentSnapshot.v1"),
+    schemaVersion: z.literal("openpond.agentSnapshot.v2"),
     id: ReleaseIdSchema,
-    profileRelease: ImmutableReleaseRefSchema.nullable(),
+    sourceRelease: ImmutableReleaseRefSchema.nullable(),
     instructions: z.array(ImmutableAssetRefSchema).max(10_000),
     skills: z.array(ImmutableAssetRefSchema).max(10_000),
     agents: z.array(ImmutableAssetRefSchema).max(10_000),
@@ -40,15 +40,13 @@ export const GraderInterfaceContractSchema = z.object({
     privateVerifierIsolation: z.boolean(),
 }).strict();
 export const HarnessReleaseContentSchema = z.object({
-    schemaVersion: z.literal("openpond.harnessRelease.v1"),
+    schemaVersion: z.literal("openpond.harnessRelease.v2"),
     id: ReleaseIdSchema,
     agentSnapshot: ImmutableReleaseRefSchema,
     program: ImmutableAssetRefSchema,
-    environment: EnvironmentContractSchema,
     tools: z.array(ToolDeclarationSchema).max(200),
     lifecycle: LifecycleContractSchema,
     graderInterface: GraderInterfaceContractSchema,
-    policy: PolicyBoundarySchema,
     files: z.array(ImmutableAssetRefSchema).max(100_000),
     metadata: MetadataSchema,
 }).strict();

package/dist/index.js

@@ -1,6 +1,9 @@
 export * from "./common.js";
+export * from "./compatibility.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 "./tasksets.js";

package/dist/runs.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "./common.js";
+import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, assertContentHash, contentHash, } from "./common.js";
 export const ModelRefSchema = z.object({
     provider: ReleaseIdSchema,
     model: ReleaseIdSchema,
@@ -69,6 +69,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 +130,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 { ImmutableAssetRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, assertContentHash, contentHash, } from "./common.js";
 export const TaskSplitSchema = z.enum(["train", "validation", "test", "frozen_eval"]);
 export const PolicyBoundarySchema = z.object({
     policyVisibleFields: z.array(ReleaseIdSchema).max(1_000).default([]),
@@ -77,10 +77,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),

package/dist/types/compatibility.d.ts

@@ -0,0 +1,11 @@
+import { type HarnessRelease } from "./harness.js";
+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,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"}

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;
@@ -61,7 +61,7 @@ export declare const genericToolConformance: {
         contentHash: string;
     };
     harness: {
-        schemaVersion: "openpond.harnessRelease.v1";
+        schemaVersion: "openpond.harnessRelease.v2";
         id: string;
         agentSnapshot: {
             id: string;
@@ -75,16 +75,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 +96,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 +108,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 +266,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;
@@ -347,7 +327,7 @@ export declare const marketingPortfolioConformance: {
         contentHash: string;
     };
     harness: {
-        schemaVersion: "openpond.harnessRelease.v1";
+        schemaVersion: "openpond.harnessRelease.v2";
         id: string;
         agentSnapshot: {
             id: string;
@@ -361,16 +341,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 +362,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 +374,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":"AASA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}