feat: per-queue extension fakes with error injection in example

## Summary

### Why?

Extensions over external systems (changeprovider, buildrunner, pusher,
mergechecker) had no runnable stub to exercise their success — and
especially failure — paths without standing up the real backend
(GitHub/CI/git). scorer and conflict had deterministic stubs (heuristic,
composite, all, none) but no way to inject errors. We needed to drive
both happy and error paths end-to-end, including e2e, against a single
running stack.

We also wanted the example orchestrator to demonstrate SubmitQueue's core
premise — per-queue pluggable extensions — instead of wiring one
implementation for every queue.

### What?

Fakes (test/example stubs, never production):
- buildrunner/fake, changeprovider/fake, pusher/fake, mergechecker/fake:
  best-case by default; inject failures via an `sq-fake=<token>` marker in
  a change URI (e.g. build-fail, conflict, unmergeable, provider-error),
  so a single land request can drive the error path end-to-end.
- scorer/fake, conflict/fake: decorators that wrap an existing impl (the
  "pick") and overlay error injection — scorer via the URI marker
  (score-error) over entity.BatchChanges, analyzer via a predicate, since
  Analyze sees batches, not change URIs.
- Retired buildrunner/noop (subsumed by buildrunner/fake); swapped its
  unit-test and example callers.

