Protect transcript refinement resume semantics

internal/app/semantic_resume_test.go

@@ -367,6 +367,74 @@ func TestInitialPipelineSemanticChangesRerunOnlyAffectedLineage(t *testing.T) {
 	}
 }
 
+func TestRefinementSemanticChangesRespectDependencyBranches(t *testing.T) {
+	names := []string{"prepare", "transcribe", "merge", "polish", "normalize", "trim", "render"}
+	for _, test := range []struct {
+		name              string
+		mutate            func(*config.Config)
+		wantRuns          [7]int
+		wantExtractStatus manifest.StageStatus
+	}{
+		{name: "polish model", mutate: func(cfg *config.Config) {
+			cfg.Pipeline.Audita.Model = "production"
+		}, wantRuns: [7]int{0, 0, 0, 1, 1, 1, 1}, wantExtractStatus: manifest.StatusStale},
+		{name: "normalize schema", mutate: func(cfg *config.Config) {
+			cfg.Pipeline.Normalize = &config.NormalizeConfig{OutputSchema: "seriatim.transcript.v2"}
+		}, wantRuns: [7]int{0, 0, 0, 0, 1, 1, 1}, wantExtractStatus: manifest.StatusStale},
+		{name: "trim prompt", mutate: func(cfg *config.Config) {
+			enabled := true
+			cfg.Pipeline.Trim = &config.TrimConfig{
+				Enabled: &enabled,
+				Bounds:  config.TrimBoundsConfig{PromptID: "session-bounds-v2"},
+			}
+		}, wantRuns: [7]int{0, 0, 0, 0, 0, 1, 1}, wantExtractStatus: manifest.StatusStale},
+		{name: "render format", mutate: func(cfg *config.Config) {
+			cfg.Pipeline.Render = &config.RenderConfig{Format: "html"}
+		}, wantRuns: [7]int{0, 0, 0, 0, 0, 0, 1}, wantExtractStatus: manifest.StatusSucceeded},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			cfg := testConfig(t)
+			providers := make([]stage.SemanticConfigFingerprinter, len(names))
+			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 {
+				providers[index] = canonicalSemanticProvider(t, name)
+				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 := [7]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)
+			}
+			loaded, err := store.Load(context.Background(), manifestPathFor(cfg))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := loaded.Stages["extract"].Status; got != test.wantExtractStatus {
+				t.Fatalf("extract status = %q, want %q", got, test.wantExtractStatus)
+			}
+		})
+	}
+}
+
 func canonicalSemanticProvider(t *testing.T, name string) stage.SemanticConfigFingerprinter {
 	t.Helper()
 	for _, candidate := range stage.All() {