#23 feat(merge): mr ready, passing checks to merge, mr:force-merge and --ignore-checks · ermite


@@ -161,7 +161,7 @@ func TestMRPanelsAndMenus(t *testing.T) {
161	161		assert.NotContains(t, rail, text)
162	162		}
163	163		more := renderToString(t, moreMenu(p))
164		-	for _, text := range []string{"Merge settings", "squash, merge", "failing ones block", `id="mr-signing"`, "fingerprint", "ermite signing-key show"} {
	164	+	for _, text := range []string{"Merge settings", "squash, merge", "failing or unfinished checks block", `id="mr-signing"`, "fingerprint", "ermite signing-key show"} {
165	165		assert.Contains(t, more, text)
166	166		}
167	167		merge := renderToString(t, mergeMenu(p))

@@ -297,3 +297,37 @@ func TestAutoMergeLiveEvents(t *testing.T) {
297	297		assert.True(t, liveEvent(watchOf(domain.MergeRequestAutoMergeEnabled{})))
298	298		assert.True(t, liveEvent(watchOf(domain.MergeRequestAutoMergeCancelled{})))
299	299		}
	300	+
	301	+	func TestMergeIgnoreChecks(t *testing.T) {
	302	+	t.Parallel()
	303	+	for _, kind := range []string{"bad", "running", "ok", ""} {
	304	+	t.Run(kind, func(t *testing.T) {
	305	+	t.Parallel()
	306	+	box := (&Server{}).mergeBox(&repoData{repo: repoWithModes(domain.MergeModes()...)}, 3, "feat", "abc", true, mergeabilityView(domain.Mergeability{State: domain.MergeabilityUpToDate}, "main"))
	307	+	html := renderToString(t, mergeMenu(MRPage{Box: box, ChecksSum: ChecksSummary{Kind: kind}}))
	308	+	if kind == "bad" \|\| kind == "running" {
	309	+	assert.Contains(t, html, `name="ignore_checks"`)
	310	+	assert.Contains(t, html, "Ignore checks")
	311	+	} else {
	312	+	assert.NotContains(t, html, `name="ignore_checks"`)
	313	+	}
	314	+	assert.True(t, box.CanMerge())
	315	+	})
	316	+	}
	317	+	name, err := domain.ParseRepoName("demo")
	318	+	require.NoError(t, err)
	319	+	head, err := domain.ParseObjectID(strings.Repeat("a", domain.ObjectIDLen))
	320	+	require.NoError(t, err)
	321	+	for _, ignore := range []bool{false, true} {
	322	+	svc := mocks.NewMergeRequestService(t)
	323	+	svc.EXPECT().Merge(mock.Anything, mock.Anything, name, int64(3), ports.MergeParams{Mode: domain.MergeModeSquash, HeadID: head, IgnoreChecks: ignore}).Return(ports.MergeResult{}, nil).Once()
	324	+	body := "mode=squash&head_id=" + head.String()
	325	+	if ignore {
	326	+	body += "&ignore_checks=on"
	327	+	}
	328	+	s := &Server{cfg: Config{MergeRequests: svc}}
	329	+	to, _, err := s.mrMerge(context.Background(), autoMergeRequest("/demo/merge-requests/3/merge", body))
	330	+	require.NoError(t, err)
	331	+	assert.Equal(t, mrHref("demo", 3), to)
	332	+	}
	333	+	}


@@ -161,7 +161,7 @@ func TestMRPanelsAndMenus(t *testing.T) {
161		assert.NotContains(t, rail, text)	161		assert.NotContains(t, rail, text)
162		}	162		}
163		more := renderToString(t, moreMenu(p))	163		more := renderToString(t, moreMenu(p))
164	-	for _, text := range []string{"Merge settings", "squash, merge", "failing ones block", `id="mr-signing"`, "fingerprint", "ermite signing-key show"} {	164	+	for _, text := range []string{"Merge settings", "squash, merge", "failing or unfinished checks block", `id="mr-signing"`, "fingerprint", "ermite signing-key show"} {
165		assert.Contains(t, more, text)	165		assert.Contains(t, more, text)
166		}	166		}
167		merge := renderToString(t, mergeMenu(p))	167		merge := renderToString(t, mergeMenu(p))

@@ -297,3 +297,37 @@ func TestAutoMergeLiveEvents(t *testing.T) {
297		assert.True(t, liveEvent(watchOf(domain.MergeRequestAutoMergeEnabled{})))	297		assert.True(t, liveEvent(watchOf(domain.MergeRequestAutoMergeEnabled{})))
298		assert.True(t, liveEvent(watchOf(domain.MergeRequestAutoMergeCancelled{})))	298		assert.True(t, liveEvent(watchOf(domain.MergeRequestAutoMergeCancelled{})))
299		}	299		}
			300	+
			301	+	func TestMergeIgnoreChecks(t *testing.T) {
			302	+	t.Parallel()
			303	+	for _, kind := range []string{"bad", "running", "ok", ""} {
			304	+	t.Run(kind, func(t *testing.T) {
			305	+	t.Parallel()
			306	+	box := (&Server{}).mergeBox(&repoData{repo: repoWithModes(domain.MergeModes()...)}, 3, "feat", "abc", true, mergeabilityView(domain.Mergeability{State: domain.MergeabilityUpToDate}, "main"))
			307	+	html := renderToString(t, mergeMenu(MRPage{Box: box, ChecksSum: ChecksSummary{Kind: kind}}))
			308	+	if kind == "bad" \|\| kind == "running" {
			309	+	assert.Contains(t, html, `name="ignore_checks"`)
			310	+	assert.Contains(t, html, "Ignore checks")
			311	+	} else {
			312	+	assert.NotContains(t, html, `name="ignore_checks"`)
			313	+	}
			314	+	assert.True(t, box.CanMerge())
			315	+	})
			316	+	}
			317	+	name, err := domain.ParseRepoName("demo")
			318	+	require.NoError(t, err)
			319	+	head, err := domain.ParseObjectID(strings.Repeat("a", domain.ObjectIDLen))
			320	+	require.NoError(t, err)
			321	+	for _, ignore := range []bool{false, true} {
			322	+	svc := mocks.NewMergeRequestService(t)
			323	+	svc.EXPECT().Merge(mock.Anything, mock.Anything, name, int64(3), ports.MergeParams{Mode: domain.MergeModeSquash, HeadID: head, IgnoreChecks: ignore}).Return(ports.MergeResult{}, nil).Once()
			324	+	body := "mode=squash&head_id=" + head.String()
			325	+	if ignore {
			326	+	body += "&ignore_checks=on"
			327	+	}
			328	+	s := &Server{cfg: Config{MergeRequests: svc}}
			329	+	to, _, err := s.mrMerge(context.Background(), autoMergeRequest("/demo/merge-requests/3/merge", body))
			330	+	require.NoError(t, err)
			331	+	assert.Equal(t, mrHref("demo", 3), to)
			332	+	}
			333	+	}

M internal/adapters/web/static/js/ermite.js +7 -0


@@ -966,6 +966,13 @@ window.ermiteLive = (() => {
966	966		continue;
967	967		}
968	968		if (old.hasAttribute('data-cursor')) el.setAttribute('data-cursor', '');
	969	+	// data-keep-checks: the checkboxes the user ticked stay ticked.
	970	+	if (old.hasAttribute('data-keep-checks')) {
	971	+	for (const box of old.querySelectorAll('input[type=checkbox][name]:checked')) {
	972	+	const same = el.querySelector(`input[type=checkbox][name="${CSS.escape(box.name)}"]`);
	973	+	if (same) same.checked = true;
	974	+	}
	975	+	}
969	976		old.replaceWith(el);
970	977		const rows = document.getElementById('repo-rows');
971	978		if (rows && el.parentElement === rows && rows.dataset.sort === 'activity' &&


@@ -966,6 +966,13 @@ window.ermiteLive = (() => {
966	continue;	966		continue;
967	}	967		}
968	if (old.hasAttribute('data-cursor')) el.setAttribute('data-cursor', '');	968		if (old.hasAttribute('data-cursor')) el.setAttribute('data-cursor', '');
		969	+	// data-keep-checks: the checkboxes the user ticked stay ticked.
		970	+	if (old.hasAttribute('data-keep-checks')) {
		971	+	for (const box of old.querySelectorAll('input[type=checkbox][name]:checked')) {
		972	+	const same = el.querySelector(`input[type=checkbox][name="${CSS.escape(box.name)}"]`);
		973	+	if (same) same.checked = true;
		974	+	}
		975	+	}
969	old.replaceWith(el);	976		old.replaceWith(el);
970	const rows = document.getElementById('repo-rows');	977		const rows = document.getElementById('repo-rows');
971	if (rows && el.parentElement === rows && rows.dataset.sort === 'activity' &&	978		if (rows && el.parentElement === rows && rows.dataset.sort === 'activity' &&

M internal/adapters/web/summary_actions_test.go +53 -0


@@ -4,6 +4,7 @@ package web
4	4
5	5		import (
6	6		"bytes"
	7	+	"context"
7	8		"errors"
8	9		"strings"
9	10		"testing"

@@ -125,3 +126,55 @@ func TestRunUpdatedOnSummaryWhenCIIsNotReadable(t *testing.T) {
125	126		assert.Contains(t, got[0].html, "hidden", "the block empties and hides, no run leaks")
126	127		assert.NotContains(t, got[0].html, "rr-name")
127	128		}
	129	+
	130	+	func TestMRChecksLiveMergeControls(t *testing.T) {
	131	+	t.Parallel()
	132	+	repo := repoName(t, "proj")
	133	+	head := strings.Repeat("a", domain.ObjectIDLen)
	134	+	for _, kind := range []string{"bad", "running", "ok", ""} {
	135	+	t.Run(kind, func(t *testing.T) {
	136	+	t.Parallel()
	137	+	runs := mocks.NewRunService(t)
	138	+	var checks []ports.CheckView
	139	+	if kind != "" {
	140	+	check := domain.CICheck{Name: "ci", Status: domain.CICompleted, Conclusion: domain.CISuccess}
	141	+	if kind == "bad" {
	142	+	check.Conclusion = domain.CIFailure
	143	+	}
	144	+	if kind == "running" {
	145	+	check.Status, check.Conclusion = domain.CIQueued, ""
	146	+	}
	147	+	checks = []ports.CheckView{{CICheck: check}}
	148	+	}
	149	+	runs.EXPECT().ListChecks(mock.Anything, mock.Anything, repo, head).Return(ports.ChecksResult{Checks: checks}, nil)
	150	+	srv := newTestServer(t, Config{Repos: reposServing(t, publicRepo(t, "proj")), Browse: mocks.NewBrowseService(t), Runs: runs})
	151	+
	152	+	// A visitor's stream never carries the owner's merge form.
	153	+	visitor, err := (&liveStream{s: srv, repo: "proj", head: head, view: "mr"}).mrChecks(t.Context())
	154	+	require.NoError(t, err)
	155	+	require.Len(t, visitor, 2)
	156	+	for _, f := range visitor {
	157	+	assert.NotContains(t, f.html, `mr-merge-checks`)
	158	+	}
	159	+
	160	+	owner := context.WithValue(t.Context(), signedInKey{}, struct{}{})
	161	+	ls := &liveStream{s: srv, repo: "proj", head: head, view: "mr"}
	162	+	got, err := ls.mrChecks(owner)
	163	+	require.NoError(t, err)
	164	+	require.Len(t, got, 3)
	165	+	assert.Contains(t, got[2].html, `data-keep-checks`, "a swap keeps the ticked box")
	166	+	assert.Equal(t, "ci-run", got[2].event)
	167	+	assert.Contains(t, got[2].html, `id="mr-merge-checks"`)
	168	+	assert.Equal(t, renderToString(t, MRMergeChecks(checksSummary(repo, head, checks))), got[2].html)
	169	+	if kind == "bad" \|\| kind == "running" {
	170	+	assert.Contains(t, got[2].html, `name="ignore_checks"`)
	171	+	} else {
	172	+	assert.NotContains(t, got[2].html, `name="ignore_checks"`)
	173	+	}
	174	+	// An unrelated job event with identical checks must not reset the checkbox.
	175	+	got, err = ls.mrChecks(owner)
	176	+	require.NoError(t, err)
	177	+	require.Len(t, got, 2)
	178	+	})
	179	+	}
	180	+	}


@@ -4,6 +4,7 @@ package web
4		4
5	import (	5		import (
6	"bytes"	6		"bytes"
		7	+	"context"
7	"errors"	8		"errors"
8	"strings"	9		"strings"
9	"testing"	10		"testing"

@@ -125,3 +126,55 @@ func TestRunUpdatedOnSummaryWhenCIIsNotReadable(t *testing.T) {
125	assert.Contains(t, got[0].html, "hidden", "the block empties and hides, no run leaks")	126		assert.Contains(t, got[0].html, "hidden", "the block empties and hides, no run leaks")
126	assert.NotContains(t, got[0].html, "rr-name")	127		assert.NotContains(t, got[0].html, "rr-name")
127	}	128		}
		129	+
		130	+	func TestMRChecksLiveMergeControls(t *testing.T) {
		131	+	t.Parallel()
		132	+	repo := repoName(t, "proj")
		133	+	head := strings.Repeat("a", domain.ObjectIDLen)
		134	+	for _, kind := range []string{"bad", "running", "ok", ""} {
		135	+	t.Run(kind, func(t *testing.T) {
		136	+	t.Parallel()
		137	+	runs := mocks.NewRunService(t)
		138	+	var checks []ports.CheckView
		139	+	if kind != "" {
		140	+	check := domain.CICheck{Name: "ci", Status: domain.CICompleted, Conclusion: domain.CISuccess}
		141	+	if kind == "bad" {
		142	+	check.Conclusion = domain.CIFailure
		143	+	}
		144	+	if kind == "running" {
		145	+	check.Status, check.Conclusion = domain.CIQueued, ""
		146	+	}
		147	+	checks = []ports.CheckView{{CICheck: check}}
		148	+	}
		149	+	runs.EXPECT().ListChecks(mock.Anything, mock.Anything, repo, head).Return(ports.ChecksResult{Checks: checks}, nil)
		150	+	srv := newTestServer(t, Config{Repos: reposServing(t, publicRepo(t, "proj")), Browse: mocks.NewBrowseService(t), Runs: runs})
		151	+
		152	+	// A visitor's stream never carries the owner's merge form.
		153	+	visitor, err := (&liveStream{s: srv, repo: "proj", head: head, view: "mr"}).mrChecks(t.Context())
		154	+	require.NoError(t, err)
		155	+	require.Len(t, visitor, 2)
		156	+	for _, f := range visitor {
		157	+	assert.NotContains(t, f.html, `mr-merge-checks`)
		158	+	}
		159	+
		160	+	owner := context.WithValue(t.Context(), signedInKey{}, struct{}{})
		161	+	ls := &liveStream{s: srv, repo: "proj", head: head, view: "mr"}
		162	+	got, err := ls.mrChecks(owner)
		163	+	require.NoError(t, err)
		164	+	require.Len(t, got, 3)
		165	+	assert.Contains(t, got[2].html, `data-keep-checks`, "a swap keeps the ticked box")
		166	+	assert.Equal(t, "ci-run", got[2].event)
		167	+	assert.Contains(t, got[2].html, `id="mr-merge-checks"`)
		168	+	assert.Equal(t, renderToString(t, MRMergeChecks(checksSummary(repo, head, checks))), got[2].html)
		169	+	if kind == "bad" \|\| kind == "running" {
		170	+	assert.Contains(t, got[2].html, `name="ignore_checks"`)
		171	+	} else {
		172	+	assert.NotContains(t, got[2].html, `name="ignore_checks"`)
		173	+	}
		174	+	// An unrelated job event with identical checks must not reset the checkbox.
		175	+	got, err = ls.mrChecks(owner)
		176	+	require.NoError(t, err)
		177	+	require.Len(t, got, 2)
		178	+	})
		179	+	}
		180	+	}

M internal/app/api_test.go +1 -1


@@ -196,7 +196,7 @@ func TestAC2ReadAccess(t *testing.T) {
196	196		for _, who := range allPrincipals {
197	197		resp, err := r.who[who].server.GetVersion(ctx, connect.NewRequest(&pb.GetVersionRequest{}))
198	198		require.NoError(t, err, who)
199		-	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge"}, resp.Msg.GetFeatures(), who)
	199	+	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge", "merge_requests.ignore_checks", "merge_requests.ready"}, resp.Msg.GetFeatures(), who)
200	200		assert.NotEmpty(t, resp.Msg.GetVersion())
201	201		}
202	202		})


@@ -196,7 +196,7 @@ func TestAC2ReadAccess(t *testing.T) {
196		for _, who := range allPrincipals {	196		for _, who := range allPrincipals {
197		resp, err := r.who[who].server.GetVersion(ctx, connect.NewRequest(&pb.GetVersionRequest{}))	197		resp, err := r.who[who].server.GetVersion(ctx, connect.NewRequest(&pb.GetVersionRequest{}))
198		require.NoError(t, err, who)	198		require.NoError(t, err, who)
199	-	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge"}, resp.Msg.GetFeatures(), who)	199	+	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge", "merge_requests.ignore_checks", "merge_requests.ready"}, resp.Msg.GetFeatures(), who)
200		assert.NotEmpty(t, resp.Msg.GetVersion())	200		assert.NotEmpty(t, resp.Msg.GetVersion())
201		}	201		}
202		})	202		})

