package app

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	"gitea.maximumdirect.net/eric/narratio/internal/adapters/audita"
	"gitea.maximumdirect.net/eric/narratio/internal/adapters/notify"
	"gitea.maximumdirect.net/eric/narratio/internal/adapters/scriptorium"
	"gitea.maximumdirect.net/eric/narratio/internal/adapters/seriatim"
	"gitea.maximumdirect.net/eric/narratio/internal/adapters/storage"
	"gitea.maximumdirect.net/eric/narratio/internal/adapters/whisperx"
	"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
	"gitea.maximumdirect.net/eric/narratio/internal/config"
	"gitea.maximumdirect.net/eric/narratio/internal/manifest"
	"gitea.maximumdirect.net/eric/narratio/internal/stage"
)

type failingStage struct {
	name string
	err  error
}

func (s failingStage) Name() string           { return s.name }
func (s failingStage) Declares() stage.IODecl { return stage.IODecl{} }
func (s failingStage) Run(_ context.Context, _ *stage.Env, _ *manifest.Manifest) (*stage.StageResult, error) {
	return nil, s.err
}

type countingStage struct {
	name string
	runs *int
}

func (s countingStage) Name() string           { return s.name }
func (s countingStage) Declares() stage.IODecl { return stage.IODecl{} }
func (s countingStage) Run(_ context.Context, _ *stage.Env, _ *manifest.Manifest) (*stage.StageResult, error) {
	*s.runs = *s.runs + 1
	return &stage.StageResult{Metadata: map[string]any{"counting": true}}, nil
}

func TestExecuteStagesPlaceholderSuccessUpdatesManifest(t *testing.T) {
	cfg := testConfig(t)

	summary, err := executeStages(context.Background(), cfg, BuildFullPlan(), RunOptions{})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}
	if len(summary.StageNames) != 9 || len(summary.Executed) != 9 || len(summary.Skipped) != 0 {
		t.Fatalf("summary = %#v, want all 9 executed", summary)
	}

	store := &manifest.LocalStore{}
	m, err := store.Load(context.Background(), summary.ManifestPath)
	if err != nil {
		t.Fatalf("Load manifest error = %v", err)
	}

	for _, name := range []string{"prepare", "transcribe", "merge", "polish", "normalize", "trim", "analyze", "archive", "notify"} {
		sr := m.Stages[name]
		if sr == nil {
			t.Fatalf("missing stage record %q", name)
		}
		if sr.Status != manifest.StatusSucceeded {
			t.Fatalf("stage %q status = %q, want %q", name, sr.Status, manifest.StatusSucceeded)
		}
		if name == "prepare" {
			if sr.Metadata == nil || sr.Metadata["prepared"] != true {
				t.Fatalf("prepare metadata missing prepared=true: %#v", sr.Metadata)
			}
			continue
		}
		if name == "transcribe" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "transcribe" {
				t.Fatalf("transcribe metadata missing stage=transcribe: %#v", sr.Metadata)
			}
			if len(sr.Outputs) == 0 {
				t.Fatalf("transcribe outputs missing")
			}
			continue
		}
		if name == "merge" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "merge" {
				t.Fatalf("merge metadata missing stage=merge: %#v", sr.Metadata)
			}
			if len(sr.Outputs) == 0 {
				t.Fatalf("merge outputs missing")
			}
			if len(sr.Logs) == 0 {
				t.Fatalf("merge logs missing")
			}
			if len(sr.GeneratedConfigs) == 0 {
				t.Fatalf("merge generated configs missing")
			}
			continue
		}
		if name == "polish" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "polish" {
				t.Fatalf("polish metadata missing stage=polish: %#v", sr.Metadata)
			}
			if len(sr.Outputs) == 0 {
				t.Fatalf("polish outputs missing")
			}
			if len(sr.Logs) == 0 {
				t.Fatalf("polish logs missing")
			}
			if len(sr.GeneratedConfigs) == 0 {
				t.Fatalf("polish generated configs missing")
			}
			continue
		}
		if name == "normalize" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "normalize" {
				t.Fatalf("normalize metadata missing stage=normalize: %#v", sr.Metadata)
			}
			if len(sr.Outputs) == 0 {
				t.Fatalf("normalize outputs missing")
			}
			continue
		}
		if name == "analyze" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "analyze" {
				t.Fatalf("analyze metadata missing stage=analyze: %#v", sr.Metadata)
			}
			if sr.Metadata["skipped"] != true {
				t.Fatalf("analyze metadata missing skipped=true when scriptorium is unconfigured: %#v", sr.Metadata)
			}
			continue
		}
		if name == "trim" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "trim" {
				t.Fatalf("trim metadata missing stage=trim: %#v", sr.Metadata)
			}
			if sr.Metadata["trim_action"] != "copy_disabled" {
				t.Fatalf("trim metadata missing trim_action=copy_disabled: %#v", sr.Metadata)
			}
			if len(sr.Outputs) == 0 {
				t.Fatalf("trim outputs missing")
			}
			continue
		}
		if name == "archive" {
			if sr.Metadata == nil || sr.Metadata["stage"] != "archive" {
				t.Fatalf("archive metadata missing stage=archive: %#v", sr.Metadata)
			}
			if sr.Metadata["skipped"] != true {
				t.Fatalf("archive metadata missing skipped=true for test config without archive section: %#v", sr.Metadata)
			}
			continue
		}
		if sr.Metadata == nil || sr.Metadata["placeholder"] != true {
			t.Fatalf("stage %q missing placeholder metadata", name)
		}
	}
	if len(m.Inputs) == 0 {
		t.Fatalf("manifest inputs should be recorded by prepare")
	}

	if _, err := os.Stat(summary.ManifestPath); err != nil {
		t.Fatalf("manifest file missing at %q: %v", summary.ManifestPath, err)
	}
}

