[brettheap]

Lane: openreposhape-2 (openRepoShape-2)
Claim: opensoft/openRepoTools#198 (comment)

Re-homed from opensoft/openRepoTools#311

This is slice 3 of Amendment 23 act 2, re-homed from opensoft/openRepoTools#311 to the code leg. Brett Heap confirmed it as Q28 on opensoft/openRepoTools#198 (comment 6722244541): slices 2a, 2b, 3 and 4 open as draft PRs here, and are reviewed and ready for his word by 2026-11-17. The six act 2 drafts keep their stack order and move by cherry-pick, not by merge (opensoft/openRepoTools#186, comment 6548291952 S18).

• Heads.
  • Old: 2dc07d1 on opensoft/openRepoTools feat/198-a23-slice-3-skill, an archived original that is never pushed again.
  • Re-homed: f6b029f, the old 2dc07d1 rebuilt here.
  • This branch now: f2340ad, the merge of 2b'' (4031100: 2b' with A61, F28) into 7690a1f, the answer-3 commit (F27) on 6b81f19, the merge of 2b' (a44b9d2) into 95c52cc. 95c52cc is the merge of 2a' (2b1a232) into 2a420e0; 2a420e0 is f6b029f, the merge of 2a's code-leg head 1320847 (e7bae8e), and this round's six commits. The merge of 2a' changed none of the slice's files. The merge of 2b' changed one line of one of them, in tests/test_handoff_skill_80_85.py (F26). 7690a1f adds tests/test_repo_hygiene.py to the slice's files and retires one test of tests/test_handoff_skill_commit_block.py (F27). The merge of 2b'' changed none of the slice's files (F28).
• Method.
  • Each old commit's tree is cut to the code leg's 26 owned top-level paths: the cutover plan's leg: code entries (opensoft/openRepoTools-spec specs/004-migrate-to-triad/adoption-plan-cutover-2026-10-26.yaml).
  • Each commit keeps its author, its author and committer dates, and its message byte for byte. A (cherry picked from commit <old sha>) line is added, placed where git cherry-pick -x puts it, and the committer is Brett Heap.
  • The stack is rebuilt on 0cefa1f, the code leg's counterpart of old f18b818. The rule is an include list: for all 139 mapped pairs of old main, the restricted old tree equals the code leg's tree.
  • Slice 3's net diff touches no spec-leg path, so nothing goes to the spec leg.
• Range-diff summary, for all six slices: 227 pairs and 0 mismatches in tree, parents, author, committer, message or headers. git range-diff shows 183 ! pairs, each only the cherry-pick line or a dropped docs hunk. It shows 12 unmatched pairs, all explained: 11 commits empty after the restriction (none of them slice 3's) and 1 equal by patch-id. Nothing is unexplained. Range-diff does not show the 32 merges; tree equality covers them. Slice 3 has 11 commits, none empty.

Receipt: slice 3's 11 old commits and their code-leg counterparts

old	code leg	subject
b599ed9	98e2ec0	Amendment 23 act 2, slice 3: the handoff skill defines its file through handoff-path and writes it with ONE write-handoff --whole call, so it spells no checkout and commits, pulls and pushes nothing of its own, and step 4's append-line and set-row-state carry LANES_LANE (opensoft/openRepoTools#198)
019074b	502b060	Slice 3, rv3's MUST 1: the handoff skill's first step-2 block tells handoff-path's exits apart, so only its 8 is HANDOFF NOT FOUND and every other exit is a HANDOFF READ FAILED that quotes the code, an older helper is told to update lanes-edit.sh, a held lock to run step 2 again, and the session keeps its new top block in the report (opensoft/openRepoTools#198)
b9ba76d	c65acbf	Slice 3, rv3's SHOULD 2: the skill's exit-7 arm says to run the block under WHERE THE HANDOFF IS again, for a new digest and a new prepared file, and then this block once more, and where the verb wrote nothing the new file's temporary path is named for the report (opensoft/openRepoTools#198)
ce10339	925aec2	Slice 3, rv3's SHOULD 3: step 4's register PAUSED line ends with what step 2 did, carried in $hf_record, so it says handoff refreshed only where write-handoff exited 0, handoff written, its publication NOT confirmed (...) where the verb wrote the file and exited otherwise, and handoff NOT refreshed (<why>) wherever nothing was written or step 2's outcome never reached it (opensoft/openRepoTools#198)
dd956d4	31b705f	Slice 3, rv3's SHOULD 4: the words that keep the swap safe are pinned (the 3 arm's "Do not call it published until it is read back", the 2 arm's "Do not call it again", and the * arm's "the file is written at", now run with stdout), and a 2 from handoff-path that is no older helper says the handoff it names may belong to another repository, where nothing is to be written (601) (opensoft/openRepoTools#198)
8445406	d8260c4	Slice 3, rv3's SHOULD 1, option (b): the session writes only its new top block, to $block_file, and the skill builds the complete new file from it, --- and a blank line, then cat -- "$handoff_file", and proves with tail -c <old size> | cmp that the old file survives at its end, so a file that lost the history is never sent (opensoft/openRepoTools#198)
a972899	e5c8df8	Slice 3, rv3's NITs 1-4: the subject is lane-handoff's (@${ws:-unknown}, control characters as spaces), the 0 arm says "handoff written" and leaves what was committed and pushed to the verb's note (604: S2 governs), the three places that called step 2's write a commit "in the LANE'S OWN repository" say it is write-handoff's and not refused for want of a workstation, and four composite asserts are split (opensoft/openRepoTools#198)
1913db9	9da8a26	Slice 3, rv3's mutants A, E and I: three stub tests hold what no test held, so a digest of the wrong shape sends nothing, sha256sum is asked before shasum as the helper's own lane_handoff_digest asks, and the digest sent is block 1's even where the file moved between the blocks (opensoft/openRepoTools#198)
f30fe2f	4aff313	Merge slice 2a at 60ddad3 into slice 3: git found no conflict; 2a brings 601's refusal of a handoff in another checkout of the register (A54), 602 (A55), 603's fence 7s (A56), 604's 8(d) commit in its own repository (A57), A58 and A59 (605, 607), which slice 3's round for lane openRepoTools-3's review of opensoft/openRepoTools#311 at 1913db9 rests on (opensoft/openRepoTools#198)
18c5b3c	1052cd5	Slice 3, 981 (MUST) of lane openRepoTools-3's review of opensoft/openRepoTools#311, by option (a) on lane 3's word: the skill writes its top block with write-handoff --prepend "$block_file", so the verb builds and proves the new file under its lock and refuses a block with no final newline (64), where the build glued --- onto its last line; new arms for that 64 and for a restart's 7 (opensoft/openRepoTools#198)
2dc07d1	f6b029f	Slice 3, 982 of lane openRepoTools-3's review of opensoft/openRepoTools#311: the 6 arm says, in the verb's words after 604, where the commit is kept or that there is none (on HEAD of the lane checkout, in an Amendment 8(d) handoff's own repository, or nowhere where the add or the commit failed), with a real 8(d) case whose push fails there (opensoft/openRepoTools#198)

4aff313's subject is shown with one word fewer (its "round" is the commit's "fix round"), so that no closing keyword stands before an issue reference in this body; the commit itself is unchanged.

What this slice does

skills/handoff/SKILL.md stops committing, pulling and pushing the handoff itself. Step 2 now:

• asks handoff-path --create where the lane's handoff is, and tells its exits apart, so that only an 8 is "no handoff";
• has the session write ONLY its new top block, to a temporary block file;
• writes it with ONE write-handoff --prepend "$block_file" call. The verb, which slice 2a added, reads the handoff under the lane checkout's lock, puts the block, --- and a blank line in front of it, and proves that the block and the old file both survive before it replaces the file (option (a), F17);
• says what each exit of the verb means, and never stops the swap;
• prints the one call that puts a kept block into the handoff, filled in, and never says to edit the handoff by hand (F19).

Step 4's register PAUSED line then says what step 2 did, in the phrases the skill and 2b's lane-handoff share (F12, F23). Every Bash call is a new shell, so each block prints what the next one needs (F20).

The block this replaces was one of the three writers that commit to a checkout with no lock and then pull and push (finding 282 of lane openRepoTools-3's review of opensoft/openRepoTools#307, with lane-start's stamp and lane-handoff's PAUSED commit). The other two are slice 2b's.

This round: lane openRepoTools-3's first review of opensoft/openRepoTools#311 at 1913db9

Lane openRepoTools-3's review (comment 6376170218 on opensoft/openRepoTools#311) said LAND AFTER FIXES: MUST 981, SHOULDs 982 to 984, NITs 985 to 987, INFO 988 to 992, and answers to round 2's six questions. 1913db9 is 9da8a26 here. Each fix has a case that was red before it, a mutant the case kills, and its own commit:

item	what it found	answered in (code leg)	decision
merge	2a's round, 60ddad3, which 981 and 982 rest on	4aff313 (old f30fe2f)
MUST 981	a top block with no final newline merged into the old one, and lane-start handed the next session both as one prompt	1052cd5 (old 18c5b3c)	F17 (option (a))
SHOULD 982	the 6 arm was out of date after 604: an 8(d) handoff's 6 is in its own repository, and a failed add or commit is 6 with no commit	f6b029f (old 2dc07d1)	F18
merge	2a's head on the code leg, 1320847 (A60, 991)	e7bae8e
SHOULD 983	every kept-block message said the block goes "at the head of the handoff by hand"	8797d11	F19
SHOULD 984	step 4 learnt step 2's outcome only in the same shell, so a step 4 in its own call wrote a false line	d61b02f	F20
NIT 985	the 2 arm called a sibling checkout "another repository" (8(d)'s term), and did not name 602	054e84d	F21
NIT 986	two phrases that were false once 2a's round was merged	11c854f	F22
NIT 987	two mutants survived the module	3e828ee	rows only
answer 6, INFO 990	one set of record phrases for the act's two writers; a 0 may commit nothing	2a420e0	F23, F24
merge	2a' (2b1a232): 2a with 1b', 1a' and the code leg's main 577110e, which brings the .gitattributes and LICENSE that the rebuilt base lacked	95c52cc	F25
merge	2b' (a44b9d2): 2b on 2a', with lane-start and lane-handoff on write-handoff; the sitting that lane 3 ruled needs this branch to contain it	6b81f19	F26
answer 3	_NO_PULL_FILES did not list the skill, which 2b' left to the second of 2b and this PR to land, and the module held the rule by a stand-in test	7690a1f	F27
merge	2b'' (4031100): 2b' with A61, 2a's test-only fix for two cases that failed on CI's git 2.56.0	f2340ad	F28
INFO 988, 989, 991, 992	errexit, temporary files, handoff-path's glob path, opensoft/openRepoTools#303's twin lines	none	"Lane 3's answers and the INFO items"

Stacked on

Slice 2b's code-leg PR, #20, on feat/198-a23-slice-2b-start-handoff at 4031100 (2b'': slice 2b's a44b9d2 (2b') with A61, 56a9b87, 2a's test-only fix; 2b' is slice 2b with 2a' (2b1a232), which carries slice 1b's and slice 1a's rebuilt commits and the code leg's main 577110e), merged here at f2340ad. This PR's base is that branch, retargeted from slice 2a's, #18. Its own diff is git diff 4031100 HEAD: four files ("What changed"): the slice's three, with the counts they had over 2a' less the test F27 retires, and tests/test_repo_hygiene.py.

• The code leg's main is merged, through 2b' and 2a': 577110e (code PRs 3 to 7 and the cutover's own commits) is an ancestor of this head. The two tests that failed on 2a420e0 (and still fail on the rehome base 0cefa1f and on every rehomed slice without the code leg's main) pass at this head:
  • tests/test_repo_hygiene.py::test_the_root_carries_the_line_ending_rule, because .gitattributes is there;
  • tests/test_tests_workflow.py::test_tests_yml_synthetic_wheels_are_wheel_md_s_members, because LICENSE is there.
• Where it lands. In the one sitting that lane openRepoTools-3 ruled (Lane writers commit first and sync second, so a pull that refuses or conflicts strands the commit and later writes stack on it: fast-forward before the edit, and refuse before committing (fail closed) openRepoTools#198, comment 6724194619), last and right after slice 2b (Amendment 23 act 2, slice 2b: lane-start and lane-handoff write the Rule 3 stamp and the PAUSED block with one write-handoff through the lane's checkout, W moves only by fast-forward, and a launch refuses only at a restart's fences #20), by merge commit, on Brett Heap's standing word for act 2's six re-homed slices (Lane writers commit first and sync second, so a pull that refuses or conflicts strands the commit and later writes stack on it: fast-forward before the edit, and refuse before committing (fail closed) openRepoTools#198, comment 6723968257): "land each once its CI is green and lane 3's review passes, by merge commit". A HOLD goes stale after 30 minutes, so no step may need a CI re-run, and each step's merge tree must equal its tested head's tree. This branch contained slice 2a' but not 2b' at 95c52cc, so its step would not have been equal; at this head it is (F26, F27). A new head of Amendment 23 act 2, slice 2b: lane-start and lane-handoff write the Rule 3 stamp and the PAUSED block with one write-handoff through the lane's checkout, W moves only by fast-forward, and a launch refuses only at a restart's fences #20 is merged here the same way.

Round 2: rv3's pre-review of b599ed9

Before lane openRepoTools-3's first review, an independent reviewer of lane openRepoShape-2 (rv3) read b599ed9, ran it, and predicted its merge with 2b (37b8806, no conflict). Its verdict was NOT READY: one MUST, four SHOULDs and four NITs. Its ten planned mutants did not run, because the coordinator's last step came first. Round 2 answered them in seven commits (old shas below; the receipt above maps each to the code leg). Each of the first six carries a case that was red at the head before it; the seventh's tests were red against the mutants they kill:

rv3's item	what it found	answered in	decision
MUST 1	every non-zero exit of handoff-path was read as "not found", so a read that failed (1, 2, 4, 127) dropped the new top block with nothing in the report	019074b	F10
SHOULD 2	a lane checkout behind origin gets exit 7 on the first call, and the 7 arm never said to run block 1 again for a new digest	b9ba76d	F11
SHOULD 3	step 4's register line ended ; handoff refreshed whatever step 2 printed	ce10339	F12
SHOULD 4	three phrases that keep the swap safe were not pinned, and the * arm was never run with stdout	dd956d4	F13
SHOULD 1	the session built the whole file by hand, and nothing checked that the old file survived under the new block	8445406	F14 (option (b)); option (a) is question 1
NITs 1-4	the subject's workstation fallback, the 0 arm's claim of a push, old wording in three places, composite asserts	a972899	F15
its mutants A-I and P	run this round, with one each for SHOULD 3 and SHOULD 1: A, E and I survived	1913db9	F16

Decisions

F1 to F9 are round 1's and F10 to F16 round 2's, numbered as the work's own log numbers them; F17 to F28 are this round's. F2 and F7 depart from the plan. F17 (option (a)) replaces the digest, the build and the --whole call that F1, F4, F11, F14 and F16 describe. Those are kept as the record of what lane 3 reviewed; the blocks are as F17 to F24 say.

1. F1. Two blocks in step 2, and the verb is called once. The digest must be read BEFORE the session writes its new top block, and the call comes AFTER the top block's template. So:

   • block 1 (the block that holds handoff_file="$("$L" handoff-path "$lane" --create)") defines handoff_file, prior_sha256, block_file and prepared_file (both mktemp under $TMPDIR), and prints all four;
   • block 2 (the block that holds --whole "$prepared_file") stands where Handoff skill: commit the handoff in the checkout it was published in, by its own path, and refuse foreign staged entries and in-progress operations (#197) openRepoTools#199's block stood. It builds the new file and the subject, and makes the ONE call LANES_LANE="$lane" "$L" write-handoff "$lane" --whole "$prepared_file" --expect-digest "$prior_sha256" --subject "$hf_subject".

   The old publish-handoff block is gone, and the three variables it named, which no step of the file ever defined, are now defined. This round added block_file (F14).

2. F2. DEPARTS FROM THE PLAN: handoff-path "$lane" --create, where the plan says a bare handoff-path "$lane". The skill must READ the file, for the digest and for the old bytes the new file keeps under ---, and a lane that never wrote through its own checkout has none yet. --create is handoff-path's own flag (2a's decision 9). rv3 agrees (question 2).

3. F3. A handoff that is not found, or not read, does not stop the swap (R-A11-11). Block 1 says why, empties handoff_file, and block 2's guard says HANDOFF NOT WRITTEN ... was NOT called. Steps 3 to 5 still run. This round, only an 8 (or a 0 that names no file) is "not found" (F10).

4. F4. Every exit of the verb is said, and none stops the swap. Block 2's case: 0 handoff written (F15); 2 with stdout HANDOFF NOT COMMITTED, the file written and uncommitted, and do not call again (a second call is refused, 7); 2 with no stdout HANDOFF NOT WRITTEN; 3 PUSHED, NOT CONFIRMED; 6 NOT PUSHED, the commit kept on HEAD and named; 7 NOT WRITTEN, the handoff moved or a restart owns it (F11); anything else NOT PUBLISHED, and whether the file is written (F13). A non-empty stdout means the file is written: 2a's cleanup prints HANDOFF_OUT on every exit once the replace has succeeded.

5. F5. The subject is built from variables, never from placeholders (the rule of Copilot's review of workBenches#91 against the vendored bytes at f98d734: --dir flag swallows -*, lane-handoff's rename-before-commit and permissive window checks, --lane= accepts empty, and two placeholder leaks in handoff/SKILL.md openRepoTools#80's item 7): handoff(<lane>@<workstation>): PAUSED, <why>, with handoff where there is no why. This round, a missing workstation is unknown and a control character becomes a space, as 2b's lane-handoff writes the same act's subject (F15). The verb exits 64 on a control character in the subject, so a tab in a why must not cost the swap its handoff. A dash survives.

6. F6. The skill spells no checkout path at all: no ~/projects/brett-wip, no workspace-root, no LANES_REPO, no LANES_BRANCH, no cd, and no line outside a comment that pulls with --rebase.

7. F7. DEPARTS FROM THE PLAN: _NO_PULL_FILES in tests/test_repo_hygiene.py is NOT edited here. Slice 2b edits the same tuple line for lane-start and lane-handoff, so two slices would conflict on one line by construction. The module's test_the_skill_never_pulls_with_rebase_outside_a_comment holds the rule until the third name goes in at the merge of 2b. rv3 agrees (question 3). F27 makes that edit and retires the test.

8. F8. Step 4's append-line and set-row-state run as LANES_LANE="$lane" "$L" ..., as log PAUSED already did: under Amendment 23 S2 a register write goes through the lane's own checkout.

9. F9. The tests are one rewritten module, tests/test_handoff_skill_commit_block.py, each block run under bash and under zsh where it is installed: 148 tests now (see "Tests").

10. F10 (MUST 1). Block 1 tells handoff-path's exits apart:

    • 8, or a 0 that names no file: HANDOFF NOT FOUND;
    • 4: HANDOFF READ FAILED, another write held the lock that makes the lane checkout: run step 2 again;
    • 2 with "unknown subcommand": an older lanes-edit.sh that predates handoff-path. Update it (openRepoTools --install installs it with this skill), then run step 2 again. To tell this 2 apart, a 2 is asked a second time with only its stderr kept, as step 1's sread asks, WITHOUT --create and with LANES_NO_FETCH=1, so the second ask is a read that clones and fetches nothing;
    • any other 2 (F13), and every other exit: HANDOFF READ FAILED, quoting the code. A read that failed is no answer (Amendment 7(d)), and the helper's own words for 1 are "R22: never 8".

    Every outcome of block 1 that writes nothing tells the session to write its new top block all the same and put it whole in the report, where it is the one copy ($hf_keep), and the swap goes on (R-A11-11). The module's old expectation, an exit 1 said as NOT FOUND, now expects a read that failed.

11. F11 (SHOULD 2). The 7 arm says the way out. If the handoff moved: run the block under WHERE THE HANDOFF IS again, which reads a new digest and makes a new prepared file and a new block file; write the new top block to the new block file; run block 2 once more, which builds the new file from what is there now. If a restart owns it: do not retry, because that restart writes this handoff. The prose notes 603 (a fence refusal is 7 too) and 601. Wherever the verb wrote nothing, block 2 names both temporary files for the report ($hf_kept). rv3's probe of the behind checkout is ported as a real-helper test, routed and through the managed seam, in both shells: the first call is 7 with nothing published, and step 2 run again writes the new block over the peer's file, which survives under it.

12. F12 (SHOULD 3). Step 4's register line says what step 2 did, carried in $hf_record:

    • handoff refreshed, only where the call exited 0;
    • handoff written, its publication NOT confirmed (write-handoff exited <rc>), where the verb's stdout names the file and it exited otherwise (2, 3, 6, any other);
    • handoff NOT refreshed (write-handoff exited <rc> and wrote nothing);
    • from block 1: handoff NOT refreshed (no handoff found) (8, or a 0 with no file) or handoff NOT refreshed (the handoff read failed, exit <rc>);
    • from block 2's guard: handoff NOT refreshed (write-handoff was not called) and handoff NOT refreshed (the new file did not keep the old handoff whole) (F14).

    Step 4 defaults an unset $hf_record (safe under set -u) to handoff NOT refreshed (step 2 left no outcome), the safe direction: a lost variable must not claim a refresh. Step 4's comment now says its line equals lane-handoff's word for word only where step 2's call exited 0 (question 6). tests/test_handoff_skill_80_85.py's two step-4 preludes bind hf_record="handoff refreshed", what step 2 binds on a 0, so its tests of that equality stand.

13. F13 (SHOULD 4). The safety words are pinned, in the module's table of what each exit says: the 3 arm's "Do not call it published until it is read back", the 2-with-stdout arm's "Do not call it again", and the * arm's "the file is written at ." in a new case WITH stdout (exit 1 after the write). The full stop after the path catches a stdout left unsplit (<file><TAB><sha256>), and the no-stdout * cases may never say it. Block 1 also gains a 2:* arm after the unknown-subcommand one, for a name refused, a clone that failed, or 601's refusal: "Where its words name such a file, the handoff it names belongs to another repository and not to this lane: nothing is to be written there, by this skill or by hand." It is worded as a condition, because 2a's handoff-path gives 2 for all three causes. A new case carries A54's own words on stderr and pins that sentence.

14. F14 (SHOULD 1, option (b)). The skill builds the new file, and proves the old one survives. The session writes ONLY its new top block, to $block_file. Block 2 then:

    • builds $prepared_file as { cat -- "$block_file" && printf -- '---\n\n' && cat -- "$handoff_file"; }, the layout write-handoff --prepend makes;
    • reads the old size with wc -c (spaces stripped, shape-checked as digits), and checks tail -c "$hf_old_size" -- "$prepared_file" | cmp -s - "$handoff_file";
    • sends only a build that proves out. A build that does not (a short copy, a failed cat) is HANDOFF NOT WRITTEN, no call, the block file named for the report.

    An empty $block_file is no block, and nothing is sent; a whole file typed into $prepared_file by hand, the old habit that let a session drop the history, is overwritten by the build or never sent. The size is read at build time, so the check is "the build kept the file whole"; a file that moved since block 1's digest is still the verb's 7 (F16, mutant I). Option (a) is question 1.

15. F15 (NITs 1-4).

    • NIT 1: hf_subject="handoff($lane@${ws:-unknown}): PAUSED, ${why:-handoff}", then LC_ALL=C tr '[:cntrl:]' ' ', as 2b's lane-handoff spells the same act's subject (subject_text, at 37b8806).
    • NIT 2: the 0 arm is handoff written: <path> (the note above, from write-handoff, says what was committed and where it was pushed). It never says "pushed from the lane checkout" or "never committed", because an Amendment 8(d) handoff is committed and pushed in its own top level (604: S2 governs).
    • NIT 3: step 1's comment, the $ws_missing paragraph and step 4's (c) comment no longer call step 2's write a commit "in the LANE'S OWN repository". Each says the write is write-handoff's, in the lane's own checkout, and "not one of the writes the helper refuses for want of a workstation" (it is not in the dispatcher's list at lanes-edit.sh:16418).
    • NIT 4: the composite asserts are split.

16. F16 (rv3's mutants). Of the twelve mutants run this round, nine were killed by tests already there, and three survived, as rv3 and w3-c6 expected. Each survivor got a stub test, red against its mutant and green at the head (see "Mutants"):

    • A (the digest's shape check dropped): a sha256sum that answers with an error word, upper case, or 63 digits gives no digest, so no call is made and step 4 says the handoff was NOT refreshed;
    • E (no sha256sum, only shasum): where both tools are there, sha256sum is asked, in the order of the helper's own lane_handoff_digest; a shasum that answers otherwise is never asked;
    • I (the digest read again at the call): where the file moves between the blocks, the call still carries block 1's digest, of the bytes the session read and wrote its top block from. The verb then finds other bytes and refuses (7), rather than taking a top block written from a file that is no longer there.

17. F17 (981, MUST): option (a), on lane 3's word for the plan. Step 2's one call is LANES_LANE="$lane" "$L" write-handoff "$lane" --prepend "$block_file" --subject "$hf_subject".

    • Block 1 reads no digest and makes no prepared file. Block 2 builds and proves nothing itself: the verb's --prepend builds <block>---, a blank line and the old file under the checkout's lock, from the bytes S3 has just fast-forwarded, and proves the block, the rule and the tail.
    • New arms: 64 ("end it with one (echo >> <block file>) and run this block once more, once"), and a 7 that is a restart's ("Do not retry: that restart writes this handoff"), with a note for the verb's in-lock "changed before publication".
    • F14's build and the stub tests for mutants A, E and I went with the digest. The real tests now show that a peer's edit pushed between the blocks, and a lane checkout behind origin, are written at the first call, with the peer's edit kept under the new block.
    • New real cases: a block with no final newline is 64, with nothing written or published, and once an echo gives it a newline, block 2 writes it whole; an active restart is 7.

18. F18 (982). The 6 arm says, in the verb's words after 604, where the commit is kept, or that there is none: on HEAD of the lane checkout, named; for an Amendment 8(d) handoff, in its own repository; or nowhere, where its add or its commit failed. A new real case covers an 8(d) handoff whose push fails there: exit 6, the commit is in the other repository, and neither the lane checkout's HEAD nor the register's origin moves.

19. F19 (983): a kept top block goes into the handoff by the one call, never by a hand edit.

    • Block 1 makes $block_file whatever handoff-path answered, so a block kept after a failed read is on disk, and each failure arm prints block_file=. Its keep message names the call in lane 3's form, LANES_LANE=<lane> lanes-edit.sh write-handoff <lane> --prepend <block file> --subject "<subject>", and says block 2 prints it filled in. Block 1 has no subject, and computing one there would add values to carry across shells (F20).
    • Block 2 builds the call, hf_call, with each word single-quoted by sed, and prints it on a line of its own after the kept message and in the not-called arm. That quoting gives the same bytes under bash and zsh; zsh reads a quote-swapping ${var//…} differently, so the expansion is not used. A test runs the printed line as printed and checks it makes exactly the call the block makes, for a why holding a quote, a double quote, a $ and a backtick as well.
    • The 601 arm says the file it names is not this lane's handoff, and that the new top block goes to the lane's own handoff once the row's cell is corrected to name it. The arm's printf format is single-quoted, so it carries no apostrophe.

20. F20 (984): every Bash call is a new shell. Block 2's last line is printf 'hf_record=%s\n' "$hf_record", and block 1's failure arms print hf_record= beside block_file=, so a block 2 run in another shell keeps block 1's reason. The paragraph that carries the outcome to step 4 says what to set, quoted:

    • before block 2: L, lane, ws and why as step 1 has them, and each name=value line block 1 printed;
    • before step 4: hf_record from block 2's last line.

    Step 4's other values are not 984's subject and are unchanged.

21. F21 (985). The 2 arm and its paragraph use the helper's term, "another checkout of the register", and keep 8(d)'s "another repository" for 8(d). Beside 601 they name 602 (a relative cell that climbs out of the lane checkout) and 607 (a glob character in the path, which handoff-path refuses since 2a's A60, merged here). The file such a cell names "is not the handoff of this lane".

22. F22 (986). The one-call paragraph's "once … finding 601 … is in" now states the verb's refusals as they stand since 2a's merge: 601, 602 and 607, each a 2 with nothing written, which handoff-path shares, so block 1 meets them first. Every one of write-handoff's cell refusals is a die … 2. The other phrase ("a restart fence's refusal is 7 too, where it is 2 today") went with F17's rewrite of the 7 arm.

23. F23 (answer 6): one set of phrases, "refined on both sides". Step 4's record is:

    • handoff refreshed on a 0;
    • handoff written, NOT published (write-handoff exited <n>) for a 2 or a 6 that wrote the file;
    • handoff written, its publication NOT confirmed (write-handoff exited <n>) for a 3;
    • handoff NOT refreshed (<why>) where nothing was written.

    Lane 3 says "publication NOT confirmed" for "3 only" of the defined exits. Another exit after a write, where the verb said nothing of what it published, keeps the unconfirmed phrase, because it claims nothing either way. 2b's fit (c) takes the same set, and Most reads of a lane's log cannot tell a failed read from a lane with no log: lane-dir, lane-profile, lane-agent, lane-transcript, history, lane-last, binding and lane-trees answer 8 ("none") over a log git could not read (from #290) openRepoTools#303's R7 phrase joins it when R7 lands.

24. F24 (INFO 990). A 0 may commit nothing: under LANES_NO_GIT=1, for an 8(d) handoff in no git work tree, or for a clone of the register not beside W. Since 604 the verb's note says so in each case. The 0 arm now ends "(the note above, from write-handoff, says what was committed and where it was pushed, or that nothing was committed)". The record of a 0 stays handoff refreshed: it claims no commit, and it is lane-handoff's phrase for the same act. 2b's 721 and 728 took the same line for lane-start and lane-handoff under LANES_NO_GIT=1.

25. F25. 2a' is merged, and the code leg's main with it. Main named 2a' (2b1a232: slice 2a's head with 1b', 1a' and the code leg's main 577110e). git merge-tree and git merge --no-ff found no conflict (tree 4a81608), and the merge is 95c52cc, worded as e7bae8e is. From the merge base 1320847 it brings 31 files (7999 lines added, 319 removed) and none of this slice's three files: git diff 2a420e0 HEAD over them is empty. It brings .gitattributes and LICENSE, which clears the two failures the rebuilt base gave this branch ("Stacked on"). This PR's diff over 2a' is the same three files with the same counts as over 1320847: 234 lines added and 71 removed, 4 and 3, 1114 and 380.

26. F26. 2b' is merged, so this branch contains 2b for the one sitting. Lane openRepoTools-3 ruled (Lane writers commit first and sync second, so a pull that refuses or conflicts strands the commit and later writes stack on it: fast-forward before the edit, and refuse before committing (fail closed) openRepoTools#198, comment 6724194619) that slices 1b, 2a, 2b and 3 land in one sitting under one register HOLD per leg, each by merge commit. A HOLD goes stale after 30 minutes, so no step may need a CI re-run: each step's merge tree must equal its own tested head's tree. This branch at 95c52cc did not contain 2b, so its step would not have been equal. Main named 2b' (a44b9d2, Amendment 23 act 2, slice 2b: lane-start and lane-handoff write the Rule 3 stamp and the PAUSED block with one write-handoff through the lane's checkout, W moves only by fast-forward, and a launch refuses only at a restart's fences #20: slice 2b on 2a', 1b', 1a' and the code leg's main 577110e). git merge-tree --write-tree 95c52cc a44b9d2 and git merge --no-ff a44b9d2 found no conflict (tree bebe083), and the merge is 6b81f19, worded as 95c52cc is. From the merge base 2b1a232 it brings 15 files (2123 lines added, 537 removed): lane-start, lane-handoff, their tests and golden files, tests/test_lane_helpers.sh, tests/test_supervised_restart_regressions.py, and tests/test_repo_hygiene.py. It touches one of this slice's three files, by one line: tests/test_handoff_skill_80_85.py, in _lane_handoff_writes (a helper this slice does not touch), where 2b' binds handoff_record in the stand-in script. skills/handoff/SKILL.md and tests/test_handoff_skill_commit_block.py are the same blobs as at 95c52cc. At the merge, this PR's diff over 2b' is the same three files with the same counts as over 2a': 234 lines added and 71 removed, 4 and 3, 1114 and 380. A dry run of the whole sitting, offline (each head merged into a simulated main with git merge-tree, in the ruled order, from the code leg's main 577110e, slice 1a's Every register write goes through its lane's own checkout <W>-lanes/<lane>/, where lane-start and lane-end read the lane's row; a LANES_REPO naming W refuses; locks name their holder's container; refresh-workspace fast-forwards W (Amendment 23) #16 first and the two spec-leg steps between), finds no conflict and, for every code step including this one, a merge tree equal to its head's own tree (this PR's at the merge: bebe083), so no step needs a CI re-run. No fix beyond the merge was made.

27. F27. Lane 3's answer 3 is made here, and the module's stand-in for it is retired. Answer 3 left the entry "skills/handoff/SKILL.md" and 2b's hygiene comment ("the skill … joins it then") to one edit, made with whichever of 2b and this PR lands second. F7 had left _NO_PULL_FILES alone because 2b edits the same line. The sitting lands 2b first and this PR second (F26), so the edit is this PR's, in one commit, 7690a1f:

    • _NO_PULL_FILES gains "skills/handoff/SKILL.md" as its fourth name, and the comment above it, which said the skill "still pulls until its slice", says in the past tense that the skill is asserted in slice 3, whose top block is write-handoff --prepend's now;
    • the module's test_the_skill_never_pulls_with_rebase_outside_a_comment, F7's stand-in "until the third name goes in", is retired in the same commit. It was read against the generic test_no_lane_writer_pulls_with_rebase and asserts nothing more: the same pattern, the same filter (a line that is not a comment) and the same file, skills/handoff/SKILL.md under the code root, read as UTF-8. The generic test also has its own cases of what the pattern reads (test_the_no_pull_rule_reads_what_it_should, 7). Its own docstring said the file list takes the skill at the merge.
    • Red first, with one mutant in a scratch worktree at 6b81f19, never the branch's: git pull --rebase origin main appended to the skill, outside a comment. With the tests as they were, the generic test passed on its three names and only the stand-in failed, so the entry was the missing part. With the entry added and the stand-in gone, test_no_lane_writer_pulls_with_rebase[skills/handoff/SKILL.md] failed at line 1118 ("still runs or prints a rebasing pull outside a comment"). At 7690a1f, with the skill unmutated, all four pass.
    • The dry run of the sitting is repeated at 7690a1f: no conflict, and every code step's merge tree equals its head's own tree; this PR's is ec31abd.

28. F28. 2b'' is merged, and with it A61. CI on this PR at 95c52cc failed two cases and passed 3734: the two other-owner cases of test_a_clone_git_cannot_read_is_never_taken_for_no_repository, in 2a's tests/test_a23_write_handoff.py, which this branch carries through 2a' and 2b'. CI's git 2.56.0 read the clone that the case makes unreadable. Slice 2a's writer fixed them as A61 (56a9b87, test-only, that one file, 32 lines added and 2 removed): the case sets GIT_CONFIG_NOSYSTEM=1 beside git's test hook, and skips, saying why, where git still reads the clone. It merged A61 into 2b as 4031100 (2b''), a --no-ff merge of 56a9b87 into a44b9d2. Main named 4031100. git merge-tree --write-tree 7690a1f 4031100 and git merge --no-ff 4031100 found no conflict (tree fdf667e), and the merge is f2340ad, worded as 6b81f19 is. Against 7690a1f it changes tests/test_a23_write_handoff.py and no other file, none of this slice's four. This PR's diff over 2b'' is the same four files with the same counts as over 2b'. The dry run of the sitting is repeated over the new chain (slice 2a at 56a9b87, slice 2b at 4031100, this head): no conflict, and every code step's merge tree equals its head's own tree; this PR's is fdf667e.

Lane 3's answers and the INFO items

1. Option (a): taken (F17). Lane 3 flags Amendment 23 S4.4's parenthetical ("the skill's publish-handoff", a whole-file write) to Brett for an addendum. With (a), the skill's write replays as an edit. That wording does not hold this slice.
2. --create: kept (F2). The cell is read first, so a lane with no row clones nothing; a case shows it.
3. _NO_PULL_FILES: made in this PR, at the merge of 2b'. The entry "skills/handoff/SKILL.md" and 2b's hygiene comment ("the skill … joins it then") change in one edit, made with whichever of 2b and this PR lands second. 2b' is merged into this branch (F26), and the sitting lands this PR second, so the edit is this PR's: one commit, 7690a1f (F27). _NO_PULL_FILES lists lanes-edit.sh, lane-start, lane-handoff and skills/handoff/SKILL.md, and its comment says the skill joins it in slice 3. The module's stand-in test for the entry goes with it (F27).
4. handoff-path stays a read. With (a), the behind-origin case is gone: the first call writes.
5. One install act, at the cutover. The install that brings act 2's helper brings the skill in the same step. It also updates the ~/projects/xFactory/lanes-edit.sh fallback target (SKILL.md:59) and the copy workBenches vendors. A new skill on an old helper loses the refresh, but says so. An old skill on a new helper commits, pulls and pushes from W (282). This is an ordering note for the cutover; no file of this slice changes for it.
6. One set of phrases: taken on the skill's side (F23).

• 988: errexit holds for the cases Amendment 23 act 2, slice 3: the handoff skill locates its file with handoff-path and writes it with ONE write-handoff --whole call from the lane's own checkout, so it spells, commits in, pulls and pushes no checkout of its own (#198) openRepoTools#311 adds.
• 989: the temporary files stay in TMPDIR. It is now one block file per step 2, made on every outcome of block 1 (F19).
• 990: F24.
• 991: handoff-path's glob path is closed by 2a's A60, merged here; the 2 arm names 607 (F21).
• 992: Most reads of a lane's log cannot tell a failed read from a lane with no log: lane-dir, lane-profile, lane-agent, lane-transcript, history, lane-last, binding and lane-trees answer 8 ("none") over a log git could not read (from #290) openRepoTools#303's R7 (7d43e53, lane 3's approval of the twin lines, 651) and this PR both rewrite the skill's twin lines, so whichever lands second is re-cut against the other. Most reads of a lane's log cannot tell a failed read from a lane with no log: lane-dir, lane-profile, lane-agent, lane-transcript, history, lane-last, binding and lane-trees answer 8 ("none") over a log git could not read (from #290) openRepoTools#303 is not one of act 2's six re-homed drafts.

What changed

From a44b9d2, 2b's head (2b'):

• skills/handoff/SKILL.md (234 lines added, 71 removed):
  • Step 2's opening prose says the verb is the lock, the sync to origin, the build and its proof, the atomic replace, the commit by pathspec with the Rule 5 Lane: trailer, the push with no pull, the read-back and the replay of a refused push. The skill holds no lock and runs no git.
  • Block 1 (F1, F2, F3, F10, F19, F20, F21) says where the handoff is and what each exit of the read means. It makes the block file on every outcome, and prints what block 2 needs.
  • Handoff skill: commit the handoff in the checkout it was published in, by its own path, and refuse foreign staged entries and in-progress operations (#197) openRepoTools#199's block is replaced by block 2 (F4, F5, F17 to F20, F23, F24): the one --prepend call, an arm for each exit, the record for step 4, the printed call for a kept block, and hf_record= as its last line. What went: the checkout resolved from $LANES_REPO and then workspace-root; the refusals for an operation in progress and for a staged entry the handoff did not make; git add and git commit by pathspec; git pull --rebase and git push; rebase --abort. Those refusals are now the verb's own, made before anything is committed (2).
  • The prose after block 2 keeps R-A11-11, a swap is never left unwritten, says what the verb does on a refusal (2) and on a refused push (6), and says what step 4's line records and what each new shell must be given (F12, F20, F23).
  • Step 1, the $ws_missing paragraph and step 4 (F8, F12, F15).
• tests/test_handoff_skill_commit_block.py, rewritten (1104 lines added, 380 removed): 180 tests of the two blocks, the printed call and step 4's line. F27 retired one test of the 181: the rebasing-pull rule is tests/test_repo_hygiene.py's.
• tests/test_handoff_skill_80_85.py (4 lines added, 3 removed): its two step-4 preludes bind hf_record (F12).
• tests/test_repo_hygiene.py (5 lines added, 4 removed): _NO_PULL_FILES takes the skill as its fourth name, and the comment above it says why (answer 3, F27).

Tests

Each run was one pytest process. Every LANES_*, LANE_*, TMUX*, CLAUDE_*, GIT_*, GH_*, GITHUB_*, SONAR*, OPENREPOTOOLS_* and WORKBENCHES_* variable was unset. A refusing gh stub came first on PATH, with GH_TOKEN=bogus, GIT_SSH_COMMAND=false and GIT_CONFIG_GLOBAL=/dev/null. Nothing reached a real register, W or GitHub. At this head, f2340ad:

file	result
tests/test_handoff_skill_commit_block.py	180 passed
tests/test_skill_shell_blocks.py	6 passed
tests/test_handoff_skill_80_85.py, tests/test_handoff_skill_72_80.py and tests/test_handoff_skill_98_99_100.py, one process	123 passed
tests/test_repo_hygiene.py	240 passed, 18 skipped
tests/test_install_skill_and_hook.py, tests/test_openrepotools_command.py and tests/test_tests_workflow.py, one process	172 passed, 28 skipped
2b's tests/test_a23_lane_start.py	24 passed
2b's tests/test_a23_lane_handoff.py	13 passed
2b's tests/test_a23_lane_start_read.py	10 passed
2b's tests/test_lane_start_row_stamp.py	3 passed
2b's tests/test_lane_start_claude_current.py	34 passed
2b's tests/test_a23_write_handoff.py	179 passed

The first five rows are this slice's set, run at 7690a1f, except tests/test_repo_hygiene.py, which was run again at the head. The last six are 2b's modules, each in its own process: tests/test_a23_write_handoff.py was run again at the head, because F28 changed that file, and the other five at the merge 6b81f19, which neither F27 nor F28 touched (F27 changed tests/test_repo_hygiene.py and tests/test_handoff_skill_commit_block.py, F28 only tests/test_a23_write_handoff.py). tests/test_handoff_skill_commit_block.py has one test fewer than at 6b81f19 (181; F27). tests/test_repo_hygiene.py has five more cases than at 95c52cc (235): 2b' adds lane-start and lane-handoff to _NO_PULL_FILES and a carry-promise case for each (4), and F27 adds the skill to _NO_PULL_FILES (1). No test failed. The skips are the same 18 and 28 as at 95c52cc: files that belong to the assembly root or the spec root, which this standalone code checkout lacks, and the pinned openRepoShape submodule, which is not checked out. The last six had none. The two other-owner cases that A61 repairs pass here, on git 2.43.0; they failed only on CI's git 2.56.0, so CI is the proof of that fix.

The module's 180 tests (181 before F27 retired one), by what they hold (most run in bash and zsh):

• The call and its subject (13):
  • --prepend <block file> --subject <s> and nothing else, under LANES_LANE the lane (2);
  • no digest is read and no new file is built (2);
  • the subject: one line, control characters as spaces, unknown and handoff where nothing was given, a dash kept (8);
  • the variables the call names are defined in block 1 (1).
• No checkout of its own, and the text's rules (11):
  • no spelled checkout, and an ambient LANES_REPO changes nothing (2);
  • both blocks parse, every write names its lane, the refusal text keeps R-A11-11, and the write is the verb's (4); the rule that no line of the skill runs a rebasing pull is tests/test_repo_hygiene.py's since F27;
  • the five pins this round added: no hand edit (983), the helper's terms (985), the one-call paragraph (986), what to set in each shell (984), and the record phrases (F23).
• Each exit of the verb (44): what each of eleven outcomes says and never says, with the swap going on and one call only (22); where nothing was written, the block file is named for the report (22).
• A kept block and the one call (14): the printed line, run as printed, makes the block's own call, for six outcomes (12), and for a why holding quotes, a $ and a backtick (2).
• Block 1's read (30):
  • not found, three shapes (6);
  • a read that failed, nine shapes, among them an older helper and 601's, 602's and 607's refusals (18);
  • only a 2 is asked again, and never with --create (6).
• What is never sent (2): a top block the session never wrote.
• Step 4 (46):
  • its three register writes carry LANES_LANE (4);
  • its register line says what step 2 did, thirteen outcomes (26);
  • a step 4 that step 2 never reached never claims a refresh, under set -u too (4), and nor does one run after block 1 alone (2);
  • block 1, block 2 and step 4 each run in its own shell, carrying only what they print (10).
• The real lanes-edit.sh (20), in slice 2a's Box (a bare origin, W, the lane's row and handoff, LANES_ROUTE_WRITES=1, and a gh and a tmux that refuse):
  • the handoff is pushed from the lane's own checkout with the Lane: trailer, and W is untouched, routed and through the seam (4);
  • a peer's edit pushed between the blocks is kept under the new block (2);
  • a checkout behind origin is written at the first call (4);
  • a block with no final newline is 64, then written once it has one (2);
  • an active restart is 7 (2);
  • a foreign staged entry is 2, with the file written and uncommitted (2);
  • an 8(d) handoff whose push fails there is 6 (2);
  • a lane with no row has nothing to write, and nothing is cloned (2).

Not run here: the shell suite (tests/test_lane_helpers_suite.py) and the whole of tests/test_supervised_restart_regressions.py; CI's tests job is the suite of record. A static check stands in for the part of the shell suite that reads this skill. It ran every has and hasnt that tests/test_lane_helpers.sh asks of the skill's text (45, on $SWSK_TEXT and $hfsk) at 9da8a26 (old 1913db9), at 2a420e0, at 95c52cc and at this head, with the suite file of this head (2a' and 2b' changed it), and compared the seven extracts the suite takes of the file with awk and grep:

• 44 answer ok at all four revisions. The 45th is a two-line string (line 6116 of the suite file at this head), which the checker cannot split; run on its own by hand, it answers ok at all four;
• the seven extracts are byte-identical across the four. The skill's bytes at 2a420e0, at 95c52cc and at this head are the same blob (f5cf9f4).

Mutants

This round. Each mutant was one edit of the skill in a second worktree, never in the branch's worktree. Each was run against the tests predicted to kill it, and the skill was restored after each (cmp). 987's two survivors were also run against the whole module as committed before 987:

item	mutant	result
981	the 64 arm dropped	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[block-with-no-final-newline-bash]
981	the block file's guard -s made -e	killed by test_a_top_block_the_session_never_wrote_is_never_sent[none-bash]
982	the 6 arm's "$hf_path" made "$hf_out"	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[kept-on-head-bash]
983 A	the printed call's --prepend names $handoff_file	killed, 14 failed
983 B	the printed call left unquoted	killed, 14 failed
983 C	block 1's keep message says "at the head of the handoff by hand" again	killed, 5 failed
983 D	the kept arm prints no call	killed, 8 failed
984 A	block 2 prints no hf_record=	killed, 10 failed
984 B	block 1's failure arms print no hf_record=	killed, 4 failed
984 C	the paragraph drops "EVERY BASH CALL IS A NEW SHELL"	killed, 1 failed
985 A	the 2 arm says "belongs to another repository"	killed, 7 failed
985 B	the 2 arm drops 602	killed, 6 failed
985 C	the paragraph says "belongs to another repository"	killed, 1 failed
986 A	"once it is in, so is" put back	killed, 1 failed
986 B	the one-call paragraph drops 602	killed, 1 failed
987 M1	block 1's != 0 && != 8 made != 8	survives the module as committed at 11c854f (176 passed); killed by the zero-with-no-file row (2 of 2 red)
987 M2	step 4's ${hf_record:-…} made ${hf_record-…}	survives 11c854f's module (176 passed); killed by test_a_step_4_after_block_1_alone_never_claims_a_refresh (2 of 2 red)
F23 A	no "NOT published" for a 2 or a 6	killed, 4 failed
F23 B	a 3 said "NOT published"	killed, 4 failed
F24	the 0 arm without "or that nothing was committed"	killed, 2 failed

Earlier rounds.

Round 1, at b599ed9: 15 one-line mutants of skills/handoff/SKILL.md, each run against the module with -x. All 15 were killed: m1 (no --expect-digest), m4 (no --create), m7 (write-handoff without LANES_LANE), m12 (a placeholder subject), m14 (publish-handoff back) and m15 (no --whole) by the argv test; m2 and m8 (append-line or set-row-state without LANES_LANE) by test_step4_writes_carry_LANES_LANE; m3 (the workspace-root fallback back), m9 (a pull --rebase line) and m13 (a cd to the checkout) by test_no_spelled_checkout_and_no_workspace_root_fallback; m5 (no control-character tr) by the subject test; m6 (exit 2 said as pushed) and m11 (exit 7 said as written) by the exits test; m10 (the prepared-file guard weakened) by the never-sent test.

Round 2, at a972899: rv3's ten planned mutants, plus one for SHOULD 3 and one for SHOULD 1. Each was one edit of the skill in a git archive copy, never in the worktree. Each was run first against the test predicted to kill it; where none was predicted, or that test passed, the whole module was run with -x. The skill was restored after each.

id	mutant	result at a972899
A	the digest's shape check dropped	survived the module (138 passed); killed by the new test_a_digest_that_is_not_a_sha256_is_no_digest_and_nothing_is_sent (6 of 6 red)
B	hf_path left unsplit	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[pushed-bash]
C	the block file's -s made -e	killed by test_a_top_block_the_session_never_wrote_is_never_sent[none-bash]
D	the * arm never says the file is written	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[written-then-failed-bash]
E	no sha256sum branch, shasum only	survived the module (138 passed); killed by the new test_sha256sum_gives_the_digest_where_shasum_is_there_too (2 of 2 red)
F	"Do not call it again" made "Call it again"	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[refused-after-writing-bash]
G	the 3 arm says "It is published."	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[pushed-not-confirmed-bash]
H	the 2 arm's -n "$hf_out" made -z	killed by test_each_exit_of_the_verb_is_said_and_the_swap_goes_on[refused-after-writing-bash]
I	the digest read again at the call, in block 2	survived the module (138 passed); killed by the new test_the_digest_sent_is_block_1s_even_where_the_file_moved_before_the_call (2 of 2 red)
P	log PAUSED without LANES_LANE	killed by test_step4_writes_carry_LANES_LANE[unset-bash]
SHOULD 3	block 2's [[ "$hf_rc" != 0 ]] made ==	killed by test_step4_register_line_says_what_step_2_did[pushed-bash]
SHOULD 1	the cmp against the old file dropped	killed by test_a_new_file_that_lost_the_old_one_is_never_sent[short-bash]

rv3 expected D, F, G and I to survive on b599ed9; D, F and G were killed by the pins this round added (F13), and I needed the new test. No mutant of the integration tests was run.

F27's mutant. One edit of the skill in a scratch worktree at 6b81f19, never the branch's: git pull --rebase origin main appended outside a comment (line 1118). With the tests as they were: test_no_lane_writer_pulls_with_rebase passed on its three names (the hole), and test_the_skill_never_pulls_with_rebase_outside_a_comment failed. With the skill's entry added and that test retired: test_no_lane_writer_pulls_with_rebase[skills/handoff/SKILL.md] failed, and the other three passed. At 7690a1f, the skill unmutated: all four pass.

Questions for lane openRepoTools-3

1. F19's printed call. Block 1 names the call in your form, with placeholders, because it has no subject. Block 2 prints the call filled in, each word single-quoted by sed, and a test runs the printed line. Is a runnable line the shape you want, or should the messages name only the form?
2. F23's other exits. An exit other than 0, 2, 3 or 6 after a write keeps "its publication NOT confirmed", because the verb said nothing of what it published. Is that the reading of "for 3 only" you meant?

Not changed

• lane-start, lane-handoff and lane-end: this PR's diff over 2b' touches none of them. Slice 2b makes the write-handoff and handoff-path calls of the first two, and takes F23's phrases in its fit (c); it is merged here through 2b' (F26). Slice 4 is lane-end's.
• lanes-edit.sh, which is slice 2a's; the docs are the spec leg's.
• Steps 1, 3 and 5 of the skill, step 2's row read and top-block template, and step 4's writes, apart from the record's phrases.
• skills/lane-swap/SKILL.md, the alias, which restates no step.
• The installed copies and the vendored one. Nobody ran openRepoTools --install or --uninstall, and nothing under ~/.claude or ~/.claude-profiles/shared was read or edited.

Refs opensoft/openRepoTools#198

🤖 Generated with Claude Code

[sourcery-ai]

Reviewer's Guide

UI

Update the handoff skill to locate the lane’s handoff, prepare only a new top block, and delegate the write and publication to one write-handoff --prepend call while reporting its outcome through step 4.

• skills/handoff/SKILL.md L272-282, L334-418, L493-615 (+6 small edits)

Tests

Replace the tests for the skill’s former manual commit flow with coverage for handoff lookup, the single prepend call, its outcomes, carried state, and real-helper behavior.

• tests/test_handoff_skill_commit_block.py L2-50, L68-90, L128-1207 (+7 small edits)

Add the skill to the repository’s no-rebasing-pull checks and update their explanatory comment.

• tests/test_repo_hygiene.py L3292-3297

Set the handoff outcome in step-4 test setup so the register-line assertions reflect the new carried result.

• tests/test_handoff_skill_80_85.py L210-213, L406

---

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.

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

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

See analysis details on SonarQube Cloud