carson 4.3.1 → 4.3.3

data/lib/carson/warehouse/vault.rb

@@ -1,60 +1,66 @@
-# The warehouse's vault concern.
-# The vault is local main — where accepted parcels live.
-# In local-centred workstyle, the vault is the source of truth.
-# In remote-centred workstyle, the vault is the backup (receives
-# the standard from the bureau's registry after acceptance).
+# The vault — where the production standard lives.
+# The vault is local main. It is the source of truth.
+# Accepted parcels live here permanently.
 require "open3"
 
 module Carson
 	class Warehouse
-		module Vault
+		class Vault
+			attr_reader :main_label
+
+			def initialize( path:, main_label: )
+				@path = path
+				@main_label = main_label
+			end
 
 			# Accept a parcel into the vault.
-			# Fast-forwards local main to include the parcel's branch.
-			# Runs from the main worktree root where main is checked out.
+			# Fast-forwards the standard to include the parcel's branch.
 			#
 			# Precondition: the parcel's branch must be a fast-forward of main.
 			# If not, the agent must rebase first.
-			#
-			# Returns a result hash:
-			#   { status: "ok", branch: ..., head: ... }
-			#   { status: "block", error: ..., recovery: ... }
-			#   { status: "error", error: ..., recovery: ... }
 			def accept!( parcel )
-				root = main_worktree_root
-
-				# Verify main is checked out in the main worktree.
-				unless main_checked_out_at?( root )
+				unless main_checked_out?
 					return {
 						status: "error",
 						error: "#{@main_label} is not checked out in the main worktree.",
-						recovery: "Check the main worktree state at #{root}."
+						recovery: "Check the main worktree state at #{@path}."
 					}
 				end
 
-				# Fast-forward main to include the parcel's branch.
 				_, stderr, status = Open3.capture3(
-					"git", "-C", root, "merge", "--ff-only", parcel.label
+					"git", "-C", @path, "merge", "--ff-only", parcel.label
 				)
 
-				return vault_accepted( parcel, root ) if status.success?
+				return accepted( parcel ) if status.success?
 
-				vault_blocked( parcel, stderr )
+				blocked( parcel, stderr )
+			end
+
+			# Has this label's content been absorbed into the vault?
+			# Content-aware — compares tree content, not SHA ancestry.
+			# Catches rebase-merged and squash-merged branches that
+			# ancestry-based checks miss (replayed SHAs differ).
+			def absorbed?( label )
+				_, _, status = Open3.capture3(
+					"git", "diff", "--quiet", @main_label, label,
+					chdir: @path
+				)
+				status.success?
 			end
 
 		private
 
-			# Check whether main is the checked-out branch at a given path.
-			def main_checked_out_at?( root )
+			# Is main checked out in the vault's worktree?
+			def main_checked_out?
 				head_ref, _, status = Open3.capture3(
-					"git", "-C", root, "rev-parse", "--abbrev-ref", "HEAD"
+					"git", "-C", @path, "rev-parse", "--abbrev-ref", "HEAD"
 				)
 				status.success? && head_ref.strip == @main_label
 			end
 
-			# Build the success result after vault acceptance.
-			def vault_accepted( parcel, root )
-				new_head, = Open3.capture3( "git", "-C", root, "rev-parse", "HEAD" )
+			# Build the success result after acceptance.
+			def accepted( parcel )
+				new_head, = Open3.capture3( "git", "-C", @path, "rev-parse", "HEAD" )
 				{
 					status: "ok",
 					branch: parcel.label,
@@ -62,15 +68,24 @@ module Carson
 				}
 			end
 
-			# Build the blocked/error result when vault acceptance fails.
-			def vault_blocked( parcel, stderr )
-				{
-					status: "block",
-					error: "#{parcel.label} cannot be fast-forwarded into #{@main_label}.",
-					recovery: "Rebase onto #{@main_label} and deliver again."
-				}
+			# Build the blocked result when acceptance fails.
+			# Distinguishes dirty-tree conflicts from diverged-history blocks
+			# so the agent gets the correct recovery advice.
+			def blocked( parcel, stderr )
+				if stderr.to_s.include?( "would be overwritten" )
+					{
+						status: "block",
+						error: "Main worktree has uncommitted changes that conflict with #{parcel.label}.",
+						recovery: "Commit or discard the dirty files in the main worktree, then deliver again."
+					}
+				else
+					{
+						status: "block",
+						error: "#{parcel.label} cannot be fast-forwarded into #{@main_label}.",
+						recovery: "Rebase onto #{@main_label} and deliver again."
+					}
+				end
 			end