func TestExecuteStagesSkipSucceededWhenNotForced(t *testing.T) {
	cfg := testConfig(t)
	manifestPath := manifestPathFor(cfg)
	store := &manifest.LocalStore{}

	existing := manifest.New(cfg.Session.SessionID, time.Date(2026, 5, 3, 1, 0, 0, 0, time.UTC))
	existing.MarkStageSucceeded("transcribe", time.Date(2026, 5, 3, 1, 1, 0, 0, time.UTC), []manifest.ArtifactRecord{{Kind: "transcript_raw", LocalPath: "existing.json"}})
	existing.Stages["transcribe"].Metadata = map[string]any{"kept": true}
	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
		t.Fatalf("MkdirAll() error = %v", err)
	}
	if err := store.Save(context.Background(), manifestPath, existing); err != nil {
		t.Fatalf("Save manifest error = %v", err)
	}

	runs := 0
	stageToRun := countingStage{name: "transcribe", runs: &runs}
	summary, err := executeStages(context.Background(), cfg, []stage.Stage{stageToRun}, RunOptions{})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}
	if runs != 0 {
		t.Fatalf("runs = %d, want 0 due to skip", runs)
	}
	if len(summary.Executed) != 0 || len(summary.Skipped) != 1 || summary.Skipped[0] != "transcribe" {
		t.Fatalf("summary = %#v, want skipped transcribe", summary)
	}

	loaded, err := store.Load(context.Background(), manifestPath)
	if err != nil {
		t.Fatalf("Load manifest error = %v", err)
	}
	sr := loaded.Stages["transcribe"]
	if sr == nil || sr.Status != manifest.StatusSucceeded {
		t.Fatalf("transcribe status = %#v, want succeeded", sr)
	}
	if sr.Metadata == nil || sr.Metadata["kept"] != true {
		t.Fatalf("transcribe metadata = %#v, want preserved", sr.Metadata)
	}
}

