carson 3.22.0 → 3.23.0

data/lib/carson/runtime/review/gate_support.rb

@@ -5,6 +5,73 @@ module Carson
 			module GateSupport
 			private
 
+				def review_gate_report_for_missing_pr( branch_name: )
+					{
+						generated_at: Time.now.utc.iso8601,
+						branch: branch_name,
+						status: "block",
+						converged: false,
+						wait_seconds: config.review_wait_seconds,
+						poll_seconds: config.review_poll_seconds,
+						max_polls: config.review_max_polls,
+						block_reasons: [ "no pull request found for current branch" ],
+						pr: nil,
+						unresolved_threads: [],
+						actionable_top_level: [],
+						unacknowledged_actionable: []
+					}
+				end
+
+				def review_gate_report_for_pr( owner:, repo:, pr_number:, branch_name:, pr_summary: nil )
+					resolved_pr_summary = resolved_review_gate_pr_summary(
+						owner: owner,
+						repo: repo,
+						pr_number: pr_number,
+						pr_summary: pr_summary
+					)
+					pre_snapshot = wait_for_review_warmup( owner: owner, repo: repo, pr_number: pr_number )
+					converged = false
+					last_snapshot = pre_snapshot
+					last_signature = pre_snapshot.nil? ? nil : review_gate_signature( snapshot: pre_snapshot )
+					poll_attempts = 0
+
+					config.review_max_polls.times do |index|
+						poll_attempts = index + 1
+						snapshot = review_gate_snapshot( owner: owner, repo: repo, pr_number: pr_number )
+						last_snapshot = snapshot
+						signature = review_gate_signature( snapshot: snapshot )
+						puts_verbose "poll_attempt: #{poll_attempts}/#{config.review_max_polls}"
+						puts_verbose "latest_activity: #{snapshot.fetch( :latest_activity ) || 'unknown'}"
+						puts_verbose "unresolved_threads: #{snapshot.fetch( :unresolved_threads ).count}"
+						puts_verbose "unacknowledged_actionable: #{snapshot.fetch( :unacknowledged_actionable ).count}"
+						if !last_signature.nil? && signature == last_signature
+							converged = true
+							puts_verbose "convergence: stable"
+							break
+						end
+						last_signature = signature
+						wait_for_review_poll if index < config.review_max_polls - 1
+					end
+
+					build_review_gate_report(
+						branch_name: branch_name,
+						pr_summary: resolved_pr_summary,
+						snapshot: last_snapshot,
+						converged: converged,
+						poll_attempts: poll_attempts
+					)
+				end
+
+				def review_gate_result( report: )
+					return { status: :pass, review: :approved, detail: "review gate passed" } if report.fetch( :status ) == "ok"
+
+					{
+						status: :fail,
+						review: review_gate_changes_requested?( report: report ) ? :changes_requested : :blocked,
+						detail: report.fetch( :block_reasons ).join( "; " )
+					}
+				end
+
 				def wait_for_review_warmup( owner:, repo:, pr_number: )
 					return unless config.review_wait_seconds.positive?
 					quick = review_gate_snapshot( owner: owner, repo: repo, pr_number: pr_number )
@@ -31,7 +98,9 @@ module Carson
 					unresolved_threads = unresolved_thread_entries( details: details )
 					actionable_top_level = actionable_top_level_items( details: details, pr_author: pr_author )
 					acknowledgements = disposition_acknowledgements( details: details, pr_author: pr_author )
-					unacknowledged_actionable = actionable_top_level.reject { acknowledged_by_disposition?( item: it, acknowledgements: acknowledgements ) }
+					unacknowledged_actionable = actionable_top_level.reject do |item|
+						acknowledged_by_disposition?( item: item, acknowledgements: acknowledgements )
+					end
 					{
 						latest_activity: latest_review_activity( details: details ),
 						unresolved_threads: unresolved_threads,
@@ -45,8 +114,8 @@ module Carson
 				def review_gate_signature( snapshot: )
 					{
 						latest_activity: snapshot.fetch( :latest_activity ).to_s,
-						unresolved_urls: snapshot.fetch( :unresolved_threads ).map { it.fetch( :url ) }.sort,
-						unacknowledged_urls: snapshot.fetch( :unacknowledged_actionable ).map { it.fetch( :url ) }.sort
+						unresolved_urls: snapshot.fetch( :unresolved_threads ).map { |entry| entry.fetch( :url ) }.sort,
+						unacknowledged_urls: snapshot.fetch( :unacknowledged_actionable ).map { |entry| entry.fetch( :url ) }.sort
 					}
 				end
 
@@ -67,8 +136,11 @@ module Carson
 					}
 				end
 
