brainiac 0.0.6 → 0.0.7

data/lib/brainiac/handlers/github.rb

@@ -75,14 +75,12 @@ def handle_github_pr_merged(payload)
   pr_title = pr["title"]
   repo_full_name = payload.dig("repository", "full_name")
 
-  # Only act on merges into the repo's default branch
   default_branch = payload.dig("repository", "default_branch") || "main"
   unless base == default_branch
     LOG.info "PR merged into #{base}, not #{default_branch} — ignoring"
     return [200, { status: "ignored", reason: "not merged into #{default_branch}" }.to_json]
   end
 
-  # Identify project by GitHub repo
   project_result = identify_project_by_repo(repo_full_name)
   unless project_result
     LOG.info "No project found for GitHub repo #{repo_full_name}"
@@ -100,62 +98,53 @@ def handle_github_pr_merged(payload)
 
   internal_id, card_info = result
   card_number = card_info["number"]
-
   unless card_number
     LOG.warn "Card #{internal_id} has no number — can't comment or move"
     return [200, { status: "ignored", reason: "card has no number" }.to_json]
   end
 
   LOG.info "PR merged into main for card ##{card_number} (project: #{project_key}): #{pr_url}"
+  process_merged_pr(card_info, card_number, branch, pr, pr_url, pr_title, project_key, project_config, repo_path)
+
+  [200, { status: "processed", card: card_number, pr: pr_url, action: "merged_to_uat", project: project_key }.to_json]
+rescue StandardError => e
+  LOG.error "Error handling merged PR: #{e.message}"
+  [500, { error: e.message }.to_json]
+end
 
-  # Use the card's assigned agent identity for fizzy interactions
+def process_merged_pr(card_info, card_number, branch, pull_request, pr_url, pr_title, project_key, project_config, repo_path)
   card_agent = card_info["agent"]
   card_fizzy_env = fizzy_env_for(card_agent)
 
-  # Comment with the PR link if not already there
-  if pr_link_already_commented?(card_number, pr_url, chdir: repo_path, env: card_fizzy_env)
-    LOG.info "PR link already on card ##{card_number}, skipping comment"
-  else
+  unless pr_link_already_commented?(card_number, pr_url, chdir: repo_path, env: card_fizzy_env)
     comment_body = "<p>PR merged into main: <a href=\"#{pr_url}\">#{pr_title}</a></p><p>Branch: <code>#{branch}</code></p>"
     run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", comment_body, chdir: repo_path, env: card_fizzy_env)
-    LOG.info "Commented PR link on card ##{card_number} as #{card_agent || "default"}"
   end
 
-  # Move card to UAT column — merged into main means it's deployed to UAT
   mark_card_merged(card_number)
   run_cmd("fizzy", "card", "column", card_number.to_s, "--column", uat_column_id(project_config), chdir: repo_path, env: card_fizzy_env)
   record_self_move(card_number)
-  LOG.info "Moved card ##{card_number} to UAT column as #{card_agent || "default"}"
-
-  # Clean up the primary worktree and any cross-agent review worktrees
   cleanup_card_worktrees(card_number, repo_path: repo_path, primary_worktree: card_info["worktree"], primary_branch: branch)
-
-  # Clear any deployment environments occupied by this card
   clear_deployment_for_card(card_number)
 
-  # Dispatch agent to comment UAT testing steps on the Fizzy card
   agent_name = card_agent || agent_name_for(project_config)
   card_title = card_info["title"] || pr_title
+  dispatch_uat_agent(card_number, card_title, pull_request["number"].to_s, agent_name, project_key, project_config, repo_path)
+end
 
+def dispatch_uat_agent(card_number, card_title, pr_number, agent_name, project_key, project_config, repo_path)
   prompt = render_prompt(PROMPT_GITHUB_UAT,
-                         { "CARD_NUMBER" => card_number,
-                           "CARD_TITLE" => card_title,
-                           "PR_NUMBER" => pr["number"].to_s },
-                         brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, card_title: card_title,
-                                                            project_key: project_key),
-                         agent_name: agent_name,
-                         channel: :fizzy,
+                         { "CARD_NUMBER" => card_number, "CARD_TITLE" => card_title, "PR_NUMBER" => pr_number },
+                         brain_context: build_brain_context(agent_name: agent_name, card_number: card_number,
+                                                            card_title: card_title, project_key: project_key),
+                         agent_name: agent_name, channel: :fizzy,
                          board_key: board_key_for_project(project_config))
 
-  pid, log_file = run_agent(prompt, project_config: project_config, chdir: repo_path, log_name: "uat-#{card_number}", agent_name: agent_name,
+  pid, log_file = run_agent(prompt, project_config: project_config, chdir: repo_path,
+                                    log_name: "uat-#{card_number}", agent_name: agent_name,
                                     source: :fizzy, source_context: { card_number: card_number }, skip_column_move: true)
   register_session("card-#{card_number}", pid, log_file: log_file, agent_name: agent_name)
   LOG.info "Dispatched #{agent_name} for UAT testing steps on card ##{card_number}"
-
-  [200, { status: "processed", card: card_number, pr: pr_url, action: "merged_to_uat", project: project_key }.to_json]
-rescue StandardError => e
-  LOG.error "Error handling merged PR: #{e.message}"
-  [500, { error: e.message }.to_json]
 end
 
 def handle_github_issue_comment(payload)
@@ -166,13 +155,11 @@ def handle_github_issue_comment(payload)
   comment_user = comment.dig("user", "login")
   repo_name = payload.dig("repository", "full_name")
 
-  # Only process if this is a PR (issues have pull_request key when they're PRs)
   unless issue["pull_request"]
     LOG.info "Issue comment on non-PR issue ##{issue["number"]}, ignoring"
     return [200, { status: "ignored", reason: "not a PR comment" }.to_json]
   end
 
-  # Identify project by GitHub repo
   project_result = identify_project_by_repo(repo_name)
   unless project_result
     LOG.info "No project found for GitHub repo #{repo_name}"
@@ -180,12 +167,10 @@ def handle_github_issue_comment(payload)
   end
 
   project_key, project_config = project_result
-
   pr_number = issue["number"]
-  issue["html_url"]
 
-  # Find the card by PR branch
-  pr_data = run_cmd("gh", "api", "/repos/#{repo_name}/pulls/#{pr_number}", "--jq", "{branch: .head.ref}", chdir: project_config["repo_path"])
+  pr_data = run_cmd("gh", "api", "/repos/#{repo_name}/pulls/#{pr_number}", "--jq", "{branch: .head.ref}",
+                    chdir: project_config["repo_path"])
   branch = JSON.parse(pr_data)["branch"]
 
   result = find_card_by_branch(branch)
@@ -198,54 +183,52 @@ def handle_github_issue_comment(payload)
   card_number = card_info["number"]
   worktree = card_info["worktree"]
 
-  # Only process if worktree exists
   unless worktree && File.directory?(worktree)
     LOG.info "No active worktree for PR ##{pr_number}, ignoring comment"
     return [200, { status: "ignored", reason: "no active worktree" }.to_json]
   end
 
-  LOG.info "PR comment from #{comment_user} on PR ##{pr_number} for card ##{card_number} (project: #{project_key})"
-
   card_key = "card-#{card_number}"
   if session_active?(card_key)
     LOG.info "Skipping PR comment on card ##{card_number} — agent session already active"
     return [200, { status: "ignored", reason: "session already active" }.to_json]
   end
 
-  # React in background — don't block the dispatch path
+  LOG.info "PR comment from #{comment_user} on PR ##{pr_number} for card ##{card_number} (project: #{project_key})"
+  dispatch_pr_comment(card_number, card_key, pr_number, comment_id, comment_user, comment_body,
+                      repo_name, worktree, project_key, project_config)
+
+  [200, { status: "processed", card: card_number, pr: pr_number, comment_id: comment_id, project: project_key }.to_json]
+rescue StandardError => e
+  LOG.error "Error handling PR comment: #{e.message}"
+  [500, { error: e.message }.to_json]
+end
+
+def dispatch_pr_comment(card_number, card_key, pr_number, comment_id, comment_user, comment_body,
+                        repo_name, worktree, project_key, project_config)
   Thread.new do
-    run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/issues/comments/#{comment_id}/reactions", "-f", "content=eyes", "-H",
-            "Accept: application/vnd.github+json", chdir: worktree)
-    LOG.info "Added 👀 reaction to comment ##{comment_id}"
+    run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/issues/comments/#{comment_id}/reactions",
+            "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: worktree)
   rescue StandardError => e
     LOG.warn "Could not add reaction to comment: #{e.message}"
   end
 
