gui: a preset screen, and a guard that compares the two surfaces by their bytes

A second screen that starts from a question rather than from numbers. It shows
the question a preset closes and what it typically finds, and its parameters
are drawn by the code that draws a format's settings - because a preset
parameter is a format.Property. Nothing in the screen knows what
size-boundaries takes.

Expanding a preset moved out of internal/cli into internal/preset, so the
window, "generate --preset" and "preset eject" all call one Expand. The
manifest record stays a small literal in each surface on purpose: putting it in
internal/preset would make an input concept import the output contract.

The run half of a screen is now shared. A runner owns preview, generate,
progress, cancel, the manifest save and the close intercept, and a screen
supplies only what to produce. Written when the second screen arrived rather
than after the two had drifted, because the parts that drift here are the ones
nobody compares: whether closing waits, whether a preview writes.

The guard for all this does not compare two lists of fields. It runs one preset
from both surfaces and compares seven files byte for byte, the preset block of
the manifest and the recipe hash - because turning a parsed recipe into engine
targets is written twice and cannot be shared, and that exact conversion
drifted before, when validate lost BoundaryLimit and started refusing recipes
generate accepted.

It found two real differences on its first run.

A field filled in with its declared default makes "I did not state this"
impossible to express, so the window would never have marked a parameter as
defaulted - untouchable rule 5 broken by a form convenience. No field arrives
filled in now, and what a setting falls back to is shown as a hint instead.

And the window had nowhere to put the sentences the command line prints as
"note:", so it stayed silent about building a set around a limit nobody gave
it. A set built around a number we invented carries expectations that read
exactly like a set built around the real one, so saying so is not decoration.

The close intercept moved to Open and asks every screen, because a run keeps
going while somebody moves to another screen and the busy one is not
necessarily the visible one.

D1 parity 36 of 60 to 39 of 60. Seven mutation patterns repointed after the
refactor moved their code, which the staleness check caught rather than a
twelve minute run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: donislawdev

CHANGELOG.md

@@ -16,6 +16,20 @@ because it turns other people's test suites red.
 
 ### Added
 
+- **Presets in the window.** A second screen that starts from a question rather
+  than from numbers: pick what you are testing, and the set is worked out from
+  the answer. It shows the question the preset closes and the mistakes it
+  typically finds, and its settings are drawn from the preset itself, the same
+  way a format's settings are.
+  It produces exactly what `tfg generate --preset` produces - the same files,
+  byte for byte, and the same record of the run. When a number was not given and
+  ours stood in, the window says so out loud, because a set built around a limit
+  we invented carries expectations that read exactly like a set built around
+  yours.
+  No field arrives filled in any more. What a setting falls back to is shown in
+  the box as a hint instead, so leaving a field alone means "I did not state
+  this" and the manifest can say which numbers were ours.
+
 - **The window generates files.** Pick a format, say how big and how many, and
   press Generate. It writes the same bytes the command line writes from the same
   settings, because it is the same engine underneath rather than a second one.

internal/cli/preset.go

@@ -15,70 +15,26 @@ import (
 	"github.com/donislawdev/TestingFilesGenerator/internal/recipe"
 )
 
-// expandedPreset is one preset settled on its parameters and turned into the
-// recipe it stands for.
-//
-// The source is what a run consumes and what eject prints, because it is the
-// same bytes - PR5 in docs/PRESETS.md. Every command here goes through this one
-// function, so none of them can be the one that expands differently.
-type expandedPreset struct {
-	Preset  preset.Preset
-	Settled preset.Args
-	// Defaulted names the parameters nobody gave, whose declared default stood
-	// in. Sorted, so two runs of one preset produce identical records.
-	Defaulted []string
-	Source    []byte
-}
-
-func expandPreset(id string, given preset.Args) (*expandedPreset, error) {
-	p, err := preset.Get(id)
-	if err != nil {
-		return nil, err
-	}
-	settled, err := p.Settle(given)
-	if err != nil {
-		return nil, err
-	}
-
-	var defaulted []string
-	for name := range p.Defaults() {
-		if given[name] == "" {
-			defaulted = append(defaulted, name)
-		}
-	}
-	sort.Strings(defaulted)
-
-	src, err := p.Expand(settled)
-	if err != nil {
-		return nil, err
-	}
-	return &expandedPreset{Preset: p, Settled: settled, Defaulted: defaulted, Source: src}, nil
-}
+// Expanding a preset lives in internal/preset, because the window expands them
+// too and the two surfaces cannot import each other. What stays here is the one
+// thing that is about output rather than about presets: turning an expansion
+// into the manifest record.
 
 // record is what goes into the manifest.
