test(recipes): pin the k8s-aibom stock-adoption contract

Review on #2328 noted that no automated test asserted the new stock
behavior: both parity goldens key on leaf recipes, h100-gke-cos-inference
is not a leaf, and the render-parity tests use a synthetic
single-component fixture. Flipping the target ref to install: false would
have left every existing test green while un-shipping the component.

Adds TestK8sAIBOMStockAdoption over the public builder API, asserting the
target enables it, the Dynamo descendant declares but declines it, the
generation-time opt-out declines it, and a sibling recipe does not declare
it at all. DeploymentOrder is asserted alongside IsEnabled because that is
what bundlers walk, which covers the emission half.

Verified by mutation: setting the target ref to install: false fails both
the IsEnabled and DeploymentOrder assertions.

Also corrects the uninstall instructions. The documented flow regenerated
a bundle without the component and then called helmfile destroy, which
tears down every release in the bundle and, against the regenerated
bundle, could not remove the one release it was meant to. Replaced with a
release-scoped helm uninstall that is correct for both helm and helmfile.

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

Author: mchmarny

docs/user/component-catalog.md

@@ -534,12 +534,25 @@ underneath it, so it reconciles against resources that are disappearing.
 
 1. Remove the component reference from the custom overlay and regenerate the
    recipe and bundle.
