[brettheap]

Lane: openreposhape-5 (openRepoShape-5)
Claim: #1053 (comment)

Found by lane 5's independent review of #1044 (#980), rv980, and filed as #1053. Two commits on origin/main 6476c170 (made on 8a057215; the rebase was clean and docs/cli.md needed no regeneration): 2e6dd9e5, the change, and 7ff61666, fix round 1 (rv1067's SHOULD-1: one more test row, no code). Five files change (+396, -52): templates/assembly-root/scripts/validate-pins.py, scripts/validate-repository-naming.py, docs/cli.md, tests/test_neutral_pin_validator.py and tests/test_link_source_chain_defaults.py.

Both scripts are pinned copies (COPIED_VERBATIM and COPIED_FROM_SHAPE), so every existing root takes two upstream-changed rows, scripts/validate-pins.py and scripts/validate-repository-naming.py, and re-pins. No digest of either file is kept anywhere in tests/: the texts that pin the help and the docstrings are held by test_cli_reference.py (regenerated) and test_pinned_copy_text.py (runtime), and both pass.

The Goal

validate-pins.py reads a --pin-source key as the naming gate has read a --link-source key since #980 (the longest declared pin before an = that leaves a path after it), so a pin whose name holds = can be a key, and the sentence saying the two copied tools read [PRODUCT=]PATH one way is true.

This is consistency, not a live failure. No scaffold writes a pin holding = (PIN_ARG_RE admits [A-Za-z0-9_.-]), only a hand-edited project.yaml declares one, and a pin's digest stops a wrong source from passing: a wrong tree is a finding and never a pass.

What was wrong

PinSources.__init__ cut every value at its FIRST = (typed.partition("=")), and two more places cut at the first = on their own: the no-path refusal and read_as_path.