M internal/app/ci_e2e_test.go +3 -9


@@ -13,7 +13,6 @@ import (
13	13		"connectrpc.com/connect"
14	14		"github.com/stretchr/testify/assert"
15	15		"github.com/stretchr/testify/require"
16		-	"google.golang.org/protobuf/types/known/fieldmaskpb"
17	16		"google.golang.org/protobuf/types/known/timestamppb"
18	17
19	18		pb "bnema.dev/ermite-api/gen/ermite"

@@ -271,7 +270,7 @@ func TestCIPushRunsAWorkflowOnARunner(t *testing.T) {
271	270		}
272	271
273	272		// AC5: merge refused while checks are pending or failing, allowed when they
274		-	// pass, and when failing_checks_block is off.
	273	+	// pass, or when explicitly bypassed by an authorized caller.
275	274		func TestCIMergeIsBlockedByChecks(t *testing.T) {
276	275		c := newCIHarness(t, nil)
277	276		runner := c.registerRunner("alpha", "ubuntu-latest")

@@ -302,14 +301,9 @@ func TestCIMergeIsBlockedByChecks(t *testing.T) {
302	301		assert.Equal(t, connect.CodeFailedPrecondition, ciErrCode(err))
303	302		assert.Contains(t, err.Error(), "failing checks block the merge")
304	303
305		-	// Off: the merge goes through.
306		-	_, err = c.root.repo.UpdateRepo(c.ctx, connect.NewRequest(&pb.UpdateRepoRequest{
307		-	Repo: "proj",
308		-	Settings: &pb.RepoSettings{FailingChecksBlock: false},
309		-	UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"settings.failing_checks_block"}},
310		-	}))
	304	+	// An explicit override by root allows the merge despite failure.
	305	+	_, err = c.root.mr.MergeMergeRequest(c.ctx, connect.NewRequest(&pb.MergeMergeRequestRequest{Repo: "proj", Number: mr.Msg.GetMergeRequest().GetNumber(), HeadId: feat, IgnoreChecks: true}))
311	306		require.NoError(t, err)
312		-	require.NoError(t, merge())
313	307		}
314	308
315	309		// AC2: a job token works for its job only, and not once the job has ended.

 	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/types/known/fieldmaskpb"
 	"google.golang.org/protobuf/types/known/timestamppb"
 	pb "bnema.dev/ermite-api/gen/ermite"
 }
 // AC5: merge refused while checks are pending or failing, allowed when they
-// pass, and when failing_checks_block is off.
+// pass, or when explicitly bypassed by an authorized caller.
 func TestCIMergeIsBlockedByChecks(t *testing.T) {
 	c := newCIHarness(t, nil)
 	runner := c.registerRunner("alpha", "ubuntu-latest")
 	assert.Equal(t, connect.CodeFailedPrecondition, ciErrCode(err))
 	assert.Contains(t, err.Error(), "failing checks block the merge")
-	// Off: the merge goes through.
+	// An explicit override by root allows the merge despite failure.
-	_, err = c.root.repo.UpdateRepo(c.ctx, connect.NewRequest(&pb.UpdateRepoRequest{
+	_, err = c.root.mr.MergeMergeRequest(c.ctx, connect.NewRequest(&pb.MergeMergeRequestRequest{Repo: "proj", Number: mr.Msg.GetMergeRequest().GetNumber(), HeadId: feat, IgnoreChecks: true}))
-		Repo:       "proj",
-		Settings:   &pb.RepoSettings{FailingChecksBlock: false},
-		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"settings.failing_checks_block"}},
-	}))
 	require.NoError(t, err)
-	require.NoError(t, merge())
 }
 // AC2: a job token works for its job only, and not once the job has ended.

M internal/app/cli_e2e_test.go +2 -2


@@ -203,7 +203,7 @@ type eventOut struct {
203	203		MergeRequest *mrOut `json:"merge_request"`
204	204		}
205	205
206		-	var repoKeys = []string{"allow_auto_merge", "created_at", "default_branch", "description", "failing_checks_block", "issues", "merge_modes", "name", "pushed_at", "topics", "visibility"}
	206	+	var repoKeys = []string{"allow_auto_merge", "created_at", "default_branch", "description", "issues", "merge_modes", "name", "pushed_at", "topics", "visibility"}
207	207
208	208		// AC6: the CLI end to end against a real forge.
209	209		func TestAC6CLIEndToEnd(t *testing.T) {

@@ -350,7 +350,7 @@ func TestAC6CLIEndToEnd(t *testing.T) {
350	350		ver := decode[versionOut](t, res.stdout)
351	351		assert.Equal(t, c.url, ver.Server.URL)
352	352		assert.NotEmpty(t, ver.Server.Version)
353		-	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge"}, ver.Server.Features)
	353	+	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge", "merge_requests.ignore_checks", "merge_requests.ready"}, ver.Server.Features)
354	354		assert.Equal(t, []string{"passkeys"}, ver.Server.MissingFeatures)
355	355		stdout, stderr, code = c.bin(t, secret, "version")
356	356		require.Equal(t, 0, code, stderr)


@@ -203,7 +203,7 @@ type eventOut struct {
203		MergeRequest *mrOut `json:"merge_request"`	203		MergeRequest *mrOut `json:"merge_request"`
204		}	204		}
205			205
206	-	var repoKeys = []string{"allow_auto_merge", "created_at", "default_branch", "description", "failing_checks_block", "issues", "merge_modes", "name", "pushed_at", "topics", "visibility"}	206	+	var repoKeys = []string{"allow_auto_merge", "created_at", "default_branch", "description", "issues", "merge_modes", "name", "pushed_at", "topics", "visibility"}
207			207
208		// AC6: the CLI end to end against a real forge.	208		// AC6: the CLI end to end against a real forge.
209		func TestAC6CLIEndToEnd(t *testing.T) {	209		func TestAC6CLIEndToEnd(t *testing.T) {

@@ -350,7 +350,7 @@ func TestAC6CLIEndToEnd(t *testing.T) {
350		ver := decode[versionOut](t, res.stdout)	350		ver := decode[versionOut](t, res.stdout)
351		assert.Equal(t, c.url, ver.Server.URL)	351		assert.Equal(t, c.url, ver.Server.URL)
352		assert.NotEmpty(t, ver.Server.Version)	352		assert.NotEmpty(t, ver.Server.Version)
353	-	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge"}, ver.Server.Features)	353	+	assert.ElementsMatch(t, []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "issues", "issues.links", "merge_requests.mergeability", "signing_key", "session", "git.list_paths", "token.branch_prefixes", "ci.runs", "ci.runs.filters", "ci.runners", "ci.actions", "ci.annotations", "ci.summaries", "ci.concurrency", "ci.dispatch", "ci.workflows", "ci.cache", "ci.secrets", "ci.artifacts", "commit_signatures", "mirror", "merge_requests.auto_merge", "merge_requests.ignore_checks", "merge_requests.ready"}, ver.Server.Features)
354		assert.Equal(t, []string{"passkeys"}, ver.Server.MissingFeatures)	354		assert.Equal(t, []string{"passkeys"}, ver.Server.MissingFeatures)
355		stdout, stderr, code = c.bin(t, secret, "version")	355		stdout, stderr, code = c.bin(t, secret, "version")
356		require.Equal(t, 0, code, stderr)	356		require.Equal(t, 0, code, stderr)

M internal/app/cli_issue_test.go +1 -1


@@ -202,7 +202,7 @@ func TestRepoShowIssues(t *testing.T) {
202	202		}}
203	203		url := f.serve(t)
204	204		res := runCLI(t, envFor(url), "", "repo", "show", "alpha").ok(t)
205		-	assert.Contains(t, res.stdout, "issues owner\n")
	205	+	assert.Contains(t, res.stdout, "issues owner\n")
206	206		res = runCLI(t, envFor(url), "", "repo", "show", "alpha", "--json").ok(t)
207	207		assert.Contains(t, res.stdout, `"issues": "owner"`)
208	208		}


@@ -202,7 +202,7 @@ func TestRepoShowIssues(t *testing.T) {
202		}}	202		}}
203		url := f.serve(t)	203		url := f.serve(t)
204		res := runCLI(t, envFor(url), "", "repo", "show", "alpha").ok(t)	204		res := runCLI(t, envFor(url), "", "repo", "show", "alpha").ok(t)
205	-	assert.Contains(t, res.stdout, "issues owner\n")	205	+	assert.Contains(t, res.stdout, "issues owner\n")
206		res = runCLI(t, envFor(url), "", "repo", "show", "alpha", "--json").ok(t)	206		res = runCLI(t, envFor(url), "", "repo", "show", "alpha", "--json").ok(t)
207		assert.Contains(t, res.stdout, `"issues": "owner"`)	207		assert.Contains(t, res.stdout, `"issues": "owner"`)
208		}	208		}

M internal/app/cli_mr.go +45 -3


@@ -291,7 +291,7 @@ func newMRCmd(env cliEnv) cobra.Command {
291	291		}
292	292		mr.AddCommand(
293	293		newMRCreateCmd(env), newMRListCmd(env), newMRShowCmd(env), newMRCommentCmd(env),
294		-	newMRResolveCmd(env), newMREditCommentCmd(env), newMRDeleteCommentCmd(env), newMRMergeCmd(env), newMRCloseCmd(env),
	294	+	newMRResolveCmd(env), newMREditCommentCmd(env), newMRDeleteCommentCmd(env), newMRMergeCmd(env), newMRCloseCmd(env), newMRReadyCmd(env),
295	295		)
296	296		return mr
297	297		}

