@tangle-network/agent-interface 0.25.0 → 0.26.1

package/dist/agent-candidate.d.ts

@@ -4,6 +4,10 @@ import type { HarnessType } from "./harness.js";
 export type Sha256Digest = `sha256:${string}`;
 /** RFC 8785 JSON Canonicalization Scheme followed by SHA-256. */
 export type AgentCandidateDigestAlgorithm = "rfc8785-sha256";
+/** Finite, acyclic JSON accepted by canonical candidate documents. */
+export type AgentCandidateJsonValue = null | boolean | number | string | AgentCandidateJsonValue[] | {
+    [key: string]: AgentCandidateJsonValue;
+};
 export interface AgentCandidateS3Locator {
     kind: "s3";
     bucket: string;
@@ -195,10 +199,23 @@ export interface AgentCandidateExecution {
         candidateSecrets: "disabled";
     };
 }
-/** Optional immutable knowledge snapshot mounted with the profile. */
+/** Exact frozen knowledge candidate admitted only through an approved review. */
+export interface AgentCandidateKnowledgeRef {
+    schemaVersion: 1;
+    kind: "knowledge-improvement-candidate";
+    runId: string;
+    candidateId: string;
+    goalHash: Sha256Digest;
+    baseHash: Sha256Digest;
+    candidateHash: Sha256Digest;
+    evidenceHash: Sha256Digest;
+    promotionPlanHash: Sha256Digest;
+}
 export interface AgentCandidateKnowledge {
-    snapshotId: string;
-    manifest: AgentCandidateArtifactRef;
+    candidate: AgentCandidateKnowledgeRef;
+    snapshot: AgentCandidateWorkspaceSnapshotEvidence;
+    retrievalConfig?: AgentCandidateCapturedArtifact;
+    evaluation: AgentCandidateCapturedArtifact;
 }
 /** Memory is absent or freshly evaluator-scoped to exactly one task. */
 export type AgentCandidateMemoryPolicy = {
@@ -251,8 +268,8 @@ export interface AgentCandidateLineage {
  * runtime integrity verifier before materialization; the carried digest and all
  * artifact hashes are untrusted until recomputed.
  */
-export interface AgentCandidateBundleV1 {
-    schemaVersion: 1;
+export interface AgentCandidateBundle {
+    schemaVersion: 2;
     kind: "agent-candidate-bundle";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     profile: AgentCandidateProfile;
@@ -263,7 +280,6 @@ export interface AgentCandidateBundleV1 {
     lineage: AgentCandidateLineage;
     digest: Sha256Digest;
 }
-export type AgentCandidateBundle = AgentCandidateBundleV1;
 export interface AgentCandidateEntrypointReceipt {
     path: string;
     sha256: Sha256Digest;
@@ -282,7 +298,7 @@ export interface AgentCandidateResolvedModel {
     reasoningEffort: ReasoningEffort;
 }
 /** Canonical, digest-free profile-plan identity document. */
-export interface AgentCandidateProfilePlanMaterialV1 {
+export interface AgentCandidateProfilePlanMaterial {
     version: 1;
     harness: HarnessType;
     files: Array<{
@@ -297,22 +313,23 @@ export interface AgentCandidateProfilePlanMaterialV1 {
         reason: string;
     }>;
 }
-export interface AgentCandidateWorkspaceManifestMaterialV1 {
-    schemaVersion: 1;
+export interface AgentCandidateWorkspaceManifestMaterial {
+    schemaVersion: 2;
     kind: "agent-candidate-workspace-manifest";
     files: Array<{
         path: string;
-        mode: 0o644 | 0o755;
+        /** Exact regular-file permission bits, excluding file-type and special bits. */
+        mode: number;
         sha256: Sha256Digest;
         byteLength: number;
     }>;
 }
 /** Content-addressed manifest of every file uploaded to one workspace. */
 export interface AgentCandidateWorkspaceSnapshotEvidence {
-    schemaVersion: 1;
+    schemaVersion: 2;
     kind: "agent-candidate-workspace-snapshot";
     digest: Sha256Digest;
-    material: AgentCandidateWorkspaceManifestMaterialV1;
+    material: AgentCandidateWorkspaceManifestMaterial;
     manifest: AgentCandidateCapturedArtifact;
     archive: AgentCandidateCapturedArtifact;
 }
@@ -359,14 +376,33 @@ export type AgentCandidateModelAccessNetwork = {
     mode: "gateway-only";
     domains: string[];
 };
+/** Optional source repository identity for a signed benchmark task. */
+export interface AgentCandidateTaskRepository {
+    identity: string;
+    rootIdentity: string;
+    baseCommit: string;
+    baseTree: string;
+}
+/** Bounded media contract for one exact non-workspace task result. */
+export interface AgentCandidateTaskOutputSpec {
+    /** Evaluator-declared label; the bound grader verifies the bytes match it. */
+    mediaType: string;
+    maxBytes: number;
+}
+/** Exact result shape the evaluator must capture after one candidate task. */
+export type AgentCandidateTaskOutcomeSpec = {
+    kind: "workspace";
+} | ({
+    kind: "output";
+} & AgentCandidateTaskOutputSpec);
 /**
  * Canonical, digest-free per-task execution identity document.
  *
  * RFC 8785 serialization of this material is stored verbatim by the receipt;
  * its raw SHA-256 is the execution-plan digest.
  */
-export interface AgentCandidateExecutionPlanMaterialV1 {
-    schemaVersion: 1;
+export interface AgentCandidateExecutionPlanMaterial {
+    schemaVersion: 2;
     kind: "agent-candidate-execution-plan-material";
     bundleDigest: Sha256Digest;
     executionId: string;
@@ -382,12 +418,8 @@ export interface AgentCandidateExecutionPlanMaterialV1 {
             byteLength: number;
             delivery: AgentCandidateInstructionDelivery;
         };
-        repository: {
-            identity: string;
-            rootIdentity: string;
-            baseCommit: string;
-            baseTree: string;
-        };
+        repository?: AgentCandidateTaskRepository;
+        outcome: AgentCandidateTaskOutcomeSpec;
         workspace: AgentCandidateWorkspaceSnapshotEvidence;
     };
     workspaces: {
@@ -453,14 +485,26 @@ export interface AgentCandidateProfilePlanEvidence {
     schemaVersion: 1;
     kind: "agent-profile-workspace-plan";
     digest: Sha256Digest;
-    material: AgentCandidateProfilePlanMaterialV1;
+    material: AgentCandidateProfilePlanMaterial;
     artifact: AgentCandidateCapturedArtifact;
 }
-export interface AgentCandidateExecutionPlanEvidence {
+/** 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<{
+        path: string;
+        mode: number;
+        content: string;
+    }>;
+    digest: Sha256Digest;
+}
+export interface AgentCandidateExecutionPlanEvidence {
+    schemaVersion: 2;
     kind: "agent-candidate-execution-plan";
     digest: Sha256Digest;
-    material: AgentCandidateExecutionPlanMaterialV1;
+    material: AgentCandidateExecutionPlanMaterial;
     artifact: AgentCandidateCapturedArtifact;
 }
 export interface AgentCandidateTraceEvidence {
@@ -469,10 +513,6 @@ export interface AgentCandidateTraceEvidence {
     eventCount: number;
     modelCallCount: number;
 }
-export interface AgentCandidateModelUsage {
-    resolved: AgentCandidateResolvedModel;
-    usage: AgentCandidateSpend;
-}
 export type AgentCandidateMemoryReceipt = {
     mode: "disabled";
 } | {
@@ -484,8 +524,8 @@ export type AgentCandidateMemoryReceipt = {
     afterState: AgentCandidateWorkspaceSnapshotEvidence;
 };
 /** Proof emitted after a runtime materializes, but before it executes, a bundle. */
-export interface AgentCandidateMaterializationReceiptV1 {
-    schemaVersion: 1;
+export interface AgentCandidateMaterializationReceipt {
+    schemaVersion: 2;
     kind: "agent-candidate-materialization";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     bundleDigest: Sha256Digest;
@@ -508,7 +548,6 @@ export interface AgentCandidateMaterializationReceiptV1 {
     entrypoint?: AgentCandidateEntrypointReceipt;
     digest: Sha256Digest;
 }
-export type AgentCandidateMaterializationReceipt = AgentCandidateMaterializationReceiptV1;
 /** How an execution ended, independent of whether protected evidence capture completed. */
 export type AgentCandidateTermination = {
     kind: "exit";
@@ -523,52 +562,187 @@ export type AgentCandidateTermination = {
     kind: "cancelled";
 };
 /** Proof emitted after the exact materialized plan finishes executing. */
-export interface AgentCandidateRunReceiptV1 {
-    schemaVersion: 1;
+export interface AgentCandidateRunReceipt {
+    schemaVersion: 3;
     kind: "agent-candidate-run";
     digestAlgorithm: AgentCandidateDigestAlgorithm;
     bundleDigest: Sha256Digest;
     materializationReceiptDigest: Sha256Digest;
     executionPlanDigest: Sha256Digest;
     memory: AgentCandidateMemoryReceipt;
-    usage: AgentCandidateSpend;
-    modelUsage: AgentCandidateModelUsage;
     trace: AgentCandidateTraceEvidence;
     termination: AgentCandidateTermination;
+    executorCapture: AgentCandidateArtifactRef;
+    modelSettlement: AgentCandidateModelSettlementEvidence;
+    taskOutcome: AgentCandidateTaskOutcomeEvidence;
+    benchmarkResult: AgentCandidateBenchmarkResultEvidence;
+    digest: Sha256Digest;
+}
+export type AgentImprovementSurface = "prompt" | "skills" | "tools" | "mcp" | "hooks" | "subagents" | "agent-profile" | "memory" | "code" | "knowledge";
+/** 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;
+    overall: {
+        name: "composite";
+        baseline: number;
+        candidate: number;
+        delta: number;
+        confidenceInterval: {
+            level: number;
+            lower: number;
+            upper: number;
+            method: "paired-bootstrap";
+            statistic: "mean";
+            resamples: number;
+        };
+        n: number;
+        direction: "higher-is-better";
+        unit: "score";
+    };
+    objectives: Array<({
+        kind: "objective";
+        name: string;
+        direction: "higher-is-better";
+        unit: "score";
+    } | {
+        kind: "dimension";
+        objective: string;
+        name: string;
+        direction: "higher-is-better";
+        unit: "score";
+    } | {
+        kind: "cost";
+        name: "cost";
+        direction: "lower-is-better";
+        unit: "usd";
+    } | {
+        kind: "latency";
+        name: "latency";
+        direction: "lower-is-better";
+        unit: "milliseconds";
+    }) & ({
+        availability: "measured";
+        baseline: number;
+        candidate: number;
+        delta: number;
+        confidenceInterval: {
+            level: number;
+            lower: number;
+            upper: number;
+            method: "paired-bootstrap";
+            statistic: "mean";
+            resamples: number;
+        };
+        n: number;
+    } | {
+        availability: "unavailable";
+        reason: string;
+    })>;
+    candidate?: {
+        label?: string;
+        rationale?: string;
+    };
+    decision: {
+        outcome: "ship" | "hold" | "need_more_work" | "model_ceiling" | "arch_ceiling";
+        reasons: string[];
+        contributingChecks: Array<{
+            name: string;
+            passed: boolean;
+        }>;
+    };
+    power: {
+        sufficient: boolean;
+        n: number;
+        minimumDetectableDelta: number;
+        confidenceLevel: number;
+        scaleAssumed: boolean;
+        sharedScorerChannel: boolean;
+        reason: string;
+    };
+    provenance: {
+        kind: "agent-eval-loop";
+        schema: string;
+        runId: string;
+        recordDigest: Sha256Digest;
+        baselineContentHash: string;
+        candidateContentHash: string;
+    };
+    diff: string;
+    evaluation: {
+        generationsExplored: number;
+        durationMs: number;
+        totalCostUsd: number;
+    };
+    metadata?: {
+        [key: string]: AgentCandidateJsonValue;
+    };
+}
+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;
+    reason: string;
+    feedback?: string;
+    digest: Sha256Digest;
+}
+/** Successful post-approval execution, carrying the exact Runtime receipt. */
+export interface CandidateExecutionEvidence {
+    schemaVersion: 1;
+    kind: "agent-candidate-execution-evidence";
+    proposalDigest: Sha256Digest;
+    reviewDigest: Sha256Digest;
+    executionId: string;
+    succeeded: true;
+    materializationReceipt: AgentCandidateMaterializationReceipt;
+    profileActivation: AgentCandidateProfileActivation;
+    receipt: AgentCandidateRunReceipt;
     digest: Sha256Digest;
 }
-/** One evaluator-mediated model call in a terminal settlement. */
+/** One router-authored model call in a terminal settlement. */
 export interface AgentCandidateModelSettlementCall {
     callId: string;
+    generationId: string;
     traceSpanId: string;
+    status: "succeeded" | "failed";
     model: string;
+    startedAtMs: number;
+    endedAtMs: number;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens: number;
     reasoningTokens: number;
     costUsdNanos: number;
 }
-/** Router-authored call identity, timing, and terminal status. */
-export interface AgentCandidateModelSettlementCallV2 extends AgentCandidateModelSettlementCall {
-    generationId: string;
-    status: "succeeded" | "failed";
-    startedAtMs: number;
-    endedAtMs: number;
-}
-/** Canonical model-access ledger after the evaluator has revoked the grant. */
-export interface AgentCandidateModelSettlementMaterialV1 {
-    schemaVersion: 1;
-    kind: "agent-candidate-model-settlement-material";
-    executionPlanDigest: Sha256Digest;
-    preparationId: string;
-    grantDigest: Sha256Digest;
-    closed: true;
-    resolved: AgentCandidateResolvedModel;
-    calls: AgentCandidateModelSettlementCall[];
-    usage: AgentCandidateFixedSpend;
-}
-/** Canonical ledger whose LLM spans can be reproduced only from router facts. */
-export interface AgentCandidateModelSettlementMaterialV2 {
+/** Canonical model-access ledger after the evaluator has revoked access. */
+export interface AgentCandidateModelSettlementMaterial {
     schemaVersion: 2;
     kind: "agent-candidate-model-settlement-material";
     executionPlanDigest: Sha256Digest;
@@ -576,12 +750,11 @@ export interface AgentCandidateModelSettlementMaterialV2 {
     grantDigest: Sha256Digest;
     closed: true;
     resolved: AgentCandidateResolvedModel;
-    calls: AgentCandidateModelSettlementCallV2[];
+    calls: AgentCandidateModelSettlementCall[];
     usage: AgentCandidateFixedSpend;
 }
-export type AgentCandidateModelSettlementMaterial = AgentCandidateModelSettlementMaterialV1 | AgentCandidateModelSettlementMaterialV2;
 export interface AgentCandidateModelSettlementEvidence {
-    schemaVersion: 1;
+    schemaVersion: 2;
     kind: "agent-candidate-model-settlement";
     digest: Sha256Digest;
     material: AgentCandidateModelSettlementMaterial;
@@ -594,24 +767,31 @@ export interface AgentCandidateRepositoryState {
     commit: string;
     tree: string;
 }
-/** Canonical repository result produced by the candidate on one task. */
-export interface AgentCandidateTaskOutcomeMaterialV1 {
-    schemaVersion: 1;
+/** Canonical result captured by the evaluator after one candidate task. */
+export interface AgentCandidateTaskOutcomeMaterial {
+    schemaVersion: 2;
     kind: "agent-candidate-task-outcome-material";
     executionPlanDigest: Sha256Digest;
-    baseRepository: AgentCandidateRepositoryState;
-    resultRepository: AgentCandidateRepositoryState;
-    afterState: AgentCandidateWorkspaceSnapshotEvidence;
-    gitDiff: {
-        format: "git-diff-binary";
+    outcome: {
+        kind: "workspace";
+        baseRepository: AgentCandidateRepositoryState;
+        resultRepository: AgentCandidateRepositoryState;
+        afterState: AgentCandidateWorkspaceSnapshotEvidence;
+        gitDiff: {
+            format: "git-diff-binary";
+            artifact: AgentCandidateArtifactRef;
+        };
+    } | {
+        kind: "output";
+        spec: AgentCandidateTaskOutputSpec;
         artifact: AgentCandidateArtifactRef;
     };
 }
 export interface AgentCandidateTaskOutcomeEvidence {
-    schemaVersion: 1;
+    schemaVersion: 2;
     kind: "agent-candidate-task-outcome";
     digest: Sha256Digest;
-    material: AgentCandidateTaskOutcomeMaterialV1;
+    material: AgentCandidateTaskOutcomeMaterial;
     artifact: AgentCandidateCapturedArtifact;
 }
 export interface AgentCandidateBenchmarkDimension {
@@ -619,7 +799,7 @@ export interface AgentCandidateBenchmarkDimension {
     score: number;
 }
 /** Canonical executable-grade result for one task outcome. */
-export interface AgentCandidateBenchmarkResultMaterialV1 {
+export interface AgentCandidateBenchmarkResultMaterial {
     schemaVersion: 1;
     kind: "agent-candidate-benchmark-result-material";
     executionPlanDigest: Sha256Digest;
@@ -645,24 +825,8 @@ export interface AgentCandidateBenchmarkResultEvidence {
     schemaVersion: 1;
     kind: "agent-candidate-benchmark-result";
     digest: Sha256Digest;
-    material: AgentCandidateBenchmarkResultMaterialV1;
+    material: AgentCandidateBenchmarkResultMaterial;
     artifact: AgentCandidateCapturedArtifact;
 }
-/**
- * Terminal candidate receipt with lossless spend, exact repository output,
- * and executable benchmark evidence. V1 fields remain present for consumers
- * that have not yet adopted the stronger evidence surfaces.
- */
-export interface AgentCandidateRunReceiptV2 extends Omit<AgentCandidateRunReceiptV1, "schemaVersion"> {
-    schemaVersion: 2;
-    fixedUsage: AgentCandidateFixedSpend;
-    modelSettlement: AgentCandidateModelSettlementEvidence;
-    taskOutcome: AgentCandidateTaskOutcomeEvidence;
-    benchmarkResult: AgentCandidateBenchmarkResultEvidence;
-}
-/** Backward-compatible V1 receipt name. */
-export type AgentCandidateRunReceipt = AgentCandidateRunReceiptV1;
-/** Explicit parser target for consumers that accept both receipt generations. */
-export type AgentCandidateRunReceiptAnyVersion = AgentCandidateRunReceiptV1 | AgentCandidateRunReceiptV2;
 /** Declare a candidate bundle while retaining literal inference. */
 export declare function defineAgentCandidateBundle<T extends AgentCandidateBundle>(bundle: T): T;

package/dist/agent-candidate.test-fixture.d.ts

@@ -1,7 +1,7 @@
 export declare const candidateSha: (digit: string) => `sha256:${string}`;
 export declare const candidateGit: (digit: string) => string;
 export declare function candidateFixture(): {
-    schemaVersion: 1;
+    schemaVersion: 2;
     kind: "agent-candidate-bundle";
     digestAlgorithm: "rfc8785-sha256";
     profile: {
@@ -81,15 +81,15 @@ export declare function candidateFixture(): {
             };
         };
         workspace: {
-            schemaVersion: 1;
+            schemaVersion: 2;
             kind: "agent-candidate-workspace-snapshot";
             digest: `sha256:${string}`;
             material: {
-                schemaVersion: 1;
+                schemaVersion: 2;
                 kind: "agent-candidate-workspace-manifest";
                 files: {
                     path: string;
-                    mode: 493;
+                    mode: number;
                     sha256: `sha256:${string}`;
                     byteLength: number;
                 }[];
@@ -114,14 +114,48 @@ export declare function candidateFixture(): {
         };
     };
     knowledge: {
-        snapshotId: string;
-        manifest: {
-            locator: {
-                kind: "s3";
-                bucket: string;
-                key: string;
-                region: string;
+        candidate: {
+            schemaVersion: 1;
+            kind: "knowledge-improvement-candidate";
+            runId: string;
+            candidateId: string;
+            goalHash: `sha256:${string}`;
+            baseHash: `sha256:${string}`;
+            candidateHash: `sha256:${string}`;
+            evidenceHash: `sha256:${string}`;
+            promotionPlanHash: `sha256:${string}`;
+        };
+        snapshot: {
+            schemaVersion: 2;
+            kind: "agent-candidate-workspace-snapshot";
+            digest: `sha256:${string}`;
+            material: {
+                schemaVersion: 2;
+                kind: "agent-candidate-workspace-manifest";
+                files: never[];
             };
+            manifest: {
+                encoding: "base64";
+                content: string;
+                sha256: `sha256:${string}`;
+                byteLength: number;
+            };
+            archive: {
+                encoding: "base64";
+                content: string;
+                sha256: `sha256:${string}`;
+                byteLength: number;
+            };
+        };
+        retrievalConfig: {
+            encoding: "base64";
+            content: string;
+            sha256: `sha256:${string}`;
+            byteLength: number;
+        };
+        evaluation: {
+            encoding: "base64";
+            content: string;
             sha256: `sha256:${string}`;
             byteLength: number;
         };

package/dist/agent-candidate.test-fixture.js

@@ -3,7 +3,7 @@ export const candidateSha = (digit) => `sha256:${digit.repeat(64)}`;
 export const candidateGit = (digit) => digit.repeat(40);
 export function candidateFixture() {
     return defineAgentCandidateBundle({
-        schemaVersion: 1,
+        schemaVersion: 2,
         kind: "agent-candidate-bundle",
         digestAlgorithm: "rfc8785-sha256",
         profile: {
@@ -69,11 +69,11 @@ export function candidateFixture() {
                 container: { image: "node:22", indexDigest: candidateSha("6") },
             },
             workspace: {
-                schemaVersion: 1,
+                schemaVersion: 2,
                 kind: "agent-candidate-workspace-snapshot",
                 digest: candidateSha("c"),
                 material: {
-                    schemaVersion: 1,
+                    schemaVersion: 2,
                     kind: "agent-candidate-workspace-manifest",
                     files: [
                         {
@@ -104,16 +104,50 @@ export function candidateFixture() {
             },
         },
         knowledge: {
-            snapshotId: "knowledge-17",
-            manifest: {
-                locator: {
-                    kind: "s3",
-                    bucket: "agent-candidate-artifacts",
-                    key: "knowledge/knowledge-17.json",
-                    region: "us-east-1",
+            candidate: {
+                schemaVersion: 1,
+                kind: "knowledge-improvement-candidate",
+                runId: "knowledge-run-17",
+                candidateId: "knowledge-17",
+                goalHash: candidateSha("5"),
+                baseHash: candidateSha("6"),
+                candidateHash: candidateSha("7"),
+                evidenceHash: candidateSha("8"),
+                promotionPlanHash: candidateSha("9"),
+            },
+            snapshot: {
+                schemaVersion: 2,
+                kind: "agent-candidate-workspace-snapshot",
+                digest: candidateSha("7"),
+                material: {
+                    schemaVersion: 2,
+                    kind: "agent-candidate-workspace-manifest",
+                    files: [],
+                },
+                manifest: {
+                    encoding: "base64",
+                    content: "e30=",
+                    sha256: candidateSha("7"),
+                    byteLength: 2,
                 },
-                sha256: candidateSha("7"),
-                byteLength: 42,
+                archive: {
+                    encoding: "base64",
+                    content: "e30=",
+                    sha256: candidateSha("8"),
+                    byteLength: 2,
+                },
+            },
+            retrievalConfig: {
+                encoding: "base64",
+                content: "e30=",
+                sha256: candidateSha("9"),
+                byteLength: 2,
+            },
+            evaluation: {
+                encoding: "base64",
+                content: "e30=",
+                sha256: candidateSha("a"),
+                byteLength: 2,
             },
         },
         memory: {