@tangle-network/agent-interface 0.27.2 → 0.29.0

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

@@ -0,0 +1,191 @@
+import { z } from "zod";
+import { agentCandidateArtifactRefSchema, agentCandidateWorkspaceSnapshotEvidenceSchema, } from "./agent-candidate-artifact-schema.js";
+import { agentCandidateBenchmarkGraderIdentitySchema, agentCandidateBenchmarkCellRefSchema, agentCandidateExecutionLimitsSchema, agentCandidateResolvedModelSchema, agentCandidateResolvedTaskContainerSchema, agentCandidateRetryPolicySchema, agentCandidateTaskRepositorySchema, agentCandidateTaskOutcomeSpecSchema, } from "./agent-candidate-execution-plan-schema.js";
+import { isCanonicalJsonValue, isWellFormedUnicode, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+export const agentCandidateBenchmarkTaskMaterialSchema = z
+    .object({
+    kind: z.literal("agent-candidate-benchmark-task"),
+    digestAlgorithm: z.literal("rfc8785-sha256"),
+    benchmark: z
+        .object({
+        name: z.string().min(1).max(512),
+        version: z.string().min(1).max(256),
+        splitDigest: sha256DigestSchema,
+    })
+        .strict(),
+    scenario: z
+        .object({
+        id: z.string().min(1).max(512),
+        kind: z.string().min(1).max(512),
+        scenarioDigest: sha256DigestSchema,
+    })
+        .strict(),
+    datasetSnapshot: agentCandidateArtifactRefSchema.optional(),
+    instruction: z
+        .string()
+        .min(1)
+        .max(4 * 1024 * 1024)
+        .refine(isWellFormedUnicode, "task instruction must be well-formed Unicode"),
+    repository: agentCandidateTaskRepositorySchema.optional(),
+    outcome: agentCandidateTaskOutcomeSpecSchema,
+    workspace: agentCandidateWorkspaceSnapshotEvidenceSchema,
+    grader: agentCandidateBenchmarkGraderIdentitySchema,
+    model: agentCandidateResolvedModelSchema,
+    attempt: z
+        .object({
+        maxAttempts: z.number().int().min(1),
+        retryPolicy: agentCandidateRetryPolicySchema,
+    })
+        .strict(),
+    evaluatorTaskContainer: agentCandidateResolvedTaskContainerSchema.optional(),
+    limits: agentCandidateExecutionLimitsSchema,
+})
+    .strict()
+    .superRefine((task, ctx) => {
+    if (!isCanonicalJsonValue(task)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "candidate benchmark task must contain finite, acyclic canonical JSON",
+        });
+    }
+    if (task.outcome.kind === "workspace" && task.repository === undefined) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["repository"],
+            message: "workspace outcomes require an exact source repository",
+        });
+    }
+    if (task.attempt.retryPolicy === "none" && task.attempt.maxAttempts !== 1) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["attempt", "maxAttempts"],
+            message: "a no-retry task must allow exactly one attempt",
+        });
+    }
+    if (task.datasetSnapshot?.byteLength === 0) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["datasetSnapshot", "byteLength"],
+            message: "dataset snapshot provenance must contain bytes",
+        });
+    }
+});
+/** Structural parse only; Runtime recomputes the canonical digest before use. */
+export const agentCandidateBenchmarkTaskSchema = agentCandidateBenchmarkTaskMaterialSchema
+    .extend({ digest: sha256DigestSchema })
+    .strict();
+export const agentCandidateBenchmarkSuiteMaterialSchema = z
+    .object({
+    kind: z.literal("agent-candidate-benchmark-suite"),
+    digestAlgorithm: z.literal("rfc8785-sha256"),
+    taskDigests: z
+        .tuple([sha256DigestSchema])
+        .rest(sha256DigestSchema),
+    reps: z.number().int().positive(),
+    seeds: z
+        .tuple([
+        z
+            .number()
+            .int()
+            .min(Number.MIN_SAFE_INTEGER)
+            .max(Number.MAX_SAFE_INTEGER),
+    ])
+        .rest(z
+        .number()
+        .int()
+        .min(Number.MIN_SAFE_INTEGER)
+        .max(Number.MAX_SAFE_INTEGER)),
+})
+    .strict()
+    .superRefine((suite, ctx) => {
+    const taskDigests = new Set();
+    for (const [index, digest] of suite.taskDigests.entries()) {
+        if (taskDigests.has(digest)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["taskDigests", index],
+                message: "benchmark suite task digests must be unique",
+            });
+        }
+        taskDigests.add(digest);
+    }
+    const expectedSeeds = suite.taskDigests.length * suite.reps;
+    if (suite.seeds.length !== expectedSeeds) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["seeds"],
+            message: "benchmark suite must provide one seed per task repetition",
+        });
+    }
+    if (!isCanonicalJsonValue(suite)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "benchmark suite must contain finite, acyclic canonical JSON",
+        });
+    }
+});
+export const agentCandidateBenchmarkSuiteSchema = agentCandidateBenchmarkSuiteMaterialSchema
+    .extend({ digest: sha256DigestSchema })
+    .strict();
+export const agentCandidateBenchmarkSuiteInputsSchema = z
+    .object({
+    suite: agentCandidateBenchmarkSuiteSchema,
+    tasks: z
+        .tuple([agentCandidateBenchmarkTaskSchema])
+        .rest(agentCandidateBenchmarkTaskSchema),
+})
+    .strict()
+    .superRefine((input, ctx) => {
+    if (input.tasks.length !== input.suite.taskDigests.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["tasks"],
+            message: "benchmark suite inputs must contain every signed task exactly once",
+        });
+    }
+    const taskIds = new Set();
+    const scenarioDigests = new Set();
+    const benchmark = input.tasks[0]?.benchmark;
+    for (const [index, task] of input.tasks.entries()) {
+        if (task.digest !== input.suite.taskDigests[index]) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "digest"],
+                message: "benchmark task order must match the signed suite",
+            });
+        }
+        if (taskIds.has(task.scenario.id)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "scenario", "id"],
+                message: "benchmark suite task ids must be unique",
+            });
+        }
+        taskIds.add(task.scenario.id);
+        if (scenarioDigests.has(task.scenario.scenarioDigest)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "scenario", "scenarioDigest"],
+                message: "benchmark suite scenario digests must be unique",
+            });
+        }
+        scenarioDigests.add(task.scenario.scenarioDigest);
+        if (benchmark &&
+            (task.benchmark.name !== benchmark.name ||
+                task.benchmark.version !== benchmark.version ||
+                task.benchmark.splitDigest !== benchmark.splitDigest)) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["tasks", index, "benchmark"],
+                message: "benchmark suite tasks must share one benchmark identity",
+            });
+        }
+    }
+    if (!isCanonicalJsonValue(input)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "benchmark suite inputs must contain finite, acyclic canonical JSON",
+        });
+    }
+});
+export { agentCandidateBenchmarkCellRefSchema };

