ace-git-worktree 0.27.0 → 0.27.3

data/README.md

@@ -14,6 +14,10 @@
 
 > Works with: Claude Code, Codex CLI, OpenCode, Gemini CLI, pi-agent, and more.
 
+> **State owner:** `.ace-wt/` -- one worktree per project task, owning only the
+> Git checkout and branch. Task metadata stays in `.ace-tasks/`; assignment
+> plans stay in `.ace-local/assign/`. See [docs/lab-flow.md](../docs/lab-flow.md).
+
 [Getting Started](docs/getting-started.md) | [Usage Guide](docs/usage.md) | [Handbook - Skills, Agents, Templates](docs/handbook.md)
 
 ![ace-git-worktree demo](docs/demo/ace-git-worktree-getting-started.gif)
@@ -36,6 +40,9 @@
 
 **Orchestrate parallel task work with ace-overseer** - pair with [ace-overseer](../ace-overseer) to spin up worktrees per task, drive agents in parallel, and prune finished worktrees automatically.
 
+> **Planned (L6):** the private overseer queue that hands one worktree between
+> worker, reviewer, and integrator -- not available yet.
+
 ## Testing Contract
 
 Run package tests with the restarted deterministic + scenario split:

data/docs/usage.md

@@ -74,6 +74,11 @@ Created task worktree and branch for 081
 
 **Next steps:** Run `cd "$(ace-git-worktree switch 081)"` to move into the new worktree.
 
+Worktree creation is role- and folder-name-agnostic: it does not inspect
+`.gitignore` and does not classify management tasks. If a requested worktree
+does not contain the named task, the executor reports the missing task;
+preparing a correct delegation is the requester's responsibility.
+
 ### Scenario 2: Review a Pull Request in Its Own Worktree
 
 **Goal:** Create a dedicated workspace for PR review or patching, on any
@@ -292,21 +297,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 +329,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 +348,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/atoms/task_id_extractor.rb

@@ -15,13 +15,24 @@ module Ace
         #   TaskIDExtractor.extract({id: "v.0.9.0+task.121"})    # => "121"
         #   TaskIDExtractor.extract({id: "v.0.9.0+ace-t.121.01"}) # => "121.01"
         #   TaskIDExtractor.extract({id: "v.0.9.0+t.121"})       # => "121"
+        #   TaskIDExtractor.extract({id: "8xh.t.ddd.0.0"})      # => "ddd.0.0"
         #
         # @example Normalize a task reference string
         #   TaskIDExtractor.normalize("v.0.9.0+task.121.01") # => "121.01"
         #   TaskIDExtractor.normalize("task.121")       # => "121"
         #   TaskIDExtractor.normalize("ace-t.121")      # => "121"
         #   TaskIDExtractor.normalize("121.01")         # => "121.01"
+        #   TaskIDExtractor.normalize("8xh.t.ddd.0.0")  # => "ddd.0.0"
         class TaskIDExtractor
+          # B36TS full id with an arbitrary chain of subtask segments:
+          # "8xh.t.ddd" -> "ddd", "8xh.t.ddd.0" -> "ddd.0",
+          # "8xh.t.ddd.0.0" -> "ddd.0.0". Every task/subtask segment is
+          # preserved so the derived branch/worktree name is deterministic
+          # and reversible (the segment chain maps 1:1 onto the id).
+          B36TS_FULL_ID = /\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3}(?:\.[0-9a-z]+)*)\z/
+          # Short form of the same chain, optionally inside a longer path
+          # (matched at the end): "t.ddd.0.0", "task.hy4", "/x/ace-task.121/".
+          SHORT_TASK_ID = /(?:ace-)?(?:task|t)\.([0-9a-z]{3}(?:\.[0-9a-z]+)*)\/?\z/
           # Extract task ID from task data hash
           #
           # @param task_data [Hash] Task data with :id and/or :task_number
@@ -31,8 +42,9 @@ module Ace
 
             # Regex with subtask support
             if task_data[:id]
-              # B36TS full ID: "8pp.t.hy4" -> "hy4", or subtask "8pp.t.hy4.a" -> "hy4.a"
-              if match = task_data[:id].match(/\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3}(?:\.[a-z0-9])?)\z/)
+              # B36TS full ID: "8pp.t.hy4" -> "hy4", subtasks keep every
+              # segment: "8pp.t.hy4.a" -> "hy4.a", "8xh.t.ddd.0.0" -> "ddd.0.0"
+              if (match = task_data[:id].match(B36TS_FULL_ID))
                 return match[1]
               end
               # Try subtask pattern first (e.g., "v.0.9.0+task.121.01" -> "121.01")
@@ -55,18 +67,17 @@ module Ace
 
           # Derive the short form of a full Base36 task id.
           #
-          # The short form is the three-character suffix plus an optional
-          # subtask segment (numeric or single character).
+          # The short form is the three-character suffix plus the complete
+          # subtask segment chain (each segment numeric or alphanumeric,
+          # any depth): "8xh.t.ddd.0.0" -> "ddd.0.0".
           #
           # @param full_id [String, nil] formatted task id (e.g. "8xg.t.k9y",
-          #   "8wr.t.qk0.3")
-          # @return [String, nil] short id (e.g. "k9y", "qk0.3") or nil when the
-          #   argument is not a full task id
+          #   "8wr.t.qk0.3", "8xh.t.ddd.0.0")
+          # @return [String, nil] short id (e.g. "k9y", "qk0.3", "ddd.0.0")
+          #   or nil when the argument is not a full task id
           def self.short_id(full_id)
-            match = full_id.to_s.strip.match(/\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3})(?:\.([0-9a-z]+))?\z/)
-            return nil unless match
-
-            match[2] ? "#{match[1]}.#{match[2]}" : match[1]
+            match = full_id.to_s.strip.match(B36TS_FULL_ID)
+            match && match[1]
           end
 
           # Normalize a task reference string to simple ID format
@@ -78,8 +89,9 @@ module Ace
             return nil if ref.empty?
 
             # Regex patterns for recognized ACE task ID formats
-            # B36TS full ID: "8pp.t.hy4" -> "hy4", or subtask "8pp.t.hy4.a" -> "hy4.a"
-            if match = ref.match(/\A[0-9a-z]{3}\.[a-z]\.([0-9a-z]{3}(?:\.[0-9a-z]+)?)\z/)
+            # B36TS full ID: "8pp.t.hy4" -> "hy4", subtasks keep every
+            # segment: "8pp.t.hy4.a" -> "hy4.a", "8xh.t.ddd.0.0" -> "ddd.0.0"
+            if (match = ref.match(B36TS_FULL_ID))
               match[1]
             # B36TS short ref: exactly 3 lowercase alphanumeric chars (e.g., "hy4")
             elsif match = ref.match(/\A([0-9a-z]{3})\z/)
@@ -88,11 +100,14 @@ module Ace
             # Try hierarchical pattern first (e.g., "121.01", "task.121.01")
             elsif match = ref.match(/(\d{3})\.(\d{2})(?:\b|$)/)
               "#{match[1]}.#{match[2]}"
-            # B36TS short ref with subtask segment (e.g., "qk0.3", "hy4.a")
-            elsif match = ref.match(/\A([0-9a-z]{3})\.([0-9a-z]+)\z/)
-              "#{match[1]}.#{match[2]}"
-            # Try ace-task/ace-t or task/t directory at end of path (e.g., "ace-task.hy4", "/path/to/task.121")
-            elsif match = ref.match(/(?:ace-)?(?:task|t)\.([0-9a-z]{3})\/?$/)
+            # B36TS short ref with the whole subtask segment chain
+            # (e.g., "qk0.3", "hy4.a", "ddd.0.0")
+            elsif match = ref.match(/\A([0-9a-z]{3}(?:\.[0-9a-z]+)*)\z/)
+              match[1]
+            # Try task./t. (or ace-task./ace-t.) prefix, keeping the whole
+            # subtask segment chain (e.g. "t.ddd.0.0", "task.hy4.a",
+            # "/path/to/task.121", "ace-task.hy4/")
+            elsif (match = ref.match(SHORT_TASK_ID))
               match[1]
             # Try task./t. prefix in middle of path (e.g., ".cache/test/task.121")
             # Use negative lookbehind to skip ace-task.XXX / ace-t.XXX parent directories

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/organisms/worktree_manager.rb

@@ -272,8 +272,8 @@ module Ace
           #   result = manager.list_all
           #   result = manager.list_all(format: :json)
           #
-          # Programmatic inventory for internal consumers (overseer, prune,
-          # switch/remove hints). The user-facing enriched table is rendered by
+          # Programmatic inventory for internal consumers (prune, switch/remove
+          # hints). The user-facing enriched table is rendered by
           # {WorktreeListReport}, not here.
           #
           # @option options [Symbol] :format Optional formatting (:simple, :json)

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

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-git-worktree
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.27.3
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-17 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli