[brettheap]

Lane: openreposhape-1 (openRepoShape-1)
Claim: #654 (comment)

What

check now asks this machine's git what the split's checkout, the mount's git rm and the split's git add make of every file the plan keeps in the assembly root or sends to a leg (or drops), and of each pinned shape copy where the split writes it. A file git would store as other bytes than the split expects, or would refuse, is a new finding, plan-file-reencoded, and execute refuses it before any leg exists. Since #619, check asked this only about the source's own root .gitattributes. Every other such file passed check and failed after both leg remotes existed.

The finding comes in up to four groups, in this order. Each names up to ten paths in tree order, then counts the rest:

• kept files the split's git add -A would store as other bytes, which the verification then reports as adopt-lost:

  FINDING plan-file-reencoded: the plan keeps 1 file in the assembly root, and this machine's `git add` would store it as other bytes than its blob once the split's checkout has written it: `notes.txt`. The split's `git add -A` stores again each one git reads again (every file of a small source; of a large one, those checked out in the second git wrote its index), and the verification then reports it as `adopt-lost`, in no leg and not in the root tree, after both legs exist. Commit it in the source as git stores it (`git add --renormalize -- <path>`, then commit), or change the rule that reaches it, and re-run `plan`.
  

• sent to a leg or dropped: files the mount's git rm refuses as holding local modifications, so the split stops at mounting the legs. The way out is the same.

• pinned copies the source's rules make git add store as other bytes than the split writes, over which execute would say adoption verified. The way out names, for each copy, the line that keeps the rule off it, such as /scripts/bootstrap.py -filter.

• git's refusals, one finding for each step git refuses, in git's own words: the split's checkout, its git add -A of what the root keeps, and its add of the pinned copies. Under core.safecrlf=true:

  FINDING plan-file-reencoded: this machine's git refuses to store again what the plan keeps in the assembly root, as the split's `git add -A` does (git said `fatal: CRLF would be replaced by LF in notes.txt`), so `execute` would stop there, after the leg repositories exist. Commit the file git names in the source as git stores it, or change the rule or the setting that refuses it, and re-run `plan`.
  

Riding along:

