@openpond/evals 0.10.4 → 0.10.5

package/LEARNING.md

@@ -232,6 +232,23 @@ owns it. Duplicate observations are idempotent, older decision revisions cannot
 overwrite newer ones, and contradictory observations at the same revision fail.
 This operation does not change the training parent or activate serving.
 
+### Policy readiness reads
+
+`client.inspectPolicy({ id, revision, contentHash })` sends the read payload
+`{ "action": "inspect_policy", "scope": "<profile-or-team>", "policy": { "id": "...", "revision": 1, "contentHash": "..." } }`.
+The authenticated owner reads a scope-serialized snapshot of the current policy's
+eligible, awaiting-review, excluded and consumed counts, chain identity, cooldown
+and daily budget. It uses the same eligibility, complete batch validation and
+budget accounting as manual or scheduled reservation. A stale policy reference is
+rejected; source-only credentials cannot read it.
+
+`canReserve` describes shared reservation readiness at `inspectedAt`. The actual
+command rechecks current state and execution-owner preparation still validates
+its training configuration. `blockers` explains unmet constraints. `counts: null`
+means inspection could not count valid sources or supported admission, not that
+the backlog is empty. Reads never write an iteration, timer fire, family
+reservation, batch, consumption or operation record and never launch training.
+
 ### Durable learning schedules
 
 Policy publication atomically synchronizes a `schedule` resource. Enabling

package/dist/learning/batch-service.js

@@ -4,6 +4,17 @@ import { learningRef, sameLearningRef } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
 export async function sealLearningBatch(transaction, input, actorId, timestamp) {
+    const { batch, release, evidence, definition } = await prepareLearningBatch(transaction, input, actorId, timestamp);
+    for (const item of evidence) {
+        for (const reservation of taskFamilyReservations(item, definition))
+            await transaction.reserveFamilySplit(reservation.namespace, reservation.kind, reservation.key, reservation.split);
+    }
+    await transaction.put("batch", batch, 0, { parentId: definition.id });
+    await transaction.put("package", release, 0, { parentId: batch.id });
+    return [pointer("batch", batch), pointer("package", release)];
+}
+/** Performs the complete shared validation without reserving families or publishing resources. */
+export async function prepareLearningBatch(transaction, input, actorId, timestamp) {
     const definition = await requireLearningRelease(transaction, "definition", input.taskDefinition);
     const binding = await requireLearningRelease(transaction, "binding", definition.rewardBinding);
     const rewards = await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
@@ -26,13 +37,7 @@ export async function sealLearningBatch(transaction, input, actorId, timestamp)
     }
     const batch = sealTaskBatch({ id: input.batchId, definition, binding, rewards, purpose: input.purpose, evidence, decisions, priorSplits, actorId, now: timestamp });
     const release = compileTaskBatch({ batch, definition, binding, rewards, evidence, decisions });
