carson 2.24.0 → 2.25.0

data/lib/carson/runtime/local.rb

@@ -1,1230 +1,11 @@
+require_relative "local/sync"
+require_relative "local/prune"
+require_relative "local/template"
+require_relative "local/hooks"
+require_relative "local/onboard"
+
 module Carson
 	class Runtime
-		module Local
-			TEMPLATE_SYNC_BRANCH = "carson/template-sync".freeze
-
-			def sync!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				unless working_tree_clean?
-					puts_line "BLOCK: working tree is dirty; commit/stash first, then run carson sync."
-					return EXIT_BLOCK
-				end
-				start_branch = current_branch
-				switched = false
-				git_system!( "fetch", config.git_remote, "--prune" )
-				if start_branch != config.main_branch
-					git_system!( "switch", config.main_branch )
-					switched = true
-				end
-				git_system!( "pull", "--ff-only", config.git_remote, config.main_branch )
-				ahead_count, behind_count, error_text = main_sync_counts
-				if error_text
-					puts_line "BLOCK: unable to verify main sync state (#{error_text})."
-					return EXIT_BLOCK
-				end
-				if ahead_count.zero? && behind_count.zero?
-					puts_line "OK: local #{config.main_branch} is now in sync with #{config.git_remote}/#{config.main_branch}."
-					return EXIT_OK
-				end
-				puts_line "BLOCK: local #{config.main_branch} still diverges (ahead=#{ahead_count}, behind=#{behind_count})."
-				EXIT_BLOCK
-			ensure
-				git_system!( "switch", start_branch ) if switched && branch_exists?( branch_name: start_branch )
-			end
-
-			# Removes stale local branches (gone upstream) and orphan branches (no tracking) with merged PR evidence.
-			def prune!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				git_system!( "fetch", config.git_remote, "--prune" )
-				active_branch = current_branch
-				counters = { deleted: 0, skipped: 0 }
-
-				stale_branches = stale_local_branches
-				prune_stale_branch_entries( stale_branches: stale_branches, active_branch: active_branch, counters: counters )
-
-				orphan_branches = orphan_local_branches( active_branch: active_branch )
-				prune_orphan_branch_entries( orphan_branches: orphan_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 )}"
-				unless verbose?
-					deleted_count = counters.fetch( :deleted )
-					if deleted_count.zero?
-						puts_line "No stale branches."
-					else
-						puts_line "Pruned #{deleted_count} stale branch#{plural_suffix( count: deleted_count )}."
-					end
-				end
-				EXIT_OK
-			end
-
-			def prune_no_stale_branches
-				if verbose?
-					puts_line "OK: no stale or orphan branches to prune."
-				else
-					puts_line "No stale branches."
-				end
-				EXIT_OK
-			end
-
-			def prune_stale_branch_entries( stale_branches:, active_branch:, counters: { deleted: 0, skipped: 0 } )
-				stale_branches.each do |entry|
-					outcome = prune_stale_branch_entry( entry: entry, active_branch: active_branch )
-					counters[ outcome ] += 1
-				end
-				counters
-			end
-
-			def prune_stale_branch_entry( entry:, active_branch: )
-				branch = entry.fetch( :branch )
-				upstream = entry.fetch( :upstream )
-				return prune_skip_stale_branch( type: :protected, branch: branch, upstream: upstream ) if config.protected_branches.include?( branch )
-				return prune_skip_stale_branch( type: :current, branch: branch, upstream: upstream ) if branch == active_branch
-
-				prune_delete_stale_branch( branch: branch, upstream: upstream )
-			end
-
-			def prune_skip_stale_branch( type:, branch:, upstream: )
-				status = type == :protected ? "skip_protected_branch" : "skip_current_branch"
-				puts_verbose "#{status}: #{branch} (upstream=#{upstream})"
-				:skipped
-			end
-
-			def prune_delete_stale_branch( branch:, upstream: )
-				stdout_text, stderr_text, success, = git_run( "branch", "-d", branch )
-				return prune_safe_delete_success( branch: branch, upstream: upstream, stdout_text: stdout_text ) if success
-
-				delete_error_text = normalise_branch_delete_error( error_text: stderr_text )
-				prune_force_delete_stale_branch(
-					branch: branch,
-					upstream: upstream,
-					delete_error_text: delete_error_text
-				)
-			end
-
-			def prune_safe_delete_success( branch:, upstream:, stdout_text: )
-				out.print stdout_text if verbose? && !stdout_text.empty?
-				puts_verbose "deleted_local_branch: #{branch} (upstream=#{upstream})"
-				:deleted
-			end
-
-			def prune_force_delete_stale_branch( branch:, upstream:, delete_error_text: )
-				merged_pr, force_error = force_delete_evidence_for_stale_branch(
-					branch: branch,
-					delete_error_text: delete_error_text
-				)
-				return prune_force_delete_skipped( branch: branch, upstream: upstream, delete_error_text: delete_error_text, force_error: force_error ) if merged_pr.nil?
-
-				force_stdout, force_stderr, force_success, = git_run( "branch", "-D", branch )
-				return prune_force_delete_success( branch: branch, upstream: upstream, merged_pr: merged_pr, force_stdout: force_stdout ) if force_success
-
-				prune_force_delete_failed( branch: branch, upstream: upstream, force_stderr: force_stderr )
-			end
-
-			def prune_force_delete_success( branch:, upstream:, merged_pr:, force_stdout: )
-				out.print force_stdout if verbose? && !force_stdout.empty?
-				puts_verbose "deleted_local_branch_force: #{branch} (upstream=#{upstream}) merged_pr=#{merged_pr.fetch( :url )}"
-				:deleted
-			end
-
-			def prune_force_delete_failed( branch:, upstream:, force_stderr: )
-				force_error_text = normalise_branch_delete_error( error_text: force_stderr )
-				puts_verbose "fail_force_delete_branch: #{branch} (upstream=#{upstream}) reason=#{force_error_text}"
-				:skipped
-			end
-
-			def prune_force_delete_skipped( branch:, upstream:, delete_error_text:, force_error: )
-				puts_verbose "skip_delete_branch: #{branch} (upstream=#{upstream}) reason=#{delete_error_text}"
-				puts_verbose "skip_force_delete_branch: #{branch} (upstream=#{upstream}) reason=#{force_error}" unless force_error.to_s.strip.empty?
-				:skipped
-			end
-
-			def normalise_branch_delete_error( error_text: )
-				text = error_text.to_s.strip
-				text.empty? ? "unknown error" : text
-			end
-
-			# Installs required hook files and enforces repository hook path.
-			def prepare!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				FileUtils.mkdir_p( hooks_dir )
-				missing_templates = config.required_hooks.reject { |name| File.file?( hook_template_path( hook_name: name ) ) }
-				unless missing_templates.empty?
-					puts_line "BLOCK: missing hook templates in Carson: #{missing_templates.join( ', ' )}."
-					return EXIT_BLOCK
-				end
-
-				symlinked = symlink_hook_files
-				unless symlinked.empty?
-					puts_line "BLOCK: symlink hook files are not allowed: #{symlinked.join( ', ' )}."
-					return EXIT_BLOCK
-				end
-
-				config.required_hooks.each do |hook_name|
-					source_path = hook_template_path( hook_name: hook_name )
-					target_path = File.join( hooks_dir, hook_name )
-					FileUtils.cp( source_path, target_path )
-					FileUtils.chmod( 0o755, target_path )
-					puts_verbose "hook_written: #{relative_path( target_path )}"
-				end
-				git_system!( "config", "core.hooksPath", hooks_dir )
-				File.write( File.join( hooks_dir, "workflow_style" ), config.workflow_style )
-				puts_verbose "configured_hooks_path: #{hooks_dir}"
-				unless verbose?
-					puts_line "Hooks installed (#{config.required_hooks.count} hooks)."
-					return EXIT_OK
-				end
-
-				inspect!
-			end
-
-			# One-command onboarding for new repositories: detect remote, install hooks,
-			# apply templates, and run initial audit.
-			def onboard!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				unless inside_git_work_tree?
-					puts_line "ERROR: #{repo_root} is not a git repository."
-					return EXIT_ERROR
-				end
-
-				repo_name = File.basename( repo_root )
-				puts_line ""
-				puts_line "Onboarding #{repo_name}..."
-
-				if !global_config_exists? || !git_remote_exists?( remote_name: config.git_remote )
-					if self.in.respond_to?( :tty? ) && self.in.tty?
-						setup_status = setup!
-						return setup_status unless setup_status == EXIT_OK
-					else
-						silent_setup!
-					end
-				end
-
-				onboard_apply!
-			end
-
-			# Re-applies hooks, templates, and audit after upgrading Carson.
-			def refresh!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				unless inside_git_work_tree?
-					puts_line "ERROR: #{repo_root} is not a git repository."
-					return EXIT_ERROR
-				end
-
-				if verbose?
-					puts_verbose ""
-					puts_verbose "[Refresh]"
-					hook_status = prepare!
-					return hook_status unless hook_status == EXIT_OK
-
-					drift_count = template_results.count { |entry| entry.fetch( :status ) != "ok" }
-					template_status = template_apply!
-					return template_status unless template_status == EXIT_OK
-
-					@template_sync_result = template_propagate!( drift_count: drift_count )
-
-					audit_status = audit!
-					if audit_status == EXIT_OK
-						puts_line "OK: Carson refresh completed for #{repo_root}."
-					elsif audit_status == EXIT_BLOCK
-						puts_line "BLOCK: Carson refresh completed with policy blocks; resolve and rerun carson audit."
-					end
-					return audit_status
-				end
-
-				puts_line "Refresh"
-				hook_status = with_captured_output { prepare! }
-				return hook_status unless hook_status == EXIT_OK
-				puts_line "Hooks installed (#{config.required_hooks.count} hooks)."
-
-				template_drift_count = template_results.count { |entry| entry.fetch( :status ) != "ok" }
-				template_status = with_captured_output { template_apply! }
-				return template_status unless template_status == EXIT_OK
-				if template_drift_count.positive?
-					puts_line "Templates applied (#{template_drift_count} updated)."
-				else
-					puts_line "Templates in sync."
-				end
-
-				@template_sync_result = template_propagate!( drift_count: template_drift_count )
-
-				audit_status = audit!
-				puts_line "Refresh complete."
-				audit_status
-			end
-
-			# Re-applies hooks, templates, and audit across all governed repositories.
-			def refresh_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 "Refresh all (#{repos.length} repo#{plural_suffix( count: repos.length )})"
-				refreshed = 0
-				failed = 0
-
-				repos.each do |repo_path|
-					repo_name = File.basename( repo_path )
-					unless Dir.exist?( repo_path )
-						puts_line "#{repo_name}: FAIL (path not found)"
-						failed += 1
-						next
-					end
-
-					status = refresh_single_repo( repo_path: repo_path, repo_name: repo_name )
-					if status == EXIT_ERROR
-						failed += 1
-					else
-						refreshed += 1
-					end
-				end
-
-				puts_line ""
-				puts_line "Refresh all complete: #{refreshed} refreshed, #{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 ""
-				puts_verbose "[Offboard]"
-				unless inside_git_work_tree?
-					puts_line "ERROR: #{repo_root} is not a git repository."
-					return EXIT_ERROR
-				end
-				hooks_status = disable_carson_hooks_path!
-				return hooks_status unless hooks_status == EXIT_OK
-
-				removed_count = 0
-				missing_count = 0
-				offboard_cleanup_targets.each do |relative|
-					absolute = resolve_repo_path!( relative_path: relative, label: "offboard target #{relative}" )
-					if File.exist?( absolute )
-						FileUtils.rm_rf( absolute )
-						puts_verbose "removed_path: #{relative}"
-						removed_count += 1
-					else
-						puts_verbose "skip_missing_path: #{relative}"
-						missing_count += 1
-					end
-				end
-				remove_empty_offboard_directories!
-				remove_govern_repo!( repo_path: File.expand_path( repo_root ) )
-				puts_verbose "govern_deregistered: #{File.expand_path( repo_root )}"
-				puts_verbose "offboard_summary: removed=#{removed_count} missing=#{missing_count}"
-				if verbose?
-					puts_line "OK: Carson offboard completed for #{repo_root}."
-				else
-					puts_line "Removed #{removed_count} file#{plural_suffix( count: removed_count )}. Offboard complete."
-				end
-				EXIT_OK
-			end
-
-			# Strict hook health check used by humans, hooks, and CI paths.
-			def inspect!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				puts_verbose ""
-				puts_verbose "[Inspect]"
-				ok = hooks_health_report( strict: true )
-				puts_verbose( ok ? "status: ok" : "status: block" )
-				unless verbose?
-					puts_line( ok ? "Hooks: ok" : "Hooks: block" )
-				end
-				ok ? EXIT_OK : EXIT_BLOCK
-			end
-
-			# Read-only template drift check; returns block when managed files are out of sync.
-			def template_check!
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				puts_verbose ""
-				puts_verbose "[Template Sync Check]"
-				results = template_results
-				stale = template_superseded_present
-				drift_count = results.count { |entry| entry.fetch( :status ) == "drift" }
-				error_count = results.count { |entry| entry.fetch( :status ) == "error" }
-				stale_count = stale.count
-				results.each do |entry|
-					puts_verbose "template_file: #{entry.fetch( :file )} status=#{entry.fetch( :status )} reason=#{entry.fetch( :reason )}"
-				end
-				stale.each { |file| puts_verbose "template_file: #{file} status=stale reason=superseded" }
-				puts_verbose "template_summary: total=#{results.count} drift=#{drift_count} stale=#{stale_count} error=#{error_count}"
-				unless verbose?
-					if ( drift_count + stale_count ).positive?
-						summary_parts = []
-						summary_parts << "#{drift_count} of #{results.count} drifted" if drift_count.positive?
-						summary_parts << "#{stale_count} stale" if stale_count.positive?
-						puts_line "Templates: #{summary_parts.join( ", " )}"
-						results.select { |entry| entry.fetch( :status ) == "drift" }.each { |entry| puts_line "  #{entry.fetch( :file )}" }
-						stale.each { |file| puts_line "  #{file} — superseded" }
-					else
-						puts_line "Templates: #{results.count} files in sync"
-					end
-				end
-				return EXIT_ERROR if error_count.positive?
-
-				( drift_count + stale_count ).positive? ? EXIT_BLOCK : EXIT_OK
-			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 )
-				fingerprint_status = block_if_outsider_fingerprints!
-				return fingerprint_status unless fingerprint_status.nil?
-
-				puts_verbose ""
-				puts_verbose "[Template Sync Apply]"
-				results = template_results
-				stale = template_superseded_present
-				applied = 0
-				results.each do |entry|
-					if entry.fetch( :status ) == "error"
-						puts_verbose "template_file: #{entry.fetch( :file )} status=error reason=#{entry.fetch( :reason )}"
-						next
-					end
-
-					file_path = File.join( repo_root, entry.fetch( :file ) )
-					if entry.fetch( :status ) == "ok"
-						puts_verbose "template_file: #{entry.fetch( :file )} status=ok reason=in_sync"
-						next
-					end
-
-					FileUtils.mkdir_p( File.dirname( file_path ) )
-					File.write( file_path, entry.fetch( :applied_content ) )
-					puts_verbose "template_file: #{entry.fetch( :file )} status=updated reason=#{entry.fetch( :reason )}"
-					applied += 1
-				end
-
-				removed = 0
-				stale.each do |file|
-					file_path = resolve_repo_path!( relative_path: file, label: "template.superseded_files entry #{file}" )
-					File.delete( file_path )
-					puts_verbose "template_file: #{file} status=removed reason=superseded"
-					removed += 1
-				end
-
-				error_count = results.count { |entry| entry.fetch( :status ) == "error" }
-				puts_verbose "template_apply_summary: updated=#{applied} removed=#{removed} error=#{error_count}"
-				unless verbose?
-					if applied.positive? || removed.positive?
-						summary_parts = []
-						summary_parts << "#{applied} updated" if applied.positive?
-						summary_parts << "#{removed} removed" if removed.positive?
-						puts_line "Templates applied (#{summary_parts.join( ", " )})."
-					else
-						puts_line "Templates in sync."
-					end
-				end
-				return EXIT_ERROR if error_count.positive?
-
-				return EXIT_BLOCK if push_prep && push_prep_commit!
-				EXIT_OK
-			end
-
-		private
-
-			# Orchestrates worktree-based template propagation to the remote.
-			# Skips silently when there is no drift or no remote configured.
-			# Returns a result hash stored in @template_sync_result.
-			def template_propagate!( drift_count: )
-				if drift_count.zero?
-					puts_verbose "template_propagate: skip (no drift)"
-					return { status: :skip, reason: "no drift" }
-				end
-
-				unless git_remote_exists?( remote_name: config.git_remote )
-					puts_verbose "template_propagate: skip (no remote #{config.git_remote})"
-					return { status: :skip, reason: "no remote" }
-				end
-
-				worktree_dir = nil
-				begin
-					worktree_dir = template_propagate_create_worktree!
-					template_propagate_write_files!( worktree_dir: worktree_dir )
-					committed = template_propagate_commit!( worktree_dir: worktree_dir )
-					unless committed
-						puts_verbose "template_propagate: skip (no changes after write)"
-						return { status: :skip, reason: "no changes" }
-					end
-					result = template_propagate_deliver!( worktree_dir: worktree_dir )
-					template_propagate_report!( result: result )
-					result
-				rescue StandardError => e
-					puts_verbose "template_propagate: error (#{e.message})"
-					{ status: :error, reason: e.message }
-				ensure
-					template_propagate_cleanup!( worktree_dir: worktree_dir ) if worktree_dir
-				end
-			end
-
-			# Creates a detached worktree from the remote main, checks out the sync branch,
-			# and disables hooks so Carson's own pre-commit never fires inside the worktree.
-			def template_propagate_create_worktree!
-				worktree_dir = File.join( Dir.tmpdir, "carson-template-sync-#{Process.pid}-#{Time.now.to_i}" )
-				wt_git = Adapters::Git.new( repo_root: worktree_dir )
-
-				git_system!( "fetch", config.git_remote, config.main_branch )
-				git_system!( "worktree", "add", "--detach", worktree_dir, "#{config.git_remote}/#{config.main_branch}" )
-				wt_git.run( "checkout", "-B", TEMPLATE_SYNC_BRANCH )
-				wt_git.run( "config", "core.hooksPath", "/dev/null" )
-				puts_verbose "template_propagate: worktree created at #{worktree_dir}"
-				worktree_dir
-			end
-
-			# Copies all Carson template source files into the worktree.
-			# Also removes superseded files present in the worktree.
-			def template_propagate_write_files!( worktree_dir: )
-				config.template_managed_files.each do |managed_file|
-					template_path = template_source_path( managed_file: managed_file )
-					next if template_path.nil?
-
-					target_path = File.join( worktree_dir, managed_file )
-					FileUtils.mkdir_p( File.dirname( target_path ) )
-					expected_content = normalize_text( text: File.read( template_path ) )
-					File.write( target_path, expected_content )
-					puts_verbose "template_propagate: wrote #{managed_file}"
-				end
-
-				template_superseded_present_in( root: worktree_dir ).each do |file|
-					file_path = File.join( worktree_dir, file )
-					File.delete( file_path )
-					puts_verbose "template_propagate: removed superseded #{file}"
-				end
-			end
-
-			# Stages all changes in the worktree and commits if there is an actual diff.
-			# Returns true if a commit was created, false if worktree content matches remote.
-			def template_propagate_commit!( worktree_dir: )
-				wt_git = Adapters::Git.new( repo_root: worktree_dir )
-				wt_git.run( "add", "--all" )
-
-				_, _, no_diff, = wt_git.run( "diff", "--cached", "--quiet" )
-				return false if no_diff
-
-				wt_git.run( "commit", "-m", "chore: sync Carson #{Carson::VERSION} managed templates" )
-				puts_verbose "template_propagate: committed"
-				true
-			end
-
-			# Dispatches to trunk or branch delivery based on workflow style.
-			def template_propagate_deliver!( worktree_dir: )
-				if config.workflow_style == "trunk"
-					template_propagate_deliver_trunk!( worktree_dir: worktree_dir )
-				else
-					template_propagate_deliver_branch!( worktree_dir: worktree_dir )
-				end
-			end
-
-			# Trunk mode: push template changes directly to main.
-			def template_propagate_deliver_trunk!( worktree_dir: )
-				wt_git = Adapters::Git.new( repo_root: worktree_dir )
-				stdout_text, stderr_text, success, = wt_git.run( "push", config.git_remote, "HEAD:refs/heads/#{config.main_branch}" )
-				unless success
-					error_text = stderr_text.to_s.strip
-					error_text = "push to #{config.main_branch} failed" if error_text.empty?
-					raise error_text
-				end
-				puts_verbose "template_propagate: pushed to #{config.main_branch}"
-				{ status: :pushed, ref: config.main_branch }
-			end
-
-			# Branch mode: force-push the sync branch and ensure a PR exists.
-			def template_propagate_deliver_branch!( worktree_dir: )
-				wt_git = Adapters::Git.new( repo_root: worktree_dir )
-				stdout_text, stderr_text, success, = wt_git.run( "push", "--force-with-lease", config.git_remote, "#{TEMPLATE_SYNC_BRANCH}:#{TEMPLATE_SYNC_BRANCH}" )
-				unless success
-					error_text = stderr_text.to_s.strip
-					error_text = "push #{TEMPLATE_SYNC_BRANCH} failed" if error_text.empty?
-					raise error_text
-				end
-				puts_verbose "template_propagate: pushed #{TEMPLATE_SYNC_BRANCH}"
-
-				pr_url = template_propagate_ensure_pr!( worktree_dir: worktree_dir )
-				{ status: :pr, branch: TEMPLATE_SYNC_BRANCH, pr_url: pr_url }
-			end
-
-			# Checks for an existing open PR from the sync branch; creates one if none exists.
-			# Returns the PR URL.
-			def template_propagate_ensure_pr!( worktree_dir: )
-				wt_gh = Adapters::GitHub.new( repo_root: worktree_dir )
-
-				# Check for existing open PR.
-				stdout_text, _, success, = wt_gh.run(
-					"pr", "list",
-					"--head", TEMPLATE_SYNC_BRANCH,
-					"--base", config.main_branch,
-					"--state", "open",
-					"--json", "url",
-					"--jq", ".[0].url"
-				)
-				existing_url = stdout_text.to_s.strip
-				if success && !existing_url.empty?
-					puts_verbose "template_propagate: existing PR #{existing_url}"
-					return existing_url
-				end
-
-				# Create new PR.
-				stdout_text, stderr_text, success, = wt_gh.run(
-					"pr", "create",
-					"--head", TEMPLATE_SYNC_BRANCH,
-					"--base", config.main_branch,
-					"--title", "chore: sync Carson #{Carson::VERSION} managed templates",
-					"--body", "Auto-generated by `carson refresh`.\n\nUpdates managed template files to match Carson #{Carson::VERSION}."
-				)
-				unless success
-					error_text = stderr_text.to_s.strip
-					error_text = "gh pr create failed" if error_text.empty?
-					raise error_text
-				end
-				pr_url = stdout_text.to_s.strip
-				puts_verbose "template_propagate: created PR #{pr_url}"
-				pr_url
-			end
-
-			# Removes the worktree and the local sync branch it created.
-			def template_propagate_cleanup!( worktree_dir: )
-				git_run( "worktree", "remove", "--force", worktree_dir )
-				git_run( "branch", "-D", TEMPLATE_SYNC_BRANCH )
-				puts_verbose "template_propagate: worktree and local branch cleaned up"
-			rescue StandardError => e
-				puts_verbose "template_propagate: cleanup warning (#{e.message})"
-			end
-
-			# Prints a human-readable summary of the propagation result.
-			def template_propagate_report!( result: )
-				case result.fetch( :status )
-				when :pushed
-					puts_line "Templates pushed to #{result.fetch( :ref )}."
-				when :pr
-					puts_line "Template sync PR: #{result.fetch( :pr_url )}"
-				end
-			end
-
-			# Checks which superseded files exist under an arbitrary root directory.
-			def template_superseded_present_in( root: )
-				config.template_superseded_files.select do |file|
-					File.file?( File.join( root, file ) )
-				end
-			end
-
-			def refresh_sync_suffix( result: )
-				return "" if result.nil?
-
-				case result.fetch( :status )
-				when :pushed then " (templates pushed to #{result.fetch( :ref )})"
-				when :pr then " (PR: #{result.fetch( :pr_url )})"
-				else ""
-				end
-			end
-
-			# Refreshes a single governed repository using a scoped Runtime.
-			def refresh_single_repo( repo_path:, repo_name: )
-				if verbose?
-					rt = Runtime.new( repo_root: repo_path, tool_root: tool_root, out: out, err: err, verbose: true )
-				else
-					rt = Runtime.new( repo_root: repo_path, tool_root: tool_root, out: StringIO.new, err: StringIO.new )
-				end
-				status = rt.refresh!
-				label = refresh_status_label( status: status )
-				sync_suffix = refresh_sync_suffix( result: rt.template_sync_result )
-				puts_line "#{repo_name}: #{label}#{sync_suffix}"
-				status
-			rescue StandardError => e
-				puts_line "#{repo_name}: FAIL (#{e.message})"
-				EXIT_ERROR
-			end
-
-			def refresh_status_label( status: )
-				case status
-				when EXIT_OK then "OK"
-				when EXIT_BLOCK then "BLOCK"
-				else "FAIL"
-				end
-			end
-
-			def template_results
-				config.template_managed_files.map { |managed_file| template_result_for_file( managed_file: managed_file ) }
-			end
-
-			def template_superseded_present
-				config.template_superseded_files.select do |file|
-					file_path = resolve_repo_path!( relative_path: file, label: "template.superseded_files entry #{file}" )
-					File.file?( file_path )
-				end
-			end
-
-			# Calculates whole-file expected content and returns sync status plus apply payload.
-			def template_result_for_file( managed_file: )
-				template_path = template_source_path( managed_file: managed_file )
-				return { file: managed_file, status: "error", reason: "missing template #{File.basename( managed_file )}", applied_content: nil } if template_path.nil?
-
-				expected_content = normalize_text( text: File.read( template_path ) )
-				file_path = resolve_repo_path!( relative_path: managed_file, label: "template.managed_files entry #{managed_file}" )
-				return { file: managed_file, status: "drift", reason: "missing_file", applied_content: expected_content } unless File.file?( file_path )
-
-				current_content = normalize_text( text: File.read( file_path ) )
-				return { file: managed_file, status: "ok", reason: "in_sync", applied_content: current_content } if current_content == expected_content
-
-				{ file: managed_file, status: "drift", reason: "content_mismatch", applied_content: expected_content }
-			end
-
-			# Uses LF-only normalisation so platform newlines do not cause false drift.
-			def normalize_text( text: )
-				"#{text.to_s.gsub( "\r\n", "\n" ).rstrip}\n"
-			end
-
-			# GitHub managed template source directory inside Carson repository.
-			def github_templates_dir
-				File.join( tool_root, "templates", ".github" )
-			end
-
-			# Resolves the source file path for a managed template.
-			# Checks the user's canonical directory first, then falls back to Carson's built-in templates.
-			def template_source_path( managed_file: )
-				relative_within_github = managed_file.delete_prefix( ".github/" )
-
-				# Canonical source: the user's canonical .github/ files.
-				canonical = config.template_canonical
-				if canonical && !canonical.empty?
-					canonical_path = File.join( canonical, relative_within_github )
-					return canonical_path if File.file?( canonical_path )
-				end
-
-				# Carson built-in templates: subdirectory-aware path first, then flat basename fallback.
-				template_path = File.join( github_templates_dir, relative_within_github )
-				return template_path if File.file?( template_path )
-
-				basename_path = File.join( github_templates_dir, File.basename( managed_file ) )
-				return basename_path if File.file?( basename_path )
-
-				nil
-			end
-
-			# Canonical hook template location inside Carson repository.
-			def hook_template_path( hook_name: )
-				File.join( tool_root, "hooks", hook_name )
-			end
-
-			# Reports full hook health and can enforce stricter action messaging in `check`.
-			def hooks_health_report( strict: false )
-				configured = configured_hooks_path
-				expected = hooks_dir
-				hooks_path_ok = print_hooks_path_status( configured: configured, expected: expected )
-				print_required_hook_status
-				hooks_integrity = hook_integrity_state
-				hooks_ok = hooks_integrity_ok?( hooks_integrity: hooks_integrity )
-				print_hook_action(
-					strict: strict,
-					hooks_ok: hooks_path_ok && hooks_ok,
-					hooks_path_ok: hooks_path_ok,
-					configured: configured,
-					expected: expected
-				)
-				hooks_path_ok && hooks_ok
-			end
-
-			def print_hooks_path_status( configured:, expected: )
-				configured_abs = configured.nil? ? nil : File.expand_path( configured )
-				hooks_path_ok = configured_abs == expected
-				puts_verbose "hooks_path: #{configured || '(unset)'}"
-				puts_verbose "hooks_path_expected: #{expected}"
-				puts_verbose( hooks_path_ok ? "hooks_path_status: ok" : "hooks_path_status: attention" )
-				hooks_path_ok
-			end
-
-			def print_required_hook_status
-				required_hook_paths.each do |path|
-					exists = File.file?( path )
-					symlink = File.symlink?( path )
-					executable = exists && !symlink && File.executable?( path )
-					puts_verbose "hook_file: #{relative_path( path )} exists=#{exists} symlink=#{symlink} executable=#{executable}"
-				end
-			end
-
-			def hook_integrity_state
-				{
-					missing: missing_hook_files,
-					non_executable: non_executable_hook_files,
-					symlinked: symlink_hook_files
-				}
-			end
-
-			def hooks_integrity_ok?( hooks_integrity: )
-				missing_ok = hooks_integrity.fetch( :missing ).empty?
-				non_executable_ok = hooks_integrity.fetch( :non_executable ).empty?
-				symlinked_ok = hooks_integrity.fetch( :symlinked ).empty?
-				missing_ok && non_executable_ok && symlinked_ok
-			end
-
-			def print_hook_action( strict:, hooks_ok:, hooks_path_ok:, configured:, expected: )
-				return if hooks_ok
-
-				if strict && !hooks_path_ok
-					configured_text = configured.to_s.strip
-					if configured_text.empty?
-						puts_verbose "ACTION: hooks path is unset (expected=#{expected})."
-					else
-						puts_verbose "ACTION: hooks path mismatch (configured=#{configured_text}, expected=#{expected})."
-					end
-				end
-				message = strict ? "ACTION: run carson prepare to align hooks with Carson #{Carson::VERSION}." : "ACTION: run carson prepare to enforce local main protections."
-				puts_verbose message
-			end
-
-			# Returns ahead/behind counts for local main versus configured remote main.
-			def main_sync_counts
-				target = "#{config.main_branch}...#{config.git_remote}/#{config.main_branch}"
-				stdout_text, stderr_text, success, = git_run( "rev-list", "--left-right", "--count", target )
-				unless success
-					error_text = stderr_text.to_s.strip
-					error_text = "git rev-list failed" if error_text.empty?
-					return [ 0, 0, error_text ]
-				end
-				counts = stdout_text.to_s.strip.split( /\s+/ )
-				return [ 0, 0, "unexpected rev-list output: #{stdout_text.to_s.strip}" ] if counts.length < 2
-
-				[ counts[ 0 ].to_i, counts[ 1 ].to_i, nil ]
-			end
-
-			# Reads configured core.hooksPath and normalises empty values to nil.
-			def configured_hooks_path
-				stdout_text, = git_capture_soft( "config", "--get", "core.hooksPath" )
-				value = stdout_text.to_s.strip
-				value.empty? ? nil : value
-			end
-
-			# Fully-qualified required hook file locations in the target repository.
-			def required_hook_paths
-				config.required_hooks.map { |name| File.join( hooks_dir, name ) }
-			end
-
-			# Missing required hook files.
-			def missing_hook_files
-				required_hook_paths.reject { |path| File.file?( path ) }.map { |path| relative_path( path ) }
-			end
-
-			# Required hook files that exist but are not executable.
-			def non_executable_hook_files
-				required_hook_paths.select { |path| File.file?( path ) && !File.executable?( path ) }.map { |path| relative_path( path ) }
-			end
-
-			# Symlink hooks are disallowed to prevent bypassing managed hook content.
-			def symlink_hook_files
-				required_hook_paths.select { |path| File.symlink?( path ) }.map { |path| relative_path( path ) }
-			end
-
-			# Local directory where managed hooks are installed.
-			def hooks_dir
-				File.expand_path( File.join( config.hooks_base_path, Carson::VERSION ) )
-			end
-
-			# In outsider mode, Carson must not leave Carson-owned fingerprints in host repositories.
-			def block_if_outsider_fingerprints!
-				return nil unless outsider_mode?
-
-				violations = outsider_fingerprint_violations
-				return nil if violations.empty?
-
-				violations.each { |entry| puts_line "BLOCK: #{entry}" }
-				EXIT_BLOCK
-			end
-
-			# Carson source repository itself is excluded from host-repository fingerprint checks.
-			def outsider_mode?
-				File.expand_path( repo_root ) != File.expand_path( tool_root )
-			end
-
-			# Detects Carson-owned host artefacts that violate outsider boundary.
-			def outsider_fingerprint_violations
-				violations = []
-				violations << "forbidden file .carson.yml detected" if File.file?( File.join( repo_root, ".carson.yml" ) )
-				violations << "forbidden file bin/carson detected" if File.file?( File.join( repo_root, "bin", "carson" ) )
-				violations << "forbidden directory .tools/carson detected" if Dir.exist?( File.join( repo_root, ".tools", "carson" ) )
-				violations
-			end
-
-			# Detects local branches whose upstream tracking is marked [gone] after fetch --prune.
-			# Branches without upstream tracking are handled separately by orphan_local_branches.
-			def stale_local_branches
-				git_capture!( "for-each-ref", "--format=%(refname:short)\t%(upstream:short)\t%(upstream:track)", "refs/heads" ).lines.map do |line|
-					branch, upstream, track = line.strip.split( "\t", 3 )
-					upstream = upstream.to_s
-					track = track.to_s
-					next if branch.to_s.empty? || upstream.empty?
-					next unless upstream.start_with?( "#{config.git_remote}/" ) && track.include?( "gone" )
-
-					{ branch: branch, upstream: upstream, track: track }
-				end.compact
-			end
-
-			# Detects local branches with no upstream tracking ref — candidates for orphan pruning.
-			# Filters out protected branches, the active branch, and Carson's own sync branch.
-			def orphan_local_branches( active_branch: )
-				git_capture!( "for-each-ref", "--format=%(refname:short)\t%(upstream:short)", "refs/heads" ).lines.filter_map do |line|
-					branch, upstream = line.strip.split( "\t", 2 )
-					branch = branch.to_s.strip
-					upstream = upstream.to_s.strip
-					next if branch.empty?
-					next unless upstream.empty?
-					next if config.protected_branches.include?( branch )
-					next if branch == active_branch
-					next if branch == TEMPLATE_SYNC_BRANCH
-
-					branch
-				end
-			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?
-				return counters unless gh_available?
-
-				orphan_branches.each do |branch|
-					outcome = prune_orphan_branch_entry( branch: branch )
-					counters[ outcome ] += 1
-				end
-				counters
-			end
-
-			# Checks a single orphan branch for merged PR evidence and force-deletes if confirmed.
-			def prune_orphan_branch_entry( branch: )
-				tip_sha_text, tip_sha_error, tip_sha_success, = git_run( "rev-parse", "--verify", branch.to_s )
-				unless tip_sha_success
-					error_text = tip_sha_error.to_s.strip
-					error_text = "unable to read local branch tip sha" if error_text.empty?
-					puts_verbose "skip_orphan_branch: #{branch} reason=#{error_text}"
-					return :skipped
-				end
-				branch_tip_sha = tip_sha_text.to_s.strip
-				if branch_tip_sha.empty?
-					puts_verbose "skip_orphan_branch: #{branch} reason=unable to read local branch tip sha"
-					return :skipped
-				end
-
-				merged_pr, error = merged_pr_for_branch( branch: branch, branch_tip_sha: branch_tip_sha )
-				if merged_pr.nil?
-					reason = error.to_s.strip
-					reason = "no merged PR evidence for branch tip into #{config.main_branch}" if reason.empty?
-					puts_verbose "skip_orphan_branch: #{branch} reason=#{reason}"
-					return :skipped
-				end
-
-				force_stdout, force_stderr, force_success, = git_run( "branch", "-D", branch )
-				if force_success
-					out.print force_stdout if verbose? && !force_stdout.empty?
-					puts_verbose "deleted_orphan_branch: #{branch} merged_pr=#{merged_pr.fetch( :url )}"
-					return :deleted
-				end
-
-				force_error_text = normalise_branch_delete_error( error_text: force_stderr )
-				puts_verbose "fail_delete_orphan_branch: #{branch} reason=#{force_error_text}"
-				:skipped
-			end
-
-			# Safe delete can fail after squash merges because branch tip is no longer an ancestor.
-			def non_merged_delete_error?( error_text: )
-				error_text.to_s.downcase.include?( "not fully merged" )
-			end
-
-			# Guarded force-delete policy for stale branches:
-			# 1) safe delete failure must be merge-related (`not fully merged`),
-			# 2) gh must confirm at least one merged PR for this exact branch into configured main.
-			def force_delete_evidence_for_stale_branch( branch:, delete_error_text: )
-				return [ nil, "safe delete failure is not merge-related" ] unless non_merged_delete_error?( error_text: delete_error_text )
-				return [ nil, "gh CLI not available; cannot verify merged PR evidence" ] unless gh_available?
-
-				tip_sha_text, tip_sha_error, tip_sha_success, = git_run( "rev-parse", "--verify", branch.to_s )
-				unless tip_sha_success
-					error_text = tip_sha_error.to_s.strip
-					error_text = "unable to read local branch tip sha" if error_text.empty?
-					return [ nil, error_text ]
-				end
-				branch_tip_sha = tip_sha_text.to_s.strip
-				return [ nil, "unable to read local branch tip sha" ] if branch_tip_sha.empty?
-
-				merged_pr_for_branch( branch: branch, branch_tip_sha: branch_tip_sha )
-			end
-
-			# Finds merged PR evidence for the exact local branch tip; this blocks old-PR false positives.
-			def merged_pr_for_branch( branch:, branch_tip_sha: )
-				owner, repo = repository_coordinates
-				results = []
-				page = 1
-				max_pages = 50
-				loop do
-					stdout_text, stderr_text, success, = gh_run(
-						"api", "repos/#{owner}/#{repo}/pulls",
-						"--method", "GET",
-						"-f", "state=closed",
-						"-f", "base=#{config.main_branch}",
-						"-f", "head=#{owner}:#{branch}",
-						"-f", "sort=updated",
-						"-f", "direction=desc",
-						"-f", "per_page=100",
-						"-f", "page=#{page}"
-					)
-					unless success
-						error_text = gh_error_text( stdout_text: stdout_text, stderr_text: stderr_text, fallback: "unable to query merged PR evidence for branch #{branch}" )
-						return [ nil, error_text ]
-					end
-					page_nodes = Array( JSON.parse( stdout_text ) )
-					break if page_nodes.empty?
-
-					page_nodes.each do |entry|
-						next unless entry.dig( "head", "ref" ).to_s == branch.to_s
-						next unless entry.dig( "base", "ref" ).to_s == config.main_branch
-						next unless entry.dig( "head", "sha" ).to_s == branch_tip_sha
-
-						merged_at = parse_time_or_nil( text: entry[ "merged_at" ] )
-						next if merged_at.nil?
-
-						results << {
-							number: entry[ "number" ],
-							url: entry[ "html_url" ].to_s,
-							merged_at: merged_at.utc.iso8601,
-							head_sha: entry.dig( "head", "sha" ).to_s
-						}
-						end
-						if page >= max_pages
-							probe_stdout_text, probe_stderr_text, probe_success, = gh_run(
-								"api", "repos/#{owner}/#{repo}/pulls",
-								"--method", "GET",
-								"-f", "state=closed",
-								"-f", "base=#{config.main_branch}",
-								"-f", "head=#{owner}:#{branch}",
-								"-f", "sort=updated",
-								"-f", "direction=desc",
-								"-f", "per_page=100",
-								"-f", "page=#{page + 1}"
-							)
-							unless probe_success
-								error_text = gh_error_text( stdout_text: probe_stdout_text, stderr_text: probe_stderr_text, fallback: "unable to verify merged PR pagination limit for branch #{branch}" )
-								return [ nil, error_text ]
-							end
-							probe_nodes = Array( JSON.parse( probe_stdout_text ) )
-							return [ nil, "merged PR lookup exceeded pagination safety limit (#{max_pages} pages) for branch #{branch}" ] unless probe_nodes.empty?
-							break
-						end
-						page += 1
-					end
-				latest = results.max_by { |item| item.fetch( :merged_at ) }
-				return [ nil, "no merged PR evidence for branch tip #{branch_tip_sha} into #{config.main_branch}" ] if latest.nil?
-
-				[ latest, nil ]
-			rescue JSON::ParserError => e
-				[ nil, "invalid gh JSON response (#{e.message})" ]
-			rescue StandardError => e
-				[ nil, e.message ]
-			end
-
-			def working_tree_clean?
-				git_capture!( "status", "--porcelain" ).strip.empty?
-			end
-
-			def push_prep_commit!
-				# JIT auto-commit is for feature branches only; main is protected from direct commits.
-				return if current_branch == config.main_branch
-
-				dirty = managed_dirty_paths
-				return if dirty.empty?
-
-				git_system!( "add", *dirty )
-				git_system!( "commit", "-m", "chore: sync Carson managed files" )
-				puts_line "Carson committed managed file updates. Push again to include them."
-				true
-			end
-
-			def managed_dirty_paths
-				template_paths = config.template_managed_files + config.template_superseded_files
-				linters_glob   = Dir.glob( File.join( repo_root, ".github/linters/**/*" ) )
-					.select { |p| File.file?( p ) }
-					.map { |p| p.delete_prefix( "#{repo_root}/" ) }
-				candidates = ( template_paths + linters_glob ).uniq
-				return [] if candidates.empty?
-
-				stdout_text, = git_capture_soft( "status", "--porcelain", "--", *candidates )
-				stdout_text.to_s.lines
-					.map { |l| l[ 3.. ].strip }
-					.reject( &:empty? )
-			end
-
-			def inside_git_work_tree?
-				stdout_text, = git_capture_soft( "rev-parse", "--is-inside-work-tree" )
-				stdout_text.to_s.strip == "true"
-			end
-
-			def disable_carson_hooks_path!
-				configured = configured_hooks_path
-				if configured.nil?
-					puts_verbose "hooks_path: (unset)"
-					return EXIT_OK
-				end
-				puts_verbose "hooks_path: #{configured}"
-				configured_abs = File.expand_path( configured, repo_root )
-				unless carson_managed_hooks_path?( configured_abs: configured_abs )
-					puts_verbose "hooks_path_kept: #{configured} (not Carson-managed)"
-					return EXIT_OK
-				end
-				git_system!( "config", "--unset", "core.hooksPath" )
-				puts_verbose "hooks_path_unset: core.hooksPath"
-				EXIT_OK
-			rescue StandardError => e
-				puts_line "ERROR: unable to update core.hooksPath (#{e.message})"
-				EXIT_ERROR
-			end
-
-			def carson_managed_hooks_path?( configured_abs: )
-				hooks_root = File.join( File.expand_path( config.hooks_base_path ), "" )
-				return true if configured_abs.start_with?( hooks_root )
-
-				carson_hook_files_match_templates?( hooks_path: configured_abs )
-			end
-
-			def carson_hook_files_match_templates?( hooks_path: )
-				return false unless Dir.exist?( hooks_path )
-				config.required_hooks.all? do |hook_name|
-					installed_path = File.join( hooks_path, hook_name )
-					template_path = hook_template_path( hook_name: hook_name )
-					next false unless File.file?( installed_path ) && File.file?( template_path )
-
-					installed_content = normalize_text( text: File.read( installed_path ) )
-					template_content = normalize_text( text: File.read( template_path ) )
-					installed_content == template_content
-				end
-			rescue StandardError
-				false
-			end
-
-			def offboard_cleanup_targets
-				( config.template_managed_files + config.template_superseded_files + [
-					".github/workflows/carson-governance.yml",
-					".github/workflows/carson_policy.yml",
-					".carson.yml",
-					"bin/carson",
-					".tools/carson"
-				] ).uniq
-			end
-
-			def remove_empty_offboard_directories!
-				[ ".github/workflows", ".github", ".tools", "bin" ].each do |relative|
-					absolute = resolve_repo_path!( relative_path: relative, label: "offboard cleanup directory #{relative}" )
-					next unless Dir.exist?( absolute )
-					next unless Dir.empty?( absolute )
-
-					Dir.rmdir( absolute )
-					puts_verbose "removed_empty_dir: #{relative}"
-				end
-			end
-
-			# Verifies configured remote exists and logs status without mutating remotes.
-			def report_detected_remote!
-				if git_remote_exists?( remote_name: config.git_remote )
-					puts_verbose "remote_ok: #{config.git_remote}"
-				else
-					puts_line "WARN: remote '#{config.git_remote}' not found; run carson setup to configure."
-				end
-			end
-
-			# Concise onboard orchestration: hooks, templates, remote, audit, guidance.
-			def onboard_apply!
-				hook_status = with_captured_output { prepare! }
-				return hook_status unless hook_status == EXIT_OK
-				puts_line "Hooks installed (#{config.required_hooks.count} hooks)."
-
-				template_drift_count = template_results.count { |entry| entry.fetch( :status ) != "ok" }
-				template_status = with_captured_output { template_apply! }
-				return template_status unless template_status == EXIT_OK
-				if template_drift_count.positive?
-					puts_line "Templates synced (#{template_drift_count} file#{plural_suffix( count: template_drift_count )} updated)."
-				else
-					puts_line "Templates in sync."
-				end
-
-				onboard_report_remote!
-				audit_status = onboard_run_audit!
-
-				puts_line ""
-				puts_line "Carson at your service."
-
-				prompt_govern_registration! if self.in.respond_to?( :tty? ) && self.in.tty?
-
-				puts_line ""
-				puts_line "Your repository is set up. Carson has placed files in your"
-				puts_line "project's .github/ directory — pull request templates,"
-				puts_line "guidelines for AI coding assistants, and any CI or lint"
-				puts_line "rules you've configured. Once pushed to GitHub, they'll"
-				puts_line "ensure every pull request follows a consistent standard"
-				puts_line "and all checks run automatically."
-				puts_line ""
-				puts_line "Before your first push, have a look through .github/ to"
-				puts_line "make sure everything is to your liking."
-				puts_line ""
-				puts_line "To adjust any setting: carson setup"
-
-				audit_status
-			end
-
-			# Friendly remote status for onboard output.
-			def onboard_report_remote!
-				if git_remote_exists?( remote_name: config.git_remote )
-					puts_line "Remote: #{config.git_remote} (connected)."
-				else
-					puts_line "Remote not configured yet — carson setup will walk you through it."
-				end
-			end
-
-			# Runs audit with captured output; reports summary instead of full detail.
-			def onboard_run_audit!
-				audit_error = nil
-				audit_status = with_captured_output { audit! }
-			rescue StandardError => e
-				audit_error = e
-				audit_status = EXIT_OK
-			ensure
-				return onboard_print_audit_result( status: audit_status, error: audit_error )
-			end
-
-			def onboard_print_audit_result( status:, error: )
-				if error
-					if error.message.to_s.match?( /HEAD|rev-parse/ )
-						puts_line "No commits yet — run carson audit after your first commit."
-					else
-						puts_line "Audit skipped — run carson audit for details."
-					end
-					return EXIT_OK
-				end
-
-				if status == EXIT_BLOCK
-					puts_line "Some checks need attention — run carson audit for details."
-				end
-				status
-			end
-
-			# Uses `git remote get-url` as existence check to avoid parsing remote lists.
-			def git_remote_exists?( remote_name: )
-				_, _, success, = git_run( "remote", "get-url", remote_name.to_s )
-				success
-			end
-		end
-
 		include Local
 	end
 end