@openpond/evals 0.1.1 → 0.3.0

package/dist/harness-improvements.js

@@ -0,0 +1,329 @@
+import { z } from "zod";
+import { HarnessImprovementRouteSchema, HarnessOverlaySnapshotRefSchema, } from "./harness-workspaces.js";
+import { contentHash, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, } from "./common.js";
+const BoundedTextSchema = z.string().trim().min(1).max(100_000);
+const MetadataSchema = z.record(z.string(), z.unknown()).default({});
+export const ImprovementSafeBoundaryKindSchema = z.enum([
+    "completed_tool_batch",
+    "before_model_step",
+    "turn_completed",
+    "turn_paused",
+]);
+export const ImprovementSafeBoundarySchema = z
+    .object({
+    kind: ImprovementSafeBoundaryKindSchema,
+    eventSequence: z.number().int().nonnegative(),
+    occurredAt: ReleaseTimestampSchema,
+})
+    .strict();
+export const ImprovementEventRefSchema = z
+    .object({
+    id: ReleaseIdSchema,
+    sequence: z.number().int().nonnegative().nullable(),
+    contentHash: ReleaseHashSchema,
+})
+    .strict();
+export const ImprovementObservationKindSchema = z.enum([
+    "tool_failure",
+    "retry",
+    "recovery",
+    "validation",
+    "user_correction",
+    "reusable_success",
+    "completion_detour",
+]);
+export const ImprovementObservationStateSchema = z.enum([
+    "open",
+    "recovered",
+    "terminal",
+]);
+export const ImprovementToolIdentitySchema = z
+    .object({
+    name: z.string().trim().min(1).max(500),
+    invocationKey: ReleaseHashSchema,
+})
+    .strict();
+export const ImprovementObservationContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.improvementObservation.v1"),
+    id: ReleaseIdSchema,
+    runRef: ReleaseIdSchema,
+    turnId: ReleaseIdSchema,
+    harnessRelease: ImmutableReleaseRefSchema,
+    overlay: HarnessOverlaySnapshotRefSchema.nullable(),
+    eventRefs: z.array(ImprovementEventRefSchema).min(1).max(100),
+    kind: ImprovementObservationKindSchema,
+    state: ImprovementObservationStateSchema,
+    tool: ImprovementToolIdentitySchema.nullable(),
+    deterministicClass: z.string().trim().min(1).max(500).nullable(),
+    summary: BoundedTextSchema,
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((observation, context) => {
+    if (new Set(observation.eventRefs.map((reference) => reference.id)).size !==
+        observation.eventRefs.length) {
+        context.addIssue({
+            code: "custom",
+            message: "observation event refs must be unique",
+            path: ["eventRefs"],
+        });
+    }
+    if (["tool_failure", "retry", "recovery", "completion_detour"].includes(observation.kind) &&
+        observation.tool === null) {
+        context.addIssue({
+            code: "custom",
+            message: `${observation.kind} observations require a tool identity`,
+            path: ["tool"],
+        });
+    }
+});
+export const ImprovementObservationSchema = ImprovementObservationContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const RefinementTriggerPolicySchema = z
+    .object({
+    schemaVersion: z.literal("openpond.refinementTriggerPolicy.v1"),
+    maxEstimatedCostUsd: z.number().finite().nonnegative(),
+    cooldownMs: z.number().int().nonnegative(),
+    maxPendingPlans: z.number().int().min(1).max(100),
+    maxEvidenceEvents: z.number().int().min(1).max(1_000),
+    maxProposalEdits: z.number().int().min(1).max(1_000),
+    maxProposalBytes: z.number().int().min(1).max(10_000_000),
+})
+    .strict();
+export const RefinementTriggerDecisionKindSchema = z.enum([
+    "no_action",
+    "route_deterministically",
+    "queue_refiner",
+]);
+export const RefinementTriggerDecisionContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.refinementTriggerDecision.v1"),
+    id: ReleaseIdSchema,
+    runRef: ReleaseIdSchema,
+    turnId: ReleaseIdSchema,
+    harnessRelease: ImmutableReleaseRefSchema,
+    overlay: HarnessOverlaySnapshotRefSchema.nullable(),
+    observations: z.array(ImmutableReleaseRefSchema).max(100),
+    decision: RefinementTriggerDecisionKindSchema,
+    deterministicRoute: HarnessImprovementRouteSchema.nullable(),
+    suggestedRoutes: z.array(HarnessImprovementRouteSchema).max(8),
+    reason: BoundedTextSchema,
+    deduplicationKey: ReleaseHashSchema,
+    policy: RefinementTriggerPolicySchema,
+    estimatedMaxCostUsd: z.number().finite().nonnegative(),
+    pendingPlanCount: z.number().int().nonnegative(),
+    boundary: ImprovementSafeBoundarySchema,
+    cooldownUntil: ReleaseTimestampSchema.nullable(),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((trigger, context) => {
+    if (trigger.estimatedMaxCostUsd > trigger.policy.maxEstimatedCostUsd) {
+        context.addIssue({
+            code: "custom",
+            message: "estimated Refiner cost exceeds the trigger policy budget",
+            path: ["estimatedMaxCostUsd"],
+        });
+    }
+    if (trigger.pendingPlanCount > trigger.policy.maxPendingPlans) {
+        context.addIssue({
+            code: "custom",
+            message: "pending plan count exceeds the trigger policy limit",
+            path: ["pendingPlanCount"],
+        });
+    }
+    if (trigger.observations.length > trigger.policy.maxEvidenceEvents) {
+        context.addIssue({
+            code: "custom",
+            message: "trigger observations exceed the evidence budget",
+            path: ["observations"],
+        });
+    }
+    if (trigger.decision === "route_deterministically" &&
+        trigger.deterministicRoute === null) {
+        context.addIssue({
+            code: "custom",
+            message: "deterministic decisions require a route",
+            path: ["deterministicRoute"],
+        });
+    }
+    if (trigger.decision !== "route_deterministically" &&
+        trigger.deterministicRoute !== null) {
+        context.addIssue({
+            code: "custom",
+            message: "only deterministic decisions may declare a deterministic route",
+            path: ["deterministicRoute"],
+        });
+    }
+    if (trigger.decision === "no_action" && trigger.suggestedRoutes.length > 0) {
+        context.addIssue({
+            code: "custom",
+            message: "no-action decisions cannot suggest routes",
+            path: ["suggestedRoutes"],
+        });
+    }
+    if (trigger.decision !== "no_action" && trigger.observations.length === 0) {
+        context.addIssue({
+            code: "custom",
+            message: "actionable trigger decisions require observations",
+            path: ["observations"],
+        });
+    }
+});
+export const RefinementTriggerDecisionSchema = RefinementTriggerDecisionContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const ImprovementRouteAuthoritySchema = z.enum([
+    "runtime_service",
+    "refiner_model",
+    "human_review",
+    "evaluation_system",
+    "training_system",
+]);
+export const ImprovementRouteDecisionContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.improvementRouteDecision.v1"),
+    id: ReleaseIdSchema,
+    trigger: ImmutableReleaseRefSchema,
+    route: HarnessImprovementRouteSchema,
+    authority: ImprovementRouteAuthoritySchema,
+    automatic: z.boolean(),
+    reason: BoundedTextSchema,
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((decision, context) => {
+    if (decision.automatic &&
+        ["human_review", "evaluation_system", "training_system"].includes(decision.authority)) {
+        context.addIssue({
+            code: "custom",
+            message: `${decision.authority} routes cannot be marked automatic`,
+            path: ["automatic"],
+        });
+    }
+    if (decision.route === "training" && decision.authority !== "training_system") {
+        context.addIssue({
+            code: "custom",
+            message: "training routes require training-system authority",
+            path: ["authority"],
+        });
+    }
+});
+export const ImprovementRouteDecisionSchema = ImprovementRouteDecisionContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const HarnessRefinerOutcomeContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.harnessRefinerOutcome.v1"),
+    id: ReleaseIdSchema,
+    trigger: ImmutableReleaseRefSchema,
+    decision: z.enum(["no_action", "proposed"]),
+    proposal: ImmutableReleaseRefSchema.nullable(),
+    reason: BoundedTextSchema,
+    evidenceRefs: z.array(ImmutableReleaseRefSchema).max(100),
+    estimatedCostUsd: z.number().finite().nonnegative(),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((outcome, context) => {
+    if ((outcome.decision === "proposed") !== (outcome.proposal !== null)) {
+        context.addIssue({
+            code: "custom",
+            message: "proposed Refiner outcomes require a proposal; no-action outcomes cannot include one",
+            path: ["proposal"],
+        });
+    }
+});
+export const HarnessRefinerOutcomeSchema = HarnessRefinerOutcomeContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const ImprovementApplyDecisionSchema = z.enum([
+    "applied",
+    "retained",
+    "declined",
+    "conflict",
+    "rolled_back",
+]);
+export const ImprovementApplyReceiptContentSchema = z
+    .object({
+    schemaVersion: z.literal("openpond.improvementApplyReceipt.v1"),
+    id: ReleaseIdSchema,
+    proposal: ImmutableReleaseRefSchema,
+    beforeOverlay: HarnessOverlaySnapshotRefSchema,
+    afterOverlay: HarnessOverlaySnapshotRefSchema.nullable(),
+    decision: ImprovementApplyDecisionSchema,
+    boundary: ImprovementSafeBoundarySchema,
+    validationRefs: z.array(ImmutableReleaseRefSchema).max(100),
+    outcomeEvidenceRefs: z.array(ImprovementEventRefSchema).max(1_000),
+    rollbackOf: ImmutableReleaseRefSchema.nullable(),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+})
+    .strict()
+    .superRefine((receipt, context) => {
+    if ((receipt.decision === "applied") !== (receipt.afterOverlay !== null)) {
+        context.addIssue({
+            code: "custom",
+            message: "applied receipts require an after-overlay; other decisions cannot include one",
+            path: ["afterOverlay"],
+        });
+    }
+    if ((receipt.decision === "rolled_back") !== (receipt.rollbackOf !== null)) {
+        context.addIssue({
+            code: "custom",
+            message: "only rollback receipts require rollbackOf",
+            path: ["rollbackOf"],
+        });
+    }
+});
+export const ImprovementApplyReceiptSchema = ImprovementApplyReceiptContentSchema.extend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+function createHashedContract(input) {
+    const parsed = input.contentSchema.parse(input.content);
+    return input.resultSchema.parse({
+        ...parsed,
+        contentHash: contentHash(parsed),
+    });
+}
+export function createImprovementObservation(content) {
+    return createHashedContract({
+        content,
+        contentSchema: ImprovementObservationContentSchema,
+        resultSchema: ImprovementObservationSchema,
+    });
+}
+export function createRefinementTriggerDecision(content) {
+    return createHashedContract({
+        content,
+        contentSchema: RefinementTriggerDecisionContentSchema,
+        resultSchema: RefinementTriggerDecisionSchema,
+    });
+}
+export function createImprovementRouteDecision(content) {
+    return createHashedContract({
+        content,
+        contentSchema: ImprovementRouteDecisionContentSchema,
+        resultSchema: ImprovementRouteDecisionSchema,
+    });
+}
+export function createHarnessRefinerOutcome(content) {
+    return createHashedContract({
+        content,
+        contentSchema: HarnessRefinerOutcomeContentSchema,
+        resultSchema: HarnessRefinerOutcomeSchema,
+    });
+}
+export function createImprovementApplyReceipt(content) {
+    return createHashedContract({
+        content,
+        contentSchema: ImprovementApplyReceiptContentSchema,
+        resultSchema: ImprovementApplyReceiptSchema,
+    });
+}

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),
+    });
+}