gitflash 0.7.0.beta1 → 0.7.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8466fec203a9fdd7ac08e721fb0bb624fb8f486e68f9b369660e5d369e717ad
-  data.tar.gz: 53243a2e0dc1d5877bd5541999fec636e89ac882b9af78d84790ef32be3e12cb
+  metadata.gz: d5d05aaa23c964d36999d266023460edddaaaf9b6298e02143de593b583d79f9
+  data.tar.gz: 5112665666f18a4a91a025765a33f3b5591a4d02adad72c1512624c66d245586
 SHA512:
-  metadata.gz: 27b78d4baac19b15a9f6bef731cc0ec3622ee5c51a2ee82ab9f20a63a5f50d6ecedb3c4f1651d0849eae970f5a66c20480272d0bf00b0284e8434f1893805901
-  data.tar.gz: 1c1f6e76de4e2f67fb7c1c591e9569d8578a96cad8cc9e58ff75fd9448abaa8ead4e7b96cef519d6a4a991e75299e07eaafcc8d060896b8742b9c7f4ec4b93f5
+  metadata.gz: ec5b291e0e0d4c1ed23c540356c9c5c6c2f1c65e5c1494e0afc38d7187ae0e05861e4c524fecb37552105e12d6182387b67e615afc8fe2a716538c235b039484
+  data.tar.gz: f34102849614fc40763142de8a3c85c0c59fdbadd2534306e7f6c8da507fa0c4f0851c6c3ec6aa1a96a7931b56e8407691c7a48ff54d10455abff6019f526f42

data/CHANGELOG.md

@@ -87,3 +87,25 @@ Beta of the parallel agent work release. Install with `gem install gitflash --pr
 - The Claude Code hook also runs after Bash commands (`PostToolUse`): branches created with plain git (`checkout -b`, `switch -c`, `branch NAME`, `worktree add`) are marked as agent work. `hook install` adds it, so run it again after upgrading; `hook status` reports whether marking is on. A gitflash hook under a matcher that does not cover Bash no longer counts as installed
 - JSON schema: new commands `clean`, `mark`, `pick` and `worktree ...`, error codes `invalid_config`, `unknown_worktree`, `protected_worktree` and `conflict`, the `owner` field, and `recreate_worktree` in the `undo` plan
 - Author names from other branches are shown with control characters escaped in `pick` output
+
+## [0.7.0.beta2] - 2026-10-08
+
+Second beta of the parallel agent work release: the `pick` branch list, a quieter `hook claude` and a round of security fixes on top of beta1. Install with `gem install gitflash --pre`. If you installed the hook before, run `gitflash hook install` again. Needs git 2.36 or newer.
+
+- `pick` without a source branch shows a list of the other local branches in a terminal, as `checkout` does; without a terminal the source is still required
+- `hook claude` is no longer listed in `gitflash hook` help (it is run by Claude Code, not by hand; `gitflash hook help claude` still describes it) and prints a short note instead of waiting for input when run in a terminal. The `hook` line in `gitflash help` now says it installs and checks the Claude Code hooks
+- Security hardening, from a CodeRabbit scan of the repository:
+  - Snapshots save untracked files whose names look like Git pathspec magic (`:(exclude)*`) or start or end with a space; before, such a name could drop other files from the snapshot. `Repo#toplevel` and the git readers keep whitespace at the end of a path
+  - Confirmation prompts show control characters in paths as escapes, as other output does
+  - `protected` branch patterns of the user file and the repository file add up; a repository can protect more branches but can no longer remove the ones the user protects
+  - `worktree_dir` may only use `%<repo>s` and `%<branch>s` and is limited to 512 characters (anything else is `invalid_config`); a format width such as `%<repo>999999999s` could exhaust memory
+  - `pick --continue --dry-run` only shows the plan
+  - `pick` reads `git log -z` with one field per line, so a commit message cannot forge entries in the list, and only commits found by `git rev-list` are offered
+  - The git runner never hands a lone string to a shell
+  - The Claude hook in `ask` mode asks also when no snapshot could be saved, notices bundled branch flags (`git branch -qD x`), `git clean -i`, and commands inside `bash -c`, `sh -c` and `eval`, and marks a branch as agent work only if it did not exist before the command
+  - `hook install` refuses to write `.claude` settings through a symbolic link in the repository (the user scope may be a link)
+  - `docs/map/_meta/check.rb` and `sync-twins.sh` do not follow links, read files over 2 MB, or print raw file names
+  - Output keeps a path from the repository on one line: a newline or tab in a worktree path is shown as an escape, so it cannot forge a row in the confirmation text, the list or the menus. `Repo#toplevel` and the git readers remove only git's final newline, not a carriage return that ends the path
+  - When a command touches several directories the hook tells Claude one `gitflash undo` command per snapshot; a failure to record branches never stops the snapshot; the record directory is refused unless it is a real directory only the user can use
+  - A literal backslash in a path is shown doubled, so a path with a newline and a path with the characters backslash and n stay two different choices in the `wt remove` menu
+  - The hook marks a branch the command deleted and created again (`git branch -D x && git switch -c x`) as agent work: the record keeps a branch's creation stamp, not only its name