@@ -1085,7 +1085,7 @@ func newMRMergeCmd(env cliEnv) cobra.Command {
1085	1085		var mode string
1086	1086		var deleteBranch bool
1087	1087		var head string
1088		-	var auto, cancelAuto bool
	1088	+	var auto, cancelAuto, ignoreChecks bool
1089	1089		cmd := &cobra.Command{
1090	1090		Use: "merge <repo> <number>",
1091	1091		Short: "Merge a merge request",

@@ -1105,6 +1105,9 @@ func newMRMergeCmd(env cliEnv) cobra.Command {
1105	1105		"required: give the full id of the head that `ermite mr show <repo> <number>` printed when you\n" +
1106	1106		"reviewed the change. If the branch moved since, the merge is refused: review again. Needs the\n" +
1107	1107		"mr:merge scope.\n\n" +
	1108	+	"A merge needs the checks on the head to pass: none failed, none queued or running. A head\n" +
	1109	+	"without checks can be merged. --ignore-checks merges anyway and needs the mr:force-merge scope\n" +
	1110	+	"(the cli preset has it, the agent preset does not).\n\n" +
1108	1111		"The merge answers as soon as the target branch has moved. --delete-branch asks the server to delete\n" +
1109	1112		"the source branch right after, in the background. The merge is refused when the branch is the\n" +
1110	1113		"default branch or used by another open merge request. If the deletion later fails (the branch\n" +

@@ -1123,6 +1126,9 @@ func newMRMergeCmd(env cliEnv) cobra.Command {
1123	1126		cmd.Flags().BoolVar(&deleteBranch, "delete-branch", false, "delete the source branch after the merge")
1124	1127		cmd.Flags().BoolVar(&auto, "auto", false, "merge by itself once the checks passed (needs `repo edit --allow-auto-merge`)")
1125	1128		cmd.Flags().BoolVar(&cancelAuto, "cancel-auto", false, "cancel the pending auto-merge")
	1129	+	cmd.Flags().BoolVar(&ignoreChecks, "ignore-checks", false, "merge despite failing or unfinished checks (needs mr:force-merge)")
	1130	+	cmd.MarkFlagsMutuallyExclusive("ignore-checks", "auto")
	1131	+	cmd.MarkFlagsMutuallyExclusive("ignore-checks", "cancel-auto")
1126	1132		cmd.MarkFlagsMutuallyExclusive("auto", "cancel-auto")
1127	1133		cmd.MarkFlagsMutuallyExclusive("cancel-auto", "delete-branch")
1128	1134		cmd.MarkFlagsMutuallyExclusive("cancel-auto", "head")

@@ -1156,13 +1162,18 @@ func newMRMergeCmd(env cliEnv) cobra.Command {
1156	1162		return err
1157	1163		}
1158	1164		ctx := env.ctx(cmd)
	1165	+	if ignoreChecks {
	1166	+	if err := requireFeature(ctx, c, client.FeatureIgnoreChecks, "cannot bypass checks (--ignore-checks)"); err != nil {
	1167	+	return err
	1168	+	}
	1169	+	}
1159	1170		if pbMode == ermite.MergeMode_MERGE_MODE_MERGE_COMMIT {
1160	1171		if err := requireFeature(ctx, c, client.FeatureMergeability, "has no merge commit mode (--mode merge)"); err != nil {
1161	1172		return err
1162	1173		}
1163	1174		}
1164	1175		res, err := c.MergeRequests().MergeMergeRequest(ctx, connect.NewRequest(&ermite.MergeMergeRequestRequest{
1165		-	Repo: args[0], Number: n, Mode: pbMode, HeadId: head, DeleteSourceBranch: deleteBranch,
	1176	+	Repo: args[0], Number: n, Mode: pbMode, HeadId: head, DeleteSourceBranch: deleteBranch, IgnoreChecks: ignoreChecks,
1166	1177		}))
1167	1178		if err != nil {
1168	1179		return c.Describe(err)

@@ -1282,3 +1293,34 @@ func newMRCloseCmd(env cliEnv) cobra.Command {
1282	1293		}
1283	1294		return cmd
1284	1295		}
	1296	+
	1297	+	func newMRReadyCmd(env cliEnv) cobra.Command {
	1298	+	cmd := &cobra.Command{
	1299	+	Use: "ready <repo> <number>",
	1300	+	Short: "Mark a draft merge request ready for review",
	1301	+	Long: "Remove the WIP: or [WIP] prefix from the title so the merge request can be merged.\nFails if it is not open or not a draft. Needs the mr:write scope.\nPrints a confirmation, then the full web URL on its own line." + jsonMRHelp,
	1302	+	Args: cobra.ExactArgs(2),
	1303	+	ValidArgsFunction: completeMRRepoThenNumber(env),
	1304	+	}
	1305	+	asJSON := addJSONFlag(cmd)
	1306	+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
	1307	+	n, err := parseNumber(args[1])
	1308	+	if err != nil {
	1309	+	return err
	1310	+	}
	1311	+	c, err := env.client(cmd)
	1312	+	if err != nil {
	1313	+	return err
	1314	+	}
	1315	+	ctx := env.ctx(cmd)
	1316	+	if err := requireFeature(ctx, c, client.FeatureMarkReady, "cannot mark drafts ready (mr ready)"); err != nil {
	1317	+	return err
	1318	+	}
	1319	+	res, err := c.MergeRequests().MarkReady(ctx, connect.NewRequest(&ermite.MarkReadyRequest{Repo: args[0], Number: n}))
	1320	+	if err != nil {
	1321	+	return c.Describe(err)
	1322	+	}
	1323	+	return outputMR(cmd, res.Msg.GetMergeRequest(), *asJSON, "marked ready", c.URL())
	1324	+	}
	1325	+	return cmd
	1326	+	}

 	}
 	mr.AddCommand(
 		newMRCreateCmd(env), newMRListCmd(env), newMRShowCmd(env), newMRCommentCmd(env),
-		newMRResolveCmd(env), newMREditCommentCmd(env), newMRDeleteCommentCmd(env), newMRMergeCmd(env), newMRCloseCmd(env),
+		newMRResolveCmd(env), newMREditCommentCmd(env), newMRDeleteCommentCmd(env), newMRMergeCmd(env), newMRCloseCmd(env), newMRReadyCmd(env),
 	)
 	return mr
 }
 	var mode string
 	var deleteBranch bool
 	var head string
-	var auto, cancelAuto bool
+	var auto, cancelAuto, ignoreChecks bool
 	cmd := &cobra.Command{
 		Use:   "merge <repo> <number>",
 		Short: "Merge a merge request",
 			"required: give the full id of the head that `ermite mr show <repo> <number>` printed when you\n" +
 			"reviewed the change. If the branch moved since, the merge is refused: review again. Needs the\n" +
 			"mr:merge scope.\n\n" +
+			"A merge needs the checks on the head to pass: none failed, none queued or running. A head\n" +
+			"without checks can be merged. --ignore-checks merges anyway and needs the mr:force-merge scope\n" +
+			"(the cli preset has it, the agent preset does not).\n\n" +
 			"The merge answers as soon as the target branch has moved. --delete-branch asks the server to delete\n" +
 			"the source branch right after, in the background. The merge is refused when the branch is the\n" +
 			"default branch or used by another open merge request. If the deletion later fails (the branch\n" +
 	cmd.Flags().BoolVar(&deleteBranch, "delete-branch", false, "delete the source branch after the merge")
 	cmd.Flags().BoolVar(&auto, "auto", false, "merge by itself once the checks passed (needs `repo edit --allow-auto-merge`)")
 	cmd.Flags().BoolVar(&cancelAuto, "cancel-auto", false, "cancel the pending auto-merge")
+	cmd.Flags().BoolVar(&ignoreChecks, "ignore-checks", false, "merge despite failing or unfinished checks (needs mr:force-merge)")
+	cmd.MarkFlagsMutuallyExclusive("ignore-checks", "auto")
+	cmd.MarkFlagsMutuallyExclusive("ignore-checks", "cancel-auto")
 	cmd.MarkFlagsMutuallyExclusive("auto", "cancel-auto")
 	cmd.MarkFlagsMutuallyExclusive("cancel-auto", "delete-branch")
 	cmd.MarkFlagsMutuallyExclusive("cancel-auto", "head")
 			return err
 		}
 		ctx := env.ctx(cmd)
+		if ignoreChecks {
+			if err := requireFeature(ctx, c, client.FeatureIgnoreChecks, "cannot bypass checks (--ignore-checks)"); err != nil {
+				return err
+			}
+		}
 		if pbMode == ermite.MergeMode_MERGE_MODE_MERGE_COMMIT {
 			if err := requireFeature(ctx, c, client.FeatureMergeability, "has no merge commit mode (--mode merge)"); err != nil {
 				return err
 			}
 		}
 		res, err := c.MergeRequests().MergeMergeRequest(ctx, connect.NewRequest(&ermite.MergeMergeRequestRequest{
-			Repo: args[0], Number: n, Mode: pbMode, HeadId: head, DeleteSourceBranch: deleteBranch,
+			Repo: args[0], Number: n, Mode: pbMode, HeadId: head, DeleteSourceBranch: deleteBranch, IgnoreChecks: ignoreChecks,
 		}))
 		if err != nil {
 			return c.Describe(err)
 	}
 	return cmd
 }
+func newMRReadyCmd(env *cliEnv) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:               "ready <repo> <number>",
+		Short:             "Mark a draft merge request ready for review",
+		Long:              "Remove the WIP: or [WIP] prefix from the title so the merge request can be merged.\nFails if it is not open or not a draft. Needs the mr:write scope.\nPrints a confirmation, then the full web URL on its own line." + jsonMRHelp,
+		Args:              cobra.ExactArgs(2),
+		ValidArgsFunction: completeMRRepoThenNumber(env),
+	}
+	asJSON := addJSONFlag(cmd)
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		n, err := parseNumber(args[1])
+		if err != nil {
+			return err
+		}
+		c, err := env.client(cmd)
+		if err != nil {
+			return err
+		}
+		ctx := env.ctx(cmd)
+		if err := requireFeature(ctx, c, client.FeatureMarkReady, "cannot mark drafts ready (mr ready)"); err != nil {
+			return err
+		}
+		res, err := c.MergeRequests().MarkReady(ctx, connect.NewRequest(&ermite.MarkReadyRequest{Repo: args[0], Number: n}))
+		if err != nil {
+			return c.Describe(err)
+		}
+		return outputMR(cmd, res.Msg.GetMergeRequest(), *asJSON, "marked ready", c.URL())
+	}
+	return cmd
+}

M internal/app/cli_mr_e2e_test.go +38 -14


@@ -382,29 +382,17 @@ func TestRepoEditMergeSettingsCLI(t *testing.T) {
382	382		c.seed("proj", domain.VisibilityPublic)
383	383		res := c.cli(t, adminToken, "repo", "show", "proj", "--json").ok(t)
384	384		repo := decode[struct {
385		-	MergeModes []string `json:"merge_modes"`
386		-	FailingChecksBlock bool `json:"failing_checks_block"`
	385	+	MergeModes []string `json:"merge_modes"`
387	386		}](t, res.stdout)
388	387		assert.Equal(t, []string{"fast-forward", "squash", "merge"}, repo.MergeModes)
389		-	assert.True(t, repo.FailingChecksBlock)
390	388
391	389		res = c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "squash", "--json").ok(t)
392	390		repo = decode[struct {
393		-	MergeModes []string `json:"merge_modes"`
394		-	FailingChecksBlock bool `json:"failing_checks_block"`
	391	+	MergeModes []string `json:"merge_modes"`
395	392		}](t, res.stdout)
396	393		assert.Equal(t, []string{"squash"}, repo.MergeModes)
397		-	assert.True(t, repo.FailingChecksBlock, "untouched")
398		-	res = c.cli(t, adminToken, "repo", "edit", "proj", "--failing-checks-block=false", "--json").ok(t)
399		-	repo = decode[struct {
400		-	MergeModes []string `json:"merge_modes"`
401		-	FailingChecksBlock bool `json:"failing_checks_block"`
402		-	}](t, res.stdout)
403		-	assert.Equal(t, []string{"squash"}, repo.MergeModes, "untouched")
404		-	assert.False(t, repo.FailingChecksBlock)
405	394		res = c.cli(t, adminToken, "repo", "show", "proj").ok(t)
406	395		assert.Regexp(t, `(?m)^merge modes\s+squash$`, res.stdout)
407		-	assert.Regexp(t, `(?m)^failing checks block\s+false$`, res.stdout)
408	396
409	397		require.Error(t, c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "rebase").err)
410	398		require.Error(t, c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "").err)

@@ -497,3 +485,39 @@ func TestMergeRequestNotesCLIEndToEnd(t *testing.T) {
497	485		require.Error(t, c.cli(t, adminToken, "mr", "edit-comment", "notes", "1", root.ID, "-m", "late").err)
498	486		require.Error(t, c.cli(t, adminToken, "mr", "delete-comment", "notes", "1", root.ID).err)
499	487		}
	488	+
	489	+	func TestMRReadyAndIgnoreChecksCLIEndToEnd(t *testing.T) {
	490	+	c := newCLIHarness(t)
	491	+	secret := strings.TrimSpace(c.cli(t, adminToken, "token", "create", "daily", "--preset", "cli").ok(t).stdout)
	492	+	agent := strings.TrimSpace(c.cli(t, adminToken, "token", "create", "agent", "--preset", "agent", "--scope", "mr:merge").ok(t).stdout)
	493	+	c.cli(t, secret, "repo", "create", "proj", "--visibility", "public").ok(t)
	494	+	wt := c.workTree("main", "README.md")
	495	+	url := c.urlAuth(secret, "/proj.git")
	496	+	c.mustGit(wt, "push", "-q", url, "main")
	497	+	c.mustGit(wt, "checkout", "-q", "-b", "feat/ready")
	498	+	c.writeFile(wt, "README.md", []byte("ready\n"))
	499	+	c.mustGit(wt, "push", "-q", url, "feat/ready")
	500	+	head := c.bareGit("proj", "rev-parse", "feat/ready")
	501	+	c.cli(t, agent, "mr", "create", "proj", "--source", "feat/ready", "--title", "WIP: Add feature").ok(t)
	502	+	ready := c.cli(t, agent, "mr", "ready", "proj", "1", "--json").ok(t)
	503	+	assert.Equal(t, mrKeys, keys(t, ready.stdout))
	504	+	assert.Equal(t, "Add feature", decode[mrOut](t, ready.stdout).Title)
	505	+	res := c.cli(t, agent, "mr", "ready", "proj", "1")
	506	+	require.Error(t, res.err)
	507	+	assert.Contains(t, res.err.Error(), "not a draft")
	508	+	res = c.cli(t, secret, "mr", "merge", "proj", "1", "--head", head, "--ignore-checks", "--auto")
	509	+	require.Error(t, res.err)
	510	+	assert.Contains(t, res.err.Error(), "ignore-checks")
	511	+	res = c.cli(t, agent, "mr", "merge", "proj", "1", "--head", head, "--ignore-checks")
	512	+	require.Error(t, res.err)
	513	+	assert.Contains(t, res.err.Error(), "mr:force-merge")
	514	+	c.cli(t, secret, "mr", "merge", "proj", "1", "--head", head, "--ignore-checks").ok(t)
	515	+	c.mustGit(wt, "checkout", "-q", "-b", "feat/second")
	516	+	c.writeFile(wt, "README.md", []byte("second\n"))
	517	+	c.mustGit(wt, "push", "-q", url, "feat/second")
	518	+	head = c.bareGit("proj", "rev-parse", "feat/second")
	519	+	c.cli(t, agent, "mr", "create", "proj", "--source", "feat/second", "--title", "[WIP] Second").ok(t)
	520	+	res = c.cli(t, agent, "mr", "ready", "proj", "2").ok(t)
	521	+	assert.Contains(t, res.stdout, "marked ready proj!2 (feat/second into main)\n"+c.url+"/proj/merge-requests/2\n")
	522	+	c.cli(t, secret, "mr", "merge", "proj", "2", "--head", head).ok(t)
	523	+	}


@@ -382,29 +382,17 @@ func TestRepoEditMergeSettingsCLI(t *testing.T) {
382		c.seed("proj", domain.VisibilityPublic)	382		c.seed("proj", domain.VisibilityPublic)
383		res := c.cli(t, adminToken, "repo", "show", "proj", "--json").ok(t)	383		res := c.cli(t, adminToken, "repo", "show", "proj", "--json").ok(t)
384		repo := decode[struct {	384		repo := decode[struct {
385	-	MergeModes []string `json:"merge_modes"`	385	+	MergeModes []string `json:"merge_modes"`
386	-	FailingChecksBlock bool `json:"failing_checks_block"`
387		}](t, res.stdout)	386		}](t, res.stdout)
388		assert.Equal(t, []string{"fast-forward", "squash", "merge"}, repo.MergeModes)	387		assert.Equal(t, []string{"fast-forward", "squash", "merge"}, repo.MergeModes)
389	-	assert.True(t, repo.FailingChecksBlock)
390			388
391		res = c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "squash", "--json").ok(t)	389		res = c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "squash", "--json").ok(t)
392		repo = decode[struct {	390		repo = decode[struct {
393	-	MergeModes []string `json:"merge_modes"`	391	+	MergeModes []string `json:"merge_modes"`
394	-	FailingChecksBlock bool `json:"failing_checks_block"`
395		}](t, res.stdout)	392		}](t, res.stdout)
396		assert.Equal(t, []string{"squash"}, repo.MergeModes)	393		assert.Equal(t, []string{"squash"}, repo.MergeModes)
397	-	assert.True(t, repo.FailingChecksBlock, "untouched")
398	-	res = c.cli(t, adminToken, "repo", "edit", "proj", "--failing-checks-block=false", "--json").ok(t)
399	-	repo = decode[struct {
400	-	MergeModes []string `json:"merge_modes"`
401	-	FailingChecksBlock bool `json:"failing_checks_block"`
402	-	}](t, res.stdout)
403	-	assert.Equal(t, []string{"squash"}, repo.MergeModes, "untouched")
404	-	assert.False(t, repo.FailingChecksBlock)
405		res = c.cli(t, adminToken, "repo", "show", "proj").ok(t)	394		res = c.cli(t, adminToken, "repo", "show", "proj").ok(t)
406		assert.Regexp(t, `(?m)^merge modes\s+squash$`, res.stdout)	395		assert.Regexp(t, `(?m)^merge modes\s+squash$`, res.stdout)
407	-	assert.Regexp(t, `(?m)^failing checks block\s+false$`, res.stdout)
408			396
409		require.Error(t, c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "rebase").err)	397		require.Error(t, c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "rebase").err)
410		require.Error(t, c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "").err)	398		require.Error(t, c.cli(t, adminToken, "repo", "edit", "proj", "--merge-modes", "").err)

