@@ -54,7 +54,9 @@ The runner performs these stages:
    are relative to this timestamp.
 3. Generate temporary planner and engine configuration.
 4. Start Prometheus and wait for its health check.
-5. Run the planner. Its output is placed in a named shared volume.
+5. Run the planner. Its output is placed in a named shared volume. A suite
+   with `planner_output_dir` skips the planner and mounts that directory
+   instead.
 6. Start the ASAPQuery query engine after the planner completes.
 7. Send the same encoded remote-write batches to Prometheus and ASAPQuery.
 8. Wait for both query APIs to be ready and for the first probe query to return
 
@@ -128,6 +128,25 @@ To change the five-minute cap or one-second ingestion assumption, change the
 runner’s generated-config logic in `runner/run.go`. Do not edit the generated
 configuration: it is temporary and is deleted after the run.
 
+## Use fixed planner output
+
+By default the planner generates the engine's streaming and inference
+configs from the suite. To test configs the planner does not produce, such as
+roll-ups from a finer grouping, check the configs in next to the suite and
+point the suite at their directory:
+
+```yaml
+name: rollup
+planner_output_dir: rollup-planner-output
+```
+
+The path is relative to the suite file. The directory must contain
+`streaming_config.yaml` and `inference_config.yaml` in the planner's output
+format; the runner fails at load time if either is missing. The planner
+service then does not run, and the query engine reads the directory in place
+of the planner's output volume. With already-running targets the field has no
+effect. `suites/rollup.yaml` is an example.
+
 ## Configure tolerance
 
 Set a suite-wide default:
 
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"math"
 	"os"
+	"path/filepath"
 	"time"
 
 	"gopkg.in/yaml.v3"
@@ -15,6 +16,10 @@ const (
 	instantOrderDescending = "descending"
 	orderGroupingBy        = "by"
 	orderGroupingWithout   = "without"
+
+	// File names the planner writes and the query engine reads.
+	plannerStreamingConfigFile = "streaming_config.yaml"
+	plannerInferenceConfigFile = "inference_config.yaml"
 )
 
 // Suite is a data-independent collection of PromQL cases. All timestamps are
@@ -23,6 +28,11 @@ type Suite struct {
 	Name               string           `yaml:"name" json:"name"`
 	ComparisonDefaults ComparisonPolicy `yaml:"comparison_defaults" json:"comparisonDefaults"`
 	Queries            []QueryCase      `yaml:"queries" json:"queries"`
+	// PlannerOutputDir, when set, holds fixed streaming and inference configs
+	// that the query engine uses instead of running the planner. It is
+	// relative to the suite file; LoadSuiteFile resolves it to an absolute
+	// path.
+	PlannerOutputDir string `yaml:"planner_output_dir" json:"plannerOutputDir,omitempty"`
 }
 
 type QueryCase struct {
@@ -123,13 +133,47 @@ func LoadSuite(contents []byte) (Suite, error) {
 	return suite, nil
 }
 
-// LoadSuiteFile reads a query suite from disk.
+// LoadSuiteFile reads a query suite from disk and resolves its
+// planner_output_dir against the suite file's directory.
 func LoadSuiteFile(path string) (Suite, error) {
 	contents, err := os.ReadFile(path)
 	if err != nil {
 		return Suite{}, fmt.Errorf("read query suite %q: %w", path, err)
 	}
-	return LoadSuite(contents)
+	suite, err := LoadSuite(contents)
+	if err != nil {
+		return Suite{}, err
+	}
+	if suite.PlannerOutputDir != "" {
+		resolved, err := resolvePlannerOutputDir(filepath.Dir(path), suite.PlannerOutputDir)
+		if err != nil {
+			return Suite{}, fmt.Errorf("query suite %q: %w", suite.Name, err)
+		}
+		suite.PlannerOutputDir = resolved
+	}
+	return suite, nil
+}
+
+func resolvePlannerOutputDir(suiteDirectory, configured string) (string, error) {
+	directory := configured
+	if !filepath.IsAbs(directory) {
+		directory = filepath.Join(suiteDirectory, directory)
+	}
+	directory, err := filepath.Abs(directory)
+	if err != nil {
+		return "", fmt.Errorf("resolve planner_output_dir %q: %w", configured, err)
+	}
+	for _, name := range []string{plannerStreamingConfigFile, plannerInferenceConfigFile} {
+		file := filepath.Join(directory, name)
+		info, err := os.Stat(file)
+		if err != nil {
+			return "", fmt.Errorf("planner_output_dir %q: %w", configured, err)
+		}
+		if !info.Mode().IsRegular() {
+			return "", fmt.Errorf("planner_output_dir %q: %s is not a regular file", configured, file)
+		}
+	}
+	return directory, nil
 }
 
 func (q QueryCase) InstantTimes(base time.Time) []time.Time {
 
@@ -1,6 +1,10 @@
 package runner
 
 import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 )
@@ -171,3 +175,118 @@ queries:
 		t.Fatal("LoadSuite accepted an invalid instant vector order direction")
 	}
 }
