@openpond/evals 0.11.16 → 0.11.17

package/dist/experiments.js

@@ -33,7 +33,7 @@ export const ExperimentEvaluatorSchema = z.object({
     configurationHash: ReleaseHashSchema.optional(),
     output: z.enum(["boolean", "score", "category"]),
     /** Category labels are meaningful only for category output. */
-    categories: z.array(z.string().trim().min(1).max(120)).max(50),
+    categories: z.array(z.string().trim().min(1).max(500)).max(100),
 }).strict().superRefine((value, context) => {
     if ((value.output === "category") !== (value.categories.length > 0))
         context.addIssue({ code: "custom", path: ["categories"], message: "Only category feedback declares categories." });
@@ -49,6 +49,9 @@ export function experimentCaseKey(identity) {
     const value = ExperimentCaseIdentitySchema.parse(identity);
     return JSON.stringify([value.caseId, value.seed, value.fixtureId]);
 }
+export function humanProjectionViewId(originalManifest, selectionHash, rulesHash) {
+    return `human-projection-${contentHash({ originalManifest, selectionHash, rulesHash }).slice(0, 48)}`;
+}
 export const ExperimentManifestContentSchema = z.object({
     schemaVersion: z.literal("openpond.experimentManifest.v1"),
     id: ReleaseIdSchema,
@@ -74,6 +77,8 @@ export const ExperimentManifestContentSchema = z.object({
         definition: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict().nullable(),
         execution: ImmutableReleaseRefSchema,
         scoringPassId: ReleaseIdSchema.nullable(),
+        /** Explicit accepted Human view; original execution/pass identity is retained. */
+        humanProjection: z.object({ originalManifest: ImmutableReleaseRefSchema, selectionHash: ReleaseHashSchema, rulesHash: ReleaseHashSchema }).strict().optional(),
     }).strict().optional(),
     evaluators: z.array(ExperimentEvaluatorSchema).max(100),
     population: z.array(ExperimentCaseIdentitySchema).min(1).max(10_000),
@@ -81,8 +86,15 @@ export const ExperimentManifestContentSchema = z.object({
 }).strict().superRefine((value, context) => {
     if (value.execution?.compatibility && value.execution.compatibility.targetKind !== value.target.kind)
         context.addIssue({ code: "custom", path: ["execution", "compatibility"], message: "Execution compatibility differs from its admitted target kind." });
-    if (value.lineage && value.id !== (value.lineage.scoringPassId ?? value.lineage.execution.id))
-        context.addIssue({ code: "custom", path: ["lineage"], message: "Experiment identity must match its execution or independent scoring pass." });
+    if (value.lineage) {
+        const originalId = value.lineage.scoringPassId ?? value.lineage.execution.id, projection = value.lineage.humanProjection;
+        if (projection) {
+            if (projection.originalManifest.id !== originalId || projection.originalManifest.id.startsWith("human-projection-") || value.id !== humanProjectionViewId(projection.originalManifest, projection.selectionHash, projection.rulesHash))
+                context.addIssue({ code: "custom", path: ["lineage", "humanProjection"], message: "Human view must bind its original execution or scoring pass and deterministic selection identity." });
+        }
+        else if (value.id !== originalId)
+            context.addIssue({ code: "custom", path: ["lineage"], message: "Experiment identity must match its execution or independent scoring pass." });
+    }
     if (new Set(value.population.map(experimentCaseKey)).size !== value.population.length)
         context.addIssue({ code: "custom", path: ["population"], message: "Experiment cases must be unique." });
     if (new Set(value.evaluators.map((item) => item.feedbackKey)).size !== value.evaluators.length)
@@ -93,7 +105,7 @@ export const ExperimentFeedbackSchema = z.object({
     feedbackKey: FeedbackKeySchema,
     evaluator: ExperimentEvaluatorSchema.shape.release,
     status: z.enum(["scored", "unavailable", "failed", "pending"]),
-    value: z.union([z.boolean(), z.number().finite(), z.string().max(120)]).nullable(),
+    value: z.union([z.boolean(), z.number().finite(), z.string().max(500)]).nullable(),
     passed: z.boolean().nullable().optional(),
     reasoning: z.string().max(20_000).nullable(),
     evidenceRefs: z.array(ImmutableArtifactRefSchema).max(1_000),

package/dist/graders.js

@@ -18,6 +18,7 @@ export const GraderEvidenceContentSchema = z.object({
     schemaVersion: z.literal("openpond.graderEvidence.v1"),
     graderId: ReleaseIdSchema,
     graderVersion: z.string().trim().min(1).max(100),
+    status: z.enum(["scored", "pending", "unavailable", "failed"]).optional(),
     score: z.number().min(0).max(1).nullable(),
     passed: z.boolean(),
     rewardEligible: z.boolean(),
@@ -54,7 +55,7 @@ export async function gradeEvidence(input) {
             return evidence(grader, await input.customVerifier({ grader, task: input.task, evidence: input.evidence }));
         }
         if (grader.kind === "human")
-            return evidence(grader, unavailable("Human review is pending."));
+            return evidence(grader, { score: null, passed: false, rewardEligible: false, failureClass: null, status: "pending", feedback: ["Human review is pending."], visibleEvidenceRefs: [], privilegedEvidenceRefs: [] });
         return evidence(grader, gradeDeterministic(grader, input.task, input.evidence));
     }));
 }
@@ -88,7 +89,7 @@ function unavailable(message) {
 const GradeSummarySchema = z.object({
     score: z.number().min(0).max(1).nullable(), passed: z.boolean(),
     rewardEligible: z.boolean(), failureClass: FailureClassSchema.nullable(),
-    gradingStatus: z.enum(["scored", "unscorable", "not_configured"]),
+    gradingStatus: z.enum(["scored", "pending", "unscorable", "not_configured"]),
 }).strict();
 /** Shared ordinary grading policy. Results must match the declared population;
  * missing checks cannot disappear from the denominator or the hard gates. */
@@ -105,6 +106,7 @@ export function aggregateGraderScores(input) {
     let passed = true;
     let eligible = false;
     let unavailable = false;
+    let pending = false;
     let infrastructure = !!input.infrastructureError;
     for (const grader of input.graders) {
         const item = components.get(grader.id);
@@ -113,18 +115,19 @@ export function aggregateGraderScores(input) {
         if (!Number.isFinite(grader.weight) || grader.weight < 0 || (item.score !== null && (!Number.isFinite(item.score) || item.score < 0 || item.score > 1)))
             throw new Error("Grade scores and weights must be finite and within their declared range.");
         infrastructure ||= item.failureClass === "infrastructure_failure";
-        unavailable ||= item.score === null || (item.failureClass !== null && item.failureClass !== "policy_failure");
+        pending ||= item.status === "pending";
+        unavailable ||= item.status !== "pending" && (item.score === null || (item.failureClass !== null && item.failureClass !== "policy_failure"));
         hardGateFailed ||= grader.hardGate && !item.passed;
         passed &&= item.passed;
         eligible ||= grader.rewardEligible && item.rewardEligible;
         totalWeight += grader.weight;
         weighted += (item.score ?? 0) * grader.weight;
     }
-    const score = infrastructure || unavailable || totalWeight <= 0 ? null : hardGateFailed ? 0 : weighted / totalWeight;
+    const score = infrastructure || unavailable || pending || totalWeight <= 0 ? null : hardGateFailed ? 0 : weighted / totalWeight;
     passed = score !== null && !hardGateFailed && passed;
     return GradeSummarySchema.parse({ score, passed, rewardEligible: score !== null && eligible,
-        failureClass: infrastructure ? "infrastructure_failure" : score === null ? "grader_failure" : passed ? null : "policy_failure",
-        gradingStatus: !input.graders.length && !infrastructure ? "not_configured" : score === null ? "unscorable" : "scored" });
+        failureClass: infrastructure ? "infrastructure_failure" : pending && !unavailable ? null : score === null ? "grader_failure" : passed ? null : "policy_failure",
+        gradingStatus: !input.graders.length && !infrastructure ? "not_configured" : pending && !unavailable && !infrastructure ? "pending" : score === null ? "unscorable" : "scored" });
 }
 export const TaskGradeSchema = /* @__PURE__ */ (() => GradeSummarySchema.extend({
     schemaVersion: z.literal("openpond.taskGrade.v1"),

package/dist/human-review/comparison.js

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+import { contentHash, ImmutableReleaseRefSchema } from '@openpond/harness';
+import { humanProjectionViewId, createExperimentManifest, createExperimentResult, verifyExperimentEvidence, experimentCaseKey, ExperimentManifestSchema, ExperimentResultSchema } from '../experiments.js';
+import { ReviewReleaseSchema } from './contracts.js';
+import { acceptedHumanEvidence } from './handoff.js';
+import { createHumanResultView, HumanResultViewSchema } from './results.js';
+import { LearningDomainError } from '../learning/errors.js';
+const Hash = z.string().regex(/^[a-f0-9]{64}$/), Id = z.string().min(1).max(240);
+const Base = { feedbackKey: Id, criterionId: Id };
+export const HumanComparisonRuleSchema = z.discriminatedUnion('kind', [
+    z.object({ ...Base, kind: z.literal('normalized_score'), minimum: z.number().finite(), maximum: z.number().finite(), passThreshold: z.number().min(0).max(1).optional() }).strict(),
+    z.object({ ...Base, kind: z.literal('boolean') }).strict(),
+    z.object({ ...Base, kind: z.literal('category') }).strict(),
+    z.object({ ...Base, kind: z.literal('preference_score'), tieScore: z.number().min(0).max(1).nullable() }).strict(),
+]);
+const Lane = z.object({ execution: ImmutableReleaseRefSchema, resultHash: Hash, reviews: z.array(z.object({ review: ReviewReleaseSchema, decision: ReviewReleaseSchema }).strict()).min(1).max(10000) }).strict();
+export const HumanComparisonSelectionsSchema = z.object({ rules: z.array(HumanComparisonRuleSchema).min(1).max(100), baseline: Lane, candidate: Lane }).strict().superRefine((v, c) => { if (new Set(v.rules.map(r => r.feedbackKey)).size !== v.rules.length)
+    c.addIssue({ code: 'custom', message: 'Select each Human feedback key once.' }); });
+const Evidence = z.object({ manifest: ExperimentManifestSchema, result: ExperimentResultSchema }).strict();
+const Source = z.object({ id: Id, manifestHash: Hash, resultHash: Hash }).strict();
+const ReceiptContent = z.object({ schemaVersion: z.literal('openpond.humanComparisonProjection.v1'), teamId: Id, projectId: Id, selections: HumanComparisonSelectionsSchema, original: z.object({ baseline: Source, candidate: Source }).strict(), humanResults: z.object({ baseline: HumanResultViewSchema, candidate: HumanResultViewSchema }).strict(), baseline: Evidence, candidate: Evidence }).strict();
+export const HumanComparisonProjectionSchema = ReceiptContent.extend({ contentHash: Hash }).strict();
+function fail(code) { throw new LearningDomainError(code, 409); }
+/** The host supplies current resource/subject owners and real retained receipt
+ * identities. This creates another evidence view; it never changes a pass. */
+export async function projectAcceptedHumanComparison(input) {
+    const selections = HumanComparisonSelectionsSchema.parse(input.selections);
+    await input.authorize();
+    const sources = { baseline: verifyExperimentEvidence(input.baseline), candidate: verifyExperimentEvidence(input.candidate) };
+    const expectedExecutions = new Set([selections.baseline.execution.id, selections.candidate.execution.id]);
+    if (expectedExecutions.size !== 2)
+        fail("human_comparison_distinct_executions_required");
+    let acceptedBytes = 0;
+    async function lane(kind) {
+        const source = sources[kind], selection = selections[kind], execution = source.manifest.lineage?.execution;
+        if (source.manifest.lineage?.humanProjection)
+            fail('human_comparison_recursive_projection');
+        if (!execution || contentHash(execution) !== contentHash(selection.execution) || source.manifest.teamId !== input.teamId)
+            fail('human_comparison_execution_changed');
+        const reviews = [];
+        const projected = new Map();
+        for (const selected of selection.reviews) {
+            const review = await input.readReview(selected.review);
+            if (review.scope !== input.teamId || review.projectId !== input.projectId || review.kind !== 'grade' || review.revision !== selected.review.revision || review.id !== selected.review.id)
+                fail('human_comparison_review_scope_changed');
+            const accepted = acceptedHumanEvidence(review, { reviewHash: selected.review.contentHash, decisionHash: selected.decision.contentHash });
+            acceptedBytes += new TextEncoder().encode(JSON.stringify({ answers: accepted.answers, form: review.form })).byteLength;
+            if (acceptedBytes > 4_194_304)
+                fail('human_comparison_projection_too_large');
+            if (contentHash(accepted.decision) !== contentHash(selected.decision))
+                fail('human_comparison_decision_changed');
+            if (review.evidence.attempts.some(a => !expectedExecutions.has(a.experimentId)))
+                fail('human_comparison_foreign_attempt');
+            const attempts = review.evidence.attempts.filter(a => a.experimentId === execution.id);
+            if (attempts.length !== 1)
+                fail('human_comparison_attempt_ambiguous');
+            const attempt = attempts[0], identity = await input.caseIdentity(attempt), row = source.result.cases.find(r => experimentCaseKey(r.identity) === experimentCaseKey(identity));
+            if (!row || identity.caseId !== attempt.taskId || !row.traceRef || row.traceRef.contentHash !== attempt.trace?.contentHash || row.output === null)
+                fail('human_comparison_receipt_changed');
+            const key = experimentCaseKey(identity) + ':' + review.evidence.grader.id;
+            if (projected.has(key))
+                fail('human_comparison_duplicate_assessment');
+            projected.set(key, { review, accepted, attempt });
+            reviews.push(review);
+        }
+        const resultView = createHumanResultView({ executionId: execution.id, executionHash: execution.contentHash, reviews });
+        if (resultView.contentHash !== selection.resultHash || resultView.coverage.accepted !== reviews.length)
+            fail('human_comparison_result_changed');
+        const evaluatorRules = new Map(selections.rules.map(rule => [rule.feedbackKey, rule]));
+        const evaluators = source.manifest.evaluators.map(evaluator => {
+            const rule = evaluatorRules.get(evaluator.feedbackKey);
+            if (!rule)
+                return evaluator;
+            const forms = reviews.filter(r => r.evidence.grader.id === evaluator.release.id && String(r.evidence.grader.revision) === String(evaluator.release.revision) && r.evidence.grader.contentHash === evaluator.release.contentHash).map(r => r.form);
+            if (!forms.length || new Set(forms.map(contentHash)).size !== 1)
+                fail('human_comparison_form_changed');
+            const criterion = forms[0].criteria.find(c => c.id === rule.criterionId);
+            if (!criterion)
+                fail('human_comparison_criterion_unavailable');
+            if (rule.kind === 'normalized_score' && (criterion.kind !== 'score' || rule.minimum !== criterion.minimum || rule.maximum !== criterion.maximum || rule.maximum <= rule.minimum) || rule.kind === 'boolean' && criterion.kind !== 'boolean' || rule.kind === 'category' && criterion.kind !== 'category' || rule.kind === 'preference_score' && (criterion.kind !== 'preference' || forms[0].mode !== 'pairwise'))
+                fail('human_comparison_rule_changed');
+            return { ...evaluator, output: rule.kind === 'boolean' ? 'boolean' : rule.kind === 'category' ? 'category' : 'score', categories: criterion.kind === 'category' ? criterion.options : [], configurationHash: contentHash({ original: evaluator.configurationHash, rule, formHash: contentHash(forms[0]) }) };
+        });
+        if (selections.rules.some(rule => !source.manifest.evaluators.some(e => e.feedbackKey === rule.feedbackKey)))
+            fail('human_comparison_grader_unavailable');
+        const { contentHash: _manifestHash, ...manifestBody } = source.manifest;
+        void _manifestHash;
+        const projectionLineage = { originalManifest: { id: source.manifest.id, contentHash: source.manifest.contentHash }, selectionHash: contentHash(selection), rulesHash: contentHash(selections.rules) };
+        const manifest = createExperimentManifest({ ...manifestBody, id: humanProjectionViewId(projectionLineage.originalManifest, projectionLineage.selectionHash, projectionLineage.rulesHash), lineage: { ...source.manifest.lineage, humanProjection: projectionLineage }, evaluators });
+        const cases = source.result.cases.map(row => {
+            const feedback = row.feedback.map(original => {
+                const rule = evaluatorRules.get(original.feedbackKey);
+                if (!rule)
+                    return original;
+                const found = projected.get(experimentCaseKey(row.identity) + ':' + original.evaluator.id);
+                if (!found || found.review.evidence.grader.contentHash !== original.evaluator.contentHash)
+                    fail('human_comparison_assessment_missing');
+                const answer = found.accepted.answers.find(a => a.criterionId === rule.criterionId);
+                let value = null;
+                if (answer && !answer.abstain) {
+                    if (rule.kind === 'normalized_score' && typeof answer.value === 'number')
+                        value = (answer.value - rule.minimum) / (rule.maximum - rule.minimum);
+                    if (rule.kind === 'boolean' && typeof answer.value === 'boolean')
+                        value = answer.value;
+                    if (rule.kind === 'category' && typeof answer.value === 'string')
+                        value = answer.value;
+                    if (rule.kind === 'preference_score') {
+                        const slot = found.review.evidence.attempts.findIndex(a => a.experimentId === execution.id && a.attemptId === found.attempt.attemptId);
+                        value = answer.value === 'tie' ? rule.tieScore : answer.value === 'A' || answer.value === 'B' ? (answer.value === (slot === 0 ? 'A' : 'B') ? 1 : 0) : null;
+                    }
+                }
+                return { ...original, status: value === null ? 'unavailable' : 'scored', value, passed: value === null ? null : rule.kind === 'boolean' ? value : rule.kind === 'normalized_score' && rule.passThreshold !== undefined ? Number(value) >= rule.passThreshold : null, reasoning: answer?.note ?? null, evidenceRefs: [{ id: found.accepted.review.id, contentHash: found.accepted.review.contentHash, mediaType: 'application/vnd.openpond.human-review+json', sizeBytes: null }, { id: found.accepted.decision.id, contentHash: found.accepted.decision.contentHash, mediaType: 'application/vnd.openpond.human-decision+json', sizeBytes: null }] };
+            });
+            const complete = row.output !== null && feedback.every(f => f.status === 'scored');
+            return { ...row, feedback, status: complete ? 'completed' : row.status, error: complete ? null : row.error };
+        });
+        const { contentHash: _resultHash, ...resultBody } = source.result;
+        void _resultHash;
+        const result = createExperimentResult({ ...resultBody, manifest: { id: manifest.id, contentHash: manifest.contentHash }, cases }, manifest);
+        // After all private reads, re-read every exact accepted revision through the
+        // current host authority before returning a projection usable by adoption.
+        for (const review of reviews) {
+            const current = await input.readReview({ id: review.id, revision: review.revision, contentHash: review.contentHash });
+            if (current.contentHash !== review.contentHash || current.status !== 'accepted')
+                fail('human_comparison_review_changed');
+        }
+        await input.authorize();
+        return { evidence: { manifest, result }, humanResult: resultView };
+    }
+    const baseline = await lane('baseline'), candidate = await lane('candidate');
+    for (const ref of [...selections.baseline.reviews, ...selections.candidate.reviews]) {
+        const current = await input.readReview(ref.review);
+        if (current.contentHash !== ref.review.contentHash || current.status !== 'accepted' || current.decisions.at(-1)?.contentHash !== ref.decision.contentHash)
+            fail('human_comparison_review_changed');
+    }
+    await input.authorize();
+    const original = { baseline: { id: sources.baseline.manifest.id, manifestHash: sources.baseline.manifest.contentHash, resultHash: sources.baseline.result.contentHash }, candidate: { id: sources.candidate.manifest.id, manifestHash: sources.candidate.manifest.contentHash, resultHash: sources.candidate.result.contentHash } };
+    const body = ReceiptContent.parse({ schemaVersion: 'openpond.humanComparisonProjection.v1', teamId: input.teamId, projectId: input.projectId, selections, original, humanResults: { baseline: baseline.humanResult, candidate: candidate.humanResult }, baseline: baseline.evidence, candidate: candidate.evidence });
+    if (new TextEncoder().encode(JSON.stringify(body)).byteLength > 8_388_608)
+        fail('human_comparison_projection_too_large');
+    return HumanComparisonProjectionSchema.parse({ ...body, contentHash: contentHash(body) });
+}
+export function verifyHumanComparisonProjection(raw, originals) {
+    const value = HumanComparisonProjectionSchema.parse(raw), { contentHash: hash, ...body } = value;
+    if (hash !== contentHash(body))
+        fail('human_comparison_projection_invalid');
+    for (const kind of ['baseline', 'candidate']) {
+        const evidence = verifyExperimentEvidence(value[kind]), lineage = evidence.manifest.lineage, projection = lineage?.humanProjection, original = value.original[kind], selection = value.selections[kind];
+        if (!lineage || !projection || projection.originalManifest.id !== original.id || projection.originalManifest.contentHash !== original.manifestHash || projection.selectionHash !== contentHash(selection) || projection.rulesHash !== contentHash(value.selections.rules) || contentHash(lineage.execution) !== contentHash(selection.execution) || evidence.manifest.teamId !== value.teamId || value.humanResults[kind].contentHash !== selection.resultHash)
+            fail('human_comparison_projection_lineage_changed');
+        const { contentHash: humanHash, ...humanBody } = value.humanResults[kind];
+        if (contentHash(humanBody) !== humanHash || humanBody.executionId !== selection.execution.id || humanBody.executionHash !== selection.execution.contentHash || contentHash(humanBody.selection) !== contentHash(selection.reviews.map(ref => ref.review)))
+            fail('human_comparison_human_result_changed');
+        if (originals) {
+            const actual = verifyExperimentEvidence(originals[kind]);
+            if (actual.manifest.lineage?.humanProjection || actual.manifest.id !== original.id || actual.manifest.contentHash !== original.manifestHash || actual.result.contentHash !== original.resultHash || contentHash(actual.manifest.lineage?.execution) !== contentHash(selection.execution))
+                fail('human_comparison_original_changed');
+        }
+    }
+    return value;
+}

package/dist/human-review/contracts.js

@@ -0,0 +1,110 @@
+import { HumanRevokeLocalPublicationSchema, HumanLocalPublicationsReadSchema, HumanNativeAttemptOriginSchema, HumanLocalAttemptOriginSchema, HumanExportLocalRequestSchema, HumanPublishLocalRequestSchema, HumanShareLocalRequestSchema } from "./local-publication.js";
+import { HumanTaskProposalSchema, HumanTaskProposalViewSchema } from "./task-proposals.js";
+import { z } from "zod";
+import { contentHash, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+const Id = ReleaseIdSchema;
+export const ReviewReleaseSchema = z.object({ id: Id, revision: z.number().int().positive(), contentHash: ReleaseHashSchema }).strict();
+export const HumanCriterionSchema = z.discriminatedUnion("kind", [
+    z.object({ id: Id, label: z.string().trim().min(1).max(500), instructions: z.string().max(20_000), required: z.boolean(), allowAbstain: z.boolean(), requireRationale: z.boolean().optional(), anchors: z.array(z.object({ value: z.union([z.number(), z.string(), z.boolean()]), description: z.string().min(1).max(2000) }).strict()).max(100).optional(), kind: z.literal("score"), minimum: z.number().finite(), maximum: z.number().finite(), step: z.number().positive().finite() }).strict().refine(c => c.minimum < c.maximum && c.step <= c.maximum - c.minimum, "Use an increasing raw score range and a step within that range."),
+    z.object({ id: Id, label: z.string().trim().min(1).max(500), instructions: z.string().max(20_000), required: z.boolean(), allowAbstain: z.boolean(), requireRationale: z.boolean().optional(), anchors: z.array(z.object({ value: z.union([z.number(), z.string(), z.boolean()]), description: z.string().min(1).max(2000) }).strict()).max(100).optional(), kind: z.literal("category"), options: z.array(z.string().trim().min(1).max(500)).min(2).max(100) }).strict().refine(c => new Set(c.options).size === c.options.length, "Category options must be unique."),
+    z.object({ id: Id, label: z.string().trim().min(1).max(500), instructions: z.string().max(20_000), required: z.boolean(), allowAbstain: z.boolean(), requireRationale: z.boolean().optional(), anchors: z.array(z.object({ value: z.union([z.number(), z.string(), z.boolean()]), description: z.string().min(1).max(2000) }).strict()).max(100).optional(), kind: z.literal("boolean") }).strict(),
+    z.object({ id: Id, label: z.string().trim().min(1).max(500), instructions: z.string().max(20_000), required: z.boolean(), allowAbstain: z.boolean(), requireRationale: z.boolean().optional(), anchors: z.array(z.object({ value: z.union([z.number(), z.string(), z.boolean()]), description: z.string().min(1).max(2000) }).strict()).max(100).optional(), kind: z.literal("text"), minimumLength: z.number().int().nonnegative().max(20_000).optional(), maximumLength: z.number().int().positive().max(20_000) }).strict(),
+    z.object({ id: Id, label: z.string().trim().min(1).max(500), instructions: z.string().max(20_000), required: z.boolean(), allowAbstain: z.boolean(), requireRationale: z.boolean().optional(), anchors: z.array(z.object({ value: z.union([z.number(), z.string(), z.boolean()]), description: z.string().min(1).max(2000) }).strict()).max(100).optional(), kind: z.literal("preference"), requireStrength: z.boolean().optional(), allowTie: z.boolean() }).strict(),
+]);
+export const HumanFormSchema = z.object({ schemaVersion: z.literal("openpond.humanForm.v1"), mode: z.enum(["individual", "pairwise"]), instructions: z.string().max(20_000), criteria: z.array(HumanCriterionSchema).min(1).max(100) }).strict().superRefine((form, ctx) => {
+    form.criteria.forEach((criterion, index) => {
+        if (criterion.kind === "text" && (criterion.minimumLength ?? 0) > criterion.maximumLength)
+            ctx.addIssue({ code: "custom", path: ["criteria", index, "minimumLength"], message: "Minimum text length must not exceed maximum length." });
+        const seen = new Set();
+        criterion.anchors?.forEach((anchor, anchorIndex) => { const value = anchor.value; const valid = criterion.kind === "score" ? typeof value === "number" && Number.isFinite(value) && value >= criterion.minimum && value <= criterion.maximum && Math.abs((value - criterion.minimum) / criterion.step - Math.round((value - criterion.minimum) / criterion.step)) < 1e-8 : criterion.kind === "category" ? typeof value === "string" && criterion.options.includes(value) : criterion.kind === "boolean" ? typeof value === "boolean" : criterion.kind === "preference" ? ["A", "B", ...(criterion.allowTie ? ["tie"] : [])].includes(String(value)) : typeof value === "string"; const key = JSON.stringify(value); if (!valid || seen.has(key))
+            ctx.addIssue({ code: "custom", path: ["criteria", index, "anchors", anchorIndex, "value"], message: "Each anchor must describe a unique valid raw value." }); seen.add(key); });
+    });
+    if (new Set(form.criteria.map(c => c.id)).size !== form.criteria.length)
+        ctx.addIssue({ code: "custom", path: ["criteria"], message: "Criterion IDs must be unique." });
+    if (form.mode === "individual" && form.criteria.some(c => c.kind === "preference"))
+        ctx.addIssue({ code: "custom", path: ["criteria"], message: "Preferences require an explicit pair." });
+});
+export const HumanAttemptRefSchema = z.object({ localSource: z.union([HumanLocalAttemptOriginSchema, HumanNativeAttemptOriginSchema]).optional(), recordedSource: z.object({ id: Id, snapshotHash: ReleaseHashSchema, boundaryId: Id, boundaryRevisionHash: ReleaseHashSchema }).strict().optional(), experimentId: Id, attemptId: Id, taskId: Id, targetId: Id, output: ReviewReleaseSchema, trace: ReviewReleaseSchema.nullable(), familyKey: Id, split: z.enum(["train", "validation", "test", "frozen_eval"]) }).strict();
+export const HumanEvidenceSchema = z.object({ publication: ReviewReleaseSchema.optional(), dataset: ReviewReleaseSchema, grader: ReviewReleaseSchema, graderBinding: z.object({ id: Id, version: z.string().min(1).max(100), contentHash: ReleaseHashSchema }).strict(), rubric: ReviewReleaseSchema, attempts: z.array(HumanAttemptRefSchema).max(2), taskIds: z.array(Id).min(1).max(1000).optional() }).strict().superRefine((e, ctx) => {
+    if (!e.attempts.length && !e.taskIds?.length)
+        ctx.addIssue({ code: "custom", message: "Select retained attempts or exact tasks." });
+    if (e.taskIds && new Set(e.taskIds).size !== e.taskIds.length)
+        ctx.addIssue({ code: "custom", path: ["taskIds"], message: "Select each task once." });
+    if (e.attempts.length === 2 && (e.attempts[0].attemptId === e.attempts[1].attemptId || e.attempts[0].taskId !== e.attempts[1].taskId || e.attempts[0].familyKey !== e.attempts[1].familyKey || e.attempts[0].split !== e.attempts[1].split))
+        ctx.addIssue({ code: "custom", path: ["attempts"], message: "A/B review requires distinct attempts of the same task, family and split." });
+});
+export const HumanAnswerSchema = z.object({ criterionId: Id, value: z.union([z.number().finite(), z.boolean(), z.string().max(20_000), z.null()]), abstain: z.boolean(), note: z.string().max(20_000), strength: z.enum(["slight", "moderate", "strong"]).optional() }).strict();
+export const HumanPolicySchema = z.object({ approval: z.enum(["none", "manager"]), minimumRaters: z.number().int().min(1).max(100), managerIds: z.array(Id).max(100), reviewerIds: z.array(Id).max(100), queueClaim: z.boolean(), teamVisible: z.boolean(), distinctManager: z.boolean().optional(), independentRaters: z.boolean().optional(), blindPair: z.boolean().optional() }).strict().superRefine((p, c) => {
+    if (p.approval === "none" && p.minimumRaters !== 1)
+        c.addIssue({ code: "custom", path: ["minimumRaters"], message: "Multi-rater review requires explicit adjudication." });
+});
+const SubmissionSchema = z.object({ taskProposal: HumanTaskProposalSchema.optional(), id: Id, revision: z.number().int().positive(), actorId: Id, generation: z.number().int().positive(), evidenceHash: ReleaseHashSchema, formHash: ReleaseHashSchema, answers: z.array(HumanAnswerSchema).max(100), note: z.string().max(20_000), submittedAt: ReleaseTimestampSchema, supersedes: Id.nullable(), contentHash: ReleaseHashSchema }).strict();
+const DecisionSchema = z.object({ taskProposalHash: ReleaseHashSchema.optional(), id: Id, revision: z.number().int().positive(), actorId: Id, outcome: z.enum(["accept", "reject", "request_changes"]), submissions: z.array(z.object({ id: Id, contentHash: ReleaseHashSchema }).strict()).min(1).max(100), answers: z.array(HumanAnswerSchema).max(100), note: z.string().max(20_000), decidedAt: ReleaseTimestampSchema, contentHash: ReleaseHashSchema }).strict();
+export const HumanReviewSchema = z.object({ schemaVersion: z.literal("openpond.humanReview.v1"), id: Id, revision: z.number().int().positive(), scope: Id, projectId: Id, createdBy: Id, kind: z.enum(["author", "execute", "grade"]), dueAt: ReleaseTimestampSchema.optional(), title: z.string().trim().min(1).max(500), authorPublication: z.object({ proposalHash: ReleaseHashSchema, dataset: ReviewReleaseSchema, operationId: Id, publishedBy: Id, publishedAt: ReleaseTimestampSchema }).strict().nullable(), evidence: HumanEvidenceSchema, form: HumanFormSchema, policy: HumanPolicySchema, status: z.enum(["queued", "assigned", "in_progress", "submitted", "returned", "accepted", "rejected", "cancelled"]), assigneeId: Id.nullable(), generation: z.number().int().positive(), drafts: z.array(z.object({ taskProposal: HumanTaskProposalSchema.optional(), actorId: Id, generation: z.number().int().positive(), answers: z.array(HumanAnswerSchema).max(100), note: z.string().max(20_000), updatedAt: ReleaseTimestampSchema }).strict()).max(100), submissions: z.array(SubmissionSchema).max(1000), decisions: z.array(DecisionSchema).max(1000), audit: z.array(z.object({ actorId: Id, action: z.enum(["claim", "reassign", "cancel"]), priorAssigneeId: Id.nullable(), assigneeId: Id.nullable(), generation: z.number().int().positive(), note: z.string().max(20_000), occurredAt: ReleaseTimestampSchema }).strict()).max(1000), execution: z.object({ executionId: Id.nullable(), operationId: Id, boundBy: Id, configurationHash: ReleaseHashSchema, generation: z.number().int().positive(), result: ReviewReleaseSchema.nullable() }).strict().nullable(), createdAt: ReleaseTimestampSchema, updatedAt: ReleaseTimestampSchema, contentHash: ReleaseHashSchema }).strict();
+const Mutation = { operationId: Id, id: Id, expectedRevision: z.number().int().nonnegative() };
+export const HumanReviewCommandSchema = z.discriminatedUnion("action", [
+    z.object({ ...Mutation, action: z.literal("create"), projectId: Id, kind: HumanReviewSchema.shape.kind, title: HumanReviewSchema.shape.title, dueAt: ReleaseTimestampSchema.optional(), evidence: HumanEvidenceSchema, form: HumanFormSchema, policy: HumanPolicySchema, assigneeId: Id.nullable() }).strict(),
+    z.object({ ...Mutation, action: z.literal("claim") }).strict(),
+    z.object({ ...Mutation, action: z.literal("bind_author_publication"), proposalHash: ReleaseHashSchema, dataset: ReviewReleaseSchema }).strict(),
+    z.object({ ...Mutation, action: z.literal("reserve_execution"), generation: z.number().int().positive(), runOperationId: Id, configurationHash: ReleaseHashSchema }).strict(),
+    z.object({ ...Mutation, action: z.literal("bind_execution"), generation: z.number().int().positive(), executionId: Id, runOperationId: Id, configurationHash: ReleaseHashSchema }).strict(),
+    z.object({ ...Mutation, action: z.literal("reassign"), assigneeId: Id.nullable(), note: z.string().trim().min(1).max(20_000) }).strict(),
+    z.object({ ...Mutation, action: z.literal("cancel"), note: z.string().max(20_000) }).strict(),
+    z.object({ ...Mutation, action: z.literal("save_draft"), taskProposal: HumanTaskProposalSchema.optional(), generation: z.number().int().positive(), answers: z.array(HumanAnswerSchema).max(100), note: z.string().max(20_000) }).strict(),
+    z.object({ ...Mutation, action: z.literal("submit"), taskProposal: HumanTaskProposalSchema.optional(), generation: z.number().int().positive(), evidenceHash: ReleaseHashSchema, formHash: ReleaseHashSchema, executionResult: ReviewReleaseSchema.optional(), answers: z.array(HumanAnswerSchema).max(100), note: z.string().max(20_000) }).strict(),
+    z.object({ ...Mutation, action: z.literal("decide"), taskProposalHash: ReleaseHashSchema.optional(), outcome: DecisionSchema.shape.outcome, submissions: DecisionSchema.shape.submissions, answers: DecisionSchema.shape.answers, note: DecisionSchema.shape.note }).strict(),
+]);
+export const HumanReviewRequestSchema = z.discriminatedUnion("endpoint", [
+    z.object({ endpoint: z.literal("command"), scope: Id, command: HumanReviewCommandSchema }).strict(),
+    z.object({ endpoint: z.literal("get"), scope: Id, id: Id, revision: z.number().int().positive().optional() }).strict(),
+    z.object({ endpoint: z.literal("inbox"), scope: Id, projectId: Id.optional(), view: z.enum(["mine", "team", "approval"]), status: z.enum(["active", "history"]), afterId: Id.optional(), limit: z.number().int().min(1).max(100) }).strict(),
+]);
+export function sealHumanRecord(record) { return { ...record, contentHash: contentHash(record) }; }
+export function assertHumanAnswers(form, answers, complete) {
+    if (new Set(answers.map(a => a.criterionId)).size !== answers.length)
+        throw new Error("human_duplicate_criterion");
+    for (const answer of answers) {
+        const criterion = form.criteria.find(c => c.id === answer.criterionId);
+        if (!criterion)
+            throw new Error("human_unknown_criterion");
+        if (complete && criterion.requireRationale && !answer.note.trim())
+            throw new Error("human_rationale_required");
+        if (complete && criterion.kind === "preference" && criterion.requireStrength && !answer.strength && !answer.abstain)
+            throw new Error("human_preference_strength_required");
+        if (answer.abstain) {
+            if (!criterion.allowAbstain || answer.value !== null || !answer.note.trim())
+                throw new Error("human_abstention_invalid");
+            continue;
+        }
+        const v = answer.value;
+        if (!complete && v === null)
+            continue;
+        const valid = criterion.kind === "score" ? typeof v === "number" && v >= criterion.minimum && v <= criterion.maximum && Math.abs((v - criterion.minimum) / criterion.step - Math.round((v - criterion.minimum) / criterion.step)) < 1e-8
+            : criterion.kind === "category" ? typeof v === "string" && criterion.options.includes(v)
+                : criterion.kind === "boolean" ? typeof v === "boolean"
+                    : criterion.kind === "preference" ? ["A", "B", ...(criterion.allowTie ? ["tie"] : [])].includes(String(v))
+                        : typeof v === "string" && v.length >= (criterion.minimumLength ?? 0) && v.length <= criterion.maximumLength && (!criterion.required || Boolean(v.trim()));
+        if (!valid)
+            throw new Error("human_answer_invalid");
+    }
+    if (complete && form.criteria.some(c => c.required && !answers.some(a => a.criterionId === c.id)))
+        throw new Error("human_required_answer_missing");
+}
+export const HumanReviewViewSchema = HumanReviewSchema.omit({ evidence: true, drafts: true, submissions: true }).extend({ drafts: z.array(HumanReviewSchema.shape.drafts.element.omit({ taskProposal: true }).extend({ taskProposal: HumanTaskProposalViewSchema.optional() })).max(100), submissions: z.array(SubmissionSchema.omit({ taskProposal: true }).extend({ taskProposal: HumanTaskProposalViewSchema.optional() })).max(1000), evidence: HumanEvidenceSchema.nullable(), evidenceHash: ReleaseHashSchema, formHash: ReleaseHashSchema, permissions: z.object({ owner: z.boolean(), manager: z.boolean(), reviewer: z.boolean(), claim: z.boolean() }).strict() }).strict();
+export const HumanInboxSchema = z.object({ items: z.array(HumanReviewViewSchema).max(100), nextCursor: Id.nullable(), actionCount: z.number().int().nonnegative(), approvalAvailable: z.boolean() }).strict();
+export const HumanSnapshotRequestSchema = z.object({ endpoint: z.literal("snapshot"), scope: Id, projectId: Id, graderId: Id, selections: z.array(z.object({ executionId: Id, receiptId: Id }).strict()).min(1).max(2) }).strict();
+export const HumanTasksSnapshotRequestSchema = z.object({ endpoint: z.literal("snapshot_tasks"), scope: Id, projectId: Id, graderId: Id, dataset: ReviewReleaseSchema, taskIds: z.array(Id).min(1).max(1000).optional(), all: z.literal(true).optional() }).strict().refine(value => Boolean(value.all) !== Boolean(value.taskIds), "Choose an exact selected task list or the server-frozen full Dataset.");
+export const HumanInspectRequestSchema = z.object({ endpoint: z.literal("inspect"), scope: Id, id: Id, slot: z.number().int().min(0).max(1).optional(), afterId: z.string().min(1).max(500).optional() }).strict();
+export const HumanResultsReadRequestSchema = z.object({ endpoint: z.literal("results"), scope: Id, executionId: Id, selection: z.array(ReviewReleaseSchema).max(10000).optional() }).strict();
+export const HumanMembersRequestSchema = z.object({ endpoint: z.literal("members"), scope: Id }).strict();
+export const HumanExecuteRequestSchema = z.object({ endpoint: z.literal("execute"), scope: Id, id: Id, expectedRevision: z.number().int().positive(), generation: z.number().int().positive(), operationId: Id, configuration: z.unknown() }).strict();
+export const HumanExecutionReadRequestSchema = z.object({ endpoint: z.literal("execution"), scope: Id, id: Id, action: z.enum(["status", "result", "cancel"]) }).strict();
+export const HumanPublishEvidenceRequestSchema = HumanSnapshotRequestSchema.omit({ endpoint: true }).extend({ endpoint: z.literal("publish_evidence"), operationId: Id, audience: z.array(Id).max(100), workspaceVisible: z.boolean() }).strict();
+export const HumanPublicationAccessRequestSchema = z.object({ endpoint: z.literal("publication_access"), scope: Id, projectId: Id }).strict();
+export const HumanRevokePublicationRequestSchema = z.object({ endpoint: z.literal("revoke_publication"), scope: Id, publication: ReviewReleaseSchema }).strict();
+export const HumanPublishAuthorRequestSchema = z.object({ endpoint: z.literal("publish_author"), scope: Id, id: Id, expectedRevision: z.number().int().positive(), operationId: Id, proposalHash: ReleaseHashSchema, workspaceId: Id.optional(), expectedWorkspaceRevision: z.number().int().positive().optional() }).strict();
+export const HumanAuthorTasksRequestSchema = z.object({ endpoint: z.literal("author_tasks"), scope: Id, id: Id, includeReference: z.literal(true).optional() }).strict();
+export const HumanGraderChoicesRequestSchema = z.object({ endpoint: z.literal("graders"), scope: Id, projectId: Id, dataset: ReviewReleaseSchema }).strict();
+export const HumanGraderChoicesSchema = z.array(z.object({ id: Id, name: z.string(), version: z.string(), contentHash: ReleaseHashSchema, mode: z.enum(["individual", "pairwise"]) }).strict()).max(1000);
+export const HumanReviewTransportSchema = z.union([HumanRevokeLocalPublicationSchema, HumanLocalPublicationsReadSchema, HumanExportLocalRequestSchema, HumanPublishLocalRequestSchema, HumanShareLocalRequestSchema, HumanPublicationAccessRequestSchema, HumanPublishAuthorRequestSchema, HumanAuthorTasksRequestSchema, HumanGraderChoicesRequestSchema, HumanPublishEvidenceRequestSchema, HumanRevokePublicationRequestSchema, HumanExecuteRequestSchema, HumanExecutionReadRequestSchema, HumanReviewRequestSchema, HumanSnapshotRequestSchema, HumanTasksSnapshotRequestSchema, HumanInspectRequestSchema, HumanResultsReadRequestSchema, HumanMembersRequestSchema]);
+export const HumanInspectionSchema = z.array(z.object({ origin: z.literal("owner_attested_local").optional(), coverage: z.object({ sourceEventCount: z.number().int().nonnegative(), publishedEventCount: z.number().int().nonnegative(), traceLimited: z.boolean(), artifactsIncluded: z.literal(false) }).strict().optional(), reviewId: Id, reviewRevision: z.number().int().positive(), evidenceHash: ReleaseHashSchema, slot: z.string(), input: z.unknown(), output: z.unknown(), error: z.string().nullable(), events: z.array(z.record(z.string(), z.unknown())), eventCount: z.number().int().nonnegative(), evidenceLimited: z.boolean(), nextEventCursor: z.string().nullable(), slotIndex: z.number().int().nonnegative(), executionId: Id.optional(), receiptId: Id.optional() }).strict()).max(1000);

package/dist/human-review/execution.js

@@ -0,0 +1,61 @@
+import { contentHash } from "@openpond/harness";
+import { LearningDomainError } from "../learning/errors.js";
+/** Reserve before I/O; recovery reads the original owner's durable admission.
+ * A reservation with unknown admission never becomes a second dispatch. */
+export async function dispatchAssignedHumanExecution(input) {
+    const { service, context, request } = input, opened = await service.get(context, request.id);
+    if (opened.kind !== "execute" || opened.generation !== request.generation)
+        throw new LearningDomainError("human_execution_assignment_stale", 409);
+    const retained = opened.execution;
+    if (retained && retained.boundBy !== context.actorId)
+        throw new LearningDomainError("human_execution_executor_changed", 403);
+    const runOperationId = retained?.operationId ?? `human-run-${contentHash([context.actorId, request.id, request.operationId])}`;
+    const raw = input.configuration;
+    const configuration = { ...raw, operationId: runOperationId, request: { ...raw.request, operationId: runOperationId } }, configurationHash = contentHash(configuration);
+    const reserved = retained ? opened : await service.command(context, { action: "reserve_execution", id: request.id, expectedRevision: request.expectedRevision, operationId: `reserve-${request.operationId}`, generation: request.generation, runOperationId, configurationHash });
+    if (!reserved.execution || reserved.execution.operationId !== runOperationId || reserved.execution.configurationHash !== configurationHash)
+        throw new LearningDomainError("human_execution_reservation_conflict", 409);
+    const current = await service.get(context, request.id);
+    if (current.execution?.executionId) {
+        if (current.status === "cancelled")
+            await input.cancel(current);
+        return current;
+    }
+    let dispatched;
+    if (retained)
+        dispatched = await input.recover(current);
+    else {
+        if (current.generation !== reserved.generation || ["accepted", "rejected", "cancelled"].includes(current.status))
+            throw new LearningDomainError("human_execution_assignment_stale", 409);
+        try {
+            dispatched = await input.dispatch(configuration, current);
+        }
+        catch (error) {
+            dispatched = await input.recover(await service.get(context, request.id));
+            if (!dispatched)
+                throw error;
+        }
+    }
+    if (!dispatched)
+        throw new LearningDomainError("human_execution_admission_recovery_pending", 409, "The original execution admission is unavailable. Recover its retained owner outcome before retrying this assignment.");
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const latest = await service.get(context, request.id);
+        if (latest.generation !== reserved.generation || !latest.execution || latest.execution.operationId !== runOperationId)
+            throw new LearningDomainError("human_execution_assignment_stale", 409);
+        let bound;
+        try {
+            bound = latest.execution.executionId ? latest : await service.command(context, { action: "bind_execution", id: request.id, expectedRevision: latest.revision, operationId: `bind-${runOperationId}`, generation: request.generation, runOperationId, configurationHash, executionId: dispatched.id });
+        }
+        catch (error) {
+            if (error instanceof LearningDomainError && error.code === "human_revision_conflict")
+                continue;
+            throw error;
+        }
+        if (bound.execution?.executionId !== dispatched.id)
+            throw new LearningDomainError("human_execution_binding_conflict", 409);
+        if (bound.status === "cancelled")
+            await input.cancel(bound);
+        return bound;
+    }
+    throw new LearningDomainError("human_execution_binding_recovery_pending", 409, "The assignment changed while retaining its execution. Retry the original operation to recover that exact run.");
+}

package/dist/human-review/handoff.js

@@ -0,0 +1,18 @@
+import { contentHash } from "@openpond/harness";
+import { HumanReviewSchema } from "./contracts.js";
+import { LearningDomainError } from "../learning/errors.js";
+/** Call only after current host authority/evidence checks. Acceptance grants no learning use or adoption. */
+export function acceptedHumanEvidence(raw, expected) {
+    const review = HumanReviewSchema.parse(raw);
+    const { contentHash: hash, ...content } = review;
+    const decision = review.decisions.at(-1);
+    if (hash !== contentHash(content) || hash !== expected.reviewHash || review.status !== "accepted" || !decision || decision.outcome !== "accept" || decision.contentHash !== expected.decisionHash)
+        throw new LearningDomainError("human_accepted_revision_unavailable", 409);
+    const submissions = decision.submissions.map(ref => {
+        const submission = review.submissions.find(s => s.id === ref.id && s.contentHash === ref.contentHash);
+        if (!submission || submission.evidenceHash !== contentHash(review.evidence) || submission.formHash !== contentHash(review.form))
+            throw new LearningDomainError("human_accepted_lineage_invalid", 409);
+        return { id: submission.id, revision: submission.revision, contentHash: submission.contentHash };
+    });
+    return { schemaVersion: "openpond.acceptedHumanEvidence.v1", scope: review.scope, projectId: review.projectId, review: { id: review.id, revision: review.revision, contentHash: hash }, sourceOrigins: review.evidence.attempts.map(attempt => attempt.localSource ? attempt.localSource.kind : attempt.recordedSource ? "recorded_evidence" : "hosted_retained"), decision: { id: decision.id, revision: decision.revision, contentHash: decision.contentHash }, submissions, evidence: review.evidence, answers: decision.answers, ...(review.execution?.result ? { execution: { id: review.execution.executionId, result: review.execution.result, configurationHash: review.execution.configurationHash } } : {}), ...(decision.taskProposalHash ? { taskProposal: review.submissions.find(s => s.taskProposal?.contentHash === decision.taskProposalHash).taskProposal } : {}) };
+}

package/dist/human-review/index.js

@@ -0,0 +1,9 @@
+export * from "./contracts.js";
+export * from "./repository.js";
+export * from "./service.js";
+export * from "./handoff.js";
+export * from "./results.js";
+export * from "./execution.js";
+export * from "./task-proposals.js";
+export * from "./local-publication.js";
+export * from "./comparison.js";

package/dist/human-review/local-publication.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { contentHash, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+const Id = ReleaseIdSchema, Hash = ReleaseHashSchema;
+const Release = z.object({ id: Id, revision: z.number().int().positive(), contentHash: Hash }).strict();
+export const HumanLocalAttemptOriginSchema = z.object({ kind: z.literal("owner_attested_local"), ownerActorId: Id, teamId: Id, executionHash: Hash, configurationHash: Hash, retainedAttemptHash: Hash, traceHash: Hash, publicationCutoffHash: Hash }).strict();
+export const HumanNativeAttemptOriginSchema = HumanLocalAttemptOriginSchema.omit({ publicationCutoffHash: true, kind: true }).extend({ kind: z.literal("native_local") }).strict();
+const Attempt = z.object({ origin: HumanLocalAttemptOriginSchema, executionId: Id, receiptId: Id, taskId: Id, targetId: Id, familyKey: Id, split: z.enum(["train", "validation", "test", "frozen_eval"]), input: z.record(z.string(), z.unknown()), policyVisibleContext: z.record(z.string(), z.unknown()), output: z.string().nullable(), error: z.string().nullable(), events: z.array(z.record(z.string(), z.unknown())).max(1000), coverage: z.object({ sourceEventCount: z.number().int().nonnegative().max(20000), publishedEventCount: z.number().int().nonnegative().max(1000), traceLimited: z.boolean(), artifactsIncluded: z.literal(false) }).strict() }).strict().superRefine((value, context) => { if (value.events.length !== value.coverage.publishedEventCount || value.coverage.sourceEventCount < value.events.length || value.coverage.traceLimited !== (value.coverage.sourceEventCount > value.events.length))
+    context.addIssue({ code: "custom", message: "Publication coverage must describe its actual retained event population." }); if (contentHash(value.events) !== value.origin.publicationCutoffHash)
+    context.addIssue({ code: "custom", message: "Published trace cutoff changed." }); });
+const Content = z.object({ schemaVersion: z.literal("openpond.humanLocalEvidenceExport.v1"), actorId: Id, scope: Id, projectId: Id, dataset: Release, graderId: Id, compiledGraderHash: Hash, attempts: z.array(Attempt).min(1).max(2), sealedAt: ReleaseTimestampSchema }).strict().superRefine((value, context) => { if (value.attempts.some(attempt => attempt.origin.ownerActorId !== value.actorId || attempt.origin.teamId !== value.scope))
+    context.addIssue({ code: "custom", message: "Local publication belongs to another actor/workspace." }); });
+export const HumanLocalEvidenceExportSchema = Content.safeExtend({ contentHash: Hash }).strict().superRefine((value, context) => { const { contentHash: hash, ...content } = value; if (contentHash(content) !== hash)
+    context.addIssue({ code: "custom", message: "Local evidence export bytes changed." }); });
+export const HumanExportLocalRequestSchema = z.object({ endpoint: z.literal("export_local"), scope: Id, projectId: Id, graderId: Id, selections: z.array(z.object({ executionId: Id, receiptId: Id }).strict()).min(1).max(2) }).strict();
+export const HumanPublishLocalRequestSchema = z.object({ endpoint: z.literal("publish_local"), scope: Id, projectId: Id, operationId: Id, audience: z.array(Id).max(100), workspaceVisible: z.boolean(), evidence: HumanLocalEvidenceExportSchema }).strict();
+export const HumanShareLocalRequestSchema = HumanExportLocalRequestSchema.omit({ endpoint: true }).extend({ endpoint: z.literal("share_local"), operationId: Id, audience: z.array(Id).max(100), workspaceVisible: z.boolean() }).strict();
+export const HumanLocalPublicationsReadSchema = z.object({ endpoint: z.literal("local_publications"), scope: Id, executionId: Id }).strict();
+export const HumanRevokeLocalPublicationSchema = z.object({ endpoint: z.literal("revoke_local"), scope: Id, publication: Release }).strict();

package/dist/human-review/repository.js

@@ -0,0 +1 @@
+export {};

package/dist/human-review/results.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+import { HumanAnswerSchema, HumanReviewSchema, ReviewReleaseSchema, sealHumanRecord } from "./contracts.js";
+import { LearningDomainError } from "../learning/errors.js";
+const Content = z.object({ schemaVersion: z.literal("openpond.humanResultView.v1"), executionId: z.string().min(1), executionHash: z.string().regex(/^[a-f0-9]{64}$/), selection: z.array(ReviewReleaseSchema).max(10000), coverage: z.object({ pending: z.number().int().nonnegative(), submitted: z.number().int().nonnegative(), accepted: z.number().int().nonnegative(), rejected: z.number().int().nonnegative(), cancelled: z.number().int().nonnegative() }).strict(), results: z.array(z.object({ review: ReviewReleaseSchema, decision: ReviewReleaseSchema.nullable(), attemptIds: z.array(z.string().min(1)).min(1).max(2), mode: z.enum(["individual", "pairwise"]), origin: z.enum(["hosted_retained", "recorded_evidence", "owner_attested_local", "native_local"]), status: z.enum(["pending", "submitted", "accepted", "rejected", "cancelled"]), grader: ReviewReleaseSchema, answers: z.array(HumanAnswerSchema).max(100) }).strict()).max(10000) }).strict();
+export const HumanResultViewSchema = Content.extend({ contentHash: z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+/** A content-addressed view retains selected review revisions; automatic execution receipts remain untouched. */
+export function createHumanResultView(input) {
+    const selected = input.reviews.map(raw => { const r = HumanReviewSchema.parse(raw), { contentHash: hash, ...body } = r; if (contentHash(body) !== hash || !r.evidence.attempts.some(a => a.experimentId === input.executionId))
+        throw new LearningDomainError("human_result_selection_mismatch", 409); return r; });
+    if (new Set(selected.map(r => r.id)).size !== selected.length)
+        throw new LearningDomainError("human_result_duplicate_review", 422);
+    const results = selected.map(r => { const d = r.decisions.at(-1); return { review: { id: r.id, revision: r.revision, contentHash: r.contentHash }, decision: d ? { id: d.id, revision: d.revision, contentHash: d.contentHash } : null, attemptIds: r.evidence.attempts.map(a => a.attemptId), mode: r.form.mode, origin: r.evidence.attempts.some(attempt => attempt.localSource?.kind === "owner_attested_local") ? "owner_attested_local" : r.evidence.attempts.some(attempt => attempt.localSource?.kind === "native_local") ? "native_local" : r.evidence.attempts.some(attempt => attempt.recordedSource) ? "recorded_evidence" : "hosted_retained", status: r.status === "accepted" ? "accepted" : r.status === "rejected" ? "rejected" : r.status === "cancelled" ? "cancelled" : r.status === "submitted" ? "submitted" : "pending", grader: r.evidence.grader, answers: r.status === "accepted" && d?.outcome === "accept" ? d.answers : [] }; });
+    const coverage = { pending: 0, submitted: 0, accepted: 0, rejected: 0, cancelled: 0 };
+    for (const r of results)
+        coverage[r.status]++;
+    return HumanResultViewSchema.parse(sealHumanRecord(Content.parse({ schemaVersion: "openpond.humanResultView.v1", executionId: input.executionId, executionHash: input.executionHash, selection: results.map(r => r.review), coverage, results })));
+}