@@ -497,3 +485,39 @@ func TestMergeRequestNotesCLIEndToEnd(t *testing.T) {
497		require.Error(t, c.cli(t, adminToken, "mr", "edit-comment", "notes", "1", root.ID, "-m", "late").err)	485		require.Error(t, c.cli(t, adminToken, "mr", "edit-comment", "notes", "1", root.ID, "-m", "late").err)
498		require.Error(t, c.cli(t, adminToken, "mr", "delete-comment", "notes", "1", root.ID).err)	486		require.Error(t, c.cli(t, adminToken, "mr", "delete-comment", "notes", "1", root.ID).err)
499		}	487		}
			488	+
			489	+	func TestMRReadyAndIgnoreChecksCLIEndToEnd(t *testing.T) {
			490	+	c := newCLIHarness(t)
			491	+	secret := strings.TrimSpace(c.cli(t, adminToken, "token", "create", "daily", "--preset", "cli").ok(t).stdout)
			492	+	agent := strings.TrimSpace(c.cli(t, adminToken, "token", "create", "agent", "--preset", "agent", "--scope", "mr:merge").ok(t).stdout)
			493	+	c.cli(t, secret, "repo", "create", "proj", "--visibility", "public").ok(t)
			494	+	wt := c.workTree("main", "README.md")
			495	+	url := c.urlAuth(secret, "/proj.git")
			496	+	c.mustGit(wt, "push", "-q", url, "main")
			497	+	c.mustGit(wt, "checkout", "-q", "-b", "feat/ready")
			498	+	c.writeFile(wt, "README.md", []byte("ready\n"))
			499	+	c.mustGit(wt, "push", "-q", url, "feat/ready")
			500	+	head := c.bareGit("proj", "rev-parse", "feat/ready")
			501	+	c.cli(t, agent, "mr", "create", "proj", "--source", "feat/ready", "--title", "WIP: Add feature").ok(t)
			502	+	ready := c.cli(t, agent, "mr", "ready", "proj", "1", "--json").ok(t)
			503	+	assert.Equal(t, mrKeys, keys(t, ready.stdout))
			504	+	assert.Equal(t, "Add feature", decode[mrOut](t, ready.stdout).Title)
			505	+	res := c.cli(t, agent, "mr", "ready", "proj", "1")
			506	+	require.Error(t, res.err)
			507	+	assert.Contains(t, res.err.Error(), "not a draft")
			508	+	res = c.cli(t, secret, "mr", "merge", "proj", "1", "--head", head, "--ignore-checks", "--auto")
			509	+	require.Error(t, res.err)
			510	+	assert.Contains(t, res.err.Error(), "ignore-checks")
			511	+	res = c.cli(t, agent, "mr", "merge", "proj", "1", "--head", head, "--ignore-checks")
			512	+	require.Error(t, res.err)
			513	+	assert.Contains(t, res.err.Error(), "mr:force-merge")
			514	+	c.cli(t, secret, "mr", "merge", "proj", "1", "--head", head, "--ignore-checks").ok(t)
			515	+	c.mustGit(wt, "checkout", "-q", "-b", "feat/second")
			516	+	c.writeFile(wt, "README.md", []byte("second\n"))
			517	+	c.mustGit(wt, "push", "-q", url, "feat/second")
			518	+	head = c.bareGit("proj", "rev-parse", "feat/second")
			519	+	c.cli(t, agent, "mr", "create", "proj", "--source", "feat/second", "--title", "[WIP] Second").ok(t)
			520	+	res = c.cli(t, agent, "mr", "ready", "proj", "2").ok(t)
			521	+	assert.Contains(t, res.stdout, "marked ready proj!2 (feat/second into main)\n"+c.url+"/proj/merge-requests/2\n")
			522	+	c.cli(t, secret, "mr", "merge", "proj", "2", "--head", head).ok(t)
			523	+	}

M internal/app/cli_repo.go +17 -29


@@ -34,9 +34,8 @@ type jsonRepo struct {
34	34		CreatedAt *string `json:"created_at"`
35	35		PushedAt *string `json:"pushed_at"`
36	36		// MergeModes are the allowed merge modes ("fast-forward", "squash", "merge").
37		-	MergeModes []string `json:"merge_modes"`
38		-	FailingChecksBlock bool `json:"failing_checks_block"`
39		-	AllowAutoMerge bool `json:"allow_auto_merge"`
	37	+	MergeModes []string `json:"merge_modes"`
	38	+	AllowAutoMerge bool `json:"allow_auto_merge"`
40	39		// Issues is the issue mode ("off", "owner" or "public").
41	40		Issues string `json:"issues"`
42	41		}

@@ -47,17 +46,16 @@ func toJSONRepo(r *ermite.Repo) jsonRepo {
47	46		modes = append(modes, modeName(m))
48	47		}
49	48		return jsonRepo{
50		-	MergeModes: modes,
51		-	FailingChecksBlock: r.GetSettings().GetFailingChecksBlock(),
52		-	AllowAutoMerge: r.GetSettings().GetAllowAutoMerge(),
53		-	Issues: issuesModeName(r.GetSettings().GetIssues()),
54		-	Name: r.GetName(),
55		-	Description: r.GetDescription(),
56		-	Topics: append([]string{}, r.GetTopics()...),
57		-	Visibility: visibilityName(r.GetVisibility()),
58		-	DefaultBranch: r.GetDefaultBranch(),
59		-	CreatedAt: jsonTime(r.GetCreatedAt()),
60		-	PushedAt: jsonTime(r.GetPushedAt()),
	49	+	MergeModes: modes,
	50	+	AllowAutoMerge: r.GetSettings().GetAllowAutoMerge(),
	51	+	Issues: issuesModeName(r.GetSettings().GetIssues()),
	52	+	Name: r.GetName(),
	53	+	Description: r.GetDescription(),
	54	+	Topics: append([]string{}, r.GetTopics()...),
	55	+	Visibility: visibilityName(r.GetVisibility()),
	56	+	DefaultBranch: r.GetDefaultBranch(),
	57	+	CreatedAt: jsonTime(r.GetCreatedAt()),
	58	+	PushedAt: jsonTime(r.GetPushedAt()),
61	59		}
62	60		}
63	61

@@ -117,7 +115,7 @@ const jsonRepoHelp = `
117	115		JSON fields of a repository (--json): name, description, visibility ("public" or
118	116		"private"), default_branch, created_at and pushed_at (RFC 3339 UTC; pushed_at is
119	117		null until the first push), merge_modes (array of the allowed merge modes, "fast-forward", "squash" and/or
120		-	"merge"), failing_checks_block (whether a failing check prevents a merge), allow_auto_merge (whether
	118	+	"merge"), allow_auto_merge (whether
121	119		auto-merge can be enabled) and issues (the issue mode: "off", "owner" or "public").`
122	120
123	121		func newRepoCmd(env cliEnv) cobra.Command {

@@ -230,7 +228,6 @@ func printRepo(w io.Writer, r *ermite.Repo) error {
230	228		{"created", shortTime(r.GetCreatedAt(), "-")},
231	229		{"last push", shortTime(r.GetPushedAt(), "never")},
232	230		{"merge modes", orDash(strings.Join(modes, ", "))},
233		-	{"failing checks block", strconv.FormatBool(r.GetSettings().GetFailingChecksBlock())},
234	231		{"allow auto-merge", strconv.FormatBool(r.GetSettings().GetAllowAutoMerge())},
235	232		{"issues", issuesModeName(r.GetSettings().GetIssues())},
236	233		})

