ace-git-worktree 0.27.0 → 0.27.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cc9f7055655e28b11fd7caa92051817825c8487316237972859985aca1d2478
-  data.tar.gz: dba29a6ffef411ec95e890d6521aca30385f823bb3bb52827bad86a4fe8fd6ba
+  metadata.gz: 3fbcf3673de821e4ed42fd7415a7cc0fa88fca4176d2d3cfbf7cff65e6d50332
+  data.tar.gz: ec88eedd7b9f6d3822835b70777e235a5581cacf3a413a98ee4a4bdd66eb5ae1
 SHA512:
-  metadata.gz: 776ccc9af30e1dc2027d9a27933eefe6589e33c4e4ab3a23a11d3d3e37ef238a1e360480d1ac60739438277e37bf8c27586438588bd6efcc39a7e22010558606
-  data.tar.gz: 633565bd32222e69ba61d521a3f7d110f28a197c6f7790061eeb131acf5bd714cd302c5ae5558adfb03d7880daf6db8eb5ef2a02d02da4eb9a099e3120bdfea3
+  metadata.gz: 8e3038cf6f5465be9074866bd6c174da7c79839fa94eb0e6abc902ea1f7300dc4fb511e6132a55841e92de594b0b9c89f9a8401de08020a37f7ae0baec512bf0
+  data.tar.gz: 73ee36beff2acc5bcda6d456db1715b95b3dc580193ce07acaab7e9ec89a591674756a456036d179b2ee30b4f054bd5a2d007e99c24b7f54e2b9f6423fac503a

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.27.1] - 2026-10-18
+
+### Changed
+
+- `list` table rows now print the full, never-truncated worktree path on its
+  own line under the row (indented to the `Commit` column) followed by a blank
+  separator line, replacing the truncated `Path` column. Every displayed path
+  is directly usable (`cd`, copy/paste); `--full` prints absolute paths.
+- `Changes` counts staged + unstaged + untracked files under `.ace-tasks/`;
+  untracked files outside the task tree are no longer scanned or counted.
+
+### Fixed
+
+- Large-repository listing performance: the deep untracked walk
+  (`--untracked-files=all`) dominated runtime and degraded further under
+  parallel probing (88 worktrees: ~18s). Probes now read tracked-only status
+  and run the deep `.ace-tasks/` untracked scan as a selective second round
+  for worktrees the cheap association tiers cannot resolve (~7s).
+- Task index lookups no longer re-`realpath` every task directory on every
+  lookup; canonical paths are resolved once per index.
+
 ## [0.27.0] - 2026-10-17
 
 ### Added

data/docs/usage.md

@@ -292,21 +292,29 @@ association is always inferred.
 
 ```text
 Active worktrees (last 18h) -- 3 of 88:
-Task   Branch                       Age  Commit                    Changes  PR           Path
-----------------------------------------------------------------------------------------------
-k9y    codex/r3-bounded-convergence  17h  feat(review): define bo…        2  #142 draft   …/codex-r3-bounded-convergence
--      codex/ei9-campaign-join        8m  feat(ace-assign): compl…        -  -            …/ei9-campaign-composition-join
+Task   Branch                       Age  Commit                    Changes  PR
+---------------------------------------------------------------------------------------
+k9y    codex/r3-bounded-convergence  17h  feat(review): define bo…        2  #142 draft
+                                         ~/Ps/ace/.ace-wt/codex-r3-bounded-convergence
+
+-      codex/ei9-campaign-join        8m  feat(ace-assign): compl…        -  -
+                                         ~/Ps/ace/.ace-wt/ei9-campaign-composition-join
 
 Inactive: 85  (use --full to list all)
 Task-associated: 14    Usable: 71    Recent branches without worktrees: 4
 ```
 
+Each worktree renders as three lines: the aligned columns, the
+never-truncated path (indented to the `Commit` column, `$HOME` shortened to
+`~` in compact mode, absolute with `--full`), and a blank separator line, so
+every displayed path is directly usable (`cd`, copy/paste).
+
 **Activity:** a worktree is active when the last commit reachable from its
-checked-out HEAD is inside the window **or** it has uncommitted changes (staged,
-unstaged, or untracked). Bare worktrees are never active. Filters apply before
-the active/inactive split, so the header and footer counts always describe the
-filtered set. `Recent branches without worktrees` is branch-based and is not
-affected by worktree filters.
+checked-out HEAD is inside the window **or** it has uncommitted changes
+(staged, unstaged, or untracked under `.ace-tasks/`). Bare worktrees are never
+active. Filters apply before the active/inactive split, so the header and
+footer counts always describe the filtered set. `Recent branches without
+worktrees` is branch-based and is not affected by worktree filters.
 
 **Columns:**
 
