Files
frameledger/docs/spike-notes.md
T
poli0981andClaude Opus 5.5 2ce8251d31 feat: the game's own memory, measured from outside the game in every session - a C++ reader of the GPU Process Memory counters and GetProcessMemoryInfo, median and mean, schema 0018 (D43, beta.12 PR-2) (#254)
- FrameLedger.ProcessStats.dll (C++20, loaded by the Agent, never into a game): the game process's dedicated and shared
  GPU memory from the documented `GPU Process Memory` performance counters (no handle to the game, every instance of the
  pid summed) and its private working set / working set / commit from GetProcessMemoryInfo (EX2, falling back to EX)
  through PROCESS_QUERY_LIMITED_INFORMATION only (a sentinel refuses an EX2 answer whose private working set was not
  filled). Not D3DKMTQueryStatistics ("Reserved for system use").
  ctest fl_process_stats (GPU_INSTANCE on a hardware adapter, NO_GPU_INSTANCE on CI) and fl-probe-processstats.
- Measured first, decision table in spike-notes §16 written before the runs: +512.0 MiB for a 512 MiB buffer,
  private working set equal to Windows' own counter, 0.1 ms per read, nothing leaked over 600 reads; dedicated reads a
  constant 4.5 MiB above DXGI's local usage, so it is never compared with a budget.
- NativeProcessStats (third facade), GameMemoryReader: a pinned session reads through its held handle; an unpinned
  Tier-2 hold opens each process of the executable for the read, refuses a reused pid, sums. CaptureSession tells the
  observer which process (ICaptureObserver.Measuring), the recorder forwards it to the poller (ITelemetryPoller.Follow).
- TelemetrySample.Game; five sensor series; schema 0018 (game_vram_dedicated_*, game_ram_private_*, ..., sensor_stats_json);
  SeriesAggregates gains Median and Min; a wide .partial sensors chunk (type 8) with type 4 still read; SessionProgress
  and SessionHeld carry the game's memory live.