Wiring (example orchestrator main.go):
- Queue-major registry: queueExtensions (one queue's full impl set) +
  queueRegistry (queue -> profile, with a default). Six thin Factory
  adapters resolve impls by Config.QueueName.
- Per-queue profiles: test-queue (bucketed heuristic over lines changed),
  e2e-test-queue (composite scorer, no-conflict), plus a new
  e2e-conflict-error-queue that always fails conflict analysis. Edge
  integrations + build runner share a baseline.
- Removed all per-impl NewFactory() from extension/*: factory
  implementations and queue routing now live only in the wiring layer.

Conventions:
- CLAUDE.md: documented that extensions hold contracts + impls only (no
  factory implementations or routing — that belongs in the wiring layer);
  added a TODO to evaluate promoting the registry into submitqueue/core
  later.

Stacking / upstream accommodation (this PR is stacked on the scorer
branch): adapted to the scorer branch's refactors — ChangeStore folded
into storage (dropped the example's changestore wiring; change.sql is now
applied by the existing storage schema step), and the scorer now scores
over entity.BatchChanges (scorer/fake and the example value func use it).

## Test Plan

- ✅ `make test` — 44/44 unit tests
- ✅ `make e2e-test` — 1/1
- ✅ `make integration-test` — 7/7
- ✅ `make check-gazelle` / `make check-tidy` — clean
- ✅ Live stack (`make local-submitqueue-start`): Ping OK on gateway and
  orchestrator; gateway rejects unknown queues; validated end-to-end —
  scorer passthrough (test-queue progressed past scoring), scorer error
  (`?sq-fake=score-error` -> "fake: marked score error"), and conflict
  error (e2e-conflict-error-queue -> "fake: injected analyze error").

Author: behinddwalls

CLAUDE.md

@@ -116,6 +116,8 @@ Vendor-agnostic, pluggable interfaces with implementations in subdirectories:
 2. Implementations at `extension/{ext}/{impl}/`
 3. Factory interface for dependency injection and lifecycle management
 
+**Extensions hold contracts and impls only — never factory implementations or routing.** An `extension/{ext}` package owns the behavioral interface, its `Config`, the `Factory` *interface*, and impl constructors `New(...)` that return the interface. It must NOT contain `Factory` *implementations* (no `NewFactory()` constructors or factory structs) and no queue-selection/routing logic. The reason: an impl package (e.g. `scorer/heuristic`) cannot know the queue topology or the other impls, so any "which impl for which queue" decision baked there is wrong by construction. A `Factory` whose `For(cfg)` ignores `cfg.QueueName` is just an impl→Factory adapter — that adapting, and all per-queue routing, belongs in the **wiring/integrator layer** (e.g. `example/{domain}/{service}/server/main.go`), which is the one place that knows the queue set. There, adapt `New(...)` impls to the `Factory` contract and route on `Config.QueueName`. Keep this seam strict: if you're about to add a `NewFactory()` or a `map[queue]impl` under `extension/`, it belongs in the wiring layer instead.
+
 **Design interfaces for the technology *space*, not the implementation in front of you.** The interface is a contract every backend will have to satisfy — SQL, key-value (DynamoDB, Bigtable), document, message queue, search, RPC, in-memory, mocks. If the contract assumes a capability that some plausible backend can't provide cheaply, you've baked the current impl's strengths into the API.
 
 Common over-constraints to avoid:

example/submitqueue/gateway/server/queues.yaml

@@ -7,3 +7,7 @@ queues:
   - name: test-queue
   - name: e2e-test-queue
   - name: e2e-cancel-queue
+  # Routes to an analyzer that always errors (conflictfake.FailAlways) so e2e can
+  # exercise the conflict-analysis error path. See newQueueRegistry in the
+  # orchestrator example server.
+  - name: e2e-conflict-error-queue

example/submitqueue/orchestrator/server/BUILD.bazel

@@ -21,16 +21,23 @@ go_library(
         "//submitqueue/core/consumer",
         "//submitqueue/entity",
         "//submitqueue/extension/buildrunner",
-        "//submitqueue/extension/buildrunner/noop",
+        "//submitqueue/extension/buildrunner/fake",
         "//submitqueue/extension/changeprovider",
+        "//submitqueue/extension/changeprovider/fake",
         "//submitqueue/extension/changeprovider/github",
         "//submitqueue/extension/conflict",
         "//submitqueue/extension/conflict/all",
+        "//submitqueue/extension/conflict/fake",
+        "//submitqueue/extension/conflict/none",
         "//submitqueue/extension/mergechecker",
+        "//submitqueue/extension/mergechecker/fake",
         "//submitqueue/extension/mergechecker/github",
         "//submitqueue/extension/pusher",
+        "//submitqueue/extension/pusher/fake",
         "//submitqueue/extension/pusher/git",
         "//submitqueue/extension/scorer",
+        "//submitqueue/extension/scorer/composite",
+        "//submitqueue/extension/scorer/fake",
         "//submitqueue/extension/scorer/heuristic",
         "//submitqueue/extension/storage",
         "//submitqueue/extension/storage/mysql",

example/submitqueue/orchestrator/server/main.go

@@ -1,9 +1,9 @@
 load("@rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
-    name = "noop",
-    srcs = ["noop.go"],
-    importpath = "github.com/uber/submitqueue/submitqueue/extension/buildrunner/noop",
+    name = "fake",
+    srcs = ["fake.go"],
+    importpath = "github.com/uber/submitqueue/submitqueue/extension/buildrunner/fake",
     visibility = ["//visibility:public"],
     deps = [
         "//submitqueue/entity",
@@ -12,9 +12,9 @@ go_library(
 )
 
 go_test(
-    name = "noop_test",
-    srcs = ["noop_test.go"],
-    embed = [":noop"],
+    name = "fake_test",
+    srcs = ["fake_test.go"],
+    embed = [":fake"],
     deps = [
         "//submitqueue/entity",
         "//submitqueue/extension/buildrunner",

…e/extension/buildrunner/noop/BUILD.bazel …e/extension/buildrunner/fake/BUILD.bazelsubmitqueue/extension/buildrunner/noop/BUILD.bazel renamed to submitqueue/extension/buildrunner/fake/BUILD.bazel submitqueue/extension/buildrunner/noop/BUILD.bazel renamed to submitqueue/extension/buildrunner/fake/BUILD.bazel

@@ -0,0 +1,143 @@
+// Copyright (c) 2025 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 fake provides a buildrunner.BuildRunner whose outcome is driven by the
+// triggered changes. With no marker every build immediately succeeds, behaving
+// as a best-case stub for wiring and baselines. A failure can be injected
+// end-to-end (e.g. from an e2e land request) by embedding a marker token in a
+// head change URI of the form "sq-fake=<token>":
+//
+//	sq-fake=build-fail  -> Status reports BuildStatusFailed
+//	sq-fake=build-error -> Status returns a non-nil error
+//
+// Because the contract reports a build's result via Status (which receives only
+// a BuildID), the runner records the desired outcome per build ID at Trigger
+// time and looks it up at Status time. This lets a single running stack exercise
+// negative paths purely by varying request payloads. It is intended for examples
+// and tests only, never production.
+package fake
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"github.com/uber/submitqueue/submitqueue/entity"
+	"github.com/uber/submitqueue/submitqueue/extension/buildrunner"
+)
+
+// Recognized marker tokens. See the package doc for the convention.
+const (
+	tokenFail  = "build-fail"
+	tokenError = "build-error"
+)
+
+// outcome is the result a build will report at Status time, decided from the
+// head changes at Trigger time.
+type outcome int
+
+const (
+	outcomeSucceeded outcome = iota
+	outcomeFailed
+	outcomeError
+)
+
+// runner is a buildrunner.BuildRunner that reports every build as succeeded
+// unless a marker token in a head change URI requests otherwise. The desired
+// outcome is recorded per build ID at Trigger and read back at Status. The
+// atomic counter hands out unique build IDs; the mutex guards the outcome map.
+type runner struct {
+	counter  atomic.Uint64
+	mu       sync.Mutex
+	outcomes map[string]outcome
+}
+
+// New returns a buildrunner.BuildRunner that defaults to succeeding and honors
+// marker tokens embedded in head change URIs.
+func New() buildrunner.BuildRunner {
+	return &runner{outcomes: make(map[string]outcome)}
+}
+
+// Trigger records the desired outcome for a new build (decided from a marker
+// token in the head changes) and returns its unique build ID. The base changes
+// and metadata are ignored.
+func (r *runner) Trigger(_ context.Context, _ []entity.Change, head []entity.Change, _ entity.BuildMetadata) (entity.BuildID, error) {
+	o := outcomeSucceeded
+	switch markerToken(head) {
+	case tokenFail:
+		o = outcomeFailed
+	case tokenError:
+		o = outcomeError
+	}
+
+	id := fmt.Sprintf("fake-%d", r.counter.Add(1))
+	r.mu.Lock()
+	r.outcomes[id] = o
+	r.mu.Unlock()
+	return entity.BuildID{ID: id}, nil
+}
+
+// Status returns the outcome recorded for the build at Trigger time. Unknown
+// build IDs default to succeeded, keeping the runner best-case for builds it did
+// not create.
+func (r *runner) Status(_ context.Context, buildID entity.BuildID) (entity.BuildStatus, entity.BuildMetadata, error) {
+	r.mu.Lock()
+	o := r.outcomes[buildID.ID]
+	r.mu.Unlock()
+
+	switch o {
+	case outcomeFailed:
+		return entity.BuildStatusFailed, nil, nil
+	case outcomeError:
+		return entity.BuildStatusUnknown, nil, fmt.Errorf("fake: marked build error")
+	default:
+		return entity.BuildStatusSucceeded, nil, nil
+	}
+}
+
+// Cancel is a no-op and always succeeds.
+func (r *runner) Cancel(_ context.Context, _ entity.BuildID) error {
+	return nil
+}
+
+// markerToken returns the first marker token found across all changes' URIs,
+// or "" if none carry one.
+func markerToken(changes []entity.Change) string {
+	for _, change := range changes {
+		if tok := fakeToken(change.URIs); tok != "" {
+			return tok
+		}
+	}
+	return ""
+}
+
+// markerPrefix introduces a marker token in a change URI: "sq-fake=<token>".
+const markerPrefix = "sq-fake="
+
+// fakeToken returns the marker token embedded in the first URI that carries
+// one, or "" if none do. The token ends at the first "&" or "#" delimiter.
+func fakeToken(uris []string) string {
+	for _, u := range uris {
+		if i := strings.Index(u, markerPrefix); i >= 0 {
+			rest := u[i+len(markerPrefix):]
+			if j := strings.IndexAny(rest, "&#"); j >= 0 {
+				rest = rest[:j]
+			}
+			return rest
+		}
+	}
+	return ""
+}

submitqueue/extension/buildrunner/fake/fake.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package noop
+package fake
 
 import (
 	"context"
@@ -28,34 +28,70 @@ func TestNew_ImplementsInterface(t *testing.T) {
 	var _ buildrunner.BuildRunner = New()
 }
 
-func TestRunner_Trigger(t *testing.T) {
+func TestRunner_Trigger_UniqueIDs(t *testing.T) {
 	r := New()
 	ctx := context.Background()
 
-	id1, err := r.Trigger(ctx,
-		[]entity.Change{{URIs: []string{"github://owner/repo/pull/1"}}},
-		[]entity.Change{{URIs: []string{"github://owner/repo/pull/2"}}},
-		entity.BuildMetadata{"requester": "alice"},
-	)
+	id1, err := r.Trigger(ctx, nil, []entity.Change{{URIs: []string{"github://o/r/pull/1/a"}}}, nil)
 	require.NoError(t, err)
 	assert.NotEmpty(t, id1.ID)
 
-	// IDs are unique across calls, even with empty inputs.
 	id2, err := r.Trigger(ctx, nil, nil, nil)
 	require.NoError(t, err)
 	assert.NotEqual(t, id1, id2)
 }
 
 func TestRunner_Status(t *testing.T) {
-	r := New()
+	ctx := context.Background()
+
+	tests := []struct {
+		name       string
+		headURIs   []string
+		wantStatus entity.BuildStatus
+		wantErr    bool
+	}{
+		{
+			name:       "no marker succeeds",
+			headURIs:   []string{"github://o/r/pull/1/a"},
+			wantStatus: entity.BuildStatusSucceeded,
+		},
+		{
+			name:       "build-fail marker fails",
+			headURIs:   []string{"github://o/r/pull/1/a?sq-fake=build-fail"},
+			wantStatus: entity.BuildStatusFailed,
+		},
+		{
+			name:     "build-error marker errors",
+			headURIs: []string{"github://o/r/pull/1/a?sq-fake=build-error"},
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := New()
+			id, err := r.Trigger(ctx, nil, []entity.Change{{URIs: tt.headURIs}}, nil)
+			require.NoError(t, err)
 
-	status, meta, err := r.Status(context.Background(), entity.BuildID{ID: "any-id"})
+			status, _, err := r.Status(ctx, id)
+			if tt.wantErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, tt.wantStatus, status)
+		})
+	}
+}
+
+func TestRunner_Status_UnknownBuildSucceeds(t *testing.T) {
+	r := New()
+	status, _, err := r.Status(context.Background(), entity.BuildID{ID: "never-triggered"})
 	require.NoError(t, err)
 	assert.Equal(t, entity.BuildStatusSucceeded, status)
-	assert.Empty(t, meta)
 }
 
 func TestRunner_Cancel(t *testing.T) {
 	r := New()
-	assert.NoError(t, r.Cancel(context.Background(), entity.BuildID{ID: "any-id"}))
+	assert.NoError(t, r.Cancel(context.Background(), entity.BuildID{ID: "any"}))
 }

…/extension/buildrunner/noop/noop_test.go …/extension/buildrunner/fake/fake_test.gosubmitqueue/extension/buildrunner/noop/noop_test.go renamed to submitqueue/extension/buildrunner/fake/fake_test.go submitqueue/extension/buildrunner/noop/noop_test.go renamed to submitqueue/extension/buildrunner/fake/fake_test.go

@@ -0,0 +1,24 @@
+load("@rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "fake",
+    srcs = ["fake.go"],
+    importpath = "github.com/uber/submitqueue/submitqueue/extension/changeprovider/fake",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//submitqueue/entity",
+        "//submitqueue/extension/changeprovider",
+    ],
+)
+
+go_test(
+    name = "fake_test",
+    srcs = ["fake_test.go"],
+    embed = [":fake"],
+    deps = [
+        "//submitqueue/entity",
+        "//submitqueue/extension/changeprovider",
+        "@com_github_stretchr_testify//assert",
+        "@com_github_stretchr_testify//require",
+    ],
+)