data/README.md

@@ -24,7 +24,7 @@ Or install it yourself as:
 
     $ gem install gitflash
 
-Prerelease versions such as `0.7.0.beta1` are only installed when you ask for them: `gem install gitflash --pre`, or `gem 'gitflash', '0.7.0.beta1'` in a Gemfile.
+Prerelease versions such as `0.7.0.beta2` are only installed when you ask for them: `gem install gitflash --pre`, or `gem 'gitflash', '0.7.0.beta2'` in a Gemfile.
 
 ## Requirements
 
@@ -43,7 +43,7 @@ Run `gitflash` inside a git repository to get a list with the available commands
 | `gitflash mark [BRANCH...]` | Mark branches as agent (default) or human work, or `--clear` the mark. Without a branch it marks the current one. Use it for branches made with plain git so `clean --agent` can find them |
 | `gitflash clean` | Delete merged branches and branches whose upstream is gone, with a snapshot first. `--stale [DAYS]` and `--agent` add stale and agent-created branches; unmerged ones are kept unless `--force`. Protected: current, default, `main`, `master`, `protected` in `.gitflash.yml`, branches checked out in a worktree |
 | `gitflash worktree` (`wt`) `list`, `add`, `remove`, `clean`, `prune`, `lock`, `unlock`, `move` | Worktrees for parallel agent work, with absolute paths in `--json` (see below) |
-| `gitflash pick SOURCE [SHA...]` | Cherry-pick commits from another branch: `--list` shows what is missing here, `--continue`, `--skip` and `--abort` handle conflicts |
+| `gitflash pick [SOURCE] [SHA...]` | Cherry-pick commits from another branch (pick SOURCE from a list when you omit it): `--list` shows what is missing here, `--continue`, `--skip` and `--abort` handle conflicts |
 | `gitflash undo [SNAPSHOT]` | Restore a snapshot, the latest by default: deleted branches, moved branches, HEAD, uncommitted and untracked files, dropped stashes |
 | `gitflash snapshot` | Save the current state on request (`--scope`, `--message`) |
 | `gitflash snapshots` | List snapshots, newest first |
@@ -64,9 +64,9 @@ Run `gitflash` inside a git repository to get a list with the available commands
 Settings live in `.gitflash.yml` in the repository and `~/.config/gitflash.yml` (the repository file wins):
 
 ```yaml
-protected: ["release/*"]   # branch patterns clean and delete never touch
+protected: ["release/*"]   # branch patterns clean and delete never touch; both files add up
 stale_days: 30             # used by --stale without a number
-worktree_dir: "../%<repo>s.worktrees/%<branch>s"
+worktree_dir: "../%<repo>s.worktrees/%<branch>s"   # only these two placeholders, up to 512 characters
 ```
 
 ### Undo

data/command_descriptions.yml

@@ -110,6 +110,10 @@ pick:
   long: |
     Moves fixes between branches, for example between agent branches.
 
+    Without SOURCE, a terminal shows a list of the other local branches to choose from (use the
+    arrow keys, type to search, `enter` to choose and `ctrl+c` to cancel). Without a terminal,
+    SOURCE is required.
+
     `gitflash pick SOURCE --list` lists the commits of SOURCE that are not on the current branch
     yet, oldest first, with SHA, subject, author, date and a diff summary. A commit whose change
     is already here (the same patch under another SHA) is marked `=` (`applied` in JSON) and is

data/lib/gitflash/cherry_pick/log_parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Gitflash
+  class CherryPick
+    # Reads the output of `git log -z --shortstat --format=FORMAT` into Candidate records.
+    #
+    # One field per line: a subject or an author name cannot hold a newline, and `-z` ends each
+    # commit with a NUL, which text cannot hold either, so the framing is unambiguous whatever a
+    # commit message says. Git prints the fields of a commit, a NUL, the stat of that commit and
+    # the fields of the next one. So chunk 0 holds the fields of commit 0, chunk i the stat of
+    # commit i-1 and the fields of commit i, and the last chunk only a stat.
+    module LogParser
+      FORMAT = '%m%n%H%n%s%n%an%n%cI'
+      FIELDS = 5
+
+      module_function
+
+      def parse(output)
+        chunks = output.split("\0", -1)
+        stats = stats_of(chunks)
+        fields = chunks[0...-1].map { |chunk| chunk.lines(chomp: true).last(FIELDS) }
+        fields.each_with_index.filter_map do |row, index|
+          candidate(row, stats[index + 1]) if row.size == FIELDS
+        end
+      end
+
+      def stats_of(chunks)
+        last = chunks.size - 1
+        chunks.each_with_index.map { |chunk, index| stat_part(chunk, index == last) }
+      end
+
+      # The part of a chunk before the fields of the next commit; the last chunk is all stat
+      def stat_part(chunk, last)
+        last ? chunk : chunk.lines(chomp: true)[0...-FIELDS].to_a.join("\n")
+      end
+
+      def candidate(row, stat_text)
+        mark, sha, subject, author, date = row
+        files, insertions, deletions = stat(stat_text)
+        Candidate.new(sha: sha, subject: subject, author: author, date: date,
+                      applied: mark == '=', files: files, insertions: insertions,
+                      deletions: deletions)
+      end
+
+      # [files, insertions, deletions] from a line such as
+      # " 2 files changed, 3 insertions(+), 1 deletion(-)". Split on commas and spaces, with no
+      # regular expression, so a long run of digits in the text costs only its own length.
+      def stat(text)
+        line = text.to_s.lines.map(&:strip).reject(&:empty?).last.to_s
+        counts = { 'file' => 0, 'insertion' => 0, 'deletion' => 0 }
+        line.split(',').each { |part| tally(counts, part) }
+        counts.values
+      end
+
+      def tally(counts, part)
+        count, label = part.strip.split(' ', 2)
+        number = Integer(count, 10, exception: false)
+        kind = counts.keys.find { |name| label.to_s.start_with?(name) }
+        counts[kind] = number if number && kind
+      end
+    end
+  end
+end

