@dailephd/my-dev-kit-lab 0.4.3 → 0.4.5

package/dist/src/evaluation/upstreamArtifacts/validateMyDevKitContextCapsuleV1.js

@@ -909,7 +909,7 @@ function validateTestInfrastructureSummary(ctx, value, fieldPath) {
 }
 function validateGroupTruncationEntry(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
-    return {
+    const result = {
         groupId: requiredString(ctx, requiredField(ctx, obj, "groupId", joinFieldPath(fieldPath, "groupId")), joinFieldPath(fieldPath, "groupId")),
         limit: requiredNullableNumber(ctx, requiredField(ctx, obj, "limit", joinFieldPath(fieldPath, "limit")), joinFieldPath(fieldPath, "limit")),
         availableCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "availableCount", joinFieldPath(fieldPath, "availableCount")), joinFieldPath(fieldPath, "availableCount")),
@@ -917,6 +917,54 @@ function validateGroupTruncationEntry(ctx, value, fieldPath) {
         truncated: requiredBoolean(ctx, requiredField(ctx, obj, "truncated", joinFieldPath(fieldPath, "truncated")), joinFieldPath(fieldPath, "truncated")),
         droppedCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "droppedCount", joinFieldPath(fieldPath, "droppedCount")), joinFieldPath(fieldPath, "droppedCount"))
     };
