includedBuild {
                buildLogic
                nested {
                    buildLogic
                    includeBuild '../buildLogic'
                }
            }
            includingBuild {
                includeBuild '../includedBuild'
                buildLogic
                nested {
                    includeBuild '../buildLogic'
                    buildLogic
                }
            }

│   ├── settings.gradle.kts // <5>
│   └── src
│       └── main
│           └── kotlin // <6>
│               ├── buildlogic.${languageLC.raw}-application-conventions.gradle.kts
│               ├── buildlogic.${languageLC.raw}-common-conventions.gradle.kts
│               └── buildlogic.${languageLC.raw}-library-conventions.gradle.kts
├── app
│   ├── build.gradle.kts // <7>
│   └── src
│       ├── main // <8>

        then:
        cachedClasspath.asFiles == [cachedFile]
        cachedFile.assertIsFile()

        and:
        1 * fileAccessTimeJournal.setLastAccessTime(cachedFile.parentFile, _)
        0 * fileAccessTimeJournal._

        when:
        def cachedClasspath2 = transformer.transform(classpath, BuildLogic)

        then:

        workerDaemonProcess.run(new Param())
    }
}
'''
        file('included/build.gradle') << """
plugins {
    id("groovy-gradle-plugin")
}
group = "buildlogic"

"""
        buildFile << '''
plugins {
    id('buildlogic.foo')
}
'''
        settingsFile << '''
            pluginManagement {
                includeBuild('included')
            }
        '''
        when:

            PropertyTrace.BuildLogic(location.sourceShortDisplayName, location.lineNumber)
        } else {
            locationForCaller(consumer, diagnostics.source)
        }
    }

    private
    fun locationForCaller(consumer: String?, source: UserCodeSource?): PropertyTrace {
        return if (source != null) {
            PropertyTrace.BuildLogic(source.displayName, null)

            // So, disable or fail or whatever based on which execution modes are enabled
            whenThirdPartyAgentPresent()
        } else {
            CachedClasspathTransformer.StandardTransform.BuildLogic
        }
    }

    abstract fun whenThirdPartyAgentPresent(): CachedClasspathTransformer.StandardTransform

            fragments.addAll(message.fragments)
        }
    }
}


sealed class PropertyTrace {

    object Unknown : PropertyTrace()

    object Gradle : PropertyTrace()

    class BuildLogic(
        val source: DisplayName,
        val lineNumber: Int? = null
    ) : PropertyTrace()

    class BuildLogicClass(
        val name: String
    ) : PropertyTrace()

    class Task(

    fun ProblemSpec.locationOfProblem(problem: PropertyProblem) {
        val trace = problem.trace.buildLogic()
        if (trace?.lineNumber != null) {
            lineInFileLocation(trace.source.displayName, trace.lineNumber!!)
        }
    }

    private
    fun PropertyTrace.buildLogic() = sequence.filterIsInstance<PropertyTrace.BuildLogic>().firstOrNull()

    private
    fun ProblemSeverity.toProblemSeverity() = when {

        when:
        run 'init', '--dsl', scriptDsl.id as String

        then:
        targetDir.file(dsl.settingsFileName).exists()
        !targetDir.file(dsl.buildFileName).exists() // no root build file
        warSubprojectBuildFile.exists()

                documentationSection = DocumentationSection.NotYetImplementedTestKitJavaAgent
            )
        )
        return CachedClasspathTransformer.StandardTransform.BuildLogic
    }