-    for (const item of evidence) {
-        for (const reservation of taskFamilyReservations(item, definition))
-            await transaction.reserveFamilySplit(reservation.namespace, reservation.kind, reservation.key, reservation.split);
-    }
-    await transaction.put("batch", batch, 0, { parentId: definition.id });
-    await transaction.put("package", release, 0, { parentId: batch.id });
-    return [pointer("batch", batch), pointer("package", release)];
+    return { batch, release, evidence, definition };
 }
 export async function requireCurrentLearningEvidence(transaction, ref) {
     const evidence = await requireLearningRelease(transaction, "evidence", ref);

package/dist/learning/index.js

@@ -19,3 +19,4 @@ export * from "./iteration-candidate-decision.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";
+export * from "./policy-inspection.js";

package/dist/learning/iteration-budget.js

@@ -0,0 +1,17 @@
+/** Outstanding reservations survive midnight; settled spend belongs to its UTC day. */
+export async function readLearningIterationBudget(transaction, chainId, now) {
+    const day = new Date(now).toISOString().slice(0, 10);
+    let reservedSpendUsd = 0;
+    let settledSpendUsd = 0;
+    let afterId;
+    do {
+        const page = await transaction.list("reservation", { parentId: chainId, limit: 100, ...(afterId ? { afterId } : {}) });
+        for (const { budget } of page.items) {
+            reservedSpendUsd += budget.reservedSpendUsd;
+            if (budget.settledAt && new Date(budget.settledAt).toISOString().slice(0, 10) === day)
+                settledSpendUsd += budget.settledSpendUsd;
+        }
+        afterId = page.nextCursor ?? undefined;
+    } while (afterId);
+    return { reservedSpendUsd, settledSpendUsd, committedSpendUsd: reservedSpendUsd + settledSpendUsd };
+}

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

@@ -3,6 +3,7 @@ import { sealLearningBatch } from "./batch-service.js";
 import { LearningIterationSchema, learningRef, sameLearningRef } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
 import { inspectIterationEligibility, learningChainId, learningConsumptionId } from "./iteration-eligibility.js";
+import { readLearningIterationBudget } from "./iteration-budget.js";
 import { LearningChainSchema, LearningConsumptionSchema, LearningIterationReservationSchema } from "./iteration-reservation-contracts.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
 /** The caller owns one scope-serialized transaction. This never submits a Job. */
@@ -89,18 +90,7 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     return [{ kind: "iteration", id, revision: 1 }, { kind: "reservation", id, revision: 1 }, ...pointers];
 }
 async function assertAvailableBudget(transaction, chainId, now, requested, maximum) {
-    let committed = 0;
-    let afterId;
-    do {
-        const page = await transaction.list("reservation", { parentId: chainId, limit: 100, ...(afterId ? { afterId } : {}) });
-        for (const { budget } of page.items) {
-            // Unsettled reservations carry across midnight and worker restarts.
-            committed += budget.reservedSpendUsd;
-            if (budget.settledAt && new Date(budget.settledAt).toISOString().slice(0, 10) === new Date(now).toISOString().slice(0, 10))
-                committed += budget.settledSpendUsd;
-        }
-        afterId = page.nextCursor ?? undefined;
-    } while (afterId);
-    if (committed + requested > maximum)
+    const budget = await readLearningIterationBudget(transaction, chainId, now);
+    if (budget.committedSpendUsd + requested > maximum)
         throw new LearningDomainError("learning_daily_budget_exhausted", 409);
 }

package/dist/learning/policy-inspection.js

