copy_directories: excludeDirs post-hoc delete wastes time cloning large excluded subtrees

[echarrod]

Summary

copy_directories in lib/copy.sh copies the full parent directory first (via _fast_copy_dir), then calls _apply_directory_excludes to rm -rf the excluded subdirectories afterwards. For large excluded subtrees this means paying the full clone + delete cost every time a worktree is created, even though the data is immediately thrown away.

Reproduction

Add a large directory to includeDirs and exclude a large subdirectory of it via excludeDirs:

[copy]
    includeDirs = .claude
    excludeDirs = .claude/worktrees

Where .claude/worktrees contains ~150,000 files / 3.1 GB (Claude Code session state).

Running git gtr new <branch> takes ~70 extra seconds per worktree:

• ~48s for cp -cRP .claude <worktree>/ (APFS clonefile still allocates per-inode metadata for 150k files)
• ~22s for rm -rf <worktree>/.claude/worktrees

Root cause

In copy_directories (line 369), is_excluded is checked against the top-level dir_path (e.g. .claude). The exclude patterns (e.g. .claude/worktrees) don't match .claude, so the full directory is cloned. _apply_directory_excludes is only called at line 381 after _fast_copy_dir has already completed.

# copy.sh, inside copy_directories:
is_excluded "$dir_path" "$excludes" && continue   # .claude doesn't match .claude/worktrees → proceeds

_fast_copy_dir "$dir_path" "$dest_parent/"        # clones ALL 3.1 GB including worktrees
_apply_directory_excludes "$dest_parent" "$dir_path" "$excludes"  # rm -rf worktrees after the fact

Expected behaviour

When excludeDirs specifies a direct child of an includeDirs directory, the excluded subtree should be skipped during the copy rather than deleted afterwards. On macOS this could be achieved with rsync --exclude or by walking one level and selectively cloning; on Linux cp --reflink=auto combined with pre-filtering would work similarly.

Workaround

Replace broad includeDirs = .parent entries with specific includeDirs and include entries for only the subdirectories/files you actually need, avoiding the large excluded subtree entirely.

[traycerai]

Warning

Ticket Assist will be discontinued on May 1, 2026. After that date, the feature will no longer be available. We suggest installing the Traycer IDE Extension for continued AI-powered, spec-driven development. Thank you for choosing Traycer!

Plan

Observations

The root cause is in copy_directories (file:lib/copy.sh, lines 386–412). When a dir_path (e.g. .claude) is found, is_excluded only checks for an exact match against the full exclude pattern (e.g. .claude/worktrees). Since .claude ≠ .claude/worktrees, the check passes and _fast_copy_dir clones the entire tree. _apply_directory_excludes then deletes the excluded subtree post-hoc — paying full copy + delete cost for data that is immediately discarded.

_apply_directory_excludes already has the logic to match pattern_prefix against dir_path and glob-expand pattern_suffix inside the copied directory; the missing piece is doing that before the copy, not after.

Approach

Introduce a helper _has_subdir_excludes that checks whether any exclude pattern is a child of a given dir_path. When such patterns exist, replace the single _fast_copy_dir call with a selective copy: enumerate the top-level entries of the source directory and _fast_copy_dir only those that are not excluded. This keeps CoW semantics for every entry that is actually needed, avoids touching the large excluded subtrees entirely, and requires no new external tools (no rsync dependency). Deeper nested excludes (e.g. a/b/c) still fall through to the existing _apply_directory_excludes path, which handles them correctly.

---

Implementation Steps

1. Add _has_subdir_excludes helper in file:lib/copy.sh

Add a new private function immediately before copy_directories. It accepts dir_path and excludes (newline-separated) and returns 0 if any exclude pattern has dir_path as its first path component (i.e. the pattern is of the form <dir_path>/<something>), 1 otherwise.

