- 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>
166 KiB
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
KFsuffix means no iGPU) and exactly one adapter. Multi-GPU adapter-LUID selection — theadapterLuidfield in the shm handshake, and the PDH instance filtering in18_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:
HKCUimplicit layers: none. All six above needed admin to register.17_HOOK_ENGINE's choice ofHKCUis the less common one and the better one.- The loader warns that
GalaxyOverlayVkLayerviolates naming policyLLP_LAYER_3, and that OBS/RTSS declare API 1.3 against a 1.4 application. Both are mistakes we should not copy — see17_HOOK_ENGINE§Vulkan, where the layer name was corrected toVK_LAYER_FRAMELEDGER_overlayas 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:
LibreHardwareMonitorLib0.9.6, nuspec<license type="expression">MPL-2.0</license>, repo commit3d331e33. - 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
LICENSEitself — 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.csall 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
.nupkgwas 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.txtis now committed, and theTHIRD_PARTY_NOTICESrelease gate is a real requirement, not boilerplate. Gpu/IntelIntegratedGpu.cshas 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.libandx86/nvapi.libare tracked files, not a separate SDK download. That was the crux of the question — a.libobtained from the NVIDIA SDK installer would have come with the SDK's own agreement instead. License.txtanswers it in its first line, unusually explicitly:nvapi.lib and nvapi64.lib are licensed under the following terms:followed bySPDX-License-Identifier: MITand the standard MIT text. The grant names the import libraries as its subject.- Headers carry their own
SPDX-License-Identifier: MITblocks (nvapi.h,nvapi_lite_common.h,nvapi_interface.hall verified). - Result: headers and
nvapi64.libare both MIT. MIT is one-way compatible with GPL-3.0; vendoring is fine provided the notice is retained, whichtools/license-check.ps1enforces.legal/licenses/nvapi-MIT.txtcommitted. - 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_COPYmeans 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:
OpenProcesswith the guard's own rights returnsERROR_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, and19_SAFETY§Elevated / protected targets is implementable. - Absent service:
OpenServiceWon a non-existent name returnsERROR_SERVICE_DOES_NOT_EXIST (1060)specifically, not a generic failure — which is the discrimination19_SAFETYrelies on. - NOT MEASURED — the DENIED service branch. A standard user holds
SERVICE_QUERY_STATUSon the stock service set, soACCESS_DENIEDis 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, asdxgiPresentsBeforeHookplus 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:
- Discovery is not loading. With the variable unset the loader still prints
Located json file "...\FrameLedger.VkLayer\VkLayer_..._overlay.json". A match onFrameLedger.VkLayer.dllhit that path — the manifest sits in a directory of that name. - 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).
vulkaninfoproves 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:
- 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. - We see the post-proxy call. Parameters the proxy rewrote are what we observe, not what the game passed.
- 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.SetPausedis 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
pauseRequestedwas unreachable on any frame whereguardTickschanged — one root cause,MayObserve()having exactly one caller. Measured in both directions:unhookRequestedagainst a live--holdtarget leftstatusatREADYthrough 10 s of polling, and a paused session leaked 12 records across 12 guard ticks, exactly one per tick (writeIndex9 → 21). Closed by the watchdog thread (§S25). - 🔴 The three-fault self-disable still has no test at all.
NoteFaultdiscardedMH_DisableHook's return and set nog_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 theVirtualProtectExalternative cannot locate the target's view base. Both approaches and their failure modes are written intosrc/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
LoadLibraryinstall 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:
Yestwice,Notwice, every verdict agreeing with the game's own menu. Cyberpunk with path tracing on and Wukong at RT High both readYes; Rune Factory, whose menu has no ray-tracing option, and Cyberpunk with every RT option switched off both readNo— the branch that had never been reachable in this project.rt_frame_pctreads 25.0% at ×4 on two titles, which is the falsifier03_METRICS§RT/PT/RR pre-committed. It did not fire.faults = 0on 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,280rays per RT-active present, and3 × 1706 × 960is4,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.dlltakesDispatchRaysand leavesBuildRaytracingAccelerationStructurealone, and nothing says another UMD splits them the same way — or leaves either inD3D12Core: - 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.exeat the install root is a shim and was left alone. /MTDLL loaded without incident: yes.FlGuardEvaluate→Allow;FlGuardedInject→Allow;FrameLedger.Overlay.dllpresent in the target on re-enumeration (143 → 144 modules), mapped at0x7FFA60340000, 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 bothLOP-Win64-Shipping.exeand theLOP.exeshim exited on their own; no hang, no crash dialog, no orphan. Worth stating because process exit runsDllMain(DLL_PROCESS_DETACH)on a loader-locked thread, which is the one lifecycle path a/MTstatic-CRT DLL is most likely to fail on, and it is not exercised byhook-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 oncePresentis 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 carriedFrameLedger.Guard.dllitself — 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 inC:\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.exein the scan set, which an unelevated guard cannot open — a correctProcessUnreadableabout something irrelevant. Orphaning it viacmd /c startterminates 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 andFrameLedger.Appcarries 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 reportsO=for files that carry no embedded signature at all.mskeyprotect.dll,kernel32.dllandnvapi64.dllare allSignatureType=Catalog. A nativeWinVerifyTrustwithWTD_CHOICE_FILE, which is what "wireIsTrustedSigner" means in every prior note, recovers nothing for them;IsTrustedSigner(nullptr)is false by contract and the refusal survives. Catalog verification needsCryptCATAdminAcquireContext2/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:
EnumerateScanSetImplstops the ancestor walk at the firstIsPlatformLaunchermatch, and that list includesexplorer.exe,services.exeandsvchost.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.dllThe 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_QUESTIONSbecause §Purpose of this file makes measurements this file's job, and #51 changed only that other document.Live consequence: the drain tests are
Category=Integrationand 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.dllLOADED, 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 namegameguardcould match,guardmatches 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-validatenow fails when any fragment contains another, so the list cannot regrow a rule that cannot fire. Note that removing it does triprules-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), andfaults=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_pctDisplayed FPS Cyberpunk, PT on 10,603 2,578 DLSS_RR25782,561 / 2,567 24.2% (25.0% of the claiming window) 264.93 Alan Wake 2 900 875 DLSS_RR875869 / 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 kFeatureDLSS42420 / 0 0.0% 436.28 1 · The tri-state is complete, and
Nois correct twice for two different reasons.Yeson Cyberpunk (path tracing) and Wukong (RT High);Noon 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 conjuncts03_METRICSrequires:rtTier12,RtAsBuildinstalled, and zero evidence across 36,575 and 16,871 claiming records.2 ·
slEvaluateFeatureIS 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 bothsl.interposer.dllandsl.dlss_g.dllloaded and DLSS-G demonstrably running, and Rune Factory likewise. The other two call it only for Ray Reconstruction.kFeatureDLSS_Gis 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_RR2578 /DLSS0 toDLSS4242 /DLSS_RR0. This is also the first observation ofkFeatureDLSSanywhere in this project, and the local-tag extent arrives on that evaluation exactly as it did on the RR one — the same1485×835.4 · A SECOND FG proxy, and it covers what the first cannot. On Wukong there are no Streamline batches, so
presents/batchis unreadable — andpresents ÷ RT-active presentsreads 5,764 / 1,441 = 4.0000 exactly against a title configured for ×4. It carries the same unverified premise aspresents/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_pctmust 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 andrt_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,280rays per RT-active present, and3 × 1706 × 960 = 4,913,280exactly — 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_PARAMSproduced 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), hooksPresent | 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 reportedUNKNOWN. What settles it rather than suggesting it:renderW/Hare 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.000on three independent runs (10,176/2,544 · 10,276/2,569 · 10,092/2,523), against the title's ownx4. 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_factorstructurally 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/batchis 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/batchfalls 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 thecapabilitiesgroup ofrules/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. AnINCOMPLETEorFAILEDscan 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
anticheatsubtree, 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 ownFrameLedger.Guard.dllcopied 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).
Presentinterception, 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 thatnothing reads the ring:. Both are prerequisites of filling this table, and neither is "finding a game".src/FrameLedger.Sharedholds a.csprojand no.csfiles, so the Overlay's output is observable only from insideguard_test.cppThe 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 ETWFrameType: 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 — sofgEvaluationsis 0 on every record and there is nothing for ETW to be compared against. The comparison15_ROADMAPitem 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 81during a ×2 capture whose own figures imply 161.7 and 80.8. That is one agreement, not two:presents/batchwas 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 fromDisplayed FPS, sopresents/spanrestates it), and the rival reading — that the overlay'sFPSfield 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 — ourpresents/batchagainst the overlay'sDLSS/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_Gis zero on every one, and two of the four never callslEvaluateFeatureat all — Black Myth: Wukong with bothsl.interposer.dllandsl.dlss_g.dllloaded 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.slEvaluateFeatureis a route some titles use for some features, not the Streamline entry point.presents / RT-active presentsis a second proxy and covers the gap. Wukong has no batches at all, sopresents/batchis unreadable — and5,764 / 1,441 = 4.0000exactly, 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-probewas 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 capabilitiesloaded, includingdlss_gandxefg— two mutually exclusive frame-generation implementations — soloadedmeans "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
FrameTypesee 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.dllon disk and the loader reportednvngx_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
0x2794Dat off, FSR and DLSS + FG ×4; Lies of P the identical0x41801across 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 what03_METRICSsays the census may and may not do, now measured. - The facade regroup was load-bearing. Lies of P ships
amd_fidelityfx_dx12.dllalone 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 theFL_CENSUS_RANequalityfl_guardasserts 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 severalGame.exeprocesses 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-processflag 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/tokensread 0.22 / 0.64 / 1.31 andtokens/batch4.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: stillTargetAmbiguous, 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/tokens1.00 / 1.00 / 2.99 / 3.99,tokens/batch1.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, census0x1, 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
Presenton the shareddxgi.dllvtable, exactly as--probe-proxypredicted 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), sofg_factorstays 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.dll1.0.1.41314SDK 1.1.x monolith — a leaf Black Myth: Wukong the monolith and amd_fidelityfx_loader_dx12.dll2.1.0 andamd_fidelityfx_denoiser_dx12.dllmixed Dying Light: The Beast, Kingdom Come: Deliverance II amd_fidelityfx_loader_dx12.dll1.0.2 +amd_fidelityfx_upscaler_dx12.dll4.0.2 (+…framegeneration_dx12.dll3.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 loaderUE5, 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.dllFSR 3.0 host DLLs, named exports — the deferred routehooked 2026-09-05 at the host facade (ffxFsr3ContextDispatchUpscale, tagfsr3-v3.0.4: the module's twelve exports match that tag, notv1.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 PFsr3/FsrFg/118.98 → 238.02 (×2)/ counts agree 1.00, andnoneby count with FG off; Hell Is UsFSR (3.1 or 4 …)/FsrFg/ ×2 / 1.00, andnonewith 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/Aon 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: Dlsson 4720/4783, 4271/4345 and 4575/4657 records,FPS 80.41 / 72.73 / 77.69, every batch identified, RT measured on ~98% of presents.UpscalerParams0 of N on all three,render -> output: N/A, quality byte never published. Cause, measured with dumpbin: DL:TB shipssl.interposer.dll2.8.0, which exportsslSetTagForFrame(Cyberpunk's 2.7.1 does not);sl.hmarksslSetTagdeprecated 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.ps1recorded the FIRSTsl.interposer.dllfound (2.7.4.0), so the 2.8 export was absent fromdocs/vendor-exports.jsonuntil the tool unioned across copies (ten copies, eight distinct versions from 1.5.6 to 2.10.3). All three runs readframe generation: nonewith presents = tokens = batches; which of the three had DLSS Frame Generation on is the owner's to say — if any did,nonethere 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):Dlss4331/4401,FPS 73.64, andUpscalerParamsstill 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::Resourcecarries its ownwidth/height(mandatory only on Vulkan, so filled or not on D3D12 at the title's choice), andTagSizeinfl_sl_inputs.hnow 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 arender -> outputline, that was the shape; if not, the title does not state the size on this route at all and the honest line staysN/A. -
2026-09-05 00:53, DL:TB at DLSS on the #116 build (payload rebuilt 00:51):
N/Astands.Dlss3460/3523,FPS 58.87,UpscalerParams0 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 measuredN/Afor 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: noneagain 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 = tokenson 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 in20_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.dll32.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,noneby 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 1707x960on 3677 recordscount right, DLSS-G unnamed ( kFeatureDLSS_Gnever evaluated)Dying Light: The Beast, DLSS FG ×4 (twice) Presented FPS 76.7/93.24,noneWITHHELD with the §H5 qualifier,sl.interposer.dll 2.8.0.0namedowner'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/Asame 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.0loadedsame 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 namingamd_fidelityfx_dx12.dll,upscaler: N/A,tokens=0NGX-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/Aon every FG-on capture — Cyberpunk at FSR 3 + FG printed it two lines underrender 1506x847 on 4332 record(s)— becauseUpscaleExtentkeyed 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 andkFeatureDLSS_Gis 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 in20_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) DlssG38.5 → 154.04 (×4),81.41 → 325.58 (×4)global: depth, mvec, hudless, ui-color-alpha, backbuffer, other Expedition 33, DLSS + FG ×2 DlssG75.95 → 149.83 (×1.97)global: same set Black Myth: Wukong, DLSS + FG ×4 DlssG47.99 → 191.89 (×4)global: depth, mvec, hudless, ui-color-alpha, backbuffer Rune Factory, DLSS + FG ×4 DlssG128.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.97global: depth, mvec, hudless, scaling-in, scaling-out, other (no UI tag) Dying Light: The Beast, DLSS FG ×4 N/A ( nonewithheld, §H5) + "it is FEEDING frame generation"Presented FPS 67.13frame ( slSetTagForFrame): depth, mvec, hudless, scaling-in, scaling-out, ui-color-alpha, otherThree 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 throughslSetTagForFrame— soActive (technology not identified)is gone from every one of them, andupscaler: N/Aon 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 tagkBufferTypeScalingInputColor, through the 2.8 export, andUpscalerParamsis 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; theN/Athere is the title's truth. Cyberpunk's refusal is the guard working:tokens/batch 2.97withpresents/batch 4.97and 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.98withtokens/batch 1.00on 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=18207DlssGOnimusha: Way of the Sword demo, 2.10.3, DLSS + FG 60.04 → 220.33 (×3.67)unseen=0 over samples=12914DlssG,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.dllmust 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'srender -> output: N/AwithUpscalerParams 0/13014is DL:TB's shape again — the frame-route tags carry no size on D3D12, wheresl::Resourcedeclares 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: 12387unseen=12483 over samples=4202 (2.97)DlssGDying Light: The Beast, DLSS, FG off (07:45) Presented FPS 75.52(withheld)unseen=0 over samples=4519N/A (withheld) — census still 0x25F0F, tags0x23600(no hudless / UI)Dying Light: The Beast, DLSS, FG off (07:55) Presented FPS 61.14(withheld)unseen=0 over samples=3659same Expedition 33, FG off (Streamline 2.7.30) FPS: 85.86unseen=0 over samples=5063noneby count; tag census0x0Two 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.dllis 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 printnonewith 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/frameGenerationCountHell Is Us, no override, 83.21 → 332.82 (×4 FG)DlssG,upscaler: N/A0x80605CREATED EVALUATE (+ INITIALIZED DLL_EXISTS ERR_NOT_FOUND)INITIALIZED DLL_EXISTS ERR_NOT_FOUND 0x5INITIALIZED DLL_EXISTS only0 / 0 / 0 / 0 Expedition 33, override ON, FG off, FPS: 79.4none(DXGI agrees),upscaler: N/A0x8067FCREATED EVALUATE ENABLED DLL_LOADED DLL_SELECTED PRESET PERF_MODE (+ …)INITIALIZED DLL_EXISTS ERR_NOT_FOUND 0x1FINITIALIZED ENABLED DLL_EXISTS DLL_LOADED DLL_SELECTED0 / 2 / 11 / 0 Lies of P, no override, Presented FPS 59.89,upscaler: N/A0x605CREATED 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),
frameGenerationCountis the override target and not the multiplier, andscalingRatiois 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 printsnonewith DXGI's own present counter agrees: 0 unseen over 4774 (#126), and Lies of P'sPresented FPSkeeps its "MAY include generated frames" qualifier becauseamd_fidelityfx_dx12.dllis loaded there — the census cannot saynoneand 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 on0x605— N3 keeps the rung. Then the captures:Title / setting upscaler:NVIDIA driver NGX state:SR / RR / FGFG line Lies of P, DLSS (no override) Dlss (driver-reported: …)0x605/0x90001/0x90001N/A (no FG in this title) Expedition 33, override ON, FG off Dlss (driver-reported: …)0x8067F(mode 2, preset 11) /0x80005/0x1Fnone, DXGI agreesHell Is Us, DLSS + FG ×4 Dlss (driver-reported: …)0x80605/0x80005/0x605(CHANGED between readings)81.32 → 321.73 (×3.96),DlssGOnimusha demo, SL 2.10.3, DLSS + FG Dlss — the NVIDIA driver agrees0x605/0x5/0x605(CHANGED)59.99 → 235.47 (×3.93),DlssGDying Light: The Beast, DLSS + FG ×4 Dlss — the NVIDIA driver agrees0x605/0x90001/0x605(CHANGED)39.63 → 158.5 (×4)DXGI-COUNTED,DlssGCronos: The New Dawn demo (new; UE, SL 2.8.0), DLSS, FG off Dlss (driver-reported: …)0x80605/0x80005/0x5FPS 105.01,none, DXGI agrees; RT YesDying Light: The Beast, FSR upscaling + DLSS FG FSR (3.1 or 4 …),2560x1440 -> 2560x14400x205(CREATED, not EVALUATE) /0x90001/0x605DlssGfrom the tags; factor REFUSED (bucket 8 of 8 at 1.96 vs 2.85); DXGI 1.80 unseen / presentThree 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 | EVALUATEwith the word changing mid-session; the multiplier bits never set, so it is an identity witness and is now printed besideframe generation:.SR 0x205on 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 censusframe=[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 countednone, 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 = 1xon 3,538 records,frame generation: FsrFg,Native FPS: 59.77 -> Displayed FPS: 119.55 (x2 FG)over 7,042 presents; the ffx censusupscale-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 wordSR 0x5/FG 0x90001— nothing created, so the driver-reported rung correctly says nothing beside an AMD identity. The census names onlyamd_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),DlssGwith 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,noneby count, DXGI agreesNoneffxFrameInterpolation ×1, NVSDK_NGX ×112, xefgSwapChain ×13 Hell Is Us, XeSS + XeSS-FG Presented FPS: 186.47,tokens=0,unseen=0N/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=0Active (technology not identified) — by elimination …; the executable itself carries ffxFsr3, ffxFrameInterpolationffxFsr3 ×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:
-
D3DKMTperf-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 stayuntested(§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(LhmComputerAdapterwithIsGpuEnabledonly, then the same tree read throughLhmTelemetrySource). 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 → GpuSampleGPU CoreTemperature 40.4 °C TempCoreCGPU Memory JunctionTemperature 50 °C TempMemoryCGPU CoreLoad 0–5 % (idle) LoadPctGPU Memory UsedSmallData 3,071–3,089 MB VramAdapterMbGPU Core/GPU MemoryClock 2,655–2,677 / 14,801 MHz CoreClockMhz/MemClockMhzGPU PackagePower 54.4–55.7 W PowerWGPU Fan 1..3Fan ~1,200 rpm FanRpm(fan 1)(no GPU Hot Spotsensor at all)— — TempHotspotC= N/AAlso present and deliberately not mapped:
GPU MemoryLoad (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.SharedMemoryIsNotVrampins the correction), threeControlsensors (fan duty 30 %),GPU Bus/GPU Video Engine/ fourteenD3D *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_probeafter vendoring:NvAPI_Initialize→NVAPI_OK, driver 610.88 (branchr610_85), 1 physical GPU, "NVIDIA GeForce RTX 5080". The absent-driver path is exercised by CI, where the probe printsBRANCH: DEGRADEDand exits 0 —nvapi64.libis a static stub library reachingnvapi64.dllthroughnvapi_QueryInterfaceat 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 needNvapiTelemetrySource, 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 namedNvAPI_GPU_GetMemoryInfo. The vendored headers mark it__nvapi_deprecated_function("deprecated in release 520 — useNvAPI_GPU_GetMemoryInfoEx"), so under/W4 /WXa call to it fails the native build. Table corrected. This is the class17_HOOK_ENGINEcalls 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, SHA2569BEC3083069F58F911E6A512F4806DB51A27BD096103087BC1D05EF54C80A191. Version 2.5.1, read from its own--helpbanner.It carries NO VERSIONINFO at all —
FileVersion,ProductVersionandCompanyNameare all empty. So "pin the version" has to mean pin the hash and the filename; there is nothing in the file for aversioninfo-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 userDESKTOP-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-usersandAuthenticated Users— not an administrator, and not inPerformance 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.
PresentMonSharedServiceisRunning/Automatic,StartName = LocalSystem, fromC:\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. WhetherPresentMon.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.ps1parses, 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
offleg drained ZERO Streamline batches, againstpresents/batch = 1.000at 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
Applicationand holds the process name, while the value being counted, in column 9, is also the stringApplication. 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_typeTrack 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 Folderskey underHKCUis 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
SHGetKnownFolderPathaddedole32andSHELL32to 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:
ctest/Catch2 with-c "*name*"selects nothing and exits 0, so every "the canary passed" was vacuous.- The rewritten check matched only Catch2's failure summary, so a genuinely green run parsed as "the filter selected nothing".
build.ps1's throw escaped the harness and left a canary edit on disk — the next build then failed on an unrelated/W4 /WXunused-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-*andEasyAntiCheat*are now indrivers, 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/Aon 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 honestN/Awhere 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.mdresolved, 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.rdatain four (15–30 MB sections), and 290 MB into.codein Black Myth: Wukong, whose protected executable has an 8 KB.rdata; in UMIGARI also in the version strings. Absent in five (Hell Is Us carriesUE5-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
.rdataread Black Myth as5.0.0from the file version alone; the 1 MiB.rdatafloor (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.