@tangle-network/agent-interface 0.28.0 → 0.29.0

package/dist/agent-candidate-execution-plan-schema.js

@@ -1,17 +1,9 @@
 import { z } from "zod";
 import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
 import { agentCandidateContainerSchema, agentCandidateInstructionDeliverySchema, agentCandidateWorkingDirectorySchema, } from "./agent-candidate-code-schema.js";
+import { reasoningEffortSchema } from "./profile-schema.js";
 import { addDuplicateIssues, agentCandidateConfigValueSchema, agentCandidateMediaTypeSchema, environmentConfigSchema, gitObjectSchema, isCanonicalJsonValue, isObviouslyPrivateHostname, isSafeExecutable, isSafeRelativePath, isWellFormedUnicode, sameGitObjectFormat, sha256Utf8, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { harnessTypeSchema } from "./harness.js";
-const reasoningEffortSchema = z.enum([
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "ultracode",
-]);
 function isCanonicalAbsolutePath(value) {
     return (value.startsWith("/") &&
         value !== "/" &&
@@ -58,8 +50,59 @@ export const agentCandidateResolvedModelSchema = z
     reasoningEffort: reasoningEffortSchema,
 })
     .strict();
+export const agentCandidateBenchmarkGraderIdentitySchema = z
+    .object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    format: z.literal("tangle-grader"),
+    artifact: agentCandidateArtifactRefSchema,
+})
+    .strict()
+    .superRefine((grader, ctx) => {
+    if (grader.artifact.byteLength === 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["artifact", "byteLength"],
+            message: "pinned grader artifact must contain executable grader bytes",
+        });
+    }
+});
+export const agentCandidateTaskRepositorySchema = z
+    .object({
+    identity: z.string().min(1).max(512),
+    rootIdentity: z.string().min(1).max(512),
+    baseCommit: gitObjectSchema,
+    baseTree: gitObjectSchema,
+})
+    .strict()
+    .superRefine((repository, ctx) => {
+    if (!sameGitObjectFormat(repository.baseCommit, repository.baseTree)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "task Git object ids must use one object format",
+        });
+    }
+});
+export const agentCandidateResolvedTaskContainerSchema = agentCandidateContainerSchema
+    .extend({
+    source: z.literal("evaluator-task-container"),
+    manifestDigest: sha256DigestSchema,
+    platform: z
+        .object({
+        os: z.string().min(1).max(100),
+        architecture: z.string().min(1).max(100),
+        variant: z.string().min(1).max(100).optional(),
+    })
+        .strict(),
+})
+    .strict();
+export const agentCandidateRetryPolicySchema = z.enum([
+    "pre-model-infrastructure-only",
+    "none",
+]);
 export const agentCandidateProfilePlanMaterialSchema = z
     .object({
+    sourceProfileDigest: sha256DigestSchema,
     harness: harnessTypeSchema,
     files: z.array(z
         .object({
@@ -149,45 +192,35 @@ export const agentCandidateTaskOutcomeSpecSchema = z.discriminatedUnion("kind",
     })
         .strict(),
 ]);
+export const agentCandidateBenchmarkCellRefSchema = z
+    .object({
+    suiteDigest: sha256DigestSchema,
+    taskIndex: z.number().int().nonnegative(),
+    repetition: z.number().int().nonnegative(),
+})
+    .strict();
+export const agentCandidateRunCellMaterialSchema = z
+    .object({
+    kind: z.literal("agent-candidate-run-cell"),
+    experimentDigest: sha256DigestSchema,
+    arm: z.enum(["baseline", "candidate"]),
+    bundleDigest: sha256DigestSchema,
+    suiteDigest: sha256DigestSchema,
+    taskDigest: sha256DigestSchema,
+    taskIndex: z.number().int().nonnegative(),
+    repetition: z.number().int().nonnegative(),
+    seed: z.number().int().safe(),
+    attempt: z.number().int().positive(),
+})
+    .strict();
+export const agentCandidateRunCellSchema = agentCandidateRunCellMaterialSchema
+    .extend({ digest: sha256DigestSchema })
+    .strict();
 export const agentCandidateExecutionPlanMaterialSchema = z
     .object({
     kind: z.literal("agent-candidate-execution-plan-material"),
-    bundleDigest: sha256DigestSchema,
+    runCell: agentCandidateRunCellSchema,
     executionId: z.string().min(1),
-    attempt: z
-        .object({
-        number: z.number().int().min(1),
-        maxAttempts: z.number().int().min(1),
-        retryPolicy: z.enum(["pre-model-infrastructure-only", "none"]),
-    })
-        .strict(),
-    task: z
-        .object({
-        benchmark: z.string().min(1),
-        benchmarkVersion: z.string().min(1),
-        taskId: z.string().min(1),
-        splitDigest: sha256DigestSchema,
-        instruction: z
-            .object({
-            encoding: z.literal("utf8"),
-            sha256: sha256DigestSchema,
-            byteLength: z.number().int().positive(),
-            delivery: agentCandidateInstructionDeliverySchema,
-        })
-            .strict(),
-        repository: z
-            .object({
-            identity: z.string().min(1),
-            rootIdentity: z.string().min(1),
-            baseCommit: gitObjectSchema,
-            baseTree: gitObjectSchema,
-        })
-            .strict()
-            .optional(),
-        outcome: agentCandidateTaskOutcomeSpecSchema,
-        workspace: agentCandidateWorkspaceSnapshotEvidenceSchema,
-    })
-        .strict(),
     workspaces: z
         .object({
         taskRoot: z
@@ -212,6 +245,8 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         .strict(),
     harness: harnessTypeSchema,
     harnessVersion: z.string().min(1),
+    instructionDelivery: agentCandidateInstructionDeliverySchema,
+    limits: agentCandidateExecutionLimitsSchema,
     container: agentCandidateContainerSchema
         .extend({
         source: z.enum(["pinned-container", "evaluator-task-container"]),
@@ -268,13 +303,6 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             .min(1),
     })
         .strict(),
-    grader: z
-        .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        artifact: agentCandidateArtifactRefSchema,
-    })
-        .strict(),
     launch: z
         .object({
         executable: z
@@ -287,42 +315,10 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         .strict(),
     knowledgeManifestDigest: sha256DigestSchema.optional(),
     memory: agentCandidateEffectiveMemorySchema,
-    limits: agentCandidateExecutionLimitsSchema,
     network: z.object({ mode: z.literal("disabled") }).strict(),
 })
     .strict()
     .superRefine((material, ctx) => {
-    if (material.task.repository !== undefined &&
-        !sameGitObjectFormat(material.task.repository.baseCommit, material.task.repository.baseTree)) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["task", "repository"],
-            message: "task Git object ids must use one object format",
-        });
-    }
-    if (material.task.outcome.kind === "workspace" &&
-        material.task.repository === undefined) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["task", "repository"],
-            message: "workspace outcomes require task repository provenance",
-        });
-    }
-    if (material.attempt.number > material.attempt.maxAttempts) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["attempt", "number"],
-            message: "attempt number cannot exceed the frozen maximum",
-        });
-    }
-    if (material.attempt.retryPolicy === "none" &&
-        material.attempt.maxAttempts !== 1) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["attempt", "maxAttempts"],
-            message: "a no-retry plan must allow exactly one attempt",
-        });
-    }
     const routeIds = material.model.routes.map((route) => route.kind === "mode" || route.kind === "subagent"
         ? `${route.kind}:${route.name}`
         : route.kind);
