# Modern runtime Slice J8 — no-window integration and Slice J closeout

**Status:** PLANNED — J7 PHYSICAL-DISPLAY ACCEPTANCE IS THE ENTRY GATE
**Parent:** `2026-07-25-modern-runtime-slice-j.md`, J8
**Authorization:** the user approved Slices F–L, including the J gameplay-owner
gates, on 2026-07-24
**Purpose:** prove that the exact `GameRuntime` graph now used by the graphical
client can run a complete deterministic client lifecycle without App, a
window, rendering, retained UI, audio, or backend assemblies.

## 1. Entry state

J7.1 created the root at `96ddd165`. J7.2/J7.3 cut the graphical host and
shutdown transaction over to it at
`ce41efb9e5938f79a7580476b949d172f52a1e69`. Focused, complete Release,
connected lifecycle/reconnect, and canonical nine-stop automated gates pass.
J8 may begin production/test implementation only after the user accepts J7's
physical-display radar, paperdoll, Use/approach, combat-facing, and recall
matrix.

Existing direct tests prove the individual pieces, but not the complete root:

- `RuntimeLiveSessionNoWindowTests` proves a direct session can connect, enter,
  and stop.
- `RuntimeSimulationFixtureHostTests` proves movement, use, attack, cast, and
  projectile behavior over separately constructed Runtime owners.
- `RuntimeWorldTransitDirectHostTests` proves login, portal, cancellation, and
  host acknowledgements over a separately constructed transit owner.
- `GameRuntimeTests` proves root construction, isolation, lazy events, leases,
  rollback, and terminal disposal.

J8 replaces those disconnected proofs with one end-to-end root-host proof. It
does not remove the focused tests.

## 2. Fixed boundary

The integration host lives in `AcDream.Runtime.Tests` and references only
`AcDream.Runtime` and its existing transitive Core/Core.Net/Content contracts.
It is a test host, not the Slice-K CLI.

It constructs:

- one `GameRuntime`;
- one explicit no-window host lease;
- one `LiveSessionHost` borrowing `GameRuntime.Session`;
- one deterministic `ILiveSessionOperations` fixture with a real
  `WorldSession` and in-memory transport;
- one generation-scoped inbound route;
- one generation-scoped outbound command route;
- one immutable fixture-content catalog for spell and world metadata;
- one `RuntimeTraceRecorder`.

It must not construct an App adapter, duplicate entity directory, duplicate
object table, duplicate gameplay owner, second clock, second transit owner, or
second session controller.

The host applies already-decoded deterministic packets through the same Runtime
owner APIs that the graphical session route uses. Core.Net parser correctness
remains covered by Core.Net wire fixtures; J8 verifies ownership, ordering,
commands, state, generation, and teardown after decode. Test reflection may
raise a `WorldSession` event only where the public event source deliberately
has no injection API; no production test-only hook is added.

## 3. Scenario and exact ordering

One canonical scenario runs in this order:

1. Construct the root and host; capture the empty checkpoint.
2. Start generation 1 through `LiveSessionHost`.
3. Bind inbound before connect, select the first fixture character, install
   exact local identity, enter world, and activate outbound commands.
4. Deliver decoded inbound fixtures:
   - local-player CreateObject;
   - one hostile creature;
   - one usable world object;
   - one container and one inventory item;
   - one inventory/container mutation;
   - one system chat line and one local speech line;
   - one vital/character update;
   - one environment/time update.
5. Advance the instance clock and execute through the root's exact owners:
   - movement;
   - selection plus use;
   - combat mode plus attack;
   - learned-spell cast;
   - one projectile simulation commit.
6. Drive one accepted teleport destination through typed destination
   readiness, materialization, host projection acknowledgements, world-visible
   acknowledgement, and completion.
7. Capture and compare the ordered Runtime event/checkpoint trace.
8. Stop generation 1; prove the old inbound and outbound routes are inert.
9. Reconnect as generation 2 in the same process.
10. Reuse one server GUID with a new incarnation; prove no generation-1
    identity, command, packet, event sequence, inventory, physics, or portal
    state leaks into generation 2.
11. Stop, release the no-window lease, dispose the root, and require
    `GameRuntimeOwnershipSnapshot.IsConverged`.

The fixture trace records lifecycle, entity, inventory, chat, movement,
portal, command, and checkpoint rows. Sequence numbers must be strictly
increasing within a generation and restart only when the generation changes.

## 4. Execution

### J8.1 — one direct root host

