feat(stovepipe): Record project validation facts

**What**:
- Record named project outcomes alongside final repository validation results.
- Let deployments without project attribution continue recording only repository results.

**Why**:
- Enable consumers to query durable project failures when an integration supplies attribution.

Author: prathshenoy

service/stovepipe/server/BUILD.bazel

@@ -33,6 +33,7 @@ go_library(
         "//stovepipe/core/requestlog:go_default_library",
         "//stovepipe/extension/buildrunner:go_default_library",
         "//stovepipe/extension/buildrunner/fake:go_default_library",
+        "//stovepipe/extension/projectresult:go_default_library",
         "//stovepipe/extension/queueconfig/default:go_default_library",
         "//stovepipe/extension/sourcecontrol:go_default_library",
         "//stovepipe/extension/sourcecontrol/fake:go_default_library",

service/stovepipe/server/main.go

@@ -55,6 +55,7 @@ import (
 	"github.com/uber/submitqueue/stovepipe/core/requestlog"
 	"github.com/uber/submitqueue/stovepipe/extension/buildrunner"
 	buildrunnerfake "github.com/uber/submitqueue/stovepipe/extension/buildrunner/fake"
+	"github.com/uber/submitqueue/stovepipe/extension/projectresult"
 	queueconfigdefault "github.com/uber/submitqueue/stovepipe/extension/queueconfig/default"
 	"github.com/uber/submitqueue/stovepipe/extension/sourcecontrol"
 	sourcecontrolfake "github.com/uber/submitqueue/stovepipe/extension/sourcecontrol/fake"
@@ -440,7 +441,7 @@ func registerPrimaryControllers(
 	}
 	count++
 
-	recordController := record.NewController(logger, scope, store, materializer, sourceControl, registry, stovepipemq.TopicKeyRecord, "stovepipe-record")
+	recordController := record.NewController(logger, scope, store, materializer, projectresult.NoopFactory{}, sourceControl, registry, stovepipemq.TopicKeyRecord, "stovepipe-record")
 	if err := c.Register(recordController); err != nil {
 		return count, fmt.Errorf("failed to register record controller: %w", err)
 	}
@@ -486,7 +487,7 @@ func registerDLQControllers(
 	}
 	count++
 
-	recordDLQController := record.NewController(logger, scope, store, materializer, sourceControl, registry, dlq.TopicKey(stovepipemq.TopicKeyRecord), "stovepipe-record-dlq")
+	recordDLQController := record.NewController(logger, scope, store, materializer, projectresult.NoopFactory{}, sourceControl, registry, dlq.TopicKey(stovepipemq.TopicKeyRecord), "stovepipe-record-dlq")
 	if err := c.Register(recordDLQController); err != nil {
 		return count, fmt.Errorf("failed to register record dlq controller: %w", err)
 	}

stovepipe/controller/record/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//stovepipe/core/messagequeue:go_default_library",
         "//stovepipe/core/requestlog:go_default_library",
         "//stovepipe/entity:go_default_library",
+        "//stovepipe/extension/projectresult:go_default_library",
         "//stovepipe/extension/sourcecontrol:go_default_library",
         "//stovepipe/extension/storage:go_default_library",
         "@com_github_uber_go_tally//:go_default_library",
@@ -39,6 +40,7 @@ go_test(
         "//stovepipe/core/requestlog:go_default_library",
         "//stovepipe/core/requestlog/mock:go_default_library",
         "//stovepipe/entity:go_default_library",
+        "//stovepipe/extension/projectresult:go_default_library",
         "//stovepipe/extension/sourcecontrol:go_default_library",
         "//stovepipe/extension/sourcecontrol/mock:go_default_library",
         "//stovepipe/extension/storage:go_default_library",

stovepipe/controller/record/record.go

@@ -33,6 +33,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"math"
 	"strconv"
 	"time"
 
@@ -47,6 +48,7 @@ import (
 	stovepipemq "github.com/uber/submitqueue/stovepipe/core/messagequeue"
 	"github.com/uber/submitqueue/stovepipe/core/requestlog"
 	"github.com/uber/submitqueue/stovepipe/entity"
+	"github.com/uber/submitqueue/stovepipe/extension/projectresult"
 	"github.com/uber/submitqueue/stovepipe/extension/sourcecontrol"
 	"github.com/uber/submitqueue/stovepipe/extension/storage"
 	"go.uber.org/zap"
@@ -60,6 +62,7 @@ type Controller struct {
 	metricsScope  tally.Scope
 	stores        storage.Factory
 	materializer  requestlog.Materializer
+	projectResult projectresult.Factory
 	sourceControl sourcecontrol.Factory
 	registry      consumer.TopicRegistry
 	topicKey      consumer.TopicKey
@@ -73,8 +76,7 @@ var _ consumer.Controller = (*Controller)(nil)
 const _opName = "record"
 
 // wholeRepositoryProject is the project component of a fact covering the whole
-// repository rather than one project within it. Per-project facts need target-graph
-// attribution that this stage does not do, so every fact it writes is whole-repository.
+// repository rather than one project within it.
 const wholeRepositoryProject = ""
 
 // NewController creates a new record controller.
@@ -83,6 +85,7 @@ func NewController(
 	scope tally.Scope,
 	stores storage.Factory,
 	materializer requestlog.Materializer,
+	projectResult projectresult.Factory,
 	sourceControl sourcecontrol.Factory,
 	registry consumer.TopicRegistry,
 	topicKey consumer.TopicKey,
@@ -94,6 +97,7 @@ func NewController(
 		metricsScope:  scope.SubScope(name),
 		stores:        stores,
 		materializer:  materializer,
+		projectResult: projectResult,
 		sourceControl: sourceControl,
 		registry:      registry,
 		topicKey:      topicKey,
@@ -150,6 +154,9 @@ func (c *Controller) Process(ctx context.Context, delivery consumer.Delivery) er
 		if err := c.persistValidationFactRecordedLog(ctx, store, request, fact); err != nil {
 			return err
 		}
+		if err := c.recordProjectFacts(ctx, store, request); err != nil {
+			return err
+		}
 		if err := c.applyFactToDerivedCaches(ctx, store, request, fact, created); err != nil {
 			return err
 		}
@@ -176,6 +183,46 @@ func (c *Controller) Process(ctx context.Context, delivery consumer.Delivery) er
 	}
 }
 
+func (c *Controller) recordProjectFacts(ctx context.Context, store storage.Storage, request entity.Request) error {
+	resolver, err := c.projectResult.For(projectresult.Config{QueueName: request.Queue})
+	if err != nil {
+		return fmt.Errorf("failed to resolve project result resolver for queue %q: %w", request.Queue, err)
+	}
+	results, err := resolver.Resolve(ctx, request)
+	if err != nil {
+		return fmt.Errorf("failed to resolve project results for request %q: %w", request.ID, err)
+	}
+
+	seen := make(map[string]struct{}, len(results))
+	for _, result := range results {
+		if result.Project == "" {
+			return fmt.Errorf("project result for request %q has an empty project", request.ID)
+		}
+		if _, ok := seen[result.Project]; ok {
+			return fmt.Errorf("project result for request %q contains duplicate project %q", request.ID, result.Project)
+		}
+		seen[result.Project] = struct{}{}
+		if math.IsNaN(result.Degree) || result.Degree < entity.DegreeGreen || result.Degree > entity.DegreeBroken {
+			return fmt.Errorf("project result for request %q and project %q has invalid degree %v", request.ID, result.Project, result.Degree)
+		}
+
+		fact, _, err := c.recordValidationFact(ctx, store.GetValidationFactStore(), entity.ValidationFact{
+			URI:       request.URI,
+			Project:   result.Project,
+			Degree:    result.Degree,
+			RequestID: request.ID,
+			CreatedAt: time.Now().UnixMilli(),
+		})
+		if err != nil {
+			return err
+		}
+		if err := c.persistValidationFactRecordedLog(ctx, store, request, fact); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (c *Controller) persistValidationFactRecordedLog(
 	ctx context.Context,
 	store storage.Storage,
@@ -241,48 +288,49 @@ func (c *Controller) applyFactToDerivedCaches(
 // second return reports whether this call is the one that wrote the fact, which is
 // how a caller tells the original delivery from a redelivery.
 func (c *Controller) recordFact(ctx context.Context, store storage.Storage, request entity.Request) (entity.ValidationFact, bool, error) {
-	factStore := store.GetValidationFactStore()
-
-	fact := entity.ValidationFact{
+	return c.recordValidationFact(ctx, store.GetValidationFactStore(), entity.ValidationFact{
 		URI:       request.URI,
 		Project:   wholeRepositoryProject,
 		Degree:    degreeFor(request.State),
 		RequestID: request.ID,
 		CreatedAt: time.Now().UnixMilli(),
-	}
+	})
+}
+
+func (c *Controller) recordValidationFact(ctx context.Context, factStore storage.ValidationFactStore, fact entity.ValidationFact) (entity.ValidationFact, bool, error) {
 
 	err := factStore.Create(ctx, fact)
 	switch {
 	case err == nil:
 		metrics.NamedCounter(c.metricsScope, _opName, "fact_created", 1, metrics.TagsFromContext(ctx)...)
 		c.logger.Infow("recorded validation fact",
-			"queue", request.Queue,
-			"request_id", request.ID,
-			"uri", request.URI,
+			"request_id", fact.RequestID,
+			"uri", fact.URI,
+			"project", fact.Project,
 			"degree", fact.Degree,
 		)
 		return fact, true, nil
 
 	case errors.Is(err, storage.ErrAlreadyExists):
-		stored, getErr := factStore.Get(ctx, request.URI, wholeRepositoryProject)
+		stored, getErr := factStore.Get(ctx, fact.URI, fact.Project)
 		if getErr != nil {
 			metrics.NamedCounter(c.metricsScope, _opName, "storage_errors", 1, metrics.TagsFromContext(ctx)...)
-			return entity.ValidationFact{}, false, fmt.Errorf("failed to load the existing fact for uri %s: %w", request.URI, getErr)
+			return entity.ValidationFact{}, false, fmt.Errorf("failed to load the existing fact for uri %s and project %q: %w", fact.URI, fact.Project, getErr)
 		}
-		if stored.RequestID != request.ID {
+		if stored.RequestID != fact.RequestID {
 			// Two requests validating one URI would break the dedup ingest
 			// enforces, so this is a broken invariant rather than a race to
 			// resolve. Non-retryable: the stored fact is immutable.
 			metrics.NamedCounter(c.metricsScope, _opName, "invariant_errors", 1, metrics.TagsFromContext(ctx)...)
 			return entity.ValidationFact{}, false, fmt.Errorf(
-				"fact for uri %s is owned by request %s, not %s", request.URI, stored.RequestID, request.ID)
+				"fact for uri %s and project %q is owned by request %s, not %s", fact.URI, fact.Project, stored.RequestID, fact.RequestID)
 		}
 		metrics.NamedCounter(c.metricsScope, _opName, "fact_exists", 1, metrics.TagsFromContext(ctx)...)
 		return stored, false, nil
 
 	default:
 		metrics.NamedCounter(c.metricsScope, _opName, "storage_errors", 1, metrics.TagsFromContext(ctx)...)
-		return entity.ValidationFact{}, false, fmt.Errorf("failed to create the fact for uri %s: %w", request.URI, err)
+		return entity.ValidationFact{}, false, fmt.Errorf("failed to create the fact for uri %s and project %q: %w", fact.URI, fact.Project, err)
 	}
 }
 

stovepipe/controller/record/record_test.go

@@ -34,6 +34,7 @@ import (
 	"github.com/uber/submitqueue/stovepipe/core/requestlog"
 	requestlogmock "github.com/uber/submitqueue/stovepipe/core/requestlog/mock"
 	"github.com/uber/submitqueue/stovepipe/entity"
+	"github.com/uber/submitqueue/stovepipe/extension/projectresult"
 	"github.com/uber/submitqueue/stovepipe/extension/sourcecontrol"
 	sourcecontrolmock "github.com/uber/submitqueue/stovepipe/extension/sourcecontrol/mock"
 	"github.com/uber/submitqueue/stovepipe/extension/storage"
@@ -125,6 +126,23 @@ func (f staticSourceControlFactory) For(sourcecontrol.Config) (sourcecontrol.Sou
 	return f.sourceControl, nil
 }
 
+type staticProjectResultFactory struct {
+	resolver projectresult.Resolver
+}
+
+func (f staticProjectResultFactory) For(projectresult.Config) (projectresult.Resolver, error) {
+	return f.resolver, nil
+}
+
+type staticProjectResultResolver struct {
+	results []projectresult.Result
+	err     error
+}
+
+func (r staticProjectResultResolver) Resolve(context.Context, entity.Request) ([]projectresult.Result, error) {
+	return r.results, r.err
+}
+
 // failingSourceControlFactory resolves no queue.
 type failingSourceControlFactory struct{}
 
@@ -194,6 +212,7 @@ func newControllerForTopic(t *testing.T, ctrl *gomock.Controller, topicKey consu
 		scope,
 		staticStorageFactory{store: m.store},
 		m.materializer,
+		projectresult.NoopFactory{},
 		staticSourceControlFactory{sourceControl: m.sourceControl},
 		registry,
 		topicKey,
@@ -325,6 +344,34 @@ func TestProcess_AdvancesBookmarkOnSuccess(t *testing.T) {
 	}
 }
 
+func TestProcess_RecordsNamedProjectResults(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	c, m := newController(t, ctrl)
+	c.projectResult = staticProjectResultFactory{resolver: staticProjectResultResolver{results: []projectresult.Result{
+		{Project: "project-a", Degree: entity.DegreeBroken},
+		{Project: "project-b", Degree: entity.DegreeBroken},
+	}}}
+	m.reqStore.EXPECT().Get(gomock.Any(), testID).Return(requestWithState(entity.RequestStateFailed), nil)
+
+	var facts []entity.ValidationFact
+	m.factStore.EXPECT().Create(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(_ context.Context, fact entity.ValidationFact) error {
+			facts = append(facts, fact)
+			return nil
+		}).
+		Times(3)
+
+	require.NoError(t, c.Process(queueContext(), delivery(t, ctrl, recordPayload(t, testID))))
+	require.Len(t, facts, 3)
+	assert.Equal(t, []string{"", "project-a", "project-b"}, []string{facts[0].Project, facts[1].Project, facts[2].Project})
+	for _, fact := range facts {
+		assert.Equal(t, testURI, fact.URI)
+		assert.Equal(t, testID, fact.RequestID)
+		assert.Equal(t, entity.DegreeBroken, fact.Degree)
+		assert.Positive(t, fact.CreatedAt)
+	}
+}
+
 func TestProcess_TimestampReportingFailureDoesNotFailRecord(t *testing.T) {
 	tests := []struct {
 		name        string

stovepipe/extension/projectresult/BUILD.bazel

@@ -0,0 +1,9 @@
+load("@rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["projectresult.go"],
+    importpath = "github.com/uber/submitqueue/stovepipe/extension/projectresult",
+    visibility = ["//visibility:public"],
+    deps = ["//stovepipe/entity:go_default_library"],
+)

stovepipe/extension/projectresult/projectresult.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package projectresult defines the optional integration that attributes a
+// completed validation to named projects.
+package projectresult
+
+import (
+	"context"
+
+	"github.com/uber/submitqueue/stovepipe/entity"
+)
+
+// Result is one project-scoped validation outcome. The record stage supplies
+// the request identity and recording timestamp when it persists this result.
+type Result struct {
+	// Project identifies the project to which this result applies.
+	Project string
+	// Degree describes how broken the project is, on the closed interval [0, 1].
+	Degree float64
+}
+
+// Resolver attributes one terminal validation request to named project
+// outcomes. Implementations may use any repository-specific analysis they need
+// to obtain those outcomes. Returning no results is valid.
+type Resolver interface {
+	Resolve(ctx context.Context, request entity.Request) ([]Result, error)
+}
+
+// Config carries the queue identity handed to a Factory.
+type Config struct {
+	// QueueName identifies the queue served by the resolver.
+	QueueName string
+}
+
+// Factory constructs a Resolver for one queue.
+type Factory interface {
+	For(cfg Config) (Resolver, error)
+}
+
+// NoopFactory returns a resolver that records no project outcomes. It is the
+// default for deployments that do not configure project attribution.
+type NoopFactory struct{}
+
+// For returns the no-op resolver for a queue.
+func (NoopFactory) For(Config) (Resolver, error) {
+	return noopResolver{}, nil
+}
+
+type noopResolver struct{}
+
+func (noopResolver) Resolve(context.Context, entity.Request) ([]Result, error) {
+	return nil, nil
+}