IMPLEMENTER BRIEF — phase5-run-entry-fixes-2 (Phase 5: the settle-route fixes — F17–F25)

GOAL: F17–F25 are disposed and the settle seam's history tells the truth. F18: the settle records exactly one `FAILURE_RECORDED` per observed failure and reaches its terminal outcome through the node machine's existing deterministic-infeasibility route — `NODE_MARKED_INFEASIBLE` on `any_non_terminal` ([node-lifecycle.yaml](../tables/node-lifecycle.yaml), guard "Deterministic infeasibility policy passes") — via a small public `Controller` surface beside `record_failure`/`evaluate_repeated_failure`; the manufactured second stamp is gone, `evaluate_repeated_failure` and the repeated-failure rule are unchanged, and `inspect` shows one observed failure for one overrun with no `REPLAN_REQUESTED` of reason `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`. F20: the settle settles the timed-out attempt's accounting regardless of the run's outcome read (a `TIMED_OUT` attempt is never left `PROVISIONALLY_SETTLED` on a terminal run), skips the node-level chain when the fresh outcome is already terminal at the point of emission, and the returned `StartResult`/CLI JSON carries the fresh outcome re-read after the settle's own admissions. F19: `ProtocolViolation` settles through the same recorded-refusal path as `AttemptTimedOut`/`AttemptCancelled` — the Settled-start shape's three named classes hold as written, never a traceback with a live run. F21: the fail-closed claim is narrowed to what is true in `docs/run-entry.md` and `run_entry`'s module docstring — a loader-refusable malformed spec is refused before any store is opened or any event is admitted; a freeze-boundary refusal (a DECLARED divergence, an unfreezable repository) admits zero events and may leave the store file created — and the pin covers the divergence class's zero-events honesty. F23: the import pin checks every dotted segment of an import path, not only the leaf, and a dotted-import row (`import orchestrator.experiment.trial_driver`) is red at the delivered helper. F24: the clean-env pin runs the documented `python3` form (or tries the system interpreter first and falls back to `sys.executable`, naming the choice in its docstring, which currently misstates what it runs). F17 closes with this brief's commit: the `ACCEPTANCE` line below names the interpreter that can go green. F22 and F25 close as `fixed: recorded in docs/research/phase5-run-entry-fixes-review.md` (defects in an already-committed report — nothing can correct it in place, R8's precedent); their substance is discipline here: every `FIXED` line names the delivered file's line numbers or none at all, and `SHAPES` names everything unbuilt (the dynamic-import class included).

CONTEXT: The review (`docs/research/phase5-run-entry-fixes-review.md`) reproduced all six reds at `REV` and filed nine findings; F11–F16 stay fixed (its answer 6) and the run-entry step's held set stays held (its answer 9). The settle route already exists in the normative tables: `NODE_MARKED_INFEASIBLE` transitions `any_non_terminal` to `INFEASIBLE` with the guard "Deterministic infeasibility policy passes" ([node-lifecycle.yaml](../tables/node-lifecycle.yaml)) — so no `docs/tables/*` change, no new event, and no catalogue or conformance entry are needed (`NODE_MARKED_INFEASIBLE` and `FAILURE_RECORDED` are catalogued and the emitter is `Controller`). This brief's stated reading of that guard for the settle path: an executor-level terminal condition (`AttemptTimedOut`, `AttemptCancelled`, `ProtocolViolation`) that ends the root attempt without an observation is a deterministic infeasibility of the root's execution, admitted as one recorded failure plus `NODE_MARKED_INFEASIBLE`. F20's claim discipline: the two deterministic interleave orders the review drove (the second process's complete `stop_run` between the launcher's fresh read and its settle steps, and before that read) are the pinned threat; a same-instant adversarial race beyond the check-before-emit claim is outside the pin set and is named in `SHAPES` if it remains. F19's remedy is prescribed as the handler (make the shape's sentence true), not the narrowing; F21's is prescribed as the narrowing (the universal could not be made true — the divergence measure needs the live repository at the freeze boundary). Red at this brief's `REV`: the suite is green — red evidence is written first (see the Red evidence section). `REV` names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson).

