fix(recipe): carry the selection through copy, query, and the API schema

Four more review findings, all reproduced before fixing. Each is the same
defect in a different place: the recipe acts on a selection it no longer
records.

RecipeResult.DeepCopy allocated a fresh RecipeConfiguration and cloned only
Slurm, dropping RuntimeInventory rather than aliasing it. Client.AdoptRecipe
always deep-copies, so an adopted recipe kept the install: false override while
losing the configuration explaining it. Every pointer under
RecipeConfiguration now has a clause, and the test asserts a real copy rather
than a shared pointer.

Query hydration projected only Configuration.Slurm, so
`aicr query --selector configuration.runtimeInventory.mode` returned NOT_FOUND
and hydrated output omitted the decision the recipe records. Verified through
the built CLI: the selector now returns the mode.

The OpenAPI ConfiguredRecipeConfiguration schema declared
`additionalProperties: false` with `required: [slurm]`, so a conforming client
could not submit a generated runtime-inventory recipe to POST /v2/bundle -- and
a recipe carrying only that selection failed the required check as well. Added
the shape to both the strict schema and the permissive base, and replaced
`required: [slurm]` with `minProperties: 1`, since either section may now
appear alone.

The PR body said `Fixes: #2271`, which would have closed the epic on merge.
#2310 and #2311 are open and no stock overlay is added here, so it is now
`Part of #2271` with the remaining work named.

Part of #2271

Signed-off-by: Mark Chmarny <mark@chmarny.com>

Author: mchmarny

api/aicr/v1/server.yaml

@@ -2622,6 +2622,13 @@ components:
                     mode:
                       type: string
                       enum: [disabled, customer-managed, aicr-provided]
+            runtimeInventory:
+              type: object
+              required: [mode]
+              properties:
+                mode:
+                  type: string
+                  enum: [enabled, disabled]
         componentRefs:
           type: array
           items:
@@ -2812,7 +2819,10 @@ components:
       allOf:
         - $ref: "#/components/schemas/RecipeResponseBase/properties/configuration"
         - type: object
-          required: [slurm]
+          # At least one section, but not any particular one: a recipe may
+          # record a runtime-inventory selection without Slurm accounting, or
+          # the reverse. Requiring `slurm` rejected the former outright.
+          minProperties: 1
           additionalProperties: false
           properties:
             slurm:
@@ -2828,6 +2838,14 @@ components:
                     mode:
                       type: string
                       enum: [disabled, customer-managed, aicr-provided]
+            runtimeInventory:
+              type: object
+              required: [mode]
+              additionalProperties: false
+              properties:
+                mode:
+                  type: string
+                  enum: [enabled, disabled]
 
     ProfileRecipeResponse:
       allOf:

pkg/recipe/metadata.go

@@ -1181,6 +1181,14 @@ func (r *RecipeResult) DeepCopy() *RecipeResult {
 				out.Configuration.Slurm.Accounting = &accounting
 			}
 		}
+		// Every pointer under RecipeConfiguration needs a clause here.
+		// Omitting one does not alias it, it drops it: the copy keeps the
+		// component overrides a selection applied while losing the record
+		// explaining them, and Client.AdoptRecipe always deep-copies.
+		if r.Configuration.RuntimeInventory != nil {
+			runtimeInventory := *r.Configuration.RuntimeInventory
+			out.Configuration.RuntimeInventory = &runtimeInventory
+		}
 	}
 
 	if r.Constraints != nil {

pkg/recipe/query.go

@@ -102,6 +102,14 @@ func HydrateResultWithContext(ctx context.Context, result *RecipeResult) (map[st
 			}
 			configuration["slurm"] = slurm
 		}
+		// Every section of RecipeConfiguration must be projected here or the
+		// decision is invisible to `aicr query --selector` and absent from
+		// hydrated output, even though the recipe records it.
+		if result.Configuration.RuntimeInventory != nil {
+			configuration["runtimeInventory"] = map[string]any{
+				"mode": string(result.Configuration.RuntimeInventory.Mode),
+			}
+		}
 		hydrated["configuration"] = configuration
 	}
 

pkg/recipe/runtimeinventory_test.go

@@ -312,3 +312,66 @@ func TestApplyRuntimeInventoryRejectsIncoherentEnable(t *testing.T) {
 		t.Errorf("error = %v, want a coherence rejection", err)
 	}
 }
+
+// TestDeepCopyPreservesRuntimeInventory covers a defect found in review:
+// RecipeResult.DeepCopy allocated a fresh RecipeConfiguration and cloned only
+// Slurm, so the runtime inventory record was dropped rather than aliased.
+//
+// Client.AdoptRecipe always deep-copies, so an adopted recipe kept the
+// component override the selection applied while losing the configuration that
+// explains it — a recipe acting on a decision it no longer records.
+func TestDeepCopyPreservesRuntimeInventory(t *testing.T) {
+	t.Parallel()
+
+	result := runtimeInventoryTestResult()
+	mode := RuntimeInventoryDisabled
+	if err := applyBuildConfig(result, &buildConfig{runtimeInventoryMode: &mode}); err != nil {
+		t.Fatalf("applyBuildConfig() error = %v", err)
+	}
+
+	clone := result.DeepCopy()
+	got, present := clone.RuntimeInventoryMode()
+	if !present {
+		t.Fatal("DeepCopy dropped configuration.runtimeInventory")
+	}
+	if got != RuntimeInventoryDisabled {
+		t.Errorf("cloned mode = %q, want %q", got, RuntimeInventoryDisabled)
+	}
+
+	// A copy, not an alias: mutating the clone must not reach the original.
+	clone.Configuration.RuntimeInventory.Mode = RuntimeInventoryEnabled
+	if orig, _ := result.RuntimeInventoryMode(); orig != RuntimeInventoryDisabled {
+		t.Errorf("original mode = %q after mutating the clone; the pointer is shared", orig)
+	}
+
+	// The sibling section must survive the same copy.
+	if clone.Configuration.Slurm != nil && result.Configuration.Slurm == nil {
+		t.Error("clone invented a Slurm section")
+	}
+}
+
+// TestQueryHydrationExposesRuntimeInventory covers the second half of the same
+// class: the recipe recorded the selection but `aicr query --selector
+// configuration.runtimeInventory.mode` returned NOT_FOUND, because hydration
+// projected only Configuration.Slurm.
+func TestQueryHydrationExposesRuntimeInventory(t *testing.T) {
+	t.Parallel()
+
+	result := runtimeInventoryTestResult()
+	mode := RuntimeInventoryDisabled
+	if err := applyBuildConfig(result, &buildConfig{runtimeInventoryMode: &mode}); err != nil {
+		t.Fatalf("applyBuildConfig() error = %v", err)
+	}
+
+	hydrated, err := HydrateResult(result)
+	if err != nil {
+		t.Fatalf("Hydrate() error = %v", err)
+	}
+	got, err := Select(hydrated, "configuration.runtimeInventory.mode")
+	if err != nil {
+		t.Fatalf("Select(configuration.runtimeInventory.mode) error = %v", err)
+	}
+	if got != string(RuntimeInventoryDisabled) {
+		t.Errorf("selector returned %v, want %q", got, RuntimeInventoryDisabled)
+	}
+}