Establish explicit runner lifecycle state

internal/app/runner_test.go

@@ -26,11 +26,51 @@ type failingStage struct {
 	err  error
 }
 
+type releaseErrorArtifactStore struct {
+	artifacts.Store
+	err error
+}
+
+func (s *releaseErrorArtifactStore) ReleaseSessionLock(lock *artifacts.LockHandle) error {
+	return errors.Join(s.Store.ReleaseSessionLock(lock), s.err)
+}
+
 func (s failingStage) Name() string { return s.name }
 func (s failingStage) Run(_ context.Context, _ *stage.Env, _ *manifest.Manifest) (*stage.StageResult, error) {
 	return nil, s.err
 }
 
+func TestExecutePlanPreservesSessionLockReleaseErrors(t *testing.T) {
+	releaseErr := errors.New("release failed")
+	executionErr := errors.New("execution failed")
+	tests := []struct {
+		name          string
+		selectedStage stage.Stage
+		wantExecution bool
+	}{
+		{name: "release is final error", selectedStage: resultStage{name: "prepare"}},
+		{name: "release joins execution error", selectedStage: failingStage{name: "prepare", err: executionErr}, wantExecution: true},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			cfg := testConfig(t)
+			store := &releaseErrorArtifactStore{
+				Store: artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root),
+				err:   releaseErr,
+			}
+			_, err := executePlan(context.Background(), cfg, BoundedPlan{stages: []stage.Stage{test.selectedStage}}, RunOptions{
+				Env: &Env{ArtifactStore: store},
+			})
+			if !errors.Is(err, releaseErr) {
+				t.Fatalf("executePlan() error = %v, want release error", err)
+			}
+			if got := errors.Is(err, executionErr); got != test.wantExecution {
+				t.Fatalf("executePlan() contains execution error = %t, want %t", got, test.wantExecution)
+			}
+		})
+	}
+}
+
 type countingStage struct {
 	name string
 	runs *int