@@ -551,7 +551,7 @@ spec:
           cd ../../..
           . hack/e2e-chainsaw/_lib/remediation-guard.sh
           statuses=$(kubectl -n "$NAMESPACE" get helmrelease opensearch-test \
-            -o jsonpath='{range .status.history[*]}{.status}{"\n"}{end}')
+            -o "jsonpath=${HELMRELEASE_HISTORY_JSONPATH}")
           # Always emit the raw value so a silent future-Flux field rename shows
           # up as "empty history on a Ready HR" in CI logs rather than vanishing.
           # The helper reads empty input as "no cycle observed", so without this
 
@@ -35,13 +35,18 @@ import (
 
 	helmv2 "github.com/fluxcd/helm-controller/api/v2"
 	"k8s.io/client-go/util/jsonpath"
+	"sigs.k8s.io/yaml"
 )
 
 const (
 	// The shell library that owns the expression, and the script that runs it.
 	guardLibrary = "../../hack/e2e-chainsaw/_lib/remediation-guard.sh"
 	guardCaller  = "../../hack/e2e-chainsaw/_lib/run-kubernetes.sh"
 
+	// The Chainsaw suites, one directory each, which may call the guard from a
+	// script step.
+	chainsawSuites = "../../hack/e2e-chainsaw"
+
 	sharedName = "HELMRELEASE_HISTORY_JSONPATH"
 )
 
@@ -73,11 +78,12 @@ var nameFollowedByEquals = regexp.MustCompile(regexp.QuoteMeta(sharedName) + `=`
 // free, because this script mixes forms that behave identically. Each is a
 // case in the accept table below.
 //
-// The reach is one named caller and calls that pass a local. A second script
-// calling the guard, or this one passing a substitution written out in the
-// argument, is outside what this sees. Neither exists today, and the rule for
-// authors is prose rather than a pattern: docs/agents/e2e-testing.md tells them
-// to take the expression from the shared name.
+// The reach is one named caller, the Chainsaw suites, and calls that pass a
+// local. Any other script calling the guard, or a caller passing a substitution
+// written out in the argument, is outside what this sees. Neither exists today,
+// and the rule for authors is prose rather than a pattern:
+// docs/agents/e2e-testing.md tells them to take the expression from the shared
+// name.
 var guardConsumers = regexp.MustCompile(
 	`(?m)^[ \t]*(?:if[ \t]+)?(?:![ \t]*)?helmrelease_has_remediation_cycle[ \t]+"?\$\{?([A-Za-z_][A-Za-z0-9_]*)`)
 
@@ -478,6 +484,11 @@ func TestGuardCallerReferencesTheSharedExpansion(t *testing.T) {
 			"calls it in a shape %s cannot see.", guardCaller, guardConsumers)
 	}
 
