carson 3.30.1 → 3.30.3

data/lib/carson/runtime/audit.rb

@@ -164,58 +164,6 @@ module Carson
 				exit_code
 			end
 
-			# Runs audit across all governed repositories.
-			def audit_all!
-				repos = config.govern_repos
-				if repos.empty?
-					puts_line "No governed repositories configured."
-					puts_line "  Run carson onboard in each repo to register."
-					return EXIT_ERROR
-				end
-
-				puts_line ""
-				puts_line "Audit all (#{repos.length} repo#{plural_suffix( count: repos.length )})"
-				passed = 0
-				blocked = 0
-				failed = 0
-
-				repos.each do |repo_path|
-					repo_name = File.basename( repo_path )
-					unless Dir.exist?( repo_path )
-						puts_line "#{repo_name}: not found"
-						record_batch_skip( command: "audit", repo_path: repo_path, reason: "path not found" )
-						failed += 1
-						next
-					end
-
-					begin
-						scoped_runtime = build_scoped_runtime( repo_path: repo_path )
-						status = scoped_runtime.audit!
-						case status
-						when EXIT_OK
-							puts_line "#{repo_name}: ok" unless verbose?
-							clear_batch_success( command: "audit", repo_path: repo_path )
-							passed += 1
-						when EXIT_BLOCK
-							puts_line "#{repo_name}: needs attention" unless verbose?
-							blocked += 1
-						else
-							puts_line "#{repo_name}: could not complete" unless verbose?
-							record_batch_skip( command: "audit", repo_path: repo_path, reason: "audit failed" )
-							failed += 1
-						end
-					rescue StandardError => exception
-						puts_line "#{repo_name}: could not complete (#{exception.message})"
-						record_batch_skip( command: "audit", repo_path: repo_path, reason: exception.message )
-						failed += 1
-					end
-				end
-
-				puts_line ""
-				puts_line "Audit all complete: #{passed} ok, #{blocked} blocked, #{failed} failed."
-				blocked.zero? && failed.zero? ? EXIT_OK : EXIT_BLOCK
-				end
-
 			# rubocop:disable Layout/AccessModifierIndentation -- tab-width calculation produces unfixable mixed tabs+spaces
 			private
 			# rubocop:enable Layout/AccessModifierIndentation

data/lib/carson/runtime/deliver.rb

@@ -288,7 +288,7 @@ module Carson
 					when :blocked
 						result[ :outcome ] = "blocked"
 						result[ :waited_seconds ] = elapsed_settle_seconds( started_at: started_at )
