Make runner persistence session-only

internal/app/runner.go

@@ -17,6 +17,7 @@ import (
 	"gitea.maximumdirect.net/eric/narratio/internal/artifactmodel"
 	"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
 	"gitea.maximumdirect.net/eric/narratio/internal/config"
+	"gitea.maximumdirect.net/eric/narratio/internal/fileops"
 	"gitea.maximumdirect.net/eric/narratio/internal/logging"
 	"gitea.maximumdirect.net/eric/narratio/internal/manifest"
 	"gitea.maximumdirect.net/eric/narratio/internal/stage"
@@ -27,17 +28,15 @@ type RunOptions struct {
 	SelectedArtifacts  []string
 	EffectiveArtifacts artifacts.EffectiveArtifactSet
 	Env                *Env
-	RunManifestStore   manifest.RunStore
 }
 
 type RunSummary struct {
-	SessionID       string
-	RunID           string
-	ManifestPath    string
-	RunManifestPath string
-	StageNames      []string
-	Executed        []string
-	Skipped         []string
+	SessionID    string
+	RunID        string
+	ManifestPath string
+	StageNames   []string
+	Executed     []string
+	Skipped      []string
 }
 
 var executeStagesFn = executePlan
@@ -151,46 +150,23 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 	if err := env.ManifestStore.Save(ctx, manifestPath, m); err != nil {
 		return nil, fmt.Errorf("save manifest identity %q: %w", manifestPath, err)
 	}
-	runManifestPath := artifacts.SessionRunManifestPathForCampaign(
-		cfg.Pipeline.Workspace.Root,
-		identity.Campaign,
-		identity.SessionID,
-		identity.RunID,
-	)
-	runManifestStore := opts.RunManifestStore
-	if runManifestStore == nil {
-		runManifestStore = &manifest.LocalStore{}
-	}
-	runManifest, err := runManifestStore.CreateRun(
-		ctx,
-		identity.SessionID,
-		identity.Campaign,
-		identity.RunID,
-		opts.Force,
-		requestedStageNames(stages),
-	)
-	if err != nil {
-		return nil, fmt.Errorf("create run manifest: %w", err)
-	}
-	identity.applyToRunManifest(runManifest, manifestPath)
-	applyEffectiveConfigProvenanceToRun(runManifest, cfg)
-	if err := runManifestStore.SaveRun(ctx, runManifestPath, runManifest); err != nil {
-		return nil, persistTerminalFailure(
-			ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
-			fmt.Errorf("save initial run manifest %q: %w", runManifestPath, err),
+	if err := fileops.EnsureWorkspaceDirectory(identity.LocalWorkDir); err != nil {
+		return nil, persistSessionTerminalFailure(
+			ctx, env.ManifestStore, manifestPath, m,
+			fmt.Errorf("create run directory %q: %w", identity.LocalWorkDir, err),
 		)
 	}
 	if _, err := loadSecretsFromConfig(env.Config, env.Logger); err != nil {
-		return nil, persistTerminalFailure(
-			ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+		return nil, persistSessionTerminalFailure(
+			ctx, env.ManifestStore, manifestPath, m,
 			fmt.Errorf("load secrets from files: %w", err),
 		)
 	}
 	if env.WhisperX == nil && stagesContainAny(stages, "transcribe") {
 		client, err := buildDefaultWhisperXClient(env.Config)
 		if err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				fmt.Errorf("initialize whisperx client: %w", err),
 			)
 		}
@@ -199,8 +175,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 	if env.Seriatim == nil && stagesContainAny(stages, "merge", "normalize", "trim", "render") {
 		runner, err := buildDefaultSeriatimRunner(env.Config)
 		if err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				fmt.Errorf("initialize seriatim runner: %w", err),
 			)
 		}
@@ -209,8 +185,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 	if env.Audita == nil && stagesContainAny(stages, "polish") {
 		runner, err := buildDefaultAuditaRunner(env.Config)
 		if err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				fmt.Errorf("initialize audita runner: %w", err),
 			)
 		}
@@ -225,8 +201,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 	if env.ObjectStore == nil && needsObjectStoreForRun(env.Config, stages, effectiveArtifacts) {
 		objectStore, err := newCommandObjectStore(ctx, env.Config, nil)
 		if err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest, err,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m, err,
 			)
 		}
 		env.ObjectStore = objectStore
@@ -234,8 +210,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 	if needsRemoteLocksForRun(env.Config, stages) {
 		locks, err := loadEffectiveLocks(ctx, env.Config, env.ObjectStore)
 		if err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				fmt.Errorf("load remote publish locks: %w", err),
 			)
 		}
@@ -263,8 +239,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 		runNames = append(runNames, s.Name())
 		semanticConfig, err := currentStageSemanticConfig(s, stageEnv)
 		if err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				fmt.Errorf("fingerprint semantic configuration for stage %q: %w", s.Name(), err),
 			)
 		}
@@ -273,8 +249,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 		if action == stageActionSkip {
 			validation, err := evaluateStageResume(ctx, s, stageEnv, m, semanticConfig)
 			if err != nil {
-				return nil, persistTerminalFailure(
-					ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+				return nil, persistSessionTerminalFailure(
+					ctx, env.ManifestStore, manifestPath, m,
 					fmt.Errorf("validate resume for stage %q: %w", s.Name(), err),
 				)
 			}
@@ -284,14 +260,14 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 				if _, err := invalidateDependentSucceededStagesWithReason(
 					m, s.Name(), staleAt, staleReasonNotResumable,
 				); err != nil {
-					return nil, persistTerminalFailure(
-						ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+					return nil, persistSessionTerminalFailure(
+						ctx, env.ManifestStore, manifestPath, m,
 						fmt.Errorf("invalidate dependents after resume validation for stage %q: %w", s.Name(), err),
 					)
 				}
 				if err := env.ManifestStore.Save(ctx, manifestPath, m); err != nil {
-					return nil, persistTerminalFailure(
-						ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+					return nil, persistSessionTerminalFailure(
+						ctx, env.ManifestStore, manifestPath, m,
 						fmt.Errorf("save manifest after resume validation for stage %q: %w", s.Name(), err),
 					)
 				}
@@ -302,16 +278,6 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 
 		if action == stageActionSkip {
 			skipped = append(skipped, s.Name())
-			skipAt := nowUTC()
-			runManifest.SetStageAction(s.Name(), manifest.RunStageActionSkip, skipAt)
-			runManifest.MarkStageSkipped(s.Name(), skipAt, "already_succeeded")
-			setRunStageSemanticConfig(runManifest, s.Name(), semanticConfig)
-			if err := runManifestStore.SaveRun(ctx, runManifestPath, runManifest); err != nil {
-				return nil, persistTerminalFailure(
-					ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
-					fmt.Errorf("save run manifest after skip %q: %w", s.Name(), err),
-				)
-			}
 			env.Logger.Info("skipping stage", "stage", s.Name(), "reason", "already_succeeded", "force", opts.Force)
 			continue
 		}
@@ -320,20 +286,11 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 		priorAnalyzeState := captureAnalyzeState(m, s.Name())
 
 		now := nowUTC()
-		runManifest.SetStageAction(s.Name(), manifest.RunStageActionRun, now)
-		runManifest.MarkStageRunning(s.Name(), now)
-		if err := runManifestStore.SaveRun(ctx, runManifestPath, runManifest); err != nil {
-			operationErr := fmt.Errorf("save run manifest before stage %q: %w", s.Name(), err)
-			runManifest.MarkStageFailed(s.Name(), nowUTC(), operationErr.Error())
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest, operationErr,
-			)
-		}
 		m.MarkStageRunning(s.Name(), now)
 		if opts.Force {
 			if _, err := invalidateDependentSucceededStagesWithReason(m, s.Name(), now, staleReasonForcedReplacement); err != nil {
-				return nil, persistTerminalFailure(
-					ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+				return nil, persistSessionTerminalFailure(
+					ctx, env.ManifestStore, manifestPath, m,
 					fmt.Errorf("invalidate dependents before forced stage %q: %w", s.Name(), err),
 				)
 			}
@@ -345,8 +302,8 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 			if _, invalidationErr := invalidateDependentSucceededStagesWithReason(m, s.Name(), nowUTC(), staleReasonFailure); invalidationErr != nil {
 				operationErr = errors.Join(operationErr, fmt.Errorf("invalidate dependents after stage %q persistence failure: %w", s.Name(), invalidationErr))
 			}
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest, operationErr,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m, operationErr,
 			)
 		}
 		env.Logger.Debug("manifest saved", "stage", s.Name(), "transition", "running", "path", manifestPath)
@@ -367,18 +324,16 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 		}
 		if err != nil {
 			if analyzeProjection != nil {
-				applyAnalyzeProjection(m, runManifest, analyzeProjection)
+				applyAnalyzeProjection(m, analyzeProjection)
 			}
 			failedAt := nowUTC()
 			m.MarkStageFailed(s.Name(), failedAt, err.Error())
 			if _, invalidationErr := invalidateDependentSucceededStagesWithReason(m, s.Name(), failedAt, staleReasonFailure); invalidationErr != nil {
 				err = errors.Join(err, fmt.Errorf("invalidate dependents after stage %q failure: %w", s.Name(), invalidationErr))
 			}
-			runManifest.MarkStageFailed(s.Name(), failedAt, err.Error())
-			identity.applyToRunManifest(runManifest, manifestPath)
 			env.Logger.Info("stage failed", "stage", s.Name(), "error", err)
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				fmt.Errorf("stage %q failed: %w", s.Name(), err),
 			)
 		}
@@ -390,48 +345,36 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 			setSessionStageSemanticConfig(m, s.Name(), semanticConfig)
 			if !priorOutcome.isSameSelfSkip(result.SkipReason) {
 				if _, err := invalidateDependentSucceededStagesWithReason(m, s.Name(), skippedAt, staleReasonSelfSkip); err != nil {
-					return nil, persistTerminalFailure(
-						ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+					return nil, persistSessionTerminalFailure(
+						ctx, env.ManifestStore, manifestPath, m,
 						fmt.Errorf("invalidate dependents after stage %q self-skip: %w", s.Name(), err),
 					)
 				}
 			}
 			if err := env.ManifestStore.Save(ctx, manifestPath, m); err != nil {
-				return nil, persistTerminalFailure(
-					ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+				return nil, persistSessionTerminalFailure(
+					ctx, env.ManifestStore, manifestPath, m,
 					fmt.Errorf("save manifest after self-skip %q: %w", s.Name(), err),
 				)
 			}
-			runManifest.MarkStageSkipped(s.Name(), skippedAt, result.SkipReason)
-			applyStageResultToRunManifest(runManifest, s.Name(), result)
-			setRunStageSemanticConfig(runManifest, s.Name(), semanticConfig)
-			identity.applyToRunManifest(runManifest, manifestPath)
-			if err := runManifestStore.SaveRun(ctx, runManifestPath, runManifest); err != nil {
-				return nil, persistTerminalFailure(
-					ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
-					fmt.Errorf("save run manifest after self-skip %q: %w", s.Name(), err),
-				)
-			}
 			env.Logger.Debug("manifest saved", "stage", s.Name(), "transition", "skipped", "path", manifestPath)
 			env.Logger.Info("stage skipped", "stage", s.Name(), "reason", result.SkipReason)
 			continue
 		}
 
 		sessionOutputs := mapResultOutputs(s.Name(), result, runID)
-		runOutputs := sessionOutputs
 		if analyzeProjection != nil {
 			sessionOutputs = analyzeProjectionOutputs(analyzeProjection.session, "")
-			runOutputs = analyzeProjectionOutputs(analyzeProjection.invocation, runID)
 		}
 		succeededAt := nowUTC()
 		m.MarkStageSucceeded(s.Name(), succeededAt, sessionOutputs)
-		applyAnalyzeProjection(m, runManifest, analyzeProjection)
+		applyAnalyzeProjection(m, analyzeProjection)
 		applyStageResultToManifest(m, s.Name(), result)
 		setSessionStageSemanticConfig(m, s.Name(), semanticConfig)
 		if !priorOutcome.exists || priorOutcome.status != manifest.StatusSucceeded {
 			if _, err := invalidateDependentSucceededStagesWithReason(m, s.Name(), succeededAt, staleReasonChangedResult); err != nil {
-				return nil, persistTerminalFailure(
-					ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+				return nil, persistSessionTerminalFailure(
+					ctx, env.ManifestStore, manifestPath, m,
 					fmt.Errorf("invalidate dependents after changed stage %q result: %w", s.Name(), err),
 				)
 			}
@@ -446,39 +389,16 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 				if _, invalidationErr := invalidateDependentSucceededStagesWithReason(m, s.Name(), failedAt, staleReasonFailure); invalidationErr != nil {
 					operationErr = errors.Join(operationErr, fmt.Errorf("invalidate dependents after analyze projection persistence failure: %w", invalidationErr))
 				}
-				runManifest.MarkStageFailed(s.Name(), failedAt, operationErr.Error())
 			}
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
+			return nil, persistSessionTerminalFailure(
+				ctx, env.ManifestStore, manifestPath, m,
 				operationErr,
 			)
 		}
-		runManifest.MarkStageSucceeded(s.Name(), succeededAt, runOutputs)
-		applyStageResultToRunManifest(runManifest, s.Name(), result)
-		setRunStageSemanticConfig(runManifest, s.Name(), semanticConfig)
-		identity.applyToRunManifest(runManifest, manifestPath)
-		if err := runManifestStore.SaveRun(ctx, runManifestPath, runManifest); err != nil {
-			return nil, persistTerminalFailure(
-				ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
-				fmt.Errorf("save run manifest after stage %q: %w", s.Name(), err),
-			)
-		}
 		env.Logger.Debug("manifest saved", "stage", s.Name(), "transition", "succeeded", "path", manifestPath)
 		env.Logger.Info("stage succeeded", "stage", s.Name())
 	}
 
-	completedAt := nowUTC()
-	runManifest.MarkSucceeded(completedAt)
-	identity.applyToRunManifest(runManifest, manifestPath)
-	if err := runManifestStore.SaveRun(ctx, runManifestPath, runManifest); err != nil {
-		return nil, persistTerminalFailure(
-			ctx, env.ManifestStore, manifestPath, m, runManifestStore, runManifestPath, runManifest,
-			fmt.Errorf("save final run manifest %q: %w", runManifestPath, err),
-		)
-	}
-	// The run record lives inside the run work directory, which cleanup may
-	// remove. Persist its completed publishing result before cleanup starts so a
-	// successful deletion cannot be undone by a later diagnostic write.
 	if containsStage(executed, "publish") {
 		if err := runPostPublishCleanup(ctx, env, manifestPath, m, executed); err != nil {
 			return nil, persistPostPublishCleanupFailure(
@@ -489,13 +409,12 @@ func executePlan(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts
 	}
 
 	return &RunSummary{
-		SessionID:       cfg.Session.SessionID,
-		RunID:           runID,
-		ManifestPath:    manifestPath,
-		RunManifestPath: runManifestPath,
-		StageNames:      runNames,
-		Executed:        executed,
-		Skipped:         skipped,
+		SessionID:    cfg.Session.SessionID,
+		RunID:        runID,
+		ManifestPath: manifestPath,
+		StageNames:   runNames,
+		Executed:     executed,
+		Skipped:      skipped,
 	}, nil
 }
 
@@ -536,14 +455,11 @@ func persistPostPublishCleanupFailure(
 	return errors.Join(operationErr, wrapTerminalPersistenceError("save terminal session manifest", sessionErr))
 }
 
-func persistTerminalFailure(
+func persistSessionTerminalFailure(
 	ctx context.Context,
 	sessionStore manifest.Store,
 	sessionManifestPath string,
 	sessionManifest *manifest.Manifest,
-	runStore manifest.RunStore,
-	runManifestPath string,
-	runManifest *manifest.RunManifest,
 	operationErr error,
 ) error {
 	if operationErr == nil {
@@ -555,18 +471,10 @@ func persistTerminalFailure(
 		sessionManifest.RecordFailure(at, operationErr.Error())
 	}
 
-	// A running run record is durable before execution. At termination, session
-	// state controls resume while the run record only diagnoses this invocation,
-	// so session persistence comes first and any disagreement remains visible.
 	sessionErr := sessionStore.Save(ctx, sessionManifestPath, sessionManifest)
-	if runManifest != nil {
-		runManifest.MarkFailed(at, operationErr.Error())
-	}
-	runErr := runStore.SaveRun(ctx, runManifestPath, runManifest)
 	return errors.Join(
 		operationErr,
 		wrapTerminalPersistenceError("save terminal session manifest", sessionErr),
-		wrapTerminalPersistenceError("save terminal run manifest", runErr),
 	)
 }
 
@@ -898,51 +806,6 @@ func (identity invocationIdentity) applyToSessionManifest(m *manifest.Manifest)
 	m.S3RunPrefix = identity.S3RunPrefix
 }
 
-func (identity invocationIdentity) applyToRunManifest(m *manifest.RunManifest, sessionManifestPath string) {
-	if m == nil {
-		return
-	}
-	m.SessionID = identity.SessionID
-	m.Campaign = identity.Campaign
-	m.RunID = identity.RunID
-	m.SessionManifestPath = sessionManifestPath
-	m.LocalWorkDir = identity.LocalWorkDir
-	m.LocalSpoolDir = identity.LocalSpoolDir
-	m.S3Bucket = identity.S3Bucket
-	m.S3SessionPrefix = identity.S3SessionPrefix
-	m.S3RunPrefix = identity.S3RunPrefix
-}
-
-func requestedStageNames(stages []stage.Stage) []string {
-	out := make([]string, 0, len(stages))
-	for _, s := range stages {
-		if s == nil {
-			continue
-		}
-		out = append(out, s.Name())
-	}
-	return out
-}
-
-func applyStageResultToRunManifest(m *manifest.RunManifest, stageName string, result *stage.StageResult) {
-	if m == nil || result == nil {
-		return
-	}
-	sr := m.Stages[stageName]
-	if sr == nil {
-		return
-	}
-	if len(result.Logs) > 0 {
-		sr.Logs = append([]string(nil), result.Logs...)
-	}
-	if len(result.GeneratedConfigs) > 0 {
-		sr.GeneratedConfigs = append([]string(nil), result.GeneratedConfigs...)
-	}
-	if len(result.Metadata) > 0 {
-		sr.Metadata = result.Metadata
-	}
-}
-
 func manifestPathFor(cfg *config.Config) string {
 	return artifacts.SessionManifestPathForCampaign(
 		cfg.Pipeline.Workspace.Root,