`54bdb31`

S23: pr_reviews migration 0024 + queries + sqlc regen

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 5 days ago

SHA: 54bdb31cf78c9511ebdcf5a0368989a34180eb9a
Parents: 8aaaf88
Tree: e0553f1

14 changed files

Status	File	+	-
M	`internal/auth/policy/sqlc/models.go`	146	12
M	`internal/issues/sqlc/models.go`	146	12
M	`internal/meta/sqlc/models.go`	146	12
A	`internal/migrationsfs/migrations/0024_pr_reviews.sql`	134	0
A	`internal/pulls/queries/reviews.sql`	170	0
M	`internal/pulls/sqlc/models.go`	146	12
M	`internal/pulls/sqlc/querier.go`	48	0
A	`internal/pulls/sqlc/reviews.sql.go`	743	0
M	`internal/repos/queries/branch_protection.sql`	13	2
M	`internal/repos/sqlc/branch_protection.sql.go`	37	2
M	`internal/repos/sqlc/models.go`	146	12
M	`internal/repos/sqlc/querier.go`	3	0
M	`internal/users/sqlc/models.go`	146	12
M	`internal/worker/sqlc/models.go`	146	12

internal/auth/policy/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/issues/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/meta/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/migrationsfs/migrations/0024_pr_reviews.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
 +--
 +-- S23 PR-review subsystem.
 +--
 +--   pr_reviews          — one row per submitted review (comment / approve /
 +--                         request_changes); also dismissable with reason.
 +--   pr_review_comments  — file-level inline comments anchored on
 +--                         (file_path, side, original_commit_sha,
 +--                         original_line, original_position). Each is
 +--                         either part of a submitted review (review_id
 +--                         non-NULL) or a single inline comment outside a
 +--                         review (review_id IS NULL, pending=false), or a
 +--                         server-side draft that hasn't been submitted yet
 +--                         (review_id IS NULL, pending=true).
 +--   pr_review_requests  — pending review requests; satisfied when the
 +--                         requested user submits an approve/request_changes.
 +--
 +-- Branch protection extensions (the actual gate evaluation lives in
 +-- internal/pulls/review/required.go):
 +--
 +--   required_review_count           int  DEFAULT 0
 +--   dismiss_stale_reviews_on_push   bool DEFAULT false
 +--   require_code_owner_review       bool DEFAULT false  (placeholder; CODEOWNERS post-MVP)
++
 +-- +goose Up
++
 +CREATE TYPE pr_review_state AS ENUM ('comment', 'approve', 'request_changes');
 +CREATE TYPE pr_review_side  AS ENUM ('left', 'right');
++
 +CREATE TABLE pr_reviews (
 +    id                    bigserial         PRIMARY KEY,
 +    pr_issue_id           bigint            NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    author_user_id        bigint            REFERENCES users(id) ON DELETE SET NULL,
 +    state                 pr_review_state   NOT NULL,
 +    body                  text              NOT NULL DEFAULT '',
 +    body_html_cached      text,
 +    submitted_at          timestamptz       NOT NULL DEFAULT now(),
 +    dismissed_at          timestamptz,
 +    dismissed_by_user_id  bigint            REFERENCES users(id) ON DELETE SET NULL,
 +    dismissal_reason      text              NOT NULL DEFAULT ''
 +);
++
 +CREATE INDEX pr_reviews_pr_idx
 +    ON pr_reviews (pr_issue_id, submitted_at DESC);
 +CREATE INDEX pr_reviews_state_idx
 +    ON pr_reviews (pr_issue_id, state) WHERE dismissed_at IS NULL;
++
++
 +CREATE TABLE pr_review_comments (
 +    id                    bigserial         PRIMARY KEY,
 +    pr_issue_id           bigint            NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    review_id             bigint            REFERENCES pr_reviews(id) ON DELETE SET NULL,
 +    author_user_id        bigint            REFERENCES users(id) ON DELETE SET NULL,
 +    file_path             text              NOT NULL,
 +    side                  pr_review_side    NOT NULL DEFAULT 'right',
 +    original_commit_sha   text              NOT NULL,
 +    original_line         int               NOT NULL,
 +    original_position     int               NOT NULL,
 +    -- NULL means the comment has gone outdated (no equivalent line on the
 +    -- current head). Comments still display in the timeline + a "Show
 +    -- outdated" toggle in the Files tab.
 +    current_position      int,
 +    body                  text              NOT NULL,
 +    body_html_cached      text,
 +    in_reply_to_id        bigint            REFERENCES pr_review_comments(id) ON DELETE SET NULL,
 +    -- Server-side draft state: pending=true rows belong to a draft review
 +    -- the author hasn't submitted yet. They flip to pending=false +
 +    -- review_id=N when the review is submitted.
 +    pending               boolean           NOT NULL DEFAULT false,
 +    resolved_at           timestamptz,
 +    resolved_by_user_id   bigint            REFERENCES users(id) ON DELETE SET NULL,
 +    created_at            timestamptz       NOT NULL DEFAULT now(),
 +    updated_at            timestamptz       NOT NULL DEFAULT now(),
 +    edited_at             timestamptz,
++
 +    CONSTRAINT pr_review_comments_body_length CHECK (char_length(body) BETWEEN 1 AND 65535)
 +);
++
 +CREATE INDEX pr_review_comments_pr_idx
 +    ON pr_review_comments (pr_issue_id, created_at);
 +CREATE INDEX pr_review_comments_review_idx
 +    ON pr_review_comments (review_id) WHERE review_id IS NOT NULL;
 +CREATE INDEX pr_review_comments_drafts_idx
 +    ON pr_review_comments (pr_issue_id, author_user_id) WHERE pending = true;
 +CREATE INDEX pr_review_comments_threads_idx
 +    ON pr_review_comments (in_reply_to_id);
++
 +CREATE TRIGGER set_updated_at BEFORE UPDATE ON pr_review_comments
 +    FOR EACH ROW EXECUTE FUNCTION tg_set_updated_at();
++
++
 +CREATE TABLE pr_review_requests (
 +    id                       bigserial    PRIMARY KEY,
 +    pr_issue_id              bigint       NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    requested_user_id        bigint       REFERENCES users(id) ON DELETE CASCADE,
 +    -- Teams arrive in S31; column is in from day one so the migration
 +    -- doesn't need to touch this table when teams ship.
 +    requested_team_id        bigint,
 +    requested_by_user_id     bigint       REFERENCES users(id) ON DELETE SET NULL,
 +    requested_at             timestamptz  NOT NULL DEFAULT now(),
 +    dismissed_at             timestamptz,
 +    satisfied_by_review_id   bigint       REFERENCES pr_reviews(id) ON DELETE SET NULL,
++
 +    CONSTRAINT pr_review_requests_target_xor CHECK (
 +        (requested_user_id IS NOT NULL) <> (requested_team_id IS NOT NULL)
 +    )
 +);
++
 +CREATE INDEX pr_review_requests_user_pending_idx
 +    ON pr_review_requests (requested_user_id)
 +    WHERE dismissed_at IS NULL AND satisfied_by_review_id IS NULL;
 +CREATE INDEX pr_review_requests_pr_idx
 +    ON pr_review_requests (pr_issue_id);
++
++
 +-- Branch-protection knobs.
 +ALTER TABLE branch_protection_rules
 +    ADD COLUMN required_review_count          int  NOT NULL DEFAULT 0,
 +    ADD COLUMN dismiss_stale_reviews_on_push  bool NOT NULL DEFAULT false,
 +    ADD COLUMN require_code_owner_review      bool NOT NULL DEFAULT false,
 +    ADD CONSTRAINT branch_protection_rules_required_review_nonneg CHECK (required_review_count >= 0);
++
++
 +-- +goose Down
 +ALTER TABLE branch_protection_rules
 +    DROP CONSTRAINT IF EXISTS branch_protection_rules_required_review_nonneg,
 +    DROP COLUMN IF EXISTS require_code_owner_review,
 +    DROP COLUMN IF EXISTS dismiss_stale_reviews_on_push,
 +    DROP COLUMN IF EXISTS required_review_count;
 +DROP TABLE IF EXISTS pr_review_requests;
 +DROP TABLE IF EXISTS pr_review_comments;
 +DROP TABLE IF EXISTS pr_reviews;
 +DROP TYPE IF EXISTS pr_review_side;
 +DROP TYPE IF EXISTS pr_review_state;

internal/pulls/queries/reviews.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
++
 +-- ─── pr_reviews ──────────────────────────────────────────────────────
++
 +-- name: CreatePRReview :one
 +INSERT INTO pr_reviews (
 +    pr_issue_id, author_user_id, state, body, body_html_cached
 +) VALUES (
 +    $1, sqlc.narg(author_user_id)::bigint, $2, $3, sqlc.narg(body_html_cached)::text
 +)
 +RETURNING *;
++
 +-- name: GetPRReviewByID :one
 +SELECT * FROM pr_reviews WHERE id = $1;
++
 +-- name: ListPRReviews :many
 +SELECT * FROM pr_reviews
 +WHERE pr_issue_id = $1
 +ORDER BY submitted_at;
++
 +-- name: DismissPRReview :exec
 +UPDATE pr_reviews
 +SET dismissed_at = now(),
 +    dismissed_by_user_id = sqlc.narg(dismissed_by_user_id)::bigint,
 +    dismissal_reason = $2
 +WHERE id = $1;
++
 +-- name: CountPRReviewsForGate :one
 +-- Returns the counts the merge gate cares about. `approves` excludes
 +-- dismissed reviews; `request_changes` includes only undismissed and
 +-- unsuperseded-by-same-author reviews. The "unsuperseded" semantics
 +-- (a later review by the same author wins) is computed in Go on the
 +-- caller side; this query only returns the raw rows it needs.
 +SELECT
 +    count(*) FILTER (WHERE state = 'approve' AND dismissed_at IS NULL)::int AS approves,
 +    count(*) FILTER (WHERE state = 'request_changes' AND dismissed_at IS NULL)::int AS request_changes
 +FROM pr_reviews
 +WHERE pr_issue_id = $1;
++
 +-- name: ListUndismissedReviewsForGate :many
 +-- Used by the merge gate to compute "latest review per author" semantics
 +-- in Go. Ordered author + submitted_at so the caller can pick the last
 +-- per author cheaply.
 +SELECT id, pr_issue_id, author_user_id, state, submitted_at
 +FROM pr_reviews
 +WHERE pr_issue_id = $1
 +  AND dismissed_at IS NULL
 +ORDER BY author_user_id, submitted_at;
++
++
 +-- ─── pr_review_comments ──────────────────────────────────────────────
++
 +-- name: CreatePRReviewComment :one
 +INSERT INTO pr_review_comments (
 +    pr_issue_id, review_id, author_user_id, file_path, side,
 +    original_commit_sha, original_line, original_position, current_position,
 +    body, body_html_cached, in_reply_to_id, pending
 +) VALUES (
 +    $1, sqlc.narg(review_id)::bigint, sqlc.narg(author_user_id)::bigint, $2, $3,
 +    $4, $5, $6, $7,
 +    $8, sqlc.narg(body_html_cached)::text, sqlc.narg(in_reply_to_id)::bigint, $9
 +)
 +RETURNING *;
++
 +-- name: GetPRReviewComment :one
 +SELECT * FROM pr_review_comments WHERE id = $1;
++
 +-- name: ListPRReviewComments :many
 +SELECT * FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +ORDER BY created_at;
++
 +-- name: ListPRReviewCommentsForFile :many
 +-- Files-tab fetch: comments anchored to a single file path, oldest first.
 +SELECT * FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +  AND file_path = $2
 +  AND pending = false
 +ORDER BY created_at;
++
 +-- name: ListPendingDraftCommentsForUser :many
 +-- Server-side draft listing: rows with pending=true belonging to one
 +-- user. Ordered by creation so the submit step processes them in order.
 +SELECT * FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +  AND author_user_id = $2
 +  AND pending = true
 +ORDER BY created_at;
++
 +-- name: AttachPendingCommentsToReview :exec
 +-- One-shot UPDATE that flips a user's pending draft comments on a PR
 +-- into the just-submitted review. Runs inside the submit-review tx.
 +UPDATE pr_review_comments
 +SET review_id = $3, pending = false, updated_at = now()
 +WHERE pr_issue_id = $1
 +  AND author_user_id = $2
 +  AND pending = true;
++
 +-- name: UpdatePRReviewCommentBody :exec
 +UPDATE pr_review_comments
 +SET body = $2, body_html_cached = sqlc.narg(body_html_cached)::text,
 +    edited_at = now(), updated_at = now()
 +WHERE id = $1;
++
 +-- name: SetPRReviewCommentResolved :exec
 +UPDATE pr_review_comments
 +SET resolved_at = sqlc.narg(resolved_at)::timestamptz,
 +    resolved_by_user_id = sqlc.narg(resolved_by_user_id)::bigint,
 +    updated_at = now()
 +WHERE id = $1;
++
 +-- name: SetPRReviewCommentCurrentPosition :exec
 +-- Position-mapping update emitted by pulls.Synchronize. NULL means
 +-- the comment has gone outdated.
 +UPDATE pr_review_comments
 +SET current_position = sqlc.narg(current_position)::int,
 +    updated_at = now()
 +WHERE id = $1;
++
 +-- name: ListNonDraftCommentsForPositionMap :many
 +-- Position-mapping reads only submitted comments (drafts re-anchor
 +-- when the user resumes the diff view).
 +SELECT id, file_path, side, original_commit_sha, original_line, original_position
 +FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +  AND pending = false;
++
++
 +-- ─── pr_review_requests ──────────────────────────────────────────────
++
 +-- name: CreatePRReviewRequest :one
 +INSERT INTO pr_review_requests (
 +    pr_issue_id, requested_user_id, requested_team_id, requested_by_user_id
 +) VALUES (
 +    $1, sqlc.narg(requested_user_id)::bigint, sqlc.narg(requested_team_id)::bigint, sqlc.narg(requested_by_user_id)::bigint
 +)
 +RETURNING *;
++
 +-- name: ListPRReviewRequests :many
 +SELECT * FROM pr_review_requests
 +WHERE pr_issue_id = $1
 +ORDER BY requested_at;
++
 +-- name: ListPendingReviewRequestsForUser :many
 +-- Reviewer's inbox feed. Excludes dismissed + satisfied requests.
 +SELECT pr.* FROM pr_review_requests pr
 +WHERE requested_user_id = $1
 +  AND dismissed_at IS NULL
 +  AND satisfied_by_review_id IS NULL
 +ORDER BY requested_at DESC;
++
 +-- name: SatisfyPRReviewRequest :exec
 +UPDATE pr_review_requests
 +SET satisfied_by_review_id = $2
 +WHERE pr_issue_id = $1
 +  AND requested_user_id = $3
 +  AND dismissed_at IS NULL
 +  AND satisfied_by_review_id IS NULL;
++
 +-- name: DismissPRReviewRequest :exec
 +UPDATE pr_review_requests
 +SET dismissed_at = now()
 +WHERE id = $1;
++
 +-- name: CountActivePRReviewRequests :one
 +-- Used by the rate-limit gate (max 20 reviewers per PR per the spec
 +-- pitfall section).
 +SELECT count(*)::int FROM pr_review_requests
 +WHERE pr_issue_id = $1
 +  AND dismissed_at IS NULL;

internal/pulls/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/pulls/sqlc/querier.gomodified

  import (
  	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
+ )
  type Querier interface {
 +	// One-shot UPDATE that flips a user's pending draft comments on a PR
 +	// into the just-submitted review. Runs inside the submit-review tx.
 +	AttachPendingCommentsToReview(ctx context.Context, db DBTX, arg AttachPendingCommentsToReviewParams) error
  	// ─── commits + files (refreshed on synchronize) ──────────────────────
  	ClearPullRequestCommits(ctx context.Context, db DBTX, prID int64) error
  	ClearPullRequestFiles(ctx context.Context, db DBTX, prID int64) error
 +	// Used by the rate-limit gate (max 20 reviewers per PR per the spec
 +	// pitfall section).
 +	CountActivePRReviewRequests(ctx context.Context, db DBTX, prIssueID int64) (int32, error)
 +	// Returns the counts the merge gate cares about. `approves` excludes
 +	// dismissed reviews; `request_changes` includes only undismissed and
 +	// unsuperseded-by-same-author reviews. The "unsuperseded" semantics
 +	// (a later review by the same author wins) is computed in Go on the
 +	// caller side; this query only returns the raw rows it needs.
 +	CountPRReviewsForGate(ctx context.Context, db DBTX, prIssueID int64) (CountPRReviewsForGateRow, error)
  	CountPullRequestsByRepo(ctx context.Context, db DBTX, arg CountPullRequestsByRepoParams) (int64, error)
  	// SPDX-License-Identifier: AGPL-3.0-or-later
 +	// ─── pr_reviews ──────────────────────────────────────────────────────
 +	CreatePRReview(ctx context.Context, db DBTX, arg CreatePRReviewParams) (PrReview, error)
 +	// ─── pr_review_comments ──────────────────────────────────────────────
 +	CreatePRReviewComment(ctx context.Context, db DBTX, arg CreatePRReviewCommentParams) (PrReviewComment, error)
 +	// ─── pr_review_requests ──────────────────────────────────────────────
 +	CreatePRReviewRequest(ctx context.Context, db DBTX, arg CreatePRReviewRequestParams) (PrReviewRequest, error)
 +	// SPDX-License-Identifier: AGPL-3.0-or-later
  	// ─── pull_requests core ──────────────────────────────────────────────
  	// Creates the PR-side row keyed on issue_id (the caller already
  	// inserted the issues row with kind='pr'). Defaults give a freshly-
  	// opened PR `mergeable_state='unknown'` until the mergeability job
  	// ticks.
  	CreatePullRequest(ctx context.Context, db DBTX, arg CreatePullRequestParams) (PullRequest, error)
 +	DismissPRReview(ctx context.Context, db DBTX, arg DismissPRReviewParams) error
 +	DismissPRReviewRequest(ctx context.Context, db DBTX, id int64) error
 +	GetPRReviewByID(ctx context.Context, db DBTX, id int64) (PrReview, error)
 +	GetPRReviewComment(ctx context.Context, db DBTX, id int64) (PrReviewComment, error)
  	GetPullRequestByIssueID(ctx context.Context, db DBTX, issueID int64) (PullRequest, error)
  	// Joins issues + pull_requests so handlers can resolve via the URL
  	// {owner}/{repo}/pulls/{number} in one round-trip.
  	GetPullRequestByRepoAndNumber(ctx context.Context, db DBTX, arg GetPullRequestByRepoAndNumberParams) (GetPullRequestByRepoAndNumberRow, error)
  	InsertPullRequestCommit(ctx context.Context, db DBTX, arg InsertPullRequestCommitParams) error
  	InsertPullRequestFile(ctx context.Context, db DBTX, arg InsertPullRequestFileParams) error
 +	// Position-mapping reads only submitted comments (drafts re-anchor
 +	// when the user resumes the diff view).
 +	ListNonDraftCommentsForPositionMap(ctx context.Context, db DBTX, prIssueID int64) ([]ListNonDraftCommentsForPositionMapRow, error)
  	// Returns the issue_ids of every still-open PR whose head_repo_id +
  	// head_ref match the pushed ref. push:process uses this to fan-out
  	// pr:synchronize jobs after a head-side push.
  	ListOpenPRsForHeadRef(ctx context.Context, db DBTX, arg ListOpenPRsForHeadRefParams) ([]int64, error)
 +	ListPRReviewComments(ctx context.Context, db DBTX, prIssueID int64) ([]PrReviewComment, error)
 +	// Files-tab fetch: comments anchored to a single file path, oldest first.
 +	ListPRReviewCommentsForFile(ctx context.Context, db DBTX, arg ListPRReviewCommentsForFileParams) ([]PrReviewComment, error)
 +	ListPRReviewRequests(ctx context.Context, db DBTX, prIssueID int64) ([]PrReviewRequest, error)
 +	ListPRReviews(ctx context.Context, db DBTX, prIssueID int64) ([]PrReview, error)
 +	// Server-side draft listing: rows with pending=true belonging to one
 +	// user. Ordered by creation so the submit step processes them in order.
 +	ListPendingDraftCommentsForUser(ctx context.Context, db DBTX, arg ListPendingDraftCommentsForUserParams) ([]PrReviewComment, error)
 +	// Reviewer's inbox feed. Excludes dismissed + satisfied requests.
 +	ListPendingReviewRequestsForUser(ctx context.Context, db DBTX, requestedUserID pgtype.Int8) ([]PrReviewRequest, error)
  	ListPullRequestCommits(ctx context.Context, db DBTX, prID int64) ([]PullRequestCommit, error)
  	ListPullRequestFiles(ctx context.Context, db DBTX, prID int64) ([]PullRequestFile, error)
  	// Mirrors the issues list query: state filter via narg, pagination,
  	// ordered by recent activity.
  	ListPullRequestsByRepo(ctx context.Context, db DBTX, arg ListPullRequestsByRepoParams) ([]ListPullRequestsByRepoRow, error)
 +	// Used by the merge gate to compute "latest review per author" semantics
 +	// in Go. Ordered author + submitted_at so the caller can pick the last
 +	// per author cheaply.
 +	ListUndismissedReviewsForGate(ctx context.Context, db DBTX, prIssueID int64) ([]ListUndismissedReviewsForGateRow, error)
  	// FOR UPDATE row lock + return current shape so the merge job can
  	// decide whether to proceed (e.g. someone else just merged it).
  	LockPullRequestForMerge(ctx context.Context, db DBTX, issueID int64) (PullRequest, error)
 +	SatisfyPRReviewRequest(ctx context.Context, db DBTX, arg SatisfyPRReviewRequestParams) error
 +	// Position-mapping update emitted by pulls.Synchronize. NULL means
 +	// the comment has gone outdated.
 +	SetPRReviewCommentCurrentPosition(ctx context.Context, db DBTX, arg SetPRReviewCommentCurrentPositionParams) error
 +	SetPRReviewCommentResolved(ctx context.Context, db DBTX, arg SetPRReviewCommentResolvedParams) error
  	SetPullRequestDraft(ctx context.Context, db DBTX, arg SetPullRequestDraftParams) error
  	SetPullRequestMergeability(ctx context.Context, db DBTX, arg SetPullRequestMergeabilityParams) error
  	SetPullRequestMerged(ctx context.Context, db DBTX, arg SetPullRequestMergedParams) error
  	// Updates base_oid + head_oid + last_synchronized_at after a
  	// synchronize tick.
  	SetPullRequestSnapshot(ctx context.Context, db DBTX, arg SetPullRequestSnapshotParams) error
 +	UpdatePRReviewCommentBody(ctx context.Context, db DBTX, arg UpdatePRReviewCommentBodyParams) error
+ }
  var _ Querier = (*Queries)(nil)

