Use trimmed transcript for session recap

internal/stage/analyze.go

@@ -24,6 +24,7 @@ func (analyzeStage) Declares() IODecl {
 	return IODecl{
 		Inputs: []artifacts.Ref{
 			{Kind: "transcript_processed", Category: "transcripts", RelativePath: "transcripts/processed.json"},
+			{Kind: "transcript_trimmed", Category: "transcripts", RelativePath: "transcripts/trimmed.json"},
 		},
 		Outputs: []artifacts.Ref{
 			{Kind: "session_recap", Category: "artifacts", RelativePath: "artifacts/session_recap.md"},
@@ -85,11 +86,16 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S
 	if err != nil {
 		return nil, fmt.Errorf("analyze: resolve processed transcript: %w", err)
 	}
-	if processedTranscriptPath == "" {
-		return nil, fmt.Errorf("analyze: processed transcript input is required")
+	trimmedTranscriptPath, trimmedSource, err := discoverTrimmedTranscript(m, paths)
+	if err != nil {
+		return nil, fmt.Errorf("analyze: resolve trimmed transcript: %w", err)
 	}
-	if err := validateProcessedTranscriptOutput(processedTranscriptPath); err != nil {
-		return nil, fmt.Errorf("analyze: processed transcript %q invalid: %w", processedTranscriptPath, err)
+
+	transcriptInputs := analyzeTranscriptInputs{
+		ProcessedPath:   processedTranscriptPath,
+		ProcessedSource: processedSource,
+		TrimmedPath:     trimmedTranscriptPath,
+		TrimmedSource:   trimmedSource,
 	}
 
 	inputPaths := map[string]string{}
@@ -98,7 +104,7 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S
 	inputNames := sortedScriptoriumInputNames(artifactCfg.Inputs)
 	for _, inputName := range inputNames {
 		inputCfg := artifactCfg.Inputs[inputName]
-		resolvedPath, resolved, resolveErr := resolveScriptoriumInput(inputName, inputCfg, processedTranscriptPath, paths, sessionDir)
+		resolvedPath, resolved, resolveErr := resolveScriptoriumInput(inputName, inputCfg, transcriptInputs, paths, sessionDir)
 		if resolveErr != nil {
 			return nil, fmt.Errorf("analyze: resolve input %q: %w", inputName, resolveErr)
 		}
@@ -146,6 +152,8 @@ func (analyzeStage) Run(ctx context.Context, env *Env, m *manifest.Manifest) (*S
 		"timeout":                     timeout.String(),
 		"processed_transcript_path":   processedTranscriptPath,
 		"processed_transcript_source": processedSource,
+		"trimmed_transcript_path":     trimmedTranscriptPath,
+		"trimmed_transcript_source":   trimmedSource,
 		"render_debug_enabled":        resolveRenderDebugEnabled(env.Config.Pipeline.Scriptorium.RenderDebug, artifactCfg.RenderDebug),
 	}
 
@@ -333,16 +341,71 @@ func discoverProcessedTranscript(m *manifest.Manifest, paths artifacts.SessionPa
 	return "", "", nil
 }
 
+func discoverTrimmedTranscript(m *manifest.Manifest, paths artifacts.SessionPaths) (string, string, error) {
+	candidates := []string{}
+	if m != nil && m.Stages != nil {
+		if sr := m.Stages["trim"]; sr != nil {
+			for _, out := range sr.Outputs {
+				if out.Kind != "transcript_trimmed" {
+					continue
+				}
+				p := strings.TrimSpace(out.LocalPath)
+				if p == "" {
+					continue
+				}
+				resolved := artifacts.ResolveSessionLocalPathForRead(paths, p)
+				candidates = append(candidates, filepath.Clean(resolved))
+			}
+		}
+	}
+	deduped := dedupeAndSortPaths(candidates)
+	for _, p := range deduped {
+		if info, err := os.Stat(p); err == nil && !info.IsDir() {
+			return p, "manifest.trim.outputs", nil
+		}
+	}
+
+	fallback := filepath.Join(paths.TranscriptsDir, "trimmed.json")
+	if info, err := os.Stat(fallback); err == nil && !info.IsDir() {
+		return filepath.Clean(fallback), "fallback.transcripts_dir", nil
+	}
+	if len(deduped) > 0 {
+		return deduped[0], "manifest.trim.outputs", nil
+	}
+	return "", "", nil
+}
+
+type analyzeTranscriptInputs struct {
+	ProcessedPath   string
+	ProcessedSource string
+	TrimmedPath     string
+	TrimmedSource   string
+}
+
 func resolveScriptoriumInput(
 	inputName string,
 	inputCfg config.ScriptoriumInputConfig,
-	processedTranscriptPath string,
+	transcriptInputs analyzeTranscriptInputs,
 	paths artifacts.SessionPaths,
 	sessionDir string,
 ) (string, bool, error) {
 	switch strings.TrimSpace(inputCfg.Source) {
 	case "processed_transcript":
-		return processedTranscriptPath, true, nil
+		if strings.TrimSpace(transcriptInputs.ProcessedPath) == "" {
+			return "", false, nil
+		}
+		if err := validateProcessedTranscriptOutput(transcriptInputs.ProcessedPath); err != nil {
+			return "", false, fmt.Errorf("processed transcript %q invalid: %w", transcriptInputs.ProcessedPath, err)
+		}
+		return transcriptInputs.ProcessedPath, true, nil
+	case "trimmed_transcript":
+		if strings.TrimSpace(transcriptInputs.TrimmedPath) == "" {
+			return "", false, fmt.Errorf("trimmed transcript input is unavailable; run trim stage first")
+		}
+		if err := validateProcessedTranscriptOutput(transcriptInputs.TrimmedPath); err != nil {
+			return "", false, fmt.Errorf("trimmed transcript %q invalid: %w", transcriptInputs.TrimmedPath, err)
+		}
+		return transcriptInputs.TrimmedPath, true, nil
 	case "previous_session_artifact":
 		if strings.TrimSpace(inputCfg.Path) == "" {
 			return "", false, nil