INHERITED:

From `docs/research/phase5-run-entry-fixes-implementer.md`:

none — every received item (F11, F12, F13, F14, F15, F16) is fixed by this step, so nothing remains open and nothing is carried.

From `docs/research/phase5-run-entry-fixes-review.md` — its `INHERITED` block, then each carried finding's block from its `FINDINGS` section (the block's own "the findings above" pointer), moved verbatim:

  Nothing received still open — the received list was F11–F16, and each is fixed in FINAL and
  verified above (reds reproduced at REV: F11 line 492, `assert completed.returncode == 0,
  completed.stderr`; F12 line 528 "start_run escaped with AttemptTimedOut…" and line 612
  `"Traceback" not in stderr`; F13 line 426 on both named spellings via the helper-reverted hybrid;
  F14 line 625 with `ModuleNotFoundError: No module named 'orchestrator'`; F16 line 688 "DID NOT
  RAISE RunSpecError") and green at FINAL (31 passed). The implementer report's `INHERITED: none`
  reading is correct against the receipts.
  This review carries, with their IDs, the findings above: F17, F18, F19, F20, F21, F22, F23, F24,
  F25 (all carried, per the template's rule "a defect you will not fix now is carried, never
  declined").

  F17 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The fixes-brief's ACCEPTANCE names a command that cannot go green as written on this host, and the
  report's answer substituted a different command inside the VERIFIED parenthetical instead of filing
  the fact. Measured: bare `pytest tests/test_run_entry.py` (the pytest-9.1.1 on PATH, no
  pytest-timeout plugin) aborts at config load — `ERROR: Unknown config option: timeout`
  (pytest.ini's `timeout` option under `strict_config = true`), collects all 31 test names, awaits
  none, "no tests ran in
  0.03s", exit 4. The literal ACCEPTANCE line is therefore not executable to green by the operator it
  names; the report's VERIFIED reads "ran as .venv/bin/python -m pytest …" — an interpreter the
  ACCEPTANCE does not name, filed as a verified run of a command that was not run, with no METHOD
  FRICTION and no NOT VERIFIED entry and no ORIGIN: BRIEF finding. Per the method, "A defect in the
  brief is a FINDING, never METHOD FRICTION": the owed item was exactly that finding — the J-class
  violation is the substitution itself. Correction the next implementer brief should carry: either
  repair the brief's ACCEPTANCE wording (none is possible post-commit — briefs are immutable records),
  or record the substitution as an honest departure (J-row: a claim not declared against its source —
  the VERIFIED entry's command line is the claim; the executed interpreter is the artifact).
  FIXED: no regression test — a brief-text defect has no failing assertion at any revision; a later
  committed brief must re-cut the ACCEPTANCE line (`pytest tests/test_run_entry.py` is only green
  under the interpreter that has pytest-timeout installed) or the next report's VERIFIED must carry
  the deviation as a declared departure rather than a parenthetical.
  F18 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  `start_run`'s settle path (both `_settle_executor_refusal` (run_entry.py:487) and the pre-existing
  twin in `_bind_acceptance`'s refusal path (run_entry.py:453)) stamps the SAME failure fingerprint
  twice for one observed failure, then solves the repeated-failure gate off the pair it just forged —
  the durable log records a history that never happened. Reproducer on the delivered code (real
  fixture repo, `wall_clock_seconds: 1`, a sleeping visible command, in-process `start_run`): the log
  records exactly one overrun (`TIMER_FIRED`, `ATTEMPT_EXECUTION_ENDED_UNRECONCILED`) and then TWO
  `FAILURE_RECORDED` events with byte-identical fingerprints
  (`sha256:e6b323caed4edce823d6764a1fad8137fc50fb02f4f85be48e0a43cc54a2f3d8` ×2, idempotency keys
  `failure-RUN-Q2-root-1/-2`), and `evaluate_repeated_failure` fires on them (`REPLAN_REQUESTED` with
  reason `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`, then `NODE_MARKED_INFEASIBLE`); `inspect` reads the
  node's failure history back as two observed failures for the one overrun. The trigger is
  `len(fingerprints) >= 2 and fingerprints[-1] == fingerprints[-2]` (controller.py:2043) — the second
  failure is the code's own double stamp. Counterfactual on a scratch copy of FINAL (the loop run
  once — the only delta vs `git show 223596b:src/orchestrator/run_entry.py`, verified by diff): one
  honest stamp yields `NO_ACTION`, the node stays READY, `get_outcome` reads None, `inspect` shows
  `outcome: null` — a single honest stamp settles NOTHING, so the forged second stamp is the only way
  `start_run` reaches the outcome the Settled-start shape demands. Ledger rows: B (coercion, "looks
  close enough" — the two-failure precondition asserted by the rule is satisfied by manufacture) and
  A (the failure-count accounting an auditor reads from `inspect`/replay is laundered). The delivered
  wall-clock pin goes further and ENSHRINES the forgery: `assert len(futures) >= 2`
  (tests/test_run_entry.py:540) passes on two fingerprints for one failure.
  FIXED: no regression test — the pin's red would be: settle one overrun, assert `len(fingerprints)`
  == 1 and that the node reaches its terminal outcome WITHOUT a `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`
  `REPLAN_REQUESTED`; today the node machine has no legal single-failure route from the settle path,
  which is the defect's actual shape (a recorded refusal that must not depend on a manufactured repeat;
  the next brief must decide the route — e.g. an infeasible transition from the recorded-refusal event
  itself — before any pin can be green).
  F19 | SEVERITY: P1 | ORIGIN: BRIEF | STATE: carried
  The Settled-start shape's X_X as delivered: `start_run` catches only

  `AttemptTimedOut` and `AttemptCancelled` (run_entry.py:522-531); no `ProtocolViolation` handler
  exists on the root-execute drive. Mutant on a scratch copy of FINAL: `worktree.py:328`'s bundle
  create ref `HEAD` → `NO-SUCH-REF` (the only delta vs FINAL, verified by diff), so `git bundle
  create` fails for a content reason no path normalisation can fix (`fatal: ambiguous argument
  'NO-SUCH-REF': unknown revision or path not in the tree`, raised as
  `executor_protocol.ProtocolViolation` by `worktree._git`). Reproducer: CLI `start` with an absolute
  workdir (F11's fix stays intact — only the missing ProtocolViolation handler is exercised) — exit 1,
  EMPTY stdout (no JSON document), traceback in stderr, and the store after the escape holds attempt
  DISPATCHED, root node READY, `outcome: None` (`inspect` reads null): the run is live, in the exact
  shape F11's red rejected. The overreach is the brief's: the named remedies cover two of the three
  classes the sentence names (F11 = abs-path at entry for the ProtocolViolation it measured; F12 =
  handlers for the two executor-exception classes); nothing prescribed ProtocolViolation handling, and
  the implementer implemented exactly the remedies without narrowing the shape or filing the gap.
  FIXED: no regression test — a later committed brief either narrows the shape's sentence to the two
  handler classes (with the recovery note that a ProtocolViolation escape remains recoverable via
  `stop`), or prescribes a recorded-refusal path for ProtocolViolation before any pin; carried until
  then.
  F20 | SEVERITY: P1 | ORIGIN: CODE | STATE: carried
  The read-then-settle window in `_settle_executor_refusal` is real under the documented two-process
  workflow: ONE fresh read (`controller.store.replay_fresh(run_id).outcome`) is followed by settle
  steps that all reduce against the STALE in-memory projection (`store.state(run_id)`) with no
  cross-process claim between them. Deterministic two-connection interleave probe (the second
  process's complete `stop_run` inserted between the fresh read and the settle steps; the launcher then
  continues): (a1) the launcher emits its whole forged chain — `ATTEMPT_COST_SETTLED_CONSERVATIVELY`,
  two `FAILURE_RECORDED`, `REPLAN_REQUESTED`, `NODE_MARKED_INFEASIBLE` — as LATE events after the
  second process's `NODE_CANCELLED`: the durable log shows a CANCELLED run AND a forged
  repeat-failure-to-INFEASIBLE trail for the same single overrun (fresh replay keeps outcome
  CANCELLED, node CANCELLED — no ReplayError; the late node events are retained non-mutating), while
  the LAUNCHER's own JSON document reads `outcome: INFEASIBLE`, `accepted: false` — the document is
  NOT "the settled outcome" the exit contract names; it is a stale projection's outcome. (a2) with the
  stop completed before the read, the launcher correctly skips settling and returns the fresh
  CANCELLED — but the timed-out attempt's accounting stays PROVISIONALLY_SETTLED forever: `stop`'s
  `cancel_run` treats TIMED_OUT attempts as terminal and skips them (controller.py:2759-2770), nothing
  finally settles the attempt's ledger, and the run is terminal with an open provisioning liability
  (`fresh`: attempts `[(TIMED_OUT, PROVISIONALLY_SETTLED)]` on a CANCELLED run). The two call sites
  answered: the stop process never stamps failures, so no double-FAILURE pair fires from stop; the
  double-`_settle_if_open` cannot fire (the second settle's idempotency key dedupes inter-process);
  `replay_fresh` per escape is a full genesis replay (affordable for a one-shot CLI) but is read ONCE
  while the following mutations reduce stale — the read surface is half-fresh, which is exactly the
  hole. Interleaving (a1) also reproduces F18's forged pair in the CANCELLED flow — the defects
  compound, not overlap.
  FIXED: no regression test — the eventual reds would drive the two interleave orders above
  (deterministically, by inserting the stop between the replay and the settle) and assert: the JSON
  document equals the durable fresh outcome; the log holds no late forged chain; and a terminal run
  never leaves attempt accounting PROVISIONALLY_SETTLED on TIMED_OUT attempts (the launcher must
  settle the attempt regardless of the outcome read, and must re-read the fresh outcome after its own
  settle emissions).
  F21 | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  The Fail-closed-load shape's and the GOAL's "every malformed run-spec class is refused before any
  store is opened" remains false as delivered for the classes the remedy could not reach. The CLI
  constructs `EventStore(os.path.abspath(args.store))` (store.py:117-131: `sqlite3.connect` +
  `PRAGMA journal_mode=WAL` + `executescript(_SCHEMA)` — the file is created at construction) BEFORE
  `start_run` runs, so every freeze-boundary refusal leaves the store file behind. Measured with a
  nonexistent `--store` path: a DECLARED spec whose axes do not match the measured set — valid
  obligation schema (`child_id`/`scope`/`criterion_ids`/`acceptance` present) so the check is reached —
  refuses exactly as the original F16 text quoted (`RunSpecError: cannot freeze target
  'TARGET-RUN-Q5-DIV': declared obligations … are not admissible: measured divergence [], declared
  axes ['ALLOCATION', 'EDGES', …]`), exit 1, zero events, traceback in stderr — AND the store file
  exists on disk after the refusal. Same for the `cannot freeze target …: target repository
  '/tmp/kilo/does-not-exist' does not exist` class. The verdict named by the question: ORIGIN: BRIEF
  narrowing — the prescribed remedy (move the obligations completeness check into `validate_run_spec`)
  could not make the shape's universal "every class … before any store is opened" true: the divergence
  measure needs the live repository and sits at the freeze boundary by construction, and the
  cannot-freeze classes are the freeze boundary itself. The delivered doc sentence
  (docs/run-entry.md:12) and the module docstring's "before a store is touched" (run_entry.py:7-8)
  remain false universals, and the delivered F16 pin's CLI half now only exercises the
  loader-refused form (the earlier notch), leaving the freeze-refused classes unpinned.
  FIXED: no regression test — a later committed brief either narrows "malformed run-spec class" to
  the loader-refusable classes in the shape and both doc sentences (with the freeze boundary honestly
  named as where the divergence class refuses), or moves the divergence check to the loader (it has
  the repository path; the commit still resolves inside `build_target`) — carried until either.
  F22 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The implementer report's red-evidence FIXED citations name line numbers that neither the delivered
  test file nor one consistent scratch layout reproduces: F11 line 491 vs actual 492
  (`tests/test_run_entry.py`, `assert completed.returncode == 0, completed.stderr`); F12's wall-clock
  518 vs actual 528 and cancelled 605 vs actual 612 (`assert "Traceback" not in stderr`); F13 line
  426 vs actual 436 (`assert leaves & _FORBIDDEN_MODULES`); F14 618 vs actual 625; F16 681 vs actual
  688 (`with pytest.raises(run_entry.RunSpecError)`). The assert CONTENTS and failure messages are
  verified correct everywhere (every red reproduced by me: F11 red =
  `assert 1 == 0` at line 492 with the bundle-create ProtocolViolation; F12a red = "start_run escaped
  with AttemptTimedOut…" at 528; F12b red = line 612; F14 red = line 625 with `ModuleNotFoundError:
  No module named 'orchestrator'`; F16 red = "Failed: DID NOT RAISE RunSpecError" at 688; F13's two
  mutants red = 426/`the pin misses the 'relative-import' spelling: []` and
  `['orchestrator']` for named-import). The numbers' provenance is explainable — the helper-reverted
  hybrid file is 10 lines shorter than the delivered one, so F13/F12a's citations match THAT hybrid
  (426/518 exactly) while the rest match neither the hybrid nor the delivered file — but the
  committed citation set is internally inconsistent, and a replay that follows the report's line
  numbers lands off-target in every case. The assertions were named correctly; only the line numbers
  are wrong.
  FIXED: no regression test — a defect in an already-committed report; the citation set should have
  named the delivered file's line numbers (or no line numbers and only the named assertions). Recorded
  in the review that filed it; nothing can correct the committed text in place.
  F23 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The extended import pin's `ast.Import` arm misses the dotted absolute-import spelling: the leaf
  collapse `_module_leaf` keeps only the last dotted component, so `import
  orchestrator.experiment.trial_driver` collects leaves = {'trial_driver'} and the pin's
  `_FORBIDDEN_MODULES` intersection is empty — the shape's own named class ("ast.Import names", the
  extended helper's guarantee "including the two the review's mutants reached green") is STILL not
  closed: a dotted path into a harness submodule (what `import orchestrator.experiment_spec.sub`
  would be for a future harness layout) sneaks through. Measured against the delivered helper
  directly (the eight-spelling probe; the four brief-named spellings all FLAG:
  `from orchestrator.experiment import run_measured_comparison` collects
  {'experiment','run_measured_comparison'}, `from orchestrator.experiment_spec import
  ExperimentError as E` collects {'experiment_spec'}, `import orchestrator.experiment` and
  `import orchestrator.experiment_spec as spec` both flagged); only the dotted case is missed.
  FIXED: no regression test — the spelling pin's parametrisation gains a dotted-import row
  (`import orchestrator.experiment.trial_driver\n`) whose assertion at the delivered helper is RED;
  the helper fix is one line: check every dotted path segment of the import against the forbidden set, not only the leaf.
  F24 | SEVERITY: P2 | ORIGIN: CODE | STATE: carried
  The Clean-env CLI pin launches `[sys.executable, str(_SCRIPT), …]` — the venv interpreter — while
  the doc row and the pin's own docstring name `python3 scripts/orchestrate.py`. The literal form is
  NOT exercised by the pin: on a host whose system `python3` lacks `yaml` (run_entry's one third-party
  import path the CLI reaches at `load_run_spec`), the pin stays green while the documented form
  fails to start. On THIS host the literal form is verified real: `env -u PYTHONPATH python3
  scripts/orchestrate.py --help` → exit 0, usage output; a real `start` (accept), `inspect`, `stop`
  and the mid-run-cancelled launcher form all run from the repo root with a clean env under the system
  python3.13.5 — exit codes 0/1 as documented, JSON documents naming the run, no `Traceback` in
  stderr, and after a `stop` the launcher's document reads `accepted: false, outcome: CANCELLED` —
  the documented contract holds today by hand-verification. The J-class half: the pin claims the
  form it does not run (the interpreter the shape names is the documented `python3`, the interpreter
  the pin executes is the venv's) — behaviourally sound here, enforced nowhere.
  FIXED: no regression test — the pin could pass the literal `python3` form OR try the system
  interpreter first and only fall back to `sys.executable` (naming the choice in its docstring,
  which currently misstates what it runs). Carried: the shape today depends on the host's
  system `python3` having `yaml`. Also noted for the SAME J-class family: F17's substitution and this
  substitution are two instances of the one departure class (the command executed is not the command
  named) — row J earns its second sighting this step.
  F25 | SEVERITY: P2 | ORIGIN: DOCUMENT | STATE: carried
  The report's SHAPES claim ("none — every named shape is built in tests/test_run_entry.py; nothing
  probed by hand was left unbuilt") is false read against the code this step changed. Probed shapes
  the suite does not build, each pinned by my reproducers this review: (i) the ProtocolViolation
  escape class (F19 — no suite case drives `start_run` into a mid-dispatch ProtocolViolation); (ii)
  the settle/stop interleavings — both orders of the second process's stop against the settle window
  (F20; the delivered cancelled-launcher pin only exercises stop-before-read, and its tolerances
  hide the stale-read order entirely); (iii) the freeze-refused classes' store-file creation (F21 —
  the delivered F16 pin's CLI half only exercises the loader-refused form after the fix); (iv) the
  dotted absolute-import spelling (F23); (v) the dynamic-import class (`__import__("orchestrator
  .experiment")`, `importlib.import_module`) — probed by me and left unenforced by the four-spelling
  pin and named in no shapes entry; it belongs there per the review's own question, as a static pin's
  known unenforced class (the dynamic class is outside ast in a way the DELIVERED helper cannot reach
  without new linting, but the shapes section should have said so instead of claiming nothing was
  left unbuilt). Also extra: the confirmed-clean shape "stop of a settled timed-out run is idempotent
  and the late-event rule holds under a DOUBLE stop" (probed clean this review — the run stays
  INFEASIBLE, `[(TIMED_OUT, FINALLY_SETTLED)]`, no ReplayError) is a property the suite partially
  builds (`test_stop_never_rewrites_a_settled_outcome`) but does not build for the timed-out-accounting
  variant — folded into F20's eventual reds rather than a new finding.
  FIXED: no regression test — a false "nothing left unbuilt" claim in an already-committed report;
  the shapes inventory above belongs to the next brief's reds. Recorded in the review that filed it.

Expected dispositions (rule 8 forms): F18, F19, F20, and F23 fixed with red evidence (named below); F21 and F24 `no regression test` (a claim narrowed to truth and a pin made honest — drift-guard pins green at both revisions); F17 `no regression test` naming this brief's commit (rule 8's ORIGIN: BRIEF close: a later committed brief corrects the text — the `ACCEPTANCE` line is corrected here); F22 and F25 `fixed: recorded in docs/research/phase5-run-entry-fixes-review.md` (an already-committed report defect closes as recorded — the api-shape closeout's form for F7 and F9).

IN SCOPE: src/orchestrator/run_entry.py, src/orchestrator/controller.py, docs/run-entry.md, tests/test_run_entry.py

RESIDUALS:

Rule 3 selection for this brief's `IN SCOPE`, copied verbatim from `docs/residuals.md` and byte-verified against it (fenced so the store's relative evidence links are not re-resolved from this directory): `IN SCOPE` matches `PILOT-R1` and `PILOT-R10` trigger globs (`src/orchestrator/controller.py`); `PILOT-R2`–`PILOT-R9` (`decomposition.py`, `planning_pilot.py`, `model.py`, `derive_obligations.py`) do not match and do not ride.

```
| ID | State | Trigger | Risk | Rationale | Evidence |
| --- | --- | --- | --- | --- | --- |
| `PILOT-R1` | accepted | `src/orchestrator/planning_pilot.py`, `src/orchestrator/controller.py`, `src/orchestrator/reducer.py` | mutable admitted payload (wiring constraint): the caller holds a mutable reference to the admitted payload, and a post-return mutation of a child's scope survives the reducer's re-validation. Any integration must therefore not mutate a payload between the guard and event admission. | the admitted payload is mutable; the reducer's re-derivation runs at admission and on replay, so the guard's result is only as safe as the wiring keeps it | [pilot re-review 3](research/phase4-recursive-planning-pilot-re-review-3.md) |
| `PILOT-R10` | accepted | `src/orchestrator/controller.py`, `src/orchestrator/planning_pilot.py` | in-process trusted-code circumvention of the admission capability: the capability is not reconstructible from data, but trusted code running in-process can hold or mint one and admit anything — if untrusted code is ever loaded in-process, the capability boundary does not hold | R1's prevention-shape ruling: the capability's threat model is data-only reconstruction, and trusted-code circumvention is recorded here rather than claimed solved | [owner rulings](record.md#owner-rulings) (R1) |
```

A tripped trigger is a finding: fixed with red evidence, or carried into the closeout with its reason. `scripts/check-scope` prints the `tripped: <ids>` line your report's `TRIPPED` field copies. Both rows stay accepted: this brief's path never admits a decomposition (so no admitted payload exists to mutate), and `PILOT-R10` is not closed.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-fixes-2-brief.md`). A committed brief is never modified; a re-cut is a new file.
- The controller stack beyond one small public infeasible-marking surface on `src/orchestrator/controller.py`: `reducer.py`, `store.py`, `executor.py`, `executor_protocol.py`, `command_executor.py`, `acceptance_checks.py`, `schemas.py`, `glossary.py`, `experiment_target.py`, `derive_obligations.py`, and the experiment harness (`experiment.py`, `experiment_spec.py`, `experiment_phases.py`, `trial_driver.py`, `hidden_oracle.py`, `scripts/smoke_run.py`, `scripts/stress_run.py`). `scripts/orchestrate.py` prints the `StartResult` unchanged and needs no edit; if it must change, or if `controller.py` needs more than the marking surface and the settle's existing calls, stop and report `IN SCOPE` as insufficient.
- `evaluate_repeated_failure`, the repeated-failure rule's semantics, and `record_failure`'s fingerprint material stay unchanged (the one-stamp fix is the caller's; the route change is the marking surface, not the rule).
- Any `docs/` file except `docs/run-entry.md` and your report: no `docs/tables/*` change and no table regeneration (`NODE_MARKED_INFEASIBLE`'s transition already exists — cite it), 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, no `docs/self-host.md` edit (the status concern is already in `record.md#pending-for-the-owner`).
- Model-produced candidates and recursive decomposition driving (unchanged): `start` drives the root's execution only.
- Registry and control files: `tests/open_defects.yaml`, `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. The review's mutants are regression guards, not defects to register; if a registry meta-gate demands a row anyway, stop and report.
- No new dependencies, no tooling configuration, no reformatting. No new `*Executor` or `*ModelClient` class and no provider-registry registration. No new arm and no `docs/tables/limits.yaml` change.
- Name no test `test_bug_*` (the open-defect registry would then own it).
- Do not mutate an admitted payload between the guard and event admission.

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.py
    .venv/bin/python -m pytest tests/test_milestone2_conformance.py
    .venv/bin/python -m pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope 544a0bf0ae130d7391d5215054c78ca60bebd81d <FINAL> docs/research/phase5-run-entry-fixes-2-brief.md

Every `pytest` line names `.venv/bin/python -m pytest` deliberately — F17's correction carried into this brief's text: the bare `pytest` on PATH has no `pytest-timeout` and `pytest.ini`'s `strict_config = true` rejects the run on this host (`ERROR: Unknown config option: timeout`, exit 4), so the named interpreter is the one that goes green; run these lines exactly as written and claim them under these names. `tests/test_milestone2_conformance.py` is named because the settle admits `NODE_MARKED_INFEASIBLE` from a new site under the existing transition. `tests/test_phase3_project_oracle.py` is named under the standing rule for `tests/` changes. 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` `544a0bf0ae130d7391d5215054c78ca60bebd81d` (command `scripts/check-tests`; each unit must be replayable): the suite is green at `REV`, so each red is written by this step and demonstrated at `REV` against the unfixed code (scratch copy diff-verified against `git show 544a0bf0ae130d7391d5215054c78ca60bebd81d:…` before use). `FIXED` names the pin's node id, the command, the named failing assertion, and the delivered file's line numbers or none (F22). Named reds to produce: the one-stamp settle pin (F18 — at `REV` the log shows two `FAILURE_RECORDED` with byte-identical fingerprints and a `REPLAN_REQUESTED` of reason `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`; the pin asserts one fingerprint per observed failure, no repeated-failure `REPLAN_REQUESTED`, and a terminal outcome); the two interleave pins (F20 — at `REV` the stale order's JSON reads `INFEASIBLE` while the durable outcome is `CANCELLED`, and the fresh order leaves the `TIMED_OUT` attempt `PROVISIONALLY_SETTLED`); the `ProtocolViolation` escape pin (F19 — at `REV` the exception escapes `start_run` with the run live); the dotted-import row (F23 — red at the delivered helper). F21, F24, and F17 close `no regression test` (claim narrowed to truth, pin made honest, brief line corrected); F22 and F25 close `fixed: recorded in docs/research/phase5-run-entry-fixes-review.md`.

Slow-mark convention: every case in `tests/test_run_entry.py` stays slow-marked by the module's existing `pytestmark = pytest.mark.slow` (`src/orchestrator/project_oracle.py:731`'s internal gate runs `scripts/check-tests --fast`, and the pre-commit hook deselects the same way); no new module is needed. The named `.venv/bin/python -m pytest tests/test_run_entry.py` line runs them directly.

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:

- `Honest-settle shape` (F18): one `FAILURE_RECORDED` per observed failure; the terminal outcome admitted through `NODE_MARKED_INFEASIBLE` on `any_non_terminal` under the guard as this brief reads it; `inspect`'s failure history reads one for one overrun; no `REPLAN_REQUESTED` of reason `REPEATED_FAILURE_WITHOUT_NEW_EVIDENCE`; `evaluate_repeated_failure` and the fingerprint material untouched. The review's single-honest-stamp counterfactual is this pin's twin (`NO_ACTION` at `REV` is red; the new route settles).
- `Settle-claim shape` (F20): both deterministic interleave orders leave (a) the returned and printed outcome equal to the durable fresh outcome, (b) no node-level chain admitted after a second process's settlement, and (c) every `TIMED_OUT` attempt conservatively settled (`FINALLY_SETTLED`) on a terminal run. The double-`stop`-after-settled-timeout variant (the review's clean probe) is built here too. Any same-instant race beyond the check-before-emit claim is named in `SHAPES`, not hidden.
- `ProtocolViolation-refusal shape` (F19): the third named escape class settles through the recorded-refusal path — a dispatch that raises `ProtocolViolation` (inject it) yields a settled refusal and a terminal outcome, never a traceback with a live run.
- `Honest-fail-closed shape` (F21): the loader-refusable classes refuse before any store is opened (the delivered pin stays); the freeze-boundary classes — the DECLARED divergence class with a fully valid obligation schema and the unfreezable repository — admit zero events and leave the store-file honesty the narrowed wording claims; the two doc sentences match the measured behaviour exactly.
- `Import-spelling shape` (F23): every dotted segment of an import path is checked against the forbidden set (the `import orchestrator.experiment.trial_driver` row red at the delivered helper); the dynamic-import class (`__import__`, `importlib.import_module`) is named in the pin's docstring as a static pin's known unenforced class.
- `Documented-interpreter shape` (F24): the clean-env pin runs the documented `python3` form (or tries the system interpreter first and falls back to `sys.executable` with the choice named in its docstring), and its docstring states what it actually runs.

REV: 544a0bf0ae130d7391d5215054c78ca60bebd81d
CLOSE OUT: yes
DIVERGENCES: none

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>
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>
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.>
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.
