Updated transcript artifact names and canonical paths to use a consistent, role-based nomenclature

2026-05-22 19:05:23 -05:00
parent e920f3a8d5
commit cee52aa092
56 changed files with 991 additions and 463 deletions
--- a/internal/stage/analyze.go
+++ b/internal/stage/analyze.go
@@ -24,9 +24,9 @@ func (analyzeStage) Name() string { return "analyze" }
 func (analyzeStage) Declares() IODecl {
 	return IODecl{
 		Inputs: []artifacts.Ref{
-			{Kind: "transcript_processed", Category: "transcripts", RelativePath: "transcripts/processed.json"},
-			{Kind: "transcript_normalized", Category: "transcripts", RelativePath: "transcripts/normalized.json"},
-			{Kind: "transcript_trimmed", Category: "transcripts", RelativePath: "transcripts/trimmed.json"},
+			{Kind: "transcript_polished", Category: "transcripts", RelativePath: "transcripts/polished.json"},
+			{Kind: "transcript_final", Category: "transcripts", RelativePath: "transcripts/final.json"},
+			{Kind: "transcript_final_trimmed", Category: "transcripts", RelativePath: "transcripts/final.trimmed.json"},
 		},
 		Outputs: nil,
 	}
@@ -562,7 +562,7 @@ func discoverProcessedTranscript(m *manifest.Manifest, paths artifacts.SessionPa
 	if m != nil && m.Stages != nil {
 		if sr := m.Stages["polish"]; sr != nil {
 			for _, out := range sr.Outputs {
-				if out.Kind != "transcript_processed" {
+				if out.Kind != "transcript_polished" {
 					continue
 				}
 				p := strings.TrimSpace(out.LocalPath)
@@ -581,7 +581,7 @@ func discoverProcessedTranscript(m *manifest.Manifest, paths artifacts.SessionPa
 		}
 	}

-	fallback := filepath.Join(paths.TranscriptsDir, "processed.json")
+	fallback := filepath.Join(paths.TranscriptsDir, "polished.json")
 	if info, err := os.Stat(fallback); err == nil && !info.IsDir() {
 		return filepath.Clean(fallback), "fallback.transcripts_dir", nil
 	}
@@ -602,8 +602,8 @@ type analyzeTranscriptInputs struct {

 func discoverAnalyzeTranscriptRefs(m *manifest.Manifest, paths artifacts.SessionPaths) analyzeTranscriptInputs {
 	processedPath, processedSource := discoverAnalyzeArtifactRef(m, paths, artifacts.ArtifactTranscriptPolished)
-	normalizedPath, normalizedSource := discoverAnalyzeArtifactRef(m, paths, artifacts.ArtifactTranscriptFull)
-	trimmedPath, trimmedSource := discoverAnalyzeArtifactRef(m, paths, artifacts.ArtifactTranscriptTrimmed)
+	normalizedPath, normalizedSource := discoverAnalyzeArtifactRef(m, paths, artifacts.ArtifactTranscriptFinal)
+	trimmedPath, trimmedSource := discoverAnalyzeArtifactRef(m, paths, artifacts.ArtifactTranscriptFinalTrimmed)
 	return analyzeTranscriptInputs{
 		ProcessedPath:    processedPath,
 		ProcessedSource:  processedSource,
@@ -669,9 +669,9 @@ func resolveScriptoriumInput(
 			switch normalized {
 			case artifacts.ArtifactTranscriptPolished:
 				return "", false, nil, nil
-			case artifacts.ArtifactTranscriptFull:
+			case artifacts.ArtifactTranscriptFinal:
 				return "", false, nil, fmt.Errorf("normalized transcript input is unavailable; run normalize stage first")
-			case artifacts.ArtifactTranscriptTrimmed:
+			case artifacts.ArtifactTranscriptFinalTrimmed:
 				return "", false, nil, fmt.Errorf("trimmed transcript input is unavailable; run trim stage first")
 			default:
 				return "", false, nil, nil
--- a/internal/stage/analyze_test.go
+++ b/internal/stage/analyze_test.go
@@ -19,7 +19,7 @@ import (
 func TestAnalyzeGeneratesSessionRecapFromTrimmedTranscript(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	result, err := (analyzeStage{}).Run(context.Background(), env, m)
 	if err != nil {
@@ -36,7 +36,7 @@ func TestAnalyzeGeneratesSessionRecapFromTrimmedTranscript(t *testing.T) {
 	if req.ProfileID != "local-quality" {
 		t.Fatalf("profile id = %q, want local-quality", req.ProfileID)
 	}
-	if req.InputPaths["transcript"] != filepath.Join(paths.TranscriptsDir, "trimmed.json") {
+	if req.InputPaths["transcript"] != filepath.Join(paths.TranscriptsDir, "final.trimmed.json") {
 		t.Fatalf("transcript input = %q, want trimmed transcript path", req.InputPaths["transcript"])
 	}
 	if req.OutputPath != filepath.Join(paths.ArtifactsDir, "session_recap.md") {
@@ -72,7 +72,7 @@ func TestAnalyzeGeneratesSessionRecapFromTrimmedTranscript(t *testing.T) {
 func TestAnalyzeRenderDebugFalseDoesNotCallRenderArtifact(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.RenderDebug = false

@@ -88,7 +88,7 @@ func TestAnalyzeRenderDebugFalseDoesNotCallRenderArtifact(t *testing.T) {
 func TestAnalyzeRenderDebugArtifactOverrideFalseWinsOverGlobalTrue(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.RenderDebug = true
 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
@@ -111,7 +111,7 @@ func TestAnalyzeRenderDebugArtifactOverrideFalseWinsOverGlobalTrue(t *testing.T)
 func TestAnalyzeRenderDebugTrueCallsRenderBeforeRun(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.RenderDebug = true
 	runner := &orderedScriptoriumRunner{
@@ -132,7 +132,7 @@ func TestAnalyzeRenderDebugTrueCallsRenderBeforeRun(t *testing.T) {
 func TestAnalyzeRenderOutputPathIsRecorded(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	env.Config.Pipeline.Scriptorium.RenderDebug = true

 	result, err := (analyzeStage{}).Run(context.Background(), env, m)
@@ -156,7 +156,7 @@ func TestAnalyzeRenderOutputPathIsRecorded(t *testing.T) {
 func TestAnalyzeRenderFailurePreventsRun(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	env.Config.Pipeline.Scriptorium.RenderDebug = true
 	fake.RenderErr = errors.New("render boom")

@@ -178,7 +178,7 @@ func TestAnalyzeRenderFailurePreventsRun(t *testing.T) {
 func TestAnalyzeRenderInvalidJSONFailsClearly(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	env.Config.Pipeline.Scriptorium.RenderDebug = true
 	runner := &orderedScriptoriumRunner{
 		RenderBody: `not-json`,
@@ -201,7 +201,7 @@ func TestAnalyzeRenderInvalidJSONFailsClearly(t *testing.T) {
 func TestAnalyzeRunStillSucceedsWhenRenderSucceeds(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	env.Config.Pipeline.Scriptorium.RenderDebug = true

 	result, err := (analyzeStage{}).Run(context.Background(), env, m)
@@ -222,7 +222,7 @@ func TestAnalyzeRunStillSucceedsWhenRenderSucceeds(t *testing.T) {
 func TestAnalyzeOmitsOptionalCanonicalPreviousRecapWhenUnavailable(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{
 		Enabled:    true,
@@ -261,7 +261,7 @@ func TestAnalyzeUsesRunLocalPathsAndPromotesCanonical(t *testing.T) {
 	m.Campaign = "sample-campaign"
 	m.RunID = "20260518T010203Z-abcdef12"
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	result, err := (analyzeStage{}).Run(context.Background(), env, m)
 	if err != nil {
@@ -344,7 +344,7 @@ func (r *orderedScriptoriumRunner) RunArtifact(_ context.Context, req scriptoriu
 func TestAnalyzeIncludesCanonicalPreviousRecapWhenPreparedCacheExists(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`)

 	previousRecapPath := artifacts.SessionPreviousArtifactPath(paths, "artifacts/session_recap.md")
 	writeAnalyzeFile(t, previousRecapPath, "previous recap\n")
@@ -383,7 +383,7 @@ func TestAnalyzeIncludesCanonicalPreviousRecapWhenPreparedCacheExists(t *testing
 func TestAnalyzeFailsWhenRequiredCanonicalPreviousRecapMissing(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{
 		Enabled:    true,
@@ -413,7 +413,7 @@ func TestAnalyzeFailsWhenRequiredCanonicalPreviousRecapMissing(t *testing.T) {
 func TestAnalyzeResolvesConfiguredArtifactInputFromDisabledArtifactOutput(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	playerHandoutPath := filepath.Join(paths.ArtifactsDir, "player_handout.md")
 	writeAnalyzeFile(t, playerHandoutPath, "handout\n")

@@ -443,7 +443,7 @@ func TestAnalyzeResolvesConfiguredArtifactInputFromDisabledArtifactOutput(t *tes
 func TestAnalyzeMetadataIncludesGeneratedAndReusedArtifacts(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	playerHandoutPath := filepath.Join(paths.ArtifactsDir, "player_handout.md")
 	writeAnalyzeFile(t, playerHandoutPath, "handout\n")

@@ -512,7 +512,7 @@ func TestAnalyzeMetadataIncludesGeneratedAndReusedArtifacts(t *testing.T) {
 func TestAnalyzeRunsMultipleIndependentArtifactsInDeterministicOrder(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{
 		Enabled:    true,
@@ -521,7 +521,7 @@ func TestAnalyzeRunsMultipleIndependentArtifactsInDeterministicOrder(t *testing.
 		OutputPath: "artifacts/player_handout.md",
 		Inputs: map[string]config.ScriptoriumInputConfig{
 			"transcript": {
-				Source:   "narratio.transcript.trimmed",
+				Source:   "narratio.transcript.final_trimmed",
 				Required: true,
 			},
 		},
@@ -553,7 +553,7 @@ func TestAnalyzeRunsMultipleIndependentArtifactsInDeterministicOrder(t *testing.
 func TestAnalyzeRunsDependenciesBeforeDependents(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{
 		Enabled:    true,
@@ -567,7 +567,7 @@ func TestAnalyzeRunsDependenciesBeforeDependents(t *testing.T) {
 				Required: true,
 			},
 			"transcript": {
-				Source:   "narratio.transcript.trimmed",
+				Source:   "narratio.transcript.final_trimmed",
 				Required: true,
 			},
 		},
@@ -594,7 +594,7 @@ func TestAnalyzeRunsDependenciesBeforeDependents(t *testing.T) {
 func TestAnalyzeAppliesSelectedArtifactsFilter(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{
 		Enabled:    true,
@@ -603,7 +603,7 @@ func TestAnalyzeAppliesSelectedArtifactsFilter(t *testing.T) {
 		OutputPath: "artifacts/player_handout.md",
 		Inputs: map[string]config.ScriptoriumInputConfig{
 			"transcript": {
-				Source:   "narratio.transcript.trimmed",
+				Source:   "narratio.transcript.final_trimmed",
 				Required: true,
 			},
 		},
@@ -628,7 +628,7 @@ func TestAnalyzeAppliesSelectedArtifactsFilter(t *testing.T) {
 func TestAnalyzeMetadataIncludesMultipleGeneratedArtifacts(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["player_handout"] = config.ScriptoriumArtifactConfig{
 		Enabled:    true,
@@ -637,7 +637,7 @@ func TestAnalyzeMetadataIncludesMultipleGeneratedArtifacts(t *testing.T) {
 		OutputPath: "artifacts/player_handout.md",
 		Inputs: map[string]config.ScriptoriumInputConfig{
 			"transcript": {
-				Source:   "narratio.transcript.trimmed",
+				Source:   "narratio.transcript.final_trimmed",
 				Required: true,
 			},
 		},
@@ -663,7 +663,7 @@ func TestAnalyzeMetadataIncludesMultipleGeneratedArtifacts(t *testing.T) {
 func TestAnalyzeFailsWhenRequiredConfiguredArtifactMissing(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{
@@ -688,7 +688,7 @@ func TestAnalyzeFailsWhenRequiredConfiguredArtifactMissing(t *testing.T) {
 func TestAnalyzeOmitsOptionalMissingConfiguredArtifactInput(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	sessionRecap.Inputs["recap"] = config.ScriptoriumInputConfig{
@@ -735,7 +735,7 @@ func TestAnalyzeRequiredPreviousSessionArtifactInputGuidesPrepareForce(t *testin
 func TestAnalyzeResolvesCanonicalPreviousSessionArtifactFromManifestInput(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	previousPath := artifacts.SessionPreviousArtifactPath(paths, "artifacts/session_recap.md")
 	writeAnalyzeFile(t, previousPath, "previous recap\n")
@@ -766,7 +766,7 @@ func TestAnalyzeResolvesCanonicalPreviousSessionArtifactFromManifestInput(t *tes
 func TestAnalyzeOmitsOptionalMissingCanonicalPreviousSessionArtifact(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	sessionRecap := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	sessionRecap.Inputs["previous_recap"] = config.ScriptoriumInputConfig{
@@ -790,7 +790,7 @@ func TestAnalyzeOmitsOptionalMissingCanonicalPreviousSessionArtifact(t *testing.
 func TestAnalyzeRenderDebugWithCanonicalPreviousSessionInput(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	env.Config.Pipeline.Scriptorium.RenderDebug = true

 	previousPath := artifacts.SessionPreviousArtifactPath(paths, "artifacts/session_recap.md")
@@ -825,7 +825,7 @@ func TestAnalyzeRenderDebugWithCanonicalPreviousSessionInput(t *testing.T) {
 func TestAnalyzeDoesNotCallObjectStoreForCanonicalPreviousSessionInput(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	previousPath := artifacts.SessionPreviousArtifactPath(paths, "artifacts/session_recap.md")
 	writeAnalyzeFile(t, previousPath, "previous recap\n")
@@ -856,7 +856,7 @@ func TestAnalyzeDoesNotCallObjectStoreForCanonicalPreviousSessionInput(t *testin
 func TestAnalyzeFailsWhenOutputPathMissing(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.OutputPath = ""
@@ -891,7 +891,7 @@ func TestAnalyzeFailsWhenTrimmedTranscriptMissing(t *testing.T) {
 func TestAnalyzeSupportsProcessedTranscriptSourceWhenConfigured(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[]}`)

 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{
@@ -907,7 +907,7 @@ func TestAnalyzeSupportsProcessedTranscriptSourceWhenConfigured(t *testing.T) {
 	if len(fake.RunRequests) != 1 {
 		t.Fatalf("run requests = %d, want 1", len(fake.RunRequests))
 	}
-	if fake.RunRequests[0].InputPaths["transcript"] != filepath.Join(paths.TranscriptsDir, "processed.json") {
+	if fake.RunRequests[0].InputPaths["transcript"] != filepath.Join(paths.TranscriptsDir, "polished.json") {
 		t.Fatalf("transcript input = %q, want processed transcript path", fake.RunRequests[0].InputPaths["transcript"])
 	}
 }
@@ -915,11 +915,11 @@ func TestAnalyzeSupportsProcessedTranscriptSourceWhenConfigured(t *testing.T) {
 func TestAnalyzeSupportsCanonicalTrimmedTranscriptSourceWhenConfigured(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{
-		Source:   "narratio.transcript.trimmed",
+		Source:   "narratio.transcript.final_trimmed",
 		Required: true,
 	}
 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact
@@ -931,7 +931,7 @@ func TestAnalyzeSupportsCanonicalTrimmedTranscriptSourceWhenConfigured(t *testin
 	if len(fake.RunRequests) != 1 {
 		t.Fatalf("run requests = %d, want 1", len(fake.RunRequests))
 	}
-	if fake.RunRequests[0].InputPaths["transcript"] != filepath.Join(paths.TranscriptsDir, "trimmed.json") {
+	if fake.RunRequests[0].InputPaths["transcript"] != filepath.Join(paths.TranscriptsDir, "final.trimmed.json") {
 		t.Fatalf("transcript input = %q, want trimmed transcript path", fake.RunRequests[0].InputPaths["transcript"])
 	}
 }
@@ -939,12 +939,12 @@ func TestAnalyzeSupportsCanonicalTrimmedTranscriptSourceWhenConfigured(t *testin
 func TestAnalyzeSupportsNormalizedTranscriptSourceWhenConfigured(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	normalizedPath := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	normalizedPath := filepath.Join(paths.TranscriptsDir, "final.json")
 	writeAnalyzeFile(t, normalizedPath, `{"segments":[{"id":1}]}`)

 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{
-		Source:   "narratio.transcript.full",
+		Source:   "narratio.transcript.final",
 		Required: true,
 	}
 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact
@@ -964,17 +964,17 @@ func TestAnalyzeSupportsNormalizedTranscriptSourceWhenConfigured(t *testing.T) {
 func TestAnalyzeSupportsCanonicalNormalizedTranscriptSourceFromManifestOutput(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	fallbackPath := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	fallbackPath := filepath.Join(paths.TranscriptsDir, "final.json")
 	manifestPath := filepath.Join(paths.ArtifactsDir, "normalized.from-manifest.json")
 	writeAnalyzeFile(t, fallbackPath, `{"segments":[{"id":999}]}`)
 	writeAnalyzeFile(t, manifestPath, `{"segments":[{"id":10}]}`)
 	m.MarkStageSucceeded("normalize", time.Now().UTC(), []manifest.ArtifactRecord{
-		{Kind: "transcript_normalized", LocalPath: manifestPath},
+		{Kind: "transcript_final", LocalPath: manifestPath},
 	})

 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{
-		Source:   "narratio.transcript.full",
+		Source:   "narratio.transcript.final",
 		Required: true,
 	}
 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact
@@ -994,17 +994,17 @@ func TestAnalyzeSupportsCanonicalNormalizedTranscriptSourceFromManifestOutput(t
 func TestAnalyzeSupportsNormalizedTranscriptSourceFromManifestOutput(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	fallbackPath := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	fallbackPath := filepath.Join(paths.TranscriptsDir, "final.json")
 	manifestPath := filepath.Join(paths.ArtifactsDir, "normalized.from-manifest.json")
 	writeAnalyzeFile(t, fallbackPath, `{"segments":[{"id":999}]}`)
 	writeAnalyzeFile(t, manifestPath, `{"segments":[{"id":10}]}`)
 	m.MarkStageSucceeded("normalize", time.Now().UTC(), []manifest.ArtifactRecord{
-		{Kind: "transcript_normalized", LocalPath: manifestPath},
+		{Kind: "transcript_final", LocalPath: manifestPath},
 	})

 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{
-		Source:   "narratio.transcript.full",
+		Source:   "narratio.transcript.final",
 		Required: true,
 	}
 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact
@@ -1025,7 +1025,7 @@ func TestAnalyzeFailsWhenNormalizedTranscriptMissing(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	artifact := env.Config.Pipeline.Scriptorium.Artifacts["session_recap"]
 	artifact.Inputs["transcript"] = config.ScriptoriumInputConfig{
-		Source:   "narratio.transcript.full",
+		Source:   "narratio.transcript.final",
 		Required: true,
 	}
 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = artifact
@@ -1048,7 +1048,7 @@ func TestAnalyzeFailsWhenNormalizedTranscriptMissing(t *testing.T) {
 func TestAnalyzeFailsWhenProcessedTranscriptInvalidJSON(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{not-json`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{not-json`)

 	_, err := (analyzeStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -1062,7 +1062,7 @@ func TestAnalyzeFailsWhenProcessedTranscriptInvalidJSON(t *testing.T) {
 func TestAnalyzeFailsWhenProcessedTranscriptMissingSegmentsArray(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"not_segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"not_segments":[]}`)

 	_, err := (analyzeStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -1076,7 +1076,7 @@ func TestAnalyzeFailsWhenProcessedTranscriptMissingSegmentsArray(t *testing.T) {
 func TestAnalyzeRecordsRefsAndMetadata(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	result, err := (analyzeStage{}).Run(context.Background(), env, m)
 	if err != nil {
@@ -1105,7 +1105,7 @@ func TestAnalyzeRecordsRefsAndMetadata(t *testing.T) {
 func TestAnalyzeHandlesAdapterError(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	fake.RunErr = errors.New("adapter boom")

 	_, err := (analyzeStage{}).Run(context.Background(), env, m)
@@ -1120,7 +1120,7 @@ func TestAnalyzeHandlesAdapterError(t *testing.T) {
 func TestAnalyzeHandlesValidationFailedResultAsError(t *testing.T) {
 	env, m, fake := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)
 	fake.RunResult = scriptorium.ArtifactResult{
 		ValidationFailed: true,
 		ExitCode:         2,
@@ -1139,7 +1139,7 @@ func TestAnalyzeHandlesValidationFailedResultAsError(t *testing.T) {
 func TestAnalyzeSkipsWhenNoEnabledScriptoriumArtifactsConfigured(t *testing.T) {
 	env, m, _ := setupAnalyzeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "trimmed.json"), `{"segments":[]}`)
+	writeAnalyzeFile(t, filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), `{"segments":[]}`)

 	env.Config.Pipeline.Scriptorium.Artifacts["session_recap"] = config.ScriptoriumArtifactConfig{
 		Enabled: false,
@@ -1199,7 +1199,7 @@ func setupAnalyzeEnv(t *testing.T) (*Env, *manifest.Manifest, *scriptorium.FakeR
 						Timeout:    "2m",
 						Inputs: map[string]config.ScriptoriumInputConfig{
 							"transcript": {
-								Source:   "narratio.transcript.trimmed",
+								Source:   "narratio.transcript.final_trimmed",
 								Required: true,
 							},
 							"previous_recap": {
--- a/internal/stage/archive_test.go
+++ b/internal/stage/archive_test.go
@@ -82,7 +82,7 @@ func TestArchiveUploadsRunRecordPromotionsAndCurrentPointer(t *testing.T) {
 		"manifest.json",
 		"polish/reports/audita.report.json",
 		"transcribe/outputs/transcripts/raw/speaker.json",
-		"trim/outputs/transcripts/trimmed.json",
+		"trim/outputs/transcripts/final.trimmed.json",
 	}
 	for _, rel := range wantRunUploads {
 		key := runPrefix + rel
@@ -91,7 +91,7 @@ func TestArchiveUploadsRunRecordPromotionsAndCurrentPointer(t *testing.T) {
 		}
 	}

-	trimmedKey := sessionPrefix + "transcripts/trimmed.json"
+	trimmedKey := sessionPrefix + "transcripts/final.trimmed.json"
 	recapKey := sessionPrefix + "artifacts/session_recap.md"
 	if _, ok := fake.Objects[trimmedKey]; !ok {
 		t.Fatalf("missing promoted key %q", trimmedKey)
@@ -180,7 +180,7 @@ func TestArchiveToleratesMissingPreviousCache(t *testing.T) {
 func TestArchiveUsesCustomPromotionRules(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	env.Config.Pipeline.Archive.PromoteArtifacts = []config.ArchivePromotionRule{
-		{Source: "narratio.transcript.trimmed", Dest: "published/trimmed.json", Required: boolPtr(true)},
+		{Source: "narratio.transcript.final_trimmed", Dest: "published/trimmed.json", Required: boolPtr(true)},
 		{Source: "narratio.artifact.session_recap", Dest: "published/recap.md", Required: boolPtr(true)},
 	}

@@ -201,8 +201,8 @@ func TestArchiveUsesCustomPromotionRules(t *testing.T) {
 func TestArchiveSkipsOptionalMissingPromotion(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	env.Config.Pipeline.Archive.PromoteArtifacts = []config.ArchivePromotionRule{
-		{Source: "narratio.transcript.trimmed", Dest: "transcripts/trimmed.json", Required: boolPtr(true)},
-		{Source: "narratio.transcript.merged", Dest: "transcripts/merged.json", Required: boolPtr(false)},
+		{Source: "narratio.transcript.final_trimmed", Dest: "transcripts/final.trimmed.json", Required: boolPtr(true)},
+		{Source: "narratio.transcript.base", Dest: "transcripts/base.json", Required: boolPtr(false)},
 	}

 	result, err := archiveStage{}.Run(context.Background(), env, m)
@@ -210,7 +210,7 @@ func TestArchiveSkipsOptionalMissingPromotion(t *testing.T) {
 		t.Fatalf("Run() error = %v", err)
 	}
 	got, _ := result.Metadata["skipped_optional_promotions"].([]string)
-	want := []string{"transcripts/merged.json"}
+	want := []string{"transcripts/base.json"}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("skipped_optional_promotions = %#v, want %#v", got, want)
 	}
@@ -230,7 +230,7 @@ func TestArchiveSkipsRequiredUnselectedConfiguredPromotion(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Run() error = %v", err)
 	}
-	if _, ok := fake.Objects[m.S3SessionPrefix+"transcripts/trimmed.json"]; !ok {
+	if _, ok := fake.Objects[m.S3SessionPrefix+"transcripts/final.trimmed.json"]; !ok {
 		t.Fatalf("missing built-in promoted trimmed key")
 	}
 	if _, ok := fake.Objects[m.S3SessionPrefix+"artifacts/session_recap.md"]; ok {
@@ -321,7 +321,7 @@ func TestArchiveLockedUnselectedConfiguredPromotionSkipsAsUnselected(t *testing.
 func TestArchiveSkipsLockedRequiredPromotionAndCommits(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	env.Config.Pipeline.Archive.Locks = []config.ArchiveLockRule{
-		{Source: "narratio.transcript.trimmed", Reason: "human reviewed"},
+		{Source: "narratio.transcript.final_trimmed", Reason: "human reviewed"},
 	}
 	fake := env.ObjectStore.(*storage.FakeBackend)

@@ -330,7 +330,7 @@ func TestArchiveSkipsLockedRequiredPromotionAndCommits(t *testing.T) {
 		t.Fatalf("Run() error = %v", err)
 	}

-	trimmedKey := m.S3SessionPrefix + "transcripts/trimmed.json"
+	trimmedKey := m.S3SessionPrefix + "transcripts/final.trimmed.json"
 	if _, ok := fake.Objects[trimmedKey]; ok {
 		t.Fatalf("locked promotion key %q should not be uploaded", trimmedKey)
 	}
@@ -338,7 +338,7 @@ func TestArchiveSkipsLockedRequiredPromotionAndCommits(t *testing.T) {
 	if _, ok := fake.Objects[recapKey]; !ok {
 		t.Fatalf("unlocked promotion key %q should be uploaded", recapKey)
 	}
-	runTrimmedKey := m.S3RunPrefix + "trim/outputs/transcripts/trimmed.json"
+	runTrimmedKey := m.S3RunPrefix + "trim/outputs/transcripts/final.trimmed.json"
 	if _, ok := fake.Objects[runTrimmedKey]; !ok {
 		t.Fatalf("run-local locked source output %q should still be uploaded", runTrimmedKey)
 	}
@@ -358,8 +358,8 @@ func TestArchiveSkipsLockedRequiredPromotionAndCommits(t *testing.T) {
 	if len(locked) != 1 {
 		t.Fatalf("locked_promotions = %#v, want one item", locked)
 	}
-	if locked[0]["source"] != "narratio.transcript.trimmed" ||
-		locked[0]["dest"] != "transcripts/trimmed.json" ||
+	if locked[0]["source"] != "narratio.transcript.final_trimmed" ||
+		locked[0]["dest"] != "transcripts/final.trimmed.json" ||
 		locked[0]["remote_key"] != trimmedKey ||
 		locked[0]["reason"] != "human reviewed" ||
 		locked[0]["required"] != true ||
@@ -388,10 +388,10 @@ func TestArchiveSkipsLockedRequiredPromotionAndCommits(t *testing.T) {
 func TestArchiveLockedRequiredMissingPromotionSucceeds(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	env.Config.Pipeline.Archive.PromoteArtifacts = []config.ArchivePromotionRule{
-		{Source: "narratio.transcript.merged", Dest: "transcripts/merged.json", Required: boolPtr(true)},
+		{Source: "narratio.transcript.base", Dest: "transcripts/base.json", Required: boolPtr(true)},
 	}
 	env.Config.Pipeline.Archive.Locks = []config.ArchiveLockRule{
-		{Source: "narratio.transcript.merged", Reason: "manual merge is locked"},
+		{Source: "narratio.transcript.base", Reason: "manual merge is locked"},
 	}

 	result, err := archiveStage{}.Run(context.Background(), env, m)
@@ -400,7 +400,7 @@ func TestArchiveLockedRequiredMissingPromotionSucceeds(t *testing.T) {
 	}

 	fake := env.ObjectStore.(*storage.FakeBackend)
-	mergedKey := m.S3SessionPrefix + "transcripts/merged.json"
+	mergedKey := m.S3SessionPrefix + "transcripts/base.json"
 	if _, ok := fake.Objects[mergedKey]; ok {
 		t.Fatalf("locked missing promotion key %q should not be uploaded", mergedKey)
 	}
@@ -419,10 +419,10 @@ func TestArchiveLockedRequiredMissingPromotionSucceeds(t *testing.T) {
 func TestArchiveLockDoesNotOverwriteExistingPromotion(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	env.Config.Pipeline.Archive.Locks = []config.ArchiveLockRule{
-		{Source: "narratio.transcript.trimmed", Reason: "already published"},
+		{Source: "narratio.transcript.final_trimmed", Reason: "already published"},
 	}
 	fake := env.ObjectStore.(*storage.FakeBackend)
-	trimmedKey := m.S3SessionPrefix + "transcripts/trimmed.json"
+	trimmedKey := m.S3SessionPrefix + "transcripts/final.trimmed.json"
 	fake.SeedObject(storage.FakeObject{Key: trimmedKey, Data: []byte("previously published\n")})

 	if _, err := (archiveStage{}).Run(context.Background(), env, m); err != nil {
@@ -443,7 +443,7 @@ func TestArchiveLockDoesNotOverwriteExistingPromotion(t *testing.T) {
 func TestArchiveFailsWhenRequiredPromotionMissing(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	env.Config.Pipeline.Archive.PromoteArtifacts = []config.ArchivePromotionRule{
-		{Source: "narratio.transcript.merged", Dest: "transcripts/merged.json", Required: boolPtr(true)},
+		{Source: "narratio.transcript.base", Dest: "transcripts/base.json", Required: boolPtr(true)},
 	}

 	_, err := archiveStage{}.Run(context.Background(), env, m)
@@ -470,7 +470,7 @@ func TestArchiveFailsWhenCanonicalRunRootMissing(t *testing.T) {
 func TestArchiveDoesNotWriteCurrentPointerWhenPromotionUploadFails(t *testing.T) {
 	env, m, _ := archiveFixture(t)
 	fake := env.ObjectStore.(*storage.FakeBackend)
-	trimmedKey := m.S3SessionPrefix + "transcripts/trimmed.json"
+	trimmedKey := m.S3SessionPrefix + "transcripts/final.trimmed.json"

 	origUploadErr := fake.UploadErr
 	fake.UploadErr = nil
@@ -528,13 +528,13 @@ func archiveFixture(t *testing.T) (*Env, *manifest.Manifest, string) {
 	sessionRoot := artifacts.SessionWorkDirForCampaign(root, campaign, sessionID)
 	runRoot := artifacts.SessionRunRootForCampaign(root, campaign, sessionID, runID)

-	writeStageTestFile(t, filepath.Join(sessionRoot, "transcripts", "trimmed.json"), "{\"segments\":[]}\n")
+	writeStageTestFile(t, filepath.Join(sessionRoot, "transcripts", "final.trimmed.json"), "{\"segments\":[]}\n")
 	writeStageTestFile(t, filepath.Join(sessionRoot, "artifacts", "session_recap.md"), "# recap\n")

 	writeStageTestFile(t, filepath.Join(runRoot, "prepare", "inputs", "session.yml"), "session_id: 2026-04-19\n")
 	writeStageTestFile(t, filepath.Join(runRoot, "prepare", "outputs", "audio", "speaker.flac"), "flac\n")
 	writeStageTestFile(t, filepath.Join(runRoot, "transcribe", "outputs", "transcripts", "raw", "speaker.json"), "{}\n")
-	writeStageTestFile(t, filepath.Join(runRoot, "trim", "outputs", "transcripts", "trimmed.json"), "{\"segments\":[]}\n")
+	writeStageTestFile(t, filepath.Join(runRoot, "trim", "outputs", "transcripts", "final.trimmed.json"), "{\"segments\":[]}\n")
 	writeStageTestFile(t, filepath.Join(runRoot, "analyze", "outputs", "artifacts", "session_recap.md"), "# recap\n")
 	writeStageTestFile(t, filepath.Join(runRoot, "polish", "reports", "audita.report.json"), "{}\n")
 	writeStageTestFile(t, filepath.Join(runRoot, "merge", "config", "seriatim.generated.yml"), "key: value\n")
@@ -567,7 +567,7 @@ func archiveFixture(t *testing.T) (*Env, *manifest.Manifest, string) {
 					Enabled:   boolPtr(true),
 					UploadRun: boolPtr(true),
 					PromoteArtifacts: []config.ArchivePromotionRule{
-						{Source: "narratio.transcript.trimmed", Dest: "transcripts/trimmed.json", Required: boolPtr(true)},
+						{Source: "narratio.transcript.final_trimmed", Dest: "transcripts/final.trimmed.json", Required: boolPtr(true)},
 						{Source: "narratio.artifact.session_recap", Dest: "artifacts/session_recap.md", Required: boolPtr(true)},
 					},
 				},
--- a/internal/stage/merge.go
+++ b/internal/stage/merge.go
@@ -26,7 +26,7 @@ func (mergeStage) Declares() IODecl {
 			{Kind: "autocorrect", Category: "inputs", RelativePath: "inputs/autocorrect.yml"},
 		},
 		Outputs: []artifacts.Ref{
-			{Kind: "transcript_merged", Category: "transcripts", RelativePath: "transcripts/merged.json"},
+			{Kind: "transcript_base", Category: "transcripts", RelativePath: "transcripts/base.json"},
 			{Kind: "seriatim_report", Category: "artifacts", RelativePath: "artifacts/seriatim.report.json"},
 		},
 	}
@@ -85,7 +85,7 @@ func (mergeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*Sta
 		return nil, fmt.Errorf("merge: %w", err)
 	}

-	canonicalMergedPath := filepath.Join(paths.TranscriptsDir, "merged.json")
+	canonicalMergedPath := filepath.Join(paths.TranscriptsDir, "base.json")
 	mergedPath, err := runLocalPathForCanonical(runLayout, paths, canonicalMergedPath)
 	if err != nil {
 		return nil, fmt.Errorf("merge: resolve run-local merged transcript path: %w", err)
@@ -151,7 +151,7 @@ func (mergeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*Sta
 	}

 	promotedMerged, err := promoteRunLocalOutput(env.ArtifactStore, finalMergedPath, canonicalMergedPath, artifacts.Ref{
-		Kind:      "transcript_merged",
+		Kind:      "transcript_base",
 		Category:  "transcripts",
 		SessionID: sessionID,
 	})
--- a/internal/stage/merge_test.go
+++ b/internal/stage/merge_test.go
@@ -86,8 +86,8 @@ func TestMergeStageMergesRawTranscriptsAndRecordsMetadata(t *testing.T) {
 	if len(result.Outputs) != 2 {
 		t.Fatalf("outputs len = %d, want 2", len(result.Outputs))
 	}
-	if result.Outputs[0].Kind != "transcript_merged" {
-		t.Fatalf("output[0] kind = %q, want transcript_merged", result.Outputs[0].Kind)
+	if result.Outputs[0].Kind != "transcript_base" {
+		t.Fatalf("output[0] kind = %q, want transcript_base", result.Outputs[0].Kind)
 	}
 	if result.Outputs[1].Kind != "seriatim_report" {
 		t.Fatalf("output[1] kind = %q, want seriatim_report", result.Outputs[1].Kind)
--- a/internal/stage/normalize.go
+++ b/internal/stage/normalize.go
@@ -20,10 +20,10 @@ func (normalizeStage) Name() string { return "normalize" }
 func (normalizeStage) Declares() IODecl {
 	return IODecl{
 		Inputs: []artifacts.Ref{
-			{Kind: "transcript_processed", Category: "transcripts", RelativePath: "transcripts/processed.json"},
+			{Kind: "transcript_polished", Category: "transcripts", RelativePath: "transcripts/polished.json"},
 		},
 		Outputs: []artifacts.Ref{
-			{Kind: "transcript_normalized", Category: "transcripts", RelativePath: "transcripts/normalized.json"},
+			{Kind: "transcript_final", Category: "transcripts", RelativePath: "transcripts/final.json"},
 			{Kind: "seriatim_normalize_report", Category: "artifacts", RelativePath: "artifacts/seriatim.normalize.report.json"},
 		},
 	}
@@ -134,7 +134,7 @@ func (normalizeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (
 	}

 	promotedNormalized, err := promoteRunLocalOutput(env.ArtifactStore, finalNormalizedPath, canonicalNormalizedPath, artifacts.Ref{
-		Kind:      "transcript_normalized",
+		Kind:      "transcript_final",
 		Category:  "transcripts",
 		SessionID: sessionID,
 	})
@@ -202,7 +202,7 @@ func normalizeConfigOrDefault(cfg *config.NormalizeConfig) *config.NormalizeConf
 	}
 	report := true
 	return &config.NormalizeConfig{
-		OutputPath:   "transcripts/normalized.json",
+		OutputPath:   "transcripts/final.json",
 		OutputSchema: "seriatim-intermediate",
 		Report:       &report,
 	}
@@ -213,7 +213,7 @@ func discoverNormalizedTranscript(m *manifest.Manifest, paths artifacts.SessionP
 	if m != nil && m.Stages != nil {
 		if sr := m.Stages["normalize"]; sr != nil {
 			for _, out := range sr.Outputs {
-				if out.Kind != "transcript_normalized" {
+				if out.Kind != "transcript_final" {
 					continue
 				}
 				p := strings.TrimSpace(out.LocalPath)
@@ -232,7 +232,7 @@ func discoverNormalizedTranscript(m *manifest.Manifest, paths artifacts.SessionP
 		}
 	}

-	fallback := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	fallback := filepath.Join(paths.TranscriptsDir, "final.json")
 	if info, err := os.Stat(fallback); err == nil && !info.IsDir() {
 		return filepath.Clean(fallback), "fallback.transcripts_dir", nil
 	}
--- a/internal/stage/normalize_test.go
+++ b/internal/stage/normalize_test.go
@@ -19,9 +19,9 @@ func TestNormalizeStageConsumesProcessedTranscriptFromManifest(t *testing.T) {
 	paths := sessionPathsForEnv(env, m.SessionID)
 	manifestProcessed := filepath.Join(paths.ArtifactsDir, "processed.from-manifest.json")
 	writeFile(t, manifestProcessed, `{"segments":[{"id":10}]}`)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":99}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":99}]}`)
 	m.MarkStageSucceeded("polish", time.Now().UTC(), []manifest.ArtifactRecord{{
-		Kind:      "transcript_processed",
+		Kind:      "transcript_polished",
 		LocalPath: manifestProcessed,
 	}})

@@ -44,7 +44,7 @@ func TestNormalizeStageConsumesProcessedTranscriptFromManifest(t *testing.T) {
 func TestNormalizeStageFallsBackToProcessedTranscriptPath(t *testing.T) {
 	env, m, ser := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	fallback := filepath.Join(paths.TranscriptsDir, "processed.json")
+	fallback := filepath.Join(paths.TranscriptsDir, "polished.json")
 	writeFile(t, fallback, `{"segments":[{"id":1}]}`)

 	_, err := (normalizeStage{}).Run(context.Background(), env, m)
@@ -73,7 +73,7 @@ func TestNormalizeStageFailsWhenProcessedTranscriptMissing(t *testing.T) {
 func TestNormalizeStageFailsWhenProcessedTranscriptInvalidJSON(t *testing.T) {
 	env, m, _ := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), "not-json")
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), "not-json")

 	_, err := (normalizeStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -87,7 +87,7 @@ func TestNormalizeStageFailsWhenProcessedTranscriptInvalidJSON(t *testing.T) {
 func TestNormalizeStageFailsWhenProcessedTranscriptMissingSegments(t *testing.T) {
 	env, m, _ := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"schema":"audita.processed.v1"}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"schema":"audita.processed.v1"}`)

 	_, err := (normalizeStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -101,7 +101,7 @@ func TestNormalizeStageFailsWhenProcessedTranscriptMissingSegments(t *testing.T)
 func TestNormalizeStagePassesConfiguredOutputSchemaToAdapter(t *testing.T) {
 	env, m, ser := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)
 	env.Config.Pipeline.Normalize.OutputSchema = "seriatim-full"

 	result, err := (normalizeStage{}).Run(context.Background(), env, m)
@@ -122,24 +122,24 @@ func TestNormalizeStagePassesConfiguredOutputSchemaToAdapter(t *testing.T) {
 func TestNormalizeStageRecordsNormalizedTranscriptOutputKind(t *testing.T) {
 	env, m, _ := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)

 	result, err := (normalizeStage{}).Run(context.Background(), env, m)
 	if err != nil {
 		t.Fatalf("normalize.Run() error = %v", err)
 	}
 	if len(result.Outputs) == 0 {
-		t.Fatalf("outputs = %#v, want at least transcript_normalized", result.Outputs)
+		t.Fatalf("outputs = %#v, want at least transcript_final", result.Outputs)
 	}
-	if result.Outputs[0].Kind != "transcript_normalized" {
-		t.Fatalf("outputs[0].kind = %q, want transcript_normalized", result.Outputs[0].Kind)
+	if result.Outputs[0].Kind != "transcript_final" {
+		t.Fatalf("outputs[0].kind = %q, want transcript_final", result.Outputs[0].Kind)
 	}
 }

 func TestNormalizeStageRecordsReportLogAndGeneratedConfigRefs(t *testing.T) {
 	env, m, _ := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)
 	report := true
 	env.Config.Pipeline.Normalize.Report = &report

@@ -148,7 +148,7 @@ func TestNormalizeStageRecordsReportLogAndGeneratedConfigRefs(t *testing.T) {
 		t.Fatalf("normalize.Run() error = %v", err)
 	}
 	if len(result.Outputs) < 2 {
-		t.Fatalf("outputs = %#v, want transcript_normalized + report", result.Outputs)
+		t.Fatalf("outputs = %#v, want transcript_final + report", result.Outputs)
 	}
 	if result.Outputs[1].Kind != "seriatim_normalize_report" {
 		t.Fatalf("outputs[1].kind = %q, want seriatim_normalize_report", result.Outputs[1].Kind)
@@ -165,7 +165,7 @@ func TestNormalizeStageRecordsReportLogAndGeneratedConfigRefs(t *testing.T) {
 func TestNormalizeStageFailsWhenAdapterReturnsError(t *testing.T) {
 	env, m, ser := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)
 	ser.NormalizeErr = errors.New("normalize failed")

 	_, err := (normalizeStage{}).Run(context.Background(), env, m)
@@ -180,7 +180,7 @@ func TestNormalizeStageFailsWhenAdapterReturnsError(t *testing.T) {
 func TestNormalizeStageFailsWhenNormalizedOutputInvalid(t *testing.T) {
 	env, m, ser := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)
 	badOutput := filepath.Join(paths.TranscriptsDir, "normalized.bad.json")
 	writeFile(t, badOutput, "not-json")
 	ser.NormalizeResult = seriatim.NormalizeResult{OutputNormalizedPath: badOutput}
@@ -197,7 +197,7 @@ func TestNormalizeStageFailsWhenNormalizedOutputInvalid(t *testing.T) {
 func TestNormalizeStageReportEnabledFailsWhenReportMissing(t *testing.T) {
 	env, m, ser := setupNormalizeEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)
 	report := true
 	env.Config.Pipeline.Normalize.Report = &report
 	ser.NormalizeResult = seriatim.NormalizeResult{ReportPath: filepath.Join(paths.ArtifactsDir, "missing-report.json")}
@@ -217,7 +217,7 @@ func TestNormalizeStageUsesRunLocalPathsAndPromotesCanonical(t *testing.T) {
 	m.Campaign = "sample-campaign"
 	m.RunID = "20260518T010203Z-abcdef12"
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1}]}`)

 	result, err := (normalizeStage{}).Run(context.Background(), env, m)
 	if err != nil {
@@ -261,7 +261,7 @@ func setupNormalizeEnv(t *testing.T) (*Env, *manifest.Manifest, *seriatim.FakeRu
 				Report:       &report,
 			},
 			Normalize: &config.NormalizeConfig{
-				OutputPath:   "transcripts/normalized.json",
+				OutputPath:   "transcripts/final.json",
 				OutputSchema: "seriatim-intermediate",
 				Report:       &report,
 			},
--- a/internal/stage/placeholders_test.go
+++ b/internal/stage/placeholders_test.go
@@ -163,8 +163,8 @@ func TestStagesReturnExpectedMetadata(t *testing.T) {
 			if result.Metadata["output_schema"] == nil {
 				t.Fatalf("normalize metadata = %#v, want output_schema metadata", result.Metadata)
 			}
-			if len(result.Outputs) == 0 || result.Outputs[0].Kind != "transcript_normalized" {
-				t.Fatalf("normalize outputs = %#v, want transcript_normalized output", result.Outputs)
+			if len(result.Outputs) == 0 || result.Outputs[0].Kind != "transcript_final" {
+				t.Fatalf("normalize outputs = %#v, want transcript_final output", result.Outputs)
 			}
 			if len(result.Logs) != 2 {
 				t.Fatalf("normalize logs = %#v, want stdout+stderr", result.Logs)
@@ -190,8 +190,8 @@ func TestStagesReturnExpectedMetadata(t *testing.T) {
 			if result.Metadata["trim_action"] != "copy_disabled" {
 				t.Fatalf("trim metadata = %#v, want trim_action=copy_disabled", result.Metadata)
 			}
-			if len(result.Outputs) == 0 || result.Outputs[0].Kind != "transcript_trimmed" {
-				t.Fatalf("trim outputs = %#v, want transcript_trimmed output", result.Outputs)
+			if len(result.Outputs) == 0 || result.Outputs[0].Kind != "transcript_final_trimmed" {
+				t.Fatalf("trim outputs = %#v, want transcript_final_trimmed output", result.Outputs)
 			}
 			continue
 		}
--- a/internal/stage/polish.go
+++ b/internal/stage/polish.go
@@ -20,11 +20,11 @@ func (polishStage) Name() string { return "polish" }
 func (polishStage) Declares() IODecl {
 	return IODecl{
 		Inputs: []artifacts.Ref{
-			{Kind: "transcript_merged", Category: "transcripts", RelativePath: "transcripts/merged.json"},
+			{Kind: "transcript_base", Category: "transcripts", RelativePath: "transcripts/base.json"},
 			{Kind: "glossary", Category: "inputs", RelativePath: "inputs/glossary.yml"},
 		},
 		Outputs: []artifacts.Ref{
-			{Kind: "transcript_processed", Category: "transcripts", RelativePath: "transcripts/processed.json"},
+			{Kind: "transcript_polished", Category: "transcripts", RelativePath: "transcripts/polished.json"},
 			{Kind: "audita_report", Category: "artifacts", RelativePath: "artifacts/audita.report.json"},
 		},
 	}
@@ -76,7 +76,7 @@ func (polishStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*St
 		return nil, fmt.Errorf("polish: %w", err)
 	}

-	canonicalProcessedPath := filepath.Join(paths.TranscriptsDir, "processed.json")
+	canonicalProcessedPath := filepath.Join(paths.TranscriptsDir, "polished.json")
 	processedPath, err := runLocalPathForCanonical(runLayout, paths, canonicalProcessedPath)
 	if err != nil {
 		return nil, fmt.Errorf("polish: resolve run-local processed transcript path: %w", err)
@@ -150,7 +150,7 @@ func (polishStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*St
 	}

 	promotedProcessed, err := promoteRunLocalOutput(env.ArtifactStore, finalProcessedPath, canonicalProcessedPath, artifacts.Ref{
-		Kind:      "transcript_processed",
+		Kind:      "transcript_polished",
 		Category:  "transcripts",
 		SessionID: sessionID,
 	})
@@ -250,7 +250,7 @@ func discoverMergedTranscript(m *manifest.Manifest, paths artifacts.SessionPaths
 	if m != nil && m.Stages != nil {
 		if sr := m.Stages["merge"]; sr != nil {
 			for _, out := range sr.Outputs {
-				if out.Kind != "transcript_merged" {
+				if out.Kind != "transcript_base" {
 					continue
 				}
 				p := strings.TrimSpace(out.LocalPath)
@@ -270,7 +270,7 @@ func discoverMergedTranscript(m *manifest.Manifest, paths artifacts.SessionPaths
 		}
 	}

-	fallback := filepath.Join(paths.TranscriptsDir, "merged.json")
+	fallback := filepath.Join(paths.TranscriptsDir, "base.json")
 	if info, err := os.Stat(fallback); err == nil && !info.IsDir() {
 		return filepath.Clean(fallback), "fallback.transcripts_dir", nil
 	}
--- a/internal/stage/polish_test.go
+++ b/internal/stage/polish_test.go
@@ -18,11 +18,11 @@ func TestPolishStagePolishesMergedTranscriptAndRecordsMetadata(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)

-	mergedPath := filepath.Join(paths.TranscriptsDir, "merged.json")
+	mergedPath := filepath.Join(paths.TranscriptsDir, "base.json")
 	writeFile(t, mergedPath, `{"segments":[]}`)
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")
 	m.MarkStageSucceeded("merge", time.Now().UTC(), []manifest.ArtifactRecord{
-		{Kind: "transcript_merged", LocalPath: mergedPath},
+		{Kind: "transcript_base", LocalPath: mergedPath},
 	})

 	fake := &audita.FakeRunner{}
@@ -85,8 +85,8 @@ func TestPolishStagePolishesMergedTranscriptAndRecordsMetadata(t *testing.T) {
 	if len(result.Outputs) != 2 {
 		t.Fatalf("outputs len = %d, want 2", len(result.Outputs))
 	}
-	if result.Outputs[0].Kind != "transcript_processed" {
-		t.Fatalf("output[0] kind = %q, want transcript_processed", result.Outputs[0].Kind)
+	if result.Outputs[0].Kind != "transcript_polished" {
+		t.Fatalf("output[0] kind = %q, want transcript_polished", result.Outputs[0].Kind)
 	}
 	if result.Outputs[1].Kind != "audita_report" {
 		t.Fatalf("output[1] kind = %q, want audita_report", result.Outputs[1].Kind)
@@ -121,7 +121,7 @@ func TestPolishStagePolishesMergedTranscriptAndRecordsMetadata(t *testing.T) {
 func TestPolishStageFallsBackToMergedTranscriptPath(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	mergedPath := filepath.Join(paths.TranscriptsDir, "merged.json")
+	mergedPath := filepath.Join(paths.TranscriptsDir, "base.json")
 	writeFile(t, mergedPath, `{"segments":[]}`)
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")

@@ -158,7 +158,7 @@ func TestPolishStageFailsWhenMergedTranscriptMissing(t *testing.T) {
 func TestPolishStageFailsWhenMergedTranscriptInvalidJSON(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "merged.json"), "not-json")
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "base.json"), "not-json")
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")
 	env.Audita = &audita.FakeRunner{}

@@ -174,7 +174,7 @@ func TestPolishStageFailsWhenMergedTranscriptInvalidJSON(t *testing.T) {
 func TestPolishStageFailsWhenGlossaryMissing(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "merged.json"), `{"segments":[]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "base.json"), `{"segments":[]}`)
 	env.Audita = &audita.FakeRunner{}

 	_, err := (polishStage{}).Run(context.Background(), env, m)
@@ -189,7 +189,7 @@ func TestPolishStageFailsWhenGlossaryMissing(t *testing.T) {
 func TestPolishStageFailsWhenAdapterFails(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "merged.json"), `{"segments":[]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "base.json"), `{"segments":[]}`)
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")
 	env.Audita = &audita.FakeRunner{Err: errors.New("audita failed")}

@@ -205,7 +205,7 @@ func TestPolishStageFailsWhenAdapterFails(t *testing.T) {
 func TestPolishStageFailsWhenProcessedOutputInvalid(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "merged.json"), `{"segments":[]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "base.json"), `{"segments":[]}`)
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")
 	badPath := filepath.Join(paths.TranscriptsDir, "processed.invalid.json")
 	writeFile(t, badPath, `{"schema":"audita.processed.v1","segments":"wrong-type"}`)
@@ -223,7 +223,7 @@ func TestPolishStageFailsWhenProcessedOutputInvalid(t *testing.T) {
 func TestPolishStageFailsWhenReportInvalid(t *testing.T) {
 	env, m := setupPolishEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "merged.json"), `{"segments":[]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "base.json"), `{"segments":[]}`)
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")
 	badReport := filepath.Join(paths.ArtifactsDir, "bad.report.json")
 	writeFile(t, badReport, "not-json")
@@ -244,7 +244,7 @@ func TestPolishStageUsesRunLocalPathsAndPromotesCanonical(t *testing.T) {
 	m.Campaign = "sample-campaign"
 	m.RunID = "20260518T010203Z-abcdef12"
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "merged.json"), `{"segments":[]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "base.json"), `{"segments":[]}`)
 	writeFile(t, filepath.Join(paths.InputsDir, "glossary.yml"), "terms: []\n")

 	fake := &audita.FakeRunner{}
--- a/internal/stage/run_local_test.go
+++ b/internal/stage/run_local_test.go
@@ -19,13 +19,13 @@ func TestRunLocalPathForCanonicalCreatesParentDirectories(t *testing.T) {
 		t.Fatalf("mkdir outputs dir: %v", err)
 	}

-	canonical := filepath.Join(sessionRoot, "transcripts", "merged.json")
+	canonical := filepath.Join(sessionRoot, "transcripts", "base.json")
 	got, err := runLocalPathForCanonical(layout, artifacts.SessionPaths{Root: sessionRoot}, canonical)
 	if err != nil {
 		t.Fatalf("runLocalPathForCanonical() error = %v", err)
 	}

-	want := filepath.Join(layout.OutputsDir, "transcripts", "merged.json")
+	want := filepath.Join(layout.OutputsDir, "transcripts", "base.json")
 	if got != want {
 		t.Fatalf("runLocalPathForCanonical() = %q, want %q", got, want)
 	}
--- a/internal/stage/trim.go
+++ b/internal/stage/trim.go
@@ -23,10 +23,10 @@ func (trimStage) Name() string { return "trim" }
 func (trimStage) Declares() IODecl {
 	return IODecl{
 		Inputs: []artifacts.Ref{
-			{Kind: "transcript_normalized", Category: "transcripts", RelativePath: "transcripts/normalized.json"},
+			{Kind: "transcript_final", Category: "transcripts", RelativePath: "transcripts/final.json"},
 		},
 		Outputs: []artifacts.Ref{
-			{Kind: "transcript_trimmed", Category: "transcripts", RelativePath: "transcripts/trimmed.json"},
+			{Kind: "transcript_final_trimmed", Category: "transcripts", RelativePath: "transcripts/final.trimmed.json"},
 			{Kind: "session_bounds", Category: "artifacts", RelativePath: "artifacts/session_bounds.json"},
 		},
 	}
@@ -101,7 +101,7 @@ func (trimStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*Stag
 			return nil, fmt.Errorf("trim: copied trimmed transcript %q invalid: %w", trimmedPath, err)
 		}
 		promotedTrimmed, err := promoteRunLocalOutput(env.ArtifactStore, trimmedPath, canonicalTrimmedPath, artifacts.Ref{
-			Kind:      "transcript_trimmed",
+			Kind:      "transcript_final_trimmed",
 			Category:  "transcripts",
 			SessionID: sessionID,
 		})
@@ -352,7 +352,7 @@ func (trimStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*Stag
 	}

 	promotedTrimmed, err := promoteRunLocalOutput(env.ArtifactStore, trimmedPath, canonicalTrimmedPath, artifacts.Ref{
-		Kind:      "transcript_trimmed",
+		Kind:      "transcript_final_trimmed",
 		Category:  "transcripts",
 		SessionID: sessionID,
 	})
@@ -382,7 +382,7 @@ func resolveTrimmedOutputPath(paths artifacts.SessionPaths, cfg *config.TrimConf
 		configured = strings.TrimSpace(cfg.OutputPath)
 	}
 	if configured == "" {
-		return filepath.Join(paths.TranscriptsDir, "trimmed.json"), nil
+		return filepath.Join(paths.TranscriptsDir, "final.trimmed.json"), nil
 	}
 	return resolveScriptoriumOutputPath(paths, configured)
 }
--- a/internal/stage/trim_test.go
+++ b/internal/stage/trim_test.go
@@ -19,10 +19,10 @@ import (
 func TestTrimStageConsumesNormalizedAndProducesTrimmedTranscript(t *testing.T) {
 	env, m, scr, ser := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	normalized := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	normalized := filepath.Join(paths.TranscriptsDir, "final.json")
 	writeFile(t, normalized, `{"segments":[{"id":10},{"id":868}]}`)
 	m.MarkStageSucceeded("normalize", time.Now().UTC(), []manifest.ArtifactRecord{
-		{Kind: "transcript_normalized", LocalPath: normalized},
+		{Kind: "transcript_final", LocalPath: normalized},
 	})
 	scr.BoundsBody = `{"confidence":"high","trim_action":"trim","start_segment_id":10,"end_segment_id":868,"warnings":[]}`

@@ -44,7 +44,7 @@ func TestTrimStageConsumesNormalizedAndProducesTrimmedTranscript(t *testing.T) {
 	if trimReq.KeepSelector != "10-868" {
 		t.Fatalf("keep selector = %q, want %q", trimReq.KeepSelector, "10-868")
 	}
-	if trimReq.OutputTrimmedPath != filepath.Join(paths.TranscriptsDir, "trimmed.json") {
+	if trimReq.OutputTrimmedPath != filepath.Join(paths.TranscriptsDir, "final.trimmed.json") {
 		t.Fatalf("trim output = %q", trimReq.OutputTrimmedPath)
 	}

@@ -54,13 +54,13 @@ func TestTrimStageConsumesNormalizedAndProducesTrimmedTranscript(t *testing.T) {
 	if len(result.Outputs) < 2 {
 		t.Fatalf("outputs = %#v, want trimmed+bounds outputs", result.Outputs)
 	}
-	if result.Outputs[0].Kind != "transcript_trimmed" {
-		t.Fatalf("output[0] kind = %q, want transcript_trimmed", result.Outputs[0].Kind)
+	if result.Outputs[0].Kind != "transcript_final_trimmed" {
+		t.Fatalf("output[0] kind = %q, want transcript_final_trimmed", result.Outputs[0].Kind)
 	}
 	if result.Outputs[1].Kind != "session_bounds" {
 		t.Fatalf("output[1] kind = %q, want session_bounds", result.Outputs[1].Kind)
 	}
-	if result.Metadata["trimmed_output_path"] != filepath.Join(paths.TranscriptsDir, "trimmed.json") {
+	if result.Metadata["trimmed_output_path"] != filepath.Join(paths.TranscriptsDir, "final.trimmed.json") {
 		t.Fatalf("metadata trimmed_output_path = %#v", result.Metadata["trimmed_output_path"])
 	}
 	if result.Metadata["keep_selector"] != "10-868" {
@@ -71,7 +71,7 @@ func TestTrimStageConsumesNormalizedAndProducesTrimmedTranscript(t *testing.T) {
 func TestTrimStageUsesConfiguredScriptoriumInputName(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	normalized := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	normalized := filepath.Join(paths.TranscriptsDir, "final.json")
 	writeFile(t, normalized, `{"segments":[{"id":10},{"id":11}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":10,"end_segment_id":11}`

@@ -95,7 +95,7 @@ func TestTrimStageUsesConfiguredScriptoriumInputName(t *testing.T) {
 func TestTrimStageRecordsLogAndGeneratedConfigRefs(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":1},{"id":2}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":1,"end_segment_id":2}`

 	result, err := (trimStage{}).Run(context.Background(), env, m)
@@ -115,7 +115,7 @@ func TestTrimStageRecordsLogAndGeneratedConfigRefs(t *testing.T) {
 func TestTrimStageRenderDebugDiagnosticsAreNotStageOutputs(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":1},{"id":2}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":1,"end_segment_id":2}`

 	cfg := *env.Config.Pipeline.Trim
@@ -153,7 +153,7 @@ func TestTrimStageFailsWhenNormalizedTranscriptMissing(t *testing.T) {
 func TestTrimStageDoesNotFallBackToProcessedTranscript(t *testing.T) {
 	env, m, scr, ser := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "processed.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "polished.json"), `{"segments":[{"id":1},{"id":2}]}`)

 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -173,7 +173,7 @@ func TestTrimStageDoesNotFallBackToProcessedTranscript(t *testing.T) {
 func TestTrimStageFailsWhenNormalizedTranscriptInvalidJSON(t *testing.T) {
 	env, m, _, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), "not-json")
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), "not-json")
 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
 		t.Fatal("expected error, got nil")
@@ -186,7 +186,7 @@ func TestTrimStageFailsWhenNormalizedTranscriptInvalidJSON(t *testing.T) {
 func TestTrimStageFailsWhenNormalizedTranscriptMissingSegmentsArray(t *testing.T) {
 	env, m, _, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"schema":"audita.processed.v1"}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"schema":"audita.processed.v1"}`)
 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
 		t.Fatal("expected error, got nil")
@@ -199,7 +199,7 @@ func TestTrimStageFailsWhenNormalizedTranscriptMissingSegmentsArray(t *testing.T
 func TestTrimStageFailsWhenBoundsOutputInvalidJSON(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":1},{"id":2}]}`)
 	scr.BoundsBody = "not-json"
 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -213,7 +213,7 @@ func TestTrimStageFailsWhenBoundsOutputInvalidJSON(t *testing.T) {
 func TestTrimStageFailsWhenBoundsRangeIsDescending(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":1},{"id":2}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":2,"end_segment_id":1}`
 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -227,7 +227,7 @@ func TestTrimStageFailsWhenBoundsRangeIsDescending(t *testing.T) {
 func TestTrimStageFailsWhenBoundsIDsMissingFromTranscript(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":20},{"id":21}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":20},{"id":21}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":10,"end_segment_id":21}`
 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -241,7 +241,7 @@ func TestTrimStageFailsWhenBoundsIDsMissingFromTranscript(t *testing.T) {
 func TestTrimStageFailsWhenScriptoriumAdapterFails(t *testing.T) {
 	env, m, scr, _ := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":1},{"id":2}]}`)
 	scr.RunErr = errors.New("bounds failed")
 	_, err := (trimStage{}).Run(context.Background(), env, m)
 	if err == nil {
@@ -255,7 +255,7 @@ func TestTrimStageFailsWhenScriptoriumAdapterFails(t *testing.T) {
 func TestTrimStageFailsWhenSeriatimTrimAdapterFails(t *testing.T) {
 	env, m, scr, ser := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	writeFile(t, filepath.Join(paths.TranscriptsDir, "normalized.json"), `{"segments":[{"id":1},{"id":2}]}`)
+	writeFile(t, filepath.Join(paths.TranscriptsDir, "final.json"), `{"segments":[{"id":1},{"id":2}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":1,"end_segment_id":2}`
 	ser.TrimErr = errors.New("trim failed")
 	_, err := (trimStage{}).Run(context.Background(), env, m)
@@ -270,7 +270,7 @@ func TestTrimStageFailsWhenSeriatimTrimAdapterFails(t *testing.T) {
 func TestTrimStageDisabledCopiesNormalizedTranscript(t *testing.T) {
 	env, m, scr, ser := setupTrimEnv(t)
 	paths := sessionPathsForEnv(env, m.SessionID)
-	normalized := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	normalized := filepath.Join(paths.TranscriptsDir, "final.json")
 	normalizedBody := `{"segments":[{"id":1,"text":"alpha"},{"id":2,"text":"beta"}]}`
 	writeFile(t, normalized, normalizedBody)

@@ -288,7 +288,7 @@ func TestTrimStageDisabledCopiesNormalizedTranscript(t *testing.T) {
 	if result.Metadata["trim_action"] != "copy_disabled" {
 		t.Fatalf("metadata trim_action = %#v, want copy_disabled", result.Metadata["trim_action"])
 	}
-	trimmedPath := filepath.Join(paths.TranscriptsDir, "trimmed.json")
+	trimmedPath := filepath.Join(paths.TranscriptsDir, "final.trimmed.json")
 	data, err := os.ReadFile(trimmedPath)
 	if err != nil {
 		t.Fatalf("read trimmed transcript: %v", err)
@@ -304,7 +304,7 @@ func TestTrimStageUsesRunLocalPathsAndPromotesCanonical(t *testing.T) {
 	m.Campaign = "sample-campaign"
 	m.RunID = "20260518T010203Z-abcdef12"
 	paths := sessionPathsForEnv(env, m.SessionID)
-	normalized := filepath.Join(paths.TranscriptsDir, "normalized.json")
+	normalized := filepath.Join(paths.TranscriptsDir, "final.json")
 	writeFile(t, normalized, `{"segments":[{"id":10},{"id":11}]}`)
 	scr.BoundsBody = `{"trim_action":"trim","start_segment_id":10,"end_segment_id":11,"warnings":[]}`

@@ -438,7 +438,7 @@ func setupTrimEnv(t *testing.T) (*Env, *manifest.Manifest, *boundsScriptoriumRun
 			},
 			Trim: &config.TrimConfig{
 				Enabled:    true,
-				OutputPath: "transcripts/trimmed.json",
+				OutputPath: "transcripts/final.trimmed.json",
 				Bounds: config.TrimBoundsConfig{
 					PromptID:            "dnd_session.bounds",
 					ProfileID:           "",