Protect initial pipeline stage resume semantics

internal/app/semantic_resume_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 	"time"
 
+	"gitea.maximumdirect.net/eric/narratio/internal/config"
 	"gitea.maximumdirect.net/eric/narratio/internal/manifest"
 	"gitea.maximumdirect.net/eric/narratio/internal/stage"
 )
@@ -39,6 +40,21 @@ type semanticResumeCheckingStage struct {
 	validationCalls *int
 }
 
+type semanticContractRunStub struct {
+	name     string
+	provider stage.SemanticConfigFingerprinter
+	runs     *int
+}
+
+func (s semanticContractRunStub) Name() string { return s.name }
+func (s semanticContractRunStub) Run(_ context.Context, _ *stage.Env, _ *manifest.Manifest) (*stage.StageResult, error) {
+	*s.runs++
+	return &stage.StageResult{}, nil
+}
+func (s semanticContractRunStub) SemanticConfigFingerprint(env *stage.Env) (manifest.SemanticConfigFingerprint, error) {
+	return s.provider.SemanticConfigFingerprint(env)
+}
+
 func (s semanticResumeCheckingStage) ValidateResume(_ context.Context, _ *stage.Env, _ *manifest.Manifest) (stage.ResumeValidation, error) {
 	if s.validationCalls != nil {
 		*s.validationCalls++
@@ -295,6 +311,78 @@ func TestSemanticMismatchInvalidatesOnlyFixedDependents(t *testing.T) {
 	}
 }
 
+func TestInitialPipelineSemanticChangesRerunOnlyAffectedLineage(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mutate   func(*config.Config)
+		wantRuns [3]int
+	}{
+		{name: "prepare selection", mutate: func(cfg *config.Config) {
+			cfg.Session.PreviousSessionID = "2026-04-26"
+		}, wantRuns: [3]int{1, 1, 1}},
+		{name: "transcribe language", mutate: func(cfg *config.Config) {
+			cfg.Pipeline.WhisperX.Language = "fr"
+		}, wantRuns: [3]int{0, 1, 1}},
+		{name: "merge transformation", mutate: func(cfg *config.Config) {
+			value := 1.75
+			cfg.Pipeline.Seriatim.CoalesceGap = &value
+		}, wantRuns: [3]int{0, 0, 1}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			cfg := testConfig(t)
+			names := []string{"prepare", "transcribe", "merge"}
+			providers := make([]stage.SemanticConfigFingerprinter, len(names))
+			for index, name := range names {
+				providers[index] = canonicalSemanticProvider(t, name)
+			}
+			seed := manifest.New(cfg.Session.SessionID, time.Now().UTC())
+			for _, candidate := range stage.All() {
+				seed.MarkStageSucceeded(candidate.Name(), time.Now().UTC(), nil)
+			}
+			for index, name := range names {
+				fingerprint, err := providers[index].SemanticConfigFingerprint(&stage.Env{Config: cfg})
+				if err != nil {
+					t.Fatal(err)
+				}
+				seed.Stages[name].SemanticConfig = &fingerprint
+			}
+			store := &manifest.LocalStore{}
+			if err := store.Save(context.Background(), manifestPathFor(cfg), seed); err != nil {
+				t.Fatal(err)
+			}
+			test.mutate(cfg)
+
+			runs := [3]int{}
+			selected := make([]stage.Stage, 0, len(names))
+			for index, name := range names {
+				selected = append(selected, semanticContractRunStub{name: name, provider: providers[index], runs: &runs[index]})
+			}
+			if _, err := executeStages(context.Background(), cfg, selected, RunOptions{}); err != nil {
+				t.Fatal(err)
+			}
+			if runs != test.wantRuns {
+				t.Fatalf("runs = %v, want %v", runs, test.wantRuns)
+			}
+		})
+	}
+}
+
+func canonicalSemanticProvider(t *testing.T, name string) stage.SemanticConfigFingerprinter {
+	t.Helper()
+	for _, candidate := range stage.All() {
+		if candidate.Name() != name {
+			continue
+		}
+		provider, ok := candidate.(stage.SemanticConfigFingerprinter)
+		if !ok {
+			t.Fatalf("canonical stage %q does not implement semantic fingerprinting", name)
+		}
+		return provider
+	}
+	t.Fatalf("canonical stage %q not found", name)
+	return nil
+}
+
 func semanticFingerprint(version int, seed string) manifest.SemanticConfigFingerprint {
 	digest := sha256.Sum256([]byte(seed))
 	return manifest.SemanticConfigFingerprint{Version: version, Digest: hex.EncodeToString(digest[:])}