@@ -0,0 +1,82 @@
+import { ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { z } from "zod";
+import { 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";
+/** 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({
+    policy: LearningRevisionRefSchema,
+    modelProjectId: ReleaseIdSchema,
+    inspectedAt: ReleaseTimestampSchema,
+    chain: LearningChainSchema.nullable(),
+    counts: LearningEligibilityCountsSchema.nullable(),
+    minimumApprovedExamples: z.number().int().positive(),
+    canReserve: z.boolean(),
+    blockers: z.array(z.object({ code: z.string().min(1).max(200), message: z.string().min(1).max(20_000) }).strict()).max(20),
+    cooldownUntil: ReleaseTimestampSchema.nullable(),
+    budget: z.object({
+        reservedSpendUsd: z.number().nonnegative(), settledSpendUsd: z.number().nonnegative(), committedSpendUsd: z.number().nonnegative(),
+        maximumIterationSpendUsd: z.number().nonnegative(), maximumDailySpendUsd: z.number().nonnegative(),
+    }).strict(),
+}).strict();
+export async function inspectLearningPolicy(transaction, reference, actorId, now) {
+    const policy = await requireLearningRelease(transaction, "policy", reference);
+    const current = await requireLearningResource(transaction, "policy", policy.id);
+    if (!sameLearningRef(learningRef(current), reference))
+        throw new LearningDomainError("learning_policy_revision_stale", 409);
+    const chainId = learningChainId(policy.modelProjectId);
+    const chain = await transaction.get("chain", chainId);
+    const budget = await readLearningIterationBudget(transaction, chainId, now);
+    const blockers = [];
+    const block = (code, message) => { blockers.push({ code, message }); };
+    if (!policy.enabled)
+        block("learning_policy_paused", "Learning is paused.");
+    if (policy.automation.accept || policy.automation.serve)
+        block("learning_automatic_acceptance_not_available", "Candidates require explicit acceptance and serving selection.");
+    if (chain?.activeIterationId)
+        block("learning_iteration_active", "An iteration is already active.");
+    const cooldownUntil = chain?.lastReservedAt && Date.parse(now) - Date.parse(chain.lastReservedAt) < policy.limits.cooldownSeconds * 1_000
+        ? new Date(Date.parse(chain.lastReservedAt) + policy.limits.cooldownSeconds * 1_000).toISOString() : null;
+    if (cooldownUntil)
+        block("learning_iteration_cooldown", "The training cooldown has not elapsed.");
+    if (budget.committedSpendUsd + policy.limits.maxIterationSpendUsd > policy.limits.maxDailySpendUsd) {
+        block("learning_daily_budget_exhausted", "The daily budget cannot cover another iteration's maximum spend.");
+    }
+    let counts = null;
+    try {
+        const eligibility = await inspectIterationEligibility(transaction, policy);
+        counts = eligibility.counts;
+        if (counts.eligible < policy.admission.minimumApprovedExamples) {
+            if (counts.awaitingReview > 0)
+                block("learning_waiting_for_review", "More approved tasks are required before training.");
+            else
+                block("learning_waiting_for_data", "More eligible new tasks are required before training.");
+        }
+        else {
+            await prepareLearningBatch(transaction, {
+                action: "seal_batch", operationId: "policy-inspection", batchId: "policy-inspection",
+                taskDefinition: policy.taskDefinition, purpose: eligibility.purpose,
+                evidence: eligibility.selected.map(item => learningRef(item.evidence)),
+                decisions: eligibility.selected.map(item => learningRef(item.decision)),
+            }, actorId, now);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof LearningDomainError))
+            throw error;
+        // An unavailable count is not zero. Invalid sources or unsupported admission
+        // must remain visible while the Model's settings and history can still load.
+        block(error.code, error.message.slice(0, 20_000));
+    }
+    return LearningPolicyInspectionResultSchema.parse({
+        policy: learningRef(policy), modelProjectId: policy.modelProjectId, inspectedAt: now, chain,
+        counts, minimumApprovedExamples: policy.admission.minimumApprovedExamples, canReserve: blockers.length === 0,
+        blockers, cooldownUntil,
+        budget: { ...budget, maximumIterationSpendUsd: policy.limits.maxIterationSpendUsd, maximumDailySpendUsd: policy.limits.maxDailySpendUsd },
+    });
+}

package/dist/learning/service.js

@@ -2,6 +2,7 @@ import { cancelLearningIterationReservation } from "./iteration-reservation-canc
 import { commandLearningIterationDispatch } from "./iteration-dispatch-commands.js";
 import { reserveLearningIteration } from "./iteration-reservation-service.js";
 import { synchronizeLearningSchedule } from "./schedule-service.js";
+import { inspectLearningPolicy } from "./policy-inspection.js";
 import { requireCurrentLearningEvidence as currentEvidence, sealLearningBatch } from "./batch-service.js";
 import { saveAuthoringDraft, archiveAuthoringDraft, finalizeAuthoringDraft } from "./authoring-service.js";
 import { queueRewardCheck, cancelRewardCheck } from "./reward-check-service.js";
@@ -327,6 +328,11 @@ export function createLearningService(repository, options = {}) {
     }
     return {
         command,
+        async inspectPolicy(context, reference) {
+            authorizeRead(context);
+            const ref = LearningRevisionRefSchema.parse(reference);
+            return repository.transaction(context.scope, transaction => inspectLearningPolicy(transaction, ref, context.actor.id, now()));
+        },
         async inspectEvidence(context, reference) {
             authorizeRead(context);
             const ref = LearningRevisionRefSchema.parse(reference);

package/dist/learning/transport.js

@@ -17,6 +17,7 @@ export function assertLearningRequestJson(raw) {
 /** Scope selection is never authorization; each host resolves its authenticated owner. */
 export const LearningCommandRequestSchema = z.object({ scope: ReleaseIdSchema, command: LearningCommandSchema }).strict();
 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(),

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

@@ -4,5 +4,315 @@ import { type LearningResourcePointer, type LearningTransaction } from "./reposi
 export declare function sealLearningBatch(transaction: LearningTransaction, input: Extract<LearningCommand, {
     action: "seal_batch";
 }>, actorId: string, timestamp: string): Promise<LearningResourcePointer[]>;
+/** Performs the complete shared validation without reserving families or publishing resources. */
+export declare function prepareLearningBatch(transaction: LearningTransaction, input: Extract<LearningCommand, {
+    action: "seal_batch";
+}>, actorId: string, timestamp: string): Promise<{
+    batch: {
+        schemaVersion: "openpond.taskBatch.v1";
+        id: string;
+        revision: 1;
+        taskDefinition: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        rewardBinding: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        purpose: "evaluation" | "supervised_training" | "reward_training";
+        examples: {
+            evidence: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            decision: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            familyKey: string;
+            inputHash: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+        }[];
+        sealedAt: string;
+        sealedBy: string;
+        contentHash: string;
+    };
+    release: {
+        schemaVersion: "openpond.tasksetRelease.v2";
+        id: string;
+        revision: number;
+        policy: {
+            policyVisibleFields: string[];
+            privilegedFields: string[];
+            hiddenGraderRefs: string[];
+            connectedAppScopes: string[];
+        };
+        environment: {
+            protocolVersion: "openpond.environment.v1";
+            kind: "text" | "agent" | "work" | "custom_program";
+            entrypoint: string;
+            stateful: boolean;
+            deterministicSeeds: boolean;
+            lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+            networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+            defaultTimeoutMs: number;
+        };
+        tools: {
+            name: string;
+            description: string;
+            inputSchema: Record<string, unknown>;
+            inputSchemaHash: string;
+            sideEffect: "read" | "write";
+            timeoutMs: number;
+        }[];
+        capabilities: {
+            id: string;
+            required: boolean;
+            scopes: string[];
+            portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+        }[];
+        tasks: {
+            id: string;
+            clusterKey: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, unknown>;
+            expectedOutput: Record<string, unknown> | null;
+            policyVisibleContext: Record<string, unknown>;
+            privilegedContextRef: string | null;
+            artifactRefs: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            tags: string[];
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                schemaRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                } | null;
+                maxBytes: number | null;
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+        }[];
+        graders: ({
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            config: Record<string, unknown>;
+        } | {
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "model_judge";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
+        } | {
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "custom_verifier";
+            verifierRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            timeoutMs: number;
+            networkPolicy: "none";
+            exportName?: string | undefined;
+        } | {
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "human";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            reviewerRole: string;
+        })[];
+        metadata: Record<string, unknown>;
+        contentHash: string;
+        environmentRelease?: {
+            id: string;
+            contentHash: string;
+        } | undefined;
+        verifierSetRelease?: {
+            id: string;
+            contentHash: string;
+        } | undefined;
+        metrics?: {
+            schemaVersion: "openpond.tasksetMetricPolicy.v1";
+            primaryMetric: string;
+            aggregation: "mean_score" | "pass_rate" | "weighted_mean" | "custom";
+            missingReward: "zero" | "exclude";
+            customAggregator: {
+                module: string;
+                exportName: string;
+                contentHash: string;
+                timeoutMs: number;
+                networkPolicy: "none";
+            } | null;
+            taskWeights?: Record<string, number> | undefined;
+        } | undefined;
+    };
+    evidence: {
+        schemaVersion: "openpond.taskEvidence.v1";
+        id: string;
+        revision: number;
+        source: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        submission: {
+            schemaVersion: "openpond.taskExample.v1";
+            sourceId: string;
+            idempotencyKey: string;
+            taskDefinition: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            exampleId: string;
+            attemptId: string;
+            occurredAt: string;
+            familyKey: string | null;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, import("zod").JSONType>;
+            observedOutput: Record<string, import("zod").JSONType> | null;
+            expected: Record<string, import("zod").JSONType> | null;
+            evaluatorContext: Record<string, import("zod").JSONType> | null;
+            assets: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            provenance: {
+                sourceRecordRef: string | null;
+                mappingHash: string | null;
+            };
+        };
+        supersedes: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        correctionFeedbackId: string | null;
+        receivedAt: string;
+        contentHash: string;
+    }[];
+    definition: {
+        schemaVersion: "openpond.taskDefinition.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        instructions: string;
+        category: "custom" | "structured" | "question_answering" | "coding" | "tool_workflow";
+        familyNamespace: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        rewardBinding: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        harness: {
+            id: string;
+            contentHash: string;
+        } | null;
+        execution: {
+            policy: {
+                policyVisibleFields: string[];
+                privilegedFields: string[];
+                hiddenGraderRefs: string[];
+                connectedAppScopes: string[];
+            };
+            environment: {
+                protocolVersion: "openpond.environment.v1";
+                kind: "text" | "agent" | "work" | "custom_program";
+                entrypoint: string;
+                stateful: boolean;
+                deterministicSeeds: boolean;
+                lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+                networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                defaultTimeoutMs: number;
+            };
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilities: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+            }[];
+            environmentRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+            verifierSetRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+        };
+        contentHash: string;
+    };
+}>;
 export declare function requireCurrentLearningEvidence(transaction: LearningTransaction, ref: LearningRevisionRef): Promise<TaskEvidence>;
 //# sourceMappingURL=batch-service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"batch-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/batch-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAA8E,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAErK,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CA2B3M;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtI"}
