[brettheap]

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

#884's three lines, from rv876's NIT 2, NIT 3 and NIT 4 on #876 (#876 issuecomment-6246717354), with fix round 1 from rv884's review of this pull request (issuecomment-6248806027). The change is in the family holder's pinned templates/family-root/scripts/bootstrap.py and in tests/test_family_holder_bootstrap_texts.py, and nothing else.

Base: origin/main 281df263, where #876 has landed as 41baf920. Each line was probed there first, under the holder's own make bootstrap, with GNU Make 4.3, dash 0.5.12 as /bin/sh and git 2.43.0. The probes reuse rv876's p2/ptyrun.py and its member Makefiles.

1. Five mutants of #876's code survived its tests, and one docstring claimed what no test checked. Tests only; no code changes for this line.

• R10 and R11 (credential_advice ignoring unreadable or refused): test_no_advice_beside_no_member_updated_with_every_member_checked_out. Every member is checked out, as in the holder itself, and HEAD's .gitmodules is given update = None or a conflict marker. Bootstrap's own stderr lines after the fetch line are asserted exactly: the "NO MEMBER UPDATED, and not for want of a credential" line and the failure, with no advice between them. tests/test_family_gitmodules_values.py asks only the last two lines, which is why the mutants passed there.
• R1 (named[0]) and R8 (the regex anchored on ^make: ): test_the_line_names_the_code_of_the_member_s_innermost_command[last-under-make]. bootstrap.py --no-fetch runs under a real parent make -k, as the holder's make bootstrap runs it, so the member's make prints make[1]:. One member exits 1. Another has two commands that exit 1 and then 2, and the line must name the last.
• R7 (passed_on's sink.flush() dropped): test_a_member_s_question_shows_before_its_answer_is_typed. Bootstrap runs on a pseudo-terminal (its stdin, stdout and stderr). A member recipe asks Continue? on stderr and reads the answer. The test types yes only once the question has shown, and fails if it has not shown within 10 s. It asserts the output before the answer and after it exactly. Measured on the pty: the question showed at 0.13 s at head; with R7 on 281df263 it showed only at 8.1 s, after the blind answer, when the run ended.
• The store: test_a_git_mv_staged_with_work_in_the_checkout_is_undone_as_printed now asserts what its docstring said. After every line is typed, the checkout's commit (the new commit, or the pin where only an untracked file was added) is still in .git/modules/members/IRRS. A helper, kept, is shared with test_a_checkout_moved_on_at_the_variant_is_moved_with_f's own store assert.
• On 281df263, with rv876's own mut/mutants.py unchanged, every one of the five is caught by the test named above, and those tests pass on the unmutated code:

rv876's mutant on 281df263	caught by
R1 named[0]	[last-under-make]
R7 no sink.flush()	test_a_member_s_question_shows_before_its_answer_is_typed
R8 ^make:	[last-under-make]
R10 advice ignores unreadable	test_no_advice_beside_no_member_updated_with_every_member_checked_out[unparsed]
R11 advice ignores refused	test_no_advice_beside_no_member_updated_with_every_member_checked_out[value-refused]

2. The final line misled in three cases (run_make, MakeErrors).

• Measured on 281df263 and on this head, each member under the holder's make bootstrap and with bootstrap.py run straight (-k where the case needs it). The last five rows came from rv884's review:

member	281df263	head
$(MAKE) inner, inner command exits 1	exited 2	exited 1
$(MAKE) inner, inner command exits 2	exited 2	exited 2
$(MAKE) nothere, the inner make's own failure	exited 2	make printed no Error <code> line for a command of the member's
$(MAKE) -s nothere; exit 3	exited 3	exited 3
make -k: Error 1, then 5000 bytes on stderr	make printed no Error <code> line (false)	exited 1
make -k: two commands exit 1, then 3	exited 3	exited 3
a command killed by SIGKILL under dash	exited 137	exited 137
kill -TERM $$ in a recipe	make printed no Error <code> line	the same
$(MAKE) -s nothere || exit 1	exited 1	exited 1
$(MAKE) -k inner, whose second target prints after the inner Error 1	exited 2	exited 1
make -k: a finding, then a command that kill -KILL $$ ends	exited 1	exited 1
-$(MAKE) inner (inner exits 1), then the recipe's own exit 2	exited 2	exited 2 (82a84f88 read exited 1)
printf 'x: *** y' >&2; exit 1, so make's line follows it on one line	exited 1	exited 1 (82a84f88 named none)

• A recursing member: the line names the innermost command's code. Why: the inner make exits 2 for any failure, which is the very code the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839 set out to see past. The command the member's author wrote, and whose code tells a finding (1) from a refusal (2), is the innermost one.
  • The depth comes from make's own prefix (make[N]:, or make: for 0).
  • An Error 2 at a shallower depth than the last *** line before it, whatever lines come between, is taken for that make's parent reporting it, and is passed over.
  • Where the inner make failed on its own (No rule to make target), no command's code is named, and the line is the one for make's own failure.
  • A command that runs a failing make and then fails itself, with 3 or with 1, is still named.
  • Two failures at the same depth under -k name the last, as before.
  • Where a - let the inner make fail, make prints [Makefile:N: bootstrap] Error 2 (ignored), with no ***. That line now puts the depth back at the parent's, so the parent's own Error 2 after it is named. rv884 offered this as an option, to adopt only if it changed no other case. Measured: across rv884's 133 case runs (its tools/cases1.py to cases6.py, at both depths), head with it differs from 82a84f88 only in that case and in the last-match case below. Across 21 more of mine it differs only in that case, in -$(MAKE) nothere then exit 2, and in the last-match case, each now as 281df263 read it. An inner make that ignores a failure of its own prints the same kind of line at its own, deeper depth; that line changes nothing (measured: $(MAKE) inner; exit 2, where inner ignores an exit 2, reads exited 2).
• The last match on a line (rv884's NIT 1). A member's own text with no newline, x: *** y, followed by make's Error 1 on the same line, named no code at 82a84f88. said now takes the last match on a line (findall), and that case reads exited 1, as 281df263 read it.
• Where the line is not the innermost command's code. This is now written in MakeErrors' docstring, not only in this body (rv884's NIT 2):
  • a recipe that runs a make, lets its failure pass in the shell (|| true, or ;), or with a - in a make run with -s (which prints no (ignored) line), and then exits 2 itself: that Error 2 is read as the inner make's report, and the inner command's code is named. Measured: $(MAKE) inner || true; ...; exit 2 and -$(MAKE) inner under the holder's make -s read exited 1; 281df263 read exited 2;
  • an inner make run with env -u MAKELEVEL, which prints its parent's depth: the parent's Error 2 is named, as on 281df263;
  • under -j, a job of the parent's that fails while the inner make is still running: its line comes between, and the parent's Error 2 is named, as on 281df263;
  • a member's own line shaped like a deeper make's (x[3]: *** y) before it exits 2 itself: its Error 2 is passed over.
  • The module docstring's (b) now says the code is the innermost command's "as far as make's lines tell it".
• More than 4 KiB after the Error line: run_make kept the last 4096 bytes of make's stderr and read that tail at the end. MakeErrors now reads each line as it passes. It keeps only the last 4096 bytes of a line that no newline has ended yet, so memory stays bounded for a progress meter that writes only \r. rv884's tools/chunks.py, pointed at this head, fed 174 captured streams to MakeErrors in 81,406 chunkings; none read differently from the whole.
• A signal: the docstring is now true of rv884's 24 cases (probe2.log: dash 0.5.12 and bash 5.2.21; a command run with no shell, one command, kill $$, a command then echo, a command then exit $?, echo then a command; SIGKILL and SIGTERM; at both depths).
  • Where the signal kills what make started, make prints its name, Killed or Terminated, and names no code. That is: a command make runs with no shell; the shell a kill -KILL $$ kills; or a command bash runs in its own place, which is a line's last command, a line of one command included.
  • Where the shell outlives the command, the shell prints the signal's name itself, Killed or Terminated, and exits 137 or 143, which make names. dash outlives every command; bash outlives one that is not a line's last.
  • Where the line goes on after the command, the shell exits as the rest of the line does: ; echo after ends the recipe with 0.
  • The line itself was not changed for a signal. The signal's name is printed right above make's Error 137, and a command may also exit 137 by itself.
• Tests: test_the_line_names_the_code_of_the_member_s_innermost_command, with four sets:
  • [innermost-under-make] and [innermost] run INNERMOST's 11 members, once under a parent make and once with the member's make at depth 0. They are the first five rows of the table, the last five, and an inner make that ignores an exit 2 of its own, then exit 2 (InnerLets, run without -s, which would keep make from saying so);
  • [last-under-make] is line 1's R1 and R8 test;
  • [signal] runs one of each signal case in a form that does not hang on which shell /bin/sh is: sh -c 'kill -KILL $$'; exit $?, which the shell outlives (137), and kill -KILL $$, which kills the shell (no code).
  • Each set asserts the run's final line exactly. Under the parent make, a premise checks that no member line reads make:.
• test_a_line_that_comes_in_pieces_is_read_whole (the pieces test) feeds MakeErrors an Error line cut in two, and a line ended by no newline, which stays at LINE_KEPT bytes.
• The existing test_a_finding_a_refusal_and_make_s_own_failure_are_told_apart (depth 0, no -k) passes unchanged. It now shares with_members and its line helpers with the new tests.

3. What passing make's stderr on changes. I chose to document it in run_make's docstring, after measuring both ways.

effect	281df263 and head (documented)	reading only until make exits (prototype, not committed)
test -t 2 in the member	false: the pipe	false
stdout and stderr order	out of order on the pty: one run printed err 1 after out 4, another all six out lines first	the same
recipe sleep 6 &	6.14 s	0.29 s
( sleep 1; echo late >&2 ) &	1.12 s, late shown	late lost, and the writer died at that write: its status file was never written
non-UTF-8 bytes (caf and 0xE9)	passed on as written	the same

• The background holder. Stopping once make has exited and nothing is waiting fixes only the hold, and only by closing the pipe. The left-running process's next stderr write then meets a closed pipe and dies of SIGPIPE, silently. Holding the run is visible, ends when the process lets go of stderr, and the recipe can give the process its own stderr (2>log), as the docstring says.
• The terminal. Giving make the terminal back would lose its Error <code> line. Measured: make --debug=j prints only "Reaping losing child" on stdout, with no code, and no other output make writes carries the code. That would reopen line 2 of the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839, which this change keeps closed: make still runs.
• The line order and the Windows decoding cannot be fixed by the reader. The docstring says each, with the Windows case read and not run.
• Tests that hold the docstring:
  • test_what_a_member_s_make_leaves_on_stderr_is_passed_on_as_written (the leaves test) asserts bootstrap's stderr bytes exactly: the non-UTF-8 line as written, then late, before the run ends;
  • the pty test asserts stderr: no terminal and stdout: a terminal from the member.

Pinned copy and docs.

• bootstrap.py is in FAMILY_COPIED_VERBATIM, so each holder takes one upstream-changed row for it on its next update. Its mode stays 100755.
• Its imports from repo_shape are unchanged, so the skew rule (tests/test_pinned_copy_text.py) and tests/test_update_shape_kept_helper.py hold.
• No --help text changed, so docs/cli.md is unchanged.
• No sentence of AGENTS.md, templates/family-root/AGENTS-shape.md, templates/family-root/README.md or README.md speaks of the make line or of stderr (grep).

Fail on base. The test file at this head, run on 281df263's code: 3 failed, 54 passed. On 82a84f88's code (this pull request before fix round 1): 2 failed, 55 passed.

• On 281df263, the 3 failures are the tests that pin line 2's change: [innermost-under-make], [innermost] and test_a_line_that_comes_in_pieces_is_read_whole. On 82a84f88, the 2 failures are both [innermost*].
• These pass on 281df263 by design:
  • the pure mutant-killers [last-under-make] (R1, R8), the pty test (R7) and both test_no_advice_beside_no_member_updated_with_every_member_checked_out cases (R10, R11);
  • the tests that hold a docstring: [signal], test_what_a_member_s_make_leaves_on_stderr_is_passed_on_as_written, and the store assert in both test_a_git_mv_staged_with_work_in_the_checkout_is_undone_as_printed cases.
• Each INNERMOST member, run straight with -k (depth 0):

member	expected	281df263	82a84f88	head
Recurse	1	2	1	1
RecurseRefuse	2	2	2	2
InnerOwn	none named	2	none named	none named
InnerThenOwn	3	3	3	3
InnerThenFinding (X12)	1	1	1	1
Long	1	none named	1	1
KeepsGoing (X11)	1	2	1	1
ThenKilled (X7)	1	1	1	1
LetFail	2	2	1	2
InnerLets	2	2	2	2
OwnStars	1	1	none named	1

• rv884's own X7, X11 and X12, its saved copies of 82a84f88 with each mutant, read their member wrong: ThenKilled says none, KeepsGoing says 2 and InnerThenFinding says none.

Mutants at this head, each run against the whole test file: 36 made, 33 caught. The 3 survivors are the equivalents rv884 named: X5 (\s*$ dropped; make's *** lines carry nothing after the code), X6 (the unended remainder read at EOF; make always ends its line) and X9 (passed over only one level deeper; makes nest one level at a time).

mutant	caught by
R1, first Error line kept	[last-under-make], both [innermost*]
R7, no sink.flush()	the pty test
R8, regex anchored on ^make()?:	[last-under-make], both [innermost*], the pieces test
R10, R11	the matching test_no_advice_beside_no_member_updated_with_every_member_checked_out case
H1 nothing passed over; H2 any code passed over; H4 depth never read; H6 depth not kept; H8 a *** line with no code not read; H9 the 4096-byte tail again	both [innermost*]
H3, <= for < in the depth test	[last-under-make], both [innermost*]
H5, make: read as depth 9	[innermost]
H7, depth starting at 99	both told_apart cases, both [innermost*]
H10 an unended line dropped; H11 kept whole	the pieces test
H12, only a chunk's last line read	[last-under-make]
D1 reading stopped once make exits; D2 the bytes decoded as UTF-8	the leaves test
rv884's X1 (!=), X2 (depth only on coded lines), X4 (depth group dropped), X7, X11, X12	both [innermost*] (X1 also both told_apart cases)
rv884's X3 ([:LINE_KEPT])	the pieces test
rv884's X8 (splitlines)	7 tests
rv884's X10 (one-digit code)	[signal]
N1, the first match on a line	both [innermost*] (OwnStars)
N2, the (ignored) line not read	both [innermost*] (LetFail)
N3, the (ignored) line always sets the depth; N5, it falls through	both [innermost*] (InnerLets)
N4, max for min	both [innermost*] (LetFail, InnerLets)

Runs, each through run9s.sh with SHARDS=3 at this head, with no tracked changes. The files: tests/test_family_holder_bootstrap_texts.py, tests/test_family_bootstrap_gate_order.py, tests/test_bootstrap_spelling.py and tests/test_pinned_copy_text.py; the two that git grep -l 'family-root/scripts/bootstrap' -- tests names, tests/test_family.py and tests/test_update_shape_kept_helper.py; the trio, tests/test_repo_hygiene.py, tests/test_agents_md_codes.py and tests/test_cli_reference.py; and five more that run the holder's bootstrap: tests/test_family_gitmodules_values.py, tests/test_family_head_lost_gitmodules.py, tests/test_family_members_not_a_list.py, tests/test_bootstrap_without_git.py and tests/test_family_makefile_siblings.py.

• git 2.43.0: 1049 passed, rc 0 (shards 218, 394 and 437), at dbd3a6dd.
• git 2.47.1: 1049 passed, rc 0 (shards 218, 394 and 437), at dbd3a6dd.

Merge checks, git merge-tree --write-tree of this head, after a fresh fetch:

against	result
origin/main 71f36fe0, where lane 3's #877 has landed as c9ca9a45, editing other parts of bootstrap.py	clean, tree 8b5826db
origin/main 201c6f09, after #865, #871 and #815 too	clean, tree 8c3d8e13; on a commit at that tree, this test file, tests/test_family_gitmodules_values.py and tests/test_pinned_copy_text.py gave 291 passed, rc 0 (git 2.43, rv884's re-check, #886 issuecomment-6249507909)
#877's head 35b214b2	clean, tree b80a2ba0

Sonar-style checks.

• No duplicated block: no 10-line window that touches an added line appears anywhere else in tests/, scripts/ or templates/. At 6 lines, only the import block matches another file.
• No assert joins conditions with and. The one or assert in the file is the family root's bootstrap.py and validate-family.py: the credential advice and a member's exit code say what happened, and the gate's git rm --cached, guarded mv and section lines type as printed where they failed (#839) #876's.
• Cognitive complexity, counted by hand with Sonar's rules: no changed function is over 15, so no def line had to stay as it was. said counts each boolean sequence: depth_said or 0, code == b"2" and ..., and code and not ....

function	281df263	82a84f88	head
run_make	2	1	1
MakeErrors.read	new	1	1
MakeErrors.said	new	5	6
read_until (test)	new	9	9
made, with_members (test)	new	2, 1	2, 1
test_the_line_names_the_code_of_the_member_s_innermost_command	new	4	4
test_a_finding_a_refusal_and_make_s_own_failure_are_told_apart	3	2	2
test_a_git_mv_staged_with_work_in_the_checkout_is_undone_as_printed	3	3	3

Not here.

• No Windows or macOS run, since CI is Linux only (ci: run the test suite on Linux only #597). The Windows decoding is read, not run.
• Make before 4.0 was not run. The prefix and the Error line keep make 3.81's form by its source, but the line-2 test already asserts make 4's quoting.
• The innermost rule's limits are in MakeErrors' docstring and listed under line 2 above. A make that speaks another language still gets the line for make's own failure.

Closes #884

🤖 Generated with Claude Code

Summary by Sourcery

Improve family bootstrap failure reporting by reading make output line by line and identifying the innermost command responsible for failures.

Bug Fixes:

• Correctly identify the innermost member command's exit code when GNU Make invokes nested makes.
• Preserve make -k error codes even when additional stderr exceeds the previous buffer limit.

Enhancements:

• Process make stderr incrementally while preserving output bytes and supporting bounded handling of incomplete lines.
• Document and test stderr forwarding, signal behavior, nested-make reporting, terminal interaction, and background writers.
• Expand bootstrap regression coverage for surviving mutants, member prompts, and Git store preservation.

Tests:

• Add comprehensive bootstrap tests for nested make failures, make -k, signals, partial stderr lines, prompts, forwarded output, and credential-advice edge cases.

[brettheap]

(lane openRepoShape-5, 2026-10-18T09:59Z) @codex review

[chatgpt-codex-connector]

Codex Review Summary

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

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-18T10:02:59.123795Z	82a84f8	Manual request

ℹ️ About Codex in GitHub

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

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

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

[sourcery-ai]

Reviewer's Guide

Updates the pinned family-root bootstrap implementation to parse GNU Make stderr incrementally and depth-aware, so nested and -k failures report the correct command exit code while preserving stderr streaming semantics; comprehensive tests cover diagnostics, PTY interaction, byte fidelity, background writers, and related bootstrap regressions.

Sequence diagram for streaming make stderr and reporting the innermost failure

sequenceDiagram
    participant Bootstrap
    participant Make
    participant MakeErrors
    participant Terminal

    Bootstrap->>Make: run_make(make, target, cwd)
    Make-->>Bootstrap: stderr chunk
    Bootstrap->>Terminal: passed_on(chunk)
    Bootstrap->>MakeErrors: read(chunk)
    MakeErrors->>MakeErrors: said(line)
    alt nested make reports parent Error 2
        MakeErrors->>MakeErrors: pass over shallower depth Error 2
    else command Error line
        MakeErrors->>MakeErrors: store innermost exit code
    end
    Make-->>Bootstrap: process exit
    Bootstrap-->>Bootstrap: return make exit code and stored command code

Loading

Flow diagram for depth-aware GNU Make error parsing

flowchart TD
    A[Read stderr chunk] --> B[Pass chunk through unchanged]
    B --> C[Split completed lines]
    C --> D[Match make depth and Error code]
    D --> E{Deeper make's parent Error 2?}
    E -->|Yes| F[Ignore propagated Error 2]
    E -->|No| G[Store command exit code]
    F --> H[Keep reading]
    G --> H
    H --> I{Unended line?}
    I -->|Yes| J[Retain last 4096 bytes]
    I -->|No| K[Wait for next chunk]
    J --> K

Loading

File-Level Changes

Change	Details	Files
Reworked make stderr parsing to stream complete lines, preserve bounded partial-line state, and identify the innermost command’s exit code across nested makes.	Added depth-aware parsing that ignores parent make Error 2 reports when they merely propagate a deeper failure. Handles nested make failures, make -k output beyond 4 KiB, make-owned failures, and signal termination without losing the relevant code. Expanded run_make documentation to describe stderr piping, ordering, terminal behavior, inherited background writers, byte preservation, and signal semantics.	templates/family-root/scripts/bootstrap.py
Expanded regression coverage for make diagnostics, stderr streaming behavior, and previously untested bootstrap guarantees.	Added tests for nested make diagnostics, make -k, signal cases, split and unterminated stderr lines, parent-make prefixes, and exact final failure messages. Added pseudo-terminal coverage proving prompts are flushed before input and member stderr is piped while stdout remains terminal-bound. Added coverage for preserving non-UTF-8 stderr bytes and output from background processes that retain the pipe. Added tests catching credential-advice mutants when all members are checked out.	tests/test_family_holder_bootstrap_texts.py
Strengthened and refactored existing test helpers and Git store assertions without changing production behavior.	Shared member setup, script loading, and Git object-retention helpers across tests. Asserted that the checkout commit remains present in the member Git store after the guarded move scenario.	tests/test_family_holder_bootstrap_texts.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#884	Add regression tests that catch the surviving #876 mutants, including the prompt-flush, parent-make parsing, advice, and last-Error-line cases, and assert the member-store state claimed by the existing docstring.	✅
#884	Make the reported member make result truthful for recursive makes and Error lines followed by more than 4 KiB of stderr, and make the signal behavior described by run_make's docstring accurate.	✅
#884	Document the observable effects of piping make's stderr, including terminal detection, output ordering, background-child pipe lifetime, and Windows byte decoding, with tests for the relevant behavior.	✅

Possibly linked issues

• #unknown: The PR extends make-error parsing to report the innermost command’s code, directly addressing the issue’s member finding-versus-refusal concern.
• the family root's bootstrap.py: run_make's final line is false in three cases, piping make's stderr loses the terminal, the line order and a background child's exit, and five mutants of #876's code survive its tests #884: The PR implements issue the family root's bootstrap.py: run_make's final line is false in three cases, piping make's stderr loses the terminal, the line order and a background child's exit, and five mutants of #876's code survive its tests #884’s requested regression tests, line-by-line error tracking, innermost-command reporting, and stderr-effects documentation.

---

Tips and commands

Interacting with Sourcery

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

Customizing Your Experience

Access your dashboard to:

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

Getting Help

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

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 82a84f88b6

ℹ️ About Codex in GitHub

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

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

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

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

[chatgpt-codex-connector]

Do not discard Error 2 after a handled submake failure

When a member recipe handles a recursive failure (for example, $(MAKE) -s inner || true) and a later command genuinely exits 2, the inner error raises self.depth but produces no parent Error 2 because the shell handled it. The later top-level Error 2 then has a lower depth and is discarded here, leaving the stale inner code (such as 1), so the family summary mislabels an actual member refusal as a finding. Suppression needs to be tied to an unhandled submake failure rather than any previously observed deeper error.

Useful? React with 👍 / 👎.

[brettheap]

Independent review of #886 (#884) at 82a84f88, for lane openRepoShape-5: READY

I found no MUST: at head the code gives the right answer in every normal case I measured. There is one SHOULD, which is three more test members and no code. I changed no branch, pushed nothing and posted nothing. $Q = /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad. My logs, probes and tools are in $Q/v118/rv884/.

Findings, most severe first

SHOULD 1 (tests only): three of my mutants of #884's new code survive all 57 tests, and a person would see each of them. The body says "19 made, 19 caught, no survivor". That is true of w884's 19, but these three are not in them. Logs: $Q/v118/rv884/mut/summary.txt. I confirmed each one is visible with a patched copy of head (probe5.log, probe6.log).

• X7, a *** line with no code clears the last code (bootstrap.py:926-927 changed to if not reports_a_make: self.code = int(code) if code else None).
  • Run straight with MAKEFLAGS=-j2, make prints make: *** Waiting for unfinished jobs.... after Error 1.
  • Under -k, a finding followed by a kill -KILL $$ gives the same kind of codeless line.
  • In both cases the mutant's line says "printed no Error <code> line", which is the family root's bootstrap.py and validate-family.py: the credential advice prints beside "not for want of a credential", a member's refusal and finding both read make bootstrap exited 2, and the wrong-case move's git rm --cached may refuse #839's symptom back again. Head says exited 1.
• X11, any line that is not a *** line resets the depth (:921-922).
  • Case 1: a member runs $(MAKE) -j2 inner, and the other inner job writes y done after the inner make's Waiting line.
  • Case 2: a member runs $(MAKE) -k inner, and a later target prints to stderr.
  • In both cases the mutant reads exited 2, which is the family root's bootstrap.py: run_make's final line is false in three cases, piping make's stderr loses the terminal, the line order and a background child's exit, and five mutants of #876's code survive its tests #884's own symptom. Head says exited 1.
• X12, an Error 1 is passed over as well as Error 2 (code in (b"1", b"2")). With $(MAKE) -s nothere || { echo ... >&2; exit 1; }, the mutant names no code. Head says exited 1.
• Why the tests miss them: no test runs a member under -j, puts stderr lines between a sub-make's Error line and its parent's, or has a recipe exit 1 after a failed sub-make. The only such recipe, InnerThenOwn, exits 3.
• The fix, three entries in INNERMOST (tests/test_family_holder_bootstrap_texts.py:448):
  • a $(MAKE) -k inner whose second target prints to stderr (kills X11);
  • a -k finding followed by kill -KILL $$$$ (kills X7, with no sleep);
  • $(MAKE) -s nothere || exit 1, expected exited 1 (kills X12).

NIT 1: MAKE_FAILED_RE takes the first : *** on a line. Its code group is optional, so a later Error on the same line is never tried (bootstrap.py:885, :920). Measured at both depths (probe1.log):

• A member writes printf 'x: *** y' >&2; exit 1, with no newline. Head says "printed no Error <code> line"; base said exited 1. That is a regression, though a contrived one.
• A member line x[3]: *** y followed by exit 2 is passed over as a deeper make's report. Head names no code; base said exited 2.
• Neither case is among the body's two "Not here" limits.
• A fix: use finditer and take the last match on the line. Anchoring on make would be wrong, because make prints its own program name.

NIT 2: the docstrings state the innermost rule with no conditions, and the limits are only in the PR body (bootstrap.py:83, :898-903, :944).

• "Straight after" is narrower than the code. said passes over an Error 2 that follows the last deeper *** line with any number of other lines in between.
  • Measured: -$(MAKE) inner (inner exits 1), then echo 'own refusal' >&2; exit 2 reads exited 1. The member's own refusal shows as a finding. Base read exited 2.
  • $(MAKE) inner || true; ...; exit 2 gives the same result.
  • This is the body's second limit, measured, and a regression from base for that shape.
• Other cases where the line is not the innermost command's code:
  • env -u MAKELEVEL $(MAKE) inner reads exited 2 at both depths, as base did.
  • -j interleaving reads exited 2; see "Checked and true".
• Suggest writing these limits into MakeErrors' docstring.

NIT 3: the signal sentence in the run_make docstring (bootstrap.py:948-955), measured under dash 0.5.12 and bash 5.2.21 (probe2.log, 24 cases at both depths):

• "the shell prints Killed itself … 143 for SIGTERM" is wrong for SIGTERM. dash prints Terminated, then make prints Error 143.
• "bash, which runs a recipe line of one command in its own place" is true but incomplete. bash also runs the last command of a list in its own place: echo before >&2; <killed> gives Killed and no code under bash, and 137 under dash.
• Every other sentence in it is true. See below.

NIT 4 (PR body only):

• In the complexity table, MakeErrors.said is 5 by Sonar's rules, not 4: the or 0 at :923 is a boolean sequence. It is still well under 15.
• The merge row for main names 1ef1a018. Main is now 33c5128b, and the merge is still clean (tree 18472b1d).

Checked and true

Line 2, the reading. GNU Make 4.3. Each case ran under the holder's make [-k] bootstrap (make[1]:) and with bootstrap.py run straight (make:), on head and on base 281df263, in the same holder. Logs: probe1.log, probe3.log, probe4.log.

case	head (both depths)	base
$(MAKE) inner, inner exits 1 / 2 / 3	1 / 2 / 3	2 / 2 / 2
two deep, inner exits 1 / 2	1 / 2	2 / 2
$(MAKE) nothere	no code named	2
inner make killed by SIGTERM / SIGKILL	no code named (Terminated / Killed)	the same
-k: sub-make (inner 1), then plain exit 2	2 (the last)	2
-k: plain exit 2, then sub-make (inner 1)	1 (the last)	2
-j2 inner make, with its Waiting line	1	2
-j2: plain job fails first, then the sub-make's inner	1	2
-j2 interleave: inner 1, then a plain job at the parent's depth fails 1	2 (the documented limit)	2
the same, with only Killed and Waiting (no code) at the parent's depth	2	2
-k: Error 1, then 5000 bytes (ended, and not ended)	1	no code named (false)
5000 bytes, and 100 KB, with no newline before Error 1	1	1
non-UTF-8 bytes; CRLF	1; 1	1; 1
-exit 1 then success; stderr not ended at EOF on success	ok; ok	ok; ok

• Can a *** line with no code reset the depth so the parent's Error 2 is taken as a code? Yes, but only under -j, when a job at the parent's depth fails or is killed while the sub-make is still finishing. That is inside the documented -j limit, and base read 2 too.
• Waiting lines at the inner depth never cause it.
• Under the holder's make -j2, each member's make warns jobserver unavailable: using -j1 and runs serially.
• Chunking: 92 captured stderr streams were fed to MakeErrors at every 2-way split, byte by byte, and in 200 random splits: 57,178 chunkings, none differing from the whole read (tools/chunks.py). Separately, read1(7) in place of read1(65536) passed all 57 tests (E1).
• EOF remainder: make's Error line can never be the unended remainder. make always writes it with its newline, and a mutant that reads the remainder (X6) survives as equivalent.
• The final-line texts are true in every case above, except the documented limits and NIT 1's contrived lines.
• stdout is byte-identical between head and base in 68 of 68 runs. stderr is identical apart from the family bootstrap line. Popen leaves stdout alone.

Line 2's signal docstring:

• make prints Killed or Terminated and no code in these cases: a command make runs without a shell, kill -KILL/-TERM $$ under either shell, and bash running one command.
• dash running one command prints the signal's name itself, exits 137 or 143, and make names that code.

Line 3, on a pty (pty2.log, ask/), through bootstrap and through the member's make alone:

• The terminal: stdin and stdout stay a terminal; stderr is not one through bootstrap and is one through make alone.
• git's progress meter: absent through bootstrap, shown through make alone.
• Line order: out of order through bootstrap (out 1|out 2|err 1|…, 3 of 3 runs), in order through make alone.
• A background process: sleep 6 & holds bootstrap 6.16 s, against 0.23 s under make alone. With 2>/dev/null it takes 0.29 s.
• A late write: ( sleep 1; echo late >&2 ) & takes 1.14 s, late shows, and its status file reads rc=0.
• w884's SIGPIPE claim, re-measured: with the "stop once make exits" variant (d1-bootstrap.py), the run ends in 0.33 s, late is lost, and no status file is ever written. The writer died at that write, silently.
• "Giving make the terminal back would lose its Error <code> line" is true. make --debug=j prints only "Reaping losing child …", and --debug=a prints no code anywhere.
• Documenting rather than changing is sound. The one way to keep both on POSIX would be a pty for make's stderr. It would fix only the isatty(2) effect and does not exist on Windows; it was not weighed.

Line 1:

• rv876's survivors, restated: R1 → [last-under-make]; R7 → the pty test; R8 (^make()?: ) → 4 tests; R10 → [unparsed]; R11 → [value-refused].
• The store mutant (S1b: the put-back lines also delete the store's main, expire its reflog and run gc --prune=now) is caught by exactly the new store assert in [commit]. [untracked] cannot catch it, because there the checkout's commit is the pin.
• My 12 mutants: 6 caught (X1 !=, X2 depth only on lines with a code, X3 [:LINE_KEPT], X4 depth group dropped, X8 splitlines, X10 one-digit code). 3 survive but are equivalent or never seen: X5 (\s*$ dropped: make's *** lines carry nothing after the code), X6, and X9 (depth exactly one less: makes nest one level at a time). The other 3 are SHOULD 1.
• R7 on the pty: the question shows at 0.04-0.07 s at head; with R7 it shows at 8.06 s, after the blind answer.

The pty test:

• 20 of 20 passed while my 2.43 run went beside it. The call phase took 0.07-0.13 s each time, against a 10 s window.
• It cannot hang without bound. If the question never shows, it gives up after 10 s, then 60 s, then proc.wait(timeout=60) fails at about 130 s. It does leave a member that hangs forever still running.
• With pty made unimportable, the file still collects 57 items and the test is skipped (could not import 'pty').

Fail on base: the head test file on 281df263 gives 3 failed and 54 passed (base-new.log). The 3 are exactly [innermost-under-make], [innermost] and the pieces test. 281df263 is byte-identical to 41baf920 for the touched files.

Runs at 82a84f88 through run9.sh:

• git 2.43, the 7 files: 532 passed, rc 0 (h243.log).
• git 2.47.1, the test file: 57 passed, rc 0 (h247.log).
• w884's logs: 218+394+437 = 1049 passed on both versions, rc 0, head 82a84f88, no tracked changes, the body's 14 files, no skips.

Merge checks (git merge-tree), all clean:

against	tree
main 33c5128b	18472b1d
#877	a137741f
#882	e39f0153
#769	881061ec

• On the tree merged with bootstrap.py: a .gitmodules blob with a line git cannot parse is read up to that line, as git reads it, and a parity test holds the value rules both family scripts write to one answer (#856) #877, test_family_holder_bootstrap_texts.py and test_family_gitmodules_values.py (the only test file bootstrap.py: a .gitmodules blob with a line git cannot parse is read up to that line, as git reads it, and a parity test holds the value rules both family scripts write to one answer (#856) #877 changes) gave 204 passed, rc 0 (merge877.log). The merged bootstrap.py keeps no MAKE_ERROR_RE.

Pinned copy and docs:

• bootstrap.py is in FAMILY_COPIED_VERBATIM (scripts/shape_materialize.py:533).
• update-shape.py:863-865 makes an upstream-changed row per path wherever the pinned bytes differ from the target, so each holder takes one row for it.
• Imports are unchanged and the mode stays 100755, so the skew rule holds.
• No sentence in AGENTS.md, AGENTS-shape.md, either README or docs/cli.md speaks of the make line or of stderr.
• The module docstring's (b) paragraph is true apart from NIT 2's limits.

Sonar-style checks:

• No duplicated window of 7 to 10 lines, even with literals blinded. At 6 lines, only the import block matches another file.
• No assert joins conditions with and; the one or assert is the family root's bootstrap.py and validate-family.py: the credential advice and a member's exit code say what happened, and the gate's git rm --cached, guarded mv and section lines type as printed where they failed (#839) #876's (:844).
• Hand counts: read 1, said 5, run_make 1, read_until 9, made 2, the line test 4.
• The longest new line in bootstrap.py is 76 columns.

The body's other numbers are true: both of its tables, 9 new items (57 in all), 3/54 on base, and 1049 on both versions. The title (225 characters) is in the repo's subject style.

Could not verify

• Windows decoding: read only. A member on Python 3.15 or later, whose UTF-8 mode is the default (PEP 686), would not garble.
• macOS, make before 4.0, a make speaking another language (no locale here), and CI's git 2.55.0.
• SonarCloud's real verdict: the Sonar MCP failed to connect.

Checklist candidates

• C1 (older than the family root's bootstrap.py: run_make's final line is false in three cases, piping make's stderr loses the terminal, the line order and a background child's exit, and five mutants of #876's code survive its tests #884). Under the holder's make -jN bootstrap, every member's make prints warning: jobserver unavailable: using -j1. Add '+' to parent make rule. bootstrap.py's Popen closes the jobserver file descriptors, and the holder Makefile's recipe has no +.

Scratch left; nothing of mine is running

• Worktrees: rv884-head, rv884-base, rv884-mut and rv884-merge877 are all removed with git worktree remove.
• An unreferenced commit in the shared repo: 1b541bc9, the merge with bootstrap.py: a .gitmodules blob with a line git cannot parse is read up to that line, as git reads it, and a parity test holds the value rules both family scripts write to one answer (#856) #877, made with commit-tree and a throwaway identity.
• Basetemps: $Q/v110/bt/rv884-{h243,h247,base,mut,m877,nopty,pty}.
• Probes, logs and tools: $Q/v118/rv884/. Two __pycache__ folders from py_compile were moved there out of the worktrees: moved-pycache-mut and moved-pycache-merge877.
• Processes: no process of mine is still running.

[brettheap]

(lane openRepoShape-5, 2026-10-18T11:15:47Z) Fix round 1 for #886 (#884), from rv884's review (issuecomment-6248806027): head dbd3a6dd

One commit on 82a84f88, touching templates/family-root/scripts/bootstrap.py and tests/test_family_holder_bootstrap_texts.py only.

SHOULD 1, X7, X11 and X12. INNERMOST has three more members: KeepsGoing, which is $(MAKE) -s -k inner whose second target prints after the inner Error 1 (X11); ThenKilled, a -k finding followed by kill -KILL $$ with no sleep (X7); and InnerThenFinding, which is $(MAKE) -s nothere || exit 1, expecting exited 1 (X12). Each mutant, restated at the new head, is caught by both [innermost*]. rv884's own saved copies of 82a84f88 with X7, X11 and X12 each read their member wrong (ThenKilled says none, KeepsGoing says 2, InnerThenFinding says none).

NIT 1, the first match on a line. MakeErrors.said now takes the last MAKE_FAILED_RE match on a line (findall). OwnStars, rv884's printf 'x: *** y' >&2; exit 1, reads exited 1 at both depths, as 281df263 read it; 82a84f88 named none. Mutant N1, which takes the first match, is caught. x[3]: *** y followed by exit 2 stays a limit, written in the docstring.

NIT 2, the limits in the docstrings. MakeErrors' docstring now says what the code does: an Error 2 at a shallower depth than the last *** line, whatever lines come between. It names where the code is not the innermost command's: a make whose failure the shell lets pass (|| true, ;), or a - in a make run with -s, which prints no (ignored) line, followed by the recipe's own exit 2; env -u MAKELEVEL; -j interleaving; and a member's own line shaped like make's. The module docstring's (b) says "as far as make's lines tell it".

• The optional (ignored) line: adopted, by measurement. make's [Makefile:N: bootstrap] Error 2 (ignored) now puts the depth back at the parent's, but only where it is shallower than the last *** line. So -$(MAKE) inner then exit 2 (LetFail) reads exited 2 again; 82a84f88 read 1.
• Across rv884's 133 case runs (tools/cases1.py to cases6.py, both depths), head differs from 82a84f88 only there and in NIT 1's case. Across 21 more of mine it differs only there, in -$(MAKE) nothere then exit 2, and in NIT 1's case, each now as 281df263 read it.
• An inner make that ignores an exit 2 of its own prints the same kind of line at its deeper depth; InnerLets holds that this changes nothing (exited 2). It runs without -s, since -s keeps make from printing the line. Mutants N2-N5 on that branch are each caught.

NIT 3, the signal sentence. It is now true of rv884's 24 cases in its probe2.log:

• make prints the signal's name and no code where the signal kills what make started: a command run with no shell, the shell a kill $$ kills, or a command bash runs in its own place, which is a line's last command;
• where the shell outlives the command (dash always, bash for a command that is not the line's last), the shell prints Killed or Terminated itself and exits 137 or 143, which make names;
• where the line goes on after the command, the shell exits as the rest of the line does.

NIT 4, the body. body-r1 recounts said: 5 at 82a84f88, 6 now with the (ignored) branch. The merge rows name main 71f36fe0, with its tree.

Tests. Still 57 items; INNERMOST has 11 members, run at both depths.

• On 281df263's code: 3 failed, 54 passed ([innermost-under-make], [innermost], the pieces test).
• On 82a84f88's code: 2 failed, 55 passed (both [innermost*]: LetFail and OwnStars).
• At head: 57 passed.

Mutants at head: 36 made (w884's 19 and rv884's X1-X12, restated where the code changed, and N1-N5 for this round's hunks), 33 caught. The 3 survivors are the equivalents rv884 named: X5, X6 and X9.

Runs at dbd3a6dd, through run9s.sh with SHARDS=3, on the body's 14 files:

• git 2.43.0: 1049 passed, rc 0 (shards 218, 394 and 437).
• git 2.47.1: 1049 passed, rc 0 (shards 218, 394 and 437).

Merge checks after a fresh fetch:

• origin/main 71f36fe0, where bootstrap.py: a .gitmodules blob with a line git cannot parse is read up to that line, as git reads it, and a parity test holds the value rules both family scripts write to one answer (#856) #877 has landed as c9ca9a45: clean, tree 8b5826db. On that tree, this test file and tests/test_family_gitmodules_values.py gave 204 passed.
• bootstrap.py: a .gitmodules blob with a line git cannot parse is read up to that line, as git reads it, and a parity test holds the value rules both family scripts write to one answer (#856) #877's head 35b214b2: clean, tree b80a2ba0.
• Main is not merged into the branch. Against main 201c6f09, which has since taken family.py, adopt-project.py and the four tools' --org: init asks GitHub's limits on the topic, the --org and the holder's name before any repository exists, check finds what execute refuses from one list, and an --org GitHub gives no organisation (., a trailing hyphen, --) is refused where GitHub is asked (#863) #871 and bootstrap.py: a validator's exit 2 ends bootstrap REFUSED, exit 2, an unreadable upstream path, cache or pin is no answer and a reftable leg's cherry-pick or revert is read from its ref store, so no traceback or ended pick follows (#764) #815, the merge is clean too: tree 8c3d8e13.

Lane: openreposhape-5 (openRepoShape-5)

[brettheap]

Re-check of #886 (#884)'s fix round 1 at dbd3a6dd, for lane openRepoShape-5: READY

All five of my first-round findings are closed. I found no MUST and no SHOULD. The new (ignored) marker gets two NITs: a one-token code change and a docs gap. I changed no branch, pushed nothing and posted nothing. $Q = /tmp/claude-1000/-workspace-projects-openRepoShape/50cede29-ab82-4ca3-9f67-d98e1a58c8d2/scratchpad. Logs and tools are in $Q/v118/rv884b/.

Findings, most severe first

NIT 1: the (ignored) rule could reset the depth fully, which would make two more shapes read right (templates/family-root/scripts/bootstrap.py:947-948, and :889 for Error 2 only).

• Scenario 1 (probe-ign3.log): the member runs $(MAKE) mid, then its own exit 2. mid runs -$(MAKE) inner, and inner exits 1.
  • make prints make[3]: *** … Error 1, then make[2]: [mid] Error 2 (ignored), then make[1]: *** [bootstrap] Error 2.
  • Head moves the depth back to 2, the ignoring make's own, so the member's Error 2 is passed over.
  • The line says exited 1, so a refusal reads as a finding, at both depths. 82a84f88 also said 1; 281df263 said 2.
• Scenario 2: $(MAKE) inner || true, then -false, then exit 2. Error 1 (ignored) is not a marker, so head says exited 1. That shape is listed in the docstring.
• Why a full reset is safe: in a sequential run, a make that has printed (ignored) keeps going. If it fails later, it prints its own *** line first, and that line sets the depth again. So no Error 2 that comes after an (ignored) line, with no deeper *** line between, can be a make reporting a failed sub-make.
• Measured with patched copies of head, over all 183 case-modes I have (probe-i17.log, probe-i117.log):
  • self.depth = -1 in the (ignored) branch (my I17) differs from head in 3 case-modes;
  • adding any code's (ignored) line as the marker (I1+I17) differs in 5;
  • each difference is one where head names the wrong code and the patch names the member's own exit 2; everything else is unchanged.
• Both I1 and I17 survive the tests. A person would see them only as lines that become right.

NIT 2 (docstring only): the list of limits in MakeErrors misses two shapes (bootstrap.py:913-925).

• Scenario 1 above: a - one make below the one that exits 2. NIT 1's change would remove it.
• Under -k, a: $(MAKE) innerA (exits 1), then b: -$(MAKE) innerB (exits 3). The line names 3, the code of the sub-make a - let fail, though the failing command exited 1. 82a84f88 and 281df263 also said 3 (k-sub1-then-letfail).

Checked and true

My first-round findings:

• SHOULD 1, closed. X7, X11 and X12, restated at dbd3a6dd, are each caught by both [innermost*] (mut/summary.txt).
• NIT 1, closed. said takes the last findall match. printf 'x: *** y' >&2; exit 1 reads exited 1 at both depths (82a84f88 named none), and N1, which takes the first match, is caught.
• NIT 2, closed apart from the two shapes above.
  • The docstring now says "at a shallower depth than the last *** line …, whatever lines come between", and lists || true/;, - under -s, env -u MAKELEVEL, -j, and x[3]: *** y.
  • I measured each of them: s-letfail-then2 reads 1 under the holder's make -s and under MAKEFLAGS=s.
  • The -s behaviour is in the docstring.
• NIT 3, closed. All three sentences are true of every one of the 24 cases in probe2.log:
  • no code where make started what was killed (no shell, kill $$, or bash's last command);
  • the shell's Killed or Terminated with 137 or 143 where the shell outlives the command (dash always, bash when it is not the last command);
  • ; echo after ends the recipe with 0.
• NIT 4, closed. said is 6 by my count too. The merge rows are right: main 71f36fe0 gives tree 8b5826db, bootstrap.py: a .gitmodules blob with a line git cannot parse is read up to that line, as git reads it, and a parity test holds the value rules both family scripts write to one answer (#856) #877's head 35b214b2 gives b80a2ba0, and main 201c6f09 gives 8c3d8e13.

The (ignored) marker, measured at both depths on dbd3a6dd, 82a84f88 and 281df263 (probe-ign.log, probe-ign2.log, 25 cases, 150 runs):

case	head	82a84f88	281df263
-exit 2 (or -exit 1) first, then a sub-make whose inner command exits 1	1	1	2
sub-make 1 || true, then -false, then own exit 2	1 (listed limit)	1	2
sub-make 1 || true, then -sh -c 'exit 2', then own exit 2	2	1	2
-$(MAKE) inner (inner 1 or 3), then exit 1 / exit 2 / exit 3	1 / 2 / 3	1 / 1 / 3	1 / 2 / 3
-$(MAKE) nothere, then exit 2	2	none named	2
-k: let-fail, then own exit 2	2	1	2
-k: let-fail (inner 3), then sub-make (inner 1)	1	1	2
-j2: sub-make 1 beside a let-fail sub-make	1	1	2
-j2: let-fail beside own exit 2	2	1	2
an ignored exit 2 inside the inner make, then the inner fails 1	1	1	2
an ignored exit 2 inside the inner make, then the member's own exit 2	2	2	2
-$(MAKE) -s inner, then exit 2 (the parent still prints (ignored))	2	1	2

• No case reads worse than 281df263 except the shapes already listed as limits and Scenario 1.
• One case reads worse than 82a84f88: under -j2, an ignored plain exit 2 lands between a still-running sub-make's Error 1 and its parent's report (j-keepsgoing-and-ign-plain2). Head says 2, 82a84f88 said 1, and 281df263 said 2. That is inside the documented -j limit.

All my earlier cases: over 133 case-modes, head differs from 82a84f88 in only 4: the let-fail case and the last-match case, each at both depths, and each now as 281df263 read it (probe-all.log).

Chunking: 250 streams in 137,515 chunkings, none differing from a whole read. read1(7) (E1) passes all 57 tests.

Mutants at dbd3a6dd (22 runs):

• caught: X1-X4, X7, X8, X10-X12, N1-N5, and my I8 (min with depth + 1);
• survived, equivalent: X5, X6, X9;
• survived and visible: I1 and I17, both changes that would make lines right (NIT 1), and I4 (an (ignored) line clears the code). I4 reads "none named" for the -k let-fail shape where head says 3 and the true code is 1, so both are wrong there.

Runs at dbd3a6dd:

• texts file on 2.43: 57 passed, rc 0;
• 7-file set on 2.43: 532 passed, rc 0;
• texts file on 2.47.1: 57 passed, rc 0.

Fail on older code, with the round's test file:

• on 82a84f88's code: 2 failed (both [innermost*]), 55 passed;
• on 281df263's code: 3 failed, 54 passed.

w884's logs: 218+394+437 = 1049 passed on 2.43 and on 2.47.1, head dbd3a6dd, no tracked changes. This matches the body.

Main: the merge with 201c6f09 is clean, tree 8c3d8e13. On a detached commit at that tree, the texts file, test_family_gitmodules_values.py and test_pinned_copy_text.py gave 291 passed, rc 0. Merges with #882 and #769 are clean too.

Sonar-style checks:

• No duplicated window of 6 to 10 lines with exact text.
• With literals blinded, INNERMOST's own entries match each other in 10-line windows. That matters only if Sonar blinds literals.
• The only or assert is the old one (:865), and no assert joins conditions with and.
• said scores 6; no other changed function's code changed.
• The longest new line is 76 columns.

A note on the body's evidence: merged-main.log for "204 passed on that tree" shows head=281df263 dirty=35, not a commit at the merged tree. My own run on the real merged commit (291 passed) covers that claim.

Could not verify

• SonarCloud's real verdict (the Sonar MCP is down), Windows, macOS, make before 4.0, and CI's git 2.55.0.

Checklist candidates

• None new. C1 from my first review stands: under the holder's make -jN bootstrap, every member warns jobserver unavailable.

Scratch left

• Worktrees: rv884b-head, rv884b-mut and rv884b-main are all removed. My fetched ref refs/l5rv884b/pr886 is deleted.
• An unreferenced commit: d8802b66 (the merge with main, made with a throwaway identity), beside the earlier 1b541bc9.
• Basetemps (reused): $Q/v110/bt/rv884-{h243,h247,base,mut,m877,nopty,pty}.
• Probes and logs: $Q/v118/rv884b/.
• Processes: none of mine are running.

[sonarqubecloud]

Quality Gate passed

Issues
0 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[sourcery-ai]

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

You can request another review in 3 days and 6 hours by commenting @sourcery-ai review. Upgrade to get a review now.