• Iterate over excludes line by line.
• For each pattern, extract pattern_prefix as ${exclude_pattern%%/*}.
• Use a case "$dir_path" in $pattern_prefix) match (same glob logic already used in _apply_directory_excludes).
• If a match is found, return 0 immediately.

2. Add _selective_copy_dir helper in file:lib/copy.sh

Add a new private function that performs a top-level-entry-by-entry copy of a source directory, skipping entries whose relative path (i.e. <dir_path>/<entry_name>) is excluded.

• Accept src_dir, dest_parent, dir_path, and excludes.
• mkdir -p "$dest_parent/$dir_path" to create the destination container.
• Use find "$src_dir" -maxdepth 1 -mindepth 1 to enumerate direct children (files and directories).
• For each child entry:
  • Compute child_rel="$dir_path/$(basename "$child")".
  • Call is_excluded "$child_rel" "$excludes" — if excluded, skip (log a message like "Skipping excluded subtree $child_rel").
  • Otherwise call _fast_copy_dir "$child" (for directories) or cp (for files) into "$dest_parent/$dir_path/".
• After the selective copy, call _apply_directory_excludes as before to handle any deeper nested excludes (e.g. a/b/c where only b/c is excluded, not b itself).

3. Modify copy_directories in file:lib/copy.sh

Inside the inner while loop (around line 406), replace the unconditional _fast_copy_dir call with a branch:

if _has_subdir_excludes "$dir_path" "$excludes"; then
    _selective_copy_dir  <src>  <dest_parent>  <dir_path>  <excludes>
else
    _fast_copy_dir "$dir_path" "$dest_parent/"
    _apply_directory_excludes "$dest_parent" "$dir_path" "$excludes"
fi

• The _selective_copy_dir path handles the case where a direct child of dir_path is excluded — it never copies the excluded subtree.
• The existing _fast_copy_dir + _apply_directory_excludes path is preserved for all other cases (no sub-excludes, or only deeper nested excludes).
• Logging (log_info "Copied directory $dir_path") and copied_count increment remain in both branches.

4. Update _apply_directory_excludes call inside _selective_copy_dir

_selective_copy_dir must still call _apply_directory_excludes "$dest_parent" "$dir_path" "$excludes" after the selective copy, so that patterns like a/b/c (where b is not a direct child exclude but c inside b is) continue to be handled correctly.

---

Data Flow After the Fix

sequenceDiagram
    participant CD as copy_directories
    participant HSE as _has_subdir_excludes
    participant SCD as _selective_copy_dir
    participant FCD as _fast_copy_dir
    participant ADE as _apply_directory_excludes

    CD->>HSE: dir_path=".claude", excludes=".claude/worktrees"
    HSE-->>CD: 0 (has sub-excludes)
    CD->>SCD: src=".claude", dest_parent, dir_path, excludes
    SCD->>SCD: find .claude -maxdepth 1 -mindepth 1
    loop each child entry
        SCD->>SCD: is_excluded ".claude/worktrees"? → skip
        SCD->>FCD: _fast_copy_dir ".claude/settings" dest/.claude/
    end
    SCD->>ADE: handle deeper nested excludes (no-op here)

Loading

5. Add tests in file:tests/copy_safety.bats

Add BATS tests covering:

Test	Scenario
_has_subdir_excludes returns true when a direct-child exclude exists	dir_path=".claude", excludes=".claude/worktrees"
_has_subdir_excludes returns false when no sub-exclude matches	dir_path=".claude", excludes="node_modules"
_selective_copy_dir copies non-excluded children	Verify sibling dirs are present in dest
_selective_copy_dir skips excluded direct child	Verify excluded dir is absent in dest without ever being created
copy_directories end-to-end: excluded subtree never appears in dest	Integration-style test with a multi-child source dir

Existing test "cmd_copy applies configured excludeDirs" in file:tests/cmd_copy.bats already validates the observable behaviour and should continue to pass unchanged.

Import In IDE

🤖 Prompt for AI Agents

## Observations

The root cause is in `copy_directories` (`file:lib/copy.sh`, lines 386–412). When a `dir_path` (e.g. `.claude`) is found, `is_excluded` only checks for an **exact** match against the full exclude pattern (e.g. `.claude/worktrees`). Since `.claude ≠ .claude/worktrees`, the check passes and `_fast_copy_dir` clones the entire tree. `_apply_directory_excludes` then deletes the excluded subtree post-hoc — paying full copy + delete cost for data that is immediately discarded.

`_apply_directory_excludes` already has the logic to match `pattern_prefix` against `dir_path` and glob-expand `pattern_suffix` inside the copied directory; the missing piece is doing that **before** the copy, not after.

## Approach

Introduce a helper `_has_subdir_excludes` that checks whether any exclude pattern is a child of a given `dir_path`. When such patterns exist, replace the single `_fast_copy_dir` call with a selective copy: enumerate the top-level entries of the source directory and `_fast_copy_dir` only those that are **not** excluded. This keeps CoW semantics for every entry that is actually needed, avoids touching the large excluded subtrees entirely, and requires no new external tools (no `rsync` dependency). Deeper nested excludes (e.g. `a/b/c`) still fall through to the existing `_apply_directory_excludes` path, which handles them correctly.

---

## Implementation Steps

### 1. Add `_has_subdir_excludes` helper in `file:lib/copy.sh`

Add a new private function immediately before `copy_directories`. It accepts `dir_path` and `excludes` (newline-separated) and returns `0` if **any** exclude pattern has `dir_path` as its first path component (i.e. the pattern is of the form `<dir_path>/<something>`), `1` otherwise.

- Iterate over `excludes` line by line.
- For each pattern, extract `pattern_prefix` as `${exclude_pattern%%/*}`.
- Use a `case "$dir_path" in $pattern_prefix)` match (same glob logic already used in `_apply_directory_excludes`).
- If a match is found, return `0` immediately.

### 2. Add `_selective_copy_dir` helper in `file:lib/copy.sh`

Add a new private function that performs a **top-level-entry-by-entry** copy of a source directory, skipping entries whose relative path (i.e. `<dir_path>/<entry_name>`) is excluded.

- Accept `src_dir`, `dest_parent`, `dir_path`, and `excludes`.
- `mkdir -p "$dest_parent/$dir_path"` to create the destination container.
- Use `find "$src_dir" -maxdepth 1 -mindepth 1` to enumerate direct children (files and directories).
- For each child entry:
  - Compute `child_rel="$dir_path/$(basename "$child")"`.
  - Call `is_excluded "$child_rel" "$excludes"` — if excluded, skip (log a message like `"Skipping excluded subtree $child_rel"`).
  - Otherwise call `_fast_copy_dir "$child"` (for directories) or `cp` (for files) into `"$dest_parent/$dir_path/"`.
- After the selective copy, call `_apply_directory_excludes` as before to handle any **deeper** nested excludes (e.g. `a/b/c` where only `b/c` is excluded, not `b` itself).

### 3. Modify `copy_directories` in `file:lib/copy.sh`

Inside the inner `while` loop (around line 406), replace the unconditional `_fast_copy_dir` call with a branch:

```
if _has_subdir_excludes "$dir_path" "$excludes"; then
    _selective_copy_dir  <src>  <dest_parent>  <dir_path>  <excludes>
else
    _fast_copy_dir "$dir_path" "$dest_parent/"
    _apply_directory_excludes "$dest_parent" "$dir_path" "$excludes"
fi
```

- The `_selective_copy_dir` path handles the case where a direct child of `dir_path` is excluded — it never copies the excluded subtree.
- The existing `_fast_copy_dir` + `_apply_directory_excludes` path is preserved for all other cases (no sub-excludes, or only deeper nested excludes).
- Logging (`log_info "Copied directory $dir_path"`) and `copied_count` increment remain in both branches.

### 4. Update `_apply_directory_excludes` call inside `_selective_copy_dir`

`_selective_copy_dir` must still call `_apply_directory_excludes "$dest_parent" "$dir_path" "$excludes"` after the selective copy, so that patterns like `a/b/c` (where `b` is not a direct child exclude but `c` inside `b` is) continue to be handled correctly.

---

## Data Flow After the Fix

```mermaid
sequenceDiagram
    participant CD as copy_directories
    participant HSE as _has_subdir_excludes
    participant SCD as _selective_copy_dir
    participant FCD as _fast_copy_dir
    participant ADE as _apply_directory_excludes

    CD->>HSE: dir_path=".claude", excludes=".claude/worktrees"
    HSE-->>CD: 0 (has sub-excludes)
    CD->>SCD: src=".claude", dest_parent, dir_path, excludes
    SCD->>SCD: find .claude -maxdepth 1 -mindepth 1
    loop each child entry
        SCD->>SCD: is_excluded ".claude/worktrees"? → skip
        SCD->>FCD: _fast_copy_dir ".claude/settings" dest/.claude/
    end
    SCD->>ADE: handle deeper nested excludes (no-op here)
```

### 5. Add tests in `file:tests/copy_safety.bats`

Add BATS tests covering:

| Test | Scenario |
|---|---|
| `_has_subdir_excludes` returns true when a direct-child exclude exists | `dir_path=".claude"`, `excludes=".claude/worktrees"` |
| `_has_subdir_excludes` returns false when no sub-exclude matches | `dir_path=".claude"`, `excludes="node_modules"` |
| `_selective_copy_dir` copies non-excluded children | Verify sibling dirs are present in dest |
| `_selective_copy_dir` skips excluded direct child | Verify excluded dir is absent in dest without ever being created |
| `copy_directories` end-to-end: excluded subtree never appears in dest | Integration-style test with a multi-child source dir |

Existing test `"cmd_copy applies configured excludeDirs"` in `file:tests/cmd_copy.bats` already validates the observable behaviour and should continue to pass unchanged.

---

Execution Information

Branch: main
Commit: 86563fb

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.