@@ -311,7 +308,7 @@ func buildCreateRepo(name, description string, topics []string, visibility strin
311	308		func newRepoEditCmd(env cliEnv) cobra.Command {
312	309		var description, visibility, defaultBranch string
313	310		var topics, mergeModes []string
314		-	var failingChecksBlock, allowAutoMerge bool
	311	+	var allowAutoMerge bool
315	312		var issues string
316	313		cmd := &cobra.Command{
317	314		Use: "edit <name>",

@@ -321,7 +318,6 @@ func newRepoEditCmd(env cliEnv) cobra.Command {
321	318		"may be merged with (fast-forward, squash, merge; every mode is allowed by default, so to disable one,\n" +
322	319		"list the others: --merge-modes fast-forward,squash disables the merge commit; squash and merge\n" +
323	320		"commits are signed with the server's key, see `ermite signing-key show`), and\n" +
324		-	"--failing-checks-block says whether a failing check prevents a merge (a failed or unfinished CI check of the head; see README, CI).\n" +
325	321		"--issues sets who may use issues: off (default), owner (the owner and tokens with issue:write) or\n" +
326	322		"public (visitors of a public repository may also propose issues through a moderated form).\nNeeds a server with the issues feature.\n" +
327	323		"Needs the repo:admin scope." + jsonRepoHelp,

@@ -333,7 +329,6 @@ func newRepoEditCmd(env cliEnv) cobra.Command {
333	329		cmd.Flags().StringVar(&visibility, "visibility", "", "new visibility: public or private")
334	330		cmd.Flags().StringVar(&defaultBranch, "default-branch", "", "short name of the new default branch")
335	331		cmd.Flags().StringSliceVar(&mergeModes, "merge-modes", nil, "allowed merge modes, comma-separated: fast-forward, squash, merge (all by default; list the ones to keep)")
336		-	cmd.Flags().BoolVar(&failingChecksBlock, "failing-checks-block", true, "a failing check prevents a merge (--failing-checks-block=false to allow it)")
337	332		cmd.Flags().BoolVar(&allowAutoMerge, "allow-auto-merge", false, "allow auto-merge on merge requests (--allow-auto-merge=false to forbid it)")
338	333		cmd.Flags().StringVar(&issues, "issues", "", "issue mode: off, owner or public")
339	334		_ = cmd.RegisterFlagCompletionFunc("issues", func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {

@@ -345,7 +340,7 @@ func newRepoEditCmd(env cliEnv) cobra.Command {
345	340		})
346	341		asJSON := addJSONFlag(cmd)
347	342		cmd.RunE = func(cmd *cobra.Command, args []string) error {
348		-	req, err := buildUpdateRepo(cmd, args[0], description, topics, visibility, defaultBranch, mergeModes, failingChecksBlock, allowAutoMerge, issues)
	343	+	req, err := buildUpdateRepo(cmd, args[0], description, topics, visibility, defaultBranch, mergeModes, allowAutoMerge, issues)
349	344		if err != nil {
350	345		return err
351	346		}

@@ -369,7 +364,7 @@ func newRepoEditCmd(env cliEnv) cobra.Command {
369	364
370	365		// buildUpdateRepo maps the flags of `repo edit` to the request: only the flags
371	366		// the user passed go into the update mask.
372		-	func buildUpdateRepo(cmd cobra.Command, name, description string, topics []string, visibility, defaultBranch string, mergeModes []string, failingChecksBlock, allowAutoMerge bool, issues string) (ermite.UpdateRepoRequest, error) {
	367	+	func buildUpdateRepo(cmd cobra.Command, name, description string, topics []string, visibility, defaultBranch string, mergeModes []string, allowAutoMerge bool, issues string) (ermite.UpdateRepoRequest, error) {
373	368		req := &ermite.UpdateRepoRequest{Repo: name}
374	369		var paths []string
375	370		if cmd.Flags().Changed("description") {

@@ -411,13 +406,6 @@ func buildUpdateRepo(cmd *cobra.Command, name, description string, topics []stri
411	406		req.Settings = &ermite.RepoSettings{AllowedMergeModes: modes}
412	407		paths = append(paths, "settings.allowed_merge_modes")
413	408		}
414		-	if cmd.Flags().Changed("failing-checks-block") {
415		-	if req.Settings == nil {
416		-	req.Settings = &ermite.RepoSettings{}
417		-	}
418		-	req.Settings.FailingChecksBlock = failingChecksBlock
419		-	paths = append(paths, "settings.failing_checks_block")
420		-	}
421	409		if cmd.Flags().Changed("allow-auto-merge") {
422	410		if req.Settings == nil {
423	411		req.Settings = &ermite.RepoSettings{}

@@ -434,7 +422,7 @@ func buildUpdateRepo(cmd *cobra.Command, name, description string, topics []stri
434	422		req.Issues = &mode
435	423		}
436	424		if len(paths) == 0 && req.Issues == nil {
437		-	return nil, errors.New("nothing to change: give at least one of --description, --topics, --visibility, --default-branch, --merge-modes, --failing-checks-block, --allow-auto-merge, --issues")
	425	+	return nil, errors.New("nothing to change: give at least one of --description, --topics, --visibility, --default-branch, --merge-modes, --allow-auto-merge, --issues")
438	426		}
439	427		req.UpdateMask = &fieldmaskpb.FieldMask{Paths: paths}
440	428		return req, nil

 	CreatedAt     *string  `json:"created_at"`
 	PushedAt      *string  `json:"pushed_at"`
 	// MergeModes are the allowed merge modes ("fast-forward", "squash", "merge").
-	MergeModes         []string `json:"merge_modes"`
+	MergeModes     []string `json:"merge_modes"`
-	FailingChecksBlock bool     `json:"failing_checks_block"`
+	AllowAutoMerge bool     `json:"allow_auto_merge"`
-	AllowAutoMerge     bool     `json:"allow_auto_merge"`
 	// Issues is the issue mode ("off", "owner" or "public").
 	Issues string `json:"issues"`
 }
 		modes = append(modes, modeName(m))
 	}
 	return jsonRepo{
-		MergeModes:         modes,
+		MergeModes:     modes,
-		FailingChecksBlock: r.GetSettings().GetFailingChecksBlock(),
+		AllowAutoMerge: r.GetSettings().GetAllowAutoMerge(),
-		AllowAutoMerge:     r.GetSettings().GetAllowAutoMerge(),
+		Issues:         issuesModeName(r.GetSettings().GetIssues()),
-		Issues:             issuesModeName(r.GetSettings().GetIssues()),
+		Name:           r.GetName(),
-		Name:               r.GetName(),
+		Description:    r.GetDescription(),
-		Description:        r.GetDescription(),
+		Topics:         append([]string{}, r.GetTopics()...),
-		Topics:             append([]string{}, r.GetTopics()...),
+		Visibility:     visibilityName(r.GetVisibility()),
-		Visibility:         visibilityName(r.GetVisibility()),
+		DefaultBranch:  r.GetDefaultBranch(),
-		DefaultBranch:      r.GetDefaultBranch(),
+		CreatedAt:      jsonTime(r.GetCreatedAt()),
-		CreatedAt:          jsonTime(r.GetCreatedAt()),
+		PushedAt:       jsonTime(r.GetPushedAt()),
-		PushedAt:           jsonTime(r.GetPushedAt()),
 	}
 }
 JSON fields of a repository (--json): name, description, visibility ("public" or
 "private"), default_branch, created_at and pushed_at (RFC 3339 UTC; pushed_at is
 null until the first push), merge_modes (array of the allowed merge modes, "fast-forward", "squash" and/or
-"merge"), failing_checks_block (whether a failing check prevents a merge), allow_auto_merge (whether
+"merge"), allow_auto_merge (whether
 auto-merge can be enabled) and issues (the issue mode: "off", "owner" or "public").`
 func newRepoCmd(env *cliEnv) *cobra.Command {
 		{"created", shortTime(r.GetCreatedAt(), "-")},
 		{"last push", shortTime(r.GetPushedAt(), "never")},
 		{"merge modes", orDash(strings.Join(modes, ", "))},
-		{"failing checks block", strconv.FormatBool(r.GetSettings().GetFailingChecksBlock())},
 		{"allow auto-merge", strconv.FormatBool(r.GetSettings().GetAllowAutoMerge())},
 		{"issues", issuesModeName(r.GetSettings().GetIssues())},
 	})
 func newRepoEditCmd(env *cliEnv) *cobra.Command {
 	var description, visibility, defaultBranch string
 	var topics, mergeModes []string
-	var failingChecksBlock, allowAutoMerge bool
+	var allowAutoMerge bool
 	var issues string
 	cmd := &cobra.Command{
 		Use:   "edit <name>",
 			"may be merged with (fast-forward, squash, merge; every mode is allowed by default, so to disable one,\n" +
 			"list the others: --merge-modes fast-forward,squash disables the merge commit; squash and merge\n" +
 			"commits are signed with the server's key, see `ermite signing-key show`), and\n" +
-			"--failing-checks-block says whether a failing check prevents a merge (a failed or unfinished CI check of the head; see README, CI).\n" +
 			"--issues sets who may use issues: off (default), owner (the owner and tokens with issue:write) or\n" +
 			"public (visitors of a public repository may also propose issues through a moderated form).\nNeeds a server with the issues feature.\n" +
 			"Needs the repo:admin scope." + jsonRepoHelp,
 	cmd.Flags().StringVar(&visibility, "visibility", "", "new visibility: public or private")
 	cmd.Flags().StringVar(&defaultBranch, "default-branch", "", "short name of the new default branch")
 	cmd.Flags().StringSliceVar(&mergeModes, "merge-modes", nil, "allowed merge modes, comma-separated: fast-forward, squash, merge (all by default; list the ones to keep)")
-	cmd.Flags().BoolVar(&failingChecksBlock, "failing-checks-block", true, "a failing check prevents a merge (--failing-checks-block=false to allow it)")
 	cmd.Flags().BoolVar(&allowAutoMerge, "allow-auto-merge", false, "allow auto-merge on merge requests (--allow-auto-merge=false to forbid it)")
 	cmd.Flags().StringVar(&issues, "issues", "", "issue mode: off, owner or public")
 	_ = cmd.RegisterFlagCompletionFunc("issues", func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
 	})
 	asJSON := addJSONFlag(cmd)
 	cmd.RunE = func(cmd *cobra.Command, args []string) error {
-		req, err := buildUpdateRepo(cmd, args[0], description, topics, visibility, defaultBranch, mergeModes, failingChecksBlock, allowAutoMerge, issues)
+		req, err := buildUpdateRepo(cmd, args[0], description, topics, visibility, defaultBranch, mergeModes, allowAutoMerge, issues)
 		if err != nil {
 			return err
 		}
 // buildUpdateRepo maps the flags of `repo edit` to the request: only the flags
 // the user passed go into the update mask.
-func buildUpdateRepo(cmd *cobra.Command, name, description string, topics []string, visibility, defaultBranch string, mergeModes []string, failingChecksBlock, allowAutoMerge bool, issues string) (*ermite.UpdateRepoRequest, error) {
+func buildUpdateRepo(cmd *cobra.Command, name, description string, topics []string, visibility, defaultBranch string, mergeModes []string, allowAutoMerge bool, issues string) (*ermite.UpdateRepoRequest, error) {
 	req := &ermite.UpdateRepoRequest{Repo: name}
 	var paths []string
 	if cmd.Flags().Changed("description") {
 		req.Settings = &ermite.RepoSettings{AllowedMergeModes: modes}
 		paths = append(paths, "settings.allowed_merge_modes")
 	}
-	if cmd.Flags().Changed("failing-checks-block") {
-		if req.Settings == nil {
-			req.Settings = &ermite.RepoSettings{}
-		}
-		req.Settings.FailingChecksBlock = failingChecksBlock
-		paths = append(paths, "settings.failing_checks_block")
-	}
 	if cmd.Flags().Changed("allow-auto-merge") {
 		if req.Settings == nil {
 			req.Settings = &ermite.RepoSettings{}
 		req.Issues = &mode
 	}
 	if len(paths) == 0 && req.Issues == nil {
-		return nil, errors.New("nothing to change: give at least one of --description, --topics, --visibility, --default-branch, --merge-modes, --failing-checks-block, --allow-auto-merge, --issues")
+		return nil, errors.New("nothing to change: give at least one of --description, --topics, --visibility, --default-branch, --merge-modes, --allow-auto-merge, --issues")
 	}
 	req.UpdateMask = &fieldmaskpb.FieldMask{Paths: paths}
 	return req, nil

M internal/app/cli_repo_test.go +17 -27


@@ -19,8 +19,7 @@ var (
19	19		Name: "alpha", Description: "The first one", Topics: []string{"cli", "go"}, Visibility: ermite.Visibility_VISIBILITY_PUBLIC,
20	20		DefaultBranch: "main", CreatedAt: ts("2026-01-02T03:04:05Z"), PushedAt: ts("2026-03-04T05:06:07Z"),
21	21		Settings: &ermite.RepoSettings{
22		-	AllowedMergeModes: []ermite.MergeMode{ermite.MergeMode_MERGE_MODE_FAST_FORWARD, ermite.MergeMode_MERGE_MODE_SQUASH},
23		-	FailingChecksBlock: true,
	22	+	AllowedMergeModes: []ermite.MergeMode{ermite.MergeMode_MERGE_MODE_FAST_FORWARD, ermite.MergeMode_MERGE_MODE_SQUASH},
24	23		},
25	24		}
26	25		repoBeta = &ermite.Repo{

@@ -54,8 +53,8 @@ func TestRepoList(t *testing.T) {
54	53		{
55	54		name: "json", repos: both, args: []string{"repo", "list", "--json"}, wantJSON: true,
56	55		wantStdout: `[
57		-	{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"failing_checks_block":true,"allow_auto_merge":false,"issues":"off"},
58		-	{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"failing_checks_block":false,"allow_auto_merge":false,"issues":"off"}
	56	+	{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"allow_auto_merge":false,"issues":"off"},
	57	+	{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"allow_auto_merge":false,"issues":"off"}
59	58		]`,
60	59		},
61	60		{

@@ -107,22 +106,21 @@ func TestRepoShow(t *testing.T) {
107	106		url := f.serve(t)
108	107		res := runCLI(t, envFor(url), "", "repo", "show", "alpha").ok(t)
109	108		assert.Equal(t, ""+
110		-	"name alpha\n"+
111		-	"visibility public\n"+
112		-	"default branch main\n"+
113		-	"description The first one\n"+
114		-	"topics cli, go\n"+
115		-	"created 2026-01-02 03:04\n"+
116		-	"last push 2026-03-04 05:06\n"+
117		-	"merge modes fast-forward, squash\n"+
118		-	"failing checks block true\n"+
119		-	"allow auto-merge false\n"+
120		-	"issues off\n", res.stdout)
	109	+	"name alpha\n"+
	110	+	"visibility public\n"+
	111	+	"default branch main\n"+
	112	+	"description The first one\n"+
	113	+	"topics cli, go\n"+
	114	+	"created 2026-01-02 03:04\n"+
	115	+	"last push 2026-03-04 05:06\n"+
	116	+	"merge modes fast-forward, squash\n"+
	117	+	"allow auto-merge false\n"+
	118	+	"issues off\n", res.stdout)
121	119		_, reqs := f.snapshot()
122	120		assert.Equal(t, "alpha", reqs[0].(*ermite.GetRepoRequest).GetRepo())
123	121
124	122		res = runCLI(t, envFor(url), "", "repo", "show", "alpha", "--json").ok(t)
125		-	assert.JSONEq(t, `{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"failing_checks_block":true,"allow_auto_merge":false,"issues":"off"}`, res.stdout)
	123	+	assert.JSONEq(t, `{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"allow_auto_merge":false,"issues":"off"}`, res.stdout)
126	124		}
127	125
128	126		func TestRepoShowNeedsOneArg(t *testing.T) {

@@ -178,7 +176,7 @@ func TestRepoCreateJSON(t *testing.T) {
178	176		return &ermite.CreateRepoResponse{Repo: repoBeta}, nil
179	177		}}
180	178		res := runCLI(t, envFor(f.serve(t)), "", "repo", "create", "beta", "--json").ok(t)
181		-	assert.JSONEq(t, `{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"failing_checks_block":false,"allow_auto_merge":false,"issues":"off"}`, res.stdout)
	179	+	assert.JSONEq(t, `{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"allow_auto_merge":false,"issues":"off"}`, res.stdout)
182	180		}
183	181
184	182		func TestRepoEditMask(t *testing.T) {

@@ -209,16 +207,8 @@ func TestRepoEditMask(t *testing.T) {
209	207		{"merge modes", []string{"--merge-modes", "squash,ff"}, []string{"settings.allowed_merge_modes"}, func(t testing.T, r ermite.UpdateRepoRequest) {
210	208		assert.Equal(t, []ermite.MergeMode{ermite.MergeMode_MERGE_MODE_SQUASH, ermite.MergeMode_MERGE_MODE_FAST_FORWARD}, r.GetSettings().GetAllowedMergeModes())
211	209		}},
212		-	{"failing checks do not block", []string{"--failing-checks-block=false"}, []string{"settings.failing_checks_block"}, func(t testing.T, r ermite.UpdateRepoRequest) {
213		-	assert.False(t, r.GetSettings().GetFailingChecksBlock())
214		-	assert.Empty(t, r.GetSettings().GetAllowedMergeModes())
215		-	}},
216		-	{"failing checks block", []string{"--failing-checks-block"}, []string{"settings.failing_checks_block"}, func(t testing.T, r ermite.UpdateRepoRequest) {
217		-	assert.True(t, r.GetSettings().GetFailingChecksBlock())
218		-	}},
219	210		{"allow auto-merge", []string{"--allow-auto-merge"}, []string{"settings.allow_auto_merge"}, func(t testing.T, r ermite.UpdateRepoRequest) {
220	211		assert.True(t, r.GetSettings().GetAllowAutoMerge())
221		-	assert.False(t, r.GetSettings().GetFailingChecksBlock())
222	212		}},
223	213		{"forbid auto-merge", []string{"--allow-auto-merge=false"}, []string{"settings.allow_auto_merge"}, func(t testing.T, r ermite.UpdateRepoRequest) {
224	214		assert.False(t, r.GetSettings().GetAllowAutoMerge())

@@ -460,9 +450,9 @@ func TestRepoEditAllowAutoMerge(t *testing.T) {
460	450		assert.Equal(t, []string{"settings.allow_auto_merge"}, got.GetUpdateMask().GetPaths())
461	451		assert.True(t, got.GetSettings().GetAllowAutoMerge())
462	452
463		-	res = runCLI(t, envFor(url), "", "repo", "edit", "alpha", "--allow-auto-merge", "--failing-checks-block=false", "--json").ok(t)
	453	+	res = runCLI(t, envFor(url), "", "repo", "edit", "alpha", "--allow-auto-merge", "--json").ok(t)
464	454		assert.Contains(t, res.stdout, `"allow_auto_merge": true`)
465	455		_, reqs = f.snapshot()
466	456		got = reqs[1].(*ermite.UpdateRepoRequest)
467		-	assert.ElementsMatch(t, []string{"settings.allow_auto_merge", "settings.failing_checks_block"}, got.GetUpdateMask().GetPaths())
	457	+	assert.ElementsMatch(t, []string{"settings.allow_auto_merge"}, got.GetUpdateMask().GetPaths())
468	458		}

 		Name: "alpha", Description: "The first one", Topics: []string{"cli", "go"}, Visibility: ermite.Visibility_VISIBILITY_PUBLIC,
 		DefaultBranch: "main", CreatedAt: ts("2026-01-02T03:04:05Z"), PushedAt: ts("2026-03-04T05:06:07Z"),
 		Settings: &ermite.RepoSettings{
-			AllowedMergeModes:  []ermite.MergeMode{ermite.MergeMode_MERGE_MODE_FAST_FORWARD, ermite.MergeMode_MERGE_MODE_SQUASH},
+			AllowedMergeModes: []ermite.MergeMode{ermite.MergeMode_MERGE_MODE_FAST_FORWARD, ermite.MergeMode_MERGE_MODE_SQUASH},
-			FailingChecksBlock: true,
 		},
 	}
 	repoBeta = &ermite.Repo{
 		{
 			name: "json", repos: both, args: []string{"repo", "list", "--json"}, wantJSON: true,
 			wantStdout: `[
-				{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"failing_checks_block":true,"allow_auto_merge":false,"issues":"off"},
+				{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"allow_auto_merge":false,"issues":"off"},
-				{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"failing_checks_block":false,"allow_auto_merge":false,"issues":"off"}
+				{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"allow_auto_merge":false,"issues":"off"}
 			]`,
 		},
 		{
 	url := f.serve(t)
 	res := runCLI(t, envFor(url), "", "repo", "show", "alpha").ok(t)
 	assert.Equal(t, ""+
-		"name                  alpha\n"+
+		"name              alpha\n"+
-		"visibility            public\n"+
+		"visibility        public\n"+
-		"default branch        main\n"+
+		"default branch    main\n"+
-		"description           The first one\n"+
+		"description       The first one\n"+
-		"topics                cli, go\n"+
+		"topics            cli, go\n"+
-		"created               2026-01-02 03:04\n"+
+		"created           2026-01-02 03:04\n"+
-		"last push             2026-03-04 05:06\n"+
+		"last push         2026-03-04 05:06\n"+
-		"merge modes           fast-forward, squash\n"+
+		"merge modes       fast-forward, squash\n"+
-		"failing checks block  true\n"+
+		"allow auto-merge  false\n"+
-		"allow auto-merge      false\n"+
+		"issues            off\n", res.stdout)
-		"issues                off\n", res.stdout)
 	_, reqs := f.snapshot()
 	assert.Equal(t, "alpha", reqs[0].(*ermite.GetRepoRequest).GetRepo())
 	res = runCLI(t, envFor(url), "", "repo", "show", "alpha", "--json").ok(t)
-	assert.JSONEq(t, `{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"failing_checks_block":true,"allow_auto_merge":false,"issues":"off"}`, res.stdout)
+	assert.JSONEq(t, `{"name":"alpha","description":"The first one","topics":["cli","go"],"visibility":"public","default_branch":"main","created_at":"2026-01-02T03:04:05Z","pushed_at":"2026-03-04T05:06:07Z","merge_modes":["fast-forward","squash"],"allow_auto_merge":false,"issues":"off"}`, res.stdout)
 }
 func TestRepoShowNeedsOneArg(t *testing.T) {
 		return &ermite.CreateRepoResponse{Repo: repoBeta}, nil
 	}}
 	res := runCLI(t, envFor(f.serve(t)), "", "repo", "create", "beta", "--json").ok(t)
-	assert.JSONEq(t, `{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"failing_checks_block":false,"allow_auto_merge":false,"issues":"off"}`, res.stdout)
+	assert.JSONEq(t, `{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"allow_auto_merge":false,"issues":"off"}`, res.stdout)
 }
 func TestRepoEditMask(t *testing.T) {
 		{"merge modes", []string{"--merge-modes", "squash,ff"}, []string{"settings.allowed_merge_modes"}, func(t *testing.T, r *ermite.UpdateRepoRequest) {
 			assert.Equal(t, []ermite.MergeMode{ermite.MergeMode_MERGE_MODE_SQUASH, ermite.MergeMode_MERGE_MODE_FAST_FORWARD}, r.GetSettings().GetAllowedMergeModes())
 		}},
-		{"failing checks do not block", []string{"--failing-checks-block=false"}, []string{"settings.failing_checks_block"}, func(t *testing.T, r *ermite.UpdateRepoRequest) {
-			assert.False(t, r.GetSettings().GetFailingChecksBlock())
-			assert.Empty(t, r.GetSettings().GetAllowedMergeModes())
-		}},
-		{"failing checks block", []string{"--failing-checks-block"}, []string{"settings.failing_checks_block"}, func(t *testing.T, r *ermite.UpdateRepoRequest) {
-			assert.True(t, r.GetSettings().GetFailingChecksBlock())
-		}},
 		{"allow auto-merge", []string{"--allow-auto-merge"}, []string{"settings.allow_auto_merge"}, func(t *testing.T, r *ermite.UpdateRepoRequest) {
 			assert.True(t, r.GetSettings().GetAllowAutoMerge())
-			assert.False(t, r.GetSettings().GetFailingChecksBlock())
 		}},
 		{"forbid auto-merge", []string{"--allow-auto-merge=false"}, []string{"settings.allow_auto_merge"}, func(t *testing.T, r *ermite.UpdateRepoRequest) {
 			assert.False(t, r.GetSettings().GetAllowAutoMerge())
 	assert.Equal(t, []string{"settings.allow_auto_merge"}, got.GetUpdateMask().GetPaths())
 	assert.True(t, got.GetSettings().GetAllowAutoMerge())
-	res = runCLI(t, envFor(url), "", "repo", "edit", "alpha", "--allow-auto-merge", "--failing-checks-block=false", "--json").ok(t)
+	res = runCLI(t, envFor(url), "", "repo", "edit", "alpha", "--allow-auto-merge", "--json").ok(t)
 	assert.Contains(t, res.stdout, `"allow_auto_merge": true`)
 	_, reqs = f.snapshot()
 	got = reqs[1].(*ermite.UpdateRepoRequest)
-	assert.ElementsMatch(t, []string{"settings.allow_auto_merge", "settings.failing_checks_block"}, got.GetUpdateMask().GetPaths())
+	assert.ElementsMatch(t, []string{"settings.allow_auto_merge"}, got.GetUpdateMask().GetPaths())
 }

M internal/app/cli_watch_test.go +1 -1


@@ -95,7 +95,7 @@ func TestWatchNDJSON(t *testing.T) {
95	95		assert.True(t, json.Valid([]byte(sc.Text())), "one JSON value per line: %s", sc.Text())
96	96		}
97	97		require.Len(t, lines, 5)
98		-	assert.JSONEq(t, `{"id":"1","time":"2026-10-10T12:00:00Z","type":"repo_created","repo":"beta","repository":{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"failing_checks_block":false,"allow_auto_merge":false,"issues":"off"}}`, lines[0])
	98	+	assert.JSONEq(t, `{"id":"1","time":"2026-10-10T12:00:00Z","type":"repo_created","repo":"beta","repository":{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"allow_auto_merge":false,"issues":"off"}}`, lines[0])
99	99		assert.JSONEq(t, `{"id":"3","time":"2026-10-10T12:00:00Z","type":"pushed","repo":"alpha","ref_updates":[
100	100		{"ref":"refs/heads/main","old_id":"1111111111111111","new_id":"2222222222222222"},
101	101		{"ref":"refs/heads/new","old_id":"","new_id":"3333333333333333"},


@@ -95,7 +95,7 @@ func TestWatchNDJSON(t *testing.T) {
95		assert.True(t, json.Valid([]byte(sc.Text())), "one JSON value per line: %s", sc.Text())	95		assert.True(t, json.Valid([]byte(sc.Text())), "one JSON value per line: %s", sc.Text())
96		}	96		}
97		require.Len(t, lines, 5)	97		require.Len(t, lines, 5)
98	-	assert.JSONEq(t, `{"id":"1","time":"2026-10-10T12:00:00Z","type":"repo_created","repo":"beta","repository":{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"failing_checks_block":false,"allow_auto_merge":false,"issues":"off"}}`, lines[0])	98	+	assert.JSONEq(t, `{"id":"1","time":"2026-10-10T12:00:00Z","type":"repo_created","repo":"beta","repository":{"name":"beta","description":"","topics":[],"visibility":"private","default_branch":"trunk","created_at":"2026-02-02T00:00:00Z","pushed_at":null,"merge_modes":["squash"],"allow_auto_merge":false,"issues":"off"}}`, lines[0])
99		assert.JSONEq(t, `{"id":"3","time":"2026-10-10T12:00:00Z","type":"pushed","repo":"alpha","ref_updates":[	99		assert.JSONEq(t, `{"id":"3","time":"2026-10-10T12:00:00Z","type":"pushed","repo":"alpha","ref_updates":[
100		{"ref":"refs/heads/main","old_id":"1111111111111111","new_id":"2222222222222222"},	100		{"ref":"refs/heads/main","old_id":"1111111111111111","new_id":"2222222222222222"},
101		{"ref":"refs/heads/new","old_id":"","new_id":"3333333333333333"},	101		{"ref":"refs/heads/new","old_id":"","new_id":"3333333333333333"},

M internal/app/issue_api_test.go +0 -1


@@ -221,7 +221,6 @@ func TestIssuesFeatureAndSettingOverTheAPI(t *testing.T) {
221	221		updated, err := update(r.root, pb.IssuesMode_ISSUES_MODE_OWNER)
222	222		require.NoError(t, err)
223	223		assert.Equal(t, pb.IssuesMode_ISSUES_MODE_OWNER, updated.GetSettings().GetIssues())
224		-	assert.True(t, updated.GetSettings().GetFailingChecksBlock(), "the other settings are kept")
225	224		_, err = r.root.issue.CreateIssue(ctx, connect.NewRequest(&pb.CreateIssueRequest{Repo: "priv", Title: "t"}))
226	225		require.NoError(t, err)
227	226


@@ -221,7 +221,6 @@ func TestIssuesFeatureAndSettingOverTheAPI(t *testing.T) {
221		updated, err := update(r.root, pb.IssuesMode_ISSUES_MODE_OWNER)	221	updated, err := update(r.root, pb.IssuesMode_ISSUES_MODE_OWNER)
222		require.NoError(t, err)	222	require.NoError(t, err)
223		assert.Equal(t, pb.IssuesMode_ISSUES_MODE_OWNER, updated.GetSettings().GetIssues())	223	assert.Equal(t, pb.IssuesMode_ISSUES_MODE_OWNER, updated.GetSettings().GetIssues())
224	-	assert.True(t, updated.GetSettings().GetFailingChecksBlock(), "the other settings are kept")
225		_, err = r.root.issue.CreateIssue(ctx, connect.NewRequest(&pb.CreateIssueRequest{Repo: "priv", Title: "t"}))	224	_, err = r.root.issue.CreateIssue(ctx, connect.NewRequest(&pb.CreateIssueRequest{Repo: "priv", Title: "t"}))
226		require.NoError(t, err)	225	require.NoError(t, err)
227			226

M internal/app/mr_api_test.go +9 -9


@@ -299,7 +299,7 @@ func TestUpdateRepoSettingsOverTheAPI(t *testing.T) {
299	299		got, err := h.api("").repo.GetRepo(ctx, connect.NewRequest(&pb.GetRepoRequest{Repo: "proj"}))
300	300		require.NoError(t, err)
301	301		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_MERGE_COMMIT}, got.Msg.GetRepo().GetSettings().GetAllowedMergeModes())
302		-	assert.True(t, got.Msg.GetRepo().GetSettings().GetFailingChecksBlock())
	302	+	assert.False(t, got.Msg.GetRepo().GetSettings().GetAllowAutoMerge())
303	303
304	304		update := func(c clients, paths []string, s pb.RepoSettings) (*pb.Repo, error) {
305	305		res, err := c.repo.UpdateRepo(ctx, connect.NewRequest(&pb.UpdateRepoRequest{

@@ -311,23 +311,23 @@ func TestUpdateRepoSettingsOverTheAPI(t *testing.T) {
311	311		return res.Msg.GetRepo(), nil
312	312		}
313	313		repo, err := update(root, []string{"settings.allowed_merge_modes"}, &pb.RepoSettings{
314		-	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, FailingChecksBlock: false,
	314	+	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, AllowAutoMerge: false,
315	315		})
316	316		require.NoError(t, err)
317	317		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes())
318		-	assert.True(t, repo.GetSettings().GetFailingChecksBlock(), "not named in the mask: unchanged")
	318	+	assert.False(t, repo.GetSettings().GetAllowAutoMerge(), "not named in the mask: unchanged")
319	319
320		-	repo, err = update(root, []string{"settings.failing_checks_block"}, &pb.RepoSettings{FailingChecksBlock: false})
	320	+	repo, err = update(root, []string{"settings.allow_auto_merge"}, &pb.RepoSettings{AllowAutoMerge: false})
321	321		require.NoError(t, err)
322		-	assert.False(t, repo.GetSettings().GetFailingChecksBlock())
	322	+	assert.False(t, repo.GetSettings().GetAllowAutoMerge())
323	323		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes(), "not named in the mask: unchanged")
324	324
325	325		repo, err = update(root, []string{"settings"}, &pb.RepoSettings{
326		-	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, FailingChecksBlock: true,
	326	+	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, AllowAutoMerge: true,
327	327		})
328	328		require.NoError(t, err)
329	329		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes(), "canonical order, no duplicates")
330		-	assert.True(t, repo.GetSettings().GetFailingChecksBlock())
	330	+	assert.True(t, repo.GetSettings().GetAllowAutoMerge())
331	331
332	332		for name, s := range map[string]*pb.RepoSettings{
333	333		"no modes": {},

@@ -341,11 +341,11 @@ func TestUpdateRepoSettingsOverTheAPI(t *testing.T) {
341	341		assert.Equal(t, "invalid_argument", codeName(err))
342	342
343	343		// repo:admin is needed.
344		-	_, err = update(h.api(h.token(scopes(domain.ScopeRepoRead, domain.ScopeMRMerge))), []string{"settings.failing_checks_block"}, &pb.RepoSettings{})
	344	+	_, err = update(h.api(h.token(scopes(domain.ScopeRepoRead, domain.ScopeMRMerge))), []string{"settings.allow_auto_merge"}, &pb.RepoSettings{})
345	345		assert.Equal(t, "permission_denied", codeName(err))
346	346		got, err = root.repo.GetRepo(ctx, connect.NewRequest(&pb.GetRepoRequest{Repo: "proj"}))
347	347		require.NoError(t, err)
348		-	assert.True(t, got.Msg.GetRepo().GetSettings().GetFailingChecksBlock())
	348	+	assert.True(t, got.Msg.GetRepo().GetSettings().GetAllowAutoMerge())
349	349		}
350	350
351	351		// AC4 over the API: a mode the settings do not allow is refused.


@@ -299,7 +299,7 @@ func TestUpdateRepoSettingsOverTheAPI(t *testing.T) {
299		got, err := h.api("").repo.GetRepo(ctx, connect.NewRequest(&pb.GetRepoRequest{Repo: "proj"}))	299		got, err := h.api("").repo.GetRepo(ctx, connect.NewRequest(&pb.GetRepoRequest{Repo: "proj"}))
300		require.NoError(t, err)	300		require.NoError(t, err)
301		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_MERGE_COMMIT}, got.Msg.GetRepo().GetSettings().GetAllowedMergeModes())	301		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_MERGE_COMMIT}, got.Msg.GetRepo().GetSettings().GetAllowedMergeModes())
302	-	assert.True(t, got.Msg.GetRepo().GetSettings().GetFailingChecksBlock())	302	+	assert.False(t, got.Msg.GetRepo().GetSettings().GetAllowAutoMerge())
303			303
304		update := func(c clients, paths []string, s pb.RepoSettings) (*pb.Repo, error) {	304		update := func(c clients, paths []string, s pb.RepoSettings) (*pb.Repo, error) {
305		res, err := c.repo.UpdateRepo(ctx, connect.NewRequest(&pb.UpdateRepoRequest{	305		res, err := c.repo.UpdateRepo(ctx, connect.NewRequest(&pb.UpdateRepoRequest{

@@ -311,23 +311,23 @@ func TestUpdateRepoSettingsOverTheAPI(t *testing.T) {
311		return res.Msg.GetRepo(), nil	311		return res.Msg.GetRepo(), nil
312		}	312		}
313		repo, err := update(root, []string{"settings.allowed_merge_modes"}, &pb.RepoSettings{	313		repo, err := update(root, []string{"settings.allowed_merge_modes"}, &pb.RepoSettings{
314	-	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, FailingChecksBlock: false,	314	+	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, AllowAutoMerge: false,
315		})	315		})
316		require.NoError(t, err)	316		require.NoError(t, err)
317		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes())	317		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes())
318	-	assert.True(t, repo.GetSettings().GetFailingChecksBlock(), "not named in the mask: unchanged")	318	+	assert.False(t, repo.GetSettings().GetAllowAutoMerge(), "not named in the mask: unchanged")
319			319
320	-	repo, err = update(root, []string{"settings.failing_checks_block"}, &pb.RepoSettings{FailingChecksBlock: false})	320	+	repo, err = update(root, []string{"settings.allow_auto_merge"}, &pb.RepoSettings{AllowAutoMerge: false})
321		require.NoError(t, err)	321		require.NoError(t, err)
322	-	assert.False(t, repo.GetSettings().GetFailingChecksBlock())	322	+	assert.False(t, repo.GetSettings().GetAllowAutoMerge())
323		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes(), "not named in the mask: unchanged")	323		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes(), "not named in the mask: unchanged")
324			324
325		repo, err = update(root, []string{"settings"}, &pb.RepoSettings{	325		repo, err = update(root, []string{"settings"}, &pb.RepoSettings{
326	-	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, FailingChecksBlock: true,	326	+	AllowedMergeModes: []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH, pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, AllowAutoMerge: true,
327		})	327		})
328		require.NoError(t, err)	328		require.NoError(t, err)
329		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes(), "canonical order, no duplicates")	329		assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, repo.GetSettings().GetAllowedMergeModes(), "canonical order, no duplicates")
330	-	assert.True(t, repo.GetSettings().GetFailingChecksBlock())	330	+	assert.True(t, repo.GetSettings().GetAllowAutoMerge())
331			331
332		for name, s := range map[string]*pb.RepoSettings{	332		for name, s := range map[string]*pb.RepoSettings{
333		"no modes": {},	333		"no modes": {},

@@ -341,11 +341,11 @@ func TestUpdateRepoSettingsOverTheAPI(t *testing.T) {
341		assert.Equal(t, "invalid_argument", codeName(err))	341		assert.Equal(t, "invalid_argument", codeName(err))
342			342
343		// repo:admin is needed.	343		// repo:admin is needed.
344	-	_, err = update(h.api(h.token(scopes(domain.ScopeRepoRead, domain.ScopeMRMerge))), []string{"settings.failing_checks_block"}, &pb.RepoSettings{})	344	+	_, err = update(h.api(h.token(scopes(domain.ScopeRepoRead, domain.ScopeMRMerge))), []string{"settings.allow_auto_merge"}, &pb.RepoSettings{})
345		assert.Equal(t, "permission_denied", codeName(err))	345		assert.Equal(t, "permission_denied", codeName(err))
346		got, err = root.repo.GetRepo(ctx, connect.NewRequest(&pb.GetRepoRequest{Repo: "proj"}))	346		got, err = root.repo.GetRepo(ctx, connect.NewRequest(&pb.GetRepoRequest{Repo: "proj"}))
347		require.NoError(t, err)	347		require.NoError(t, err)
348	-	assert.True(t, got.Msg.GetRepo().GetSettings().GetFailingChecksBlock())	348	+	assert.True(t, got.Msg.GetRepo().GetSettings().GetAllowAutoMerge())
349		}	349		}
350			350
351		// AC4 over the API: a mode the settings do not allow is refused.	351		// AC4 over the API: a mode the settings do not allow is refused.

M internal/domain/ci.go +1 -1


@@ -42,7 +42,7 @@ const (
42	42		)
43	43
44	44		// PassesMerge reports whether a check that ended this way lets a merge go
45		-	// through under FailingChecksBlock: success, skipped and neutral do.
	45	+	// through under the merge checks policy: success, skipped and neutral do.
46	46		func (c CIConclusion) PassesMerge() bool {
47	47		return c == CISuccess \|\| c == CISkipped \|\| c == CINeutral
48	48		}


@@ -42,7 +42,7 @@ const (
42		)	42		)
43			43
44		// PassesMerge reports whether a check that ended this way lets a merge go	44		// PassesMerge reports whether a check that ended this way lets a merge go
45	-	// through under FailingChecksBlock: success, skipped and neutral do.	45	+	// through under the merge checks policy: success, skipped and neutral do.
46		func (c CIConclusion) PassesMerge() bool {	46		func (c CIConclusion) PassesMerge() bool {
47		return c == CISuccess \|\| c == CISkipped \|\| c == CINeutral	47		return c == CISuccess \|\| c == CISkipped \|\| c == CINeutral
48		}	48		}

M internal/domain/mergerequest.go +3 -5


@@ -46,8 +46,6 @@ type RepoSettings struct {
46	46		// AllowedMergeModes is never empty, in canonical order, without
47	47		// duplicates.
48	48		AllowedMergeModes []MergeMode
49		-	// FailingChecksBlock says that a failing check prevents the merge.
50		-	FailingChecksBlock bool
51	49		// Issues says who may write issues; the empty mode means IssuesOff.
52	50		Issues IssuesMode
53	51		// AllowAutoMerge says that merge requests may be set to merge themselves

@@ -55,10 +53,10 @@ type RepoSettings struct {
55	53		AllowAutoMerge bool
56	54		}
57	55
58		-	// DefaultRepoSettings are the settings of a new repository: every mode, and
59		-	// failing checks block the merge.
	56	+	// DefaultRepoSettings are the settings of a new repository: every merge mode,
	57	+	// with issues and auto-merge disabled.
60	58		func DefaultRepoSettings() RepoSettings {
61		-	return RepoSettings{AllowedMergeModes: MergeModes(), FailingChecksBlock: true, Issues: IssuesOff}
	59	+	return RepoSettings{AllowedMergeModes: MergeModes(), Issues: IssuesOff}
62	60		}
63	61
64	62		// IsZero reports whether s holds no mode, which only the zero value does.

 	// AllowedMergeModes is never empty, in canonical order, without
 	// duplicates.
 	AllowedMergeModes []MergeMode
-	// FailingChecksBlock says that a failing check prevents the merge.
-	FailingChecksBlock bool
 	// Issues says who may write issues; the empty mode means IssuesOff.
 	Issues IssuesMode
 	// AllowAutoMerge says that merge requests may be set to merge themselves
 	AllowAutoMerge bool
 }
-// DefaultRepoSettings are the settings of a new repository: every mode, and
+// DefaultRepoSettings are the settings of a new repository: every merge mode,
-// failing checks block the merge.
+// with issues and auto-merge disabled.
 func DefaultRepoSettings() RepoSettings {
-	return RepoSettings{AllowedMergeModes: MergeModes(), FailingChecksBlock: true, Issues: IssuesOff}
+	return RepoSettings{AllowedMergeModes: MergeModes(), Issues: IssuesOff}
 }
 // IsZero reports whether s holds no mode, which only the zero value does.

M internal/domain/mergerequest_test.go +0 -1


@@ -25,7 +25,6 @@ func TestDefaultRepoSettings(t *testing.T) {
25	25		t.Parallel()
26	26		s := domain.DefaultRepoSettings()
27	27		assert.Equal(t, []domain.MergeMode{domain.MergeModeFastForward, domain.MergeModeSquash, domain.MergeModeMerge}, s.AllowedMergeModes)
28		-	assert.True(t, s.FailingChecksBlock)
29	28		assert.True(t, s.Allows(domain.MergeModeSquash))
30	29		assert.False(t, domain.RepoSettings{}.Allows(domain.MergeModeSquash))
31	30		assert.True(t, domain.RepoSettings{}.IsZero())


@@ -25,7 +25,6 @@ func TestDefaultRepoSettings(t *testing.T) {
25		t.Parallel()	25	t.Parallel()
26		s := domain.DefaultRepoSettings()	26	s := domain.DefaultRepoSettings()
27		assert.Equal(t, []domain.MergeMode{domain.MergeModeFastForward, domain.MergeModeSquash, domain.MergeModeMerge}, s.AllowedMergeModes)	27	assert.Equal(t, []domain.MergeMode{domain.MergeModeFastForward, domain.MergeModeSquash, domain.MergeModeMerge}, s.AllowedMergeModes)
28	-	assert.True(t, s.FailingChecksBlock)
29		assert.True(t, s.Allows(domain.MergeModeSquash))	28	assert.True(t, s.Allows(domain.MergeModeSquash))
30		assert.False(t, domain.RepoSettings{}.Allows(domain.MergeModeSquash))	29	assert.False(t, domain.RepoSettings{}.Allows(domain.MergeModeSquash))
31		assert.True(t, domain.RepoSettings{}.IsZero())	30	assert.True(t, domain.RepoSettings{}.IsZero())

M internal/domain/token.go +4 -2


@@ -30,6 +30,8 @@ const (
30	30		ScopeMRWrite Scope = "mr:write"
31	31		// ScopeMRMerge merges, and deletes the merged source branch on request.
32	32		ScopeMRMerge Scope = "mr:merge"
	33	+	// ScopeMRForceMerge bypasses failing or unfinished merge checks.
	34	+	ScopeMRForceMerge Scope = "mr:force-merge"
33	35		// ScopeMRReview sets a verdict on a merge request.
34	36		ScopeMRReview Scope = "mr:review"
35	37		// ScopeCIWrite re-runs or cancels CI runs.

@@ -45,11 +47,11 @@ const (
45	47		ScopeIssueWrite Scope = "issue:write"
46	48		)
47	49
48		-	// AllScopes returns the eleven scopes in a stable order.
	50	+	// AllScopes returns the twelve scopes in a stable order.
49	51		func AllScopes() []Scope {
50	52		return []Scope{
51	53		ScopeRepoRead, ScopeRepoWrite, ScopeRepoAdmin,
52		-	ScopeMRWrite, ScopeMRMerge, ScopeMRReview,
	54	+	ScopeMRWrite, ScopeMRMerge, ScopeMRForceMerge, ScopeMRReview,
53	55		ScopeCIWrite, ScopeSecretsWrite, ScopeRunnerRegister,
54	56		ScopeTokenAdmin,
55	57		ScopeIssueWrite,

 	ScopeMRWrite Scope = "mr:write"
 	// ScopeMRMerge merges, and deletes the merged source branch on request.
 	ScopeMRMerge Scope = "mr:merge"
+	// ScopeMRForceMerge bypasses failing or unfinished merge checks.
+	ScopeMRForceMerge Scope = "mr:force-merge"
 	// ScopeMRReview sets a verdict on a merge request.
 	ScopeMRReview Scope = "mr:review"
 	// ScopeCIWrite re-runs or cancels CI runs.
 	ScopeIssueWrite Scope = "issue:write"
 )
-// AllScopes returns the eleven scopes in a stable order.
+// AllScopes returns the twelve scopes in a stable order.
 func AllScopes() []Scope {
 	return []Scope{
 		ScopeRepoRead, ScopeRepoWrite, ScopeRepoAdmin,
-		ScopeMRWrite, ScopeMRMerge, ScopeMRReview,
+		ScopeMRWrite, ScopeMRMerge, ScopeMRForceMerge, ScopeMRReview,
 		ScopeCIWrite, ScopeSecretsWrite, ScopeRunnerRegister,
 		ScopeTokenAdmin,
 		ScopeIssueWrite,

M internal/domain/token_test.go +1 -1


@@ -16,7 +16,7 @@ import (
16	16		func TestScopes(t *testing.T) {
17	17		t.Parallel()
18	18		all := domain.AllScopes()
19		-	assert.Len(t, all, 11)
	19	+	assert.Len(t, all, 12)
20	20		assert.Contains(t, all, domain.ScopeIssueWrite)
21	21		got, err := domain.ParseScope("issue:write")
22	22		require.NoError(t, err)


@@ -16,7 +16,7 @@ import (
16		func TestScopes(t *testing.T) {	16		func TestScopes(t *testing.T) {
17		t.Parallel()	17		t.Parallel()
18		all := domain.AllScopes()	18		all := domain.AllScopes()
19	-	assert.Len(t, all, 11)	19	+	assert.Len(t, all, 12)
20		assert.Contains(t, all, domain.ScopeIssueWrite)	20		assert.Contains(t, all, domain.ScopeIssueWrite)
21		got, err := domain.ParseScope("issue:write")	21		got, err := domain.ParseScope("issue:write")
22		require.NoError(t, err)	22		require.NoError(t, err)

M internal/ports/dto.go +2 -2


@@ -47,8 +47,6 @@ type UpdateRepoParams struct {
47	47		// AllowedMergeModes replaces the allowed merge modes; it must hold at
48	48		// least one known mode.
49	49		AllowedMergeModes *[]domain.MergeMode
50		-	// FailingChecksBlock replaces the setting of that name.
51		-	FailingChecksBlock *bool
52	50		// Issues replaces the issues mode.
53	51		Issues *domain.IssuesMode
54	52		// AllowAutoMerge replaces the setting of that name.

@@ -381,6 +379,8 @@ type AddCommentParams struct {
381	379
382	380		// MergeParams describes the merge to perform.
383	381		type MergeParams struct {
	382	+	// IgnoreChecks bypasses checks and requires mr:force-merge.
	383	+	IgnoreChecks bool
384	384		// Mode defaults to fast-forward.
385	385		Mode domain.MergeMode
386	386		// HeadID is the commit the caller reviewed; the source branch must still

 	// AllowedMergeModes replaces the allowed merge modes; it must hold at
 	// least one known mode.
 	AllowedMergeModes *[]domain.MergeMode
-	// FailingChecksBlock replaces the setting of that name.
-	FailingChecksBlock *bool
 	// Issues replaces the issues mode.
 	Issues *domain.IssuesMode
 	// AllowAutoMerge replaces the setting of that name.
 // MergeParams describes the merge to perform.
 type MergeParams struct {
+	// IgnoreChecks bypasses checks and requires mr:force-merge.
+	IgnoreChecks bool
 	// Mode defaults to fast-forward.
 	Mode domain.MergeMode
 	// HeadID is the commit the caller reviewed; the source branch must still

M internal/usecase/access.go +1 -1


@@ -36,7 +36,7 @@ func canReadAs(p domain.Principal, name domain.RepoName, vis domain.Visibility)
36	36		// repo:admin on it, and no branch prefixes. A token limited to some branches
37	37		// may not delete the repository (that deletes every branch, those outside its
38	38		// prefixes included), nor change its default branch, visibility, description,
39		-	// merge modes or failing-checks rule: these decide what happens to branches the
	39	+	// merge modes or auto-merge settings: these decide what happens to branches the
40	40		// token may not write. A caller that may not administer it learns nothing it
41	41		// could not already read: not found when it cannot see the repository,
42	42		// unauthenticated when it is anonymous, forbidden otherwise.


@@ -36,7 +36,7 @@ func canReadAs(p domain.Principal, name domain.RepoName, vis domain.Visibility)
36		// repo:admin on it, and no branch prefixes. A token limited to some branches	36		// repo:admin on it, and no branch prefixes. A token limited to some branches
37		// may not delete the repository (that deletes every branch, those outside its	37		// may not delete the repository (that deletes every branch, those outside its
38		// prefixes included), nor change its default branch, visibility, description,	38		// prefixes included), nor change its default branch, visibility, description,
39	-	// merge modes or failing-checks rule: these decide what happens to branches the	39	+	// merge modes or auto-merge settings: these decide what happens to branches the
40		// token may not write. A caller that may not administer it learns nothing it	40		// token may not write. A caller that may not administer it learns nothing it
41		// could not already read: not found when it cannot see the repository,	41		// could not already read: not found when it cannot see the repository,
42		// unauthenticated when it is anonymous, forbidden otherwise.	42		// unauthenticated when it is anonymous, forbidden otherwise.

M internal/usecase/automerge_test.go +1 -4


@@ -159,7 +159,7 @@ func TestAutoMergeMergesAsEnablerWhenAChecksPassed(t *testing.T) {
159	159		require.True(t, found)
160	160		}
161	161
162		-	func TestAutoMergeIgnoresFailingChecksBlockOff(t *testing.T) {
	162	+	func TestAutoMergeRequiresPassingChecks(t *testing.T) {
163	163		for _, tc := range []struct {
164	164		name string
165	165		check domain.CICheck

@@ -170,8 +170,6 @@ func TestAutoMergeIgnoresFailingChecksBlockOff(t *testing.T) {
170	170		t.Run(tc.name, func(t *testing.T) {
171	171		r, mr, checks := autoRig(t)
172	172		enableAuto(t, r, mr)
173		-	_, err := r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{FailingChecksBlock: ptr(false)})
174		-	require.NoError(t, err)
175	173		checks.EXPECT().CommitChecks(mock.Anything, r.repo, r.head().String()).Return([]domain.CICheck{{Status: domain.CICompleted, Conclusion: domain.CISuccess}, tc.check}, nil)
176	174		a := autoEvaluator(r, checks, nil, nil)
177	175		defer a.Close(r.ctx)

@@ -388,7 +386,6 @@ func TestMergeGateSettingsUpdateWaits(t *testing.T) {
388	386		for _, params := range []ports.UpdateRepoParams{
389	387		{AllowAutoMerge: ptr(false)},
390	388		{AllowedMergeModes: ptr([]domain.MergeMode{domain.MergeModeSquash})},
391		-	{FailingChecksBlock: ptr(false)},
392	389		} {
393	390		r, _, _ := autoRig(t)
394	391		r.repos.WithMergeGate(r.mrs)

 	require.True(t, found)
 }
-func TestAutoMergeIgnoresFailingChecksBlockOff(t *testing.T) {
+func TestAutoMergeRequiresPassingChecks(t *testing.T) {
 	for _, tc := range []struct {
 		name  string
 		check domain.CICheck
 		t.Run(tc.name, func(t *testing.T) {
 			r, mr, checks := autoRig(t)
 			enableAuto(t, r, mr)
-			_, err := r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{FailingChecksBlock: ptr(false)})
-			require.NoError(t, err)
 			checks.EXPECT().CommitChecks(mock.Anything, r.repo, r.head().String()).Return([]domain.CICheck{{Status: domain.CICompleted, Conclusion: domain.CISuccess}, tc.check}, nil)
 			a := autoEvaluator(r, checks, nil, nil)
 			defer a.Close(r.ctx)
 	for _, params := range []ports.UpdateRepoParams{
 		{AllowAutoMerge: ptr(false)},
 		{AllowedMergeModes: ptr([]domain.MergeMode{domain.MergeModeSquash})},
-		{FailingChecksBlock: ptr(false)},
 	} {
 		r, _, _ := autoRig(t)
 		r.repos.WithMergeGate(r.mrs)

M internal/usecase/ci_unit_test.go +37 -6


@@ -24,7 +24,7 @@ type mergeUnit struct {
24	24		head domain.ObjectID
25	25		}
26	26
27		-	func newMergeUnit(t testing.T, block bool) mergeUnit {
	27	+	func newMergeUnit(t testing.T) mergeUnit {
28	28		t.Helper()
29	29		u := &mrUnit{
30	30		meta: mocks.NewRepoMetaStore(t),

@@ -34,7 +34,6 @@ func newMergeUnit(t testing.T, block bool) mergeUnit {
34	34		repo: domain.Repo{Name: name(t, "proj"), Visibility: domain.VisibilityPrivate},
35	35		}
36	36		u.repo.Settings = domain.DefaultRepoSettings()
37		-	u.repo.Settings.FailingChecksBlock = block
38	37		clock := mocks.NewClock(t)
39	38		clock.EXPECT().Now().Return(now).Maybe()
40	39		sched := mocks.NewMaintenanceScheduler(t)

@@ -63,8 +62,8 @@ func (m *mergeUnit) merge() error {
63	62		return err
64	63		}
65	64
66		-	// AC5: the merge rule under FailingChecksBlock.
67		-	func TestMergeRuleOfFailingChecksBlock(t *testing.T) {
	65	+	// AC5: the merge rule under ChecksPolicy.
	66	+	func TestMergeRuleOfChecksPolicy(t *testing.T) {
68	67		t.Parallel()
69	68		check := func(status domain.CIStatus, c domain.CIConclusion, name string) domain.CICheck {
70	69		return domain.CICheck{Name: name, Status: status, Conclusion: c}

@@ -84,7 +83,7 @@ func TestMergeRuleOfFailingChecksBlock(t *testing.T) {
84	83		for _, tt := range tests {
85	84		t.Run(tt.name, func(t *testing.T) {
86	85		t.Parallel()
87		-	m := newMergeUnit(t, true)
	86	+	m := newMergeUnit(t)
88	87		m.checks.EXPECT().CommitChecks(mock.Anything, m.repo.Name, m.head.String()).Return(tt.checks, nil)
89	88		// The merge stops at the rule: the branch mock expects no move.
90	89		err := m.merge()

@@ -94,7 +93,7 @@ func TestMergeRuleOfFailingChecksBlock(t *testing.T) {
94	93		}
95	94		t.Run("too many checks to tell", func(t *testing.T) {
96	95		t.Parallel()
97		-	m := newMergeUnit(t, true)
	96	+	m := newMergeUnit(t)
98	97		m.checks.EXPECT().CommitChecks(mock.Anything, m.repo.Name, m.head.String()).Return(nil, domain.ErrResourceExhausted)
99	98		err := m.merge()
100	99		require.ErrorIs(t, err, domain.ErrPreconditionFailed)

@@ -174,3 +173,35 @@ func TestTokenShapes(t *testing.T) {
174	173		assert.False(t, domain.IsJobToken("ermite_"+good[10:]))
175	174		assert.False(t, domain.IsJobToken(good+"="))
176	175		}
	176	+
	177	+	func TestMergeChecksAndOverride(t *testing.T) {
	178	+	for _, tc := range []struct {
	179	+	name string
	180	+	principal domain.Principal
	181	+	checks []domain.CICheck
	182	+	ignore bool
	183	+	want error
	184	+	}{
	185	+	{name: "no checks allowed", principal: writer(domain.ScopeRepoRead, domain.ScopeMRMerge)},
	186	+	{name: "failure refused", principal: root, checks: []domain.CICheck{{Name: "build", Status: domain.CICompleted, Conclusion: domain.CIFailure}}, want: domain.ErrPreconditionFailed},
	187	+	{name: "pending refused", principal: root, checks: []domain.CICheck{{Name: "build", Status: domain.CIQueued}}, want: domain.ErrPreconditionFailed},
	188	+	{name: "force scope bypasses failure", principal: writer(domain.ScopeRepoRead, domain.ScopeMRMerge, domain.ScopeMRForceMerge), checks: []domain.CICheck{{Status: domain.CICompleted, Conclusion: domain.CIFailure}}, ignore: true},
	189	+	{name: "missing force scope denied", principal: writer(domain.ScopeRepoRead, domain.ScopeMRMerge), ignore: true, want: domain.ErrForbidden},
	190	+	{name: "force scope alone insufficient", principal: writer(domain.ScopeRepoRead, domain.ScopeMRForceMerge), ignore: true, want: domain.ErrForbidden},
	191	+	{name: "root override", principal: domain.Root(), ignore: true},
	192	+	{name: "owner override", principal: domain.Owner(), ignore: true},
	193	+	} {
	194	+	t.Run(tc.name, func(t *testing.T) {
	195	+	r, mr, checks := autoRig(t)
	196	+	if !tc.ignore {
	197	+	checks.EXPECT().CommitChecks(mock.Anything, r.repo, r.head().String()).Return(tc.checks, nil).Once()
	198	+	}
	199	+	_, err := r.mrs.Merge(r.ctx, tc.principal, r.repo, mr.Number, ports.MergeParams{HeadID: r.head(), IgnoreChecks: tc.ignore})
	200	+	if tc.want != nil {
	201	+	require.ErrorIs(t, err, tc.want)
	202	+	} else {
	203	+	require.NoError(t, err)
	204	+	}
	205	+	})
	206	+	}
	207	+	}

 	head   domain.ObjectID
 }
-func newMergeUnit(t *testing.T, block bool) *mergeUnit {
+func newMergeUnit(t *testing.T) *mergeUnit {
 	t.Helper()
 	u := &mrUnit{
 		meta:  mocks.NewRepoMetaStore(t),
 		repo:  domain.Repo{Name: name(t, "proj"), Visibility: domain.VisibilityPrivate},
 	}
 	u.repo.Settings = domain.DefaultRepoSettings()
-	u.repo.Settings.FailingChecksBlock = block
 	clock := mocks.NewClock(t)
 	clock.EXPECT().Now().Return(now).Maybe()
 	sched := mocks.NewMaintenanceScheduler(t)
 	return err
 }
-// AC5: the merge rule under FailingChecksBlock.
+// AC5: the merge rule under ChecksPolicy.
-func TestMergeRuleOfFailingChecksBlock(t *testing.T) {
+func TestMergeRuleOfChecksPolicy(t *testing.T) {
 	t.Parallel()
 	check := func(status domain.CIStatus, c domain.CIConclusion, name string) domain.CICheck {
 		return domain.CICheck{Name: name, Status: status, Conclusion: c}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			m := newMergeUnit(t, true)
+			m := newMergeUnit(t)
 			m.checks.EXPECT().CommitChecks(mock.Anything, m.repo.Name, m.head.String()).Return(tt.checks, nil)
 			// The merge stops at the rule: the branch mock expects no move.
 			err := m.merge()
 	}
 	t.Run("too many checks to tell", func(t *testing.T) {
 		t.Parallel()
-		m := newMergeUnit(t, true)
+		m := newMergeUnit(t)
 		m.checks.EXPECT().CommitChecks(mock.Anything, m.repo.Name, m.head.String()).Return(nil, domain.ErrResourceExhausted)
 		err := m.merge()
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 	assert.False(t, domain.IsJobToken("ermite_"+good[10:]))
 	assert.False(t, domain.IsJobToken(good+"="))
 }
+func TestMergeChecksAndOverride(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		principal domain.Principal
+		checks    []domain.CICheck
+		ignore    bool
+		want      error
+	}{
+		{name: "no checks allowed", principal: writer(domain.ScopeRepoRead, domain.ScopeMRMerge)},
+		{name: "failure refused", principal: root, checks: []domain.CICheck{{Name: "build", Status: domain.CICompleted, Conclusion: domain.CIFailure}}, want: domain.ErrPreconditionFailed},
+		{name: "pending refused", principal: root, checks: []domain.CICheck{{Name: "build", Status: domain.CIQueued}}, want: domain.ErrPreconditionFailed},
+		{name: "force scope bypasses failure", principal: writer(domain.ScopeRepoRead, domain.ScopeMRMerge, domain.ScopeMRForceMerge), checks: []domain.CICheck{{Status: domain.CICompleted, Conclusion: domain.CIFailure}}, ignore: true},
+		{name: "missing force scope denied", principal: writer(domain.ScopeRepoRead, domain.ScopeMRMerge), ignore: true, want: domain.ErrForbidden},
+		{name: "force scope alone insufficient", principal: writer(domain.ScopeRepoRead, domain.ScopeMRForceMerge), ignore: true, want: domain.ErrForbidden},
+		{name: "root override", principal: domain.Root(), ignore: true},
+		{name: "owner override", principal: domain.Owner(), ignore: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			r, mr, checks := autoRig(t)
+			if !tc.ignore {
+				checks.EXPECT().CommitChecks(mock.Anything, r.repo, r.head().String()).Return(tc.checks, nil).Once()
+			}
+			_, err := r.mrs.Merge(r.ctx, tc.principal, r.repo, mr.Number, ports.MergeParams{HeadID: r.head(), IgnoreChecks: tc.ignore})
+			if tc.want != nil {
+				require.ErrorIs(t, err, tc.want)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

M internal/usecase/mergerequests.go +12 -5


@@ -995,8 +995,9 @@ func (m *MergeRequests) MarkRead(ctx context.Context, p domain.Principal, name d
995	995		// allowed by the settings of the repository, the source branch no longer
996	996		// points to the head ("branch moved, read again") or is gone, the target is
997	997		// gone, the mode's own condition does not hold (see below), or the branch
998		-	// brings nothing. Checks come with CI (CI-1): there are none yet, so the
999		-	// setting that lets failing checks block the merge has nothing to act on.
	998	+	// brings nothing. Checks on the head must pass: none may be failed, queued
	999	+	// or running; a head with no checks may be merged. params.IgnoreChecks bypasses
	1000	+	// this requirement and needs mr:force-merge.
1000	1001		//
1001	1002		// The conditions are always checked with Git, under the lock, never from the
1002	1003		// stored mergeability. A fast-forward needs the target to be an ancestor of

@@ -1075,9 +1076,15 @@ var errAutoMergeWait = errors.New("auto-merge is waiting for checks")
1075	1076
1076	1077		func (m *MergeRequests) mergeAs(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams, opts mergeOpts) (domain.MergeRequest, error) {
1077	1078		if opts.auto == nil {
1078		-	if _, err := m.writable(ctx, p, name, domain.ScopeMRMerge); err != nil {
	1079	+	repo, err := m.writable(ctx, p, name, domain.ScopeMRMerge)
	1080	+	if err != nil {
1079	1081		return domain.MergeRequest{}, err
1080	1082		}
	1083	+	if params.IgnoreChecks {
	1084	+	if err := scopeAccess(p, repo, domain.ScopeMRForceMerge); err != nil {
	1085	+	return domain.MergeRequest{}, err
	1086	+	}
	1087	+	}
1081	1088		}
1082	1089		mode := params.Mode
1083	1090		if mode == "" {

@@ -1179,7 +1186,7 @@ func (m *MergeRequests) mergeAs(ctx context.Context, p domain.Principal, name do
1179	1186		if opts.auto != nil && !settings.AllowAutoMerge {
1180	1187		return domain.MergeRequest{}, fmt.Errorf("%w: auto-merge is off in %s", domain.ErrPreconditionFailed, name)
1181	1188		}
1182		-	if settings.FailingChecksBlock \|\| opts.auto != nil {
	1189	+	if !params.IgnoreChecks \|\| opts.auto != nil {
1183	1190		checks, err := m.readMergeChecks(ctx, name, head)
1184	1191		if err == nil {
1185	1192		err = checksPolicy(checks)

@@ -1362,7 +1369,7 @@ func checksPolicy(checks []domain.CICheck) error {
1362	1369		}
1363	1370		switch {
1364	1371		case len(failing) > 0:
1365		-	return fmt.Errorf("%w: failing checks block the merge: %s (turn off failing_checks_block to merge anyway)", domain.ErrPreconditionFailed, strings.Join(failing, ", "))
	1372	+	return fmt.Errorf("%w: failing checks block the merge: %s (merge with --ignore-checks, needs the mr:force-merge scope)", domain.ErrPreconditionFailed, strings.Join(failing, ", "))
1366	1373		case len(pending) > 0:
1367	1374		return fmt.Errorf("%w: checks have not finished: %s", domain.ErrPreconditionFailed, strings.Join(pending, ", "))
1368	1375		}

 // allowed by the settings of the repository, the source branch no longer
 // points to the head ("branch moved, read again") or is gone, the target is
 // gone, the mode's own condition does not hold (see below), or the branch
-// brings nothing. Checks come with CI (CI-1): there are none yet, so the
+// brings nothing. Checks on the head must pass: none may be failed, queued
-// setting that lets failing checks block the merge has nothing to act on.
+// or running; a head with no checks may be merged. params.IgnoreChecks bypasses
+// this requirement and needs mr:force-merge.
 //
 // The conditions are always checked with Git, under the lock, never from the
 // stored mergeability. A fast-forward needs the target to be an ancestor of
 func (m *MergeRequests) mergeAs(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams, opts mergeOpts) (domain.MergeRequest, error) {
 	if opts.auto == nil {
-		if _, err := m.writable(ctx, p, name, domain.ScopeMRMerge); err != nil {
+		repo, err := m.writable(ctx, p, name, domain.ScopeMRMerge)
+		if err != nil {
 			return domain.MergeRequest{}, err
 		}
+		if params.IgnoreChecks {
+			if err := scopeAccess(p, repo, domain.ScopeMRForceMerge); err != nil {
+				return domain.MergeRequest{}, err
+			}
+		}
 	}
 	mode := params.Mode
 	if mode == "" {
 	if opts.auto != nil && !settings.AllowAutoMerge {
 		return domain.MergeRequest{}, fmt.Errorf("%w: auto-merge is off in %s", domain.ErrPreconditionFailed, name)
 	}
-	if settings.FailingChecksBlock || opts.auto != nil {
+	if !params.IgnoreChecks || opts.auto != nil {
 		checks, err := m.readMergeChecks(ctx, name, head)
 		if err == nil {
 			err = checksPolicy(checks)
 	}
 	switch {
 	case len(failing) > 0:
-		return fmt.Errorf("%w: failing checks block the merge: %s (turn off failing_checks_block to merge anyway)", domain.ErrPreconditionFailed, strings.Join(failing, ", "))
+		return fmt.Errorf("%w: failing checks block the merge: %s (merge with --ignore-checks, needs the mr:force-merge scope)", domain.ErrPreconditionFailed, strings.Join(failing, ", "))
 	case len(pending) > 0:
 		return fmt.Errorf("%w: checks have not finished: %s", domain.ErrPreconditionFailed, strings.Join(pending, ", "))
 	}

M internal/usecase/mergerequests_integration_test.go +5 -5

show this file

M internal/usecase/repos_write.go +4 -7

show this file

M internal/usecase/repos_write_test.go +1 -3

show this file

M proto/ermite/storage/merge_request.proto +2 -1

show this file

M skills/ermite/CLI.md +10 -4

show this file

M skills/ermite/SKILL.md +5 -3

show this file

Commit	Subject	Author	Date	Signature
f61e6a6	fix(store): keep failing_checks_block as a deprecated storage field, run the new subtests in parallel	brice	21h ago	GPG Verified
923f868	build(deps): use ermite-api v0.15.0	brice	21h ago	GPG Verified
eba8ed7	fix(scopes): keep the owner rights of full tokens with mr:force-merge, refresh the owner's merge check controls live	brice	24h ago	GPG Verified
7348bb2	feat(web): offer ignore checks on the merge form, document mr ready and the merge check rules	brice	24h ago	GPG Verified
5d0c190	feat(cli): add mr ready and mr merge --ignore-checks, implement the MarkReady RPC	brice	24h ago	GPG Verified
cfc292c	feat(merge): require passing checks to merge, add mr:force-merge and ignore_checks, drop failing_checks_block	brice	24h ago	GPG Verified

Merge settings

Comments2 open / 2