-						result[ :recovery ] = "git rebase #{config.git_remote}/#{main} && carson deliver" if evaluation[ :cause ] == "freshness"
+						result[ :recovery ] = "refresh this branch onto #{config.git_remote}/#{main}, then carson deliver" if evaluation[ :cause ] == "freshness"
 						apply_handoff!(
 							result: result,
 							reason: evaluation.fetch( :reason ),
@@ -742,7 +742,7 @@ module Carson
 			end
 
 			def deliver_handoff_next_steps
-				[ "carson status", "carson deliver", "carson govern --loop 300" ]
+				[ "carson status", "carson deliver" ]
 			end
 
 			def deliver_ci_poll_seconds
@@ -809,10 +809,9 @@ module Carson
 
 			def freshness_recovery( freshness: )
 				remote_ref = freshness.fetch( :remote_ref )
-				return "git rebase #{remote_ref} && carson deliver" if freshness.fetch( :status ) == :behind
+				return "refresh this branch onto #{remote_ref}, then carson deliver" if freshness.fetch( :status ) == :behind
 
-				remote, main = remote_ref.split( "/", 2 )
-				"git fetch #{remote} #{main} && carson deliver"
+				"carson deliver (once #{remote_ref} is reachable)"
 			end
 
 			def deliver_merge_attempt_cap
@@ -898,7 +897,7 @@ module Carson
 					reason: "freshness_behind",
 					cause: "freshness",
 					summary: "branch is behind #{remote_main}",
-					recovery: "git rebase #{remote_main} && carson deliver"
+					recovery: "refresh this branch onto #{remote_main}, then carson deliver"
 				} if merge_state == "BEHIND"
 
 				return {
@@ -1127,7 +1126,7 @@ module Carson
 
 				if lease_stderr.to_s.include?( "stale info" )
 					result[ :error ] = "force-with-lease rejected — another push landed on #{branch} since your last fetch"
-					result[ :recovery ] = "git fetch #{remote} #{branch} && carson deliver"
+					result[ :recovery ] = "inspect newer commits on #{branch}, reconcile, then carson deliver"
 				else
 					error_text = lease_stderr.to_s.strip
 					error_text = "push failed (force-with-lease)" if error_text.empty?
@@ -1175,7 +1174,7 @@ module Carson
 					error_text = stderr.to_s.strip
 					error_text = "pr create failed" if error_text.empty?
 					result[ :error ] = error_text
-					result[ :recovery ] = "gh pr create --title '#{pr_title}' --head #{branch}"
+					result[ :recovery ] = "carson deliver"
 					return [ nil, nil ]
 				end
 
@@ -1274,7 +1273,7 @@ module Carson
 					error_text = stderr.to_s.strip
 					error_text = "merge failed" if error_text.empty?
 					result[ :error ] = error_text
-					result[ :recovery ] = "gh pr merge #{number} --#{method}"
+					result[ :recovery ] = "carson deliver"
 					EXIT_ERROR
 				end
 			end

data/lib/carson/runtime/housekeep.rb

@@ -23,73 +23,6 @@ module Carson
 				housekeep_one( repo_path: canonical, json_output: json_output )
 			end
 
-			# Resolves a target name to a governed repo, then serves it.
-			def housekeep_target!( target:, json_output: false, dry_run: false )
-				repo_path = resolve_governed_repo( target: target )
-				unless repo_path
-					result = { command: "housekeep", status: "error", error: "Not a governed repository: #{target}", recovery: "Run carson repos to see governed repositories." }
-					return housekeep_finish( result: result, exit_code: EXIT_ERROR, json_output: json_output )
-				end
-
-				if dry_run
-					scoped = Runtime.new( repo_root: repo_path, tool_root: tool_root, output: output, error: error, verbose: verbose? )
-					return scoped.housekeep_one_dry_run
-				end
-
-				housekeep_one( repo_path: repo_path, json_output: json_output )
-			end
-
-			# Knocks each governed repo's gate in turn.
-			def housekeep_all!( json_output: false, dry_run: false )
-				repos = config.govern_repos
-				if repos.empty?
-					result = { command: "housekeep", status: "error", error: "No governed repositories configured.", recovery: "Run carson onboard in each repo to register." }
-					return housekeep_finish( result: result, exit_code: EXIT_ERROR, json_output: json_output )
-				end
-
-				if dry_run
-					repos.each_with_index do |repo_path, idx|
-						puts_line "" if idx > 0
-						unless Dir.exist?( repo_path )
-							puts_line "#{File.basename( repo_path )}: SKIP (path not found)"
-							next
-						end
-						scoped = Runtime.new( repo_root: repo_path, tool_root: tool_root, output: output, error: error, verbose: verbose? )
-						scoped.housekeep_one_dry_run
-					end
-					total = repos.size
-					puts_line ""
-					puts_line "#{total} repo#{plural_suffix( count: total )} surveyed. Run without --dry-run to apply."
-					return EXIT_OK
-				end
-
-				results = []
-				repos.each do |repo_path|
-					entry = housekeep_one_entry( repo_path: repo_path, silent: json_output )
-					if entry[ :status ] == "ok"
-						clear_batch_success( command: "housekeep", repo_path: repo_path )
-					else
-						record_batch_skip( command: "housekeep", repo_path: repo_path, reason: entry[ :error ] || "housekeep failed" )
-					end
-					results << entry
-				end
-
-				succeeded = results.count { |entry| entry[ :status ] == "ok" }
-				failed = results.count { |entry| entry[ :status ] != "ok" }
-				result = { command: "housekeep", status: failed.zero? ? "ok" : "partial", repos: results, succeeded: succeeded, failed: failed }
-				housekeep_finish( result: result, exit_code: failed.zero? ? EXIT_OK : EXIT_ERROR, json_output: json_output, results: results, succeeded: succeeded, failed: failed )
-			end
-
-			def housekeep_loop!( json_output:, dry_run:, loop_seconds: )
-				run_signal_aware_loop!(
-					loop_name: "housekeep",
-					loop_seconds: loop_seconds,
-					cycle_line: ->( cycle_count ) { "housekeep cycle #{cycle_count} at #{Time.now.utc.strftime( '%Y-%m-%d %H:%M:%S UTC' )}" }
-				) do
-					housekeep_all!( json_output: json_output, dry_run: dry_run )
-				end
-			end
-
 			# Prints a dry-run plan for this repo without making any changes.
 			# Calls reap_dead_worktrees_plan and prune_plan on self (already scoped to the repo).
 			def housekeep_one_dry_run
@@ -185,17 +118,6 @@ module Carson
 				{ name: repo_name, path: repo_path, status: "error", error: exception.message }
 			end
 
-			# Resolves a user-supplied target to a governed repository path.
-			# Accepts: exact path, expandable path, or basename match (case-insensitive).
-			def resolve_governed_repo( target: )
-				repos = config.govern_repos
-				expanded = File.expand_path( target )
-				return expanded if repos.include?( expanded )
-
-				downcased = File.basename( target ).downcase
-				repos.find { |repo_path| File.basename( repo_path ).downcase == downcased }
-			end
-
 			# Unified output — JSON or human-readable.
 			def housekeep_finish( result:, exit_code:, json_output:, results: nil, succeeded: nil, failed: nil )
 				result[ :exit_code ] = exit_code

data/lib/carson/runtime/{repos.rb → list.rb}

@@ -4,12 +4,12 @@ require "json"
 
 module Carson
 	class Runtime
-		module Repos
-			def repos!( json_output: false )
+		module List
+			def list!( json_output: false )
 				repos = config.govern_repos
 
 				if json_output
-					output.puts JSON.pretty_generate( { command: "repos", repos: repos } )
+					output.puts JSON.pretty_generate( { command: "list", repos: repos } )
 				else
 					if repos.empty?
 						puts_line "No governed repositories."
@@ -24,6 +24,6 @@ module Carson
 			end
 		end
 
-		include Repos
+		include List
 	end
 end

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

@@ -57,7 +57,7 @@ module Carson
 
 			# Canonical hook template location inside Carson repository.
 			def hook_template_path( hook_name: )
-				File.join( tool_root, "hooks", hook_name )
+				File.join( tool_root, "config", ".github", "hooks", hook_name )
 			end
 
 			# Reports full hook health and can enforce stricter action messaging in `check`.

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

@@ -144,56 +144,6 @@ module Carson
 				failed.zero? && pending.zero? ? EXIT_OK : EXIT_ERROR
 			end
 
-			def prune_all!
-				repos = config.govern_repos
-				if repos.empty?
-					puts_line "No governed repositories configured."
-					puts_line "  Run carson onboard in each repo to register."
-					return EXIT_ERROR
-				end
-
-				puts_line ""
-				puts_line "Prune all (#{repos.length} repo#{plural_suffix( count: repos.length )})"
-				succeeded = 0
-				failed = 0
-
-				repos.each do |repo_path|
-					repo_name = File.basename( repo_path )
-					unless Dir.exist?( repo_path )
-						puts_line "#{repo_name}: not found"
-						record_batch_skip( command: "prune", repo_path: repo_path, reason: "path not found" )
-						failed += 1
-						next
-					end
-
-					begin
-						buffer = verbose? ? output : StringIO.new
-						error_buffer = verbose? ? error : StringIO.new
-						scoped_runtime = Runtime.new( repo_root: repo_path, tool_root: tool_root, output: buffer, error: error_buffer, verbose: verbose? )
-						status = scoped_runtime.prune!
-						unless verbose?
-							summary = buffer.string.lines.last.to_s.strip
-							puts_line "#{repo_name}: #{summary.empty? ? 'OK' : summary}"
-						end
-						if status == EXIT_ERROR
-							record_batch_skip( command: "prune", repo_path: repo_path, reason: "prune failed" )
-							failed += 1
-						else
-							clear_batch_success( command: "prune", repo_path: repo_path )
-							succeeded += 1
-						end
-					rescue StandardError => exception
-						puts_line "#{repo_name}: could not complete (#{exception.message})"
-						record_batch_skip( command: "prune", repo_path: repo_path, reason: exception.message )
-						failed += 1
-					end
-				end
-
-				puts_line ""
-				puts_line "Prune all complete: #{succeeded} pruned, #{failed} failed."
-				failed.zero? ? EXIT_OK : EXIT_ERROR
-			end
-
 			# Removes Carson-managed repository integration so a host repository can retire Carson cleanly.
 			def offboard!
 				puts_verbose ""

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

@@ -60,53 +60,6 @@ module Carson
 				git_system!( "switch", start_branch ) if switched && branch_exists?( branch_name: start_branch )
 			end
 
-			# Syncs main branch across all governed repositories.
-			def sync_all!
-				repos = config.govern_repos
-				if repos.empty?
-					puts_line "No governed repositories configured."
-					puts_line "  Run carson onboard in each repo to register."
-					return EXIT_ERROR
-				end
-
-				puts_line ""
-				puts_line "Sync all (#{repos.length} repo#{plural_suffix( count: repos.length )})"
-				synced = 0
-				failed = 0
-
-				repos.each do |repo_path|
-					repo_name = File.basename( repo_path )
-					unless Dir.exist?( repo_path )
-						puts_line "#{repo_name}: not found"
-						record_batch_skip( command: "sync", repo_path: repo_path, reason: "path not found" )
-						failed += 1
-						next
-					end
-
-					begin
-						scoped_runtime = build_scoped_runtime( repo_path: repo_path )
-						status = scoped_runtime.sync!
-						if status == EXIT_OK
-							puts_line "#{repo_name}: ok" unless verbose?
-							clear_batch_success( command: "sync", repo_path: repo_path )
-							synced += 1
-						else
-							puts_line "#{repo_name}: could not sync" unless verbose?
-							record_batch_skip( command: "sync", repo_path: repo_path, reason: "sync failed" )
-							failed += 1
-						end
-					rescue StandardError => exception
-						puts_line "#{repo_name}: could not sync (#{exception.message})"
-						record_batch_skip( command: "sync", repo_path: repo_path, reason: exception.message )
-						failed += 1
-					end
-				end
-
-				puts_line ""
-				puts_line "Sync all complete: #{synced} synced, #{failed} failed."
-				failed.zero? ? EXIT_OK : EXIT_ERROR
-			end
-
 		private
 
 			# Runs a git command, suppressing stdout/stderr in JSON mode to keep output clean.
@@ -181,7 +134,7 @@ module Carson
 			end
 
 			def main_worktree_context?
-				realpath_safe( repo_root ) == realpath_safe( main_worktree_root )
+				realpath_safe( work_dir ) == realpath_safe( main_worktree_root )
 			end
 
 			def inside_git_work_tree?

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

@@ -53,53 +53,6 @@ module Carson
 				( drift_count + stale_count ).positive? ? EXIT_BLOCK : EXIT_OK
 			end
 
-			# Read-only template drift check across all governed repositories.
-			def template_check_all!
-				repos = config.govern_repos
-				if repos.empty?
-					puts_line "No governed repositories configured."
-					puts_line "  Run carson onboard in each repo to register."
-					return EXIT_ERROR
-				end
-
-				puts_line ""
-				puts_line "Template check all (#{repos.length} repo#{plural_suffix( count: repos.length )})"
-				in_sync = 0
-				drifted = 0
-				failed = 0
-
-				repos.each do |repo_path|
-					repo_name = File.basename( repo_path )
-					unless Dir.exist?( repo_path )
-						puts_line "#{repo_name}: not found"
-						record_batch_skip( command: "template_check", repo_path: repo_path, reason: "path not found" )
-						failed += 1
-						next
-					end
-
-					begin
-						scoped_runtime = build_scoped_runtime( repo_path: repo_path )
-						status = scoped_runtime.template_check!
-						if status == EXIT_OK
-							puts_line "#{repo_name}: in sync" unless verbose?
-							clear_batch_success( command: "template_check", repo_path: repo_path )
-							in_sync += 1
-						else
-							puts_line "#{repo_name}: DRIFT" unless verbose?
-							drifted += 1
-						end
-					rescue StandardError => exception
-						puts_line "#{repo_name}: could not complete (#{exception.message})"
-						record_batch_skip( command: "template_check", repo_path: repo_path, reason: exception.message )
-						failed += 1
-					end
-				end
-
-				puts_line ""
-				puts_line "Template check complete: #{in_sync} in sync, #{drifted} drifted, #{failed} failed."
-				drifted.zero? && failed.zero? ? EXIT_OK : EXIT_BLOCK
-			end
-
 			# Applies managed template files as full-file writes from Carson sources.
 			# Also removes superseded files that are no longer part of the managed set.
 			def template_apply!( push_prep: false )

data/lib/carson/runtime/{govern.rb → receive.rb}

@@ -1,46 +1,47 @@
-# Carson govern — portfolio-wide oversight over branch deliveries.
-# Govern reassesses queued/gated deliveries, records revision cycles, and integrates one ready delivery at a time.
+# Carson receive — single-repo delivery triage.
+# Receive reassesses queued/gated deliveries, records revision cycles, and integrates one ready delivery at a time.
 require "json"
 require "time"
 
 module Carson
 	class Runtime
-		module Govern
-			# Portfolio-level entry point. Scans governed repos (or the current repo) and advances deliveries.
-			def govern!( dry_run: false, json_output: false, loop_seconds: nil )
+		module Receive
+			# Single-repo entry point. Advances deliveries for the current repository.
+			def receive!( dry_run: false, json_output: false, loop_seconds: nil )
 				if loop_seconds
-					govern_loop!( dry_run: dry_run, json_output: json_output, loop_seconds: loop_seconds )
+					receive_loop!( dry_run: dry_run, json_output: json_output, loop_seconds: loop_seconds )
 				else
-					govern_cycle!( dry_run: dry_run, json_output: json_output )
+					receive_cycle!( dry_run: dry_run, json_output: json_output )
 				end
 			end
 
-			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 )}" unless json_output
+			def receive_cycle!( dry_run:, json_output: )
+				repo_path = repository_record.path
+				repo_name = File.basename( repo_path )
+				print_header "Receiving #{repo_name}" unless json_output
 