-  # Detect model override
-  model = detect_model(project_config, text: comment_body)
-  effort = detect_effort(project_config, text: comment_body)
   agent_name = agent_name_for(project_config)
-
   prompt = render_prompt(PROMPT_GITHUB_PR_COMMENT,
-                         { "CARD_NUMBER" => card_number,
-                           "CARD_ID" => card_number,
-                           "COMMENT_CREATOR" => comment_user,
-                           "COMMENT_BODY" => comment_body,
-                           "PR_NUMBER" => pr_number.to_s,
-                           "WORKTREE_PATH" => worktree },
-                         brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, project_key: project_key,
-                                                            comment_body: comment_body),
-                         agent_name: agent_name,
-                         channel: :github)
-
-  pid, log_file = run_agent(prompt, project_config: project_config, chdir: worktree, log_name: "pr-comment-#{pr_number}", model: model, effort: effort, agent_name: agent_name,
-                                    source: :github, source_context: { pr_number: pr_number, repo_name: repo_name, work_dir: worktree })
+                         { "CARD_NUMBER" => card_number, "CARD_ID" => card_number,
+                           "COMMENT_CREATOR" => comment_user, "COMMENT_BODY" => comment_body,
+                           "PR_NUMBER" => pr_number.to_s, "WORKTREE_PATH" => worktree },
+                         brain_context: build_brain_context(agent_name: agent_name, card_number: card_number,
+                                                            project_key: project_key, comment_body: comment_body),
+                         agent_name: agent_name, channel: :github)
+
+  pid, log_file = run_agent(prompt, project_config: project_config, chdir: worktree,
+                                    log_name: "pr-comment-#{pr_number}",
+                                    model: detect_model(project_config, text: comment_body),
+                                    effort: detect_effort(project_config, text: comment_body),
+                                    agent_name: agent_name, source: :github,
+                                    source_context: { pr_number: pr_number, repo_name: repo_name, work_dir: worktree })
   register_session(card_key, pid, log_file: log_file, agent_name: agent_name)
-
-  [200, { status: "processed", card: card_number, pr: pr_number, comment_id: comment_id, project: project_key }.to_json]
-rescue StandardError => e
-  LOG.error "Error handling PR comment: #{e.message}"
-  [500, { error: e.message }.to_json]
 end
 
 def handle_github_workflow_run(payload)
@@ -255,75 +238,70 @@ def handle_github_workflow_run(payload)
   repo_full_name = payload.dig("repository", "full_name")
   run_url = workflow["html_url"]
 
-  # Handle Deploy to Production failure
   if workflow_name == "Deploy to Production" && conclusion == "failure"
-    project_result = identify_project_by_repo(repo_full_name)
-    project_key = project_result ? project_result[0] : repo_full_name
+    project_key = identify_project_by_repo(repo_full_name)&.first || repo_full_name
     send_workflow_failure_notification(project_key, workflow_name, run_url)