func TestExecuteStagesForceRerunsSucceeded(t *testing.T) {
	cfg := testConfig(t)
	manifestPath := manifestPathFor(cfg)
	store := &manifest.LocalStore{}

	existing := manifest.New(cfg.Session.SessionID, time.Date(2026, 5, 3, 1, 0, 0, 0, time.UTC))
	existing.MarkStageSucceeded("transcribe", time.Date(2026, 5, 3, 1, 1, 0, 0, time.UTC), nil)
	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
		t.Fatalf("MkdirAll() error = %v", err)
	}
	if err := store.Save(context.Background(), manifestPath, existing); err != nil {
		t.Fatalf("Save manifest error = %v", err)
	}

	runs := 0
	stageToRun := countingStage{name: "transcribe", runs: &runs}
	summary, err := executeStages(context.Background(), cfg, []stage.Stage{stageToRun}, RunOptions{Force: true})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}
	if runs != 1 {
		t.Fatalf("runs = %d, want 1 with force", runs)
	}
	if len(summary.Executed) != 1 || summary.Executed[0] != "transcribe" || len(summary.Skipped) != 0 {
		t.Fatalf("summary = %#v, want executed transcribe", summary)
	}
}

func TestExecuteStagesFailureUpdatesManifest(t *testing.T) {
	cfg := testConfig(t)

	stages := []stage.Stage{
		BuildFullPlan()[0],
		failingStage{name: "transcribe", err: errors.New("boom")},
		BuildFullPlan()[2],
	}

	summary, err := executeStages(context.Background(), cfg, stages, RunOptions{})
	if err == nil {
		t.Fatal("expected error, got nil")
	}
	if summary != nil {
		t.Fatalf("summary = %#v, want nil on failure", summary)
	}
	if !strings.Contains(err.Error(), "stage \"transcribe\" failed") {
		t.Fatalf("error = %q, want stage failure", err.Error())
	}

	manifestPath := manifestPathFor(cfg)
	store := &manifest.LocalStore{}
	m, loadErr := store.Load(context.Background(), manifestPath)
	if loadErr != nil {
		t.Fatalf("Load manifest error = %v", loadErr)
	}

	if got := m.Stages["prepare"]; got == nil || got.Status != manifest.StatusSucceeded {
		t.Fatalf("prepare status = %#v, want succeeded", got)
	}
	if got := m.Stages["transcribe"]; got == nil || got.Status != manifest.StatusFailed {
		t.Fatalf("transcribe status = %#v, want failed", got)
	}
	if got := m.Stages["merge"]; got != nil {
		t.Fatalf("merge should not run, got %#v", got)
	}
}

func TestExecuteStagesLoadsExistingManifest(t *testing.T) {
	cfg := testConfig(t)
	manifestPath := manifestPathFor(cfg)
	store := &manifest.LocalStore{}

	existing := manifest.New(cfg.Session.SessionID, time.Date(2026, 5, 3, 1, 0, 0, 0, time.UTC))
	existing.MarkStageSucceeded("prepare", time.Date(2026, 5, 3, 1, 1, 0, 0, time.UTC), nil)
	audioPath := filepath.Join(
		cfg.Pipeline.Workspace.Root,
		"work",
		cfg.Session.Campaign,
		cfg.Session.SessionID,
		"audio",
		"alice.flac",
	)
	if err := os.MkdirAll(filepath.Dir(audioPath), 0o755); err != nil {
		t.Fatalf("MkdirAll() error = %v", err)
	}
	if err := os.WriteFile(audioPath, []byte("audio"), 0o644); err != nil {
		t.Fatalf("WriteFile() error = %v", err)
	}
	existing.Inputs = append(existing.Inputs, manifest.InputRecord{
		Kind: "audio",
		Path: audioPath,
	})
	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
		t.Fatalf("MkdirAll() error = %v", err)
	}
	if err := store.Save(context.Background(), manifestPath, existing); err != nil {
		t.Fatalf("Save manifest error = %v", err)
	}

	_, err := executeStages(context.Background(), cfg, []stage.Stage{BuildFullPlan()[1]}, RunOptions{})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}

	loaded, err := store.Load(context.Background(), manifestPath)
	if err != nil {
		t.Fatalf("Load manifest error = %v", err)
	}
	if loaded.Stages["prepare"] == nil || loaded.Stages["prepare"].Status != manifest.StatusSucceeded {
		t.Fatalf("existing stage prepare should remain succeeded")
	}
	if loaded.Stages["transcribe"] == nil || loaded.Stages["transcribe"].Status != manifest.StatusSucceeded {
		t.Fatalf("transcribe should be succeeded after run")
	}
}

