IMPLEMENTER BRIEF — phase5-run-entry (Phase 5: the run-spec over an arbitrary repository, the operator start/inspect/stop CLI, and the evidence-policy binding)

GOAL: The Phase 5 run entry point exists. A documented run-spec points the controller at an arbitrary repository and base commit and configures the run's owned scopes, budgets and limits, its control-policy version, and its evidence policy — a level from [Evidence policy levels](../glossary.md#evidence-policy-levels) plus a version. `scripts/orchestrate.py` carries the operator workflow the harness has stood in for: `start` freezes the target through `experiment_target.build_target`, builds a `RunConfiguration` that `Controller.submit_run` admits, and drives the run's root execution to a settled attempt and an evidence-bound acceptance claim or recorded refusal; `inspect` prints the run's status, outcome, candidate reference, evidence, costs, and event history read-only from the store; `stop` settles every live attempt and admits the run's cancellation. The configured scopes, budgets, control-policy version, and evidence policy are observable in the admitted root contract — the evidence policy recorded beside the control-policy version in the frozen `run_specification` binding. The entry point imports no experiment-harness module (`orchestrator.experiment`, `orchestrator.experiment_spec`, `orchestrator.experiment_phases`, `orchestrator.trial_driver`, `scripts.smoke_run`); `orchestrator.experiment_target` is the allowed seam. F10's docstring half (INHERITED) is fixed in `AdmissionCapability`'s docstring.