-    LOG.info "Deploy to Production failed for #{project_key} — notified Discord"
     return [200, { status: "processed", action: "prod_deploy_failure_notified", project: project_key }.to_json]
   end
 
-  # Handle Deploy to UAT success
   if workflow_name == "Deploy to UAT" && conclusion == "success"
-    project_result = identify_project_by_repo(repo_full_name)
-    project_key = project_result ? project_result[0] : repo_full_name
+    project_key = identify_project_by_repo(repo_full_name)&.first || repo_full_name
     send_uat_deploy_notification(project_key)
-    LOG.info "Deploy to UAT succeeded for #{project_key} — notified Discord"
     return [200, { status: "processed", action: "uat_deploy_notified", project: project_key }.to_json]
   end
 
-  unless conclusion == "success"
-    LOG.info "Workflow '#{workflow_name}' concluded with '#{conclusion}' — ignoring"
-    return [200, { status: "ignored", reason: "conclusion: #{conclusion}" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "conclusion: #{conclusion}" }.to_json] unless conclusion == "success"
 
-  unless workflow_name == "Deploy to Production"
-    LOG.info "Workflow '#{workflow_name}' is not a prod deploy — ignoring"
-    return [200, { status: "ignored", reason: "workflow: #{workflow_name}" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "workflow: #{workflow_name}" }.to_json] unless workflow_name == "Deploy to Production"
 
   project_result = identify_project_by_repo(repo_full_name)
-  unless project_result
-    LOG.info "No project found for GitHub repo #{repo_full_name}"
-    return [200, { status: "ignored", reason: "no matching project" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "no matching project" }.to_json] unless project_result
 
   project_key, project_config = project_result
-  repo_path = project_config["repo_path"]
+  close_uat_cards_after_deploy(project_key, project_config)
+rescue StandardError => e
+  LOG.error "Error handling workflow run: #{e.message}"
+  [500, { error: e.message }.to_json]
+end
 
-  # List all cards in the UAT column
-  output = run_cmd("fizzy", "card", "list", "--column", uat_column_id(project_config), "--all", chdir: repo_path, env: default_fizzy_env)
-  cards = JSON.parse(output)
-  card_list = cards["data"] || []
+def close_uat_cards_after_deploy(project_key, project_config)
+  repo_path = project_config["repo_path"]
+  output = run_cmd("fizzy", "card", "list", "--column", uat_column_id(project_config), "--all",
+                   chdir: repo_path, env: default_fizzy_env)
+  card_list = JSON.parse(output)["data"] || []
 
   if card_list.empty?
     LOG.info "No cards in UAT column — nothing to close"
     return [200, { status: "processed", action: "no_uat_cards", project: project_key }.to_json]
   end
 
+  closed_cards = close_and_cleanup_uat_cards(card_list, repo_path)
+  send_deploy_notification(project_key, closed_cards) if closed_cards.any?
+
+  LOG.info "Prod deploy complete — closed #{closed_cards.size} UAT cards: #{closed_cards.map { |c| c[:number] }.join(", ")}"
+  [200, { status: "processed", action: "prod_deploy_closed_uat",
+          closed_cards: closed_cards.map { |c| c[:number] }, project: project_key }.to_json]
+end
+
+def close_and_cleanup_uat_cards(card_list, repo_path)
   closed_cards = []
   map = load_card_map
+
   card_list.each do |card|
     card_number = card["number"]
     next unless card_number
 
-    # Try to find the card in our map to get the assigned agent
     map_entry = map.values.find { |info| info["number"] == card_number }
     agent_name = map_entry["agent"] if map_entry
-
     env = agent_name ? fizzy_env_for(agent_name) : default_fizzy_env
 
