carson 3.27.1 → 3.28.0

data/lib/carson/runtime/govern.rb

@@ -18,12 +18,12 @@ module Carson
 			def govern_cycle!( dry_run:, json_output: )
 				repositories = governed_repo_paths
 				repositories = [ repository_record.path ] if repositories.empty?
-				print_header "Governing #{repositories.length} repo#{plural_suffix( count: repositories.length )}"
+				print_header "Governing #{repositories.length} repo#{plural_suffix( count: repositories.length )}" unless json_output
 
 				report = {
 					cycle_at: Time.now.utc.iso8601,
 					dry_run: dry_run,
-					repositories: repositories.map { |path| govern_repo!( repo_path: path, dry_run: dry_run ) }
+					repositories: repositories.map { |path| govern_repo!( repo_path: path, dry_run: dry_run, silent: json_output ) }
 				}
 
 				if json_output
@@ -62,7 +62,7 @@ module Carson
 				end.compact
 			end
 
-			def govern_repo!( repo_path:, dry_run: )
+			def govern_repo!( repo_path:, dry_run:, silent: false )
 				scoped_runtime = repo_runtime_for( repo_path: repo_path )
 				repository = Repository.new( path: repo_path, runtime: scoped_runtime )
 				deliveries = scoped_runtime.ledger.active_deliveries( repo_path: repo_path )
@@ -75,11 +75,11 @@ module Carson
 				}
 
 				if deliveries.empty?
-					puts_line "#{repository.name}: no active deliveries"
+					puts_line "#{repository.name}: no active deliveries" unless silent
 					return repo_report
 				end
 
-				puts_line "#{repository.name}: #{deliveries.length} active deliver#{deliveries.length == 1 ? 'y' : 'ies'}"
+				puts_line "#{repository.name}: #{deliveries.length} active deliver#{deliveries.length == 1 ? 'y' : 'ies'}" unless silent
 
 				reconciled = deliveries.map { |item| scoped_runtime.send( :reconcile_delivery!, delivery: item ) }
 				next_to_integrate = reconciled.find( &:ready? )&.key
@@ -122,7 +122,10 @@ module Carson
 						delivery: delivery,
 						status: "integrated",
 						integrated_at: Time.now.utc.iso8601,
-						summary: "integrated into #{config.main_branch}"
+						summary: "integrated into #{config.main_branch}",
+						pull_request_state: "MERGED",
+						pull_request_draft: false,
+						pull_request_merged_at: pr_state[ "mergedAt" ]
 					)
 				end
 
@@ -131,47 +134,67 @@ module Carson
 						delivery: delivery,
 						status: "failed",
 						cause: "policy",
-						summary: "pull request closed without integration"
+						summary: "pull request closed without integration",
+						pull_request_state: "CLOSED",
+						pull_request_draft: pr_state[ "isDraft" ],
+						pull_request_merged_at: pr_state[ "mergedAt" ]
 					)
 				end
 
 				assess_delivery!( delivery: delivery, branch_name: delivery.branch )
 			end
 
-			def decide_delivery_action( delivery:, repo_path:, dry_run:, next_to_integrate: )
-				report = {
-					key: delivery.key,
-					branch: delivery.branch,
-					status: delivery.status,
-					summary: delivery.summary,
-					revision_count: delivery.revision_count,
-					action: "none"
-				}
+				def decide_delivery_action( delivery:, repo_path:, dry_run:, next_to_integrate: )
+					report = {
+						key: delivery.key,
+						branch: delivery.branch,
+						status: delivery.status,
+						cause: delivery.cause,
+						summary: delivery.summary,
+						revision_count: delivery.revision_count,
+						action: "none"
+					}
 
 				if delivery.superseded? || delivery.integrated? || delivery.failed?
 					return report
 				end
 
