feat(runway): git merger SQUASH_REBASE and MERGE

## Summary

### Why?

The git merger landed with REBASE only. `SQUASH_REBASE` and `MERGE` are part of the wire contract SubmitQueue already publishes against, and until they apply here a request naming either is rejected as an invalid request. This adds the two transforming strategies on top of the shared apply machinery.

### What?

**SQUASH_REBASE** applies the step exactly like REBASE — cherry-picking each URI's head commit onto the tip — then collapses the commits the step produced into a single commit. The squash unit is the step, not the request: a multi-step request still lands one commit per step.

Two degenerate cases produce no output rather than an empty commit. If every change in the step was already present the picks moved HEAD nowhere, so there is nothing to squash. If the picks did create commits but their net tree matches the base, the squashed result would be empty, so the intermediates are dropped and the step reports no output. Both keep redelivery idempotent.

**MERGE** creates a `--no-ff` merge commit per URI, which keeps the original commit hashes reachable through second-parent history — the difference that matters versus REBASE, where cherry-picking rewrites them. A SHA already contained in HEAD is skipped rather than merged again. A merge that conflicts aborts the in-progress merge before returning `ErrConflict`, leaving the checkout usable for the next request.

Both strategies join the existing dispatch and inherit the reset/apply/push cycle, contention retry, and dry-run discard unchanged. `isConcreteStrategy` now admits them; PROMOTE remains rejected until the next change in the stack.

Restores `isAncestor` (containment checks for MERGE) and adds `squashMessage`, which synthesizes the squash commit message from the step id and the PRs named by its URIs — only SHAs are on the wire, so there is no upstream message to carry over.

## Test Plan

✅ `bazel test //runway/extension/merger/...` — 2/2 pass (git suite 24.7s)

New cases: SQUASH_REBASE collapsing two stacked URIs into one output, SQUASH_REBASE over an already-landed change producing none, MERGE creating a merge commit for a fresh change, MERGE skipping a SHA already an ancestor of the tip, and the MERGE dry-run path.

Author: behinddwalls

runway/extension/merger/git/README.md

@@ -13,9 +13,11 @@ The URI carries only the head commit SHA — no base and no commit range. A chan
 | Strategy | What it does | Outputs |
 |---|---|---|
 | `REBASE` | Cherry-picks each URI's head commit onto the tip, in order. A pick already present on the target is rebased out (reported, no output); an empty pick is rolled back. | one revision per newly-created commit |
+| `SQUASH_REBASE` | Applies the step like `REBASE`, then collapses the resulting commits into a single commit (squash unit = the step). | one revision, or none when the step is entirely already-present |
+| `MERGE` | Creates a `--no-ff` merge commit per URI, preserving the original commit hashes in second-parent history. A commit already contained in the tip is skipped. | the merge-commit revision(s) |
 | `DEFAULT` | Resolved to the instance's configured default strategy before any step runs. | per the resolved strategy |
 
-`REBASE` is the only strategy implemented so far. `SQUASH_REBASE`, `MERGE`, and `PROMOTE` are defined by the wire contract but not yet applied here — a step naming one is rejected as an invalid request.
+`PROMOTE` is defined by the wire contract but not yet applied here — a step naming it is rejected as an invalid request.
 
 ## Committing, dry-run, atomicity, contention
 