-    comment_body = "<p>✅ Deployed to production. Closing card.</p>"
-    run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", comment_body, chdir: repo_path, env: env)
+    run_cmd("fizzy", "comment", "create", "--card", card_number.to_s,
+            "--body", "<p>✅ Deployed to production. Closing card.</p>", chdir: repo_path, env: env)
     run_cmd("fizzy", "card", "close", card_number.to_s, chdir: repo_path, env: env)
 
-    # Clean up worktrees (primary + cross-agent review)
-    primary_worktree = map_entry&.dig("worktree")
-    primary_branch = map_entry&.dig("branch")
-    cleanup_card_worktrees(card_number, repo_path: repo_path, primary_worktree: primary_worktree, primary_branch: primary_branch)
+    cleanup_card_worktrees(card_number, repo_path: repo_path,
+                                        primary_worktree: map_entry&.dig("worktree"), primary_branch: map_entry&.dig("branch"))
 
-    # Clean up card map entry
     if map_entry
       internal_id = map.key(map_entry)
       map.delete(internal_id)
@@ -334,14 +312,7 @@ def handle_github_workflow_run(payload)
   end
 
   save_card_map(map) if closed_cards.any?
-
-  send_deploy_notification(project_key, closed_cards) if closed_cards.any?
-
-  LOG.info "Prod deploy complete — closed #{closed_cards.size} UAT cards: #{closed_cards.map { |c| c[:number] }.join(", ")}"
-  [200, { status: "processed", action: "prod_deploy_closed_uat", closed_cards: closed_cards.map { |c| c[:number] }, project: project_key }.to_json]
-rescue StandardError => e
-  LOG.error "Error handling workflow run: #{e.message}"
-  [500, { error: e.message }.to_json]
+  closed_cards
 end
 
 def send_deploy_notification(project_key, closed_cards)
@@ -402,171 +373,137 @@ def handle_github_pr_review_submitted(payload)
   review = payload["review"]
   branch = pr.dig("head", "ref")
   pr_number = pr["number"]
-  pr["html_url"]
   repo_name = payload.dig("repository", "full_name")
   review_state = review["state"]
   reviewer = review.dig("user", "login")
 
-  # Only act on submitted reviews (not just comments)
-  unless %w[changes_requested commented].include?(review_state)
-    LOG.info "PR review state is '#{review_state}', ignoring"
-    return [200, { status: "ignored", reason: "review state: #{review_state}" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "review state: #{review_state}" }.to_json] unless %w[changes_requested commented].include?(review_state)
 
-  # Identify project by GitHub repo
   project_result = identify_project_by_repo(repo_name)
-  unless project_result
-    LOG.info "No project found for GitHub repo #{repo_name}"
-    return [200, { status: "ignored", reason: "no matching project" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "no matching project" }.to_json] unless project_result
 
   project_key, project_config = project_result
   repo_path = project_config["repo_path"]
 
   result = find_card_by_branch(branch)
-  unless result
-    LOG.info "No Fizzy card found for PR branch #{branch}"
-    return [200, { status: "ignored", reason: "no matching card" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "no matching card" }.to_json] unless result
 
   internal_id, card_info = result
   card_number = card_info["number"]
-  worktree = card_info["worktree"]
-
   unless card_number
     LOG.warn "Card #{internal_id} has no number — can't comment"
     return [200, { status: "ignored", reason: "card has no number" }.to_json]
   end
 
+  card_key = "card-#{card_number}"
+  return [200, { status: "ignored", reason: "session already active" }.to_json] if session_active?(card_key)
+
   LOG.info "PR review submitted by #{reviewer} on PR ##{pr_number} for card ##{card_number} (project: #{project_key})"
+  dispatch_pr_review(card_number, card_key, card_info, pr_number, review, reviewer, repo_name, project_key, project_config, repo_path)
 
