fix(cmd): remove duplicate doc comment and double blank line

Address sonnet-review feedback on PR #106:

- Document that the type assertion in supersedeOldReviews is guaranteed to
  succeed given the caller's provider switch, with the !ok branch guarding
  against future refactors (comment 18889).
- Clarify that vcsURL is only used in the Gitea path for constructing
  review permalink URLs (comment 18890).
- Add note explaining why the page-limit warning in ListReviews only fires
  when the final page is full, confirming the logic is intentional
  (comment 18891).

CONVENTIONS.md

@@ -9,7 +9,7 @@
 
 | Package | Use Case | Scope |
 |---------|----------|-------|
-| `gopkg.in/yaml.v3` | YAML parsing (persona files, config) | production |
+| `github.com/goccy/go-yaml` | YAML parsing and AST inspection (subpkgs: `ast`, `parser`) | production |
 | `github.com/google/go-cmp` | Test comparisons (`cmp.Diff`) | test only |
 
 **Any import not in this table or the Go standard library is forbidden.**

cmd/review-bot/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"errors"
 	"flag"
 	"fmt"
 	"log/slog"
@@ -70,7 +71,7 @@ func main() {
 	conventionsFile := flag.String("conventions-file", envOrDefault("CONVENTIONS_FILE", ""), "Conventions file path in repo (e.g. CLAUDE.md)")
 	systemPromptFile := flag.String("system-prompt-file", envOrDefault("SYSTEM_PROMPT_FILE", ""), "Local file with additional system prompt instructions")
 	patternsRepo := flag.String("patterns-repo", envOrDefault("PATTERNS_REPO", ""), "Repo with language patterns (e.g. rodin/elixir-patterns)")
-	patternsFiles := flag.String("patterns-files", envOrDefault("PATTERNS_FILES", "README.md"), "Comma-separated file paths to fetch from patterns repo")
+	patternsFiles := flag.String("patterns-files", envOrDefault("PATTERNS_FILES", ""), "Comma-separated file paths to fetch from patterns repo (empty = all files)")
 	dryRun := flag.Bool("dry-run", false, "Print review to stdout instead of posting")
 	llmTemp := flag.Float64("llm-temperature", envOrDefaultFloat("LLM_TEMPERATURE", 0), "LLM temperature (0 = server default)")
 	llmTimeout := flag.Int("llm-timeout", envOrDefaultInt("LLM_TIMEOUT", 300), "LLM request timeout in seconds (default 300)")
@@ -84,9 +85,16 @@ func main() {
 	aicoreAPIURL := flag.String("aicore-api-url", envOrDefault("AICORE_API_URL", ""), "SAP AI Core API URL (for provider=aicore)")
 	aicoreResourceGroup := flag.String("aicore-resource-group", envOrDefault("AICORE_RESOURCE_GROUP", "default"), "SAP AI Core resource group (for provider=aicore)")
 
-	// Backward-compatible alias: --gitea-url shares vcsURL's pointer (last flag wins).
+	// Register --gitea-url as a backward-compatible alias for --vcs-url.
-	// Must use *vcsURL as default: StringVar sets *p=value at registration, so empty
+	// StringVar shares the *string pointer with vcsURL, so whichever flag is
-	// string would overwrite the env-resolved value from the --vcs-url declaration.
+	// set last by flag.Parse wins — both point to the same underlying value.
+	// NOTE: If a user passes both --vcs-url and --gitea-url, the last one on
+	// the command line takes effect (standard flag package behavior). This is
+	// acceptable since --gitea-url is deprecated and both serve the same purpose.
+	//
+	// ORDERING: This must remain AFTER vcsURL's flag.String declaration and BEFORE
+	// flag.Parse(). The *vcsURL dereference captures the env-var-resolved default
+	// at registration time; moving flag.Parse() above this line would break it.
 	flag.StringVar(vcsURL, "gitea-url", *vcsURL, "Deprecated: use --vcs-url instead")
 
 	flag.Parse()
@@ -102,8 +110,10 @@ func main() {
 	slog.Info("review-bot starting", "version", version)
 
 	// Validate VCS provider
-	vcsProvider := vcs.VCSProvider(*provider)
+	switch *provider {
-	if !vcsProvider.Valid() {
+	case "gitea", "github":
+		// valid
+	default:
 		fmt.Fprintf(os.Stderr, "Error: invalid --provider %q (valid: gitea, github)\n", *provider)
 		os.Exit(1)
 	}
@@ -116,7 +126,7 @@ func main() {
 		os.Exit(1)
 	}
 	// --vcs-url is required only for gitea provider
-	if vcsProvider == vcs.ProviderGitea && *vcsURL == "" {
+	if *provider == "gitea" && *vcsURL == "" {
 		fmt.Fprintf(os.Stderr, "Error: --vcs-url (or --gitea-url) is required for provider=gitea\n")
 		os.Exit(1)
 	}
@@ -159,16 +169,21 @@ func main() {
 
 	// Initialize VCS client
 	var client vcs.Client
-	switch vcsProvider {
+	switch *provider {
-	case vcs.ProviderGitea:
+	case "gitea":
 		giteaClient := gitea.NewClient(*vcsURL, *reviewerToken)
 		client = gitea.NewAdapter(giteaClient)
-	case vcs.ProviderGitHub:
+	case "github":
-		client = github.NewClient(*reviewerToken, *baseURL)
+		ghBaseURL := *baseURL
-	default:
+		if ghBaseURL == "" {
-		panic("unreachable: provider validation should have caught " + vcsProvider.String())
+			ghBaseURL = "https://api.github.com"
 		}
-	slog.Info("VCS client initialized", "provider", vcsProvider)
+		client = github.NewClient(*reviewerToken, ghBaseURL)
+	default:
+		fmt.Fprintf(os.Stderr, "Error: unhandled provider %q\n", *provider)
+		os.Exit(1)
+	}
+	slog.Info("VCS client initialized", "provider", *provider)
 
 	// Initialize LLM client
 	llmClient := llm.NewClient(*llmBaseURL, *llmAPIKey, *llmModel)
@@ -417,7 +432,7 @@ func main() {
 		currentSHA = currentPR.Head.SHA
 	}
 	if shouldSkipStaleReview(evaluatedSHA, currentSHA) {
-		slog.Warn("HEAD moved during review -- skipping stale review",
+		slog.Warn("HEAD moved during review — skipping stale review",
 			"evaluated", evaluatedSHA,
 			"current", currentSHA,
 			"pr", prNumber)
@@ -439,7 +454,7 @@ func main() {
 		inlineComments = append(inlineComments, vcs.ReviewComment{
 			Path:     f.File,
 			Position: pos,
-			CommitID: evaluatedSHA,
+			CommitID: pr.Head.SHA,
 			Body:     fmt.Sprintf("**[%s]** %s", f.Severity, f.Finding),
 		})
 	}
@@ -465,12 +480,12 @@ func main() {
 	}
 
 	// Self-request as reviewer (Gitea-specific; ensures we appear in required-reviewer checks)
-	if selfReq, ok := client.(vcs.ReviewerSelfRequester); ok {
+	if giteaAdapter, ok := client.(*gitea.Adapter); ok {
 		authUser, err := client.GetAuthenticatedUser(ctx)
 		if err != nil {
 			slog.Warn("could not determine authenticated user for reviewer self-request", "error", err)
 		} else if authUser != "" {
-			if err := selfReq.RequestReviewerSelf(ctx, owner, repoName, prNumber, authUser); err != nil {
+			if err := giteaAdapter.Underlying().RequestReviewer(ctx, owner, repoName, prNumber, authUser); err != nil {
 				slog.Warn("could not self-request as reviewer", "user", authUser, "error", err)
 			} else {
 				slog.Debug("self-requested as reviewer", "user", authUser, "pr", prNumber)
@@ -485,7 +500,6 @@ func main() {
 	reviewReq := vcs.ReviewRequest{
 		Body:     reviewBody,
 		Event:    event,
-		CommitID: evaluatedSHA,
 		Comments: inlineComments,
 	}
 	posted, err := client.PostReview(ctx, owner, repoName, prNumber, reviewReq)
@@ -495,16 +509,12 @@ func main() {
 	}
 	slog.Info("review posted", "review_id", posted.ID, "user", posted.User.Login, "pr", prNumber)
 
-	// Supersede all old reviews via optional interface
+	// Supersede all old reviews
 	if len(oldReviews) > 0 {
-		if superseder, ok := client.(vcs.ReviewSuperseder); ok {
+		if err := supersedeOldReviews(ctx, client, *provider, *vcsURL, owner, repoName, prNumber, oldReviews, posted.ID, sentinel); err != nil {
-			if err := superseder.SupersedeReviews(ctx, owner, repoName, prNumber, oldReviews, posted.ID, *vcsURL, sentinel); err != nil {
 			slog.Error("failed to supersede old reviews", "error", err)
 			os.Exit(1)
 		}
-		} else {
-			slog.Error("provider does not support review superseding", "provider", vcsProvider)
-		}
 	}
 }
 
@@ -520,6 +530,84 @@ func verdictToEvent(verdict string) vcs.ReviewEvent {
 	}
 }
 
+// supersedeOldReviews marks prior reviews as superseded so only the latest review is visible.
+// For GitHub: dismisses old reviews (vcsURL is unused in this path).
+// For Gitea: edits the review body with a link to the new review and resolves inline comments.
+//
+// The vcsURL parameter is only used in the Gitea path to construct review permalink URLs;
+// it is accepted unconditionally to keep the function signature uniform across providers.
+func supersedeOldReviews(ctx context.Context, client vcs.Client, provider, vcsURL, owner, repoName string, prNumber int, oldReviews []vcs.Review, newReviewID int64, sentinel string) error {
+	switch provider {
+	case "github":
+		// Best-effort dismissal: attempt all reviews, join any errors.
+		var errs []error
+		for _, old := range oldReviews {
+			if err := client.DismissReview(ctx, owner, repoName, prNumber, old.ID, "Superseded by new review"); err != nil {
+				slog.Warn("failed to dismiss review", "id", old.ID, "error", err)
+				errs = append(errs, fmt.Errorf("dismiss review %d: %w", old.ID, err))
+			} else {
+				slog.Info("dismissed old review", "review_id", old.ID, "new_review_id", newReviewID, "pr", prNumber)
+			}
+		}
+		return errors.Join(errs...)
+	case "gitea":
+		// Continue to Gitea-specific logic below the switch.
+	default:
+		return fmt.Errorf("supersedeOldReviews: unsupported provider %q", provider)
+	}
+
+	// The type assertion below is guaranteed to succeed: the caller's provider switch
+	// ensures we only reach this point when provider == "gitea", and the gitea provider
+	// always constructs a *gitea.Adapter. The !ok branch guards against future refactors
+	// (e.g. wrapping the adapter in a decorator) that would silently break this path.
+	giteaAdapter, ok := client.(*gitea.Adapter)
+	if !ok {
+		return fmt.Errorf("expected gitea.Adapter for gitea provider, got %T", client)
+	}
+	underlying := giteaAdapter.Underlying()
+
+	newReviewURL := fmt.Sprintf("%s/%s/%s/pulls/%d#pullrequestreview-%d", strings.TrimRight(vcsURL, "/"), owner, repoName, prNumber, newReviewID)
+	for _, oldReview := range oldReviews {
+		cid, err := underlying.GetTimelineReviewCommentIDForReview(ctx, owner, repoName, prNumber, oldReview.ID)
+		if err != nil {
+			slog.Warn("could not find comment ID for old review", "review_id", oldReview.ID, "error", err)
+			continue
+		}
+		supersededBody := buildSupersededBody(oldReview.Body, oldReview.CommitID, newReviewURL, sentinel)
+		if err := underlying.EditComment(ctx, owner, repoName, cid, supersededBody); err != nil {
+			slog.Warn("could not mark old review as superseded", "review_id", oldReview.ID, "comment_id", cid, "error", err)
+			continue
+		}
+		slog.Info("marked old review as superseded", "review_id", oldReview.ID, "new_review_id", newReviewID, "pr", prNumber)
+
+		// Resolve old review's inline comments
+		oldComments, err := underlying.ListReviewComments(ctx, owner, repoName, prNumber, oldReview.ID)
+		if err != nil {
+			slog.Warn("could not list old review comments for resolution", "review_id", oldReview.ID, "error", err)
+			continue
+		}
+		resolved, failed := 0, 0
+		for _, c := range oldComments {
+			if c.ID == 0 {
+				continue
+			}
+			if err := underlying.ResolveComment(ctx, owner, repoName, c.ID); err != nil {
+				slog.Debug("could not resolve inline comment", "comment_id", c.ID, "error", err)
+				failed++
+			} else {
+				resolved++
+			}
+		}
+		if resolved > 0 {
+			slog.Info("resolved old inline comments", "review_id", oldReview.ID, "count", resolved, "pr", prNumber)
+		}
+		if failed > 0 {
+			slog.Warn("some inline comments could not be resolved", "review_id", oldReview.ID, "failed", failed, "pr", prNumber)
+		}
+	}
+	return nil
+}
+
 // fetchFileContext fetches the full content of modified files from the PR branch.
 func fetchFileContext(ctx context.Context, client vcs.PRReader, owner, repo, ref string, files []vcs.ChangedFile) string {
 	var sb strings.Builder
@@ -547,12 +635,25 @@ func fetchFileContext(ctx context.Context, client vcs.PRReader, owner, repo, ref
 // patternsRepo is comma-separated list of owner/name repos.
 // patternsFiles is comma-separated list of file paths or directories.
 // If a path ends with / or is a directory, all files within it are fetched recursively.
-// Empty entries in patternsFiles are skipped (no implicit repo-root fetch).
+// If patternsFiles is empty, all files from the repo root are fetched.
 func fetchPatterns(ctx context.Context, client vcs.FileReader, patternsRepo, patternsFiles string) string {
 	var sb strings.Builder
 
 	repos := strings.Split(patternsRepo, ",")
-	paths := strings.Split(patternsFiles, ",")
+
+	// Build the list of paths to fetch
+	var paths []string
+	if patternsFiles == "" {
+		// Empty patternsFiles means "fetch all files from repo root"
+		paths = []string{""}
+	} else {
+		for _, p := range strings.Split(patternsFiles, ",") {
+			p = strings.TrimSpace(p)
+			if p != "" {
+				paths = append(paths, p)
+			}
+		}
+	}
 
 	for _, repoRef := range repos {
 		if ctx.Err() != nil {
@@ -573,11 +674,6 @@ func fetchPatterns(ctx context.Context, client vcs.FileReader, patternsRepo, pat
 		var repoSkippedFiles []string
 
 		for _, path := range paths {
-			path = strings.TrimSpace(path)
-			if path == "" {
-				continue
-			}
-
 			files, err := vcs.GetAllFilesInPath(ctx, client, owner, repo, path)
 			if err != nil {
 				slog.Warn("could not fetch patterns", "path", path, "repo", repoRef, "error", err)
@@ -672,6 +768,14 @@ func envOrDefaultInt(key string, defaultVal int) int {
 	return defaultVal
 }
 
+func envOrDefaultBool(key string, defaultVal bool) bool {
+	v := strings.TrimSpace(strings.ToLower(os.Getenv(key)))
+	if v == "" {
+		return defaultVal
+	}
+	return v == "true" || v == "1" || v == "yes"
+}
+
 // validateReviewerName checks that the name contains only safe characters
 // for embedding in an HTML comment sentinel ([a-zA-Z0-9_-]).
 func validateReviewerName(name string) error {
@@ -723,6 +827,31 @@ func validateWorkspacePath(path, pathName string) (string, error) {
 	return resolvedPath, nil
 }
 
+// buildSupersededBody creates the body for a superseded review: struck-through banner
+// with collapsed original content and the commit it was evaluated against.
+func buildSupersededBody(originalBody, commitSHA, newReviewURL, sentinel string) string {
+	shortSHA := commitSHA
+	if len(shortSHA) > 8 {
+		shortSHA = shortSHA[:8]
+	}
+	var sb strings.Builder
+	sb.WriteString("~~Original review~~\n\n")
+	sb.WriteString("**Superseded** \u2014 [see current review](")
+	sb.WriteString(newReviewURL)
+	sb.WriteString(") for up-to-date findings.\n\n")
+	if shortSHA != "" {
+		sb.WriteString("<details><summary>Previous findings (commit ")
+		sb.WriteString(shortSHA)
+		sb.WriteString(")</summary>\n\n")
+	} else {
+		sb.WriteString("<details><summary>Previous findings</summary>\n\n")
+	}
+	sb.WriteString(originalBody)
+	sb.WriteString("\n\n</details>\n\n")
+	sb.WriteString(sentinel)
+	return sb.String()
+}
+
 // hasSharedToken detects if another review-bot role posted under the same
 // VCS user. This indicates misconfiguration where two roles share a token
 // instead of having separate accounts. Returns true if shared token
@@ -740,7 +869,7 @@ func hasSharedToken(reviews []vcs.Review, ownSentinel string) bool {
 	}
 	for _, r := range reviews {
 		if r.User.Login == ownLogin && strings.Contains(r.Body, "<!-- review-bot:") && !strings.Contains(r.Body, ownSentinel) {
-			slog.Warn("shared token detected -- another review-bot role is using the same VCS user",
+			slog.Warn("shared token detected — another review-bot role is using the same VCS user",
 				"sibling_role", extractSentinelName(r.Body), "user", ownLogin)
 			return true
 		}
@@ -778,6 +907,7 @@ func extractSentinelName(body string) string {
 	return name
 }
 
+
 // findAllOwnReviews returns all non-superseded reviews matching the sentinel.
 func findAllOwnReviews(reviews []vcs.Review, sentinel string) []vcs.Review {
 	var result []vcs.Review

cmd/review-bot/main_test.go

@@ -162,6 +162,55 @@ func makeReview(id int64, login, state string, stale bool, body string) vcs.Revi
 	}
 }
 
+func TestBuildSupersededBody(t *testing.T) {
+	original := "# Review\n\nLooks good.\n\n<!-- review-bot:sonnet -->"
+	sentinel := "<!-- review-bot:sonnet -->"
+	newURL := "https://gitea.example.com/owner/repo/pulls/1#pullrequestreview-99"
+
+	result := buildSupersededBody(original, "abcdef1234567890", newURL, sentinel)
+
+	// Should contain the struck-through banner
+	if !strings.Contains(result, "~~Original review~~") {
+		t.Error("missing struck-through banner")
+	}
+	// Should contain superseded notice with link
+	if !strings.Contains(result, "**Superseded**") {
+		t.Error("missing superseded notice")
+	}
+	if !strings.Contains(result, "[see current review]("+newURL+")") {
+		t.Error("missing link to new review")
+	}
+	// Should contain collapsed original
+	if !strings.Contains(result, "<details>") {
+		t.Error("missing details/collapse")
+	}
+	// Should contain short commit SHA
+	if !strings.Contains(result, "abcdef12") {
+		t.Error("missing short SHA")
+	}
+	// Should NOT contain full SHA
+	if strings.Contains(result, "abcdef1234567890") {
+		t.Error("should truncate SHA to 8 chars")
+	}
+	// Should contain the original body inside details
+	if !strings.Contains(result, original) {
+		t.Error("original body not preserved in collapsed section")
+	}
+	// Should end with sentinel
+	if !strings.Contains(result, sentinel) {
+		t.Error("missing sentinel")
+	}
+}
+
+func TestBuildSupersededBodyShortSHA(t *testing.T) {
+	// Short SHA should pass through without panic
+	result := buildSupersededBody("body", "abc", "https://example.com/review", "<!-- review-bot:x -->")
+	if !strings.Contains(result, "abc") {
+		t.Error("short SHA not preserved")
+	}
+}
+
+
 func TestHasSharedToken(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -367,6 +416,52 @@ func TestIsPatternFile(t *testing.T) {
 	}
 }
 
+// TestBuildPatternPaths verifies the path-building logic for fetchPatterns.
+// Empty patternsFiles means "fetch all from root" (represented as [""]).
+func TestBuildPatternPaths(t *testing.T) {
+	buildPaths := func(patternsFiles string) []string {
+		if patternsFiles == "" {
+			return []string{""}
+		}
+		var paths []string
+		for _, p := range strings.Split(patternsFiles, ",") {
+			p = strings.TrimSpace(p)
+			if p != "" {
+				paths = append(paths, p)
+			}
+		}
+		return paths
+	}
+
+	tests := []struct {
+		name  string
+		input string
+		want  []string
+	}{
+		{"empty fetches root", "", []string{""}},
+		{"single file", "README.md", []string{"README.md"}},
+		{"multiple files", "README.md,PATTERNS.md", []string{"README.md", "PATTERNS.md"}},
+		{"trims whitespace", " foo.md , bar.md ", []string{"foo.md", "bar.md"}},
+		{"skips empty between commas", "foo.md,,bar.md", []string{"foo.md", "bar.md"}},
+		{"directory path", "patterns/", []string{"patterns/"}},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := buildPaths(tc.input)
+			if len(got) != len(tc.want) {
+				t.Errorf("buildPaths(%q) = %v, want %v", tc.input, got, tc.want)
+				return
+			}
+			for i := range got {
+				if got[i] != tc.want[i] {
+					t.Errorf("buildPaths(%q)[%d] = %q, want %q", tc.input, i, got[i], tc.want[i])
+				}
+			}
+		})
+	}
+}
+
 func TestEvaluateCIStatus(t *testing.T) {
 	tests := []struct {
 		name       string
@@ -548,6 +643,47 @@ func TestEnvOrDefaultInt(t *testing.T) {
 	}
 }
 
+func TestEnvOrDefaultBool(t *testing.T) {
+	tests := []struct {
+		name       string
+		envVal     string
+		setEnv     bool
+		defaultVal bool
+		want       bool
+	}{
+		{"unset returns default true", "", false, true, true},
+		{"unset returns default false", "", false, false, false},
+		{"true", "true", true, false, true},
+		{"TRUE", "TRUE", true, false, true},
+		{"True", "True", true, false, true},
+		{"1", "1", true, false, true},
+		{"yes", "yes", true, false, true},
+		{"YES", "YES", true, false, true},
+		{"false", "false", true, true, false},
+		{"0", "0", true, true, false},
+		{"no", "no", true, true, false},
+		{"random string", "random", true, true, false},
+		{"empty string returns default", "", true, true, true},
+		{"whitespace true", "  true  ", true, false, true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			envKey := "TEST_ENV_BOOL_" + strings.ReplaceAll(tc.name, " ", "_")
+			if tc.setEnv {
+				os.Setenv(envKey, tc.envVal)
+				defer os.Unsetenv(envKey)
+			} else {
+				os.Unsetenv(envKey)
+			}
+			got := envOrDefaultBool(envKey, tc.defaultVal)
+			if got != tc.want {
+				t.Errorf("envOrDefaultBool(%q, %v) = %v, want %v", tc.envVal, tc.defaultVal, got, tc.want)
+			}
+		})
+	}
+}
+
 func TestExtractSentinelName_EdgeCases(t *testing.T) {
 	tests := []struct {
 		body string

docs/DESIGN-57-yaml-persona.md

@@ -9,7 +9,7 @@ JSON is awkward for persona files that contain multi-line text (identity, severi
 - Backwards compatibility: existing JSON personas must continue to work
 - Security: protect against DoS via deeply nested YAML (AIKIDO-2024-10486)
 - Consistency: use `.yaml` extension (not `.yml`)
-- Library: use `gopkg.in/yaml.v3` (approved in CONVENTIONS.md) with explicit depth limiting
+- Library: use `github.com/goccy/go-yaml` v1.16.0+ (approved in CONVENTIONS.md); we implement custom AST-based depth/node-count checks for precise alias-aware validation
 
 ## Proposed Approach
 
@@ -33,37 +33,16 @@ func parsePersona(data []byte, source string) (*Persona, error) {
 
 ### YAML Parsing with Depth Protection
 
-```go
+We implement a custom AST-based depth/node-count walk (`checkYAMLDepth` in
-func unmarshalYAMLWithDepthLimit(data []byte, out any, maxDepth int) error {
+`review/persona.go`) rather than relying on library decoder options. Key design
-    var node yaml.Node
+decisions:
-    dec := yaml.NewDecoder(bytes.NewReader(data))
-    if err := dec.Decode(&node); err != nil {
-        return err
-    }
-    if err := checkYAMLDepth(&node, 0, maxDepth); err != nil {
-        return err
-    }
-    return node.Decode(out)
-}
 
-func checkYAMLDepth(node *yaml.Node, depth, maxDepth int) error {
+- **Library:** `github.com/goccy/go-yaml` with `ast.Node`-based traversal
-    if depth > maxDepth {
+- **Dual-map tracking:** `validated` (depth-aware short-circuit) + `visiting` (cycle detection)
-        return fmt.Errorf("YAML nesting depth exceeds maximum (%d)", maxDepth)
+- **Node-count limit:** Conservative overcounting bounds total validation work
-    }
+- **Alias-aware depth:** Aliases increment depth and are re-checked when encountered at greater depths
-    // Handle alias nodes by following the Alias pointer
-    if node.Kind == yaml.AliasNode && node.Alias != nil {
-        return checkYAMLDepth(node.Alias, depth, maxDepth)
-    }
-    for _, child := range node.Content {
-        if err := checkYAMLDepth(child, depth+1, maxDepth); err != nil {
-            return err
-        }
-    }
-    return nil
-}
-```
 
-The `gopkg.in/yaml.v3` library does not have built-in depth protection, so we implement explicit depth checking by first decoding into a `yaml.Node`, walking the tree to verify depth (including alias resolution), then decoding into the target struct.
+See `review/persona.go:checkYAMLDepth` for the authoritative implementation.
 
 ## State/Data Model
 
@@ -74,7 +53,7 @@ No new state. Same `Persona` struct, just different parsing.
 | Error | Handling |
 |-------|----------|
 | Invalid YAML syntax | Return parse error with source file |
-| Deeply nested YAML | Library rejects (v1.16.0+ fix) |
+| Deeply nested YAML | Custom AST walk (`checkYAMLDepth`) rejects before decode |
 | Unknown extension | Fall back to JSON parsing |
 | Missing required fields | Validation rejects after parse |
 

gitea/adapter.go

@@ -3,8 +3,6 @@ package gitea
 import (
 	"context"
 	"fmt"
-	"log/slog"
-	"strings"
 
 	"gitea.weiker.me/rodin/review-bot/vcs"
 )
@@ -18,7 +16,6 @@ type Adapter struct {
 
 // Compile-time interface conformance assertion.
 var _ vcs.Client = (*Adapter)(nil)
-var _ vcs.ReviewerSelfRequester = (*Adapter)(nil)
 
 // NewAdapter creates a new Adapter wrapping the given gitea Client.
 func NewAdapter(client *Client) *Adapter {
@@ -170,9 +167,9 @@ func (a *Adapter) PostReview(ctx context.Context, owner, repo string, number int
 			if err != nil {
 				return nil, fmt.Errorf("translate position %d in %s: %w", c.Position, c.Path, err)
 			}
-			// Per-comment CommitID is not forwarded to Gitea inline comments:
+			// CommitID from vcs.ReviewComment is intentionally not forwarded:
-			// Gitea's CreatePullReview API has no per-comment commit_id field.
+			// Gitea review comments are pinned to the PR head SHA automatically,
-			// The review-level commit anchor is set via req.CommitID instead.
+			// and the CreatePullReview API has no per-comment commit_id field.
 			giteaComments = append(giteaComments, ReviewComment{
 				Path:        c.Path,
 				NewPosition: int64(lineNum),
@@ -181,7 +178,7 @@ func (a *Adapter) PostReview(ctx context.Context, owner, repo string, number int
 		}
 	}
 
-	review, err := a.client.PostReview(ctx, owner, repo, number, event, req.Body, req.CommitID, giteaComments)
+	review, err := a.client.PostReview(ctx, owner, repo, number, event, req.Body, giteaComments)
 	if err != nil {
 		return nil, fmt.Errorf("post review: %w", err)
 	}
@@ -233,84 +230,3 @@ func (a *Adapter) DismissReview(ctx context.Context, owner, repo string, number
 func (a *Adapter) GetAuthenticatedUser(ctx context.Context) (string, error) {
 	return a.client.GetAuthenticatedUser(ctx)
 }
-
-// RequestReviewerSelf adds the given user as a requested reviewer on a pull request.
-// This implements vcs.ReviewerSelfRequester for the Gitea adapter.
-func (a *Adapter) RequestReviewerSelf(ctx context.Context, owner, repo string, number int, user string) error {
-	return a.client.RequestReviewer(ctx, owner, repo, number, user)
-}
-
-// Compile-time interface conformance assertion for ReviewSuperseder.
-var _ vcs.ReviewSuperseder = (*Adapter)(nil)
-
-// SupersedeReviews marks prior reviews as superseded by editing their body with a
-// link to the new review and resolving their inline comments. This is Gitea-specific
-// behavior that has no GitHub equivalent (GitHub uses DismissReview instead).
-//
-// baseURL is the Gitea instance URL used to construct review permalink URLs.
-// sentinel is the HTML comment sentinel that identifies reviews belonging to this reviewer.
-func (a *Adapter) SupersedeReviews(ctx context.Context, owner, repo string, prNumber int, oldReviews []vcs.Review, newReviewID int64, baseURL, sentinel string) error {
-	// Validate baseURL scheme before embedding in Markdown link (defense-in-depth).
-	if !strings.HasPrefix(baseURL, "http://") && !strings.HasPrefix(baseURL, "https://") {
-		return fmt.Errorf("SupersedeReviews: baseURL must have http or https scheme, got %q", baseURL)
-	}
-
-	underlying := a.client
-
-	newReviewURL := fmt.Sprintf("%s/%s/%s/pulls/%d#pullrequestreview-%d",
-		strings.TrimRight(baseURL, "/"), owner, repo, prNumber, newReviewID)
-
-	for _, oldReview := range oldReviews {
-		cid, err := underlying.GetTimelineReviewCommentIDForReview(ctx, owner, repo, prNumber, oldReview.ID)
-		if err != nil {
-			slog.Warn("could not find comment ID for old review", "review_id", oldReview.ID, "error", err)
-			continue
-		}
-		supersededBody := buildSupersededBody(oldReview.Body, oldReview.CommitID, newReviewURL, sentinel)
-		if err := underlying.EditComment(ctx, owner, repo, cid, supersededBody); err != nil {
-			slog.Warn("could not mark old review as superseded", "review_id", oldReview.ID, "error", err)
-			continue
-		}
-
-		// Resolve old review's inline comments
-		oldComments, err := underlying.ListReviewComments(ctx, owner, repo, prNumber, oldReview.ID)
-		if err != nil {
-			slog.Warn("could not list old review comments for resolution", "review_id", oldReview.ID, "error", err)
-			continue
-		}
-		for _, c := range oldComments {
-			if c.ID == 0 {
-				continue
-			}
-			if err := underlying.ResolveComment(ctx, owner, repo, c.ID); err != nil {
-				slog.Debug("could not resolve inline comment", "comment_id", c.ID, "error", err)
-			}
-		}
-	}
-	return nil
-}
-
-// buildSupersededBody creates the body for a superseded review: struck-through banner
-// with collapsed original content and the commit it was evaluated against.
-func buildSupersededBody(originalBody, commitSHA, newReviewURL, sentinel string) string {
-	shortSHA := commitSHA
-	if len(shortSHA) > 8 {
-		shortSHA = shortSHA[:8]
-	}
-	var sb strings.Builder
-	sb.WriteString("~~Original review~~\n\n")
-	sb.WriteString("**Superseded** \u2014 [see current review](")
-	sb.WriteString(newReviewURL)
-	sb.WriteString(") for up-to-date findings.\n\n")
-	if shortSHA != "" {
-		sb.WriteString("<details><summary>Previous findings (commit ")
-		sb.WriteString(shortSHA)
-		sb.WriteString(")</summary>\n\n")
-	} else {
-		sb.WriteString("<details><summary>Previous findings</summary>\n\n")
-	}
-	sb.WriteString(originalBody)
-	sb.WriteString("\n\n</details>\n\n")
-	sb.WriteString(sentinel)
-	return sb.String()
-}

gitea/adapter_test.go

@@ -386,95 +386,3 @@ func TestAdapter_GetFileContent_RefRouting(t *testing.T) {
 		t.Errorf("GetFileContent(ref=\"abc123\") = %q, want %q", got, "content-at-ref")
 	}
 }
-
-func TestAdapter_RequestReviewerSelf(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPost {
-			t.Errorf("expected POST, got %s", r.Method)
-		}
-		expected := "/api/v1/repos/owner/repo/pulls/5/requested_reviewers"
-		if r.URL.Path != expected {
-			t.Errorf("path = %q, want %q", r.URL.Path, expected)
-		}
-		w.WriteHeader(http.StatusCreated)
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	err := adapter.RequestReviewerSelf(context.Background(), "owner", "repo", 5, "bot-user")
-	if err != nil {
-		t.Fatalf("RequestReviewerSelf() error = %v", err)
-	}
-}
-
-func TestAdapter_PostReview_CommitID(t *testing.T) {
-	var gotPayload struct {
-		Body     string `json:"body"`
-		Event    string `json:"event"`
-		CommitID string `json:"commit_id"`
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewDecoder(r.Body).Decode(&gotPayload)
-		json.NewEncoder(w).Encode(map[string]any{
-			"id":        1,
-			"body":      "test",
-			"user":      map[string]any{"login": "bot"},
-			"commit_id": "abc123def456",
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	review, err := adapter.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-		Body:     "LGTM",
-		Event:    vcs.ReviewEventApprove,
-		CommitID: "abc123def456",
-		// No comments → no diff fetch needed
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if gotPayload.CommitID != "abc123def456" {
-		t.Errorf("commit_id = %q, want %q", gotPayload.CommitID, "abc123def456")
-	}
-	if review.CommitID != "abc123def456" {
-		t.Errorf("review.CommitID = %q, want %q", review.CommitID, "abc123def456")
-	}
-}
-
-func TestAdapter_PostReview_EmptyCommitID_Omitted(t *testing.T) {
-	var gotRawPayload map[string]any
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		json.NewDecoder(r.Body).Decode(&gotRawPayload)
-		json.NewEncoder(w).Encode(map[string]any{
-			"id":   1,
-			"body": "test",
-			"user": map[string]any{"login": "bot"},
-		})
-	}))
-	defer server.Close()
-
-	client := gitea.NewClient(server.URL, "token")
-	adapter := gitea.NewAdapter(client)
-
-	_, err := adapter.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-		Body:  "looks good",
-		Event: vcs.ReviewEventComment,
-		// CommitID intentionally empty
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	// With empty CommitID and omitempty tag, the field should not appear in JSON
-	if _, exists := gotRawPayload["commit_id"]; exists {
-		t.Errorf("commit_id should be omitted when empty, but was present: %v", gotRawPayload["commit_id"])
-	}
-}

gitea/client.go

@@ -186,22 +186,18 @@ func (c *Client) GetFileContentRef(ctx context.Context, owner, repo, filepath, r
 }
 
 // PostReview submits a review to a PR and returns the created review.
-// event should be one of "APPROVED", "REQUEST_CHANGES", or "COMMENT".
+// event should be "APPROVED" or "REQUEST_CHANGES".
-// commitID anchors the review to a specific commit SHA. If empty, Gitea
-// defaults to the current PR head.
 // comments are optional inline comments attached to specific lines.
-func (c *Client) PostReview(ctx context.Context, owner, repo string, number int, event, body, commitID string, comments []ReviewComment) (*Review, error) {
+func (c *Client) PostReview(ctx context.Context, owner, repo string, number int, event, body string, comments []ReviewComment) (*Review, error) {
 	reqURL := fmt.Sprintf("%s/api/v1/repos/%s/%s/pulls/%d/reviews", c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
 
 	payload := struct {
 		Body     string          `json:"body"`
 		Event    string          `json:"event"`
-		CommitID string          `json:"commit_id,omitempty"`
 		Comments []ReviewComment `json:"comments,omitempty"`
 	}{
 		Body:     body,
 		Event:    event,
-		CommitID: commitID,
 		Comments: comments,
 	}
 

gitea/client_test.go

@@ -135,7 +135,7 @@ func TestPostReview(t *testing.T) {
 	defer server.Close()
 
 	client := NewClient(server.URL, "test-token")
-	review, err := client.PostReview(context.Background(), "owner", "repo", 3, "APPROVED", "LGTM", "", nil)
+	review, err := client.PostReview(context.Background(), "owner", "repo", 3, "APPROVED", "LGTM", nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -147,46 +147,6 @@ func TestPostReview(t *testing.T) {
 	}
 }
 
-func TestPostReview_CommitID(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != "POST" {
-			t.Fatalf("expected POST, got %s", r.Method)
-		}
-
-		body, _ := io.ReadAll(r.Body)
-		var payload struct {
-			Body     string `json:"body"`
-			Event    string `json:"event"`
-			CommitID string `json:"commit_id"`
-		}
-		if err := json.Unmarshal(body, &payload); err != nil {
-			t.Fatalf("unmarshal payload: %v", err)
-		}
-		if payload.CommitID != "deadbeef123" {
-			t.Errorf("expected commit_id %q, got %q", "deadbeef123", payload.CommitID)
-		}
-		if payload.Event != "APPROVED" {
-			t.Errorf("expected event APPROVED, got %q", payload.Event)
-		}
-
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(`{"id":101,"user":{"login":"review-bot"},"state":"APPROVED","stale":false,"commit_id":"deadbeef123"}`))
-	}))
-	defer server.Close()
-
-	client := NewClient(server.URL, "test-token")
-	review, err := client.PostReview(context.Background(), "owner", "repo", 3, "APPROVED", "LGTM", "deadbeef123", nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if review.ID != 101 {
-		t.Errorf("expected review ID 101, got %d", review.ID)
-	}
-	if review.CommitID != "deadbeef123" {
-		t.Errorf("expected commit_id %q, got %q", "deadbeef123", review.CommitID)
-	}
-}
-
 func TestGetPullRequest_Non200(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNotFound)
@@ -222,7 +182,7 @@ func TestPostReview_Non200(t *testing.T) {
 	defer server.Close()
 
 	client := NewClient(server.URL, "test-token")
-	_, err := client.PostReview(context.Background(), "owner", "repo", 1, "APPROVED", "test", "", nil)
+	_, err := client.PostReview(context.Background(), "owner", "repo", 1, "APPROVED", "test", nil)
 	if err == nil {
 		t.Fatal("expected error for 403, got nil")
 	}
@@ -1184,62 +1144,3 @@ func TestSanitizeErrorForLog(t *testing.T) {
 		})
 	}
 }
-
-func TestPostReview_CommitID_InPayload(t *testing.T) {
-	var gotPayload struct {
-		Body     string `json:"body"`
-		Event    string `json:"event"`
-		CommitID string `json:"commit_id"`
-	}
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		json.NewDecoder(r.Body).Decode(&gotPayload)
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(200)
-		json.NewEncoder(w).Encode(map[string]any{
-			"id":        200,
-			"body":      "LGTM",
-			"user":      map[string]any{"login": "bot"},
-			"state":     "APPROVED",
-			"commit_id": "deadbeef1234",
-		})
-	}))
-	defer server.Close()
-
-	client := NewClient(server.URL, "test-token")
-	review, err := client.PostReview(context.Background(), "owner", "repo", 5, "APPROVED", "LGTM", "deadbeef1234", nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if gotPayload.CommitID != "deadbeef1234" {
-		t.Errorf("sent commit_id = %q, want %q", gotPayload.CommitID, "deadbeef1234")
-	}
-	if review.CommitID != "deadbeef1234" {
-		t.Errorf("response commit_id = %q, want %q", review.CommitID, "deadbeef1234")
-	}
-}
-
-func TestPostReview_EmptyCommitID_OmittedFromPayload(t *testing.T) {
-	var gotRaw map[string]any
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		json.NewDecoder(r.Body).Decode(&gotRaw)
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(200)
-		json.NewEncoder(w).Encode(map[string]any{
-			"id":   201,
-			"body": "ok",
-			"user": map[string]any{"login": "bot"},
-		})
-	}))
-	defer server.Close()
-
-	client := NewClient(server.URL, "test-token")
-	_, err := client.PostReview(context.Background(), "owner", "repo", 5, "COMMENT", "ok", "", nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if _, exists := gotRaw["commit_id"]; exists {
-		t.Errorf("commit_id should be omitted when empty, but was present: %v", gotRaw["commit_id"])
-	}
-}

gitea/post_review_comments_test.go

@@ -37,7 +37,7 @@ func TestPostReview_WithComments(t *testing.T) {
 		{Path: "util.go", NewPosition: 10, Body: "[MINOR] Style issue"},
 	}
 
-	_, err := client.PostReview(context.Background(), "owner", "repo", 1, "REQUEST_CHANGES", "summary", "", comments)
+	_, err := client.PostReview(context.Background(), "owner", "repo", 1, "REQUEST_CHANGES", "summary", comments)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -72,7 +72,7 @@ func TestPostReview_NilComments(t *testing.T) {
 	defer server.Close()
 
 	client := NewClient(server.URL, "test-token")
-	_, err := client.PostReview(context.Background(), "owner", "repo", 1, "APPROVED", "all good", "", nil)
+	_, err := client.PostReview(context.Background(), "owner", "repo", 1, "APPROVED", "all good", nil)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

gitea/supersede_test.go

@@ -1,54 +0,0 @@
-package gitea
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestBuildSupersededBody(t *testing.T) {
-	original := "# Review\n\nLooks good.\n\n<!-- review-bot:sonnet -->"
-	sentinel := "<!-- review-bot:sonnet -->"
-	newURL := "https://gitea.example.com/owner/repo/pulls/1#pullrequestreview-99"
-
-	result := buildSupersededBody(original, "abcdef1234567890", newURL, sentinel)
-
-	// Should contain the struck-through banner
-	if !strings.Contains(result, "~~Original review~~") {
-		t.Error("missing struck-through banner")
-	}
-	// Should contain superseded notice with link
-	if !strings.Contains(result, "**Superseded**") {
-		t.Error("missing superseded notice")
-	}
-	if !strings.Contains(result, "[see current review]("+newURL+")") {
-		t.Error("missing link to new review")
-	}
-	// Should contain collapsed original
-	if !strings.Contains(result, "<details>") {
-		t.Error("missing details/collapse")
-	}
-	// Should contain short commit SHA
-	if !strings.Contains(result, "abcdef12") {
-		t.Error("missing short SHA")
-	}
-	// Should NOT contain full SHA in summary (it's truncated to 8)
-	if strings.Contains(result, "abcdef1234567890") {
-		t.Error("should truncate SHA to 8 chars")
-	}
-	// Should contain the original body inside details
-	if !strings.Contains(result, original) {
-		t.Error("original body not preserved in collapsed section")
-	}
-	// Should end with sentinel
-	if !strings.Contains(result, sentinel) {
-		t.Error("missing sentinel")
-	}
-}
-
-func TestBuildSupersededBodyShortSHA(t *testing.T) {
-	// Short SHA should pass through without panic
-	result := buildSupersededBody("body", "abc", "https://example.com/review", "<!-- review-bot:x -->")
-	if !strings.Contains(result, "abc") {
-		t.Error("short SHA not preserved")
-	}
-}

github/client.go

@@ -110,11 +110,6 @@ type Client struct {
 	// retryBackoff[i] is the delay before attempt i+1 (after attempt i fails).
 	// If nil, defaults to {1s, 2s}. Set to shorter durations in tests via SetRetryBackoff.
 	retryBackoff []time.Duration
-
-	// reviewPageSize overrides reviewsPerPage for testing. Zero means use default.
-	reviewPageSize int
-	// reviewMaxPages overrides maxReviewPages for testing. Zero means use default.
-	reviewMaxPages int
 }
 
 // defaultCheckRedirect is the redirect policy used by NewClient and SetHTTPClient(nil).
@@ -199,13 +194,6 @@ func (c *Client) SetRetryBackoff(d []time.Duration) error {
 	return nil
 }
 
-// SetReviewPagination overrides the page size and max pages for ListReviews.
-// Intended for testing only; must be called before any goroutines issue requests.
-func (c *Client) SetReviewPagination(pageSize, maxPages int) {
-	c.reviewPageSize = pageSize
-	c.reviewMaxPages = maxPages
-}
-
 // requestOptions holds per-request configuration for doRequestCore.
 type requestOptions struct {
 	// bodyFn returns a fresh io.Reader for the request body on each attempt.
@@ -396,8 +384,8 @@ func (c *Client) doRequestWithBody(ctx context.Context, method, reqURL string, r
 		opts.extraHeaders = map[string]string{"Content-Type": "application/json"}
 	}
 	return c.doRequestCore(ctx, method, reqURL, opts)
-}
 
+}
 // doJSONRequest performs an HTTP request with a JSON body and returns the response body.
 // It delegates retry/backoff/429 handling to doRequestWithBody.
 // This is a general-purpose helper used by any method that needs to send JSON payloads

github/client_test.go

@@ -568,6 +568,7 @@ func TestSetHTTPClient_NilRestoresDefault(t *testing.T) {
 	}
 }
 
+
 func TestSetRetryBackoff_RejectsInvalidLength(t *testing.T) {
 	c := NewClient("token", "https://api.github.com")
 

github/conformance_test.go

@@ -9,6 +9,3 @@ import (
 // This verifies github.Client satisfies the full vcs.Client interface
 // (PRReader, FileReader, Reviewer, Identity).
 var _ vcs.Client = (*github.Client)(nil)
-
-// Verify github.Client implements ReviewSuperseder.
-var _ vcs.ReviewSuperseder = (*github.Client)(nil)

github/identity.go

@@ -0,0 +1,29 @@
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// userResponse is the GitHub API response for the authenticated user.
+type userResponse struct {
+	Login string `json:"login"`
+}
+
+// GetAuthenticatedUser returns the login of the currently authenticated user.
+func (c *Client) GetAuthenticatedUser(ctx context.Context) (string, error) {
+	reqURL := fmt.Sprintf("%s/user", c.baseURL)
+
+	body, err := c.doGet(ctx, reqURL)
+	if err != nil {
+		return "", fmt.Errorf("get authenticated user: %w", err)
+	}
+
+	var resp userResponse
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return "", fmt.Errorf("parse user response: %w", err)
+	}
+
+	return resp.Login, nil
+}

github/review.go

@@ -5,21 +5,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log/slog"
 	"net/http"
 	"net/url"
 
 	"gitea.weiker.me/rodin/review-bot/vcs"
 )
 
-const (
-	// reviewsPerPage is the number of reviews to fetch per API page.
-	reviewsPerPage = 100
-	// maxReviewPages is the maximum number of pages to paginate through
-	// when listing reviews. Acts as a safeguard against infinite pagination.
-	maxReviewPages = 100
-)
-
 // ErrCannotDeleteSubmittedReview is returned when DeleteReview is called on
 // a review that has already been submitted (APPROVED, REQUEST_CHANGES, COMMENT).
 // GitHub only allows deletion of PENDING reviews. Callers that need to replace
@@ -63,11 +54,6 @@ type dismissReviewRequest struct {
 	Event   string `json:"event"`
 }
 
-// userResponse is the GitHub API response for the authenticated user.
-type userResponse struct {
-	Login string `json:"login"`
-}
-
 // translateGitHubReviewState translates a GitHub API review state to the
 // canonical vcs.Review.State value.
 func translateGitHubReviewState(state string) string {
@@ -96,11 +82,9 @@ func translateGitHubReviewState(state string) string {
 // (via the omitempty tag on postReviewRequest.Comments).
 //
 // The GitHub API accepts a single commit_id per review submission. PostReview
-// uses req.CommitID as the primary commit anchor. If req.CommitID is empty,
+// extracts it from the first comment with a non-empty CommitID. If any subsequent
-// it falls back to extracting from the first comment with a non-empty CommitID.
+// comment specifies a different CommitID, PostReview returns ErrConflictingCommitIDs.
-// If any subsequent comment specifies a different CommitID, PostReview returns
+// Comments with an empty CommitID are allowed and inherit the review-level value.
-// ErrConflictingCommitIDs. Comments with an empty CommitID are allowed and
-// inherit the review-level value.
 func (c *Client) PostReview(ctx context.Context, owner, repo string, number int, req vcs.ReviewRequest) (*vcs.Review, error) {
 	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews",
 		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
@@ -108,21 +92,18 @@ func (c *Client) PostReview(ctx context.Context, owner, repo string, number int,
 	payload := postReviewRequest{
 		Body:  req.Body,
 		Event: string(req.Event),
-		CommitID: req.CommitID,
 	}
 
 	// Build the payload in one pass. The GitHub API accepts a single commit_id
-	// per review. req.CommitID is the primary source; if empty, we extract from
+	// per review; we extract it from the first comment that supplies one and
-	// the first comment that supplies one. Reject if any comment disagrees with
+	// reject the request if any other comment disagrees.
-	// the resolved commit_id.
 	for _, comment := range req.Comments {
 		if comment.CommitID != "" {
-			if payload.CommitID == "" { // only reachable when req.CommitID is empty
+			if payload.CommitID == "" {
 				payload.CommitID = comment.CommitID
 			} else if payload.CommitID != comment.CommitID {
 				return nil, ErrConflictingCommitIDs
 			}
-			// else: matching SHA is a no-op by design
 		}
 		payload.Comments = append(payload.Comments, reviewCommentEntry{
 			Path:     comment.Path,
@@ -131,7 +112,12 @@ func (c *Client) PostReview(ctx context.Context, owner, repo string, number int,
 		})
 	}
 
-	body, err := c.doJSONRequest(ctx, http.MethodPost, reqURL, payload)
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return nil, fmt.Errorf("marshal review request: %w", err)
+	}
+
+	body, err := c.doRequestWithBody(ctx, http.MethodPost, reqURL, data)
 	if err != nil {
 		return nil, fmt.Errorf("post review: %w", err)
 	}
@@ -150,28 +136,15 @@ func (c *Client) PostReview(ctx context.Context, owner, repo string, number int,
 	}, nil
 }
 
-// ListReviews retrieves all reviews for a pull request with pagination.
+// ListReviews retrieves all reviews for a pull request.
 // GitHub review states are translated to canonical vcs values.
 func (c *Client) ListReviews(ctx context.Context, owner, repo string, number int) ([]vcs.Review, error) {
-	perPage := reviewsPerPage
+	reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews",
-	if c.reviewPageSize > 0 {
+		c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number)
-		perPage = c.reviewPageSize
-	}
-	maxPages := maxReviewPages
-	if c.reviewMaxPages > 0 {
-		maxPages = c.reviewMaxPages
-	}
-
-	var allReviews []vcs.Review
-	truncated := false
-
-	for page := 1; page <= maxPages; page++ {
-		reqURL := fmt.Sprintf("%s/repos/%s/%s/pulls/%d/reviews?per_page=%d&page=%d",
-			c.baseURL, url.PathEscape(owner), url.PathEscape(repo), number, perPage, page)
 
 	body, err := c.doGet(ctx, reqURL)
 	if err != nil {
-			return nil, fmt.Errorf("list reviews page %d: %w", page, err)
+		return nil, fmt.Errorf("list reviews: %w", err)
 	}
 
 	var responses []reviewResponse
@@ -179,40 +152,17 @@ func (c *Client) ListReviews(ctx context.Context, owner, repo string, number int
 		return nil, fmt.Errorf("parse reviews response: %w", err)
 	}
 
-		if len(responses) == 0 {
+	reviews := make([]vcs.Review, len(responses))
-			break
+	for i, r := range responses {
-		}
+		reviews[i] = vcs.Review{
-
-		for _, r := range responses {
-			allReviews = append(allReviews, vcs.Review{
 			ID:       r.ID,
 			Body:     r.Body,
 			User:     vcs.UserInfo{Login: r.User.Login},
 			State:    translateGitHubReviewState(r.State),
 			CommitID: r.CommitID,
-			})
-		}
-
-		if len(responses) < perPage {
-			break
-		}
-
-		// Truncation detection: this runs on the final allowed iteration
-		// (page == maxPages) only when the page was full (the len < perPage
-		// early-break above didn't fire). A full final page means additional
-		// reviews likely exist beyond our pagination limit.
-		if page == maxPages {
-			truncated = true
 		}
 	}
-
+	return reviews, nil
-	if truncated {
-		slog.Warn("ListReviews hit page limit; results may be truncated",
-			"owner", owner, "repo", repo, "pr", number,
-			"maxPages", maxPages, "reviewsFetched", len(allReviews))
-	}
-
-	return allReviews, nil
 }
 
 // DeleteReview deletes a pull request review.
@@ -249,36 +199,14 @@ func (c *Client) DismissReview(ctx context.Context, owner, repo string, number i
 		Event: "DISMISS",
 	}
 
-	_, err := c.doJSONRequest(ctx, http.MethodPut, reqURL, payload)
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("marshal dismiss request: %w", err)
+	}
+
+	_, err = c.doRequestWithBody(ctx, http.MethodPut, reqURL, data)
 	if err != nil {
 		return fmt.Errorf("dismiss review: %w", err)
 	}
 	return nil
 }
-
-// SupersedeReviews marks prior reviews as superseded by dismissing them.
-// This implements vcs.ReviewSuperseder for the GitHub adapter.
-// The baseURL and sentinel parameters are unused for GitHub (dismissal is the mechanism).
-func (c *Client) SupersedeReviews(ctx context.Context, owner, repo string, prNumber int, oldReviews []vcs.Review, newReviewID int64, _, _ string) error {
-	var errs []error
-	for _, old := range oldReviews {
-		if err := c.DismissReview(ctx, owner, repo, prNumber, old.ID, "Superseded by new review"); err != nil {
-			errs = append(errs, fmt.Errorf("dismiss review %d: %w", old.ID, err))
-		}
-	}
-	return errors.Join(errs...)
-}
-
-// GetAuthenticatedUser returns the login name of the authenticated user.
-func (c *Client) GetAuthenticatedUser(ctx context.Context) (string, error) {
-	reqURL := fmt.Sprintf("%s/user", c.baseURL)
-	body, err := c.doGet(ctx, reqURL)
-	if err != nil {
-		return "", fmt.Errorf("get authenticated user: %w", err)
-	}
-	var resp userResponse
-	if err := json.Unmarshal(body, &resp); err != nil {
-		return "", fmt.Errorf("parse user response: %w", err)
-	}
-	return resp.Login, nil
-}

github/review_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"net/http"
 	"strings"
@@ -390,288 +389,3 @@ func TestPostReview_ConflictingCommitIDs(t *testing.T) {
 		t.Errorf("expected ErrConflictingCommitIDs, got: %v", err)
 	}
 }
-
-func TestPostReview_RequestCommitID_TakesPriority(t *testing.T) {
-	var gotPayload struct {
-		CommitID string `json:"commit_id"`
-		Body     string `json:"body"`
-	}
-
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		json.NewDecoder(r.Body).Decode(&gotPayload)
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(map[string]any{
-			"id":        42,
-			"body":      "LGTM",
-			"state":     "APPROVED",
-			"commit_id": "req-level-sha",
-			"user":      map[string]any{"login": "bot"},
-		})
-	})
-
-	review, err := c.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-		Body:     "LGTM",
-		Event:    vcs.ReviewEventApprove,
-		CommitID: "req-level-sha",
-		Comments: []vcs.ReviewComment{
-			{Path: "a.go", Position: 1, CommitID: "req-level-sha", Body: "looks good"},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if gotPayload.CommitID != "req-level-sha" {
-		t.Errorf("sent commit_id = %q, want %q", gotPayload.CommitID, "req-level-sha")
-	}
-	if review.CommitID != "req-level-sha" {
-		t.Errorf("review.CommitID = %q, want %q", review.CommitID, "req-level-sha")
-	}
-}
-
-func TestPostReview_RequestCommitID_ConflictsWithComment(t *testing.T) {
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		t.Fatal("request should not be sent when commit IDs conflict")
-	})
-
-	// req.CommitID is set, and a comment has a different CommitID → conflict
-	_, err := c.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-		Body:     "Review",
-		Event:    vcs.ReviewEventComment,
-		CommitID: "req-sha",
-		Comments: []vcs.ReviewComment{
-			{Path: "a.go", Position: 1, CommitID: "different-sha", Body: "nit"},
-		},
-	})
-	if err == nil {
-		t.Fatal("expected error for conflicting commit IDs")
-	}
-	if !errors.Is(err, ErrConflictingCommitIDs) {
-		t.Errorf("expected ErrConflictingCommitIDs, got: %v", err)
-	}
-}
-
-func TestPostReview_RequestCommitID_FallbackToComment(t *testing.T) {
-	var gotPayload struct {
-		CommitID string `json:"commit_id"`
-	}
-
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		json.NewDecoder(r.Body).Decode(&gotPayload)
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(map[string]any{
-			"id":        43,
-			"body":      "ok",
-			"state":     "COMMENTED",
-			"commit_id": "comment-sha",
-			"user":      map[string]any{"login": "bot"},
-		})
-	})
-
-	// req.CommitID is empty, so it falls back to the comment's CommitID
-	_, err := c.PostReview(context.Background(), "owner", "repo", 1, vcs.ReviewRequest{
-		Body:  "ok",
-		Event: vcs.ReviewEventComment,
-		// CommitID intentionally empty
-		Comments: []vcs.ReviewComment{
-			{Path: "a.go", Position: 1, CommitID: "comment-sha", Body: "note"},
-		},
-	})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if gotPayload.CommitID != "comment-sha" {
-		t.Errorf("sent commit_id = %q, want %q (fallback from comment)", gotPayload.CommitID, "comment-sha")
-	}
-}
-
-// --- ListReviews pagination tests ---
-
-func TestListReviews_MultiPage(t *testing.T) {
-	// Test multi-page pagination: 2 full pages + 1 partial page.
-	// pageSize=3, so pages return [3, 3, 2] reviews = 8 total.
-	const pageSize = 3
-	callCount := 0
-
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != "GET" {
-			t.Fatalf("expected GET, got %s", r.Method)
-		}
-		callCount++
-
-		page := r.URL.Query().Get("page")
-		var reviews []map[string]interface{}
-
-		switch page {
-		case "1":
-			for i := 1; i <= pageSize; i++ {
-				reviews = append(reviews, map[string]interface{}{
-					"id": i, "body": fmt.Sprintf("review %d", i),
-					"state": "APPROVED", "commit_id": "sha1",
-					"user": map[string]string{"login": "user1"},
-				})
-			}
-		case "2":
-			for i := pageSize + 1; i <= pageSize*2; i++ {
-				reviews = append(reviews, map[string]interface{}{
-					"id": i, "body": fmt.Sprintf("review %d", i),
-					"state": "COMMENTED", "commit_id": "sha1",
-					"user": map[string]string{"login": "user2"},
-				})
-			}
-		case "3":
-			// Partial page: only 2 reviews (less than pageSize)
-			for i := pageSize*2 + 1; i <= pageSize*2+2; i++ {
-				reviews = append(reviews, map[string]interface{}{
-					"id": i, "body": fmt.Sprintf("review %d", i),
-					"state": "CHANGES_REQUESTED", "commit_id": "sha1",
-					"user": map[string]string{"login": "user3"},
-				})
-			}
-		default:
-			t.Fatalf("unexpected page: %s", page)
-		}
-
-		json.NewEncoder(w).Encode(reviews)
-	})
-	c.SetReviewPagination(pageSize, 10)
-
-	reviews, err := c.ListReviews(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(reviews) != 8 {
-		t.Fatalf("expected 8 reviews, got %d", len(reviews))
-	}
-	if callCount != 3 {
-		t.Errorf("expected 3 API calls, got %d", callCount)
-	}
-
-	// Verify reviews are correctly concatenated in order
-	for i, r := range reviews {
-		expectedID := int64(i + 1)
-		if r.ID != expectedID {
-			t.Errorf("review[%d]: expected ID %d, got %d", i, expectedID, r.ID)
-		}
-	}
-}
-
-func TestListReviews_ExactMultipleOfPageSize(t *testing.T) {
-	// When total reviews is an exact multiple of pageSize, an extra request
-	// returning 0 results terminates the loop. No truncation warning.
-	const pageSize = 2
-	callCount := 0
-
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		callCount++
-		page := r.URL.Query().Get("page")
-
-		var reviews []map[string]interface{}
-		switch page {
-		case "1":
-			reviews = []map[string]interface{}{
-				{"id": 1, "body": "r1", "state": "APPROVED", "commit_id": "s1", "user": map[string]string{"login": "u1"}},
-				{"id": 2, "body": "r2", "state": "APPROVED", "commit_id": "s1", "user": map[string]string{"login": "u2"}},
-			}
-		case "2":
-			reviews = []map[string]interface{}{
-				{"id": 3, "body": "r3", "state": "APPROVED", "commit_id": "s1", "user": map[string]string{"login": "u3"}},
-				{"id": 4, "body": "r4", "state": "APPROVED", "commit_id": "s1", "user": map[string]string{"login": "u4"}},
-			}
-		case "3":
-			// Empty page — signals end of data
-			reviews = []map[string]interface{}{}
-		default:
-			t.Fatalf("unexpected page: %s", page)
-		}
-
-		json.NewEncoder(w).Encode(reviews)
-	})
-	c.SetReviewPagination(pageSize, 10)
-
-	reviews, err := c.ListReviews(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(reviews) != 4 {
-		t.Fatalf("expected 4 reviews, got %d", len(reviews))
-	}
-	// 3 calls: page 1 (full), page 2 (full), page 3 (empty)
-	if callCount != 3 {
-		t.Errorf("expected 3 API calls, got %d", callCount)
-	}
-}
-
-func TestListReviews_MaxPagesCutoff(t *testing.T) {
-	// When maxPages is hit and the last page is full, results are truncated
-	// and a warning would fire (we verify the reviews are still returned).
-	const pageSize = 2
-	const maxPages = 2
-	callCount := 0
-
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		callCount++
-		page := r.URL.Query().Get("page")
-
-		// Always return a full page (simulating more data exists)
-		var reviews []map[string]interface{}
-		var baseID int
-		switch page {
-		case "1":
-			baseID = 0
-		case "2":
-			baseID = pageSize
-		default:
-			t.Fatalf("unexpected page %s (should not exceed maxPages)", page)
-		}
-		for i := 1; i <= pageSize; i++ {
-			reviews = append(reviews, map[string]interface{}{
-				"id": baseID + i, "body": fmt.Sprintf("r%d", baseID+i),
-				"state": "APPROVED", "commit_id": "sha1",
-				"user": map[string]string{"login": "user"},
-			})
-		}
-
-		json.NewEncoder(w).Encode(reviews)
-	})
-	c.SetReviewPagination(pageSize, maxPages)
-
-	reviews, err := c.ListReviews(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	// Should return all reviews fetched within the cap
-	expectedCount := pageSize * maxPages
-	if len(reviews) != expectedCount {
-		t.Fatalf("expected %d reviews, got %d", expectedCount, len(reviews))
-	}
-	if callCount != maxPages {
-		t.Errorf("expected %d API calls, got %d", maxPages, callCount)
-	}
-	// Verify concatenation order
-	for i, r := range reviews {
-		if r.ID != int64(i+1) {
-			t.Errorf("review[%d]: expected ID %d, got %d", i, i+1, r.ID)
-		}
-	}
-}
-
-func TestListReviews_EmptyFirstPage(t *testing.T) {
-	// PR with no reviews: first page returns empty array.
-	callCount := 0
-	c := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
-		callCount++
-		json.NewEncoder(w).Encode([]map[string]interface{}{})
-	})
-	c.SetReviewPagination(10, 5)
-
-	reviews, err := c.ListReviews(context.Background(), "owner", "repo", 1)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(reviews) != 0 {
-		t.Fatalf("expected 0 reviews, got %d", len(reviews))
-	}
-	if callCount != 1 {
-		t.Errorf("expected 1 API call, got %d", callCount)
-	}
-}

go.mod

@@ -2,4 +2,4 @@ module gitea.weiker.me/rodin/review-bot
 
 go 1.26.2
 
-require gopkg.in/yaml.v3 v3.0.1
+require github.com/goccy/go-yaml v1.19.2

go.sum

@@ -1,4 +1,2 @@
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+github.com/goccy/go-yaml v1.19.2 h1:PmFC1S6h8ljIz6gMRBopkjP1TVT7xuwrButHID66PoM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

review/persona.go

@@ -5,12 +5,15 @@ import (
 	"embed"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"sort"
 	"strings"
 	"unicode/utf8"
 
-	"gopkg.in/yaml.v3"
+	"github.com/goccy/go-yaml"
+	"github.com/goccy/go-yaml/ast"
+	"github.com/goccy/go-yaml/parser"
 )
 
 //go:embed personas/*.yaml
@@ -118,10 +121,8 @@ func ListBuiltinPersonas() []string {
 		default:
 			continue
 		}
-		if !seen[personaName] {
 		seen[personaName] = true
 	}
-	}
 	names := make([]string, 0, len(seen))
 	for name := range seen {
 		names = append(names, name)
@@ -142,10 +143,19 @@ func parsePersona(data []byte, source string) (*Persona, error) {
 		err = unmarshalYAMLWithDepthLimit(data, &p, MaxYAMLDepth)
 	} else {
 		// Use json.Decoder with DisallowUnknownFields for consistency with
-		// YAML's KnownFields(true) - both reject unknown fields to catch typos.
+		// YAML's Strict() - both reject unknown fields to catch typos.
 		dec := json.NewDecoder(bytes.NewReader(data))
 		dec.DisallowUnknownFields()
 		err = dec.Decode(&p)
+		if err == nil {
+			// Reject trailing content after the first valid JSON object.
+			// Without this check, input like `{"name":"x"}garbage` would
+			// silently succeed because Decoder stops after one object.
+			var dummy json.RawMessage
+			if err2 := dec.Decode(&dummy); err2 != io.EOF {
+				err = fmt.Errorf("unexpected trailing content after JSON object")
+			}
+		}
 	}
 	if err != nil {
 		return nil, fmt.Errorf("parse persona %s: %w", source, err)
@@ -156,78 +166,176 @@ func parsePersona(data []byte, source string) (*Persona, error) {
 	return &p, nil
 }
 
-// unmarshalYAMLWithDepthLimit unmarshals YAML data with explicit depth limiting
+// unmarshalYAMLWithDepthLimit unmarshals YAML data with three safety checks:
-// and strict field checking. This protects against stack exhaustion from deeply
+//   - Depth limiting: rejects AST trees exceeding maxDepth to prevent stack exhaustion.
-// nested structures and catches typos in field names.
+//   - Multi-document rejection: prevents silent data loss from ignored extra documents.
-// Multi-document YAML files are rejected to prevent silent data loss.
+//   - Strict field checking: rejects unknown YAML keys to catch typos early.
 func unmarshalYAMLWithDepthLimit(data []byte, out any, maxDepth int) error {
-	// First pass: decode into a yaml.Node to check depth limits and node counts.
+	// First pass: parse into AST to check depth limits, node counts, and
-	// This prevents stack exhaustion before we attempt to decode into structs.
+	// multi-document rejection. This prevents stack exhaustion before we
-	var node yaml.Node
+	// attempt to decode into structs.
-	dec := yaml.NewDecoder(bytes.NewReader(data))
+	file, err := parser.ParseBytes(data, 0)
-	if err := dec.Decode(&node); err != nil {
+	if err != nil {
 		return err
 	}
 
+	// Reject empty YAML input (whitespace-only, comment-only, or truly empty files).
+	// The parser returns a single doc with nil body for these cases.
+	if len(file.Docs) == 0 || file.Docs[0].Body == nil {
+		return fmt.Errorf("empty YAML document")
+	}
+
 	// Reject multi-document YAML files - silently ignoring additional documents
 	// could lead to confusing behavior where users think their changes take effect.
-	var extra yaml.Node
+	if len(file.Docs) > 1 {
-	if dec.Decode(&extra) == nil {
 		return fmt.Errorf("multi-document YAML is not supported; only single-document files are allowed")
 	}
 
 	nodeCount := 0
-	if err := checkYAMLDepth(&node, 0, maxDepth, MaxYAMLNodes, make(map[*yaml.Node]struct{}), &nodeCount); err != nil {
+	if err := checkYAMLDepth(file.Docs[0].Body, 0, maxDepth, MaxYAMLNodes, make(map[ast.Node]int), make(map[ast.Node]bool), &nodeCount); err != nil {
 		return err
 	}
 
 	// Second pass: decode with strict field checking enabled.
-	// KnownFields(true) rejects unknown keys, catching typos like "focuss" or "identiy".
+	// Strict() rejects unknown keys, catching typos like "focuss" or "identiy".
-	// We must re-decode from the original data because yaml.Node.Decode() doesn't
+	//
-	// support the KnownFields option.
+	// Safety note: goccy/go-yaml's decoder does not expand YAML aliases
-	strictDec := yaml.NewDecoder(bytes.NewReader(data))
+	// recursively — it resolves them via the pre-built AST, which our first
-	strictDec.KnownFields(true)
+	// pass already depth-checked. Alias chains that would exceed depth limits
-	return strictDec.Decode(out)
+	// are caught above; the decoder merely reads the resolved scalar values.
+	dec := yaml.NewDecoder(bytes.NewReader(data), yaml.Strict())
+	return dec.Decode(out)
 }
 
-// checkYAMLDepth recursively checks that YAML nodes don't exceed the depth limit
+// checkYAMLDepth recursively checks that YAML AST nodes don't exceed the depth
-// or the total node count limit. It also detects alias cycles to prevent infinite
+// limit or the total node count limit. It uses two tracking maps:
-// recursion from crafted YAML with self-referential aliases.
+//   - validated: maps each node to the maximum depth at which it was previously
-func checkYAMLDepth(node *yaml.Node, depth, maxDepth, maxNodes int, seen map[*yaml.Node]struct{}, nodeCount *int) error {
+//     checked. If a node is revisited at a deeper depth (e.g., via an alias),
+//     we re-check it to ensure the combined effective depth doesn't exceed limits.
+//   - visiting: per-path recursion stack for true cycle detection. A node on the
+//     current path is a cycle (alias loop); we return nil to avoid infinite recursion.
+//
+// This design prevents the alias depth bypass where an anchored subtree validated
+// at a shallow depth could be referenced via alias at a greater depth, effectively
+// exceeding MaxYAMLDepth.
+func checkYAMLDepth(node ast.Node, depth, maxDepth, maxNodes int, validated map[ast.Node]int, visiting map[ast.Node]bool, nodeCount *int) error {
+	if node == nil {
+		return nil
+	}
+
 	if depth > maxDepth {
 		return fmt.Errorf("YAML nesting depth exceeds maximum (%d)", maxDepth)
 	}
 
+	// Cycle detection: if we're currently visiting this node on the current
+	// recursion path, it's a cycle (e.g., alias pointing to an ancestor).
+	// Return nil to break the cycle without error — cycles are a structural
+	// property, not a depth violation.
+	if visiting[node] {
+		return nil
+	}
+
 	// Track total nodes visited as defense-in-depth against wide-but-shallow attacks.
+	// Placed after cycle detection but before the depth-aware short-circuit. This means
+	// nodes revisited at shallower depths (via aliases) are counted each time they are
+	// encountered — intentional conservative overcounting. This bounds the total work
+	// performed during validation rather than tracking unique nodes, which is the safer
+	// security posture for untrusted YAML input.
 	*nodeCount++
 	if *nodeCount > maxNodes {
 		return fmt.Errorf("YAML node count exceeds maximum (%d)", maxNodes)
 	}
 
-	// Cycle detection: if we've seen this node before, we're in a cycle.
+	// Depth-aware short-circuit: skip re-validation only when the current visit
-	if _, ok := seen[node]; ok {
+	// depth is the same or shallower than the depth at which this node was
-		return nil // Already validated this subtree, skip to avoid infinite recursion.
+	// previously validated. A shallower (or equal) current depth means the
+	// prior, deeper validation already covered any subtree depth violations.
+	// If the current depth exceeds the previous validation depth (e.g., an alias
+	// references this node deeper in the tree), we must re-traverse to ensure
+	// the combined effective depth doesn't exceed maxDepth.
+	//
+	// Note: using ast.Node (interface) as map key relies on pointer identity,
+	// which is correct because all goccy/go-yaml AST node types are pointer
+	// receivers (*MappingNode, *SequenceNode, etc.), never value types.
+	if prevDepth, ok := validated[node]; ok && depth <= prevDepth {
+		return nil
 	}
-	seen[node] = struct{}{}
+	validated[node] = depth
 
-	// Handle alias nodes: follow the alias to its anchor target.
+	// Mark as visiting (on the current recursion path) for cycle detection.
-	// Increment depth when following aliases since they expand the effective structure.
+	visiting[node] = true
-	if node.Kind == yaml.AliasNode && node.Alias != nil {
+	defer func() { visiting[node] = false }()
-		return checkYAMLDepth(node.Alias, depth+1, maxDepth, maxNodes, seen, nodeCount)
-	}
 
-	for _, child := range node.Content {
+	// Walk children based on node type.
-		if err := checkYAMLDepth(child, depth+1, maxDepth, maxNodes, seen, nodeCount); err != nil {
+	switch n := node.(type) {
+	case *ast.MappingNode:
+		for _, value := range n.Values {
+			if err := checkYAMLDepth(value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
 				return err
 			}
 		}
+	case *ast.MappingValueNode:
+		// Both Key and Value are visited at depth+1 relative to this
+		// MappingValueNode. Since MappingNode visits its MappingValueNode
+		// children at depth+1 as well, keys and values end up at depth+2
+		// from the parent MappingNode. This is intentional: it mirrors the
+		// actual nesting structure (mapping → key-value pair → key/value).
+		if err := checkYAMLDepth(n.Key, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
+			return err
+		}
+		if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
+			return err
+		}
+	case *ast.SequenceNode:
+		for _, value := range n.Values {
+			if err := checkYAMLDepth(value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
+				return err
+			}
+		}
+	case *ast.AliasNode:
+		// Follow alias to its target, incrementing depth since aliases expand
+		// the effective structure.
+		if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
+			return err
+		}
+	case *ast.AnchorNode:
+		// Increment depth for anchor values as a conservative measure: the
+		// anchor definition itself is structural, and treating it as a depth
+		// level ensures that deeply nested anchors are caught at definition
+		// time rather than only when referenced via alias. This +1 is
+		// asymmetric with alias (which also increments) — by design, the
+		// effective depth budget for anchored-then-aliased content is reduced
+		// because both the definition site and the reference site each consume
+		// a level, making deeply nested anchor/alias pairs hit the limit sooner.
+		if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
+			return err
+		}
+	case *ast.TagNode:
+		if err := checkYAMLDepth(n.Value, depth+1, maxDepth, maxNodes, validated, visiting, nodeCount); err != nil {
+			return err
+		}
+	case *ast.MergeKeyNode:
+		// MergeKeyNode represents the literal "<<" merge key token. It has no
+		// child nodes — the value side of a merge (e.g., *alias) lives in the
+		// parent MappingValueNode.Value, which is already recursed into above.
+		// Explicitly listed here (rather than in the default case) to prevent
+		// future library changes from silently bypassing depth checks.
+	default:
+		// Scalar leaf nodes (StringNode, IntegerNode, FloatNode, BoolNode,
+		// NullNode, InfinityNode, NanNode, LiteralNode) have no children to
+		// recurse into.
+	}
 	return nil
 }
 
 // ParsePersonaBytes parses persona data from bytes with a source label for errors.
 // This is useful for parsing personas fetched from external sources (e.g., Gitea API)
 // without requiring filesystem access. Format is detected by source extension.
+// Input is bounded by MaxPersonaFileSize to prevent resource exhaustion.
 func ParsePersonaBytes(data []byte, source string) (*Persona, error) {
+	if len(data) > MaxPersonaFileSize {
+		return nil, fmt.Errorf("persona data from %s exceeds maximum size (%d bytes, limit %d)", source, len(data), MaxPersonaFileSize)
+	}
 	return parsePersona(data, source)
 }
 

review/persona_test.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"testing"
 
-	"gopkg.in/yaml.v3"
+	"github.com/goccy/go-yaml/ast"
 )
 
 func TestLoadBuiltinPersona(t *testing.T) {
@@ -459,7 +459,14 @@ func TestYAMLDeeplyNestedRejection(t *testing.T) {
 	path := filepath.Join(dir, "deeply-nested.yaml")
 
 	// Build a deeply nested YAML structure that exceeds MaxYAMLDepth (20).
-	// Each level adds 2 to the depth count (key + value mapping).
+	// Depth accumulation trace for "nested: \n  level0: \n    level1: ...":
+	//   - Document root parsed at depth 0
+	//   - Root MappingNode children (MappingValueNodes) visited at depth 1
+	//   - "nested" MappingValueNode: key at depth 2, value at depth 2
+	//   - Each levelN adds depth via MappingValueNode traversal (key + value)
+	//   - Exact depth per level depends on AST structure (MappingNode wrapping),
+	//     but 25 levels reliably exceeds MaxYAMLDepth (20) with comfortable margin.
+	// The test uses 25 levels rather than exactly 21 to avoid brittleness.
 	var sb strings.Builder
 	sb.WriteString("name: test\nidentity: test\nnested:\n")
 	indent := "  "
@@ -483,6 +490,35 @@ func TestYAMLDeeplyNestedRejection(t *testing.T) {
 	}
 }
 
+func TestYAMLEmptyFileRejection(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+	}{
+		{"completely_empty", ""},
+		{"whitespace_only", "   \n\n  "},
+		{"comment_only", "# just a comment\n"},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			path := filepath.Join(dir, tc.name+".yaml")
+			if err := os.WriteFile(path, []byte(tc.content), 0644); err != nil {
+				t.Fatalf("failed to write test file: %v", err)
+			}
+
+			_, err := LoadPersona(path)
+			if err == nil {
+				t.Fatal("expected error for empty YAML input, got nil")
+			}
+			if !strings.Contains(err.Error(), "empty YAML document") {
+				t.Errorf("expected error containing %q, got: %v", "empty YAML document", err)
+			}
+		})
+	}
+}
+
 func TestYAMLFileSizeLimit(t *testing.T) {
 	dir := t.TempDir()
 	path := filepath.Join(dir, "huge.yaml")
@@ -504,41 +540,41 @@ func TestYAMLFileSizeLimit(t *testing.T) {
 
 func TestYAMLAliasCycleDetection(t *testing.T) {
 	// Test that our checkYAMLDepth function handles alias cycles gracefully
-	// by using the seen map to prevent infinite recursion.
+	// by using the visiting map to prevent infinite recursion.
-	// We test this directly because go-yaml's parser handles most cycles
-	// at parse time, but we need to ensure our checker is robust.
 
 	// Create a node structure where an alias points to a parent node,
-	// simulating what could happen with malicious input that bypasses
+	// simulating what could happen with crafted input.
-	// go-yaml's cycle detection.
+	parent := &ast.MappingNode{
-	parent := &yaml.Node{
+		Values: []*ast.MappingValueNode{
-		Kind: yaml.MappingNode,
+			{
-		Content: []*yaml.Node{
+				Key:   &ast.StringNode{Value: "name"},
-			{Kind: yaml.ScalarNode, Value: "name"},
+				Value: &ast.StringNode{Value: "test"},
-			{Kind: yaml.ScalarNode, Value: "test"},
+			},
-			{Kind: yaml.ScalarNode, Value: "nested"},
 		},
 	}
 
 	// Create a child that aliases back to the parent (artificial cycle)
-	aliasToParent := &yaml.Node{
+	aliasToParent := &ast.AliasNode{
-		Kind:  yaml.AliasNode,
+		Value: parent,
-		Alias: parent,
 	}
-	parent.Content = append(parent.Content, aliasToParent)
+	parent.Values = append(parent.Values, &ast.MappingValueNode{
+		Key:   &ast.StringNode{Value: "nested"},
+		Value: aliasToParent,
+	})
 
 	nodeCount := 0
-	seen := make(map[*yaml.Node]struct{})
+	validated := make(map[ast.Node]int)
+	visiting := make(map[ast.Node]bool)
 
-	// This should NOT hang or stack overflow - the seen map prevents infinite recursion
+	// This should NOT hang or stack overflow - cycle detection prevents infinite recursion
-	err := checkYAMLDepth(parent, 0, MaxYAMLDepth, MaxYAMLNodes, seen, &nodeCount)
+	err := checkYAMLDepth(parent, 0, MaxYAMLDepth, MaxYAMLNodes, validated, visiting, &nodeCount)
 	if err != nil {
 		t.Errorf("unexpected error traversing cyclic structure: %v", err)
 	}
 
-	// Verify we tracked the parent in the seen map
+	// Verify we tracked the parent in the validated map
-	if _, ok := seen[parent]; !ok {
+	if _, ok := validated[parent]; !ok {
-		t.Error("parent node not tracked in seen map")
+		t.Error("parent node not tracked in validated map")
 	}
 }
 
@@ -594,36 +630,82 @@ func TestYAMLNodeCountLimit(t *testing.T) {
 func TestCheckYAMLDepthCycleDetectionDirect(t *testing.T) {
 	// Direct test of cycle detection in checkYAMLDepth by creating
 	// a node structure with an artificial cycle.
-	// This tests the seen map logic independent of go-yaml's parsing.
+	node := &ast.MappingNode{
-	node := &yaml.Node{
+		Values: []*ast.MappingValueNode{
-		Kind: yaml.MappingNode,
+			{
-		Content: []*yaml.Node{
+				Key:   &ast.StringNode{Value: "key"},
-			{Kind: yaml.ScalarNode, Value: "key"},
+				Value: &ast.StringNode{Value: "value"},
-			{Kind: yaml.ScalarNode, Value: "value"},
+			},
 		},
 	}
 
 	// Create a cycle by making a child reference the parent
-	cycleChild := &yaml.Node{
+	cycleChild := &ast.AliasNode{
-		Kind:  yaml.AliasNode,
+		Value: node, // Points back to the parent
-		Alias: node, // Points back to the parent
 	}
-	node.Content = append(node.Content,
+	node.Values = append(node.Values, &ast.MappingValueNode{
-		&yaml.Node{Kind: yaml.ScalarNode, Value: "cyclic"},
+		Key:   &ast.StringNode{Value: "cyclic"},
-		cycleChild,
+		Value: cycleChild,
-	)
+	})
 
 	nodeCount := 0
-	seen := make(map[*yaml.Node]struct{})
+	validated := make(map[ast.Node]int)
-	err := checkYAMLDepth(node, 0, MaxYAMLDepth, MaxYAMLNodes, seen, &nodeCount)
+	visiting := make(map[ast.Node]bool)
+	err := checkYAMLDepth(node, 0, MaxYAMLDepth, MaxYAMLNodes, validated, visiting, &nodeCount)
 
 	// Should complete without infinite recursion due to cycle detection
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	// The seen map should contain multiple entries
+	// The validated map should contain multiple entries
-	if len(seen) < 2 {
+	if len(validated) < 2 {
-		t.Errorf("seen map has %d entries, expected at least 2", len(seen))
+		t.Errorf("validated map has %d entries, expected at least 2", len(validated))
+	}
+}
+
+func TestYAMLAliasDepthBypass(t *testing.T) {
+	// Test that an anchored subtree first validated at a shallow depth is
+	// re-checked when referenced via alias at a deeper position. Without the
+	// depth-aware validated map, the alias reference would skip re-checking
+	// and allow the effective nesting to exceed MaxYAMLDepth.
+
+	dir := t.TempDir()
+	path := filepath.Join(dir, "alias-depth-bypass.yaml")
+
+	// Build YAML with an anchor at shallow depth containing a subtree near the limit,
+	// then reference it via alias deep enough that effective depth exceeds MaxYAMLDepth.
+	var sb strings.Builder
+	sb.WriteString("name: test\nidentity: test\n")
+
+	// Create the anchored subtree at depth 1 (key level) that nests 15 levels deep.
+	sb.WriteString("anchor_key: &deep_anchor\n")
+	for i := 0; i < 15; i++ {
+		sb.WriteString(strings.Repeat("  ", i+1))
+		sb.WriteString(fmt.Sprintf("level%d:\n", i))
+	}
+	sb.WriteString(strings.Repeat("  ", 16))
+	sb.WriteString("leaf: value\n")
+
+	// Create a wrapper that nests 6 levels deep, then references the anchor.
+	// Effective depth at alias target = 6 (wrapper nesting) + 1 (alias) + 15 (subtree) = 22 > 20
+	sb.WriteString("wrapper:\n")
+	for i := 0; i < 6; i++ {
+		sb.WriteString(strings.Repeat("  ", i+1))
+		sb.WriteString(fmt.Sprintf("n%d:\n", i))
+	}
+	sb.WriteString(strings.Repeat("  ", 7))
+	sb.WriteString("alias_ref: *deep_anchor\n")
+
+	if err := os.WriteFile(path, []byte(sb.String()), 0644); err != nil {
+		t.Fatalf("failed to write test file: %v", err)
+	}
+
+	_, err := LoadPersona(path)
+	if err == nil {
+		t.Fatal("expected error for alias depth bypass, got nil")
+	}
+	if !strings.Contains(err.Error(), "nesting depth exceeds") {
+		t.Errorf("error = %q, want containing 'nesting depth exceeds'", err.Error())
 	}
 }
 
@@ -776,3 +858,102 @@ identity: test identity
 		t.Errorf("Name = %q, want %q", p.Name, "test")
 	}
 }
+
+func TestJSONTrailingContentRejected(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+	}{
+		{
+			name:    "trailing garbage after object",
+			content: `{"name":"test","identity":"test identity"}garbage`,
+		},
+		{
+			name:    "two JSON objects",
+			content: `{"name":"test","identity":"test identity"}{"name":"other"}`,
+		},
+		{
+			name:    "trailing array",
+			content: `{"name":"test","identity":"test identity"}[]`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dir := t.TempDir()
+			path := filepath.Join(dir, "test.json")
+			if err := os.WriteFile(path, []byte(tt.content), 0644); err != nil {
+				t.Fatalf("failed to write test file: %v", err)
+			}
+
+			_, err := LoadPersona(path)
+			if err == nil {
+				t.Fatal("expected error for trailing content, got nil")
+			}
+			if !strings.Contains(err.Error(), "trailing content") {
+				t.Errorf("error = %q, want to contain 'trailing content'", err.Error())
+			}
+		})
+	}
+}
+
+func TestParsePersonaBytesSizeLimit(t *testing.T) {
+	// ParsePersonaBytes should reject input exceeding MaxPersonaFileSize
+	oversized := make([]byte, MaxPersonaFileSize+1)
+	for i := range oversized {
+		oversized[i] = 'x'
+	}
+
+	_, err := ParsePersonaBytes(oversized, "oversized.yaml")
+	if err == nil {
+		t.Fatal("expected error for oversized input, got nil")
+	}
+	if !strings.Contains(err.Error(), "exceeds maximum size") {
+		t.Errorf("error = %q, want to contain 'exceeds maximum size'", err.Error())
+	}
+
+	// Just under the limit should not trigger size error (may fail parse, but not size)
+	underLimit := []byte("name: test\nidentity: test persona\n")
+	p, err := ParsePersonaBytes(underLimit, "valid.yaml")
+	if err != nil {
+		t.Fatalf("unexpected error for valid input: %v", err)
+	}
+	if p.Name != "test" {
+		t.Errorf("Name = %q, want %q", p.Name, "test")
+	}
+}
+
+func TestYAMLMergeKeyDepthCheck(t *testing.T) {
+	// Verify that YAML merge keys (<<: *alias) are properly handled by the
+	// depth checker. The merge key content is in the MappingValueNode.Value
+	// (an AliasNode), not in the MergeKeyNode itself.
+	p, err := ParsePersonaBytes([]byte("name: merge-test\nidentity: test\n"), "merge.yaml")
+	if err != nil {
+		t.Fatalf("basic parse failed: %v", err)
+	}
+	if p.Name != "merge-test" {
+		t.Errorf("Name = %q, want %q", p.Name, "merge-test")
+	}
+
+	// Test that deeply nested merge keys still hit depth limit.
+	// Build YAML with merge key content nested beyond MaxYAMLDepth.
+	var sb strings.Builder
+	sb.WriteString("name: deep-merge\nidentity: deep merge persona\n")
+	sb.WriteString("anchor: &deep\n")
+	indent := "  "
+	for i := 0; i < MaxYAMLDepth+5; i++ {
+		sb.WriteString(indent)
+		sb.WriteString(fmt.Sprintf("level%d:\n", i))
+		indent += "  "
+	}
+	sb.WriteString(indent + "leaf: value\n")
+	sb.WriteString("target:\n  <<: *deep\n")
+
+	_, err = ParsePersonaBytes([]byte(sb.String()), "deep-merge.yaml")
+	if err == nil {
+		t.Fatal("expected error for deeply nested merge key content, got nil")
+	}
+	if !strings.Contains(err.Error(), "depth") {
+		t.Errorf("error = %q, want to contain 'depth'", err.Error())
+	}
+}

vcs/interfaces.go

@@ -41,20 +41,3 @@ type Client interface {
 	Reviewer
 	Identity
 }
-
-// ReviewerSelfRequester is an optional interface implemented by adapters that support
-// requesting the authenticated user as a reviewer on a pull request. This is used for
-// Gitea-specific behavior (ensuring the bot appears in required-reviewer checks).
-// Consumers should use interface assertion: if sr, ok := client.(ReviewerSelfRequester); ok { ... }
-type ReviewerSelfRequester interface {
-	RequestReviewerSelf(ctx context.Context, owner, repo string, number int, user string) error
-}
-
-// ReviewSuperseder is an optional interface implemented by adapters that support
-// marking old reviews as superseded. For Gitea this means editing the review body
-// with a link to the new review and resolving inline comments. For GitHub this
-// means dismissing old reviews.
-// Consumers should use interface assertion: if rs, ok := client.(ReviewSuperseder); ok { ... }
-type ReviewSuperseder interface {
-	SupersedeReviews(ctx context.Context, owner, repo string, prNumber int, oldReviews []Review, newReviewID int64, baseURL, sentinel string) error
-}

vcs/provider.go

@@ -1,26 +0,0 @@
-package vcs
-
-// VCSProvider identifies a VCS platform. Using a typed string instead of bare
-// strings makes provider values compiler-checkable and prevents typos from
-// silently passing validation.
-type VCSProvider string
-
-const (
-	ProviderGitea  VCSProvider = "gitea"
-	ProviderGitHub VCSProvider = "github"
-)
-
-// Valid reports whether p is a known VCS provider.
-func (p VCSProvider) Valid() bool {
-	switch p {
-	case ProviderGitea, ProviderGitHub:
-		return true
-	default:
-		return false
-	}
-}
-
-// String returns the string representation of the provider.
-func (p VCSProvider) String() string {
-	return string(p)
-}

vcs/types.go

@@ -94,10 +94,5 @@ type ReviewRequest struct {
 	Body string `json:"body"`
 	// Event is the review action (approve, request changes, or comment).
 	Event    ReviewEvent     `json:"event"`
-	// CommitID anchors the review to a specific commit SHA.
-	// If empty, the platform defaults to the current PR head.
-	// Adapters use this as the primary commit anchor for the review submission.
-	CommitID string `json:"commit_id,omitempty"`
-
 	Comments []ReviewComment `json:"comments,omitempty"`
 }