- Add a reusable test-only `NoWindowGameRuntimeHost`.
- Move the existing J5 direct-host scenario onto `host.Runtime` rather than
  separately constructing six owners.
- Borrow root identity, session, entity/object, inventory, character,
  communication, action, movement, environment, transit, clock, and event
  source.
- Acquire and release one named host lease.
- Prove the test assembly/process loads no App, UI, Silk.NET, OpenAL, Arch,
  ImGui, or renderer/audio/window type.

Gate: the direct root host constructs, captures a checkpoint, and converges
without a presentation assembly or duplicate owner.

### J8.2 — deterministic transport/content lifecycle

- Build deterministic session operations and in-memory transport.
- Bind the exact session lifecycle order:
  reset → attach inbound → connect → select identity → enter → activate
  outbound.
- Install immutable spell/world fixture metadata before its dependent packet.
- Route decoded entity, object, inventory, chat, character, environment, and
  transit fixtures into the root.
- Execute movement, use, attack, cast, and projectile work through root-owned
  state.
- Complete one portal using the same typed host acknowledgement contract as
  App.
- Stop and reconnect, then verify generation isolation and GUID reuse.

Gate: one normalized golden trace proves all state and commands share the same
root, accepted ordering is stable, and old-generation routes are inert.

### J8.3 — cancellation, faults, isolation, and credentials

- Cancel during connect, after inbound attach, during portal readiness, and
  with a host acknowledgement pending.
- Inject route-construction, route-detach, observer, projection
  acknowledgement, and terminal callback failures.
- Retry the exact retained suffix and require convergence.
- Run two roots simultaneously with different credentials, clocks, GUIDs,
  inventory, chat, combat, spell, projectile, and portal state.
- Assert logs contain endpoint/user context only where intended and never
  contain the password, credential record, or exception text that embeds it.
- Prove a disposed/old route cannot mutate the new generation.

Gate: every fault converges; two roots remain isolated; diagnostics are
credential-safe.

### J8.4 — complete Slice J gate

- Run focused Runtime tests.
- Run the Release solution build.
- Run the complete Release suite.
- Run exact-binary connected graphical lifecycle/reconnect.
- Run the canonical graphical nine-stop route.
- Reconfirm the accepted J7 physical-display matrix.
- Audit dependency closure, presentation assembly loads, duplicate
  constructors, mutable statics, retail divergences, and teardown ledgers.
- Update architecture, code structure, milestones, roadmap, parent and
  umbrella plans, AGENTS/CLAUDE, and durable memory.

Gate: graphical and no-window hosts use the same root and owner graph; packet
and command ordering remains stable; terminal ownership converges; no
presentation/backend assembly enters the direct process. Slice J is then
closed and Slice K may add the Linux multi-session CLI and scheduler without
extracting gameplay again.

## 5. Adversarial matrix

- missing credentials and no characters;
- connect failure before and after route attachment;
- duplicate Start, stale Start, Stop, and Reconnect generations;
- inbound packet before selection and after Stop;
- command before world entry and after route retirement;
- duplicate CreateObject and GUID reuse across reconnect;
- observer throws during entity, inventory, chat, command, movement, or portal
  dispatch;
- route creation succeeds but activation fails;
- detach throws once, then succeeds;
- portal cancellation before readiness, after readiness, and with each host
  acknowledgement outstanding;
- projectile projection callback throws;
- host lease retained during root disposal;
- root terminal disposal retries after each stage;
- two roots use the same server GUID without sharing local IDs;
- password-shaped marker absent from trace, logs, exception messages, and
  test output;
- App/UI/Silk/OpenAL/Arch/ImGui assemblies absent from the loaded-assembly set.

## 6. Non-goals

- No Linux executable or bot scheduler; those are Slice K.
- No hidden graphical process.
- No renderer, audio, UI, particle, camera, selection-marker, or portal-tunnel
  stub.
- No new network parser or alternate packet order.
- No asynchronous command queue or extra frame boundary.
- No gameplay-state mirror, facade dictionary, service locator, or test-only
  production injection API.
- No retail behavior change and therefore no divergence row unless the audit
  discovers a pre-existing unregistered difference.

## 7. Commit and rollback discipline

J8 implementation lands as one test/integration closeout commit after the J7
visual entry gate, followed by one documentation closeout commit if needed.
The full production SHA and exact `git revert <sha>` are recorded here before
Slice K starts. J8 must not modify the J7 rollback point:

```text
git revert ce41efb9e5938f79a7580476b949d172f52a1e69
```