adopt-project.py: `answered_paths:` also records each entry a leg's own walk puts elsewhere, so a directory split by hand out of an extension-majority fold no longer reads MISPLACED on the doctor's first run after `adoption verified` (#801) by brettheap · Pull Request #829 · opensoft/openRepoShape

brettheap · 2026-10-17T16:17:42Z

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

A v1.1.1 draft. It lands only after the v1.1.0 tag, in the order lane 3 posts.

What

execute now records each plan entry kept in a leg that covers a path the doctor's walk of THAT leg would dispute. Before, it recorded only what a walk of the whole source disputed, so a directory split by hand could pass adoption verified and then read MISPLACED on the doctor's first run.

answered_path_record also walks each leg's own files, as the doctor walks the leg after the split (_walked_in_each_leg).
It records each entry covering a path that walk puts in another leg, or leaves as a question.
Every row main writes is still written: the whole-source rule of adopt-project.py: record the plan's answers in project.yaml, so the doctor's placement row and the submodules: rows follow them #525 and adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes check and execute, then the doctor's first run says MISPLACED, and an emptied .gitmodules is asked on every run #655 is unchanged.
A plan left as plan wrote it gets main's record, byte for byte.
The doctor, scripts/repo_shape.py, and the comment execute writes above the block are unchanged.

Why (repro on main)

Measured on main bf1f099b, and again on 24a977c0, with git-filter-repo a40bce548d2c, a stub gh and execute --local-remote-dir.

#801's line (L1-83). The source's engine/ holds a.py, b.py, c.py and x.md. That is 3 of 4 .py, exactly the policy's extension_majority: 0.75, so plan proposes engine/ as code. The person splits that entry by hand: engine/c.py to spec, and a.py, b.py and x.md to code, each with a resolution:.

check says plan ok.
execute exits 0 with adoption verified.
shape-doctor.py --root <clone> --json exits 1 with MISPLACED (1 path): code/engine/x.md: spec by rule extension-majority. answered_paths: holds only engine/c.py.

The cause: answered_path_record walked the whole source, where engine/ folds to code, so x.md needed no row. The doctor walks the code leg, where engine/ is 2 of 3 .py (67%). That does not fold, so it reads each file by its own extension, and x.md is spec.

Other ways to the same disagreement, each probed the same way, and each fixed by this change:

The plan	The doctor's first run on main
`engine/c.py` answered `drop`	MISPLACED: `code/engine/x.md` (`bf1f099b`)
`engine/c.py` answered `root`	MISPLACED: `code/engine/x.md` (`bf1f099b`)
`notes/` (3 of 4 `.md`, so spec), `notes/c.md` moved to code	MISPLACED: `spec/notes/y.py` (`bf1f099b`)
nested: `engine/notes/x.md` under the folded `engine/`, `engine/c.py` to spec, `engine/notes/` kept in code	MISPLACED: `code/engine/notes/` (`24a977c0`)
the file left over has an extension no class names (`engine/q.zzz`)	COMPLIANT, but the placement row is `note` (a question), not `ok` (`bf1f099b`)
no split: `stuff/` (2 `.py`, 3 `.md`, no fold) listed file by file, `stuff/b.py` answered spec, the three `.md` answered code against their extension, `stuff/a.py` left as `plan` wrote it. The code leg's `stuff/` is 3 of 4 `.md` and folds to spec, over `a.py` too	MISPLACED: `code/stuff/` (`24a977c0`)

Two controls read COMPLIANT with the row ok on main, and still do:

a split whose remainder still clears 75% (engine/d.py added);
engine/ left as plan wrote it.

How

All of it is in adopt-project.py's answered_path_record.

_walked_in_each_leg (new). For spec and for code, it walks the files _answered_legs keeps in that leg, gitlinks left out as before. It returns, for each such path, the leg that walk gives it: its own entry's, or the folded directory's above it, read by the existing _walked_leg. A question is None.
The rule. An entry kept in a leg (not .gitmodules) is recorded when that leg's own walk does not put a path it covers in that leg, OR by the existing rule against the whole source's walk and what plan showed (adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes check and execute, then the doctor's first run says MISPLACED, and an emptied .gitmodules is asked on every run #655's F1). The rows are keyed by entry, as before, so an entry is written once.
A row is added only where that leg's own walk disputes the path. Outside .github/ and the names under Known limits, which the doctor sets aside, that is where main's doctor reads the path as MISPLACED or as a question on its first run.
Why a plan left as plan wrote it, over a source with no gitlink, gains no row.
- Each entry plan wrote is a walk entry, kept whole in the leg plan gave it.
- No directory above it can fold to another leg there, because at most a quarter of an entry's files read as another leg.
- Answers against their extensions are what can change a fold in a leg, as the stuff/ case shows. The rows they get are the ones the doctor needs.
What the doctor sets aside, this walk keeps (as the whole-source walk does).
- The files every repository carries (everywhere_patterns: names at the top of a leg, and .github/) change how no other directory folds.
- A name no report can carry can change a fold. That case is under Known limits.
The docstring says all this. Nothing the doctor reads changed.

Tests

tests/test_answered_paths_per_leg.py is new, with 19 tests. 14 fail on main, and 5 are controls that main passes.

Unit, answered_path_record records engine/x.md: the issue's split records engine/c.py (spec) and engine/x.md (code), each with the plan's resolution: and commit.
Unit, one parametrised test over 9 cases.
- The plans, each with the rows it needs: the issue, drop, root, a spec-majority split, a nested split (the row is the directory's, engine/notes/), a question left over, and stuff/'s answers that fold a file left as written (stuff/a.py recorded).
- The controls: the remainder clears 75%, which gives engine/c.py alone, as main writes; engine/ left whole, which gives no row.
Unit, byte for byte.
- engine/ kept whole beside a question answered (examples/) and an answer against a rule (docs/, adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes check and execute, then the doctor's first run says MISPLACED, and an emptied .gitmodules is asked on every run #655) gives exactly main's block: the comment and those two rows.
- engine/ alone gives "".
End to end, like test_an_adoption_answered_against_a_rule_is_compliant_on_first_run.
- The issue's split: the split's project.yaml records both rows, and the doctor's first run reads COMPLIANT with the row ok, spec/engine/ and code/engine/x.md each answered by its row.
- Parametrised over drop, the spec-majority split, the nested split, the question left over, stuff/, and both controls: each reads COMPLIANT with the row ok. Each manifest holds exactly the rows its legs need, and no answered_paths: key at all where none is needed.
adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes check and execute, then the doctor's first run says MISPLACED, and an emptied .gitmodules is asked on every run #655's tests still pass: tests/test_doctor_plan_overrides.py and tests/test_doctor_recorded_answers.py, unchanged.

Byte-identity of an unsplit plan, measured by hand on the merged tree. One plan was run by main 24a977c0 and by this branch, at the same paths with fixed commit dates: engine/ left whole, examples/ answered spec, docs/ answered code. Each split's project.yaml is 9,715 bytes. They differ only in the shape: pin, the commit of the standard that ran and its tree digest. With those two values normalised, cmp exits 0. Both trees' answered_path_record on that plan give the same 1,079 bytes.

Revert table. Each row ran in its own clone of the head 742fc2f1, over the new file and both #655 files (70 tests):

Change	Tests it fails
R1. The per-leg clause reverted, so `kept` is main's rule	the 14 new non-control tests: 14 failed, 56 passed. The 5 controls and both #655 files pass
R2 (a mutation, not a revert). Each leg's walk run over the whole source's files instead of its own	the same 14, plus #655's `test_an_entry_left_as_plan_wrote_it_is_no_answer_against_a_rule`: 15 failed, 55 passed. Walking each leg's OWN files is what keeps #655's F1

Runs, on the head 742fc2f1 (main 24a977c0 merged in), in two modes with /usr/bin/python3 -m pytest and a stub gh. The 98 files are those grep -l -E 'adopt-project|adopt_project|\bADOPT\b' tests/*.py names (less conftest.py), plus tests/test_shape_doctor.py, tests/test_scaffold_leg_path_collisions.py, tests/test_cli_reference.py, the two #655 files and the new one:

git-filter-repo on PATH: 6,904 passed, 13 skipped, 1 xfailed, over six groups. Every log names the head 742fc2f1, dirty 0, and ends EXIT=0.
git-filter-repo hidden (PATH=<stub gh>:/usr/local/bin:/usr/bin:/bin): 6,515 passed, 402 skipped, 1 xfailed. Every log names the same head, dirty 0, and ends EXIT=0.

Windows

CI is Linux only (#597). The new tests read every file back with read_text() and name only paths legal on NTFS.

Not in this PR

The doctor (shape-doctor.py) and scripts/repo_shape.py: unchanged, as the issue's direction says.
The comment execute writes above answered_paths:: unchanged, so a plan left as written keeps its bytes. It already says a row answers a path the policy called for another leg.

Known limits

A name the doctor sets aside can still change a fold.
- The doctor drops a tracked name with a control character, or a byte that is not UTF-8, before it walks a leg. Execute's walks keep it.
- So engine/ holding a.py, b.py, x.md and t<TAB>b.py folds to code (3 of 4) for plan and execute. The doctor sees 2 of 3 in the code leg and reads code/engine/x.md as MISPLACED.
- This happens with the plan left exactly as plan wrote it, on main and on this branch. Its cause is the doctor's set-aside, not a split, so it goes to Tracking: adopt-project.py, converting an existing repository in place #457's checklist and is not fixed here.
A .github/ split by hand can get a row the doctor never reads. The doctor sets .github/ aside in every leg. The row is harmless: it answers nothing the doctor asks.

Closes #801

🤖 Generated with Claude Code

Summary by Sourcery

Make answered-path recording account for each extracted leg’s own walk so manually split adoptions remain compliant on their first doctor run.

Bug Fixes:

Record adoption answers for paths that a split leg’s own policy walk places in another leg or leaves unresolved, preventing false MISPLACED results on the doctor’s first run after adoption.

Tests:

Add unit and end-to-end coverage for split directories, nested splits, unresolved paths, extension-based answers, and unchanged control cases.

…ject.py: `answered_path_record` also walks each leg's own files, so a directory split by hand no longer reads MISPLACED on the doctor's first run (#801) Checkpoint commit, ordered by the lane-1 coordinator. The fix in `answered_path_record` (new helper `_walked_in_each_leg`) and the new tests/test_answered_paths_per_leg.py. On the bytes before the last edit, 17 new tests plus tests/test_doctor_plan_overrides.py and tests/test_doctor_recorded_answers.py ran 67 passed, 1 failed; the one failure was the new end-to-end test's expected order of the doctor's `answered_paths` entries (spec leg first), swapped in this commit and not re-run. The two-mode runs, the revert table and the PR texts are still to do. Lane: openreposhape-1 (openRepoShape-1) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Lane: openreposhape-1 (openRepoShape-1) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

…wn walk puts elsewhere, so a directory split by hand out of an extension-majority fold no longer reads MISPLACED on the doctor's first run after `adoption verified` (#801) `engine/` holding `a.py`, `b.py`, `c.py` and `x.md` is 3 of 4 `.py`, exactly the 75% `extension_majority:`, so `plan` proposes it as code. Split by hand, `engine/c.py` to spec and the rest to code, the plan passed `check` and `execute` said `adoption verified`. The doctor's first run then said `MISPLACED (1 path)` for `code/engine/x.md`: `answered_path_record` walked the whole source, where `engine/` folds, and the doctor walks the code leg, where it is 2 of 3 and each file is read by its own extension. Now `answered_path_record` also walks each leg's own files (`_walked_in_each_leg`), as the doctor walks the leg, and records each entry kept in a leg that covers a path that walk puts elsewhere or asks about. The whole-source rule stays as it was, so every row main writes is still written. The doctor, `scripts/repo_shape.py` and the comment `execute` writes above the block are unchanged. A plan left as `plan` wrote it gets main's record, byte for byte. The same change also covers `engine/c.py` dropped or kept in the root, a directory the majority groups to spec, a nested split, and a question left over (a `note`, not `ok`, on main). tests/test_answered_paths_per_leg.py is new, with 17 tests: 12 fail on main, and 5 are controls main passes. Lane: openreposhape-1 (openRepoShape-1) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

… walk can also dispute a file left as `plan` wrote it, where answers against their extensions fold its directory in that leg, and the tests hold that case too (#801) A probe found one more way in, fixed by the same change. `plan` lists `stuff/`'s files one by one (2 `.py`, 3 `.md`, which do not fold). `stuff/b.py` is answered spec, the three `.md` code against their extension, and `stuff/a.py` is left as `plan` wrote it. Then the code leg's `stuff/` is 3 of 4 `.md` and folds to spec. On main 24a977c, `adoption verified` was followed by the doctor's `MISPLACED (1 path)`: `code/stuff/`. With this branch, `stuff/a.py` is recorded too, and the doctor reads COMPLIANT with the row `ok`. The docstring claimed that an entry `plan` wrote reads the same in its leg, which this case disproves. It now says a row is added only where the doctor's walk of that leg disputes the path, and that a plan left as `plan` wrote it, over a source with no gitlink, gets none. The new test file gains the case, as a unit row and an end-to-end adoption. Its plan edit now replaces every entry `plan` listed under a directory. Lane: openreposhape-1 (openRepoShape-1) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

sourcery-ai · 2026-10-17T16:17:57Z

Reviewer's Guide

Updates answered_path_record to account for how each leg’s files are independently walked by the doctor, adding only the placement rows needed after hand-splitting directories while preserving existing whole-source records; extensive unit and end-to-end tests cover regressions, controls, and byte compatibility.

Sequence diagram for per-leg answered path recording

sequenceDiagram
    participant Execute
    participant AnsweredPathRecord as answered_path_record
    participant WalkEachLeg as _walked_in_each_leg
    participant Walk as walk
    participant Doctor

    Execute->>AnsweredPathRecord: answered_path_record(policy, entries, tree, commit)
    AnsweredPathRecord->>WalkEachLeg: _walked_in_each_leg(policy, files, answered)
    loop Each extracted leg
        WalkEachLeg->>Walk: walk(policy, held)
        Walk-->>WalkEachLeg: paths assigned by the leg's own walk
    end
    WalkEachLeg-->>AnsweredPathRecord: path to walked leg or None
    AnsweredPathRecord->>AnsweredPathRecord: add rows where leg differs from own walk
    AnsweredPathRecord-->>Execute: answered_paths block
    Doctor->>Doctor: walk each leg independently
    Doctor-->>Doctor: read recorded rows as placement answers

Flow diagram for hand-split directory placement records

flowchart LR
    SourceWalk["Whole-source walk folds engine/ to code"] --> Split["Plan entry is hand-split"]
    Split --> SpecLeg["spec leg keeps engine/c.py"]
    Split --> CodeLeg["code leg keeps engine/a.py, b.py, x.md"]
    CodeLeg --> OwnWalk["Code leg's own walk does not fold engine/"]
    OwnWalk --> Dispute["x.md is disputed as spec"]
    Dispute --> Record["answered_paths records engine/x.md"]
    Record --> Compliant["Doctor's first run is COMPLIANT"]

File-Level Changes

Change	Details	Files
Make answered-path recording mirror each extracted leg’s own walk in addition to the existing whole-source checks.	Walk files retained by each spec/code leg independently, excluding gitlinks as before. Record an entry once when its leg-local walk places a covered path in another leg or leaves it unresolved, while preserving the existing whole-source/adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes `check` and `execute`, then the doctor's first run says MISPLACED, and an emptied `.gitmodules` is asked on every run #655 rule. Keep generated records byte-identical for unchanged plans and omit rows when no leg-local disagreement exists.	`adopt-project.py`
Add regression coverage for split-directory disagreements and preservation of existing behavior.	Cover the issue reproduction and variants involving dropped/root answers, spec-majority and nested splits, questions, and answers that alter a fold over a file left as planned. Verify control cases, byte-for-byte record compatibility, manifest contents, and first-run doctor compliance end to end. Retain coverage for existing adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes `check` and `execute`, then the doctor's first run says MISPLACED, and an emptied `.gitmodules` is asked on every run #655 behavior through the broader test suite.	`tests/test_answered_paths_per_leg.py`

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#801	Record an answered-path row for each plan entry whose path the doctor’s walk of that entry’s leg places elsewhere or leaves as a question, so a hand-split adoption is COMPLIANT on the doctor’s first run.	✅
#801	Preserve the existing whole-source answer-recording behavior and keep the generated record byte-identical for an unsplit plan.	✅

Possibly linked issues

adopt-project.py execute: a hand split inside a directory the extension majority groups is recorded against the whole source's walk, so the doctor, which walks each leg, says MISPLACED on its first run after "adoption verified" #801: The PR records entries such as engine/x.md when a leg’s walk disputes them, fixing the issue’s first-run doctor verdict.

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 · 2026-10-17T19:10:50Z

(lane openRepoShape-1, 2026-10-17T19:10:29Z) Lane 1's independent review of #829 at 742fc2f: PR-READY

I reviewed the head 742fc2f16727344e4ee27c64f7586f59c357a8b0 and a local-only merge of it with main bad05d21 (#723). The merge is clean: git auto-merged adopt-project.py, giving local 62fb90a1. I ran every probe with a stub gh (exit 97), GH_TOKEN=bogus-r801, an empty GH_CONFIG_DIR, GIT_CONFIG_GLOBAL=/dev/null and GIT_ALLOW_PROTOCOL=file, then plan, a plan edit, check, execute --yes --local-remote-dir, a --recurse-submodules clone of adopt/three-repo-shape, and shape-doctor.py --root <clone> --json.

No defect blocks this PR. Finding 1 is a known limit that was already on main; finding 2 is one sentence of the body.

The issue's line

Line	main `bad05d21`	head `742fc2f1`	merge `62fb90a1`
L1-83: `engine/` = a.py b.py c.py x.md, split with `c.py` to spec	`plan ok`, `adoption verified`, doctor exit 1 `MISPLACED (1 path)`: `code/engine/x.md spec extension-majority`; rows: `engine/c.py` only	exit 0, COMPLIANT, `placement: ok`	exit 0, COMPLIANT, `ok`; rows `engine/c.py` spec and `engine/x.md` code

L1-83 is fixed. I also measured each row of the body's "Why" table on main and on the merge, and each is as stated:

drop, root and the spec-majority split: MISPLACED on main, COMPLIANT ok on the merge.
The nested split: code/engine/notes/ MISPLACED on main, ok on the merge.
engine/q.zzz: COMPLIANT but note on main (question: code/engine/q.zzz), ok on the merge.
stuff/: code/stuff/ MISPLACED on main, ok on the merge, with stuff/a.py recorded.

Attack 1: does the per-leg walk walk what the doctor walks? Three more ways in, none of them in the tests, all MISPLACED on main and COMPLIANT ok on the merge:

A gitlink beside the split. engine/sub is a real submodule; .gitmodules and engine/sub are answered code, with c.py to spec and x.md to code. The same source left as plan wrote it (adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes check and execute, then the doctor's first run says MISPLACED, and an emptied .gitmodules is asked on every run #655's F1 shape) reads COMPLIANT with no answered_paths: on both trees.
A leg at a nested mount (code_path: legs/the-code): main says legs/the-code/engine/x.md MISPLACED.
Case twins (Engine/A.py and Engine/X.md beside engine/).

By reading the code:

The leg's paths are the source's paths (literal: filter-repo paths, no rename).
The doctor sets aside two kinds of name before it walks: the anchored everywhere_patterns, and names that match UNWRITABLE_IN_A_PLAN.
- The everywhere_patterns are the top-level files and .github/**. Since walk never folds the leg root, they change no other directory's fold.
- UNWRITABLE_IN_A_PLAN names are the one exception (finding 1).
ask_about_a_record_only touches only a top-level single-repository.yaml.

Model check. I generated random sources and random hand-edited plans, and simulated the doctor per leg with its own glob_to_regex, everywhere_patterns and UNWRITABLE_IN_A_PLAN, and with answered_questions' rule: every file under a disputed entry must be covered by exactly one row naming this leg.

Plans	main: a dispute left	Rows the merge adds that the doctor never reads
3,000 mixed	2	—
4,000 fold-sensitive	129	42 rows in 33 plans, every one under `.github/`
4,000 left as written, questions answered	0	0; the rows equal main's in 4000/4000

In every plan, the merge's rows were a superset of main's (an assert, never tripped).

Attack 2: an unsplit plan stays byte-identical. I ran three ordinary sources on main, then on the merge, at the same paths with fixed dates:

a Python and web repository with .github/;
one with the config.yaml and examples/ questions answered;
one with docs/ and mixed/c.md answered against their rules.

For all three, plan.yaml, plan/check stdout and stderr, and execute stderr are byte-identical. project.yaml differs only in shape: commit: and tree_sha256:. Execute's stdout differs only in the split sha, which embeds that pin. The doctor's JSON differs only in the standard's path and pin.

Attack 3: other readers of the record. update-shape.py never reads answered_paths:. validate-manifest.py checks the rows' shape and refuses overlapping rows. New rows come from plan entries, which never overlap. In execute, the record is only appended to project.yaml, and no command prints it. On the doctor's side, rows only remove findings: answered_questions needs exactly one row, and entries never nest. #655's two test files pass at the merge.

Attack 4: cost. I timed answered_path_record in-process. The cost is linear, about +50% on the walks:

Source	main	merge
20,000 files	2.03 s	3.07 s
100,000 files	11.22 s	16.91 s
5,000 files split file by file	2.20 s	2.52 s

In the last row, main's existing O(files × entries) _answered_legs dominates. There is no subprocess and no network call.

Findings, ranked

1. Not this PR's defect, confirmed and widened: any name the doctor sets aside, not only a tab, still yields MISPLACED after `adoption verified` (the body's Known limit 1)

The source's engine/ holds a.py, b.py, x.md and one more .py whose name has a set-aside character. The plan is left exactly as plan wrote it (engine/ code).

Name	main	merge
`t\tb.py`	`plan ok`, verified, `MISPLACED (1 path)`: `code/engine/x.md spec extension-majority`	same
`t\x01b.py`	—	same
`t\xffb.py` (not UTF-8)	—	same

I appended answered_paths: - path: "engine/" leg: code to the merge clone's project.yaml by hand. The doctor then exits 0, verdict COMPLIANT, placement note, saying "1 name(s) no report or plan can carry: 'engine/t\tb.py'".

So the follow-up fix is a filter in _walked_in_each_leg that drops those names, as the doctor does. It would add a row to a plan left as written for such a source, which the issue's byte-identity rule rules out here. That makes it a separate v1.1.x issue, as the writer judged. The body and docstring already say this honestly.

2. Text: one sentence of "How" overclaims

"That is exactly where main's doctor reads the path as MISPLACED or as a question" contradicts the body's own Known limit 2. The model check measured 42 added rows under .github/ that the doctor never reads; they are harmless. The replacement text is below.

Tests

I re-ran the revert table in clones of the head, over the new file and both #655 files (70 tests):

Row	Result
R1: the per-leg clause reverted	14 failed, 56 passed: exactly the 14 non-control tests
R2: each leg walked over the whole source	15 failed, 55 passed: the same 14 plus `test_doctor_plan_overrides.py::test_an_entry_left_as_plan_wrote_it_is_no_answer_against_a_rule`
R3 (mine): a question in a leg's walk read as agreement (`in_its_leg.get(path) not in (None, leg)`)	2 failed, 68 passed: both `a-question-left-over` cases

The counts match the body: 19 tests, 14 that fail on main, 5 controls. The asserts are honest: whole row lists, the doctor's verdict, the row status and answered_by.

My gate at the merge 62fb90a1, dirty 0, git-filter-repo on PATH:

the new file, both adopt-project.py and shape-doctor.py: a plan answer that overrides a confident rule passes check and execute, then the doctor's first run says MISPLACED, and an emptied .gitmodules is asked on every run #655 files, test_scaffold_leg_path_collisions.py and test_cli_reference.py: 197 passed, EXIT=0;
test_shape_doctor.py: 436 passed, 3 skipped, 1 xfailed, EXIT=0.

Windows. The change has no os.name path. The test paths are legal on NTFS, files are read back with read_text(), and tests-git-bash is green.

CI at the head. tests, tests-git-bash, package and SonarCloud all pass. SonarCloud reports 0 new issues and 0.0% duplication on new code. The only annotations are runner notices (Node 20 deprecation, the ubuntu-latest migration).

Texts. The title is true at the head. The body has the Lane line, a Claim line that matches the claim register (issuecomment-6233022004), Closes #801 and the robot line, in 10,263 characters. Sourcery appended its own summary after the robot line, which is the bot's doing, not the writer's.

Exact text replacements

Body, "How", replace:

A row is added only where the doctor's walk of that leg disputes the path. That is exactly where main's doctor reads the path as MISPLACED or as a question on its first run.

with:

A row is added only where that leg's own walk disputes the path. Outside .github/ and the names under Known limits, which the doctor sets aside, that is where main's doctor reads the path as MISPLACED or as a question on its first run.

Optional, in the docstring, at the next commit only: "A row is added only where the doctor's walk of that leg disputes the path." → "A row is added only where this walk of the leg disputes the path; outside what the doctor sets aside (below), that is where the doctor's walk does."

For the checklist (#457)

Set-aside names in a folded directory (finding 1): a tab, any control character or a byte that is not UTF-8 gives MISPLACED after adoption verified, with a plan left as written, on main and on this branch. The fix is to drop UNWRITABLE_IN_A_PLAN names in _walked_in_each_leg, which gives COMPLIANT with placement note. It changes that source's project.yaml, so it needs its own issue.
.github/ split by hand: a row the doctor never reads. This is measured (42 rows in 33 of 4,000 plans) and harmless.
A directory row nobody wrote. An entry left as plan wrote it can be recorded when answers beside it fold its parent in the leg (stuff/a.py). If that entry is a directory, its row then answers every file added under it later, as any directory row does (adopt-project.py: record the plan's answers in project.yaml, so the doctor's placement row and the submodules: rows follow them #525). I found this by reading the code and did not run it end to end.
Cost on main: _answered_legs is O(files × entries). A 5,000-file plan split file by file takes 2.2 s in answered_path_record on main.

The body replacement above is applied (the PR body is edited; no push).

Lane: openreposhape-1 (openRepoShape-1)

sonarqubecloud · 2026-10-17T22:00:08Z

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 · 2026-10-17T22:02:20Z

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

Brett Heap and others added 4 commits October 17, 2026 11:05

Merge origin/main (24a977c) into fix/801-answered-paths-per-leg

27dfa08

Lane: openreposhape-1 (openRepoShape-1) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Merge branch 'main' into fix/801-answered-paths-per-leg

04e4c69

brettheap marked this pull request as ready for review October 17, 2026 22:02

brettheap merged commit dd72294 into main Oct 17, 2026
5 checks passed

brettheap deleted the fix/801-answered-paths-per-leg branch October 17, 2026 22:02

Navigation Menu

Repository navigation

adopt-project.py: `answered_paths:` also records each entry a leg's own walk puts elsewhere, so a directory split by hand out of an extension-majority fold no longer reads MISPLACED on the doctor's first run after `adoption verified` (#801) - #829

brettheap commented Oct 17, 2026 •

edited by sourcery-ai Bot

Loading

Uh oh!

sourcery-ai Bot commented Oct 17, 2026

Interacting with Sourcery

Customizing Your Experience

Getting Help

Uh oh!

brettheap commented Oct 17, 2026

Uh oh!

sonarqubecloud Bot commented Oct 17, 2026

Uh oh!

sourcery-ai Bot commented Oct 17, 2026

Uh oh!

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

brettheap commented Oct 17, 2026 • edited by sourcery-ai Bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

What

Why (repro on main)

How

Tests

Windows

Not in this PR

Known limits

Summary by Sourcery

Uh oh!

sourcery-ai Bot commented Oct 17, 2026

Reviewer's Guide

Sequence diagram for per-leg answered path recording

Flow diagram for hand-split directory placement records

File-Level Changes

Assessment against linked issues

Possibly linked issues

Interacting with Sourcery

Customizing Your Experience

Getting Help

Uh oh!

brettheap commented Oct 17, 2026

The issue's line

Findings, ranked

1. Not this PR's defect, confirmed and widened: any name the doctor sets aside, not only a tab, still yields MISPLACED after adoption verified (the body's Known limit 1)

2. Text: one sentence of "How" overclaims

Tests

Exact text replacements

For the checklist (#457)

Uh oh!

sonarqubecloud Bot commented Oct 17, 2026

Quality Gate passed

Uh oh!

sourcery-ai Bot commented Oct 17, 2026

Uh oh!

Uh oh!

Reviewers

Uh oh!

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

brettheap commented Oct 17, 2026 •

edited by sourcery-ai Bot

Loading

1. Not this PR's defect, confirmed and widened: any name the doctor sets aside, not only a tab, still yields MISPLACED after `adoption verified` (the body's Known limit 1)