+
+const plannerOutputSuite = `name: fixed-output
+planner_output_dir: %s
+queries:
+  - name: up
+    expr: up
+    instant_offsets_seconds: [60]
+`
+
+// writePlannerOutputSuite writes a suite under root/suites whose
+// planner_output_dir is configured, plus the named files under
+// root/suites/fixed.
+func writePlannerOutputSuite(t *testing.T, configured string, files ...string) (string, string) {
+	t.Helper()
+	root := t.TempDir()
+	suiteDirectory := filepath.Join(root, "suites")
+	outputDirectory := filepath.Join(suiteDirectory, "fixed")
+	if err := os.MkdirAll(outputDirectory, 0o755); err != nil {
+		t.Fatalf("create planner output directory: %v", err)
+	}
+	for _, name := range files {
+		if err := os.WriteFile(filepath.Join(outputDirectory, name), []byte("{}\n"), 0o600); err != nil {
+			t.Fatalf("write %s: %v", name, err)
+		}
+	}
+	suitePath := filepath.Join(suiteDirectory, "suite.yaml")
+	if err := os.WriteFile(suitePath, []byte(fmt.Sprintf(plannerOutputSuite, configured)), 0o600); err != nil {
+		t.Fatalf("write suite: %v", err)
+	}
+	return suitePath, outputDirectory
+}
+
+func TestLoadSuiteFileResolvesPlannerOutputDirAgainstSuiteFile(t *testing.T) {
+	suitePath, outputDirectory := writePlannerOutputSuite(t, "fixed", plannerStreamingConfigFile, plannerInferenceConfigFile)
+
+	// Load through a relative suite path so resolution cannot depend on the
+	// caller's working directory matching the suite's directory.
+	workingDirectory, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Getwd: %v", err)
+	}
+	relativeSuitePath, err := filepath.Rel(workingDirectory, suitePath)
+	if err != nil {
+		t.Fatalf("Rel: %v", err)
+	}
+	suite, err := LoadSuiteFile(relativeSuitePath)
+	if err != nil {
+		t.Fatalf("LoadSuiteFile: %v", err)
+	}
+	if got, want := suite.PlannerOutputDir, outputDirectory; got != want {
+		t.Fatalf("planner output dir = %q, want %q", got, want)
+	}
+}
+
+func TestLoadSuiteFileAcceptsAbsolutePlannerOutputDir(t *testing.T) {
+	outputDirectory := t.TempDir()
+	for _, name := range []string{plannerStreamingConfigFile, plannerInferenceConfigFile} {
+		if err := os.WriteFile(filepath.Join(outputDirectory, name), []byte("{}\n"), 0o600); err != nil {
+			t.Fatalf("write %s: %v", name, err)
+		}
+	}
+	suitePath, _ := writePlannerOutputSuite(t, outputDirectory)
+
+	suite, err := LoadSuiteFile(suitePath)
+	if err != nil {
+		t.Fatalf("LoadSuiteFile: %v", err)
+	}
+	if got, want := suite.PlannerOutputDir, outputDirectory; got != want {
+		t.Fatalf("planner output dir = %q, want %q", got, want)
+	}
+}
+
+func TestLoadSuiteFileLeavesPlannerOutputDirUnsetByDefault(t *testing.T) {
+	suite, err := LoadSuiteFile("../suites/temporal.yaml")
+	if err != nil {
+		t.Fatalf("LoadSuiteFile: %v", err)
+	}
+	if suite.PlannerOutputDir != "" {
+		t.Fatalf("planner output dir = %q, want empty", suite.PlannerOutputDir)
+	}
+}
+
+func TestLoadSuiteFileRejectsIncompletePlannerOutputDir(t *testing.T) {
+	for _, test := range []struct {
+		name       string
+		configured string
+		files      []string
+		missing    string
+	}{
+		{"missing inference config", "fixed", []string{plannerStreamingConfigFile}, plannerInferenceConfigFile},
+		{"missing streaming config", "fixed", []string{plannerInferenceConfigFile}, plannerStreamingConfigFile},
+		{"missing directory", "absent", nil, plannerStreamingConfigFile},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			suitePath, _ := writePlannerOutputSuite(t, test.configured, test.files...)
+			_, err := LoadSuiteFile(suitePath)
+			if err == nil {
+				t.Fatal("LoadSuiteFile accepted a planner_output_dir without both config files")
+			}
+			if !strings.Contains(err.Error(), test.missing) {
+				t.Fatalf("error %q does not name the missing file %q", err, test.missing)
+			}
+		})
+	}
+}
+
+func TestLoadSuiteFileRejectsPlannerOutputDirectoryInPlaceOfFile(t *testing.T) {
+	suitePath, outputDirectory := writePlannerOutputSuite(t, "fixed", plannerStreamingConfigFile)
+	if err := os.Mkdir(filepath.Join(outputDirectory, plannerInferenceConfigFile), 0o755); err != nil {
+		t.Fatalf("create directory: %v", err)
+	}
+	if _, err := LoadSuiteFile(suitePath); err == nil {
+		t.Fatal("LoadSuiteFile accepted a directory as a planner config file")
+	}
+}
@@ -27,8 +27,27 @@ const (
 	dataReadyTimeout               = 3 * time.Minute
 	readinessPollInterval          = time.Second
 	composeShutdownTimeout         = time.Minute
+
+	plannerOutputMountPath        = "/asap-planner-output"
+	fixedPlannerOutputComposeFile = "docker-compose.fixed-planner-output.yml"
+	fixedPlannerOutputDirEnv      = "ASAP_FIXED_PLANNER_OUTPUT_DIR"
 )
 
