refactor(status): add shared status snapshot

Co-authored-by: Andrew <andrewxhill@gmail.com>

Author: andrewxhill-ai

internal/app/status.go

@@ -243,29 +243,7 @@ func collectStatus(repoPath string, limit int) (statusResult, error) {
 	}
 
 	ctx := context.Background()
-	submissions, err := store.ListIntegrationSubmissions(ctx, repoRecord.ID)
-	if err != nil {
-		return statusResult{}, err
-	}
-	requests, err := store.ListPublishRequests(ctx, repoRecord.ID)
-	if err != nil {
-		return statusResult{}, err
-	}
-	events, err := store.ListEvents(ctx, repoRecord.ID, limit)
-	if err != nil {
-		return statusResult{}, err
-	}
-
-	enrichedSubmissions, err := enrichStatusSubmissions(ctx, store, repoRecord.ID, cfg.Repo.MainWorktree, cfg.Repo.ProtectedBranch, submissions)
-	if err != nil {
-		return statusResult{}, err
-	}
-	estimate, err := collectExecutionEstimate(ctx, store, repoRecord.ID, cfg, submissions)
-	if err != nil {
-		return statusResult{}, err
-	}
-	enrichedSubmissions = annotateQueueEstimates(enrichedSubmissions, estimate)
-	queue, err := loadQueueSnapshot(store, repoRecord.ID)
+	snapshot, err := loadRepoStatusSnapshot(ctx, store, repoRecord, cfg, limit)
 	if err != nil {
 		return statusResult{}, err
 	}
@@ -278,12 +256,12 @@ func collectStatus(repoPath string, limit int) (statusResult, error) {
 		ProtectedBranch:    cfg.Repo.ProtectedBranch,
 		ProtectedBranchSHA: protectedSHA,
 		ProtectedUpstream:  protectedStatus,
-		ExecutionEstimate:  estimate,
+		ExecutionEstimate:  snapshot.ExecutionEstimate,
 		PublishExecution:   buildPublishExecutionPolicy(cfg),
-		Counts:             queue.Counts,
-		ActiveSubmissions:  activeSubmissions(enrichedSubmissions),
-		ActivePublishes:    activePublishes(requests),
-		RecentEvents:       events,
+		Counts:             snapshot.Counts,
+		ActiveSubmissions:  snapshot.ActiveSubmissions,
+		ActivePublishes:    snapshot.ActivePublishes,
+		RecentEvents:       snapshot.RecentEvents,
 	}
 	if currentBranch != "(detached)" && currentBranch != "" && currentBranch != cfg.Repo.ProtectedBranch {
 		comparison, compareErr := engine.CompareBranches(cfg.Repo.ProtectedBranch, currentBranch)
@@ -292,34 +270,13 @@ func collectStatus(repoPath string, limit int) (statusResult, error) {
 			result.RebaseGuidance = buildStatusRebaseGuidance(cfg, comparison, protectedStatus, layout.WorktreeRoot, currentBranch)
 		}
 	}
-	result.QueueSummary = queue.Summary
-	result.Alerts = buildStatusAlerts(result.Counts)
-	lockManager := state.NewLockManager(layout.RepositoryRoot, layout.GitDir)
-	if metadata, ok := readActiveLease(lockManager, state.IntegrationLock); ok {
-		result.IntegrationWorker = &metadata
-	}
-	if metadata, ok := readActiveLease(lockManager, state.PublishLock); ok {
-		result.PublishWorker = &metadata
-	}
-	result.ProtectedWorktreeActivity = buildProtectedWorktreeActivity(cfg.Repo.MainWorktree, result.IntegrationWorker, result.PublishWorker)
-	if len(enrichedSubmissions) > 0 {
-		latest := enrichedSubmissions[len(enrichedSubmissions)-1]
-		result.LatestSubmission = &latest
-	}
-	if len(requests) > 0 {
-		latest := newStatusPublish(requests[len(requests)-1])
-		if result.PublishWorker != nil && result.PublishWorker.RequestID == latest.ID {
-			latest.ActiveStage = result.PublishWorker.Stage
-		}
-		result.LatestPublish = &latest
-	}
-	if result.PublishWorker != nil {
-		for i := range result.ActivePublishes {
-			if result.ActivePublishes[i].ID == result.PublishWorker.RequestID {
-				result.ActivePublishes[i].ActiveStage = result.PublishWorker.Stage
-			}
-		}
-	}
+	result.QueueSummary = snapshot.QueueSummary
+	result.Alerts = snapshot.Alerts
+	result.IntegrationWorker = snapshot.IntegrationWorker
+	result.PublishWorker = snapshot.PublishWorker
+	result.ProtectedWorktreeActivity = snapshot.ProtectedWorktreeActivity
+	result.LatestSubmission = snapshot.LatestSubmission
+	result.LatestPublish = snapshot.LatestPublish
 
 	return result, nil
 }