+{"version":3,"file":"batch-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/batch-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAA8E,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAErK,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAQ3M;AAED,kGAAkG;AAClG,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBzK;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtI"}

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

@@ -19,4 +19,5 @@ export * from "./iteration-candidate-decision.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";
+export * from "./policy-inspection.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/learning/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/learning/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC"}

package/dist/types/learning/iteration-budget.d.ts

@@ -0,0 +1,8 @@
+import type { LearningTransaction } from "./repository.js";
+/** Outstanding reservations survive midnight; settled spend belongs to its UTC day. */
+export declare function readLearningIterationBudget(transaction: LearningTransaction, chainId: string, now: string): Promise<{
+    reservedSpendUsd: number;
+    settledSpendUsd: number;
+    committedSpendUsd: number;
+}>;
+//# sourceMappingURL=iteration-budget.d.ts.map

package/dist/types/learning/iteration-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-budget.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-budget.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,uFAAuF;AACvF,wBAAsB,2BAA2B,CAAC,WAAW,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;;;;GAc/G"}

package/dist/types/learning/iteration-reservation-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iteration-reservation-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-reservation-service.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAmD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE1I,KAAK,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAAC;AAEhF,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CA0ExK"}
+{"version":3,"file":"iteration-reservation-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-reservation-service.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAmD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE1I,KAAK,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAAC;AAEhF,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CA0ExK"}