+    if (optionalField(obj, "droppedEvidenceIds") !== undefined) {
+        result.droppedEvidenceIds = requiredStringArray(ctx, obj.droppedEvidenceIds, joinFieldPath(fieldPath, "droppedEvidenceIds"));
+    }
+    if (optionalField(obj, "required") !== undefined)
+        result.required = optionalBoolean(ctx, obj.required, joinFieldPath(fieldPath, "required"));
+    if (optionalField(obj, "reservation") !== undefined)
+        result.reservation = optionalNumber(ctx, obj.reservation, joinFieldPath(fieldPath, "reservation"));
+    if (optionalField(obj, "initiallySelectedCount") !== undefined)
+        result.initiallySelectedCount = optionalNumber(ctx, obj.initiallySelectedCount, joinFieldPath(fieldPath, "initiallySelectedCount"));
+    if (optionalField(obj, "unusedReservationContributed") !== undefined)
+        result.unusedReservationContributed = optionalNumber(ctx, obj.unusedReservationContributed, joinFieldPath(fieldPath, "unusedReservationContributed"));
+    if (optionalField(obj, "borrowedCapacity") !== undefined)
+        result.borrowedCapacity = optionalNumber(ctx, obj.borrowedCapacity, joinFieldPath(fieldPath, "borrowedCapacity"));
+    if (optionalField(obj, "requiredOmittedCount") !== undefined)
+        result.requiredOmittedCount = optionalNumber(ctx, obj.requiredOmittedCount, joinFieldPath(fieldPath, "requiredOmittedCount"));
+    if (optionalField(obj, "optionalOmittedCount") !== undefined)
+        result.optionalOmittedCount = optionalNumber(ctx, obj.optionalOmittedCount, joinFieldPath(fieldPath, "optionalOmittedCount"));
+    if (optionalField(obj, "adequacyAffected") !== undefined)
+        result.adequacyAffected = optionalBoolean(ctx, obj.adequacyAffected, joinFieldPath(fieldPath, "adequacyAffected"));
+    if (optionalField(obj, "governingHardBound") !== undefined)
+        result.governingHardBound = optionalNumber(ctx, obj.governingHardBound, joinFieldPath(fieldPath, "governingHardBound"));
+    if (optionalField(obj, "aggregateCapacityUsed") !== undefined)
+        result.aggregateCapacityUsed = optionalNumber(ctx, obj.aggregateCapacityUsed, joinFieldPath(fieldPath, "aggregateCapacityUsed"));
+    if (optionalField(obj, "aggregateCapacityRemaining") !== undefined)
+        result.aggregateCapacityRemaining = optionalNumber(ctx, obj.aggregateCapacityRemaining, joinFieldPath(fieldPath, "aggregateCapacityRemaining"));
+    return result;
+}
+const ROLE_CONDITION_IDS = ["implementation.selected-owner", "implementation.required-contract"];
+const ROLE_CONDITION_WITNESS_POLICIES = ["at-least-one"];
+const ROLE_CONDITION_COVERAGE_LOSS_REASONS = ["bounded-allocation-omitted-required-witnesses"];
+const ROLE_CONDITION_ROLES = ["architecture", "implementation", "test-implementation"];
+export function validateRoleConditionCoverage(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        conditionId: requiredLiteral(ctx, requiredField(ctx, obj, "conditionId", joinFieldPath(fieldPath, "conditionId")), joinFieldPath(fieldPath, "conditionId"), ROLE_CONDITION_IDS),
+        role: requiredLiteral(ctx, requiredField(ctx, obj, "role", joinFieldPath(fieldPath, "role")), joinFieldPath(fieldPath, "role"), ROLE_CONDITION_ROLES),
+        required: requiredBoolean(ctx, requiredField(ctx, obj, "required", joinFieldPath(fieldPath, "required")), joinFieldPath(fieldPath, "required")),
+        evidenceGroupIds: requiredStringArray(ctx, requiredField(ctx, obj, "evidenceGroupIds", joinFieldPath(fieldPath, "evidenceGroupIds")), joinFieldPath(fieldPath, "evidenceGroupIds")),
+        witnessPolicy: requiredLiteral(ctx, requiredField(ctx, obj, "witnessPolicy", joinFieldPath(fieldPath, "witnessPolicy")), joinFieldPath(fieldPath, "witnessPolicy"), ROLE_CONDITION_WITNESS_POLICIES),
+        requiredWitnessCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "requiredWitnessCount", joinFieldPath(fieldPath, "requiredWitnessCount")), joinFieldPath(fieldPath, "requiredWitnessCount")),
+        availableWitnessCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "availableWitnessCount", joinFieldPath(fieldPath, "availableWitnessCount")), joinFieldPath(fieldPath, "availableWitnessCount")),
+        retainedWitnessCount: requiredNonnegativeInteger(ctx, requiredField(ctx, obj, "retainedWitnessCount", joinFieldPath(fieldPath, "retainedWitnessCount")), joinFieldPath(fieldPath, "retainedWitnessCount")),
+        retainedWitnessIds: requiredStringArray(ctx, requiredField(ctx, obj, "retainedWitnessIds", joinFieldPath(fieldPath, "retainedWitnessIds")), joinFieldPath(fieldPath, "retainedWitnessIds")),
+        conditionSatisfied: requiredBoolean(ctx, requiredField(ctx, obj, "conditionSatisfied", joinFieldPath(fieldPath, "conditionSatisfied")), joinFieldPath(fieldPath, "conditionSatisfied")),
+        lostRequiredCondition: requiredBoolean(ctx, requiredField(ctx, obj, "lostRequiredCondition", joinFieldPath(fieldPath, "lostRequiredCondition")), joinFieldPath(fieldPath, "lostRequiredCondition")),
+        lossReason: requiredNullableLiteral(ctx, requiredField(ctx, obj, "lossReason", joinFieldPath(fieldPath, "lossReason")), joinFieldPath(fieldPath, "lossReason"), ROLE_CONDITION_COVERAGE_LOSS_REASONS),
+        evaluationOrder: requiredNumber(ctx, requiredField(ctx, obj, "evaluationOrder", joinFieldPath(fieldPath, "evaluationOrder")), joinFieldPath(fieldPath, "evaluationOrder"))
+    };
 }
 export function validateProvenanceRecord(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
@@ -1040,11 +1088,15 @@ function validateCapsuleTruncationRecord(ctx, value, fieldPath) {
 }
 export function validateTruncationSummary(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
-    return {
+    const result = {
         truncated: requiredBoolean(ctx, requiredField(ctx, obj, "truncated", joinFieldPath(fieldPath, "truncated")), joinFieldPath(fieldPath, "truncated")),
         records: requiredArray(ctx, requiredField(ctx, obj, "records", joinFieldPath(fieldPath, "records")), joinFieldPath(fieldPath, "records")).map((item, i) => validateCapsuleTruncationRecord(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "records"), i))),
         warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings"))
     };
+    if (optionalField(obj, "requiredEvidenceLost") !== undefined) {
+        result.requiredEvidenceLost = optionalBoolean(ctx, obj.requiredEvidenceLost, joinFieldPath(fieldPath, "requiredEvidenceLost"));
+    }
+    return result;
 }
 function validateFullFileFallbackRecord(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
@@ -1178,6 +1230,11 @@ export function validateMyDevKitContextCapsuleV1(value, sourcePath) {
             testInfrastructure: validateTestInfrastructureSummary(ctx, requiredField(ctx, value, "testInfrastructure", "testInfrastructure"), "testInfrastructure"),
             unresolvedItems: requiredArray(ctx, requiredField(ctx, value, "unresolvedItems", "unresolvedItems"), "unresolvedItems").map((item, i) => validateUnresolvedEvidenceItem(ctx, item, arrayFieldPath("unresolvedItems", i))),
             groupTruncation: requiredArray(ctx, requiredField(ctx, value, "groupTruncation", "groupTruncation"), "groupTruncation").map((item, i) => validateGroupTruncationEntry(ctx, item, arrayFieldPath("groupTruncation", i))),
+            ...(optionalField(value, "roleConditionCoverage") !== undefined
+                ? {
+                    roleConditionCoverage: requiredArray(ctx, value.roleConditionCoverage, "roleConditionCoverage").map((item, i) => validateRoleConditionCoverage(ctx, item, arrayFieldPath("roleConditionCoverage", i)))
+                }
+                : {}),
             responsibilityMappings: validateResponsibilityMappingSummary(ctx, requiredField(ctx, value, "responsibilityMappings", "responsibilityMappings"), "responsibilityMappings"),
             roleAdequacy: validateRoleAdequacyStatement(ctx, requiredField(ctx, value, "roleAdequacy", "roleAdequacy"), "roleAdequacy"),
             freshness: validateFreshnessSummary(ctx, requiredField(ctx, value, "freshness", "freshness"), "freshness"),

package/dist/src/evaluation/upstreamArtifacts/validateMyDevKitRetrievalAuditRecordV1.js

@@ -1,6 +1,6 @@
 import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
-import { ArtifactValidationError, arrayFieldPath, joinFieldPath, requiredArray, requiredField, requiredLiteral, requiredObject, requiredRecord, requiredScalarLike, requiredString, requiredStringArray } from "./runtimeValidation.js";
-import { validateBudgetSummary, validateContextAdequacyStatement, validateContextCapsuleRequest, validateFreshnessSummary, validateFullFileFallbackSummary, validateProvenanceRecord, validateResponsibilityMappingSummary, validateRoleAdequacyStatement, validateRoleContextSummary, validateTruncationSummary } from "./validateMyDevKitContextCapsuleV1.js";
+import { ArtifactValidationError, arrayFieldPath, joinFieldPath, optionalField, optionalString, requiredArray, requiredField, requiredLiteral, requiredObject, requiredRecord, requiredScalarLike, requiredString, requiredStringArray } from "./runtimeValidation.js";
+import { validateBudgetSummary, validateContextAdequacyStatement, validateContextCapsuleRequest, validateFreshnessSummary, validateFullFileFallbackSummary, validateProvenanceRecord, validateResponsibilityMappingSummary, validateRoleAdequacyStatement, validateRoleConditionCoverage, validateRoleContextSummary, validateTruncationSummary } from "./validateMyDevKitContextCapsuleV1.js";
 const ARTIFACT_KIND = "my-dev-kit-retrieval-audit-record-v1";
 const AUDIT_STEP_STATUSES = ["ok", "skipped", "failed"];
 function validateContextCapsuleTool(ctx, value, fieldPath) {
@@ -12,10 +12,17 @@ function validateContextCapsuleTool(ctx, value, fieldPath) {
 }
 function validateRetrievalAuditRecordIndex(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
-    return {
+    const result = {
         indexPath: requiredString(ctx, requiredField(ctx, obj, "indexPath", joinFieldPath(fieldPath, "indexPath")), joinFieldPath(fieldPath, "indexPath")),
         manifestPath: requiredString(ctx, requiredField(ctx, obj, "manifestPath", joinFieldPath(fieldPath, "manifestPath")), joinFieldPath(fieldPath, "manifestPath"))
     };
+    if (optionalField(obj, "manifestSchemaVersion") !== undefined) {
+        result.manifestSchemaVersion = optionalString(ctx, obj.manifestSchemaVersion, joinFieldPath(fieldPath, "manifestSchemaVersion"));
+    }
+    if (optionalField(obj, "projectRoot") !== undefined) {
+        result.projectRoot = optionalString(ctx, obj.projectRoot, joinFieldPath(fieldPath, "projectRoot"));
+    }
+    return result;
 }
 function validateAuditStepRecord(ctx, value, fieldPath) {
     const obj = requiredRecord(ctx, value, fieldPath);
@@ -76,6 +83,11 @@ export function validateMyDevKitRetrievalAuditRecordV1(value, sourcePath) {
             contextAdequacy: validateContextAdequacyStatement(ctx, requiredField(ctx, value, "contextAdequacy", "contextAdequacy"), "contextAdequacy"),
             roleContext: validateRoleContextSummary(ctx, requiredField(ctx, value, "roleContext", "roleContext"), "roleContext"),
             responsibilityMappings: validateResponsibilityMappingSummary(ctx, requiredField(ctx, value, "responsibilityMappings", "responsibilityMappings"), "responsibilityMappings"),
+            ...(optionalField(value, "roleConditionCoverage") !== undefined
+                ? {
+                    roleConditionCoverage: requiredArray(ctx, value.roleConditionCoverage, "roleConditionCoverage").map((item, i) => validateRoleConditionCoverage(ctx, item, arrayFieldPath("roleConditionCoverage", i)))
+                }
+                : {}),
             roleAdequacy: validateRoleAdequacyStatement(ctx, requiredField(ctx, value, "roleAdequacy", "roleAdequacy"), "roleAdequacy"),
             freshness: validateFreshnessSummary(ctx, requiredField(ctx, value, "freshness", "freshness"), "freshness"),
             budget: validateBudgetSummary(ctx, requiredField(ctx, value, "budget", "budget"), "budget"),

package/dist/src/evaluation/upstreamArtifacts/validateOrchestratorRunIntegrityV1.js

@@ -0,0 +1,177 @@
+import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
+import { ArtifactValidationError, arrayFieldPath, joinFieldPath, optionalField, optionalString, requiredArray, requiredBoolean, requiredField, requiredLiteral, requiredNullableLiteral, requiredNullableString, requiredObject, requiredString, requiredStringArray } from "./runtimeValidation.js";
+import { validateOrchestratorContextReadinessResultV1 } from "./orchestratorContextReadinessResultV1.js";
+import { ARTIFACT_LIFECYCLE_STATES, CONTEXT_SENSITIVE_STAGE_NAMES, CORRECTABLE_STAGES, JUDGE_VERDICT_PARSE_STATUSES, JUDGE_VERDICTS, MANUAL_ARTIFACT_LIFECYCLE_STATES, ROUTE_STATUSES, RUN_INTEGRITY_READINESS_CLASSIFICATIONS } from "./orchestratorRunIntegrityV1.js";
+const ARTIFACT_KIND = "orchestrator-run-integrity-evidence-v1";
+const EXPECTED_JUDGE_VERDICTS = ["PASS", "NEED_CONTEXT"];
+const APPLICABLE_CONTEXT_KINDS = ["implementation", "test"];
+function validateContextReadinessNested(ctx, value, fieldPath) {
+    const result = validateOrchestratorContextReadinessResultV1(value, `${ctx.sourcePath}#${fieldPath}`);
+    if (!result.ok) {
+        throw new ArtifactValidationError({
+            ok: false,
+            artifactKind: ctx.artifactKind,
+            sourcePath: ctx.sourcePath,
+            code: result.code,
+            message: `Nested readiness field "${fieldPath}" is invalid: ${result.message}`,
+            fieldPath,
+            expected: result.expected,
+            actual: result.actual
+        });
+    }
+    return result.artifact;
+}
+function validateCorrectionRouteResult(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        verdict: requiredNullableLiteral(ctx, requiredField(ctx, obj, "verdict", joinFieldPath(fieldPath, "verdict")), joinFieldPath(fieldPath, "verdict"), JUDGE_VERDICTS),
+        recommendedStage: requiredNullableString(ctx, requiredField(ctx, obj, "recommendedStage", joinFieldPath(fieldPath, "recommendedStage")), joinFieldPath(fieldPath, "recommendedStage")),
+        routedStage: requiredNullableLiteral(ctx, requiredField(ctx, obj, "routedStage", joinFieldPath(fieldPath, "routedStage")), joinFieldPath(fieldPath, "routedStage"), CORRECTABLE_STAGES),
+        routeStatus: requiredLiteral(ctx, requiredField(ctx, obj, "routeStatus", joinFieldPath(fieldPath, "routeStatus")), joinFieldPath(fieldPath, "routeStatus"), ROUTE_STATUSES),
+        warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings")),
+        errors: requiredStringArray(ctx, requiredField(ctx, obj, "errors", joinFieldPath(fieldPath, "errors")), joinFieldPath(fieldPath, "errors")),
+        isBlocked: requiredBoolean(ctx, requiredField(ctx, obj, "isBlocked", joinFieldPath(fieldPath, "isBlocked")), joinFieldPath(fieldPath, "isBlocked")),
+        strictFail: requiredBoolean(ctx, requiredField(ctx, obj, "strictFail", joinFieldPath(fieldPath, "strictFail")), joinFieldPath(fieldPath, "strictFail"))
+    };
+}
+function validateGate(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        schemaVersion: requiredLiteral(ctx, requiredField(ctx, obj, "schemaVersion", joinFieldPath(fieldPath, "schemaVersion")), joinFieldPath(fieldPath, "schemaVersion"), ["1.0.0"]),
+        mode: requiredString(ctx, requiredField(ctx, obj, "mode", joinFieldPath(fieldPath, "mode")), joinFieldPath(fieldPath, "mode")),
+        contextRequired: requiredBoolean(ctx, requiredField(ctx, obj, "contextRequired", joinFieldPath(fieldPath, "contextRequired")), joinFieldPath(fieldPath, "contextRequired")),
+        applicableContextKinds: requiredArray(ctx, requiredField(ctx, obj, "applicableContextKinds", joinFieldPath(fieldPath, "applicableContextKinds")), joinFieldPath(fieldPath, "applicableContextKinds")).map((item, i) => requiredLiteral(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "applicableContextKinds"), i), APPLICABLE_CONTEXT_KINDS)),
+        contextReady: requiredBoolean(ctx, requiredField(ctx, obj, "contextReady", joinFieldPath(fieldPath, "contextReady")), joinFieldPath(fieldPath, "contextReady")),
+        readinessClassification: requiredLiteral(ctx, requiredField(ctx, obj, "readinessClassification", joinFieldPath(fieldPath, "readinessClassification")), joinFieldPath(fieldPath, "readinessClassification"), RUN_INTEGRITY_READINESS_CLASSIFICATIONS),
+        blockedStageNames: requiredArray(ctx, requiredField(ctx, obj, "blockedStageNames", joinFieldPath(fieldPath, "blockedStageNames")), joinFieldPath(fieldPath, "blockedStageNames")).map((item, i) => requiredLiteral(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "blockedStageNames"), i), CONTEXT_SENSITIVE_STAGE_NAMES)),
+        blockingCodes: requiredStringArray(ctx, requiredField(ctx, obj, "blockingCodes", joinFieldPath(fieldPath, "blockingCodes")), joinFieldPath(fieldPath, "blockingCodes")),
+        recommendedCorrectionStage: requiredNullableString(ctx, requiredField(ctx, obj, "recommendedCorrectionStage", joinFieldPath(fieldPath, "recommendedCorrectionStage")), joinFieldPath(fieldPath, "recommendedCorrectionStage")),
+        expectedJudgeVerdict: requiredLiteral(ctx, requiredField(ctx, obj, "expectedJudgeVerdict", joinFieldPath(fieldPath, "expectedJudgeVerdict")), joinFieldPath(fieldPath, "expectedJudgeVerdict"), EXPECTED_JUDGE_VERDICTS),
+        warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings"))
+    };
+    if (optionalField(obj, "implementationContext") !== undefined) {
+        result.implementationContext = validateContextReadinessNested(ctx, obj.implementationContext, joinFieldPath(fieldPath, "implementationContext"));
+    }
+    if (optionalField(obj, "testContext") !== undefined) {
+        result.testContext = validateContextReadinessNested(ctx, obj.testContext, joinFieldPath(fieldPath, "testContext"));
+    }
+    if (optionalField(obj, "primaryBlocker") !== undefined) {
+        // primaryBlocker reuses ContextReadinessBlockerSummary's exact shape (owned by
+        // orchestratorContextReadinessResultV1.ts's blockerSummary field); walked structurally
+        // here rather than re-validated through a second nested-artifact call, since it is not
+        // itself a standalone readiness artifact.
+        const blockerObj = requiredObject(ctx, obj.primaryBlocker, joinFieldPath(fieldPath, "primaryBlocker"));
+        result.primaryBlocker = blockerObj;
+    }
+    return result;
+}
+function validateJudgeIntegrity(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        schemaVersion: requiredLiteral(ctx, requiredField(ctx, obj, "schemaVersion", joinFieldPath(fieldPath, "schemaVersion")), joinFieldPath(fieldPath, "schemaVersion"), ["1.0.0"]),
+        judgeArtifactPresent: requiredBoolean(ctx, requiredField(ctx, obj, "judgeArtifactPresent", joinFieldPath(fieldPath, "judgeArtifactPresent")), joinFieldPath(fieldPath, "judgeArtifactPresent")),
+        judgeVerdictParseStatus: requiredLiteral(ctx, requiredField(ctx, obj, "judgeVerdictParseStatus", joinFieldPath(fieldPath, "judgeVerdictParseStatus")), joinFieldPath(fieldPath, "judgeVerdictParseStatus"), JUDGE_VERDICT_PARSE_STATUSES),
+        authoredJudgeVerdict: requiredNullableLiteral(ctx, requiredField(ctx, obj, "authoredJudgeVerdict", joinFieldPath(fieldPath, "authoredJudgeVerdict")), joinFieldPath(fieldPath, "authoredJudgeVerdict"), JUDGE_VERDICTS),
+        expectedJudgeVerdict: requiredLiteral(ctx, requiredField(ctx, obj, "expectedJudgeVerdict", joinFieldPath(fieldPath, "expectedJudgeVerdict")), joinFieldPath(fieldPath, "expectedJudgeVerdict"), EXPECTED_JUDGE_VERDICTS),
+        judgeVerdictMatchesExpected: requiredBoolean(ctx, requiredField(ctx, obj, "judgeVerdictMatchesExpected", joinFieldPath(fieldPath, "judgeVerdictMatchesExpected")), joinFieldPath(fieldPath, "judgeVerdictMatchesExpected")),
+        judgeVerdictAccepted: requiredBoolean(ctx, requiredField(ctx, obj, "judgeVerdictAccepted", joinFieldPath(fieldPath, "judgeVerdictAccepted")), joinFieldPath(fieldPath, "judgeVerdictAccepted")),
+        correctionRequired: requiredBoolean(ctx, requiredField(ctx, obj, "correctionRequired", joinFieldPath(fieldPath, "correctionRequired")), joinFieldPath(fieldPath, "correctionRequired")),
+        correctionBlocked: requiredBoolean(ctx, requiredField(ctx, obj, "correctionBlocked", joinFieldPath(fieldPath, "correctionBlocked")), joinFieldPath(fieldPath, "correctionBlocked")),
+        acceptedCorrectionStage: requiredNullableString(ctx, requiredField(ctx, obj, "acceptedCorrectionStage", joinFieldPath(fieldPath, "acceptedCorrectionStage")), joinFieldPath(fieldPath, "acceptedCorrectionStage")),
+        finalReportEligible: requiredBoolean(ctx, requiredField(ctx, obj, "finalReportEligible", joinFieldPath(fieldPath, "finalReportEligible")), joinFieldPath(fieldPath, "finalReportEligible")),
+        blockingCodes: requiredStringArray(ctx, requiredField(ctx, obj, "blockingCodes", joinFieldPath(fieldPath, "blockingCodes")), joinFieldPath(fieldPath, "blockingCodes")),
+        acceptedCorrectionRoute: (() => {
+            const routeValue = requiredField(ctx, obj, "acceptedCorrectionRoute", joinFieldPath(fieldPath, "acceptedCorrectionRoute"));
+            return routeValue === null ? null : validateCorrectionRouteResult(ctx, routeValue, joinFieldPath(fieldPath, "acceptedCorrectionRoute"));
+        })()
+    };
+    if (optionalField(obj, "primaryReason") !== undefined) {
+        result.primaryReason = optionalString(ctx, obj.primaryReason, joinFieldPath(fieldPath, "primaryReason"));
+    }
+    return result;
+}
+function validateFinalReportEligibility(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        eligible: requiredBoolean(ctx, requiredField(ctx, obj, "eligible", joinFieldPath(fieldPath, "eligible")), joinFieldPath(fieldPath, "eligible")),
+        contextReady: requiredBoolean(ctx, requiredField(ctx, obj, "contextReady", joinFieldPath(fieldPath, "contextReady")), joinFieldPath(fieldPath, "contextReady")),
+        priorArtifactsValid: requiredBoolean(ctx, requiredField(ctx, obj, "priorArtifactsValid", joinFieldPath(fieldPath, "priorArtifactsValid")), joinFieldPath(fieldPath, "priorArtifactsValid")),
+        judgeIntegrity: validateJudgeIntegrity(ctx, requiredField(ctx, obj, "judgeIntegrity", joinFieldPath(fieldPath, "judgeIntegrity")), joinFieldPath(fieldPath, "judgeIntegrity")),
+        blockingCodes: requiredStringArray(ctx, requiredField(ctx, obj, "blockingCodes", joinFieldPath(fieldPath, "blockingCodes")), joinFieldPath(fieldPath, "blockingCodes"))
+    };
+    if (optionalField(obj, "primaryReason") !== undefined) {
+        result.primaryReason = optionalString(ctx, obj.primaryReason, joinFieldPath(fieldPath, "primaryReason"));
+    }
+    return result;
+}
+function validateArtifactStateRecord(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const result = {
+        state: requiredLiteral(ctx, requiredField(ctx, obj, "state", joinFieldPath(fieldPath, "state")), joinFieldPath(fieldPath, "state"), MANUAL_ARTIFACT_LIFECYCLE_STATES),
+        updatedAt: requiredString(ctx, requiredField(ctx, obj, "updatedAt", joinFieldPath(fieldPath, "updatedAt")), joinFieldPath(fieldPath, "updatedAt"))
+    };
+    if (optionalField(obj, "reason") !== undefined)
+        result.reason = optionalString(ctx, obj.reason, joinFieldPath(fieldPath, "reason"));
+    if (optionalField(obj, "source") !== undefined)
+        result.source = optionalString(ctx, obj.source, joinFieldPath(fieldPath, "source"));
+    return result;
+}
+function validateLifecycleEntry(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const manualRecordValue = requiredField(ctx, obj, "manualRecord", joinFieldPath(fieldPath, "manualRecord"));
+    const result = {
+        artifactFile: requiredString(ctx, requiredField(ctx, obj, "artifactFile", joinFieldPath(fieldPath, "artifactFile")), joinFieldPath(fieldPath, "artifactFile")),
+        stageName: requiredString(ctx, requiredField(ctx, obj, "stageName", joinFieldPath(fieldPath, "stageName")), joinFieldPath(fieldPath, "stageName")),
+        fileExists: requiredBoolean(ctx, requiredField(ctx, obj, "fileExists", joinFieldPath(fieldPath, "fileExists")), joinFieldPath(fieldPath, "fileExists")),
+        manualRecord: manualRecordValue === null ? null : validateArtifactStateRecord(ctx, manualRecordValue, joinFieldPath(fieldPath, "manualRecord")),
+        resolvedState: requiredLiteral(ctx, requiredField(ctx, obj, "resolvedState", joinFieldPath(fieldPath, "resolvedState")), joinFieldPath(fieldPath, "resolvedState"), ARTIFACT_LIFECYCLE_STATES)
+    };
+    if (optionalField(obj, "blockingReason") !== undefined) {
+        result.blockingReason = optionalString(ctx, obj.blockingReason, joinFieldPath(fieldPath, "blockingReason"));
+    }
+    return result;
+}
+export function validateOrchestratorRunIntegrityEvidenceV1(value, sourcePath) {
+    const ctx = { artifactKind: ARTIFACT_KIND, sourcePath };
+    try {
+        const schemaVersionResult = parseSupportedMajorOneSchemaVersion(requiredField(ctx, value, "schemaVersion", "schemaVersion"), ARTIFACT_KIND, sourcePath);
+        if ("ok" in schemaVersionResult)
+            return schemaVersionResult;
+        const evidence = {
+            schemaVersion: requiredString(ctx, value.schemaVersion, "schemaVersion"),
+            runFolder: requiredString(ctx, requiredField(ctx, value, "runFolder", "runFolder"), "runFolder"),
+            gate: validateGate(ctx, requiredField(ctx, value, "gate", "gate"), "gate"),
+            lifecycle: requiredArray(ctx, requiredField(ctx, value, "lifecycle", "lifecycle"), "lifecycle").map((item, i) => validateLifecycleEntry(ctx, item, arrayFieldPath("lifecycle", i)))
+        };
+        if (optionalField(value, "judgeIntegrity") !== undefined) {
+            evidence.judgeIntegrity = validateJudgeIntegrity(ctx, value.judgeIntegrity, "judgeIntegrity");
+        }
+        if (optionalField(value, "finalReportEligibility") !== undefined) {
+            evidence.finalReportEligibility = validateFinalReportEligibility(ctx, value.finalReportEligibility, "finalReportEligibility");
+        }
+        if (optionalField(value, "finalArtifactPresent") !== undefined) {
+            evidence.finalArtifactPresent = requiredBoolean(ctx, value.finalArtifactPresent, "finalArtifactPresent");
+        }
+        if (optionalField(value, "finalArtifactVerdict") !== undefined) {
+            evidence.finalArtifactVerdict = requiredNullableLiteral(ctx, value.finalArtifactVerdict, "finalArtifactVerdict", JUDGE_VERDICTS);
+        }
+        // Per the exact-mirror contract, the returned artifact is always the original parsed
+        // reference, not a rebuilt object. The construction above exists only to walk and
+        // type-check every field.
+        void evidence;
+        return {
+            ok: true,
+            artifactKind: ARTIFACT_KIND,
+            sourcePath,
+            schemaVersion: value.schemaVersion,
+            schemaMajor: 1,
+            artifact: value,
+            rawArtifact: value
+        };
+    }
+    catch (error) {
+        if (error instanceof ArtifactValidationError)
+            return error.failure;
+        throw error;
+    }
+}

