REVIEW BRIEF — phase5-run-entry-fixes-7 (the loader's refusal envelope — F38–F42)
REV: b7a010a1cbc984493033d9bd4872d7aeacfe9b48
FINAL: 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2
REVIEW ACCEPTANCE: scripts/check-scope b7a010a1cbc984493033d9bd4872d7aeacfe9b48 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2 docs/research/phase5-run-entry-fixes-7-brief.md
FOCUS: the seam's structural truth — one question above all: does anything other than `MemoryError` (raw, by the ruling's explicit clause), `KeyboardInterrupt`, and `SystemExit` still exit `load_run_spec` raw? — then the generated-input property's corpus integrity, the boundary docstrings' honesty, the message form's collapse, and this brief's own two brief-origin findings (FFR-1's gate-blocking prose, FFR-2's stale figure), for which the REVIEW ACCEPTANCE's expected exit is not green — see question 7.
SEVERITY SCALE: P0 blocks the step; P1 is serious; P2 is minor.
QUESTIONS TO ATTACK:

The two implementer findings that question the brief, copied verbatim from `docs/research/phase5-run-entry-fixes-7-implementer.md`:

  FFR-1 | SEVERITY: P1 | ORIGIN: BRIEF | STATE: carried
  The brief's `IN SCOPE:` line wraps both intended paths in backticks inside one prose line (`` `src/orchestrator/run_entry.py` … `tests/test_run_entry_loader_envelope.py` …``); `scripts/check-scope`'s awk extractor tokenises on commas/whitespace but does not strip backticks, so the claimed patterns are the literal strings `` `src/orchestrator/run_entry.py` `` / `` `tests/test_run_entry_loader_envelope.py` `` and match no path. The gate therefore exits 1 naming both intended files "not in IN SCOPE", and the ACCEPTANCE line requiring it green cannot be satisfied by any in-scope action (editing the brief is OUT OF SCOPE; the two files are the only diff).
  FIXED: no regression test — a committed brief's prose has none; per rule 8's ORIGIN: BRIEF close form a later committed brief corrects the IN SCOPE text to plain, un-backticked paths on their own lines as the fixes-6 brief does, after which `scripts/check-scope` is green. The residual half already prints `tripped: none`.

  FFR-2 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The brief's ACCEPTANCE sentence says the docs gate's printed total at REV (361 total, 361 OK, 0 errors) "is expected to hold"; at FINAL `scripts/check-docs` prints 363 total / 363 OK / 0 errors. The +2 is the brief's own two `[record.md](../record.md)` links, which lychee counts because it scans `**/*.md` and the brief is itself committed in `docs/research/`. The gate is green and 0-errors; only the predicted figure is stale.
  FIXED: no regression test — a count figure in a committed brief's prose has none; a later committed brief corrects or drops the predicted figure, naming the gate's own printed line (the F41 class).

The claims are attacked below, each answered in the form's fields.