internal/app/status_snapshot.go

@@ -0,0 +1,98 @@
+package app
+
+import (
+	"context"
+	"path/filepath"
+
+	"github.com/recallnet/mainline/internal/policy"
+	"github.com/recallnet/mainline/internal/state"
+)
+
+type repoStatusSnapshot struct {
+	ExecutionEstimate         executionEstimate
+	Counts                    queueCounts
+	QueueSummary              queueSummary
+	Alerts                    []string
+	LatestSubmission          *statusSubmission
+	LatestPublish             *statusPublish
+	ActiveSubmissions         []statusSubmission
+	ActivePublishes           []statusPublish
+	IntegrationWorker         *state.LeaseMetadata
+	PublishWorker             *state.LeaseMetadata
+	ProtectedWorktreeActivity *protectedWorktreeActivity
+	RecentEvents              []state.EventRecord
+}
+
+func loadRepoStatusSnapshot(ctx context.Context, store state.Store, repoRecord state.RepositoryRecord, cfg policy.File, limit int) (repoStatusSnapshot, error) {
+	submissions, err := store.ListIntegrationSubmissions(ctx, repoRecord.ID)
+	if err != nil {
+		return repoStatusSnapshot{}, err
+	}
+	requests, err := store.ListPublishRequests(ctx, repoRecord.ID)
+	if err != nil {
+		return repoStatusSnapshot{}, err
+	}
+	events, err := store.ListEvents(ctx, repoRecord.ID, limit)
+	if err != nil {
+		return repoStatusSnapshot{}, err
+	}
+
+	enrichedSubmissions, err := enrichStatusSubmissions(ctx, store, repoRecord.ID, cfg.Repo.MainWorktree, cfg.Repo.ProtectedBranch, submissions)
+	if err != nil {
+		return repoStatusSnapshot{}, err
+	}
+	estimate, err := collectExecutionEstimate(ctx, store, repoRecord.ID, cfg, submissions)
+	if err != nil {
+		return repoStatusSnapshot{}, err
+	}
+	enrichedSubmissions = annotateQueueEstimates(enrichedSubmissions, estimate)
+	queue, err := loadQueueSnapshot(store, repoRecord.ID)
+	if err != nil {
+		return repoStatusSnapshot{}, err
+	}
+
+	snapshot := repoStatusSnapshot{
+		ExecutionEstimate: estimate,
+		Counts:            queue.Counts,
+		QueueSummary:      queue.Summary,
+		Alerts:            buildStatusAlerts(queue.Counts),
+		ActiveSubmissions: activeSubmissions(enrichedSubmissions),
+		ActivePublishes:   activePublishes(requests),
+		RecentEvents:      events,
+	}
+
+	lockManager := state.NewLockManager(repoRecord.CanonicalPath, stateGitDirFromStorePath(store.Path))
+	if metadata, ok := readActiveLease(lockManager, state.IntegrationLock); ok {
+		snapshot.IntegrationWorker = &metadata
+	}
+	if metadata, ok := readActiveLease(lockManager, state.PublishLock); ok {
+		snapshot.PublishWorker = &metadata
+	}
+	snapshot.ProtectedWorktreeActivity = buildProtectedWorktreeActivity(cfg.Repo.MainWorktree, snapshot.IntegrationWorker, snapshot.PublishWorker)
+
+	if len(enrichedSubmissions) > 0 {
+		latest := enrichedSubmissions[len(enrichedSubmissions)-1]
+		snapshot.LatestSubmission = &latest
+	}
+	if len(requests) > 0 {
+		latest := newStatusPublish(requests[len(requests)-1])
+		if snapshot.PublishWorker != nil && snapshot.PublishWorker.RequestID == latest.ID {
+			latest.ActiveStage = snapshot.PublishWorker.Stage
+		}
+		snapshot.LatestPublish = &latest
+	}
+	if snapshot.PublishWorker != nil {
+		for i := range snapshot.ActivePublishes {
+			if snapshot.ActivePublishes[i].ID == snapshot.PublishWorker.RequestID {
+				snapshot.ActivePublishes[i].ActiveStage = snapshot.PublishWorker.Stage
+			}
+		}
+	}
+
+	return snapshot, nil
+}
+
+func stateGitDirFromStorePath(path string) string {
+	// state.DefaultPath writes under <gitdir>/mainline/state.db; derive the gitdir back from that stable layout.
+	return filepath.Dir(filepath.Dir(path))
+}