data/lib/gitflash/cherry_pick.rb

@@ -19,9 +19,6 @@ module Gitflash
     # The state of an unfinished pick: files with conflicts and the commits still to apply
     Progress = Data.define(:conflicted, :remaining, :current)
 
-    RECORD = "\x1e"
-    SEPARATOR = "\x1f"
-    FORMAT = ['%m', '%H', '%s', '%an', '%cI'].join(SEPARATOR)
     ENV_NO_EDITOR = { 'GIT_EDITOR' => 'true', 'GIT_SEQUENCE_EDITOR' => 'true' }.freeze
 
     def initialize(bash: Git::BashCommand)
@@ -38,10 +35,11 @@ module Gitflash
     # Commits of `source_ref` that are not merges, oldest first, each marked as applied when an
     # equivalent change (same patch) is already on HEAD
     def candidates(source_ref)
-      output = @bash.exec('git', 'log', '--left-right', '--cherry-mark', '--right-only',
-                          '--no-merges', '--reverse', '--shortstat', "--format=#{RECORD}#{FORMAT}",
+      output = @bash.exec('git', 'log', '-z', '--left-right', '--cherry-mark', '--right-only',
+                          '--no-merges', '--reverse', '--shortstat', "--format=#{LogParser::FORMAT}",
                           "HEAD...#{source_ref}", '--')
-      output.split(RECORD).reject { |record| record.strip.empty? }.map { |record| parse(record) }
+      eligible = eligible_shas(source_ref)
+      LogParser.parse(output).select { |candidate| eligible.include?(candidate.sha) }.uniq(&:sha)
     end
 
     # Applies the commits (full shas, in the given order) with `git cherry-pick`.
@@ -70,18 +68,12 @@ module Gitflash
 
     private
 
-    def parse(record)
-      line, *rest = record.split("\n", 2)
-      mark, sha, subject, author, date = line.split(SEPARATOR, 5)
-      files, insertions, deletions = stat(rest.first.to_s)
-      Candidate.new(sha: sha, subject: subject.to_s, author: author, date: date,
-                    applied: mark == '=', files: files, insertions: insertions,
-                    deletions: deletions)
-    end
-
-    def stat(text)
-      [text[/(\d+) files? changed/, 1], text[/(\d+) insertions?\(\+\)/, 1],
-       text[/(\d+) deletions?\(-\)/, 1]].map(&:to_i)
+    # The commits of the source that are not merges and not on HEAD, listed by git without any
+    # text a commit author controls. A commit message holding the separators of the log format
+    # could forge extra records; only SHAs found here become candidates.
+    def eligible_shas(source_ref)
+      @bash.exec('git', 'rev-list', '--right-only', '--no-merges', "HEAD...#{source_ref}", '--')
+           .lines(chomp: true).to_set
     end
 
     def conflicted_files

data/lib/gitflash/cli.rb

@@ -99,7 +99,7 @@ module Gitflash
       run_command('gc', Commands::Gc)
     end
 
-    desc 'hook SUBCOMMAND', 'Agent hooks: claude (run the hook), install (register it)'
+    desc 'hook SUBCOMMAND', 'Claude Code hooks: install them and check they are active'
     subcommand 'hook', HookCli
 
     desc 'pick [SOURCE] [SHA...]', descriptions.pick.short

data/lib/gitflash/commands/base.rb

@@ -14,6 +14,9 @@ module Gitflash
 
       attr_reader :repo, :ui, :options
 
+      # A path from the repository, kept on one line of the output
+      def shown(path) = TerminalText.line(path)
+
       def require_interactive!(message)
         usage_error!('input_required', message) unless ui.interactive?
       end

data/lib/gitflash/commands/hook_install.rb

@@ -30,10 +30,23 @@ module Gitflash
 
       def build_plan
         scope = choice(:scope, SCOPES, 'local')
-        { scope: scope, file: settings.path(scope), command: hook_command,
+        file = settings.path(scope)
+        refuse_symlink!(file) unless scope == 'user'
+        { scope: scope, file: file, command: hook_command,
           marking_command: MARKING_COMMAND, applies_to: settings.applies_to(scope) }
       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
         @settings ||= Hook::Settings.new(options[:scope] == 'user' ? nil : repo)
       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/undo.rb

@@ -80,8 +80,9 @@ 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
@@ -100,7 +101,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_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

@@ -24,13 +24,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
@@ -107,7 +112,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)

data/lib/gitflash/config.rb

@@ -8,13 +8,15 @@ module Gitflash
   # Command-line flags are applied by the commands themselves and win over all of these.
   # An unknown key or a value of the wrong type raises a UsageError, so a typo never goes unnoticed.
   Config = Data.define(:protected_patterns, :stale_days, :worktree_dir) do
-    # `root` is the main checkout; `home` is where the user file lives
+    # `root` is the main checkout; `home` is where the user file lives. The repository file wins
+    # key by key, except `protected`: both files add patterns, so a repository can protect more
+    # branches but never remove what the user protects.
     def self.load(root:, home: Dir.home)
-      values = [File.join(home, ConfigKeys::USER_FILE), File.join(root, ConfigKeys::REPO_FILE)]
+      layers = [File.join(home, ConfigKeys::USER_FILE), File.join(root, ConfigKeys::REPO_FILE)]
                .map { |path| read(path) }
-               .reduce(ConfigKeys::DEFAULTS) { |merged, layer| merged.merge(layer) }
-      new(protected_patterns: values['protected'], stale_days: values['stale_days'],
-          worktree_dir: values['worktree_dir'])
+      values = layers.reduce(ConfigKeys::DEFAULTS) { |merged, layer| merged.merge(layer) }
+      new(protected_patterns: layers.flat_map { |layer| layer.fetch('protected', []) }.uniq,
+          stale_days: values['stale_days'], worktree_dir: values['worktree_dir'])
     end
 
     def self.defaults
@@ -85,10 +87,11 @@ module Gitflash
       protected_patterns.any? { |pattern| File.fnmatch?(pattern, name) }
     end
 
-    # Directory for a new worktree. `%{repo}` and `%{branch}` are replaced; a relative path
-    # is resolved against the main checkout. Slashes in a branch name stay as folders.
+    # Directory for a new worktree. `%<repo>s` and `%<branch>s` are replaced as plain text; a
+    # relative path is resolved against the main checkout. Slashes in a branch name stay as
+    # folders.
     def worktree_path(root:, branch:)
-      path = format(worktree_dir, repo: File.basename(root), branch: branch)
+      path = worktree_dir.gsub('%<repo>s') { File.basename(root) }.gsub('%<branch>s') { branch }
       File.expand_path(path, root)
     end
   end

data/lib/gitflash/config_keys.rb

@@ -9,11 +9,23 @@ module Gitflash
     DEFAULTS = {
       'protected' => [], 'stale_days' => 30, 'worktree_dir' => DEFAULT_WORKTREE_DIR
     }.freeze
+    PLACEHOLDERS = ['%<repo>s', '%<branch>s'].freeze
+    MAX_TEMPLATE_LENGTH = 512
     CHECKS = {
       'protected' => [->(v) { v.is_a?(Array) && v.all?(String) },
                       'a list of branch name patterns'],
       'stale_days' => [->(v) { v.is_a?(Integer) && v.positive? }, 'a positive whole number'],
-      'worktree_dir' => [->(v) { v.is_a?(String) && !v.empty? }, 'a non-empty string']
+      'worktree_dir' => [->(v) { template?(v) },
+                         'a path of up to 512 characters that uses only %<repo>s and %<branch>s']
     }.freeze
+
+    # A path template: the two placeholders are the only `%` directives, so a width such as
+    # `%<repo>999999999s` can never make Ruby build a huge string
+    def self.template?(value)
+      return false unless value.is_a?(String)
+      return false if value.empty? || value.length > MAX_TEMPLATE_LENGTH
+
+      !PLACEHOLDERS.reduce(value) { |rest, placeholder| rest.gsub(placeholder, '') }.include?('%')
+    end
   end
 end

data/lib/gitflash/git/bash_command.rb

@@ -16,9 +16,12 @@ module Gitflash
         end
 
         # Runs a command without a shell and returns [stdout, stderr, success].
-        # `env` adds environment variables for this command only.
+        # `env` adds environment variables for this command only. The executable is passed as a
+        # pair, which keeps Ruby from handing a lone string to a shell.
         def capture(*args, env: {})
-          stdout, stderr, status = Open3.capture3(env, *args)
+          raise CommandError, 'no command given' if args.empty?
+
+          stdout, stderr, status = Open3.capture3(env, [args.first, args.first], *args.drop(1))
           [stdout, stderr, status.success?]
         rescue SystemCallError => e
           raise CommandError, "#{args.join(' ')} failed: #{e.message}"

data/lib/gitflash/hook/branch_marker.rb

@@ -1,30 +1,133 @@
 # frozen_string_literal: true
 
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'tmpdir'
+
 module Gitflash
   module Hook
     # Marks the branches an agent just created as agent work (see Ownership), so
     # `gitflash clean --agent` can find them. Runs in the PostToolUse hook, after the command:
     # the branch exists then, and Claude Code only runs it when the command succeeded.
     #
-    # A branch is marked only when it is unmarked and its reflog says it was created a moment
-    # ago ("branch: Created from ..."), so a branch that was already there is never claimed.
+    # Text in a command proves nothing (`false && git branch x` creates nothing), so a branch is
+    # only marked when it is new:
+    # - the PreToolUse hook records which of the branches the command names exist before it runs
+    #   (`record`), and a branch that existed then is never marked;
+    # - its reflog must say it was created a moment ago ("branch: Created from ..."), which also
+    #   covers a Claude Code that ran no PreToolUse hook;
+    # - it must be unmarked.
     class BranchMarker
       CREATED = 'branch: Created from'
       RECENT_SECONDS = 120
+      STALE_RECORD_SECONDS = 24 * 60 * 60
 
-      def initialize(clock: -> { Time.now })
+      def initialize(clock: -> { Time.now }, state_dir: nil)
         @clock = clock
+        @state_dir = state_dir || File.join(Dir.tmpdir, "gitflash-hook-#{Process.uid}")
+      end
+
+      # PreToolUse: remember the branches the command may create that exist already
+      def record(command, cwd, tool_use_id)
+        creations = CommandParser.new(cwd).creations(command)
+        return if creations.empty? || (path = record_path(tool_use_id)).nil?
+        return unless private_state_dir?
+
+        prune_records
+        File.write(path, JSON.generate(existing_stamps(creations)))
       end
 
-      # Branch names marked as agent work, in the directories the command ran in
-      def call(command, cwd)
+      # PostToolUse: branch names marked as agent work, in the directories the command ran in
+      def call(command, cwd, tool_use_id = nil)
+        existed = take_record(tool_use_id)
         created = CommandParser.new(cwd).creations(command)
-        created.select { |creation| mark(creation[:dir], creation[:branch]) }
+        created.reject { |creation| already_there?(existed, creation) }
+               .select { |creation| mark(creation[:dir], creation[:branch]) }
                .map { |creation| creation[:branch] }.uniq
       end
 
       private
 
+      # { key => stamp } of the named branches that exist now
+      def existing_stamps(creations)
+        existing = creations.select { |creation| branch_exists?(creation[:dir], creation[:branch]) }
+        existing.to_h { |creation| [key(creation), stamp(creation)] }
+      end
+
+      def key(creation)
+        "#{creation[:dir]}\0#{creation[:branch]}"
+      end
+
+      # A branch that was there before the command and is the same branch now. One that the
+      # command deleted and created again has a new reflog, so a new stamp, and counts as new.
+      # An empty stamp (no reflog) is no evidence of a new branch either: all that is known is
+      # that the branch existed, and claiming a branch a person may have made is the worse
+      # mistake, so it is left alone. Without a reflog nothing could be marked in any case.
+      def already_there?(existed, creation)
+        existed.key?(key(creation)) && existed[key(creation)] == stamp(creation)
+      end
+
+      # Time, commit and message of the oldest reflog entry, which is the creation of the branch;
+      # empty when the reflog is off
+      def stamp(creation)
+        return '' unless Dir.exist?(creation[:dir])
+
+        stdout, _stderr, success = Git::BashCommand.capture(
+          'git', '-C', creation[:dir], 'log', '-g', '--format=%ct %H %gs',
+          "#{Repo::HEADS}#{creation[:branch]}", '--'
+        )
+        success ? stdout.lines(chomp: true).last.to_s : ''
+      end
+
+      # One file per tool call, named from a hash so the id can never form a path
+      def record_path(tool_use_id)
+        return nil if tool_use_id.to_s.empty?
+
+        File.join(@state_dir, "#{Digest::SHA256.hexdigest(tool_use_id.to_s)}.json")
+      end
+
+      def take_record(tool_use_id)
+        path = record_path(tool_use_id)
+        return {} unless path && private_state_dir? && File.file?(path)
+
+        record = JSON.parse(File.read(path))
+        record.is_a?(Hash) ? record : {}
+      rescue JSON::ParserError
+        {}
+      ensure
+        FileUtils.rm_f(path) if path
+      end
+
+      # The directory holds the records of this user only: created with mode 0700, and refused
+      # when it is a link, belongs to someone else or is open to the group or others (a shared
+      # /tmp lets another user create the name first)
+      def private_state_dir?
+        FileUtils.mkdir_p(@state_dir, mode: 0o700)
+        stat = File.lstat(@state_dir)
+        stat.directory? && stat.owned? && stat.mode.nobits?(0o077)
+      rescue SystemCallError
+        false
+      end
+
+      # Another hook may delete a record at the same moment: a vanished file is not an error
+      def prune_records
+        Dir.glob(File.join(@state_dir, '*.json')).each do |file|
+          FileUtils.rm_f(file) if @clock.call - File.mtime(file) > STALE_RECORD_SECONDS
+        rescue SystemCallError
+          next
+        end
+      end
+
+      def branch_exists?(dir, branch)
+        return false unless Dir.exist?(dir)
+
+        _stdout, _stderr, success = Git::BashCommand.capture(
+          'git', '-C', dir, 'show-ref', '--verify', '--quiet', "#{Repo::HEADS}#{branch}"
+        )
+        success
+      end
+
       def mark(dir, branch)
         return false unless Dir.exist?(dir)
 

data/lib/gitflash/hook/claude.rb

@@ -29,21 +29,37 @@ module Gitflash
         data = JSON.parse(input)
         return after_command(data) if data['hook_event_name'] == POST_EVENT
 
+        before_command(data)
+      end
+
+      private
+
+      # PreToolUse: remember which branches exist, then snapshot, ask or deny for risky commands
+      def before_command(data)
+        record_branches(data)
         targets = targets(data)
         return nil if targets.empty?
         return deny(targets) if @mode == 'deny'
 
         saved = merge_by_dir(targets).filter_map { |target| save(target) }
-        saved.empty? ? nil : output(saved)
+        # Asking is the user's protection: it must not depend on a snapshot having been saved
+        saved.empty? && @mode != 'ask' ? nil : output(saved, targets)
       end
 
-      private
+      # Recording is a side feature: when it fails, snapshots and the ask or deny decision still run
+      def record_branches(data)
+        return unless bash?(data)
+
+        @marker.record(command_of(data), data['cwd'] || Dir.pwd, data['tool_use_id'])
+      rescue StandardError => e
+        warn "gitflash hook: could not record branches (#{e.message})"
+      end
 
       # PostToolUse: mark the branches the command created, and tell Claude
       def after_command(data)
         return nil unless data['tool_name'] == 'Bash'
 
-        marked = @marker.call(data.dig('tool_input', 'command').to_s, data['cwd'] || Dir.pwd)
+        marked = @marker.call(command_of(data), data['cwd'] || Dir.pwd, data['tool_use_id'])
         return nil if marked.empty?
 
         context = "gitflash marked #{marked.join(', ')} as agent work, so " \
@@ -52,11 +68,18 @@ module Gitflash
         { hookSpecificOutput: { hookEventName: POST_EVENT, additionalContext: context } }
       end
 
+      def bash?(data)
+        data['tool_name'] == 'Bash'
+      end
+
+      def command_of(data)
+        data.dig('tool_input', 'command').to_s
+      end
+
       def targets(data)
-        return [] unless data['tool_name'] == 'Bash'
+        return [] unless bash?(data)
 
-        command = data.dig('tool_input', 'command').to_s
-        CommandParser.new(data['cwd'] || Dir.pwd).targets(command)
+        CommandParser.new(data['cwd'] || Dir.pwd).targets(command_of(data))
       end
 
       # One snapshot per directory, covering every command run there
@@ -93,11 +116,8 @@ module Gitflash
         end
       end
 
-      def output(saved)
-        notes = saved.map { |target, snap| "snapshot #{snap.id} before `#{target.command}`" }
-        context = "gitflash saved #{notes.join('; ')}. If this discards work that was still " \
-                  "needed, restore it with `gitflash undo #{saved.last[1].id}` " \
-                  '(list snapshots with `gitflash snapshots`).'
+      def output(saved, targets)
+        context = saved.empty? ? Messages.unsaved(targets) : Messages.saved(saved)
         specific = { hookEventName: EVENT, additionalContext: context }
         if @mode == 'ask'
           specific[:permissionDecision] = 'ask'
@@ -108,12 +128,8 @@ module Gitflash
       end
 
       def deny(targets)
-        commands = targets.map { |target| "`#{target.command}`" }.join(', ')
-        reason = "gitflash blocked #{commands}: it can discard work git cannot restore. " \
-                 'Use the gitflash equivalent (gitflash reset, gitflash delete, ...), which ' \
-                 'saves a snapshot first, or run `gitflash snapshot` before retrying.'
         { hookSpecificOutput: { hookEventName: EVENT, permissionDecision: 'deny',
-                                permissionDecisionReason: reason } }
+                                permissionDecisionReason: Messages.denial(targets) } }
       end
 
       # Stripped stdout of a git command, or nil when it fails