-func (e *expandedPreset) record() *manifest.Preset {
+//
+// A three field literal rather than a shared constructor, and deliberately so:
+// putting it in internal/preset would make that package import the manifest,
+// which is the output contract and no business of an input concept. The drift
+// this invites is watched behaviourally instead - a guard runs the same preset
+// from both surfaces and compares the records they produce.
+func record(e *preset.Expansion) *manifest.Preset {
 	return &manifest.Preset{
 		ID:         e.Preset.ID,
 		Parameters: map[string]string(e.Settled),
 		Defaulted:  e.Defaulted,
 	}
 }
 
-// notes is what to say out loud about a value nobody gave us.
-//
-// Some defaults describe our own file and some describe somebody else's system.
-// A set built around a limit we invented carries expectations that read exactly
-// like a set built around the real one, so the run says which number it made up.
-func (e *expandedPreset) notes() []string {
-	var out []string
-	for _, name := range e.Defaulted {
-		if said := e.Preset.SaidWhenDefaulted[name]; said != "" {
-			out = append(out, said)
-		}
-	}
-	return out
-}
-
 // budget is what a preset would produce, counted by the planner.
 //
 // Not a declared number beside the code. The one that used to sit in
@@ -92,7 +48,7 @@ type budget struct {
 	Formats []string `json:"formats"`
 }
 
-func budgetOf(e *expandedPreset) (budget, error) {
+func budgetOf(e *preset.Expansion) (budget, error) {
 	rec, err := recipe.Parse(e.Source, e.Preset.ID)
 	if err != nil {
 		return budget{}, err
@@ -358,7 +314,7 @@ func targetsFromPreset(fs *flag.FlagSet, g *generateOpts, given map[string]bool,
 		return nil, ExitUsage
 	}
 
-	expanded, err := expandPreset(g.presetID, givenPresetArgs(fs, p))
+	expanded, err := preset.Expand(g.presetID, givenPresetArgs(fs, p))
 	if err != nil {
 		fmt.Fprintf(errOut, "tfg: %s\n", describeError(err))
 		return nil, classify(err)
@@ -374,10 +330,10 @@ func targetsFromPreset(fs *flag.FlagSet, g *generateOpts, given map[string]bool,
 		return nil, classify(err)
 	}
 
-	for _, note := range expanded.notes() {
+	for _, note := range expanded.Notes() {
 		fmt.Fprintf(errOut, "note: %s\n", note)
 	}
-	opt.Preset = expanded.record()
+	opt.Preset = record(expanded)
 	return targetsFromParsedRecipe(rec, hash, g, given, opt), ExitOK
 }
 
@@ -431,7 +387,7 @@ Run "tfg generate --preset <id>" to produce the files.
 // nil for the one that does not - a recipe is already machine readable, and a
 // second encoding of it would be a second thing to keep in step.
 func presetFlagSet(name string, args []string, out, errOut io.Writer, usage func(io.Writer), asJSON *bool) (
-	*expandedPreset, int) {
+	*preset.Expansion, int) {
 
 	fs := flag.NewFlagSet("preset "+name, flag.ContinueOnError)
 	fs.SetOutput(errOut)
@@ -470,7 +426,7 @@ func presetFlagSet(name string, args []string, out, errOut io.Writer, usage func
 		return nil, ExitUsage
 	}
 
-	expanded, err := expandPreset(id, givenPresetArgs(fs, p))
+	expanded, err := preset.Expand(id, givenPresetArgs(fs, p))
 	if err != nil {
 		fmt.Fprintf(errOut, "tfg: %s\n", describeError(err))
 		return nil, classify(err)
@@ -555,14 +511,14 @@ Usage:
 		entry := presetEntryFor(expanded.Preset)
 		entry.Budget = &b
 		entry.Defaulted = expanded.Defaulted
-		entry.Notes = expanded.notes()
+		entry.Notes = expanded.Notes()
 		return renderJSON(entry, out, errOut)
 	}
 	describePreset(expanded, b, out)
 	return ExitOK
 }
 
-func describePreset(e *expandedPreset, b budget, out io.Writer) {
+func describePreset(e *preset.Expansion, b budget, out io.Writer) {
 	p := e.Preset
 	fmt.Fprintf(out, "%s - %s\n%s\n", p.ID, p.Title, p.Question)
 
@@ -581,7 +537,7 @@ func describePreset(e *expandedPreset, b budget, out io.Writer) {
 
 	fmt.Fprintf(out, "\nbudget at these values:\n  %d target(s), %d file(s), %d B total, format %s\n",
 		b.Targets, b.Files, b.Bytes, strings.Join(b.Formats, ", "))
-	for _, note := range e.notes() {
+	for _, note := range e.Notes() {
 		fmt.Fprintf(out, "\nnote: %s\n", note)
 	}
 
@@ -618,7 +574,7 @@ Usage:
 	// The note goes to the error channel. The recipe is the data here, and a
 	// sentence about a number we chose has no business inside a file somebody
 	// is about to commit.
-	for _, note := range expanded.notes() {
+	for _, note := range expanded.Notes() {
 		fmt.Fprintf(errOut, "note: %s\n", note)
 	}
 	if _, err := out.Write(expanded.Source); err != nil {

internal/guard/parity_test.go

@@ -48,6 +48,14 @@ import (
 // the guard was armed on 2026-08-03, which was the point: the distance started
 // as the whole list rather than as whatever was left after nobody was watching.
 var reachableFromTheWindow = []string{
+	// A named question, its parameters drawn by the same code that draws a
+	// format's settings - because a preset parameter IS a format.Property.
+	// TestTheWindowOffersEveryPresetThereIs and the two beside it, one of which
+	// runs the same preset from both surfaces and compares the bytes.
+	"preset:size-boundaries",
+	"preset:size-boundaries.limit",
+	"preset:size-boundaries.spread",
+
 	// Every format the registry holds, taken from the registry itself rather
 	// than listed in the window. TestTheWindowOffersEveryFormatTheRegistryHas.
 	"format:csv",
@@ -111,9 +119,6 @@ var reachableFromTheWindow = []string{
 // key the window cannot produce, and separating the two reasons would be a
 // second list to keep in step for no gain.
 var notYetReachable = []string{
-	"preset:size-boundaries",
-	"preset:size-boundaries.limit",
-	"preset:size-boundaries.spread",
 	"recipe:allow_nondeterministic",
 	"recipe:targets.group",
 	"recipe:defaults",