-
 		end
 	end
 end

data/lib/carson/warehouse/workbench.rb

@@ -104,8 +104,8 @@ module Carson
 
 			# --- Lifecycle ---
 
-			# Build a new workbench from the latest production standard.
-			# Creates the directory, branches from the latest standard,
+			# Build a new workbench from local main.
+			# Creates the directory, branches from the local standard,
 			# ensures .claude/ is excluded from git status.
 			def build_workbench!( name: )
 				root = main_worktree_root
@@ -119,23 +119,12 @@ module Carson
 						recovery: "carson worktree remove #{name}, then retry" }
 				end
 
-				# Determine the base branch.
-				base = @main_label
-
-				# Fetch to update remote tracking ref without mutating the main worktree.
-				_, _, fetch_ok = git( "fetch", @bureau_address, base )
-				if fetch_ok.success?
-					remote_ref = "#{@bureau_address}/#{base}"
-					_, _, ref_ok = git( "rev-parse", "--verify", remote_ref )
-					base = remote_ref if ref_ok.success?
-				end
-
 				# Ensure .claude/ is excluded from git status.
 				ensure_claude_dir_excluded!
 
 				# Create the worktree with a new branch.
 				FileUtils.mkdir_p( File.dirname( workbench_path ) )
-				wt_stdout, wt_stderr, wt_status = git( "worktree", "add", workbench_path, "-b", name, base )
+				wt_stdout, wt_stderr, wt_status = git( "worktree", "add", workbench_path, "-b", name, @main_label )
 				unless wt_status.success?
 					error_text = wt_stderr.to_s.strip
 					error_text = "unable to create worktree" if error_text.empty?
@@ -159,11 +148,10 @@ module Carson
 					path: workbench_path, branch: name }
 			end
 
-			# Agent checks in — prepare a fresh workbench from the latest standard.
+			# Agent checks in — prepare a fresh workbench from local main.
 			# Sweeps delivered workbenches first — the Warehouse cleans behind the agent.
 			def checkin!( name: )
-				receive_latest_standard!
-				sweep_delivered_workbenches!
+				sweep!
 				result = build_workbench!( name: name )
 				result[ :command ] = "checkin"
 				result
@@ -237,19 +225,20 @@ module Carson
 			end
 
 			# Full safety assessment before removal.
+			# Asks the workbench about its own state — no duplicate checks.
 			# Returns { status: :ok } or { status: :block/:error, error:, recovery: }.
 			def assess_removal( workbench, force: false, skip_unpushed: false )
 				unless workbench.exists?
 					return { status: :ok, missing: true }
 				end
 
-				if agent_at_workbench?( workbench )
+				if workbench.holds_cwd?
 					return { status: :block, result_status: "block",
 						error: "current working directory is inside this worktree",
-						recovery: "cd #{main_worktree_root} && carson worktree remove #{File.basename( workbench.path )}" }
+						recovery: "cd #{main_worktree_root} && carson checkout #{File.basename( workbench.path )}" }
 				end
 
-				if workbench_held_by_process?( workbench )
+				if workbench.held_by_other_process?
 					return { status: :block, result_status: "block",
 						error: "another process has its working directory inside this worktree",
 						recovery: "wait for the other session to finish, then retry" }
@@ -269,9 +258,12 @@ module Carson
 				{ status: :ok, missing: false }
 			end
 
-			# Sweep stale workbenches. Walk all agent-owned workbenches,
-			# check state, tear down those safe to reap. Repair missing ones.
-			def sweep_workbenches!
+			# The warehouse sweeps — autonomous housekeeping.
+			# Walks all agent-owned workbenches. Asks each one about its state.
+			# If the label has been absorbed into the vault, and the workbench
+			# isn't sealed or occupied — safe to remove, tears it down.
+			# Repairs missing ones.
+			def sweep!
 				root = main_worktree_root
 
 				agent_prefixes = AGENT_DIRS.map do |dir|
@@ -284,48 +276,17 @@ module Carson
 					next unless workbench.branch
 					next unless agent_prefixes.any? { |prefix| workbench.path.start_with?( prefix ) }
 
-					# Use the existing classifier if available (transitional).
-					if respond_to?( :classify_worktree_cleanup, true )
-						classification = classify_worktree_cleanup( worktree: workbench )
-						next unless classification.fetch( :action ) == :reap
-					end
-
 					unless workbench.exists?
 						repair_missing_workbench!( workbench )
 						next
 					end
 