internal/pulls/sqlc/reviews.sql.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: reviews.sql
++
 +package pullsdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const attachPendingCommentsToReview = `-- name: AttachPendingCommentsToReview :exec
 +UPDATE pr_review_comments
 +SET review_id = $3, pending = false, updated_at = now()
 +WHERE pr_issue_id = $1
 +  AND author_user_id = $2
 +  AND pending = true
 +`
++
 +type AttachPendingCommentsToReviewParams struct {
 +	PrIssueID    int64
 +	AuthorUserID pgtype.Int8
 +	ReviewID     pgtype.Int8
 +}
++
 +// One-shot UPDATE that flips a user's pending draft comments on a PR
 +// into the just-submitted review. Runs inside the submit-review tx.
 +func (q *Queries) AttachPendingCommentsToReview(ctx context.Context, db DBTX, arg AttachPendingCommentsToReviewParams) error {
 +	_, err := db.Exec(ctx, attachPendingCommentsToReview, arg.PrIssueID, arg.AuthorUserID, arg.ReviewID)
 +	return err
 +}
++
 +const countActivePRReviewRequests = `-- name: CountActivePRReviewRequests :one
 +SELECT count(*)::int FROM pr_review_requests
 +WHERE pr_issue_id = $1
 +  AND dismissed_at IS NULL
 +`
++
 +// Used by the rate-limit gate (max 20 reviewers per PR per the spec
 +// pitfall section).
 +func (q *Queries) CountActivePRReviewRequests(ctx context.Context, db DBTX, prIssueID int64) (int32, error) {
 +	row := db.QueryRow(ctx, countActivePRReviewRequests, prIssueID)
 +	var column_1 int32
 +	err := row.Scan(&column_1)
 +	return column_1, err
 +}
++
 +const countPRReviewsForGate = `-- name: CountPRReviewsForGate :one
 +SELECT
 +    count(*) FILTER (WHERE state = 'approve' AND dismissed_at IS NULL)::int AS approves,
 +    count(*) FILTER (WHERE state = 'request_changes' AND dismissed_at IS NULL)::int AS request_changes
 +FROM pr_reviews
 +WHERE pr_issue_id = $1
 +`
++
 +type CountPRReviewsForGateRow struct {
 +	Approves       int32
 +	RequestChanges int32
 +}
++
 +// Returns the counts the merge gate cares about. `approves` excludes
 +// dismissed reviews; `request_changes` includes only undismissed and
 +// unsuperseded-by-same-author reviews. The "unsuperseded" semantics
 +// (a later review by the same author wins) is computed in Go on the
 +// caller side; this query only returns the raw rows it needs.
 +func (q *Queries) CountPRReviewsForGate(ctx context.Context, db DBTX, prIssueID int64) (CountPRReviewsForGateRow, error) {
 +	row := db.QueryRow(ctx, countPRReviewsForGate, prIssueID)
 +	var i CountPRReviewsForGateRow
 +	err := row.Scan(&i.Approves, &i.RequestChanges)
 +	return i, err
 +}
++
 +const createPRReview = `-- name: CreatePRReview :one
++
++
 +INSERT INTO pr_reviews (
 +    pr_issue_id, author_user_id, state, body, body_html_cached
 +) VALUES (
 +    $1, $4::bigint, $2, $3, $5::text
 +)
 +RETURNING id, pr_issue_id, author_user_id, state, body, body_html_cached, submitted_at, dismissed_at, dismissed_by_user_id, dismissal_reason
 +`
++
 +type CreatePRReviewParams struct {
 +	PrIssueID      int64
 +	State          PrReviewState
 +	Body           string
 +	AuthorUserID   pgtype.Int8
 +	BodyHtmlCached pgtype.Text
 +}
++
 +// SPDX-License-Identifier: AGPL-3.0-or-later
 +// ─── pr_reviews ──────────────────────────────────────────────────────
 +func (q *Queries) CreatePRReview(ctx context.Context, db DBTX, arg CreatePRReviewParams) (PrReview, error) {
 +	row := db.QueryRow(ctx, createPRReview,
 +		arg.PrIssueID,
 +		arg.State,
 +		arg.Body,
 +		arg.AuthorUserID,
 +		arg.BodyHtmlCached,
 +	)
 +	var i PrReview
 +	err := row.Scan(
 +		&i.ID,
 +		&i.PrIssueID,
 +		&i.AuthorUserID,
 +		&i.State,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.SubmittedAt,
 +		&i.DismissedAt,
 +		&i.DismissedByUserID,
 +		&i.DismissalReason,
 +	)
 +	return i, err
 +}
++
 +const createPRReviewComment = `-- name: CreatePRReviewComment :one
++
 +INSERT INTO pr_review_comments (
 +    pr_issue_id, review_id, author_user_id, file_path, side,
 +    original_commit_sha, original_line, original_position, current_position,
 +    body, body_html_cached, in_reply_to_id, pending
 +) VALUES (
 +    $1, $10::bigint, $11::bigint, $2, $3,
 +    $4, $5, $6, $7,
 +    $8, $12::text, $13::bigint, $9
 +)
 +RETURNING id, pr_issue_id, review_id, author_user_id, file_path, side, original_commit_sha, original_line, original_position, current_position, body, body_html_cached, in_reply_to_id, pending, resolved_at, resolved_by_user_id, created_at, updated_at, edited_at
 +`
