gitflash 0.7.0.beta1 → 0.7.0.beta3

data/lib/gitflash/commands/hook_install.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'shellwords'
 
 module Gitflash
   module Commands
@@ -11,10 +12,14 @@ module Gitflash
       SCOPES = Hook::Settings::SCOPES
       MARKING_COMMAND = 'gitflash hook claude'
 
+      # From the weakest protection to the strongest
+      STRENGTH = %w[snapshot ask deny].freeze
+
       def call
         plan = build_plan
         data = settings.read(plan[:file])
         entry = settings.entry(data)
+        add_mode(plan, entry)
         marking = settings.entry(data, Hook::Claude::POST_EVENT)
         return already_installed(plan) if up_to_date?(entry, marking, plan)
         return planned(plan, "Would add the gitflash hook to #{plan[:file]}") if ui.dry_run?
@@ -30,8 +35,59 @@ module Gitflash
 
       def build_plan
         scope = choice(:scope, SCOPES, 'local')
-        { scope: scope, file: settings.path(scope), command: hook_command,
-          marking_command: MARKING_COMMAND, applies_to: settings.applies_to(scope) }
+        file = settings.path(scope)
+        refuse_symlink!(file) unless scope == 'user'
+        { scope: scope, file: file, marking_command: MARKING_COMMAND,
+          applies_to: settings.applies_to(scope) }
+      end
+
+      # Without --mode the installed mode is kept, so running install again to add the
+      # PostToolUse hook never turns ask or deny off. A weaker --mode needs --downgrade.
+      def add_mode(plan, entry)
+        previous = entry && installed_mode(entry['command'])
+        mode = options[:mode] ? choice(:mode, Hook::Claude::MODES, 'snapshot') : previous
+        mode ||= 'snapshot'
+        refuse_downgrade!(previous, mode) if previous
+        plan[:mode] = mode
+        plan[:previous_mode] = previous if previous && previous != mode
+        plan[:command] = hook_command(mode)
+      end
+
+      # The mode the installed command runs in, read the way a shell splits it: `snapshot` when
+      # it has no --mode; a --mode gitflash does not know is refused, never read as snapshot,
+      # so a reinstall cannot quietly weaken it
+      def installed_mode(command)
+        words = Shellwords.split(command.to_s)
+        index = words.index { |word| word == '--mode' || word.start_with?('--mode=') }
+        return 'snapshot' unless index
+
+        mode = words[index] == '--mode' ? words[index + 1] : words[index].delete_prefix('--mode=')
+        return mode if Hook::Claude::MODES.include?(mode)
+
+        raise Error.new("The installed hook command `#{command}` has a mode gitflash cannot " \
+                        'read; fix or remove it, then install again', code: 'invalid_settings')
+      rescue ArgumentError
+        raise Error.new("The installed hook command `#{command}` cannot be parsed",
+                        code: 'invalid_settings')
+      end
+
+      def refuse_downgrade!(previous, mode)
+        return if options[:downgrade] || STRENGTH.index(mode).to_i >= STRENGTH.index(previous).to_i
+
+        usage_error!('invalid_options',
+                     "The installed hook runs in #{previous} mode; --mode #{mode} would protect " \
+                     'less. Pass --downgrade to change it anyway.')
+      end
+
+      # The repository decides what .claude holds, and a link there could point at the user's own
+      # settings; writing through it would change a scope other than the one asked for. The
+      # user scope may be a link (dotfiles) because the user owns it.
+      def refuse_symlink!(file)
+        linked = [file, File.dirname(file)].find { |path| File.symlink?(path) }
+        return unless linked
+
+        raise Error.new("#{linked} is a symbolic link; gitflash will not write settings through it",
+                        code: 'invalid_settings')
       end
 
       def settings
@@ -41,10 +97,9 @@ module Gitflash
       def install(data, entry, marking, plan)
         entry ? entry['command'] = plan[:command] : add_entry(data, 'PreToolUse', plan[:command])
         add_entry(data, Hook::Claude::POST_EVENT, MARKING_COMMAND) unless marking
-        FileUtils.mkdir_p(File.dirname(plan[:file]))
-        File.write(plan[:file], "#{JSON.pretty_generate(data)}\n")
+        write_atomically(plan[:file], "#{JSON.pretty_generate(data)}\n")
         ui.report(status: 'done', plan: plan, result: plan,
-                  text: "Installed the gitflash hook in #{plan[:file]}.\n" \
+                  text: "Installed the gitflash hook in #{plan[:file]} (#{mode_text(plan)}).\n" \
                         "It applies to #{plan[:applies_to]}, including running ones.")
       end
 