• adopt-project.py: a nested .gitattributes setting eol or -text for a pinned copy outranks #471's root LF block, so Windows writes CRLF #530's rider 2 (a source filter= or working-tree-encoding= rule reaching a pinned copy) is covered for what this machine's git does: the copies group and the refusals group above.
• L1-11.
  • (1) tests-windows never executes an adoption: git-filter-repo is not installed there, so the eight adopt suites skip and v1.0.0's "adopt works on Windows" is unverified #471's follow-up for a symlinked root .gitattributes (scripts/shape_materialize.py) said "Git reads no .gitattributes that is a symlink". It now says "Git follows no .gitattributes that is a symlink: a checkout reads only the link's own text, the path it leads to, and a path names no attribute, so no line-ending rule reaches the pinned copies outside it". Two docstrings say the same.
  • (2) Where the root's .gitattributes is a symlink, plan-nested-attributes said a nested file outranks "the root's line-ending rule". It now says it outranks "the line-ending rule tests-windows never executes an adoption: git-filter-repo is not installed there, so the eight adopt suites skip and v1.0.0's "adopt works on Windows" is unverified #471's follow-up asks a regular root .gitattributes to hold (the root's is a symlink, which gives none)".
• L1-12. Where a working-tree-encoding rule reaches the root's own .gitattributes, plan-attributes-reencoded said the verification would report adopt-lost. It now says that the split's checkout writes the file in that encoding, that git then reads no rule from it, and that the mount's git rm stops the split at mounting the legs. It says git add --renormalize -- .gitattributes is no way out, because it stores the encoded bytes, and names the line .gitattributes -working-tree-encoding.

Why (repro on main)

22 real adoptions (plan, check, execute --local-remote-dir) on main at a524542, with git 2.43.0 and git-filter-repo 2.47.0, a stub gh first on PATH (no network):

source (the file is notes.txt unless named)	main	this PR
kept CRLF under * text eol=lf; kept CRLF docs/.gitattributes; kept $Id: deadbeef $ under ident; kept, under a filter this machine defines; kept *.txt whose working-tree-encoding rule goes to a leg with the root .gitattributes (5)	check 0, then adopt-lost after both legs, exit 1	found (kept)
the CRLF file, the ident file, a CRLF file under core.safecrlf=true and a src/*.py under that filter, each sent to a leg (4)	check 0, then refused at mounting the legs (git rm: local modifications)	found (sent; the filter case also finds the pinned scripts it reaches)
* working-tree-encoding=UTF-16LE with .gitattributes -working-tree-encoding	refused at mounting the legs, on the mount's own .gitmodules	found (a refusal of the copies)
a kept non-UTF-8 file under working-tree-encoding; a kept CRLF file under core.safecrlf=true; *.py working-tree-encoding=UTF-16LE-BOM (#530's rider) (3)	refused committing the split	found (refusals)
filter.<x>.required with no command	refused extracting the spec leg	found (a refusal)
/scripts/*.py filter=<upper>	adoption verified over uppercased pinned scripts; the recursive clone's validate-pins.py dies with a SyntaxError	found (copies)
CRLF under text=auto; LF under text; CRLF with no rule under core.autocrlf=true; a filter= with no driver here; a valid and a non-UTF-8 file under working-tree-encoding, sent to a leg (6)	verified	no finding, and verified
* working-tree-encoding=UTF-16LE	#619's plan-attributes-reencoded	the same, then this finding's lines

On main's code at this branch's base (78fe3ff), the new tests fail as On main's code under Tests says.

Timing is part of the defect. Git reads a checked-out file again, and stores it through its rules, only where it cannot trust the index's stat data. In three identical runs of the split's own clone, checkout -B and git add -A over 20,000 CRLF files under * text eol=lf, git stored 852, 1,577 and 6,803 of them again. On a small source that is every file. So check asks about every file a rule reaches. It finds the source that can fail, not only the run that would.

How

• _reencoded_files_findings is added to _entry_findings right after adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's _reencoded_attributes_findings. So check prints it, and _refuse_what_check_finds makes execute refuse it before _create_leg_remotes. It walks the plan as the split lays the root out (_PlannedRoot), with the one _SymlinkProbe that _entry_findings now makes and also gives _root_symlink_findings, so git is still asked once whether it checks a symlink out as one.

• _SplitRehearsal is a throwaway repository in the system's temporary directory, removed on leaving its with, as adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's probe is. It is made by git init with an empty template, and the source's object directory is its alternates, so nothing is copied. No byte of the source changes, but git's object freshening does touch it: where the question's git add or hash-object -w stores a blob the source already holds, git sets the modification time of the source's pack or loose object file that holds it to now. Every git it runs in the throwaway repository gets _inherited_env() and -c core.fsmonitor=false: this process's environment and this machine's config, as the split runs with them, without the variables that point git at another repository, GIT_ATTR_SOURCE or a command-scope attr.tree, which would steer the answer, and with GIT_LFS_SKIP_SMUDGE=1 (see Known limits).

• What it runs. This machine's own filter drivers run in the throwaway repository, as they run in the split's clone: each smudge at the checkout, each clean at each git add. A driver defined only in the source's .git/config runs in neither. A post-index-change hook that this machine's core.hooksPath names runs at each index the question writes, as it does in adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's.

• Which files are asked (_rules_reaching). git check-attr --cached -z --stdin reads text, eol, crlf, working-tree-encoding, ident and filter twice:

  • over every file, from an index of the source's commit, as the source holds its rules;
  • over the kept files and each pinned copy where _pinned_landings lands it, from an index laid out as the split's root will be: the moved paths removed, the root .gitattributes as _root_attributes writes it, and the shape's shape/.gitattributes beside it.

  A file any of the six reaches, in either layout, is asked. text=auto is asked too, never assumed safe. A source no rule reaches costs those two reads, a checkout of its .gitattributes files and the add of the pinned copies.

• The checkout. The asked files and every .gitattributes are held in an index with no stat data (update-index --index-info) and written with checkout-index -a -f, without -u, as the split's clone writes them. Git then trusts no entry and reads each file again.

• The mount's side. Over the files the plan moves, update-index --refresh then diff-files: git rm's own compare, which writes nothing. A conversion git cannot make is no change there, which matches the adoption that verifies a non-UTF-8 file sent to a leg.

• The split's side (_as_the_split_writes). The moved .gitattributes files are deleted. Every file the question writes replaces a symlink the checkout wrote at its path and never writes through it (_SplitRehearsal.place), because a link the source keeps may lead out of the throwaway repository. The root's own .gitattributes gets tests-windows never executes an adoption: git-filter-repo is not installed there, so the eight adopt suites skip and v1.0.0's "adopt works on Windows" is unverified #471's block appended, or the shape's own is written where the root keeps none, and shape/.gitattributes is placed beside it where the root keeps nothing there. Then a plain git add -u, never --renormalize, over the kept files, and what it staged (ls-files -s) is compared with each blob. --renormalize skips git's protection for a blob that already holds CRLF: under core.autocrlf=true with no rule it re-stores a file the real adoption verifies, and it raised none of the refusals core.safecrlf=true and an encoding raise in the real split. The index is not compared with the commit (diff-index), because that makes git read the .gitmodules the checkout wrote for each gitlink the commit holds, and die on one it cannot parse.

• The pinned copies (_copies_stored). Each copy's own bytes are written where it lands (the Makefile with adopt_makefile_block) and added with git --literal-pathspecs add -f, then compared with hash-object --no-filters. SPLIT_TEMPLATE names where the materializer reads them, templates/assembly-root under the shape root: the same directory as ASSEMBLY_TEMPLATE, which adopt-project.py plan writes null, true and other YAML keywords unquoted, so plan --spec-path null silently mounts the leg at the default spec #181's gate reads and a test may point at a copy. _root_attributes reads the shape's .gitattributes there too.

• The root's own .gitattributes is adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's question and is not asked again here. Kept as a symlink, it is plan-root-symlink's or tests-windows never executes an adoption: git-filter-repo is not installed there, so the eight adopt suites skip and v1.0.0's "adopt works on Windows" is unverified #471's follow-up's, and is not asked either. Other symlinks and gitlinks get no filter and are not asked. A refusal is reported in git's last line: a refused checkout ends the question there, and a refused git add of the kept files still leaves the pinned copies asked.

• The helper that names ten paths is _named_and_counted. adopt-project.py already has a _named, for adopt-project.py plan writes null, true and other YAML keywords unquoted, so plan --spec-path null silently mounts the leg at the default spec #181's gate.

Cost, measured at 78ffd72 (this head adds only an environment variable and a helper) on a shared 32-core machine while other test runs went (load average 35 to 60), median of 3. check on main's code is 78fe3ff's adopt-project.py; "the question" is _reencoded_files_findings alone, in process.

source	check on main's code	check here	the question
this repository at a524542 (277 files)	0.52 s	1.25 s	0.56 s
20,001 files, no rule	2.84 s	3.78 s	0.90 s
20,001 files under * text=auto eol=lf, sent to a leg	2.91 s	14.1 s	9.3 s
the same, kept	6.11 s	18.2 s	11.3 s
20,000 CRLF files under * text eol=lf, sent to a leg (found)	2.51 s	12.4 s	9.4 s
the same, kept (found)	5.68 s	28.5 s	22.7 s

Most of it is git's own work. On the text=auto source, checkout-index of the 20,000 files took 5.8 s of the question's 9.0 s (2.1 to 3.3 s in the design's quieter session, so the disk was busy); on the kept CRLF one, git add -u storing 20,000 blobs took 12.2 s of 22.5 s. For scale, a real execute of the text=auto source took 24.6 s.

Tests

tests/test_adopt_reencoded_files.py, 53 tests:

• 17 sources check finds, each in its group's words: the 15 of the table above that pass check on main, the same CRLF file dropped by the plan, and a required smudge filter that fails;
• 4 sources execute refuses before any leg exists, one for each group;
• 8 sources the split stores as their blobs: no finding, and each adopts end to end (16; the adoptions need git filter-repo). They are the six right verifications of the table, pinned scripts under *.py text eol=crlf with core.safecrlf=true, which the block keeps LF, and a kept .github/workflows/ whose filter rule's .github/.gitattributes goes to a leg;
• the words of each group, and the ten-name cap (4);
• the root's own .gitattributes, named by adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's finding alone (1);
• a source no rule reaches checks out only its .gitattributes, and the checkout's index holds no stat data (2);
• GIT_ATTR_SOURCE=HEAD, GIT_ATTR_SOURCE at the empty tree and a command-scope attr.tree do not steer the answer (3);
• two malformed plans get findings, not a traceback (2);
• a stand-in for git-lfs's required filter, whose smudge fails unless GIT_LFS_SKIP_SMUDGE is 1, gets no finding (1);
• a kept file named shape where the shape's shape/.gitattributes goes (1), the root asked as the split writes it under core.autocrlf=true and core.safecrlf=true (1), and a kept root .gitattributes symlink out of the source, which the question never writes through (1).

Edited: tests/test_adopt_nested_attributes.py (L1-11 (2) in two tests, and L1-12's words in the encoding test, which now also expects plan-file-reencoded after #619's finding) and tests/test_adopt_attributes_eol_block.py (L1-11 (1)).

On main's code. With 78fe3ff's adopt-project.py and scripts/shape_materialize.py and this PR's tests, 34 of the three files' 169 tests fail: 31 of the new module, and the three L1-11 and L1-12 assertions. The 22 new tests that pass there are the controls: the 8 sources stored as their blobs, checked and adopted (16), the two malformed plans, the kept file named shape, the root's own .gitattributes, the root link and the git-lfs stand-in.

Revert table. Each change reverted alone in a clone of this head, committed there, and run with git filter-repo on PATH over the new module (53 tests), with the test a row names run beside it, or over the one file a row names:

change reverted	fails
the _entry_findings line	29: every test that runs check or execute for a finding (the 22 controls, the gate and the clock pass)
_entry_findings' one probe not given to the question	1: tests/test_adopt_root_symlinks.py's test_the_probe_is_made_once_however_many_walks_ask (run with it)
ls-files -s back to diff-index --cached against the commit	1: tests/test_adopt_submodules.py's unreadable .gitmodules kept, its submodule dropped (REFUSED git-failed; run with that test's 5 cases)
place writing through a symlink	1: the root link (the file it reaches is overwritten)
the root's .gitattributes link asked as a kept file	1: the root link (a second finding)
GIT_LFS_SKIP_SMUDGE=1 not set	1: the git-lfs stand-in (its required smudge fails, and the checkout is refused)
git add -u back to git add --renormalize -- .	9: the text=auto and core.autocrlf controls, checked and adopted (4), and five refusals it does not raise (a kept non-UTF-8 file under an encoding, a kept CRLF file under core.safecrlf, the refusal's words, the root asked as the split writes it)
checkout-index -u	1: the clock
the mount's side asked with git add -u and its refusal	3: a CRLF file sent to a leg under core.safecrlf (found as a refusal instead), and a non-UTF-8 file sent to a leg under an encoding, checked and adopted (a refusal the mount's git rm never meets)
the moved .gitattributes left in place	2: the kept .github/workflows/ whose rule goes to a leg, checked and adopted
the checkout without the .gitattributes files	26
the pinned copies not asked	6: the four copy cases, execute's copy case and the copies' words
#471's block not appended to the root's own	2: the pinned scripts under *.py text eol=crlf with core.safecrlf, checked and adopted
the shape's own .gitattributes not written at the root	1: the root asked as the split writes it
the gate (every file checked out)	1: a source no rule reaches
_inherited_env() back to os.environ	3: the three steering cases
a refusal read as success	9: every refusal case
the root's own .gitattributes asked again	31
no ten-name cap	1
shape/.gitattributes placed where the root keeps one	1: tests/test_adopt_nested_attributes.py's kept shape/.gitattributes (run with it)
a refused checkout not read	1: the smudge filter that fails
update-index --replace dropped	1: the kept file named shape (REFUSED git-failed)
SPLIT_TEMPLATE back to ASSEMBLY_TEMPLATE	16 of tests/test_adopt_plan_yaml_quoting.py's 524 (bare_template points ASSEMBLY_TEMPLATE at a copy without .gitattributes)
_named_and_counted named _named again	43 of tests/test_adopt_plan_yaml_quoting.py's 524 (it replaced #181's _named: a TypeError)
L1-11 (1): scripts/shape_materialize.py's sentence	1 of tests/test_adopt_attributes_eol_block.py's 37
L1-11 (2): linked always false	1 of tests/test_adopt_nested_attributes.py's 79
L1-12: encoded always false	1 of tests/test_adopt_nested_attributes.py's 79

Runs on this head (9cf5e48, made from main at 78fe3ff; git merge-tree merges it cleanly with main at 55c6ba7, whose newer commits #610, #658, #650 and #425 change scripts/shape_materialize.py or adopt-project.py outside this diff's hunks), with /usr/bin/python3 -m pytest, over 29 files: the three test files this diff touches, tests/test_shape_doctor.py, tests/test_scaffold_leg_path_collisions.py, tests/test_cli_reference.py, tests/test_agents_md_codes.py, tests/test_repo_hygiene.py, and 21 adopt test files that run check or execute over kept files, symlinks, submodules, unusual names and the temporary directory:

• with git filter-repo on PATH: 2788 passed, 3 skipped, 0 failed;
• with it hidden (PATH=/usr/local/bin:/usr/bin:/bin behind a stub gh): 2637 passed, 154 skipped, 0 failed.

On 78ffd72 merged locally with main at b618ec1, the reviewer ran the three test files this diff touches, tests/test_adopt_root_symlinks.py, tests/test_adopt_submodules.py, tests/test_shape_doctor.py and tests/test_scaffold_leg_path_collisions.py: 1000 passed and 3 skipped with git filter-repo on PATH, and 954 passed and 49 skipped with it hidden.

These runs found three defects of the question's own on earlier heads of this branch, each fixed here with a test: it made a second symlink probe (tests/test_adopt_root_symlinks.py); diff-index read a .gitmodules git cannot parse and refused git-failed (tests/test_adopt_submodules.py); and a root .gitattributes link out of the source was written through, outside the throwaway repository (found by a probe). CI's full Linux suite runs on this pull request.

Windows

CI is Linux only since #597. The new tests commit every file byte for byte (committed_raw, from tests/test_adopt_nested_attributes.py), set git's config through GIT_CONFIG_COUNT rather than a file, and read the plan back with read_text(). Their filter commands, tr a-z A-Z and false, are tools Git for Windows ships. Every path they make (notes.txt, notes/n01.txt, docs/a.md, more.txt, shape, a/b/Thing, victim.txt) is legal on NTFS. The root-link test makes a symlink on the disk and skips where the platform cannot, and it points TMPDIR, which Python's tempfile reads first on every platform, at a directory of its own.

Not in this PR

• adopt-project.py: a nested .gitattributes setting eol or -text for a pinned copy outranks #471's root LF block, so Windows writes CRLF #530's rider 1 (the .github -> ci link spelling in tests-windows never executes an adoption: git-filter-repo is not installed there, so the eight adopt suites skip and v1.0.0's "adopt works on Windows" is unverified #471's block). It stays open. The block line names the link's spelling, /.github/workflows/validate.yml text eol=lf, while git tracks ci/workflows/validate.yml, so a clone can write that copy CRLF and validate-pins.py reports shape-copy-drift (reproduced on a524542). That is the checkout half of the block's own line, not anything git add stores, so this question cannot see it. The fix names the path git tracks in _append_eol_block and eol_block_paths' callers, _land_the_eol_block, _root_attributes and update-shape.py's extend_eol_block, which is four files, one of them D1's. Lane 1 re-points the rider on Tracking: adopt-project.py, converting an existing repository in place #457 when this closes.

Known limits

• The files the split renders, and the mounts' .gitmodules, are not asked: README.md, project.yaml, the three pin files, AGENTS.md and CLAUDE.md. Their bytes exist only after the legs are pushed. A rule that reaches only them still fails after both legs, though a * rule is found through the pinned copies. One case: under core.autocrlf=true and core.safecrlf=true with no rule of the source's, execute on main stops at mounting the legs on the mount's own .gitmodules (LF would be replaced by CRLF in .gitmodules). This PR finds that source first, because the split's git add -A would also refuse its kept .gitignore (CRLF would be replaced by LF in .gitignore, replayed by hand), but a source whose kept files all pass would still meet .gitmodules.
• Another machine's config and filter drivers are not asked, and neither is what a cloner's checkout writes.
• The mount's per-entry git rm order is not modelled: a moved .gitattributes removed by an earlier git rm than a sibling entry's file.
• A split that would pass by timing is still refused. That is by design: the next run may not.
• The throwaway repository lives in the system's temporary directory and holds the files a rule reaches, up to the source's size.
• git-lfs's smudge is skipped in the throwaway repository (GIT_LFS_SKIP_SMUDGE=1): each LFS file is checked out as its pointer, and git-lfs's clean stores a pointer as it is, so an LFS source is asked without reading, linking or downloading its LFS objects, and a blob under filter=lfs that is not a pointer is still found. Not measured with git-lfs, which this machine lacks; the behaviour is read in git-lfs's source and emulated with a required filter. git-crypt defines its filter in the repository's own .git/config, which neither the throwaway repository nor the split's clone reads, so its files are asked as their encrypted blobs, as the split stores them. Any other required filter whose smudge needs something the throwaway repository lacks is refused there.
• adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's encoding case (* working-tree-encoding=UTF-16LE) also gets this finding's lines after adopt-project.py: check finds, and execute refuses before any leg, a kept nested .gitattributes that outranks the root's line-ending rule for a pinned copy, and a root .gitattributes that git add would re-encode (#530) #619's own: they are consequences of the one rule.
• adopt-project.py: a nested .gitattributes setting eol or -text for a pinned copy outranks #471's root LF block, so Windows writes CRLF #530's rider 1 stays open, as above.

Closes #654

🤖 Generated with Claude Code

Summary by Sourcery

Make adoption checks detect Git-dependent file transformations and refusals before leg repositories are created.

New Features:

• Add preflight detection for files and pinned copies that Git would re-encode, transform, or reject during project adoption.

Bug Fixes:

• Prevent adoptions from proceeding when Git would later lose kept files, reject moved files, or verify incorrectly transformed pinned copies.
• Avoid following symlinked root .gitattributes files during rehearsal and clarify their resulting diagnostics.
• Correct handling and messaging for root .gitattributes files affected by working-tree-encoding.

Enhancements:

• Model the split's checkout, mount removal, root staging, and pinned-copy staging in an isolated Git rehearsal using the current machine's configuration.
• Group and cap file-reencoding findings with actionable remediation guidance, including Git refusal messages and affected paths.

Documentation:

• Clarify how Git treats symlinked .gitattributes files and update related nested-attribute diagnostics.

Tests:

• Add comprehensive coverage for re-encoded files, Git refusals, transformed pinned copies, symlink safety, environment isolation, path limits, and successful control cases.

[sourcery-ai]

Reviewer's Guide

The PR extends check with a Git-backed rehearsal of the split’s checkout, leg removal, root staging, and pinned-copy staging, reporting plan-file-reencoded findings before execution can create legs; it also refines symlink and root-attribute diagnostics and adds broad regression coverage.

Sequence diagram for preflight Git re-encoding checks

sequenceDiagram
    participant Check
    participant Rehearsal as SplitRehearsal
    participant Git
    participant Source
    Check->>Rehearsal: _reencoded_files_findings()
    Rehearsal->>Source: Read commit objects via alternates
    Rehearsal->>Git: check-attr --cached for source and split layouts
    Rehearsal->>Git: checkout-index -a -f
    alt checkout refused
        Git-->>Rehearsal: refusal text
        Rehearsal-->>Check: plan-file-reencoded
    else checkout succeeds
        Rehearsal->>Git: update-index --refresh and diff-files
        Git-->>Rehearsal: moved or dropped files with local modifications
        Rehearsal->>Git: add -u for files kept in the root
        Git-->>Rehearsal: stored blobs or refusal
        Rehearsal->>Git: literal-pathspecs add -f for pinned copies
        Git-->>Rehearsal: stored blobs or refusal
        Rehearsal-->>Check: grouped plan-file-reencoded findings
    end
    Check->>Check: _refuse_what_check_finds()
    Check-->>Check: execute refuses before _create_leg_remotes

Loading

Flow diagram for grouped re-encoding findings

flowchart TD
    Start[check] --> Layout[Build source and split index layouts]
    Layout --> Checkout[Rehearse checkout]
    Checkout -->|refused| Refusal[Record Git refusal]
    Checkout -->|succeeds| Mount[Rehearse moved or dropped files with git rm comparison]
    Mount --> Kept[Rehearse kept files with git add -u]
    Kept --> Copies[Rehearse pinned copies with git add -f]
    Copies --> Groups[Group findings in order]
    Groups --> KeptFinding[Kept files: adopt-lost risk]
    Groups --> MovedFinding[Sent or dropped files: git rm risk]
    Groups --> CopyFinding[Pinned copies: adoption verified drift]
    Groups --> RefusalFinding[Git refusals]
    KeptFinding --> Execute[execute refuses before legs exist]
    MovedFinding --> Execute
    CopyFinding --> Execute
    RefusalFinding --> Execute

Loading

File-Level Changes

Change	Details	Files
Added rehearsal-based detection of Git re-encoding and refusal cases across files affected by the split.	Introduced a temporary repository using source-object alternates and inherited Git configuration to model checkout, leg removal, root staging, and pinned-copy staging. Determined which files are reached by conversion attributes in both source and split layouts, including text, encoding, ident, and filter rules. Added grouped plan-file-reencoded findings for kept files, moved or dropped files, pinned copies, and Git refusals, with capped path lists and remediation guidance. Made execute reject these findings before creating leg remotes. Protected symlink handling, Git index/stat behavior, Git steering environment, and unreadable submodule metadata during rehearsal.	adopt-project.py
Clarified symlinked-root and encoded-root-attributes behavior to match Git and split execution semantics.	Updated documentation and follow-up wording to state that Git does not follow symlinked .gitattributes files for attribute discovery. Adjusted nested-attribute findings when the root .gitattributes is a symlink. Expanded root-attributes re-encoding diagnostics for working-tree-encoding, including why renormalization is not a remedy.	adopt-project.py scripts/shape_materialize.py
Expanded regression coverage for re-encoding detection and updated affected wording assertions.	Added comprehensive tests for kept, moved, dropped, pinned-copy, and refusal scenarios across line endings, encodings, ident, filters, safecrlf, and required filters. Verified successful controls, execute-time refusal before leg creation, ten-path reporting limits, malformed plans, environment steering, symlink safety, root layout, and stat-independent reads. Updated nested-attribute and symlink follow-up expectations, including encoded root .gitattributes behavior.	tests/test_adopt_reencoded_files.py tests/test_adopt_nested_attributes.py tests/test_adopt_attributes_eol_block.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#654	Have check detect kept or moved files other than the root .gitattributes whose bytes Git would re-encode or refuse during the split, and make execute refuse before any leg exists.	✅
#654	Document the whole-source rehearsal design and its cost, and correct the related wording for symlinked attributes and working-tree-encoding failures.	✅

Possibly linked issues

• adopt-project.py check: a kept or moved file other than .gitattributes whose blob git add would re-encode passes, and execute ends adopt-lost or dies mounting the legs after both legs are pushed #654: The PR implements the issue’s whole-source precheck for kept and moved files, and also covers pinned copies and specified riders.

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sourcery-ai]

Sorry @brettheap, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 3 hours and 34 minutes by commenting @sourcery-ai review. Upgrade to get a review now.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[sourcery-ai]

Sourcery assessment

Approved.