data/lib/gitflash/hook/command_parser.rb

@@ -17,6 +17,8 @@ module Gitflash
       Target = Data.define(:dir, :command, :scope, :branches)
 
       PREFIXES = %w[sudo command exec time nohup env].freeze
+      SHELLS = %w[bash sh zsh dash ksh].freeze
+      MAX_NESTING = 3
       OPTIONS_WITH_VALUE = %w[-c --git-dir --work-tree --namespace --exec-path --config-env].freeze
 
       def initialize(cwd)
@@ -48,20 +50,36 @@ module Gitflash
       # subcommand and its arguments
       GitCommand = Data.define(:dir, :command, :subcommand, :args)
 
-      def git_commands(command_line)
-        dir = @cwd
-        segments(command_line).filter_map do |segment|
+      def git_commands(command_line, dir = @cwd, depth = 0)
+        segments(command_line).flat_map do |segment|
           words = words(segment)
-          next if words.empty?
+          next [] if words.empty?
 
           if words.first == 'cd'
             dir = File.expand_path(words[1] || Dir.home, dir)
-            next
+            next []
           end
-          git_command(words, dir, segment.strip) if File.basename(words.first) == 'git'
+          commands_in(words, dir, segment.strip, depth)
         end
       end
 
+      # The git command of one segment, or the ones inside `bash -c "..."` and `eval "..."`
+      def commands_in(words, dir, segment, depth)
+        return [git_command(words, dir, segment)] if File.basename(words.first) == 'git'
+
+        script = nested_script(words)
+        script && depth < MAX_NESTING ? git_commands(script, dir, depth + 1) : []
+      end
+
+      # The script text passed to a shell (`bash -c`, `sh -lc`) or to `eval`
+      def nested_script(words)
+        return words.drop(1).join(' ') if words.first == 'eval'
+        return nil unless SHELLS.include?(File.basename(words.first))
+
+        index = words.index { |word| word.match?(/\A-[a-z]*c[a-z]*\z/) }
+        index && words[index + 1]
+      end
+
       # Splits on unquoted ; & | and newlines
       def segments(line)
         parts = [+'']