+				# GraphQL returns "gemini-code-assist"; REST returns "gemini-code-assist[bot]".
+				# Normalise both sides by stripping the [bot] suffix for a consistent match.
 				def bot_username?( author: )
-					config.review_bot_usernames.any? { it.downcase == author.to_s.downcase }
+					normalised = author.to_s.downcase.delete_suffix( "[bot]" )
+					config.review_bot_usernames.any? { |username| username.downcase.delete_suffix( "[bot]" ) == normalised }
 				end
 
 				def unresolved_thread_entries( details: )
@@ -79,7 +151,7 @@ module Carson
 						comments = thread.fetch( :comments )
 						first_comment = comments.first || {}
 						next if bot_username?( author: first_comment.fetch( :author, "" ) )
-						latest_time = comments.map { it.fetch( :created_at ) }.max.to_s
+						latest_time = comments.map { |comment| comment.fetch( :created_at ) }.max.to_s
 						{
 							url: blank_to( value: first_comment.fetch( :url, "" ), default: "#{details.fetch( :url )}#thread-#{index + 1}" ),
 							author: first_comment.fetch( :author, "" ),
@@ -131,7 +203,7 @@ module Carson
 					sources = []
 					sources.concat( Array( details.fetch( :comments ) ) )
 					sources.concat( Array( details.fetch( :reviews ) ) )
-					sources.concat( Array( details.fetch( :review_threads ) ).flat_map { it.fetch( :comments ) } )
+					sources.concat( Array( details.fetch( :review_threads ) ).flat_map { |thread| thread.fetch( :comments ) } )
 					sources.map do |entry|
 						next unless entry.fetch( :author, "" ) == pr_author
 						body = entry.fetch( :body, "" ).to_s
@@ -152,7 +224,7 @@ module Carson
 				# True when any disposition acknowledgement references the specific finding URL.
 				def acknowledged_by_disposition?( item:, acknowledgements: )
 					acknowledgements.any? do |ack|
-						Array( ack.fetch( :target_urls ) ).any? { it == item.fetch( :url ) }
+						Array( ack.fetch( :target_urls ) ).any? { |target_url| target_url == item.fetch( :url ) }
 					end
 				end
 
@@ -160,10 +232,70 @@ module Carson
 				def latest_review_activity( details: )
 					timestamps = []
 					timestamps << details.fetch( :updated_at )
-					timestamps.concat( Array( details.fetch( :comments ) ).map { it.fetch( :created_at ) } )
-					timestamps.concat( Array( details.fetch( :reviews ) ).map { it.fetch( :created_at ) } )
-					timestamps.concat( Array( details.fetch( :review_threads ) ).flat_map { it.fetch( :comments ) }.map { it.fetch( :created_at ) } )
-					timestamps.map { parse_time_or_nil( text: it ) }.compact.max&.utc&.iso8601
+					timestamps.concat( Array( details.fetch( :comments ) ).map { |comment| comment.fetch( :created_at ) } )
+					timestamps.concat( Array( details.fetch( :reviews ) ).map { |review| review.fetch( :created_at ) } )
+					timestamps.concat( Array( details.fetch( :review_threads ) ).flat_map { |thread| thread.fetch( :comments ) }.map { |comment| comment.fetch( :created_at ) } )
+					timestamps.map { |timestamp| parse_time_or_nil( text: timestamp ) }.compact.max&.utc&.iso8601
+				end
+
+				def resolved_review_gate_pr_summary( owner:, repo:, pr_number:, pr_summary: )
+					required_keys = %i[number title url state]
+					if !pr_summary.nil? && required_keys.all? { |key| pr_summary.key?( key ) && !pr_summary.fetch( key ).to_s.empty? }
+						return pr_summary
+					end
+
+					pull_request_summary( owner: owner, repo: repo, pr_number: pr_number )
+				end
+
+				def pull_request_summary( owner:, repo:, pr_number: )
+					details = pull_request_details( owner: owner, repo: repo, pr_number: pr_number )
+					{
+						number: details.fetch( :number ),
+						title: details.fetch( :title ),
+						url: details.fetch( :url ),
+						state: details.fetch( :state )
+					}
+				end
+
+				def build_review_gate_report( branch_name:, pr_summary:, snapshot:, converged:, poll_attempts: )
+					{
+						generated_at: Time.now.utc.iso8601,
+						branch: branch_name,
+						status: review_gate_block_reasons( snapshot: snapshot, converged: converged ).empty? ? "ok" : "block",
+						converged: converged,
+						wait_seconds: config.review_wait_seconds,
+						poll_seconds: config.review_poll_seconds,
+						max_polls: config.review_max_polls,
+						poll_attempts: poll_attempts,
+						block_reasons: review_gate_block_reasons( snapshot: snapshot, converged: converged ),
+						pr: {
+							number: pr_summary.fetch( :number ),
+							title: pr_summary.fetch( :title ),
+							url: pr_summary.fetch( :url ),
+							state: pr_summary.fetch( :state )
+						},
+						unresolved_threads: snapshot.fetch( :unresolved_threads ),
+						actionable_top_level: snapshot.fetch( :actionable_top_level ),
+						unacknowledged_actionable: snapshot.fetch( :unacknowledged_actionable )
+					}
+				end
+
+				def review_gate_block_reasons( snapshot:, converged: )
+					reasons = []
+					reasons << "review snapshot did not converge within #{config.review_max_polls} polls" unless converged
+					if snapshot.fetch( :unresolved_threads ).any?
+						reasons << "unresolved review threads remain (#{snapshot.fetch( :unresolved_threads ).count})"
+					end
+					if snapshot.fetch( :unacknowledged_actionable ).any?
+						reasons << "actionable top-level comments/reviews without required disposition (#{snapshot.fetch( :unacknowledged_actionable ).count})"
+					end
+					reasons
+				end
+
+				def review_gate_changes_requested?( report: )
+					Array( report.fetch( :unacknowledged_actionable ) ).any? do |entry|
+						entry.fetch( :reason ) == "changes_requested_review"
+					end
 				end
 
 				# Writes review gate artefacts using fixed report names in global report output.
@@ -209,7 +341,7 @@ module Carson
 					if report.fetch( :block_reasons ).empty?
 						lines << "- none"
 					else
-						report.fetch( :block_reasons ).each { lines << "- #{it}" }
+						report.fetch( :block_reasons ).each { |reason| lines << "- #{reason}" }
 					end
 					lines << ""
 					lines << "## Unresolved Threads"

data/lib/carson/runtime/review/sweep_support.rb

@@ -60,7 +60,7 @@ module Carson
 						)
 					end
 