func TestExecuteStagesCreatesRunManifestPerInvocation(t *testing.T) {
	cfg := testConfig(t)
	run1, err := executeStages(context.Background(), cfg, []stage.Stage{BuildFullPlan()[0]}, RunOptions{})
	if err != nil {
		t.Fatalf("first executeStages() error = %v", err)
	}
	run2, err := executeStages(context.Background(), cfg, []stage.Stage{BuildFullPlan()[0]}, RunOptions{Force: true})
	if err != nil {
		t.Fatalf("second executeStages() error = %v", err)
	}

	if run1.RunID == "" || run2.RunID == "" {
		t.Fatalf("run ids must be set, got %q and %q", run1.RunID, run2.RunID)
	}
	if run1.RunID == run2.RunID {
		t.Fatalf("expected distinct run ids, got %q", run1.RunID)
	}
	if run1.RunManifestPath == "" || run2.RunManifestPath == "" {
		t.Fatalf("run manifest paths must be set, got %q and %q", run1.RunManifestPath, run2.RunManifestPath)
	}
	if run1.RunManifestPath == run2.RunManifestPath {
		t.Fatalf("expected distinct run manifest paths, got %q", run1.RunManifestPath)
	}
	for _, path := range []string{run1.RunManifestPath, run2.RunManifestPath} {
		if _, statErr := os.Stat(path); statErr != nil {
			t.Fatalf("run manifest missing at %q: %v", path, statErr)
		}
	}

	store := &manifest.LocalStore{}
	sessionManifest, err := store.Load(context.Background(), run2.ManifestPath)
	if err != nil {
		t.Fatalf("Load session manifest error = %v", err)
	}
	if sessionManifest.RunID != run2.RunID {
		t.Fatalf("session manifest run_id = %q, want latest run id %q", sessionManifest.RunID, run2.RunID)
	}
}

func TestExecuteStagesRunManifestRecordsSkippedStage(t *testing.T) {
	cfg := testConfig(t)
	store := &manifest.LocalStore{}
	manifestPath := manifestPathFor(cfg)
	existing := manifest.New(cfg.Session.SessionID, time.Date(2026, 5, 3, 1, 0, 0, 0, time.UTC))
	existing.MarkStageSucceeded("transcribe", time.Date(2026, 5, 3, 1, 1, 0, 0, time.UTC), nil)
	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
		t.Fatalf("MkdirAll() error = %v", err)
	}
	if err := store.Save(context.Background(), manifestPath, existing); err != nil {
		t.Fatalf("Save manifest error = %v", err)
	}

	summary, err := executeStages(context.Background(), cfg, []stage.Stage{BuildFullPlan()[1]}, RunOptions{})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}
	if len(summary.Skipped) != 1 || summary.Skipped[0] != "transcribe" {
		t.Fatalf("summary = %#v, want skipped transcribe", summary)
	}

	runManifest, err := store.LoadRun(context.Background(), summary.RunManifestPath)
	if err != nil {
		t.Fatalf("LoadRun() error = %v", err)
	}
	sr := runManifest.Stages["transcribe"]
	if sr == nil {
		t.Fatal("run manifest transcribe stage missing")
	}
	if sr.Action != manifest.RunStageActionSkip {
		t.Fatalf("action = %q, want %q", sr.Action, manifest.RunStageActionSkip)
	}
	if sr.Status != manifest.StatusSkipped {
		t.Fatalf("status = %q, want %q", sr.Status, manifest.StatusSkipped)
	}
}

func TestExecuteStagesRunLocalArtifactsAndCanonicalPromotion(t *testing.T) {
	cfg := testConfig(t)
	stages := []stage.Stage{
		BuildFullPlan()[0], // prepare
		BuildFullPlan()[1], // transcribe
		BuildFullPlan()[2], // merge
		BuildFullPlan()[3], // polish
		BuildFullPlan()[4], // normalize
		BuildFullPlan()[5], // trim
	}

	summary, err := executeStages(context.Background(), cfg, stages, RunOptions{})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}
	if summary.RunID == "" {
		t.Fatal("run id must be set")
	}

	runRoot := artifacts.SessionRunRootForCampaign(
		cfg.Pipeline.Workspace.Root,
		cfg.Session.Campaign,
		cfg.Session.SessionID,
		summary.RunID,
	)
	paths := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root).SessionPathsFor(cfg.Session.Campaign, cfg.Session.SessionID)

	runLocalChecks := []string{
		filepath.Join(runRoot, "transcribe", "outputs", "transcripts", "raw", "alice.json"),
		filepath.Join(runRoot, "merge", "logs", "seriatim.stdout.log"),
		filepath.Join(runRoot, "polish", "config", "audita.generated.yml"),
		filepath.Join(runRoot, "normalize", "logs", "seriatim.normalize.stdout.log"),
		filepath.Join(runRoot, "trim", "outputs", "transcripts", "trimmed.json"),
	}
	for _, p := range runLocalChecks {
		if _, statErr := os.Stat(p); statErr != nil {
			t.Fatalf("run-local artifact missing at %q: %v", p, statErr)
		}
	}

	canonicalChecks := []string{
		filepath.Join(paths.TranscriptsRawDir, "alice.json"),
		filepath.Join(paths.TranscriptsDir, "merged.json"),
		filepath.Join(paths.TranscriptsDir, "processed.json"),
		filepath.Join(paths.TranscriptsDir, "normalized.json"),
		filepath.Join(paths.TranscriptsDir, "trimmed.json"),
	}
	for _, p := range canonicalChecks {
		if _, statErr := os.Stat(p); statErr != nil {
			t.Fatalf("canonical promoted artifact missing at %q: %v", p, statErr)
		}
	}

	store := &manifest.LocalStore{}
	sessionManifest, err := store.Load(context.Background(), summary.ManifestPath)
	if err != nil {
		t.Fatalf("Load manifest error = %v", err)
	}
	if got := sessionManifest.Stages["trim"]; got == nil || len(got.Outputs) == 0 {
		t.Fatalf("trim stage outputs missing in session manifest: %#v", got)
	}
	for _, out := range sessionManifest.Stages["trim"].Outputs {
		if strings.Contains(out.LocalPath, string(filepath.Separator)+"runs"+string(filepath.Separator)) {
			t.Fatalf("session manifest output should be canonical, got run-local path %q", out.LocalPath)
		}
		if out.ProducerRunID != summary.RunID {
			t.Fatalf("producer_run_id = %q, want %q", out.ProducerRunID, summary.RunID)
		}
	}

	runManifest, err := store.LoadRun(context.Background(), summary.RunManifestPath)
	if err != nil {
		t.Fatalf("LoadRun() error = %v", err)
	}
	mergeStage := runManifest.Stages["merge"]
	if mergeStage == nil || len(mergeStage.Logs) == 0 {
		t.Fatalf("merge logs missing in run manifest: %#v", mergeStage)
	}
	for _, logPath := range mergeStage.Logs {
		if !strings.Contains(logPath, filepath.Join("runs", summary.RunID, "merge", "logs")) {
			t.Fatalf("run manifest merge log path = %q, want run-local merge logs path", logPath)
		}
	}
}

func TestExecuteStagesSkippedStagePreservesExistingOutputsProvenance(t *testing.T) {
	cfg := testConfig(t)
	store := &manifest.LocalStore{}
	manifestPath := manifestPathFor(cfg)

	existing := manifest.New(cfg.Session.SessionID, time.Date(2026, 5, 3, 1, 0, 0, 0, time.UTC))
	existing.MarkStageSucceeded("transcribe", time.Date(2026, 5, 3, 1, 1, 0, 0, time.UTC), []manifest.ArtifactRecord{
		{
			Kind:          "transcript_raw",
			LocalPath:     "transcripts/raw/alice.json",
			ProducerRunID: "20260501T000000Z-deadbeef",
		},
	})
	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
		t.Fatalf("MkdirAll() error = %v", err)
	}
	if err := store.Save(context.Background(), manifestPath, existing); err != nil {
		t.Fatalf("Save manifest error = %v", err)
	}

	summary, err := executeStages(context.Background(), cfg, []stage.Stage{BuildFullPlan()[1]}, RunOptions{})
	if err != nil {
		t.Fatalf("executeStages() error = %v", err)
	}
	if len(summary.Skipped) != 1 || summary.Skipped[0] != "transcribe" {
		t.Fatalf("summary = %#v, want skipped transcribe", summary)
	}

	loaded, err := store.Load(context.Background(), manifestPath)
	if err != nil {
		t.Fatalf("Load manifest error = %v", err)
	}
	got := loaded.Stages["transcribe"]
	if got == nil || len(got.Outputs) != 1 {
		t.Fatalf("transcribe outputs = %#v, want one preserved output", got)
	}
	if got.Outputs[0].ProducerRunID != "20260501T000000Z-deadbeef" {
		t.Fatalf("producer_run_id = %q, want preserved value", got.Outputs[0].ProducerRunID)
	}
}

