REPORT — phase6-supervisor-cleanup-implementer
STEP: phase6-supervisor-cleanup (Phase 6: absorb the leaf-cleanup probe — F19)
REV: c6d2d7adb1d5f67c99b31d3a976d6763dfdfcdc5   FINAL: 584e63e08698b2a65a0df0fd85060923afc0e2ee
CHANGED: scripts/supervise_run.py (+6/-2) — the container-boundary comment's removal sentence only: "The leaf is per supervisor process and removed when the child is done" devolves to name the clean-child corner it does not cover (`:106`-`:111`) — a process that outlived a clean child's exit was never in any kill's surface, so a leaf still occupied after the bounded removal budget is left standing by construction, and the deadline contract does not cover that path. `_container_close`, its budget (`CONTAINER_REMOVALS`/`CONTAINER_REMOVAL_SETTLE`), and the sweep loop are untouched.
CHANGED: tests/test_phase6_supervisor.py (+65/-1) — the absorbed leaf-cleanup pin (`test_the_deadline_drive_leaves_no_container_leaf`, `:730`, `@pytest.mark.timeout(120)`), the review probe's shape moved in: a full escaped-forker deadline drive at `--budget 0.4` with the boundary parent's leaf set diffed across one fresh 5.0s window; the leaf-listing helper (`_boundary_leaves`, `:395`) and its prefix (`LEAF_PREFIX`, `:153`), plus `import glob`; the docstring's shape bullet and red block recording F19.
VERIFIED: `scripts/check-scope c6d2d7a 584e63e08698b2a65a0df0fd85060923afc0e2ee docs/research/phase6-supervisor-cleanup-brief.md` — exit 0, prints `claimed: scripts/supervise_run.py tests/test_phase6_supervisor.py`, `tripped: none`, `scope: ok (3 path(s) in c6d2d7a..584e63e08698b2a65a0df0fd85060923afc0e2ee)`. The range diff is exactly the two IN SCOPE files at FINAL plus the brief commit (`b4a7867`)'s own file; the work commit `584e63e` was written by this step's own session.
VERIFIED: F19's red at REV `c6d2d7a`, on a scratch with `scripts/supervise_run.py` cut from `git show c6d2d7a:…` and diff-verified byte-identical (sha256 `97d857f592b286434a820d1148a5cba75d1c97eb37b9a6492fff2bb80c2010ea`), the delivered module copied in uncommitted, and `_container_close`'s removal loop disabled (`for _ in range(0)`): `.venv/bin/python -m pytest -q tests/test_phase6_supervisor.py::test_the_deadline_drive_leaves_no_container_leaf tests/test_phase6_supervisor.py::test_the_deadline_kill_reaches_a_session_escaped_forkers_tail_forks tests/test_phase6_supervisor.py::test_the_deadline_kill_reaches_a_predecessor_exited_double_forked_sleeper` — `1 failed, 2 passed in 9.08s`. The pin's leaf-set assertion fails at `tests/test_phase6_supervisor.py:757` (`assert not remaining`): `AssertionError: leaf(s) left standing after the deadline drive: ['/sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service/app.slice/app-org.gnome.Terminal.slice/tmux-spawn-f8732029-895b-4520-aba3-cb18b4d59338.scope/orchestrator-supervisor-8gxmwkzg'] — the delivered leaf-removal claim (…) is unheld`; both boundary pins stay green over the same mutant (`0.78s` escaped-forker, `2.36s` double-forked sleeper). No error, no collection failure, no hang — the assertion is the thing that failed, the named class the F19 review measured (`1 failed in 6.01s`).
VERIFIED: ACCEPTANCE at FINAL, each command as run with its own printed summary — `scripts/check-tests --fast`: `980 passed, 108 deselected in 95.88s (0:01:35)`, exit 0 (the REV baseline `979 passed, 108 deselected in 95.17s`; the delta is exactly the one absorbed pin, no test dropped or deselected). `.venv/bin/python -m pytest tests/test_phase6_supervisor.py --durations=5`: `14 passed in 11.92s`, slowest five `3.51s call test_the_deadline_kill_reaches_the_tree_at_a_fixed_time_and_the_whole_surface_after_the_exit`, `2.36s call test_the_deadline_kill_reaches_a_predecessor_exited_double_forked_sleeper`, `2.27s call test_killed_child_is_reaped_marked_timed_out_and_drives_recovery`, `0.78s call test_the_deadline_drive_leaves_no_container_leaf`, `0.78s call test_the_deadline_kill_sweeps_a_racing_forker_to_quiescence` — the absorbed pin sits inside the existing pins' envelope, no budget raised, and its `120`s `@pytest.mark.timeout` is set from these walls plus the 5.0s measurement window with margin for a loaded host (rule 15). `scripts/check-static`: exit 0 — gated `All checks passed!`; advisory `Found 104 errors.` unchanged. `scripts/check-docs`: `392 Total / 180 Unique / 392 OK / 0 Errors`, exit 0 (the brief's drafting baseline `391 Total`; the delta is the brief file's own links, unique count unchanged and every link OK).
VERIFIED: the boundary measured, not assumed — cgroup2 mounted at `/sys/fs/cgroup`, the running process's own cgroup the tmux-spawn scope under `user@1000.service` with a writable `cgroup.procs`, so `supervise_run._container_boundary()` returns that scope and both the absorbed pin and the two boundary pins run (no skip). Green at FINAL is the delivered `_container_close` removing the leaf inside the 5.0s window (the pin's `0.78s` call), and three `orchestrator-supervisor-*` leaves leaked by the mutant scratch drives were pruned by hand afterwards, the delegation left at `0`.
VERIFIED: the work commit's own gate run before it landed — the repository's pre-commit hook ran `scripts/tables.py` (table verification passed, no regeneration) and `scripts/check-tests --fast --parallel` (`949 passed in 24.63s`) plus the runner-spawning modules it runs after (`31 passed in 12.40s`), all green.
NOT VERIFIED: none
FINDINGS:
  F19 | SEVERITY: P2 | ORIGIN: CODE | STATE: fixed
  The container leaf's removal is claimed (`scripts/supervise_run.py:106`-`:107`, "removed when the child is done") and demonstrated by hand at FINAL (`leaves: []` after every measured drive) but held by no delivered pin: under a `_container_close`-leaks mutant both boundary pins stayed green 2 of 2 drives while empty leaves stood under the boundary parent, so a removal regression would go unheld by the delivered suite. Folded in: the docstring's removal sentence is the one over-claim corner — the clean-child corner (a child exiting 0 with a document while an adopted orphan outlives it) leaves one leaf standing after `_container_close`'s bounded 20×50ms wait, because the orphan's survival predates the boundary and the deadline contract does not cover the clean path.
  FIXED: the absorbed pin `tests/test_phase6_supervisor.py::test_the_deadline_drive_leaves_no_container_leaf`; red at REV `c6d2d7a` under the leak defect on the byte-verified scratch (sha256 `97d857f5…`), command and `1 failed, 2 passed in 9.08s` above, the named failing assertion `assert not remaining` at `tests/test_phase6_supervisor.py:757`; the two boundary pins stayed green over the same mutant. Green at FINAL in the module battery (`14 passed in 11.92s`). The docstring devolution lands in `scripts/supervise_run.py:106`-`:111` with no kill-surface change, and the review probe file rides untouched.

  F22 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The brief's review-block copy of the carried F17 finding is truncated mid-sentence: `docs/research/phase6-supervisor-cleanup-brief.md` reads "…Next action is the planner's: a later committed brief's text correction — the boundary sentence... (line truncated to 2000 chars)" (the marker is literally in the committed file; the same artifact also sits in `docs/research/phase6-supervisor-boundary-review-brief.md`). The F17 item itself is intact elsewhere in the same brief (`:20` and `:38`), so nothing is lost, but a verbatim copy of the review-block copy propagates `… (line truncated to 2000 chars)` into the next report; the planner's long-block copy is the source. This report carries F17's intact text.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief's text correction lands; the truncation is prose only and no code or pin rides on it.