package/dist/types/learning/policy-inspection.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { LearningRevisionRefSchema } from "./contracts.js";
+import { type LearningTransaction } from "./repository.js";
+/** A scope-serialized snapshot of shared reservation readiness, not a Job guarantee.
+ * No iteration, timer, batch, consumption or operation record is written. */
+export declare const LearningPolicyInspectionResultSchema: z.ZodObject<{
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    modelProjectId: z.ZodString;
+    inspectedAt: z.ZodString;
+    chain: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningChain.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        modelProjectId: z.ZodString;
+        activeIterationId: z.ZodNullable<z.ZodString>;
+        latestIterationId: z.ZodString;
+        lastReservedAt: z.ZodNullable<z.ZodString>;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    counts: z.ZodNullable<z.ZodObject<{
+        eligible: z.ZodNumber;
+        awaitingReview: z.ZodNumber;
+        excluded: z.ZodNumber;
+        consumed: z.ZodNumber;
+    }, z.core.$strict>>;
+    minimumApprovedExamples: z.ZodNumber;
+    canReserve: z.ZodBoolean;
+    blockers: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    cooldownUntil: z.ZodNullable<z.ZodString>;
+    budget: z.ZodObject<{
+        reservedSpendUsd: z.ZodNumber;
+        settledSpendUsd: z.ZodNumber;
+        committedSpendUsd: z.ZodNumber;
+        maximumIterationSpendUsd: z.ZodNumber;
+        maximumDailySpendUsd: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LearningPolicyInspectionResult = z.infer<typeof LearningPolicyInspectionResultSchema>;
+export declare function inspectLearningPolicy(transaction: LearningTransaction, reference: z.infer<typeof LearningRevisionRefSchema>, actorId: string, now: string): Promise<LearningPolicyInspectionResult>;
+//# sourceMappingURL=policy-inspection.d.ts.map

package/dist/types/learning/policy-inspection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy-inspection.d.ts","sourceRoot":"","sources":["../../../../../src/learning/policy-inspection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,yBAAyB,EAAgC,MAAM,gBAAgB,CAAC;AAMzF,OAAO,EAAmD,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE5G;6EAC6E;AAC7E,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBActC,CAAC;AACZ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAElG,wBAAsB,qBAAqB,CAAC,WAAW,EAAE,mBAAmB,EAAE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,8BAA8B,CAAC,CA6CzM"}

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

@@ -17,6 +17,45 @@ export declare function createLearningService(repository: LearningRepository, op
     now?: () => string;
 }): {
     command: (context: LearningServiceContext, raw: unknown) => Promise<LearningOperationResult>;
+    inspectPolicy(context: LearningServiceContext, reference: LearningRevisionRef): Promise<{
+        policy: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        modelProjectId: string;
+        inspectedAt: string;
+        chain: {
+            schemaVersion: "openpond.learningChain.v1";
+            id: string;
+            revision: number;
+            modelProjectId: string;
+            activeIterationId: string | null;
+            latestIterationId: string;
+            lastReservedAt: string | null;
+            updatedAt: string;
+        } | null;
+        counts: {
+            eligible: number;
+            awaitingReview: number;
+            excluded: number;
+            consumed: number;
+        } | null;
+        minimumApprovedExamples: number;
+        canReserve: boolean;
+        blockers: {
+            code: string;
+            message: string;
+        }[];
+        cooldownUntil: string | null;
+        budget: {
+            reservedSpendUsd: number;
+            settledSpendUsd: number;
+            committedSpendUsd: number;
+            maximumIterationSpendUsd: number;
+            maximumDailySpendUsd: number;
+        };
+    }>;
     inspectEvidence(context: LearningServiceContext, reference: LearningRevisionRef): Promise<{
         evidence: {
             id: string;

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

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/service.ts"],"names":[],"mappings":"AAaA,OAAO,EAA+Q,KAAK,mBAAmB,EAAwC,MAAM,gBAAgB,CAAC;AAE7W,OAAO,EAAmH,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAgC,KAAK,qBAAqB,EAAE,KAAK,sBAAsB,EAA4B,MAAM,iBAAiB,CAAC;AAK5W,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtG,MAAM,MAAM,sBAAsB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAC7E,MAAM,MAAM,uBAAuB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,sBAAsB,EAAE,CAAA;CAAE,CAAC;AAEnG,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO;uBAGxE,sBAAsB,OAAO,OAAO,KAAG,OAAO,CAAC,uBAAuB,CAAC;6BA0PtE,sBAAsB,aAAa,mBAAmB;;;;;;;;;;;;;QAS3E,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,MAAM,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;SAIxI,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,UAAS,OAAO,CAAC,qBAAqB,CAAC,GAAQ,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;EAMrK"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/service.ts"],"names":[],"mappings":"AAcA,OAAO,EAA+Q,KAAK,mBAAmB,EAAwC,MAAM,gBAAgB,CAAC;AAE7W,OAAO,EAAmH,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAgC,KAAK,qBAAqB,EAAE,KAAK,sBAAsB,EAA4B,MAAM,iBAAiB,CAAC;AAK5W,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtG,MAAM,MAAM,sBAAsB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAC7E,MAAM,MAAM,uBAAuB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,sBAAsB,EAAE,CAAA;CAAE,CAAC;AAEnG,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO;uBAGxE,sBAAsB,OAAO,OAAO,KAAG,OAAO,CAAC,uBAAuB,CAAC;2BA0PxE,sBAAsB,aAAa,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAKpD,sBAAsB,aAAa,mBAAmB;;;;;;;;;;;;;QAS3E,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,MAAM,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;SAIxI,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,UAAS,OAAO,CAAC,qBAAqB,CAAC,GAAQ,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;EAMrK"}

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

@@ -1438,6 +1438,14 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
     }, z.core.$strict>]>;
 }, z.core.$strict>;
 export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"inspect_policy">;
