<!-- informative -->

# R08 Evaluator-Isolation Adversarial Review — Batch 4

- Repo: `/home/ruben/Projectos/meta-project/orchestrator`
- Revision reviewed: `HEAD` = `18ad723` (`18ad7234eb31bbbfce2fdc719f3233f09e15ae61`,
  "Batch 4 MEASUREMENT: isolate the hidden evaluator from candidate code"), frozen worktree
  `/tmp/kilo/r08-review-18ad723`.
- Re-verification: `300325e` (fixes), frozen worktree `/tmp/kilo/r08-review-300325e`; the reviewer's
  original probes re-run from `/tmp/kilo/rerun-300325e/`; suite **512 passed in 96.27s**. See
  [§7](#7-re-verification-against-300325e).
- Reviewer independence: not an author of `18ad723`. The brief, the R08 clause of
  `docs/report-milestone8-readiness.md`, `docs/experiment.md#independent-oracle`,
  `docs/experiment.md#verified-progress`, and the sources (`experiment.py`, `oracle.py`,
  `sandbox.py`, `sandbox_launcher.py`, `worktree.py`, `executor_protocol.py`) were read before the
  implementer's tests. No source was edited; all probes live under `/tmp/kilo/`.
- Baseline: `.venv/bin/python -m pytest -q` (from the frozen worktree) → **509 passed in 102.93s**.
  A green suite is not a verdict.
- Host: kernel `6.12.96+deb13-amd64`, Debian 13, cgroup v2 delegated to
  `…/user@1000.service` (`cpu memory pids`), `NAMESPACE_V1` available, Landlock ABI 6,
  libseccomp api 7.
- No network, no real credentials, no paid calls; synthetic clients and local fixtures only. No host
  cgroup configuration was changed outside the reviewer's own delegated subtree.

---

## 1. Verdict

**NO-GO for the R08 guarantee as stated.** The central claim — "a hidden check must not share an
interpreter with candidate code", and the commit's own "the collector never imports candidate code"
— is **false on this revision**. The trusted collector is launched as `/usr/bin/python3 -c <script>`
with its working directory at the candidate mount `/work`; for `-c`, CPython prepends the current
directory (`''`) to `sys.path`, so the collector's opening `import json, subprocess, sys` resolves
candidate-supplied `/work/json.py` (or `/work/subprocess.py`). A candidate tree that contains a
top-level module therefore **executes in the collector**, and `hidden_runner` grades whatever
`COLLECT:` line that candidate code chooses to emit. For a functionally broken candidate
(`parse` returns `[]`) plus a top-level `json.py`, `hidden_runner` returns **`PASS`** (F1).

Reachability caveat, stated plainly: for the frozen target `owned_scope` is `src/**` and the
publication gate (`worktree.py:276-324`, `path_in_scope` rejects absolute/`..` paths) refuses
top-level files, so *this target's* candidate cannot plant a shadow module through the candidate
pipeline; the false pass requires a separate R07 scope escape (out of scope here). The guarantee is
nonetheless unconditional, the harness (`hidden_runner`) is generic and is the same one used for
calibration and any future target, and the defect is closed by a one-line environment change.
F2 and F3 are required follow-ups and do not by themselves block the gate.

**Re-verdict on `300325e`: GO for the R08 guarantee.** F1, F2, and F3 are closed and the original
reproducers now fail to reproduce (the F1 shadow and forge probes, the F2 flood probe, and the F3
hash probe all report the fixed behaviour; §7). The collector no longer imports candidate code, the
child's captured output is bounded, and the freeze hash binds what each check executes and asserts.
The verdict and findings below describe `18ad723`; §7 records the `300325e` re-verification.

---

## 2. Findings

### F1 — P1 — The "trusted collector" executes candidate code (cwd `/work` is on its `sys.path`)

- **Invariant violated (claim 1 / claim 4; commit message):** *"candidate code must not … escape the
  boundary to influence grading"* and *"The collector never imports candidate code and contains none
  of the expected values."*
- **Root cause:** `experiment.hidden_runner` builds
  `command=("/usr/bin/python3", "-c", script)` (`experiment.py:646`) and the launcher `chdir`s to the
  plan workdir before exec (`sandbox_launcher.py:280`, `os.chdir(workdir)`, workdir `"/work"`;
  `sandbox_launcher.py:438` `os.execvpe`). For `python -c`, `sys.path[0]` is `''` (the cwd), so the
  collector's first statement — `import json, subprocess, sys` (`experiment.py:587`) — searches
  `/work` first. `_HIDDEN_ENV` (`experiment.py:512-520`) does not set `PYTHONSAFEPATH`, and neither
  `-P` nor `-I` is passed. The same is true of the driver's own `import json, sys`, but the driver is
  untrusted by design; the collector is not.
- **Reproducer:** `/tmp/kilo/r08_shadowpid_probe.py` (candidate tree with a top-level `json.py` that
  records `os.getpid()`); plus `/tmp/kilo/r08_forge_probe.py` for the end-to-end grading impact.
  ```bash
  cd /tmp/kilo/r08-review-18ad723
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/r08_shadowpid_probe.py
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/r08_forge_probe.py
  ```
- **Observed:**
  - `r08_shadowpid_probe.py`: the marker file written by candidate `/work/json.py` contains
    `"1 2 "` — **the collector (PID 1) and the driver (PID 2) both imported candidate code**; the
    sandbox emits `COLLECT:{"shadow": "IMPORTED"}`, i.e. the observation is entirely candidate-authored.
    Adding `-P` to the collector leaves only `"2 "` (collector isolated); setting `PYTHONSAFEPATH=1`
    removes both.
  - `r08_forge_probe.py`: a candidate whose `parse` returns `[]` is graded
    `broken parse + collector shadow -> PASS`, while the identical tree without `json.py` gives
    `broken parse, no shadow -> FAIL`.
- **Expected:** the collector imports only the standard library; candidate-supplied modules never run
  in the process that serialises the observation. `hidden_runner` on a tree whose `parse` is broken
  must return `FAIL` regardless of any top-level file.
- **Why it matters:** this is the R08 boundary itself. Once candidate code runs in the collector it
  controls `subprocess.run` and `json.loads`/`json.dumps`, i.e. the whole observation-production
  path, so every "suppression/forgery" defence collapses to the acknowledged residual (candidate
  knows the expected value). The false pass above needs that residual, but the isolation guarantee is
  broken unconditionally, and defence-in-depth is gone. Reachability for the frozen target is gated
  only by `src/**` scope plus the publication gate — an R07 property the R08 guarantee explicitly
  should not depend on.
- **Fix (validated):** add `"PYTHONSAFEPATH": "1"` to `_HIDDEN_ENV` (covers both the collector and
  the inner `subprocess.run` driver), or pass `-P` on both spawns. `r08_shadowfix_probe.py` shows the
  env change restores the trusted payload.
- **Proposed permanent regression test:** `tests/test_r08_evaluator_isolation.py::
  test_collector_does_not_import_candidate_top_level_modules` — build a known-good tree, add a
  top-level `json.py` sentinel whose `dumps` returns a marker, run `hidden_runner`, and assert the
  result is `PASS` with the genuine payload (not the marker). Additionally assert the collector
  process never imports the sentinel (e.g. sentinel writes `os.getpid()` to `/work/.pids` and the
  test asserts `"1 "` is absent), so the test fails closed if the env fix is ever removed.

### F2 — P2 — The collector buffers the candidate's entire stdout in memory; "bounded responses" is not enforced

- **Invariant violated (R08 Required; claim 3):** *"send inputs to a candidate subprocess and validate
  its **bounded** responses in a trusted harness."*
- **Root cause:** `_collector_script` uses `subprocess.run(..., capture_output=True)`
  (`experiment.py:591`), which accumulates the child's entire stdout in the collector's memory before
  line selection and JSON parsing. Only the *controller-side* `SandboxRunner._drain`
  (`sandbox.py:845-863`) is bounded (1 MiB prefix, full-stream hash); the child→collector pipe is not.
- **Reproducer:** `/tmp/kilo/r08_flood_probe.py`.
  ```bash
  cd /tmp/kilo/r08-review-18ad723
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/r08_flood_probe.py
  ```
- **Observed:** peak sandbox RSS scales with candidate output:
  `1 MiB → 14.8 MB`, `32 MiB → 107.9 MB`, `128 MiB → 412.7 MB`, `256 MiB → 814.5 MB` (all
  `exit=0`, graded `FAIL`). Memory is roughly 3.2× the emitted bytes (pipe buffer + `decode` +
  `splitlines`) and is capped only by `SandboxLimits.memory_bytes` (1 GiB per-process rlimit); it
  grows without bound if that limit is raised.
- **Expected:** a candidate cannot convert output volume into host memory; the collector should stream
  the child's stdout and retain at most a fixed prefix (and, ideally, stop reading / kill the child
  past a cap) exactly as the controller already does.