SHAPES: The brief's one named shape — the leaf-cleanup shape (F19): a deadline drive's container leaf is gone after the supervisor exits — is built as the absorbed pin, red at REV under the leak defect and green at FINAL, so no probed shape is left unbuilt. The clean-child corner folded into F19 is the docstring's prose devolution, not a shape the brief asks to build (it is out of the deadline path and is `_container_close`'s own documented bounded wait). The boundary-availability skip, the delivery of the boundary in the two boundary pins, and the escaped-forker/double-fork drives are the delivered module's own shapes, re-driven green by the ACCEPTANCE module battery.
TRIPPED: none
PROPOSED ROWS: none
METHOD FRICTION: none
INHERITED:
From `docs/research/phase6-supervisor-boundary-implementer.md`, its `INHERITED` block verbatim:

  Nothing else in the received set is still open: the brief's INHERITED carried F4, F5 and F6 (each fixed at the fixes step), F7 (fixed as recorded in the review that filed it), F9 (fixed at the fixes-2 step), F10 (fixed at the fixes-2 step), F11 and F12 (each `carried`, fixed here with the red evidence above), and F8 (`fixed` as recorded in the grading-seed step, unchanged here). Still open, each copied verbatim with its ID:
    F13 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief names the pin's red as "N consecutive grades of the known-good tree produce non-identical verdicts (PASS on one run, CANDIDATE_TIMEOUT on the next)". In this environment the known-good tree's `gate-check-tests` grade is stable well under the fixture's 60.0s deadline (ten pin runs, 50 grades, ~37–46s each, every grade PASS), so the pin passes at REV. The lottery's grade-flip needs a candidate whose suite fails — a failing tree's hypothesis tests shrink, and the shrinking varies the suite's wall — and the near-deadline flip is the neutralisation test's broken-source candidate (FAIL→CANDIDATE_TIMEOUT, 3/3 at REV). The pin's assertion and the seeded determinism are correct; the brief's stated candidate is simply not the one that flips here.
    FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the pin and the seed land as delivered.

    F14 (P2, ORIGIN: DOCUMENT, carried) — the F8 red evidence is load-borne and the implementer report does not say so; a later actor re-driving the red on an idle host sees green and may conclude the red is chimeric. Next action is the planner's: carry the load condition into the carried F8 block (or a later committed brief's correction), the seed and the pins stand as delivered.

    F15 (P2, ORIGIN: CODE, carried) — killed runs leak intermediate probe trees and no janitor reaps them; the shared tmpfs inode table filled to 3 free and the standing battery's first run died ENOSPC until 81 leaked trees were pruned by hand. Next action is the harness owner's (a tombstone/janitor keyed by the run identity) or a planner ruling that scratch hygiene is each session's duty.

    F16 (P2, ORIGIN: CODE, carried) — the seeded determinism is wall-bounded: at the fixture's 60.0s deadline the near-deadline candidate's seeded grade flips FAIL→CANDIDATE_TIMEOUT under host load (measured once mid-run and once at a 62.44s wall), so the pin's green determinism is stable-half evidence only. Next action is the fixture owner's: raise the grading deadline for near-deadline candidates (the 300.0 default gives a >=5x margin here) or an OWNER ruling that the deadline's load envelope is governed, not deterministic.

    F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief's boundary-fix instruction is internally inconsistent (FINDINGS, F17): the double-fork pin must leave no descendant alive after the exit while the F10 q1e boundary shape must survive the fix, and the two name one live shape (a session-escaped middleman spawning a session-escaped sleeper then exiting before the deadline, the sleeper adopted by init) that no container boundary can kill and spare at once. The GOAL reading was taken (F11/F12 fixed by the container boundary, both pins green at FINAL, no committed discriminating member changed verdict); the boundary this step retires is the named init-adopted orphan, and the new boundary is what the child never forked. Next action is the planner's: a later committed brief's text correction — the q1e-survival sentence, F12's "without also catching the documented boundary" clause, and the boundary sentence in the module docstring this step corrected in code.

From `docs/research/phase6-supervisor-boundary-review.md` — its `INHERITED` block, then each carried finding's block from its `FINDINGS` section, moved verbatim (rule 2 governs the planner's copy of this block; the review's received set is the boundary implementer's INHERITED above plus its F17/F18, F11/F12/F18 fixed at FINAL, F13–F17 carried):

  From `docs/research/phase6-supervisor-boundary-implementer.md`, its `INHERITED` block verbatim:

    Nothing else in the received set is still open: the brief's INHERITED carried F4, F5 and F6 (each fixed at the fixes step), F7 (fixed as recorded in the review that filed it), F9 (fixed at the fixes-2 step), F10 (fixed at the fixes-2 step), F11 and F12 (each `carried`, fixed here with the red evidence above), and F8 (`fixed` as recorded in the grading-seed step, unchanged here). Still open, each copied verbatim with its ID:
    F13 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief names the pin's red as "N consecutive grades of the known-good tree produce non-identical verdicts (PASS on one run, CANDIDATE_TIMEOUT on the next)". In this environment the known-good tree's `gate-check-tests` grade is stable well under the fixture's 60.0s deadline (ten pin runs, 50 grades, ~37–46s each, every grade PASS), so the pin passes at REV. The lottery's grade-flip needs a candidate whose suite fails — a failing tree's hypothesis tests shrink, and the shrinking varies the suite's wall — and the near-deadline flip is the neutralisation test's broken-source candidate (FAIL→CANDIDATE_TIMEOUT, 3/3 at REV). The pin's assertion and the seeded determinism are correct; the brief's stated candidate is simply not the one that flips here.
    FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; the pin and the seed land as delivered.

    F14 (P2, ORIGIN: DOCUMENT, carried) — the F8 red evidence is load-borne and the implementer report does not say so; a later actor re-driving the red on an idle host sees green and may conclude the red is chimeric. Next action is the planner's: carry the load condition into the carried F8 block (or a later committed brief's correction), the seed and the pins stand as delivered.

    F15 (P2, ORIGIN: CODE, carried) — killed runs leak intermediate probe trees and no janitor reaps them; the shared tmpfs inode table filled to 3 free and the standing battery's first run died ENOSPC until 81 leaked trees were pruned by hand. Next action is the harness owner's (a tombstone/janitor keyed by the run identity) or a planner ruling that scratch hygiene is each session's duty.

    F16 (P2, ORIGIN: CODE, carried) — the seeded determinism is wall-bounded: at the fixture's 60.0s deadline the near-deadline candidate's seeded grade flips FAIL→CANDIDATE_TIMEOUT under host load (measured once mid-run and once at a 62.44s wall), so the pin's green determinism is stable-half evidence only. Next action is the fixture owner's: raise the grading deadline for near-deadline candidates (the 300.0 default gives a >=5x margin here) or an OWNER ruling that the deadline's load envelope is governed, not deterministic.

    F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief's boundary-fix instruction is internally inconsistent (FINDINGS, F17): the double-fork pin must leave no descendant alive after the exit while the F10 q1e boundary shape must survive the fix, and the two name one live shape (a session-escaped middleman spawning a session-escaped sleeper then exiting before the deadline, the sleeper adopted by init) that no container boundary can kill and spare at once. The GOAL reading was taken (F11/F12 fixed by the container boundary with both pins green at FINAL, no committed discriminating member changed verdict); the boundary this step retires is the named init-adopted orphan, and the new boundary is what the child never forked. Next action is the planner's: a later committed brief's text correction — the q1e-survival sentence, F12's "without also catching the documented boundary" clause, and the boundary sentence in the module docstring this step corrected in code.

  From the same report, the carried findings' full blocks from its `FINDINGS` section, moved verbatim (the F17 block, complete; F14–F16 ride as complete inline copies above; F13 rides complete above with its FIXED line):

    F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
    The brief's boundary-fix instruction is internally inconsistent: it requires the double-fork pin to leave no descendant alive after the supervisor exits (GOAL, expected dispositions, the pin's spec) while also requiring that "the F10 q1e boundary shape ... still survives it — the review's discriminating member, re-driven, must stay green or the fix over-reaches" — and the two name one live shape. The F10 q1e shape (the fixes-2 implementer's SHAPES reparented-orphan boundary, probed at `--budget 3`, surviving `state=S ppid=3174`) and F12's reported variant (the fixes-2 review's double-forking fixture child) are both a session-escaped middleman spawning a session-escaped sleeper then exiting before the deadline, and F12's own text calls the shape "the named boundary at a higher fork rate"; F11's text likewise says a subreaper catches the shapes but "also catches the documented init-adopted boundary (measured against the F10 q1e shape)". cgroup membership is fixed at fork and is not changed by reparenting, so no container boundary can catch the F12 sleeper and spare the q1e orphan: they are the same process, reached the same way. The reading taken, per the brief's own instruction ("If exactly one reading is consistent, take it and file a FINDING with ORIGIN: BRIEF that names the reading you took"): the GOAL reading — F11 and F12 fixed by the container boundary with both pins green at FINAL — because the OWNER has not ruled (record.md's Owner-rulings section holds no F11/F12 ruling; its Pending section still queues the rule-13 ownership of the shape ruling, and the brief's own conditional is "If the OWNER has not ruled, deliver the container boundary"), so the narrowing branch is unavailable. The q1e clause is satisfied in the only physically possible sense: no committed discriminating member changed verdict (all 13 module pins and both review probes green at FINAL, above). Next action is the planner's: a later committed brief's text correction — the boundary sentence in the module docstring this step corrected in code.
    FIXED: no regression test — the reading is delivered in the work commit and its evidence is the two reds above and the FINAL battery above; the correction itself is a committed brief's prose, which has none.

  Expected dispositions of the received set (rule 8 forms), kept: F11/F12 fixed with red evidence (the pins at `tests/test_phase6_supervisor.py:627`/`:662`, each red at REV on the delivered sweep — re-driven by this review); F13–F16 stay carried; F17 carried; F18 fixed (the guard rides the delivered measurement; the sandbox condition re-driven by this review).

  Added by this review, each carried finding with its ID:
      F19 (P2, ORIGIN: CODE, carried) — the container leaf's removal is claimed and demonstrated but not held by any delivered pin (leak-mutant red, both boundary pins green over it); the committed probe holds the shape. Next action is the next implementer brief's (absorb the probe; devolve the module docstring's removal sentence to name the clean-child corner).
      F20 (P2, ORIGIN: CODE, carried) — the nested-grading survivor class re-sighted once at FINAL (leaked launcher/collect/pytest stack adopted by init, alive 15 minutes past the grade; red-then-green oracle re-drives); the owner is `SandboxRunner._kill` (`src/orchestrator/sandbox.py:1081`, out of scope of every phase-6 brief so far). Next action is the planner's: a brief in scope of the sandbox kill, or a load-envelope ruling folding the corpus's sandbox drives into the F16 disposition.
      F21 (P2, ORIGIN: DOCUMENT, carried) — the implementer report's module-battery line is a widened substitute (supervisor module + review module, `15 passed`) for the brief's documented command, whose own printed line the report never recites; the documented form re-ran green here (`13 passed in 12.46s`). Next action is the planner's: a committed brief or report correction of the carried note.

  F19 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The container leaf's removal is claimed (`scripts/supervise_run.py:106`–`:107`, "removed when the child is done") and demonstrated by hand at FINAL (`leaves: []` after every measured drive), but no delivered pin holds it: under a `_container_close`-leaks mutant (the removal loop disabled on a byte-verified scratch) both boundary pins stayed green 2 of 2 drives while empty leaves of the drives stood under the boundary parent — a removal regression would go unheld by the delivered suite. Folded in: the module docstring's removal sentence is also the report's one over-claim corner — the clean-child corner (a child exiting 0 with a document while an adopted orphan outlives it) leaves one leaf standing after `_container_close`'s bounded 20×50ms wait (measured: exit 0, `recovered: false`, the orphan `state=S ppid=3174`, one leaf holding it), which the `_container_close` docstring honestly names ("A leaf still occupied after the budget … is left standing") — the deadline contract does not cover the clean path, the orphan's survival predates the boundary (nothing killed it pre-boundary either), and what the corner adds is only the standing leaf itself. Next action is the next implementer brief's: absorb the leaf-cleanup pin into `tests/test_phase6_supervisor.py` and devolve the module docstring's removal sentence to name the corner.
  FIXED: no regression test of the delivered module's own — the shape is this review's committed probe (`tests/test_review_phase6_supervisor_boundary.py::test_the_deadline_drive_leaves_no_container_leaf`), green at FINAL (`1 passed in 0.95s`) and red under the leak mutant (`1 failed in 6.01s`); it rides until the delivered module absorbs it as its own pin.

  F20 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The nested-grading survivor class re-sighted at FINAL: this review's first oracle re-drive failed only on the determinism pin's post-run survivor sweep (the assertion at `tests/test_phase3_project_oracle.py:630`) catching a live four-process stack (two `sandbox_launcher.py` in a launcher/shim chain, the `/work/.venv` identity collect runner, the nested `pytest -m not slow`), every member adopted by init (`ppid=3174`), `state=S`, alive 15+ minutes after the grade returned PASS verdicts and the value assertions held — no grade flip, no gate-check FAIL: not the F8/F18 class. All four were SIGKILLed and confirmed gone. The reaping defect's owner is `SandboxRunner._kill` (`src/orchestrator/sandbox.py:1081`–`:1102`): a single capture-then-kill with no sweep to quiescence — the pre-F9 surface the supervisor's own sweep left behind when the phase-6 fixes ported it — and `src/orchestrator/sandbox.py` is OUT OF SCOPE of every phase-6 brief so far. `record.md`'s "left zero survivors … the class is closed by the phase-6 descendant sweep" attribution holds for `scripts/supervise_run.py`'s sweep, not for the corpus's sandbox drives; a second oracle re-drive on the same host otherwise idle returned `6 passed in 536.49s`, so the class is not a standing red — it is the load-borne half the F14/F16 dispositions already govern. Next action is the planner's: a brief in scope of `SandboxRunner._kill` (sweep to quiescence, the supervise_run fix's own pattern) or a ruling folding the corpus's sandbox drives into the F16 load-envelope ruling.
  FIXED: no regression test — the standing survivor sweep that caught the leak (`:630`) is delivered and held; the reaping defect is outside the phase-6 steps' IN SCOPE files; both re-drive lines (red, then green) are recorded here.

  F21 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The implementer report's supervisor-module battery line records the module battery widened by the review module (`.venv/bin/python -m pytest tests/test_phase6_supervisor.py tests/test_review_phase6_supervisor.py --durations=5` — `15 passed in 17.72s`) and never the brief's documented form (`.venv/bin/python -m pytest tests/test_phase6_supervisor.py --durations=5`) with the documented form's own printed line. The wide form is a strict superset (the module's 13 pins plus the review module's 2 probes), green, and every figure it carries is its own printed line — nothing is evaded; but the brief's acceptance names the documented command, and the report's own template requires each claimed figure to name the command that actually ran while this acceptance line names both the documented form it did not run and the wide form it did. This review ran the documented form at FINAL — `13 passed in 12.46s` — so the figures stand; what carries is the report-text deviation from the brief's named battery.
  FIXED: no regression test — a document deviation in a committed report, which only a later step (or the planner's correction of the carried note) absorbs; the documented form's gate line is in this review's VERIFIED.

Expected dispositions (rule 8 forms): F19 fixed with red evidence (the absorbed leaf-cleanup pin, red under the leak defect, green at FINAL — the probe's green `1 passed in 0.95s` and its leak-mutant red `1 failed in 6.01s` are the named red class). F20 stays carried (owner `SandboxRunner._kill`, out of scope of every phase-6 brief; the planner's next brief or a load-envelope ruling). F21 stays carried (a document deviation in a committed report, absorbed only by a later step's correction). F11/F12/F18 stay fixed as recorded in the reports that filed them. F13–F17 stay carried with their named owners and text corrections.

Received F19 is fixed by this step (above), so it does not ride; received F20 and F21 stay carried with their named owners. Added by this step: F22 (P2, ORIGIN: BRIEF) — the brief's review-block copy of the carried F17 finding is truncated mid-sentence (the literal `(line truncated to 2000 chars)` marker), which rides as a carried text-correction to the planner.
