@openpond/evals 0.10.6 → 0.10.8

package/LEARNING.md

@@ -79,6 +79,24 @@ for untrusted schemas and deliberately rejects unsupported capabilities.
 
 ## Host responsibilities
 
+### Accepted checkpoints between iterations
+
+Candidate decisions are reconciled with their verified `decidedAt`, immutable
+decision reference, execution, evaluation and terminal receipt. The chain records
+the latest accepted candidate. New reservations capture its exact accepted
+iteration revision in `trainingParentSelection`; `trainingParent` becomes that
+candidate's artifact reference. Before the first acceptance, the configured base
+parent is used. A rejected candidate is removed from future parent selection;
+already reserved iterations keep their captured parent and original review.
+
+`inspectPolicy` returns the resolved next `trainingParent`, or a blocker when its
+accepted evidence or underlying model/method is incompatible. Execution owners
+must resolve the captured iteration revision, verify the team/Model-scoped
+terminal checkpoint and materialize it through their existing continuation
+adapter. The hosted adapter uses fresh optimizer state. Acceptance does not
+activate serving. Candidate decisions lacking verified timing must be reconciled
+from their retained provider receipts before another reservation can use them.
+
 ### Reward fixture checks
 
 Reward drafts may contain up to 50 named fixtures. JSON and numeric editor fields

package/dist/learning/authoring-service.js

@@ -2,7 +2,7 @@ import { assertBoundedTaskJson } from "../task-schema.js";
 import { AuthoringDraftSchema } from "./authoring.js";
 import { LearningDomainError } from "./errors.js";
 import { learningRef, sameLearningRef, sealLearningContent } from "./contracts.js";