-					_, _, rm_ok = git( "worktree", "remove", workbench.path )
-					next unless rm_ok.success?
-
-					if workbench.branch
-						git( "branch", "-D", workbench.branch )
-					end
-				end
-			end
-
-		private
-
-			# --- Sweep ---
-
-			# Sweep delivered workbenches — branches absorbed into main, not sealed,
-			# not CWD-blocked. Called by checkin! so the Warehouse cleans behind the agent.
-			def sweep_delivered_workbenches!
-				root = main_worktree_root
-
-				agent_prefixes = AGENT_DIRS.map do |dir|
-					full = File.join( root, dir, "worktrees" )
-					File.join( realpath_safe( full ), "" ) if Dir.exist?( full )
-				end.compact
-				return if agent_prefixes.empty?
+					# Only sweep workbenches whose content has been absorbed into the vault.
+					next unless absorbed?( workbench.branch )
 
-				workbenches.each do |workbench|
-					next unless workbench.branch
-					next unless agent_prefixes.any? { |prefix| workbench.path.start_with?( prefix ) }
-					next unless workbench.exists?
-					next unless label_absorbed?( workbench.branch )
-					next if agent_at_workbench?( workbench )
-					next if workbench_held_by_process?( workbench )
+					# Ask the workbench about its own state — not occupied, not held.
+					next if workbench.holds_cwd?
+					next if workbench.held_by_other_process?
 
 					# Do not sweep sealed workbenches — parcel still in flight.
 					seal_check = Warehouse.new( path: workbench.path )
@@ -338,41 +299,7 @@ module Carson
 				end
 			end
 
-			# --- Safety checks ---
-
-			# Is the agent's working directory inside this workbench?
-			def agent_at_workbench?( workbench )
-				cwd = realpath_safe( Dir.pwd )
-				workbench_path = realpath_safe( workbench.path )
-				normalised = File.join( workbench_path, "" )
-				cwd == workbench_path || cwd.start_with?( normalised )
-			rescue StandardError
-				false
-			end
-
-			# Is another process occupying this workbench?
-			def workbench_held_by_process?( workbench )
-				canonical = realpath_safe( workbench.path )
-				return false if canonical.nil? || canonical.empty?
-				return false unless Dir.exist?( canonical )
-
-				stdout, = Open3.capture3( "lsof", "-d", "cwd" )
-				return false if stdout.nil? || stdout.empty?
-
-				normalised = File.join( canonical, "" )
-				my_pid = Process.pid
-				stdout.lines.drop( 1 ).any? do |line|
-					fields = line.strip.split( /\s+/ )
-					next false unless fields.length >= 9
-					next false if fields[ 1 ].to_i == my_pid
-					name = fields[ 8.. ].join( " " )
-					name == canonical || name.start_with?( normalised )
-				end
-			rescue Errno::ENOENT
-				false
-			rescue StandardError
-				false
-			end
+		private
 
 			# Would tearing down lose unpushed work?
 			# Content-aware: compares tree content vs main, not SHAs.

data/lib/carson/warehouse.rb

@@ -1,7 +1,10 @@
-# A governed repository. In the FedEx metaphor, the warehouse is where
-# parcels are built on workbenches (worktrees) with labels (branches).
-# Git and gh commands are hidden inside — callers never see git or
-# GitHub terms.
+# A governed repository — the intelligent, self-managing building
+# where parcels are built on workbenches. Each warehouse belongs
+# to a client. The warehouse is the local authority — everything
+# inside the repository is its domain.
+#
+# At the heart of the warehouse is the vault — where the production
+# standard lives. The vault is the source of truth.
 require "fileutils"
 require "open3"
 
@@ -11,13 +14,8 @@ require_relative "warehouse/seal"
 require_relative "warehouse/bureau"
 
 module Carson
-	# A governed repository — the warehouse where parcels are built on
-	# workbenches (worktrees) with labels (branches). An intelligent
-	# warehouse that manages itself: packing parcels, checking compliance,
-	# managing workbenches, and sweeping up.
 	class Warehouse
 		include Workbench
-		include Vault
 		include Seal
 		include Bureau
 
@@ -30,29 +28,46 @@ module Carson
 			@compliance_checker = compliance_checker
 		end
 
