carson 3.27.0 → 3.28.0

data/lib/carson/runtime/status.rb

@@ -54,6 +54,7 @@ module Carson
 			def gather_status
 				repository = repository_record
 				branch = branch_record
+				tracked_delivery = status_branch_delivery( branch_name: branch.name )
 				deliveries = ledger.active_deliveries( repo_path: repository.path )
 				next_delivery_key = deliveries.find( &:ready? )&.key
 
@@ -69,7 +70,9 @@ module Carson
 						worktree: branch.worktree,
 						dirty: working_tree_dirty?,
 						dirty_reason: dirty_worktree_reason,
-						sync: remote_sync_status( branch: branch.name )
+						sync: remote_sync_status( branch: branch.name ),
+						pull_request: status_branch_pull_request( delivery: tracked_delivery ),
+						merge_proof: status_branch_merge_proof( branch_name: branch.name, delivery: tracked_delivery )
 					},
 					worktrees: gather_worktree_summary,
 					branches: deliveries.map { |delivery| status_branch_entry( delivery: delivery, next_to_integrate: delivery.key == next_delivery_key ) },
@@ -150,6 +153,12 @@ module Carson
 				puts_line branch_line
 				worktree_summary = data.fetch( :worktrees )
 				puts_line "Worktrees: #{worktree_summary.fetch( :non_main_count )} tracked outside main — run carson worktree list." if worktree_summary.fetch( :non_main_count ).positive?
+				if (pull_request = branch[ :pull_request ])
+					puts_line pull_request.fetch( :summary )
+				end
+				if branch.fetch( :name ) != config.main_branch && (merge_proof = branch[ :merge_proof ])
+					puts_line "Merge proof: #{merge_proof.fetch( :summary )}"
+				end
 
 				deliveries = data.fetch( :branches )
 				if deliveries.empty?
@@ -194,6 +203,30 @@ module Carson
 				else "sync unknown"
 				end
 			end
+
+			def status_branch_delivery( branch_name: )
+				return nil if branch_name == config.main_branch
+
+				ledger.latest_delivery(
+					repo_path: repository_record.path,
+					branch_name: branch_name
+				)
+			end
+
+			def status_branch_pull_request( delivery: )
+				return nil unless delivery
+
+				pull_request_payload( delivery: delivery )
+			end
+
+			def status_branch_merge_proof( branch_name:, delivery: )
+				return merge_proof_payload( proof: merge_proof_for_branch( branch: branch_name ) ) if branch_name == config.main_branch
+				return nil unless delivery
+
+				return merge_proof_payload( proof: delivery.merge_proof ) if delivery.merge_proof
+
+				merge_proof_payload( proof: merge_proof_for_branch( branch: branch_name ) )
+			end
 		end
 
 		include Status

data/lib/carson/worktree.rb

@@ -7,18 +7,20 @@
 require "fileutils"
 require "json"
 require "open3"
+require "pathname"
 
 module Carson
 	class Worktree
 		# Agent directory names whose worktrees Carson may sweep.
 		AGENT_DIRS = %w[ .claude .codex ].freeze
 
-		attr_reader :path, :branch
+		attr_reader :path, :branch, :prunable_reason
 
-		def initialize( path:, branch:, runtime: nil )
+		def initialize( path:, branch:, runtime: nil, prunable_reason: nil )
 			@path = path
 			@branch = branch
 			@runtime = runtime
+			@prunable_reason = prunable_reason
 		end
 
 		# --- Class lifecycle methods ---
@@ -30,21 +32,36 @@ module Carson
 			entries = []
 			current_path = nil
 			current_branch = :unset
+			current_prunable_reason = nil
 			raw.lines.each do |line|
 				line = line.strip
 				if line.empty?
-					entries << new( path: current_path, branch: current_branch == :unset ? nil : current_branch, runtime: runtime ) if current_path
+					entries << new(
+						path: current_path,
+						branch: current_branch == :unset ? nil : current_branch,
+						runtime: runtime,
+						prunable_reason: current_prunable_reason
+					) if current_path
 					current_path = nil
 					current_branch = :unset
+					current_prunable_reason = nil
 				elsif line.start_with?( "worktree " )
 					current_path = runtime.realpath_safe( line.sub( "worktree ", "" ) )
 				elsif line.start_with?( "branch " )
 					current_branch = line.sub( "branch refs/heads/", "" )
 				elsif line == "detached"
 					current_branch = nil
+				elsif line.start_with?( "prunable" )
+					reason = line.sub( "prunable", "" ).strip
+					current_prunable_reason = reason.empty? ? "prunable" : reason
 				end
 			end