+    scope: z.ZodString;
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
     action: z.ZodLiteral<"inspect_evidence">;
     scope: z.ZodString;
     evidence: z.ZodObject<{

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

@@ -1 +1 @@
-{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../../src/learning/transport.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG/B,CAAC"}
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../../src/learning/transport.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG/B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpond/evals",
-  "version": "0.10.4",
+  "version": "0.10.5",
   "description": "Portable Tasksets, graders, evaluation runs, receipts, conformance fixtures, and Work evidence for OpenPond Harnesses",
   "license": "MIT",
   "type": "module",

package/schemas/learning/v1/policy-inspection.schema.json

@@ -0,0 +1,243 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "policy": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/__schema0"
+        },
+        "contentHash": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "revision": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "maximum": 9007199254740991
+        }
+      },
+      "required": [
+        "id",
+        "contentHash",
+        "revision"
+      ],
+      "additionalProperties": false
+    },
+    "modelProjectId": {
+      "$ref": "#/$defs/__schema0"
+    },
+    "inspectedAt": {
+      "$ref": "#/$defs/__schema1"
+    },
+    "chain": {
+      "anyOf": [
+        {
+          "type": "object",
+          "properties": {
+            "schemaVersion": {
+              "type": "string",
+              "const": "openpond.learningChain.v1"
+            },
+            "id": {
+              "$ref": "#/$defs/__schema0"
+            },
+            "revision": {
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            },
+            "modelProjectId": {
+              "$ref": "#/$defs/__schema0"
+            },
+            "activeIterationId": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/__schema0"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "latestIterationId": {
+              "$ref": "#/$defs/__schema0"
+            },
+            "lastReservedAt": {
+              "anyOf": [
+                {
+                  "$ref": "#/$defs/__schema1"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "updatedAt": {
+              "$ref": "#/$defs/__schema1"
+            }
+          },
+          "required": [
+            "schemaVersion",
+            "id",
+            "revision",
+            "modelProjectId",
+            "activeIterationId",
+            "latestIterationId",
+            "lastReservedAt",
+            "updatedAt"
+          ],
+          "additionalProperties": false
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "counts": {
+      "anyOf": [
+        {
+          "type": "object",
+          "properties": {
+            "eligible": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            },
+            "awaitingReview": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            },
+            "excluded": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            },
+            "consumed": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
+            }
+          },
+          "required": [
+            "eligible",
+            "awaitingReview",
+            "excluded",
+            "consumed"
+          ],
+          "additionalProperties": false
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "minimumApprovedExamples": {
+      "type": "integer",
+      "exclusiveMinimum": 0,
+      "maximum": 9007199254740991
+    },
+    "canReserve": {
+      "type": "boolean"
+    },
+    "blockers": {
+      "maxItems": 20,
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/__schema2"
+      }
+    },
+    "cooldownUntil": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/__schema1"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "budget": {
+      "type": "object",
+      "properties": {
+        "reservedSpendUsd": {
+          "type": "number",
+          "minimum": 0
+        },
+        "settledSpendUsd": {
+          "type": "number",
+          "minimum": 0
+        },
+        "committedSpendUsd": {
+          "type": "number",
+          "minimum": 0
+        },
+        "maximumIterationSpendUsd": {
+          "type": "number",
+          "minimum": 0
+        },
+        "maximumDailySpendUsd": {
+          "type": "number",
+          "minimum": 0
+        }
+      },
+      "required": [
+        "reservedSpendUsd",
+        "settledSpendUsd",
+        "committedSpendUsd",
+        "maximumIterationSpendUsd",
+        "maximumDailySpendUsd"
+      ],
+      "additionalProperties": false
+    }
+  },
+  "required": [
+    "policy",
+    "modelProjectId",
+    "inspectedAt",
+    "chain",
+    "counts",
+    "minimumApprovedExamples",
+    "canReserve",
+    "blockers",
+    "cooldownUntil",
+    "budget"
+  ],
+  "additionalProperties": false,
+  "$defs": {
+    "__schema0": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 240
+    },
+    "__schema1": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
+    },
+    "__schema2": {
+      "type": "object",
+      "properties": {
+        "code": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 200
+        },
+        "message": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 20000
+        }
+      },
+      "required": [
+        "code",
+        "message"
+      ],
+      "additionalProperties": false
+    }
+  },
+  "$id": "urn:openpond:learning:v1:policy-inspection",
+  "$comment": "Generated from @openpond/evals. Cross-resource identity, authorization, idempotency, admission, grading and split constraints are enforced by the shared domain service in addition to this structural schema."
+}