-				if delivery.ready? && delivery.key == next_to_integrate
-					report[ :action ] = dry_run ? "would_integrate" : "integrate"
-					report[ :status ] = execute_delivery_action!( action: report[ :action ], delivery: delivery, repo_path: repo_path, dry_run: dry_run ).status unless dry_run
-					return report
-				end
-
-				if delivery.blocked?
-					if merge_blocked_delivery?( delivery: delivery )
-						report[ :action ] = dry_run ? "would_hold" : "hold"
+					if delivery.ready? && delivery.key == next_to_integrate
+						report[ :action ] = dry_run ? "would_integrate" : "integrate"
+						unless dry_run
+							updated = execute_delivery_action!( action: report[ :action ], delivery: delivery, repo_path: repo_path, dry_run: dry_run )
+							report[ :status ] = updated.status
+							report[ :cause ] = updated.cause
+							report[ :summary ] = updated.summary
+							report[ :merge_proof ] = merge_proof_payload( proof: updated.merge_proof ) if updated.integrated? && updated.merge_proof
+						end
 						return report
 					end
 
-					if delivery.revision_count >= 3
-						report[ :action ] = dry_run ? "would_escalate" : "escalate"
-						report[ :status ] = execute_delivery_action!( action: report[ :action ], delivery: delivery, repo_path: repo_path, dry_run: dry_run ).status unless dry_run
-					else
-						report[ :action ] = dry_run ? "would_revise" : "revise"
-						report[ :status ] = execute_delivery_action!( action: report[ :action ], delivery: delivery, repo_path: repo_path, dry_run: dry_run ).status unless dry_run
+					if delivery.blocked?
+						if held_delivery?( delivery: delivery )
+							report[ :action ] = dry_run ? "would_hold" : "hold"
+							return report
+						end
+
+						if delivery.revision_count >= 3
+							report[ :action ] = dry_run ? "would_escalate" : "escalate"
+							unless dry_run
+								updated = execute_delivery_action!( action: report[ :action ], delivery: delivery, repo_path: repo_path, dry_run: dry_run )
+								report[ :status ] = updated.status
+								report[ :cause ] = updated.cause
+								report[ :summary ] = updated.summary
+							end
+						else
+							report[ :action ] = dry_run ? "would_revise" : "revise"
+							unless dry_run
+								updated = execute_delivery_action!( action: report[ :action ], delivery: delivery, repo_path: repo_path, dry_run: dry_run )
+								report[ :status ] = updated.status
+								report[ :cause ] = updated.cause
+								report[ :summary ] = updated.summary
+							end
+						end
 					end
-				end
 
 				report
 			end
@@ -191,23 +214,51 @@ module Carson
 				end
 			end
 
-			def integrate_delivery!( delivery:, repo_path: )
-				result = {}
-				prepared = ledger.update_delivery(
-					delivery: delivery,
-					status: "integrating",
-					summary: "integrating into #{config.main_branch}"
-				)
+				def integrate_delivery!( delivery:, repo_path: )
+					result = {}
+					freshness = assess_branch_freshness(
+						head_ref: delivery.head || delivery.branch,
+						remote: config.git_remote,
+						main: config.main_branch
+					)
+					unless freshness.fetch( :ready )
+						return ledger.update_delivery(
+							delivery: delivery,
+							status: "gated",
+							cause: "freshness",
+							summary: freshness.fetch( :summary )
+						)
+					end
+
+					prepared = ledger.update_delivery(
+						delivery: delivery,
+						status: "integrating",
+						summary: "integrating into #{config.main_branch}"
+					)
 				merge_exit = merge_pr!( number: prepared.pull_request_number, result: result )
 				if merge_exit == EXIT_OK
 					integrated = ledger.update_delivery(
 						delivery: prepared,
 						status: "integrated",
 						integrated_at: Time.now.utc.iso8601,
-						summary: "integrated into #{config.main_branch}"
+						summary: "integrated into #{config.main_branch}",
+						pull_request_state: "MERGED",
+						pull_request_draft: false,
+						pull_request_merged_at: Time.now.utc.iso8601
+					)
+					housekeep_result = housekeep_repo!( repo_path: repo_path )
+					proof = if housekeep_result.is_a?( Hash ) && housekeep_result[ :sync_status ] != "ok"
+						merge_proof_unavailable(
+							main_ref: config.main_branch,
+							summary: "proof unavailable — local #{config.main_branch} sync did not complete."
+						)
+					else
+						merge_proof_for_branch( branch: integrated.branch, main_ref: config.main_branch )
+					end
+					ledger.update_delivery(
+						delivery: integrated,
+						merge_proof: proof
 					)
