Reconcile ReScaleFrame and plugin documentation with current implementation

.agents/skills/game-render-analysis/SKILL.md

@@ -124,8 +124,9 @@ resize and teardown. A clean aircraft with missing clouds is a regression.
 Update research, engine evidence and tracker with question, rationale, discovery, revisions,
 units, identities, lifetimes, failed attempts, runtime use and uncertainty. Separate source review,
 build, synthetic/device fixtures, captured game data and user-run visual acceptance. Numeric
-fixtures do not prove moving-game quality, FPS gains or latency. FG/Reflex and missing-object
-motion coverage remain separate work.
+fixtures do not prove moving-game quality, FPS gains or latency. FG/Reflex acceptance and missing-object motion coverage require their own evidence. Current
+AC7 DLSS-G and final Unity FG corrections have recorded acceptance; higher MFG, new AC7 vendor FG,
+Claw and measured latency claims remain separate gaps. See [current status](../../../docs/current-status.md).
 
 Use focused checks for documentation. Native/SDK changes require `eng/verify.ps1`; Rust behavior
 also requires `cargo test --workspace --locked`. Verification must not alter a game installation.

.agents/skills/game-render-analysis/references/session-lessons.md

@@ -1,5 +1,9 @@
 # AC7 session lessons, 30 September to 2 October 2026
 
+Scope: this reference records AC7 SR findings through 2 October. Later FG/Reflex, shared Unity
+services and unresolved lighting work are summarized in
+[current status](../../../../docs/current-status.md). SR acceptance alone does not validate those paths.
+
 These are AC7 findings, not universal engine or GPU rules. The parent transcript and current
 source were reviewed before this reference was written. On 2 October the user accepted clean
 wing/cloud rendering, then accepted the optimized SR bridge and FSR4 compatibility deployment.

.agents/skills/ue418-render-integration/references/ac7-native-ownership.md

@@ -1,5 +1,9 @@
 # AC7 native ownership on UE4.18
 
+Scope: this reference records AC7 SR findings through 2 October. Later FG/Reflex, shared Unity
+services and unresolved lighting work are summarized in
+[current status](../../../../docs/current-status.md). SR acceptance alone does not validate those paths.
+
 This is the working AC7 integration's evidence map, not a portable binary patch recipe.
 Always read current guards and structures in source. Values below were checked against that
 source on 2 October 2026; private layouts depend on the fingerprinted executable.

AGENTS.md