- **Proposed permanent regression test:** a hidden-runner test that floods the child with `N` MiB and
  asserts the recorded `max_rss_bytes` stays below a fixed bound independent of `N` (and that the
  outcome remains `FAIL`, not `PASS` or an infrastructure error).

### F3 — P2 — The frozen hidden-suite hash does not bind the drivers or the expected values

- **Invariant violated (claim 5; `docs/experiment.md#independent-oracle` "unchanged across arms and
  trials"):** the frozen hash is the integrity anchor that makes the suite immutable.
- **Root cause:** `hidden_suite_manifest_hash` (`experiment.py:721-761`) builds its descriptor from
  `HIDDEN_SUITE_VERSION`, `target.snapshot_hash()`, `oracle_version`, the fixed `execution` block, the
  criteria, and the check metadata (id, criteria, weight, expected *outcome*, timeout, mandatory). It
  never includes `_HIDDEN_DRIVERS` (`experiment.py:535-566`) or `_HIDDEN_EXPECTED`
  (`experiment.py:571-576`), i.e. what each check actually runs and asserts.
- **Reproducer:** `/tmp/kilo/r08_hash_probe.py`.
  ```bash
  cd /tmp/kilo/r08-review-18ad723
  /home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python /tmp/kilo/r08_hash_probe.py
  ```
- **Observed:** after replacing `_HIDDEN_EXPECTED["hidden-parse"]` with
  `{"a": ["PWNED"], "b": [], "c": []}` and appending `# tampered` to every driver, the recomputed
  hash is byte-identical to the original:
  `base_hash == tampered_hash == sha256:ae118c3914df9f61a4f7f256318a92c0d074f73aeeeb4fa01c107efca65dcb65`.
- **Expected:** changing what a hidden check executes or asserts must change the frozen suite hash, so
  the freeze verification (`experiment.py:2622-2625`) actually binds the suite.
- **Proposed permanent regression test:** mutate `_HIDDEN_EXPECTED` / `_HIDDEN_DRIVERS` in-process and
  assert `hidden_suite_manifest_hash` changes; include a digest of the drivers and expected values in
  the descriptor.

---

## 3. Claims verified (attempted falsification, not "tests pass")

| # | Claim | Method / probe | Result |
|---|---|---|---|
| 1 | No expected value, check id, or completion sentinel is reachable from the sandbox | `/tmp/kilo/r08_recon_probe.py`, `r08_fd_probe.py`, `r08_fdwrite_probe.py`, `r08_escape_probe.py`, `r08_hash_probe.py` | **Attacked, not falsified.** The sandbox contains no expected literal, no check id, and no `… ok` sentinel; `/`-walk for `REPORT: A B` / `hidden-parse` / `_HIDDEN_EXPECTED` is empty; `import orchestrator` fails; the host source tree and `/home` are absent. Caveat F1: candidate code *does* run in the collector, but expected values remain controller-side and the collector never receives them. |
| 2 | A forged/injected observation passes only if it equals the hidden expected value | `r08_failure_probe.py`, `r08_forge_probe.py` | **Structurally holds, boundary falsified (F1).** `hidden_runner` returns `PASS` only on `payload == _HIDDEN_EXPECTED[check_id]` (`experiment.py:692-694`); injecting `COLLECT:` into the parent's output channel is blocked by Landlock (see boundary audit), and a wrong payload, an `emit_many_driver_lines` override, and a `fork`ed late writer that does not know expected all `FAIL`. With F1 the collector itself is candidate code, which subsumes forgery. |
| 3 | Early exit, suppression, malformed output, timeout, and infrastructure failure map to `FAIL`, `CANDIDATE_TIMEOUT`, `INFRASTRUCTURE_ERROR`, never `PASS` | `r08_failure_probe.py` | **Attacked, not falsified.** `os._exit(0)`, `os._exit(1)`, `builtins.print` no-op, `dup2`/dev/null, `close(1)`, `json.dumps` raising, SIGKILL self, SIGSYS via a denied syscall, and `kill(getppid(), SIGKILL)` (PID 1 is signal-protected, so the collector survives) all grade `FAIL`; a hanging `parse` grades `CANDIDATE_TIMEOUT`; a wrong result grades `FAIL`. No candidate-reachable path to `PASS` was found without expected knowledge. The inner `CHILD_TIMEOUT` branch is effectively unreachable because the sandbox wall-clock deadline (started at the ready handshake) always expires before the collector's inner timeout (started after interpreter startup); it maps to `FAIL`, not `CANDIDATE_TIMEOUT`, but both are non-pass, so this is not a finding. |
| 4 | Boundary integrity: candidate cannot reach the collector/controller or alter the comparison; teardown leaves no child/cgroup/temp artefact | `r08_fd_probe.py`, `r08_fdwrite_probe.py`, `r08_escape_probe.py`, `r08_resource_probe.py`, `r08_flood_probe.py` | **Falsified (F1).** Candidate code executes in the collector. Otherwise the boundary holds: `/proc/1/cmdline`/`environ` reveal only inputs; the controller's capture files (`/proc/1/fd/1|2`) are `PermissionError` for read and write (Landlock); `ptrace`/`process_vm_readv` are seccomp-denied; the host source and `/home` are not visible; the per-check copy plus digest catches persistent mutation (`mutate_then_keep → FAIL`) and a fork bomb/`fork_holder` leaves no survivors; no new process or cgroup leaks were observed. |
| 5 | Determinism and disclosure: deterministic per tree, tamper detection survives a concurrent writer, disclosure matches execution | `r08_determinism_probe.py`, `r08_hash_probe.py`, source read of `experiment.py:721-761` | **Partially falsified (F3).** Same tree graded three times gives `PASS, PASS, PASS`; a wrong mutation flips to `FAIL`; the `before_digest`/`after_digest` guard (`experiment.py:635,661-664`) catches persistent tree mutation and a restore-only mutation is invisible but cannot help. The `execution` disclosure text (`SANDBOXED_COLLECTOR_CHILD`, `child process of a trusted collector`, `expected_values: controller-side only`) matches the code — but it is *false in fact* under F1, and the hash anchoring it binds none of the assertions (F3). |
| 6 | Host-state hygiene: no orphaned processes, cgroups, or temporary trees | `ps` / `ls /sys/fs/cgroup/…/orchestrator-*` before and after every probe | **Attacked, not falsified.** No descendant survived teardown and no new `orchestrator-*` cgroup remained after known-good, timeout, fork-bomb, flood, or mutation runs. One empty `orchestrator-2030116-…` cgroup dated `17:58` (before this session) pre-existed; it was removed at the end so the delegated subtree is clean. |

---

## 4. Residual unknowns

- **R07 scope dependence.** F1's false pass is unreachable for the frozen target only because
  `owned_scope=src/**` and the publication gate refuses top-level paths. I did not attempt an R07
  scope escape (out of scope). If the target's scope ever widens, or if `hidden_runner` is called
  directly on an unscoped tree (it is a public harness function), F1 is immediately reachable.
- **Adaptive multi-trial probing.** I did not model a candidate that receives per-trial pass/fail
  feedback and searches for the expected payload across trials; each trial's tree is frozen, but the
  experiment reports outcomes. This is the acknowledged unforgeability residual and is unchanged by
  F1.
- **Fixed-input special-casing.** The driver's exact inputs and call sequence are visible to candidate
  code via `/proc/self/cmdline`; a candidate can hardcode responses for the specific hidden inputs
  (the driver's imports make the tested functions obvious). This is inherent to fixed-input
  behavioural checks and was not treated as an isolation finding.
- **No-cgroup host.** F2's memory measurement used the delegated cgroup. On a host without cgroup v2
  the per-process `RLIMIT_AS` still bounds the collector, but the accounting provenance would be
  `RUSAGE_CHILDREN`; I did not re-measure there.
- **`/etc/passwd` readability.** The sandbox could read `/etc/passwd` (world-readable, no secret);
  `/etc/shadow` was absent. This looks unrelated to R08 (no expected values) but the exact Landlock
  rule that permits it was not fully traced; it is noted for the EXECUTION/sandbox review, not
  reported as an R08 finding.

---

## 5. Boundary audit — what sandboxed candidate code can reach

| Reachable object | Access | Contains expected/check-id/influence? |
|---|---|---|
| `/proc/1/cmdline` (collector argv) | read | Collector script + embedded driver. Inputs only; no expected value, no check id, no sentinel. |
| `/proc/1/environ` | read | `_HIDDEN_ENV` only. |
| `/proc/1/fd/0` | read (EOF) | Launcher stdin pipe, already drained. |
| `/proc/1/fd/1`, `/proc/1/fd/2` (controller capture files) | open read/write | **Denied (`PermissionError`)** by Landlock; the files live outside the sandbox view. Injection of a `COLLECT:` line is impossible. |
| `/proc/1/fd/3`, `/proc/1/fd/5` | read/write | The candidate's own stdout/stderr pipes (`subprocess` capture) — no new capability. |
| `/proc/1/mem`, `ptrace`, `process_vm_readv` | denied | seccomp kill / Landlock. |
| Host `/home`, orchestrator `src`, `/root` | absent | — |
| `/work` (per-check copy) | read/write | Candidate's own tree; writes are digest-checked; cannot persist across checks. |
| Collector `sys.path` | **loads `/work` first** | **F1: candidate modules are imported by the collector.** |
| `/tmp` (private tmpfs) | read/write | Shared by collector/child; not read by the collector. |
| Signals to PID 1 | ignored | Kernel PID-namespace init protection. |

---

## 6. Reproduce everything

```bash
cd /tmp/kilo/r08-review-18ad723          # frozen revision 18ad723
PY=/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python

$PY -m pytest -q                                   # baseline: 509 passed
$PY /tmp/kilo/r08_recon_probe.py                   # secrecy recon (no expected/check-id/sentinel)
$PY /tmp/kilo/r08_fd_probe.py                      # inherited fds / Landlock on parent fds
$PY /tmp/kilo/r08_fdwrite_probe.py                 # write to collector stdout -> PermissionError
$PY /tmp/kilo/r08_escape_probe.py                  # host paths / proc-root escape attempts
$PY /tmp/kilo/r08_failure_probe.py                 # failure mapping + injection/ordering
$PY /tmp/kilo/r08_resource_probe.py                # fork bomb / holder / mutation / digest
$PY /tmp/kilo/r08_flood_probe.py                   # F2: unbounded capture memory
$PY /tmp/kilo/r08_determinism_probe.py             # determinism + per-tree mutation
$PY /tmp/kilo/r08_hash_probe.py                    # F3: suite hash does not bind assertions
$PY /tmp/kilo/r08_shadowpid_probe.py               # F1: collector (PID 1) imports candidate json
$PY /tmp/kilo/r08_shadowfix_probe.py               # F1 fix: PYTHONSAFEPATH / -P / -I
$PY /tmp/kilo/r08_forge_probe.py                   # F1: broken candidate graded PASS with shadow
```

No paid calls were made; all clients are in-process/synthetic, and no source file was modified.

---

## 7. Re-verification against `300325e`

Same independent reviewer, same probes, frozen worktree `/tmp/kilo/r08-review-300325e` (probe copies
in `/tmp/kilo/rerun-300325e/`; the only adaptation is the collector's new single-argument signature
`_collector_script(driver)`, whose call sites in the repo and in the probes were updated). Baseline
`.venv/bin/python -m pytest -q` → **512 passed in 96.27s**. The fix diff (`git diff 18ad723 300325e`)
was read before re-running, so the verdict does not rest on the commit message.

### 7.1 Finding-by-finding re-verification

| Finding | Fix under test | Probe | Observed on `300325e` | Result |
|---|---|---|---|---|
| F1 collector imports candidate code | `_HIDDEN_ENV` gains `PYTHONSAFEPATH=1` (`experiment.py:526`); the driver is spawned `[sys.executable, '-P', '-c', driver]` (`experiment.py:605`) | `r08_shadowpid_probe.py`, `r08_shadow_probe.py`, `r08_subshadow_probe.py`, `r08_forge_probe.py` | `COLLECT:{"a": ["a", "b"], "b": ["x", "y"], "c": []}`; `.shadow_pids`/`.subprocess_shadow_ran` **not created** (no import in either process); `broken parse + collector shadow -> FAIL` and `broken parse, no shadow -> FAIL` | **closed** |
| F2 unbounded capture | collector streams the child's stdout and retains ≤1 MiB, killing on overflow (`_COLLECTOR_CAPTURE_CAP`, `experiment.py:532`, streaming loop `experiment.py:591-632`) | `r08_flood_probe.py`, `r08_newcollector_probe.py` | peak RSS flat: `1 MiB → 21.3 MB`, `32 MiB → 21.3 MB`, `128 MiB → 17.2 MB`, `256 MiB → 21.0 MB`, `400 MiB → 15.5 MB`; payload `{"error": "CHILD_OUTPUT_TRUNCATED"}` → `FAIL`; grandchild flood 25.3 MB, driver-then-flood 15.9 MB | **closed** |
| F3 hash binds no assertions | descriptor adds `drivers_hash` and `expected_values_hash` (`experiment.py:800-801`) | `r08_hash_probe.py` | `base_hash sha256:4cd54c02…` vs `tampered_hash sha256:32013d52…`; `hash_binds_assertions True` | **closed** |

### 7.2 Regression checks and new observations (no new findings)

- **Failure mapping unchanged.** `r08_failure_probe.py` on `300325e` reproduces the `18ad723` table
  exactly: early exit / suppression / malformed / self-SIGKILL / SIGSYS / parent-SIGKILL all `FAIL`,
  `spin_forever` `CANDIDATE_TIMEOUT`, wrong result `FAIL`, no candidate-reachable `PASS`. The
  collector's inner `CHILD_TIMEOUT` branch is gone; the sandbox wall-clock is the sole timeout, and
  the hanging-candidate case still grades `CANDIDATE_TIMEOUT`.
- **Secrecy and escape unchanged.** `r08_recon_probe.py` still reports `secret_hits=[]` and
  `import orchestrator` failing; `r08_escape_probe.py` still denies the host source, `/home`,
  `/root`, `/etc/shadow` and writes outside `/work`.
- **The fix removes F1's R07-scope dependence, as claimed.** With `PYTHONSAFEPATH` set, the collector
  and driver resolve `json`/`subprocess` from the standard library regardless of whether a top-level
  module exists, so the isolation no longer rests on the publication gate refusing top-level files.
- **New-collector edge cases.** A forked grandchild that floods the pipe, and a driver that prints the
  correct `DRIVER:` line then floods, are both truncated and graded `FAIL`; the direct-child kill is
  sufficient because the collector stops reading at the cap and the sandbox teardown reaps
  descendants (0 leaked cgroups, 0 leaked processes after all probes).
- **Candidate stderr is now outside the collector's cap.** The child's stderr is inherited by the
  collector rather than captured (`stdout=subprocess.PIPE` only), so a candidate can write up to the
  workload `RLIMIT_FSIZE` (256 MiB) into the controller's stderr temp file; `_drain`
  (`sandbox.py:845-863`) still streams it in bounded memory. A 256 MiB stderr flood showed a 274.7 MB
  cgroup peak (page cache attributed to the sandbox) and graded `PASS` on a correct candidate.
  Bounded, not a finding; noted for the sandbox/resource review.
- **The new tests are non-vacuous.** `test_collector_does_not_import_candidate_top_level_modules`
  passes only because the stdlib is used (a shadow `dumps` returning `'PWNED'` would make the
  collector emit a malformed payload and grade `FAIL`); `test_candidate_output_volume_is_bounded`
  includes a modest-noise case that still `PASS`es, so it is not vacuously failing all candidates;
  `test_hidden_suite_hash_binds_drivers_and_expected_values` mutates the expected values and the
  drivers separately.

### 7.3 Residuals after re-verification

- **Unforgeability if the candidate already knows the expected values** — unchanged and out of scope
  (explicit brief residual); with F1 closed it is no longer trivially reachable from inside the
  collector.
- **Adaptive multi-trial probing; fixed-input special-casing** — unchanged.
- **No-cgroup memory provenance** — F2 was measured on the delegated cgroup; on a host without
  cgroup v2 the per-process `RLIMIT_AS` still bounds the collector, but the flat-RSS claim was not
  re-measured there.
- **`/etc/passwd` readability** — unchanged, noted for the sandbox review, not an R08 finding.

### 7.4 Reproduce the re-verification

```bash
cd /home/ruben/Projectos/meta-project/orchestrator
git worktree add --detach /tmp/kilo/r08-review-300325e 300325e
/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python -m pytest -q   # 512 passed

PY=/home/ruben/Projectos/meta-project/orchestrator/.venv/bin/python
D=/tmp/kilo/rerun-300325e
$PY $D/r08_shadowpid_probe.py       # F1 closed: no shadow import, genuine payload
$PY $D/r08_shadow_probe.py          # F1 closed: genuine payload, no marker
$PY $D/r08_subshadow_probe.py       # F1 closed for subprocess.py shadow too
$PY $D/r08_forge_probe.py           # F1 closed: both variants FAIL
$PY $D/r08_flood_probe.py           # F2 closed: flat peak RSS
$PY $D/r08_newcollector_probe.py    # F2 edge cases: truncation, no leak
$PY $D/r08_hash_probe.py            # F3 closed: hash_binds_assertions True
$PY $D/r08_failure_probe.py         # failure mapping unchanged
$PY $D/r08_recon_probe.py           # secrecy unchanged
$PY $D/r08_escape_probe.py          # boundary unchanged
```

No paid calls were made; all clients are in-process/synthetic, and no source file was modified.
