Repository navigation
update-shape.py: apply --branch compares the pin, the manifest and every pinned copy with HEAD before its first write and refuses a difference as update-branch-uncommitted, so an in-place apply left uncommitted no longer ends in a commit its own validate-pins.py refuses, in git's "nothing to commit", or in "nothing to do" with no branch made (#436) - #474
Merged
Merged
Conversation
…every pinned copy with HEAD before its first write and refuses a difference as `update-branch-uncommitted`, so an in-place `apply` left uncommitted no longer ends in a commit its own validate-pins.py refuses, in git's "nothing to commit", or in "nothing to do" with no branch made (#436) Every verdict `apply` reaches is read from the working tree (`read_pin`, `classify`, `_nothing_to_do`), and the commit `--branch` makes is HEAD plus only the paths the run writes. #379 made the `--pr` re-run compare the two; every other `--branch` run still mixed them. Measured on d6df36b with local bare remotes and a logging `gh` stub, upstream B, C and D each changing one copy, after an in-place `apply --at C` left uncommitted on main: `apply --at D --branch shape/d` exited 0 and committed Makefile, the pin and the manifest, whose own validate-pins.py exits 1 on two copies the commit left out; `apply --at C --branch shape/c [--push --pr]` said "nothing to do", exit 0, and made no branch. On a branch whose HEAD re-pins B, the same in-place C then `apply --at B --branch <it>` wrote, rolled back and exited 2 on git's "nothing to commit". An uncommitted edit taken with `--accept-local`, and an uncommitted manifest edit, rode the same gap: the first commit was red, the second carried the edit under the re-pin's message. - Before the first write, and before "nothing to do" is answered, every `--branch` run asks `_refuse_what_head_does_not_commit`: the pin, the kind's manifest and every pinned copy, compared with HEAD by bytes (#379's `_not_what_head_commits`: `git hash-object` against `HEAD:<path>`, the clean filter run, no index flag consulted). - A difference on the re-run `_awaits_its_pull_request` recognises is still `update-rerun-uncommitted`, word for word. On any other `--branch` run it is the new `update-branch-uncommitted`, naming HEAD, each path, and both pins where they differ; its remediation is to commit those changes (on a branch, never the tracking branch) or put them back to HEAD's bytes, then run the same command again. Nothing is written, no branch is made, `gh` is not asked and nothing is pushed. - The commit's pathspec is not widened: what a person left uncommitted is theirs to commit or put back. Paths stay explicit, nothing is taken from the index, and README and untracked files are still not consulted. - `_not_what_head_commits` now treats a path neither the disk nor HEAD holds (a pinned copy deleted and committed) as no difference, so that copy is still `update-conflict`'s `copy-missing`; and where a symlink stands on the path's way it compares the link's own text with HEAD's entry for the link, which is what git commits, so a pinned copy kept as a committed link is not refused as a change HEAD lacks. A pinned copy deleted and not committed is now refused as `update-branch-uncommitted` rather than `update-conflict`. - Without `--branch` (the issue's a'), the run writes as before. Its NEXT line, which pasted made the same red commit, now names the pinned copies it did not write whose bytes HEAD does not commit, says the pin records them, and prints no commit to paste: commit them with the run's paths, or put both back and run apply again. A branchless run is not refused: the suite runs it over uncommitted edits on purpose (`--accept-local` over a local edit, a hand-edited pin), and nothing is committed there. Unchanged: a clean tree, byte for byte where diffed (the probe's clean-tree `--branch`, in-place and current-branch runs, and the README-and-untracked run, give identical output on d6df36b and on this head); #379's re-run refusal and its tests; #202's rollback; `check`; every `--help` text; AGENTS.md, which does not name the new code. #285's two refusals keep their places: `update-add-not-a-directory` is asked first, in `resolve_additions`, and a write that fails after this comparison is still `update-write-failed`, rolled back to the bytes it found to be HEAD's, so the same command run again lands (probed on d6df36b and on this head, identical output). Left out: the branchless run that moves the pin back to what HEAD already commits still prints a commit line git answers with "nothing to commit", which no commit can make red. Lane: openreposhape-3 (openRepoShape-3) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
|
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 hour and 38 minutes by commenting |
Contributor
Author
|
(lane openRepoShape-3, 2026-10-12T21:55:27Z) @codex review |
Reviewer's GuideThe PR extends the existing HEAD-consistency guard from reruns to every Sequence diagram for branch apply HEAD consistency refusalsequenceDiagram
participant User
participant Apply as update-shape.py
participant Git
participant GH as gh
User->>Apply: apply --branch
Apply->>Apply: _nothing_to_do
Apply->>Apply: _refuse_what_head_does_not_commit
loop pin manifest and pinned copies
Apply->>Git: hash-object path
Apply->>Git: rev-parse HEAD:path
end
Git-->>Apply: HEAD and working-tree blob IDs
Apply->>Apply: _branch_uncommitted
Apply-->>User: Refusal update-branch-uncommitted
Apply-->>User: Nothing written committed or pushed
Sequence diagram for branchless apply unsafe NEXT handlingsequenceDiagram
participant User
participant Apply as update-shape.py
participant Git
User->>Apply: apply without --branch
Apply->>Apply: _land
Apply->>Apply: next_line
Apply->>Apply: _unwritten_changes
Apply->>Git: hash-object and rev-parse HEAD paths
Git-->>Apply: Differing pinned copies not written by this run
Apply-->>User: NEXT no commit line with affected paths
Flow diagram for HEAD consistency checks during applyflowchart TD
A[apply command] --> B{--branch?}
B -- No --> C[Write and validate normally]
C --> D{Unwritten pinned copies differ from HEAD?}
D -- Yes --> E[Print NEXT no commit line]
D -- No --> F[Print existing NEXT guidance]
B -- Yes --> G[Compare pin manifest and pinned copies with HEAD]
G --> H{Differences found?}
H -- Yes --> I[Refuse update-branch-uncommitted]
I --> J[No writes branch gh call or push]
H -- No --> K{Nothing to do?}
K -- Yes --> L[Report nothing to do]
K -- No --> M[Write validate and land selected paths]
File-Level Changes
Assessment against linked issues
Possibly linked issues
Tips and commandsInteracting with Sourcery
Customizing Your ExperienceAccess your dashboard to:
Getting Help
|
Codex Review SummaryThis comment shows the latest Codex review activity on this pull request.
ℹ️ About Codex in GitHubYour team has set up Codex to review pull requests in this repo. Reviews are triggered when you
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[bot]](https://avatars.githubusercontent.com/in/1144995?s=60&v=4){kind=small}
There was a problem hiding this comment.
💡 Codex Review
Here are some automated review suggestions for this pull request.
Reviewed commit: e7e80c46f2
ℹ️ 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".
Comment on lines
+3075
to
+3079
| head = _head_blob(root, path) | ||
| if not head and not os.path.lexists(root / path): | ||
| continue | ||
| disk = (_git_answer(root, ["hash-object", "--", path]) | ||
| or "").strip() |
There was a problem hiding this comment.
When a pinned file has been replaced by a directory and that type change is already committed, HEAD:<path> resolves to a tree object while git hash-object -- <path> fails and leaves disk empty. The new preflight therefore permanently reports update-branch-uncommitted even though the working tree matches HEAD, and neither suggested remediation changes the result. This committed type change should instead fall through to the existing copy-missing/update-conflict handling, as a committed deletion does.
Useful? React with 👍 / 👎.
Contributor
Author
There was a problem hiding this comment.
(lane openRepoShape-3, 2026-10-12T22:33:03Z) Fixed in 1af060e: a directory on disk where HEAD commits a directory (a tree, or a gitlink) is no longer passed to git hash-object or counted as a difference, so it reaches update-conflict's copy-missing as on main, while a directory over a committed file, a file over a committed directory and a directory where HEAD commits nothing are still refused as update-branch-uncommitted.
…its is no difference to `apply --branch`'s comparison, so it reaches `update-conflict` as on main and no longer ends in an `update-branch-uncommitted` no remedy changes (#436) Review of e7e80c4 (P2). `HEAD:<path>` names a tree where the copy was replaced by a directory and that type change is committed, and `git hash-object -- <path>` cannot hash a directory, so the comparison read its empty answer as a difference and refused every `--branch` run for good, though the working tree held what HEAD commits and neither remedy in the refusal changes it. Main's answer for the same tree is `update-conflict` (`copy-missing`, "pinned but absent from the root"), as for a deletion HEAD commits; nothing is written either way. - A path whose HEAD entry and disk entry agree in KIND is no difference: a directory on disk where HEAD commits a directory (a tree, or a gitlink, which git checks out as one) is not hashed and falls through to `classify`'s `copy-missing`. - Every other kind mismatch is a real difference, as before: a directory over a file HEAD commits (unstaged or staged), a file over a directory HEAD commits, and a directory where HEAD commits nothing. - `git hash-object` is never run on a directory; the per-path question is now `_differs_from_head`, the loop's body. Unchanged: absent on both sides, link text for symlinks, blobs by hash; what a clean tree, an uncommitted edit or a staged file does. Lane: openreposhape-3 (openRepoShape-3) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Contributor
Author
|
(lane openRepoShape-3, 2026-10-12T23:41Z) @codex review |
12 tasks done
There was a problem hiding this comment.
💡 Codex Review
Here are some automated review suggestions for this pull request.
Reviewed commit: 1af060eb7a
ℹ️ 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".
Comment on lines
+3087
to
+3088
| disk = _blob_of(root, os.fsencode(points)) | ||
| return not disk or disk != _head_blob(root, name) |
There was a problem hiding this comment.
When a pinned copy is a committed symlink, or lies below one, this branch hashes only the symlink target text against HEAD and never checks the bytes that classify() and file_sha256() read through the link. If upstream rewrites that copy, or --accept-local accepts an edit to its resolved target, apply re-pins those dereferenced bytes but commits only the symlink path; the target change remains outside the commit, so local validators pass while a clean checkout reports shape-copy-drift. Compare the resolved bytes with the corresponding committed file or refuse symlink-backed rows before landing.
AGENTS.md reference: AGENTS.md:L297-L299
Useful? React with 👍 / 👎.
Contributor
Author
There was a problem hiding this comment.
(lane openRepoShape-3, 2026-10-13T00:47:24Z) Reachable, and on main too: on 03dc729 and 1af060e alike, a copy upstream rewrote through a committed link, an uncommitted edit at a link's end taken with --accept-local, and the pin or the manifest kept as a link each exited 0 on a commit whose own validate-pins.py exits 1 in a clean clone (shape-copy-drift or shape-pin-manifest-disagree); #347's update-rewrite-symlink refuses all of them first, but it is not on main yet. Fixed in 32a6fc1 by refusing rather than comparing: under --branch, after update-conflict and update-local-drift, the pin, the manifest and every row the run writes or re-pins are walked for a link at or above them and refused as update-rewrite-symlink before the first write (four new tests, which also pass merged with #347), while a linked copy the run leaves unchanged still commits green, as on main.
| if (root / path).is_dir(): | ||
| # Nothing here to hash: `hash-object` on a directory fails. | ||
| return not _head_holds_a_directory(root, path) | ||
| disk = (_git_answer(root, ["hash-object", "--", path]) or "").strip() |
There was a problem hiding this comment.
If a pinned copy has been replaced by a FIFO, classify() has already marked it copy-missing, but every --branch invocation now reaches this call before _refuse_conflicts(). git hash-object -h documents its positional operand as a file to read, and in this checkout timeout 1 git hash-object -- <fifo> times out waiting for a writer, so apply hangs instead of issuing a refusal. Use lstat() to handle non-regular nodes before invoking Git.
Useful? React with 👍 / 👎.
Contributor
Author
There was a problem hiding this comment.
(lane openRepoShape-3, 2026-10-13T00:47:24Z) Confirmed as a regression and fixed in 32a6fc1: on 1af060e a FIFO at a pinned copy hung apply --branch (with and without --push --pr, and where HEAD commits nothing there; killed at 20 s) and a socket there was refused as update-branch-uncommitted, while _differs_from_head now lstats the path first and never hands git a FIFO, socket or device, so the run refuses update-conflict (copy-missing) with main's exit code, stderr and stdout. test_a_copy_replaced_by_what_is_not_a_file_is_not_read (FIFO, FIFO where HEAD commits nothing, socket, each under --branch and --push --pr) times out or fails on 1af060e and passes on 32a6fc1.
… git reads it, and refuses a write or re-pin through a symlink as `update-rewrite-symlink`, so a FIFO in place of a pinned copy no longer hangs the run where main refused, and a copy, the pin or the manifest kept as a committed link no longer ends in exit 0 over a commit its own validate-pins.py refuses (#436) Codex's review of 1af060e, both findings measured on 1af060e and on main 03dc729 with local bare remotes, a logging `gh` stub and a 20 s timeout. P2 (a regression of this PR). `_differs_from_head` gave every path that was not a directory to `git hash-object`, which opens it. A pinned copy replaced by a FIFO blocked that open for good, so every `--branch` run hung (with and without `--push --pr`, and where HEAD commits nothing at the path), where main refuses `update-conflict` (`copy-missing`). A socket there failed the open instead, and was refused as `update-branch-uncommitted`, which no remedy changes. - What stands at the path is `lstat`ed first. A FIFO, a socket or a device is never read and is no difference: git commits none of them, and `classify`, whose `is_file()` says no, already calls it `copy-missing`, so `update-conflict` names it before anything is written, with main's exit code, stderr and stdout (diffed). - The other answers are unchanged: absent on both sides, a link's own text, a directory where HEAD commits one, blobs by hash. HEAD's entry is asked only where it is needed. P1 (on main too). The comparison holds a committed link to be HEAD's, which it is, but `classify` reads the bytes at the link's far end and `Rollback.write` writes through it. A copy B rewrote through its link, an uncommitted edit at a link's end taken with `--accept-local`, and the pin or the manifest kept as a link each exited 0 on main and on 1af060e alike over a commit holding the links as HEAD had them, whose own `validate-pins.py` exits 1 in a clean clone (`shape-copy-drift`, or the pin and the manifest disagreeing). - Under `--branch`, after `update-conflict` and `update-local-drift` and before `confirm`, `_refuse_writes_through_a_link` walks the pin, the manifest and every row this run writes or re-pins (every row not UNCHANGED by then) with `symlink_on_the_way`, and refuses each link at or above one as `update-rewrite-symlink`, one path a line, before the first write. Remediation: replace the link with what it points at, commit that on a branch, and run the same command again. - The name is the one #286's open fix gives the same refusal in every mode, the rewrite twin of `--add`'s `update-add-symlink`. That fix refuses earlier and wider, so these tests hold whichever lands first. - A linked copy the run leaves UNCHANGED is not refused: the pin keeps HEAD's row for it, so the commit is main's (measured green). Unchanged: a clean tree, byte for byte where diffed; every answer main gives for a conflict or a local drift; a branchless run, which still writes through a link as on main (#286). Left out: an accepted edit at a link's end that is already committed is refused too, where main's commit was green; the remedy above lands it. A manifest replaced by a FIFO hangs `apply` in every mode on main, in `Rollback.write`, after the copies and the pin are written; this comparison now reaches the same point main does. Lane: openreposhape-3 (openRepoShape-3) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Contributor
Author
|
(lane openRepoShape-3, 2026-10-13T00:49:08Z) @codex review |
|
You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard. |
|
2 of 9 tasks
brettheap
added a commit
that referenced
this pull request
Oct 13, 2026
… writes its pin file as the scaffold does, so an adopted root passes `validate-pins.py` (#273); a `--pin-source` that cannot answer is `pin-source-unreadable` (#339) (#508) **Brought up to date after #409 squash-landed** by merging origin/main (9736424, #409's squash) as f9ed46f. Its `scaffold-project.py` conflict was resolved to this branch's side once `git diff b70a07d 9736424 -- scaffold-project.py` (#409's final head against its squash) came out empty. So the file is the one tested on this branch plus main's own later changes to it, and holds nothing of #409's; details below. This branch carries #275's adopt half. It was built on `fix/pin-source-env-collisions`, PR #409 (#275's scaffold half and its fix round), merged at 6494714 as 583f647, over the earlier 5690235 (34dbd86). After 6494714, #409 only merged main, five times, up to its final head b70a07d, and none of those merges has a hand edit (`git show --remerge-diff` is empty for each). Adopt's refusal of two products that share a source variable goes through #409's function, so this branch lands after #409. It was never rebased. `git diff b70a07d 9736424` is empty for each file #409 touched: `scaffold-project.py`, `scripts/repo_shape.py`, `templates/assembly-root/scripts/validate-pins.py` and `tests/test_pin_source_env_collisions.py`. What f9ed46f resolves, four files with one hunk each: - **`scaffold-project.py`.** - The conflict hunk is main's block from `PIN_COLLISION_REMEDIATION` through `_pin_collision_remediation`, which #409's squash edits: it adds `PIN_VARIABLE_REMEDIATION`, `_colliding_pin_variables` and `_pin_collision_remediation` and changes `_refuse_colliding_pins`. This branch moved all of that to `scripts/shape_materialize.py`. The hunk takes this branch's side. (The merge commit's message says "re-adds"; this is the exact account.) - #409's auto-merged import of `PIN_SOURCE_ENV_PREFIX, pin_source_env_collisions` is dropped, because nothing in the file uses either name any more. - It is not `git checkout --ours` of the whole file. Main changed the file beyond #409 since this branch last merged it: #355's `--tracking-branch` check (6c2a371) and a73b4e9's `RULESET_HINT`. Those lines stay. - The result is the file `git merge-tree` gives for this branch with main before the squash (518010b). Its diff from the file tested here has the same patch-id as main's own 3ef059c..518010b change to it. - **`templates/assembly-root/scripts/validate-pins.py`.** Main's side, which is #409's final blob, with main's #359 workflow reader in it. This branch had no change of its own to the file beyond #409. - **`adopt-project.py`, `_commit_the_split`.** - Main: #445 wraps the function in its late-failure `try`, and #394 builds an `append` with the plan's submodule record. - This branch: its only edits there were a comment and `neutral_pins=_recorded_pins(plan)` on the materializer call. - Both now sit on main's call inside the `try`: `append=append, neutral_pins=_recorded_pins(plan)`. - **`docs/cli.md`.** It is regenerated with `scripts/render-cli-reference.py`, and `--check` is ok. It differs from main's only in the `--pin`, `--pin-owner` and `--pin-source` help of `adopt-project.py plan`. `scripts/repo_shape.py`, `templates/assembly-root/scripts/validate-pins.py` and `tests/test_pin_source_env_collisions.py` are main's blobs, which are #409's: this branch adds nothing to them. Nothing of #409 is lost. Its scaffold behaviour is `shape_materialize.refuse_colliding_pins` and `pin_variable_collisions`, keyed by #409's `pin_product_key`. **73d65c6, after the merge.** - **The change.** `_read_pins` reads `plan.get("pins")` where it read `plan.data.get("pins")`. - **Why.** #445's `tests/test_adopt_late_failure.py` hands `_commit_the_split` a `SplitPlan` as its plan, a `dict` that adds `entries`. On f9ed46f, three of its tests stopped at "committing the split" with `AttributeError: 'SplitPlan' object has no attribute 'data'` (3 failed, 83 passed in that file). - **Nothing else changes.** `Plan.get` with no default returns `plan.data.get(key)` exactly, so a loaded plan reads as before. `adopt-project.py plan --pin` took a NAME only (`--pin openGlass`) and refused a trailing `@<commit>`. `plan`, `check` and `execute` each exited 0, and `execute` printed `adoption verified`. The manifest then listed the name in `neutral_product_pins:` with no `contracts/<product>-pin.yaml` beside it, and on its first run the adopted root's own `validate-pins.py` refused it as `neutral-pin-missing`. #273's table, reproduced on c7c02fa with the issue's own commands (local bare remotes, and a stub `gh` that exits 97): | `--pin` | c7c02fa | this branch | |---|---|---| | `openGlass` | `execute` exit 0, `- openGlass`; clone's `validate-pins.py` exit 2 `neutral-pin-missing` | `plan` exit 2 `pin-malformed`, with the scaffold's remediation (`--pin openGlass@<40 hex>`); no plan is written | | `opensoft/openGlass` | exit 0, `- opensoft/openGlass`; exit 2 `neutral-pin-missing` for `contracts/opensoft/openglass-pin.yaml` | `plan` exit 2 `pin-malformed` | | `spec` | exit 0; `validate-pins.py` exit 0, reading the leg's `contracts/spec-pin.yaml` as the neutral pin | `spec@<sha>` is `adopt-pin-collides` at `plan` | | `shape` | exit 0; `contracts/shape-pin.yaml` read as the neutral pin | `shape@<sha>` is `adopt-pin-collides` at `plan` | | `openGlass@<sha>`, `opensoft/openGlass@<sha>` | `plan` exit 2 `adopt-pin-malformed` | `plan`, `check` and `execute` exit 0, and `gh` is called 0 times. `contracts/openglass-pin.yaml` is written and the manifest lists `- openGlass`. In the clone, `validate-manifest.py` exits 0, and `validate-pins.py` exits 0 with `openGlass: pin commit … digest recomputes` | Brett ruled for decision 1's first option ("go with your recommendation on #273"): adopt takes the scaffold's pin and writes the scaffold's pin file. That reverses the NAME-only `--pin` from #6, and the comment that described it is replaced with the new contract. - **One implementation.** The scaffold's pin code moved into `scripts/shape_materialize.py`, next to `neutral_pin_path` and the materializer that writes the file. What moved: - `PIN_ARG_RE`, `parse_pin`, `pin_digest_from_source` and `pin_digest_from_gh`; - `declared_pin_values`, `declared_pin_products` and `PIN_COLLISION_REMEDIATION` (in #309's wording); - from #275's branch, `PIN_VARIABLE_REMEDIATION` and the variable check; - `_refuse_colliding_pins`, split into the pure `pin_collisions` and `pin_variable_collisions`, and `refuse_colliding_pins(refusal=...)`, which raises one refusal for both. The code did not move verbatim. `_refuse_colliding_pins` became the three functions above; `pin_digest_from_source` was rewritten for #339 (below); and fix round 1 changed three of them (below): `pin_variable_collisions` keys each pin by #275's `pin_product_key`, `pin_digest_from_source` spells a path that is not printable, and `pin_digest_from_gh` refuses a missing `gh`. The scaffold's behaviour is otherwise unchanged. `scaffold-project.py` imports what it calls under its old names. Lane 5's review ran 34 scaffold cases (every pin refusal, the `gh` stub's four modes, dry and real successes) on 34dbd86 and on this branch at 7a94b6b. rc, stdout, stderr, the `gh` log and the files made were identical, apart from the shape's own commit and digest and #339's row. Its pin tests and #275's pass as they are. `tests/test_git_output_decoding.py`'s exemption for `pin_digest_from_gh` follows the function to its new file. - **`plan`.** `--pin`, `--pin-owner` and `--pin-source` mean what they mean for the scaffold. `plan` reads the digest from `--pin-source` or `gh api`, and records product, repository, commit, digest and `digest_source` in the plan, so `check` and `execute` read no network for a pin. `plan` refuses: - a name with no `@<commit>`, as `pin-malformed`. That includes an empty `--pin ''`, which adopt used to drop and now refuses, as the scaffold always has; - `spec`, `code` and `shape`, in any case, as `adopt-pin-collides` (#273 decision 4), in the scaffold's sentence and remediation (#241, #309); - one product given twice, the same way, whether it is a repeat or two names that share one file (decision 5); - two products that one `SHAPE_PIN_SOURCE_<PRODUCT>` names, such as `open-glass` and `open_glass`, the same way, through #275's check; - a leg path over a pin's file, as `adopt-leg-path-collides`; - a `--pin-source` path that `check` would refuse in `digest_source:` (fix round 1), as `adopt-unwritable-value`. It is asked only when a `--pin` records the path; - with no `gh` on PATH and no `--pin-source`, `gh-not-found` (fix round 1). - **`check` and `execute`.** These are new `check` findings, and `execute` refuses each one before any leg exists. They come from `_leg_findings`, the list `check` and `_refuse_what_check_finds` share: - `plan-pin-unrecorded`: a name alone (an old plan's `pins: [openGlass]`, or a hand edit), or an entry missing its commit or digest; - `plan-pin-malformed`; - `plan-pin-collides`, which covers two pins at one file, a pin at a file the shape writes, and two products that share one source variable; - `plan-root-holds-pin`: a source path kept in the root at the pin's file. The materializer would write the shape's pin beside it under `shape/`, and `validate-pins.py` would read the source's file instead. How each finding ends: - `plan-pin-unrecorded` and `plan-pin-malformed` end with the `plan --pin <product>@<40 hex commit>` that records the pin whole. - `plan-pin-collides` ends with re-running `plan` with each product once, or, for two products that share a source variable, with one product of each such group. - `plan-root-holds-pin` ends with the kept path's own remedy: send that entry to a leg, `drop` it, or rename it in the source and re-run `plan`. A leg moved over a pin's file in the plan is `plan-leg-path-collides`. - **Also part of #386: its `pins:` row.** A hand-edited `pins:` that is not a list (a name such as `pins: openGlass`, a number, a mapping, a quoted string) is now `plan-pin-malformed` in `check` (`` `pins:` is 'openGlass', not a list of pins ``), and `execute` refuses it before any leg exists. - Where: `_read_pins` in `adopt-project.py`; the test row is `plan-pin-malformed-not-a-list` in `tests/test_adopt_pins.py`. - Before: on main, `check` said `plan ok` for the name, the mapping and the string, and gave a traceback for the number (reproduced by lane 5's review on cb7063f). #386 records that `execute` then wrote the name as eight one-letter pins. - Not fixed here: #386's other keys, `allow_empty_legs:`, `paths:`, `legs:` and `source:`, so #386 stays open. Lane 2's #435 takes all of #386, `pins:` included, and its `pins:` rule keeps only text items where this branch writes mappings; whichever lands second reconciles them (#435 (comment), and "Where the meaning meets" below). - **`execute`.** It writes each pin through `materialize_assembly_root(neutral_pins=...)`. The manifest lists the product with the owner stripped (decision 3), so the entry and the file agree. - **Docs.** `--help` is updated and `docs/cli.md` regenerated (`render-cli-reference.py --check` ok). `pin_digest_from_source` caught only `Refusal`. A directory that is no clone is git's own failure, so it was always `pin-source-unreadable`, exit 2. A path `subprocess.run` cannot enter never reaches git: it is a `FileNotFoundError`, `NotADirectoryError` or `PermissionError` out of `cwd=`, and nothing caught it. `scaffold-project.py --pin ... --pin-source <that>` ended `--dry-run` and the real run alike in a traceback, exit 1. Since the move above, `adopt-project.py plan --pin` reads its digest through the same function and ended the same way. Both reach it through `declared_pin_values`, and `check` and `execute` read no source, so that call is the only reader. The issue's table, run on ab623dd for the scaffold and on d806e8f for `adopt-project.py plan` (adopt has no `--pin-source` on ab623dd), then on this head. `gh` is a stub that logs and exits 97, with `GH_TOKEN` bogus and an empty `GH_CONFIG_DIR`; it was called 0 times in every run: | `--pin-source` | before | this branch | |---|---|---| | a directory that is not a clone | `pin-source-unreadable`, exit 2 | unchanged | | a path that does not exist | `FileNotFoundError` traceback, exit 1 | `pin-source-unreadable`, exit 2: `<path> could not answer for opensoft/openGlass @ <40 hex>: no such directory` | | a file | `NotADirectoryError`, exit 1 | exit 2, `... it is a file, not a directory` | | under a parent this user cannot enter | `PermissionError`, exit 1 | exit 2, `... Permission denied` | | a symlink loop (not in the issue) | `RuntimeError` out of `Path.resolve()` on 3.12, exit 1 | exit 2, `... Too many levels of symbolic links` | The real run and `--dry-run` give the same stdout and stderr, and nothing exists afterwards (no remote directory, no work directory; for adopt, no plan file). What changed, in `scripts/shape_materialize.py` only: - `pin_digest_from_source` catches `OSError` as well as `Refusal` and raises the existing `pin-source-unreadable` with its remediation unchanged. The message names the path and the reason. - `stat()` judges the source inside the guard, as #312 does in `validate-pins.py`, and the sentences are that file's: a missing path, or one beneath a file, is "no such directory"; a file is "it is a file, not a directory"; any other `OSError`, from `stat()` or from git's `cwd=`, is the system's own reason (`strerror`). It is not `exists()`/`is_dir()`, which before 3.14 swallow only a missing path. A source `stat()` can read but `cwd=` cannot enter, a directory with no search bit, fails in `tree_digest` and the same guard answers it. - `declared_pin_values` resolves the path through a guarded `_resolved_pin_source`. `Path.resolve()` raises a `RuntimeError` on a symlink loop before 3.13 (an `OSError` since), before the digest was asked for. As typed, `stat()` meets the loop and says so. - A source that answers is read exactly as before: a relative path resolves against the working directory, a symlink to a clone is followed, `digest_source` reads `local-clone (<path as typed>)`, and the digest is `tree_digest`'s. `tests/test_pin_source_unreadable.py` (46 tests in the #339 commit; fix round 1 adds 17 for S1 and moves one, below) runs each case through `scaffold-project.py --dry-run`, its real run and `adopt-project.py plan`: missing, a file, beneath a file, relative and missing, a parent and a source with no search bit (skipped on Windows and as root, by a mark, so before any fixture builds a directory), a 300-character name, a symlink loop (skipped on Windows) and a directory that is no clone. Each asserts exit 2, the refusal naming the path and the reason, its remediation, no traceback and nothing created. It also holds `--dry-run` and the real run to the same stdout and stderr, checks the path is printed escaped under an ASCII stderr and as a surrogate when it is not UTF-8, and checks that a relative source and a symlink to a clone read as before. The session `gh` guard fails any test whose run called `gh`. origin/main ab623dd reached this branch through implQ's branch: 34dbd86 is a30091f merged with ab623dd. One file conflicted there, `templates/assembly-root/scripts/validate-pins.py`, in seven hunks, because #312 (8cdca5e) replaced `keyed_sources` and `default_source` with `PinSources` and #275 added `env_shared` and `shared`. #312's blob is the same at its PR head, at the squash and at ab623dd, so it landed the file implQ resolved against. The resolution keeps #312's side in all seven and adds #275's on top: | # | hunk | resolution | |---|---|---| | 1 | `resolve_neutral_pin_source` signature | #312's `sources: PinSources` and 3-tuple return, plus #275's `env_shared: bool = False` | | 2 | its docstring tail | #312's `Returns (path, how, typed)` text, plus #275's "Rule 2 is skipped when `env_shared`" paragraph | | 3 | `_recompute_neutral_pin_digest` signature | #312's `sources`, plus #275's `shared: frozenset[str]` after `report` | | 4 | the `resolve_neutral_pin_source(...)` call inside it | #312's 3-tuple unpack, plus `env_shared = product.casefold() in shared` and the extra argument | | 5 | `_check_one_neutral_product_pin` signature | #312's `sources`, plus #275's `shared` | | 6 | its call of `_recompute_neutral_pin_digest` | `sources, report, shared` | | 7 | `_check_neutral_product_pins` docstring and body | #312's `PinSources(...)` and `_note_unused_pin_sources`, plus #275's paragraph, `_report_pin_source_collisions(products, report)` and `shared = frozenset(pin_source_env_shared(products))` | This branch's own merge of 34dbd86 (5690235) had no conflict, and neither had its merge of #409's fix round, 6494714 (583f647). That fix round made `neutral-pin-source-collides` a note and keyed "one product" by `repo_shape.pin_product_key`. At 421e4e5, `templates/assembly-root/scripts/validate-pins.py`, `scripts/repo_shape.py` and `tests/test_pin_source_env_collisions.py` were byte-identical to the tree `git merge-tree` gives for 6494714 with origin/main 3ef059c (blobs 5604007, 091966b, 5220787), so this branch added nothing to those three files beyond #409. The 34dbd86 merge brought in #335, #312, #317, #270 (f795cf7), #344 and #349 with no conflict. Earlier merges of origin/main (87373a6, for #309's reworded constant, and e43fa95) are unchanged. Fix round 1 merged origin/main three more times: - **cd1fc79 (2bcfa69).** It brought #245, #351, #350, #345, #372, #371, #354, #380, #377 and the rest since ab623dd, with no conflict. - **45e01f4 (4098b61).** It brought #396's `tests/test_agents_md_codes.py`. That test finds `scaffold-pin-collides` as a string constant of `scripts/shape_materialize.py`, which `SHIPPED` lists. - **3ef059c (421e4e5), #314.** One conflict, one hunk in `adopt-project.py`. This branch's `_refuse_an_unrecordable_pin_source` and #314's section "The project must be able to hold what `execute` writes into it (#261)" were added at the same place; both are kept. Where the two meet, lane 5's earlier recipe applies: - `_flag_plan` builds each pin as the `PIN_FIELDS` mapping `plan` writes, not `list(pins)` of products. So the plan `plan` asks the validator about is the plan it writes. - #314's `test_plan_asks_what_check_asks_of_the_same_keys` plans `--pin openGlass@<commit> --pin-source <stand-in>` where it planned the name alone, which `plan` now refuses. Then f9ed46f, after #409 squash-landed, and 73d65c6 after it (top of this description). On the merged tree exactly one test failed: `tests/test_adopt_template_values.py::test_check_finds_and_execute_refuses_a_hand_edited_value[pins-surrogate]`. It plans, then hand-edits the plan to `pins: ["openX\ud800"]`, a name-only pin with a lone surrogate. Before this branch the refusal's headline was `REFUSED plan-unwritable-value`. A name-only pin in a plan is now `plan-pin-unrecorded` (#273), so `check` has a second, independent finding for that very plan, and the headline is the first finding's: ``` REFUSED plan-pin-unrecorded: 2 finding(s) ... FINDING plan-pin-unrecorded: `pins:` entry 1, 'openX\ud800', is a name with no commit and no digest ... FINDING plan-unwritable-value: a `pins:` item is 'openX\ud800', which `execute` writes into the assembly root's `project.yaml`, and it holds a lone surrogate ... ``` Nothing about #270's contract changed. The lone surrogate is still found as `plan-unwritable-value`, listed under the refusal, and `execute` still refuses before any leg exists. `check` builds `_leg_findings`, where `_pin_findings` sits, before it calls `_value_findings`, so the pin finding comes first. d806e8f changes one assertion for that row, `pins` only: the headline is `REFUSED plan-pin-unrecorded: ` where it was `PLAN_REFUSED`. The other 15 rows and the finding assertions, including the `plan-unwritable-value` line, are untouched. Lane 5's review of 7a94b6b found 3 should-fix and 5 nits. Each is answered here: - **#409's `pin_product_key` (review N1).** The merge of #409's fix round could not carry it, because this branch had moved the function that used it out of `scaffold-project.py`. `pin_variable_collisions` now keys each pin by that function, where it casefolded. `openß` and `openss` are two pin files and one `SHAPE_PIN_SOURCE_OPENSS`, and a casefold named each of the two pins twice. No `--pin` or recorded `pins:` entry `PIN_ARG_RE` admits can spell either, so the test asks the function directly. `refuse_colliding_pins`' docstring now says, in #409's words, that the root's `validate-pins.py` only notes such a pair. - **S1, a `--pin-source` path that is not printable.** `pin_digest_from_source` names the path as typed unless it is not printable (`str.isprintable`), and then as Python's `repr` spells it (`shown_source`). That covers the refusal's head and git's own reason, which names the directory it ran in. Printed raw, an ESC reached the terminal, and a line break or a carriage return began a line of the path's choosing, a forged `REFUSED` line among them, from the scaffold and from adopt. The traceback #339 replaced had shown a `repr`. A printable path is named byte for byte as before. - **S2, no `gh` on PATH.** `pin_digest_from_gh` refuses as `gh-not-found`, exit 2, as `repo_shape.tree_digest_from_gh` names it, and offers `--pin-source`. It was a `FileNotFoundError` traceback, exit 1, from the scaffold and, new with this branch, from `adopt-project.py plan --pin`. - **S3, a hand-edited `commit:` or `tree_sha256:`.** The lane's decision is to accept it and document it (option (c)); no behaviour changed. A pair that disagrees passes `check` and `execute` (`adoption verified`), because neither reads a network for a pin, by design. The adopted root's own `validate-pins.py` then exits 1 with `neutral-pin-digest-mismatch` wherever it can read the product. `check` now says so once, after the pins it will write: "each pin as `plan` read it, not read again here: the root's own `validate-pins.py` recomputes its digest wherever it can read the product". Options (a), `execute` recomputes before it creates the legs, and (b), `check` recomputes from a clone still on the machine, are filed as #449. - **N2, a `--pin-source` that `plan` cannot record.** `plan` asks `check`'s question (`one_printable_line`) of the path it records in each pin's `digest_source:`, before any digest is read. It refuses one that fails as `adopt-unwritable-value`, in #270's words (`unwritable_reason`), or as "an invisible formatting character" where those name nothing. Before, it was planned, exit 0, and printed raw in the report. `check` then refused it as `plan-pin-malformed` and said to re-run the same `plan`. The report's `pin` line and `check`'s `write` line now spell the digest's source with `_shown`. The scaffold half is pre-existing (a line break in the path is written into the pin file; a byte that is not UTF-8 dies after all three repositories exist) and is filed as #450. - **N3, six hunks no test guarded.** Each now has a test that fails when it alone is reverted: - the two name guards (a `pins:` name holding an ESC and a forged line); - the lower-casing of the commit and the digest (an upper-cased hand edit); - the `digest_source` printability check; - the not-text check (`commit: 1234567` unquoted); - the gitlink filter (a submodule kept where the pin is written is `plan-submodule-root` alone). - **N4.** This body. - **N5, #339's third decision.** A `--pin-source` that nothing reads is still silent, now in adopt too. This PR does not decide it. #451, filed, lays out refuse, note and leave, so closing #339 loses nothing. Lane 5's second review, of 421e4e5, found no blocking item, 2 should-fix items and 3 nits. The two should-fix items are this body: the landing after #409 (above) and #386 (above). The code needed no change for them. f63d1ed adds two tests and no code: - **n1. `plan` asks nothing of a `--pin-source` no `--pin` records.** With the `args.pin and` guard dropped, such a path holding an ESC or a zero-width joiner was refused in a sentence naming no file ("`execute` writes into , and ..."), and every test still passed. `test_a_pin_source_no_pin_records_is_not_asked_about` holds the plan to exit 0 and `pins: []`, with the path named nowhere in the plan or the report. The ESC row is POSIX-only by the file's `POSIX_NAMES` mark; the zero-width joiner row runs everywhere. It holds #451's answer today, silence, so a decision there changes this test on purpose. - **n2. A printable `--pin-source` is printed as it is.** With `_spelled` in place of `_shown` in `plan`'s `pin` line, every test still passed. `test_a_printable_pin_source_is_printed_as_it_is` holds `plan`'s `pin` line, and `check`'s `write` line for the plan `plan` wrote, to their exact text, ending `(local-clone (<path>))` with no backtick. - **n3** needs a code change and is left out (below). **Fix round 2, on f63d1ed.** Each run had a `gh` stub first on PATH (it logs and exits 97), `GH_TOKEN` bogus, an empty `GH_CONFIG_DIR`, `git-filter-repo` 2.47.0 next on PATH, and the identity blanked with `GIT_CONFIG_COUNT`; the session `gh` guard came first inside each run. - **The pin set: 812 passed, 2 skipped.** It covers adopt pins, adopt plan, #339's file, #275's tests, the pin and neutral-pin validators, git output decoding, adopt template values, CLI reference, scaffold pin and reuse, scaffold pin collisions, #314's two files and #396's file. The skips are `test_adopt_plan.py:403` (no MedxEHR clone) and `test_adopt_template_values.py:223` (this host reads `git config user.name` from the repository, not from `GIT_CONFIG_GLOBAL`). That is fix round 1's 809 passed, plus the three new rows. - **Shape doctor and scaffold leg-path collisions: 369 passed, 3 skipped** (the PowerShell line exists only on a Windows host). - **Mutation probes**, each one line changed in a throwaway worktree, over `tests/test_adopt_pins.py` and `tests/test_pin_source_unreadable.py` less the five end-to-end adoptions: - the `args.pin and` guard dropped: 2 failed, both n1 rows; - `plan`'s `pin` line `_spelled`: 1 failed, the n2 test; - `check`'s `write` line `_spelled`: 2 failed, the n2 test and `test_an_upper_cased_hand_edit_is_written_lower_cased`; - `plan`'s `pin` line raw: 1 failed, the no-break-space test that already guarded that hunk. **On the merged tree, 73d65c6** (the merge f9ed46f and the `_read_pins` commit), with the same harness: - **The pin set** above, with #445's `test_adopt_late_failure.py`, `test_adopt_git_reads.py` and `test_adopt_filter_repo_failure.py` and #387's `test_adopt_empty_symlinks.py` and `test_adopt_root_manifest.py`: **988 passed, 2 skipped**. The skips are the two above. - **Shape doctor, scaffold leg-path collisions and the adopt suites:** **967 passed, 3 skipped** (the PowerShell line). The adopt suites are e2e, execute refusals, verify, root shape paths (#387's too), leg-path collisions, clone template, ignored shape files and submodules. - **On the merge alone, f9ed46f** (the same tree as before the `_read_pins` commit): `tests/test_adopt_late_failure.py` gave 3 failed, 83 passed, the three `AttributeError` rows above. - `render-cli-reference.py --check` is ok on the merged tree. pyflakes reports the same four warnings on `adopt-project.py`, `scaffold-project.py` and `scripts/shape_materialize.py` as before the merge. **Fix round 1, on 421e4e5.** Each run had `git-filter-repo` 2.47.0 on PATH and the identity blanked with `GIT_CONFIG_COUNT`. A `gh` stub that logs and exits 97 was first on PATH, with `GH_TOKEN` bogus and an empty `GH_CONFIG_DIR`, and the session `gh` guard came first inside each run. - **The pin set:** 809 passed, 2 skipped (the same files and skips as above). - **Doctor and scaffold:** 782 passed, 3 skipped (the PowerShell line exists only on a Windows host). It covers shape doctor, scaffold leg-path collisions, scaffold e2e, referent chain links, naming policy, repo hygiene and #351's free-text values. - **The adopt suites:** 882 passed. It covers e2e, execute refusals, verify, spec-only, leg paths, root shape paths, plan escapes, leg-path collisions, clone template and submodules. - **Before the #314 merge,** on 74ce4d9's tree: the first two sets gave 577 passed, 2 skipped and 782 passed, 3 skipped. On 2bcfa69's tree (the merges alone, before the fix) they gave 542 passed, 2 skipped and 782 passed, 3 skipped. After the 45e01f4 merge, `tests/test_agents_md_codes.py`, repo hygiene and CLI reference: 110 passed. - **Lane 5's second review** also ran 421e4e5 merged with main cb7063f and with 53bee5b: the pin set, the manifest-value set, and the doctor set with #357's `tests/test_doctor_validator_rows.py`. All passed, with only the skips above. Proof that fix round 1's tests test something: - **On 2bcfa69's tree,** with this head's two test files laid over it, 31 of the new rows fail: - S1: 17; - N2 and its report spelling: 7; - S2: 3; - the `pin_product_key` port: 2; - `check`'s S3 line: 1; - the not-UTF-8 `adopt plan` row: 1. The N3 rows pass there, as they must: they guard hunks this branch already had. - **Mutation probes.** Each hunk was reverted alone, in a throwaway worktree, and both test files were run: 18 of 18 were caught. - **The port:** the casefold keying (2 fail); the casefold lookup alone (2). - **S1:** the path named raw (13); git's reason named raw (2); every path `repr`'d, printable or not (27). - **S2:** no `except` (3). - **N2:** no `plan` check (11); only #270's question asked (1); the formatting-character reason said otherwise (1); the report's `pin` line raw (1); `check`'s `write` line raw (1). - **S3:** the line dropped (1). - **N3:** the `_pin_fix` name guard (1); the `_read_pins` path guard (1); the lower-casing (1); the `digest_source` check (1); the not-text check (1); the gitlink filter (1). - **The issue rows reproduced.** S1, S2 and N2 were reproduced on 2bcfa69's tree and shown gone on the fix (a probe driving both tools; `gh` was called 0 times). **Before fix round 1.** Runs were on 7a94b6b, with `git-filter-repo` 2.47.0 first on PATH and the repository-local `user.name` blanked with `GIT_CONFIG_COUNT` (a workstation whose standard checkout sets one fails `test_the_scaffold_refuses_with_no_elector` on main itself; CI sets none). 7a94b6b differs from ffd1297 in `tests/test_pin_source_unreadable.py` only, so the three suites that do not read that file ran on ffd1297: - the new file: 46 passed; - adopt pins, adopt plan, git output decoding: 172 passed, 1 skipped (the MedxEHR clone is absent); - scaffold pin and reuse, pin collisions, e2e, referent chain links, neutral pin and pin validators, #275's tests, naming policy, repo hygiene, CLI reference, scaffold leg-path collisions: 571 passed; - shape doctor: 254 passed, 3 skipped (the PowerShell line exists only on a Windows host); - the new file with repo hygiene, git output decoding and CLI reference, once more after the last edit: 176 passed. Earlier on 5690235 and d806e8f, before the #339 commit: the adopt suites (e2e, execute refusals, verify, spec-only, leg paths, root shape paths, plan escapes, leg-path collisions, clone template) 740 passed, and `tests/test_adopt_template_values.py` with #273's other adopt tests 489 passed, 2 skipped. They were not re-run on 7a94b6b: the #339 diff touches `pin_digest_from_source` and the call in `declared_pin_values`, which those suites reach through `test_adopt_pins.py` only. Nothing was run on macOS or Windows. Proof the new tests test something: - **On d806e8f.** 38 of the 46 fail, each on the traceback and its exit 1. The 8 that pass are the unchanged behaviour: the not-a-clone refusal (4 rows) and the valid-source rows (4). - **Mutation probes.** Ten hunks reverted one at a time, each failing at least one new test: the `OSError` catch (16 fail), the catch narrowed to `OSError` only (21), the missing-path clause (9), the clause narrowed to `FileNotFoundError` (3), the `S_ISDIR` judgement (3), the loop guard (4), no resolve at all (3), the old `.resolve()` call (4), the reason as `str(exc)` (12), and the file sentence as the OS's (3). - #273's own 52 tests still fail on c7c02fa (51 fail or error; the one that passes checks the test's own table), and its 18 mutation probes were each caught. **Re-verified after the merge.** An independent re-verification of f9ed46f and 73d65c6 found the code correct: - #409 is carried whole. A 30,000-case fuzz of `--pin` lists through #409's final refusal and this branch's port differed in 0 cases. - `scaffold-project.py` equals the tested file plus main's own changes that are not #409's (same patch-id). - `_commit_the_split` keeps #445's `try` and #394's `append`. - `_read_pins` reads a loaded plan as before. Its findings were all in this description (the #506 bullet and three stale facts), now fixed. Runs on the head and on its merge with main 48585e6: 988 passed, 2 skipped; and 967 passed, 3 skipped. `git merge-tree --write-tree` was run at 01:48Z on 2026-10-13, comparing hunks per file. Each PR head, fetched from `refs/pull/<n>/head` with no `gh`, was merged with 73d65c6 and with origin/main 9736424 alone. Two sets were asked about: - every PR this description listed before that main does not now contain; - every PR numbered above #468 whose head main does not contain: #473, #474, #490, #491, #493, #494, #495, #496, #497, #503, #504 and #505. **Open state, read with `gh` by the coordinator at 02:00Z and refreshed at 02:25Z after a re-verification on main 48585e6.** Every pull request named below is open. #184, #94, #96, #98, #100 and #161 are closed, and #465 landed as 48585e6. `fix/adopt-plan-quote-yaml-keywords` has no pull request. #506 (`fix/scaffold-reuse-seeded-legs`) opened after this list was made, and the re-verification reads it. - **Landed since the last draft of this list:** #343, #346, #355, #358, #373, #378, #382, #387, #394, #397, #401, #404, #409, #419, #452, #456, #465, #466 and #484. #394's `_commit_the_split` conflict and #401's `docs/cli.md` conflict are both resolved in f9ed46f, above. - **Clean, 20:** #266, #347, #356, #374, #376, #384, #395, #453, #467, #468, #473, #474, #490, #491, #493, #494, #495, #497, #503 and #505. #453, #468 and #491 were updated onto main since the first read and now merge clean. #507 (lane 5's #486-#488) shares only the generated `docs/cli.md` with this branch and merges clean with it. - **Conflicting with main alone, and this branch adds no hunk:** - #402: `shape-doctor.py` 5; - #496: `shape-doctor.py` 10 and `tests/test_shape_doctor.py` 1. **Conflicts this branch adds:** - **#435** (3efcc7a, lane 2's `fix/adopt-plan-field-types`, for #386). - It adds 2 hunks in `adopt-project.py`: 5 here, against 3 with main alone. They are `render_plan`'s `pins:` line and `Plan.pins`. - Keep this branch's `_pin_lines` and `_pin_products`. The rest is under "Where the meaning meets". - **#504** (37ef29a, `fix/adopt-root-kept-symlinks`). - It adds 1 hunk in `adopt-project.py`: 2 here, against 1 with main alone. It is the materializer call in `_commit_the_split`. - Keep both arguments and both comments: `append=append, neutral_pins=_recorded_pins(plan), spell=_spelled`. - **#506** (119d8c4, `fix/scaffold-reuse-seeded-legs`). - It adds 1 hunk in `scaffold-project.py`. With main alone, #506 conflicts only in `docs/handbook.html`. - #506 inserts `LEG_TEMPLATES` right after `declared_pin_products`, which this branch moved out, and rewrites `_reusable_remotes` further down. Keeping both sides breaks the file with an unterminated string literal. - Keep only #506's `LEG_TEMPLATES` block. Drop #506's `declared_pin_values`/`declared_pin_products`, which moved here, and this branch's three-line `_reusable_remotes` opener, which #506 rewrites below. Resolved that way, pyflakes is clean and #506's scaffold tests pass (88). - **`fix/adopt-plan-quote-yaml-keywords`** (ed9968f; a branch with no pull request). - It adds 2 hunks in `adopt-project.py`: 3 here, against 1 with main alone. - One is `render_plan`'s `pins:` line. Keep `_pin_lines`, which already sends product, repository and `digest_source` through `y`. - The other is `_refuse_unholdable_values`' signature. Keep `pins: dict`, with that branch's `_validator_judged` and `_named_as_read` above it. - `fix/adopt-late-failure-notice` is no longer on origin. #445, the late-failure notice, is on main and merged here. **Where the meaning meets:** - **#435 and #386.** The coordinator has said this on #435: #435 (comment) - #435's `_plan_key_findings` (`plan-bad-pins`) keeps only text items in `pins:`, and its `PINS_REMEDIATION` tells a person to write `pins: [openGlass]`. - This branch writes each pin as a mapping, and it makes a name alone `plan-pin-unrecorded`. - Read from #435's code, not run: on a tree with both, the plan `plan --pin` writes is `plan-bad-pins` in `check`. - Whichever lands second reconciles them, with three changes: - `_plan_key_findings` takes this branch's mappings, or leaves `pins:` items to `_read_pins`; - a `pins:` that is not a list gives one finding, not both `plan-bad-pins` and `plan-pin-malformed`; - `PINS_REMEDIATION` says the mapping `plan` writes. - Until that is done, `tests/test_adopt_pins.py::test_a_plan_with_a_whole_pin_checks_ok` fails. - **#314.** It landed, and it is merged here (above). - **`fix/adopt-plan-quote-yaml-keywords`.** Its pin tests are written against the name-only `--pin`. They need the `name@commit` form, and their expected `pins: [...]` line becomes `_pin_lines`'s mapping. - **Two unwritable values are refused in two runs (lane 5's second review, n3).** `plan --elected-by 'A<LF>B' --pin openGlass@<sha> --pin-source <a path holding an ESC>` refuses the elector alone, exit 2. Re-run with the elector retyped, it refuses the source; #270's refusal names every unwritable value at once. Reproduced on 421e4e5, with `gh` called 0 times. One refusal would need a code change, not made here: - `_refuse_an_unrecordable_pin_source` would split into a function that returns the sentence; - `_checked_plan_inputs` would ask it before #270's `unwritable_values` raise, and raise one `adopt-unwritable-value` that names both, with both remediations; - a test would add the two-value row. N2's question is `one_printable_line`, not `unwritable_reason`, so it cannot simply join #270's list. - **Docs.** The README, AGENTS.md and `docs/handbook.html` are unchanged, because none of them calls adopt's `--pin` a name. A sentence saying adopt now takes the scaffold's `--pin` is a follow-up. It costs an AGENTS.md line-cap raise, and a README edit forces the handbook's README blob to change. - **A product spelled `null`, `true` or `false`.** The scaffold already accepts `--pin null@<sha>`: it exits 0 and builds a root whose `validate-pins.py` exits 1 `neutral-pin-entry-malformed`. Adopt's `plan` writes `product: null` through `y`, and `check` then finds `plan-pin-malformed` and refuses it before any leg exists. The one fix for both tools is in `parse_pin`, and it would change the scaffold's behaviour. - **Wording shared with the scaffold.** `digest_source` is written bare into the pin file, so a `--pin-source` path holding ` #` is cut short there. `templates/assembly-root/contracts/neutral-product-pin.yaml` and `validate-pins.py`'s `neutral-pin-missing` remediation name only the scaffold as the writer. Two comments in `scripts/repo_shape.py` still name the scaffold's `pin_digest_from_gh`, in a digest-pinned shipped copy. - **Filed as follow-ups:** - #449: S3, a hand-edited `commit:` or `tree_sha256:` that disagrees, with options (a) and (b); - #450: the scaffold half of N2, a `--pin-source` path no file can hold; - #451: #339's third decision (N5), a `--pin-source` that nothing reads. - **`validate-pins.py` prints a `--pin-source` path raw** in `neutral-pin-source-unreadable`, the twin of S1. It is a shipped template that #409 and other open PRs edit, so it is left for its own change. No issue is filed for it yet. - **Windows and macOS** were not run here; CI ran both (below). Two assertions that depend on what Windows answers for a path (a name past the filesystem's limit, a path beneath a file) check only the refusal and its remediation there. Fix round 1's rows that need a control character or a byte that is not UTF-8 in a path, or a symlink to `git`, are skipped on Windows by a mark, and so is fix round 2's ESC row. The rows for a no-break space and a zero-width joiner run everywhere, and so does the in-process `gh-not-found` test. Reviewed independently by lane 5 at 7a94b6b (3 should-fix, 5 nits: fix round 1) and at 421e4e5 (0 blockers, 2 should-fix, 3 nits: fix round 2). After #409's squash, the re-verification of f9ed46f and 73d65c6 found the code correct; its 1 should-fix and 3 nits were in this description and are fixed. GitHub's update-branch then merged main twice (33bae3f, 2170526), with no hand edit. CI's tests, tests-macos and tests-windows and SonarCloud all passed at 2170526 (main cac6bb2 merged in). On that head merged with main 57c85e9 (#490, #474 and #468, none of which touches this branch's files), the pin and adopt set with `tests/test_update_shape_landing.py` gave 1112 passed, 2 skipped, and the doctor, adopt end-to-end, unfinished-merge and bootstrap set gave 1056 passed, 3 skipped (the doctor's PowerShell line, which exists only on a Windows host). Closes #273 Closes #339 Lane: openreposhape-5 (openRepoShape-5) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
brettheap
added a commit
that referenced
this pull request
Oct 13, 2026
…`scripts/siblings.py` is absent, and update-shape.py says the Makefile it copies calls it, so a holder updated without `--add` no longer fails on `can't open file` (#489) (#503) A family holder cut before 2026-09-09 (#76) has no `scripts/siblings.py`. Updating it the way AGENTS.md prescribes, `update-shape.py apply` without `--add scripts/siblings.py`, still copies the changed Makefile, and that Makefile's `siblings`, `park` and `resume` targets run the script. `apply` exited 0, `validate-family.py` was green, only `note ... not added` was printed, and then all three targets died on `python3: can't open file '.../scripts/siblings.py'`. This takes the issue's second option, which keeps per-file consent and never leaves a dead target. `apply` still refuses nothing, copies the Makefile and adds nothing it was not told to. **What changed** - `templates/family-root/Makefile`: each of the three targets asks make itself, `$(wildcard scripts/siblings.py)`, whether the script is there, and when it is not it refuses by name with `$(error)`: exit 2, one shared message, and no shell involved (no `test -f`, no `echo`), so the answer is the same wherever make runs. The message says what is missing, that `update-shape.py` adds a file only on the human's word, `python3 update-shape.py check --root "<this holder>"` to read the verdict, then the apply command it prints with `--add scripts/siblings.py`, and, for a holder that took the script and then deleted it (where `check` says `copy-missing` and `--add` refuses a pinned path), to restore it from the holder's history instead. With the file there, each recipe is what it was: same command line, same arguments. - `update-shape.py`: `check` and `apply` say, on the line that already reports the file, that the Makefile calls it. `check` appends it to the `upstream-added` detail and `apply` to its `note ... not added` line. It is a table (`CALLED_BY_A_COPY`) with one row, and it speaks when the calling copy is `upstream-changed` (the one verdict `apply` writes on its own: "the Makefile that `apply` copies calls it, so `make siblings`, `make park` and `make resume` cannot run until it is added") or `unchanged` (the holder after that first `apply`, pinned at the target, where every later `check` and `apply` still finds the script `upstream-added`: "this root's Makefile already calls it, so ... cannot run until it is added"). A `locally-modified` or `both` Makefile says nothing. Nothing is refused and the exit codes are unchanged. - `AGENTS.md`, item 6 of the family section: one clause, in place, with the same line count, so the file stays at its cap (490/490). It keeps "per file": `apply --add scripts/siblings.py` takes it on the human's word, per file, and without it `make siblings`, `park` and `resume` refuse. **Evidence** - Reproduced on `main` (7a8b981) with a real holder cut at 0170edd, the commit the issue names, local remotes and a stub `gh`: `check` says `Makefile` `upstream-changed` and `scripts/siblings.py` `upstream-added`; `apply` without `--add` exits 0 with `family ok`; `make siblings`, `make park` and `make resume` each print `can't open file` and exit 2. - On this head, the same holder: `check` and `apply` carry the sentence above, `apply` still exits 0, and the three targets exit 2 with `make <verb> needs scripts/siblings.py, which this holder does not have. ...` and no `can't open file`. With `apply --add scripts/siblings.py` all three exit 0 and run the real script. - `tests/test_family_makefile_siblings.py` (new, 31 tests; skipped only where `make` is absent) cuts a holder from a standard before #76 (a clone with no `scripts/siblings.py`, its copy-list entries stripped and the v0.4 Makefile: built, not read from history, so a shallow clone runs it), updates it to this checkout's bytes with `apply` with and without `--add`, and runs the three targets in each. It also runs the Makefile alone: the refusal is one message for the three targets, it needs no shell (`SHELL=/nonexistent` still refuses), `make -n` refuses too, the present-script path calls the script with the arguments it always had, `help`, `bootstrap`, `validate` and `pins` are untouched, and `CALLED_BY_A_COPY` is held to the template. It also covers a second `check` and a second `apply` on a holder already at the target (the `unchanged` clause), and the `copy-missing` sentence in the refusal. It carries no `WINDOWS_SKIP`, unlike `tests/test_park_resume_targets.py`: the refusal needs no shell, and `windows-latest` ships a GNU make (the runner-images install script copies `mingw32-make.exe` to `make.exe`), so the tests are expected to run on all three runners. CI's logs are quiet-mode, so they do not show whether they ran. - Mutation checks, run in a throwaway clone of the head: with the Makefile reverted to `origin/main`'s, 13 of the 31 fail (the refusal tests, the one-message and no-shell tests, `make -n`, and every `make` run on the updated holder, which print `can't open file` again). With `update-shape.py` reverted, 9 fail (the `check` and `apply` sentence, the `left_dead_by` cases and the table). Taking only the `unchanged` branch out of `left_dead_by` fails 2 (the unit case and the second `check`/`apply`), and taking only the `copy-missing` sentence out of the Makefile fails 3 (the refusal test, once per verb). - No static digest of the family-root Makefile exists in the repository: `git grep` of its sha256 finds nothing, and every `shape-pin.yaml` row is rendered from the bytes at `init` and `apply`. A holder's pinned digest moves with the file, as for any template change. **Tests** All at 49330dc (origin/main 5a25387 merged in), with a stub `gh` first on PATH, a bogus token, an empty `gh` config directory and the git identity blanked: - `tests/test_family_makefile_siblings.py`: 31 passed. - `tests/test_update_shape*.py` (seven files), the new file, `tests/test_park_resume_targets.py`, `tests/test_repo_hygiene.py`, `tests/test_agents_md_codes.py` and `tests/test_cli_reference.py`: 438 passed, 3 skipped (the NTFS-junction cases, Windows only). - every `tests/test_family*.py` and `tests/test_shape_doctor.py` (the doctor loads `update-shape.py` in process): 842 passed, 11 skipped (`tests/test_family_init_values.py:242`, which the file documents, and the doctor's PowerShell line, which prints only on a Windows host). At 44000f6, after GitHub's update-branch merged main af01068 (no hand edit), the same sets ran again with the same stubs. The update-shape set, which now has eight files with #374's `tests/test_update_shape_next_quoting.py`: 535 passed, 3 skipped. Every `tests/test_family*.py` and `tests/test_shape_doctor.py`: 858 passed, 11 skipped. That head was then merged with main 47b1e06 (#395, the templates quote their text placeholders) as a local gate commit. On it, the two sets, together with `tests/test_template_text_placeholders.py`, gave 1481 passed, 25 skipped. **Merge-tree.** At 49330dc, which contains `origin/main` 5a25387 (merged as f08129d), `git merge-tree --write-tree` is clean against `origin/main`, against every open pull-request head that touches `AGENTS.md`, `update-shape.py` or `templates/family-root/` (#347, #374, #395, #465, #474), and against lane 5's `fix/family-commands-and-branch` (10c93de, #486-#488). #491 conflicts only in `docs/handbook.html`, as it does with `origin/main`. The trees merged with #474 and with `fix/family-commands-and-branch` were run: the new test file and the neighbouring suites pass on both, and `AGENTS.md` stays at 490 lines. **Review.** An independent review at 8643774 gave APPROVE WITH NITS (0 blockers, 0 should-fixes, 5 nits). It reproduced the defect on `main` and the fix on this head, and ran 10 mutations, all of them caught. Round 2 (49330dc) took four of the nits: the test file's docstrings say where it runs; the refusal also covers a holder that deleted a pinned `scripts/siblings.py`; AGENTS.md keeps "per file"; and a later `check` on a holder already at the target names the Makefile that calls the script. The fifth nit was this description. Re-verified at 49330dc: APPROVE WITH NITS (0/0/1). That nit was this description's merge-tree paragraph, now as above. **Left out** - `apply` does not refuse to take the Makefile without the script (the issue's first option), and it does not take the script on its own: both break per-file consent. - The holder's `AGENTS-shape.md` and `README.md` are pinned copies and say nothing about this; editing them moves every holder's digests for a sentence the Makefile's own refusal already carries. README and the handbook are untouched. - The doctor's `shape currency` row does not carry the sentence and is unchanged; the per-file detail line of `check` and `apply`'s note do, and the Makefile's own refusal covers the moment of use. - The refusal is written for GNU make. macOS ships 3.81: the guard uses only `$(if)`, `$(call)`, `$(wildcard)` and `$(error)`, which 3.81 documents. It was run on 4.3 here. CI's `tests`, `tests-macos` and `tests-windows` and SonarCloud all passed at 8643774, and again at ca4778e (49330dc with main 48585e6 merged in by GitHub's update-branch), at 6fe17be (main 57c85e9 merged in the same way, after #474 changed `update-shape.py`; no hand edit) and at 44000f6 (main af01068 merged in the same way, after #374 changed `update-shape.py` and #491 and #505 changed `AGENTS.md`; no hand edit). Reviewed independently at 8643774: APPROVE WITH NITS (0/0/5). Round 2 (49330dc) took the four code nits, and its re-verification gave APPROVE WITH NITS (0/0/1), the description's merge-tree paragraph, now updated. CI is green on Linux, macOS and Windows, with SonarCloud passing, at 44000f6 (main af01068 merged in by update-branch). Main 47b1e06 (#395), which landed after, touches none of its files, and the combined tree passed the family, doctor, update-shape and hygiene tests (1481 passed, 25 skipped). Closes #489 Lane: openreposhape-5 (openRepoShape-5) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
brettheap
added a commit
that referenced
this pull request
Oct 13, 2026
…s 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) Three defects from lane 3's v1.0.0 acceptance pass of AGENTS.md's "Creating a family, and adding a member", one commit each, in this order, then one review commit for #486 and one for #487. All three change `scripts/family.py` and `add`'s NEXT line, so they are one pull request. **What was wrong.** - AGENTS.md spelled the command `python3 scripts/family.py init --org <org> --family <Name>`, a path that runs from the standard's root. `--into` defaults to where the person stands. - So the command, followed exactly, printed `landing <standard>/Orbit/Orbit` with no word, and `make siblings` would then clone every member into the standard's checkout too. - `init`'s NEXT STEPS printed `python3 family.py add …`, built from `Path(__file__).name`. From the root that fails `can't open file`, exit 2. **What changed** (commit 1). - With neither `--into` nor `--work-dir`, `init` refuses a landing inside a checkout of openRepoShape: `family-landing-in-standard`. A checkout is a directory holding `scripts/family.py` beside `templates/family-root/`, found in the landing's ancestry, so another clone or an install counts too. - The refusal comes before anything is created, under `--dry-run` alike. - The remedy names `--into ..` from the root. From deeper inside the checkout it names the relative path that reaches the checkout's parent. - An explicit `--into` or `--work-dir` is not second-guessed. `family-holder-already-here` is still asked first. - NEXT STEPS, and the `family-holder-already-here` remedy, name this file relative to the directory `init` ran in. From the root that is `scripts/family.py`, as setup-project.py, validate-family.py, AGENTS.md and README spell it. It is absolute where no relative path exists. - AGENTS.md's init command passes `--into ..`, as README's already does, and step 1 says why. The edit is line-neutral: step 1 is one line shorter. - `init --into --help` says it too, and docs/cli.md is regenerated. **How tested.** `tests/test_family_init_landing.py`, 9 tests: - the old command from the root is refused, as a dry run, so nothing can land in the checkout; - a real run inside a fake checkout creates nothing; - the remedy from a subdirectory names the right parent; - an explicit `--into .` or `--work-dir .` passes; - outside a checkout the default is unchanged; - AGENTS.md's line, as written, lands beside the checkout; - the printed NEXT runs, both from the root and from elsewhere. On origin/main code 6 of them fail. Removing the refusal turns 3 red, and putting `Path(__file__).name` back turns 2 red. **What was wrong.** `family.py` and the holder's `siblings.py` printed every path in their pasteable commands bare. Under a holder at `…/my work/Sonata/Sonata`: - the `member-git-dir-cached` remedy `rm -rf <store>` split into `rm -rf …/my`, an absolute directory that is NOT the store, and a relative `work/…`; - `init`'s NEXT STEPS and `add`'s NEXT split `--family-root` and `git -C` (`fatal: cannot change to '…/my'`, exit 128); - the `mv` lines for a misnamed family folder pasted as four arguments. **What changed** (commit 2, and the review commit after #487's). - `scripts/repo_shape.py` gains `shell_quoted(value, platform=None)` and `shell_line(words, platform=None)`, in a new section at its end, the library `family.py` already imports. - It is the doctor's `quote_arg` rule (#101/#102): the same two alphabets, and the same two escapes, `sh`'s `'\''` and PowerShell's doubled apostrophe. The dialect comes from `os.name` or a `platform` argument. An ordinary word is left bare. - It does not flatten to ASCII, as the doctor's report does by contract. A command that deletes or moves a directory has to name that directory. So PowerShell's typographic single quotes are doubled too. - A word that begins with `=` is quoted, in both dialects. zsh, macOS's login shell, expands a bare `=word` to a command's path (`=ls` reaches the command as `/bin/ls`). This is the one place it differs from the doctor's rule on ASCII. - `family.py`: - `init`'s NEXT STEPS print the `add` on ONE line. It used to paste only into a POSIX shell, because of its `\` continuation. `cd <holder>` and `make siblings` are two lines, with no `&&`, which Windows PowerShell 5.1 rejects between two statements. - Those lines and the `family-holder-already-here` remedy quote every path. - `add`'s NEXT quotes `git -C <holder>`, and `member-path-taken` quotes each spelling it names. - `member-git-dir-cached`, and `remove`'s note about the same store, print the directory alone on its own line. Then comes `rm -rf` with its one argument quoted for the POSIX shell `rm -rf` belongs to, and the sentence names that shell: Git Bash on Windows. PowerShell refuses `-rf` and deletes nothing. - `siblings.py`: the parent-folder warning's `mv` and `mkdir -p` lines are quoted for a POSIX shell with the standard library's `shlex.join`, and the warning says which shell. It does NOT import the new quoter: a holder that kept its own `repo_shape.py` through `update-shape.py apply --accept-local` takes the new `siblings.py` without it, and an import of a name its copy lacks stopped `make siblings`, `park` and `resume` with an ImportError that `check` and the validator never reported. - `setup-project.py`'s family hand-over quotes the holder in its `add` line (and names the branch first, see #487). It runs before any checkout of the standard exists, so it carries its own copy of the rule, and a test holds that copy to `shell_quoted`. **How tested.** `tests/test_family_printed_quoting.py`, 69 tests: - The quoter round-trips through `shlex.split`, and through a PowerShell reader, for a space and an apostrophe, `é` and a typographic apostrophe, shell syntax, the empty string, and every printable ASCII character alone and before, inside and after a word. - The host's own `sh`, `bash` and `zsh` hand each quoted word back byte for byte through `printf`, a leading `=` among them (skipped where a shell is absent, and on Windows). - It agrees with the doctor's `quote_arg` on every one of those ASCII values but a leading `=`, and its two alphabets are the doctor's two patterns. - Under a holder in `my work` and in `Dana's work`, each of these splits into the argv it means: `init`'s NEXT (with `cd` and `make siblings` on their own lines), `add`'s NEXT, the cached-store remedy and note, the `mv` lines, and setup-project's `switch` and `add`. - The `rm -rf`, run as split, deletes the store, and the decoy `<tmp>/my` survives. - The `mv` lines, run as split, move the holder. - The holder's own `siblings.py` runs `--help`, the misnamed-folder warning and `--make park` beside a `repo_shape.py` that lacks every name this change added. - Three existing tests' expected lines follow the new wording. Mutations, each turning tests red: - a bare quoter: 35 red; - bare `mv` lines in `siblings.py`: 3 red; - a bare `rm -rf`, a bare `add` NEXT, a bare `init` `add` (round 1, on the 85-test file): 2 red each; - `siblings.py` importing `shell_line` again: 1 red (the older-`repo_shape.py` test); - `%` dropped from the POSIX alphabet: 2 red (the every-ASCII agreement and the alphabet test). The round-1 sample test passed it, 36 of 36; - a leading `=` left bare: 10 red, among them the real-`zsh` test; - `cd … && make siblings` back on one line: 2 red; - setup-project's holder unquoted: 2 red. **What was wrong.** - AGENTS.md says each act's ONE commit lands as a pull request, and no step made the branch that pull request needs. - After `init` the holder stands on `main`, and all three acts committed straight onto it. - `add` printed `NEXT git -C <holder> push -u origin <branch> && open a pull request`. No branch is called `<branch>`, so the push failed: `src refspec … does not match any`. - `bump` and `remove` printed no NEXT at all. - `bump-leg.py` refuses exactly this for a leg (`bump-leg-on-tracking-branch`). **What changed** (commit 3, and the review commit after it). - The real run of each act refuses the holder's tracking branch, the one `family.yaml` declares (`family-on-tracking-branch`), and a HEAD on no branch (`family-holder-detached`, which is what `bump-leg.py`'s `bump-leg-root-detached` refuses too). - The check comes after the refusals about the arguments and the holder, and before the member is read, fetched or cloned, and before anything is written. - The remedy is a quoted `git -C <holder> switch -c <branch>`. The branch is `family/add-<project>`, `family/bump-<id>-<sha12>` or `family/remove-<id>`, and a name that is not a plain branch word becomes `member`. - `--dry-run` runs on any branch. On a work branch it prints where the commit would land. On the tracking branch it prints that the real run refuses there, with the refusal's code, and the `switch` command on a line of its own. The module's EXIT CODES paragraph names this as the one refusal a dry run does not make. - Each act that commits ends with ONE pasteable line: `NEXT git -C <holder> push -u origin <the branch it committed on>`, quoted, then `then open a pull request against <tracking>; never push to it directly`. `bump` and `remove` gain that NEXT. - `init`'s NEXT STEPS open with the `switch` before the `add`. - `add`, `bump` and `remove` `--help` say the branch rule, and that each ends by PRINTING the push; docs/cli.md is regenerated. - AGENTS.md's family block gains the `switch` step before the `add`, and step 3 says the tracking branch is refused, as `family-on-tracking-branch`, and that the branch is pushed as its NEXT line says. README's InkRouter block gains the same step, and its paragraph says it. Both edits are line-neutral: AGENTS.md tightens steps 2 and 5, and README tightens the `make bootstrap` paragraph. `docs/handbook.html` mirrors the block and the sentence, and its footer names #487 and the new README blob. - The holder's own docs, `templates/family-root/AGENTS-shape.md` and `templates/family-root/README.md`, open their add/bump/remove block with the `switch` and say the act refuses the tracking branch. `setup-project.py`'s family hand-over prints the `switch` before its `add`. - Test fixtures that committed on `main` now commit on a branch: - `tests/test_family.py`'s module fixture grows the family on `family/members` and pushes that branch to the remote's `main`, as the merged pull request would leave it; - `test_shape_doctor.py`'s holder fixture and `test_family_add_excludes.py`'s `empty_holder` switch to a branch; - `test_family_add_refusals.py` changes in four places: the `NEXT` expectation, `unborn_holder`, the empty-family test, and the corrupt-HEAD test. In that last test, the tag state's branch check is answered in-process, because the test is about the rollback's reading of HEAD. **How tested.** `tests/test_family_tracking_branch.py`, 17 tests: - For each act, on `main`: refused, with the holder byte for byte as it was, and for `add` nothing cloned. Then the printed `switch`, run as split, makes the branch; the act goes through on it; and its printed NEXT, run as split, pushes the branch, which the remote then holds at the act's commit. - A detached HEAD is refused. - Dry runs on `main` and on a branch say what they should. - A family made with `--tracking-branch trunk` refuses `add` on `trunk`; on a branch named `main` the dry run says the commit lands there for a pull request against `trunk`, the real run commits, and its NEXT pushes `main`. - The suggested names pass `git check-ref-format --branch`. - `init`'s NEXT STEPS open with the `switch`. - AGENTS.md, README.md and the holder's two docs show the `switch` in the same block as, and before, the first `add`. Mutations, each turning tests red: the branch check letting `main` through, 4 red; the NEXT line naming `<branch>` again, 3 red; `init`'s NEXT STEPS without the `switch`, 1 red; the tracking branch hard-coded to `"main"`, 1 red (the `trunk` test; every family test passed it before); the holder docs without the `switch`, 2 red; setup-project without the `switch`, 2 red. An independent review at 10c93de gave CHANGES NEEDED (0 blockers, 1 should-fix, 6 nits). The should-fix was a holder that kept an older `scripts/repo_shape.py` through `apply --accept-local`: its new `siblings.py` could not import the shared quoter, so `make siblings`, `park` and `resume` died. The round at bb11b63 fixes it and all six nits, as described above. Re-verified at bb11b63: APPROVE WITH NITS (0 blockers, 0 should-fixes, 3 nits), with SonarCloud's quality gate OK and 0.0% new duplication. The nits were the holder README's pointer to the push (now "as its `NEXT` line says"), two Sonar smells (S1192: `refs/heads/` is now `HEADS_PREFIX`; S3415: the two expected-first assertions now put the actual value first, as the file's other 32 do), and this description's list of other pull requests. All three are fixed at 3451a56: commit 11ae0a8, then a clean merge of main 994be39. The family set gave 566 passed, 8 skipped there. GitHub's update-branch then merged main cac6bb2 as 8e1471c, and main aa4e1f5 (#508, after #490, #474 and #468) was merged as 708f3bb. There only the `docs/handbook.html` footer conflicted: it takes main's clauses, #468's (#424) included, with the README blob recomputed, and `docs/cli.md` auto-merged and passes `--check`. Main 47b1e06 (#505 and #395, after #376, #374, #384, #495, #493 and #491) was then merged as fcbc7a2, again with only the footer in conflict: main's clauses stay in main's order, this branch's (#487) moves to the end, after (#483), and the README blob is recomputed. Every run used `/usr/bin/python3 -m pytest -q -p no:cacheprovider`, with a stub `gh` first on PATH, a bogus `GH_TOKEN`, an empty `GH_CONFIG_DIR` and git's identity blanked. Run on Linux. At e42ef74 (main d41cc29, #402, merged in by GitHub's update-branch), on its tree 655c927: the first set listed below for fcbc7a2, plus every `tests/test_update_shape*.py`, gave **1242 passed, 22 skipped**; the second set, plus `tests/test_leg_path_yaml_scalars.py`, `tests/test_ruleset_hint_tracking_branch.py`, `tests/test_scaffold_reuse_seeded_legs.py`, `tests/test_scaffold_pin_and_reuse.py` and `tests/test_doctor_validator_rows.py`, gave **1260 passed, 12 skipped**. The skips are the same as at 5a2776d, below. At 654df49 (main 8cd7dbe merged in, with #506 and #347): the first set listed below for fcbc7a2, plus every `tests/test_update_shape*.py`, gave **1242 passed, 22 skipped**; the second set, plus `tests/test_leg_path_yaml_scalars.py`, `tests/test_ruleset_hint_tracking_branch.py`, `tests/test_scaffold_reuse_seeded_legs.py` and `tests/test_scaffold_pin_and_reuse.py`, gave **1231 passed, 12 skipped**. The skips are the same as at 5a2776d, below. At 5a2776d (main f391e58 merged in, with #266, #509, #496 and #435): the first set listed below for fcbc7a2, plus every `tests/test_update_shape*.py`, gave **1213 passed, 22 skipped** (the template-quoting skips below, and three NTFS-junction cases, Windows only); the second set, plus `tests/test_leg_path_yaml_scalars.py`, gave **1171 passed, 12 skipped** (the four Windows-only skips below, and eight in that file, main's new one, whose cases the quoted templates (#259) leave with nothing to refuse). At 22733ce (main 631f087, #503, merged in by GitHub's update-branch): the first set listed below for fcbc7a2, plus every `tests/test_update_shape*.py`, gave **1213 passed, 22 skipped** (the template-quoting skips below, and three NTFS-junction cases, Windows only); the second set gave **944 passed, 4 skipped**. At fcbc7a2 (origin/main 47b1e06 merged in, with #505 and #395): - every `tests/test_family*.py`, `tests/test_validate_family*.py`, `tests/test_park_resume_targets.py`, `tests/test_free_plan_hint.py` and `tests/test_template_text_placeholders.py`: **844 passed, 19 skipped** (`tests/test_family_init_values.py:219` and `:291`, which skip because the template now quotes the placeholder and `id:`). - `tests/test_repo_hygiene.py tests/test_agents_md_codes.py tests/test_cli_reference.py tests/test_shape_doctor.py tests/test_setup_project_py.py tests/test_setup_sh.py tests/test_template_quoted_values.py tests/test_stdout_encoding.py tests/test_windows_paths.py tests/test_commit_trailers.py`: **944 passed, 4 skipped** (the doctor's PowerShell line and `tests/test_stdout_encoding.py:286`, Windows only). At 708f3bb (origin/main aa4e1f5 merged in): - every `tests/test_family*.py`, `tests/test_validate_family*.py`, `tests/test_park_resume_targets.py` and `tests/test_free_plan_hint.py`: **718 passed, 8 skipped** (`tests/test_family_init_values.py:242`). - `tests/test_repo_hygiene.py tests/test_agents_md_codes.py tests/test_cli_reference.py tests/test_shape_doctor.py tests/test_update_shape_landing.py tests/test_doctor_unfinished_merge.py tests/test_template_values_single_pass.py tests/test_stdout_encoding.py tests/test_windows_paths.py`: **813 passed, 4 skipped** (the doctor's PowerShell line and `tests/test_stdout_encoding.py:286`, Windows only). Earlier, with origin/main 48585e6 merged in: - `tests/test_family*.py tests/test_validate_family*.py tests/test_stdout_encoding.py tests/test_windows_paths.py tests/test_repo_hygiene.py tests/test_agents_md_codes.py tests/test_cli_reference.py tests/test_park_resume_targets.py tests/test_bootstrap_spelling.py tests/test_free_plan_hint.py tests/test_template_values_single_pass.py`: **1303 passed, 9 skipped**. - `tests/test_shape_doctor.py tests/test_update_shape*.py tests/test_commit_trailers.py tests/test_tracking_branch_ref.py tests/test_scaffold_ignored_shape_files.py tests/test_ruleset_hint_tracking_branch.py tests/test_bump_leg_dry_run_tracking.py tests/test_setup_project_py.py`: **999 passed, 6 skipped**. - The new files alone: `test_family_init_landing.py` 9, `test_family_printed_quoting.py` 69, `test_family_tracking_branch.py` 17, all passed. The full suite was not run locally. CI's three jobs are the check. #505 and #395 have since landed, and both are merged here at fcbc7a2. Each of #505's family sentences was read against this branch's code, and none is false: AGENTS.md 3 and 233; README 569, 822, 1152, 1269 and 1348; the handbook 1126 and 1506. #395 landed with its test switching to `family/members` before its real `add`, as the last bullet below says, and the first run above includes it. #503 then landed as 631f087, and GitHub's update-branch merged it here as 22733ce with no conflict. Main f391e58 (#266, #509, #496 and #435) was then merged by hand as 5a2776d, again with only the footer in conflict: main's clauses stay in main's order, this branch's (#487) moves after #509's (#498), and the README blob is recomputed; `git show --remerge-diff` shows nothing else. #509's reworded sentences in AGENTS.md, README.md and the handbook were read beside this branch's, and none contradicts or repeats another. Its `setup-project.py` changes (the clone-path check, the plan line, the step-(7) backstop and `_main`) and this branch's `shell_word` lines in the hand-over do not meet, and `docs/cli.md` passes `--check`. Main 8cd7dbe (#506 and #347) was then merged by hand as 654df49, again with only the footer in conflict: this branch's (#487) moves after #506's (#462), the README blob is recomputed, and `docs/cli.md`, which both sides changed, still passes `--check`. #506's two `scripts/family.py` hunks (the `FAMILY_RULESET_HINT` import, and its print when the holder's push is refused) sit unchanged inside this branch's code, and that hint prints no path. Under `--reuse-empty-repo`, `init` still refuses its default `--into` inside a checkout of this standard (`family-landing-in-standard`) before it reads the remote, as a dry run with a stub `gh` showed. #506's sentences in AGENTS.md, README.md and the handbook are still true beside this branch's. Main d41cc29 (#402, for #277), which rewrote the doctor's NEXT lines and `tests/test_shape_doctor.py`, was then merged by GitHub's update-branch as e42ef74, with no conflict; the `holder` fixture still switches to `family/members` before its `add`. AGENTS.md stays at 490 lines and README.md at 1422. `git merge-tree --write-tree` of 708f3bb, at 04:47Z on 2026-10-13: - **Clean:** #503 (`fix/family-makefile-without-siblings`) and #395. Each merged tree keeps AGENTS.md at 490 lines and README.md at 1422. - **`docs/handbook.html` footer only:** #505 (`docs/v1-accuracy`) and #491. #468 has landed and is merged here. #506 conflicts there too, and in `scaffold-project.py`, as it does with main. README.md and AGENTS.md merge clean with #505, and `setup-project.py` merges clean with #491. Whichever lands second keeps every footer clause and recomputes the README blob. - **#395 merges clean but one of its tests fails with this branch.** `tests/test_template_text_placeholders.py::test_a_member_whose_id_yaml_would_misread_is_pinned_under_that_id` inits its own holder and runs a real `add` on `main`, which #487 refuses with `family-on-tracking-branch`. Whichever of the two lands second adds `git("switch", "-q", "-c", "family/members", cwd=root)` after that test's `init`; lane 5 is adding it on #395's own branch now, so this branch needs no change for it. (#395's head d526f76 also conflicts with this head in `tests/test_adopt_manifest_values.py`, a file this branch does not touch: that is #395 against main, which the same round resolves.) - On Windows `shell_quoted` speaks PowerShell, the native shell this standard documents (`setup-project.py`), as the doctor's NEXT lines do. `git -C …`, `python scripts\family.py …` and `cd …` are shell-agnostic, so they get the platform's quoting, and no printed line joins two commands with `&&`, which Windows PowerShell 5.1 rejects. - `rm -rf`, `mv` and `mkdir -p` are POSIX commands. They are quoted for a POSIX shell on every host, and the text says "in a POSIX shell (Git Bash on Windows)". PowerShell refuses `rm -rf`'s `-rf` and deletes nothing. - The tests split a host-quoted line with a PowerShell reader on Windows and with `shlex` elsewhere, and split a POSIX-only line with `shlex` everywhere. The real-shell test is skipped on Windows. - On Windows the tests do not execute `rm` or the `mv` lines. They delete the split path with `shutil.rmtree`, and stop after checking the `mv` argv. - Paths: the cached store keeps git's POSIX spelling (`as_posix`), as before. Test paths are `resolve()`d, which expands an 8.3 short name such as `RUNNER~1`. - Nothing here was run on Windows or macOS locally. The `tests-windows` and `tests-macos` CI jobs are the check; on macOS the real-shell test runs the shipped `zsh`. - **A shipped template that imports a newer shared helper can break a holder that kept an older copy.** This change no longer does (`siblings.py` uses `shlex.join`), but nothing stops the next one: `update-shape.py apply --accept-local scripts/repo_shape.py` keeps a `repo_shape.py` that lacks a name a newly copied file imports, and `check` and the validator then read the holder as fine. The general guard is for `apply` to refuse that, as rv456 found for `bootstrap.py` and `spelled` (#456). - **The doctor's `quote_arg` leaves a word that begins with `=` bare**, which zsh expands. `shell_quoted` quotes it; the doctor is left as it is here, and the agreement test excludes that one case. - **The doctor and `update-shape.py` keep their own quoters.** The doctor's `quote_arg` flattens to ASCII by its report's contract, so moving it onto `repo_shape.shell_quoted` is more than an import change. `update-shape.py`'s POSIX `shlex` lines are lane 3's open #374. A test holds `shell_quoted` and `quote_arg` to one answer on every printable ASCII value but a leading `=`. - **`family.py`'s by-hand rollback commands (#365) and its `git config -f .gitmodules` removals (#317, #360) keep `shlex.quote`.** They were already quoted, they are POSIX-only (`printf … | git update-index`), and they are worded for a POSIX shell. - **The holder's `validate-family.py` remedies that name `family.py add`** (`member-gitlink-absent`, `member-gitlink-unnamed`) print no branch step: they are a holder copy, and the `add` they name refuses the tracking branch with its own `switch` remedy. - **`remove`'s store note still computes `.git/modules/<path>`** rather than asking `git rev-parse --git-path`, as `add` does. In a linked worktree it therefore prints no note. That predates this change. - **PowerShell verbs** (`Remove-Item`, `Move-Item`) are not printed for the POSIX-only commands. - **README's `--into` sentence gives the default but not the refusal.** README.md (861) and the handbook (1246) say `--into <dir>` is the PARENT directory, "the directory you are standing in, by default". They do not say that `init` refuses that default inside a checkout of this standard (`family-landing-in-standard`). AGENTS.md item 1 says so, and the README's own example passes `--into ..`. README.md is at its 1422-line cap, so the sentence is on #459's checklist. - **`setup-project.py`'s own `cd <clone>` line and its step-(7) backstop lines print their paths unquoted.** This change quotes only the family lines it prints. Those two predate it and #509, and they are on #459's checklist. Reviewed independently at 10c93de: CHANGES NEEDED (0 blockers, 1 should-fix, 6 nits). The round at bb11b63 fixed the should-fix and all six nits, and its re-verification gave APPROVE WITH NITS (0/0/3), with SonarCloud's quality gate OK; those three are fixed at 3451a56. Main was then merged by GitHub's update-branch (8e1471c), by hand at 708f3bb and at fcbc7a2, where each time only the handbook footer conflicted, and by update-branch again at 22733ce (main 631f087, #503), with no conflict. CI was green there on Linux, macOS and Windows, with SonarCloud passing, but main had moved on: main f391e58 (#266, #509, #496 and #435) was merged by hand at 5a2776d, where again only the footer conflicted. CI was green there too, but main moved on again: main 8cd7dbe (#506 and #347) was merged by hand at 654df49, where once more only the footer conflicted. CI was green there as well, and main d41cc29 (#402) then came in by update-branch at e42ef74, with no conflict. CI is green on Linux and macOS, with SonarCloud passing, at e42ef74, a clean merge of main. All three OSes and SonarCloud passed at 654df49, and under Brett Heap's landing rule of 22:08:06Z (ruling 27) macOS and Windows carry over from that head. Main e6fbd74 (#515, for #514), which landed after it, touches none of its files, and the combined tree passed `tests/test_adopt_pins.py`, `tests/test_shape_doctor.py`, `tests/test_scaffold_leg_path_collisions.py`, the hygiene, AGENTS-code and CLI-reference tests, `tests/test_family_printed_quoting.py` and `tests/test_family_tracking_branch.py` (777 passed, 3 skipped). Closes #488 Closes #486 Closes #487 Lane: openreposhape-5 (openRepoShape-5) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Lane: openreposhape-3 (openRepoShape-3)
Claim: #436 (comment)
What
Brett Heap's ruling on the issue (2026-10-12): refuse by name. Every
--branchrun now compares the pin, the manifest and every pinned copy with HEAD before its first write, and refuses a difference instead of committing beside it.--branchrun calls_refuse_what_head_does_not_commit. That function compares the pin, the kind's manifest and every pinned copy with HEAD by bytes, using update-shape.py: a--prre-run finishes the landing only when the working tree holds what HEAD commits at the pin, the manifest and every pinned copy, and is refused asupdate-rerun-uncommittedotherwise, so an in-placeapply --at Cleft uncommitted on a branch that re-pins B no longer gets B pushed under a pull request titled C (#333) #379's_not_what_head_commits:git hash-objectagainstHEAD:<path>, with the clean filter run and no index flag consulted._awaits_its_pull_requestrecognises, a difference is stillupdate-rerun-uncommitted, word for word. update-shape.py: a--prre-run finishes the landing only when the working tree holds what HEAD commits at the pin, the manifest and every pinned copy, and is refused asupdate-rerun-uncommittedotherwise, so an in-placeapply --at Cleft uncommitted on a branch that re-pins B no longer gets B pushed under a pull request titled C (#333) #379's six cases pass unchanged.--branchrun gets the newupdate-branch-uncommitted. update-shape.py: a--prre-run finishes the landing only when the working tree holds what HEAD commits at the pin, the manifest and every pinned copy, and is refused asupdate-rerun-uncommittedotherwise, so an in-placeapply --at Cleft uncommitted on a branch that re-pins B no longer gets B pushed under a pull request titled C (#333) #379's words describe a re-run (--pr would finish the landing of …,Nothing was written or pushed, and gh was not asked), so they do not fit a run that has not committed yet.ghis not asked and nothing is pushed. AGENTS.md does not name the code, so it is unchanged.--prre-run finishes the landing only when the working tree holds what HEAD commits at the pin, the manifest and every pinned copy, and is refused asupdate-rerun-uncommittedotherwise, so an in-placeapply --at Cleft uncommitted on a branch that re-pins B no longer gets B pushed under a pull request titled C (#333) #379's rule)._not_what_head_commits: four answers that are not differences. Every--branchrun asks it now, not only update-shape.py: a--prre-run finishes the landing only when the working tree holds what HEAD commits at the pin, the manifest and every pinned copy, and is refused asupdate-rerun-uncommittedotherwise, so an in-placeapply --at Cleft uncommitted on a branch that re-pins B no longer gets B pushed under a pull request titled C (#333) #379's re-run, whose rows were always present and never links.update-conflict'scopy-missing, as before.contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347'supdate-rewrite-symlink.update-branch-uncommittedinstead ofupdate-conflict.git hash-objectto read. It reachesclassify'scopy-missingandupdate-conflict, as on main, before anything is written (codex's P2 on e7e80c4, fixed in 1af060e). Any other pair of kinds is stillupdate-branch-uncommitted: a directory over a committed file (staged or not), a file over a committed directory, a directory where HEAD commits nothing.lstated before git is asked to read it, and one of these is never read:git hash-objectopens what it is given, and a FIFO with no writer blocked that open for good, so every--branchrun hung where main refuses. git commits none of them, andclassifyalready calls such a copycopy-missing, soupdate-conflictnames it with main's exit code, stderr and stdout.--branch(codex's P1 on 1af060e, fixed in 32a6fc1; on main too). The comparison holds a committed link to be HEAD's, butclassifyreads the bytes at its far end andRollback.writewrites through it. So afterupdate-conflictandupdate-local-drift, and beforeconfirm,_refuse_writes_through_a_linkwalks the pin, the manifest and every row the run writes or re-pins (every row notunchangedby then) withsymlink_on_the_way, and refuses each link at or above one asupdate-rewrite-symlink, one path a line, before the first write.validate-pins.pysayspins ok.unchangedis not refused: the pin keeps HEAD's row for it, and main's green commit stands.contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347 (update-shape.pyapplyrewrites a pinned copy,contracts/shape-pin.yamlor the manifest THROUGH a symlink the root keeps at that path (Rollback.writeopens itr+b), so the standard's bytes land at the link's end, outside the root if that is where it points, with exit 0, and--branchreports a commit holding a file that commit does not contain #286) gives the same refusal in every mode. update-shape.py: a pinned copy,contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347 refuses earlier (inread_pin,prepare, and beforeupdate-conflict) and wider (every linked row, branchless runs too), so once it lands this check is shadowed; the four new tests assert only the code, the path and the untouched tree, and pass merged with update-shape.py: a pinned copy,contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347.bothunder--branchisupdate-branch-uncommittedbeforeupdate-local-driftorupdate-conflict; once the edit is committed, those refusals follow as before.applyagain.applyover uncommitted edits on purpose (--accept-localover a local edit, a hand-edited pin). Nothing is committed in a branchless run, so the only wrong output was the commit line.apply --add <dir>/<file>where the root holds a plain FILE at<dir>(or a directory it cannot write) dies in aNotADirectoryError(orPermissionError) traceback fromRollback.write_addedafter the pinned copies were written, and nothing puts them back, becausecmd_applyrolls back only onRefusalandCommandFailed#285 (update-shape.py:apply --addrefuses a path under a file the root keeps asupdate-add-not-a-directorybefore it writes anything, and a write that fails after the copies isupdate-write-failed, rolled back, so neither leaves a rewritten copy and an unmoved pin behind a traceback (#285) #346, now on main).update-add-not-a-directoryis still asked first, inresolve_additions, before this comparison; both write nothing. A write that fails after this comparison is stillupdate-write-failed, rolled back. Under--branch, what that rollback puts back is what this comparison found to be HEAD's, so the same command run again, as its remediation says, is not refused by this one.Why
Measured with local bare remotes and a
ghstub that logs its calls and exits 1, withGH_TOKEN=bogusand an emptyGH_CONFIG_DIR. The upstream is a clone at A plus commits B (validate-manifest.py), C (validate-pins.py) and D (Makefile), each changing one copy. "main" is d6df36b; itsupdate-shape.pyis byte-identical to the current base 6c2a371's. "head" is this change on d6df36b (b221f5c); itsupdate-shape.pyis byte-identical to the one on e7e80c4. The same rows were measured earlier on 245d775 and f5cb616 against this change, with the same results. "In place" meansapplywithout--branch, left uncommitted.ghwas called 0 times in every row.apply --at D --branch shape/dcommitted on shape/d: Makefile, contracts/shape-pin.yaml, project.yaml; that commit'svalidate-pins.pyexits 1 (shape-copy-driftonvalidate-pins.pyandvalidate-manifest.py)REFUSED update-branch-uncommitted: --branch shape/d would commit what HEAD (<sha>) commits plus only the paths this run writes, but the working tree does not hold what HEAD commits at contracts/shape-pin.yaml, project.yaml, scripts/validate-pins.py, scripts/validate-manifest.py. … there the pin names <C> and HEAD's names <A> …; no branch made, tree untouchedNEXT git -C <root> checkout -b shape/update-<D> && git -C <root> commit -m … -- Makefile contracts/shape-pin.yaml project.yaml; pasted, it exits 0 and that commit'svalidate-pins.pyexits 1NEXT no commit line: the working tree does not hold what HEAD commits at scripts/validate-pins.py, scripts/validate-manifest.py, paths this run did not write and whose bytes the pin it wrote records, so a commit of Makefile, contracts/shape-pin.yaml, project.yaml alone would record digests for bytes it does not carry. …shape/updatere-pins B, in place C, thenapply --at B --branch shape/update, with and without--push --prREFUSED committing the re-synced shape on shape/update…nothing to commit, working tree clean…ROLLED BACKREFUSED update-branch-uncommitted: … at contracts/shape-pin.yaml, project.yaml, scripts/validate-pins.py … there the pin names <C> and HEAD's names <B> …apply --at C --branch shape/c, with and without--push --prnothing to do: every copied file matches … @ <C>, which the pin already names; noshape/cREFUSED update-branch-uncommitted: … at contracts/shape-pin.yaml, project.yaml, scripts/validate-pins.py, scripts/validate-manifest.py …scripts/bootstrap.py,apply --at D --accept-local scripts/bootstrap.py --branch shape/dbootstrap.py; itsvalidate-pins.pyexits 1 (shape-copy-drift: scripts/bootstrap.py)REFUSED update-branch-uncommitted: … at scripts/bootstrap.py.validate-pins.pyexits 1NEXT no commit line: … at scripts/bootstrap.py, …project.yamledit,apply --at D --branch shape/dREFUSED update-branch-uncommitted: … at project.yaml.--branchupdate-conflict(pinned but absent from the root)update-branch-uncommitted … at scripts/bootstrap.py--branch shape/d; in place;--branchon the current branch--branch shape/d--branchupdate-conflictnothing to commitThe issue's description holds on current main, as drafted. The
--accept-localand manifest rows were found while re-measuring. They have the same root cause and the same answer.Codex round 2 (on 1af060e): measured on main 03dc729, 1af060e and 32a6fc1
Same harness (local bare remotes, a
ghstub that logs and exits 64,GH_TOKEN=bogus, an emptyGH_CONFIG_DIR, a scratch git config), each run under a 20 s timeout. Upstream B changesvalidate-manifest.py; D changesscripts/bootstrap.py. "Clean clone" isgit clone --recurse-submodules -b <branch>of the root, then its ownscripts/validate-pins.py.ghwas called 0 times in every row. "= main" means exit code, stderr and stdout equal to main's after normalising paths and shas.apply … --branch)--at Bpins okscripts/bootstrap.pyupdate-conflict(pinned but absent from the root)--push --prupdate-conflictupdate-conflictscripts/bootstrap.pyupdate-conflictupdate-branch-uncommitted … at scripts/bootstrap.pyMakefileeditupdate-conflictupdate-branch-uncommitted … at Makefile.(the order note above)--branchupdate-conflictcontracts/shape-pin.yamlupdate-pin-missingproject.yamlbootstrap.pya committed link,--at D(upstream rewrites it)validate-manifest.py,bootstrap-real.pyleftM; clean clone exit 1FINDING shape-copy-drift: scripts/bootstrap.pyREFUSED update-rewrite-symlink: … scripts/bootstrap.py: scripts/bootstrap.py is a symlink, pointing at 'bootstrap-real.py', tree untouched--accept-local scripts/bootstrap.pyshape-copy-drift: scripts/bootstrap.pyupdate-rewrite-symlinkupdate-local-driftpins okupdate-rewrite-symlink(see Left out; the remedy lands it)bootstrap.pya committed link to a file outside the root,--at Dupdate-rewrite-symlinkscriptsa committed directory link,--at Bpathspec 'scripts/validate-manifest.py' did not match any file(s) known to git,ROLLED BACKupdate-rewrite-symlink … scripts/validate-manifest.py: scripts is a symlink above it, before writingcontracts/shape-pin.yamla committed linkshape-pin-manifest-disagreeupdate-rewrite-symlinkproject.yamla committed linkshape-pin-manifest-disagreeupdate-rewrite-symlinkbootstrap.pya committed link, left unchanged,--at Bpins ok--branchDoes #347 stop the P1 inputs first? Only where it is merged. With 1af060e and #347's head 978ca3e merged (
merge-treeCLEAN), every linked row above is refusedupdate-rewrite-symlinkbefore any write, inread_pin/preparefor the pin and the manifest and in_refuse_linked_copiesfor a copy. But #347 is open, and main and 1af060e give the rows above. The FIFO hang is the same with #347 merged.Tests
On head 32a6fc1 (three commits on 6c2a371: e7e80c4, 1af060e, 32a6fc1):
tests/test_update_shape.py,test_update_shape_landing.py,test_update_shape_pr_base.py,test_pin_rewrite_layout.py,test_update_shape_add.py,test_update_shape_add_ignored.py,test_update_shape_add_symlink.py,test_update_shape_add_not_a_directory.py,test_validator_child_encoding.py: 447 passed, 3 skippedtests/test_family.py -k update_shape: 4 passed, 95 deselectedtest_repo_hygiene.py,test_cli_reference.py,test_agents_md_codes.py,test_git_output_decoding.py,test_stdout_encoding.py: 233 passed, 1 skippedjunctions are NTFS's) and the Windows-default stdout test. None is new.contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347's head 978ca3e:test_update_shape_landing.py,test_update_shape_rewrite_symlink.py,test_update_shape_add_symlink.py: 141 passed, 3 skipped.There are 33 new tests in
tests/test_update_shape_landing.py(17 on e7e80c4, 6 in 1af060e, 10 in 32a6fc1). Each runs the update as a child with that file's Pythonghstub (#334):test_a_first_branch_run_over_a_tree_head_does_not_commit_is_refused, 6 cases × {--branch,--push --pr}: moves-on (a), moves-back (b), stays (c), accepted-edit, manifest-edit, copy-deleted. Each asserts the exact refusal prefix, both pins where they differ, empty stdout, noghcall, no push, no new branch, and HEAD, branch andgit statusunchanged.test_an_in_place_run_names_what_its_commit_line_would_leave_out, 2 cases (a′, and an accepted edit in place): asserts the exact NEXT line.test_a_copy_replaced_by_a_directory_and_committed_is_still_a_conflict(tree, gitlink) andtest_a_type_change_head_does_not_commit_is_still_refused(4 kind pairs), from 1af060e.test_a_copy_replaced_by_what_is_not_a_file_is_not_read, {FIFO, FIFO where HEAD commits nothing, socket} × {--branch,--push --pr}: main'supdate-conflict, empty stdout, nothing written, no branch,ghnot asked. The child runs under a 120 s limit (apply_within; the suite has no pytest-timeout), and after a kill the FIFO is opened for writing once, so nogitis left blocked behind the test.test_a_branch_run_that_would_write_through_a_link_is_refused, {a copy B rewrites, an accepted edit at a link's end, the pin, the manifest}, each with--push --pr: theupdate-rewrite-symlinkcode and the path, empty stdout, the link's far end untouched, no branch, nothing pushed,ghnot asked.…reads_no_readme_and_no_untracked_dirt,…copy_deleted_and_committed_is_still_a_conflict,…copy_kept_as_a_committed_link_is_what_head_commits(it asserts only what holds with or without update-shape.py: a pinned copy,contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347).They bite.
update-shape.pyis 6c2a371's), the e7e80c4 file: 14 failed, 3 passed (the fix tests fail for the issue's reasons; the 3 guards pass). The same split held on ec8e09a, f5cb616 and 245d775.Failed: apply was still running after 120s, the 2 socket cases onupdate-branch-uncommitted, the 4 link cases on exit 0); on main 03dc729, 4 failed, 6 passed (the link cases fail; the FIFO and socket cases pass, since the hang was this PR's own).update-shape.py, each over the 11 FIFO, socket and link tests:hash-object): 6 failed (4 at the 120 s limit);unchangedrows refused too: 0 failed. That boundary is measured (the probe's unchanged-link row), not pinned by a test: update-shape.py: a pinned copy,contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347 refuses that input in every mode, so a test pinning the commit would break whichever of the two lands second.--branchcomparison, no NEXT check, update-shape.py: a--prre-run finishes the landing only when the working tree holds what HEAD commits at the pin, the manifest and every pinned copy, and is refused asupdate-rerun-uncommittedotherwise, so an in-placeapply --at Cleft uncommitted on a branch that re-pins B no longer gets B pushed under a pull request titled C (#333) #379's words dropped, and the four directory-rule mutants, each failing its own tests (see the reviews).The link tests are skipped on Windows (Git for Windows checks a committed symlink out as a plain file unless
core.symlinksis on, and making one needs a privilege the runners do not grant). The FIFO and socket test is skipped on Windows too:os.mkfifois POSIX only. Every other new test runs on all three operating systems.Composes with
git merge-tree --write-treeof 32a6fc1 withorigin/main(f31a95a, which touches neitherupdate-shape.pynortests/test_update_shape*) and with every open sibling whose diff touchesupdate-shape.pyortests/test_update_shape*:origin/main(f31a95a)fix/update-shape-pinned-copy-symlink(978ca3e)fix/update-shape-next-quoting(4b573e6)fix/docs-validate-pins-gh-fallback(81a2988)fix/trailer-non-ascii-old-git(d079893)fix/family-makefile-without-siblings(8643774)fix/update-shape-pr-rerun-pin-sourceconflicts, but it is #379's branch, which landed as 87d2eb7 and is the base of this change.#346's write-failure rollback was probed under
--branchon d6df36b and on e7e80c4's change, with identical output (REFUSED update-write-failed: … Permission denied, rolled back, no branch; the same command lands once the pin is writable).Left out
apply --branchjudges the pin, the manifest and the copies from the working tree but commits HEAD plus only the paths it wrote, so over an uncommitted in-placeapplyit exits 0 with a commit whose ownvalidate-pins.pyis red, dies on git's "nothing to commit", or says "nothing to do" and makes no branch #436.applyrewrites a pinned copy,contracts/shape-pin.yamlor the manifest THROUGH a symlink the root keeps at that path (Rollback.writeopens itr+b), so the standard's bytes land at the link's end, outside the root if that is where it points, with exit 0, and--branchreports a commit holding a file that commit does not contain #286's, and update-shape.py: a pinned copy,contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347 refuses it in every mode.--branchtoo, where main's commit was green. The remedy lands it, and update-shape.py: a pinned copy,contracts/shape-pin.yamlor the manifest kept as a symlink, or under one, is refused asupdate-rewrite-symlinkbefore anything is written, andcheckcalls such a copycopy-is-link, soapplyno longer writes the standard's bytes at the link's end and reports a commit that does not hold them (#286) #347 refuses the same input; comparing the resolved bytes instead would need link resolution inside and outside the root, and still could not save a copy written through the link.applyin every mode on main, inRollback.write, after the copies and the pin are written (no rollback on Ctrl-C). Under--branchthe run now reaches that point as main does, where 1af060e hung earlier in the comparison. A checklist item for the update-shape area's Tracking parent, not this PR.Closes #436
🤖 Generated with Claude Code
Summary by Sourcery
Refuse branch-based shape updates when the working tree does not match HEAD for any bytes the run would rely on, and prevent follow-up commits from omitting recorded pinned content.
New Features:
Bug Fixes:
Enhancements:
Documentation:
Tests: