[brettheap]

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

What

One rule, applied in two places: a value is never written where the project's own YAML loader (scripts/repo_shape.py) will read it back as something else. The loader decides each case. Nothing here keeps a list of words.

The plan writer (76a6153). y() writes a string bare only if the plan's loader gives the same string back. It asks in both places the writer puts a string: after key: , and as a - item (- a: is a one-key mapping, k: a: is not). A line the loader refuses counts as not read back. Anything else is quoted with #199's repo_shape.double_quoted.

• Now quoted: null, Null, NULL, true, True, TRUE, false, False, FALSE.
• Still bare: yes, no, on, off, .inf, .nan. This loader reads them as text. PyYAML would read them as booleans and floats; the project's own loader decides, as it does for the manifest's neutral_product_pins: entries since adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514 (Tracking: adopt-project.py, converting an existing repository in place #457 (comment)).
• Pins: since adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273 each is a mapping, and _pin_lines writes its product, repository and digest source through y, so a product null is written product: "null".
• Ordinary adoption is byte-identical to main's, at 7d6e13c against main 5ed3e5d, for three flag sets: default flags; --pin openGlass@<commit> --pin opensoft/openCode@<commit> --pin-source <clone> --allow-empty-leg code; and --spec-path legs/spec --code-path legs/code --tracking-branch develop. Compared: the plan's bytes, plan's and check's output, execute --local-remote-dir's output and every file of the split branch (32, 34 and 32), with temp paths and shas normalized. A stub gh was never called.

The gate on what execute writes (b26841b to 94242a2, and 180902f). execute puts the plan's values into the project's own YAML files. Each command refuses a value the project's loader would read back as something else from the line execute writes:

• plan: REFUSED adopt-manifest-misread, exit 2, before the plan is written;
• check: FINDING plan-manifest-misread, exit 1, with the remediation printed once after the findings;
• execute: refused through adopt-project.py execute refuses only plan-unresolved and plan-stale, so a plan check rejects as uncovered or with a bad leg creates and pushes both legs before it fails verification #168's _refuse_what_check_finds, before any leg repository exists.

What it finds on main now: nothing, on the shipped templates. Main's 47b1e06 (#259), merged here in 5c04ca2, writes id, elected_on, visibility, tracking_branch, both leg paths and the leg pins' submodule_path between double quotes. There render spells a value with double_quoted, and the loader reads it back as typed. Main's e6fbd74 (#514), merged here in f54dce7, writes an item of the manifest's neutral_product_pins: list between double quotes where the project's loader would misread it bare, and 89c6a6c (#516), merged in 8ce572b, quotes the neutral pin file's product:. The gate asks the line execute writes, so on main's templates it finds no value misread: the class fuzz under Tests names none. Before those merges it refused --tracking-branch true, null and 007, and then --pin null@<commit>, True@<commit> and 007@<commit>; now each is planned, checked and written as given (READ_BACK, under Tests). On a line written bare, as the templates were before #259 and the pins' list before #514, it says:

REFUSED adopt-manifest-misread: the product of a --pin is `null`, which `execute` writes into project.yaml's neutral_product_pins as `- null`, where the project's own YAML loader reads it back as no value at all and not as that text: choose another value.

check says the same of "the product of a pin in pins". The remediation says execute writes these values "into the project's own YAML files as they stand", not "into project.yaml and leg pins": a pin's product goes into the manifest and the product's own pin file, not a leg pin.

Why the gate stays whole (the lane's ruling in round K4):

• A value is this gate's only where the loader misreads what execute writes (G1 (A)). Where every line reads back, it says nothing: that is the rule working. Main keeps scaffold-project.py and adopt-project.py ask the project's YAML reader and validate-manifest.py about the manifest's values before anything exists, so --id null, --tracking-branch true and a blank --elected-by are refused (#258, #261) #314's scaffold twin after templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 on the same grounds. Its tests/test_scaffold_manifest_values.py says the question "is still asked", and that a template line written bare "is refused again, with no edit to the rule".
• A pin is asked of _template_table, the table execute writes the manifest from (180902f). _pin_field builds the table with _manifest_values from the plan with that one pin; execute's _template_values writes the project's files from a table _template_table builds the same way. render puts the item into the template's line (_written). _pin_item, the copy of how an item is spelled that _template_table and the gate shared, is gone, and _template_table's NEUTRAL_PRODUCT_PINS line was main's text again. So lane 2's adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514, which quotes those items, silenced the gate on pins with no edit to the rule when it was merged here (f54dce7), and 14 of this branch's tests flipped (under "Composes with adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514"). 9efe95a made adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514's own docstring true of this branch's y(). Since then this branch's own adopt-project.py changes are comments and docstrings that still said a pin's product is written bare, the unused MANIFEST_YAML removed (6c9e585), and the resolutions of its conflicted merges with main (a22b7f9, b602c16; under Merges).
• plan asks the plan it is about to write, built once: _refuse_unholdable_values returns it (_flag_plan), and _refuse_misread_values and _flag_fields take it. Main's test_plan_asks_what_check_asks_of_the_same_keys holds plan to one _flag_plan.
• Nothing else is removed: no piece of the gate is dead even to a direct call. The branches that only a line written bare can reach now are asked by direct tests over bare_template, a copy of the templates with templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259's lines bare again, and bare_pins, the pins' list written as before adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514, in this process (under Tests). They are the derived id (DERIVED_ID, FLAG_DEFAULTS), a set id and a branch read as not text, git's question about a branch and whether the source is asked about one, what the source answers (_pushed_in_every_mode) and what plan, check and execute do with that answer, the validator asked before this gate at plan, the default branch's name, the escapes UNESCAPED names, the validator asked about no manifest and a manifest its reader refuses, the values execute never writes, and each refusal itself: at plan, at check and at execute, a pin's product named as such, and no pin named beside a adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273 finding.

How the gate decides.

• manifest_misreads builds each line execute writes for a value: every line of a templated YAML file that carries the value's placeholder (the .yaml files in shape_materialize.TEMPLATED), handed with the value to the materializer's own render (d38e143). No copy of render's rules is kept here.
• It then asks loader_reading, the same question y() asks, to read that line back. loader_reading calls repo_shape.parse_yaml, from the same file execute copies into every project (COPIED_FROM_SHAPE).
• So the template decides how a value is written. A bare placeholder gets the value as it stands. Between a template's double quotes, render spells it with double_quoted (repo_shape.py: a quote opens a quoted scalar only where one begins and must close there, so k: [it's, a] reads two items, k: it's fine # note drops its comment, and an unclosed "abc or a mid-key [ is refused, not misread (#249, #250) #284) and puts it in once (adopt-project.py and scaffold-project.py substitute the template placeholders one after another, so a free-text value holding another placeholder's token is expanded (--elected-by '{{SPEC_PATH}}' is recorded as elected_by: "spec") or, after the legs are pushed, refused as template-unsubstituted with "a defect in the substitution table of the tool you ran" #260). The gate follows the loader with no edit of its own: adopt-project.py plan writes a plan its own loader cannot parse when a source name holds a line break (the macOS Icon\r file), so check refuses the whole plan as yaml-unparsable with no entry to edit #199's escapes, scripts/repo_shape.py reads ? a: b in a flow mapping as the literal key ? a, where the block reader refuses explicit keys, and refuses {a: } and {a:} as not a flow collection: '' instead of reading {'a': None} #252's flow mappings, scripts/repo_shape.py: the double-quoted reader that #247 adds (fix/adopt-plan-linebreak-names, not yet on main) resolves \x00 inside a block-scalar KEY, and _parse_mapping splits the NUL-joined sentinel record, so "a\x00b": | reads as the key a with the body b<NUL>text where main reads the literal key a\x00b #248's block scalars and repo_shape.py: a quote opens a quoted scalar only where one begins and must close there, so k: [it's, a] reads two items, k: it's fine # note drops its comment, and an unclosed "abc or a mid-key [ is refused, not misread (#249, #250) #284's quote boundaries.
• The values asked about: the id, the tracking branch, the elector, the election date, the reference, both leg paths, each pin's product, and a visibility that is one of the three choices. The id is named as derived when plan lowercased --project, or when the plan sets none (no id:, or id: null).

The project's own validator is asked first (f38d19a; rv181f's G1 and G2). Main's #314 asks the project's own validate-manifest.py about the same values: plan-manifest-invalid at check and execute, adopt-manifest-invalid at plan. This gate's remediation says that execute writes the values it names as they stand, and that the run would still end adoption verified. So a value is this gate's only where all three hold:

• the loader reads it back as something else;
• the validator, asked as the command asks it, makes no finding about what the loader reads;
• execute gets as far as writing it, in every mode it runs in (_execute_gets_to_write, below).
• At plan, _refuse_unholdable_values runs inside _checked_plan_inputs, before this gate. At check, _misread_findings asks _validator_judged first: it renders the manifest the plan would make and asks manifest_invalid's own question (shape_materialize.manifest_judged), and the gate leaves to it every value one of its findings is about (FINDING_PLACEHOLDER).
• Where the validator's own reader refuses the whole manifest (a pin ? x while the pins' list was written bare; since adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514 no plan value was found to make such a manifest of the shipped templates, probed over every key the manifest is rendered from), or it makes a finding about no one value (a leg path ../x), this gate names none of the plan's values, and the one finding is the validator's, as on main.
• An election date is adopt-project.py: check never reads a plan's elected_on: when the plan has no reference:, so plan ok is followed by an execute that creates both leg repositories and only then refuses election-date-malformed, naming --elected-on, a flag neither command takes #294's since 965420b: check asks election_date, one it refuses is election-date-malformed, _manifest_values renders no manifest, and neither the validator nor this gate is asked.