+				repo_report = receive_repo!( repo_path: repo_path, dry_run: dry_run, silent: 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, silent: json_output ) }
+					repository: repo_report
 				}
 
 				if json_output
 					output.puts JSON.pretty_generate( report )
 				else
-					print_govern_summary( report: report )
+					print_receive_summary( repo_report: repo_report )
 				end
 
 				EXIT_OK
 			rescue StandardError => exception
-				puts_line "Govern did not complete: #{exception.message}"
+				puts_line "Receive did not complete: #{exception.message}"
 				EXIT_ERROR
 			end
 
-			def govern_loop!( dry_run:, json_output:, loop_seconds: )
+			def receive_loop!( dry_run:, json_output:, loop_seconds: )
 				run_signal_aware_loop!(
-					loop_name: "govern",
+					loop_name: "receive",
 					loop_seconds: loop_seconds,
 					cycle_line: ->( cycle_count ) { "cycle #{cycle_count} at #{Time.now.utc.strftime( '%Y-%m-%d %H:%M:%S UTC' )}" },
 					sleep_line: ->( seconds ) do
@@ -48,21 +49,13 @@ module Carson
 						"sleeping #{seconds}s — next cycle at #{next_at.strftime( '%Y-%m-%d %H:%M:%S %z' )}"
 					end
 				) do