package/dist/src/evaluation/upstreamArtifacts/validateSupplementalContextDocumentV1.js

@@ -0,0 +1,148 @@
+import { makeFailure } from "./runtimeValidation.js";
+import { parseSupplementalContextText } from "./supplementalContextTextParser.js";
+import { REQUIRED_METADATA_BY_DOCUMENT_KIND, REQUIRED_SECTIONS_BY_DOCUMENT_KIND, ROLE_BY_DOCUMENT_KIND, SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR, SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR, VALID_ADEQUACY_VALUES, VALID_DECLARED_STATUSES, VALID_FRESHNESS_VALUES, VALID_REPOSITORY_SCOPES, VALID_TRUNCATION_VALUES, isRetrievalReportKind, isTestKind } from "./supplementalContextTypes.js";
+const SCHEMA_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+function supportedMajorForKind(kind) {
+    return isRetrievalReportKind(kind)
+        ? SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR
+        : SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR;
+}
+function literalOrFail(artifactKind, sourcePath, fieldPath, value, allowed, errorCode = "INVALID_LITERAL_VALUE") {
+    if (allowed.includes(value))
+        return value;
+    return {
+        ok: false,
+        artifactKind,
+        sourcePath,
+        code: errorCode,
+        message: `Field "${fieldPath}" in artifact "${artifactKind}" at "${sourcePath}" has invalid value "${value}". Expected one of: ${allowed.join(", ")}.`,
+        fieldPath,
+        expected: allowed.join(" | "),
+        actual: value
+    };
+}
+function isFailure(value) {
+    return typeof value === "object" && value !== null && value.ok === false;
+}
+export function validateSupplementalContextDocumentV1(artifactKind, expectedKind, text, sourcePath) {
+    const parsed = parseSupplementalContextText(text);
+    if (parsed.metadataOrder.length === 0 && parsed.sectionOrder.length === 0) {
+        return makeFailure(artifactKind, sourcePath, "MALFORMED_TEXT_ARTIFACT", `Artifact "${artifactKind}" at "${sourcePath}" contains no recognizable "Key: value" metadata or "## Heading" sections.`);
+    }
+    // Kind/role identity is checked before general required-metadata/section completeness so
+    // that feeding one document kind's file to another kind's reader is reported as a
+    // structural identity mismatch (DOCUMENT_KIND_MISMATCH / DOCUMENT_ROLE_MISMATCH) rather
+    // than as an incidental "missing metadata key" from the wrong kind's required-field list.
+    const declaredKind = parsed.metadata["Document kind"];
+    if (declaredKind !== expectedKind) {
+        return makeFailure(artifactKind, sourcePath, "DOCUMENT_KIND_MISMATCH", `Artifact "${artifactKind}" at "${sourcePath}" declares document kind "${declaredKind}" but this reader expects "${expectedKind}".`, "Document kind", expectedKind, declaredKind);
+    }
+    const expectedRole = ROLE_BY_DOCUMENT_KIND[expectedKind];
+    const declaredRole = parsed.metadata["Role"];
+    if (declaredRole !== expectedRole) {
+        return makeFailure(artifactKind, sourcePath, "DOCUMENT_ROLE_MISMATCH", `Artifact "${artifactKind}" at "${sourcePath}" declares role "${declaredRole}" but this reader expects "${expectedRole}".`, "Role", expectedRole, declaredRole);
+    }
+    const requiredMetadata = REQUIRED_METADATA_BY_DOCUMENT_KIND[expectedKind];
+    for (const key of requiredMetadata) {
+        if (!(key in parsed.metadata)) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_METADATA", `Artifact "${artifactKind}" at "${sourcePath}" is missing required metadata key "${key}".`, key, "present");
+        }
+    }
+    const requiredSections = REQUIRED_SECTIONS_BY_DOCUMENT_KIND[expectedKind];
+    for (const heading of requiredSections) {
+        if (!(heading in parsed.sections)) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_SECTION", `Artifact "${artifactKind}" at "${sourcePath}" is missing required section heading "## ${heading}".`, heading, "present");
+        }
+    }
+    const schemaVersion = parsed.metadata["Schema version"];
+    if (!SCHEMA_VERSION_PATTERN.test(schemaVersion)) {
+        return makeFailure(artifactKind, sourcePath, "INVALID_SCHEMA_VERSION", `Artifact "${artifactKind}" at "${sourcePath}" has an invalid "Schema version": expected strict "x.y.z" semantic version.`, "Schema version", "^[0-9]+\\.[0-9]+\\.[0-9]+$", schemaVersion);
+    }
+    const major = Number(schemaVersion.split(".")[0]);
+    const supportedMajor = supportedMajorForKind(expectedKind);
+    if (major !== supportedMajor) {
+        return makeFailure(artifactKind, sourcePath, "UNSUPPORTED_SCHEMA_MAJOR", `Artifact "${artifactKind}" at "${sourcePath}" has unsupported schema major "${major}" in "Schema version": supported major is ${supportedMajor}.`, "Schema version", String(supportedMajor), schemaVersion);
+    }
+    const status = literalOrFail(artifactKind, sourcePath, "Status", parsed.metadata["Status"], VALID_DECLARED_STATUSES, "UNKNOWN_STATUS_VALUE");
+    if (isFailure(status))
+        return status;
+    const repositoryScope = literalOrFail(artifactKind, sourcePath, "Repository scope", parsed.metadata["Repository scope"], VALID_REPOSITORY_SCOPES);
+    if (isFailure(repositoryScope))
+        return repositoryScope;
+    const freshness = literalOrFail(artifactKind, sourcePath, "Freshness", parsed.metadata["Freshness"], VALID_FRESHNESS_VALUES);
+    if (isFailure(freshness))
+        return freshness;
+    const adequacy = literalOrFail(artifactKind, sourcePath, "Adequacy", parsed.metadata["Adequacy"], VALID_ADEQUACY_VALUES);
+    if (isFailure(adequacy))
+        return adequacy;
+    const requiredEvidenceTruncated = literalOrFail(artifactKind, sourcePath, "Required evidence truncated", parsed.metadata["Required evidence truncated"], VALID_TRUNCATION_VALUES);
+    if (isFailure(requiredEvidenceTruncated))
+        return requiredEvidenceTruncated;
+    const indexIdentity = parsed.metadata["Index identity"];
+    if (!indexIdentity || indexIdentity.length === 0) {
+        return makeFailure(artifactKind, sourcePath, "MISSING_CANONICAL_IDENTITY", `Artifact "${artifactKind}" at "${sourcePath}" is missing a non-empty canonical "Index identity".`, "Index identity", "present");
+    }
+    const document = {
+        documentKind: expectedKind,
+        role: expectedRole,
+        schemaVersion,
+        schemaMajor: 1,
+        status,
+        repositoryScope,
+        freshness,
+        adequacy,
+        requiredEvidenceTruncated,
+        contextCapsuleSchemaVersion: parsed.metadata["Context capsule schema version"],
+        retrievalAuditSchemaVersion: parsed.metadata["Retrieval audit schema version"],
+        toolName: parsed.metadata["Tool name"],
+        toolVersion: parsed.metadata["Tool version"],
+        indexIdentity,
+        rawMetadata: parsed.metadata,
+        sections: parsed.sections,
+        sectionOrder: parsed.sectionOrder,
+        metadataOrder: parsed.metadataOrder,
+        warnings: []
+    };
+    if (isRetrievalReportKind(expectedKind)) {
+        document.requestSchemaVersion = parsed.metadata["Request schema version"];
+        const fullFileFallbackUsed = literalOrFail(artifactKind, sourcePath, "Full-file fallback used", parsed.metadata["Full-file fallback used"], VALID_TRUNCATION_VALUES);
+        if (isFailure(fullFileFallbackUsed))
+            return fullFileFallbackUsed;
+        document.fullFileFallbackUsed = fullFileFallbackUsed;
+        const determinismChecked = literalOrFail(artifactKind, sourcePath, "Determinism checked", parsed.metadata["Determinism checked"], VALID_TRUNCATION_VALUES);
+        if (isFailure(determinismChecked))
+            return determinismChecked;
+        document.determinismChecked = determinismChecked;
+    }
+    if (isTestKind(expectedKind)) {
+        const responsibilityMappingsTruncated = literalOrFail(artifactKind, sourcePath, "Responsibility mappings truncated", parsed.metadata["Responsibility mappings truncated"], VALID_TRUNCATION_VALUES);
+        if (isFailure(responsibilityMappingsTruncated))
+            return responsibilityMappingsTruncated;
+        document.responsibilityMappingsTruncated = responsibilityMappingsTruncated;
+        // Preserved verbatim, never validated against the orchestrator's internal
+        // CriticalResponsibilityMappingState enum -- see supplementalContextTypes.ts.
+        const criticalStatus = parsed.metadata["Critical responsibility mapping status"];
+        if (!criticalStatus || criticalStatus.length === 0) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_METADATA", `Artifact "${artifactKind}" at "${sourcePath}" is missing a non-empty "Critical responsibility mapping status".`, "Critical responsibility mapping status", "present");
+        }
+        document.criticalResponsibilityMappingStatus = criticalStatus;
+    }
+    if (parsed.duplicateMetadataKeys.length > 0) {
+        document.warnings.push(`Duplicate metadata keys were ignored (first occurrence kept): ${parsed.duplicateMetadataKeys.join(", ")}.`);
+    }
+    if (parsed.duplicateSectionHeadings.length > 0) {
+        document.warnings.push(`Duplicate section headings were ignored (first occurrence kept): ${parsed.duplicateSectionHeadings.join(", ")}.`);
+    }
+    if (parsed.emptyMetadataKeys.length > 0) {
+        document.warnings.push(`Metadata keys had empty values: ${parsed.emptyMetadataKeys.join(", ")}.`);
+    }
+    return {
+        ok: true,
+        artifactKind,
+        sourcePath,
+        schemaVersion,
+        schemaMajor: 1,
+        artifact: document,
+        rawArtifact: { metadata: parsed.metadata, sections: parsed.sections }
+    };
+}