-			entries << new( path: current_path, branch: current_branch == :unset ? nil : current_branch, runtime: runtime ) if current_path
+			entries << new(
+				path: current_path,
+				branch: current_branch == :unset ? nil : current_branch,
+				runtime: runtime,
+				prunable_reason: current_prunable_reason
+			) if current_path
 			entries
 		end
 
@@ -84,15 +101,15 @@ module Carson
 			# Best-effort — if pull fails (non-ff, offline), continue anyway.
 			main_root = runtime.main_worktree_root
 			_, _, pull_ok, = Open3.capture3( "git", "-C", main_root, "pull", "--ff-only", runtime.config.git_remote, base )
-			runtime.puts_verbose pull_ok.success? ? "synced #{base} before branching" : "sync skipped — continuing from local #{base}"
+			runtime.puts_verbose( pull_ok.success? ? "synced #{base} before branching" : "sync skipped — continuing from local #{base}" ) unless json_output
 
 			# Ensure .claude/ is excluded from git status in the host repository.
 			# Uses .git/info/exclude (local-only, never committed) to respect the outsider boundary.
 			ensure_claude_dir_excluded!( runtime: runtime )
 
 			# Create the worktree with a new branch based on the main branch.
-			FileUtils.mkdir_p( worktrees_dir )
-			_, worktree_stderr, worktree_success, = runtime.git_run( "worktree", "add", worktree_path, "-b", name, base )
+			FileUtils.mkdir_p( File.dirname( worktree_path ) )
+			worktree_stdout, worktree_stderr, worktree_success, = runtime.git_run( "worktree", "add", worktree_path, "-b", name, base )
 			unless worktree_success
 				error_text = worktree_stderr.to_s.strip
 				error_text = "unable to create worktree" if error_text.empty?
@@ -104,10 +121,16 @@ module Carson
 			end
 
 			unless creation_verified?( path: worktree_path, branch: name, runtime: runtime )
+				diagnostics = gather_create_diagnostics(
+					git_stdout: worktree_stdout, git_stderr: worktree_stderr,
+					name: name, runtime: runtime
+				)
+				cleanup_partial_create!( path: worktree_path, branch: name, runtime: runtime )
 				return finish(
 					result: { command: "worktree create", status: "error", name: name, path: worktree_path, branch: name,
 						error: "git reported success but Carson could not verify the worktree and branch",
-						recovery: "git worktree list && git branch --list '#{name}'" },
+						recovery: "git worktree list --porcelain && git branch --list '#{name}'",
+						diagnostics: diagnostics },
 					exit_code: Runtime::EXIT_ERROR, runtime: runtime, json_output: json_output
 				)
 			end
@@ -291,10 +314,9 @@ module Carson
 			{ status: :ok, resolved_path: resolved_path, branch: branch, missing: false }
 		end
 
-		# Removes agent-owned worktrees whose branch content is already on main.
-		# Scans AGENT_DIRS (e.g. .claude/worktrees/, .codex/worktrees/)
-		# under the main repo root. Safe: skips detached HEADs, the caller's CWD,
-		# and dirty working trees (git worktree remove refuses without --force).
+		# Removes agent-owned worktrees that the shared cleanup classifier judges
+		# safe to reap. Scans AGENT_DIRS (e.g. .claude/worktrees/, .codex/worktrees/)
+		# under the main repo root.
 		def self.sweep_stale!( runtime: )
 			main_root = runtime.main_worktree_root
 			worktrees = list( runtime: runtime )
@@ -308,11 +330,16 @@ module Carson
 			worktrees.each do |worktree|
 				next unless worktree.branch
 				next unless agent_prefixes.any? { |prefix| worktree.path.start_with?( prefix ) }
-				next if worktree.holds_cwd?
-				next if worktree.held_by_other_process?
-				next unless runtime.branch_absorbed_into_main?( branch: worktree.branch )
 
-				# Remove the worktree (no --force: refuses if dirty working tree).
+				classification = runtime.send( :classify_worktree_cleanup, worktree: worktree )
+				next unless classification.fetch( :action ) == :reap
+
+				unless worktree.exists?
+					remove_missing!( resolved_path: worktree.path, runtime: runtime, json_output: false )
+					next
+				end
+
+				# Remove the worktree (no --force: automatic sweep never force-removes dirty worktrees).
 				_, _, rm_success, = runtime.git_run( "worktree", "remove", worktree.path )
 				next unless rm_success
 
@@ -369,6 +396,10 @@ module Carson
 			Dir.exist?( path )
 		end
 