-					govern_cycle!( dry_run: dry_run, json_output: json_output )
+					receive_cycle!( dry_run: dry_run, json_output: json_output )
 				end
 			end
 
 		private
 
-			def governed_repo_paths
-				config.govern_repos.map do |path|
-					expanded = File.expand_path( path )
-					next nil unless Dir.exist?( expanded )
-					expanded
-				end.compact
-			end
-
-			def govern_repo!( repo_path:, dry_run:, silent: false )
+			def receive_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 )
@@ -365,10 +358,10 @@ module Carson
 				def delivery_action_hint( delivery:, next_to_integrate:, dry_run: )
 					return nil if dry_run
 					return nil if delivery.superseded? || delivery.integrated? || delivery.failed?
-					return "integrating…" if delivery.ready? && delivery.key == next_to_integrate
+					return "integrating..." if delivery.ready? && delivery.key == next_to_integrate
 					return nil unless delivery.blocked?
 					return nil if held_delivery?( delivery: delivery )
-					delivery.revision_count >= 3 ? "escalating…" : "revising…"
+					delivery.revision_count >= 3 ? "escalating..." : "revising..."
 				end
 
 			def housekeep_repo!( repo_path: )
@@ -514,28 +507,26 @@ module Carson
 				""
 			end
 
-			def print_govern_summary( report: )
-				Array( report[ :repositories ] ).each do |repo_report|
-					if repo_report[ :error ]
-						puts_line "#{repo_report[ :repository ]}: #{repo_report[ :error ]}"
-						next
-					end
+			def print_receive_summary( repo_report: )
+				if repo_report[ :error ]
+					puts_line "#{repo_report[ :repository ]}: #{repo_report[ :error ]}"
+					return
+				end
 