@@ -356,20 +352,6 @@ export const agentCandidateExecutionPlanMaterialSchema = z
         }
     }
     const modelNetwork = material.model.access.network;
-    if (material.limits.maxModelCalls === 0 && modelNetwork.mode !== "disabled") {
-        ctx.addIssue({
-            code: "custom",
-            path: ["model", "access", "network"],
-            message: "zero-call plans cannot expose a model gateway",
-        });
-    }
-    if (material.limits.maxModelCalls > 0 && modelNetwork.mode !== "gateway-only") {
-        ctx.addIssue({
-            code: "custom",
-            path: ["model", "access", "network"],
-            message: "model-calling plans require one frozen gateway allowlist",
-        });
-    }
     if (modelNetwork.mode === "gateway-only") {
         addDuplicateIssues(modelNetwork.domains, ["model", "access", "network", "domains"], ctx);
         for (let index = 1; index < modelNetwork.domains.length; index++) {
@@ -405,62 +387,46 @@ export const agentCandidateExecutionPlanMaterialSchema = z
             message: "task and candidate workspace roots must be disjoint",
         });
     }
-    if (material.launch.cwd.workspace === "candidate" &&
-        material.workspaces.candidateRoot === undefined) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["launch", "cwd", "workspace"],
-            message: "candidate cwd requires a pinned candidate workspace root",
-        });
-    }
-    if (material.profile.targetWorkspace === "candidate" &&
-        material.workspaces.candidateRoot === undefined) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["profile", "targetWorkspace"],
-            message: "candidate-targeted profile files require a candidate workspace root",
-        });
-    }
-    const delivery = material.task.instruction.delivery;
     const taskPath = material.launch.env.TANGLE_CANDIDATE_TASK_PATH;