func TestAdapterBackedStageFailureMarksManifestFailed(t *testing.T) {
	cases := []struct {
		name string
		env  *Env
	}{
		{name: "transcribe", env: &Env{WhisperX: &whisperx.FakeClient{Err: errors.New("transcribe fail")}}},
		{name: "merge", env: &Env{Seriatim: &seriatim.FakeRunner{Err: errors.New("merge fail")}}},
		{name: "polish", env: &Env{Audita: &audita.FakeRunner{Err: errors.New("polish fail")}}},
		{name: "analyze", env: &Env{Scriptorium: &scriptorium.FakeRunner{RunErr: errors.New("analyze fail")}}},
		{name: "archive", env: &Env{ObjectStore: &storage.FakeBackend{UploadErr: errors.New("archive fail")}}},
		{name: "notify", env: &Env{Notifier: &notify.FakeSender{Err: errors.New("notify fail")}}},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			cfg := testConfig(t)
			selected, err := stage.Select(tc.name)
			if err != nil {
				t.Fatalf("Select() error = %v", err)
			}

			artifactStore := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root)
			tc.env.Config = cfg
			tc.env.ArtifactStore = artifactStore
			tc.env.ManifestStore = &manifest.LocalStore{}
			if tc.name == "transcribe" {
				paths, ensureErr := artifactStore.EnsureLayoutFor(cfg.Session.Campaign, cfg.Session.SessionID)
				if ensureErr != nil {
					t.Fatalf("EnsureLayout() error = %v", ensureErr)
				}
				audioPath := filepath.Join(paths.AudioDir, "alice.flac")
				if err := os.WriteFile(audioPath, []byte("audio"), 0o644); err != nil {
					t.Fatalf("write transcribe fixture audio: %v", err)
				}
				m := manifest.New(cfg.Session.SessionID, time.Now().UTC())
				m.Inputs = append(m.Inputs, manifest.InputRecord{Kind: "audio", Path: audioPath})
				if err := tc.env.ManifestStore.Save(context.Background(), manifestPathFor(cfg), m); err != nil {
					t.Fatalf("seed manifest: %v", err)
				}
			}
			if tc.name == "merge" {
				paths, ensureErr := artifactStore.EnsureLayoutFor(cfg.Session.Campaign, cfg.Session.SessionID)
				if ensureErr != nil {
					t.Fatalf("EnsureLayout() error = %v", ensureErr)
				}
				rawPath := filepath.Join(paths.TranscriptsRawDir, "alice.json")
				if err := os.MkdirAll(filepath.Dir(rawPath), 0o755); err != nil {
					t.Fatalf("mkdir raw dir: %v", err)
				}
				if err := os.WriteFile(rawPath, []byte(`{"segments":[]}`), 0o644); err != nil {
					t.Fatalf("write raw transcript: %v", err)
				}
				if err := os.WriteFile(filepath.Join(paths.InputsDir, "speakers.yml"), []byte("match: []\n"), 0o644); err != nil {
					t.Fatalf("write speakers: %v", err)
				}
				if err := os.WriteFile(filepath.Join(paths.InputsDir, "autocorrect.yml"), []byte("rules: []\n"), 0o644); err != nil {
					t.Fatalf("write autocorrect: %v", err)
				}
			}
			if tc.name == "polish" {
				paths, ensureErr := artifactStore.EnsureLayoutFor(cfg.Session.Campaign, cfg.Session.SessionID)
				if ensureErr != nil {
					t.Fatalf("EnsureLayout() error = %v", ensureErr)
				}
				if err := os.WriteFile(filepath.Join(paths.TranscriptsDir, "merged.json"), []byte(`{"segments":[]}`), 0o644); err != nil {
					t.Fatalf("write merged transcript: %v", err)
				}
				if err := os.WriteFile(filepath.Join(paths.InputsDir, "glossary.yml"), []byte("terms: []\n"), 0o644); err != nil {
					t.Fatalf("write glossary: %v", err)
				}
			}
			if tc.name == "analyze" {
				paths, ensureErr := artifactStore.EnsureLayoutFor(cfg.Session.Campaign, cfg.Session.SessionID)
				if ensureErr != nil {
					t.Fatalf("EnsureLayout() error = %v", ensureErr)
				}
				if err := os.WriteFile(filepath.Join(paths.TranscriptsDir, "processed.json"), []byte(`{"segments":[]}`), 0o644); err != nil {
					t.Fatalf("write processed transcript: %v", err)
				}
				cfg.Pipeline.Scriptorium = &config.ScriptoriumConfig{
					Binary:  "scriptorium",
					Timeout: "10m",
					Artifacts: map[string]config.ScriptoriumArtifactConfig{
						"session_recap": {
							Enabled:    true,
							PromptID:   "dnd.session_recap",
							OutputPath: "artifacts/session_recap.md",
							Inputs: map[string]config.ScriptoriumInputConfig{
								"transcript": {Source: "processed_transcript", Required: true},
							},
						},
					},
				}
			}
			if tc.name == "archive" {
				cfg.Pipeline.Archive = &config.ArchiveConfig{
					Enabled:   boolPtr(true),
					UploadRun: boolPtr(true),
				}
				cfg.Pipeline.Storage.S3 = &config.StorageS3Config{
					Bucket:     "my-dnd-archive",
					RootPrefix: "dnd",
				}
				runID := "20260516T010203Z-0a1b2c3d"
				runWorkDir := filepath.Join(cfg.Pipeline.Workspace.Root, "work", cfg.Session.Campaign, cfg.Session.SessionID, runID)
				if err := os.MkdirAll(filepath.Join(runWorkDir, "inputs"), 0o755); err != nil {
					t.Fatalf("mkdir archive inputs dir: %v", err)
				}
				if err := os.WriteFile(filepath.Join(runWorkDir, "inputs", "session.yml"), []byte("session_id: 2026-05-03\n"), 0o644); err != nil {
					t.Fatalf("write archive fixture session.yml: %v", err)
				}
				if err := os.WriteFile(filepath.Join(runWorkDir, "manifest.json"), []byte("{}\n"), 0o644); err != nil {
					t.Fatalf("write archive fixture manifest.json: %v", err)
				}

				seed := manifest.New(cfg.Session.SessionID, time.Now().UTC())
				seed.Campaign = cfg.Session.Campaign
				seed.RunID = runID
				seed.LocalWorkDir = runWorkDir
				seed.S3Bucket = "my-dnd-archive"
				seed.S3SessionPrefix = "dnd/campaigns/" + cfg.Session.Campaign + "/sessions/" + cfg.Session.SessionID + "/"
				seed.S3RunPrefix = seed.S3SessionPrefix + "runs/" + runID + "/"
				for _, name := range []string{"prepare", "transcribe", "merge", "polish", "normalize", "trim", "analyze"} {
					seed.MarkStageSucceeded(name, time.Now().UTC(), nil)
				}
				if err := tc.env.ManifestStore.Save(context.Background(), manifestPathFor(cfg), seed); err != nil {
					t.Fatalf("seed archive manifest: %v", err)
				}
			}

			_, runErr := executeStages(context.Background(), cfg, []stage.Stage{selected}, RunOptions{Env: tc.env})
			if runErr == nil {
				t.Fatal("expected error, got nil")
			}

			m, loadErr := tc.env.ManifestStore.Load(context.Background(), manifestPathFor(cfg))
			if loadErr != nil {
				t.Fatalf("load manifest error = %v", loadErr)
			}
			sr := m.Stages[tc.name]
			if sr == nil {
				t.Fatalf("missing stage record %q", tc.name)
			}
			if sr.Status != manifest.StatusFailed {
				t.Fatalf("status = %q, want %q", sr.Status, manifest.StatusFailed)
			}
		})
	}
}