@@ -55,22 +110,34 @@ module Gitflash
         usage_error!('invalid_options', "Unknown #{name} '#{value}' (use #{allowed.join(', ')})")
       end
 
-      def hook_command
-        mode = choice(:mode, Hook::Claude::MODES, 'snapshot')
+      def hook_command(mode)
         mode == 'snapshot' ? 'gitflash hook claude' : "gitflash hook claude --mode #{mode}"
       end
 
+      def mode_text(plan)
+        changed = plan[:previous_mode] ? ", was #{plan[:previous_mode]}" : ''
+        "#{plan[:mode]} mode#{changed}"
+      end
+
       def already_installed(plan)
         ui.report(status: 'noop', plan: plan, result: plan,
                   text: "Already installed in #{plan[:file]}.\nIt applies to #{plan[:applies_to]}.")
       end
 
+      # Claude Code ignores a settings file it cannot parse, and with it the user's own
+      # permission rules, so the file is replaced in one step (AtomicFile)
+      def write_atomically(path, text)
+        AtomicFile.write(path, text)
+      rescue SystemCallError, IOError => e
+        raise Error.new("Could not write #{path}: #{e.message}", code: 'invalid_settings')
+      end
+
+      # Settings#read has checked that `hooks` and each of its events have the shape Claude Code
+      # reads, so a missing event is the only one to create
       def add_entry(data, event, command)
-        hooks = (data['hooks'] ||= {})
-        (hooks[event] ||= []) << {
-          'matcher' => 'Bash',
-          'hooks' => [{ 'type' => 'command', 'command' => command, 'timeout' => 30 }]
-        }
+        groups = ((data['hooks'] ||= {})[event] ||= [])
+        hook = { 'type' => 'command', 'command' => command, 'timeout' => 30 }
+        groups << { 'matcher' => 'Bash', 'hooks' => [hook] }
       end
     end
   end

data/lib/gitflash/commands/mark.rb

@@ -2,8 +2,10 @@
 
 module Gitflash
   module Commands
-    # Marks branches as agent or human work (`--owner`, default agent) or removes the mark
-    # (`--clear`), so `gitflash clean --agent` knows which branches an agent created.
+    # Marks branches as agent or human work (`--owner`) or removes the mark (`--clear`), so
+    # `gitflash clean --agent` knows which branches an agent created. Without --owner a person
+    # in a terminal marks the branch as theirs (human) and an agent or script as agent work:
+    # `agent` is the side `clean --agent` deletes, so a person never claims it by accident.
     # Without branch names the current branch is marked. Needs no confirmation: only a git
     # config key changes, and `--clear` or another `mark` reverses it.
     class Mark < Base
@@ -32,12 +34,16 @@ module Gitflash
           usage_error!('invalid_options', 'Use either --owner or --clear, not both') if given
           return nil
         end
-        return 'agent' if given.nil?
+        return default_owner if given.nil?
         return given if Ownership::OWNERS.include?(given)
 
         usage_error!('invalid_options', "Unknown owner '#{given}' (use agent or human)")
       end
 
+      def default_owner
+        $stdin.tty? ? 'human' : 'agent'
+      end
+
       def verb
         options[:clear] ? 'clear the mark of' : "mark as #{owner}"
       end

data/lib/gitflash/commands/pick.rb

@@ -18,8 +18,10 @@ module Gitflash
       end
 
       def call(source = nil, *shas)
-        usage_error!('input_required', 'Pass the source branch: gitflash pick SOURCE') unless source
         check_idle!
+        source ||= pick_source
+        return 0 if source.nil?
+
         candidates = cherry_pick.candidates(source_ref(source))
         return list(source, candidates) if options[:list]
 
@@ -31,6 +33,16 @@ module Gitflash
 
       private
 
+      # The branch picked from a menu of the other local branches (as `checkout` does), nil after
+      # telling the user there is no other branch
+      def pick_source
+        require_interactive!('Pass the source branch: gitflash pick SOURCE')
+        branches = repo.branches
+        return nothing_chosen('You only have one branch!') if branches.size < 2
+
+        ui.select('Select the branch to pick commits from', branches.reject(&:current?).map(&:name))
+      end
+
       def check_idle!
         return unless cherry_pick.in_progress?
 

data/lib/gitflash/commands/pick_control.rb