-2. Uninstall the release with the deployer-appropriate procedure in
-   [Bundle Uninstall](cli-reference.md#bundle-uninstall) — `helm uninstall
-   k8s-aibom -n k8s-aibom-system` for the `helm` deployer, `helmfile destroy`
-   for Helmfile bundles, deleting the owning `Application` for Argo CD, and the
-   `HelmRelease` for Flux. Confirm the controller Deployment is gone before
-   continuing.
+2. Uninstall the release, scoped to this component only:
+
+   ```bash
+   # helm and helmfile bundles alike: helmfile installs through Helm, so the
+   # release is an ordinary Helm release and this removes exactly one.
+   helm uninstall k8s-aibom -n k8s-aibom-system
+   ```
+
+   For Argo CD, delete the owning `Application`; for Flux, the `HelmRelease`.
+   Confirm the controller Deployment is gone before continuing.
+
+   **Do not use `helmfile destroy` for this.** It tears down *every* release in
+   the bundle in reverse dependency order, not just this component. It is also
+   ineffective here: step 1 regenerated the bundle without `k8s-aibom`, so the
+   release is no longer declared in it and `destroy` would not remove the one
+   release you actually want gone while removing all the ones you do not. If
+   you prefer a Helmfile-native command, run it against a bundle that still
+   declares the component and scope it explicitly with
+   `helmfile destroy --selector name=k8s-aibom`.
 3. Only then delete retained AIBOMs and, last, the CRDs.
 
 Deleting the CRDs cascades to every AIBOM stored cluster-wide, including any

pkg/bundler/k8s_aibom_render_parity_test.go

@@ -41,10 +41,17 @@ import (
 // leaves only, so no golden pins this component's rendered bytes and no KWOK
 // deployer lane exercises it per deployer.
 //
-// These tests remain the substitute — they build the same single-component
-// recipe an adopter would, from the live registry entry rather than from
-// hardcoded coordinates, so a registry edit flows into the assertions instead
-// of silently diverging from them.
+// These tests cover the per-deployer render: they build the same
+// single-component recipe an adopter would, from the live registry entry rather
+// than from hardcoded coordinates, so a registry edit flows into the assertions
+// instead of silently diverging from them.
+//
+// They deliberately do not assert the stock-adoption contract — that the target
+// recipe enables the component, the Dynamo descendant declines it, and the
+// generation-time opt-out works. A synthetic single-component fixture cannot
+// see any of that, so flipping the target ref to `install: false` would leave
+// every assertion here green. That contract is pinned separately by
+// TestK8sAIBOMStockAdoption in pkg/recipe.
 const (
 	k8sAIBOMComponentName = "k8s-aibom"
 	k8sAIBOMValuesFile    = "components/k8s-aibom/values.yaml"

pkg/recipe/k8s_aibom_stock_adoption_test.go

@@ -0,0 +1,138 @@
+// Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES.  All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package recipe_test
+
+import (
+	"context"
+	"slices"
+	"testing"
+
+	"github.com/NVIDIA/aicr/pkg/recipe"
+)
+
+const (
+	stockAdoptionComponent = "k8s-aibom"
+	stockAdoptionVersion   = "k8s-aibom-stock-adoption-test"
+)
+
+// TestK8sAIBOMStockAdoption pins the stock-adoption contract from ADR-019's
+// amendment: exactly one stock recipe installs k8s-aibom, its only descendant
+// declines it, and the generation-time flag declines it too.
+//
+// Why this test rather than the parity goldens: both goldens key on *leaf*
+// recipes, and `h100-gke-cos-inference` is not a leaf — `-dynamo` bases on it.
+// So the target recipe of this whole amendment has no golden coverage, and the
+// only golden that moves is the collateral one on the descendant. Without this
+// test, flipping the target ref to `install: false` would leave every existing
+// test green while silently un-shipping the component.
+//
+// DeploymentOrder is asserted alongside IsEnabled because the order is what
+// bundlers walk. A ref that is declared-but-declined must be absent from it,
+// which is the emission-level half of the claim.
+func TestK8sAIBOMStockAdoption(t *testing.T) {
+	target := func() *recipe.Criteria {
+		return &recipe.Criteria{
+			Service:     recipe.CriteriaServiceGKE,
+			Accelerator: recipe.CriteriaAcceleratorH100,
+			OS:          recipe.CriteriaOSCOS,
+			Intent:      recipe.CriteriaIntentInference,
+		}
+	}
+
+	tests := []struct {
+		name         string
+		criteria     *recipe.Criteria
+		opts         []recipe.BuildOption
+		wantDeclared bool
+		wantEnabled  bool
+	}{
+		{
+			name:         "target stock recipe declares and enables the component",
+			criteria:     target(),
+			wantDeclared: true,
+			wantEnabled:  true,
+		},
+		{
+			name: "dynamo descendant declares but declines it",
+			criteria: func() *recipe.Criteria {
+				c := target()
+				c.Platform = recipe.CriteriaPlatformDynamo
+				return c
+			}(),
+			wantDeclared: true,
+			wantEnabled:  false,
+		},
+		{
+			name:         "generation-time opt-out declines it on the target",
+			criteria:     target(),
+			opts:         []recipe.BuildOption{recipe.WithRuntimeInventoryMode(recipe.RuntimeInventoryDisabled)},
+			wantDeclared: true,
+			wantEnabled:  false,
+		},
+		{
+			name: "a sibling stock recipe does not declare it at all",
+			criteria: func() *recipe.Criteria {
+				c := target()
+				c.Intent = recipe.CriteriaIntentTraining
+				return c
+			}(),
+			wantDeclared: false,
+			wantEnabled:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			builder := recipe.NewBuilder(recipe.WithVersion(stockAdoptionVersion))
+
+			result, err := builder.BuildFromCriteria(context.Background(), tt.criteria, tt.opts...)
+			if err != nil {
+				t.Fatalf("BuildFromCriteria() error = %v", err)
+			}
+
+			var ref *recipe.ComponentRef
+			for i := range result.ComponentRefs {
+				if result.ComponentRefs[i].Name == stockAdoptionComponent {
+					ref = &result.ComponentRefs[i]
+					break
+				}
+			}
+
+			if !tt.wantDeclared {
+				if ref != nil {
+					t.Fatalf("component %q is declared, want absent: adoption leaked beyond the target recipe",
+						stockAdoptionComponent)
+				}
+				if slices.Contains(result.DeploymentOrder, stockAdoptionComponent) {
+					t.Errorf("component %q is in DeploymentOrder despite not being declared",
+						stockAdoptionComponent)
+				}
+				return
+			}
+
+			if ref == nil {
+				t.Fatalf("component %q is absent, want declared: the target recipe no longer ships it",
+					stockAdoptionComponent)
+			}
+			if got := ref.IsEnabled(); got != tt.wantEnabled {
+				t.Errorf("IsEnabled() = %v, want %v", got, tt.wantEnabled)
+			}
+			if got := slices.Contains(result.DeploymentOrder, stockAdoptionComponent); got != tt.wantEnabled {
+				t.Errorf("in DeploymentOrder = %v, want %v: enabled state and emission disagree",
+					got, tt.wantEnabled)
+			}
+		})
+	}
+}