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.