@@ -15,8 +15,8 @@ module Gitflash
         usage_error!('invalid_usage', 'No cherry-pick in progress') unless cherry_pick.in_progress?
 
         plan = build_plan(action)
-        return perform(action, plan, nil) if action == 'continue'
         return planned(plan, "Would #{action} the cherry-pick in progress") if ui.dry_run?
+        return perform(action, plan, nil) if action == 'continue'
         return cancelled(plan) unless ui.confirm?(summary(action), plan: plan)
 
         perform(action, plan, take_snapshot("gitflash pick --#{action}", scope: %w[head worktree]))

data/lib/gitflash/commands/removal_report.rb

@@ -21,7 +21,8 @@ module Gitflash
       end
 
       def ignored_line(row)
-        "* #{row[:path]}: #{row[:ignored_count]} (#{row[:ignored].join(', ')})"
+        "* #{TerminalText.line(row[:path])}: #{row[:ignored_count]} " \
+          "(#{TerminalText.line(row[:ignored].join(', '))})"
       end
 
       def report_results(plan, outcomes)
@@ -56,8 +57,12 @@ module Gitflash
       end
 
       def results_text(result)
-        lines = result[:removed].map { |row| "Removed #{row[:path]} (undo: #{row[:undo]})" }
-        lines += result[:failed].map { |row| "Not removed #{row[:path]}: #{row[:error]}" }
+        lines = result[:removed].map do |row|
+          "Removed #{TerminalText.line(row[:path])} (undo: #{row[:undo]})"
+        end
+        lines += result[:failed].map do |row|
+          "Not removed #{TerminalText.line(row[:path])}: #{row[:error]}"
+        end
         lines.join("\n")
       end
     end

data/lib/gitflash/commands/snapshot_create.rb

@@ -20,10 +20,12 @@ module Gitflash
       end
 
       def text(snapshot)
-        text = "Saved snapshot #{snapshot.id}"
-        return text if snapshot.skipped_files.empty?
-
-        "#{text}\nSkipped large untracked files: #{snapshot.skipped_files.join(', ')}"
+        lines = ["Saved snapshot #{snapshot.id}"]
+        lines << "Skipped large untracked files: #{snapshot.skipped_files.join(', ')}" if
+          snapshot.skipped_files.any?
+        lines << "Left out by snapshot_exclude: #{snapshot.excluded_files.join(', ')}" if
+          snapshot.excluded_files.any?
+        lines.join("\n")
       end
     end
   end

data/lib/gitflash/commands/undo.rb

@@ -2,15 +2,15 @@
 
 module Gitflash
   module Commands
-    # Restores a snapshot (the latest one by default). The current state is saved first,
-    # so an undo can itself be undone.
+    # Restores a snapshot (by default the latest one taken in this worktree). The current state
+    # is saved first, so an undo can itself be undone.
     class Undo < Base
       def call(id = nil)
         snapshot = find(id)
         return no_snapshots unless snapshot
 
         restore = build_restore(snapshot)
-        plan = restore.plan.merge(snapshot: snapshot.id)
+        plan = restore.plan.merge(snapshot: snapshot.id, reason: snapshot.reason)
         return nothing_to_undo(plan) if restore.empty?
 
         restore!(snapshot, restore, plan)
@@ -18,12 +18,19 @@ module Gitflash
 
       private
 
+      # Snapshots are shared by all worktrees of the repository, and another agent may have
+      # taken the newest one elsewhere; without an ID only this worktree's count
       def find(id)
-        return snapshots.list.first if id.nil?
+        return snapshots.list.find { |snapshot| own?(snapshot) } if id.nil?
 
         snapshots.find(id) || usage_error!('unknown_snapshot', "Unknown snapshot '#{id}'")
       end
 
+      # Taken in this worktree; snapshots from before worktree_path was recorded count too
+      def own?(snapshot)
+        snapshot.worktree_path.nil? || snapshot.worktree_path == repo.toplevel
+      end
+
       # A snapshot of a worktree that is gone is restored by adding the worktree again
       def build_restore(snapshot)
         return WorktreeRevival.new(snapshot, repo: repo) if removed_worktree?(snapshot)
@@ -34,14 +41,14 @@ module Gitflash
 
       # The snapshot was taken in a worktree whose directory no longer exists
       def removed_worktree?(snapshot)