-					Array( details.fetch( :review_threads ) ).flat_map { it.fetch( :comments ) }.each do |comment|
+					Array( details.fetch( :review_threads ) ).flat_map { |thread| thread.fetch( :comments ) }.each do |comment|
 						next if comment.fetch( :author ) == pr_author
 						next if bot_username?( author: comment.fetch( :author ) )
 						hits = matched_risk_keywords( text: comment.fetch( :body ) )
@@ -153,7 +153,7 @@ module Carson
 					stdout_text, stderr_text, success, = gh_run( "issue", "list", "--repo", repo_slug, "--state", "all", "--limit", "100", "--json", "number,title,state,url,labels" )
 					raise gh_error_text( stdout_text: stdout_text, stderr_text: stderr_text, fallback: "unable to list issues for review sweep" ) unless success
 					issues = Array( JSON.parse( stdout_text ) )
-					node = issues.find { it[ "title" ].to_s == config.review_tracking_issue_title }
+					node = issues.find { |issue| issue[ "title" ].to_s == config.review_tracking_issue_title }
 					return nil if node.nil?
 					{
 						number: node[ "number" ],

data/lib/carson/runtime/review/utility.rb

@@ -25,7 +25,7 @@ module Carson
 
 				# GitHub URL extraction for mapping disposition acknowledgements to finding URLs.
 				def extract_github_urls( text: )
-					text.to_s.scan( %r{https://github\.com/[^\s\)\]]+} ).map { it.sub( /[.,;:]+$/, "" ) }.uniq
+					text.to_s.scan( %r{https://github\.com/[^\s\)\]]+} ).map { |url| url.sub( /[.,;:]+$/, "" ) }.uniq
 				end
 
 				# Parse RFC3339 timestamps and return nil on blank/invalid values.

data/lib/carson/runtime/review.rb

@@ -24,15 +24,16 @@ module Carson
 					puts_line "Review Gate"
 				end
 				unless gh_available?
-					puts_line "ERROR: gh CLI not available in PATH."
+					puts_line "gh CLI not found in PATH — install it to use review commands."
 					return EXIT_ERROR
 				end
 
 				owner, repo = repository_coordinates
+				branch = current_branch
 				pr_number_override = carson_pr_number_override
 				pr_summary =
 					if pr_number_override.nil?
-						current_pull_request_for_branch( branch_name: current_branch )
+						current_pull_request_for_branch( branch_name: branch )
 					else
 						details = pull_request_details( owner: owner, repo: repo, pr_number: pr_number_override )
 						{
@@ -43,93 +44,36 @@ module Carson
 						}
 					end
 				if pr_summary.nil?
-					puts_line "BLOCK: no pull request found for branch #{current_branch}."
-					report = {
-						generated_at: Time.now.utc.iso8601,
-						branch: current_branch,
-						status: "block",
-						converged: false,
-						wait_seconds: config.review_wait_seconds,
-						poll_seconds: config.review_poll_seconds,
-						max_polls: config.review_max_polls,
-						block_reasons: [ "no pull request found for current branch" ],
-						pr: nil,
-						unresolved_threads: [],
-						actionable_top_level: [],
-						unacknowledged_actionable: []
-					}
+					puts_line "No pull request found for branch #{branch}."
+					report = review_gate_report_for_missing_pr( branch_name: branch )
 					write_review_gate_report( report: report )
 					return EXIT_BLOCK
 				end
 
-				pre_snapshot = wait_for_review_warmup( owner: owner, repo: repo, pr_number: pr_summary.fetch( :number ) )
-				converged = false
-				last_snapshot = pre_snapshot
-				last_signature = pre_snapshot.nil? ? nil : review_gate_signature( snapshot: pre_snapshot )
-				poll_attempts = 0
-
-				config.review_max_polls.times do |index|
-					poll_attempts = index + 1
-					snapshot = review_gate_snapshot( owner: owner, repo: repo, pr_number: pr_summary.fetch( :number ) )
-					last_snapshot = snapshot
-					signature = review_gate_signature( snapshot: snapshot )
-					puts_verbose "poll_attempt: #{poll_attempts}/#{config.review_max_polls}"
-					puts_verbose "latest_activity: #{snapshot.fetch( :latest_activity ) || 'unknown'}"
-					puts_verbose "unresolved_threads: #{snapshot.fetch( :unresolved_threads ).count}"
-					puts_verbose "unacknowledged_actionable: #{snapshot.fetch( :unacknowledged_actionable ).count}"
-					if !last_signature.nil? && signature == last_signature
-						converged = true
-						puts_verbose "convergence: stable"
-						break
-					end
-					last_signature = signature
-					wait_for_review_poll if index < config.review_max_polls - 1
-				end
-
-				block_reasons = []
-				block_reasons << "review snapshot did not converge within #{config.review_max_polls} polls" unless converged
-				if last_snapshot.fetch( :unresolved_threads ).any?
-					block_reasons << "unresolved review threads remain (#{last_snapshot.fetch( :unresolved_threads ).count})"
-				end
-				if last_snapshot.fetch( :unacknowledged_actionable ).any?
-					block_reasons << "actionable top-level comments/reviews without required disposition (#{last_snapshot.fetch( :unacknowledged_actionable ).count})"
-				end
-
-				report = {
-					generated_at: Time.now.utc.iso8601,
-					branch: current_branch,
-					status: block_reasons.empty? ? "ok" : "block",
-					converged: converged,
-					wait_seconds: config.review_wait_seconds,
-					poll_seconds: config.review_poll_seconds,
-					max_polls: config.review_max_polls,
-					poll_attempts: poll_attempts,
-					block_reasons: block_reasons,
-					pr: {
-						number: pr_summary.fetch( :number ),
-						title: pr_summary.fetch( :title ),
-						url: pr_summary.fetch( :url ),
-						state: pr_summary.fetch( :state )
-					},
-					unresolved_threads: last_snapshot.fetch( :unresolved_threads ),
-					actionable_top_level: last_snapshot.fetch( :actionable_top_level ),
-					unacknowledged_actionable: last_snapshot.fetch( :unacknowledged_actionable )
-				}
+				report = review_gate_report_for_pr(
+					owner: owner,
+					repo: repo,
+					pr_number: pr_summary.fetch( :number ),
+					branch_name: branch,
+					pr_summary: pr_summary
+				)
 				write_review_gate_report( report: report )
 				unless verbose?
+					poll_attempts = report.fetch( :poll_attempts, 0 )
 					puts_line "Polling... (converged after #{poll_attempts} attempt#{plural_suffix( count: poll_attempts )})"
 				end
+				block_reasons = report.fetch( :block_reasons )
 				if block_reasons.empty?
 					puts_line "OK: review gate passed."
 					return EXIT_OK
 				end
-				block_reasons.each { |reason| puts_line "BLOCK: #{reason}" }
+				block_reasons.each { |reason| puts_line reason }
 				EXIT_BLOCK
 			rescue JSON::ParserError => exception
-				puts_line "ERROR: invalid gh JSON response (#{exception.message})."
+				puts_line "Unexpected response from gh (#{exception.message})."
 				EXIT_ERROR
 			rescue StandardError => exception
-				puts_line "ERROR: #{exception.message}"
+				puts_line exception.message
 				EXIT_ERROR
 			end
 
@@ -140,7 +84,7 @@ module Carson
 				puts_verbose ""
 				puts_verbose "[Review Sweep]"
 				unless gh_available?
-					puts_line "ERROR: gh CLI not available in PATH."
+					puts_line "gh CLI not found in PATH — install it to use review commands."
 					return EXIT_ERROR
 				end
 
@@ -176,13 +120,13 @@ module Carson
 					puts_line "OK: no actionable late review activity detected."
 					return EXIT_OK
 				end
-				puts_line "BLOCK: actionable late review activity detected."
+				puts_line "Late review activity needs attention."
 				EXIT_BLOCK
 			rescue JSON::ParserError => exception
-				puts_line "ERROR: invalid gh JSON response (#{exception.message})."
+				puts_line "Unexpected response from gh (#{exception.message})."
 				EXIT_ERROR
 			rescue StandardError => exception
-				puts_line "ERROR: #{exception.message}"
+				puts_line exception.message
 				EXIT_ERROR
 			end
 		end

data/lib/carson/runtime/setup.rb

@@ -21,7 +21,7 @@ module Carson
 					return write_setup_config( choices: cli_choices )
 				end
 
-				if self.in.respond_to?( :tty? ) && self.in.tty?
+				if input_stream.respond_to?( :tty? ) && input_stream.tty?
 					interactive_setup!
 				else
 					silent_setup!
@@ -42,11 +42,8 @@ module Carson
 				workflow_choice = prompt_workflow_style
 				choices[ "workflow.style" ] = workflow_choice unless workflow_choice.nil?
 
-				merge_choice = prompt_merge_method
-				choices[ "govern.merge.method" ] = merge_choice unless merge_choice.nil?
-
-				canonical_choice = prompt_canonical_template
-				choices[ "template.canonical" ] = canonical_choice unless canonical_choice.nil?
+				canonical_choice = prompt_canonical_lint_policy
+				choices[ "lint.canonical" ] = canonical_choice unless canonical_choice.nil?
 
 				write_setup_config( choices: choices )
 			end
@@ -67,7 +64,7 @@ module Carson
 				duplicates = duplicate_remote_groups( remotes: remotes )
 				unless duplicates.empty?
 					duplicates.each_value do |group|
-						names = group.map { it.fetch( :name ) }.join( " and " )
+						names = group.map { |entry| entry.fetch( :name ) }.join( " and " )
 						puts_verbose "duplicate_remotes: #{names} share the same URL"
 					end
 				end
@@ -91,10 +88,10 @@ module Carson
 				end
 
 				duplicates = duplicate_remote_groups( remotes: remotes )
-				duplicate_names = duplicates.values.flatten.map { it.fetch( :name ) }.to_set
+				duplicate_names = duplicates.values.flatten.map { |entry| entry.fetch( :name ) }.to_set
 				unless duplicates.empty?
 					duplicates.each_value do |group|
-						names = group.map { it.fetch( :name ) }.join( " and " )
+						names = group.map { |entry| entry.fetch( :name ) }.join( " and " )
 						puts_line "Remotes #{names} share the same URL. Consider removing the duplicate."
 					end
 				end
@@ -139,33 +136,19 @@ module Carson
 					{ label: "branch — enforce PR-only merges (default)", value: "branch" },
 					{ label: "trunk — commit directly to main", value: "trunk" }
 				]
-				default_index = options.index { it.fetch( :value ) == current } || 0
+				default_index = options.index { |option| option.fetch( :value ) == current } || 0
 				prompt_choice( options: options, default: default_index )
 			end
 
-			def prompt_merge_method
+			def prompt_canonical_lint_policy
 				puts_line ""
-				puts_line "Merge method"
-				current = config.govern_merge_method
-				puts_line "  Currently: #{current}" unless current.nil? || current.empty?
-				options = [
-					{ label: "squash — one commit per PR (recommended)", value: "squash" },
-					{ label: "rebase — linear history, individual commits", value: "rebase" },
-					{ label: "merge — merge commits", value: "merge" }
-				]
-				default_index = options.index { it.fetch( :value ) == current } || 0
-				prompt_choice( options: options, default: default_index )
-			end
-
-			def prompt_canonical_template
-				puts_line ""
-				puts_line "Canonical template directory"
-				current = config.template_canonical
+				puts_line "Canonical lint policy directory"
+				current = config.lint_canonical
 				if current && !current.empty?
 					puts_line "  Currently set to: #{current}"
 					puts_line "  Leave blank to keep current value."
 				else
-					puts_line "  A directory of .github/ files to sync across governed repos."
+					puts_line "  A directory of canonical lint-policy files to sync across governed repos."
 					puts_line "  Leave blank to skip for now."
 				end
 				prompt_custom_value( label: "Path" )
@@ -177,7 +160,7 @@ module Carson
 				end
 				output.print "#{BADGE} Choice [#{default + 1}]: "
 				output.flush
-				raw = self.in.gets
+				raw = input_stream.gets
 				return options[ default ].fetch( :value ) if raw.nil?
 
 				input = raw.to_s.strip
@@ -194,7 +177,7 @@ module Carson
 			def prompt_custom_value( label: )
 				output.print "#{BADGE} #{label}: "
 				output.flush
-				raw = self.in.gets
+				raw = input_stream.gets
 				return nil if raw.nil?
 
 				value = raw.to_s.strip
@@ -221,7 +204,7 @@ module Carson
 						others << entry
 					end
 				end
-				well_known.sort_by { WELL_KNOWN_REMOTES.index( it.fetch( :name ) ) || 999 } + others.sort_by { it.fetch( :name ) }
+				well_known.sort_by { |entry| WELL_KNOWN_REMOTES.index( entry.fetch( :name ) ) || 999 } + others.sort_by { |entry| entry.fetch( :name ) }
 			end
 
 			# Normalises a remote URL so SSH and HTTPS variants of the same host/path compare equal.
@@ -297,7 +280,7 @@ module Carson
 
 			def detect_git_remote
 				remotes = list_git_remotes
-				remote_names = remotes.map { it.fetch( :name ) }
+				remote_names = remotes.map { |entry| entry.fetch( :name ) }
 				return nil if remote_names.empty?
 
 				return config.git_remote if remote_names.include?( config.git_remote )
@@ -327,6 +310,7 @@ module Carson
 
 				existing_data = load_existing_config( path: config_path )
 				merged = Config.deep_merge( base: existing_data, overlay: config_data )
+				remove_deprecated_template_canonical!( data: merged ) if config_data.dig( "lint", "canonical" )
 
 				FileUtils.mkdir_p( File.dirname( config_path ) )
 				File.write( config_path, JSON.pretty_generate( merged ) )
@@ -361,6 +345,14 @@ module Carson
 				{}
 			end
 
+			def remove_deprecated_template_canonical!( data: )
+				template_hash = data[ "template" ]
+				return unless template_hash.is_a?( Hash )
+
+				template_hash.delete( "canonical" )
+				data.delete( "template" ) if template_hash.empty?
+			end
+
 			def reload_config_after_setup!
 				@config = Config.load( repo_root: repo_root )
 			end
@@ -387,7 +379,7 @@ module Carson
 				hint = default ? "Y/n" : "y/N"
 				output.print "#{BADGE} [#{hint}]: "
 				output.flush
-				raw = self.in.gets
+				raw = input_stream.gets
 				return default if raw.nil?
 
 				input = raw.to_s.strip.downcase