func testConfig(t *testing.T) *config.Config {
	t.Helper()

	workspace := t.TempDir()
	cfgDir := t.TempDir()
	sessionPath := filepath.Join(cfgDir, "session.yml")
	pipelinePath := filepath.Join(cfgDir, "pipeline.yml")

	mustWriteFile(t, pipelinePath, "workspace:\n  root: "+workspace+"\n")
	mustWriteFile(t, sessionPath, "session_id: 2026-05-03\ncampaign: sample-campaign\n")
	mustWriteFile(t, filepath.Join(cfgDir, "speakers.yml"), "alice: alice.flac\n")
	mustWriteFile(t, filepath.Join(cfgDir, "autocorrect.yml"), "[]\n")
	mustWriteFile(t, filepath.Join(cfgDir, "glossary.yml"), "[]\n")
	mustWriteFile(t, filepath.Join(cfgDir, "audio", "alice.flac"), "audio")

	return &config.Config{
		Pipeline:     &config.PipelineConfig{Workspace: config.WorkspaceConfig{Root: workspace}},
		PipelinePath: pipelinePath,
		SessionPath:  sessionPath,
		Session: &config.SessionConfig{
			SessionID: "2026-05-03",
			Campaign:  "sample-campaign",
			Inputs: config.SessionInputsConfig{
				AudioDir:        "./audio",
				SpeakersFile:    "./speakers.yml",
				AutocorrectFile: "./autocorrect.yml",
				GlossaryFile:    "./glossary.yml",
			},
		},
	}
}