@@ -316,11 +324,11 @@ affected by worktree filters.
 * `Age` - last commit age in one unit (`8m`, `3h`, `9d`, `3w`, `2mo`, `1y`);
   `never` when the branch has no commits; future timestamps render `0m`.
 * `Commit` - last commit subject, right-truncated with `…`.
-* `Changes` - uncommitted file count (staged + unstaged + untracked); `-` when
-  clean.
+* `Changes` - uncommitted file count (staged + unstaged + untracked files
+  under `.ace-tasks/`); `-` when clean. Untracked files outside the task tree
+  are not scanned: the deep untracked walk dominates listing time on large
+  repositories, and stray artifacts are not an activity signal.
 * `PR` - `#N` (open), `#N draft`, `#N merged`, `#N closed`, or `-`.
-* `Path` - `$HOME` shortened to `~` and left-elided in compact mode; absolute
-  and untruncated with `--full`.
 
 **Task association (name-independent), in precedence order:**
 
@@ -335,15 +343,19 @@ affected by worktree filters.
 name, then by HEAD commit sha, then by a unique task reference in the PR
 title/body. Unconfigured/offline forges render `-` and never fail the command.
 
-**Width behavior:** the table targets `120` columns, shrinks `Path`, then
-`Commit`, then `Branch` down to their minimums, and drops `Path` (then `Commit`)
-on very narrow terminals. Width comes from `COLUMNS`, else the terminal size,
-else `120`. `--full` is exempt from truncation.
-
-**Probe isolation:** each worktree is probed in its own forked child process
-(one child per worktree, at most 16 alive, hard 5 second budget per probe).
-Probe results are ordered by `git worktree list` order, so output is
-deterministic; a failed or timed-out probe renders `?` in `Age`/`Commit`/
+**Width behavior:** the table targets `120` columns, shrinks `Commit`, then
+`Branch` down to their minimums, and drops `Commit` on very narrow terminals.
+Width comes from `COLUMNS`, else the terminal size, else `120`. Path lines are
+never truncated; `--full` is exempt from truncation entirely.
+
+**Probe isolation and performance:** each worktree is probed in its own forked
+child process (one child per worktree, at most 16 alive, hard 5 second budget
+per probe). The probe reads only cheap signals: HEAD metadata, tracked changes
+(`git status --untracked-files=no`), committed task-file diffs, and the
+`_current` symlink. The expensive deep untracked scan of `.ace-tasks/` runs as
+a selective second round, only for worktrees the cheap association tiers could
+not resolve. Probe results are ordered by `git worktree list` order, so output
+is deterministic; a failed or timed-out probe renders `?` in `Age`/`Commit`/
 `Changes` while the rest of the table renders and the command exits 0. Where
 `fork` is unavailable, probes run sequentially with the same timeouts.
 

data/lib/ace/git/worktree/models/task_index.rb

@@ -36,6 +36,8 @@ module Ace
             @entries = entries.freeze
             @available = available
             @project_root = project_root
+            @canonical_directories = {}
+            @canonical_worktree_paths = {}
           end
 
           attr_reader :entries, :project_root
@@ -92,7 +94,7 @@ module Ace
 
             expanded = canonical_path(path)
             @entries.find do |entry|
-              entry.worktree_path && canonical_path(entry.worktree_path) == expanded
+              entry.worktree_path && canonical_worktree_path(entry) == expanded
             end
           end
 
@@ -114,7 +116,7 @@ module Ace
             return nil if directory.to_s.empty?
 
             expanded = canonical_path(directory)
-            @entries.find { |entry| canonical_path(entry.directory) == expanded }
+            @entries.find { |entry| canonical_directory(entry) == expanded }
           end
 
           # Map changed file paths to task candidates.
@@ -146,11 +148,24 @@ module Ace
           # under the task directory, including nested spec/artifact folders).
           def find_by_enclosing_directory(absolute_path)
             @entries.find do |entry|
-              directory = canonical_path(entry.directory)
+              directory = canonical_directory(entry)
               absolute_path == directory || absolute_path.start_with?("#{directory}/")
             end
           end
 
+          # Canonical forms are compared on every lookup; resolve each entry's
+          # directory / recorded worktree path exactly once (realpath is a
+          # syscall per path component and dominates lookup time otherwise).
+          def canonical_directory(entry)
+            @canonical_directories.fetch(entry) { @canonical_directories[entry] = canonical_path(entry.directory) }
+          end
+
+          def canonical_worktree_path(entry)
+            @canonical_worktree_paths.fetch(entry) do
+              @canonical_worktree_paths[entry] = entry.worktree_path ? canonical_path(entry.worktree_path) : nil
+            end
+          end
+
           # Canonical comparison form for paths that may be reached through a
           # symlinked root (e.g. macOS /var -> /private/var).
           def canonical_path(value)