• With open=y declared, --pin-source open=y=<tree> was a bare PATH that is not there: the neutral-pin-source-unreadable FINDING, exit 1.
• With open and open=y both declared, open=y=<tree> was open's, with the path y=<tree>. open=y read neither value, and of open=<a> and open=y=<b> the later replaced the earlier.
• open=y= was a bare PATH, where openGlass= is refused pin-source-no-path (scripts/validate-repository-naming.py _link_sources_from_args (:406) and templates/assembly-root/scripts/validate-pins.py PinSources (:409): a key with an empty path (--link-source openXdox=, --pin-source openXdox=) is Path(""), which is the current directory, so run from a project root the naming gate reads the project's OWN project.yaml as the link's declaration and reports a chain that holds as broken, a FINDING (exit 1) for a name with no direct pin #442).

What changed

• PinSources._read_source(typed) (new, validate-pins.py), returning (product, before, path). It reads a key as the naming gate's LinkSources._read_source reads a link: the LAST = whose text names a declared pin by pin_product_key, with a non-empty path after it, ends the key. The key is read whole (never stripped, never cut at a /) and the pin is spelled as project.yaml spells it. A value that ends at a declared pin, with no shorter one leaving a path, is that pin's with an empty path. Anything else is a bare PATH, whole.
• __init__, the no-path refusal and read_as_path all use it, so nothing cuts at the first = on its own. self.names (was a local) is the table it reads against. read_as_path keeps its words (tests/test_chain_remedy_callers.py: no row holds #980's unchanged --link-source reading at the old first-= split's corners (path =x, blank path, key in capitals), so four gate mutants survive #1054's wording improvement is out of scope): the text it names is _read_source's before, which for a bare value is the text before the first =.
• Words made true: the PinSources docstring (THE READING, the no-path paragraph, a new "THE TWO COPIED TOOLS READ [PRODUCT=]PATH ONE WAY" paragraph that now holds with no exception), the --pin-source help, and docs/cli.md regenerated from it by scripts/render-cli-reference.py (only that option's block changed).
• Item 5, the gate's LinkSources docstring (scripts/validate-repository-naming.py, the only change in that file): the "still ends a key at the first =" sentence is gone, and so is the casefold() passage (false since validate-pins.py: an unsearchable contracts/ still ends in a PermissionError, an unreadable pin is named by its absolute path twice, and a workflow name or a pin entry's control character reaches stderr raw #712: both tools key by pin_product_key) and the "one way OVER ASCII ONLY (scripts/repo_shape.py: the chain readers identify a link, a declared pin and a --link-source key by casefold() (twelve calls, :1207 to :2428), where #275's fix (PR #409, 6494714) makes a product's identity pin_product_key (lower(), the pin file's own fold), so openß and openss are two products to the pin validator and one link to the chain: a holder's tree that declares openss verifies a chain that says openß, a project that pins openss verifies a chain that begins at openß, a --link-source openss= answers for the link openß, link_pins_from_trees keeps one entry for the pair, and a chain that names both is refused as a cycle #444)" clause. Four lines say what is true, and name PinSources._read_source (validate-pins.py: --pin-source still ends a key at the first =, as --link-source did before #980, so a pin whose name holds = is never a key, and a docstring says the two tools read one way #1053).
• Tests, 17 new rows: 14 in tests/test_neutral_pin_validator.py beside the templates/assembly-root/scripts/validate-pins.py: a bare --pin-source <path> whose path holds an = is read as <product>=<path> (raw.partition("=")), so a stand-in clone under a directory named a=b is never consulted and the pin's digest silently goes to gh api and a skip (pins ok, exit 0), or, when the text before the = is a declared pin's name, to a FileNotFoundError traceback #295 rows (section "validate-pins.py: --pin-source still ends a key at the first =, as --link-source did before #980, so a pin whose name holds = is never a key, and a docstring says the two tools read one way #1053"), and 3 in tests/test_link_source_chain_defaults.py beside the scripts/validate-repository-naming.py _link_sources_from_args (:406) and templates/assembly-root/scripts/validate-pins.py PinSources (:409): a key with an empty path (--link-source openXdox=, --pin-source openXdox=) is Path(""), which is the current directory, so run from a project root the naming gate reads the project's OWN project.yaml as the link's declaration and reports a chain that holds as broken, a FINDING (exit 1) for a name with no direct pin #442 rows. A pin holding = cannot be scaffolded, so each row hand-writes the neutral_product_pins: entry and its pin file with the helper declare_by_hand (the link file imports it). The existing scripts/validate-repository-naming.py _link_sources_from_args (:406) and templates/assembly-root/scripts/validate-pins.py PinSources (:409): a key with an empty path (--link-source openXdox=, --pin-source openXdox=) is Path(""), which is the current directory, so run from a project root the naming gate reads the project's OWN project.yaml as the link's declaration and reports a chain that holds as broken, a FINDING (exit 1) for a name with no direct pin #442 row now builds its expected stderr through a shared pin_source_no_path helper, with the same assertion.

The rows:

• a declared pin open=y verified by --pin-source open=y=<tree>, as declared and in capitals;
• open and open=y both declared, each given its own tree, in either order, and with a path that begins like the longer pin (open=./y=dir): both verify, neither replaces the other;
• open=y= with open declared too is open's, with the path y=, never refused;
• open=y= and OPEN=Y= with only open=y declared are refused pin-source-no-path, exit 2, in openGlass='s words;
• a value naming no declared pin (a leading blank, an owner prefix, open=z=x) is a bare PATH, whole, and so is one that ENDS in an = no declared pin names (open=z=, rv1067's SHOULD-1), never refused and never read as a pin's;
• the note for a bare value names the text before its first =;
• a keyed OPEN=Y=<tree> names the pin as the manifest spells it, open=y, where the digest was never recomputed;
• the old split's corners, openGlass==x and openGlass= , are still openGlass's.

The probe, before and after

PinSources(values, declared), read at 8a057215 and at the head (probe-base.log, probe-head.log):

declared [open=y], value open=y=/p
  at 8a057215   reading {'open=y=/p': None}  (a bare PATH)
  with this     reading {'open=y=/p': 'open=y'}, keyed to open=y with the path /p
declared [open, open=y], values open=y=/p then open=/q
  at 8a057215   both 'open'; keyed {'open': ('open=/q', '/q')}, open=y read nothing
  with this     {'open=y=/p': 'open=y', 'open=/q': 'open'}, each pin its own
declared [open=y], value open=y=
  at 8a057215   a bare PATH, no refusal
  with this     REFUSED pin-source-no-path
controls, the same at both: openGlass= REFUSED pin-source-no-path; openss= with a declared
  open + sharp s is a bare PATH; ' open=y=x', 'opensoft/open=y=x' and 'open=z=x' with open=y
  declared are bare PATHs, whole.

The tests that fail at main

The final test files copied onto a clone of 8a057215, the 17 new rows: 11 failed, 6 passed. Each failure is on the defect (the source read as a bare PATH, or open=y read none). The 6 that pass pin readings that did not change, by design: the four bare-PATH rows (a leading blank, an owner prefix, no declared pin, and a value that ends at no declared pin) and the two old-split corners.

Unchanged where no declared pin holds =

The base and the head copies of validate-pins.py were run with --root, over the same root and directory, comparing stdout, stderr and exit code: 7 pin lists, none holding = (one pin, two, none, capitals, a sharp s, one variable, a scalar), and 40 values singly plus 182 ordered pairs of 14 values (capitals, a leading blank, an owner prefix, ./openGlass=x/openGlass, the #295 rows' values). 1554 runs, 0 differing; the head's exit codes were 0 (502), 1 (1037) and 2 (15). The rebase did not touch validate-pins.py.

Mutants

Each applied alone to a scratch tree's copy of the change, run against the three files that exercise PinSources (test_neutral_pin_validator.py, test_link_source_chain_defaults.py, test_validate_pins_named_and_spelled.py), through run9.sh. 17 of 18 killed; the 18th is equivalent. The counts are the passes and fails of 408 tests (the files as of 2e6dd9e5); R5, and M1, M2 and M16a rerun on the final files (409 tests), are noted under the table.

mutant	result	failed / passed	killed by (a few)
M1 back to typed.partition("=")	killed	11 / 397	the own-key, shorter-pin and both-declared rows
M2 the shortest match instead of the longest	killed	5 / 403	the shorter-pin and both-declared rows
M3 the "leaves a path after it" check dropped	killed	1 / 407	the shorter-pin row
M4 the key stripped	killed	1 / 407	the bare-PATH row (a leading blank)
M5 the key not folded by pin_product_key	killed	21 / 387	the capitals rows, the #295 rows
M6 the no-path refusal back to its own first-= cut	killed	2 / 406	the two open=y= refusal rows
M7 read_as_path back to typed.partition("=")[0]	survived	0 / 408	none: equivalent, below
M8 before the longest text tried, not the shortest	killed	8 / 400	the note row, the corners row
M9 the empty-path fallback dropped	killed	10 / 398	the refusal rows
M10 the fallback keyed at the first =	killed	2 / 406	the two open=y= refusal rows
M11 the key cut at its last /	killed	2 / 406	the owner-prefix row, the directory row
M12 the keyed path read after the first =	killed	8 / 400	the both-declared and own-key rows
M13 the scan skips an adjacent =	killed	1 / 407	the openGlass==x corner
M14 a blank path names none	killed	1 / 407	the openGlass= corner
M15 the no-path refusal strips the path	killed	1 / 407	the openGlass= corner
M16a the keyed pin spelled as typed	killed	2 / 406	the manifest-spelling row
M16b the no-path pin spelled as typed	killed	2 / 406	the capitals refusal rows
R5 (rv1067's) the if product is not None: guard dropped from the empty-path fallback	killed, after the fix; it survived all 408 tests at 2e6dd9e5	1 / 408	the bare-PATH row ends-at-no-declared-pin

R5 and the fix round. rv1067's mutant R5 returns product, typed[:-1], "" for every value ending in =, so --pin-source open=z= with open=y declared (or x=, ../build= with openGlass) ended in an AttributeError traceback in _shown(None). It survived because no row held a bare PATH ending in =. 7ff61666 adds the fourth value open=z= (id ends-at-no-declared-pin) to test_a_value_naming_no_declared_pin_is_a_bare_path_whole: it passes at 8a057215 and at the head, by design, and fails under R5 (1 failed, 408 passed). Rerun on the final files (409 tests): M1 killed 11 / 398, M2 killed 5 / 404, M16a killed 2 / 407. The code is unchanged by the round.

M7 is equivalent. read_as_path says anything only for a value no declared pin is keyed to, and for such a value the scan's last turn is at the value's first =, so _read_source's before IS the text before the first =: the two spellings print the same words for every value. Not a gap.

Runs

At the committed head 2e6dd9e5 (the 88-file shards below; 7ff61666 changes one parameter of one test, run next), through run9.sh (gh stub first on PATH, GH_TOKEN=bogus, an empty GH_CONFIG_DIR, GIT_SSH_COMMAND=false, GIT_CONFIG_GLOBAL=/dev/null, no LANES_* variable):

• git 2.43.0 (/usr/bin/git): the 88 test files that name validate-pins or validate-repository-naming, which include the three mutant files, test_chain_remedy_callers.py, test_pinned_copy_text.py and the trio (test_repo_hygiene.py, test_agents_md_codes.py, test_cli_reference.py), in four shards: 1376 passed, 4 skipped; 1702 passed; 1963 passed, 2 skipped; 1812 passed, 6 skipped. 6853 passed, 12 skipped, 0 failed.
• git 2.47.1 (exactly $Q/v115/w764/git247/bin/git, first on PATH): the three mutant files: 408 passed.
• At 7ff61666: the three mutant files, 409 passed on git 2.43.0 and 409 passed on git 2.47.1.
• The rest of the suite is left to CI's tests job.

The upgrade rows

From a root scaffolded at 8a057215 (scaffold-project.py with local remotes, cloned with submodules), update-shape.py at the head:

• check --at 2e6dd9e5 lists upstream-changed for scripts/validate-pins.py and scripts/validate-repository-naming.py (upstream-changed 2, unchanged 9);
• apply --yes --branch shape/update-2e6dd9e56eb8 exits 0, copies both files, re-pins 8a0572157723 -> 2e6dd9e56eb8, and the root's own validators print pins ok and manifest ok: Atlas (atlas), 3 legs;
• a fresh check prints unchanged 11 and nothing to do; the root's two copies are byte for byte the head's (sha256 adc1f7d8... and fc5c9f81...).

Merge checks

git merge-tree --write-tree of the head 7ff61666 against: origin/main 9cbba9d5 clean (tree d776b7d7), and the one open PR that still touches one of these files, #1062 (fix/1040-windows-start-errors, 957ba038, which edits validate-pins.py around _git_runs, not the PinSources region) clean (tree aa6fc31b). #1063 (d996ebf1, docs/cli.md) is no longer in the open list. At 2e6dd9e5 the same three were clean against 00f6d7f7, #1062 01a8b759 and #1063. Since the rebase main has changed docs/cli.md (8 lines added, 2 removed, outside the --pin-source block) and none of the other four files, and the merge-tree against it is clean, so the branch needs no rebase.

Closes #1053

🤖 Generated with Claude Code

Summary by Sourcery

Make pin-source resolution consistently support declared pin names containing = while preserving existing path handling.

Bug Fixes:

• Make --pin-source correctly recognize declared pin names containing = and reject values that name no path.

Enhancements:

• Align pin-source parsing with link-source parsing by selecting the longest declared key that leaves a path.
• Clarify pin-source behavior in CLI help and validator documentation.

Documentation:

• Update the generated CLI reference and validator documentation for pin-source keys containing =.

Tests:

• Add coverage for equals-containing pin names, overlapping keys, empty paths, bare paths, spelling normalization, and legacy parsing cases.

[sourcery-ai]

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

You can request another review in 1 day and 2 hours by commenting @sourcery-ai review. Upgrade to get a review now.

[sourcery-ai]

Reviewer's Guide

Updates pin-source parsing to consistently select the longest declared pin key that leaves a path, enabling pins containing = while preserving bare-path and no-path behavior; documentation and copied-validator guidance are updated, with comprehensive regression tests for overlapping keys, spelling, and edge cases.

Sequence diagram for longest declared pin-source resolution

sequenceDiagram
    participant CLI
    participant PinSources
    participant Manifest
    participant Filesystem
    CLI->>PinSources: __init__(values, declared)
    PinSources->>Manifest: pin_product_key(before)
    Manifest-->>PinSources: declared pin spelling
    PinSources->>PinSources: _read_source(typed)
    alt longest declared key leaves a path
        PinSources->>Filesystem: read_as_path(path)
        Filesystem-->>PinSources: source tree
        PinSources-->>CLI: verify keyed pin
    else value ends at declared pin
        PinSources-->>CLI: Refusal pin-source-no-path
    else no declared key matches
        PinSources-->>CLI: use bare PATH
    end

Loading

Flow diagram for pin-source key resolution

flowchart TD
    A["--pin-source value"] --> B["Scan = separators from right to left"]
    B --> C{"Declared pin key leaves a path?"}
    C -->|Yes| D["Use longest matching key"]
    D --> E["Read remaining text as path"]
    C -->|No| F{"Value ends at a declared pin?"}
    F -->|Yes| G["Refuse pin-source-no-path"]
    F -->|No| H["Treat whole value as bare PATH"]

Loading

File-Level Changes

Change	Details	Files
Align --pin-source parsing with --link-source by resolving the longest declared pin name before an = that leaves a non-empty path, including pin names containing =.	Added PinSources._read_source to scan candidate separators from right to left using pin_product_key, preserving manifest spelling and bare-path behavior. Updated initialization, no-path refusal, and path-note generation to use the shared parser. Preserved empty-path refusal while allowing a shorter declared pin to claim a remaining path, such as open=y= resolving to open when both pins exist.	templates/assembly-root/scripts/validate-pins.py
Refresh user-facing documentation and copied-validator guidance to describe the unified longest-key parsing semantics.	Updated --pin-source help text and regenerated CLI documentation. Revised the naming validator docstring to remove obsolete first-= and case-folding claims and reference the shared semantics.	docs/cli.md scripts/validate-repository-naming.py
Add regression coverage for pins containing = and parser edge cases.	Added hand-declared pin fixtures and tests for exact and case-insensitive keyed sources, overlapping pins, path-like values, empty paths, bare paths, manifest spelling, and legacy split corners. Refactored shared no-path stderr construction while retaining existing behavior checks.	tests/test_neutral_pin_validator.py tests/test_link_source_chain_defaults.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#1053	Parse each --pin-source using the longest declared pin name before an = that leaves a non-empty path, while treating a value ending at a declared pin as a no-path refusal when no shorter declared pin leaves a path.	✅
#1053	Use the same parsed reading for source classification, no-path refusal, and read_as_path, preserving the existing behavior for values where no declared pin name contains =.	✅
#1053	Update the copied tools’ help and documentation to describe their consistent reading, and correct the naming-gate docstring’s stale claims about first-= parsing and casefold().	✅

Possibly linked issues

• validate-pins.py: --pin-source still ends a key at the first =, as --link-source did before #980, so a pin whose name holds = is never a key, and a docstring says the two tools read one way #1053: The PR implements the issue’s parsing, no-path refusal, documentation, and pinned-copy updates for equals-sign pin names.

---

Tips and commands

Interacting with Sourcery

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

Customizing Your Experience

Access your dashboard to:

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

Getting Help

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

[brettheap]

(lane openRepoShape-5, 2026-10-20T17:20Z) @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-20T17:25:13.129760Z	2e6dd9e	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. Delightful!

Reviewed commit: 2e6dd9e56e

ℹ️ 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".

[brettheap]

Independent review of #1067 (#1053) at 2e6dd9e5, for lane openRepoShape-5: READY

There is no MUST. There is one SHOULD: a mutant of mine survives, and one more parameter row would kill it. There is one NIT. Every number in the body that I re-measured came out the same.

Findings

SHOULD-1. No row holds a bare PATH that ends in =, so my mutant R5 survives.

• Where: templates/assembly-root/scripts/validate-pins.py:1600-1603 (the empty-path fallback in _read_source) and tests/test_neutral_pin_validator.py:654-656.
• The mutant: R5 drops the if product is not None: guard from the fallback, so it reads return product, typed[:-1], "" for every value that ends in =.
• Result: 408 passed, 0 failed ($Q/v118/rv1067/mut-R5.log).
• The failure it hides: under R5, --pin-source x=, --pin-source ../build= (with openGlass declared) and --pin-source open=z= (with open=y declared) each end in a traceback, AttributeError: 'NoneType' object has no attribute 'isprintable' in _shown(None) at __init__:1548. At the head, each is the bare PATH x=, ../build= or open=z=, which I probed.
• Why it matters: the issue says "Any other value is a bare PATH, whole". The three bare-PATH rows (" open=y=x", "opensoft/open=y=x", "open=z=x") do not end in =, and nothing else in the three files passes a bare value that does.
• The fix: add a fourth parameter, for example "open=z=" with id ends-at-no-declared-pin, to test_a_value_naming_no_declared_pin_is_a_bare_path_whole. The row's standin_at(product, tmp_path / typed) already makes that directory. The row would pass at base and at head, by design, and fail under R5.
• The code at the head is right: my probes (below) cover such values with 0 differences. This is a gap in the tests only.

NIT-1. The two readers scan alike, but their name tables still differ. The new "THE TWO COPIED TOOLS READ [PRODUCT=]PATH ONE WAY" paragraph (validate-pins.py:1508-1514) and the gate's LinkSources docstring (validate-repository-naming.py:266-271) do not say so.

• Line by line, PinSources._read_source is LinkSources._read_source plus a before value:
  • the same rfind loop;
  • the same pin_product_key lookup;
  • the same non-empty-path test;
  • the same endswith("=") fallback;
  • the same (None, typed) for a bare PATH.
• Measured in process over 1,610 (names, value) pairs: they part on 33. Every one comes from a name table, not from the scan:
  • 15 pairs: two declared spellings fold to one key (openGlass, OPENGLASS). The pins table keeps the last spelling, because its dict comprehension is unchanged since before this PR. The gate keeps the first.
  • 18 pairs: names holding /. The gate's names are repo_basenames, so a declared opensoft/openGlass or openGlass/ is a key in validate-pins.py and not in the gate.
• On every name list both tools build alike, including lists that hold =, they part on 0.
• Both differences existed before this PR, both need a hand-edited manifest, and neither changes which key or path a value reads for names the two tables share. No change is needed. A clause or a follow-up is optional.

Checked and true

1. The reader matches the issue.

   • It takes the longest declared pin before an = that leaves a non-empty path, reads the key whole and spells the pin as project.yaml does.
   • open=y= with only open=y declared is refused pin-source-no-path, exit 2, in openGlass='s words.
   • Everything else is a bare PATH, whole.
   • __init__, the no-path refusal and read_as_path all use _read_source.
   • I reproduced the body's before/after probe exactly at 8a057215 and at the head: {'open=y=/p': None} became 'open=y'; the both-declared case became each pin with its own source; open=y= went from a bare PATH to refused; the controls (openGlass= refused, openss= with openß declared a bare PATH, the blank, owner and open=z=x values bare) are the same at both.

2. Nothing changes where no declared pin holds =.

   • As programs: the base and head copies, run with --root over one root I scaffolded myself, with 4 pin lists (one pin, two pins, capitals OPENGLASS, openInk first). Each list took 40 single values and 132 ordered pairs. The values included blanks, =, ==, owners, values starting with =, values ending in =, case-folded keys, openß/openss, the templates/assembly-root/scripts/validate-pins.py: a bare --pin-source <path> whose path holds an = is read as <product>=<path> (raw.partition("=")), so a stand-in clone under a directory named a=b is never consulted and the pin's digest silently goes to gh api and a skip (pins ok, exit 0), or, when the text before the = is a declared pin's name, to a FileNotFoundError traceback #295 values (./openGlass=x/openGlass, openGlass=x/openGlass, a=b/openGlass) and wrong trees. 688 value sets, 1,376 program runs, 0 differing. Exit codes at the head: 0 (78), 1 (468), 2 (142).
   • In process: every PinSources attribute and every read_as_path, over 16 pin lists × (53 values + 53² pairs). 45,792 comparisons, 0 differing.
   • The algebra agrees: pin_product_key is lower(), which never adds or removes an =, so only the first = can name a pin that holds none.

3. The 16 new rows (13 in test_neutral_pin_validator.py, 3 in test_link_source_chain_defaults.py).

   • With the head's two test files copied onto a worktree at 8a057215: 11 failed, 5 passed.
   • Each failure is on the defect: a bare PATH that is not there, open=y reading nothing, or exit 1 where exit 2 is due.
   • The 5 that pass are the bare_path_whole[a-blank, an-owner, no-declared-pin] rows and the two old_split_s_corners rows.
   • No added assert joins conditions with and or or. Every added line is at most 79 characters, within the files' own widths of 80 to 93.
   • test_link_source_chain_defaults.py still collects alone with its new import of declare_by_hand (26 tests).

4. Mutants, each alone in a scratch worktree, over the 3 files (408 tests), through run9.sh.

   • The writers' five, all killed with the body's counts: M1 11/397, M2 5/403, M5 21/387, M12 8/400, M16a 2/406.
   • M7 is equivalent, and I agree. For a value read as a bare PATH, the scan's last turn is at the value's first =, and a hit in the endswith fallback would make the value keyed, not bare. So before is typed.partition("=")[0]. Measured: 1,291 bare values holding =, over pin lists with and without =, 0 where the two differ.
   • My own six:

Mutant	What it changes	Result
R1	the fold dropped from the no-path fallback only	killed, 4
R2	the first declared pin in manifest order instead of the longest	killed, 4
R3	the no-path reading tried before any shorter pin	killed, 1 (the shorter-pin row)
R4	a bare value's before is the whole value	killed, 3
R5	the fallback guard dropped	survived (SHOULD-1)
R6	the new reader keyed by casefold() again	killed, 2

• Each tree was checked byte for byte against the head's file after its lane.

5. docs/cli.md.

   • scripts/render-cli-reference.py --check prints [ok] docs/cli.md is what the generator produces, and tests/test_cli_reference.py passed.
   • Only the --pin-source block changed. Its help is true, including the bare-PATH and ./ clauses.
   • scripts/validate-repository-naming.py changes only in its docstring. validate-pins.py adds no import, so no older pinned repo_shape.py is at risk. test_pinned_copy_text.py passed.

6. Upgrade rows. The body matches the logs under $Q/v118/w1053/upg/ (check1.log, apply.log, check2.log, pins.log, manifest.log):

   • the first check lists upstream-changed 2 unchanged 9;
   • apply copies both files, re-pins 8a0572157723 -> 2e6dd9e56eb8 and prints pins ok and manifest ok: Atlas (atlas), 3 legs;
   • the second check prints unchanged 11 and nothing to do;
   • the head's two files hash to adc1f7d8… and fc5c9f81… from the git objects, which I recomputed;
   • neither digest appears anywhere in tests/.

7. Runs at 2e6dd9e5 through run9.sh, with EMAIL, GIT_SSH_COMMAND=false and GIT_CONFIG_GLOBAL=/dev/null exported:

   • git 2.43 (/usr/bin/git): the 3 mutant files, test_cli_reference.py, test_repo_hygiene.py, test_agents_md_codes.py and test_pinned_copy_text.py. 665 passed, 0 skipped.
   • git 2.47.1 (exactly $Q/v115/w764/git247/bin/git; git --version printed 2.47.1 under run9.sh's PATH): the 3 mutant files. 408 passed.

8. Merges. I fetched again at 17:29Z. origin/main is 00f6d7f7.

Against	Head	merge-tree	Tree
origin/main	00f6d7f7	clean	e52427f3
#1062	01a8b759	clean	d2fb528d
#1063	d996ebf1	clean	88c9721d

• All three trees are the body's.
• Main's move from 6476c170 touches only templates/family-root/scripts/bootstrap.py and its test.

9. Title and body.
   • The title is 236 characters, read live. It is true: "open=y= is refused" is said where open=y alone is declared, and the body gives the shorter-pin exception.
   • GitHub's closingIssuesReferences is [1053], and the body's only closing keyword is Closes #1053. The Sourcery "Bug Fixes:" heading names no issue.
   • SonarCloud on PR validate-pins.py: a --pin-source key is the longest declared pin before an = that leaves a path, as a --link-source key is since #980, so open=y=<path> verifies the pin open=y and open=y= is refused as naming no path (#1053) #1067: the quality gate is OK, new duplication is 0.0%, and there are 0 open issues.
   • Cognitive complexity of _read_source is 7 by S3776, against 15. __init__ dropped one conditional expression from its base form.

Could not verify

• Body numbers I did not re-run (the logs are there):
  • The writers' 1,554-run, 0-differing table. I ran my own: 1,376 program runs plus 45,792 in-process comparisons.
  • Mutants M3, M4, M6, M8 to M11, M13 to M15 and M16b.
  • The 88-file shard totals: 6,853 passed, 12 skipped. I read them from $Q/v118/f1053/head-s1.log to head-s4.log, which match the body and record head 2e6dd9e5. I did not re-run them.
• Not my own run: the upgrade run itself. I read its logs rather than running upg.sh again.
• Not checked: f1053's 2.47.1 log does not print git --version. My own 2.47.1 run proves that version for the same 408 tests.
• No Windows or macOS run. CI is Linux-only since ci: run the test suite on Linux only #597.

Checklist candidates

• When a reader gains a fallback with a guard, add a row where the guard's other branch matters. Here that is a bare value ending in = that names no declared pin.
• When two pinned copies claim to read "one way", compare their name tables as well as their scans: which spelling of a fold-duplicate wins, and whether names are basenamed.

Scratch I leave

• Notes, scripts and logs in /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/rv1067/:
  • logs: at-main.log, h243.log, g247.log, subcmp.log, mutants-A.log, mutants-B.log, and one mut-*.log per mutant;
  • scripts: inproc.py, inproc2.py, subcmp.py, mut.py;
  • the cmp/ probe root, the vp-* and vrn-* copies, and a __pycache__.
• Basetemps:
  • /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v110/bt/rv1067-h243
  • /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v110/bt/rv1067-g247
  • /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v110/bt/rv1067-main
  • /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v110/bt/rv1067-mA
  • /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v110/bt/rv1067-mB
• Removed: all four scratch worktrees (rv1067-head, -main, -mutA, -mutB), each clean and taken out with git worktree remove. Deleted: the refs refs/l5rv/rv1067-pr1067, -pr1062 and -pr1063.
• Nothing of mine is running. I ran no rm, no git config and no real gh in a run; my only gh call was one read of gh pr view 1067. I pushed, posted and filed nothing.

[brettheap]

Re-check of #1067 (#1053) at 7ff61666, for lane openRepoShape-5: READY

SHOULD-1 is fixed: the new row kills my mutant R5, and no test file changed outside that one row. NIT-1 stays open by agreement and needs no change. There are no new findings.

1. The new commit changes only that test file.

   • git diff --stat 2e6dd9e5 7ff61666 gives tests/test_neutral_pin_validator.py | 13 ++++++++----- (+8/-5), and 7ff61666^ is 2e6dd9e5.
   • The commit adds "open=z=" with the id ends-at-no-declared-pin to test_a_value_naming_no_declared_pin_is_a_bare_path_whole, and rewords that test's docstring.
   • validate-pins.py at the new head is byte for byte the copy I reviewed at 2e6dd9e5 (checked with cmp).
   • No added assert joins conditions with and or or, and the widest added line is 77 characters.

2. R5 is killed by the new row alone.

Run	Result
R5, new row alone	1 failed
R5, all 409 tests of the three files	killed, 1 failed / 408 passed; the only failure is [ends-at-no-declared-pin]
The row unmutated, at the head	passes (in both 409-test runs below)
The row at 8a057215 (head's test files copied onto a worktree there)	passes, by design

3. The three mutant files pass at 7ff61666.

   • git 2.43.0: 409 passed.
   • git 2.47.1, exactly $Q/v115/w764/git247/bin/git (it printed git version 2.47.1): 409 passed.

4. The body's changed numbers are true.

   • 17 new rows: 14 in test_neutral_pin_validator.py and 3 in test_link_source_chain_defaults.py.
   • At 8a057215, 11 failed and 6 passed. The 6 are the four bare-PATH rows (now including ends-at-no-declared-pin) and the two old-split corners.
   • Line counts: five files, +396/-52 from 6476c170.
   • Mutant table:
     • The R5 row says 1 / 408. I measured that.
     • M1 11/398, M2 5/404 and M16a 2/407 on the final files: I re-ran these three on the new row alone, and it passes under each. My earlier full runs on the 408 tests that did not change gave 11, 5 and 2 killed. Together that gives the body's counts.
     • The other rows are unchanged from 2e6dd9e5: M1, M2, M5, M12 and M16a I measured then; the rest I did not re-run.
     • "17 of 18 killed; the 18th is equivalent" holds: M7 is still the equivalent one.
   • Closing keyword: the only one is Closes #1053. The title is 236 characters, and GitHub's closing references are [1053] (one gh read).
   • Main's docs/cli.md change: 6476c170..9cbba9d5 changes docs/cli.md +8/-2, in one hunk at line 959 in the family.py block, outside the --pin-source block. Main changed none of the other four files.

5. Merges (fetched again at 17:58Z):

Against	Head	merge-tree	Tree
origin/main	9cbba9d5	clean	d776b7d7
#1062	957ba038	clean	aa6fc31b

• Both trees are the ones the body names.
• The predicted merge still matches the generator. I wrote tree d776b7d7 into a scratch worktree at 9cbba9d5 with read-tree -u --reset. There, scripts/render-cli-reference.py --check prints [ok] docs/cli.md is what the generator produces, exit 0.

Not verified: the body's other mutant rows (M3, M4, M6, M8 to M11, M13 to M15, M16b), the 88-file shard totals and the upgrade rows are unchanged from 2e6dd9e5. I checked those at the first review from the writers' logs, not here.

Scratch I leave:

• New logs and a script in /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad/v118/rv1067/:
  • logs: re-h243.log, re-g247.log, re-at-main.log, re-mutants-R5.log, re-mut-one.log, re-live-body.md, mut-R5-at-2e6dd9e5.log;
  • script: mut_one.py.
• Basetemps reused under $Q/v110/bt/rv1067-*.
• Removed: the worktrees rv1067-head2, -main2, -mut2 and -merge, each clean, with git worktree remove. Deleted: the refs refs/l5rv/rv1067-pr1067 and -pr1062. No rv1067 worktree, ref or process is left.
• I ran no rm, no git config and no real gh in a run, and pushed, posted and filed nothing.

[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