func TestBuildDefaultRunnersWithOmittedToolSections(t *testing.T) {
	dir := t.TempDir()
	pipelinePath := filepath.Join(dir, "pipeline.yml")
	sessionPath := filepath.Join(dir, "session.yml")
	pipelineYAML := `workspace:
  root: ` + t.TempDir() + `
whisperx:
  transcribe_url: https://example.com/transcribe
analyzer:
  timeout: 20m
notification:
  timeout: 10s
`
	sessionYAML := `session_id: 2026-05-03
campaign: sample-campaign
inputs:
  audio_dir: ./audio
  speakers_file: ./speakers.yml
  autocorrect_file: ./autocorrect.yml
  glossary_file: ./glossary.yml
`
	mustWriteFile(t, pipelinePath, pipelineYAML)
	mustWriteFile(t, sessionPath, sessionYAML)

	cfg, err := config.Load(pipelinePath, sessionPath)
	if err != nil {
		t.Fatalf("Load() error = %v", err)
	}
	if err := config.Validate(cfg); err != nil {
		t.Fatalf("Validate() error = %v", err)
	}

	serRunner, err := buildDefaultSeriatimRunner(cfg)
	if err != nil {
		t.Fatalf("buildDefaultSeriatimRunner() error = %v", err)
	}
	if _, ok := serRunner.(*seriatim.SubprocessRunner); !ok {
		t.Fatalf("seriatim runner type = %T, want *seriatim.SubprocessRunner", serRunner)
	}

	audRunner, err := buildDefaultAuditaRunner(cfg)
	if err != nil {
		t.Fatalf("buildDefaultAuditaRunner() error = %v", err)
	}
	if _, ok := audRunner.(*audita.SubprocessRunner); !ok {
		t.Fatalf("audita runner type = %T, want *audita.SubprocessRunner", audRunner)
	}
}

func mustWriteFile(t *testing.T, path, contents string) {
	t.Helper()
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		t.Fatalf("MkdirAll(%q): %v", path, err)
	}
	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
		t.Fatalf("WriteFile(%q): %v", path, err)
	}
}

func boolPtr(v bool) *bool {
	p := v
	return &p
}