-  card_key = "card-#{card_number}"
-  if session_active?(card_key)
-    LOG.info "Skipping PR review on card ##{card_number} — agent session already active"
-    return [200, { status: "ignored", reason: "session already active" }.to_json]
-  end
+  [200, { status: "processed", card: card_number, pr: pr_number, reviewer: reviewer, project: project_key }.to_json]
+rescue StandardError => e
+  LOG.error "Error handling PR review: #{e.message}"
+  [500, { error: e.message }.to_json]
+end
 
-  # React to the review with 👀 to show we're starting
+def dispatch_pr_review(card_number, card_key, card_info, pr_number, review, reviewer, repo_name, project_key, project_config, repo_path)
   review_id = review["id"]
-  # React in background — don't block the dispatch path
   Thread.new do
-    run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/pulls/reviews/#{review_id}/reactions", "-f", "content=eyes", "-H",
-            "Accept: application/vnd.github+json", chdir: repo_path)
-    LOG.info "Added 👀 reaction to review ##{review_id}"
+    run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/pulls/reviews/#{review_id}/reactions",
+            "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: repo_path)
   rescue StandardError => e
     LOG.warn "Could not add reaction to review: #{e.message}"
   end
 
-  # Post status to Fizzy in background — don't block the dispatch path
   agent_name = agent_name_for(project_config)
   Thread.new do
     status_comment = "<p>🔄 Code review received from @#{reviewer}. Updates in progress...</p>"
-    run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", status_comment, chdir: repo_path, env: fizzy_env_for(agent_name))
-    LOG.info "Posted status update to card ##{card_number} as #{agent_name}"
+    run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", status_comment,
+            chdir: repo_path, env: fizzy_env_for(agent_name))
   rescue StandardError => e
     LOG.warn "Could not post status update to card ##{card_number}: #{e.message}"
   end
 
-  # Fetch all review comments (line-specific comments)
-  review_comments = fetch_pr_review_comments(pr_number, repo_name)
+  review_context = build_review_context(reviewer, review, pr_number, repo_name)
+  worktree = card_info["worktree"]
+  work_dir = worktree && File.directory?(worktree) ? worktree : repo_path
 
-  # Build context for the agent
-  review_context = "GitHub PR Review from @#{reviewer}:\n\n"
-  review_context += "Review body:\n#{review["body"]}\n\n" if review["body"] && !review["body"].empty?
+  prompt = render_prompt(PROMPT_GITHUB_PR_REVIEW,
+                         { "CARD_NUMBER" => card_number, "CARD_ID" => card_number,
+                           "COMMENT_CREATOR" => reviewer, "REVIEW_CONTEXT" => review_context,
+                           "PR_NUMBER" => pr_number.to_s, "WORKTREE_PATH" => work_dir },
+                         brain_context: build_brain_context(agent_name: agent_name, card_number: card_number,
+                                                            project_key: project_key),
+                         agent_name: agent_name, channel: :github)
 
+  pid, log_file = run_agent(prompt, project_config: project_config, chdir: work_dir,
+                                    log_name: "review-#{card_number}", agent_name: agent_name,
+                                    source: :github,
+                                    source_context: { pr_number: pr_number, repo_name: repo_name, work_dir: work_dir })
+  register_session(card_key, pid, log_file: log_file, agent_name: agent_name)
+end
+
+def build_review_context(reviewer, review, pr_number, repo_name)
+  context = "GitHub PR Review from @#{reviewer}:\n\n"
+  context += "Review body:\n#{review["body"]}\n\n" if review["body"] && !review["body"].empty?
+
+  review_comments = fetch_pr_review_comments(pr_number, repo_name)
   if review_comments.any?
-    review_context += "Line-specific comments:\n"
+    context += "Line-specific comments:\n"
     review_comments.each do |comment|
-      review_context += "- #{comment["path"]}:#{comment["line"]} (@#{comment["user"]}): #{comment["body"]}\n"
+      context += "- #{comment["path"]}:#{comment["line"]} (@#{comment["user"]}): #{comment["body"]}\n"
     end
   end