package/dist/agent-candidate.d.ts

@@ -106,8 +106,6 @@ export interface AgentCandidateProfile extends Omit<AgentProfile, "model" | "mcp
 }
 export interface AgentCandidateCodeDisabled {
     kind: "disabled";
-    /** `control` marks a comparison arm; `not-applicable` disables only the code surface. */
-    reason: "control" | "not-applicable";
 }
 /** A code proposer ran against this exact tree and returned no change. */
 export interface AgentCandidateCodeNoOp {
@@ -201,7 +199,6 @@ export interface AgentCandidateExecution {
 }
 /** Exact frozen knowledge candidate admitted only through an approved review. */
 export interface AgentCandidateKnowledgeRef {
-    schemaVersion: 1;
     kind: "knowledge-improvement-candidate";
     runId: string;
     candidateId: string;
@@ -225,14 +222,6 @@ export type AgentCandidateMemoryPolicy = {
     scope: "task";
     seed?: AgentCandidateArtifactRef;
 };
-/** Captured model spend for one phase of candidate production. */
-export interface AgentCandidateSpend {
-    costUsd: number;
-    inputTokens: number;
-    outputTokens: number;
-    cachedInputTokens?: number;
-    modelCalls: number;
-}
 /** Lossless evaluator-owned usage totals for one candidate execution. */
 export interface AgentCandidateFixedSpend {
     inputTokens: number;
@@ -250,15 +239,8 @@ export interface AgentCandidateLineage {
     runIds?: string[];
     profileDiffIds?: string[];
     modelSnapshots?: string[];
-    benchmark?: {
-        name: string;
-        version: string;
-        splitDigest: Sha256Digest;
-    };
-    spend?: {
-        proposal: AgentCandidateSpend;
-        evaluation: AgentCandidateSpend;
-    };
+    /** Exact development split used to produce a generated candidate. */
+    developmentSplitDigest?: Sha256Digest;
 }
 /**
  * Portable, immutable output of agent improvement.
@@ -269,7 +251,6 @@ export interface AgentCandidateLineage {
  * artifact hashes are untrusted until recomputed.
  */
 export interface AgentCandidateBundle {
-    schemaVersion: 2;
     kind: "agent-candidate-bundle";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     profile: AgentCandidateProfile;
@@ -277,7 +258,6 @@ export interface AgentCandidateBundle {
     execution: AgentCandidateExecution;
     knowledge?: AgentCandidateKnowledge;
     memory: AgentCandidateMemoryPolicy;
-    lineage: AgentCandidateLineage;
     digest: Sha256Digest;
 }
 export interface AgentCandidateEntrypointReceipt {
@@ -290,6 +270,14 @@ export interface AgentCandidateOciPlatform {
     architecture: string;
     variant?: string;
 }
+/** Exact evaluator-selected task image used when the candidate does not pin one. */
+export interface AgentCandidateResolvedTaskContainer {
+    source: "evaluator-task-container";
+    image: string;
+    indexDigest: Sha256Digest;
+    manifestDigest: Sha256Digest;
+    platform: AgentCandidateOciPlatform;
+}
 export interface AgentCandidateResolvedModel {
     requested: string;
     provider: string;
@@ -299,7 +287,8 @@ export interface AgentCandidateResolvedModel {
 }
 /** Canonical, digest-free profile-plan identity document. */
 export interface AgentCandidateProfilePlanMaterial {
-    version: 1;
+    /** Canonical digest of the complete frozen profile that produced this plan. */
+    sourceProfileDigest: Sha256Digest;
     harness: HarnessType;
     files: Array<{
         relPath: string;
@@ -314,7 +303,6 @@ export interface AgentCandidateProfilePlanMaterial {
     }>;
 }
 export interface AgentCandidateWorkspaceManifestMaterial {
-    schemaVersion: 2;
     kind: "agent-candidate-workspace-manifest";
     files: Array<{
         path: string;
@@ -326,7 +314,6 @@ export interface AgentCandidateWorkspaceManifestMaterial {
 }
 /** Content-addressed manifest of every file uploaded to one workspace. */
 export interface AgentCandidateWorkspaceSnapshotEvidence {
-    schemaVersion: 2;
     kind: "agent-candidate-workspace-snapshot";
     digest: Sha256Digest;
     material: AgentCandidateWorkspaceManifestMaterial;
@@ -395,6 +382,103 @@ export type AgentCandidateTaskOutcomeSpec = {
 } | ({
     kind: "output";
 } & AgentCandidateTaskOutputSpec);
+/** Immutable grader identity admitted for one benchmark task. */
+export interface AgentCandidateBenchmarkGraderIdentity {
+    name: string;
+    version: string;
+    format: "tangle-grader";
+    artifact: AgentCandidateArtifactRef;
+}
+/** Portable task bytes shared by evaluation, approval, and execution. */
+export interface AgentCandidateBenchmarkTaskMaterial {
+    kind: "agent-candidate-benchmark-task";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    benchmark: {
+        name: string;
+        version: string;
+        splitDigest: Sha256Digest;
+    };
+    scenario: {
+        id: string;
+        kind: string;
+        scenarioDigest: Sha256Digest;
+    };
+    datasetSnapshot?: AgentCandidateArtifactRef;
+    instruction: string;
+    repository?: AgentCandidateTaskRepository;
+    outcome: AgentCandidateTaskOutcomeSpec;
+    workspace: AgentCandidateWorkspaceSnapshotEvidence;
+    grader: AgentCandidateBenchmarkGraderIdentity;
+    model: AgentCandidateResolvedModel;
+    attempt: Omit<AgentCandidateAttemptPolicy, "number">;
+    evaluatorTaskContainer?: AgentCandidateResolvedTaskContainer;
+    limits: AgentCandidateExecutionLimits;
+}
+/** Content-addressed benchmark task approved and executed without reinterpretation. */
+export interface AgentCandidateBenchmarkTask extends AgentCandidateBenchmarkTaskMaterial {
+    digest: Sha256Digest;
+}
+/** Complete measured denominator shared by evaluation and execution. */
+export interface AgentCandidateBenchmarkSuiteMaterial {
+    kind: "agent-candidate-benchmark-suite";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    taskDigests: [Sha256Digest, ...Sha256Digest[]];
+    reps: number;
+    /** Task-major, then repetition-major: seeds[taskIndex * reps + repetition]. */
+    seeds: [number, ...number[]];
+}
+export interface AgentCandidateBenchmarkSuite extends AgentCandidateBenchmarkSuiteMaterial {
+    digest: Sha256Digest;
+}
+/** Canonical task documents transported alongside their signed suite. */
+export interface AgentCandidateBenchmarkSuiteInputs {
+    suite: AgentCandidateBenchmarkSuite;
+    tasks: [AgentCandidateBenchmarkTask, ...AgentCandidateBenchmarkTask[]];
+}
+/** One cell in a signed suite; task identity and seed are derived by position. */
+export interface AgentCandidateBenchmarkCellRef {
+    suiteDigest: Sha256Digest;
+    taskIndex: number;
+    repetition: number;
+}
+/** Decision rules frozen before either experiment arm executes. */
+export interface AgentCandidateEvaluationPolicy {
+    confidenceLevel: number;
+    resamples: number;
+    bootstrapSeed: number;
+    deltaThreshold: number;
+    minProductiveRuns: number;
+    budgetUsd?: number;
+    criticalDimensions: string[];
+    regressionTolerance: number;
+}
+/** Both complete agent states and the exact held-out work used to compare them. */
+export interface AgentCandidateExperimentMaterial {
+    kind: "agent-candidate-experiment";
+    digestAlgorithm: AgentCandidateDigestAlgorithm;
+    baseline: AgentCandidateBundle;
+    candidate: AgentCandidateBundle;
+    candidateLineage: AgentCandidateLineage;
+    benchmark: AgentCandidateBenchmarkSuiteInputs;
+    policy: AgentCandidateEvaluationPolicy;
+}
+export interface AgentCandidateExperiment extends AgentCandidateExperimentMaterial {
+    digest: Sha256Digest;
+}
+/** Digest-free identity of one exact attempt in a frozen experiment. */
+export interface AgentCandidateRunCellMaterial extends AgentCandidateBenchmarkCellRef {
+    kind: "agent-candidate-run-cell";
+    experimentDigest: Sha256Digest;
+    arm: "baseline" | "candidate";
+    bundleDigest: Sha256Digest;
+    taskDigest: Sha256Digest;
+    seed: number;
+    attempt: number;
+}
+/** One immutable experiment attempt used by plans, receipts, traces, and results. */
+export interface AgentCandidateRunCell extends AgentCandidateRunCellMaterial {
+    digest: Sha256Digest;
+}
 /**
  * Canonical, digest-free per-task execution identity document.
  *
@@ -402,26 +486,9 @@ export type AgentCandidateTaskOutcomeSpec = {
  * its raw SHA-256 is the execution-plan digest.
  */
 export interface AgentCandidateExecutionPlanMaterial {
-    schemaVersion: 2;
     kind: "agent-candidate-execution-plan-material";
-    bundleDigest: Sha256Digest;
+    runCell: AgentCandidateRunCell;
     executionId: string;
-    attempt: AgentCandidateAttemptPolicy;
-    task: {
-        benchmark: string;
-        benchmarkVersion: string;
-        taskId: string;
-        splitDigest: Sha256Digest;
-        instruction: {
-            encoding: "utf8";
-            sha256: Sha256Digest;
-            byteLength: number;
-            delivery: AgentCandidateInstructionDelivery;
-        };
-        repository?: AgentCandidateTaskRepository;
-        outcome: AgentCandidateTaskOutcomeSpec;
-        workspace: AgentCandidateWorkspaceSnapshotEvidence;
-    };
     workspaces: {
         taskRoot: string;
         candidateRoot?: string;
@@ -431,6 +498,8 @@ export interface AgentCandidateExecutionPlanMaterial {
     profile: AgentCandidateProfileApplication;
     harness: HarnessType;
     harnessVersion: string;
+    instructionDelivery: AgentCandidateInstructionDelivery;
+    limits: AgentCandidateExecutionLimits;
     container: {
         source: AgentCandidateExecutionEnvironment["kind"];
         image: string;
@@ -462,12 +531,6 @@ export interface AgentCandidateExecutionPlanMaterial {
             requested: string;
         }>;
     };
-    /** Exact evaluator grader implementation admitted for this plan. */
-    grader: {
-        name: string;
-        version: string;
-        artifact: AgentCandidateArtifactRef;
-    };
     launch: {
         executable: string;
         args: AgentCandidateConfigValue[];
@@ -476,13 +539,11 @@ export interface AgentCandidateExecutionPlanMaterial {
     };
     knowledgeManifestDigest?: Sha256Digest;
     memory: AgentCandidateEffectiveMemory;
-    limits: AgentCandidateExecutionLimits;
     network: {
         mode: "disabled";
     };
 }
 export interface AgentCandidateProfilePlanEvidence {
-    schemaVersion: 1;
     kind: "agent-profile-workspace-plan";
     digest: Sha256Digest;
     material: AgentCandidateProfilePlanMaterial;
@@ -490,7 +551,6 @@ export interface AgentCandidateProfilePlanEvidence {
 }
 /** Exact native profile files and the canonical plan that activated them. */
 export interface AgentCandidateProfileActivation {
-    schemaVersion: 1;
     kind: "agent-candidate-profile-activation";
     profilePlan: AgentCandidateProfilePlanEvidence;
     files: Array<{
@@ -501,14 +561,23 @@ export interface AgentCandidateProfileActivation {
     digest: Sha256Digest;
 }
 export interface AgentCandidateExecutionPlanEvidence {
-    schemaVersion: 2;
     kind: "agent-candidate-execution-plan";
     digest: Sha256Digest;
     material: AgentCandidateExecutionPlanMaterial;
     artifact: AgentCandidateCapturedArtifact;
 }
+/** Exact suite and task material selected for one execution plan. */
+export interface AgentCandidateBenchmarkInputEvidence {
+    suite: {
+        digest: Sha256Digest;
+        material: AgentCandidateCapturedArtifact;
+    };
+    task: {
+        digest: Sha256Digest;
+        material: AgentCandidateCapturedArtifact;
+    };
+}
 export interface AgentCandidateTraceEvidence {
-    schemaVersion: 1;
     artifact: AgentCandidateCapturedArtifact;
     eventCount: number;
     modelCallCount: number;
@@ -525,11 +594,11 @@ export type AgentCandidateMemoryReceipt = {
 };
 /** Proof emitted after a runtime materializes, but before it executes, a bundle. */
 export interface AgentCandidateMaterializationReceipt {
-    schemaVersion: 2;
     kind: "agent-candidate-materialization";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     bundleDigest: Sha256Digest;
-    profilePlan: AgentCandidateProfilePlanEvidence;
+    benchmark: AgentCandidateBenchmarkInputEvidence;
+    profileActivation: AgentCandidateProfileActivation;
     executionPlan: AgentCandidateExecutionPlanEvidence;
     candidateWorkspace?: AgentCandidateWorkspaceSnapshotEvidence;
     codeKind: AgentCandidateCode["kind"];
@@ -563,12 +632,17 @@ export type AgentCandidateTermination = {
 };
 /** Proof emitted after the exact materialized plan finishes executing. */
 export interface AgentCandidateRunReceipt {
-    schemaVersion: 3;
     kind: "agent-candidate-run";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     bundleDigest: Sha256Digest;
+    runCellDigest: Sha256Digest;
     materializationReceiptDigest: Sha256Digest;
     executionPlanDigest: Sha256Digest;
+    timing: {
+        startedAtMs: number;
+        endedAtMs: number;
+        durationMs: number;
+    };
     memory: AgentCandidateMemoryReceipt;
     trace: AgentCandidateTraceEvidence;
     termination: AgentCandidateTermination;
@@ -579,17 +653,16 @@ export interface AgentCandidateRunReceipt {
     digest: Sha256Digest;
 }
 export type AgentImprovementSurface = "prompt" | "skills" | "tools" | "mcp" | "hooks" | "subagents" | "agent-profile" | "memory" | "code" | "knowledge";
+/** One paired Runtime execution from the exact signed experiment. */
+export interface AgentCandidateExperimentMeasurement {
+    baseline: CandidateExecutionEvidence;
+    candidate: CandidateExecutionEvidence;
+}
 /** Portable paired held-out comparison produced by an evaluation package. */
 export interface AgentImprovementMeasuredComparison {
-    schemaVersion: 1;
     kind: "agent-improvement-measured-comparison";
-    benchmark: {
-        name: string;
-        version: string;
-        splitDigest: Sha256Digest;
-    };
-    baselineProfileDigest: Sha256Digest;
-    candidateBundleDigest: Sha256Digest;
+    experiment: AgentCandidateExperiment;
+    measurements: AgentCandidateExperimentMeasurement[];
     overall: {
         name: "composite";
         baseline: number;
@@ -678,7 +751,11 @@ export interface AgentImprovementMeasuredComparison {
     diff: string;
     evaluation: {
         generationsExplored: number;
+        searchDurationMs: number;
+        executionDurationMs: number;
         durationMs: number;
+        searchCostUsd: number;
+        executionCostUsd: number;
         totalCostUsd: number;
     };
     metadata?: {
@@ -686,26 +763,21 @@ export interface AgentImprovementMeasuredComparison {
     };
 }
 export interface AgentImprovementProposal {
-    schemaVersion: 1;
     kind: "agent-improvement-proposal";
     runId: string;
     changedSurfaces: [AgentImprovementSurface, ...AgentImprovementSurface[]];
     proposedAt: string;
-    baselineProfile: AgentProfile;
     findings: {
         [key: string]: AgentCandidateJsonValue;
     }[];
     evaluation: AgentImprovementMeasuredComparison;
-    candidateBundle: AgentCandidateBundle;
     digest: Sha256Digest;
 }
 export type AgentImprovementReviewDecision = "approve" | "reject" | "request-changes";
 /** Human or tenant-policy decision bound to one exact proposal. */
 export interface AgentImprovementReview {
-    schemaVersion: 1;
     kind: "agent-improvement-review";
     proposalDigest: Sha256Digest;
-    candidateBundleDigest: Sha256Digest;
     decision: AgentImprovementReviewDecision;
     reviewedBy: string;
     reviewedAt: string;
@@ -713,16 +785,30 @@ export interface AgentImprovementReview {
     feedback?: string;
     digest: Sha256Digest;
 }
-/** Successful post-approval execution, carrying the exact Runtime receipt. */
-export interface CandidateExecutionEvidence {
-    schemaVersion: 1;
-    kind: "agent-candidate-execution-evidence";
+export interface AgentImprovementActivationTarget {
+    surface: AgentImprovementSurface;
+    /** Product-owned stable identity, such as an agent profile, repository, or knowledge base. */
+    identity: string;
+    /** Current target state that activation is allowed to replace. */
+    expectedBaseDigest: Sha256Digest;
+}
+/** Authority receipt permitting activation of one already-measured candidate. */
+export interface AgentImprovementActivation {
+    kind: "agent-improvement-activation";
     proposalDigest: Sha256Digest;
     reviewDigest: Sha256Digest;
-    executionId: string;
-    succeeded: true;
+    experimentDigest: Sha256Digest;
+    candidateBundleDigest: Sha256Digest;
+    targets: [AgentImprovementActivationTarget, ...AgentImprovementActivationTarget[]];
+    fundingOwner: string;
+    authorizedBy: string;
+    authorizedAt: string;
+    digest: Sha256Digest;
+}
+/** Complete execution of one exact experiment attempt. */
+export interface CandidateExecutionEvidence {
+    kind: "agent-candidate-execution-evidence";
     materializationReceipt: AgentCandidateMaterializationReceipt;
-    profileActivation: AgentCandidateProfileActivation;
     receipt: AgentCandidateRunReceipt;
     digest: Sha256Digest;
 }
@@ -743,7 +829,6 @@ export interface AgentCandidateModelSettlementCall {
 }
 /** Canonical model-access ledger after the evaluator has revoked access. */
 export interface AgentCandidateModelSettlementMaterial {
-    schemaVersion: 2;
     kind: "agent-candidate-model-settlement-material";
     executionPlanDigest: Sha256Digest;
     preparationId: string;
@@ -754,7 +839,6 @@ export interface AgentCandidateModelSettlementMaterial {
     usage: AgentCandidateFixedSpend;
 }
 export interface AgentCandidateModelSettlementEvidence {
-    schemaVersion: 2;
     kind: "agent-candidate-model-settlement";
     digest: Sha256Digest;
     material: AgentCandidateModelSettlementMaterial;
@@ -769,7 +853,6 @@ export interface AgentCandidateRepositoryState {
 }
 /** Canonical result captured by the evaluator after one candidate task. */
 export interface AgentCandidateTaskOutcomeMaterial {
-    schemaVersion: 2;
     kind: "agent-candidate-task-outcome-material";
     executionPlanDigest: Sha256Digest;
     outcome: {
@@ -788,7 +871,6 @@ export interface AgentCandidateTaskOutcomeMaterial {
     };
 }
 export interface AgentCandidateTaskOutcomeEvidence {
-    schemaVersion: 2;
     kind: "agent-candidate-task-outcome";
     digest: Sha256Digest;
     material: AgentCandidateTaskOutcomeMaterial;
@@ -800,29 +882,26 @@ export interface AgentCandidateBenchmarkDimension {
 }
 /** Canonical executable-grade result for one task outcome. */
 export interface AgentCandidateBenchmarkResultMaterial {
-    schemaVersion: 1;
     kind: "agent-candidate-benchmark-result-material";
     executionPlanDigest: Sha256Digest;
     taskOutcomeDigest: Sha256Digest;
-    benchmark: {
-        name: string;
-        version: string;
-        taskId: string;
-        splitDigest: Sha256Digest;
-    };
-    grader: {
-        name: string;
-        version: string;
-        artifact: AgentCandidateArtifactRef;
-    };
+    grader: AgentCandidateBenchmarkGraderIdentity;
     /** Raw grader output required to independently audit the reported verdict. */
     evidence: AgentCandidateArtifactRef;
+    /** Evaluator-owned model usage and elapsed time, separate from candidate usage. */
+    grading: {
+        usage: AgentCandidateFixedSpend;
+        timing: {
+            startedAtMs: number;
+            endedAtMs: number;
+            durationMs: number;
+        };
+    };
     score: number;
     passed: boolean;
     dimensions: AgentCandidateBenchmarkDimension[];
 }
 export interface AgentCandidateBenchmarkResultEvidence {
-    schemaVersion: 1;
     kind: "agent-candidate-benchmark-result";
     digest: Sha256Digest;
     material: AgentCandidateBenchmarkResultMaterial;