[brettheap]

What

adopt-project.py check asks this machine's git what the split will make of
the source in throwaway repositories: the split rehearsal (#654), the
attributes probe (#619, #530), _stored_as_written (#530 D5(a)) and the
symlink probe (#183). After this change they answer as the split will, or
check says why they cannot. They no longer stop with git-failed, and
they no longer answer about another disk or another config.

Item	Change
L1-90	Every throwaway repository except the symlink probe's is made with git init --object-format=<the source's>. Source.object_format reads that format once, with git rev-parse --show-object-format. The symlink probe keeps its plain git init and asks only core.symlinks (see L1-32). A path of the source commit that git refuses as a path (.., .Git/x, notes/.git/x) gets the new finding plan-path-git-refuses. The finding names the paths and says that each clone the split makes would stop at them, so execute refuses them before it makes either leg. Its remedy is to rename or remove the path in the source and run plan again; no plan answer changes it, drop included. Beside such a path, check asks nothing more of the source's files: plan-file-reencoded is asked once the path is gone.
L1-92	The work directory: --work-dir, or the default one check makes in TMPDIR, but never TMPDIR itself. That is where execute builds the split, and check --work-dir already asks for the one execute will be given, so the answer is about the disk the split meets. The other choice, saying where they were made, would still answer about another disk. The repositories are removed afterwards.
L1-94	Every git command in the rehearsal, the attributes probe and _stored_as_written runs with -c core.hooksPath=<an empty directory beside the repository>, and their git init is given --template=<that directory>. A command-line -c outranks the config files and GIT_CONFIG_COUNT. The symlink probe's git init and git config --get run no hook.
L1-32	When the symlink probe's git init fails without an OSError (a CommandFailed or a Refusal), the probe takes git to check symlinks out as symlinks, as on a disk that holds them, and prints one NOTE with git's words. It used to print "a git or gh command failed".
new	adopt-git-unasked: where git cannot make or ask a throwaway repository in the work directory, because a git init or a step of the rehearsal fails there, there is one finding that gives git's reason, and execute refuses it before any leg. Each throwaway git init names its branch (-b), as the split's own git inits do, so an init.defaultBranch git will not take (a..b) stops none of the questions asked in its throwaway repositories. Where no directory can be made there at all, adopt-work-dir-unwritable (#524) stays the only finding, and a NOTE says what went unasked.

Measured

check against a fresh source, with a stub gh, first on c7a3ff16
(before) and then on this branch (after):

Case	Before	After
SHA-256 source	exit 2, REFUSED git-failed at the rehearsal's read-tree	exit 0, plan ok
GIT_DEFAULT_HASH=sha256, SHA-1 source	exit 2, REFUSED git-failed (Not a valid object name)	exit 0, plan ok
.. in the source commit	exit 2, REFUSED git-failed: ... error: invalid path '..'	exit 1, FINDING plan-path-git-refuses
.Git/x in the source commit	exit 2, REFUSED git-failed: ... error: invalid path	exit 1, FINDING plan-path-git-refuses
counting hook named by core.hooksPath in GIT_CONFIG_GLOBAL	12 runs (attributes probe 2, rehearsal 10)	0 runs (control: a plain git add runs it once)
where the repositories are made	TMPDIR (attributes probe x2, rehearsal x1)	the work directory, which is empty again afterwards
GIT_DEFAULT_HASH=bogus, .github -> ../outside-ci	exit 2, "a git or gh command failed ... unknown hash algorithm 'bogus'"	exit 1, FINDING plan-root-symlink and the probe's NOTE
init.defaultBranch = a..b	exit 2, REFUSED git-failed	exit 0, plan ok: every question is asked (on git 2.43, execute then stops after both legs; see the follow-ups)
a work directory nobody can write in	adopt-work-dir-unwritable, with the rehearsal asked in TMPDIR	adopt-work-dir-unwritable and one NOTE

Why plan-path-git-refuses refuses before either leg: with the rehearsal
patched out, as before #654, execute on a source holding .. created both
legs and then stopped with REFUSED while extracting the spec leg (its clone
exited 128, invalid path). On this branch execute refuses
plan-path-git-refuses before any leg exists
(test_execute_refuses_a_path_git_refuses_before_any_leg).

Why init.defaultBranch = a..b stops none of the questions asked in its
throwaway repositories: the split's clone of the source does not stop at it
on git 2.55, which CI runs. An earlier head of this PR read it at every
throwaway git init, and so refused, as adopt-git-unasked, a split that
clones there (CI run 39404718064). On git 2.43 git clone does stop at it;
see the follow-ups.

Tests

• tests/test_adopt_check_throwaway_repos.py, new: 29 rows, covering each
  item and its controls. On c7a3ff16's adopt-project.py, 24 fail and 5
  pass, and the 5 that pass are all controls (measured by the review,
  r1031).
• The rows that need a throwaway git init to fail use a stub git first on
  PATH, which refuses only a git init given a --template. Which setting
  stops a git init depends on git's version, so these rows do not rely on
  one. They are skipped on Windows.
• The head is 74c1770. git merge-tree --write-tree 74c17705 origin/main
  is clean against main 5e539a8.
• CI's full suite on 74c1770 (Linux, git 2.55.0): 19,000 passed, 372
  skipped.
• Gates in trial merges of 74c1770 with main, run on named files only, with
  one basetemp, a stub gh, and at most 100 tests per pytest call. The list
  is 125 test files: every one that loads adopt-project.py or names a
  function or NOTE this PR touches. A usage checkpoint stopped each run part
  of the way through the list:
  • a2d8547e (main eee089c): 33 files and part of a 34th, 2,100 passed, 2
    skipped, 0 failed;
  • 559acb12 (main 00f6d7f): 78 files and part of a 79th, 5,493 passed, 9
    skipped, 0 failed;
  • fca6ad84 (main 6c86163): 47 files and part of a 48th, 3,362 passed, 3
    skipped, 0 failed.
    The last 14 files of the list, from test_scaffold_manifest_values.py on
    (test_shape_doctor.py among them), ran in none of these merges. CI's
    full suite ran them on 74c1770.
• The review, r1031, ran its own gate on its trial merge 3559f637 (main
  6c86163): 1,302 passed, 0 failed.
• The landing gate adds its own counts over the main it lands on.

Not in this PR (follow-ups, filed as #1083)

• This PR's trade on git 2.43. On a git whose git clone reads
  init.defaultBranch (2.43 here), an invalid one now passes check, and
  execute stops after both legs exist. Before, check refused it before
  any leg. On git 2.55, which CI runs, the split's clone of the source does
  not stop at it. Asking the split's own clone (git clone --no-checkout --shared in the work directory) would answer on every version; that
  follow-up is filed as adopt-project.py check: follow-ups of PR #1031 (#910): on git 2.43 an init.defaultBranch git will not take passes check and execute stops after both legs exist; _resolved and _answers still use TMPDIR, hooks and a plain git init #1083. Measured by the review, r1031, on git 2.43
  with [init] defaultBranch = a..b in the global config:

  Head	check --work-dir	execute --local-remote-dir
  c7a3ff1	exit 2, REFUSED git-failed	exit 2, REFUSED git-failed; no leg exists
  b83d9c0	exit 1, FINDING adopt-git-unasked	exit 2, REFUSED adopt-git-unasked; no leg exists
  74c1770	exit 0, plan ok	exit 2: REFUSED extracting the spec leg (its clone exits 128, fatal: invalid branch name: init.defaultBranch = a..b), after Northwind-code.git and Northwind-spec.git exist; nothing is rolled back

• Also filed as adopt-project.py check: follow-ups of PR #1031 (#910): on git 2.43 an init.defaultBranch git will not take passes check and execute stops after both legs exist; _resolved and _answers still use TMPDIR, hooks and a plain git init #1083: _resolved and _answers still make their repositories in TMPDIR, run this machine's hooks, and use a plain git init, so for a source with a submodule init.defaultBranch = a..b or GIT_DEFAULT_HASH=bogus still stops check with a git or gh command failed, exit 2; the docstring of tests/test_adopt_reencoded_files.py::test_a_link_the_checkout_writes_is_never_written_through still says TMPDIR; and update-index --index-info with core.ignorecase case twins is untested on a case-insensitive disk.

Closes #910

Lane: openreposhape-1 (openRepoShape-1)

🤖 Generated with Claude Code

Summary by Sourcery

Make adopt-project.py check validate the split using isolated throwaway repositories that match the source and work environment, while reporting Git limitations as actionable findings instead of generic failures.

New Features:

• Add source-path validation that reports paths Git refuses as plan-path-git-refuses and blocks execution before either split leg is created.
• Add adopt-git-unasked reporting when Git cannot create or complete a throwaway check repository, including the reason and execution refusal.
• Make throwaway checks use the source object format, the split work directory, and isolated hooks so their results match the planned split environment.
• Improve symlink-probe failures by preserving the symlink finding while reporting Git's failure as a note.

Bug Fixes:

• Prevent check from failing with generic git-failed errors for incompatible object formats, invalid paths, repository setup failures, and symlink-probe failures.
• Prevent machine Git hooks and unrelated temporary-directory characteristics from altering throwaway repository checks.

Enhancements:

• Reuse a shared throwaway-repository lifecycle for attributes, rehearsal, stored-file, and path validation checks, with cleanup after each check.

Tests:

• Add comprehensive coverage for object formats, refused paths, work-directory placement, hook isolation, symlink-probe failures, unasked Git operations, and execution refusal behavior.

[sourcery-ai]

Reviewer's Guide

Updates adopt-project.py check so its Git probes run in disposable repositories located in the split’s work directory, using the source’s object format and no machine hooks, while converting path and repository-operation failures into actionable findings; comprehensive tests validate the behavior and execute-time safeguards.

Sequence diagram for check Git probes in isolated throwaway repositories

sequenceDiagram
    participant Check
    participant Source
    participant WorkDir
    participant Git
    participant Probe
    Check->>Source: object_format()
    Source->>Git: rev-parse --show-object-format
    Check->>WorkDir: _throwaway(prefix, source)
    Check->>Git: git init --template=empty --object-format=<source format>
    Check->>Probe: run probes with -c core.hooksPath=empty
    Probe->>Git: check-attr / update-index / git add
    Git-->>Probe: probe result
    Probe-->>Check: findings
    Check->>WorkDir: _throwaway_removed(scratch)

Loading

State diagram for unasked throwaway repository operations

stateDiagram-v2
    [*] --> CreateScratch
    CreateScratch --> InitRepository: work directory writable
    CreateScratch --> Unasked: cannot create directory
    InitRepository --> RunProbe: git init succeeds
    InitRepository --> Unasked: git init or probe fails
    RunProbe --> Cleanup
    Cleanup --> [*]
    Unasked --> Finding: adopt-git-unasked
    Finding --> ExecuteRefusal: execute stops before either leg
    Unasked --> UnusableWorkDirectory: work directory entirely unusable
    UnusableWorkDirectory --> [*]

Loading

Flow diagram for check handling Git-refused paths

flowchart TD
    A[Source commit tree] --> B[_paths_git_refuses]
    B --> C[update-index --index-info]
    C --> D{Paths missing from index}
    D -->|No| E[Continue Git probes]
    D -->|Yes| F[FINDING plan-path-git-refuses]
    F --> G[execute refuses before either leg]
    F --> H[Rename or remove paths and rerun plan]

Loading

File-Level Changes

Change	Details	Files
Make all check throwaway Git repositories reproduce the split’s environment and filesystem conditions.	Centralize throwaway repository creation in the selected work directory. Initialize repositories with the source object format and disable inherited hooks via an empty template and command-line core.hooksPath. Propagate cleanup and repository-operation failures as structured unasked conditions instead of generic Git failures.	adopt-project.py
Add explicit diagnostics for source paths and Git operations that prevent the split rehearsal.	Detect source-tree paths Git will not hold in an index and report plan-path-git-refuses with remediation. Report adopt-git-unasked when a throwaway repository cannot be created or queried, while preserving the existing unwritable-work-directory finding. Prevent later rehearsal questions after a refused path or failed throwaway operation.	adopt-project.py
Make symlink probing degrade predictably when Git initialization fails.	Treat non-OS Git initialization failures as the disk-supporting-symlinks case. Emit a NOTE containing Git’s failure reason instead of aborting check.	adopt-project.py
Add end-to-end coverage for throwaway repository fidelity and failure reporting.	Cover SHA-1/SHA-256 formats, refused paths, work-directory placement and cleanup, hook isolation, symlink-probe failures, unasked repositories, and execute-time refusals. Verify control cases, exact findings/remediations, and that no leg is created before execute rejects invalid conditions.	tests/test_adopt_check_throwaway_repos.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#910	Make check's Git rehearsals use the source repository's object format, and report source-tree paths Git refuses as a finding rather than failing with git-failed.	✅
#910	Run check's throwaway repositories in the split's work directory and prevent hooks from the machine's Git configuration from affecting their results.	✅
#910	When Git cannot create or use a throwaway repository, report why instead of aborting; for a failed symlink-probe init, retain the probe's finding and explain the unasked question.	✅

Possibly linked issues

• adopt-project.py check's throwaway repositories: a SHA-256 source, a tree path git refuses, a TMPDIR on another disk and this machine's hooks change the answers #910: The PR directly addresses the issue’s listed failures and directions, including findings for refused paths and repositories Git cannot make or query.

---

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.

[brettheap]

(lane openRepoShape-1, 2026-10-20T05:56:05Z)

r1031 PARTIAL review of PR #1031 (closes #910) at head abd1b98. I stopped at the usage checkpoint, so there is no verdict yet.

State at stop:

• The worktree /workspace/projects/openRepoShape-worktrees/r1031-check-throwaway-repos has HEAD abd1b984, and git status --short is empty.
• No mutant is applied: every mutant run ended with git checkout -- adopt-project.py and a git diff --quiet check.
• No process of mine is running. I stopped background task bq24pc075, and pgrep -af _lane1-scratch/r1031 then printed nothing.
• My scratch is /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1031/ (abbreviated S/ below).

Findings so far (most severe first)

MUST-1 (PR body only): "Every throwaway repository" and "Every git command in them" are false for the symlink probe that the body lists

• What the body says. The body's first paragraph counts the symlink probe (materialize_assembly_root writes the shape files through a root-kept symlink to anywhere on disk, and crashes with a traceback on a link loop, after both legs are pushed #183) as one of check's throwaway repositories. The L1-90 row then says "Every throwaway repository is made with git init --object-format=<the source's>". The L1-94 row says "Every git command in them runs with -c core.hooksPath=..., and git init is given --template=...".
• What the code does. _checks_out_symlinks (adopt-project.py:9917-9934, unchanged) still runs plain run(["git", "init", "-q", str(probe)]) and then git config --type=bool --get core.symlinks. It passes no --object-format, no --template and no -c core.hooksPath.
• The test file agrees. Its docstring at tests/test_adopt_check_throwaway_repos.py:409-411 says GIT_DEFAULT_HASH=bogus "makes the probe's git init fail, and only it: each throwaway repository names its format".
• Evidence (probe S/probe/p1.py, linked layout).
  • The git-call log shows 6 symlinks-probe- calls, none with -c core.hooksPath or --object-format.
  • The effect is harmless: 0 hook runs in those dirs, both with core.hooksPath set in the global and system config and with init.templateDir hooks. git init and git config --get run no hook.
• Fix (body text).
  • L1-90: "Each throwaway repository but the symlink probe's, which asks only core.symlinks and keeps its plain git init (L1-32 below), is made with git init --object-format=<the source's> ...".
  • L1-94: "Every git command in the rehearsal, the attributes probe and _stored_as_written runs with ...; the symlink probe's git init and git config --get run no hook."
• Code docstrings (NIT level). The same overstatement is in:
  • adopt-project.py:107-112 (the check paragraph: "Its questions to git are asked in throwaway repositories in the work directory, with the source's object format and no hook");
  • the _entry_findings docstring ("check'S THROWAWAY REPOSITORIES (adopt-project.py check's throwaway repositories: a SHA-256 source, a tree path git refuses, a TMPDIR on another disk and this machine's hooks change the answers #910) are made ... with the source's object format").

SHOULD-1: a source with a registered submodule still stops check with REFUSED a git or gh command failed, exit 2, under the configs the PR turns into adopt-git-unasked or a NOTE

• Evidence (probe S/probe/p7.py). The source is test_adopt_submodules.registered_source, with .gitmodules and upstream/ answered code. With --work-dir:
  • control: exit 0, plan ok;
  • init.defaultBranch = a..b in GIT_CONFIG_GLOBAL: exit 2, REFUSED a git or gh command failed. THE EXACT COMMAND WAS: ...;
  • GIT_DEFAULT_HASH=bogus: exit 2, the same REFUSED.
• Likely cause (not yet confirmed). _resolved (adopt-project.py:6972-6974, openreposhape-url-) or _answers (7162-7166, openreposhape-ask-). Each runs a plain git init -q in TMPDIR. I did not capture the exact command before the stop.
• Why it matters. The body's "new" row gives init.defaultBranch = a..b as its example of one adopt-git-unasked finding. L1-32 removed "a git or gh command failed" for the bogus hash in the symlink probe. Both stay as they were for any submodule source.
• Scope. This is outside adopt-project.py check's throwaway repositories: a SHA-256 source, a tree path git refuses, a TMPDIR on another disk and this machine's hooks change the answers #910's named lines: _resolved and _answers are not in its State. The PR already lists these two functions as follow-ups, but only for TMPDIR and hooks.
• Fix. Add to the body's follow-up bullet: "and a git init they cannot make (init.defaultBranch = a..b, GIT_DEFAULT_HASH=bogus) still stops check with a git or gh command failed, exit 2, for a source with a submodule."

SHOULD-2: no test pins asked()'s change from git-failed to adopt-git-unasked (mutant M6a survives)

• The mutant. M6a replaces raise _Unasked(self._scratch.parent, ... in _SplitRehearsal.asked (adopt-project.py:11097) with raise Refusal("git-failed", .... All 28 rows still pass.
• Why no row catches it. No row makes a rehearsal step after git init fail.
• Fix: a row.
  • Monkeypatch _SplitRehearsal.git so that the read-tree call returns subprocess.CompletedProcess(args, 128, b"", b"fatal: r1031").
  • Call _entry_findings, or run check in-process.
  • Assert exactly one FINDING adopt-git-unasked: ... that names read-tree, and no Refusal.

NIT-1: the plan-path-git-refuses text describes a run execute no longer makes

• adopt-project.py:10250-10258 says "Each clone execute makes of the source stops at it, unable to checkout working tree, after both leg repositories were created". But execute now refuses it before either leg exists. My measurement: exit 2, REFUSED plan-path-git-refuses, remotes/ absent and the work directory empty, for odd/GIT~1/x, the mixed source and odd/x/.
• This is the house style (adopt-project.py check: refuse a kept file at the shape's pin path, and an unwritable --work-dir, before any leg exists #524's adopt-work-dir-unwritable says the same), and the body explains the choice.
• Suggested wording: "Each clone the split makes of the source would stop at it, unable to checkout working tree, so execute refuses it before it makes either leg, whatever the plan answers for it."

NIT-2: a malformed tree is named "git refuses as a path", but the clone exits 0

• Case (probe S/probe/p6.py). A tree holds blob odd/x beside tree odd/x/ (git fsck: duplicateEntries).
• Head: FINDING plan-path-git-refuses ... odd/x`` and "Each clone ... stops at it".
• But git clone exits 0, and git status in the clone shows D odd/x: the checkout dropped the file.
• c7a3ff1 said plan ok, exit 0. So head is better than base here, but the finding's words are wrong for this case.
• update-index --index-info replaced odd/x with odd/x/y; it did not refuse the path. This is rare: GitHub's fsck rejects such a push.

NIT-3: the L1-92 row says "(--work-dir or its default), not TMPDIR"

• The default work directory is itself made in TMPDIR: _work_root, adopt-project.py:15675-15678, tempfile.mkdtemp(prefix="openreposhape-adopt-").
• So without --work-dir, the repositories sit under $TMPDIR/openreposhape-adopt-*/. The p1 log shows .../tmpdir/openreposhape-adopt-hmaj8wiy/openreposhape-reencoded-....
• Suggested wording: "in the work directory (--work-dir, or the default one check makes in TMPDIR), never in TMPDIR itself".

NIT-4: beside a refused path, plan-file-reencoded goes unasked

• Evidence (probe S/probe/p5.py). The source has * text eol=lf, two kept CRLF files, and ..:
  • with ..: exit 1, only plan-path-git-refuses;
  • without ..: exit 1, plan-file-reencoded names more.txt and notes.txt.
• This is by design: if refused: return [] at adopt-project.py:11404, the docstring, and the row test_the_rehearsal_asks_nothing_more_of_a_tree_git_refuses. The body does not say it.
• Fix: one sentence in the body. Optionally, the finding could say that check asks about the files once the path is gone.

NIT-5 (test strength, equivalent mutants)

• M3 (git init without --template=<empty>) survives. The -c core.hooksPath already disables hooks, so no row shows what the empty template adds, for example a template that carries info/attributes or config.
• M17 (the attributes probe's check-attr without hooks_off) survives. It is equivalent: check-attr runs no hook, and _probe_env empties the global config.
• M16 (_entry_findings swallowing the path question's _Unasked) survives. The later rehearsal fails the same way, so the output is unchanged. The resume steps check whether some plan skips the later rehearsal.

Verified (with evidence)

1. Nothing is left behind, and no hook runs

Probe S/probe/p1.py, results under S/p1/. TMPDIR was an empty directory per run, and a git wrapper first on PATH logged every call.

• Configs tried:
  • core.hooksPath in both GIT_CONFIG_GLOBAL and GIT_CONFIG_SYSTEM, plus a core.fsmonitor hook;
  • init.templateDir in global and system, each with marker hooks;
  • GIT_TEMPLATE_DIR;
  • GIT_CONFIG_PARAMETERS;
  • GIT_CONFIG_COUNT.
• Layouts: basic (root .gitattributes), nested (.github/.gitattributes above a pinned copy) and linked (.github -> ../outside-ci), with SHA-1 and SHA-256 sources.
• check --work-dir: the work directory and TMPDIR were empty afterwards in every run. Hook runs: 0.
• check with the default work directory: TMPDIR was empty afterwards (the default openreposhape-adopt-* was removed). Hook runs: 0.
• execute: 94-110 hook runs, all in its own repositories (work-exec/Northwind, .git/modules/*, the source's receive hooks). There were 0 in any openreposhape-attributes-*, openreposhape-reencoded-* or symlinks-probe-* directory. TMPDIR was empty afterwards.
• The -c on every call: all 117 git calls made in throwaway directories carry -c core.hooksPath=<scratch>/empty. Each git init there is init -q --template=<scratch>/empty --object-format=<fmt>.
• Object format: with the SHA-256 source, all 6 inits were --object-format=sha256 and the result was exit 0, plan ok.

2. plan-path-git-refuses (probe S/probe/p2.py, one source per path)

Each case was compared with git clone of the same source under the same config.

• Named exactly once, and the clone fails (exit 128):
  • .., ., .git (file), .GIT/x, odd/.gIt/x, odd/.git, odd/.., odd/.;
  • odd/GIT~1/x, git~1/x, odd/.git./x, odd/.git /x, odd/.git::$INDEX_ALLOCATION/x;
  • the symlink .gitmodules, the symlink odd/GITMOD~1, and the literal entry odd/x/ (a name with a trailing slash).
• Not flagged, and the clone succeeds:
  • odd/GI7EBA~1/x, and by default odd/.git\u200c/x and odd/.G\u200dIT/x;
  • ..x, .gitx/x, git~2/x, ..., .github-x, the symlink .gitmodulesx;
  • names holding a line break, a tab, ", Latin-1 \xe9, \xff\xfe, \x01, \x7f or a backslash;
  • a literal entry named a/b.
• core.protectHFS = true: both HFS names are then named, and the clone fails too.
• core.protectNTFS = false: the NTFS names are not flagged, and the clone succeeds.
• Mixed source: 5 refused paths (inside directories named with \n, \t, ", \ and the byte \xff) are named in the tree's order. The 4 odd but good names beside them are unflagged.
• 13 refused paths: 10 are named and the rest are counted.
• Agreement: the finding matched the clone in every case but NIT-2. An entry with an empty name makes plan itself refuse (ls-tree), which is outside this PR.
• execute: on odd/GIT~1/x, the mixed source and odd/x/, it exits 2 with REFUSED plan-path-git-refuses. "no leg repository was created", remotes/ is absent and the work directory is empty.

3. adopt-git-unasked (S/p3/*.out)

Case	Result
--work-dir mode 500	exit 1; one FINDING adopt-work-dir-unwritable and the one unmade NOTE; no git-failed. execute: exit 2, REFUSED adopt-work-dir-unwritable
--work-dir is a file	exit 2, REFUSED adopt-work-dir-unwritable ... (File exists) (#650, before any throwaway)
--work-dir below a file	exit 2, REFUSED ... (Not a directory)
init.defaultBranch = a..b	exit 1, one FINDING adopt-git-unasked: ... git init there exited 128: fatal: invalid branch name: init.defaultBranch = a..b. ... on one line; the work directory is empty afterwards
the same, default work directory	the same finding, naming $TMPDIR/openreposhape-adopt-*; TMPDIR is empty afterwards
the same, execute	exit 2, REFUSED adopt-git-unasked; remotes/ is absent

The exception is SHOULD-1 (submodule sources).

4. The index refused_paths writes (S/p4)

• The source's .git/index sha256 (203bfd2c...) and its mtime are identical before and after check.
• The only GIT_INDEX_FILE any git call saw was <work>/openreposhape-reencoded-*/repository/.git/index-paths, for -c core.hooksPath=... -c core.fsmonitor=false update-index -z --index-info.
• git 2.43 update-index -z --index-info: it prints Ignoring path .. and exits 0. It keeps a\nb, t\tab, q"uote, \xff\xfe, \x01ctl and back\slash (raw probe in S/gitt/t1).
• core.ignorecase = true (global, Linux, a proxy for the case-insensitive follow-up): case twins odd/Read/odd/read and odd/D/x/odd/d/x are not flagged. A separate plan-file-reencoded from the rehearsal's checkout is pre-existing behaviour.
• _reencoded_files_findings with a non-empty refused: it asks nothing (NIT-4).

5. Base check

• On c7a3ff16's adopt-project.py the new file gives 22 failed and 6 passed. The 6 that pass are exactly the controls:
  • [control-a-sha1-source];
  • test_a_path_git_takes_beside_them_is_no_finding;
  • test_the_counting_hook_runs_where_this_machines_config_reaches x2;
  • test_a_probe_git_makes_prints_the_same_finding_and_no_note;
  • test_the_splits_own_clone_refuses_that_setting_too.
• Afterwards adopt-project.py was restored with git checkout --, and the status is clean.

7. The PR body (so far)

• Checked and true:
  • 28 rows, with 22/6 on the base;
  • the gate arithmetic from the writer's shard numbers: 2,843 passed, 7 skipped, 32 shards;
  • the head tree equals 5425d73b's (4c2538e0);
  • the sibling trees 5248272d (with c9652c9) and 6765a21d (with 9c210eb), each re-run here with merge-tree;
  • the Measured "after" column for every row I re-ran.
• The follow-ups:
  • (a) is real: _resolved and _answers use mkdtemp with no dir and a plain git init, at :6972 and :7162. It is outside adopt-project.py check's throwaway repositories: a SHA-256 source, a tree path git refuses, a TMPDIR on another disk and this machine's hooks change the answers #910's State.
  • (b) is real: tests/test_adopt_reencoded_files.py:466 still says "in TMPDIR".
  • (c) is real: it is untested on a case-insensitive disk (proxy above).
• Problems: MUST-1, NIT-3 and SHOULD-1.

8. Style

• git diff --check c7a3ff16 abd1b984 is clean.
• The 996 added lines hold no line over 79 columns, no non-ASCII and no tab. adopt-project.py has 42 lines over 79 columns at the base and at head.
• The new file has 0 lines over 79 columns and no compound assert a and b.

Test counts

Each run used /usr/bin/python3 -m pytest -p no:cacheprovider, basetemp S/bt with retention failed, a stub gh first on PATH, GH_TOKEN=bogus-r1031, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null, GIT_SSH_COMMAND=false, LANES_LANE unset, and EMAIL set to the brief's r1031 address.

At head abd1b984:

• new file 28, test_adopt_reencoded_files.py 53, test_agents_md_codes.py 47, test_repo_hygiene.py 100, test_readme_windows_quoting_sentence.py 44, test_scaffold_leg_path_collisions.py 104: 376 passed;
• test_shape_doctor.py in 4 shards: 118, 110, 117, and 100 + 3 skipped, so 445 passed, 3 skipped;
• total 821 passed, 3 skipped, 0 failed.

On the main trial merge:

• the same six files: 376 passed;
• set 2 (test_adopt_execute_refusals.py, test_adopt_plan_value_order.py, test_adopt_plan_yaml_quoting.py, test_adopt_template_values.py, test_adopt_nested_attributes.py, test_adopt_root_symlinks.py) was stopped at about 85% for the checkpoint: 888 passed, 0 failed so far.

Mutants (22 run; each against the new file, then restored)

Id	Mutant	Result	Rows that killed it
M1	the throwaway back in TMPDIR (dir=None)	killed, 3	the work-dir row, the unasked row, the unmade row
M2	hooks_off = []	killed, 2	both no-hook rows
M3	no --template=<empty>	SURVIVED	equivalent while hooksPath is set
M4	no --object-format	killed, 6
M5	the refused finding dropped	killed, 5
M6a	the rehearsal's asked() raises git-failed	SURVIVED	SHOULD-2
M6b	a failed throwaway git init raises git-failed	killed, 2
M6c	_Unasked's code is git-failed	killed, 2
M7	update-index --index-info without -z	killed, 14
M8	ls-files without -z	killed, 14
M9	_reencoded_files_findings ignores refused	killed, 5
M10	the probe no longer catches CommandFailed/Refusal	killed, 3
M11	the rehearsal's throwaway not removed	killed, 3
M12	the rehearsal's git() without hooks_off	killed, 2
M13	_stored_as_written without hooks_off	killed, 2
M14	object_format always sha1	killed, 4
M15	the unmade case is a finding, not a NOTE	killed, 1
M16	_entry_findings swallows the path question's _Unasked	SURVIVED	pending, resume step 2
M17	the attributes probe's check-attr without hooks_off	SURVIVED	equivalent
M18	_throwaway lets the OSError through	killed, 1
M19	the probe's NOTE not printed	killed, 1
M20	refused_paths answers nothing	killed, 6

The script is S/probe/mut.py, with logs in S/mut/*.log and S/mut/batch2.txt.

Merges

• fetch origin main (with --no-write-fetch-head): main is 5b41d44fcc96 and contains e2f9fc42.
• fix/901-plan-value-order is gone from origin: adopt-project.py: check and execute ask a plan's org: and id: before its leg paths and branch names, a pins: entry _read_pins names is that one finding, and a digest_source: finding says how the digest was read (#901) #1015 MERGED as e2f9fc424957, last head 2ede5101e62f.
• fix/900-spelled-names newest is 18cc65939e58 (PR adopt-project.py: the split commit's message and plan's report name each path, question and rule id one way only and never raw, the history scan's git-failed is one line, and the table pads a name as stdout prints it (#900) #1030, OPEN).

git merge-tree --write-tree abd1b984 <X>:

X	Exit	Tree
main 5b41d44	0	4526352524d67ced3c4c577aebc82d6d3c6d17f3
900 18cc659	0	0ac6fd0d306508816cce686e0ba934f9a25322b8
901 2ede510	0	3837a195a8976de353c6d02b4bee60b0122a2217

The main merge is built in a git clone --shared of /workspace/projects/openRepoShape at S/merged-main: commit 5b98cedfe3db (parents abd1b984 and 5b41d44f), tree 45263525. Its tests are above.

Resume steps (after the 10:00Z reset)

1. Run git status --short in the worktree (expect it empty, HEAD abd1b984) and df -i /workspace.
2. SHOULD-1: re-run p7 into a new base dir and print the whole REFUSED block, to name the command:
   S/probe/env.sh /usr/bin/python3 S/probe/p7.py <worktree> S/p7b, with the print widened from l[:330] to the full stderr.
   Expect _resolved's git init -q <TMPDIR>/openreposhape-url-*.
3. M16: read the early returns of _reencoded_files_findings (adopt-project.py:11383-11406). Find a plan that never reaches with _SplitRehearsal (one that keeps no file to ask about) and run it under init.defaultBranch = a..b. If head gives adopt-git-unasked and M16 gives plan ok, that is a SHOULD with a row.
4. Re-run main-merge set 2 in S/merged-main, split into two calls under 9 minutes:
   • (a) test_adopt_execute_refusals.py, test_adopt_plan_value_order.py, test_adopt_plan_yaml_quoting.py;
   • (b) test_adopt_template_values.py, test_adopt_nested_attributes.py, test_adopt_root_symlinks.py.
5. Optional: build the 900 merge (tree 0ac6fd0d) the same way and run the new file there.
6. Re-fetch main. If it has moved past 5b41d44f, run merge-tree again.
7. Decide the verdict and write c1031-r1031.md with the full report.

Lean so far: the only MUST is a body sentence (MUST-1), and the code behaves as #910 asks on every case I ran.

[brettheap]

(lane openRepoShape-1, 2026-10-20T10:21:07Z)

r1031 review of PR #1031 (closes #910), written at the usage checkpoint.

Verdict

NOT READY at abd1b984. Its PR body held false sentences (MUST-1), and no row pinned asked() (SHOULD-2).

NOT READY at b83d9c022eb32654691c765bd184fd98083005a9 (round 1), on one PR-body phrase only (MUST-A below).

• The code and tests at b83d9c02 hold up for me: the new row kills M6a, and every changed sentence in the code is true.
• No new head is needed. Once lane 1 edits that one body phrase, my verdict is READY at b83d9c02, with no re-run.
• Two of the four test_shape_doctor.py shards were not re-run at b83d9c02 (see "Not verified").

State at stop:

• The worktree /workspace/projects/openRepoShape-worktrees/r1031-check-throwaway-repos is detached at b83d9c02, and git status --short is empty.
• No mutant is applied.
• No process of mine is running.
• My scratch is /workspace/projects/openRepoShape-worktrees/_lane1-scratch/r1031/ (S/ below).

Findings at b83d9c02 and the live body (most severe first)

MUST-A (PR body only, one phrase)

• The sentence. The L1-90 row now ends: "Beside such a path, plan-file-reencoded is not asked: the refused path is the one finding until it is renamed."
• Why it is false. Read as written, it says no other finding prints beside plan-path-git-refuses. Other findings do.
• Evidence (S/p2/default/gitmodules-symlink/check.out). A source whose .gitmodules is a symlink, answered root, makes check exit 1 with two findings: FINDING plan-path-git-refuses ... .gitmodules`` and FINDING plan-submodule-root: .gitmodules` has leg: root ...`.
• The code. Only _reencoded_files_findings stops on a refused path (if refused: return [], adopt-project.py:11404 at abd1b984). The nested-attributes, root-attributes and every other check still run.
• Fix. "Beside such a path, plan-file-reencoded is not asked: plan-path-git-refuses stands in its place until the path is renamed."

NIT-A (not blocking)

• The sentence. The module docstring (adopt-project.py:113-115) says of the symlink probe: "where git cannot make it, a symlink is taken to check out as one, and a NOTE says why".
• Where it falls short. It holds for a git init that fails (CommandFailed or Refusal). It does not hold where the probe's directory cannot be made (OSError): there the probe adds no NOTE (the row test_a_work_directory_the_probe_cannot_write_gives_no_note). adopt-work-dir-unwritable says it instead.
• Fix. Add "(where the directory itself cannot be made, adopt-work-dir-unwritable says so)", or leave it as it is.

Carried from the partial review at abd1b984, now resolved or tracked

Finding	Status
MUST-1 ("Every throwaway repository" / "Every git command in them")	Fixed in the body. L1-90 names the symlink probe as the exception, and L1-94 lists the three plus "the symlink probe's git init and git config --get run no hook". The code side is fixed in round 1 (module docstring, _entry_findings, the comment above PATH_GIT_REFUSES, the test docstring). Each sentence was checked against p1's evidence: the probe's 6 calls carry no -c, with 0 hook runs.
SHOULD-1 (submodule source stops with a git or gh command failed)	Tracked as #1032 in the body. The command is now confirmed (below); it is outside #910 and was not a regression (_answers is unchanged code).
SHOULD-2 (M6a survived)	Fixed. The row test_a_step_git_fails_in_the_rehearsal_is_one_finding_in_its_words kills M6a.
NIT-1 (finding text)	Fixed. It now reads "Each clone the split makes of the source would stop at it, unable to checkout working tree, so execute refuses it before it makes either leg". That matches my execute runs: exit 2, no remotes/, an empty work directory.
NIT-3 (L1-92, TMPDIR)	Fixed in the body: "(--work-dir, or the default one check makes in TMPDIR), never TMPDIR itself".
NIT-4 (plan-file-reencoded unasked)	Said in the body, but see MUST-A for the wording.
NIT-2 (malformed tree)	Open, not blocking. A tree with blob odd/x beside tree odd/x/ (git fsck: duplicateEntries) is named plan-path-git-refuses ("git refuses as a path ... would stop at it"), but git clone exits 0 and drops the file. c7a3ff1 said plan ok, so this is still an improvement.
NIT-5	Unchanged: the equivalent mutants M3 and M17, and M16 (below).

SHOULD-1, confirmed command (S/probe/p7b.py). The source has a registered submodule with an absolute url.

• Under init.defaultBranch = a..b, the refusal is REFUSED a git or gh command failed. THE EXACT COMMAND WAS: git init -q <TMPDIR>/openreposhape-ask-4q8yrx69, exit 128, fatal: invalid branch name: init.defaultBranch = a..b.
• Under GIT_DEFAULT_HASH=bogus, it is the same command, with fatal: unknown hash algorithm 'bogus'.
• That is _answers (adopt-project.py:7162-7166).

M16 is equivalent.

• _reencoded_files_findings has no early return before its with _SplitRehearsal except if refused: (adopt-project.py:11381-11406). So where the path question's rehearsal cannot be made or asked, the later rehearsal fails the same way, and the same adopt-git-unasked prints at the same place.
• No row can tell M16 apart. That is no finding.

Verified

1. Nothing is left behind, and no hook runs

Probe S/probe/p1.py, with TMPDIR an empty directory and a git wrapper first on PATH.

• Configs tried:
  • core.hooksPath in both the global and system config, plus a core.fsmonitor hook;
  • init.templateDir in global and system;
  • GIT_TEMPLATE_DIR;
  • GIT_CONFIG_PARAMETERS;
  • GIT_CONFIG_COUNT.
• Layouts: basic, nested-attributes and root-symlink, with SHA-1 and SHA-256 sources.
• check: for both check --work-dir and check with the default work directory, nothing was left in the work directory or in TMPDIR, and there were 0 hook runs.
• execute: 94-110 hook runs, all in its own repositories, and 0 in any throwaway directory.
• The -c on every call: all 117 git calls in the throwaway directories carry -c core.hooksPath=<scratch>/empty.
• Object format: with the SHA-256 source, all 6 inits were --object-format=sha256, and the result was plan ok.

2. plan-path-git-refuses (probe S/probe/p2.py)

One source per path, compared with git clone of the same source under the same config.

• Named exactly once, and the clone fails (exit 128):
  • .., ., .git, .GIT/x, odd/.gIt/x, odd/.git, odd/.., odd/.;
  • odd/GIT~1/x, git~1/x, odd/.git./x, odd/.git /x, odd/.git::$INDEX_ALLOCATION/x;
  • the symlinks .gitmodules and odd/GITMOD~1, and a literal odd/x/.
• Not flagged, and the clone succeeds:
  • GI7EBA~1;
  • the HFS names (.git plus U+200C, .G U+200D IT) by default;
  • ..x, .gitx/x, git~2/x, ...;
  • names holding a line break, a tab, a quote, Latin-1, bytes 0xFF 0xFE, 0x01, 0x7F or a backslash.
• core.protectHFS = true: the HFS names are then named, and the clone fails too.
• core.protectNTFS = false: the NTFS names are neither flagged nor refused by the clone.
• Mixed source: 5 refused paths inside oddly named directories are named in the tree's order, and the good names beside them are unflagged.
• 13 refused paths: 10 are named and the rest are counted.
• execute refuses each before any leg.
• Agreement: the finding matched the clone in every case but NIT-2.

3. adopt-git-unasked

Case	Result
--work-dir mode 500	exit 1; one adopt-work-dir-unwritable finding and one NOTE
--work-dir is a file, or below one	exit 2, REFUSED adopt-work-dir-unwritable (#650)
init.defaultBranch = a..b	exit 1, one adopt-git-unasked line in git's words; the work directory is empty afterwards (also so with the default work directory)
the same, execute	exit 2, REFUSED adopt-git-unasked, no remotes/

No case produced git-failed, except #1032's submodule case.

4. The index refused_paths writes

• The source's .git/index hash and mtime are unchanged after check.
• The only GIT_INDEX_FILE any git call saw is the throwaway's index-paths.
• -z round-trips a line break, a tab, a quote and non-UTF-8 names.
• core.ignorecase = true: case twins are not flagged.

5. Base check

• On c7a3ff1's adopt-project.py, the original 28 rows give 22 failed and 6 passed, and the 6 that pass are exactly the controls (checked by test id).
• The round-1 row passes at b83d9c02, and fails under M6a.

6. Merges

• Fetch: main is dc7cd49b; it contains e656199f (adopt-project.py: a kept or dropped name reaches the split commit and the pull request body unspelled, and _spelled, _shown and plan's report print text that reads as another name, or raw #900, landed from adopt-project.py: the split commit's message and plan's report name each path, question and rule id one way only and never raw, the history scan's git-failed is one line, and the table pads a name as stdout prints it (#900) #1030) and e2f9fc42 (adopt-project.py check and execute: one bad plan value is named in different orders, or by two or three findings, and two pin sentences say more than execute does #901).
• Merge exit codes: git merge-tree --write-tree exits 0 for every pair:

Merge	Tree
abd1b984 + main dc7cd49b	0356492a
abd1b984 + fix/977-lower-case-makefile 83b3671b	fa99cd04
b83d9c02 + main dc7cd49b	12af67b6
b83d9c02 + fix/977 83b3671b	68592e21

• Earlier: abd1b984 merged cleanly with main 5b41d44f (45263525), fix/900 18cc6593 (0ac6fd0d) and adopt-project.py: check and execute ask a plan's org: and id: before its leg paths and branch names, a pins: entry _read_pins names is that one finding, and a digest_source: finding says how the digest was read (#901) #1015's last head 2ede5101 (3837a195).

Tests on the abd1b984 + dc7cd49b merge. This is a git clone --shared at S/merged-main2, commit 57486054:

• the new file, test_adopt_reencoded_files.py, test_agents_md_codes.py, test_repo_hygiene.py, the readme-quoting test and the collisions test: 376 passed;
• test_adopt_execute_refusals.py, test_adopt_plan_value_order.py and test_adopt_plan_yaml_quoting.py: 718 passed;
• test_adopt_template_values.py, test_adopt_nested_attributes.py and test_adopt_root_symlinks.py: 313 passed;
• adopt-project.py: a kept or dropped name reaches the split commit and the pull request body unspelled, and _spelled, _shown and plan's report print text that reads as another name, or raw #900's seven changed test files: 367 + 354 = 721 passed;
• total 2,128 passed, 0 failed.

Tests on the abd1b984 + fix/977 merge (S/merged-977): the new file, test_adopt_reencoded_files.py and test_agents_md_codes.py: 128 passed.

7. The PR body (live, round 1)

• Checked and true:
  • the 28 rows plus 1, with 22/6 on the base;
  • the gate arithmetic: 2,843 passed, 7 skipped, 32 shards;
  • the round-1 gate: 29+53+156+445+104+100+47+44 = 978 passed, 3 skipped;
  • the head tree equals 5425d73b's;
  • the sibling trees 5248272d and 6765a21d;
  • every Measured "after" I re-ran;
  • the round-1 bullets: the new row kills M6a; the finding text and the docstrings are as stated.
• The follow-ups: _resolved and _answers (TMPDIR, hooks, and the git init stop) are real and outside adopt-project.py check's throwaway repositories: a SHA-256 source, a tree path git refuses, a TMPDIR on another disk and this machine's hooks change the answers #910. So are the TMPDIR docstring in test_adopt_reencoded_files.py and the ignorecase case twins on a case-insensitive disk.
• Problem: MUST-A.

8. Style

• git diff --check is clean for c7a3ff16..abd1b984 and for abd1b984..b83d9c02.
• No added line is over 79 columns, and none holds non-ASCII or a tab.
• There is no compound assert.

Mutants

22 were run at abd1b984 against the new file; the 4 that survived there were re-run at b83d9c02.

Id	Mutant	abd1b984	b83d9c02
M1	the throwaway back in TMPDIR	killed, 3
M2	hooks_off = []	killed, 2
M3	no --template=<empty>	SURVIVED	SURVIVED (equivalent while hooksPath is set)
M4	no --object-format	killed, 6
M5	the refused finding dropped	killed, 5
M6a	asked() raises git-failed	SURVIVED	killed by the new row
M6b	a failed throwaway init raises git-failed	killed, 2
M6c	_Unasked's code is git-failed	killed, 2
M7	update-index without -z	killed, 14
M8	ls-files without -z	killed, 14
M9	refused ignored	killed, 5
M10	the probe no longer catches CommandFailed/Refusal	killed, 3
M11	the rehearsal's throwaway not removed	killed, 3
M12	the rehearsal's git() without hooks_off	killed, 2
M13	_stored_as_written without hooks_off	killed, 2
M14	object_format always sha1	killed, 4
M15	the unmade case is a finding	killed, 1
M16	the path question's _Unasked swallowed	SURVIVED	SURVIVED (equivalent, see above)
M17	check-attr without hooks_off	SURVIVED	SURVIVED (equivalent)
M18	the OSError passes through _throwaway	killed, 1
M19	the probe's NOTE dropped	killed, 1
M20	refused_paths answers nothing	killed, 6

The script is S/probe/mut.py; its logs are in S/mut/, and the round-1 rows are in S/mut-r1/batch.txt.

Test counts

Each run used /usr/bin/python3 -m pytest -p no:cacheprovider, one basetemp S/bt with retention failed, a stub gh, GH_TOKEN=bogus-r1031, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null, GIT_SSH_COMMAND=false, LANES_LANE unset, and EMAIL set to the brief's r1031 address.

At abd1b984:

• the new file 28, test_adopt_reencoded_files.py 53, test_agents_md_codes.py 47, test_repo_hygiene.py 100, the readme-quoting test 44, the collisions test 104;
• test_shape_doctor.py in 4 shards: 118, 110, 117, and 100 + 3 skipped;
• total 821 passed, 3 skipped, 0 failed.

At b83d9c02:

• the new file 29, test_adopt_reencoded_files.py 53, test_agents_md_codes.py 47, test_repo_hygiene.py 100, the readme-quoting test 44, the collisions test 104, test_cli_reference.py 23, test_adopt_root_symlinks.py 156: 556 passed;
• test_shape_doctor.py shards 1 and 2: 118 and 110 passed;
• total so far 784 passed, 0 failed.

The merges: see section 6.

Not verified

• test_shape_doctor.py shards 3 and 4 (117, and 100 + 3 skipped) at b83d9c02. They passed at abd1b984. Since then, tests/test_shape_doctor.py is unchanged, and adopt-project.py changed only in a docstring, a comment and the plan-path-git-refuses text, which no doctor test reads. The writer's round-1 gate reports 445 passed, 3 skipped.
• The b83d9c02 + main merge: only merge-tree was run (exit 0). No tests ran in it; the delta is that same text and one test row.
• That adopt-project.py: _resolved and _answers still make their repositories in TMPDIR and run this machine's hooks, where #910 (#1031) moves check's throwaway repositories into the work directory #1032 and adopt-project.py: refused_paths' update-index -z --index-info is untested with core.ignorecase and case twins (a and A) on a case-insensitive disk #1033 exist as issues: I did not read them with gh.
• The case-insensitive disk: Linux only here. A global core.ignorecase = true was the proxy.
• A real TMPDIR on another file system: there was one file system here. Placement was proved by path.

Resume steps (only if lane 1 wants them)

1. Run doctor shards 3 and 4 at b83d9c02. The ids are in S/doctor-q02 and S/doctor-q03; run them with S/run.sh.
2. Re-read the live body (gh pr view 1031 --json body) for the MUST-A phrase. Once it is fixed, the verdict is READY at b83d9c02.

[brettheap]

(lane openRepoShape-1, 2026-10-20T10:45:10Z)

#1031 is READY at b83d9c02, on r1031's own condition (issuecomment-6288771656): "Once lane 1 edits that one body phrase, my verdict is READY at b83d9c02, with no re-run."

• The L1-90 row now uses the reviewer's exact wording: "Beside such a path, plan-file-reencoded is not asked: plan-path-git-refuses stands in its place until the path is renamed."
• Lane 1 lands it once tests on b83d9c02 is green, in lane 3's order: first green and gated goes first, one HOLD at a time.

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

(lane openRepoShape-1, 2026-10-20T11:33:40Z)

#1031 is NOT green, so lane 1's READY note (issuecomment-6289121998) is withdrawn until a fix round lands. CI's tests on b83d9c02 (run 39404718064) failed 2 of 18,765 tests:

• tests/test_adopt_check_throwaway_repos.py::test_the_splits_own_clone_refuses_that_setting_too: AssertionError: b''. This is adopt-project.py: check's throwaway repositories are made in the work directory with the source's object format and no hook of this machine's; a path git refuses is plan-path-git-refuses, a repository git cannot make there adopt-git-unasked (#910) #1031's own new test. It passes locally, so it is likely the git version on CI.
• tests/test_adopt_relative_submodule_url.py::test_an_absolute_url_resolves_nothing: an extra NOTE ending "...can write in." This is an existing test, and adopt-project.py: check's throwaway repositories are made in the work directory with the source's object format and no hook of this machine's; a path git refuses is plan-path-git-refuses, a repository git cannot make there adopt-git-unasked (#910) #1031's gate did not run it.

Lane 1's writer fixes both, with a full grep of tests/ for the files #1031 can reach, after the usage window resets at 15:30Z. Lane 1 holds no HOLD.

Lane: openreposhape-1 (openRepoShape-1)

[brettheap]

r1031, the independent review of #1031: READY at 74c17705. It found no MUST and no open SHOULD. All three round-2 conditions are met: the live body is accurate, #1083 is filed, and the merge runs on main 5e539a87 passed (2,584 passed, 0 failed). The landing pilot gates over the current main and takes the HOLD only when no lane holds one.

r1031's report, as written:

(lane openRepoShape-1, 2026-10-20T23:17:47Z)

r1031's final verdict on PR #1031 (closes #910). Report file: /workspace/projects/openRepoShape-worktrees/_lane1-notes-20261011/v11/c1031-r1031.md (ASCII only). The round-2 detail is in c1031-r1031-r2.md next to it.

Verdict: READY at 74c17705edc23d97b0869a47e8b6e7fb81a803a1

All three round-2 conditions are met:

1. The live body is right. It applies SHOULD-R2-1 and NIT-R2-1 accurately, and its counts are true (checked below).
2. Follow-up adopt-project.py check: follow-ups of PR #1031 (#910): on git 2.43 an init.defaultBranch git will not take passes check and execute stops after both legs exist; _resolved and _answers still use TMPDIR, hooks and a plain git init #1083 exists. It is OPEN and carries the measured table: its body names c7a3ff1, b83d9c0 and 74c1770.
3. Every merge run passed on the trial merge with main 5e539a87: 2,584 passed, 3 skipped, 0 failed.

The head has not moved. At 23:17Z, git ls-remote gives 74c17705 for fix/910-check-throwaway-repos, which matches the live PR's headRefOid. closingIssuesReferences is [910].

There is no MUST and no open SHOULD.

Merge runs on main 5e539a8

• git merge-tree --write-tree 74c17705 5e539a87 exits 0, tree 6670f0dc.
• It is built in a new git clone --shared at S/r3-merge, commit 1bd7ee81. The old clone is kept.
• The runs used the probe environment and one basetemp.

Run	Files	Result
B1	the new file, the relative-submodule-url, re-encoded files, nested attributes, root symlinks, empty symlinks and symlink-target-bytes tests	504 passed
B2	the execute-refusals, entry-paths, literal-names, project-is-the-source, split-branch and windows-paths tests	390 passed
B4	the submodules, history-gitlinks, submodule-url-answers, manifest-values and leg-path-collisions tests	410 passed (manifest values has 2 more rows since #1064)
(a)	test_adopt_plan_yaml_quoting.py	517 passed
(b)	the collisions, hygiene, agents-md-codes, readme-quoting and cli-reference tests	318 passed
(c), (d)	test_shape_doctor.py, shards q00-q03: 118, 110, 117, and 100 + 3 skipped	445 passed, 3 skipped
Total		2,584 passed, 3 skipped, 0 failed

Main has moved again since the runs. It is now c13c3985. The two new commits are bccae28 (test changes in five adopt test files) and c13c398 (bootstrap.py). Neither touches adopt-project.py or the new test file, and git merge-tree with c13c3985 exits 0 (tree d49e898c). I did not re-run on it; the landing gate covers the main it lands on.

The live body

• SHOULD-R2-1:
  • The measured a..b row now says "on git 2.43, execute then stops after both legs; see the follow-ups".
  • The "This PR's trade on git 2.43" section carries my table, and all three rows match my measurements.
  • It names adopt-project.py check: follow-ups of PR #1031 (#910): on git 2.43 an init.defaultBranch git will not take passes check and execute stops after both legs exist; _resolved and _answers still use TMPDIR, hooks and a plain git init #1083.
• NIT-R2-1: "stops none of the questions asked in its throwaway repositories" appears in both the "new" row and the paragraph heading.
• Counts: all true.
  • 29 rows, of which 24 fail and 5 pass on c7a3ff1, and the 5 are all controls.
  • The merge is clean against 5e539a87.
  • CI on 74c1770 ran git 2.55.0: 19,000 passed, 372 skipped.
  • r1031's earlier run: 1,302 passed on the 3559f637 merge.
  • The only closing keyword is "Closes adopt-project.py check's throwaway repositories: a SHA-256 source, a tree path git refuses, a TMPDIR on another disk and this machine's hooks change the answers #910".
• Not verified by me: w910's own partial merge-gate counts. My (c) and (d) runs now cover the doctor and collisions files, which those gates left out.

NITs left (none blocking)

• NIT-R2-2. Mutant N2 is caught only by test_adopt_relative_submodule_url.py, not by the new file. This is already in adopt-project.py check: follow-ups of PR #1031 (#910): on git 2.43 an init.defaultBranch git will not take passes check and execute stops after both legs exist; _resolved and _answers still use TMPDIR, hooks and a plain git init #1083.
• NIT-A. The docstring says "a NOTE says why" for the symlink probe. Where the probe's directory itself cannot be made, the probe adds no NOTE; adopt-work-dir-unwritable says it instead.
• NIT-2. A malformed tree (a blob and a tree both named odd/x, which git fsck calls duplicateEntries) is named plan-path-git-refuses, but git clone succeeds and drops the file. This is still better than c7a3ff1's plan ok.
• Body wording. "Before, check refused it before any leg" would be more exact as "Before, check refused it (git-failed) and execute refused it before any leg".

Self-correction

My earlier READY at b83d9c02 was wrong: my gate left out test_adopt_relative_submodule_url.py, which failed here too. Since round 2, my gates include all 19 test files that run this code in-process.

State

• The worktree is detached at 74c17705 and clean.
• adopt-project.py's sha256 on disk matches HEAD in the worktree and in r2-mut (fe264c11...), and in r3-merge (45776fb8...).
• No process of mine is running.
• Nothing was posted, committed or pushed.

Lane: openreposhape-1 (openRepoShape-1)

[sonarqubecloud]

Quality Gate passed

Issues
3 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]

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 2 days and 23 hours by commenting @sourcery-ai review. Upgrade to get a review now.