CONTEXT: Phase 5's run-entry item ([self-host.md#phase-5-run-entry-point](../self-host.md#phase-5-run-entry-point)) is selected: Phase 4 is complete as delivered by the integration stream — measured at this commit, `trial_driver._route_decomposition` routes the recursive arms through `planning_pilot.propose_decomposition`, `Controller.propose_decomposition` requires a minted admission capability, the derived entry is `admit_derived_decomposition`, and Phase 4's three named blockers are cleared (R1 and R2 are consumed Record rows; the pilot residual surface migrated into `docs/residuals.md` under R3) — so the roadmap prose's "blocked on two OWNER rulings" sentence no longer describes the tree (a concern for the OWNER, recorded at closeout). Stated readings, each consistent with the rest of this brief: (1) the experiment harness is the four-arm comparison — `src/orchestrator/experiment.py`, `experiment_spec.py`, `experiment_phases.py`, `trial_driver.py`, `hidden_oracle.py`, `scripts/smoke_run.py`, `scripts/stress_run.py`; `experiment_target.build_target` is Phase 2's generic seam and is allowed (its internal lazy `experiment_spec.ExperimentError` import stays inside the builder). (2) `start` drives the root node's ready EXECUTE over the run-spec's visible commands through an injected `DispatchBase` executor (the CLI builds a `CommandExecutor` over the target's visible commands) and binds acceptance with `VisibleAcceptanceChecker` evidence admitted through `Controller.admit_evidence` and `Controller.authorise_acceptance` against the node's own produced result; model-produced candidates, the patch/review path, and recursive decomposition driving are not this brief. (3) The evidence policy is a `{level, version}` pair — level one of [Evidence policy levels](../glossary.md#evidence-policy-levels) through a new `glossary` accessor (the catalogue is never redefined locally), version a positive int — carried as an optional `RunConfiguration` field and recorded beside `policy_version` in the frozen `run_specification` binding `Controller.submit_run` writes; the run-spec freezes its `experiment_manifest` reference from its own content digest and its `project_kernel` reference from the named repository commit. (4) `REV` names the step's base — the parent of this brief commit — and is not claimed to be `FINAL`'s parent (F4's lesson). The working tree at dispatch is clean.

INHERITED:

F10 (docstring half) | SEVERITY: P2 | ORIGIN: BRIEF | STATE: carried
  `AdmissionCapability`'s claim that "construction without the module-private mint nonce is refused", falsified by `copy.copy` and by `__new__` — is live code and stands as the only carried item.
  The clause should read data-only construction, matching the Capability shape's "a caller holding only data cannot construct one"; as written it invites a reader to claim a third-mint closure that `PILOT-R10` does not buy.
  FIXED: no regression test — an ORIGIN: BRIEF finding is fixed once a later committed brief corrects the text; none has at this commit.

The first line is R8's (`docs/record.md#owner-rulings`) and the two lines after it are the review's remedy clause and `FIXED` line moved verbatim from `docs/research/phase4-recursive-planning-integration-api-shape-review.md`. R8 keeps this half alone — "its brief-wording half has no possible action and closes" — and the closeout closed F7, F8, and F9 (F8's rename lesson as an Observation in `docs/record.md`), so this docstring half is the only item that rides.

IN SCOPE: src/orchestrator/run_entry.py, scripts/orchestrate.py, docs/run-entry.md, src/orchestrator/schemas.py, src/orchestrator/glossary.py, src/orchestrator/controller.py, 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 mutates an admitted decomposition payload between the guard and event admission (it never admits a decomposition), and `PILOT-R10` is not closed — the docstring fix below must not claim more than the data-only threat model.

OUT OF SCOPE:
- Editing this brief file (`docs/research/phase5-run-entry-brief.md`). A committed brief is never modified; a re-cut is a new file.
- The experiment harness: `src/orchestrator/experiment.py`, `experiment_spec.py`, `experiment_phases.py`, `trial_driver.py`, `hidden_oracle.py`, `scripts/smoke_run.py`, `scripts/stress_run.py`. `src/orchestrator/experiment_target.py` and `src/orchestrator/derive_obligations.py` are the allowed seam — call `build_target`; do not change them. If one of these must change, stop and report `IN SCOPE` as insufficient.
- Model-produced candidates: the patch/review path (`src/orchestrator/model.py`, `patch_executor.py`, `model_adapter.py`, `Controller.run_model_review`) and recursive decomposition driving (the planning pilot, `Controller.admit_derived_decomposition`, `plan_decomposition`). `start` drives the root's execution only.
- Completing [Acceptance binding](../validation.md#acceptance-binding)'s full list (node-contract version, input versions, artefact hashes, validator and test versions, environment version, acceptance authority): the bindings shape is pre-existing (R09); this brief records the evidence policy beside the control-policy version in the `run_specification` binding only.
- Selecting an executor from `executor_profile` (the field is required by the `RunConfiguration` schema and stays a label; executor selection is separate work).
- 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. No `tests/fixtures/` change is required (the new schema field is optional); if you believe one is needed, stop and report `IN SCOPE` as insufficient.
- Any `docs/` file except `docs/run-entry.md` and your report: no `docs/event-catalogue.md` change and no new event type, no `docs/control-plane.md` freeze, no `docs/residuals.md` or `docs/record.md` edit, no `docs/tables/*` change, and no `docs/self-host.md` edit (the phase status is the OWNER's between steps).
- 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).

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

    scripts/check-tests --fast
    pytest tests/test_run_entry.py
    pytest tests/test_harness_schemas.py tests/test_boundary_mutations.py tests/test_categorical_completeness.py
    pytest tests/test_phase3_project_oracle.py
    scripts/check-static
    scripts/check-docs
    scripts/check-scope a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c <FINAL> docs/research/phase5-run-entry-brief.md

Never put a full run in `ACCEPTANCE`; the reviewer runs `scripts/check-tests`. The three suite modules are the changed schema and catalogue surface (`RunConfiguration` mutations and the new `glossary` accessor). `pytest tests/test_phase3_project_oracle.py` is named under the standing rule for new files under `tests/` and `scripts/` (it was named for the same reason in `phase4-recursive-planning-integration-provider-brief.md`). `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, fixed as `no regression test` — `61e6d07`).

Slow-mark convention: any new module under `tests/` slow-marks every case (`@pytest.mark.slow`), because 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`. `tests/test_run_entry.py` slow-marks every case, and `pytest tests/test_run_entry.py` above 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:

- `Run-spec load shape`: a run-spec naming an arbitrary repository and base commit loads fail-closed and freezes the target through `experiment_target.build_target`; the produced `RunConfiguration` is admitted by `Controller.submit_run`, and the admitted root contract carries the configured owned scopes, budgets, limits, control-policy version, and evidence policy in the frozen `run_specification` binding beside `policy_version`.
- `Configuration refusal shape`: every malformed run-spec is refused before any event is admitted and with no store writes — an evidence-policy level that is not one of [Evidence policy levels](../glossary.md#evidence-policy-levels), an evidence-policy version that is not a positive int, an unknown budget dimension (outside [Budget dimensions](../glossary.md#budget-dimensions)), a missing or empty repository or base commit, and a `RunConfiguration` the schema would reject. Each refusal is a named load-time error, never a run-time surprise.
- `Start shape`: `start` drives the root node's ready EXECUTE to a settled attempt and an evidence-bound acceptance claim or recorded refusal — plan, dispatch over the run-spec's visible commands, observation and result admission, `VisibleAcceptanceChecker` evidence admitted via `Controller.admit_evidence`, and `Controller.authorise_acceptance` bound to the node's own produced result. Failing visible commands are a refusal: failing checks are recorded and acceptance is never authorised. The run reaches a terminal [Run outcomes](../glossary.md#run-outcomes) value that `Controller.get_outcome` reads.
- `Observe shape`: `inspect` prints the run's status, outcome, candidate reference, evidence, costs, and event history from the store alone and admits no events — including a run started by another process (two `Controller`s over one `EventStore`), read-only end to end.
- `Stop shape`: `stop` on an in-flight run settles every non-terminal attempt and admits the run's cancellation on the root; the admitted outcome of an already-settled run is never rewritten by `stop`.
- `No-harness-import shape`: the run-entry module's and the CLI's own import surface names none of `orchestrator.experiment`, `orchestrator.experiment_spec`, `orchestrator.experiment_phases`, `orchestrator.trial_driver`, or `scripts.smoke_run` — pin the modules' own imports; do not assert on `sys.modules`, which after a `build_target` call legitimately contains `experiment_spec` (the allowed seam's lazy `ExperimentError` import). `orchestrator.experiment_target` is the allowed seam and is the only target-freeze path.
- `Evidence-policy shape`: the evidence policy binds the run — a catalogue level plus a version recorded beside the control-policy version in the frozen `run_specification` binding and read back by `inspect`; an unknown level is the Configuration refusal shape's load-time failure.

REV: a13aacfe2219e3dbd1b6207a28bbe0f980c78b2c
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.