data/lib/gitflash/hook/messages.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Gitflash
+  module Hook
+    # What the PreToolUse hook tells Claude about a risky command
+    module Messages
+      module_function
+
+      def saved(saved)
+        notes = saved.map { |target, snap| "snapshot #{snap.id} before `#{target.command}`" }
+        "gitflash saved #{notes.join('; ')}. If this discards work that was still needed, " \
+          "restore it with #{undo_commands(saved)} (list snapshots with `gitflash snapshots`)."
+      end
+
+      # One command per snapshot: with several directories each snapshot belongs to its own
+      def undo_commands(saved)
+        return "`gitflash undo #{saved.first[1].id}`" if saved.size == 1
+
+        saved.map { |target, snap| "`gitflash undo #{snap.id}` (run in #{target.dir})" }.join(', ')
+      end
+
+      def unsaved(targets)
+        "gitflash could not save a snapshot before #{commands(targets)} (the directory is not a " \
+          'git work tree or does not exist), so nothing can be restored with `gitflash undo`.'
+      end
+
+      def denial(targets)
+        "gitflash blocked #{commands(targets)}: it can discard work git cannot restore. " \
+          'Use the gitflash equivalent (gitflash reset, gitflash delete, ...), which ' \
+          'saves a snapshot first, or run `gitflash snapshot` before retrying.'
+      end
+
+      def commands(targets)
+        targets.map { |target| "`#{target.command}`" }.join(', ')
+      end
+    end
+  end
+end

data/lib/gitflash/hook/rules.rb

@@ -41,9 +41,9 @@ module Gitflash
       def clean(args, _dir)
         flags = args.select { |arg| arg.start_with?('-') }
         short = short_flags(args)
-        force = flags.include?('--force') || short.include?('f')
-        dry_run = any?(flags, %w[--dry-run --interactive]) || short.match?(/[ni]/)
-        force && !dry_run ? { scope: %w[worktree] } : nil
+        removes = any?(flags, %w[--force --interactive]) || short.match?(/[fi]/)
+        dry_run = flags.include?('--dry-run') || short.include?('n')
+        removes && !dry_run ? { scope: %w[worktree] } : nil
       end
 
       def switch(args, _dir)
@@ -59,7 +59,9 @@ module Gitflash
       end
 
       def branch(args, _dir)
-        return nil unless any?(args, %w[-d -D --delete -f --force -m -M --move -C --copy])
+        changes = any?(args, %w[--delete --force --move --copy]) ||
+                  short_flags(args).match?(/[dDfmMcC]/)
+        return nil unless changes
 
         { scope: %w[branches], branches: args.reject { |arg| arg.start_with?('-') } }
       end

data/lib/gitflash/hook_cli.rb

@@ -14,8 +14,12 @@ module Gitflash
       true
     end
 
+    TERMINAL_NOTE = 'gitflash hook claude is run by Claude Code, not by hand. Use ' \
+                    '`gitflash hook install` to set it up and `gitflash hook status` to check it.'
+
     desc 'claude',
-         'Run as a Claude Code hook (PreToolUse and PostToolUse; reads the input on stdin)'
+         'Run as a Claude Code hook (PreToolUse and PostToolUse; reads the input on stdin)',
+         hide: true
     long_desc <<~TEXT
       Reads the Claude Code hook input on stdin. When the Bash command can discard work git
       cannot restore (for example reset --hard, clean -f, checkout -- ., branch -D, stash drop),
@@ -29,10 +33,13 @@ module Gitflash
       branch NAME, worktree add) as agent work, so `gitflash clean --agent` can find them. A branch
       is only marked when it is new (its reflog says it was created a moment ago) and unmarked.
 
-      Errors never block the command: they are printed to stderr and the hook exits with 0.
+      Not meant to be run by hand: in a terminal it only prints a note. Errors never block the
+      command: they are printed to stderr and the hook exits with 0.
     TEXT
     option :mode, type: :string, default: 'snapshot', enum: Hook::Claude::MODES
     def claude
+      return puts(TERMINAL_NOTE) if $stdin.tty?
+
       output = Hook::Claude.new(mode: options[:mode]).call($stdin.read)
       puts JSON.generate(output) if output
     rescue StandardError => e

data/lib/gitflash/repo.rb

@@ -39,12 +39,13 @@ module Gitflash
     end
 
     def toplevel