- notice-check accepts a contributor's own copyright line in the same form.
- Tests: the two classes that open a LibreHardwareMonitor Computer run one at a time - GenericCpu.Update threw a
  NullReferenceException in the local gate when they ran in parallel (the Agent's own read is already contained).
- Docs corrected in place: 03_METRICS, 18_GPU_VENDOR_APIS, 17_HOOK_ENGINE, 20_OPEN_QUESTIONS (§M7, §H10, new §M11),
  04_CAPTURE, 19_SAFETY, 06_DATA_MODEL, 07_IPC, 02_SPEC, 01_ARCHITECTURE, 12_BUILD, CLAUDE.md; the accuracy block and
  LIMITATIONS.md.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-03 23:21:45 +07:00

166 KiB
Raw Blame History

P0 spike notes

P0's named deliverable (15_ROADMAP §P0). Where measured results go, not predictions. (It began empty by design and is now the longest record here.)

Rules:

  • Record what was observed, with the machine, driver version, game and SDK version it was observed on. A result without its context is not reusable.
  • Record failures and dead ends too. "We tried X, it deadlocked, here is why" is worth more than silence, and prevents the next person retrying it.
  • When an entry answers an item in 20_OPEN_QUESTIONS.md, fix the owning doc, delete the question, and note both here.
  • Nothing in P1 starts until the exit criteria at the bottom pass.

Environment

Recorded 2026-08-02. Toolchain rows are verified — the native layer builds and its tests pass on this machine. Everything below the toolchain is context for the measurements that have not been taken yet.

CPU Intel Core i7-14700KF
GPU NVIDIA GeForce RTX 5080, driver 32.0.16.1088
RAM 32 GB DDR5
Motherboard Gigabyte Z790M AORUS ELITE AX
Display MSI MAG 274QF X24 — 2560×1440, 240 Hz
OS Windows 11 Pro Insider Preview, build 26300.9032
.NET SDK 10.0.302 (pinned by global.json) — ✅ verified
MSVC 19.51.36252, toolset 14.51.36231, VS 2026 Insiders — ✅ verified
Windows SDK 10.0.22621.0 and 10.0.26100.0 installed — ✅ matches the TFM
CMake / Ninja CMake 4.4.0, Ninja from the VS CMake component — ✅ verified
Vulkan SDK 1.4.357.0 at C:\VulkanSDK\1.4.357.0, loader instance 1.4.357 — ✅ verified
Launchers installed Steam, Epic, itch.io, GOG Galaxy

Coverage gaps to state plainly rather than discover later:

  • No AMD or Intel GPU. The 18_GPU_VENDOR_APIS §Capability matrix cannot be filled for those vendors here, and that matrix drives what the UI advertises as available. Mark them "untested", never ?. AFMF (§9) is likewise unreachable — it is an AMD driver-side feature.
  • No integrated GPU (the KF suffix means no iGPU) and exactly one adapter. Multi-GPU adapter-LUID selection — the adapterLuid field in the shm handshake, and the PDH instance filtering in 18_GPU_VENDOR_APIS §L1 — cannot be exercised on this machine.
  • 240 Hz display. Useful to know when reading the ring-sizing argument in 04_CAPTURE: 8192 records is ~16 s at 500 fps, so ~34 s at this refresh rate. Hook-overhead runs should uncap the frame rate rather than sit at 240.

✅ This machine is a realistic multi-overlay test bed — use it

Six machine-wide implicit Vulkan layers are already registered under HKLM\SOFTWARE\Khronos\Vulkan\ImplicitLayers:

Layer Source
VK_LAYER_VALVE_steam_overlay, VK_LAYER_VALVE_steam_fossilize Steam
VK_LAYER_EOS_Overlay Epic Online Services
GalaxyOverlayVkLayer (+ _DEBUG, _VERBOSE) GOG Galaxy
VK_LAYER_OBS_HOOK OBS Studio
VK_LAYER_RTSS RivaTuner Statistics Server

RTSS and the Steam overlay also hook D3D presentation in-process. That makes this machine the right place to answer two open questions, rather than discovering them in a user's bug report:

  • §H7 — unhook clobbering. 17_HOOK_ENGINE §Unhooking restores the original vtable entry. If RTSS hooked the same slot after us, restoring it silently removes their hook. Test: hook with RTSS running, unhook, confirm RTSS still works. The compare-and-restore-only-if-unchanged fix is testable here today.
  • §H5 — proxy swapchains. With this many overlays present, the swapchain the game presents through may not be the object our dummy-vtable probe patched.

Two more observations from vulkaninfo on this machine:

  • HKCU implicit layers: none. All six above needed admin to register. 17_HOOK_ENGINE's choice of HKCU is the less common one and the better one.
  • The loader warns that GalaxyOverlayVkLayer violates naming policy LLP_LAYER_3, and that OBS/RTSS declare API 1.3 against a 1.4 application. Both are mistakes we should not copy — see 17_HOOK_ENGINE §Vulkan, where the layer name was corrected to VK_LAYER_FRAMELEDGER_overlay as a result.

GOG fixture available: A Space for the Unbound - Prologue at D:\another\gog\, with a goggame-1125815775.info sibling — a real fixture for the 05_DETECTION §Platform signatures GOG path.


0 · Licence checks (no hardware needed — do these first)

Answers 20_OPEN_QUESTIONS §M3, §M4. Both can invalidate a whole telemetry layer, and neither needs a GPU.

✅ M4 · LibreHardwareMonitor MPL-2.0 Exhibit B — CLEAR (2026-08-02)

  • Pinned version: LibreHardwareMonitorLib 0.9.6, nuspec <license type="expression">MPL-2.0</license>, repo commit 3d331e33.
  • The LICENSE file is not the evidence. MPL-2.0's own text contains Exhibit B as a template (at lines 369–372 of the licence), so grepping the licence file finds the string in every MPL-2.0 project ever published and proves nothing. What matters is whether a source file applies the notice.
  • Authenticated code search across the whole repository for "Incompatible With Secondary Licenses": total_count = 1, and the single hit is LICENSE itself — the template, not an applied notice.
  • Every file we depend on carries Exhibit A, the permissive form: Computer.cs, Sensor.cs, Gpu/NvidiaGpu.cs, Gpu/AmdGpu.cs all begin "This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0" with no Exhibit B sentence.
  • The shipped 0.9.6 .nupkg was unpacked and scanned: no Exhibit B notice in any of its 46 entries.
  • Result: MPL-2.0 §3.3 Secondary Licenses applies → GPL-3.0 compatible. L2 telemetry is safe to build on.

Two things this turned up that are not blockers but are now known:

  • The package ships no licence file at all (<license> is an SPDX expression). MPL-2.0 §3.1 therefore makes shipping the text our obligation — legal/licenses/mpl-2.0.txt is now committed, and the THIRD_PARTY_NOTICES release gate is a real requirement, not boilerplate.
  • Gpu/IntelIntegratedGpu.cs has no licence header — an upstream inconsistency, not an Exhibit B problem. The repo-root LICENSE still governs. Worth re-checking on any version bump.

✅ M3 · NVAPI licensing and the import library — CLEAR (2026-08-02)

  • Artifact: https://github.com/NVIDIA/nvapi, main.
  • The import library is in the repository: amd64/nvapi64.lib and x86/nvapi.lib are tracked files, not a separate SDK download. That was the crux of the question — a .lib obtained from the NVIDIA SDK installer would have come with the SDK's own agreement instead.
  • License.txt answers it in its first line, unusually explicitly:

    nvapi.lib and nvapi64.lib are licensed under the following terms: followed by SPDX-License-Identifier: MIT and the standard MIT text. The grant names the import libraries as its subject.

  • Headers carry their own SPDX-License-Identifier: MIT blocks (nvapi.h, nvapi_lite_common.h, nvapi_interface.h all verified).
  • Result: headers and nvapi64.lib are both MIT. MIT is one-way compatible with GPL-3.0; vendoring is fine provided the notice is retained, which tools/license-check.ps1 enforces. legal/licenses/nvapi-MIT.txt committed.
  • Reflex / PC latency (FR-4.6, the latency tab, sessions.latency_*) is therefore reachable. Ordinal resolution stays rejected — it was only ever a workaround for a constraint that does not exist.

1 · Guard (moved to first — 20_OPEN_QUESTIONS §R1)

Measured 2026-08-02, Windows 11 Pro Insider Preview 26300.9032, unelevated (the default Agent under ADR-9). Probe: src/native/tools/fl-probe-guard, running as ctest fl_guard_apis, so these are re-checked on every build rather than being a one-off. It opens processes only with PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ — the rights 19_SAFETY specifies — and never with CREATE_THREAD | VM_OPERATION | VM_WRITE.

✅ §S1 · Module enumeration on a suspended process — it fails, it does not return empty

suspended:          opened=1  enumerated=0  modules=0  enumErr=299 (ERROR_PARTIAL_COPY)
after ResumeThread: opened=1  enumerated=1  modules=9   (kernel32.dll present)

S1 predicted EnumProcessModulesEx "returns essentially nothing". Measured, it is sharper than that, and the difference is the whole point: the call fails with ERROR_PARTIAL_COPY (299). It does not hand back a plausible empty success.

That is the good version of this news. An empty success is the dangerous shape — it is exactly what EnumDeviceDrivers does, and it is what a guard reads as "clean". An outright error cannot be mistaken for a clean scan by any caller that checks the return value. So the guard's obligation here is narrow and explicit:

ERROR_PARTIAL_COPY means CANNOT DETERMINE, which means REFUSE. Never "no modules found".

The blindness is the suspension and not our handle rights — the same target with the same rights enumerates normally once resumed. §S1 is confirmed as a real constraint on launch mode; what to do about it is still §S13(c).

✅ §S7 · WOW64 — the wrong filter under-reports, and silently

Live 32-bit target (SysWOW64\cmd.exe) enumerated from this x64 process:

Filter Modules
LIST_MODULES_ALL 15
LIST_MODULES_DEFAULT 7
LIST_MODULES_32BIT 9
LIST_MODULES_64BIT 6

The default filter returns less than half the list, and returns it as a success. A guard using the default would scan a 32-bit title, see 7 modules, find no anti-cheat among them and report clean. LIST_MODULES_ALL is mandatory, not a preference.

✅ Fail-closed inputs — "cannot inspect" is a distinguishable state

  • Protected process: OpenProcess with the guard's own rights returns ERROR_ACCESS_DENIED (5) for at least one process on this machine. So "I could not look" and "I looked and it was clean" are genuinely different values, and 19_SAFETY §Elevated / protected targets is implementable.
  • Absent service: OpenServiceW on a non-existent name returns ERROR_SERVICE_DOES_NOT_EXIST (1060) specifically, not a generic failure — which is the discrimination 19_SAFETY relies on.
  • NOT MEASURED — the DENIED service branch. A standard user holds SERVICE_QUERY_STATUS on the stock service set, so ACCESS_DENIED is not producible against real services here. It has to be driven from a unit-test fake. Recorded rather than implied: A5 does not cover it.

✅ Driver enumeration — the replacement measured against the fail-open

EnumDeviceDrivers                 ok=1  count=266  non-null bases=0  recoverable names=0
NtQuerySystemInformation(11)      STATUS_SUCCESS  78,744 bytes
                                  parsed=266  well-formed=266  resolvable-on-disk=257  ntoskrnl=yes

EnumDeviceDrivers reproduces its documented fail-open exactly: 266 drivers reported, zero usable base addresses, zero recoverable names. The Nt* route returns 266 real native paths.

The fail-open is purely a function of elevation — established by CI, which runs elevated and failed this probe's original assertion:

Configuration EnumDeviceDrivers
unelevated (this machine, the ADR-9 default) 266 drivers, 0 bases, 0 names
elevated (GitHub windows-latest) 260 drivers, 260 bases, 260 names

The API is not broken; it is broken for standard users. That is the configuration ADR-9 makes the default, and it means anyone who tests this while elevated sees a perfectly working call and concludes the defect is imaginary.

The probe's assertion was originally unconditional — "the Nt* route recovers more identities" — which encoded one machine's configuration as a universal fact and went red on CI for a correct reason. It is now elevation-aware: it asserts the fail-open when unelevated, and when elevated says plainly that this run cannot demonstrate it.

The assertions here check content, not count — deliberately. "266 distinct non-empty strings" is not discriminating: the earlier two-byte offset bug produced exactly that, and every string was garbage. So the probe asserts that ntoskrnl.exe is present, that every path is a native path (\SystemRoot\ or \??\), and that 257 of them name files that actually exist on disk.

Canary, run every build: the same buffer is re-parsed with the historical two-byte skew and the validator must reject it — well-formed=0, ntoskrnl=NO, first entry ystemRoot\system32\ntoskrnl.exe. A count check passes that. This one does not.

◐ §S19(b) · the signer half, measured before it is designed — fl-probe-signer (2026-08-27)

ctest fl_signer_probe, unelevated, dev box. §S19(b) asked for three answers before any design is fixed; these are they. The analysis and the decision rows live in 20_OPEN_QUESTIONS §S19(b) — what belongs here is what was run.

Q1 · which route recovers an organisation. Offline flags throughout (WTD_REVOKE_NONE | WTD_CACHE_ONLY_URL_RETRIEVAL):

Subject embedded catalog O=
System.Security.Cryptography.ProtectedData.dll (NuGet 6.0.0) ERROR_SUCCESS 3.61 ms no catalog Microsoft Corporation
mskeyprotect.dll TRUST_E_NOSIGNATURE 0.23 ms ERROR_SUCCESS 3.62 ms Microsoft Corporation
kernel32.dll ERROR_SUCCESS 4.69 ms ERROR_SUCCESS 3.48 ms Microsoft Corporation

Full subject on every one: C=US, S=Washington, L=Redmond, O=Microsoft Corporation, CN=Microsoft Windows — so signerField: "O" holds here, on a subject class it had never been measured against.

Two results that cut opposite ways. The CI blocker is embedded-signed and verifies offline, so the embedded half alone would clear that refusal. mskeyprotect.dll — the module §S19(b) was written about — does not, and needs CryptCATAdmin*. The entry predicted exactly that and it is now measured rather than argued.

kernel32.dll carries BOTH, which the probe was written assuming it would not. "Catalog-signed" is not inferable from a file being a system binary; it is a per-file measurement, which is why the probe reports both routes for every subject.

And the module is not what §S19(b) says it is. It calls the blocker "a .NET shared-framework assembly". Microsoft.NETCore.App 10.0.11 does not contain it. It is a NuGet package assembly reached transitively as Microsoft.NET.Test.Sdk → System.Configuration.ConfigurationManager → System.Security.Cryptography.ProtectedData, staged next to every test binary. Dropping the reference means dropping the test SDK, so the cheapest-looking route out of the CI refusal is closed.

Q2 · cost. Cold 3.45 ms; warm mean of 20 = 3.54 ms. There is no amortisation: the second verification of the same file costs what the first did. Comfortable against the 30 s re-scan because the scan set is small — three real titles produced no fragment hit at all — and it stops being comfortable on a title that trips the fuzzy tier repeatedly.

Q3 · 🔴 cryptnet.dll is newly loaded UNDER THE OFFLINE FLAGS. Census bracketing the offline arm alone: cryptnet.dll appears. Nothing further appears once the default WTD_REVOKE_WHOLECHAIN calls run, so this is not the default arm leaking into the measurement.

The first version of this probe could not have told those apart. It censused once at the top and once at the bottom with both arms in between, so the module appeared and the delta could not attribute it — a census spanning both arms of the comparison it exists to discriminate. Fixed before the run recorded above. Same shape as §S30's "two numbers agreeing can be one number read twice", one layer down.

Mapped is not transmitted, and this probe cannot close the gap. cryptnet.dll being loaded is the module that would make a request, not evidence that one was made; there is no packet counter here. The discriminating run is the owner's: adapters disabled, same three subjects, compare verdicts. A verdict that changes offline retires the route, and §S19(b)'s row G2 says so before the run.

Canary. The probe's own unsigned executable returns TRUST_E_NOSIGNATURE and yields no organisation — so a green result discriminates rather than merely running. fl-baseline-probe was retired by exactly this class of test.

Not measured here: the CI leg (a different machine stages a different copy), and the adapters-disabled leg. Both have pre-committed rows. An unrun leg is unrun. The CI leg, 2026-09-06 (the ctest printed nothing for eleven days; ci.yml now runs the probe as a step): windows-latest, elevated. Blocker copy from the runner's NuGet cache, 6.0.0, embedded/offline ERROR_SUCCESS 3.47 ms, O= Microsoft Corporation, no catalog; mskeyprotect.dll embedded TRUST_E_NOSIGNATURE, catalog ERROR_SUCCESS; kernel32.dll both; cold 3.45 / warm 3.53 ms; cryptnet.dll newly loaded under the offline flags; canary TRUST_E_NOSIGNATURE; "G1 is a CANDIDATE". Rows G3, G4, G5 do not fire. The adapters-disabled leg, the owner's run, 2026-09-06 (dev box, elevated): every verdict unchanged — kernel32.dll both ERROR_SUCCESS; mskeyprotect.dll embedded TRUST_E_NOSIGNATURE, catalog ERROR_SUCCESS; the blocker embedded ERROR_SUCCESS, O= Microsoft Corporation, subject now CN=.NET (the August copy read CN=Microsoft Windows; same O=); cold 2.14 / warm 2.15 ms; cryptnet.dll mapped; canary TRUST_E_NOSIGNATURE. Row G1 reads; the bound decision is the owner's before anything is built.

Still open

  • §S13(c) — decision on launch-mode injection timing. The measurement above makes the constraint precise but does not make the decision. Deliberately not taken here: quantifying the early-init data actually lost needs a title that loads a presentation runtime lazily, and the only local fixtures are hook-harness (creates D3D at startup) and a 2D GOG prologue. A number from those would not generalise, which is worse than recording it as unmeasured. (2026-09-06: built as "inject late" — P1 item 2 — and the number now comes from every launched session, as dxgiPresentsBeforeHook plus the reported wait. 20_OPEN_QUESTIONS §S1.)

✅ Signer field for the unknown-but-suspicious heuristic — O=, not CN=

Measured 2026-08-02, Windows 11 26300, unelevated, via Get-AuthenticodeSignature on real binaries present on this machine.

Binary CN= O=
kernel32.dll Microsoft Windows Microsoft Corporation
win32u.dll Microsoft Windows Microsoft Corporation
nvapi64.dll Microsoft Windows Hardware Compatibility Publisher Microsoft Corporation
nvlddmkm.sys (the display driver) Microsoft Windows Hardware Compatibility Publisher Microsoft Corporation
nvrla.exe NVIDIA Corporation NVIDIA Corporation
steam.exe Valve Corp. Valve Corp.

The trustedSigners list was a guess marked UNVERIFIED, and the schema's own comment said the comparison was against CN. Measurement says that is the wrong field: WHQL re-signing replaces the CN with a Microsoft publisher string, so NVIDIA's own kernel driver does not present as NVIDIA. Under a CN comparison the whole driver stack reads as untrusted, and paired with the guard/protect name fragments that is a false-refusal path — the failure direction that is safe for the user's account but destroys trust in the gate, which is how someone ends up asking for the override CLAUDE.md rule 2 says does not exist.

signerField is now a schema const": "O", so switching it back requires editing the schema. "Microsoft Windows" was dropped from trustedSigners — it is a CN value and matches nothing under O=.

Untested by decision (2026-08-02): Intel Corporation and Advanced Micro Devices, Inc.. No AMD or Intel GPU and no iGPU on this machine (§Environment), and the owner elected to keep NVIDIA as the v1 focus rather than chase them.

The WHQL finding above is what makes that cheap: both vendors' driver binaries are WHQL-signed, so they present O='Microsoft Corporation' and are already suppressed by the first entry. Only their non-WHQL first-party binaries depend on these two strings, and a wrong string there fails closed — a refusal, never a silent allow. Kept in the data, labelled untested, not presented as measured.

2 · Vulkan layer passthrough (moved earlier — §R2)

Measured 2026-08-02 against Vulkan loader 1.4.357 on Windows 11 26300, unelevated, with tools/vklayer-blastradius.ps1. That script is the only place the layer is registered; it registers under HKCU, runs vulkaninfo, and unregisters in a finally block including on failure. Verified clean afterwards.

✅ enable_environment works, and it compares the VALUE

Condition Result
FRAMELEDGER_ENABLE_VK_LAYER unset loader locates the manifest, never maps the DLL
set to 1 (the manifest's value) Insert instance layer / Inserted device layer — mapped
set to 0 (non-matching) not enabled — the loader compares the value, not mere existence

The value comparison is the better of the two possible answers and was not safe to assume: had the loader merely checked existence, a stray FRAMELEDGER_ENABLE_VK_LAYER=0 anywhere in a user's environment would have enabled us machine-wide.

Still a loading gate, not a security gate. Anything running as the user can set the variable. It shrinks the default blast radius from "every Vulkan process on the machine" to "processes the Agent launched"; it does not authorise.

🔴 Declining vkNegotiateLoaderLayerInterfaceVersion CRASHES the host

The single most valuable thing this test found, and it was in code written the same afternoon. The obvious-looking gate — "if this process is not in the enable-list, return VK_ERROR_INITIALIZATION_FAILED from negotiation so the loader skips us" — does not make loader 1.4.357 skip the layer. It access-violates the application. Reproduced every time, with and without VK_LOADER_DEBUG:

Enable-list state (variable set) vulkaninfo exit
file absent 0xC0000005
file present, this process not listed 0xC0000005
file present, this process listed ok

So that design would have crashed every Vulkan application on the machine outside our enable-list — a far larger blast radius than the one §S2 exists to reduce, and inflicted on applications that have nothing to do with FrameLedger.

The rule that follows: the layer always accepts negotiation and always forwards. The enable-list decides what we intercept, never whether we load. Being present and inert is cheap; being absent by erroring out is not something this loader supports.

Two false positives in the test itself, both corrected

Recorded because each would have reported a working gate as broken, and both are the same shape as defects found elsewhere in this project:

  1. Discovery is not loading. With the variable unset the loader still prints Located json file "...\FrameLedger.VkLayer\VkLayer_..._overlay.json". A match on FrameLedger.VkLayer.dll hit that path — the manifest sits in a directory of that name.
  2. Availability is not loading. vulkaninfo's own report lists the layer by name, read from the manifest. That is the tool describing the system, not the loader mapping anything.

The unambiguous signal is the loader printing Insert instance layer / Inserted device layer with our name and DLL path.

✅ VK_ADD_IMPLICIT_LAYER_PATH is honoured, and it needs no registry (2026-09-06, P1 item 3)

Measured against the same loader 1.4.357 with vulkaninfo --summary and VK_LOADER_DEBUG=layer: with VK_ADD_IMPLICIT_LAYER_PATH pointed at the build tree's FrameLedger.VkLayer directory and FRAMELEDGER_ENABLE_VK_LAYER=1, the loader prints Insert instance layer "VK_LAYER_FRAMELEDGER_overlay" (…\FrameLedger.VkLayer.dll) and Inserted device layer … — the unambiguous signal above — with nothing under HKCU or HKLM, and vulkaninfo exits 0 with the layer inert (no enable-list entry for it). The first run's grep … | head cut the log before the Insert lines and read as "found, not inserted"; the lines are at the instance-creation point, ~850 lines in. So the operator host launches Vulkan titles with no registration at all, and the real-loader ctest (fl_vklayer_real) does the same: the harness's --vulkan mode presented 241 frames in 4 s on a hidden 240-wide window and the layer recorded every one.

✅ On NVIDIA a Vulkan swapchain presents through DXGI — and the DXGI hook sees it (2026-09-06)

Found by the first end-to-end run of launch on the harness's --vulkan mode: the guard's poll saw dxgi.dll + d3d12.dll (the fixture imports d3d11/dxgi; but the NVIDIA Vulkan ICD nvoglv64 maps them too) and injected the Overlay, whose Present hook then recorded 295 DXGI presents in 5 s with apiMask = D3D12 and DXGI's counter agreeing (248 samples, 0 unseen) — the Vulkan swapchain's own presents, made by the driver on an internal DXGI flip-model chain. So on this driver the injected Overlay can measure a Vulkan title's presents; that is a driver property, not a portable one (AMD's and Intel's WSI need not do it), which is why the layer stays the capture side. Two consequences landed: the launch-mode guard now classifies any process that mapped vulkan-1.dll as the layer's, and the harness's --vulkan mode maps the loader before anything else so the fixture looks like a real Vulkan title to the first poll.

✅ The in-layer blocklist scan — §S2's second half

The layer scans its own process at init and goes fully passthrough on any hit, using the same matcher and the same rules file as the injection guard. Verified by fl-probe-vklayer (ctest fl_vklayer_selfscan), both directions:

[PASS] a clean process is NOT forced inert (so the blocked case below can mean something)
[PASS] the planted module is loaded into this process
[PASS] the self-scan now says STAY INERT - a blocklisted module was found
       after unload the scan says: may observe

The planted module is our own DLL copied under a blocklisted name (14_TESTING §Integration tests: "a renamed harmless DLL, not real anti-cheat software"). Proven red by making the matcher stop matching.

Two things worth keeping:

  • Both directions are asserted. A self-scan that always answered "stay inert" would pass a one-sided test while silently disabling the layer everywhere — and would look exactly like a working gate.
  • The probe installs the seed rules when none exist, then removes them. Without that it skipped on any machine that had not run the product, and a ctest that always skips is a gate that cannot fail. Installing them is the only option: there is deliberately no way to point the layer at a different rules file (§S3).

Not yet done

  • Passthrough under a real Vulkan game, alongside the six implicit layers already resident on this machine (§Environment). vulkaninfo proves load/no-load; it does not prove a real title still renders correctly with us in the chain.

3 · Hook viability on hook-harness only

Already settled — the shared-memory layout. ✅ fl_shm.h compiles under MSVC 19.51 with /W4 /WX, every static_assert holds, and fl-layout-dump output is byte-identical between MSVC and gcc across all four structs and 39 field offsets. All four regions are exactly 64 bytes with no implicit padding, and the mapping is 512 KiB + 192 B of header at the default capacity. This is what the corrected 07_IPC layout was worth checking twice: the earlier design put FlControlBlock at an offset that overlapped the header.

✅ H1 · /guard:cf with MinHook trampolines — SAFE (2026-08-02)

Probe: src/native/tools/fl-probe-hookprofile, built with the exact Overlay flag set and run as ctest fl_hook_profile. MinHook v1.3.4, commit c3fcafdc. Result: the indirect call from a /guard:cf module into MinHook's runtime-allocated trampoline succeeds; original=44 hooked=144, and the unhook path restores the original behaviour.

A green probe is only worth what its setup proves, so the setup was verified separately rather than assumed — if CFG had not actually been enforcing, the call would have succeeded for reasons that say nothing about H1:

Evidence Value
PE DLL characteristics Control Flow Guard present
Guard CF function table 84 entries
Guard Flags 0x10014500
Guarded indirect call sites in .text 114
GetProcessMitigationPolicy EnableControlFlowGuard = 1

Why it works: Windows marks memory allocated VirtualAlloc(PAGE_EXECUTE_*) as a valid call target in the process CFG bitmap by default, so a trampoline is callable without any SetProcessValidCallTargets dance.

⚠ Measured with CFG strict mode OFF (the probe reports it explicitly). A host process that enables strict mode does not auto-validate dynamic code and could still __fastfail. That is rare, and it is not catchable by FL_HOOK_GUARD — see §H8. Treat it as a residual risk to watch for on real titles, not as a solved problem.

✅ H3 · -D_HAS_EXCEPTIONS=0 with <atomic> — SAFE, with a sharp edge

Compiles and runs under MSVC 19.51 with the full Overlay flag set, real fl_shm.h included. std::atomic_ref is lock-free at both 32- and 64-bit widths — the part that actually matters, since a non-lock-free atomic would take a mutex and violate CLAUDE.md rule 5 in the present hook.

The sharp edge is what the define does, which is not "remove failure paths":

yvals.h:     #define _THROW(...) (__VA_ARGS__)._Raise()
             #define _RAISE(x)   _MSVC_STL_DOOM_FUNCTION(...)
__msvc_doom_core.hpp:  #define _MSVC_STL_DOOM_FUNCTION(mesg) __fastfail(5)

So a would-be exception becomes __fastfail — an immediate, uncatchable kill of the host game. In an injected DLL that is arguably worse than an exception, and SEH cannot intercept it (§H8 again).

It is safe here only because the hot path does not use throwing STL at all: <atomic>, <cstdint> and <type_traits> contain zero throw-sites. That makes the existing "no STL containers that allocate in hook paths" rule load-bearing rather than stylistic — and arguably it is now a feature, since violating it fails loudly in testing instead of propagating quietly.

◐ H2 · Hook installation under the loader lock — safe path verified

The deferred pattern holds: 20 MinHook enable/disable cycles (each suspending every other thread to patch) while a worker thread ran 4,510 LoadLibrary/FreeLibrary cycles. No deadlock, thread joined cleanly.

Be precise about what this does not show. It does not prove the naive inline install deadlocks. A probe that deadlocks cannot report its own result, and hanging CI to demonstrate a hazard we have already decided to avoid buys nothing. So: the safe path is verified; the case against installing from inside the LoadLibrary hook rests on the documented mechanism — suspending a thread that holds the loader lock — and remains an argument, not a measurement. H2 stays open in 20_OPEN_QUESTIONS for that reason.

✅ H4 · Vtable indices — all three proved, and CI can prove them too

hook-harness --probe-vtable, ctest fl_vtable_indices.

A vtable slot carries no identity, so "check that slot 8 is Present" is not a question the runtime can answer — which is why the old "verified at runtime against the dummy object" wording was unimplementable. What is answerable is behaviour: patch the slot, call the method, see whether the detour ran.

Slot Claim Result
8 IDXGISwapChain::Present ✅ detour ran on Present()
13 IDXGISwapChain::ResizeBuffers ✅ detour ran on ResizeBuffers()
22 IDXGISwapChain1::Present1 ✅ detour ran on Present1()

Also confirmed: IDXGISwapChain and IDXGISwapChain1 return the same vtable pointer — one concrete object with the table extended past the base interface — so slot 22 is reachable from either interface pointer. And slot 8 resolves inside a mapped image, with dxgi.dll loaded at the expected base.

The CI half of §H4 is answered too. The worry was that a hosted runner has no GPU, no DXGI output and no interactive window station, so index probing would be dev-machine-only and the test would have to be skipped. Two choices remove that: WARP (software rasteriser, no adapter needed) and CreateSwapChainForComposition (no HWND at all). Feature level 0xB000 obtained headless. These run as ordinary ctests.

◐ H5 · Proxy swapchains — less dangerous than assumed, not yet cleared

hook-harness --probe-proxy, ctest fl_proxy_swapchain. The harness builds a real forwarding IDXGISwapChain wrapper — what sl.interposer and ReShade hand the application — and presents through it while our hook sits on the real vtable.

real vtable  00007FFE3C87C688
proxy vtable 00007FF701716F20   (different, as expected — we never patched it)
proxy saw 1 present;  hook on the REAL vtable saw 1

The hook still fires. The proxy forwards with real_->Present(...), an ordinary virtual dispatch through the real vtable, so patching the real vtable catches it one layer down. The naive fear — "a proxy has its own vtable, so we miss the present entirely" — does not hold for a forwarding wrapper.

Why this is not yet a clearance for §H5:

  1. A forwarding proxy is the easy case. DLSS-G does not merely forward; it presents interpolated frames the application never submitted. Whether those reach a real-vtable hook at all is the question that matters for the FG counting in 03_METRICS, and this harness cannot answer it.
  2. We see the post-proxy call. Parameters the proxy rewrote are what we observe, not what the game passed.
  3. A proxy that owns a different swapchain — rather than wrapping ours — would still be invisible.

So: layering does not inherently break the strategy, which is genuinely good news for the vtable approach. A real Streamline/DLSS-G title is still required before §H5 closes.

🔴 Guard · The documented driver scan is blind unelevated — fail-open found

Measured 2026-08-02, Windows 11 26300, standard user (the default Agent configuration under ADR-9). Independently reproduced twice.

API Result unelevated
EnumDeviceDrivers (what 19_SAFETY specified) ok=True, 258 drivers, 0 usable base addresses, 1 recoverable name (ntoskrnl.exe)
NtQuerySystemInformation(SystemModuleInformation) STATUS_SUCCESS, 258 modules, 258 distinct full paths, real driver names legible

The first one succeeds while telling you nothing. A guard built on it would report "no anti-cheat driver present" on a machine running Riot Vanguard. That is a fail-open in the hard gate, in the default configuration — the single most serious defect found in this project so far, and it was in a shipped doc.

19_SAFETY §Pre-injection checks now specifies the Nt* route. Caveats that must not be lost: the API is documented-as-unsupported, and RTL_PROCESS_MODULE_INFORMATION's layout is version-sensitive — my own quick probe mis-computed the path offset by two bytes (INDOWS\system32\...), which is exactly the class of error that must fail closed rather than silently match nothing. Assert the struct offsets; treat any parse failure as refuse.

✅ H7 · Unhook does not clobber a later hooker — closed

hook-harness --probe-unhook, ctest fl_unhook_preserves_foreign. The foreign hooker is simulated rather than depending on RTSS being installed, so the test is deterministic and runs on CI instead of only on this machine.

[PASS] the foreign hook chained through ours (it saved our detour as its original)
[PASS] our unhook DECLINED to restore, because the slot is no longer ours
[PASS] the foreign hook is still installed - we did not silently remove it
[PASS] the foreign hook still fires after our unhook
[PASS] with the slot untouched, our unhook DOES restore
[PASS] the slot holds the pristine entry again

The mechanism is the interesting part: a later hooker saves our detour as its original and chains through it, so an unconditional restore does not "clean up after ourselves" — it deletes their hook, silently, and their overlay stops working with no error anywhere. 17_HOOK_ENGINE's "cleaner uninstall" claim was backwards and is corrected.

Both halves are asserted deliberately. A compare-and-restore that never restores would pass a one-sided test and leave our detour permanently in every process.

✅ Per-present cost — 8.4 ns, against a 1,000 ns budget

hook-harness --probe-cost. 20,000 presents × 5 runs, hooked and unhooked runs interleaved so scheduler or thermal drift during the run is not attributed to the hook, medians compared.

ns / present
unhooked 317.9
hooked 326.3
delta 8.4 (budget 1,000 — NFR-1, 14_TESTING §Hook overhead item 1)

Read this narrowly. The detour is an atomic increment plus a call through the saved pointer, i.e. the floor for any vtable hook — it bounds the mechanism, not the product. The Overlay's real per-present cost is 14_TESTING item 2, measured on a real game, and that number is not this one.

Not registered as a ctest: a timing threshold on a shared CI runner fails for reasons that have nothing to do with the code. Run it deliberately.

✅ The Overlay is a real capture side now — and what it does NOT measure (2026-08-05)

Recorded here retrospectively: PRs #40–#44 changed 8 files, all under src/native/, and touched no documentation, so none of the below was written down at the time.

Hooks installed three, on the shared dxgi.dll class vtable: Present (8), ResizeBuffers (13), Present1 (22)
Acquisition throwaway WARP D3D11 device + CreateSwapChainForComposition, vtable read, dummy released — no HWND, runs headless
Ring Local\FrameLedger.Ring.<pid>, DACL = current user's SID only, ERROR_ALREADY_EXISTS refuses
ctests 15, incl. four [inject][shm] cases that inject the real Overlay into hook-harness cross-process

The api field, and a Windows API that does not do what the docs imply. IDXGISwapChain::GetDevice on a D3D12 swapchain returns the device, not the command queue — even though CreateSwapChainForComposition is given the queue. DXGI resolves the queue to its owning device before storing it. The obvious implementation (query the result for ID3D12CommandQueue) made every record from a real D3D12 target come back FL_API_UNKNOWN. Both queries are kept: a DXGI that did hand back the queue would otherwise regress to UNKNOWN silently.

What the Overlay measures today is 8 of 23 record fields, and the other 15 are reported as not measured rather than defaulted:

Written Left at "not measured"
qpc, frameIndex, presentFlags, syncInterval, api, swapchainId, outputW/H renderW/H, upscaler, upscalerQuality, fgMode, fgEvaluations, rtFlags, dispatchRaysVolume, maxTraceRecursionDepth, psoCreatedThisFrame, vramUsedBytes, reflexLatencyUs, hdr

measuredMask = FL_MEASURED_OUTPUT_RES and rtFlags = FL_RT_NOT_MEASURED on every record. Without those two bytes a present-only writer would assert "no upscaler, no frame generation, no ray tracing" as measured fact ~118 times a second — fg_factor 1.0 (rule 6) and a definite RT No (rule 7) about a title nobody looked at.

Two fields have a producer and no consumer, and one has neither: FlWriterState::vramBudgetMb is never written (no QueryVideoMemoryInfo hook); FlControlBlock::overlayEnabled is never read; and FlControlBlock::pauseRequested is never written by anything, while its only reader is unreachable on any frame where guardTicks changed.

Half of that last clause was fixed five lines below it, in the same PR, and this sentence was left in the present tense. The reader is no longer unreachable — #46 moved the deadline onto the watchdog thread, which removed the early return that jumped the pause check. What is still true is the first half: nothing writes pauseRequested. ShmRingReader.SetPaused is the intended writer and it has no caller and no test at all — three symbol sites in the whole tree, none of them a test — so the round trip has never been driven end to end even though both halves exist and the harness that would drive it is already staged.

Two gaps found the same day by tracing call paths, and one is still open.

  • ✅ Both runtime stops were unreachable in a non-presenting process, and pauseRequested was unreachable on any frame where guardTicks changed — one root cause, MayObserve() having exactly one caller. Measured in both directions: unhookRequested against a live --hold target left status at READY through 10 s of polling, and a paused session leaked 12 records across 12 guard ticks, exactly one per tick (writeIndex 9 → 21). Closed by the watchdog thread (§S25).
  • 🔴 The three-fault self-disable still has no test at all. NoteFault discarded MH_DisableHook's return and set no g_observing; that is fixed, without a regression net. The blocker is the vehicle — a fault seam compiled into a DLL that ships into games is rejected on sight, and the VirtualProtectEx alternative cannot locate the target's view base. Both approaches and their failure modes are written into src/native/tests/CMakeLists.txt.
  • The 65-second value in its real configuration is also unverified: the stop is proven to fire, but a suite that runs on every build cannot wait 65 s, so what is tested is the mechanism, not the number.

Still open in §3

Both remaining items need something this harness cannot synthesise:

  • §H2 — the deferred LoadLibrary install pattern is verified against heavy loader contention, but the case against the naive inline install still rests on the mechanism, not a measurement. Exercising it needs a real game that loads D3D12 lazily.
  • §H5 — a forwarding proxy does not defeat a real-vtable hook. DLSS-G presenting interpolated frames the application never submitted is the case that matters for FG counting, and it needs a real Streamline title.

Everything else in §3 is answered: H1, H3, H4, H7 and the per-present cost.

4 · Vendor symbol reality check

Resolve the actual exported names; 17_HOOK_ENGINE records conventions, not verified facts. A wrong name degrades silently to unknown, which reads as "working, no upscaler detected" — the highest false-confidence risk in the spike. Record the SDK version each name came from.

✅ Answered 2026-08-05 — docs/vendor-exports.json

Measured across 34 distinct modules in 162 files from installed titles by tools/vendor-exports.ps1 (dumpbin over files on disk; nothing is loaded). The map is committed rather than transcribed here, because a table copied by hand is a second source that drifts from the first.

The finding this item existed to produce — the NGX parameter surface splits into two hook classes, and only one half is an exported function:

Module Parameter accessors Parameter-object factories
sl.common.dll (Streamline) yes, all 16 yes
nvngx.dll / driver-store _nvngx.dll no yes (D3D11/12/VK/CUDA)
nvngx_dlss.dll, _dlssg, _dlssd no no

Streamline-shimmed titles (9 of those installed here) expose NVSDK_NGX_Parameter_SetI/SetUI as ordinary exports. NGX-direct titles do not: the accessors are function pointers inside the object the factories return, so there is no symbol to hook. 17_HOOK_ENGINE §The NGX parameter surface carries the decision and its CLAUDE.md rule-4 justification.

Not gated. Nothing cross-checks 17_HOOK_ENGINE's symbol table against the JSON, so they can drift — that gate belongs with the PR that adds the feature hooks, where a failing row would mean something. The map is also one machine on one driver version, and the JSON says so in its own $comment.

5 · Proxy swapchains (§H5)

✅ The shared-vtable premise, proven both directions — ctest fl_vtable_identity_control

fl-probe-interposer (2026-08-05). Two composition swapchains created by independent routes through the real dxgi.dll report one vtable (0x…842BC688, stable across runs), and a different interface reports a different one. The second half is what makes the first readable: a comparison that has never been shown to detect a difference carries no information when it reports "same".

This is the property 17_HOOK_ENGINE §swapchainId and the whole vtable-hook design rest on, and it is now a ctest rather than a one-off measurement — if it ever stops holding, the build fails instead of a game discovering it.

◐ The interposer question is NOT answered, and the first run of the probe answered it wrongly

Measured against Cyberpunk 2077 (sl.interposer.dll 2.7.1) and Black Myth: Wukong (2.7.4), loaded into our own process — no game running, no injection, no guard.

The interposer loads standalone and exports CreateDXGIFactory2 its address differs from dxgi.dll's, so we are genuinely on its code path
Swapchain vtable through the interposer identical to the real one
Factory vtable through the interposer also identical
sl.* plugins mapped afterwards none — only sl.interposer.dll itself

That last row is why the first three mean nothing, and the probe was changed to say so. As first written it printed "VERDICT: THE SAME — a vtable-slot present hook DOES catch presents made through the Streamline interposer" for both titles. It was a confident wrong answer. Streamline forwards straight to dxgi.dll until slInit() has run and a feature is loaded, so what was measured is that passthrough is passthrough. The tell was in the output the whole time: a genuinely interposing Streamline cannot leave the factory vtable unwrapped, because wrapping the factory is how it reaches the swapchain.

The probe now enumerates its own loaded modules and refuses to render a verdict when no plugin is mapped, exiting 2 = inconclusive. Same discipline as the guard's tri-state collectors: "could not look" must not read as "looked and it was clean".

What answering it actually needs, stated rather than left to be rediscovered: slInit(), whose sl::Preferences argument is vendor ABI — i.e. the licence question legal/THIRD_PARTY_NOTICES.md settles for Intel IGCL ("re-declaring the API by hand is explicitly NOT an approved workaround") and which is unanswered for NVIDIA. So §H5 case 3 is blocked on a licence decision, not on hardware, which is a different and more tractable blocker than "needs a real DLSS-G session". The alternative route is unchanged: observe a real title once the Overlay has a present hook.

What is bounded now: the risk is confined to titles that go through the Streamline interposer. NGX-direct titles call nvngx*.dll and never wrap the swapchain, so the vtable premise is not in question for them.

6 · RT detection

✅ The pre-flight, before a single hook was written — 2026-08-20

hook-harness --probe-d3d12-vtable (ctest fl_d3d12_vtable_indices) and --probe-dxr (ctest fl_dxr_probe), on this machine: Windows 11 Insider 29648, RTX 5080, MSVC 14.51.

Adapters, and all three can ray-trace.

Adapter D3D12 RaytracingTier
NVIDIA GeForce RTX 5080 yes 12 (TIER_1_1)
Microsoft Basic Render Driver yes 12
WARP (software) yes 12

So HANDOFF item 4's "check first whether WARP on the CI runners supports DXR" is answered yes on this machine's WARP, which means a DXR fixture is not condemned to a GPU box. CI still has to answer for its own d3d10warp.dll; the tier is a property of that binary, and fl_dxr_probe prints it on every run.

Slot indices, proved by behaviour on BOTH list types. Slot 72 is BuildRaytracingAccelerationStructure and slot 76 is DispatchRays: patched, called by name through the interface, detour ran, slots restored and the restore asserted. 60 consecutive runs of each probe, zero failures.

🔴 Reset() moves DispatchRays into the vendor driver, and the first version of the hook never fired

THE FIRST THREE ANSWERS WERE MEASURED ON THE WRONG OBJECT, and two of them were wrong because of it. The probe originally read the vtable off a freshly created command list and compared vtable ARRAYS. A game's list is Reset every frame, and the Overlay patches the FUNCTION a slot points at rather than the slot — so both choices measured something no hook depends on. Corrected here rather than quietly re-run: the wrong answers are the useful part.

Question measured on a reset list, comparing functions
two DIRECT lists, one device same functions — one inline patch covers every list. Their vtable ARRAYS differ (per-object after Reset), which is why a slot patch would have to be repeated and a function patch does not
a command allocator (the control) different, as it must be
DIRECT vs COMPUTE same functions — slot 72 D3D12Core.dll in both, slot 76 nvwgf2umx.dll in both. One detour per method covers both list types
a WARP list vs a hardware list DIFFERENT — slot 76 is nvwgf2umx.dll on the RTX 5080 and D3D12Core.dll on WARP
a fresh list vs a reset list DIFFERENT — slot 76 moves from D3D12Core.dll to nvwgf2umx.dll; slot 72 stays in D3D12Core.dll

The failure this produced, before the fix. The Overlay read its targets off an unreset throwaway list, so it hooked D3D12Core.dll's DispatchRays — a function no title on this GPU ever calls, because the first Reset hands the method to the driver. The hook installed, published FL_HOOK_RT_DISPATCH, and never fired. The injected fixture caught it exactly: withAsBuild = 60, withDispatch = 0, hooks = RT_DISPATCH | RT_AS_BUILD — a mask bit with nothing behind it, which is the honesty failure the whole entitlement machinery exists to prevent.

Why one hook worked and the other did not, which is what made it hard to read. BuildRaytracingAccelerationStructure stays in D3D12Core.dll across the swap, so the AS-build hook fired from the first run. A pair where one half works reads as a bug in the other half's detour, not in the acquisition both share.

The fix is one call: put the throwaway list through the same lifecycle a game's list goes through — Close(), Reset() — before reading its vtable. --probe-dxr Q5 now prints the module on each side of the Reset, so a runtime that stops swapping, or starts swapping the other slot, says so rather than being discovered by a silent zero on a real title.

And Q4 stops being permissive. With the correction, a WARP list and a hardware list resolve DispatchRays to different functions, so a throwaway-device acquisition would silently miss every call on an NVIDIA GPU. The Overlay takes its targets off a list created on the game's own device — which was already the design, for the unrelated reason that this machine lost WARP's D3D12 path to an Insider build for a fortnight (§Traps), and now has a second reason that is about correctness rather than availability.

Bundles are not a further case, and this is a documented API constraint rather than something measured here: D3D12_COMMAND_LIST_TYPE_BUNDLE does not permit DispatchRays. Stated as an inherited claim so the next reader knows which of these lines came from a run.

✅ Both hooks, proved by injection — 2026-08-20

ctest fl_guard, the case "the injected Overlay records ray-tracing work, and an AS-build-only title is not a negative". Two harness modes that differ by one recorded call, sharing their acceleration structure, state object, swapchain and loop, so any difference in the record is attributable to that call:

Mode records FL_MEASURED_RT AsBuildObserved DispatchObserved dispatchRaysVolume
--hold-presenting-dxr 60 every one 60 ≥ 8 exact multiple of 64×32×1
--hold-presenting-rayquery 60 every one 60 0 0

The rayquery arm is what makes 03_METRICS:226 falsifiable instead of a sentence: a writer with only the DispatchRays hook sees nothing there, and its silence is indistinguishable from a real negative — rtTier is 12, the mask bit is set, evidence is zero, and the No branch fires about a title that ray-traces every frame. It does not run a RayQuery shader, and does not need to: the claim under test is "AS-build catches a title DispatchRays misses", and the absence of a dispatch is what tests it.

DispatchRays also needs a bound raytracing state object to be RECORDED at all: measured 2026-08-20, it access-violates inside D3D12Core with no state object set, with a well-formed shader table and with a zeroed one alike. That is why the fixture carries a 1.2 KB DXIL raygen library (dxr_raygen.hlsl, compiled by hand and checked in with its command line).

✅ Both hooks against four real titles' own settings menus — 2026-08-20

§8 carries the five captures in full. What belongs here is the RT half:

  • Yes twice, No twice, every verdict agreeing with the game's own menu. Cyberpunk with path tracing on and Wukong at RT High both read Yes; Rune Factory, whose menu has no ray-tracing option, and Cyberpunk with every RT option switched off both read No — the branch that had never been reachable in this project.
  • rt_frame_pct reads 25.0% at ×4 on two titles, which is the falsifier 03_METRICS §RT/PT/RR pre-committed. It did not fire.
  • faults = 0 on every run, with both detours on the render thread of titles running at up to ~950 presents/second.
  • The dispatch extent is exact. Alan Wake 2: 4,913,280 rays per RT-active present, and 3 × 1706 × 960 is 4,913,280 — three rays per render pixel, against a render resolution the menu states outright.

Still open in §6

  • The same measurements on an AMD or Intel GPU. Every vendor-specific result above is one driver's: nvwgf2umx.dll takes DispatchRays and leaves BuildRaytracingAccelerationStructure alone, and nothing says another UMD splits them the same way — or leaves either in D3D12Core:
  • Recorded-vs-executed semantics and counter concurrency (§H6):

7 · First real injection (requires the guard, §1)

✅ Done — 2026-08-03

  • Title: Lies of P (Steam, Unreal, x64, single-player, no anti-cheat). Injected into LOP-Win64-Shipping.exe, the presenting process — LOP.exe at the install root is a shim and was left alone.
  • /MT DLL loaded without incident: yes. FlGuardEvaluate → Allow; FlGuardedInject → Allow; FrameLedger.Overlay.dll present in the target on re-enumeration (143 → 144 modules), mapped at 0x7FFA60340000, 820 KB. Afterwards: alive, responding, 103.6 s of CPU over 6 s wall-clock across 180 threads — still rendering, not stalled.
  • It also shut down cleanly with the Overlay still mapped. WM_CLOSE, and both LOP-Win64-Shipping.exe and the LOP.exe shim exited on their own; no hang, no crash dialog, no orphan. Worth stating because process exit runs DllMain(DLL_PROCESS_DETACH) on a loader-locked thread, which is the one lifecycle path a /MT static-CRT DLL is most likely to fail on, and it is not exercised by hook-harness — the harness is killed, not closed. Nothing is hooked yet, so this clears the loader, not the unhook path; P1's fault policy and unhook still need the same check once Present is hooked.
  • Reached through the shipped C ABI (FrameLedger.Guard.dll), so there was no path that skipped the gate. There is no injector CLI and there will not be — §S9 closed that as a design decision, not as a gap.

The three refusals that came first are the valuable part. Every one was a real defect, and none would have surfaced without a real machine and a real title:

Attempt Verdict What it actually was
Deadly Heart Gambit, no rules installed RulesUnreadable Correct. A machine that has never run the product refuses by default.
Same, rules installed BlockedService EasyAntiCheat_EOS Defect. A Stopped/Manual service installed by an unrelated EOS game made the guard refuse every process on the machine, explorer.exe included. Fixed: present now means running.
Same, from the launching shell SuspiciousUnsigned FrameLedger.Guard.dll Defect, open. Our own DLL trips our own guard name fragment. See below.
Same, from a non-ancestor process Allow → injection refused Correct, and now legible: Deadly Heart Gambit is x86, and the Overlay is x64-only. This fills 14_TESTING's manual-matrix row for a 32-bit title.

✅ Closed — the guard refused itself in launch mode (fixed 2026-08-04)

Isolated cleanly on the same title, same machine, same rules:

Evaluating process Verdict
An ancestor of the game, with FrameLedger.Guard.dll loaded SuspiciousUnsigned
Not an ancestor Allow

§S16 walks the game's ancestors up to the first platform launcher. The name FrameLedger.Guard.dll contains guard, which is one of the heuristic's nameFragments, and the signer half is not wired — so an unchecked signature is untrusted by definition and the pair refuses.

In launch mode the Agent is the parent (04_CAPTURE §Launch mode) and hosts that DLL, so every launch-mode injection would refuse. Attach mode is unaffected, which is why the run above succeeded. Not fixed here; recorded as its own item.

Note the project also ships unsigned (CLAUDE.md rule 9 and the pinned-stack Packaging row — not 12_BUILD, which this line used to cite and which contains no signing text at all), so wiring the signer check would not rescue our own binaries. Whatever the fix is, it cannot be "sign it".

✅ Fixed and re-measured on three real titles — 2026-08-04

The arrangement was reproduced end to end rather than argued: a stand-in for the Agent, built into FrameLedger.Agent's own output directory beside a real FrameLedger.Guard.dll, loads that DLL and then launches the game. So our binary is the game's ancestor and carries the module whose name trips the guard's own guard fragment — the 2026-08-03 shape, with a real title on the other end.

Evaluate only. FlGuardedInject was never called; nothing was injected into any game.

Title Store / engine Pre-fix (bb0da0a) Post-fix
Deadly Heart Gambit Steam / Unity, x86 SuspiciousUnsigned — FrameLedger.Guard.dll Allow
Lies of P Steam / Unreal, x64 SuspiciousUnsigned — FrameLedger.Guard.dll Allow
Alan Wake 2 Epic / Northlight SuspiciousUnsigned — FrameLedger.Guard.dll Allow

Two things about the harness that are worth keeping, because both produced a confident wrong answer first:

  • The evaluator must not be in the target's ancestor chain. The first attempt used Start-Process, so the evaluating process — which had P/Invoked into the guard and therefore carried FrameLedger.Guard.dll itself — was the game's grandparent. Post-fix still refused, and it looked like the fix did not work. It did; the refusal was about the evaluator, whose image is in C:\Program Files\PowerShell, correctly not ours. The script now walks the chain and asserts the evaluator is absent from it before reporting.
  • Launching the stand-in through WMI put WmiPrvSE.exe in the scan set, which an unelevated guard cannot open — a correct ProcessUnreadable about something irrelevant. Orphaning it via cmd /c start terminates the ancestor walk at the stand-in instead.

An earlier iteration also stopped at PreScanFailed because the target was cmd.exe and check 4 then tried to list System32. That is check 4 answering correctly about the wrong directory — noted because it is the shape of a green that means nothing.

Decided 2026-08-03 — identity by install root. A four-lens panel, three refuters and a completeness critic. All three refuters broke the panel's first answer. What survived: suppress the fuzzy fragment tier for any scan-set process whose image resolves inside our own install directory, never for the target, ancestor walk left intact. GetCurrentProcessId() was rejected because the defect is a property of the binary and FrameLedger.App carries it too; the platform-launcher-style boundary was rejected because everything above the Agent is an undefined category, so truncating there is "could not look" recorded as clean. Full reasoning and the rejected options in §S18.

The panel also measured that this is worth more than it looked. §S18 is the sole blocker of the entire Vulkan Tier-1 path: the layer is gated by FRAMELEDGER_ENABLE_VK_LAYER=1, which only the launching process can set, and §S1 does not apply there because the Vulkan path performs no injection at all.

◐ The same tier matches benign system DLLs — measured twice, and the second time changed the conclusion

First measurement (2026-08-03), unelevated, Windows 11 26300: 331 processes, 0 access-denied, 4 modules matching the protect fragment, none anti-cheat. Recorded as "a game that loads mskeyprotect.dll is refused today, in the mode that ships", and used to justify wiring the signer half next.

Re-measured 2026-08-04 on the same machine, and neither half of that survived: 290 processes, 0 inaccessible, 3 hits.

Process Module Signature type O= Suppressed by a file-choice signer check?
WidgetService mskeyprotect.dll Catalog Microsoft Corporation No — no embedded signature to read
ProtonVPN.Client System.Security.Cryptography.ProtectedData.dll Authenticode Microsoft Corporation Yes
Malwarebytes Malwarebytes.Protection.Interop.dll Authenticode Malwarebytes Inc No — publisher absent from trustedSigners

Two findings, both of which change what gets built:

  • The proposed fix addresses one case of three. The signer table in §1 above was taken with Get-AuthenticodeSignature, which consults the CatRoot catalogs — so it reports O= for files that carry no embedded signature at all. mskeyprotect.dll, kernel32.dll and nvapi64.dll are all SignatureType=Catalog. A native WinVerifyTrust with WTD_CHOICE_FILE, which is what "wire IsTrustedSigner" means in every prior note, recovers nothing for them; IsTrustedSigner(nullptr) is false by contract and the refusal survives. Catalog verification needs CryptCATAdminAcquireContext2 / CalcHashFromFileHandle / EnumCatalogFromHash + WTD_CHOICE_CATALOG. A measurement taken with a convenient tool does not license a design built on a different one.
  • "Refused today, in attach mode" is not supported. All three hits are desktop processes — a widget host, a VPN client, an AV service. None can enter a game's scan set: EnumerateScanSetImpl stops the ancestor walk at the first IsPlatformLauncher match, and that list includes explorer.exe, services.exe and svchost.exe. Three real titles (§8) were scanned with no fragment hit at all.

The defensible claim: the protect fragment matches a benign, widely-loaded Microsoft system DLL, and has not been shown to match inside any game's scan set. A game process loading DPAPI/CNG for save encryption or a launcher token would trip it — plausible, unmeasured, and worth fixing; not a live incident.

🔴 MEASURED IN A REAL SCAN SET BY CI, 2026-08-05 — and this file is where that belongs

The sentence above is superseded. CI, running the drain integration test:

the guard refused our own harness: SuspiciousUnsigned unknown
System.Security.Cryptography.ProtectedData.dll

The mechanism is the one the paragraph above ruled out. §S16 puts the target's ancestors in the scan set; the integration test spawns hook-harness, so the .NET test host is its parent — which is the launch-mode arrangement, where the Agent is the game's parent. A .NET host that loads that assembly poisons its own scan set and the injection it is attempting is refused. A gate that cannot pass.

Attach mode is unaffected: a normally-launched game's ancestor chain terminates at a platform launcher one hop above it, so no .NET host of ours is in the set.

It passed on the dev box, because the two hosts load different module sets — the second time in one PR that this machine was not the configuration that mattered, the first being the rules file. This entry is recorded here rather than only in 20_OPEN_QUESTIONS because §Purpose of this file makes measurements this file's job, and #51 changed only that other document.

Live consequence: the drain tests are Category=Integration and CI runs ./build.ps1 check -SkipIntegration, so the only end-to-end proof of the capture path does not run on the machine that gates merges.

§S19(b) is therefore deferred with a written rationale rather than scheduled next. Before any design is fixed, fl-probe-signer should answer three things on this machine, in the shape fl-probe-guard established: whether WinVerifyTrust(WTD_CHOICE_FILE) recovers O= from a catalog-signed system binary; what one full Evaluate() costs with catalog verification across a real scan set, against the 30 s re-scan; and whether WTD_REVOKE_NONE + WTD_CACHE_ONLY_URL_RETRIEVAL emits network traffic — the default WTD_REVOKE_WHOLECHAIN performs CRL/OCSP fetches, which breaks NFR-10 offline-first as well as CLAUDE.md rule 8, from inside the hard gate.

THE PROBE NOW EXISTS AND HAS ANSWERED ALL THREE, 2026-08-27 — see the §S19(b) subsection in §1 above. This paragraph is kept because the QUESTIONS it fixes are what the probe was built to, and because a reader arriving here needs to know the shape was decided before the answers existed. Two of the three came back the way it predicted; the third — whether the offline flags avoid network I/O — came back with cryptnet.dll LOADED, which is neither a pass nor a failure and is why the discriminating run is the owner's.

Also measured: gameguard could never fire. The match is a case-insensitive substring and guard is a substring of gameguard, so the shorter token always won first. A shipped rule incapable of firing independently, inside the safety gate.

Closed 2026-08-05 by removing it, and the reason it was safe to remove is not the reason that applies to the fragment below. These two findings sat in one paragraph and the paragraph's conclusion — "neither is fixed by deleting a fragment" — was true of one and false of the other.

  • protect: deleting it IS a detection removal. This tier is the only coverage for families the seed admits it has no data for (Ricochet, VAC), and three refuters rejected deletion. Unchanged, still open as §S19(b).
  • gameguard: deleting it removes zero coverage, by construction. That is what subsumption means — every module name gameguard could match, guard matches too, and matches first. Measured separately: nProtect GameGuard also has its own named module family in the same file (GameGuard, npgg, GameMon, exact-prefix), so the fragment was redundant twice over rather than once.

rules-validate now fails when any fragment contains another, so the list cannot regrow a rule that cannot fire. Note that removing it does trip rules-publish's removal check — correctly. That gate exists to make a blocklist removal reviewable, and this is one.

The guard against a RUNNING title, 2026-08-15

The precondition every verification run below depends on, and it had never been measured against a live process. Everything earlier in this file evaluated the guard in launch-mode arrangement — our binary as the game's ancestor, evaluate-only, nothing injected — or scanned files on disk. Neither answers the question the capture path actually asks: does the guard allow this title while it is playing?

Alan Wake 2, pid 40424, running, FlGuardEvaluate → Allow. Reason 0, empty family, empty signal. Rules resolved from C:\Users\Anon\AppData\Local\FrameLedger\rules\detection-rules.json, 24 reason codes.

Evaluate only. Nothing was injected, and no consent record exists for this title — FlGuardEvaluate is the read-only half of the ABI and takes no injection rights.

Why it needed doing at all: the installed-corpus scan (§Environment) is a file scan, and the guard scans loaded modules of the live process plus the target's ancestors (§S16). A title clean on disk can still load an anti-cheat module at runtime, and Alan Wake 2 is launched by the Epic client, which is in the scan set. Had this refused, every per-title row in §8 would have been undischargeable and the upscaler/FG/RT work would have had no oracle to verify against.

One title, one moment. This is not a statement about Cyberpunk 2077, about Alan Wake 2 on another machine, or about the same machine after a launcher update. It is the one measurement that was missing before the feature hooks had anywhere to prove themselves.

8 · The accuracy question — why this rewrite exists

≥ 3 real offline titles. Verify against each game's own settings menu.

Title Upscaler Quality Render → output FG active RT Matches menu?
Cyberpunk 2077 (2026-08-15) ❌ Unknown ⬜ 0xFF ✅ 1485×835 → 2560×1440 ⬜ not measured ⬜ not measured 1 of 5
Cyberpunk 2077 (2026-08-15, later, after §S30) ✅ Dlss ⬜ 0xFF ✅ 1485×835 → 2560×1440 ◐ on, factor not measurable on this route ⬜ not measured 2 of 5
Cyberpunk 2077 (2026-08-20, PT on · RR on · MFG ×4 · Balanced) ✅ Dlss ⬜ 0xFF ✅ 1485×835 → 2560×1440 ◐ on, presents/batch = 4.00 as a PROXY ✅ Yes 3 of 5
Alan Wake 2 (2026-08-20, RR on · PT ultra · FG 4X set but reportedly not applying) ✅ Dlss ⬜ 0xFF ⬜ no local tag; 1706×960 corroborated arithmetically, see below ❓ presents/batch = 1.00 — unexplained ✅ Yes 2 of 5
Black Myth: Wukong (2026-08-20, RT High · FG ×4 · Balanced) ⬜ Unknown — coverage short, not the title's ⬜ ⬜ no local tag ◐ presents / RT-active = 4.0000 as a PROXY ✅ Yes 2 of 5
Rune Factory: Guardians of Azuma (2026-08-20, no RT option · FG ×6 via NVIDIA App · DLAA) ⬜ Unknown ⬜ ⬜ no local tag ⬜ nothing observed ✅ No 1 of 5
Cyberpunk 2077 (2026-08-20, all RT off · RR off · MFG ×4 · Balanced) ✅ Dlss ⬜ 0xFF ✅ 1485×835 → 2560×1440 ◐ presents/batch = 4.00 as a PROXY ✅ No 3 of 5
Cyberpunk 2077 (2026-09-04, RR on · MFG ×4 · Balanced) ✅ Dlss ⬜ 0xFF (title never chains sl::DLSSOptions) ✅ 1485×835 → 2560×1440 ✅ ×3.99 MEASURED — presents / tokens, §S31 row P1, tokens/batch 1.00 ✅ Yes 4 of 5
Cyberpunk 2077 (2026-09-04, MFG ×3) ✅ Dlss ⬜ 0xFF ✅ ✅ ×2.99 measured ✅ 4 of 5
Cyberpunk 2077 (2026-09-04, MFG off, RR on) ✅ Dlss ⬜ 0xFF ✅ ✅ none by counting — 1.00, 4,922 tokens against 4,922 presents ✅ 4 of 5
Hell Is Us (2026-09-04, DLSS · FG ×4) ❌ N/A — SL loaded, slEvaluateFeature never called (NGX-direct SR) ⬜ ⬜ ✅ ×4.00 measured, identity Active (technology not identified) ✅ No 2 of 5 — the FG factor is right on a title whose upscaler is invisible to this writer

✅ FIVE CAPTURES ACROSS FOUR TITLES — 2026-08-20, and the RT tri-state is complete

Every run: 40 s, one identified swapchain, one segment, 0 gaps, 0 dropped, foreground on all 369 drain ticks, status=Ready, layoutVersion=3, rtTier=12, apiMask=0x4 (D3D12), and faults=0 — including a title that pushed 37,823 presents through the hook in 39 seconds (~950/s) without a drop. All six hook families installed on every title. The Overlay payload was hash-verified against the just-built DLL before each run.

Run records batches Streamline ids seen asBuild / dispatch rt_frame_pct Displayed FPS
Cyberpunk, PT on 10,603 2,578 DLSS_RR 2578 2,561 / 2,567 24.2% (25.0% of the claiming window) 264.93
Alan Wake 2 900 875 DLSS_RR 875 869 / 871 96.8% 22.5
Wukong 5,956 0 none at all 1,437 / 1,441 24.2% (25.0%) 148.89
Rune Factory 37,823 0 none at all 0 / 0 0.0% 946.44
Cyberpunk, all RT off 17,456 4,242 kFeatureDLSS 4242 0 / 0 0.0% 436.28

1 · The tri-state is complete, and No is correct twice for two different reasons. Yes on Cyberpunk (path tracing) and Wukong (RT High); No on Rune Factory, whose settings menu has no ray-tracing option at all, and on Cyberpunk with every RT option switched off — a title that can ray-trace and is not doing so, which is the harder and more valuable case. Both negatives satisfy all three conjuncts 03_METRICS requires: rtTier 12, RtAsBuild installed, and zero evidence across 36,575 and 16,871 claiming records.

2 · slEvaluateFeature IS NOT A GENERAL ROUTE, and this generalises HANDOFF item 3 from one title to four. Two of the four titles never call it at all — Wukong with both sl.interposer.dll and sl.dlss_g.dll loaded and DLSS-G demonstrably running, and Rune Factory likewise. The other two call it only for Ray Reconstruction. kFeatureDLSS_G is zero on every run, so item 3's counter has nothing to count on any of them.

3 · §S30's closure survived a test in the REVERSE direction, which it never had. It concluded that Ray Reconstruction replaces the super-resolution pass rather than running beside it, from one configuration. Turn RR off on the same title, same machine, one setting changed: the census flips from DLSS_RR 2578 / DLSS 0 to DLSS 4242 / DLSS_RR 0. This is also the first observation of kFeatureDLSS anywhere in this project, and the local-tag extent arrives on that evaluation exactly as it did on the RR one — the same 1485×835.

4 · A SECOND FG proxy, and it covers what the first cannot. On Wukong there are no Streamline batches, so presents/batch is unreadable — and presents ÷ RT-active presents reads 5,764 / 1,441 = 4.0000 exactly against a title configured for ×4. It carries the same unverified premise as presents/batch (that the work is recorded once per application frame), so it is a proxy and not a producer. What it adds is coverage: the two are readable on disjoint sets of titles, and on the one run where both were available they agreed.

5 · The #87 falsifier did not fire, on two independent titles. It pre-committed that rt_frame_pct must read ≈25% at ×4 and not ≈100%. Cyberpunk: 25.0%. Wukong: 25.0% — and Wukong reached it through the RT evidence alone, with no Streamline batches involved.

6 · Alan Wake 2 is the outlier and is NOT explained. presents/batch = 1.00 and rt_frame_pct = 96.8%, i.e. every present carried an application frame's work, against a menu set to FG 4X. Two readings fit every number equally: generated presents not reaching the vtable we patch (§H5 case 3), or frame generation simply not running. The operator reported that this title would not apply its settings, which is evidence for the second and is why it is not written up as §H5 case 3. The discriminating run — the same scene with FG off — was not taken.

7 · One arithmetic result worth keeping on its own. Alan Wake 2's dispatch volume is 4,279,466,880 / 871 = 4,913,280 rays per RT-active present, and 3 × 1706 × 960 = 4,913,280 exactly — three rays per pixel of the render resolution the game's own menu states. The params hook reported nothing on that title, so the render resolution was confirmed by a completely different route from the one meant to measure it.

8 · FL_MEASURED_UPSCALER_PARAMS produced nothing on three of the four titles. Only Cyberpunk tags scaling inputs locally. §2b's local-tag route is narrower than that entry assumed, and the honest failure mode held: the writer published nothing rather than something wrong.

The first row, and it is one row. Read the legend before the marks: ✅ measured and correct against the title's own settings; ❌ measured and wrong; ⬜ honestly absent — no producer, or the title does not expose it on the route we take.

Conditions: Cyberpunk 2077 in combat, 40 s bounded capture, 10,169 presents, 0 gaps, 0 dropped, 254.82 displayed FPS, apiMask = D3D12, hooks Present | UpscalerIdentity | UpscalerParams. Consent granted by the operator; the guard evaluated Allow. A second run minutes earlier gave 11,108 presents with the same shape.

Render → output is the one that lands, and it lands exactly. UserSettings.json records DLSS = Balanced at 2560x1440; Balanced is 0.58, so 2560 × 0.58 = 1484.8 and 1440 × 0.58 = 835.2. The writer said 1485×835. This is the first of exit criterion 1's five values measured correctly from a real game.

The second row, and §S30's answer: Ray Reconstruction was doing the upscaling

Three further 40 s captures, same title, same settings (DLSS = Balanced, DLSS_D = True, DLSS_MultiFrameGeneration = x4, ReflexMode = Enabled, 2560×1440), with the id census the previous row's defect motivated. Conditions: 10,092–10,443 presents, 0 gaps, 0 dropped, ~260 displayed FPS, apiMask = D3D12, rtTier = 12 (TIER_1_2), hooks Present | UpscalerIdentity | UpscalerParams | FgEvaluations.

The census, and it is the whole of §S30: of 2,523 batches, kFeatureDLSS_RR = 2,523, kFeatureDLSS = 0, kFeatureNIS = 0, kFeatureDLSS_G = 0, undecoded = 0. With Ray Reconstruction on, the title evaluates RR instead of super-resolution, not beside it. The decode had no arm for that and reported UNKNOWN. What settles it rather than suggesting it: renderW/H are published only on a frame that drained an evaluation, and they are 1485×835 — so the scaling-input tag arrives ON the RR evaluation. The evaluation that upscales is the one the decode was already looking at.

presents/batch = 4.000 on three independent runs (10,176/2,544 · 10,276/2,569 · 10,092/2,523), against the title's own x4. Two things follow, and the second is the one that changes the plan:

  • DLSS-G's GENERATED presents reach the vtable we patch. A factor of exactly 4 cannot be produced by a writer that only sees application frames. §H5's fear — fg_factor structurally 1.0 on every Streamline title — does not hold for the present path.
  • slEvaluateFeature(kFeatureDLSS_G) is never called. Zero, in ~7,600 batches across three runs, while frame generation is demonstrably active. On Streamline 2.x DLSS-G is driven through the interposer's swapchain proxy, not through the feature-evaluation entry point — so HANDOFF item 3's premise is wrong for this route, and the counter built for it is correct and has nothing to count. presents/batch is a working proxy only because RR happens to be evaluated once per application frame.

Still unmeasured, and it is one setting away: the same capture with multi-frame generation OFF. If presents/batch falls to ~1 the 4.000 is proven to be FG rather than a property of how this title evaluates RR, and §H5 closes on two points instead of one. Until then the ×4 reading has one configuration behind it.

Quality 0xFF is a measurement of the TITLE, not a gap in the code. Cyberpunk sets its preset out of band through slDLSSSetOptions and never chains sl::DLSSOptions into slEvaluateFeature's inputs. The only route that would reach it is the one docs/HANDOFF.md §2b refuses on five grounds. So the DLSSOptions half of the inputs walk has a ZERO hit rate on this title — the unknown §2b flagged as its largest, now measured once. 0xFF is the defined "a hook ran and could not tell", and it is true.

Upscaler Unknown is WRONG, and is filed as §S30 rather than reported as a result. Cyberpunk is running DLSS. Every one of the 2,461 params-carrying presents decoded to UNKNOWN. Honest — it is never NONE — and not the answer the exit criterion asks for.

One number fell out that this run was not designed to take. The params bit appeared on 2,461 of 10,169 presents (24.2%), i.e. 10,169 / 2,461 = 4.13; the earlier run gave 11,108 / 2,696 = 4.12 independently. UserSettings.json says DLSS_MultiFrameGeneration = x4. That is fg_factor matching its oracle to two significant figures before the frame-generation producer exists — strong support for counting evaluations directly (the 2026-08-14 owner ruling) rather than deriving generated frames from a multiplier. It is not a measurement of fgEvaluations: it uses the params bit as a proxy for "an SL feature evaluated during this present", and item 3's producer must reproduce it directly before the number may be published.

Two operational facts, learned by hitting them. The lazy feature-hook install costs the opening ~1.15 s of every session — 292 of 10,169 records lack the Upscaler bit, and 288 of 11,108 in the other run, both matching the 1 Hz watchdog. And a game launch yields ONE capture: when the host detaches, the Overlay stops receiving guard ticks and self-unhooks at the 65 s deadline exactly as 19_SAFETY specifies, so the next attach correctly reports SupervisionLost rather than a live session. The Overlay does not re-arm.

✅ The baseline exists — fl-baseline-probe (2026-08-03)

§M9's problem is closed. 15_ROADMAP required comparing against "the old file/module-based detection", which does not exist in this repository, so item 4 had no left-hand side and ADR-7's founding claim was unfalsifiable. The baseline is now a real tool rather than a memory of one.

  • Baseline used instead: src/native/tools/fl-baseline-probe, reading the capabilities group of rules/detection-rules.json (rulesVersion 2026.08.1, 7 capabilities: DLSS, DLSS-G, Ray Reconstruction, Streamline, FSR, XeSS, XeSS-FG). It answers two questions per capability — is it on disk beside the game, and is it loaded right now.
  • It reuses the guard's module enumerator (SystemSources().EnumerateModules, LIST_MODULES_ALL, §1) rather than carrying a second walk, so the baseline and the product see the same module list — including the same fail-closed behaviour. An INCOMPLETE or FAILED scan is printed as such and must never be read as "no capability loaded".
  • It reads the capability data in its own translation unit. The guard's jsmn parser deliberately reads only the anticheat subtree, and teaching it a group the hard gate does not need would spend the gate's parse budget (§S17) on inference data.
  • Proven both directions, ctest fl_baseline_probe: a clean process reports nothing loaded, a planted module is detected, and the answer flips back after unload rather than latching. The planted module is our own FrameLedger.Guard.dll copied under a capability name (14_TESTING §Integration tests) — no NVIDIA, AMD or Intel binary is shipped, downloaded or executed, and none needs to be installed for the test to mean something.
  • Proven red twice: a probe that never reports loaded, and findings that latch across scans.

🔴 The comparison item 4 asks for cannot be a percentage

Stated before any README wording is drafted, because the roadmap's phrasing ("quantify the improvement") invites a number that would have to be invented.

Item 4 asks the baseline about upscaler identity, quality preset, render vs output resolution, and DLSS-G activity. The baseline can answer none of them:

Item 4 asks Baseline answers Hooks answer
upscaler identity ships / loads DLSS — a different statement (05_DETECTION:10) measured
quality preset nothing measured
render vs output resolution nothing measured
DLSS-G active ships / loads DLSS-G measured
engine · platform · version detected not measured by hooks at all

A loaded nvngx_dlss.dll means the title can use DLSS this run. It does not say whether DLSS is on, at what preset, or at what render resolution — and a title that ships the DLL and has it disabled in the menu is indistinguishable from one using it.

So the honest form of ADR-7's claim is "the baseline cannot answer four of these five questions at all", not "N% more accurate". That is both stronger and checkable. Owner decision, recorded here rather than assumed.

  • Quantified improvement (belongs in the README): not a percentage — see above. Fill the per-title table once an offline title is chosen.

✅ The static half, measured on three real titles (2026-08-03)

First run of the detector against real installs. It failed on three of four cases, and the failures were the point — both were real defects that only a real layout could expose.

Title Store / engine On disk (scanned by hand) Detector, after the fixes
Deadly Heart Gambit Steam / Unity UnityPlayer.dll, steam_api.dll unity 2022.3.32.13119501, steam
Lies of P Steam / Unreal nvngx_dlss.dll, amd_fidelityfx_dx12.dll, steam_api64.dll unreal, steam, dlss + fsr
Alan Wake 2 Epic / (Northlight) EOSSDK-Win64-Shipping.dll, 6 NGX/Streamline DLLs epic, dlss + dlss_g + dlss_rr + streamline

Alan Wake 2 reports no engine, correctly: Remedy's Northlight is not in the rules table, and "no rule matched" is a real answer rather than a failure. Lies of P reports no engine version because its LOP-Win64-Shipping.exe carries no ProductVersion for the regex to read — also honest.

None of the three carries anti-cheat, so all three are legitimate candidates for the first real injection (item 2).

🔴 Defect A — a depth cap that made the detector useless

GameFileProbe capped the walk at depth 4. Measured real depths: Deadly Heart Gambit 6, Alan Wake 2 5, Lies of P 9. Every real game exceeded it.

Worse than the cap was what incompleteness meant: an unfinished walk marked FileExists, SiblingGlob and DirExists all uncollected, so every file-based signal became Unknown, the engine walk stopped at its first rule, and nothing was ever identified. Failing safe is right; failing safe on every input is not working.

Fixed by separating the two questions. A file the walk listed is a file that is there, however early it stopped afterwards — only absence is in doubt. So a hit stays Match regardless, and only a miss becomes Unknown when the listing did not finish. Caps raised to depth 16 / 200,000 entries, with the entry count as the real bound.

🔴 Defect B — the pre-scan was looking in the wrong directory

This one is a hole in a hard gate, not a detection miss.

Both the probe and ImageDirectoryImpl derived "the game directory" by stripping the filename from the executable's path. Unreal puts the exe at <root>\<Project>\Binaries\Win64\ — measured on Lies of P, that directory holds seven files, none of which could ever have been an anti-cheat SDK, because EasyAntiCheat/ sits at the install root three levels up.

So for exactly the layout most likely to carry EAC, check 4 scanned a folder that could not contain what it was looking for and returned clean. It also cost Lies of P its DLSS capability, which is how the defect was noticed at all.

Fixed by ResolveInstallRoot: walk up from the executable to a hardcoded platform boundary (steamapps\common\<X>, GOG Galaxy\Games\<X>, Epic Games\<X>) and scan from there. Hardcoded for the same reason IsPlatformLauncher is — a data-driven boundary would let a rules update move where the hard gate looks.

When no boundary is recognised the executable's own directory is kept. Alan Wake 2 is installed at D:\another\epic\AlanWake2 with no store marker in the path; walking up blindly would reach a folder of unrelated games, and refusing a title because a sibling ships anti-cheat is a false refusal with no appeal. That residual is stated rather than hidden: a nested executable outside a recognised store layout is still scanned from its own directory.

The entry point must not change the answer — and now it does not

Unreal titles conventionally ship two executables: a shim at the install root and the real shipping binary nested under <Project>\Binaries\Win64\. Lies of P has LOP.exe and LOP-Win64-Shipping.exe.

That matters because a user adds one of them to the watchlist, and the guard is handed whichever process it is handed. Before this resolution existed the two disagreed:

Entered via Before After
LOP.exe (root shim) engine undetermined, capabilities none unreal, steam, dlss + fsr
LOP-Win64-Shipping.exe unreal, steam, fsr only unreal, steam, dlss + fsr

Both now resolve to the same install root and produce identical results, which is asserted in both languages rather than left as an observation.

Still unmeasured

The runtime table above is empty on purpose. The static half is now real and has been run on three real installs; the per-title runtime rows still need a hooked session.

That is no longer item 2. Item 2 closed on 2026-08-03 — the Overlay loads into a real title and the process survives it (§7).

"Nothing is hooked yet" was true when written and is not now (corrected 2026-08-05). Present interception, the ring writer and the fault policy all landed in #40–#44, ahead of the P1 label they were filed under. What blocks the rows above is therefore no longer the present path — it is that no upscaler, FG or RT hook exists (P0 items 4, 6 and 7), and that nothing reads the ring: src/FrameLedger.Shared holds a .csproj and no .cs files, so the Overlay's output is observable only from inside guard_test.cpp. Both are prerequisites of filling this table, and neither is "finding a game".

The reader half is done, corrected later the same day. ShmLayout.cs (#47), ShmHandshakeValidator (#49), ShmRingReader (#50) and a closed write-read integration test (#51) all exist, and the Overlay's output is readable from managed code. This passage was itself written to correct an earlier stale claim and went stale within hours, in the same file — which is why the strike is left visible.

What still blocks this table is one thing plus one caveat. The one thing: no upscaler, FG or RT hook exists. The caveat: the reader has no production caller, so something must drive it against a real title — and §S27 forbids an injecting entry point on a shipped binary until a consent record exists, so that driver is its own piece of work rather than a command-line flag.

9 · Frame generation

  • Rung 1 (API / fgEvaluations) vs Tier-2 ETW FrameType: NOT RUN, and rung 1 does not produce a number to compare. Measured 2026-08-15 on Cyberpunk 2077 (SL 2.7.1): slEvaluateFeature(kFeatureDLSS_G) is never called — 0 across ~14,000 Streamline batches at four frame-generation settings — so fgEvaluations is 0 on every record and there is nothing for ETW to be compared against. The comparison 15_ROADMAP item 7 asks for is blocked on a PRODUCER, not on tooling.

  • What DID move with the setting is presents / batch, and it is a PROXY. Five 40 s captures, one title, one GPU, D3D12, Ray Reconstruction on: off → 1.000, ×2 → 2.000, ×4 → 4.000 (×4 three times independently, one identified swapchain and 0 gaps/0 dropped in every run). Application frame rate falls 85.3 → 70.9 → 63.1 as the multiplier rises, which is the direction frame-generation overhead predicts, and 70.9 × 2.06 = 146 reproduces the ×2 displayed figure. So the extra presents are real, they are visible to our present hook, and their count tracks the configured multiplier. A batch is "a present that drained a Streamline evaluation", NOT "an application frame" — the two coincide here only because Ray Reconstruction happens to be evaluated once per application frame on this title, and no independent oracle has confirmed that.

  • THE APPLICATION-FRAME PREMISE IS STILL NOT MEASURED — a draft of this bullet said it was, and was corrected before it landed, 2026-08-16. Steam's overlay read DLSS 162 | FPS 81 during a ×2 capture whose own figures imply 161.7 and 80.8. That is one agreement, not two: presents/batch was 2.0000 exactly and 162/81 is 2.0000 exactly, so both residuals are forced to −0.182%. The surviving comparison is circular (the span was derived from Displayed FPS, so presents/span restates it), and the rival reading — that the overlay's FPS field is displayed ÷ 2 rather than an application-frame count — predicts the identical number at ×2. Steam's overlay is also not an independent instrument: 17_HOOK_ENGINE §Coexistence records that it hooks D3D presentation in-process too. The discriminating run is ×4 (application frames ⇒ ≈65, fixed halving ⇒ ≈130) plus an FG-off leg where a genuine counter converges with displayed and a halving does not, comparing RATIOS — our presents/batch against the overlay's DLSS/FPS — so neither side needs a span. §S30 carries the full correction.

    GENERALISED FROM ONE TITLE TO FOUR — 2026-08-20, §8. The bullet above rests on Cyberpunk. Four titles, five captures: kFeatureDLSS_G is zero on every one, and two of the four never call slEvaluateFeature at all — Black Myth: Wukong with both sl.interposer.dll and sl.dlss_g.dll loaded and DLSS-G demonstrably running, and Rune Factory: Guardians of Azuma. So this is not "DLSS-G avoids that export"; on half the titles measured, nothing goes through it. slEvaluateFeature is a route some titles use for some features, not the Streamline entry point.

    presents / RT-active presents is a second proxy and covers the gap. Wukong has no batches at all, so presents/batch is unreadable — and 5,764 / 1,441 = 4.0000 exactly, against a title configured for ×4. Same unverified premise, disjoint coverage; on the one run where both proxies were readable they agreed. Neither is a producer, and §S31's measurement is still what decides whether either may be published.

    fl-baseline-probe was run on 2026-08-16 and is RETIRED as an FG-engagement oracle by its own pre-committed falsifier: against the running title with FG on at ×2 it reports all seven capabilities loaded, including dlss_g and xefg — two mutually exclusive frame-generation implementations — so loaded means "mapped", not "engaged", and one run settled it without needing the FG-off leg. Its real job, the static/loaded baseline for item 4, is unaffected. The game's own frame counter is the only remaining candidate and is still unrun.

  • Can PresentMon 2.x FrameType see driver-level FG / AFMF (§M1):

  • AFMF on this machine: untested — RTX 5080, AMD driver-side feature

✅ Presented FPS + the runtime census, on six real titles — 2026-09-03

The two qualifiers 03_METRICS §Rung 0's qualifier specifies were both seen on real games, and the report line that prints the census by name (runtime census:) is what made each row below readable. Operator: the owner. Instrument: FrameLedger.CaptureHost capture --seconds 60, one launch per capture, consent granted after launch. Exit codes and full reports in E:\frameledger-runs\2026-09-03\ (not in the repository).

Title API Hooks installed Census: FG group Census: upscaler group Presented FPS Qualifier printed
DARK SOULS III (2016, no anti-cheat on this install) D3D11 Present — — 59.8 cannot include — the clean (a) shape
KOISHIKARUBEKI (Unity, 2D VN, x64) D3D11 Present — — 59.6 cannot include — the clean (a) shape
Cyberpunk 2077 D3D12 Present, SL identity+params, FG evals, RT ×2 nvngx_dlssg, libxess_fg, ffx_frameinterpolation_x64, ffx_fsr3_x64, amd_fidelityfx_dx12 sl.interposer, nvngx, nvngx_dlss, nvngx_dlssd, libxess, ffx_fsr3upscaler 142.0 WARNING, names listed; presents/batch = 2 against the title's own ×2
Lies of P ×3 — FSR + AMD frame generation, FSR + AMD frame generation, DLSS (operator-confirmed; no off run) D3D12 Present, RT ×2 — no Streamline amd_fidelityfx_dx12 in every run, the DLSS one included nvngx, nvngx_dlss in every run 231.1 / 237.5 (FG on) / 59.9 (DLSS, no FG) WARNING naming amd_fidelityfx_dx12.dll — the facade regroup of the same morning is what put it there
Hell Is Us ×3 (off / FSR / DLSS + FG ×4 — the third labelled by the operator's own note) D3D12 Present, SL identity+params, FG evals, RT ×2 nvngx_dlssg, libxess_fg, amd_fidelityfx_framegeneration_dx12 in every run sl.interposer, nvngx, nvngx_dlss, nvngx_dlssd, libxess, amd_fidelityfx_upscaler_dx12 in every run 60.0 / 60.0 / 300.4 WARNING, names listed, all three runs
Flower in Us (NW.js / RPG Maker, not Ren'Py) — — — — — TargetAmbiguous, exit 6 — no capture

What it settles.

  • Both shapes are reachable on real titles, and the census names are the loader's, not the directory's: Hell Is Us ships sl.dlss_g.dll on disk and the loader reported nvngx_dlssg.dll; Cyberpunk's row is five FG runtimes for one title.
  • The census is a STARTUP property on UE5, and it cannot see settings. Hell Is Us reported the identical word 0x2794D at off, FSR and DLSS + FG ×4; Lies of P the identical 0x41801 across its three. The plugins load at init whatever the menu says. So (b) "module loaded, upscaling off" and (c) "module loaded, driven through an unhooked path" print the same WARNING — exactly what 03_METRICS says the census may and may not do, now measured.
  • The facade regroup was load-bearing. Lies of P ships amd_fidelityfx_dx12.dll alone and the operator reports Steam's counter counting generated frames on its FSR run. With the facade in the upscaler group the report would have printed "cannot include in-process generated frames" on a title generating them.
  • A THIRD title where nothing goes through slEvaluateFeature. Hell Is Us with DLSS on and frame generation at ×4: records carrying Upscaler = 17,920 / 18,033, 0 batches drained, kFeatureDLSS = 0, upscaler: N/A. UE5's DLSS plugin drives super-resolution through NGX directly and its Streamline plugin drives DLSS-G somewhere this hook does not see. spike-notes §8's "two of the four" is now three of five. Presented 300 FPS at ×4 reads as ~75 native, and the WARNING is the only honest line the report has for it.
  • The (a) shape is exact on a title with no vendor module at all: DS3 and the Unity VN publish runtimeCensus == 0x1, precisely the FL_CENSUS_RAN equality fl_guard asserts on the harness.

What it opens.

  • Multi-process titles refused as TargetAmbiguous — NW.js / Electron / Chromium-based games (RPG Maker MV/MZ, many VNs) run several Game.exe processes with one image path — browser, renderer, GPU — and the presenting one is the GPU process, which has no window of its own. Resolved the same day by Chromium's --type=gpu-process flag read through a kernel query (20_OPEN_QUESTIONS §Scope). What the next Flower in Us run measures is whether the Overlay loads inside Chromium's GPU process at all: NW.js runs without the Chromium sandbox by default, so the expectation is yes, and the expectation is not a result.

  • Hell Is Us at FSR reported 60 FPS presented with the operator's Steam counter not counting, identical to its off run. Whether FSR frame generation was engaged at all in that run is unknown; the census cannot say and the report does not claim to.

  • Second run, same evening, after #103 / #104 merged — the frame-token producer landed on §S31 row P4 and the NW.js shape had no GPU process. Cyberpunk 2077 off / ×2 / ×4 (legs identified by their own presents/batch = 1.00 / 2.00 / 3.99): presents/tokens read 0.22 / 0.64 / 1.31 and tokens/batch 4.63 / 3.10 / 3.05; Hell Is Us DLSS + FG ×4 read 1.29 (17,788 presents, 13,783 tokens). The title asks for a token three to four-and- a-half times per application frame and gets a distinct object each time, so a count keyed on pointer change read the request rate. No factor was published on any leg — the ≥ 1.5 gate is what the table was written for. The detour now keys on the frame index; the run is owed again. Flower in Us through the merged resolver: still TargetAmbiguous, and the tree says why — browser, crashpad-handler, utility ×3, renderer, no --type=gpu-process; NW.js keeps the GPU in the browser process. Rule added for the untyped-browser shape.

  • Run 3, 2026-09-04 morning, on #105's monotone count — row P1, and §S31's question answered. Cyberpunk 2077 off (RR on) / off (RR off) / ×3 / ×4: presents/tokens 1.00 / 1.00 / 2.99 / 3.99, tokens/batch 1.00 on every leg with batches; Hell Is Us DLSS + FG ×4: 4.00 (17,942 presents, 4,485 tokens, zero batches). The report printed the trio on the three FG legs — 61.37 → 183.49 (×2.99), 58.74 → 234.09 (×3.99), 76.54 → 306.17 (×4) — and refused the two off legs at 1.00 exactly as the pre-P1 gate was written to; that refusal is lifted in the PR that records this. Two independent per-frame counts agreeing to the frame is the oracle four instruments could not be. Flower in Us through #105's browser rule: resolved, injected, captured — target: 6 processes share the image (browser=1, crashpad-handler=1, renderer=1, utility=3); pid 32652 is the untyped browser process; 3,587 records over three swapchains (Chromium presents its UI and content separately; the dominant stream carried 3,435), Presented FPS 59.76, census 0x1, the clean (a) shape. So the Overlay loads inside NW.js's browser process, which was the one thing the rule could not promise. Lies of P, FSR + FG: WARNING as before, no tokens (no Streamline), 239 presented.

  • Lies of P's FSR3 frame-generation presents REACH the hook — the §H5 fear does not occur for the FidelityFX 3.1 facade either. The two FSR + FG runs presented 231 and 237 FPS with Steam's counter counting generated frames; the DLSS run, with AMD frame generation off, presented 59.9. So the facade's proxy swapchain forwards to the real Present on the shared dxgi.dll vtable, exactly as --probe-proxy predicted for a forwarding proxy — and the presented figure on those runs is therefore the DISPLAYED rate, which is what the WARNING says to read it as. What the run does not give is the native rate: nothing in this writer counts FSR3 interpolations (H11), so fg_factor stays N/A there. The 59.9 on the DLSS run is a cap or vsync, not a measurement of anything this run was about.

  • 2026-09-04, the AMD identity PR (HANDOFF 7c), measured before the code was written. Both Steam libraries scanned to full depth for the AMD module topology, because the hook's scoping depends on which module the game calls:

    Title AMD modules shipped Shape
    Lies of P, Cyberpunk 2077, Rune Factory: Guardians of Azuma amd_fidelityfx_dx12.dll 1.0.1.41314 SDK 1.1.x monolith — a leaf
    Black Myth: Wukong the monolith and amd_fidelityfx_loader_dx12.dll 2.1.0 and amd_fidelityfx_denoiser_dx12.dll mixed
    Dying Light: The Beast, Kingdom Come: Deliverance II amd_fidelityfx_loader_dx12.dll 1.0.2 + amd_fidelityfx_upscaler_dx12.dll 4.0.2 (+ …framegeneration_dx12.dll 3.1.5 on DL:TB) SDK 2.x loader + leaves
    Expedition 33 upscaler 4.0.2 + frame generation 3.1.5, no loader UE5: the plugin's built-in loader calls the leaves directly
    Hell Is Us upscaler 4.0.3 + frame generation 4.0.0 under Plugins/FSR/Source/fidelityfx-sdk/Kits/FidelityFX/signedbin/, no loader UE5, SDK 2.1.x
    Red Dead Redemption 2 ffx_fsr2_api_x64.dll + _dx12_ + _vk_ FSR 2, dynamic
    Cyberpunk 2077 (also) ffx_fsr3_x64.dll, ffx_backend_dx12_x64.dll, ffx_frameinterpolation_x64.dll, ffx_fsr3upscaler_x64.dll, ffx_opticalflow_x64.dll FSR 3.0 host DLLs, named exports — the deferred route hooked 2026-09-05 at the host facade (ffxFsr3ContextDispatchUpscale, tag fsr3-v3.0.4: the module's twelve exports match that tag, not v1.1.4)

    Every module in the ffx-api family exports the same five names and nothing else (vendor-exports.json) — which the morning read as "the loader can only reach a leaf through the leaf's own export, so the rows are the leaves and never the loader". The evening's run reversed that (below): on the three loader-shipping titles the leaves' exports stayed silent while FSR ran, so the loader is the game's entry and is now a row. No statically linked FSR title is installed — shipping is not loading: Rune Factory ships the monolith and never loads it.

  • 2026-09-04 evening, thirteen captures across nine titles under the leaf-only build (#110), one launch each — the full table with the settings the owner set is in 20_OPEN_QUESTIONS §H11. In one line each: Lies of P Fsr3 / FsrFg / 118.98 → 238.02 (×2) / counts agree 1.00, and none by count with FG off; Hell Is Us FSR (3.1 or 4 …) / FsrFg / ×2 / 1.00, and none with FG off; Expedition 33 FSR upscale under DLSS FG ×3 → ×2.97, technology not identified, count from UPSCALE dispatches (no PREPARE, no token); Cyberpunk at FSR 3: the FSR 3.0 host DLLs upscale (upscaler: N/A on that build; the host row landed 2026-09-05, §H11 B1 owed) while the 1.1.x monolith generates (FsrFg, 4261 batches, ×2); Dying Light: The Beast (FSR + FSR FG), KCD2 (FSR) and Wukong (FSR): zero dispatches at any leaf export, upscaler: N/A — the loader-row reversal; Rune Factory (FSR FG): no AMD module in the census, 59.99 → 119.95 (×2) from Streamline tokens, technology not identified — 7b's statically linked title, with the count surviving and the identity not. Row R6, same night, on #111: DL:TB FSR + FSR FG → FSR (3.1 or 4 …) / FsrFg / 70.49 → 140.9 (×2) / 1.01 and KCD2 FSR → identity + none / 1.00, both through the loader row at 1×; Wukong FSR (×2 runs) → silent at monolith and loader with the monolith loaded, and the title has no FSR frame-generation option — FSR upscaling compiled in (Rune Factory's shape), the monolith shipped and loaded for nothing this hook sees.

  • 2026-09-04, late: Dying Light: The Beast at DLSS, three captures (23:31 / 23:39 / 23:43), for 7a after Alan Wake 2 would not run. The first Streamline title measured whose batches carry kFeatureDLSS: upscaler: Dlss on 4720/4783, 4271/4345 and 4575/4657 records, FPS 80.41 / 72.73 / 77.69, every batch identified, RT measured on ~98% of presents. UpscalerParams 0 of N on all three, render -> output: N/A, quality byte never published. Cause, measured with dumpbin: DL:TB ships sl.interposer.dll 2.8.0, which exports slSetTagForFrame (Cyberpunk's 2.7.1 does not); sl.h marks slSetTag deprecated in its favour, and a 2.8 title tagging per frame never calls the export the only params row hooked. The oracle had hidden it: vendor-exports.ps1 recorded the FIRST sl.interposer.dll found (2.7.4.0), so the 2.8 export was absent from docs/vendor-exports.json until the tool unioned across copies (ten copies, eight distinct versions from 1.5.6 to 2.10.3). All three runs read frame generation: none with presents = tokens = batches; which of the three had DLSS Frame Generation on is the owner's to say — if any did, none there is the §H5 false negative on a title where the FG runtime (sl.dlss_g.dll) is in the census, and it is a finding about DLSS-G on SL 2.8, not about the tag row. Row added; rerun owed.

  • 2026-09-05 00:19, DL:TB at DLSS again, on the #115 build (the payload is the CaptureHost bin's FrameLedger.Overlay.dll, rebuilt 00:17): Dlss 4331/4401, FPS 73.64, and UpscalerParams still 0 of 4401 with the params family live — which, under publish-when-whole, means BOTH tag rows were patched. So the title either tags the scaling input with a zero extent ("use the entire resource") or tags it nowhere we hook. The zero-extent reading is the one the record can still act on: sl::Resource carries its own width/height (mandatory only on Vulkan, so filled or not on D3D12 at the title's choice), and TagSize in fl_sl_inputs.h now reads them when the extent is zero — on every route, local and both global — GUID-checked, from the argument the hooked API received. If the next run prints a render -> output line, that was the shape; if not, the title does not state the size on this route at all and the honest line stays N/A.

  • 2026-09-05 00:53, DL:TB at DLSS on the #116 build (payload rebuilt 00:51): N/A stands. Dlss 3460/3523, FPS 58.87, UpscalerParams 0 of 3523, both tag rows live, the whole-resource fallback in. So on this title the scaling-input tag reaches neither global export with a size in either place, or does not reach them at all — the record cannot separate those two, and that is the one thing left to instrument if 7a is ever reopened on this title (a tag-route census: calls seen per export, zero-extent seen, Resource-size seen — a record bit or a writer-state word, so a layout bump). 7a on DL:TB closes as measured N/A for the quality byte and the render size; the derived label has no input here and stays the owner's decision for the titles that do print the line (Cyberpunk). frame generation: none again with presents = tokens = 3441 and DLSS FG on — the fifth such run, §H5.

  • And the owner's answer to the FG question: all four DLSS runs had DLSS Frame Generation ON. presents = tokens on every one, against ×2 with FSR FG on the same title and ×3.99 on Cyberpunk (SL 2.7.1, DLSS-G 310.8) — recorded in 20_OPEN_QUESTIONS §H5 as case 3's candidate, with the discriminator (the owner's counter reading) pre-committed there.

  • 2026-09-05, the owner's run on #118 + #119 — eleven captures, seven titles, every one with DLSS or frame generation on, the first with the module: lines (interposer versions read off the files: DL:TB 2.8.0, Cyberpunk 2.7.1, Hell Is Us 2.7.3, Expedition 33 2.7.30, Wukong 2.7.4; _nvngx.dll 32.0.16.1664 from the driver store on every NVIDIA title):

    Title / setting What printed Reading
    Cyberpunk 2077, FSR 3 + FSR FG upscaler: Fsr3 (host route, 4332 records at 1506×847), FsrFg, 74.31 → 148.56 (×2), frames/upscale-drained 1.01 §H11 B1 accepted
    Cyberpunk 2077, FSR 3, FG off Fsr3, none by count 4919/4919, 1506x847 -> 2560x1440 = 1.7x (59%) B1-off accepted
    Cyberpunk 2077, DLSS + RR + MFG ×3 Dlss (via RR, 3704 batches), 62.86 → 187.49 (×2.98), Active (technology not identified), render 1707x960 on 3677 records count right, DLSS-G unnamed (kFeatureDLSS_G never evaluated)
    Dying Light: The Beast, DLSS FG ×4 (twice) Presented FPS 76.7 / 93.24, none WITHHELD with the §H5 qualifier, sl.interposer.dll 2.8.0.0 named owner's counter ~300 = 3.9× ours — reading (a) with its number
    Hell Is Us, DLSS + FG ×4 (twice) 82.23 → 328.98 (×4), Active (technology not identified), upscaler: N/A; the first run refused the factor (bucket 2.25 vs 3.65 — 53 unfocused ticks) NGX-direct SR, Streamline tokens still count
    Expedition 33, DLSS + FG (twice) 54.9 → 218.38 (×3.98), Active (technology not identified), upscaler: N/A same shape
    Black Myth: Wukong, DLSS + FG ×4 55.39 → 221.53 (×4), Active (technology not identified), upscaler: N/A, sl.dlss_g.dll 2.7.4.0 loaded same shape; the plugin bit is set on a 2.7 title, and the gate correctly did not fire (factor active)
    Lies of P, DLSS, no FG (owner) Presented FPS 59.77, WARNING naming amd_fidelityfx_dx12.dll, upscaler: N/A, tokens=0 NGX-direct SR with no Streamline at all: nothing this build hooks fires

    Two things the run found beyond the rows. A consumer defect: render -> output: N/A on every FG-on capture — Cyberpunk at FSR 3 + FG printed it two lines under render 1506x847 on 4332 record(s) — because UpscaleExtent keyed its window on the params bit, which under frame generation rides on one present in N; fixed the same day (identity-bit window). And the shape of what is left: on every NVIDIA title measured the count is right and the identity is what this build cannot say — DLSS on four NGX-direct titles, DLSS-G on all of them — because the NGX SDK is licence-blocked and kFeatureDLSS_G is never evaluated through the export the Streamline hook owns. 20_OPEN_QUESTIONS §H5 carries the one candidate that is not a hook (NvAPI_NGX_GetNGXOverrideState, by PID) and the probe that measures it before anything is built on it.

  • 2026-09-05 evening, the owner's run on #121 (the tag route) — eight captures, six titles, every one at DLSS with frame generation on, the first with the Streamline tag census: line. The pre-commitment in 20_OPEN_QUESTIONS §H5 landed on every title that goes through Streamline:

    Title / setting frame generation: Trio Tag census (route: types)
    Hell Is Us, DLSS + FG ×4 (twice) DlssG 38.5 → 154.04 (×4), 81.41 → 325.58 (×4) global: depth, mvec, hudless, ui-color-alpha, backbuffer, other
    Expedition 33, DLSS + FG ×2 DlssG 75.95 → 149.83 (×1.97) global: same set
    Black Myth: Wukong, DLSS + FG ×4 DlssG 47.99 → 191.89 (×4) global: depth, mvec, hudless, ui-color-alpha, backbuffer
    Rune Factory, DLSS + FG ×4 DlssG 128.85 → 513.02 (×3.98) global: same as Hell Is Us
    Cyberpunk 2077, DLSS + RR + MFG DlssG, upscaler: Dlss, 1707x960 -> 2560x1440 = 1.5x (67%) factor refused — bucket 1 of 8 reads 3.0 against 1.67 overall; tokens/batch 2.97 global: depth, mvec, hudless, scaling-in, scaling-out, other (no UI tag)
    Dying Light: The Beast, DLSS FG ×4 N/A (none withheld, §H5) + "it is FEEDING frame generation" Presented FPS 67.13 frame (slSetTagForFrame): depth, mvec, hudless, scaling-in, scaling-out, ui-color-alpha, other

    Three readings. The identity is measured on six of six Streamline titles — the UE Streamline plugin tags the DLSS-G inputs globally (slSetTag) on every UE title, Cyberpunk on 2.7.1 tags globally too, DL:TB on 2.8 tags through slSetTagForFrame — so Active (technology not identified) is gone from every one of them, and upscaler: N/A on the UE titles is now the ONLY NVIDIA gap (NGX-direct super-resolution, the NVAPI probe's job). DL:TB's 7a question is answered by the census, at no layout cost: the title DOES tag kBufferTypeScalingInputColor, through the 2.8 export, and UpscalerParams is still 0 of 4030 — so the tag carries neither an extent nor a Resource size, which is exactly the shape #116 named and could not see; the N/A there is the title's truth. Cyberpunk's refusal is the guard working: tokens/batch 2.97 with presents/batch 4.97 and bucket 1 at 3.0 is a session whose state changed after the first eighth — tokens kept flowing while Ray Reconstruction stopped being evaluated, which is what a menu or a pause does — and the report refused the session-level number rather than averaging two configurations (the 2026-08-16 alt-tab lesson). The owner's settings for that run are recorded when known; the earlier 14:01 run at MFG ×3 read ×2.98 with tokens/batch 1.00 on the same title.

  • 2026-09-05 night, the owner's run on #124 (the DXGI present counter) — DL:TB twice, Hell Is Us, and a new title, the Onimusha: Way of the Sword demo on Streamline 2.10.3. 20_OPEN_QUESTIONS §H5 row P1-DXGI landed on the first title and both controls read zero:

    Title / Streamline Trio or Presented DXGI present counter: frame generation:
    Dying Light: The Beast, 2.8.0, DLSS FG ×4 (21:56) Presented FPS 69.99 (withheld) unseen=12204 over samples=4136 (2.95) N/A (withheld) + FEEDING
    Dying Light: The Beast, 2.8.0, DLSS FG ×4 (22:06) Presented FPS 73.19 (withheld) unseen=12741 over samples=4392 (2.90) same
    Hell Is Us, 2.7.3, DLSS + FG ×4 79.89 → 308.14 (×3.86) unseen=0 over samples=18207 DlssG
    Onimusha: Way of the Sword demo, 2.10.3, DLSS + FG 60.04 → 220.33 (×3.67) unseen=0 over samples=12914 DlssG, upscaler: Dlss, RT Yes (27.1 %)

    The 2.8.0 pacer presents on the hooked chain through a body the inline patches do not cover; 2.7.3 and 2.10.3 present through the body they do. The owner's "sl.interposer.dll + sl.common.dll must be loaded on ≥ 2.8" lead is closed by the 2.10.3 title: it injects, tags on the frame route (depth, mvec, hudless, scaling-in, scaling-out, ui-color-alpha, backbuffer, other) and counts like 2.7. Onimusha's render -> output: N/A with UpscalerParams 0/13014 is DL:TB's shape again — the frame-route tags carry no size on D3D12, where sl::Resource declares none. The PR after #124 turns the 2.8.0 reading into a DXGI-COUNTED Displayed (03_METRICS §Displayed may be DXGI-COUNTED).

  • 2026-09-06 morning, the owner's run on #125 — DL:TB three times (frame generation on, then off twice) and Expedition 33 with frame generation off. The promotion landed and §H5's Leg 0 answered:

    Title / setting Line DXGI present counter: frame generation:
    Dying Light: The Beast, DLSS FG ×4 (07:31) Native FPS: 70.52 -> Displayed FPS: 282.08 (x4 FG) over 16516 present(s) + Displayed is DXGI-COUNTED: 12387 unseen=12483 over samples=4202 (2.97) DlssG
    Dying Light: The Beast, DLSS, FG off (07:45) Presented FPS 75.52 (withheld) unseen=0 over samples=4519 N/A (withheld) — census still 0x25F0F, tags 0x23600 (no hudless / UI)
    Dying Light: The Beast, DLSS, FG off (07:55) Presented FPS 61.14 (withheld) unseen=0 over samples=3659 same
    Expedition 33, FG off (Streamline 2.7.30) FPS: 85.86 unseen=0 over samples=5063 none by count; tag census 0x0

    Two readings. The trio is printed on the title that could not print it, from a count DXGI made (12,387 presents this hook never timed), and it is the number the owner's own counter showed (~300 at ×4 against ~75 native). Leg 0: sl.dlss_g.dll is a startup-time load — the census cannot tell FG off from FG on, exactly the cost the gate pre-committed — but the DXGI counter can (0 unseen with FG off, 2.9–3.0 with it on), so the gate is narrowed to sessions where the counter was not read, and the two FG-off captures above print none with DXGI's agreement on the next build. Also visible: with FG off DL:TB sends no hudless / UI tag and the UE plugin sends no tags at all, so the DLSS-G identity is per-setting on both.

  • 2026-09-06, 09:20–09:35, the NVAPI probe against three running titles (fl-probe-nvapi --ngx-state <pid>, driver 616.64), each beside a capture on the #126 build. The question §H5 opened on 2026-09-05 — are the driver's per-process NGX feedback bits populated without an NVIDIA-app override? — is answered YES for super resolution and NO for frame generation:

    Title / override / capture beside it SR RR FG scalingRatio / performanceMode / renderPreset / frameGenerationCount
    Hell Is Us, no override, 83.21 → 332.82 (×4 FG) DlssG, upscaler: N/A 0x80605 CREATED EVALUATE (+ INITIALIZED DLL_EXISTS ERR_NOT_FOUND) INITIALIZED DLL_EXISTS ERR_NOT_FOUND 0x5 INITIALIZED DLL_EXISTS only 0 / 0 / 0 / 0
    Expedition 33, override ON, FG off, FPS: 79.4 none (DXGI agrees), upscaler: N/A 0x8067F CREATED EVALUATE ENABLED DLL_LOADED DLL_SELECTED PRESET PERF_MODE (+ …) INITIALIZED DLL_EXISTS ERR_NOT_FOUND 0x1F INITIALIZED ENABLED DLL_EXISTS DLL_LOADED DLL_SELECTED 0 / 2 / 11 / 0
    Lies of P, no override, Presented FPS 59.89, upscaler: N/A 0x605 CREATED EVALUATE (+ INITIALIZED DLL_EXISTS) INITIALIZED ERR_FAILED ERR_NOT_FOUND INITIALIZED ERR_FAILED ERR_NOT_FOUND 0 / 0 / 0 / 0

    The SR word carries the identity the hooks cannot see on these three titles; the FG word does not see DLSS-G running at ×4 (it tracks the override machinery's DLL, not the plugin), frameGenerationCount is the override target and not the multiplier, and scalingRatio is 0 even under the override. §H5 carries what a driver-reported rung may and may not claim, and the negative still owed (DLSS off in the menu). Also on this run: Expedition 33 with FG off now prints none with DXGI's own present counter agrees: 0 unseen over 4774 (#126), and Lies of P's Presented FPS keeps its "MAY include generated frames" qualifier because amd_fidelityfx_dx12.dll is loaded there — the census cannot say none and the token count is 0 on that title, so that line is right as printed.

  • 2026-09-06, 10:39–11:36, the owner's run on #128 (the driver-reported rung) — §H5 rows N1–N4 and one correction. The standalone probe first: Lies of P with upscaling OFF reads SR 0x5 (CREATED clear), with DLSS on 0x605 — N3 keeps the rung. Then the captures:

    Title / setting upscaler: NVIDIA driver NGX state: SR / RR / FG FG line
    Lies of P, DLSS (no override) Dlss (driver-reported: …) 0x605 / 0x90001 / 0x90001 N/A (no FG in this title)
    Expedition 33, override ON, FG off Dlss (driver-reported: …) 0x8067F (mode 2, preset 11) / 0x80005 / 0x1F none, DXGI agrees
    Hell Is Us, DLSS + FG ×4 Dlss (driver-reported: …) 0x80605 / 0x80005 / 0x605 (CHANGED between readings) 81.32 → 321.73 (×3.96), DlssG
    Onimusha demo, SL 2.10.3, DLSS + FG Dlss — the NVIDIA driver agrees 0x605 / 0x5 / 0x605 (CHANGED) 59.99 → 235.47 (×3.93), DlssG
    Dying Light: The Beast, DLSS + FG ×4 Dlss — the NVIDIA driver agrees 0x605 / 0x90001 / 0x605 (CHANGED) 39.63 → 158.5 (×4) DXGI-COUNTED, DlssG
    Cronos: The New Dawn demo (new; UE, SL 2.8.0), DLSS, FG off Dlss (driver-reported: …) 0x80605 / 0x80005 / 0x5 FPS 105.01, none, DXGI agrees; RT Yes
    Dying Light: The Beast, FSR upscaling + DLSS FG FSR (3.1 or 4 …), 2560x1440 -> 2560x1440 0x205 (CREATED, not EVALUATE) / 0x90001 / 0x605 DlssG from the tags; factor REFUSED (bucket 8 of 8 at 1.96 vs 2.85); DXGI 1.80 unseen / present

    Three readings. The rung works as written and its negative held. The FG word is not blind — the morning's Hell Is Us reading was taken before the feature came up, and every ×4 session's loop readings show CREATED | EVALUATE with the word changing mid-session; the multiplier bits never set, so it is an identity witness and is now printed beside frame generation:. SR 0x205 on the FSR session is the word telling the truth finely: DLSS was created at some point (the title initialises it) and not evaluated, and the rung's two-bit key keeps it from claiming DLSS beside FSR. The FSR + DLSS-G session also exposed a wrong qualifier ("no evaluation was observed" beside 4,415 tokens and a refused factor), fixed the same day. Cronos is a second Streamline 2.8.0 title; its FG-on capture is the one that says whether the pacer bypass measured on DL:TB belongs to SDK 2.8.0 or to that title.

  • 2026-09-06, 12:17, Cronos: The New Dawn demo with frame generation ON — the row that closed §H5's DLSS / DLSS-G question. Streamline 2.8.0, UE: Native FPS: 86.8 -> Displayed FPS: 172.72 (x1.99 FG) over 9,948 presents, unseen=0 over samples=10063, tag census frame=[depth, mvec, hudless, ui-color-alpha, backbuffer, other], frame generation: DlssG — the NVIDIA driver agrees, upscaler: Dlss (driver-reported), RT Yes. The 2.8.0 SDK presents its generated frames through the body the inline patches cover; the bypass measured on Dying Light: The Beast is that title's integration. With this row every measured NVIDIA title prints the rule-6 trio or a counted none, and the owner closed the item.

  • 2026-09-06, 12:46, Lies of P at FSR 3.1 + FSR frame generation, on the #129 build — §H11 row A1 again, now with every witness on the page. upscaler: Fsr3, render -> output: 2560x1440 -> 2560x1440 = 1x on 3,538 records, frame generation: FsrFg, Native FPS: 59.77 -> Displayed FPS: 119.55 (x2 FG) over 7,042 presents; the ffx census upscale-drained=3518 fg-dispatch-drained=3518 frames=3520, presents/frame=2.00, frames/upscale-drained=1.00; DXGI present counter: unseen=0 over samples=7096 (the FSR 3.1 pacer presents through the patched body); the NVIDIA driver's word SR 0x5 / FG 0x90001 — nothing created, so the driver-reported rung correctly says nothing beside an AMD identity. The census names only amd_fidelityfx_dx12.dll (the 3.1 monolith Lies of P calls) — the AMD half of 7c is complete on its oracle. Same run, Rune Factory at DLSS + FG ×4: 125.45 → 498.51 (×3.97), Dlss (driver-reported), DlssG with the driver agreeing — the 7b title on its NVIDIA path.

  • 2026-09-06, 13:45–14:02, the owner's run on #132 (rung 3 by elimination + the executable scan): Cronos at XeSS (no FG option), Hell Is Us at XeSS + XeSS-FG, Rune Factory at FSR + FSR FG.

    Title / setting Line frame generation: executable markers:
    Cronos, XeSS, no FG FPS: 110.02, none by count, DXGI agrees None ffxFrameInterpolation ×1, NVSDK_NGX ×112, xefgSwapChain ×13
    Hell Is Us, XeSS + XeSS-FG Presented FPS: 186.47, tokens=0, unseen=0 N/A — no token on this plugin at XeSS; witnesses: not DLSS-G, no FSR dispatch, runtimes nvngx_dlssg + libxess_fg + amd FG, file carries xefgSwapChain same set
    Rune Factory, FSR + FSR FG (compiled in) 30.05 → 60.05 (×2 FG) from the token, unseen=0 Active (technology not identified) — by elimination …; the executable itself carries ffxFsr3, ffxFrameInterpolation ffxFsr3 ×13, ffxFrameInterpolation ×9, NVSDK_NGX ×112

    Three readings. Rune Factory is the pre-committed 7b line, verbatim. XeFG presents through the patched body (0 unseen) so its Displayed rate is measured; its Native is not, because Hell Is Us's plugin requests no Streamline token at XeSS (it does at DLSS, and Cronos's does at XeSS) — the count producer is the plugin's choice, and nothing in policy replaces it. The Steam overlay could not show FG on that session either. The upscaler N/A on both XeSS titles now names Intel's licence as the reason (7c item 4).

10 · Telemetry layering

  • L1 baseline vendor-neutral:

  • D3DKMT perf-data probe on Win 10 22H2 and Win 11 — stable enough to keep:

  • L2: LHM fields returned per vendor (fill 18_GPU_VENDOR_APIS §Capability matrix; use explicit "untested", never ?, for absent hardware): NVIDIA measured 2026-09-03, below. AMD and Intel stay untested (§R5/§R6).

  • L2: GPU sensors unelevated, without PawnIO (§M5) — decides whether the default unelevated Agent has temperatures at all: YES — row R1 of the table pre-committed in 20_OPEN_QUESTIONS §M5, measured 2026-09-03, unelevated and elevated giving the identical field set.

    Instrument: FrameLedger.CaptureHost probe-lhm --seconds 3 (LhmComputerAdapter with IsGpuEnabled only, then the same tree read through LhmTelemetrySource). Machine: RTX 5080, driver 616.56 (nvidia-smi; §Environment's 32.0.16.1088 / 610.88 is what it was on 2026-08-02 and 2026-08-05), Windows 10.0.29648, LHM 0.9.6.0, PawnIO installed on the box but never opened — only LHM's CPU and board groups use it, and the GPU group was the only one enabled.

    Unelevated (process elevated: False), every tick of three:

    LHM sensor Type Value → GpuSample
    GPU Core Temperature 40.4 °C TempCoreC
    GPU Memory Junction Temperature 50 °C TempMemoryC
    GPU Core Load 0–5 % (idle) LoadPct
    GPU Memory Used SmallData 3,071–3,089 MB VramAdapterMb
    GPU Core / GPU Memory Clock 2,655–2,677 / 14,801 MHz CoreClockMhz / MemClockMhz
    GPU Package Power 54.4–55.7 W PowerW
    GPU Fan 1..3 Fan ~1,200 rpm FanRpm (fan 1)
    (no GPU Hot Spot sensor at all) — — TempHotspotC = N/A

    Also present and deliberately not mapped: GPU Memory Load (VRAM-in-use as a percentage, 18.9 %), D3D Shared Memory Used (279 MB of system RAM — the first draft of the fragment rule took it as VRAM; SensorMapTests.SharedMemoryIsNotVram pins the correction), three Control sensors (fan duty 30 %), GPU Bus / GPU Video Engine / fourteen D3D * engine loads, GPU Core Voltage, GPU PCIe Rx/Tx.

    Through the port: TryRead=True, Capabilities = TempCore, TempMemory, Load, VramAdapter, CoreClock, MemClock, Power, Fan, faults=0. Elevated control run (process elevated: True, launched through UAC): the same eight fields, the same values to within idle drift, the same verdict. Elevation adds nothing to GPU sensors on this vendor.

    What it settles: the unelevated Agent's Tier-2 session has GPU temperature, load, power, clocks, VRAM use and fan speed on NVIDIA. The three user-facing sentences stand (row R1: they may name the fields). What it does not settle: hotspot temperature — absent here, and whether that is the driver, the GPU generation or LHM 0.9.6 is unmeasured; and anything about AMD or Intel.

  • L3: Reflex latency, throttle reasons, per-domain utilisation: not yet — but L3 now initialises and is proven to degrade cleanly. Measured 2026-08-05 by ctest fl_nvapi_probe after vendoring: NvAPI_Initialize → NVAPI_OK, driver 610.88 (branch r610_85), 1 physical GPU, "NVIDIA GeForce RTX 5080". The absent-driver path is exercised by CI, where the probe prints BRANCH: DEGRADED and exits 0 — nvapi64.lib is a static stub library reaching nvapi64.dll through nvapi_QueryInterface at first call, so it is not a load-time dependency and a machine with no NVIDIA driver still loads the binary. The fields in this bullet need NvapiTelemetrySource, which does not exist.

  • L3 · a doc error the vendoring found, which reading vendor documentation would not have: 18_GPU_VENDOR_APIS §L3's table named NvAPI_GPU_GetMemoryInfo. The vendored headers mark it __nvapi_deprecated_function ("deprecated in release 520 — use NvAPI_GPU_GetMemoryInfoEx"), so under /W4 /WX a call to it fails the native build. Table corrected. This is the class 17_HOOK_ENGINE calls the highest false-confidence risk in the spike, in a document rather than in code.

11 · PresentMon / Tier 2 (§M2, §M6)

◐ Measured 2026-08-20 — the binary is here, and it will not run for us

  • Console binary obtained, version, pinned hash: ✅ C:\Program Files\Intel\PresentMon\PresentMonConsoleApplication\PresentMon-2.5.1-x64.exe, 956,768 bytes, SHA256 9BEC3083069F58F911E6A512F4806DB51A27BD096103087BC1D05EF54C80A191. Version 2.5.1, read from its own --help banner.

    It carries NO VERSIONINFO at all — FileVersion, ProductVersion and CompanyName are all empty. So "pin the version" has to mean pin the hash and the filename; there is nothing in the file for a versioninfo-check-style gate to read. Worth stating because this repository requires exactly that metadata of everything it builds (19_SAFETY, tools/versioninfo-check.ps1), and a bundled third-party binary that lacks it is a packaging fact, not a detail.

  • Runs unelevated: 🔴 NO, on this machine. Measured against hook-harness --hold-presenting, current user DESKTOP-NUHVIDP\Anon:

    error: failed to start trace session: access denied.
           PresentMon requires either administrative privileges or to be run by a
           user in the "Performance Log Users" user group.
    

    Exit code 6, no CSV written. The account is in BUILTIN\Users, docker-users and Authenticated Users — not an administrator, and not in Performance Log Users (S-1-5-32-559), so the refusal is exactly what it says rather than something subtler.

  • Performance Log Users sufficient without admin: ❓ UNMEASURED, and it stays that way here. Adding an account to a local group is a system settings change and it needs administrative rights of its own; it is the owner's to do, not a session's.

  • The shared service is running and it does NOT help the console. PresentMonSharedService is Running / Automatic, StartName = LocalSystem, from C:\Program Files\Intel\PresentMonSharedService\PresentMonService.exe. The console binary still starts its own trace session and still fails. So §M6's "or the PresentMon Service" half is not answered by the service merely being installed — the console does not talk to it. Whether PresentMon.exe (the Application, a GUI) does is unmeasured and would not produce a CSV anyway.

  • 2.x column set over stdout: ❓ UNMEASURED. No session, no CSV, no header. This is the input tools/frametype-oracle.ps1 parses, so that parser has never seen a real PresentMon CSV — it resolves columns by name and refuses loudly on anything it does not recognise, and its decision table is the only thing standing behind it. Said plainly rather than left for the next reader to assume.

🔴 THE RUN HAPPENED — 2026-08-27, three legs, three game launches, and row P2

Owner-run from an elevated shell via a three-leg runbook script. That script is not in this repository — it drove PresentMon, so it was closed unmerged when PresentMon was dropped the same day; do not go looking for it. Cyberpunk 2077, frame generation off / ×2 / ×4 set in the title's own menu, 40 s per leg, one game launch each. Analysis is in 20_OPEN_QUESTIONS §S31; what belongs here is what was measured.

The 2.x column set, which §M2 left unmeasured: 24 columns.

Application, ProcessID, SwapChainAddress, PresentRuntime, SyncInterval, PresentFlags,
AllowsTearing, PresentMode, FrameType, CPUStartTime, FrameTime, CPUBusy, CPUWait,
GPULatency, GPUTime, GPUBusy, GPUWait, DisplayLatency, DisplayedTime, AnimationError,
AnimationTime, MsFlipDelay, AllInputToPhotonLatency, ClickToPhotonLatency

FrameType is present, and every row of all three legs reads Application. Counted off the raw CSVs rather than off the tool's own summary:

leg rows distinct FrameType values
off 1,937 Application × 1,937
×2 6,488 Application × 6,488
×4 10,881 Application × 10,881

And the two instruments agree on the present rate to within 0.3%, which is what makes the finding a measurement rather than a shrug — PresentMon SAW the generated presents:

leg our hook PresentMon our presents/batch our evaluations
off 1,676 presents / 38.82 s = 43.16 /s 1,937 / 45 s = 43.04 /s N/A — no batch drained 0
×2 5,746 / 38.64 s = 144.31 /s 6,488 / 45 s = 144.18 /s 2.00 0
×4 9,652 / 38.77 s = 241.84 /s 10,881 / 45 s = 241.80 /s 3.99 0

Every leg: status=Ready, faults=0, layoutVersion=3, attach=Ok, one stream, one segment, 0 gaps and 0 dropped, unidentified=0.

So displayed rate tracks the configured multiplier, both instruments count the same present stream, and at ×4 roughly three presents in four cannot be application frames — while PresentMon classifies 100% of them Application. That is §S31 row P2, and tools/frametype-oracle.ps1 reported it as a falsifier on all three legs rather than as a ratio of 1.0, which is the one behaviour it was written to guarantee.

Unmeasured, and it decides the REASON rather than the action: whether --track_frame_type was in effect at all. If FrameType ships in --v2_metrics output regardless of the flag, these legs recorded a default. The discriminator is one five-second run without the flag, checking only whether the header carries the column — no game, no capture, no launch spent. It still needs elevation; attempted unelevated 2026-08-27 and refused with the same exit 6 this section opens with.

Both branches end at the same action, which is why §S31 landed anyway: either the vendor emitted nothing, or the invocation produced no frame-type data at all. In neither case did PresentMon answer the question as invoked.

The discriminator was run on 2026-08-27 and produced no file at all, so it settled nothing: the command targeted explorer.exe, which may present nothing PresentMon tracks, and "no CSV" is indistinguishable from "no FrameType column". Badly chosen target, recorded as such. Moot now — PresentMon was dropped the same day — and written down so nobody re-runs it thinking it is untried. Two findings nobody was looking for.

  • The off leg drained ZERO Streamline batches, against presents/batch = 1.000 at off in §8. The difference is Ray Reconstruction: §S30 established RR is evaluated once per application frame, so with RR on there are batches even with FG off. RR was not on here. Our side therefore had two readable legs, not three — turn RR on if the off leg needs to carry a ratio.
  • The CSV's first column is named Application and holds the process name, while the value being counted, in column 9, is also the string Application. A parser resolving by position — or grepping for the word — counts process names and reports a ratio from them. frametype-oracle.ps1's "resolved BY NAME from the header, never by position" was written before it had ever seen a real CSV, against exactly the collision that was waiting in it.

kFeatureDLSS_G is zero on all three legs, which takes the count to five capture sets across five titles. HANDOFF item 3's premise has now failed everywhere it has been looked for.

Artifacts: %LOCALAPPDATA%\FrameLedger\s31\{off,x2,x4}\ — presentmon.csv and capturehost-report.txt per leg. Not committed; they are measurement output and the numbers above are the record.

🔴 --track_frame_type is a BETA option that needs the VENDOR to cooperate

This is the finding, and it lands on a pre-committed oracle. PresentMon 2.5.1 --help, verbatim, under Beta Options:

--track_frame_type Track the type of each displayed frame; requires application and/or driver instrumentation using Intel-PresentMon provider.

So FrameType is not a general ETW classification of any present. It is a report of events the application or the graphics driver chose to emit through Intel's provider. 03_METRICS rung 2 says "PresentMon 2.x FrameType column reports generated frames directly" and §S30 called it "a mechanism that divides by nothing" — both are true of the mechanism and neither is a promise that the mechanism is available on an NVIDIA DLSS-G title. Whether NVIDIA's driver instruments that provider is the make-or-break question and is unmeasured.

The falsifier is written before the run (§S31): if a DLSS-G capture comes back with no FrameType column, or with every row spelled Application while frame generation was demonstrably on, PresentMon is retired as the application-frame oracle for NVIDIA frame generation in that same row — exactly as fl-baseline-probe was, rather than being re-run until it answers.

12 · The gate's own inputs — §S21 and §S20 (2026-08-04)

Analysis and the decisions live in 20_OPEN_QUESTIONS §S21 and §S20. What belongs here is what was run.

✅ §S21 · The override, demonstrated end to end on two real binaries

Same input to both — a crafted twelve-line rules file naming the three families IsCompleteEnoughToGate required, with values that match nothing, plus a real EasyAntiCheat_x64.dll loaded in the target:

Binary Verdict
bb0da0a, the tree before the fix Allow
The fix branch BlockedModule, family "Easy Anti-Cheat"

No admin, no write to our install directory, nothing left on disk. This is the one measurement to keep from the whole item: the hard gate could be turned off by an inherited environment variable and a text file.

✅ §S21 · The ANSI path, on the real Win32 calls (system ACP 1252)

A profile component the system code page cannot spell exists on disk and CreateFileW opens it, while CreateFileA fails ERROR_INVALID_NAME (123). Under an ASCII profile the same file opens both ways — which is exactly why a dev box cannot see this, and why it would have shipped.

A measurement of my own that was wrong first. The initial round-trip used [Text.Encoding]::Default, which in .NET Core is always UTF-8 and not the process ANSI code page, so it reported no loss. Re-run against the real ACP, it lost the characters. Measuring the wrong API is indistinguishable from measuring a working one.

✅ §S21 · What the first floor actually covered

Measured against the shipped seed, the hand-written three-family floor held 4 of 22 values, 2 of 5 groups, 0 of 5 name fragments — so it closed "a crafted file allows everything" and left "a crafted file removes most of the blocklist" open. Recorded because the write-up read as though it bounded more than it did. The floor is now generated from rules/detection-rules.json at build time and carries all of it.

Two residuals measured rather than asserted:

  • The known-folder path is still user-relocatable — the User Shell Folders key under HKCU is FullControl for the user. That is a persistent change affecting every application, not a per-launch variable, so the fix is a narrowing and is written down as one.
  • Moving the layer to SHGetKnownFolderPath added ole32 and SHELL32 to its imports. Resident in 62% and 61% of inspectable processes respectively, so the layer takes on no meaningful new load-time surface.

✅ §S20 · MoveFileEx vs ReplaceFileW against a live reader

MoveFileExW(MOVEFILE_REPLACE_EXISTING) returns ERROR_ACCESS_DENIED when the destination is open by a reader holding the guard's exact share mode (READ|WRITE|DELETE). ReplaceFileW succeeds. This repository had prescribed the failing one — in a source comment and in the ledger — as guidance for whoever built the seeder. A prescription nobody ran is a guess in the imperative mood.

✅ §S20 · rulesVersion does not track the blocklist

The first seeder design replaced the installed file when the packaged seed was strictly newer. Measured against this repository's own history of that file: 31825cf and ba5355e both changed the anticheat block without touching rulesVersion, and a4a2c63 — the only commit that bumped it — changed the block not at all. The rule would have delivered none of the two changes it existed for. The seeder records a hash of what it installed instead.

✅ §S20 · The seed half, on the machine's real rules location

Remove the file → the guard answers RulesUnreadable. Run the Agent → the guard reads its rules and reaches check 1. Four Agent branches exercised against the real location, with the machine's own file backed up and restored by hash: already-current, installed-from-nothing, idempotent second run, corrupt file replaced.

The feed half is untouched, so a rules edit still reaches no installed machine until a release.

🔴 The canary harness lied three times before it caught anything

Kept because this file's rules ask for dead ends, and because this one produced three confident greens in one session:

  1. ctest/Catch2 with -c "*name*" selects nothing and exits 0, so every "the canary passed" was vacuous.
  2. The rewritten check matched only Catch2's failure summary, so a genuinely green run parsed as "the filter selected nothing".
  3. build.ps1's throw escaped the harness and left a canary edit on disk — the next build then failed on an unrelated /W4 /WX unused-parameter warning, which was nearly diagnosed as the canary working.

Now: tag filters, an assertion that assertions actually ran, and try/finally around the build. A canary that cannot go red is the defect it was written to catch, one level up.


13 · Can the guard go RED against real anti-cheat? (2026-08-04)

Every real-machine verdict recorded before this section was Allow or an uncertainty refusal. The only blocklist positive ever seen — EasyAntiCheat_EOS as an installed-but-stopped service — was classified as a defect and deliberately narrowed away. So nothing had ever shown that the module, driver, service or directory tiers fire against a running commercial anti-cheat, and a gate that has never been observed to refuse carries the same amount of information as one that never refuses.

Measured against four real titles, unelevated. FlGuardEvaluate and FlStaticPreScan only — nothing was injected anywhere.

✅ It goes red — through the SERVICE tier, and machine-wide

With Goose Goose Duck (Easy Anti-Cheat, Unity) actually running:

Target Verdict
Goose Goose Duck (pid) BlockedService, family Easy Anti-Cheat, signal EasyAntiCheat_EOS
GGDLauncher same
EasyAntiCheat_EOS same
a freshly spawned hook-harness, completely unrelated same

State at the moment of measurement: service EasyAntiCheat_EOS Running, driver EasyAntiCheat_EOSSys Running.

The refusal is machine-wide, and that is worth stating plainly rather than discovering. Checks 2 and 2b do not depend on the target, so while any EAC title is running FrameLedger refuses to inject into anything — a user with a party game idling in the background cannot capture an unrelated single-player title, and the signal names a game they are not playing. That is the correct fail-closed posture (a live anti-cheat driver is a machine-wide hazard, which is exactly what §S1's driver check exists for), but the user-facing text has to explain it or it reads as a bug.

🔴 Check 1 structurally cannot see an EAC-protected game

Measured with the guard's own rights and flags (PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ, LIST_MODULES_ALL):

Process Result
Goose Goose Duck OpenProcess succeeds, EnumProcessModulesEx fails with ERROR_ACCESS_DENIED (5)
EasyAntiCheat_EOS OpenProcess fails with 5
GGDLauncher 62 modules readable, none matching any blocklist prefix or fuzzy fragment

So the module tier's EasyAntiCheat entries can never fire on the process that matters: the guard gets kFailed → kProcessUnreadable, which is a refusal for "could not look", not for "found EAC". The handle opening while the enumeration is denied is worth remembering — a probe that only checked OpenProcess would have concluded the process was readable.

The consequence for §S16: the readable member of this title's tree is the launcher, and the launcher carries nothing. The service check is doing all the work.

🔴 Two whole families were missing, and one is kernel-level

ACE-BASE.sys, ACE-ADVT.sys Installed under System32\drivers by Neverness To Everness (Anti-Cheat Expert, kernel level). Matched nothing — the family was absent from 19_SAFETY's table and from the data
service AntiCheatExpert Protection Registered. Matched nothing
EasyAntiCheat_EOSSys Running as a kernel driver. Matched nothing in drivers; the refusal came from services instead
NTEGlobal/driver/PGameProtectDriver_X64.sys A kernel driver shipped inside the game install. Matched nothing. Its name contains protect, but the fuzzy tier is modules-only and never looks at check 4's file and directory groups

All four are now in the data and in 19_SAFETY §Blocklist seed, with the unmeasured siblings marked as such.

Valve VAC remains absent, and CS2 measures Allow. VAC is neither a machine-wide driver nor a service; it is modules loaded into the game process, which — per the previous section — is exactly what cannot be read. The route 19_SAFETY reserves for it is blockedStoreIds — check 3's store-id half, which cannot be called (§S14). #52 wired the executable half; that changes nothing here, because a renamed executable defeats a name list and the store-id route is exactly why 19_SAFETY reserves it. Recorded rather than papered over: a real VAC title is allowed by this guard today.

🔴 The data addition alone changed nothing, and that is the sharper finding

Adding PGameProtectDriver_X64.sys made check 4 refuse when the scan started at NTEGlobal — and still return Allow from the install root, which is where check 4 actually runs (ImageDirectory → ResolveInstallRoot).

kMaxPreScanDepth was 2. Measured with a control tree carrying a known blocklisted file at increasing depth:

File at Old cap New cap
depth 0 refuse refuse
depth 1 refuse refuse
depth 2 Allow refuse
depth 3 Allow Allow

The driver sits at depth 2. So the blocklist row was coverage on paper — a row that cannot be reached from where the scan begins.

The cap was measured before it moved, because it is a REFUSAL and not a truncation: overrunning kMaxPreScanEntries = 4096 does not scan less, it refuses the title. Across 67 installed titles the worst case is 506 entries at the old reach and 729 at the new one — 18% of budget, 5.6x headroom.

✅ Proven on the whole corpus, both directions

The deeper pre-scan run against all 67 installed titles:

Verdict Count
Allow 65
AntiCheatDirectory (Goose Goose Duck) 1
AntiCheatFile (Neverness To Everness) 1
PreScanFailed 0

Exactly the two anti-cheat titles refuse, nothing else does, and the deeper walk produced no false refusal on any real install.

What is still unmeasured

  • Whether the module tier fires on any real anti-cheat. It could not be reached here: the one title whose modules are readable carries none.
  • Whether the driver tier fires. ACE-* and EasyAntiCheat* are now in drivers, but both were Stopped during the measurement window that would have exercised it, and the EAC session was caught by the service check first. The driver rows are therefore data-complete and behaviourally untested.
  • VAC, as above.

Exit criteria

15_ROADMAP §P0. Nothing in P1 starts until all are met.

  • A throwaway build records a real session from a real offline game reporting correct upscaler, quality preset, render → output resolution, FG factor and RT state — verified against the game's own settings menu. Met 2026-09-06 with one amendment, the owner's: the quality preset reads N/A on every title, by measurement — Streamline's tags carry no size or preset on Direct3D 12, NVIDIA's override fields are the override's, XeSS is closed by licence — and an honest N/A where measurement is impossible is the correct value CLAUDE.md rule 7 asks for. Upscaler, render → output (where the vendor's call carries it), FG factor and RT state are verified against the menus of nine titles (§9). The owner closed 7a on this reading and closed P0 on it here.
  • Moved to the end of P1 (§R4, decided 2026-08-02) — measured game FPS impact under 0.5%. As written it imported P2's drain, aggregate and recorder paths; the harness-level per-present cost stayed in P0 and is measured in §3 (8.4 ns).
  • Every S-series item in 20_OPEN_QUESTIONS.md resolved, or explicitly deferred with a written rationale. Met 2026-09-06 (§S24: zero counted against it). 🚫 S23-2 is a branch-protection setting outside any PR and is recorded as such, not as met.
  • M3 and M4 answered before any NVAPI or LHM code is written — both CLEAR, §0 above.

Note (§R4): … Decide before starting, not halfway through. Decided 2026-08-02 — the FPS-impact criterion moved to the end of P1, and the harness-level per-present cost stayed in P0 as item 2. This file went on asking for a decision that two other documents had already recorded.


14 · The P2 milestone and the FPS-impact run (slots — the owner's runs)

Nothing below has been run (written 2026-09-10; §14.1's row half is read 2026-09-16 — see there — and §14.2–14.4 are still unrun). The section exists because P2's code is finished and its two remaining obligations are measurements a script cannot take: a real title, read against its own settings menu, and a benchmark whose number only the operator can see. Written as empty slots with the exact commands rather than left absent, so the next session cannot mistake "not measured" for "not required" — the failure mode this file's own rules name first.

14.1 · The milestone session — Tier 1, a real title, against its menus

15_ROADMAP §P2: "first real hooked session persisted with measured upscaler/RT data."

The technical half is met and is in the merge gate (2026-09-10, P2 PR-F): AgentEndToEndTests runs the shipped FrameLedger.Agent.exe --console capture --exe hook-harness.exe and reads back one sessions row — tier 1, d3d11, > 100 frames, guard_ticks_published ≥ 1, the blobs beside it, no .partial left. What the harness cannot supply is a game: it has no upscaler, no frame generation and no ray tracing, so upscaler, fg_mode and rt_flag are honestly N/A there. The milestone is the row where they are not.

The run, when the owner takes it (candidates from §9: Cyberpunk 2077, Lies of P, Cronos):

FrameLedger.Agent --console consent grant  --exe "<title>.exe"      # type the phrase
FrameLedger.Agent --console launch         --exe "<title>.exe" --seconds 600
FrameLedger.Agent --console sessions --last 1

The row half is read — 2026-09-16, the shipped Agent, not the console. The owner ran the App with its --serve Agent for an afternoon (18 hooked sessions — count note, 2026-09-27: CHANGELOG 2026-09-17 says all nine hooked sessions of 2026-09-16; neither count was re-made when the other was written, and the ledger as it stands today holds no session from that day, so the discrepancy is recorded rather than resolved — attach mode, late_attach = 1, every one watcher-driven from a Steam launch rather than the launch verb above — a Steam title started from its Shipping executable relaunches through Steam, so the console recipe is the wrong vehicle for a Steam library and the product's own path is the right one). sessions.id = 10, Lies of P, 16:11, 147 s, d3d12, 16,221 frames, guard_ticks_published = 5, Overlay dcf5796bf2a6-dirty, read from the ledger (rebuilt that evening from its WAL — 06_DATA_MODEL §Migrations carries that incident; the row is the row):

Field Read from the row The game's own menu Agree?
upscaler fsr3 (fg_source = api) owner to read
upscaler_quality NULL (0xFF → not stored, #183) (N/A is the measured answer on every title so far — §9, P0 exit criterion 1; FSR 3 carries no Streamline DLSSOptions to chain, so it is the expected answer here too)
render_w × render_h → output_w × output_h 1506 × 848 → 2560 × 1440 (upscale_ratio 1.70 — FSR "Balanced" is 1.7×; "Quality" would be 1.5×, "Performance" 2.0×) owner to read
fg_mode / fg_factor fsrfg / 2.04 (native_fps 57.1 → displayed_fps 116.4, displayed_counted_by = hook, no refusal) owner to read
rt_flag no (rt_source = measured, rt_frame_pct 0.0) owner to read
telemetry_source l1+lhm+nvapi (expect l1+lhm+nvapi on this box since PR-E2) ✅

What this row does and does not settle. It is the first hooked session the shipped Agent persisted with a measured upscaler, a counted frame-generation factor and a measured RT state — the milestone's row half. The "against its menus" column is empty because only the owner can read the game's settings screen, and the row is kept here with that column blank rather than filled from memory. The same afternoon's DLSS-G rows (Onimusha ×2, Hell Is Us, Black Myth: Wukong) are the refused shape — identity dlssg from the tags, fg_factor NULL, fg_refusal = multiple_streams (RE Engine's second swapchain) or non_uniform (a bucket that departed: menus, loading, alt-tab in a whole play session) — which is the guard working on real play rather than on a 40-second leg, and the reason fg_refusal_detail (schema 0005) now stores the bucket's numbers. Onimusha's rt_flag = yes with rt_frame_pct 25.0 / 17.8 and Wukong's yes at 16.2 are measured against nothing yet either.

One launch per capture (HANDOFF §Traps): a title measured off / ×2 / ×4 is three launches.

14.2 · §S1's launcher-fronted title — launch mode and the descendant election

The election is built (P2 PR-F, DescendantElection) and unit-tested against fabricated snapshots; what has never happened is a real launcher spawning a real game under it. An Epic- or Ubisoft-fronted title is the case: the consented executable exits or never presents, the guard answers LaunchTargetExited / LaunchNoPresentationRuntime with nothing injected, and the Agent then elects the newest tracked descendant and attaches.

The elected image needs its own consent record — a launcher's consent does not extend to what it spawns — so the run is: consent grant the launcher, launch it, read the election: line, then consent grant the game the election named and launch again.

Title / launcher
Guard's answer for the launcher
election: line
Session row for the elected image

14.3 · FPS impact ≤ 0.5 % — 14_TESTING §Hook overhead item 2

The last thing P1 owes (§R4 moved it here because it needs P2's drain and recorder). Run tools/fps-impact-runbook.ps1; it prints the block that replaces this one.

./tools/fps-impact-runbook.ps1 -Exe "<title>.exe" -GameArgs "-benchmark" -Seconds 600
Run Leg Game avg FPS Agent CPU (% of a core) Agent RSS (MB)
1 ON
2 ON
3 ON
1 OFF
2 OFF
3 OFF

Gates: FPS delta ≤ 0.5 %, Agent CPU ≤ 1 % of a core, Agent RSS ≤ 150 MB. Overlay resident ≤ 8 MB is not measured by the runbook and is left blank rather than guessed: it is a module inside the game process, and reading the target's memory is what CLAUDE.md rule 4 forbids — an external tool that inspects module sizes is the way to fill it.

14.4 · §H7's six overlays — still owner-only

Unchanged by P2 and repeated here because it is the other measurement no PR can close: the compare-and-restore path is proven against a fixture (ctest fl_unhook_inline), and §H7 still asks for one capture with each of the six overlays actually resident on the dev machine.

15 · Unreal Engine versions in shipping executables (2026-09-27, beta.10)

Measured read-only on the owner's machine (i7-14700KF, RTX 5080, Windows 11 29648): every *-Win64-Shipping.exe under D:\SteamLibrary\steamapps\common (a USB drive), before the extractor was written, then again through the shipped UnrealBuildReader once it was. Nothing was copied or written; the numbers are in 05_DETECTION §Engine version (the table is not repeated here).

  • Numeric file version (VS_FIXEDFILEINFO): the engine's MAJOR.MINOR.PATCH in seven of ten; a studio's own in three (Cronos 1.2.0.0, Rune Factory 1.0.3.0, SILENT HILL 2 1.0.0.5). The version strings are empty in six of ten.
  • Branch name (UTF-16 ++UE4+Release-M.m / ++UE5+Release-M.m): present in five — in .rdata in four (15–30 MB sections), and 290 MB into .code in Black Myth: Wukong, whose protected executable has an 8 KB .rdata; in UMIGARI also in the version strings. Absent in five (Hell Is Us carries UE5-CL-0: a renamed branch).
  • The shipped reader, same ten files: every version as tabled — 8 read, 2 honestly none — in 16 ms to 1.1 s each and 7.5 s for Black Myth (the whole-file fallback, stopping at the first chunk that names a release line). A first pass that scanned only a PE's .rdata read Black Myth as 5.0.0 from the file version alone; the 1 MiB .rdata floor (UnrealBuildReader.MinRdataBytes) is what moved it to the stronger rung.
  • No UE3 title is installed; the rule does not detect UE3 at all.

16 · A game process's own memory, read from outside it (2026-10-03, beta.12, owner decision D43)

Why this was measured. Per-process VRAM had storage since 0001 and no producer: 17_HOOK_ENGINE §Memory planned IDXGIAdapter3::QueryVideoMemoryInfo inside the game, 20_OPEN_QUESTIONS §M7 (2026-09-09) recorded that its CurrentUsage is the calling process's own (0 bytes from the Agent) and concluded the figure could only be read in the game, and §H10 left open where in the game. The owner chose the other road (D43): the documented performance counters \GPU Process Memory(pid_<pid>_luid_…_phys_<n>)\Dedicated Usage / Shared Usage — the numbers Task Manager's Details tab shows — need no handle to the game at all, and GetProcessMemoryInfo needs only PROCESS_QUERY_LIMITED_INFORMATION. §M7's conclusion holds for QueryVideoMemoryInfo and not in general.

Already seen before this section was written, stated so the table below is not read as having preceded them: (1) the counter set exists on the dev box, 37 instances at an idle desktop (Get-Counter, 2026-10-03); (2) Dedicated Usage is not Local Usage — dwm.exe 858 MB against 310 MB — so "dedicated" is defined as Task Manager's column and never compared with a DXGI budget; (3) ctest fl_process_stats on the RTX 5080 while the reader was being written: a 256 MiB DEFAULT buffer moved this process's dedicated figure 12.9 → 269.0 MiB (+256.1), and PROCESS_MEMORY_COUNTERS_EX2 answered (private working set 5.2 MiB) on Windows 11 29648.

The decision table, written before the runs below (instrument: fl-probe-processstats, --hold-vram in one process and --read against it in another):

# Measurement Outcome → what it means
M1 Cost of one collect + read, 60 samples at 1 s median ≤ 5 ms → 1 Hz with the sensors; 5–20 ms → still 1 Hz, noted in 18_GPU_VENDOR_APIS; > 20 ms → every 5 s, and said so
M2 Δ dedicated of a second process holding 512 MiB within ±2 % → "Dedicated GPU memory, as Task Manager shows it" may be written; off by > 10 % → stop, the video half does not ship
M3 dedicated against that process's own QueryVideoMemoryInfo(LOCAL).CurrentUsage recorded in 03_METRICS, whichever way it falls — the source does not change
M4 PrivateWorkingSetSize (EX2) against \Process V2(<name>:<pid>)\Working Set - Private equal → "the same as Task Manager's Memory column"; EX2 refused → the EX fallback, and Windows 10 stays unmeasured
M5 How soon a new process's counter instance appears recorded; the first seconds of a session reading N/A is then expected, not a fault
M6 The probe's own private bytes after 600 collections Δ < 1 MiB → keep one query per session; more → open and close per collection, then measure again

Results (2026-10-03, the same evening; RTX 5080, driver 617.14, Windows 11 29648.1000, fl-probe-processstats from this PR's build):

# Measured Row taken
M1 60 samples at 1 s: collect + read median 0.098 ms, max 0.217 ms; 600 back to back: median 0.028 ms, max 0.190 ms ≤ 5 ms → 1 Hz with the sensors
M2 holder at 8 MiB: dedicated 21.0 MiB; holder at 512 MiB: 525.0 MiB → Δ 512.0 MiB for 512 MiB allocated (0.0 %); the in-process ctest earlier: +256.1 MiB for 256 within ±2 % → "Dedicated GPU memory, as Task Manager shows it"
M3 the holder's own CurrentUsage(LOCAL): 16.5 MiB (8 MiB holder) and 520.5 MiB (512 MiB holder) against dedicated 21.0 and 525.0 — dedicated reads 4.5 MiB more, the same 4.5 MiB at both sizes recorded in 03_METRICS: the counter includes a constant per-device amount the DXGI budget group does not; the difference does not grow with what the game allocates
M4 private working set (EX2) 9.1 MiB = \Process V2(fl-probe-processstats:<pid>)\Working Set - Private 9.1 MiB, in all 60 samples equal → "the same as Task Manager's Memory column"
M5 the holder's instance was present at the reader's first poll, ~50 ms after the holder started (its device and buffer had already been created) an instance exists from the process's first GPU allocation; a game that has made none reads N/A, as specified
M6 600 collections: the probe's private bytes moved by 0 bytes (−44 KB over the 60 slow ones) < 1 MiB → one query per session

What stays unmeasured: Windows 10 22H2 (no machine; the reader falls back to PROCESS_MEMORY_COUNTERS_EX where EX2 is refused, and the private working set then reads N/A), AMD and Intel GPUs, a laptop with two adapters (the reader sums every adapter's instances for the pid), and a real game — the owner's beta.12 check (HANDOFF owner-only item 9) compares a session's figures with Task Manager's Details tab at the same moment.