-					housekeep_repo!( repo_path: repo_path )
-					integrated
 				else
 					ledger.update_delivery(
 						delivery: prepared,
@@ -288,9 +339,9 @@ module Carson
 				end
 			end
 
-			def merge_blocked_delivery?( delivery: )
-				delivery.cause == "merge"
-			end
+				def held_delivery?( delivery: )
+					[ "merge", "freshness" ].include?( delivery.cause )
+				end
 
 			def housekeep_repo!( repo_path: )
 				scoped_runtime = repo_runtime_for( repo_path: repo_path )
@@ -435,36 +486,37 @@ module Carson
 
 					next if repo_report[ :deliveries ].empty?
 
-					repo_report[ :deliveries ].each do |delivery|
-						action_text = format_govern_action( status: delivery[ :status ], action: delivery[ :action ] )
-						puts_line "#{repo_report[ :repository ]}/#{delivery[ :branch ]} — #{action_text}"
-						puts_line "  #{delivery[ :summary ]}" unless delivery[ :summary ].to_s.empty?
+						repo_report[ :deliveries ].each do |delivery|
+							action_text = format_govern_action( status: delivery[ :status ], action: delivery[ :action ], cause: delivery[ :cause ] )
+							puts_line "#{repo_report[ :repository ]}/#{delivery[ :branch ]} — #{action_text}"
+							puts_line "  #{delivery[ :summary ]}" unless delivery[ :summary ].to_s.empty?
+							puts_line "  Merge proof: #{delivery.dig( :merge_proof, :summary )}" if delivery[ :merge_proof ]
+						end
 					end
 				end
-			end
 
-			def format_govern_action( status:, action: )
-				case action
-				when "integrate"
-					format_govern_integration_outcome( status: status )
-				when "would_integrate" then "ready to integrate (dry run)"
-				when "hold" then "held at gate"
-				when "would_hold" then "would hold at gate (dry run)"
-				when "revise" then "revision dispatched"
-				when "would_revise" then "would revise (dry run)"
+				def format_govern_action( status:, action:, cause: )
+					case action
+					when "integrate"
+						format_govern_integration_outcome( status: status, cause: cause )
+					when "would_integrate" then "ready to integrate (dry run)"
+					when "hold" then cause == "freshness" ? "refresh required" : "held at gate"
+					when "would_hold" then cause == "freshness" ? "would require refresh (dry run)" : "would hold at gate (dry run)"
+					when "revise" then "revision dispatched"
+					when "would_revise" then "would revise (dry run)"
 				when "escalate" then "escalated"
 				when "would_escalate" then "would escalate (dry run)"
 				else status
 				end
 			end
 
-			def format_govern_integration_outcome( status: )
-				case status
-				when "integrated" then "integrated"
-				when "gated" then "held at gate"
-				when "failed" then "integration failed"
-				when "escalated" then "integration escalated"
-				else status
+				def format_govern_integration_outcome( status:, cause: )
+					case status
+					when "integrated" then "integrated"
+					when "gated" then cause == "freshness" ? "refresh required" : "held at gate"
+					when "failed" then "integration failed"
+					when "escalated" then "integration escalated"
+					else status
 				end
 			end
 		end

data/lib/carson/runtime/local/merge_proof.rb

@@ -0,0 +1,199 @@
+# Shared local merge-proof detection for commands that need content-aware "already on main" evidence.
+module Carson
+	class Runtime
+		module Local
+			def merge_proof_for_branch( branch:, main_ref: config.main_branch )
+				return merge_proof_not_applicable( main_ref: main_ref ) if branch.to_s == main_ref.to_s
+
+				candidate = merge_proof_candidate( branch: branch, main_ref: main_ref )
+				return candidate if candidate.fetch( :basis ) == "unavailable"
+
+				trust = merge_proof_main_trust( main_ref: main_ref )
+				return candidate if trust.fetch( :trusted )
+
+				merge_proof_hash(
+					applicable: true,
+					proven: false,
+					basis: "unavailable",
+					summary: trust.fetch( :summary ),
+					main_branch: main_ref,
+					changed_files_count: candidate.fetch( :changed_files_count, 0 )
+				)
+			end
+
+			def branch_absorbed_into_main?( branch: )
+				merge_proof_for_branch( branch: branch ).fetch( :proven )
+			end
+
+		private
+
+			def merge_proof_candidate( branch:, main_ref: )
+				_, _, ancestor_success, ancestor_exit = git_run( "merge-base", "--is-ancestor", branch, main_ref )
+				merge_base_text, merge_base_error, merge_base_success, = git_run( "merge-base", main_ref, branch )
+				unless merge_base_success
+					return merge_proof_unavailable(
+						main_ref: main_ref,
+						summary: merge_proof_command_failure_summary(
+							remote_ref: merge_proof_remote_ref( main_ref: main_ref ),
+							fallback: "proof unavailable — could not determine merge-base with #{main_ref}.",
+							error_text: merge_base_error
+						)
+					)
+				end
+
+				merge_base = merge_base_text.to_s.strip
+				return merge_proof_unavailable( main_ref: main_ref, summary: "proof unavailable — merge-base with #{main_ref} is empty." ) if merge_base.empty?
+
+				changed_text, changed_error, changed_success, = git_run( "diff", "--name-only", merge_base, branch )
+				unless changed_success
+					return merge_proof_unavailable(
+						main_ref: main_ref,
+						summary: merge_proof_command_failure_summary(
+							remote_ref: merge_proof_remote_ref( main_ref: main_ref ),
+							fallback: "proof unavailable — could not list branch changes against #{main_ref}.",
+							error_text: changed_error
+						)
+					)
+				end
+
+				changed_files = changed_text.to_s.lines.map( &:strip ).reject( &:empty? )
+				changed_files_count = changed_files.length
+
+				if ancestor_success
+					return merge_proof_hash(
+						applicable: true,
+						proven: true,
+						basis: "ancestor",
+						summary: "proven on main — branch tip is already on #{main_ref}.",
+						main_branch: main_ref,
+						changed_files_count: changed_files_count
+					)
+				end
+
+				if ancestor_exit != 1
+					return merge_proof_unavailable(
+						main_ref: main_ref,
+						summary: "proof unavailable — could not verify whether #{branch} is already on #{main_ref}.",
+						changed_files_count: changed_files_count
+					)
+				end
+
+				if changed_files.empty?
+					return merge_proof_hash(
+						applicable: true,
+						proven: true,
+						basis: "no_changes",
+						summary: "proven on main — branch has no unique changes.",
+						main_branch: main_ref,
+						changed_files_count: 0
+					)
+				end
+
+				_, _, identical, identical_exit = git_run( "diff", "--quiet", branch, main_ref, "--", *changed_files )
+				if identical
+					return merge_proof_hash(
+						applicable: true,
+						proven: true,
+						basis: "content_identical",
+						summary: "proven on main — #{changed_files_count} changed file#{plural_suffix( count: changed_files_count )} already #{merge_proof_files_verb( count: changed_files_count, singular: 'matches', plural: 'match' )} #{main_ref}.",
+						main_branch: main_ref,
+						changed_files_count: changed_files_count
+					)
+				end
+
+				if identical_exit == 1
+					return merge_proof_hash(
+						applicable: true,
+						proven: false,
+						basis: "content_differs",
+						summary: "not proven on main — #{changed_files_count} changed file#{plural_suffix( count: changed_files_count )} still #{merge_proof_files_verb( count: changed_files_count, singular: 'differs', plural: 'differ' )} from #{main_ref}.",
+						main_branch: main_ref,
+						changed_files_count: changed_files_count
+					)
+				end
+
+				merge_proof_unavailable(
+					main_ref: main_ref,
+					summary: "proof unavailable — could not compare branch content against #{main_ref}.",
+					changed_files_count: changed_files_count
+				)
+			end
+
+			def merge_proof_main_trust( main_ref: )
+				remote_ref = merge_proof_remote_ref( main_ref: main_ref )
+				_, _, remote_exists, = git_run( "rev-parse", "--verify", remote_ref )
+				unless remote_exists
+					return {
+						trusted: false,
+						summary: "proof unavailable — no local #{remote_ref} reference."
+					}
+				end
+
+				ahead_behind, _, sync_success, = git_run( "rev-list", "--left-right", "--count", "#{main_ref}...#{remote_ref}" )
+				unless sync_success
+					return {
+						trusted: false,
+						summary: "proof unavailable — could not compare local #{main_ref} with #{remote_ref}."
+					}
+				end
+
+				ahead, behind = ahead_behind.to_s.strip.split.map( &:to_i )
+				return { trusted: true, summary: "local #{main_ref} is in sync with #{remote_ref}." } if ahead.zero? && behind.zero?
+
+				{
+					trusted: false,
+					summary: "proof unavailable — local #{main_ref} is not in sync with #{remote_ref}."
+				}
+			end
+
+			def merge_proof_remote_ref( main_ref: )
+				"#{config.git_remote}/#{main_ref}"
+			end
+
+			def merge_proof_not_applicable( main_ref: )
+				merge_proof_hash(
+					applicable: false,
+					proven: false,
+					basis: "not_applicable",
+					summary: "not applicable — current branch is #{main_ref}.",
+					main_branch: main_ref,
+					changed_files_count: 0
+				)
+			end
+
+			def merge_proof_unavailable( main_ref:, summary:, changed_files_count: 0 )
+				merge_proof_hash(
+					applicable: true,
+					proven: false,
+					basis: "unavailable",
+					summary: summary,
+					main_branch: main_ref,
+					changed_files_count: changed_files_count
+				)
+			end
+
+			def merge_proof_hash( applicable:, proven:, basis:, summary:, main_branch:, changed_files_count: )
+				{
+					applicable: applicable,
+					proven: proven,
+					basis: basis,
+					summary: summary,
+					main_branch: main_branch,
+					changed_files_count: changed_files_count.to_i
+				}
+			end
+
+			def merge_proof_files_verb( count:, singular:, plural: )
+				count.to_i == 1 ? singular : plural
+			end
+
+			def merge_proof_command_failure_summary( remote_ref:, fallback:, error_text: )
+				text = error_text.to_s.strip
+				return fallback if text.empty?
+				return "proof unavailable — local main is not in sync with #{remote_ref}." if text.include?( remote_ref ) && text.include?( "not a valid object name" )
+
+				fallback
+			end
+		end
+	end
+end

data/lib/carson/runtime/local/sync.rb

@@ -22,6 +22,15 @@ module Carson
 						exit_code: EXIT_BLOCK, json_output: json_output
 					)
 				end
+
+				attachment = ensure_main_attached!
+				unless attachment.fetch( :ok )
+					return sync_finish(
+						result: { command: "sync", status: "block", error: attachment.fetch( :error ), recovery: attachment[ :recovery ] },
+						exit_code: EXIT_BLOCK, json_output: json_output
+					)
+				end
+
 				start_branch = current_branch
 				switched = false
 				sync_git!( "fetch", config.git_remote, "--prune", json_output: json_output )
@@ -186,6 +195,86 @@ module Carson
 				success
 			end
 
+			# Ensures the main worktree is attached to the main branch, not detached HEAD
+			# or on a wrong branch.
+			#
+			# Returns { ok: true } when already attached or successfully reattached.
+			# Returns { ok: false, error: "...", recovery: "..." } when blocked.
+			#
+			# Why this exists: git pull --ff-only on a detached HEAD succeeds (exit 0)
+			# but fast-forwards the detached HEAD instead of updating the local main
+			# branch ref. This means sync_after_merge! can report synced: true while
+			# local main is still stale.
+			def ensure_main_attached!( main_root: nil )
+				main_root ||= repo_root
+				main = config.main_branch
+
+				head_ref, _, head_success, = Open3.capture3( "git", "-C", main_root, "rev-parse", "--abbrev-ref", "HEAD" )
+				return { ok: true } unless head_success
+
+				head_ref = head_ref.strip
+				return { ok: true } if head_ref == main
+
+				if head_ref != "HEAD"
+					# On a wrong branch — switch to main if the tree is clean.
+					status_out, = Open3.capture3( "git", "-C", main_root, "status", "--porcelain" )
+					unless status_out.to_s.strip.empty?
+						return {
+							ok: false,
+							error: "main worktree is on branch #{head_ref} with uncommitted changes, expected #{main}",
+							recovery: "cd #{main_root} && git stash && git switch #{main}"
+						}
+					end
+
+					_, switch_err, switch_status, = Open3.capture3( "git", "-C", main_root, "switch", main )
+					unless switch_status.success?
+						return {
+							ok: false,
+							error: "main worktree is on branch #{head_ref}, could not switch to #{main}: #{switch_err.strip}",
+							recovery: "cd #{main_root} && git switch #{main}"
+						}
+					end
+
+					puts_verbose "switched main worktree from #{head_ref} to #{main}"
+					return { ok: true, reattached: true }
+				end
+
+				# Detached HEAD — check if safe to reattach.
+				detached_sha, = Open3.capture3( "git", "-C", main_root, "rev-parse", "HEAD" )
+				detached_sha = detached_sha.strip
+
+				main_sha, _, main_exists, = Open3.capture3( "git", "-C", main_root, "rev-parse", "--verify", "refs/heads/#{main}" )
+				main_sha = main_sha.strip if main_exists&.success?
+
+				remote = config.git_remote
+				remote_sha, _, remote_exists, = Open3.capture3( "git", "-C", main_root, "rev-parse", "--verify", "refs/remotes/#{remote}/#{main}" )
+				remote_sha = remote_sha.strip if remote_exists&.success?
+
+				safe = ( main_exists&.success? && detached_sha == main_sha ) ||
+					( remote_exists&.success? && detached_sha == remote_sha )
+
+				unless safe
+					short_sha = detached_sha[ 0, 8 ]
+					return {
+						ok: false,
+						error: "main worktree is detached at #{short_sha} which differs from #{main}",
+						recovery: "cd #{main_root} && git switch #{main}"
+					}
+				end
+
+				_, switch_err, switch_status, = Open3.capture3( "git", "-C", main_root, "switch", main )
+				unless switch_status.success?
+					return {
+						ok: false,
+						error: "could not reattach main worktree to #{main}: #{switch_err.strip}",
+						recovery: "cd #{main_root} && git switch #{main}"
+					}
+				end
+
+				puts_verbose "reattached main worktree to #{main}"
+				{ ok: true, reattached: true }
+			end
+
 			# In outsider mode, Carson must not leave Carson-owned fingerprints in host repositories.
 			def block_if_outsider_fingerprints!
 				return nil unless outsider_mode?