-        (snapshot.scope?('head') || snapshot.scope?('worktree')) &&
-          snapshot.worktree_path != repo.toplevel && !File.exist?(snapshot.worktree_path)
+        !own?(snapshot) && (snapshot.scope?('head') || snapshot.scope?('worktree')) &&
+          !File.exist?(snapshot.worktree_path)
       end
 
       # Branches are shared between worktrees; HEAD and files belong to one worktree
       def check_worktree!(snapshot)
         return unless snapshot.scope?('head') || snapshot.scope?('worktree')
-        return if snapshot.worktree_path == repo.toplevel
+        return if own?(snapshot)
 
         usage_error!('wrong_worktree', "Snapshot #{snapshot.id} was taken in " \
                                        "#{snapshot.worktree_path}; run gitflash undo there")
@@ -80,12 +87,16 @@ module Gitflash
       def revival_hint(plan)
         return '' unless plan[:recreate_worktree]
 
-        "\nThe worktree #{plan[:recreate_worktree]} was added again and may be partly restored; " \
-          "remove it with: gitflash wt remove #{plan[:recreate_worktree]} --force"
+        path = TerminalText.line(plan[:recreate_worktree])
+        "\nThe worktree #{path} was added again and may be partly restored; " \
+          "remove it with: gitflash wt remove #{path} --force"
       end
 
       def no_snapshots
-        ui.report(status: 'noop', result: { snapshot: nil }, text: 'No snapshots to undo')
+        ui.report(status: 'noop', result: { snapshot: nil },
+                  text: 'No snapshots of this worktree to undo. `gitflash snapshots` lists all: ' \
+                        'run `gitflash undo ID` in the worktree a snapshot was taken in (an ' \
+                        'ID from elsewhere works here only for a branches-only snapshot)')
       end
 
       def nothing_to_undo(plan)
@@ -100,7 +111,9 @@ module Gitflash
 
       def describe(plan)
         lines = plan[:branches].map { |change| branch_line(change) }
-        lines << "* add worktree #{plan[:recreate_worktree]} again" if plan[:recreate_worktree]
+        if plan[:recreate_worktree]
+          lines << "* add worktree #{TerminalText.line(plan[:recreate_worktree])} again"
+        end
         lines << head_line(plan[:head]) if plan[:head] && !plan[:recreate_worktree]
         (lines + file_lines(plan)).join("\n")
       end

data/lib/gitflash/commands/worktree_add.rb

@@ -15,7 +15,7 @@ module Gitflash
         plan = build_plan(branch, source)
         if ui.dry_run?
           return planned(plan,
-                         "Would add worktree #{plan[:path]} on #{branch} (#{source})")
+                         "Would add worktree #{shown(plan[:path])} on #{branch} (#{source})")
         end
 
         add(worktrees, plan)
@@ -48,13 +48,15 @@ module Gitflash
         holder = worktrees.list.find { |worktree| worktree.branch == branch }
         return unless holder
 
-        usage_error!('invalid_usage', "Branch #{branch} is already checked out at #{holder.path}")
+        usage_error!('invalid_usage',
+                     "Branch #{branch} is already checked out at #{TerminalText.line(holder.path)}")
       end
 
       def build_plan(branch, source)
         path = target_path(branch)
         if File.exist?(path) && !(File.directory?(path) && Dir.empty?(path))
-          usage_error!('invalid_usage', "#{path} already exists and is not an empty directory")
+          usage_error!('invalid_usage',
+                       "#{TerminalText.line(path)} already exists and is not an empty directory")
         end
 
         { branch: branch, path: path, source: source.to_s, from: options[:from],
@@ -86,7 +88,7 @@ module Gitflash
 
       def report(plan)
         ui.report(status: 'done', plan: plan, result: outcome(plan),
-                  text: "Added worktree #{plan[:path]} on #{plan[:branch]}")
+                  text: "Added worktree #{TerminalText.line(plan[:path])} on #{plan[:branch]}")
       end
 
       def outcome(plan)

data/lib/gitflash/commands/worktree_command.rb

@@ -11,10 +11,24 @@ module Gitflash
       end
 
       # The worktree named by a path or a branch; raises `unknown_worktree` when none matches
+      # A target that names one worktree by path and another by branch is refused, so a command
+      # never acts on the worktree the caller did not mean
       def find!(target, list = worktrees.list)
-        path = File.expand_path(target)
-        list.find { |worktree| worktree.path == path || worktree.branch == target } ||
-          usage_error!('unknown_worktree', "Unknown worktree: #{target}")
+        path = expand(target)
+        found = list.select { |worktree| worktree.path == path || worktree.branch == target }
+        usage_error!('unknown_worktree', "Unknown worktree: #{target}") if found.empty?
+        return found.first if found.one?
+
+        paths = found.map { |worktree| TerminalText.line(worktree.path) }.join(', ')
+        usage_error!('invalid_usage', "#{target} names more than one worktree (#{paths}); " \
+                                      'pass the full path')
+      end
+
+      # File.expand_path, but `~name` for an unknown user is a usage error, not a crash
+      def expand(path)
+        File.expand_path(path)
+      rescue ArgumentError => e
+        usage_error!('invalid_options', "Cannot read the path #{path}: #{e.message}")
       end
 
       def refuse_main!(worktree, action)

data/lib/gitflash/commands/worktree_list.rb

@@ -13,13 +13,13 @@ module Gitflash
       private
 
       def table(worktrees)
-        width = worktrees.map { |worktree| worktree.path.length }.max
+        width = worktrees.map { |worktree| TerminalText.line(worktree.path).length }.max
         worktrees.map { |worktree| row(worktree, width) }.join("\n")
       end
 
       def row(worktree, width)
-        [worktree.path.ljust(width), worktree.branch || "(detached #{worktree.head.to_s[0, 7]})",
-         flags(worktree)].join('  ').rstrip
+        name = worktree.branch || "(detached #{worktree.head.to_s[0, 7]})"
+        [TerminalText.line(worktree.path).ljust(width), name, flags(worktree)].join('  ').rstrip
       end
 
       def flags(worktree)

data/lib/gitflash/commands/worktree_lock.rb

@@ -13,7 +13,10 @@ module Gitflash
         worktree = find!(target)
         refuse_main!(worktree, verb)
         return noop(worktree) if worktree.locked? == lock?
-        return planned(plan(worktree), "Would #{verb} #{worktree.path}") if ui.dry_run?
+        if ui.dry_run?
+          return planned(plan(worktree),
+                         "Would #{verb} #{TerminalText.line(worktree.path)}")
+        end
 
         change(worktree)
       end
@@ -32,7 +35,7 @@ module Gitflash
         result = git_change(worktree)
         git_error!("worktree #{verb}", result) unless result.success?
 
-        report('done', worktree, "#{verb.capitalize}ed #{worktree.path}")
+        report('done', worktree, "#{verb.capitalize}ed #{TerminalText.line(worktree.path)}")
       end
 
       def git_change(worktree)
@@ -42,7 +45,8 @@ module Gitflash
       end
 
       def noop(worktree)
-        report('noop', worktree, "#{worktree.path} is #{lock? ? 'already locked' : 'not locked'}")
+        report('noop', worktree,
+               "#{TerminalText.line(worktree.path)} is #{lock? ? 'already locked' : 'not locked'}")
       end
 
       def report(status, worktree, text)

data/lib/gitflash/commands/worktree_move.rb

@@ -14,7 +14,10 @@ module Gitflash
         worktree = find!(target)
         check!(worktree)
         plan = { from: worktree.path, to: File.expand_path(destination), force: force? }
-        return planned(plan, "Would move #{plan[:from]} to #{plan[:to]}") if ui.dry_run?
+        if ui.dry_run?
+          return planned(plan,
+                         "Would move #{shown(plan[:from])} to #{shown(plan[:to])}")
+        end
 
         move(plan)
       end
@@ -28,11 +31,13 @@ module Gitflash
       def check!(worktree)
         refuse_main!(worktree, 'move')
         if worktree.path == repo.toplevel
-          usage_error!('protected_worktree', "#{worktree.path} is the current worktree")
+          usage_error!('protected_worktree',
+                       "#{TerminalText.line(worktree.path)} is the current worktree")
         end
         return unless worktree.locked? && !force?
 
-        usage_error!('protected_worktree', "#{worktree.path} is locked (use --force)")
+        usage_error!('protected_worktree',
+                     "#{TerminalText.line(worktree.path)} is locked (use --force)")
       end
 
       def move(plan)
@@ -40,7 +45,7 @@ module Gitflash
         git_error!('worktree move', result) unless result.success?
 
         ui.report(status: 'done', plan: plan, result: plan.slice(:from, :to),
-                  text: "Moved #{plan[:from]} to #{plan[:to]}")
+                  text: "Moved #{shown(plan[:from])} to #{shown(plan[:to])}")
       end
     end
   end

data/lib/gitflash/commands/worktree_prune.rb

@@ -34,7 +34,7 @@ module Gitflash
       end
 
       def bullets(plan)
-        plan[:worktrees].map { |path| "* #{path}" }.join("\n")
+        plan[:worktrees].map { |path| "* #{TerminalText.line(path)}" }.join("\n")
       end
     end
   end

data/lib/gitflash/commands/worktree_remove.rb

@@ -6,7 +6,8 @@ module Gitflash
     # The main checkout, the worktree gitflash runs in, locked and dirty worktrees are refused
     # unless --force is given (the main checkout and the current one never can be removed).
     # Each removal saves a snapshot of the worktree first; `gitflash undo ID` brings the
-    # directory, its branch and its uncommitted files back.
+    # directory, its branch and its uncommitted files back. Ignored files cannot be saved, so a
+    # removal that deletes some needs --confirm TOKEN instead of --yes.
     class WorktreeRemove < WorktreeCommand
       include RemovalReport
 
@@ -24,13 +25,18 @@ module Gitflash
       def pick(worktrees)
         require_interactive!('Pass the worktrees to remove: gitflash wt remove PATH_OR_BRANCH...')
         choices = worktrees.reject { |worktree| worktree.main? || current?(worktree) }
-                           .to_h { |wt| ["#{wt.branch || '(detached)'}  #{wt.path}", wt.path] }
+                           .to_h { |wt| [menu_label(wt), wt.path] }
         return report_nothing('No worktrees available to remove') if choices.empty?
 
         picked = ui.multi_select('Select worktrees to remove', choices)
         picked.empty? ? report_nothing('No worktrees selected') : picked
       end
 
+      # Paths come from the repository, so control characters in them are shown as escapes
+      def menu_label(worktree)
+        TerminalText.line("#{worktree.branch || '(detached)'}  #{worktree.path}")
+      end
+
       def force?
         options[:force] ? true : false
       end
@@ -51,7 +57,11 @@ module Gitflash
       def remove(chosen)
         plan = build_plan(chosen)
         return planned(plan, "Would remove:\n#{preview(chosen, plan)}") if dry_run?
-        return cancelled(plan) unless ui.confirm?(summary(chosen, plan), plan: plan)
+
+        # Ignored files are never saved, so losing them needs --confirm TOKEN, not --yes
+        confirmed = ui.confirm?(summary(chosen, plan), plan: plan,
+                                                       irreversible: loses_ignored?(plan))
+        return cancelled(plan) unless confirmed
 
         outcomes = chosen.map { |worktree| remove_one(worktree) }
         report_results(plan, outcomes)
@@ -59,6 +69,10 @@ module Gitflash
 
       def dry_run? = ui.dry_run?
 
+      def loses_ignored?(plan)
+        plan[:worktrees].any? { |row| row[:ignored_count].positive? }
+      end
+
       def preview(chosen, plan) = "#{bullets(chosen)}#{ignored_warning(plan)}"
 
       # The plan reported and returned in JSON; `wt clean` adds why each worktree was chosen
@@ -74,7 +88,7 @@ module Gitflash
 
       def remove_one(worktree)
         snapshot = snapshot_for(worktree)
-        unsaved = snapshot.skipped_files
+        unsaved = snapshot.unsaved_files
         return refuse_unsaved(worktree, unsaved) if unsaved.any?
 
         result = Worktrees.new(repo: repo).remove(worktree.path, force: force?)
@@ -85,8 +99,8 @@ module Gitflash
       def refuse_unsaved(worktree, files)
         shown = files.first(3).join(', ')
         shown += ", and #{files.size - 3} more" if files.size > 3
-        message = "#{files.size} untracked file(s) over 50 MB cannot be saved by a snapshot " \
-                  "(#{shown}); move or delete them first"
+        message = "#{files.size} untracked file(s) cannot be saved by a snapshot (over 50 MB or " \
+                  "matched by snapshot_exclude: #{shown}); move or delete them first"
         Removal.new(worktree: worktree, result: Result.new(success: false, output: message),
                     snapshot: nil)
       end
@@ -107,7 +121,9 @@ module Gitflash
       end
 
       def bullets(chosen)
-        chosen.map { |worktree| "* #{worktree.path} (#{worktree.branch || 'detached'})" }.join("\n")
+        chosen.map { |worktree|
+          "* #{TerminalText.line(worktree.path)} (#{worktree.branch || 'detached'})"
+        }.join("\n")
       end
 
       def report_nothing(text)