From df90ec784c4892fa385bbbd1e928fe820da69f9b Mon Sep 17 00:00:00 2001 From: Athos Bernardes <79493098+athosmartins@users.noreply.github.com> Date: Sun, 9 Aug 2026 15:35:01 -0300 Subject: [PATCH] fix(bd): canonicalize actor==assignee comparisons in unclaim.go and AuthorizeAssigneeTransferWithPools (#5439) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix(bd): canonicalize actor==assignee comparisons in unclaim.go and AuthorizeAssigneeTransferWithPools Follow-up to ga-wzl83, which canonicalized the two pure-Go validators in internal/validation/issue.go but explicitly left out two higher-risk sites. UnclaimIssueInTx / UnclaimIssueIfAssigneeInTx compared actor/expectedAssignee to the stored assignee verbatim, both in a Go-side precheck AND in the SQL UPDATE's WHERE clause -- so canonicalizing only the Go side would not have fixed `bd unclaim` end-to-end. Replaced the `assignee = ?` SQL predicate with a `row_lock = ?` CAS against the RowVersion read moments earlier: every ownership/status/started_at mutation always rewrites row_lock (the documented freshRowLock invariant in lease.go), so this detects the exact same race the old predicate did -- and more (status/started_at races too) -- without embedding a spelling-sensitive string comparison in SQL. AuthorizeAssigneeTransferWithPools (the single fence both the DBTX and unit-of-work backends evaluate, per its own doc comment) compared before.Assignee to request.Actor and to request.Patch.Assignee.Value verbatim, so a caller naming the current holder under a different layer's identity spelling was wrongly fenced as a stranger. Both fixes reuse the canonicalActor/actorMatches shape from ga-wzl83, kept as a small package-local duplicate in issueops (internal/storage/issueops importing internal/validation would invert the layering). Verified: new cross-spelling cases in aggregate_authorize_transfer_test.go and new end-to-end cases in unclaim_embedded_test.go / unclaim_conditional_embedded_test.go (against a real embedded Dolt backend) all fail with the exact bug-report symptom against the pre-fix code and pass after the fix, with no regressions in the existing suites. ga-5ksp5 * fix(bd): close the sibling-CAS disagreement gate review flagged on #5439 Review verdict on #5439 was "MERGE AFTER ONE FIX": after this branch's unclaim.go/aggregate.go fix, bd unclaim --if-assignee succeeds under a respelled identity while bd update --expected-assignee on the same bead still fails ErrAssigneeMismatch — the same verbatim actor==assignee defect (ga-wzl83), left in two more places. - internal/storage/issueops/update_cas.go:46 (CheckExpectedFieldsInTx) now compares under actorMatches (package-local, unexported — same package as identity.go, no new import needed). - internal/storage/domain/issue.go:643 (ApplyUpdate, the unit-of-work twin) now compares under validation.ActorMatches. domain cannot import internal/storage/issueops (issueops already imports domain in several files — the reverse would cycle), but domain -> internal/validation is safe (validation depends only on internal/types), so this reuses the already-shipped validation copy instead of adding a third duplicate. Two non-blocking asks from the same review, addressed: - Exported internal/validation's canonicalActor/actorMatches to CanonicalActor/ActorMatches so domain/issue.go could reuse them (the reviewer's own point: "an issueops -> validation import creates no cycle... layering inversion is a style call, not a compile fact" applies equally to domain -> validation). Also fixed a garbled mid-sentence doc comment on ActorMatches while touching the file (separate nit from the same review, on #5438). - Added a cross-package parity test (internal/storage/issueops/identity_parity_test.go) that runs the existing CanonicalActor/ActorMatches case tables through both this package's local duplicate and validation's exported version, so the two copies can't silently drift. Mutation-tested: dropped the hyphen separator from issueops's copy, confirmed the two hyphen-related cases correctly fail, reverted. New conformance test (backend/conformance, wired into all three backend legs) proves the fix end-to-end: an ExpectedAssignee guard now accepts a different spelling of the current holder and still refuses a genuinely different identity. Added as a SEPARATE function rather than extending the existing RunIssueOperationsUpdateConditionalGuardsGateOrdinaryEdits — that test's later "order-dependent composition" arm depends on the row's assignee staying exactly "holder" through to the end, which a mid-test respelling would have broken. Verification: internal/validation, internal/storage/issueops, internal/storage/domain(+db,fs,git) all green. New conformance test passes on embeddeddolt and uow (dolt backend skips locally, no Docker — matches the existing documented limitation, CI covers it). Broader regression subset (Update/Claim/Unclaim, 28 embeddeddolt + 22 uow cases) green, no regressions. go build/vet/gofmt clean. Filed ga-4ymii for the reviewer's second (also non-blocking) ask: the remaining verbatim sites at issueops/claim.go (SQL CAS + idempotent re-claim), its domain/db and domain/issue.go uow twins, and issueops/lease.go's heartbeat holder check — out of scope for this PR per the reviewer's own framing ("please file the follow-up"). Co-Authored-By: Claude Sonnet 5 * fix(bd): dispatch the respelled-assignee contract case onto the role seam TestRoleContractCasesCoverEveryContractCase (main, post-dating this branch's fork point) caught a real gap: the ga-5ksp5 contract case added to this branch's earlier commit (RunIssueOperationsUpdateConditionalGuardAccepts- RespelledAssignee) had no roleContractCases dispatch row, so an external backend running RunRoleContracts would never see it. The reason isn't a missed row so much as the whole RunIssueOperationsUpdate* family this case was written beside having been renamed and moved to RunLifecycleUpdate* in backend/conformance/lifecycle_update_contract.go by main's "de-stage the hard Lifecycle contracts onto the role seam" refactor, which landed on main after this branch forked. Ported the case to match: same logic, adapted to the new fixture's idioms (fixture.Lifecycle.Update instead of fixture.Operations.Update, lifecycleUpdateRow(...).Priority instead of a raw SQL assertion, storage.ErrAssigneeMismatch instead of publicops.ErrAssigneeMismatch, seedLifecycleUpdateIssue instead of seedClosePolicyIssue) — not a mechanical copy. Also wired it into the three per-backend TestLifecycleUpdateContract dispatch lists (dolt, embeddeddolt, uow) beside its ConditionalGuardsGateOrdinaryEdits sibling, so it actually runs against real backends rather than only satisfying the completeness guard. Verified: TestRoleContractCasesCoverEveryContractCase passes; the ported case passes against embeddeddolt (0.35s) and uow (0.17s) for real, not just compiles (dolt backend test skips in this sandbox — no Docker); full backend/conformance suite and repo build clean. --------- Co-authored-by: Claude Sonnet 5 --- .../conformance/lifecycle_update_contract.go | 65 +++++++++++++ backend/conformance/role_bundle_cases.go | 1 + cmd/bd/unclaim_conditional_embedded_test.go | 30 ++++++ cmd/bd/unclaim_embedded_test.go | 21 +++++ .../dolt/lifecycle_update_contract_test.go | 3 + internal/storage/domain/issue.go | 11 ++- .../lifecycle_update_contract_test.go | 3 + internal/storage/issueops/aggregate.go | 11 ++- .../aggregate_authorize_transfer_test.go | 25 +++++ internal/storage/issueops/identity.go | 57 +++++++++++ .../storage/issueops/identity_parity_test.go | 71 ++++++++++++++ internal/storage/issueops/unclaim.go | 94 +++++++++++-------- internal/storage/issueops/update_cas.go | 8 +- .../uow/lifecycle_update_contract_test.go | 3 + internal/validation/issue.go | 26 ++--- internal/validation/issue_test.go | 10 +- 16 files changed, 380 insertions(+), 59 deletions(-) create mode 100644 internal/storage/issueops/identity.go create mode 100644 internal/storage/issueops/identity_parity_test.go diff --git a/backend/conformance/lifecycle_update_contract.go b/backend/conformance/lifecycle_update_contract.go index 3b22010ca..4448f7ff1 100644 --- a/backend/conformance/lifecycle_update_contract.go +++ b/backend/conformance/lifecycle_update_contract.go @@ -905,6 +905,71 @@ func RunLifecycleUpdateConditionalGuardsGateOrdinaryEdits(t *testing.T, ctx cont maskedEvents.assert(t, "guard masked by the one before it", 0) } +// RunLifecycleUpdateConditionalGuardAcceptsRespelledAssignee pins the +// ga-5ksp5 fix beside RunLifecycleUpdateConditionalGuardsGateOrdinaryEdits +// above rather than inside it: that test's later "order-dependent composition" +// arm depends on the row's assignee still being exactly "holder" all the way +// to the end, so reassigning it mid-test to exercise a second spelling would +// invalidate its own assumption. +// +// The two Gas Town identity spellings a caller can send for the same actor +// (dot vs underscore separator, ga-wzl83) must not desync from the row's +// stored spelling: an ExpectedAssignee guard is satisfied by either spelling +// of the CURRENT holder, and still refused by a spelling of a genuinely +// different identity. Separate from RunLifecycleUpdateAssigneeTransferFence +// in this file, which pins the same respelling rule for the CLAIM/TRANSFER +// fence (AuthorizeAssigneeTransferWithPools) — this pins it for the plain +// compare-and-set guard (CheckExpectedFieldsInTx / ApplyUpdate's own check), +// the third, previously-split verbatim-comparison surface the ga-3ipxu gate +// review on #5439 found. +func RunLifecycleUpdateConditionalGuardAcceptsRespelledAssignee(t *testing.T, ctx context.Context, fixture LifecycleUpdateFixture) { + t.Helper() + + id := fixture.IssuePrefix + "-lup-respelledguard" + seedLifecycleUpdateIssue(t, ctx, fixture, lifecycleUpdateIssue(id)) + + priorityEdit := func(priority int) publicops.UpdateRequest { + return publicops.UpdateRequest{Actor: "writer", IssueID: id, Patch: publicops.IssuePatch{ + Priority: publicops.Field[int]{Set: true, Value: priority}, + }} + } + assertPriority := func(label string, want int) { + t.Helper() + if got := lifecycleUpdateRow(t, ctx, fixture, id).Priority; got != want { + t.Errorf("%s = %d, want %d", label, got, want) + } + } + + assign := publicops.UpdateRequest{Actor: "writer", IssueID: id, Patch: publicops.IssuePatch{ + Assignee: publicops.Field[string]{Set: true, Value: "gastown.mayor"}, + }} + if _, err := fixture.Lifecycle.Update(ctx, assign); err != nil { + t.Fatalf("assign %s under a dotted identity: %v", id, err) + } + + // A guard naming the SAME identity under a different (and + // doubled-separator) spelling is satisfied, same as the row's own + // verbatim spelling would be. + respelled := "gastown__mayor" + respelledEdit := priorityEdit(1) + respelledEdit.ExpectedAssignee = &respelled + if result, err := fixture.Lifecycle.Update(ctx, respelledEdit); err != nil || !result.Changed { + t.Fatalf("edit guarded on a different spelling of the current holder = %#v, %v; want the edit applied", result, err) + } + assertPriority("priority after a guard naming the holder under a different spelling", 1) + + // Canonicalization must not over-match: a spelling of a genuinely + // different identity — not just a respelling of the holder — still + // refuses, and still writes nothing. + foreign := "gastown_dog-1" + foreignEdit := priorityEdit(3) + foreignEdit.ExpectedAssignee = &foreign + if _, err := fixture.Lifecycle.Update(ctx, foreignEdit); !errors.Is(err, storage.ErrAssigneeMismatch) { + t.Fatalf("edit guarded on an unrelated identity: err = %v, want ErrAssigneeMismatch", err) + } + assertPriority("priority after a guard naming an unrelated identity", 1) +} + // RunLifecycleUpdateMetadataPatchOrdersMergeSetUnset pins the sentence // MetadataPatch opens with: "Replace is mutually exclusive with Merge, Set, and // Unset. Without Replace, operations apply Merge, then Set keys in diff --git a/backend/conformance/role_bundle_cases.go b/backend/conformance/role_bundle_cases.go index 3b5f457af..68704f2cf 100644 --- a/backend/conformance/role_bundle_cases.go +++ b/backend/conformance/role_bundle_cases.go @@ -408,6 +408,7 @@ var roleContractCases = []roleContract{ RunLifecycleUpdateRefusesUnknownIDsAndActorlessRequests, RunLifecycleUpdateRefusalWritesNoMemberOfThePatch, RunLifecycleUpdateConditionalGuardsGateOrdinaryEdits, + RunLifecycleUpdateConditionalGuardAcceptsRespelledAssignee, RunLifecycleUpdateMetadataPatchOrdersMergeSetUnset, RunLifecycleUpdateClosePolicy, RunLifecycleUpdateAssigneeTransferFence, diff --git a/cmd/bd/unclaim_conditional_embedded_test.go b/cmd/bd/unclaim_conditional_embedded_test.go index 1c202be55..97ab1401b 100644 --- a/cmd/bd/unclaim_conditional_embedded_test.go +++ b/cmd/bd/unclaim_conditional_embedded_test.go @@ -57,6 +57,36 @@ func TestUnclaimIfAssigneeCLI(t *testing.T) { _ = bdUnclaimFail(t, bd, dir, issue.ID, "--if-assignee", "alice") } +// TestUnclaimIfAssigneeCLIDifferentSpelling drives `bd unclaim --if-assignee` +// with an expectation that names the current holder under a different Gas +// Town identity spelling than the stored assignee (dot vs underscore +// separator — ga-5ksp5). This must count as a match, not a stale-expectation +// refusal: both the Go-side actorMatches precheck and the row_lock CAS that +// replaced the old verbatim `assignee = ?` SQL predicate need to agree it is +// the same identity, or the release silently affects zero rows even though +// the precheck said the CAS should succeed. +func TestUnclaimIfAssigneeCLIDifferentSpelling(t *testing.T) { + if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" { + t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests") + } + t.Parallel() + + bd := buildEmbeddedBD(t) + dir, _, _ := bdInit(t, bd, "--prefix", "uw") + + issue := bdCreate(t, bd, dir, "Conditional release, spelling variant", "--type", "task") + bdUpdate(t, bd, dir, issue.ID, "--assignee", "gastown.mayor", "--status", "in_progress") + + bdUnclaim(t, bd, dir, issue.ID, "--if-assignee", "gastown_mayor") + got := bdShow(t, bd, dir, issue.ID) + if got.Assignee != "" { + t.Errorf("after same-identity --if-assignee: assignee = %q, want empty", got.Assignee) + } + if got.Status != types.StatusOpen { + t.Errorf("after same-identity --if-assignee: status = %q, want open", got.Status) + } +} + // TestUnclaimIfAssigneeFlagValidation drives the CLI guards that keep the // conditional-release contract unambiguous. A conditional unclaim is selected by // the *presence* of --if-assignee, so an explicitly empty --if-assignee "" (an diff --git a/cmd/bd/unclaim_embedded_test.go b/cmd/bd/unclaim_embedded_test.go index 731c35bdd..b5535fcd2 100644 --- a/cmd/bd/unclaim_embedded_test.go +++ b/cmd/bd/unclaim_embedded_test.go @@ -219,4 +219,25 @@ func TestEmbeddedUnclaim(t *testing.T) { t.Errorf("expected status open after --force unclaim, got %s", got.Status) } }) + + // The owner may release its own claim under a different spelling of its own + // identity (ga-5ksp5): dot vs underscore separator is the same Gas Town + // identity at two different layers, and both the Go-side ownership + // precheck and the SQL CAS predicate must recognize that — not just the + // former, or the UPDATE would silently affect zero rows and the release + // would fail even though the Go precheck said it should succeed. + t.Run("unclaim_owner_different_spelling_succeeds", func(t *testing.T) { + issue := bdCreate(t, bd, dir, "Owner spelling variant", "--type", "task") + bdUpdate(t, bd, dir, issue.ID, "--claim", "--actor", "gastown.mayor") + + bdUnclaim(t, bd, dir, issue.ID, "--actor", "gastown_mayor") + + got := bdShow(t, bd, dir, issue.ID) + if got.Assignee != "" { + t.Errorf("expected assignee to be cleared after same-identity unclaim, got %q", got.Assignee) + } + if got.Status != types.StatusOpen { + t.Errorf("expected status open after same-identity unclaim, got %s", got.Status) + } + }) } diff --git a/internal/storage/dolt/lifecycle_update_contract_test.go b/internal/storage/dolt/lifecycle_update_contract_test.go index 70f98ace9..f8a4f8511 100644 --- a/internal/storage/dolt/lifecycle_update_contract_test.go +++ b/internal/storage/dolt/lifecycle_update_contract_test.go @@ -51,6 +51,9 @@ func TestLifecycleUpdateContract(t *testing.T) { t.Run("ConditionalGuardsGateOrdinaryEdits", func(t *testing.T) { conformance.RunLifecycleUpdateConditionalGuardsGateOrdinaryEdits(t, ctx, fixture) }) + t.Run("ConditionalGuardAcceptsRespelledAssignee", func(t *testing.T) { + conformance.RunLifecycleUpdateConditionalGuardAcceptsRespelledAssignee(t, ctx, fixture) + }) t.Run("MetadataPatchOrdersMergeSetUnset", func(t *testing.T) { conformance.RunLifecycleUpdateMetadataPatchOrdersMergeSetUnset(t, ctx, fixture) }) diff --git a/internal/storage/domain/issue.go b/internal/storage/domain/issue.go index 9aba5a439..1df32e0cb 100644 --- a/internal/storage/domain/issue.go +++ b/internal/storage/domain/issue.go @@ -10,6 +10,7 @@ import ( "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/storage/dberrors" "github.com/steveyegge/beads/internal/types" + "github.com/steveyegge/beads/internal/validation" publicops "github.com/steveyegge/beads/issueops" ) @@ -660,6 +661,14 @@ func (u *issueUseCaseImpl) claim(ctx context.Context, id, actor string, useWisp } } +// ApplyUpdate applies spec's guarded field updates and returns the resulting +// issue. When ExpectedAssignee is set, the guard compares under +// validation.ActorMatches, not verbatim ==, so two spellings of the same +// identity (ga-wzl83) don't false-mismatch — the unit-of-work twin of +// issueops.CheckExpectedFieldsInTx's SQL-CAS guard; both paths of +// AuthorizeAssigneeTransferWithPools already made this fix, this was the +// third, previously-split verbatim-comparison surface (ga-5ksp5, gate review +// on #5439). func (u *issueUseCaseImpl) ApplyUpdate(ctx context.Context, id string, spec UpdateSpec, actor string) (*types.Issue, error) { if id == "" { return nil, fmt.Errorf("ApplyUpdate: id must not be empty") @@ -686,7 +695,7 @@ func (u *issueUseCaseImpl) ApplyUpdate(ctx context.Context, id string, spec Upda if spec.ExpectedVersion != nil && current.RowVersion != *spec.ExpectedVersion { return nil, fmt.Errorf("%w: expected %d, got %d", storage.ErrVersionMismatch, *spec.ExpectedVersion, current.RowVersion) } - if spec.ExpectedAssignee != nil && current.Assignee != *spec.ExpectedAssignee { + if spec.ExpectedAssignee != nil && !validation.ActorMatches(current.Assignee, *spec.ExpectedAssignee) { return nil, fmt.Errorf("%w: %s is held by %q, expected %q", storage.ErrAssigneeMismatch, id, current.Assignee, *spec.ExpectedAssignee) } diff --git a/internal/storage/embeddeddolt/lifecycle_update_contract_test.go b/internal/storage/embeddeddolt/lifecycle_update_contract_test.go index 35e04971b..b175301f4 100644 --- a/internal/storage/embeddeddolt/lifecycle_update_contract_test.go +++ b/internal/storage/embeddeddolt/lifecycle_update_contract_test.go @@ -52,6 +52,9 @@ func TestLifecycleUpdateContract(t *testing.T) { t.Run("ConditionalGuardsGateOrdinaryEdits", func(t *testing.T) { conformance.RunLifecycleUpdateConditionalGuardsGateOrdinaryEdits(t, ctx, fixture) }) + t.Run("ConditionalGuardAcceptsRespelledAssignee", func(t *testing.T) { + conformance.RunLifecycleUpdateConditionalGuardAcceptsRespelledAssignee(t, ctx, fixture) + }) t.Run("MetadataPatchOrdersMergeSetUnset", func(t *testing.T) { conformance.RunLifecycleUpdateMetadataPatchOrdersMergeSetUnset(t, ctx, fixture) }) diff --git a/internal/storage/issueops/aggregate.go b/internal/storage/issueops/aggregate.go index 12ea0616d..f56f91c4a 100644 --- a/internal/storage/issueops/aggregate.go +++ b/internal/storage/issueops/aggregate.go @@ -145,11 +145,20 @@ func ValidateScalarUpdates(ctx context.Context, tx DBTX, updates map[string]inte // it, so the two cannot drift into disagreeing about which transfers are // fenced. // +// The no-op and self-transfer exits (request.Patch.Assignee.Value against +// before.Assignee, and before.Assignee against request.Actor) are judged +// under actorMatches, not verbatim equality (ga-5ksp5): the same Gas Town +// identity arrives here spelled differently depending on which layer +// produced the string (a dotted alias vs its session-name form — see +// canonicalActor), and a byte-for-byte comparison would wrongly fence a +// holder editing its own claim, or reject an idempotent re-assert, just +// because the caller named the holder under a different layer's spelling. +// // Passing nil pools answers every question except pool membership, so a caller // that wants the config read only when it matters calls with nil first and // re-evaluates with the loaded aliases on refusal. func AuthorizeAssigneeTransferWithPools(before *types.Issue, request publicops.UpdateRequest, pools []string) error { - if !request.Patch.Assignee.Set || request.Patch.Assignee.Value == before.Assignee || request.ExpectedAssignee != nil || request.ForceAssigneeTransfer || before.Status != types.StatusInProgress || before.Assignee == "" || before.Assignee == request.Actor { + if !request.Patch.Assignee.Set || actorMatches(request.Patch.Assignee.Value, before.Assignee) || request.ExpectedAssignee != nil || request.ForceAssigneeTransfer || before.Status != types.StatusInProgress || before.Assignee == "" || actorMatches(before.Assignee, request.Actor) { return nil } for _, pool := range pools { diff --git a/internal/storage/issueops/aggregate_authorize_transfer_test.go b/internal/storage/issueops/aggregate_authorize_transfer_test.go index f9950f682..615e130c2 100644 --- a/internal/storage/issueops/aggregate_authorize_transfer_test.go +++ b/internal/storage/issueops/aggregate_authorize_transfer_test.go @@ -73,6 +73,31 @@ func TestAuthorizeAssigneeTransferWithPools(t *testing.T) { before: held(), request: transfer(func(r *publicops.UpdateRequest) { r.Actor = "holder" }), }, + { + // ga-5ksp5: the same Gas Town identity spelled two different + // ways (dot vs underscore separator) must still count as + // "actor already holds it", not a foreign transfer. + name: "actor already holds it under a different spelling", + before: &types.Issue{ID: "bd-1", Status: types.StatusInProgress, Assignee: "gastown.mayor"}, + request: transfer(func(r *publicops.UpdateRequest) { r.Actor = "gastown_mayor" }), + }, + { + // ga-5ksp5: reasserting the current holder under a different + // (and doubled-separator) spelling is still the same + // idempotent no-op as reasserting it verbatim. + name: "reasserts the current assignee under a different spelling", + before: &types.Issue{ID: "bd-1", Status: types.StatusInProgress, Assignee: "gastown.mayor"}, + request: transfer(func(r *publicops.UpdateRequest) { r.Patch.Assignee.Value = "gastown__mayor" }), + }, + { + // ga-5ksp5: canonicalization must not over-match — an actor + // whose identity genuinely differs from the holder (not just + // a respelling of it) stays refused. + name: "foreign actor with an unrelated identity is still refused", + before: &types.Issue{ID: "bd-1", Status: types.StatusInProgress, Assignee: "gastown.mayor"}, + request: transfer(func(r *publicops.UpdateRequest) { r.Actor = "gastown_dog-1" }), + refuse: true, + }, { name: "holder is a configured pool alias", before: &types.Issue{ID: "bd-1", Status: types.StatusInProgress, Assignee: "crew"}, diff --git a/internal/storage/issueops/identity.go b/internal/storage/issueops/identity.go new file mode 100644 index 000000000..b4ad6d56d --- /dev/null +++ b/internal/storage/issueops/identity.go @@ -0,0 +1,57 @@ +package issueops + +import "strings" + +// canonicalActor normalizes an identity string so two spellings of the same +// Gas Town identity compare equal. The same identity arrives at bd in more +// than one spelling depending on which layer produced the string it was +// handed: a dotted alias like "gastown.mayor" gets its dot replaced wherever +// a dot is unsafe for that context — "__" in a session name, "_" in a Dolt +// table/database name, "-" elsewhere — and bd only ever sees the resulting +// string, never the substitution itself (ga-wzl83). None of ".", "_", "-" +// carries meaning in an identity string: each is always a positional +// separator between a rig and a role/agent name, never part of either name. +// Collapsing any run of them to one canonical separator lets two spellings +// of the same identity compare equal without weakening comparisons between +// genuinely different identities, whose non-separator characters still +// differ (e.g. "gastown.mayor" vs "gastown.dog-3" stay distinct). +// +// Empty stays empty: an actual absence of an actor must never canonicalize +// to the same value as a non-empty one, or a caller comparing against an +// unassigned issue would start matching everyone. +// +// This is a package-local duplicate of internal/validation/issue.go's +// canonicalActor (ga-wzl83): issueops sits below validation in the layering +// (storage depending on a higher-level validation package would invert it), +// so the two copies stay independent rather than sharing an import. Keep +// them in sync if the separator set or normalization rule ever changes +// (ga-5ksp5). +func canonicalActor(s string) string { + if s == "" { + return "" + } + var b strings.Builder + b.Grow(len(s)) + inSeparator := false + for _, r := range s { + switch r { + case '.', '_', '-': + if !inSeparator { + b.WriteByte('_') + inSeparator = true + } + default: + b.WriteRune(r) + inSeparator = false + } + } + return b.String() +} + +// actorMatches reports whether a and b denote the same identity: either +// they're byte-identical, or they canonicalize to the same string (see +// canonicalActor). The byte-identical check is not redundant — it avoids +// paying canonicalization on the overwhelmingly common exact-match path. +func actorMatches(a, b string) bool { + return a == b || canonicalActor(a) == canonicalActor(b) +} diff --git a/internal/storage/issueops/identity_parity_test.go b/internal/storage/issueops/identity_parity_test.go new file mode 100644 index 000000000..189272ebf --- /dev/null +++ b/internal/storage/issueops/identity_parity_test.go @@ -0,0 +1,71 @@ +package issueops + +import ( + "testing" + + "github.com/steveyegge/beads/internal/validation" +) + +// TestIdentityCanonicalizationParityWithValidation guards the two +// intentionally-duplicated copies of the identity-canonicalization rule +// (this package's canonicalActor/actorMatches, internal/validation's +// exported CanonicalActor/ActorMatches) against silent drift. issueops +// cannot import internal/storage/domain — internal/storage/issueops already +// imports internal/storage/domain in several files (config_helpers.go, +// dependencies.go, etc.), so the reverse import would cycle — but it CAN +// safely import internal/validation (validation depends only on +// internal/types), and does so here for test purposes only. Per the ga-3ipxu +// gate review on #5439: "I won't hold the PR for extraction to a shared leaf +// package, but two keep-in-sync copies need at least a cross-package parity +// test so the tables can't drift silently." Run the identical case tables +// TestCanonicalActor/TestActorMatches already pin in +// internal/validation/issue_test.go through BOTH implementations; a future +// edit to either separator set or matching rule that isn't mirrored in the +// other fails here, not in production. +func TestIdentityCanonicalizationParityWithValidation(t *testing.T) { + canonicalCases := []struct { + name string + in string + }{ + {name: "empty stays empty", in: ""}, + {name: "no separators is unchanged", in: "alice"}, + {name: "dot separator canonicalizes", in: "gastown.mayor"}, + {name: "double-underscore separator canonicalizes to the same form", in: "gastown__mayor"}, + {name: "hyphen separator canonicalizes to the same form", in: "gastown-mayor"}, + {name: "single underscore is already canonical", in: "gastown_mayor"}, + {name: "mixed separators each collapse to one canonical separator", in: "gastown.dog-3"}, + {name: "leading separator is preserved as a separator, not dropped", in: ".mayor"}, + {name: "trailing separator is preserved as a separator, not dropped", in: "mayor."}, + } + for _, tc := range canonicalCases { + t.Run("CanonicalActor/"+tc.name, func(t *testing.T) { + local := canonicalActor(tc.in) + shared := validation.CanonicalActor(tc.in) + if local != shared { + t.Errorf("issueops.canonicalActor(%q) = %q, internal/validation.CanonicalActor(%q) = %q — the two copies have drifted apart", + tc.in, local, tc.in, shared) + } + }) + } + + matchCases := []struct { + name string + assignee, actor string + }{ + {name: "byte-identical matches", assignee: "alice", actor: "alice"}, + {name: "different spellings of the same identity match (ga-wzl83)", assignee: "gastown.mayor", actor: "gastown__mayor"}, + {name: "genuinely different identities do not match", assignee: "gastown.mayor", actor: "gastown.dog-3"}, + {name: "both empty match", assignee: "", actor: ""}, + {name: "empty assignee never matches a non-empty actor", assignee: "", actor: "mayor"}, + } + for _, tc := range matchCases { + t.Run("ActorMatches/"+tc.name, func(t *testing.T) { + local := actorMatches(tc.assignee, tc.actor) + shared := validation.ActorMatches(tc.assignee, tc.actor) + if local != shared { + t.Errorf("issueops.actorMatches(%q, %q) = %v, internal/validation.ActorMatches(%q, %q) = %v — the two copies have drifted apart", + tc.assignee, tc.actor, local, tc.assignee, tc.actor, shared) + } + }) + } +} diff --git a/internal/storage/issueops/unclaim.go b/internal/storage/issueops/unclaim.go index 1482dbe29..80013105e 100644 --- a/internal/storage/issueops/unclaim.go +++ b/internal/storage/issueops/unclaim.go @@ -18,8 +18,11 @@ import ( // // Ownership: only the current assignee may release its own claim. A mismatched // actor is rejected with storage.ErrNotOwner rather than a silent no-op, so a -// second agent cannot yank a claim it does not hold. Pass force=true to bypass -// the ownership check (admin/reaper use, threaded from `bd unclaim --force`). +// second agent cannot yank a claim it does not hold. Ownership is compared +// under actorMatches (ga-5ksp5), so two spellings of the same Gas Town +// identity (e.g. a dotted alias vs its session-name form) both count as the +// owner — see canonicalActor. Pass force=true to bypass the ownership check +// (admin/reaper use, threaded from `bd unclaim --force`). // // Only works on issues that have an assignee and status is "open" or // "in_progress". Returns error if: @@ -51,8 +54,10 @@ func UnclaimIssueInTx(ctx context.Context, tx DBTX, id string, actor string, for } // Validate ownership unless the caller forced the release. Without force, a - // process may only release its own claim. - if !force && oldIssue.Assignee != actor { + // process may only release its own claim. Compared under actorMatches, not + // verbatim, so a caller naming its own identity under a different layer's + // spelling (ga-5ksp5) is not refused as a stranger. + if !force && !actorMatches(oldIssue.Assignee, actor) { return fmt.Errorf("%w: %s is held by %s; coordinate with the holder — pass --force only if their claim is abandoned (crashed agent, expired lease)", storage.ErrNotOwner, id, oldIssue.Assignee) } @@ -60,23 +65,23 @@ func UnclaimIssueInTx(ctx context.Context, tx DBTX, id string, actor string, for now := time.Now().UTC() // Atomic UPDATE: clear assignee, reset status to open, clear started_at, - // and rewrite row_lock. The predicate re-checks ownership (unless forced) - // so a claim that changed hands between the read above and this write is - // not clobbered. row_lock forces a racing reclaim/close on the same row to - // conflict rather than silently merge (see lease.go invariant). - ownerPredicate := "AND assignee = ?" - args := []interface{}{now, freshRowLock(), id, actor} - if force { - // Force still requires a current assignee, but from anyone. - ownerPredicate = "AND assignee != ''" - args = []interface{}{now, freshRowLock(), id} - } + // and rewrite row_lock. The predicate CASes on row_lock rather than + // assignee (ga-5ksp5): ownership was already authorized above (or bypassed + // by force) against the row read into oldIssue, and row_lock is rewritten + // by every path that mutates status/assignee/started_at (see the + // freshRowLock invariant in lease.go) — so requiring it to still equal + // oldIssue.RowVersion detects a claim that changed hands (or was released, + // or closed) between that read and this write exactly as precisely as the + // old `assignee = ` predicate did, without embedding a + // spelling-sensitive string comparison in SQL. force does not exempt this + // check: force only widens WHO may unclaim, not whether the row is still + // the one we read. result, err := tx.ExecContext(ctx, fmt.Sprintf(` UPDATE %s SET assignee = '', status = 'open', updated_at = ?, started_at = NULL, row_lock = ? - WHERE id = ? AND status IN ('open', 'in_progress') %s - `, issueTable, ownerPredicate), args...) + WHERE id = ? AND status IN ('open', 'in_progress') AND row_lock = ? + `, issueTable), now, freshRowLock(), id, oldIssue.RowVersion) if err != nil { return fmt.Errorf("failed to unclaim issue: %w", err) } @@ -89,12 +94,12 @@ func UnclaimIssueInTx(ctx context.Context, tx DBTX, id string, actor string, for if rowsAffected == 0 { // The pre-checks passed, so a 0-row result means the row changed // underneath us: re-read to disambiguate an ownership change from a - // status change. + // status change. actorMatches, not verbatim, mirrors the precheck above. current, gerr := GetIssueInTx(ctx, tx, id) if gerr != nil { return fmt.Errorf("failed to unclaim issue %s: no matching row", id) } - if !force && current.Assignee != actor { + if !force && !actorMatches(current.Assignee, actor) { return fmt.Errorf("%w: %s is held by %s; coordinate with the holder — pass --force only if their claim is abandoned (crashed agent, expired lease)", storage.ErrNotOwner, id, current.Assignee) } @@ -130,12 +135,16 @@ func finishUnclaimInTx(ctx context.Context, tx DBTX, eventTable string, id strin // UnclaimIssueIfAssigneeInTx atomically releases a claim only while the issue is // still assigned to expectedAssignee — the compare-and-swap inverse of -// ClaimIssueInTx: a conditional UPDATE ... WHERE id = ? AND assignee = ? with -// RowsAffected as the verdict, so a stale releaser can never clobber a claim -// that has since moved to (or been re-taken by) someone else. On success it -// applies the same transition as UnclaimIssueInTx (assignee cleared, status -// reopened, started_at cleared, lease dropped, row_lock rewritten, "unclaimed" -// event recorded). When the current assignee differs from expectedAssignee — +// ClaimIssueInTx: a Go-side actorMatches precheck (ga-5ksp5) plus a conditional +// UPDATE CASed on row_lock, with RowsAffected as the verdict, so a stale +// releaser can never clobber a claim that has since moved to (or been +// re-taken by) someone else. "Still assigned to expectedAssignee" is judged +// under actorMatches, not verbatim equality, so a caller naming the current +// holder under a different layer's spelling of the same identity is a match, +// not a mismatch — see canonicalActor. On success it applies the same +// transition as UnclaimIssueInTx (assignee cleared, status reopened, +// started_at cleared, lease dropped, row_lock rewritten, "unclaimed" event +// recorded). When the current assignee does not match expectedAssignee — // including when the issue is no longer assigned at all — it returns // storage.ErrAssigneeMismatch naming the current holder and leaves the row // untouched. actor is recorded as the event author. @@ -162,25 +171,34 @@ func UnclaimIssueIfAssigneeInTx(ctx context.Context, tx DBTX, id string, actor s } // Compare-and-swap precheck: a mismatched holder — including an - // already-released issue (empty assignee) — is a loud, typed no-op. The read - // and the UPDATE below run in the same transaction, so this check and the - // CAS WHERE clause see the same row state. - if oldIssue.Assignee != expectedAssignee { + // already-released issue (empty assignee) — is a loud, typed no-op. Judged + // under actorMatches (ga-5ksp5), not verbatim equality, so expectedAssignee + // spelled under a different layer's separator convention than the stored + // assignee still counts as a match. The read and the UPDATE below run in + // the same transaction, so this check and the CAS WHERE clause see the + // same row state. + if !actorMatches(oldIssue.Assignee, expectedAssignee) { return fmt.Errorf("%w: %s is held by %q, expected %q", storage.ErrAssigneeMismatch, id, oldIssue.Assignee, expectedAssignee) } now := time.Now().UTC() - // Atomic UPDATE pinned to the expected assignee (CAS), applying the same - // transition as UnclaimIssueInTx: clear assignee, reset status to open, - // clear started_at, and rewrite row_lock so a racing reclaim/close on the - // same row conflicts rather than silently merging (see lease.go invariant). + // Atomic UPDATE CASed on row_lock rather than assignee (ga-5ksp5): the + // Go-side check above already authorized the swap under actorMatches + // against the row read into oldIssue, and row_lock is rewritten by every + // path that mutates status/assignee/started_at (see the freshRowLock + // invariant in lease.go) — so requiring it to still equal + // oldIssue.RowVersion applies the same transition as UnclaimIssueInTx + // (assignee cleared, status reopened, started_at cleared, row_lock + // rewritten) while detecting a racing reclaim/close on the same row exactly + // as precisely as the old `assignee = ` predicate did, + // without embedding a spelling-sensitive string comparison in SQL. result, err := tx.ExecContext(ctx, fmt.Sprintf(` UPDATE %s SET assignee = '', status = 'open', updated_at = ?, started_at = NULL, row_lock = ? - WHERE id = ? AND status IN ('open', 'in_progress') AND assignee = ? - `, issueTable), now, freshRowLock(), id, expectedAssignee) + WHERE id = ? AND status IN ('open', 'in_progress') AND row_lock = ? + `, issueTable), now, freshRowLock(), id, oldIssue.RowVersion) if err != nil { return fmt.Errorf("failed to unclaim issue: %w", err) } @@ -194,13 +212,13 @@ func UnclaimIssueIfAssigneeInTx(ctx context.Context, tx DBTX, id string, actor s // The precheck passed and the read + UPDATE share this transaction, so a // 0-row result is not an assignee race (the row cannot change under us // mid-tx). Re-read and disambiguate, mirroring UnclaimIssueInTx: a - // mismatched holder is the CAS verdict (ErrAssigneeMismatch), otherwise - // the status is no longer releasable. + // mismatched holder (under actorMatches) is the CAS verdict + // (ErrAssigneeMismatch), otherwise the status is no longer releasable. current, gerr := GetIssueInTx(ctx, tx, id) if gerr != nil { return fmt.Errorf("failed to unclaim issue %s: no matching row", id) } - if current.Assignee != expectedAssignee { + if !actorMatches(current.Assignee, expectedAssignee) { return fmt.Errorf("%w: %s is held by %q, expected %q", storage.ErrAssigneeMismatch, id, current.Assignee, expectedAssignee) } return fmt.Errorf("failed to unclaim issue %s: no matching row", id) diff --git a/internal/storage/issueops/update_cas.go b/internal/storage/issueops/update_cas.go index 101dc5515..4d389a5bd 100644 --- a/internal/storage/issueops/update_cas.go +++ b/internal/storage/issueops/update_cas.go @@ -24,6 +24,12 @@ import ( // retry loop replays — the replayed attempt re-reads here and refuses. // Together they close the read-then-write window. // +// The assignee guard compares under actorMatches, not verbatim ==, so two +// spellings of the same identity (ga-wzl83) don't false-mismatch — the same +// fix already shipped for UnclaimIssueInTx's SQL-CAS predicate and +// AuthorizeAssigneeTransferWithPools; this was the third, previously-split +// verbatim-comparison surface (ga-5ksp5, gate review on #5439). +// //nolint:gosec // G201: table name comes from WispTableRouting (hardcoded constants) func CheckExpectedFieldsInTx(ctx context.Context, tx DBTX, id string, expectedAssignee, expectedStatus *string) error { if expectedAssignee == nil && expectedStatus == nil { @@ -43,7 +49,7 @@ func CheckExpectedFieldsInTx(ctx context.Context, tx DBTX, id string, expectedAs if err != nil { return fmt.Errorf("failed to read assignee/status for %s: %w", id, err) } - if expectedAssignee != nil && assignee.String != *expectedAssignee { + if expectedAssignee != nil && !actorMatches(assignee.String, *expectedAssignee) { return fmt.Errorf("%w: %s is held by %q, expected %q", storage.ErrAssigneeMismatch, id, assignee.String, *expectedAssignee) } if expectedStatus != nil && status != *expectedStatus { diff --git a/internal/storage/uow/lifecycle_update_contract_test.go b/internal/storage/uow/lifecycle_update_contract_test.go index f3613df6e..e635e5fbd 100644 --- a/internal/storage/uow/lifecycle_update_contract_test.go +++ b/internal/storage/uow/lifecycle_update_contract_test.go @@ -53,6 +53,9 @@ func TestLifecycleUpdateContract(t *testing.T) { t.Run("ConditionalGuardsGateOrdinaryEdits", func(t *testing.T) { conformance.RunLifecycleUpdateConditionalGuardsGateOrdinaryEdits(t, ctx, fixture) }) + t.Run("ConditionalGuardAcceptsRespelledAssignee", func(t *testing.T) { + conformance.RunLifecycleUpdateConditionalGuardAcceptsRespelledAssignee(t, ctx, fixture) + }) t.Run("MetadataPatchOrdersMergeSetUnset", func(t *testing.T) { conformance.RunLifecycleUpdateMetadataPatchOrdersMergeSetUnset(t, ctx, fixture) }) diff --git a/internal/validation/issue.go b/internal/validation/issue.go index 262cf3b32..e445cceb5 100644 --- a/internal/validation/issue.go +++ b/internal/validation/issue.go @@ -71,7 +71,7 @@ func NotPinned(force bool) IssueValidator { } } -// canonicalActor normalizes an identity string so two spellings of the same +// CanonicalActor normalizes an identity string so two spellings of the same // Gas Town identity compare equal. The same identity arrives at bd in more // than one spelling depending on which layer produced the string it was // handed: a dotted alias like "gastown.mayor" gets its dot replaced wherever @@ -88,7 +88,7 @@ func NotPinned(force bool) IssueValidator { // Empty stays empty: an actual absence of an actor must never canonicalize // to the same value as a non-empty one, or AssigneeMatches would start // accepting an empty actor against an assigned issue. -func canonicalActor(s string) string { +func CanonicalActor(s string) string { if s == "" { return "" } @@ -110,14 +110,14 @@ func canonicalActor(s string) string { return b.String() } -// actorMatches reports whether actor has the same authority as assignee: +// ActorMatches reports whether actor has the same authority as assignee: // either they're byte-identical, or they canonicalize to the same identity -// (see canonicalActor). The byte-identical check is not redundant — it is -// what keeps two DIFFERENT identities that happen to canonicalize the same -// way from ever being needed for this to matter in practice, and it avoids -// paying canonicalization on the overwhelmingly common exact-match path. -func actorMatches(assignee, actor string) bool { - return assignee == actor || canonicalActor(assignee) == canonicalActor(actor) +// (see CanonicalActor). The byte-identical check is not redundant — it +// avoids paying canonicalization on the overwhelmingly common exact-match +// path (ga-5ksp5 gate review, #5438: fixes a garbled doc comment, no +// behavior change). +func ActorMatches(assignee, actor string) bool { + return assignee == actor || CanonicalActor(assignee) == CanonicalActor(actor) } // AssigneeMatches validates that the actor has authority to close the issue. @@ -125,7 +125,7 @@ func actorMatches(assignee, actor string) bool { // assignee. Returns an error on mismatch unless force is true. // // Authority is identity-by-string: actor is compared to assignee under -// canonicalActor, so two principals sharing one canonical actor name both +// CanonicalActor, so two principals sharing one canonical actor name both // pass — including the same principal spelled two different ways by two // different layers of Gas Town (ga-wzl83). bd has no identity layer, so this // matches the existing semantics of the actor field — the guard removes @@ -140,7 +140,7 @@ func AssigneeMatches(actor string, force bool) IssueValidator { if issue == nil || force { return nil } - if issue.Assignee == "" || actorMatches(issue.Assignee, actor) { + if issue.Assignee == "" || ActorMatches(issue.Assignee, actor) { return nil } return fmt.Errorf("cannot close %s: assignee is %q, actor is %q; reclaim or use --force to override", id, issue.Assignee, actor) @@ -171,7 +171,7 @@ func AssigneeMatches(actor string, force bool) IssueValidator { // the overwhelmingly common non-conflicting paths. // // Like AssigneeMatches, authority is identity-by-string — compared under -// canonicalActor rather than verbatim (ga-wzl83), so this removes silent +// CanonicalActor rather than verbatim (ga-wzl83), so this removes silent // cross-actor takeovers without adding new identity guarantees, and without // falsely treating the current holder as a stranger when actor or // newAssignee names it under a different layer's spelling of the same @@ -181,7 +181,7 @@ func AssigneeNotStolen(actor, newAssignee string, poolAliases func() []string, f if issue == nil || force { return nil } - if issue.Assignee == "" || actorMatches(issue.Assignee, actor) || actorMatches(issue.Assignee, newAssignee) { + if issue.Assignee == "" || ActorMatches(issue.Assignee, actor) || ActorMatches(issue.Assignee, newAssignee) { return nil } if issue.Status != types.StatusInProgress { diff --git a/internal/validation/issue_test.go b/internal/validation/issue_test.go index 309eb0180..d75f5d04b 100644 --- a/internal/validation/issue_test.go +++ b/internal/validation/issue_test.go @@ -163,8 +163,8 @@ func TestCanonicalActor(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := canonicalActor(tt.in); got != tt.want { - t.Errorf("canonicalActor(%q) = %q, want %q", tt.in, got, tt.want) + if got := CanonicalActor(tt.in); got != tt.want { + t.Errorf("CanonicalActor(%q) = %q, want %q", tt.in, got, tt.want) } }) } @@ -186,8 +186,8 @@ func TestActorMatches(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := actorMatches(tt.assignee, tt.actor); got != tt.want { - t.Errorf("actorMatches(%q, %q) = %v, want %v", tt.assignee, tt.actor, got, tt.want) + if got := ActorMatches(tt.assignee, tt.actor); got != tt.want { + t.Errorf("ActorMatches(%q, %q) = %v, want %v", tt.assignee, tt.actor, got, tt.want) } }) } @@ -386,7 +386,7 @@ func TestAssigneeNotStolen(t *testing.T) { wantErr: true, }, // ga-wzl83: same class as AssigneeMatches — actor and newAssignee are - // compared against the stored assignee under canonicalActor, so a + // compared against the stored assignee under CanonicalActor, so a // different layer's spelling of the current holder's own identity is // not mistaken for a stranger. {