Prepare v0.15.0 release documentation

.gitignore

@@ -22,6 +22,9 @@
 go.work
 go.work.sum
 
+# Local ReleaseKit executable
+.releasekit/
+
 # env file
 .env
 
@@ -67,4 +70,3 @@ Icon
 .AppleDesktop
 Network Trash Folder
 Temporary Items
-.apdisk

README.md

@@ -8,7 +8,8 @@ gitea.maximumdirect.net/eric/promptkit
 ```
 
 The root `promptkit` package provides the supported public engine. Consumers
-can configure filesystem or in-memory prompt, profile, and schema sources,
+can configure file, embedded, or programmatic backend, profile, and prompt
+definitions alongside filesystem or in-memory schemas,
 prepare requests without generation, run requests with the built-in
 OpenAI-compatible client, or inject their own model client and artifact reader.
 
@@ -20,9 +21,12 @@ Run the maintained offline preparation example from the repository root:
 go run ./examples/go-library/prepare
 ```
 
-It loads a repository-local prompt, supplies an in-memory profile and inline
-input, and prints deterministic preparation metadata without contacting a
-provider or requiring credentials. Read the
+It loads a repository-local prompt, supplies a programmatic profile and inline
+input, inspects the captured configuration, and prints deterministic
+preparation metadata without contacting a provider or requiring credentials.
+The [consumer guide](docs/consumers/pkg-promptkit.md) also shows a local backend,
+ordered file/embedded sources, programmatic mappings, and how to replace an
+engine when source files change. Read the
 [example source](examples/go-library/prepare/main.go), the
 [Go package consumer guide](docs/consumers/pkg-promptkit.md), and the
 [framework format reference](docs/formats.md) to build a consumer workflow.
@@ -33,6 +37,13 @@ boundary and constraints that framework work must preserve.
 
 ## Release Guidance
 
+The [v0.15.0 release notes](docs/releases/v0.15.0.md) cover error-only
+validation of concrete requests with `Engine.ValidateRequest`.
+
+Consumers upgrading to `v0.12.0` should read the
+[v0.12.0 release notes](docs/releases/v0.12.0.md) for the intentional ConfigKit
+configuration and public construction API migration.
+
 The [v0.11.2 release notes](docs/releases/v0.11.2.md) cover policy alignment
 and copied-policy attribution updates.
 

appended_messages_contract_test.go

@@ -29,15 +29,7 @@ func TestAppendedMessagesComposeFrozenEffectivePrompt(t *testing.T) {
 		{Role: promptkit.RoleUser, Content: "corrective request", CacheControl: cacheControl},
 	}
 	client := &fakeLLMClient{response: &promptkit.GenerateResponse{Content: "output"}}
-	engine, err := promptkit.NewEngine(
-		promptkit.Config{},
-		promptkit.WithPromptFS(contractPromptFS("prompt", "profile", "configured prompt"), "."),
-		promptkit.WithProfiles(promptkit.Profile{ID: "profile", Endpoint: "http://example.test/v1", Model: "model"}),
-		promptkit.WithLLMClient(client),
-	)
-	if err != nil {
-		t.Fatalf("construct engine: %v", err)
-	}
+	engine := newSimpleEngine(t, "configured prompt", promptkit.WithLLMClient(client))
 	request := promptkit.RunRequest{PromptID: "prompt", AppendedMessages: appended}
 
 	plain, err := engine.Prepare(context.Background(), promptkit.RunRequest{PromptID: "prompt"})
@@ -101,14 +93,9 @@ func TestAppendedMessagesComposeFrozenEffectivePrompt(t *testing.T) {
 	}
 }
 
-func TestInvalidAppendedMessagesFailBeforeSourceOrModelWork(t *testing.T) {
-	promptSource := &inspectionCountingFS{}
+func TestInvalidAppendedMessagesFailBeforeModelWork(t *testing.T) {
 	var modelCalls atomic.Int64
-	engine, err := promptkit.NewEngine(
-		promptkit.Config{},
-		promptkit.WithPromptFS(promptSource, "."),
-		promptkit.WithLLMClient(countingLLMClient{calls: &modelCalls}),
-	)
+	engine, err := promptkit.NewEngine(promptkit.Config{}, promptkit.WithLLMClient(countingLLMClient{calls: &modelCalls}))
 	if err != nil {
 		t.Fatalf("construct engine: %v", err)
 	}
@@ -136,9 +123,6 @@ func TestInvalidAppendedMessagesFailBeforeSourceOrModelWork(t *testing.T) {
 			}
 		})
 	}
-	if promptSource.opens.Load() != 0 {
-		t.Fatalf("invalid appended message opened prompt sources %d times", promptSource.opens.Load())
-	}
 	if modelCalls.Load() != 0 {
 		t.Fatalf("invalid appended message invoked the model %d times", modelCalls.Load())
 	}

assembled_workflow_benchmark_test.go

@@ -0,0 +1,237 @@
+package promptkit_test
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+var (
+	assembledPreparedSink *promptkit.PreparedRun
+	assembledResultSink   *promptkit.RunResult
+	assembledDetailsSink  promptkit.PreparedRun
+	assembledHandleSink   *promptkit.PreparedExecution
+)
+
+type assembledWorkflowClient struct{ content string }
+
+func (client assembledWorkflowClient) Generate(
+	context.Context,
+	promptkit.GenerateRequest,
+) (*promptkit.GenerateResponse, error) {
+	return &promptkit.GenerateResponse{Content: client.content}, nil
+}
+
+type assembledWorkflowFixture struct {
+	engine          *promptkit.Engine
+	request         promptkit.RunRequest
+	expectedMessage string
+	response        string
+}
+
+func assembledWorkflowSchema(b *testing.B) []byte {
+	b.Helper()
+	properties := make(map[string]any, 256)
+	for index := range 256 {
+		properties[fmt.Sprintf("property-%03d", index)] = map[string]any{"type": "string"}
+	}
+	data, err := json.Marshal(map[string]any{
+		"$schema":              "https://json-schema.org/draft/2020-12/schema",
+		"type":                 "object",
+		"properties":           properties,
+		"additionalProperties": false,
+	})
+	if err != nil {
+		b.Fatal(err)
+	}
+	return data
+}
+
+func assembledWorkflowExtras(entries int) map[string]any {
+	providers := make(map[string]any, entries)
+	for index := range entries {
+		providers[fmt.Sprintf("provider-%03d", index)] = map[string]any{
+			"enabled": true,
+			"labels":  []any{fmt.Sprintf("tier-%d", index%4), fmt.Sprintf("region-%d", index%3)},
+			"limits":  map[string]any{"burst": index + 1, "period": "minute"},
+			"routes":  []any{map[string]any{"weight": index + 1, "fallback": true}},
+		}
+	}
+	return map[string]any{"provider_options": providers}
+}
+
+func newAssembledWorkflowFixture(b *testing.B, name string) assembledWorkflowFixture {
+	b.Helper()
+	message := "Hello {{.name}}"
+	response := "ok"
+	output := map[string]any{"format": "text", "validation_mode": "none"}
+	profile := map[string]any{"endpoint": "http://example.test/v1", "model": "benchmark-model"}
+	options := []promptkit.Option{promptkit.WithLLMClient(assembledWorkflowClient{content: response})}
+	var expectedMessage string
+
+	switch name {
+	case "small":
+		expectedMessage = "Hello Ada"
+	case "large_message":
+		prefix := strings.Repeat("x", 256*1024)
+		message = prefix + "{{.name}}"
+		expectedMessage = prefix + "Ada"
+	case "mutable_payload":
+		message = `{"subject":"{{.name}}"}`
+		expectedMessage = `{"subject":"Ada"}`
+		response = "{}"
+		profile["extra_params"] = assembledWorkflowExtras(64)
+		output = map[string]any{
+			"format": "json", "validation_mode": "json_schema", "schema_path": "workflow-schema.json",
+		}
+		options[0] = promptkit.WithLLMClient(assembledWorkflowClient{content: response})
+		options = append(options, promptkit.WithSchemaFS(fstest.MapFS{
+			"workflow-schema.json": &fstest.MapFile{Data: assembledWorkflowSchema(b)},
+		}, "."))
+	default:
+		b.Fatalf("unknown assembled workflow fixture %q", name)
+	}
+
+	config := map[string]any{
+		"profiles": map[string]any{"profile": profile},
+		"prompts": map[string]any{"workflow": map[string]any{"v1": map[string]any{
+			"default_profile": "profile",
+			"messages":        []any{map[string]any{"role": "user", "content": message}},
+			"output":          output,
+		}}},
+	}
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &configkit.Input{
+		Source: configkit.Mapping("assembled workflow benchmark", config),
+	}}}, options...)
+	if err != nil {
+		b.Fatal(err)
+	}
+	request := promptkit.RunRequest{
+		PromptID: "workflow", PromptVersion: "v1", Vars: map[string]string{"name": "Ada"},
+	}
+	return assembledWorkflowFixture{
+		engine: engine, request: request, expectedMessage: expectedMessage, response: response,
+	}
+}
+
+func verifyAssembledWorkflowFixture(b *testing.B, fixture assembledWorkflowFixture) {
+	b.Helper()
+	ctx := context.Background()
+	prepared, err := fixture.engine.Prepare(ctx, fixture.request)
+	if err != nil {
+		b.Fatal(err)
+	}
+	if prepared.PromptID != "workflow" || prepared.PromptVersion != "v1" || len(prepared.Messages) != 1 ||
+		prepared.Messages[0].Content != fixture.expectedMessage {
+		b.Fatalf("prepared fixture output is invalid: %+v", prepared)
+	}
+	handle, err := fixture.engine.PrepareExecution(ctx, fixture.request)
+	if err != nil {
+		b.Fatal(err)
+	}
+	details := handle.Details()
+	if details.PromptID != "workflow" || len(details.Messages) != 1 || details.Messages[0].Content != fixture.expectedMessage {
+		handle.Discard()
+		b.Fatalf("prepared execution details are invalid: %+v", details)
+	}
+	handle.Discard()
+	result, err := fixture.engine.Run(ctx, fixture.request)
+	if err != nil {
+		b.Fatal(err)
+	}
+	if result.RawOutput != fixture.response {
+		b.Fatalf("run output=%q, want %q", result.RawOutput, fixture.response)
+	}
+	if fixture.response == "{}" && result.Validation.Status != promptkit.ValidationPassed {
+		b.Fatalf("structured response validation=%+v, want passed", result.Validation)
+	}
+}
+
+func BenchmarkEnginePreparation(b *testing.B) {
+	for _, name := range []string{"small", "large_message", "mutable_payload"} {
+		b.Run(name, func(b *testing.B) {
+			fixture := newAssembledWorkflowFixture(b, name)
+			verifyAssembledWorkflowFixture(b, fixture)
+			ctx := context.Background()
+			b.Run("prepare", func(b *testing.B) {
+				b.ReportAllocs()
+				b.ResetTimer()
+				for b.Loop() {
+					prepared, err := fixture.engine.Prepare(ctx, fixture.request)
+					if err != nil {
+						b.Fatal(err)
+					}
+					assembledPreparedSink = prepared
+				}
+				b.StopTimer()
+				assembledPreparedSink = nil
+			})
+			b.Run("prepared_execution_creation_and_discard", func(b *testing.B) {
+				b.ReportAllocs()
+				b.ResetTimer()
+				for b.Loop() {
+					handle, err := fixture.engine.PrepareExecution(ctx, fixture.request)
+					if err != nil {
+						b.Fatal(err)
+					}
+					handle.Discard()
+					assembledHandleSink = handle
+				}
+				b.StopTimer()
+				assembledHandleSink = nil
+			})
+		})
+	}
+}
+
+func BenchmarkEngineRun(b *testing.B) {
+	for _, name := range []string{"small", "large_message", "mutable_payload"} {
+		b.Run(name, func(b *testing.B) {
+			fixture := newAssembledWorkflowFixture(b, name)
+			verifyAssembledWorkflowFixture(b, fixture)
+			ctx := context.Background()
+			b.ReportAllocs()
+			b.ResetTimer()
+			for b.Loop() {
+				result, err := fixture.engine.Run(ctx, fixture.request)
+				if err != nil {
+					b.Fatal(err)
+				}
+				assembledResultSink = result
+			}
+			b.StopTimer()
+			assembledResultSink = nil
+		})
+	}
+}
+
+func BenchmarkPreparedExecutionDetails(b *testing.B) {
+	for _, name := range []string{"small", "large_message", "mutable_payload"} {
+		b.Run(name, func(b *testing.B) {
+			fixture := newAssembledWorkflowFixture(b, name)
+			verifyAssembledWorkflowFixture(b, fixture)
+			handle, err := fixture.engine.PrepareExecution(context.Background(), fixture.request)
+			if err != nil {
+				b.Fatal(err)
+			}
+			defer handle.Discard()
+			initial := handle.Details()
+			if len(initial.Messages) != 1 || initial.Messages[0].Content != fixture.expectedMessage {
+				b.Fatalf("prepared details fixture is invalid: %+v", initial)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for b.Loop() {
+				assembledDetailsSink = handle.Details()
+			}
+			b.StopTimer()
+			assembledDetailsSink = promptkit.PreparedRun{}
+		})
+	}
+}

backends.go

@@ -1,107 +1,69 @@
 package promptkit
 
 import (
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 )
 
-// BackendOpenRouter is the reserved ID of Promptkit's built-in OpenRouter
-// backend.
+// BackendOpenRouter identifies the maintained OpenRouter backend.
 const BackendOpenRouter = backend.OpenRouterID
 
-// BackendRakestrawHome is the reserved ID of Promptkit's built-in
-// Rakestrawhome backend.
+// BackendRakestrawHome identifies the maintained Rakestrawhome backend.
 const BackendRakestrawHome = backend.RakestrawHomeID
 
-// BackendLocal is the case-sensitive conventional ID used by [LocalBackend].
-// It is not a built-in or reserved backend and must be registered with
-// [WithBackend].
+// BackendLocal is a conventional ID for a caller-configured local backend.
 const BackendLocal = "local"
 
-// Backend configures one engine-scoped OpenAI-compatible backend.
-//
-// Backend has no stable JSON representation. Use keyed literals so additions
-// to this configuration value do not break source compatibility.
-type Backend struct {
-	// ID is the stable, case-sensitive registry key. NewEngine trims it and
-	// requires a non-blank value. Built-in backend IDs are reserved.
-	ID string
-	// Endpoint is the OpenAI-compatible base endpoint. NewEngine trims it and
-	// requires an absolute HTTP or HTTPS URL with a host and without user
-	// information, a query string, or a fragment. Paths are allowed.
-	Endpoint string
-	// APIKeyEnv optionally names an environment lookup source for an API key.
-	// NewEngine trims it and requires the portable form [A-Za-z_][A-Za-z0-9_]*.
-	// A direct RunRequest.APIKey takes precedence. When no usable credential is
-	// available, the built-in client omits Authorization; injected clients own
-	// their own credential-resolution behavior. Store only the name, never a
-	// credential value.
-	APIKeyEnv string
-	// ExtraParams contains backend-wide request defaults. Values must be
-	// JSON-compatible, finite, acyclic, and keyed by non-empty strings. Keys
-	// must not be model, session_id, messages, temperature, max_tokens, top_p,
-	// service_tier, reasoning_effort, or response_format. An empty map supplies
-	// no defaults. NewEngine deeply copies the map and rejects excessively deep
-	// or large values for safety.
-	ExtraParams map[string]any
-	// ConcurrencyLimit is the maximum number of simultaneous model-generation
-	// calls allowed for this backend within one Engine. Zero leaves the backend
-	// unlimited. A negative value makes NewEngine fail with ErrInvalidConfig.
-	ConcurrencyLimit int
-	// QueueCapacity controls how many additional Run or RunPrepared calls may
-	// be admitted beyond ConcurrencyLimit. Nil uses 1024 when ConcurrencyLimit
-	// is positive; a pointer uses its exact value, including zero. The pointed-to
-	// value must be non-negative, and QueueCapacity must be nil when
-	// ConcurrencyLimit is zero. Their sum must fit in an int. WithBackend copies
-	// the value and does not retain the pointer.
+// BackendConfig is a presence-aware convenience value for a keyed backend
+// definition. Nil pointer fields are omitted, while non-nil pointers preserve
+// explicit zero or blank values. A nil ExtraParams map is omitted; a non-nil
+// empty map supplies an empty mapping. Use raw ConfigKit Mapping inputs for
+// explicit null. BackendConfig has no stable JSON representation.
+type BackendConfig struct {
+	// Endpoint is the required absolute HTTP(S) base URL after all layers merge.
+	Endpoint *string
+	// APIKeyEnv optionally names an environment variable, not a credential.
+	APIKeyEnv *string
+	// ConcurrencyLimit is zero for unlimited generation; negative is invalid.
+	ConcurrencyLimit *int
+	// QueueCapacity defaults to 1024 for positive concurrency when omitted.
+	// An explicit value, including zero, requires positive concurrency.
 	QueueCapacity *int
+	// ExtraParams supplies JSON-compatible provider request defaults.
+	ExtraParams map[string]any
 }
 
-// LocalBackend returns a caller-owned Backend for a conventional local
-// OpenAI-compatible endpoint. It sets ID to BackendLocal and copies endpoint
-// and concurrencyLimit into Endpoint and ConcurrencyLimit without
-// normalization or validation. APIKeyEnv, ExtraParams, and QueueCapacity keep
-// their zero values.
-//
-// LocalBackend does not read environment variables, register the value, or
-// mutate engine or package state. Supply the returned value through
-// [WithBackend]; [NewEngine] then applies the ordinary backend validation and
-// concurrency semantics, including default queue capacity for a positive
-// limit, unlimited behavior for zero, and ErrInvalidConfig for a negative
-// limit.
-func LocalBackend(endpoint string, concurrencyLimit int) Backend {
-	return Backend{
-		ID:               BackendLocal,
-		Endpoint:         endpoint,
-		ConcurrencyLimit: concurrencyLimit,
+// BackendSource creates a labeled ConfigKit mapping from keyed backend values.
+// It encodes fields without validating them; NewEngine validates the final
+// effective configuration after all selected source layers are combined.
+// Mapping captures a copy of supported input values at creation; unsupported
+// values fail when the source is loaded.
+func BackendSource(label string, backends map[string]BackendConfig) configkit.Source {
+	definitions := make(map[string]any, len(backends))
+	for id, config := range backends {
+		fields := make(map[string]any)
+		if config.Endpoint != nil {
+			fields["endpoint"] = *config.Endpoint
+		}
+		if config.APIKeyEnv != nil {
+			fields["api_key_env"] = *config.APIKeyEnv
+		}
+		if config.ConcurrencyLimit != nil {
+			fields["concurrency_limit"] = *config.ConcurrencyLimit
+		}
+		if config.QueueCapacity != nil {
+			fields["queue_capacity"] = *config.QueueCapacity
+		}
+		if config.ExtraParams != nil {
+			fields["extra_params"] = providerMapForMapping(config.ExtraParams)
+		}
+		definitions[id] = fields
 	}
+	return configkit.Mapping(label, map[string]any{"backends": definitions})
 }
 
-// WithBackend adds one Backend registration to the constructed Engine.
-//
-// Registrations accumulate in option order. Every normalized ID must be unique
-// across consumer registrations and built-ins; a duplicate or invalid
-// definition makes NewEngine fail with ErrInvalidConfig. Built-in IDs,
-// including [BackendOpenRouter] and [BackendRakestrawHome], cannot be
-// replaced. The immutable registration is scoped to the resulting Engine and
-// cannot be enumerated, replaced, removed, or mutated after construction.
-// WithBackend does not install package-global state.
-func WithBackend(backend Backend) Option {
-	queueCapacity := 0
-	queueCapacitySet := backend.QueueCapacity != nil
-	if queueCapacitySet {
-		queueCapacity = *backend.QueueCapacity
-	}
-	return optionFunc(func(options *engineOptions) error {
-		options.internal.AddBackend(domain.Backend{
-			ID:               backend.ID,
-			Endpoint:         backend.Endpoint,
-			APIKeyEnv:        backend.APIKeyEnv,
-			ExtraParams:      backend.ExtraParams,
-			ConcurrencyLimit: backend.ConcurrencyLimit,
-			QueueCapacity:    queueCapacity,
-			QueueCapacitySet: queueCapacitySet,
-		})
-		return nil
-	})
+// LocalBackend supplies endpoint and concurrency pointers for a caller-chosen
+// backend ID; it does not select an ID or validate either value.
+func LocalBackend(endpoint string, concurrencyLimit int) BackendConfig {
+	return BackendConfig{Endpoint: &endpoint, ConcurrencyLimit: &concurrencyLimit}
 }

capacity_contract_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit"
 )
 
@@ -150,17 +151,7 @@ func TestUnlimitedBackendsRetainInjectedClientConcurrency(t *testing.T) {
 		{
 			name: "endpoint-only profile",
 			configure: func(t *testing.T, client promptkit.LLMClient) *promptkit.Engine {
-				engine, err := promptkit.NewEngine(promptkit.Config{},
-					promptkit.WithPromptFS(contractPromptFS("prompt", "profile", "message"), "."),
-					promptkit.WithProfiles(promptkit.Profile{
-						ID: "profile", Endpoint: "http://endpoint.example/v1", Model: "model",
-					}),
-					promptkit.WithLLMClient(client),
-				)
-				if err != nil {
-					t.Fatalf("construct endpoint-only engine: %v", err)
-				}
-				return engine
+				return newSimpleEngine(t, "message", promptkit.WithLLMClient(client))
 			},
 		},
 	}
@@ -250,27 +241,35 @@ func newBackendCapacityEngine(
 	reader promptkit.ArtifactReader,
 ) *promptkit.Engine {
 	t.Helper()
-	promptFS := contractPromptFS("prompt", "profile", "message")
+	promptID, content := "prompt", "message"
+	var inputs []any
 	if reader != nil {
-		promptFS = contractInputPromptFS()
+		promptID, content = "input-prompt", `{{input "input"}}`
+		inputs = []any{map[string]any{"name": "input", "required": true}}
 	}
-	options := []promptkit.Option{
-		promptkit.WithPromptFS(promptFS, "."),
-		promptkit.WithBackend(promptkit.Backend{
-			ID:               "limited",
-			Endpoint:         "http://backend.example/v1",
-			ConcurrencyLimit: limit,
-			QueueCapacity:    queueCapacity,
-		}),
-		promptkit.WithProfiles(promptkit.Profile{
-			ID: "profile", BackendID: "limited", Model: "model",
-		}),
-		promptkit.WithLLMClient(client),
+	backend := map[string]any{"endpoint": "http://backend.example/v1", "concurrency_limit": limit}
+	if queueCapacity != nil {
+		backend["queue_capacity"] = *queueCapacity
 	}
+	definition := map[string]any{
+		"default_profile": "profile",
+		"messages":        []any{map[string]any{"role": "user", "content": content}},
+		"output":          map[string]any{"format": "text", "validation_mode": "none"},
+	}
+	if inputs != nil {
+		definition["inputs"] = inputs
+	}
+	options := []promptkit.Option{promptkit.WithLLMClient(client)}
 	if reader != nil {
 		options = append(options, promptkit.WithArtifactReader(reader))
 	}
-	engine, err := promptkit.NewEngine(promptkit.Config{}, options...)
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &configkit.Input{
+		Source: configkit.Mapping("capacity fixture", map[string]any{
+			"backends": map[string]any{"limited": backend},
+			"profiles": map[string]any{"profile": map[string]any{"backend": "limited", "model": "model"}},
+			"prompts":  map[string]any{promptID: map[string]any{"1": definition}},
+		}),
+	}}}, options...)
 	if err != nil {
 		t.Fatalf("construct capacity engine: %v", err)
 	}

configuration_diff_contract_test.go

@@ -0,0 +1,243 @@
+package promptkit_test
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+func TestConfigurationInspectionDiffsCapturedValues(t *testing.T) {
+	left := comparisonInspection(t, "earlier-model")
+	right := comparisonInspection(t, "later-model")
+
+	differences, err := left.Diff(right)
+	if err != nil {
+		t.Fatalf("compare captured configurations: %v", err)
+	}
+	if len(differences) != 1 {
+		t.Fatalf("difference count = %d, want 1: %+v", len(differences), differences)
+	}
+	difference := differences[0]
+	if got, want := difference.Path.String(), "/profiles/offline/model"; got != want {
+		t.Fatalf("difference path = %q, want %q", got, want)
+	}
+	if !strings.Contains(difference.Left.YAML, "earlier-model") || !strings.Contains(difference.Right.YAML, "later-model") {
+		t.Fatalf("difference snapshots = (%q, %q)", difference.Left.YAML, difference.Right.YAML)
+	}
+
+	reversed, err := right.Diff(left)
+	if err != nil {
+		t.Fatalf("compare reversed configurations: %v", err)
+	}
+	if len(reversed) != 1 || reversed[0].Path.String() != difference.Path.String() ||
+		!strings.Contains(reversed[0].Left.YAML, "later-model") ||
+		!strings.Contains(reversed[0].Right.YAML, "earlier-model") {
+		t.Fatalf("reversed difference = %+v", reversed)
+	}
+
+	equal := comparisonInspection(t, "earlier-model")
+	if equal, err := left.Diff(equal); err != nil || len(equal) != 0 {
+		t.Fatalf("compare equal configurations = (%+v, %v), want no differences", equal, err)
+	}
+	if equal, err := left.Diff(left); err != nil || len(equal) != 0 {
+		t.Fatalf("compare view with itself = (%+v, %v), want no differences", equal, err)
+	}
+}
+
+func TestConfigurationInspectionDiffRejectsZeroViews(t *testing.T) {
+	valid := comparisonInspection(t, "current-model")
+	var zero promptkit.ConfigurationInspection
+
+	for _, comparison := range []struct {
+		name        string
+		left, right promptkit.ConfigurationInspection
+	}{
+		{name: "zero left", left: zero, right: valid},
+		{name: "zero right", left: valid, right: zero},
+		{name: "both zero", left: zero, right: zero},
+	} {
+		t.Run(comparison.name, func(t *testing.T) {
+			differences, err := comparison.left.Diff(comparison.right)
+			if !errors.Is(err, promptkit.ErrInvalidConfig) || len(differences) != 0 {
+				t.Fatalf("Diff() = (%+v, %v), want ErrInvalidConfig and no records", differences, err)
+			}
+		})
+	}
+}
+
+func TestConfigurationInspectionDiffIgnoresSourceHistory(t *testing.T) {
+	left := comparisonInspectionFrom(t, "earlier source", "same-model", nil)
+	right := comparisonInspectionFrom(t, "later source", "same-model", nil)
+	if !hasSourceLabel(left, "earlier source") || !hasSourceLabel(right, "later source") {
+		t.Fatal("comparison fixtures did not retain their distinct source labels")
+	}
+
+	differences, err := left.Diff(right)
+	if err != nil || len(differences) != 0 {
+		t.Fatalf("compare equal effective values with different sources = (%+v, %v), want no differences", differences, err)
+	}
+}
+
+func TestConfigurationInspectionDiffReportsPresenceAndSequences(t *testing.T) {
+	left := comparisonInspectionFrom(t, "before", "same-model", map[string]any{
+		"sequence": []any{"earlier", "unchanged"},
+	})
+	right := comparisonInspectionFrom(t, "after", "same-model", map[string]any{
+		"nullable": nil,
+		"sequence": []any{"later", "unchanged"},
+	})
+
+	differences, err := left.Diff(right)
+	if err != nil {
+		t.Fatalf("compare presence and sequence values: %v", err)
+	}
+	if len(differences) != 2 {
+		t.Fatalf("difference count = %d, want 2: %+v", len(differences), differences)
+	}
+	byPath := differencesByPath(differences)
+	nullable, ok := byPath["/backends/local/extra_params/nullable"]
+	if !ok || nullable.Left.Present || !nullable.Right.Present || strings.TrimSpace(nullable.Right.YAML) != "null" {
+		t.Fatalf("absent-to-null difference = (%+v, %t)", nullable, ok)
+	}
+	sequence, ok := byPath["/backends/local/extra_params/sequence"]
+	if !ok || !sequence.Left.Present || !sequence.Right.Present ||
+		!strings.Contains(sequence.Left.YAML, "earlier") || !strings.Contains(sequence.Right.YAML, "later") {
+		t.Fatalf("atomic sequence difference = (%+v, %t)", sequence, ok)
+	}
+}
+
+func TestConfigurationInspectionDiffProtectsSensitiveValuesAndReturnedRecords(t *testing.T) {
+	left := comparisonInspectionFrom(t, "before", "same-model", map[string]any{
+		"token":   "left-secret-sentinel",
+		"visible": "before-value",
+	})
+	right := comparisonInspectionFrom(t, "after", "same-model", map[string]any{
+		"token":   "right-secret-sentinel",
+		"visible": "after-value",
+	})
+
+	differences, err := left.Diff(right)
+	if err != nil {
+		t.Fatalf("compare sensitive values: %v", err)
+	}
+	if len(differences) != 2 {
+		t.Fatalf("difference count = %d, want 2: %+v", len(differences), differences)
+	}
+	byPath := differencesByPath(differences)
+	secret, ok := byPath["/backends/local/extra_params/token"]
+	if !ok || !secret.Left.Redacted || !secret.Right.Redacted || !secret.HiddenChanged {
+		t.Fatalf("sensitive difference = (%+v, %t)", secret, ok)
+	}
+	if strings.Contains(secret.Left.YAML, "left-secret-sentinel") || strings.Contains(secret.Left.YAML, "right-secret-sentinel") ||
+		strings.Contains(secret.Right.YAML, "left-secret-sentinel") || strings.Contains(secret.Right.YAML, "right-secret-sentinel") {
+		t.Fatalf("sensitive snapshots disclosed a value: %+v", secret)
+	}
+	visible, ok := byPath["/backends/local/extra_params/visible"]
+	if !ok || visible.Left.Redacted || visible.Right.Redacted || visible.HiddenChanged ||
+		!strings.Contains(visible.Left.YAML, "before-value") || !strings.Contains(visible.Right.YAML, "after-value") {
+		t.Fatalf("public sibling difference = (%+v, %t)", visible, ok)
+	}
+
+	differences[0].Path = configkit.Keys("caller", "mutation")
+	differences[0].Left.YAML = "caller mutation"
+	differences[0].Right.YAML = "caller mutation"
+	again, err := left.Diff(right)
+	if err != nil {
+		t.Fatalf("repeat comparison after mutating returned records: %v", err)
+	}
+	if len(again) != 2 {
+		t.Fatalf("repeat difference count = %d, want 2: %+v", len(again), again)
+	}
+	againByPath := differencesByPath(again)
+	if _, exists := againByPath["/caller/mutation"]; exists {
+		t.Fatal("mutating returned path reached retained inspection")
+	}
+	if _, exists := againByPath["/backends/local/extra_params/token"]; !exists {
+		t.Fatalf("original sensitive path was lost after mutation: %+v", again)
+	}
+	if _, exists := againByPath["/backends/local/extra_params/visible"]; !exists {
+		t.Fatalf("original public path was lost after mutation: %+v", again)
+	}
+	for _, difference := range again {
+		if difference.Left.YAML == "caller mutation" || difference.Right.YAML == "caller mutation" {
+			t.Fatalf("mutating returned snapshots reached retained inspection: %+v", difference)
+		}
+	}
+}
+
+func TestConfigurationInspectionDiffMasksSensitiveShapeReplacement(t *testing.T) {
+	left := comparisonInspectionFrom(t, "before", "same-model", map[string]any{
+		"details": map[string]any{
+			"token": "nested-secret-sentinel",
+			"label": "public detail",
+		},
+	})
+	right := comparisonInspectionFrom(t, "after", "same-model", map[string]any{
+		"details": "replacement",
+	})
+
+	differences, err := left.Diff(right)
+	if err != nil {
+		t.Fatalf("compare sensitive shape replacement: %v", err)
+	}
+	if len(differences) != 1 || differences[0].Path.String() != "/backends/local/extra_params/details" {
+		t.Fatalf("shape replacement differences = %+v", differences)
+	}
+	difference := differences[0]
+	if !difference.Left.Redacted || !difference.Right.Redacted || !difference.HiddenChanged {
+		t.Fatalf("shape replacement masking = %+v", difference)
+	}
+	if strings.Contains(difference.Left.YAML, "nested-secret-sentinel") || strings.Contains(difference.Right.YAML, "nested-secret-sentinel") {
+		t.Fatalf("shape replacement disclosed a sensitive value: %+v", difference)
+	}
+}
+
+func comparisonInspection(t *testing.T, model string) promptkit.ConfigurationInspection {
+	t.Helper()
+	return comparisonInspectionFrom(t, "comparison fixture", model, nil)
+}
+
+func comparisonInspectionFrom(t *testing.T, source, model string, extraParams map[string]any) promptkit.ConfigurationInspection {
+	t.Helper()
+	backend := map[string]any{"endpoint": "https://example.invalid/v1"}
+	if extraParams != nil {
+		backend["extra_params"] = extraParams
+	}
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: configkit.Mapping(source, map[string]any{
+			"backends": map[string]any{"local": backend},
+			"profiles": map[string]any{"offline": map[string]any{
+				"backend": "local",
+				"model":   model,
+			}},
+		})}}}},
+	}})
+	if err != nil {
+		t.Fatalf("construct comparison engine: %v", err)
+	}
+	inspection, err := engine.InspectConfiguration()
+	if err != nil {
+		t.Fatalf("inspect comparison engine: %v", err)
+	}
+	return inspection
+}
+
+func differencesByPath(differences []configkit.Difference) map[string]configkit.Difference {
+	byPath := make(map[string]configkit.Difference, len(differences))
+	for _, difference := range differences {
+		byPath[difference.Path.String()] = difference
+	}
+	return byPath
+}
+
+func hasSourceLabel(view promptkit.ConfigurationInspection, label string) bool {
+	for _, source := range view.Sources() {
+		if source.Label == label {
+			return true
+		}
+	}
+	return false
+}

configuration_inspection.go

@@ -0,0 +1,99 @@
+package promptkit
+
+import (
+	"fmt"
+	"io"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/configuration"
+)
+
+// ConfigurationInspection is a read-only view of one Engine's captured
+// effective configuration and source history. It does not expose typed
+// configuration values, filesystem contexts, or runtime credentials.
+// Report content may include application prompt and provider data, so callers
+// choose where and to whom to disclose it.
+type ConfigurationInspection struct {
+	source configuration.Inspection
+}
+
+// InspectConfiguration returns the ConfigKit inspection view captured by this
+// Engine. It does not reload sources, resolve credentials, or contact a model.
+// A nil Engine returns ErrInvalidConfig.
+func (e *Engine) InspectConfiguration() (ConfigurationInspection, error) {
+	if e == nil || e.internal == nil {
+		return ConfigurationInspection{}, fmt.Errorf("%w: engine is nil", ErrInvalidConfig)
+	}
+	return ConfigurationInspection{source: e.internal.InspectConfiguration()}, nil
+}
+
+// Diff compares this view's captured effective configuration with other. This
+// view is the earlier (left) value and other is the later (right) value. The
+// comparison delegates to ConfigKit's frozen effective-value semantics, so
+// source or resolution history alone does not create differences. It does not
+// reread external sources or compare referenced file contents, resolved
+// credential contents, later execution preparation, or request-specific
+// overrides. Either zero view returns ErrInvalidConfig and no records; other
+// ConfigKit errors are returned unchanged. An empty diff is not evidence of
+// equivalent engine behavior or execution. Records can contain ordinary
+// application data, so callers choose where and to whom to disclose them.
+func (v ConfigurationInspection) Diff(other ConfigurationInspection) ([]configkit.Difference, error) {
+	if v.source == nil || other.source == nil {
+		return nil, ErrInvalidConfig
+	}
+	return configuration.Diff(v.source, other.source)
+}
+
+// Metadata returns detached effective presence and history records.
+func (v ConfigurationInspection) Metadata() configkit.Metadata {
+	if v.source == nil {
+		return configkit.Metadata{}
+	}
+	return v.source.Metadata()
+}
+
+// Sources returns a detached list of loaded source descriptions.
+func (v ConfigurationInspection) Sources() []configkit.SourceInfo {
+	if v.source == nil {
+		return nil
+	}
+	return v.source.Sources()
+}
+
+// Diagnostics returns detached nonfatal load diagnostics.
+func (v ConfigurationInspection) Diagnostics() []configkit.Diagnostic {
+	if v.source == nil {
+		return nil
+	}
+	return v.source.Diagnostics()
+}
+
+// Explain returns detached effective and historical values for a known path.
+// Dynamic credential-shaped provider keys are redacted by ConfigKit; ordinary
+// prompt and provider content is not automatically safe to disclose.
+func (v ConfigurationInspection) Explain(path configkit.Path) (configkit.Explanation, bool) {
+	if v.source == nil {
+		return configkit.Explanation{}, false
+	}
+	return v.source.Explain(path)
+}
+
+// WriteEffective writes ConfigKit's redacted effective YAML. Writer errors
+// remain available through errors.Is and errors.As. The zero view returns
+// ErrInvalidConfig.
+func (v ConfigurationInspection) WriteEffective(w io.Writer) error {
+	if v.source == nil {
+		return ErrInvalidConfig
+	}
+	return v.source.WriteEffective(w)
+}
+
+// WriteExplanation writes ConfigKit's redacted history for path. Unknown paths
+// produce no output; writer errors remain inspectable. The zero view returns
+// ErrInvalidConfig.
+func (v ConfigurationInspection) WriteExplanation(w io.Writer, path configkit.Path) error {
+	if v.source == nil {
+		return ErrInvalidConfig
+	}
+	return v.source.WriteExplanation(w, path)
+}

configuration_inspection_contract_test.go

@@ -0,0 +1,247 @@
+package promptkit_test
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+func TestConfigurationInspectionReportsLiteralKeysAndRedactedHistory(t *testing.T) {
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{
+			{Inputs: []configkit.Input{{Source: configkit.Mapping("defaults", map[string]any{
+				"backends": map[string]any{"local": map[string]any{
+					"endpoint": "https://example.invalid/v1", "api_key_env": "OPTIONAL_KEY",
+					"extra_params": map[string]any{"token": "private-sentinel", "visible": "public-value"},
+				}},
+				"profiles": map[string]any{
+					"base.v1":    map[string]any{"backend": "local", "model": "default-model"},
+					"literal/id": map[string]any{"extends": "base.v1"},
+				},
+			})}}},
+			{Inputs: []configkit.Input{{Source: configkit.Mapping("operator", map[string]any{
+				"profiles": map[string]any{"base.v1": map[string]any{"model": "operator-model"}},
+			})}}},
+		},
+	}})
+	if err != nil {
+		t.Fatalf("construct layered engine: %v", err)
+	}
+	view, err := engine.InspectConfiguration()
+	if err != nil {
+		t.Fatalf("inspect configuration: %v", err)
+	}
+	modelPath := configkit.Keys("profiles", "base.v1", "model")
+	model, found := view.Explain(modelPath)
+	if !found || !strings.Contains(model.Effective.YAML, "operator-model") || len(model.History) < 2 {
+		t.Fatalf("layered model explanation = (%+v, %t)", model, found)
+	}
+	inheritedPath := configkit.Keys("profiles", "literal/id", "model")
+	inherited, found := view.Explain(inheritedPath)
+	if !found || !strings.Contains(inherited.Effective.YAML, "operator-model") || len(inherited.History) == 0 || !view.Metadata().IsExplicit(inheritedPath) {
+		t.Fatalf("literal-key inheritance explanation = (%+v, %t)", inherited, found)
+	}
+	if inheritedPath.String() != "/profiles/literal~1id/model" {
+		t.Fatalf("literal-key path = %q", inheritedPath)
+	}
+	secretPath := configkit.Keys("backends", "local", "extra_params", "token")
+	secret, found := view.Explain(secretPath)
+	if !found || !secret.Effective.Redacted || strings.Contains(secret.Effective.YAML, "private-sentinel") {
+		t.Fatalf("credential-shaped provider value was not redacted: (%+v, %t)", secret, found)
+	}
+	var effective bytes.Buffer
+	if err := view.WriteEffective(&effective); err != nil {
+		t.Fatalf("write effective configuration: %v", err)
+	}
+	if strings.Contains(effective.String(), "private-sentinel") || !strings.Contains(effective.String(), "OPTIONAL_KEY") || !strings.Contains(effective.String(), "public-value") {
+		t.Fatalf("unexpected effective report: %s", effective.String())
+	}
+	var explanation bytes.Buffer
+	if err := view.WriteExplanation(&explanation, secretPath); err != nil || strings.Contains(explanation.String(), "private-sentinel") {
+		t.Fatalf("secret explanation = (%q, %v)", explanation.String(), err)
+	}
+
+	sources := view.Sources()
+	if len(sources) == 0 {
+		t.Fatal("inspection returned no sources")
+	}
+	originalLabel := sources[0].Label
+	sources[0].Label = "changed"
+	if view.Sources()[0].Label != originalLabel {
+		t.Fatal("source mutation reached retained inspection")
+	}
+	model.History[0].After.YAML = "changed"
+	if again, ok := view.Explain(modelPath); !ok || again.History[0].After.YAML == "changed" {
+		t.Fatal("explanation mutation reached retained inspection")
+	}
+	history := view.Metadata().History(modelPath)
+	if len(history) == 0 {
+		t.Fatal("metadata history is empty")
+	}
+	history[0].Reasons = []string{"changed"}
+	if again := view.Metadata().History(modelPath); len(again) == 0 || (len(again[0].Reasons) > 0 && again[0].Reasons[0] == "changed") {
+		t.Fatal("metadata mutation reached retained inspection")
+	}
+}
+
+type failingInspectionWriter struct{ err error }
+
+func (writer failingInspectionWriter) Write([]byte) (int, error) { return 0, writer.err }
+
+func TestConfigurationInspectionZeroAndWriterErrors(t *testing.T) {
+	var engine *promptkit.Engine
+	if _, err := engine.InspectConfiguration(); !errors.Is(err, promptkit.ErrInvalidConfig) {
+		t.Fatalf("nil engine inspection = %v", err)
+	}
+	var empty promptkit.ConfigurationInspection
+	path := configkit.Keys("profiles", "missing")
+	if _, found := empty.Metadata().Lookup(path); found || len(empty.Sources()) != 0 || len(empty.Diagnostics()) != 0 {
+		t.Fatal("zero inspection reported configuration")
+	}
+	if _, found := empty.Explain(path); found {
+		t.Fatal("zero inspection explained an unknown path")
+	}
+	if err := empty.WriteEffective(io.Discard); !errors.Is(err, promptkit.ErrInvalidConfig) {
+		t.Fatalf("zero effective writer = %v", err)
+	}
+	if err := empty.WriteExplanation(io.Discard, path); !errors.Is(err, promptkit.ErrInvalidConfig) {
+		t.Fatalf("zero explanation writer = %v", err)
+	}
+
+	valid, err := promptkit.NewEngine(promptkit.Config{})
+	if err != nil {
+		t.Fatalf("construct engine: %v", err)
+	}
+	view, err := valid.InspectConfiguration()
+	if err != nil {
+		t.Fatalf("inspect configuration: %v", err)
+	}
+	writeErr := errors.New("report writer failed")
+	writer := failingInspectionWriter{err: writeErr}
+	if err := view.WriteEffective(writer); !errors.Is(err, writeErr) {
+		t.Fatalf("effective writer error = %v", err)
+	}
+	if err := view.WriteExplanation(writer, configkit.Keys("profiles", "mistral-small-3", "model")); !errors.Is(err, writeErr) {
+		t.Fatalf("explanation writer error = %v", err)
+	}
+}
+
+func TestConfigurationInspectionUsesCapturedSourcesWithoutProviderCalls(t *testing.T) {
+	source := &unreadableAfterConstructionFS{FS: fstest.MapFS{
+		"config/prompt.yaml": &fstest.MapFile{Data: []byte(capturedPromptDocument)},
+		"config/body.tmpl":   &fstest.MapFile{Data: []byte("hello")},
+	}}
+	inputs, err := promptkit.FilesystemInputs("inspection source", source, "config")
+	if err != nil {
+		t.Fatalf("select inputs: %v", err)
+	}
+	otherSource := &unreadableAfterConstructionFS{FS: fstest.MapFS{
+		"config/prompt.yaml": &fstest.MapFile{Data: []byte(capturedPromptDocument)},
+		"config/body.tmpl":   &fstest.MapFile{Data: []byte("hello")},
+	}}
+	otherInputs, err := promptkit.FilesystemInputs("comparison source", otherSource, "config")
+	if err != nil {
+		t.Fatalf("select comparison inputs: %v", err)
+	}
+	var modelCalls atomic.Int64
+	client := countingLLMClient{calls: &modelCalls}
+	endpoint, model, otherModel := "https://example.invalid/v1", "offline-model", "comparison-model"
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: inputs}, {Inputs: []configkit.Input{{Source: promptkit.ProfileSource("offline profile", map[string]promptkit.ProfileConfig{
+			"offline": {Endpoint: &endpoint, Model: &model},
+		})}}}},
+	}}, promptkit.WithLLMClient(client))
+	if err != nil {
+		t.Fatalf("construct engine: %v", err)
+	}
+	otherEngine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: otherInputs}, {Inputs: []configkit.Input{{Source: promptkit.ProfileSource("comparison profile", map[string]promptkit.ProfileConfig{
+			"offline": {Endpoint: &endpoint, Model: &otherModel},
+		})}}}},
+	}}, promptkit.WithLLMClient(client))
+	if err != nil {
+		t.Fatalf("construct comparison engine: %v", err)
+	}
+	source.closed.Store(true)
+	otherSource.closed.Store(true)
+	view, err := engine.InspectConfiguration()
+	if err != nil {
+		t.Fatalf("inspect configuration: %v", err)
+	}
+	otherView, err := otherEngine.InspectConfiguration()
+	if err != nil {
+		t.Fatalf("inspect comparison configuration: %v", err)
+	}
+	var expected configkit.Difference
+	for index := 0; index < 3; index++ {
+		differences, err := view.Diff(otherView)
+		if err != nil || len(differences) != 1 {
+			t.Fatalf("compare captured configurations = (%+v, %v), want one difference", differences, err)
+		}
+		if differences[0].Path.String() != "/profiles/offline/model" ||
+			!strings.Contains(differences[0].Left.YAML, model) ||
+			!strings.Contains(differences[0].Right.YAML, otherModel) {
+			t.Fatalf("captured difference = %+v", differences[0])
+		}
+		if index == 0 {
+			expected = differences[0]
+		} else if differences[0].Path.String() != expected.Path.String() ||
+			differences[0].Left.YAML != expected.Left.YAML || differences[0].Right.YAML != expected.Right.YAML {
+			t.Fatalf("captured difference changed between reads: first=%+v next=%+v", expected, differences[0])
+		}
+	}
+	if _, found := view.Explain(configkit.Keys("prompts", "captured", "1", "messages").Index(0).Key("content_file")); !found {
+		t.Fatal("captured prompt content path was not inspectable")
+	}
+	var report bytes.Buffer
+	if err := view.WriteEffective(&report); err != nil || !strings.Contains(report.String(), "captured") {
+		t.Fatalf("write captured report = (%q, %v)", report.String(), err)
+	}
+	if source.reads.Load() != 0 || otherSource.reads.Load() != 0 || modelCalls.Load() != 0 {
+		t.Fatalf("inspection or comparison touched source or provider: reads=(%d,%d) requests=%d", source.reads.Load(), otherSource.reads.Load(), modelCalls.Load())
+	}
+
+	const calls = 24
+	var wait sync.WaitGroup
+	errs := make(chan error, calls)
+	for index := 0; index < calls; index++ {
+		wait.Add(1)
+		go func(index int) {
+			defer wait.Done()
+			switch index % 3 {
+			case 0:
+				_, err := engine.InspectConfiguration()
+				errs <- err
+			case 1:
+				_, err := engine.Run(context.Background(), promptkit.RunRequest{PromptID: "captured", SessionID: "direct"})
+				errs <- err
+			case 2:
+				differences, err := view.Diff(otherView)
+				if err == nil && (len(differences) != 1 || differences[0].Path.String() != expected.Path.String() ||
+					differences[0].Left.YAML != expected.Left.YAML || differences[0].Right.YAML != expected.Right.YAML) {
+					err = errors.New("concurrent comparison returned an unexpected difference")
+				}
+				errs <- err
+			}
+		}(index)
+	}
+	wait.Wait()
+	close(errs)
+	for err := range errs {
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	if source.reads.Load() != 0 || otherSource.reads.Load() != 0 || modelCalls.Load() != calls/3 {
+		t.Fatalf("concurrent inspection/comparison/execution = source reads (%d,%d), model calls %d", source.reads.Load(), otherSource.reads.Load(), modelCalls.Load())
+	}
+}

configuration_sources.go

@@ -0,0 +1,83 @@
+package promptkit
+
+import (
+	"context"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/filecatalog"
+)
+
+// DirectoryInputs selects the YAML files beneath an explicitly chosen host
+// directory as one strict-composition group. The returned order is deterministic;
+// it does not assign precedence among those files. Discovery is recursive over
+// .yaml and .yml files. An unavailable root fails; an empty directory yields
+// no inputs. Imports are disabled unless callers enable them on the inputs.
+func DirectoryInputs(directory string) ([]configkit.Input, error) {
+	root, err := filepath.Abs(directory)
+	if err != nil {
+		return nil, fmt.Errorf("resolve configuration directory: %w", err)
+	}
+	info, err := os.Stat(root)
+	if err != nil {
+		return nil, fmt.Errorf("inspect configuration directory: %w", err)
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("configuration root is not a directory: %s", root)
+	}
+	root, err = filepath.EvalSymlinks(root)
+	if err != nil {
+		return nil, fmt.Errorf("resolve configuration directory: %w", err)
+	}
+	files, err := filecatalog.FindYAMLFiles(context.Background(), root)
+	if err != nil {
+		return nil, fmt.Errorf("discover configuration files: %w", err)
+	}
+	inputs := make([]configkit.Input, 0, len(files))
+	for _, file := range files {
+		inputs = append(inputs, configkit.Input{
+			Source:     configkit.File(file),
+			Filesystem: &configkit.FilesystemContext{Root: root},
+		})
+	}
+	return inputs, nil
+}
+
+// FilesystemInputs selects the YAML files beneath root in a caller-owned
+// filesystem as one strict-composition group. Discovery is recursive over
+// .yaml and .yml files, with deterministic ordering and no precedence among
+// files. The caller retains ownership of the filesystem; an unavailable root
+// fails and an empty directory yields no inputs. Imports remain disabled unless
+// callers enable them on inputs.
+func FilesystemInputs(label string, filesystem fs.FS, root string) ([]configkit.Input, error) {
+	if filesystem == nil {
+		return nil, fmt.Errorf("configuration filesystem is nil")
+	}
+	root = filecatalog.CleanFSRoot(root)
+	if !fs.ValidPath(root) {
+		return nil, fmt.Errorf("configuration root is not a valid filesystem path: %s", root)
+	}
+	info, err := fs.Stat(filesystem, root)
+	if err != nil {
+		return nil, fmt.Errorf("inspect configuration root: %w", err)
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("configuration root is not a directory: %s", root)
+	}
+	files, err := filecatalog.FindFSYAMLFiles(context.Background(), filesystem, root)
+	if err != nil {
+		return nil, fmt.Errorf("discover configuration files: %w", err)
+	}
+	namespace := configkit.NewFilesystem(label, filesystem)
+	inputs := make([]configkit.Input, 0, len(files))
+	for _, file := range files {
+		inputs = append(inputs, configkit.Input{
+			Source:     namespace.File(file),
+			Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: root},
+		})
+	}
+	return inputs, nil
+}

configuration_sources_test.go

@@ -0,0 +1,83 @@
+package promptkit_test
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+type sourceDocument struct {
+	First  string `yaml:"first"`
+	Second string `yaml:"second"`
+}
+
+func TestDirectoryInputsSelectsSortedFilesWithRootContext(t *testing.T) {
+	root := t.TempDir()
+	if err := os.Mkdir(filepath.Join(root, "nested"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	for name, data := range map[string]string{
+		"a.yaml": "first: one\n", "nested/b.yml": "second: two\n", "nested/body.md": "message",
+	} {
+		if err := os.WriteFile(filepath.Join(root, name), []byte(data), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	inputs, err := promptkit.DirectoryInputs(root)
+	if err != nil || len(inputs) != 2 || inputs[0].Imports || inputs[1].Imports {
+		t.Fatalf("directory inputs: %+v, %v", inputs, err)
+	}
+	assertSourceInputs(t, inputs, "message")
+	if _, err := promptkit.DirectoryInputs(filepath.Join(root, "missing")); err == nil {
+		t.Fatal("missing selected directory succeeded")
+	}
+	if empty, err := promptkit.DirectoryInputs(t.TempDir()); err != nil || len(empty) != 0 {
+		t.Fatalf("empty directory: %+v, %v", empty, err)
+	}
+}
+
+func TestFilesystemInputsSelectsEmbeddedFilesWithRootContext(t *testing.T) {
+	files := fstest.MapFS{
+		"settings/a.yaml":         {Data: []byte("first: one\n")},
+		"settings/nested/b.yml":   {Data: []byte("second: two\n")},
+		"settings/nested/body.md": {Data: []byte("message")},
+	}
+	inputs, err := promptkit.FilesystemInputs("embedded", files, "settings")
+	if err != nil || len(inputs) != 2 || inputs[0].Imports || inputs[1].Imports {
+		t.Fatalf("filesystem inputs: %+v, %v", inputs, err)
+	}
+	assertSourceInputs(t, inputs, "message")
+	if _, err := promptkit.FilesystemInputs("embedded", files, "missing"); err == nil {
+		t.Fatal("missing selected root succeeded")
+	}
+}
+
+func assertSourceInputs(t *testing.T, inputs []configkit.Input, expected string) {
+	t.Helper()
+	result, err := configkit.LoadLayered(configkit.Input{Source: configkit.NoSource()}, configkit.LayeredOptions[sourceDocument]{
+		Underlays: []configkit.Underlay{{Inputs: inputs}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Config.First != "one" || result.Config.Second != "two" {
+		t.Fatalf("configuration files did not compose: %+v", result.Config)
+	}
+	field, found := result.Metadata().Lookup(configkit.Keys("second"))
+	if !found || len(field.Origin.Locations) != 1 {
+		t.Fatalf("missing second-field origin: %+v", field)
+	}
+	context, found := result.SourceContext(field.Origin.Locations[0].SourceID)
+	if !found || context.BaseDir != "nested" {
+		t.Fatalf("unexpected rooted source context: %+v", context)
+	}
+	data, err := fs.ReadFile(context.FS, "nested/body.md")
+	if err != nil || string(data) != expected {
+		t.Fatalf("rooted resource read: %q, %v", data, err)
+	}
+}

construction_contract_test.go

@@ -0,0 +1,231 @@
+package promptkit_test
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+func TestProfileEnvironmentLookupAcceptsNonShellNames(t *testing.T) {
+	const name = "promptkit.test-api-key"
+	for _, test := range []struct {
+		name, value, direct, want string
+		unset, clear              bool
+	}{
+		{name: "set", value: " synthetic-key ", want: "Bearer synthetic-key"},
+		{name: "empty"},
+		{name: "whitespace", value: "  "},
+		{name: "unset", unset: true},
+		{name: "direct precedence", value: "synthetic-key", direct: "direct-key", want: "Bearer direct-key"},
+		{name: "explicit clear", value: "synthetic-key", clear: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			t.Setenv(name, test.value)
+			if test.unset {
+				if err := os.Unsetenv(name); err != nil {
+					t.Fatal(err)
+				}
+			}
+			cfg := simpleConfig("hello")
+			cfg.Sources.Underlays = []configkit.Underlay{{Inputs: []configkit.Input{*cfg.Sources.Main}}}
+			lowerName := name
+			cfg.Sources.Underlays = append(cfg.Sources.Underlays, configkit.Underlay{Inputs: []configkit.Input{{
+				Source: promptkit.ProfileSource("default credentials", map[string]promptkit.ProfileConfig{
+					"profile": {APIKeyEnv: &lowerName},
+				}),
+			}}})
+			env := " " + name + " "
+			if test.clear {
+				env = ""
+			}
+			cfg.Sources.Main = &configkit.Input{Source: promptkit.ProfileSource("credentials", map[string]promptkit.ProfileConfig{
+				"profile": {APIKeyEnv: &env},
+			})}
+			var calls int
+			var auth string
+			cfg.HTTPClient = &http.Client{Transport: roundTripFunc(func(request *http.Request) (*http.Response, error) {
+				calls++
+				auth = request.Header.Get("Authorization")
+				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(`{"choices":[{"message":{"content":"ok"}}]}`))}, nil
+			})}
+			engine, err := promptkit.NewEngine(cfg)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = engine.Run(context.Background(), promptkit.RunRequest{PromptID: "prompt", APIKey: test.direct})
+			if err != nil || calls != 1 || auth != test.want {
+				t.Fatalf("run: err=%v calls=%d authorization=%q, want %q", err, calls, auth, test.want)
+			}
+		})
+	}
+}
+
+func TestPublicConstructionWithLocalBackendAndProgrammaticProfile(t *testing.T) {
+	backendID, model := "workstation", "offline-model"
+	prompt := configkit.Input{Source: configkit.Mapping("prompt", map[string]any{
+		"prompts": map[string]any{"hello": map[string]any{"1": map[string]any{
+			"default_profile": "offline",
+			"messages":        []any{map[string]any{"role": "user", "content": "Hello"}},
+			"output":          map[string]any{"format": "text", "validation_mode": "none"},
+		}}},
+	})}
+	client := &fakeLLMClient{response: &promptkit.GenerateResponse{Content: "reply"}}
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: []configkit.Input{
+			{Source: promptkit.BackendSource("local backend", map[string]promptkit.BackendConfig{
+				backendID: promptkit.LocalBackend("http://localhost:8000/v1", 2),
+			})},
+			{Source: promptkit.ProfileSource("profile", map[string]promptkit.ProfileConfig{
+				"offline": {Backend: &backendID, Model: &model},
+			})},
+		}}},
+		Main: &prompt,
+	}}, promptkit.WithLLMClient(client))
+	if err != nil {
+		t.Fatalf("construct engine: %v", err)
+	}
+	result, err := engine.Run(context.Background(), promptkit.RunRequest{PromptID: "hello"})
+	if err != nil {
+		t.Fatalf("run prompt: %v", err)
+	}
+	if result.RawOutput != "reply" || result.SelectedBackendID != backendID || result.EffectiveModelParams.Model != model {
+		t.Fatalf("unexpected result: %+v", result)
+	}
+	if len(client.requests) != 1 || client.requests[0].Target.Endpoint != "http://localhost:8000/v1" {
+		t.Fatalf("unexpected model request: %+v", client.requests)
+	}
+}
+
+func TestPublicConstructionCombinesEmbeddedOperatorAndProgrammaticInputs(t *testing.T) {
+	embedded, err := promptkit.FilesystemInputs("embedded defaults", fstest.MapFS{
+		"config/default.yaml": &fstest.MapFile{Data: []byte(`
+profiles:
+  application:
+    endpoint: https://example.invalid/v1
+    model: default-model
+prompts:
+  hello:
+    "1":
+      default_profile: application
+      messages:
+        - role: user
+          content: Hello
+      output:
+        format: text
+        validation_mode: none
+`)},
+	}, "config")
+	if err != nil {
+		t.Fatalf("select embedded defaults: %v", err)
+	}
+	operatorDirectory := t.TempDir()
+	if err := os.WriteFile(filepath.Join(operatorDirectory, "override.yaml"), []byte("profiles:\n  application:\n    model: operator-model\n"), 0o644); err != nil {
+		t.Fatalf("write operator input: %v", err)
+	}
+	operator, err := promptkit.DirectoryInputs(operatorDirectory)
+	if err != nil {
+		t.Fatalf("select operator inputs: %v", err)
+	}
+	programmaticModel := "programmatic-model"
+	programmatic := configkit.Input{Source: promptkit.ProfileSource("programmatic settings", map[string]promptkit.ProfileConfig{
+		"application": {Model: &programmaticModel},
+	})}
+	for _, test := range []struct {
+		name  string
+		apply bool
+		want  string
+	}{
+		{name: "embedded", want: "default-model"},
+		{name: "operator", apply: true, want: "operator-model"},
+		{name: "programmatic", apply: true, want: "programmatic-model"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			underlays := []configkit.Underlay{{Inputs: embedded}}
+			if test.apply {
+				underlays = append(underlays, configkit.Underlay{Inputs: operator})
+			}
+			if test.name == "programmatic" {
+				underlays = append(underlays, configkit.Underlay{Inputs: []configkit.Input{programmatic}})
+			}
+			engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Underlays: underlays}})
+			if err != nil {
+				t.Fatalf("construct engine: %v", err)
+			}
+			prepared, err := engine.Prepare(context.Background(), promptkit.RunRequest{PromptID: "hello"})
+			if err != nil {
+				t.Fatalf("prepare prompt: %v", err)
+			}
+			if prepared.EffectiveModelParams.Model != test.want {
+				t.Fatalf("model = %q, want %q", prepared.EffectiveModelParams.Model, test.want)
+			}
+		})
+	}
+}
+
+func TestPublicConstructionPreservesConfigKitLoadError(t *testing.T) {
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &configkit.Input{
+		Source: configkit.Mapping("invalid", map[string]any{"profiles": map[string]any{"broken": map[string]any{"unknown": true}}}),
+	}}})
+	var loadErr *configkit.LoadError
+	if engine != nil || !errors.Is(err, promptkit.ErrInvalidConfig) || !errors.As(err, &loadErr) {
+		t.Fatalf("construction = (%#v, %v), want invalid config preserving LoadError", engine, err)
+	}
+}
+
+func TestPublicConstructionRejectsSuppliedInvalidMainInput(t *testing.T) {
+	main := configkit.Input{}
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{Main: &main}})
+	if engine != nil || !errors.Is(err, promptkit.ErrInvalidConfig) {
+		t.Fatalf("construction = (%#v, %v), want invalid supplied main input", engine, err)
+	}
+}
+
+func TestPublicConstructionCanOverlayMaintainedBackend(t *testing.T) {
+	endpoint := "http://local-openrouter.example/v1"
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: promptkit.BackendSource("operator backend", map[string]promptkit.BackendConfig{
+			promptkit.BackendOpenRouter: {Endpoint: &endpoint},
+		})}}}},
+	}})
+	if err != nil {
+		t.Fatalf("construct engine with backend overlay: %v", err)
+	}
+	inspection, err := engine.InspectProfile(context.Background(), "mistral-small-3")
+	if err != nil {
+		t.Fatalf("inspect catalog profile: %v", err)
+	}
+	if inspection.EffectiveModelParams.Endpoint != endpoint {
+		t.Fatalf("effective endpoint = %q, want %q", inspection.EffectiveModelParams.Endpoint, endpoint)
+	}
+}
+
+func TestPreparationRejectsAmbiguousPromptVersion(t *testing.T) {
+	definition := func(content string) map[string]any {
+		return map[string]any{
+			"messages": []any{map[string]any{"role": "user", "content": content}},
+			"output":   map[string]any{"format": "text", "validation_mode": "none"},
+		}
+	}
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Main: &configkit.Input{Source: configkit.Mapping("versions", map[string]any{
+			"prompts": map[string]any{"hello": map[string]any{
+				"1": definition("first"), "2": definition("second"),
+			}},
+		})},
+	}})
+	if err != nil {
+		t.Fatalf("construct engine: %v", err)
+	}
+	if result, err := engine.Prepare(context.Background(), promptkit.RunRequest{PromptID: "hello"}); result != nil || !errors.Is(err, promptkit.ErrPromptLoad) {
+		t.Fatalf("ambiguous preparation = (%#v, %v), want ErrPromptLoad", result, err)
+	}
+}

consumer_test_helpers_test.go

@@ -0,0 +1,73 @@
+package promptkit_test
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"sync/atomic"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+type fakeLLMClient struct {
+	response  *promptkit.GenerateResponse
+	responses []*promptkit.GenerateResponse
+	err       error
+	requests  []promptkit.GenerateRequest
+}
+
+func (f *fakeLLMClient) Generate(_ context.Context, request promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) {
+	f.requests = append(f.requests, request)
+	if f.err != nil {
+		return nil, f.err
+	}
+	if len(f.responses) > 0 {
+		index := len(f.requests) - 1
+		if index >= len(f.responses) {
+			return nil, fmt.Errorf("no response configured for generation %d", index+1)
+		}
+		return f.responses[index], nil
+	}
+	return f.response, nil
+}
+
+type countingLLMClient struct{ calls *atomic.Int64 }
+
+func (client countingLLMClient) Generate(context.Context, promptkit.GenerateRequest) (*promptkit.GenerateResponse, error) {
+	if client.calls != nil {
+		client.calls.Add(1)
+	}
+	return &promptkit.GenerateResponse{Content: "ok"}, nil
+}
+
+type roundTripFunc func(*http.Request) (*http.Response, error)
+
+func (f roundTripFunc) RoundTrip(request *http.Request) (*http.Response, error) { return f(request) }
+
+// newSimpleEngine exercises the public constructor with a complete keyed
+// document. Tests that need layering or resources select their own inputs.
+func newSimpleEngine(t *testing.T, content string, options ...promptkit.Option) *promptkit.Engine {
+	t.Helper()
+	engine, err := promptkit.NewEngine(simpleConfig(content), options...)
+	if err != nil {
+		t.Fatalf("construct consumer test engine: %v", err)
+	}
+	return engine
+}
+
+func simpleConfig(content string) promptkit.Config {
+	return promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Main: &configkit.Input{Source: configkit.Mapping("consumer test", map[string]any{
+			"profiles": map[string]any{"profile": map[string]any{
+				"endpoint": "http://example.test/v1", "model": "model",
+			}},
+			"prompts": map[string]any{"prompt": map[string]any{"1": map[string]any{
+				"default_profile": "profile",
+				"messages":        []any{map[string]any{"role": "user", "content": content}},
+				"output":          map[string]any{"format": "text", "validation_mode": "none"},
+			}}},
+		})},
+	}}
+}

doc.go

@@ -1,27 +1,32 @@
 // Package promptkit provides an embeddable engine for preparing and executing
 // prompt-defined LLM workflows.
 //
-// Applications construct an [Engine] with [NewEngine], select filesystem or
-// in-memory sources and optional engine-scoped [Backend] registrations, and
-// call [Engine.InspectPrompt], [Engine.InspectProfile], [Engine.Prepare],
-// [Engine.PrepareExecution], [Engine.Run], or [Engine.RunPrepared]. Concrete
-// registries, repositories, validators, and the built-in OpenAI-compatible
-// client remain internal implementation details.
+// Applications construct an [Engine] with [NewEngine], select ConfigKit
+// sources for prompts, profiles, and backends, and
+// call [Engine.InspectConfiguration], [Engine.InspectPrompt],
+// [Engine.InspectRequirements], [Engine.InspectProfile], [Engine.ListProfiles],
+// [Engine.ListPrompts], [Engine.Prepare], [Engine.PrepareExecution],
+// [Engine.Run], or [Engine.RunPrepared]. Concrete registries, repositories,
+// validators, and the built-in OpenAI-compatible client remain internal
+// implementation details.
 //
 // # Concurrency and ownership
 //
-// An Engine supports concurrent InspectPrompt, InspectProfile, Prepare,
+// An Engine supports concurrent InspectConfiguration, InspectPrompt,
+// InspectRequirements, InspectProfile, ListProfiles, ListPrompts, Prepare,
 // PrepareExecution, Run, and RunPrepared calls. Engine-local backend policies
 // bound admitted Run and RunPrepared calls and model generations where
 // configured, while different backend pools and unlimited backends continue
 // independently. An injected [LLMClient] or [ArtifactReader] can therefore
 // still receive concurrent calls and must be safe for that use.
 //
-// NewEngine copies in-memory profiles and backend definitions. Prepare,
-// PrepareExecution, and Run copy request maps, slices, pointer values, and
-// JSON-compatible extra parameters before using them. InspectPrompt and
-// InspectProfile return copied inspection values. Returned values and values
-// passed to extension interfaces are likewise isolated from engine state.
+// ConfigKit captures the selected configuration when NewEngine constructs an
+// Engine. Prepare, PrepareExecution, and Run copy request maps, slices, pointer
+// values, and JSON-compatible extra parameters before using them. InspectPrompt,
+// InspectRequirements, and InspectProfile return copied inspection values.
+// ListProfiles and ListPrompts return caller-owned identity slices.
+// Returned values and values passed to extension interfaces are likewise
+// isolated from engine state.
 // Callers own those copies and may mutate them after the call that supplied or
 // returned them. [CapacityError] values are caller-owned and may be mutated
 // without affecting engine state or another error. Immutable [GenerationError]
@@ -52,9 +57,11 @@
 // used by those values.
 //
 // Construction, inspection, handle, and error values, including [Config],
-// [Backend], [RunRequest], [ArtifactRef], [ExecutionTargetOverride], [Profile],
-// [OpenAICompatibleProfileConfig], [ProfileInspection],
-// [PromptInputDefinition], [PromptInspection], [PreparedExecution],
+// [ConfigurationSources], [ConfigurationInspection], [BackendConfig],
+// [ProfileConfig], [RunRequest],
+// [ArtifactRef], [ExecutionTargetOverride], [ProfileInspection],
+// [PromptIdentity], [PromptInputDefinition], [PromptInspection],
+// [RequirementInspectionRequest], [RequirementInspection], [PreparedExecution],
 // [CapacityError], [GenerationError], [RetryExhaustedError], and
 // [ExecutionEvent], do not have stable JSON
 // representations. Direct API keys are nevertheless excluded from JSON for

docs/adr/0001-configuration-boundary.md

@@ -0,0 +1,60 @@
+# 0001: Configuration Ownership At The ConfigKit Handoff
+
+## Status
+
+Accepted.
+
+## Date
+
+2026-09-30
+
+## Context
+
+PromptKit is adopting ConfigKit to standardize configuration semantics and
+simplify its loading machinery. Configuration includes prompts, profiles, and
+backend definitions contributed by maintained catalogs and consuming applications.
+ConfigKit supplies loading, composition, precedence, inheritance, and inspection
+capabilities. PromptKit supplies LLM-specific interpretation and execution.
+
+A clear handoff assigns each library responsibility for the configuration it
+owns and keeps validation aligned with the values an application actually uses.
+
+## Decision
+
+ConfigKit owns configuration processing up to the handoff of the final effective
+configuration. PromptKit takes ownership at that handoff and applies its domain
+interpretation and validation to the final configuration.
+
+The handoff includes effective presence/null information and resource context
+supplied by ConfigKit. PromptKit uses this information to interpret effective
+settings and resolve referenced resources.
+
+PromptKit passes through ConfigKit's inspection capabilities for explicit
+operator use. Configuration history and source explanations serve that
+inspection purpose; domain validation operates on the final effective values.
+
+This boundary applies uniformly to application configuration and maintained
+catalog configuration, including backend definitions.
+
+## Alternatives Considered
+
+- **Independent source or catalog preflight validation:** preserves checks on
+  individual contributions, but duplicates configuration processing and evaluates
+  values that may be replaced before handoff. Raw-source and intermediate-state
+  validation are outside PromptKit's scope, including equivalent test-only checks.
+- **History-based source auditing:** can identify overwritten contributions, but
+  couples domain enforcement to configuration history. Historical inspection is
+  an operator capability rather than a validation mechanism.
+
+## Consequences
+
+PromptKit's configuration logic and tests focus on the final effective values,
+their domain meaning, and resulting execution behavior. ConfigKit owns failures
+arising during its processing, which PromptKit preserves through its error
+boundary. Catalog maintainers own their repositories' publishing checks.
+
+The adoption work routes backend configuration through the same handoff and
+retires PromptKit's source-level and intermediate-configuration validation.
+Effective resource interpretation and explicit operator inspection remain
+supported. This concentrates configuration semantics in ConfigKit and reduces
+duplicated machinery and maintenance in PromptKit.

docs/consumers/pkg-promptkit.md

@@ -19,56 +19,202 @@ The following Go fragments are illustrative and omit surrounding package,
 import, and error-handling code. Use the maintained examples for complete
 programs.
 
+## Go Compatibility
+
+The `go` directive in the selected release's [module metadata](../../go.mod)
+declares its minimum supported consumer Go version. Maintainers build and
+validate releases with the locally selected Go patch release; the minimum
+does not simply track that patch version.
+
+Successful release validation on the selected patch is sufficient to presume
+support across its Go series, subject to the declared minimum and concrete
+evidence of incompatibility. Specific compatibility concerns are investigated
+as they arise. Minor releases may raise the minimum; patch releases preserve
+it. Release notes explain increases and any required consumer action. See the
+[release policy](../policy/release.md#consumer-minimum-and-release-toolchain).
+
 ## Construct An Engine
 
-Create an engine with
-[`NewEngine`](../../engine.go). A directory-backed setup supplies a prompt
-directory and may supply profile and schema directories:
+Create an engine with [`NewEngine`](../../engine.go). Select each directory
+explicitly and place its inputs in an ordered ConfigKit underlay. A group
+strictly composes its files; later groups can overlay earlier ones:
 
 ```go
+promptInputs, err := promptkit.DirectoryInputs("prompts")
+if err != nil { return err }
+profileInputs, err := promptkit.DirectoryInputs("profiles")
+if err != nil { return err }
 engine, err := promptkit.NewEngine(promptkit.Config{
-	PromptDir:  "prompts",
-	ProfileDir: "profiles",
-	SchemaDir:  "schemas",
+	Sources: promptkit.ConfigurationSources{Underlays: []configkit.Underlay{
+		{Inputs: promptInputs},
+		{Inputs: profileInputs},
+	}},
+	SchemaDir: "schemas",
 })
 ```
 
-Options support single-file or `fs.FS` sources, in-memory profiles,
-engine-scoped backends, and injected artifact or model clients. Consult the
-[constructor and option GoDoc](../../engine.go) for composition, precedence,
-validation, and default transport behavior. Source discovery, format
-validation, and profile precedence are defined by the
-[framework format reference](../formats.md).
+For a single highest-priority document, set `Sources.Main` to a
+`*configkit.Input`; omit it for ordinary layered construction. A single file
+can use `configkit.File` directly. `ProfileSource`, `BackendSource`, and raw
+`configkit.Mapping` supply programmatic definitions. Schema and runtime
+collaborator options remain available. Construction validates the final
+effective configuration and captures referenced prompt content; construct a
+new engine to observe configuration edits. See the [constructor GoDoc](../../engine.go)
+for the exact public contract and the [framework format reference](../formats.md)
+for definition fields.
 
 ## Supply Embedded Application Defaults
 
-Use `WithFallbackProfileFS` when an application packages profile definitions
-that should apply unless an operator provides an ordinary configured profile
-with the same ID. For example, an application can embed its defaults while
-continuing to use `ProfileDir` for operator overrides:
+Use `FilesystemInputs` for embedded defaults and `DirectoryInputs` for an
+explicitly chosen operator directory. A later programmatic group can override
+both. No directory name has built-in precedence:
 
 ```go
-//go:embed profiles/*.yaml
-var applicationProfiles embed.FS
-
-engine, err := promptkit.NewEngine(promptkit.Config{
-	PromptDir:  "prompts",
-	ProfileDir: operatorProfileDir,
-},
-	promptkit.WithFallbackProfileFS(applicationProfiles, "profiles"),
-)
+defaults, err := promptkit.FilesystemInputs("embedded defaults", applicationFS, "config")
+if err != nil { return err }
+operator, err := promptkit.DirectoryInputs(operatorDirectory)
+if err != nil { return err }
+profile := promptkit.ProfileSource("application choices", map[string]promptkit.ProfileConfig{
+	"summary": {Model: &selectedModel},
+})
+engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+	Underlays: []configkit.Underlay{
+		{Inputs: defaults},
+		{Inputs: operator},
+		{Inputs: []configkit.Input{{Source: profile}}},
+	},
+}})
 ```
 
-Keep application-owned profile IDs and definitions in the embedded source.
-Use the ordinary configured profile source for operator overrides. Leave
-`operatorProfileDir` empty when the operator did not configure an override
-directory; a non-empty path names an authoritative higher-precedence source,
-so an unavailable or unreadable directory is an error rather than a reason to
-fall back. The
-[framework format reference](../formats.md#source-and-profile-precedence)
-owns the exact profile format and lookup order; the
-[`WithFallbackProfileFS` GoDoc](../../engine.go) owns its option contract and
-validation rules.
+Only add the operator group when the application selects that directory; an
+explicitly selected missing or unreadable root is an error. Each helper finds
+`.yaml` and `.yml` files recursively and disables imports by default. The
+caller may enable imports on individual inputs. A nil `Sources.Main` is an
+empty main source, not another directory lookup.
+
+For a programmatic document with explicit null or a prompt definition, use a
+labeled mapping as an input. A mapping owns a snapshot of supported values:
+
+```go
+document := configkit.Mapping("application configuration", map[string]any{
+	"profiles": map[string]any{
+		"local-summary": map[string]any{
+			"backend": "local", "model": "example-model",
+			"temperature": nil, // Suppress an inherited provider control.
+		},
+	},
+})
+input := configkit.Input{Source: document}
+// Add input to a later underlay, or set Sources.Main = &input.
+```
+
+`ProfileSource` and `BackendSource` are smaller typed conveniences when null
+is not needed. A caller underlay can overlay catalog backend fields just as it
+can overlay profiles; there is no registration-only backend namespace.
+
+When configuration or message files change, build and validate a new engine,
+then switch the application to that engine for subsequent work. Existing
+engines and prepared handles retain their captured definitions; schema and
+request artifact resources still follow their runtime lifecycle. Inspection
+does not watch or reload sources automatically.
+
+## Discover Available Profiles And Prompts
+
+Use [`Engine.ListProfiles`](../../listing.go) and
+[`Engine.ListPrompts`](../../listing.go) to discover exact identities from the
+engine's final captured configuration, then inspect a selected prompt:
+
+```go
+profiles, err := engine.ListProfiles(ctx)
+if err != nil {
+	return err
+}
+if len(profiles) > 0 {
+	_, err := engine.InspectProfile(ctx, profiles[0])
+	if err != nil {
+		return err
+	}
+}
+prompts, err := engine.ListPrompts(ctx)
+if err != nil {
+	return err
+}
+if len(prompts) > 0 {
+	selected := prompts[0]
+	inspection, err := engine.InspectPrompt(ctx, selected.ID, selected.Version)
+	if err != nil {
+		return err
+	}
+	_ = inspection
+}
+```
+
+These lists describe effective membership, not ConfigKit contribution history,
+and do not promise that a profile is ready to execute. Use inspection for
+details and preparation to resolve request resources. The linked method GoDoc
+owns ordering, ownership, concurrency, and error behavior; identifiers may be
+sensitive application data.
+
+## Inspect The Captured Configuration
+
+Use [`Engine.InspectConfiguration`](../../configuration_inspection.go) for an
+operator-selected report of effective configuration, source descriptions,
+diagnostics, and path history. For a literal ID containing a slash, construct
+the semantic path with `configkit.Keys`:
+
+```go
+view, err := engine.InspectConfiguration()
+if err != nil { return err }
+path := configkit.Keys("profiles", "team/summary", "model")
+explanation, found := view.Explain(path)
+if found && explanation.Effective.Redacted {
+	// Apply the application's disclosure policy before sharing the report.
+}
+```
+
+`WriteEffective` and `WriteExplanation` produce ConfigKit-redacted reports;
+the application decides whether those reports may be disclosed. Credential-
+shaped provider keys are redacted, but arbitrary prompt and provider content
+is not necessarily safe to share. Inspection uses the engine's captured result
+and does not reopen sources or resolve credentials. `InspectProfile` instead
+shows backend-completed execution settings for one profile, and `Prepare` or
+`PreparedExecution.Details` shows request-specific rendered messages, inputs,
+and validation resources. None of those views is a substitute for the others.
+
+To review changes between two independently captured configurations, compare
+their inspection views:
+
+```go
+earlier, err := earlierEngine.InspectConfiguration()
+if err != nil {
+	return err
+}
+later, err := candidateEngine.InspectConfiguration()
+if err != nil {
+	return err
+}
+differences, err := earlier.Diff(later)
+if err != nil {
+	return err
+}
+for _, difference := range differences {
+	if difference.HiddenChanged {
+		// Report a protected change without inferring its value.
+	}
+	if difference.Left.Redacted || difference.Right.Redacted {
+		// Apply the application's disclosure policy before presenting snapshots.
+	}
+}
+```
+
+See the [`ConfigurationInspection.Diff` GoDoc](../../configuration_inspection.go)
+and ConfigKit's [v0.7.0 effective-configuration diff guidance](https://gitea.maximumdirect.net/eric/ConfigKit/src/tag/v0.7.0/docs/config.md#effective-configuration-diffs)
+for the exact comparison contract. The operation compares only frozen effective
+configuration values: it does not reread external files or compare their
+contents, resolved credential contents, later execution preparation, or
+request-specific overrides. An empty diff is not proof of equivalent execution.
+Records can contain ordinary application data, so use the application's
+disclosure policy when presenting them.
 
 ## Inspect A Prompt Before Preparation
 
@@ -94,6 +240,85 @@ rendered messages, and use prepared execution when that work must remain tied
 to later execution. The method's [GoDoc](../../engine.go) owns exact fields,
 hash, ownership, and error semantics.
 
+## Inspect Requirements Before Preparation
+
+Use [`Engine.InspectRequirements`](../../requirements.go) when the application
+needs the prompt's recognizable input and caller-variable dependencies for a
+particular context before it has input artifacts. Unlike `InspectPrompt`, it
+also walks captured template syntax and selects a profile identity; unlike
+`Prepare`, it does not load artifacts or render messages.
+
+```go
+requirements, err := engine.InspectRequirements(ctx, promptkit.RequirementInspectionRequest{
+	PromptID: "meeting.summary",
+	Vars:     map[string]string{"audience": "project leads"},
+})
+if err != nil {
+	return err
+}
+
+for _, input := range requirements.Inputs {
+	if input.Kind == promptkit.RequirementRequired {
+		// Plan to bind this input before preparation.
+	}
+	if input.Kind == promptkit.RequirementOptional && input.Explanation != "" {
+		// A recognizable reference may occur only on a known skipped path.
+	}
+}
+for _, variable := range requirements.Variables {
+	if variable.Kind == promptkit.RequirementRequired && !variable.Supplied {
+		// The key is required even though this inspection did not receive it.
+	}
+}
+if !requirements.Complete {
+	// Preserve the partial inventory and account for its discovery issues.
+}
+```
+
+Optional entries can include recognizable inputs and variables found only in
+inactive branches. A missing required variable is reported separately from
+discovery completeness: missing a value used only for direct text substitution
+does not by itself make the inventory incomplete. Conversely, an unresolved
+dependency-bearing branch can make discovery incomplete while retaining known
+conditional entries. Do not treat an empty partial inventory as proof that no
+input bindings are needed. See the method's [GoDoc](../../requirements.go) for
+the exact classifications, supported syntax, ownership, and error contract.
+
+## Validate A Concrete Request
+
+Use [`Engine.ValidateRequest`](../../engine.go) when the application has a
+complete `RunRequest` and needs to know whether that concrete invocation passes
+preparation:
+
+```go
+request := promptkit.RunRequest{
+	PromptID: "meeting.summary",
+	Vars:     map[string]string{"audience": "project leads"},
+	Inputs: map[string]promptkit.ArtifactRef{
+		"note": promptkit.Inline("Synthetic meeting notes"),
+	},
+}
+if err := engine.ValidateRequest(ctx, request); err != nil {
+	return err
+}
+```
+
+Unlike `InspectRequirements`, this checks supplied values, the selected template
+branches, and request bindings through the existing preparation path. It checks
+only this invocation, does not aggregate errors, and loads every supplied input
+according to ordinary preparation behavior, even if a branch does not use it.
+It makes no model call and returns no prepared snapshot, but artifact and schema
+resource I/O and its time and memory costs remain. Success does not certify
+provider acceptance or later execution success. See the method's GoDoc for its
+exact error and context behavior.
+
+Scriptorium can map the returned error to its own diagnostics and exit status.
+Its `validate` and `run` commands should construct equivalent requests for
+equivalent caller inputs so their preparation behavior agrees. Separate
+subprocess calls prepare independently; an opaque `PrepareExecution` handle
+cannot be transferred from `validate` to `run`. Use `PrepareExecution` when one
+process and engine must execute the exact prepared snapshot.
+
 ## Prepare Without Model Execution
 
 [`Engine.Prepare`](../../engine.go) resolves the selected prompt and profile,
@@ -114,8 +339,11 @@ prepared, err := engine.Prepare(ctx, promptkit.RunRequest{
 The maintained
 [offline preparation example](../../examples/go-library/prepare/main.go)
 shows a complete runnable setup with a prompt file, in-memory profile, and
-inline input. Exact request requirements and prepared-result fields belong to
-the [`RunRequest` and `PreparedRun` GoDoc](../../types.go).
+inline input. It demonstrates validation and preparation with the same request
+to make the two operations concrete; this performs preparation twice and is
+illustrative, not a requirement to validate before `Prepare` or `Run`. Exact
+request requirements and prepared-result fields belong to the
+[`RunRequest` and `PreparedRun` GoDoc](../../types.go).
 
 ## Prepare Now And Execute The Same Snapshot Later
 
@@ -268,8 +496,8 @@ result, err := engine.Run(ctx, request)
 
 These messages are already rendered: Promptkit does not template or resolve
 files in them, and they can contain sensitive model output or application
-feedback. Promptkit remains stateless; every `Run` call re-resolves its current
-sources and the application owns any semantic retry budget. When a
+feedback. Every `Run` call uses the engine's captured configuration; the
+application owns any semantic retry budget. When a
 pre-execution equality check is required, use `PrepareExecution` and compare
 its opaque rendered-prompt hash before invoking `RunPrepared`.
 
@@ -282,12 +510,44 @@ replace execution settings or the complete output contract.
 The [public value GoDoc](../../types.go) defines nil, empty, zero, replacement,
 copy, and credential behavior. The
 [framework format reference](../formats.md) defines how those request values
-interact with prompt definitions, file-backed and application fallback
-profiles, built-ins, schemas, and framework defaults.
+interact with prompt definitions, layered profiles, built-ins, schemas, and
+framework defaults.
 
-For programmatic profiles,
-[`OpenAICompatibleProfile`](../../profiles.go) converts ordinary
-OpenAI-compatible settings into a value accepted by `WithProfiles`.
+For programmatic profiles, use [`ProfileSource`](../../profiles.go) with keyed
+`ProfileConfig` values. Nil fields are omitted; pointers preserve explicit
+zero, false, and blank values. Raw `configkit.Mapping` expresses explicit null.
+
+### Migrate From The Previous Configuration API
+
+Replace `Config.PromptDir` and `Config.ProfileDir` with selected ConfigKit
+inputs in `Config.Sources`. The removed `WithPromptFS`, `WithPromptFile`,
+`WithProfileFS`, `WithProfileFile`, `WithFallbackProfileFS`, `WithProfiles`,
+and `WithBackend` options have no compatibility wrappers. Use
+`DirectoryInputs` or `FilesystemInputs` for a strict-composition file group,
+ConfigKit file inputs for individual files, and `ProfileSource`,
+`BackendSource`, or `configkit.Mapping` for programmatic values. Backend IDs
+are keys in configuration, not registrations. Choose caller underlays in
+fallback-to-operator-to-programmatic order; use `Sources.Main` for one final
+highest-priority input.
+
+Move embedded `id` and `version` fields into keyed `profiles` and `prompts`
+maps; convert `base_profile` to ConfigKit `extends`. IDs and references are
+exact literal keys, without trimming. A supplied zero, false, or empty string
+is now distinguishable from omission; null can clear or suppress an inherited
+field according to the [field table](../formats.md#defaults-and-overrides).
+Maps merge recursively across inheritance and layers. `{}` does not clear an
+inherited map: use null to clear the whole map. At request time, a literal
+`extra_params["extends"]` is ordinary provider data, not an inheritance
+instruction; a nonempty request ExtraParams map replaces configured params.
+Changing a model or backend does not clear unrelated explicit fields, though
+backend-derived defaults are applied after inheritance to the final backend.
+
+Invalid final definitions, including unused ones, now fail `NewEngine`; only
+request-dependent failures remain at preparation or execution. Prompt text
+and static templates are captured at construction, not automatically reloaded
+between runs. Replace the engine to pick up changed definitions or message
+files. The [format reference](../formats.md) owns exact field and presence
+rules; the maintained examples show complete runnable workflows.
 
 ### Choose A Profile Ownership Model
 
@@ -319,18 +579,19 @@ the application ID while inheriting the built-in target. The child can override
 only the setting it owns:
 
 ```go
-promptkit.WithProfiles(promptkit.Profile{
-	ID:              "weather-light",
-	BaseProfileID:   "promptkit-openrouter-standard",
-	ReasoningEffort: "high",
+profile := promptkit.ProfileSource("application profiles", map[string]promptkit.ProfileConfig{
+	"weather-light": {
+		Extends: &standardID,
+		ReasoningEffort: &high,
+	},
 })
 ```
 
-Select `weather-light` in a prompt or `RunRequest.ProfileID`; it remains the
-reported selected profile. See the [profile inheritance format
-reference](../formats.md#profile-inheritance) and the
-[`Profile` GoDoc](../../types.go) for exact lookup, merging, and validation
-behavior. If the base is an external profile, apply the volatility guidance
+Place `profile` in a ConfigKit underlay, with `standardID` set to
+`"promptkit-openrouter-standard"` and `high` to `"high"`. Select
+`weather-light` in a prompt or `RunRequest.ProfileID`; it remains the
+reported selected profile. Definition IDs and inheritance references are exact
+keys. If the base is an external profile, apply the volatility guidance
 above when deciding whether to use an application-owned complete definition
 instead.
 
@@ -355,9 +616,8 @@ if prepared.SelectedBackendID != promptkit.BackendRakestrawHome {
 }
 ```
 
-Do not register `rakestrawhome` manually. When adopting this built-in, remove
-an existing `WithBackend` registration with that exact ID; retaining it causes
-the intentional duplicate-ID configuration error. Direct request credentials
+The maintained catalog supplies this backend, and callers may overlay its
+effective configuration through a later ConfigKit source. Direct request credentials
 and runtime endpoint overrides remain supported under their ordinary GoDoc and
 format contracts.
 
@@ -424,19 +684,15 @@ Choose the smallest configuration that fits how the endpoint will be reused.
 
 #### Use An Endpoint-Only Profile
 
-Put the endpoint directly on an in-memory profile when only that profile needs
+Put the endpoint directly on a programmatic profile when only that profile needs
 it and shared backend identity or capacity policy is unnecessary:
 
 ```go
-engine, err := promptkit.NewEngine(promptkit.Config{
-	PromptDir: "prompts",
-},
-	promptkit.WithProfiles(promptkit.Profile{
-		ID:       "local-summary",
-		Endpoint: "http://localhost:8000/v1",
-		Model:    "example-model",
-	}),
-)
+endpoint, model := "http://localhost:8000/v1", "example-model"
+profile := promptkit.ProfileSource("local profile", map[string]promptkit.ProfileConfig{
+	"local-summary": {Endpoint: &endpoint, Model: &model},
+})
+// Add configkit.Input{Source: profile} to a caller underlay.
 ```
 
 Endpoint-only profiles have an empty backend ID and remain unrestricted by
@@ -448,59 +704,44 @@ Use `LocalBackend` when profiles should share the conventional `local`
 identity, endpoint, and concurrency limit:
 
 ```go
-engine, err := promptkit.NewEngine(promptkit.Config{
-	PromptDir: "prompts",
-},
-	promptkit.WithBackend(
-		promptkit.LocalBackend("http://localhost:8000/v1", 2),
-	),
-	promptkit.WithProfiles(promptkit.Profile{
-		ID:        "local-summary",
-		BackendID: promptkit.BackendLocal,
-		Model:     "example-model",
-	}),
-)
+backendID, model := promptkit.BackendLocal, "example-model"
+backend := promptkit.BackendSource("local backend", map[string]promptkit.BackendConfig{
+	backendID: promptkit.LocalBackend("http://localhost:8000/v1", 2),
+})
+profile := promptkit.ProfileSource("local profile", map[string]promptkit.ProfileConfig{
+	"local-summary": {Backend: &backendID, Model: &model},
+})
+// Add both sources as inputs in a caller underlay.
 ```
 
-The helper is explicit: it does not pre-register a backend or read environment
-variables. Supplying a positive limit leaves queue capacity omitted, so normal
-backend registration selects the existing default waiting capacity of 1024.
-The returned value still enters the engine through `WithBackend`.
+The helper does not choose an ID or read environment variables. A positive
+concurrency limit with omitted queue capacity selects the default waiting
+capacity of 1024.
 
 #### Configure A Complete Backend
 
-Use a keyed `Backend` value for authentication, extra request parameters, an
+Use a keyed `BackendConfig` value for authentication, extra request parameters, an
 explicit queue capacity, a custom ID, or multiple local endpoints:
 
 ```go
-noWaiting := 0
-engine, err := promptkit.NewEngine(promptkit.Config{
-	PromptDir: "prompts",
-},
-	promptkit.WithBackend(promptkit.Backend{
-		ID:               "local-gpu",
-		Endpoint:         "http://gpu-host:8000/v1",
-		APIKeyEnv:        "LOCAL_GPU_API_KEY",
-		ExtraParams:      map[string]any{"provider_option": "enabled"},
-		ConcurrencyLimit: 2,
-		QueueCapacity:    &noWaiting,
-	}),
-	promptkit.WithProfiles(promptkit.Profile{
-		ID:        "gpu-summary",
-		BackendID: "local-gpu",
-		Model:     "example-model",
-	}),
-)
+endpoint, keyName, limit, noWaiting := "http://gpu-host:8000/v1", "LOCAL_GPU_API_KEY", 2, 0
+backend := promptkit.BackendSource("GPU backend", map[string]promptkit.BackendConfig{
+	"local-gpu": {
+		Endpoint: &endpoint, APIKeyEnv: &keyName,
+		ConcurrencyLimit: &limit, QueueCapacity: &noWaiting,
+		ExtraParams: map[string]any{"provider_option": "enabled"},
+	},
+})
 ```
 
-Use distinct custom IDs when registering multiple local endpoints.
-Registrations belong to one engine and custom IDs cannot replace built-ins.
-The [`Backend`, `LocalBackend`, and `WithBackend` GoDoc](../../backends.go)
-defines exact construction, validation, copying, uniqueness, concurrency, and
-request-default behavior.
+Place `backend` in a caller underlay and select `"local-gpu"` from a
+`ProfileConfig.Backend` pointer or a keyed file profile. All backend
+contributions use the same ConfigKit layering rules, including overlays of
+maintained definitions. The [`BackendConfig` and `LocalBackend` GoDoc](../../backends.go)
+defines exact omission and construction behavior.
 
-Both file-backed and in-memory profiles select a registration through
-`backend` or `Profile.BackendID`. Profile and request endpoint overrides retain
+Both file-backed and programmatic profiles select a backend through
+`backend` or `ProfileConfig.Backend`. Profile and request endpoint overrides retain
 that routing and capacity identity. `PreparedRun.SelectedBackendID`,
 `RunResult.SelectedBackendID`, and the effective `ExecutionTarget.BackendID`
 expose it to consumers and injected model clients. Endpoint-only profiles
@@ -508,7 +749,7 @@ remain supported and expose an empty backend ID.
 
 ### Limit Backend Concurrency
 
-Set `Backend.ConcurrencyLimit` when a backend needs protection from too many
+Set `BackendConfig.ConcurrencyLimit` when a backend needs protection from too many
 simultaneous model calls. Leaving `QueueCapacity` nil, as in the local-backend
 example above, selects the default waiting capacity of 1024.
 
@@ -517,24 +758,23 @@ zero:
 
 ```go
 noWaiting := 0
-backend := promptkit.Backend{
-	ID:               "local-gpu",
-	Endpoint:         "http://gpu-host:8000/v1",
-	ConcurrencyLimit: 2,
-	QueueCapacity:    &noWaiting,
+backend := promptkit.BackendConfig{
+	Endpoint: &endpoint,
+	ConcurrencyLimit: &limit,
+	QueueCapacity: &noWaiting,
 }
 ```
 
-The pointer distinguishes an explicit zero from omission. Keep using keyed
-`Backend` literals so additive configuration fields remain source-compatible.
+The pointer distinguishes an explicit zero from omission. Use keyed
+`BackendConfig` literals inside `BackendSource` for programmatic definitions.
 Capacity belongs to one engine and the selected backend ID; endpoint-only
 profiles and custom backends without a configured limit remain unrestricted.
 Exact validation, defaulting, ownership, and concurrency semantics belong to
-the [`Backend` GoDoc](../../backends.go).
+the [`BackendConfig` GoDoc](../../backends.go).
 
 ## Credentials
 
-File-backed profiles name an environment variable; in-memory profiles can
+File-backed and programmatic profiles can name an environment variable or
 require a direct request key. Direct keys are request-scoped and are excluded
 from supported JSON values and the package's `String` and `GoString`
 summaries. The exact precedence and redaction guarantees belong to
@@ -568,12 +808,13 @@ the application policy that motivated the injection.
 
 Use `errors.Is` with the
 [public error sentinels and operation GoDoc](../../engine.go). The declarations
-distinguish invalid construction, invalid requests, absent sources,
-source-loading failures, collaborator failures, and operational validation
+distinguish invalid construction, invalid requests, absent selections,
+collaborator failures, and operational validation
 failures. Specific request conditions may also match the broader
 `ErrInvalidRequest`, and injected collaborator identities are preserved where
-documented. Invalid or duplicate backend registrations match
-`ErrInvalidConfig`; selecting an unknown backend matches `ErrProfileLoad`.
+documented. Invalid effective definitions, including unknown backend
+references, match `ErrInvalidConfig` during construction. ConfigKit load
+errors remain available through `errors.As`.
 
 When a limited backend has admitted all active and waiting calls, handle
 `ErrCapacityExceeded` separately from request errors and provider failures:

docs/development.md

@@ -59,37 +59,43 @@ exist.
 ## Maintainer Validation
 
 For ordinary work, select validation proportionate to the change. Do not repeat
-successful checks for unchanged content merely to create a commit. The full
-release-candidate checks have one executable entry point from the repository root:
+successful checks for unchanged content merely to create a commit. During
+development, run relevant Go tests and vet, format changed Go files, and execute
+the maintained examples when they are affected:
 
 ```sh
-./scripts/release-check.sh
+go test ./...
+go vet ./...
+gofmt -w path/to/changed.go
+python3 scripts/check-examples.py
+git diff --check
 ```
 
-The [script](../scripts/release-check.sh) owns the executable checks:
-race-enabled tests, vet, the three offline consumer examples with semantic output
-assertions, tracked Go formatting, local Markdown links, module/workspace
-hygiene, whitespace, and the credential-pattern scan. It does not publish,
-change files, validate release-note structure, or retire roadmaps. It requires Go,
-Git, a POSIX shell, and Python 3. Tests and examples require no provider
-credentials or live inference calls.
+Release candidates use `./scripts/release.sh VERSION`, which runs the selected
+profile checks and publishes the tag. The [release procedure](release.md)
+describes its requirements and recovery. For an optional diagnostic of a
+committed candidate without publication, run `./scripts/releasekit.sh check
+VERSION`; this is not a required pre-publication step.
 
-The script can run on intended uncommitted changes during development.
-Formatting and documentation checks use tracked files; stage intended new
-files before final validation so those checks include them. The release
-procedure separately enforces a clean, committed candidate.
+The standalone `python3 scripts/check-examples.py` command checks semantic
+expectations for the three offline consumer examples. The focused
+`python3 scripts/test-release.py` command exercises the release tooling against
+disposable local repositories; use it when changing that tooling, not as a
+recurring release gate. Tests and examples require no provider credentials or
+live inference calls.
+
+Ordinary validation can run on intended uncommitted work. Release validation
+uses committed candidate contents and the selected local Go installation.
 
 ### Change Review
 
 Inspect `git status --short --untracked-files=all` and the complete diff before
 accepting a change. Reject unintended files, credentials, private data,
 generated binaries, test output, downloaded assets, and template residue.
-The automated credential scan does not replace review of the actual change.
 
-For releases, follow the [release procedure](release.md). Its publication
-command runs the full local checks once on the final committed candidate and
-automates release-note structure and Git checks. Do not repeat ordinary change
-review as a release sign-off. Roadmap retirement remains preparation housekeeping.
+For releases, follow the [release procedure](release.md). Do not repeat its
+candidate checks as a separate sign-off. Roadmap retirement remains preparation
+housekeeping.
 
 Follow the [agent commit policy](policy/agents.md#git-commit-policy) for local
 commits. Ordinary commits may leave unrelated work in the workspace; preserve

docs/formats.md

@@ -2,394 +2,316 @@
 
 ## Purpose
 
-This document is the canonical contract for Promptkit prompt-definition,
-profile, and schema files. The [Go package consumer guide](consumers/pkg-promptkit.md)
-explains how to select these sources and invoke the engine. The
+This is the canonical reference for Promptkit's backend, profile, prompt, and
+schema definitions. The [Go consumer guide](consumers/pkg-promptkit.md) shows
+how to select sources and use an engine; the
 [OpenAI-compatible integration contract](integrations/openai-compatible-chat.md)
-owns the resulting outbound wire behavior.
+owns outbound wire behavior. [ConfigKit](https://gitea.maximumdirect.net/eric/ConfigKit)
+owns the generic YAML grammar, imports, layering, inheritance, and diagnostics.
+This reference describes what Promptkit does with the final effective values.
 
-Prompt and profile sources recursively discover files ending in `.yaml` or
-`.yml`. Each prompt-definition and profile file contains exactly one YAML
-document; comments and trailing whitespace are allowed. YAML decoding is
-strict: unknown fields are errors for the selected definition. Definitions are
-selected by their YAML `id`, not their file name or directory.
+A configuration document has keyed top-level `backends`, `profiles`, and
+`prompts` mappings. Their keys are literal IDs, not filename-derived identities.
+Prompt versions are a second keyed mapping. Keys and references must be
+nonblank and remain exact: Promptkit does not trim or re-key them. Old embedded
+`id`, `version`, and `base_profile` fields are invalid. Unknown fields are
+errors.
+
+```yaml
+backends:
+  local:
+    endpoint: http://localhost:8000/v1
+    concurrency_limit: 2
+profiles:
+  local-summary:
+    backend: local
+    model: example-model
+prompts:
+  meeting.summary:
+    "1.0.0":
+      default_profile: local-summary
+      messages:
+        - role: user
+          content: Summarize this note.
+      output:
+        format: text
+        validation_mode: none
+```
+
+Every effective backend, profile, and prompt definition is validated when
+`NewEngine` constructs the engine, even if it is never selected. A profile may
+be partial: an endpoint and model need only be complete after request overrides
+are applied. A prompt's default profile similarly need not be runnable without
+an overriding request. Missing request data, artifacts, schemas, credentials,
+and provider work remain runtime concerns.
+
+The engine captures effective definitions, referenced message-file contents,
+and static template syntax at construction. It does not reread configuration or
+message files on ordinary runs; construct a new engine to observe edits.
+Schema and request artifact reads still happen during preparation. Use
+`InspectConfiguration` for an explicit effective-configuration or provenance
+report, `InspectProfile` for backend-completed profile settings, and preparation
+for request-specific rendered details. For identity discovery before inspection,
+see the consumer guide's [profile and prompt listing](consumers/pkg-promptkit.md#discover-available-profiles-and-prompts).
 
 ## Prompt Definitions
 
-A prompt definition describes inputs, Go-template messages, an optional
-default profile, and an output contract.
+The `prompts` mapping selects a literal prompt ID, then a string version key:
 
 ```yaml
-id: meeting.summary
-version: "1.0.0"
-default_profile: local-summary
-description: Summarize a synthetic meeting note.
-session_id: '{{.session}}'
-inputs:
-  - name: note
-    required: true
-    content_type: text/plain
-    description: Meeting note to summarize.
-messages:
-  - role: system
-    content: Return a concise summary.
-    cache_control:
-      type: ephemeral
-      ttl: 1h
-  - role: user
-    content_file: ./summary.user.md
-output:
-  format: markdown
-  validation_mode: basic
-  repair_attempts: 0
+prompts:
+  meeting.summary:
+    "1.0.0":
+      default_profile: local-summary
+      description: Summarize a synthetic meeting note.
+      session_id: '{{.session}}'
+      inputs:
+        - name: note
+          required: true
+          content_type: text/plain
+          description: Meeting note to summarize.
+      messages:
+        - role: system
+          content: Return a concise summary.
+          cache_control:
+            type: ephemeral
+            ttl: 1h
+        - role: user
+          content_file: ./summary.user.md
+      output:
+        format: markdown
+        validation_mode: basic
+        repair_attempts: 0
 ```
 
-| Field | Required | Meaning |
-| --- | --- | --- |
-| `id` | yes | Non-empty prompt identifier used by `RunRequest.PromptID`. |
-| `version` | yes | Non-empty version selected by an optional `RunRequest.PromptVersion`. |
-| `default_profile` | no | Non-empty profile ID used when the request omits `ProfileID`. |
-| `description` | no | Human-readable description. |
-| `session_id` | no | Go template rendered from request variables and input helpers. |
-| `inputs` | no | Declared input metadata. |
-| `messages` | yes | One or more chat-message templates. |
-| `output` | yes | Output format and validation settings. |
-
-When a request omits a version, the selected prompt ID must identify exactly
-one definition. When it supplies a version, the ID and version pair must be
-unique.
-
-Exact prompt inspection uses this same configured source, strict decoding,
-referenced content-file resolution, and ID/version selection. It reports the
-selected definition's declared metadata without changing the prompt format or
-executing the definition.
+`messages` must be nonempty and `output` must be a valid mapping. Optional
+`default_profile`, `description`, `session_id`, `inputs`, and cache-control
+fields may be absent or cleared with null where appropriate. A null whole
+definition, required role, output format, or validation mode is invalid.
+`required` and `repair_attempts` default to false and zero, respectively, and
+are not nullable. A request that omits a prompt version succeeds only if that
+prompt ID has exactly one effective version. `InspectPrompt` selects from the
+same captured definitions without rendering or resolving a profile.
 
 ### Inputs
 
-Each `inputs` item has these fields:
-
-| Field | Required | Meaning |
-| --- | --- | --- |
-| `name` | yes | Non-empty name used by the request input map and `input` template helper. Names must be unique. |
-| `required` | no | When true, preparation fails if the request omits the input. The default is false. |
-| `content_type` | no | Expected media-type metadata. |
-| `description` | no | Human-readable input description. |
-
-Requests supply inputs as inline or file-backed `ArtifactRef` values. Declared
-required inputs must be present. A template reference also requires the named
-input to exist, whether or not it was declared. Extra request inputs are
-allowed.
+Each `inputs` item may contain `name`, `required`, `content_type`, and
+`description`. `name` is required, nonblank, and unique within the prompt.
+Omitted `required` means false. Null `inputs` means no declarations. Requests
+supply inline or file-backed `ArtifactRef` values; declared required inputs
+must be present. A template reference also needs its named input, even when
+undeclared. Extra request inputs are allowed.
 
 ### Messages And Templates
 
-Each message has a `role` that Promptkit trims and lowercases. It must then be
-exactly one of `developer`, `system`, `user`, or `assistant`; blank, custom,
-`tool`, and `function` roles are invalid. This intentionally tightens the
-previous nonblank-string rule. Consumers migrating to the next minor release
-must update any nonstandard prompt-definition roles before upgrading.
+Each message needs a role and exactly one nonnull `content` or `content_file`.
+An explicitly empty inline `content` is valid. Null clears either content
+selection. Roles are trimmed and lowercased, then must be `developer`,
+`system`, `user`, or `assistant`. Static template syntax is checked during
+construction; missing variables and named inputs fail when rendered.
+Request variables are template data (`{{.audience}}`), and
+`{{input "note"}}` renders an input body.
 
-Each message also has exactly one of:
+`content_file` uses the effective field's own source context, including when
+inherited or imported. Its relative path is resolved against that source's
+base directory within its rooted filesystem. Absolute paths and lexical
+escapes from the selected root fail. Host-file sources also prevent symlink
+escapes. Promptkit preserves the path text, including meaningful whitespace,
+after checking that it is not blank. A source without a unique usable resource
+context must supply one explicitly or override the field. Content is captured
+at construction, not reopened for each request.
 
-- `content`, containing an inline Go template; or
-- `content_file`, naming a file whose contents are the Go template.
+Optional `session_id` uses the same template variables and input helper. Its
+rendered value is trimmed, omitted if empty, and limited to 256 Unicode code
+points. A nonblank direct request session ID bypasses the template.
 
-`content_file` must be a relative path. It resolves from the directory that
-contains the prompt file and must remain within the configured prompt source
-root; parent components are allowed only when the resolved target remains
-inside that root. Absolute paths and paths that escape the root are rejected.
-Operating-system directory and single-file sources also reject symlink targets
-outside the root, while injected `fs.FS` sources apply containment in that
-filesystem's relative path namespace. For `WithPromptFile`, the source root is
-the directory containing the selected prompt file. Promptkit uses the parsed
-path text exactly after checking separately that it is not blank, so leading
-and trailing whitespace can name real filesystem entries.
-
-Request variables are the template data, so a variable named `audience` is
-referenced as `{{.audience}}`. The `{{input "note"}}` helper renders the body
-of a named input. Missing variables and input references are errors.
-
-The optional `session_id` uses the same template data and input helper. Its
-rendered value is trimmed, omitted when empty, and limited to 256 Unicode code
-points. A nonblank direct request session ID bypasses this template completely;
-a blank direct value leaves the template behavior unchanged.
+`InspectRequirements` can enumerate recognizable dependencies from captured
+templates before artifact content is available. Its conservative syntax
+coverage does not change template validity or rendering; see the [consumer
+guide](consumers/pkg-promptkit.md#inspect-requirements-before-preparation) and
+the method's [GoDoc](../requirements.go) for that inspection boundary.
 
 ### Cache Control
 
-`cache_control` is optional and has these fields:
-
-| Field | Required | Values |
-| --- | --- | --- |
-| `type` | yes | `ephemeral` |
-| `ttl` | no | Empty or `1h` |
-
-Promptkit preserves cache-control metadata on the rendered message. The
-outbound integration determines its wire representation.
+Optional `cache_control` has required `type: ephemeral` and optional `ttl`,
+which may be empty or `1h`. Promptkit retains this metadata on rendered
+messages; the integration contract defines its wire representation.
 
 ### Output Contract
 
 | Field | Required | Values or behavior |
 | --- | --- | --- |
-| `format` | yes | `text`, `markdown`, or `json`. |
-| `validation_mode` | yes | `none`, `basic`, `json`, or `json_schema`. |
-| `schema_path` | for `json_schema` | Path to a schema in the configured schema source. |
-| `repair_attempts` | no | Integer from zero through three; omitted means zero. A positive value requires `basic`, `json`, or `json_schema` validation. |
+| `format` | yes | `text`, `markdown`, or `json` |
+| `validation_mode` | yes | `none`, `basic`, `json`, or `json_schema` |
+| `schema_path` | for `json_schema` | Path in the selected schema source |
+| `repair_attempts` | no | Integer 0–3; default 0. Positive values need `basic`, `json`, or `json_schema` |
 
-The validation modes behave as follows:
-
-- `none` skips content validation;
-- `basic` requires non-empty generated content;
-- `json` requires valid JSON; and
-- `json_schema` requires valid JSON that satisfies the selected schema.
-
-`format` controls output artifact metadata. JSON Schema mode also supplies the
-schema to compatible model clients as structured-output metadata. Plain `json`
-validation accepts every valid JSON value and does not request a provider-native
-JSON-object constraint.
-
-`repair_attempts` counts additional generation calls after a failed validation.
-Zero is single-pass. With a positive eligible budget, Promptkit stops at the
-first valid candidate. If the budget is exhausted, it returns the final
-candidate and its complete failed validation result; generation and operational
-validation failures remain errors. `none` never permits repair.
-
-A request-level `OutputContract` replaces the complete prompt output contract.
-It does not merge individual fields. If its format is empty, Promptkit uses
-`text`.
+`none` skips content validation; `basic` requires nonempty content; `json`
+accepts any valid JSON value; `json_schema` checks the selected schema.
+`format` determines output artifact metadata. JSON Schema mode also supplies
+structured-output metadata to compatible clients. Plain `json` does not
+request a provider-native JSON-object constraint. A positive repair budget
+counts additional generations after failed validation; exhaustion returns the
+last candidate and its failed validation result. Operational errors remain
+errors. A request-level `OutputContract` replaces the whole configured one,
+not individual fields; an empty request format defaults to `text`.
 
 ## Built-In Backends
 
-Every engine provides these reserved OpenAI-compatible backend IDs. Consumers
-must not register either ID with `WithBackend`; exact registration and
-reservation behavior belongs to the [`Backend` GoDoc](../backends.go).
+The selected catalog modules contribute these backend definitions as the
+earliest underlay. Their settings can be overlaid by caller sources; these IDs
+are not reserved against configuration changes.
 
-| ID | Base endpoint | API-key environment variable | Active generation limit | Default queue capacity |
-| --- | --- | --- | ---: | ---: |
-| `openrouter` | `https://openrouter.ai/api/v1` | `OPENROUTER_API_KEY` | 16 | 1024 |
-| `rakestrawhome` | `https://inference.ai.rakestrawhome.com/v1` | `RAKESTRAWHOME_INFERENCE_API_KEY` | 4 | 1024 |
+| ID | Catalog endpoint | API-key environment name | Active generation limit |
+| --- | --- | --- | ---: |
+| `openrouter` | `https://openrouter.ai/api/v1` | `OPENROUTER_API_KEY` | 16 |
+| `rakestrawhome` | `https://inference.ai.rakestrawhome.com/v1` | `RAKESTRAWHOME_INFERENCE_API_KEY` | 4 |
+
+A backend definition may have `endpoint`, `api_key_env`,
+`concurrency_limit`, `queue_capacity`, and `extra_params`. The final endpoint
+is required and must be an absolute HTTP(S) URL with a host, no user
+information, query, or fragment. An omitted or null API-key environment name
+means no lookup. Omitted/null concurrency is zero (unlimited); a supplied
+negative value is invalid. For positive concurrency, omitted/null queue
+capacity defaults to 1024. An explicit queue capacity, including zero,
+requires positive concurrency and must be nonnegative. Unlimited concurrency
+has no queue. Provider maps contain JSON-compatible values; null entries are
+ordinary JSON null. Unknown fields, including a raw `api_key`, fail.
 
 ## Profile Definitions
 
-A profile supplies model execution settings:
+Profiles are keyed by literal ID and may inherit a named parent with
+`extends`:
 
 ```yaml
-id: local-summary
-backend: openrouter
-model: example-model
-temperature: 0.2
-max_tokens: 500
-top_p: 0.95
-timeout_seconds: 90
-service_tier: flex
-reasoning_effort: medium
-extra_params:
-  provider_option: enabled
+profiles:
+  local-summary:
+    backend: local
+    model: example-model
+    temperature: 0.2
+    max_tokens: 500
+    timeout_seconds: 90
+    extra_params:
+      provider_option: enabled
+  local-summary-fast:
+    extends: local-summary
+    timeout_seconds: 30
+    reasoning_effort: low
 ```
 
-A derived profile can use a named base and override only the settings it owns:
-
-```yaml
-id: local-summary-fast
-base_profile: local-summary
-timeout_seconds: 30
-reasoning_effort: low
-```
-
-| Field | Required | Meaning |
-| --- | --- | --- |
-| `id` | yes | Profile identifier, trimmed before selection and publication. It must be non-empty after trimming and unique within one source after normalization. |
-| `base_profile` | no | One optional parent profile ID. A derived profile may inherit target fields from it. |
-| `backend` | unless `endpoint` is present | Backend registry ID. It is trimmed and registry membership is checked when the profile is prepared or inspected. |
-| `endpoint` | unless `backend` is present | OpenAI-compatible base URL, including an API version path when required. A nonempty value is trimmed and must be absolute HTTP or HTTPS with a host and without user information, a query, or a fragment. When both connection fields are present, this overrides the backend endpoint without changing backend identity. |
-| `model` | yes | Non-empty provider model name. |
-| `temperature` | no | Number from 0 through 2. |
-| `max_tokens` | no | Integer zero or greater. |
-| `top_p` | no | Number from 0 through 1. |
-| `timeout_seconds` | no | Per-generation deadline in whole seconds; integer zero or greater. |
-| `service_tier` | no | Provider-specific request tier. |
-| `reasoning_effort` | no | Provider-specific reasoning setting. |
-| `api_key_env` | no | Optional environment-variable lookup source for an API key. |
-| `extra_params` | no | JSON-compatible provider-specific outbound fields. |
-
-Raw `api_key` is prohibited in profile YAML. Store only an environment
-variable name in `api_key_env`.
-
-A standalone profile must provide a model and at least one of `backend` or
-`endpoint`. A derived profile may omit those target fields because its selected
-base chain can provide them. Local parsing still validates a derived profile's
-own ID, supplied endpoint, execution-setting bounds, and `extra_params`.
-
-Promptkit does not infer a backend from a model or endpoint. Endpoint-only
-profiles remain supported and have no effective backend ID.
-The engine always provides the built-in `openrouter` and `rakestrawhome` IDs.
-Consumers can add engine-scoped IDs with
-[`WithBackend`](../backends.go); exact registration validation belongs to its
-GoDoc.
-
-`extra_params` accepts null, booleans, finite numbers, strings, arrays, and
-objects with string keys. Keys must be non-empty. With the built-in client,
-they also cannot collide with the standard fields listed in the
-[outbound request contract](integrations/openai-compatible-chat.md#request-body).
-Excessively deep or large JSON-shaped values are rejected for safety.
+Profiles may also supply `endpoint`, `top_p`, `service_tier`, `api_key_env`,
+and `api_key_required`. Promptkit does not infer a backend from an endpoint or
+model. A profile with only an endpoint has no backend capacity identity.
+Nonblank endpoints follow the backend URL rules; temperature is 0–2, top_p
+is 0–1, max_tokens and timeout_seconds are nonnegative. Provider maps accept
+JSON-compatible values with nonempty keys and cannot collide with the built-in
+client's [standard request fields](integrations/openai-compatible-chat.md#request-body).
+Credential values do not belong in profiles: raw `api_key` is invalid.
 
 ### Defaults And Overrides
 
-Execution settings resolve in this order:
+After effective profile inheritance, Promptkit applies the selected backend's
+defaults once, then request `ExecutionTargetOverride` values. Backend-derived
+settings are not inheritance input: changing a child profile's backend does
+not carry the parent's derived endpoint or credential source into it. Changing
+only a model or backend does not clear unrelated explicitly inherited fields.
 
-1. the framework timeout baseline;
-2. the selected backend, when the profile names one;
-3. the selected profile; and
-4. request `ExecutionTargetOverride` values.
+| Profile field | Absent | Explicit value | Explicit null |
+| --- | --- | --- | --- |
+| `backend` | No backend | Exact backend ID; blank means none | No backend |
+| `endpoint` | Selected backend endpoint | Valid nonblank URL; empty clears | Clear, without backend fallback |
+| `model` | Unspecified | Nonblank model; empty clears | Unspecified |
+| `temperature`, `top_p`, `max_tokens` | Unspecified | Valid value, including outbound zero | Suppress outbound control |
+| `service_tier`, `reasoning_effort` | Unspecified | Normalized value; blank suppresses | Suppress outbound control |
+| `timeout_seconds` | 600 seconds | Nonnegative; zero disables generation deadline | Reset to 600 seconds |
+| `api_key_env` | Backend lookup name, if any | Trimmed name; blank disables | Disable backend lookup |
+| `api_key_required` | False | Boolean, including false | False |
+| `extra_params` | Backend defaults | Recursively overlay profile map on backend map | Suppress configured provider map |
 
-The framework baseline is:
-
-| Setting | Default |
-| --- | --- |
-| `temperature` | Unspecified and omitted from compatible provider requests unless a profile or runtime override selects it. |
-| `max_tokens` | Unspecified and omitted from compatible provider requests unless a profile or runtime override selects it. |
-| `top_p` | Unspecified and omitted from compatible provider requests unless a profile or runtime override selects it. |
-| `timeout_seconds` | `600` |
-
-Numeric zero in a file or in-memory profile does not select a numeric value.
-For `temperature`, `max_tokens`, and `top_p`, it leaves the provider control
-unspecified. For `timeout_seconds`, it retains the framework deadline. Numeric
-request overrides use pointers, so an explicit zero is retained and sent to
-compatible providers. In particular, an explicit request `timeout_seconds` of
-zero disables the per-generation deadline while leaving the caller context and
-transport timeout intact.
-
-Non-empty profile strings replace backend defaults, and non-empty request
-strings replace both. Request reasoning is the exception: a nil
-`ReasoningEffort` pointer inherits the profile, a pointer to a nonblank string
-trims and replaces it, and a pointer to a blank string clears it. Backend
-identity is retained when either layer overrides the endpoint, so the override
-also retains any engine-local capacity policy configured for that backend.
-Capacity configuration belongs to the Go
-[`Backend` API](../backends.go), not prompt or profile YAML. A non-empty
-`extra_params` map at each layer replaces the entire lower-precedence map
-rather than merging keys.
-The [outbound integration contract](integrations/openai-compatible-chat.md)
-defines how the effective settings are serialized.
+An empty mapping does not clear inherited map entries; null clears the whole
+map. Nested maps merge recursively, while scalar and array values replace.
+Runtime nonempty `ExtraParams` overrides replace the entire configured map.
+Request overrides otherwise follow the [public value GoDoc](../types.go).
+For example, a runtime `extra_params["extends"]` key is ordinary provider
+data, not a configuration inheritance instruction. An explicit zero timeout
+does not disable the caller context or HTTP transport timeout.
 
 ### Source And Profile Precedence
 
-An explicit request profile ID takes precedence over the prompt's
-`default_profile`. If neither is present, preparation fails. Exact profile
-inspection instead takes one explicit profile ID and does not use a prompt
-default.
+`NewEngine` composes catalog definitions first, Promptkit-owned definitions
+next, then caller underlays in their given order, with an optional main input
+last. Later tiers overlay earlier ones. Inputs within one underlay group are
+strictly composed: conflicting contributions are errors, not priority
+signals. The directory helpers discover `.yaml` and `.yml` files recursively
+in sorted order, but that order does not give one file higher precedence.
+An explicitly selected missing/unreadable root fails; an empty root contributes
+nothing. Imports are disabled by these helpers unless the caller enables them
+on an input. Single files can use ConfigKit inputs directly.
 
-Profile sources resolve matching IDs in this order:
-
-1. in-memory profiles supplied with `WithProfiles`;
-2. the ordinary configured source selected by a profile file, `fs.FS`, or
-   configured profile directory;
-3. application fallback profiles supplied with `WithFallbackProfileFS`; and
-4. Promptkit-owned profiles; and
-5. maintained external catalog profiles.
-
-A profile source supplies a complete definition; definitions and their fields
-are not merged across sources. A higher-precedence source falls back only when
-the requested profile ID is absent. An invalid matching profile is an error and
-does not fall back. In-memory `Profile` values follow the same ranges as YAML
-profiles. They use `APIKeyRequired` for request-scoped credentials instead of
-`api_key_env`. Preparation and exact profile inspection use this same source
-precedence.
-
-When a selected definition names `base_profile`, every profile ID in that
-chain is looked up through this same precedence order. A higher-precedence
-definition therefore shadows a lower-precedence definition of the same base
-ID, including a built-in. References are not source-qualified.
+Backends, profiles, and prompts all follow these same source rules. A later
+profile or backend can change individual fields of a lower definition. A
+request `ProfileID` takes precedence over a prompt `default_profile`; if
+neither is selected, preparation fails. Exact profile inspection selects one
+explicit ID and does not consult a prompt default.
 
 ### Profile Inheritance
 
-Promptkit resolves one linear base chain of at most 32 profiles, including the
-selected profile. It merges settings from the root base to the selected leaf.
-The leaf's `id` remains the selected profile identity. Nonblank string fields
-(`backend`, `endpoint`, `model`, `service_tier`, `reasoning_effort`, and
-`api_key_env`) and nonzero numeric fields replace inherited values. A nonempty
-`extra_params` map replaces the complete inherited map rather than merging
-keys, and `APIKeyRequired: true` remains true through the chain. Backend and
-endpoint are independent: replacing one does not clear the other.
-
-There is no profile-level clearing syntax. Blank strings, zero numbers, false,
-and empty maps remain unspecified and inherit from a base. Use existing
-presence-aware request overrides where an execution needs an explicit zero or
-empty reasoning setting.
-
-An absent directly selected profile reports the ordinary not-found error. Once
-the selected profile exists, a missing base, cycle, overlong chain, or
-incomplete resolved target is a profile-load failure. Ordinary operations
-resolve chains afresh; prepared execution retains the fully resolved target.
+ConfigKit resolves `extends` on effective profile definitions. One profile
+may inherit another keyed profile; presence, explicit null, and recursively
+merged maps determine the final fields. References are literal IDs, including
+IDs containing punctuation. There is no Promptkit-specific depth limit or
+second base-chain resolver. Missing references and cycles fail at construction.
+For generic inheritance and layer mechanics, consult
+[ConfigKit](https://gitea.maximumdirect.net/eric/ConfigKit).
 
 ## Built-In Profile Catalog
 
-Every built-in profile selects one maintained built-in backend and inherits
-that backend's connection and credential metadata. Profile files do not repeat
-those values. A configured, application fallback, or in-memory profile with
-the same profile ID takes precedence.
-
-Promptkit owns two opt-in profiles. The following definitions are current
-selections, not automatic defaults:
+Promptkit contributes two opt-in definitions; neither is selected by default:
 
 | ID | Current definition |
 | --- | --- |
-| `promptkit-openrouter-standard` | Inherits `gemini-flash-latest`. |
+| `promptkit-openrouter-standard` | Extends the selected OpenRouter catalog's `gemini-flash-latest` profile. |
 | `promptkit-openrouter-auto` | Selects backend `openrouter` and model `openrouter/auto`. |
 
-Select either name through an existing request `profile_id` or prompt
-`default_profile`. Consumers can replace either definition or its inherited
-base through the ordinary profile-source precedence above. The
-[release policy](policy/release.md#catalog-profile-compatibility) defines the
-cross-version guarantee for these names.
+Select one through request `ProfileID` or prompt `default_profile`.
+Caller layers may overlay these definitions or their catalog bases. The
+[release policy](policy/release.md#catalog-profile-compatibility) owns their
+cross-version compatibility boundary.
 
 ## External Profile Inventories
 
-The external profile inventory is defined by the selected catalog modules, not
-duplicated here. Browse the exact data selected by this Promptkit version:
+The selected catalog modules, not this document, own their profile inventories:
 
-- [OpenRouter catalog v2.20260926.0 profiles](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/tag/v2.20260926.0/catalog/profiles)
-- [Rakestrawhome catalog v2.20260926.0 profiles](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/tag/v2.20260926.0/catalog/profiles)
+- [OpenRouter catalog v3.20260930.0 profiles](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/tag/v3.20260930.0/catalog/profiles)
+- [Rakestrawhome catalog v3.20260930.0 profiles](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/tag/v3.20260930.0/catalog/profiles)
 
-External profile entries are volatile across catalog releases. The
-[release policy](policy/release.md#catalog-profile-compatibility) owns the precise
-compatibility boundary; a selected module version identifies tested local data,
-not live provider availability.
+These are tested local data, not a promise of live provider availability.
+The [release policy](policy/release.md#catalog-profile-compatibility) owns
+the compatibility boundary.
 
 ## Schemas
 
-Schemas are JSON documents selected by a prompt or request
-`schema_path`. For a directory or `fs.FS` source, paths resolve within the
-configured source root. Referenced nested schemas resolve relative to the
-owning schema document. `WithSchemaFile` exposes one schema, addressed by its
-base name.
-
-An unreadable, invalid, or unresolvable schema produces an operational
-validation error. Generated content that is valid JSON but does not satisfy the
-schema produces a failed validation result.
+Schemas are JSON documents selected by a prompt or request `schema_path`.
+Directory and `fs.FS` schema paths resolve within the configured root;
+referenced nested schemas resolve relative to the owning schema document.
+`WithSchemaFile` exposes one schema under its base name. An unreadable,
+invalid, or unresolvable schema causes an operational validation error.
+Valid JSON that fails the schema instead yields a failed validation result.
 
 ## Credentials
 
-Credential values belong at the request or environment boundary, never in
-prompt, profile, schema, or example files:
+Only environment-variable names belong in backend/profile definitions, never
+credential values. A request may supply a direct `APIKey` or an `APIKeyEnv`
+override. A direct key takes precedence, followed by a request environment
+source, an explicit profile source, and an inherited backend source. A true
+profile `api_key_required` suppresses the backend-derived environment source,
+but an explicit profile or request environment source remains usable. False
+restores ordinary optional-credential behavior. Missing or blank optional
+environment values leave the built-in client's Authorization header absent;
+required availability is checked at preparation and again during prepared
+execution. Injected clients own their credential-resolution behavior.
 
-- a backend or file profile can name an optional environment lookup source
-  with `APIKeyEnv` or `api_key_env`;
-- an in-memory profile may set `APIKeyRequired` as an explicit local
-  requirement;
-- a request can provide a direct `APIKey` or override the optional `APIKeyEnv`
-  source; and
-- a direct request key takes precedence over environment lookup.
-
-After a direct request key, the credential-source precedence is request
-`APIKeyEnv`, profile `api_key_env`, then the backend default. An in-memory
-profile with `APIKeyRequired` clears an inherited backend environment name and
-requires a direct key unless the request explicitly supplies `APIKeyEnv`.
-Named environment sources are optional: when the selected source is absent,
-empty, or whitespace-only, the built-in client omits the `Authorization`
-header and handles the provider response normally. `APIKeyRequired` is the
-only explicit local availability requirement. Promptkit validates required
-credential availability during preparation and rechecks it when a prepared
-execution runs. Injected clients receive resolved source metadata but define
-their own credential-resolution behavior.
-Direct keys are excluded from JSON results and redacted by public string
-formatters. Environment-variable names may appear in prepared metadata, but
-their values do not.
+Credential values are excluded from JSON results and redacted by public
+string formatters. ConfigKit inspection redacts credential-shaped dynamic
+provider keys, but does not make arbitrary prompt/provider content safe to
+disclose. Applications own report disclosure and secret handling.

docs/integrations/openai-compatible-chat.md

@@ -78,9 +78,8 @@ The client conditionally includes:
 
 The engine resolves backend, profile, and request extra-parameter maps by
 whole-map replacement rather than key merging. The resulting effective map is
-then merged directly into the top-level body after JSON serialization is
-verified. Empty keys and collisions with these reserved fields are rejected
-before any provider call:
+merged into the top-level body. Empty keys, values that cannot be encoded, and
+collisions with these reserved fields are rejected before any provider call:
 
 - `model`
 - `session_id`

docs/internal/llm.md

@@ -34,9 +34,13 @@ resolved request target may supply the endpoint. Generation preparation then:
 1. validates shared execution-setting invariants and the final selected base
    endpoint;
 2. maps the internal request into the OpenAI-compatible chat payload;
-3. validates and merges extra parameters;
+3. checks extra-parameter keys against empty and reserved names, then merges
+   their values into the payload;
 4. composes `/chat/completions` through parsed URL path operations;
-5. resolves authentication and freezes the URL, body, and optional credential.
+5. encodes the complete body once on success. If encoding fails, extra values
+   are checked individually to retain invalid-request classification; otherwise
+   the complete-request failure remains a request failure;
+6. resolves authentication and freezes the URL, body, and optional credential.
 
 Each execution of that prepared request creates a fresh HTTP request, body
 reader, and attempt timeout context. It closes the response body and returns

docs/internal/overview.md

@@ -11,27 +11,28 @@ contributor workflow and validation.
 
 | Component | Implemented responsibility | References |
 | --- | --- | --- |
-| Root `promptkit` package | Provides the supported engine facade, source, backend-registration, and injection options, public request, result, prompt-inspection, profile-inspection, and ordinary-run observation values, opaque prepared-execution handles, profile construction, extension interfaces, value conversion, redacted formatting, and typed capacity and generation error mapping. | [Package GoDoc](../../doc.go), [observations](../../observations.go), [prepared execution](../../prepared_execution.go), [backend API](../../backends.go), [engine facade](../../engine.go) |
-| `examples/go-library/prepare` | Demonstrates an offline downstream consumer using a prompt file, in-memory profile, inline input, and `Prepare`. It is not a public library package. | [Example program](../../examples/go-library/prepare/main.go) |
-| `examples/go-library/run` | Demonstrates an offline downstream consumer using a prompt file, in-memory profile, inline input, an injected deterministic model client, and `Run`. It is not a public library package. | [Example program](../../examples/go-library/run/main.go) |
+| Root `promptkit` package | Provides the supported engine facade, ConfigKit source helpers, profile and backend mapping conveniences, injection options, public requests and results, prompt/profile/requirement inspection and identity listing, concrete-request validation, observation values, opaque prepared-execution handles, value conversion, redacted formatting, and typed capacity and generation error mapping. | [Package GoDoc](../../doc.go), [observations](../../observations.go), [prepared execution](../../prepared_execution.go), [backend API](../../backends.go), [engine facade](../../engine.go), [identity listing](../../listing.go), [requirement facade](../../requirements.go) |
+| `examples/go-library/prepare` | Demonstrates offline preparation and explicit configuration inspection with a prompt file, programmatic profile, and inline input. It is not a public library package. | [Example program](../../examples/go-library/prepare/main.go) |
+| `examples/go-library/run` | Demonstrates an offline downstream consumer using a prompt file, programmatic profile, inline input, an injected deterministic model client, and `Run`. It is not a public library package. | [Example program](../../examples/go-library/run/main.go) |
 | `examples/go-library/observe` | Demonstrates offline built-in HTTP retry and synchronous metadata observation across structured proposal and assessment runs using embedded sources, two profiles on one finite backend, and an application decision. It is not a public library package. | [Example program](../../examples/go-library/observe/main.go) |
-| `internal/backend` | Constructs each engine's immutable registry from maintained definitions and consumer additions, validates and defensively copies definitions through the shared JSON-value package, and consumes the LLM-owned OpenAI-compatible reserved request-field rule. | [Backend registry](../../internal/backend/registry.go) |
-| `internal/catalog` | Strictly validates imported immutable maintained backend and profile catalog assets before engine assembly uses them. | [Catalog adapter](../../internal/catalog/catalog.go), [internal sources](sources.md#profiles-and-built-ins) |
+| `internal/backend` | Holds a defensive, immutable lookup and capacity-policy index for final backend definitions validated by the configuration adapter. | [Backend registry](../../internal/backend/registry.go) |
+| `internal/catalog` | Selects released keyed catalog assets and PromptKit-owned profile definitions as ConfigKit underlays; effective validation belongs to the configuration loader. | [Catalog adapter](../../internal/catalog/catalog.go), [internal sources](sources.md#profiles-and-built-ins) |
+| `internal/configuration` | Loads keyed backend, profile, and prompt configuration through ConfigKit; records effective field presence, validates final values, captures indexed prompt definitions, referenced message content, compiled templates, input metadata snapshots, sorted identity-only profile and prompt inventories, backend and presence-aware profile snapshots, and an explicit read-only inspection view. | [Typed loader](../../internal/configuration/load.go), [identity listing](../../internal/configuration/listing.go), [internal sources](sources.md#typed-configuration-loading) |
 | `internal/capacity` | Owns engine-local bounded execution admission and FIFO model-generation permits for limited backend IDs, including cancellation-safe waiter removal and client wrapping. | [Internal capacity management](capacity.md) |
-| `internal/domain` | Defines internal framework values for requests, artifacts, prompt definitions, profiles, execution targets, rendering, generation, and validation, and owns source-neutral invariants for shared execution settings, OpenAI-compatible base endpoints, session identifiers, and output contracts. Source parsing, required fields, other source-specific normalization, defaulting, and boundary-specific error classification remain with their callers. | [Domain declarations](../../internal/domain/domain.go), [endpoint invariant](../../internal/domain/endpoint.go) |
-| `internal/engine` | Assembles external catalogs, Promptkit-owned profiles, repositories, registry, capacity, collaborators, repairer, and the one use-case runner for each engine instance. | [Engine assembly](../../internal/engine/engine.go), [internal sources](sources.md#profiles-and-built-ins), [internal runner](runner.md) |
+| `internal/domain` | Defines internal framework values for requests, artifacts, prompt definitions, requirement inspection, profiles, execution targets, rendering, generation, and validation, and owns source-neutral invariants for shared execution settings, OpenAI-compatible base endpoints, session identifiers, and output contracts. Source parsing, required fields, other source-specific normalization, defaulting, and boundary-specific error classification remain with their callers. | [Domain declarations](../../internal/domain/domain.go), [requirement values](../../internal/domain/requirements.go), [endpoint invariant](../../internal/domain/endpoint.go) |
+| `internal/engine` | Assembles selected catalog and caller configuration into one snapshot, then constructs capacity, rendering, validation, generation, repair, and the use-case runner for each engine. It delegates identity listing directly to the captured configuration inventory rather than the runner. | [Engine assembly](../../internal/engine/engine.go), [internal sources](sources.md#profiles-and-built-ins), [internal runner](runner.md) |
 | `internal/generation` | Coordinates frozen built-in HTTP attempts and one-shot injected calls through active backend permits, including bounded status retries, cancellable backoff, and attempt observations. | [Internal generation coordination](generation.md) |
 | `internal/defaults` | Defines application-neutral framework constants and constructs the default execution target. It contains no CLI, server, or inbound HTTP limits. | [Framework defaults](../../internal/defaults/defaults.go) |
 | `internal/filecatalog` | Provides deterministic YAML discovery and path helpers for operating-system filesystems and `fs.FS` sources. | [File catalog](../../internal/filecatalog/catalog.go) |
 | `internal/jsonvalue` | Validates and deeply copies bounded JSON-compatible extra-parameter and prepared-schema trees while preserving supported concrete value types and rejecting cycles or excessive depth and work. | [JSON values](../../internal/jsonvalue/jsonvalue.go) |
-| `internal/promptdef` | Loads strictly decoded, validated prompt definitions from filesystem and `fs.FS` sources, including version selection and contained file-backed message content. | [Framework formats](../formats.md), [prompt-definition repository](../../internal/promptdef/filesystem_repository.go) |
-| `internal/profile` | Owns immutable in-memory and filesystem profile repositories, local profile validation, raw-source overlays with error-preserving fallback, and inherited-profile resolution. | [Framework formats](../formats.md), [profile repositories](../../internal/profile/filesystem_repository.go), [internal sources](sources.md#profiles-and-built-ins) |
-| `internal/prompt` | Renders prompt messages from Go templates with artifact, variable, session, and cache-control data. | [Go-template renderer](../../internal/prompt/go_renderer.go) |
+| `internal/promptdef` | Provides a narrow captured-prompt lookup contract, not-found identity, and execution-ready definition hash. | [Prompt lookup](../../internal/promptdef/repository.go), [framework formats](../formats.md) |
+| `internal/profile` | Provides a narrow captured-profile lookup contract and not-found identity. | [Profile lookup](../../internal/profile/repository.go), [framework formats](../formats.md) |
+| `internal/prompt` | Renders prompt messages from Go templates with artifact, variable, session, and cache-control data, and conservatively enumerates dependencies from captured template syntax. | [Go-template renderer](../../internal/prompt/go_renderer.go), [requirement discovery](../../internal/prompt/requirements.go) |
 | `internal/artifact` | Resolves ordinary inline and unrestricted caller-selected file references into copied artifacts with metadata and hashes. | [Internal sources and validation](sources.md) |
 | `internal/validate` | Validates basic, JSON, and JSON Schema output using operating-system filesystem or `fs.FS` schema sources and creates operation-local validation plans with canonical contained schema resources. | [Framework formats](../formats.md#schemas), [internal sources and validation](sources.md) |
 | `internal/llm` | Defines the internal generation boundary and implements outbound OpenAI-compatible chat requests from resolved execution targets, including bounded structured non-success response decoding, successful-response decoding, authentication, deadline handling, and ownership of the OpenAI-compatible reserved request-field policy. | [Internal model client](llm.md) |
 | `internal/observation` | Owns invocation-local run IDs, presence-aware usage and phase accounting, and synchronous metadata event delivery for ordinary and claimed prepared runs and generation attempts. | [Internal execution observation](observation.md) |
-| `internal/usecase` | Resolves prompt definitions and hashes, profiles, backends, and targets for exact inspection and request settings for preparation, and coordinates ordinary and single-claim prepared execution across internal sources, rendering, artifact loading, operation-local validation plans, generation, capacity, and bounded repair. | [Internal runner](runner.md), [prepared-execution implementation](../../internal/usecase/prepared_execution.go) |
+| `internal/usecase` | Selects captured prompts and profiles, enumerates requirements from captured prompt syntax, applies request overrides and completion checks, and coordinates ordinary and single-claim prepared execution across rendering, artifact loading, operation-local validation plans, generation, capacity, and bounded repair. | [Internal runner](runner.md), [requirement inspection](../../internal/usecase/requirements_inspection.go), [prepared-execution implementation](../../internal/usecase/prepared_execution.go) |
 
 The internal engine assembles these internal components without exposing their
 representations. Consumers depend only on the root facade.

docs/internal/runner.md

@@ -4,7 +4,7 @@
 
 This document describes Promptkit's implemented internal orchestration. The
 [architecture policy](../policy/architecture.md) owns dependency and consumer
-boundaries. The [source and validation document](sources.md) owns repository,
+boundaries. The [source and validation document](sources.md) owns configuration,
 artifact, rendering, and validation behavior, while the
 [model-client document](llm.md) owns generation behavior and failure
 categories.
@@ -16,11 +16,10 @@ and override semantics consumed by the runner.
 
 ## Collaborators
 
-`Runner` coordinates narrow internal interfaces for prompt definitions,
-profiles, backend resolution, artifacts, rendering, model generation, and
-validation. The internal engine supplies one immutable registry containing the
-built-in backend and validated consumer additions, one engine-local run
-admitter, and a generation coordinator using the same capacity manager. Validation
+`Runner` coordinates narrow internal interfaces for captured prompt definitions
+and resolved profiles, artifacts, rendering, model generation, and validation.
+The internal engine supplies one engine-local run admitter and a generation
+coordinator using the same capacity manager. Validation
 plans and provider-facing schema metadata come from the validator's preparation
 interface.
 The internal engine supplies one default output repairer through the explicit
@@ -33,28 +32,40 @@ The runner has no durable run or session store.
 
 ## Shared Prompt Selection
 
-The runner uses one prompt-selection and hashing boundary for ordinary
-preparation and exact prompt inspection. Preparation retains its early
-request-ID check before direct-session normalization; both operations then use
-the configured prompt repository to select one definition, load referenced
-message content, and calculate the same prompt hash.
+Ordinary preparation selects the full prompt definition and construction-time
+hash. It retains its early request-ID check before direct-session
+normalization. Referenced message content and static template syntax were
+captured when the engine was built.
 
-Inspection stops after that structural lookup. It does not parse templates or
-touch profile, artifact, schema, renderer, validator, admission, or model
-collaborators. The root [`Engine.InspectPrompt`](../../engine.go) GoDoc owns
-the public operation's exact contract.
+`InspectPrompt` selects captured metadata through an optional repository
+capability, falling back to the full definition and existing hash resolution
+for internal repositories without it. It returns owned metadata without
+rendering templates or touching profile, artifact, schema, renderer, validator,
+admission, or model collaborators. The root
+[`Engine.InspectPrompt`](../../engine.go) GoDoc owns the public operation's
+exact contract.
+
+`InspectRequirements` uses the same metadata selection to resolve the
+request-profile/default identity, then obtains the exact captured requirement
+snapshot by the selected prompt ID and version. The analyzer receives only
+those identity fields rather than an execution definition. It analyzes the
+snapshot with the supplied caller variables and normalized direct-session
+bypass; it does not resolve target readiness or enter the preparation
+pipeline. Missing snapshot capability is a prompt-load failure rather than a
+source fallback. The root
+[`Engine.InspectRequirements`](../../requirements.go) GoDoc owns the public
+operation's exact contract.
 
 ## Shared Profile Selection
 
 The runner uses one profile-selection and target-resolution boundary for
 ordinary preparation and exact profile inspection. Preparation first selects a
 request profile or a prompt default; inspection begins with its required
-explicit profile ID. Both then apply the ordinary source precedence, resolve a
-named backend, and construct the effective target from framework, backend, and
-profile values.
-
-Inspection stops after the resulting endpoint and model are structurally
-validated. It does not check credential availability or perform prompt,
+explicit profile ID. Both use the captured, presence-aware target constructed
+from the final effective profile and backend configuration. Request overrides
+apply afterward; preparation checks endpoint and model completeness only after
+those overrides. Inspection can report a partial profile without requiring a
+runnable target. Neither path checks credential availability or performs prompt,
 artifact, schema, rendering, admission, or model-client work. The root
 [`Engine.InspectProfile`](../../engine.go) GoDoc owns the public operation's
 exact contract.
@@ -66,11 +77,10 @@ where a run can be assigned to its selected backend pool. The resolution phase
 performs only the work needed to validate routing and admission:
 
 1. validate the required prompt selection and normalize any direct session ID;
-2. load the prompt definition and hash the original definition;
+2. select the captured prompt definition and hash;
 3. select the request profile or the prompt's default profile;
-4. resolve the profile's backend ID, when present;
-5. resolve application-neutral defaults, backend defaults, profile values,
-   and explicit request overrides in that order;
+4. retain the profile's selected backend identity, when present;
+5. apply explicit request overrides to its captured backend-completed target;
 6. validate endpoint, model, numeric overrides, and credential requirements;
 7. resolve and validate the effective output contract without loading its
    schema; and
@@ -95,33 +105,42 @@ one execution-precedence and error-ordering implementation while allowing a
 full backend pool to reject work before expensive schema, artifact, and
 rendering operations. `Prepare` discards the plan after returning its public
 metadata. `Run` retains the plan through initial and repaired-output validation
-and discards it when the operation ends. Prepared execution stores the same
-kind of plan only in its private payload.
+and discards it when the operation ends. Prepared execution transfers the
+completed preparation's owned message, input-hash, and copied-schema values
+into its private payload, while deep-copying mutable provider extras and
+creating an independent details snapshot. Claim completion or discard clears
+the execution payload without removing the details snapshot.
+
+The root facade's `Engine.ValidateRequest` uses the same complete preparation
+path as `Prepare` and discards the resulting internal prepared value without
+converting it into a public snapshot. It does not add a runner operation or
+validator component; request conversion and public error mapping remain at the
+facade boundary.
 
 Pointer-based numeric overrides preserve an explicit zero. Invalid negative or
 out-of-range values fail as invalid requests. Endpoint overrides do not change
 the selected backend identity. Non-empty extra-parameter maps replace whole
 lower-precedence maps. A direct API key takes precedence over environment
-lookup; otherwise request, profile, and backend environment-variable names
-apply in that order. A profile requiring a direct key clears an inherited
+lookup; otherwise request, explicit profile, and backend environment-variable
+names apply in that order. A profile requiring a direct key suppresses an inherited
 backend environment name unless the request supplies its own name. Secret
 values remain excluded from serialized metadata.
 
 Reasoning overrides are tri-state: nil inherits the profile, a pointer to a
 nonblank string trims and replaces it, and a pointer to a blank string clears
-it. A nonblank direct session is normalized before source loading, bypasses
+it. A nonblank direct session is normalized before prompt selection, bypasses
 the prompt session template, and is applied after ordinary message rendering.
 A blank direct value retains prompt-template behavior. The runner clears the
 template only on a value copy of the definition, so the definition hash always
-describes the original source while the rendered-prompt hash includes the
+describes captured effective content while the rendered-prompt hash includes the
 effective direct or rendered session and the complete effective message
 sequence. The rendered-prompt hash uses a versioned, length-framed SHA-256
 encoding of that session, every role and content value, and cache-control
 presence and values; its hexadecimal value is opaque.
 
-The registry is read-only after engine construction. Concurrent `Prepare` and
-`Run` calls resolve independent defensive backend values and keep all
-invocation state local.
+The configuration snapshot is read-only after engine construction. Concurrent
+`Prepare` and `Run` calls copy their resolved targets and keep all invocation
+state local.
 
 ## Run Flow
 
@@ -215,7 +234,7 @@ generation, validation, repair, and cancellation failures.
 Other context cancellation propagates through the invoked collaborator and is
 classified by the owning operation. In particular, cancellation observed by
 validation retains the context identity through the validation error category.
-An overlong direct session is an invalid request before source loading, while
+An overlong direct session is an invalid request before prompt selection, while
 an invalid or overlong prompt session template remains a prompt-render failure.
 An unknown selected backend, or a selected backend with no configured resolver,
 is classified as a profile-load failure.

docs/internal/sources.md

@@ -2,117 +2,141 @@
 
 ## Purpose
 
-This document describes Promptkit's implemented internal source, artifact,
+This document describes Promptkit's implemented configuration, artifact,
 rendering, and output-validation behavior. The
-[architecture policy](../policy/architecture.md) owns the library boundary and
-dependency rules. None of these internal packages is a supported consumer API,
-and the internal engine assembles them behind the public facade's source options and values.
-The [framework format reference](../formats.md) owns the exact file fields,
-validation modes, built-in catalog, and source precedence.
+[architecture policy](../policy/architecture.md) owns dependency rules, while
+the [framework format reference](../formats.md) owns fields, defaults, and
+source semantics. Internal packages are not consumer APIs.
+
+## Typed Configuration Loading
+
+`internal/configuration` is the single adapter from ConfigKit's final
+effective configuration to execution-owned definitions. It performs one
+layered load, captures effective presence (including explicit null), records
+normalization and defaults through resolution, and validates all effective
+backend, profile, and prompt values. Replaced lower-layer domain values are
+not separately validated. It builds an immutable backend index and
+presence-aware profile targets, applying final backend defaults only after
+profile inheritance. It retains ConfigKit's result privately for explicit
+inspection, not for per-run resolution. The runtime/domain packages do not
+depend on ConfigKit.
+
+The `ConfigurationInspection.Diff` facade method compares two retained results
+through a private wrapper and a narrow `internal/configuration.Diff` bridge.
+The wrapper keeps `Result[document]` inside the adapter; the bridge delegates
+once to ConfigKit v0.7.0 and returns its public difference records. Comparison
+uses only frozen effective values and does not reopen sources, resolve runtime
+credentials, or enter the execution path. ConfigKit applies sensitivity from
+both results; reports may still contain ordinary application data. See the
+[consumer comparison guide](../consumers/pkg-promptkit.md#inspect-the-captured-configuration)
+and ConfigKit's [v0.7.0 comparison contract](https://gitea.maximumdirect.net/eric/ConfigKit/src/tag/v0.7.0/docs/config.md#effective-configuration-diffs).
+
+After prompt materialization and effective-profile snapshot construction, the
+adapter captures lexically ordered, identity-only inventories from the final
+prompt and indexed-profile maps. Its listing methods return caller-owned copies
+of those inventories without consulting ConfigKit or copying definitions.
+
+The root `DirectoryInputs` and `FilesystemInputs` helpers discover sorted YAML
+files under an explicit root, provide resource context, and leave imports
+disabled. Each returned slice belongs to one strict-composition group; file
+order does not confer priority. The engine prepends selected catalog and
+Promptkit-owned definitions, then caller underlays and optional main. The
+[configuration tests](../../internal/configuration/load_test.go) exercise the
+real loader and final-value handoff.
 
 ## Prompt Definitions
 
-`internal/promptdef` uses one source-neutral flow for prompt selection and
-normalization. That flow scans normalized YAML ID and version metadata,
-requires one strictly decoded document per file, classifies errors for the
-selected definition, detects duplicates, and normalizes the exact match.
-Small operating-system and `fs.FS` adapters own discovery, byte reads, display
-paths, content opening, and root containment. Each lookup remains a
-point-in-time scan: definitions and catalogs are not cached, and file-backed
-message content is opened only for the exact selected candidate.
+The configuration adapter indexes each prompt by exact ID and version,
+materializes file-backed message content using the exact effective field's
+origin and resource context, and checks static message/session template syntax
+at construction. It stores captured content, compiled templates, declared
+input metadata, and a definition hash. Alongside the unchanged hashed
+definition, it retains content-type and description presence for each declared
+input and provides an internal requirement snapshot with those declarations
+and the captured parses. Metadata values come from the final normalized
+declaration; absent and null fields remain distinguishable from explicit
+strings, including empty strings. It closes content-file handles before
+returning and retains no source capability for public inspection.
 
-Message roles are normalized through the shared domain owner by trimming
-Unicode whitespace and lowercasing. Only `developer`, `system`, `user`, and
-`assistant` are published; invalid roles remain selected prompt-definition
-failures rather than becoming request errors. Cache-control metadata uses the
-same shared domain normalization and defensive-copy rule.
+Role and cache-control normalization is applied to execution-owned message
+copies. ConfigKit v0.7.0 retains effective input message metadata and its
+resource origins; recording a sequence-wide normalization in the retained
+configuration would replace origins of unchanged content-file fields.
 
-Operating-system sources enforce containment against canonical roots and
-targets so symlinks cannot escape. Injected `fs.FS` sources enforce containment
-in their clean relative path namespace. A single-file source uses the selected
-prompt file's containing directory as its root. Every content path must be
-relative and is opened from its exact parsed text after a separate blank check;
-contained parent components and whitespace-bearing names remain valid.
+The runner selects full definitions from this index for preparation and uses
+captured prompt metadata for `InspectPrompt` and `InspectRequirements`; the
+internal requirement snapshot lookup selects by exact prompt ID and version.
+These paths do not rescan configuration or reopen message files. `InspectPrompt`
+returns declared metadata without rendering or resolving profile, input, or
+schema resources, and its public shape and prompt hashes do not include the
+captured presence state. Runtime rendering still checks request variables and
+input helpers. The [prompt adapter tests](../../internal/configuration/prompts_test.go)
+cover resource origins, context containment, capture, and selection.
 
-Exact prompt inspection performs one point-in-time lookup through that same
-repository and validates referenced message content before returning declared
-metadata. It does not parse templates or read profile, input, or schema
-sources, and it does not retain the definition for a later execution.
+The configuration adapter shares exact ID/version selection across its
+internal prompt lookups. The execution snapshot lookup returns an owned prompt
+definition and cached hash; metadata inspection returns owned input metadata
+without copying execution templates. Profile selection likewise has an
+identity-only lookup for consumers that do not need the execution target,
+while the full profile lookup continues to return an owned target and deep copy
+of provider extras. These lookups use captured indexes and do not query
+ConfigKit again.
 
-Its package tests own prompt selection, strict decoding, definition validation,
-duplicate detection, and source containment:
-[prompt-definition repository tests](../../internal/promptdef/repository_test.go).
+The `internal/prompt` requirement walker uses the captured parse trees and
+declaration metadata without executing templates or reading artifacts. It
+collects literal `input` names, direct root caller keys, and literal-key
+`index` lookups. For `if` and `with`, it classifies branches when their
+conditions are simple supported values: direct values, literals, negation, or
+two-string equality/inequality. It uses Go template truthiness, so a supplied
+nonempty string such as `false` is true. Missing decision values and
+content-dependent conditions leave dependency-bearing branches conditional
+and report incomplete discovery; unresolved conditions with no branch
+dependencies do not by themselves make discovery incomplete. Recognizable
+references on known skipped paths remain optional inventory entries with an
+inactive-use explanation, unless another applicable use establishes a
+stronger classification. Skipped expressions are scanned only for
+syntactically recognizable names and are not evaluated. A direct caller value
+or literal-key lookup can also supply an input name, including through simple
+parentheses or a direct pipeline to `input`; names are used exactly as
+supplied. Unresolved names and unsupported dependency-bearing expressions
+produce structured limitations while retaining recognizable references.
+Where an unresolved name or scope could affect existing optional entries, those
+entries are reported as conditional rather than inactive-only or definitively
+optional. Direct root-map `with` forms retain caller-map identity. Known scalar
+values remain separate from unknown scopes; accesses through untracked local
+maps report incomplete discovery rather than silently losing caller keys.
+Unsupported name expressions reuse value analysis's conservative syntax scan
+instead of recursively rescanning the same subtree.
+Invoked named templates are scanned conservatively, and
+dependency-bearing range scopes make discovery incomplete. Uncalled definitions
+and bypassed session templates are not traversed. This internal walker does not
+change rendering behavior.
 
 ## Profiles And Built-Ins
 
-`internal/profile` owns immutable in-memory and filesystem repositories, local
-validation, overlays, and resolution for execution profiles. In-memory
-definitions are normalized and validated once at that repository boundary and
-are defensively copied on storage and lookup. A file contains
-exactly one YAML document and its trimmed YAML `id` is its only selection
-identity; filenames do not confer authority. Each point lookup reads discovered
-files once for their metadata and reuses the selected file's bytes for strict
-decoding; unrelated profiles are not fully decoded. Strict selected decoding
-recognizes `base_profile` and the optional `backend` field, trims their values,
-and permits inherited target fields only when a base is named. File-backed
-`extra_params` values are validated and defensively copied through the shared
-bounded JSON-value owner before a profile is published. OpenAI-compatible
-reserved-field policy remains with the model-client and backend-registry owners.
+`internal/catalog` selects the released keyed OpenRouter and Rakestrawhome
+assets as one ConfigKit underlay and PromptKit-owned profiles as the next.
+It discovers YAML inputs and supplies passive filesystem context without
+parsing or pre-validating catalog definitions. The configuration loader
+validates only the final effective backend and profile values, including
+consumer overlays of maintained bases or backends. There is no catalog-only
+preflight, reserved source namespace, or replay of backend registration.
 
-`LoadFSRepository` is the eager immutable loading boundary for internal
-catalog consumers. It discovers and strictly validates every raw profile once,
-preserves safe source metadata including explicitly present YAML fields, and
-publishes independently copied values from memory. It does not resolve profile
-inheritance. Configured consumer sources continue to use the lazy point lookup
-repositories described above.
+ConfigKit resolves profile inheritance before the handoff. The configuration
+adapter validates effective references and field values, then builds target
+snapshots with backend defaults and presence/suppression state. A profile can
+remain partial until runtime overrides complete it. `InspectProfile` selects
+that captured target without prompt, artifact, schema, credential lookup, or
+provider work. Preparation applies runtime overrides and then checks target
+completeness. Identity-only profile selection can identify a partial captured
+profile without copying its target or requiring readiness. The
+[target tests](../../internal/configuration/targets_test.go) cover effective
+target interpretation, while the [catalog tests](../../internal/catalog/catalog_test.go)
+cover selected released assets.
 
-`internal/catalog` validates the imported immutable OpenRouter and
-Rakestrawhome asset modules as one private adapter boundary. It enforces their
-manifest, layout, profile ownership, inheritance, and secret-safety rules
-before returning raw catalog sources. Internal engine assembly uses those validated
-catalogs as the lowest-precedence profile source.
-
-Normalized external catalog profile IDs with the exact `promptkit-` prefix are
-rejected at this adapter boundary. That reservation applies only to imported
-catalogs; configured consumer sources retain the ordinary profile-ID rules.
-
-The overlay repository consults the next repository only when the
-higher-precedence repository reports that a profile is absent. A reliably
-selected malformed profile stops fallback, while an unrelated malformed file
-does not become authoritative through its filename. Loading does not check
-backend registry membership because the available registry belongs to the
-assembled engine; the runner checks membership during preparation and exact
-profile inspection.
-
-The internal engine assembles one raw composite catalog in precedence order:
-in-memory profiles, one ordinary configured source, an application fallback
-source, Promptkit-owned profiles, then the maintained external catalog. It
-constructs the owned definitions through the in-memory repository and validates
-their maintained-only resolution and backend membership before consumer sources
-are overlaid. An explicit file or `fs.FS` profile source replaces
-`Config.ProfileDir` within the ordinary configured-source category. One outer
-resolving repository wraps that complete raw catalog, so each base lookup
-observes the same precedence and shadowing rules.
-
-The resolving repository traverses every selected chain afresh, retains no
-cache, detects cycles, limits a chain to 32 profiles, merges root-to-leaf into a
-new caller-owned value, and validates the final target before publishing it. It
-does not check backend registry membership. Exact `base_profile` syntax, merge
-rules, and consumer-visible failure behavior belong to the [framework format
-reference](../formats.md#profile-inheritance).
-
-Exact profile inspection performs one point-in-time resolved lookup through
-those profile sources and checks the final target without reading prompt, input,
-or schema sources. It does not retain that lookup for a later execution.
-Prepared execution instead freezes the fully resolved target; a later ordinary
-operation performs a fresh traversal.
-
-The imported external catalog provides external profiles and matching backend
-definitions. The internal engine owns the Promptkit profiles documented in the
-[framework format reference](../formats.md#built-in-profile-catalog). Profile
-loading and overlay behavior are owned by the [profile repository tests](../../internal/profile/repository_test.go), while
-catalog completeness, backend selection, and duplicate IDs are owned by the
-[catalog adapter tests](../../internal/catalog/catalog_test.go).
+The internal engine delegates listing through a narrow identity-inventory
+interface directly to the configuration snapshot. The execution runner has no
+listing responsibility.
 
 ## Ordinary Artifacts
 
@@ -123,10 +147,15 @@ and after opening the file. It copies content into an artifact, records
 metadata and an opaque content-equality value, and applies a content-type
 fallback.
 
-Regular files are read synchronously in bounded chunks. Cancellation is
-checked before opening, before and after every read, and before publishing the
-artifact, so a canceled read never publishes partial content. The ordinary
-reader does not detach file reads into background goroutines.
+Regular files are read synchronously in bounded chunks. The opened file's size
+is only an initial-capacity hint, capped at 1 MiB; reads continue to EOF, and
+the returned body determines artifact size and hash. If an overreported hint
+leaves unused capacity greater than the actual body length, the completed body
+is copied to release the excess backing storage, including when the body is
+empty. Cancellation is checked before opening, before and after every read,
+and before publishing the artifact, so a
+canceled read never publishes partial content. The ordinary reader does not
+detach file reads into background goroutines.
 
 This ordinary reader does not implement an inbound HTTP security boundary. In
 particular, it does not constrain files to an application root or impose an
@@ -137,19 +166,22 @@ implemented reader behavior and failures.
 
 ## Rendering
 
-`internal/prompt` renders definition messages as Go templates using named
-artifacts and variables. Within one render, each referenced artifact body is
-converted to text lazily and cached by input name for reuse across the session
-and every message; the cache is not shared across renders. Conversion uses
-bounded chunks and preserves the artifact bytes exactly.
+`internal/prompt` renders captured, pre-parsed definition templates using named
+artifacts and variables. It clones templates to bind request-specific input
+helpers without mutating shared state. Within one render, each referenced
+artifact body is converted to text lazily and cached by input name for reuse
+across the session and every message; the cache is not shared across renders.
+Conversion uses bounded chunks and preserves the artifact bytes exactly.
 
-Session and message parsing and execution remain synchronous. The renderer
-checks cancellation before and after each parse and execution boundary,
+Template parsing occurs during engine construction. Runtime execution remains
+synchronous. The renderer checks cancellation around execution boundaries,
 between artifact conversion chunks, around each message, and before publishing
 the complete prompt. It cannot interrupt template work already in progress and
 never publishes a partial prompt after observing cancellation. It validates and
 canonicalizes message roles before carrying roles, session IDs, and cache
-control into the rendered prompt. The
+control into the rendered prompt. Message and session templates execute into
+per-call string builders, so their rendered strings do not require a final
+buffer-to-string copy. The
 [renderer tests](../../internal/prompt/renderer_test.go) own rendering behavior.
 
 ## Schemas And Output Validation
@@ -157,7 +189,8 @@ control into the rendered prompt. The
 `internal/validate` provides validators backed by an operating-system
 filesystem or an `fs.FS`. Invalid generated content is returned as a validation
 result; inability to load, register, or compile a schema is an operational
-error.
+error. Basic validation checks body emptiness on the byte slice directly
+instead of first making a response-sized string copy.
 
 Every preparation operation creates one operation-local validation plan. None,
 basic, and JSON modes retain the effective output contract without source
@@ -181,9 +214,10 @@ not detach dependency work into background goroutines.
 `Prepare` discards its validation plan after returning metadata. `Run` retains
 its plan for initial and repaired-output validation, then discards it with the
 operation. `PrepareExecution` retains the plan in its private frozen payload;
-`RunPrepared` uses that plan without reopening prompt, profile, input, or
-schema sources or rerendering the request. A later ordinary `Run` always
-performs fresh source resolution and preparation.
+`RunPrepared` uses that plan without reopening configuration, message, input,
+or schema resources or rerendering the request. A later ordinary `Run` uses
+the same captured configuration but prepares request artifacts and schemas
+afresh.
 
 The [validator tests](../../internal/validate/standard_validator_test.go) own
 basic, JSON, JSON Schema, source resolution, schema loading, compilation,

docs/oss/attribution.md

@@ -6,45 +6,67 @@ Material: policy documents under `docs/policy/` and the Policy Reading Guide in
 `docs/development.md`, adapted for this repository; root `AGENTS.md`, copied
 without modification from upstream `agents/AGENTS.md`.
 
+The release policy uses upstream commit
+`e833faddf120c789a9b45348edaf75720de16348`; the remaining material uses
+`d84a38ebab26f048cafbe59a2246700c35d29843`.
+
 Copyright (C) 2026 Eric Rakestraw
 
 SPDX-License-Identifier: CC-BY-SA-4.0
 
 License and notices: [CC BY-SA 4.0](licenses/CC-BY-SA-4.0.txt) |
 [COPYRIGHT](https://gitea.maximumdirect.net/eric/policy/src/commit/d84a38ebab26f048cafbe59a2246700c35d29843/COPYRIGHT) |
-[LICENSE](https://gitea.maximumdirect.net/eric/policy/src/commit/d84a38ebab26f048cafbe59a2246700c35d29843/LICENSE).
+[LICENSE](https://gitea.maximumdirect.net/eric/policy/src/commit/d84a38ebab26f048cafbe59a2246700c35d29843/LICENSE) |
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/policy/src/commit/e833faddf120c789a9b45348edaf75720de16348/COPYRIGHT) |
+[LICENSE](https://gitea.maximumdirect.net/eric/policy/src/commit/e833faddf120c789a9b45348edaf75720de16348/LICENSE).
 
 [Source](https://gitea.maximumdirect.net/eric/policy/src/commit/d84a38ebab26f048cafbe59a2246700c35d29843).
 
-## Promptkit OpenRouter Catalog
+[Source](https://gitea.maximumdirect.net/eric/policy/src/commit/e833faddf120c789a9b45348edaf75720de16348).
 
-Selected module: `gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2`
-at `v2.20260926.0`.
+## ConfigKit
+
+Selected module: `gitea.maximumdirect.net/eric/ConfigKit` at `v0.7.1`.
+
+Copyright (C) 2026 Eric Rakestraw
+
+SPDX-License-Identifier: LGPL-3.0-or-later
+
+License and notices: [LGPL 3.0](../../LICENSE) |
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/ConfigKit/src/commit/6fffde4af8f31f99d3ee295c426eb3234cb0fb77/COPYRIGHT) |
+[LICENSE](https://gitea.maximumdirect.net/eric/ConfigKit/src/commit/6fffde4af8f31f99d3ee295c426eb3234cb0fb77/LICENSE).
+
+[Source](https://gitea.maximumdirect.net/eric/ConfigKit/src/commit/6fffde4af8f31f99d3ee295c426eb3234cb0fb77).
+
+## Promptkit OpenRouter Catalog v3
+
+Selected module: `gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v3`
+at `v3.20260930.0`.
 
 Copyright (C) 2026 Eric Rakestraw
 
 SPDX-License-Identifier: MIT
 
 License and notices: [MIT](licenses/MIT.txt) |
-[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/commit/4f731d217e0bc39151c010f50fb5912706e7b6b3/COPYRIGHT) |
-[LICENSE](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/commit/4f731d217e0bc39151c010f50fb5912706e7b6b3/LICENSE).
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/commit/f17d208cb7ad1fb043cda2266cd3011d11b40aa0/COPYRIGHT) |
+[LICENSE](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/commit/f17d208cb7ad1fb043cda2266cd3011d11b40aa0/LICENSE).
 
-[Source](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/commit/4f731d217e0bc39151c010f50fb5912706e7b6b3).
+[Source](https://gitea.maximumdirect.net/eric/promptkit-backend-openrouter/src/commit/f17d208cb7ad1fb043cda2266cd3011d11b40aa0).
 
-## Promptkit Rakestrawhome Catalog
+## Promptkit Rakestrawhome Catalog v3
 
-Selected module: `gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2`
-at `v2.20260926.0`.
+Selected module: `gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v3`
+at `v3.20260930.0`.
 
 Copyright (C) 2026 Eric Rakestraw
 
 SPDX-License-Identifier: MIT
 
 License and notices: [MIT](licenses/MIT.txt) |
-[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/commit/48918a3ad39fd99843cda94a86133b1b3881d596/COPYRIGHT) |
-[LICENSE](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/commit/48918a3ad39fd99843cda94a86133b1b3881d596/LICENSE).
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/commit/993443d88c451901f4c917fa00c204fd3b54d28d/COPYRIGHT) |
+[LICENSE](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/commit/993443d88c451901f4c917fa00c204fd3b54d28d/LICENSE).
 
-[Source](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/commit/48918a3ad39fd99843cda94a86133b1b3881d596).
+[Source](https://gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/src/commit/993443d88c451901f4c917fa00c204fd3b54d28d).
 
 ## jsonschema
 
@@ -73,7 +95,7 @@ License and notices: [BSD 3-Clause](licenses/BSD-3-Clause.txt) |
 
 ## Go YAML v3
 
-Selected module: `gopkg.in/yaml.v3` at `v3.0.1`.
+Selected module: `gopkg.in/yaml.v3` at `v3.0.1` (transitive dependency).
 
 Copyright (c) 2006-2010 Kirill Simonov
 
@@ -91,3 +113,22 @@ License and notices: [MIT](licenses/MIT.txt) |
 [NOTICE](https://github.com/go-yaml/yaml/blob/f6f7691b1fdeb513f56608cd2c32c51f8194bf51/NOTICE).
 
 [Source](https://github.com/go-yaml/yaml/tree/f6f7691b1fdeb513f56608cd2c32c51f8194bf51).
+
+## Go YAML v4
+
+Selected module: `go.yaml.in/yaml/v4` at `v4.0.0-rc.6` (transitive dependency).
+
+Copyright 2006-2010 Kirill Simonov
+
+Copyright 2011-2019 Canonical Ltd
+
+Copyright 2025 The go-yaml Project Contributors
+
+SPDX-License-Identifier: MIT AND Apache-2.0
+
+License and notices: [MIT](licenses/MIT.txt) |
+[Apache 2.0](licenses/Apache-2.0.txt) |
+[LICENSE](https://github.com/yaml/go-yaml/blob/1c17b9cee72bf81ae73a8be50fbd7dd3a9985125/LICENSE) |
+[NOTICE](https://github.com/yaml/go-yaml/blob/1c17b9cee72bf81ae73a8be50fbd7dd3a9985125/NOTICE).
+
+[Source](https://github.com/yaml/go-yaml/tree/1c17b9cee72bf81ae73a8be50fbd7dd3a9985125).

docs/policy/architecture.md

@@ -51,23 +51,22 @@ The [internal component overview](../internal/overview.md) owns the inventory
 of implemented packages and their concrete responsibilities. This policy owns
 the boundaries and dependency rules those components must preserve.
 
-The internal engine assembles one immutable backend registry, one capacity manager,
-the internal repositories, renderer, validator, outbound client, and use-case
-runner. The registry contains validated maintained definitions plus engine-scoped
-consumer additions. The root facade translates public values and errors at the
-library boundary.
-The internal engine constructs the capacity manager from the registry's immutable
-policy snapshot, wraps the selected built-in or injected model client, and
-supplies bounded admission to the runner. The defaults and renderer depend on
-the domain model. Prompt-definition and profile repositories use the domain
-model, file catalog, and YAML decoder. The catalog adapter validates imported
-immutable maintained data, including its reserved namespace, before internal
-engine assembly supplies it to the profile package. Artifact reading uses the
-domain model and application-neutral defaults. Validation uses the domain model,
-file catalog, and JSON Schema implementation. The model client uses the domain
-model and application-neutral defaults, and an injected or standard-library HTTP
-client. The use-case runner depends on the narrow interfaces owned by each
-internal component, including backend lookup and run admission.
+The internal engine composes selected catalog and caller ConfigKit inputs once,
+then assembles the captured definitions, capacity manager, renderer, validator,
+outbound client, and use-case runner. The configuration adapter interprets and
+validates only the final effective values, including presence, null, and
+resource context. It retains source history for explicit operator inspection,
+not for validation or a second resolution pass. The root facade translates
+public values and errors at the library boundary.
+
+The engine constructs capacity policy from final backend definitions, wraps
+the selected built-in or injected model client, and supplies bounded admission
+to the runner. Runtime/domain components consume execution-owned values, not
+ConfigKit types. Artifact reading and validation use the domain model and
+application-neutral defaults; validation also uses file-catalog helpers and
+JSON Schema. The model client uses the domain model, defaults, and an injected
+or standard-library HTTP client. The runner coordinates narrow lookup and
+collaborator interfaces without rereading configuration.
 
 The current implementation follows this dependency direction:
 
@@ -84,9 +83,10 @@ downstream consumers, including Scriptorium
         narrow injected abstractions
 ```
 
-The backend registry depends on the domain model and shared JSON-value
-validation, has no mutation API after construction, and consumes the
-OpenAI-compatible reserved request-field rule owned by the model client. The
+The backend index depends on the domain model and shared JSON-value ownership
+and has no mutation API after construction. The configuration adapter applies
+the OpenAI-compatible reserved request-field rule owned by the model client
+when it validates final provider maps. The
 capacity component depends on the domain model and the narrow internal
 model-client boundary, not on provider transport implementation. The model
 client does not depend on registry or capacity configuration. The facade

docs/policy/release.md

@@ -1,10 +1,10 @@
 # Release Policy
 
-**Base Policy Version:** 1.4
+**Base Policy Version:** 1.6
 
-**Last Updated**: 2026-09-27
+**Last Updated**: 2026-10-08
 
-**Upstream Source:** [release.md](https://gitea.maximumdirect.net/eric/policy/src/commit/d84a38ebab26f048cafbe59a2246700c35d29843/docs/policy/release.md)
+**Upstream Source:** [release.md](https://gitea.maximumdirect.net/eric/policy/src/commit/e833faddf120c789a9b45348edaf75720de16348/docs/policy/release.md)
 
 ## Purpose
 
@@ -12,6 +12,9 @@ This policy defines a proportionate workflow for validating and publishing an
 intended source revision under a fresh version. Releases should require little
 routine intervention, avoid repeated work, and preserve published contents.
 
+Adopt stronger verification or reproducibility requirements through an explicit
+project-specific decision justified by the intended audience and support needs.
+
 The repository-specific commands belong in `docs/release.md`. Historical release
 summaries belong in `docs/releases/`. The procedure must agree with the adopted
 policy and link to it rather than introduce additional release requirements.
@@ -59,7 +62,8 @@ requires a deliberate update to the policy and procedure where needed.
 For releases at or after `v1.0.0`:
 
 - a major release may make intentional incompatible changes;
-- a minor release may add backward-compatible behavior; and
+- a minor release may add backward-compatible behavior or raise the Go consumer
+  minimum as described below; and
 - a patch release may make backward-compatible fixes.
 
 Before `v1.0.0`, a minor release may change a documented public, operational,
@@ -71,14 +75,44 @@ Additional compatibility promises and deliberate exceptions belong in the
 adopted policy or canonical contract documentation. Release notes explain
 changes; they do not redefine current compatibility contracts.
 
-## Release Documentation
+## Consumer Minimum And Release Toolchain
+
+Distinguish the minimum toolchain supported for consumers from the toolchain
+maintainers use to build and validate a release. Record the consumer minimum in
+the language's standard metadata and explain its support meaning in canonical
+documentation. Define the selected release toolchain and its setup commands in
+`docs/release.md`. Toolchain selection and upgrade cadence are repository-specific
+choices.
+
+For Go repositories, normally declare the initial stable release of the selected
+series as the consumer minimum, such as `go 1.26.0`. Use a higher patch minimum
+when a dependency or an identified correctness fix requires it, and document
+the reason.
+
+For release-policy purposes, successful build and release validation on the
+selected Go patch release are sufficient to presume support across that Go
+series, subject to the declared consumer minimum and concrete evidence of
+incompatibility. Investigate specific compatibility concerns as they arise.
+
+Use the selected release toolchain for candidate validation and release builds,
+including CI jobs performing those tasks. A newer validation patch version alone
+leaves the consumer minimum unchanged.
+
+A minor release may raise the Go consumer minimum, including from one Go series
+to the next, both before and after `v1.0.0`. This is an explicit exception to the
+backward-compatibility requirement for minor releases. Patch releases preserve
+the consumer minimum. Explain an increase's impact and required consumer action
+in the release note. Other incompatible changes remain subject to the versioning
+rules above.
+
+## Release Documentation And Preparation
 
 Every new release must include `docs/releases/<version>.md` in the tagged
 source tree. Use the complete version tag as the filename and begin with a
 title containing the product name and that exact version.
 
 Include a short summary and any relevant compatibility impact or upgrade
-instructions. Use the Promptkit section structure below and keep the note
+instructions. Choose sections suited to the release and keep the note
 proportionate to the change.
 
 Keep exact current contracts in their canonical documents and update affected
@@ -186,7 +220,8 @@ release without replacing its contents or reusing its version.
 Maintain `docs/release.md` as a short, executable maintainer runbook. It must
 identify:
 
-1. prerequisites, primary branch, and authoritative remote;
+1. prerequisites, selected release toolchain, primary branch, and authoritative
+   remote;
 2. version and release-note preparation;
 3. one publication command with its selected local checks and automated guards;
 4. declared deliverables, required build targets, and automation responsibilities;
@@ -210,20 +245,39 @@ annotated stable SemVer tags. It has no binaries, hosted download pages, or
 asynchronous deliverables. The source commit is pushed through main before the
 tag. The [release procedure](../release.md) owns commands and recovery.
 
-The existing publication script requires Summary, Compatibility, Upgrade, and
-Changes headings beneath a title of `# Promptkit vMAJOR.MINOR.PATCH`. State
-“No action required” or “None” where appropriate. This retained local structure
-matches the automated release-note guard; changing it is separate work.
+Release preparation uses the latest Go installation available in the development
+environment to build the maintainer release executable and validate the
+candidate, including the consumer examples. Keep that same local toolchain
+active throughout those operations.
 
-The [publication script](../../scripts/release.sh) runs the
-[local checks](../../scripts/release-check.sh) once for the final committed
-candidate: race-enabled tests, vet, three offline consumer examples, tracked
-Go formatting, Markdown links, module/workspace hygiene, whitespace, and a
-credential-pattern scan. These protect concurrency, assembled library use,
-source distribution, and documentation integrity. A separate ordinary test run
-or standalone build is not an additional release gate. Candidate, tag, and
-synchronized-main checks remain automated. No CI or module-availability wait
-is required. Licensing footer URLs are preparation work, not a network gate.
+For a minor release, advance Promptkit's consumer minimum to the initial stable
+release of that Go series, retaining a higher patch minimum when required by a
+dependency or an identified correctness fix. Patch releases preserve the
+existing consumer minimum. Commit any module update before validating the final
+candidate. The [release procedure](../release.md#prepare-the-candidate) owns
+setup commands, and the consumer guide explains
+[Go compatibility](../consumers/pkg-promptkit.md#go-compatibility).
+
+Use a title containing `Promptkit` and the exact version, followed by a short
+summary and any relevant compatibility impact or upgrade instructions. The
+note is committed with the candidate and supplies the annotated tag message.
+No fixed set of section headings is required.
+
+The [publication command](../../scripts/release.sh) delegates to the released
+ReleaseKit tool selected in `go.mod`. The committed
+[profile](../../releasekit.json) selects the race-enabled Go suite, full vet,
+committed Go formatting, local Markdown links, workspace and filesystem
+replacement inspection, and the offline semantic checks for the three
+maintained consumer examples. These are the selected checks for the final
+candidate; a separate ordinary test run or standalone build is not an
+additional release gate. The upstream tool owns candidate, remote, and tag
+publication checks. It returns native status 0 for confirmed publication, 1
+for a known validation or publication failure, 2 for invalid input or profile,
+and 3 when the push outcome is unknown. For status 3, resolve the exact
+captured publication endpoint before retrying; the repository-specific
+[procedure](../release.md#failure-recovery) links to the upstream recovery
+instructions. Do not wait for CI or Go module availability. Licensing footer
+URLs are preparation work, not a network gate.
 
 ## Catalog Profile Compatibility
 

docs/policy/testing.md

@@ -58,17 +58,24 @@ and repository hygiene.
 Introducing hosted CI later would supplement, not silently redefine, this
 documented validation model.
 
-Full release-candidate validation includes race-enabled package tests, explicit
-static analysis, and execution with automated semantic checks of the three maintained
-offline consumer examples. The test run builds the packages; the examples
-also exercise ordinary compilation. Separate ordinary tests and a standalone
-build are not additional release gates. Ordinary tests remain useful during
-development. The preparation example protects assembled preparation and
+The selected ReleaseKit profile runs the race-enabled package suite and full
+vet, checks committed Go formatting, local Markdown links, and module
+distribution hygiene, and executes semantic assertions for the three
+maintained offline consumer examples. ReleaseKit owns this shared validation
+machinery and publication workflow. The test run builds the packages; the
+examples also exercise ordinary compilation. Separate ordinary tests and a
+standalone build are not additional release gates. Ordinary tests remain useful
+during development. The preparation example protects assembled preparation and
 inspection behavior. The execution example separately protects assembled
 `Run`, injected-client, validation, usage, and result behavior. The observation
 example protects assembled built-in retries, structured proposal and assessment
 runs, and application-owned interpretation of metadata.
 
+The standalone `python3 scripts/test-release.py` command exercises Promptkit's
+ReleaseKit wiring against disposable local repositories. It is focused
+development validation when release tooling changes, not part of the default
+Go test suite or a recurring release check.
+
 Tests in the default suite must be deterministic, offline, and independent of
 real credentials. They must not invoke paid APIs, use live network
 dependencies, or depend on mutable external services. Tests that require live

docs/release.md

@@ -1,64 +1,101 @@
 # Release Procedure
 
-This runbook implements the [release policy](policy/release.md). A successful
-push of the selected annotated tag to origin completes the release. Never wait
-for CI to finish or succeed.
+This runbook implements the [release policy](policy/release.md). Promptkit
+publishes source-only Go module tags from `main` to `origin`. A successful push
+of the selected annotated tag, after its source commit is available on `main`,
+completes the release. Do not wait for CI or Go module availability.
 
 ## Prepare The Candidate
 
 Required tools are Git, Go with race-detector support, POSIX shell, and Python
-3. Publication requires push access to origin. Work from the repository root.
+3. Work from the repository root with push access to `origin`.
 
-Select an unused version and create `docs/releases/<version>.md` using the
-[required structure](policy/release.md#release-documentation). Describe
-compatibility impact and consumer actions and update affected canonical docs.
-For catalog updates, record selected catalog versions and any consumer action,
-linking to the catalog policy rather than repeating its contracts.
+Use the latest Go installation available locally for the release tool, the
+candidate validation, and the maintained examples. Make it the active `go`
+command and record its version:
 
-Follow the [OSS policy](policy/oss.md) when preparing licensing and attribution
-changes. Each new note must end with the following navigation, replacing
-`vMAJOR.MINOR.PATCH` with the selected release tag:
-
-```markdown
-[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit/src/tag/vMAJOR.MINOR.PATCH/COPYRIGHT) | [LICENSE](https://gitea.maximumdirect.net/eric/promptkit/src/tag/vMAJOR.MINOR.PATCH/LICENSE) | [ATTRIBUTION](https://gitea.maximumdirect.net/eric/promptkit/src/tag/vMAJOR.MINOR.PATCH/docs/oss/attribution.md)
+```sh
+export GOTOOLCHAIN=local
+go version
 ```
 
-Check these file paths against the candidate; a future tag need not resolve
-remotely during preparation. The annotated tag derives from this same note,
-including its footer. Promptkit publishes no separate hosted release body or
-download page. If such a channel is deliberately introduced, reuse the note
-and preserve its footer. No extra network checks, artifacts, or approval gates
-are introduced, and published notes are not retrofitted.
+For a minor release, advance Promptkit's consumer minimum to the initial stable
+release of that Go series before committing the candidate:
 
-Retire completed roadmaps, preserving planned or deferred work and repairing
-links. This is housekeeping, not a separate approval gate. Review changes
-through the ordinary development workflow, commit them, and push main to
-origin. No repeated release-specific diff review is required.
+```sh
+release_go_version=$(go env GOVERSION)
+release_go_series=${release_go_version#go}
+release_go_series=${release_go_series%.*}
+go mod edit "-go=${release_go_series}.0"
+```
+
+For example, Go 1.26.8 normally results in `go 1.26.0`. Keep a higher patch
+minimum if a dependency or identified correctness fix requires it. For a patch
+release, leave the consumer minimum unchanged; using a newer validation
+toolchain does not itself raise that minimum. If the candidate needs a higher
+minimum, prepare a minor release instead. See the
+[consumer-minimum policy](policy/release.md#consumer-minimum-and-release-toolchain).
+
+Prepare module caches before validation; this may update `go.sum` and belongs
+before the candidate commit:
+
+```sh
+GOTOOLCHAIN=local go mod download
+```
+
+Choose an unused stable version and create `docs/releases/<version>.md` with a
+title containing `Promptkit` and that exact version, a short summary, and any
+relevant compatibility impact or upgrade instructions. No fixed section
+headings are required. Describe a raised Go minimum and its compatibility
+impact under the [versioning policy](policy/release.md#versioning-and-compatibility).
+End each new note with the licensing footer below, using the selected version:
+
+```markdown
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit/src/tag/vX.Y.Z/COPYRIGHT) | [LICENSE](https://gitea.maximumdirect.net/eric/promptkit/src/tag/vX.Y.Z/LICENSE) | [ATTRIBUTION](https://gitea.maximumdirect.net/eric/promptkit/src/tag/vX.Y.Z/docs/oss/attribution.md)
+```
+
+Check the footer paths against the candidate; the future tag need not resolve
+remotely during preparation. Follow the [OSS policy](policy/oss.md) for these
+links. Promptkit publishes no binaries, hosted download page, or other
+asynchronous deliverables.
+
+Retire completed roadmaps while preserving deferred work and repairing incoming
+links. Review the intended changes through the ordinary development workflow,
+commit the candidate on `main`, and push `main` to `origin` before publication.
+Preparation may update module metadata; the release bootstrap and validation
+preserve the committed candidate.
 
 ## Validate And Publish
 
-Run the following with the chosen unused version (replace the placeholder):
+For an optional local diagnostic of a committed candidate, run:
+
+```sh
+./scripts/releasekit.sh check vMAJOR.MINOR.PATCH
+```
+
+This is not a required step before publication. The upstream
+[candidate-check contract](https://gitea.maximumdirect.net/eric/ReleaseKit/src/tag/v0.4.1/docs/consumers/check.md)
+describes its requirements.
+
+Run the single publication command with the chosen version:
 
 ```sh
 ./scripts/release.sh vMAJOR.MINOR.PATCH
 ```
 
-The [publication script](../scripts/release.sh) checks a clean, synchronized
-main candidate, the version and unused tag, and the release note's title and
-required headings. It runs the [local checks](../scripts/release-check.sh)
-once, rechecks candidate identity and publication state, generates the
-annotation from the committed note plus the validated commit, and pushes only
-the selected annotated tag.
+The familiar wrapper delegates to the native ReleaseKit executable selected in
+`go.mod`. The committed [profile](../releasekit.json) selects the race-enabled
+Go suite, full vet, committed Go formatting, local Markdown links, workspace
+and filesystem replacement inspection, and semantic checks for the three
+maintained offline consumer examples. ReleaseKit also verifies the committed
+candidate and publication state, then publishes only the selected tag. Its
+checks run once for this candidate; do not repeat them as a separate sign-off.
 
-There is no separate tag-message authoring, example-output inspection,
-metadata inspection, or human sign-off. Compatibility and release-note content
-remain ordinary editorial responsibilities. Development validation is useful
-but does not require a second full run before invoking the publication script.
-
-The script stops successfully after the tag push. CI completion, CI success,
-remote read-back, and Go module availability are not release completion gates.
-Do not wait or poll for them. Provider probes and inference calls are never
-part of release validation.
+The native command returns status 0 for confirmed publication, 1 for a known
+validation or publication failure, 2 for invalid input or profile, and 3 when
+the push outcome remains unknown. Successful publication needs no remote
+read-back, CI wait, or installation check. Provider probes and inference calls
+are not part of validation.
 
 ## Catalog Profile Compatibility
 
@@ -67,28 +104,32 @@ catalog compatibility boundary. This heading preserves older incoming links.
 
 ## Failure Recovery
 
-If local checks fail, fix the candidate, commit and push changes, then rerun
-the publication command. It never automatically removes a tag.
+For status 1, use the diagnostic to distinguish a validation failure from a
+known publication conflict. Correct and commit candidate defects, push `main`,
+and rerun publication with an unused version when appropriate. Status 2 means
+the invocation or profile must be corrected.
 
-If a push fails or its result is ambiguous, set `RELEASE_VERSION` to the
-attempted version and inspect origin before retrying:
+For status 3, do not retry or remove the local tag until the remote outcome is
+resolved. ReleaseKit reports the attempted version, tag object, and recovery
+state, including the captured publication endpoint when available. Use that
+endpoint—not merely the current `origin` URL—to query the exact tag; follow the
+upstream
+[failure-recovery procedure](https://gitea.maximumdirect.net/eric/ReleaseKit/src/tag/v0.4.1/docs/release.md#resolve-failures):
 
 ```sh
-git ls-remote --tags origin "refs/tags/$RELEASE_VERSION" "refs/tags/$RELEASE_VERSION^{}"
-git rev-parse "refs/tags/$RELEASE_VERSION" "refs/tags/$RELEASE_VERSION^{}"
+releasekit_endpoint='COPY_CAPTURED_ENDPOINT'
+releasekit_version='vX.Y.Z'
+test "$(git ls-remote --get-url -- "$releasekit_endpoint")" = "$releasekit_endpoint" &&
+  git ls-remote --refs -- "$releasekit_endpoint" "refs/tags/$releasekit_version"
 ```
 
-Matching remote tag and peeled commit values confirm publication, even if the
-push command reported an error. If the remote query fails, publication status
-is still unknown. Do not delete or recreate the local tag until absence on
-origin is confirmed. Once confirmed unpublished, an unsuccessful attempt's
-local tag can be removed and the publication command rerun. Never overwrite
-a published tag.
-
-CI or module-resolution problems may be investigated separately; temporary
-service, network, or authentication failures do not require another release.
-Only an actual defect requiring changes to published contents warrants a new
-appropriate version. See the [recovery policy](policy/release.md#immutability-and-failure-recovery).
+Compare the returned object ID with the reported tag object. An exact match
+confirms publication. A missing ref confirms absence only when the endpoint
+identity check and query both succeed. If either check fails, the outcome
+remains unknown; correct the transport configuration and resolve it before
+retrying. Only after authoritative absence is confirmed may an unpublished
+local tag be removed before correcting the candidate or retrying. Never move,
+overwrite, or delete a published tag.
 
 ## Policy Changes
 

docs/releases/v0.12.0.md

@@ -0,0 +1,74 @@
+# Promptkit v0.12.0
+
+This release replaces Promptkit's configuration loader with ConfigKit and
+migrates maintained catalogs to keyed `/v3` assets. It intentionally changes
+the public construction API and configuration format.
+
+## Summary
+
+Backends, profiles, and versioned prompts now share one layered configuration
+snapshot built when `NewEngine` is called. ConfigKit supplies composition,
+inheritance, presence, and source history; Promptkit validates the final
+effective definitions and captures prompt content and templates. Consumers can
+inspect the captured configuration explicitly without triggering a reload.
+
+## Compatibility
+
+This is an incompatible minor release under Promptkit's pre-1.0
+[versioning policy](../policy/release.md#versioning-and-compatibility). The
+former source options, `Config.PromptDir`, `Config.ProfileDir`, and the old
+profile/backend convenience values have been removed. Configuration documents
+now use literal keys beneath `backends`, `profiles`, and `prompts`; embedded
+`id`/`version` fields and `base_profile` are no longer accepted. Source groups
+compose strictly within a group and overlay in the supplied order. Explicit
+zero, false, empty, and null values can now differ from omission; maps overlay
+recursively, and an empty map does not clear an inherited map.
+
+All final definitions, including unused ones, are validated during engine
+construction. Prompt text and static templates are captured then; an existing
+engine does not automatically reload changed configuration or message files.
+Request artifacts, schemas, credentials, and provider operations retain their
+runtime boundaries. See the [format reference](../formats.md) for the current
+configuration contract and the [consumer migration guide](../consumers/pkg-promptkit.md#migrate-from-the-previous-configuration-api)
+for API and source-selection changes.
+
+Maintained OpenRouter and Rakestrawhome catalogs are selected as `/v3` modules,
+both at `v3.20260930.0`. Their asset format changed; consumers that read catalog
+assets directly must adopt the keyed format. The maintained Promptkit profile
+IDs remain available under the [catalog compatibility policy](../policy/release.md#catalog-profile-compatibility),
+which does not promise fixed profile data.
+
+## Upgrade
+
+```sh
+go get gitea.maximumdirect.net/eric/promptkit@v0.12.0
+```
+
+Replace removed source and backend registration options with
+`Config.Sources`, explicitly ordered ConfigKit underlays, and optionally a
+highest-priority main input. Use `DirectoryInputs` or `FilesystemInputs` for
+selected directories, `ProfileSource` and `BackendSource` for typed
+programmatic values, or `configkit.Mapping` for explicit null and combined
+documents. Move profile `base_profile` to `extends` and embedded identities to
+mapping keys. Review zero/false/null values and any assumptions that replacing
+a model or backend discards unrelated explicit settings. Rebuild the engine
+when definitions or referenced message files change. The
+[consumer guide](../consumers/pkg-promptkit.md#migrate-from-the-previous-configuration-api)
+provides the migration details and maintained examples.
+
+## Changes
+
+- Add ConfigKit v0.5.0 as the configuration boundary and consume released
+  OpenRouter and Rakestrawhome `/v3` catalog modules.
+- Add keyed backend, profile, and prompt definitions with final-value domain
+  validation, explicit presence/null behavior, and source-relative content
+  capture.
+- Add `ConfigurationSources`, directory discovery helpers, programmatic
+  profile/backend source builders, and read-only configuration inspection.
+- Preserve execution workflows while rendering captured templates, applying
+  backend defaults after inheritance, and honoring explicit suppression of
+  provider settings.
+- Remove superseded loader, catalog preflight, and inheritance machinery;
+  update examples, format guidance, and internal documentation.
+
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.12.0/COPYRIGHT) | [LICENSE](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.12.0/LICENSE) | [ATTRIBUTION](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.12.0/docs/oss/attribution.md)

docs/releases/v0.13.0.md

@@ -0,0 +1,69 @@
+# Promptkit v0.13.0
+
+This release adds prompt requirement discovery and profile/prompt listing,
+reduces avoidable configuration and execution allocations, and standardizes
+maintainer publication through ReleaseKit. The minimum supported Go version
+increases to 1.26.0.
+
+## Discover Requirements And Available Definitions
+
+- `Engine.InspectRequirements` reports recognizable input and caller-variable
+  dependencies for a selected prompt and supplied caller context before input
+  artifacts exist. It classifies dependencies as required, conditional, or
+  optional and reports structured limitations when discovery is incomplete.
+  Discovery coverage is not proof that requirements are satisfied or execution
+  will succeed. See the [requirement inspection guide](../consumers/pkg-promptkit.md#inspect-requirements-before-preparation)
+  and [GoDoc](../../requirements.go).
+- `Engine.ListProfiles` returns effective profile IDs, and `Engine.ListPrompts`
+  returns exact ID/version pairs as `PromptIdentity` values. Lists come from the
+  engine's captured configuration, are lexically ordered and caller-owned, and
+  include consumer definitions and maintained profiles that remain effective.
+  Listing performs no provider or execution work. See the
+  [discovery guide](../consumers/pkg-promptkit.md#discover-available-profiles-and-prompts)
+  and [GoDoc](../../listing.go).
+
+## Efficiency And Tooling
+
+- Reduce response-sized copies in basic validation and rendered-message output,
+  and encode valid provider extra parameters only as part of the complete
+  request rather than serializing them twice.
+- Use bounded initial file-size reservations without limiting accepted content,
+  releasing excess backing storage for small or empty completed artifacts.
+- Reuse owned preparation values when creating prepared-execution snapshots,
+  while preserving independent inspection details and caller-owned data.
+- Use lightweight captured profile identities and prompt metadata for inspection
+  instead of copying execution targets and definitions unnecessarily.
+- Upgrade ConfigKit to v0.6.0 for more efficient loading, resolution, metadata,
+  and inspection processing. Configuration semantics remain unchanged; these
+  improvements primarily benefit construction and explicit operator inspection,
+  not upstream inference latency.
+- Adopt module-selected ReleaseKit v0.3.0 for maintainer validation and tag
+  publication. The [release procedure](../release.md) owns the current commands
+  and recovery workflow; successful tag publication remains the completion
+  point, without waiting for CI.
+
+These changes preserve existing execution and ownership contracts. Benefits
+depend on workload; this release introduces no fixed performance guarantee.
+
+## Compatibility And Upgrade
+
+Consumers upgrading from v0.12.0 need **Go 1.26.0 or newer**, rather than the
+previous 1.25.5 minimum. Update application build environments and any CI images
+still using Go 1.25 before upgrading:
+
+```sh
+go get gitea.maximumdirect.net/eric/promptkit@v0.13.0
+```
+
+No application-code or configuration migration is required from v0.12.0 beyond
+the Go toolchain update. The new discovery methods are optional additions;
+existing construction, inspection, preparation, and execution workflows remain
+available. See [Go compatibility](../consumers/pkg-promptkit.md#go-compatibility)
+for the distinction between the consumer minimum and maintainer toolchain.
+
+Maintainers should follow the current release runbook rather than the retired
+`scripts/release-check.sh`. The publication entry point remains
+`scripts/release.sh`; ReleaseKit now owns its shared validation and publication
+mechanics.
+
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.13.0/COPYRIGHT) | [LICENSE](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.13.0/LICENSE) | [ATTRIBUTION](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.13.0/docs/oss/attribution.md)

docs/releases/v0.14.0.md

@@ -0,0 +1,48 @@
+# Promptkit v0.14.0
+
+This release adds comparison of captured configuration inspections and updates
+ConfigKit and the maintainer release tool. The minimum supported Go version
+remains 1.26.0.
+
+## Compare Captured Configurations
+
+`ConfigurationInspection.Diff` compares the effective configuration captured by
+two engines. Consumers can use it to review a candidate configuration, inspect
+an overlay's effect, or present configuration changes to operators.
+
+Comparison delegates to ConfigKit and returns its difference records, including
+presence information, paired redaction, and protected-change indicators. It
+does not reload sources or contact providers. Source-history differences alone
+do not produce value differences.
+
+An empty diff is not proof of equivalent execution: referenced file contents,
+resolved credentials, later execution preparation, and request-specific
+overrides are outside the comparison. Records can contain ordinary application
+data; callers retain responsibility for their disclosure.
+
+See the [configuration comparison guide](../consumers/pkg-promptkit.md#inspect-the-captured-configuration)
+and [GoDoc](../../configuration_inspection.go) for usage and the exact contract.
+
+## Dependency And Tooling Updates
+
+- Upgrade ConfigKit from v0.6.0 to v0.7.1, providing the upstream comparison API.
+  v0.7.1 also updates ConfigKit's maintainer tooling without changing its runtime
+  behavior from v0.7.0.
+- Upgrade the module-selected ReleaseKit tool from v0.3.0 to v0.4.1. Promptkit
+  retains its existing root-module profile, publication entry point, and release
+  gates. See the [release procedure](../release.md) for maintainer commands.
+
+## Compatibility And Upgrade
+
+No application-code, configuration, or Go-toolchain migration is required from
+v0.13.0. Configuration comparison is an optional API addition; existing
+construction, inspection, preparation, and execution workflows remain available.
+
+```sh
+go get gitea.maximumdirect.net/eric/promptkit@v0.14.0
+```
+
+See [Go compatibility](../consumers/pkg-promptkit.md#go-compatibility) for the
+distinction between the consumer minimum and maintainer toolchain.
+
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.14.0/COPYRIGHT) | [LICENSE](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.14.0/LICENSE) | [ATTRIBUTION](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.14.0/docs/oss/attribution.md)

docs/releases/v0.15.0.md

@@ -0,0 +1,34 @@
+# Promptkit v0.15.0
+
+This release adds error-only validation of a concrete prompt request without
+calling a model. The minimum supported Go version remains 1.26.0.
+
+## Validate A Concrete Request
+
+`Engine.ValidateRequest` accepts an ordinary `RunRequest` and returns nil when
+it passes preparation, or the existing preparation error. Consumers can use it
+for fail-fast checks, including downstream CLI validation commands, without
+receiving a prepared snapshot.
+
+The method shares `Prepare`'s request conversion and preparation path. Unlike
+requirements inspection, it checks the actual supplied values and bindings.
+Artifact and schema resource I/O still occurs; success does not certify provider
+acceptance or later execution success. A subsequent run prepares independently.
+Validation is optional, not a required step before preparation or execution.
+
+See the [request validation guide](../consumers/pkg-promptkit.md#validate-a-concrete-request)
+and [GoDoc](../../engine.go) for usage and the exact contract. Consumers that
+need execution tied to a checked snapshot can use the existing
+[prepared execution workflow](../consumers/pkg-promptkit.md#prepare-now-and-execute-the-same-snapshot-later).
+
+## Compatibility And Upgrade
+
+No application-code, configuration, or Go-toolchain migration is required from
+v0.14.0. This is an optional API addition; existing inspection, preparation, and
+execution workflows remain available.
+
+```sh
+go get gitea.maximumdirect.net/eric/promptkit@v0.15.0
+```
+
+[COPYRIGHT](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.15.0/COPYRIGHT) | [LICENSE](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.15.0/LICENSE) | [ATTRIBUTION](https://gitea.maximumdirect.net/eric/promptkit/src/tag/v0.15.0/docs/oss/attribution.md)

docs/roadmap/configkit-assessment.md

@@ -1,333 +0,0 @@
-# ConfigKit Adoption Assessment
-
-Status: proposed for discussion, not an approved feature specification or an
-implementation plan. No runtime changes are part of this assessment.
-
-## Goal And Recommendation
-
-Use ConfigKit to standardize PromptKit's configuration semantics and simplify
-its loading machinery, improving ConfigKit where a reusable capability is
-justified. Preserve substantive consumer capabilities, not historical loading
-sequences, file syntax, or Go signatures. Document intentional breaking changes
-and their migration paths.
-
-Recommend adoption through an eager, immutable definition-loading boundary.
-ConfigKit should own YAML interpretation, strict typed decoding, presence, and
-source diagnostics. PromptKit should own definition identity, named profile
-relationships, LLM-specific rules, and execution. Do not retain the lazy loading
-architecture merely to minimize migration, or introduce a second generic
-configuration framework inside PromptKit.
-
-The expected benefits are consistent configuration semantics for applications
-using both libraries and removal of repeated discovery, partial metadata parsing,
-lazy error arbitration, and repeated profile-chain resolution. Some of those
-savings come from the loading redesign rather than ConfigKit itself. ConfigKit
-adds ongoing value by owning the generic decoding behavior and its tests.
-
-## Evidence And Scope
-
-Reviewed local baselines on 2026-09-29:
-
-- PromptKit: `12d6d80024e80c552d122a076c22429bf6f2f6c2` (v0.11.2).
-- ConfigKit: `67c03690181c5af8dde6be325abac241dae6732f` (v0.4.2).
-
-PromptKit evidence: [consumer workflows](../consumers/pkg-promptkit.md),
-[file formats](../formats.md), [source implementation](../internal/sources.md),
-[runner](../internal/runner.md), and the implementation owners identified below.
-ConfigKit evidence: its reviewed `docs/config.md`, `docs/roadmap/deferred.md`,
-`lifecycle.go`, `source.go`, and ADR 0001 in the sibling checkout. That checkout
-is review context, not a proposed build dependency or required directory layout.
-
-ConfigKit currently exposes `Load[T]` over file, byte, reader, and defaults-only
-sources. It supports strict decoding, presence/origin records, defaults,
-recorded resolution, semantic validation, explicit imports, one selected
-filesystem overlay, and secret handling. Its parser and generic conversion
-machinery are private. It has no public arbitrary layer-composition, generic
-inheritance, or `fs.FS` source API. Its deferred scope explicitly excludes several
-of these generalizations; an upstream enhancement requires a deliberate decision.
-
-This is a source-and-contract assessment, not a performance benchmark or full
-correctness audit. It does not claim measured allocation, latency, or line-count
-savings. Current code and canonical contracts remain authoritative until an
-approved implementation changes them.
-
-## 1. Capability Inventory
-
-| Preserve the ability to… | Replaceable mechanics and representation |
-| --- | --- |
-| Define named, versioned prompts, inspect their declared inputs, and select a version explicitly | Directory scans on each operation, YAML metadata prepasses, filename layout, constructor signatures |
-| Use inline and file-backed message templates, variables, input helpers, session templates, roles, and cache control | Timing of definition/content reads and private repository interfaces |
-| Configure named profiles, alias/inherit another profile, and override selected settings | Zero-as-absence fields, per-call chain traversal, raw YAML decoding types |
-| Supply embedded application defaults, operator definitions, maintained catalogs, and programmatic profiles | Repository-wrapper stacks and exact source-option API |
-| Register custom/local backends, use built-ins or endpoint-only profiles, and control backend capacity | Configuration DTO shapes and registry assembly order |
-| Prepare, inspect, execute, or freeze an execution for later single-claim execution | Source reloading during ordinary preparation; exact preparation error ordering |
-| Override per-run settings, credentials, reasoning, session, and output contract; append rendered messages | Public value signatures if presence or clearer configuration separation requires revision |
-| Supply inline/file artifacts and inject artifact readers, model clients, and HTTP clients | Assembly APIs; runtime collaborators need not be YAML-decodable |
-| Validate output, use provider-native structured output, bounded repair, transport retries, cancellation, and observation | Internal wiring, not the substantive execution behaviors |
-| Receive results, usage, identities, hashes, validation outcomes, and inspectable failures | Configuration error types and when definition failures appear |
-
-Preserve independent profile and prompt inspection as useful operations. They
-need not retain the old guarantee that engine construction has never examined
-other definitions. Preserve custom backend identity and capacity behavior,
-optional upstream credentials, and the distinction between failed generated
-content and operational errors. This project does not authorize silently
-dropping execution features to simplify the configuration layer.
-
-## 2. Responsibility Mapping
-
-| Concern | Recommended owner and disposition |
-| --- | --- |
-| YAML grammar, scalar interpretation, one-document enforcement, unknown fields, typed ranges, null legality | Delegate to ConfigKit; remove corresponding PromptKit parser logic and redundant parser tests |
-| Field presence and source coordinates | Delegate to ConfigKit; retain only the compact records needed for resolution and diagnostics |
-| File/directory/embedded source selection and definition ID indexing | Retain a small PromptKit collection loader; ConfigKit loads documents, not a prompt catalog |
-| Filesystem traversal and relative content references | Retain PromptKit's source-boundary adapters; use standard `io/fs` facilities where sufficient |
-| Profile-source priority and duplicate definition policy | Retain explicit PromptKit collection assembly; eliminate error-driven repository fallback |
-| Named profile inheritance and backend selection | Retain a typed PromptKit resolver over the loaded collection, with explicit presence; consider generic inheritance upstream only with broader evidence |
-| LLM setting bounds, role/session normalization, output rules, reserved provider fields | Retain shared PromptKit domain owners; ConfigKit validation callbacks may invoke them |
-| Definition defaults | Use ConfigKit defaults where they do not erase inheritance presence; apply effective execution defaults after inheritance |
-| Programmatic configuration | Retain typed construction; normalize to the same presence-aware internal definitions without YAML round trips |
-| Runtime clients, observers, artifact readers, request data | Retain normal Go injection and request APIs; do not load them through ConfigKit |
-| Credentials | Retain optional environment-name and direct request-key semantics; do not replace these with ConfigKit's required typed secret resolution |
-| Catalog manifest, ownership, reserved names, secret-safety checks | Retain the catalog adapter; reuse the common ConfigKit profile decoder |
-| JSON Schema resources and generated-output validation | Retain JSON Schema implementation; these are not application configuration documents |
-| Application imports, CLI overrides, deployment overlays, secrets-directory bootstrap | Leave with consuming applications unless a concrete PromptKit need is accepted |
-| Generic source/decoding diagnostics | Reuse ConfigKit; add only PromptKit identity/context and domain relationship diagnostics |
-
-## 3. Recommended Target Loading Model
-
-### Definition Snapshot
-
-Create one immutable definition snapshot during engine construction. Discover
-the explicitly supplied sources, decode each definition through ConfigKit,
-normalize domain values, assemble identity indexes, and resolve profile chains
-before publishing the engine. No provider call or credential availability check
-belongs in this phase. Publish no partially initialized engine on failure.
-
-Use one typed document per prompt or profile initially. Existing files need not
-be converted into a monolithic application configuration merely to adopt
-ConfigKit. Support OS directories, individual files, embedded/custom `fs.FS`
-sources, and programmatic profiles. For `fs.FS`, a small adapter can open a file
-and supply `configkit.Reader` with a safe source label; PromptKit retains root
-and path context for referenced message files. Close handles owned by the adapter.
-ConfigKit's existing public API is sufficient for this design.
-
-Load and freeze referenced message text with definitions. Validate static prompt
-structure and template syntax at loading, using the same template function setup
-as execution; render only when request variables and artifacts exist. Preserve
-source-relative content resolution and containment without expanding the threat
-model. A snapshot is a set of captured reads, not an atomic filesystem transaction.
-
-Keep request artifacts and schema compilation at preparation. A request can
-replace the output contract, so an unused default schema should not need eager
-compilation. Prepared execution continues to freeze its effective resources.
-The snapshot covers definitions/message text, not environment values, request
-files, every schema file, or execution state.
-
-### Composition And Validation
-
-Use explicit source categories in the existing useful priority order:
-programmatic profiles, operator source, application fallback, PromptKit-owned
-profiles, then external catalogs. Within a category, duplicate profile IDs fail;
-across categories, a higher-priority definition replaces the whole lower one.
-Prompt ID/version pairs must be unique; different versions remain available.
-An omitted version remains ambiguous when more than one version is present.
-
-Strictly decode and locally validate every supplied definition, including
-shadowed definitions. Thus an unused malformed file is a construction failure,
-not a reason to perform a partial metadata scan. Resolve relationships for the
-effective selected profile collection; shadowed definitions do not contribute
-inheritance edges to that collection. Keep the catalog adapter's independent
-validation of maintained data before consumer overrides.
-
-Preserve profile templates that become usable through descendants or runtime
-overrides: eager loading must not require every consumer profile to be an
-independently runnable endpoint/model pair. Validate supplied fields and graph
-integrity eagerly (including missing bases and cycles), and check final execution
-requirements after runtime selection/overrides. Prompt default-profile references
-can be checked against the assembled collection; a prompt with no default remains
-valid for callers that supply a profile explicitly.
-
-This is named-definition precedence, not ConfigKit's application overlay system.
-Do not generate temporary overlay files or serialize maps to YAML to imitate a
-missing layer API. ConfigKit imports are also not directory discovery: their
-strict composition has different semantics and need not be enabled here.
-
-### Inheritance And Presence
-
-Recommend omission-based inheritance: absent fields inherit; explicit values
-replace inherited settings, including zero, false, and empty strings where the
-domain permits them. Preserve presence through inheritance, backend/framework
-default application, request overrides, and outbound request construction.
-Otherwise accepting `temperature: 0` during decoding would accomplish nothing.
-
-Use ConfigKit metadata for file presence and presence-aware typed fields for
-programmatic definitions. Both paths feed one typed resolver. Decode raw profiles
-without effective execution defaults so defaults do not become child overrides.
-Avoid a parallel reflection-based merge engine in PromptKit.
-
-Keep provider `extra_params` replacement atomic: an explicitly supplied map
-replaces the inherited map, including an empty map. This matches the useful
-ability to choose a complete provider parameter set and avoids accidental mixing
-of incompatible options. Do not generalize this domain rule into arbitrary
-ConfigKit merge strategies.
-
-Recommend optional scalar pointers where null means no value/inherit, while
-explicit zero/false/empty is a value. For optional maps, null likewise means no
-override and `{}` explicitly clears. Required identity fields remain required;
-an explicitly empty model or endpoint cannot produce an executable target.
-Publish these conventions deliberately rather than pretending ConfigKit's
-presence metadata automatically determines domain inheritance semantics.
-
-Resolve and memoize each effective chain once per snapshot. Retain source and
-field-origin information sufficient to diagnose a bad base or inherited value;
-do not claim that per-document ConfigKit metadata already represents the complete
-cross-document inheritance history.
-
-### Reloading, Errors, And Application Integration
-
-Later definition edits take effect through a newly constructed engine. Do not add
-watchers, mutable registry reloads, or a second lazy compatibility mode. Applications
-choose how to swap engines and let in-flight work finish. Old prepared handles
-remain associated with their original engine. Simultaneously active engines have
-separate backend capacity pools; migration guidance must not imply a global limit
-across a reload overlap.
-
-Return configuration failures from construction with file/path/location and
-useful definition identity where available. Recommend preserving ConfigKit's
-public `LoadError` through wrapping for `errors.As`, together with a PromptKit
-configuration category; do not copy its entire diagnostic API into the facade.
-Domain-only relationship failures remain PromptKit errors with relevant source
-locations. Start with deterministic fail-fast loading across files and ConfigKit's
-existing multi-diagnostic behavior within a load, rather than inventing a batch
-diagnostic subsystem. Do not expose raw credentials or add implicit logging.
-
-Runtime failures continue to distinguish invalid requests, missing selections,
-rendering/artifact/schema errors, provider/transport errors, capacity rejection,
-and content-validation results. Cancellation remains effective at
-PromptKit-controlled boundaries; ConfigKit's current synchronous `Load` has no
-context argument, so do not promise interruption inside it or create goroutines
-to simulate that guarantee.
-
-Applications using ConfigKit can present the same underlying loading diagnostics
-for their application settings and PromptKit files. They can also translate
-application-owned typed settings into PromptKit profiles/backends. Do not require
-applications to encode Go clients into YAML or adopt ConfigKit merely to call
-PromptKit's runtime API. No full effective-configuration/explanation API is proposed
-without an identified consumer requirement.
-
-## 4. Simplification Accounting
-
-| Current implementation | Expected disposition |
-| --- | --- |
-| `internal/profile/filesystem_repository.go`: metadata scans, selected strict decode, stream-end checks, malformed-file selection arbitration | Replace with eager document loads and indexed values; remove the metadata prepass and per-lookup filesystem path |
-| `internal/promptdef/filesystem_repository.go`: metadata selection and repeated decoding/content opening | Replace with eager prompt loads and an ID/version index; keep domain normalization and contained content reading |
-| Profile filesystem, `fs.FS`, eager, memory, and overlay repository variants | Collapse loading into source adapters plus immutable collections; preserve only interfaces that still serve a real boundary |
-| `internal/profile/resolving_repository.go` | Replace per-operation traversal and zero-sentinel merging with once-per-snapshot presence-aware typed resolution; graph logic remains |
-| `internal/engine` raw repository-stack assembly | Replace with explicit collection construction and precedence; engine capacity/client assembly remains |
-| `internal/catalog` profile metadata extraction | Obtain explicit field information from ConfigKit; retain manifests, ownership, namespace, connection-metadata and secret checks |
-| `internal/filecatalog` | Retain/reduce discovery and containment helpers actually needed by the eager loader; do not claim the entire package disappears |
-| `internal/domain` source YAML tags and runtime/source coupling | Separate configuration DTOs from execution values where presence requires it; reuse domain validation rather than duplicating it |
-| Direct `gopkg.in/yaml.v3` use for definition loading | Remove once all such consumers migrate; ConfigKit brings its own private YAML dependency |
-
-New integration work is real: typed source DTOs, ConfigKit calls and error wrapping,
-source-context records, collection indexing, and conversion to runtime definitions.
-Some defensive copies remain necessary at public/injected-client boundaries;
-ConfigKit's detached load result is not permission to expose shared engine maps.
-`internal/jsonvalue` still serves programmatic values, request parameters, and
-prepared schema ownership, so adoption does not eliminate it.
-
-Maintenance savings depend on actually deleting the old lazy paths and their
-special-case tests. Move generic YAML/scalar behavior coverage to ConfigKit's
-ownership; PromptKit retains representative adapter tests plus domain, precedence,
-snapshot, inheritance, embedded-source, error, and execution integration tests.
-Do not duplicate ConfigKit's entire parser suite or discard execution regression
-coverage because construction fixtures need migration.
-
-Runtime benefit: ordinary runs no longer rediscover definition directories,
-redecode definitions, reread template text, or traverse inheritance chains.
-Cost: construction loads even unused definitions and retains their text and
-resolved values. ConfigKit also creates metadata and projections; keep only needed
-records after loading. These are reasoned tradeoffs, not measured performance
-claims. Adoption is not justified by the decoder replacement alone.
-
-## 5. Upstream Opportunities
-
-No ConfigKit enhancement is a demonstrated prerequisite for the recommended
-per-document snapshot design. Do not manufacture one to move a small adapter
-upstream. Reconsider the following if the agreed roadmap reveals concrete reuse:
-
-| Candidate | Recommendation and tradeoff |
-| --- | --- |
-| Native `fs.FS` sources with source-relative resource context | Most plausible optional enhancement: embedded configurations are useful across Go libraries. Reader sources suffice today. A fuller design must define imports/overlays in that filesystem rather than merely add a constructor or leak parser internals. |
-| Public in-memory layered loading with origins | Optional only if multiple consumers need application defaults and file/embedded layers composed together. It could remove adapters in those consumers, but is not necessary for whole-definition catalog shadowing. Review against ConfigKit's deliberate single-overlay scope. |
-| Generic named inheritance/presence-aware typed overlay | Consider an upstream proposal if a coherent application-neutral operation emerges; another concrete use case would strengthen the case but is not a prerequisite. PromptKit's named graph, atomic provider map, and routing rules alone do not justify a configurable general merge framework. Current fixed overlay semantics are not this API. |
-| Context-aware loading | Optional for reusable cancellable construction if large-source consumers need it. Promise cooperative cancellation only; no detached reads or instant interruption of arbitrary readers. |
-
-Do not propose a public raw AST, permissive identity-only decoder, or dynamic
-subtree conversion solely to preserve PromptKit's current scanning design.
-Do not upstream backend/model selection, credential timing for inference,
-profile catalog reservations, or prompt-template functions.
-
-ConfigKit and PromptKit both declare LGPL-3.0-or-later. Adoption must still update
-dependency notices under the OSS policy and inspect the exact selected release
-and its transitive notices. Their current Go minimums do not require a PromptKit
-toolchain increase. Use a released module dependency, not a sibling-directory
-replacement. This review proposes no licensing change or upstream edits.
-
-## 6. Decisions And Migration
-
-The goal and permission to break compatibility are agreed. The following specific
-choices are recommendations for discussion, not inferred approvals:
-
-1. **Loading lifetime and failure scope.** Recommend eager construction, frozen
-   definitions/content, and failure for malformed files anywhere in supplied
-   collections. This deletes lazy arbitration and repeated scans. Alternative:
-   explicit caller-loaded reusable definition snapshots separate from engine
-   construction; useful when multiple engines share data, but adds a public
-   lifecycle. Retaining automatic per-run reload is possible but sacrifices much
-   of the simplification and is not recommended.
-2. **Source organization.** Recommend individual typed definition documents with
-   explicit collection precedence. This preserves embedded catalogs and distributed
-   authoring without copying application configuration machinery. Alternative:
-   one keyed PromptKit bundle composed using ConfigKit imports and overlays;
-   offers richer unified provenance but needs decisions about embedded sources,
-   provider-map replacement, profile identity, and catalog conversion. Do not
-   assume existing ConfigKit APIs already solve those issues.
-3. **Presence and inheritance.** Recommend explicit-value replacement, null as
-   unspecified for optional settings, and atomic provider maps as described above.
-   Alternative: use ConfigKit-style recursive mapping overlays, where null clears;
-   this is more uniform with application overlays but changes provider-parameter
-   behavior and requires a supported cross-document mechanism. Historical
-   zero-as-absence is another viable option but loses useful standardization.
-4. **Diagnostic boundary.** Recommend wrapping ConfigKit's public load errors
-   rather than mirroring them. Alternative: translate into a small PromptKit-owned
-   diagnostic value; that limits public dependency coupling but introduces mapping
-   code and risks inconsistent diagnostics. Either option must cover domain errors
-   and preserve actionable source information without inventing an audit subsystem.
-
-Expected consumer migration:
-
-- Update definitions for ConfigKit's strict scalar rules, rejected YAML
-  anchors/aliases/tags, input limits, and null/type checks. Quote prompt version
-  strings rather than introducing a special numeric-version conversion merely
-  for historical YAML coercion.
-- Remove unintended explicit zero/false/empty values that formerly meant
-  inheritance; express deliberate overrides using the new presence-aware Go
-  fields and file semantics. Review provider maps for explicit replacement.
-- Handle definition errors at construction, clean up unused invalid files, and
-  deliberately rebuild/swap engines after definition changes.
-- Keep runtime credential lookup optional, avoid baking resolved secrets into
-  definition snapshots, and preserve request-scoped key overrides.
-- Update maintained catalog data if strict parsing reveals incompatible syntax;
-  coordinate catalog releases before the PromptKit dependency update. Preserve
-  maintained profile names and catalog ownership rules, not every old scalar
-  spelling. Do not validate live provider/model availability.
-- Update error inspection, constructor/source options, and programmatic profile
-  literals as required. Keep representative preparation, execution, inspection,
-  custom backend, fallback, and embedded workflows in the migration guidance.
-
-The subsequent feature roadmap should settle these choices and specify the target
-end state. The staged implementation plan can then sequence any accepted upstream
-work, PromptKit deletions/replacements, contract tests, canonical documentation,
-examples, attribution, and minor-release migration notes. Neither document should
-become a reason to preserve obsolete compatibility machinery.

docs/roadmap/deferred.md

@@ -42,20 +42,21 @@ checkpoint equality or when a broader semantic identity design is selected.
 ### Eager Source Validation
 
 **Reason for deferral:** Exact prompt and profile inspection may already
-provide a sufficiently small validation surface. Experience from downstream
-adoption should establish whether an engine-wide operation would add enough
-value to justify its broader contract.
+provide a sufficiently small validation surface alongside construction-time
+definition validation. Experience from downstream adoption should establish
+whether a separate operation would add enough value to justify its broader
+contract.
 
-Promptkit could provide an explicit offline operation that discovers and
-structurally validates configured prompt, profile, and schema sources without
-model generation. The normal `NewEngine` path would remain lazy.
+Promptkit could provide an explicit offline operation that also checks schema
+resources without model generation. `NewEngine` already validates effective
+definitions and captures prompt content; schema resources remain
+request-dependent.
 
-An eager operation would need coherent handling for duplicate prompt IDs and
-versions, strict YAML decoding, referenced content files, profile/backend
-membership, schema syntax and transitive references, context cancellation,
-and source-specific public errors. Credential declarations must remain
-separate from credential values; checking current environment availability,
-if supported at all, should be an explicit option and must not expose secrets.
+Such an operation would need coherent handling for schema syntax and transitive
+references, context cancellation, and source-specific public errors. Credential
+declarations must remain separate from credential values; checking current
+environment availability, if supported at all, should be an explicit option
+and must not expose secrets.
 
 Reconsider this idea after downstream use of `InspectPrompt`,
 `InspectProfile`, and fixture-based preparation demonstrates a concrete gap.

engine.go

@@ -8,6 +8,7 @@ import (
 	"net/http"
 	"time"
 
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 	internalengine "gitea.maximumdirect.net/eric/promptkit/internal/engine"
 	"gitea.maximumdirect.net/eric/promptkit/internal/observation"
@@ -15,7 +16,7 @@ import (
 )
 
 // ErrInvalidConfig identifies invalid engine construction, including missing
-// required configuration, invalid options or backend registrations, and a nil
+// effective configuration, invalid options, and a nil
 // Engine receiver.
 var ErrInvalidConfig = errors.New("invalid engine configuration")
 
@@ -34,13 +35,13 @@ var (
 	// nor the selected prompt's default profile is present. Such an error also
 	// matches ErrInvalidRequest.
 	ErrProfileRequired = errors.New("profile selection is required")
-	// ErrPromptLoad identifies a failure to read, decode, validate, select, or
-	// hash a prompt definition, except for the not-found case represented by
-	// ErrPromptNotFound.
+	// ErrPromptLoad identifies a prompt selection failure other than the
+	// not-found case represented by ErrPromptNotFound. Invalid definitions
+	// instead fail construction with ErrInvalidConfig.
 	ErrPromptLoad = errors.New("failed to load prompt definition")
-	// ErrProfileLoad identifies a failure to read, decode, validate, or select
-	// an execution profile or resolve its backend, except for the profile
-	// not-found case represented by ErrProfileNotFound.
+	// ErrProfileLoad identifies a profile selection or resolution failure other
+	// than the not-found case represented by ErrProfileNotFound. Invalid
+	// definitions instead fail construction with ErrInvalidConfig.
 	ErrProfileLoad = errors.New("failed to load execution profile")
 	// ErrAPIKeyEnvMissing identifies an explicitly required APIKeyEnv whose
 	// environment variable is unset or empty after direct RunRequest.APIKey
@@ -81,11 +82,12 @@ var (
 	ErrValidation = errors.New("failed to validate output")
 )
 
-// Engine inspects prompts and profiles and prepares and runs Promptkit prompt
-// requests.
+// Engine inspects prompts and profiles, enumerates prompt requirements, and
+// prepares and runs Promptkit prompt requests.
 //
-// An Engine is safe for concurrent calls to [Engine.InspectPrompt],
-// [Engine.InspectProfile], [Engine.Prepare], [Engine.PrepareExecution],
+// An Engine is safe for concurrent calls to [Engine.InspectConfiguration],
+// [Engine.InspectPrompt],
+// [Engine.InspectRequirements], [Engine.InspectProfile], [Engine.Prepare], [Engine.PrepareExecution],
 // [Engine.Run], and [Engine.RunPrepared]. Each Engine owns independent
 // backend-capacity pools that coordinate Run and RunPrepared admission and
 // model generation. Injected collaborators may still be invoked concurrently
@@ -94,18 +96,21 @@ type Engine struct {
 	internal *internalengine.Engine
 }
 
-// Config selects the directory-backed sources and built-in model-client
-// transport used by [NewEngine]. Config has no stable JSON representation.
+// ConfigurationSources selects ordered ConfigKit underlays and an optional
+// highest-priority main input. Each underlay's inputs strictly compose within
+// their group; later underlays overlay earlier ones. A nil Main uses
+// ConfigKit's empty source. A non-nil Main is passed through unchanged and
+// may fail construction if invalid.
+type ConfigurationSources struct {
+	Underlays []configkit.Underlay
+	Main      *configkit.Input
+}
+
+// Config selects configuration sources and built-in model-client transport
+// used by [NewEngine]. Config has no stable JSON representation.
 type Config struct {
-	// PromptDir is the directory searched recursively for prompt definitions.
-	// It is required unless a WithPromptFS or WithPromptFile option supplies the
-	// prompt source.
-	PromptDir string
-	// ProfileDir is an optional ordinary configured source whose profiles take
-	// precedence over application fallback and maintained catalog profiles. An
-	// empty value selects the lower-precedence sources unless a profile-source
-	// option supplies the ordinary source.
-	ProfileDir string
+	// Sources combines maintained definitions with caller-selected inputs.
+	Sources ConfigurationSources
 	// SchemaDir is the root for JSON Schema files. An empty value uses the
 	// current directory. WithSchemaFS or WithSchemaFile replaces this source.
 	SchemaDir string
@@ -128,12 +133,9 @@ type Config struct {
 // Option customizes engine construction.
 //
 // NewEngine applies options in argument order and ignores nil options. Within
-// each prompt-source, ordinary-profile-source, fallback-profile-source,
-// in-memory-profile, schema-source, model-client, and artifact-reader
-// category, the last non-nil valid option replaces earlier options in that
-// category. WithBackend is the additive exception: unique registrations
-// accumulate, and a repeated backend ID is an error rather than a replacement.
-// An invalid option fails construction even if a later option would replace it.
+// each schema-source, model-client, and artifact-reader category, the last
+// non-nil valid option replaces earlier options. An invalid option fails
+// construction even if a later option would replace it.
 type Option interface {
 	apply(*engineOptions) error
 }
@@ -181,102 +183,6 @@ func WithArtifactReader(reader ArtifactReader) Option {
 	})
 }
 
-// WithPromptFS loads prompt definitions from fsys under root.
-//
-// The source uses the same strict prompt YAML rules as configured prompt
-// directories, and prompt content_file paths resolve within this source.
-// fsys must be non-nil and root must be non-empty; otherwise NewEngine fails
-// with ErrInvalidConfig. This option replaces Config.PromptDir and earlier
-// prompt-source options.
-func WithPromptFS(fsys fs.FS, root string) Option {
-	return optionFunc(func(options *engineOptions) error {
-		return options.internal.SetPromptFS(fsys, root)
-	})
-}
-
-// WithPromptFile loads prompt definitions from the single prompt file at path.
-//
-// Relative prompt content_file paths resolve from the file's directory. path
-// must name an existing non-directory file when NewEngine applies the option.
-// This option replaces Config.PromptDir and earlier prompt-source options.
-func WithPromptFile(path string) Option {
-	return optionFunc(func(options *engineOptions) error {
-		return options.internal.SetPromptFile(path)
-	})
-}
-
-// WithProfileFS loads execution profiles from fsys under root.
-//
-// Profiles from this ordinary configured source take precedence over
-// application fallback and built-in profiles. Profile YAML must use api_key_env
-// for environment-based credentials; raw API keys are rejected. fsys must be
-// non-nil and root must be non-empty; otherwise NewEngine fails with
-// ErrInvalidConfig. This option replaces Config.ProfileDir and earlier file or
-// FS profile-source options, but remains below WithProfiles in precedence.
-func WithProfileFS(fsys fs.FS, root string) Option {
-	return optionFunc(func(options *engineOptions) error {
-		return options.internal.SetProfileFS(fsys, root)
-	})
-}
-
-// WithProfileFile loads execution profiles from the single profile file at path.
-//
-// The profile takes precedence over application fallback and built-in profiles.
-// Profile YAML must use api_key_env for environment-based credentials; raw API
-// keys are rejected. path must name an existing non-directory file when
-// NewEngine applies the option. This option replaces Config.ProfileDir and
-// earlier file or FS profile-source options, but remains below WithProfiles in
-// precedence.
-func WithProfileFile(path string) Option {
-	return optionFunc(func(options *engineOptions) error {
-		return options.internal.SetProfileFile(path)
-	})
-}
-
-// WithFallbackProfileFS supplies application-owned fallback profile
-// definitions from fsys under root.
-//
-// Profile lookup checks, in order, profiles supplied by WithProfiles; the
-// ordinary configured source selected by WithProfileFile, WithProfileFS, or
-// Config.ProfileDir; this fallback source; and Promptkit's maintained catalog
-// profiles. Each source supplies a complete profile definition; profile fields
-// are not merged between sources. Only an absent profile ID proceeds to the
-// next source. A matching read, parse, duplicate, validation, or credential
-// format failure stops resolution.
-//
-// Files use the ordinary strict profile YAML and api_key_env credential rules.
-// Loading and validation are lazy: NewEngine validates this option's arguments
-// but does not read profile files. fsys must be non-nil and root must be
-// nonblank; otherwise NewEngine returns an error matching ErrInvalidConfig.
-// Repeating this option replaces the earlier valid fallback source.
-//
-// This option controls profile-definition lookup, not provider or generation
-// failover.
-func WithFallbackProfileFS(fsys fs.FS, root string) Option {
-	return optionFunc(func(options *engineOptions) error {
-		return options.internal.SetFallbackProfileFS(fsys, root)
-	})
-}
-
-// WithProfiles configures in-memory profiles that take precedence over
-// ordinary configured, application fallback, and built-in profiles.
-//
-// NewEngine locally validates and copies every profile. IDs must be unique
-// within one call. An invalid local definition, duplicate ID, or unsupported
-// ExtraParams value makes construction fail with ErrInvalidConfig. A derived
-// profile's base reference and resolved target completeness are checked when it
-// is selected or inspected. Repeating WithProfiles replaces the complete
-// earlier in-memory set rather than merging it.
-func WithProfiles(profiles ...Profile) Option {
-	return optionFunc(func(options *engineOptions) error {
-		definitions := make([]domain.ExecutionProfile, len(profiles))
-		for index, publicProfile := range profiles {
-			definitions[index] = toDomainProfile(publicProfile)
-		}
-		return options.internal.SetMemoryProfiles(definitions)
-	})
-}
-
 // WithSchemaFS loads JSON Schema documents from fsys under root.
 //
 // Prompt schema_path values resolve within this source when schema validation
@@ -302,14 +208,15 @@ func WithSchemaFile(path string) Option {
 
 // NewEngine constructs an Engine from configuration and options.
 //
-// Options are applied in order according to [Option]. PromptDir is required
-// unless a prompt-source option is present. Construction validates option
-// arguments, in-memory profiles, and backend registrations but defers reading
-// and validating prompt, file-backed profile, and schema contents until Prepare
-// or Run needs them.
+// ConfigKit composes maintained catalog inputs, PromptKit-owned definitions,
+// caller underlays, and the optional main input in that order. Construction
+// validates the final effective backend, profile, and prompt definitions and
+// captures referenced prompt content. A missing prompt collection is allowed.
+// Schema documents and request artifacts remain runtime resources.
 //
 // NewEngine returns an error matching ErrInvalidConfig for invalid
-// configuration, options, or backend-capacity policies. Each constructed
+// configuration or options, preserving a ConfigKit LoadError when loading
+// fails. Each constructed
 // Engine has independent backend-capacity pools. Construction does not perform
 // model requests or require credentials. A negative Config.TransientRetries
 // is invalid.
@@ -320,16 +227,16 @@ func NewEngine(cfg Config, opts ...Option) (*Engine, error) {
 			continue
 		}
 		if err := opt.apply(&options); err != nil {
-			return nil, fmt.Errorf("%w: %v", ErrInvalidConfig, err)
+			return nil, fmt.Errorf("%w: %w", ErrInvalidConfig, err)
 		}
 	}
 
 	assembled, err := internalengine.New(
-		internalengine.Config{PromptDir: cfg.PromptDir, ProfileDir: cfg.ProfileDir, SchemaDir: cfg.SchemaDir, Timeout: cfg.Timeout, HTTPClient: cfg.HTTPClient, TransientRetries: copyIntPtr(cfg.TransientRetries)},
+		internalengine.Config{Sources: internalengine.ConfigurationSources{Underlays: cfg.Sources.Underlays, Main: cfg.Sources.Main}, SchemaDir: cfg.SchemaDir, Timeout: cfg.Timeout, HTTPClient: cfg.HTTPClient, TransientRetries: copyIntPtr(cfg.TransientRetries)},
 		options.internal,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("%w: %v", ErrInvalidConfig, err)
+		return nil, fmt.Errorf("%w: %w", ErrInvalidConfig, err)
 	}
 	return &Engine{internal: assembled}, nil
 }
@@ -339,9 +246,9 @@ func NewEngine(cfg Config, opts ...Option) (*Engine, error) {
 //
 // InspectPrompt requires a nonblank promptID. It passes nonblank promptID and
 // promptVersion values unchanged to the engine's ordinary, case-sensitive
-// prompt selection. An empty version succeeds only when that source has one
-// selected ID; a nonempty version selects one exact ID/version pair. The
-// configured prompt source is used without merging, fallback, or enumeration.
+// prompt selection. An empty version succeeds only when that ID has one
+// version; a nonempty version selects one exact ID/version pair from the
+// captured configuration snapshot.
 //
 // A successful result proves that the selected definition and any referenced
 // message content files were structurally loaded. Inputs are returned in
@@ -349,22 +256,22 @@ func NewEngine(cfg Config, opts ...Option) (*Engine, error) {
 // resolved. OutputContract is the normalized declared contract, with a JSON
 // Schema path when declared but without loading or compiling that schema.
 // PromptHash is the same opaque equality value as PreparedRun.PromptHash for
-// the selected definition and observed source state; its spelling, length,
+// the selected captured definition; its spelling, length,
 // encoding, algorithm, and security properties are not contracts.
 //
 // This method does not return prompt bodies, templates, source paths, schemas,
 // rendered messages, or execution settings. It does not resolve a profile or
 // credential, read artifacts or schemas, render, validate, admit capacity,
 // contact a provider, or generate model output. The returned PromptInspection
-// and its input slice are caller-owned. Filesystem-backed inspection is a
-// point-in-time lookup and does not freeze a definition for later execution.
+// and its input slice are caller-owned. Inspection does not reload configuration
+// or content files; construct another Engine to observe source changes.
 //
 // A nil Engine returns an error matching ErrInvalidConfig. A blank prompt ID
 // matches ErrInvalidRequest. An absent exact ID or version matches
-// ErrPromptNotFound and not ErrPromptLoad. Malformed, unreadable, duplicate,
-// ambiguous, referenced-content, or hashing failures match ErrPromptLoad.
-// Cancellation during lookup matches ErrPromptLoad while preserving the
-// context error. InspectPrompt returns no partial result on error.
+// ErrPromptNotFound and not ErrPromptLoad. An ambiguous omitted version matches
+// ErrPromptLoad. Invalid definitions and resource failures reject construction
+// instead. Cancellation during lookup preserves the context error. InspectPrompt
+// returns no partial result on error.
 func (e *Engine) InspectPrompt(
 	ctx context.Context,
 	promptID string,
@@ -384,10 +291,9 @@ func (e *Engine) InspectPrompt(
 // InspectProfile resolves one explicit profile without selecting a prompt or
 // starting execution work.
 //
-// InspectProfile trims surrounding whitespace from profileID and looks up the
-// resulting nonblank ID exactly and case-sensitively through the engine's
-// in-memory, ordinary configured-source, application fallback, and built-in
-// profile precedence. It applies the framework timeout baseline, selected
+// InspectProfile looks up a nonblank profileID exactly and case-sensitively
+// in the captured effective configuration. It applies the framework timeout
+// baseline, selected
 // backend, and then selected profile to EffectiveModelParams without a request
 // override. BackendID is empty for an endpoint-only profile.
 //
@@ -398,16 +304,15 @@ func (e *Engine) InspectPrompt(
 // absent or blank named environment variable is not an error.
 //
 // The returned ProfileInspection and all nested mutable values are
-// caller-owned. Filesystem-backed inspection is a point-in-time lookup and
-// does not freeze the profile for a later execution. This method does not load
+// caller-owned. Inspection does not reload configuration; construct another
+// Engine to observe source changes. This method does not load
 // a prompt, render, read artifacts or schemas, admit backend capacity, contact
 // a provider, or generate model output.
 //
 // A nil Engine returns an error matching ErrInvalidConfig. A blank profile ID
 // matches ErrInvalidRequest. An absent exact ID matches ErrProfileNotFound and
-// not ErrProfileLoad. Malformed or unreadable profile data, an unknown backend,
-// or an invalid resolved target matches ErrProfileLoad. Cancellation during
-// profile loading matches ErrProfileLoad while preserving the context error.
+// not ErrProfileLoad. Invalid definitions or unknown backends reject
+// construction instead. Cancellation preserves the context error.
 // InspectProfile returns no partial result on error.
 func (e *Engine) InspectProfile(ctx context.Context, profileID string) (*ProfileInspection, error) {
 	if e == nil || e.internal == nil {
@@ -441,6 +346,32 @@ func (e *Engine) InspectProfile(ctx context.Context, profileID string) (*Profile
 // relationship to ctx.Err is promised. Prepare returns no partial result on
 // error. It validates RunRequest.TransientRetries but makes no model attempts.
 func (e *Engine) Prepare(ctx context.Context, req RunRequest) (*PreparedRun, error) {
+	prepared, err := e.prepareRequest(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return fromDomainPreparedRun(prepared), nil
+}
+
+// ValidateRequest reports whether req passes the same preparation path used by
+// [Engine.Prepare] at the time of this call. A nil error means this concrete
+// request passed preparation. It checks only this invocation and returns errors
+// as encountered rather than aggregating them. All supplied inputs follow the
+// same loading behavior as [Engine.Prepare], including inputs unused by the
+// selected template branch. The method does not call an LLM or retain a
+// prepared snapshot or executable handle, but preparation may still perform
+// resource I/O and incur its associated time and memory costs.
+//
+// Its errors and context handling follow [Engine.Prepare], including an error
+// matching ErrInvalidConfig when the Engine is nil. Success does not guarantee
+// provider acceptance or later execution success. Use [Engine.PrepareExecution]
+// when execution must use the snapshot produced by preparation.
+func (e *Engine) ValidateRequest(ctx context.Context, req RunRequest) error {
+	_, err := e.prepareRequest(ctx, req)
+	return err
+}
+
+func (e *Engine) prepareRequest(ctx context.Context, req RunRequest) (*domain.PreparedRun, error) {
 	ctx = observation.WithoutExecutionState(ctx)
 	if e == nil || e.internal == nil {
 		return nil, fmt.Errorf("%w: engine is nil", ErrInvalidConfig)
@@ -455,7 +386,7 @@ func (e *Engine) Prepare(ctx context.Context, req RunRequest) (*PreparedRun, err
 	if err != nil {
 		return nil, mapPublicError(err)
 	}
-	return fromDomainPreparedRun(prepared), nil
+	return prepared, nil
 }
 
 // PrepareExecution completely prepares a prompt request without calling the
@@ -495,8 +426,9 @@ func (e *Engine) PrepareExecution(ctx context.Context, req RunRequest) (*Prepare
 }
 
 // Run prepares a request, invokes the configured LLMClient, and validates the
-// generated output. Each call resolves current sources and composes a fresh,
-// stateless effective prompt with any validated RunRequest.AppendedMessages.
+// generated output. Each call uses the Engine's captured configuration and
+// composes a fresh effective prompt with any validated
+// RunRequest.AppendedMessages.
 //
 // A content-validation failure is a successful run whose
 // RunResult.Validation has Status ValidationFailed. When its output contract

errors.go

@@ -72,10 +72,6 @@ func publicErrorFor(err error) error {
 		return ErrPromptLoad
 	case errors.Is(err, usecase.ErrProfileLoad):
 		return ErrProfileLoad
-	case errors.Is(err, promptdef.ErrInvalidYAML), errors.Is(err, promptdef.ErrInvalidPromptDefinition):
-		return ErrPromptLoad
-	case isProfileLoadCause(err):
-		return ErrProfileLoad
 	case errors.Is(err, usecase.ErrAPIKeyEnvMissing):
 		return errors.Join(ErrInvalidRequest, ErrAPIKeyEnvMissing)
 	case errors.Is(err, capacity.ErrCapacityExceeded):
@@ -94,9 +90,3 @@ func publicErrorFor(err error) error {
 		return nil
 	}
 }
-
-func isProfileLoadCause(err error) bool {
-	return errors.Is(err, profile.ErrInvalidYAML) ||
-		errors.Is(err, profile.ErrInvalidProfile) ||
-		errors.Is(err, profile.ErrRawAPIKeyNotAllowed)
-}

examples/go-library/observe/main.go

@@ -10,6 +10,7 @@ import (
 	"os"
 	"strings"
 
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit"
 )
 
@@ -78,14 +79,24 @@ type summary struct {
 
 func run() (summary, error) {
 	transport := &scriptedTransport{}
-	engine, err := promptkit.NewEngine(promptkit.Config{HTTPClient: &http.Client{Transport: transport}},
-		promptkit.WithPromptFS(assets, "prompts"),
-		promptkit.WithSchemaFS(assets, "schemas"),
-		promptkit.WithBackend(promptkit.Backend{ID: "offline-backend", Endpoint: "https://example.invalid/v1", ConcurrencyLimit: 1}),
-		promptkit.WithProfiles(
-			promptkit.Profile{ID: "proposal-profile", BackendID: "offline-backend", Model: "proposal-model"},
-			promptkit.Profile{ID: "assessment-profile", BackendID: "offline-backend", Model: "assessment-model"},
-		))
+	inputs, err := promptkit.FilesystemInputs("example prompts", assets, "prompts")
+	if err != nil {
+		return summary{}, err
+	}
+	backendID, proposalModel, assessmentModel := "offline-backend", "proposal-model", "assessment-model"
+	inputs = append(inputs,
+		configkit.Input{Source: promptkit.BackendSource("example backend", map[string]promptkit.BackendConfig{
+			backendID: promptkit.LocalBackend("https://example.invalid/v1", 1),
+		})},
+		configkit.Input{Source: promptkit.ProfileSource("example profiles", map[string]promptkit.ProfileConfig{
+			"proposal-profile":   {Backend: &backendID, Model: &proposalModel},
+			"assessment-profile": {Backend: &backendID, Model: &assessmentModel},
+		})},
+	)
+	engine, err := promptkit.NewEngine(promptkit.Config{
+		Sources:    promptkit.ConfigurationSources{Underlays: []configkit.Underlay{{Inputs: inputs}}},
+		HTTPClient: &http.Client{Transport: transport},
+	}, promptkit.WithSchemaFS(assets, "schemas"))
 	if err != nil {
 		return summary{}, err
 	}

examples/go-library/observe/prompts/assessment.yaml

@@ -1,17 +1,18 @@
-id: example.assessment
-version: "1.0.0"
-default_profile: assessment-profile
-description: Assess a structured proposal independently of schema validity.
-inputs:
-  - name: proposal
-    required: true
-    content_type: application/json
-messages:
-  - role: system
-    content: Return a concise assessment as JSON.
-  - role: user
-    content: '{{input "proposal"}}'
-output:
-  format: json
-  validation_mode: json_schema
-  schema_path: assessment.schema.json
+prompts:
+  example.assessment:
+    "1.0.0":
+      default_profile: assessment-profile
+      description: Assess a structured proposal independently of schema validity.
+      inputs:
+        - name: proposal
+          required: true
+          content_type: application/json
+      messages:
+        - role: system
+          content: Return a concise assessment as JSON.
+        - role: user
+          content: '{{input "proposal"}}'
+      output:
+        format: json
+        validation_mode: json_schema
+        schema_path: assessment.schema.json

examples/go-library/observe/prompts/proposal.yaml

@@ -1,17 +1,18 @@
-id: example.proposal
-version: "1.0.0"
-default_profile: proposal-profile
-description: Propose a bounded improvement from a synthetic idea.
-inputs:
-  - name: idea
-    required: true
-    content_type: text/plain
-messages:
-  - role: system
-    content: Return a concise proposal as JSON.
-  - role: user
-    content: '{{input "idea"}}'
-output:
-  format: json
-  validation_mode: json_schema
-  schema_path: proposal.schema.json
+prompts:
+  example.proposal:
+    "1.0.0":
+      default_profile: proposal-profile
+      description: Propose a bounded improvement from a synthetic idea.
+      inputs:
+        - name: idea
+          required: true
+          content_type: text/plain
+      messages:
+        - role: system
+          content: Return a concise proposal as JSON.
+        - role: user
+          content: '{{input "idea"}}'
+      output:
+        format: json
+        validation_mode: json_schema
+        schema_path: proposal.schema.json

examples/go-library/prepare/main.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit"
 )
 
@@ -18,25 +19,45 @@ type summary struct {
 }
 
 func main() {
-	engine, err := promptkit.NewEngine(
-		promptkit.Config{},
-		promptkit.WithPromptFile("examples/go-library/prepare/prompt.yaml"),
-		promptkit.WithProfiles(promptkit.Profile{
-			ID:       "offline-example",
-			Endpoint: "https://example.invalid/v1",
-			Model:    "offline-model",
-		}),
-	)
+	endpoint, model := "https://example.invalid/v1", "offline-model"
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: promptkit.ProfileSource("example profile", map[string]promptkit.ProfileConfig{
+			"offline-example": {Endpoint: &endpoint, Model: &model},
+		})}}}},
+		Main: &configkit.Input{Source: configkit.File("examples/go-library/prepare/prompt.yaml")},
+	}})
 	if err != nil {
 		exit(err)
 	}
+	view, err := engine.InspectConfiguration()
+	if err != nil {
+		exit(err)
+	}
+	if _, found := view.Explain(configkit.Keys("profiles", "offline-example", "model")); !found {
+		exit(fmt.Errorf("configured profile model was not found"))
+	}
+	requirements, err := engine.InspectRequirements(context.Background(), promptkit.RequirementInspectionRequest{
+		PromptID: "example.prepare",
+	})
+	if err != nil {
+		exit(err)
+	}
+	if !requirements.Complete || len(requirements.Inputs) != 1 ||
+		requirements.Inputs[0].Name != "note" ||
+		requirements.Inputs[0].Kind != promptkit.RequirementRequired {
+		exit(fmt.Errorf("required note input was not discovered before preparation"))
+	}
 
-	prepared, err := engine.Prepare(context.Background(), promptkit.RunRequest{
+	request := promptkit.RunRequest{
 		PromptID: "example.prepare",
 		Inputs: map[string]promptkit.ArtifactRef{
 			"note": promptkit.Inline("Ada finished the migration review."),
 		},
-	})
+	}
+	if err := engine.ValidateRequest(context.Background(), request); err != nil {
+		exit(err)
+	}
+	prepared, err := engine.Prepare(context.Background(), request)
 	if err != nil {
 		exit(err)
 	}

examples/go-library/prepare/prompt.yaml

@@ -1,16 +1,17 @@
-id: example.prepare
-version: "1.0.0"
-default_profile: offline-example
-description: Prepare a prompt without contacting a model provider.
-inputs:
-  - name: note
-    required: true
-    content_type: text/plain
-messages:
-  - role: system
-    content: Summarize the note in one sentence.
-  - role: user
-    content: '{{input "note"}}'
-output:
-  format: text
-  validation_mode: basic
+prompts:
+  example.prepare:
+    "1.0.0":
+      default_profile: offline-example
+      description: Prepare a prompt without contacting a model provider.
+      inputs:
+        - name: note
+          required: true
+          content_type: text/plain
+      messages:
+        - role: system
+          content: Summarize the note in one sentence.
+        - role: user
+          content: '{{input "note"}}'
+      output:
+        format: text
+        validation_mode: basic

examples/go-library/run/main.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit"
 )
 
@@ -38,16 +39,13 @@ type summary struct {
 }
 
 func main() {
-	engine, err := promptkit.NewEngine(
-		promptkit.Config{},
-		promptkit.WithPromptFile("examples/go-library/run/prompt.yaml"),
-		promptkit.WithProfiles(promptkit.Profile{
-			ID:       "offline-example",
-			Endpoint: "https://example.invalid/v1",
-			Model:    "offline-model",
-		}),
-		promptkit.WithLLMClient(deterministicClient{}),
-	)
+	endpoint, model := "https://example.invalid/v1", "offline-model"
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: promptkit.ProfileSource("example profile", map[string]promptkit.ProfileConfig{
+			"offline-example": {Endpoint: &endpoint, Model: &model},
+		})}}}},
+		Main: &configkit.Input{Source: configkit.File("examples/go-library/run/prompt.yaml")},
+	}}, promptkit.WithLLMClient(deterministicClient{}))
 	if err != nil {
 		exit(err)
 	}

examples/go-library/run/prompt.yaml

@@ -1,16 +1,17 @@
-id: example.run
-version: "1.0.0"
-default_profile: offline-example
-description: Run a prompt with a deterministic injected model client.
-inputs:
-  - name: note
-    required: true
-    content_type: text/plain
-messages:
-  - role: system
-    content: Summarize the note in one sentence.
-  - role: user
-    content: '{{input "note"}}'
-output:
-  format: text
-  validation_mode: basic
+prompts:
+  example.run:
+    "1.0.0":
+      default_profile: offline-example
+      description: Run a prompt with a deterministic injected model client.
+      inputs:
+        - name: note
+          required: true
+          content_type: text/plain
+      messages:
+        - role: system
+          content: Summarize the note in one sentence.
+        - role: user
+          content: '{{input "note"}}'
+      output:
+        format: text
+        validation_mode: basic

frozen_rendering_contract_test.go

@@ -0,0 +1,177 @@
+package promptkit_test
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit"
+)
+
+const capturedPromptDocument = `
+prompts:
+  captured:
+    "1":
+      default_profile: offline
+      session_id: '{{.session}}'
+      messages:
+        - role: user
+          content_file: body.tmpl
+      output:
+        format: text
+        validation_mode: none
+`
+
+func capturedPromptEngine(t *testing.T, source fs.FS) *promptkit.Engine {
+	t.Helper()
+	inputs, err := promptkit.FilesystemInputs("application prompts", source, "config")
+	if err != nil {
+		t.Fatalf("select prompt inputs: %v", err)
+	}
+	endpoint, model := "https://example.invalid/v1", "offline-model"
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{
+			{Inputs: inputs},
+			{Inputs: []configkit.Input{{Source: promptkit.ProfileSource("offline profile", map[string]promptkit.ProfileConfig{
+				"offline": {Endpoint: &endpoint, Model: &model},
+			})}}},
+		},
+	}})
+	if err != nil {
+		t.Fatalf("construct engine: %v", err)
+	}
+	return engine
+}
+
+func TestEngineCapturesPromptContentUntilReconstruction(t *testing.T) {
+	files := fstest.MapFS{
+		"config/prompt.yaml": &fstest.MapFile{Data: []byte(capturedPromptDocument)},
+		"config/body.tmpl":   &fstest.MapFile{Data: []byte("before {{.name}}")},
+	}
+	first := capturedPromptEngine(t, files)
+	files["config/body.tmpl"] = &fstest.MapFile{Data: []byte("after {{.name}}")}
+	request := promptkit.RunRequest{PromptID: "captured", Vars: map[string]string{"name": "Ada", "session": "session-1"}}
+	oldPrepared, err := first.Prepare(context.Background(), request)
+	if err != nil {
+		t.Fatalf("prepare with existing engine: %v", err)
+	}
+	second := capturedPromptEngine(t, files)
+	newPrepared, err := second.Prepare(context.Background(), request)
+	if err != nil {
+		t.Fatalf("prepare with rebuilt engine: %v", err)
+	}
+	if oldPrepared.Messages[0].Content != "before Ada" || newPrepared.Messages[0].Content != "after Ada" || oldPrepared.PromptHash == newPrepared.PromptHash {
+		t.Fatalf("captured content or hash did not follow engine lifetime: old=%+v new=%+v", oldPrepared, newPrepared)
+	}
+}
+
+type unreadableAfterConstructionFS struct {
+	fs.FS
+	closed atomic.Bool
+	reads  atomic.Int64
+}
+
+func (source *unreadableAfterConstructionFS) Open(name string) (fs.File, error) {
+	if source.closed.Load() {
+		source.reads.Add(1)
+		return nil, fs.ErrPermission
+	}
+	return source.FS.Open(name)
+}
+
+func TestCapturedTemplatesBindInputsIndependentlyAcrossConcurrentPreparations(t *testing.T) {
+	source := &unreadableAfterConstructionFS{FS: fstest.MapFS{
+		"config/prompt.yaml": &fstest.MapFile{Data: []byte(capturedPromptDocument)},
+		"config/body.tmpl":   &fstest.MapFile{Data: []byte(`{{.name}}: {{input "note"}}`)},
+	}}
+	engine := capturedPromptEngine(t, source)
+	source.closed.Store(true)
+
+	const calls = 24
+	var wait sync.WaitGroup
+	errs := make(chan error, calls)
+	for index := 0; index < calls; index++ {
+		wait.Add(1)
+		go func(index int) {
+			defer wait.Done()
+			name := fmt.Sprintf("caller-%d", index)
+			body := fmt.Sprintf("body-%d", index)
+			prepared, err := engine.Prepare(context.Background(), promptkit.RunRequest{
+				PromptID: "captured", SessionID: "direct-session",
+				Vars:   map[string]string{"name": name},
+				Inputs: map[string]promptkit.ArtifactRef{"note": promptkit.Inline(body)},
+			})
+			if err == nil && (prepared.Messages[0].Content != name+": "+body || prepared.SessionID != "direct-session") {
+				err = fmt.Errorf("unexpected prepared content: %+v", prepared)
+			}
+			errs <- err
+		}(index)
+	}
+	wait.Wait()
+	close(errs)
+	for err := range errs {
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	if source.reads.Load() != 0 {
+		t.Fatalf("preparation reopened captured source %d times", source.reads.Load())
+	}
+
+	_, err := engine.Prepare(context.Background(), promptkit.RunRequest{
+		PromptID: "captured", Vars: map[string]string{"name": "Ada"},
+		Inputs: map[string]promptkit.ArtifactRef{"note": promptkit.Inline("body")},
+	})
+	if !errors.Is(err, promptkit.ErrPromptRender) {
+		t.Fatalf("missing session variable = %v, want runtime render error", err)
+	}
+	_, err = engine.Prepare(context.Background(), promptkit.RunRequest{
+		PromptID: "captured", SessionID: "direct-session", Vars: map[string]string{"name": "Ada"},
+	})
+	if !errors.Is(err, promptkit.ErrPromptRender) {
+		t.Fatalf("missing input helper artifact = %v, want runtime render error", err)
+	}
+}
+
+func TestPreparationStillReadsRequestArtifactsAndSchemasAfterConstruction(t *testing.T) {
+	endpoint, model := "https://example.invalid/v1", "offline-model"
+	schemas := fstest.MapFS{}
+	engine, err := promptkit.NewEngine(promptkit.Config{Sources: promptkit.ConfigurationSources{
+		Underlays: []configkit.Underlay{{Inputs: []configkit.Input{{Source: promptkit.ProfileSource("profile", map[string]promptkit.ProfileConfig{
+			"offline": {Endpoint: &endpoint, Model: &model},
+		})}}}},
+		Main: &configkit.Input{Source: configkit.Mapping("structured prompt", map[string]any{
+			"prompts": map[string]any{"structured": map[string]any{"1": map[string]any{
+				"default_profile": "offline",
+				"inputs":          []any{map[string]any{"name": "note", "required": true}},
+				"messages":        []any{map[string]any{"role": "user", "content": `{{input "note"}}`}},
+				"output":          map[string]any{"format": "json", "validation_mode": "json_schema", "schema_path": "schema.json"},
+			}}},
+		})},
+	}}, promptkit.WithSchemaFS(schemas, "."))
+	if err != nil {
+		t.Fatalf("construct engine before request resources exist: %v", err)
+	}
+	schemas["schema.json"] = &fstest.MapFile{Data: []byte(`{"$schema":"https://json-schema.org/draft/2020-12/schema","type":"object"}`)}
+	artifactPath := filepath.Join(t.TempDir(), "note.txt")
+	if err := os.WriteFile(artifactPath, []byte("request artifact"), 0o600); err != nil {
+		t.Fatalf("write request artifact: %v", err)
+	}
+	prepared, err := engine.Prepare(context.Background(), promptkit.RunRequest{PromptID: "structured", Inputs: map[string]promptkit.ArtifactRef{
+		"note": promptkit.File(artifactPath),
+	}})
+	if err != nil {
+		t.Fatalf("prepare with resources supplied after construction: %v", err)
+	}
+	if len(prepared.Messages) != 1 || prepared.Messages[0].Content != "request artifact" || prepared.StructuredOutput == nil || prepared.StructuredOutput.JSONSchema == nil {
+		t.Fatalf("runtime artifact or schema was not prepared: %+v", prepared)
+	}
+}

generation_error_contract_test.go

@@ -21,14 +21,14 @@ func TestBuiltInGenerationError(t *testing.T) {
 	engine := newBuiltInGenerationErrorEngine(t, http.StatusUnprocessableEntity,
 		`{"error":{"code":"`+codeMarker+`","type":"`+typeMarker+`","message":"`+messageMarker+`"}}`)
 
-	result, err := engine.Run(context.Background(), generationErrorRunRequest())
+	result, err := engine.Run(context.Background(), simpleGenerationRequest())
 	if result != nil {
 		t.Fatalf("Run result = %#v, want nil", result)
 	}
 	assertGenerationError(t, err, http.StatusUnprocessableEntity, codeMarker, typeMarker, messageMarker)
 
 	preparedEngine := newBuiltInGenerationErrorEngine(t, http.StatusServiceUnavailable, `{"error":{}}`)
-	prepared, err := preparedEngine.PrepareExecution(context.Background(), generationErrorRunRequest())
+	prepared, err := preparedEngine.PrepareExecution(context.Background(), simpleGenerationRequest())
 	if err != nil {
 		t.Fatalf("PrepareExecution: %v", err)
 	}
@@ -43,7 +43,7 @@ func TestBuiltInGenerationErrorWithAppendedMessages(t *testing.T) {
 	const messageMarker = "combined-request-provider-marker"
 	engine := newBuiltInGenerationErrorEngine(t, http.StatusUnprocessableEntity,
 		`{"error":{"message":"`+messageMarker+`"}}`)
-	request := generationErrorRunRequest()
+	request := simpleGenerationRequest()
 	request.AppendedMessages = []promptkit.RenderedMessage{
 		{Role: promptkit.RoleAssistant, Content: "previous response"},
 		{Role: promptkit.RoleUser, Content: "consumer correction"},
@@ -63,7 +63,7 @@ func TestBuiltInRepairGenerationError(t *testing.T) {
 		messageMarker = "repair-message-marker"
 	)
 	calls := 0
-	config := contractConfig(frameworkSchemaDir)
+	config := simpleConfig("message")
 	config.HTTPClient = &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
 		calls++
 		if calls == 1 {
@@ -77,7 +77,7 @@ func TestBuiltInRepairGenerationError(t *testing.T) {
 	if err != nil {
 		t.Fatalf("NewEngine: %v", err)
 	}
-	req := generationErrorRunRequest()
+	req := simpleGenerationRequest()
 	req.Validation = &promptkit.OutputContract{
 		Format:         promptkit.FormatJSON,
 		ValidationMode: promptkit.ValidationJSON,
@@ -96,7 +96,7 @@ func TestBuiltInRepairGenerationError(t *testing.T) {
 
 func TestBuiltInGenerationFailureCategories(t *testing.T) {
 	transportCause := errors.New("private transport diagnostic")
-	config := contractConfig(frameworkSchemaDir)
+	config := simpleConfig("message")
 	config.HTTPClient = &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
 		return nil, transportCause
 	})}
@@ -104,7 +104,7 @@ func TestBuiltInGenerationFailureCategories(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	result, err := engine.Run(context.Background(), generationErrorRunRequest())
+	result, err := engine.Run(context.Background(), simpleGenerationRequest())
 	if result != nil || !errors.Is(err, promptkit.ErrLLMGenerate) || !errors.Is(err, promptkit.ErrTransport) || !errors.Is(err, transportCause) {
 		t.Fatalf("transport result=%#v, error=%v", result, err)
 	}
@@ -122,7 +122,7 @@ func TestBuiltInGenerationFailureCategories(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			engine := newBuiltInGenerationErrorEngine(t, http.StatusOK, tc.body)
-			result, err := engine.Run(context.Background(), generationErrorRunRequest())
+			result, err := engine.Run(context.Background(), simpleGenerationRequest())
 			if result != nil || !errors.Is(err, promptkit.ErrLLMGenerate) || !errors.Is(err, promptkit.ErrMalformedResponse) || errors.Is(err, promptkit.ErrTransport) {
 				t.Fatalf("malformed result=%#v, error=%v", result, err)
 			}
@@ -139,7 +139,7 @@ func TestBuiltInGenerationPreservesContextIdentity(t *testing.T) {
 		{name: "deadline", cause: context.DeadlineExceeded},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			config := contractConfig(frameworkSchemaDir)
+			config := simpleConfig("message")
 			config.HTTPClient = &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
 				return nil, tc.cause
 			})}
@@ -147,7 +147,7 @@ func TestBuiltInGenerationPreservesContextIdentity(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			result, err := engine.Run(context.Background(), generationErrorRunRequest())
+			result, err := engine.Run(context.Background(), simpleGenerationRequest())
 			if result != nil || !errors.Is(err, tc.cause) || !errors.Is(err, promptkit.ErrLLMGenerate) || !errors.Is(err, promptkit.ErrTransport) {
 				t.Fatalf("context result=%#v, error=%v", result, err)
 			}
@@ -165,8 +165,8 @@ func TestInjectedGenerationFailureCategories(t *testing.T) {
 		{name: "arbitrary error", client: &fakeLLMClient{err: errors.New("injected failure")}},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			engine := newContractEngineWithOptions(t, frameworkSchemaDir, promptkit.WithLLMClient(tc.client))
-			result, err := engine.Run(context.Background(), generationErrorRunRequest())
+			engine := newSimpleEngine(t, "message", promptkit.WithLLMClient(tc.client))
+			result, err := engine.Run(context.Background(), simpleGenerationRequest())
 			if result != nil || !errors.Is(err, promptkit.ErrLLMGenerate) || errors.Is(err, promptkit.ErrTransport) || errors.Is(err, promptkit.ErrMalformedResponse) != tc.malformed {
 				t.Fatalf("injected result=%#v, error=%v", result, err)
 			}
@@ -207,7 +207,7 @@ func assertGenerationError(t *testing.T, err error, statusCode int, code, provid
 func newBuiltInGenerationErrorEngine(t *testing.T, statusCode int, body string) *promptkit.Engine {
 	t.Helper()
 
-	config := contractConfig(frameworkSchemaDir)
+	config := simpleConfig("message")
 	noRetries := 0
 	config.TransientRetries = &noRetries
 	config.HTTPClient = &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
@@ -224,12 +224,6 @@ func newBuiltInGenerationErrorEngine(t *testing.T, statusCode int, body string)
 	return engine
 }
 
-func generationErrorRunRequest() promptkit.RunRequest {
-	return promptkit.RunRequest{
-		PromptID: frameworkMarkdownSummaryPromptID,
-		Inputs: map[string]promptkit.ArtifactRef{
-			"transcript": promptkit.Inline("Rin opens the gate."),
-			"glossary":   promptkit.Inline("gate: A guarded passage."),
-		},
-	}
+func simpleGenerationRequest() promptkit.RunRequest {
+	return promptkit.RunRequest{PromptID: "prompt"}
 }

go.mod

@@ -1,12 +1,20 @@
 module gitea.maximumdirect.net/eric/promptkit
 
-go 1.25.5
+go 1.26.0
 
 require (
-	gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2 v2.20260926.0
-	gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2 v2.20260926.0
+	gitea.maximumdirect.net/eric/ConfigKit v0.7.1
+	gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v3 v3.20260930.0
+	gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v3 v3.20260930.0
 	github.com/santhosh-tekuri/jsonschema/v6 v6.0.2
-	gopkg.in/yaml.v3 v3.0.1
 )
 
-require golang.org/x/text v0.14.0 // indirect
+require (
+	gitea.maximumdirect.net/eric/ReleaseKit v0.4.1 // indirect
+	github.com/yuin/goldmark/v2 v2.1.6 // indirect
+	go.yaml.in/yaml/v4 v4.0.0-rc.6 // indirect
+	golang.org/x/mod v0.40.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)
+
+tool gitea.maximumdirect.net/eric/ReleaseKit/cmd/releasekit

go.sum

@@ -1,14 +1,22 @@
-gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2 v2.20260926.0 h1:wdab+R+lgMZxzYwhbAuCrW7zdSQ1cW9ovBR6UzLmZR4=
-gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2 v2.20260926.0/go.mod h1:a3VBbh9oaGXD6ruxhtwHj+AWW6DY/SSyby1QtMmYSUo=
-gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2 v2.20260926.0 h1:baCCIB6Ee5t0S4Zc++NTBIPcJEv5UPS6DlSrpZfykwg=
-gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2 v2.20260926.0/go.mod h1:mtgD1E0SGm0e/I8Ffhz+AYX7GN7RKUWJXehNFIKHs4Y=
+gitea.maximumdirect.net/eric/ConfigKit v0.7.1 h1:q3HrX4WWCPt1WfMydqFEaAmCf9s6Dq+vknJj0C/mdcI=
+gitea.maximumdirect.net/eric/ConfigKit v0.7.1/go.mod h1:C82sbyKHYMV1OwaD2GJanFrwTfcZfjlW2JsGze5b0kA=
+gitea.maximumdirect.net/eric/ReleaseKit v0.4.1 h1:Qn+mdebYOzCVCEXgCbuGSO/WHmJtItwaQ8e3XwY3qtI=
+gitea.maximumdirect.net/eric/ReleaseKit v0.4.1/go.mod h1:LVodqNQ3OIKv9NBq+fFeyMByd1lHY25YOmmpah/NaNI=
+gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v3 v3.20260930.0 h1:lzfCDbzJQRGzIlRPRprnAV9hVVL5zUQy80VMQ0kbYa0=
+gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v3 v3.20260930.0/go.mod h1:HjS0f+3q0IdHCTEz+VVAEgIwIWJFAZUjuKdAtvtqKdg=
+gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v3 v3.20260930.0 h1:h12ZTRldAmpLAomj0oQRGteFxHLN1LPE6XDl9zJNbm8=
+gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v3 v3.20260930.0/go.mod h1:OEFBeKdjTsLzqJwLmXI2O5gG3r64FktcVJVb3mBrRfg=
 github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
 github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/santhosh-tekuri/jsonschema/v6 v6.0.2 h1:KRzFb2m7YtdldCEkzs6KqmJw4nqEVZGK7IN2kJkjTuQ=
 github.com/santhosh-tekuri/jsonschema/v6 v6.0.2/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU=
+github.com/yuin/goldmark/v2 v2.1.6 h1:igy0q9JcqovoFXFx/XjtU8sHVhcUHavPj2sA3EoKJUE=
+github.com/yuin/goldmark/v2 v2.1.6/go.mod h1:G6M4/qOFtfn01/o14BU1UR2Lo5N3S9Qo7xCuz/sHjGQ=
+go.yaml.in/yaml/v4 v4.0.0-rc.6 h1:1h7H1ohdUh93/FyE4YaDa1Zh64K6VVbjF4K6WUxMtH4=
+go.yaml.in/yaml/v4 v4.0.0-rc.6/go.mod h1:aZqd9kCMsGL7AuUv/m/PvWLdg5sjJsZ4oHDEnfPPfY0=
+golang.org/x/mod v0.40.0 h1:hUv+3cXcdRHz08UmSiOob7sadHig73uo5bkXxQ/tvUs=
+golang.org/x/mod v0.40.0/go.mod h1:0/weTWkPWGBikyTWAX3dkjVztMmBA5hM0DH6BElSupE=
 golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/artifact/reader.go

@@ -21,6 +21,7 @@ var (
 )
 
 const fileReadChunkSize = 64 * 1024
+const fileReadInitialCapacityLimit = 1 << 20
 
 // Reader resolves artifact references into actual artifacts.
 type Reader interface {
@@ -133,7 +134,11 @@ func readFileArtifact(ctx context.Context, path string, open func(string) (artif
 		return nil, fmt.Errorf("%w: %s", ErrUnsupportedFile, path)
 	}
 
-	data := make([]byte, 0)
+	capacity := 0
+	if size := openedInfo.Size(); size > 0 {
+		capacity = int(min(size, int64(fileReadInitialCapacityLimit)))
+	}
+	data := make([]byte, 0, capacity)
 	chunk := make([]byte, fileReadChunkSize)
 	for {
 		if err := ctx.Err(); err != nil {
@@ -153,6 +158,13 @@ func readFileArtifact(ctx context.Context, path string, open func(string) (artif
 			return nil, fmt.Errorf("failed to read file %s: %w", path, readErr)
 		}
 	}
+	if cap(data)-len(data) > len(data) {
+		// A stale size hint should not make a small completed artifact retain a
+		// disproportionately large backing array.
+		compact := make([]byte, len(data))
+		copy(compact, data)
+		data = compact
+	}
 
 	contentType := mime.TypeByExtension(filepath.Ext(path))
 	if contentType == "" {

internal/artifact/reader_benchmark_test.go

@@ -0,0 +1,180 @@
+package artifact
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"mime"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+var artifactFileReadBenchmarkSink *domain.Artifact
+
+func BenchmarkArtifactFileRead(b *testing.B) {
+	for _, fixture := range makeArtifactReadBenchmarkFiles(b) {
+		b.Run(fixture.name, func(b *testing.B) {
+			reader := &fileReader{open: openArtifactFile}
+			ref := domain.ArtifactRef{Type: domain.ArtifactRefFile, URI: fixture.path}
+			checkArtifactFileRead(b, reader, ref, fixture.body)
+
+			b.ReportAllocs()
+			b.SetBytes(int64(len(fixture.body)))
+			b.ResetTimer()
+			for range b.N {
+				artifact, err := reader.Read(context.Background(), ref)
+				if err != nil {
+					b.Fatalf("read artifact: %v", err)
+				}
+				artifactFileReadBenchmarkSink = artifact
+			}
+			b.StopTimer()
+			runtime.KeepAlive(artifactFileReadBenchmarkSink)
+		})
+	}
+}
+
+// BenchmarkRetainedArtifactFileRead measures live artifact bodies when an
+// opened file reports a size larger than the content that reaches EOF.
+func BenchmarkRetainedArtifactFileRead(b *testing.B) {
+	for _, fixture := range []struct {
+		name string
+		body []byte
+	}{
+		{name: "small", body: bytes.Repeat([]byte("x"), 256<<10)},
+		{name: "empty", body: []byte{}},
+	} {
+		b.Run(fixture.name, func(b *testing.B) {
+			benchmarkRetainedArtifactFileRead(b, fixture.body)
+		})
+	}
+}
+
+func benchmarkRetainedArtifactFileRead(b *testing.B, body []byte) {
+	path := filepath.Join(b.TempDir(), "overreported.txt")
+	if err := os.WriteFile(path, body, 0o600); err != nil {
+		b.Fatal(err)
+	}
+	mime.TypeByExtension(filepath.Ext(path))
+
+	reader := &fileReader{open: func(path string) (artifactFile, error) {
+		file, err := os.Open(path)
+		if err != nil {
+			return nil, err
+		}
+		return &sizeReportingArtifactFile{artifactFile: file, reportedSize: 16 << 20}, nil
+	}}
+	ref := domain.ArtifactRef{Type: domain.ArtifactRefFile, URI: path}
+	checkArtifactFileRead(b, reader, ref, body)
+
+	const retainedBatchSize = 4
+	retained := make([]*domain.Artifact, retainedBatchSize)
+	artifactFileReadBenchmarkSink = nil
+	runtime.GC()
+	var setupMemory runtime.MemStats
+	runtime.ReadMemStats(&setupMemory)
+	runtime.KeepAlive(reader)
+	runtime.KeepAlive(ref)
+
+	b.ReportAllocs()
+	b.SetBytes(int64(len(body)))
+	b.ResetTimer()
+	for iteration := 0; iteration < b.N; iteration++ {
+		artifact, err := reader.Read(context.Background(), ref)
+		if err != nil {
+			b.Fatalf("read retained artifact: %v", err)
+		}
+		retained[iteration%len(retained)] = artifact
+	}
+	b.StopTimer()
+	for i, artifact := range retained {
+		if artifact != nil {
+			continue
+		}
+		artifact, err := reader.Read(context.Background(), ref)
+		if err != nil {
+			b.Fatalf("fill retained artifact batch: %v", err)
+		}
+		retained[i] = artifact
+	}
+	runtime.GC()
+	var retainedMemory runtime.MemStats
+	runtime.ReadMemStats(&retainedMemory)
+	b.ReportMetric(float64(int64(retainedMemory.HeapAlloc)-int64(setupMemory.HeapAlloc)), "retained-B")
+	runtime.KeepAlive(retained)
+	runtime.KeepAlive(reader)
+	runtime.KeepAlive(ref)
+}
+
+type artifactReadBenchmarkFile struct {
+	name string
+	path string
+	body []byte
+}
+
+func makeArtifactReadBenchmarkFiles(b *testing.B) []artifactReadBenchmarkFile {
+	b.Helper()
+	fixtures := []struct {
+		name string
+		size int
+	}{
+		{name: "small_4KiB", size: 4 << 10},
+		{name: "1MiB", size: 1 << 20},
+		{name: "large_4MiB", size: 4 << 20},
+	}
+	results := make([]artifactReadBenchmarkFile, 0, len(fixtures))
+	for _, fixture := range fixtures {
+		body := bytes.Repeat([]byte("x"), fixture.size)
+		path := filepath.Join(b.TempDir(), fixture.name+".txt")
+		if err := os.WriteFile(path, body, 0o600); err != nil {
+			b.Fatal(err)
+		}
+		mime.TypeByExtension(filepath.Ext(path))
+		results = append(results, artifactReadBenchmarkFile{
+			name: fixture.name,
+			path: path,
+			body: body,
+		})
+	}
+	return results
+}
+
+func checkArtifactFileRead(b *testing.B, reader Reader, ref domain.ArtifactRef, want []byte) {
+	b.Helper()
+	artifact, err := reader.Read(context.Background(), ref)
+	if err != nil {
+		b.Fatalf("check artifact read: %v", err)
+	}
+	if !bytes.Equal(artifact.Body, want) || artifact.Size != int64(len(want)) {
+		b.Fatalf("artifact size=%d body length=%d, want %d", artifact.Size, len(artifact.Body), len(want))
+	}
+	wantHash := fmt.Sprintf("%x", sha256.Sum256(want))
+	if artifact.Hash != wantHash {
+		b.Fatalf("artifact hash=%q, want %q", artifact.Hash, wantHash)
+	}
+}
+
+type sizeReportingArtifactFile struct {
+	artifactFile
+	reportedSize int64
+}
+
+func (file *sizeReportingArtifactFile) Stat() (os.FileInfo, error) {
+	info, err := file.artifactFile.Stat()
+	if err != nil {
+		return nil, err
+	}
+	return reportedArtifactFileInfo{FileInfo: info, size: file.reportedSize}, nil
+}
+
+type reportedArtifactFileInfo struct {
+	os.FileInfo
+	size int64
+}
+
+func (info reportedArtifactFileInfo) Size() int64 { return info.size }

internal/artifact/reader_test.go

@@ -3,7 +3,9 @@ package artifact
 import (
 	"bytes"
 	"context"
+	"crypto/sha256"
 	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -232,6 +234,64 @@ func TestFileReaderFailuresAndMetadata(t *testing.T) {
 	})
 }
 
+func TestFileReaderUsesOpenedSizeOnlyAsACapacityHint(t *testing.T) {
+	tests := []struct {
+		name         string
+		body         []byte
+		reportedSize int64
+	}{
+		{name: "overreported size", body: []byte("actual file content"), reportedSize: 128},
+		{name: "overreported size with empty content", body: []byte{}, reportedSize: 16 << 20},
+		{name: "underreported size", body: bytes.Repeat([]byte("x"), fileReadChunkSize+17), reportedSize: 1},
+		{name: "very large hint with small content", body: []byte("small actual content"), reportedSize: int64(^uint64(0) >> 1)},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			filePath := filepath.Join(t.TempDir(), "artifact.txt")
+			if err := os.WriteFile(filePath, tc.body, 0o600); err != nil {
+				t.Fatal(err)
+			}
+			reader := &fileReader{open: func(path string) (artifactFile, error) {
+				file, err := os.Open(path)
+				if err != nil {
+					return nil, err
+				}
+				info, err := file.Stat()
+				if err != nil {
+					file.Close()
+					return nil, err
+				}
+				return &reportedInfoFile{
+					artifactFile: file,
+					info:         reportedFileSizeInfo{FileInfo: info, size: tc.reportedSize},
+				}, nil
+			}}
+
+			artifact, err := reader.Read(context.Background(), domain.ArtifactRef{
+				Type: domain.ArtifactRefFile,
+				URI:  filePath,
+			})
+			if err != nil {
+				t.Fatalf("read artifact: %v", err)
+			}
+			if !bytes.Equal(artifact.Body, tc.body) {
+				t.Fatalf("artifact body length=%d, want %d", len(artifact.Body), len(tc.body))
+			}
+			if artifact.Size != int64(len(tc.body)) {
+				t.Fatalf("artifact size=%d, want %d", artifact.Size, len(tc.body))
+			}
+			if artifact.Name != filepath.Base(filePath) || artifact.URI != filePath || artifact.ContentType == "" {
+				t.Fatalf("unexpected artifact metadata: name=%q URI=%q content type=%q", artifact.Name, artifact.URI, artifact.ContentType)
+			}
+			wantHash := fmt.Sprintf("%x", sha256.Sum256(tc.body))
+			if artifact.Hash != wantHash {
+				t.Fatalf("artifact hash=%q, want %q", artifact.Hash, wantHash)
+			}
+		})
+	}
+}
+
 func TestFileReaderCancelsAfterReadProgress(t *testing.T) {
 	filePath := filepath.Join(t.TempDir(), "artifact.bin")
 	content := bytes.Repeat([]byte("x"), fileReadChunkSize*2)
@@ -268,6 +328,13 @@ func (f *reportedInfoFile) Stat() (os.FileInfo, error) {
 	return f.info, nil
 }
 
+type reportedFileSizeInfo struct {
+	os.FileInfo
+	size int64
+}
+
+func (info reportedFileSizeInfo) Size() int64 { return info.size }
+
 type cancelAfterProgressFile struct {
 	artifactFile
 	cancel context.CancelFunc

internal/backend/registry.go

@@ -5,63 +5,40 @@ package backend
 import (
 	"errors"
 	"fmt"
-	"regexp"
-	"sort"
-	"strings"
 
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
-	"gitea.maximumdirect.net/eric/promptkit/internal/llm"
 )
 
 const (
-	// OpenRouterID is the reserved ID of Promptkit's built-in OpenRouter
-	// backend.
+	// OpenRouterID identifies the maintained OpenRouter backend.
 	OpenRouterID = "openrouter"
-	// RakestrawHomeID is the reserved ID of Promptkit's built-in Rakestrawhome
-	// backend.
+	// RakestrawHomeID identifies the maintained Rakestrawhome backend.
 	RakestrawHomeID = "rakestrawhome"
-
-	defaultQueueCapacity = 1024
 )
 
 // ErrBackendNotFound identifies a registry lookup for an unknown backend ID.
 var ErrBackendNotFound = errors.New("backend not found")
 
-var environmentVariableName = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
-
 // Registry is an immutable collection of validated backend definitions.
 type Registry struct {
 	backends map[string]domain.Backend
 }
 
-// NewRegistry constructs a registry containing maintained definitions followed
-// by consumer additions. Every ID must be unique across both groups.
-func NewRegistry(maintained, additions []domain.Backend) (*Registry, error) {
-	registry := &Registry{
-		backends: make(map[string]domain.Backend, len(maintained)+len(additions)),
-	}
-
-	definitions := make([]domain.Backend, 0, len(maintained)+len(additions))
-	definitions = append(definitions, maintained...)
-	definitions = append(definitions, additions...)
-
-	for _, definition := range definitions {
-		definition.ID = strings.TrimSpace(definition.ID)
-		if definition.ID == "" {
-			return nil, errors.New("backend ID must not be blank")
-		}
-		if _, exists := registry.backends[definition.ID]; exists {
-			return nil, fmt.Errorf("backend ID %q is already registered", definition.ID)
-		}
-
-		normalized, err := NormalizeDefinition(definition)
+// NewEffectiveRegistry stores already-validated effective backend definitions
+// under their exact configuration keys. Configuration validation and
+// normalization precede this ownership boundary.
+func NewEffectiveRegistry(definitions map[string]domain.Backend) (*Registry, error) {
+	registry := &Registry{backends: make(map[string]domain.Backend, len(definitions))}
+	for id, definition := range definitions {
+		params, err := jsonvalue.CopyMap(definition.ExtraParams)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("backend %q extra parameters: %w", id, err)
 		}
-		registry.backends[normalized.ID] = normalized
+		definition.ID = id
+		definition.ExtraParams = params
+		registry.backends[id] = definition
 	}
-
 	return registry, nil
 }
 
@@ -100,80 +77,3 @@ func (r *Registry) CapacityPolicies() map[string]domain.BackendCapacityPolicy {
 	}
 	return policies
 }
-
-// NormalizeDefinition validates and defensively copies one backend definition.
-func NormalizeDefinition(definition domain.Backend) (domain.Backend, error) {
-	endpoint, err := domain.NormalizeOpenAICompatibleBaseEndpoint(definition.Endpoint)
-	if err != nil {
-		return domain.Backend{}, fmt.Errorf("backend %q endpoint: %w", definition.ID, err)
-	}
-	definition.Endpoint = endpoint
-
-	definition.APIKeyEnv = strings.TrimSpace(definition.APIKeyEnv)
-	if definition.APIKeyEnv != "" && !environmentVariableName.MatchString(definition.APIKeyEnv) {
-		return domain.Backend{}, fmt.Errorf(
-			"backend %q api key environment variable %q is invalid",
-			definition.ID,
-			definition.APIKeyEnv,
-		)
-	}
-
-	if definition.ConcurrencyLimit < 0 {
-		return domain.Backend{}, fmt.Errorf(
-			"backend %q concurrency limit must not be negative",
-			definition.ID,
-		)
-	}
-	if definition.QueueCapacity < 0 {
-		return domain.Backend{}, fmt.Errorf(
-			"backend %q queue capacity must not be negative",
-			definition.ID,
-		)
-	}
-	if definition.ConcurrencyLimit == 0 {
-		if definition.QueueCapacitySet {
-			return domain.Backend{}, fmt.Errorf(
-				"backend %q queue capacity requires a positive concurrency limit",
-				definition.ID,
-			)
-		}
-		definition.QueueCapacity = 0
-	} else {
-		if !definition.QueueCapacitySet {
-			definition.QueueCapacity = defaultQueueCapacity
-			definition.QueueCapacitySet = true
-		}
-		maxInt := int(^uint(0) >> 1)
-		if definition.QueueCapacity > maxInt-definition.ConcurrencyLimit {
-			return domain.Backend{}, fmt.Errorf(
-				"backend %q total capacity overflows int",
-				definition.ID,
-			)
-		}
-	}
-
-	keys := make([]string, 0, len(definition.ExtraParams))
-	for key := range definition.ExtraParams {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	for _, key := range keys {
-		if key == "" {
-			return domain.Backend{}, fmt.Errorf("backend %q extra parameter key must not be empty", definition.ID)
-		}
-		if llm.IsReservedOpenAIChatRequestField(key) {
-			return domain.Backend{}, fmt.Errorf(
-				"backend %q extra parameter %q collides with a reserved request field",
-				definition.ID,
-				key,
-			)
-		}
-	}
-
-	extraParams, err := jsonvalue.CopyMap(definition.ExtraParams)
-	if err != nil {
-		return domain.Backend{}, fmt.Errorf("backend %q extra parameters: %w", definition.ID, err)
-	}
-	definition.ExtraParams = extraParams
-	return definition, nil
-}

internal/backend/registry_test.go

@@ -3,374 +3,54 @@ package backend_test
 import (
 	"errors"
 	"reflect"
-	"strings"
 	"testing"
 
 	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 )
 
-const validEndpoint = "https://backend.example/v1"
-
-func TestRegistryIncludesMaintainedDefinitions(t *testing.T) {
-	maintained := []domain.Backend{
-		{ID: backend.OpenRouterID, Endpoint: validEndpoint, ConcurrencyLimit: 2, QueueCapacity: 3, QueueCapacitySet: true},
-		{ID: backend.RakestrawHomeID, Endpoint: "https://second.example/v1", ConcurrencyLimit: 4, QueueCapacity: 5, QueueCapacitySet: true},
-	}
-	registry, err := backend.NewRegistry(maintained, nil)
-	if err != nil {
-		t.Fatalf("construct registry: %v", err)
-	}
-
-	for _, expected := range maintained {
-		t.Run(expected.ID, func(t *testing.T) {
-			definition, err := registry.GetBackend(expected.ID)
-			if err != nil {
-				t.Fatalf("look up maintained definition: %v", err)
-			}
-			if !reflect.DeepEqual(definition, expected) {
-				t.Fatalf("unexpected maintained definition: %#v", definition)
-			}
-		})
-	}
-
-	policies := registry.CapacityPolicies()
-	if len(policies) != 2 ||
-		policies[backend.OpenRouterID] != (domain.BackendCapacityPolicy{
-			ConcurrencyLimit: 2,
-			QueueCapacity:    3,
-		}) ||
-		policies[backend.RakestrawHomeID] != (domain.BackendCapacityPolicy{
-			ConcurrencyLimit: 4,
-			QueueCapacity:    5,
-		}) {
-		t.Fatalf("unexpected built-in capacity policies: %#v", policies)
-	}
-}
-
-func TestRegistryNormalizesUniqueAdditionsAndIsolatesMutations(t *testing.T) {
-	nested := map[string]int{"limit": 2}
-	extraParams := map[string]any{
-		"count":  int64(7),
-		"nested": nested,
-	}
-	registry, err := backend.NewRegistry(nil, []domain.Backend{
-		{
-			ID:               " custom ",
-			Endpoint:         " https://custom.example/openai/v1 ",
-			APIKeyEnv:        " CUSTOM_API_KEY ",
-			ExtraParams:      extraParams,
-			ConcurrencyLimit: 3,
-			QueueCapacity:    2,
-			QueueCapacitySet: true,
-		},
-		{
-			ID:       "Custom",
-			Endpoint: validEndpoint,
+func TestEffectiveRegistryOwnsDefinitionsAndCapacityPolicies(t *testing.T) {
+	params := map[string]any{"nested": map[string]any{"enabled": true}}
+	registry, err := backend.NewEffectiveRegistry(map[string]domain.Backend{
+		" local.v1 ": {
+			Endpoint: "https://backend.example/v1", ExtraParams: params,
+			ConcurrencyLimit: 2, QueueCapacity: 3, QueueCapacitySet: true,
 		},
 	})
 	if err != nil {
-		t.Fatalf("construct registry: %v", err)
+		t.Fatal(err)
 	}
-
-	nested["limit"] = 99
-	extraParams["added"] = true
-
-	got, err := registry.GetBackend("custom")
-	if err != nil {
-		t.Fatalf("look up custom backend: %v", err)
+	params["nested"].(map[string]any)["enabled"] = false
+	selected, err := registry.GetBackend(" local.v1 ")
+	if err != nil || selected.ID != " local.v1 " || selected.ExtraParams["nested"].(map[string]any)["enabled"] != true {
+		t.Fatalf("effective backend was not captured under its literal ID: %+v, %v", selected, err)
 	}
-	if got.ID != "custom" ||
-		got.Endpoint != "https://custom.example/openai/v1" ||
-		got.APIKeyEnv != "CUSTOM_API_KEY" ||
-		got.ConcurrencyLimit != 3 ||
-		got.QueueCapacity != 2 ||
-		!got.QueueCapacitySet {
-		t.Fatalf("unexpected normalized definition: %#v", got)
+	selected.ExtraParams["nested"].(map[string]any)["enabled"] = false
+	again, err := registry.GetBackend(" local.v1 ")
+	if err != nil || again.ExtraParams["nested"].(map[string]any)["enabled"] != true {
+		t.Fatalf("lookup exposed registry values: %+v, %v", again, err)
 	}
-	if count, ok := got.ExtraParams["count"].(int64); !ok || count != 7 {
-		t.Fatalf("integer type or value changed: %#v", got.ExtraParams["count"])
-	}
-	gotNested, ok := got.ExtraParams["nested"].(map[string]int)
-	if !ok || gotNested["limit"] != 2 {
-		t.Fatalf("container type or value changed: %#v", got.ExtraParams["nested"])
-	}
-	if _, exists := got.ExtraParams["added"]; exists {
-		t.Fatalf("registry retained caller map: %#v", got.ExtraParams)
-	}
-
-	gotNested["limit"] = 100
-	got.ExtraParams["added"] = true
-	again, err := registry.GetBackend("custom")
-	if err != nil {
-		t.Fatalf("look up custom backend again: %v", err)
-	}
-	if again.ExtraParams["nested"].(map[string]int)["limit"] != 2 {
-		t.Fatalf("lookup exposed registry nested map: %#v", again.ExtraParams)
-	}
-	if _, exists := again.ExtraParams["added"]; exists {
-		t.Fatalf("lookup exposed registry map: %#v", again.ExtraParams)
-	}
-
-	if _, err := registry.GetBackend("Custom"); err != nil {
-		t.Fatalf("backend IDs should be case-sensitive: %v", err)
-	}
-
 	policies := registry.CapacityPolicies()
-	if len(policies) != 1 {
-		t.Fatalf("unexpected capacity policy count: %#v", policies)
-	}
-	policies["custom"] = domain.BackendCapacityPolicy{}
-	delete(policies, "custom")
-	againPolicies := registry.CapacityPolicies()
-	if againPolicies["custom"] != (domain.BackendCapacityPolicy{
-		ConcurrencyLimit: 3,
-		QueueCapacity:    2,
+	if !reflect.DeepEqual(policies, map[string]domain.BackendCapacityPolicy{
+		" local.v1 ": {ConcurrencyLimit: 2, QueueCapacity: 3},
 	}) {
-		t.Fatalf("capacity policy map mutated registry state: %#v", againPolicies)
+		t.Fatalf("capacity policy = %+v", policies)
+	}
+	delete(policies, " local.v1 ")
+	if len(registry.CapacityPolicies()) != 1 {
+		t.Fatal("capacity policy map exposed registry state")
 	}
 }
 
-func TestNewRegistryNormalizesCapacityPolicy(t *testing.T) {
-	maxInt := int(^uint(0) >> 1)
-	tests := []struct {
-		name       string
-		definition domain.Backend
-		want       domain.BackendCapacityPolicy
-		wantSet    bool
-		wantError  bool
-	}{
-		{
-			name:       "unlimited when omitted",
-			definition: domain.Backend{},
-		},
-		{
-			name: "default queue",
-			definition: domain.Backend{
-				ConcurrencyLimit: 2,
-			},
-			want: domain.BackendCapacityPolicy{
-				ConcurrencyLimit: 2,
-				QueueCapacity:    1024,
-			},
-			wantSet: true,
-		},
-		{
-			name: "explicit zero queue",
-			definition: domain.Backend{
-				ConcurrencyLimit: 2,
-				QueueCapacitySet: true,
-			},
-			want: domain.BackendCapacityPolicy{
-				ConcurrencyLimit: 2,
-			},
-			wantSet: true,
-		},
-		{
-			name: "negative concurrency limit",
-			definition: domain.Backend{
-				ConcurrencyLimit: -1,
-			},
-			wantError: true,
-		},
-		{
-			name: "negative queue capacity",
-			definition: domain.Backend{
-				ConcurrencyLimit: 1,
-				QueueCapacity:    -1,
-				QueueCapacitySet: true,
-			},
-			wantError: true,
-		},
-		{
-			name: "queue without limit",
-			definition: domain.Backend{
-				QueueCapacitySet: true,
-			},
-			wantError: true,
-		},
-		{
-			name: "total overflow",
-			definition: domain.Backend{
-				ConcurrencyLimit: maxInt,
-				QueueCapacity:    1,
-				QueueCapacitySet: true,
-			},
-			wantError: true,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			tc.definition.ID = "custom"
-			tc.definition.Endpoint = validEndpoint
-			registry, err := backend.NewRegistry(nil, []domain.Backend{tc.definition})
-			if tc.wantError {
-				if err == nil {
-					t.Fatal("expected invalid capacity policy error")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("construct registry: %v", err)
-			}
-
-			definition, err := registry.GetBackend("custom")
-			if err != nil {
-				t.Fatalf("look up custom backend: %v", err)
-			}
-			if definition.ConcurrencyLimit != tc.want.ConcurrencyLimit ||
-				definition.QueueCapacity != tc.want.QueueCapacity ||
-				definition.QueueCapacitySet != tc.wantSet {
-				t.Fatalf("normalized capacity=(%d, %d, %t), want (%d, %d, %t)",
-					definition.ConcurrencyLimit,
-					definition.QueueCapacity,
-					definition.QueueCapacitySet,
-					tc.want.ConcurrencyLimit,
-					tc.want.QueueCapacity,
-					tc.wantSet,
-				)
-			}
-			policies := registry.CapacityPolicies()
-			got, ok := policies["custom"]
-			if ok != tc.wantSet || got != tc.want {
-				t.Fatalf("capacity policy=(%#v, %t), want (%#v, %t)", got, ok, tc.want, tc.wantSet)
-			}
-		})
-	}
-}
-
-func TestNewRegistryRejectsDuplicateIDs(t *testing.T) {
-	tests := []struct {
-		name      string
-		additions []domain.Backend
-		wantID    string
-	}{
-		{
-			name:      "OpenRouter collision after normalization",
-			additions: []domain.Backend{{ID: " openrouter "}},
-			wantID:    backend.OpenRouterID,
-		},
-		{
-			name:      "Rakestrawhome collision after normalization",
-			additions: []domain.Backend{{ID: " rakestrawhome "}},
-			wantID:    backend.RakestrawHomeID,
-		},
-		{
-			name: "consumer collision after normalization",
-			additions: []domain.Backend{
-				{ID: "custom", Endpoint: validEndpoint},
-				{ID: " custom ", Endpoint: "https://other.example/v1"},
-			},
-			wantID: "custom",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := backend.NewRegistry(nil, tc.additions)
-			if err == nil {
-				t.Fatal("expected duplicate ID error")
-			}
-			if !strings.Contains(err.Error(), tc.wantID) {
-				t.Fatalf("expected error to identify %q, got %v", tc.wantID, err)
-			}
-		})
-	}
-}
-
-func TestNewRegistryValidatesIDs(t *testing.T) {
-	for _, id := range []string{"", " \t\n "} {
-		t.Run(id, func(t *testing.T) {
-			_, err := backend.NewRegistry(nil, []domain.Backend{{
-				ID:       id,
-				Endpoint: validEndpoint,
-			}})
-			if err == nil {
-				t.Fatal("expected blank ID error")
-			}
-		})
-	}
-}
-
-func TestNewRegistryValidatesEndpoints(t *testing.T) {
-	tests := []struct {
-		name     string
-		endpoint string
-	}{
-		{name: "blank", endpoint: ""},
-		{name: "relative", endpoint: "/v1"},
-		{name: "missing host", endpoint: "https:///v1"},
-		{name: "unsupported scheme", endpoint: "ftp://backend.example/v1"},
-		{name: "user information", endpoint: "https://user@backend.example/v1"},
-		{name: "query", endpoint: "https://backend.example/v1?mode=chat"},
-		{name: "empty query", endpoint: "https://backend.example/v1?"},
-		{name: "fragment", endpoint: "https://backend.example/v1#chat"},
-		{name: "empty fragment", endpoint: "https://backend.example/v1#"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := backend.NewRegistry(nil, []domain.Backend{{
-				ID:       "custom",
-				Endpoint: tc.endpoint,
-			}})
-			if err == nil {
-				t.Fatal("expected invalid endpoint error")
-			}
-		})
-	}
-}
-
-func TestNewRegistryValidatesEnvironmentVariableNames(t *testing.T) {
-	for _, name := range []string{"1API_KEY", "API-KEY", "API KEY", "ÅPI_KEY"} {
-		t.Run(name, func(t *testing.T) {
-			_, err := backend.NewRegistry(nil, []domain.Backend{{
-				ID:        "custom",
-				Endpoint:  validEndpoint,
-				APIKeyEnv: name,
-			}})
-			if err == nil {
-				t.Fatal("expected invalid environment-variable name error")
-			}
-		})
-	}
-}
-
-func TestNewRegistryRejectsInvalidAndReservedExtraParameters(t *testing.T) {
-	tests := []struct {
-		name        string
-		extraParams map[string]any
-	}{
-		{name: "unsupported value", extraParams: map[string]any{"value": make(chan int)}},
-		{name: "reserved key", extraParams: map[string]any{"model": "override"}},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := backend.NewRegistry(nil, []domain.Backend{{
-				ID:          "custom",
-				Endpoint:    validEndpoint,
-				ExtraParams: tc.extraParams,
-			}})
-			if err == nil {
-				t.Fatal("expected invalid extra parameters error")
-			}
-		})
-	}
-}
-
-func TestRegistryLookupReportsNotFound(t *testing.T) {
-	registry, err := backend.NewRegistry(nil, nil)
+func TestEffectiveRegistryMissingBackend(t *testing.T) {
+	registry, err := backend.NewEffectiveRegistry(nil)
 	if err != nil {
-		t.Fatalf("construct registry: %v", err)
+		t.Fatal(err)
 	}
-
-	_, err = registry.GetBackend("missing")
-	if !errors.Is(err, backend.ErrBackendNotFound) {
-		t.Fatalf("expected ErrBackendNotFound, got %v", err)
+	if _, err := registry.GetBackend("missing"); !errors.Is(err, backend.ErrBackendNotFound) {
+		t.Fatalf("missing backend error = %v", err)
 	}
-	if !strings.Contains(err.Error(), "missing") {
-		t.Fatalf("expected error to identify backend, got %v", err)
+	if _, err := registry.GetBackend("local.v1"); !errors.Is(err, backend.ErrBackendNotFound) {
+		t.Fatalf("trimmed lookup unexpectedly matched: %v", err)
 	}
 }

internal/catalog/catalog.go

@@ -1,249 +1,52 @@
-// Package catalog validates immutable maintained backend catalog assets.
+// Package catalog selects the maintained configuration assets supplied with
+// PromptKit. ConfigKit owns their composition and effective validation.
 package catalog
 
 import (
-	"bytes"
 	"context"
-	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"io/fs"
-	"path"
-	"sort"
-	"strings"
 
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	openrouter "gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v3"
+	rakestrawhome "gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v3"
 	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/profile"
+	"gitea.maximumdirect.net/eric/promptkit/internal/filecatalog"
 )
 
-// Source identifies one immutable backend catalog asset tree.
-type Source struct {
-	Name              string
-	ExpectedBackendID string
-	FS                fs.FS
-	Root              string
-}
-
-// Set is the validated maintained backend and raw profile catalog.
-type Set struct {
-	Backends   []domain.Backend
-	Profiles   profile.Repository
-	profileIDs []string
-}
-
-// Load validates and combines immutable catalog sources in source order.
-func Load(sources ...Source) (Set, error) {
-	if len(sources) == 0 {
-		return Set{}, errors.New("at least one catalog source is required")
-	}
-	loaded := Set{Backends: make([]domain.Backend, 0, len(sources))}
-	names := map[string]bool{}
-	backendIDs := map[string]bool{}
-	profileIDs := map[string]bool{}
-	for _, source := range sources {
-		if err := validateSource(source, names); err != nil {
-			return Set{}, err
-		}
-		names[source.Name] = true
-		definition, err := loadBackend(source)
-		if err != nil {
-			return Set{}, err
-		}
-		if backendIDs[definition.ID] {
-			return Set{}, fmt.Errorf("catalog %s: backend ID duplicates an earlier catalog", source.Name)
-		}
-		backendIDs[definition.ID] = true
-		repository, metadata, err := profile.LoadFSRepository(context.Background(), source.FS, path.Join(source.Root, "profiles"))
-		if err != nil {
-			return Set{}, fmt.Errorf("catalog %s: %w", source.Name, err)
-		}
-		if len(metadata) == 0 {
-			return Set{}, fmt.Errorf("catalog %s: profiles must not be empty", source.Name)
-		}
-		resolvingRepository := profile.NewResolvingRepository(repository)
-		for _, entry := range metadata {
-			if strings.HasPrefix(entry.ID, "promptkit-") {
-				return Set{}, fmt.Errorf("catalog %s: %s uses the reserved promptkit- profile ID prefix", source.Name, entry.Path)
-			}
-			if profileIDs[entry.ID] {
-				return Set{}, fmt.Errorf("catalog %s: %s duplicates an earlier profile ID", source.Name, entry.Path)
-			}
-			if containsField(entry.ExplicitFields, "endpoint") || containsField(entry.ExplicitFields, "api_key_env") {
-				return Set{}, fmt.Errorf("catalog %s: %s contains connection metadata", source.Name, entry.Path)
-			}
-			value, err := repository.GetProfile(context.Background(), entry.ID)
-			if err != nil {
-				return Set{}, fmt.Errorf("catalog %s: %s: %w", source.Name, entry.Path, err)
-			}
-			if err := rejectSecretKeys(value.ExtraParams); err != nil {
-				return Set{}, fmt.Errorf("catalog %s: %s: prohibited extra parameter key", source.Name, entry.Path)
-			}
-			resolved, err := resolvingRepository.GetProfile(context.Background(), entry.ID)
-			if err != nil {
-				return Set{}, fmt.Errorf("catalog %s: %s has invalid profile inheritance", source.Name, entry.Path)
-			}
-			if resolved.BackendID != definition.ID {
-				return Set{}, fmt.Errorf("catalog %s: %s selects a different backend", source.Name, entry.Path)
-			}
-			profileIDs[entry.ID] = true
-			loaded.profileIDs = append(loaded.profileIDs, entry.ID)
-		}
-		if loaded.Profiles == nil {
-			loaded.Profiles = repository
-		} else {
-			loaded.Profiles = profile.NewOverlayRepository(loaded.Profiles, repository)
-		}
-		loaded.Backends = append(loaded.Backends, definition)
-	}
-	sort.Strings(loaded.profileIDs)
-	return loaded, nil
-}
-
-func validateSource(source Source, names map[string]bool) error {
-	if strings.TrimSpace(source.Name) == "" || source.Name != strings.TrimSpace(source.Name) {
-		return errors.New("catalog source name must not be blank")
-	}
-	if names[source.Name] {
-		return fmt.Errorf("duplicate catalog source name %q", source.Name)
-	}
-	if source.FS == nil {
-		return fmt.Errorf("catalog %s: filesystem is nil", source.Name)
-	}
-	if source.Root == "." || source.Root == "" || !fs.ValidPath(source.Root) {
-		return fmt.Errorf("catalog %s: asset root is invalid", source.Name)
-	}
-	if strings.TrimSpace(source.ExpectedBackendID) == "" {
-		return fmt.Errorf("catalog %s: expected backend ID is blank", source.Name)
-	}
-	return validateLayout(source)
-}
-
-func validateLayout(source Source) error {
-	manifestPath := path.Join(source.Root, "backend.json")
-	profilesRoot := path.Join(source.Root, "profiles")
-	return fs.WalkDir(source.FS, source.Root, func(assetPath string, entry fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if assetPath == source.Root {
-			if !entry.IsDir() {
-				return fmt.Errorf("catalog %s: invalid asset path %s", source.Name, assetPath)
-			}
-			return nil
-		}
-		if entry.IsDir() {
-			if assetPath == profilesRoot || strings.HasPrefix(assetPath, profilesRoot+"/") {
-				return nil
-			}
-			return fmt.Errorf("catalog %s: invalid asset path %s", source.Name, assetPath)
-		}
-		if assetPath == manifestPath && entry.Type().IsRegular() {
-			return nil
-		}
-		if strings.HasPrefix(assetPath, profilesRoot+"/") && entry.Type().IsRegular() && strings.HasSuffix(assetPath, ".yml") {
-			return nil
-		}
-		return fmt.Errorf("catalog %s: invalid asset path %s", source.Name, assetPath)
-	})
-}
-
-func loadBackend(source Source) (domain.Backend, error) {
-	data, err := fs.ReadFile(source.FS, path.Join(source.Root, "backend.json"))
+// Underlays selects external catalogs followed by PromptKit-owned profiles.
+// Neither group is interpreted before the final effective configuration loads.
+func Underlays() ([]configkit.Underlay, error) {
+	openrouterInputs, err := assetInputs("OpenRouter catalog", openrouter.FS(), openrouter.Root)
 	if err != nil {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: %w", source.Name, err)
+		return nil, err
 	}
-	type manifest struct {
-		SchemaVersion    *int            `json:"schema_version"`
-		ID               *string         `json:"id"`
-		Endpoint         *string         `json:"endpoint"`
-		APIKeyEnv        *string         `json:"api_key_env"`
-		ConcurrencyLimit *int            `json:"concurrency_limit"`
-		QueueCapacity    *int            `json:"queue_capacity"`
-		ExtraParams      json.RawMessage `json:"extra_params"`
-	}
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	decoder.DisallowUnknownFields()
-	var value manifest
-	if err := decoder.Decode(&value); err != nil {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: invalid manifest", source.Name)
-	}
-	var trailing any
-	if err := decoder.Decode(&trailing); !errors.Is(err, io.EOF) {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: invalid manifest", source.Name)
-	}
-	if value.SchemaVersion == nil || *value.SchemaVersion != 1 || value.ID == nil || value.Endpoint == nil || value.APIKeyEnv == nil || value.ConcurrencyLimit == nil || value.QueueCapacity == nil || value.ExtraParams == nil {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: required field is missing or unsupported", source.Name)
-	}
-	if *value.ID != source.ExpectedBackendID {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend ID does not match expected ID", source.Name)
-	}
-	if strings.TrimSpace(*value.APIKeyEnv) == "" {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: api key environment variable must not be blank", source.Name)
-	}
-	extraParams, err := decodeExtraParams(value.ExtraParams)
+	rakestrawhomeInputs, err := assetInputs("Rakestrawhome catalog", rakestrawhome.FS(), rakestrawhome.Root)
 	if err != nil {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: invalid extra parameters", source.Name)
+		return nil, err
 	}
-	if err := rejectSecretKeys(extraParams); err != nil {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: prohibited extra parameter key", source.Name)
-	}
-	normalized, err := backend.NormalizeDefinition(domain.Backend{ID: *value.ID, Endpoint: *value.Endpoint, APIKeyEnv: *value.APIKeyEnv, ExtraParams: extraParams, ConcurrencyLimit: *value.ConcurrencyLimit, QueueCapacity: *value.QueueCapacity, QueueCapacitySet: true})
+	catalogInputs := append(openrouterInputs, rakestrawhomeInputs...)
+	owned := configkit.Input{Source: configkit.Mapping("PromptKit-owned profiles", map[string]any{
+		"profiles": map[string]any{
+			"promptkit-openrouter-standard": map[string]any{"extends": "gemini-flash-latest"},
+			"promptkit-openrouter-auto":     map[string]any{"backend": backend.OpenRouterID, "model": "openrouter/auto"},
+		},
+	})}
+	return []configkit.Underlay{{Inputs: catalogInputs}, {Inputs: []configkit.Input{owned}}}, nil
+}
+
+func assetInputs(label string, filesystem fs.FS, root string) ([]configkit.Input, error) {
+	files, err := filecatalog.FindFSYAMLFiles(context.Background(), filesystem, root)
 	if err != nil {
-		return domain.Backend{}, fmt.Errorf("catalog %s: backend.json: invalid backend definition", source.Name)
+		return nil, fmt.Errorf("discover %s configuration: %w", label, err)
 	}
-	return normalized, nil
-}
-
-func decodeExtraParams(data []byte) (map[string]any, error) {
-	if bytes.Equal(bytes.TrimSpace(data), []byte("null")) {
-		return nil, nil
-	}
-	decoder := json.NewDecoder(bytes.NewReader(data))
-	decoder.UseNumber()
-	var value map[string]any
-	if err := decoder.Decode(&value); err != nil || value == nil {
-		return nil, errors.New("extra parameters must be an object or null")
-	}
-	var trailing any
-	if err := decoder.Decode(&trailing); !errors.Is(err, io.EOF) {
-		return nil, errors.New("extra parameters must contain exactly one JSON value")
-	}
-	return value, nil
-}
-
-func containsField(fields []string, target string) bool {
-	for _, field := range fields {
-		if field == target {
-			return true
-		}
-	}
-	return false
-}
-
-func rejectSecretKeys(value map[string]any) error {
-	return rejectSecretValue(value)
-}
-
-func rejectSecretValue(value any) error {
-	switch value := value.(type) {
-	case map[string]any:
-		for key, child := range value {
-			switch strings.ToLower(key) {
-			case "api_key", "apikey", "authorization", "credential", "credentials", "password", "secret", "token", "access_token":
-				return errors.New("prohibited key")
-			}
-			if err := rejectSecretValue(child); err != nil {
-				return err
-			}
-		}
-	case []any:
-		for _, child := range value {
-			if err := rejectSecretValue(child); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+	namespace := configkit.NewFilesystem(label, filesystem)
+	inputs := make([]configkit.Input, 0, len(files))
+	for _, name := range files {
+		inputs = append(inputs, configkit.Input{
+			Source:     namespace.File(name),
+			Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: root},
+		})
+	}
+	return inputs, nil
 }

internal/catalog/catalog_test.go

@@ -2,355 +2,67 @@ package catalog
 
 import (
 	"context"
-	"encoding/json"
-	"fmt"
-	"io/fs"
-	"strings"
+	"errors"
 	"testing"
-	"testing/fstest"
 
-	openrouter "gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2"
-	rakestrawhome "gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2"
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/configuration"
 )
 
-func TestLoadPublishedCatalogs(t *testing.T) {
-	loaded, err := Load(
-		Source{Name: "OpenRouter", ExpectedBackendID: "openrouter", FS: openrouter.FS(), Root: openrouter.Root},
-		Source{Name: "Rakestrawhome", ExpectedBackendID: "rakestrawhome", FS: rakestrawhome.FS(), Root: rakestrawhome.Root},
-	)
+func TestPublishedCatalogsResolveThroughEffectiveConfiguration(t *testing.T) {
+	underlays, err := Underlays()
 	if err != nil {
-		t.Fatalf("load published catalogs: %v", err)
+		t.Fatal(err)
 	}
-	if loaded.Profiles == nil || len(loaded.profileIDs) == 0 {
-		t.Fatalf("published catalogs have no usable profiles: %#v", loaded)
+	state, err := configuration.Load(configkit.Input{Source: configkit.NoSource()}, underlays)
+	if err != nil {
+		t.Fatal(err)
 	}
-	if _, err := loaded.Profiles.GetProfile(context.Background(), "gemini-flash-latest"); err != nil {
-		t.Fatalf("load maintained standard-profile base: %v", err)
+	openrouter, err := state.GetBackend("openrouter")
+	if err != nil || openrouter.Endpoint != "https://openrouter.ai/api/v1" || openrouter.ConcurrencyLimit != 16 || openrouter.QueueCapacity != 1024 {
+		t.Fatalf("OpenRouter backend: %+v, %v", openrouter, err)
 	}
-
-	expectedBackends := map[string]struct {
-		endpoint         string
-		apiKeyEnv        string
-		concurrencyLimit int
-		queueCapacity    int
-	}{
-		"openrouter": {
-			endpoint:         "https://openrouter.ai/api/v1",
-			apiKeyEnv:        "OPENROUTER_API_KEY",
-			concurrencyLimit: 16,
-			queueCapacity:    1024,
-		},
-		"rakestrawhome": {
-			endpoint:         "https://inference.ai.rakestrawhome.com/v1",
-			apiKeyEnv:        "RAKESTRAWHOME_INFERENCE_API_KEY",
-			concurrencyLimit: 4,
-			queueCapacity:    1024,
-		},
+	rakestrawhome, err := state.GetBackend("rakestrawhome")
+	if err != nil || rakestrawhome.Endpoint != "https://inference.ai.rakestrawhome.com/v1" || rakestrawhome.ConcurrencyLimit != 4 {
+		t.Fatalf("Rakestrawhome backend: %+v, %v", rakestrawhome, err)
 	}
-	if len(loaded.Backends) != len(expectedBackends) {
-		t.Fatalf("published backend count = %d, want %d", len(loaded.Backends), len(expectedBackends))
-	}
-	for _, definition := range loaded.Backends {
-		expected, found := expectedBackends[definition.ID]
-		if !found {
-			t.Fatalf("unexpected published backend %q", definition.ID)
-		}
-		if definition.Endpoint != expected.endpoint ||
-			definition.APIKeyEnv != expected.apiKeyEnv ||
-			definition.ConcurrencyLimit != expected.concurrencyLimit ||
-			definition.QueueCapacity != expected.queueCapacity ||
-			!definition.QueueCapacitySet ||
-			definition.ExtraParams != nil {
-			t.Fatalf("unexpected published backend definition: %#v", definition)
-		}
-	}
-}
-
-func TestLoadRejectsInvalidSources(t *testing.T) {
-	for name, sources := range map[string][]Source{
-		"none":       nil,
-		"blank name": {{Name: " ", ExpectedBackendID: "openrouter", FS: openrouter.FS(), Root: openrouter.Root}},
-		"duplicate name": {
-			{Name: "same", ExpectedBackendID: "openrouter", FS: openrouter.FS(), Root: openrouter.Root},
-			{Name: "same", ExpectedBackendID: "rakestrawhome", FS: rakestrawhome.FS(), Root: rakestrawhome.Root},
-		},
-		"nil filesystem":         {{Name: "missing", ExpectedBackendID: "openrouter", Root: openrouter.Root}},
-		"invalid root":           {{Name: "invalid-root", ExpectedBackendID: "openrouter", FS: openrouter.FS(), Root: "."}},
-		"blank expected backend": {{Name: "blank-backend", ExpectedBackendID: " ", FS: openrouter.FS(), Root: openrouter.Root}},
+	for id, want := range map[string]string{
+		"promptkit-openrouter-standard": "~google/gemini-flash-latest",
+		"promptkit-openrouter-auto":     "openrouter/auto",
+		"rakestrawhome-gemma-4-31b":     "google/gemma-4-31b-it",
 	} {
-		t.Run(name, func(t *testing.T) {
-			if _, err := Load(sources...); err == nil {
-				t.Fatal("expected error")
-			}
-		})
-	}
-}
-
-func TestLoadRejectsInvalidLayouts(t *testing.T) {
-	tests := map[string]func(fstest.MapFS){
-		"unexpected file": func(fsys fstest.MapFS) {
-			fsys["catalog/notes.txt"] = &fstest.MapFile{Data: []byte("unexpected")}
-		},
-		"unexpected directory": func(fsys fstest.MapFS) {
-			fsys["catalog/unexpected"] = &fstest.MapFile{Mode: fs.ModeDir}
-		},
-		"nonregular manifest": func(fsys fstest.MapFS) {
-			fsys["catalog/backend.json"].Mode = fs.ModeSymlink
-		},
-		"wrong profile extension": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/extra.yaml"] = &fstest.MapFile{Data: []byte(validProfile("extra", "one"))}
-		},
-		"nonregular profile": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Mode = fs.ModeSymlink
-		},
-	}
-	for name, mutate := range tests {
-		t.Run(name, func(t *testing.T) {
-			fsys := validCatalogFS("one")
-			mutate(fsys)
-			if _, err := Load(testSource("one", fsys)); err == nil {
-				t.Fatal("expected invalid layout error")
-			}
-		})
-	}
-}
-
-func TestLoadRejectsInvalidManifests(t *testing.T) {
-	tests := map[string]string{
-		"malformed":             `{`,
-		"trailing value":        validManifest("one", "TEST_API_KEY", "null") + `{}`,
-		"missing fields":        `{"schema_version":1,"id":"one"}`,
-		"unsupported version":   strings.Replace(validManifest("one", "TEST_API_KEY", "null"), `"schema_version":1`, `"schema_version":2`, 1),
-		"unknown field":         strings.Replace(validManifest("one", "TEST_API_KEY", "null"), `"extra_params":null`, `"extra_params":null,"unknown":true`, 1),
-		"blank API key env":     validManifest("one", "   ", "null"),
-		"invalid API key env":   validManifest("one", "LEAK-MARKER", "null"),
-		"invalid endpoint":      strings.Replace(validManifest("one", "TEST_API_KEY", "null"), `https://one.example/v1`, `ftp://leak-marker.invalid/v1`, 1),
-		"zero concurrency":      strings.Replace(validManifest("one", "TEST_API_KEY", "null"), `"concurrency_limit":2`, `"concurrency_limit":0`, 1),
-		"non-object parameters": validManifest("one", "TEST_API_KEY", `[]`),
-		"secret parameter":      validManifest("one", "TEST_API_KEY", `{"nested":{"token":"leak-marker"}}`),
-	}
-	for name, manifest := range tests {
-		t.Run(name, func(t *testing.T) {
-			fsys := validCatalogFS("one")
-			fsys["catalog/backend.json"].Data = []byte(manifest)
-			_, err := Load(testSource("one", fsys))
-			if err == nil {
-				t.Fatal("expected invalid manifest error")
-			}
-			if strings.Contains(strings.ToLower(err.Error()), "leak-marker") {
-				t.Fatalf("catalog error exposed manifest content: %v", err)
-			}
-		})
-	}
-}
-
-func TestLoadPreservesManifestJSONNumbers(t *testing.T) {
-	fsys := validCatalogFS("one")
-	fsys["catalog/backend.json"].Data = []byte(validManifest(
-		"one",
-		"TEST_API_KEY",
-		`{"large":9007199254740993,"nested":[1.25]}`,
-	))
-	loaded, err := Load(testSource("one", fsys))
-	if err != nil {
-		t.Fatalf("load catalog: %v", err)
-	}
-	if got := loaded.Backends[0].ExtraParams["large"]; got != json.Number("9007199254740993") {
-		t.Fatalf("large JSON integer = %#v, want preserved json.Number", got)
-	}
-	nested := loaded.Backends[0].ExtraParams["nested"].([]any)
-	if nested[0] != json.Number("1.25") {
-		t.Fatalf("nested JSON number = %#v, want preserved json.Number", nested[0])
-	}
-}
-
-func TestLoadRejectsInvalidCatalogProfiles(t *testing.T) {
-	tests := map[string]func(fstest.MapFS){
-		"empty": func(fsys fstest.MapFS) {
-			delete(fsys, "catalog/profiles/one-profile.yml")
-			fsys["catalog/profiles"] = &fstest.MapFile{Mode: fs.ModeDir}
-		},
-		"malformed": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte("id: [")
-		},
-		"raw API key": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile("one-profile", "one") + "api_key: leak-marker\n")
-		},
-		"endpoint field": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile("one-profile", "one") + "endpoint: ''\n")
-		},
-		"API key environment field": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile("one-profile", "one") + "api_key_env: ''\n")
-		},
-		"owner mismatch": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile("one-profile", "other"))
-		},
-		"missing base": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte("id: one-profile\nbase_profile: leak-marker\n")
-		},
-		"cyclic base": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte("id: one-profile\nbase_profile: second\n")
-			fsys["catalog/profiles/second.yml"] = &fstest.MapFile{Data: []byte("id: second\nbase_profile: one-profile\n")}
-		},
-		"secret profile parameter": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile("one-profile", "one") + "extra_params:\n  nested:\n    password: leak-marker\n")
-		},
-		"unknown field is redacted": func(fsys fstest.MapFS) {
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile("one-profile", "one") + "leak_marker: leak-marker\n")
-		},
-	}
-	for name, mutate := range tests {
-		t.Run(name, func(t *testing.T) {
-			fsys := validCatalogFS("one")
-			mutate(fsys)
-			_, err := Load(testSource("one", fsys))
-			if err == nil {
-				t.Fatal("expected invalid profile error")
-			}
-			if strings.Contains(strings.ToLower(err.Error()), "leak-marker") {
-				t.Fatalf("catalog error exposed profile content: %v", err)
-			}
-		})
-	}
-}
-
-func TestLoadReservesPromptkitProfilePrefixForCatalogs(t *testing.T) {
-	tests := map[string]struct {
-		profileID string
-		wantError bool
-	}{
-		"maintained name": {
-			profileID: "promptkit-openrouter-standard",
-			wantError: true,
-		},
-		"other reserved name": {
-			profileID: "promptkit-example",
-			wantError: true,
-		},
-		"ordinary name": {
-			profileID: "ordinary-profile",
-		},
-	}
-	for name, test := range tests {
-		t.Run(name, func(t *testing.T) {
-			fsys := validCatalogFS("one")
-			fsys["catalog/profiles/one-profile.yml"].Data = []byte(validProfile(test.profileID, "one"))
-
-			_, err := Load(testSource("one", fsys))
-			if (err != nil) != test.wantError {
-				t.Fatalf("Load() error = %v, want error %t", err, test.wantError)
-			}
-			if err != nil && !strings.Contains(err.Error(), "catalog one: one-profile.yml") {
-				t.Fatalf("Load() error = %v, want catalog source and path context", err)
-			}
-		})
-	}
-}
-
-func TestLoadRejectsCrossCatalogConflicts(t *testing.T) {
-	t.Run("duplicate backend", func(t *testing.T) {
-		second := catalogFS("one", map[string]string{
-			"catalog/profiles/second.yml": validProfile("second", "one"),
-		}, "null")
-		_, err := Load(
-			Source{Name: "first", ExpectedBackendID: "one", FS: validCatalogFS("one"), Root: "catalog"},
-			Source{Name: "second", ExpectedBackendID: "one", FS: second, Root: "catalog"},
-		)
-		if err == nil {
-			t.Fatal("expected duplicate backend error")
+		profile, err := state.GetProfile(context.Background(), id)
+		if err != nil || profile.ResolvedTarget.Model != want {
+			t.Fatalf("profile %s: %+v, %v", id, profile, err)
 		}
-	})
-
-	t.Run("duplicate profile", func(t *testing.T) {
-		first := catalogFS("one", map[string]string{
-			"catalog/profiles/shared.yml": validProfile("shared", "one"),
-		}, "null")
-		second := catalogFS("two", map[string]string{
-			"catalog/profiles/shared.yml": validProfile("shared", "two"),
-		}, "null")
-		_, err := Load(testSource("one", first), testSource("two", second))
-		if err == nil {
-			t.Fatal("expected duplicate profile error")
-		}
-	})
-
-	t.Run("cross-catalog base", func(t *testing.T) {
-		first := catalogFS("one", map[string]string{
-			"catalog/profiles/base.yml": validProfile("base", "one"),
-		}, "null")
-		second := catalogFS("two", map[string]string{
-			"catalog/profiles/child.yml": "id: child\nbase_profile: base\n",
-		}, "null")
-		_, err := Load(testSource("one", first), testSource("two", second))
-		if err == nil {
-			t.Fatal("expected cross-catalog base error")
-		}
-	})
+	}
 }
 
-func TestLoadReturnsDefensiveCatalogValues(t *testing.T) {
-	fsys := catalogFS("one", map[string]string{
-		"catalog/profiles/one-profile.yml": validProfile("one-profile", "one") + "extra_params:\n  nested:\n    value: profile\n",
-	}, `{"nested":{"value":"backend"}}`)
-	loaded, err := Load(testSource("one", fsys))
+func TestConsumerOverlayReplacesCatalogDefaultsBeforeValidation(t *testing.T) {
+	underlays, err := Underlays()
 	if err != nil {
-		t.Fatalf("load catalog: %v", err)
+		t.Fatal(err)
 	}
-	loaded.Backends[0].ExtraParams["nested"].(map[string]any)["value"] = "changed"
-	profileValue, err := loaded.Profiles.GetProfile(context.Background(), "one-profile")
+	underlays = append(underlays, configkit.Underlay{Inputs: []configkit.Input{{Source: configkit.Mapping("operator", map[string]any{
+		"backends": map[string]any{"openrouter": map[string]any{"endpoint": "invalid lower value"}},
+	})}}})
+	main := configkit.Input{Source: configkit.Mapping("application", map[string]any{
+		"backends": map[string]any{"openrouter": map[string]any{"endpoint": "https://alternate.example/v1"}},
+		"profiles": map[string]any{"gemini-flash-latest": map[string]any{"model": "consumer-model"}},
+	})}
+	state, err := configuration.Load(main, underlays)
 	if err != nil {
-		t.Fatalf("load profile: %v", err)
+		t.Fatalf("replaced lower-layer value failed final validation: %v", err)
 	}
-	profileValue.ExtraParams["nested"].(map[string]any)["value"] = "changed"
-
-	again, err := Load(testSource("one", fsys))
-	if err != nil {
-		t.Fatalf("reload catalog: %v", err)
+	profile, err := state.GetProfile(context.Background(), "promptkit-openrouter-standard")
+	if err != nil || profile.ResolvedTarget.Model != "consumer-model" || profile.ResolvedTarget.Endpoint != "https://alternate.example/v1" {
+		t.Fatalf("maintained profile did not observe final configuration: %+v, %v", profile, err)
 	}
-	if got := again.Backends[0].ExtraParams["nested"].(map[string]any)["value"]; got != "backend" {
-		t.Fatalf("backend mutation escaped returned set: %#v", got)
-	}
-	againProfile, err := loaded.Profiles.GetProfile(context.Background(), "one-profile")
-	if err != nil {
-		t.Fatalf("reload profile: %v", err)
-	}
-	if got := againProfile.ExtraParams["nested"].(map[string]any)["value"]; got != "profile" {
-		t.Fatalf("profile mutation escaped returned value: %#v", got)
+	_, err = configuration.Load(configkit.Input{Source: configkit.Mapping("invalid final", map[string]any{
+		"backends": map[string]any{"openrouter": map[string]any{"endpoint": "invalid final value"}},
+	})}, underlays[:2])
+	var loadError *configkit.LoadError
+	if !errors.As(err, &loadError) {
+		t.Fatalf("invalid final backend did not produce a ConfigKit load error: %v", err)
 	}
 }
-
-func testSource(id string, fsys fs.FS) Source {
-	return Source{Name: id, ExpectedBackendID: id, FS: fsys, Root: "catalog"}
-}
-
-func validCatalogFS(id string) fstest.MapFS {
-	return catalogFS(id, map[string]string{
-		"catalog/profiles/" + id + "-profile.yml": validProfile(id+"-profile", id),
-	}, "null")
-}
-
-func catalogFS(id string, profiles map[string]string, extraParams string) fstest.MapFS {
-	fsys := fstest.MapFS{
-		"catalog/backend.json": &fstest.MapFile{Data: []byte(validManifest(id, "TEST_API_KEY", extraParams))},
-	}
-	for name, content := range profiles {
-		fsys[name] = &fstest.MapFile{Data: []byte(content)}
-	}
-	return fsys
-}
-
-func validManifest(id, apiKeyEnv, extraParams string) string {
-	return fmt.Sprintf(
-		`{"schema_version":1,"id":%q,"endpoint":%q,"api_key_env":%q,"concurrency_limit":2,"queue_capacity":3,"extra_params":%s}`,
-		id,
-		"https://"+id+".example/v1",
-		apiKeyEnv,
-		extraParams,
-	)
-}
-
-func validProfile(id, backendID string) string {
-	return fmt.Sprintf("id: %s\nbackend: %s\nmodel: test-model\n", id, backendID)
-}
-
-var _ fs.FS = openrouter.FS()

internal/configuration/benchmark_test.go

@@ -0,0 +1,295 @@
+package configuration
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+const benchmarkDefinitionCount = 128
+
+var (
+	constructionResult       *loaded
+	selectedPrompt           *domain.PromptDefinition
+	selectedPromptHash       string
+	selectedPromptInspection *domain.PromptInspection
+	selectedProfile          *domain.ExecutionProfile
+	selectedProfileIdentity  string
+)
+
+type configurationShape struct {
+	main             configkit.Input
+	underlays        []configkit.Underlay
+	inputEntries     int
+	effectiveEntries int
+	tiers            int
+}
+
+func benchmarkPrompt(profileID string) map[string]any {
+	return map[string]any{
+		"default_profile": profileID,
+		"messages":        []any{map[string]any{"role": "user", "content": "Hello {{.name}}"}},
+		"output":          map[string]any{"format": "text", "validation_mode": "none"},
+	}
+}
+
+func independentDefinitions(count int) configurationShape {
+	profiles := make(map[string]any, count)
+	prompts := make(map[string]any, count)
+	for index := range count {
+		profileID := fmt.Sprintf("profile-%03d", index)
+		promptID := fmt.Sprintf("prompt-%03d", index)
+		profiles[profileID] = map[string]any{"endpoint": "https://example.test/v1", "model": profileID}
+		prompts[promptID] = map[string]any{"1": benchmarkPrompt(profileID)}
+	}
+	return configurationShape{
+		main:             configkit.Input{Source: configkit.Mapping("independent definitions", map[string]any{"profiles": profiles, "prompts": prompts})},
+		inputEntries:     count * 2,
+		effectiveEntries: count * 2,
+		tiers:            1,
+	}
+}
+
+func fileBackedDefinitions(count int) configurationShape {
+	profiles := make(map[string]any, count)
+	prompts := make(map[string]any, count)
+	for index := range count {
+		profileID := fmt.Sprintf("profile-%03d", index)
+		promptID := fmt.Sprintf("prompt-%03d", index)
+		profiles[profileID] = map[string]any{"endpoint": "https://example.test/v1", "model": profileID}
+		prompt := benchmarkPrompt(profileID)
+		prompt["messages"] = []any{map[string]any{"role": "user", "content_file": "body.md"}}
+		prompts[promptID] = map[string]any{"1": prompt}
+	}
+	namespace := configkit.NewFilesystem("benchmark content", fstest.MapFS{
+		"assets/body.md": &fstest.MapFile{Data: []byte("Hello {{.name}}")},
+	})
+	return configurationShape{
+		main: configkit.Input{
+			Source:     configkit.Mapping("file-backed definitions", map[string]any{"profiles": profiles, "prompts": prompts}),
+			Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: ".", BaseDir: "assets"},
+		},
+		inputEntries: count * 2, effectiveEntries: count * 2, tiers: 1,
+	}
+}
+
+func sharedBaseDefinitions(count int) configurationShape {
+	profiles := make(map[string]any, count+1)
+	profiles["base"] = map[string]any{
+		"endpoint": "https://example.test/v1", "model": "shared-model",
+		"extra_params": map[string]any{"provider": map[string]any{"mode": "shared", "limit": 4}},
+	}
+	for index := range count {
+		profiles[fmt.Sprintf("child-%03d", index)] = map[string]any{"extends": "base", "temperature": float64(index%10) / 10}
+	}
+	return configurationShape{
+		main: configkit.Input{Source: configkit.Mapping("inherited definitions", map[string]any{
+			"profiles": profiles,
+			"prompts":  map[string]any{"shared": map[string]any{"1": benchmarkPrompt(fmt.Sprintf("child-%03d", count-1))}},
+		})},
+		inputEntries:     count + 2,
+		effectiveEntries: count + 2,
+		tiers:            1,
+	}
+}
+
+func layeredDefinitions(count int) configurationShape {
+	base := make(map[string]any, count)
+	operator := make(map[string]any, count)
+	programmatic := make(map[string]any, count)
+	final := make(map[string]any, count)
+	for index := range count {
+		id := fmt.Sprintf("profile-%03d", index)
+		base[id] = map[string]any{"endpoint": "https://example.test/v1", "model": "base-model"}
+		operator[id] = map[string]any{"model": "operator-model"}
+		programmatic[id] = map[string]any{"extra_params": map[string]any{"provider": map[string]any{"mode": "programmatic"}}}
+		final[id] = map[string]any{"temperature": float64(index%10) / 10}
+	}
+	return configurationShape{
+		underlays: []configkit.Underlay{
+			{Inputs: []configkit.Input{{Source: configkit.Mapping("fallback", map[string]any{"profiles": base})}}},
+			{Inputs: []configkit.Input{{Source: configkit.Mapping("operator", map[string]any{"profiles": operator})}}},
+			{Inputs: []configkit.Input{{Source: configkit.Mapping("programmatic", map[string]any{"profiles": programmatic})}}},
+		},
+		main: configkit.Input{Source: configkit.Mapping("main", map[string]any{
+			"profiles": final,
+			"prompts":  map[string]any{"layered": map[string]any{"1": benchmarkPrompt(fmt.Sprintf("profile-%03d", count-1))}},
+		})},
+		inputEntries:     count*4 + 1,
+		effectiveEntries: count + 1,
+		tiers:            4,
+	}
+}
+
+func BenchmarkConfigurationConstruction(b *testing.B) {
+	for _, scenario := range []struct {
+		name  string
+		shape configurationShape
+	}{
+		{name: "independent", shape: independentDefinitions(benchmarkDefinitionCount)},
+		{name: "file_backed", shape: fileBackedDefinitions(64)},
+		{name: "shared_base", shape: sharedBaseDefinitions(benchmarkDefinitionCount)},
+		{name: "layered", shape: layeredDefinitions(benchmarkDefinitionCount)},
+	} {
+		b.Run(scenario.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for b.Loop() {
+				result, err := load(scenario.shape.main, scenario.shape.underlays)
+				if err != nil {
+					b.Fatal(err)
+				}
+				constructionResult = result
+			}
+			b.ReportMetric(float64(scenario.shape.inputEntries), "input-entries/op")
+			b.ReportMetric(float64(scenario.shape.effectiveEntries), "effective-entries/op")
+			b.ReportMetric(float64(scenario.shape.tiers), "tiers/op")
+		})
+	}
+}
+
+func BenchmarkConfigurationSelection(b *testing.B) {
+	shape := independentDefinitions(benchmarkDefinitionCount)
+	result, err := load(shape.main, nil)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.Run("prompt", func(b *testing.B) {
+		b.ReportAllocs()
+		for b.Loop() {
+			definition, _, err := result.prompt("prompt-127", "1")
+			if err != nil {
+				b.Fatal(err)
+			}
+			selectedPrompt = definition
+		}
+		b.ReportMetric(float64(shape.effectiveEntries), "effective-entries/op")
+	})
+	b.Run("profile", func(b *testing.B) {
+		b.ReportAllocs()
+		for b.Loop() {
+			profile, err := result.GetProfile(context.Background(), "profile-127")
+			if err != nil {
+				b.Fatal(err)
+			}
+			selectedProfile = profile
+		}
+		b.ReportMetric(float64(shape.effectiveEntries), "effective-entries/op")
+	})
+}
+
+func inspectionExtraParams(entries int) map[string]any {
+	providers := make(map[string]any, entries)
+	for index := range entries {
+		providers[fmt.Sprintf("provider-%03d", index)] = map[string]any{
+			"enabled": true,
+			"labels":  []any{fmt.Sprintf("tier-%d", index%4), fmt.Sprintf("region-%d", index%3)},
+			"limits":  map[string]any{"burst": index + 1, "period": "minute"},
+			"routes":  []any{map[string]any{"weight": index + 1, "fallback": true}},
+		}
+	}
+	return map[string]any{"provider_options": providers}
+}
+
+func inspectionDefinitions(extraParams map[string]any) configurationShape {
+	profiles := map[string]any{
+		"small": map[string]any{"model": "inspection-model", "extra_params": extraParams},
+	}
+	prompt := benchmarkPrompt("small")
+	prompt["inputs"] = []any{map[string]any{"name": "transcript", "required": true}}
+	prompts := map[string]any{
+		"inspection": map[string]any{"1": prompt},
+	}
+	return configurationShape{
+		main: configkit.Input{Source: configkit.Mapping("inspection definitions", map[string]any{
+			"profiles": profiles,
+			"prompts":  prompts,
+		})},
+		inputEntries: 2, effectiveEntries: 2, tiers: 1,
+	}
+}
+
+func BenchmarkInspectionSelection(b *testing.B) {
+	for _, scenario := range []struct {
+		name    string
+		entries int
+	}{
+		{name: "small_extra", entries: 2},
+		{name: "nested_extra", entries: 64},
+	} {
+		shape := inspectionDefinitions(inspectionExtraParams(scenario.entries))
+		result, err := load(shape.main, nil)
+		if err != nil {
+			b.Fatal(err)
+		}
+		ctx := context.Background()
+		definition, hash, err := result.GetPromptSnapshot(ctx, "inspection", "1")
+		if err != nil || definition.ID != "inspection" || definition.Version != "1" || hash == "" ||
+			len(definition.Inputs) != 1 || definition.Inputs[0].Name != "transcript" || !definition.Inputs[0].Required {
+			b.Fatalf("prompt lookup fixture is invalid: definition=%+v hash=%q err=%v", definition, hash, err)
+		}
+		profile, err := result.GetProfile(ctx, "small")
+		if err != nil || profile.ID != "small" || profile.ResolvedTarget.Model != "inspection-model" ||
+			len(profile.ResolvedTarget.ExtraParams["provider_options"].(map[string]any)) != scenario.entries {
+			b.Fatalf("profile lookup fixture is invalid: profile=%+v err=%v", profile, err)
+		}
+		inspection, err := result.GetPromptInspection(ctx, "inspection", "1")
+		if err != nil || inspection.PromptID != "inspection" || inspection.PromptVersion != "1" ||
+			len(inspection.Inputs) != 1 || inspection.Inputs[0].Name != "transcript" {
+			b.Fatalf("prompt inspection fixture is invalid: inspection=%+v err=%v", inspection, err)
+		}
+		identity, err := result.GetProfileIdentity(ctx, "small")
+		if err != nil || identity != "small" {
+			b.Fatalf("profile identity fixture is invalid: identity=%q err=%v", identity, err)
+		}
+
+		b.Run("prompt/"+scenario.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for b.Loop() {
+				definition, hash, err := result.GetPromptSnapshot(ctx, "inspection", "1")
+				if err != nil {
+					b.Fatal(err)
+				}
+				selectedPrompt = definition
+				selectedPromptHash = hash
+			}
+			b.ReportMetric(float64(scenario.entries), "extra-entries/op")
+		})
+		b.Run("prompt_inspection/"+scenario.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for b.Loop() {
+				inspection, err := result.GetPromptInspection(ctx, "inspection", "1")
+				if err != nil {
+					b.Fatal(err)
+				}
+				selectedPromptInspection = inspection
+			}
+			b.ReportMetric(float64(scenario.entries), "extra-entries/op")
+		})
+		b.Run("profile/"+scenario.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for b.Loop() {
+				profile, err := result.GetProfile(ctx, "small")
+				if err != nil {
+					b.Fatal(err)
+				}
+				selectedProfile = profile
+			}
+			b.ReportMetric(float64(scenario.entries), "extra-entries/op")
+		})
+		b.Run("profile_identity/"+scenario.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for b.Loop() {
+				identity, err := result.GetProfileIdentity(ctx, "small")
+				if err != nil {
+					b.Fatal(err)
+				}
+				selectedProfileIdentity = identity
+			}
+			b.ReportMetric(float64(scenario.entries), "extra-entries/op")
+		})
+	}
+}

internal/configuration/inspection.go

@@ -0,0 +1,66 @@
+package configuration
+
+import (
+	"io"
+	"strings"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+)
+
+// Inspection is the read-only subset of the retained ConfigKit result used by
+// the facade. It does not expose typed configuration or resource contexts.
+type Inspection interface {
+	Metadata() configkit.Metadata
+	Sources() []configkit.SourceInfo
+	Diagnostics() []configkit.Diagnostic
+	Explain(configkit.Path) (configkit.Explanation, bool)
+	WriteEffective(io.Writer) error
+	WriteExplanation(io.Writer, configkit.Path) error
+	capturedResult() *configkit.Result[document]
+}
+
+type inspectionResult struct {
+	*configkit.Result[document]
+}
+
+func (inspection inspectionResult) capturedResult() *configkit.Result[document] {
+	return inspection.Result
+}
+
+// Inspection returns only the retained result's inspection operations.
+func (state *loaded) Inspection() Inspection {
+	if state == nil {
+		return nil
+	}
+	return inspectionResult{Result: state.result}
+}
+
+// Diff compares two captured ConfigKit results without reconstructing them.
+func Diff(left, right Inspection) ([]configkit.Difference, error) {
+	var leftResult, rightResult *configkit.Result[document]
+	if left != nil {
+		leftResult = left.capturedResult()
+	}
+	if right != nil {
+		rightResult = right.capturedResult()
+	}
+	return configkit.Diff(leftResult, rightResult)
+}
+
+func secretProviderPath(path configkit.Path) bool {
+	pointer := path.String()
+	if pointer == "" {
+		return false
+	}
+	parts := strings.Split(strings.TrimPrefix(pointer, "/"), "/")
+	if len(parts) < 4 || (parts[0] != "backends" && parts[0] != "profiles") || parts[2] != "extra_params" {
+		return false
+	}
+	key := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(parts[len(parts)-1], "~1", "/"), "~0", "~"))
+	switch key {
+	case "api_key", "apikey", "authorization", "credential", "credentials", "password", "secret", "token", "access_token":
+		return true
+	default:
+		return false
+	}
+}

internal/configuration/listing.go

@@ -0,0 +1,29 @@
+package configuration
+
+import (
+	"context"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+func (state *loaded) ListProfiles(ctx context.Context) ([]string, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	profiles := append([]string(nil), state.profileIDs...)
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	return profiles, nil
+}
+
+func (state *loaded) ListPrompts(ctx context.Context) ([]domain.PromptIdentity, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	prompts := append([]domain.PromptIdentity(nil), state.promptIDs...)
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	return prompts, nil
+}

internal/configuration/listing_test.go

@@ -0,0 +1,142 @@
+package configuration
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+func TestLoadedListsSortedEffectiveIdentities(t *testing.T) {
+	state, err := Load(mapping("identities", map[string]any{
+		"backends": map[string]any{
+			"local": map[string]any{"endpoint": "http://localhost:8080/v1"},
+		},
+		"profiles": map[string]any{
+			"z/profile":       map[string]any{"backend": "local", "model": "z-model"},
+			"partial/profile": map[string]any{"backend": "local"},
+			"a/profile":       map[string]any{"backend": "local", "model": "a-model"},
+			" z/profile ":     map[string]any{"backend": "local", "model": "spaced-model"},
+		},
+		"prompts": map[string]any{
+			"z/prompt": map[string]any{"v1": listingPromptDefinition()},
+			"a/prompt": map[string]any{"v1": listingPromptDefinition()},
+			" z/prompt ": map[string]any{
+				"2":  listingPromptDefinition(),
+				"10": listingPromptDefinition(),
+			},
+		},
+	}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	profiles, err := state.ListProfiles(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantProfiles := []string{" z/profile ", "a/profile", "partial/profile", "z/profile"}
+	if !reflect.DeepEqual(profiles, wantProfiles) {
+		t.Fatalf("profile IDs = %#v, want %#v", profiles, wantProfiles)
+	}
+
+	prompts, err := state.ListPrompts(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantPrompts := []domain.PromptIdentity{
+		{ID: " z/prompt ", Version: "10"},
+		{ID: " z/prompt ", Version: "2"},
+		{ID: "a/prompt", Version: "v1"},
+		{ID: "z/prompt", Version: "v1"},
+	}
+	if !reflect.DeepEqual(prompts, wantPrompts) {
+		t.Fatalf("prompt identities = %#v, want %#v", prompts, wantPrompts)
+	}
+}
+
+func TestLoadedListsAreIndependent(t *testing.T) {
+	state, err := Load(mapping("identities", map[string]any{
+		"profiles": map[string]any{"profile": map[string]any{}},
+		"prompts":  map[string]any{"example": map[string]any{"v1": listingPromptDefinition()}},
+	}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	profiles, err := state.ListProfiles(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	profiles = append(profiles, "caller profile")
+	profiles[0] = "changed profile"
+
+	prompts, err := state.ListPrompts(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	prompts[0].ID = "changed prompt"
+	prompts[0].Version = "changed version"
+
+	profiles, err = state.ListProfiles(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(profiles, []string{"profile"}) {
+		t.Fatalf("caller mutation changed profile inventory: %#v", profiles)
+	}
+	prompts, err = state.ListPrompts(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantPrompts := []domain.PromptIdentity{{ID: "example", Version: "v1"}}
+	if !reflect.DeepEqual(prompts, wantPrompts) {
+		t.Fatalf("caller mutation changed prompt inventory: %#v", prompts)
+	}
+}
+
+func TestLoadedListsEmptyInventory(t *testing.T) {
+	state, err := Load(configkit.Input{Source: configkit.NoSource()}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	profiles, err := state.ListProfiles(context.Background())
+	if err != nil || len(profiles) != 0 {
+		t.Fatalf("empty profile listing = %#v, %v", profiles, err)
+	}
+	prompts, err := state.ListPrompts(context.Background())
+	if err != nil || len(prompts) != 0 {
+		t.Fatalf("empty prompt listing = %#v, %v", prompts, err)
+	}
+}
+
+func TestLoadedListsHonorCanceledContext(t *testing.T) {
+	state, err := Load(mapping("identities", map[string]any{
+		"profiles": map[string]any{"partial": map[string]any{}},
+		"prompts":  map[string]any{"example": map[string]any{"v1": listingPromptDefinition()}},
+	}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	profiles, err := state.ListProfiles(ctx)
+	if !errors.Is(err, context.Canceled) || len(profiles) != 0 {
+		t.Fatalf("canceled profile listing = %#v, %v", profiles, err)
+	}
+	prompts, err := state.ListPrompts(ctx)
+	if !errors.Is(err, context.Canceled) || len(prompts) != 0 {
+		t.Fatalf("canceled prompt listing = %#v, %v", prompts, err)
+	}
+}
+
+func listingPromptDefinition() map[string]any {
+	return map[string]any{
+		"messages": []any{map[string]any{"role": "user", "content": "Hello."}},
+		"output":   map[string]any{"format": "text", "validation_mode": "basic"},
+	}
+}

internal/configuration/load.go

@@ -0,0 +1,366 @@
+// Package configuration adapts ConfigKit's effective configuration to
+// Promptkit's definition and execution boundaries.
+package configuration
+
+import (
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
+	"gitea.maximumdirect.net/eric/promptkit/internal/llm"
+)
+
+type document struct {
+	Backends map[string]backendConfig           `yaml:"backends"`
+	Profiles map[string]profileConfig           `yaml:"profiles"`
+	Prompts  map[string]map[string]promptConfig `yaml:"prompts"`
+}
+
+type backendConfig struct {
+	Endpoint         *string        `yaml:"endpoint"`
+	APIKeyEnv        *string        `yaml:"api_key_env"`
+	ConcurrencyLimit *int           `yaml:"concurrency_limit"`
+	QueueCapacity    *int           `yaml:"queue_capacity"`
+	ExtraParams      map[string]any `yaml:"extra_params"`
+}
+
+type profileConfig struct {
+	Backend         *string        `yaml:"backend"`
+	Endpoint        *string        `yaml:"endpoint"`
+	Model           *string        `yaml:"model"`
+	Temperature     *float64       `yaml:"temperature"`
+	TopP            *float64       `yaml:"top_p"`
+	MaxTokens       *int           `yaml:"max_tokens"`
+	TimeoutSeconds  *int           `yaml:"timeout_seconds"`
+	ServiceTier     *string        `yaml:"service_tier"`
+	ReasoningEffort *string        `yaml:"reasoning_effort"`
+	APIKeyEnv       *string        `yaml:"api_key_env"`
+	APIKeyRequired  *bool          `yaml:"api_key_required"`
+	ExtraParams     map[string]any `yaml:"extra_params"`
+}
+
+type promptConfig struct {
+	DefaultProfile *string               `yaml:"default_profile"`
+	Description    *string               `yaml:"description"`
+	SessionID      *string               `yaml:"session_id"`
+	Inputs         []promptInputConfig   `yaml:"inputs"`
+	Messages       []promptMessageConfig `yaml:"messages"`
+	Output         *promptOutputConfig   `yaml:"output"`
+}
+
+type promptInputConfig struct {
+	Name        string  `yaml:"name"`
+	Required    bool    `yaml:"required"`
+	ContentType *string `yaml:"content_type"`
+	Description *string `yaml:"description"`
+}
+
+type promptMessageConfig struct {
+	Role         *string             `yaml:"role"`
+	Content      *string             `yaml:"content"`
+	ContentFile  *string             `yaml:"content_file"`
+	CacheControl *cacheControlConfig `yaml:"cache_control"`
+}
+
+type cacheControlConfig struct {
+	Type *string `yaml:"type"`
+	TTL  *string `yaml:"ttl"`
+}
+
+type promptOutputConfig struct {
+	Format         *string `yaml:"format"`
+	ValidationMode *string `yaml:"validation_mode"`
+	SchemaPath     *string `yaml:"schema_path"`
+	RepairAttempts int     `yaml:"repair_attempts"`
+}
+
+// fieldState distinguishes omission, an explicit value, and an explicit null.
+// Inherited values are explicit because ConfigKit has already expanded them.
+type fieldState uint8
+
+const (
+	fieldAbsent fieldState = iota
+	fieldValue
+	fieldNull
+)
+
+type loaded struct {
+	result          *configkit.Result[document]
+	backends        map[string]map[string]fieldState
+	profiles        map[string]map[string]fieldState
+	promptMetadata  map[string]map[string][]promptInputPresence
+	prompts         map[string]map[string]*promptEntry
+	ambiguous       map[string]bool
+	registry        *backend.Registry
+	indexedProfiles map[string]domain.ExecutionProfile
+	profileIDs      []string
+	promptIDs       []domain.PromptIdentity
+}
+
+var envName = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
+
+var backendFields = []string{"endpoint", "api_key_env", "concurrency_limit", "queue_capacity", "extra_params"}
+var profileFields = []string{"backend", "endpoint", "model", "temperature", "top_p", "max_tokens", "timeout_seconds", "service_tier", "reasoning_effort", "api_key_env", "api_key_required", "extra_params"}
+
+// Load captures one immutable effective configuration for internal consumers.
+func Load(main configkit.Input, underlays []configkit.Underlay) (*loaded, error) {
+	return load(main, underlays)
+}
+
+// load performs one ConfigKit lifecycle over the selected source tiers.
+func load(main configkit.Input, underlays []configkit.Underlay) (*loaded, error) {
+	state := &loaded{
+		backends:       make(map[string]map[string]fieldState),
+		profiles:       make(map[string]map[string]fieldState),
+		promptMetadata: make(map[string]map[string][]promptInputPresence),
+	}
+	result, err := configkit.LoadLayered(main, configkit.LayeredOptions[document]{
+		Underlays: underlays,
+		Definition: configkit.Definition[document]{
+			Secret: secretProviderPath,
+			Resolve: func(config *document, resolution *configkit.Resolution) error {
+				captureFields(config.Backends, "backends", backendFields, resolution, state.backends)
+				captureFields(config.Profiles, "profiles", profileFields, resolution, state.profiles)
+				capturePromptMetadata(config.Prompts, resolution, state.promptMetadata)
+				resolveBackends(config.Backends, resolution)
+				resolveProfiles(config.Profiles, resolution)
+				resolvePrompts(config.Prompts, resolution)
+				return nil
+			},
+			Validate: validateEffective,
+		},
+	})
+	if err != nil {
+		return nil, fmt.Errorf("load configuration: %w", err)
+	}
+	state.result = result
+	if err := state.materializePrompts(); err != nil {
+		return nil, fmt.Errorf("load configuration: %w", err)
+	}
+	if err := state.buildExecutionProfiles(); err != nil {
+		return nil, fmt.Errorf("load configuration: %w", err)
+	}
+	state.profileIDs = sortedKeys(state.indexedProfiles)
+	for _, id := range sortedKeys(state.prompts) {
+		for _, version := range sortedKeys(state.prompts[id]) {
+			state.promptIDs = append(state.promptIDs, domain.PromptIdentity{ID: id, Version: version})
+		}
+	}
+	return state, nil
+}
+
+type promptInputPresence struct {
+	contentType fieldState
+	description fieldState
+}
+
+func capturePromptMetadata(prompts map[string]map[string]promptConfig, resolution *configkit.Resolution, destination map[string]map[string][]promptInputPresence) {
+	for _, id := range sortedKeys(prompts) {
+		if destination[id] == nil {
+			destination[id] = make(map[string][]promptInputPresence, len(prompts[id]))
+		}
+		for _, version := range sortedKeys(prompts[id]) {
+			inputs := prompts[id][version].Inputs
+			states := make([]promptInputPresence, len(inputs))
+			base := configkit.Keys("prompts", id, version, "inputs")
+			for index := range inputs {
+				path := base.Index(index)
+				states[index] = promptInputPresence{
+					contentType: captureFieldState(path.Key("content_type"), resolution),
+					description: captureFieldState(path.Key("description"), resolution),
+				}
+			}
+			destination[id][version] = states
+		}
+	}
+}
+
+func captureFieldState(path configkit.Path, resolution *configkit.Resolution) fieldState {
+	info, exists := resolution.InputInfo(path)
+	switch {
+	case !exists || !info.Explicit:
+		return fieldAbsent
+	case info.Null:
+		return fieldNull
+	default:
+		return fieldValue
+	}
+}
+
+func captureFields[T any](entries map[string]T, collection string, fields []string, resolution *configkit.Resolution, destination map[string]map[string]fieldState) {
+	for id := range entries {
+		states := make(map[string]fieldState, len(fields))
+		for _, field := range fields {
+			info, exists := resolution.InputInfo(configkit.Keys(collection, id, field))
+			switch {
+			case !exists || !info.Explicit:
+				states[field] = fieldAbsent
+			case info.Null:
+				states[field] = fieldNull
+			default:
+				states[field] = fieldValue
+			}
+		}
+		destination[id] = states
+	}
+}
+
+func sortedKeys[T any](entries map[string]T) []string {
+	keys := make([]string, 0, len(entries))
+	for key := range entries {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func normalizeString(value **string, path configkit.Path, resolution *configkit.Resolution, normalized string) bool {
+	if value != nil && *value != nil && **value != normalized {
+		configkit.Normalize(resolution, path, value, &normalized, "normalize configuration value")
+		return true
+	}
+	return false
+}
+
+func resolveBackends(backends map[string]backendConfig, resolution *configkit.Resolution) {
+	for _, id := range sortedKeys(backends) {
+		backend := backends[id]
+		base := configkit.Keys("backends", id)
+		if backend.Endpoint != nil {
+			endpoint, err := domain.NormalizeOpenAICompatibleBaseEndpoint(*backend.Endpoint)
+			if err != nil {
+				resolution.Error(base.Key("endpoint"), err.Error())
+			} else {
+				normalizeString(&backend.Endpoint, base.Key("endpoint"), resolution, endpoint)
+			}
+		}
+		if backend.APIKeyEnv != nil {
+			normalizeString(&backend.APIKeyEnv, base.Key("api_key_env"), resolution, strings.TrimSpace(*backend.APIKeyEnv))
+		}
+		if backend.ConcurrencyLimit != nil && *backend.ConcurrencyLimit > 0 && backend.QueueCapacity == nil {
+			capacity := 1024
+			if resolution.IsExplicit(base.Key("queue_capacity")) {
+				configkit.Normalize(resolution, base.Key("queue_capacity"), &backend.QueueCapacity, &capacity, "select default queue capacity")
+			} else {
+				configkit.Default(resolution, base.Key("queue_capacity"), &backend.QueueCapacity, &capacity, "select default queue capacity")
+			}
+		}
+		backends[id] = backend
+	}
+}
+
+func resolveProfiles(profiles map[string]profileConfig, resolution *configkit.Resolution) {
+	for _, id := range sortedKeys(profiles) {
+		profile := profiles[id]
+		base := configkit.Keys("profiles", id)
+		if profile.Endpoint != nil && *profile.Endpoint != "" {
+			endpoint, err := domain.NormalizeOpenAICompatibleBaseEndpoint(*profile.Endpoint)
+			if err != nil {
+				resolution.Error(base.Key("endpoint"), err.Error())
+			} else {
+				normalizeString(&profile.Endpoint, base.Key("endpoint"), resolution, endpoint)
+			}
+		}
+		for _, field := range []struct {
+			name  string
+			value **string
+		}{
+			{"service_tier", &profile.ServiceTier},
+			{"reasoning_effort", &profile.ReasoningEffort},
+			{"api_key_env", &profile.APIKeyEnv},
+		} {
+			if *field.value != nil {
+				normalizeString(field.value, base.Key(field.name), resolution, strings.TrimSpace(**field.value))
+			}
+		}
+		profiles[id] = profile
+	}
+}
+
+func validateEffective(config *document, validation *configkit.Validation) {
+	for _, id := range sortedKeys(config.Backends) {
+		backend := config.Backends[id]
+		base := configkit.Keys("backends", id)
+		if strings.TrimSpace(id) == "" {
+			validation.Error(base, "backend ID must not be blank")
+		}
+		if backend.Endpoint == nil || *backend.Endpoint == "" {
+			validation.Error(base.Key("endpoint"), "endpoint is required")
+		}
+		if backend.APIKeyEnv != nil && *backend.APIKeyEnv != "" && !envName.MatchString(*backend.APIKeyEnv) {
+			validation.Error(base.Key("api_key_env"), "environment variable name is invalid")
+		}
+		if backend.ConcurrencyLimit != nil && *backend.ConcurrencyLimit < 0 {
+			validation.Error(base.Key("concurrency_limit"), "concurrency limit must not be negative")
+		}
+		if backend.QueueCapacity != nil {
+			if *backend.QueueCapacity < 0 {
+				validation.Error(base.Key("queue_capacity"), "queue capacity must not be negative")
+			}
+			if backend.ConcurrencyLimit == nil || *backend.ConcurrencyLimit <= 0 {
+				validation.Error(base.Key("queue_capacity"), "queue capacity requires a positive concurrency limit")
+			} else if *backend.QueueCapacity > int(^uint(0)>>1)-*backend.ConcurrencyLimit {
+				validation.Error(base.Key("queue_capacity"), "total capacity overflows int")
+			}
+		}
+		validateExtraParams(backend.ExtraParams, base.Key("extra_params"), true, validation)
+	}
+	for _, id := range sortedKeys(config.Profiles) {
+		profile := config.Profiles[id]
+		base := configkit.Keys("profiles", id)
+		if strings.TrimSpace(id) == "" {
+			validation.Error(base, "profile ID must not be blank")
+		}
+		if profile.Backend != nil && *profile.Backend != "" {
+			if _, exists := config.Backends[*profile.Backend]; !exists {
+				validation.Error(base.Key("backend"), "backend is not defined")
+			}
+		}
+		if profile.Model != nil && *profile.Model != "" && strings.TrimSpace(*profile.Model) == "" {
+			validation.Error(base.Key("model"), "model must not be blank")
+		}
+		if profile.Temperature != nil {
+			if err := domain.ValidateExecutionTargetSettings(domain.ExecutionTarget{Temperature: *profile.Temperature}); err != nil {
+				validation.Error(base.Key("temperature"), err.Error())
+			}
+		}
+		if profile.TopP != nil {
+			if err := domain.ValidateExecutionTargetSettings(domain.ExecutionTarget{TopP: *profile.TopP}); err != nil {
+				validation.Error(base.Key("top_p"), err.Error())
+			}
+		}
+		if profile.MaxTokens != nil {
+			if err := domain.ValidateExecutionTargetSettings(domain.ExecutionTarget{MaxTokens: *profile.MaxTokens}); err != nil {
+				validation.Error(base.Key("max_tokens"), err.Error())
+			}
+		}
+		if profile.TimeoutSeconds != nil {
+			if err := domain.ValidateExecutionTargetSettings(domain.ExecutionTarget{TimeoutSeconds: *profile.TimeoutSeconds}); err != nil {
+				validation.Error(base.Key("timeout_seconds"), err.Error())
+			}
+		}
+		validateExtraParams(profile.ExtraParams, base.Key("extra_params"), false, validation)
+	}
+}
+
+func validateExtraParams(values map[string]any, path configkit.Path, backend bool, validation *configkit.Validation) {
+	if values == nil {
+		return
+	}
+	if _, err := jsonvalue.CopyMap(values); err != nil {
+		validation.Error(path, "extra parameters must be a JSON-compatible map with nonempty keys")
+		return
+	}
+	if backend {
+		for key := range values {
+			if llm.IsReservedOpenAIChatRequestField(key) {
+				validation.Error(path.Key(key), "extra parameter conflicts with a request field")
+			}
+		}
+	}
+}

internal/configuration/load_test.go

@@ -0,0 +1,138 @@
+package configuration
+
+import (
+	"errors"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+)
+
+func mapping(label string, values map[string]any) configkit.Input {
+	return configkit.Input{Source: configkit.Mapping(label, values)}
+}
+
+func TestLoadComposesLiteralKeysAndEffectivePresence(t *testing.T) {
+	base := mapping("defaults", map[string]any{
+		"backends": map[string]any{
+			"local.v1": map[string]any{"endpoint": "http://localhost:8080/v1", "concurrency_limit": 2},
+		},
+		"profiles": map[string]any{
+			"base/one": map[string]any{"backend": "local.v1", "temperature": 0.8, "top_p": 0.9, "api_key_required": true,
+				"extra_params": map[string]any{"provider": map[string]any{"first": 1, "second": 2}}},
+			"child.v1": map[string]any{"extends": "base/one"},
+		},
+		"prompts": map[string]any{"invoice/summary": map[string]any{"v1.0": map[string]any{
+			"messages": []any{map[string]any{"role": "user", "content": "Summarize."}},
+			"output":   map[string]any{"format": "text", "validation_mode": "basic"},
+		}}},
+	})
+	overlay := mapping("operator", map[string]any{
+		"backends": map[string]any{"local.v1": map[string]any{"queue_capacity": 0}},
+		"profiles": map[string]any{"child.v1": map[string]any{
+			"temperature": 0, "top_p": nil, "api_key_required": false,
+			"extra_params": map[string]any{"provider": map[string]any{"second": 3}},
+		}},
+	})
+	loaded, err := load(configkit.Input{Source: configkit.NoSource()}, []configkit.Underlay{
+		{Inputs: []configkit.Input{base}}, {Inputs: []configkit.Input{overlay}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	profile := loaded.result.Config.Profiles["child.v1"]
+	if profile.Temperature == nil || *profile.Temperature != 0 || profile.TopP != nil || profile.APIKeyRequired == nil || *profile.APIKeyRequired {
+		t.Fatalf("effective values were not retained: %+v", profile)
+	}
+	if loaded.profiles["child.v1"]["temperature"] != fieldValue || loaded.profiles["child.v1"]["top_p"] != fieldNull || loaded.profiles["child.v1"]["api_key_required"] != fieldValue {
+		t.Fatalf("effective presence was lost: %+v", loaded.profiles["child.v1"])
+	}
+	provider := profile.ExtraParams["provider"].(map[string]any)
+	if provider["first"] != int64(1) || provider["second"] != int64(3) {
+		t.Fatalf("recursive overlay failed: %+v", provider)
+	}
+	backend := loaded.result.Config.Backends["local.v1"]
+	if backend.QueueCapacity == nil || *backend.QueueCapacity != 0 || loaded.backends["local.v1"]["queue_capacity"] != fieldValue {
+		t.Fatalf("explicit zero queue capacity was lost: %+v", backend)
+	}
+	if loaded.result.Config.Prompts["invoice/summary"]["v1.0"].Messages[0].Content == nil {
+		t.Fatal("literal prompt ID and version were not decoded")
+	}
+}
+
+func TestLoadRecordsBackendNormalizationAndNullDefault(t *testing.T) {
+	loaded, err := load(mapping("backend", map[string]any{"backends": map[string]any{
+		"local": map[string]any{"endpoint": " HTTP://localhost:8080/v1 ", "api_key_env": " TOKEN_NAME ",
+			"concurrency_limit": 2, "queue_capacity": nil},
+	}}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	backend := loaded.result.Config.Backends["local"]
+	if backend.Endpoint == nil || *backend.Endpoint != "http://localhost:8080/v1" ||
+		backend.APIKeyEnv == nil || *backend.APIKeyEnv != "TOKEN_NAME" ||
+		backend.QueueCapacity == nil || *backend.QueueCapacity != 1024 {
+		t.Fatalf("backend normalization/default was not applied: %+v", backend)
+	}
+	if loaded.backends["local"]["queue_capacity"] != fieldNull {
+		t.Fatalf("explicit null was not retained: %+v", loaded.backends["local"])
+	}
+}
+
+func TestLoadDefaultsAbsentQueueCapacity(t *testing.T) {
+	loaded, err := load(mapping("backend", map[string]any{"backends": map[string]any{
+		"local": map[string]any{"endpoint": "http://localhost:8080/v1", "concurrency_limit": 1},
+	}}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	backend := loaded.result.Config.Backends["local"]
+	if backend.QueueCapacity == nil || *backend.QueueCapacity != 1024 || loaded.backends["local"]["queue_capacity"] != fieldAbsent {
+		t.Fatalf("absent queue capacity did not receive its default: %+v", backend)
+	}
+}
+
+func TestLoadRejectsStrictGroupConflict(t *testing.T) {
+	_, err := load(configkit.Input{Source: configkit.NoSource()}, []configkit.Underlay{{Inputs: []configkit.Input{
+		mapping("first", map[string]any{"profiles": map[string]any{"shared": map[string]any{"model": "one"}}}),
+		mapping("second", map[string]any{"profiles": map[string]any{"shared": map[string]any{"model": "one"}}}),
+	}}})
+	var loadError *configkit.LoadError
+	if !errors.As(err, &loadError) {
+		t.Fatalf("expected ConfigKit load error, got %v", err)
+	}
+}
+
+func TestLoadValidatesOnlyFinalDomainValues(t *testing.T) {
+	underlay := mapping("defaults", map[string]any{
+		"backends": map[string]any{"local": map[string]any{"endpoint": "not a URL"}},
+		"profiles": map[string]any{"partial": map[string]any{"backend": "local"}},
+	})
+	main := mapping("operator", map[string]any{"backends": map[string]any{"local": map[string]any{"endpoint": "http://localhost:8080/v1"}}})
+	loaded, err := load(main, []configkit.Underlay{{Inputs: []configkit.Input{underlay}}})
+	if err != nil {
+		t.Fatalf("replaced lower-layer domain value should not fail: %v", err)
+	}
+	if loaded.result.Config.Profiles["partial"].Model != nil {
+		t.Fatal("unused partial profile unexpectedly gained a model")
+	}
+
+	_, err = load(configkit.Input{Source: configkit.NoSource()}, []configkit.Underlay{{Inputs: []configkit.Input{
+		mapping("invalid", map[string]any{"backends": map[string]any{"unused": map[string]any{"endpoint": "not a URL"}}}),
+	}}})
+	var loadError *configkit.LoadError
+	if !errors.As(err, &loadError) {
+		t.Fatalf("expected path-aware effective backend failure, got %v", err)
+	}
+	if diagnostics := loadError.Diagnostics(); len(diagnostics) != 1 || diagnostics[0].Path.String() != "/backends/unused/endpoint" {
+		t.Fatalf("expected endpoint diagnostic, got %+v", diagnostics)
+	}
+}
+
+func TestLoadKeepsSyntaxErrorsFromLowerTiers(t *testing.T) {
+	_, err := load(mapping("operator", map[string]any{"backends": map[string]any{"local": map[string]any{"endpoint": "http://localhost:8080"}}}),
+		[]configkit.Underlay{{Inputs: []configkit.Input{{Source: configkit.Bytes("broken", []byte("backends: ["))}}}})
+	var loadError *configkit.LoadError
+	if !errors.As(err, &loadError) {
+		t.Fatalf("expected lower-tier parsing error, got %v", err)
+	}
+}

internal/configuration/prompts.go

@@ -0,0 +1,424 @@
+package configuration
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"text/template"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+	"gitea.maximumdirect.net/eric/promptkit/internal/filecatalog"
+	"gitea.maximumdirect.net/eric/promptkit/internal/prompt"
+	"gitea.maximumdirect.net/eric/promptkit/internal/promptdef"
+)
+
+var (
+	errPromptNotFound  = errors.New("prompt definition not found")
+	errPromptAmbiguous = errors.New("prompt version is ambiguous")
+)
+
+type promptEntry struct {
+	definition        domain.PromptDefinition
+	inspection        domain.PromptInspection
+	requirementInputs []prompt.InputMetadata
+	hash              string
+	session           *template.Template
+	messages          []*template.Template
+}
+
+func resolvePrompts(prompts map[string]map[string]promptConfig, resolution *configkit.Resolution) {
+	for _, id := range sortedKeys(prompts) {
+		for _, version := range sortedKeys(prompts[id]) {
+			definition := prompts[id][version]
+			base := configkit.Keys("prompts", id, version)
+			for _, field := range []struct {
+				name  string
+				value **string
+			}{
+				{"description", &definition.Description},
+				{"session_id", &definition.SessionID},
+			} {
+				if *field.value != nil {
+					normalizeString(field.value, base.Key(field.name), resolution, strings.TrimSpace(**field.value))
+				}
+			}
+			inputsChanged := false
+			for index := range definition.Inputs {
+				input := &definition.Inputs[index]
+				inputPath := base.Key("inputs").Index(index)
+				normalizedName := strings.TrimSpace(input.Name)
+				if normalizedName != input.Name {
+					configkit.Normalize(resolution, inputPath.Key("name"), &input.Name, normalizedName, "normalize input metadata")
+					inputsChanged = true
+				}
+				for _, field := range []struct {
+					name  string
+					value **string
+				}{
+					{"content_type", &input.ContentType},
+					{"description", &input.Description},
+				} {
+					if *field.value != nil {
+						normalized := strings.TrimSpace(**field.value)
+						if normalized != **field.value {
+							configkit.Normalize(resolution, inputPath.Key(field.name), field.value, &normalized, "normalize input metadata")
+							inputsChanged = true
+						}
+					}
+				}
+			}
+			if inputsChanged {
+				resolution.Record(base.Key("inputs"), configkit.ChangeNormalization, "normalize input metadata")
+			}
+			// Normalize message metadata on execution-owned copies below. ConfigKit
+			// records sequence mutations as whole-value replacements, which would
+			// discard the effective source contexts of unchanged content_file fields.
+			if definition.Output != nil && definition.Output.SchemaPath != nil {
+				normalizeString(&definition.Output.SchemaPath, base.Key("output").Key("schema_path"), resolution, strings.TrimSpace(*definition.Output.SchemaPath))
+			}
+			prompts[id][version] = definition
+		}
+	}
+}
+
+func (state *loaded) materializePrompts() error {
+	state.prompts = make(map[string]map[string]*promptEntry, len(state.result.Config.Prompts))
+	state.ambiguous = make(map[string]bool)
+	var metadata *configkit.Metadata
+	lookupOrigin := func(path configkit.Path) (configkit.FieldInfo, bool) {
+		if metadata == nil {
+			captured := state.result.Metadata()
+			metadata = &captured
+		}
+		return metadata.Lookup(path)
+	}
+	for _, id := range sortedKeys(state.result.Config.Prompts) {
+		if strings.TrimSpace(id) == "" {
+			return fmt.Errorf("%s: prompt ID must not be blank", configkit.Keys("prompts", id))
+		}
+		versions := state.result.Config.Prompts[id]
+		if versions == nil {
+			return fmt.Errorf("%s: prompt collection must be a mapping", configkit.Keys("prompts", id))
+		}
+		state.prompts[id] = make(map[string]*promptEntry, len(versions))
+		state.ambiguous[id] = len(versions) > 1
+		for _, version := range sortedKeys(versions) {
+			if strings.TrimSpace(version) == "" {
+				return fmt.Errorf("%s: prompt version must not be blank", configkit.Keys("prompts", id, version))
+			}
+			entry, err := state.materializePrompt(id, version, versions[version], lookupOrigin)
+			if err != nil {
+				return err
+			}
+			state.prompts[id][version] = entry
+		}
+	}
+	return nil
+}
+
+func (state *loaded) materializePrompt(id, version string, raw promptConfig, lookupOrigin func(configkit.Path) (configkit.FieldInfo, bool)) (*promptEntry, error) {
+	base := configkit.Keys("prompts", id, version)
+	if len(raw.Messages) == 0 {
+		return nil, fmt.Errorf("%s: at least one message is required", base.Key("messages"))
+	}
+	definition := domain.PromptDefinition{ID: id, Version: version}
+	if raw.DefaultProfile != nil {
+		if strings.TrimSpace(*raw.DefaultProfile) == "" {
+			return nil, fmt.Errorf("%s: default profile must not be blank", base.Key("default_profile"))
+		}
+		definition.DefaultProfile = *raw.DefaultProfile
+	}
+	if raw.Description != nil {
+		definition.Description = *raw.Description
+	}
+	if raw.SessionID != nil {
+		definition.SessionID = *raw.SessionID
+	}
+	seenInputs := make(map[string]bool, len(raw.Inputs))
+	definition.Inputs = make([]domain.PromptInput, 0, len(raw.Inputs))
+	entry := &promptEntry{
+		messages:          make([]*template.Template, 0, len(raw.Messages)),
+		requirementInputs: make([]prompt.InputMetadata, 0, len(raw.Inputs)),
+	}
+	for index, input := range raw.Inputs {
+		path := base.Key("inputs").Index(index)
+		if input.Name == "" {
+			return nil, fmt.Errorf("%s: input name is required", path.Key("name"))
+		}
+		if seenInputs[input.Name] {
+			return nil, fmt.Errorf("%s: input name is duplicated", path.Key("name"))
+		}
+		seenInputs[input.Name] = true
+		contentType := ""
+		if input.ContentType != nil {
+			contentType = *input.ContentType
+		}
+		description := ""
+		if input.Description != nil {
+			description = *input.Description
+		}
+		definition.Inputs = append(definition.Inputs, domain.PromptInput{
+			Name: input.Name, Required: input.Required, ContentType: contentType, Description: description,
+		})
+		presence := state.promptMetadata[id][version][index]
+		metadata := prompt.InputMetadata{Name: input.Name, Required: input.Required}
+		if presence.contentType == fieldValue {
+			metadata.ContentType = stringPointer(contentType)
+		}
+		if presence.description == fieldValue {
+			metadata.Description = stringPointer(description)
+		}
+		entry.requirementInputs = append(entry.requirementInputs, metadata)
+	}
+	definition.Templates = make([]domain.PromptMessageTemplate, 0, len(raw.Messages))
+	for index, message := range raw.Messages {
+		path := base.Key("messages").Index(index)
+		if message.Role == nil {
+			return nil, fmt.Errorf("%s: role is required", path.Key("role"))
+		}
+		role, err := domain.NormalizeMessageRole(*message.Role)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", path.Key("role"), err)
+		}
+		if (message.Content != nil) == (message.ContentFile != nil) {
+			return nil, fmt.Errorf("%s: exactly one of content or content_file is required", path)
+		}
+		content := ""
+		if message.Content != nil {
+			content = *message.Content
+		} else {
+			var err error
+			content, err = state.readContent(path.Key("content_file"), *message.ContentFile, lookupOrigin)
+			if err != nil {
+				return nil, err
+			}
+		}
+		var control *domain.CacheControl
+		if message.CacheControl != nil {
+			if message.CacheControl.Type == nil {
+				return nil, fmt.Errorf("%s: type is required", path.Key("cache_control").Key("type"))
+			}
+			control = &domain.CacheControl{Type: domain.CacheControlType(*message.CacheControl.Type)}
+			if message.CacheControl.TTL != nil {
+				control.TTL = *message.CacheControl.TTL
+			}
+			var err error
+			control, err = domain.NormalizeCacheControl(control)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", path.Key("cache_control"), err)
+			}
+		}
+		compiled, err := prompt.CompileTemplate(fmt.Sprintf("msg_%d", index), content)
+		if err != nil {
+			return nil, fmt.Errorf("%s: invalid template syntax: %w", path, err)
+		}
+		entry.messages = append(entry.messages, compiled)
+		definition.Templates = append(definition.Templates, domain.PromptMessageTemplate{
+			Role: role, Content: content, CacheControl: control,
+		})
+	}
+	if raw.Output == nil {
+		return nil, fmt.Errorf("%s: output is required", base.Key("output"))
+	}
+	if raw.Output.Format == nil || raw.Output.ValidationMode == nil {
+		return nil, fmt.Errorf("%s: format and validation_mode are required", base.Key("output"))
+	}
+	contract := domain.OutputContract{
+		Format:         domain.OutputFormat(*raw.Output.Format),
+		ValidationMode: domain.ValidationMode(*raw.Output.ValidationMode),
+		RepairAttempts: raw.Output.RepairAttempts,
+	}
+	if raw.Output.SchemaPath != nil {
+		contract.SchemaPath = *raw.Output.SchemaPath
+	}
+	if err := domain.ValidateOutputContract(contract); err != nil {
+		return nil, fmt.Errorf("%s: invalid output contract: %w", base.Key("output"), err)
+	}
+	definition.OutputFormat = contract.Format
+	definition.Validation = contract
+	if raw.SessionID != nil {
+		var err error
+		entry.session, err = prompt.CompileTemplate("session_id", definition.SessionID)
+		if err != nil {
+			return nil, fmt.Errorf("%s: invalid template syntax: %w", base.Key("session_id"), err)
+		}
+	}
+	hash, err := promptdef.HashDefinition(&definition)
+	if err != nil {
+		return nil, fmt.Errorf("%s: hash prompt definition: %w", base, err)
+	}
+	entry.definition = definition
+	entry.hash = hash
+	entry.inspection = domain.PromptInspection{
+		PromptID: id, PromptVersion: version, PromptHash: hash,
+		DefaultProfileID: definition.DefaultProfile, Inputs: append([]domain.PromptInput(nil), definition.Inputs...),
+		OutputContract: contract,
+	}
+	return entry, nil
+}
+
+func stringPointer(value string) *string {
+	copy := value
+	return &copy
+}
+
+func (state *loaded) readContent(fieldPath configkit.Path, name string, lookupOrigin func(configkit.Path) (configkit.FieldInfo, bool)) (string, error) {
+	if strings.TrimSpace(name) == "" {
+		return "", fmt.Errorf("%s: content_file path must not be blank", fieldPath)
+	}
+	field, found := lookupOrigin(fieldPath)
+	if !found || len(field.Origin.Locations) != 1 {
+		return "", fmt.Errorf("%s: content_file needs one contributing source with a filesystem context", fieldPath)
+	}
+	sourceID := field.Origin.Locations[0].SourceID
+	context, found := state.result.SourceContext(sourceID)
+	if !found || context.FS == nil {
+		return "", fmt.Errorf("%s: content_file source %s has no filesystem context", fieldPath, sourceID)
+	}
+	resolved, _, err := filecatalog.ResolveFSPath(".", context.BaseDir, name)
+	if err != nil {
+		return "", fmt.Errorf("%s: content_file path is outside its source root or invalid: %w", fieldPath, err)
+	}
+	file, err := context.FS.Open(resolved)
+	if err != nil {
+		return "", fmt.Errorf("%s: open content_file from source %s: %w", fieldPath, sourceID, err)
+	}
+	content, readErr := io.ReadAll(file)
+	closeErr := file.Close()
+	if readErr != nil {
+		return "", fmt.Errorf("%s: read content_file from source %s: %w", fieldPath, sourceID, readErr)
+	}
+	if closeErr != nil {
+		return "", fmt.Errorf("%s: close content_file from source %s: %w", fieldPath, sourceID, closeErr)
+	}
+	return string(content), nil
+}
+
+func (state *loaded) lookupPromptEntry(id, version string) (*promptEntry, error) {
+	if state == nil || strings.TrimSpace(id) == "" || (version != "" && strings.TrimSpace(version) == "") {
+		return nil, errPromptNotFound
+	}
+	versions := state.prompts[id]
+	if version == "" {
+		if state.ambiguous[id] {
+			return nil, errPromptAmbiguous
+		}
+		for selected := range versions {
+			version = selected
+		}
+	}
+	entry := versions[version]
+	if entry == nil {
+		return nil, errPromptNotFound
+	}
+	return entry, nil
+}
+
+func ownPromptDefinition(definition domain.PromptDefinition) *domain.PromptDefinition {
+	definition.Inputs = append([]domain.PromptInput(nil), definition.Inputs...)
+	definition.Templates = append([]domain.PromptMessageTemplate(nil), definition.Templates...)
+	for index := range definition.Templates {
+		if control := definition.Templates[index].CacheControl; control != nil {
+			copy := *control
+			definition.Templates[index].CacheControl = &copy
+		}
+	}
+	return &definition
+}
+
+func ownPromptInspection(inspection domain.PromptInspection) *domain.PromptInspection {
+	inspection.Inputs = append([]domain.PromptInput(nil), inspection.Inputs...)
+	return &inspection
+}
+
+func promptLookupError(err error) error {
+	if errors.Is(err, errPromptNotFound) {
+		return promptdef.ErrPromptDefinitionNotFound
+	}
+	return err
+}
+
+func (state *loaded) prompt(id, version string) (*domain.PromptDefinition, domain.PromptInspection, error) {
+	entry, err := state.lookupPromptEntry(id, version)
+	if err != nil {
+		return nil, domain.PromptInspection{}, err
+	}
+	return ownPromptDefinition(entry.definition), *ownPromptInspection(entry.inspection), nil
+}
+
+// GetPromptSnapshot returns an independently owned captured definition and its
+// construction-time hash. Lookup retains literal ID and version keys.
+func (state *loaded) GetPromptSnapshot(ctx context.Context, id, version string) (*domain.PromptDefinition, string, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, "", err
+	}
+	entry, err := state.lookupPromptEntry(id, version)
+	if err != nil {
+		return nil, "", promptLookupError(err)
+	}
+	return ownPromptDefinition(entry.definition), entry.hash, nil
+}
+
+// GetPromptInspection returns an independently owned inspection of one
+// captured prompt without copying its execution templates.
+func (state *loaded) GetPromptInspection(ctx context.Context, id, version string) (*domain.PromptInspection, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	entry, err := state.lookupPromptEntry(id, version)
+	if err != nil {
+		return nil, promptLookupError(err)
+	}
+	return ownPromptInspection(entry.inspection), nil
+}
+
+// GetPromptDefinition implements the runner's prompt lookup boundary.
+func (state *loaded) GetPromptDefinition(ctx context.Context, id, version string) (*domain.PromptDefinition, error) {
+	definition, _, err := state.GetPromptSnapshot(ctx, id, version)
+	return definition, err
+}
+
+// GetCompiledTemplates returns construction-time parses for one exact prompt.
+func (state *loaded) GetCompiledTemplates(id, version string) (prompt.CompiledTemplates, bool) {
+	if state == nil {
+		return prompt.CompiledTemplates{}, false
+	}
+	entry := state.prompts[id][version]
+	if entry == nil {
+		return prompt.CompiledTemplates{}, false
+	}
+	return prompt.CompiledTemplates{Session: entry.session, Messages: entry.messages}, true
+}
+
+// GetRequirementSnapshot returns captured templates and input metadata for
+// one exact prompt identity. Returned metadata and slices are independently
+// owned; the compiled templates are shared immutable construction-time parses.
+func (state *loaded) GetRequirementSnapshot(id, version string) (prompt.RequirementSnapshot, bool) {
+	if state == nil {
+		return prompt.RequirementSnapshot{}, false
+	}
+	entry := state.prompts[id][version]
+	if entry == nil {
+		return prompt.RequirementSnapshot{}, false
+	}
+	snapshot := prompt.RequirementSnapshot{
+		Templates: prompt.CompiledTemplates{
+			Session:  entry.session,
+			Messages: append([]*template.Template(nil), entry.messages...),
+		},
+		Inputs: make([]prompt.InputMetadata, len(entry.requirementInputs)),
+	}
+	for index, input := range entry.requirementInputs {
+		snapshot.Inputs[index] = input
+		if input.ContentType != nil {
+			snapshot.Inputs[index].ContentType = stringPointer(*input.ContentType)
+		}
+		if input.Description != nil {
+			snapshot.Inputs[index].Description = stringPointer(*input.Description)
+		}
+	}
+	return snapshot, true
+}

internal/configuration/prompts_test.go

@@ -0,0 +1,403 @@
+package configuration
+
+import (
+	"context"
+	"errors"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"testing/fstest"
+
+	"gitea.maximumdirect.net/eric/ConfigKit"
+	"gitea.maximumdirect.net/eric/promptkit/internal/promptdef"
+)
+
+func TestLoadCapturesInheritedImportedContent(t *testing.T) {
+	files := fstest.MapFS{
+		"app/main.yaml":     {Data: []byte("configkit:\n  imports:\n    - path: ../catalog/base.yaml\nprompts:\n  child:\n    extends: base\n")},
+		"catalog/base.yaml": {Data: []byte("prompts:\n  base:\n    v1:\n      messages:\n        - role: ' USER '\n          cache_control:\n            type: ' ephemeral '\n            ttl: ' 1h '\n          content_file: ./body.md\n      output:\n        format: text\n        validation_mode: basic\n")},
+		"catalog/body.md":   {Data: []byte("Captured {{.name}}")},
+	}
+	namespace := configkit.NewFilesystem("embedded", files)
+	state, err := load(configkit.Input{
+		Source: namespace.File("app/main.yaml"), Imports: true,
+		Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: "."},
+	}, nil)
+	if err != nil {
+		var loadError *configkit.LoadError
+		if errors.As(err, &loadError) {
+			t.Fatalf("%v: %+v", err, loadError.Diagnostics())
+		}
+		t.Fatal(err)
+	}
+	definition, inspection, err := state.prompt("child", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if definition.Templates[0].Content != "Captured {{.name}}" || inspection.PromptHash == "" {
+		t.Fatalf("inherited file content was not captured: %+v, %+v", definition, inspection)
+	}
+	message := definition.Templates[0]
+	if message.Role != "user" || message.CacheControl == nil || message.CacheControl.Type != "ephemeral" || message.CacheControl.TTL != "1h" {
+		t.Fatalf("message metadata was not normalized: %+v", message)
+	}
+	field, ok := state.result.Metadata().Lookup(configkit.Keys("prompts", "child", "v1", "messages").Index(0).Key("content_file"))
+	if !ok || len(field.Origin.Locations) != 1 {
+		t.Fatalf("content origin was lost during normalization: %+v", field)
+	}
+	var originPath string
+	for _, source := range state.result.Sources() {
+		if source.ID == field.Origin.Locations[0].SourceID {
+			originPath = source.Path
+		}
+	}
+	if originPath != "catalog/base.yaml" {
+		t.Fatalf("content origin = %q, want catalog/base.yaml", originPath)
+	}
+	files["catalog/body.md"].Data = []byte("Changed")
+	again, againInspection, err := state.prompt("child", "v1")
+	if err != nil || again.Templates[0].Content != "Captured {{.name}}" || againInspection.PromptHash != inspection.PromptHash {
+		t.Fatalf("captured definition changed after source mutation: %+v, %+v, %v", again, againInspection, err)
+	}
+	definition.Templates[0].Content = "caller mutation"
+	third, _, err := state.prompt("child", "v1")
+	if err != nil || third.Templates[0].Content != "Captured {{.name}}" {
+		t.Fatalf("caller mutation escaped into index: %+v, %v", third, err)
+	}
+}
+
+func TestLoadUsesExplicitMappingContextAndClosesContent(t *testing.T) {
+	filesystem := &countingFS{FS: fstest.MapFS{
+		"assets/body.md": {Data: []byte("From mapping")},
+	}}
+	namespace := configkit.NewFilesystem("mapping-context", filesystem)
+	source := configkit.Mapping("application", promptWithFile("body.md"))
+	state, err := load(configkit.Input{
+		Source:     source,
+		Filesystem: &configkit.FilesystemContext{FS: &namespace, Root: ".", BaseDir: "assets"},
+	}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	definition, _, err := state.prompt("example", "v1")
+	if err != nil || definition.Templates[0].Content != "From mapping" || filesystem.contentOpened != 1 || filesystem.contentClosed != 1 {
+		t.Fatalf("mapping context or handle ownership failed: %+v, opens=%d closes=%d, %v", definition, filesystem.contentOpened, filesystem.contentClosed, err)
+	}
+	_, err = load(mapping("contextless", promptWithFile("body.md")), nil)
+	if err == nil || !strings.Contains(err.Error(), "/prompts/example/v1/messages/0/content_file") {
+		t.Fatalf("expected semantic path for contextless resource, got %v", err)
+	}
+}
+
+func TestLoadCapturesNativeContentFile(t *testing.T) {
+	root := t.TempDir()
+	definitionPath := filepath.Join(root, "definition.yaml")
+	contentPath := filepath.Join(root, "body.md")
+	if err := os.WriteFile(definitionPath, []byte("prompts:\n  example:\n    v1:\n      messages:\n        - role: user\n          content_file: body.md\n      output:\n        format: text\n        validation_mode: basic\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(contentPath, []byte("Native body"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	state, err := load(configkit.Input{Source: configkit.File(definitionPath), Filesystem: &configkit.FilesystemContext{Root: root}}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(contentPath, []byte("Modified"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	definition, _, err := state.prompt("example", "v1")
+	if err != nil || definition.Templates[0].Content != "Native body" {
+		t.Fatalf("native content was not captured: %+v, %v", definition, err)
+	}
+}
+
+func TestLoadRejectsMalformedStaticSyntaxAndAmbiguousSelection(t *testing.T) {
+	_, err := load(mapping("bad-template", map[string]any{"prompts": map[string]any{"example": map[string]any{
+		"v1": map[string]any{"messages": []any{map[string]any{"role": "user", "content": "{{if}}"}},
+			"output": map[string]any{"format": "text", "validation_mode": "basic"}},
+	}}}), nil)
+	if err == nil || !strings.Contains(err.Error(), "invalid template syntax") {
+		t.Fatalf("expected construction-time syntax error, got %v", err)
+	}
+	state, err := load(mapping("versions", map[string]any{"prompts": map[string]any{"example": map[string]any{
+		"v1": map[string]any{"messages": []any{map[string]any{"role": "user", "content": "one"}},
+			"output": map[string]any{"format": "text", "validation_mode": "basic"}},
+		"v2": map[string]any{"messages": []any{map[string]any{"role": "user", "content": "two"}},
+			"output": map[string]any{"format": "text", "validation_mode": "basic"}},
+	}}}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, _, err := state.prompt("example", ""); !errors.Is(err, errPromptAmbiguous) {
+		t.Fatalf("expected ambiguous version selection, got %v", err)
+	}
+}
+
+func TestPromptInspectionLookupMatchesSnapshotSelectionAndOwnsInputs(t *testing.T) {
+	makePrompt := func(content string) map[string]any {
+		return map[string]any{
+			"default_profile": "partial",
+			"inputs": []any{map[string]any{
+				"name": "document", "required": true,
+				"content_type": " text/plain ", "description": " source document ",
+			}},
+			"messages": []any{map[string]any{"role": "user", "content": content}},
+			"output":   map[string]any{"format": "text", "validation_mode": "none"},
+		}
+	}
+	state, err := load(mapping("prompt inspection lookup", map[string]any{
+		"profiles": map[string]any{"partial": map[string]any{}},
+		"prompts": map[string]any{
+			"multi":  map[string]any{"v1": makePrompt("first"), "v2": makePrompt("second")},
+			"single": map[string]any{"v1": makePrompt("only")},
+		},
+	}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, selection := range []struct {
+		id, version string
+	}{
+		{id: "multi", version: "v2"},
+		{id: "single"},
+	} {
+		inspection, err := state.GetPromptInspection(context.Background(), selection.id, selection.version)
+		if err != nil {
+			t.Fatalf("inspect %q/%q: %v", selection.id, selection.version, err)
+		}
+		definition, hash, err := state.GetPromptSnapshot(context.Background(), selection.id, selection.version)
+		if err != nil {
+			t.Fatalf("snapshot %q/%q: %v", selection.id, selection.version, err)
+		}
+		if inspection.PromptID != definition.ID || inspection.PromptVersion != definition.Version ||
+			inspection.PromptHash != hash || inspection.DefaultProfileID != "partial" ||
+			len(inspection.Inputs) != 1 || inspection.Inputs[0].Name != "document" ||
+			inspection.Inputs[0].ContentType != "text/plain" || inspection.Inputs[0].Description != "source document" {
+			t.Fatalf("inspection did not match the selected snapshot: inspection=%+v definition=%+v hash=%q", inspection, definition, hash)
+		}
+		if len(definition.Inputs) != len(inspection.Inputs) || definition.Inputs[0].Name != inspection.Inputs[0].Name {
+			t.Fatalf("definition and inspection inputs diverged: definition=%+v inspection=%+v", definition.Inputs, inspection.Inputs)
+		}
+	}
+
+	owned, err := state.GetPromptInspection(context.Background(), "single", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	owned.Inputs[0].Name = "caller mutation"
+	owned.Inputs[0].Description = "caller mutation"
+	again, err := state.GetPromptInspection(context.Background(), "single", "v1")
+	if err != nil || again.Inputs[0].Name != "document" || again.Inputs[0].Description != "source document" {
+		t.Fatalf("inspection mutation escaped into captured state: inspection=%+v err=%v", again, err)
+	}
+
+	for _, selection := range []struct {
+		id, version string
+	}{
+		{id: "missing", version: "v1"},
+		{id: "multi", version: "V2"},
+		{id: " ", version: "v1"},
+	} {
+		inspection, err := state.GetPromptInspection(context.Background(), selection.id, selection.version)
+		if inspection != nil || !errors.Is(err, promptdef.ErrPromptDefinitionNotFound) {
+			t.Errorf("inspection selection %q/%q=(%+v, %v), want not found", selection.id, selection.version, inspection, err)
+		}
+		definition, _, err := state.GetPromptSnapshot(context.Background(), selection.id, selection.version)
+		if definition != nil || !errors.Is(err, promptdef.ErrPromptDefinitionNotFound) {
+			t.Errorf("snapshot selection %q/%q=(%+v, %v), want not found", selection.id, selection.version, definition, err)
+		}
+	}
+	if _, err := state.GetPromptInspection(context.Background(), "multi", ""); !errors.Is(err, errPromptAmbiguous) {
+		t.Errorf("ambiguous inspection selection error=%v", err)
+	}
+	if _, _, err := state.GetPromptSnapshot(context.Background(), "multi", ""); !errors.Is(err, errPromptAmbiguous) {
+		t.Errorf("ambiguous snapshot selection error=%v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := state.GetPromptInspection(ctx, "single", "v1"); !errors.Is(err, context.Canceled) {
+		t.Errorf("canceled inspection selection error=%v", err)
+	}
+}
+
+func TestLoadAcceptsEmptyInlineContentAndRejectsInvalidPromptFields(t *testing.T) {
+	state, err := load(mapping("empty-content", map[string]any{"prompts": map[string]any{" exact.id ": map[string]any{"v1": map[string]any{
+		"inputs": []any{map[string]any{"name": " note ", "required": true}},
+		"messages": []any{map[string]any{"role": " USER ", "content": "", "content_file": nil,
+			"cache_control": map[string]any{"type": " ephemeral ", "ttl": "1h "}}},
+		"output": map[string]any{"format": "text", "validation_mode": "basic"},
+	}}}}), nil)
+	if err != nil {
+		var loadError *configkit.LoadError
+		if errors.As(err, &loadError) {
+			t.Fatalf("%v: %+v", err, loadError.Diagnostics())
+		}
+		t.Fatal(err)
+	}
+	definition, _, err := state.prompt(" exact.id ", "v1")
+	if err != nil || definition.ID != " exact.id " || definition.Templates[0].Content != "" || definition.Templates[0].Role != "user" ||
+		definition.Inputs[0].Name != "note" || definition.Templates[0].CacheControl.TTL != "1h" {
+		t.Fatalf("explicit empty content or literal ID was changed: %+v, %v", definition, err)
+	}
+	if _, _, err := state.prompt("exact.id", "v1"); !errors.Is(err, errPromptNotFound) {
+		t.Fatalf("trimmed prompt identity unexpectedly matched: %v", err)
+	}
+	_, err = load(mapping("obsolete-field", map[string]any{"prompts": map[string]any{"example": map[string]any{"v1": map[string]any{
+		"id": "example", "messages": []any{map[string]any{"role": "user", "content": "ok"}},
+		"output": map[string]any{"format": "text", "validation_mode": "basic"},
+	}}}}), nil)
+	var loadError *configkit.LoadError
+	if !errors.As(err, &loadError) {
+		t.Fatalf("obsolete identity field should fail strict decoding: %v", err)
+	}
+	_, err = load(mapping("null-prompt", map[string]any{"prompts": map[string]any{"example": nil}}), nil)
+	if err == nil {
+		t.Fatal("null prompt collection was accepted")
+	}
+}
+
+func TestRequirementSnapshotCapturesMetadataPresenceAndNormalizedValues(t *testing.T) {
+	state, err := load(mapping("requirement-metadata", map[string]any{
+		"prompts": map[string]any{"example": map[string]any{"v1": map[string]any{
+			"session_id": "{{.session}}",
+			"inputs": []any{
+				map[string]any{"name": "absent"},
+				map[string]any{"name": "null", "content_type": nil, "description": nil},
+				map[string]any{"name": "empty", "content_type": "", "description": ""},
+				map[string]any{"name": "normalized", "content_type": " text/plain ", "description": "  final text  "},
+			},
+			"messages": []any{map[string]any{"role": "user", "content": "{{input \"absent\"}}"}},
+			"output":   map[string]any{"format": "text", "validation_mode": "basic"},
+		}}},
+	}), nil)
+	if err != nil {
+		var loadError *configkit.LoadError
+		if errors.As(err, &loadError) {
+			t.Fatalf("%v: %+v", err, loadError.Diagnostics())
+		}
+		t.Fatal(err)
+	}
+
+	snapshot, ok := state.GetRequirementSnapshot("example", "v1")
+	if !ok || len(snapshot.Inputs) != 4 || len(snapshot.Templates.Messages) != 1 || snapshot.Templates.Session == nil {
+		t.Fatalf("requirement snapshot was not captured: %+v, %t", snapshot, ok)
+	}
+	for _, index := range []int{0, 1} {
+		if snapshot.Inputs[index].ContentType != nil || snapshot.Inputs[index].Description != nil {
+			t.Errorf("input %q should not have explicit string metadata: %+v", snapshot.Inputs[index].Name, snapshot.Inputs[index])
+		}
+	}
+	if snapshot.Inputs[2].ContentType == nil || *snapshot.Inputs[2].ContentType != "" ||
+		snapshot.Inputs[2].Description == nil || *snapshot.Inputs[2].Description != "" {
+		t.Errorf("explicit empty metadata presence was lost: %+v", snapshot.Inputs[2])
+	}
+	if snapshot.Inputs[3].ContentType == nil || *snapshot.Inputs[3].ContentType != "text/plain" ||
+		snapshot.Inputs[3].Description == nil || *snapshot.Inputs[3].Description != "final text" {
+		t.Errorf("snapshot did not use normalized final metadata: %+v", snapshot.Inputs[3])
+	}
+
+	definition, inspection, err := state.prompt("example", "v1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(definition.Inputs) != 4 || len(inspection.Inputs) != 4 || inspection.Inputs[2].ContentType != "" || inspection.Inputs[2].Description != "" ||
+		inspection.Inputs[3].ContentType != "text/plain" || inspection.Inputs[3].Description != "final text" {
+		t.Fatalf("existing prompt inspection shape or normalized values changed: %+v", inspection)
+	}
+
+	*snapshot.Inputs[2].ContentType = "caller mutation"
+	snapshot.Inputs[3].Name = "caller mutation"
+	snapshot.Templates.Messages[0] = nil
+	again, ok := state.GetRequirementSnapshot("example", "v1")
+	if !ok || *again.Inputs[2].ContentType != "" || again.Inputs[3].Name != "normalized" || again.Templates.Messages[0] == nil {
+		t.Fatalf("snapshot mutation escaped into captured state: %+v, %t", again, ok)
+	}
+	if _, ok := state.GetRequirementSnapshot("example", "V1"); ok {
+		t.Fatal("snapshot lookup unexpectedly changed exact version matching")
+	}
+}
+
+func TestInputMetadataPresenceDoesNotChangePromptHashOrInspection(t *testing.T) {
+	variants := []struct {
+		name   string
+		fields map[string]any
+	}{
+		{name: "absent"},
+		{name: "null", fields: map[string]any{"content_type": nil, "description": nil}},
+		{name: "empty", fields: map[string]any{"content_type": "", "description": ""}},
+	}
+	var expectedHash string
+	for _, variant := range variants {
+		t.Run(variant.name, func(t *testing.T) {
+			input := map[string]any{"name": "document"}
+			for name, value := range variant.fields {
+				input[name] = value
+			}
+			state, err := load(mapping("hash-"+variant.name, map[string]any{
+				"prompts": map[string]any{"same": map[string]any{"v1": map[string]any{
+					"inputs":   []any{input},
+					"messages": []any{map[string]any{"role": "user", "content": "hello"}},
+					"output":   map[string]any{"format": "text", "validation_mode": "basic"},
+				}}},
+			}), nil)
+			if err != nil {
+				var loadError *configkit.LoadError
+				if errors.As(err, &loadError) {
+					t.Fatalf("%v: %+v", err, loadError.Diagnostics())
+				}
+				t.Fatal(err)
+			}
+			_, inspection, err := state.prompt("same", "v1")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(inspection.Inputs) != 1 || inspection.Inputs[0].ContentType != "" || inspection.Inputs[0].Description != "" {
+				t.Fatalf("old inspection metadata changed: %+v", inspection.Inputs)
+			}
+			if expectedHash == "" {
+				expectedHash = inspection.PromptHash
+			} else if inspection.PromptHash != expectedHash {
+				t.Fatalf("metadata presence changed the definition hash: got %q, want %q", inspection.PromptHash, expectedHash)
+			}
+		})
+	}
+}
+
+func promptWithFile(name string) map[string]any {
+	return map[string]any{"prompts": map[string]any{"example": map[string]any{"v1": map[string]any{
+		"messages": []any{map[string]any{"role": "user", "content_file": name}},
+		"output":   map[string]any{"format": "text", "validation_mode": "basic"},
+	}}}}
+}
+
+type countingFS struct {
+	fs.FS
+	contentOpened int
+	contentClosed int
+}
+
+func (filesystem *countingFS) Open(name string) (fs.File, error) {
+	file, err := filesystem.FS.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	if name == "assets/body.md" {
+		filesystem.contentOpened++
+		return &countingFile{File: file, owner: filesystem}, nil
+	}
+	return file, nil
+}
+
+type countingFile struct {
+	fs.File
+	owner *countingFS
+}
+
+func (file *countingFile) Close() error {
+	file.owner.contentClosed++
+	return file.File.Close()
+}

internal/configuration/targets.go

@@ -0,0 +1,204 @@
+package configuration
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
+	"gitea.maximumdirect.net/eric/promptkit/internal/defaults"
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
+	profilepkg "gitea.maximumdirect.net/eric/promptkit/internal/profile"
+)
+
+func (state *loaded) buildExecutionProfiles() error {
+	definitions := make(map[string]domain.Backend, len(state.result.Config.Backends))
+	for _, id := range sortedKeys(state.result.Config.Backends) {
+		config := state.result.Config.Backends[id]
+		params, err := jsonvalue.CopyMap(config.ExtraParams)
+		if err != nil {
+			return fmt.Errorf("backend %q extra parameters: %w", id, err)
+		}
+		definition := domain.Backend{ID: id, ExtraParams: params}
+		if config.Endpoint != nil {
+			definition.Endpoint = *config.Endpoint
+		}
+		if config.APIKeyEnv != nil {
+			definition.APIKeyEnv = *config.APIKeyEnv
+		}
+		if config.ConcurrencyLimit != nil {
+			definition.ConcurrencyLimit = *config.ConcurrencyLimit
+		}
+		if config.QueueCapacity != nil {
+			definition.QueueCapacity = *config.QueueCapacity
+			definition.QueueCapacitySet = definition.ConcurrencyLimit > 0
+		}
+		definitions[id] = definition
+	}
+	registry, err := backend.NewEffectiveRegistry(definitions)
+	if err != nil {
+		return err
+	}
+	state.registry = registry
+	state.indexedProfiles = make(map[string]domain.ExecutionProfile, len(state.result.Config.Profiles))
+	for _, id := range sortedKeys(state.result.Config.Profiles) {
+		config := state.result.Config.Profiles[id]
+		fields := state.profiles[id]
+		target := defaults.ExecutionTargetDefault()
+		if config.Backend != nil && *config.Backend != "" {
+			selected, err := registry.GetBackend(*config.Backend)
+			if err != nil {
+				return fmt.Errorf("profile %q backend: %w", id, err)
+			}
+			target.BackendID = selected.ID
+			target.Endpoint = selected.Endpoint
+			target.APIKeyEnv = selected.APIKeyEnv
+			target.ExtraParams = selected.ExtraParams
+		}
+		presence := domain.ExecutionTargetPresence{}
+		if fields["endpoint"] != fieldAbsent {
+			target.Endpoint = valueOrZero(config.Endpoint)
+		}
+		if fields["model"] != fieldAbsent {
+			target.Model = valueOrZero(config.Model)
+		}
+		if fields["temperature"] != fieldAbsent {
+			target.Temperature = valueOrZero(config.Temperature)
+			presence.Temperature = fields["temperature"] == fieldValue
+		}
+		if fields["top_p"] != fieldAbsent {
+			target.TopP = valueOrZero(config.TopP)
+			presence.TopP = fields["top_p"] == fieldValue
+		}
+		if fields["max_tokens"] != fieldAbsent {
+			target.MaxTokens = valueOrZero(config.MaxTokens)
+			presence.MaxTokens = fields["max_tokens"] == fieldValue
+		}
+		if fields["timeout_seconds"] == fieldValue {
+			target.TimeoutSeconds = valueOrZero(config.TimeoutSeconds)
+			presence.TimeoutSeconds = true
+		}
+		if fields["service_tier"] != fieldAbsent {
+			target.ServiceTier = valueOrZero(config.ServiceTier)
+		}
+		if fields["reasoning_effort"] != fieldAbsent {
+			target.ReasoningEffort = valueOrZero(config.ReasoningEffort)
+		}
+		if fields["api_key_env"] != fieldAbsent {
+			target.APIKeyEnv = valueOrZero(config.APIKeyEnv)
+		}
+		if fields["api_key_required"] != fieldAbsent {
+			target.APIKeyRequired = valueOrZero(config.APIKeyRequired)
+		}
+		if target.APIKeyRequired && fields["api_key_env"] == fieldAbsent {
+			target.APIKeyEnv = ""
+		}
+		switch fields["extra_params"] {
+		case fieldNull:
+			target.ExtraParams = nil
+		case fieldValue:
+			merged, err := overlayProviderMap(target.ExtraParams, config.ExtraParams)
+			if err != nil {
+				return fmt.Errorf("profile %q extra parameters: %w", id, err)
+			}
+			target.ExtraParams = merged
+		}
+		profile := domain.ExecutionProfile{ID: id, ResolvedTarget: &target, TargetPresence: presence}
+		state.indexedProfiles[id] = profile
+	}
+	return nil
+}
+
+func valueOrZero[T any](value *T) T {
+	if value == nil {
+		var zero T
+		return zero
+	}
+	return *value
+}
+
+// overlayProviderMap applies only the backend-to-profile JSON-object default
+// merge. ConfigKit has already resolved source layering and inheritance.
+func overlayProviderMap(lower, upper map[string]any) (map[string]any, error) {
+	merged, err := jsonvalue.CopyMap(lower)
+	if err != nil {
+		return nil, err
+	}
+	if merged == nil {
+		merged = make(map[string]any)
+	}
+	for key, value := range upper {
+		if child, ok := value.(map[string]any); ok {
+			if existing, ok := merged[key].(map[string]any); ok {
+				combined, err := overlayProviderMap(existing, child)
+				if err != nil {
+					return nil, err
+				}
+				merged[key] = combined
+				continue
+			}
+		}
+		copied, err := jsonvalue.Copy(value)
+		if err != nil {
+			return nil, err
+		}
+		merged[key] = copied
+	}
+	return merged, nil
+}
+
+func (state *loaded) lookupProfile(ctx context.Context, id string) (domain.ExecutionProfile, error) {
+	if err := ctx.Err(); err != nil {
+		return domain.ExecutionProfile{}, err
+	}
+	if state == nil {
+		return domain.ExecutionProfile{}, fmt.Errorf("%w: %q", profilepkg.ErrProfileNotFound, id)
+	}
+	profile, found := state.indexedProfiles[id]
+	if !found {
+		return domain.ExecutionProfile{}, fmt.Errorf("%w: %q", profilepkg.ErrProfileNotFound, id)
+	}
+	return profile, nil
+}
+
+// GetProfile returns an independently owned indexed profile for the internal
+// runner's lookup boundary.
+func (state *loaded) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
+	profile, err := state.lookupProfile(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	target := *profile.ResolvedTarget
+	params, err := jsonvalue.CopyMap(target.ExtraParams)
+	if err != nil {
+		return nil, err
+	}
+	target.ExtraParams = params
+	profile.ResolvedTarget = &target
+	return &profile, nil
+}
+
+// GetProfileIdentity returns the exact lookup ID for a captured profile
+// without copying its execution target.
+func (state *loaded) GetProfileIdentity(ctx context.Context, id string) (string, error) {
+	if _, err := state.lookupProfile(ctx, id); err != nil {
+		return "", err
+	}
+	return id, nil
+}
+
+// GetBackend returns an independently owned effective backend definition.
+func (state *loaded) GetBackend(id string) (domain.Backend, error) {
+	if state == nil {
+		return domain.Backend{}, fmt.Errorf("backend registry is not configured")
+	}
+	return state.registry.GetBackend(id)
+}
+
+// CapacityPolicies returns the selected backend admission policies.
+func (state *loaded) CapacityPolicies() map[string]domain.BackendCapacityPolicy {
+	if state == nil {
+		return nil
+	}
+	return state.registry.CapacityPolicies()
+}

internal/configuration/targets_test.go

@@ -0,0 +1,166 @@
+package configuration
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/defaults"
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+	"gitea.maximumdirect.net/eric/promptkit/internal/llm"
+	profilepkg "gitea.maximumdirect.net/eric/promptkit/internal/profile"
+)
+
+func TestLoadBuildsEffectiveTargetsAfterInheritance(t *testing.T) {
+	state, err := load(mapping("effective-targets", map[string]any{
+		"backends": map[string]any{
+			"first": map[string]any{"endpoint": "https://first.example/v1", "api_key_env": "FIRST_KEY",
+				"extra_params": map[string]any{"source": "first", "nested": map[string]any{"old": true}}},
+			"second": map[string]any{"endpoint": "https://second.example/v1", "api_key_env": "SECOND_KEY",
+				"concurrency_limit": 2, "queue_capacity": 0,
+				"extra_params": map[string]any{"source": "second", "nested": map[string]any{"backend": true}}},
+		},
+		"profiles": map[string]any{
+			"base": map[string]any{"backend": "first", "model": "model", "temperature": 0.8,
+				"top_p": 0.9, "max_tokens": 100, "timeout_seconds": 30, "api_key_required": true,
+				"extra_params": map[string]any{"nested": map[string]any{"profile": true}}},
+			"child": map[string]any{"extends": "base", "backend": "second", "temperature": 0.0,
+				"top_p": nil, "max_tokens": 0, "timeout_seconds": nil, "api_key_env": nil,
+				"api_key_required": false,
+				"extra_params":     map[string]any{"nested": map[string]any{"child": nil}}},
+			"direct-key":       map[string]any{"backend": "second", "api_key_required": true},
+			"named-key":        map[string]any{"backend": "second", "api_key_required": true, "api_key_env": "CUSTOM_KEY"},
+			"no-provider-map":  map[string]any{"backend": "second", "extra_params": nil},
+			"no-timeout":       map[string]any{"backend": "second", "timeout_seconds": 0},
+			"partial":          map[string]any{},
+			"endpoint-only":    map[string]any{"endpoint": "https://standalone.example/v1"},
+			"cleared-endpoint": map[string]any{"extends": "base", "endpoint": nil},
+		},
+	}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, err := state.registry.GetBackend("second")
+	if err != nil || selected.QueueCapacity != 0 || !selected.QueueCapacitySet {
+		t.Fatalf("backend capacity was not preserved: %+v, %v", selected, err)
+	}
+	child, err := state.GetProfile(context.Background(), "child")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := state.GetProfile(context.Background(), " child "); err == nil {
+		t.Fatal("profile lookup silently changed a literal ID")
+	}
+	target := child.ResolvedTarget
+	if target.BackendID != "second" || target.Endpoint != "https://second.example/v1" || target.Model != "model" ||
+		target.Temperature != 0 || target.TopP != 0 || target.MaxTokens != 0 ||
+		target.TimeoutSeconds != defaults.ExecutionDefaultTimeoutSeconds || target.APIKeyEnv != "" || target.APIKeyRequired {
+		t.Fatalf("effective child target is wrong: %+v", target)
+	}
+	if !child.TargetPresence.Temperature || !child.TargetPresence.MaxTokens || child.TargetPresence.TopP || child.TargetPresence.TimeoutSeconds {
+		t.Fatalf("numeric presence was not retained: %+v", child.TargetPresence)
+	}
+	wantParams := map[string]any{"source": "second", "nested": map[string]any{
+		"backend": true, "profile": true, "child": nil,
+	}}
+	if !reflect.DeepEqual(target.ExtraParams, wantParams) {
+		t.Fatalf("backend/profile provider map overlay failed: %+v", target.ExtraParams)
+	}
+	if _, exists := target.ExtraParams["nested"].(map[string]any)["old"]; exists {
+		t.Fatal("previous backend derived parameter leaked into child")
+	}
+	for id, wantEnv := range map[string]string{"direct-key": "", "named-key": "CUSTOM_KEY"} {
+		profile, err := state.GetProfile(context.Background(), id)
+		if err != nil || profile.ResolvedTarget.APIKeyEnv != wantEnv {
+			t.Fatalf("credential source for %s: %+v, %v", id, profile, err)
+		}
+	}
+	noMap, _ := state.GetProfile(context.Background(), "no-provider-map")
+	if noMap.ResolvedTarget.ExtraParams != nil {
+		t.Fatalf("explicit null provider map did not suppress backend defaults: %+v", noMap.ResolvedTarget.ExtraParams)
+	}
+	noTimeout, _ := state.GetProfile(context.Background(), "no-timeout")
+	if noTimeout.ResolvedTarget.TimeoutSeconds != 0 || !noTimeout.TargetPresence.TimeoutSeconds {
+		t.Fatalf("explicit zero timeout was lost: %+v", noTimeout)
+	}
+	partial, _ := state.GetProfile(context.Background(), "partial")
+	if partial.ResolvedTarget.Endpoint != "" || partial.ResolvedTarget.Model != "" {
+		t.Fatalf("partial profile gained a runnable target: %+v", partial.ResolvedTarget)
+	}
+	identity, err := state.GetProfileIdentity(context.Background(), "partial")
+	if err != nil || identity != "partial" {
+		t.Fatalf("partial profile identity=(%q, %v)", identity, err)
+	}
+	if _, err := state.GetProfileIdentity(context.Background(), "missing"); !errors.Is(err, profilepkg.ErrProfileNotFound) {
+		t.Fatalf("missing profile identity error=%v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := state.GetProfileIdentity(ctx, "partial"); !errors.Is(err, context.Canceled) {
+		t.Fatalf("canceled profile identity lookup error=%v", err)
+	}
+	endpointOnly, _ := state.GetProfile(context.Background(), "endpoint-only")
+	if endpointOnly.ResolvedTarget.Endpoint != "https://standalone.example/v1" ||
+		endpointOnly.ResolvedTarget.BackendID != "" || endpointOnly.ResolvedTarget.Model != "" {
+		t.Fatalf("endpoint-only profile was not retained: %+v", endpointOnly.ResolvedTarget)
+	}
+	clearedEndpoint, _ := state.GetProfile(context.Background(), "cleared-endpoint")
+	if clearedEndpoint.ResolvedTarget.Endpoint != "" || clearedEndpoint.ResolvedTarget.BackendID != "first" {
+		t.Fatalf("explicit null recovered backend endpoint: %+v", clearedEndpoint.ResolvedTarget)
+	}
+	child.ResolvedTarget.ExtraParams["source"] = "mutated"
+	again, _ := state.GetProfile(context.Background(), "child")
+	if again.ResolvedTarget.ExtraParams["source"] != "second" {
+		t.Fatal("profile lookup exposed snapshot ownership")
+	}
+}
+
+func TestLoadedZeroControlsReachBuiltInRequest(t *testing.T) {
+	payloads := make(chan map[string]any, 1)
+	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		var payload map[string]any
+		if err := json.NewDecoder(request.Body).Decode(&payload); err != nil {
+			writer.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		payloads <- payload
+		writer.Header().Set("Content-Type", "application/json")
+		_, _ = writer.Write([]byte(`{"choices":[{"message":{"content":"ok"}}]}`))
+	}))
+	defer server.Close()
+	state, err := load(mapping("wire-controls", map[string]any{
+		"backends": map[string]any{"local": map[string]any{"endpoint": server.URL + "/v1"}},
+		"profiles": map[string]any{"direct": map[string]any{
+			"backend": "local", "model": "example", "temperature": 0.0, "max_tokens": 0, "top_p": nil,
+		}},
+	}), nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	profile, err := state.GetProfile(context.Background(), "direct")
+	if err != nil {
+		t.Fatal(err)
+	}
+	client, err := llm.NewOpenAICompatibleClient(llm.OpenAICompatibleConfig{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = client.Generate(context.Background(), domain.GenerateRequest{
+		Prompt: domain.RenderedPrompt{Messages: []domain.RenderedMessage{{Role: "user", Content: "hello"}}},
+		Target: *profile.ResolvedTarget, TargetPresence: profile.TargetPresence,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	payload := <-payloads
+	if payload["temperature"] != float64(0) || payload["max_tokens"] != float64(0) {
+		t.Fatalf("explicit zeros were omitted from outbound request: %+v", payload)
+	}
+	if _, exists := payload["top_p"]; exists {
+		t.Fatalf("explicit null top_p was sent: %+v", payload)
+	}
+}

internal/domain/domain.go

@@ -135,6 +135,12 @@ type Artifact struct {
 	Hash        string
 }
 
+// PromptIdentity identifies one configured prompt version.
+type PromptIdentity struct {
+	ID      string
+	Version string
+}
+
 // PromptDefinition represents a configured prompt execution definition.
 type PromptDefinition struct {
 	ID             string                  `yaml:"id"`
@@ -192,22 +198,11 @@ type BackendCapacityPolicy struct {
 	QueueCapacity    int
 }
 
-// ExecutionProfile describes how and where to execute a model.
+// ExecutionProfile holds a captured configuration target for execution.
 type ExecutionProfile struct {
-	ID              string         `yaml:"id"`
-	BaseProfileID   string         `yaml:"base_profile"`
-	BackendID       string         `yaml:"backend"`
-	Endpoint        string         `yaml:"endpoint"`
-	Model           string         `yaml:"model"`
-	Temperature     float64        `yaml:"temperature"`
-	MaxTokens       int            `yaml:"max_tokens"`
-	TopP            float64        `yaml:"top_p"`
-	TimeoutSeconds  int            `yaml:"timeout_seconds"`
-	ServiceTier     string         `yaml:"service_tier"`
-	ReasoningEffort string         `yaml:"reasoning_effort"`
-	APIKeyEnv       string         `yaml:"api_key_env"`
-	APIKeyRequired  bool           `yaml:"-" json:"-"`
-	ExtraParams     map[string]any `yaml:"extra_params"`
+	ID             string
+	ResolvedTarget *ExecutionTarget
+	TargetPresence ExecutionTargetPresence
 }
 
 // ExecutionTargetOverride represents per-request runtime setting overrides.
@@ -224,8 +219,9 @@ type ExecutionTargetOverride struct {
 	ExtraParams     map[string]any `json:"extra_params,omitempty"`
 }
 
-// ExecutionTargetPresence tracks which effective runtime fields came from an
-// explicit request override even when the resolved value is a zero value.
+// ExecutionTargetPresence tracks effective numeric values that must be sent
+// even when they are zero. Values may come from configuration or a request
+// override; explicit configuration null suppresses the corresponding bit.
 type ExecutionTargetPresence struct {
 	Temperature    bool
 	MaxTokens      bool

internal/domain/requirements.go

@@ -0,0 +1,58 @@
+package domain
+
+// RequirementKind classifies how a prompt may depend on an input or variable.
+type RequirementKind string
+
+const (
+	RequirementRequired    RequirementKind = "required"
+	RequirementConditional RequirementKind = "conditional"
+	RequirementOptional    RequirementKind = "optional"
+)
+
+// InputRequirement describes one declared or template-referenced input.
+type InputRequirement struct {
+	Name        string
+	Kind        RequirementKind
+	Declared    bool
+	ContentType *string
+	Description *string
+	Explanation string
+}
+
+// VariableRequirement describes one caller variable referenced by a prompt.
+type VariableRequirement struct {
+	Name        string
+	Kind        RequirementKind
+	Supplied    bool
+	Explanation string
+}
+
+// RequirementIssueCode identifies a limit that may affect requirement
+// discovery.
+type RequirementIssueCode string
+
+const (
+	RequirementIssueMissingVariable      RequirementIssueCode = "missing_variable"
+	RequirementIssueInputContent         RequirementIssueCode = "input_content"
+	RequirementIssueDynamicInputName     RequirementIssueCode = "dynamic_input_name"
+	RequirementIssueUnsupportedConstruct RequirementIssueCode = "unsupported_construct"
+)
+
+// RequirementIssue describes one limitation on requirement discovery.
+type RequirementIssue struct {
+	Code         RequirementIssueCode
+	InputName    string
+	VariableName string
+	Description  string
+}
+
+// RequirementInspection contains the inventories discovered for one prompt.
+type RequirementInspection struct {
+	PromptID      string
+	PromptVersion string
+	ProfileID     string
+	Inputs        []InputRequirement
+	Variables     []VariableRequirement
+	Complete      bool
+	Issues        []RequirementIssue
+}

internal/engine/engine.go

@@ -11,49 +11,42 @@ import (
 	"strings"
 	"time"
 
-	openrouter "gitea.maximumdirect.net/eric/promptkit-backend-openrouter/v2"
-	rakestrawhome "gitea.maximumdirect.net/eric/promptkit-backend-rakestrawhome/v2"
+	"gitea.maximumdirect.net/eric/ConfigKit"
 	"gitea.maximumdirect.net/eric/promptkit/internal/artifact"
-	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
 	"gitea.maximumdirect.net/eric/promptkit/internal/capacity"
 	"gitea.maximumdirect.net/eric/promptkit/internal/catalog"
+	"gitea.maximumdirect.net/eric/promptkit/internal/configuration"
 	"gitea.maximumdirect.net/eric/promptkit/internal/defaults"
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 	"gitea.maximumdirect.net/eric/promptkit/internal/generation"
 	"gitea.maximumdirect.net/eric/promptkit/internal/llm"
-	"gitea.maximumdirect.net/eric/promptkit/internal/profile"
 	"gitea.maximumdirect.net/eric/promptkit/internal/prompt"
-	"gitea.maximumdirect.net/eric/promptkit/internal/promptdef"
 	"gitea.maximumdirect.net/eric/promptkit/internal/usecase"
 	"gitea.maximumdirect.net/eric/promptkit/internal/validate"
 )
 
 // Config carries construction settings selected by the public facade.
 type Config struct {
-	PromptDir        string
-	ProfileDir       string
+	Sources          ConfigurationSources
 	SchemaDir        string
 	Timeout          time.Duration
 	HTTPClient       *http.Client
 	TransientRetries *int
 }
 
+// ConfigurationSources identifies caller-selected ConfigKit layers.
+type ConfigurationSources struct {
+	Underlays []configkit.Underlay
+	Main      *configkit.Input
+}
+
 // Options collects construction choices from the public facade.
 type Options struct {
-	llmClient             llm.Client
-	artifactReader        artifact.Reader
-	promptDefinitions     promptdef.Repository
-	profiles              profile.Repository
-	fallbackProfiles      profile.Repository
-	memoryProfiles        profile.Repository
-	backends              []domain.Backend
-	validator             validate.Validator
-	promptSource          bool
-	profileSource         bool
-	fallbackProfileSource bool
-	memorySource          bool
-	validatorSource       bool
-	artifactSource        bool
+	llmClient       llm.Client
+	artifactReader  artifact.Reader
+	validator       validate.Validator
+	validatorSource bool
+	artifactSource  bool
 }
 
 // SetLLMClient selects the client collaborator for one engine.
@@ -65,72 +58,6 @@ func (o *Options) SetArtifactReader(reader artifact.Reader) {
 	o.artifactSource = true
 }
 
-// SetPromptFS selects a prompt source rooted in fsys.
-func (o *Options) SetPromptFS(fsys fs.FS, root string) error {
-	if err := validateSourceFS(fsys, root); err != nil {
-		return err
-	}
-	o.promptDefinitions = promptdef.NewFSRepository(fsys, root)
-	o.promptSource = true
-	return nil
-}
-
-// SetPromptFile selects a single prompt file.
-func (o *Options) SetPromptFile(path string) error {
-	fsys, root, directory, err := fileSource(path)
-	if err != nil {
-		return err
-	}
-	o.promptDefinitions = promptdef.NewFileRepository(fsys, root, directory)
-	o.promptSource = true
-	return nil
-}
-
-// SetProfileFS selects an ordinary profile source rooted in fsys.
-func (o *Options) SetProfileFS(fsys fs.FS, root string) error {
-	if err := validateSourceFS(fsys, root); err != nil {
-		return err
-	}
-	o.profiles = profile.NewFSRepository(fsys, root)
-	o.profileSource = true
-	return nil
-}
-
-// SetProfileFile selects a single ordinary profile file.
-func (o *Options) SetProfileFile(path string) error {
-	fsys, root, _, err := fileSource(path)
-	if err != nil {
-		return err
-	}
-	o.profiles = profile.NewFSRepository(fsys, root)
-	o.profileSource = true
-	return nil
-}
-
-// SetFallbackProfileFS selects a fallback profile source rooted in fsys.
-func (o *Options) SetFallbackProfileFS(fsys fs.FS, root string) error {
-	if err := validateSourceFS(fsys, root); err != nil {
-		return err
-	}
-	o.fallbackProfiles = profile.NewFSRepository(fsys, root)
-	o.fallbackProfileSource = true
-	return nil
-}
-
-// SetMemoryProfiles validates and stores application-owned profile definitions.
-func (o *Options) SetMemoryProfiles(definitions []domain.ExecutionProfile) error {
-	repository, err := profile.NewMemoryRepository(definitions)
-	if err != nil {
-		return err
-	}
-	o.memoryProfiles = repository
-	o.memorySource = true
-	return nil
-}
-
-// AddBackend appends one backend registration.
-func (o *Options) AddBackend(backend domain.Backend) { o.backends = append(o.backends, backend) }
-
 // SetSchemaFS selects a schema source rooted in fsys.
 func (o *Options) SetSchemaFS(fsys fs.FS, root string) error {
 	if err := validateSourceFS(fsys, root); err != nil {
@@ -154,7 +81,14 @@ func (o *Options) SetSchemaFile(path string) error {
 
 // Engine forwards domain operations to the single assembled use-case runner.
 type Engine struct {
-	runner *usecase.Runner
+	runner     *usecase.Runner
+	inspection configuration.Inspection
+	listing    identityInventory
+}
+
+type identityInventory interface {
+	ListProfiles(context.Context) ([]string, error)
+	ListPrompts(context.Context) ([]domain.PromptIdentity, error)
 }
 
 // New assembles an engine from facade-selected configuration and collaborators.
@@ -163,33 +97,20 @@ func New(cfg Config, options Options) (*Engine, error) {
 	if err != nil {
 		return nil, err
 	}
-	promptDefinitions := options.promptDefinitions
-	if !options.promptSource {
-		if strings.TrimSpace(cfg.PromptDir) == "" {
-			return nil, fmt.Errorf("prompt directory is required")
-		}
-		promptDefinitions = promptdef.NewFilesystemRepository(cfg.PromptDir)
-	}
-
-	maintained, err := catalog.Load(
-		catalog.Source{Name: "OpenRouter", ExpectedBackendID: backend.OpenRouterID, FS: openrouter.FS(), Root: openrouter.Root},
-		catalog.Source{Name: "Rakestrawhome", ExpectedBackendID: backend.RakestrawHomeID, FS: rakestrawhome.FS(), Root: rakestrawhome.Root},
-	)
+	underlays, err := catalog.Underlays()
 	if err != nil {
-		return nil, fmt.Errorf("failed to load maintained catalogs: %w", err)
+		return nil, fmt.Errorf("select maintained configuration: %w", err)
 	}
-
-	maintainedProfiles, err := newMaintainedProfileRepository(maintained.Profiles, maintained.Backends)
+	underlays = append(underlays, cfg.Sources.Underlays...)
+	main := configkit.Input{Source: configkit.NoSource()}
+	if cfg.Sources.Main != nil {
+		main = *cfg.Sources.Main
+	}
+	snapshot, err := configuration.Load(main, underlays)
 	if err != nil {
-		return nil, fmt.Errorf("failed to construct Promptkit-maintained profiles: %w", err)
+		return nil, err
 	}
-
-	profiles := newProfileRepository(cfg.ProfileDir, options, maintainedProfiles)
-	registry, err := backend.NewRegistry(maintained.Backends, options.backends)
-	if err != nil {
-		return nil, fmt.Errorf("failed to construct backend registry: %w", err)
-	}
-	manager, err := capacity.NewManager(registry.CapacityPolicies())
+	manager, err := capacity.NewManager(snapshot.CapacityPolicies())
 	if err != nil {
 		return nil, fmt.Errorf("failed to construct backend capacity manager: %w", err)
 	}
@@ -217,23 +138,19 @@ func New(cfg Config, options Options) (*Engine, error) {
 		reader = artifact.NewCompositeReader()
 	}
 
-	return &Engine{runner: usecase.NewRunnerWithRepairer(promptDefinitions, profiles, registry, reader, prompt.NewGoRenderer(), client, validator, usecase.NewDefaultOutputRepairer(client), manager, defaultRetries)}, nil
+	return &Engine{
+		runner:     usecase.NewRunnerWithRepairer(snapshot, snapshot, reader, prompt.NewCompiledRenderer(snapshot), client, validator, usecase.NewDefaultOutputRepairer(client), manager, defaultRetries),
+		inspection: snapshot.Inspection(),
+		listing:    snapshot,
+	}, nil
 }
 
-func newProfileRepository(profileDir string, options Options, maintained profile.Repository) profile.Repository {
-	repository := maintained
-	if options.fallbackProfileSource {
-		repository = profile.NewOverlayRepository(options.fallbackProfiles, repository)
+// InspectConfiguration returns read-only operations over the captured result.
+func (e *Engine) InspectConfiguration() configuration.Inspection {
+	if e == nil {
+		return nil
 	}
-	if options.profileSource {
-		repository = profile.NewOverlayRepository(options.profiles, repository)
-	} else if strings.TrimSpace(profileDir) != "" {
-		repository = profile.NewOverlayRepository(profile.NewFilesystemRepository(profileDir), repository)
-	}
-	if options.memorySource {
-		repository = profile.NewOverlayRepository(options.memoryProfiles, repository)
-	}
-	return profile.NewResolvingRepository(repository)
+	return e.inspection
 }
 
 func validateSourceFS(fsys fs.FS, root string) error {
@@ -268,9 +185,23 @@ func fileSource(name string) (fs.FS, string, string, error) {
 func (e *Engine) InspectPrompt(ctx context.Context, id, version string) (*domain.PromptInspection, error) {
 	return e.runner.InspectPrompt(ctx, id, version)
 }
+func (e *Engine) InspectRequirements(
+	ctx context.Context,
+	request usecase.RequirementInspectionRequest,
+) (*domain.RequirementInspection, error) {
+	return e.runner.InspectRequirements(ctx, request)
+}
 func (e *Engine) InspectProfile(ctx context.Context, id string) (*domain.ProfileInspection, error) {
 	return e.runner.InspectProfile(ctx, id)
 }
+
+func (e *Engine) ListProfiles(ctx context.Context) ([]string, error) {
+	return e.listing.ListProfiles(ctx)
+}
+
+func (e *Engine) ListPrompts(ctx context.Context) ([]domain.PromptIdentity, error) {
+	return e.listing.ListPrompts(ctx)
+}
 func (e *Engine) Prepare(ctx context.Context, request domain.RunRequest) (*domain.PreparedRun, error) {
 	return e.runner.Prepare(ctx, request)
 }

internal/engine/maintained_profiles.go

@@ -1,50 +0,0 @@
-package engine
-
-import (
-	"context"
-	"fmt"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/profile"
-)
-
-func maintainedProfileDefinitions() []domain.ExecutionProfile {
-	return []domain.ExecutionProfile{
-		{
-			ID:            "promptkit-openrouter-standard",
-			BaseProfileID: "gemini-flash-latest",
-		},
-		{
-			ID:        "promptkit-openrouter-auto",
-			BackendID: backend.OpenRouterID,
-			Model:     "openrouter/auto",
-		},
-	}
-}
-
-func newMaintainedProfileRepository(catalogProfiles profile.Repository, maintainedBackends []domain.Backend) (profile.Repository, error) {
-	definitions := maintainedProfileDefinitions()
-	owned, err := profile.NewMemoryRepository(definitions)
-	if err != nil {
-		return nil, fmt.Errorf("create Promptkit-maintained profiles: %w", err)
-	}
-
-	combined := profile.NewOverlayRepository(owned, catalogProfiles)
-	resolved := profile.NewResolvingRepository(combined)
-	registry, err := backend.NewRegistry(maintainedBackends, nil)
-	if err != nil {
-		return nil, fmt.Errorf("construct maintained backend registry: %w", err)
-	}
-	for _, definition := range definitions {
-		effective, err := resolved.GetProfile(context.Background(), definition.ID)
-		if err != nil {
-			return nil, fmt.Errorf("resolve Promptkit-maintained profile %q: %w", definition.ID, err)
-		}
-		if _, err := registry.GetBackend(effective.BackendID); err != nil {
-			return nil, fmt.Errorf("Promptkit-maintained profile %q selects unavailable backend %q: %w", definition.ID, effective.BackendID, err)
-		}
-	}
-
-	return combined, nil
-}

internal/engine/maintained_profiles_test.go

@@ -1,78 +0,0 @@
-package engine
-
-import (
-	"context"
-	"testing"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/backend"
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/profile"
-)
-
-func TestNewMaintainedProfileRepository(t *testing.T) {
-	newCatalogProfiles := func(t *testing.T, definitions []domain.ExecutionProfile) profile.Repository {
-		t.Helper()
-		repository, err := profile.NewMemoryRepository(definitions)
-		if err != nil {
-			t.Fatalf("create catalog profiles: %v", err)
-		}
-		return repository
-	}
-	newBackend := func(id string) domain.Backend {
-		return domain.Backend{ID: id, Endpoint: "https://" + id + ".example/v1", APIKeyEnv: "TEST_API_KEY"}
-	}
-
-	t.Run("resolves inherited and direct definitions", func(t *testing.T) {
-		repository, err := newMaintainedProfileRepository(
-			newCatalogProfiles(t, []domain.ExecutionProfile{{
-				ID:        "gemini-flash-latest",
-				BackendID: backend.OpenRouterID,
-				Model:     "catalog-selected-model",
-			}}),
-			[]domain.Backend{newBackend(backend.OpenRouterID)},
-		)
-		if err != nil {
-			t.Fatalf("create maintained profiles: %v", err)
-		}
-
-		resolved := profile.NewResolvingRepository(repository)
-		standard, err := resolved.GetProfile(context.Background(), "promptkit-openrouter-standard")
-		if err != nil {
-			t.Fatalf("resolve inherited profile: %v", err)
-		}
-		if standard.BackendID != backend.OpenRouterID || standard.Model != "catalog-selected-model" {
-			t.Fatalf("unexpected inherited profile: %#v", standard)
-		}
-
-		auto, err := resolved.GetProfile(context.Background(), "promptkit-openrouter-auto")
-		if err != nil {
-			t.Fatalf("resolve direct profile: %v", err)
-		}
-		definitions := maintainedProfileDefinitions()
-		if auto.BackendID != definitions[1].BackendID || auto.Model != definitions[1].Model {
-			t.Fatalf("unexpected direct profile: %#v", auto)
-		}
-	})
-
-	t.Run("rejects a missing inherited base", func(t *testing.T) {
-		if _, err := newMaintainedProfileRepository(
-			newCatalogProfiles(t, nil),
-			[]domain.Backend{newBackend(backend.OpenRouterID)},
-		); err == nil {
-			t.Fatal("expected missing base error")
-		}
-	})
-
-	t.Run("rejects an unavailable effective backend", func(t *testing.T) {
-		if _, err := newMaintainedProfileRepository(
-			newCatalogProfiles(t, []domain.ExecutionProfile{{
-				ID:        "gemini-flash-latest",
-				BackendID: "other",
-				Model:     "catalog-selected-model",
-			}}),
-			[]domain.Backend{newBackend("other")},
-		); err == nil {
-			t.Fatal("expected unavailable backend error")
-		}
-	})
-}

internal/llm/openai_compatible_client.go

@@ -152,6 +152,11 @@ func (c *OpenAICompatibleClient) PrepareGeneration(req domain.GenerateRequest) (
 
 	payload, err := json.Marshal(wirePayload)
 	if err != nil {
+		for key, value := range req.Target.ExtraParams {
+			if _, extraErr := json.Marshal(value); extraErr != nil {
+				return nil, fmt.Errorf("%w: extra_params.%s must be JSON-serializable: %v", ErrInvalidRequest, key, extraErr)
+			}
+		}
 		return nil, fmt.Errorf("%w: failed to encode request: %v", ErrRequestFailed, err)
 	}
 	apiKey := strings.TrimSpace(req.Target.APIKey)
@@ -446,9 +451,6 @@ func openAIChatRequestPayload(req openAIChatRequest) (map[string]any, error) {
 		if IsReservedOpenAIChatRequestField(key) {
 			return nil, fmt.Errorf("extra_params key %q collides with reserved request field", key)
 		}
-		if _, err := json.Marshal(value); err != nil {
-			return nil, fmt.Errorf("extra_params.%s must be JSON-serializable: %w", key, err)
-		}
 		out[key] = value
 	}
 

internal/llm/openai_compatible_client_test.go

@@ -1113,6 +1113,13 @@ func TestOpenAICompatibleClientRejectsInvalidExtraParamsBeforeProviderCall(t *te
 	}{
 		{name: "empty key", extraParams: map[string]any{"": "empty"}, want: "key must not be empty"},
 		{name: "unserializable value", extraParams: map[string]any{"bad": math.Inf(1)}, want: "JSON-serializable"},
+		{
+			name: "nested unserializable value",
+			extraParams: map[string]any{
+				"nested": map[string]any{"values": []any{"valid", math.NaN()}},
+			},
+			want: "extra_params.nested",
+		},
 	}
 	for _, key := range []string{
 		"model",
@@ -1161,6 +1168,56 @@ func TestOpenAICompatibleClientRejectsInvalidExtraParamsBeforeProviderCall(t *te
 	}
 }
 
+func TestOpenAICompatibleClientClassifiesSchemaEncodingFailures(t *testing.T) {
+	tests := []struct {
+		name        string
+		extraParams map[string]any
+		want        error
+		unwanted    error
+	}{
+		{
+			name:        "serializable extra keeps full-request failure",
+			extraParams: map[string]any{"client_option": "accepted"},
+			want:        ErrRequestFailed,
+			unwanted:    ErrInvalidRequest,
+		},
+		{
+			name:        "invalid extra keeps invalid-request failure",
+			extraParams: map[string]any{"nested": map[string]any{"bad": math.Inf(1)}},
+			want:        ErrInvalidRequest,
+			unwanted:    ErrRequestFailed,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			provider := newRecordingProvider(t)
+			client := newProviderClient(t, provider, OpenAICompatibleConfig{})
+			request := ordinaryGenerateRequest()
+			request.Target.ExtraParams = tc.extraParams
+			request.StructuredOutput = &domain.StructuredOutputSpec{
+				Type: domain.StructuredOutputJSONSchema,
+				JSONSchema: &domain.StructuredOutputJSONSpec{
+					Name:   "invalid-schema",
+					Strict: true,
+					Schema: json.RawMessage("{"),
+				},
+			}
+
+			_, err := client.Generate(context.Background(), request)
+			if err == nil || !errors.Is(err, tc.want) {
+				t.Fatalf("error = %v, want identity %v", err, tc.want)
+			}
+			if errors.Is(err, tc.unwanted) {
+				t.Fatalf("error = %v, unexpectedly has identity %v", err, tc.unwanted)
+			}
+			if calls := provider.requestCount(); calls != 0 {
+				t.Fatalf("provider calls = %d, want 0", calls)
+			}
+		})
+	}
+}
+
 func checkConfiguredModelFallback(t *testing.T) {
 	provider := newRecordingProvider(t)
 	client := newProviderClient(t, provider, OpenAICompatibleConfig{Model: "default-model"})

internal/llm/prepare_generation_benchmark_test.go

@@ -0,0 +1,119 @@
+package llm
+
+import (
+	"encoding/json"
+	"runtime"
+	"strings"
+	"testing"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+var prepareGenerationBenchmarkSink *PreparedGeneration
+
+func BenchmarkPrepareGeneration(b *testing.B) {
+	client, err := NewOpenAICompatibleClient(OpenAICompatibleConfig{
+		BaseURL: "https://api.example.test/v1",
+		Model:   "benchmark-model",
+	})
+	if err != nil {
+		b.Fatalf("construct benchmark client: %v", err)
+	}
+
+	prompt := domain.RenderedPrompt{
+		Messages: []domain.RenderedMessage{{Role: "user", Content: "Summarize this request."}},
+	}
+	tests := []struct {
+		name    string
+		request domain.GenerateRequest
+	}{
+		{
+			name: "no_extras",
+			request: domain.GenerateRequest{
+				Prompt: prompt,
+				Target: domain.ExecutionTarget{Model: "benchmark-model"},
+			},
+		},
+		{
+			name: "small_extras",
+			request: domain.GenerateRequest{
+				Prompt: prompt,
+				Target: domain.ExecutionTarget{Model: "benchmark-model", ExtraParams: map[string]any{
+					"priority": "low",
+					"attempt":  3,
+					"enabled":  true,
+				}},
+			},
+		},
+		{
+			name: "1MiB_string_extra",
+			request: domain.GenerateRequest{
+				Prompt: prompt,
+				Target: domain.ExecutionTarget{Model: "benchmark-model", ExtraParams: map[string]any{
+					"payload": strings.Repeat("x", 1<<20),
+				}},
+			},
+		},
+		{
+			name: "nested_json_extras",
+			request: domain.GenerateRequest{
+				Prompt: prompt,
+				Target: domain.ExecutionTarget{Model: "benchmark-model", ExtraParams: map[string]any{
+					"options": map[string]any{
+						"enabled": true,
+						"limits":  []any{2, 4, 8},
+						"tags":    []string{"summary", "offline"},
+					},
+				}},
+			},
+		},
+		{
+			name: "structured_output",
+			request: domain.GenerateRequest{
+				Prompt: prompt,
+				Target: domain.ExecutionTarget{Model: "benchmark-model"},
+				StructuredOutput: &domain.StructuredOutputSpec{
+					Type: domain.StructuredOutputJSONSchema,
+					JSONSchema: &domain.StructuredOutputJSONSpec{
+						Name:   "summary",
+						Strict: true,
+						Schema: map[string]any{
+							"type": "object",
+							"properties": map[string]any{
+								"summary": map[string]any{"type": "string"},
+								"count":   map[string]any{"type": "integer"},
+							},
+							"required":             []string{"summary", "count"},
+							"additionalProperties": false,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		b.Run(tc.name, func(b *testing.B) {
+			prepared, err := client.PrepareGeneration(tc.request)
+			if err != nil {
+				b.Fatalf("check prepared request: %v", err)
+			}
+			if !json.Valid(prepared.payload) {
+				b.Fatal("prepared request is not valid JSON")
+			}
+
+			b.ReportAllocs()
+			b.SetBytes(int64(len(prepared.payload)))
+			b.ResetTimer()
+			for range b.N {
+				prepared, err := client.PrepareGeneration(tc.request)
+				if err != nil {
+					b.Fatalf("prepare generation: %v", err)
+				}
+				prepareGenerationBenchmarkSink = prepared
+			}
+			b.StopTimer()
+			runtime.KeepAlive(prepareGenerationBenchmarkSink)
+		})
+	}
+}

internal/profile/definition.go

@@ -1,47 +0,0 @@
-package profile
-
-import (
-	"errors"
-	"strings"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-)
-
-// NormalizeAndValidateDefinition normalizes and validates one source-local
-// profile definition without resolving a base profile.
-func NormalizeAndValidateDefinition(profile *domain.ExecutionProfile) error {
-	if profile == nil {
-		return errors.New("profile is required")
-	}
-
-	profile.ID = strings.TrimSpace(profile.ID)
-	profile.BaseProfileID = strings.TrimSpace(profile.BaseProfileID)
-	profile.BackendID = strings.TrimSpace(profile.BackendID)
-	profile.Endpoint = strings.TrimSpace(profile.Endpoint)
-
-	if profile.ID == "" {
-		return errors.New("id is required")
-	}
-	if profile.Endpoint != "" {
-		endpoint, err := domain.NormalizeOpenAICompatibleBaseEndpoint(profile.Endpoint)
-		if err != nil {
-			return err
-		}
-		profile.Endpoint = endpoint
-	}
-	if profile.BaseProfileID == "" {
-		if profile.BackendID == "" && profile.Endpoint == "" {
-			return errors.New("backend or endpoint is required")
-		}
-		if strings.TrimSpace(profile.Model) == "" {
-			return errors.New("model is required")
-		}
-	}
-
-	return domain.ValidateExecutionTargetSettings(domain.ExecutionTarget{
-		Temperature:    profile.Temperature,
-		MaxTokens:      profile.MaxTokens,
-		TopP:           profile.TopP,
-		TimeoutSeconds: profile.TimeoutSeconds,
-	})
-}

internal/profile/eager_repository.go

@@ -1,98 +0,0 @@
-package profile
-
-import (
-	"context"
-	"fmt"
-	"io/fs"
-	"sort"
-	"strings"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/filecatalog"
-	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
-)
-
-// LoadedProfileMetadata identifies one profile accepted by LoadFSRepository.
-type LoadedProfileMetadata struct {
-	// ID is the normalized profile ID.
-	ID string
-	// Path is the safe root-relative source path.
-	Path string
-	// ExplicitFields lists the sorted top-level YAML fields present in source.
-	ExplicitFields []string
-}
-
-// LoadFSRepository eagerly validates every profile under root and returns an
-// immutable raw repository and independently owned source metadata.
-func LoadFSRepository(ctx context.Context, fsys fs.FS, root string) (Repository, []LoadedProfileMetadata, error) {
-	if fsys == nil {
-		return nil, nil, fmt.Errorf("failed to read profile directory: filesystem is nil")
-	}
-	paths, err := filecatalog.FindFSYAMLFiles(ctx, fsys, root)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to read profile directory: %w", err)
-	}
-
-	repository := &loadedRepository{profiles: make(map[string]domain.ExecutionProfile, len(paths))}
-	metadata := make([]LoadedProfileMetadata, 0, len(paths))
-	for _, path := range paths {
-		if err := ctx.Err(); err != nil {
-			return nil, nil, err
-		}
-		data, err := fs.ReadFile(fsys, path)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to read profile file %s: %w", filecatalog.DisplayPath(root, path), err)
-		}
-		fileMetadata, err := readProfileFileMetadata(data)
-		if err != nil {
-			return nil, nil, fmt.Errorf("%w: %s", ErrInvalidYAML, filecatalog.DisplayPath(root, path))
-		}
-		if fileMetadata.hasRawAPIKey {
-			return nil, nil, fmt.Errorf("%w: %s", ErrRawAPIKeyNotAllowed, filecatalog.DisplayPath(root, path))
-		}
-		definition, err := decodeProfile(data)
-		if err != nil {
-			return nil, nil, fmt.Errorf("%w: %s", ErrInvalidYAML, filecatalog.DisplayPath(root, path))
-		}
-		definition.ExtraParams, err = jsonvalue.CopyMap(definition.ExtraParams)
-		if err != nil {
-			return nil, nil, fmt.Errorf("%w: %s", ErrInvalidProfile, filecatalog.DisplayPath(root, path))
-		}
-		if err := NormalizeAndValidateDefinition(definition); err != nil {
-			return nil, nil, fmt.Errorf("%w: %s", ErrInvalidProfile, filecatalog.DisplayPath(root, path))
-		}
-		if _, exists := repository.profiles[definition.ID]; exists {
-			return nil, nil, fmt.Errorf("%w: %s: duplicate profile ID", ErrInvalidProfile, filecatalog.DisplayPath(root, path))
-		}
-		repository.profiles[definition.ID] = *definition
-		fields := append([]string(nil), fileMetadata.explicitFields...)
-		sort.Strings(fields)
-		metadata = append(metadata, LoadedProfileMetadata{
-			ID:             definition.ID,
-			Path:           filecatalog.DisplayPath(root, path),
-			ExplicitFields: fields,
-		})
-	}
-	sort.Slice(metadata, func(left, right int) bool { return metadata[left].ID < metadata[right].ID })
-	return repository, metadata, nil
-}
-
-type loadedRepository struct {
-	profiles map[string]domain.ExecutionProfile
-}
-
-func (r *loadedRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, err
-	}
-	definition, found := r.profiles[strings.TrimSpace(id)]
-	if !found {
-		return nil, ErrProfileNotFound
-	}
-	extraParams, err := jsonvalue.CopyMap(definition.ExtraParams)
-	if err != nil {
-		return nil, fmt.Errorf("copy loaded profile %q: %w", definition.ID, err)
-	}
-	definition.ExtraParams = extraParams
-	return &definition, nil
-}

internal/profile/eager_repository_test.go

@@ -1,110 +0,0 @@
-package profile
-
-import (
-	"context"
-	"errors"
-	"io/fs"
-	"reflect"
-	"testing"
-	"testing/fstest"
-)
-
-func TestLoadFSRepositoryLoadsSortedIndependentProfiles(t *testing.T) {
-	fsys := fstest.MapFS{
-		"profiles/z.yml": {Data: []byte("id: z\nbackend: local\nmodel: z-model\nextra_params:\n  nested:\n    value: one\n")},
-		"profiles/a.yml": {Data: []byte("id: a\nbackend: local\nmodel: a-model\nendpoint: ''\n")},
-	}
-
-	repository, metadata, err := LoadFSRepository(context.Background(), fsys, "profiles")
-	if err != nil {
-		t.Fatalf("load repository: %v", err)
-	}
-	if len(metadata) != 2 || metadata[0].ID != "a" || metadata[1].ID != "z" || metadata[0].Path != "a.yml" {
-		t.Fatalf("unexpected metadata: %#v", metadata)
-	}
-	if len(metadata[0].ExplicitFields) != 4 || metadata[0].ExplicitFields[0] != "backend" || metadata[0].ExplicitFields[1] != "endpoint" {
-		t.Fatalf("expected explicitly empty endpoint metadata, got %#v", metadata[0].ExplicitFields)
-	}
-	metadata[1].ExplicitFields[0] = "changed"
-	first, err := repository.GetProfile(context.Background(), "z")
-	if err != nil {
-		t.Fatalf("load profile: %v", err)
-	}
-	first.ExtraParams["nested"].(map[string]any)["value"] = "changed"
-	second, err := repository.GetProfile(context.Background(), "z")
-	if err != nil {
-		t.Fatalf("reload profile: %v", err)
-	}
-	if second.ExtraParams["nested"].(map[string]any)["value"] != "one" {
-		t.Fatalf("profile value was not defensively copied: %#v", second)
-	}
-}
-
-func TestLoadFSRepositoryRejectsInvalidProfiles(t *testing.T) {
-	tests := map[string]fstest.MapFS{
-		"duplicate IDs": {
-			"profiles/one.yml": {Data: []byte("id: duplicate\nbackend: local\nmodel: one\n")},
-			"profiles/two.yml": {Data: []byte("id: duplicate\nbackend: local\nmodel: two\n")},
-		},
-		"raw API key": {
-			"profiles/one.yml": {Data: []byte("id: one\nbackend: local\nmodel: one\napi_key: forbidden\n")},
-		},
-		"multiple documents": {
-			"profiles/one.yml": {Data: []byte("id: one\nbackend: local\nmodel: one\n---\nid: two\n")},
-		},
-	}
-	for name, fsys := range tests {
-		t.Run(name, func(t *testing.T) {
-			_, _, err := LoadFSRepository(context.Background(), fsys, "profiles")
-			if err == nil {
-				t.Fatal("expected load failure")
-			}
-		})
-	}
-}
-
-func TestLoadedRepositoryHonorsCancellationAndMissingProfiles(t *testing.T) {
-	repository, _, err := LoadFSRepository(context.Background(), fstest.MapFS{
-		"profiles/one.yml": {Data: []byte("id: one\nbackend: local\nmodel: one\n")},
-	}, "profiles")
-	if err != nil {
-		t.Fatalf("load repository: %v", err)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	if _, err := repository.GetProfile(ctx, "one"); !errors.Is(err, context.Canceled) {
-		t.Fatalf("expected cancellation, got %v", err)
-	}
-	if _, err := repository.GetProfile(context.Background(), "missing"); !errors.Is(err, ErrProfileNotFound) {
-		t.Fatalf("expected missing profile, got %v", err)
-	}
-}
-
-func TestLoadFSRepositoryMatchesPointLookupForRawProfiles(t *testing.T) {
-	fsys := fstest.MapFS{
-		"profiles/base.yml":    {Data: []byte("id: base\nbackend: local\nmodel: base-model\n")},
-		"profiles/derived.yml": {Data: []byte("id: derived\nbase_profile: base\nreasoning_effort: high\n")},
-	}
-	eager, _, err := LoadFSRepository(context.Background(), fsys, "profiles")
-	if err != nil {
-		t.Fatalf("load eager repository: %v", err)
-	}
-	pointLookup := NewFSRepository(fsys, "profiles")
-	for _, id := range []string{"base", "derived"} {
-		t.Run(id, func(t *testing.T) {
-			got, err := eager.GetProfile(context.Background(), id)
-			if err != nil {
-				t.Fatalf("load eager profile: %v", err)
-			}
-			want, err := pointLookup.GetProfile(context.Background(), id)
-			if err != nil {
-				t.Fatalf("load point-in-time profile: %v", err)
-			}
-			if !reflect.DeepEqual(got, want) {
-				t.Fatalf("raw profiles differ: got %#v, want %#v", got, want)
-			}
-		})
-	}
-}
-
-var _ fs.FS = fstest.MapFS{}

internal/profile/filesystem_repository.go

@@ -1,259 +0,0 @@
-package profile
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"os"
-	"strings"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/filecatalog"
-	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
-	"gopkg.in/yaml.v3"
-)
-
-var (
-	ErrProfileNotFound     = errors.New("execution profile not found")
-	ErrInvalidYAML         = errors.New("invalid YAML format")
-	ErrInvalidProfile      = errors.New("invalid execution profile configuration")
-	ErrRawAPIKeyNotAllowed = errors.New("raw api_key is not allowed; use api_key_env")
-)
-
-type filesystemRepository struct {
-	dir string
-}
-
-func NewFilesystemRepository(dir string) Repository {
-	return &filesystemRepository{dir: dir}
-}
-
-func (r *filesystemRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	return loadProfile(ctx, os.DirFS(r.dir), ".", id)
-}
-
-type fsRepository struct {
-	fsys fs.FS
-	root string
-}
-
-func NewFSRepository(fsys fs.FS, root string) Repository {
-	return &fsRepository{fsys: fsys, root: root}
-}
-
-func (r *fsRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	return loadProfile(ctx, r.fsys, r.root, id)
-}
-
-type overlayRepository struct {
-	primary  Repository
-	fallback Repository
-}
-
-func NewOverlayRepository(primary, fallback Repository) Repository {
-	return &overlayRepository{primary: primary, fallback: fallback}
-}
-
-func (r *overlayRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	if r.primary != nil {
-		prof, err := r.primary.GetProfile(ctx, id)
-		if err == nil {
-			return prof, nil
-		}
-		if !errors.Is(err, ErrProfileNotFound) {
-			return nil, err
-		}
-	}
-	if r.fallback == nil {
-		return nil, ErrProfileNotFound
-	}
-	return r.fallback.GetProfile(ctx, id)
-}
-
-func loadProfile(ctx context.Context, fsys fs.FS, root string, id string) (*domain.ExecutionProfile, error) {
-	id = strings.TrimSpace(id)
-	if id == "" {
-		return nil, fmt.Errorf("%w: profile id is required", ErrInvalidProfile)
-	}
-	if fsys == nil {
-		return nil, fmt.Errorf("failed to read profile directory: filesystem is nil")
-	}
-
-	files, err := filecatalog.FindFSYAMLFiles(ctx, fsys, root)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read profile directory: %w", err)
-	}
-
-	var matches []profileMatch
-	for _, fullPath := range files {
-		select {
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		default:
-		}
-
-		relPath := filecatalog.DisplayPath(root, fullPath)
-		data, err := fs.ReadFile(fsys, fullPath)
-		if err != nil {
-			return nil, fmt.Errorf("failed to read profile file %s: %w", relPath, err)
-		}
-		metadata, metadataErr := readProfileFileMetadata(data)
-		idMatch := metadata.matchesID(id)
-		if metadataErr != nil {
-			if idMatch {
-				return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, relPath, metadataErr)
-			}
-			continue
-		}
-		if metadata.hasRawAPIKey {
-			if idMatch {
-				return nil, fmt.Errorf("%w: %s", ErrRawAPIKeyNotAllowed, relPath)
-			}
-			continue
-		}
-		if !idMatch {
-			continue
-		}
-
-		prof, err := decodeProfile(data)
-		if err != nil {
-			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, relPath, err)
-		}
-
-		prof.ID = strings.TrimSpace(prof.ID)
-		if prof.ID != id {
-			continue
-		}
-		prof.ExtraParams, err = jsonvalue.CopyMap(prof.ExtraParams)
-		if err != nil {
-			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, relPath, err)
-		}
-		if err := NormalizeAndValidateDefinition(prof); err != nil {
-			if errors.Is(err, ErrRawAPIKeyNotAllowed) {
-				return nil, fmt.Errorf("%w: %s", err, relPath)
-			}
-			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, relPath, err)
-		}
-		matches = append(matches, profileMatch{
-			profile: prof,
-			path:    relPath,
-		})
-	}
-
-	if len(matches) > 1 {
-		paths := make([]string, 0, len(matches))
-		for _, match := range matches {
-			paths = append(paths, match.path)
-		}
-		return nil, fmt.Errorf("%w: duplicate execution profile id %q found in: %s", ErrInvalidProfile, id, strings.Join(paths, ", "))
-	}
-
-	if len(matches) == 1 {
-		return matches[0].profile, nil
-	}
-
-	return nil, ErrProfileNotFound
-}
-
-type profileMatch struct {
-	profile *domain.ExecutionProfile
-	path    string
-}
-
-type profileFileMetadata struct {
-	ids            []string
-	hasRawAPIKey   bool
-	explicitFields []string
-}
-
-func readProfileFileMetadata(data []byte) (profileFileMetadata, error) {
-	decoder := yaml.NewDecoder(bytes.NewReader(data))
-	var node yaml.Node
-	if err := decoder.Decode(&node); err != nil {
-		return profileFileMetadata{}, err
-	}
-	metadata := profileMetadataFromNode(&node)
-	documentCount := 1
-	for {
-		var trailing yaml.Node
-		err := decoder.Decode(&trailing)
-		if errors.Is(err, io.EOF) {
-			if documentCount == 1 {
-				return metadata, nil
-			}
-			return metadata, errors.New("profile file must contain exactly one YAML document")
-		}
-		if err != nil {
-			return metadata, err
-		}
-		documentCount++
-		metadata.merge(profileMetadataFromNode(&trailing))
-	}
-}
-
-func profileMetadataFromNode(node *yaml.Node) profileFileMetadata {
-	if node.Kind != yaml.DocumentNode || len(node.Content) == 0 {
-		return profileFileMetadata{}
-	}
-	mapping := node.Content[0]
-	if mapping.Kind != yaml.MappingNode {
-		return profileFileMetadata{}
-	}
-
-	var metadata profileFileMetadata
-	for i := 0; i+1 < len(mapping.Content); i += 2 {
-		key := mapping.Content[i]
-		value := mapping.Content[i+1]
-		metadata.explicitFields = append(metadata.explicitFields, key.Value)
-		switch key.Value {
-		case "id":
-			metadata.ids = append(metadata.ids, strings.TrimSpace(value.Value))
-		case "api_key":
-			metadata.hasRawAPIKey = true
-		}
-	}
-	return metadata
-}
-
-func (m profileFileMetadata) matchesID(id string) bool {
-	for _, candidate := range m.ids {
-		if candidate == id {
-			return true
-		}
-	}
-	return false
-}
-
-func (m *profileFileMetadata) merge(other profileFileMetadata) {
-	m.ids = append(m.ids, other.ids...)
-	m.hasRawAPIKey = m.hasRawAPIKey || other.hasRawAPIKey
-	m.explicitFields = append(m.explicitFields, other.explicitFields...)
-}
-
-func decodeProfile(data []byte) (*domain.ExecutionProfile, error) {
-	var prof domain.ExecutionProfile
-	decoder := yaml.NewDecoder(bytes.NewReader(data))
-	decoder.KnownFields(true)
-	if err := decoder.Decode(&prof); err != nil {
-		return nil, err
-	}
-	if err := requireYAMLStreamEnd(decoder); err != nil {
-		return nil, err
-	}
-	return &prof, nil
-}
-
-func requireYAMLStreamEnd(decoder *yaml.Decoder) error {
-	var trailing yaml.Node
-	err := decoder.Decode(&trailing)
-	if errors.Is(err, io.EOF) {
-		return nil
-	}
-	if err != nil {
-		return err
-	}
-	return errors.New("profile file must contain exactly one YAML document")
-}

internal/profile/memory_repository.go

@@ -1,50 +0,0 @@
-package profile
-
-import (
-	"context"
-	"fmt"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
-)
-
-// NewMemoryRepository constructs an immutable repository from profile
-// definitions supplied by an internal caller.
-func NewMemoryRepository(definitions []domain.ExecutionProfile) (Repository, error) {
-	repository := &memoryRepository{profiles: make(map[string]domain.ExecutionProfile, len(definitions))}
-	for _, definition := range definitions {
-		extraParams, err := jsonvalue.CopyMap(definition.ExtraParams)
-		if err != nil {
-			return nil, err
-		}
-		definition.ExtraParams = extraParams
-		if err := NormalizeAndValidateDefinition(&definition); err != nil {
-			return nil, err
-		}
-		if _, exists := repository.profiles[definition.ID]; exists {
-			return nil, fmt.Errorf("duplicate profile id %q", definition.ID)
-		}
-		repository.profiles[definition.ID] = definition
-	}
-	return repository, nil
-}
-
-type memoryRepository struct {
-	profiles map[string]domain.ExecutionProfile
-}
-
-func (r *memoryRepository) GetProfile(_ context.Context, id string) (*domain.ExecutionProfile, error) {
-	if r == nil {
-		return nil, ErrProfileNotFound
-	}
-	definition, found := r.profiles[id]
-	if !found {
-		return nil, ErrProfileNotFound
-	}
-	extraParams, err := jsonvalue.CopyMap(definition.ExtraParams)
-	if err != nil {
-		return nil, fmt.Errorf("copy memory profile %q: %w", definition.ID, err)
-	}
-	definition.ExtraParams = extraParams
-	return &definition, nil
-}

internal/profile/memory_repository_test.go

@@ -1,91 +0,0 @@
-package profile
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-)
-
-func TestMemoryRepositoryOwnsNormalizedDefinitions(t *testing.T) {
-	nested := map[string]any{"value": "original"}
-	definitions := []domain.ExecutionProfile{{
-		ID:          " profile ",
-		BackendID:   " backend ",
-		Endpoint:    " https://example.test/v1/ ",
-		Model:       "model",
-		ExtraParams: map[string]any{"nested": nested},
-	}}
-
-	repository, err := NewMemoryRepository(definitions)
-	if err != nil {
-		t.Fatalf("construct repository: %v", err)
-	}
-	nested["value"] = "mutated input"
-
-	first, err := repository.GetProfile(context.Background(), "profile")
-	if err != nil {
-		t.Fatalf("load profile: %v", err)
-	}
-	if first.ID != "profile" || first.BackendID != "backend" || first.Endpoint != "https://example.test/v1/" {
-		t.Fatalf("normalized definition = %#v", first)
-	}
-	if first.ExtraParams["nested"].(map[string]any)["value"] != "original" {
-		t.Fatalf("repository retained input mutation: %#v", first.ExtraParams)
-	}
-	first.ExtraParams["nested"].(map[string]any)["value"] = "mutated result"
-
-	second, err := repository.GetProfile(context.Background(), "profile")
-	if err != nil {
-		t.Fatalf("reload profile: %v", err)
-	}
-	if second.ExtraParams["nested"].(map[string]any)["value"] != "original" {
-		t.Fatalf("repository retained result mutation: %#v", second.ExtraParams)
-	}
-}
-
-func TestMemoryRepositoryPreservesInheritanceAndRejectsInvalidDefinitions(t *testing.T) {
-	derived, err := NewMemoryRepository([]domain.ExecutionProfile{{
-		ID:              "derived",
-		BaseProfileID:   "base",
-		ReasoningEffort: "high",
-	}})
-	if err != nil {
-		t.Fatalf("construct derived repository: %v", err)
-	}
-	profile, err := derived.GetProfile(context.Background(), "derived")
-	if err != nil {
-		t.Fatalf("load derived profile: %v", err)
-	}
-	if profile.BaseProfileID != "base" || profile.ReasoningEffort != "high" {
-		t.Fatalf("derived profile = %#v", profile)
-	}
-	if _, err := derived.GetProfile(context.Background(), "missing"); !errors.Is(err, ErrProfileNotFound) {
-		t.Fatalf("missing profile error = %v, want ErrProfileNotFound", err)
-	}
-
-	tests := []struct {
-		name        string
-		definitions []domain.ExecutionProfile
-	}{
-		{
-			name: "normalized duplicate IDs",
-			definitions: []domain.ExecutionProfile{
-				{ID: " duplicate ", Endpoint: "https://one.example/v1", Model: "one"},
-				{ID: "duplicate", Endpoint: "https://two.example/v1", Model: "two"},
-			},
-		},
-		{
-			name:        "invalid extra parameters",
-			definitions: []domain.ExecutionProfile{{ID: "invalid", Endpoint: "https://example.test/v1", Model: "model", ExtraParams: map[string]any{"invalid": func() {}}}},
-		},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			if _, err := NewMemoryRepository(test.definitions); err == nil {
-				t.Fatal("expected repository construction error")
-			}
-		})
-	}
-}

internal/profile/repository.go

@@ -2,11 +2,15 @@ package profile
 
 import (
 	"context"
+	"errors"
 
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 )
 
-// Repository loads execution profiles.
+// ErrProfileNotFound identifies an absent profile in the captured index.
+var ErrProfileNotFound = errors.New("execution profile not found")
+
+// Repository selects execution profiles from a captured index.
 type Repository interface {
 	GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error)
 }

internal/profile/repository_benchmark_test.go

@@ -1,58 +0,0 @@
-package profile
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"testing/fstest"
-)
-
-func BenchmarkProfileRepositoryLookup(b *testing.B) {
-	for _, size := range []int{10, 1000} {
-		b.Run(fmt.Sprintf("catalog-%d", size), func(b *testing.B) {
-			files := fstest.MapFS{
-				"target.yaml": profileMapFile(`
-id: target
-endpoint: http://localhost:8000/v1
-model: target-model
-extra_params:
-  selected: true
-`),
-			}
-			metadataNames := []string{"target.yaml"}
-			for i := 1; i < size; i++ {
-				name := fmt.Sprintf("profile-%04d.yaml", i)
-				files[name] = profileMapFile(fmt.Sprintf(`
-id: profile-%04d
-endpoint: http://localhost:8000/v1
-model: unrelated-model
-temperature: 0.5
-max_tokens: 500
-extra_params:
-  provider:
-    order:
-      - first
-      - second
-`, i))
-				metadataNames = append(metadataNames, name)
-			}
-
-			fsys := &recordingProfileFS{FS: files}
-			repo := NewFSRepository(fsys, ".")
-			b.ReportAllocs()
-			b.ResetTimer()
-			for i := 0; i < b.N; i++ {
-				if _, err := repo.GetProfile(context.Background(), "target"); err != nil {
-					b.Fatal(err)
-				}
-			}
-			b.StopTimer()
-
-			for _, name := range metadataNames {
-				if got := fsys.openCount(name); got != b.N {
-					b.Fatalf("metadata %q opens = %d, want %d", name, got, b.N)
-				}
-			}
-		})
-	}
-}

internal/profile/resolving_repository.go

@@ -1,160 +0,0 @@
-package profile
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"strings"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gitea.maximumdirect.net/eric/promptkit/internal/jsonvalue"
-)
-
-const maximumProfileChainLength = 32
-
-type resolvingRepository struct {
-	source Repository
-}
-
-// NewResolvingRepository resolves inherited profile definitions from source.
-func NewResolvingRepository(source Repository) Repository {
-	return &resolvingRepository{source: source}
-}
-
-func (r *resolvingRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	if r == nil || r.source == nil {
-		return nil, fmt.Errorf("%w: profile repository is required", ErrInvalidProfile)
-	}
-	requestedID := strings.TrimSpace(id)
-	if requestedID == "" {
-		return nil, fmt.Errorf("%w: profile id is required", ErrInvalidProfile)
-	}
-	if err := ctx.Err(); err != nil {
-		return nil, err
-	}
-
-	profile, err := r.getRawProfile(ctx, requestedID)
-	if err != nil {
-		return nil, err
-	}
-	if profile == nil {
-		return nil, fmt.Errorf("%w: selected profile %q is nil", ErrInvalidProfile, requestedID)
-	}
-
-	chain := []*domain.ExecutionProfile{profile}
-	chainIDs := []string{requestedID}
-	visited := map[string]struct{}{requestedID: {}}
-	current := profile
-
-	for {
-		baseID := strings.TrimSpace(current.BaseProfileID)
-		if baseID == "" {
-			break
-		}
-		if err := ctx.Err(); err != nil {
-			return nil, err
-		}
-		if _, seen := visited[baseID]; seen {
-			return nil, fmt.Errorf("%w: profile inheritance cycle %s", ErrInvalidProfile, joinProfileChain(chainIDs, baseID))
-		}
-		if len(chain) >= maximumProfileChainLength {
-			return nil, fmt.Errorf("%w: profile inheritance chain exceeds %d profiles: %s", ErrInvalidProfile, maximumProfileChainLength, joinProfileChain(chainIDs, baseID))
-		}
-
-		base, err := r.getRawProfile(ctx, baseID)
-		if err != nil {
-			if errors.Is(err, ErrProfileNotFound) {
-				return nil, fmt.Errorf("%w: base profile %q is missing in chain %s", ErrInvalidProfile, baseID, joinProfileChain(chainIDs, baseID))
-			}
-			return nil, fmt.Errorf("%w: failed to load base profile %q in chain %s: %w", ErrInvalidProfile, baseID, joinProfileChain(chainIDs, baseID), err)
-		}
-		if base == nil {
-			return nil, fmt.Errorf("%w: base profile %q is nil in chain %s", ErrInvalidProfile, baseID, joinProfileChain(chainIDs, baseID))
-		}
-
-		chain = append(chain, base)
-		chainIDs = append(chainIDs, baseID)
-		visited[baseID] = struct{}{}
-		current = base
-	}
-
-	resolved, err := mergeProfileChain(chain)
-	if err != nil {
-		return nil, fmt.Errorf("%w: resolved profile chain %s: %w", ErrInvalidProfile, strings.Join(chainIDs, " -> "), err)
-	}
-	if err := validateResolvedProfile(resolved); err != nil {
-		return nil, fmt.Errorf("%w: resolved profile chain %s: %w", ErrInvalidProfile, strings.Join(chainIDs, " -> "), err)
-	}
-	return resolved, nil
-}
-
-func (r *resolvingRepository) getRawProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	profile, err := r.source.GetProfile(ctx, id)
-	if err != nil {
-		return nil, err
-	}
-	if err := ctx.Err(); err != nil {
-		return nil, err
-	}
-	return profile, nil
-}
-
-func joinProfileChain(chain []string, next string) string {
-	return strings.Join(append(append([]string(nil), chain...), next), " -> ")
-}
-
-func mergeProfileChain(chain []*domain.ExecutionProfile) (*domain.ExecutionProfile, error) {
-	resolved := &domain.ExecutionProfile{ID: chain[0].ID}
-	for index := len(chain) - 1; index >= 0; index-- {
-		definition := chain[index]
-		if strings.TrimSpace(definition.BackendID) != "" {
-			resolved.BackendID = definition.BackendID
-		}
-		if strings.TrimSpace(definition.Endpoint) != "" {
-			resolved.Endpoint = definition.Endpoint
-		}
-		if strings.TrimSpace(definition.Model) != "" {
-			resolved.Model = definition.Model
-		}
-		if definition.Temperature != 0 {
-			resolved.Temperature = definition.Temperature
-		}
-		if definition.MaxTokens != 0 {
-			resolved.MaxTokens = definition.MaxTokens
-		}
-		if definition.TopP != 0 {
-			resolved.TopP = definition.TopP
-		}
-		if definition.TimeoutSeconds != 0 {
-			resolved.TimeoutSeconds = definition.TimeoutSeconds
-		}
-		if strings.TrimSpace(definition.ServiceTier) != "" {
-			resolved.ServiceTier = definition.ServiceTier
-		}
-		if strings.TrimSpace(definition.ReasoningEffort) != "" {
-			resolved.ReasoningEffort = definition.ReasoningEffort
-		}
-		if strings.TrimSpace(definition.APIKeyEnv) != "" {
-			resolved.APIKeyEnv = definition.APIKeyEnv
-		}
-		resolved.APIKeyRequired = resolved.APIKeyRequired || definition.APIKeyRequired
-		if len(definition.ExtraParams) != 0 {
-			extraParams, err := jsonvalue.CopyMap(definition.ExtraParams)
-			if err != nil {
-				return nil, err
-			}
-			resolved.ExtraParams = extraParams
-		}
-	}
-	resolved.ID = chain[0].ID
-	resolved.BaseProfileID = ""
-	return resolved, nil
-}
-
-func validateResolvedProfile(profile *domain.ExecutionProfile) error {
-	if profile == nil {
-		return errors.New("resolved profile is required")
-	}
-	profile.BaseProfileID = ""
-	return NormalizeAndValidateDefinition(profile)
-}

internal/profile/resolving_repository_test.go

@@ -1,418 +0,0 @@
-package profile
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io/fs"
-	"reflect"
-	"strings"
-	"sync"
-	"testing"
-	"testing/fstest"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-)
-
-func TestResolvingRepositoryMergesProfileChain(t *testing.T) {
-	repo := &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-		"leaf": {
-			ID:              "leaf",
-			BaseProfileID:   "middle",
-			BackendID:       "leaf-backend",
-			TopP:            0.8,
-			TimeoutSeconds:  45,
-			ReasoningEffort: "high",
-		},
-		"middle": {
-			ID:             "middle",
-			BaseProfileID:  "root",
-			Endpoint:       "https://middle.example/v1",
-			Model:          "middle-model",
-			MaxTokens:      256,
-			APIKeyEnv:      "MIDDLE_API_KEY",
-			APIKeyRequired: true,
-			ExtraParams:    map[string]any{"middle": map[string]any{"value": "middle"}},
-		},
-		"root": {
-			ID:          "root",
-			BackendID:   "root-backend",
-			Endpoint:    "https://root.example/v1",
-			Model:       "root-model",
-			Temperature: 0.3,
-			ServiceTier: "priority",
-			ExtraParams: map[string]any{"root": "value"},
-		},
-	}}
-
-	got, err := NewResolvingRepository(repo).GetProfile(context.Background(), "leaf")
-	if err != nil {
-		t.Fatalf("resolve profile: %v", err)
-	}
-	want := &domain.ExecutionProfile{
-		ID:              "leaf",
-		BackendID:       "leaf-backend",
-		Endpoint:        "https://middle.example/v1",
-		Model:           "middle-model",
-		Temperature:     0.3,
-		MaxTokens:       256,
-		TopP:            0.8,
-		TimeoutSeconds:  45,
-		ServiceTier:     "priority",
-		ReasoningEffort: "high",
-		APIKeyEnv:       "MIDDLE_API_KEY",
-		APIKeyRequired:  true,
-		ExtraParams:     map[string]any{"middle": map[string]any{"value": "middle"}},
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("resolved profile:\n got %#v\nwant %#v", got, want)
-	}
-}
-
-func TestResolvingRepositoryRejectsMissingSourceAndProfileID(t *testing.T) {
-	if _, err := NewResolvingRepository(nil).GetProfile(context.Background(), "profile"); !errors.Is(err, ErrInvalidProfile) {
-		t.Fatalf("nil source error = %v, want ErrInvalidProfile", err)
-	}
-
-	repo := &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{}}
-	if _, err := NewResolvingRepository(repo).GetProfile(context.Background(), " \t "); !errors.Is(err, ErrInvalidProfile) {
-		t.Fatalf("blank id error = %v, want ErrInvalidProfile", err)
-	}
-	if got := repo.callCount(" "); got != 0 {
-		t.Fatalf("blank id looked up source %d times", got)
-	}
-}
-
-func TestResolvingRepositoryCopiesExtraParams(t *testing.T) {
-	baseParams := map[string]any{"nested": map[string]any{"value": "base"}}
-	repo := &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-		"child": {ID: "child", BaseProfileID: "base"},
-		"base": {
-			ID:          "base",
-			Endpoint:    "https://base.example/v1",
-			Model:       "model",
-			ExtraParams: baseParams,
-		},
-	}}
-	resolver := NewResolvingRepository(repo)
-
-	first, err := resolver.GetProfile(context.Background(), "child")
-	if err != nil {
-		t.Fatalf("resolve inherited map: %v", err)
-	}
-	first.ExtraParams["nested"].(map[string]any)["value"] = "mutated"
-	second, err := resolver.GetProfile(context.Background(), "child")
-	if err != nil {
-		t.Fatalf("resolve inherited map again: %v", err)
-	}
-	if got := second.ExtraParams["nested"].(map[string]any)["value"]; got != "base" {
-		t.Fatalf("later result retained mutation: %v", got)
-	}
-	if got := baseParams["nested"].(map[string]any)["value"]; got != "base" {
-		t.Fatalf("source map retained mutation: %v", got)
-	}
-
-	repo.set("child", &domain.ExecutionProfile{
-		ID:            "child",
-		BaseProfileID: "base",
-		ExtraParams:   map[string]any{"child": "replacement"},
-	})
-	replaced, err := resolver.GetProfile(context.Background(), "child")
-	if err != nil {
-		t.Fatalf("resolve replacement map: %v", err)
-	}
-	if !reflect.DeepEqual(replaced.ExtraParams, map[string]any{"child": "replacement"}) {
-		t.Fatalf("extra params = %#v, want complete child replacement", replaced.ExtraParams)
-	}
-}
-
-func TestResolvingRepositoryUsesRawOverlayForEachLookup(t *testing.T) {
-	leafSource := NewFSRepository(profileTestFS(map[string]string{
-		"leaf.yaml": "id: leaf\nbase_profile: base\n",
-	}), ".")
-	fallback := NewFSRepository(profileTestFS(map[string]string{
-		"base.yaml": "id: base\nendpoint: https://fallback.example/v1\nmodel: fallback-model\n",
-	}), ".")
-	overlay := NewOverlayRepository(leafSource, fallback)
-	resolver := NewResolvingRepository(overlay)
-
-	got, err := resolver.GetProfile(context.Background(), "leaf")
-	if err != nil {
-		t.Fatalf("resolve fallback base: %v", err)
-	}
-	if got.Model != "fallback-model" {
-		t.Fatalf("fallback base model = %q", got.Model)
-	}
-
-	shadowing := NewOverlayRepository(NewFSRepository(profileTestFS(map[string]string{
-		"leaf.yaml": "id: leaf\nbase_profile: base\n",
-		"base.yaml": "id: base\nendpoint: https://primary.example/v1\nmodel: primary-model\n",
-	}), "."), fallback)
-	got, err = NewResolvingRepository(shadowing).GetProfile(context.Background(), "leaf")
-	if err != nil {
-		t.Fatalf("resolve shadowed base: %v", err)
-	}
-	if got.Model != "primary-model" || got.Endpoint != "https://primary.example/v1" {
-		t.Fatalf("shadowed base = %+v", got)
-	}
-}
-
-func TestResolvingRepositoryReportsSafetyAndSourceErrors(t *testing.T) {
-	sourceErr := errors.New("source failure")
-	tests := []struct {
-		name     string
-		repo     *resolvingTestRepository
-		id       string
-		want     []error
-		wantNot  error
-		contains []string
-	}{
-		{
-			name:    "missing selected profile preserves not found",
-			repo:    &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{}},
-			id:      "missing",
-			want:    []error{ErrProfileNotFound},
-			wantNot: ErrInvalidProfile,
-		},
-		{
-			name: "missing base is invalid but not not found",
-			repo: &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-				"leaf": {ID: "leaf", BaseProfileID: "missing"},
-			}},
-			id:       "leaf",
-			want:     []error{ErrInvalidProfile},
-			wantNot:  ErrProfileNotFound,
-			contains: []string{"missing", "leaf -> missing"},
-		},
-		{
-			name: "direct cycle",
-			repo: &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-				"a": {ID: "a", BaseProfileID: "a"},
-			}},
-			id:       "a",
-			want:     []error{ErrInvalidProfile},
-			contains: []string{"a -> a"},
-		},
-		{
-			name: "indirect cycle",
-			repo: &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-				"a": {ID: "a", BaseProfileID: "b"},
-				"b": {ID: "b", BaseProfileID: "c"},
-				"c": {ID: "c", BaseProfileID: "a"},
-			}},
-			id:       "a",
-			want:     []error{ErrInvalidProfile},
-			contains: []string{"a -> b -> c -> a"},
-		},
-		{
-			name: "nil result",
-			repo: &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-				"leaf": nil,
-			}},
-			id:   "leaf",
-			want: []error{ErrInvalidProfile},
-		},
-		{
-			name: "incomplete resolved profile",
-			repo: &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-				"leaf": {ID: "leaf", BaseProfileID: "base"},
-				"base": {ID: "base", Model: "model"},
-			}},
-			id:   "leaf",
-			want: []error{ErrInvalidProfile},
-		},
-		{
-			name: "base source error is retained",
-			repo: &resolvingTestRepository{
-				profiles: map[string]*domain.ExecutionProfile{"leaf": {ID: "leaf", BaseProfileID: "base"}},
-				errors:   map[string]error{"base": sourceErr},
-			},
-			id:   "leaf",
-			want: []error{ErrInvalidProfile, sourceErr},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := NewResolvingRepository(tc.repo).GetProfile(context.Background(), tc.id)
-			for _, want := range tc.want {
-				if !errors.Is(err, want) {
-					t.Fatalf("error = %v, want %v", err, want)
-				}
-			}
-			if tc.wantNot != nil && errors.Is(err, tc.wantNot) {
-				t.Fatalf("error = %v, must not match %v", err, tc.wantNot)
-			}
-			for _, fragment := range tc.contains {
-				if !strings.Contains(err.Error(), fragment) {
-					t.Fatalf("error = %v, want %q", err, fragment)
-				}
-			}
-		})
-	}
-}
-
-func TestResolvingRepositoryEnforcesChainLength(t *testing.T) {
-	for _, count := range []int{maximumProfileChainLength, maximumProfileChainLength + 1} {
-		t.Run(fmt.Sprintf("%d profiles", count), func(t *testing.T) {
-			profiles := make(map[string]*domain.ExecutionProfile, count)
-			for index := 1; index <= count; index++ {
-				id := fmt.Sprintf("profile-%d", index)
-				definition := &domain.ExecutionProfile{ID: id}
-				if index == count {
-					definition.Endpoint = "https://root.example/v1"
-					definition.Model = "model"
-				} else {
-					definition.BaseProfileID = fmt.Sprintf("profile-%d", index+1)
-				}
-				profiles[id] = definition
-			}
-
-			got, err := NewResolvingRepository(&resolvingTestRepository{profiles: profiles}).GetProfile(context.Background(), "profile-1")
-			if count == maximumProfileChainLength {
-				if err != nil || got == nil {
-					t.Fatalf("profile = %+v, error = %v, want accepted chain", got, err)
-				}
-				return
-			}
-			if !errors.Is(err, ErrInvalidProfile) {
-				t.Fatalf("error = %v, want ErrInvalidProfile", err)
-			}
-		})
-	}
-}
-
-func TestResolvingRepositoryIsFreshAndCancellationAware(t *testing.T) {
-	repo := &resolvingTestRepository{profiles: map[string]*domain.ExecutionProfile{
-		"leaf": {ID: "leaf", BaseProfileID: "base"},
-		"base": {ID: "base", Endpoint: "https://base.example/v1", Model: "first", ExtraParams: map[string]any{"nested": map[string]any{"value": "first"}}},
-	}}
-	resolver := NewResolvingRepository(repo)
-
-	first, err := resolver.GetProfile(context.Background(), "leaf")
-	if err != nil || first.Model != "first" {
-		t.Fatalf("first result=(%+v, %v)", first, err)
-	}
-	repo.set("base", &domain.ExecutionProfile{ID: "base", Endpoint: "https://base.example/v1", Model: "second", ExtraParams: map[string]any{"nested": map[string]any{"value": "second"}}})
-	second, err := resolver.GetProfile(context.Background(), "leaf")
-	if err != nil || second.Model != "second" {
-		t.Fatalf("second result=(%+v, %v)", second, err)
-	}
-
-	canceled, cancel := context.WithCancel(context.Background())
-	cancel()
-	if _, err := resolver.GetProfile(canceled, "leaf"); !errors.Is(err, context.Canceled) {
-		t.Fatalf("canceled lookup error = %v", err)
-	}
-	if got := repo.callCount("leaf"); got != 2 {
-		t.Fatalf("calls after canceled lookup = %d, want 2", got)
-	}
-
-	duringTraversal, cancelDuringTraversal := context.WithCancel(context.Background())
-	repo.afterGet = func(id string) {
-		if id == "leaf" {
-			cancelDuringTraversal()
-		}
-	}
-	if _, err := resolver.GetProfile(duringTraversal, "leaf"); !errors.Is(err, context.Canceled) {
-		t.Fatalf("during traversal error = %v", err)
-	}
-	if got := repo.callCount("base"); got != 2 {
-		t.Fatalf("base calls after cancellation = %d, want 2", got)
-	}
-
-	terminalLookup, cancelTerminalLookup := context.WithCancel(context.Background())
-	repo.afterGet = func(id string) {
-		if id == "base" {
-			cancelTerminalLookup()
-		}
-	}
-	if _, err := resolver.GetProfile(terminalLookup, "leaf"); !errors.Is(err, context.Canceled) {
-		t.Fatalf("terminal lookup cancellation error = %v", err)
-	}
-	if got := repo.callCount("base"); got != 3 {
-		t.Fatalf("base calls after terminal cancellation = %d, want 3", got)
-	}
-
-	repo.afterGet = nil
-	var wg sync.WaitGroup
-	errors := make(chan error, 8)
-	for index := 0; index < cap(errors); index++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			resolved, err := resolver.GetProfile(context.Background(), "leaf")
-			if err != nil {
-				errors <- err
-				return
-			}
-			resolved.ExtraParams["nested"].(map[string]any)["value"] = "mutated"
-		}()
-	}
-	wg.Wait()
-	close(errors)
-	for err := range errors {
-		t.Errorf("concurrent resolution: %v", err)
-	}
-	latest, err := resolver.GetProfile(context.Background(), "leaf")
-	if err != nil || latest.ExtraParams["nested"].(map[string]any)["value"] != "second" {
-		t.Fatalf("latest result=(%+v, %v)", latest, err)
-	}
-}
-
-type resolvingTestRepository struct {
-	mu       sync.Mutex
-	profiles map[string]*domain.ExecutionProfile
-	errors   map[string]error
-	calls    map[string]int
-	afterGet func(string)
-}
-
-func (r *resolvingTestRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, err
-	}
-	r.mu.Lock()
-	if r.calls == nil {
-		r.calls = make(map[string]int)
-	}
-	r.calls[id]++
-	err := r.errors[id]
-	profile := r.profiles[id]
-	afterGet := r.afterGet
-	r.mu.Unlock()
-	if afterGet != nil {
-		afterGet(id)
-	}
-	if err != nil {
-		return nil, err
-	}
-	if profile == nil {
-		if _, exists := r.profiles[id]; exists {
-			return nil, nil
-		}
-		return nil, ErrProfileNotFound
-	}
-	copy := *profile
-	return &copy, nil
-}
-
-func (r *resolvingTestRepository) set(id string, profile *domain.ExecutionProfile) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.profiles[id] = profile
-}
-
-func (r *resolvingTestRepository) callCount(id string) int {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	return r.calls[id]
-}
-
-func profileTestFS(files map[string]string) fs.FS {
-	fsys := make(fstest.MapFS, len(files))
-	for name, content := range files {
-		fsys[name] = profileMapFile(content)
-	}
-	return fsys
-}

internal/profile/testdata/invalid_yaml.yaml

@@ -1,3 +0,0 @@
-id: invalid_yaml
-endpoint: http://localhost:8000/v1
-model: [broken

internal/profile/testdata/missing_endpoint.yaml

@@ -1,2 +0,0 @@
-id: missing-endpoint
-model: gpt-4o-mini

internal/profile/testdata/missing_id.yaml

@@ -1,2 +0,0 @@
-endpoint: http://localhost:8000/v1
-model: gpt-4o-mini

internal/profile/testdata/missing_model.yaml

@@ -1,2 +0,0 @@
-id: missing-model
-endpoint: http://localhost:8000/v1

internal/profile/testdata/raw_api_key.yaml

@@ -1,4 +0,0 @@
-id: raw-api-key
-endpoint: http://localhost:8000/v1
-model: gpt-4o-mini
-api_key: super-secret-should-not-be-here

internal/profile/testdata/unknown_field.yaml

@@ -1,4 +0,0 @@
-id: unknown-field
-endpoint: http://localhost:8000/v1
-model: gpt-4o-mini
-foo: bar

internal/profile/testdata/valid_local_profile.yaml

@@ -1,7 +0,0 @@
-id: local-default
-endpoint: http://localhost:8000/v1
-model: gpt-4o-mini
-temperature: 0.2
-max_tokens: 700
-top_p: 1.0
-timeout_seconds: 120

internal/profile/testdata/valid_with_api_key_env.yaml

@@ -1,8 +0,0 @@
-id: local-secure
-endpoint: http://localhost:8000/v1
-model: gpt-4o-mini
-api_key_env: PROMPTKIT_API_KEY
-service_tier: priority
-reasoning_effort: medium
-extra_params:
-  provider: local

internal/prompt/compiled_renderer_benchmark_test.go

@@ -0,0 +1,254 @@
+package prompt
+
+import (
+	"bytes"
+	"context"
+	"runtime"
+	"strconv"
+	"testing"
+	"text/template"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+const rendererBenchmarkArtifactSize = 256 << 10
+
+var (
+	renderedPromptBenchmarkSink  *domain.RenderedPrompt
+	renderedPromptsBenchmarkSink []*domain.RenderedPrompt
+)
+
+type rendererBenchmarkIdentity struct {
+	id      string
+	version string
+}
+
+type rendererBenchmarkLookup struct {
+	identity  rendererBenchmarkIdentity
+	templates CompiledTemplates
+}
+
+func (lookup rendererBenchmarkLookup) GetCompiledTemplates(id, version string) (CompiledTemplates, bool) {
+	if id != lookup.identity.id || version != lookup.identity.version {
+		return CompiledTemplates{}, false
+	}
+	return lookup.templates, true
+}
+
+type compiledRenderingBenchmarkCase struct {
+	name        string
+	renderer    Renderer
+	definition  *domain.PromptDefinition
+	inputs      map[string]*domain.Artifact
+	vars        map[string]string
+	ctx         context.Context
+	outputBytes int
+	check       func(*testing.B, *domain.RenderedPrompt)
+}
+
+func BenchmarkCompiledRendering(b *testing.B) {
+	body := bytes.Repeat([]byte("x"), rendererBenchmarkArtifactSize)
+	bodyText := string(body)
+
+	small := newCompiledRenderingBenchmarkCase(b,
+		"small_message", "", []string{"Summary for {{.audience}}."},
+		&domain.PromptDefinition{
+			ID: "compiled-render-benchmark", Version: "v1",
+			Templates: []domain.PromptMessageTemplate{{Role: "user", Content: "Summary for {{.audience}}."}},
+		}, nil, map[string]string{"audience": "project leads"},
+		len("Summary for project leads."),
+		func(b *testing.B, rendered *domain.RenderedPrompt) {
+			if rendered.SessionID != "" || len(rendered.Messages) != 1 || rendered.Messages[0].Content != "Summary for project leads." {
+				b.Fatalf("unexpected small compiled render: %+v", rendered)
+			}
+		},
+	)
+
+	artifactInputs := map[string]*domain.Artifact{
+		"document": {Name: "document", Body: body},
+	}
+	largeContent := `{{input "document"}}`
+	largeDefinition := &domain.PromptDefinition{
+		ID: "compiled-render-benchmark", Version: "v1",
+		Inputs:    []domain.PromptInput{{Name: "document"}},
+		Templates: []domain.PromptMessageTemplate{{Role: "user", Content: largeContent}},
+	}
+	large := newCompiledRenderingBenchmarkCase(b,
+		"artifact_backed_256KiB", "", []string{largeContent},
+		largeDefinition, artifactInputs, nil, len(bodyText),
+		func(b *testing.B, rendered *domain.RenderedPrompt) {
+			if len(rendered.Messages) != 1 {
+				b.Fatalf("artifact render message count=%d, want 1", len(rendered.Messages))
+			}
+			if rendered.Messages[0].Content != bodyText {
+				b.Fatalf("artifact render length=%d, want %d", len(rendered.Messages[0].Content), len(bodyText))
+			}
+		},
+	)
+
+	repeatedSession := `document-size={{len (input "document")}}`
+	repeatedMessages := []string{
+		`{{input "document"}}`,
+		`{{input "document"}}|{{input "document"}}`,
+	}
+	repeatedDefinition := &domain.PromptDefinition{
+		ID: "compiled-render-benchmark", Version: "v1", SessionID: repeatedSession,
+		Inputs: []domain.PromptInput{{Name: "document"}},
+		Templates: []domain.PromptMessageTemplate{
+			{Role: "system", Content: repeatedMessages[0]},
+			{Role: "user", Content: repeatedMessages[1]},
+		},
+	}
+	repeatedOutputBytes := len(bodyText)*3 + 1
+	repeated := newCompiledRenderingBenchmarkCase(b,
+		"repeated_across_session_and_messages", repeatedSession, repeatedMessages,
+		repeatedDefinition, artifactInputs, nil, repeatedOutputBytes,
+		func(b *testing.B, rendered *domain.RenderedPrompt) {
+			if rendered.SessionID != "document-size="+strconv.Itoa(len(bodyText)) || len(rendered.Messages) != 2 ||
+				rendered.Messages[0].Content != bodyText || rendered.Messages[1].Content != bodyText+"|"+bodyText {
+				b.Fatalf("unexpected repeated compiled render: session=%q message lengths=%v", rendered.SessionID, renderedMessageLengths(rendered))
+			}
+		},
+	)
+
+	for _, benchmark := range []compiledRenderingBenchmarkCase{small, large, repeated} {
+		b.Run(benchmark.name, func(b *testing.B) {
+			rendered, err := benchmark.renderer.Render(benchmark.ctx, benchmark.definition, benchmark.inputs, benchmark.vars)
+			if err != nil {
+				b.Fatalf("check compiled renderer output: %v", err)
+			}
+			benchmark.check(b, rendered)
+
+			b.ReportAllocs()
+			b.SetBytes(int64(benchmark.outputBytes))
+			b.ResetTimer()
+			for range b.N {
+				rendered, err := benchmark.renderer.Render(benchmark.ctx, benchmark.definition, benchmark.inputs, benchmark.vars)
+				if err != nil {
+					b.Fatalf("render compiled template: %v", err)
+				}
+				renderedPromptBenchmarkSink = rendered
+			}
+			b.StopTimer()
+			runtime.KeepAlive(renderedPromptBenchmarkSink)
+		})
+	}
+}
+
+// BenchmarkRetainedRenderedOutput reports post-GC live heap for a fixed batch
+// of rendered outputs above the same fixture's setup-only baseline.
+func BenchmarkRetainedRenderedOutput(b *testing.B) {
+	body := bytes.Repeat([]byte("x"), rendererBenchmarkArtifactSize)
+	bodyText := string(body)
+	content := `{{input "document"}}`
+	definition := &domain.PromptDefinition{
+		ID: "retained-render-benchmark", Version: "v1",
+		Inputs:    []domain.PromptInput{{Name: "document"}},
+		Templates: []domain.PromptMessageTemplate{{Role: "user", Content: content}},
+	}
+	compiled := CompiledTemplates{Messages: []*template.Template{mustCompileRendererBenchmarkTemplate(b, content)}}
+	renderer := NewCompiledRenderer(rendererBenchmarkLookup{
+		identity:  rendererBenchmarkIdentity{id: definition.ID, version: definition.Version},
+		templates: compiled,
+	})
+	inputs := map[string]*domain.Artifact{"document": {Name: "document", Body: body}}
+	ctx := context.Background()
+	const retainedBatchSize = 4
+	retained := make([]*domain.RenderedPrompt, retainedBatchSize)
+
+	check, err := renderer.Render(ctx, definition, inputs, nil)
+	if err != nil {
+		b.Fatalf("check retained-output fixture: %v", err)
+	}
+	if len(check.Messages) != 1 || check.Messages[0].Content != bodyText {
+		b.Fatalf("retained-output fixture returned unexpected content")
+	}
+	check = nil
+	// Repeated -count runs must start from the same setup-only heap baseline.
+	renderedPromptBenchmarkSink = nil
+	renderedPromptsBenchmarkSink = nil
+
+	runtime.GC()
+	var setupMemory runtime.MemStats
+	runtime.ReadMemStats(&setupMemory)
+	runtime.KeepAlive(renderer)
+	runtime.KeepAlive(definition)
+	runtime.KeepAlive(inputs)
+
+	b.ReportAllocs()
+	b.SetBytes(int64(len(bodyText)))
+	b.ResetTimer()
+	for iteration := 0; iteration < b.N; iteration++ {
+		rendered, err := renderer.Render(ctx, definition, inputs, nil)
+		if err != nil {
+			b.Fatalf("render retained-output fixture: %v", err)
+		}
+		retained[iteration%len(retained)] = rendered
+	}
+	b.StopTimer()
+	for i, rendered := range retained {
+		if rendered != nil {
+			continue
+		}
+		rendered, err := renderer.Render(ctx, definition, inputs, nil)
+		if err != nil {
+			b.Fatalf("fill retained-output fixture: %v", err)
+		}
+		retained[i] = rendered
+	}
+	renderedPromptsBenchmarkSink = retained
+	runtime.GC()
+	var retainedMemory runtime.MemStats
+	runtime.ReadMemStats(&retainedMemory)
+	b.ReportMetric(float64(int64(retainedMemory.HeapAlloc)-int64(setupMemory.HeapAlloc)), "retained-B")
+	runtime.KeepAlive(retained)
+	runtime.KeepAlive(renderer)
+	runtime.KeepAlive(definition)
+	runtime.KeepAlive(inputs)
+}
+
+func newCompiledRenderingBenchmarkCase(
+	b *testing.B,
+	name string,
+	session string,
+	messages []string,
+	definition *domain.PromptDefinition,
+	inputs map[string]*domain.Artifact,
+	vars map[string]string,
+	outputBytes int,
+	check func(*testing.B, *domain.RenderedPrompt),
+) compiledRenderingBenchmarkCase {
+	compiled := CompiledTemplates{}
+	if session != "" {
+		compiled.Session = mustCompileRendererBenchmarkTemplate(b, session)
+	}
+	for _, content := range messages {
+		compiled.Messages = append(compiled.Messages, mustCompileRendererBenchmarkTemplate(b, content))
+	}
+	return compiledRenderingBenchmarkCase{
+		name: name,
+		renderer: NewCompiledRenderer(rendererBenchmarkLookup{
+			identity:  rendererBenchmarkIdentity{id: definition.ID, version: definition.Version},
+			templates: compiled,
+		}),
+		definition: definition, inputs: inputs, vars: vars, ctx: context.Background(),
+		outputBytes: outputBytes, check: check,
+	}
+}
+
+func mustCompileRendererBenchmarkTemplate(b *testing.B, source string) *template.Template {
+	b.Helper()
+	compiled, err := CompileTemplate("benchmark", source)
+	if err != nil {
+		b.Fatalf("compile benchmark template: %v", err)
+	}
+	return compiled
+}
+
+func renderedMessageLengths(rendered *domain.RenderedPrompt) []int {
+	lengths := make([]int, len(rendered.Messages))
+	for i, message := range rendered.Messages {
+		lengths[i] = len(message.Content)
+	}
+	return lengths
+}

internal/prompt/go_renderer.go

@@ -1,7 +1,6 @@
 package prompt
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -21,12 +20,20 @@ var (
 
 const artifactTextChunkSize = 64 * 1024
 
-type goRenderer struct{}
+type goRenderer struct {
+	templates TemplateLookup
+}
 
 func NewGoRenderer() Renderer {
 	return &goRenderer{}
 }
 
+// NewCompiledRenderer renders definitions using templates captured with the
+// configuration snapshot. Per-call clones bind request-specific input helpers.
+func NewCompiledRenderer(templates TemplateLookup) Renderer {
+	return &goRenderer{templates: templates}
+}
+
 func (r *goRenderer) Render(ctx context.Context, definition *domain.PromptDefinition, inputs map[string]*domain.Artifact, vars map[string]string) (*domain.RenderedPrompt, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, err
@@ -49,11 +56,30 @@ func (r *goRenderer) Render(ctx context.Context, definition *domain.PromptDefini
 	funcs := template.FuncMap{
 		"input": resolver.resolve,
 	}
+	var compiled CompiledTemplates
+	if r.templates != nil {
+		var found bool
+		compiled, found = r.templates.GetCompiledTemplates(definition.ID, definition.Version)
+		if !found || len(compiled.Messages) != len(definition.Templates) {
+			return nil, fmt.Errorf("%w: captured templates are unavailable", ErrRenderFailure)
+		}
+	}
 
 	if err := ctx.Err(); err != nil {
 		return nil, err
 	}
-	sessionID, err := renderSessionID(ctx, definition.SessionID, funcs, vars)
+	var sessionID string
+	var err error
+	if r.templates != nil {
+		if definition.SessionID != "" {
+			if compiled.Session == nil {
+				return nil, fmt.Errorf("%w: captured session template is unavailable", ErrRenderFailure)
+			}
+			sessionID, err = renderCompiledSessionID(ctx, compiled.Session, funcs, vars)
+		}
+	} else {
+		sessionID, err = renderSessionID(ctx, definition.SessionID, funcs, vars)
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -76,7 +102,19 @@ func (r *goRenderer) Render(ctx context.Context, definition *domain.PromptDefini
 		if err := ctx.Err(); err != nil {
 			return nil, err
 		}
-		tmpl, parseErr := template.New(fmt.Sprintf("msg_%d", i)).Funcs(funcs).Option("missingkey=error").Parse(tmplMsg.Content)
+		var tmpl *template.Template
+		var parseErr error
+		if r.templates != nil {
+			if compiled.Messages[i] == nil {
+				return nil, fmt.Errorf("%w: captured message template is unavailable", ErrRenderFailure)
+			}
+			tmpl, parseErr = compiled.Messages[i].Clone()
+			if parseErr == nil {
+				tmpl.Funcs(funcs)
+			}
+		} else {
+			tmpl, parseErr = parseTemplate(fmt.Sprintf("msg_%d", i), tmplMsg.Content, funcs)
+		}
 		if err := ctx.Err(); err != nil {
 			return nil, err
 		}
@@ -87,7 +125,7 @@ func (r *goRenderer) Render(ctx context.Context, definition *domain.PromptDefini
 		if err := ctx.Err(); err != nil {
 			return nil, err
 		}
-		var buf bytes.Buffer
+		var buf strings.Builder
 		executeErr := tmpl.Execute(&buf, vars)
 		if err := ctx.Err(); err != nil {
 			return nil, err
@@ -167,18 +205,36 @@ func renderSessionID(ctx context.Context, raw string, funcs template.FuncMap, va
 	if err := ctx.Err(); err != nil {
 		return "", err
 	}
-	tmpl, parseErr := template.New("session_id").Funcs(funcs).Option("missingkey=error").Parse(raw)
+	tmpl, parseErr := parseTemplate("session_id", raw, funcs)
 	if err := ctx.Err(); err != nil {
 		return "", err
 	}
 	if parseErr != nil {
 		return "", fmt.Errorf("%w: session_id: %v", ErrInvalidTemplate, parseErr)
 	}
+	return executeSessionTemplate(ctx, tmpl, vars)
+}
 
+func renderCompiledSessionID(ctx context.Context, compiled *template.Template, funcs template.FuncMap, vars map[string]string) (string, error) {
 	if err := ctx.Err(); err != nil {
 		return "", err
 	}
-	var buf bytes.Buffer
+	tmpl, err := compiled.Clone()
+	if err := ctx.Err(); err != nil {
+		return "", err
+	}
+	if err != nil {
+		return "", fmt.Errorf("%w: session_id: %v", ErrRenderFailure, err)
+	}
+	tmpl.Funcs(funcs)
+	return executeSessionTemplate(ctx, tmpl, vars)
+}
+
+func executeSessionTemplate(ctx context.Context, tmpl *template.Template, vars map[string]string) (string, error) {
+	if err := ctx.Err(); err != nil {
+		return "", err
+	}
+	var buf strings.Builder
 	executeErr := tmpl.Execute(&buf, vars)
 	if err := ctx.Err(); err != nil {
 		return "", err

internal/prompt/renderer_test.go

@@ -4,8 +4,11 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
 	"strings"
+	"sync"
 	"testing"
+	"text/template"
 
 	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
 )
@@ -501,6 +504,77 @@ func TestGoRendererArtifactTextLifecycle(t *testing.T) {
 	}
 }
 
+func TestCompiledRendererKeepsConcurrentRequestsIndependent(t *testing.T) {
+	const (
+		promptID = "concurrent-render"
+		version  = "v1"
+	)
+	sessionTemplate, err := CompileTemplate("session", "session-{{.request}}")
+	if err != nil {
+		t.Fatalf("compile session template: %v", err)
+	}
+	messageTemplate, err := CompileTemplate("message", `request={{.request}};document={{input "document"}}`)
+	if err != nil {
+		t.Fatalf("compile message template: %v", err)
+	}
+	renderer := NewCompiledRenderer(compiledRendererTestLookup{
+		id:      promptID,
+		version: version,
+		templates: CompiledTemplates{
+			Session:  sessionTemplate,
+			Messages: []*template.Template{messageTemplate},
+		},
+	})
+	definition := &domain.PromptDefinition{
+		ID: promptID, Version: version, SessionID: "session-{{.request}}",
+		Inputs:    []domain.PromptInput{{Name: "document"}},
+		Templates: []domain.PromptMessageTemplate{{Role: "user", Content: `request={{.request}};document={{input "document"}}`}},
+	}
+
+	const requestCount = 24
+	errs := make(chan error, requestCount)
+	var wait sync.WaitGroup
+	wait.Add(requestCount)
+	for i := 0; i < requestCount; i++ {
+		go func(i int) {
+			defer wait.Done()
+			request := fmt.Sprintf("request-%d", i)
+			document := fmt.Sprintf("document-%d", i)
+			rendered, err := renderer.Render(context.Background(), definition,
+				map[string]*domain.Artifact{"document": {Body: []byte(document)}},
+				map[string]string{"request": request},
+			)
+			if err != nil {
+				errs <- fmt.Errorf("render %s: %w", request, err)
+				return
+			}
+			if rendered.SessionID != "session-"+request || len(rendered.Messages) != 1 ||
+				rendered.Messages[0].Content != "request="+request+";document="+document {
+				errs <- fmt.Errorf("render %s returned session %q and messages %#v", request, rendered.SessionID, rendered.Messages)
+			}
+		}(i)
+	}
+	wait.Wait()
+	close(errs)
+	for err := range errs {
+		t.Error(err)
+	}
+}
+
+type compiledRendererTestLookup struct {
+	id, version string
+	templates   CompiledTemplates
+}
+
+func (lookup compiledRendererTestLookup) GetCompiledTemplates(id, version string) (CompiledTemplates, bool) {
+	if id != lookup.id || version != lookup.version {
+		return CompiledTemplates{}, false
+	}
+	return lookup.templates, true
+}
+
+// BenchmarkGoRendererArtifactReferences measures NewGoRenderer's per-call
+// template-parsing fallback rather than the captured compiled path.
 func BenchmarkGoRendererArtifactReferences(b *testing.B) {
 	body := bytes.Repeat([]byte("document content "), (artifactTextChunkSize*4)/len("document content "))
 	inputs := map[string]*domain.Artifact{

internal/prompt/requirements.go

@@ -0,0 +1,978 @@
+package prompt
+
+import (
+	"context"
+	"sort"
+	"text/template"
+	"text/template/parse"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+type requirementReachability uint8
+
+const (
+	requirementDefinite requirementReachability = iota
+	requirementPossible
+	requirementInactive
+)
+
+type dotIdentity uint8
+
+const (
+	dotRoot dotIdentity = iota
+	dotNonRoot
+	dotUnknown
+)
+
+type inputEvidence struct {
+	name        string
+	kind        domain.RequirementKind
+	declared    bool
+	applicable  bool
+	contentType *string
+	description *string
+	explanation string
+}
+
+type variableEvidence struct {
+	name        string
+	kind        domain.RequirementKind
+	applicable  bool
+	explanation string
+}
+
+type requirementIssueKey struct {
+	code         domain.RequirementIssueCode
+	inputName    string
+	variableName string
+}
+
+type conditionEvaluation struct {
+	value            any
+	known            bool
+	unsupported      bool
+	inputNameUnknown bool
+	missingVariables map[string]struct{}
+	contentInputs    map[string]struct{}
+}
+
+func (evaluation conditionEvaluation) truth() bool {
+	truth, ok := template.IsTrue(evaluation.value)
+	return evaluation.known && ok && truth
+}
+
+func (walker *requirementWalker) evaluateCondition(pipe *parse.PipeNode, reach requirementReachability, dot dotIdentity) conditionEvaluation {
+	if pipe == nil {
+		return conditionEvaluation{unsupported: true}
+	}
+	if len(pipe.Cmds) == 1 && len(pipe.Decl) == 0 && !pipe.IsAssign {
+		return walker.evaluateCommand(pipe.Cmds[0], reach, dot)
+	}
+	if name, ok := directInputPipeline(pipe); ok {
+		return walker.evaluateInputName(name, reach, dot)
+	}
+	before := walker.dependencies
+	visitReach := requirementPossible
+	if reach == requirementInactive {
+		visitReach = requirementInactive
+	}
+	if err := walker.visitPipe(pipe, visitReach, dot); err != nil {
+		return conditionEvaluation{unsupported: true}
+	}
+	return conditionEvaluation{unsupported: walker.dependencies != before}
+}
+
+func (walker *requirementWalker) evaluateCommand(command *parse.CommandNode, reach requirementReachability, dot dotIdentity) conditionEvaluation {
+	if command == nil || len(command.Args) == 0 {
+		return conditionEvaluation{unsupported: true}
+	}
+	identifier, isIdentifier := command.Args[0].(*parse.IdentifierNode)
+	if isIdentifier {
+		switch identifier.Ident {
+		case "input":
+			if reach == requirementInactive {
+				if len(command.Args) == 2 {
+					if name, ok := literalStringValue(command.Args[1]); ok {
+						walker.recordInput(name, requirementInactive)
+						return conditionEvaluation{}
+					}
+				}
+				for _, argument := range command.Args[1:] {
+					_ = walker.visit(argument, requirementInactive, dot)
+				}
+				return conditionEvaluation{}
+			}
+			if len(command.Args) == 2 {
+				if name, ok := command.Args[1].(*parse.StringNode); ok {
+					walker.recordInput(name.Text, reach)
+					return conditionEvaluation{contentInputs: map[string]struct{}{name.Text: {}}}
+				}
+				return walker.evaluateInputName(command.Args[1], reach, dot)
+			}
+			for _, argument := range command.Args[1:] {
+				_ = walker.visit(argument, requirementPossible, dot)
+			}
+			return walker.unresolvedInputName(conditionEvaluation{unsupported: true})
+		case "index":
+			if len(command.Args) == 3 {
+				if key, ok := command.Args[2].(*parse.StringNode); ok && isRootMap(command.Args[1], dot, walker.rootKnown) {
+					walker.recordOptionalVariable(key.Text, reach)
+					value, supplied := walker.vars[key.Text]
+					if !supplied {
+						value = ""
+					}
+					return conditionEvaluation{value: value, known: true}
+				}
+			}
+		case "not":
+			if len(command.Args) == 2 {
+				evaluation := walker.evaluateValue(command.Args[1], reach, dot)
+				if evaluation.known {
+					truth, ok := template.IsTrue(evaluation.value)
+					if ok {
+						evaluation.value = !truth
+					} else {
+						evaluation.known = false
+						evaluation.unsupported = true
+					}
+				}
+				return evaluation
+			}
+		case "eq", "ne":
+			if len(command.Args) == 3 {
+				left := walker.evaluateValue(command.Args[1], reach, dot)
+				right := walker.evaluateValue(command.Args[2], reach, dot)
+				result := mergeConditionEvaluations(left, right)
+				if left.known && right.known {
+					leftString, leftOK := left.value.(string)
+					rightString, rightOK := right.value.(string)
+					if leftOK && rightOK {
+						equal := leftString == rightString
+						if identifier.Ident == "ne" {
+							equal = !equal
+						}
+						result.value = equal
+						result.known = true
+						return result
+					}
+					result.unsupported = true
+				}
+				return result
+			}
+		}
+	}
+	if !isIdentifier && len(command.Args) == 1 {
+		return walker.evaluateValue(command.Args[0], reach, dot)
+	}
+	if reach == requirementInactive {
+		_ = walker.visitCommand(command, reach, dot)
+		return conditionEvaluation{}
+	}
+	before := walker.dependencies
+	_ = walker.visitCommand(command, requirementPossible, dot)
+	return conditionEvaluation{unsupported: walker.dependencies != before}
+}
+
+func (walker *requirementWalker) evaluateValue(node parse.Node, reach requirementReachability, dot dotIdentity) conditionEvaluation {
+	switch node := node.(type) {
+	case *parse.DotNode:
+		if dot == dotRoot {
+			return conditionEvaluation{value: walker.vars, known: true}
+		}
+		if dot == dotUnknown {
+			walker.unresolvedVariableScope(reach)
+		}
+		return conditionEvaluation{unsupported: true}
+	case *parse.StringNode:
+		return conditionEvaluation{value: node.Text, known: true}
+	case *parse.BoolNode:
+		return conditionEvaluation{value: node.True, known: true}
+	case *parse.NilNode:
+		return conditionEvaluation{value: nil, known: true}
+	case *parse.FieldNode:
+		if dot != dotRoot || len(node.Ident) == 0 {
+			if dot == dotUnknown {
+				walker.unresolvedVariableScope(reach)
+			}
+			return conditionEvaluation{unsupported: true}
+		}
+		name := node.Ident[0]
+		walker.recordVariable(name, reach)
+		if len(node.Ident) > 1 {
+			walker.addIssue("", name, "A chained field access is outside the direct-key scope.")
+			return conditionEvaluation{unsupported: true}
+		}
+		value, supplied := walker.vars[name]
+		if !supplied {
+			return conditionEvaluation{missingVariables: map[string]struct{}{name: {}}}
+		}
+		return conditionEvaluation{value: value, known: true}
+	case *parse.VariableNode:
+		if len(node.Ident) == 1 && node.Ident[0] == "$" && walker.rootKnown {
+			return conditionEvaluation{value: walker.vars, known: true}
+		}
+		if len(node.Ident) < 2 || node.Ident[0] != "$" || !walker.rootKnown {
+			walker.visitVariable(node, reach)
+			return conditionEvaluation{unsupported: true}
+		}
+		name := node.Ident[1]
+		walker.recordVariable(name, reach)
+		if len(node.Ident) > 2 {
+			walker.addIssue("", name, "A chained field access is outside the direct-key scope.")
+			return conditionEvaluation{unsupported: true}
+		}
+		value, supplied := walker.vars[name]
+		if !supplied {
+			return conditionEvaluation{missingVariables: map[string]struct{}{name: {}}}
+		}
+		return conditionEvaluation{value: value, known: true}
+	case *parse.CommandNode:
+		return walker.evaluateCommand(node, reach, dot)
+	case *parse.PipeNode:
+		return walker.evaluateCondition(node, reach, dot)
+	case *parse.ChainNode:
+		before := walker.dependencies
+		visitReach := requirementPossible
+		if reach == requirementInactive {
+			visitReach = requirementInactive
+		}
+		_ = walker.visit(node.Node, visitReach, dot)
+		return conditionEvaluation{unsupported: walker.dependencies != before}
+	default:
+		return conditionEvaluation{unsupported: true}
+	}
+}
+
+func (walker *requirementWalker) evaluateInputName(node parse.Node, reach requirementReachability, dot dotIdentity) conditionEvaluation {
+	evaluation := walker.evaluateValue(node, reach, dot)
+	if evaluation.known {
+		if name, ok := evaluation.value.(string); ok {
+			walker.recordInput(name, reach)
+			return conditionEvaluation{contentInputs: map[string]struct{}{name: {}}}
+		}
+		evaluation.unsupported = true
+	}
+	// Value analysis has already visited recognizable references, including
+	// the conservative fallback for unsupported expressions. Do not rescan
+	// the same subtree: nested computed names would multiply that work.
+	return walker.unresolvedInputName(evaluation)
+}
+
+func (walker *requirementWalker) unresolvedInputName(evaluation conditionEvaluation) conditionEvaluation {
+	for name := range evaluation.missingVariables {
+		walker.addIssueCode(domain.RequirementIssueMissingVariable, "", name, "A missing variable prevents resolving an input name.")
+	}
+	for name := range evaluation.contentInputs {
+		walker.addIssueCode(domain.RequirementIssueInputContent, name, "", "Captured input content affects an input name.")
+	}
+	walker.addIssueCode(domain.RequirementIssueDynamicInputName, "", "", "An input helper name is not statically available.")
+	walker.unknownInputEffect = true
+	evaluation.inputNameUnknown = true
+	return evaluation
+}
+
+func directInputPipeline(pipe *parse.PipeNode) (parse.Node, bool) {
+	if pipe == nil || len(pipe.Cmds) != 2 || len(pipe.Decl) != 0 || pipe.IsAssign {
+		return nil, false
+	}
+	input := pipe.Cmds[1]
+	if len(input.Args) != 1 {
+		return nil, false
+	}
+	identifier, ok := input.Args[0].(*parse.IdentifierNode)
+	if !ok || identifier.Ident != "input" {
+		return nil, false
+	}
+	value := pipe.Cmds[0]
+	if len(value.Args) > 0 {
+		valueIdentifier, isValueIdentifier := value.Args[0].(*parse.IdentifierNode)
+		if isValueIdentifier && valueIdentifier.Ident == "input" && len(value.Args) == 2 {
+			return value, true
+		}
+	}
+	if len(value.Args) == 1 {
+		return value.Args[0], true
+	}
+	if len(value.Args) == 3 {
+		function, ok := value.Args[0].(*parse.IdentifierNode)
+		if ok && function.Ident == "index" {
+			return value, true
+		}
+	}
+	return nil, false
+}
+
+func literalStringValue(node parse.Node) (string, bool) {
+	switch node := node.(type) {
+	case *parse.StringNode:
+		return node.Text, true
+	case *parse.PipeNode:
+		if len(node.Cmds) == 1 && len(node.Cmds[0].Args) == 1 && len(node.Decl) == 0 && !node.IsAssign {
+			return literalStringValue(node.Cmds[0].Args[0])
+		}
+	}
+	return "", false
+}
+
+func mergeConditionEvaluations(left, right conditionEvaluation) conditionEvaluation {
+	result := conditionEvaluation{
+		unsupported:      left.unsupported || right.unsupported,
+		inputNameUnknown: left.inputNameUnknown || right.inputNameUnknown,
+		missingVariables: make(map[string]struct{}, len(left.missingVariables)+len(right.missingVariables)),
+		contentInputs:    make(map[string]struct{}, len(left.contentInputs)+len(right.contentInputs)),
+	}
+	for name := range left.missingVariables {
+		result.missingVariables[name] = struct{}{}
+	}
+	for name := range right.missingVariables {
+		result.missingVariables[name] = struct{}{}
+	}
+	for name := range left.contentInputs {
+		result.contentInputs[name] = struct{}{}
+	}
+	for name := range right.contentInputs {
+		result.contentInputs[name] = struct{}{}
+	}
+	return result
+}
+
+func branchReach(parent requirementReachability, known, truth, selected bool) requirementReachability {
+	if parent == requirementInactive {
+		return requirementInactive
+	}
+	if !known {
+		return requirementPossible
+	}
+	if truth == selected {
+		if parent == requirementPossible {
+			return requirementPossible
+		}
+		return requirementDefinite
+	}
+	return requirementInactive
+}
+
+type requirementWalker struct {
+	ctx                   context.Context
+	vars                  map[string]string
+	inputs                map[string]*inputEvidence
+	variables             map[string]*variableEvidence
+	issues                map[requirementIssueKey]domain.RequirementIssue
+	complete              bool
+	rootKnown             bool
+	unknownInputEffect    bool
+	unknownVariableEffect bool
+	dependencies          int
+	templateSet           *template.Template
+	visitedTrees          map[*parse.Tree]bool
+}
+
+// AnalyzeRequirements collects the prompt dependencies recognizable from its
+// captured syntax. Branch bodies remain conditional until their conditions are
+// classified; unsupported dependency-bearing syntax makes the result partial.
+func AnalyzeRequirements(
+	ctx context.Context,
+	definition *domain.PromptDefinition,
+	snapshot RequirementSnapshot,
+	vars map[string]string,
+	sessionBypassed bool,
+) (domain.RequirementInspection, error) {
+	if err := ctx.Err(); err != nil {
+		return domain.RequirementInspection{}, err
+	}
+	result := domain.RequirementInspection{Complete: true}
+	if definition != nil {
+		result.PromptID = definition.ID
+		result.PromptVersion = definition.Version
+	}
+	walker := &requirementWalker{
+		ctx:       ctx,
+		vars:      vars,
+		inputs:    make(map[string]*inputEvidence, len(snapshot.Inputs)),
+		variables: make(map[string]*variableEvidence),
+		issues:    make(map[requirementIssueKey]domain.RequirementIssue),
+		complete:  true,
+		rootKnown: true,
+	}
+	for _, input := range snapshot.Inputs {
+		if err := ctx.Err(); err != nil {
+			return domain.RequirementInspection{}, err
+		}
+		kind := domain.RequirementOptional
+		if input.Required {
+			kind = domain.RequirementRequired
+		}
+		walker.inputs[input.Name] = &inputEvidence{
+			name:        input.Name,
+			kind:        kind,
+			declared:    true,
+			contentType: copyString(input.ContentType),
+			description: copyString(input.Description),
+		}
+		if kind == domain.RequirementOptional {
+			walker.inputs[input.Name].explanation = "Declared as an optional input."
+		}
+	}
+	for _, message := range snapshot.Templates.Messages {
+		if err := walker.walkTemplate(message); err != nil {
+			return domain.RequirementInspection{}, err
+		}
+	}
+	if !sessionBypassed && snapshot.Templates.Session != nil {
+		if err := walker.walkTemplate(snapshot.Templates.Session); err != nil {
+			return domain.RequirementInspection{}, err
+		}
+	}
+	if err := ctx.Err(); err != nil {
+		return domain.RequirementInspection{}, err
+	}
+	return walker.result(result), nil
+}
+
+func (walker *requirementWalker) walkTemplate(compiled *template.Template) error {
+	if err := walker.ctx.Err(); err != nil {
+		return err
+	}
+	if compiled == nil || compiled.Tree == nil || compiled.Tree.Root == nil {
+		walker.addIssue("", "", "A captured template has no parsed root.")
+		return nil
+	}
+	previousSet := walker.templateSet
+	previousVisited := walker.visitedTrees
+	walker.templateSet = compiled
+	walker.visitedTrees = map[*parse.Tree]bool{compiled.Tree: true}
+	walker.rootKnown = true
+	err := walker.visit(compiled.Tree.Root, requirementDefinite, dotRoot)
+	walker.templateSet = previousSet
+	walker.visitedTrees = previousVisited
+	return err
+}
+
+func (walker *requirementWalker) visit(node parse.Node, reach requirementReachability, dot dotIdentity) error {
+	if err := walker.ctx.Err(); err != nil {
+		return err
+	}
+	if node == nil {
+		return nil
+	}
+	switch node := node.(type) {
+	case *parse.ListNode:
+		if node == nil {
+			return nil
+		}
+		for _, child := range node.Nodes {
+			if err := walker.visit(child, reach, dot); err != nil {
+				return err
+			}
+		}
+	case *parse.ActionNode:
+		return walker.visit(node.Pipe, reach, dot)
+	case *parse.IfNode:
+		if reach == requirementInactive {
+			if err := walker.visit(node.Pipe, requirementInactive, dot); err != nil {
+				return err
+			}
+			if err := walker.visit(node.List, requirementInactive, dot); err != nil {
+				return err
+			}
+			return walker.visit(node.ElseList, requirementInactive, dot)
+		}
+		condition := walker.evaluateCondition(node.Pipe, reach, dot)
+		before := walker.dependencies
+		thenReach := branchReach(reach, condition.known, condition.truth(), true)
+		elseReach := branchReach(reach, condition.known, condition.truth(), false)
+		if err := walker.visit(node.List, thenReach, dot); err != nil {
+			return err
+		}
+		if err := walker.visit(node.ElseList, elseReach, dot); err != nil {
+			return err
+		}
+		if !condition.known && walker.dependencies != before {
+			walker.recordConditionLimitation(condition)
+		}
+		return nil
+	case *parse.WithNode:
+		if reach == requirementInactive {
+			if err := walker.visit(node.Pipe, requirementInactive, dot); err != nil {
+				return err
+			}
+			bodyDot := walker.withDotIdentity(node.Pipe, dot, conditionEvaluation{})
+			if err := walker.visit(node.List, requirementInactive, bodyDot); err != nil {
+				return err
+			}
+			return walker.visit(node.ElseList, requirementInactive, dot)
+		}
+		condition := walker.evaluateCondition(node.Pipe, reach, dot)
+		before := walker.dependencies
+		thenReach := branchReach(reach, condition.known, condition.truth(), true)
+		elseReach := branchReach(reach, condition.known, condition.truth(), false)
+		bodyDot := walker.withDotIdentity(node.Pipe, dot, condition)
+		if err := walker.visit(node.List, thenReach, bodyDot); err != nil {
+			return err
+		}
+		if err := walker.visit(node.ElseList, elseReach, dot); err != nil {
+			return err
+		}
+		if !condition.known && walker.dependencies != before {
+			walker.recordConditionLimitation(condition)
+		}
+		return nil
+	case *parse.RangeNode:
+		if err := walker.visit(node.Pipe, reach, dot); err != nil {
+			return err
+		}
+		before := walker.dependencies
+		bodyReach := requirementPossible
+		if reach == requirementInactive {
+			bodyReach = requirementInactive
+		}
+		if err := walker.visit(node.List, bodyReach, dotNonRoot); err != nil {
+			return err
+		}
+		if err := walker.visit(node.ElseList, bodyReach, dot); err != nil {
+			return err
+		}
+		if reach != requirementInactive && walker.dependencies != before {
+			walker.addIssue("", "", "Dependencies inside a range are only conservatively enumerated.")
+		}
+	case *parse.TemplateNode:
+		pipeReach := requirementPossible
+		if reach == requirementInactive {
+			pipeReach = requirementInactive
+		}
+		if err := walker.visit(node.Pipe, pipeReach, dot); err != nil {
+			return err
+		}
+		if reach == requirementInactive {
+			return nil
+		}
+		called := walker.templateSet.Lookup(node.Name)
+		if called == nil || called.Tree == nil || called.Tree.Root == nil {
+			walker.addIssue("", "", "An invoked named template is unavailable for syntax inspection.")
+			return nil
+		}
+		if walker.visitedTrees[called.Tree] {
+			walker.addIssue("", "", "An invoked named template is scanned conservatively.")
+			return nil
+		}
+		walker.visitedTrees[called.Tree] = true
+		rootKnown := walker.rootKnown
+		walker.rootKnown = false
+		walker.unknownVariableEffect = true
+		err := walker.visit(called.Tree.Root, requirementPossible, dotNonRoot)
+		walker.rootKnown = rootKnown
+		if err != nil {
+			return err
+		}
+		walker.addIssue("", "", "An invoked named template is scanned conservatively.")
+	case *parse.PipeNode:
+		return walker.visitPipe(node, reach, dot)
+	case *parse.CommandNode:
+		return walker.visitCommand(node, reach, dot)
+	case *parse.FieldNode:
+		if dot == dotRoot && len(node.Ident) > 0 {
+			walker.recordVariable(node.Ident[0], reach)
+			if len(node.Ident) > 1 && reach != requirementInactive {
+				walker.addIssue("", node.Ident[0], "A chained field access is outside the direct-key scope.")
+			}
+		}
+		if dot == dotUnknown {
+			walker.unresolvedVariableScope(reach)
+		}
+	case *parse.DotNode:
+		if dot == dotUnknown {
+			walker.unresolvedVariableScope(reach)
+		}
+	case *parse.VariableNode:
+		walker.visitVariable(node, reach)
+	case *parse.ChainNode:
+		before := walker.dependencies
+		chainReach := requirementPossible
+		if reach == requirementInactive {
+			chainReach = requirementInactive
+		}
+		if err := walker.visit(node.Node, chainReach, dot); err != nil {
+			return err
+		}
+		if reach != requirementInactive && walker.dependencies != before {
+			walker.addIssue("", "", "A chained expression is not interpreted.")
+		}
+	case *parse.BreakNode, *parse.ContinueNode:
+		if reach != requirementInactive {
+			walker.addIssue("", "", "Loop control is outside the supported syntax scope.")
+		}
+	}
+	return nil
+}
+
+func (walker *requirementWalker) visitPipe(pipe *parse.PipeNode, reach requirementReachability, dot dotIdentity) error {
+	if pipe == nil {
+		return nil
+	}
+	if len(pipe.Cmds) == 1 && len(pipe.Decl) == 0 && !pipe.IsAssign {
+		return walker.visitCommand(pipe.Cmds[0], reach, dot)
+	}
+	if name, ok := directInputPipeline(pipe); ok {
+		if reach == requirementInactive {
+			if literal, known := literalStringValue(name); known {
+				walker.recordInput(literal, requirementInactive)
+				return nil
+			}
+			return walker.visit(name, requirementInactive, dot)
+		}
+		walker.evaluateInputName(name, reach, dot)
+		return nil
+	}
+	before := walker.dependencies
+	commandReach := requirementPossible
+	if reach == requirementInactive {
+		commandReach = requirementInactive
+	}
+	for _, command := range pipe.Cmds {
+		if err := walker.visitCommand(command, commandReach, dot); err != nil {
+			return err
+		}
+	}
+	if reach != requirementInactive && walker.dependencies != before {
+		walker.addIssue("", "", "A pipeline or variable assignment is not interpreted.")
+	}
+	if reach != requirementInactive {
+		for _, declaration := range pipe.Decl {
+			if len(declaration.Ident) > 0 && declaration.Ident[0] == "$" {
+				walker.rootKnown = false
+				walker.unknownVariableEffect = true
+				walker.addIssue("", "", "The root template binding is reassigned.")
+			}
+		}
+	}
+	return nil
+}
+
+func (walker *requirementWalker) visitCommand(command *parse.CommandNode, reach requirementReachability, dot dotIdentity) error {
+	if command == nil || len(command.Args) == 0 {
+		return nil
+	}
+	identifier, isIdentifier := command.Args[0].(*parse.IdentifierNode)
+	if isIdentifier && identifier.Ident == "input" {
+		if reach == requirementInactive {
+			if len(command.Args) == 2 {
+				if name, ok := literalStringValue(command.Args[1]); ok {
+					walker.recordInput(name, reach)
+					return nil
+				}
+			}
+			for _, argument := range command.Args[1:] {
+				if err := walker.visit(argument, requirementInactive, dot); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+		if len(command.Args) == 2 {
+			if name, ok := command.Args[1].(*parse.StringNode); ok {
+				walker.recordInput(name.Text, reach)
+				return nil
+			}
+			walker.evaluateInputName(command.Args[1], reach, dot)
+			return nil
+		}
+		for _, argument := range command.Args[1:] {
+			if err := walker.visit(argument, requirementPossible, dot); err != nil {
+				return err
+			}
+		}
+		walker.unresolvedInputName(conditionEvaluation{unsupported: true})
+		return nil
+	}
+	if isIdentifier && identifier.Ident == "index" && len(command.Args) == 3 {
+		if _, ok := command.Args[2].(*parse.StringNode); ok && isRootMap(command.Args[1], dot, walker.rootKnown) {
+			key := command.Args[2].(*parse.StringNode).Text
+			walker.recordOptionalVariable(key, reach)
+			return nil
+		}
+		// A local map may alias the caller root even though its value is not
+		// tracked. A lookup on it must not vanish from complete discovery.
+		if variable, ok := unwrapSingleValue(command.Args[1]).(*parse.VariableNode); ok && len(variable.Ident) == 1 {
+			walker.unresolvedVariableScope(reach)
+		}
+	}
+	if !isIdentifier && len(command.Args) == 1 {
+		return walker.visit(command.Args[0], reach, dot)
+	}
+	before := walker.dependencies
+	for index, argument := range command.Args {
+		if isIdentifier && index == 0 {
+			continue
+		}
+		argumentReach := requirementPossible
+		if reach == requirementInactive {
+			argumentReach = requirementInactive
+		}
+		if err := walker.visit(argument, argumentReach, dot); err != nil {
+			return err
+		}
+	}
+	if reach != requirementInactive && walker.dependencies != before {
+		walker.addIssue("", "", "A function call or computed expression is not interpreted.")
+	}
+	return nil
+}
+
+func (walker *requirementWalker) visitVariable(variable *parse.VariableNode, reach requirementReachability) {
+	if len(variable.Ident) < 2 {
+		return
+	}
+	if variable.Ident[0] != "$" {
+		walker.unresolvedVariableScope(reach)
+		return
+	}
+	if !walker.rootKnown {
+		if reach != requirementInactive {
+			walker.unknownVariableEffect = true
+			walker.addIssue("", "", "The root template binding is not known.")
+		}
+		return
+	}
+	walker.recordVariable(variable.Ident[1], reach)
+	if len(variable.Ident) > 2 && reach != requirementInactive {
+		walker.addIssue("", variable.Ident[1], "A chained field access is outside the direct-key scope.")
+	}
+}
+
+func (walker *requirementWalker) unresolvedVariableScope(reach requirementReachability) {
+	if reach != requirementInactive {
+		walker.unknownVariableEffect = true
+		walker.addIssue("", "", "A caller-variable scope is not statically known.")
+	}
+}
+
+func (walker *requirementWalker) withDotIdentity(pipe *parse.PipeNode, dot dotIdentity, condition conditionEvaluation) dotIdentity {
+	if pipe != nil && len(pipe.Cmds) == 1 && len(pipe.Decl) == 0 && !pipe.IsAssign && len(pipe.Cmds[0].Args) == 1 &&
+		isRootMap(pipe.Cmds[0].Args[0], dot, walker.rootKnown) {
+		return dotRoot
+	}
+	if condition.known {
+		if _, root := condition.value.(map[string]string); root {
+			return dotRoot
+		}
+		return dotNonRoot
+	}
+	if condition.inputNameUnknown ||
+		!condition.unsupported && (len(condition.missingVariables) > 0 || len(condition.contentInputs) > 0) {
+		// Supported caller values and input bodies are strings; supported
+		// comparisons and negation return booleans, never the root map.
+		return dotNonRoot
+	}
+	return dotUnknown
+}
+
+func isRootMap(node parse.Node, dot dotIdentity, rootKnown bool) bool {
+	switch node := unwrapSingleValue(node).(type) {
+	case *parse.DotNode:
+		return dot == dotRoot
+	case *parse.VariableNode:
+		return rootKnown && len(node.Ident) == 1 && node.Ident[0] == "$"
+	default:
+		return false
+	}
+}
+
+func unwrapSingleValue(node parse.Node) parse.Node {
+	for {
+		pipe, ok := node.(*parse.PipeNode)
+		if !ok || len(pipe.Cmds) != 1 || len(pipe.Decl) != 0 || pipe.IsAssign || len(pipe.Cmds[0].Args) != 1 {
+			return node
+		}
+		node = pipe.Cmds[0].Args[0]
+	}
+}
+
+func (walker *requirementWalker) recordInput(name string, reach requirementReachability) {
+	evidence := walker.inputs[name]
+	if evidence == nil {
+		evidence = &inputEvidence{
+			name: name, kind: domain.RequirementOptional,
+			explanation: "Declared as an optional input.",
+		}
+		walker.inputs[name] = evidence
+	}
+	if reach == requirementInactive {
+		if !evidence.applicable && evidence.kind != domain.RequirementRequired {
+			evidence.explanation = "This input is referenced only in a skipped template path."
+		}
+	} else {
+		evidence.applicable = true
+		walker.promoteInput(evidence, kindForReach(reach))
+		if evidence.kind == domain.RequirementRequired {
+			evidence.explanation = ""
+		} else if reach == requirementPossible {
+			evidence.explanation = "This reference is not known to be reached on every execution path."
+		}
+	}
+	if reach != requirementInactive {
+		walker.dependencies++
+	}
+}
+
+func (walker *requirementWalker) recordVariable(name string, reach requirementReachability) {
+	evidence := walker.variables[name]
+	if evidence == nil {
+		evidence = &variableEvidence{name: name, kind: domain.RequirementOptional}
+		walker.variables[name] = evidence
+	}
+	if reach == requirementInactive {
+		if !evidence.applicable {
+			evidence.explanation = "This variable is referenced only in a skipped template path."
+		}
+	} else {
+		evidence.applicable = true
+		walker.promoteVariable(evidence, kindForReach(reach))
+		if evidence.kind == domain.RequirementRequired {
+			evidence.explanation = ""
+		} else if reach == requirementPossible {
+			evidence.explanation = "This reference is not known to be reached on every execution path."
+		}
+	}
+	if reach != requirementInactive {
+		walker.dependencies++
+	}
+}
+
+func (walker *requirementWalker) recordOptionalVariable(name string, reach requirementReachability) {
+	evidence := walker.variables[name]
+	if evidence == nil {
+		evidence = &variableEvidence{name: name, kind: domain.RequirementOptional}
+		walker.variables[name] = evidence
+	}
+	if reach == requirementInactive {
+		if !evidence.applicable {
+			evidence.explanation = "This variable is referenced only in a skipped template path."
+		}
+	} else {
+		evidence.applicable = true
+	}
+	if evidence.kind == domain.RequirementOptional && reach != requirementInactive {
+		evidence.explanation = "This key is read through an optional map lookup."
+	}
+	if reach != requirementInactive {
+		walker.dependencies++
+	}
+}
+
+func (walker *requirementWalker) promoteInput(evidence *inputEvidence, kind domain.RequirementKind) {
+	if requirementRank(kind) > requirementRank(evidence.kind) {
+		evidence.kind = kind
+	}
+	if evidence.kind == domain.RequirementRequired {
+		evidence.explanation = ""
+	}
+}
+
+func (walker *requirementWalker) promoteVariable(evidence *variableEvidence, kind domain.RequirementKind) {
+	if requirementRank(kind) > requirementRank(evidence.kind) {
+		evidence.kind = kind
+	}
+	if evidence.kind == domain.RequirementRequired {
+		evidence.explanation = ""
+	}
+}
+
+func kindForReach(reach requirementReachability) domain.RequirementKind {
+	if reach == requirementPossible {
+		return domain.RequirementConditional
+	}
+	return domain.RequirementRequired
+}
+
+func requirementRank(kind domain.RequirementKind) int {
+	switch kind {
+	case domain.RequirementRequired:
+		return 3
+	case domain.RequirementConditional:
+		return 2
+	default:
+		return 1
+	}
+}
+
+func (walker *requirementWalker) addIssue(inputName, variableName, description string) {
+	walker.addIssueCode(domain.RequirementIssueUnsupportedConstruct, inputName, variableName, description)
+}
+
+func (walker *requirementWalker) addIssueCode(code domain.RequirementIssueCode, inputName, variableName, description string) {
+	walker.complete = false
+	issue := domain.RequirementIssue{
+		Code:         code,
+		InputName:    inputName,
+		VariableName: variableName,
+		Description:  description,
+	}
+	key := requirementIssueKey{code: issue.Code, inputName: inputName, variableName: variableName}
+	walker.issues[key] = issue
+}
+
+func (walker *requirementWalker) recordConditionLimitation(condition conditionEvaluation) {
+	for name := range condition.missingVariables {
+		walker.addIssueCode(domain.RequirementIssueMissingVariable, "", name, "A missing variable prevents selecting a dependency-bearing branch.")
+	}
+	for name := range condition.contentInputs {
+		walker.addIssueCode(domain.RequirementIssueInputContent, name, "", "Captured input content affects branch selection.")
+	}
+	if condition.unsupported && !condition.inputNameUnknown ||
+		(len(condition.missingVariables) == 0 && len(condition.contentInputs) == 0 && !condition.inputNameUnknown) {
+		walker.addIssue("", "", "A dependency-bearing branch condition is not resolved by the supported syntax analysis.")
+	}
+}
+
+func (walker *requirementWalker) result(result domain.RequirementInspection) domain.RequirementInspection {
+	result.Complete = walker.complete
+	result.Inputs = make([]domain.InputRequirement, 0, len(walker.inputs))
+	for _, evidence := range walker.inputs {
+		if walker.unknownInputEffect && evidence.kind != domain.RequirementRequired {
+			evidence.kind = domain.RequirementConditional
+			evidence.explanation = "An unresolved input name could refer to this input."
+		}
+		result.Inputs = append(result.Inputs, domain.InputRequirement{
+			Name: evidence.name, Kind: evidence.kind, Declared: evidence.declared,
+			ContentType: copyString(evidence.contentType), Description: copyString(evidence.description),
+			Explanation: evidence.explanation,
+		})
+	}
+	sort.Slice(result.Inputs, func(i, j int) bool { return result.Inputs[i].Name < result.Inputs[j].Name })
+	result.Variables = make([]domain.VariableRequirement, 0, len(walker.variables))
+	for _, evidence := range walker.variables {
+		if walker.unknownVariableEffect && evidence.kind != domain.RequirementRequired {
+			evidence.kind = domain.RequirementConditional
+			evidence.explanation = "An unresolved caller-variable scope could refer to this variable."
+		}
+		_, supplied := walker.vars[evidence.name]
+		result.Variables = append(result.Variables, domain.VariableRequirement{
+			Name: evidence.name, Kind: evidence.kind, Supplied: supplied, Explanation: evidence.explanation,
+		})
+	}
+	sort.Slice(result.Variables, func(i, j int) bool { return result.Variables[i].Name < result.Variables[j].Name })
+	result.Issues = make([]domain.RequirementIssue, 0, len(walker.issues))
+	for _, issue := range walker.issues {
+		result.Issues = append(result.Issues, issue)
+	}
+	sort.Slice(result.Issues, func(i, j int) bool {
+		left, right := result.Issues[i], result.Issues[j]
+		if left.Code != right.Code {
+			return left.Code < right.Code
+		}
+		if left.InputName != right.InputName {
+			return left.InputName < right.InputName
+		}
+		return left.VariableName < right.VariableName
+	})
+	return result
+}
+
+func copyString(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	copy := *value
+	return &copy
+}

internal/prompt/requirements_test.go

@@ -0,0 +1,671 @@
+package prompt
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+	"text/template"
+
+	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
+)
+
+func TestAnalyzeRequirementsDoesNotHideCallerMapScopes(t *testing.T) {
+	for _, source := range []string{
+		`{{with .}}{{.audience}}{{end}}`,
+		`{{with $}}{{.audience}}{{end}}`,
+		`{{with (.)}}{{.audience}}{{end}}`,
+		`{{$alias := .}}{{with $alias}}{{.audience}}{{end}}`,
+		`{{with .}}{{index . "audience"}}{{end}}`,
+		`{{$alias := .}}{{index $alias "audience"}}`,
+		`{{$alias := .}}{{index ($alias) "audience"}}`,
+		`{{$alias := .}}{{$alias.audience}}`,
+	} {
+		t.Run(source, func(t *testing.T) {
+			compiled := compileRequirementTemplate(t, "scope", source)
+			vars := map[string]string{"audience": "visible"}
+			var rendered strings.Builder
+			if err := compiled.Execute(&rendered, vars); err != nil || rendered.String() != "visible" {
+				t.Fatalf("caller-map reference did not render: %q, %v", rendered.String(), err)
+			}
+			result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+				Templates: CompiledTemplates{Messages: []*template.Template{compiled}},
+			}, vars, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if result.Complete {
+				if len(result.Variables) != 1 || result.Variables[0].Name != "audience" {
+					t.Fatalf("complete discovery lost the caller key: %+v", result)
+				}
+			} else if len(result.Issues) == 0 {
+				t.Fatalf("partial discovery did not explain its limitation: %+v", result)
+			}
+		})
+	}
+}
+
+func TestAnalyzeRequirementsUnknownScopesAffectOptionalEntriesOnlyWhenActive(t *testing.T) {
+	for _, access := range []string{`{{with $alias}}{{.audience}}{{end}}`, `{{index $alias "audience"}}`, `{{index ($alias) "audience"}}`, `{{$alias.audience}}`} {
+		for _, active := range []bool{false, true} {
+			source := `{{if false}}{{.optional}}{{end}}{{$alias := .}}` + access
+			if !active {
+				source = `{{if false}}` + source + `{{end}}`
+			}
+			compiled := compileRequirementTemplate(t, "unknown-scope", source)
+			result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+				Templates: CompiledTemplates{Messages: []*template.Template{compiled}},
+			}, map[string]string{"audience": "visible"}, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantKind := domain.RequirementOptional
+			if active {
+				wantKind = domain.RequirementConditional
+			}
+			if result.Complete == active || len(result.Variables) != 1 || result.Variables[0].Name != "optional" || result.Variables[0].Kind != wantKind {
+				t.Fatalf("active=%v, source=%s, result=%+v", active, source, result)
+			}
+			if active && (len(result.Issues) == 0 || result.Issues[0].Code != domain.RequirementIssueUnsupportedConstruct) {
+				t.Fatalf("active unknown scope lacks a structured issue: %+v", result)
+			}
+			if !active && len(result.Issues) != 0 {
+				t.Fatalf("skipped unknown scope introduced uncertainty: %+v", result)
+			}
+		}
+	}
+}
+
+func TestRequirementWalkerDoesNotRescanNestedUnsupportedNames(t *testing.T) {
+	for _, depth := range []int{6, 12} {
+		expression := ".selector"
+		for level := 0; level < depth; level++ {
+			expression = `input (printf "%s" (` + expression + `))`
+		}
+		source := "{{" + expression + "}}"
+		compiled := compileRequirementTemplate(t, "computed-name", source)
+		walker := &requirementWalker{
+			ctx: context.Background(), vars: map[string]string{"selector": "binding"},
+			inputs: make(map[string]*inputEvidence), variables: make(map[string]*variableEvidence),
+			issues: make(map[requirementIssueKey]domain.RequirementIssue), complete: true, rootKnown: true,
+		}
+		if err := walker.walkTemplate(compiled); err != nil {
+			t.Fatal(err)
+		}
+		// A generous source-relative bound detects exponential rescanning, not
+		// an exact visit count or a production analysis limit.
+		if walker.dependencies > len(source)*8 {
+			t.Fatalf("depth=%d: %d accesses for %d bytes of source", depth, walker.dependencies, len(source))
+		}
+		result := walker.result(domain.RequirementInspection{})
+		if result.Complete || len(result.Variables) != 1 || result.Variables[0].Name != "selector" ||
+			result.Variables[0].Kind != domain.RequirementConditional || len(result.Issues) == 0 {
+			t.Fatalf("nested unsupported names lost discovery metadata: %+v", result)
+		}
+	}
+}
+
+func TestAnalyzeRequirementsCollectsDeclaredAndLiteralInputs(t *testing.T) {
+	description := "retained metadata"
+	definition := &domain.PromptDefinition{ID: "capture", Version: "v1"}
+	snapshot := RequirementSnapshot{
+		Inputs: []InputMetadata{
+			{Name: "optional", ContentType: stringPointerForTest("text/plain"), Description: &description},
+			{Name: "unused", Required: true},
+			{Name: "transcript", Required: true},
+		},
+		Templates: CompiledTemplates{Messages: []*template.Template{
+			compileRequirementTemplate(t, "message", `{{input "transcript"}} {{input "extra"}} {{input "extra"}}`),
+		}},
+	}
+	result, err := AnalyzeRequirements(context.Background(), definition, snapshot, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.PromptID != "capture" || result.PromptVersion != "v1" || !result.Complete || len(result.Issues) != 0 {
+		t.Fatalf("unexpected result identity or completeness: %+v", result)
+	}
+	wantNames := []string{"extra", "optional", "transcript", "unused"}
+	if got := requirementInputNames(result.Inputs); !reflect.DeepEqual(got, wantNames) {
+		t.Fatalf("input names = %v, want %v", got, wantNames)
+	}
+	if got := result.Inputs[0]; got.Kind != domain.RequirementRequired || got.Declared || got.ContentType != nil || got.Description != nil {
+		t.Fatalf("undeclared literal input was not required independently: %+v", got)
+	}
+	if got := result.Inputs[1]; got.Kind != domain.RequirementOptional || !got.Declared || got.ContentType == nil || *got.ContentType != "text/plain" ||
+		got.Description == nil || *got.Description != description || got.Explanation == "" {
+		t.Fatalf("optional declaration metadata was not retained: %+v", got)
+	}
+	if result.Inputs[2].Kind != domain.RequirementRequired || !result.Inputs[2].Declared || result.Inputs[3].Kind != domain.RequirementRequired {
+		t.Fatalf("required declarations or literal use were lost: %+v", result.Inputs)
+	}
+	*result.Inputs[1].Description = "caller mutation"
+	if *snapshot.Inputs[0].Description != description {
+		t.Fatal("result metadata pointer aliases the captured snapshot")
+	}
+}
+
+func TestAnalyzeRequirementsDistinguishesDirectAndOptionalCallerKeys(t *testing.T) {
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{
+			compileRequirementTemplate(t, "message", `{{.missing}} {{$.present}} {{index . "lookup"}}`),
+		}},
+	}, map[string]string{"present": ""}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Complete || len(result.Issues) != 0 {
+		t.Fatalf("plain root and literal lookup syntax should be complete: %+v", result)
+	}
+	wantNames := []string{"lookup", "missing", "present"}
+	if got := requirementVariableNames(result.Variables); !reflect.DeepEqual(got, wantNames) {
+		t.Fatalf("variable names = %v, want %v", got, wantNames)
+	}
+	if result.Variables[0].Kind != domain.RequirementOptional || result.Variables[0].Supplied || result.Variables[0].Explanation == "" {
+		t.Errorf("literal index lookup should be optional and absent: %+v", result.Variables[0])
+	}
+	if result.Variables[1].Kind != domain.RequirementRequired || result.Variables[1].Supplied {
+		t.Errorf("missing direct variable should be required but not supplied: %+v", result.Variables[1])
+	}
+	if result.Variables[2].Kind != domain.RequirementRequired || !result.Variables[2].Supplied {
+		t.Errorf("empty supplied direct variable was not detected by presence: %+v", result.Variables[2])
+	}
+}
+
+func TestAnalyzeRequirementsSeparatesRootAndLocalTemplateValues(t *testing.T) {
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{
+			compileRequirementTemplate(t, "message", `{{$local := "local"}}{{with .context}}{{$local}} {{.child}} {{$.root}}{{end}}`),
+		}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantNames := []string{"context", "root"}
+	if got := requirementVariableNames(result.Variables); !reflect.DeepEqual(got, wantNames) {
+		t.Fatalf("root variable names = %v, want %v", got, wantNames)
+	}
+	if result.Variables[0].Kind != domain.RequirementRequired || result.Variables[1].Kind != domain.RequirementConditional || result.Complete {
+		t.Fatalf("with scope and unresolved branch should be conservative: %+v", result)
+	}
+	if len(result.Issues) != 1 || result.Issues[0].Code != domain.RequirementIssueMissingVariable || result.Issues[0].VariableName != "context" {
+		t.Fatalf("conditional root use should have one associated limitation: %+v", result.Issues)
+	}
+}
+
+func TestAnalyzeRequirementsMarksBranchAndUnsupportedScopeReferences(t *testing.T) {
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{
+			compileRequirementTemplate(t, "message", `{{if .enabled}}{{input "maybe"}}{{end}}{{range .items}}{{input "inside"}} {{.local}} {{$.root}}{{end}}`),
+		}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantInputs := []string{"inside", "maybe"}
+	wantVars := []string{"enabled", "items", "root"}
+	if got := requirementInputNames(result.Inputs); !reflect.DeepEqual(got, wantInputs) {
+		t.Fatalf("input names = %v, want %v", got, wantInputs)
+	}
+	if got := requirementVariableNames(result.Variables); !reflect.DeepEqual(got, wantVars) {
+		t.Fatalf("variable names = %v, want %v", got, wantVars)
+	}
+	if result.Complete || len(result.Issues) < 2 {
+		t.Fatalf("branch/range limitations were not reported: %+v", result)
+	}
+	for _, input := range result.Inputs {
+		if input.Kind != domain.RequirementConditional {
+			t.Errorf("input %q should be conservative conditional: %+v", input.Name, input)
+		}
+	}
+	if result.Variables[0].Kind != domain.RequirementRequired || result.Variables[1].Kind != domain.RequirementRequired ||
+		result.Variables[2].Kind != domain.RequirementConditional {
+		t.Errorf("root and loop-scope variables were misclassified: %+v", result.Variables)
+	}
+}
+
+func TestAnalyzeRequirementsExcludesUnusedDefinitionsAndBypassedSession(t *testing.T) {
+	message := compileRequirementTemplate(t, "message", `{{define "unused"}}{{input "unused"}}{{end}}main`)
+	session := compileRequirementTemplate(t, "session", `{{input "session_only"}}`)
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{message}, Session: session},
+	}, nil, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Complete || len(result.Inputs) != 0 {
+		t.Fatalf("unused definitions or bypassed session were included: %+v", result)
+	}
+	result, err = AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{message}, Session: session},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(result.Inputs) != 1 || result.Inputs[0].Name != "session_only" || result.Inputs[0].Kind != domain.RequirementRequired {
+		t.Fatalf("applicable session template was not visited: %+v", result)
+	}
+}
+
+func TestAnalyzeRequirementsScansInvokedDefinitionsConservatively(t *testing.T) {
+	message := compileRequirementTemplate(t, "message", `{{define "unused"}}{{input "unused"}}{{end}}{{define "called"}}{{input "called"}} {{.local}}{{end}}main {{template "called" .}}`)
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{message}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Complete || len(result.Inputs) != 1 || result.Inputs[0].Name != "called" ||
+		result.Inputs[0].Kind != domain.RequirementConditional || len(result.Variables) != 0 {
+		t.Fatalf("called definition was not scanned conservatively: %+v", result)
+	}
+	if len(result.Issues) < 1 || result.Issues[0].Code != domain.RequirementIssueUnsupportedConstruct {
+		t.Fatalf("named-template limitation was not reported: %+v", result.Issues)
+	}
+}
+
+func TestAnalyzeRequirementsClassifiesKnownConditions(t *testing.T) {
+	tests := []struct {
+		name        string
+		condition   string
+		vars        map[string]string
+		wantActive  string
+		wantSkipped string
+	}{
+		{name: "string false is truthy", condition: `.flag`, vars: map[string]string{"flag": "false"}, wantActive: "active", wantSkipped: "inactive"},
+		{name: "empty direct value is false", condition: `.flag`, vars: map[string]string{"flag": ""}, wantActive: "inactive", wantSkipped: "active"},
+		{name: "simple equality", condition: `eq .mode "active"`, vars: map[string]string{"mode": "active"}, wantActive: "active", wantSkipped: "inactive"},
+		{name: "simple inequality", condition: `ne .mode "active"`, vars: map[string]string{"mode": "other"}, wantActive: "active", wantSkipped: "inactive"},
+		{name: "not direct value", condition: `not .flag`, vars: map[string]string{"flag": ""}, wantActive: "active", wantSkipped: "inactive"},
+		{name: "literal true", condition: `true`, wantActive: "active", wantSkipped: "inactive"},
+		{name: "literal false", condition: `false`, wantActive: "inactive", wantSkipped: "active"},
+		{name: "missing index is empty", condition: `index . "toggle"`, wantActive: "inactive", wantSkipped: "active"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			definition := &domain.PromptDefinition{Templates: []domain.PromptMessageTemplate{{
+				Role: "user", Content: `{{if ` + test.condition + `}}{{input "active"}}{{else}}{{input "inactive"}}{{end}}`,
+			}}}
+			snapshot := RequirementSnapshot{Templates: CompiledTemplates{Messages: []*template.Template{
+				compileRequirementTemplate(t, "message", definition.Templates[0].Content),
+			}}}
+			result, err := AnalyzeRequirements(context.Background(), definition, snapshot, test.vars, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !result.Complete || len(result.Issues) != 0 {
+				t.Fatalf("known condition should produce a complete result: %+v", result)
+			}
+			inputs := make(map[string]domain.InputRequirement, len(result.Inputs))
+			for _, input := range result.Inputs {
+				inputs[input.Name] = input
+			}
+			if inputs[test.wantActive].Kind != domain.RequirementRequired || inputs[test.wantSkipped].Kind != domain.RequirementOptional || inputs[test.wantSkipped].Explanation == "" {
+				t.Fatalf("selected/skipped inputs were misclassified: %+v", result.Inputs)
+			}
+			if test.condition == `index . "toggle"` {
+				if len(result.Variables) != 1 || result.Variables[0].Name != "toggle" || result.Variables[0].Kind != domain.RequirementOptional || result.Variables[0].Supplied {
+					t.Fatalf("missing index key was not retained as optional: %+v", result.Variables)
+				}
+			}
+
+			artifacts := map[string]*domain.Artifact{
+				"active":   {Name: "active", Body: []byte("active")},
+				"inactive": {Name: "inactive", Body: []byte("inactive")},
+			}
+			rendered, err := NewGoRenderer().Render(context.Background(), definition, artifacts, test.vars)
+			if err != nil {
+				t.Fatal(err)
+			}
+			selected := "active"
+			if inputs[selected].Kind != domain.RequirementRequired {
+				selected = "inactive"
+			}
+			if len(rendered.Messages) != 1 || rendered.Messages[0].Content != selected {
+				t.Fatalf("analysis and renderer disagree: result=%+v rendered=%+v", result, rendered)
+			}
+		})
+	}
+}
+
+func TestAnalyzeRequirementsHandlesWithDotAndNestedReachability(t *testing.T) {
+	definition := &domain.PromptDefinition{Templates: []domain.PromptMessageTemplate{{
+		Role: "user", Content: `{{with .context}}{{input "inside"}} {{.child}} {{$.root}}{{else}}{{input "empty"}}{{end}}`,
+	}}}
+	snapshot := RequirementSnapshot{Templates: CompiledTemplates{Messages: []*template.Template{
+		compileRequirementTemplate(t, "message", definition.Templates[0].Content),
+	}}}
+	result, err := AnalyzeRequirements(context.Background(), definition, snapshot, map[string]string{"context": "value", "root": "root"}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Complete || len(result.Inputs) != 2 || len(result.Variables) != 2 {
+		t.Fatalf("known with condition should have a complete inventory: %+v", result)
+	}
+	if result.Inputs[0].Name != "empty" || result.Inputs[0].Kind != domain.RequirementOptional ||
+		result.Inputs[1].Name != "inside" || result.Inputs[1].Kind != domain.RequirementRequired {
+		t.Fatalf("with body and else reachability is incorrect: %+v", result.Inputs)
+	}
+	if result.Variables[0].Name != "context" || result.Variables[0].Kind != domain.RequirementRequired ||
+		result.Variables[1].Name != "root" || result.Variables[1].Kind != domain.RequirementRequired {
+		t.Fatalf("with dot was confused with the root caller map: %+v", result.Variables)
+	}
+
+	nested := compileRequirementTemplate(t, "nested", `{{if .outer}}{{if .inner}}{{input "inner"}}{{else}}{{input "inner_else"}}{{end}}{{else}}{{input "outer_else"}}{{end}}`)
+	nestedResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{nested}},
+	}, map[string]string{"outer": "yes", "inner": "yes"}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !nestedResult.Complete || nestedResult.Inputs[0].Name != "inner" || nestedResult.Inputs[0].Kind != domain.RequirementRequired ||
+		nestedResult.Inputs[1].Name != "inner_else" || nestedResult.Inputs[1].Kind != domain.RequirementOptional ||
+		nestedResult.Inputs[2].Name != "outer_else" || nestedResult.Inputs[2].Kind != domain.RequirementOptional {
+		t.Fatalf("known nested conditions lost selected or inactive reachability: %+v", nestedResult)
+	}
+}
+
+func TestAnalyzeRequirementsReportsUnresolvedDecisionAndContentConditions(t *testing.T) {
+	missing := compileRequirementTemplate(t, "missing", `{{if eq .mode "active"}}{{input "yes"}}{{else}}{{input "no"}}{{end}}`)
+	missingResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{missing}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if missingResult.Complete || len(missingResult.Issues) != 1 || missingResult.Issues[0].Code != domain.RequirementIssueMissingVariable ||
+		missingResult.Issues[0].VariableName != "mode" || missingResult.Inputs[0].Kind != domain.RequirementConditional ||
+		missingResult.Inputs[1].Kind != domain.RequirementConditional {
+		t.Fatalf("missing decision value did not produce conditional dependencies: %+v", missingResult)
+	}
+
+	content := compileRequirementTemplate(t, "content", `{{if input "selector"}}{{input "yes"}}{{else}}{{input "no"}}{{end}}`)
+	contentResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{content}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	contentInputs := make(map[string]domain.InputRequirement, len(contentResult.Inputs))
+	for _, input := range contentResult.Inputs {
+		contentInputs[input.Name] = input
+	}
+	if contentResult.Complete || len(contentResult.Issues) != 1 || contentResult.Issues[0].Code != domain.RequirementIssueInputContent ||
+		contentResult.Issues[0].InputName != "selector" || contentInputs["selector"].Kind != domain.RequirementRequired ||
+		contentInputs["yes"].Kind != domain.RequirementConditional || contentInputs["no"].Kind != domain.RequirementConditional {
+		t.Fatalf("content-dependent condition did not preserve known dependencies: %+v", contentResult)
+	}
+
+	textOnly := compileRequirementTemplate(t, "text-only", `{{if .missing}}plain text{{else}}also plain text{{end}}`)
+	textResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{textOnly}},
+	}, nil, false)
+	if err != nil || !textResult.Complete || len(textResult.Issues) != 0 {
+		t.Fatalf("unresolved text-only branch should not affect completeness: %+v, %v", textResult, err)
+	}
+}
+
+func TestAnalyzeRequirementsRetainsInactiveEntriesAndPromotesActiveUses(t *testing.T) {
+	description := "declared for a reason"
+	definition := &domain.PromptDefinition{Templates: []domain.PromptMessageTemplate{{
+		Role: "user", Content: `{{if false}}{{input "shared"}} {{.shared_var}} {{input "declared"}}{{input .dynamic}}{{and .left .right}}{{end}}{{input "shared"}} {{.shared_var}}`,
+	}}}
+	snapshot := RequirementSnapshot{
+		Inputs: []InputMetadata{{Name: "declared", Required: true, Description: &description}},
+		Templates: CompiledTemplates{Messages: []*template.Template{
+			compileRequirementTemplate(t, "message", definition.Templates[0].Content),
+		}},
+	}
+	result, err := AnalyzeRequirements(context.Background(), definition, snapshot, map[string]string{"shared_var": "present"}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Complete || len(result.Issues) != 0 {
+		t.Fatalf("skipped unsupported expressions introduced uncertainty: %+v", result)
+	}
+	inputs := make(map[string]domain.InputRequirement, len(result.Inputs))
+	for _, input := range result.Inputs {
+		inputs[input.Name] = input
+	}
+	if len(inputs) != 2 || inputs["shared"].Kind != domain.RequirementRequired || inputs["shared"].Explanation != "" ||
+		inputs["declared"].Kind != domain.RequirementRequired || inputs["declared"].Description == nil || *inputs["declared"].Description != description {
+		t.Fatalf("active or declared requirements did not override inactivity: %+v", result.Inputs)
+	}
+	variables := make(map[string]domain.VariableRequirement, len(result.Variables))
+	for _, variable := range result.Variables {
+		variables[variable.Name] = variable
+	}
+	for _, name := range []string{"dynamic", "left", "right", "shared_var"} {
+		if _, ok := variables[name]; !ok {
+			t.Errorf("inactive caller key %q was not inventoried", name)
+		}
+	}
+	if variables["shared_var"].Kind != domain.RequirementRequired || variables["shared_var"].Explanation != "" ||
+		variables["dynamic"].Kind != domain.RequirementOptional || variables["dynamic"].Explanation == "" {
+		t.Fatalf("inactive caller metadata was not promoted or explained: %+v", result.Variables)
+	}
+
+	allOptional := compileRequirementTemplate(t, "optional", `{{index . "lookup"}}`)
+	optionalResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Inputs: []InputMetadata{{Name: "optional"}}, Templates: CompiledTemplates{Messages: []*template.Template{allOptional}},
+	}, nil, false)
+	if err != nil || !optionalResult.Complete || len(optionalResult.Issues) != 0 || optionalResult.Inputs[0].Kind != domain.RequirementOptional ||
+		optionalResult.Variables[0].Kind != domain.RequirementOptional {
+		t.Fatalf("all-optional inventory should be complete without artifacts: %+v, %v", optionalResult, err)
+	}
+}
+
+func TestAnalyzeRequirementsResolvesSimpleInputNames(t *testing.T) {
+	tests := []struct {
+		name       string
+		expression string
+		vars       map[string]string
+		kind       domain.RequirementKind
+		supplied   bool
+	}{
+		{name: "direct dot", expression: `{{input .name}}`, vars: map[string]string{"name": " chosen "}, kind: domain.RequirementRequired, supplied: true},
+		{name: "explicit root", expression: `{{input $.name}}`, vars: map[string]string{"name": "chosen"}, kind: domain.RequirementRequired, supplied: true},
+		{name: "parenthesized direct", expression: `{{input (.name)}}`, vars: map[string]string{"name": "chosen"}, kind: domain.RequirementRequired, supplied: true},
+		{name: "literal lookup", expression: `{{input (index . "name")}}`, vars: map[string]string{"name": "chosen"}, kind: domain.RequirementOptional, supplied: true},
+		{name: "direct pipeline", expression: `{{.name | input}}`, vars: map[string]string{"name": "chosen"}, kind: domain.RequirementRequired, supplied: true},
+		{name: "empty supplied value", expression: `{{input .name}}`, vars: map[string]string{"name": ""}, kind: domain.RequirementRequired, supplied: true},
+		{name: "missing lookup has empty zero value", expression: `{{input (index . "name")}}`, vars: nil, kind: domain.RequirementOptional, supplied: false},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			definition := &domain.PromptDefinition{Templates: []domain.PromptMessageTemplate{{Role: "user", Content: test.expression}}}
+			snapshot := RequirementSnapshot{Templates: CompiledTemplates{Messages: []*template.Template{
+				compileRequirementTemplate(t, "message", test.expression),
+			}}}
+			result, err := AnalyzeRequirements(context.Background(), definition, snapshot, test.vars, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			inputName := "chosen"
+			if test.name == "direct dot" {
+				inputName = " chosen "
+			}
+			if test.name == "empty supplied value" || test.name == "missing lookup has empty zero value" {
+				inputName = ""
+			}
+			if !result.Complete || len(result.Issues) != 0 || len(result.Inputs) != 1 || result.Inputs[0].Name != inputName ||
+				result.Inputs[0].Kind != domain.RequirementRequired {
+				t.Fatalf("simple input name was not resolved exactly: %+v", result)
+			}
+			if len(result.Variables) != 1 || result.Variables[0].Name != "name" || result.Variables[0].Kind != test.kind || result.Variables[0].Supplied != test.supplied {
+				t.Fatalf("name-source caller key classification is incorrect: %+v", result.Variables)
+			}
+			artifacts := map[string]*domain.Artifact{inputName: {Name: inputName, Body: []byte("resolved")}}
+			rendered, err := NewGoRenderer().Render(context.Background(), definition, artifacts, test.vars)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(rendered.Messages) != 1 || rendered.Messages[0].Content != "resolved" {
+				t.Fatalf("analyzed input name differs from renderer: %+v", rendered)
+			}
+		})
+	}
+}
+
+func TestAnalyzeRequirementsReportsUnresolvedInputNamesAndPromotesUnknownEffects(t *testing.T) {
+	definition := &domain.PromptDefinition{Templates: []domain.PromptMessageTemplate{{
+		Role: "user", Content: `{{input .missing}}`,
+	}}}
+	result, err := AnalyzeRequirements(context.Background(), definition, RequirementSnapshot{
+		Inputs: []InputMetadata{{Name: "optional"}, {Name: "required", Required: true}},
+		Templates: CompiledTemplates{Messages: []*template.Template{
+			compileRequirementTemplate(t, "message", definition.Templates[0].Content),
+		}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Complete || len(result.Issues) != 2 || result.Issues[0].Code != domain.RequirementIssueDynamicInputName ||
+		result.Issues[1].Code != domain.RequirementIssueMissingVariable {
+		t.Fatalf("missing dynamic name did not report its limitations: %+v", result)
+	}
+	if result.Inputs[0].Name != "optional" || result.Inputs[0].Kind != domain.RequirementConditional || result.Inputs[0].Explanation == "" ||
+		result.Inputs[1].Name != "required" || result.Inputs[1].Kind != domain.RequirementRequired || len(result.Variables) != 1 ||
+		result.Variables[0].Name != "missing" || result.Variables[0].Kind != domain.RequirementRequired {
+		t.Fatalf("unknown name effects lost known classifications: %+v", result)
+	}
+
+	computed := compileRequirementTemplate(t, "computed", `{{input (printf "%s" .prefix)}}`)
+	computedResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Inputs: []InputMetadata{{Name: "declared"}}, Templates: CompiledTemplates{Messages: []*template.Template{computed}},
+	}, map[string]string{"prefix": "SENSITIVE-VALUE"}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if computedResult.Complete || len(computedResult.Inputs) != 1 || computedResult.Inputs[0].Name != "declared" ||
+		computedResult.Inputs[0].Kind != domain.RequirementConditional || len(computedResult.Variables) != 1 ||
+		computedResult.Variables[0].Name != "prefix" || computedResult.Variables[0].Kind != domain.RequirementConditional {
+		t.Fatalf("computed-name uncertainty did not affect optional entries: %+v", computedResult)
+	}
+	for _, issue := range computedResult.Issues {
+		if strings.Contains(issue.Description, "SENSITIVE-VALUE") || issue.InputName == "SENSITIVE-VALUE" || issue.VariableName == "SENSITIVE-VALUE" {
+			t.Fatalf("input-name source value leaked into diagnostics: %+v", issue)
+		}
+	}
+	for _, input := range computedResult.Inputs {
+		if strings.Contains(input.Explanation, "SENSITIVE-VALUE") {
+			t.Fatalf("input-name source value leaked into an explanation: %+v", input)
+		}
+	}
+	for _, variable := range computedResult.Variables {
+		if strings.Contains(variable.Explanation, "SENSITIVE-VALUE") {
+			t.Fatalf("input-name source value leaked into an explanation: %+v", variable)
+		}
+	}
+
+	for _, expression := range []string{`{{input (input "selector")}}`, `{{input "selector" | input}}`} {
+		t.Run(expression, func(t *testing.T) {
+			contentName := compileRequirementTemplate(t, "content-name", expression)
+			contentResult, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+				Templates: CompiledTemplates{Messages: []*template.Template{contentName}},
+			}, nil, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if contentResult.Complete || len(contentResult.Issues) != 2 ||
+				contentResult.Issues[0].Code != domain.RequirementIssueDynamicInputName ||
+				contentResult.Issues[1].Code != domain.RequirementIssueInputContent || contentResult.Issues[1].InputName != "selector" || len(contentResult.Inputs) != 1 ||
+				contentResult.Inputs[0].Name != "selector" || contentResult.Inputs[0].Kind != domain.RequirementRequired {
+				t.Fatalf("input-body-derived name did not preserve the known source dependency: %+v", contentResult)
+			}
+		})
+	}
+}
+
+func TestAnalyzeRequirementsDoesNotResolveSkippedComputedInputNames(t *testing.T) {
+	compiled := compileRequirementTemplate(t, "inactive-name", `{{if false}}{{input .name}}{{input (printf "%s" .other)}}{{"piped-literal" | input}}{{template "missing" .arg}}{{end}}`)
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{compiled}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !result.Complete || len(result.Issues) != 0 || len(result.Inputs) != 1 || result.Inputs[0].Name != "piped-literal" ||
+		result.Inputs[0].Kind != domain.RequirementOptional || result.Inputs[0].Explanation == "" || len(result.Variables) != 3 {
+		t.Fatalf("skipped computed expressions introduced uncertainty or names: %+v", result)
+	}
+	for _, variable := range result.Variables {
+		if variable.Kind != domain.RequirementOptional || variable.Explanation == "" {
+			t.Errorf("skipped variable %q was not retained as inactive optional: %+v", variable.Name, variable)
+		}
+	}
+}
+
+func TestAnalyzeRequirementsPromotesOptionalVariablesWhenRootScopeIsUnknown(t *testing.T) {
+	compiled := compileRequirementTemplate(t, "scope", `{{index . "optional"}} {{.required}} {{template "called" .}}{{define "called"}}{{$.hidden}}{{end}}`)
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{compiled}},
+	}, map[string]string{"required": "value"}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Complete || len(result.Variables) != 2 || result.Variables[0].Name != "optional" ||
+		result.Variables[0].Kind != domain.RequirementConditional || result.Variables[0].Explanation == "" ||
+		result.Variables[1].Name != "required" || result.Variables[1].Kind != domain.RequirementRequired {
+		t.Fatalf("unknown caller scope did not affect only optional known entries: %+v", result)
+	}
+}
+
+func TestAnalyzeRequirementsLeavesAssignmentDerivedNamesPartial(t *testing.T) {
+	compiled := compileRequirementTemplate(t, "assignment", `{{$alias := .source}}{{input $alias}}`)
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Inputs: []InputMetadata{{Name: "known-optional"}}, Templates: CompiledTemplates{Messages: []*template.Template{compiled}},
+	}, nil, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if result.Complete || len(result.Issues) == 0 || len(result.Inputs) != 1 ||
+		result.Inputs[0].Name != "known-optional" || result.Inputs[0].Kind != domain.RequirementConditional ||
+		len(result.Variables) != 1 || result.Variables[0].Name != "source" || result.Variables[0].Kind != domain.RequirementConditional {
+		t.Fatalf("assignment-derived input name was interpreted or lost: %+v", result)
+	}
+}
+
+func TestAnalyzeRequirementsSupportsEmptyTemplatesAndCancellation(t *testing.T) {
+	result, err := AnalyzeRequirements(context.Background(), &domain.PromptDefinition{}, RequirementSnapshot{
+		Templates: CompiledTemplates{Messages: []*template.Template{compileRequirementTemplate(t, "message", "plain text")}},
+	}, nil, false)
+	if err != nil || !result.Complete || len(result.Inputs) != 0 || len(result.Variables) != 0 {
+		t.Fatalf("input-free template should have a complete empty inventory: %+v, %v", result, err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := AnalyzeRequirements(ctx, &domain.PromptDefinition{}, RequirementSnapshot{}, nil, false); !errors.Is(err, context.Canceled) {
+		t.Fatalf("canceled context returned %v, want context.Canceled", err)
+	}
+}
+
+func compileRequirementTemplate(t *testing.T, name, source string) *template.Template {
+	t.Helper()
+	compiled, err := CompileTemplate(name, source)
+	if err != nil {
+		t.Fatalf("compile template: %v", err)
+	}
+	return compiled
+}
+
+func requirementInputNames(inputs []domain.InputRequirement) []string {
+	names := make([]string, len(inputs))
+	for index, input := range inputs {
+		names[index] = input.Name
+	}
+	return names
+}
+
+func requirementVariableNames(variables []domain.VariableRequirement) []string {
+	names := make([]string, len(variables))
+	for index, variable := range variables {
+		names[index] = variable.Name
+	}
+	return names
+}
+
+func stringPointerForTest(value string) *string {
+	return &value
+}

internal/prompt/template.go

@@ -0,0 +1,43 @@
+package prompt
+
+import "text/template"
+
+// CompiledTemplates is the immutable parsed template set for one captured
+// prompt. Callers must not mutate its templates after handing it to a renderer.
+type CompiledTemplates struct {
+	Session  *template.Template
+	Messages []*template.Template
+}
+
+// InputMetadata is the captured declaration metadata for one prompt input.
+// Nil metadata pointers mean the corresponding field was absent or null.
+type InputMetadata struct {
+	Name        string
+	Required    bool
+	ContentType *string
+	Description *string
+}
+
+// RequirementSnapshot provides the captured syntax and declarations needed
+// for requirement inspection without reopening prompt resources.
+type RequirementSnapshot struct {
+	Templates CompiledTemplates
+	Inputs    []InputMetadata
+}
+
+// TemplateLookup provides parsed templates for a captured prompt identity.
+type TemplateLookup interface {
+	GetCompiledTemplates(id, version string) (CompiledTemplates, bool)
+}
+
+// CompileTemplate checks static syntax with the same grammar and function
+// names as rendering, without evaluating request inputs or variables.
+func CompileTemplate(name, raw string) (*template.Template, error) {
+	return parseTemplate(name, raw, template.FuncMap{
+		"input": func(string) (string, error) { return "", nil },
+	})
+}
+
+func parseTemplate(name, raw string, funcs template.FuncMap) (*template.Template, error) {
+	return template.New(name).Funcs(funcs).Option("missingkey=error").Parse(raw)
+}

internal/promptdef/content_source.go

@@ -1,98 +0,0 @@
-package promptdef
-
-import (
-	"fmt"
-	"io/fs"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/filecatalog"
-)
-
-type contentSourceRoot interface {
-	readContentFile(sourcePath string, contentFile string) (string, string, error)
-}
-
-type osContentSourceRoot struct {
-	root                string
-	sourcePathsRelative bool
-}
-
-func (r osContentSourceRoot) readContentFile(sourcePath string, contentFile string) (string, string, error) {
-	if strings.TrimSpace(contentFile) == "" {
-		return "", "", fmt.Errorf("path is required")
-	}
-	if filepath.IsAbs(contentFile) {
-		return "", "", fmt.Errorf("path %q must be relative", contentFile)
-	}
-
-	root, err := filepath.Abs(r.root)
-	if err != nil {
-		return "", "", fmt.Errorf("resolve source root %q: %w", r.root, err)
-	}
-	canonicalRoot, err := filepath.EvalSymlinks(root)
-	if err != nil {
-		return "", "", fmt.Errorf("resolve source root %q: %w", r.root, err)
-	}
-
-	promptPath := sourcePath
-	if r.sourcePathsRelative && !filepath.IsAbs(promptPath) {
-		promptPath = filepath.Join(root, filepath.FromSlash(promptPath))
-	} else {
-		promptPath, err = filepath.Abs(promptPath)
-		if err != nil {
-			return "", "", fmt.Errorf("resolve prompt source %q: %w", sourcePath, err)
-		}
-	}
-	resolvedPath := filepath.Clean(filepath.Join(filepath.Dir(promptPath), contentFile))
-	if !containsOSPath(root, resolvedPath) {
-		return "", "", fmt.Errorf("path %q escapes source root %q", contentFile, r.root)
-	}
-
-	canonicalPath, err := filepath.EvalSymlinks(resolvedPath)
-	if err != nil {
-		return "", "", err
-	}
-	if !containsOSPath(canonicalRoot, canonicalPath) {
-		return "", "", fmt.Errorf("path %q escapes source root %q", contentFile, r.root)
-	}
-
-	body, err := os.ReadFile(canonicalPath)
-	if err != nil {
-		return "", "", err
-	}
-	return string(body), resolvedPath, nil
-}
-
-type fsContentSourceRoot struct {
-	fsys fs.FS
-	root string
-}
-
-func (r fsContentSourceRoot) readContentFile(sourcePath string, contentFile string) (string, string, error) {
-	root := filecatalog.CleanFSRoot(r.root)
-	cleanSourcePath := path.Clean(sourcePath)
-	if cleanSourcePath == root {
-		root = path.Dir(root)
-	}
-
-	resolvedPath, _, err := filecatalog.ResolveFSPath(root, path.Dir(cleanSourcePath), contentFile)
-	if err != nil {
-		return "", "", err
-	}
-	body, err := fs.ReadFile(r.fsys, resolvedPath)
-	if err != nil {
-		return "", "", err
-	}
-	return string(body), resolvedPath, nil
-}
-
-func containsOSPath(root string, name string) bool {
-	relative, err := filepath.Rel(root, name)
-	if err != nil || filepath.IsAbs(relative) {
-		return false
-	}
-	return relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator))
-}

internal/promptdef/filesystem_repository.go

@@ -1,328 +0,0 @@
-package promptdef
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"strings"
-
-	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
-	"gopkg.in/yaml.v3"
-)
-
-var (
-	ErrPromptDefinitionNotFound = errors.New("prompt definition not found")
-	ErrInvalidYAML              = errors.New("invalid YAML format")
-	ErrInvalidPromptDefinition  = errors.New("invalid prompt definition configuration")
-)
-
-type sourceRepository struct {
-	source promptDefinitionSource
-}
-
-type promptDefinitionFile struct {
-	ID             string                   `yaml:"id"`
-	Version        string                   `yaml:"version"`
-	DefaultProfile *string                  `yaml:"default_profile"`
-	Description    string                   `yaml:"description"`
-	SessionID      string                   `yaml:"session_id"`
-	Inputs         []promptInputFile        `yaml:"inputs"`
-	Messages       []promptMessageFile      `yaml:"messages"`
-	Output         promptOutputContractFile `yaml:"output"`
-}
-
-type promptInputFile struct {
-	Name        string `yaml:"name"`
-	Required    bool   `yaml:"required"`
-	ContentType string `yaml:"content_type"`
-	Description string `yaml:"description"`
-}
-
-type promptMessageFile struct {
-	Role         string            `yaml:"role"`
-	Content      string            `yaml:"content"`
-	ContentFile  string            `yaml:"content_file"`
-	CacheControl *cacheControlFile `yaml:"cache_control"`
-}
-
-type cacheControlFile struct {
-	Type string `yaml:"type"`
-	TTL  string `yaml:"ttl"`
-}
-
-type promptOutputContractFile struct {
-	Format         domain.OutputFormat   `yaml:"format"`
-	ValidationMode domain.ValidationMode `yaml:"validation_mode"`
-	SchemaPath     string                `yaml:"schema_path"`
-	RepairAttempts int                   `yaml:"repair_attempts"`
-}
-
-func NewFilesystemRepository(dir string) Repository {
-	return &sourceRepository{
-		source: osPromptSource{
-			root:        dir,
-			contentRoot: osContentSourceRoot{root: dir},
-		},
-	}
-}
-
-func NewFSRepository(fsys fs.FS, root string) Repository {
-	return &sourceRepository{
-		source: fsPromptSource{
-			fsys:        fsys,
-			root:        root,
-			contentRoot: fsContentSourceRoot{fsys: fsys, root: root},
-		},
-	}
-}
-
-// NewFileRepository constructs a repository for one operating-system prompt file.
-func NewFileRepository(fsys fs.FS, file string, sourceDir string) Repository {
-	return &sourceRepository{
-		source: fsPromptSource{
-			fsys: fsys,
-			root: file,
-			contentRoot: osContentSourceRoot{
-				root:                sourceDir,
-				sourcePathsRelative: true,
-			},
-		},
-	}
-}
-
-func (r *sourceRepository) GetPromptDefinition(ctx context.Context, id string, version string) (*domain.PromptDefinition, error) {
-	if strings.TrimSpace(id) == "" {
-		return nil, fmt.Errorf("%w: prompt id is required", ErrInvalidPromptDefinition)
-	}
-	if r == nil || r.source == nil {
-		return nil, errors.New("failed to read prompt definition directory: source is nil")
-	}
-
-	files, err := r.source.findYAMLFiles(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read prompt definition directory: %w", err)
-	}
-
-	var matches []promptDefinitionMatch
-	for _, fullPath := range files {
-		select {
-		case <-ctx.Done():
-			return nil, ctx.Err()
-		default:
-		}
-
-		relPath := r.source.displayPath(fullPath)
-		data, err := r.source.readDefinition(fullPath)
-		if err != nil {
-			return nil, fmt.Errorf("failed to read prompt definition file %s: %w", relPath, err)
-		}
-		raw, err := decodePromptDefinition(data)
-		if err != nil {
-			if promptDefinitionDataMatches(data, id, version) {
-				return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, relPath, err)
-			}
-			continue
-		}
-		if !promptDefinitionMatches(raw, id, version) {
-			continue
-		}
-		matches = append(matches, promptDefinitionMatch{
-			raw:        raw,
-			sourcePath: fullPath,
-			path:       relPath,
-		})
-	}
-
-	if len(matches) > 1 {
-		paths := make([]string, 0, len(matches))
-		for _, match := range matches {
-			paths = append(paths, match.path)
-		}
-		if version != "" {
-			return nil, fmt.Errorf("%w: duplicate prompt definition id %q version %q found in: %s", ErrInvalidPromptDefinition, id, version, strings.Join(paths, ", "))
-		}
-		return nil, fmt.Errorf("%w: duplicate prompt definition id %q found in: %s", ErrInvalidPromptDefinition, id, strings.Join(paths, ", "))
-	}
-
-	if len(matches) == 1 {
-		match := matches[0]
-		def, err := normalizePromptDefinition(match.raw, r.source, match.sourcePath)
-		if err != nil {
-			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidPromptDefinition, match.path, err)
-		}
-		return def, nil
-	}
-
-	return nil, ErrPromptDefinitionNotFound
-}
-
-type promptDefinitionMatch struct {
-	raw        *promptDefinitionFile
-	sourcePath string
-	path       string
-}
-
-func decodePromptDefinition(data []byte) (*promptDefinitionFile, error) {
-	var raw promptDefinitionFile
-	decoder := yaml.NewDecoder(bytes.NewReader(data))
-	decoder.KnownFields(true)
-	if err := decoder.Decode(&raw); err != nil {
-		return nil, err
-	}
-	var additional yaml.Node
-	if err := decoder.Decode(&additional); err != io.EOF {
-		if err != nil {
-			return nil, err
-		}
-		return nil, errors.New("prompt definition file must contain exactly one YAML document")
-	}
-	return &raw, nil
-}
-
-func promptDefinitionDataMatches(data []byte, id string, version string) bool {
-	var raw struct {
-		ID      string `yaml:"id"`
-		Version string `yaml:"version"`
-	}
-	if err := yaml.NewDecoder(bytes.NewReader(data)).Decode(&raw); err != nil {
-		return false
-	}
-	return promptSelectorMatches(raw.ID, raw.Version, id, version)
-}
-
-func promptDefinitionMatches(raw *promptDefinitionFile, id string, version string) bool {
-	if raw == nil {
-		return false
-	}
-	return promptSelectorMatches(raw.ID, raw.Version, id, version)
-}
-
-func promptSelectorMatches(rawID string, rawVersion string, id string, version string) bool {
-	if strings.TrimSpace(rawID) != id {
-		return false
-	}
-	return version == "" || strings.TrimSpace(rawVersion) == version
-}
-
-func normalizePromptDefinition(raw *promptDefinitionFile, sourceRoot contentSourceRoot, sourcePath string) (*domain.PromptDefinition, error) {
-	return normalizePromptDefinitionWithContent(raw, func(contentFile string) (string, string, error) {
-		return sourceRoot.readContentFile(sourcePath, contentFile)
-	})
-}
-
-func normalizePromptDefinitionWithContent(raw *promptDefinitionFile, readContentFile func(string) (string, string, error)) (*domain.PromptDefinition, error) {
-	if raw == nil {
-		return nil, errors.New("prompt definition is nil")
-	}
-
-	id := strings.TrimSpace(raw.ID)
-	if id == "" {
-		return nil, errors.New("id is required")
-	}
-
-	version := strings.TrimSpace(raw.Version)
-	if version == "" {
-		return nil, errors.New("version is required")
-	}
-
-	if len(raw.Messages) == 0 {
-		return nil, errors.New("at least one message is required")
-	}
-
-	inputs := make([]domain.PromptInput, 0, len(raw.Inputs))
-	seenInputNames := make(map[string]struct{}, len(raw.Inputs))
-	for i, in := range raw.Inputs {
-		name := strings.TrimSpace(in.Name)
-		if name == "" {
-			return nil, fmt.Errorf("input %d has empty name", i)
-		}
-		if _, exists := seenInputNames[name]; exists {
-			return nil, fmt.Errorf("duplicate input name %q", name)
-		}
-		seenInputNames[name] = struct{}{}
-
-		inputs = append(inputs, domain.PromptInput{
-			Name:        name,
-			Required:    in.Required,
-			ContentType: strings.TrimSpace(in.ContentType),
-			Description: strings.TrimSpace(in.Description),
-		})
-	}
-
-	templates := make([]domain.PromptMessageTemplate, 0, len(raw.Messages))
-	for i, msg := range raw.Messages {
-		role, err := domain.NormalizeMessageRole(msg.Role)
-		if err != nil {
-			return nil, fmt.Errorf("message %d role: %w", i, err)
-		}
-
-		hasContent := strings.TrimSpace(msg.Content) != ""
-		hasContentFile := strings.TrimSpace(msg.ContentFile) != ""
-		if hasContent == hasContentFile {
-			return nil, fmt.Errorf("message %d must set exactly one of content or content_file", i)
-		}
-
-		var rawCacheControl *domain.CacheControl
-		if msg.CacheControl != nil {
-			rawCacheControl = &domain.CacheControl{
-				Type: domain.CacheControlType(msg.CacheControl.Type),
-				TTL:  msg.CacheControl.TTL,
-			}
-		}
-		cacheControl, err := domain.NormalizeCacheControl(rawCacheControl)
-		if err != nil {
-			return nil, fmt.Errorf("message %d cache_control: %w", i, err)
-		}
-
-		templateContent := msg.Content
-		resolvedContentFile := ""
-		if hasContentFile {
-			body, resolvedPath, err := readContentFile(msg.ContentFile)
-			if err != nil {
-				return nil, fmt.Errorf("prompt %q message %d: failed to read content_file %q: %w", id, i, msg.ContentFile, err)
-			}
-			templateContent = body
-			resolvedContentFile = resolvedPath
-		}
-
-		templates = append(templates, domain.PromptMessageTemplate{
-			Role:         role,
-			Content:      templateContent,
-			ContentFile:  resolvedContentFile,
-			CacheControl: cacheControl,
-		})
-	}
-
-	outputContract := domain.OutputContract{
-		Format:         raw.Output.Format,
-		ValidationMode: raw.Output.ValidationMode,
-		SchemaPath:     strings.TrimSpace(raw.Output.SchemaPath),
-		RepairAttempts: raw.Output.RepairAttempts,
-	}
-	if err := domain.ValidateOutputContract(outputContract); err != nil {
-		return nil, fmt.Errorf("output: %w", err)
-	}
-
-	defaultProfile := ""
-	if raw.DefaultProfile != nil {
-		defaultProfile = strings.TrimSpace(*raw.DefaultProfile)
-		if defaultProfile == "" {
-			return nil, errors.New("default_profile must be a non-empty string when set")
-		}
-	}
-
-	return &domain.PromptDefinition{
-		ID:             id,
-		Version:        version,
-		DefaultProfile: defaultProfile,
-		Description:    strings.TrimSpace(raw.Description),
-		SessionID:      strings.TrimSpace(raw.SessionID),
-		Inputs:         inputs,
-		Templates:      templates,
-		OutputFormat:   raw.Output.Format,
-		Validation:     outputContract,
-	}, nil
-}