@@ -62,7 +62,8 @@ ctest --preset windows-debug
 ctest --preset windows-debug -R game_plugin_contract   # a single test
 ```
 
-Binaries land in `build/windows-x64/bin/<Config>/`.
+Shared binaries land in `build/windows-x64/bin/<Config>/`; the dedicated AC7 DirectInput carrier
+lands in `build/windows-x64/ac7/bin/<Config>/`. The Unity version alias is in `bin/<Config>/carriers/`.
 
 ### Building off Windows
 
@@ -87,14 +88,19 @@ Windows unless it was actually built there.
 
 ## Architecture
 
-Three artifacts load into the game process, plus one out-of-process frontend:
+The native targets have these roles. Current game entry uses a carrier; bootstrap and launcher
+remain scaffolds. AC7 links runtime objects into its proxy, while Unity loads the runtime DLL:
 
 | Target | Output name | Role |
 | --- | --- | --- |
-| `rsf_bootstrap` | `ReScaleFrame.Bootstrap.dll` | injected entry point, loads the orchestrator |
+| `rsf_bootstrap` | `ReScaleFrame.Bootstrap.dll` | version-only scaffold for the intended injected entry |
 | `rsf_orchestrator` | `ReScaleFrame.Runtime.dll` | vendor SDKs, plugin lifecycle, GPU resources, presentation |
-| `rsf_game_ac7` | `ReScaleFrame.Game.AC7.dll` | game plugin: detection, hooks, engine data |
-| `rsf_launcher` | `ReScaleFrame.exe` | standalone launcher and profile frontend |
+| `rsf_game_ac7` | `ReScaleFrame.Game.AC7.dll` | native AC7 detection, hooks and engine data |
+| `rsf_game_project_wingman` | `ReScaleFrame.Game.ProjectWingman.dll` | exact-build detection scaffold, rendering refused |
+| `rsf_game_unity_mono` | `ReScaleFrame.Game.UnityMono.dll` | shared Mono/Harmony URP DX12 adapter |
+| `rsf_proxy_ac7` | `dinput8.dll` in `ac7/bin/<Config>` | dedicated AC7 carrier |
+| `rsf_proxy_dinput8` | `ReScaleFrame.Loader.dll`, `carriers/version.dll` aliases | shared Windows shim; Unity drop-in carrier |
+| `rsf_launcher` | `ReScaleFrame.exe` | help/version scaffold; launching and profiles pending |
 | `rsf_game_sdk` | `ReScaleFrame::GameSDK` (INTERFACE) | the C header both sides compile against |
 
 Working consequences of the ownership split above:
@@ -146,13 +152,16 @@ Mechanics that the header and `tests/plugin_contract.cpp` jointly enforce:
 - Extend structs by appending fields and bumping `RSF_GAME_ABI_VERSION`, never by reordering.
 - Plugin-returned strings are immutable, plugin-owned, and valid until the DLL unloads. Probe strings
   are borrowed for the duration of the call.
-- Frame callbacks are deliberately absent for now (their shape, ABI 2, is specified in
-  `docs/representation-plan.md` and lands with its M5). They land after the renderer experiments settle
-  their shape.
-
-The honesty rule is testable here: `rsf_game_info.rendering_ready` stays `0` and `status` stays
-truthful until rendering works through the plugin lifecycle, and the contract test asserts it. The same applies to
-prose. Built is not injected, recognized is not supported, and a higher presentation counter is not
+- Current game ABI is 13. `game_renderer.h` defines leased rendering passes, CPU events and host
+  services; `game_frame.h` defines frame/camera ABI 1. The older ABI 2 sketches in the representation
+  plan are historical design, not the current contract. Native resource pointers cross under explicit
+  callback leases; frame identity alone does not establish final Present ownership.
+
+The honesty rule is testable here: all current plugins keep `rsf_game_info.rendering_ready` and
+renderer status readiness at `0`, and contract tests assert it. AC7 and Unity implement lifecycle
+rendering and have recorded acceptance for particular deployed paths; that does not imply broad
+plugin readiness. Keep code-level flags, actual implementation and acceptance scope distinct in prose.
+[Current status](docs/current-status.md) records those boundaries. Built is not injected, recognized is not supported, and a higher presentation counter is not
 lower latency. Do not soften README or status wording ahead of the code.
 
 ## Conventions

README.md

@@ -18,18 +18,22 @@ The AC7 proxy loads the game plugin and shared runtime services.
 | Area | Status |
 | --- | --- |
 | DLSS Super Resolution / DLAA | Working in AC7 |
-| Game detection and native SDK | Versioned C ABI, guarded AC7 engine hooks and renderer/resource ownership implemented; other games remain unsupported |
-| Frame generation and latency | Planned; graphics interoperability research and shared-surface tests are in place |
+| Game detection and native SDK | Game ABI 13 with lifecycle, CPU events and renderer callbacks; AC7 and Unity Mono paths implemented; Project Wingman remains a scaffold |
+| Frame generation and latency | Current source implements DLSS-G, FSR3/4 FG, XeSS FG, Reflex/XeLL and live provider switching; AC7 DLSS-G and Unity corrections have user acceptance; broader hardware/scene and measured latency validation remain open |
 | FSR and XeSS | FSR 2/3/4 and XeSS SR available in AC7; optimized D3D11/D3D12 transfer; FSR 4 INT8 compatibility device-tested on RTX 4070 |
 | Standalone launcher and WSGM | Scaffolding and planned integration |
 
+The published v0.1.0 AC7 ZIP provides SR and the overlay; it does not contain the later FG/Reflex
+work on `main`. Unity currently has local test packages, not a published release.
+See [current implementation and validation](docs/current-status.md) for evidence and remaining limits.
+
 For downloads, supported builds, installation and controls, see the relevant game's README:
 
-| Game | Released features | Guide |
+| Game | Availability | Guide |
 | --- | --- | --- |
 | Ace Combat 7 | DLSS/DLAA, FSR 2/3/4, XeSS SR and overlay on Windows x64 | [AC7 README](games/ac7/README.md) |
 | Project Wingman | Scaffold and static UE4.27.2 research; rendering unsupported | [Project Wingman README](games/project-wingman/README.md) |
-| Drag'n Wash | Experimental Unity Mono DX12 SR and shared overlay; Claw test package | [Drag'n Wash README](games/drag-n-wash/README.md) |
+| Drag'n Wash | Unity Mono DX12 SR, shared overlay and runtime FG switching in source/local test builds; Claw acceptance pending | [Drag'n Wash README](games/drag-n-wash/README.md) |
 
 [Releases](https://github.com/KillerPixelCrew/ReScaleFrame/releases)
 · [Implementation tracker](docs/implementation.md)
@@ -49,9 +53,9 @@ to the shared runtime. Loading that runtime is separate from activating a render
 | Game SDK | Keep the plugin/runtime boundary versioned and explicit through a C ABI |
 | Frontends | Configure sessions and show status through bounded IPC |
 
-These are the framework's ownership boundaries. The current AC7 proxy still contains some glue
-that will move into the plugin lifecycle; the working game path and that migration are tracked
-separately.
+The AC7 DirectInput carrier prepares the game plugin and links shared runtime objects into its
+proxy. The Unity version shim loads the runtime DLL and shared Mono plugin. Bootstrap and launcher
+remain scaffolds; frontend IPC is intended architecture rather than an implemented control route.
 
 Super resolution consumes scene colour before tonemapping. Frame generation needs a completed
 HUD-less image later in the frame. ReScaleFrame treats those as separate inputs and keeps frame/view
@@ -84,7 +88,9 @@ All first-party components live in this monorepo and share one release version.
 ## Build and verify
 
 Windows/MSVC is the reference platform. You need Visual Studio C++ tools, a Windows SDK, CMake,
-PowerShell and the Rust toolchain pinned in `rust-toolchain.toml`.
+PowerShell and the Rust toolchain pinned in `rust-toolchain.toml`. Unity managed builds additionally
+need .NET, Unity native headers and the researched player's Managed assemblies; see
+[the Unity guide](games/unity-mono/README.md).
 
 ```powershell
 ./eng/verify.ps1 -Configuration Release