data/lib/carson/runtime/local/worktree.rb

@@ -143,35 +143,21 @@ module Carson
 				return { action: :skip, reason: "held by another process", absorbed: false } if worktree.held_by_other_process?
 				return { action: :reap, reason: "directory missing (destroyed externally)", absorbed: false } unless worktree.exists?
 
-				if worktree.dirty?
-					absorbed = branch_absorbed_into_main?( branch: worktree.branch )
-					return { action: :reap, reason: "dirty worktree with content absorbed into main", absorbed: true, force: true } if absorbed
-					return { action: :skip, reason: "gh CLI not available for PR check", absorbed: false } unless gh_available?
-
-					tip_sha = worktree_branch_tip_sha( branch: worktree.branch )
-					return { action: :skip, reason: "cannot read branch tip SHA", absorbed: false } if tip_sha.nil?
-
-					merged_pr, = merged_pr_for_branch( branch: worktree.branch, branch_tip_sha: tip_sha )
-					return { action: :reap, reason: "dirty worktree with merged #{pr_short_ref( merged_pr.fetch( :url ) )}", absorbed: false, force: true } unless merged_pr.nil?
-
-					return { action: :skip, reason: "dirty worktree", absorbed: false }
-				end
-
 				absorbed = branch_absorbed_into_main?( branch: worktree.branch )