A value execute never gets as far as writing, in every mode, is not asked about (_execute_gets_to_write). A sentence about it would say that execute writes it and that the run would still end adoption verified, and neither would be true:

• a tracking_branch that checked_value refuses: execute refuses it as unsafe-value before any leg exists (e391b18, rv181f's F2);
• a tracking_branch the loader misreads that git will not create, by scaffold-project.py holds --tracking-branch only to checked_value's alphabet, so a name git refuses as a branch (~, a..b, x.lock, a trailing /) passes --dry-run and, against GitHub, dies at the first git init -b after gh repo create has made all three repositories #283's branch_problem: ~ (6a3a6b3, rv181f's H1). Git is asked only about a branch the loader misreads;
• a tracking_branch the loader misreads that execute does not push the legs to in every mode (69a743e, 94242a2): adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's plan-tracking-branch-missing, or one only the source's origin has. The source is asked only about a branch the loader misreads;
• a visibility that is not private, public or internal, text or not: in gh mode, execute's default, execute hands it to gh repo create as --<visibility> before anything is written (e391b18, rv181f's F2b);
• a pin of a plan whose pins: has a finding of adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273's (plan-pin-unrecorded, plan-pin-malformed, plan-pin-collides);
• a value no file can hold: adopt-project.py: since #247 a byte that is not UTF-8 in --elected-by, --reference or the --source directory passes plan and check, and execute pushes both legs before it dies with UnicodeEncodeError in write_lf #255's plan-unwritable-value names it, and execute refuses the plan before any leg exists (dae165d).

Since #259 the loader reads every tracking branch and visibility back from its quoted line, and since #514 every pin's product from the list, so these clauses change what the gate says only of a line written bare.

How each refusal reads (5aee63a, the NITs of review181).

• It names the flag or key, the value, the line execute would write and what the loader reads it as, and says "choose another value".
• The value is shown between backticks as it is typed, never as repr spells it. A text reading names each character a terminal shows as something else: "reads it back as the text CORP, then a tab, then om".
• A value a hand-edited plan's own loader read as something that is not text is named by what was read, never by str of it ("tracking_branch was read out of the plan as the number 7"). A pin is "the product of a pin in pins", and at plan "the product of a --pin". A tracking branch plan took from the source's default branch (adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479) is "--tracking-branch (not given, so the source's default branch)".

An explicit null leg path in a plan. This is spec_path: null, ~, or the key with nothing after it, which is what main's plan --spec-path null writes.

• check and execute used to read it as the default spec. Now it is plan-bad-leg-path: legs.spec_path is not text: its value was read as no value at all, and a leg path is text: write the path you mean, or remove the key to mount the leg at its role's own name.
• check's mount line no longer prints None/ or True/.
• The not-text sentence no longer says "so quote it", as main 5ed3e5d still does for spec_path: true. Quoted, the plan reads that spelling back as text, and since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 execute mounts the leg at a directory of that very name (true/, null/), which is the path meant only if it was meant. So it asks for the path meant, or for no key at all. Since scaffold-project.py: a leg's mount path must be canonical or it is refused before anything is created, so --spec-path spec/ no longer scaffolds a project whose recursive clone fails once the work directory is gone (#179) #201 that sentence lives in scripts/shape_materialize.py; the scaffold cannot reach it, because its flags are always text.

Why (repro on main 5ed3e5d)

Each case runs plan, check, execute --local-remote-dir, git clone --recurse-submodules, then the clone's own scripts/bootstrap.py, on the suite's standard source. A branch given to --tracking-branch is one the source has (#479). A stub gh stood first on PATH; its only calls came from a bootstrapped root's own validate-pins.py, asking for the digest of a pin it has no checkout of. Since #259 the templates quote what execute writes, so on main --spec-path 2026, 1.5 and ~, --tracking-branch 007 and --id 2026 adopt and bootstrap as typed, and since #514 and #516 so does --pin 007@<commit>. What is left on main is the plan: its writer puts null, true and True into the plan bare, and the plan's own loader reads them back as no value or a boolean. On main 5ed3e5d the driver's output is 89c6a6c's line for line, once temp paths and shas are normalized.

adoption verified and bootstrap ok, but with another value, and nothing says so:

• --spec-path null (also Null, NULL): the plan says spec_path: null, check says plan ok, and the leg is mounted at spec. --code-path null mounts at code.
• --tracking-branch null: both legs are on main, and so is the manifest's tracking_branch.
• --id null: the project's id is northwind.
• --project Null: the plan's legs.assembly and id are read as no value, and the manifest says id: none.

Refused at check, about a value nobody typed:

• --tracking-branch true: plan-tracking-branch-missing, "tracking_branch is True, which is no branch of the source (its branches: main, true; ...)".
• --spec-path true or False: plan-bad-leg-path, "... read as true or false, and a path is written as text, so quote it".
• --id true and --project True: plan-bad-id, "id: is 'True' and must match ^[a-z0-9][a-z0-9-]*$".
• --pin null@<commit>: plan-pin-malformed, "pins: entry 1 records no product:", from a plan that says product: null; --pin True@<commit>: "records product: True, which is not text".
• --elected-by null: plan-manifest-invalid, "elected_by is ''", from a plan that says elected_by: null.

On this branch (7d6e13c, the same driver, whose output is 9efe95a's line for line, normalized), every value above adopts and bootstraps as typed. --spec-path null, Null, NULL, true and False mount the leg at null/, Null/, NULL/, true/ and False/, and --code-path null at null/. --tracking-branch true and null put both legs on true and null, each with its origin/ upstream. --id null and --project Null make the id null, --id true and --project True make it true, and --elected-by null is elected_by: "null". --pin null@<commit> and True@<commit> adopt with the manifest's - "null" and - "True" and the pin files' product: "null" and product: "True". --spec-path legs/null --tracking-branch 2026-q4 --id yes --elected-by Null adopts and bootstraps too, each leg on 2026-q4; on main the same run stops at check with elected_by is ''.

Tests

tests/test_adopt_plan_yaml_quoting.py is new, with 524 tests, all through the real repo_shape loader:

• The round trip. Every keyword spelling, number, date, indicator, escape and syntax candidate, in the three places the writer puts a string. Also every string over two small alphabets, and 4000 seeded strings.
• The writer's guarantees. What round-trips is written exactly as before. A loader taught a new keyword is followed with no edit, and a word the loader refuses is quoted. The writer quotes a pin's product null and leaves openGlass bare.
• Read back as given (READ_BACK, 20 rows). --tracking-branch true, null and 007, each on a source that has it (adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479); the eight --spec-path values null, Null, NULL, ~, true, False, 2026 and 1.5, and --code-path null; --id true and null; --project True and Null; a source whose default branch is true; and, since adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514, --pin null@<commit>, True@ and 007@, each digest read from a stand-in clone with --pin-source (adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273). test_a_value_the_template_quotes_is_planned_and_checked_as_given asks each through plan and check, and test_execute_writes_a_value_the_template_quotes_as_given through execute --local-remote-dir: the plan, the split's project.yaml, a leg pin's submodule_path, a pin's own contracts/<product>-pin.yaml (since scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516) and the legs' branch read the value back as given, with no finding, and the manifest's list holds - "null", - "True" and - "007". plan refused each of these before the merges, as this gate's or the validator's.
• Refused as a misread where a line is written bare (REFUSED, six rows, in this process). The branches true, null and 007, on a source that has each, over bare_template; the pin products null, True and 007 over bare_pins. At plan as --tracking-branch or --pin <product>@<40 hex> (REFUSED adopt-manifest-misread, no plan written), at check as a plan carrying it (one finding, this gate's, with its remediation once), and at execute before any leg exists (needs_filter_repo).
• bare_template and bare_pins. bare_template copies the templates the gate reads (ASSEMBLY_TEMPLATE) with templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259's six placeholders bare again and puts the copy in their place; bare_pins makes _template_table write the pins' list as it did before adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514. Each first asserts that main's quotes are where it expects them. Besides REFUSED, 47 tests in 16 functions ask the branches only a bare line reaches, directly or through plan, check and execute in this process: the id plan derived from --project, and the id derived from legs.assembly four ways; a set id and a branch read as not text, named by what was read (READ_AS_NOT_TEXT: 007, TRUE, 1.50 and id: 007); the values execute never writes (NEVER_WRITTEN, 17); git asked only about a misread branch; the source asked only about a misread branch; adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's three branches execute does not push to in every mode; plan asking the validator before this gate; the default branch named by where it came from; the validator asked about no manifest, and a manifest its reader refuses; the seven UNESCAPED values shown as typed and as read; a pin beside a adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273 finding, and a pin ending in whitespace; a loader taught a new keyword; and scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266's leg-path rule (below).
• New in round K5 (the first three for rv181g's B1 at 180902f, the fourth for the ? x rows adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514's merge removed): test_a_branch_execute_does_not_push_in_every_mode_is_never_misread (the source lacks true, its fetched origin lacks it, or only origin has it: plan and check in this process over bare_template give adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's note and finding alone, or plan ok, and never a misread); test_the_source_says_whether_execute_pushes_the_legs_to_a_branch (_pushed_in_every_mode for four sources: the source lacks the branch, origin lacks it, only origin has it, both have it); test_plan_asks_the_validator_before_the_misread_rule (--id true, with the validator given the same bare copy: adopt-manifest-invalid alone, no plan written); and test_a_manifest_its_reader_refuses_is_the_validators_alone (G2's pin ? x over bare_pins).
• Changed in round K6a (6c9e585), with no test added or removed: with_origin puts the source's origin under testorg/Northwind, the repository plan is given (rv181g's M1). Since adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513 (cf118ff), plan reads a path origin's last two directories as the source's repository and refuses a plan for another, so with origin in a directory named seed five tests were refused as adopt-not-the-source before this gate was asked; cf118ff made the same change to tests/test_adopt_tracking_branch.py. Seven composite asserts are split into plain ones with the same meaning (SonarCloud's S9073), and one pytest.raises block now holds only the call that raises (S5778).
• Changed in kind at adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514's and templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259's merges: the three REFUSED tests, READ_BACK's pin rows, the template-line, table, agreement and keyword-learning tests, the two adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273 pin tests, four tests of a derived id, a value read as not text and a branch taken from the source, and manifest_judged's cases. Most now ask a line written bare in this process (bare_template, bare_pins) or read the quoted one back. Each change is listed test by test in this description's edit history (the body at 9efe95a, with which adopt-project.py: y() quotes what the plan's loader would read as a keyword, so --spec-path null, --id null and --tracking-branch true adopt as typed, and plan, check and execute refuse, before anything exists, a value the project's own loader would read back as something else from the line execute writes #518 was opened).
• Deleted, each asked by another test now: test_plan_refuses_a_value_the_validator_refuses_in_its_words_alone, test_check_leaves_a_value_the_validator_refuses_to_it and test_execute_refuses_a_value_the_validator_refuses_as_the_validators, whose values are READ_BACK's --spec-path, --code-path and --id rows now. The rule they held, the validator asked first and a value it refuses its alone (rv181f's G1), is held at check by the never-writes visibility rows together with _execute_gets_to_write (either reverted alone fails none, both together 15), and at plan by test_plan_asks_the_validator_before_the_misread_rule. Also test_plan_leaves_an_id_it_derived_from_the_project_to_the_validator (READ_BACK's --project rows) and test_the_misread_rule_names_a_set_id_by_what_was_read (test_the_misread_rule_names_a_plan_value_that_is_not_text_by_what_was_read[id='007']). JUDGED_ONCE loses id: "007", tracking_branch: "007" and legs.spec_path: "null" (main's TEXT_THE_TEMPLATE_NOW_HOLDS, and READ_BACK), and at adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514's merge its pins "null" (test_check_reports_a_plan_carrying_one's pin rows) and ? x; JUDGED_BY_THE_VALIDATOR loses ? x too (both to test_a_manifest_its_reader_refuses_is_the_validators_alone). NOT_TEXT_INVALID loses id: 007 (READ_AS_NOT_TEXT).
• Not asked about, because execute does not write it in every mode: check names none of NEVER_WRITTEN misread and prints no misread remediation: tracking_branch: '"CORP\tom"', tracking_branch: "~", visibility: "true", the eleven visibility texts the loader reads as no value ("", '', "null", "Null", "NULL", "~", "#", "#x", " ", " ", |-) and three choices in their own quotes. plan --tracking-branch ~ writes the plan, as on main. A date, a visibility and two pins' products no file can hold are each adopt-project.py: since #247 a byte that is not UTF-8 in --elected-by, --reference or the --source directory passes plan and check, and execute pushes both legs before it dies with UnicodeEncodeError in write_lf #255's plan-unwritable-value (a pin beside adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273's plan-pin-malformed), with no misread finding.
• Judged once, by the rule that is true of it (JUDGED_ONCE, 5): the validator's, each: a blank elector, and visibility set to secret, "true", true or [secret]. manifest_judged is tested in four cases here and in the G2 test, and the six LATE_DATES are each adopt-project.py: check never reads a plan's elected_on: when the plan has no reference:, so plan ok is followed by an execute that creates both leg repositories and only then refuses election-date-malformed, naming --elected-on, a flag neither command takes #294's election-date-malformed alone. With git-filter-repo, execute refuses visibility: "true" under the validator's code before any leg exists. Main's tests/test_adopt_manifest_values.py asserts the order: _misread_findings is [] where the validator judges a value.
• Read back since repo_shape.py: a quote opens a quoted scalar only where one begins and must close there, so k: [it's, a] reads two items, k: it's fine # note drops its comment, and an unclosed "abc or a mid-key [ is refused, not misread (#249, #250) #284 and put in once since adopt-project.py and scaffold-project.py substitute the template placeholders one after another, so a free-text value holding another placeholder's token is expanded (--elected-by '{{SPEC_PATH}}' is recorded as elected_by: "spec") or, after the legs are pushed, refused as template-unsubstituted with "a defect in the substitution table of the tool you ran" #260: ten values between the manifest's quotes (CORP\tom, docs\new.md, Robert "Bob" Smith, a last \, ...) for elected_by: and reference: (20 cases), and five values holding a placeholder's token (10 cases), each asked as render writes it, and each passes. The elector plan takes from git config user.name, CORP\tom, is written "CORP\\tom" and passes check.
• adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479 and adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273 (69a743e, 94242a2): on the shipped templates, plan and check name a branch the source lacks, or its fetched origin lacks, as adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's finding alone, and one only origin has as neither, and execute --local-remote-dir refuses that one before any leg exists. Since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 the branch reads back from its quoted line, so these tests no longer reach _a_branch_execute_writes, _pushed_in_every_mode or unwritten; test_a_branch_execute_does_not_push_in_every_mode_is_never_misread (the same three cases over bare_template) and test_the_source_says_whether_execute_pushes_the_legs_to_a_branch (four sources) do. A pin beside a adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273 finding is not named, and a pin ending in whitespace is adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273's plan-pin-malformed alone, both asked over bare_pins now; a product that is not text is adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273's plan-pin-malformed alone.
• Accepted end to end: --spec-path legs/null --tracking-branch 2026-q4 --id yes --elected-by Null, through execute, the recursive clone and bootstrap.py, each leg on 2026-q4 with origin/2026-q4 as its upstream (needs_filter_repo).
• The gate asks the loader and the table. It follows a loader taught a new keyword (the pins' list then quotes it, and a branch on a bare line is refused), reads the template line for its quoting, asks the table execute writes the pins' list from, quoted and written bare, and agrees with the files the materializer's render writes whole on every candidate, for the tracking branch, the elector, the reference, the spec leg path and a pin.
• Other cases: an explicit null leg path is a finding for null, ~ and nothing; the doctor's placement plan quotes a path the same way; each test that runs execute runs it on a copy of the source of its own (c87c45f).

The composition fuzz, every value class (7d6e13c against main 5ed3e5d). 286 values (rv181f's 244 candidates and 42 more) in eleven classes: the id given and derived, the tracking branch given and taken from the source's default branch, the elector, the election date, the reference, the visibility, both leg paths and a pin's product. Each runs through plan, given by its flag, and through check of a hand-edited plan carrying it as the head's y writes it: 3146 rows, 2933 run. The 213 skipped are 210 tracking-branch values git or checked_value will not take, and three a source could not be made for.

• This gate names no value in any class: 0 rows at plan, 0 at check. No row has this gate's finding beside another (0 double), so no clause of it can be false (0), and no row the tool compares has plan and check disagreeing (0; it leaves the visibility and derived-id classes out of that comparison). The stub gh was never called.
• At 9efe95a against 89c6a6c (round K5), at b602c16 against b0826e0, and at 42362de against 3121945, it gave the same counts in every class.
• At 180902f, against main 191105a, it named the pin class alone (26 rows; rv181g's own judge, with the product parsed as --pin parses it, found every clause true). adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514 and scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516 quote those lines now.

Other files: main's tests/test_adopt_manifest_values.py keeps its own tests, with misreads_elsewhere (gone since f38d19a) asked as _misread_findings(plan) == []; test_a_value_the_reader_reads_as_another_kind_is_not_this_questions is main's again, less main's visibility row. tests/test_adopt_leg_paths.py: the not-text sentence has no "quote" and covers None. Main's tests/test_template_text_placeholders.py: a comment that said plan writes true and null bare, which it does not here; #516's pin-file rows beside it are main's.

Revert table, round K5, measured on 9efe95a, and not again at 7d6e13c: the code its rows revert is unchanged since, except where main's merges changed the same functions (_checked_plan_inputs, _entry_findings, y and, at #511's, cmd_plan; under Merges). Each change was reverted alone in a scratch clone of the head; the quoting file and main's tests/test_adopt_manifest_values.py were run whole (601 tests), and the seven files touched were restored (sha256-checked). A row marked "with" runs with git-filter-repo on PATH, so its execute tests run; the others run without it, which skips those 44 tests alone. Unreverted, with it: 601 passed. The rows from K1 on are rv181g's, text for text.

change reverted	tests that fail
y() back to main's test (76a6153's change), with	68: the writer's own tests (18), READ_BACK's rows whose value the plan reads as a keyword, at plan/check and at execute (30), the bare branches true and null and the bare pins null and True at check and at execute (8), #479's three shipped tests and their execute (4), the three bare-line #479 cases, the accepted end-to-end run, the keyword-learning test, the pin writer test, the keyword-named source file and the doctor's placement plan
#514: _template_table writes the pins' list bare again, with	9: READ_BACK's three pins at plan/check and at execute, and the keyword-learning, template-line and table tests
bare_pins leaves #514's quoting in place	7: the three bare pins at plan and at check, and the G2 test
the gate asks a copy of a pin's line, not _template_table (180902f)	7: READ_BACK's three pins at plan/check, and the keyword-learning, template-line, table and pin agreement tests
check and execute ask about no pin, with	6: the three bare pins at check and at execute
plan asks about no pin	3: the three bare pins at plan
a pin's line read whole (neutral_product_pins: and its item as one)	17: the three pins at plan, at check and in READ_BACK, the keyword-learning, template-line, table and pin agreement tests, the three ordinary-pin writer cases, and main's test_plan_asks_what_check_asks_of_the_same_keys
plan builds its plan a second time for the pins	1: main's test_plan_asks_what_check_asks_of_the_same_keys
a pin asked about beside a #273 finding	1: test_a_pin_beside_a_273_finding_is_not_named_misread
every product the plan names asked about, not the pins _read_pins records	3: that test, and both cases of test_a_pin_ending_in_whitespace_is_273s_finding_alone
plan names a pin's product --pin	3: the three bare pins at plan
check names a pin's product a pin in pins	3: the three bare pins at check
#259's tracking_branch: written bare again, with	12, and the 61 tests over bare_template error, because its fixture asserts #259's quotes are in place. The 12: READ_BACK's four branch rows at plan/check and at execute (8), check passing a branch read as not text (3), and the template-line test
#259's id: written bare again, with	19, and the same 61 errors: READ_BACK's --id and --project rows twice (8), the four derived ids check passes, check passing id: 007, and six of main's tests/test_adopt_manifest_values.py cases
#259's leg paths written bare again (both path:s and both submodule_path:s), with	18, and the same 61 errors: READ_BACK's nine leg paths at plan/check and at execute
bare_template leaves #259's quotes in place	28: every test over it that needs a bare line and runs without git-filter-repo: the three bare branches at plan and at check (6), the two derived-id tests (5), the not-text rule (4), git's and the source's questions and the default branch's name (3), plan asking the validator first, the seven UNESCAPED values, the keyword-learning test and #266's composition
a value read as not text named by str of it again	4: test_the_misread_rule_names_a_plan_value_that_is_not_text_by_what_was_read, every row
a defaulted tracking branch named --tracking-branch	1: test_plan_names_a_tracking_branch_it_took_from_the_source
_execute_gets_to_write says yes to every value	3: the never-writes rule's two branches ('"CORP\tom"', "~") and the test of what git is asked. Its visibility rows still pass: the validator, asked first, judges each
the misread question asked of a leg path #266's rule refuses	1: test_a_leg_path_written_bare_is_266s_finding_alone
a validator finding about no one value judged as about none	1: test_the_validator_says_which_values_it_judges[a-finding-about-no-one-value]
a manifest the validator's reader refuses judged as about no value (G2)	1: test_a_manifest_its_reader_refuses_is_the_validators_alone
K1: plan asks git only about a misread branch, not the source	3: test_a_branch_execute_does_not_push_in_every_mode_is_never_misread, each case
K2: check and execute pass no unwritten to this gate	3: the same three cases
K3: _pushed_in_every_mode without #479's question	2: origin-lacks-it of that test and of test_the_source_says_whether_execute_pushes_the_legs_to_a_branch
K3b: _pushed_in_every_mode without the source's own branches	2: only-origin-has-it of the same two tests
K5: the source asked about every branch, misread or not	2: test_the_source_is_asked_only_about_a_branch_the_loader_misreads, and test_the_misread_rule_names_an_id_plan_derived_by_where_it_came_from, which gives plan no source
V2b: G1 at plan, this gate's question asked first, the plan built once	1: test_plan_asks_the_validator_before_the_misread_rule
V1: G1 at check, a value the validator judges not left to it	none alone
V3: _execute_gets_to_write's visibility clause off	none alone
V1 and V3 together	15: NEVER_WRITTEN's fifteen visibility rows over bare_template. Each of the two guards keeps those values from this gate on its own
V4: no manifest the validator can be asked about leaves no value	1: test_no_value_passes_a_validator_that_is_not_asked
V5: FLAG_DEFAULTS without the id	1: test_the_misread_rule_names_an_id_plan_derived_by_where_it_came_from
V6: a derived id named plain id	4: test_the_misread_rule_names_an_id_it_derived_from_the_assembly, every row

Earlier revert tables, each measured on the head named, are kept whole in this description's edit history: round K4 (180902f, 580 tests), the fix round (edf9163, with rows again on ed9968f, f911d81 and 94242a2), round K3 (94242a2, 491 tests) and the NIT round (edf9163, 543 tests). A row about a value #259 or #514 quotes describes that head, not this one. Each row failed at least one test except these, named there: rv181g's K1, K2, K3, K3b and V2b at 180902f (B1, fixed in 9efe95a); a boolean spelled with its own literals (S1192 only); and a branch checked_value refuses, asked about (4 with H1's guard reverted too).

Counts at 7d6e13c, this head (git 2.43.0, Python 3.12.3, pytest 9.1.1), measured before #511 landed on a scratch merge of 42362de with #511's predicted squash, whose tree, 88c22f0a, is this head's. Clean worktrees, a stub gh first on PATH in both modes, and six sets, each run with git-filter-repo on PATH and without it, each with exit 0, that commit named in its log and the worktree clean before and after it:

• 14 files: test_adopt_plan_yaml_quoting test_adopt_plan test_adopt_leg_paths test_adopt_e2e test_adopt_execute_refusals test_adopt_submodules test_shape_doctor test_cli_reference test_windows_paths test_adopt_leg_path_collisions test_adopt_mount_ignored test_scaffold_leg_paths test_repo_hygiene test_adopt_verify. With it: 1928 passed, 4 skipped (the MedxEHR clone, and three rows of test_shape_doctor that print a PowerShell line only on a Windows host). Without it: 1833 passed, 99 skipped (95 needs_filter_repo, plus those four). tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 changed four of these files and none of their counts.
• 65 more files, the list round K3 ran at 94242a2: adopt-project.py plan writes a plan its own loader cannot parse when a source name holds a line break (the macOS Icon\r file), so check refuses the whole plan as yaml-unparsable with no entry to edit #199's and scripts/repo_shape.py _split_flow ignores a backslash inside a double-quoted flow item, so pins: ["x\",y"] reads back as two items x\ and y" where the same text as a block sequence item reads as the one item x",y #213's escapes and flow quotes, the scaffold's collisions and ignored mounts, test_adopt_manifest_values and test_scaffold_manifest_values (scaffold-project.py and adopt-project.py ask the project's YAML reader and validate-manifest.py about the manifest's values before anything exists, so --id null, --tracking-branch true and a blank --elected-by are refused (#258, #261) #314), test_manifest_validator (repo_shape.py, validate-manifest.py: a bracket in a plain flow scalar is refused and a name holding a lone surrogate is a finding, so pins: [a, b]] is not the pin b] and name: "a\ud83db" no longer kills make validate (#301, #280) #390), test_adopt_pins (adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273, adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514), test_adopt_tracking_branch (adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479), test_ruleset_hint_tracking_branch, the update-shape files and the rest. With it: 3869 passed, 4 skipped (one test about Windows' own default, three about NTFS junctions). Without it: 3686 passed, 187 skipped (183 needs_filter_repo). Since 42362de, tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 added six tests to test_adopt_ignored_shape_files, each needing git-filter-repo.
• Main's 11 test files changed by templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259, scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266 and update-shape.py on a holder cut before siblings.py existed: taking the new Makefile without --add scripts/siblings.py (AGENTS.md's default) breaks make siblings, park and resume #489, in neither set: test_template_text_placeholders (templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259, scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516), test_leg_path_yaml_scalars (scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266), test_bootstrap_after_bump, test_bootstrap_spelling, test_family, test_family_add_member_id, test_family_makefile_siblings, test_pin_validator, test_scaffold_e2e, test_setup_project_py and test_setup_sh. With it: 963 passed, 8 skipped. Without it: 953 passed, 18 skipped (ten needs_filter_repo). The eight are scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266's rows, which skip because "the templates read" those values back since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259, or have no value left to refuse.
• Main's 10 test files changed since 191105a and in none of the above: test_doctor_legs_members_next, test_doctor_next_is_a_command, test_doctor_validator_rows, test_family_init_landing, test_family_printed_quoting, test_family_tracking_branch, test_scaffold_pin_and_reuse (scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516), test_scaffold_reuse_seeded_legs, test_update_shape_add and test_update_shape_rewrite_symlink. 364 passed, with it and without it; tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 added three tests to test_update_shape_add. Main's other test files changed since 191105a are in the sets above (test_adopt_execute_refusals, adopt-project.py: check names, and execute refuses before the work directory is made, a plan whose source: or legs: is not a mapping or whose allow_empty_legs: or paths: is not a list of what plan writes, and asks the same first of a pins: that is not a list, so a number or a boolean in any of the four no longer ends both in a traceback and allow_empty_legs: code is no longer read as four legs (#386) #435's, whole in the first), and every run loads main's tests/conftest.py.
• Main's 5 test files changed since 89c6a6c and in none of the above: test_adopt_root_symlinks (adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504), test_adopt_project_is_the_source (adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513), test_openreposhape_command (openRepoShape --doctor: the installed form keeps the clone of the standard it ran from and names it on the report's last line, so a NEXT line pasted after the command has exited runs instead of dying with can't open file, and it hands --json and --placement-plan <file> on to shape-doctor.py instead of refusing them (#500) #510), test_update_shape_merged_away (update-shape.py and shape-doctor.py: no NEXT line pre-fills --accept-local for a locally edited shape copy, so the apply a row names, pasted, meets update-local-drift and its question to the human instead of re-pinning the edit as the standard, and a shape/ collision copy merged into its original and removed is merged-away to check, whose apply drops its pin row behind the same yes, so an adopted root that did its follow-up validates green again (#501, #502) #512) and test_refusal_default_remediation (repo_shape.py, validate-pins.py, family.py: a refusal built without a remedy prints its REFUSED line alone, the assembly root's validate-pins.py still adds the lockstep remedy to its own, and add refuses a .gitmodules git cannot rea (#370) #494). With it: 248 passed. Without it: 223 passed, 25 skipped, each needs_filter_repo; tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 added one, to test_update_shape_merged_away. Main's other test files changed since 89c6a6c are in the sets above: test_adopt_finding_spelling and test_adopt_ignored_shape_files (adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504); test_adopt_git_reads, test_adopt_late_failure, test_adopt_relative_submodule_url, test_adopt_split_branch and test_adopt_tracking_branch (adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513); test_shape_doctor (openRepoShape --doctor: the installed form keeps the clone of the standard it ran from and names it on the report's last line, so a NEXT line pasted after the command has exited runs instead of dying with can't open file, and it hands --json and --placement-plan <file> on to shape-doctor.py instead of refusing them (#500) #510, update-shape.py and shape-doctor.py: no NEXT line pre-fills --accept-local for a locally edited shape copy, so the apply a row names, pasted, meets update-local-drift and its question to the human instead of re-pinning the edit as the standard, and a shape/ collision copy merged into its original and removed is merged-away to check, whose apply drops its pin row behind the same yes, so an adopted root that did its follow-up validates green again (#501, #502) #512); and test_doctor_next_is_a_command, test_update_shape and test_update_shape_next_quoting (update-shape.py and shape-doctor.py: no NEXT line pre-fills --accept-local for a locally edited shape copy, so the apply a row names, pasted, meets update-local-drift and its question to the human instead of re-pinning the edit as the standard, and a shape/ collision copy merged into its original and removed is merged-away to check, whose apply drops its pin row behind the same yes, so an adopted root that did its follow-up validates green again (#501, #502) #512).
• tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511's new test file, test_adopt_attributes_eol_block: 37 passed, with it and without it. tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511's other eleven changed test files are in the sets above.

render-cli-reference.py --check is ok. The full suite was not run here: the three-OS CI gate decides it.

Windows. No Windows machine is reachable from the lane. A pytest plugin kept outside the repository makes text-mode writes in the test process write \r\n, as on Windows: open and io.open with no newline, so Path.write_text too, and a text-mode input= to a process. At #504's 9e8c672, run without git-filter-repo, it fails exactly the 17 tests of tests/test_adopt_root_symlinks.py the Windows job failed, with its message ("the plan was written with no pin"), and nothing else in that file; with git-filter-repo it also fails test_without_a_pin_that_source_adopts, which needs disk symlinks and so never runs on Windows. At 7d6e13c, over this branch's four changed test files, tests/test_adopt_root_symlinks.py and #511's tests/test_adopt_attributes_eol_block.py, it fails nothing: 1280 passed with git-filter-repo, and 1207 passed, 73 skipped without it. Main 5ed3e5d, over the five of those files it has, gives 755 passed with it, and 713 passed, 42 skipped without it. Since #511 the Windows job installs git-filter-repo, so the quoting file's 31 tests that need it run on Windows for the first time, and the run with it is the realistic one. Git's own line endings and file names on Windows are not emulated. This branch's added test lines hold no os.name or sys.platform branch, no chmod, no text-mode stdin, no path split and no read_bytes. Its two write_text calls (answer, bare_template) are read back only as text, never as bytes, which is the pattern #504's Windows failure had. So nothing here changes for Windows; the three-OS CI is the gate.

Reviews

Lane 2 at 76a6153: CHANGES NEEDED, one P2 (#181 (comment)). It confirmed the plan-file fix: 339,485 strings round-trip through y() and the loader, y() differs from main on exactly 63 of them, and ordinary plans are byte-identical.

• P2-1: FIXED. The keyword reached project.yaml and the leg pins; the gate (b26841b) refused it, and since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 the template quotes those lines and the value reads back (under What). The end-to-end test clones recursively and bootstraps what is accepted.
• P3-1: adopt-project.py plan writes a plan its own loader cannot parse when a source name holds a line break (the macOS Icon\r file), so check refuses the whole plan as yaml-unparsable with no entry to edit #199's, landed (4835fb4, merged): a name holding a line break is written on one line. P3-2: FIXED, the docstring that misstated main. The question: TAKEN: an explicit spec_path: null is plan-bad-leg-path, as adopt-project.py accepts a non-canonical leg path such as --spec-path spec/, so the mount and its .gitmodules registration disagree and main still says adoption verified #169 rules an explicit empty value.

Lane 1's adversarial re-verification at a0ff15b (review181): PR-READY, 7 NITs. It re-ran lane 2's 26 scenarios, fuzzed the gate (2,440 flag rows and 3,872 hand-edited plan lines: 0 false refusals, 0 crashes), and found ordinary adoptions byte-identical to main.

• N1, N2, N3, N5: TAKEN (5aee63a; 34d683f names the carriage return): a value is shown as typed and each character a terminal hides is named; a hand-edited 007 or TRUE is named by what was read; "not set in the plan" for id: null; the import comment and module docstring.
• N4: TAKEN, in this description. N6: TAKEN (5aee63a, a230c82): repeated spellings are constants. A hand count at 180902f against main 191105a (SonarCloud was not reachable; literals of five or more characters, docstrings and f-strings out) finds two this branch makes a third use of or more, both in adopt-project.py and both as at 94242a2: 'utf-8' (ten; main has nine) and "project.yaml" (three: this branch's MANIFEST_YAML, 93e3bf0's SHAPE_MANIFEST and An adopted assembly records nothing about which leg a human chose for a source submodule, so shape-doctor.py cannot verify a kept gitlink's placement and can only note it; adopt should write the plan's submodule answers into the assembly #189's append["project.yaml"]; main has two). None in scripts/shape_materialize.py or the four test files then. At 7d6e13c against main 5ed3e5d 'utf-8' is eleven against ten and "project.yaml" two against two (6c9e585 removed MANIFEST_YAML), and scripts/shape_materialize.py still has none, but the quoting test file's K5 tests make a third use or more of five: "check" (seven), "product" (four), and "Remediation: ", "assembly-root" and "scripts" (three each). Main's tests/test_adopt_pins.py already repeats "check" eight times and "product" nine, so they are named here, not folded. _checked_plan_inputs, at 15 for cognitive complexity on main since adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479, is at 15 here (by hand).
• N7: NOT TAKEN then; moot since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259: --tracking-branch 2026 adopts as typed, here and on main.
• Its out-of-scope findings O1 to O4 were each identical on main, and none is changed here. O1, the scaffold twin, and O2, render substituting in turn, have since landed on main as scaffold-project.py and adopt-project.py ask the project's YAML reader and validate-manifest.py about the manifest's values before anything exists, so --id null, --tracking-branch true and a blank --elected-by are refused (#258, #261) #314 and adopt-project.py and scaffold-project.py substitute the template placeholders one after another, so a free-text value holding another placeholder's token is expanded (--elected-by '{{SPEC_PATH}}' is recorded as elected_by: "spec") or, after the legs are pushed, refused as template-unsubstituted with "a defect in the substitution table of the tool you ran" #260, both merged here.

Lane 1's re-verifications (rv181f).

• At e337f44: F1 FIXED (57103dd, a pin's line shown as written), F2 (see d38e143), F3 FIXED (a230c82), F4 FIXED (cba6d3f), F5 in this description.
• At d38e143: CHANGES NEEDED. F2 FIXED (e391b18): 44 of 540 sentences described a tracking_branch write execute never makes, because checked_value refuses it first. F2b FIXED (e391b18): a visibility outside the three choices, which execute hands to gh repo create, is no longer asked about. The merge of adopt-project.py: since #247 a byte that is not UTF-8 in --elected-by, --reference or the --source directory passes plan and check, and execute pushes both legs before it dies with UnicodeEncodeError in write_lf #255 DONE (e8e0026, dae165d).
• At 7ac2358 (round I): CHANGES NEEDED. G1, BLOCKER, FIXED (f38d19a): the misread remediation printed after values the project's own validator refuses (127 check rows, 108 plan rows); the validator is now asked first. G2, SHOULD-FIX, FIXED (f38d19a): 44 values whose manifest the validator's reader refuses got two findings; now one. G3: eleven visibility texts the loader read as no value got no finding, a residual shared with main; since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 each is the validator's plan-manifest-invalid (under "Not in this PR").
• At edf9163 (round J): CHANGES NEEDED, H1. FIXED (6a3a6b3): a tracking branch ~ got the misread finding, and git will not create it; the gate leaves out a misread branch git will not create. Since adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479, ~ is plan-tracking-branch-missing and execute refuses it before any leg exists.
• At ed9968f (round J2): PR-READY, one NIT (NIT-4, two hand counts, TAKEN). Of 356 candidates, ~ was the one branch the loader misreads that checked_value passes and git will not create. Its fuzz against main 5a25387 (5695 check rows, 3560 plan rows) found no row with both this gate's and the validator's finding, and every row with this gate's finding ended adoption verified on main's real execute.

Lane 1's re-verification at 180902f (rv181g, round K4): CHANGES NEEDED. Its own fuzz judge found 0 false clauses and 0 double findings, against main 191105a and on a scratch merge with main 8cd7dbe, and ordinary adoption byte-identical.

• B1, BLOCKER: FIXED (9efe95a). Since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 quoted tracking_branch:, no test held adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's composition or the validator-first order at plan: its rows K1, K2, K3, K3b and V2b failed 0 tests at 180902f. Three of the four tests new in round K5 hold them: K1 and K2 fail 3 each, K3 and K3b 2 each, and V2b 1 (the revert table above).
• S1, SHOULD-FIX: FIXED. Four sentences of this description were false at 180902f; each is replaced, true at this head.
• N1, NIT: FIXED. adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514's docstring on _neutral_product_pins became false once merged with this branch's y(); it is made true (under "Composes with adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514").
• Its question about the pin file's product: is answered by scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516, which landed and quotes it (under "Not in this PR").

Lane 1's re-verification at 9efe95a (rv181g, round K5): PR-READY. Its own fuzz, byte identity, pin files and targeted runs agreed with this branch's.

• M1, a semantic conflict with adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513 that git merge-tree does not show: FIXED (6c9e585, under Tests).
• S-1 and S-2, two sentences of this description: FIXED when the PR was opened. N-0: under Merges.
• N-1 to N-8: FIXED. Eight comments and docstrings in adopt-project.py, all this branch's and none printed, still said a pin's product is written bare, or that a pin ? x makes a manifest its reader refuses. N-7 sits in the adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513 conflict and is fixed in a22b7f9's resolution, the rest in 6c9e585. With docstrings blanked the module's AST is unchanged.
• N-9: 9efe95a's subject says no test of the gate passes with its change reverted. That holds per test, not per guard: V1 and V3 each fail none alone (the double guard in the revert table). It is pushed and stays; the landing message does not repeat it.

Codex at 9efe95a: "Didn't find any major issues". SonarCloud at 9efe95a: the gate passed, with no S8705 and nine new smells: seven S9073 (a composite assert) and one S5778 (two calls inside pytest.raises) in the quoting test file, and one S1192, a third "project.yaml" in adopt-project.py, which was this branch's MANIFEST_YAML. 6c9e585 fixes all nine (under Tests and Merges).

Merges

The branch was brought up to date by merging, never by rebasing: main has been merged in 31 times. Round K6's four are 8beb3d9 in a22b7f9 (one hunk, resolved), b0826e0 in b602c16 (#504, three hunks, resolved), 3121945 in 42362de (#494, clean) and 5ed3e5d in 7d6e13c (#511, clean).

• 7d6e13c merges main 5ed3e5d, by sha: tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 for tests-windows never executes an adoption: git-filter-repo is not installed there, so the eight adopt suites skip and v1.0.0's "adopt works on Windows" is unverified #471. No conflict: the tree is git merge-tree's, 88c22f0a, which a scratch merge with tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511's predicted squash had before tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 landed; every count and probe at 7d6e13c here was measured on it. cmd_plan is the one unit both sides changed, and keeps both: this branch's comment and _checked_plan_inputs asking the validator first, and tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511's attributes_link. Every other unit is the one side's that changed it, and no name in adopt-project.py is bound twice. tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511 changes no template, no render and no line execute writes into the project's YAML (under "Composes with tests.yml and adopt-project.py: the Windows job installs git-filter-repo 2.47.0, so the adoption test files that skip without it run there, and a source that keeps its own root .gitattributes gets one marked block of /<copy> text eol=lf lines appended to it in the split, so a Windows clone writes the pinned copies at the root with the bytes the pin records; the verification counts that file as the source's bytes followed by exactly that block, and update-shape.py apply --add extends it (#471) #511").

• 42362de merges main 3121945, by sha (fetched at 13:35Z): repo_shape.py, validate-pins.py, family.py: a refusal built without a remedy prints its REFUSED line alone, the assembly root's validate-pins.py still adds the lockstep remedy to its own, and add refuses a .gitmodules git cannot rea (#370) #494 for repo_shape.py's Refusal gives every refusal built without a remediation the assembly root's own (run git submodule update --init --recursive, then python3 scripts/validate-pins.py ... contracts/<leg>-pin.yaml), so in a family holder family.py add over an unparsable .gitmodules (git-failed), bump on a family.yaml of the wrong kind, and the holder's own validate-family.py on a short pin.commit each tell the operator to run a file no holder carries and to move a leg pin a holder does not have #370, which landed at 13:21:57Z. No conflict: the tree is git merge-tree --write-tree b602c16 31219459's (4a502cdd), and no top-level unit of adopt-project.py, scripts/repo_shape.py, scripts/family.py or shape-doctor.py changed on both sides. repo_shape.py, validate-pins.py, family.py: a refusal built without a remedy prints its REFUSED line alone, the assembly root's validate-pins.py still adds the lockstep remedy to its own, and add refuses a .gitmodules git cannot rea (#370) #494 makes Refusal's default remediation none, so a refusal built without one prints its REFUSED line alone, and changes adopt-project.py in _failed_loudly alone. This gate's refusals each name their own remediation and none falls back to the empty default: plan's through refuse_manifest_values and MANIFEST_MISREAD_REMEDIATION, execute's through _refuse_what_check_finds' own list, and every other Refusal in a unit this branch changed passes one too. The probes under "Composes with adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513" and "Composes with adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504" print each refusal's remediation at 42362de.

• b602c16 merges main b0826e0, by sha (fetched at 12:45Z): adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504 for materialize_assembly_root writes the shape files through a root-kept symlink to anywhere on disk, and crashes with a traceback on a link loop, after both legs are pushed #183 and adopt-project.py check refuses no root-kept symlink at or above a path the shape writes, so a link that dangles or leaves the tree makes execute traceback, or write the shape's files OUTSIDE the assembly, after both leg remotes are pushed #178, which landed at 12:40:37Z. git merge-tree finds three conflict hunks, all in adopt-project.py, and each keeps both sides:

  • the from shape_materialize import (...) list: this branch's PLACEHOLDER_RE, TEMPLATED and render, and adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504's SYMLINK_HOPS (moved there from this module), TOO_MANY_SYMLINKS and template_files, each imported once and each read in the module;
  • _entry_findings' docstring: this gate's finding after the mount paths, then the source's own submodules, then adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504's symlinks kept in the root, then the rest as both sides have it;
  • _entry_findings' return: findings + misread + split + _root_symlink_findings(plan, source, tree) + ..., with this branch's remediation list unchanged, since adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504 adds a finding and no remediation to it.

  Every other path is git merge-tree's, and adopt-project.py is its blob byte for byte outside the three conflict blocks. git merged both sides cleanly where both touched one unit: the module docstring, and y (this branch's _reads_back_as_text, adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504's FALSE_WORD). adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504 puts work_root before cloned in Source.__init__; its own Source.open passes both, and every other call passes four arguments by position, so none shifts.

• 6c9e585 (round K6a): rv181g's M1 (under Tests), N-1 to N-6 and N-8 (under Reviews), and SonarCloud's nine smells. MANIFEST_YAML, which nothing had read since 180902f took the pin's line from _template_table, is removed, so "project.yaml" appears twice in adopt-project.py, as on main. The Windows audit (under Counts) found nothing to change.

• a22b7f9 merges main 8beb3d9, by sha (fetched at 03:08Z): 173c00e (openRepoShape --doctor: the installed form keeps the clone of the standard it ran from and names it on the report's last line, so a NEXT line pasted after the command has exited runs instead of dying with can't open file, and it hands --json and --placement-plan <file> on to shape-doctor.py instead of refusing them (#500) #510 for openRepoShape --doctor, the form AGENTS.md names first and the one --install gives a person, prints every NEXT command as a path into its temporary clone of the standard, which its EXIT trap deletes before the person can paste the command, so each one fails with can't open file; and it refuses --json and --placement-plan, which AGENTS.md's doctor steps 7 and 4 use #500: openRepoShape --doctor), cf118ff (adopt-project.py: --org and --project must name the repository the source names, compared without case, so plan refuses --project BillingService for acme/billing-service as adopt-not-the-source instead of writing a plan whose execute acts on acme/BillingService, check finds and execute refuses a plan edited to name another as plan-not-the-source, and a source whose own name the naming policy refuses is told to rename it first, never to retype --project (#499) #513 for adopt-project.py plan never compares --project (or --org) with the repository it adopts in place, so a source named billing-service is refused with a remediation that steers to --project BillingService, which plans and checks plan ok against acme/billing-service, and execute then acts on acme/BillingService: a raw git ls-remote failure when no such repository exists, and, when a different repository of that name does, both legs, the split branch, the pull request and the topic on that repository #499: --org and --project must name the repository the source names) and 8beb3d9 (update-shape.py and shape-doctor.py: no NEXT line pre-fills --accept-local for a locally edited shape copy, so the apply a row names, pasted, meets update-local-drift and its question to the human instead of re-pinning the edit as the standard, and a shape/ collision copy merged into its original and removed is merged-away to check, whose apply drops its pin row behind the same yes, so an adopted root that did its follow-up validates green again (#501, #502) #512 for update-shape.py check's NEXT, and the doctor's shape currency row that sends the reader to it, already carry --accept-local <path> for every locally edited shape copy, so pasting the command AGENTS.md says to run as named re-pins the project's edit as the standard: no refusal, no question to the human, a green validate-pins.py and a COMPLIANT doctor, though AGENTS.md says never to pass --accept-local and that keeping the edit is the human's decision #501 and update-shape.py, validate-pins.py and shape-doctor.py: once an adopted root does its own follow-up "merge shape/.gitignore into .gitignore" and removes the merged copy, the copy's pin row is copy-missing, so the project's bootstrap.py and its validate check go red, apply refuses with a remedy (--accept-local) that is refused in the same words, and no tool removes the row, which leaves only undoing the merge or the hand edit of the pin that AGENTS.md forbids #502: update-shape.py, shape-doctor.py and collision_follow_up in scripts/shape_materialize.py). One conflict hunk, in _checked_plan_inputs, the only unit both sides changed: main passes source to _check_names, and this branch adds its comment and its two refusals after that call. Resolved as main's call, then this branch's comment and calls in order: rv181g's proposed resolution (d55b975), with N-7 bringing the comment up to date. Main's other change to the function, _refuse_another_repository before any pin's digest is read, merged cleanly above it. Every other path is git merge-tree's; scripts/shape_materialize.py merges cleanly, and no test of this branch asserts a collision follow-up. With this merge alone five tests of the quoting file failed (M1), which 6c9e585 fixes.

• Rounds K4 and K5, each by sha, are described in full in this description's edit history (the body at 9efe95a): 5c04ca2 merges main 631f087 (templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259, README.md and AGENTS.md: 28 statements the v1.0.0 accuracy pass found false are corrected to what the tools do on main (#483) #505 and update-shape.py on a holder cut before siblings.py existed: taking the new Makefile without --add scripts/siblings.py (AGENTS.md's default) breaks make siblings, park and resume #489; one conflict, tests/test_adopt_manifest_values.py, six hunks, both sides kept), e3fe7cf merges 191105a (scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266, clean), f54dce7 merges e6fbd74 (seven commits, adopt-project.py: check names, and execute refuses before the work directory is made, a plan whose source: or legs: is not a mapping or whose allow_empty_legs: or paths: is not a list of what plan writes, and asks the same first of a pins: that is not a list, so a number or a boolean in any of the four no longer ends both in a traceback and allow_empty_legs: code is no longer read as four legs (#386) #435 and adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514 among them, clean; _template_table keeps both sides; at that bare merge the 14 tests round K4 named failed) and 8ce572b merges 89c6a6c (family.py: init refuses to land in the standard's checkout and names a runnable scripts/family.py, printed commands quote paths, and add, bump and remove refuse the tracking branch and print their branch's push (#488, #486, #487) #507 and scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516, clean). 180902f and 9efe95a made the merges' sentences and those 14 rows true (under Tests and "Composes with adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514"). Before adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514 landed, rv181g's scratch merge of 180902f with 8cd7dbe failed three of adopt-project.py: check names, and execute refuses before the work directory is made, a plan whose source: or legs: is not a mapping or whose allow_empty_legs: or paths: is not a list of what plan writes, and asks the same first of a pins: that is not a list, so a number or a boolean in any of the four no longer ends both in a traceback and allow_empty_legs: code is no longer read as four legs (#386) #435's pin tests, which pass with adopt-project.py: execute writes each neutral_product_pins: entry bare, so plan --pin 007@<commit> says adoption verified over a root whose own validate-pins.py refuses entry 7 #514 merged.

• Earlier merges, each by sha: d8ed5b0 (22c9fdd), c6d61d1 (e4decfb), a0ff15b (54aa69a), 2ad82cb (39ac59c), 44c8c17 (60d08a1), e4e5e44 (d94d155), e337f44 (ede15ce), 77218c8 (60588d5), 37d7a71 (92e29d9), bd695e5 (c3f4987), 2e225fe (a5b09c3), 2405670 (71b58a1), 4c6e856 (dd8d0ea, scaffold-project.py and adopt-project.py ask the project's YAML reader and validate-manifest.py about the manifest's values before anything exists, so --id null, --tracking-branch true and a blank --elected-by are refused (#258, #261) #314), 3662784 (75052cb), dc7b79d (437a360), edf9163 (7a8b981), ed9968f (5a25387), cf6da3f (965420b) and 43b0f58 (cc8f2da), and four named among the semantic conflicts below: 6b104cf (4835fb4), 3352be4 (be2790e), bf6d656 (a1b3a4b) and e8e0026 (1f90a0f). Each conflict was resolved keeping both sides. The semantic conflicts, each fixed in a commit of its own:

  • a second _shown beside adopt-project.py plan writes a plan its own loader cannot parse when a source name holds a line break (the macOS Icon\r file), so check refuses the whole plan as yaml-unparsable with no entry to edit #199's (6b104cf; 34d683f's _line_shown);
  • repo_shape.py: a quote opens a quoted scalar only where one begins and must close there, so k: [it's, a] reads two items, k: it's fine # note drops its comment, and an unclosed "abc or a mid-key [ is refused, not misread (#249, #250) #284's render spelling a quoted value with double_quoted (3352be4, 4bf2cc4);
  • adopt-project.py and scaffold-project.py substitute the template placeholders one after another, so a free-text value holding another placeholder's token is expanded (--elected-by '{{SPEC_PATH}}' is recorded as elected_by: "spec") or, after the legs are pushed, refused as template-unsubstituted with "a defect in the substitution table of the tool you ran" #260's render putting a value in once (bf6d656, d38e143);
  • adopt-project.py: since #247 a byte that is not UTF-8 in --elected-by, --reference or the --source directory passes plan and check, and execute pushes both legs before it dies with UnicodeEncodeError in write_lf #255 naming a value this gate named too (e8e0026, dae165d);
  • scaffold-project.py and adopt-project.py ask the project's YAML reader and validate-manifest.py about the manifest's values before anything exists, so --id null, --tracking-branch true and a blank --elected-by are refused (#258, #261) #314's validator (f38d19a, the validator first);
  • adopt-project.py: check never reads a plan's elected_on: when the plan has no reference:, so plan ok is followed by an execute that creates both leg repositories and only then refuses election-date-malformed, naming --elected-on, a flag neither command takes #294's election_date (4ffd460, f911d81);
  • given bound twice by adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's _checked_plan_inputs, so every plan raised TypeError (43b0f58 names this branch's set flags_given);
  • adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's branch questions and adopt-project.py --pin <name> is accepted by plan, check and execute ("adoption verified"), but writes only the name into neutral_product_pins: and no contracts/<name>-pin.yaml, so the adopted root's own validate-pins.py (and its validate.yml) refuses with neutral-pin-missing from the first run #273's whole pins (69a743e, 94242a2).

  The gate followed scripts/repo_shape.py reads ? a: b in a flow mapping as the literal key ? a, where the block reader refuses explicit keys, and refuses {a: } and {a:} as not a flow collection: '' instead of reading {'a': None} #252's, scripts/repo_shape.py: the double-quoted reader that #247 adds (fix/adopt-plan-linebreak-names, not yet on main) resolves \x00 inside a block-scalar KEY, and _parse_mapping splits the NUL-joined sentinel record, so "a\x00b": | reads as the key a with the body b<NUL>text where main reads the literal key a\x00b #248's and repo_shape.py, validate-manifest.py: a bracket in a plain flow scalar is refused and a name holding a lone surrogate is a finding, so pins: [a, b]] is not the pin b] and name: "a\ud83db" no longer kills make validate (#301, #280) #390's reader changes with no edit.

Main is 5ed3e5d at 16:09:26Z (git ls-remote), merged here in 7d6e13c.

After the merges, no top-level name is bound twice in adopt-project.py, scaffold-project.py, scripts/repo_shape.py, update-shape.py, shape-doctor.py or setup-project.py (an AST scan, imports included), none is read and never bound, and no name adopt-project.py imports goes unread. In scripts/shape_materialize.py and scripts/family.py, YamlError and parse_yaml are each bound twice by a second import of them, exactly as on main. The branch's diff against main 5ed3e5d is six files: adopt-project.py, scripts/shape_materialize.py, tests/test_adopt_leg_paths.py, tests/test_adopt_manifest_values.py, tests/test_adopt_plan_yaml_quoting.py and tests/test_template_text_placeholders.py.

Composes with #266 (landed on main as 191105a, merged here)

Lane 2's #266 (#225) asks the same question in the shared leg-path rule, leg_path_problem, of every template line that holds a leg path, rendered by render. plan, check and execute ask that rule before this gate and before the validator. Since #259 those lines are quoted, so on the shipped templates neither rule refuses a leg path: #266's own tests/test_leg_path_yaml_scalars.py refuses only the values a real template line misreads, and skips a test whose values "the templates read ... back (#259 quotes the leg-path lines)", and READ_BACK here plans, checks and writes each of the nine leg paths as given. On a bare copy of the templates, given to both rules, test_a_leg_path_written_bare_is_266s_finding_alone asks the composition: leg_path_problem refuses null, _misread_findings names nothing (_plan_fields asks this gate about a leg path only where that rule has no answer), and check prints one finding, #266's plan-bad-leg-path. The 28 rows round K3 said whichever landed second would adjust are gone with #259: the leg paths are READ_BACK rows, and the leg-path JUDGED_ONCE row is deleted (under Tests). #266's tests run in the third set under Counts.

Composes with #514 (landed on main as e6fbd74, merged here)

Lane 2's #514 quotes an item of the manifest's neutral_product_pins: list that the project's own reader would misread (_neutral_product_pins, _neutral_pin_entry). It landed as e6fbd74 (#515, 21:42:03Z, from its head cd18a1b) and is merged here in f54dce7. Its one line on this gate's path is _template_table's NEUTRAL_PRODUCT_PINS entry. This gate asks that very table (_pin_field, through _manifest_values), so it asks the quoted line with no edit to the rule. At the bare merge exactly the 14 tests round K4 named failed: the three REFUSED pins at plan, at check and at execute (9), JUDGED_ONCE's pin-text-misread and pin-the-reader-refuses, JUDGED_BY_THE_VALIDATOR's its-reader-refuses-the-file, the template-line test and the table test. #181 is the second to land, so 9efe95a makes them true (under Tests): the pins are READ_BACK rows; the refusals are asked where the list is written bare (bare_pins), and so is G2's pin ? x; and the two line tests expect - "Null" and - "null".

9efe95a's one adopt-project.py change is to #514's own docstring on _neutral_product_pins. It said that a keyword y leaves bare reaches the list "only from a plan edited by hand, because check refuses the bare product: true that plan writes". With this branch's y, plan writes product: "true" and "null", check passes them, and execute writes - "true"; the docstring says so now.

With #514 and #516 landed, this gate finds nothing on main's templates, and stays as the backstop #314's scaffold twin is: a line a later template or table writes bare is refused again, with no edit to the rule (the tests over bare_template and bare_pins; writing the list bare again in _template_table fails 9 tests).

Composes with #513 (landed on main as cf118ff, merged here in a22b7f9)

#513 makes --org and --project name the repository the source names: plan refuses another as adopt-not-the-source, check finds a plan edited to name another as plan-not-the-source, and execute refuses it. Its _refuse_another_repository runs in _checked_plan_inputs before this gate's two refusals; check adds plan-not-the-source after _entry_findings, which holds this gate's finding; and execute refuses #513's cause before it asks check's findings. Probed at 7d6e13c in this process, as at 42362de, with the pins' list written bare (bare_pins) so that this gate names pin null, on a source whose origin is under testorg/Northwind:

• check of a plan whose org: is edited to otherorg: exit 1, plan-manifest-misread then plan-not-the-source, one each, and this gate's remediation once;
• execute: REFUSED plan-not-the-source alone, with no remote made and no split branch;
• plan --org otherorg --pin null@<commit>: REFUSED adopt-not-the-source alone, and no plan written.

So each cause is one finding at check, and plan and execute refuse #513's first. M1 (under Tests) was the one test change the merge needed.

Composes with #504 (landed on main as b0826e0, merged here in b602c16)

#504 (#183, #178) has check follow each symlink the plan keeps where the shape writes its files, and execute refuse one the shape cannot write through before any leg exists. Its plan-root-symlink findings are part of _entry_findings, the one list check prints and execute refuses, after the source's own submodules, so after this gate's finding. Probed at 7d6e13c in this process, as at 42362de, with a source that keeps scripts -> . in the root (the shape's scripts would land in the root itself, #504's R6 case) and, under bare_pins, a plan carrying pin null:

• the link alone, through the shipped code as a process: check exits 1 with plan-root-symlink alone;
• the pin alone: plan-manifest-misread alone;
• both: check exits 1 with plan-manifest-misread then plan-root-symlink, one each, and this gate's remediation once. execute exits 2 with REFUSED plan-manifest-misread: 2 finding(s), both listed in check's order, no remote made and no split branch in the source;
• plan --pin null@<commit> from that source: REFUSED adopt-manifest-misread, and no plan written; adopt-project.py: check follows each symlink the plan keeps where the shape writes its files, and execute refuses one the shape cannot write through, or one it writes beneath that git checks out as a file, before any leg exists, so such a link no longer breaks the run after both legs are pushed or has the shape's files written outside the assembly (#183, #178) #504 asks nothing at plan.

With #513's cause added too, check gives the three in that order, one each, and execute refuses #513's first. #504's test files run in the Counts above, and the Windows emulation runs tests/test_adopt_root_symlinks.py too.

Composes with #511 (landed on main as 5ed3e5d, merged here in 7d6e13c)

#511 (#471) appends one marked block of /<copy> text eol=lf lines to a source's own root .gitattributes, and verifies that file as the source's bytes followed by exactly that block. It writes nothing into the project's YAML, and adds no finding and no refusal before any leg exists (its materialize-attributes-path is for a pinned copy whose name git would read as a pattern, and the standard has none). Probed at 7d6e13c on a source that keeps its own .gitattributes:

• --spec-path null --tracking-branch true, through the shipped code as a process: check passes, and execute --local-remote-dir appends the block and ends adoption verified; the manifest reads the spec leg's path back as null and the tracking branch as true, and both legs are on true;
• in this process under bare_pins, pin null: check gives this gate's finding alone, with its remediation once, and execute refuses it before any leg exists, the source's .gitattributes untouched;
• a .gitattributes that is a symlink: check finds nothing without the pin, and this gate's finding alone with it.

With the default flags, that source adopts byte for byte as on main (33 split files).

Not in this PR

• A hand-edited plan value its own loader reads as a number or a boolean, which execute writes as str of it: a quiet residual shared with main. Probed at 7d6e13c, as at 42362de and 9efe95a: check passes id: 007, and execute --local-remote-dir adopts with id: "7"; tracking_branch: 007, the source holding 7, adopts on branch 7 (a source holding only 007 gets adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's plan-tracking-branch-missing, naming 7); tracking_branch: true, the source holding True, adopts on True; and tracking_branch: 1.50, the source holding 1.5, adopts on 1.5. Main 5ed3e5d does each the same, because checked_value falls back to str(). The line execute writes reads back as what it wrote, so this gate has nothing to name (READ_AS_NOT_TEXT: check passes each, as main does). plan never writes such a plan, because its writer quotes what would not read back. Read as not text, a leg path is plan-bad-leg-path, an election date adopt-project.py: check never reads a plan's elected_on: when the plan has no reference:, so plan ok is followed by an execute that creates both leg repositories and only then refuses election-date-malformed, naming --elected-on, a flag neither command takes #294's election-date-malformed, and a visibility the validator's manifest-visibility, named as read.
• A neutral pin's own file is scaffold-project.py: --pin 007@<commit> exits 0 and scaffolds a root whose own validate-pins.py refuses entry 7, because neutral_product_pins: entries (and the pin file's product:) are written bare #516's, which landed (89c6a6c, merged here) and quotes its product:: at this head --pin null@<commit>, True@, 007@ and 2026@ adopt and bootstrap with - "<product>" in the manifest and product: "<product>" in the pin file, each read back as typed, and both of the root's own validators exit 0 (probed).
• The scaffold's twin is scaffold-project.py and adopt-project.py ask the project's YAML reader and validate-manifest.py about the manifest's values before anything exists, so --id null, --tracking-branch true and a blank --elected-by are refused (#258, #261) #314 (for scaffold-project.py writes --id and --tracking-branch into project.yaml unquoted, so --id null or --id true scaffolds a project whose first bootstrap fails manifest-id, and --tracking-branch true, 007 or null puts the clone's legs on True, 7 or main with no upstream: #181's defect on the scaffold side, beside #225 #258), merged here. Its rule asks the reader in scripts/shape_materialize.py (manifest_misreads(values, what)), beside this branch's in adopt-project.py; both hand each template line to render and ask parse_yaml. Since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259 neither refuses a value the template quotes. Making them one function is a follow-up.
• Gone since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259: rv181f's G3 residual (a visibility the loader read as no value) and H1's (~). Probed at 9efe95a: visibility set to "", "null", "~", "#", " ", |- or "'private'" is one plan-manifest-invalid each, the validator's manifest-visibility, and execute refuses it before any leg exists, with no gh call. --tracking-branch ~, and a hand-edited tracking_branch: "~", are adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's: plan records it with adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479's note, check finds plan-tracking-branch-missing, and execute refuses it before any leg exists.
• Moot since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259: round K3's two adopt-project.py: a source whose default branch is not main is adopted with both legs pushed, then its pull request is refused (--base main), and the printed way out repeats --base main #479 limits. A misread branch only the source's origin has (--tracking-branch true): check says plan ok, and execute --local-remote-dir refuses it as plan-tracking-branch-missing (git ls-remote) before any remote is made. One the clone remembers after origin dropped it: plan ok, and execute --local-remote-dir adopts on true. Neither is misread any more: the plan says "true", and the manifest's line is quoted.
• Numeric branch names (2026, 1.5) adopt and bootstrap as typed, here and on main since templates/assembly-root/project.yaml and the two leg pins write eight text placeholders bare (id, elected_on, visibility, tracking_branch, the two leg paths and submodule_paths), so a checked value YAML reads as another type (007, 2026, true, null) is misread by the project or refused by the tool; quoting them reads every one back exactly and lets numeric branch names adopt #259: each leg's HEAD is 2026 with origin/2026 as its upstream.

Closes #181

🤖 Generated with Claude Code

[sourcery-ai]

Sorry @brettheap, your pull request is larger than the review limit of 150,000 diff characters

[brettheap]

@codex review

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-14T01:03:01.873199Z	9efe95a	Manual request

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

Codex Review: Didn't find any major issues. What shall we delve into next?

Reviewed commit: 9efe95a981

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[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