fix: log metadata overwrites in batched workflows and deduplicate copier PRs

#3: workflow_processor now logs when a subsequent workflow in the same
batch overwrites the commit message or PR title, showing both old and
new values so the "last wins" behavior is transparent.

#5: addFilesViaPR now checks for an existing open PR from a copier/*
branch before creating a new one. If found, pushes to the existing
branch and updates the PR title/body instead of creating a duplicate.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: cbullinger

docs/RECOMMENDATIONS.md

@@ -27,15 +27,13 @@ When two instances process the same webhook (e.g., local + Cloud Run), the secon
 
 **Files:** `services/github_write_to_target.go`
 
-### 3. PR title/body "last wins" is opaque
+### 3. ~~PR title/body "last wins" is opaque~~ (RESOLVED)
 
-**Priority:** Low
-
-When multiple workflows batch into one PR, the commit message, PR title, and body come from whichever workflow ran last. There's no logging indicating which workflow's metadata was used.
+**Priority:** Low — **Status: Fixed**
 
-**Fix:** Log which workflow's strategy was selected during the write phase.
+~~When multiple workflows batch into one PR, the commit message, PR title, and body come from whichever workflow ran last. There's no logging indicating which workflow's metadata was used.~~
 
-**Files:** `services/github_write_to_target.go`
+**Resolution:** `workflow_processor.go` now logs when a subsequent workflow overwrites a batched commit message or PR title, including the previous and new values and the workflow name responsible.
 
 ## Reliability
 
@@ -47,13 +45,13 @@ The in-memory `DeliveryTracker` prevents duplicate processing within a single in
 
 **Files:** `services/delivery_tracker.go`
 
-### 5. PR deduplication in target repos
+### 5. ~~PR deduplication in target repos~~ (RESOLVED)
 
-**Priority:** Low
+**Priority:** Low — **Status: Fixed**
 
-If the app processes two source PRs in quick succession, it can create duplicate open PRs in the target repo. Before creating a new PR, check for an existing open PR from a `copier/*` branch and update it instead.
+~~If the app processes two source PRs in quick succession, it can create duplicate open PRs in the target repo.~~
 
-**Files:** `services/github_write_to_target.go`
+**Resolution:** `addFilesViaPR` now calls `findExistingCopierPR` before creating a new branch. If an open PR from a `copier/*` branch targeting the same base branch exists, the app pushes new commits to that branch and updates the PR title/body instead of creating a duplicate.
 
 ### 6. Graceful partial failure
 

services/github_write_to_target.go

@@ -185,14 +185,72 @@ func createPullRequest(ctx context.Context, client *github.Client, defaultOwner,
 	return created, nil
 }
 
+// findExistingCopierPR searches for an open PR whose head branch starts with "copier/"
+// targeting the given base branch. Returns nil if none found.
+func findExistingCopierPR(ctx context.Context, client *github.Client, owner, repoName, baseBranch string) *github.PullRequest {
+	prs, _, err := client.PullRequests.List(ctx, owner, repoName, &github.PullRequestListOptions{
+		State: "open",
+		Base:  baseBranch,
+		ListOptions: github.ListOptions{
+			PerPage: 50,
+		},
+	})
+	if err != nil {
+		LogWarning("Failed to list PRs for dedup check; will create new PR", "repo", owner+"/"+repoName, "error", err)
+		return nil
+	}
+	for _, pr := range prs {
+		if strings.HasPrefix(pr.GetHead().GetRef(), "copier/") {
+			return pr
+		}
+	}
+	return nil
+}
+
 // addFilesViaPR creates a temporary branch, commits files to it using the provided commitMessage,
 // opens a pull request with prTitle and prBody, and optionally merges it automatically.