+		# --- The vault ---
+
+		# The vault — where the production standard lives.
+		def vault
+			@vault ||= Vault.new( path: main_worktree_root, main_label: @main_label )
+		end
+
+		# Accept a parcel into the vault.
+		def accept!( parcel )
+			vault.accept!( parcel )
+		end
+
+		# Has this label been absorbed into the vault?
+		def absorbed?( label )
+			vault.absorbed?( label )
+		end
+
 		# --- What the warehouse knows ---
 
-		# The label on the current workbench (branch name).
+		# The label on the current workbench.
 		def current_label
 			git( "rev-parse", "--abbrev-ref", "HEAD" ).first.strip
 		end
 
-		# The tip of the parcel on the current workbench (commit SHA).
+		# The tip of the parcel on the current workbench.
 		def current_head
 			git( "rev-parse", "HEAD" ).first.strip
 		end
 
-		# The destination label (from config).
+		# What the production standard is called.
 		def main_label
 			@main_label
 		end
 
-		# The bureau's address (remote name).
+		# The bureau's address — where to send things.
 		def bureau_address
 			@bureau_address
 		end
 
-		# Is the warehouse floor clean? No uncommitted changes on the current workbench.
+		# Is the floor clean? No loose material lying around.
 		def clean?
 			output, _, status = git( "status", "--porcelain" )
 			status.success? && output.strip.empty?
@@ -60,47 +75,36 @@ module Carson
 
 		# --- Warehouse operations ---
 
-		# Ship a parcel to the bureau.
-		# The warehouse sends the parcel's label to the remote.
+		# Ship a parcel to the backup so the courier can work with it.
 		def ship( parcel, remote: bureau_address )
 			_, _, status = git( "push", "-u", remote, parcel.label )
 			status.success?
 		end
 
-		# Get latest registry state from the bureau (git fetch).
-		# Returns true on success, false on failure.
-		def fetch_latest( remote: bureau_address, registry: nil )
-			arguments = [ "fetch", remote ]
-			arguments << registry if registry
-			_, _, status = git( *arguments )
+		# Is this parcel based on the latest standard?
+		# The standard is vault state — is the parcel built on top of it?
+		def based_on_latest?( parcel )
+			standard = "#{bureau_address}/#{main_label}"
+			_, _, status = git( "merge-base", "--is-ancestor", standard, parcel.head )
 			status.success?
 		end
 
-		# Is the parcel based on the client's latest production standard?
-		# Checks whether the registry tip is an ancestor of the parcel's head.
-		def based_on_latest_standard?( parcel, registry: "#{bureau_address}/#{main_label}" )
-			_, _, status = git( "merge-base", "--is-ancestor", registry, parcel.head )
-			status.success?
-		end
-
-		# Ensure the warehouse complies with company standards (template sync).
-		# Delegates to the injected compliance checker. If no checker is set,
-		# the warehouse assumes compliance — no templates to enforce.
+		# Submit compliance — ensure the warehouse meets company standards.
 		def submit_compliance!
 			return { compliant: true, committed: false } unless @compliance_checker
 
 			@compliance_checker.call( self )
 		end
 
-		# Update the warehouse's production standard — rebase onto latest registry state.
-		# Called after the bureau refuses a parcel for being behind standard.
-		def rebase_on_latest_standard!( registry: "#{bureau_address}/#{main_label}" )
-			_, _, status = git( "rebase", registry )
+		# Rebase a workbench onto the latest standard.
+		# When a parcel falls behind the standard, the warehouse fixes it.
+		def rebase!( standard: "#{bureau_address}/#{main_label}" )
+			_, _, status = git( "rebase", standard )
 			status.success?
 		end
 
-		# Pack a parcel — stage all changes and commit.
-		# Refuses if the workbench is sealed (parcel already in flight).
+		# Pack a parcel — stage all loose material and seal it.
+		# Refuses if the workbench is sealed — a parcel is already in flight.
 		def pack!( message: )
 			if sealed?
 				raise "Branch is locked — PR ##{sealed_tracking_number} in flight. " \
@@ -111,14 +115,14 @@ module Carson
 			status.success?
 		end
 
-		# Receive the latest standard from the registry after a parcel is accepted.
-		# Fast-forwards local main without switching branches.
+		# Receive the latest standard.
+		# After a parcel is accepted, the standard has changed. The warehouse
+		# updates its vault without disturbing the current workbench.
 		#
-		# Two paths depending on the main worktree's checkout state:
+		# Two paths depending on the vault's checkout state:
 		# - Main checked out → merge --ff-only (updates ref + working tree).