-import { requireLearningRelease } from "./repository.js";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
 export async function saveAuthoringDraft(tx, input, now) {
     // A 100-record page remains below the common 16 MiB response limit.
     assertBoundedTaskJson(input.draft, 131_072);
@@ -14,6 +14,16 @@ export async function saveAuthoringDraft(tx, input, now) {
             throw new LearningDomainError("authoring_draft_base_mismatch", 422);
         await requireLearningRelease(tx, input.draft.targetKind, input.draft.baseRelease);
     }
+    if (input.draft.targetKind === "reward")
+        for (const fixture of input.draft.fields.fixtures ?? []) {
+            if (!fixture.sourceLabel)
+                continue;
+            const { evidence, feedback } = fixture.sourceLabel;
+            await requireLearningRelease(tx, "evidence", evidence);
+            const label = await requireLearningResource(tx, "feedback", feedback.id, feedback.revision);
+            if (!label.evidence || !sameLearningRef(label.evidence, evidence))
+                throw new LearningDomainError("reward_fixture_label_mismatch", 422);
+        }
     const draft = AuthoringDraftSchema.parse(sealLearningContent({ ...input.draft, schemaVersion: "openpond.authoringDraft.v1", revision: input.expectedRevision + 1, status: "draft", publishedRelease: null, createdAt: previous?.createdAt ?? now, updatedAt: now }));
     await tx.put("draft", draft, input.expectedRevision, { parentId: draft.targetKind, status: draft.status });
     return { kind: "draft", id: draft.id, revision: draft.revision };

package/dist/learning/authoring.js

@@ -10,6 +10,7 @@ export const RewardFixtureAuthoringFieldsSchema = z.object({
     infrastructureError: z.string().max(20_000),
     expectedStatus: z.enum(["scored", "pending", "unavailable", "failed"]),
     minimumScore: z.string(), maximumScore: z.string(), expectedPassed: z.enum(["true", "false", "any"]),
+    sourceLabel: z.object({ evidence: LearningRevisionRefSchema, feedback: z.object({ id: ReleaseIdSchema, revision: z.number().int().positive() }).strict() }).strict().optional(),
 }).strict();
 export const RewardAuthoringFieldsSchema = z.object({
     name: z.string().max(500), description: z.string().max(10_000),

package/dist/learning/contracts.js

@@ -105,6 +105,20 @@ export const TaskEvidenceContentSchema = z.object({
     receivedAt: ReleaseTimestampSchema,
 }).strict();
 export const TaskEvidenceSchema = TaskEvidenceContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+/** A retained judgment of this exact attempt, separate from task admission. */
+export const TaskRatingSchema = z.object({
+    schemaVersion: z.literal("openpond.taskRating.v1"),
+    criteria: z.string().trim().min(1).max(20_000),
+    scale: z.object({ minimum: z.number().finite(), maximum: z.number().finite() }).strict(),
+    score: z.number().finite(),
+    evidence: z.string().max(20_000),
+    explanation: z.string().max(20_000),
+}).strict().superRefine((rating, context) => {
+    if (rating.scale.minimum >= rating.scale.maximum)
+        context.addIssue({ code: "custom", path: ["scale"], message: "The score scale must have an increasing range." });
+    if (rating.score < rating.scale.minimum || rating.score > rating.scale.maximum)
+        context.addIssue({ code: "custom", path: ["score"], message: "The score must be within its declared scale." });
+});
 export const TaskFeedbackSubmissionSchema = z.object({
     schemaVersion: z.literal("openpond.taskFeedback.v1"),
     sourceId: ReleaseIdSchema,
@@ -116,7 +130,18 @@ export const TaskFeedbackSubmissionSchema = z.object({
     kind: z.enum(["outcome", "target_correction", "ground_truth_correction", "input_correction", "family_resolution"]),
     value: LearningJsonObjectSchema,
     note: z.string().max(20_000),
-}).strict();
+}).strict().superRefine((submission, context) => {
+    if (submission.value.schemaVersion !== "openpond.taskRating.v1")
+        return;
+    if (submission.expectedEvidenceHash === null)
+        context.addIssue({ code: "custom", path: ["expectedEvidenceHash"], message: "A rating must identify the exact evidence revision." });
+    if (submission.kind !== "outcome")
+        context.addIssue({ code: "custom", path: ["kind"], message: "Ratings must be submitted as outcomes." });
+    const rating = TaskRatingSchema.safeParse(submission.value);
+    if (!rating.success)
+        for (const issue of rating.error.issues)
+            context.addIssue({ code: "custom", path: ["value", ...issue.path], message: issue.message });
+});
 export const TaskFeedbackSchema = z.object({
     schemaVersion: z.literal("openpond.taskFeedbackRecord.v1"),
     id: ReleaseIdSchema,
@@ -125,6 +150,7 @@ export const TaskFeedbackSchema = z.object({
     evidence: LearningRevisionRefSchema.nullable(),
     createdAt: ReleaseTimestampSchema,
     revision: z.number().int().positive(),
+    submittedBy: z.object({ id: ReleaseIdSchema, role: z.enum(["editor", "reviewer", "source"]), sourceId: ReleaseIdSchema.nullable() }).strict().nullable().default(null),
     review: z.object({ actorId: ReleaseIdSchema, decision: LearningRevisionRefSchema.nullable(), note: z.string().max(20_000), resolvedAt: ReleaseTimestampSchema }).strict().nullable().default(null),
 }).strict();
 export const TaskAdmissionDecisionContentSchema = z.object({
@@ -217,6 +243,13 @@ export const LearningPolicyContentSchema = z.object({
         context.addIssue({ code: "custom", path: ["limits"], message: "Daily spend must permit the iteration budget." });
 });
 export const LearningPolicySchema = LearningPolicyContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export const LearningAcceptedParentSchema = z.object({
+    iterationId: ReleaseIdSchema,
+    iterationRevision: z.number().int().positive(),
+    candidate: ImmutableReleaseRefSchema,
+    decision: LearningRevisionRefSchema,
+    decidedAt: ReleaseTimestampSchema,
+}).strict();
 export const LearningIterationStatusSchema = z.enum(["waiting_for_data", "waiting_for_review", "ready", "dispatching", "training", "evaluating", "candidate_ready", "accepted", "rejected", "paused", "failed", "cancelling", "cancelled", "completed_without_candidate"]);
 export const LearningIterationSchema = z.object({
     schemaVersion: z.literal("openpond.learningIteration.v1"),
@@ -228,12 +261,14 @@ export const LearningIterationSchema = z.object({
     batch: LearningRevisionRefSchema.nullable(),
     sourceWatermarks: z.record(ReleaseIdSchema, z.number().int().nonnegative()),
     trainingParent: ImmutableReleaseRefSchema,
+    trainingParentSelection: LearningAcceptedParentSchema.nullable().optional(),
     teacher: ImmutableReleaseRefSchema.nullable(),
     upstreamEvent: ImmutableReleaseRefSchema.nullable(),
     trainingJob: ImmutableReleaseRefSchema.nullable(),
     evaluationJob: ImmutableReleaseRefSchema.nullable(),
     candidateVersion: ImmutableReleaseRefSchema.nullable(),
     candidateDecision: LearningRevisionRefSchema.nullable().default(null),
+    candidateDecisionAt: ReleaseTimestampSchema.nullable().optional(),
     dispatchId: ReleaseIdSchema,
     retryCount: z.number().int().nonnegative(),
     spendUsd: z.number().nonnegative(),

package/dist/learning/index.js

@@ -9,6 +9,7 @@ export * from "./transport.js";
 export * from "./errors.js";
 export * from "./authoring.js";
 export * from "./reward-authoring.js";
+export * from "./rating-reward-fixture.js";
 export * from "./reward-checks.js";
 export * from "./reward-check-worker.js";
 export * from "./reward-fixture-executor.js";
@@ -16,6 +17,7 @@ export * from "./iteration-reservation-contracts.js";
 export * from "./iteration-dispatch-contracts.js";
 export * from "./iteration-dispatch-worker.js";
 export * from "./iteration-candidate-decision.js";
+export { resolveLearningTrainingParent } from "./iteration-training-parent.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";

package/dist/learning/iteration-candidate-decision.js

@@ -1,13 +1,15 @@
 import { z } from "zod";
-import { ImmutableReleaseRefSchema, ReleaseIdSchema } from "@openpond/harness";
+import { ImmutableReleaseRefSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
 import { LearningIterationSchema, LearningRevisionRefSchema } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
 import { LearningChainSchema } from "./iteration-reservation-contracts.js";
 import { requireLearningResource } from "./repository.js";
+import { latestAcceptedLearningParent } from "./iteration-training-parent.js";
 export const LearningCandidateDecisionObservationSchema = z.object({
     scope: ReleaseIdSchema,
     iterationId: ReleaseIdSchema,
     decision: LearningRevisionRefSchema,
+    decidedAt: ReleaseTimestampSchema,
     outcome: z.enum(["accepted", "rejected"]),
     execution: ImmutableReleaseRefSchema,
     candidate: ImmutableReleaseRefSchema,
@@ -34,18 +36,21 @@ export async function reconcileLearningCandidateDecision(repository, value, opti
         if (previous && input.decision.revision < previous.revision)
             return iteration;
         if (previous && input.decision.revision === previous.revision) {
-            if (!same(previous, input.decision) || iteration.status !== input.outcome)
+            if (!same(previous, input.decision) || iteration.status !== input.outcome
+                || (iteration.candidateDecisionAt != null && iteration.candidateDecisionAt !== input.decidedAt))
                 throw new LearningDomainError("learning_candidate_decision_revision_conflict", 409);
-            return iteration;
+            if (iteration.candidateDecisionAt != null)
+                return iteration;
         }
         const now = (options.now ?? (() => new Date().toISOString()))();
         const updated = LearningIterationSchema.parse({ ...iteration, revision: iteration.revision + 1,
-            candidateDecision: input.decision, status: input.outcome, updatedAt: now });
+            candidateDecision: input.decision, candidateDecisionAt: input.decidedAt, status: input.outcome, updatedAt: now });
         await tx.put("iteration", updated, iteration.revision, { parentId: dispatch.chainId, status: updated.status });
         const chain = await requireLearningResource(tx, "chain", dispatch.chainId);
-        if (chain.activeIterationId === iteration.id)
-            await tx.put("chain", LearningChainSchema.parse({ ...chain,
-                revision: chain.revision + 1, activeIterationId: null, updatedAt: now }), chain.revision, { parentId: chain.modelProjectId });
+        const acceptedParent = await latestAcceptedLearningParent(tx, chain.id);
+        await tx.put("chain", LearningChainSchema.parse({ ...chain, acceptedParent,
+            revision: chain.revision + 1, activeIterationId: chain.activeIterationId === iteration.id ? null : chain.activeIterationId,
+            updatedAt: now }), chain.revision, { parentId: chain.modelProjectId });
         return updated;
     });
 }

package/dist/learning/iteration-reservation-contracts.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
-import { LearningRevisionRefSchema } from "./contracts.js";
+import { LearningAcceptedParentSchema, LearningRevisionRefSchema } from "./contracts.js";
 export const LearningIterationTriggerSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("manual"), identity: ReleaseIdSchema }).strict(),
     z.object({ kind: z.literal("schedule"), scheduledAt: ReleaseTimestampSchema }).strict(),
@@ -12,6 +12,7 @@ export const LearningChainSchema = z.object({
     revision: z.number().int().positive(),
     modelProjectId: ReleaseIdSchema,
     activeIterationId: ReleaseIdSchema.nullable(),
+    acceptedParent: LearningAcceptedParentSchema.nullable().optional(),
     latestIterationId: ReleaseIdSchema,
     lastReservedAt: ReleaseTimestampSchema.nullable(),
     updatedAt: ReleaseTimestampSchema,

package/dist/learning/iteration-reservation-service.js

@@ -6,6 +6,7 @@ import { inspectIterationEligibility, learningChainId, learningConsumptionId } f
 import { readLearningIterationBudget } from "./iteration-budget.js";
 import { LearningChainSchema, LearningConsumptionSchema, LearningIterationReservationSchema } from "./iteration-reservation-contracts.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
+import { latestAcceptedLearningParent, resolveLearningTrainingParent } from "./iteration-training-parent.js";
 /** The caller owns one scope-serialized transaction. This never submits a Job. */
 export async function reserveLearningIteration(transaction, input, actorId, now) {
     const policy = await requireLearningRelease(transaction, "policy", input.policy);
@@ -44,6 +45,8 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     const ready = eligibility.counts.eligible >= policy.admission.minimumApprovedExamples;
     const status = ready ? "ready" : eligibility.counts.awaitingReview > 0 ? "waiting_for_review" : "waiting_for_data";
     const pointers = [];
+    const acceptedParent = await latestAcceptedLearningParent(transaction, chainId, true);
+    const parent = await resolveLearningTrainingParent(transaction, policy, acceptedParent);
     let batch = null;
     if (ready) {
         await assertAvailableBudget(transaction, chainId, now, policy.limits.maxIterationSpendUsd, policy.limits.maxDailySpendUsd);
@@ -68,7 +71,7 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
         triggerIdentity, batch,
         // Existing evidence has no ordered ingress sequence. Consumption records,
         // not a count or lexicographic ID cursor, decide whether an example is new.
-        sourceWatermarks: {}, trainingParent: policy.trainingParent, teacher: policy.teacher, upstreamEvent: null,
+        sourceWatermarks: {}, ...parent, teacher: policy.teacher, upstreamEvent: null,
         trainingJob: null, evaluationJob: null, candidateVersion: null, dispatchId: `dispatch-${contentHash(id)}`,
         retryCount: 0, spendUsd: 0, failure: null, createdAt: now, updatedAt: now,
     });
@@ -82,6 +85,7 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     const updatedChain = LearningChainSchema.parse({
         schemaVersion: "openpond.learningChain.v1", id: chainId, revision: (chain?.revision ?? 0) + 1,
         modelProjectId: policy.modelProjectId, activeIterationId: ready ? id : null, latestIterationId: id,
+        acceptedParent,
         lastReservedAt: ready ? now : chain?.lastReservedAt ?? null, updatedAt: now,
     });
     await transaction.put("iteration", iteration, 0, { parentId: chainId, status });

package/dist/learning/iteration-training-parent.js

@@ -0,0 +1,47 @@
+import { LearningAcceptedParentSchema, sameLearningRef } from "./contracts.js";
+import { LearningDomainError } from "./errors.js";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
+/** Select the latest accepted human decision. A later rejection removes that
+ * candidate from future selection without rewriting reserved descendants. */
+export async function latestAcceptedLearningParent(tx, chainId, requireComplete = false) {
+    let selected = null;
+    let afterId;
+    do {
+        const page = await tx.list("iteration", { parentId: chainId, status: "accepted", limit: 100, ...(afterId ? { afterId } : {}) });
+        for (const iteration of page.items) {
+            if (!iteration.candidateVersion || !iteration.candidateDecision || !iteration.candidateDecisionAt || !iteration.trainingJob) {
+                if (requireComplete)
+                    throw new LearningDomainError("learning_accepted_parent_evidence_missing", 409);
+                continue;
+            }
+            const candidate = LearningAcceptedParentSchema.parse({ iterationId: iteration.id, iterationRevision: iteration.revision,
+                candidate: iteration.candidateVersion, decision: iteration.candidateDecision, decidedAt: iteration.candidateDecisionAt });
+            const order = [Date.parse(candidate.decidedAt), candidate.decision.id, candidate.decision.revision];
+            const previous = selected ? [Date.parse(selected.decidedAt), selected.decision.id, selected.decision.revision] : null;
+            if (!previous || order[0] > previous[0] || (order[0] === previous[0]
+                && (order[1] > previous[1] || (order[1] === previous[1] && order[2] > previous[2]))))
+                selected = candidate;
+        }
+        afterId = page.nextCursor ?? undefined;
+    } while (afterId);
+    return selected;
+}
+/** Reservation captures an accepted revision before dispatch or later reviews.
+ * Switching the underlying base requires a separately reviewed learning chain. */
+export async function resolveLearningTrainingParent(tx, policy, selection) {
+    if (!selection)
+        return { trainingParent: policy.trainingParent, trainingParentSelection: null };
+    const parent = await requireLearningResource(tx, "iteration", selection.iterationId, selection.iterationRevision);
+    const sourcePolicy = await requireLearningRelease(tx, "policy", parent.policy);
+    if (parent.status !== "accepted" || !parent.candidateVersion || !parent.candidateDecision || !parent.trainingJob
+        || parent.candidateVersion.id !== selection.candidate.id || parent.candidateVersion.contentHash !== selection.candidate.contentHash
+        || !sameLearningRef(parent.candidateDecision, selection.decision) || parent.candidateDecisionAt !== selection.decidedAt
+        || sourcePolicy.modelProjectId !== policy.modelProjectId || sourcePolicy.executionOwner !== policy.executionOwner) {
+        throw new LearningDomainError("learning_accepted_parent_evidence_mismatch", 409);
+    }
+    if (sourcePolicy.trainingParent.id !== policy.trainingParent.id || sourcePolicy.trainingParent.contentHash !== policy.trainingParent.contentHash
+        || sourcePolicy.training.method !== policy.training.method) {
+        throw new LearningDomainError("learning_accepted_parent_configuration_mismatch", 409, "The accepted checkpoint belongs to a different starting model or training method.");
+    }
+    return { trainingParent: selection.candidate, trainingParentSelection: selection };
+}

package/dist/learning/policy-inspection.js

@@ -1,12 +1,13 @@
-import { ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { ImmutableReleaseRefSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
 import { z } from "zod";
-import { LearningRevisionRefSchema, learningRef, sameLearningRef } from "./contracts.js";
+import { LearningAcceptedParentSchema, LearningRevisionRefSchema, learningRef, sameLearningRef } from "./contracts.js";
 import { prepareLearningBatch } from "./batch-service.js";
 import { LearningDomainError } from "./errors.js";
 import { readLearningIterationBudget } from "./iteration-budget.js";
 import { inspectIterationEligibility, learningChainId } from "./iteration-eligibility.js";
 import { LearningChainSchema, LearningEligibilityCountsSchema } from "./iteration-reservation-contracts.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
+import { latestAcceptedLearningParent, resolveLearningTrainingParent } from "./iteration-training-parent.js";
 /** A scope-serialized snapshot of shared reservation readiness, not a Job guarantee.
  * No iteration, timer, batch, consumption or operation record is written. */
 export const LearningPolicyInspectionResultSchema = z.object({
@@ -14,6 +15,7 @@ export const LearningPolicyInspectionResultSchema = z.object({
     modelProjectId: ReleaseIdSchema,
     inspectedAt: ReleaseTimestampSchema,
     chain: LearningChainSchema.nullable(),
+    trainingParent: z.object({ reference: ImmutableReleaseRefSchema, selection: LearningAcceptedParentSchema.nullable() }).strict().nullable().default(null),
     counts: LearningEligibilityCountsSchema.nullable(),
     minimumApprovedExamples: z.number().int().positive(),
     canReserve: z.boolean(),
@@ -73,8 +75,18 @@ export async function inspectLearningPolicy(transaction, reference, actorId, now
         // must remain visible while the Model's settings and history can still load.
         block(error.code, error.message.slice(0, 20_000));
     }
+    let trainingParent = null;
+    try {
+        const resolved = await resolveLearningTrainingParent(transaction, policy, await latestAcceptedLearningParent(transaction, chainId, true));
+        trainingParent = { reference: resolved.trainingParent, selection: resolved.trainingParentSelection };
+    }
+    catch (error) {
+        if (!(error instanceof LearningDomainError))
+            throw error;
+        block(error.code, error.message.slice(0, 20_000));
+    }
     return LearningPolicyInspectionResultSchema.parse({
-        policy: learningRef(policy), modelProjectId: policy.modelProjectId, inspectedAt: now, chain,
+        policy: learningRef(policy), modelProjectId: policy.modelProjectId, inspectedAt: now, chain, trainingParent,
         counts, minimumApprovedExamples: policy.admission.minimumApprovedExamples, canReserve: blockers.length === 0,
         blockers, cooldownUntil,
         budget: { ...budget, maximumIterationSpendUsd: policy.limits.maxIterationSpendUsd, maximumDailySpendUsd: policy.limits.maxDailySpendUsd },

package/dist/learning/rating-reward-fixture.js

@@ -0,0 +1,19 @@
+import { learningRef, sameLearningRef, TaskRatingSchema } from "./contracts.js";
+import { LearningDomainError } from "./errors.js";
+/** Copy a retained label into editable check data while preserving its exact origin. */
+export function rewardFixtureFromRating(evidence, feedback, scale = { minimum: 0, maximum: 1 }) {
+    if (!feedback.evidence || !sameLearningRef(feedback.evidence, learningRef(evidence)) || feedback.submission.expectedEvidenceHash !== evidence.contentHash || feedback.submission.kind !== "outcome" || !evidence.submission.observedOutput)
+        throw new LearningDomainError("rating_fixture_evidence_mismatch", 422);
+    const rating = TaskRatingSchema.parse(feedback.submission.value);
+    if (!Number.isFinite(scale.minimum) || !Number.isFinite(scale.maximum) || scale.minimum >= scale.maximum)
+        throw new LearningDomainError("rating_fixture_scale_invalid", 422);
+    const score = scale.minimum + (rating.score - rating.scale.minimum) / (rating.scale.maximum - rating.scale.minimum) * (scale.maximum - scale.minimum);
+    return {
+        id: `label-${feedback.id}-${feedback.revision}`, name: evidence.submission.exampleId,
+        input: JSON.stringify(evidence.submission.input, null, 2), output: JSON.stringify(evidence.submission.observedOutput, null, 2),
+        expectedOutput: evidence.submission.expected ? JSON.stringify(evidence.submission.expected, null, 2) : "",
+        evaluatorContext: evidence.submission.evaluatorContext ? JSON.stringify(evidence.submission.evaluatorContext, null, 2) : "",
+        artifactRefs: [], runtimeEventRefs: [], infrastructureError: "", expectedStatus: "scored", minimumScore: String(score), maximumScore: String(score), expectedPassed: "any",
+        sourceLabel: { evidence: learningRef(evidence), feedback: { id: feedback.id, revision: feedback.revision } },
+    };
+}

package/dist/learning/service.js

@@ -70,7 +70,7 @@ export function createLearningService(repository, options = {}) {
                     pointers = [await submit(transaction, input)];
                     break;
                 case "submit_feedback":
-                    pointers = [await feedback(transaction, input)];
+                    pointers = [await feedback(transaction, input, context.actor)];
                     break;
                 case "apply_correction":
                     pointers = await correct(transaction, input, context.actor.id);
@@ -193,16 +193,19 @@ export function createLearningService(repository, options = {}) {
         } while (afterId);
         return pointer("evidence", evidence);
     }
-    async function feedback(transaction, input) {
+    async function feedback(transaction, input, actor) {
         const source = await requireLearningResource(transaction, "source", input.feedback.sourceId);
         if (!source.enabled)
             throw new LearningDomainError("learning_source_disabled", 409);
         const evidenceId = learningEvidenceId(source.id, input.feedback.exampleId, input.feedback.attemptId);
         const evidence = await transaction.get("evidence", evidenceId);
+        if (input.feedback.value.schemaVersion === "openpond.taskRating.v1" && (!evidence || evidence.contentHash !== input.feedback.expectedEvidenceHash || !evidence.submission.observedOutput))
+            throw new LearningDomainError("task_rating_evidence_stale", 409, "Open the current observed response before submitting a rating.");
         const record = TaskFeedbackSchema.parse({
             schemaVersion: "openpond.taskFeedbackRecord.v1", id: `feedback-${contentHash([source.id, input.feedback.idempotencyKey])}`,
             submission: input.feedback, status: evidence ? "pending_review" : "pending_example",
             evidence: evidence ? learningRef(evidence) : null, createdAt: now(), revision: 1,
+            submittedBy: { id: actor.id, role: actor.role, sourceId: actor.sourceId ?? null },
         });
         await transaction.put("feedback", record, 0, { parentId: evidenceId, status: record.status });
         return pointer("feedback", record);
@@ -348,6 +351,8 @@ export function createLearningService(repository, options = {}) {
         },
         async list(context, kind, query = {}) {
             authorizeRead(context);
+            if (query.reviewState !== undefined && (kind !== "evidence" || !["inbox", "reviewed"].includes(query.reviewState)))
+                throw new LearningDomainError("learning_review_filter_invalid", 400);
             const limit = Math.max(1, Math.min(100, Math.trunc(query.limit ?? 50)));
             return repository.transaction(context.scope, (transaction) => transaction.list(kind, { ...query, limit }));
         },

package/dist/learning/transport.js

@@ -20,7 +20,7 @@ export const LearningReadRequestSchema = z.discriminatedUnion("action", [
     z.object({ action: z.literal("inspect_policy"), scope: ReleaseIdSchema, policy: LearningRevisionRefSchema }).strict(),
     z.object({ action: z.literal("inspect_evidence"), scope: ReleaseIdSchema, evidence: LearningRevisionRefSchema }).strict(),
     z.object({ action: z.literal("get"), scope: ReleaseIdSchema, kind: LearningResourceKindSchema, id: ReleaseIdSchema, revision: z.number().int().positive().optional() }).strict(),
-    z.object({ action: z.literal("list"), scope: ReleaseIdSchema, kind: LearningResourceKindSchema, parentId: ReleaseIdSchema.optional(), status: z.string().min(1).max(200).optional(), afterId: ReleaseIdSchema.optional(), limit: z.number().int().min(1).max(100).default(50) }).strict(),
+    z.object({ action: z.literal("list"), scope: ReleaseIdSchema, kind: LearningResourceKindSchema, parentId: ReleaseIdSchema.optional(), status: z.string().min(1).max(200).optional(), reviewState: z.enum(["inbox", "reviewed"]).optional(), afterId: ReleaseIdSchema.optional(), limit: z.number().int().min(1).max(100).default(50) }).strict(),
 ]);
 export const TaskEvidenceInspectionResultSchema = z.object({
     evidence: LearningRevisionRefSchema,

package/dist/types/learning/authoring-service.d.ts

@@ -130,6 +130,17 @@ export declare function currentDraft(tx: LearningTransaction, ref: LearningRevis
             minimumScore: string;
             maximumScore: string;
             expectedPassed: "any" | "true" | "false";
+            sourceLabel?: {
+                evidence: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                feedback: {
+                    id: string;
+                    revision: number;
+                };
+            } | undefined;
         }[] | undefined;
     };
     schemaVersion: "openpond.authoringDraft.v1";

package/dist/types/learning/authoring-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authoring-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/authoring-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,EAAqD,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EAA0B,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACjH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM;;;;GAY7I;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM;;;;GAMzG;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,SAAS,GAAG,mBAAmB,CAAA;CAAE,CAAC,EAAE,SAAS,EAAE,uBAAuB,EAAE,EAAE,GAAG,EAAE,MAAM;;;;UAUpM;AAED,wBAAsB,YAAY,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMnF"}
+{"version":3,"file":"authoring-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/authoring-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,EAAqD,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EAAmD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC1I,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,EAAE,MAAM;;;;GAmB7I;AAED,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM;;;;GAMzG;AAED,wBAAsB,sBAAsB,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,SAAS,GAAG,mBAAmB,CAAA;CAAE,CAAC,EAAE,SAAS,EAAE,uBAAuB,EAAE,EAAE,GAAG,EAAE,MAAM;;;;UAUpM;AAED,wBAAsB,YAAY,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMnF"}

package/dist/types/learning/authoring.d.ts

@@ -23,6 +23,17 @@ export declare const RewardFixtureAuthoringFieldsSchema: z.ZodObject<{
         true: "true";
         false: "false";
     }>;
+    sourceLabel: z.ZodOptional<z.ZodObject<{
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        feedback: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type RewardFixtureAuthoringFields = z.infer<typeof RewardFixtureAuthoringFieldsSchema>;
 export declare const RewardAuthoringFieldsSchema: z.ZodObject<{
@@ -83,6 +94,17 @@ export declare const RewardAuthoringFieldsSchema: z.ZodObject<{
             true: "true";
             false: "false";
         }>;
+        sourceLabel: z.ZodOptional<z.ZodObject<{
+            evidence: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            feedback: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const TaskFormatAuthoringFieldsSchema: z.ZodObject<{
@@ -291,6 +313,17 @@ export declare const AuthoringDraftInputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 true: "true";
                 false: "false";
             }>;
+            sourceLabel: z.ZodOptional<z.ZodObject<{
+                evidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                feedback: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
@@ -475,6 +508,17 @@ export declare const AuthoringDraftContentSchema: z.ZodDiscriminatedUnion<[z.Zod
                 true: "true";
                 false: "false";
             }>;
+            sourceLabel: z.ZodOptional<z.ZodObject<{
+                evidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                feedback: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
     schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
@@ -688,6 +732,17 @@ export declare const AuthoringDraftSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
                 true: "true";
                 false: "false";
             }>;
+            sourceLabel: z.ZodOptional<z.ZodObject<{
+                evidence: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                feedback: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
     schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;

package/dist/types/learning/authoring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../../../../../src/learning/authoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,sFAAsF;AACtF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;kBAOpC,CAAC;AACZ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQ7B,CAAC;AACZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIjC,CAAC;AACZ,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAErC,CAAC;AACZ,eAAO,MAAM,yBAAyB;;;;EAA8C,CAAC;AAErF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAIpC,CAAC;AAMH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAoO,CAAC;AAC7Q,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAA2T,CAAC;AAC7V,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,IAAI,OAAO,CAAC,cAAc,EAAE;IAAE,UAAU,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC;AAE1G,sFAAsF;AACtF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;kBAAqI,CAAC"}
+{"version":3,"file":"authoring.d.ts","sourceRoot":"","sources":["../../../../../src/learning/authoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,sFAAsF;AACtF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQpC,CAAC;AACZ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAE9F,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQ7B,CAAC;AACZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIjC,CAAC;AACZ,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAErC,CAAC;AACZ,eAAO,MAAM,yBAAyB;;;;EAA8C,CAAC;AAErF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAIpC,CAAC;AAMH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAoO,CAAC;AAC7Q,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAA2T,CAAC;AAC7V,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,IAAI,OAAO,CAAC,cAAc,EAAE;IAAE,UAAU,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC;AAE1G,sFAAsF;AACtF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;kBAAqI,CAAC"}