data/lib/ace/git/worktree/molecules/worktree_probe.rb

@@ -86,6 +86,24 @@ module Ace
             File.expand_path(value)
           end
 
+          # Deep-scan fallback for the task tree only: untracked files under
+          # `.ace-tasks/`. This walk is expensive on large trees, so the probe
+          # itself never performs it; callers run it selectively (second round)
+          # for worktrees the cheap association tiers could not resolve.
+          #
+          # @param path [String] worktree directory
+          # @return [Array<String>] repo-relative untracked task paths
+          def untracked_task_files(path)
+            return [] unless path && File.directory?(path)
+
+            output = git(path, "ls-files", "--others", "--exclude-standard", "--", TASK_TREE_PREFIX)
+            return [] if output.nil?
+
+            output.lines.map { |line| scrub(line.chomp) }.reject(&:empty?).select { |p| task_tree_path?(p) }
+          rescue StandardError
+            []
+          end
+
           private
 
           # @return [Hash, nil] `{sha:, committer_epoch:, subject:}` for HEAD
@@ -101,9 +119,11 @@ module Ace
             nil
           end
 
-          # @return [Hash, nil] staged/unstaged/untracked counts and changed paths
+          # @return [Hash, nil] staged/unstaged counts and changed paths
+          # (tracked files only; untracked discovery is opt-in via
+          # {#untracked_task_files})
           def status_snapshot(path)
-            output = git(path, "status", "--porcelain=v1", "-z", "--untracked-files=all")
+            output = git(path, "status", "--porcelain=v1", "-z", "--untracked-files=no")
             return nil if output.nil?
 
             staged = 0

data/lib/ace/git/worktree/molecules/worktree_table_formatter.rb

@@ -11,13 +11,18 @@ module Ace
       module Molecules
         # Renders the width-aware listing table.
         #
+        # Each worktree renders as three lines: the aligned columns
+        # (Task/Branch/Age/Commit/Changes/PR), the never-truncated path
+        # indented to the Commit column, and a blank separator line, so each
+        # entry is visually grouped and the displayed path is always directly
+        # usable (copy/paste, cd).
+        #
         # Layout targets (two-space gutters): Task = max(task cells, 4),
-        # Branch 25 (min 12), Age 5, Commit 24 (min 10), Changes 7, PR 11,
-        # Path 32 (min 10). When the target total exceeds the detected width,
-        # columns shrink in priority order Path -> Commit -> Branch down to
-        # their minima, then Path is dropped, then Commit. Compact output never
-        # exceeds the detected width; `--full` prints untruncated absolute paths
-        # and is exempt from width limits.
+        # Branch 25 (min 12), Age 5, Commit 24 (min 10), Changes 7, PR 11.
+        # When the target total exceeds the detected width, columns shrink in
+        # priority order Commit -> Branch down to their minima, then Commit is
+        # dropped. Column lines never exceed the detected width; `--full`
+        # prints absolute paths and is exempt from width limits.
         class WorktreeTableFormatter
           GUTTER = "  "
           COLUMNS_MIN_WIDTH = 40
@@ -30,12 +35,11 @@ module Ace
           COMMIT_MIN = 10
           CHANGES_WIDTH = 7
           PR_WIDTH = 11
-          PATH_TARGET = 32
-          PATH_MIN = 10
           TASK_MIN = 4
+          PATH_INDENT = "  "
 
           # @param width [Integer] detected terminal width
-          # @param full [Boolean] exhaustive listing (no truncation)
+          # @param full [Boolean] exhaustive listing (absolute paths)
           # @param env [Hash] environment (HOME shortening, COLUMNS detection)
           def initialize(width: nil, full: false, env: ENV, stdout: $stdout)
             @width = width || self.class.detected_width(env: env, stdout: stdout)
@@ -65,75 +69,66 @@ module Ace
             DEFAULT_WIDTH
           end
 
-          # Render header + separator + rows.
+          # Render header + separator + three lines per worktree (columns,
+          # indented full path, blank separator).
           #
           # @param worktrees [Array<Models::WorktreeInfo>]
           # @return [Array<String>] output lines
           def render(worktrees)
             rows = Array(worktrees)
             layout = compute_layout(rows)