-		# - Main not checked out → fetch refspec (updates ref only, safe when
-		#   no worktree has the branch).
-		def receive_latest_standard!( remote: bureau_address )
+		# - Main not checked out → fetch refspec (updates ref only).
+		def receive_latest!( remote: bureau_address )
 			root = main_worktree_root
 
 			_, _, fetch_status = Open3.capture3( "git", "-C", root, "fetch", remote )
@@ -145,73 +149,60 @@ module Carson
 		# --- Delivery prep ---
 
 		# Prepare a parcel for delivery.
-		# Orchestrates the prep phase: pack, fetch, standard check, auto-rebase.
-		# Returns { status: "ok" } or { status: "block"/"error", error:, recovery: }.
+		# Packs if the agent provided a message, checks if the parcel is based
+		# on the latest standard, rebases automatically if it's behind.
 		def prepare!( parcel, message: nil )
-			registry = "#{bureau_address}/#{main_label}"
+			standard = "#{bureau_address}/#{main_label}"
 
-			# Pack if the agent provided a commit message.
 			if message
 				unless pack!( message: message )
 					return { status: "error", error: "Nothing to commit.", recovery: "Stage changes first." }
 				end
-				# Update the parcel's head after packing.
 				parcel = Parcel.new( label: parcel.label, head: current_head )
 			end
 
-			# Fetch the latest standard.
-			unless fetch_latest
+			unless receive_latest!
 				return {
 					status: "block",
-					error: "Cannot fetch latest standard.",
+					error: "Cannot receive latest standard.",
 					recovery: "Check network and remote config, then deliver again."
 				}
 			end
 
-			# Check if the parcel is based on the latest standard.
-			unless based_on_latest_standard?( parcel, registry: registry )
-				# Auto-rebase onto the latest standard.
-				unless rebase_on_latest_standard!( registry: registry )
+			unless based_on_latest?( parcel )
+				unless rebase!( standard: standard )
 					return {
 						status: "block",
 						error: "#{parcel.label} conflicts with #{@main_label}.",
 						recovery: "Rebase onto #{@main_label}, resolve conflicts, deliver again."
 					}
 				end
-				# Update the parcel's head after rebase.
 				parcel = Parcel.new( label: parcel.label, head: current_head )
 			end
 
+			# Stamp the parcel with its origin so it knows whether it carries anything.
+			origin, = git( "merge-base", main_label, parcel.label )
+			parcel = Parcel.new( label: parcel.label, head: parcel.head, shelf: parcel.shelf, origin: origin.strip )
+
+			if parcel.empty?
+				return {
+					status: "block",
+					error: "Nothing to deliver — no commits ahead of #{main_label}.",
+					recovery: "Commit changes, then carson deliver."
+				}
+			end
+
 			{ status: "ok", parcel: parcel }
 		end
 
 		# --- Inventory ---
 
-		# All labels (branch names).
+		# All labels in the warehouse.
 		def labels
 			output, = git( "branch", "--format", "%(refname:short)" )
 			output.lines.map { it.strip }.reject { it.empty? }
 		end
 
-		# Has this label's content been absorbed into main?
-		# Content-aware: compares tree content, not SHA ancestry.
-		# Catches rebase-merged and squash-merged branches that
-		# `git branch --merged` misses (replayed SHAs differ).
-		def label_absorbed?( name )
-			_, _, status = Open3.capture3(
-				"git", "diff", "--quiet", @main_label, name,
-				chdir: path )
-			status.success?
-		end
-
-		# All worktree paths (transitional — use workbenches for Worktree instances).
-		def shelves
-			output, = git( "worktree", "list", "--porcelain" )
-			output.lines
-				.select { it.start_with?( "worktree " ) }
-				.map { it.sub( "worktree ", "" ).strip }
-		end
-
 		# The main warehouse location — resolves correctly even from a workbench.
 		def main_worktree_root
 			git_common_dir, = git( "rev-parse", "--path-format=absolute", "--git-common-dir" )

data/lib/carson/worktree.rb

@@ -279,7 +279,7 @@ module Carson
 					resolved_path: resolved_path,
 					branch: branch,
 					error: "current working directory is inside this worktree",
-					recovery: "cd #{safe_root} && carson worktree remove #{File.basename( resolved_path )}"
+					recovery: "cd #{safe_root} && carson checkout #{File.basename( resolved_path )}"
 				}
 			end
 

data/lib/cli.rb

@@ -5,7 +5,7 @@ require "optparse"
 module Carson
 	class CLI
 		PORTFOLIO_COMMANDS = %w[onboard offboard list refresh version].freeze
-		REPO_COMMANDS = %w[deliver receive sync status audit prune housekeep worktree abandon recover review template setup checkin checkout].freeze
+		REPO_COMMANDS = %w[deliver receive sync status prune housekeep worktree abandon recover review template setup checkin checkout].freeze
 		ALL_COMMANDS = ( PORTFOLIO_COMMANDS + REPO_COMMANDS ).freeze
 
 		def self.start( arguments:, repo_root:, tool_root:, output:, error: )
@@ -154,7 +154,7 @@ module Carson
 				return { command: :help }
 			end
 			return { command: "version" } if [ "--version", "-v" ].include?( first )
-			return { command: "audit" } if arguments.empty?
+			return { command: "status" } if arguments.empty?
 
 			nil
 		end
@@ -217,8 +217,6 @@ module Carson
 				parse_sync_command( arguments: arguments, error: error )
 			when "status"
 				parse_status_command( arguments: arguments, error: error )
-			when "audit"
-				parse_audit_command( arguments: arguments, error: error )
 			when "prune"
 				parse_prune_command( arguments: arguments, error: error )
 			when "housekeep"
@@ -284,7 +282,7 @@ module Carson
 				parser.banner = "Usage: carson onboard <REPO_PATH>"
 				parser.separator ""
 				parser.separator "Register a repository for Carson governance."
-				parser.separator "Detects the remote, installs hooks, applies templates, and runs initial audit."
+				parser.separator "Detects the remote, installs hooks, and applies templates."
 				parser.separator ""
 				parser.separator "Examples:"
 				parser.separator "    carson onboard ~/Dev/app   Onboard a specific repository"
@@ -677,36 +675,6 @@ module Carson
 			{ command: :invalid }
 		end
 
-		# --- audit ---
-
-		def self.parse_audit_command( arguments:, error: )
-			options = { json: false }
-			audit_parser = OptionParser.new do |parser|
-				parser.banner = "Usage: carson audit [--json]"
-				parser.separator ""
-				parser.separator "Run pre-commit health checks on the repository."
-				parser.separator "Validates hooks, main-branch sync, PR status, and CI baseline."
-				parser.separator "Exits with a non-zero status when policy violations are found."
-				parser.separator ""
-				parser.separator "Options:"
-				parser.on( "--json", "Machine-readable JSON output" ) { options[ :json ] = true }
-				parser.separator ""
-				parser.separator "Examples:"
-				parser.separator "    carson audit           Check repository health (also the default command)"
-				parser.separator "    carson audit --json    Structured output for agent consumption"
-			end
-			audit_parser.parse!( arguments )
-			unless arguments.empty?
-				error.puts "#{BADGE} Unexpected arguments for audit: #{arguments.join( ' ' )}"
-				return { command: :invalid }
-			end
-			{ command: "audit", json: options[ :json ] }
-		rescue OptionParser::ParseError => exception
-			error.puts "#{BADGE} #{exception.message}"
-			error.puts audit_parser
-			{ command: :invalid }
-		end
-
 		# --- abandon ---
 
 		def self.parse_abandon_command( arguments:, error: )
@@ -854,7 +822,7 @@ module Carson
 				parser.banner = "Usage: carson recover --check NAME [--json]"
 				parser.separator ""
 				parser.separator "Merge the current repair PR when one governance-owned required check is already red on the default branch."
-				parser.separator "Recovery is narrow: Carson verifies the baseline failure, keeps every other gate intact, and records an audit event."
+				parser.separator "Recovery is narrow: Carson verifies the baseline failure, keeps every other gate intact, and records a recovery event."
 				parser.separator ""
 				parser.separator "Options:"
 				parser.on( "--check NAME", "Name of the governance-owned required check to recover" ) { |value| options[ :check_name ] = value }
@@ -988,8 +956,6 @@ module Carson
 				runtime.status!( json_output: parsed.fetch( :json, false ) )
 			when "setup"
 				runtime.setup!( cli_choices: parsed.fetch( :cli_choices, {} ) )
-			when "audit"
-				runtime.audit!( json_output: parsed.fetch( :json, false ) )
 			when "abandon"
 				runtime.abandon!( target: parsed.fetch( :target ), json_output: parsed.fetch( :json, false ) )
 			when "sync"