-    if (delivery.kind === "utf8-file") {
-        if (taskPath?.value !== delivery.path) {
+    if (taskPath !== undefined) {
+        if (taskPath.value !== "/tangle/input/task.txt") {
             ctx.addIssue({
                 code: "custom",
                 path: ["launch", "env", "TANGLE_CANDIDATE_TASK_PATH"],
-                message: "file delivery requires the signed fixed task path",
+                message: "task file delivery must use the fixed evaluator-owned path",
             });
         }
-        if (pathsOverlap(material.workspaces.taskRoot, delivery.path) ||
+        if (pathsOverlap(taskPath.value, material.workspaces.taskRoot) ||
             (material.workspaces.candidateRoot !== undefined &&
-                pathsOverlap(material.workspaces.candidateRoot, delivery.path))) {
+                pathsOverlap(taskPath.value, material.workspaces.candidateRoot))) {
             ctx.addIssue({
                 code: "custom",
-                path: ["workspaces"],
-                message: "the task instruction file must be outside both workspaces",
+                path: ["launch", "env", "TANGLE_CANDIDATE_TASK_PATH"],
+                message: "task file delivery must be outside both workspaces",
             });
         }
     }
-    else if (taskPath !== undefined) {
+    if (material.launch.cwd.workspace === "candidate" &&
+        material.workspaces.candidateRoot === undefined) {
         ctx.addIssue({
             code: "custom",
-            path: ["launch", "env", "TANGLE_CANDIDATE_TASK_PATH"],
-            message: "non-file delivery cannot expose an instruction path",
+            path: ["launch", "cwd", "workspace"],
+            message: "candidate cwd requires a pinned candidate workspace root",
         });
     }
-    if (activeCode && material.candidateWorkspace?.material.files.length === 0) {
+    if (material.profile.targetWorkspace === "candidate" &&
+        material.workspaces.candidateRoot === undefined) {
         ctx.addIssue({
             code: "custom",
-            path: ["candidateWorkspace", "material", "files"],
-            message: "active candidate workspaces cannot be empty",
+            path: ["profile", "targetWorkspace"],
+            message: "candidate-targeted profile files require a candidate workspace root",
         });
     }
-    if (material.task.outcome.kind === "workspace" &&
-        material.task.workspace.material.files.length === 0) {
+    if (activeCode && material.candidateWorkspace?.material.files.length === 0) {
         ctx.addIssue({
             code: "custom",
-            path: ["task", "workspace", "material", "files"],
-            message: "task workspace snapshots cannot be empty",
+            path: ["candidateWorkspace", "material", "files"],
+            message: "active candidate workspaces cannot be empty",
         });
     }
     if (!isCanonicalJsonValue(material)) {

package/dist/agent-candidate-lineage-schema.d.ts

@@ -120,13 +120,6 @@ export declare const agentCandidateMemoryPolicySchema: z.ZodDiscriminatedUnion<[
         byteLength: z.ZodNumber;
     }, z.core.$strict>>;
 }, z.core.$strict>], "mode">;
-export declare const agentCandidateSpendSchema: z.ZodObject<{
-    costUsd: z.ZodNumber;
-    inputTokens: z.ZodNumber;
-    outputTokens: z.ZodNumber;
-    cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-    modelCalls: z.ZodNumber;
-}, z.core.$strict>;
 export declare const agentCandidateLineageSchema: z.ZodObject<{
     source: z.ZodEnum<{
         optimizer: "optimizer";
@@ -138,25 +131,5 @@ export declare const agentCandidateLineageSchema: z.ZodObject<{
     runIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     profileDiffIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     modelSnapshots: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    benchmark: z.ZodOptional<z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-        splitDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    }, z.core.$strict>>;
-    spend: z.ZodOptional<z.ZodObject<{
-        proposal: z.ZodObject<{
-            costUsd: z.ZodNumber;
-            inputTokens: z.ZodNumber;
-            outputTokens: z.ZodNumber;
-            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-            modelCalls: z.ZodNumber;
-        }, z.core.$strict>;
-        evaluation: z.ZodObject<{
-            costUsd: z.ZodNumber;
-            inputTokens: z.ZodNumber;
-            outputTokens: z.ZodNumber;
-            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-            modelCalls: z.ZodNumber;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
+    developmentSplitDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;

package/dist/agent-candidate-lineage-schema.js

@@ -30,15 +30,6 @@ export const agentCandidateMemoryPolicySchema = z.discriminatedUnion("mode", [
     })
         .strict(),
 ]);
-export const agentCandidateSpendSchema = z
-    .object({
-    costUsd: z.number().finite().nonnegative(),
-    inputTokens: z.number().int().nonnegative(),
-    outputTokens: z.number().int().nonnegative(),
-    cachedInputTokens: z.number().int().nonnegative().optional(),
-    modelCalls: z.number().int().nonnegative(),
-})
-    .strict();
 export const agentCandidateLineageSchema = z
     .object({
     source: z.enum(["optimizer", "human", "import", "compound"]),
@@ -46,21 +37,7 @@ export const agentCandidateLineageSchema = z
     runIds: z.array(z.string().min(1)).optional(),
     profileDiffIds: z.array(z.string().min(1)).optional(),
     modelSnapshots: z.array(z.string().min(1)).optional(),
-    benchmark: z
-        .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        splitDigest: sha256DigestSchema,
-    })
-        .strict()
-        .optional(),
-    spend: z
-        .object({
-        proposal: agentCandidateSpendSchema,
-        evaluation: agentCandidateSpendSchema,
-    })
-        .strict()
-        .optional(),
+    developmentSplitDigest: sha256DigestSchema.optional(),
 })
     .strict()
     .superRefine((lineage, ctx) => {
@@ -91,19 +68,12 @@ export const agentCandidateLineageSchema = z
                 message: "generated candidates must name their producing run",
             });
         }
-        if (lineage.benchmark === undefined) {
+        if (lineage.developmentSplitDigest === undefined) {
             ctx.addIssue({
                 code: "custom",
-                path: ["benchmark"],
+                path: ["developmentSplitDigest"],
                 message: "generated candidates must pin their development split",
             });
         }
-        if (lineage.spend === undefined) {
-            ctx.addIssue({
-                code: "custom",
-                path: ["spend"],
-                message: "generated candidates must record proposal and evaluation spend",
-            });
-        }
     }
 });

package/dist/agent-candidate-outcome-schema.d.ts

@@ -522,15 +522,10 @@ export declare const agentCandidateBenchmarkResultMaterialSchema: z.ZodObject<{
     kind: z.ZodLiteral<"agent-candidate-benchmark-result-material">;
     executionPlanDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
     taskOutcomeDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    benchmark: z.ZodObject<{
-        name: z.ZodString;
-        version: z.ZodString;
-        taskId: z.ZodString;
-        splitDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    }, z.core.$strict>;
     grader: z.ZodObject<{
         name: z.ZodString;
         version: z.ZodString;
+        format: z.ZodLiteral<"tangle-grader">;
         artifact: z.ZodObject<{
             locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"s3">;
@@ -560,6 +555,21 @@ export declare const agentCandidateBenchmarkResultMaterialSchema: z.ZodObject<{
         sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
         byteLength: z.ZodNumber;
     }, z.core.$strict>;
+    grading: z.ZodObject<{
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cachedInputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNumber;
+            modelCalls: z.ZodNumber;
+            costUsdNanos: z.ZodNumber;
+        }, z.core.$strict>;
+        timing: z.ZodObject<{
+            startedAtMs: z.ZodNumber;
+            endedAtMs: z.ZodNumber;
+            durationMs: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
     score: z.ZodNumber;
     passed: z.ZodBoolean;
     dimensions: z.ZodArray<z.ZodObject<{
@@ -574,15 +584,10 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
         kind: "agent-candidate-benchmark-result-material";
         executionPlanDigest: `sha256:${string}`;
         taskOutcomeDigest: `sha256:${string}`;
-        benchmark: {
-            name: string;
-            version: string;
-            taskId: string;
-            splitDigest: `sha256:${string}`;
-        };
         grader: {
             name: string;
             version: string;
+            format: "tangle-grader";
             artifact: {
                 locator: {
                     kind: "s3";
@@ -612,6 +617,21 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
             sha256: `sha256:${string}`;
             byteLength: number;
         };
+        grading: {
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+                cachedInputTokens: number;
+                reasoningTokens: number;
+                modelCalls: number;
+                costUsdNanos: number;
+            };
+            timing: {
+                startedAtMs: number;
+                endedAtMs: number;
+                durationMs: number;
+            };
+        };
         score: number;
         passed: boolean;
         dimensions: {
@@ -622,15 +642,10 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
         kind: "agent-candidate-benchmark-result-material";
         executionPlanDigest: `sha256:${string}`;
         taskOutcomeDigest: `sha256:${string}`;
-        benchmark: {
-            name: string;
-            version: string;
-            taskId: string;
-            splitDigest: `sha256:${string}`;
-        };
         grader: {
             name: string;
             version: string;
+            format: "tangle-grader";
             artifact: {
                 locator: {
                     kind: "s3";
@@ -660,6 +675,21 @@ export declare const agentCandidateBenchmarkResultEvidenceSchema: z.ZodObject<{
             sha256: `sha256:${string}`;
             byteLength: number;
         };
+        grading: {
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+                cachedInputTokens: number;
+                reasoningTokens: number;
+                modelCalls: number;
+                costUsdNanos: number;
+            };
+            timing: {
+                startedAtMs: number;
+                endedAtMs: number;
+                durationMs: number;
+            };
+        };
         score: number;
         passed: boolean;
         dimensions: {

package/dist/agent-candidate-outcome-schema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { agentCandidateArtifactRefSchema, agentCandidateCapturedArtifactSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
-import { agentCandidateResolvedModelSchema } from "./agent-candidate-execution-plan-schema.js";
+import { agentCandidateBenchmarkGraderIdentitySchema, agentCandidateResolvedModelSchema, } from "./agent-candidate-execution-plan-schema.js";
 import { agentCandidateMediaTypeSchema, gitObjectSchema, isCanonicalJsonValue, sameGitObjectFormat, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 const safeCountSchema = z
     .number()
@@ -265,35 +265,26 @@ export const agentCandidateBenchmarkResultMaterialSchema = z
     kind: z.literal("agent-candidate-benchmark-result-material"),
     executionPlanDigest: sha256DigestSchema,
     taskOutcomeDigest: sha256DigestSchema,
-    benchmark: z
-        .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        taskId: z.string().min(1),
-        splitDigest: sha256DigestSchema,
-    })
-        .strict(),
-    grader: z
+    grader: agentCandidateBenchmarkGraderIdentitySchema,
+    evidence: agentCandidateArtifactRefSchema,
+    grading: z
         .object({
-        name: z.string().min(1),
-        version: z.string().min(1),
-        artifact: agentCandidateArtifactRefSchema,
+        usage: agentCandidateFixedSpendSchema,
+        timing: z
+            .object({
+            startedAtMs: safeCountSchema,
+            endedAtMs: safeCountSchema,
+            durationMs: safeCountSchema,
+        })
+            .strict(),
     })
         .strict(),
-    evidence: agentCandidateArtifactRefSchema,
     score: normalizedScoreSchema,
     passed: z.boolean(),
     dimensions: z.array(agentCandidateBenchmarkDimensionSchema),
 })
     .strict()
     .superRefine((material, ctx) => {
-    if (material.grader.artifact.byteLength === 0) {
-        ctx.addIssue({
-            code: "custom",
-            path: ["grader", "artifact", "byteLength"],
-            message: "pinned grader artifact must contain executable grader bytes",
-        });
-    }
     if (material.evidence.byteLength === 0) {
         ctx.addIssue({
             code: "custom",
@@ -301,11 +292,15 @@ export const agentCandidateBenchmarkResultMaterialSchema = z
             message: "benchmark result must contain non-empty durable grading evidence",
         });
     }
-    if (material.evidence.sha256 === material.grader.artifact.sha256) {
+    if (material.grading.timing.endedAtMs <
+        material.grading.timing.startedAtMs ||
+        material.grading.timing.durationMs !==
+            material.grading.timing.endedAtMs -
+                material.grading.timing.startedAtMs) {
         ctx.addIssue({
             code: "custom",
-            path: ["evidence", "sha256"],
-            message: "grading evidence must be distinct from the grader implementation",
+            path: ["grading", "timing"],
+            message: "grader timing must be ordered and internally consistent",
         });
     }
     for (let index = 1; index < material.dimensions.length; index++) {