carson 2.25.0 → 2.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6046632b555d3558d7b0b8910cbcb50a562d155b92d535f28275eb78cd9f02d9
-  data.tar.gz: 8a86dad0adc37689a2dc2185ac428c4710f3aa511b2015455a6eeab9ae7468d6
+  metadata.gz: b07e53b67d21543ee131ce2a8bbc906938fbd657f79973aaa59008911dd14df7
+  data.tar.gz: 73d0811c01b3daa2f397dd545a266085950d93d4cda474ab3288b6b754cd5d20
 SHA512:
-  metadata.gz: aca61a3a47edbbf4a6dea33970b954f5b5116786d3f14713f67e2140ce0d113364f4e5c08181146296cb28858d5023b552102178386e05c6d9120686c79dbcb2
-  data.tar.gz: 65fd5eb074422776f240a8161c5bec6d3ea6c8d746e182b9e2f95bf8cbd05131c9a0567af5dc0d9ef3f4e5b9bc1ab71e4c22493d3ef69f9a6e43c9487430fac3
+  metadata.gz: 9880a422abf831615af431cf9b32b6a28a0cd026f2154a46270664deb4d8d32dacf0dac4912a2e64984889372a43bd3cf36cd1cd87899c7b4e3c5cf7ae989fab
+  data.tar.gz: 11e37eb20e6f62dd632493c134218a714dab0a565b533681b1f57b78f28f01dd799786d2d461285dd7623d2832b29f4d3e72f2d95a273f8c80e5869d49f72cd6

data/RELEASE.md

@@ -5,6 +5,39 @@ Release-note scope rule:
 - `RELEASE.md` records only version deltas, breaking changes, and migration actions.
 - Operational usage guides live in `MANUAL.md` and `API.md`.
 
+## 2.27.0 — Absorbed Branch Pruning
+
+### What changed
+
+- **`carson prune` now detects and removes absorbed branches.** An absorbed branch is one whose upstream still exists but whose content is already on main — every file the branch changed has identical content on main. This catches branches whose work landed via a different PR, cherry-pick, or independent re-implementation.
+- Detection uses a two-step evidence check: (1) find the merge-base, (2) compare only the files the branch changed. If all are identical on main, the branch is absorbed.
+- Fast path: branches that are strict ancestors of main (fully merged via fast-forward) are also detected.
+- Safety: absorbed branches are only deleted when no open PR exists. If `gh` is unavailable, absorbed detection is skipped entirely.
+- Both local and remote branches are cleaned up.
+
+### Why
+
+Carson already pruned stale branches (upstream deleted) and orphan branches (no tracking, merged PR evidence). But branches whose remote still existed and had tracking were invisible to prune — even when their content had already landed on main through other means. This gap left repositories cluttered with dead branches that required manual investigation to clean up.
+
+### Migration
+
+No action required. `carson prune` gains the new detection automatically.
+
+## 2.26.0 — Baseline Check No Longer Blocks Commits
+
+### What changed
+
+- **Default-branch CI baseline failures are now advisory, not blocking.** When main's CI is failing, `carson audit` reports it as `attention` instead of `block`. This eliminates the deadlock where a broken main prevented committing the fix on any branch. The baseline status is still reported so users are aware before merging.
+- Message changed from "merge blocked" to "fix before merge" to reflect the advisory nature.
+
+### Why
+
+Carson's pre-commit hook runs `audit`, which checks main's CI baseline. If main had a failing check, the audit hard-blocked all commits across every branch — including the branch carrying the fix. This circular dependency made it impossible to commit the repair without bypassing the hook entirely.
+
+### Migration
+
+No action required. The `CARSON_AUDIT_ADVISORY_CHECK_NAMES` env var workaround is no longer needed for this scenario.
+
 ## 2.25.0 — Onboard/Offboard UX Improvements
 
 ### What changed

data/VERSION

@@ -1 +1 @@
-2.25.0
+2.27.0

data/lib/carson/runtime/audit.rb

@@ -75,7 +75,6 @@ module Carson
 				puts_verbose ""
 				puts_verbose "[Default Branch CI Baseline (gh)]"
 				default_branch_baseline = default_branch_ci_baseline_report
-				audit_state = "block" if default_branch_baseline.fetch( :status ) == "block"
 				audit_state = "attention" if audit_state == "ok" && default_branch_baseline.fetch( :status ) != "ok"
 				baseline_st = default_branch_baseline.fetch( :status )
 				if baseline_st == "block"
@@ -83,7 +82,7 @@ module Carson
 					parts << "#{default_branch_baseline.fetch( :failing_count )} failing" if default_branch_baseline.fetch( :failing_count ).positive?
 					parts << "#{default_branch_baseline.fetch( :pending_count )} pending" if default_branch_baseline.fetch( :pending_count ).positive?
 					parts << "no check-runs for active workflows" if default_branch_baseline.fetch( :no_check_evidence )
-					audit_concise_problems << "Baseline (#{default_branch_baseline.fetch( :default_branch, config.main_branch )}): #{parts.join( ', ' )} — merge blocked."
+					audit_concise_problems << "Baseline (#{default_branch_baseline.fetch( :default_branch, config.main_branch )}): #{parts.join( ', ' )} — fix before merge."
 				elsif baseline_st == "attention"
 					parts = []
 					parts << "#{default_branch_baseline.fetch( :advisory_failing_count )} advisory failing" if default_branch_baseline.fetch( :advisory_failing_count ).positive?

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

@@ -1,7 +1,8 @@
 module Carson
 	class Runtime
 		module Local
-			# Removes stale local branches (gone upstream) and orphan branches (no tracking) with merged PR evidence.
+			# Removes stale local branches (gone upstream), orphan branches (no tracking) with merged PR evidence,
+			# and absorbed branches (content already on main, no open PR).
 			def prune!
 				fingerprint_status = block_if_outsider_fingerprints!
 				return fingerprint_status unless fingerprint_status.nil?
@@ -16,6 +17,9 @@ module Carson
 				orphan_branches = orphan_local_branches( active_branch: active_branch )
 				prune_orphan_branch_entries( orphan_branches: orphan_branches, counters: counters )
 
+				absorbed_branches = absorbed_local_branches( active_branch: active_branch )
+				prune_absorbed_branch_entries( absorbed_branches: absorbed_branches, counters: counters )
+
 				return prune_no_stale_branches if counters.fetch( :deleted ).zero? && counters.fetch( :skipped ).zero?
 
 				puts_verbose "prune_summary: deleted=#{counters.fetch( :deleted )} skipped=#{counters.fetch( :skipped )}"
@@ -147,6 +151,107 @@ module Carson
 				end
 			end
 
+			# Detects local branches whose upstream still exists but whose content is already on main.
+			# Two-step evidence: (1) find the merge-base, (2) verify every file the branch changed
+			# relative to the merge-base has identical content on main.
+			def absorbed_local_branches( active_branch: )
+				git_capture!( "for-each-ref", "--format=%(refname:short)\t%(upstream:short)\t%(upstream:track)", "refs/heads" ).lines.filter_map do |line|
+					branch, upstream, track = line.strip.split( "\t", 3 )
+					branch = branch.to_s.strip
+					upstream = upstream.to_s.strip
+					track = track.to_s
+					next if branch.empty?
+					next if upstream.empty?
+					next if track.include?( "gone" )
+					next if config.protected_branches.include?( branch )
+					next if branch == active_branch
+					next if branch == TEMPLATE_SYNC_BRANCH
+
+					next unless branch_absorbed_into_main?( branch: branch )
+
+					{ branch: branch, upstream: upstream }
+				end
+			end
+
+			# Returns true when the branch has no unique content relative to main.
+			def branch_absorbed_into_main?( branch: )
+				# Fast path: branch is a strict ancestor of main (fully merged).
+				_, _, is_ancestor, = git_run( "merge-base", "--is-ancestor", branch, config.main_branch )
+				return true if is_ancestor
+
+				# Find the merge-base between main and the branch.
+				merge_base_text, _, mb_success, = git_run( "merge-base", config.main_branch, branch )
+				return false unless mb_success
+
+				merge_base = merge_base_text.to_s.strip
+				return false if merge_base.empty?
+
+				# List every file the branch changed relative to the merge-base.
+				changed_text, _, changed_success, = git_run( "diff", "--name-only", merge_base, branch )
+				return false unless changed_success
+
+				changed_files = changed_text.to_s.strip.lines.map( &:strip ).reject( &:empty? )
+				return true if changed_files.empty?
+
+				# Compare only those files between branch tip and main tip.
+				# If identical, every branch change is already on main.
+				_, _, identical, = git_run( "diff", "--quiet", branch, config.main_branch, "--", *changed_files )
+				identical
+			end
+
+			# Processes absorbed branches: verifies no open PR exists before deleting local and remote.
+			def prune_absorbed_branch_entries( absorbed_branches:, counters: )
+				return counters if absorbed_branches.empty?
+				return counters unless gh_available?
+
+				absorbed_branches.each do |entry|
+					outcome = prune_absorbed_branch_entry( branch: entry.fetch( :branch ), upstream: entry.fetch( :upstream ) )
+					counters[ outcome ] += 1
+				end
+				counters
+			end
+
+			# Checks a single absorbed branch for open PRs and deletes local + remote if safe.
+			def prune_absorbed_branch_entry( branch:, upstream: )
+				if branch_has_open_pr?( branch: branch )
+					puts_verbose "skip_absorbed_branch: #{branch} reason=open PR exists"
+					return :skipped
+				end
+
+				force_stdout, force_stderr, force_success, = git_run( "branch", "-D", branch )
+				unless force_success
+					error_text = normalise_branch_delete_error( error_text: force_stderr )
+					puts_verbose "fail_delete_absorbed_branch: #{branch} reason=#{error_text}"
+					return :skipped
+				end
+
+				out.print force_stdout if verbose? && !force_stdout.empty?
+
+				remote_branch = upstream.sub( "#{config.git_remote}/", "" )
+				git_run( "push", config.git_remote, "--delete", remote_branch )
+
+				puts_verbose "deleted_absorbed_branch: #{branch} (upstream=#{upstream})"
+				:deleted
+			end
+
+			# Returns true if the branch has at least one open PR.
+			def branch_has_open_pr?( branch: )
+				owner, repo = repository_coordinates
+				stdout_text, _, success, = gh_run(
+					"api", "repos/#{owner}/#{repo}/pulls",
+					"--method", "GET",
+					"-f", "state=open",
+					"-f", "head=#{owner}:#{branch}",
+					"-f", "per_page=1"
+				)
+				return true unless success
+
+				results = Array( JSON.parse( stdout_text ) )
+				!results.empty?
+			rescue StandardError
+				true
+			end
+
 			# Processes orphan branches: verifies merged PR evidence via GitHub API before deleting.
 			def prune_orphan_branch_entries( orphan_branches:, counters: )
 				return counters if orphan_branches.empty?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carson
 version: !ruby/object:Gem::Version
-  version: 2.25.0
+  version: 2.27.0
 platform: ruby
 authors:
 - Hailei Wang