+		def prunable?
+			!prunable_reason.to_s.strip.empty?
+		end
+
 		def dirty?
 			return false unless exists?
 
@@ -440,7 +471,12 @@ module Carson
 		private_class_method :finish
 
 		def self.creation_verified?( path:, branch:, runtime: )
-			registered?( path: path, runtime: runtime ) && branch_exists?( branch: branch, runtime: runtime )
+			entry = find( path: path, runtime: runtime )
+			return false if entry.nil?
+			return false if entry.prunable?
+			return false unless Dir.exist?( path )
+
+			branch_exists?( branch: branch, runtime: runtime )
 		end
 		private_class_method :creation_verified?
 
@@ -450,6 +486,39 @@ module Carson
 		end
 		private_class_method :branch_exists?
 
+		# Removes partial state left behind when git worktree add reports success
+		# but verification reveals the worktree or branch is incomplete.
+		def self.cleanup_partial_create!( path:, branch:, runtime: )
+			FileUtils.rm_rf( path ) if Dir.exist?( path )
+			runtime.git_run( "worktree", "prune" )
+			runtime.git_run( "branch", "-D", branch ) if branch_exists?( branch: branch, runtime: runtime )
+		end
+		private_class_method :cleanup_partial_create!
+
+		# Captures diagnostic state for a verification failure so the next
+		# incident is self-diagnosing without manual investigation.
+		def self.gather_create_diagnostics( git_stdout:, git_stderr:, name:, runtime: )
+			wt_list, = runtime.git_run( "worktree", "list", "--porcelain" )
+			branch_list, = runtime.git_run( "branch", "--list", name )
+			git_version, = Open3.capture3( "git", "--version" )
+			worktree_path = File.join( runtime.main_worktree_root, ".claude", "worktrees", name )
+			entry = find( path: worktree_path, runtime: runtime )
+			{
+				git_stdout: git_stdout.to_s.strip,
+				git_stderr: git_stderr.to_s.strip,
+				repo_root: runtime.send( :repo_root ),
+				main_worktree_root: runtime.main_worktree_root,
+				worktree_list: wt_list.to_s.strip,
+				branch_list: branch_list.to_s.strip,
+				git_version: git_version.to_s.strip,
+				worktree_directory_exists: Dir.exist?( worktree_path ),
+				registered_worktree: !entry.nil?,
+				prunable_reason: entry&.prunable_reason
+			}
+		end
+		private_class_method :gather_create_diagnostics
+
+
 		# Human-readable output for worktree results.
 		def self.print_human( result:, runtime: )
 			command = result[ :command ]
@@ -519,10 +588,18 @@ module Carson
 		# succeed, even when the OS resolves symlinks differently.
 		# Uses main_worktree_root (not repo_root) so resolution works from inside worktrees.
 		def self.resolve_path( path:, runtime: )
-			if path.include?( "/" )
+			if Pathname.new( path ).absolute?
 				return runtime.realpath_safe( path )
 			end
 
+			relative_candidate = runtime.realpath_safe( File.expand_path( path, Dir.pwd ) )
+			return relative_candidate if registered?( path: relative_candidate, runtime: runtime )
+
+			if path.include?( "/" )
+				scoped_candidate = runtime.realpath_safe( File.join( runtime.main_worktree_root, ".claude", "worktrees", path ) )
+				return scoped_candidate if registered?( path: scoped_candidate, runtime: runtime )
+			end
+
 			root = runtime.main_worktree_root
 			candidate = File.join( root, ".claude", "worktrees", path )
 			canonical = runtime.realpath_safe( candidate )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carson
 version: !ruby/object:Gem::Version
-  version: 3.27.0
+  version: 3.28.0
 platform: ruby
 authors:
 - Hailei Wang
@@ -10,7 +10,27 @@ authors:
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 description: 'Carson is an autonomous git strategist and repositories governor that
   lives outside the repositories it governs — no Carson-owned artefacts in your repo.
   As strategist, Carson knows when to branch, how to isolate concurrent work, and
@@ -63,6 +83,7 @@ files:
 - lib/carson/runtime/housekeep.rb
 - lib/carson/runtime/local.rb
 - lib/carson/runtime/local/hooks.rb
+- lib/carson/runtime/local/merge_proof.rb
 - lib/carson/runtime/local/onboard.rb
 - lib/carson/runtime/local/prune.rb
 - lib/carson/runtime/local/sync.rb
@@ -106,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Autonomous git strategist and repositories governor — you write the code,
   Carson manages everything else.