-
-  # Determine working directory
-  work_dir = worktree && File.directory?(worktree) ? worktree : repo_path
-
-  prompt = render_prompt(PROMPT_GITHUB_PR_REVIEW,
-                         { "CARD_NUMBER" => card_number,
-                           "CARD_ID" => card_number,
-                           "COMMENT_CREATOR" => reviewer,
-                           "REVIEW_CONTEXT" => review_context,
-                           "PR_NUMBER" => pr_number.to_s,
-                           "WORKTREE_PATH" => work_dir },
-                         brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, project_key: project_key),
-                         agent_name: agent_name,
-                         channel: :github)
-
-  pid, log_file = run_agent(prompt, project_config: project_config, chdir: work_dir, log_name: "review-#{card_number}", agent_name: agent_name,
-                                    source: :github, source_context: { pr_number: pr_number, repo_name: repo_name, work_dir: work_dir })
-  register_session(card_key, pid, log_file: log_file, agent_name: agent_name)
-
-  [200, { status: "processed", card: card_number, pr: pr_number, reviewer: reviewer, project: project_key }.to_json]
-rescue StandardError => e
-  LOG.error "Error handling PR review: #{e.message}"
-  [500, { error: e.message }.to_json]
+  context
 end
 
-# Auto-deploy when a PR gets new commits (synchronize event) if the card is already on a dev env.
 def handle_github_pr_synchronized(payload)
   pr = payload["pull_request"]
   branch = pr.dig("head", "ref")
-  payload.dig("repository", "full_name")
 
   result = find_card_by_branch(branch)
-  unless result
-    LOG.info "[PR Sync] No card found for branch #{branch}"
-    return [200, { status: "ignored", reason: "no matching card" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "no matching card" }.to_json] unless result
 
   _internal_id, card_info = result
   card_number = card_info["number"]
   worktree = card_info["worktree"]
 
-  unless worktree && File.directory?(worktree)
-    LOG.info "[PR Sync] No worktree for card ##{card_number}"
-    return [200, { status: "ignored", reason: "no worktree" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "no worktree" }.to_json] unless worktree && File.directory?(worktree)
 
-  # Check if this card is deployed to any environment
   state = load_deployment_state
   config = DEPLOYMENTS_CONFIG["environments"] || {}
   env_key = state.find { |_k, v| v["card_number"] == card_number && v["status"] == "occupied" }&.first
 
-  unless env_key
-    LOG.info "[PR Sync] Card ##{card_number} not deployed to any environment — skipping"
-    return [200, { status: "ignored", reason: "card not deployed" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "card not deployed" }.to_json] unless env_key
 
-  # Only deploy if this machine owns the environment
   env_owner = config.dig(env_key, "owner")
-  unless env_owner && env_owner.downcase == AI_AGENT_NAME.downcase
-    LOG.info "[PR Sync] Skipping #{env_key} — owner is #{env_owner.inspect}, this machine is #{AI_AGENT_NAME}"
-    return [200, { status: "ignored", reason: "not env owner" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "not env owner" }.to_json] unless env_owner && env_owner.downcase == AI_AGENT_NAME.downcase
 
-  # Cooldown — debounce rapid pushes
-  if on_deploy_cooldown?(env_key)
-    LOG.info "[PR Sync] Skipping deploy to #{env_key} — within #{DEPLOY_COOLDOWN}s cooldown"
-    return [200, { status: "ignored", reason: "deploy cooldown" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "deploy cooldown" }.to_json] if on_deploy_cooldown?(env_key)
 
   touch_deploy_cooldown(env_key)
 
-  # Pull latest commits into the worktree
   system("git", "pull", "--ff-only", chdir: worktree)
-
   deploy_script = File.join(worktree, "scripts", "deploy.sh")