++
 +type CreatePRReviewCommentParams struct {
 +	PrIssueID         int64
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	Pending           bool
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +}
++
 +// ─── pr_review_comments ──────────────────────────────────────────────
 +func (q *Queries) CreatePRReviewComment(ctx context.Context, db DBTX, arg CreatePRReviewCommentParams) (PrReviewComment, error) {
 +	row := db.QueryRow(ctx, createPRReviewComment,
 +		arg.PrIssueID,
 +		arg.FilePath,
 +		arg.Side,
 +		arg.OriginalCommitSha,
 +		arg.OriginalLine,
 +		arg.OriginalPosition,
 +		arg.CurrentPosition,
 +		arg.Body,
 +		arg.Pending,
 +		arg.ReviewID,
 +		arg.AuthorUserID,
 +		arg.BodyHtmlCached,
 +		arg.InReplyToID,
 +	)
 +	var i PrReviewComment
 +	err := row.Scan(
 +		&i.ID,
 +		&i.PrIssueID,
 +		&i.ReviewID,
 +		&i.AuthorUserID,
 +		&i.FilePath,
 +		&i.Side,
 +		&i.OriginalCommitSha,
 +		&i.OriginalLine,
 +		&i.OriginalPosition,
 +		&i.CurrentPosition,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.InReplyToID,
 +		&i.Pending,
 +		&i.ResolvedAt,
 +		&i.ResolvedByUserID,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +	)
 +	return i, err
 +}
++
 +const createPRReviewRequest = `-- name: CreatePRReviewRequest :one
++
 +INSERT INTO pr_review_requests (
 +    pr_issue_id, requested_user_id, requested_team_id, requested_by_user_id
 +) VALUES (
 +    $1, $2::bigint, $3::bigint, $4::bigint
 +)
 +RETURNING id, pr_issue_id, requested_user_id, requested_team_id, requested_by_user_id, requested_at, dismissed_at, satisfied_by_review_id
 +`
++
 +type CreatePRReviewRequestParams struct {
 +	PrIssueID         int64
 +	RequestedUserID   pgtype.Int8
 +	RequestedTeamID   pgtype.Int8
 +	RequestedByUserID pgtype.Int8
 +}
++
 +// ─── pr_review_requests ──────────────────────────────────────────────
 +func (q *Queries) CreatePRReviewRequest(ctx context.Context, db DBTX, arg CreatePRReviewRequestParams) (PrReviewRequest, error) {
 +	row := db.QueryRow(ctx, createPRReviewRequest,
 +		arg.PrIssueID,
 +		arg.RequestedUserID,
 +		arg.RequestedTeamID,
 +		arg.RequestedByUserID,
 +	)
 +	var i PrReviewRequest
 +	err := row.Scan(
 +		&i.ID,
 +		&i.PrIssueID,
 +		&i.RequestedUserID,
 +		&i.RequestedTeamID,
 +		&i.RequestedByUserID,
 +		&i.RequestedAt,
 +		&i.DismissedAt,
 +		&i.SatisfiedByReviewID,
 +	)
 +	return i, err
 +}
++
 +const dismissPRReview = `-- name: DismissPRReview :exec
 +UPDATE pr_reviews
 +SET dismissed_at = now(),
 +    dismissed_by_user_id = $3::bigint,
 +    dismissal_reason = $2
 +WHERE id = $1
 +`
++
 +type DismissPRReviewParams struct {
 +	ID                int64
 +	DismissalReason   string
 +	DismissedByUserID pgtype.Int8
 +}
++
 +func (q *Queries) DismissPRReview(ctx context.Context, db DBTX, arg DismissPRReviewParams) error {
 +	_, err := db.Exec(ctx, dismissPRReview, arg.ID, arg.DismissalReason, arg.DismissedByUserID)
 +	return err
 +}
++
 +const dismissPRReviewRequest = `-- name: DismissPRReviewRequest :exec
 +UPDATE pr_review_requests
 +SET dismissed_at = now()
 +WHERE id = $1
 +`
++
 +func (q *Queries) DismissPRReviewRequest(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, dismissPRReviewRequest, id)
 +	return err
 +}
++
 +const getPRReviewByID = `-- name: GetPRReviewByID :one
 +SELECT id, pr_issue_id, author_user_id, state, body, body_html_cached, submitted_at, dismissed_at, dismissed_by_user_id, dismissal_reason FROM pr_reviews WHERE id = $1
 +`
++
 +func (q *Queries) GetPRReviewByID(ctx context.Context, db DBTX, id int64) (PrReview, error) {
 +	row := db.QueryRow(ctx, getPRReviewByID, id)
 +	var i PrReview
 +	err := row.Scan(
 +		&i.ID,
 +		&i.PrIssueID,
 +		&i.AuthorUserID,
 +		&i.State,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.SubmittedAt,
 +		&i.DismissedAt,
 +		&i.DismissedByUserID,
 +		&i.DismissalReason,
 +	)
 +	return i, err
 +}
++
 +const getPRReviewComment = `-- name: GetPRReviewComment :one
 +SELECT id, pr_issue_id, review_id, author_user_id, file_path, side, original_commit_sha, original_line, original_position, current_position, body, body_html_cached, in_reply_to_id, pending, resolved_at, resolved_by_user_id, created_at, updated_at, edited_at FROM pr_review_comments WHERE id = $1
 +`
++
 +func (q *Queries) GetPRReviewComment(ctx context.Context, db DBTX, id int64) (PrReviewComment, error) {
 +	row := db.QueryRow(ctx, getPRReviewComment, id)
 +	var i PrReviewComment
 +	err := row.Scan(
 +		&i.ID,
 +		&i.PrIssueID,
 +		&i.ReviewID,
 +		&i.AuthorUserID,
 +		&i.FilePath,
 +		&i.Side,
 +		&i.OriginalCommitSha,
 +		&i.OriginalLine,
 +		&i.OriginalPosition,
 +		&i.CurrentPosition,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.InReplyToID,
 +		&i.Pending,
 +		&i.ResolvedAt,
 +		&i.ResolvedByUserID,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +	)
 +	return i, err
 +}
++
 +const listNonDraftCommentsForPositionMap = `-- name: ListNonDraftCommentsForPositionMap :many
 +SELECT id, file_path, side, original_commit_sha, original_line, original_position
 +FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +  AND pending = false
 +`