@@ -93,7 +99,8 @@ cargo build --release --locked -p rescaleframe-overlay
 ```
 
 Use `-VS2026` on the verification command if you have Visual Studio 2026 instead of 2022.
-Native outputs are written to `build/windows-x64/bin/Release`; the Rust overlay is in `target/release`.
+Shared native outputs are written to `build/windows-x64/bin/Release`; the dedicated AC7 carrier is
+`build/windows-x64/ac7/bin/Release/dinput8.dll`. The Rust overlay is in `target/release`.
 
 The verification gate builds and tests the native tree, checks Rust formatting and runs Clippy.
 Rust tests use the separate command above. Verification never launches a game or changes an

docs/current-status.md

@@ -0,0 +1,101 @@
+# Current implementation and validation
+
+Documentation checked on 7 October 2026 against source commit
+`fda5fd0f2730b40e5b96f419bc0a05cb0b73932b`, the recorded research and GitHub release metadata.
+This is a source/documentation audit. No new game, GPU or Windows build was run for this audit.
+
+## Downloads and source builds
+
+The published [v0.1.0 AC7 release](https://github.com/KillerPixelCrew/ReScaleFrame/releases/tag/v0.1.0)
+contains DLSS/DLAA, FSR 2/3/4 and XeSS SR, the AC7 plugin and Insert overlay. Its replacement
+assets were uploaded on 2 October. FG and Reflex are absent from that package. Updating `main`
+does not update a downloaded ZIP. Its included manifest and corresponding-source archive identify
+the packaged code. There is no published Unity or Project Wingman release in the release listing
+checked for this audit.
+
+Current source implements independent SR/FG selection and live FG provider replacement for AC7
+and the Unity Mono adapter. Build/deployment scripts and local test ZIPs are separate from a
+published release. The Unity packager uses local Release artifacts and a deployed vendor payload;
+it does not prove that a particular ZIP received game or Claw acceptance.
+
+## Game integrations
+
+| Integration | Implemented | Recorded validation and limits |
+| --- | --- | --- |
+| AC7, Steam build 9855922, D3D11 | Native renderer hooks and pre-tonemap SR; output-resolution UI/briefing; TrueSky correction; DLSS, FSR2/3/4, XeSS; D3D12 presentation facade and independent FG | User accepted corrected SR/UI/cloud rendering and DLSS-G. FSR3/XeSS FG have synthetic device activity; new AC7 vendor FG paths lack live acceptance. Briefing FG is deferred. Later low-resolution lighting defects and missing-object motion coverage remain open. |
+| Drag'n Wash, Steam build 25286774, Unity 6000.3.14f1 Mono/URP RenderGraph, D3D12 | Shared shim, Mono/Harmony hooks, pre-DoF SR, overlay, DLSS/FSR/XeSS FG switching, pre-UI colour and temporal inputs independent of SR | Live SR execution and improved post-processing order recorded; user accepted XeSS/DLSS-G and the final FSR correction. General scene/resize/teardown coverage, other Unity players and MSI Claw acceptance remain unproven. |
+| Project Wingman, researched UE4.27.2 build | Exact executable detection and ABI lifecycle scaffold | Contract-tested in a test process. Preparation/start refuse. No renderer, SR, FG, latency or VR integration. |
+
+All three native plugin APIs still report `rendering_ready = 0`. That conservative code-level
+flag is distinct from recorded user acceptance of individual deployed paths; it must not be
+rewritten in prose as either universal support or absence of all working rendering. Detection
+checks executable basename, x64 machine and exact SHA256. Other builds remain unknown.
+
+Evidence: [AC7 consumer session](research/ac7-consumer-session.md),
+[native renderer](research/ac7-native-renderer-refactor-20261001.md),
+[SR/FSR4 acceptance](research/sr-interop-performance-20261002.md),
+[AC7 FG and pacing](research/ac7-dlss-fg-20261003.md),
+[shared FG corrections and final Unity acceptance](research/shared-fg-20261004.md),
+[Unity SR](research/unity-dx12-runtime-20261004.md),
+[lighting investigation](research/ac7-lighting-shadow-20261004.md) and
+[Project Wingman research](research/project-wingman-renderer.md).
+
+## Runtime and controls
+
+SR consumes pre-tonemap scene colour. FG consumes the completed display-size frame and matching
+normalized depth/motion, with optional HUD-less guides. AC7 preserves native UI composition;
+its raw widget target is not proof of a vendor-compatible UI layer. Unity captures SDR colour
+before screen-space UI; HDR output refuses that guide path. Full UI/moving-scene quality coverage
+is not established for every provider.
+
+One physical presentation provider owns the chain at a time. Live replacement drains the old
+owner and preserves engine buffers; unsupported requests retain the working provider. Insert
+offers independent SR and FG choices, SDK-limited multipliers, Reflex and FPS controls.
+FG provider preferences are saved separately from deployment defaults. Other controls' persistence
+depends on the host; do not assume every setting survives restart.
+
+| FG provider | Capability in current source | Evidence limit |
+| --- | --- | --- |
+| DLSS-G | Fixed count and capability-gated Dynamic MFG in the runtime; SDK maximum queried; active generation requires effective Reflex at least On | Recorded RTX 4070 path generates one frame per source (2x). Higher counts and Dynamic MFG lack live acceptance. |
+| FSR3 / FSR4 | Exact provider family requested; pinned swapchain API exposes one generated frame (2x) | FSR3 device activity and Unity user acceptance recorded. FSR4 FG refused the tested NVIDIA adapter; FSR4 SR INT8 success does not establish FSR4 FG support. |
+| XeSS FG | XeLL pacing and SDK-queried interpolation maximum; count changes through the SDK | Device activity and Unity user acceptance recorded at 2x. Higher Intel MFG counts and Claw operation remain untested. |
+
+FSR2 and FSR1 are SR choices, not FG providers. Unity Off/FSR1 can still produce normalized FG
+inputs. Pacing follows the FG provider; NVIDIA SR does not impose Reflex sleep on FSR/XeSS.
+Rendered FPS and SDK/DXGI aggregate presented FPS are separate counters. Neither establishes
+physical scanout, a latency reduction, or an in-game performance gain.
+
+## ABI, build and frontends
+
+| Contract | Current version | Source |
+| --- | --- | --- |
+| Game plugin lifecycle and renderer callbacks | 13 | `sdk/game/include/rescaleframe/game_api.h`, `game_renderer.h` |
+| Frame/camera record | 1 | `sdk/game/include/rescaleframe/game_frame.h` |
+| Vendor-neutral backend | 3 | `runtime/contract/include/rescaleframe/backend.h` |
+| FG provider | 1 | `runtime/contract/include/rescaleframe/frame_generation.h` |
+| Overlay | 9 | `ui/overlay/include/rescaleframe/overlay.h` |
+
+`VERSION` and the Cargo workspace both specify 0.1.0. Equal component versions do not imply equal
+builds or ABI compatibility; deploy matched artifacts. SDK headers are optional, and absent headers
+produce explicit unavailable stubs. Unity managed builds additionally require .NET, the researched
+player's Managed assemblies, Harmony and Unity native headers. Those game assemblies are build
+references and are not distributed.
+
+Windows/MSVC is the reference build. `eng/verify.ps1` builds/tests native code and runs Rust format
+and Clippy. Rust tests need `cargo test --workspace --locked`; managed/device fixtures are separate.
+Recorded test counts describe their dated runs and include opt-in skips. They are not fresh audit
+results or proof that clean CI exercises SDK-enabled GPU code.
+
+The bootstrap DLL exports only a version; the launcher supports help/version without launching
+or injection. Current game entry points are the AC7 DirectInput carrier and Unity version shim.
+WSGM integration and frontend IPC remain planned. AC7 links shared runtime objects into its proxy;
+Unity loads `ReScaleFrame.Runtime.dll`. See the [loader guide](../loader/README.md).
+
+## Reading the history
+
+[The implementation tracker](implementation.md) and research notes preserve dated failures,
+experiments and later corrections. A pending statement in an earlier increment applies to that
+increment. Follow its later correction and this status page for current claims. Plans describe
+intended behavior; they are not feature or acceptance lists. Evidence JSON snapshots retain their
+original measurements and hashes. Game `engine.json` summaries carry a separate current validation
+summary so earlier observations remain attributable.