+// If an existing open PR from a copier/* branch is found, the files are pushed to that
+// branch and the PR is updated instead of creating a duplicate.
 func addFilesViaPR(ctx context.Context, config *configs.Config, client *github.Client, key types.UploadKey,
 	files []github.RepositoryContent, commitMessage string, prTitle string, prBody string, mergeWithoutReview bool,
 ) error {
 	defaultOwner := config.ConfigRepoOwner
-	tempBranch := "copier/" + time.Now().UTC().Format("20060102-150405")
 	baseBranch := strings.TrimPrefix(key.BranchPath, "refs/heads/")
+	owner, repoName := parseRepoPath(key.RepoName, defaultOwner)
+
+	// 0. Check for an existing open copier PR targeting this base branch.
+	existingPR := findExistingCopierPR(ctx, client, owner, repoName, baseBranch)
+	if existingPR != nil {
+		existingBranch := existingPR.GetHead().GetRef()
+		LogInfo("Found existing open copier PR; updating instead of creating new",
+			"pr_number", existingPR.GetNumber(),
+			"branch", existingBranch,
+			"repo", key.RepoName,
+		)
+
+		// Push new files to the existing branch
+		if err := commitFilesToBranch(ctx, config, client, key, files, existingBranch, commitMessage); err != nil {
+			return fmt.Errorf("commit to existing copier branch %s: %w", existingBranch, err)
+		}
+
+		// Update the PR title/body to reflect the latest content
+		_, _, err := client.PullRequests.Edit(ctx, owner, repoName, existingPR.GetNumber(), &github.PullRequest{
+			Title: github.Ptr(prTitle),
+			Body:  github.Ptr(prBody),
+		})
+		if err != nil {
+			LogWarning("Failed to update existing PR title/body", "pr_number", existingPR.GetNumber(), "error", err)
+		}
+
+		if mergeWithoutReview {
+			return autoMergePR(ctx, config, client, key.RepoName, defaultOwner, existingPR.GetNumber(), existingBranch)
+		}
+		LogInfo("Existing PR updated and awaiting review", "pr_number", existingPR.GetNumber())
+		return nil
+	}
+
+	// No existing PR — create a new temp branch and PR.
+	tempBranch := "copier/" + time.Now().UTC().Format("20060102-150405")
 
 	// 1. Create branch off the target
 	if _, err := createBranch(ctx, client, defaultOwner, key.RepoName, tempBranch, baseBranch); err != nil {

services/github_write_to_target_test.go

@@ -115,6 +115,9 @@ func TestAddFilesToTargetRepos_ViaPR_Succeeds(t *testing.T) {
 
 	test.SetupOrgToken(owner, "test-token")
 
+	// No existing open PRs
+	test.MockListOpenPRs(owner, repo, nil)
+
 	// Base ref used to create temp branch
 	httpmock.RegisterRegexpResponder("GET",
 		regexp.MustCompile(`^https://api\.github\.com/repos/`+owner+`/`+repo+`/git/ref/(?:refs/)?heads/`+baseBranch+`$`),
@@ -263,6 +266,7 @@ func TestAddFiles_ViaPR_MergeConflict_Dirty_NotMerged(t *testing.T) {
 	require.NoError(t, err, "ConfigurePermissions should succeed")
 
 	test.SetupOrgToken(owner, "test-token")
+	test.MockListOpenPRs(owner, repo, nil)
 
 	httpmock.RegisterRegexpResponder("GET",
 		regexp.MustCompile(`^https://api\.github\.com/repos/`+owner+`/`+repo+`/git/ref/(?:refs/)?heads/`+baseBranch+`$`),
@@ -395,6 +399,7 @@ func TestPriority_PRTitleDefaultsToCommitMessage_And_NoAutoMergeWhenConfigPresen
 	require.NoError(t, err, "ConfigurePermissions should succeed")
 
 	test.SetupOrgToken(owner, "test-token")
+	test.MockListOpenPRs(owner, repo, nil)
 
 	httpmock.RegisterRegexpResponder("GET",
 		regexp.MustCompile(`^https://api\.github\.com/repos/`+owner+`/`+repo+`/git/ref/(?:refs/)?heads/`+baseBranch+`$`),
@@ -470,6 +475,7 @@ func TestAddFilesToTargetRepos_MixedStrategies_ProducesSeparateOperations(t *tes
 	err := services.ConfigurePermissions(context.Background(), cfg)
 	require.NoError(t, err, "ConfigurePermissions should succeed")
 	test.SetupOrgToken(owner, "test-token")
+	test.MockListOpenPRs(owner, repo, nil)
 
 	// --- Mock direct-commit endpoints ---
 	baseRefURL, directCommitsURL, updateRefURL := test.MockGitHubWriteEndpoints(owner, repo, baseBranch)
@@ -532,6 +538,89 @@ func TestAddFilesToTargetRepos_MixedStrategies_ProducesSeparateOperations(t *tes
 	), "PR path: POST create PR")
 }
 
+// TestAddFilesViaPR_ReusesExistingCopierPR verifies that when an open PR from a
+// copier/* branch already exists, the app pushes to that branch and updates the PR
+// title/body instead of creating a duplicate PR.
+func TestAddFilesViaPR_ReusesExistingCopierPR(t *testing.T) {
+	_ = test.WithHTTPMock(t)
+	t.Setenv("COPIER_COMMIT_STRATEGY", "pr")
+
+	owner, repo := test.EnvOwnerRepo(t)
+	baseBranch := "main"
+	existingBranch := "copier/20260101-120000"
+
+	cfg := test.TestConfig()
+	services.DefaultTokenManager().SetInstallationAccessToken("")
+	test.MockGitHubAppTokenEndpoint(cfg.InstallationId)
+	err := services.ConfigurePermissions(context.Background(), cfg)
+	require.NoError(t, err, "ConfigurePermissions should succeed")
+
+	test.SetupOrgToken(owner, "test-token")
+
+	// Return an existing open PR from a copier/* branch
+	test.MockListOpenPRs(owner, repo, []map[string]any{
+		{
+			"number": 77,
+			"head":   map[string]any{"ref": existingBranch},
+			"base":   map[string]any{"ref": baseBranch},
+		},
+	})
+
+	// Mock the existing copier branch ref (for commit push)
+	httpmock.RegisterRegexpResponder("GET",
+		regexp.MustCompile(`^https://api\.github\.com/repos/`+owner+`/`+repo+`/git/ref/(?:refs/)?heads/`+regexp.QuoteMeta(existingBranch)+`$`),
+		httpmock.NewJsonResponderOrPanic(200, map[string]any{
+			"ref": "refs/heads/" + existingBranch, "object": map[string]any{"sha": "existingSha"},
+		}),
+	)
+	httpmock.RegisterRegexpResponder("POST",
+		regexp.MustCompile(`^https://api\.github\.com/repos/`+owner+`/`+repo+`/git/trees(\?.*)?$`),
+		httpmock.NewJsonResponderOrPanic(201, map[string]any{"sha": "newTreeSha"}),
+	)
+	commitsURL := "https://api.github.com/repos/" + owner + "/" + repo + "/git/commits"
+	httpmock.RegisterResponder("POST", commitsURL,
+		httpmock.NewJsonResponderOrPanic(201, map[string]any{"sha": "newCommitSha"}),
+	)
+	httpmock.RegisterRegexpResponder("PATCH",
+		regexp.MustCompile(`^https://api\.github\.com/repos/`+owner+`/`+repo+`/git/refs/heads/`+regexp.QuoteMeta(existingBranch)+`$`),
+		httpmock.NewStringResponder(200, "{}"),
+	)
+	// Mock PR Edit (title/body update)
+	editPRURL := "https://api.github.com/repos/" + owner + "/" + repo + "/pulls/77"
+	httpmock.RegisterResponder("PATCH", editPRURL,
+		httpmock.NewJsonResponderOrPanic(200, map[string]any{"number": 77}),
+	)
+
+	files := []github.RepositoryContent{{
+		Name:    github.Ptr("updated-file.txt"),
+		Path:    github.Ptr("updated-file.txt"),
+		Content: github.Ptr(base64.StdEncoding.EncodeToString([]byte("new content"))),
+	}}
+	filesToUpload := map[types.UploadKey]types.UploadFileContent{
+		{RepoName: repo, BranchPath: "refs/heads/" + baseBranch, CommitStrategy: "pull_request"}: {
+			TargetBranch:   baseBranch,
+			Content:        files,
+			CommitStrategy: "pr",
+		},
+	}
+
+	services.AddFilesToTargetRepos(context.Background(), cfg, filesToUpload, nil, nil)
+
+	info := httpmock.GetCallCountInfo()
+
+	// Should NOT create a new branch or new PR
+	require.Equal(t, 0, test.CountByMethodAndURLRegexp("POST",
+		regexp.MustCompile(`/repos/`+regexp.QuoteMeta(owner)+`/`+regexp.QuoteMeta(repo)+`/git/refs$`),
+	), "should not create a new branch ref")
+	require.Equal(t, 0, test.CountByMethodAndURLRegexp("POST",
+		regexp.MustCompile(`/repos/`+regexp.QuoteMeta(owner)+`/`+regexp.QuoteMeta(repo)+`/pulls$`),
+	), "should not create a new PR")
+
+	// Should commit to the existing branch and update the PR
+	require.Equal(t, 1, info["POST "+commitsURL], "should commit to existing branch")
+	require.Equal(t, 1, info["PATCH "+editPRURL], "should update PR title/body")
+}
+
 func TestDeleteBranchIfExists_NilReference(t *testing.T) {
 	_ = test.WithHTTPMock(t)
 

services/workflow_processor.go

@@ -374,6 +374,10 @@ func (wp *workflowProcessor) addToUploadQueue(
 	msgCtx.CommitSHA = sourceCommitSHA
 	msgCtx.FileCount = len(content.Content)
 
+	// Track previous metadata so we can log when a later workflow overwrites it.
+	prevCommitMsg := content.CommitMessage
+	prevPRTitle := content.PRTitle
+
 	// Render commit message
 	if workflow.CommitStrategy != nil && workflow.CommitStrategy.CommitMessage != "" {
 		content.CommitMessage = wp.messageTemplater.RenderCommitMessage(workflow.CommitStrategy.CommitMessage, msgCtx)
@@ -393,6 +397,24 @@ func (wp *workflowProcessor) addToUploadQueue(
 		content.PRBody = wp.messageTemplater.RenderPRBody(workflow.CommitStrategy.PRBody, msgCtx)
 	}
 
+	// Log when a subsequent workflow in the same batch overwrites PR metadata.
+	if exists && prevCommitMsg != "" && prevCommitMsg != content.CommitMessage {
+		LogInfo("Workflow overwrites batched commit message (last wins)",
+			"workflow", workflow.Name,
+			"target", workflow.Destination.Repo,
+			"prev_commit_message", prevCommitMsg,
+			"new_commit_message", content.CommitMessage,
+		)
+	}
+	if exists && prevPRTitle != "" && prevPRTitle != content.PRTitle {
+		LogInfo("Workflow overwrites batched PR title (last wins)",
+			"workflow", workflow.Name,
+			"target", workflow.Destination.Repo,
+			"prev_pr_title", prevPRTitle,
+			"new_pr_title", content.PRTitle,
+		)
+	}
+
 	// Add back to FileStateService
 	wp.fileStateService.AddFileToUpload(key, content)
 

tests/utils.go

@@ -174,6 +174,18 @@ func MockCreateRef(owner, repo string) string {
 	return url
 }
 
+// MockListOpenPRs mocks the "list open PRs" endpoint, returning the supplied PRs.
+// Pass nil or empty to simulate no existing open PRs.
+func MockListOpenPRs(owner, repo string, prs []map[string]any) {
+	if prs == nil {
+		prs = []map[string]any{}
+	}
+	httpmock.RegisterRegexpResponder("GET",
+		regexp.MustCompile(`^https://api\.github\.com/repos/`+regexp.QuoteMeta(owner)+`/`+regexp.QuoteMeta(repo)+`/pulls\?`),
+		httpmock.NewJsonResponderOrPanic(200, prs),
+	)
+}
+
 // MockPullsAndMerge mocks creating and merging a PR.
 func MockPullsAndMerge(owner, repo string, number int) {
 	httpmock.RegisterResponder("POST",