@tangle-network/agent-interface 0.34.0 → 0.36.0

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

@@ -3,9 +3,10 @@ import { agentCandidateBundleSchema } from "./agent-candidate-schema.js";
 import { agentCandidateLineageSchema } from "./agent-candidate-lineage-schema.js";
 import { agentCandidateBenchmarkSuiteInputsSchema } from "./agent-candidate-task-schema.js";
 import { canonicalCandidateDigest, isCanonicalJsonValue, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+import { refineAgentExecutionWithinLimits } from "./agent-execution-limits.js";
 import { agentCandidateMaterializationReceiptSchema, agentCandidateRunReceiptSchema, } from "./agent-candidate-receipt-schema.js";
 import { agentCandidateEvaluationPolicySchema, canonicalJsonObjectSchema, createMeasuredComparisonIdentityRegistry, measuredComparisonCommonShape, refineMeasuredComparisonSummary, } from "./agent-improvement-measurement-schema.js";
-import { agentProfileImprovementMeasuredComparisonSchema, changedProfileImprovementSurfaces, } from "./agent-profile-improvement-schema.js";
+import { agentProfileImprovementExecutionRefSchema, agentProfileImprovementMeasuredComparisonSchema, changedProfileImprovementSurfaces, } from "./agent-profile-improvement-schema.js";
 const improvementSurfaceSchema = z.enum([
     "prompt",
     "skills",
@@ -112,6 +113,14 @@ export const candidateExecutionEvidenceSchema = z
         if (!valid)
             ctx.addIssue({ code: "custom", path, message });
     }
+    refineAgentExecutionWithinLimits(plan.material.limits, {
+        durationMs: evidence.receipt.timing.durationMs,
+        steps: evidence.receipt.steps,
+        usage: evidence.receipt.modelSettlement.material.usage,
+    }, ctx, {
+        pathPrefix: ["receipt"],
+        usagePath: ["modelSettlement", "material", "usage"],
+    });
     if (!isCanonicalJsonValue(evidence)) {
         ctx.addIssue({
             code: "custom",
@@ -356,6 +365,7 @@ export const agentImprovementMeasuredComparisonSchema = z
         score: (evidence) => evidence.receipt.benchmarkResult.material.score,
         dimension: (evidence, name) => evidence.receipt.benchmarkResult.material.dimensions.find((dimension) => dimension.name === name)?.score,
         cost: executionCostUsd,
+        costProvenance: executionCostProvenance,
         latency: executionLatencyMs,
     }, ctx);
     if (!isCanonicalJsonValue(comparison)) {
@@ -433,6 +443,12 @@ function executionCostUsd(evidence) {
     return (evidence.receipt.modelSettlement.material.usage.costUsdNanos +
         evidence.receipt.benchmarkResult.material.grading.usage.costUsdNanos) / 1_000_000_000;
 }
+function executionCostProvenance(evidence) {
+    return evidence.receipt.modelSettlement.material.usage.costProvenance === "observed" &&
+        evidence.receipt.benchmarkResult.material.grading.usage.costProvenance === "observed"
+        ? "observed"
+        : "estimated";
+}
 function executionLatencyMs(evidence) {
     return (evidence.receipt.timing.durationMs +
         evidence.receipt.benchmarkResult.material.grading.timing.durationMs);
@@ -464,6 +480,7 @@ export const agentImprovementActivationSchema = z
     reviewDigest: sha256DigestSchema,
     experimentDigest: sha256DigestSchema,
     candidateDigest: sha256DigestSchema,
+    executionRef: agentProfileImprovementExecutionRefSchema.optional(),
     intent: z.enum(["activate-candidate", "restore-baseline"]),
     targets: z
         .tuple([improvementActivationTargetSchema])
@@ -476,6 +493,21 @@ export const agentImprovementActivationSchema = z
 })
     .strict()
     .superRefine((activation, ctx) => {
+    const targetsAgentProfile = activation.targets.some((target) => target.surface === "agent-profile");
+    if (targetsAgentProfile && !activation.executionRef) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["executionRef"],
+            message: "agent-profile activation requires the measured runner reference",
+        });
+    }
+    if (!targetsAgentProfile && activation.executionRef) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["executionRef"],
+            message: "executionRef is valid only for agent-profile activation",
+        });
+    }
     const identities = activation.targets.map((target) => `${target.surface}\u0000${target.identity}`);
     if (new Set(identities).size !== identities.length) {
         ctx.addIssue({

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

@@ -903,6 +903,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
         endedAtMs: z.ZodNumber;
         durationMs: z.ZodNumber;
     }, z.core.$strict>;
+    steps: z.ZodNumber;
     memory: z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"disabled">;
     }, z.core.$strict>, z.ZodObject<{
@@ -1029,6 +1030,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                 cachedInputTokens: number;
                 reasoningTokens: number;
                 costUsdNanos: number;
+                costProvenance: "observed" | "estimated";
             }[];
             kind: "agent-candidate-model-settlement-material";
             executionPlanDigest: `sha256:${string}`;
@@ -1049,6 +1051,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                 reasoningTokens: number;
                 modelCalls: number;
                 costUsdNanos: number;
+                costProvenance: "observed" | "estimated";
             };
         }, unknown, z.core.$ZodTypeInternals<{
             calls: {
@@ -1064,6 +1067,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                 cachedInputTokens: number;
                 reasoningTokens: number;
                 costUsdNanos: number;
+                costProvenance: "observed" | "estimated";
             }[];
             kind: "agent-candidate-model-settlement-material";
             executionPlanDigest: `sha256:${string}`;
@@ -1084,6 +1088,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                 reasoningTokens: number;
                 modelCalls: number;
                 costUsdNanos: number;
+                costProvenance: "observed" | "estimated";
             };
         }, unknown>>;
         artifact: z.ZodUnion<readonly [z.ZodObject<{
@@ -1390,6 +1395,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                     reasoningTokens: number;
                     modelCalls: number;
                     costUsdNanos: number;
+                    costProvenance: "observed" | "estimated";
                 };
                 timing: {
                     startedAtMs: number;
@@ -1448,6 +1454,7 @@ export declare const agentCandidateRunReceiptSchema: z.ZodObject<{
                     reasoningTokens: number;
                     modelCalls: number;
                     costUsdNanos: number;
+                    costProvenance: "observed" | "estimated";
                 };
                 timing: {
                     startedAtMs: number;

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

@@ -259,6 +259,7 @@ export const agentCandidateRunReceiptSchema = z
         durationMs: z.number().int().nonnegative().safe(),
     })
         .strict(),
+    steps: z.number().int().nonnegative().safe(),
     memory: agentCandidateMemoryReceiptSchema,
     trace: agentCandidateTraceEvidenceSchema,
     termination: agentCandidateTerminationSchema,

package/dist/agent-candidate.d.ts

@@ -1,6 +1,6 @@
 import type { AgentProfile, AgentProfileFileMount, AgentProfileHookCommand, AgentProfileMode, AgentProfileModelHints, AgentProfileResources, AgentSubagentProfile, ReasoningEffort } from "./agent-profile.js";
 import type { HarnessType } from "./harness.js";
-import type { AgentProfileImprovementMeasuredComparison } from "./agent-profile-improvement.js";
+import type { AgentProfileImprovementExecutionRef, AgentProfileImprovementMeasuredComparison } from "./agent-profile-improvement.js";
 /** Full SHA-256 digest with an explicit algorithm prefix. */
 export type Sha256Digest = `sha256:${string}`;
 /** RFC 8785 JSON Canonicalization Scheme followed by SHA-256. */
@@ -235,6 +235,33 @@ export type AgentCandidateMemoryPolicy = {
     scope: "task";
     seed?: AgentCandidateArtifactRef;
 };
+/** Whether a settled cost came from provider billing or a reproducible estimate. */
+export type AgentCandidateCostProvenance = "observed" | "estimated";
+/** One known dollar amount carried with its source. */
+export interface AgentImprovementCost {
+    usd: number;
+    provenance: AgentCandidateCostProvenance;
+}
+/** Complete accounting for a measured improvement proposal. */
+export interface AgentImprovementEvaluationAccounting {
+    generationsExplored: number;
+    /** Trace analysis and candidate search before held-out execution. */
+    preparation: {
+        wallDurationMs: number;
+        cost: AgentImprovementCost;
+    };
+    /** Held-out baseline/candidate execution. Work time sums parallel calls. */
+    measurement: {
+        wallDurationMs: number;
+        workDurationMs: number;
+        cost: AgentImprovementCost;
+    };
+    /** Wall time is preparation plus held-out measurement. */
+    total: {
+        wallDurationMs: number;
+        cost: AgentImprovementCost;
+    };
+}
 /** Lossless evaluator-owned usage totals for one candidate execution. */
 export interface AgentCandidateFixedSpend {
     inputTokens: number;
@@ -244,6 +271,7 @@ export interface AgentCandidateFixedSpend {
     modelCalls: number;
     /** Integer billionths of one US dollar. */
     costUsdNanos: number;
+    costProvenance: AgentCandidateCostProvenance;
 }
 /** Evidence and ancestry that produced the immutable candidate. */
 export interface AgentCandidateLineage {
@@ -350,13 +378,14 @@ export type AgentCandidateEffectiveMemory = {
     beforeState: AgentCandidateWorkspaceSnapshotEvidence;
     seedDigest?: Sha256Digest;
 };
-/** The exact evaluator-owned limits applied to every candidate arm. */
+/** The exact evaluator-owned limits applied to every complete candidate arm. */
 export interface AgentCandidateExecutionLimits {
     timeoutMs: number;
     maxSteps: number;
     maxModelCalls: number;
     maxInputTokens: number;
     maxOutputTokens: number;
+    /** Total agent plus grading spend for one complete arm. */
     maxCostUsd: number;
 }
 /** Counted attempt identity and the only retry class allowed by the evaluator. */
@@ -658,6 +687,7 @@ export interface AgentCandidateRunReceipt {
         endedAtMs: number;
         durationMs: number;
     };
+    steps: number;
     memory: AgentCandidateMemoryReceipt;
     trace: AgentCandidateTraceEvidence;
     termination: AgentCandidateTermination;
@@ -764,15 +794,7 @@ export interface AgentImprovementMeasuredComparisonBase<TExperiment, TMeasuremen
         candidateContentHash: string;
     };
     diff: string;
-    evaluation: {
-        generationsExplored: number;
-        searchDurationMs: number;
-        executionDurationMs: number;
-        durationMs: number;
-        searchCostUsd: number;
-        executionCostUsd: number;
-        totalCostUsd: number;
-    };
+    evaluation: AgentImprovementEvaluationAccounting;
     metadata?: {
         [key: string]: AgentCandidateJsonValue;
     };
@@ -821,6 +843,8 @@ export interface AgentImprovementActivation {
     experimentDigest: Sha256Digest;
     /** Exact proposed state, whether it is a sealed bundle or a normal profile. */
     candidateDigest: Sha256Digest;
+    /** Required when a target uses `agent-profile`; the schema enforces this condition. */
+    executionRef?: AgentProfileImprovementExecutionRef;
     intent: AgentImprovementActivationIntent;
     targets: [AgentImprovementActivationTarget, ...AgentImprovementActivationTarget[]];
     fundingOwner: string;
@@ -894,6 +918,7 @@ export interface AgentCandidateModelSettlementCall {
     cachedInputTokens: number;
     reasoningTokens: number;
     costUsdNanos: number;
+    costProvenance: AgentCandidateCostProvenance;
 }
 /** Canonical model-access ledger after the evaluator has revoked access. */
 export interface AgentCandidateModelSettlementMaterial {

package/dist/agent-execution-limits.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import type { AgentCandidateExecutionLimits, AgentCandidateFixedSpend } from "./agent-candidate.js";
+/** The observable execution facts required to prove a frozen limit was respected. */
+export interface AgentExecutionLimitObservation {
+    durationMs: number;
+    steps: number;
+    usage: AgentCandidateFixedSpend;
+}
+export declare const agentExecutionLimitObservationSchema: z.ZodObject<{
+    durationMs: z.ZodNumber;
+    steps: z.ZodNumber;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cachedInputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        modelCalls: z.ZodNumber;
+        costUsdNanos: z.ZodNumber;
+        costProvenance: z.ZodEnum<{
+            observed: "observed";
+            estimated: "estimated";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export interface RefineAgentExecutionWithinLimitsOptions {
+    pathPrefix?: (string | number)[];
+    usagePath?: (string | number)[];
+}
+/** Reject an execution record that cannot satisfy every limit it claims to use. */
+export declare function assertAgentExecutionWithinLimits(limits: AgentCandidateExecutionLimits, observation: AgentExecutionLimitObservation): void;
+/** Add schema issues instead of throwing when a receipt is parsed by Zod. */
+export declare function refineAgentExecutionWithinLimits(limits: AgentCandidateExecutionLimits, observation: AgentExecutionLimitObservation, ctx: z.RefinementCtx, options?: RefineAgentExecutionWithinLimitsOptions): void;

package/dist/agent-execution-limits.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { agentCandidateExecutionLimitsSchema } from "./agent-candidate-execution-plan-schema.js";
+import { agentCandidateFixedSpendSchema } from "./agent-candidate-outcome-schema.js";
+export const agentExecutionLimitObservationSchema = z
+    .object({
+    durationMs: z.number().finite().nonnegative(),
+    steps: z.number().int().nonnegative().safe(),
+    usage: agentCandidateFixedSpendSchema,
+})
+    .strict();
+/** Reject an execution record that cannot satisfy every limit it claims to use. */
+export function assertAgentExecutionWithinLimits(limits, observation) {
+    const parsedLimits = agentCandidateExecutionLimitsSchema.parse(limits);
+    const parsedObservation = agentExecutionLimitObservationSchema.parse(observation);
+    const violations = executionLimitViolations(parsedLimits, parsedObservation);
+    if (violations.length === 0)
+        return;
+    throw new Error(violations
+        .map((violation) => `execution ${violation.label} ${violation.actual} exceeds frozen limit ${violation.maximum}`)
+        .join("; "));
+}
+/** Add schema issues instead of throwing when a receipt is parsed by Zod. */
+export function refineAgentExecutionWithinLimits(limits, observation, ctx, options = {}) {
+    const pathPrefix = options.pathPrefix ?? [];
+    const usagePath = options.usagePath ?? ["usage"];
+    for (const violation of executionLimitViolations(limits, observation)) {
+        const path = violation.path[0] === "usage"
+            ? [...pathPrefix, ...usagePath, ...violation.path.slice(1)]
+            : [...pathPrefix, ...violation.path];
+        ctx.addIssue({
+            code: "custom",
+            path,
+            message: `execution ${violation.label} ${violation.actual} exceeds frozen limit ${violation.maximum}`,
+        });
+    }
+}
+function executionLimitViolations(limits, observation) {
+    const checks = [
+        {
+            path: ["timing", "durationMs"],
+            label: "durationMs",
+            actual: observation.durationMs,
+            maximum: limits.timeoutMs,
+        },
+        {
+            path: ["steps"],
+            label: "steps",
+            actual: observation.steps,
+            maximum: limits.maxSteps,
+        },
+        {
+            path: ["usage", "modelCalls"],
+            label: "modelCalls",
+            actual: observation.usage.modelCalls,
+            maximum: limits.maxModelCalls,
+        },
+        {
+            path: ["usage", "inputTokens"],
+            label: "inputTokens",
+            actual: observation.usage.inputTokens,
+            maximum: limits.maxInputTokens,
+        },
+        {
+            path: ["usage", "outputTokens"],
+            label: "outputTokens",
+            actual: observation.usage.outputTokens,
+            maximum: limits.maxOutputTokens,
+        },
+        {
+            path: ["usage", "costUsdNanos"],
+            label: "costUsd",
+            actual: observation.usage.costUsdNanos / 1_000_000_000,
+            maximum: limits.maxCostUsd,
+        },
+    ];
+    return checks.filter((check) => check.actual > check.maximum);
+}

package/dist/agent-improvement-measurement-schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { AgentCandidateEvaluationPolicy, AgentCandidateJsonValue, AgentImprovementMeasuredComparisonBase } from "./agent-candidate.js";
+import type { AgentCandidateCostProvenance, AgentCandidateEvaluationPolicy, AgentCandidateJsonValue, AgentImprovementMeasuredComparisonBase } from "./agent-candidate.js";
 export declare const canonicalJsonSchema: z.ZodCustom<AgentCandidateJsonValue, AgentCandidateJsonValue>;
 export declare const canonicalJsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodCustom<AgentCandidateJsonValue, AgentCandidateJsonValue>>;
 export declare const agentCandidateEvaluationPolicySchema: z.ZodObject<{
@@ -12,6 +12,13 @@ export declare const agentCandidateEvaluationPolicySchema: z.ZodObject<{
     criticalDimensions: z.ZodArray<z.ZodString>;
     regressionTolerance: z.ZodNumber;
 }, z.core.$strict>;
+export declare const agentImprovementCostSchema: z.ZodObject<{
+    usd: z.ZodNumber;
+    provenance: z.ZodEnum<{
+        observed: "observed";
+        estimated: "estimated";
+    }>;
+}, z.core.$strict>;
 export declare const measuredComparisonCommonShape: {
     overall: z.ZodObject<{
         direction: z.ZodLiteral<"higher-is-better">;
@@ -157,12 +164,37 @@ export declare const measuredComparisonCommonShape: {
     diff: z.ZodString;
     evaluation: z.ZodObject<{
         generationsExplored: z.ZodNumber;
-        searchDurationMs: z.ZodNumber;
-        executionDurationMs: z.ZodNumber;
-        durationMs: z.ZodNumber;
-        searchCostUsd: z.ZodNumber;
-        executionCostUsd: z.ZodNumber;
-        totalCostUsd: z.ZodNumber;
+        preparation: z.ZodObject<{
+            wallDurationMs: z.ZodNumber;
+            cost: z.ZodObject<{
+                usd: z.ZodNumber;
+                provenance: z.ZodEnum<{
+                    observed: "observed";
+                    estimated: "estimated";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        measurement: z.ZodObject<{
+            wallDurationMs: z.ZodNumber;
+            workDurationMs: z.ZodNumber;
+            cost: z.ZodObject<{
+                usd: z.ZodNumber;
+                provenance: z.ZodEnum<{
+                    observed: "observed";
+                    estimated: "estimated";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        total: z.ZodObject<{
+            wallDurationMs: z.ZodNumber;
+            cost: z.ZodObject<{
+                usd: z.ZodNumber;
+                provenance: z.ZodEnum<{
+                    observed: "observed";
+                    estimated: "estimated";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
     }, z.core.$strict>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<AgentCandidateJsonValue, AgentCandidateJsonValue>>>;
 };
@@ -184,6 +216,7 @@ export declare function refineMeasuredComparisonSummary<TReceipt>(comparison: Me
     score(receipt: TReceipt): number;
     dimension(receipt: TReceipt, name: string): number | undefined;
     cost(receipt: TReceipt): number;
+    costProvenance(receipt: TReceipt): AgentCandidateCostProvenance;
     latency(receipt: TReceipt): number;
 }, ctx: z.RefinementCtx): void;
 export declare function refineEstimate(estimate: {

package/dist/agent-improvement-measurement-schema.js

@@ -95,6 +95,36 @@ export const agentCandidateEvaluationPolicySchema = z
         });
     }
 });
+export const agentImprovementCostSchema = z
+    .object({
+    usd: z.number().finite().nonnegative(),
+    provenance: z.enum(["observed", "estimated"]),
+})
+    .strict();
+const agentImprovementEvaluationSchema = z
+    .object({
+    generationsExplored: z.number().int().nonnegative(),
+    preparation: z
+        .object({
+        wallDurationMs: z.number().finite().nonnegative(),
+        cost: agentImprovementCostSchema,
+    })
+        .strict(),
+    measurement: z
+        .object({
+        wallDurationMs: z.number().finite().nonnegative(),
+        workDurationMs: z.number().finite().nonnegative(),
+        cost: agentImprovementCostSchema,
+    })
+        .strict(),
+    total: z
+        .object({
+        wallDurationMs: z.number().finite().nonnegative(),
+        cost: agentImprovementCostSchema,
+    })
+        .strict(),
+})
+    .strict();
 export const measuredComparisonCommonShape = {
     overall: z
         .object({
@@ -148,17 +178,7 @@ export const measuredComparisonCommonShape = {
     })
         .strict(),
     diff: z.string(),
-    evaluation: z
-        .object({
-        generationsExplored: z.number().int().nonnegative(),
-        searchDurationMs: z.number().finite().nonnegative(),
-        executionDurationMs: z.number().finite().nonnegative(),
-        durationMs: z.number().finite().nonnegative(),
-        searchCostUsd: z.number().finite().nonnegative(),
-        executionCostUsd: z.number().finite().nonnegative(),
-        totalCostUsd: z.number().finite().nonnegative(),
-    })
-        .strict(),
+    evaluation: agentImprovementEvaluationSchema,
     metadata: canonicalJsonObjectSchema.optional(),
 };
 /** Keep receipt identity reuse rules identical across measured source formats. */
@@ -181,12 +201,18 @@ export function createMeasuredComparisonIdentityRegistry(options) {
 }
 export function refineMeasuredComparisonSummary(comparison, policy, expectedN, measurements, values, ctx) {
     refineEstimate(comparison.overall, ["overall"], ctx);
-    if (!numbersApproximatelyEqual(comparison.evaluation.durationMs, comparison.evaluation.searchDurationMs + comparison.evaluation.executionDurationMs) ||
-        !numbersApproximatelyEqual(comparison.evaluation.totalCostUsd, comparison.evaluation.searchCostUsd + comparison.evaluation.executionCostUsd)) {
+    const totalCostProvenance = comparison.evaluation.preparation.cost.provenance === "observed" &&
+        comparison.evaluation.measurement.cost.provenance === "observed"
+        ? "observed"
+        : "estimated";
+    if (!numbersApproximatelyEqual(comparison.evaluation.total.wallDurationMs, comparison.evaluation.preparation.wallDurationMs +
+        comparison.evaluation.measurement.wallDurationMs) ||
+        !numbersApproximatelyEqual(comparison.evaluation.total.cost.usd, comparison.evaluation.preparation.cost.usd + comparison.evaluation.measurement.cost.usd) ||
+        comparison.evaluation.total.cost.provenance !== totalCostProvenance) {
         ctx.addIssue({
             code: "custom",
             path: ["evaluation"],
-            message: "evaluation totals must equal their search and execution components",
+            message: "evaluation totals must equal preparation and measurement accounting",
         });
     }
     if (comparison.overall.n !== expectedN) {
@@ -265,6 +291,21 @@ export function refineMeasuredComparisonSummary(comparison, policy, expectedN, m
             latencyCount += 1;
         }
     }
+    const measurementCostUsd = measurements.reduce((sum, measurement) => sum + values.cost(measurement.baseline) + values.cost(measurement.candidate), 0);
+    const measurementWorkDurationMs = measurements.reduce((sum, measurement) => sum + values.latency(measurement.baseline) + values.latency(measurement.candidate), 0);
+    const measurementCostProvenance = measurements.every((measurement) => values.costProvenance(measurement.baseline) === "observed" &&
+        values.costProvenance(measurement.candidate) === "observed")
+        ? "observed"
+        : "estimated";
+    if (!numbersApproximatelyEqual(comparison.evaluation.measurement.cost.usd, measurementCostUsd) ||
+        comparison.evaluation.measurement.cost.provenance !== measurementCostProvenance ||
+        !numbersApproximatelyEqual(comparison.evaluation.measurement.workDurationMs, measurementWorkDurationMs)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["evaluation", "measurement"],
+            message: "measurement accounting must equal the complete signed receipts",
+        });
+    }
     if (costCount !== 1 || latencyCount !== 1) {
         ctx.addIssue({
             code: "custom",