[brettheap]

What a person now sees

#1073 (#914) named a submodule beside a .gitmodules of its leg that holds no section. #1080 asked for the two states it left unnamed:

• a gitlink that no section registers, beside a .gitmodules whose sections register other paths;
• a gitlink in a leg whose index tracks no .gitmodules, where the copy git reads instead (an untracked file on this disk, or else HEAD's) does not register it either.

In both, a recursive clone of the leg exits 0 and leaves the gitlink's directory empty, and git submodule status there exits 128 with fatal: no submodule mapping found in .gitmodules for path 'vendor/lib' (measured on real legs, git 2.43). On main the doctor said nothing in either state. Now the placement row names each one, with that state's own way out:

• beside sections: "N submodule(s) sit beside a .gitmodules of their leg with no section for them, so nothing registers them and a recursive clone of the leg leaves each empty (shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080): ...; give each a section with its path and url in that .gitmodules, or, once that .gitmodules is staged (git add .gitmodules), remove its gitlink with git rm --cached <its path in the leg> in its leg"
• where the index tracks none: "N submodule(s) sit in a leg whose index tracks no .gitmodules, so nothing registers them and a recursive clone of the leg leaves each empty (shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080): ...; give each a section with its path and url in a .gitmodules added to its leg, or remove its gitlink with git rm --cached <its path in the leg> in its leg"

The --json names go under the same leg key, unregistered_submodules, and unregistered_beside says which state (other_sections or no_gitmodules).

A gitlink git counts as registered is not named. Beside an untracked .gitmodules with its section, or beside HEAD's copy with its section once git rm .gitmodules took the file away, git submodule status exits 0 and the row names nothing.

The change (shape-doctor.py)

• unregistered_gitlinks (shape-doctor.py:8769) compares each leg's gitlinks (every stage mode 160000 in ls-files --stage -z, read as bytes by leg_tracked_files) with the paths that the .gitmodules git reads registers. It runs only where adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's empty_gitmodules named none.
  • Where the index tracks a .gitmodules, it reads the file on this disk with registered_paths (shape-doctor.py:8848). A gitlink beside sections that register other paths is named other_sections.
  • Where the index tracks none, registered_unindexed (shape-doctor.py:8817) reads the copy git reads instead. It uses the order gitmodules_entry reads in (shape-doctor.py: a holder's .gitmodules is split at the first space and at every Unicode line break, and read through a regexp a UTF-8 locale cannot match, so a section name holding a space or a byte that is not UTF-8, or a url holding NEL or U+2028, gives the doctor another mount url than git and make siblings use #668), which is git's config_from_gitmodules:
    • the untracked file on this disk, read as registered_paths reads a tracked one;
    • else HEAD's copy, git config -z --blob HEAD:.gitmodules --list, read up to its first bad line (partial=True, then submodule_keys(..., working_tree=False)), as gitmodules_entry reads it;
    • else none.
  • A gitlink that copy does not register, or every gitlink where there is no copy, is named no_gitmodules.
• registered_by (shape-doctor.py:8875) is the reading both copies share: the last path each section gives, of a section git does not ignore, matched whole. The tests hold it to git submodule status (exit 128 vs 0) for:
  • other paths;
  • a section with no key;
  • vendor/lib then other (unregistered), and other then vendor/lib (registered);
  • a section named a/../b;
  • vendor/lib/ with a slash.
• other_sections_clause (shape-doctor.py:8239) and no_gitmodules_clause (shape-doctor.py:8264) are the two clauses, in adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's words. They are added to held_clauses after adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's (shape-doctor.py:8135).
• unregistered_clause (adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's) counts only legs with no unregistered_beside, through unregistered_beside (shape-doctor.py:8231). Its text is unchanged.
• audit_leg calls it (shape-doctor.py:9055) and writes the new key (shape-doctor.py:9072). The module docstring (shape-doctor.py:254-270) and the key comments (shape-doctor.py:659-674) say so.

Decisions the Direction left open

• Note or finding. Said, never a finding, the same kind as adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's clause. It never moves the row on its own: the row stays the note (kept submodule, or the .gitmodules question) or the ok (every submodule recorded) it was. Tested both ways.
• Which state, in --json. The leg entry gains unregistered_beside (other_sections or no_gitmodules), only on a leg in one of the new states.
  • The reason is built from detail alone, so the clause needs the state there.
  • A second list key per state would break "the same key".
  • adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's entry stays byte for byte, with no unregistered_beside, and a test holds that.
• How the sections are read. Through the doctor's one reading of a .gitmodules (gitmodules_listing + submodule_keys, shape-doctor.py: a holder's .gitmodules is split at the first space and at every Unicode line break, and read through a regexp a UTF-8 locale cannot match, so a section name holding a space or a byte that is not UTF-8, or a url holding NEL or U+2028, gives the doctor another mount url than git and make siblings use #668/shape-doctor.py and siblings.py: a .gitmodules section git ignores ([submodule ""], a name with a .. component, a url beginning with -) is still read as a member, where git says No url found and exits 128 #733): git config -z --list, not --get-regexp, whose .* skips bytes that are not UTF-8 under a UTF-8 locale.
  • The copy read is the one git reads: the file on this disk, tracked or not, else HEAD's where the index tracks none; the index's copy, where this disk lacks a tracked file, is shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 (follow-up).
  • A file on this disk that git refuses, or that is not a regular file, names nothing, tracked or untracked, as adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914 calls no such file empty.
• "Beside none" means that the leg's index tracks no .gitmodules and that no copy git reads instead registers the gitlink. Round 1 named every gitlink of such a leg. The review round reads the untracked file or HEAD's copy, as git does (M-1 below).
• Each remedy, typed in a real leg (typed_in, printed_git, as adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's):
  • Beside sections: git rm --cached alone exits 128 ("please stage your changes to .gitmodules") where that file has an unstaged edit. Typed as printed (git add .gitmodules, then git rm --cached vendor/lib), each exits 0 and the gitlink leaves the index.
  • Where the index tracks none: git rm --cached vendor/lib alone exits 0 with no file, beside an untracked one, and beside HEAD's copy after git rm .gitmodules. With no file, adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's staged remedy would not work: git add .gitmodules exits 128 ("pathspec '.gitmodules' did not match any files").
  • The section remedy, for each state: once the section is written, git submodule status exits 0 and the row names nothing. Where the index tracks none, the section goes in the untracked file or in a new one beside HEAD's, and the file is added.
• A gitlink whose name no report can carry (a control character, or bytes that are not UTF-8) is not named. leg_tracked_files already sets such names aside and reports them by repr under unwritable.
• The HEAD-copy test cases commit in the code leg. A test helper (pinned_at_its_head) makes the leg's new HEAD its pin: the root's gitlink, and commit and tree_sha256 in contracts/code-pin.yaml. So the verdict stays the placement row's.

Tests changed beside the new ones

stage_gitlink stages a gitlink in a leg with no .gitmodules, which is the "beside none" state. Three tests in tests/test_shape_doctor.py held the reason exactly, and each now expects the new clause, in the review round's words:

• test_both_classes_are_said_apart_in_one_row;
• test_a_submodule_in_the_leg_its_record_names_is_placed;
• test_a_submodule_in_the_other_leg_from_its_record_is_misplaced.

#914's sectionless test gains two asserts: no unregistered_beside, and one "nothing registers them" in the reason.

Review round

RV1092 reviewed b74efd6 (NOT READY). This round is one commit, a7169b0, on top of it.

• M-1 (unregistered_gitlinks: a gitlink git counts as registered was named). Fixed. Where the index tracks no .gitmodules, the doctor reads the untracked file on this disk, else HEAD's copy, and names only the gitlinks that copy does not register. git reads HEAD's copy there: measured, git submodule status exits 0 after git rm .gitmodules beside a HEAD copy that registers the gitlink. A refused or non-regular untracked file names nothing. no_gitmodules_clause, the BESIDE_NO_GITMODULES comment and the docstrings now say "a leg whose index tracks no .gitmodules". Five new cases hold this, each against git submodule status.
• S-1 (a .gitmodules the index tracks and this disk lacks). Left as it was, naming nothing. It is named as a limit, with shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093, in the module docstring and in unregistered_gitlinks' docstring: git reads the index's copy there, git add .gitmodules would stage the file's deletion, and no section can be written in it until it is restored.
• N-1 (tests/test_shape_doctor.py:8333). The docstring now says that each submodule is named in its own class's clause, and that shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080's clause then names both again.
• N-2. The module docstring's sentence with shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 also names a gitlink whose path is not UTF-8 (UNWRITABLE_IN_A_PLAN), and a .gitmodules git refuses, or a link on this disk, which git reads through.
• N-3 (Sourcery's block after the robot line). No change: the landing uses an explicit squash message.

Review round 2

RV1092d reviewed a7169b0 (READY, five NITs). This round is one commit, 83627b2, on top of it: docstrings in shape-doctor.py, one test case and one test helper. No code behaviour changes. Every string literal in shape-doctor.py outside a docstring or comment is the one it was (checked with ast: the dumps of the module with its docstrings left out are identical at a7169b0 and 83627b2), so #1073's clause and entry and every refusal code are unchanged.

• N-1 (shape-doctor.py:262-270, the limits sentence). It now lists every state in which git exits 128 and the doctor names nothing: the shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 state; "for a submodule whose path is not UTF-8 or holds a control character (UNWRITABLE_IN_A_PLAN); beside a .gitmodules that is unmerged; and beside a .gitmodules git refuses, or one on this disk that is not a regular file: a link, which git reads through, or a directory". unregistered_gitlinks' docstring (shape-doctor.py:8797-8800) says the same of the files the doctor cannot read as git does. A directory still names nothing: this is a docstring only.
• N-2 (shape-doctor.py:265-266 and 8787-8788). "neither printed way out is true until the file is restored" overstated: the removal typed as printed works, but it stages the file's deletion. Both docstrings now say that where git reads the index's copy, git add .gitmodules would stage the file's deletion, and no section can be written in it until it is restored (shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093). The S-1 line above says it the same way now.
• N-3 (tests/test_doctor_plan_overrides.py:544, case in-head-read-to-its-first-bad-line). HEAD's copy is OTHER_SECTION + b"!!!\n" + SECTIONED; git submodule status exits 128 and the gitlink is named under no_gitmodules. RV1092d's mutant (d), partial=True to partial=False in registered_unindexed (shape-doctor.py:8842), is now KILLED: 1 failed, 18 passed, 41 deselected, the failure being [in-head-read-to-its-first-bad-line] (assert None == 'no_gitmodules'). The file was restored and checked identical with cmp.
• N-4 (tests/test_doctor_plan_overrides.py:484, pinned_at_its_head). digest = tree_digest(leg, commit), from repo_shape (the import at :54), the sorted-ls-tree-r-v1 definition itself. import hashlib and the lines that built the records and the digest are gone. The pin written is byte for byte what it was: before the old lines were deleted, the three legs the in-head cases make gave the same digest both ways (55fc0d636adf..., c117d320b224... twice, same=True each time).
• N-5 (this body, "How the sections are read"). It now says: the file on this disk, tracked or not, else HEAD's where the index tracks none; the index's copy, where this disk lacks a tracked file, is shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 (follow-up). The line numbers above, and the Out of scope list, are brought to this head.

Tests at 83627b2, each file alone, under the same stub gh and environment as above:

• tests/test_doctor_plan_overrides.py: 60 passed in 53.35s
• tests/test_doctor_recorded_answers.py: 29 passed in 34.80s
• tests/test_doctor_next_is_a_command.py: 61 passed in 49.70s
• tests/test_shape_doctor.py (once): 445 passed, 3 skipped in 441.17s (0:07:21)
• tests/test_repo_hygiene.py: 100 passed in 1.63s
• tests/test_no_auto_maintenance.py: 60 passed in 5.70s
• pyflakes 4.0.0: no warning in shape-doctor.py; tests/test_doctor_plan_overrides.py has the same 28 fixture-argument warnings as at a7169b0, and no new one.

Merges at 83627b2, after a fresh fetch (git merge-tree --write-tree):

• with origin/main de75bf0, which this head contains: clean.
• with every open PR, listed live: tests.yml and release.yml: the full suite and the Python 3.9 jobs run on ubuntu-24.04, since the Ubuntu 26.04 that ubuntu-latest now gives out has no 3.9 for setup-python and runs out of /tmp under the suite (#1094) #1095, adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091, shape_materialize.py, adopt-project.py and bump-leg.py: a tag a clone holds without its commit is one it cannot answer for, check says a commit it cannot ask was not asked, and a pinned product YAML 1.1 or 1.2 reads as no text is quoted (#912) #1090, the family root's bootstrap.py: credential_advice and ended_on say a member's failed clone ends git's update with 1 before any checkout but a leg's lets it go on, and killed_said says git's update was itself killed, not that it went on (#1085) #1088, shape_materialize.py: the fetch for a branch's answer leaves out every refspec of the repository's own onto the branches' names, whatever its source, and every one that puts a branch under a name not its own, so family.py bump and bump-leg.py no longer fail where the remote has x and release/x and the repository's own git fetch origin works (#1066) #1087 and the family root's siblings.py: with a token in use, the clone and the fetch that carry it run in bootstrap.py's untraced() environment, so make siblings and family.py siblings write the token to no trace the caller asks git for (#1055) #1075. None touches shape-doctor.py or these tests. tests.yml and release.yml: the full suite and the Python 3.9 jobs run on ubuntu-24.04, since the Ubuntu 26.04 that ubuntu-latest now gives out has no 3.9 for setup-python and runs out of /tmp under the suite (#1094) #1095, shape_materialize.py, adopt-project.py and bump-leg.py: a tag a clone holds without its commit is one it cannot answer for, check says a commit it cannot ask was not asked, and a pinned product YAML 1.1 or 1.2 reads as no text is quoted (#912) #1090, the family root's bootstrap.py: credential_advice and ended_on say a member's failed clone ends git's update with 1 before any checkout but a leg's lets it go on, and killed_said says git's update was itself killed, not that it went on (#1085) #1088, shape_materialize.py: the fetch for a branch's answer leaves out every refspec of the repository's own onto the branches' names, whatever its source, and every one that puts a branch under a name not its own, so family.py bump and bump-leg.py no longer fail where the remote has x and release/x and the repository's own git fetch origin works (#1066) #1087 and the family root's siblings.py: with a token in use, the clone and the fetch that carry it run in bootstrap.py's untraced() environment, so make siblings and family.py siblings write the token to no trace the caller asks git for (#1055) #1075 are clean; adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 (8f5fd0f) conflicts in adopt-project.py, which shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside one whose sections register other paths or beside none, is named with its own way out, as #914 names one beside a .gitmodules with no section (#1080) #1092 does not touch, and main with adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 alone conflicts the same way.

Follow-up

Follow-up: #1093, reading the index's copy where this disk lacks the tracked .gitmodules.

Out of scope

#1080 has no "Needs a ruling" or "Documented limit" section. These are left as they were, and the module docstring names the first four as limits, with the two states that review round 2 (N-1) added to the second and the third:

• a .gitmodules the index tracks and this disk lacks (shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093);
• a gitlink whose path is not UTF-8 or holds a control character, which leg_tracked_files sets aside under unwritable;
• a .gitmodules git refuses, tracked or untracked, or a link or a directory on this disk. Measured: an untracked link to a file whose section is for another path gives status 128, and nothing is named;
• a .gitmodules that is unmerged: git reads no copy there (shape-doctor.py and siblings.py: a .gitmodules section git ignores ([submodule ""], a name with a .. component, a url beginning with -) is still read as a member, where git says No url found and exits 128 #733), and the doctor names nothing, as on main;
• refusal codes and every other word of the row.

Reproductions

Round 1. A leg with vendor/lib committed as a gitlink, cloned with --recurse-submodules (real git):

• beside [submodule "other"] path = other: clone exit 0, vendor/lib empty, git submodule status exit 128;
• beside no .gitmodules: the same.

The doctor at main (de75bf0) said nothing in either state.

Review round. unregistered_gitlinks against git submodule status, with one fresh leg per case (git 2.43), at b74efd6 and at a7169b0. In each case the leg's index tracks no .gitmodules:

case	status rc	b74efd6 names	a7169b0 names
no copy anywhere	128	vendor/lib	vendor/lib
untracked, registers it	0	vendor/lib (wrong)	nothing
untracked, other section	128	vendor/lib	vendor/lib
untracked, no section	128	vendor/lib	vendor/lib
untracked, git refuses it (bare path)	128	vendor/lib	nothing (limit)
untracked link to a file that registers it	0	vendor/lib (wrong)	nothing
untracked link to a file with another section	128	vendor/lib	nothing (limit)
HEAD's copy registers it, then git rm .gitmodules	0	vendor/lib (wrong)	nothing
HEAD's copy has another section, then git rm	128	vendor/lib	vendor/lib
HEAD's copy has a bare path, then git rm	128	vendor/lib	vendor/lib
HEAD's copy registers it, untracked other section on disk	128	vendor/lib	vendor/lib
HEAD's copy has another section, untracked file registers it	0	vendor/lib (wrong)	nothing
HEAD's copy registers it, git rm --cached .gitmodules	0	vendor/lib (wrong)	nothing

RV1092's 32-case probe, its script unchanged, agrees with git in 28 cases at b74efd6 and in 29 at a7169b0:

• The case that changed is "untracked .gitmodules that registers it" (M-1).
• The three that still differ are the named limits: a non-UTF-8 gitlink, a bare path key git refuses, and a tracked file missing from disk (shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093).

The new test cases, run with shape-doctor.py at b74efd6 (-k "no_section_registers or section_written"): 7 failed, 11 passed, 41 deselected.

• untracked-and-registering, untracked-and-refused and in-head-and-registering fail because b74efd6 names the gitlink ('no_gitmodules' == None).
• no-gitmodules, no-gitmodules-and-recorded, untracked-with-other-sections and in-head-with-other-sections fail only on the clause's new words.

At a7169b0 the whole file passes.

Tests

Each file was run alone at a7169b0's tree, under a stub gh (exit 97), GH_TOKEN=bogus, an empty GH_CONFIG_DIR and EMAIL=tests@openreposhape.invalid, as /usr/bin/python3 -m pytest -q -p no:cacheprovider --basetemp=<scratch> -o tmp_path_retention_policy=failed <file>:

• tests/test_doctor_plan_overrides.py: 59 passed in 42.73s
• tests/test_doctor_recorded_answers.py: 29 passed in 32.24s
• tests/test_doctor_next_is_a_command.py: 61 passed in 46.54s
• tests/test_shape_doctor.py (once): 445 passed, 3 skipped in 392.32s (0:06:32)
• tests/test_scaffold_leg_path_collisions.py: 104 passed in 3.07s
• tests/test_repo_hygiene.py: 100 passed in 1.50s
• tests/test_no_auto_maintenance.py: 60 passed in 4.26s
• Round 1 also ran tests/test_agents_md_codes.py (47 passed), tests/test_cli_reference.py (23 passed) and tests/test_update_add_codes_documented.py (6 passed). The review round changes no refusal code and no doc, so they were not re-run.
• pyflakes 4.0.0:
  • shape-doctor.py and tests/test_shape_doctor.py: no warning at b74efd6 or at a7169b0.
  • tests/test_doctor_plan_overrides.py: the same 28 fixture-argument warnings (redefinition of unused 'standard'/'project') at both, and no new one.

Mutants

Round 1, at b74efd6. Each was run against the new tests, then the file was restored and checked identical with cmp. Every one was KILLED:

• M1, beside-sections names nothing (return [], None): killed by 6 cases of test_a_gitlink_no_section_registers_is_said (other-sections, a-section-with-no-key, its-path-given-over, a-name-git-ignores, its-path-with-a-slash, other-sections-and-an-unstaged-edit).
• M2, beside-none names nothing: killed by [no-gitmodules] and [no-gitmodules-and-recorded].
• M3, the first path a section gives wins: killed by [its-path-given-over] and [its-path-given-last].
• M4, adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914's clause counts every leg's names: killed by 8 cases (one "nothing registers them" per reason).
• M5, beside none told to stage first: killed by [no-gitmodules] and [no-gitmodules-and-recorded].
• M6, a section's trailing / stripped: killed by [its-path-with-a-slash].
• M7, unregistered_beside not written: killed by 8 cases.

Review round, at a7169b0. Each was applied to shape-doctor.py and run with -k "no_section_registers or section_written", then the file was restored and checked identical with cmp. Every one was KILLED:

• (a) where the index tracks no .gitmodules, read no disk file (if False and os.path.lexists(disk)): 2 failed, [untracked-and-registering] and [untracked-and-refused].
• (b) skip HEAD's copy (return set() before it is read): 1 failed, [in-head-and-registering].
• (c) fold a refused untracked file into an empty set (registered_paths(disk) or set()): 1 failed, [untracked-and-refused].

Merges

git merge-tree --write-tree of a7169b0, after a fresh fetch:

• with origin/main de75bf0 (which this head contains): clean.
• with every open PR, listed live: adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091, shape_materialize.py, adopt-project.py and bump-leg.py: a tag a clone holds without its commit is one it cannot answer for, check says a commit it cannot ask was not asked, and a pinned product YAML 1.1 or 1.2 reads as no text is quoted (#912) #1090, the family root's bootstrap.py: credential_advice and ended_on say a member's failed clone ends git's update with 1 before any checkout but a leg's lets it go on, and killed_said says git's update was itself killed, not that it went on (#1085) #1088, shape_materialize.py: the fetch for a branch's answer leaves out every refspec of the repository's own onto the branches' names, whatever its source, and every one that puts a branch under a name not its own, so family.py bump and bump-leg.py no longer fail where the remote has x and release/x and the repository's own git fetch origin works (#1066) #1087 and the family root's siblings.py: with a token in use, the clone and the fetch that carry it run in bootstrap.py's untraced() environment, so make siblings and family.py siblings write the token to no trace the caller asks git for (#1055) #1075. None of them touches shape-doctor.py or these tests.
  • shape_materialize.py, adopt-project.py and bump-leg.py: a tag a clone holds without its commit is one it cannot answer for, check says a commit it cannot ask was not asked, and a pinned product YAML 1.1 or 1.2 reads as no text is quoted (#912) #1090, the family root's bootstrap.py: credential_advice and ended_on say a member's failed clone ends git's update with 1 before any checkout but a leg's lets it go on, and killed_said says git's update was itself killed, not that it went on (#1085) #1088, shape_materialize.py: the fetch for a branch's answer leaves out every refspec of the repository's own onto the branches' names, whatever its source, and every one that puts a branch under a name not its own, so family.py bump and bump-leg.py no longer fail where the remote has x and release/x and the repository's own git fetch origin works (#1066) #1087 and the family root's siblings.py: with a token in use, the clone and the fetch that carry it run in bootstrap.py's untraced() environment, so make siblings and family.py siblings write the token to no trace the caller asks git for (#1055) #1075: clean.
  • adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 (8f5fd0f): conflict in adopt-project.py, which shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside one whose sections register other paths or beside none, is named with its own way out, as #914 names one beside a .gitmodules with no section (#1080) #1092 does not touch. main and adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 alone conflict the same way.

Closes #1080

Lane: openreposhape-3 (openRepoShape-3)
🤖 Generated with Claude Code

Summary by Sourcery

Identify and explain unregistered gitlinks across additional .gitmodules states while matching Git’s registration semantics and preserving placement verdicts.

New Features:

• Report unregistered gitlinks beside unrelated .gitmodules sections or in legs whose index tracks no .gitmodules, including the applicable remediation.
• Expose the unregistered-submodule context through unregistered_beside in placement JSON output.

Bug Fixes:

• Align unregistered-gitlink detection with Git’s effective .gitmodules source and registration behavior, avoiding false reports when untracked or HEAD copies register the gitlink.

Enhancements:

• Split diagnostic clauses by .gitmodules state while preserving the existing sectionless diagnostic unchanged.
• Handle .gitmodules parsing edge cases and document cases that remain intentionally unsupported.

Documentation:

• Update shape-doctor documentation and diagnostic comments for the newly reported submodule states and known limits.

Tests:

• Add coverage for registration precedence, malformed and non-regular .gitmodules files, HEAD and untracked copies, remediation commands, JSON output, and unchanged verdict behavior.

[sourcery-ai]

Reviewer's Guide

Extends shape-doctor to identify unregistered gitlinks in legs with unrelated or absent .gitmodules files, classify them in JSON, and present state-specific note guidance without changing verdicts, backed by comprehensive Git-behavior and output regression tests.

Sequence diagram for state-specific unregistered gitlink guidance

sequenceDiagram
    participant Doctor
    participant Leg
    participant Gitmodules
    Doctor->>Leg: audit_leg
    Leg-->>Doctor: gitlinks and tracked paths
    alt .gitmodules absent from index
        Doctor->>Doctor: unregistered_gitlinks
        Doctor-->>Leg: unregistered_beside = no_gitmodules
        Doctor-->>Leg: Suggest add .gitmodules section or git rm --cached
    else .gitmodules has unrelated sections
        Doctor->>Gitmodules: registered_paths
        Gitmodules-->>Doctor: registered path set
        Doctor-->>Leg: unregistered_beside = other_sections
        Doctor-->>Leg: Suggest stage .gitmodules, add section, or git rm --cached
    end
    Doctor-->>Leg: Keep existing note or ok status

Loading

Entity relationship diagram for unregistered submodule JSON output

erDiagram
    LEG_ENTRY {
        string path
        string unregistered_submodules
        string unregistered_beside
    }
    GITMODULES {
        string section
        string path
        string url
    }
    GITLINK {
        string path
        string mode_160000
    }
    LEG_ENTRY ||--o{ GITLINK : names
    GITMODULES ||--o{ GITLINK : registers
    LEG_ENTRY }o--|| GITMODULES : may_hold

Loading

Flow diagram for detecting unregistered gitlinks

flowchart TD
    A[audit_leg] --> B[empty_gitmodules]
    B -->|No existing empty-section finding| C[unregistered_gitlinks]
    C --> D{.gitmodules in leg index?}
    D -->|No| E[unregistered_beside = no_gitmodules]
    D -->|Yes| F[registered_paths]
    F --> G{Gitlink path registered?}
    G -->|No| H[unregistered_beside = other_sections]
    G -->|Yes| I[No new finding]
    E --> J[Write unregistered_submodules and state to leg JSON]
    H --> J
    I --> K[Preserve existing status]

Loading

File-Level Changes

Change	Details	Files
Detect and classify gitlinks that are not registered by their leg’s .gitmodules, including legs with unrelated sections or no .gitmodules.	Compare staged gitlink paths against Git-parsed .gitmodules path mappings. Distinguish other_sections from no_gitmodules and preserve the existing sectionless behavior. Handle Git’s last-path semantics, ignored sections, exact path matching, malformed/unreadable files, and non-UTF-8/path edge cases. Invoke detection during leg auditing and emit unregistered_submodules plus optional unregistered_beside JSON fields.	shape-doctor.py
Add separate note clauses with state-specific remediation while keeping the existing placement verdict and sectionless clause behavior unchanged.	Report distinct guidance for adding a section or removing the gitlink in each state. Keep the new condition as a note rather than a finding and avoid duplicating the existing clause. Document the new JSON keys and behavior in module and key comments.	shape-doctor.py
Expand regression coverage for detection semantics, user-facing output, JSON shape, and remediation commands.	Test unrelated sections, missing section keys, repeated paths, ignored names, trailing slashes, unstaged edits, and absent .gitmodules. Verify registered paths are not reported and that both remediation workflows succeed. Update existing multi-clause and recorded-submodule expectations for the new no-.gitmodules clause. Exercise Git status exit codes and preserve the prior adopt-project.py and shape-doctor.py: a .gitmodules of whitespace is asked on every run, a dropped file whose blob the root also holds counts as root, _answered_legs is quadratic, and two validator code families have no placeholder row #914 output contract.	tests/test_doctor_plan_overrides.py tests/test_shape_doctor.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#1080	Detect each leg-index gitlink that is not registered by a path in that leg’s .gitmodules, including when the file registers other paths or is absent.	✅
#1080	Report those unregistered gitlinks under the leg’s unregistered_submodules key and explain the appropriate registration or removal remedy for each state, without changing the existing sectionless-file behavior.	✅

Possibly linked issues

• shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080: The PR implements issue shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080’s two missing unregistered-gitlink states, adds JSON details, and prints remedies tested in real legs.
• shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080: The PR compares leg gitlinks with registered .gitmodules paths and reports unregistered ones in both requested states.

---

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-3, 2026-10-21T04:10:22Z) Independent review RV1092 of #1092 at b74efd6: NOT READY, one MUST.

MUST

• shape-doctor.py:8768-8769 (unregistered_gitlinks): a gitlink git counts as registered is named. The leg's index holds no .gitmodules, but an untracked .gitmodules on disk has a section for the gitlink. git submodule status -- vendor/lib exits 0 (git reads the disk copy, tracked or not). The doctor still names code/vendor/lib under unregistered_beside: no_gitmodules with "nothing registers them" (confirmed end to end through placement()). In the tracked twin (a section added on disk but not staged) the doctor stays silent, so the same state gets opposite answers. Fix: in that branch read the disk copy as git does:

    registered = registered_paths(mount / adopt.GITMODULES) or set()
    named = [f"{rel}/{path}" for path in held if path not in registered]
    return named, (BESIDE_NO_GITMODULES if named else None)
  and add an untracked-and-registering case at tests/test_doctor_plan_overrides.py:468 (status rc 0, nothing named). Tried in the reviewer's clone: that probe then agrees with git, and the other untracked and no-.gitmodules cases are still named.

SHOULD

• shape-doctor.py:8770-8773: a tracked .gitmodules deleted from disk is missed. git reads the index copy and exits 128; the doctor says nothing. Read ':.gitmodules' when the disk has no copy (gitmodules_listing(mount, ["--blob", ":.gitmodules"], partial=True), then submodule_keys(..., working_tree=False)), or open a follow-up and name the limit in the module docstring.

NIT

• tests/test_shape_doctor.py:8333: the docstring "each submodule once" is now stale.
• A non-UTF-8 gitlink (UNWRITABLE_IN_A_PLAN) and a .gitmodules git refuses name nothing. Both are existing doctor policies; no change needed here.
• The PR body ends with Sourcery's appended summary after the robot line, as on adopt-project.py and shape-doctor.py: a .gitmodules with no section asks nothing and says how to remove it, a submodule beside one is named, so is a file's answered_paths: row with a /, and an identical drop counts as drop (#914) #1073. The authored tail is right.

Held

• Probes: 32 edge cases against git submodule status (trailing /, a/../b as name and in the value, a section with no key, a path given twice in both orders, an empty or missing name, a dash path, a key in capitals, a quoted value, case, UTF-8 and non-UTF-8, unstaged edits in both directions). 28 agree; the 4 that differ are listed above.
• Remedies typed in real legs:
  • beside sections: git rm --cached alone 128; git add .gitmodules then git rm --cached 0.
  • beside none: git rm --cached alone 0; the adopt-project.py and shape-doctor.py: a .gitmodules with no section asks nothing and says how to remove it, a submodule beside one is named, so is a file's answered_paths: row with a /, and an identical drop counts as drop (#914) #1073 order fails (git add .gitmodules 128).
  • the section remedy gives status 0 in both states.
  • a recursive clone exits 0 and leaves vendor/lib empty in both states.
• Doubts:
  • (a) unregistered_beside is needed (the clauses read only the leg entries), documented beside the other leg keys in shape-doctor.py, and asserted in 14 cases.
  • (b) the test_shape_doctor.py edits are forced by stage_gitlink, and no assertion is weakened.
  • (c) the clause on ok rows matches adopt-project.py and shape-doctor.py: a .gitmodules with no section asks nothing and says how to remove it, a submodule beside one is named, so is a file's answered_paths: row with a /, and an identical drop counts as drop (#914) #1073: its recorded case reads ok with its clause and next None. No doc sample goes stale.
• adopt-project.py and shape-doctor.py: a .gitmodules with no section asks nothing and says how to remove it, a submodule beside one is named, so is a file's answered_paths: row with a /, and an identical drop counts as drop (#914) #1073's strings: no string literal removed or changed. Only the new keys and the two new clauses were added.
• Mutants M1, M3, M5: all KILLED (6, 2, 2 cases). The file was restored, checked identical with cmp.
• Tests at the head, one at a time: test_doctor_plan_overrides 52 passed, test_doctor_recorded_answers 29 passed, test_doctor_next_is_a_command 61 passed. test_shape_doctor.py not re-run (W1080: 445 passed).
• merge-tree: clean with origin/main de75bf0 (contained) and with shape_materialize.py, adopt-project.py and bump-leg.py: a tag a clone holds without its commit is one it cannot answer for, check says a commit it cannot ask was not asked, and a pinned product YAML 1.1 or 1.2 reads as no text is quoted (#912) #1090, the family root's bootstrap.py: credential_advice and ended_on say a member's failed clone ends git's update with 1 before any checkout but a leg's lets it go on, and killed_said says git's update was itself killed, not that it went on (#1085) #1088, shape_materialize.py: the fetch for a branch's answer leaves out every refspec of the repository's own onto the branches' names, whatever its source, and every one that puts a branch under a name not its own, so family.py bump and bump-leg.py no longer fail where the remote has x and release/x and the repository's own git fetch origin works (#1066) #1087, the family root's siblings.py: with a token in use, the clone and the fetch that carry it run in bootstrap.py's untraced() environment, so make siblings and family.py siblings write the token to no trace the caller asks git for (#1055) #1075. adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 conflicts in adopt-project.py, the same as main plus adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 alone; shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside one whose sections register other paths or beside none, is named with its own way out, as #914 names one beside a .gitmodules with no section (#1080) #1092 does not touch that file.
• PR body: closingIssuesReferences [1080]; Closes shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080, then the Lane line, then the robot line; no other closing keyword; nothing above U+007F but the robot.

Lane 3's plan:

• Fix round F1092 takes M-1. Where the leg's index tracks no .gitmodules, the doctor reads it where git reads it: the file on this disk, else HEAD's copy, the order gitmodules_entry already uses (once measured). A refused file names nothing, as in the tracked branch. The clause then says the leg's index tracks no .gitmodules.
• S-1 goes to follow-up shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093: there neither printed way out is true until the file is restored.
• N-1 is fixed. N-2's two states and S-1's are named as known limits in the module docstring.
• N-3 needs nothing: the landing uses an explicit squash message.
• After that, the delta review RV1092d.

Lane: openreposhape-3 (openRepoShape-3)

[brettheap]

(lane openRepoShape-3, 2026-10-21T04:56:56Z) Independent delta review RV1092d of #1092 at a7169b0 (fix round 1 on b74efd6): READY. No MUST, no SHOULD, five NITs.

M-1 is fixed. Over 71 probe rows against git submodule status (git 2.43), no gitlink git counts as registered is named.

NIT

• shape-doctor.py:262-268 (limits sentence). It reads as a full list, but in three more states git exits 128 and nothing is named (measured):
  • a gitlink path with a control character, e.g. vendor/a<TAB>b. UNWRITABLE_IN_A_PLAN (:588) covers \x00-\x1f and \x7f, not only bytes that are not UTF-8;
  • a directory at .gitmodules. git reads nothing there and does not fall back to HEAD. b74efd6 named this state;
  • an unmerged .gitmodules (tracked branch). The PR body lists it; the docstring does not.

  Fix: "whose path is not UTF-8 or holds a control character (UNWRITABLE_IN_A_PLAN); beside a .gitmodules that is unmerged; and beside a .gitmodules git refuses, or one on this disk that is not a regular file: a link, which git reads through, or a directory". Or return set() for a directory in registered_unindexed, as git does.

• shape-doctor.py:265-266: "neither printed way out is true until the file is restored" overstates. In the shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 state the removal typed as printed works: git add .gitmodules exits 0 (it stages the file's deletion), then git rm --cached vendor/lib exits 0 and the gitlink is gone. Say what unregistered_gitlinks' docstring (:8785) says: git add .gitmodules would stage the file's deletion, and no section can be written until the file is restored.
• tests/test_doctor_plan_overrides.py:540-550: mutant partial=True -> partial=False in registered_unindexed (:8839) SURVIVES (18 passed). With a HEAD copy of OTHER + "!!!" + REG, git exits 128 and the head names vendor/lib (agrees); the mutant names nothing. A bare path in HEAD does not test this (git config --list exits 0 on a bare key). Add (OTHER_SECTION + b"!!!\n" + SECTIONED, False, "head", "no_gitmodules").
• Doubt (c), pinned_at_its_head (tests/test_doctor_plan_overrides.py:478-498): reuse repo_shape.tree_digest(leg, commit) (scripts/repo_shape.py:1409), the sorted-ls-tree-r-v1 definition itself, already importable beside parse_yaml (:55). Drop import hashlib and the record lines. Sonar does not flag the copy (the PR gate's new_duplicated_lines_density is 0.0); this is for one definition of the format.
• PR body, "How the sections are read": "else the index's copy" - the doctor never reads the index's copy; that state is shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093. Say so there.

Held

• Probes:
  • RV1092's probe.py unchanged: 29/32 agree. The 3 left are the named limits, and only the M-1 row changed from b74efd6 (re-run there).
  • F1092's repro.py unchanged: 13 rows, identical to its report.
  • New rows: HEAD refused whole (update = bogus, shallow = maybe) is 128 with nothing named, within the refused limit. HEAD read partly (bad line or bare url, before or after the section) agrees. HEAD giving the path twice, both orders, agrees. rm --cached .gitmodules with an untracked edit agrees (the refused edit is the limit). A leg with no commit agrees. A dangling link is 128 with nothing named, within the link limit.
• Clause typed as printed, in each state (untracked file with another section; HEAD's copy with another section after git rm .gitmodules; no copy; no commit):
  • git rm --cached vendor/lib alone exits 0 and the gitlink leaves the index;
  • a section, then git add .gitmodules, exits 0 and status then exits 0;
  • a recursive clone exits 0 and leaves vendor/lib empty (not tried for no commit).
• Strings (ast): nothing removed since main de75bf0. Since b74efd6 only the clause piece changed, plus HEAD:, rev-parse, -q, --verify and --blob, and one "/" f-string piece that the two branches now share. adopt-project.py and shape-doctor.py: a .gitmodules with no section asks nothing and says how to remove it, a submodule beside one is named, so is a file's answered_paths: row with a /, and an identical drop counts as drop (#914) #1073's clause, other_sections_clause and every refusal code are unchanged.
• registered_by is b74efd6's loop word for word.
• Doubt (a), the link limit: keep it. Following the link would break the no-link (lstat) rule.
• Doubt (b): measured, as above.
• Mutants: (a) KILLED [untracked-and-registering], [untracked-and-refused]; (b) KILLED [in-head-and-registering]; (c) KILLED [untracked-and-refused]. The file was restored each time, cmp identical.
• Tests at the head, one at a time: test_doctor_plan_overrides 59 passed, test_doctor_recorded_answers 29 passed, test_doctor_next_is_a_command 61 passed. test_shape_doctor.py not re-run (F1092: 445 passed, 3 skipped).
• merge-tree: clean with origin/main de75bf0 (contained) and with tests.yml and release.yml: the full suite and the Python 3.9 jobs run on ubuntu-24.04, since the Ubuntu 26.04 that ubuntu-latest now gives out has no 3.9 for setup-python and runs out of /tmp under the suite (#1094) #1095, shape_materialize.py, adopt-project.py and bump-leg.py: a tag a clone holds without its commit is one it cannot answer for, check says a commit it cannot ask was not asked, and a pinned product YAML 1.1 or 1.2 reads as no text is quoted (#912) #1090, the family root's bootstrap.py: credential_advice and ended_on say a member's failed clone ends git's update with 1 before any checkout but a leg's lets it go on, and killed_said says git's update was itself killed, not that it went on (#1085) #1088, shape_materialize.py: the fetch for a branch's answer leaves out every refspec of the repository's own onto the branches' names, whatever its source, and every one that puts a branch under a name not its own, so family.py bump and bump-leg.py no longer fail where the remote has x and release/x and the repository's own git fetch origin works (#1066) #1087 and the family root's siblings.py: with a token in use, the clone and the fetch that carry it run in bootstrap.py's untraced() environment, so make siblings and family.py siblings write the token to no trace the caller asks git for (#1055) #1075. adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 conflicts in adopt-project.py, the same as main plus adopt-project.py: check names what the clone's .git holds as git keeps refs, and asks a pin's file through the links the root keeps, so a link into .git or onto a pin's file is refused before any leg or adopted with the copy beside it (#904) #1091 alone. No open PR touches shape-doctor.py or these tests.
• PR body: closingIssuesReferences [1080]; ends Closes shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080, then the Lane line, then the robot line; no other closing keyword; shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 only as a limit or the follow-up; nothing above U+007F but the robot.
• CI at this head: SonarCloud and tests-git-bash pass; package fails (Python 3.9 runner, handled separately); tests read pending twice. Landing still needs tests green.

Lane 3's plan:

• A short fix round, F1092b, takes all five NITs before the landing. It rewrites the limits sentence (N-1, docstring only: the directory, the control character and the unmerged file are named as limits) and words shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093's state as its side effect (N-2). It adds the HEAD partial-read row, so mutant (d) dies (N-3), reuses tree_digest in pinned_at_its_head (N-4), and fixes the body sentence (N-5).
• Then a short delta review, and the pilot, chained behind tests.yml and release.yml: the full suite and the Python 3.9 jobs run on ubuntu-24.04, since the Ubuntu 26.04 that ubuntu-latest now gives out has no 3.9 for setup-python and runs out of /tmp under the suite (#1094) #1095's: tests.yml and release.yml: the full suite and the Python 3.9 jobs run on ubuntu-24.04, since the Ubuntu 26.04 that ubuntu-latest now gives out has no 3.9 for setup-python and runs out of /tmp under the suite (#1094) #1095 keeps package off the Ubuntu 26.04 runners, so main's push run stays green.

Lane: openreposhape-3 (openRepoShape-3)

[brettheap]

(lane openRepoShape-3, 2026-10-21T05:15:46Z) Independent delta check RV1092e of #1092 at 83627b2 (fix round 2 on a7169b0): READY.

All five RV1092d NITs are fixed as asked, and nothing else changed (2 files, +19/-16):

• N-1: the limits sentence (shape-doctor.py:262-270) now lists the shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 state, a control character, an unmerged file, and a file git refuses or one that is not a regular file (a link or a directory). It matches the RV1092d probe rows (tab gitlink, dangling link, directory: 128, nothing named).
• N-2: both docstrings say git add .gitmodules would stage the file's deletion, as measured (exit 0, then the index tracks none).
• N-3: in-head-read-to-its-first-bad-line kills mutant (d), partial=False: 1 failed, that case. The file was restored, cmp identical.
• N-4: pinned_at_its_head uses tree_digest(leg, commit), and hashlib is gone. The whole file passes.
• N-5: the body's "How the sections are read" now says the index's copy is shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093.

Held

• shape-doctor.py with its docstrings removed: the ast dump is identical at a7169b0 and 83627b2. String literals: 0 removed, 0 added.
• tests/test_doctor_plan_overrides.py, whole file, once: 60 passed in 51.84s. Other suites skipped as asked.
• merge-tree: clean with origin/main de75bf0 (contained; the result is the head's own tree) and with tests.yml and release.yml: the full suite and the Python 3.9 jobs run on ubuntu-24.04, since the Ubuntu 26.04 that ubuntu-latest now gives out has no 3.9 for setup-python and runs out of /tmp under the suite (#1094) #1095 (6031bf1).
• Body: closingIssuesReferences [1080]; ends Closes shape-doctor.py: a leg's gitlink that no .gitmodules section registers, beside a .gitmodules whose sections name other paths or beside none, is named by no row, though a recursive clone of the leg leaves it empty #1080, then the Lane line, then the robot line; no other closing keyword; shape-doctor.py: beside a .gitmodules that a leg's index tracks but this disk lacks, a gitlink with no section in the index's copy is not named, though git reads that copy and git submodule status exits 128 #1093 only as a limit or the follow-up; nothing above U+007F in the authored part but the robot (Sourcery's block holds a U+2019).
• CI at this head: SonarCloud and tests-git-bash pass; package fails (Python 3.9 runner, handled separately); tests reads pending. Landing still needs tests green.

NIT (optional)

• shape-doctor.py:268 and :8799: "beside a .gitmodules that is unmerged" is broader than the doctor. With .gitmodules unmerged and its disk copy resolved to another path's section only, git exits 128 and the doctor names code/vendor/lib under other_sections, agreeing with git. It names nothing only while the disk copy is the conflict (git refuses it) or registers the submodule. If wanted: "beside a .gitmodules that is unmerged, while its copy on this disk is the conflict or registers the submodule".

Lane 3's plan: this head lands as it is. The optional NIT goes with #1093, which rewrites the same limits sentence. The pilot (key 1092a, the squash files at lane 3's land/1092-*) is chained behind #1095's and starts once #1095 has LANDED, so package on main's push run runs on ubuntu-24.04. It waits for tests on this head, gates the predicted squash over main, then takes the HOLD.

Lane: openreposhape-3 (openRepoShape-3)

[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]

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 9 hours and 46 minutes by commenting @sourcery-ai review. Upgrade to get a review now.