-            [header_line(layout), separator_line(layout), *rows.map { |worktree| row_line(worktree, layout) }]
+            [
+              header_line(layout),
+              separator_line(layout),
+              *rows.flat_map { |worktree| [row_line(worktree, layout), path_line(worktree, layout), ""] }
+            ]
           end
 
           private
 
-          Layout = Struct.new(:task, :branch, :age, :commit, :changes, :pr, :path, :total_width,
+          Layout = Struct.new(:task, :branch, :age, :commit, :changes, :pr, :total_width,
             keyword_init: true)
 
           def compute_layout(worktrees)
             task_width = [TASK_MIN, *worktrees.map { |wt| task_cell(wt).length }].max
             branch_width = BRANCH_TARGET
             commit_width = COMMIT_TARGET
-            path_width = PATH_TARGET
-
-            if @full
-              path_width = [PATH_TARGET, *worktrees.map { |wt| full_path(wt).length }].max
-              return build_layout(task_width, branch_width, commit_width, path_width)
-            end
 
-            while total_width(task_width, branch_width, commit_width, path_width) > @width
-              if path_width > PATH_MIN
-                path_width -= 1
-              elsif commit_width > COMMIT_MIN
-                commit_width -= 1
-              elsif branch_width > BRANCH_MIN
-                branch_width -= 1
-              else
-                break
+            unless @full
+              while total_width(task_width, branch_width, commit_width) > @width
+                if commit_width > COMMIT_MIN
+                  commit_width -= 1
+                elsif branch_width > BRANCH_MIN
+                  branch_width -= 1
+                else
+                  break
+                end
               end
             end
 
-            layout = build_layout(task_width, branch_width, commit_width, path_width)
+            layout = build_layout(task_width, branch_width, commit_width)
             return layout if layout[:total_width] <= @width
 
-            drop_path(layout)
+            drop_commit(layout)
           end
 
-          def build_layout(task_width, branch_width, commit_width, path_width)
-            total = total_width(task_width, branch_width, commit_width, path_width)
+          def build_layout(task_width, branch_width, commit_width)
+            total = total_width(task_width, branch_width, commit_width)
             Layout.new(task: task_width, branch: branch_width, age: AGE_WIDTH, commit: commit_width,
-              changes: CHANGES_WIDTH, pr: PR_WIDTH, path: path_width, total_width: total)
+              changes: CHANGES_WIDTH, pr: PR_WIDTH, total_width: total)
           end
 
-          def total_width(task_width, branch_width, commit_width, path_width)
+          def total_width(task_width, branch_width, commit_width)
             task_width + branch_width + AGE_WIDTH + commit_width + CHANGES_WIDTH + PR_WIDTH +
-              path_width + (GUTTER.length * 6)
+              (GUTTER.length * 5)
           end
 
-          # Drop the Path column when even the minimum layout overflows; then
-          # drop Commit as the last resort.
-          def drop_path(layout)
-            without_path = Layout.new(
-              task: layout[:task], branch: layout[:branch], age: layout[:age], commit: layout[:commit],
-              changes: layout[:changes], pr: layout[:pr], path: 0,
-              total_width: layout[:total_width] - layout[:path] - GUTTER.length
-            )
-            return without_path if without_path[:total_width] <= @width
-
+          # Drop the Commit column when even the minimum layout overflows.
+          def drop_commit(layout)
             Layout.new(
-              task: without_path[:task], branch: without_path[:branch], age: without_path[:age],
-              commit: 0, changes: without_path[:changes], pr: without_path[:pr], path: 0,
-              total_width: without_path[:total_width] - without_path[:commit] - GUTTER.length
+              task: layout[:task], branch: layout[:branch], age: layout[:age],
+              commit: 0, changes: layout[:changes], pr: layout[:pr],
+              total_width: layout[:total_width] - layout[:commit] - GUTTER.length
             )
           end
 
@@ -145,7 +140,6 @@ module Ace
             cells << pad("Commit", layout[:commit], :left) if layout[:commit].positive?
             cells << pad("Changes", layout[:changes], :right)
             cells << pad("PR", layout[:pr], :left)
-            cells << pad("Path", layout[:path], :left) if layout[:path].positive?
             cells.join(GUTTER).rstrip
           end
 
@@ -161,10 +155,28 @@ module Ace
             cells << pad(commit_cell(worktree, layout[:commit]), layout[:commit], :left) if layout[:commit].positive?
             cells << pad(changes_cell(worktree), layout[:changes], :right)
             cells << pad(pr_cell(worktree), layout[:pr], :left)
-            cells << pad(path_cell(worktree, layout[:path]), layout[:path], :left) if layout[:path].positive?
             cells.join(GUTTER).rstrip
           end
 