-  unless File.exist?(deploy_script)
-    LOG.warn "[PR Sync] No deploy script at #{deploy_script}"
-    return [200, { status: "ignored", reason: "no deploy script" }.to_json]
-  end
+  return [200, { status: "ignored", reason: "no deploy script" }.to_json] unless File.exist?(deploy_script)
 
   LOG.info "[PR Sync] Auto-deploying card ##{card_number} to #{env_key} (PR updated)"
   mark_deploying(env_key, worktree_path: worktree)
+  run_pr_sync_deploy(env_key, card_number, worktree, config)
+
+  [200, { status: "processed", action: "pr_sync_deploy", card: card_number, env: env_key }.to_json]
+rescue StandardError => e
+  LOG.error "[PR Sync] Error: #{e.message}"
+  [500, { error: e.message }.to_json]
+end
 
+def run_pr_sync_deploy(env_key, card_number, worktree, config)
   Thread.new do
     deploy_env = {}
     aws_profile = config.dig(env_key, "aws_profile")
     deploy_env["AWS_PROFILE"] = aws_profile if aws_profile
+    deploy_script = File.join(worktree, "scripts", "deploy.sh")
 
     stdout, stderr, status = Open3.capture3(deploy_env, deploy_script, env_key, chdir: worktree)
 
@@ -574,25 +511,25 @@ def handle_github_pr_synchronized(payload)
       deploy_to_environment(env_key, worktree_path: worktree, deployed_by: "pr-sync")
       LOG.info "[PR Sync] Deploy to #{env_key} succeeded for card ##{card_number}"
     elsif terraform_lock_error?(stdout, stderr)
-      lock_file = File.join(worktree, "infrastructure/#{env_key}/.terraform.lock.hcl")
-      FileUtils.rm_f(lock_file)
-      Open3.capture3("terraform", "init", "-upgrade", chdir: File.join(worktree, "infrastructure/#{env_key}"))
-      stdout2, stderr2, status2 = Open3.capture3(deploy_env, deploy_script, env_key, chdir: worktree)
-      if status2.success?
-        deploy_to_environment(env_key, worktree_path: worktree, deployed_by: "pr-sync")
-        LOG.info "[PR Sync] Deploy to #{env_key} succeeded (after terraform lock fix) for card ##{card_number}"
-      else
-        record_deploy_failure(env_key, worktree_path: worktree, stdout: stdout2, stderr: stderr2)
-        LOG.error "[PR Sync] Deploy to #{env_key} failed (after retry) for card ##{card_number}"
-      end
+      retry_pr_sync_deploy(deploy_env, deploy_script, env_key, card_number, worktree)
     else
       record_deploy_failure(env_key, worktree_path: worktree, stdout: stdout, stderr: stderr)
       LOG.error "[PR Sync] Deploy to #{env_key} failed for card ##{card_number}"
     end
   end
+end
 
-  [200, { status: "processed", action: "pr_sync_deploy", card: card_number, env: env_key }.to_json]
-rescue StandardError => e
-  LOG.error "[PR Sync] Error: #{e.message}"
-  [500, { error: e.message }.to_json]
+def retry_pr_sync_deploy(deploy_env, deploy_script, env_key, card_number, worktree)
+  infra_dir = File.join(worktree, "infrastructure/#{env_key}")
+  FileUtils.rm_f(File.join(infra_dir, ".terraform.lock.hcl"))
+  Open3.capture3("terraform", "init", "-upgrade", chdir: infra_dir)
+  stdout, stderr, status = Open3.capture3(deploy_env, deploy_script, env_key, chdir: worktree)
+
+  if status.success?
+    deploy_to_environment(env_key, worktree_path: worktree, deployed_by: "pr-sync")
+    LOG.info "[PR Sync] Deploy to #{env_key} succeeded (after terraform lock fix) for card ##{card_number}"
+  else
+    record_deploy_failure(env_key, worktree_path: worktree, stdout: stdout, stderr: stderr)
+    LOG.error "[PR Sync] Deploy to #{env_key} failed (after retry) for card ##{card_number}"
+  end
 end