From cdf2566f195e7a47a933affc87b74029d8903055 Mon Sep 17 00:00:00 2001 From: cairn-reviewer-scratch Date: Wed, 19 Aug 2026 17:46:50 -0700 Subject: [PATCH 1/3] =?UTF-8?q?test(feat):=20red=20=E2=80=94=20reviewer=20?= =?UTF-8?q?resolves=20before=20commit;=20rig=20tier=20ignores=20$GC=5FRIG?= =?UTF-8?q?=20(refs=20crn-rott9.1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cmd/branches_test.go | 7 +++-- cmd/cull_test.go | 28 +++++++++++++++++++ cmd/promote_test.go | 29 +++++++++++++++++++ cmd/remember_batch_test.go | 41 ++++++++++++++++++++++++++- cmd/remember_test.go | 45 +++++++++++++++++++++++------- cmd/reviewer_test.go | 57 ++++++++++++++++++++++++++++++-------- 6 files changed, 182 insertions(+), 25 deletions(-) diff --git a/cmd/branches_test.go b/cmd/branches_test.go index e9a2d647..f10a2345 100644 --- a/cmd/branches_test.go +++ b/cmd/branches_test.go @@ -206,7 +206,10 @@ func TestStaleBranchesEscalatesOnlyAfterPriorNotify(t *testing.T) { func TestStaleBranchesEscalateReviewerResolutionFailureReportsError(t *testing.T) { store := t.TempDir() gitInit(t, store) - e := commitReviewBranchAt(t, store, "escalate-topic", []string{"rig:web"}, time.Now().Add(-3*time.Hour)) + // role:, not rig: -- crn-rott9.1 fixed rig tier to resolve from the + // entry's own declared rig value instead of $GC_RIG, so only role tier can + // still be forced to fail resolution via stubGCWithRig("") below. + e := commitReviewBranchAt(t, store, "escalate-topic", []string{"role:reviewer"}, time.Now().Add(-3*time.Hour)) stateFile := filepath.Join(t.TempDir(), "state.json") first, err := runStaleBranches(t, store, stubGCWithRig("myrig"), @@ -214,7 +217,7 @@ func TestStaleBranchesEscalateReviewerResolutionFailureReportsError(t *testing.T require.NoError(t, err) require.Len(t, first, 1) require.Equal(t, "notify", first[0].Status, "precondition: first pass must downgrade to notify, not escalate") - require.Equal(t, "myrig/architect", first[0].Reviewer, "precondition: reviewer must resolve successfully on the first pass") + require.Equal(t, "myrig/reviewer", first[0].Reviewer, "precondition: reviewer must resolve successfully on the first pass") require.True(t, first[0].Notified) second, err := runStaleBranches(t, store, stubGCWithRig(""), diff --git a/cmd/cull_test.go b/cmd/cull_test.go index 17f22cf9..c9d6fdb7 100644 --- a/cmd/cull_test.go +++ b/cmd/cull_test.go @@ -109,6 +109,34 @@ func TestCullEvictSharedTierProposesReviewBranchAndDoesNotDeleteDirectly(t *test assert.Contains(t, lines[0], branch) } +// TestCullEvictReviewerResolutionFailureCommitsNothing is crn-rott9.1's +// regression guard for requestCullReview: resolveReviewer must run BEFORE +// EvictToReviewBranch, so a resolution failure leaves no cull/ branch at +// all -- true fail-closed, not proposed-but-unnotified. role: is used to +// force the failure since rig: no longer depends on $GC_RIG post-crn-rott9.1. +func TestCullEvictReviewerResolutionFailureCommitsNothing(t *testing.T) { + store := t.TempDir() + gitInit(t, store) + e := seedCommittedEntry(t, store, []string{"role:reviewer"}) + headBefore := strings.TrimSpace(gitOutput(t, store, "rev-parse", "HEAD")) + + resetCullEvictFlags(t) + t.Cleanup(func() { resetCullEvictFlags(t) }) + stubGCWithRig("")(t) + rootCmd.SetArgs([]string{"cull-evict", "--store", store, e.ID}) + rootCmd.SetOut(&bytes.Buffer{}) + rootCmd.SetErr(&bytes.Buffer{}) + err := rootCmd.Execute() + require.Error(t, err, "an unresolvable reviewer must fail cull-evict") + assert.Contains(t, err.Error(), "GC_RIG") + + headAfter := strings.TrimSpace(gitOutput(t, store, "rev-parse", "HEAD")) + assert.Equal(t, headBefore, headAfter, "an unresolvable reviewer must leave the store's HEAD untouched") + + branches := gitOutput(t, store, "branch", "--list", "cull/*") + assert.Empty(t, strings.TrimSpace(branches), "an unresolvable reviewer must leave no cull/ review branch at all") +} + func TestCullEvictUnknownIDReturnsClearError(t *testing.T) { store := t.TempDir() gitInit(t, store) diff --git a/cmd/promote_test.go b/cmd/promote_test.go index 907787a6..f36dad44 100644 --- a/cmd/promote_test.go +++ b/cmd/promote_test.go @@ -90,6 +90,35 @@ func TestPromoteMarkSharedTierProposesReviewBranchAndDoesNotCommitDirectly(t *te assert.Contains(t, lines[0], branch) } +// TestPromoteMarkReviewerResolutionFailureCommitsNothing is crn-rott9.1's +// regression guard for requestPromotionReview: resolveReviewer must run +// BEFORE CommitPromotionToReviewBranch, so a resolution failure leaves no +// remember/ branch at all -- true fail-closed, not +// committed-but-unnotified. role: is used to force the failure since rig: no +// longer depends on $GC_RIG post-crn-rott9.1. +func TestPromoteMarkReviewerResolutionFailureCommitsNothing(t *testing.T) { + store := t.TempDir() + gitInit(t, store) + e := seedCommittedEntry(t, store, []string{"role:reviewer"}) + headBefore := strings.TrimSpace(gitOutput(t, store, "rev-parse", "HEAD")) + + resetPromoteMarkFlags(t) + t.Cleanup(func() { resetPromoteMarkFlags(t) }) + stubGCWithRig("")(t) + rootCmd.SetArgs([]string{"promote-mark", "--store", store, e.ID, "--bead", "crn-abcd"}) + rootCmd.SetOut(&bytes.Buffer{}) + rootCmd.SetErr(&bytes.Buffer{}) + err := rootCmd.Execute() + require.Error(t, err, "an unresolvable reviewer must fail promote-mark") + assert.Contains(t, err.Error(), "GC_RIG") + + headAfter := strings.TrimSpace(gitOutput(t, store, "rev-parse", "HEAD")) + assert.Equal(t, headBefore, headAfter, "an unresolvable reviewer must leave the store's HEAD untouched") + + branches := gitOutput(t, store, "branch", "--list", "remember/*") + assert.Empty(t, strings.TrimSpace(branches), "an unresolvable reviewer must leave no remember/ review branch at all") +} + func TestPromoteMarkUnknownIDReturnsClearError(t *testing.T) { store := t.TempDir() gitInit(t, store) diff --git a/cmd/remember_batch_test.go b/cmd/remember_batch_test.go index 71bce931..02160c1e 100644 --- a/cmd/remember_batch_test.go +++ b/cmd/remember_batch_test.go @@ -480,7 +480,46 @@ func TestRememberBatchGroupsMailByDistinctResolvedReviewer(t *testing.T) { require.Len(t, c, 7, "gc mail send -s -m ") recipients[i] = c[2] } - assert.ElementsMatch(t, []string{"test-rig/architect", "test-rig/builder"}, recipients) + // "web/architect", not "test-rig/architect": since crn-rott9.1, rig:web + // resolves its reviewer from the entry's own declared rig value ("web"), + // not from writeStubGC's pinned $GC_RIG ("test-rig"). role:builder is + // unaffected -- role tier still resolves via $GC_RIG + "/" + value. + assert.ElementsMatch(t, []string{"web/architect", "test-rig/builder"}, recipients) +} + +// TestRememberBatchReviewerResolutionFailureCommitsNothing is crn-rott9.1's +// regression guard for commitForBatchReview: resolveReviewer must run BEFORE +// CommitToReviewBranch, so a resolution failure leaves no remember/ +// branch for that line at all. role: is used to force the failure since +// rig: no longer depends on $GC_RIG post-crn-rott9.1. +func TestRememberBatchReviewerResolutionFailureCommitsNothing(t *testing.T) { + resetRememberFlags(t) + resetBatchFlag(t) + t.Cleanup(func() { + resetRememberFlags(t) + resetBatchFlag(t) + }) + + manifest := writeBatchManifest( + t, + batchManifestLine(t, map[string]any{"body": "unresolvable entry", "scope": []string{"role:reviewer"}, "topic": "resolve-fail"}), + ) + store := t.TempDir() + gitInit(t, store) + stubGCWithRig("")(t) + + var runErr error + stdout := captureStdout(t, func() { + rootCmd.SetArgs([]string{"remember", "--store", store, "--batch-file", manifest}) + rootCmd.SetOut(&bytes.Buffer{}) + rootCmd.SetErr(&bytes.Buffer{}) + runErr = rootCmd.Execute() + }) + require.Error(t, runErr, "a batch containing an unresolvable-reviewer line must exit non-zero") + assert.Contains(t, stdout, "GC_RIG", "the per-line failure must be reported in the plain-text summary") + + branches := gitOutput(t, store, "branch", "--list", "remember/*") + assert.Empty(t, strings.TrimSpace(branches), "an unresolvable reviewer must leave no remember/ review branch at all") } // TestRememberBatchRejectsManifestOverSizeCap pins the 5000-line cap's diff --git a/cmd/remember_test.go b/cmd/remember_test.go index e43a4310..566b5427 100644 --- a/cmd/remember_test.go +++ b/cmd/remember_test.go @@ -234,12 +234,15 @@ func stubGCFail(t *testing.T) { // stubGCWithRig mirrors stubGC (a stub gc binary that always succeeds), but // pins GC_RIG to rig instead of writeStubGC's fixed "test-rig" -- letting a -// test control rig/role-tier default-reviewer resolution directly, including +// test control role-tier default-reviewer resolution directly, including // simulating $GC_RIG being unset (rig == "") to make resolveReviewer's -// rig-tier branch fail deterministically. A caller cannot get this effect by -// just calling t.Setenv("GC_RIG", ...) around a runStaleBranches/runRemember -// call that stubs with plain stubGC: writeStubGC's own GC_RIG pin runs -// inside that call (stub(t) fires before rootCmd.Execute()) and always wins. +// role-tier branch fail deterministically. (Rig-tier resolution no longer +// depends on $GC_RIG at all as of crn-rott9.1 -- it resolves from the +// entry's own declared rig value instead -- so only role: scope can still be +// used to force this failure.) A caller cannot get this effect by just +// calling t.Setenv("GC_RIG", ...) around a runStaleBranches/runRemember call +// that stubs with plain stubGC: writeStubGC's own GC_RIG pin runs inside +// that call (stub(t) fires before rootCmd.Execute()) and always wins. func stubGCWithRig(rig string) func(*testing.T) { return func(t *testing.T) { t.Helper() @@ -1169,6 +1172,27 @@ func TestRememberCLIRoundTripAllFieldsRoleTier(t *testing.T) { assert.NoError(t, err, "created_at must be an RFC3339 timestamp (crn-3476/crn-zcxq FR-5)") } +// TestRememberSharedTierReviewerResolutionFailureCommitsNothing is +// crn-rott9.1's regression guard for requestReview: resolveReviewer must run +// BEFORE CommitToReviewBranch, so a resolution failure leaves no +// remember/ review branch at all -- true fail-closed, not +// committed-but-unnotified as it was before this fix. role: is used to force +// the failure since rig: no longer depends on $GC_RIG post-crn-rott9.1 (see +// TestRememberSharedTierRigScopeVisibleAfterReviewMerge). +func TestRememberSharedTierReviewerResolutionFailureCommitsNothing(t *testing.T) { + var store string + var runErr error + stdout := captureStdout(t, func() { + store, runErr = runRememberWithGC(t, stubGCWithRig(""), "--topic", "valid-topic", "--scope", "role:reviewer", "a body") + }) + require.Error(t, runErr, "an unresolvable reviewer must fail the command") + assert.Contains(t, runErr.Error(), "GC_RIG") + assert.Empty(t, strings.TrimSpace(stdout), "resolution must fail before any review-branch line is printed") + + branches := gitOutput(t, store, "branch", "--list", "remember/*") + assert.Empty(t, strings.TrimSpace(branches), "an unresolvable reviewer must leave no remember/ review branch at all") +} + // TestRememberSharedTierRigScopeVisibleAfterReviewMerge is the full rig: // scope lifecycle no existing test exercised end to end before crn-0tsu // FR-6: every other shared-tier test stops at "the review branch exists" or @@ -1182,10 +1206,11 @@ func TestRememberCLIRoundTripAllFieldsRoleTier(t *testing.T) { func TestRememberSharedTierRigScopeVisibleAfterReviewMerge(t *testing.T) { store := t.TempDir() gitInit(t, store) - // Pinned explicitly (not just relied on as writeStubGC's side effect): - // this round trip's correctness claim is specifically about $GC_RIG - // flowing through to the reviewer address, so the test states that - // dependency itself rather than borrowing it from the stub helper. + // Pinned explicitly to a value DIFFERENT from the entry's own declared + // rig ("web"), not just relied on as writeStubGC's side effect: since + // crn-rott9.1, a rig:-scope entry's default reviewer resolves from its + // own declared rig value, not $GC_RIG, and this deliberate mismatch is + // what proves $GC_RIG is correctly ignored here. t.Setenv("GC_RIG", "test-rig") captureFile := filepath.Join(t.TempDir(), "gc-invocation") @@ -1199,7 +1224,7 @@ func TestRememberSharedTierRigScopeVisibleAfterReviewMerge(t *testing.T) { args := readStubGCArgs(t, captureFile) require.Len(t, args, 7, "gc mail send -s -m ") - assert.Equal(t, "test-rig/architect", args[2], "a rig:-scope entry's default reviewer must be $GC_RIG/architect") + assert.Equal(t, "web/architect", args[2], "a rig:-scope entry's default reviewer must be /architect, ignoring $GC_RIG entirely") require.NoError(t, runReviewCmd(t, "review", "merge", branch, "--store", store, "--topic-key", "rig-roundtrip")) diff --git a/cmd/reviewer_test.go b/cmd/reviewer_test.go index 0f6922f4..574982c5 100644 --- a/cmd/reviewer_test.go +++ b/cmd/reviewer_test.go @@ -24,15 +24,19 @@ func reviewerFlagCmd(t *testing.T, reviewerFlag string) *cobra.Command { } // TestDefaultReviewerPerTier covers crn-419.4 AC3's three computed defaults. -// Only the "rig" case was previously exercised, indirectly, via the CLI -// test's fixed --scope rig:web (crn-kbf). +// The rig case is pinned against a *different* $GC_RIG ("myrig") than its +// expected reviewer ("web/architect") deliberately: crn-rott9.1 fixed rig +// tier to resolve from the entry's own declared rig value, not $GC_RIG, and +// a rig case that happened to share the same string as $GC_RIG would not +// prove that -- it would pass identically whether the fix resolves value or +// falls through to the old $GC_RIG-based behavior. func TestDefaultReviewerPerTier(t *testing.T) { t.Setenv("GC_RIG", "myrig") cases := []struct { tier, value, want string }{ {"global", "", "mayor"}, - {"rig", "web", "myrig/architect"}, + {"rig", "web", "web/architect"}, {"role", "reviewer", "myrig/reviewer"}, } for _, tc := range cases { @@ -44,15 +48,44 @@ func TestDefaultReviewerPerTier(t *testing.T) { } } -func TestDefaultReviewerSharedTiersRequireGCRig(t *testing.T) { - for _, tier := range []string{"rig", "role"} { - t.Run(tier, func(t *testing.T) { - t.Setenv("GC_RIG", "") - _, err := defaultReviewer(tier, "web") - require.Error(t, err, "a rig/role default reviewer can't be computed without $GC_RIG") - assert.Contains(t, err.Error(), "GC_RIG") - }) - } +// TestDefaultReviewerRoleTierRequiresGCRig is +// TestDefaultReviewerSharedTiersRequireGCRig narrowed to role alone +// (crn-rott9.1): rig tier no longer depends on $GC_RIG at all, since it now +// resolves the reviewer from the entry's own declared rig value -- storage +// under rig: is unambiguous about which rig's reviewer should see it, +// unlike role tier, where the entry's own scope carries no rig at all and +// $GC_RIG remains the only available signal for which rig's role-holder +// should review. +func TestDefaultReviewerRoleTierRequiresGCRig(t *testing.T) { + t.Setenv("GC_RIG", "") + _, err := defaultReviewer("role", "web") + require.Error(t, err, "a role default reviewer can't be computed without $GC_RIG") + assert.Contains(t, err.Error(), "GC_RIG") +} + +// TestDefaultReviewerRigTierIgnoresGCRig is crn-rott9.1's core regression +// guard: rig tier must resolve purely from the entry's own declared rig +// value, so it succeeds even with $GC_RIG completely unset. +func TestDefaultReviewerRigTierIgnoresGCRig(t *testing.T) { + t.Setenv("GC_RIG", "") + got, err := defaultReviewer("rig", "web") + require.NoError(t, err, "rig tier must not require $GC_RIG -- it resolves from the entry's own declared rig value") + assert.Equal(t, "web/architect", got) +} + +// TestDefaultReviewerRigTierRequiresNonEmptyValue covers the edge crn-rott9.1 +// introduces: an empty rig value (a malformed "rig:" scope tag with nothing +// after the colon) must still fail clearly rather than silently producing +// "/architect", regardless of $GC_RIG. $GC_RIG is pinned non-empty here +// (rather than left ambient) specifically to prove the failure comes from +// the empty value, not a Try-$GC_RIG-first fallback -- this test binary may +// itself be running inside a real gc rig with $GC_RIG already set (see +// stubGC's own doc comment). +func TestDefaultReviewerRigTierRequiresNonEmptyValue(t *testing.T) { + t.Setenv("GC_RIG", "myrig") + _, err := defaultReviewer("rig", "") + require.Error(t, err, "a rig default reviewer can't be computed without the entry's own declared rig value") + assert.Contains(t, err.Error(), "rig value") } func TestDefaultReviewerUnknownTier(t *testing.T) { From b1320d785ae8b5d28527f6ffd2356f7f944291ce Mon Sep 17 00:00:00 2001 From: cairn-reviewer-scratch Date: Wed, 19 Aug 2026 17:55:58 -0700 Subject: [PATCH 2/3] =?UTF-8?q?feat:=20green=20=E2=80=94=20reviewer=20reso?= =?UTF-8?q?lves=20before=20commit;=20rig=20tier=20ignores=20$GC=5FRIG=20(r?= =?UTF-8?q?efs=20crn-rott9.1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reorder requestReview, commitForBatchReview, requestCullReview, and requestPromotionReview to call resolveReviewer before their respective commit-to-review-branch step, so a resolution failure leaves nothing committed anywhere -- true fail-closed instead of committed-but-unnotified. Fix defaultReviewer's rig-tier case to resolve from the entry's own declared rig value (from cairn.ResolvedTier) instead of $GC_RIG: an entry stored under rig: is unambiguous about which rig's reviewer should see it, regardless of which rig the writing agent happens to be running in. role tier is deliberately left $GC_RIG-based -- role-tier storage carries no rig of its own, so $GC_RIG remains the only available signal there. Also relax TestRememberSharedTierReviewerResolutionFailureCommitsNothing's stdout assertion: remember.go always echoes the new entry's ID right after the loose file write, before the tier branch is even decided -- unconditional and orthogonal to this fix. The test now checks for the absence of "review branch:"/"mailed reviewer:" lines instead of total silence. --- cmd/remember_test.go | 10 +++++- cmd/reviewer.go | 75 +++++++++++++++++++++++++++----------------- 2 files changed, 56 insertions(+), 29 deletions(-) diff --git a/cmd/remember_test.go b/cmd/remember_test.go index 566b5427..59199340 100644 --- a/cmd/remember_test.go +++ b/cmd/remember_test.go @@ -1179,6 +1179,13 @@ func TestRememberCLIRoundTripAllFieldsRoleTier(t *testing.T) { // committed-but-unnotified as it was before this fix. role: is used to force // the failure since rig: no longer depends on $GC_RIG post-crn-rott9.1 (see // TestRememberSharedTierRigScopeVisibleAfterReviewMerge). +// +// stdout is NOT asserted empty: remember.go prints the freshly created +// entry's ID right after e.Create() writes its loose (uncommitted) file, +// before the private/shared tier branch is even decided -- that echo is +// unconditional and orthogonal to this fix, which is about the git commit to +// a review branch, not the local file write. What must be absent is any +// trace that a review branch was committed or a reviewer was mailed. func TestRememberSharedTierReviewerResolutionFailureCommitsNothing(t *testing.T) { var store string var runErr error @@ -1187,7 +1194,8 @@ func TestRememberSharedTierReviewerResolutionFailureCommitsNothing(t *testing.T) }) require.Error(t, runErr, "an unresolvable reviewer must fail the command") assert.Contains(t, runErr.Error(), "GC_RIG") - assert.Empty(t, strings.TrimSpace(stdout), "resolution must fail before any review-branch line is printed") + assert.NotContains(t, stdout, "review branch:", "resolution must fail before any review-branch line is printed") + assert.NotContains(t, stdout, "mailed reviewer:", "resolution must fail before any reviewer is reported as mailed") branches := gitOutput(t, store, "branch", "--list", "remember/*") assert.Empty(t, strings.TrimSpace(branches), "an unresolvable reviewer must leave no remember/ review branch at all") diff --git a/cmd/reviewer.go b/cmd/reviewer.go index 730f8123..90dd5da9 100644 --- a/cmd/reviewer.go +++ b/cmd/reviewer.go @@ -18,10 +18,18 @@ import ( // only invoke this for a scope that has already resolved away from the // private agent tier (RunE branches on cairn.IsPrivateScope before ever // reaching here). e's entry file already exists on disk by this point; -// nothing here can undo that, only report a downstream failure. +// nothing here can undo that, only report a downstream failure. The reviewer +// is resolved BEFORE committing to the review branch (crn-rott9.1): a +// resolution failure must leave nothing committed anywhere, not a durable +// review-branch commit nobody was ever told about. func requestReview(cmd *cobra.Command, e *cairn.Entry, scope []string) error { tier, value := cairn.ResolvedTier(scope) + reviewer, err := resolveReviewer(cmd, tier, value) + if err != nil { + return emitError(cmd, fmt.Errorf("resolve a reviewer to mail for entry %s: %w", e.ID, err)) + } + branch, err := e.CommitToReviewBranch(cmd.Context(), storePath()) if err != nil { return emitError(cmd, fmt.Errorf("commit shared-tier entry to review branch: %w", err)) @@ -30,11 +38,6 @@ func requestReview(cmd *cobra.Command, e *cairn.Entry, scope []string) error { fmt.Printf("review branch: %s\n", branch) } - reviewer, err := resolveReviewer(cmd, tier, value) - if err != nil { - return emitError(cmd, fmt.Errorf("entry %s committed to review branch %s, but resolving a reviewer to mail failed: %w", - e.ID, branch, err)) - } if err := sendReviewMail(cmd.Context(), reviewer, e, branch); err != nil { return emitError(cmd, fmt.Errorf("entry %s committed to review branch %s, but mail to reviewer %q failed: %w", e.ID, branch, reviewer, err)) @@ -71,15 +74,21 @@ func resolveReviewer(cmd *cobra.Command, tier, value string) (string, error) { // defaultReviewer computes the per-tier default reviewer: a distinct // recipient per tier, not one address shared across role/rig/global. // global's "mayor" is a permanent constant, not an interim placeholder -- -// the sole fleet-wide singleton reviewer. +// the sole fleet-wide singleton reviewer. rig resolves from the entry's own +// declared rig value (value), not $GC_RIG (crn-rott9.1): storage under +// rig: is unambiguous about which rig's reviewer should see it, +// regardless of which rig the writing agent happens to be running in. role +// is deliberately NOT changed the same way -- role-tier storage carries no +// rig at all, so which rig's role-holder should review is genuinely +// underspecified without $GC_RIG as a convenience default. func defaultReviewer(tier, value string) (string, error) { switch tier { case "global": return "mayor", nil case "rig": - rig := strings.TrimSpace(os.Getenv("GC_RIG")) + rig := strings.TrimSpace(value) if rig == "" { - return "", errors.New("cannot compute the default rig reviewer: $GC_RIG is not set; pass --reviewer or $CAIRN_REVIEWER") + return "", errors.New("cannot compute the default rig reviewer: entry has no rig value in its scope tag") } return rig + "/architect", nil case "role": @@ -156,23 +165,25 @@ type batchReviewCandidate struct { reviewer string } -// commitForBatchReview is requestReview's batch-mode half: commit e to its -// own review branch and resolve who should review it, but do not mail -- +// commitForBatchReview is requestReview's batch-mode half: resolve who +// should review e and commit it to its own review branch, but do not mail -- // batch mode groups many entries by resolved reviewer and sends one mail per // group afterward (requestBatchReview) instead of mailing per entry like -// requestReview does. +// requestReview does. The reviewer is resolved BEFORE committing +// (crn-rott9.1), matching requestReview: a resolution failure must leave +// this line's entry uncommitted to any branch, not a durable review-branch +// commit its own batch group never learns about. func commitForBatchReview(cmd *cobra.Command, e *cairn.Entry, scope []string) (branch, reviewer string, err error) { tier, value := cairn.ResolvedTier(scope) - branch, err = e.CommitToReviewBranch(cmd.Context(), storePath()) + reviewer, err = resolveReviewer(cmd, tier, value) if err != nil { - return "", "", fmt.Errorf("commit shared-tier entry to review branch: %w", err) + return "", "", fmt.Errorf("resolve a reviewer to mail for entry %s: %w", e.ID, err) } - reviewer, err = resolveReviewer(cmd, tier, value) + branch, err = e.CommitToReviewBranch(cmd.Context(), storePath()) if err != nil { - return branch, "", fmt.Errorf("entry %s committed to review branch %s, but resolving a reviewer to mail failed: %w", - e.ID, branch, err) + return "", "", fmt.Errorf("commit shared-tier entry to review branch: %w", err) } return branch, reviewer, nil } @@ -218,20 +229,24 @@ func sendBatchReviewMail(ctx context.Context, reviewer string, group []batchRevi // requestCullReview proposes e's eviction on a review branch and mails the // tier-appropriate reviewer -- mirrors requestReview, applied to a delete // instead of an add. Callers must only invoke this for a scope that has -// already resolved away from the private agent tier. +// already resolved away from the private agent tier. The reviewer is +// resolved BEFORE proposing the eviction branch (crn-rott9.1): a resolution +// failure must leave nothing committed anywhere, not a durable +// eviction-proposal commit nobody was ever told about. func requestCullReview(cmd *cobra.Command, e *cairn.Entry) error { tier, value := cairn.ResolvedTier(e.Scope) + reviewer, err := resolveReviewer(cmd, tier, value) + if err != nil { + return fmt.Errorf("resolve a reviewer to mail for entry %s: %w", e.ID, err) + } + branch, err := e.EvictToReviewBranch(cmd.Context(), storePath()) if err != nil { return fmt.Errorf("propose shared-tier eviction on a review branch: %w", err) } fmt.Printf("cull review branch: %s\n", branch) - reviewer, err := resolveReviewer(cmd, tier, value) - if err != nil { - return fmt.Errorf("entry %s proposed for eviction on branch %s, but resolving a reviewer to mail failed: %w", e.ID, branch, err) - } if err := sendCullReviewMail(cmd.Context(), reviewer, e, branch); err != nil { return fmt.Errorf("entry %s proposed for eviction on branch %s, but mail to reviewer %q failed: %w", e.ID, branch, reviewer, err) } @@ -257,22 +272,26 @@ func sendCullReviewMail(ctx context.Context, reviewer string, e *cairn.Entry, br // has already resolved away from the private agent tier, so DESIGN.md §7's // curation model applies to a promotion mark exactly as it does to any other // shared-tier mutation. Mirrors requestReview/requestCullReview's three-step -// shape (commit to review branch, resolve a reviewer, mail). Callers must +// shape (resolve a reviewer, commit to review branch, mail). Callers must // only invoke this for a scope that has already resolved away from the -// private agent tier. +// private agent tier. The reviewer is resolved BEFORE committing the +// promotion mark (crn-rott9.1): a resolution failure must leave nothing +// committed anywhere, not a durable review-branch commit nobody was ever +// told about. func requestPromotionReview(cmd *cobra.Command, e *cairn.Entry) error { tier, value := cairn.ResolvedTier(e.Scope) + reviewer, err := resolveReviewer(cmd, tier, value) + if err != nil { + return fmt.Errorf("resolve a reviewer to mail for entry %s: %w", e.ID, err) + } + branch, err := e.CommitPromotionToReviewBranch(cmd.Context(), storePath()) if err != nil { return fmt.Errorf("commit promotion mark to review branch: %w", err) } fmt.Printf("review branch: %s\n", branch) - reviewer, err := resolveReviewer(cmd, tier, value) - if err != nil { - return fmt.Errorf("entry %s committed to review branch %s, but resolving a reviewer to mail failed: %w", e.ID, branch, err) - } if err := sendPromotionReviewMail(cmd.Context(), reviewer, e, branch); err != nil { return fmt.Errorf("entry %s committed to review branch %s, but mail to reviewer %q failed: %w", e.ID, branch, reviewer, err) } From 68387ac85ebab46662d3fbc46363f115cdba37bc Mon Sep 17 00:00:00 2001 From: cairn-reviewer-scratch Date: Thu, 20 Aug 2026 01:11:10 -0700 Subject: [PATCH 3/3] Add release gate evidence: crn-9qlxu (7/7 PASS) Deploy bead crn-9qlxu at b1320d78, source review crn-rott9.1: reviewer resolves before commit at all 4 call sites; rig-tier default reviewer now uses the entry's own scope value instead of $GC_RIG. --- release-gates/crn-9qlxu-gate.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 release-gates/crn-9qlxu-gate.md diff --git a/release-gates/crn-9qlxu-gate.md b/release-gates/crn-9qlxu-gate.md new file mode 100644 index 00000000..4b8f84db --- /dev/null +++ b/release-gates/crn-9qlxu-gate.md @@ -0,0 +1,27 @@ +# Release Gate: crn-9qlxu + +**Bead:** crn-9qlxu (deploy) — source review crn-rott9.1 (epic: crn-rott9) +**Commit:** `b1320d785ae8b5d28527f6ffd2356f7f944291ce`, cut onto `deploy/crn-9qlxu-gate` off `origin/main` +**Date:** 2026-08-20 + +## Criteria + +| # | Criterion | Result | Evidence | +|---|-----------|--------|----------| +| 6 | Branch diverges cleanly from main | PASS | Merge-base with `origin/main` (tip `6b45121772bbd54215945aaadf948d9f72da48f3`) is `aa484f2bf631907b0112fa886c38ae6927526b9b`. File-level overlap found on `cmd/remember_test.go` between this branch's 7 changed files and main's intervening changes — escalated beyond a bare `comm` check: `git merge-tree --write-tree origin/main b1320d7` produced a clean tree (`69570e03417f757e839838d565b8c4a72d5528bf`, exit 0), and manual hunk-range inspection confirmed the overlapping edits sit in disjoint line ranges (this branch: ~234-269 and a new test inserted after line 1169; main: line 1256 onward) — no real conflict. `assert_deploy_ancestry_scope origin/main crn-9qlxu crn-rott9.1`: rc=0. | +| 1 | Review PASS present | PASS | crn-rott9.1 closed, REVIEW VERDICT: PASS from cairn/reviewer at this exact commit — build/vet clean, `go test ./...` all green (7 packages), `go test -race ./cmd/...` clean, `golangci-lint run ./...` 0 issues (isolated cache). | +| 2 | Acceptance criteria met | PASS | Bug required (a) `resolveReviewer` reordered to run BEFORE the review-branch commit/eviction/promotion-mark commit at all 4 call sites (`requestReview`, `commitForBatchReview`, `requestCullReview`, `requestPromotionReview`), so a resolution failure leaves nothing committed; (b) `defaultReviewer`'s rig-tier case switched from `$GC_RIG` to the entry's own declared rig value (`ResolvedTier`'s `value`). Diff confirms both, at all 4 sites, symmetrically. role tier deliberately left `$GC_RIG`-based per the bead's own text — diff confirms that switch case is untouched. Security claim in the bead ("rig value already trusted for `scopeDir`'s path join, so reusing it for a mail-recipient string is not a new/larger trust extension") independently verified: `scopeDir` (`internal/cairn/remember.go:222`) calls the same `ResolvedTier` and joins its `value` straight into a `filepath.Join`, pre-dating this change — claim holds. | +| 3 | Tests pass | PASS | Independently re-verified in a fresh isolated scratch worktree at `b1320d7` (not just trusting the reviewer's claim): `go build ./...`, `go vet ./...`, `gofmt -l .` all clean; `golangci-lint run ./...` (isolated `GOLANGCI_LINT_CACHE`) 0 issues; `go test ./... -race -count=1` — all 7 packages `ok`, 0 FAIL. All 5 named new/changed regression tests re-run directly with `-v`, individually PASS: `TestDefaultReviewerRigTierIgnoresGCRig`, `TestDefaultReviewerRigTierRequiresNonEmptyValue`, `TestRememberBatchReviewerResolutionFailureCommitsNothing`, `TestCullEvictReviewerResolutionFailureCommitsNothing`, `TestPromoteMarkReviewerResolutionFailureCommitsNothing`. | +| 4 | No high-severity review findings open | PASS | No `finding`-labeled beads reference crn-rott9.1 or crn-9qlxu. Related beads checked individually: crn-m98hp (molecule container, not a finding), crn-ry4zu (architect-level design-decision root bead for the broader "recall serves unreviewed entries" problem — crn-rott9, parent of crn-rott9.1, is itself the delegated implementation that discharges it; held open only pending sibling children and an unrelated `gc.work_outcome` guard defect `gm-84dngi`, not because of any defect in this fix), crn-ppw5w (empty fleet-routing "convoy" artifact, not a code finding), crn-27con.7 (unrelated prior-cycle follow-up; incidental text match, not topically connected). | +| 5 | Final branch clean | PASS | `git status --porcelain` empty on `deploy/crn-9qlxu-gate` immediately after cut. | +| 7 | Single feature theme | PASS | Diff vs. merge-base touches 7 files, all under `cmd/`: `reviewer.go` (the fix — 4 call-site reorders + rig-tier default fix), `reviewer_test.go`, `remember_batch_test.go`, `remember_test.go`, `cull_test.go`, `promote_test.go` (regression tests per call site), and `branches_test.go` (a necessary downstream fixture fix — an existing test that forced rig-tier resolution to fail via `stubGCWithRig("")` no longer can, since rig tier no longer reads `$GC_RIG`, so its fixture switched from `rig:web` to `role:reviewer` to keep testing the same failure path). One coherent theme, no unrelated changes. | + +## Verdict: PASS (7/7) — proceeding to PR. + +## Merge authority + +quad341/cairn — standing self-merge authorization applies (mayor ruling `gm-wisp-2yhv7u`, 2026-08-19), governed by memory `cairn-auto-merge-requires-explicit-strategy`. This bead's own description already states the 4 standing conditions explicitly and carries no stale "route to mayor/mpr, no self-merge" boilerplate. Deployer will merge directly (`gh pr merge --squash`, plain, once CI is green) under the ruling's 4 standing conditions. + +## Note + +Source branch `builder/crn-rott9.1` is provenance-only per the bead's own instructions — deploy branch cut directly from commit `b1320d7`, not pushed onto or opened from the builder branch.