package/dist/src/experiments/plugins/contextStrategyComparison/loadV043StrategyArtifacts.js

@@ -1,4 +1,4 @@
-import { readMyDevKitContextCapsuleV1, readMyDevKitRetrievalAuditRecordV1, readOrchestratorWorkflowInstructionPacketV1 } from "../../../evaluation/upstreamArtifacts/index.js";
+import { readImplementationContextPacketV1, readImplementationContextRetrievalReportV1, readMyDevKitContextCapsuleV1, readMyDevKitRetrievalAuditRecordV1, readOrchestratorWorkflowInstructionPacketV1, readTestContextPacketV1, readTestContextRetrievalReportV1, validateOrchestratorContextReadinessResultV1 } from "../../../evaluation/upstreamArtifacts/index.js";
 import { checkMyDevKitContextArtifactConsistency } from "../../../evaluation/stageContextSelectors/index.js";
 import { readStageContextExpectationFixtureV1 } from "../../../evaluation/stageContextExpectations/index.js";
 import { readV043FullWorkflowLibraryFixture } from "./readV043FullWorkflowLibraryFixture.js";
@@ -265,20 +265,131 @@ export async function loadV043StrategyArtifacts(input) {
                     details: packetResult
                 });
             }
+            // v0.4.4 Batch 3: producer-readiness bridge inputs -- every one is optional (section
+            // 11.2). Only a supplied-but-unreadable source becomes a load failure; an absent
+            // source is simply left off the payload for the bridge evaluator to treat as
+            // unavailable/not-applicable.
+            let implementationContextPacketSourcePath;
+            let implementationContextPacket;
+            if (input.implementationContextPacketPath !== undefined) {
+                const result = await readImplementationContextPacketV1(input.implementationContextPacketPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "IMPLEMENTATION_CONTEXT_PACKET_READ_FAILED",
+                        fieldPath: "implementationContextPacket",
+                        message: `Failed to read implementation-context packet: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    implementationContextPacketSourcePath = result.sourcePath;
+                    implementationContextPacket = result.artifact;
+                }
+            }
+            let implementationContextRetrievalReportSourcePath;
+            let implementationContextRetrievalReport;
+            if (input.implementationContextRetrievalReportPath !== undefined) {
+                const result = await readImplementationContextRetrievalReportV1(input.implementationContextRetrievalReportPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "IMPLEMENTATION_CONTEXT_RETRIEVAL_REPORT_READ_FAILED",
+                        fieldPath: "implementationContextRetrievalReport",
+                        message: `Failed to read implementation-context retrieval report: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    implementationContextRetrievalReportSourcePath = result.sourcePath;
+                    implementationContextRetrievalReport = result.artifact;
+                }
+            }
+            let testContextPacketSourcePath;
+            let testContextPacket;
+            if (input.testContextPacketPath !== undefined) {
+                const result = await readTestContextPacketV1(input.testContextPacketPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "TEST_CONTEXT_PACKET_READ_FAILED",
+                        fieldPath: "testContextPacket",
+                        message: `Failed to read test-context packet: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    testContextPacketSourcePath = result.sourcePath;
+                    testContextPacket = result.artifact;
+                }
+            }
+            let testContextRetrievalReportSourcePath;
+            let testContextRetrievalReport;
+            if (input.testContextRetrievalReportPath !== undefined) {
+                const result = await readTestContextRetrievalReportV1(input.testContextRetrievalReportPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "TEST_CONTEXT_RETRIEVAL_REPORT_READ_FAILED",
+                        fieldPath: "testContextRetrievalReport",
+                        message: `Failed to read test-context retrieval report: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    testContextRetrievalReportSourcePath = result.sourcePath;
+                    testContextRetrievalReport = result.artifact;
+                }
+            }
+            let readiness;
+            if (input.readiness !== undefined) {
+                const readinessResult = validateOrchestratorContextReadinessResultV1(input.readiness, "programmatic-input:readiness");
+                if (!readinessResult.ok) {
+                    issues.push({
+                        code: "READINESS_INPUT_INVALID",
+                        fieldPath: "readiness",
+                        message: `Readiness programmatic input is invalid: ${readinessResult.message}`,
+                        details: readinessResult
+                    });
+                }
+                else {
+                    readiness = readinessResult.artifact;
+                }
+            }
             if (issues.length > 0 || !expectationsResult.ok || !packetResult.ok || pairs.length !== input.contextArtifacts.length) {
                 return buildFailureResult(input, issues);
             }