-					next if repo_report[ :deliveries ].empty?
+				return if repo_report[ :deliveries ].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
+				repo_report[ :deliveries ].each do |delivery|
+					action_text = format_receive_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
 
-				def format_govern_action( status:, action:, cause: )
+				def format_receive_action( status:, action:, cause: )
 					case action
 					when "integrate"
-						format_govern_integration_outcome( status: status, cause: cause )
+						format_receive_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)"
@@ -547,7 +538,7 @@ module Carson
 				end
 			end
 
-				def format_govern_integration_outcome( status:, cause: )
+				def format_receive_integration_outcome( status:, cause: )
 					case status
 					when "integrated" then "integrated"
 					when "gated" then cause == "freshness" ? "refresh required" : "held at gate"
@@ -558,6 +549,6 @@ module Carson
 			end
 		end
 
-		include Govern
+		include Receive
 	end
 end

data/lib/carson/runtime/recover.rb

@@ -2,7 +2,7 @@
 module Carson
 	class Runtime
 		module Recover
-			GOVERNANCE_SURFACE_PREFIXES = %w[ .github/ hooks/ ].freeze
+			GOVERNANCE_SURFACE_PREFIXES = %w[ .github/ config/.github/ ].freeze
 
 			def recover!( check_name:, json_output: false )
 				result = {
@@ -71,7 +71,7 @@ module Carson
 
 				unless relation.fetch( :related )
 					result[ :error ] = "branch does not touch the governance surface for #{check_name}"
-					result[ :recovery ] = "update the branch to repair .github/ or hooks/, then rerun carson recover --check #{check_name.inspect}"
+					result[ :recovery ] = "update the branch to repair .github/ or config/.github/, then rerun carson recover --check #{check_name.inspect}"
 					return recover_finish( result: result, exit_code: EXIT_BLOCK, json_output: json_output )
 				end
 

data/lib/carson/runtime/status.rb

@@ -15,40 +15,6 @@ module Carson
 				EXIT_OK
 			end
 
-			# Portfolio-wide status overview across all governed repositories.
-			def status_all!( json_output: false )
-				repositories = config.govern_repos
-				if repositories.empty?
-					puts_line "No governed repositories configured."
-					puts_line "  Run carson onboard in each repo to register."
-					return EXIT_ERROR
-				end
-
-				results = repositories.map do |repo_path|
-					repo_name = File.basename( repo_path )
-					unless Dir.exist?( repo_path )
-						{ name: repo_name, status: "error", error: "not found" }
-					else
-						begin
-							scoped_runtime = build_scoped_runtime( repo_path: repo_path )
-							{ name: repo_name, status: "ok" }.merge( scoped_runtime.send( :gather_status ) )
-						rescue StandardError => exception
-							{ name: repo_name, status: "error", error: exception.message }
-						end
-					end
-				end
-
-				if json_output
-					output.puts JSON.pretty_generate( { command: "status", repos: results, repositories: results } )
-				else
-					puts_line "Carson #{Carson::VERSION} — Portfolio (#{repositories.length} repo#{plural_suffix( count: repositories.length )})"
-					puts_line ""
-					results.each { |result| print_portfolio_status( result: result ) }
-				end
-
-				EXIT_OK
-			end
-
 		private
 
 			def gather_status
@@ -108,7 +74,7 @@ module Carson
 			end
 
 			def main_worktree_context?
-				realpath_safe( repo_root ) == realpath_safe( main_worktree_root )
+				realpath_safe( work_dir ) == realpath_safe( main_worktree_root )
 			end
 
 			def remote_sync_status( branch: )
@@ -181,18 +147,6 @@ module Carson
 				end
 			end
 
-			def print_portfolio_status( result: )
-				if result.fetch( :status ) == "error"
-					puts_line "#{result.fetch( :name )}: #{result.fetch( :error )}"
-					return
-				end
-
-				deliveries = Array( result.fetch( :branches, [] ) )
-				counts = deliveries.each_with_object( Hash.new( 0 ) ) { |delivery, memo| memo[ delivery.fetch( :delivery_state ) ] += 1 }
-				summary = counts.empty? ? "no active deliveries" : counts.map { |state, count| "#{count} #{state}" }.join( ", " )
-				puts_line "#{result.fetch( :name )} — #{summary}"
-			end
-
 			def format_sync( sync: )
 				case sync
 				when :in_sync then "in sync with remote"