+// fixedPlannerOutputCompose overrides the base Compose file for suites with a
+// planner_output_dir: the planner sits behind a never-activated profile so it
+// does not run, and the query engine mounts the fixed directory where the
+// planner's output volume would be.
+const fixedPlannerOutputCompose = `services:
+  planner:
+    profiles: ["generated-planner-output"]
+  queryengine:
+    depends_on: !override
+      prometheus:
+        condition: service_healthy
+    volumes:
+      - "${` + fixedPlannerOutputDirEnv + `:?` + fixedPlannerOutputDirEnv + ` is required}:` + plannerOutputMountPath + `:ro"
+`
+
 type RunOptions struct {
 	DatasetPath       string
 	SuitePath         string
@@ -79,6 +98,13 @@ func Run(ctx context.Context, options RunOptions) (Report, error) {
 		project: options.ComposeProject,
 		env:     []string{"ASAP_TEST_CONFIG_DIR=" + runDirectory},
 	}
+	if suite.PlannerOutputDir != "" {
+		lifecycle.files = append(
+			append([]string(nil), options.ComposeFiles...),
+			filepath.Join(runDirectory, fixedPlannerOutputComposeFile),
+		)
+		lifecycle.env = append(lifecycle.env, fixedPlannerOutputDirEnv+"="+suite.PlannerOutputDir)
+	}
 	if len(options.ComposeFiles) > 0 {
 		if err := lifecycle.Start(ctx); err != nil {
 			return Report{}, err
@@ -345,7 +371,24 @@ type plannerCleanup struct {
 	Policy string `yaml:"policy"`
 }
 
+// writeGeneratedConfigs writes the engine config plus either the planner input
+// or, for a suite with fixed planner output, the Compose override that skips
+// the planner. The planner input is not generated in the fixed case, so its
+// timing derivation cannot reject queries the planner never sees.
 func writeGeneratedConfigs(directory string, fixture seeder.Fixture, suite Suite) error {
+	if err := writeEngineConfig(directory); err != nil {
+		return err
+	}
+	if suite.PlannerOutputDir != "" {
+		if err := os.WriteFile(filepath.Join(directory, fixedPlannerOutputComposeFile), []byte(fixedPlannerOutputCompose), 0o600); err != nil {
+			return fmt.Errorf("write fixed planner output compose override: %w", err)
+		}
+		return nil
+	}
+	return writePlannerConfig(directory, fixture, suite)
+}
+
+func writePlannerConfig(directory string, fixture seeder.Fixture, suite Suite) error {
 	metrics := make(map[string]map[string]struct{})
 	for _, series := range fixture.Series {
 		if metrics[series.Metric] == nil {
@@ -399,6 +442,10 @@ func writeGeneratedConfigs(directory string, fixture seeder.Fixture, suite Suite
 	if err := os.WriteFile(filepath.Join(directory, "controller-config.yaml"), contents, 0o600); err != nil {
 		return fmt.Errorf("write generated planner config: %w", err)
 	}
+	return nil
+}
+
+func writeEngineConfig(directory string) error {
 	engineConfig := []byte(`output_dir: "/app/outputs"
 log_level: "INFO"
 data_ingestion_interval_ms: 1000
@@ -414,8 +461,8 @@ store:
 ingest:
   type: "http_remote_write"
   port: 9091
-inference_config: "/asap-planner-output/inference_config.yaml"
-streaming_config: "/asap-planner-output/streaming_config.yaml"
+inference_config: "` + plannerOutputMountPath + `/` + plannerInferenceConfigFile + `"
+streaming_config: "` + plannerOutputMountPath + `/` + plannerStreamingConfigFile + `"
 `)
 	if err := os.WriteFile(filepath.Join(directory, "engine_config.yaml"), engineConfig, 0o600); err != nil {
 		return fmt.Errorf("write generated engine config: %w", err)