@@ -29,6 +31,6 @@ A merge conflict surfaces as `merger.ErrConflict`; an unusable request (unsuppor
 
 ## Runtime and identity
 
-Every git invocation uses the pinned runtime (explicit executable, exec-path, and template dir) and a scrubbed environment: no ambient configuration, no system or global git config, no interactive prompts. Because that leaves no ambient identity, the committer name and email are injected per-invocation, which the commit-creating `REBASE` strategy requires.
+Every git invocation uses the pinned runtime (explicit executable, exec-path, and template dir) and a scrubbed environment: no ambient configuration, no system or global git config, no interactive prompts. Because that leaves no ambient identity, the committer name and email are injected per-invocation, which the commit-creating strategies (`REBASE`, `SQUASH_REBASE`, `MERGE`) require.
 
 Object availability relies on `git fetch <remote>` making the referenced SHAs reachable through the remote's refs. A deployment whose head commits live only under non-fetched refs (for example GitHub `refs/pull/*`) must arrange for those objects to be fetchable.

runway/extension/merger/git/git_merger.go

@@ -19,11 +19,15 @@
 // Strategy → git operation:
 //
 //   - REBASE:        cherry-pick each URI's head commit onto the target tip.
+//   - SQUASH_REBASE: cherry-pick the step's changes, then collapse them into a
+//     single commit (squash unit = the step).
+//   - MERGE:         create a --no-ff merge commit per URI, preserving the
+//     original commit hashes in second-parent history.
 //   - DEFAULT:       resolved to the instance's configured DefaultStrategy
 //     before any step runs.
 //
-// REBASE is the only strategy implemented so far. A step naming any other
-// strategy is rejected as merger.ErrInvalidRequest until its apply path lands.
+// PROMOTE is not implemented yet; a step naming it is rejected as
+// merger.ErrInvalidRequest until its apply path lands.
 //
 // Atomicity: for a committing merge nothing reaches the remote until the final
 // push. A step that fails to apply aborts the in-progress git operation and
@@ -73,8 +77,8 @@ const defaultMaxPushAttempts = 10
 
 // Default committer identity used when Params leaves it unset. The scrubbed
 // environment (GIT_CONFIG_NOSYSTEM, GIT_CONFIG_GLOBAL=/dev/null) leaves no
-// ambient identity, so the commit-creating REBASE strategy needs one supplied
-// explicitly.
+// ambient identity, so commit-creating strategies (REBASE/SQUASH_REBASE/MERGE)
+// need one supplied explicitly.
 const (
 	defaultCommitterName  = "SubmitQueue Runway"
 	defaultCommitterEmail = "runway@submitqueue.invalid"
@@ -102,7 +106,7 @@ type Params struct {
 	// Target is the destination branch ref on the remote (e.g. "main").
 	Target string
 	// DefaultStrategy resolves a step whose strategy is DEFAULT. Must be a
-	// concrete strategy (currently only REBASE).
+	// concrete strategy (REBASE, SQUASH_REBASE, or MERGE).
 	DefaultStrategy mergestrategypb.Strategy
 	// Runtime is the pinned Git runtime used for every invocation.
 	Runtime GitRuntime
@@ -156,7 +160,7 @@ func NewMerger(params Params) (merger.Merger, error) {
 		return nil, err
 	}
 	if !isConcreteStrategy(params.DefaultStrategy) {
-		return nil, fmt.Errorf("default strategy must be concrete (currently only REBASE), got %v", params.DefaultStrategy)
+		return nil, fmt.Errorf("default strategy must be concrete (REBASE, SQUASH_REBASE, or MERGE), got %v", params.DefaultStrategy)
 	}
 	maxAttempts := params.MaxPushAttempts
 	if maxAttempts <= 0 {
@@ -276,7 +280,8 @@ func (m *gitMerger) resolveAndValidate(req *runwaymq.MergeRequest) ([]resolvedSt
 }
 
 // applyTransforming runs the reset/apply/push cycle for the transforming
-// strategies, retrying on remote contention when committing. For a dry run it applies the steps locally then discards them.
+// strategies (REBASE, SQUASH_REBASE, MERGE), retrying on remote contention when
+// committing. For a dry run it applies the steps locally then discards them.
 func (m *gitMerger) applyTransforming(ctx context.Context, req *runwaymq.MergeRequest, steps []resolvedStep, commit bool) (*runwaymq.MergeResult, error) {
 	var lastErr error
 	for attempt := 1; attempt <= m.maxPushAttempts; attempt++ {
@@ -372,6 +377,10 @@ func (m *gitMerger) applySteps(ctx context.Context, steps []resolvedStep) ([]*ru
 		switch rs.strategy {
 		case mergestrategypb.Strategy_REBASE:
 			outputs, err = m.applyRebase(ctx, rs.step)
+		case mergestrategypb.Strategy_SQUASH_REBASE:
+			outputs, err = m.applySquashRebase(ctx, rs.step)
+		case mergestrategypb.Strategy_MERGE:
+			outputs, err = m.applyMerge(ctx, rs.step)
 		default:
 			// resolveAndValidate rejects anything else; defensive.
 			return nil, fmt.Errorf("%w: unsupported strategy %v", merger.ErrInvalidRequest, rs.strategy)
@@ -394,6 +403,92 @@ func (m *gitMerger) applyRebase(ctx context.Context, step *runwaymq.MergeStep) (
 	return toOutputs(picked), nil
 }
 
+// applySquashRebase cherry-picks the step's changes like REBASE, then collapses
+// the resulting commits into a single squashed commit (squash unit = the step).
+// A step whose changes are all already present, or whose net change is empty,
+// produces no output.
+func (m *gitMerger) applySquashRebase(ctx context.Context, step *runwaymq.MergeStep) ([]*runwaymq.StepOutput, error) {
+	preSHA, err := m.headSHA(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := m.pickStepChanges(ctx, step); err != nil {
+		return nil, err
+	}
+	postSHA, err := m.headSHA(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if postSHA == preSHA {
+		// Every change was already present; nothing to squash.
+		return nil, nil
+	}
+
+	// If the picks produced commits but their net tree matches the base, the
+	// squashed result would be empty — drop the intermediates, no output.
+	preTree, err := m.commitTreeSHA(ctx, preSHA)
+	if err != nil {
+		return nil, err
+	}
+	postTree, err := m.commitTreeSHA(ctx, postSHA)
+	if err != nil {
+		return nil, err
+	}
+	if preTree == postTree {
+		if _, err := m.run(ctx, nil, "reset", "--hard", preSHA); err != nil {
+			return nil, fmt.Errorf("git reset --hard %s after empty squash: %w", preSHA, err)
+		}
+		return nil, nil
+	}
+
+	if _, err := m.run(ctx, nil, "reset", "--soft", preSHA); err != nil {
+		return nil, fmt.Errorf("git reset --soft %s: %w", preSHA, err)
+	}
+	if _, err := m.run(ctx, nil, "commit", "-m", squashMessage(step)); err != nil {
+		return nil, fmt.Errorf("git commit (squash): %w", err)
+	}
+	sha, err := m.headSHA(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return []*runwaymq.StepOutput{{Id: sha}}, nil
+}
+
+// applyMerge creates a --no-ff merge commit for the head SHA of every URI of
+// every change in the step, preserving the original commit hashes in
+// second-parent history. A SHA already contained in HEAD produces no output.
+func (m *gitMerger) applyMerge(ctx context.Context, step *runwaymq.MergeStep) ([]*runwaymq.StepOutput, error) {
+	var outputs []*runwaymq.StepOutput
+	for _, uri := range step.GetChange().GetUris() {
+		cid, err := entitygithub.ParseChangeID(uri)
+		if err != nil {
+			return nil, fmt.Errorf("%w: invalid change URI %q: %v", merger.ErrInvalidRequest, uri, err)
+		}
+		sha := cid.HeadCommitSHA
+
+		contained, err := m.isAncestor(ctx, sha, "HEAD")
+		if err != nil {
+			return nil, err
+		}
+		if contained {
+			continue
+		}
+
+		out, err := m.runCombined(ctx, nil, "merge", "--no-ff", "--no-edit", sha)
+		if err != nil {
+			_, _ = m.run(ctx, nil, "merge", "--abort")
+			coremetrics.NamedCounter(m.metricsScope, "merge", "merge_conflicts", 1)
+			return nil, fmt.Errorf("%w: git merge %s: %s", merger.ErrConflict, sha, strings.TrimSpace(string(out)))
+		}
+		mergeSHA, err := m.headSHA(ctx)
+		if err != nil {
+			return nil, err
+		}
+		outputs = append(outputs, &runwaymq.StepOutput{Id: mergeSHA})
+	}
+	return outputs, nil
+}
+
 // pickStepChanges cherry-picks the head SHA of every URI of every change in the
 // step, in order, returning the new commit SHAs (empty for picks that were
 // no-ops because the content is already on the target).
@@ -494,6 +589,24 @@ func (m *gitMerger) refetchTipSHA(ctx context.Context) (string, error) {
 	return strings.TrimSpace(string(out)), nil
 }
 
+// isAncestor reports whether ancestor is an ancestor of (or equal to)
+// descendant. `git merge-base --is-ancestor` exits 0 for true, 1 for false;
+// any other exit is a real error.
+func (m *gitMerger) isAncestor(ctx context.Context, ancestor, descendant string) (bool, error) {
+	cmd := m.command(ctx, "merge-base", "--is-ancestor", ancestor, descendant)
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	if err == nil {
+		return true, nil
+	}
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 {
+		return false, nil
+	}
+	return false, fmt.Errorf("git merge-base --is-ancestor %s %s: %w: %s", ancestor, descendant, err, strings.TrimSpace(stderr.String()))
+}
+
 // isEmptyHEADCommit returns true when HEAD's tree matches HEAD^'s tree — i.e.
 // the most recent commit introduces no changes.
 func (m *gitMerger) isEmptyHEADCommit(ctx context.Context) (bool, error) {
@@ -601,12 +714,13 @@ func newGitCommand(ctx context.Context, runtime GitRuntime, dir string, args ...
 }
 
 // isConcreteStrategy reports whether s names a concrete integration strategy
-// (i.e. not DEFAULT and not an unknown value). Only REBASE is implemented so
-// far; the remaining strategies are rejected as invalid requests until their
-// apply paths land.
+// (i.e. not DEFAULT and not an unknown value). PROMOTE is not implemented yet
+// and is rejected as an invalid request until its apply path lands.
 func isConcreteStrategy(s mergestrategypb.Strategy) bool {
 	switch s {
-	case mergestrategypb.Strategy_REBASE:
+	case mergestrategypb.Strategy_REBASE,
+		mergestrategypb.Strategy_SQUASH_REBASE,
+		mergestrategypb.Strategy_MERGE:
 		return true
 	default:
 		return false
@@ -621,6 +735,21 @@ func isRedundantCherryPick(out []byte) bool {
 		strings.Contains(s, "nothing to commit")
 }
 
+// squashMessage synthesizes a commit message for a squashed step, referencing
+// the step id and the PRs of its changes (only SHAs are available on the wire).
+func squashMessage(step *runwaymq.MergeStep) string {
+	var prs []string
+	for _, uri := range step.GetChange().GetUris() {
+		if cid, err := entitygithub.ParseChangeID(uri); err == nil {
+			prs = append(prs, fmt.Sprintf("%s#%d", cid.OwnerRepo(), cid.PRNumber))
+		}
+	}
+	if step.GetStepId() != "" {
+		return fmt.Sprintf("squash: %s (%s)", step.GetStepId(), strings.Join(prs, ", "))
+	}
+	return fmt.Sprintf("squash: %s", strings.Join(prs, ", "))
+}
+
 // toOutputs wraps commit SHAs as StepOutputs in order.
 func toOutputs(shas []string) []*runwaymq.StepOutput {
 	if len(shas) == 0 {

runway/extension/merger/git/git_merger_test.go

@@ -352,6 +352,77 @@ func TestMerge_Rebase_GivesUpAfterMaxAttempts(t *testing.T) {
 	assert.Equal(t, raceSHAs[1], f.remoteHEAD(t))
 }
 
+// --- SQUASH_REBASE ---
+
+func TestMerge_SquashRebase_TwoStackedURIsOneOutput(t *testing.T) {
+	f := setupGitFixture(t)
+	sha1, sha2 := f.pushStack(t)
+
+	m := f.newMerger(t, mergestrategypb.Strategy_REBASE)
+	res, err := m.Merge(context.Background(), req("b",
+		stepOf(mergestrategypb.Strategy_SQUASH_REBASE, "s1", uri(sha1), uri(sha2)),
+	))
+	require.NoError(t, err)
+	assert.Equal(t, runwaypb.Outcome_SUCCEEDED, res.GetOutcome())
+	require.Len(t, res.GetSteps(), 1)
+	require.Len(t, res.GetSteps()[0].GetOutputs(), 1, "the two picks collapse to a single squashed commit")
+
+	commits := f.remoteCommitsSinceSeed(t)
+	require.Len(t, commits, 1, "exactly one new commit on the remote")
+	assert.Equal(t, res.GetSteps()[0].GetOutputs()[0].GetId(), commits[0])
+	assert.Equal(t, "hello\nearth\ngoodbye\n", f.remoteFile(t, "hello.txt"))
+}
+
+func TestMerge_SquashRebase_AlreadyLanded(t *testing.T) {
+	f := setupGitFixture(t)
+	sha := f.pushPRCommit(t, "feature/a", "hello.txt", "hello\nearth\n", "tweak hello")
+	f.landOnMain(t, sha)
+	mainBefore := f.remoteHEAD(t)
+
+	m := f.newMerger(t, mergestrategypb.Strategy_REBASE)
+	res, err := m.Merge(context.Background(), req("b", stepOf(mergestrategypb.Strategy_SQUASH_REBASE, "s1", uri(sha))))
+	require.NoError(t, err)
+	require.Len(t, res.GetSteps(), 1)
+	assert.Empty(t, res.GetSteps()[0].GetOutputs())
+	assert.Equal(t, mainBefore, f.remoteHEAD(t))
+}
+
+// --- MERGE ---
+
+func TestMerge_Merge_FreshChangeCreatesMergeCommit(t *testing.T) {
+	f := setupGitFixture(t)
+	freshSHA := f.pushPRCommit(t, "feature/a", "hello.txt", "hello\nearth\n", "tweak hello")
+
+	m := f.newMerger(t, mergestrategypb.Strategy_REBASE)
+	res, err := m.Merge(context.Background(), req("b", stepOf(mergestrategypb.Strategy_MERGE, "s1", uri(freshSHA))))
+	require.NoError(t, err)
+	assert.Equal(t, runwaypb.Outcome_SUCCEEDED, res.GetOutcome())
+	require.Len(t, res.GetSteps(), 1)
+	require.Len(t, res.GetSteps()[0].GetOutputs(), 1)
+
+	mergeSHA := res.GetSteps()[0].GetOutputs()[0].GetId()
+	assert.Equal(t, mergeSHA, f.remoteHEAD(t))
+	assert.Len(t, f.parents(t, mergeSHA), 2, "a --no-ff merge commit has two parents")
+	assert.Contains(t, f.parents(t, mergeSHA), freshSHA,
+		"the original head commit is preserved as the merge's second parent")
+}
+
+func TestMerge_Merge_AlreadyAncestor(t *testing.T) {
+	f := setupGitFixture(t)
+	freshSHA := f.pushPRCommit(t, "feature/a", "hello.txt", "hello\nearth\n", "tweak hello")
+	f.advanceMain(t, freshSHA) // fast-forward main directly to freshSHA
+	mainBefore := f.remoteHEAD(t)
+
+	m := f.newMerger(t, mergestrategypb.Strategy_REBASE)
+	res, err := m.Merge(context.Background(), req("b", stepOf(mergestrategypb.Strategy_MERGE, "s1", uri(freshSHA))))
+	require.NoError(t, err)
+	require.Len(t, res.GetSteps(), 1)
+	assert.Empty(t, res.GetSteps()[0].GetOutputs())
+	assert.Equal(t, mainBefore, f.remoteHEAD(t))
+}
+
+// --- PROMOTE ---
+
 func TestMerge_Default_ResolvesToRebase(t *testing.T) {
 	f := setupGitFixture(t)
 	sha := f.pushPRCommit(t, "feature/a", "hello.txt", "hello\nearth\n", "tweak hello")
@@ -378,7 +449,7 @@ func TestMerge_InvalidRequests(t *testing.T) {
 		},
 		{
 			name: "unsupported strategy",
-			req:  req("b", stepOf(mergestrategypb.Strategy_MERGE, "s1", uri(fakeSHA))),
+			req:  req("b", stepOf(mergestrategypb.Strategy_PROMOTE, "s1", uri(fakeSHA))),
 		},
 		{
 			name: "malformed URI",
@@ -413,6 +484,20 @@ func TestCheckMergeability_RebaseMergeable(t *testing.T) {
 	assert.Equal(t, mainBefore, f.remoteHEAD(t), "a dry run does not advance the remote tip")
 }
 
+func TestCheckMergeability_MergeMergeable(t *testing.T) {
+	f := setupGitFixture(t)
+	sha := f.pushPRCommit(t, "feature/a", "hello.txt", "hello\nearth\n", "tweak hello")
+	mainBefore := f.remoteHEAD(t)
+
+	m := f.newMerger(t, mergestrategypb.Strategy_REBASE)
+	res, err := m.CheckMergeability(context.Background(), req("b", stepOf(mergestrategypb.Strategy_MERGE, "s1", uri(sha))))
+	require.NoError(t, err)
+	assert.Equal(t, runwaypb.Outcome_SUCCEEDED, res.GetOutcome())
+	require.Len(t, res.GetSteps(), 1)
+	assert.Empty(t, res.GetSteps()[0].GetOutputs())
+	assert.Equal(t, mainBefore, f.remoteHEAD(t))
+}
+
 func TestCheckMergeability_Conflict(t *testing.T) {
 	f := setupGitFixture(t)
 	mainBefore, conflictingSHA := f.setupConflict(t)