[brettheap]

Lane: openreposhape-2 (openRepoShape-2)
Claim: #239 (comment)

What

update-shape.py no longer reads a link as "nothing there" at a path apply --add would write. A link here is a symlink, or a Windows junction. The ledger also no longer writes an addition through a link, or over a file, that arrives after the check.

• is_link_info(info) (new) reads an lstat result as a link when S_ISLNK is set or st_reparse_tag is IO_REPARSE_TAG_MOUNT_POINT, a junction.
  • It reads the constant through getattr, because stat names it only on Windows.
  • It mirrors 3.12's ntpath.isjunction. is_junction and isjunction are 3.12+, and this standard runs on 3.9.
• symlink_on_the_way(root, rel) (new) lstats each component of the path under the root, the path itself included. It returns the first link as (its path inside the root, where it points). os.readlink reads a symlink or a junction.
• find_additions marks a path present when the walk finds a link or os.path.lexists finds anything. It used to ask Path.exists(), which follows a link. Addition carries the link (link).
• resolve_additions refuses a linked path as update-add-symlink (exit 2), ahead of update-add-would-overwrite and before any write.
  • The refusal (link_refusal) names the link, where it points, quoted with !r, and the path. It says --add never writes through a link.
  • Its remediation says to leave the path alone if the link is the operator's to keep, or to remove or move the link and run the same --add again.
• Rollback.write_added creates an addition with open(path, "xb") (O_CREAT|O_EXCL) and records it in the ledger only once it exists.
  • A name already taken at that point is refused: update-add-symlink when the walk finds a link, update-add-would-overwrite otherwise. That covers a link or a file that arrived after prepare looked, for example while an interactive apply waits in confirm, and a dangling directory link above the path, where mkdir fails.
  • apply's refusal arm then puts back the copies already written.
• check, and shape-doctor.py's currency row, which reads Addition.present through prepare, stop offering or counting a path the root holds a link at, as for any path it holds.

A directory link ABOVE the path is the same write-through (docs -> elsewhere, under docs/x.md), so the same walk covers it. A live one took the file into the directory it leads to. A dangling one was a FileExistsError traceback from write_added's mkdir.

Why

#239. apply --add <path> wrote the standard's file THROUGH an operator's dangling symlink and created what it pointed at, outside the root included. It was reproduced on main 39ac59c with the issue's own steps: a scaffolded project cut before AGENTS-shape.md, with a dangling link at that path.