++
 +type ListNonDraftCommentsForPositionMapRow struct {
 +	ID                int64
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +}
++
 +// Position-mapping reads only submitted comments (drafts re-anchor
 +// when the user resumes the diff view).
 +func (q *Queries) ListNonDraftCommentsForPositionMap(ctx context.Context, db DBTX, prIssueID int64) ([]ListNonDraftCommentsForPositionMapRow, error) {
 +	rows, err := db.Query(ctx, listNonDraftCommentsForPositionMap, prIssueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListNonDraftCommentsForPositionMapRow{}
 +	for rows.Next() {
 +		var i ListNonDraftCommentsForPositionMapRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.FilePath,
 +			&i.Side,
 +			&i.OriginalCommitSha,
 +			&i.OriginalLine,
 +			&i.OriginalPosition,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPRReviewComments = `-- name: ListPRReviewComments :many
 +SELECT id, pr_issue_id, review_id, author_user_id, file_path, side, original_commit_sha, original_line, original_position, current_position, body, body_html_cached, in_reply_to_id, pending, resolved_at, resolved_by_user_id, created_at, updated_at, edited_at FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +ORDER BY created_at
 +`
++
 +func (q *Queries) ListPRReviewComments(ctx context.Context, db DBTX, prIssueID int64) ([]PrReviewComment, error) {
 +	rows, err := db.Query(ctx, listPRReviewComments, prIssueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []PrReviewComment{}
 +	for rows.Next() {
 +		var i PrReviewComment
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.ReviewID,
 +			&i.AuthorUserID,
 +			&i.FilePath,
 +			&i.Side,
 +			&i.OriginalCommitSha,
 +			&i.OriginalLine,
 +			&i.OriginalPosition,
 +			&i.CurrentPosition,
 +			&i.Body,
 +			&i.BodyHtmlCached,
 +			&i.InReplyToID,
 +			&i.Pending,
 +			&i.ResolvedAt,
 +			&i.ResolvedByUserID,
 +			&i.CreatedAt,
 +			&i.UpdatedAt,
 +			&i.EditedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPRReviewCommentsForFile = `-- name: ListPRReviewCommentsForFile :many
 +SELECT id, pr_issue_id, review_id, author_user_id, file_path, side, original_commit_sha, original_line, original_position, current_position, body, body_html_cached, in_reply_to_id, pending, resolved_at, resolved_by_user_id, created_at, updated_at, edited_at FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +  AND file_path = $2
 +  AND pending = false
 +ORDER BY created_at
 +`
++
 +type ListPRReviewCommentsForFileParams struct {
 +	PrIssueID int64
 +	FilePath  string
 +}
++
 +// Files-tab fetch: comments anchored to a single file path, oldest first.
 +func (q *Queries) ListPRReviewCommentsForFile(ctx context.Context, db DBTX, arg ListPRReviewCommentsForFileParams) ([]PrReviewComment, error) {
 +	rows, err := db.Query(ctx, listPRReviewCommentsForFile, arg.PrIssueID, arg.FilePath)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []PrReviewComment{}
 +	for rows.Next() {
 +		var i PrReviewComment
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.ReviewID,
 +			&i.AuthorUserID,
 +			&i.FilePath,
 +			&i.Side,
 +			&i.OriginalCommitSha,
 +			&i.OriginalLine,
 +			&i.OriginalPosition,
 +			&i.CurrentPosition,
 +			&i.Body,
 +			&i.BodyHtmlCached,
 +			&i.InReplyToID,
 +			&i.Pending,
 +			&i.ResolvedAt,
 +			&i.ResolvedByUserID,
 +			&i.CreatedAt,
 +			&i.UpdatedAt,
 +			&i.EditedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPRReviewRequests = `-- name: ListPRReviewRequests :many
 +SELECT id, pr_issue_id, requested_user_id, requested_team_id, requested_by_user_id, requested_at, dismissed_at, satisfied_by_review_id FROM pr_review_requests
 +WHERE pr_issue_id = $1
 +ORDER BY requested_at
 +`
++
 +func (q *Queries) ListPRReviewRequests(ctx context.Context, db DBTX, prIssueID int64) ([]PrReviewRequest, error) {
 +	rows, err := db.Query(ctx, listPRReviewRequests, prIssueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []PrReviewRequest{}
 +	for rows.Next() {
 +		var i PrReviewRequest
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.RequestedUserID,
 +			&i.RequestedTeamID,
 +			&i.RequestedByUserID,
 +			&i.RequestedAt,
 +			&i.DismissedAt,
 +			&i.SatisfiedByReviewID,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPRReviews = `-- name: ListPRReviews :many
 +SELECT id, pr_issue_id, author_user_id, state, body, body_html_cached, submitted_at, dismissed_at, dismissed_by_user_id, dismissal_reason FROM pr_reviews
 +WHERE pr_issue_id = $1
 +ORDER BY submitted_at
 +`
++
 +func (q *Queries) ListPRReviews(ctx context.Context, db DBTX, prIssueID int64) ([]PrReview, error) {
 +	rows, err := db.Query(ctx, listPRReviews, prIssueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []PrReview{}
 +	for rows.Next() {
 +		var i PrReview
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.AuthorUserID,
 +			&i.State,
 +			&i.Body,
 +			&i.BodyHtmlCached,
 +			&i.SubmittedAt,
 +			&i.DismissedAt,
 +			&i.DismissedByUserID,
 +			&i.DismissalReason,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPendingDraftCommentsForUser = `-- name: ListPendingDraftCommentsForUser :many
 +SELECT id, pr_issue_id, review_id, author_user_id, file_path, side, original_commit_sha, original_line, original_position, current_position, body, body_html_cached, in_reply_to_id, pending, resolved_at, resolved_by_user_id, created_at, updated_at, edited_at FROM pr_review_comments
 +WHERE pr_issue_id = $1
 +  AND author_user_id = $2
 +  AND pending = true
 +ORDER BY created_at
 +`
++
 +type ListPendingDraftCommentsForUserParams struct {
 +	PrIssueID    int64
 +	AuthorUserID pgtype.Int8
 +}
++
 +// Server-side draft listing: rows with pending=true belonging to one
 +// user. Ordered by creation so the submit step processes them in order.
 +func (q *Queries) ListPendingDraftCommentsForUser(ctx context.Context, db DBTX, arg ListPendingDraftCommentsForUserParams) ([]PrReviewComment, error) {
 +	rows, err := db.Query(ctx, listPendingDraftCommentsForUser, arg.PrIssueID, arg.AuthorUserID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []PrReviewComment{}
 +	for rows.Next() {
 +		var i PrReviewComment
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.ReviewID,
 +			&i.AuthorUserID,
 +			&i.FilePath,
 +			&i.Side,
 +			&i.OriginalCommitSha,
 +			&i.OriginalLine,
 +			&i.OriginalPosition,
 +			&i.CurrentPosition,
 +			&i.Body,
 +			&i.BodyHtmlCached,
 +			&i.InReplyToID,
 +			&i.Pending,
 +			&i.ResolvedAt,
 +			&i.ResolvedByUserID,
 +			&i.CreatedAt,
 +			&i.UpdatedAt,
 +			&i.EditedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPendingReviewRequestsForUser = `-- name: ListPendingReviewRequestsForUser :many
 +SELECT pr.id, pr.pr_issue_id, pr.requested_user_id, pr.requested_team_id, pr.requested_by_user_id, pr.requested_at, pr.dismissed_at, pr.satisfied_by_review_id FROM pr_review_requests pr
 +WHERE requested_user_id = $1
 +  AND dismissed_at IS NULL
 +  AND satisfied_by_review_id IS NULL
 +ORDER BY requested_at DESC
 +`
++
 +// Reviewer's inbox feed. Excludes dismissed + satisfied requests.
 +func (q *Queries) ListPendingReviewRequestsForUser(ctx context.Context, db DBTX, requestedUserID pgtype.Int8) ([]PrReviewRequest, error) {
 +	rows, err := db.Query(ctx, listPendingReviewRequestsForUser, requestedUserID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []PrReviewRequest{}
 +	for rows.Next() {
 +		var i PrReviewRequest
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.RequestedUserID,
 +			&i.RequestedTeamID,
 +			&i.RequestedByUserID,
 +			&i.RequestedAt,
 +			&i.DismissedAt,
 +			&i.SatisfiedByReviewID,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listUndismissedReviewsForGate = `-- name: ListUndismissedReviewsForGate :many
 +SELECT id, pr_issue_id, author_user_id, state, submitted_at
 +FROM pr_reviews
 +WHERE pr_issue_id = $1
 +  AND dismissed_at IS NULL
 +ORDER BY author_user_id, submitted_at
 +`
++
 +type ListUndismissedReviewsForGateRow struct {
 +	ID           int64
 +	PrIssueID    int64
 +	AuthorUserID pgtype.Int8
 +	State        PrReviewState
 +	SubmittedAt  pgtype.Timestamptz
 +}
++
 +// Used by the merge gate to compute "latest review per author" semantics
 +// in Go. Ordered author + submitted_at so the caller can pick the last
 +// per author cheaply.
 +func (q *Queries) ListUndismissedReviewsForGate(ctx context.Context, db DBTX, prIssueID int64) ([]ListUndismissedReviewsForGateRow, error) {
 +	rows, err := db.Query(ctx, listUndismissedReviewsForGate, prIssueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListUndismissedReviewsForGateRow{}
 +	for rows.Next() {
 +		var i ListUndismissedReviewsForGateRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.PrIssueID,
 +			&i.AuthorUserID,
 +			&i.State,
 +			&i.SubmittedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const satisfyPRReviewRequest = `-- name: SatisfyPRReviewRequest :exec
 +UPDATE pr_review_requests
 +SET satisfied_by_review_id = $2
 +WHERE pr_issue_id = $1
 +  AND requested_user_id = $3
 +  AND dismissed_at IS NULL
 +  AND satisfied_by_review_id IS NULL
 +`
++
 +type SatisfyPRReviewRequestParams struct {
 +	PrIssueID           int64
 +	SatisfiedByReviewID pgtype.Int8
 +	RequestedUserID     pgtype.Int8
 +}
++
 +func (q *Queries) SatisfyPRReviewRequest(ctx context.Context, db DBTX, arg SatisfyPRReviewRequestParams) error {
 +	_, err := db.Exec(ctx, satisfyPRReviewRequest, arg.PrIssueID, arg.SatisfiedByReviewID, arg.RequestedUserID)
 +	return err
 +}
++
 +const setPRReviewCommentCurrentPosition = `-- name: SetPRReviewCommentCurrentPosition :exec
 +UPDATE pr_review_comments
 +SET current_position = $2::int,
 +    updated_at = now()
 +WHERE id = $1
 +`
++
 +type SetPRReviewCommentCurrentPositionParams struct {
 +	ID              int64
 +	CurrentPosition pgtype.Int4
 +}
++
 +// Position-mapping update emitted by pulls.Synchronize. NULL means
 +// the comment has gone outdated.
 +func (q *Queries) SetPRReviewCommentCurrentPosition(ctx context.Context, db DBTX, arg SetPRReviewCommentCurrentPositionParams) error {
 +	_, err := db.Exec(ctx, setPRReviewCommentCurrentPosition, arg.ID, arg.CurrentPosition)
 +	return err
 +}
++
 +const setPRReviewCommentResolved = `-- name: SetPRReviewCommentResolved :exec
 +UPDATE pr_review_comments
 +SET resolved_at = $2::timestamptz,
 +    resolved_by_user_id = $3::bigint,
 +    updated_at = now()
 +WHERE id = $1
 +`
++
 +type SetPRReviewCommentResolvedParams struct {
 +	ID               int64
 +	ResolvedAt       pgtype.Timestamptz
 +	ResolvedByUserID pgtype.Int8
 +}
++
 +func (q *Queries) SetPRReviewCommentResolved(ctx context.Context, db DBTX, arg SetPRReviewCommentResolvedParams) error {
 +	_, err := db.Exec(ctx, setPRReviewCommentResolved, arg.ID, arg.ResolvedAt, arg.ResolvedByUserID)
 +	return err
 +}
++
 +const updatePRReviewCommentBody = `-- name: UpdatePRReviewCommentBody :exec
 +UPDATE pr_review_comments
 +SET body = $2, body_html_cached = $3::text,
 +    edited_at = now(), updated_at = now()
 +WHERE id = $1
 +`
++
 +type UpdatePRReviewCommentBodyParams struct {
 +	ID             int64
 +	Body           string
 +	BodyHtmlCached pgtype.Text
 +}
++
 +func (q *Queries) UpdatePRReviewCommentBody(ctx context.Context, db DBTX, arg UpdatePRReviewCommentBodyParams) error {
 +	_, err := db.Exec(ctx, updatePRReviewCommentBody, arg.ID, arg.Body, arg.BodyHtmlCached)
 +	return err
 +}

internal/repos/queries/branch_protection.sqlmodified

         prevent_force_push, prevent_deletion, require_pr_for_push,
         allowed_pusher_user_ids,
         require_signed_commits, status_checks_required,
 -       created_at, updated_at, created_by_user_id
 +       created_at, updated_at, created_by_user_id,
 +       required_review_count, dismiss_stale_reviews_on_push, require_code_owner_review
  FROM branch_protection_rules
  WHERE repo_id = $1
  ORDER BY pattern;
         prevent_force_push, prevent_deletion, require_pr_for_push,
         allowed_pusher_user_ids,
         require_signed_commits, status_checks_required,
 -       created_at, updated_at, created_by_user_id
 +       created_at, updated_at, created_by_user_id,
 +       required_review_count, dismiss_stale_reviews_on_push, require_code_owner_review
  FROM branch_protection_rules
  WHERE id = $1;
      allowed_pusher_user_ids = $6
  WHERE id = $1;
 +-- name: UpdateBranchProtectionReviewSettings :exec
 +-- S23 surface for the review-related knobs. Branch-protection edit
 +-- handler calls this alongside UpdateBranchProtectionRule.
 +UPDATE branch_protection_rules
 +SET required_review_count = $2,
 +    dismiss_stale_reviews_on_push = $3,
 +    require_code_owner_review = $4
 +WHERE id = $1;
++
  -- name: DeleteBranchProtectionRule :exec
  DELETE FROM branch_protection_rules WHERE id = $1;

internal/repos/sqlc/branch_protection.sql.gomodified

         prevent_force_push, prevent_deletion, require_pr_for_push,
         allowed_pusher_user_ids,
         require_signed_commits, status_checks_required,
 -       created_at, updated_at, created_by_user_id
 +       created_at, updated_at, created_by_user_id,
 +       required_review_count, dismiss_stale_reviews_on_push, require_code_owner_review
  FROM branch_protection_rules
  WHERE id = $1
+ `
  		&i.CreatedAt,
  		&i.UpdatedAt,
  		&i.CreatedByUserID,
 +		&i.RequiredReviewCount,
 +		&i.DismissStaleReviewsOnPush,
 +		&i.RequireCodeOwnerReview,
+ 	)
  	return i, err
+ }
         prevent_force_push, prevent_deletion, require_pr_for_push,
         allowed_pusher_user_ids,
         require_signed_commits, status_checks_required,
 -       created_at, updated_at, created_by_user_id
 +       created_at, updated_at, created_by_user_id,
 +       required_review_count, dismiss_stale_reviews_on_push, require_code_owner_review
  FROM branch_protection_rules
  WHERE repo_id = $1
  ORDER BY pattern
  			&i.CreatedAt,
  			&i.UpdatedAt,
  			&i.CreatedByUserID,
 +			&i.RequiredReviewCount,
 +			&i.DismissStaleReviewsOnPush,
 +			&i.RequireCodeOwnerReview,
  		); err != nil {
  			return nil, err
+ 		}
  	return items, nil
+ }
 +const updateBranchProtectionReviewSettings = `-- name: UpdateBranchProtectionReviewSettings :exec
 +UPDATE branch_protection_rules
 +SET required_review_count = $2,
 +    dismiss_stale_reviews_on_push = $3,
 +    require_code_owner_review = $4
 +WHERE id = $1
 +`
++
 +type UpdateBranchProtectionReviewSettingsParams struct {
 +	ID                        int64
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
 +}
++
 +// S23 surface for the review-related knobs. Branch-protection edit
 +// handler calls this alongside UpdateBranchProtectionRule.
 +func (q *Queries) UpdateBranchProtectionReviewSettings(ctx context.Context, db DBTX, arg UpdateBranchProtectionReviewSettingsParams) error {
 +	_, err := db.Exec(ctx, updateBranchProtectionReviewSettings,
 +		arg.ID,
 +		arg.RequiredReviewCount,
 +		arg.DismissStaleReviewsOnPush,
 +		arg.RequireCodeOwnerReview,
 +	)
 +	return err
 +}
++
  const updateBranchProtectionRule = `-- name: UpdateBranchProtectionRule :exec
  UPDATE branch_protection_rules
  SET pattern = $2,

internal/repos/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/repos/sqlc/querier.gomodified

  	// so a user→org transfer flips both columns atomically.
  	TransferRepoOwner(ctx context.Context, db DBTX, arg TransferRepoOwnerParams) error
  	UnarchiveRepo(ctx context.Context, db DBTX, id int64) error
 +	// S23 surface for the review-related knobs. Branch-protection edit
 +	// handler calls this alongside UpdateBranchProtectionRule.
 +	UpdateBranchProtectionReviewSettings(ctx context.Context, db DBTX, arg UpdateBranchProtectionReviewSettingsParams) error
  	UpdateBranchProtectionRule(ctx context.Context, db DBTX, arg UpdateBranchProtectionRuleParams) error
  	// Used by the default-branch settings handler. The on-disk HEAD update
  	// is a separate step done via `git symbolic-ref` from the orchestrator.

internal/users/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/worker/sqlc/models.gomodified

  	return string(ns.PrMergeableState), nil
+ }
 +type PrReviewSide string
++
 +const (
 +	PrReviewSideLeft  PrReviewSide = "left"
 +	PrReviewSideRight PrReviewSide = "right"
 +)
++
 +func (e *PrReviewSide) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewSide(s)
 +	case string:
 +		*e = PrReviewSide(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewSide: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewSide struct {
 +	PrReviewSide PrReviewSide
 +	Valid        bool // Valid is true if PrReviewSide is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewSide) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewSide, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewSide.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewSide) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewSide), nil
 +}
++
 +type PrReviewState string
++
 +const (
 +	PrReviewStateComment        PrReviewState = "comment"
 +	PrReviewStateApprove        PrReviewState = "approve"
 +	PrReviewStateRequestChanges PrReviewState = "request_changes"
 +)
++
 +func (e *PrReviewState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrReviewState(s)
 +	case string:
 +		*e = PrReviewState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrReviewState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrReviewState struct {
 +	PrReviewState PrReviewState
 +	Valid         bool // Valid is true if PrReviewState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrReviewState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrReviewState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrReviewState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrReviewState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrReviewState), nil
 +}
++
  type RepoVisibility string
  const (
+ }
  type BranchProtectionRule struct {
 -	ID                   int64
 -	RepoID               int64
 -	Pattern              string
 -	PreventForcePush     bool
 -	PreventDeletion      bool
 -	RequirePrForPush     bool
 -	AllowedPusherUserIds []int64
 -	RequireSignedCommits bool
 -	StatusChecksRequired []string
 -	CreatedAt            pgtype.Timestamptz
 -	UpdatedAt            pgtype.Timestamptz
 -	CreatedByUserID      pgtype.Int8
 +	ID                        int64
 +	RepoID                    int64
 +	Pattern                   string
 +	PreventForcePush          bool
 +	PreventDeletion           bool
 +	RequirePrForPush          bool
 +	AllowedPusherUserIds      []int64
 +	RequireSignedCommits      bool
 +	StatusChecksRequired      []string
 +	CreatedAt                 pgtype.Timestamptz
 +	UpdatedAt                 pgtype.Timestamptz
 +	CreatedByUserID           pgtype.Int8
 +	RequiredReviewCount       int32
 +	DismissStaleReviewsOnPush bool
 +	RequireCodeOwnerReview    bool
+ }
  type EmailVerification struct {
  	CreatedAt pgtype.Timestamptz
+ }
 +type PrReview struct {
 +	ID                int64
 +	PrIssueID         int64
 +	AuthorUserID      pgtype.Int8
 +	State             PrReviewState
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	SubmittedAt       pgtype.Timestamptz
 +	DismissedAt       pgtype.Timestamptz
 +	DismissedByUserID pgtype.Int8
 +	DismissalReason   string
 +}
++
 +type PrReviewComment struct {
 +	ID                int64
 +	PrIssueID         int64
 +	ReviewID          pgtype.Int8
 +	AuthorUserID      pgtype.Int8
 +	FilePath          string
 +	Side              PrReviewSide
 +	OriginalCommitSha string
 +	OriginalLine      int32
 +	OriginalPosition  int32
 +	CurrentPosition   pgtype.Int4
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	InReplyToID       pgtype.Int8
 +	Pending           bool
 +	ResolvedAt        pgtype.Timestamptz
 +	ResolvedByUserID  pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type PrReviewRequest struct {
 +	ID                  int64
 +	PrIssueID           int64
 +	RequestedUserID     pgtype.Int8
 +	RequestedTeamID     pgtype.Int8
 +	RequestedByUserID   pgtype.Int8
 +	RequestedAt         pgtype.Timestamptz
 +	DismissedAt         pgtype.Timestamptz
 +	SatisfiedByReviewID pgtype.Int8
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string