package/schemas/learning/v1/read-request.schema.json

@@ -1,6 +1,27 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "oneOf": [
+    {
+      "type": "object",
+      "properties": {
+        "action": {
+          "type": "string",
+          "const": "inspect_policy"
+        },
+        "scope": {
+          "$ref": "#/$defs/__schema0"
+        },
+        "policy": {
+          "$ref": "#/$defs/__schema1"
+        }
+      },
+      "required": [
+        "action",
+        "scope",
+        "policy"
+      ],
+      "additionalProperties": false
+    },
     {
       "type": "object",
       "properties": {
@@ -12,27 +33,7 @@
           "$ref": "#/$defs/__schema0"
         },
         "evidence": {
-          "type": "object",
-          "properties": {
-            "id": {
-              "$ref": "#/$defs/__schema0"
-            },
-            "contentHash": {
-              "type": "string",
-              "pattern": "^[a-f0-9]{64}$"
-            },
-            "revision": {
-              "type": "integer",
-              "exclusiveMinimum": 0,
-              "maximum": 9007199254740991
-            }
-          },
-          "required": [
-            "id",
-            "contentHash",
-            "revision"
-          ],
-          "additionalProperties": false
+          "$ref": "#/$defs/__schema1"
         }
       },
       "required": [
@@ -53,7 +54,7 @@
           "$ref": "#/$defs/__schema0"
         },
         "kind": {
-          "$ref": "#/$defs/__schema1"
+          "$ref": "#/$defs/__schema2"
         },
         "id": {
           "$ref": "#/$defs/__schema0"
@@ -83,7 +84,7 @@
           "$ref": "#/$defs/__schema0"
         },
         "kind": {
-          "$ref": "#/$defs/__schema1"
+          "$ref": "#/$defs/__schema2"
         },
         "parentId": {
           "$ref": "#/$defs/__schema0"
@@ -119,6 +120,29 @@
       "maxLength": 240
     },
     "__schema1": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/__schema0"
+        },
+        "contentHash": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "revision": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "maximum": 9007199254740991
+        }
+      },
+      "required": [
+        "id",
+        "contentHash",
+        "revision"
+      ],
+      "additionalProperties": false
+    },
+    "__schema2": {
       "type": "string",
       "enum": [
         "draft",