-      @bash.exec('git', 'rev-parse', '--show-toplevel').strip
+      @bash.exec('git', 'rev-parse', '--show-toplevel').delete_suffix("\n")
     end
 
     # Root of the main checkout; differs from toplevel inside a linked worktree
     def main_root
-      common = @bash.exec('git', 'rev-parse', '--path-format=absolute', '--git-common-dir').strip
+      common = @bash.exec('git', 'rev-parse', '--path-format=absolute',
+                          '--git-common-dir').delete_suffix("\n")
       File.basename(common) == '.git' ? File.dirname(common) : toplevel
     end
 

data/lib/gitflash/state_capture.rb

@@ -48,13 +48,15 @@ module Gitflash
     private
 
     def git(*, env: {})
-      @bash.exec('git', *, env: env).strip
+      # Only git's final newline goes: a path may start or end with whitespace, even a carriage
+      # return, which `chomp` would take together with the newline
+      @bash.exec('git', *, env: env).delete_suffix("\n")
     end
 
     # Stripped stdout, or nil when the command fails
     def try(*)
       stdout, _stderr, success = @bash.capture('git', *)
-      success ? stdout.strip : nil
+      success ? stdout.delete_suffix("\n") : nil
     end
 
     def rev(ref)
@@ -122,7 +124,10 @@ module Gitflash
       sizes = file_sizes(top, paths)
       small, large = sizes.partition { |_path, size| size <= MAX_UNTRACKED_FILE_BYTES }
                           .map { |group| group.map(&:first) }
-      small.each_slice(ADD_BATCH_SIZE) { |batch| git('-C', top, 'add', '--', *batch, env: env) }
+      # File names are literal paths, never pathspec magic such as `:(exclude)*`
+      small.each_slice(ADD_BATCH_SIZE) do |batch|
+        git('--literal-pathspecs', '-C', top, 'add', '--', *batch, env: env)
+      end
       large
     end
   end

data/lib/gitflash/terminal_text.rb

@@ -15,5 +15,14 @@ module Gitflash
         format(char.ord > 0xFF ? '\\u%04X' : '\\x%02X', char.ord)
       end
     end
+
+    # Text that must stay on one line, such as a path inside a bullet list: as `safe`, and a
+    # newline or tab in it is shown as an escape too, so it cannot start a fake row. A literal
+    # backslash is doubled first, so two different texts never look the same (a real newline
+    # shows as `\n`, the two characters backslash and n as `\\n`); that keeps menu labels unique.
+    def line(text)
+      doubled = text.to_s.scrub.gsub('\\') { '\\\\' }
+      safe(doubled).gsub("\n") { '\\n' }.gsub("\t") { '\\t' }
+    end
   end
 end

data/lib/gitflash/ui.rb

@@ -69,7 +69,7 @@ module Gitflash
       message = "#{summary}\nRe-run with --yes to confirm."
       raise ConfirmationRequired.new(message, plan: plan) unless interactive?
 
-      prompt.proceed_with_warning(summary) { true } == true
+      prompt.proceed_with_warning(TerminalText.safe(summary)) { true } == true
     end
 
     private

data/lib/gitflash/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gitflash
-  VERSION = '0.7.0.beta1'
+  VERSION = '0.7.0.beta2'
 end

data/lib/gitflash/worktree.rb

@@ -17,16 +17,16 @@ module Gitflash
     # Why this worktree must not be removed, nil when it can go. `current` is true for the
     # worktree gitflash runs in. The main checkout and the current one are never removable.
     def removal_blocker(force:, current:)
-      return "#{path} is the main checkout" if main?
-      return "#{path} is the current worktree" if current
+      return "#{TerminalText.line(path)} is the main checkout" if main?
+      return "#{TerminalText.line(path)} is the current worktree" if current
 
       in_use_blocker unless force || (missing? && !locked?)
     end
 
     def in_use_blocker
-      return "#{path} is locked (use --force)" if locked?
+      return "#{TerminalText.line(path)} is locked (use --force)" if locked?
 
-      "#{path} has uncommitted changes (use --force)" if dirty? != false
+      "#{TerminalText.line(path)} has uncommitted changes (use --force)" if dirty? != false
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitflash
 version: !ruby/object:Gem::Version
-  version: 0.7.0.beta1
+  version: 0.7.0.beta2
 platform: ruby
 authors:
 - Kleanthis Mitsioulis
@@ -75,6 +75,7 @@ files:
 - lib/gitflash.rb
 - lib/gitflash/branch.rb
 - lib/gitflash/cherry_pick.rb
+- lib/gitflash/cherry_pick/log_parser.rb
 - lib/gitflash/cleanup.rb
 - lib/gitflash/cli.rb
 - lib/gitflash/command_runner.rb
@@ -118,6 +119,7 @@ files:
 - lib/gitflash/hook/claude.rb
 - lib/gitflash/hook/command_parser.rb
 - lib/gitflash/hook/creations.rb
+- lib/gitflash/hook/messages.rb
 - lib/gitflash/hook/rules.rb
 - lib/gitflash/hook/settings.rb
 - lib/gitflash/hook_cli.rb