• Validators red: exit 2, ROLLED BACK ... the tree is exactly as it was. The link is gone, and outside/agents.md (8218 bytes, the standard's bytes) is left.
• Validators green: exit 0. The link stays, and the standard's bytes are written outside the root.

At this head (ca68458) the same two runs, plus the doctor, behave as follows (repro.sh from the review, run on a clone at ca68458):

• both exit 2 with REFUSED update-add-symlink, the link's target quoted;
• the link is in place, outside/ is empty, and git status --porcelain is ?? AGENTS-shape.md, as before the run;
• check exits 0 with nothing to do;
• the doctor's shape-currency row is ok, with {'unchanged': 10}.

On native Windows, which README.md:116 supports ("Windows, natively"), the ordinary directory link is a junction. lstat reads a junction as a directory, because CPython sets S_IFLNK for IO_REPARSE_TAG_SYMLINK only, so the walk needs the reparse tag as well (the codex thread at update-shape.py:771).

One behaviour change to note: a LIVE link at the path was already refused on main, as update-add-would-overwrite ("a human merges"). It is now update-add-symlink, which names the link and its target. The refusal is the same, and nothing is written either way.

Fix round 1

This answers lane openRepoShape-2's review of 7bceeca (#269 (comment)) and the codex thread at update-shape.py:771, in ca68458:

1. Junctions. is_link_info is applied on the walk and at the path itself.
   • A live junction above an --add path no longer takes the file outside the root.
   • A dangling one is no longer a traceback.
   • A junction at the path is update-add-symlink, not update-add-would-overwrite.
   • The check uses st_reparse_tag, not the FILE_ATTRIBUTE_REPARSE_POINT bit, which lstat keeps for a OneDrive placeholder it has traversed.
2. update-shape.py apply --add <path> where <path> is the operator's own DANGLING symlink reads it as absent (find_additions asks .exists()) and writes THROUGH it, so when the project's validators go red the rollback unlinks the operator's symlink, leaves the file it wrote at the link's target outside the root, and prints that the tree is exactly as it was #239's second change. write_added's exclusive create, the record after the create, and the refusal, as above.
3. The wording. The refusal says --add never writes through a link. It no longer claims that for the whole command, which still rewrites a pinned copy kept as a link (see Left out).
4. The quoting. Where the link points is printed with !r, so a target holding a newline cannot print a line that reads as a second refusal.
5. Sonar python:S9073. The root fixture's composite assert is two asserts.
6. README.md:1070-1083. Left out; see below.
7. "Composes with". The table is refreshed.

Tests

tests/test_update_shape_add_symlink.py (new) holds 41 tests: 38 run on POSIX, and 3 run on Windows only. The ones that make a symlink carry @WINDOWS_SKIP. Every "nothing was written" assertion compares the whole tree before and after:

• each file's bytes and mode;
• each link, by readlink;
• each directory;
• HEAD, the branches, the index and status --ignored;
• the directories the links lead to.

The module's commit B also changes a pinned copy, so a refusal that wrote the copies first would show.

• check for a dangling link (inside the root, outside it, and into a directory that does not exist) and a live one: the path is not offered, and the other addition still reports (4).
• apply --add for the same four links, under green AND red validators (8):
  • refused as update-add-symlink, exit 2, with no traceback;
  • the link and its target untouched, and nothing re-pinned;
  • the refusal quotes the target (repr) and says --add never writes through a link.
• A link's target holding a newline prints no line of its own (1).
• Before any write. The refusal comes before --branch creates its branch (1). One link among several --adds refuses them all, and docs/ is never made for the good one (1).
• A directory link above the path, live and dangling. check does not offer it (2). apply --add refuses it, green and red, naming the link (4).
• The ledger's guard, in-process.
  • A dangling link at the path, and a dangling directory link above it, are refused as update-add-symlink, with created empty and the link and its end untouched (2).
  • A file that arrived after the check is refused as update-add-would-overwrite, and its bytes are kept (1).
  • The control: a directory and a file it made are recorded, in order (1).
  • cmd_apply with the link arriving in confirm: refused, the pinned copy already written is restored, and the tree is exactly as it was when the writes began (1).
• Junctions, on every platform. is_link_info over six lstat shapes: a junction, Windows and POSIX symlinks, Windows and POSIX directories, and a reparse point lstat traverses (6). The walk handed a junction's lstat, at the path and above it (1).
• Junctions, on Windows only. Real junctions, made with _winapi.CreateJunction or mklink /J: live above the path, dangling above it, and at the path (3). For each:
  • check does not offer the path;
  • apply --add exits 2 with REFUSED update-add-symlink and no traceback;
  • nothing is at the junction's end, there is no pin row, and git status --porcelain is unchanged.
• Controls.
  • Nothing at the path still adds, and the validators stay green.
  • An unrelated link elsewhere in the root does not stop an addition.
  • A root named through a symlink still takes one.
  • A directory or a FIFO at the path is still refused as update-add-would-overwrite (5).

Against main's code. The whole module was copied into a clone at main 67a398a: 31 failed, 7 passed, 3 skipped (Windows only).

• The 7 that pass: the controls, check for a live link (main is already silent about it), and the ledger's control.
• Dangling link at the path, check (3): main offers the path as upstream-added.
• Dangling link at the path, apply --add (6: green and red, with the link's end inside the root, outside it, and in a missing directory): main writes through the link, or leaves the pinned copy written after a traceback. In the red runs main also deletes the operator's link.
• The refusal before --branch (1), the several---adds test (1) and the newline test (1): main applies, writing through the link.
• Directory links (6): check offers the path under the link (2). apply --add writes through a live one or dies in a traceback on a dangling one, leaving the pinned copy written. The live one under red validators fails only on the refusal's id.
• The live-link apply --add tests (2): they fail only on the refusal's id and wording.
• The ledger (4): main writes through the link, overwrites the file that arrived, raises a raw FileExistsError, and finishes the run with the file outside the root.
• Junctions (7): is_link_info does not exist (6), and the walk misses a junction (1).

Against the fix round's reviewed head 7bceeca's code, the fix round's tests and the 8 refusal tests it changed gave 20 failed, 1 passed (the ledger's control) and 3 skipped, each failing for its finding's reason. Eight mutants of this round's code were all killed:

• the junction clause dropped;
• the attribute bit in place of st_reparse_tag;
• "wb";
• recording before the create;
• the raw error;
• mkdir outside the guard;
• the target unquoted;
• the old wording.

At this head (ca68458):

• tests/test_update_shape_add_symlink.py: 38 passed, 3 skipped (Windows only).
• tests/test_update_shape.py, tests/test_update_shape_add.py, tests/test_update_shape_add_ignored.py: 77 + 17 + 26 = 120 passed.
• tests/test_shape_doctor.py: 181 passed.
• tests/test_cli_reference.py: 13 passed. scripts/render-cli-reference.py --check is ok; no --help text changed.
• tests/test_repo_hygiene.py: 50 passed.
• Not run here: the whole suite, and Windows and macOS. Those are CI's. The three junction tests run only in tests-windows.

Composes with

git merge-tree --write-tree <this head ca68458> <head>, run in a scratch repository. Every one gave rc=0 with no conflicting file:

head	touches, of this PR's neighbourhood	rc
main 67a398a (39ac59c..67a398a)	update-shape.py, tests/test_update_shape.py, tests/test_update_shape_pr_base.py, shape-doctor.py, tests/test_shape_doctor.py, README.md	0
main d94d155 (ls-remote's tip in this round, one commit past 67a398a)	shape-doctor.py, tests/test_shape_doctor.py	0
#227 fix/update-shape-pr-create-failure 629373b	update-shape.py, tests/test_update_shape_add_ignored.py, tests/test_update_shape_landing.py, tests/test_update_shape_pr_base.py	0
#281 fix/validator-child-encoding 5757e29	update-shape.py	0
#267 fix/doctor-root-shape-pin-unreadable 092a5f9	shape-doctor.py, tests/test_shape_doctor.py	0
#245 fix/adopt-relative-submodule-url 8ce5614	shape-doctor.py, tests/test_shape_doctor.py	0
#264 67a1163, #266 aa2be9a, #268 06cb68e, #270 aed9190	none of these files	0
#184, #228, #231, #236, #240, #256, #284	none of these files	0

None of main's changes since 39ac59c, 629373b or 5757e29 touches Addition, find_additions, resolve_additions, symlink_on_the_way or Rollback.write_added. In each merged tree write_added keeps its one caller. #267 calls the same prepare and reads Addition.present, whose meaning is unchanged. fix/update-shape-pr-base-branch has landed as #218 and is in main.

Left out

• README. No README paragraph on the new refusal. README.md:1070-1083 also says check reports a path "the root has no file at", until "a file arrives at that path", and a dangling link (no file) is now silent there. Both edits wait for a handbook regeneration:

  • the README is capped at 1416 lines;
  • docs/handbook.html pins its blob, so tests/test_repo_hygiene.py fails any change to it.

  The refusal's text carries the remedy.

• A LIVE directory link, or junction, that ARRIVES above an --add path after prepare looked. O_EXCL guards the last component only, so the create follows such a link. Anything at the path itself is refused by the exclusive create, and a dangling link above it by mkdir's EEXIST.

• "xb" on a dangling Windows symlink is CreateFileW CREATE_NEW, and is not verified here. On Windows the walk in prepare is the guard. tests-windows runs the junction tests.

• The other .exists() / is_file() calls in update-shape.py, each looked at:

  • root_kind (family.yaml/project.yaml), open_upstream, read_pin, validators and prepare's root.is_dir() read decide no write.
  • classify's is_file() on a PINNED path reads a dangling link there as copy-missing, which apply already refuses.
  • ReadmeShapeLine asks is_symlink() first (update-shape.py apply now moves the README's trailing Shape: <repo> @ <sha>. line in the same commit as the pin it names, so a holder's README stops drifting from contracts/shape-pin.yaml (#148) #152).
  • write_added's parent loop keeps exists() on purpose: a dangling directory link above the path then reaches mkdir, whose failure is now a refusal.
  • Rollback.undo's exists() sees only the paths this run created.

• Two cases the review found identical on main and at the head, follow-ups rather than this PR's:

  • --add docs/x.md with docs a plain file, or a read-only directory, is a traceback with the pinned copy left rewritten.
  • A pinned copy, or the pin, kept as a symlink is rewritten through it with exit 0, and the --branch commit leaves it out. That is why the refusal promises only that --add never writes through a link.

• 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 and 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 (the adopt and scaffold materializers writing through a link the root keeps): a different tool.

Review

Lane openRepoShape-2's own adversarial review of 7bceeca (#269 (comment)) asked for changes. ca68458 is the fix round described above. A review by another lane is welcome: lane openRepoShape-3's fix/update-shape-pr-create-failure (#227) and lane openRepoShape-5's fix/validator-child-encoding (#281) sit in the same file.

Closes #239

🤖 Generated with Claude Code

Summary by Sourcery

Refuse additions that would write through operator-owned links or overwrite paths that become occupied, preserving the root and link targets.

Bug Fixes:

• Prevent apply --add from treating dangling symlinks or Windows junctions at or above an addition path as absent, writing through them, or deleting them during rollback.
• Protect additions from links or files that appear after preparation by refusing occupied paths and preserving the existing filesystem state.

Enhancements:

• Recognize symlinks and Windows junctions during addition discovery and provide explicit, safely quoted refusal messages with remediation guidance.
• Use exclusive creation and accurate ledger recording so rollback only removes files and directories created by the current run.
• Keep check and shape-doctor currency reporting consistent with paths already held by the root.

Tests:

• Add comprehensive POSIX and Windows coverage for symlinks, directory links, junctions, late-arriving paths, rollback behavior, refusal ordering, and unchanged-tree guarantees.

[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 1 hour by commenting @sourcery-ai review. Upgrade to get a review now.

[brettheap]

(lane openRepoShape-2, 2026-10-11T22:54:36Z) @codex review

[sourcery-ai]

Reviewer's Guide

The PR makes update-shape.py symlink-aware by walking addition paths with lstat, treating links as present, and refusing affected --add operations before any writes; extensive tests verify safe behavior for dangling/live links, directory links, rollback scenarios, and existing controls.

Sequence diagram for symlink-safe update add

sequenceDiagram
    participant User
    participant UpdateShape
    participant Root
    participant Filesystem

    User->>UpdateShape: apply --add path
    UpdateShape->>Root: find_additions(root, rows, upstream, target, kind)
    UpdateShape->>Filesystem: symlink_on_the_way(root, path)
    Filesystem-->>UpdateShape: link path and target, or None
    UpdateShape->>Filesystem: os.path.lexists(root / path)
    Filesystem-->>UpdateShape: present
    UpdateShape->>UpdateShape: resolve_additions(rows, additions, ...)
    alt symlink found
        UpdateShape-->>User: Refusal update-add-symlink
    else no symlink and path absent
        UpdateShape-->>User: Addition proceeds to writing
    end

Loading

Flow diagram for symlink-aware addition resolution

flowchart TD
    A[find_additions] --> B[symlink_on_the_way]
    B --> C{Symlink at path or above?}
    C -->|Yes| D[Addition.link set; present]
    C -->|No| E[os.path.lexists checks presence]
    D --> F[resolve_additions]
    E --> F
    F --> G{link is not None?}
    G -->|Yes| H[Refuse as update-add-symlink before writes]
    G -->|No| I{Path already present?}
    I -->|Yes| J[Refuse as update-add-would-overwrite]
    I -->|No| K[Write addition]

Loading

File-Level Changes

Change	Details	Files
Detect symlinks anywhere along an addition path without following them.	Added component-by-component symlink detection using lstat semantics. Treat paths containing symlinks, including dangling links, as present. Stored the first link and its target on each addition for later diagnostics.	update-shape.py
Refuse symlink-backed additions before any repository or filesystem writes.	Added the update-add-symlink refusal ahead of overwrite handling. Reported the link location, target, affected path, and remediation. Preserved existing overwrite behavior for regular files, directories, and FIFOs.	update-shape.py
Prevent checks and downstream currency reporting from offering additions already covered by links.	Suppressed additions at symlink paths and beneath directory symlinks. Kept unrelated additions and roots reached through a symlink working normally.	update-shape.py
Added comprehensive regression coverage for symlink safety and transactional refusal.	Covered live and dangling links at the path and above it under green and red validators. Verified no files, links, pins, branches, index, status, or external targets change on refusal. Added controls for normal additions, unrelated links, symlinked roots, and non-link collisions.	tests/test_update_shape_add_symlink.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#239	Ensure update-shape.py apply --add <path> treats a symlink at the target path, or on a parent directory, as present and refuses the addition before any files, pins, branches, or external targets are written.	✅
#239	Make rollback and added-file creation safe by creating files exclusively and recording them in the rollback ledger only after successful creation, so rollback cannot remove an operator-owned symlink or leave a file created through it, including if a link appears during the run.	❌	The PR explicitly leaves the requested os.open(..., O_EXCL) and post-success ledger recording changes out. The new early symlink refusal prevents the reported normal path from reaching write_added, but it does not implement the independent rollback/creation guard for links that appear or are encountered after the refusal check.
#239	Add regression coverage demonstrating that dangling and live symlinks, including directory symlinks above an added path, are refused without side effects while ordinary additions and unrelated filesystem entries retain their existing behavior.	✅

Possibly linked issues

• update-shape.py apply --add <path> where <path> is the operator's own DANGLING symlink reads it as absent (find_additions asks .exists()) and writes THROUGH it, so when the project's validators go red the rollback unlinks the operator's symlink, leaves the file it wrote at the link's target outside the root, and prints that the tree is exactly as it was #239: PR directly fixes the reported symlink write-through and rollback corruption by refusing linked addition paths before writes.

---

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.

[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-11T23:01:45.656154Z	7bceeca	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

Here are some automated review suggestions for this pull request.

Reviewed commit: 7bceecad8d

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

[chatgpt-codex-connector]

Reject Windows junctions before writing additions

On native Windows, an unpinned upstream file beneath an NTFS junction (for example, docs junctioned to an external directory) bypasses this check because Path.is_symlink() does not classify junctions as symbolic links; Python exposes junction detection separately. When the destination file is absent, lexists() also returns false, so apply --add docs/... proceeds and writes outside the project root. Detect junction/reparse-point ancestors as well, while retaining compatibility with the supported Python 3.9 baseline.

Useful? React with 👍 / 👎.

[brettheap]

(lane openRepoShape-2, 2026-10-11T23:54:06Z)

This lane reviewed its own PR #269 at 7bceeca, before any fix round, read-only in its own detached worktrees.

CHANGES NEEDED.

On POSIX the fix holds. On main, the issue's steps delete the link and write outside/agents.md. At this head, apply refuses update-add-symlink before any write.

Findings:

• P2, fix here (codex P1). update-shape.py:770 uses is_symlink(), which is False for an NTFS junction.
  • A live junction above an --add path still gets the file written outside the root. A dangling one is a traceback.
  • A 3.9-safe check is lstat().st_reparse_tag against IO_REPARSE_TAG_MOUNT_POINT. Read the constant through getattr, because stat lacks it on Linux.
  • A Windows-only mklink /J test can pin it in tests-windows.
• P3, fix here or file it. update-shape.py apply --add <path> where <path> is the operator's own DANGLING symlink reads it as absent (find_additions asks .exists()) and writes THROUGH it, so when the project's validators go red the rollback unlinks the operator's symlink, leaves the file it wrote at the link's target outside the root, and prints that the tree is exactly as it was #239's second change (O_EXCL, record after the create, :1820-1821) is left out under Closes #239.
• Nits:
  • :855 says "this command never writes through a link", but it does for pinned copies and the pin.
  • :852 prints the link target unescaped.
  • Sonar S9073 flags test :116.
  • README:1073 and :1083 are inexact for a dangling link.
  • The "Composes with" table is stale.

Follow-ups, with no matching open issue. Both happen identically on main and head, and both are drafted in the review directory:

• --add docs/x.md with docs a plain file gives a NotADirectoryError traceback, and the pinned copy is left rewritten.
• A pinned copy kept as a symlink is rewritten at the link's end, exit 0. The --branch commit omits it but reports it as committed.

Tests:

• The PR's module on main: 19 failed and 6 passed, for the issue's reasons. At head: 25 passed.
• Mutants: three of four killed. The survivor, lexists to exists, is redundant code.
• At head: the update-shape modules plus cli_reference and hygiene, 208 passed; shape_doctor, 181 passed.
• Merged with c3f4987: 235 and 191 passed.
• Merged with 60588d5: 42 passed.

Merges: merge-tree against main c3f4987 and 60588d5, #281 5757e29, c874e4f and this lane's five other heads gives rc=0 with no conflicts.

The full report is at handoffs/xFactory/attachments/lane-openRepoShape-2/review269-7bceeca/final-report.md in opensoft/brett-wip.

[brettheap]

(lane openRepoShape-2, 2026-10-12T00:53:55Z)

This lane re-verified its own PR #269 at ca68458 after fix round 1, read-only in its own detached worktrees.

MERGEABLE WITH NITS.

Items:

1. Junctions: fixed. is_link_info checks S_ISLNK or st_reparse_tag through getattr, and it is 3.9-safe.
   • The cross-platform tests pass here.
   • The three real-junction tests ran only in tests-windows, which passed (2826 passed, Python 3.14.7).
2. O_EXCL: fixed. The path is recorded after the create.
   • A link, file or dangling directory link arriving during confirm is refused and rolled back (copy, earlier addition, docs/), green and red.
   • The body names the residual: a live directory link arriving above the path.
3. Wording: fixed.
4. !r: fixed.
5. Split assert: fixed. Sonar shows 0 open issues.
6. README: declined, and named in the body.
7. Body table: stale again, since main is now be2790e. Nit.

Tests:

• At ca68458: update set 221 passed, 3 skipped; shape_doctor 181 passed.
• The PR's module: 31 failed, 7 passed on main; 20 failed on 7bceeca's code, matching the body.
• Merged with b30595c: 248 and 208 passed. Merged with be2790e: 281 and 208 passed.
• Mutants: 14 of 15 killed. The survivor, lexists to exists, is redundant.
• CI: all three OS jobs and SonarCloud pass.

Merges: merge-tree against main b30595c and be2790e, #281 5757e29 and 754803d, and every open head is rc=0. The one exception is 04792d2, which conflicts with main alone.

The full report is at handoffs/xFactory/attachments/lane-openRepoShape-2/review269-7bceeca/reverify-1.md in opensoft/brett-wip.

[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