+          # The full, never-truncated worktree path on its own line, indented
+          # to the Commit column so it reads as a continuation of the row
+          # (falls back to the Branch column, then a minimal indent).
+          def path_line(worktree, layout)
+            path = @full ? full_path(worktree) : compact_path(worktree)
+            "#{path_indent(layout)}#{path}"
+          end
+
+          def path_indent(layout)
+            if layout[:commit].positive?
+              " " * (layout[:task] + GUTTER.length + layout[:branch] + GUTTER.length +
+                layout[:age] + GUTTER.length)
+            elsif layout[:branch].positive?
+              " " * (layout[:task] + GUTTER.length)
+            else
+              PATH_INDENT
+            end
+          end
+
           # --- Cell contents ---
 
           def task_cell(worktree)
@@ -204,13 +216,6 @@ module Ace
             PrStatusResolver.cell(worktree.pr)
           end
 
-          def path_cell(worktree, width)
-            return "" if width <= 0
-
-            path = @full ? full_path(worktree) : compact_path(worktree)
-            Atoms::TextTruncator.left(path, width)
-          end
-
           def full_path(worktree)
             File.expand_path(worktree.path)
           end

data/lib/ace/git/worktree/organisms/worktree_list_report.rb

@@ -65,6 +65,7 @@ module Ace
             project_root = task_index.project_root || @project_root
 
             probes = probe_worktrees(raw_worktrees, project_root)
+            supplement_untracked_task_files(raw_worktrees, probes, project_root, task_index)
             enriched = enrich(raw_worktrees, probes, task_index, now, options)
             selected = apply_filters(enriched, options)
             active, inactive = selected.partition { |worktree| worktree.active_within_window }
@@ -111,6 +112,40 @@ module Ace
             runner.run(raw_worktrees)
           end
 
+          # Second probe round, only for worktrees the cheap association tiers
+          # (metadata, `_current` symlink, validated name, tracked task-file
+          # changes, committed task files) could not resolve. The deep
+          # `.ace-tasks/` untracked scan dominates listing time on large
+          # repositories, so it runs selectively and merges its findings back
+          # into the round-one payloads (counts + changed task paths) before
+          # enrichment classifies activity and renders.
+          def supplement_untracked_task_files(raw_worktrees, probes, project_root, task_index)
+            return unless task_index.available?
+
+            resolver = Molecules::TaskAssociationResolver.new(task_index: task_index)
+            unresolved = raw_worktrees.each_index.select do |index|
+              probe = probes[index]
+              probe && resolver.resolve(raw_worktrees[index], probe).task_id.nil?
+            end
+            return if unresolved.empty?
+
+            probe_molecule = Molecules::WorktreeProbe.new(project_root: project_root)
+            supplement = ->(worktree) { {untracked_task_files: probe_molecule.untracked_task_files(worktree.path)} }
+            runner = WorktreeProbeRunner.new(project_root: project_root, probe: supplement)
+            payloads = runner.run(unresolved.map { |index| raw_worktrees[index] })
+
+            unresolved.each_with_index do |probe_index, position|
+              payload = payloads[position]
+              next if payload.nil? || payload[:untracked_task_files].to_a.empty?
+
+              paths = payload[:untracked_task_files]
+              probe = probes[probe_index]
+              probe[:untracked] = probe[:untracked].to_i + paths.length
+              probe[:uncommitted_paths] = Array(probe[:uncommitted_paths]) + paths
+              probe[:changed_task_files] = Array(probe[:changed_task_files]) + paths
+            end
+          end
+
           def enrich(raw_worktrees, probes, task_index, now, options)
             resolver = Molecules::TaskAssociationResolver.new(task_index: task_index)
             pr_resolver = @pr_resolver || Molecules::PrStatusResolver.new
@@ -252,14 +287,17 @@ module Ace
             end
 
             rows = options[:full] ? (active + inactive) : active
+            table_ended_with_blank = false
             if rows.empty?
               lines << footer.no_active_message
             else
               lines.concat(table.render(rows))
+              table_ended_with_blank = true
             end
 
             unless options[:quiet]
-              lines << ""
+              # The table already ends each entry with a blank separator line.
+              lines << "" unless table_ended_with_blank
               lines.concat(footer.lines(
                 inactive: inactive.length,
                 task_associated: statistics[:task_associated],

data/lib/ace/git/worktree/version.rb

@@ -3,7 +3,7 @@
 module Ace
   module Git
     module Worktree
-      VERSION = "0.27.0"
+      VERSION = "0.27.1"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ace-git-worktree
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.27.1
 platform: ruby
 authors:
 - Michal Czyz