# M7 — bounded recovery and safe hidden retirement

19 October 2026. Execution record for [M7](2026-10-13-enemy-ai-implementation.md#m7--add-bounded-recovery-and-safe-hidden-retirement).

**Current, 20 October:** isolated runtime implementation and three source reviews
are complete; **28/28 native M7** and **19/19 cooperation** pass on the corrected source, while
**19/19 pure recovery**, **23/23 position/query**, **12/12 protocol** and the actual
cooperative recovery hook pass on the corrected source. Corrected full EditMode is
RED at **1,526/1,533**: six existing weapon expectation mismatches and one NGO
domain-reload teardown error; isolated reload passes without changing source.
Corrected full PlayMode is **474/504**, with valid unchanged identities; one retained
navigation and 29 first-person qualification cases fail. All three builds succeed
and release exclusion passes (Normal retains its explicit CLI timeout artifact).
All selected packaged first attempts are terminal: owner/warp cohorts pass; headless
arena/combat/lifecycle/menu/Verdant qualification remains failed or incomplete.
The actual rendered M7 launch/reset/visible/hidden/stop checkpoint passes; End human
acceptance remains pending. No local commit or production promotion is made.
Final scope audit found and corrected an M7 pressure-hook pursuit-guard bypass;
the actual native hook now has valid RED/GREEN proof and three delta reviews.
Corrected final suites use the declared vSync-0 test profile;
remaining packaged and human gates control closure alongside the retained broad failures.
M6 gates and production activation remain unchanged. See the
[corrected qualification](#corrected-full-playmode-and-authored-build-freeze) and
[packaged results](#packaged-batch-a-results) with remaining selections
below; earlier failed attempts are retained chronology, not final qualification.

## Authorization and baseline

- User requests completion of M7 and selects human playtesting **at the end**.
- After the M6 dependency is disclosed, the user explicitly selects **“Proceed with
  isolated M7; retain M6 gates.”** This authorizes isolated implementation, not M6
  acceptance, navigation repair, production activation or later milestones.
- Starting HEAD: `6b82871912ab7e1603490e099d4d51ccddca0110`, branch
  `codex/enemy-ai-rebuild`, existing connected-project checkout.
- Preserve the pre-existing movement ownership diagnostics in
  `EnemyMovementExecutor.cs`, their `EnemyBehaviorNavigationTests.cs` changes,
  the bridge-investigation paragraph in `Docs/PROJECT_PLAN.md`, the untracked
  bridge investigation record and all weapon art/source/export work. These are
  outside M7's commit ownership.
- M6's recorded full PlayMode/navigation failures and human/hardware/separate-network
  acceptance remain open. Prior qualified local commits do not turn these gates green.

## Compact implementation packet

**Intent:** an ordinary enemy that genuinely cannot contribute should try finite
legal alternatives, retain damage and earned player space, then leave only when
every relevant player's supported view establishes that removal is hidden.

**Observed gap:** M5 disconnected-ground proof is explicitly a partial refusal stub.
M6 assigns finite coarse pressure but neither its failed assignments nor expired
pursuits establish exhaustive inability. There is no ordinary retirement service.

**Hypothesis:** recording completed, identity-scoped route and capability assessments
across all living players separates genuine inability from missing evidence, query
deferral, control, paid recovery and temporary blockage. A separate execution guard
can then release live capacity without death, credit, refund or replacement. Any
protected-case retirement, renewed chase or visible disappearance falsifies this.

**Scope/ownership:** lead is the sole writer. Add `EnemyRecoveryPolicy.cs` and
`EnemyRetirementService.cs` under enemy coordination, a narrow read-only capability
contribution contract, explicit ordinary-retirement eligibility, native route/observer
assessment and narrow encounter lifecycle integration. Use opted-in fixtures and
owned runtime geometry. Preserve native graph/action ownership, personal evidence,
health, pursuit, launched effects, spawning finances/cadence and production bindings.
Do not repair navigation, restore support/melee, rebake or regenerate authored scenes.

**Risk/reviews:** high: authoritative despawn, object lifetime, encounter population,
reward and visibility boundaries. Independent Sol 6.1 / Medium technical, gameplay
and design/UX pre-reviews completed read-only on 19 October. Require the same three
perspectives against the integrated result, including Ponytail correctness,
completeness, simplicity and commit scope.

**Provisional inputs:** retain the approved plan's three completed alternatives over
at least eight eligible seconds, with three seconds/one metre meaningful progress
as the recovery trigger. These bounds never truncate the all-player/capability sweep.
Deferred queries, status restrictions and unknown capability/observer coverage cannot
supply failed attempts or eligible observation time. Exhausted unchanged conditions
remain blocked; elapsed time/assignment renaming cannot mint another attempt budget.
The pure policy conservatively requires all **six** candidate slots for **every**
supplied living target, exceeding the plan's three-alternative minimum rather than
truncating the existing six-candidate route assessment. Native collection of those
assessments and the progress trigger are implemented in the 20 October integration;
their qualification status is recorded below.

**Focused proof:** exact discovery then pure `EnemyBehaviorRecoveryTests` and native
`EnemyBehaviorRetirementTests`. Pair positive hidden ordinary removal with alternate
reachable player, disconnected legal ranged contribution, deferred work, temporary
obstruction, root/stun and expiry, paid recovery, all-down lifecycle, boss and explicit
custom/critical protection, request/execution visibility change, downed observer,
unknown/stale view, target/actor recycling and duplicate callbacks. Check wounded
health/pursuit retention, no kill/loot/stats/split/refund and ordinary future cadence.
Include real two/four-peer authority, visibility and cleanup where affected.

**Integrated proof:** after reviews/fixes, freeze inputs; discover and run full current
EditMode/PlayMode once, plus necessary normal/development/release builds and release
exclusion, affected two/four-player combat/lifecycle and normal menu/stage progression.
Retain each failure distinctly; known M6 failures are not silently exempted from M7's
reported results. Select compatible reuse only after the final diff is known. No new
Natural campaign, budget or reroll is authorized. Human End review is separate.

**Duration:** unknown until Editor connectivity and native discovery are restored.
Escalate ownership/identity uncertainty, unsupported observer data, new role/lifecycle
boundaries or changed normal-stage rules. Stop at the isolated M7 result and its actual
proof/limitations; no M8 or production promotion.

## Pre-review decisions and integration constraints

1. Pressure request timeout currently becomes `NoPath`, and ordinary planning can
   fail for missing observation or pursuit policy. Neither supplies M7 failure evidence.
2. Each actual attack/support owner must report useful, infeasible or unknown/temporary
   contribution without starting an action or revealing hidden aim. Unknown contracts
   keep an actor present; recovery has no central role switch.
3. Living targets and relevant observers are distinct sets. Include downed observers;
   zero living players follows the retained run cleanup.
4. Body yaw, spawn visibility cones and the development-only owner sight sensor are
   not accepted negative camera evidence. Unsupported/stale camera state and incomplete
   rendered-bounds occlusion fail closed. Final observer integration remains to be
   established before any retirement implementation is accepted.
5. Use nonlethal `NetworkObject.Despawn` accounting through `OnNetworkDespawn` and
   `NotifyDirectorDespawn`; never call lethal damage, death notification, financial
   cancellation/refund or the spawn scheduler. Guard duplicate execution before callbacks.
6. Preserve off-NavMesh authority refusal. An unsupported actor is an honest blocked
   encounter, not permission to bypass context validation.

### Supported observer design from the bounded technical follow-up

The player prefab camera is a direct root child at `(0, 1.6, 0)` with unit scale;
current aim code changes rotation/FOV rather than its origin. A conservative
omnidirectional test can avoid introducing a second camera-frustum replication path.
Validate the supported hierarchy/offset/scale at runtime. A movement-owned read-only
eye-envelope query must also validate actor/session/stage identity, correction state,
the actual accepted source tick/age and bounded possible movement since that sample.
`SpatiallySettled` alone is insufficient: stationary accepted samples need not expire,
and correction issuance can move the server's accepted position before the owner
receives it. Missing, stale or unbounded data returns unknown, including for downed
observers. Do not substitute an assumed small radius around `AcceptedPosition`.

For the smallest rigorous occlusion proof, support a single opaque rendered box face:
the complete eye envelope and conservative complete actor-render enclosure must be
strictly on opposite sides, and every eye-corner/actor-corner segment must cross inside
that same face with an inward tolerance. This encloses the intervening convex volumes;
point-ray samples alone do not. The collider is not opacity proof: require matching
enabled rendered geometry/materials and reject transparent/cutout/unsupported cases.
Account conservatively for the supported camera near plane. Incomplete bounds,
geometry, opacity, clipping or source-pose coverage retains the actor. This proves the
supported authoritative execution snapshot, not future client reception under latency.

Relevant existing seams: `PrototypePlayer.prefab` camera transform and near plane;
`PrototypeFirstPersonPlayer.Aim.cs` owner presentation; `ReceivedMovementBudget.cs`
retained samples; `PrototypeFirstPersonPlayer.cs` correction issuance and accepted
movement. This follow-up was read-only; exact envelope bounds and real peer/render
qualification have not been implemented or verified.

## Progress and evidence

- [x] Read current requirements, M7/dependency contracts, risk/model policy and testing route.
- [x] Record human timing and explicit isolated-M7 dependency exception.
- [x] Obtain independent technical/gameplay/design pre-reviews.
- [x] Implement and independently review the pure failure ledger and convex-volume math;
  obtain isolated CLR RED/GREEN evidence, with the limits below.
- [ ] Establish supported observer and complete contribution-assessment integration.
- [ ] Write focused tests and observe deliberate RED in the pinned ready Editor.
- [ ] Implement and obtain focused GREEN and native/network proof.
- [ ] Obtain integrated independent post-reviews; resolve blockers.
- [ ] Freeze source, accept final verification and inspect scoped staging/local closure.
- [ ] Present safe End human checkpoint; retain external and M6 acceptance limits.

### Implemented pure groundwork; M7 remains incomplete

`EnemyRecoveryPolicy.cs` records distinct completed target/alternative assessments,
requires full supplied-target coverage and eight eligible seconds, excludes paused
and stalled time, and rejects old opportunity/target lifetimes. A useful contribution
ends the evidence generation; unknown reassessment removes the affected proved bit.
`EnemyRetirementVisibility.cs` contains the pure geometric single-box-face proof,
including finite arithmetic, affine/nonsingular transform and volume validation. It
does **not** establish opacity, accepted eye envelopes, native visibility or despawn.

The actual C# sources and `EnemyBehaviorRecoveryTests.cs` were compiled with PowerShell
Roslyn and the project's pinned NUnit assembly; the geometric cases use the pinned
Unity core assembly's managed math. Reflection executes the exact test/test-case
leaves. This is explicitly **isolated CLR execution, not Unity discovery, EditMode,
PlayMode, a build, network or gameplay proof**.

Evidence root: [enemy-m7-20261019-fc08c1d7635948c2ae0ffc8663de1bb2](../../../TestResults/enemy-m7-20261019-fc08c1d7635948c2ae0ffc8663de1bb2/).

| Selection | Actual result |
| --- | --- |
| Initial pure ledger RED / GREEN | RED 4/9 passed, five expected missing-behavior failures; GREEN 9/9. Raw RED and its source copies/input hashes retained. |
| Initial geometry RED / GREEN | RED 12/13, failed the whole-volume positive; GREEN 13/13. |
| Independent review regression RED / GREEN | RED 13/19: unknown reproof, useful-generation replay, two overflow cases, singular transform and perspective transform all fail as expected. Corrected GREEN **19/19**, zero skips, matching before/after input hashes. See `review-findings-red01.json` / `review-findings-green01.json` and the retained RED source copies. |
| Independent bounded post-review | All three perspectives inspect the actual pure source; compact correction delta rechecks clear their reported pure-code blockers. They do not accept absent native integration or the whole milestone. |

The standalone runner lives only in ignored evidence; no new repository test framework
or dependency was added. The initial nine-case RED report is a raw per-case array;
later reports include exact reflection selection, runtime description, source hashes
and before/after identity. No historical gameplay proof is reused for these new helpers.

### Editor infrastructure and remaining work

The installed CLI alias cannot execute inside the sandbox. An unrestricted status
request initially discovers the correct pinned project/version, PID 7600, but reports
it unreachable; process inspection also initially reports not responding. The delayed
MCP readiness command subsequently succeeds: correct project/6000.6.4f1, stopped,
not compiling/updating, runner idle, saved PlayTestScene not dirty; Console errors zero.

After initial scaffolding import, Unity produces foundation/test assembly files and
begins a domain reload. CLI readiness and exact `m7-recovery-red` launch attempts time
out at the main-thread boundary. No `m7-*` Foundation request directory was created;
there is no admitted/discovered/executed Unity test evidence. The log later explicitly
reports `abandoned domain reload`, drops the relay and shuts that relay down after
inactivity. Timeout is not a successful operation. Final helper changes were compiled
and tested only in the isolated CLR path, not loaded/qualified in Unity.

Editor-created metas exist for the initial policy and test source. The later visibility
helper still needs supported Editor import/meta creation after recovery; do not invent
its GUID. No authored scene, prefab, navigation or package pin was changed. No runtime
recovery service, accepted-eye query, capability contribution integration, despawn path,
native fixture, player build or playable End checkpoint exists yet. No commit/staging
or M7 completion checkbox is authorized by this partial proof. M6 gates remain open.

The user has been asked to preserve unsaved work and restore/restart the pinned Editor.
Do not force-close it or start a second Editor against the project. After restoration,
confirm project/version, scenes/unsaved work, import/compile readiness, Console and exact
runner ownership before discovery. Resume at supported observer/contribution integration
and real native RED; retain these completed pure components and evidence rather than
reimplementing or relabeling them as native proof.

## 20 October resumption

The user requests **“Continue”**. Retain isolated-M7 authorization, M6's open gates
and End human timing. HEAD is now `b4dc32af3afe418430ac20437c0e4a065b65b714`;
additional unrelated weapon, movement, tools and documentation work is dirty and
must remain outside M7 ownership. Unity is restored at PID 41300, correct pinned
project/version, stopped/imported/compiled with runner idle, clean saved MainMenu
and no Console errors.

Fresh exact Unity EditMode selection: **19/19 GREEN**, no skips/conflicts, matched
terminal and input identity: `foundation-runs/m7-resume-pure-20261020-6e3fa7760bc24e8db9d765f82d949b6e`.
This is the first Unity qualification of the pure groundwork; earlier CLR proof
remains historical CLR proof. The initial native observer fixture has **2/4 RED**:
the expected supported-eye and whole-actor opaque-cover positives fail against API
scaffolding. Manifest: `m7-observer-native-red01-853cc987f287485c8c72a06111c50234`.
The CLI launch timed out, but the admitted request was subsequently found and its
matched final manifest read; it was not duplicated or treated as unexecuted.

Independent pre-review deltas cover current movement and native query seams.
Recovery must distinguish supported world geometry from temporary actor occupancy,
and valid alternate pressure must become an actual bounded coarse assignment while
retaining pursuit ownership. No assignment deadline can become failure evidence.

**Observer ruling:** fixed camera origin alone does not bound near-plane clipping
under unknown remote FOV/aspect. Use an explicitly opted-in projection epoch on the
existing player: owner enforces a conservative 2 m near-plane corner-radius ceiling
before acknowledging the matching lifetime/run/stage/epoch and before rendering.
Normal projections are unchanged. Extreme projections may reduce near clip/depth
precision. The initial suppression approach was rejected at post-review and replaced
by the render fence described below. Server revokes the grant before
disabling the request; cleanup restores the original near clip. No heading, target,
visibility verdict or camera-origin RPC is introduced. The movement-owned eye
envelope separately requires an actually approved fresh source tick, identity and
settled correction state. This closes the projection expansion race; it does not
prove future client reception under network delay. Independent technical pre-review
accepts the approach subject to source/native/peer proof.

### Integrated runtime and review corrections (20 October)

The opt-in host service now consumes explicit capability contribution contracts,
all living target lifetimes and six native geometry-only alternatives per target.
Root/stun, arrival, unknown data and deferred queries do not fund the eligible
window. A separate three-second / one-metre destination-progress trigger allows
reassessment without cancelling an accepted movement owner. Hypothetical lanes
can produce finite coarse arrival facing; firing still requires personal sight.
Only explicitly opted-in ordinary definitions qualify. Production assets and
activation remain unchanged. Execution uses nonlethal NGO despawn.

Initial native proof: `m7-runtime-native-green01-91ac8d80d0654c5aa45f9414190f5a1d`
is **6/6 GREEN**. Pure/shared-budget proof was **44/44 GREEN** at
`m7-shared-query-green01-2784fda795d64f9c95adf1bc61ff92d8`. Neither qualifies
the later fixes. The subsequently removed weighted-batch implementation and its
two tests remain historical evidence, not part of the final implementation.

Independent gameplay/technical/design post-reviews found stale exact-position
evidence, lease renewal masking progress, unearned physical bolt lanes, missing
camera handling, effective view overrides and an unqualified opaque pass. Native
regressions deliberately reproduced five defects: **6 passed / 5 failed**, matched
terminal/no skips in `m7-review-regressions-red01-abdb7b7d71ab4200bcb577ebe14b63e8`.
Fixes are implemented; their corrected native result remains pending.

Failure proof now captures exact accepted target positions, root/muzzle/eye poses,
agent filter/envelope/settings, supported primitive collider state and bounded
native navigation triangulation/area costs. Changes invalidate the entire proof.
Unsupported mutable mesh/terrain/link geometry cannot authorize retirement; it
still allows a finite useful-recovery search. Final execution rechecks all six
alternatives for every target with the existing shared FIFO budget and compatible
inputs, then rechecks authority/contributions/whole-actor visibility. No shared
scheduler extension remains.

Camera qualification includes effective view/culling matrices and the actual
URP Lit `ForwardLit`/`GBuffer` pass names. Missing cameras fail closed. Unsupported
host views revoke synchronously. A remote owner that already acknowledged an epoch
revokes it permanently and temporarily renders a bounded mono/unit-scale standard
first-person view before rendering while the request remains live; desired camera
settings are restored after the render. This avoids blacking the view while old
permission is in flight. Unsupported pre-grant views are unchanged. Diagnostics
explain the fallback and reset requirement. Remote rendering/replacement/scale,
ordered shutdown restoration and two/four-peer behavior remain unverified.

The existing Shooter sandbox now has an explicit **M7: disconnected recovery —
manual** launch, wounded actor, opaque-cover toggle, passive status and mode-preserving
F5/reset. The historical disconnected scripted stub remains partial. This is a
playtest route under construction, not human acceptance.

After the terminal RED run the Editor was observed running unrelated VerdantRelay;
the user explicitly authorized stopping it. At resumption it was already stopped
at saved MainMenu, compiled/imported, runner idle. Import then stalled at
`Begin MonoManager ReloadAssembly` and repeatedly timed out on the main thread.
Log/checkpoint preserved in `TestResults/m7-editor-reload-36861763cb0c4c7ab38646c577eee48c`.
The exact PID 41300 was closed through project-targeted Unity CLI (forced after
grace), its exit confirmed, and pinned-project reopening requested. No new test
was started or old evidence overwritten. Required final proof, local commit,
End human checkpoint and M6 gates remain open.

### Native findings, supported envelopes and protocol 13

`m7-reviewed-native-green01-56008ead10174598bb1f8e013e4e4eeb` completed with
**14 passed / 7 failed / zero skipped**, matched terminal and frozen identity.
Camera/protection/reacquisition cases passed. Retirement positives could not qualify;
the slow-movement fixture also requested 6 m at .03 m/s in a 20 s lease, correctly
refused by M3. Its destination is corrected to .4 m, preserving the intended sub-metre
progress condition. The original failure remains fixture evidence.

The single diagnostic `m7-eligibility-diagnostic01-bda83ea6ca10407899779fce542694ee`
retained the actual blocked state: completed 0, eligible 0, revision 2151, unsupported
`MeshCollider: Stairs (1)`. Animated muzzle transforms invalidated every frame;
existing mesh geometry also lacked qualification. Do not bypass either boundary.

The correction snapshots bounded readable mesh vertices/indices, identity, transform,
convex/cooking settings exactly. Unreadable/oversized meshes, terrain, unversioned
links and other unknown geometry remain protective. Recovery-only ranged failure
uses a conservative **5 m world-space muzzle envelope**, validated live with captured
binding/unit-root checks. Target volume includes the actual attack aim samples and
all active nontrigger target collider bounds. Range failure uses minimum volume
separation; physical obstruction must block every connecting segment through a
supported solid box. Unproved lanes remain possible and trigger at most finite
coarse recovery, without granting sight or firing. Thus muzzle animation within the
supported envelope no longer renames the opportunity every frame. Exact root, target
position/volume, filter, navigation and geometry compatibility remain mandatory.

`m7-positive-envelope-green01-01341c259986405d8eccc1c0ee78fd88` is **1/1 GREEN**:
actual animated hidden wounded actor retired nonlethally with health preserved at
despawn and unchanged kill count. This precedes the derived-target-volume/protocol
delta; it is scoped evidence, not final integrated proof.

`m7-manual-reset-red01-502fb2c82dbb4de987897a569661763c` reproduced failed F5-style
M7 reset: ending an inactive credit director did not close recovery. Explicit
`EndRecoveryFixtureServer` now closes that owner before the driver replaces actors.
The repeated-reset native regression awaits its corrected run.

Wire schema now pins **protocol 13** for the new player view fields/RPC. Three
independent prechecks cleared the bounded migration. The supported narrow prefab
upgrade changed only AppRoot `NetworkConfig.ProtocolVersion: 12 → 13`; saved MainMenu
reports source/effective 13, one correct manager and no protocol override. Migration
still accepts source 12. Native mismatch checks retain rejection of 11 and add 12;
matching-build admission/owner-arrival harness expectations now use 13.

Three independent source delta reviews are clear. A **25-case** protocol-13 native
fixture is currently owned by request `517091604648449c8d87061e22e4dc7e`
(`m7-protocol13-native-green01`). This includes actual two/four-peer accepted views
and downed observers, paid ledger/cadence checks, mesh mutation, camera fence and
protected controls. Admission is not success; source/assets remain frozen through
its matched terminal result. No broad gate, build, final commit or human acceptance
is claimed yet.

### Protocol-13 focused results and correction handoff

`m7-protocol13-native-green01-517091604648449c8d87061e22e4dc7e` finished
**21 passed / 4 failed / zero skipped**, matched terminal/identity. Hidden wounded
retirement, visible/protected cases, cover removal, same-cell movement, in-place
readable-mesh mutation, conservative range/muzzle controls and camera safeguards pass.
The remaining two peer cases and two fixture prerequisites were investigated rather
than excluded. Paid selection must use the ledger's actual captured settings identity;
the fixture now does. The no-progress test now observes an actual shared-query grant
after three seconds while asserting that its accepted movement owner stays intact;
it no longer requires one particular useful-query result string.

Single-process NGO owners had their CharacterController physically overlapping their
authoritative proxy body. The fixture now ignores only matching owner/proxy collision
pairs while retaining the owner motor, real transport and camera acknowledgements.
`m7-two-peer-physics-green01-35eb7317f6df460ab35f429da2a86ede` is **1/1 GREEN**,
including a real downed observer, all-observer hidden removal and peer despawn delivery.
This is loopback/shared-process proof, not separate machines or hardware acceptance.

`m7-manual-reset-green01-65a5a5d185b9433aafebd49934490357` is **1/1 GREEN** for
two repeated mode-preserving M7 resets, replaced service/actor identity and retained
wounded fixture setup. The earlier reset RED remains recorded above.

Technical investigation then found a real correction boundary: `CommitReceivedWarp`
committed an eligible native source tick without recording M7 observer metadata.
Unchanged stationary samples could not repair an invalid/old correction identity.
`m7-warp-observer-red01-19f47a61397d439b9c5b64b99aa03cb5` reproduced this with
actual remote downed corrections (**0/1**, matched terminal). The fix records only
retirement observer metadata immediately after the existing approved warp/budget
commit and before pending-jump processing. It grants no movement or action credit.
All three compact source postchecks clear that ordering. The actual one-argument
helper captures the committed pose/tick and identity internally and retains its
conservative lifetime speed high-water; an earlier handoff described its signature
incorrectly. It grants no movement allowance. Source changes invalidate affected
proof; no final gate is claimed.

`m7-warp-observer-green02-8d3d66e5da3f4c398e15a6933cfe6743` is **1/1 GREEN**,
zero skipped with matched terminal/source/compiled identity. Three actual downed
remote corrections each reject the old view while unsettled, qualify immediately
after accepted commit and retain stationary freshness through owner heartbeats
beyond the .5 s pose-age window. Source SHA256
`A1BE9DAE821B004527B74EEACFAD79DAB877177F93BB2680183EE6144F63EDF5`;
compiled `214140D9CFB9369D3790E83C9080B9B8C436B2D00C7A27EEC35E94EC3EF1A94B`.

The lead freezes source/assets/settings and transfers exclusive Editor/test ownership
to the technical reviewer as the policy's test operator. Selected batch: complete
28-case M7 fixture, then full current EditMode and PlayMode once if M7 passes.
Exact discovery, immutable final manifests, identity, no exclusions and confirmed
terminal cleanup remain required. Native failures return to lead diagnosis; known
unrelated broad failures remain visible. Builds/cohorts follow a separate bounded
packet. No result is inferred from admission.

`m7-final-native01-c98e76da85f74176a35232a4b10a0b13` finished **25/28 passed**,
zero skipped/inconclusive, all 28 discovered/executed, matched terminal and both frozen
identities, 171.991 s execution. Broad checks did not start; operator confirmed clean,
stopped MainMenu/idle runner and restored settings before returning ownership.

Three failures remain explicit. Paid admission's private pre-birth eligibility clone
violated the retained ledger's strict original-definition-reference check. The fixture
now proves that original reference and real native commit before applying only the
eligibility flag on a private actor clone; shared definitions and admission guards remain
unchanged. Technical review clears this accounting-only fixture correction, not production
eligibility authoring. The slow .03 m/s lease kept its initial +Z heading because its
per-frame motion is below the native 1 mm turning threshold. The player 90 degrees left
was inside the authored 210-degree view, so genuine useful sight correctly reset idle.
That fixture now starts facing the destination (+X), places the player behind, and
asserts no actual firing contribution throughout. Its original speed, five-second
window and movement-ownership assertions remain. The alternate-player 12 s timeout
lacked state evidence; the unchanged deadline now captures actual passive diagnostics
for focused diagnosis. No runtime fix or longer deadline is inferred from these failures.

Corrected focused runs are GREEN: paid accounting
`m7-paid-accounting-green02-7dcaeefaef3f4f438646f4c3e271a13e` **1/1** and slow lease
`m7-slow-lease-green02-561a596de51e48539ac7f5790b640ae3` **1/1**, matched terminals.
Alternate diagnostics remain failed evidence:
`m7-alternate-diagnostic01-de34174cd5ad4ab2af9739ee3cf5a8bd` and
`m7-alternate-trace02-ee46c61a160f473d8a65fb1403dd8d93`, each **0/1**.
The latter records a genuine coarse assignment, accepted 3 m +X destination and
coarse facing, then repeated native Yielding at zero travel/yaw until its original
6 s expiry. This disproves the preliminary vertical-only/current-location-plan
hypothesis. Target accepted pose remains settled. Native rejection capture is the
next bounded diagnostic; neither source navigation tolerances nor deadlines change.

`m7-alternate-native-cause03-b8d299acf6b945d1b9deb36b047d6b46` (**0/1**) identifies
`sweep destination capsule`; `m7-alternate-blocker04-7340199588d94ae9bff22a0fbf782c00`
(**0/1**) proves the exact overlap: identical Head/Body colliders at the authoritative
pose, one self and one foreign enemy hierarchy. `DisableClientPhysics` had run before
the later enemy replica existed. After gameplay source review, the fixture now awaits
that exact replicated NetworkObject ID and disables only its client colliders,
asserting the authoritative actor's colliders stay enabled. The 12 s behavior deadline,
actual server target/body, graph and native clearance remain unchanged. This is a
demonstrated shared-physics fixture correction, not an M6 navigation repair.

`m7-alternate-green05-0643d2ba52a443df8bc6476c62901c67` retains **0/1**: the later
wounded-health replication called `ShowAlive` and re-enabled those client colliders.
The fixture now wounds first, waits for the exact replica's matching health, then
isolates only that duplicate body. `m7-alternate-health-order06-98d4e86ec04b48ddae5da60f2a448bf4`
is **1/1 GREEN**, matched terminal/identity, for actual alternate-target personal
reacquisition/release and unchanged wounded health. No runtime navigation/collision,
deadline or admission guard was changed by the three final fixture corrections.
Technical/Ponytail and gameplay compact postchecks clear these fixture deltas.

### Frozen M7 qualification, 20 October

`m7-final-native02-05a88a18806d44709eca1a06423387c9` is **28/28 GREEN**,
zero failed/skipped/inconclusive, all exact discovered leaves executed, terminal
observed/matched and no conflict/error, 184.187 s execution. Lead reads the final
manifest and XML. Frozen source
`AF1DC9C1CCF3C6C7933F5060CF9C76D8EB15EA9DC40CBA2BA9943ECFFE69A40B`;
compiled `05CEBFF07BB8216E17653A48DBE16A520BC2E56EF7407A3AEDD03E18B9D63D7E`.
This covers actual hidden wounded retirement, protected/visible/control/deferred
cases, same-cell target/world-mesh changes, real alternate reacquisition/fire,
slow-progress reassessment with retained owner, paid accounting/cadence, supported
camera safeguards and actual two/four NGO peers including downed accepted observers.
The prior failed runs remain failed evidence and explain the fixture corrections.

Exclusive test ownership remains with the operator for the selected full current
EditMode then PlayMode assemblies. Full-suite/build/packaged/manual results remain
pending. This passing fixture does not close those gates, M6, human, hardware,
separate-network acceptance or production activation.

Full EditMode `m7-final-edit01-986315b7843b4a94a60b77a92f62e347` completes
**1,527/1,533 passed; six failed; zero skipped/inconclusive**, 15.526 s execution,
matched terminal/no conflict, all discovery/execution leaves and frozen source match.
The six failures are the previously recorded unrelated weapon expectations: damage
IDs 1/2/5 expect 20/40/11 but dirty assets supply 18/47/14, and RPM expects
360/168/120 but assets supply 450/175/140. No M7 assertion failed. The full gate is
RED; these failures are retained, not excluded or treated as M7 success. The operator
continues the agreed full PlayMode selection after idle/exact discovery.

The same fresh full EditMode XML contains **19/19** recovery policy cases,
**23/23** retained position/query cases and **12/12** protocol/build validation
cases. These are scoped GREEN results within the failed complete assembly, with
the full assembly's AF1DC9… source identity; no focused rerun is substituted for
the full gate. Its mode-specific compiled identity is
`DE5ACE3D81DC843C568617187741EE666228E9407190DF775FD1758392FD3ED9`.

### End human checkpoint route

Use **ProjectI > Debug > Enemy AI > Shooter sandbox > M7: disconnected recovery —
manual**. This launches owned temporary geometry in PlayTestScene, not VerdantRelay
or a production recovery default. The wounded shooter is on the right-hand island;
the sandbox's cover toggle compares retained visible presence with genuinely hidden
removal. Start with cover disabled to inspect the actor/health, then reset with F5
or the window's reset control to repeat the hidden case. Observe the passive eligible
time/state rather than assuming a wall-clock deadline; deferred/unknown coverage must
retain the actor. Repeated reset should keep M7 mode with a new actor/service identity
and the same wounded setup. **Stop** removes the owned sandbox.

Actual rendered launch/stop verification and the user's keep/tune/revert decision
remain pending at this point. The 28 native passes do not substitute for that review,
M6 gameplay acceptance, representative hardware or independently controlled separate
networks. Pending acceptance still blocks dependent promotion.

### Remaining packaged selection

After accepting the frozen full-suite outcomes, build normal Windows development,
DebugArena development and ReleaseExclusion sequentially. Save each actual native
build report/GUID, options/scenes, before/after source/settings, packed inventory
and executable/managed/full-data fingerprints under
`TestResults/m7-delivery-87a1e49b05b0491aafb4671b6fa602b0`. Check positive debug
versus absent release fixture/diagnostic markers, including the M7 opt-in methods;
the core recovery policy/view wire layout remains runtime code.

Lead-selected first-attempt packaged checks, subject to successful matching build
identity and confirmed cleanup after each: `Test-OwnerArrivalInput.ps1 -Players 2`
then `4` (75/15/1), `Test-WarpSettlement.ps1 -Players 2` then `4` (retained 350/15/0),
`Test-DebugArena.ps1 -Players 2 -ResetCycles 2` then `4` (75/15/1, retained failure
proof included), and normal `Test-Combat.ps1` once. If an arena failure leaves the
required lifecycle tail unexecuted, select one first-attempt
`Test-Foundation.ps1 -LifecycleRegressionOnly` to measure that boundary separately;
it cannot turn the failed arena into a pass. After all owned-process cleanup,
select standalone `Test-MainMenu.ps1` and
`Test-EncounterPolish.ps1 -VerdantInitial -DelayMs 75 -JitterMs 15 -LossPercent 1`
once as independent normal-entry/progression gates. Retain primary, coverage and
cleanup failures independently; no source fixes, relaxed checks or retries are
authorized for unrelated weapon/navigation work. Stop for cleanup/identity/ownership
failure or a novel consequential defect. No Natural campaign or new attempt budget.

### Final scope-audit blocker: cooperative pursuit retention

During the frozen full PlayMode run, the lead found that M7's new
`EnemyPressureDirector.TryAssignRecoveryServer` calls `Pursuit.TryBegin` with its
default `allowUnobservedEpisode=true`. The normal assignment path passes
`!member.Cooperated`. Gameplay review confirms a real bypass: an expired previously
cooperating elite can obtain a new episode against a previously unattempted split
participant when area/endpoint move materially, without earned new personal contact.
The current 28-case M7 fixture exercises direct coarse recovery without the pressure
director, so its GREEN result does not cover this branch.

The smallest correction is the same `!member.Cooperated` argument in M7's hook,
leaving pursuit rules and normal assignment unchanged. Gameplay and design prechecks
clear this. After the active full run reaches matched terminal/cleanup, extend the
retained native `ExhaustedEliteCannotAcquireFreshChaseThroughASecondSplitPack` to
invoke the actual M7 hook for the supported second target and require refusal,
unchanged episode/deadline/travel and no recovery assignment. Establish RED before
the one-line runtime fix, then GREEN and affected pressure/cooperation/recovery proof.
Builds remain paused. No source mutation during the active run and no M6 repair.

Full PlayMode `m7-final-play01-c0de88a2f6ab413da7109d800b49f8e1` completes all
**504** discovered/executed leaves, **502 passed / two failed / zero skipped**, but
is **identity-invalid**, not a valid broad checkpoint. Compiled identity stays
05CEBF…; source changes from AF1DC9… to
`3514C1EB52C5D92EA25B79CC4E79F134C7296BBE5C8BDA8D5FABF45968EEAEE5`.
The exact delta is PC `QualitySettings.asset` vSync 1 → 0 at startup. The two
observed failures are `OffCentreStairEntrance_CompletesAscentAndDescent` (native
yield expiry) and `LowCeiling_BoundsImpactAndSettles` (-.0407638662 versus >-.04).
The latter is new to the selected baseline; neither failure is repaired as M7.
M7's 28 leaves pass inside this run, but identity invalidity prevents accepting it
as fresh full-suite qualification. Execution is 1,052.757 s. Operator confirms
stopped/idle, clean MainMenu, no live session and settings restored except the
recorded quality drift before returning ownership. No builds ran.

The existing `LocalPlayerSettings.ApplyDisplaySettings` applies loaded vSync false
and the Editor persists that native settings state when assets are saved. Technical
review accepts a declared vSync-0 test profile rather than weakening identity checks
or changing unrelated settings code. Original and drift snapshots/diff live under
the delivery root. Restoration through the quality object was verified against the
**exact original AF1DC9… source hash**, then the test profile is explicitly saved as
3514C1…: quality level 1, vSync 0, loaded preference false, frame cap 120. Saving was
guarded by exact live/saved build-scene equality and zero dirty authored Assets;
no unrelated authoring was saved. `quality-profile.json` records those values.
The corrected tests freeze this explicit profile. Restore the authored vSync 1
file/hash before builds; keep test-profile and authored-build identities distinct.
Another drift must remain invalid, never normalized away.

First direct-hook request `m7-cooperative-pursuit-red01-77227a89da2c4c5f811685d3dce1018d`
is **0/1**, valid terminal/identity, but fails its material-area fixture prerequisite
(0 m instead of ≥24 m), not the intended hook assertion. Initial pressure purpose
is not guaranteed to match the pack's physical side. The original two-player C2
assertions are retained, then a real third peer joins after pursuit expiry and is
accepted in a new separated area. This supplies a genuinely new target lifetime
that could not already be in the pursuit's attempted history. The original actor,
expiry, no-progress condition and native hook remain unchanged. Corrected RED is
required before editing the runtime guard.

### Cooperative pursuit correction and corrected final freeze

`m7-cooperative-pursuit-red02-2e12f2519fc74ce6997cb1a02d56a2b0` is the valid
intended RED: the actual recovery hook returns true and advances an exhausted
cooperating elite from episode 1 to 2, extending its deadline from 4.6013573124
to 9.2171054280 without earned progress. The new third participant joins after
expiry and supplies a genuinely new lifetime and materially different area/endpoint.

The runtime correction passes `!member.Cooperated` to the existing `TryBegin`
contract, exactly as normal assignment does. No pursuit rule or ordinary assignment
changed. The test now also waits for positive capture of the new participant before
invoking the hook, so missing capture cannot produce a false refusal pass.

`m7-cooperative-pursuit-green01-4b4117bf80e34326a2eff18051a6925a` passes **1/1**
in 12.090970 execution seconds. The exact requested/discovered/executed leaf matches;
terminal is matched, no conflict/skips/inconclusive results, and identities match:
source `17EE1817AC5E13A09D2FEB4D46CD19D0D2AA85802D02F4C91B37A3E7419C5F26`,
PlayMode compiled `56F09F1C87F00AE8A66F2A82B9D0700967922C448E3902B731448D931685C61F`.
Technical, gameplay and design/UX delta postchecks clear the two-file change.

Exclusive Editor ownership transfers to the technical verification operator for
full `m7-final-edit02` (expected 1,533) then `m7-final-play02` (expected 504), once,
with the vSync-0 profile and source above frozen. The six known unrelated weapon
EditMode failures do not cancel the selected full PlayMode observation. No source,
assets or settings mutation, test exclusion, build or packaged cohort during this
batch. Identity/ownership/cleanup failures or a novel consequential M7 defect return
to the lead. The old identity-invalid PlayMode run remains invalid.

Corrected full EditMode `m7-final-edit02-a0eabccaeb654ddb923da27323bd2f1a`
finishes valid/matched at **1,526/1,533**, seven failures, zero skipped/inconclusive,
32.258825 execution seconds. Source 17EE1817… and Edit compiled
`C4A2738D957E899EE3A82AEA9B7F1DED124B9C997FD6400ED6D486C2C314998D`
remain unchanged. Six weapon expectation failures recur. The new seventh is
`EnemyBehaviorDomainReloadTests.ActualDomainReload_StoppedSessionDoesNotResumeOldWork`:
“Errors occurred during domain reload.” The retained stack is NGO
`NetworkSceneManager.Dispose:609 → NetworkManager.ShutdownInternal:1672 → OnDestroy:1754`;
it contains no M7 frame. Its classification requires diagnosis, not an automatic waiver.
The operator correctly stops before admitting PlayMode and returns ownership after
confirming idle/stopped/clean MainMenu, stopped network, restored options and unchanged
quality profile. The exact exception is preserved beside the result manifest.

The lead selects one exact isolated unchanged-source reproduction, without the
preceding full-suite state, to distinguish a retained fixture/NGO reload dependency
from an M7 regression. No assertion suppression, package change or full-suite reroll.
Builds and the selected full PlayMode remain pending that diagnosis.

Isolated `m7-domain-reload-isolation01-960e561d0a274da0b98e7e1be2628445` is
**1/1 GREEN**, exact leaf/matched terminal, no conflict/skips, same 17EE1817… source
and C4A2738D… Edit compiled identity. It observes the actual reload and verifies
one shutdown/invalidated context with no resumed starts/ticks. No source, settings,
assertions or package changed. The contrast localizes the observed failure to the
full-suite context; it does not establish the precise contamination/race root cause,
waive the full-suite failure or support live NGO hot reload. The retained stack and
unchanged-source isolation provide enough evidence to continue the independently
selected full PlayMode observation without an unrelated runtime/fixture repair.
Exclusive ownership transfers back to the operator for `m7-final-play02`, once,
with the same frozen test profile. Full EditMode is not rerun.

Read-only candidate commit-scope review clears the owned path list and three shared
runtime hunks: referenced APIs exist in HEAD, with no dependency found on excluded
weapon/movement/bridge changes. This clears scope coherence only. The combined dirty
working tree remains the tested source, and failed integrated gates remain failed.

### Corrected full PlayMode and authored build freeze

`m7-final-play02-2866b1512b094e91bc6526cf5e545339` completes valid/matched at
**474/504**, 30 failed, zero skipped/inconclusive. All 504 unique discovered leaves
execute exactly once with no selection difference or conflict. Source 17EE1817…
and Play compiled 56F09F1C… remain unchanged. Execution is **1,110.793523 s**.
All **28/28 retirement**, **19/19 cooperation**, including the extended actual-hook
guard, and **22/22 scenario** cases pass. This is fresh corrected-source evidence,
unlike the older identity-invalid full run.

The full gate remains RED. Failure groups are one
`SmoothRampAtSameLanding_CompletesCapturedUpperSeamDescent` (native yield expiry),
eight first-person arms, nine recoil, one reference capture, one viewmodel, seven ADS
and three sight cases. Many explicitly report `focus=False` or a required focused
GameView. These are unresolved first-person qualification failures; focus observations
do not waive them or prove every failure's cause. Exact 30 names/messages/stacks remain
in the run XML/operator summary and the delivery root's `final-play02-failures.json`.
There is no M7 fixture failure. No unrelated movement/input/weapon repair or reroll.

Operator handback confirms stopped/idle, saved clean MainMenu, compile/import idle,
sole app-root manager stopped, options true/3 restored and unchanged vSync-0 profile.
Three intentional test-error logs remain recorded (throwing cleanup, deliberate M2
observer failure and injected M5 failure); no Console clearing. Application focus is
false at handback. Only after this matched terminal/cleanup does the lead restore
authored quality through the supported API and guarded save. Zero dirty authored
Assets and exact live/saved build-scene equality are required; original quality file
bytes match the preserved snapshot exactly.

Authored build source is now
`9E40E3D4575E184E1DECC4CD8716E4AD747DADBA7D2FE43F00131A2D0171DF6C`,
quality level 1, vSync 1, frame cap 120, recorded in `authored-profile-restored.json`.
Only the declared quality profile differs from the final test source. Exclusive
ownership transfers to the operator for Normal, Debug and Release builds using
the evidence-only `BuildM7.cs` template, native detailed reports and fingerprints,
then positive debug/absent release audits. No packaged cohort is admitted yet.
Broad failures remain open; the independent build selection does not make them pass.

Normal build native result is **Succeeded**, GUID
`37d383836f6d4330b8a0f8fe74ac2767`, 71.419 native seconds, unchanged 9E40E3D4…
source/scenes. Its report retains **one error and 675 warnings**: the only error is
`Failed to handle /api/exec request: Main thread operation timed out after 5000ms`.
The build outlives that caller timeout and reaches a confirmed native successful
terminal. This is a successful build with a retained transport-error artifact,
**not a zero-error build**. No report count was changed and Normal is not rerun.
Requested and native report options both equal 536870913
(Development | DetailedBuildReport); the actual backend is Mono2x. Enum alias text
does not identify an IL2CPP build. Executable, managed/full-data/player-source,
packed inventory and native report fingerprints are saved in `Normal/fingerprints.json`.

The supported Editor timeout after the CLI `--` fence is extended for subsequent
builds; no product or assertion changes. Debug succeeds with **zero errors / 640
warnings**, GUID `2c01d7f1d23f4ad2b7040e753e91f383`, 16.163 native seconds,
unchanged source/scenes, the same development options and Mono2x backend. Its
report/inventory/fingerprints are saved. Release and exclusion audit remain pending.

Release succeeds with **zero errors / 809 warnings**, GUID
`ff0839538199492d91e48f4586814d2e`, 41.798337 wall seconds, unchanged authored
source/scenes and saved raw report/inventory/fingerprints. The exclusion audit scans
all ProjectI managed assemblies using ASCII and UTF16LE at both byte alignments:
all **12/12** selected fixture/diagnostic markers have positive Debug presence and
zero Release presence. No forbidden DebugTestArena, authoring or non-code enemy
fixture assets occur in Release's packed inventory. The core retirement service and
view request/epoch fields intentionally remain runtime code. Audit is preserved in
`release-exclusion-audit.json`; build success does not prove active recovery in a
packaged process.

After lead acceptance of the native builds and exclusion evidence, the operator keeps
exclusive ownership for first-attempt packaged batch A: OwnerArrivalInput 2 then 4
(normal GUID 37d383…; 75/15/1; required protocol 13), then WarpSettlement 2 then 4
(Debug GUID 2c01d7…; retained 350/15/0). Exact build/data/managed/player-source
fingerprints must match before and after each cohort. Common player-source identity
is `06F40CEA06DC9DD95755B138207B9483F92E515414BC59F6115A44226BA44CC4`.
Legacy warp results receive an additive evidence companion without modifying the
harness. Confirm all owned players exited and preferences restored before advancing;
any unexpected failure, identity, ownership or cleanup problem returns to the lead.
No retries, source edits, arena/combat/common regressions or Editor Play operations
are admitted in this batch. Both full-suite gates and M6/human acceptance remain open.

Packaged preflight catches a missed launcher migration before any player/attempt:
OwnerArrivalInput's final assertion expects 13, but its polling helper still expects
12. Repository inspection finds the same helper pin in DebugArena and EnemyDirector.
The lead corrects only these three 12 → 13 expectations, preserving DebugArena's
unrelated camera-layout work. Technical pre/post checks clear the narrow migration.

Controlled evidence runs the actual AST-extracted `Wait-State` and actual reader
functions against scoped synthetic reports, using the real identity helper and a
live current-process handle. `launcher-protocol-red01` demonstrates all three
rejecting 13 and accepting 12; `launcher-protocol-green01` passes **6/6**, accepting
13 and rejecting 12 as invalid identity. No players, network, preferences, runtime
code, assets or build inputs change. These checks qualify the polling migration,
not complete EnemyDirector/C3 packaged behavior; no new C3 cohort is selected.

New frozen runner hashes: OwnerArrivalInput
`EC7B17F67445C6A7775C60C364540DD17AA0E7D373E496FD8417A84E1EBAB2B1`,
DebugArena `804300FD57CA05D0A55E0D0FA720375C16C33EAEB6815260F901344B56444560`,
EnemyDirector `A928E8D56F37C91576D4DA51CCD971042D4B1D28F10B3213E90E9EB5C13CE64B`.
Foundation source identity and player-source/build fingerprints exclude these Tools
files and remain unchanged; runner hashes are recorded separately for real cohorts.
The operator regains exclusive ownership to execute the original batch A selection.

### Packaged batch A results

All four **first attempts pass**, with immutable raw reports and additive evidence
under `packaged-A`; `batch-summary.json` records the accepted selection and cleanup.

| Check | Raw TestResults directory | Coverage | Elapsed harness including cleanup |
|---|---|---|---|
| Owner input, 2 | `owner-arrival-input-4c45d2243f2f4cd19359aec5add81f4f` | 6 phases; actual 75/15/1, protocol 13 | 39.545529 s |
| Owner input, 4 | `owner-arrival-input-f228382ca21644f59afd8c8984d97426` | 10 phases; actual 75/15/1, protocol 13 | 45.637296 s |
| Warp settlement, 2 | `warp-settlement-17381b5824514cbe93352a8f241e2086` | Five settlement cases; actual 350/15/0, protocol 13 | 49.259588 s |
| Warp settlement, 4 | `warp-settlement-4012904b75f4451ca0e7bcbc3964d7bb` | Five settlement cases; actual 350/15/0, protocol 13 | 53.333931 s |

Warp cases cover short/large correction, moving before confirmation, jump after
correction and downing during pending correction. Both report **causalProof=false**;
these passes establish the recorded settlement/convergence observations, not captured
causal proof of the pending window or an instantaneous-correction guarantee. All 10
two-player and 20 four-player active peer snapshots confirm the requested simulator
profile and protocol. Post-leave simulator unavailability is teardown, not active proof.

Exact native GUIDs, executable/managed/full-data, player-source 06F40CEA… and revised
runner fingerprints match before/after all cohorts. All **12** launched player PIDs
have positive exit confirmation; no live ProjectI player remains. Local settings
values, types and key absence match the preserved baseline in every cohort; cleanup
errors are empty. Final Editor is stopped/idle, clean MainMenu, source 9E40E3D4…,
options true/3, authored vSync 1 and stopped app-root manager. These are local
multi-process matching-wire/passivity/owner/warp observations; active packaged M7,
human control, representative hardware and separate networks remain distinct.

Lead accepts batch A within those limits and transfers ownership for batch B:
DebugArena 2 then 4 with two reset cycles, 75/15/1, retained failure proof, then normal
Combat once at its default 0/0/0 profile. Stop on the first primary failure for lead
classification before another cohort; no assertion relaxation, unrelated repair or
retry. Lifecycle fallback/common normal regressions remain separately queued pending
coverage and confirmed cleanup. No Editor Play/build operations during player cohorts.

### Packaged batch B: retained camera-readiness failure

First two-player DebugArena request
`debug-arena-7d0920b536f24a0aac60dedff0466fd0` fails **initial shared Idle epoch,
host, 20 seconds**. Both peers are connected in DebugTestArena with matching Debug
GUID/protocol 13, actual 75/15/1, two players, one local owner, no busy/probe error,
Generation 1/State 0 and zero fixture objects/work. The failed predicate includes
`ownerCameraLayoutValid=false`; both have one world camera, zero viewmodel cameras
and one listener. No damage scenario, reset cycle, intentional failure proof or
lifecycle tail executes. The failed raw result and additive sidecar remain failed.
Both owned player PIDs exit, settings/identities match and cleanup errors are empty.

Lead compares the earlier handcannon four-player request
`debug-arena-251fe995ad8c407aa439cc510cadd3db`: protocol 12/GUID 7154d7bb… has the
same connected scene, invalid layout, world 1/viewmodel 0 and Generation 1/State 0.
This establishes prior occurrence under another build, not the exact root cause or
compatible passing evidence. No camera/graphics/input repair, assertion relaxation
or retry is made within M7. The broader gate and missing tail remain open.

After positive cleanup, the lead selects the remaining independent first attempts:
Arena 4/two resets/75/15/1, normal Combat once at 0/0/0, then one lifecycle-only
Foundation fallback at 0/0/0 because the arena tail is absent. Identical retained
headless camera/readiness or unsupported-graphics failures may be recorded and the
next independently selected cohort executed only after confirmed cleanup. Novel
consequential defects, changed identity, ownership or cleanup failures stop the batch.
Common menu/Verdant checks remain queued separately. No further M7 runtime change.

Batch B's remaining first attempts retain the following failures:

| Requested check | Unique TestResults directory | Reached / omitted coverage | Elapsed including cleanup |
|---|---|---|---|
| Arena 2 / two resets | `debug-arena-7d0920b536f24a0aac60dedff0466fd0` | Two connected peers; initial Idle readiness fails at 20 s; no scenarios/reset/failure/lifecycle tail | 38.574265 s |
| Arena 4 / two resets | `debug-arena-1f66be5e347e4af6aec189dc709bda6b` | Four connected peers; same initial readiness failure and omitted tail | 38.926925 s |
| Combat full 2/4 selection | `combat-6e4a355f40c545ac98d223995c4e02c0` | Only host launches; 120 s host-ready timeout; no multiplayer combat phases | 123.441771 s |
| Lifecycle-only fallback | `foundation-b77254ca5f124cae9caf62683258ed4d` | Only host launches; 120 s host-ready timeout; no leave/kick/rehost phases | 123.701676 s |

Combat and lifecycle failure snapshots show a connected idle host with protocol 13,
matching normal build and the same invalid world-1/viewmodel-0 camera layout; their
connected-group predicates also require a valid layout. Phase names mentioning a
private code do not isolate the cause, and snapshots deliberately redact join codes.
The graphics-buffer/unsupported-compute exception is also logged; its exact causal
relationship remains unresolved. Earlier protocol-12 handcannon results record the
same readiness failures. No failure is reclassified as a pass or repaired here.

All **eight** B player PIDs have positive exit confirmation, settings/identities match
before/after, and cleanup errors are empty. Both successful 2/4 owner cohorts and
failed headless cohorts are reported separately; they cannot replace missing combat,
reset/failure-proof or lifecycle acceptance. The operator continues with explicitly
selected standalone MainMenu then VerdantInitial checks once, after all prior owned
cleanup, preserving failures and stopping for novel consequential/identity/ownership/
cleanup problems. No failed-arena convenience regression call or extra attempt.

### Common normal checks and final packaged handback

Standalone MainMenu `main-menu-f309bddb8eb14639bea5b6a65a53ed5f` is **RED**:
three positive phases cover two-peer private lobby, production library/equip/discard/
recipe flow and readiness/unready-start authority, then two-player load fails on the
retained unsupported compute graphics-buffer `ArgumentException`. Later run/four-peer/
lifecycle tails are absent. Raw harness elapsed is 25.377 seconds; the additive
parent interval including launch/confirmed exit is 27.424405 seconds. The menu
probe has no runtime build/protocol/simulator telemetry; matched native executable/
managed/full-data/player-source provenance remains available, without inventing
runtime fields or claiming a profile readback the schema cannot provide.

VerdantInitial `encounter-polish-04ab1a26a71b487388ca4f93872cd2ad` is **RED** at
120-second first-host readiness (raw harness 121.317 seconds; additive parent interval
123.387075 seconds). Its connected
Verdant host reports protocol 13, matching normal GUID, actual 75/15/1 and invalid
world-1/viewmodel-0 layout. No two/four-player full-run, rewards/portal/travel/results
tail executes. This remains failed progression qualification, not a completed cohort.

The B/common summary and `packaged-final-readiness.json` confirm every selected first
attempt reached a terminal result, all **11** B/common player processes exited,
all before/after build/runner/player-source identities matched and cleanup errors are
empty. Common preference comparison covers both LocalSettings and LocalLoadout values,
types and absence; no preference values are printed. Final handback is stopped/idle,
pinned 6000.6.4f1, clean saved MainMenu, no dirty authored Assets, options true/3,
authored quality bytes/vSync 1, source 9E40E3D4…, no live network/player and Console
errors zero. No retry, headless graphics repair or unrelated source edit is made.

### Actual rendered M7 checkpoint

The lead launches the existing M7 menu route after packaged cleanup. Actual frames
advance (`wait_for`: initial 1779 → 1792, two observed frames), with a supported
first-person observer. An initial inspection snippet fails to compile because a
UI Toolkit extension namespace is absent; none of that snippet executes and the
project itself stays compiled. The cover stays enabled, so its ordinary actor
retires while the inspection is corrected. That empty capture/state is retained as
an unsuccessful visible-check attempt, not counted as visible-retention evidence.

An owned ready-state callback uses the existing reset and cover controls, without
source changes, to prepare generation/spawn **3** with cover disabled. The shooter
is at (445, 0, 400), wounded **178/180**. It remains the same living actor at exactly
178/180 for **60.377808** observed game seconds. Its six alternatives and 8.01 eligible
seconds are complete, but execution retains it as visible/unsupported occlusion.
The composited Game View capture `manual/visible-held.png` shows the drone, its
health bar, normal HUD and first-person weapon.

Enabling opaque cover through the existing control changes the opportunity revision.
The actual status observation advances completed-six/eligible 2.80 → 8.01 seconds,
then pending and **“Retired spawn 3 without death, credit, refund or replacement.”**
The server-side wait observes 53 samples over 5.306 seconds, beginning after 2.80
eligible seconds have accrued. `hidden-final-ui.json` records the terminal status,
zero live actors, M7 mode and enabled launch/cover/F5-reset/Stop controls. The covered
capture `manual/hidden-retired.png` shows opaque cover hiding the actor region while
the HUD/weapon continue rendering. Images establish rendered states; accounting and
timing are supported by the native/recorded observations, not inferred from pixels.

Independent design/UX image review finds no rendered handoff blocker and retains the
human keep/tune/revert gate. Repeated resets preserve M7 mode and replace generations;
Stop then positively reaches edit mode, removes the driver, closes the local network
and restores saved MainMenu/options true/3. Supported capture unexpectedly places PNGs
under Assets/TestResults; verified copies are preserved in ignored TestResults and
only this task's imported capture folder/metas are removed via AssetDatabase. The
pre-existing Assets/TestResults root is preserved. Guarded quality restoration matches
the exact authored bytes; `manual/stopped-restored.json` confirms source 9E40E3D4…,
clean MainMenu, no driver and stopped app-root manager. Console errors remain zero.

The user confirms handcannon positioning edits predate these checks. Those values
are already included in the recorded source and are preserved; no pose rollback is
used to address focus, navigation, reload or headless failures.

### Closure and remaining acceptance

**Implementation decision: keep as an isolated checkpoint for human review.** All
seven M7 implementation checklist items have scoped rule/native proof; source reviews,
rendered checkpoint, required builds/exclusion and owner/warp cohorts pass within their
recorded identities/limits. Full suites and headless integration gates remain failed;
their missing tails, representative hardware, independently controlled separate-network
combat and actual human acceptance remain open. M6's explicit exception is retained;
M8 and production activation are not started.

No local commit is made yet: the shared closure policy authorizes it after agreed
checks pass, and these broader checks have not all passed. A user-approved isolated
checkpoint exception or resolution of those gates is required before committing.
Only M7-owned paths/hunks are candidates; all weapon, movement, art and other dirty
work stays preserved. No staging, blanket commit, push or amend has occurred.

The immutable automated checkpoint manifest is
`TestResults/m7-delivery-87a1e49b05b0491aafb4671b6fa602b0/final-manifest.json`;
the proposed ownership inventory contains **42 owned paths and six shared files
requiring only M7 hunks**. Tested source includes preserved unrelated dirty work;
an isolated commit will not contain every tested byte. That limit remains explicit.

After proving Stop/restoration, the lead relaunches the same sandbox solely for End
human review. `manual/human-handoff.json` confirms source 9E40E3D4… unchanged,
playing/unpaused, frames advancing, M7 mode/generation 2, one living 178/180 actor,
supported observer and six/eight-second recovery exhausted but safely retained while
cover is absent. Passive diagnostics are enabled and Console errors are zero. This
live local preview is intentionally left for the user; all packaged test processes
are already gone. **ProjectI > Debug > Enemy AI > Shooter sandbox** contains
**M7: show / hide opaque cover**, **Reset current fixture (F5)** and
**Stop sandbox / restore Editor scenes**. Turn cover on to compare the hidden case;
F5 creates a fresh wounded actor in M7 mode with cover on, so remove cover promptly
for another visible-retention comparison. Human keep/tune/revert and any isolated
commit exception are pending; this handoff does not close M6 or the failed gates.