-				return { action: :reap, reason: "content absorbed into main", absorbed: true } if absorbed
-				return { action: :skip, reason: "gh CLI not available for PR check", absorbed: false } unless gh_available?
+				return { action: :skip, reason: "dirty worktree", absorbed: absorbed } if worktree.dirty?
+				return { action: :skip, reason: "gh CLI not available for PR check", absorbed: absorbed } unless gh_available?
 
 				tip_sha = worktree_branch_tip_sha( branch: worktree.branch )
-				return { action: :skip, reason: "cannot read branch tip SHA", absorbed: false } if tip_sha.nil?
+				return { action: :skip, reason: "cannot read branch tip SHA", absorbed: absorbed } if tip_sha.nil?
 
 				merged_pr, = merged_pr_for_branch( branch: worktree.branch, branch_tip_sha: tip_sha )
-				return { action: :reap, reason: "merged #{pr_short_ref( merged_pr.fetch( :url ) )}", absorbed: false } unless merged_pr.nil?
-				return { action: :skip, reason: "open PR exists", absorbed: false } if branch_has_open_pr?( branch: worktree.branch )
+				return { action: :reap, reason: "merged #{pr_short_ref( merged_pr.fetch( :url ) )}", absorbed: absorbed } unless merged_pr.nil?
+				return { action: :skip, reason: "open PR exists", absorbed: absorbed } if branch_has_open_pr?( branch: worktree.branch )
 
 				abandoned_pr, = abandoned_pr_for_branch( branch: worktree.branch, branch_tip_sha: tip_sha )
-				return { action: :reap, reason: "closed abandoned #{pr_short_ref( abandoned_pr.fetch( :url ) )}", absorbed: false } unless abandoned_pr.nil?
+				return { action: :reap, reason: "closed abandoned #{pr_short_ref( abandoned_pr.fetch( :url ) )}", absorbed: absorbed } unless abandoned_pr.nil?
 
-				{ action: :skip, reason: "no evidence to reap", absorbed: false }
+				{ action: :skip, reason: "no evidence to reap", absorbed: absorbed }
 			end
 
 			def worktree_branch_tip_sha( branch: )

data/lib/carson/runtime/local.rb

@@ -1,5 +1,6 @@
 # Aggregates local repository operation modules (sync, prune, hooks, worktree, template).
 require_relative "local/sync"
+require_relative "local/merge_proof"
 require_relative "local/prune"
 require_relative "local/template"
 require_relative "local/hooks"