1. The verdict question. Re-drive the fixes-5 review's seventeen-named-class corpus (named in the brief's CONTEXT from that review's own list), the fixes-6 review's new classes (2000-deep block nesting, over-deep indent, a 5MB scalar, a huge alias-expanded document, a multi-document stream, an unhashable key, invalid `!!binary` padding, a `!!python/object` tag, a merge-from-null key), and the typed-scalar classes — and any class your own reading of `yaml.safe_load` + the delivered seam suggests — at `load_run_spec` on written tmp files and through the documented `python3 scripts/orchestrate.py start …` head. Ask of each: does anything other than the ruling's three named raws (`MemoryError`, `KeyboardInterrupt`, `SystemExit`) still exit `load_run_spec` raw? File a finding per escaping class. Then the three probes: re-run `.venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_6_review.py -v` at FINAL (green, no test edit — verify `git diff 76a37a5 00577a4 -- tests/test_phase5_run_entry_fixes_6_review.py` is empty and `git diff b7a010a1cbc984493033d9bd4872d7aeacfe9b48 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2 -- tests/` names only the new module), and re-measure their red at REV's scratch form (`git show b7a010a1cbc984493033d9bd4872d7aeacfe9b48:tests/test_phase5_run_entry_fixes_6_review.py` diffed against the tree's file before trusting any scratch result) — the red→green pair with no test edit is the step's central delivery.

2. The seam's delivered shape. `git diff b7a010a1cbc984493033d9bd4872d7aeacfe9b48 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2 -- src/orchestrator/run_entry.py` names exactly: the `RunSpecError` docstring's boundary paragraph, `load_run_spec`'s docstring and except clauses, nothing else. The body carries exactly two except clauses in the ruling's order — `except MemoryError:` then `except Exception as error:  # noqa: BLE001 - the whole loader-refusal face` raising `RunSpecError(f"cannot load run-spec {path!r}: {error}") from error` — `validate_run_spec` is called OUTSIDE the try (a validation-stage bug surfaces unwrapped, question 5) and every other function and the module docstring are byte-identical. The two old message forms ("cannot read run-spec …" / "cannot parse run-spec …") are fully retired — grep the committed corpus for both strings in `tests/` and `docs/`: no committed pin or documented sentence names them (the fixes-5/fixes-6 reviews' CLI-head measurements were observations, not pins), so the collapse is honest — or name the sentence or pin the collapse widens/falsifies.

3. The mutants, each on a scratch copy diff-verified against `git show 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2:src/orchestrator/run_entry.py` before use: (a) delete the `except MemoryError: raise` clause — a `MemoryError`-shaped input (the fixes-6 review's `RLIMIT_AS` reproducer: a well-formed bulk document that loads fine without the limit) now WRAPS into `RunSpecError` — a ruling violation (host-resource faults must stay unwrapped), a finding; (b) delete the whole `except Exception` clause — F38/F39/F40's probes and the property go red with their named translations; (c) narrow `except Exception` back to the old three-name tuple `(yaml.YAMLError, UnicodeDecodeError, RecursionError)` — the probes go red while the read-refusal pin stays green, pinning that the pin set alone is not the seam's proof and the property is rule 13's pin; (d) drop `{path!r}` from the format string — the read-refusal pin reds (its `assert str(path) in str(error)`).

4. The property's corpus integrity. Read `tests/test_run_entry_loader_envelope.py` as written and attack its axes: does every safe-loader tag family (the thesis's eleven named tags plus the merge key) really cross the drawn payloads — each generated document carries one tagged value per family (note: ONE drawn payload × all families per example, so per-example the cross is uniform — judge whether 50 derandomized examples over the 44-payload sample plus `st.text(max_size=8)` cover each family × payload class, or is the cross a product-shaped claim the strategy never builds); the three quote-form renders (plain, single, double) with each payload; the splice axis (the seven invalid-UTF-8 measures × a drawn index, and the initial-byte/end-of-document placements in particular); the depth axis 1..2500 (which depths overflow the parser and which land a doc, and does the generated depth hit the interpreter's own recursion handling rather than the parser's — the F36 class's trailing bytes); the raw `st.binary(max_size=16)` axis; the valid-document arm (the `Mapping` arm exercised five ways); `derandomize=True, deadline=None, suppress_health_check=[HealthCheck.too_slow]` — the fidelity of the thereby-deterministic green, and whether `too_slow` suppression can hide a corpus too small to name the face. Then the envelope's both arms as replayed: the refusal arm's `RunSpecError` (never a subclass assertion — is bare `except run_entry.RunSpecError` honest when a refusing input could raise a subclass? `RunSpecError` has none) and the returned arm's `isinstance(document, Mapping)` against `validate_run_spec`'s normalised copy.

5. The validation stage's outside-the-seam reading. `validate_run_spec` is byte-identical to REV (verify in question 2's diff). Plant a bug on a scratch copy (`raise ValueError("planted")` as the function's first statement) and drive `load_run_spec` on a valid spec: the `ValueError` exits raw (the envelope does not wrap it — `return validate_run_spec(document)` sits outside the try), and the property would fail it as a test failure, exactly the ruling's "validation-stage bugs surface as test failures, never as wrapped operator errors". Verify the half from the delivered code as well: a `validate_run_spec` refusal (`RunSpecError`) passes through the envelope's clause untouched (`RunSpecError` subclasses `Exception` — the seam would wrap an envelope-raised one too if the clause sat around the call; it does not).

6. The docstrings' honesty and the claim's non-narrowing. `docs/run-entry.md` and the module docstring are untouched (`git diff b7a010a1cbc984493033d9bd4872d7aeacfe9b48 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2` names no `docs/` file). The two delivered docstrings: does the delivered boundary text hold without widening or falsifying any documented sentence — the `RunSpecError` docstring's old sentence ("the operator sees one named failure, never a run-time surprise") stands followed by the boundary paragraph; the fixes-6 review's MemoryError adjudication (the claim's subject is "a loader-refusable **malformed** spec"; a host fault is not one) is the boundary's ground — say whether the delivered text encodes that ground or silently restates it as newly-granted (the F21 narrow-claim class run in the docstring direction).

7. REVIEW ACCEPTANCE and the F42 citation. Run it first, as the method requires — and note its expected exit is NOT green: `scripts/check-scope b7a010a1cbc984493033d9bd4872d7aeacfe9b48 00577a4e14fcb03e61f5868d9a8cbef7e195e1e2 docs/research/phase5-run-entry-fixes-7-brief.md` prints the two "is in the diff and not in IN SCOPE" lines then `tripped: none` and exits 1 — FFR-1's prose defect (a backticked IN SCOPE line the awk extractor cannot parse). The gate's SUBSTANCE is what you verify: the gate-named paths are exactly the diff's only two paths and both are the brief's intended files (read the brief's IN SCOPE line and the diff's paths), the residual half prints `tripped: none`, and the implementer's report records the gate as NOT VERIFIED with the defect filed — the scope duty's content is discharged and the prose is the defect. Also verify the F42 citation: `git rev-parse 76a37a5` equals `76a37a50431c04eb4d1c3a343b4710bb0ee5e678` (the commit that holds the brief) as the report's F42 `FIXED:` names, and the brief's CONTEXT paragraph is the correcting text it claims (the corpus named as seventeen, never nineteen — grep the committed corpus for "19-class" in the fixes-6 review brief and the fixes-5 banner: those committed texts stand as filed, and this brief's correction is the rule-8 close form the F42 finding itself names).

8. The report's forms and counts (J-class). Every `VERIFIED` count re-measured and copied from the gate's own printed line (`--fast` 961 passed, 104 deselected, 68.27s — account the 104: REV's 102 + the new module's two cases; the 5-passed module line = 2 new cases + 3 probes; the 54-passed battery = 2 + 5 + 40 + 7; `scripts/check-static` gated `BLE001,S110` clean and advisory `B,SIM` 104 rows unchanged; `scripts/check-docs` 363 total, 363 OK, 0 errors — the +2 over the brief's predicted 361 is FFR-2's own named cause, re-measure the printed line; TRIPPED copied from check-scope's own line despite its exit 1); `FINAL` is the work commit `00577a4e14fcb03e61f5868d9a8cbef7e195e1e2`, never the report commit `840a9d3`; the oracle line's five passed in 213.88s re-measured (the module's `@pytest.mark.timeout(2400)` cap is not its floor — judge the run's own count and duration as printed). The finding-form question: the two brief-origin findings are named `FFR-1`/`FFR-2` where the corpus's convention numbers findings sequentially (the last committed ID is F42) — adjudicate whether the prefix is a defect (the next brief copies carried names verbatim, so the naming's effect on the INHERITED chain's mechanics is the standard to judge by; if the prefix breaks any chain reading, name the finding) — answer here in the form's fields. Every field of the report present and filled, nothing outside the template added; `SHAPES: none` read against rule 7 (the property and the pin ARE the two named shapes' tests; the absorbed probes' green named as the third shape's tests; name any probed-but-unbuilt shape you find); `INHERITED` carries F41, FFR-1, FFR-2 as still open and nothing else is open in it.

9. The owner-directed question — the `project_kernel.kernel_id` dict-acceptance question, which R10 ordered to ride this review brief. `run_configuration`'s kernel read is `str(target.project_kernel.get("kernel_id") or target.snapshot_id)` at `src/orchestrator/run_entry.py:338`, the admin schema's `ProjectKernelReference` validates the admitted configuration's `kernel_id` with `_non_empty_str` (`src/orchestrator/schemas.py:162`), and the loader's `validate_run_spec` checks only that `project_kernel` is a non-empty mapping (`src/orchestrator/run_entry.py:202-204`) — no type or content requirement on `kernel_id` itself. Ask: does a spec whose `kernel_id` is a dict (or a list, or an empty mapping — anything non-string) pass the loader and get `str()`-coerced into the admitted root contract's `kernel_id` (`"{'a': 1}"` past `_non_empty_str`), and is that a defect against the schema's intent (the class-B "looks close enough" coercion face) or an intended fallback (`or target.snapshot_id`)? Drive it: a valid spec whose `project_kernel.kernel_id` is a mapping, through `freeze_target` and `run_configuration` (or through the documented `start` head against a real frozen repository — the one allowed seam) — what is admitted? Anything that falsifies the schema-admission intent ("Schema admission is checked here so a configuration the controller would reject is a load-time refusal, not a run-time surprise" — the `run_configuration` docstring's own sentence) is a finding with its severity; a truth it survives is an attacked-and-not-falsified with the method. Note the seam boundary: `run_configuration` is OUT OF SCOPE of this brief, so a confirming finding is carried, not fixed here — a later OWNER-directed brief owns its fix.

10. The Phase 5 exit gate as a whole — the envelope's reach into the operator surface. The fixes-6 review re-verified the five operator classes live two steps ago and they are carried by the standing battery's pins, so re-drive only where the envelope touches: a malformed-spec class through the documented `python3 scripts/orchestrate.py start …` head (one typed-scalar class, one over-deep class, one missing-path class): exit 1 with the named refusal as the terminal exception, its message the new single form `orchestrator.run_entry.RunSpecError: cannot load run-spec '<path>': …`, empty stdout, and the store file ABSENT (not merely zero events) — and `inspect`/`stop` against that refused run id in their unchanged clean forms. Then report each guarantee as falsified-with-reproducer or attacked-and-not-falsified; what remains open after this review is the decision input — report findings and let the planner decide (cycle step 5).

--- BEGIN BRIEF UNDER REVIEW (copy of docs/research/phase5-run-entry-fixes-7-brief.md; the committed file is authoritative) ---
IMPLEMENTER BRIEF — phase5-run-entry-fixes-7 (Phase 5: the loader's refusal envelope — F38–F42)

GOAL: The loader's named-refusal face is made structurally true at one seam (owner ruling R10, per the fixes-6 refer) and the three committed red probes go green with no test edit. `load_run_spec`'s try block over the read+decode+parse+construct pipeline (the `open` + `yaml.safe_load` block it already is) carries exactly two except clauses: `except MemoryError: raise` first (`MemoryError` subclasses `Exception`, so the raw-exception boundary must be explicit), then `except Exception as error: raise RunSpecError(f"cannot load run-spec {path!r}: {error}") from error`. One seam, one wrap, one message form naming the path and the cause; the delivered two forms ("cannot read run-spec …" / "cannot parse run-spec …") collapse into it. Everything the loader's own failure surface can raise is the named refusal raised `from` its cause: the `OSError` read family stays wrapped (unreadable files are refusals), `RecursionError` stays wrapped (over-deep input is malformed input — `RecursionError` subclasses `Exception`, so the seam catches it as before), and the typed-scalar construction class (`ValueError`/`AttributeError`/`KeyError` out of `!!int`/`!!float`/`!!timestamp`/`!!bool`) — the third time the enumerated-class trap returned inside this same face (F35, F36, now F38–F40) — is covered because the face is named whole, not by inventory. `KeyboardInterrupt` and `SystemExit` stay raw by construction (they are not `Exception` subclasses); a `MemoryError`-shaped input is a host-resource fault, not a spec refusal, and escapes unwrapped — the docstrings name that boundary, and the documented claim (`docs/run-entry.md`'s "a loader-refusable malformed spec is refused as a named `RunSpecError` before any store is opened or any event is admitted") stands unwritten-but-true as before: claim narrowing is declined by R10 and a tag-universe restriction may come later as hardening and is not part of this step. The validation stage stays outside the seam: the `validate_run_spec(document)` call, the function's body, and its refusals are byte-identical to `REV` — its named refusals are `RunSpecError` already, and a bug there surfaces unwrapped: validation-stage bugs surface as test failures, never as wrapped operator errors. The seam is pinned by a test over generated inputs (below, `Loader-refusal envelope`). No `tests/open_defects.yaml` registration rides (the absorbed probes are `test_review_*`; the registry owns `test_bug_*` pins only).

CONTEXT: The fixes-6 step was referred to the OWNER at its decision (the whole-face widening absorbed the fixes-5 probe green, and its review's full-corpus attack found the typed-scalar class still escaping — the enumerated-class trap returning a fourth time inside the same face). R10 ([record.md](../record.md)#owner-rulings) settles the contract the refer asked for, and this brief delivers it: rule 13 forbids answering a falsified absolute with another enumerated list, so the fix is one seam over the whole surface, pinned by a test over generated inputs — not a wider tuple. The three red probes are the fixes-6 review's own, committed red and accepted to ride red until absorbed (the standing practice, record.md's Observations): F38 (P1, `!!int`/`!!float` → raw `ValueError`), F39 (P1, `!!timestamp` → raw `AttributeError` or `ValueError`), F40 (P1, `!!bool` → raw `KeyError`). Each probe's mechanism sits inside `yaml.safe_load`'s construct stage — the same pipeline the delivered three-clause tuple wraps — so the envelope absorbs all three at once with no test edit, the same red→green shape F36's probe rode at the fixes-6 step. `hypothesis` 6.168.0 is already the pinned dev dependency (`requirements-dev.txt:3`); the generated-input property needs none new. The corpus-size correction (F42, carried by the fixes-6 review as an ORIGIN: BRIEF count defect): the fixes-6 review brief's QUESTIONS line and the fixes-5 review's own banner count the malformed-class corpus at nineteen, while that review's VERIFIED corpus line names exactly seventeen — the two extra classes are named nowhere and cannot be re-driven by name. This brief's text is the correcting text: **the malformed-class corpus is seventeen named classes**, the fixes-5 review's own VERIFIED corpus line's list, named here from the artifact and nowhere as nineteen: (1) unparseable YAML — `ParserError`; (2) tab-scanned indent — `ScannerError`; (3) NUL byte in the document — `ReaderError`; (4) invalid UTF-8 bytes; (5) truncated multi-byte tail; (6) truncated UTF-8 tail at the input end; (7) UTF-16 BOM head — `UnicodeDecodeError`; (8) an empty file; (9) a wrong top-level type (sequence and scalar both); (10) missing required keys; (11) an alias-cyclic document; (12) a billion-laughs-shaped alias bomb; (13) a cyclic root alias (`&x [*x]` and `{b: *a}`, both self-referential shapes); (14) a missing path (`FileNotFoundError`); (15) a directory path (`IsADirectoryError`); (16) a symlink loop (`OSError`); (17) deeply-nested flow — `RecursionError`, F36's escape class.

INHERITED:

From `docs/research/phase5-run-entry-fixes-6-implementer.md`, its `INHERITED` block verbatim:

  INHERITED:
  none — the received INHERITED carried exactly one open item, F36 (the fixes-5 review's carried P2, moved into this brief's body). It is fixed in this step (FINDINGS, F36); nothing is carried forward and nothing new is left open.

From `docs/research/phase5-run-entry-fixes-6-review.md`, its `INHERITED` block verbatim:

  INHERITED:
  F38, F39, F40, F41, F42 are filed carried by this review and live in its FINDINGS above. Nothing else is still open: what this review received is fully disposed — F36 (the only item carried by the fixes-5 review's INHERITED) is fixed by the step under review (its red probe green in both full runs with no test edit), F37 is fixed at the fixes-5 step and green as a maintained pin, the fixes-5 implementer's INHERITED block reads none with nothing open, and the brief's two copied blocks resolve to those same two findings.

The copied block's "(above)" references resolve to that report's `FINDINGS` entries; the five findings are moved verbatim here so the brief is the actor's only input, each with this brief's disposition stated after the moved block:

  F38 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  A malformed typed scalar (`run_id: !!int 'garbage'` / `!!float 'garbage'`) fails the safe constructor's own conversion and raises a raw `ValueError` out of `yaml.safe_load`; it is not a `yaml.YAMLError`, so the delivered tuple `(yaml.YAMLError, UnicodeDecodeError, RecursionError)` does not catch it — the raw class escapes `load_run_spec` (and the documented `start` head dies on its traceback, terminal line `ValueError: could not convert string to float: 'garbage'`) instead of the named refusal. The step's central claim — the work commit's "every failure the loader's read+decode+parse can produce is now the named refusal", the GOAL's face, and `RunSpecError`'s "one named failure, never a run-time surprise" docstring — is falsified for this operator-reachable malformed-spec family; this is the enumerated-class trap returning a fourth time inside the same face (F35's `UnicodeDecodeError`, F36's `RecursionError`, now the typed-conversion leak class), which is why it is graded serious. The fail-closed halves hold (store ABSENT through the head, zero events). Pre-existing at every earlier step (the face was never guarded for it), not a regression of this one.
  FIXED: tests/test_phase5_run_entry_fixes_6_review.py::test_review_f38_int_float_typed_scalar_refused_as_a_named_run_spec_error — at FINAL the named assertion fails at tests/test_phase5_run_entry_fixes_6_review.py:35 as `.venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_6_review.py -v` → `Failed: F38: an ill-typed int scalar is refused as ValueError, not the documented named \`RunSpecError\`: ValueError("invalid literal for int() with base 10: 'garbage'")` (the `!!float` half names `could not convert string to float: 'garbage'` in the same probe's second iteration) — 1 failed, 2 passed with this review's probes; the probe rides red until a loader widening absorbs it green with no test edit.
  This brief's disposition: the seam absorbs the probe green with no test edit (see Red evidence; every clause the old tuple caught stays caught, and the construct stage's typed-scalar class lands in `except Exception`).

  F39 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  A malformed `!!timestamp` typed scalar raises a raw non-YAMLError exception out of the safe constructor — `run_id: !!timestamp 'nope'` crashes on `'NoneType' object has no attribute 'groupdict'` (an `AttributeError` from the constructor's own regex handling) and an out-of-range value (`!!timestamp '2020-13-45T99:99:99Z'`) raises a raw `ValueError` (`month must be in 1..12`) — both escape `load_run_spec`'s tuple raw and the documented head dies on their tracebacks instead of the named refusal. Same central-claim falsification and same trap as F38; fail-closed halves hold.
  FIXED: tests/test_phase5_run_entry_fixes_6_review.py::test_review_f39_timestamp_typed_scalar_refused_as_a_named_run_spec_error — at FINAL → `Failed: F39: an ill-typed timestamp scalar (nope) is refused as AttributeError, not the documented named \`RunSpecError\`: AttributeError('\\'NoneType\\' object has no attribute \\'groupdict\\'')` under the same command as F38 (1 failed, 2 passed).
  This brief's disposition: the seam absorbs the probe green with no test edit (see Red evidence).

  F40 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  A malformed `!!bool` typed scalar (`run_id: !!bool 'garbage'`) raises a raw `KeyError` out of the safe constructor's bool handling; not a `yaml.YAMLError`, so the delivered tuple misses it — the raw class escapes `load_run_spec` and the documented head dies on `KeyError: 'garbage'` instead of the named refusal. Same central-claim falsification and same trap as F38; fail-closed halves hold.
  FIXED: tests/test_phase5_run_entry_fixes_6_review.py::test_review_f40_boolean_typed_scalar_refused_as_a_named_run_spec_error — at FINAL → `Failed: F40: an ill-typed bool scalar is refused as KeyError, not the documented named \`RunSpecError\`: KeyError('garbage')` under the same command as F38 (1 failed, 2 passed).
  This brief's disposition: the seam absorbs the probe green with no test edit (see Red evidence).

  F41 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The implementer report's `VERIFIED` figure "links 364/364 OK" does not match what the gate prints for the committed content: `scripts/check-docs` on scratch copies of both the REV tree and the FINAL tree measures `366 Total / 366 OK / 0 Errors`, and the range's own diff adds the brief's single local `../record.md` request (the `lychee --dump` cross-check) — no content state in the measured neighbourhood prints 364. The gate's substance holds (exit 0, 0 errors, both trees measured), so this is a copied-or-guessed figure rather than a run record — the J-class ("a claim not checked against the artifact it cites"), here in a direction that changed nothing material. A later actor corrects it by naming the gate's own line (a figure copied from the printed source, never recomputed from memory).
  FIXED: no regression test — a prose figure in a committed report has none; the close form is the review that filed this one (this report's VERIFIED) and, if the step closes out, a record.md Observations line for the count-figure class.
  This brief's disposition: carry it verbatim through your report (STATE: carried; it rides your INHERITED) — nobody edits a committed report, so the implementer has no action on it. The planner closes it at this step's closeout as `fixed: recorded in` the fixes-6 review (rule 8's close form for a defect in an already-committed report; the count-figure class's authoring lesson is already recorded at [record.md](../record.md)#observations). Do not work on it and do not mark it fixed.

  F42 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The corpus-count number is a claim not checked against the artifact it cites: this review brief's QUESTIONS line (and the fixes-5 review's own banner, and this brief's CONTEXT sentence "the review's 19-class corpus") count the malformed-class corpus at nineteen classes, while the fixes-5 review's own VERIFIED corpus line names exactly seventeen; the two extra classes are named nowhere and cannot be re-driven by name. The fixes-5 review's own summary ("attacked-and-not-falsified for 18 of 19 classes") inherits the same unreconciled count. No coverage gap results — this review drove all seventeen named members to fill the demand's substance — but the number travelled through two committed documents unverified, so a later committed brief corrects the text to the artifact's own list (seventeen named classes) or drops the banner number.
  FIXED: no regression test — a count in a committed brief's prose has none; the correcting text is the next committed brief naming the corpus size from the artifact's own list (the fix-form rule 8 gives ORIGIN: BRIEF findings).
  This brief's disposition: this brief's own CONTEXT paragraph above is the correcting text — it names the corpus size from the fixes-5 review's own corpus line's list (seventeen named classes) and never as nineteen. Per rule 8's ORIGIN: BRIEF close form, in your report F42's `STATE` is `fixed` and its `FIXED:` line reads `no regression test` and names **this brief's commit** — obtain the sha before your work commit: `git rev-parse HEAD` is this brief's commit (the tree's tip at dispatch; cross-check with `git log -1 --format=%H -- docs/research/phase5-run-entry-fixes-7-brief.md`, which names the same sha). No code work belongs to F42.

IN SCOPE: `src/orchestrator/run_entry.py` — only `load_run_spec` (its two docstring and except-clause changes below) and the `RunSpecError` class docstring. `tests/test_run_entry_loader_envelope.py` — this step's new module, created here (the `Loader-refusal envelope` property and the `Read-refusal pin`, shapes named below). Nothing else in either file: every other function in `src/orchestrator/run_entry.py` and the module docstring stay byte-identical to `REV` (OUT OF SCOPE).

RESIDUALS:

none — rule 3 selection for this brief's `IN SCOPE`: no `docs/residuals.md` trigger glob matches `src/orchestrator/run_entry.py` or the new test module (the ten `PILOT-R*` triggers name `planning_pilot.py`, `controller.py`, `reducer.py`, `decomposition.py`, `model.py`, and `derive_obligations.py`; the store is byte-verified against `docs/residuals.md` before this brief's commit, rule 2). No residual row rides, so the residual half of `scripts/check-scope` has nothing to carry here and it prints `tripped: none` — the line your report's `TRIPPED` field copies.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-fixes-7-brief.md`). A committed brief is never modified; a re-cut is a new file.
- `validate_run_spec`'s body, every `_require_*` helper, `freeze_target`, `run_configuration`, `start_run`/`_bind_acceptance`, and every other function in `src/orchestrator/run_entry.py`: the validation stage stays outside the seam by the ruling — its named refusals are `RunSpecError` already and a bug there must surface unwrapped (test failures, never wrapped operator errors). If one seems to need changing for acceptance to pass, stop and report `IN SCOPE` as insufficient.
- The module docstring of `src/orchestrator/run_entry.py` and `docs/run-entry.md`: the envelope makes their sentences true as written and R10 declines any narrowing; the host-resource boundary is named in the two docstrings `IN SCOPE` names, not in the documented claim. If you find a sentence the envelope cannot make true, stop and report rather than reword it (a document amended is an OWNER commit, rule 5).
- Every committed pin and probe of the earlier steps: `tests/test_phase5_run_entry_fixes_6_review.py` (the three probes turn green from the fix alone — NO test edit), `tests/test_phase5_run_entry_fixes_5_review.py`, `tests/test_phase5_run_entry_fixes_4_review.py`, `tests/test_run_entry.py`, and `tests/test_phase5_run_entry_fixes_2_review.py` are read-only here. If a pin would have to change for acceptance to pass, stop and report `IN SCOPE` as insufficient.
- `tests/open_defects.yaml` and the registry's meta-tests: no registration rides (the absorbed probes are `test_review_*`; the registry owns `test_bug_*` pins only).
- The tag-universe restriction: R10 rules it "may come later as hardening and is not part of this ruling" — do not restrict the tag set, do not build the restriction's shape, and do not amend any sentence about it.
- No `docs/tables/*` change and no table regeneration, no `docs/event-catalogue.md` change and no new event type, no `docs/control-plane.md` edit, no `docs/residuals.md` or `docs/record.md` edit (F41 closes at the planner's closeout, not here), no `docs/self-host.md` edit, no `docs/method.md` or `docs/templates/` edit.
- The controller stack, the store, the experiment harness, `scripts/orchestrate.py`, `experiment_target.build_target`, `schemas.py`.
- Registry and control files: `tests/counterexamples.yaml`, `tests/guard_mutation_matrix.yaml`, `tests/fixture_fidelity.yaml`, `tests/verifier_registry.yaml`, `tests/spend_paths.yaml`, `tests/invariants.py`, `tests/helpers.py`, `pytest.ini`, tool configuration.
- No new dependencies (`hypothesis` is already pinned at `requirements-dev.txt:3`), no tooling configuration, no reformatting. No new exception class (`RunSpecError` is the named failure) and no `*Executor`/`*ModelClient` class or provider-registry registration.
- Name no test `test_bug_*` (the open-defect registry would then own it).

ACCEPTANCE: Commands (run every one and paste what each prints into `VERIFIED`; expected result is green, exit 0, for each):

    scripts/check-tests --fast
    .venv/bin/python -m pytest tests/test_run_entry_loader_envelope.py tests/test_phase5_run_entry_fixes_6_review.py
    .venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_5_review.py tests/test_phase5_run_entry_fixes_4_review.py tests/test_run_entry.py tests/test_phase5_run_entry_fixes_2_review.py
    .venv/bin/python -m pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope b7a010a1cbc984493033d9bd4872d7aeacfe9b48 <FINAL> docs/research/phase5-run-entry-fixes-7-brief.md

Every `pytest` line names `.venv/bin/python -m pytest` deliberately (F17's carried correction: the bare `pytest` on PATH has no `pytest-timeout` and `pytest.ini`'s `strict_config = true` rejects it on this host — run these lines exactly as written and claim them under these names). `tests/test_phase3_project_oracle.py` is named per the standing rule for a brief that adds a file under `tests/` (the fast suite and the commit hook both deselect the oracle, and this brief adds one module). `tests/test_run_entry_loader_envelope.py` and `tests/test_phase5_run_entry_fixes_6_review.py` share a line because the three probes are red at `REV` and must be green beside the new module's cases at `FINAL` — expected at FINAL: 5 passed, exit 0. The four earlier modules are the loader's whole committed battery and must not regress. The fast suite's expected shape: the passed count stays 961 (the new module's cases ride slow — see the slow-mark convention) and the deselected count grows from 102 by the new module's case count. `docs/run-entry.md` is untouched, so the docs gate's printed total at `REV` (361 total, 361 OK, 0 errors) is expected to hold — and every count figure you write in `VERIFIED` is the gate's own printed line, never recomputed from memory (F41's class). Never put a full run in `ACCEPTANCE`; the reviewer runs `scripts/check-tests`. `REV` below names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson).

Red evidence at `REV` `b7a010a1cbc984493033d9bd4872d7aeacfe9b48` (command `.venv/bin/python -m pytest tests/test_phase5_run_entry_fixes_6_review.py -v`; each unit replayable; measured 3 failed, 0.28s): the fixes-6 review's own committed probes are red at `REV` as committed, each a `pytest.fail` translation naming the raw class that escaped —

- `tests/test_phase5_run_entry_fixes_6_review.py::test_review_f38_int_float_typed_scalar_refused_as_a_named_run_spec_error` — at tests/test_phase5_run_entry_fixes_6_review.py:35: `Failed: F38: an ill-typed int scalar is refused as ValueError, not the documented named \`RunSpecError\`: ValueError("invalid literal for int() with base 10: 'garbage'")` (the `!!float` half of the same probe names `could not convert string to float: 'garbage'`)
- `tests/test_phase5_run_entry_fixes_6_review.py::test_review_f39_timestamp_typed_scalar_refused_as_a_named_run_spec_error` — at tests/test_phase5_run_entry_fixes_6_review.py:55: `Failed: F39: an ill-typed timestamp scalar (nope) is refused as AttributeError, not the documented named \`RunSpecError\`: AttributeError("'NoneType' object has no attribute 'groupdict'")`
- `tests/test_phase5_run_entry_fixes_6_review.py::test_review_f40_boolean_typed_scalar_refused_as_a_named_run_spec_error` — at tests/test_phase5_run_entry_fixes_6_review.py:71: `Failed: F40: an ill-typed bool scalar is refused as KeyError, not the documented named \`RunSpecError\`: KeyError('garbage')`

That red is this step's red evidence, already in the tree; `FIXED` names the node id, the command, that failing message, and the delivered file's line numbers or none (F22's lesson). Each probe turns green at `FINAL` with no test edit. Other gates measured at `REV`: `scripts/check-tests --fast` 961 passed, 102 deselected, 89.95s (the 102 accounted: the fixes-6 review's 99-deselected list — 40 `test_run_entry` + 12 `test_planning_pilot_routing` + 7 `test_phase5_run_entry_fixes_2_review` + 7 `test_milestone6_acceptance` + 5 `test_phase5_run_entry_fixes_4_review` + 5 `test_phase3_project_oracle` + 4 `test_ledger_fuzzer` + 4 `test_crash_matrix` + 4 `test_axis2_robustness` + 3 `test_review_depth_walk` + 3 `test_milestone7_acceptance` + 2 `test_phase5_run_entry_fixes_5_review` + 1 `test_spend_multi_writer` + 1 `test_phase0_defects` + 1 `test_grade_cache` — plus this review's three slow probes); `scripts/check-static` exit 0, 104 advisory rows, unchanged from the fixes-6 step; `scripts/check-docs` 361 total, 361 OK, 0 errors; the full `scripts/check-tests` state at `REV` is the fixes-6 review's own measured state (3 failed, exactly the three probes, + 1060 passed, 658.29s, with the probes in tree — `git diff 8d21905..HEAD` is docs-only plus this probe module, `src/` byte-identical); the implementer does not re-run the full suite.

Slow-mark convention: the new module carries `pytestmark = pytest.mark.slow` at module level, so every case in it is slow-marked (the standing convention for a new module under `tests/`: the project oracle's internal gate runs `scripts/check-tests --fast` (`-m "not slow"`, `src/orchestrator/project_oracle.py:731`) and the pre-commit hook deselects the same way; unmarked trial-running cases break `pytest tests/test_phase3_project_oracle.py`). The module pins its `hypothesis` settings explicitly (`@settings`) so the property's example count is bounded and its runs are green and deterministic — this is your choice of module constants, not a new dependency or tooling configuration.

Named shapes to build — the list of shapes, not the number of tests. One shape needs at least one test, and every named shape needs one:

- `Loader-refusal envelope` (R10's seam — rule 13's structurally-true shape, pinned by a test over generated inputs): the try block carries exactly the two except clauses the GOAL writes (`except MemoryError: raise` first, then `except Exception as error: raise RunSpecError(f"cannot load run-spec {path!r}: {error}") from error`), and the new module's property test pins the whole surface: over `hypothesis`-generated YAML bytes combining (a) every safe-loader tag family crossed with arbitrary scalars — the tagged nodes (`!!int`, `!!float`, `!!bool`, `!!str`, `!!null`, `!!timestamp`, `!!binary`, `!!set`, `!!omap`, `!!seq`, `!!map`, and the merge key) whose contents are drawn from garbage text, numeric text, empty, unicode, and the numeric-garbage forms the probes drive, plus documents whose every value carries a tag; (b) invalid UTF-8 byte splices (the generated bytes are written raw, so the decode stage sees them); (c) deep nesting (recursive sequences/maps at depths the parser overflows, the F36 class) — the property asserts `load_run_spec` either returns a `Mapping` or raises `RunSpecError`, nothing else. The generated corpus's sizes are hypothesis-bounded (the strategy generates no host-resource-scale document), so the corpus contains no `MemoryError` input and the property holds as stated — the host-resource boundary rides the docstrings, not this strategy; nothing about the seam's clause set exempts anything from the property's either/or. The unsafe-tag class (`!!python/…`) and every `ConstructorError` face land in the property too (they are the loader's own failure surface).
- `Read-refusal pin` (the `OSError` family under the envelope): a test in the new module driving the read face — a missing path, a directory, and a symlink loop each refuse as `RunSpecError` whose message names the path and whose `__cause__` is the tool's own `OSError` subclass. This pin is newly owed here: the fixes-5 and fixes-6 reviews disclosed the face unpinned as UNCHANGED behaviour, but this seam replaces the `except OSError` clause, so the face is touched rather than unchanged and rule 7's re-drive demand converts to a pin.
- `Absorbed typed-scalar probes` (F38/F39/F40): the three probes in `tests/test_phase5_run_entry_fixes_6_review.py` go green at `FINAL` with no test edit — the envelope is their fix; this line of expected-green names the shape's tests even though they are not created or edited by this step.

Maintained unchanged (no new test owed; green in the battery line): the F34 probe (`ParserError`), the F37 pin (`UnicodeDecodeError`), and the F36 probe (`RecursionError`) — all three faces are covered by the seam but their pins already exist and stay untouched.

REV: b7a010a1cbc984493033d9bd4872d7aeacfe9b48
CLOSE OUT: yes
DIVERGENCES: none
REVIEW: one session — R10's verdict question above all: does anything other than `MemoryError` (raw, by the ruling's explicit clause), `KeyboardInterrupt`, and `SystemExit` still escape `load_run_spec` raw? Attack the envelope over the seventeen-named-class corpus plus typed-scalar and unsafe-tag classes re-driven as runners, the mutants (drop the `MemoryError` clause — does a `MemoryError`-shaped input wrap, violating the ruling? drop the `except Exception` clause — do the three probes go red? narrow it back to the old tuple — do they stay red?), the message form's collapse (one form naming the path and the cause; the `OSError` message's old form honestly retired), the generated-input property's corpus honesty (does the strategy really cross every safe-loader tag family with arbitrary scalars, splice invalid UTF-8, and recurse deep — and is the property deterministic, bounded, and green?), the validation-stage-outside-the-seam reading (`validate_run_spec` byte-identical; a planted validation-stage bug surfacing unwrapped), the read-refusal pin and its own mutant spacing, the docstrings' boundary honesty (do they name host-resource faults as not-spec-refusals without widening or narrowing the documented claim?), the probes' red→green with no test edit, the full-suite and module counts and the report's forms (J-class; every figure the gate's own printed line), and the Phase 5 exit gate's operator classes as the review brief later demands. And the OWNER's directed question rides this step's review brief under `QUESTIONS TO ATTACK`: the `project_kernel.kernel_id` dict-acceptance question (`run_configuration`'s `kernel_id` reads `str(target.project_kernel.get("kernel_id") or target.snapshot_id)` at `src/orchestrator/run_entry.py:338` while the admin schema's `ProjectKernelReference` validates it `_non_empty_str` at `src/orchestrator/schemas.py:162` and `validate_run_spec` checks only that `project_kernel` is a non-empty mapping — whether a dict-typed `kernel_id` in the spec is accepted and `str()`-coerced past the schema's intent is the question the review brief carries; the implementer does not work on it — `run_configuration` is OUT OF SCOPE here).

You implement one brief. You do not plan, re-scope, or decide what the work is. Read every file
in IN SCOPE before editing it; if what you find contradicts the brief, report that instead of
guessing. Modify only what IN SCOPE names. If you find uncommitted changes in the tree, stop and say
so. Stop and report rather than improvise when IN SCOPE is
insufficient, the brief contradicts the code, you have already failed twice at this goal, or the
requirement is ambiguous and no single reading is consistent with the rest of the brief. If exactly
one reading is consistent, take it and file a FINDING with ORIGIN: BRIEF that names the reading you
took. No new dependencies, no tooling configuration, no reformatting. Run every ACCEPTANCE command;
fix what is in scope and report what is not.

A defect in the brief is a FINDING, never METHOD FRICTION. METHOD FRICTION is only for the method and
its templates: any place you deviated from them, found them ambiguous, or found them silent. Report
friction you worked around — that is the section the method learns from.

Commit your own work. When ACCEPTANCE passes, commit the files you changed, and only those, in one
commit whose message ends with the trailer `Actor: IMPLEMENTER`. That commit's full sha is FINAL.
Then append docs/templates/report.txt verbatim, fill it in, write it to
docs/research/<phase>-<subject>-implementer.md, and commit it in a second commit with the same
trailer. Do not amend the first commit to add the report: FINAL must not change after the report
names it. If you cannot commit, stop and say so; do not leave work uncommitted for someone else to
commit.

# report.txt

REPORT — <phase>-<subject>-<role>
STEP: <implementer brief subject>
REV: <copied from the brief's REV — the step's base, not FINAL's parent>   FINAL: <implementer: sha of your work commit, never the commit that holds this report;
  reviewer: the sha under review, copied from the review brief>
CHANGED: <files, one line each>
VERIFIED: <command, duration, counts>
         Every VERIFIED and ACCEPTANCE claim names the command that actually ran — never a
         substituted interpreter, wrapper, or narrowed form. If the documented form cannot run in
         your environment, record both commands and the documented form's separate check.
NOT VERIFIED: <why, or none>
FINDINGS: none | one block each:
  ID | SEVERITY: P0|P1|P2 | ORIGIN: BRIEF|CODE|DOCUMENT | STATE: fixed|declined|carried
  <root cause, one line>
  FIXED: <node id, command, and the named failing assertion at REV — or "no regression test">
         An error or a collection failure is not red. The assertion has to be the thing that
         failed; a run that merely crashed proves nothing.
  STATE means: fixed (above); declined = not a defect, with the reason; carried = a real defect
  left unfixed, passed on in INHERITED. A defect you will not fix now is carried, never declined.
  An ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text: FIXED: names
  that brief's commit and reads "no regression test". Carried means a future actor has something to
  do with it; at closeout a finding with no possible next action is closed — a defect in an
  already-committed report reads FIXED: recorded in the review that filed it, and an authoring
  lesson from a finished brief goes into record.md's Observations.
SHAPES: <shapes probed that the suite does not build, or none with a reason>
        Every shape this report names needs a test or an entry here: a hand measurement is not a
        test. A facet claimed unchanged is re-driven at FINAL when your fix touches its surface.
        SHAPES: none claims nothing probed is left unbuilt — never that unbuilt probes were left
        unnamed.
TRIPPED: <copied from check-scope's tripped: line>
PROPOSED ROWS: <ledger rows, or none>
METHOD FRICTION: none | <where you deviated from the method or its templates, misread them, or
  found them silent. A defect in the brief is a FINDING, not friction. This form is exhaustive:
  every field is filled and nothing outside it is added. A departure from the form is friction
  even when it changes no outcome — silence is not compliance.>
INHERITED:
<<every INHERITED item you received that is still open, copied verbatim; then each
  finding you marked carried, with its ID>>
Rule 2 governs the planner's copy of this block. What goes in it is yours: an implementer or
reviewer who received an obligation, finding, entry or trigger carries it forward verbatim, and
adds anything new that is still open. A block reading `none` is correct only when nothing came in
and nothing is open. INHERITED never carries residual rows; they are re-selected from the store per
brief.
--- END BRIEF UNDER REVIEW ---

You did not write this code and you will not fix it; a finding is output, not an action. The step's
decision is the planner's (cycle step 5): report findings, never decisions. The commits under review
carry the trailer `Actor: IMPLEMENTER`; if your session wrote any of them, stop and say so. Run
REVIEW ACCEPTANCE first: it is the method's only gated check. The ACCEPTANCE lines inside the brief
under review are the implementer's; re-run them to verify the delivery, and run `scripts/check-tests`
as your standing battery — the full suite is your falsification ground — recording both in `VERIFIED`.
The embedded brief is a convenience copy: if the
standalone file it names differs, file a FINDING with ORIGIN: BRIEF and review against the committed
file.

You may create new test files to prove a finding, and modify nothing else. If a failing test would
need registering in tests/open_defects.yaml, say so in the report and leave the registration to the
next implementer brief rather than editing that file; the registry owns test_bug_* pins only, and a
test_review_* probe rides red until absorbed. Read pre-images with git show <rev>:..., not
the implementation's account of them. Run every mutant on a scratch copy of the tree, and diff each
mutant against git show <rev>:... before trusting its result. Attempt to falsify the brief, not only
the code: a finding that the brief was wrong is a finding, and so is a defect the implementer filed
only as friction. Answer every item under QUESTIONS TO ATTACK. Answers live in the form's fields —
a finding in FINDINGS, a measurement in VERIFIED/SHAPES. An added review's QUESTIONS TO
ATTACK come only from the implementer's report — never from another review's findings. Enumerate
the shapes you probed that
the existing suite does not build, as a list; zero with a stated reason is legitimate. Report each
guarantee as falsified-with-reproducer or attacked-and-not-falsified with the method.

Commit your own work: your new test files and your report, together, in one commit whose message
ends with the trailer `Actor: REVIEWER`. Append docs/templates/report.txt verbatim, fill it in, and
write it to docs/research/<phase>-<subject>-review.md. If you cannot commit, stop and say so.