+	assertConsumedLocalsTakeTheSharedRead(t, guardCaller, src, consumers)
+}
+
+func assertConsumedLocalsTakeTheSharedRead(t *testing.T, path string, src []byte, consumers [][][]byte) {
+	t.Helper()
 	for _, m := range consumers {
 		local := string(m[1])
 		n := len(localFollowedByEquals(local).FindAll(src, -1))
@@ -486,16 +497,129 @@ func TestGuardCallerReferencesTheSharedExpansion(t *testing.T) {
 				"exactly one. The count is of occurrences, so a comment mentioning one counts too; "+
 				"what it looks for is a second assignment, which the shell would take instead of "+
 				"the one this pin matched, putting an unpinned expression in front of the guard.",
-				guardCaller, local, n)
+				path, local, n)
 			continue
 		}
 		if !sharedReadBy(local).Match(src) {
 			t.Errorf("%s fills %s, the local it hands the guard, in a shape that does not take its "+
 				"expression from %s. The pattern is the exact form accepted: %s. Either the read "+
 				"stopped using the shared assignment, or it uses it in a shape the pattern cannot "+
-				"see.", guardCaller, local, sharedName, sharedReadBy(local))
+				"see.", path, local, sharedName, sharedReadBy(local))
+		}
+	}
+}
+
+// A Chainsaw suite that sources the guard library from a script step is a
+// caller too, and one this file would otherwise never read: the pin above names
+// one script, so a suite writing the jsonpath out as a literal runs an
+// expression nothing here checked.
+//
+// Every suite is read rather than a named one, because the next suite to adopt
+// the guard is the likeliest place for a copied literal and naming suites here
+// would need the same edit that introduces it. A suite cannot assign the shared
+// name either: its script sources the library first, so its own assignment
+// lands afterwards and replaces the value the upstream test resolved.
+//
+// Both sets are asserted non-empty. A glob that stops matching, or suites that
+// all stop calling the guard, leave the loop with nothing to check, and that
+// reads exactly like a pass.
+func TestChainsawSuitesReadHistoryThroughTheSharedName(t *testing.T) {
+	var suites []string
+	for _, pattern := range []string{"chainsaw-test.yaml", "chainsaw-test.yml"} {
+		found, err := filepath.Glob(filepath.Join(chainsawSuites, "*", pattern))
+		if err != nil {
+			t.Fatalf("globbing the Chainsaw suites: %v", err)
+		}
+		suites = append(suites, found...)
+	}
+	if len(suites) == 0 {
+		t.Fatalf("no Chainsaw suites found under %s, so this test asserted nothing", chainsawSuites)
+	}
+
+	// Each script step runs in a shell of its own, so the read the guard sees is
+	// the one in its own step. Checked against the whole file, a read in one
+	// step would satisfy a call in another, and an unrelated assignment of the
+	// same local elsewhere would fail a correct one.
+	t.Run("a read in another step does not count", func(t *testing.T) {
+		steps := scriptSteps(t, "fixture", []byte(`spec:
+  steps:
+  - try:
+    - script:
+        content: |
+          statuses=$(kubectl get hr -o "jsonpath=${HELMRELEASE_HISTORY_JSONPATH}")
+---
+spec:
+  steps:
+  - try:
+    - script:
+        content: |
+          helmrelease_has_remediation_cycle "$statuses"
+`))
+		if len(steps) != 2 {
+			t.Fatalf("split the fixture into %d script steps, want 2", len(steps))
+		}
+		if n := len(localFollowedByEquals("statuses").FindAll([]byte(steps[1]), -1)); n != 0 {
+			t.Errorf("the calling step holds %d assignments of the local, want 0", n)
+		}
+	})
+
+	callers := 0
+	for _, path := range suites {
+		src := readGuardFile(t, path)
+		if n := len(nameFollowedByEquals.FindAll(src, -1)); n != 0 {
+			t.Errorf("%s writes %s followed by = %d times; only %s may assign it. A suite sources "+
+				"the library before its own lines run, so its assignment replaces the value the "+
+				"upstream test checked.", path, sharedName, n, guardLibrary)
+		}
+		for _, step := range scriptSteps(t, path, src) {
+			consumers := guardConsumers.FindAllSubmatch([]byte(step), -1)
+			if len(consumers) == 0 {
+				continue
+			}
+			callers++
+			assertConsumedLocalsTakeTheSharedRead(t, path, []byte(step), consumers)
+		}
+	}
+	if callers == 0 {
+		t.Fatalf("no Chainsaw suite under %s calls helmrelease_has_remediation_cycle with an "+
+			"expanded local, so this test asserted nothing. If no suite runs the guard any more, "+
+			"this test goes with it.", chainsawSuites)
+	}
+}
+
+var yamlDocumentSeparator = regexp.MustCompile(`(?m)^---[ \t]*$`)
+
+// The content of every script step in a Chainsaw file, wherever it sits: try,
+// catch, finally, or a nested operation.
+func scriptSteps(t *testing.T, path string, src []byte) []string {
+	t.Helper()
+	var steps []string
+	var walk func(any)
+	walk = func(node any) {
+		switch v := node.(type) {
+		case map[string]any:
+			if script, ok := v["script"].(map[string]any); ok {
+				if content, ok := script["content"].(string); ok {
+					steps = append(steps, content)
+				}
+			}
+			for _, child := range v {
+				walk(child)
+			}
+		case []any:
+			for _, child := range v {
+				walk(child)
+			}
+		}
+	}
+	for _, doc := range yamlDocumentSeparator.Split(string(src), -1) {
+		var tree any
+		if err := yaml.Unmarshal([]byte(doc), &tree); err != nil {
+			t.Fatalf("parsing %s: %v", path, err)
 		}
+		walk(tree)
 	}
+	return steps
 }
 
 // No shell library but the one that owns the name assigns it. Sourcing the