+            const payload = {
+                contextArtifacts: pairs,
+                workflowInstructionPacketSourcePath: packetResult.sourcePath,
+                workflowInstructionPacket: packetResult.artifact
+            };
+            if (implementationContextPacket !== undefined) {
+                payload.implementationContextPacketSourcePath = implementationContextPacketSourcePath;
+                payload.implementationContextPacket = implementationContextPacket;
+            }
+            if (implementationContextRetrievalReport !== undefined) {
+                payload.implementationContextRetrievalReportSourcePath = implementationContextRetrievalReportSourcePath;
+                payload.implementationContextRetrievalReport = implementationContextRetrievalReport;
+            }
+            if (testContextPacket !== undefined) {
+                payload.testContextPacketSourcePath = testContextPacketSourcePath;
+                payload.testContextPacket = testContextPacket;
+            }
+            if (testContextRetrievalReport !== undefined) {
+                payload.testContextRetrievalReportSourcePath = testContextRetrievalReportSourcePath;
+                payload.testContextRetrievalReport = testContextRetrievalReport;
+            }
+            if (readiness !== undefined) {
+                payload.readiness = readiness;
+            }
             return {
                 status: "completed",
                 strategyId: input.strategyId,
                 input,
                 expectationsSourcePath: expectationsResult.sourcePath,
                 expectations: expectationsResult.fixture,
-                payload: {
-                    contextArtifacts: pairs,
-                    workflowInstructionPacketSourcePath: packetResult.sourcePath,
-                    workflowInstructionPacket: packetResult.artifact
-                },
+                payload,
                 warnings: []
             };
         }