Compare commits
8
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fdd0eb855c | ||
|
|
7ddb367c63 | ||
|
|
d586de1ccc | ||
|
|
97c3feb648 | ||
|
|
480b30ae0d | ||
|
|
3f95c4b9fb | ||
|
|
7c67f4610d | ||
|
|
b9c11e4a34 |
No files matched your search
+108
@@ -27,8 +27,116 @@ under a `## [x.y.z] - date` heading in the same commit that bumps `VERSION`, the
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
### Added
|
||||
|
||||
- **RE Engine and FromSoftware games are detected.** Capcom's RE Engine titles (RESIDENT EVIL 2/3/4/7/Village, Devil
|
||||
May Cry 5, Monster Hunter Rise/Wilds, Street Fighter 6, Dragon's Dogma 2, Onimusha…) by their `re_chunk_000.pak`
|
||||
archive; FromSoftware's (DARK SOULS II/III, ELDEN RING, Sekiro…) by their `.bhd` + `.bdt` archive pairs. Both are
|
||||
relative signals — a file layout, not a proof — like every engine rule. Every game in the library is re-detected on
|
||||
the next sweep. Engines are now shown by name ("RPG Maker MV/MZ", "Unreal Engine") instead of the rule's id
|
||||
(`rpgmaker_mv`). A game added by hand whose executable says nothing (`Game.exe`) is named after the game — RPG
|
||||
Maker's own title when the folder carries one, else its folder — instead of "Game".
|
||||
|
||||
### Fixed
|
||||
|
||||
- **Another game's `Game.exe` no longer runs under a library entry — no wrong name, no second session.** On
|
||||
2026-09-23 00:16 *HELLO, HELLO WORLD!* (itch) started its RPG Maker runtime, `swiftshader\Game.exe`, and the Agent
|
||||
matched it by FILE NAME to the only entry named `Game.exe`, *Flower in Us*: it recorded the session under that name,
|
||||
which created a new "Flower in Us" entry at HHW's path, and an NW.js child process then matched the new entry and
|
||||
started a second session beside the first (57 s and 56 s). A process that matches an entry by file name only now
|
||||
starts nothing — unless it is that entry's own executable on a drive that changed its letter, in which case the entry
|
||||
follows it as before — and the log says once that it is not in the library. The same match can no longer move an
|
||||
entry onto another game whose `Game.exe` has identical bytes (every RPG Maker MV game ships the same one). One session
|
||||
per executable, whatever id its entry has; a session that could not be hooked is timed by its own executable instead
|
||||
of any process with its file name; the resolver says in the Agent's log why a process could not be read; an
|
||||
unreadable entry is logged once instead of every 15 s. **Changed:** a game whose folder moved records nothing until
|
||||
*Change executable* points its entry at the new file. The "Flower in Us" entry the old match created stays until you
|
||||
rename it (it points at HHW's `swiftshader\Game.exe`, the file to measure HHW by) or remove it.
|
||||
|
||||
- **A game removed from the library while it runs no longer loses its session — or stops the Agent at the next
|
||||
start.** On 2026-09-22 23:26 and 2026-09-23 00:25 a GIRLS' FRONTLINE 2 session ended `FAULTED` on the database's
|
||||
foreign key: its entry had been removed (and re-imported) while the game ran, and the session was written under the
|
||||
id it started with. Each left a `.partial` file, and the recovery that runs at every start would have failed on it
|
||||
the same way — with no guard, so the Agent's host would have stopped at every start and nothing would have been
|
||||
captured. Now the session is stored under the entry that holds its executable when the one it started with is gone
|
||||
(the re-imported entry); when no entry does — the game was removed with its sessions — it is dropped with a log line
|
||||
that says so. Recovery never throws: a file it cannot finalize is set aside as `<guid>.partial.failed`, kept for a bug
|
||||
report, and the next file is recovered. The `FAULTED` and end-of-session log lines now name the session, the game and
|
||||
its executable, and the Agent's host logs its own warnings and errors into `agent-*.log`.
|
||||
|
||||
## [0.1.0-beta.5] - 2026-09-22
|
||||
|
||||
**The fifth pre-release: the guard override is gone, Tier 2 exists, and a drive that changes its letter is followed.**
|
||||
The same unsigned installer: verify its hash against `SHA256SUMS.txt`, then *More info → Run anyway*. What changed for
|
||||
a user:
|
||||
|
||||
- **The "Bypass the anti-cheat guard" switch is removed.** Where FrameLedger finds anti-cheat in a game — before it
|
||||
injects, when a session starts, or during one — it refuses and **turns hooking off for that game**, says so in the
|
||||
notice and on the game's page, and offers no way to turn it back on for that executable. The terms say so
|
||||
(Disclaimer 2.5, EULA 1.2), so the Legal Gate opens once after the update.
|
||||
- **Sessions that could not be hooked are recorded now.** A refused or hooking-off game gets a T2 row with its
|
||||
duration, hardware telemetry and the reason — the summary says why ("the guard refused — …", "hooking was off for
|
||||
this game", "Windows would not let FrameLedger open the process"). Until now every such session was thrown away
|
||||
within a second.
|
||||
- **A hooking-off entry that runs as administrator (Borderless Gaming, imported from Steam) no longer gets the
|
||||
"anti-cheat driver" notice**, and Steam's tools are no longer imported as games. An entry you already have for one
|
||||
stays until you remove it.
|
||||
- **A drive that changes its letter no longer loses your games.** The Agent finds the same file under the new letter
|
||||
and moves the entry to it with its consent kept — within about 15 s in the background, at once when you launch the
|
||||
game, and when you click the hooking switch. The game's page says when its executable is not where the entry points.
|
||||
|
||||
**Updating from `0.1.0-beta.4`:**
|
||||
|
||||
- Quit the App (tray icon → Exit) and end `FrameLedger.Agent.exe` before running the installer.
|
||||
- Schema 0008 drops the five columns of the removed switch; the database opens in place, nothing else changes.
|
||||
- Entries whose switch was on lose it; if the guard blocked such a game, its hooking is off and its page says why.
|
||||
|
||||
### Removed
|
||||
|
||||
- **The per-game guard override ("Bypass the anti-cheat guard") is gone** — owner decision 2026-09-22, two pre-releases
|
||||
after it arrived. Its first real use could not reach a process an anti-cheat driver protects, and where it could
|
||||
inject it only exposed the user to the risk its own warning described. Removed entirely: the native entries
|
||||
(`FlGuardedInjectAcknowledged`, its WhenReady twin, `FlGuardIsJudgement`, reason 28), the `SetGuardBypass` message, the
|
||||
App's card and dialog, the session mark and its export line, the `Safety_Bypass_*` strings, and schema 0007's five
|
||||
columns (schema 0008 drops them — the first `DROP COLUMN` in the migration set). Sessions that ran under it keep
|
||||
`guard-bypass=` in their notes. CLAUDE.md rule 2 reads "there is no override" again; Disclaimer 2.5 and EULA 1.2 say
|
||||
so, so the Legal Gate opens once.
|
||||
|
||||
### Added
|
||||
|
||||
- **Tier 2 exists now: a session that could not be hooked is recorded — duration, hardware telemetry and the
|
||||
reason — instead of being thrown away.** Until 2026-09-22 every refusal returned within a second and the 30 s
|
||||
minimum discarded it (`Discarded (tier 2, exit=Normal, frames=0)` for every one in the owner's log), so "the session
|
||||
is still recorded" in the notice was false. The loop now holds a refused session open, ticking the telemetry poller,
|
||||
until the game exits; the row lands as T2 with N/A everywhere a measurement would be, and its summary says why
|
||||
("Why: the guard refused — Easy Anti-Cheat (…)", "Why: hooking was off for this game", "Why: Windows would not let
|
||||
FrameLedger open the process"). The unshipped operator host keeps returning at the refusal.
|
||||
- **A drive that changes its letter no longer loses your games.** When the drive holding a library comes back as
|
||||
another letter (the owner's external drive: `D:` one evening, `H:` the next morning), every game on it read
|
||||
"executable unreadable" and a game launched from the new letter ran as a stranger with no consent. The Agent now
|
||||
finds the same file — same size, same modified time, under exactly one other drive letter — and moves the entry to
|
||||
it with consent, block and detection kept: within about 15 s in the background sweep, at once when such a game is
|
||||
launched, and when you click the hooking switch. The game's page says when its executable is not where the entry
|
||||
points. *Change executable* is still the way to point an entry at a different file.
|
||||
- **Steam's tools are no longer imported as games**: Steamworks Common Redistributables, Borderless Gaming, Wallpaper
|
||||
Engine, SteamVR, the Proton and Steam Linux Runtime entries and Blender are skipped by app id. A row you already have
|
||||
for one of them stays until you remove it.
|
||||
|
||||
### Fixed
|
||||
|
||||
- **A hooking-off entry that runs as administrator no longer gets the "anti-cheat driver" notice.** Borderless Gaming,
|
||||
imported from Steam with hooking off, produced a red "hooking refused" notice on every launch: the Agent tried to
|
||||
open its process before it looked at whether hooking was on. Hooking-off is decided first now — no process is
|
||||
opened, no resolver, no gate — and the row gets a quiet Tier-2 session like any other hooking-off game.
|
||||
|
||||
### Changed
|
||||
|
||||
- **A finding turns the game's hooking off, wherever the guard makes it** (`19_SAFETY` §What a finding does to the game). The
|
||||
pre-scan always did this; now a finding at a session's start or at the 30 s re-scan writes the same block — hooking
|
||||
off, the reason on the row, the toggle disabled on the game's page — when it names an anti-cheat *in the game* (its
|
||||
process, its folder, its title lists). A machine-wide driver or service refuses that session only. The notice says
|
||||
"Hooking has been turned off for this game", the session's notes carry `hooking-turned-off=`, and `CaptureRefused` /
|
||||
`SafetyUnhook` carry `hookingTurnedOff`.
|
||||
- **`0.1.0-beta.4`'s notes named a cause they had no evidence for, and are corrected in place** (see its *Updating*
|
||||
section). The owner reported afterwards that the external USB drive holding the Steam library had a loose cable that
|
||||
evening. Windows' System and Application logs for 2026-09-21 agree and re-date the day's symptoms: disk resets and
|
||||
|
||||
@@ -11,14 +11,11 @@ A C++ DLL (`FrameLedger.Overlay.dll`) is injected into games the user explicitly
|
||||
## Non-negotiable rules
|
||||
|
||||
1. **Injection is opt-in, per game, never automatic.** The user must add the game *and* enable hooking for it. There is no "hook everything" mode, no global auto-inject.
|
||||
2. **The anti-cheat guard is a hard gate, not a warning.** Before injecting, scan the target for known anti-cheat/anti-tamper modules (`19_SAFETY`). If any is found → **refuse**, log, tell the user why. ~~There is no override switch, no "I understand, continue anyway" button. Do not add one.~~
|
||||
2. **The anti-cheat guard is a hard gate, not a warning.** Before injecting, scan the target for known anti-cheat/anti-tamper modules (`19_SAFETY`). If any is found → **refuse**, log, tell the user why. There is no override switch, no "I understand, continue anyway" button. Do not add one.
|
||||
|
||||
> **Amended 2026-09-21 (owner decision): there is exactly ONE override, and its shape is the rule now.** The owner asked for a "bypass the guard" mode at the user's own risk. It exists (`docs/19_SAFETY_AND_ANTICHEAT.md` §The user's bypass) and everything about it is a constraint a PR may not loosen:
|
||||
> - **Per game, OFF by default, never global.** There is no settings key, no CLI switch, no environment variable, no field in `rules/detection-rules.json` (its schema still makes one a validation error) and no "apply to all". Do not add one.
|
||||
> - **A recorded human act.** It is turned on only through its own disclosure — which states the ban risk and that the user carries the entire risk and the developers none — accepted by BOTH a ticked acknowledgement and the typed phrase, stamped by the Agent with the disclosure's version, keyed on the executable's fingerprint like consent, and gone when hooking is turned off or the executable changes.
|
||||
> - **It overrules the guard's JUDGEMENT and nothing else.** The kill switch, a game that was merely added, a missing consent, a foreign payload, a 32-bit target and a failed injection refuse exactly as before. The guard still runs every check, still reports what it found, and the verdict is `AllowedUnderUserBypass` — never `Allow`. A Vulkan title the guard refuses stays refused.
|
||||
> - **Rule 3 is untouched, and that is the line.** The bypass changes WHETHER FrameLedger injects, never HOW: the same documented `LoadLibraryW`, the DLL's real name, exports and version info, in one chokepoint file. Nothing about it makes FrameLedger harder for anti-cheat to see, and a PR that did would still be rejected on principle.
|
||||
> - **It is visible afterwards.** A session that started under it is marked on its row, with what the guard found, on every surface and in every export.
|
||||
> **Amended 2026-09-22 (owner decision): the override of 2026-09-21 is withdrawn, and the sentence above is the rule again.** For one day (releases `0.1.0-beta.3` and `beta.4`) a per-game override existed. The owner withdrew it: no entry point, no message, no column (schema 0008 drops 0007's five), no string. Do not add one in any form.
|
||||
>
|
||||
> **A finding turns the game's hooking off** (`19_SAFETY` §What a finding does to the game). An anti-cheat named in the game itself — its process, its title lists, its folder — is written to the row exactly as the pre-scan always wrote it (`hook_enabled = 0`, `hook_blocked_reason`, `hook_prescan_state = 'blocked'`), and since 2026-09-22 also when the guard finds it at a session's start or at the 30 s re-scan (`AntiCheatVerdict.IsFindingAboutTheGame`). A machine-wide driver or service refuses that session only. The notice, the game's page, the session's notes and the Agent's log all say it happened. Nothing clears the block, as before.
|
||||
3. **Never implement evasion.** No manual mapping, no PE header erasure, no thread hiding, no signature obfuscation, no unlinking from the PEB module list. Injection uses documented `LoadLibraryW`. The DLL keeps its real name, real exports, and version info. A performance tool must be *visible* to anti-cheat, not hidden from it. Any PR that makes FrameLedger harder to detect is rejected on principle.
|
||||
4. **Never read or write game memory outside our own hooks.** We read arguments passed to APIs we hooked and COM/handle objects we legitimately own. No pattern scanning for game internals, no reading player/entity state, no writing to game memory. Ever.
|
||||
5. **The hook must never crash the game.** Every hook body: SEH-guarded, allocation-free, lock-free, no logging, no exceptions crossing the boundary. On repeated faults, self-disable (`17_HOOK_ENGINE` §Fault policy).
|
||||
|
||||
@@ -5,12 +5,11 @@
|
||||
> No telemetry. No accounts. All data stays on your machine.
|
||||
|
||||
<!-- accuracy-block:begin -->
|
||||
> ⚠ **What FrameLedger actually measures today — 2026-09-21.** The software is a beta; its latest
|
||||
> **pre-release is `0.1.0-beta.4`** (2026-09-21), an unsigned installer built from that tag with its
|
||||
> ⚠ **What FrameLedger actually measures today — 2026-09-22.** The software is a beta; its latest
|
||||
> **pre-release is `0.1.0-beta.5`** (2026-09-22), an unsigned installer built from that tag with its
|
||||
> checksums published beside it. The source holds the desktop app
|
||||
> (library, store import, charts, settings) and the background Agent, which records a session when a
|
||||
> game in the library runs, injects only into games you enabled and only past the safety guard (or,
|
||||
> for a game whose guard bypass you turned on yourself, past your own acceptance of that risk), and
|
||||
> game in the library runs, injects only into games you enabled and only past the safety guard, and
|
||||
> stores sessions in a local database. What that path measures:
|
||||
>
|
||||
> - **Frame times and output resolution:** measured from the present call for Direct3D 11/12 and
|
||||
@@ -61,11 +60,10 @@
|
||||
> half of the suspicious-module rule. During every capture the Agent re-runs the checks every 30 s and
|
||||
> stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer
|
||||
> goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at
|
||||
> its next check; it can only refuse, never permit. **There is one override, and only one:** a per-game
|
||||
> "bypass the anti-cheat guard" switch, off by default, that you can turn on only by accepting its own
|
||||
> warning (a tick and a typed word). With it on, FrameLedger injects into that game even where the
|
||||
> checks find anti-cheat, the 30 s re-check no longer stops the capture for that finding, and every
|
||||
> session started that way is marked. It never changes HOW FrameLedger injects: nothing is hidden.
|
||||
> its next check; it can only refuse, never permit. **There is no override.** A finding about a game — anti-cheat
|
||||
> named in its process, in its folder or on its title lists — turns hooking off for that game, whether found
|
||||
> before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it
|
||||
> back on for that executable.
|
||||
>
|
||||
> Where a value is not measured it reads `N/A`, with two exceptions: FPS then shows Presented FPS with a
|
||||
> note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as
|
||||
@@ -138,7 +136,7 @@ Elevation is **optional — for everything.** Hooked capture is the normal path
|
||||
|
||||
## Install
|
||||
|
||||
> **The latest pre-release is `v0.1.0-beta.4` (2026-09-21); before it `v0.1.0-beta.3` (2026-09-21), `v0.1.0-beta.2` (2026-09-17) and `v0.1.0-beta.1` (2026-09-16).** They are pre-releases: read `CHANGELOG.md`'s section for the one you install — what it measures, what it does not yet, and how to update — before installing. A source build is `docs/12_BUILD.md`.
|
||||
> **The latest pre-release is `v0.1.0-beta.5` (2026-09-22); before it `v0.1.0-beta.4` (2026-09-21), `v0.1.0-beta.3` (2026-09-21), `v0.1.0-beta.2` (2026-09-17) and `v0.1.0-beta.1` (2026-09-16).** They are pre-releases: read `CHANGELOG.md`'s section for the one you install — what it measures, what it does not yet, and how to update — before installing. A source build is `docs/12_BUILD.md`.
|
||||
|
||||
1. Download the latest `FrameLedger.App-win-Setup.exe` from [Releases](https://github.com/poli0981/frameledger/releases). It installs into `%LOCALAPPDATA%\FrameLedger.App`; your data stays in `%LOCALAPPDATA%\FrameLedger`, and uninstalling asks before touching it.
|
||||
2. SmartScreen may warn — releases are not code-signed (free, open-source project). Verify the SHA-256 checksum published with each release, then **More info → Run anyway**.
|
||||
@@ -166,4 +164,4 @@ If you find a game with anti-cheat that FrameLedger fails to detect, please open
|
||||
|
||||
---
|
||||
|
||||
**Status:** pre-release (beta). Four tagged pre-releases so far; see `CHANGELOG.md` for what each one changed and the accuracy block at the top of this file for what is and is not measured. It is not feature-complete, it certainly still has bugs, and `legal/DISCLAIMER.md` §0 says what that means for you.
|
||||
**Status:** pre-release (beta). Five tagged pre-releases so far; see `CHANGELOG.md` for what each one changed and the accuracy block at the top of this file for what is and is not measured. It is not feature-complete, it certainly still has bugs, and `legal/DISCLAIMER.md` §0 says what that means for you.
|
||||
+6
-6
@@ -23,13 +23,13 @@ to refuse, never how to evade (`docs/19_SAFETY_AND_ANTICHEAT.md`).
|
||||
This is a one-person project. The intent is to acknowledge a private report within a week and to say
|
||||
plainly what will happen next; that is an intent, not a contractual response time.
|
||||
|
||||
## The guard bypass is a feature, not a vulnerability
|
||||
## The guard has no override
|
||||
|
||||
Since 0.1.0-beta.3 a user can overrule the anti-cheat guard for one game through a disclosure they must accept by two
|
||||
separate acts (`docs/19_SAFETY_AND_ANTICHEAT.md` §The user's bypass). That is documented behaviour. What IS a security
|
||||
report: any way to reach an injection past the guard WITHOUT that disclosure having been accepted for that game — a
|
||||
flag, a setting, a crafted rules file, a pipe message, a database edit the Agent then honours without the stamp's
|
||||
version — or any session that ran under the bypass and is not marked as such.
|
||||
For two pre-releases (0.1.0-beta.3 and beta.4) a user could overrule the anti-cheat guard for one game through a
|
||||
disclosure. That switch was withdrawn on 2026-09-22 (`docs/19_SAFETY_AND_ANTICHEAT.md` §What a finding does to the game): a finding
|
||||
now turns the game's hooking off. What IS a security report: any way to reach an injection past a refusal — a flag, a
|
||||
setting, a crafted rules file, a pipe message, a database edit the Agent honours — or a finding about a game that
|
||||
does not turn its hooking off.
|
||||
|
||||
## A safety gap — a game with anti-cheat that FrameLedger fails to detect
|
||||
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ Requirement IDs (`FR-x`, `NFR-x`) are referenced by other docs, commits, and tes
|
||||
- FR-2.2 The static anti-cheat pre-scan disables the toggle outright for titles shipping anti-cheat; the reason is shown and the control is not clickable.
|
||||
- FR-2.3 The runtime guard refuses injection and refuses to continue a session when anti-cheat is detected. **No override exists anywhere in the UI, config, or CLI.**
|
||||
- FR-2.4 Global "disable all hooking" kill switch in Settings; also honored by the Vulkan layer.
|
||||
- FR-2.7 (owner decision 2026-09-21) A per-game **"bypass the anti-cheat guard"** switch, off by default, never global. Turning it on requires its own disclosure — naming the ban risk and that the user carries the entire risk and the developers none — accepted by a ticked acknowledgement AND a typed phrase, stamped by the Agent. It overrules the guard's judgement only (`19_SAFETY` §The user's bypass lists both sides), never changes how FrameLedger injects (CLAUDE.md rule 3), and every session started under it is marked as such permanently.
|
||||
- FR-2.7 (owner decision 2026-09-22; it was a per-game override for one day, withdrawn) A finding about a game — anti-cheat named in its process, on its title lists or in its folder — turns hooking off for that game wherever the guard makes it: at the pre-scan, at a session's start, or at the 30 s re-scan. The row carries the reason, the game's page and the notice say so, and nothing overrides it (`19_SAFETY` §What a finding does to the game).
|
||||
- FR-2.5 Repeated crashes shortly after injection auto-disable hooking for that game, with an explanation and a manual re-enable path.
|
||||
- FR-2.6 Users can always see, per session, which tier produced the data.
|
||||
|
||||
|
||||
+53
-2
@@ -74,6 +74,28 @@ promises.** It is stated here, in `README` §Capture tiers and in `03_METRICS`
|
||||
frame times without injection and a reader who remembers that will otherwise assume
|
||||
it still holds.
|
||||
|
||||
> **Built 2026-09-22 — until then Tier 2 did not exist in practice.** Every refusal returned from
|
||||
> `CaptureSession` within about a second and `SessionFinalizer`'s 30 s minimum discarded the row, so the
|
||||
> table above described a tier no session had ever reached (the owner's log: `Discarded (tier 2, exit=Normal,
|
||||
> frames=0)` for every refusal). Now the loop **holds** a refused session open — `HoldUnhookedAsync`, one tick
|
||||
> per `CaptureOptions.HoldInterval` (1 s), each tick draining the telemetry poller through the observer as a
|
||||
> hooked session's ticks do — until the target exits, the user stops it or `MaxDuration` runs out. The clock is
|
||||
> the pinned liveness when the loop holds a pin, and ~~the executable's NAME~~ **the executable's image path in the
|
||||
> watcher's own 1 Hz snapshot** (`ITargetResolver.IsRunning` over `LatestProcessSnapshot`, 2026-09-23; a process
|
||||
> whose path could not be read still counts by its name; the console verbs, where nothing polls, keep the name
|
||||
> list) when it never opened the process — by name, another game's `Game.exe` held an RPG Maker game's session
|
||||
> open. Nothing about the hold touches the target, and no process is opened for it. **And hooking-off is decided before the process is opened**: `RunAsync` reads the consent record
|
||||
> first, and a row whose hooking is off — merely added, blocked by a finding, auto-disabled — goes straight to
|
||||
> the hold with `RefusedHookNotEnabled` (its verdict is the row's block when it has one, `PreviouslyBlocked`).
|
||||
> The resolver used to run first, and a hooking-off utility that runs elevated (Borderless Gaming, imported from
|
||||
> Steam) was reported as a process an anti-cheat driver protects, with the notice that sentence deserves.
|
||||
> `TargetNotRunning` alone returns at once — there is nothing to hold. Launch mode's two guard refusals
|
||||
> (`LaunchTargetExited`, `LaunchNoPresentationRuntime`) return at once too, because the descendant election
|
||||
> is waiting on them. The unshipped operator host sets `HoldUnhooked = false`: to an operator a refusal is the
|
||||
> answer and the exit code. The discard rule is unchanged: a Tier-2 row under 30 s is still dropped, which is
|
||||
> now a game that ran under 30 s rather than every refusal. `PartialRecovery` no longer reads a tick as proof of
|
||||
> a hooked session — a held session flushes ticks with no records and no `attached` note.
|
||||
|
||||
**The reason is the payload of Tier 2**, not a consolation attached to it. A session
|
||||
that records duration and sensors while saying nothing about *why* it measured
|
||||
nothing is indistinguishable from a broken capture. `sessions.capture_notes` and the
|
||||
@@ -103,7 +125,7 @@ which makes the notification more important than it was, not less.
|
||||
## Process watcher
|
||||
|
||||
- 1 Hz snapshot via `CreateToolhelp32Snapshot` (CsWin32): pid, ppid, exe path (`QueryFullProcessImageName`).
|
||||
- Watchlist match on normalized full path (`GetFinalPathNameByHandle` — junctions/symlinks), filename fallback with a stale-path warning badge.
|
||||
- Watchlist match on normalized full path (`GetFinalPathNameByHandle` — junctions/symlinks), ~~filename fallback with a stale-path warning badge~~ **and a file name alone never starts a session (2026-09-23, HANDOFF D25): it can only be the entry's own executable on a drive that changed its letter (the relocator's rule), or it is not in the library.**
|
||||
- Process tree assembled from ppid chains; the **capture target** is the descendant that actually presents. In launch mode we know it; in attach mode we wait for the first ring handshake. ~~or (Tier 2) elect the PID with the most presents in the first 10 s~~ — there is no Tier-2 present stream to elect from. Re-elect if the presenting PID dies while the tree lives (level-transition relaunches).
|
||||
|
||||
> **Built 2026-09-10 (P2 PR-F), in `Application.Watch` with one adapter.** `ToolhelpProcessSnapshotSource`
|
||||
@@ -113,7 +135,20 @@ which makes the notification more important than it was, not less.
|
||||
> both null so it can match nothing. `ProcessWatcher` diffs it against the watchlist — the `games` rows — on the
|
||||
> normalised full path first and on the file name only when exactly ONE row carries it (`StalePath`, the
|
||||
> "stale-path warning badge"; the session is keyed on the path the process actually runs from, so consent for the
|
||||
> old path does not follow the binary). `ProcessTree` reads ppid chains with the one rule that defeats pid
|
||||
> old path does not follow the binary — **unless it IS the same binary on a drive that changed its letter**, 2026-09-22:
|
||||
> `CaptureOrchestrator.AdoptIfMovedAsync` asks `ExecutableRelocator` first, and when the row's file is gone and the
|
||||
> running one has the row's size and mtime, the row is moved and the session is the row's, consent and all;
|
||||
> `19_SAFETY` §A moved drive is the same executable). **Narrowed 2026-09-23 (D25): a `StalePath` match that is not
|
||||
> adopted records NOTHING.** The stranger session was keyed on the real path and named after the matched row, and
|
||||
> `SessionRecorder`'s `EnsureAsync` turned that into a new library entry with the other game's name: *HELLO, HELLO
|
||||
> WORLD!*'s `swiftshader\Game.exe` became a second "Flower in Us" (the only entry named `Game.exe`), and its NW.js
|
||||
> children, matching the new entry exactly, started a second session beside the first. Now the process is said once
|
||||
> in the log ("not in the library, so nothing is recorded") and its exit is silent; the adopt itself accepts only the
|
||||
> row's path with its drive letter changed (an RPG Maker `Game.exe` has the same bytes in every game); and the
|
||||
> running-session table is keyed by the executable's path, so a re-imported or merged entry's new id cannot start a
|
||||
> second session for the same executable. The launch election registers its session there too, and skips a child the
|
||||
> watcher already records. **Behaviour change:** a game whose folder moved (not its drive letter) records nothing until
|
||||
> *Change executable* points its entry at the new file. `ProcessTree` reads ppid chains with the one rule that defeats pid
|
||||
> reuse: a child that started before its parent is not its child. `DescendantElection` picks the newest-started
|
||||
> descendant whose image is tracked — a launcher's consent does not extend to what it spawns, so the elected image
|
||||
> needs its own record. `CaptureOrchestrator` is the `--serve` loop: one snapshot per second, ONE session per game
|
||||
@@ -317,6 +352,22 @@ because a layer cannot leave a running game's loader chain.
|
||||
|
||||
**Discard rule:** duration < min session length (default 30 s) → discard silently (log only).
|
||||
|
||||
> **A session whose entry was removed while it ran (2026-09-23).** Step 5 wrote under the id the session *started*
|
||||
> with, and the owner's GIRLS' FRONTLINE 2 entry was removed — and re-imported — twice while the game ran: both
|
||||
> sessions died on the foreign key (`session: FAULTED SqliteException: … FOREIGN KEY constraint failed`, 2026-09-22
|
||||
> 23:26 and 2026-09-23 00:25), and each left a `.partial` whose recovery would have died the same way at the next
|
||||
> start — stopping the host, because recovery ran before the watcher with no guard. As built:
|
||||
> - **The owner is looked up, not assumed** (`ISessionRepository.ResolveOwnerAsync`, `FinalizeInput.ExePath`): the id
|
||||
> the session started under when that row predates the session or holds its executable (an id SQLite reused for a
|
||||
> later game is neither — `games.id` has no AUTOINCREMENT), else the row that holds the executable's path now (the
|
||||
> re-imported entry), else **`GameRemoved`**: the user removed the game with its sessions and this was one of them.
|
||||
> Nothing is written, the `.partial` is deleted, and the log says which. The write transaction re-checks the row, so a
|
||||
> removal between the lookup and the insert is the same answer rather than the foreign key's exception.
|
||||
> - **Recovery never throws.** A file it cannot finalize is set aside as `<guid>.partial.failed` (never retried, kept for
|
||||
> a bug report) and reported `Failed`; the next file is recovered, and the watcher starts either way.
|
||||
> - The Agent's host logs through Serilog since the same day: a background service that stops the host is now in
|
||||
> `agent-*.log`, where before it was in no file at all.
|
||||
|
||||
> **Built 2026-09-10 (P2 PR-D): `Application.Recording`.** The state machine above is the intent; what
|
||||
> runs is one class per box. `SessionRecorder` owns a session end to end — the row's identity and time
|
||||
> base (`session_guid`, `qpc_epoch`/`qpc_frequency` from `TimeProvider.GetTimestamp`, which is QPC), the
|
||||
|
||||
+26
-2
@@ -137,6 +137,8 @@ Recorded as a residual risk, not as a solved problem.
|
||||
| GameMaker | `data.win` | `N/A` |
|
||||
| RPG Maker MV/MZ | `nw.dll` **and** `package.json` siblings (since 2026-09-16) | `N/A` — the `.js` header needs a `from` that `strings_regex` lacks |
|
||||
| RPG Maker XP/VX/VX Ace | `RGSS1*`/`RGSS2*`/`RGSS3*.dll` sibling **or** a `*.rgssad`/`*.rgss2a`/`*.rgss3a` archive (since 2026-09-16) | `N/A` — one rule, the variant unnamed |
|
||||
| RE Engine (Capcom) | `re_chunk_000.pak` sibling, the exact name (since 2026-09-23) | `N/A` |
|
||||
| FromSoftware | a `*.bhd` **and** a `*.bdt` sibling (since 2026-09-23) | `N/A` |
|
||||
| Ren'Py | `renpy/` dir **or** `*.rpa` | `renpy/__init__` strings / `log.txt` first line |
|
||||
| CryEngine | `CrySystem.dll` | FileVersion |
|
||||
| Source | `gameinfo.txt` + `bin/engine.dll` | `N/A` |
|
||||
@@ -160,6 +162,25 @@ Order matters (first match wins). Engine is user-overridable.
|
||||
> `every_engine_marker` canary carries both engines' markers and still expects `unity`. `rulesVersion` is
|
||||
> `2026.09.1`, so the sweep's cache key changes and every game is re-detected on the next pass.
|
||||
|
||||
> **RE Engine and FromSoftware, 2026-09-23 (owner request, "mang tính tương đối" — a relative signal, not a proof).**
|
||||
> Both are file-layout signals, checked on the owner's disk before they were written. **RE Engine:** every Capcom RE
|
||||
> Engine title ships its content as `re_chunk_000.pak` beside the executable, with patches as
|
||||
> `re_chunk_000.pak.patch_00N.pak` (RESIDENT EVIL 2 and the Onimusha demo). The rule names the base archive exactly — a
|
||||
> glob without a star is the whole leaf name — so a patch archive alone is not it. **FromSoftware:** the studio's
|
||||
> titles keep their data as `.bhd` header + `.bdt` data pairs beside the executable — DARK SOULS II
|
||||
> (`GameDataEbl.bhd/.bdt`), DARK SOULS III (`Data0`–`Data5`), ELDEN RING (`Data0`–`Data3`, plus `DLC`) and Sekiro
|
||||
> (`Data1`–`Data5`). The request described the second extension as `.bht`; on disk it is **`.bdt`**. An `all` group
|
||||
> over the two globs — half a pair is not a pair. The request also described a `<Game>\Game\` layout; it is not a
|
||||
> signal here, because Sekiro has no `Game\` folder and "the parent folder is named X" is not a signal type anyway.
|
||||
> None of the owner's other 80 Steam titles carries either marker. Both rules sit after the RPG Maker rules and
|
||||
> before `godot`, whose `*.pck` would also match a loose Wwise sound bank (an `Unknown` there would stop the walk
|
||||
> before these rules). Fixtures `engines/re_engine` and `engines/fromsoftware`; the `every_engine_marker` canary
|
||||
> carries both engines' markers and still expects `unity`. `rulesVersion` is `2026.09.2`, so every stored game is
|
||||
> re-detected on the next sweep. Engine detection never feeds the guard: ELDEN RING stays refused by its anti-cheat
|
||||
> whatever engine it is shown as. **Engines are shown by name since the same date** (`Formats.Engine` in the App —
|
||||
> proper nouns, not resources; an unknown id, or one the user typed, passes through): the game card and page used
|
||||
> to show the raw id (`rpgmaker_mv`).
|
||||
|
||||
⛔ *(kept for the record — the two rows above were the ones this note described)* **Two rows cannot be expressed in schemaVersion 2**, and are documented rather than half-implemented — a rule that exists but never fires is worse than one that is absent, because it reads as coverage:
|
||||
|
||||
- ~~**RPG Maker MV/MZ.** The signal is `nw.dll` **and** (`www/` **or** `package.json`) — a nested group, and `signalGroup` sets `maxProperties: 1` with its own `$comment` saying nesting is unsupported in v2.~~ Its version is a header inside a sibling `.js`, and `strings_regex` carries no `from`, so it cannot be aimed at a file other than the executable.
|
||||
@@ -177,7 +198,7 @@ Everything else in the table is in the data and has a fixture; `rules-validate.p
|
||||
| itch.io | `.itch\receipt.json.gz` | **`%APPDATA%\itch\db\butler.db`** (`install_locations` + `caves`, butler's `verdict` names the executable) since 2026-09-16, then the receipt JSON: title, id |
|
||||
| None/Manual | fallback | PE VersionInfo |
|
||||
|
||||
**Auto-import (FR-1.2):** Steam via `libraryfolders.vdf` → all `appmanifest_*.acf`; GOG via `HKLM\SOFTWARE\WOW6432Node\GOG.com\Games\*`; Epic via `Manifests\*.item`; itch by receipt scan. Import presents a review checklist; nothing is launched, nothing is hooked on import.
|
||||
**Auto-import (FR-1.2):** Steam via `libraryfolders.vdf` → all `appmanifest_*.acf` except `SteamLibrarySource.KnownTools` (2026-09-22: Steamworks Common Redistributables, Borderless Gaming, Wallpaper Engine, SteamVR, the Proton and Steam Linux Runtime entries, Blender — tools Steam's manifests do not distinguish from games, and which became library rows the watcher recorded); GOG via `HKLM\SOFTWARE\WOW6432Node\GOG.com\Games\*`; Epic via `Manifests\*.item`; itch by receipt scan. Import presents a review checklist; nothing is launched, nothing is hooked on import.
|
||||
|
||||
> **Built 2026-09-14 (P4 PR-4).** `Application.Import.LibraryImporter` over four `IStoreLibrarySource` adapters in
|
||||
> `Infrastructure.Import` — `SteamLibrarySource` (`libraryfolders.vdf` + `appmanifest_*.acf` through
|
||||
@@ -256,7 +277,10 @@ Three things this section previously implied that are not true, and are worth st
|
||||
> `DetectionHostedService` (`--serve` only) sweeps the library on its own task — every 15 s, and at once
|
||||
> when `UpdateRules` re-seeds the rules file — through `Application.Detection.DetectionSweep`, which runs
|
||||
> `StaticGameDetector` over the real `GameFileProbe` for every game whose key is stale and persists through
|
||||
> `IGameRepository.ApplyDetectionAsync`. A game the App adds is scanned on the next tick (the App writes the
|
||||
> `IGameRepository.ApplyDetectionAsync`. *A missing executable is asked one more question before it is skipped
|
||||
> (2026-09-22): is the same file — same size, same mtime — under exactly one other drive letter? When it is, the row
|
||||
> follows it (`ExecutableRelocator`, `19_SAFETY` §A moved drive is the same executable) and this very pass scans
|
||||
> it there; `DetectionSweepReport.Relocated` counts them.* A game the App adds is scanned on the next tick (the App writes the
|
||||
> row, the Agent reads the table); no Agent running means no scan, and the game page says "not scanned yet".
|
||||
> *The key's exe half is NOT `exe_size_bytes` / `exe_mtime_ms`:* those are the consent fingerprint the gate
|
||||
> reads (`SqliteGameConsentStore` refuses a mismatch while a block stands), so schema 0004 gave the key its own
|
||||
|
||||
+23
-7
@@ -40,7 +40,9 @@ CREATE TABLE schema_migrations (version INTEGER PRIMARY KEY, applied_at INTEGER
|
||||
CREATE TABLE games (
|
||||
id INTEGER PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
exe_path TEXT NOT NULL UNIQUE,
|
||||
exe_path TEXT NOT NULL UNIQUE, -- where the executable lives; rewritten by ExecutableRelocator when the
|
||||
-- SAME bytes (exe_size_bytes, exe_mtime_ms) turn up under another drive
|
||||
-- letter (2026-09-22), and by Change executable for a DIFFERENT binary
|
||||
platform TEXT NOT NULL DEFAULT 'none', -- steam|gog|epic|itch|none
|
||||
store_id TEXT,
|
||||
engine TEXT, engine_version TEXT,
|
||||
@@ -281,12 +283,10 @@ CREATE TABLE frame_blobs (
|
||||
|
||||
CREATE TABLE sensor_blobs (
|
||||
session_id INTEGER NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
|
||||
-- (schema 0007, 2026-09-21 - 19_SAFETY §The user's bypass) lives on TWO tables and nowhere else:
|
||||
-- games.guard_bypass_at INTEGER, games.guard_bypass_disclosure_version TEXT NOT NULL DEFAULT ''
|
||||
-- NULL/'' = off, every row's default. Both or neither: a timestamp without its version is not an
|
||||
-- acknowledgement. Written only through IGuardBypassStore; cleared by revoking consent and by Change executable.
|
||||
-- sessions.guard_bypassed INTEGER NOT NULL DEFAULT 0, guard_bypass_family TEXT, guard_bypass_signal TEXT
|
||||
-- 1 when the session STARTED under the bypass. A session recovered from a .partial does not carry it.
|
||||
-- schema 0007 (2026-09-21) added five guard-override columns (games.guard_bypass_at,
|
||||
-- games.guard_bypass_disclosure_version; sessions.guard_bypassed, guard_bypass_family, guard_bypass_signal) and
|
||||
-- schema 0008 (2026-09-22) DROPPED them with the feature (19_SAFETY §What a finding does to the game). Sessions that
|
||||
-- ran under it keep "guard-bypass=" in capture_notes.
|
||||
series TEXT NOT NULL, -- cpu_temp|gpu_temp|gpu_hotspot|gpu_load|gpu_power|vram_proc|vram_adapter|cpu_load|ram_mb
|
||||
-- cpu_load / ram_mb / cpu_temp and sessions.avg_cpu_load, avg_cpu_temp, max_cpu_temp,
|
||||
-- avg_ram_mb were in schema 0001 with NO producer until 2026-09-21 (Telemetry.SystemTelemetrySource
|
||||
@@ -389,6 +389,16 @@ Because Tier-1 and Tier-2 sessions carry different fields, every query that comp
|
||||
> column computed from the prefix exactly as a live finalize would. **Rejected:** a `sessions_in_progress`
|
||||
> table — a blob churn every minute, a lock fight with the UI in P3, and `04_CAPTURE` had already named a
|
||||
> file under `tmp\`.
|
||||
>
|
||||
> **The header's `game_id` is where the session started, not necessarily where it lands (2026-09-23).** A live
|
||||
> finalize and a recovery both ask `ISessionRepository.ResolveOwnerAsync`: that id when the row predates the session
|
||||
> or holds the header's exe path; else the row that holds the exe path now (an entry removed and re-imported while
|
||||
> the game ran); else nothing — `FinalizeStatus.GameRemoved` / `RecoveryStatus.GameRemoved`, file deleted, nothing
|
||||
> written. `games.id` is `INTEGER PRIMARY KEY` without AUTOINCREMENT, so a deleted id can be handed to the next row
|
||||
> added; `added_at` after the session's start and another path is how that row is told apart. A file recovery cannot
|
||||
> finalize for any other reason is renamed `<guid>.partial.failed` (`IPartialSessionStore.Quarantine`) — not listed
|
||||
> again, not retried, kept for a bug report — and recovery goes on to the next file: it runs before the watcher on
|
||||
> every start, and one file used to be able to stop them all.
|
||||
|
||||
## Retention
|
||||
|
||||
@@ -447,6 +457,12 @@ Sequential embedded SQL (`Migrations/0001_init.sql`, `0002_*.sql`, …), applied
|
||||
> detail still set beside it. A reader that ignores the scope reads a steady factor as a session one, which is why
|
||||
> every surface prints the share. Existing rows keep NULL. `LatestVersion` is 6.
|
||||
|
||||
> **`0007_guard_bypass.sql` (2026-09-21) and `0008_withdraw_guard_bypass.sql` (2026-09-22) — the first DROP.** 0007
|
||||
> added five columns for the per-game guard override; the owner withdrew the feature a day later and 0008 drops them
|
||||
> (`ALTER TABLE … DROP COLUMN`, SQLite ≥ 3.35 — `LedgerDatabaseTests` asserts the engine's version beside the columns'
|
||||
> absence). "Never edit an applied script; only append" holds: 0007 stays as applied and 0008 is the append. The
|
||||
> data dropped is the override acknowledgements themselves, which is the decision. `LatestVersion` is 8.
|
||||
|
||||
> **Every open used to migrate, and one that should not have did — 2026-09-16.** The Agent's `--console sessions`,
|
||||
> a verb that prints, was run against the owner's ledger while the file on disk was at schema 2 and applied 0003 and
|
||||
> 0004 to it. `LedgerDatabase.OpenReadOnlyAsync` exists since that day: an existing file, `PRAGMA query_only`, no
|
||||
|
||||
+3
-4
@@ -334,12 +334,11 @@ Unchanged in spirit from v1, bumped to `v2` for the new message set.
|
||||
| `Shutdown` | UI→A | graceful stop → `ShutdownAck`, then the host stops (sessions finalize inside its grace window). *(Built 2026-09-13, PR-1b: `IAgentLifetime`, the host's under `--serve`, a logged no-op under `--console`.)* |
|
||||
| `SweepRetention` | UI→A | **no payload** — a trigger, like `UpdateRules`: the Agent applies `06_DATA_MODEL` §Retention to every game with the `retention.raw_sessions_per_game` it reads itself → `SweepRetentionAck { keep, games, sessions }` (`keep` 0 = unlimited, and then nothing was swept). *(Built 2026-09-15, P4 PR-7, for Tools ▸ Database maintenance: `Application.Recording.RetentionSweep` over `ISessionRepository.SweepRetentionAllAsync`, composed into `AgentCommandHandler` under `--serve`. The client names no number because the rows are the Agent's (§Writer ownership). Additive: an older Agent answers `Error UnknownType`, which the dialog reads as "restart the Agent". Carries no safety fact.)* |
|
||||
| `SessionStarted` | A→UI | `{ sessionGuid, gameId, gameName, pid, tier, startedAt }` — **published at the attach**, i.e. when the session becomes Tier 1 and the live card has something to show; a session that never attaches has no `SessionStarted`, only its `SessionCompleted` (tier 2) and, when a refusal or error caused that, the event below that names it |
|
||||
| `SetGuardBypass` | UI→A | `{ gameId, enabled, disclosureVersion? }` → `GuardBypassAck { gameId, enabled, outcome }` (owner decision 2026-09-21, `19_SAFETY` §The user's bypass). `enabled: true` records that the user accepted the bypass disclosure for this game's executable: refused with `DisclosureVersionMismatch` for any version but the Agent's own `GuardBypassDisclosure.Version`, `ExecutableUnreadable`, `UnknownGame`, or `DisclosureUnavailable` where no store was composed; `outcome` is the store's `ConsentWriteOutcome` (`StaleFingerprint` when the binary is not the row's). `enabled: false` withdraws it. It writes two columns and enables nothing. **There is no global form of this message.** `HookEnabledAck.prescan` gains the value `"bypassed"`: the pre-scan refused, the finding was written, and the consent was stamped beside it |
|
||||
| `SessionProgress` | A→UI | 1 Hz: `{ sessionGuid, elapsedS, presents5s, presentedFps5s?, presentedQualifier, nativeFps5s?, displayedFps5s?, fgFactor?, fgMode, upscaler?, upscalerQuality?, upscalerDriverReported?, renderW/H?, outputW/H?, rtActive?, gpuTempC?, cpuTempC?, cpuLoadPct?, vramProcMb?, latencyUs?, fgRefusal?, fgRuntimeCensus? }` — a 5 s rolling window over the ring through the SAME Domain calculators the row uses (`SessionProgressCalculator`, D13). **`upscalerDriverReported` added 2026-09-21, optional:** `dlss` when the NVIDIA driver reports an NGX super-resolution feature created and evaluated in the target (`03_METRICS` §The driver-reported rung), so the live card says `DLSS (driver-reported)` where no hook can name the upscaler; identity only. **`cpuLoadPct` added 2026-09-21, optional** (CPU time busy over the last telemetry tick, 0–100; `cpuTempC` has a producer from the same date, present only when the Agent is elevated with PawnIO). **Two fields added 2026-09-14, both optional (an older client ignores them, §C):** `fgRefusal` is the row's `fg_refusal` (schema 0003) — present when `fgMode` names a technology and `fgFactor` is absent, so the live card can say "DLSS-G active — factor not counted" rather than N/A; `fgRuntimeCensus` is the raw census so the `fg_runtime_loaded` chip can name the module. **Rule 6 at the wire (2026-09-13):** `nativeFps5s` / `displayedFps5s` / `fgFactor` are present only when frame generation was measured in the window; otherwise `presentedFps5s` stands alone with `presentedQualifier` (`census_not_run` · `no_fg_runtime` · `fg_runtime_loaded` · `none_withheld`, the row's `presented_qualifier` from the same function). Every unmeasured field is absent, never 0. Suppressed when no client is connected |
|
||||
| `SessionCompleted` | A→UI | `{ sessionGuid, sessionId?, exitStatus, tier, finalize, reason }` — UI loads the full row from SQLite; `sessionId` is null and `finalize` is `discarded` when the row was not stored (under the minimum length); `exitStatus` is the row's vocabulary (`normal` · `crashed` · `unhooked_safety` · `degraded`); `reason` is the loop's `SessionEndReason` |
|
||||
| `CaptureRefused` | A→UI | `{ gameId, gameName, reason, family?, signal? }` — **guard fired**; UI shows the plain-language explanation — ~~and the Tier-2 offer~~; there is no alternative measurement to offer, only the option to record the session unmeasured (`08_UI` §Safety events). *(Built: for `RefusedByGuard`, `RefusedPreviouslyBlocked`, `RefusedKillSwitch` and `PreScanCouldNotVerify` — the last with no family, because "could not verify" is neither a hit nor a pass; `family`/`signal` are the verdict's. A game merely not enabled or not consented raises nothing: that is an ordinary Tier-2 row, not a refusal to explain.)* |
|
||||
| `SessionCompleted` | A→UI | `{ sessionGuid, sessionId?, exitStatus, tier, finalize, reason }` — UI loads the full row from SQLite; `sessionId` is null and `finalize` is `discarded` when the row was not stored (under the minimum length), or `game_removed` when its entry was removed with its sessions while it ran (2026-09-23); `exitStatus` is the row's vocabulary (`normal` · `crashed` · `unhooked_safety` · `degraded`); `reason` is the loop's `SessionEndReason` |
|
||||
| `CaptureRefused` | A→UI | `{ gameId, gameName, reason, family?, signal?, hookingTurnedOff }` — **guard fired**; `hookingTurnedOff` (2026-09-22) is true when the finding turned the game's hooking off (`19_SAFETY` §What a finding does to the game); UI shows the plain-language explanation — ~~and the Tier-2 offer~~; there is no alternative measurement to offer, only the option to record the session unmeasured (`08_UI` §Safety events). *(Built: for `RefusedByGuard`, `RefusedPreviouslyBlocked`, `RefusedKillSwitch` and `PreScanCouldNotVerify` — the last with no family, because "could not verify" is neither a hit nor a pass; `family`/`signal` are the verdict's. A game merely not enabled or not consented raises nothing: that is an ordinary Tier-2 row, not a refusal to explain.)* |
|
||||
| `CaptureDegraded` | A→UI | `{ sessionGuid, from: 1, to: 2, reason }` — Tier 1 → Tier 2 mid-flight, or overlay self-disabled. **Under a two-rung ladder this means measurement STOPPED**, not that it continued at lower fidelity, and the notice must say so. *(Built: `SupervisionLost`, `WriterSelfDisabled`, `WriterStoppedBlocklisted`, `WriterNeverInstalledHooks`, `SupervisionFaulted`, `KillSwitchEngaged` — `RecordedSessionEvents.Classify` is the table.)* |
|
||||
| `SafetyUnhook` | A→UI | `{ sessionGuid, family?, signal? }` — anti-cheat appeared mid-session; prominent UI notice. *(Built: the verdict that FIRED, not the pass that started the session — `CaptureOutcome.Verdict` carries the supervisor's last verdict on this reason since 2026-09-13.)* |
|
||||
| `SafetyUnhook` | A→UI | `{ sessionGuid, family?, signal?, hookingTurnedOff }` — anti-cheat appeared mid-session; prominent UI notice; `hookingTurnedOff` as on `CaptureRefused`. *(Built: the verdict that FIRED, not the pass that started the session — `CaptureOutcome.Verdict` carries the supervisor's last verdict on this reason since 2026-09-13.)* |
|
||||
| `CaptureError` | A→UI | `{ sessionGuid?, code, message }` — `InjectFailed`, `RingVersionMismatch`, `AttachRefused`, ~~`EtwAccessDenied`~~ (struck 2026-09-13 with the tier), ~~`PresentMonMissing`~~ (retired with the tool, 2026-08-27 — a code naming an implementation nobody chose), `TelemetryUnavailable`, `DbWriteFailed`, `SessionFaulted` (the session's task threw before finalize; the `.partial` stays for recovery, and no `SessionCompleted` follows). *(Built: `RingVersionMismatch` for a layout / record-size / build-id refusal — the "restart the game after an update" case — `AttachRefused` for the rest of the ring's refusals, `InjectFailed` for a target that could not be started, pinned, read or singled out.)* |
|
||||
| `Ping`/`Pong` | ~~both~~ UI→A | 15 s keepalive, **client-driven** (built 2026-09-13): the client pings, the Agent answers; the Agent initiates nothing on an idle connection |
|
||||
|
||||
|
||||
+7
-2
@@ -93,7 +93,12 @@ The Menu sits in its own row **below** the TitleBar (never inside the drag regio
|
||||
> duration and hardware telemetry — with every frame-derived value at N/A"). The one button is
|
||||
> `Safety_RecordWithoutMeasuring` on a refusal and Dismiss otherwise; it removes the notice and does nothing
|
||||
> else, because the Agent already records Tier 2 on a refusal (owner decision 2026-08-28) — the button is the
|
||||
> user's acknowledgement, not a second request. `CaptureError` (non-fatal) goes to the 4 s strip. The safety
|
||||
> user's acknowledgement, not a second request. *(That sentence became true on 2026-09-22: until then every
|
||||
> refused session was discarded under the minimum length, and for one day `TargetUnreadable` omitted the
|
||||
> "still recorded" sentence for that reason. `04_CAPTURE` §Tier selection.)* The session summary of a Tier-2 row
|
||||
> says WHY under its Tier-2 sentence (`Formats.Tier2Reason` over `capture_notes`: hooking off, the block on the
|
||||
> row, the guard's family and signal, a process that could not be opened, or the end reason by name —
|
||||
> `Summary_Tier2_Why_*`). `CaptureError` (non-fatal) goes to the 4 s strip. The safety
|
||||
> documentation link lives on the Settings page's Capture section rather than in every notice. Tests:
|
||||
> `SafetyNoticesTests` (the three kinds, the sentence per refusal reason, the strip for errors, nothing for a
|
||||
> session event, dismiss only by the user).
|
||||
@@ -163,7 +168,7 @@ All screens are `Page`s registered with the navigation page provider and navigat
|
||||
> fields), **the row's executable path under the subtitle and Change executable… since 2026-09-21** (a store import
|
||||
> guesses the executable and everything downstream is keyed on it; the pick re-points the row, which comes back
|
||||
> hooking-off and unconsented like a new game, consent revoked over the pipe first, a block never cleared —
|
||||
> `05_DETECTION` §Library import), **one App per data folder since 2026-09-21** (`Services.SingleInstance`: a named mutex and a named event keyed on a hash of the data directory, claimed in `Program.Main` after Velopack's hooks and before any window; a later start sets the event and exits 0, and the first instance brings its window forward through `ShellHost.Reveal` — from the tray too. Nothing stopped a second App before: the owner's log shows two started 360 ms apart, two tray icons, a second log file. `--diag` never claims), **the guard-bypass switch since 2026-09-21** (`19_SAFETY` §The user's bypass, FR-2.7: a `CardControl` with a `OneWay` toggle under the hooking card, its body text, and — while it is on — a non-closable **Error** `InfoBar` saying so; ON opens `GuardBypassPrompt`, a `ContentDialog` whose Danger primary button is enabled only while the acknowledgement is ticked AND `BYPASS` is typed, `DefaultButton = Close`; OFF needs no dialog; the switch shows the ROW, never the click; a blocked row's hooking toggle becomes usable while the bypass is on and the block's text stays on the page — as "The guard found: … You chose to bypass it", not as "Hooking is disabled for this game", which is what beta.3 printed beside a hooking switch that was ON; a session that started under it reads "· Guard bypassed: <family>" in the list's exit column and carries an Error `InfoBar` in its summary), **Supports** (from `capability_flags`; ~~empty until P4's scan writes it, and the card says so~~ **written by the Agent's detection sweep since P4 PR-1, 2026-09-14** — the rule ids as product names via `CapabilityNames`, "not scanned yet" only until the Agent's next tick) beside
|
||||
> `05_DETECTION` §Library import), **one App per data folder since 2026-09-21** (`Services.SingleInstance`: a named mutex and a named event keyed on a hash of the data directory, claimed in `Program.Main` after Velopack's hooks and before any window; a later start sets the event and exits 0, and the first instance brings its window forward through `ShellHost.Reveal` — from the tray too. Nothing stopped a second App before: the owner's log shows two started 360 ms apart, two tray icons, a second log file. `--diag` never claims), ~~**the guard-bypass switch since 2026-09-21**~~ **withdrawn 2026-09-22** (the card, its dialog, the session mark and the export line are gone; a blocked row's toggle is disabled and `Safety_Blocked_Toggle_Format` is the whole story; a refusal or unhook notice that turned hooking off ends with `Safety_HookingTurnedOff` — `19_SAFETY` §What a finding does to the game), **Supports** (from `capability_flags`; ~~empty until P4's scan writes it, and the card says so~~ **written by the Agent's detection sweep since P4 PR-1, 2026-09-14** — the rule ids as product names via `CapabilityNames`, "not scanned yet" only until the Agent's next tick) beside
|
||||
> **Last session measured** (upscaler · resolution, frame generation, the non-N/A chips — accent pills, from the
|
||||
> hooks). Hooking: the toggle is `OneWay` from the row and its command runs `HookingConsent`; a refusal, a
|
||||
> mismatch or a failure is a persistent `InfoBar` on the page (never a toast); a blocked row disables the
|
||||
|
||||
+1
-1
@@ -6,7 +6,7 @@ Languages: **en** (neutral/default) · **vi** · **ja**. Same `.resx` pattern as
|
||||
> AND `FrameLedger.Shared.Strings.Culture`. The second was missing: the safety family fell back to the thread's
|
||||
> `CurrentUICulture`, and a culture set inside the App's async start flows with that async context, not to the
|
||||
> dispatcher's later operations — so on an English Windows a Vietnamese UI showed the consent dialog, the refusal
|
||||
> notices and the guard-bypass card in English. A resource accessor that depends on which thread asks is the defect;
|
||||
> notices in English (and, for one day, a guard-override card). A resource accessor that depends on which thread asks is the defect;
|
||||
> `StringsTests.ApplyingTheUiLanguageSetsTheSafetyFamilyToo` holds it with the thread deliberately left English.
|
||||
|
||||
## Mechanics
|
||||
|
||||
+2
-2
@@ -9,12 +9,12 @@ The anti-cheat guard is the one component where a bug can cost someone an accoun
|
||||
**These are Catch2 tests, not xUnit.** `20_OPEN_QUESTIONS` §S13(a) settled the guard into the C++ `FrameLedger.Injector`, so the fail-closed matrix below lives in the native suite and the guard needs seams — injectable enumerator function pointers — before any of these failures can be forced at all. ~~Landing Catch2 is a prerequisite of the guard, not a later nicety (§S15).~~ **Landed long since** — `ctest` runs 31 native suites on every gate (`fl_guard` alone is ~100 s); the sentence was left in the future tense until 2026-09-21.
|
||||
|
||||
- Blocklist matching: exact, case-insensitive, prefix rules; every family in `19_SAFETY` §Blocklist seed has a fixture. Two families (Activision Ricochet, Valve VAC) have **no data yet**, so their fixtures must assert that absence explicitly rather than quietly passing on an empty rule set.
|
||||
- **The user's bypass (2026-09-21) has its own proofs, and they are about what it must NOT do.** Native (`[bypass]` in `guard_test.cpp`): a blocklisted target is refused by the plain entry and injected by the acknowledged one with the same family and signal and a verdict that is not `kAllow`; a clean target is a plain allow; a foreign or absent payload is still refused and nothing is loaded; `IsGuardJudgement` is exactly its list. Managed: `GuardMirrorTests` holds the C# list against the native one for every reason; `HookedCaptureGateTests` proves the kill switch, an un-enabled game and a missing consent still refuse with the guard never asked, that an acknowledged request never takes the plain entry (and the reverse), and that a guard which does not know the bypass is the hard gate (the port's default implementation); `HookRequestFromConsentTests` that the fifth input needs a stored record naming its disclosure and the same executable; `GuardSupervisorTests` that a judgement is counted, kept and overruled while a fact still unhooks; `SqliteGuardBypassStoreTests` that it cannot exist for a game nobody added or another binary, touches neither block nor consent, and ends with consent or the executable; `AgentCommandHandlerTests` that the pipe re-checks everything; `GameDetailViewModelTests` that a declined disclosure sends nothing and the switch shows the row.
|
||||
- **A finding turns the game's hooking off (2026-09-22), and the proofs are about WHICH findings.** `AntiCheatVerdictTests` pins `IsFindingAboutTheGame` per reason (in the game: yes; machine-wide driver or service, heuristics, failed scans, the latch: no) and that a finding without a family is not one; `CaptureSessionTests` that a start-time `BlockedModule` writes the block, keeps the consent stamp and says `HookingTurnedOff`, that a `BlockedDriver` refuses the session and leaves the row alone, and that the 30 s re-scan's finding writes the same block; `RecordedSessionEventsTests` and `SafetyNoticesTests` that the flag travels to the notice. The override of 2026-09-21 had its own proofs for one day; they went with it, and `NoSecondMatcherTests` counts the port's four methods again.
|
||||
- **Fail-closed proofs:** malformed `detection-rules.json`, missing `anticheat` block, unreadable target process, `EnumProcessModulesEx` failure, partial module list → **all must refuse injection**, never allow. Each is a named test.
|
||||
- **Measured error paths that must be named tests** (`spike-notes.md` §1): `ERROR_PARTIAL_COPY (299)` from a suspended target, `ERROR_ACCESS_DENIED (5)` from a protected one, a driver-list parse whose paths are not native paths, and a service query returning `ACCESS_DENIED` — the last of which **cannot be produced on real services by a standard user**, so it exists only as a fake. Every one means REFUSE.
|
||||
- Mid-session detection: simulated late-loading anti-cheat module → `unhookRequested` set, hooks disabled within one frame, session finalized `unhooked_safety`. Cover the **driver** scan too, not only modules: a machine-wide driver can start after injection.
|
||||
- **Absence-of-override test:** no code path may reach the injection primitive without a passing guard result. The mechanism previously described here — a `sealed` token type "only the guard can produce" — does not work and was disproved by compiling (`20_OPEN_QUESTIONS` §S8: C# accessibility flows inward, `CS0122`). The replacement is structural: the guard **owns the chokepoint** and calls the primitive itself, the primitive has internal linkage in the guard's own translation unit so no other TU has a symbol to call, and a build-time check asserts that nothing else references it. A token that escapes can be ignored; a symbol that does not exist cannot.
|
||||
- Static pre-scan: a game directory containing `EasyAntiCheat/` renders `hook_enabled` un-settable; API-level attempt to set it is rejected — including via `SetWatchlist`, which no longer carries hooking state at all (`07_IPC` §The pipe is not a trust boundary). ~~**The toggle half needs persistence and is not built yet**~~ **built in P2/P3**: `SqliteGameConsentStore.RecordGuardBlockAsync` forces `hook_enabled = 0`, `AgentCommandHandler.SetHookEnabledAsync` re-runs the pre-scan and answers `Refused`, and `GameDetailViewModel` disables the toggle on a blocked row (corrected 2026-09-21; the one way past it is `19_SAFETY` §The user's bypass); the scan itself is ctest `fl_prescan`, whose matrix is mostly fail-closed: a listing that FAILED, one that was TRUNCATED, a directory that could not be established, unusable rules, and a missing evidence source must each be *undetermined*, never clean. Two cases exist only to stop the rest passing vacuously — a genuinely clean directory must be **allowed**, and a name matching the wrong group (a directory named like a `files` entry) must **not** fire. One case removes a family from the rules and asserts the hit disappears, which is what proves there is a single matcher rather than a second one that happens to agree.
|
||||
- Static pre-scan: a game directory containing `EasyAntiCheat/` renders `hook_enabled` un-settable; API-level attempt to set it is rejected — including via `SetWatchlist`, which no longer carries hooking state at all (`07_IPC` §The pipe is not a trust boundary). ~~**The toggle half needs persistence and is not built yet**~~ **built in P2/P3**: `SqliteGameConsentStore.RecordGuardBlockAsync` forces `hook_enabled = 0`, `AgentCommandHandler.SetHookEnabledAsync` re-runs the pre-scan and answers `Refused`, and `GameDetailViewModel` disables the toggle on a blocked row (corrected 2026-09-21; since 2026-09-22 a finding at a session's start or at the re-scan writes the same block — `CaptureSessionTests`); the scan itself is ctest `fl_prescan`, whose matrix is mostly fail-closed: a listing that FAILED, one that was TRUNCATED, a directory that could not be established, unusable rules, and a missing evidence source must each be *undetermined*, never clean. Two cases exist only to stop the rest passing vacuously — a genuinely clean directory must be **allowed**, and a name matching the wrong group (a directory named like a `files` entry) must **not** fire. One case removes a family from the rules and asserts the hit disappears, which is what proves there is a single matcher rather than a second one that happens to agree.
|
||||
|
||||
## Native unit tests (Catch2)
|
||||
|
||||
|
||||
@@ -18,7 +18,7 @@ These are permanently out of scope. A PR implementing any of them is rejected re
|
||||
- Hiding, renaming, or randomizing the DLL, its exports, or its shared-memory object names
|
||||
- Thread hiding (`NtSetInformationThread`/`ThreadHideFromDebugger`) or debugger-evasion tricks
|
||||
- Signature-breaking obfuscation/packing of our own binaries
|
||||
- Any "stealth mode", or documentation explaining how to defeat the guard below. *(This line also read "'bypass' setting" until 2026-09-21. The owner decided that day that one bypass exists — §The user's bypass, under the guard — and what stays on THIS list is everything that would make FrameLedger harder to see: that bypass changes whether we inject, never how.)*
|
||||
- Any "bypass" setting, "stealth mode", or documentation explaining how to defeat the guard below. *(The first two words left this line on 2026-09-21 and returned on 2026-09-22 — §What a finding does to the game.)*
|
||||
- Reading or writing game memory outside the arguments of APIs we hooked
|
||||
- Kernel drivers of our own
|
||||
|
||||
@@ -348,54 +348,50 @@ the injection primitive, not a fifth question about the title.
|
||||
- **Absent** is still `kInjectionFailed`, not `kPayloadNotOurs`. A damaged install
|
||||
and a misuse of the ABI are different problems and must not share a reason.
|
||||
|
||||
> ~~There is no override.~~ **There is one, since 2026-09-21, and it is none of the things this paragraph named**: still no hidden setting, no config-file flag, no CLI switch, no "advanced users" escape hatch, no global form. If a user disagrees with a specific entry, the path is still a GitHub issue against the rules file, reviewed in public. What exists is below.
|
||||
> **There is no override.** ~~There is one, since 2026-09-21, and it is none of the things this paragraph named~~ *(one day; withdrawn 2026-09-22)*: still no hidden setting, no config-file flag, no CLI switch, no "advanced users" escape hatch, no global form. If a user disagrees with a specific entry, the path is still a GitHub issue against the rules file, reviewed in public. What exists is below.
|
||||
|
||||
### The user's bypass — owner decision 2026-09-21
|
||||
### What a finding does to the game — owner decision 2026-09-22
|
||||
|
||||
The owner asked for a mode that skips the guard at the user's own risk, behind a warning the user MUST accept first. This section is that mode's whole specification; CLAUDE.md rule 2 carries the same constraints as a rule.
|
||||
**The per-game override of 2026-09-21 is withdrawn.** It shipped in `0.1.0-beta.3` and `beta.4`. Its first real use
|
||||
(D21, below) showed that it could not reach a process an anti-cheat driver protects, and where it could inject it only
|
||||
exposed the user to the risk its own disclosure described. The owner withdrew it on 2026-09-22: the native entries, the
|
||||
pipe message, the App's dialog and card, the strings and the five columns of schema 0007 are gone (schema 0008 drops
|
||||
them). Sessions that ran under it keep `guard-bypass=` in `capture_notes`; nothing else remembers it.
|
||||
|
||||
**What it is.** A per-game switch on the game's page, **off by default**, that lets a user overrule the guard's *judgement* for that one game. With it on, the Agent reaches the guard through `FlGuardedInjectAcknowledged` / `FlGuardedInjectWhenReadyAcknowledged` instead of the plain entries. The guard still runs **every** check in the same order. Where the evaluation refuses with a reason `fl::guard::IsGuardJudgement` accepts, the injection proceeds and the verdict is **`AllowedUnderUserBypass` (28)** — `family` and `signal` still name what was found. It is not `Allow`: `Verdict::Allowed()` and `AntiCheatVerdict.IsAllowed` stay false for it, so every caller written before it existed keeps refusing, and `CaptureSession` — the one caller that may proceed — asks `IsAllowedUnderBypass` by name.
|
||||
**What replaced it is the opposite of an override: a finding turns the game's hooking off.** The pre-scan has done
|
||||
this since P2 (`RecordGuardBlockAsync`: `hook_enabled = 0`, `hook_blocked_reason`, `hook_prescan_state = 'blocked'`).
|
||||
The two later moments the guard can find something now write the same block:
|
||||
|
||||
**What it overrules: a judgement. What it never overrules: a fact.**
|
||||
| Moment | Where | What it sees |
|
||||
|---|---|---|
|
||||
| hooking is turned on | `AgentCommandHandler.SetHookEnabledAsync` | check 4 over the game's folder |
|
||||
| a session starts | `CaptureSession.SessionAsync`, after the gate | checks 1–4 over the live process, its tree, the drivers, the folder |
|
||||
| the 30 s re-scan | `CaptureSession.DrainAsync`, on a `SafetyUnhook` | the same, for an anti-cheat that loaded late |
|
||||
|
||||
| Overruled (the guard's judgement) | Never overruled |
|
||||
|---|---|
|
||||
| `BlockedModule`, `BlockedDriver`, `BlockedService`, `BlockedExecutable`, `BlockedStoreId`, `AntiCheatDirectory`, `AntiCheatFile`, `SuspiciousUnsigned` | `KillSwitchEngaged` (FR-2.4 outranks everything) |
|
||||
| the scans that could not look, which the guard treats as findings: `ModuleScanFailed`, `ProcessUnreadable`, `ProcessTreeUnavailable`, `DriverScanFailed`, `ServiceQueryFailed`, `PreScanFailed` | `HookNotEnabled`, `ConsentMissing` — the bypass is not a second way to enable or to consent |
|
||||
| unusable rules: `RulesUnreadable`, `RulesMalformed`, `RulesIncomplete` | `PayloadNotOurs` — no acknowledgement loads a foreign DLL (§S22 stands) |
|
||||
| the latch a past judgement left on the row: `PreviouslyBlocked`, and the pre-scan's "could not verify" | `TargetIsWow64`, `InjectionFailed`, `LaunchTargetExited`, `LaunchNoPresentationRuntime` |
|
||||
| | **a Vulkan title the guard refuses**: the layer has its own in-process guard, and this path does not talk past it |
|
||||
**Which findings** — `AntiCheatVerdict.IsFindingAboutTheGame`: an anti-cheat *named* (family non-empty) in the game's
|
||||
own process (`BlockedModule`), on its title lists (`BlockedExecutable`, `BlockedStoreId`) or in its folder
|
||||
(`AntiCheatDirectory`, `AntiCheatFile`). **Not** a machine-wide driver or service (`BlockedDriver`, `BlockedService`):
|
||||
a driver running for another game says nothing about this one, so that refuses this session and writes nothing. Not a
|
||||
scan that could not look, not unusable rules, not the unsigned-module heuristic, not the latch of an earlier block.
|
||||
|
||||
The list exists twice — `fl::guard::IsGuardJudgement` and `AntiCheatVerdict.IsGuardJudgement` — and `GuardMirrorTests` holds them against each other for every reason through the exported `FlGuardIsJudgement`. `PreviouslyBlocked` is the one deliberate difference: managed-only, because the native guard never produces it.
|
||||
**What the user sees.** The refusal or unhook notice ends with `Safety_HookingTurnedOff`; the game's page shows the
|
||||
block (`Safety_Blocked_Toggle_Format`) with the toggle disabled; `capture_notes` carry
|
||||
`hooking-turned-off=<reason>/<family>`; the Agent's session line carries `; hooking-turned-off`; `CaptureRefused` and
|
||||
`SafetyUnhook` carry `hookingTurnedOff` (`07_IPC`). `CaptureOutcome.HookingTurnedOff` is the loop's word for it.
|
||||
|
||||
**How it is turned on — a recorded human act, the shape consent has.**
|
||||
1. The App shows its own disclosure (`GuardBypassPrompt`, text in `FrameLedger.Shared` `Safety_Bypass_*`, reviewed as the safety text it is; `ja` ships the English until a reviewer signs, `09_I18N`). It states what the guard found for THIS game, that anti-cheat treats a loaded DLL as tampering whatever it does, that the account can be flagged, suspended or **permanently banned** without warning or appeal, that FrameLedger does not hide and never will, and — in the owner's words — that **by turning it on the user accepts the entire risk and the developers accept no responsibility or liability** for anything that follows.
|
||||
2. The primary button is the Danger one and is enabled only while **both** acts are performed: a ticked acknowledgement **and** the typed phrase `BYPASS` (`GuardBypassDisclosure.ConfirmationPhrase`, the same five letters in every language). Enter keeps the guard on.
|
||||
3. The App writes nothing. It sends `SetGuardBypass` (`07_IPC`); the Agent refuses any disclosure version but its own (`GuardBypassDisclosure.Version`), re-reads the executable, and stamps `games.guard_bypass_at` + `guard_bypass_disclosure_version` (schema 0007) through `IGuardBypassStore` — a port of its own, so nothing that can grant consent can by the same call overrule the guard.
|
||||
4. It enables nothing. Hooking is still its own switch and its own FR-2.1 dialog; with the bypass recorded, `SetHookEnabled` still runs the pre-scan and **still writes the finding** (`hook_blocked_reason` stays on the row and stays true) and then stamps the consent beside it, answering `prescan: "bypassed"`.
|
||||
**What clears it.** Nothing, as before: the block outlives *Change executable* and a re-import (§A game already enabled
|
||||
can become blocked later). The owner asked for hooking to be turned off when anti-cheat is detected, not for a second
|
||||
switch.
|
||||
|
||||
**What it cannot do, measured on its first real use (2026-09-21, the owner, ELDEN RING under Easy Anti-Cheat).** A
|
||||
kernel anti-cheat does not only detect a loaded DLL; its driver strips other processes' handles to the game. From the
|
||||
Agent that looks like this: the watcher sees the process (its image path is readable with limited rights), and
|
||||
`TargetResolver` cannot read its main module — every candidate exists and none can be opened. That is
|
||||
`SessionEndReason.TargetUnreadable` since 2026-09-21 (it was reported as `TargetAmbiguous`, "more than one process is
|
||||
running it", about one process; reached the user as a toast reading `InjectFailed: TargetAmbiguous`; and the one-second
|
||||
session was discarded for being short — so with the bypass ON the whole visible result was nothing). **The bypass does
|
||||
not change this and nothing will be built that does**: it overrules FrameLedger's own refusal, and a process another
|
||||
product's driver has closed to us stays closed — opening it anyway would be defeating that product, which is rule 3,
|
||||
not rule 2. The user now gets a persistent notice that says so (`Safety_Refused_TargetUnreadable`), the bypass
|
||||
disclosure says it before they accept (`GuardBypassDisclosure.Version` is `/2` for that sentence), and
|
||||
`legal/DISCLAIMER.md` §2A says it. The same reason covers a game that runs as administrator while the Agent does not.
|
||||
**D21 stands as a fact.** A process an anti-cheat driver protects is `SessionEndReason.TargetUnreadable` (2026-09-21:
|
||||
every candidate of that name exists and none can be opened; ELDEN RING under Easy Anti-Cheat on the owner's machine).
|
||||
Nothing will be built that opens it — that would be defeating another product's protection, which is rule 3. The same
|
||||
reason covers a game that runs as administrator while the Agent does not.
|
||||
|
||||
**How it ends.** Turning the switch off (no dialog needed to restore the guard); turning hooking off (`RevokeAsync` clears it — the row returns to its safest state); the executable changing (`HookRequest.FromConsent` drops it on a fingerprint mismatch exactly as it drops consent, and *Change executable…* clears the columns).
|
||||
**What did not change.** `InjectViaLoadLibrary` keeps internal linkage in `fl_guard.cpp` and `tools/chokepoint-check.ps1`
|
||||
still finds the injection primitives in exactly that file and the evasion primitives nowhere. `IAntiCheatGuard` is back
|
||||
to four methods (`NoSecondMatcherTests`). `FloorFamilies` is untouched.
|
||||
|
||||
**During a session.** `GuardSupervisor` still scans every 30 s and the tick still counts — the Overlay's own stop is fed by it. A scan that refuses on a *judgement* is kept (`LastVerdict`), counted (`JudgementsOverruled`) and does not unhook: it is the refusal the user overruled, re-discovered. A refusal that is not a judgement still unhooks.
|
||||
|
||||
**Afterwards.** `CaptureOutcome.StartedUnderBypass` carries the start verdict; the row gets `guard_bypassed = 1`, `guard_bypass_family`, `guard_bypass_signal`, and `capture_notes` gains `guard-bypass=<family>/<signal>`. The sessions list, the session summary (an Error `InfoBar`), the CSV header and the JSON export all say so. **Recorded limit:** a session recovered from a `.partial` after an Agent crash does not carry the mark — the verdict is known only to the live loop.
|
||||
|
||||
**What did NOT change, and may not.** `InjectViaLoadLibrary` still has internal linkage in `fl_guard.cpp` and `tools/chokepoint-check.ps1` still finds the injection primitives in exactly that file and the evasion primitives nowhere. `FloorFamilies` is untouched: the bypass does not shrink what the guard looks for, so §S21 stays closed — that was a bypass a crafted *data file* performed silently; this is one a *person* performs through a disclosure, and the difference is the whole design. The rules schema still rejects any `enabled` / `severity` / `warnOnly` field. There is no global form, and none may be added.
|
||||
|
||||
**Withdrawing it.** Pre-committed: if a report shows a user reached an injection under this path without having seen the disclosure, or the mark failing to appear on a session that ran under it, the switch is removed from the App in the next release and re-enters only with the defect's test.
|
||||
|
||||
### The floor data cannot remove
|
||||
|
||||
@@ -715,7 +711,34 @@ Consent is stored per game (`games.hook_consent_at`), **stamped by the Agent, ne
|
||||
> publishing `unhookRequested`, and keeps the Vulkan layer off by never setting `FRAMELEDGER_ENABLE_VK_LAYER`
|
||||
> on a launch.
|
||||
|
||||
The default for every newly added game is **hooking off — Tier 2**. Nothing is ever injected because the user merely added a game.
|
||||
The default for every newly added game is **hooking off — Tier 2**. Nothing is ever injected because the user merely added a game — and since 2026-09-22 nothing is *opened* either: a hooking-off row's Tier-2 session is held by ~~the executable's name~~ the executable's image path in the watcher's own snapshot (2026-09-23), with no `OpenProcess`, no resolver and no gate (`04_CAPTURE` §Tier selection).
|
||||
|
||||
### A moved drive is the same executable — owner ask 2026-09-22
|
||||
|
||||
Every row is keyed on its executable's path, and consent is a record about one executable: path, size, mtime
|
||||
(`ExecutableFingerprint`). On 2026-09-21/22 the owner's external drive came back as `H:` instead of `D:`, and
|
||||
every one of 46 games read "executable unreadable" until the letter came back; a game launched from `H:` matched
|
||||
its row by file name only and ran as a stranger, keyed on the new path, with no consent. **The path is where the
|
||||
bytes live; the size and the mtime are what the consent is about.** So `ExecutableRelocator` may move a row to the
|
||||
same file under another drive-letter root — and only then — with everything kept: consent, block, pre-scan state,
|
||||
detection. The conditions are the safety of it:
|
||||
|
||||
- the file is gone from the row's path (both files present is two copies, not a move; nothing happens);
|
||||
- exactly one other root holds a file with the same size and the same mtime (two is an ambiguity, and ambiguity
|
||||
refuses, as it does in the resolver);
|
||||
- the repository's write requires the same size and mtime again (`RelocateExecutableAsync`), so no caller can point
|
||||
a consent at a different binary through it;
|
||||
- no process is opened for any of this; the relocator reads files. It is asked by the 15 s sweep, by the watcher on
|
||||
a file-name match, and by the enable-hooking command before it says "unreadable".
|
||||
- **the candidate is the row's own path with only the drive letter changed — for every caller (2026-09-23).** The
|
||||
watcher's adopt used to accept ANY running path with the row's size and mtime, and every RPG Maker MV game ships
|
||||
the same NW.js `Game.exe`, byte for byte, with the mtime an unzip keeps: a hooking-on entry whose drive was unplugged
|
||||
could have followed another game's executable, consent and all. The adopt now requires the drive-letter twin and the
|
||||
same one-candidate rule as the sweep (over the drive list plus the running file's own drive). A file-name match that
|
||||
is not adopted records nothing at all (`04_CAPTURE` §Process watcher, HANDOFF D25).
|
||||
|
||||
*Change executable* is the other operation and stays what it was: a different binary, so hooking off, consent gone,
|
||||
pre-scan not run — it is the user saying "that file", not "that file moved".
|
||||
|
||||
### A game already enabled can become blocked later
|
||||
|
||||
|
||||
@@ -34,6 +34,12 @@ Rules for this document:
|
||||
> one, so that would be a code list); and the ja text, which ships as English until a reviewer signs. **Pre-committed
|
||||
> withdrawal:** an injection reached under it without the disclosure having been shown, or a session under it that is
|
||||
> not marked, removes the switch from the App in the next release.
|
||||
>
|
||||
> **2026-09-22 — withdrawn by the owner, for a reason the pre-commitment did not list.** Its first real use (ELDEN
|
||||
> RING under Easy Anti-Cheat) reached `TargetUnreadable`: the switch could not do anything where it was wanted, and
|
||||
> where it could inject it only exposed the user. The owner asked for the opposite: a finding turns the game's hooking
|
||||
> off, wherever the guard makes it. `19_SAFETY` §What a finding does to the game is the specification; CLAUDE.md rule 2 is
|
||||
> unstruck. The two open items above (kernel-level families, the ja text) are moot.
|
||||
|
||||
| # | Decision | Consequence |
|
||||
|---|---|---|
|
||||
|
||||
+77
-12
@@ -1361,7 +1361,7 @@ charts (6) after Games (5) because the summary opens from the Sessions tab; Sett
|
||||
*PRs #204-#210. Status is where status lives (`CHANGELOG.md` `[0.1.0-beta.3]`); this is only what no other file carries.*
|
||||
|
||||
**Decisions (owner, 2026-09-21).**
|
||||
- **D18 — the guard has one override, and its shape is fixed.** Per game, off by default, never global, a two-act
|
||||
- ~~**D18 — the guard has one override, and its shape is fixed.**~~ **Withdrawn 2026-09-22 (D22, below).** Per game, off by default, never global, a two-act
|
||||
disclosure stamped by the Agent, overruling the guard's JUDGEMENT only, never changing HOW FrameLedger injects.
|
||||
`19_SAFETY` §The user's bypass is the specification and CLAUDE.md rule 2 carries it as a rule. The owner chose this
|
||||
over a global switch and over a variant that kept kernel-level families refused. **Do not widen it**: no settings key,
|
||||
@@ -1372,9 +1372,9 @@ charts (6) after Games (5) because the summary opens from the Sessions tab; Sett
|
||||
`--diag` and Settings ▸ System (with Copy) carry it instead.
|
||||
|
||||
**Owed by the owner after this release.** `20_OPEN_QUESTIONS` M10 (one elevated session with PawnIO beside a reference
|
||||
tool decides whether `cpu_temp` stays); a look at the light theme's pills, the bypass dialog and Settings ▸ System in the
|
||||
running App — no FrameLedger binary was run against the owner's data folder in the session that built them; the ja
|
||||
review of `Safety_Bypass_*`, which ships as English until signed.
|
||||
tool decides whether `cpu_temp` stays); a look at the light theme's pills ~~, the bypass dialog~~ and Settings ▸ System in the
|
||||
running App — no FrameLedger binary was run against the owner's data folder in the session that built them ~~; the ja
|
||||
review of `Safety_Bypass_*`, which ships as English until signed~~ (moot since 2026-09-22: the strings are gone).
|
||||
|
||||
**Traps.**
|
||||
- **xUnit.net v3 4.x defaults to Microsoft Testing Platform v2.** `build.ps1` is VSTest-shaped (collector, `results.trx`);
|
||||
@@ -1394,16 +1394,13 @@ review of `Safety_Bypass_*`, which ships as English until signed.
|
||||
|
||||
*Status is `CHANGELOG.md` `[0.1.0-beta.4]`; this is what no other file carries.*
|
||||
|
||||
**Decision (D21).** A process an anti-cheat driver protects is `TargetUnreadable`, and **the bypass stops there**: D18's
|
||||
override overrules FrameLedger's own guard; it is not, and may not become, a way past another product's protection.
|
||||
Any proposal to "make the bypass work on EAC titles" is rule 3, not rule 2 — refuse it.
|
||||
**Decision (D21).** A process an anti-cheat driver protects is `TargetUnreadable`, and nothing FrameLedger offers changes
|
||||
that: it is not, and may not become, a way past another product's protection (rule 3, not rule 2). ~~"the bypass
|
||||
stops there"~~ — the override itself is gone since 2026-09-22 (D22).
|
||||
|
||||
**Found and NOT fixed — each needs its own PR.**
|
||||
- **A refused session is not recorded, though the notice says it is.** `Notice_Refused_Recording` ("the session is still
|
||||
recorded — duration and hardware telemetry") is appended to every refusal, and `CaptureSession` returns at the
|
||||
refusal: the run lasts about a second and `SessionFinalizer` discards it as under the minimum length. CLAUDE.md's
|
||||
Tier 2 ("duration + sensors + the reason") has no producer for a refusal. The new `TargetUnreadable` notice does not
|
||||
make the claim; the older refusals still do.
|
||||
- ~~**A refused session is not recorded, though the notice says it is.**~~ **Fixed 2026-09-22 (D23):** the loop holds a
|
||||
refused session open until the target exits, so Tier 2 has a producer and the sentence is true for every refusal.
|
||||
- **A released Overlay logs its build as `v0.1.0-beta.3-dirty`**: the CI checkout is dirty by the time CMake runs
|
||||
`git describe`. Both sides of the handshake compile the same string, so nothing breaks; it is a release that calls
|
||||
itself dirty.
|
||||
@@ -1432,6 +1429,74 @@ Any proposal to "make the bypass work on EAC titles" is rule 3, not rule 2 — r
|
||||
- **`Mutex` is thread-affine**: `SingleInstance` is claimed and disposed on `Main`'s thread; its tests are synchronous
|
||||
on purpose.
|
||||
|
||||
## 2026-09-22 — the override withdrawn; a finding turns hooking off; Tier 2 exists; a moved drive is followed
|
||||
|
||||
*Status is `CHANGELOG.md` `[0.1.0-beta.5]`; this is what no other file carries.*
|
||||
|
||||
**Decision (D23, owner: "Tier 2 does not work — what does it record, and show it").** Tier 2 is now a held session
|
||||
(`04_CAPTURE` §Tier selection): duration, telemetry and the reason, saved under the same 30 s rule as Tier 1. **Two
|
||||
choices inside it that a later session may want to revisit:** (a) *every* library row is still watched, so a
|
||||
hooking-off game accumulates play-time rows — the documented behaviour (`06_DATA_MODEL` "0 = Tier 2"), kept; the
|
||||
alternative, watching only rows the user enabled or FrameLedger itself disabled, is one predicate in
|
||||
`CaptureOrchestrator` and a doc change; (b) a hooking-off row is decided BEFORE the process is opened, so an
|
||||
elevated utility in the library (the owner's Borderless Gaming) is a quiet Tier-2 row rather than a red notice — and
|
||||
`SteamLibrarySource.KnownTools` keeps the next import from adding one. The owner's existing Borderless Gaming row is
|
||||
theirs to remove.
|
||||
|
||||
**Decision (D24, owner: "handle the drive changing its letter while the data does not").** A row may follow its
|
||||
executable to another drive-letter root when the file is gone from the row's path and exactly one other root holds a
|
||||
file with the same size and mtime — with consent, block and detection kept (`19_SAFETY` §A moved drive is the same
|
||||
executable). Three callers: the 15 s sweep, the watcher's file-name match, the enable-hooking command. The owner's
|
||||
log of the same morning is the case: 46 rows unreadable on `D:` while the drive sat on `H:`, GF2 and ELDEN RING
|
||||
running from `H:` "BY FILE NAME ONLY". **Not done, on purpose:** re-import does not merge a duplicate row an earlier
|
||||
re-scan created at the new path (`LibraryImporter` still dedupes on path); the relocator refuses to move onto a path
|
||||
another row owns and says so in the log.
|
||||
|
||||
**Trap.** `FakeIdentity` in three test classes answers the same fingerprint for ANY path; a relocation test needs one
|
||||
that answers per path, or the "exactly one candidate" rule reads every root as a match.
|
||||
|
||||
**Decision (D22, owner).** The per-game guard override (D18) is withdrawn entirely — the owner's words: a switch that
|
||||
can be turned on and still does nothing is meaningless. In its place a finding about the game turns that game's hooking
|
||||
off, at the pre-scan (as before), at a session's start and at the 30 s re-scan (new): `19_SAFETY` §What a finding does to the game.
|
||||
Machine-wide drivers and services refuse the session only. D18 and D21's "the bypass stops there" are history; D21's
|
||||
fact stands.
|
||||
|
||||
**Traps.**
|
||||
- **Removing an enum value that is LAST on both sides of the ABI renumbers nothing**, and `GuardMirrorTests` fails until
|
||||
the native DLL in the test output is rebuilt (`./build.ps1 native`) — it looks like a managed defect and is not.
|
||||
- **The first `DROP COLUMN` migration.** SQLite ≥ 3.35 is asserted in `LedgerDatabaseTests`. The test helper
|
||||
`RewindSchemaAsync` deletes `schema_migrations` rows and leaves columns in place; a rewind to below 8 followed by a
|
||||
re-migration would run 0008 against columns that are gone. Today it rewinds to 2 and never re-migrates.
|
||||
- **Meziantou MA0004 fires on the SECOND await of a test method** once a lambda inside it used `ConfigureAwait(false)`.
|
||||
- **A patch script must not carry `\r\n` inside a bash heredoc**; the helper module is written with the Write tool.
|
||||
|
||||
## 2026-09-23 — the beta.6 train: a file name is not an identity, one entry per executable, Tier 2 shown live
|
||||
|
||||
*Status is `CHANGELOG.md` `[Unreleased]` until the tag; this is what no other file carries. The owner's list and the
|
||||
evidence behind each item are in the approved plan the PRs cite; the decisions it took are D25–D28.*
|
||||
|
||||
**Decision (D25, owner: "HELLO, HELLO WORLD! was recorded as Flower in Us, twice").** A file name is not an identity:
|
||||
a process that matches an entry by file name only starts nothing unless the relocator moves that entry to it, and the
|
||||
relocator accepts only the entry's own path with its drive letter changed. The stranger session is gone (it created a
|
||||
wrongly-named entry through `SessionRecorder`'s `EnsureAsync`); the running table is keyed by executable path; the
|
||||
launch election registers its session and defers to the watcher's. **What it costs:** a game whose FOLDER moved records
|
||||
nothing until *Change executable* — accepted, because the alternative is exactly what put HHW's sessions under Flower
|
||||
in Us. **D28 (owner, same day):** HHW itself is measured by pointing an entry at `swiftshader\Game.exe` (the NW.js
|
||||
runtime its .NET launcher starts); no launcher-following in beta.6.
|
||||
|
||||
**Traps.**
|
||||
- **`FakeIdentity` in `CaptureOrchestratorTests` answers every path with the same bytes — which is exactly the hazard
|
||||
D25 closed**, so it is the right fake for "identical bytes in another folder are another game" and the wrong one for
|
||||
any test that needs a relocation to succeed (use `ExecutableRelocatorTests.DiskByPath`).
|
||||
- **A background service that throws stops the Agent's host, and until 2026-09-23 it said so nowhere.** The Generic
|
||||
Host's default `BackgroundServiceExceptionBehavior` is `StopHost`, and `ServeAsync` never routed
|
||||
Microsoft.Extensions.Logging into Serilog, so the reason reached no file. `WatcherHostedService` runs recovery before
|
||||
the watcher: one `.partial` whose finalize threw would have stopped every start, and the App would have started a new
|
||||
Agent into the same failure each time. `PartialRecovery` never throws now, and the host logs through `AddSerilog`.
|
||||
- **Removing an entry while its game runs used to lose the session.** Both of the owner's GIRLS' FRONTLINE 2 faults
|
||||
were a removal (to clean up an `H:` twin) under a running session. The finalize now resolves the owner; a test that
|
||||
deletes a row mid-session must expect `GameRemoved` or a re-keyed row, never an exception.
|
||||
|
||||
## Owner-only — no PR can close these
|
||||
|
||||
1. **§S23-2 — branch protection.** `Rules / validate` is not a required status check on
|
||||
|
||||
+7
-9
@@ -11,12 +11,11 @@
|
||||
that changes what FrameLedger.Overlay or the capture host does; date the change.
|
||||
HTML comments are not part of the block.
|
||||
-->
|
||||
> ⚠ **What FrameLedger actually measures today — 2026-09-21.** The software is a beta; its latest
|
||||
> **pre-release is `0.1.0-beta.4`** (2026-09-21), an unsigned installer built from that tag with its
|
||||
> ⚠ **What FrameLedger actually measures today — 2026-09-22.** The software is a beta; its latest
|
||||
> **pre-release is `0.1.0-beta.5`** (2026-09-22), an unsigned installer built from that tag with its
|
||||
> checksums published beside it. The source holds the desktop app
|
||||
> (library, store import, charts, settings) and the background Agent, which records a session when a
|
||||
> game in the library runs, injects only into games you enabled and only past the safety guard (or,
|
||||
> for a game whose guard bypass you turned on yourself, past your own acceptance of that risk), and
|
||||
> game in the library runs, injects only into games you enabled and only past the safety guard, and
|
||||
> stores sessions in a local database. What that path measures:
|
||||
>
|
||||
> - **Frame times and output resolution:** measured from the present call for Direct3D 11/12 and
|
||||
@@ -67,11 +66,10 @@
|
||||
> half of the suspicious-module rule. During every capture the Agent re-runs the checks every 30 s and
|
||||
> stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer
|
||||
> goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at
|
||||
> its next check; it can only refuse, never permit. **There is one override, and only one:** a per-game
|
||||
> "bypass the anti-cheat guard" switch, off by default, that you can turn on only by accepting its own
|
||||
> warning (a tick and a typed word). With it on, FrameLedger injects into that game even where the
|
||||
> checks find anti-cheat, the 30 s re-check no longer stops the capture for that finding, and every
|
||||
> session started that way is marked. It never changes HOW FrameLedger injects: nothing is hidden.
|
||||
> its next check; it can only refuse, never permit. **There is no override.** A finding about a game — anti-cheat
|
||||
> named in its process, in its folder or on its title lists — turns hooking off for that game, whether found
|
||||
> before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it
|
||||
> back on for that executable.
|
||||
>
|
||||
> Where a value is not measured it reads `N/A`, with two exceptions: FPS then shows Presented FPS with a
|
||||
> note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as
|
||||
|
||||
+15
-36
@@ -1,6 +1,6 @@
|
||||
# FrameLedger — Disclaimer
|
||||
|
||||
**Version:** 2.4 · **Effective:** {{RELEASE_DATE}}
|
||||
**Version:** 2.5 · **Effective:** {{RELEASE_DATE}}
|
||||
|
||||
> **How this document is kept true.** The statement of what FrameLedger measures (§4) is `legal/ACCURACY.md`,
|
||||
> embedded here and in `README.md` and bound to its source by `tools/accuracy-check.ps1`, which fails the build when a
|
||||
@@ -53,7 +53,7 @@ Install it somewhere only you can write to, and verify the published SHA-256 che
|
||||
FrameLedger is designed to reduce that risk substantially:
|
||||
|
||||
- Injection is **off by default** and must be enabled by you **per game**.
|
||||
- Before injecting, and every 30 seconds afterwards, FrameLedger scans for known anti-cheat and anti-tamper components. **If it finds one, it refuses to inject; if a session is already running, it stops at the next scan.** No setting turns this off globally; the one exception is the per-game bypass described in §2A, which only you can turn on, one game at a time. Because the scan runs every 30 seconds rather than continuously, anti-cheat that loads mid-session may be present for **up to 30 seconds** before FrameLedger detects it and stops.
|
||||
- Before injecting, and every 30 seconds afterwards, FrameLedger scans for known anti-cheat and anti-tamper components. **If it finds one, it refuses to inject; if a session is already running, it stops at the next scan.** No setting turns this off, globally or per game (§2A). Because the scan runs every 30 seconds rather than continuously, anti-cheat that loads mid-session may be present for **up to 30 seconds** before FrameLedger detects it and stops.
|
||||
|
||||
**And there is a second, longer window you should know about.** The part of FrameLedger running inside the game also stops on its own if it loses contact with the part doing the scanning — because a scanner that has stopped cannot protect you. It waits **65 seconds** before concluding that contact is lost, so that one delayed scan on a busy machine does not end your session. In the worst case those windows combine: if the scanner stops at the moment anti-cheat appears, the component inside the game may keep running for up to **65 seconds** afterwards. That number is 65 and not 30, and this document says so rather than leaving the 30 above to imply it.
|
||||
|
||||
@@ -79,33 +79,14 @@ FrameLedger is designed to reduce that risk substantially:
|
||||
|
||||
**FrameLedger is intended for offline and single-player play. If you enable injection for a game with any online or competitive component, you do so entirely at your own risk and are solely responsible for the consequences, including compliance with that game's terms of service.**
|
||||
|
||||
## 2A. The guard bypass — entirely at your own risk
|
||||
## 2A. There is no way past the guard
|
||||
|
||||
Since version 0.1.0-beta.3 each game's page has a switch labelled **"Bypass the anti-cheat guard (at your own risk)"**.
|
||||
It is **off by default**, it applies to that one game only, and there is no way to turn it on for all games at once.
|
||||
Versions 0.1.0-beta.3 and 0.1.0-beta.4 offered a per-game switch to overrule the guard. **It has been removed.** If
|
||||
FrameLedger finds anti-cheat or anti-tamper software in a game — before it injects, when a session starts, or during a
|
||||
session — it refuses, turns hooking off for that game, and says so on the game's page. There is no setting, per game or
|
||||
global, that turns that back on for that executable. Sessions recorded under the earlier switch stay in your database,
|
||||
marked as such in their notes.
|
||||
|
||||
Turning it on tells FrameLedger to inject into that game **even where its checks find anti-cheat or anti-tamper
|
||||
software** — that is, in exactly the situation §2 says can get an account banned. The checks still run and what they
|
||||
found is still recorded; they simply no longer stop the injection or the running session for that game. FrameLedger
|
||||
still does nothing to hide itself: it loads under its real name and is fully visible to the anti-cheat.
|
||||
|
||||
**It does not make FrameLedger work everywhere.** Several anti-cheat systems protect the game's process so that no
|
||||
other program can open it. FrameLedger cannot measure such a game with or without the bypass, it says so when that
|
||||
happens, and it will never try to get around another product's protection. Turning the bypass on for such a game
|
||||
gains you nothing and still marks your intent to load software into it.
|
||||
|
||||
You can turn it on only by accepting a warning inside the application, by **both** ticking a statement and typing a
|
||||
word. **BY TURNING IT ON YOU ACCEPT THE ENTIRE RISK YOURSELF.** The developer and the contributors accept **no
|
||||
responsibility and no liability whatsoever** for anything that happens on your side as a result — including, without
|
||||
limitation, an account that is flagged, suspended or **permanently banned** (in that game or in others from the same
|
||||
publisher or platform), purchases, progress or data that are lost, a game that crashes or will not start, or any
|
||||
dispute with a publisher or platform under their terms of service. Nobody can undo a ban for you.
|
||||
|
||||
Every session started with the bypass on is permanently marked as such in the application and in every export,
|
||||
together with what the checks found. The bypass turns itself off when you turn hooking off for the game or when the
|
||||
game's executable changes.
|
||||
|
||||
**If you are not certain, leave it off.**
|
||||
|
||||
## 3. Stability
|
||||
|
||||
@@ -116,12 +97,11 @@ Software running inside another process can, in principle, destabilize it. Frame
|
||||
Frame timing is derived from high-resolution timestamps taken at the moment the game presents each frame; upscaling, frame-generation and ray-tracing state are read from the parameters the game passes to those APIs. This is substantially more accurate than inferring settings from files on disk, but **no measurement is guaranteed to be exact**:
|
||||
|
||||
<!-- accuracy-block:begin -->
|
||||
> ⚠ **What FrameLedger actually measures today — 2026-09-21.** The software is a beta; its latest
|
||||
> **pre-release is `0.1.0-beta.4`** (2026-09-21), an unsigned installer built from that tag with its
|
||||
> ⚠ **What FrameLedger actually measures today — 2026-09-22.** The software is a beta; its latest
|
||||
> **pre-release is `0.1.0-beta.5`** (2026-09-22), an unsigned installer built from that tag with its
|
||||
> checksums published beside it. The source holds the desktop app
|
||||
> (library, store import, charts, settings) and the background Agent, which records a session when a
|
||||
> game in the library runs, injects only into games you enabled and only past the safety guard (or,
|
||||
> for a game whose guard bypass you turned on yourself, past your own acceptance of that risk), and
|
||||
> game in the library runs, injects only into games you enabled and only past the safety guard, and
|
||||
> stores sessions in a local database. What that path measures:
|
||||
>
|
||||
> - **Frame times and output resolution:** measured from the present call for Direct3D 11/12 and
|
||||
@@ -172,11 +152,10 @@ Frame timing is derived from high-resolution timestamps taken at the moment the
|
||||
> half of the suspicious-module rule. During every capture the Agent re-runs the checks every 30 s and
|
||||
> stops capturing on a refusal: a Direct3D or OpenGL game's hooks are removed, and the Vulkan layer
|
||||
> goes passthrough. A global switch in Settings turns all hooking off, and a running capture stops at
|
||||
> its next check; it can only refuse, never permit. **There is one override, and only one:** a per-game
|
||||
> "bypass the anti-cheat guard" switch, off by default, that you can turn on only by accepting its own
|
||||
> warning (a tick and a typed word). With it on, FrameLedger injects into that game even where the
|
||||
> checks find anti-cheat, the 30 s re-check no longer stops the capture for that finding, and every
|
||||
> session started that way is marked. It never changes HOW FrameLedger injects: nothing is hidden.
|
||||
> its next check; it can only refuse, never permit. **There is no override.** A finding about a game — anti-cheat
|
||||
> named in its process, in its folder or on its title lists — turns hooking off for that game, whether found
|
||||
> before injection, at a session's start or by the 30 s re-check; the game's page says so, and nothing turns it
|
||||
> back on for that executable.
|
||||
>
|
||||
> Where a value is not measured it reads `N/A`, with two exceptions: FPS then shows Presented FPS with a
|
||||
> note on what it may include, and ray-tracing flags may show a value you set yourself, labelled as
|
||||
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
# FrameLedger — End User License Agreement (EULA)
|
||||
|
||||
**Version:** 1.1 · **Effective:** {{RELEASE_DATE}}
|
||||
**Version:** 1.2 · **Effective:** {{RELEASE_DATE}}
|
||||
|
||||
This End User License Agreement ("Agreement") applies to **FrameLedger** ("the Software"), developed and published by **poli0981** ("the Developer"), contactable at <contact@poli0981.dev> — see <https://poli0981.dev/> for other contact channels.
|
||||
|
||||
@@ -14,7 +14,7 @@ The Software records game performance data, hardware telemetry (temperatures, lo
|
||||
|
||||
## 2A. Code injection — your responsibility
|
||||
|
||||
To measure rendering settings accurately, the Software can load a component into a game process, **but only for games you have individually enabled**, after a consent prompt that explains the risk. The Software refuses to do so when it detects anti-cheat or anti-tamper software. It provides exactly one means to override that refusal: a per-game "bypass the anti-cheat guard" switch, off by default, which you can turn on only by accepting a separate in-application warning by two distinct acts (Disclaimer §2A). **If you turn it on, you do so entirely at your own risk, and the Developer accepts no responsibility or liability for any consequence**, including a suspended or permanently banned account.
|
||||
To measure rendering settings accurately, the Software can load a component into a game process, **but only for games you have individually enabled**, after a consent prompt that explains the risk. The Software refuses to do so when it detects anti-cheat or anti-tamper software, turns hooking off for that game, and provides no means to override that refusal (Disclaimer §2A).
|
||||
|
||||
By enabling this feature for a game, you confirm that:
|
||||
|
||||
|
||||
@@ -41,7 +41,7 @@
|
||||
"level, which made it a check that could not fire."
|
||||
],
|
||||
"schemaVersion": 2,
|
||||
"rulesVersion": "2026.09.1",
|
||||
"rulesVersion": "2026.09.2",
|
||||
|
||||
"engines": [
|
||||
{
|
||||
@@ -84,6 +84,23 @@
|
||||
] },
|
||||
"version": null
|
||||
},
|
||||
{
|
||||
"id": "re_engine",
|
||||
"name": "RE Engine",
|
||||
"signals": { "any": [
|
||||
{ "type": "sibling_glob", "value": "re_chunk_000.pak" }
|
||||
] },
|
||||
"version": null
|
||||
},
|
||||
{
|
||||
"id": "fromsoftware",
|
||||
"name": "FromSoftware",
|
||||
"signals": { "all": [
|
||||
{ "type": "sibling_glob", "value": "*.bhd" },
|
||||
{ "type": "sibling_glob", "value": "*.bdt" }
|
||||
] },
|
||||
"version": null
|
||||
},
|
||||
{
|
||||
"id": "godot",
|
||||
"name": "Godot",
|
||||
|
||||
@@ -61,7 +61,6 @@ internal static class AgentServices
|
||||
|
||||
// Persistence: the one ledger, the Agent's own (%LOCALAPPDATA%\FrameLedger, §S18 blocker 3).
|
||||
services.AddSingleton<IGameConsentStore, SqliteGameConsentStore>();
|
||||
services.AddSingleton<IGuardBypassStore, SqliteGuardBypassStore>();
|
||||
services.AddSingleton<IGameRepository, SqliteGameRepository>();
|
||||
services.AddSingleton<ISessionRepository, SqliteSessionRepository>();
|
||||
services.AddSingleton<IHardwareSnapshotRepository, SqliteHardwareSnapshotRepository>();
|
||||
@@ -76,8 +75,16 @@ internal static class AgentServices
|
||||
services.AddSingleton<IAntiCheatGuard, NativeAntiCheatGuard>();
|
||||
services.AddSingleton<HookedCaptureGate>();
|
||||
|
||||
// The capture path's adapters (PR-C).
|
||||
services.AddSingleton<ITargetResolver>(static _ => new TargetResolver(AgentConsole.Line));
|
||||
// The capture path's adapters (PR-C). The resolver's notes reach the Agent's log too (2026-09-23: there were none in
|
||||
// it), and its Tier-2 liveness reads the watcher's snapshot by image path, never a process of its own.
|
||||
services.AddSingleton<LatestProcessSnapshot>();
|
||||
services.AddSingleton<ITargetResolver>(static sp => new TargetResolver(
|
||||
static line =>
|
||||
{
|
||||
AgentConsole.Line(line);
|
||||
Serilog.Log.Information("{Line}", line);
|
||||
},
|
||||
sp.GetRequiredService<LatestProcessSnapshot>()));
|
||||
services.AddSingleton<ITargetLivenessSource, HeldProcessLivenessSource>();
|
||||
services.AddSingleton<IRingAttacher>(static _ => new ShmRingAttacher(NativeAntiCheatGuard.BuildId()));
|
||||
services.AddSingleton<IRuntimeModuleSnapshot>(static _ => new RuntimeModuleSnapshot(CensusNames.ModuleFileNames));
|
||||
@@ -113,12 +120,20 @@ internal static class AgentServices
|
||||
// --serve only (DetectionHostedService); composed and inert under --console.
|
||||
services.AddSingleton<IDetectionRulesSource>(static _ => new DetectionRulesFile());
|
||||
services.AddSingleton<IGameFileProbe, GameFileProbe>();
|
||||
// A drive that changed its letter (2026-09-22): one relocator, asked by the sweep, the watcher and the enable-hooking
|
||||
// command, over the BCL's drive list.
|
||||
services.AddSingleton(static sp => new ExecutableRelocator(
|
||||
sp.GetRequiredService<IGameRepository>(),
|
||||
sp.GetRequiredService<IExecutableIdentitySource>(),
|
||||
VolumeRoots.Ready,
|
||||
static line => Serilog.Log.Information("{Line}", line)));
|
||||
services.AddSingleton(static sp => new DetectionSweep(
|
||||
sp.GetRequiredService<IGameRepository>(),
|
||||
sp.GetRequiredService<IDetectionRulesSource>(),
|
||||
sp.GetRequiredService<IGameFileProbe>(),
|
||||
sp.GetRequiredService<IExecutableIdentitySource>(),
|
||||
static line => Serilog.Log.Information("{Line}", line)));
|
||||
static line => Serilog.Log.Information("{Line}", line),
|
||||
sp.GetRequiredService<ExecutableRelocator>()));
|
||||
|
||||
// The layer's registration follows the ledger (P4 PR-2, 12_BUILD §The Vulkan layer is not registered at
|
||||
// install time): the same manifest and key --register-vklayer writes, reconciled after every consent change
|
||||
@@ -172,8 +187,7 @@ internal static class AgentServices
|
||||
sp.GetRequiredService<VkLayerReconciler>(),
|
||||
// P4 PR-7: the on-demand retention sweep, over the Agent's own settings read and its own blob tables.
|
||||
ct => new RetentionSweep(sp.GetRequiredService<ISessionRepository>(), sp.GetRequiredService<RegisteredSettings>()).RunAsync(ct),
|
||||
// Owner decision 2026-09-21: the per-game guard bypass is written through its own port, never the consent one.
|
||||
sp.GetRequiredService<IGuardBypassStore>()));
|
||||
sp.GetRequiredService<ExecutableRelocator>()));
|
||||
services.AddSingleton<IIpcRequestHandler>(static sp => new AgentRequestHandler(
|
||||
AgentIdentityFactory.OfThisProcess(sp.GetRequiredService<AgentPaths>().VkLayerDirectory),
|
||||
TelemetryDescriptor(),
|
||||
@@ -193,7 +207,9 @@ internal static class AgentServices
|
||||
sp.GetRequiredService<IExecutableIdentitySource>(),
|
||||
new OrchestratorOptions { PayloadPath = AgentPaths.Payload },
|
||||
static line => Serilog.Log.Information("{Line}", line),
|
||||
sp.GetRequiredService<ILaunchRecorderFactory>()));
|
||||
sp.GetRequiredService<ILaunchRecorderFactory>(),
|
||||
sp.GetRequiredService<ExecutableRelocator>(),
|
||||
sp.GetRequiredService<LatestProcessSnapshot>()));
|
||||
services.AddSingleton<ILaunchRecorderFactory, AgentLaunches>();
|
||||
|
||||
}
|
||||
|
||||
@@ -25,17 +25,22 @@ internal sealed class DetectionHostedService(DetectionSweep sweep, VkLayerReconc
|
||||
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
||||
{
|
||||
Log.Information("detect: sweeping the library every {Seconds} s, and on every rules update", Interval.TotalSeconds);
|
||||
DetectionSweepReport? previous = null;
|
||||
while (!stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
DetectionSweepReport r = await sweep.SweepOnceAsync(stoppingToken).ConfigureAwait(false);
|
||||
if (r.Scanned > 0 || r.Unreadable > 0 || r.RulesUnusable)
|
||||
// Said when something happened or changed (2026-09-23): an unreadable entry used to repeat this line every
|
||||
// 15 s — 5,760 a day — with nothing new in it.
|
||||
if (r.Scanned > 0 || r.Relocated > 0 || r.RulesUnusable || (r.Unreadable > 0 && r.Unreadable != previous?.Unreadable))
|
||||
{
|
||||
Log.Information("detect: sweep scanned {Scanned}, current {Current}, unreadable {Unreadable}{Rules}",
|
||||
r.Scanned, r.Current, r.Unreadable, r.RulesUnusable ? ", rules unusable" : string.Empty);
|
||||
}
|
||||
|
||||
previous = r;
|
||||
|
||||
// The layer follows the ledger after every sweep (P4 PR-2): a Vulkan fact that arrived after the
|
||||
// consent, and the crash policy's auto-disable, both converge here within one interval.
|
||||
_ = await layer.ReconcileAsync(stoppingToken).ConfigureAwait(false);
|
||||
|
||||
@@ -14,16 +14,26 @@ namespace FrameLedger.Agent.Hosting;
|
||||
/// a session somebody lost, and it becomes an <c>interrupted</c> row before any new session can write beside
|
||||
/// it. Then the orchestrator polls until the host stops; its sessions finalize inside the host's shutdown
|
||||
/// grace, and one that does not make it leaves its <c>.partial</c> for the next start — the same rule.
|
||||
/// <b>Nothing recovery does can keep the watcher from starting (2026-09-23)</b>: the host's default for a background
|
||||
/// service that throws is to stop the whole Agent, so a file recovery could not finalize would have stopped every start
|
||||
/// after it. <see cref="PartialRecovery"/> no longer throws; the guard here is for what it cannot foresee.
|
||||
/// </remarks>
|
||||
internal sealed class WatcherHostedService(PartialRecovery recovery, CaptureOrchestrator orchestrator) : BackgroundService
|
||||
{
|
||||
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
||||
{
|
||||
IReadOnlyList<RecoveryOutcome> recovered = await recovery.RecoverAsync(stoppingToken).ConfigureAwait(false);
|
||||
Log.Information("recover: {Count} pending .partial file(s)", recovered.Count);
|
||||
foreach (RecoveryOutcome o in recovered)
|
||||
try
|
||||
{
|
||||
Log.Information("recover: {Guid} {Status} {Detail}", o.SessionGuid.ToString("N"), o.Status, o.Detail);
|
||||
IReadOnlyList<RecoveryOutcome> recovered = await recovery.RecoverAsync(stoppingToken).ConfigureAwait(false);
|
||||
Log.Information("recover: {Count} pending .partial file(s)", recovered.Count);
|
||||
foreach (RecoveryOutcome o in recovered)
|
||||
{
|
||||
Log.Information("recover: {Guid} {Status} {Detail}", o.SessionGuid.ToString("N"), o.Status, o.Detail);
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException and not OutOfMemoryException)
|
||||
{
|
||||
Log.Warning(ex, "recover: did not complete; the watcher starts anyway and the files stay for the next start");
|
||||
}
|
||||
|
||||
Log.Information("serve: watching the games table at 1 Hz; hooking only where a game is enabled and consented ({Elevation}, pid {Pid})",
|
||||
|
||||
@@ -200,6 +200,9 @@ internal static class Program
|
||||
Directory.CreateDirectory(paths.Logs);
|
||||
Log.Logger = new LoggerConfiguration()
|
||||
.MinimumLevel.Information()
|
||||
// The host's own lines reach this file since 2026-09-23 (ServeAsync's AddSerilog): its warnings and errors —
|
||||
// a background service that stopped the host — not its start/stop chatter.
|
||||
.MinimumLevel.Override("Microsoft", Serilog.Events.LogEventLevel.Warning)
|
||||
.WriteTo.File(Path.Combine(paths.Logs, "agent-.log"), formatProvider: System.Globalization.CultureInfo.InvariantCulture,
|
||||
rollingInterval: RollingInterval.Day, retainedFileCountLimit: 14)
|
||||
.CreateLogger();
|
||||
@@ -236,6 +239,9 @@ internal static class Program
|
||||
private static async Task<int> ServeAsync(LedgerDatabase db, AgentPaths paths)
|
||||
{
|
||||
HostApplicationBuilder builder = Host.CreateApplicationBuilder();
|
||||
// The host's log into agent-*.log (2026-09-23). A background service that threw stopped the host with nothing in
|
||||
// the file: the Generic Host logs that through Microsoft.Extensions.Logging, which was never routed here.
|
||||
builder.Services.AddSerilog();
|
||||
// Before the composition, so its TryAdd keeps this one: Shutdown over the pipe stops the host (PR-1b).
|
||||
builder.Services.AddSingleton<IAgentLifetime, HostAgentLifetime>();
|
||||
builder.Services.AddFrameLedgerAgent(db, paths);
|
||||
|
||||
@@ -244,8 +244,8 @@ public partial class App : System.Windows.Application
|
||||
|
||||
// THE SAFETY FAMILY TOO (2026-09-21). FrameLedger.Shared's Strings had no culture of its own and fell back to the
|
||||
// thread's - and CurrentUICulture set inside this async start does not reach the dispatcher's later operations,
|
||||
// so on an English Windows a Vietnamese UI showed the consent dialog, the refusal notices and the guard-bypass
|
||||
// card in English (the owner's screenshot, beta.3). An explicit culture does not depend on which thread asks.
|
||||
// so on an English Windows a Vietnamese UI showed the consent dialog and the refusal notices in English (the
|
||||
// owner's screenshot, beta.3). An explicit culture does not depend on which thread asks.
|
||||
Shared.Strings.Culture = culture;
|
||||
}
|
||||
|
||||
@@ -327,10 +327,6 @@ public partial class App : System.Windows.Application
|
||||
services.AddSingleton<IMessageStrip, SnackbarStrip>();
|
||||
services.AddSingleton<IEditGamePrompt, EditGamePrompt>();
|
||||
|
||||
// The per-game guard bypass (owner decision 2026-09-21): its own disclosure, its own service, no global form.
|
||||
services.AddSingleton<IGuardBypassPrompt, GuardBypassPrompt>();
|
||||
services.AddSingleton<GuardBypass>();
|
||||
|
||||
// The session summary (P3 PR-6): the series loader over the ports, the exports' file picker, the window opener.
|
||||
services.AddSingleton<IHardwareSnapshotRepository, SqliteHardwareSnapshotRepository>();
|
||||
// Settings > System (2026-09-21): the same source the Agent stamps every session with, read for this PC now.
|
||||
|
||||
@@ -1,43 +0,0 @@
|
||||
<UserControl x:Class="FrameLedger.App.Dialogs.GuardBypassDialogContent"
|
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
|
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
|
||||
xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
|
||||
xmlns:vm="clr-namespace:FrameLedger.App.ViewModels"
|
||||
d:DataContext="{d:DesignInstance Type=vm:GuardBypassDialogViewModel}"
|
||||
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
|
||||
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
|
||||
mc:Ignorable="d"
|
||||
MaxWidth="660">
|
||||
<!--
|
||||
The guard-bypass disclosure (owner decision 2026-09-21, 19_SAFETY §The user's bypass). Text from
|
||||
FrameLedger.Shared's Safety_Bypass_* only. Order: what the switch is, what the guard found, what can happen, who
|
||||
carries it, what is recorded, then the two acts. The risk and the liability paragraphs sit on the theme's
|
||||
critical fill with primary text (a pair ContrastTests measures); every colour is a theme brush (16_WPFUI §Theming).
|
||||
-->
|
||||
<ScrollViewer MaxHeight="540" VerticalScrollBarVisibility="Auto">
|
||||
<StackPanel>
|
||||
<ui:TextBlock Text="{x:Static vm:GuardBypassDialogViewModel.Intro}" TextWrapping="Wrap" />
|
||||
|
||||
<ui:TextBlock Margin="0,12,0,0" FontWeight="SemiBold" Text="{Binding Found}" TextWrapping="Wrap" />
|
||||
|
||||
<Border Margin="0,14,0,0" Padding="12" CornerRadius="6" Background="{DynamicResource SystemFillColorCriticalBackgroundBrush}">
|
||||
<ui:TextBlock Foreground="{DynamicResource TextFillColorPrimaryBrush}" Text="{x:Static vm:GuardBypassDialogViewModel.Risk}" TextWrapping="Wrap" />
|
||||
</Border>
|
||||
<Border Margin="0,8,0,0" Padding="12" CornerRadius="6" Background="{DynamicResource SystemFillColorCriticalBackgroundBrush}">
|
||||
<ui:TextBlock Foreground="{DynamicResource TextFillColorPrimaryBrush}" FontWeight="SemiBold" Text="{x:Static vm:GuardBypassDialogViewModel.Liability}" TextWrapping="Wrap" />
|
||||
</Border>
|
||||
|
||||
<ui:TextBlock Margin="0,12,0,0" Text="{x:Static vm:GuardBypassDialogViewModel.Recorded}" TextWrapping="Wrap" />
|
||||
|
||||
<CheckBox Margin="0,16,0,0" IsChecked="{Binding Acknowledged, Mode=TwoWay}"
|
||||
AutomationProperties.Name="{x:Static vm:GuardBypassDialogViewModel.CheckboxText}">
|
||||
<TextBlock Text="{x:Static vm:GuardBypassDialogViewModel.CheckboxText}" TextWrapping="Wrap" MaxWidth="600" />
|
||||
</CheckBox>
|
||||
|
||||
<ui:TextBlock Margin="0,14,0,6" Appearance="Secondary" Text="{Binding TypeToConfirm}" TextWrapping="Wrap" />
|
||||
<ui:TextBox AutomationProperties.Name="{Binding TypeToConfirm}"
|
||||
Text="{Binding Typed, UpdateSourceTrigger=PropertyChanged}"
|
||||
PlaceholderText="{x:Static vm:GuardBypassDialogViewModel.Phrase}" />
|
||||
</StackPanel>
|
||||
</ScrollViewer>
|
||||
</UserControl>
|
||||
@@ -1,16 +0,0 @@
|
||||
using System.Windows.Controls;
|
||||
using FrameLedger.App.ViewModels;
|
||||
|
||||
namespace FrameLedger.App.Dialogs;
|
||||
|
||||
public partial class GuardBypassDialogContent : UserControl
|
||||
{
|
||||
public GuardBypassDialogContent(GuardBypassDialogViewModel viewModel)
|
||||
{
|
||||
ViewModel = viewModel ?? throw new ArgumentNullException(nameof(viewModel));
|
||||
DataContext = viewModel;
|
||||
InitializeComponent();
|
||||
}
|
||||
|
||||
public GuardBypassDialogViewModel ViewModel { get; }
|
||||
}
|
||||
@@ -30,6 +30,9 @@
|
||||
<ui:TextBlock FontTypography="Title" Text="{Binding ViewModel.Name}" />
|
||||
<ui:TextBlock Appearance="Secondary" Text="{Binding ViewModel.Subtitle}" />
|
||||
<ui:TextBlock Appearance="Tertiary" TextTrimming="CharacterEllipsis" Text="{Binding ViewModel.ExecutableText}" ToolTip="{Binding ViewModel.ExecutableText}" />
|
||||
<ui:InfoBar Margin="0,6,0,0" IsClosable="False" Severity="Warning"
|
||||
IsOpen="{Binding ViewModel.ExecutableMissing, Mode=OneWay}"
|
||||
Message="{x:Static vm:GameDetailViewModel.ExecutableMissingText}" />
|
||||
<ui:TextBlock Appearance="Secondary" Text="{Binding ViewModel.LastSessionText}" />
|
||||
<StackPanel Orientation="Horizontal" Margin="0,10,0,0">
|
||||
<ui:TextBlock Appearance="Secondary" VerticalAlignment="Center" Margin="0,0,12,0" Text="{x:Static vm:GameDetailViewModel.LifetimeLabel}" />
|
||||
@@ -123,16 +126,6 @@
|
||||
Visibility="{Binding ViewModel.UnverifiedText, Converter={StaticResource NullToCollapsed}}" />
|
||||
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" Text="{x:Static vm:GameDetailViewModel.BusyText}"
|
||||
Visibility="{Binding ViewModel.Busy, Converter={StaticResource BoolToVis}}" />
|
||||
<!-- the user's guard bypass (owner decision 2026-09-21, 19_SAFETY §The user's bypass): per game, OFF by default -->
|
||||
<ui:CardControl Margin="0,12,0,0" Header="{x:Static vm:GameDetailViewModel.BypassLabel}" Icon="{ui:SymbolIcon ShieldError24}">
|
||||
<ui:ToggleSwitch AutomationProperties.Name="{x:Static vm:GameDetailViewModel.BypassLabel}"
|
||||
IsChecked="{Binding ViewModel.GuardBypassOn, Mode=OneWay}"
|
||||
Command="{Binding ViewModel.ToggleGuardBypassCommand}" />
|
||||
</ui:CardControl>
|
||||
<ui:TextBlock Margin="0,6,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:GameDetailViewModel.BypassBody}" />
|
||||
<ui:InfoBar Margin="0,8,0,0" IsClosable="False" Severity="Error"
|
||||
IsOpen="{Binding ViewModel.GuardBypassOn, Mode=OneWay}"
|
||||
Message="{x:Static vm:GameDetailViewModel.BypassOnNotice}" />
|
||||
<ui:InfoBar Margin="0,8,0,0" IsClosable="False" Severity="Warning"
|
||||
IsOpen="{Binding ViewModel.AutoDisabledText, Converter={StaticResource NotNull}}"
|
||||
Message="{Binding ViewModel.AutoDisabledText}">
|
||||
|
||||
@@ -129,6 +129,28 @@ public static class Formats
|
||||
_ => Strings.Exit_Normal,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// The engine id as the engine's name (2026-09-23): a proper noun, the same in every language (the glossary rule
|
||||
/// above). The ids are the rules file's; one this table does not know — a newer rule, or an engine the user typed —
|
||||
/// passes through as it is, never blank.
|
||||
/// </summary>
|
||||
public static string Engine(string? id) => id switch
|
||||
{
|
||||
null => string.Empty,
|
||||
"unity" => "Unity",
|
||||
"unreal" => "Unreal Engine",
|
||||
"rpgmaker_mv" => "RPG Maker MV/MZ",
|
||||
"rpgmaker_rgss" => "RPG Maker XP/VX/VX Ace",
|
||||
"re_engine" => "RE Engine",
|
||||
"fromsoftware" => "FromSoftware",
|
||||
"godot" => "Godot",
|
||||
"gamemaker" => "GameMaker",
|
||||
"renpy" => "Ren'Py",
|
||||
"cryengine" => "CryEngine",
|
||||
"source" => "Source",
|
||||
_ => id,
|
||||
};
|
||||
|
||||
/// <summary>The platform token as its store name.</summary>
|
||||
public static string Platform(string? token) => token switch
|
||||
{
|
||||
@@ -138,4 +160,28 @@ public static class Formats
|
||||
"itch" => "itch.io",
|
||||
_ => string.Empty,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Why a Tier-2 session measured nothing, from <c>capture_notes</c> (2026-09-22): hooking off, a block on the row,
|
||||
/// the guard's refusal by family, a process that could not be opened, or the end reason by name.
|
||||
/// </summary>
|
||||
public static string Tier2Reason(string? captureNotes)
|
||||
{
|
||||
Application.Recording.CaptureNotes n = Application.Recording.CaptureNotes.Parse(captureNotes);
|
||||
switch (n.End)
|
||||
{
|
||||
case null:
|
||||
return string.Empty;
|
||||
case "RefusedHookNotEnabled" when string.Equals(n.GuardReason, "PreviouslyBlocked", StringComparison.Ordinal) && n.GuardSignal is { Length: > 0 } blocked:
|
||||
return string.Format(CultureInfo.CurrentCulture, Strings.Summary_Tier2_Why_Blocked_Format, blocked);
|
||||
case "RefusedHookNotEnabled":
|
||||
return Strings.Summary_Tier2_Why_HookOff;
|
||||
case "RefusedByGuard" or "SafetyUnhook" when n.GuardFamily is { Length: > 0 } family:
|
||||
return string.Format(CultureInfo.CurrentCulture, Strings.Summary_Tier2_Why_Guard_Format, family, n.GuardSignal ?? Strings.Common_NotAvailable);
|
||||
case "TargetUnreadable":
|
||||
return Strings.Summary_Tier2_Why_Unreadable;
|
||||
default:
|
||||
return string.Format(CultureInfo.CurrentCulture, Strings.Summary_Tier2_Why_Other_Format, n.End);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,8 @@
|
||||
using System.IO;
|
||||
using FrameLedger.Application.Import;
|
||||
using FrameLedger.Application.Persistence;
|
||||
using FrameLedger.Domain.Consent;
|
||||
using FrameLedger.Infrastructure.Import;
|
||||
using FrameLedger.Infrastructure.Io;
|
||||
|
||||
namespace FrameLedger.App.Services;
|
||||
@@ -60,10 +62,14 @@ public sealed class GameLibrary
|
||||
return null;
|
||||
}
|
||||
|
||||
string name = Path.GetFileNameWithoutExtension(normalised);
|
||||
// A generic executable (Game.exe) is named from the game's own title or its folder, not "Game" (2026-09-23).
|
||||
string name = GameTitleGuess.Guess(normalised, () => RpgMakerTitle.TryRead(normalised));
|
||||
return await _games.EnsureAsync(fingerprint.Value, name, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>Whether the row's executable is where the row says (2026-09-22): the page's "not found" line, nothing else.</summary>
|
||||
public static bool ExecutableExists(string normalisedExePath) => ExecutableIdentity.Read(normalisedExePath) is not null;
|
||||
|
||||
/// <summary>
|
||||
/// Points the row at another executable; null when the file cannot be read, false when another row owns that path.
|
||||
/// The caller revokes consent over the pipe FIRST, as removal does: the table write only downgrades.
|
||||
|
||||
@@ -1,71 +0,0 @@
|
||||
using System.IO;
|
||||
using FrameLedger.Infrastructure.Ipc;
|
||||
using FrameLedger.Shared.Ipc;
|
||||
using FrameLedger.Shared.Safety;
|
||||
using Serilog;
|
||||
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>
|
||||
/// The per-game guard bypass as the App performs it (owner decision 2026-09-21, <c>19_SAFETY</c> §The user's bypass):
|
||||
/// show the disclosure, and only when it was accepted by both of its acts ask the Agent to record it. The App writes
|
||||
/// nothing itself — the acknowledgement is stamped by the Agent, over the pipe, exactly as consent is — and the Agent
|
||||
/// re-checks the disclosure version and the executable, because the pipe is not a trust boundary.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// There is no "all games" form of this and no setting that pre-accepts it: every game is its own dialog.
|
||||
/// </remarks>
|
||||
public sealed class GuardBypass
|
||||
{
|
||||
private readonly IAgentRequests _agent;
|
||||
private readonly IGuardBypassPrompt _prompt;
|
||||
|
||||
public GuardBypass(IAgentRequests agent, IGuardBypassPrompt prompt)
|
||||
{
|
||||
_agent = agent ?? throw new ArgumentNullException(nameof(agent));
|
||||
_prompt = prompt ?? throw new ArgumentNullException(nameof(prompt));
|
||||
}
|
||||
|
||||
public async Task<GuardBypassResult> EnableAsync(long gameId, string gameName, string? finding, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(gameName);
|
||||
if (!_agent.IsConnected)
|
||||
{
|
||||
return new GuardBypassResult(GuardBypassOutcome.AgentUnavailable);
|
||||
}
|
||||
|
||||
if (!await _prompt.ShowAsync(gameName, finding, ct).ConfigureAwait(true))
|
||||
{
|
||||
return new GuardBypassResult(GuardBypassOutcome.Declined);
|
||||
}
|
||||
|
||||
return await SendAsync(new SetGuardBypassRequest(gameId, Enabled: true, GuardBypassDisclosure.Version), GuardBypassOutcome.Enabled, ct).ConfigureAwait(true);
|
||||
}
|
||||
|
||||
public Task<GuardBypassResult> DisableAsync(long gameId, CancellationToken ct = default) =>
|
||||
_agent.IsConnected
|
||||
? SendAsync(new SetGuardBypassRequest(gameId, Enabled: false, null), GuardBypassOutcome.Disabled, ct)
|
||||
: Task.FromResult(new GuardBypassResult(GuardBypassOutcome.AgentUnavailable));
|
||||
|
||||
private async Task<GuardBypassResult> SendAsync(SetGuardBypassRequest request, GuardBypassOutcome onWritten, CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
IpcEnvelope ack = await _agent.RequestAsync(IpcMessageType.SetGuardBypass, request, ct).ConfigureAwait(true);
|
||||
if (!string.Equals(ack.Type, IpcMessageType.GuardBypassAck, StringComparison.Ordinal))
|
||||
{
|
||||
return new GuardBypassResult(GuardBypassOutcome.Failed, "UnexpectedAck:" + ack.Type);
|
||||
}
|
||||
|
||||
GuardBypassAck? outcome = IpcCodec.Payload<GuardBypassAck>(ack);
|
||||
return outcome is not null && outcome.Enabled == request.Enabled
|
||||
? new GuardBypassResult(onWritten, outcome.Outcome)
|
||||
: new GuardBypassResult(GuardBypassOutcome.Failed, outcome?.Outcome ?? "EmptyAck");
|
||||
}
|
||||
catch (Exception ex) when (ex is IpcRequestException or TimeoutException or IOException or InvalidOperationException)
|
||||
{
|
||||
Log.Warning(ex, "bypass: SetGuardBypass(game {GameId}, {Enabled}) did not complete", request.GameId, request.Enabled);
|
||||
return new GuardBypassResult(GuardBypassOutcome.Failed, ex is IpcRequestException ipc ? ipc.Code ?? IpcMessageType.Error : ex.GetType().Name);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>What happened when the user moved a game's guard-bypass switch (owner decision 2026-09-21).</summary>
|
||||
public enum GuardBypassOutcome
|
||||
{
|
||||
/// <summary>The Agent recorded the acknowledgement: the bypass is on for this game.</summary>
|
||||
Enabled,
|
||||
|
||||
/// <summary>The Agent withdrew it: the guard is a hard gate for this game again.</summary>
|
||||
Disabled,
|
||||
|
||||
/// <summary>The disclosure was closed without both acts. Nothing was sent.</summary>
|
||||
Declined,
|
||||
|
||||
/// <summary>No Agent to record it; nothing changed.</summary>
|
||||
AgentUnavailable,
|
||||
|
||||
/// <summary>The Agent answered with something other than a written acknowledgement; <c>Detail</c> says what.</summary>
|
||||
Failed,
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
using System.Windows.Data;
|
||||
using FrameLedger.App.Dialogs;
|
||||
using FrameLedger.App.ViewModels;
|
||||
using Wpf.Ui;
|
||||
using Wpf.Ui.Controls;
|
||||
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>
|
||||
/// <see cref="IGuardBypassPrompt"/> as a <c>ContentDialog</c>, the shape FR-2.1's consent dialog has and stricter: the
|
||||
/// primary button is the Danger one, it is enabled only while the checkbox is ticked AND the phrase is typed, and Enter
|
||||
/// keeps the guard on.
|
||||
/// </summary>
|
||||
public sealed class GuardBypassPrompt : IGuardBypassPrompt
|
||||
{
|
||||
private readonly IContentDialogService _dialogs;
|
||||
|
||||
public GuardBypassPrompt(IContentDialogService dialogs) => _dialogs = dialogs ?? throw new ArgumentNullException(nameof(dialogs));
|
||||
|
||||
public async Task<bool> ShowAsync(string gameName, string? finding, CancellationToken ct = default)
|
||||
{
|
||||
var viewModel = new GuardBypassDialogViewModel(gameName, finding);
|
||||
var dialog = new ContentDialog
|
||||
{
|
||||
Title = viewModel.Title,
|
||||
Content = new GuardBypassDialogContent(viewModel),
|
||||
PrimaryButtonText = GuardBypassDialogViewModel.ConfirmText,
|
||||
PrimaryButtonAppearance = ControlAppearance.Danger,
|
||||
CloseButtonText = GuardBypassDialogViewModel.KeepGuardText,
|
||||
// Enter keeps the guard on; only a click on the (doubly gated) primary overrules it.
|
||||
DefaultButton = ContentDialogButton.Close,
|
||||
IsPrimaryButtonEnabled = false,
|
||||
DialogMaxWidth = 720,
|
||||
};
|
||||
_ = dialog.SetBinding(ContentDialog.IsPrimaryButtonEnabledProperty, new Binding(nameof(GuardBypassDialogViewModel.IsConfirmed)) { Source = viewModel, Mode = BindingMode.OneWay });
|
||||
|
||||
ContentDialogResult result = await _dialogs.ShowAsync(dialog, ct).ConfigureAwait(true);
|
||||
// The binding is the gate on the button; this is the same rule read once more at the moment that matters.
|
||||
return result == ContentDialogResult.Primary && viewModel.IsConfirmed;
|
||||
}
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
[StructLayout(LayoutKind.Auto)]
|
||||
public readonly record struct GuardBypassResult(GuardBypassOutcome Outcome, string? Detail = null);
|
||||
@@ -12,7 +12,7 @@ public enum HookingConsentOutcome
|
||||
/// <summary>The user closed the dialog without the acknowledgement; nothing was sent.</summary>
|
||||
Declined,
|
||||
|
||||
/// <summary>The Agent's pre-scan refused (<c>Refused</c>): a block is on the row. This dialog offers no way past it; the one override is the per-game guard bypass, with its own disclosure (<c>19_SAFETY</c> §The user's bypass, 2026-09-21).</summary>
|
||||
/// <summary>The Agent's pre-scan refused (<c>Refused</c>): a block is on the row, and there is no way past it (<c>19_SAFETY</c> §What a finding does to the game).</summary>
|
||||
Refused,
|
||||
|
||||
/// <summary>The Agent stamps against another version of the disclosure than this app shows; the dialog was not opened (D14).</summary>
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>
|
||||
/// The guard-bypass disclosure (owner decision 2026-09-21, <c>19_SAFETY</c> §The user's bypass): true only when the user
|
||||
/// ticked the acknowledgement AND typed the confirmation phrase AND pressed the primary button. A seam so the flow is
|
||||
/// testable without a window.
|
||||
/// </summary>
|
||||
public interface IGuardBypassPrompt
|
||||
{
|
||||
/// <summary>Shows the disclosure for one game and answers whether both acts were performed.</summary>
|
||||
/// <param name="gameName">The game the bypass is for; it applies to no other.</param>
|
||||
/// <param name="finding">What the guard has recorded for this game (the row's block reason), or null when nothing yet.</param>
|
||||
/// <param name="ct">Cancels the dialog; a cancelled disclosure is a declined one.</param>
|
||||
Task<bool> ShowAsync(string gameName, string? finding, CancellationToken ct = default);
|
||||
}
|
||||
@@ -45,14 +45,12 @@ public sealed class SafetyNotices : IDisposable
|
||||
case IpcMessageType.CaptureRefused when IpcCodec.Payload<CaptureRefusedEvent>(envelope) is { } refused:
|
||||
return new SafetyNotice(SafetyNoticeKind.Refused,
|
||||
string.Format(CultureInfo.CurrentCulture, Strings.Notice_Refused_Title_Format, refused.GameName ?? Strings.Common_NotAvailable),
|
||||
// "The session is still recorded" is not said about a process that could not be opened: that run ends at once
|
||||
// and is discarded for being short, so the sentence would be false there (2026-09-21).
|
||||
string.Equals(refused.Reason, "TargetUnreadable", StringComparison.Ordinal)
|
||||
? RefusalText(refused.Reason, refused.Family, refused.Signal)
|
||||
: RefusalText(refused.Reason, refused.Family, refused.Signal) + " " + Strings.Notice_Refused_Recording, now);
|
||||
// "The session is still recorded" is true for every refusal since 2026-09-22: the loop holds a refused session
|
||||
// open, unhooked, until the game exits (it was untrue for a process that could not be opened, 2026-09-21).
|
||||
TurnedOff(RefusalText(refused.Reason, refused.Family, refused.Signal) + " " + Strings.Notice_Refused_Recording, refused.HookingTurnedOff), now);
|
||||
case IpcMessageType.SafetyUnhook when IpcCodec.Payload<SafetyUnhookEvent>(envelope) is { } unhooked:
|
||||
return new SafetyNotice(SafetyNoticeKind.Unhooked, Strings.Notice_Unhooked_Title,
|
||||
string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Unhooked_Format, unhooked.Family ?? unhooked.Signal ?? Strings.Common_NotAvailable), now);
|
||||
TurnedOff(string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Unhooked_Format, unhooked.Family ?? unhooked.Signal ?? Strings.Common_NotAvailable), unhooked.HookingTurnedOff), now);
|
||||
case IpcMessageType.CaptureDegraded when IpcCodec.Payload<CaptureDegradedEvent>(envelope) is { } degraded:
|
||||
return new SafetyNotice(SafetyNoticeKind.Degraded, Strings.Notice_Degraded_Title,
|
||||
string.Format(CultureInfo.CurrentCulture, Strings.Notice_Degraded_Body_Format, degraded.Reason), now);
|
||||
@@ -61,6 +59,9 @@ public sealed class SafetyNotices : IDisposable
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The finding turned the game's hooking off (2026-09-22): the notice says so, because the page will.</summary>
|
||||
private static string TurnedOff(string text, bool turnedOff) => turnedOff ? text + " " + Shared.Strings.Safety_HookingTurnedOff : text;
|
||||
|
||||
private static string RefusalText(string reason, string? family, string? signal)
|
||||
{
|
||||
if (string.Equals(reason, "PreScanCouldNotVerify", StringComparison.Ordinal))
|
||||
|
||||
@@ -100,7 +100,6 @@ public sealed class SessionExporter
|
||||
w.WriteLine("# started_at: " + row.StartedAt.ToString("O", _inv));
|
||||
w.WriteLine("# ended_at: " + row.EndedAt.ToString("O", _inv));
|
||||
w.WriteLine("# capture_tier: " + ((int)row.Tier).ToString(_inv) + (row.Tier == CaptureTier.Hooked ? " (hooked, measured)" : " (not hooked: duration and sensors only; no per-frame rows)"));
|
||||
w.WriteLine("# guard_bypassed: " + (row.GuardBypassed ? "1 (" + (row.GuardBypassFamily ?? "unnamed") + (row.GuardBypassSignal is { Length: > 0 } sig ? " / " + sig : string.Empty) + ")" : "0"));
|
||||
w.WriteLine("# api: " + (row.Api ?? "N/A") + "; present_mode: " + (row.PresentMode ?? "N/A") + "; swap_effect: " + (row.SwapEffect ?? "N/A"));
|
||||
w.WriteLine("# hardware: " + (hardware is null ? "N/A" : string.Join("; ", new[] { hardware.CpuName, hardware.GpuName, hardware.GpuDriver, hardware.OsBuild, hardware.DisplayRes }.Where(static s => !string.IsNullOrEmpty(s)))));
|
||||
w.WriteLine("# rt: " + row.RtFlag + " (" + (row.RtSource ?? "n/a") + "); pt: " + row.PtFlag + " (" + (row.PtSource ?? "n/a") + "); rr: " + row.RrFlag + " (" + (row.RrSource ?? "n/a") + ")");
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
using System.Globalization;
|
||||
using FrameLedger.Application.Persistence;
|
||||
|
||||
namespace FrameLedger.App.Services;
|
||||
|
||||
/// <summary>Marks a session carries for as long as it exists, stated the same way on every surface.</summary>
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format string is a resource that follows the UI culture, which changes at runtime")]
|
||||
public static class SessionMarks
|
||||
{
|
||||
/// <summary>
|
||||
/// "Guard bypassed: Easy Anti-Cheat" for a session that STARTED under the user's guard bypass (schema 0007, owner
|
||||
/// decision 2026-09-21), naming what the guard found; null for every other session.
|
||||
/// </summary>
|
||||
public static string? GuardBypass(SessionRow row)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(row);
|
||||
if (!row.GuardBypassed)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
string found = row.GuardBypassFamily is { Length: > 0 } family ? family : Shared.Strings.Safety_Bypass_Session_Unnamed;
|
||||
return string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Bypass_Session_Format, found);
|
||||
}
|
||||
}
|
||||
Generated
+18
@@ -248,6 +248,7 @@ public static class Strings
|
||||
nameof(GameDetail_Back),
|
||||
nameof(GameDetail_ChangeExe),
|
||||
nameof(GameDetail_Edit),
|
||||
nameof(GameDetail_ExeMissing),
|
||||
nameof(GameDetail_Hooking_Body),
|
||||
nameof(GameDetail_Hooking_Busy),
|
||||
nameof(GameDetail_Hooking_Header),
|
||||
@@ -540,6 +541,11 @@ public static class Strings
|
||||
nameof(Summary_Stat_Stutter_Format),
|
||||
nameof(Summary_Tags_Placeholder),
|
||||
nameof(Summary_Tier2_Body),
|
||||
nameof(Summary_Tier2_Why_Blocked_Format),
|
||||
nameof(Summary_Tier2_Why_Guard_Format),
|
||||
nameof(Summary_Tier2_Why_HookOff),
|
||||
nameof(Summary_Tier2_Why_Other_Format),
|
||||
nameof(Summary_Tier2_Why_Unreadable),
|
||||
nameof(Summary_Title_Format),
|
||||
nameof(Summary_Unhooked_Body),
|
||||
nameof(Summary_Unhooked_Title),
|
||||
@@ -1072,6 +1078,8 @@ public static class Strings
|
||||
|
||||
public static string GameDetail_Edit => ResourceManager.GetString(nameof(GameDetail_Edit), Culture) ?? nameof(GameDetail_Edit);
|
||||
|
||||
public static string GameDetail_ExeMissing => ResourceManager.GetString(nameof(GameDetail_ExeMissing), Culture) ?? nameof(GameDetail_ExeMissing);
|
||||
|
||||
public static string GameDetail_Hooking_Body => ResourceManager.GetString(nameof(GameDetail_Hooking_Body), Culture) ?? nameof(GameDetail_Hooking_Body);
|
||||
|
||||
public static string GameDetail_Hooking_Busy => ResourceManager.GetString(nameof(GameDetail_Hooking_Busy), Culture) ?? nameof(GameDetail_Hooking_Busy);
|
||||
@@ -1656,6 +1664,16 @@ public static class Strings
|
||||
|
||||
public static string Summary_Tier2_Body => ResourceManager.GetString(nameof(Summary_Tier2_Body), Culture) ?? nameof(Summary_Tier2_Body);
|
||||
|
||||
public static string Summary_Tier2_Why_Blocked_Format => ResourceManager.GetString(nameof(Summary_Tier2_Why_Blocked_Format), Culture) ?? nameof(Summary_Tier2_Why_Blocked_Format);
|
||||
|
||||
public static string Summary_Tier2_Why_Guard_Format => ResourceManager.GetString(nameof(Summary_Tier2_Why_Guard_Format), Culture) ?? nameof(Summary_Tier2_Why_Guard_Format);
|
||||
|
||||
public static string Summary_Tier2_Why_HookOff => ResourceManager.GetString(nameof(Summary_Tier2_Why_HookOff), Culture) ?? nameof(Summary_Tier2_Why_HookOff);
|
||||
|
||||
public static string Summary_Tier2_Why_Other_Format => ResourceManager.GetString(nameof(Summary_Tier2_Why_Other_Format), Culture) ?? nameof(Summary_Tier2_Why_Other_Format);
|
||||
|
||||
public static string Summary_Tier2_Why_Unreadable => ResourceManager.GetString(nameof(Summary_Tier2_Why_Unreadable), Culture) ?? nameof(Summary_Tier2_Why_Unreadable);
|
||||
|
||||
public static string Summary_Title_Format => ResourceManager.GetString(nameof(Summary_Title_Format), Culture) ?? nameof(Summary_Title_Format);
|
||||
|
||||
public static string Summary_Unhooked_Body => ResourceManager.GetString(nameof(Summary_Unhooked_Body), Culture) ?? nameof(Summary_Unhooked_Body);
|
||||
|
||||
@@ -1225,6 +1225,26 @@
|
||||
<value>このセッションはフックされていません。時間とハードウェアテレメトリは記録されましたが、実測はなく、描画するフレームもありません。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Blocked_Format" xml:space="preserve">
|
||||
<value>理由: このゲームのフックはオフです — ガードが {0} を検出しました。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Guard_Format" xml:space="preserve">
|
||||
<value>理由: ガードが拒否しました — {0}({1})。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_HookOff" xml:space="preserve">
|
||||
<value>理由: このゲームのフックはオフだったため、何も読み込まれていません。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Other_Format" xml:space="preserve">
|
||||
<value>理由: {0}。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Unreadable" xml:space="preserve">
|
||||
<value>理由: Windows が FrameLedger にプロセスを開かせませんでした(アンチチートのドライバー、またはゲームが管理者として実行中)。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="Summary_Title_Format" xml:space="preserve">
|
||||
<value>{0} — {1}</value>
|
||||
<comment>review</comment>
|
||||
@@ -2292,6 +2312,10 @@
|
||||
ログフォルダーを開きますか?</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="GameDetail_ExeMissing" xml:space="preserve">
|
||||
<value>このパスに実行ファイルが見つかりません。ドライブ文字が変わった場合、ドライブが戻ってから約 15 秒以内にエージェントがこの項目をそのファイルへ移します。そうでない場合は「実行ファイルを変更」を使ってください。</value>
|
||||
<comment>review</comment>
|
||||
</data>
|
||||
<data name="GameDetail_ChangeExe" xml:space="preserve">
|
||||
<value>実行ファイルを変更…</value>
|
||||
<comment>review</comment>
|
||||
@@ -2428,7 +2452,7 @@
|
||||
<value>要点 — 同意する前にお読みください:
|
||||
• これはベータ版(プレリリース)です。不具合は確実に残っており、それによって生じた問題について開発者は責任を負いません。
|
||||
• お使いの PC は、ゲームの開発元またはパブリッシャーが公表している最低動作環境を少なくとも満たしている必要があります。先にご確認ください。それを下回る PC で起きた問題は FrameLedger ではなく、あなたの責任です。
|
||||
• フックは、あなたが同意した場合にのみ、ゲームごとにコンポーネントをゲームへ読み込みます。アンチチートはこれを理由にアカウントを BAN することがあります。FrameLedger はアンチチートを検出した場合は拒否します。あるゲームでその拒否をバイパスすることを選んだ場合、すべてのリスクはあなたが負い、開発者は一切負いません。
|
||||
• フックは、あなたが同意した場合にのみ、ゲームごとにコンポーネントをゲームへ読み込みます。アンチチートはこれを理由にアカウントを BAN することがあります。FrameLedger はアンチチートを検出した場合は拒否し、そのゲームのフックをオフにします。この拒否を回避する方法はありません。
|
||||
• どこにも何も送信されません。記録はこの PC に残り、バックアップはご自身で行ってください。
|
||||
以下の文書が正式な条項であり、この要約はそれらに代わるものではありません。</value>
|
||||
<comment>review</comment>
|
||||
|
||||
@@ -924,6 +924,21 @@
|
||||
<data name="Summary_Tier2_Body" xml:space="preserve">
|
||||
<value>This session was not hooked: duration and hardware telemetry were recorded, nothing was measured, and there are no frames to chart.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Blocked_Format" xml:space="preserve">
|
||||
<value>Why: hooking is off for this game — the guard found {0}.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Guard_Format" xml:space="preserve">
|
||||
<value>Why: the guard refused — {0} ({1}).</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_HookOff" xml:space="preserve">
|
||||
<value>Why: hooking was off for this game, so nothing was injected.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Other_Format" xml:space="preserve">
|
||||
<value>Why: {0}.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Unreadable" xml:space="preserve">
|
||||
<value>Why: Windows would not let FrameLedger open the process (an anti-cheat driver, or the game runs as administrator).</value>
|
||||
</data>
|
||||
<data name="Summary_Title_Format" xml:space="preserve">
|
||||
<value>{0} — {1}</value>
|
||||
</data>
|
||||
@@ -1728,6 +1743,9 @@ The details are in the log folder:
|
||||
|
||||
Open the log folder?</value>
|
||||
</data>
|
||||
<data name="GameDetail_ExeMissing" xml:space="preserve">
|
||||
<value>The executable was not found at this path. If a drive changed its letter, the Agent moves this entry to the file itself within about 15 seconds of the drive being back; otherwise use Change executable.</value>
|
||||
</data>
|
||||
<data name="GameDetail_ChangeExe" xml:space="preserve">
|
||||
<value>Change executable…</value>
|
||||
</data>
|
||||
@@ -1831,7 +1849,7 @@ Open the log folder?</value>
|
||||
<value>In short — please read before you accept:
|
||||
• This is a beta (pre-release). It certainly still has bugs, and the developer is not responsible for problems that result.
|
||||
• Your PC must meet at least the minimum requirements the game's developer or publisher states. Read them first. Problems on a PC below them are your responsibility, not FrameLedger's.
|
||||
• Hooking loads a component into a game, one game at a time, only after you agree. Anti-cheat systems can ban an account for that. FrameLedger refuses where it detects anti-cheat; if you choose to bypass that refusal for a game, you carry the entire risk and the developer carries none.
|
||||
• Hooking loads a component into a game, one game at a time, only after you agree. Anti-cheat systems can ban an account for that. FrameLedger refuses where it detects anti-cheat and turns hooking off for that game; there is no way to override that refusal.
|
||||
• Nothing is sent anywhere. Your recordings stay on this PC, and backing them up is up to you.
|
||||
The documents below are the full terms; this summary does not replace them.</value>
|
||||
</data>
|
||||
|
||||
@@ -919,6 +919,21 @@
|
||||
<data name="Summary_Tier2_Body" xml:space="preserve">
|
||||
<value>Phiên này không hook: đã ghi thời lượng và telemetry phần cứng, không đo gì, và không có khung hình để vẽ.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Blocked_Format" xml:space="preserve">
|
||||
<value>Lý do: hooking đang tắt cho game này — guard đã phát hiện {0}.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Guard_Format" xml:space="preserve">
|
||||
<value>Lý do: guard đã từ chối — {0} ({1}).</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_HookOff" xml:space="preserve">
|
||||
<value>Lý do: hooking đang tắt cho game này, nên không có gì được inject.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Other_Format" xml:space="preserve">
|
||||
<value>Lý do: {0}.</value>
|
||||
</data>
|
||||
<data name="Summary_Tier2_Why_Unreadable" xml:space="preserve">
|
||||
<value>Lý do: Windows không cho FrameLedger mở tiến trình (driver anti-cheat, hoặc game chạy với quyền quản trị).</value>
|
||||
</data>
|
||||
<data name="Summary_Title_Format" xml:space="preserve">
|
||||
<value>{0} — {1}</value>
|
||||
</data>
|
||||
@@ -1723,6 +1738,9 @@ Chi tiết nằm trong thư mục log:
|
||||
|
||||
Mở thư mục log?</value>
|
||||
</data>
|
||||
<data name="GameDetail_ExeMissing" xml:space="preserve">
|
||||
<value>Không tìm thấy file thực thi ở đường dẫn này. Nếu ổ đĩa đổi ký tự, Agent sẽ tự chuyển mục này sang file đó trong khoảng 15 giây sau khi ổ có lại; nếu không, hãy dùng Đổi file thực thi.</value>
|
||||
</data>
|
||||
<data name="GameDetail_ChangeExe" xml:space="preserve">
|
||||
<value>Đổi file thực thi…</value>
|
||||
</data>
|
||||
@@ -1826,7 +1844,7 @@ Mở thư mục log?</value>
|
||||
<value>Tóm tắt — vui lòng đọc trước khi chấp nhận:
|
||||
• Đây là bản beta (pre-release). Chắc chắn vẫn còn lỗi, và nhà phát triển không chịu trách nhiệm về các sự cố phát sinh.
|
||||
• Máy của bạn phải đáp ứng ít nhất mức cấu hình tối thiểu mà nhà phát triển/nhà phát hành game công bố. Hãy đọc cấu hình tối thiểu trước. Sự cố trên máy dưới mức đó là trách nhiệm của bạn, không phải của FrameLedger.
|
||||
• Hooking nạp một thành phần vào game, từng game một, và chỉ sau khi bạn đồng ý. Hệ thống chống gian lận có thể khoá tài khoản vì việc này. FrameLedger từ chối ở nơi nó phát hiện anti-cheat; nếu bạn chọn bỏ qua sự từ chối đó cho một game, bạn tự chịu toàn bộ rủi ro và nhà phát triển không chịu bất kỳ trách nhiệm nào.
|
||||
• Hooking nạp một thành phần vào game, từng game một, và chỉ sau khi bạn đồng ý. Hệ thống chống gian lận có thể khoá tài khoản vì việc này. FrameLedger từ chối ở nơi nó phát hiện anti-cheat và tự tắt hooking cho game đó; không có cách nào vượt qua sự từ chối này.
|
||||
• Không có gì được gửi đi đâu cả. Dữ liệu ghi lại nằm trên máy này, và việc sao lưu là của bạn.
|
||||
Các tài liệu bên dưới là điều khoản đầy đủ; phần tóm tắt này không thay thế chúng.</value>
|
||||
</data>
|
||||
|
||||
@@ -15,7 +15,7 @@ public sealed class GameCardViewModel
|
||||
Id = card.Row.Id;
|
||||
Name = card.Row.Name;
|
||||
PlatformText = Formats.Platform(card.Row.Platform);
|
||||
EngineText = card.Row.Engine ?? string.Empty;
|
||||
EngineText = Formats.Engine(card.Row.Engine);
|
||||
HookOn = card.Row.HookEnabled;
|
||||
HookText = HookOn ? Strings.Games_Card_HookOn : Strings.Games_Card_HookOff;
|
||||
SessionCount = card.Summary?.SessionCount ?? 0;
|
||||
|
||||
@@ -30,7 +30,6 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
private readonly IConfirmations _confirmations;
|
||||
private readonly IEditGamePrompt _edit;
|
||||
private readonly IGamePicker _picker;
|
||||
private readonly GuardBypass _bypass;
|
||||
private readonly IMessageStrip _strip;
|
||||
private readonly ISessionSummaryOpener _summaries;
|
||||
private readonly SessionSeriesLoader _loader;
|
||||
@@ -45,17 +44,17 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
[ObservableProperty]
|
||||
private string _subtitle = string.Empty;
|
||||
|
||||
/// <summary>
|
||||
/// The per-game guard bypass as the row states it (owner decision 2026-09-21). <c>OneWay</c> on the page: the switch
|
||||
/// moves only when the Agent has recorded or withdrawn the acknowledgement and the row was re-read.
|
||||
/// </summary>
|
||||
[ObservableProperty]
|
||||
private bool _guardBypassOn;
|
||||
|
||||
/// <summary>The executable the row is about: what the watcher matches and what consent is keyed on, so a wrong import guess is visible.</summary>
|
||||
[ObservableProperty]
|
||||
private string _executableText = string.Empty;
|
||||
|
||||
/// <summary>
|
||||
/// The row's executable is not where the row says (2026-09-22). Read when the page loads; the Agent moves the row
|
||||
/// itself when the file is under another drive letter, so this clears on the next visit once it has.
|
||||
/// </summary>
|
||||
[ObservableProperty]
|
||||
private bool _executableMissing;
|
||||
|
||||
[ObservableProperty]
|
||||
private string _lastSessionText = string.Empty;
|
||||
|
||||
@@ -130,10 +129,9 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
|
||||
public GameDetailViewModel(GameLibrary library, GameSelection selection, HookingConsent consent, IPageNavigator navigator,
|
||||
IConfirmations confirmations, IEditGamePrompt edit, IMessageStrip strip, ISessionSummaryOpener summaries,
|
||||
SessionSeriesLoader loader, IHardwareSnapshotRepository hardware, SessionSelection sessionSelection, IGamePicker picker, GuardBypass bypass)
|
||||
SessionSeriesLoader loader, IHardwareSnapshotRepository hardware, SessionSelection sessionSelection, IGamePicker picker)
|
||||
{
|
||||
_picker = picker ?? throw new ArgumentNullException(nameof(picker));
|
||||
_bypass = bypass ?? throw new ArgumentNullException(nameof(bypass));
|
||||
_selection = sessionSelection ?? throw new ArgumentNullException(nameof(sessionSelection));
|
||||
_library = library ?? throw new ArgumentNullException(nameof(library));
|
||||
ArgumentNullException.ThrowIfNull(selection);
|
||||
@@ -157,11 +155,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
|
||||
public static string ChangeExecutableText => Strings.GameDetail_ChangeExe;
|
||||
|
||||
public static string BypassLabel => Shared.Strings.Safety_Bypass_Toggle_Label;
|
||||
|
||||
public static string BypassBody => Shared.Strings.Safety_Bypass_Toggle_Body;
|
||||
|
||||
public static string BypassOnNotice => Shared.Strings.Safety_Bypass_On_Notice;
|
||||
public static string ExecutableMissingText => Strings.GameDetail_ExeMissing;
|
||||
|
||||
public static string LifetimeLabel => Strings.GameDetail_LifetimeAvg;
|
||||
|
||||
@@ -370,9 +364,6 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
[RelayCommand]
|
||||
private Task ChangeExecutableAsync() => RunAsync(ChangeExecutableCoreAsync);
|
||||
|
||||
[RelayCommand]
|
||||
private Task ToggleGuardBypassAsync() => RunAsync(ToggleGuardBypassCoreAsync);
|
||||
|
||||
/// <summary>One action at a time, and the one in flight is <see cref="Pending"/> for a test to await.</summary>
|
||||
private async Task RunAsync(Func<Task> work)
|
||||
{
|
||||
@@ -423,39 +414,6 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
await LoadAsync().ConfigureAwait(true);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Turning it ON is the disclosure, both of its acts, then the Agent's stamp; turning it OFF needs no dialog. Either
|
||||
/// way the row is re-read, so the switch shows what is recorded and never what was clicked.
|
||||
/// </summary>
|
||||
private async Task ToggleGuardBypassCoreAsync()
|
||||
{
|
||||
if (Game is null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Busy = true;
|
||||
try
|
||||
{
|
||||
GuardBypassResult result = GuardBypassOn
|
||||
? await _bypass.DisableAsync(Game.Id).ConfigureAwait(true)
|
||||
: await _bypass.EnableAsync(Game.Id, Game.Name, Game.HookBlockedReason).ConfigureAwait(true);
|
||||
(NoticeText, NoticeSeverity) = result.Outcome switch
|
||||
{
|
||||
GuardBypassOutcome.AgentUnavailable => (Shared.Strings.Safety_Consent_AgentUnavailable, InfoBarSeverity.Warning),
|
||||
GuardBypassOutcome.Failed => (string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Bypass_Failed_Format, result.Detail ?? Strings.Common_NotAvailable), InfoBarSeverity.Warning),
|
||||
_ => (null, InfoBarSeverity.Informational),
|
||||
};
|
||||
OnPropertyChanged(nameof(NoticeVisible));
|
||||
}
|
||||
finally
|
||||
{
|
||||
Busy = false;
|
||||
}
|
||||
|
||||
await LoadAsync().ConfigureAwait(true);
|
||||
}
|
||||
|
||||
private async Task EditCoreAsync()
|
||||
{
|
||||
if (Game is null)
|
||||
@@ -560,6 +518,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
Name = row.Name;
|
||||
Subtitle = string.Join(" · ", new[] { row.Publisher, row.GameVersion, Formats.Platform(row.Platform), EngineText(row) }.Where(static s => !string.IsNullOrWhiteSpace(s)));
|
||||
ExecutableText = row.Fingerprint.ExePath;
|
||||
ExecutableMissing = !GameLibrary.ExecutableExists(row.Fingerprint.ExePath);
|
||||
|
||||
SessionRow? last = detail.Sessions.Count > 0 ? detail.Sessions[0] : null;
|
||||
SessionRow? lastHooked = detail.Sessions.FirstOrDefault(static s => s.Tier == CaptureTier.Hooked && s.FrameCount > 0);
|
||||
@@ -618,20 +577,15 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
private void PresentHooking(GameRow row)
|
||||
{
|
||||
HookEnabled = row.HookEnabled;
|
||||
GuardBypassOn = row.GuardBypassAt is not null;
|
||||
bool blocked = row.HookBlockedReason is not null || string.Equals(row.HookPrescanState, "blocked", StringComparison.Ordinal);
|
||||
|
||||
// A blocked row's toggle is disabled because enabling it could only be refused; under the user's bypass it is
|
||||
// not refused, so the toggle works and the block's text stays on the page beside it.
|
||||
HookToggleEnabled = (!blocked || GuardBypassOn) && !Busy;
|
||||
// A blocked row's toggle is disabled because enabling it could only be refused (19_SAFETY §What a finding does
|
||||
// to the game): the finding is on the page, and there is no switch that overrules it (2026-09-22).
|
||||
HookToggleEnabled = !blocked && !Busy;
|
||||
HookStatusText = row.HookEnabled ? Strings.GameDetail_Hooking_On : Strings.GameDetail_Hooking_Off;
|
||||
// "Hooking is disabled for this game" beside a hooking switch that is ON was the beta.3 page under a bypass. The
|
||||
// finding stays on the page - it is still true - and says what happened to it.
|
||||
BlockedText = !blocked
|
||||
? null
|
||||
: string.Format(CultureInfo.CurrentCulture,
|
||||
GuardBypassOn ? Shared.Strings.Safety_Bypass_Found_Overruled_Format : Shared.Strings.Safety_Blocked_Toggle_Format,
|
||||
row.HookBlockedReason ?? row.HookPrescanState);
|
||||
: string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_Blocked_Toggle_Format, row.HookBlockedReason ?? row.HookPrescanState);
|
||||
AutoDisabledText = row.HookAutoDisabledReason is { Length: > 0 } reason && !row.HookEnabled
|
||||
? string.Format(CultureInfo.CurrentCulture, Shared.Strings.Safety_AutoDisabled_Format, reason)
|
||||
: null;
|
||||
@@ -650,7 +604,7 @@ public sealed partial class GameDetailViewModel : ObservableObject
|
||||
}
|
||||
|
||||
private static string EngineText(GameRow row) =>
|
||||
row.Engine is null ? string.Empty : row.EngineVersion is null ? row.Engine : row.Engine + " " + row.EngineVersion;
|
||||
row.Engine is null || row.EngineVersion is null ? Formats.Engine(row.Engine) : Formats.Engine(row.Engine) + " " + row.EngineVersion;
|
||||
|
||||
private static Domain.Metrics.Tri DefaultOf(GameRow row, TriStateKind kind) => kind switch
|
||||
{
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
using System.Globalization;
|
||||
using CommunityToolkit.Mvvm.ComponentModel;
|
||||
using FrameLedger.Shared.Safety;
|
||||
using SafetyStrings = FrameLedger.Shared.Strings;
|
||||
|
||||
namespace FrameLedger.App.ViewModels;
|
||||
|
||||
/// <summary>
|
||||
/// The guard-bypass disclosure's state (owner decision 2026-09-21): two independent acts, both required — a ticked
|
||||
/// acknowledgement and the typed phrase — so neither a stray click nor a held Enter key can overrule the guard. Text
|
||||
/// from <c>FrameLedger.Shared</c>'s <c>Safety_Bypass_*</c> only, reviewed as the safety text it is.
|
||||
/// </summary>
|
||||
public sealed partial class GuardBypassDialogViewModel : ObservableObject
|
||||
{
|
||||
[ObservableProperty]
|
||||
[NotifyPropertyChangedFor(nameof(IsConfirmed))]
|
||||
private bool _acknowledged;
|
||||
|
||||
[ObservableProperty]
|
||||
[NotifyPropertyChangedFor(nameof(IsConfirmed))]
|
||||
private string _typed = string.Empty;
|
||||
|
||||
[System.Diagnostics.CodeAnalysis.SuppressMessage("Performance", "CA1863:Use 'CompositeFormat'", Justification = "the format strings are resources that follow the UI culture, which changes at runtime; a cached CompositeFormat would pin the first culture")]
|
||||
public GuardBypassDialogViewModel(string gameName, string? finding)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(gameName);
|
||||
Title = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Bypass_Title_Format, gameName);
|
||||
Found = string.IsNullOrWhiteSpace(finding)
|
||||
? SafetyStrings.Safety_Bypass_Found_Nothing
|
||||
: string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Bypass_Found_Format, finding);
|
||||
TypeToConfirm = string.Format(CultureInfo.CurrentCulture, SafetyStrings.Safety_Bypass_TypeToConfirm_Format, GuardBypassDisclosure.ConfirmationPhrase);
|
||||
}
|
||||
|
||||
public string Title { get; }
|
||||
|
||||
public string Found { get; }
|
||||
|
||||
public string TypeToConfirm { get; }
|
||||
|
||||
public static string Intro => SafetyStrings.Safety_Bypass_Intro;
|
||||
|
||||
public static string Risk => SafetyStrings.Safety_Bypass_Risk;
|
||||
|
||||
public static string Liability => SafetyStrings.Safety_Bypass_Liability;
|
||||
|
||||
public static string Recorded => SafetyStrings.Safety_Bypass_Recorded;
|
||||
|
||||
public static string CheckboxText => SafetyStrings.Safety_Bypass_Checkbox;
|
||||
|
||||
public static string Phrase => GuardBypassDisclosure.ConfirmationPhrase;
|
||||
|
||||
public static string ConfirmText => SafetyStrings.Safety_Bypass_Confirm;
|
||||
|
||||
public static string KeepGuardText => SafetyStrings.Safety_Bypass_KeepGuard;
|
||||
|
||||
/// <summary>Both acts, or nothing: the tick alone and the phrase alone each leave the primary button disabled.</summary>
|
||||
public bool IsConfirmed => Acknowledged && IsThePhrase(Typed);
|
||||
|
||||
/// <summary>Exact and case-sensitive after trimming: "bypass" is not "BYPASS".</summary>
|
||||
public static bool IsThePhrase(string? typed) => string.Equals(typed?.Trim(), GuardBypassDisclosure.ConfirmationPhrase, StringComparison.Ordinal);
|
||||
}
|
||||
@@ -32,8 +32,7 @@ public sealed class SessionItemViewModel
|
||||
ResolutionText = IsHooked ? Formats.Resolution(row.RenderW, row.RenderH, row.OutputW, row.OutputH) + " · " + Formats.Upscaler(row.Upscaler, row.UpscalerQuality, row.UpscalerDriverReported) : Strings.Common_NotAvailable;
|
||||
GpuTempText = Formats.Temperature(row.MaxGpuTemp);
|
||||
ApiText = IsHooked ? Formats.Api(row.Api) : Strings.Common_NotAvailable;
|
||||
// A session that started under the user's guard bypass says so wherever it is listed (schema 0007).
|
||||
ExitText = SessionMarks.GuardBypass(row) is { } mark ? Formats.ExitStatusText(row.ExitStatus) + " · " + mark : Formats.ExitStatusText(row.ExitStatus);
|
||||
ExitText = Formats.ExitStatusText(row.ExitStatus);
|
||||
IsCrashed = row.ExitStatus == ExitStatus.Crashed;
|
||||
TagsText = annotation is null ? string.Empty : string.Join(", ", annotation.Tags);
|
||||
Rt = TriStateChipModel.Of(TriStateKind.RayTracing, TriStateResolution.Resolve(TriStateKind.RayTracing, row, annotation, game));
|
||||
|
||||
@@ -56,9 +56,9 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
[ObservableProperty]
|
||||
private bool _isUnhooked;
|
||||
|
||||
/// <summary>"Guard bypassed: (family)" when the session started under the user's bypass (schema 0007), else null.</summary>
|
||||
/// <summary>Tier 2's payload (2026-09-22): why this session measured nothing, from the row's notes; empty for a hooked row.</summary>
|
||||
[ObservableProperty]
|
||||
private string? _guardBypassText;
|
||||
private string _tier2Reason = string.Empty;
|
||||
|
||||
[ObservableProperty]
|
||||
private bool _notFound;
|
||||
@@ -282,7 +282,7 @@ public sealed partial class SessionSummaryViewModel : ObservableObject
|
||||
IsHooked = row.Tier == CaptureTier.Hooked;
|
||||
IsCrashed = row.ExitStatus == ExitStatus.Crashed;
|
||||
IsUnhooked = row.ExitStatus == ExitStatus.UnhookedSafety;
|
||||
GuardBypassText = SessionMarks.GuardBypass(row);
|
||||
Tier2Reason = IsHooked ? string.Empty : Formats.Tier2Reason(row.CaptureNotes);
|
||||
Readout = FpsPresentation.FromRow(row);
|
||||
Line = string.Format(CultureInfo.CurrentCulture, Strings.Summary_Line_Format,
|
||||
IsHooked ? Formats.Api(row.Api) : Strings.Tier_NotHooked, row.PresentMode ?? Strings.Common_NotAvailable,
|
||||
|
||||
@@ -35,10 +35,6 @@
|
||||
Title="{x:Static vm:SessionSummaryViewModel.UnhookedTitle}"
|
||||
Message="{x:Static vm:SessionSummaryViewModel.UnhookedBody}" />
|
||||
|
||||
<ui:InfoBar IsClosable="False" Severity="Error" Margin="0,0,0,12"
|
||||
IsOpen="{Binding ViewModel.GuardBypassText, Mode=OneWay, Converter={StaticResource NotNull}}"
|
||||
Message="{Binding ViewModel.GuardBypassText}" />
|
||||
|
||||
<!-- header line + chips -->
|
||||
<ui:TextBlock Appearance="Secondary" Text="{Binding ViewModel.Line}" />
|
||||
<ui:TextBlock Appearance="Tertiary" TextWrapping="Wrap" Text="{Binding ViewModel.HardwareLine}" />
|
||||
@@ -82,6 +78,8 @@
|
||||
|
||||
<ui:TextBlock Margin="0,8,0,0" Appearance="Secondary" TextWrapping="Wrap" Text="{x:Static vm:SessionSummaryViewModel.Tier2Text}"
|
||||
Visibility="{Binding ViewModel.IsHooked, Converter={StaticResource InverseBoolToVis}}" />
|
||||
<ui:TextBlock Margin="0,4,0,0" TextWrapping="Wrap" Text="{Binding ViewModel.Tier2Reason}"
|
||||
Visibility="{Binding ViewModel.IsHooked, Converter={StaticResource InverseBoolToVis}}" />
|
||||
|
||||
<!-- charts -->
|
||||
<StackPanel Visibility="{Binding ViewModel.IsHooked, Converter={StaticResource BoolToVis}}">
|
||||
|
||||
@@ -23,7 +23,7 @@ namespace FrameLedger.Application.AntiCheat;
|
||||
/// the far side of a returned verdict.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class GuardSupervisor(IAntiCheatGuard guard, bool guardBypassAcknowledged = false)
|
||||
public sealed class GuardSupervisor(IAntiCheatGuard guard)
|
||||
{
|
||||
private readonly IAntiCheatGuard _guard = guard ?? throw new ArgumentNullException(nameof(guard));
|
||||
|
||||
@@ -46,9 +46,6 @@ public sealed class GuardSupervisor(IAntiCheatGuard guard, bool guardBypassAckno
|
||||
/// <summary>The verdict of the most recent completed evaluation, if any.</summary>
|
||||
public AntiCheatVerdict? LastVerdict { get; private set; }
|
||||
|
||||
/// <summary>How many in-session scans refused on the guard's judgement and were overruled by the user's bypass.</summary>
|
||||
public uint JudgementsOverruled { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// Run one re-scan. Returns true if capture may continue.
|
||||
/// </summary>
|
||||
@@ -78,17 +75,6 @@ public sealed class GuardSupervisor(IAntiCheatGuard guard, bool guardBypassAckno
|
||||
|
||||
if (!verdict.IsAllowed)
|
||||
{
|
||||
// A SESSION THAT STARTED UNDER THE USER'S BYPASS (owner decision 2026-09-21) already knows the guard
|
||||
// refuses this target: that refusal is what the user overruled, and re-discovering it every 30 s is not
|
||||
// news. The scan still RUNS and the tick still counts — the Overlay's own stop is fed by it — and the
|
||||
// verdict is kept, so the log says what was found. Anything that is not the guard's judgement still stops
|
||||
// the session: the bypass overrules a judgement, never a fact.
|
||||
if (guardBypassAcknowledged && AntiCheatVerdict.IsGuardJudgement(verdict.Reason))
|
||||
{
|
||||
JudgementsOverruled++;
|
||||
return true;
|
||||
}
|
||||
|
||||
UnhookRequested = true;
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -31,9 +31,8 @@ namespace FrameLedger.Application.AntiCheat;
|
||||
public sealed class HookRequest
|
||||
{
|
||||
private HookRequest(int targetPid, string payloadPath, bool hookEnabled, DateTimeOffset? consentedAt,
|
||||
string? blockedReason, int waitForPresentationRuntimeMs, bool killSwitchEngaged, bool guardBypassAcknowledged)
|
||||
string? blockedReason, int waitForPresentationRuntimeMs, bool killSwitchEngaged)
|
||||
{
|
||||
GuardBypassAcknowledged = guardBypassAcknowledged;
|
||||
TargetPid = targetPid;
|
||||
PayloadPath = payloadPath;
|
||||
HookEnabled = hookEnabled;
|
||||
@@ -49,15 +48,6 @@ public sealed class HookRequest
|
||||
/// </summary>
|
||||
public bool KillSwitchEngaged { get; }
|
||||
|
||||
/// <summary>
|
||||
/// The gate's FIFTH input (owner decision 2026-09-21): the user accepted the guard-bypass disclosure for this game,
|
||||
/// for THIS executable. The only input that can turn a refusal into a start, which is why it is built where the
|
||||
/// other four are and nowhere else: from a stored record that names the disclosure it answered, and only when the
|
||||
/// observed binary is the one that record is about. It never outranks the kill switch, an un-enabled game or a
|
||||
/// missing consent — it overrules the guard's judgement and nothing else.
|
||||
/// </summary>
|
||||
public bool GuardBypassAcknowledged { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Launch mode's budget: how long the guard may wait for the target to map a presentation runtime
|
||||
/// before injecting. Zero — the default, and attach mode — asks the guard to inject now.
|
||||
@@ -118,7 +108,7 @@ public sealed class HookRequest
|
||||
if (!record.IsFromStore)
|
||||
{
|
||||
return new HookRequest(targetPid, payloadPath, hookEnabled: false, consentedAt: null,
|
||||
blockedReason: null, waitForPresentationRuntimeMs, killSwitchEngaged, guardBypassAcknowledged: false);
|
||||
blockedReason: null, waitForPresentationRuntimeMs, killSwitchEngaged);
|
||||
}
|
||||
|
||||
// A TIMESTAMP IS NOT CONSENT. games.hook_consent_at is a bare DateTime, so a record could carry
|
||||
@@ -134,16 +124,12 @@ public sealed class HookRequest
|
||||
// PRESERVED — "the user did consent; the block is not a withdrawal of consent" — so nothing here
|
||||
// writes to the store. The stored record is untouched and a later session against the matching
|
||||
// binary uses it unchanged.
|
||||
// THE BYPASS IS ABOUT ONE EXECUTABLE TOO. An acknowledgement given for the binary that was on disk does not
|
||||
// travel to the one a patch replaced it with: the user overruled a judgement about THAT file.
|
||||
bool bypass = record.GuardBypassAcknowledged;
|
||||
if (!record.Fingerprint.Matches(observed))
|
||||
{
|
||||
consentedAt = null;
|
||||
bypass = false;
|
||||
}
|
||||
|
||||
return new HookRequest(targetPid, payloadPath, record.HookEnabled, consentedAt, record.BlockedReason,
|
||||
waitForPresentationRuntimeMs, killSwitchEngaged, bypass);
|
||||
waitForPresentationRuntimeMs, killSwitchEngaged);
|
||||
}
|
||||
}
|
||||
@@ -78,10 +78,7 @@ public sealed class HookedCaptureGate(IAntiCheatGuard guard)
|
||||
"the per-game consent dialog has not been accepted");
|
||||
}
|
||||
|
||||
// THE FIFTH INPUT (owner decision 2026-09-21). Everything above has already refused what a bypass may never
|
||||
// touch: the global switch, a game that was merely added, a consent nobody gave. What is left is the guard's
|
||||
// judgement — this latch of a past one, and the live one below — and that is exactly what the user overruled.
|
||||
if (request.BlockedReason is { Length: > 0 } blocked && !request.GuardBypassAcknowledged)
|
||||
if (request.BlockedReason is { Length: > 0 } blocked)
|
||||
{
|
||||
// 19_SAFETY §A game already enabled can become blocked later: a
|
||||
// patch adds anti-cheat, or updated rules newly match. hook_enabled
|
||||
@@ -92,16 +89,6 @@ public sealed class HookedCaptureGate(IAntiCheatGuard guard)
|
||||
|
||||
// Launch mode is the same gate reached through the guard's WAITING entry: the consent checks
|
||||
// above are identical, and what differs is only WHEN the guard's full scan runs (P1 item 2).
|
||||
if (request.GuardBypassAcknowledged)
|
||||
{
|
||||
// The guard still runs every check and still reports what it found; the verdict that comes back is
|
||||
// AllowedUnderUserBypass, never Allow, so a caller that only knows IsAllowed still does not proceed.
|
||||
return request.WaitForPresentationRuntimeMs > 0
|
||||
? await _guard.GuardedInjectWhenReadyAcknowledgedAsync(request.TargetPid, request.PayloadPath,
|
||||
request.WaitForPresentationRuntimeMs, ct).ConfigureAwait(false)
|
||||
: await _guard.GuardedInjectAcknowledgedAsync(request.TargetPid, request.PayloadPath, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return request.WaitForPresentationRuntimeMs > 0
|
||||
? await _guard.GuardedInjectWhenReadyAsync(request.TargetPid, request.PayloadPath,
|
||||
request.WaitForPresentationRuntimeMs, ct).ConfigureAwait(false)
|
||||
|
||||
@@ -53,32 +53,6 @@ public interface IAntiCheatGuard
|
||||
ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAsync(int targetPid, string payloadPath, int timeoutMs,
|
||||
CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// <see cref="GuardedInjectAsync"/> for a game whose owner accepted the guard-bypass disclosure (owner decision
|
||||
/// 2026-09-21, <c>19_SAFETY</c> §The user's bypass): every check still runs, and where one refuses on the guard's
|
||||
/// own judgement the injection proceeds and the verdict is
|
||||
/// <see cref="AntiCheatRefusalReason.AllowedUnderUserBypass"/>, still naming what was found.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>The default implementation is the hard gate.</b> An implementation that does not know the bypass answers
|
||||
/// exactly as <see cref="GuardedInjectAsync"/> does, so a fake, an older adapter or a forgotten override fails
|
||||
/// towards refusing. Only <c>NativeAntiCheatGuard</c> overrides it.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// On this port, and counted by <c>NoSecondMatcherTests</c>, for the reason
|
||||
/// <see cref="PreScanGameDirectoryAsync"/> is: a second way into a game process that lived on another interface
|
||||
/// would be a surface that test never saw.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
ValueTask<AntiCheatVerdict> GuardedInjectAcknowledgedAsync(int targetPid, string payloadPath, CancellationToken ct = default) =>
|
||||
GuardedInjectAsync(targetPid, payloadPath, ct);
|
||||
|
||||
/// <summary>Launch mode's <see cref="GuardedInjectAcknowledgedAsync"/>; the same default, the same reasons.</summary>
|
||||
ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAcknowledgedAsync(int targetPid, string payloadPath, int timeoutMs,
|
||||
CancellationToken ct = default) =>
|
||||
GuardedInjectWhenReadyAsync(targetPid, payloadPath, timeoutMs, ct);
|
||||
|
||||
/// <summary>
|
||||
/// Check 4 asked before anything is launched: does this game directory ship
|
||||
/// anti-cheat? Answers FR-2.2's question — whether the hooking toggle may be
|
||||
|
||||
@@ -27,4 +27,15 @@ public sealed record CaptureOptions
|
||||
/// watchdog acts within one 1 s tick, so a little more than that.
|
||||
/// </summary>
|
||||
public TimeSpan LogFlushGrace { get; init; } = TimeSpan.FromMilliseconds(1300);
|
||||
|
||||
/// <summary>
|
||||
/// Tier 2 (2026-09-22): after a refusal, keep the session open — duration and telemetry accruing, nothing injected —
|
||||
/// until the target exits. True is the product (<c>04_CAPTURE</c> §Tier selection: "duration, whatever telemetry
|
||||
/// this machine can provide, and the REASON"); the unshipped operator host sets false because to an operator a
|
||||
/// refusal is the answer and the exit code.
|
||||
/// </summary>
|
||||
public bool HoldUnhooked { get; init; } = true;
|
||||
|
||||
/// <summary>The hold's tick: the telemetry drain and the liveness check, at the poller's own cadence.</summary>
|
||||
public TimeSpan HoldInterval { get; init; } = TimeSpan.FromSeconds(1);
|
||||
}
|
||||
@@ -11,11 +11,11 @@ public sealed record CaptureOutcome
|
||||
public AntiCheatVerdict Verdict { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// The verdict the session STARTED under when that was the user's bypass (owner decision 2026-09-21), else null.
|
||||
/// Its own field because <see cref="Verdict"/> is replaced by the one that fired on a safety unhook, and a session
|
||||
/// that ran beside anti-cheat must say so on its row however it ended.
|
||||
/// True when this session's <see cref="Verdict"/> was a finding about the game and the loop turned the game's
|
||||
/// hooking off for it (owner decision 2026-09-22, <c>19_SAFETY</c> §What a finding does to the game): the row now
|
||||
/// carries <c>hook_blocked_reason</c>, and the user is told so with the refusal or the unhook.
|
||||
/// </summary>
|
||||
public AntiCheatVerdict? StartedUnderBypass { get; init; }
|
||||
public bool HookingTurnedOff { get; init; }
|
||||
|
||||
public ShmAttachRefusal AttachRefusal { get; init; }
|
||||
|
||||
@@ -90,4 +90,10 @@ public sealed record CaptureOutcome
|
||||
|
||||
/// <summary>The target's exit code, when it had exited by the time the session let go; null otherwise.</summary>
|
||||
public int? ExitCode { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// True when the loop held the session open unhooked until the target left (Tier 2, 2026-09-22): the duration is the
|
||||
/// game's, so the crash witness applies even where no pid was ever held.
|
||||
/// </summary>
|
||||
public bool HeldUnhooked { get; init; }
|
||||
}
|
||||
@@ -27,4 +27,20 @@ public sealed record CaptureProgress
|
||||
public required RuntimeModuleSet RuntimeModules { get; init; }
|
||||
|
||||
public required NgxDriverState NgxDriver { get; init; }
|
||||
|
||||
/// <summary>The tick of a session that never attached (Tier 2, 2026-09-22): no records, no ring, nothing measured.</summary>
|
||||
public static CaptureProgress Unhooked { get; } = new()
|
||||
{
|
||||
Records = [],
|
||||
GapBefore = [],
|
||||
WriterState = default,
|
||||
TotalDropped = 0,
|
||||
TotalGaps = 0,
|
||||
DrainTicks = 0,
|
||||
ForegroundTicks = 0,
|
||||
GuardTicksPublished = 0,
|
||||
TouchQpc = [],
|
||||
RuntimeModules = RuntimeModuleSet.Empty,
|
||||
NgxDriver = NgxDriverState.NotRun,
|
||||
};
|
||||
}
|
||||
@@ -84,28 +84,81 @@ public sealed class CaptureSession(
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(normalisedExePath);
|
||||
|
||||
// HOOKING OFF IS DECIDED BEFORE THE PROCESS IS OPENED (2026-09-22). A row whose hooking is off — merely added,
|
||||
// blocked by a finding, or auto-disabled — gets a Tier-2 session and nothing else: no OpenProcess, no resolver,
|
||||
// no gate. Until this line existed the resolver ran first, and a hooking-off utility that runs elevated
|
||||
// (Borderless Gaming, on the owner's machine) was reported as a process an anti-cheat driver protects.
|
||||
GameConsentRecord record = await store.FindAsync(normalisedExePath, ct).ConfigureAwait(false);
|
||||
if (!record.HookEnabled)
|
||||
{
|
||||
return await HoldUnhookedAsync(HookingOff(record), normalisedExePath, alive: null, pid: null, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
int? pid = resolver.Resolve(normalisedExePath, out SessionEndReason resolveReason);
|
||||
if (pid is null)
|
||||
{
|
||||
return new CaptureOutcome { Reason = resolveReason };
|
||||
// Nothing to hold when nothing is running; a process that exists and cannot be read is held by its name.
|
||||
var unresolved = new CaptureOutcome { Reason = resolveReason };
|
||||
return resolveReason == SessionEndReason.TargetNotRunning
|
||||
? unresolved
|
||||
: await HoldUnhookedAsync(unresolved, normalisedExePath, alive: null, pid: null, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
using ITargetLiveness? alive = liveness.TryPin(pid.Value);
|
||||
if (alive is null)
|
||||
{
|
||||
return new CaptureOutcome { Reason = SessionEndReason.TargetCannotBePinned };
|
||||
return await HoldUnhookedAsync(new CaptureOutcome { Reason = SessionEndReason.TargetCannotBePinned }, normalisedExePath, alive: null, pid, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
GameConsentRecord record = await store.FindAsync(normalisedExePath, ct).ConfigureAwait(false);
|
||||
if (ConsentRefusal(record, observed) is SessionEndReason refused)
|
||||
{
|
||||
return new CaptureOutcome { Reason = refused };
|
||||
return await HoldUnhookedAsync(new CaptureOutcome { Reason = refused }, normalisedExePath, alive, pid, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return await SessionAsync(pid.Value, alive, record, observed!.Value, payloadPath, started: null, ct, stop)
|
||||
.ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>The verdict a hooking-off row's Tier-2 session carries: the row's block when it has one, else "not enabled".</summary>
|
||||
private static CaptureOutcome HookingOff(GameConsentRecord record) => new()
|
||||
{
|
||||
Reason = SessionEndReason.RefusedHookNotEnabled,
|
||||
Verdict = record.BlockedReason is { Length: > 0 } blocked
|
||||
? AntiCheatVerdict.Refused(AntiCheatRefusalReason.PreviouslyBlocked, "previously blocked", blocked)
|
||||
: AntiCheatVerdict.Refused(AntiCheatRefusalReason.HookNotEnabled, "not enabled", "hooking is off for this game; nothing is injected because a game was merely added"),
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Tier 2 as a session rather than a return code (2026-09-22; <c>04_CAPTURE</c> §Tier selection). The refusal is the
|
||||
/// outcome's reason and stays so; what this adds is the game's duration and the machine's telemetry, drained on
|
||||
/// every tick through the observer exactly as a hooked session's are. The clock is the pinned liveness when the
|
||||
/// loop holds one, and the executable's name when it never opened the process. Nothing here touches the target.
|
||||
/// </summary>
|
||||
private async Task<CaptureOutcome> HoldUnhookedAsync(CaptureOutcome refusal, string normalisedExePath, ITargetLiveness? alive,
|
||||
int? pid, CancellationToken ct, CancellationToken stop)
|
||||
{
|
||||
if (!options.HoldUnhooked)
|
||||
{
|
||||
return refusal;
|
||||
}
|
||||
|
||||
DateTimeOffset? hardStop = options.MaxDuration > TimeSpan.Zero ? DateTimeOffset.UtcNow + options.MaxDuration : null;
|
||||
while (!stop.IsCancellationRequested)
|
||||
{
|
||||
bool running = alive is not null ? !alive.HasExited : resolver.IsRunning(normalisedExePath);
|
||||
if (!running || (hardStop is not null && DateTimeOffset.UtcNow >= hardStop))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
observer?.Tick(CaptureProgress.Unhooked);
|
||||
await Task.Delay(options.HoldInterval, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
observer?.Tick(CaptureProgress.Unhooked);
|
||||
return refusal with { HeldUnhooked = true, TargetPid = pid ?? 0, ExitCode = alive?.ExitCode };
|
||||
}
|
||||
|
||||
/// <summary>Launch mode (P1 item 2): start the consented executable, then the same session.</summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
@@ -143,7 +196,7 @@ public sealed class CaptureSession(
|
||||
GameConsentRecord record = await store.FindAsync(normalisedExePath, ct).ConfigureAwait(false);
|
||||
if (ConsentRefusal(record, observed) is SessionEndReason refused)
|
||||
{
|
||||
return new CaptureOutcome { Reason = refused };
|
||||
return await HoldUnhookedAsync(new CaptureOutcome { Reason = refused }, normalisedExePath, alive, launched.Value.Pid, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return await SessionAsync(launched.Value.Pid, alive, record, observed!.Value, payloadPath, started, ct, stop)
|
||||
@@ -153,9 +206,7 @@ public sealed class CaptureSession(
|
||||
/// <summary>The two refusals the loop makes itself, before the gate (see <see cref="RunAsync"/>'s remarks).</summary>
|
||||
private static SessionEndReason? ConsentRefusal(GameConsentRecord record, ExecutableFingerprint? observed)
|
||||
{
|
||||
// "Could not verify" is the pre-scan's judgement, and the user's bypass overrules the guard's judgements
|
||||
// (owner decision 2026-09-21); an executable nobody can read is a fact, and stays a refusal below.
|
||||
if (record.PreScanUnverified && !record.GuardBypassAcknowledged)
|
||||
if (record.PreScanUnverified)
|
||||
{
|
||||
return SessionEndReason.PreScanCouldNotVerify;
|
||||
}
|
||||
@@ -168,6 +219,7 @@ public sealed class CaptureSession(
|
||||
ExecutableFingerprint observed, string payloadPath, Stopwatch? started, CancellationToken ct, CancellationToken stop)
|
||||
{
|
||||
int waitMs = started is null ? 0 : checked((int)options.LaunchWaitBudget.TotalMilliseconds);
|
||||
string observedPath = observed.ExePath;
|
||||
// THE FOURTH INPUT (FR-2.4, decision D7) is read here and handed to the request, so the refusal is
|
||||
// the gate's — a check upstream of it would make the gate's own "ONLY managed logic" remark false.
|
||||
bool engaged = await IsKillSwitchEngagedAsync(ct).ConfigureAwait(false);
|
||||
@@ -179,37 +231,57 @@ public sealed class CaptureSession(
|
||||
// to attach to is the layer's, and it appears at the title's first vkCreateDevice -- which is
|
||||
// why the attach budget is launch mode's, not the 5 s an already-injected Overlay gets.
|
||||
bool layered = verdict.Reason == AntiCheatRefusalReason.TargetIsVulkanLayered;
|
||||
|
||||
// THE OTHER VERDICT THAT IS NEITHER (owner decision 2026-09-21): the Overlay IS in the target, beside the
|
||||
// anti-cheat the verdict names, because the user overruled the guard for this game. Asked for by name —
|
||||
// IsAllowed is false for it — so this is the only place a bypassed start becomes a session.
|
||||
bool bypassed = verdict.IsAllowedUnderBypass;
|
||||
if (!verdict.IsAllowed && !layered && !bypassed)
|
||||
if (!verdict.IsAllowed && !layered)
|
||||
{
|
||||
return new CaptureOutcome { Reason = RefusalOf(verdict.Reason), Verdict = verdict, LaunchWait = launchWait };
|
||||
// A finding about the game turns its hooking off here and now (owner decision 2026-09-22), not only at
|
||||
// the pre-scan: the guard's start-time scan sees the process and the drivers the pre-scan cannot.
|
||||
bool turnedOff = await TurnHookingOffAsync(observed, verdict, ct).ConfigureAwait(false);
|
||||
var refused = new CaptureOutcome { Reason = RefusalOf(verdict.Reason), Verdict = verdict, LaunchWait = launchWait, HookingTurnedOff = turnedOff };
|
||||
// Launch mode's two guard refusals are the orchestrator's cue to elect a descendant (04_CAPTURE §Launch
|
||||
// mode); holding the launcher's session open would delay that. Every other refusal is Tier 2 from here.
|
||||
return refused.Reason is SessionEndReason.LaunchTargetExited or SessionEndReason.LaunchNoPresentationRuntime
|
||||
? refused
|
||||
: await HoldUnhookedAsync(refused, observedPath, alive, pid, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
TimeSpan attachBudget = layered ? options.LaunchWaitBudget : options.AttachBudget;
|
||||
(ICaptureSink? sink, ShmAttachRefusal refusal) = await AttachAsync(pid, attachBudget, ct).ConfigureAwait(false);
|
||||
if (sink is null)
|
||||
{
|
||||
return new CaptureOutcome
|
||||
return await HoldUnhookedAsync(new CaptureOutcome
|
||||
{
|
||||
Reason = SessionEndReason.AttachRefused,
|
||||
Verdict = verdict,
|
||||
AttachRefusal = refusal,
|
||||
LaunchWait = launchWait,
|
||||
};
|
||||
}, observedPath, alive, pid, ct, stop).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
using (sink)
|
||||
{
|
||||
observer?.Attached(pid, sink.Handshake);
|
||||
CaptureOutcome result = await DrainAsync(pid, alive, sink, verdict, ct, stop).ConfigureAwait(false);
|
||||
return result with { LaunchWait = launchWait, TargetPid = pid, ExitCode = alive.ExitCode, StartedUnderBypass = bypassed ? verdict : null };
|
||||
CaptureOutcome result = await DrainAsync(pid, alive, sink, verdict, observed, ct, stop).ConfigureAwait(false);
|
||||
return result with { LaunchWait = launchWait, TargetPid = pid, ExitCode = alive.ExitCode };
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// What a finding does to the game (owner decision 2026-09-22, <c>19_SAFETY</c>): an anti-cheat named IN the game
|
||||
/// — its process, its folder, its title lists — is written to the row as the pre-scan writes it
|
||||
/// (<c>hook_blocked_reason</c>, <c>hook_enabled = 0</c>), so the next launch of that game is not a new refusal but a
|
||||
/// game whose hooking is off, and its page says why. A machine-wide driver, a scan that could not look and every
|
||||
/// fact about the payload or the launch refuse THIS session and write nothing.
|
||||
/// </summary>
|
||||
private async ValueTask<bool> TurnHookingOffAsync(ExecutableFingerprint observed, AntiCheatVerdict verdict, CancellationToken ct)
|
||||
{
|
||||
if (!verdict.IsFindingAboutTheGame)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return await store.RecordGuardBlockAsync(observed, verdict, ct).ConfigureAwait(false) == ConsentWriteOutcome.Written;
|
||||
}
|
||||
|
||||
private static SessionEndReason RefusalOf(AntiCheatRefusalReason reason) => reason switch
|
||||
{
|
||||
AntiCheatRefusalReason.HookNotEnabled => SessionEndReason.RefusedHookNotEnabled,
|
||||
@@ -255,21 +327,26 @@ public sealed class CaptureSession(
|
||||
}
|
||||
|
||||
private async Task<CaptureOutcome> DrainAsync(int pid, ITargetLiveness alive, ICaptureSink sink,
|
||||
AntiCheatVerdict verdict, CancellationToken ct, CancellationToken stop)
|
||||
AntiCheatVerdict verdict, ExecutableFingerprint observed, CancellationToken ct, CancellationToken stop)
|
||||
{
|
||||
var supervisor = new GuardSupervisor(guard, guardBypassAcknowledged: verdict.IsAllowedUnderBypass);
|
||||
var supervisor = new GuardSupervisor(guard);
|
||||
var state = new DrainState(new ModuleTally(modules, ngx));
|
||||
SessionEndReason end = await SuperviseAsync(pid, alive, sink, supervisor, state, ct, stop).ConfigureAwait(false);
|
||||
|
||||
// On a safety unhook the verdict that matters is the one that FIRED mid-session, not the pass that
|
||||
// let the session start: the pipe's SafetyUnhook names its family and signal (P3 PR-1). And a finding
|
||||
// about the game at the 30 s re-scan turns its hooking off exactly as one at the start does (2026-09-22).
|
||||
AntiCheatVerdict final = end == SessionEndReason.SafetyUnhook && supervisor.LastVerdict is { } fired ? fired : verdict;
|
||||
bool turnedOff = end == SessionEndReason.SafetyUnhook && await TurnHookingOffAsync(observed, final, ct).ConfigureAwait(false);
|
||||
|
||||
return new CaptureOutcome
|
||||
{
|
||||
RuntimeModules = state.Loaded.Set,
|
||||
NgxDriver = state.Loaded.Ngx,
|
||||
TouchQpc = state.Loaded.TouchQpc,
|
||||
Reason = end,
|
||||
// On a safety unhook the verdict that matters is the one that FIRED mid-session, not the pass that
|
||||
// let the session start: the pipe's SafetyUnhook names its family and signal (P3 PR-1).
|
||||
Verdict = end == SessionEndReason.SafetyUnhook && supervisor.LastVerdict is { } fired ? fired : verdict,
|
||||
Verdict = final,
|
||||
HookingTurnedOff = turnedOff,
|
||||
AttachRefusal = ShmAttachRefusal.Ok,
|
||||
Records = state.Records,
|
||||
GapBefore = state.GapBefore,
|
||||
|
||||
@@ -8,4 +8,14 @@ public interface ITargetResolver
|
||||
/// </summary>
|
||||
/// <returns>The pid, or null with <paramref name="reason"/> set.</returns>
|
||||
int? Resolve(string normalisedExePath, out SessionEndReason reason);
|
||||
|
||||
/// <summary>
|
||||
/// Whether the executable is running (2026-09-22). The Tier-2 hold's clock for a target the loop never opened: a game
|
||||
/// whose hooking is off is never opened at all, and a process the resolver could not read cannot be pinned. Where a
|
||||
/// watcher runs it answers from the watcher's snapshot by the IMAGE PATH (2026-09-23 — by file name, another game's
|
||||
/// <c>Game.exe</c> kept an RPG Maker game's hold open), a process whose path could not be read still counting by its
|
||||
/// name; the console verbs, where nothing polls, keep the name. Nothing is ever injected on the strength of this answer;
|
||||
/// it only decides how long duration and telemetry accrue.
|
||||
/// </summary>
|
||||
bool IsRunning(string normalisedExePath);
|
||||
}
|
||||
@@ -153,12 +153,11 @@ public enum SessionEndReason
|
||||
/// <para>
|
||||
/// It was reported as <see cref="TargetAmbiguous"/> until this existed — "more than one process is running it" about
|
||||
/// a single process — and reached the user as a toast reading <c>InjectFailed: TargetAmbiguous</c>, while the
|
||||
/// one-second session was discarded for being short. With the guard bypass on, that was the whole visible result.
|
||||
/// one-second session was discarded for being short.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>The guard bypass does not change it, and nothing will be built that does.</b> The bypass overrules
|
||||
/// FrameLedger's own refusal; a process another product's driver has closed to us stays closed, and opening it
|
||||
/// anyway would be defeating that product — CLAUDE.md rule 3.
|
||||
/// <b>Nothing will be built that changes it.</b> A process another product's driver has closed to us stays closed,
|
||||
/// and opening it anyway would be defeating that product — CLAUDE.md rule 3.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
TargetUnreadable,
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
using FrameLedger.Domain.Consent;
|
||||
|
||||
namespace FrameLedger.Application.Consent;
|
||||
|
||||
/// <summary>
|
||||
/// The record of a human accepting the guard-bypass disclosure for one executable (owner decision 2026-09-21,
|
||||
/// <c>19_SAFETY</c> §The user's bypass). The shape <see cref="OperatorAcknowledgement"/> has, for the same reason: what is
|
||||
/// written is an acknowledgement of a named text at a time, never a flag somebody sets.
|
||||
/// </summary>
|
||||
public sealed record GuardBypassAcknowledgement
|
||||
{
|
||||
public required ExecutableFingerprint Fingerprint { get; init; }
|
||||
|
||||
/// <summary>The version of the bypass disclosure that was shown. Empty is refused: an acknowledgement of nothing is not one.</summary>
|
||||
public required string DisclosureVersion { get; init; }
|
||||
|
||||
public required DateTimeOffset AcknowledgedAt { get; init; }
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
namespace FrameLedger.Application.Consent;
|
||||
|
||||
/// <summary>
|
||||
/// Writes the per-game guard bypass (owner decision 2026-09-21). Reads travel with the consent record
|
||||
/// (<c>GameConsentRecord.GuardBypassAcknowledged</c>), because the gate reads consent and the bypass in one look at one
|
||||
/// row; the writes are their own port so that nothing which can grant consent can also, by the same call, overrule the
|
||||
/// guard.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>It can only be recorded for a row that exists and for the executable that row is about.</b> A game nobody added
|
||||
/// has nothing to bypass, and an acknowledgement for a binary other than the stored one is
|
||||
/// <see cref="ConsentWriteOutcome.StaleFingerprint"/>, never a re-point.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// It writes two columns and no others: not <c>hook_enabled</c>, not the consent stamp, not
|
||||
/// <c>hook_blocked_reason</c>. A block stays on the row and stays true; the gate is what reads the bypass beside it.
|
||||
/// There is no global form of this and no method here that could produce one.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public interface IGuardBypassStore
|
||||
{
|
||||
ValueTask<ConsentWriteOutcome> RecordAsync(GuardBypassAcknowledgement acknowledgement, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Turns the bypass off for the row. Idempotent: a row without one is <see cref="ConsentWriteOutcome.Written"/> too.</summary>
|
||||
ValueTask<ConsentWriteOutcome> RevokeAsync(string normalisedExePath, CancellationToken ct = default);
|
||||
}
|
||||
@@ -36,15 +36,29 @@ public sealed class DetectionSweep : IDisposable
|
||||
private readonly StaticGameDetector _detector;
|
||||
private readonly IExecutableIdentitySource _identity;
|
||||
private readonly Action<string> _log;
|
||||
private readonly ExecutableRelocator? _relocator;
|
||||
private readonly SemaphoreSlim _wake = new(0, 1);
|
||||
|
||||
public DetectionSweep(IGameRepository games, IDetectionRulesSource rules, IGameFileProbe probe, IExecutableIdentitySource identity, Action<string> log)
|
||||
// The path each unreadable entry was last reported at (2026-09-23): said once until it changes or reads again. The
|
||||
// owner's log repeated the same "executable unreadable" line for the same entries every 15 s.
|
||||
private readonly Dictionary<long, string> _unreadableSaid = [];
|
||||
|
||||
/// <summary>The sweep over the library, with the detector it runs and the identity it reads executables with.</summary>
|
||||
/// <param name="games">The library.</param>
|
||||
/// <param name="rules">The detection rules the detector runs.</param>
|
||||
/// <param name="probe">The file probe the detector runs over.</param>
|
||||
/// <param name="identity">Reads each row's executable (its fingerprint), or null when it cannot.</param>
|
||||
/// <param name="log">The Agent's log line.</param>
|
||||
/// <param name="relocator">Follows an executable to a drive that changed its letter (2026-09-22); null sweeps without looking.</param>
|
||||
public DetectionSweep(IGameRepository games, IDetectionRulesSource rules, IGameFileProbe probe, IExecutableIdentitySource identity, Action<string> log,
|
||||
ExecutableRelocator? relocator = null)
|
||||
{
|
||||
_games = games ?? throw new ArgumentNullException(nameof(games));
|
||||
_rules = rules ?? throw new ArgumentNullException(nameof(rules));
|
||||
ArgumentNullException.ThrowIfNull(probe);
|
||||
_identity = identity ?? throw new ArgumentNullException(nameof(identity));
|
||||
_log = log ?? throw new ArgumentNullException(nameof(log));
|
||||
_relocator = relocator;
|
||||
_detector = new StaticGameDetector(rules, probe);
|
||||
}
|
||||
|
||||
@@ -83,48 +97,89 @@ public sealed class DetectionSweep : IDisposable
|
||||
int scanned = 0;
|
||||
int current = 0;
|
||||
int unreadable = 0;
|
||||
foreach (GameRow game in await _games.ListAsync(ct).ConfigureAwait(false))
|
||||
int relocated = 0;
|
||||
foreach (GameRow listed in await _games.ListAsync(ct).ConfigureAwait(false))
|
||||
{
|
||||
ct.ThrowIfCancellationRequested();
|
||||
if (_identity.Read(game.Fingerprint.ExePath) is not { } onDisk)
|
||||
(GameRow game, ExecutableFingerprint? read, bool moved) = await ReadOrRelocateAsync(listed, ct).ConfigureAwait(false);
|
||||
if (moved)
|
||||
{
|
||||
relocated++;
|
||||
}
|
||||
|
||||
if (read is not { } onDisk)
|
||||
{
|
||||
unreadable++;
|
||||
_log($"detect: {game.Name} — executable unreadable, skipped ({game.Fingerprint.ExePath})");
|
||||
if (!_unreadableSaid.TryGetValue(game.Id, out string? said) || !string.Equals(said, game.Fingerprint.ExePath, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
_unreadableSaid[game.Id] = game.Fingerprint.ExePath;
|
||||
_log($"detect: {game.Name} — executable unreadable, skipped ({game.Fingerprint.ExePath}); said once until that changes");
|
||||
}
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
_unreadableSaid.Remove(game.Id);
|
||||
|
||||
if (!IsStale(game, onDisk, rules.RulesVersion))
|
||||
{
|
||||
current++;
|
||||
continue;
|
||||
}
|
||||
|
||||
StaticDetectionResult r = await _detector.DetectAsync(game.Fingerprint.ExePath, ct).ConfigureAwait(false);
|
||||
// The Vulkan fact rides in capability_flags under its own id (P4 PR-2): not a rule id, stored beside them
|
||||
// so one column says what the game ships AND whether the layer is its capture side.
|
||||
IReadOnlyList<string> capabilities = r.UsesVulkan == true
|
||||
? [.. r.CapabilityIds, StaticDetectionResult.VulkanCapabilityId]
|
||||
: r.CapabilityIds;
|
||||
var write = new DetectionWrite
|
||||
{
|
||||
EngineId = r.EngineId,
|
||||
EngineVersion = r.EngineVersion,
|
||||
PlatformId = r.PlatformId,
|
||||
CapabilityIds = capabilities,
|
||||
RulesVersion = r.RulesVersion,
|
||||
ExeSizeBytes = onDisk.SizeBytes,
|
||||
ExeMtimeMs = onDisk.MtimeUnixMs,
|
||||
};
|
||||
if (await _games.ApplyDetectionAsync(game.Id, write, ct).ConfigureAwait(false))
|
||||
if (await ScanAsync(game, onDisk, ct).ConfigureAwait(false))
|
||||
{
|
||||
scanned++;
|
||||
_log($"detect: {game.Name} — engine={r.EngineId ?? (r.EngineUndetermined ? "undetermined" : "none")}"
|
||||
+ $"{(r.EngineVersion is null ? string.Empty : " " + r.EngineVersion)} platform={r.PlatformId ?? (r.PlatformUndetermined ? "undetermined" : "none")}"
|
||||
+ $" capabilities=[{string.Join(",", capabilities)}] vulkan={(r.UsesVulkan is { } v ? (v ? "yes" : "no") : "unknown")} rules={r.RulesVersion}");
|
||||
}
|
||||
}
|
||||
|
||||
return new DetectionSweepReport { Scanned = scanned, Current = current, Unreadable = unreadable };
|
||||
return new DetectionSweepReport { Scanned = scanned, Current = current, Unreadable = unreadable, Relocated = relocated };
|
||||
}
|
||||
|
||||
/// <summary>One game through the detector and into the row; true when the row took the write.</summary>
|
||||
private async ValueTask<bool> ScanAsync(GameRow game, ExecutableFingerprint onDisk, CancellationToken ct)
|
||||
{
|
||||
StaticDetectionResult r = await _detector.DetectAsync(game.Fingerprint.ExePath, ct).ConfigureAwait(false);
|
||||
// The Vulkan fact rides in capability_flags under its own id (P4 PR-2): not a rule id, stored beside them
|
||||
// so one column says what the game ships AND whether the layer is its capture side.
|
||||
IReadOnlyList<string> capabilities = r.UsesVulkan == true
|
||||
? [.. r.CapabilityIds, StaticDetectionResult.VulkanCapabilityId]
|
||||
: r.CapabilityIds;
|
||||
var write = new DetectionWrite
|
||||
{
|
||||
EngineId = r.EngineId,
|
||||
EngineVersion = r.EngineVersion,
|
||||
PlatformId = r.PlatformId,
|
||||
CapabilityIds = capabilities,
|
||||
RulesVersion = r.RulesVersion,
|
||||
ExeSizeBytes = onDisk.SizeBytes,
|
||||
ExeMtimeMs = onDisk.MtimeUnixMs,
|
||||
};
|
||||
if (!await _games.ApplyDetectionAsync(game.Id, write, ct).ConfigureAwait(false))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
_log($"detect: {game.Name} — engine={r.EngineId ?? (r.EngineUndetermined ? "undetermined" : "none")}"
|
||||
+ $"{(r.EngineVersion is null ? string.Empty : " " + r.EngineVersion)} platform={r.PlatformId ?? (r.PlatformUndetermined ? "undetermined" : "none")}"
|
||||
+ $" capabilities=[{string.Join(",", capabilities)}] vulkan={(r.UsesVulkan is { } v ? (v ? "yes" : "no") : "unknown")} rules={r.RulesVersion}");
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The row's executable as read from disk — and, when it is missing, one more question before the row is skipped
|
||||
/// (2026-09-22): is the same file under another drive letter? When it is, the row follows it and this very pass
|
||||
/// scans it there.
|
||||
/// </summary>
|
||||
private async ValueTask<(GameRow Game, ExecutableFingerprint? Read, bool Moved)> ReadOrRelocateAsync(GameRow game, CancellationToken ct)
|
||||
{
|
||||
ExecutableFingerprint? read = _identity.Read(game.Fingerprint.ExePath);
|
||||
if (read is not null || _relocator is null || await _relocator.TryRelocateAsync(game, ct).ConfigureAwait(false) is not { } moved)
|
||||
{
|
||||
return (game, read, false);
|
||||
}
|
||||
|
||||
return (game with { Fingerprint = moved }, _identity.Read(moved.ExePath), true);
|
||||
}
|
||||
|
||||
/// <summary><c>DetectionCacheKey</c> compared field by field against the row: any difference is a re-run.</summary>
|
||||
|
||||
@@ -12,6 +12,9 @@ public sealed record DetectionSweepReport
|
||||
/// <summary>Games whose executable could not be read, skipped.</summary>
|
||||
public int Unreadable { get; init; }
|
||||
|
||||
/// <summary>Rows whose executable was found under another drive letter and moved there this pass (2026-09-22).</summary>
|
||||
public int Relocated { get; init; }
|
||||
|
||||
/// <summary>The rules file could not be loaded; nothing was scanned.</summary>
|
||||
public bool RulesUnusable { get; init; }
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
namespace FrameLedger.Application.Import;
|
||||
|
||||
/// <summary>
|
||||
/// The name an entry gets when the user adds an executable by hand (2026-09-23). The file name is the right answer for
|
||||
/// <c>DarkSoulsIII.exe</c> and the wrong one for <c>Game.exe</c>: every RPG Maker game, and a good share of engine
|
||||
/// runtimes, ship an executable whose name says nothing about the game. For those the engine's own title wins when there
|
||||
/// is one (RPG Maker's <c>System.json</c> <c>gameTitle</c>), then the nearest folder that is not a runtime folder — so
|
||||
/// <i>HELLO, HELLO WORLD!</i>'s <c>swiftshader\Game.exe</c> is "HELLO, HELLO WORLD!", not "Game" or "swiftshader".
|
||||
/// </summary>
|
||||
public static class GameTitleGuess
|
||||
{
|
||||
// Executable stems that name a runtime or a role, never a game.
|
||||
private static readonly HashSet<string> _generic = new(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
"game", "nw", "launcher", "launch", "start", "play", "main", "app", "client", "run", "runtime", "engine",
|
||||
"player", "bootstrap", "bootstrapper", "win64", "shipping",
|
||||
};
|
||||
|
||||
// Folders an engine puts its executable in; the game's name is above them.
|
||||
private static readonly HashSet<string> _runtimeFolders = new(StringComparer.OrdinalIgnoreCase)
|
||||
{
|
||||
"swiftshader", "bin", "binaries", "win64", "win32", "x64", "x86", "www", "nw", "game", "exe", "app", "runtime",
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// The name for <paramref name="exePath"/>: its file name when that names something, else <paramref name="engineTitle"/>
|
||||
/// (asked only then — it reads a file), else the nearest folder that is not a runtime folder, else the file name.
|
||||
/// </summary>
|
||||
public static string Guess(string exePath, Func<string?>? engineTitle = null)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(exePath);
|
||||
string stem = Path.GetFileNameWithoutExtension(exePath);
|
||||
if (!_generic.Contains(stem))
|
||||
{
|
||||
return stem;
|
||||
}
|
||||
|
||||
if (engineTitle?.Invoke() is { } title && !string.IsNullOrWhiteSpace(title))
|
||||
{
|
||||
return title.Trim();
|
||||
}
|
||||
|
||||
for (string? dir = Path.GetDirectoryName(exePath); !string.IsNullOrEmpty(dir); dir = Path.GetDirectoryName(dir))
|
||||
{
|
||||
string name = Path.GetFileName(dir);
|
||||
if (name.Length > 0 && !_runtimeFolders.Contains(name))
|
||||
{
|
||||
return name;
|
||||
}
|
||||
}
|
||||
|
||||
return stem;
|
||||
}
|
||||
}
|
||||
@@ -25,7 +25,6 @@ public sealed class AgentCommandHandler
|
||||
{
|
||||
private readonly IGameRepository _games;
|
||||
private readonly IGameConsentStore _consent;
|
||||
private readonly IGuardBypassStore? _bypass;
|
||||
private readonly IAntiCheatGuard _guard;
|
||||
private readonly IExecutableIdentitySource _identity;
|
||||
private readonly CaptureOrchestrator _orchestrator;
|
||||
@@ -36,6 +35,7 @@ public sealed class AgentCommandHandler
|
||||
private readonly TimeProvider _clock;
|
||||
private readonly VkLayerReconciler? _layer;
|
||||
private readonly Func<CancellationToken, ValueTask<SweepRetentionAck>>? _sweepRetention;
|
||||
private readonly ExecutableRelocator? _relocator;
|
||||
|
||||
/// <summary>
|
||||
/// <c>disclosureVersion</c> is the version of FR-2.1's reviewed disclosure this Agent carries
|
||||
@@ -45,11 +45,11 @@ public sealed class AgentCommandHandler
|
||||
public AgentCommandHandler(IGameRepository games, IGameConsentStore consent, IAntiCheatGuard guard, IExecutableIdentitySource identity,
|
||||
CaptureOrchestrator orchestrator, CapturePause pause, IAgentLifetime lifetime, Func<CancellationToken, ValueTask<string>> updateRules,
|
||||
string? disclosureVersion = null, TimeProvider? clock = null, VkLayerReconciler? layer = null,
|
||||
Func<CancellationToken, ValueTask<SweepRetentionAck>>? sweepRetention = null, IGuardBypassStore? bypass = null)
|
||||
Func<CancellationToken, ValueTask<SweepRetentionAck>>? sweepRetention = null, ExecutableRelocator? relocator = null)
|
||||
{
|
||||
// Owner decision 2026-09-21: the per-game guard bypass. Null where nothing composed it, and SetGuardBypass then
|
||||
// answers DisclosureUnavailable - a handler that cannot record the acknowledgement must not pretend it did.
|
||||
_bypass = bypass;
|
||||
// A drive that changed its letter (2026-09-22): the click that enables hooking looks for the file under another root
|
||||
// before it says the executable cannot be read.
|
||||
_relocator = relocator;
|
||||
// P4 PR-7: Tools ▸ Database maintenance's sweep — composed under --serve, absent (UnknownType) where nothing wired it.
|
||||
_sweepRetention = sweepRetention;
|
||||
_clock = clock ?? TimeProvider.System;
|
||||
@@ -79,7 +79,6 @@ public sealed class AgentCommandHandler
|
||||
IpcMessageType.SetWatchlist => await SetWatchlistAsync(request, ct).ConfigureAwait(false),
|
||||
IpcMessageType.LaunchGame => await LaunchAsync(request, ct).ConfigureAwait(false),
|
||||
IpcMessageType.SetHookEnabled => await SetHookEnabledAsync(request, ct).ConfigureAwait(false),
|
||||
IpcMessageType.SetGuardBypass => await SetGuardBypassAsync(request, ct).ConfigureAwait(false),
|
||||
IpcMessageType.PauseCapture => IpcCodec.Encode(IpcMessageType.PauseAck, request.Id, new PauseAck(_pause.Set(true))),
|
||||
IpcMessageType.ResumeCapture => IpcCodec.Encode(IpcMessageType.PauseAck, request.Id, new PauseAck(_pause.Set(false))),
|
||||
IpcMessageType.StopSession => Stop(request),
|
||||
@@ -165,6 +164,12 @@ public sealed class AgentCommandHandler
|
||||
}
|
||||
|
||||
ExecutableFingerprint? fingerprint = _identity.Read(path);
|
||||
if (fingerprint is null && _relocator is not null && await _relocator.TryRelocateAsync(game, ct).ConfigureAwait(false) is { } moved)
|
||||
{
|
||||
path = moved.ExePath;
|
||||
fingerprint = moved;
|
||||
}
|
||||
|
||||
if (fingerprint is null)
|
||||
{
|
||||
return Error(request, IpcErrorCode.ExecutableUnreadable, $"{path} could not be read, so nothing can be scanned or stamped");
|
||||
@@ -177,18 +182,6 @@ public sealed class AgentCommandHandler
|
||||
// A refusal, or a scan that reached no answer: the store records which (a default verdict is
|
||||
// "could not verify", never a block), and both are answered as a refusal to enable.
|
||||
await _consent.RecordGuardBlockAsync(fingerprint.Value, verdict, ct).ConfigureAwait(false);
|
||||
|
||||
// THE USER'S BYPASS (owner decision 2026-09-21). The finding above is still WRITTEN - the block stays on
|
||||
// the row and stays true - and then, for a game whose owner accepted the bypass disclosure for this very
|
||||
// executable, the consent is stamped anyway. Only the guard's judgement is overruled: a verdict that is a
|
||||
// fact (none reaches this call today) still refuses.
|
||||
GameConsentRecord recorded = await _consent.FindAsync(path, ct).ConfigureAwait(false);
|
||||
bool judgement = verdict.Reason == AntiCheatRefusalReason.Allow || AntiCheatVerdict.IsGuardJudgement(verdict.Reason);
|
||||
if (recorded.GuardBypassAcknowledged && recorded.Fingerprint.Matches(fingerprint.Value) && judgement)
|
||||
{
|
||||
return await StampAsync(request, game, fingerprint.Value, payload.DisclosureVersion, "bypassed", ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
await ReconcileLayerAsync(ct).ConfigureAwait(false);
|
||||
string reason = verdict.Reason == AntiCheatRefusalReason.Allow ? "PreScanCouldNotVerify" : verdict.Reason.ToString();
|
||||
return IpcCodec.Encode(IpcMessageType.Refused, request.Id,
|
||||
@@ -198,60 +191,6 @@ public sealed class AgentCommandHandler
|
||||
return await StampAsync(request, game, fingerprint.Value, payload.DisclosureVersion, "clean", ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Owner decision 2026-09-21: record, or withdraw, the user's acknowledgement of the guard-bypass disclosure for one
|
||||
/// game. It writes two columns and enables nothing - hooking, consent and the block are untouched - and it is
|
||||
/// refused for any disclosure version but this Agent's own, for an executable that cannot be read, and where no
|
||||
/// store was composed. The pipe is not a trust boundary, so everything the App checked is checked again here.
|
||||
/// </summary>
|
||||
private async ValueTask<byte[]> SetGuardBypassAsync(IpcEnvelope request, CancellationToken ct)
|
||||
{
|
||||
SetGuardBypassRequest? payload = IpcCodec.Payload<SetGuardBypassRequest>(request);
|
||||
if (payload is null)
|
||||
{
|
||||
return Malformed(request, "SetGuardBypass carries no payload");
|
||||
}
|
||||
|
||||
GameRow? game = await FindGameAsync(payload.GameId, ct).ConfigureAwait(false);
|
||||
if (game is null)
|
||||
{
|
||||
return Error(request, IpcErrorCode.UnknownGame, $"no games row has id {payload.GameId}");
|
||||
}
|
||||
|
||||
if (_bypass is null)
|
||||
{
|
||||
return Error(request, IpcErrorCode.DisclosureUnavailable, "this Agent was composed without the guard-bypass store; nothing was recorded");
|
||||
}
|
||||
|
||||
string path = game.Fingerprint.ExePath;
|
||||
if (!payload.Enabled)
|
||||
{
|
||||
ConsentWriteOutcome revoked = await _bypass.RevokeAsync(path, ct).ConfigureAwait(false);
|
||||
return IpcCodec.Encode(IpcMessageType.GuardBypassAck, request.Id, new GuardBypassAck(game.Id, Enabled: false, revoked.ToString()));
|
||||
}
|
||||
|
||||
if (!string.Equals(payload.DisclosureVersion, GuardBypassDisclosure.Version, StringComparison.Ordinal))
|
||||
{
|
||||
return Error(request, IpcErrorCode.DisclosureVersionMismatch,
|
||||
$"the client showed bypass disclosure '{payload.DisclosureVersion ?? "(none)"}' and this Agent records '{GuardBypassDisclosure.Version}': nothing was recorded - restart both");
|
||||
}
|
||||
|
||||
ExecutableFingerprint? fingerprint = _identity.Read(path);
|
||||
if (fingerprint is null)
|
||||
{
|
||||
return Error(request, IpcErrorCode.ExecutableUnreadable, $"{path} could not be read, so there is no executable to record the bypass for");
|
||||
}
|
||||
|
||||
ConsentWriteOutcome outcome = await _bypass.RecordAsync(new GuardBypassAcknowledgement
|
||||
{
|
||||
Fingerprint = fingerprint.Value,
|
||||
DisclosureVersion = GuardBypassDisclosure.Version,
|
||||
AcknowledgedAt = _clock.GetUtcNow(),
|
||||
}, ct).ConfigureAwait(false);
|
||||
return IpcCodec.Encode(IpcMessageType.GuardBypassAck, request.Id,
|
||||
new GuardBypassAck(game.Id, Enabled: outcome == ConsentWriteOutcome.Written, outcome.ToString()));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The stamp (P3 PR-4, D14): the client's version must be this Agent's — a client that showed other text, or
|
||||
/// none, gets <c>DisclosureVersionMismatch</c> and nothing written; a composition with no version at all gets
|
||||
|
||||
@@ -38,8 +38,8 @@ public static class RecordedSessionEvents
|
||||
{
|
||||
SessionEndReason.RefusedByGuard or SessionEndReason.RefusedPreviouslyBlocked
|
||||
or SessionEndReason.PreScanCouldNotVerify or SessionEndReason.RefusedKillSwitch
|
||||
// A persistent notice that says why, not a toast with a code: the user enabled hooking (perhaps the bypass
|
||||
// too), started the game and would otherwise see nothing at all.
|
||||
// A persistent notice that says why, not a toast with a code: the user enabled hooking, started the game
|
||||
// and would otherwise see nothing at all.
|
||||
or SessionEndReason.TargetUnreadable => Kind.Refused,
|
||||
SessionEndReason.SafetyUnhook => Kind.SafetyUnhook,
|
||||
SessionEndReason.SupervisionLost or SessionEndReason.WriterSelfDisabled or SessionEndReason.WriterStoppedBlocklisted
|
||||
@@ -71,10 +71,10 @@ public static class RecordedSessionEvents
|
||||
{
|
||||
case Kind.Refused:
|
||||
pipe.Publish(IpcMessageType.CaptureRefused,
|
||||
new CaptureRefusedEvent(info.GameId, info.GameName, o.Reason.ToString(), NullIfEmpty(o.Verdict.Family), NullIfEmpty(o.Verdict.Signal)));
|
||||
new CaptureRefusedEvent(info.GameId, info.GameName, o.Reason.ToString(), NullIfEmpty(o.Verdict.Family), NullIfEmpty(o.Verdict.Signal), o.HookingTurnedOff));
|
||||
break;
|
||||
case Kind.SafetyUnhook:
|
||||
pipe.Publish(IpcMessageType.SafetyUnhook, new SafetyUnhookEvent(guid, NullIfEmpty(o.Verdict.Family), NullIfEmpty(o.Verdict.Signal)));
|
||||
pipe.Publish(IpcMessageType.SafetyUnhook, new SafetyUnhookEvent(guid, NullIfEmpty(o.Verdict.Family), NullIfEmpty(o.Verdict.Signal), o.HookingTurnedOff));
|
||||
break;
|
||||
case Kind.Degraded:
|
||||
pipe.Publish(IpcMessageType.CaptureDegraded, new CaptureDegradedEvent(guid, From: 1, To: 2, o.Reason.ToString()));
|
||||
@@ -104,6 +104,7 @@ public static class RecordedSessionEvents
|
||||
FinalizeStatus.Saved => "saved",
|
||||
FinalizeStatus.Discarded => "discarded",
|
||||
FinalizeStatus.AlreadyStored => "already_stored",
|
||||
FinalizeStatus.GameRemoved => "game_removed",
|
||||
_ => status.ToString(),
|
||||
};
|
||||
|
||||
|
||||
@@ -75,12 +75,6 @@ public sealed record GameRow
|
||||
/// <summary><c>not_run|clean|blocked|unverified</c> (<c>05_DETECTION</c>'s tri-state pre-scan plus "not run").</summary>
|
||||
public string HookPrescanState { get; init; } = "not_run";
|
||||
|
||||
/// <summary>
|
||||
/// When the user accepted the guard-bypass disclosure for this game (schema 0007, owner decision 2026-09-21), or
|
||||
/// null: the bypass is off. Display only — the gate reads it from the consent record, never from here.
|
||||
/// </summary>
|
||||
public DateTimeOffset? GuardBypassAt { get; init; }
|
||||
|
||||
/// <summary>FR-1.4: set when the user removed the game but kept its sessions; such a row is not in the library.</summary>
|
||||
public DateTimeOffset? RemovedAt { get; init; }
|
||||
|
||||
|
||||
@@ -34,6 +34,17 @@ public interface IGameRepository
|
||||
/// </summary>
|
||||
ValueTask<bool> ChangeExecutableAsync(long gameId, ExecutableFingerprint fingerprint, DateTimeOffset at, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Points a library row at the SAME executable under another path (2026-09-22; <c>19_SAFETY</c> §A moved drive is the
|
||||
/// same executable): the drive changed its letter, the bytes did not. Unlike <see cref="ChangeExecutableAsync"/> it
|
||||
/// keeps everything — consent, block, pre-scan state, detection — because the fingerprint's size and mtime are the
|
||||
/// executable's identity and the path is only where it lives; the write itself requires them to match
|
||||
/// (<c>WHERE exe_size_bytes = @size AND exe_mtime_ms = @mtime</c>), so a different binary cannot inherit a consent
|
||||
/// through this call. False when the row is absent or removed, when the bytes differ, or when another row already
|
||||
/// owns the new path.
|
||||
/// </summary>
|
||||
ValueTask<bool> RelocateExecutableAsync(long gameId, ExecutableFingerprint moved, DateTimeOffset at, CancellationToken ct = default);
|
||||
|
||||
ValueTask<int> RecordCrashAsync(long gameId, CancellationToken ct = default);
|
||||
|
||||
ValueTask<bool> RecordInjectionAsync(long gameId, DateTimeOffset at, CancellationToken ct = default);
|
||||
|
||||
@@ -7,8 +7,21 @@ namespace FrameLedger.Application.Persistence;
|
||||
/// </summary>
|
||||
public interface ISessionRepository
|
||||
{
|
||||
/// <summary>
|
||||
/// Writes the session under <c>session.Row.GameId</c>, in one transaction. Throws <see cref="SessionOwnerMissingException"/>
|
||||
/// — never the foreign key's <c>SqliteException</c> — when that row no longer exists at the moment of the write.
|
||||
/// </summary>
|
||||
ValueTask<long> InsertFinalizedAsync(FinalizedSession session, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// The <c>games</c> row a finishing session belongs to (2026-09-23), or null when there is none any more:
|
||||
/// <paramref name="gameId"/> when that row existed before the session started or holds its executable (an id SQLite
|
||||
/// reused for a later game is neither), else the row that holds <paramref name="exePath"/> — the game re-imported
|
||||
/// while the session ran. Two GIRLS' FRONTLINE 2 sessions on 2026-09-22/23 died on the foreign key because their
|
||||
/// entry was removed and re-imported mid-session.
|
||||
/// </summary>
|
||||
ValueTask<long?> ResolveOwnerAsync(long gameId, string? exePath, DateTimeOffset startedAt, CancellationToken ct = default);
|
||||
|
||||
ValueTask<bool> ExistsAsync(Guid sessionGuid, CancellationToken ct = default);
|
||||
|
||||
ValueTask<SessionRow?> FindAsync(Guid sessionGuid, CancellationToken ct = default);
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
namespace FrameLedger.Application.Persistence;
|
||||
|
||||
/// <summary>
|
||||
/// The session's <c>games</c> row was deleted between the finalizer's owner lookup and its write (2026-09-23): the
|
||||
/// repository checks inside the write transaction and throws this rather than letting the foreign key throw a
|
||||
/// <c>SqliteException</c> the caller cannot tell from a real fault. The finalizer answers it as
|
||||
/// <c>FinalizeStatus.GameRemoved</c>.
|
||||
/// </summary>
|
||||
public sealed class SessionOwnerMissingException : Exception
|
||||
{
|
||||
public SessionOwnerMissingException()
|
||||
{
|
||||
}
|
||||
|
||||
public SessionOwnerMissingException(string message)
|
||||
: base(message)
|
||||
{
|
||||
}
|
||||
|
||||
public SessionOwnerMissingException(string message, Exception innerException)
|
||||
: base(message, innerException)
|
||||
{
|
||||
}
|
||||
}
|
||||
@@ -258,18 +258,4 @@ public sealed record SessionRow
|
||||
public double? AvgGpuPowerW { get; init; }
|
||||
|
||||
public double? ThrottlePct { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// True when the session STARTED under the user's guard bypass (schema 0007, owner decision 2026-09-21): the guard
|
||||
/// refused on its own judgement and the Overlay was injected anyway. False for every other session, every earlier
|
||||
/// row, and a session recovered from a <c>.partial</c> (the verdict is known only to the live loop). Every surface
|
||||
/// that shows the session, and every export, says so.
|
||||
/// </summary>
|
||||
public bool GuardBypassed { get; init; }
|
||||
|
||||
/// <summary>The anti-cheat family the guard named at that start, when it named one.</summary>
|
||||
public string? GuardBypassFamily { get; init; }
|
||||
|
||||
/// <summary>The module, driver or file that produced the finding.</summary>
|
||||
public string? GuardBypassSignal { get; init; }
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
namespace FrameLedger.Application.Recording;
|
||||
|
||||
/// <summary>
|
||||
/// The words <c>sessions.capture_notes</c> is made of (<c>ExitStatusMapper.Describe</c>, <c>SessionRecorder.Skeleton</c>):
|
||||
/// <c>end=<SessionEndReason>; exit_code=…; tier2: attach=…; guard=<reason>/<family>/<signal>; …</c>.
|
||||
/// Read back so a Tier-2 row can say WHY it measured nothing (<c>04_CAPTURE</c>: "the reason is the payload of Tier 2"),
|
||||
/// which the schema keeps in this one text column rather than in fields (2026-09-22).
|
||||
/// </summary>
|
||||
public readonly record struct CaptureNotes(string? End, string? GuardReason, string? GuardFamily, string? GuardSignal)
|
||||
{
|
||||
public static CaptureNotes Parse(string? notes)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(notes))
|
||||
{
|
||||
return default;
|
||||
}
|
||||
|
||||
string? end = null, reason = null, family = null, signal = null;
|
||||
foreach (string raw in notes.Split(';'))
|
||||
{
|
||||
string part = raw.Trim();
|
||||
if (part.StartsWith("end=", StringComparison.Ordinal))
|
||||
{
|
||||
end = part[4..];
|
||||
}
|
||||
else if (part.StartsWith("guard=", StringComparison.Ordinal))
|
||||
{
|
||||
string[] words = part[6..].Split('/', 3);
|
||||
reason = words.Length > 0 && words[0].Length > 0 ? words[0] : null;
|
||||
family = words.Length > 1 && words[1].Length > 0 ? words[1] : null;
|
||||
signal = words.Length > 2 && words[2].Length > 0 ? words[2] : null;
|
||||
}
|
||||
}
|
||||
|
||||
return new CaptureNotes(end, reason, family, signal);
|
||||
}
|
||||
}
|
||||
@@ -19,4 +19,11 @@ public sealed record FinalizeInput
|
||||
|
||||
/// <summary><c>04_CAPTURE</c> §Discard rule: shorter than this is dropped. The Agent keeps the default; the unshipped host lowers it for bounded operator captures.</summary>
|
||||
public TimeSpan MinimumSessionLength { get; init; } = SessionFinalizer.MinimumSessionLength;
|
||||
|
||||
/// <summary>
|
||||
/// The normalised executable the session ran (2026-09-23): how the finalizer finds the session's row when the one it
|
||||
/// started under is gone — removed while it ran, or its id reused by another game (<c>games.id</c> has no
|
||||
/// AUTOINCREMENT). Null keeps the old behaviour: the skeleton's <c>GameId</c>, or nothing when that row is gone.
|
||||
/// </summary>
|
||||
public string? ExePath { get; init; }
|
||||
}
|
||||
@@ -2,6 +2,9 @@ using System.Runtime.InteropServices;
|
||||
|
||||
namespace FrameLedger.Application.Recording;
|
||||
|
||||
/// <summary>What finalizing did.</summary>
|
||||
/// <summary>
|
||||
/// What finalizing did. <see cref="GameId"/> is the row the session was stored under when that is known — the one it
|
||||
/// started under, or the row that holds its executable's path when that one was removed while it ran (2026-09-23).
|
||||
/// </summary>
|
||||
[StructLayout(LayoutKind.Auto)]
|
||||
public readonly record struct FinalizeOutcome(FinalizeStatus Status, long? SessionId, int RetentionSwept);
|
||||
public readonly record struct FinalizeOutcome(FinalizeStatus Status, long? SessionId, int RetentionSwept, long? GameId = null);
|
||||
@@ -10,4 +10,11 @@ public enum FinalizeStatus
|
||||
|
||||
/// <summary>A session with this guid was already stored — recovery ran after a finalize that did land.</summary>
|
||||
AlreadyStored,
|
||||
|
||||
/// <summary>
|
||||
/// No <c>games</c> row owns the session any more (2026-09-23): its entry was removed with its sessions while it ran,
|
||||
/// and no row holds its executable's path either. Nothing is written; the caller deletes the <c>.partial</c> as it does
|
||||
/// for <see cref="Discarded"/>. Until this value existed the insert died on the foreign key and the session FAULTED.
|
||||
/// </summary>
|
||||
GameRemoved,
|
||||
}
|
||||
@@ -19,4 +19,11 @@ public interface IPartialSessionStore
|
||||
|
||||
/// <summary>Removes the file; a missing file is not an error.</summary>
|
||||
void Delete(Guid sessionGuid);
|
||||
|
||||
/// <summary>
|
||||
/// Sets the file aside as <c><guid>.partial.failed</c> (2026-09-23): out of <see cref="ListPending"/>, never
|
||||
/// retried, kept for a bug report. What recovery does with a file it could not finalize, so that one bad file cannot
|
||||
/// stop every later start. A missing file is not an error.
|
||||
/// </summary>
|
||||
void Quarantine(Guid sessionGuid);
|
||||
}
|
||||
@@ -6,9 +6,16 @@ namespace FrameLedger.Application.Recording;
|
||||
/// <summary>
|
||||
/// The Agent's first act at startup (<c>04_CAPTURE</c> §Session recorder: <c>Interrupted → recovered from
|
||||
/// .partial</c>): every pending file becomes an <c>interrupted</c> session from its valid prefix, or is
|
||||
/// dropped for one of three stated reasons — already stored, too short, unreadable. Nothing is retried,
|
||||
/// nothing is left behind.
|
||||
/// dropped for one of four stated reasons — already stored, too short, unreadable, its game removed. Nothing is
|
||||
/// retried, nothing is left behind.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <b>Recovery never throws (2026-09-23).</b> It runs before the watcher on every start, and the host stops on a
|
||||
/// background service's exception: one file whose finalize failed — two GIRLS' FRONTLINE 2 sessions whose entry was
|
||||
/// removed mid-session left exactly that — would have stopped every start from then on, and with it every capture.
|
||||
/// A file that cannot be finalized is set aside (<see cref="IPartialSessionStore.Quarantine"/>) and reported as
|
||||
/// <see cref="RecoveryStatus.Failed"/>; the next file is recovered.
|
||||
/// </remarks>
|
||||
public sealed class PartialRecovery
|
||||
{
|
||||
private readonly IPartialSessionStore _store;
|
||||
@@ -29,14 +36,48 @@ public sealed class PartialRecovery
|
||||
public async ValueTask<IReadOnlyList<RecoveryOutcome>> RecoverAsync(CancellationToken ct = default)
|
||||
{
|
||||
var outcomes = new List<RecoveryOutcome>();
|
||||
foreach (Guid guid in _store.ListPending())
|
||||
IReadOnlyList<Guid> pending;
|
||||
try
|
||||
{
|
||||
outcomes.Add(await RecoverOneAsync(guid, ct).ConfigureAwait(false));
|
||||
pending = _store.ListPending();
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
outcomes.Add(new RecoveryOutcome(Guid.Empty, RecoveryStatus.Failed, null, $"the pending files could not be listed — {ex.GetType().Name}: {ex.Message}"));
|
||||
return outcomes;
|
||||
}
|
||||
|
||||
foreach (Guid guid in pending)
|
||||
{
|
||||
outcomes.Add(await RecoverOrSetAsideAsync(guid, ct).ConfigureAwait(false));
|
||||
}
|
||||
|
||||
return outcomes;
|
||||
}
|
||||
|
||||
private async ValueTask<RecoveryOutcome> RecoverOrSetAsideAsync(Guid guid, CancellationToken ct)
|
||||
{
|
||||
try
|
||||
{
|
||||
return await RecoverOneAsync(guid, ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex) when (ex is not OperationCanceledException and not OutOfMemoryException)
|
||||
{
|
||||
string aside;
|
||||
try
|
||||
{
|
||||
_store.Quarantine(guid);
|
||||
aside = "set aside as .partial.failed";
|
||||
}
|
||||
catch (Exception move) when (move is IOException or UnauthorizedAccessException)
|
||||
{
|
||||
aside = $"and could not be set aside ({move.GetType().Name}: {move.Message}); it will be tried again at the next start";
|
||||
}
|
||||
|
||||
return new RecoveryOutcome(guid, RecoveryStatus.Failed, null, $"{ex.GetType().Name}: {ex.Message} — {aside}");
|
||||
}
|
||||
}
|
||||
|
||||
private async ValueTask<RecoveryOutcome> RecoverOneAsync(Guid guid, CancellationToken ct)
|
||||
{
|
||||
PartialSession? partial = _store.Read(guid);
|
||||
@@ -46,14 +87,17 @@ public sealed class PartialRecovery
|
||||
return new RecoveryOutcome(guid, RecoveryStatus.Unreadable, null, "no readable header");
|
||||
}
|
||||
|
||||
FinalizeInput input = ToInput(partial) with { MinimumSessionLength = _minimumSessionLength };
|
||||
FinalizeInput input = ToInput(partial) with { MinimumSessionLength = _minimumSessionLength, ExePath = partial.Header.ExePath };
|
||||
FinalizeOutcome result = await _finalizer.FinalizeAsync(input, ct).ConfigureAwait(false);
|
||||
_store.Delete(guid);
|
||||
return result.Status switch
|
||||
{
|
||||
FinalizeStatus.Saved => new RecoveryOutcome(guid, RecoveryStatus.Recovered, result.SessionId,
|
||||
$"{partial.Records.Count} record(s), {partial.Sensors.Count} sensor sample(s){(partial.Truncated ? ", tail truncated" : "")}"),
|
||||
$"{partial.Records.Count} record(s), {partial.Sensors.Count} sensor sample(s){(partial.Truncated ? ", tail truncated" : "")}"
|
||||
+ (result.GameId is { } owner && owner != partial.Header.GameId ? $"; stored under games row {owner}, which holds {partial.Header.ExePath} now" : "")),
|
||||
FinalizeStatus.AlreadyStored => new RecoveryOutcome(guid, RecoveryStatus.AlreadyStored, null, "the finalize had landed"),
|
||||
FinalizeStatus.GameRemoved => new RecoveryOutcome(guid, RecoveryStatus.GameRemoved, null,
|
||||
$"games row {partial.Header.GameId} is gone and no row holds {partial.Header.ExePath}: its game was removed with its sessions"),
|
||||
_ => new RecoveryOutcome(guid, RecoveryStatus.Discarded, null,
|
||||
$"{input.Skeleton.DurationSeconds:0.#} s is under the {input.MinimumSessionLength.TotalSeconds:0} s minimum"),
|
||||
};
|
||||
@@ -71,7 +115,9 @@ public sealed class PartialRecovery
|
||||
PartialHeader h = partial.Header;
|
||||
DateTimeOffset endedAt = EndedAt(partial);
|
||||
PartialNote? attached = partial.Notes.Cast<PartialNote?>().FirstOrDefault(n => n!.Value.Text.StartsWith("attached ", StringComparison.Ordinal));
|
||||
bool hooked = h.Tier == CaptureTier.Hooked || attached is not null || partial.LastTick is not null || partial.Records.Count > 0;
|
||||
// A tick is no longer proof of a hooked session: a held Tier-2 session (2026-09-22) flushes ticks too, with no
|
||||
// records and no attached note. The attach note and the records are the proof.
|
||||
bool hooked = h.Tier == CaptureTier.Hooked || attached is not null || partial.Records.Count > 0;
|
||||
string? buildId = h.OverlayBuildId ?? BuildIdOf(attached?.Text);
|
||||
string notes = "end=Interrupted; recovered from .partial"
|
||||
+ (partial.Truncated ? " (tail truncated)" : "")
|
||||
|
||||
@@ -13,4 +13,13 @@ public enum RecoveryStatus
|
||||
|
||||
/// <summary>No readable header: nothing to recover, and the file is gone.</summary>
|
||||
Unreadable,
|
||||
|
||||
/// <summary>Its game is no longer in the ledger and no row holds its executable's path: nothing written, the file is gone.</summary>
|
||||
GameRemoved,
|
||||
|
||||
/// <summary>
|
||||
/// Recovering it threw. The file is set aside as <c><guid>.partial.failed</c> — kept for a bug report, never
|
||||
/// retried — and recovery goes on to the next file, so one bad file can never stop the watcher from starting.
|
||||
/// </summary>
|
||||
Failed,
|
||||
}
|
||||
@@ -30,7 +30,7 @@ public static class SessionAggregator
|
||||
row = ApplyUpscaler(row, ctx);
|
||||
row = ApplyRt(row, ctx);
|
||||
row = ApplyWriter(row, ctx);
|
||||
row = ApplySensors(row, ctx);
|
||||
row = WithSensorAggregates(row, input.Sensors);
|
||||
row = ApplyWitnesses(row, ctx);
|
||||
|
||||
return new AggregationResult
|
||||
@@ -174,9 +174,15 @@ public static class SessionAggregator
|
||||
};
|
||||
}
|
||||
|
||||
private static SessionRow ApplySensors(SessionRow row, Context c)
|
||||
/// <summary>
|
||||
/// The sensor columns from the session's telemetry samples — the one aggregation a Tier-2 row shares with a hooked
|
||||
/// one (2026-09-22): a held session has no frames and every sensor the machine could provide.
|
||||
/// </summary>
|
||||
public static SessionRow WithSensorAggregates(SessionRow row, IReadOnlyList<TelemetrySample> sensors)
|
||||
{
|
||||
IReadOnlyList<GpuSample> s = [.. c.Input.Sensors.Select(static t => t.Sample)];
|
||||
ArgumentNullException.ThrowIfNull(row);
|
||||
ArgumentNullException.ThrowIfNull(sensors);
|
||||
IReadOnlyList<GpuSample> s = [.. sensors.Select(static t => t.Sample)];
|
||||
SeriesAggregates temp = SeriesAggregates.Of(s.Select(static x => x.TempCoreC));
|
||||
SeriesAggregates hotspot = SeriesAggregates.Of(s.Select(static x => x.TempHotspotC));
|
||||
SeriesAggregates load = SeriesAggregates.Of(s.Select(static x => x.LoadPct));
|
||||
@@ -186,9 +192,9 @@ public static class SessionAggregator
|
||||
|
||||
// The machine beside the GPU: these four columns are schema 0001's and had no producer until 2026-09-21. A
|
||||
// session recorded before then, or one whose ticks never carried a reading, keeps its nulls.
|
||||
SeriesAggregates cpuLoad = SeriesAggregates.Of(c.Input.Sensors.Select(static t => t.System.CpuLoadPct));
|
||||
SeriesAggregates cpuTemp = SeriesAggregates.Of(c.Input.Sensors.Select(static t => t.System.CpuTempC));
|
||||
SeriesAggregates ram = SeriesAggregates.Of(c.Input.Sensors.Select(static t => t.System.RamUsedMb));
|
||||
SeriesAggregates cpuLoad = SeriesAggregates.Of(sensors.Select(static t => t.System.CpuLoadPct));
|
||||
SeriesAggregates cpuTemp = SeriesAggregates.Of(sensors.Select(static t => t.System.CpuTempC));
|
||||
SeriesAggregates ram = SeriesAggregates.Of(sensors.Select(static t => t.System.RamUsedMb));
|
||||
return row with
|
||||
{
|
||||
AvgCpuLoad = cpuLoad.Average,
|
||||
|
||||
@@ -15,7 +15,7 @@ namespace FrameLedger.Application.Recording;
|
||||
/// <b>Step 1 is the caller's</b>: the loop already asked the Overlay to stop and drained once more before
|
||||
/// it let go of the ring; what arrives here is final. <b>Step 5's delete of the <c>.partial</c> is the
|
||||
/// caller's too</b>, because only the caller holds the file, and it deletes only on
|
||||
/// <see cref="FinalizeStatus.Saved"/> or <see cref="FinalizeStatus.Discarded"/>.
|
||||
/// <see cref="FinalizeStatus.Saved"/>, <see cref="FinalizeStatus.Discarded"/> or <see cref="FinalizeStatus.GameRemoved"/>.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Every series in <c>06_DATA_MODEL</c> is written, or is null because nothing measured it</b> — never
|
||||
@@ -55,9 +55,11 @@ public sealed class SessionFinalizer
|
||||
SessionRow row = input.Skeleton;
|
||||
if (input.Hooked is null)
|
||||
{
|
||||
// A Tier-2 row has no frames and every sensor the machine provided (2026-09-22): the same averages a
|
||||
// hooked row gets, so the sessions list can show its GPU temperature and the trend charts can use it.
|
||||
return new FinalizedSession
|
||||
{
|
||||
Row = row with { Tier = CaptureTier.NotHooked },
|
||||
Row = SessionAggregator.WithSensorAggregates(row with { Tier = CaptureTier.NotHooked }, input.Sensors),
|
||||
Sensors = EncodeSensors(input.Sensors, row.QpcEpoch, row.QpcFrequency),
|
||||
};
|
||||
}
|
||||
@@ -73,7 +75,16 @@ public sealed class SessionFinalizer
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>The discard rule, then step 5: one transaction, then the retention sweep.</summary>
|
||||
/// <summary>
|
||||
/// The discard rule, the owner, then step 5: one transaction, then the retention sweep.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <b>The owner is looked up, not assumed (2026-09-23).</b> The skeleton carries the id the session started under,
|
||||
/// and the entry can be removed — or removed and re-imported — while the game runs: two GIRLS' FRONTLINE 2 sessions
|
||||
/// died on the foreign key that way and left their <c>.partial</c> files for a recovery that would have died the same
|
||||
/// way. The session lands on the row that owns it now (<see cref="ISessionRepository.ResolveOwnerAsync"/>), and with no
|
||||
/// owner it is <see cref="FinalizeStatus.GameRemoved"/>: the user removed the game with its sessions, and this was one.
|
||||
/// </remarks>
|
||||
public async ValueTask<FinalizeOutcome> FinalizeAsync(FinalizeInput input, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(input);
|
||||
@@ -87,10 +98,26 @@ public sealed class SessionFinalizer
|
||||
return new FinalizeOutcome(FinalizeStatus.AlreadyStored, null, 0);
|
||||
}
|
||||
|
||||
FinalizedSession session = Build(input);
|
||||
long id = await _sessions.InsertFinalizedAsync(session, ct).ConfigureAwait(false);
|
||||
int swept = await _sessions.SweepRetentionAsync(session.Row.GameId, input.RetentionKeep, ct).ConfigureAwait(false);
|
||||
return new FinalizeOutcome(FinalizeStatus.Saved, id, swept);
|
||||
long? owner = await _sessions.ResolveOwnerAsync(input.Skeleton.GameId, input.ExePath, input.Skeleton.StartedAt, ct).ConfigureAwait(false);
|
||||
if (owner is not { } gameId)
|
||||
{
|
||||
return new FinalizeOutcome(FinalizeStatus.GameRemoved, null, 0);
|
||||
}
|
||||
|
||||
FinalizedSession session = Build(gameId == input.Skeleton.GameId ? input : input with { Skeleton = input.Skeleton with { GameId = gameId } });
|
||||
long id;
|
||||
try
|
||||
{
|
||||
id = await _sessions.InsertFinalizedAsync(session, ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (SessionOwnerMissingException)
|
||||
{
|
||||
// Removed between the lookup and the write: the same answer, reached one statement later.
|
||||
return new FinalizeOutcome(FinalizeStatus.GameRemoved, null, 0);
|
||||
}
|
||||
|
||||
int swept = await _sessions.SweepRetentionAsync(gameId, input.RetentionKeep, ct).ConfigureAwait(false);
|
||||
return new FinalizeOutcome(FinalizeStatus.Saved, id, swept, gameId);
|
||||
}
|
||||
|
||||
/// <summary>The full <c>frame_blobs</c> row over every record in drained order.</summary>
|
||||
|
||||
@@ -144,7 +144,8 @@ public sealed class SessionRecorder : ISessionRecorder
|
||||
Run run, DateTimeOffset endedAt, PartialSessionWriter writer, RecorderOptions options, CancellationToken ct)
|
||||
{
|
||||
bool hooked = outcome.AttachRefusal == ShmAttachRefusal.Ok;
|
||||
bool hadPid = hooked || outcome.TargetPid != 0;
|
||||
// A held Tier-2 session's duration is the game's (2026-09-22), so the Application-log witness applies to it too.
|
||||
bool hadPid = hooked || outcome.TargetPid != 0 || outcome.HeldUnhooked;
|
||||
bool crashEvent = hadPid && _crashes.FoundCrash(Path.GetFileName(request.NormalisedExePath), header.StartedAt, endedAt + ExitStatusMapper.CrashWitnessGrace);
|
||||
ExitStatus exit = ExitStatusMapper.Map(outcome.Reason, outcome.ExitCode, crashEvent);
|
||||
|
||||
@@ -156,6 +157,7 @@ public sealed class SessionRecorder : ISessionRecorder
|
||||
Sensors = writer.Sensors,
|
||||
RetentionKeep = options.RetentionKeep,
|
||||
MinimumSessionLength = options.MinimumSessionLength,
|
||||
ExePath = request.NormalisedExePath,
|
||||
};
|
||||
FinalizedSession built = _finalizer.Build(input);
|
||||
|
||||
@@ -164,18 +166,22 @@ public sealed class SessionRecorder : ISessionRecorder
|
||||
writer.Dispose();
|
||||
_partials.Delete(header.SessionGuid);
|
||||
|
||||
// The row the session was stored under (2026-09-23): the one it started with, or — when that entry was removed
|
||||
// and re-imported while the game ran — the one that holds its executable now. A removed game has none, and
|
||||
// neither the injection stamp nor the crash policy has a row to write to.
|
||||
long ownerId = saved.GameId ?? game.Id;
|
||||
CrashPolicyOutcome crash = CrashPolicyOutcome.NotAnEarlyCrash;
|
||||
if (hooked)
|
||||
if (hooked && saved.Status != FinalizeStatus.GameRemoved)
|
||||
{
|
||||
await _games.RecordInjectionAsync(game.Id, run.AttachedAt ?? header.StartedAt, ct).ConfigureAwait(false);
|
||||
crash = await _crashPolicy.ApplyAsync(game.Id, exit, run.AttachedAt, endedAt, ct).ConfigureAwait(false);
|
||||
await _games.RecordInjectionAsync(ownerId, run.AttachedAt ?? header.StartedAt, ct).ConfigureAwait(false);
|
||||
crash = await _crashPolicy.ApplyAsync(ownerId, exit, run.AttachedAt, endedAt, ct).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
return new RecordedSession
|
||||
{
|
||||
SessionGuid = header.SessionGuid,
|
||||
Outcome = outcome,
|
||||
Row = built.Row with { Id = saved.SessionId ?? 0 },
|
||||
Row = built.Row with { Id = saved.SessionId ?? 0, GameId = ownerId },
|
||||
ExitStatus = exit,
|
||||
Finalize = saved,
|
||||
CrashPolicy = crash,
|
||||
@@ -196,12 +202,11 @@ public sealed class SessionRecorder : ISessionRecorder
|
||||
}
|
||||
}
|
||||
|
||||
// A session that ran beside anti-cheat because the user overruled the guard says so in words too, whatever
|
||||
// tier it ended at: the notes travel into every bug bundle, the columns into every export.
|
||||
if (o.StartedUnderBypass is { } under)
|
||||
// The session that turned the game's hooking off says so in its notes (2026-09-22): the row's block names
|
||||
// the finding, and the notes travel into every bug bundle.
|
||||
if (o.HookingTurnedOff)
|
||||
{
|
||||
notes += "; guard-bypass=" + (string.IsNullOrEmpty(under.Family) ? "unnamed" : under.Family)
|
||||
+ (string.IsNullOrEmpty(under.Signal) ? "" : "/" + under.Signal);
|
||||
notes += "; hooking-turned-off=" + o.Verdict.Reason + (string.IsNullOrEmpty(o.Verdict.Family) ? "" : "/" + o.Verdict.Family);
|
||||
}
|
||||
|
||||
return new SessionRow
|
||||
@@ -224,9 +229,6 @@ public sealed class SessionRecorder : ISessionRecorder
|
||||
DrainTicks = hooked ? o.DrainTicks : null,
|
||||
ForegroundTicks = hooked ? o.ForegroundTicks : null,
|
||||
GuardTicksPublished = hooked ? o.GuardTicksPublished : null,
|
||||
GuardBypassed = o.StartedUnderBypass is not null,
|
||||
GuardBypassFamily = o.StartedUnderBypass is { Family.Length: > 0 } f ? f.Family : null,
|
||||
GuardBypassSignal = o.StartedUnderBypass is { Signal.Length: > 0 } g ? g.Signal : null,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -8,14 +8,28 @@ namespace FrameLedger.Application.Watch;
|
||||
|
||||
/// <summary>
|
||||
/// The Agent's <c>--serve</c> loop (P2 PR-F): one process snapshot per second, the watcher's events, and
|
||||
/// <b>one session per game at a time</b> through <see cref="ISessionRecorder"/>. It decides nothing about
|
||||
/// <b>one session per executable at a time</b> through <see cref="ISessionRecorder"/>. It decides nothing about
|
||||
/// hooking — the recorder's loop reaches <c>HookedCaptureGate</c> with the row's consent, the kill switch and
|
||||
/// the guard exactly as a console verb does, and a game with hooking off lands as a Tier-2 row (or is
|
||||
/// discarded under the recorder's minimum length). What this class owns is <i>when</i> a session starts and
|
||||
/// that two never run for the same game.
|
||||
/// that two never run for the same executable.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>A file name is not an identity (2026-09-23, HANDOFF D25).</b> A process that matches a library entry by its
|
||||
/// FILE NAME only starts nothing. It may only be that entry's executable on a drive that changed its letter — the
|
||||
/// relocator's rule — and then the entry moves and the session is the entry's; anything else is not in the library, is
|
||||
/// said once in the log, and records nothing. Until this date such a process got a session under the matched entry's
|
||||
/// NAME, keyed on its own path — and the recorder inserted a new entry with that name: *HELLO, HELLO WORLD!*'s
|
||||
/// <c>swiftshader\Game.exe</c> became a second "Flower in Us" (the only entry named <c>Game.exe</c>), and its NW.js
|
||||
/// children then matched the new entry exactly and started a second session beside the first.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>The running table is keyed by the executable's path</b>, not the entry's id (2026-09-23): an entry removed and
|
||||
/// re-imported while its game runs, or two entries merged, get a new id for the same executable, and a second process of
|
||||
/// it must still find the first session.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>The running-session table has one lock, and the sessions themselves never take it.</b> Until P3 PR-1b
|
||||
/// <see cref="PollOnceAsync"/> was the table's only writer; the pipe's <c>LaunchGame</c> and <c>StopSession</c>
|
||||
/// now reach it from the pipe's tasks too, so the table is guarded rather than queued (HANDOFF §P3 decision
|
||||
@@ -44,13 +58,22 @@ public sealed class CaptureOrchestrator
|
||||
private readonly OrchestratorOptions _options;
|
||||
private readonly Action<string> _log;
|
||||
private readonly ILaunchRecorderFactory? _launches;
|
||||
private readonly ExecutableRelocator? _relocator;
|
||||
private readonly LatestProcessSnapshot? _latest;
|
||||
private readonly ProcessWatcher _watcher = new();
|
||||
private readonly Lock _table = new();
|
||||
private readonly Dictionary<long, Running> _running = [];
|
||||
private readonly Dictionary<string, Running> _running = new(StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
// Processes a file-name match declined (pid → the path they run from), touched only by the poll: their exit is
|
||||
// not an entry's, and a launch that spawns five of them is said once.
|
||||
private readonly Dictionary<int, string> _declined = [];
|
||||
|
||||
public CaptureOrchestrator(ISessionRecorder recorder, IGameRepository games, IProcessSnapshotSource processes,
|
||||
IExecutableIdentitySource identity, OrchestratorOptions options, Action<string> log, ILaunchRecorderFactory? launches = null)
|
||||
IExecutableIdentitySource identity, OrchestratorOptions options, Action<string> log, ILaunchRecorderFactory? launches = null,
|
||||
ExecutableRelocator? relocator = null, LatestProcessSnapshot? latest = null)
|
||||
{
|
||||
_relocator = relocator;
|
||||
_latest = latest;
|
||||
_recorder = recorder ?? throw new ArgumentNullException(nameof(recorder));
|
||||
_games = games ?? throw new ArgumentNullException(nameof(games));
|
||||
_processes = processes ?? throw new ArgumentNullException(nameof(processes));
|
||||
@@ -72,6 +95,15 @@ public sealed class CaptureOrchestrator
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Whether a session started here for the entry <paramref name="gameId"/> is still running — what a merge of two entries waits for.</summary>
|
||||
public bool IsRecording(long gameId)
|
||||
{
|
||||
lock (_table)
|
||||
{
|
||||
return _running.Values.Any(r => r.GameId == gameId && !r.Task.IsCompleted);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Poll until cancelled, then wait for every running session to finalize.</summary>
|
||||
public async Task RunAsync(CancellationToken ct)
|
||||
{
|
||||
@@ -97,17 +129,33 @@ public sealed class CaptureOrchestrator
|
||||
{
|
||||
IReadOnlyList<GameRow> watchlist = await _games.ListAsync(ct).ConfigureAwait(false);
|
||||
IReadOnlyList<ProcessSnapshot> snapshot = _processes.Take();
|
||||
_latest?.Publish(snapshot);
|
||||
IReadOnlyList<WatchEvent> events = _watcher.Poll(snapshot, watchlist);
|
||||
|
||||
foreach (WatchEvent e in events)
|
||||
{
|
||||
switch (e)
|
||||
{
|
||||
case TrackedProcessAppeared appeared:
|
||||
case TrackedProcessAppeared { StalePath: false } appeared:
|
||||
Start(appeared, ct);
|
||||
break;
|
||||
case TrackedProcessAppeared nameOnly:
|
||||
if (await AdoptIfMovedAsync(nameOnly, ct).ConfigureAwait(false) is { } adopted)
|
||||
{
|
||||
Start(adopted, ct);
|
||||
}
|
||||
else
|
||||
{
|
||||
Decline(nameOnly);
|
||||
}
|
||||
|
||||
break;
|
||||
case TrackedProcessGone gone:
|
||||
_log($"watch: pid {gone.Pid} ({gone.Game.Name}) exited");
|
||||
if (!_declined.Remove(gone.Pid))
|
||||
{
|
||||
_log($"watch: pid {gone.Pid} ({gone.Game.Name}) exited");
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
@@ -160,16 +208,17 @@ public sealed class CaptureOrchestrator
|
||||
return LaunchResult.Of(LaunchOutcome.UnknownGame);
|
||||
}
|
||||
|
||||
string path = game.Fingerprint.ExePath;
|
||||
lock (_table)
|
||||
{
|
||||
if (_running.TryGetValue(gameId, out Running? current) && !current.Task.IsCompleted)
|
||||
if (_running.TryGetValue(path, out Running? current) && !current.Task.IsCompleted)
|
||||
{
|
||||
return LaunchResult.Of(LaunchOutcome.SessionRunning);
|
||||
}
|
||||
|
||||
var running = new Running(Guid.NewGuid());
|
||||
var running = new Running(Guid.NewGuid(), game.Id);
|
||||
running.Task = RunLaunchAsync(game, arguments, running.SessionGuid, running.Stop.Token, ct);
|
||||
_running[gameId] = running;
|
||||
_running[path] = running;
|
||||
return new LaunchResult(LaunchOutcome.Accepted, running.SessionGuid);
|
||||
}
|
||||
}
|
||||
@@ -177,7 +226,8 @@ public sealed class CaptureOrchestrator
|
||||
/// <summary>
|
||||
/// After a launch-mode session ended with the launcher gone (<see cref="SessionEndReason.LaunchTargetExited"/>)
|
||||
/// or sitting on its window (<see cref="SessionEndReason.LaunchNoPresentationRuntime"/>): elect the newest
|
||||
/// tracked descendant and run an attach-mode session against it. Null when nothing was elected.
|
||||
/// tracked descendant and run an attach-mode session against it. Null when nothing was elected, or when the watcher
|
||||
/// already records that executable — the child appeared while the launcher ran, and one session is its session.
|
||||
/// </summary>
|
||||
public async Task<RecordedSession?> ElectAfterLaunchAsync(RecordedSession launched, CancellationToken ct)
|
||||
{
|
||||
@@ -197,27 +247,79 @@ public sealed class CaptureOrchestrator
|
||||
return null;
|
||||
}
|
||||
|
||||
_log($"election: pid {elected.Value.Pid} ({path}) is the newest tracked descendant; attaching");
|
||||
return await _recorder.RecordAsync(Attach(path, null, null, default), ct).ConfigureAwait(false);
|
||||
GameRow? row = watchlist.FirstOrDefault(g => string.Equals(g.Fingerprint.ExePath, path, StringComparison.OrdinalIgnoreCase));
|
||||
Task<RecordedSession> session;
|
||||
lock (_table)
|
||||
{
|
||||
// Registered under its executable like any session (2026-09-23), so the watcher does not start a second one for
|
||||
// it; and when the watcher got there first, that session is the child's. The launch's own entry (the same
|
||||
// executable relaunching itself) is the one exception: it is this very flow, still awaiting this election.
|
||||
if (_running.TryGetValue(path, out Running? current) && !current.Task.IsCompleted && current.SessionGuid != launched.SessionGuid)
|
||||
{
|
||||
_log($"election: pid {elected.Value.Pid} ({path}) is already recorded by session {current.SessionGuid:N}; not a second one");
|
||||
return null;
|
||||
}
|
||||
|
||||
_log($"election: pid {elected.Value.Pid} ({path}) is the newest tracked descendant; attaching");
|
||||
if (current is not null && current.SessionGuid == launched.SessionGuid)
|
||||
{
|
||||
session = _recorder.RecordAsync(Attach(path, row?.Name, null, default), ct);
|
||||
}
|
||||
else
|
||||
{
|
||||
var running = new Running(Guid.NewGuid(), row?.Id ?? 0);
|
||||
session = _recorder.RecordAsync(Attach(path, row?.Name, running.SessionGuid, running.Stop.Token), ct);
|
||||
running.Task = session;
|
||||
_running[path] = running;
|
||||
}
|
||||
}
|
||||
|
||||
return await session.ConfigureAwait(false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A file-name match is only ever the entry's own executable on a drive that changed its letter (2026-09-22, narrowed
|
||||
/// 2026-09-23): the relocator moves the entry first, so the session is keyed on the entry's (now real) path and its
|
||||
/// consent applies. Null otherwise — the process is not in the library.
|
||||
/// </summary>
|
||||
private async ValueTask<TrackedProcessAppeared?> AdoptIfMovedAsync(TrackedProcessAppeared appeared, CancellationToken ct)
|
||||
{
|
||||
if (_relocator is null || !await _relocator.TryAdoptAsync(appeared.Game, appeared.ImagePath, ct).ConfigureAwait(false))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
GameRow moved = await _games.FindByIdAsync(appeared.Game.Id, ct).ConfigureAwait(false) ?? appeared.Game;
|
||||
return appeared with { Game = moved, StalePath = false };
|
||||
}
|
||||
|
||||
/// <summary>A file-name match that is not the entry's executable: said once per executable while it runs, and nothing recorded.</summary>
|
||||
private void Decline(TrackedProcessAppeared nameOnly)
|
||||
{
|
||||
bool said = _declined.ContainsValue(nameOnly.ImagePath);
|
||||
_declined[nameOnly.Pid] = nameOnly.ImagePath;
|
||||
if (!said)
|
||||
{
|
||||
_log($"watch: pid {nameOnly.Pid} runs {nameOnly.ImagePath} — its file name matches {nameOnly.Game.Name} ({nameOnly.Game.Fingerprint.ExePath}), "
|
||||
+ "but it is not that entry's executable; it is not in the library, so nothing is recorded");
|
||||
}
|
||||
}
|
||||
|
||||
private void Start(TrackedProcessAppeared appeared, CancellationToken ct)
|
||||
{
|
||||
lock (_table)
|
||||
{
|
||||
if (_running.TryGetValue(appeared.Game.Id, out Running? current) && !current.Task.IsCompleted)
|
||||
if (_running.TryGetValue(appeared.ImagePath, out Running? current) && !current.Task.IsCompleted)
|
||||
{
|
||||
_log($"watch: pid {appeared.Pid} ({appeared.Game.Name}) appeared while a session for that game is running; one at a time");
|
||||
_log($"watch: pid {appeared.Pid} ({appeared.Game.Name}) appeared while a session for that executable is running; one at a time");
|
||||
return;
|
||||
}
|
||||
|
||||
_log(appeared.StalePath
|
||||
? $"watch: pid {appeared.Pid} matched {appeared.Game.Name} BY FILE NAME ONLY — it runs from {appeared.ImagePath}, not the path on record; the session is keyed on the real path"
|
||||
: $"watch: pid {appeared.Pid} ({appeared.Game.Name}) appeared; starting a session");
|
||||
var running = new Running(Guid.NewGuid());
|
||||
_log($"watch: pid {appeared.Pid} ({appeared.Game.Name}) appeared; starting a session");
|
||||
var running = new Running(Guid.NewGuid(), appeared.Game.Id);
|
||||
RecordRequest request = Attach(appeared.ImagePath, appeared.Game.Name, running.SessionGuid, running.Stop.Token);
|
||||
running.Task = RunAndReportAsync(_recorder, request, ct);
|
||||
_running[appeared.Game.Id] = running;
|
||||
_running[appeared.ImagePath] = running;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -227,18 +329,23 @@ public sealed class CaptureOrchestrator
|
||||
try
|
||||
{
|
||||
RecordedSession r = await Task.Run(() => recorder.RecordAsync(request, ct), ct).ConfigureAwait(false);
|
||||
Report(r);
|
||||
Report(r, Name(request));
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_log("session: cancelled before it could finalize; the .partial stays for recovery");
|
||||
_log($"session {SessionId(request)}: cancelled before it could finalize; the .partial stays for recovery — {Name(request)}");
|
||||
}
|
||||
catch (Exception ex) when (ex is not OutOfMemoryException)
|
||||
{
|
||||
_log($"session: FAULTED {ex.GetType().Name}: {ex.Message}");
|
||||
_log($"session {SessionId(request)}: FAULTED {ex.GetType().Name}: {ex.Message} — {Name(request)} ({request.NormalisedExePath})");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>The game a log line is about (2026-09-23: the owner's log said "FAULTED" twice and not which game or session).</summary>
|
||||
private static string Name(RecordRequest request) => request.GameName ?? Path.GetFileName(request.NormalisedExePath);
|
||||
|
||||
private static string SessionId(RecordRequest request) => request.SessionGuid?.ToString("N") ?? "(unnamed)";
|
||||
|
||||
/// <summary>Launch mode on its own task: the environment, the session, the election, each reported.</summary>
|
||||
private async Task RunLaunchAsync(GameRow game, string arguments, Guid sessionGuid, CancellationToken stop, CancellationToken ct)
|
||||
{
|
||||
@@ -259,26 +366,26 @@ public sealed class CaptureOrchestrator
|
||||
StopToken = stop,
|
||||
};
|
||||
RecordedSession r = await Task.Run(() => launch.Recorder.RecordAsync(request, ct), ct).ConfigureAwait(false);
|
||||
Report(r);
|
||||
Report(r, game.Name);
|
||||
|
||||
RecordedSession? elected = await ElectAfterLaunchAsync(r, ct).ConfigureAwait(false);
|
||||
if (elected is not null)
|
||||
{
|
||||
Report(elected);
|
||||
Report(elected, $"elected after {game.Name}");
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
_log("session: cancelled before it could finalize; the .partial stays for recovery");
|
||||
_log($"session {sessionGuid:N}: cancelled before it could finalize; the .partial stays for recovery — {game.Name}");
|
||||
}
|
||||
catch (Exception ex) when (ex is not OutOfMemoryException)
|
||||
{
|
||||
_log($"session: FAULTED {ex.GetType().Name}: {ex.Message}");
|
||||
_log($"session {sessionGuid:N}: FAULTED {ex.GetType().Name}: {ex.Message} — {game.Name} ({game.Fingerprint.ExePath})");
|
||||
}
|
||||
}
|
||||
|
||||
private void Report(RecordedSession r) =>
|
||||
_log($"session {r.SessionGuid:N}: {r.Outcome.Reason}; {r.Finalize.Status} (tier {(int)r.Row.Tier}, exit={r.ExitStatus}, frames={r.Row.FrameCount}){GuardDetail(r.Outcome)}");
|
||||
private void Report(RecordedSession r, string game) =>
|
||||
_log($"session {r.SessionGuid:N}: {r.Outcome.Reason}; {r.Finalize.Status} (tier {(int)r.Row.Tier}, exit={r.ExitStatus}, frames={r.Row.FrameCount}){GuardDetail(r.Outcome)} — {game}");
|
||||
|
||||
/// <summary>
|
||||
/// What the guard said, when it said anything but a plain allow (2026-09-21). A SafetyUnhook on the owner's machine
|
||||
@@ -288,13 +395,13 @@ public sealed class CaptureOrchestrator
|
||||
private static string GuardDetail(CaptureOutcome o)
|
||||
{
|
||||
Domain.AntiCheat.AntiCheatVerdict v = o.Verdict;
|
||||
if (v.Reason == Domain.AntiCheat.AntiCheatRefusalReason.Allow && o.StartedUnderBypass is null)
|
||||
if (v.Reason == Domain.AntiCheat.AntiCheatRefusalReason.Allow)
|
||||
{
|
||||
return string.Empty;
|
||||
}
|
||||
|
||||
string text = $"; guard={v.Reason}" + (v.Family.Length > 0 ? "/" + v.Family : string.Empty) + (v.Signal.Length > 0 ? "/" + v.Signal : string.Empty);
|
||||
return o.StartedUnderBypass is { } under ? text + $"; started-under-bypass={under.Family}/{under.Signal}" : text;
|
||||
return o.HookingTurnedOff ? text + "; hooking-turned-off" : text;
|
||||
}
|
||||
|
||||
private RecordRequest Attach(string normalisedExePath, string? gameName, Guid? sessionGuid, CancellationToken stop)
|
||||
@@ -316,11 +423,11 @@ public sealed class CaptureOrchestrator
|
||||
{
|
||||
lock (_table)
|
||||
{
|
||||
foreach ((long gameId, Running running) in _running.ToArray())
|
||||
foreach ((string path, Running running) in _running.ToArray())
|
||||
{
|
||||
if (running.Task.IsCompleted)
|
||||
{
|
||||
_running.Remove(gameId);
|
||||
_running.Remove(path);
|
||||
running.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -343,11 +450,14 @@ public sealed class CaptureOrchestrator
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>One started session: its guid (chosen here, so the stop is addressable), its task, its stop token.</summary>
|
||||
private sealed class Running(Guid sessionGuid) : IDisposable
|
||||
/// <summary>One started session: its guid (chosen here, so the stop is addressable), its entry, its task, its stop token.</summary>
|
||||
private sealed class Running(Guid sessionGuid, long gameId) : IDisposable
|
||||
{
|
||||
public Guid SessionGuid { get; } = sessionGuid;
|
||||
|
||||
/// <summary>The entry the session was started for (0 when an elected executable has none); what <see cref="IsRecording"/> answers from.</summary>
|
||||
public long GameId { get; } = gameId;
|
||||
|
||||
public CancellationTokenSource Stop { get; } = new();
|
||||
|
||||
public Task Task { get; set; } = System.Threading.Tasks.Task.CompletedTask;
|
||||
|
||||
@@ -0,0 +1,210 @@
|
||||
using FrameLedger.Application.Persistence;
|
||||
using FrameLedger.Domain.Consent;
|
||||
|
||||
namespace FrameLedger.Application.Watch;
|
||||
|
||||
/// <summary>
|
||||
/// A drive that changed its letter is the same executable (2026-09-22; <c>19_SAFETY</c> §A moved drive is the same
|
||||
/// executable). Every row is keyed on its executable's path, so when the owner's external drive came back as <c>H:</c>
|
||||
/// instead of <c>D:</c> all 46 games read "executable unreadable" for as long as it stayed there, and a game launched
|
||||
/// from <c>H:</c> matched its row by file name only and ran as a stranger. This finds the same file under another
|
||||
/// volume root — same size, same mtime, exactly one candidate — and moves the row to it with everything kept.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <b>What "the same file" means here.</b> The consent fingerprint is path + size + mtime; size and mtime are the
|
||||
/// bytes' identity and the path is where they live. A candidate must match both to the millisecond, and the
|
||||
/// repository's write requires the same again, so nothing here can point a consent at a different binary. Two
|
||||
/// candidates (two drives with the file) is an ambiguity, and ambiguity is a refusal, as it is in the resolver.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Only a drive letter may differ (2026-09-23).</b> The watcher's adopt used to accept ANY running path with the
|
||||
/// row's size and mtime — and an RPG Maker MV game's <c>Game.exe</c> is the same NW.js stub in every game, byte for
|
||||
/// byte, with the mtime an unzip keeps: a hooking-on row whose drive was unplugged could have been moved, consent and
|
||||
/// all, onto another game. Every caller now asks for the same thing: the row's path with only its letter changed
|
||||
/// (<see cref="IsDriveLetterTwin"/>), and exactly one such file with the row's bytes.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>Three callers, one rule.</b> The 15 s sweep (a missing executable), the watcher (a process running from a path
|
||||
/// that is not the row's while the row's is gone) and the enable-hooking command (the same, when the user clicks). No
|
||||
/// caller opens a process; this reads files. A refusal is logged once per row until it changes — the owner's log
|
||||
/// carried the same "could not be moved" line every 15 s, 5,675 times on 2026-09-22.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
public sealed class ExecutableRelocator
|
||||
{
|
||||
private readonly IGameRepository _games;
|
||||
private readonly IExecutableIdentitySource _identity;
|
||||
private readonly Func<IReadOnlyList<string>> _roots;
|
||||
private readonly Action<string> _log;
|
||||
private readonly TimeProvider _clock;
|
||||
private readonly Lock _logged = new();
|
||||
private readonly Dictionary<long, string> _lastLine = [];
|
||||
|
||||
/// <summary>The relocator over the library, the disk and the machine's drive list.</summary>
|
||||
/// <param name="games">The library, whose rows move.</param>
|
||||
/// <param name="identity">Reads a file's fingerprint, or null when it is not there.</param>
|
||||
/// <param name="roots">The mounted volumes' roots (<c>C:\</c>, <c>H:\</c>, …); an adapter's, so a test can name its own.</param>
|
||||
/// <param name="log">The Agent's log line.</param>
|
||||
/// <param name="clock">The row's <c>updated_at</c>.</param>
|
||||
public ExecutableRelocator(IGameRepository games, IExecutableIdentitySource identity, Func<IReadOnlyList<string>> roots, Action<string> log, TimeProvider? clock = null)
|
||||
{
|
||||
_games = games ?? throw new ArgumentNullException(nameof(games));
|
||||
_identity = identity ?? throw new ArgumentNullException(nameof(identity));
|
||||
_roots = roots ?? throw new ArgumentNullException(nameof(roots));
|
||||
_log = log ?? throw new ArgumentNullException(nameof(log));
|
||||
_clock = clock ?? TimeProvider.System;
|
||||
}
|
||||
|
||||
/// <summary>The same path under each other drive-letter root; empty for a path that is not a drive-letter path (UNC).</summary>
|
||||
public static IReadOnlyList<string> Candidates(string exePath, IReadOnlyList<string> roots)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(exePath);
|
||||
ArgumentNullException.ThrowIfNull(roots);
|
||||
if (!IsDriveLetterPath(exePath))
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
string tail = exePath[3..];
|
||||
List<string> candidates = [];
|
||||
HashSet<char> seen = [char.ToUpperInvariant(exePath[0])];
|
||||
foreach (string root in roots)
|
||||
{
|
||||
if (root.Length < 2 || root[1] != ':' || !seen.Add(char.ToUpperInvariant(root[0])))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
candidates.Add(root.TrimEnd('\\', '/') + "\\" + tail);
|
||||
}
|
||||
|
||||
return candidates;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether <paramref name="a"/> and <paramref name="b"/> are the same path on two different drive letters
|
||||
/// (2026-09-23) — the only difference a moved drive can make. Case-insensitive, as NTFS is; UNC paths never are.
|
||||
/// </summary>
|
||||
public static bool IsDriveLetterTwin(string a, string b)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(a);
|
||||
ArgumentNullException.ThrowIfNull(b);
|
||||
return IsDriveLetterPath(a) && IsDriveLetterPath(b)
|
||||
&& char.ToUpperInvariant(a[0]) != char.ToUpperInvariant(b[0])
|
||||
&& string.Equals(a[3..], b[3..], StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The row's executable is gone from its path: find it under another root and move the row. Null when the file is
|
||||
/// still where the row says, when no other root has it, or when more than one does.
|
||||
/// </summary>
|
||||
public async ValueTask<ExecutableFingerprint?> TryRelocateAsync(GameRow row, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(row);
|
||||
if (_identity.Read(row.Fingerprint.ExePath) is not null)
|
||||
{
|
||||
Forget(row.Id);
|
||||
return null;
|
||||
}
|
||||
|
||||
List<ExecutableFingerprint> found = SameBytesUnder(row, Candidates(row.Fingerprint.ExePath, _roots()), ct);
|
||||
if (found.Count > 1)
|
||||
{
|
||||
LogOnce(row.Id, $"relocate: {row.Name} — {found.Count} drives hold {row.Fingerprint.ExePath[2..]} with the same size and mtime; not guessing which");
|
||||
return null;
|
||||
}
|
||||
|
||||
return found.Count == 1 ? await MoveAsync(row, found[0], ct).ConfigureAwait(false) : null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The watcher saw the game run from <paramref name="observedPath"/>, not the row's path (a file-name match). When the
|
||||
/// row's file is gone, the running one is the row's path with only its drive letter changed, and it is the only file
|
||||
/// there with the row's size and mtime, it is the row's executable on a drive that changed its letter: move the row, so
|
||||
/// the session is the row's and its consent applies. False otherwise — including when both files exist, which is two
|
||||
/// copies, not a move, and when the running file is in another folder, which is another game (2026-09-23).
|
||||
/// </summary>
|
||||
public async ValueTask<bool> TryAdoptAsync(GameRow row, string observedPath, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(row);
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(observedPath);
|
||||
if (!IsDriveLetterTwin(row.Fingerprint.ExePath, observedPath)
|
||||
|| _identity.Read(row.Fingerprint.ExePath) is not null
|
||||
|| _identity.Read(observedPath) is not { } onDisk
|
||||
|| !SameBytes(row.Fingerprint, onDisk))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// The running file's own drive is mounted by definition; the rest of the list may not know it yet.
|
||||
List<string> roots = [.. _roots(), observedPath[..3]];
|
||||
List<ExecutableFingerprint> found = SameBytesUnder(row, Candidates(row.Fingerprint.ExePath, roots), ct);
|
||||
if (found.Count != 1)
|
||||
{
|
||||
LogOnce(row.Id, $"relocate: {row.Name} — {found.Count} drives hold {row.Fingerprint.ExePath[2..]} with the same size and mtime; not guessing which");
|
||||
return false;
|
||||
}
|
||||
|
||||
return await MoveAsync(row, onDisk, ct).ConfigureAwait(false) is not null;
|
||||
}
|
||||
|
||||
private static bool IsDriveLetterPath(string path) =>
|
||||
path.Length >= 3 && char.IsAsciiLetter(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/');
|
||||
|
||||
private static bool SameBytes(ExecutableFingerprint stored, ExecutableFingerprint onDisk) =>
|
||||
stored.SizeBytes == onDisk.SizeBytes && stored.MtimeUnixMs == onDisk.MtimeUnixMs;
|
||||
|
||||
private List<ExecutableFingerprint> SameBytesUnder(GameRow row, IReadOnlyList<string> candidates, CancellationToken ct)
|
||||
{
|
||||
List<ExecutableFingerprint> found = [];
|
||||
foreach (string candidate in candidates)
|
||||
{
|
||||
ct.ThrowIfCancellationRequested();
|
||||
if (_identity.Read(_identity.Normalise(candidate)) is { } onDisk && SameBytes(row.Fingerprint, onDisk))
|
||||
{
|
||||
found.Add(onDisk);
|
||||
}
|
||||
}
|
||||
|
||||
return found;
|
||||
}
|
||||
|
||||
private async ValueTask<ExecutableFingerprint?> MoveAsync(GameRow row, ExecutableFingerprint moved, CancellationToken ct)
|
||||
{
|
||||
bool done = await _games.RelocateExecutableAsync(row.Id, moved, _clock.GetUtcNow(), ct).ConfigureAwait(false);
|
||||
if (done)
|
||||
{
|
||||
Forget(row.Id);
|
||||
_log($"relocate: {row.Name} — executable moved {row.Fingerprint.ExePath} → {moved.ExePath} (same size and mtime); the row follows it, consent and block kept");
|
||||
return moved;
|
||||
}
|
||||
|
||||
LogOnce(row.Id, $"relocate: {row.Name} — {moved.ExePath} has the row's size and mtime but the row could not be moved (another row owns that path, or the row changed underneath)");
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>The same refusal about the same row is said once, until something about it changes.</summary>
|
||||
private void LogOnce(long rowId, string line)
|
||||
{
|
||||
lock (_logged)
|
||||
{
|
||||
if (_lastLine.TryGetValue(rowId, out string? last) && string.Equals(last, line, StringComparison.Ordinal))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
_lastLine[rowId] = line;
|
||||
}
|
||||
|
||||
_log(line);
|
||||
}
|
||||
|
||||
private void Forget(long rowId)
|
||||
{
|
||||
lock (_logged)
|
||||
{
|
||||
_lastLine.Remove(rowId);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
namespace FrameLedger.Application.Watch;
|
||||
|
||||
/// <summary>
|
||||
/// The watcher's most recent process snapshot, shared (2026-09-23). A Tier-2 hold asks "is this game still running"
|
||||
/// of the same 1 Hz list the watcher matched it in, by the image path — so a hooking-off game is timed by its own
|
||||
/// executable and not by any process that shares its file name (the owner's two "Flower in Us" sessions were held by
|
||||
/// every <c>Game.exe</c> on the machine), and still no process is opened for the hold.
|
||||
/// </summary>
|
||||
public sealed class LatestProcessSnapshot
|
||||
{
|
||||
private IReadOnlyList<ProcessSnapshot>? _current;
|
||||
|
||||
/// <summary>Null until the watcher's first poll; the console verbs never poll, and keep the name check.</summary>
|
||||
public IReadOnlyList<ProcessSnapshot>? Current => Volatile.Read(ref _current);
|
||||
|
||||
/// <summary>The watcher's poll: the list it just matched against.</summary>
|
||||
public void Publish(IReadOnlyList<ProcessSnapshot> snapshot)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(snapshot);
|
||||
Volatile.Write(ref _current, snapshot);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether <paramref name="normalisedExePath"/> is in the latest snapshot — by its image path, or, for a process
|
||||
/// whose path could not be read, by its file name (a process we cannot identify must not end a hold early). Null
|
||||
/// when there is no snapshot yet.
|
||||
/// </summary>
|
||||
public bool? Contains(string normalisedExePath)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(normalisedExePath);
|
||||
IReadOnlyList<ProcessSnapshot>? snapshot = Current;
|
||||
if (snapshot is null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
string name = Path.GetFileName(normalisedExePath);
|
||||
foreach (ProcessSnapshot p in snapshot)
|
||||
{
|
||||
if (p.ImagePath is { } image
|
||||
? string.Equals(image, normalisedExePath, StringComparison.OrdinalIgnoreCase)
|
||||
: string.Equals(p.ImageName, name, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -13,10 +13,10 @@ namespace FrameLedger.Application.Watch;
|
||||
/// both normalised the same way (<c>ExecutableIdentity.Normalise</c>), compared case-insensitively because
|
||||
/// NTFS is. <b>Fall back to the file name only when it is unambiguous</b>: exactly one tracked row carries that
|
||||
/// file name. Two rows sharing <c>game.exe</c> in different directories are two games, and guessing which
|
||||
/// one moved is how a session lands on the wrong row. The fallback event says <c>StalePath</c>, and the
|
||||
/// session it starts is keyed on the path the process actually runs from — so consent for the old path
|
||||
/// does not follow the binary to a new one, which is <c>HookRequest.FromConsent</c>'s rule read from the
|
||||
/// other side.
|
||||
/// one moved is how a session lands on the wrong row. The fallback event says <c>StalePath</c>, and since
|
||||
/// 2026-09-23 it is a CANDIDATE, never a session (HANDOFF D25): the orchestrator asks the relocator whether the
|
||||
/// process is the row's own executable on a drive that changed its letter, and otherwise records nothing — a
|
||||
/// single row named <c>Game.exe</c> is every RPG Maker game's name.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// <b>A process that cannot be opened matches nothing.</b> Its image path is null and its name alone is
|
||||
|
||||
@@ -7,8 +7,8 @@ namespace FrameLedger.Application.Watch;
|
||||
/// <param name="Game">The <c>games</c> row it matched.</param>
|
||||
/// <param name="ImagePath">The image path the process actually runs from, normalised — the path a session is keyed on.</param>
|
||||
/// <param name="StalePath">
|
||||
/// True when the match was by file name only: the game moved since it was added, and <paramref name="ImagePath"/>
|
||||
/// differs from the row's. The session runs against the real path, so consent given for the old one does not
|
||||
/// apply until it is granted again (<c>04_CAPTURE</c> §Process watcher's "stale-path warning badge").
|
||||
/// True when the match was by file name only, and <paramref name="ImagePath"/> differs from the row's. Since 2026-09-23
|
||||
/// it starts nothing by itself (HANDOFF D25): it is the row's executable only when the relocator moves the row to it (a
|
||||
/// drive that changed its letter), and otherwise a process that is not in the library.
|
||||
/// </param>
|
||||
public sealed record TrackedProcessAppeared(int Pid, GameRow Game, string ImagePath, bool StalePath) : WatchEvent(Pid);
|
||||
@@ -37,6 +37,9 @@ internal sealed class HostSessionFactory(IGameConsentStore store, int seconds, I
|
||||
// --seconds is an operator taking a bounded measurement, and CaptureSession
|
||||
// already honoured MaxDuration -- nothing could set it.
|
||||
MaxDuration = seconds > 0 ? TimeSpan.FromSeconds(seconds) : TimeSpan.Zero,
|
||||
// To an operator a refusal is the answer and the exit code (CommandLineSurfaceTests); the Agent is
|
||||
// where a refusal becomes a Tier-2 session that lasts as long as the game (2026-09-22).
|
||||
HoldUnhooked = false,
|
||||
},
|
||||
new RuntimeModuleSnapshot(CensusNames.ModuleFileNames),
|
||||
_ngx,
|
||||
|
||||
@@ -207,22 +207,6 @@ public enum AntiCheatRefusalReason
|
||||
/// </summary>
|
||||
KillSwitchEngaged = 27,
|
||||
|
||||
/// <summary>
|
||||
/// The guard ran every check, one refused on the guard's own judgement, and the Overlay was injected anyway because
|
||||
/// the user accepted the bypass disclosure for THIS game (owner decision 2026-09-21, <c>19_SAFETY</c> §The user's
|
||||
/// bypass). The verdict's family and signal still name what the guard found.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// <para>
|
||||
/// <strong>Neither an allow nor a refusal.</strong> <see cref="AntiCheatVerdict.IsAllowed"/> stays false for it, so
|
||||
/// every caller written before it existed keeps refusing; the one caller that may proceed asks
|
||||
/// <see cref="AntiCheatVerdict.IsAllowedUnderBypass"/> by name. The native guard produces it only from its
|
||||
/// <c>*Acknowledged</c> entry points.
|
||||
/// </para>
|
||||
/// <para>
|
||||
/// What it does not change: HOW the injection happens. The same documented <c>LoadLibraryW</c> primitive, the DLL's
|
||||
/// real name, exports and version info — CLAUDE.md rule 3 is untouched by the bypass.
|
||||
/// </para>
|
||||
/// </remarks>
|
||||
AllowedUnderUserBypass = 28,
|
||||
// Value 28 was AllowedUnderUserBypass for one day (2026-09-21) and was withdrawn with the bypass on 2026-09-22. It
|
||||
// was the last value, so nothing is renumbered; the native enum dropped it in the same change (GuardMirrorTests).
|
||||
}
|
||||
@@ -56,34 +56,17 @@ public readonly record struct AntiCheatVerdict
|
||||
/// not read as permission.
|
||||
/// </summary>
|
||||
/// <summary>
|
||||
/// True only for <see cref="AntiCheatRefusalReason.AllowedUnderUserBypass"/>: the Overlay IS in the target, beside
|
||||
/// the anti-cheat <see cref="Family"/> names, because the user overruled the guard for this game. Separate from
|
||||
/// <see cref="IsAllowed"/> on purpose — a caller has to ask for this by name, so none proceeds by accident.
|
||||
/// A finding about THE GAME (owner decision 2026-09-22, <c>19_SAFETY</c> §What a finding does to the game): an
|
||||
/// anti-cheat named in the game's own process, in its folder, or on its title lists. This is what turns the game's
|
||||
/// hooking off, at the pre-scan, at a session's start and at the 30 s re-scan alike. A machine-wide driver or
|
||||
/// service (<see cref="AntiCheatRefusalReason.BlockedDriver"/>, <see cref="AntiCheatRefusalReason.BlockedService"/>)
|
||||
/// says nothing about this game and refuses this session only; a scan that could not look, unusable rules and the
|
||||
/// unsigned-module heuristic are not findings about the game at all.
|
||||
/// </summary>
|
||||
public bool IsAllowedUnderBypass => _evaluated && Reason == AntiCheatRefusalReason.AllowedUnderUserBypass;
|
||||
|
||||
/// <summary>
|
||||
/// The refusals that are the guard's JUDGEMENT about anti-cheat — a blocklist match, a suspicious module, a scan
|
||||
/// that could not look (which the guard treats as a finding), unusable rules — and the latch a past one left
|
||||
/// (<see cref="AntiCheatRefusalReason.PreviouslyBlocked"/>). These are what a user's bypass overrules. Everything
|
||||
/// else is a fact about consent, the kill switch, the payload, the target's bitness, the launch or the injection
|
||||
/// itself, and no acknowledgement changes a fact.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// A mirror of the native <c>fl::guard::IsGuardJudgement</c> plus the one managed-only latch;
|
||||
/// <c>GuardMirrorTests</c> reads the native answer back for every reason, so the two lists cannot drift.
|
||||
/// </remarks>
|
||||
public static bool IsGuardJudgement(AntiCheatRefusalReason reason) => reason is
|
||||
AntiCheatRefusalReason.BlockedModule or AntiCheatRefusalReason.ModuleScanFailed
|
||||
or AntiCheatRefusalReason.ProcessUnreadable or AntiCheatRefusalReason.ProcessTreeUnavailable
|
||||
or AntiCheatRefusalReason.BlockedDriver or AntiCheatRefusalReason.DriverScanFailed
|
||||
or AntiCheatRefusalReason.BlockedService or AntiCheatRefusalReason.ServiceQueryFailed
|
||||
or AntiCheatRefusalReason.BlockedExecutable or AntiCheatRefusalReason.BlockedStoreId
|
||||
or AntiCheatRefusalReason.AntiCheatDirectory or AntiCheatRefusalReason.AntiCheatFile
|
||||
or AntiCheatRefusalReason.SuspiciousUnsigned
|
||||
or AntiCheatRefusalReason.RulesUnreadable or AntiCheatRefusalReason.RulesMalformed
|
||||
or AntiCheatRefusalReason.RulesIncomplete or AntiCheatRefusalReason.PreScanFailed
|
||||
or AntiCheatRefusalReason.PreviouslyBlocked;
|
||||
public bool IsFindingAboutTheGame => _evaluated && Family.Length > 0 && Reason is
|
||||
AntiCheatRefusalReason.BlockedModule or AntiCheatRefusalReason.BlockedExecutable
|
||||
or AntiCheatRefusalReason.BlockedStoreId or AntiCheatRefusalReason.AntiCheatDirectory
|
||||
or AntiCheatRefusalReason.AntiCheatFile;
|
||||
|
||||
public static AntiCheatVerdict Refused(AntiCheatRefusalReason reason, string family, string signal) =>
|
||||
reason == AntiCheatRefusalReason.Allow
|
||||
|
||||
@@ -149,27 +149,6 @@ public readonly record struct GameConsentRecord
|
||||
/// </remarks>
|
||||
public bool IsFromStore => _fromStore;
|
||||
|
||||
/// <summary>
|
||||
/// When the user accepted the guard-bypass disclosure for this game, or null: the bypass is OFF, which is every
|
||||
/// row's default and the only state before 2026-09-21 (<c>19_SAFETY</c> §The user's bypass). A record of a human act,
|
||||
/// exactly as <see cref="ConsentedAt"/> is, and never meaningful without
|
||||
/// <see cref="GuardBypassDisclosureVersion"/>.
|
||||
/// </summary>
|
||||
public DateTimeOffset? GuardBypassAt { get; private init; }
|
||||
|
||||
/// <summary>The version of the bypass disclosure that was shown; empty when none was.</summary>
|
||||
public string GuardBypassDisclosureVersion { get => field ?? string.Empty; private init; }
|
||||
|
||||
/// <summary>
|
||||
/// True when a bypass acknowledgement is on the row AND names the disclosure it answered. A timestamp alone is not
|
||||
/// an acknowledgement, for the reason a consent timestamp alone is not consent.
|
||||
/// </summary>
|
||||
public bool GuardBypassAcknowledged => _fromStore && GuardBypassAt is not null && GuardBypassDisclosureVersion.Length > 0;
|
||||
|
||||
/// <summary>The same record carrying the row's bypass columns; the store is the only caller.</summary>
|
||||
internal GameConsentRecord WithGuardBypass(DateTimeOffset? at, string? disclosureVersion) =>
|
||||
this with { GuardBypassAt = at, GuardBypassDisclosureVersion = disclosureVersion ?? string.Empty };
|
||||
|
||||
/// <summary>The only way to build a record that claims to have come from a store.</summary>
|
||||
/// <remarks>
|
||||
/// Internal on purpose — see the type remarks. Widening it to <c>public</c> puts a
|
||||
|
||||
@@ -7,8 +7,10 @@ namespace FrameLedger.Domain.Detection;
|
||||
/// It holds signals, never groups. The schema forbids nesting in v2
|
||||
/// (<c>maxProperties: 1</c> plus its own <c>$comment</c>), so that constraint is
|
||||
/// expressed as a type here rather than as a validation rule someone has to
|
||||
/// remember. It is also why two <c>05_DETECTION</c> engine rows — both RPG Maker
|
||||
/// variants — cannot be expressed at all in this schema version.
|
||||
/// remember. This remark used to say it is why both RPG Maker rows could not be
|
||||
/// expressed; since 2026-09-16 both are, without nesting (<c>05_DETECTION</c>
|
||||
/// §Engine signatures), and FromSoftware's two archive halves are one <c>all</c>
|
||||
/// group (2026-09-23).
|
||||
/// </remarks>
|
||||
public sealed record SignalGroup
|
||||
{
|
||||
|
||||
@@ -72,21 +72,6 @@ public sealed class NativeAntiCheatGuard : IAntiCheatGuard
|
||||
private static extern void FlGuardedInjectWhenReady(uint targetPid, string dllPath, uint timeoutMs,
|
||||
out FlGuardResult result);
|
||||
|
||||
// The user's bypass (owner decision 2026-09-21): the two entry points above with one branch different. Every check
|
||||
// still runs and the result still names what was found; the reason is AllowedUnderUserBypass, never Allow.
|
||||
[DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
|
||||
[DllImport(_guardDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
|
||||
private static extern void FlGuardedInjectAcknowledged(uint targetPid, string dllPath, out FlGuardResult result);
|
||||
|
||||
[DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
|
||||
[DllImport(_guardDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
|
||||
private static extern void FlGuardedInjectWhenReadyAcknowledged(uint targetPid, string dllPath, uint timeoutMs,
|
||||
out FlGuardResult result);
|
||||
|
||||
[DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
|
||||
[DllImport(_guardDll, CallingConvention = CallingConvention.Cdecl)]
|
||||
private static extern int FlGuardIsJudgement(int reason);
|
||||
|
||||
[DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
|
||||
[DllImport(_guardDll, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
|
||||
private static extern void FlStaticPreScan(string gameDirectory, out FlGuardResult result);
|
||||
@@ -154,37 +139,6 @@ public sealed class NativeAntiCheatGuard : IAntiCheatGuard
|
||||
}, ct);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public ValueTask<AntiCheatVerdict> GuardedInjectAcknowledgedAsync(int targetPid, string payloadPath, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(payloadPath);
|
||||
return RunAsync(() =>
|
||||
{
|
||||
FlGuardedInjectAcknowledged(checked((uint)targetPid), payloadPath, out FlGuardResult r);
|
||||
return AntiCheatVerdict.FromNative(r.Reason, r.Family, r.Signal);
|
||||
}, ct);
|
||||
}
|
||||
|
||||
/// <inheritdoc />
|
||||
public ValueTask<AntiCheatVerdict> GuardedInjectWhenReadyAcknowledgedAsync(int targetPid, string payloadPath, int timeoutMs,
|
||||
CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(payloadPath);
|
||||
ArgumentOutOfRangeException.ThrowIfNegative(timeoutMs);
|
||||
return RunAsync(() =>
|
||||
{
|
||||
FlGuardedInjectWhenReadyAcknowledged(checked((uint)targetPid), payloadPath, checked((uint)timeoutMs),
|
||||
out FlGuardResult r);
|
||||
return AntiCheatVerdict.FromNative(r.Reason, r.Family, r.Signal);
|
||||
}, ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The NATIVE answer to "is this refusal the guard's judgement" — for the mirror test, which holds
|
||||
/// <c>AntiCheatVerdict.IsGuardJudgement</c> against it for every reason so the two lists cannot drift.
|
||||
/// </summary>
|
||||
public static bool NativeIsGuardJudgement(int reason) => FlGuardIsJudgement(reason) != 0;
|
||||
|
||||
/// <inheritdoc />
|
||||
public ValueTask<AntiCheatVerdict> PreScanGameDirectoryAsync(string gameDirectory,
|
||||
CancellationToken ct = default)
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
using System.Diagnostics;
|
||||
using FrameLedger.Application.Capture;
|
||||
using FrameLedger.Application.Watch;
|
||||
using FrameLedger.Infrastructure.Io;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Capture;
|
||||
@@ -31,25 +32,35 @@ public sealed class TargetResolver : ITargetResolver
|
||||
{
|
||||
private readonly Func<int, string?> _commandLineOf;
|
||||
private readonly Action<string>? _note;
|
||||
private readonly LatestProcessSnapshot? _latest;
|
||||
|
||||
/// <summary>The real resolver, reading command lines through the kernel query.</summary>
|
||||
/// <param name="note">Where the one line about a multi-process pick goes; null discards it.</param>
|
||||
public TargetResolver(Action<string>? note = null) : this(ProcessCommandLine.TryRead, note)
|
||||
/// <param name="note">Where the one line about a multi-process pick, or an unreadable candidate, goes; null discards it.</param>
|
||||
/// <param name="latest">The watcher's snapshot, when a watcher runs: <see cref="IsRunning"/> reads it by image path.</param>
|
||||
public TargetResolver(Action<string>? note = null, LatestProcessSnapshot? latest = null) : this(ProcessCommandLine.TryRead, note, latest)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>Test seam: how a candidate's command line is read.</summary>
|
||||
public TargetResolver(Func<int, string?> commandLineOf, Action<string>? note = null)
|
||||
public TargetResolver(Func<int, string?> commandLineOf, Action<string>? note = null, LatestProcessSnapshot? latest = null)
|
||||
{
|
||||
_commandLineOf = commandLineOf ?? throw new ArgumentNullException(nameof(commandLineOf));
|
||||
_note = note;
|
||||
_latest = latest;
|
||||
}
|
||||
|
||||
public int? Resolve(string normalisedExePath, out SessionEndReason reason)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(normalisedExePath);
|
||||
|
||||
List<int> matches = CollectMatches(normalisedExePath, out int unreadable);
|
||||
List<int> matches = CollectMatches(normalisedExePath, out int unreadable, out List<string> why);
|
||||
if (unreadable > 0)
|
||||
{
|
||||
// Said where the owner can read it (2026-09-23): HELLO, HELLO WORLD!'s launcher ended TargetUnreadable and the
|
||||
// log could not say whether it ran elevated or had not finished loading.
|
||||
_note?.Invoke($"target: {Path.GetFileName(normalisedExePath)}: {unreadable} process(es) with that name could not be read "
|
||||
+ $"({string.Join("; ", why)}); {matches.Count} readable match(es)");
|
||||
}
|
||||
|
||||
if (matches.Count == 0)
|
||||
{
|
||||
@@ -80,11 +91,39 @@ public sealed class TargetResolver : ITargetResolver
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>Every readable process whose image is the path; unreadable candidates are counted, never dropped.</summary>
|
||||
private static List<int> CollectMatches(string normalisedExePath, out int unreadable)
|
||||
/// <inheritdoc />
|
||||
public bool IsRunning(string normalisedExePath)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(normalisedExePath);
|
||||
|
||||
// The watcher's own 1 Hz snapshot when a watcher runs (2026-09-23): by the image path, so another game's Game.exe
|
||||
// no longer keeps this game's hold open, and still not one process is opened for the hold. The name below is the
|
||||
// console verbs' answer, where nothing polls.
|
||||
if (_latest?.Contains(normalisedExePath) is { } seen)
|
||||
{
|
||||
return seen;
|
||||
}
|
||||
|
||||
Process[] named = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(normalisedExePath));
|
||||
try
|
||||
{
|
||||
return named.Length > 0;
|
||||
}
|
||||
finally
|
||||
{
|
||||
foreach (Process p in named)
|
||||
{
|
||||
p.Dispose();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Every readable process whose image is the path; unreadable candidates are counted, never dropped, and <paramref name="why"/> says what stopped each.</summary>
|
||||
private static List<int> CollectMatches(string normalisedExePath, out int unreadable, out List<string> why)
|
||||
{
|
||||
string name = Path.GetFileNameWithoutExtension(normalisedExePath);
|
||||
List<int> matches = [];
|
||||
why = [];
|
||||
|
||||
// COUNTED, NOT JUST SKIPPED, and the difference is the whole invariant. Skipping alone is what
|
||||
// NARROWS: unreadable candidates vanish, so `matches.Count == 1` could not tell "one candidate
|
||||
@@ -110,6 +149,7 @@ public sealed class TargetResolver : ITargetResolver
|
||||
// enumerated. "Could not look" must not narrow the set, and that includes this
|
||||
// shape; it is counted like a process we lack the rights to read.
|
||||
unreadable++;
|
||||
why.Add($"pid {p.Id}: no main module yet");
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -124,6 +164,7 @@ public sealed class TargetResolver : ITargetResolver
|
||||
// Exited between enumeration and the read, or not ours to read. Either way we did not
|
||||
// establish whether it is our target.
|
||||
unreadable++;
|
||||
why.Add($"pid {p.Id}: {ex.Message}");
|
||||
}
|
||||
finally
|
||||
{
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
using System.Text.Json;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Import;
|
||||
|
||||
/// <summary>
|
||||
/// An RPG Maker MV/MZ game's own title (2026-09-23): <c>gameTitle</c> in <c>data\System.json</c> — under <c>www\</c> for
|
||||
/// MV, at the root for MZ — beside the executable or up to two folders above it (a launcher-fronted game keeps its
|
||||
/// runtime in a subfolder: <i>HELLO, HELLO WORLD!</i>'s is <c>swiftshader\</c>). Read only when the executable's own name
|
||||
/// says nothing (<c>Game.exe</c>), and bounded: a file over 1 MiB, an unreadable one or one without the field is null.
|
||||
/// </summary>
|
||||
public static class RpgMakerTitle
|
||||
{
|
||||
private const long _maxBytes = 1024 * 1024;
|
||||
|
||||
/// <summary>The title, or null when there is none to be read.</summary>
|
||||
public static string? TryRead(string exePath)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(exePath);
|
||||
string? dir = Path.GetDirectoryName(exePath);
|
||||
for (int up = 0; up <= 2 && !string.IsNullOrEmpty(dir); up++, dir = Path.GetDirectoryName(dir))
|
||||
{
|
||||
foreach (string relative in (string[])[Path.Combine("www", "data", "System.json"), Path.Combine("data", "System.json")])
|
||||
{
|
||||
if (TryTitle(Path.Combine(dir, relative)) is { } title)
|
||||
{
|
||||
return title;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static string? TryTitle(string path)
|
||||
{
|
||||
try
|
||||
{
|
||||
var file = new FileInfo(path);
|
||||
if (!file.Exists || file.Length > _maxBytes)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
using FileStream stream = file.OpenRead();
|
||||
using JsonDocument doc = JsonDocument.Parse(stream);
|
||||
return doc.RootElement.ValueKind == JsonValueKind.Object
|
||||
&& doc.RootElement.TryGetProperty("gameTitle", out JsonElement title)
|
||||
&& title.ValueKind == JsonValueKind.String
|
||||
&& title.GetString() is { } text
|
||||
&& !string.IsNullOrWhiteSpace(text)
|
||||
? text.Trim()
|
||||
: null;
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or JsonException)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -12,6 +12,26 @@ namespace FrameLedger.Infrastructure.Import;
|
||||
/// </summary>
|
||||
public sealed class SteamLibrarySource(string? steamRoot = null) : IStoreLibrarySource
|
||||
{
|
||||
/// <summary>
|
||||
/// Steam app ids that are tools, runtimes or redistributables rather than games (2026-09-22). Steam's manifests do
|
||||
/// not say which is which, and an imported tool becomes a row the watcher records Tier-2 sessions for — Borderless
|
||||
/// Gaming (388080) on the owner's machine, a tray utility that runs elevated for hours. A user who wants one of
|
||||
/// these tracked can still add its executable by hand; the import merely stops guessing that it is a game.
|
||||
/// </summary>
|
||||
public static readonly IReadOnlySet<string> KnownTools = new HashSet<string>(StringComparer.Ordinal)
|
||||
{
|
||||
"228980", // Steamworks Common Redistributables
|
||||
"250820", // SteamVR
|
||||
"365670", // Blender
|
||||
"388080", // Borderless Gaming
|
||||
"431960", // Wallpaper Engine
|
||||
"1070560", // Steam Linux Runtime
|
||||
"1391110", // Steam Linux Runtime - Soldier
|
||||
"1493710", // Proton Experimental
|
||||
"1628350", // Steam Linux Runtime - Sniper
|
||||
"2180100", // Proton Hotfix
|
||||
};
|
||||
|
||||
public string Platform => "steam";
|
||||
|
||||
public ValueTask<IReadOnlyList<StoreGame>> ListAsync(CancellationToken ct = default)
|
||||
@@ -34,7 +54,7 @@ public sealed class SteamLibrarySource(string? steamRoot = null) : IStoreLibrary
|
||||
|
||||
foreach (string manifest in Directory.EnumerateFiles(steamapps, "appmanifest_*.acf"))
|
||||
{
|
||||
if (ReadManifest(manifest, steamapps) is { } game)
|
||||
if (ReadManifest(manifest, steamapps) is { } game && !KnownTools.Contains(game.StoreId))
|
||||
{
|
||||
games.Add(game);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
-- 0008 (2026-09-22): the guard bypass is withdrawn (owner decision; 19_SAFETY §What a finding does to the game).
|
||||
--
|
||||
-- 0007 added five columns for the one day the guard had an override. The owner withdrew it before any release carried
|
||||
-- it past 0.1.0-beta.4: a bypass that cannot open a process an anti-cheat driver protects, and that merely lets the
|
||||
-- Overlay be loaded beside an anti-cheat that WILL see it, was a switch whose only reliable effect was a ban. Nothing
|
||||
-- reads or writes these columns any more, and this script removes them so the schema says what the code does.
|
||||
--
|
||||
-- THE ONE DEPARTURE from "ALTER TABLE ADD COLUMN only" (06_DATA_MODEL §Migrations), and the reasons it is safe here:
|
||||
-- * SQLite has supported ALTER TABLE ... DROP COLUMN since 3.35.0 (2021-03); Microsoft.Data.Sqlite bundles a newer
|
||||
-- engine, and LedgerDatabaseTests asserts the version floor beside this script.
|
||||
-- * none of the five is indexed, referenced, generated, or part of a constraint; guard_bypass_disclosure_version is
|
||||
-- NOT NULL DEFAULT '' and drops like any other column.
|
||||
-- * the data being dropped is the bypass acknowledgements themselves. A row that carried one loses it, which is the
|
||||
-- decision: no game keeps a standing permission to inject past a finding. The mark on a session
|
||||
-- (guard_bypassed = 1) is dropped with the columns; capture_notes still carries "guard-bypass=" for the sessions
|
||||
-- that ran under it, so the ledger does not forget that they did.
|
||||
--
|
||||
-- Earlier scripts are still never edited; 0007 stays as applied.
|
||||
|
||||
ALTER TABLE sessions DROP COLUMN guard_bypass_signal;
|
||||
ALTER TABLE sessions DROP COLUMN guard_bypass_family;
|
||||
ALTER TABLE sessions DROP COLUMN guard_bypassed;
|
||||
ALTER TABLE games DROP COLUMN guard_bypass_disclosure_version;
|
||||
ALTER TABLE games DROP COLUMN guard_bypass_at;
|
||||
@@ -13,10 +13,10 @@ namespace FrameLedger.Infrastructure.Persistence;
|
||||
internal static class SessionRowColumns
|
||||
{
|
||||
public const string Insert =
|
||||
"INSERT INTO sessions (session_guid, game_id, snapshot_id, started_at, ended_at, duration_s, qpc_epoch, qpc_frequency, capture_tier, capture_mode, capture_notes, late_attach, telemetry_source, overlay_build_id, exit_status, drain_ticks, foreground_ticks, records_before_attach, dxgi_presents_before_hook, gap_count, guard_ticks_published, launch_wait_ms, api, present_mode, swap_effect, hdr_flag, hdr_source, sync_interval_mode, upscaler, upscaler_quality, upscaler_sharpness, upscaler_driver_reported, render_w, render_h, output_w, output_h, upscale_ratio, settings_changed_midsession, fg_mode, fg_source, fg_factor, fg_driver_reported, fg_runtime_census, fg_none_withheld_reason, fg_refusal, fg_refusal_detail, fg_factor_scope, fg_steady_share, presented_fps, presented_qualifier, dxgi_unseen_total, dxgi_present_samples, displayed_counted_by, sl_tag_census, sl_interposer_version, runtime_modules, executable_markers, ngx_driver_words, rt_flag, rt_source, pt_flag, pt_source, pt_confidence, rr_flag, rr_source, rt_frame_pct, rays_per_pixel, rt_pso_count, rt_tier, hooks_installed_mask, raster_pso_count, frame_count, app_frame_count, displayed_frame_count, dropped_frames, native_fps, displayed_fps, median_fps, p1_low_fps, p01_low_fps, displayed_p1_low_fps, min_fps, max_fps, frametime_stddev_ms, stutter_count, stutter_time_pct, pso_stutter_pct, reflex_active, latency_avg_us, latency_p95_us, dropped_records, fault_count, data_quality_warnings, writer_status_at_end, early_stop_family, loader_signals, vram_proc_avg_mb, vram_proc_max_mb, vram_budget_exceeded_pct, vram_adapter_max_mb, avg_cpu_temp, max_cpu_temp, avg_gpu_temp, max_gpu_temp, max_gpu_hotspot, avg_gpu_load, avg_cpu_load, avg_ram_mb, avg_gpu_power_w, throttle_pct, guard_bypassed, guard_bypass_family, guard_bypass_signal) "
|
||||
+ "VALUES (@session_guid, @game_id, @snapshot_id, @started_at, @ended_at, @duration_s, @qpc_epoch, @qpc_frequency, @capture_tier, @capture_mode, @capture_notes, @late_attach, @telemetry_source, @overlay_build_id, @exit_status, @drain_ticks, @foreground_ticks, @records_before_attach, @dxgi_presents_before_hook, @gap_count, @guard_ticks_published, @launch_wait_ms, @api, @present_mode, @swap_effect, @hdr_flag, @hdr_source, @sync_interval_mode, @upscaler, @upscaler_quality, @upscaler_sharpness, @upscaler_driver_reported, @render_w, @render_h, @output_w, @output_h, @upscale_ratio, @settings_changed_midsession, @fg_mode, @fg_source, @fg_factor, @fg_driver_reported, @fg_runtime_census, @fg_none_withheld_reason, @fg_refusal, @fg_refusal_detail, @fg_factor_scope, @fg_steady_share, @presented_fps, @presented_qualifier, @dxgi_unseen_total, @dxgi_present_samples, @displayed_counted_by, @sl_tag_census, @sl_interposer_version, @runtime_modules, @executable_markers, @ngx_driver_words, @rt_flag, @rt_source, @pt_flag, @pt_source, @pt_confidence, @rr_flag, @rr_source, @rt_frame_pct, @rays_per_pixel, @rt_pso_count, @rt_tier, @hooks_installed_mask, @raster_pso_count, @frame_count, @app_frame_count, @displayed_frame_count, @dropped_frames, @native_fps, @displayed_fps, @median_fps, @p1_low_fps, @p01_low_fps, @displayed_p1_low_fps, @min_fps, @max_fps, @frametime_stddev_ms, @stutter_count, @stutter_time_pct, @pso_stutter_pct, @reflex_active, @latency_avg_us, @latency_p95_us, @dropped_records, @fault_count, @data_quality_warnings, @writer_status_at_end, @early_stop_family, @loader_signals, @vram_proc_avg_mb, @vram_proc_max_mb, @vram_budget_exceeded_pct, @vram_adapter_max_mb, @avg_cpu_temp, @max_cpu_temp, @avg_gpu_temp, @max_gpu_temp, @max_gpu_hotspot, @avg_gpu_load, @avg_cpu_load, @avg_ram_mb, @avg_gpu_power_w, @throttle_pct, @guard_bypassed, @guard_bypass_family, @guard_bypass_signal) RETURNING id";
|
||||
"INSERT INTO sessions (session_guid, game_id, snapshot_id, started_at, ended_at, duration_s, qpc_epoch, qpc_frequency, capture_tier, capture_mode, capture_notes, late_attach, telemetry_source, overlay_build_id, exit_status, drain_ticks, foreground_ticks, records_before_attach, dxgi_presents_before_hook, gap_count, guard_ticks_published, launch_wait_ms, api, present_mode, swap_effect, hdr_flag, hdr_source, sync_interval_mode, upscaler, upscaler_quality, upscaler_sharpness, upscaler_driver_reported, render_w, render_h, output_w, output_h, upscale_ratio, settings_changed_midsession, fg_mode, fg_source, fg_factor, fg_driver_reported, fg_runtime_census, fg_none_withheld_reason, fg_refusal, fg_refusal_detail, fg_factor_scope, fg_steady_share, presented_fps, presented_qualifier, dxgi_unseen_total, dxgi_present_samples, displayed_counted_by, sl_tag_census, sl_interposer_version, runtime_modules, executable_markers, ngx_driver_words, rt_flag, rt_source, pt_flag, pt_source, pt_confidence, rr_flag, rr_source, rt_frame_pct, rays_per_pixel, rt_pso_count, rt_tier, hooks_installed_mask, raster_pso_count, frame_count, app_frame_count, displayed_frame_count, dropped_frames, native_fps, displayed_fps, median_fps, p1_low_fps, p01_low_fps, displayed_p1_low_fps, min_fps, max_fps, frametime_stddev_ms, stutter_count, stutter_time_pct, pso_stutter_pct, reflex_active, latency_avg_us, latency_p95_us, dropped_records, fault_count, data_quality_warnings, writer_status_at_end, early_stop_family, loader_signals, vram_proc_avg_mb, vram_proc_max_mb, vram_budget_exceeded_pct, vram_adapter_max_mb, avg_cpu_temp, max_cpu_temp, avg_gpu_temp, max_gpu_temp, max_gpu_hotspot, avg_gpu_load, avg_cpu_load, avg_ram_mb, avg_gpu_power_w, throttle_pct) "
|
||||
+ "VALUES (@session_guid, @game_id, @snapshot_id, @started_at, @ended_at, @duration_s, @qpc_epoch, @qpc_frequency, @capture_tier, @capture_mode, @capture_notes, @late_attach, @telemetry_source, @overlay_build_id, @exit_status, @drain_ticks, @foreground_ticks, @records_before_attach, @dxgi_presents_before_hook, @gap_count, @guard_ticks_published, @launch_wait_ms, @api, @present_mode, @swap_effect, @hdr_flag, @hdr_source, @sync_interval_mode, @upscaler, @upscaler_quality, @upscaler_sharpness, @upscaler_driver_reported, @render_w, @render_h, @output_w, @output_h, @upscale_ratio, @settings_changed_midsession, @fg_mode, @fg_source, @fg_factor, @fg_driver_reported, @fg_runtime_census, @fg_none_withheld_reason, @fg_refusal, @fg_refusal_detail, @fg_factor_scope, @fg_steady_share, @presented_fps, @presented_qualifier, @dxgi_unseen_total, @dxgi_present_samples, @displayed_counted_by, @sl_tag_census, @sl_interposer_version, @runtime_modules, @executable_markers, @ngx_driver_words, @rt_flag, @rt_source, @pt_flag, @pt_source, @pt_confidence, @rr_flag, @rr_source, @rt_frame_pct, @rays_per_pixel, @rt_pso_count, @rt_tier, @hooks_installed_mask, @raster_pso_count, @frame_count, @app_frame_count, @displayed_frame_count, @dropped_frames, @native_fps, @displayed_fps, @median_fps, @p1_low_fps, @p01_low_fps, @displayed_p1_low_fps, @min_fps, @max_fps, @frametime_stddev_ms, @stutter_count, @stutter_time_pct, @pso_stutter_pct, @reflex_active, @latency_avg_us, @latency_p95_us, @dropped_records, @fault_count, @data_quality_warnings, @writer_status_at_end, @early_stop_family, @loader_signals, @vram_proc_avg_mb, @vram_proc_max_mb, @vram_budget_exceeded_pct, @vram_adapter_max_mb, @avg_cpu_temp, @max_cpu_temp, @avg_gpu_temp, @max_gpu_temp, @max_gpu_hotspot, @avg_gpu_load, @avg_cpu_load, @avg_ram_mb, @avg_gpu_power_w, @throttle_pct) RETURNING id";
|
||||
|
||||
public const string Select = "SELECT id, session_guid, game_id, snapshot_id, started_at, ended_at, duration_s, qpc_epoch, qpc_frequency, capture_tier, capture_mode, capture_notes, late_attach, telemetry_source, overlay_build_id, exit_status, drain_ticks, foreground_ticks, records_before_attach, dxgi_presents_before_hook, gap_count, guard_ticks_published, launch_wait_ms, api, present_mode, swap_effect, hdr_flag, hdr_source, sync_interval_mode, upscaler, upscaler_quality, upscaler_sharpness, upscaler_driver_reported, render_w, render_h, output_w, output_h, upscale_ratio, settings_changed_midsession, fg_mode, fg_source, fg_factor, fg_driver_reported, fg_runtime_census, fg_none_withheld_reason, fg_refusal, fg_refusal_detail, fg_factor_scope, fg_steady_share, presented_fps, presented_qualifier, dxgi_unseen_total, dxgi_present_samples, displayed_counted_by, sl_tag_census, sl_interposer_version, runtime_modules, executable_markers, ngx_driver_words, rt_flag, rt_source, pt_flag, pt_source, pt_confidence, rr_flag, rr_source, rt_frame_pct, rays_per_pixel, rt_pso_count, rt_tier, hooks_installed_mask, raster_pso_count, frame_count, app_frame_count, displayed_frame_count, dropped_frames, native_fps, displayed_fps, median_fps, p1_low_fps, p01_low_fps, displayed_p1_low_fps, min_fps, max_fps, frametime_stddev_ms, stutter_count, stutter_time_pct, pso_stutter_pct, reflex_active, latency_avg_us, latency_p95_us, dropped_records, fault_count, data_quality_warnings, writer_status_at_end, early_stop_family, loader_signals, vram_proc_avg_mb, vram_proc_max_mb, vram_budget_exceeded_pct, vram_adapter_max_mb, avg_cpu_temp, max_cpu_temp, avg_gpu_temp, max_gpu_temp, max_gpu_hotspot, avg_gpu_load, avg_cpu_load, avg_ram_mb, avg_gpu_power_w, throttle_pct, guard_bypassed, guard_bypass_family, guard_bypass_signal FROM sessions";
|
||||
public const string Select = "SELECT id, session_guid, game_id, snapshot_id, started_at, ended_at, duration_s, qpc_epoch, qpc_frequency, capture_tier, capture_mode, capture_notes, late_attach, telemetry_source, overlay_build_id, exit_status, drain_ticks, foreground_ticks, records_before_attach, dxgi_presents_before_hook, gap_count, guard_ticks_published, launch_wait_ms, api, present_mode, swap_effect, hdr_flag, hdr_source, sync_interval_mode, upscaler, upscaler_quality, upscaler_sharpness, upscaler_driver_reported, render_w, render_h, output_w, output_h, upscale_ratio, settings_changed_midsession, fg_mode, fg_source, fg_factor, fg_driver_reported, fg_runtime_census, fg_none_withheld_reason, fg_refusal, fg_refusal_detail, fg_factor_scope, fg_steady_share, presented_fps, presented_qualifier, dxgi_unseen_total, dxgi_present_samples, displayed_counted_by, sl_tag_census, sl_interposer_version, runtime_modules, executable_markers, ngx_driver_words, rt_flag, rt_source, pt_flag, pt_source, pt_confidence, rr_flag, rr_source, rt_frame_pct, rays_per_pixel, rt_pso_count, rt_tier, hooks_installed_mask, raster_pso_count, frame_count, app_frame_count, displayed_frame_count, dropped_frames, native_fps, displayed_fps, median_fps, p1_low_fps, p01_low_fps, displayed_p1_low_fps, min_fps, max_fps, frametime_stddev_ms, stutter_count, stutter_time_pct, pso_stutter_pct, reflex_active, latency_avg_us, latency_p95_us, dropped_records, fault_count, data_quality_warnings, writer_status_at_end, early_stop_family, loader_signals, vram_proc_avg_mb, vram_proc_max_mb, vram_budget_exceeded_pct, vram_adapter_max_mb, avg_cpu_temp, max_cpu_temp, avg_gpu_temp, max_gpu_temp, max_gpu_hotspot, avg_gpu_load, avg_cpu_load, avg_ram_mb, avg_gpu_power_w, throttle_pct FROM sessions";
|
||||
|
||||
public static Dictionary<string, object?> Parameters(SessionRow s)
|
||||
{
|
||||
@@ -155,9 +155,6 @@ internal static class SessionRowColumns
|
||||
d["avg_ram_mb"] = s.AvgRamMb;
|
||||
d["avg_gpu_power_w"] = s.AvgGpuPowerW;
|
||||
d["throttle_pct"] = s.ThrottlePct;
|
||||
d["guard_bypassed"] = s.GuardBypassed ? 1L : 0L;
|
||||
d["guard_bypass_family"] = s.GuardBypassFamily;
|
||||
d["guard_bypass_signal"] = s.GuardBypassSignal;
|
||||
}
|
||||
|
||||
|
||||
@@ -285,9 +282,6 @@ internal static class SessionRowColumns
|
||||
AvgRamMb = D(r, "avg_ram_mb"),
|
||||
AvgGpuPowerW = D(r, "avg_gpu_power_w"),
|
||||
ThrottlePct = D(r, "throttle_pct"),
|
||||
GuardBypassed = L(r, "guard_bypassed") == 1,
|
||||
GuardBypassFamily = S(r, "guard_bypass_family"),
|
||||
GuardBypassSignal = S(r, "guard_bypass_signal"),
|
||||
};
|
||||
|
||||
public static string ExitStatusText(ExitStatus status) => Vocabulary.ExitStatusText(status);
|
||||
|
||||
@@ -34,8 +34,7 @@ public sealed class SqliteGameConsentStore : IGameConsentStore
|
||||
{
|
||||
private const string _columns =
|
||||
"exe_path, exe_size_bytes, exe_mtime_ms, hook_enabled, hook_consent_at, hook_consent_provenance, "
|
||||
+ "hook_consent_disclosure_version, hook_blocked_reason, hook_prescan_state, updated_at, "
|
||||
+ "guard_bypass_at, guard_bypass_disclosure_version";
|
||||
+ "hook_consent_disclosure_version, hook_blocked_reason, hook_prescan_state, updated_at";
|
||||
|
||||
private const string _selectOne = $"SELECT {_columns} FROM games WHERE exe_path = @path";
|
||||
|
||||
@@ -52,12 +51,9 @@ public sealed class SqliteGameConsentStore : IGameConsentStore
|
||||
+ "hook_consent_provenance = @provenance, hook_consent_disclosure_version = @disclosure, updated_at = @at "
|
||||
+ "WHERE exe_path = @path";
|
||||
|
||||
// Withdrawing consent takes the guard bypass with it (schema 0007): turning hooking off returns the row to its
|
||||
// safest state, and turning it on again under a bypass means reading that disclosure again.
|
||||
private const string _revoke =
|
||||
"UPDATE games SET hook_enabled = 0, hook_consent_at = NULL, hook_consent_provenance = @provenance, "
|
||||
+ "hook_consent_disclosure_version = '', guard_bypass_at = NULL, guard_bypass_disclosure_version = '', "
|
||||
+ "updated_at = @at WHERE exe_path = @path";
|
||||
+ "hook_consent_disclosure_version = '', updated_at = @at WHERE exe_path = @path";
|
||||
|
||||
private const string _insertBlock =
|
||||
"INSERT INTO games (name, exe_path, exe_size_bytes, exe_mtime_ms, hook_enabled, hook_blocked_reason, "
|
||||
@@ -239,9 +235,7 @@ public sealed class SqliteGameConsentStore : IGameConsentStore
|
||||
string DisclosureVersion,
|
||||
string? BlockedReason,
|
||||
string PreScanState,
|
||||
long UpdatedAtMs,
|
||||
long? GuardBypassAtMs,
|
||||
string GuardBypassDisclosureVersion)
|
||||
long UpdatedAtMs)
|
||||
{
|
||||
public static Row From(DbDataReader r) => new(
|
||||
new ExecutableFingerprint
|
||||
@@ -256,9 +250,7 @@ public sealed class SqliteGameConsentStore : IGameConsentStore
|
||||
r.GetString(6),
|
||||
SqliteReaders.String(r, 7),
|
||||
r.GetString(8),
|
||||
r.GetInt64(9),
|
||||
SqliteReaders.Int64(r, 10),
|
||||
SqliteReaders.String(r, 11) ?? string.Empty);
|
||||
r.GetInt64(9));
|
||||
|
||||
public GameConsentRecord ToRecord() => GameConsentRecord.Stored(
|
||||
Fingerprint,
|
||||
@@ -268,8 +260,7 @@ public sealed class SqliteGameConsentStore : IGameConsentStore
|
||||
DisclosureVersion,
|
||||
BlockedReason,
|
||||
string.Equals(PreScanState, "unverified", StringComparison.Ordinal),
|
||||
DateTimeOffset.FromUnixTimeMilliseconds(UpdatedAtMs))
|
||||
.WithGuardBypass(GuardBypassAtMs is { } at ? DateTimeOffset.FromUnixTimeMilliseconds(at) : null, GuardBypassDisclosureVersion);
|
||||
DateTimeOffset.FromUnixTimeMilliseconds(UpdatedAtMs));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -23,7 +23,7 @@ public sealed class SqliteGameRepository : IGameRepository
|
||||
+ "hook_crash_count, hook_last_injected_at, added_at, updated_at, "
|
||||
+ "platform, store_id, engine, engine_version, publisher, game_version, cover_path, notes, field_provenance, capability_flags, "
|
||||
+ "rt_default, pt_default, rr_default, hook_consent_at, hook_prescan_state, removed_at, "
|
||||
+ "detection_rules_version, detection_exe_size_bytes, detection_exe_mtime_ms, guard_bypass_at";
|
||||
+ "detection_rules_version, detection_exe_size_bytes, detection_exe_mtime_ms";
|
||||
|
||||
private const string _selectByPath = $"SELECT {_columns} FROM games WHERE exe_path = @path";
|
||||
|
||||
@@ -46,9 +46,16 @@ public sealed class SqliteGameRepository : IGameRepository
|
||||
private const string _changeExecutable =
|
||||
"UPDATE games SET exe_path = @path, exe_size_bytes = @size, exe_mtime_ms = @mtime, hook_enabled = 0, hook_consent_at = NULL, "
|
||||
+ "hook_consent_provenance = 'NotRecorded', hook_consent_disclosure_version = '', hook_prescan_state = 'not_run', "
|
||||
+ "guard_bypass_at = NULL, guard_bypass_disclosure_version = '', updated_at = @at "
|
||||
+ "updated_at = @at "
|
||||
+ "WHERE id = @id AND removed_at IS NULL AND NOT EXISTS (SELECT 1 FROM games other WHERE other.exe_path = @path AND other.id <> @id)";
|
||||
|
||||
// The same bytes under another path: nothing but exe_path and updated_at move, and the size/mtime predicate is what
|
||||
// makes "the same bytes" a condition of the write rather than a promise of the caller (IGameRepository.RelocateExecutableAsync).
|
||||
private const string _relocateExecutable =
|
||||
"UPDATE games SET exe_path = @path, updated_at = @at "
|
||||
+ "WHERE id = @id AND removed_at IS NULL AND exe_size_bytes = @size AND exe_mtime_ms = @mtime "
|
||||
+ "AND NOT EXISTS (SELECT 1 FROM games other WHERE other.exe_path = @path AND other.id <> @id)";
|
||||
|
||||
private const string _crash =
|
||||
"UPDATE games SET hook_crash_count = hook_crash_count + 1, updated_at = @now WHERE id = @id RETURNING hook_crash_count";
|
||||
|
||||
@@ -130,6 +137,14 @@ public sealed class SqliteGameRepository : IGameRepository
|
||||
_changeExecutable, p, tx, cancellationToken: token)).ConfigureAwait(false) == 1, ct);
|
||||
}
|
||||
|
||||
public ValueTask<bool> RelocateExecutableAsync(long gameId, ExecutableFingerprint moved, DateTimeOffset at, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(moved.ExePath, nameof(moved));
|
||||
var p = new { id = gameId, path = moved.ExePath, size = moved.SizeBytes, mtime = moved.MtimeUnixMs, at = at.ToUnixTimeMilliseconds() };
|
||||
return _db.WriteAsync(async (c, tx, token) => await c.ExecuteAsync(new CommandDefinition(
|
||||
_relocateExecutable, p, tx, cancellationToken: token)).ConfigureAwait(false) == 1, ct);
|
||||
}
|
||||
|
||||
public ValueTask<int> RecordCrashAsync(long gameId, CancellationToken ct = default) =>
|
||||
_db.WriteAsync((c, tx, token) => c.ExecuteScalarAsync<int>(new CommandDefinition(
|
||||
_crash, new { id = gameId, now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }, tx, cancellationToken: token)), ct);
|
||||
@@ -312,7 +327,6 @@ public sealed class SqliteGameRepository : IGameRepository
|
||||
DetectionRulesVersion = SqliteReaders.String(r, 28),
|
||||
DetectionExeSizeBytes = SqliteReaders.Int64(r, 29),
|
||||
DetectionExeMtimeMs = SqliteReaders.Int64(r, 30),
|
||||
GuardBypassAt = At(SqliteReaders.Int64(r, 31)),
|
||||
};
|
||||
|
||||
private static DateTimeOffset? At(long? unixMs) => unixMs is { } ms ? DateTimeOffset.FromUnixTimeMilliseconds(ms) : null;
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
using Dapper;
|
||||
using FrameLedger.Application.Consent;
|
||||
using FrameLedger.Domain.Consent;
|
||||
using Microsoft.Data.Sqlite;
|
||||
|
||||
namespace FrameLedger.Infrastructure.Persistence;
|
||||
|
||||
/// <summary>
|
||||
/// <see cref="IGuardBypassStore"/> over <c>games.guard_bypass_at</c> / <c>guard_bypass_disclosure_version</c> (schema
|
||||
/// 0007). Two statements, two columns each, and a WHERE clause that is the rule: the row must exist, must be in the
|
||||
/// library, and must be about the executable the acknowledgement names.
|
||||
/// </summary>
|
||||
public sealed class SqliteGuardBypassStore : IGuardBypassStore
|
||||
{
|
||||
// The fingerprint is IN the predicate: an acknowledgement for another binary updates zero rows.
|
||||
private const string _record =
|
||||
"UPDATE games SET guard_bypass_at = @at, guard_bypass_disclosure_version = @disclosure, updated_at = @at "
|
||||
+ "WHERE exe_path = @path AND removed_at IS NULL AND exe_size_bytes = @size AND exe_mtime_ms = @mtime";
|
||||
|
||||
private const string _exists = "SELECT COUNT(*) FROM games WHERE exe_path = @path AND removed_at IS NULL";
|
||||
|
||||
private const string _revoke =
|
||||
"UPDATE games SET guard_bypass_at = NULL, guard_bypass_disclosure_version = '', updated_at = @at WHERE exe_path = @path";
|
||||
|
||||
private readonly LedgerDatabase _db;
|
||||
|
||||
public SqliteGuardBypassStore(LedgerDatabase db) => _db = db ?? throw new ArgumentNullException(nameof(db));
|
||||
|
||||
public async ValueTask<ConsentWriteOutcome> RecordAsync(GuardBypassAcknowledgement acknowledgement, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(acknowledgement);
|
||||
if (string.IsNullOrWhiteSpace(acknowledgement.DisclosureVersion))
|
||||
{
|
||||
throw new ArgumentException("a bypass acknowledgement must name the disclosure it answered", nameof(acknowledgement));
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
return await _db.WriteAsync(async (c, tx, token) =>
|
||||
{
|
||||
ExecutableFingerprint fp = acknowledgement.Fingerprint;
|
||||
var p = new
|
||||
{
|
||||
path = fp.ExePath,
|
||||
size = fp.SizeBytes,
|
||||
mtime = fp.MtimeUnixMs,
|
||||
at = acknowledgement.AcknowledgedAt.ToUnixTimeMilliseconds(),
|
||||
disclosure = acknowledgement.DisclosureVersion,
|
||||
};
|
||||
int written = await c.ExecuteAsync(new CommandDefinition(_record, p, tx, cancellationToken: token)).ConfigureAwait(false);
|
||||
if (written == 1)
|
||||
{
|
||||
return ConsentWriteOutcome.Written;
|
||||
}
|
||||
|
||||
long rows = await c.ExecuteScalarAsync<long>(new CommandDefinition(_exists, new { path = fp.ExePath }, tx, cancellationToken: token)).ConfigureAwait(false);
|
||||
return rows == 0 ? ConsentWriteOutcome.Failed : ConsentWriteOutcome.StaleFingerprint;
|
||||
}, ct).ConfigureAwait(false);
|
||||
}
|
||||
catch (SqliteException)
|
||||
{
|
||||
return ConsentWriteOutcome.Failed;
|
||||
}
|
||||
}
|
||||
|
||||
public async ValueTask<ConsentWriteOutcome> RevokeAsync(string normalisedExePath, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(normalisedExePath);
|
||||
try
|
||||
{
|
||||
await _db.WriteAsync(async (c, tx, token) => await c.ExecuteAsync(new CommandDefinition(
|
||||
_revoke, new { path = normalisedExePath, at = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() }, tx, cancellationToken: token)).ConfigureAwait(false), ct).ConfigureAwait(false);
|
||||
return ConsentWriteOutcome.Written;
|
||||
}
|
||||
catch (SqliteException)
|
||||
{
|
||||
return ConsentWriteOutcome.Failed;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -34,6 +34,16 @@ public sealed class SqliteSessionRepository : ISessionRepository
|
||||
|
||||
private const string _exists = "SELECT COUNT(*) FROM sessions WHERE session_guid = @guid";
|
||||
|
||||
// The row a finishing session belongs to (2026-09-23; ISessionRepository.ResolveOwnerAsync). The id it started under,
|
||||
// when that row predates the session or holds its executable — an id SQLite handed to a LATER game (no AUTOINCREMENT)
|
||||
// is neither — and otherwise the row that holds the executable now. exe_path is COLLATE NOCASE, so '=' is too.
|
||||
private const string _ownerById =
|
||||
"SELECT id FROM games WHERE id = @gameId AND (added_at <= @startedAt OR (@path IS NOT NULL AND exe_path = @path))";
|
||||
|
||||
private const string _ownerByPath = "SELECT id FROM games WHERE exe_path = @path";
|
||||
|
||||
private const string _ownerExists = "SELECT COUNT(*) FROM games WHERE id = @gameId";
|
||||
|
||||
private const string _selectSegments =
|
||||
"SELECT swapchain_id, start_frame, end_frame, render_w, render_h, output_w, output_h, upscaler, upscaler_quality, fg_mode, "
|
||||
+ "native_fps, displayed_fps, p1_low_fps FROM session_segments WHERE session_id = @sessionId ORDER BY start_frame, swapchain_id";
|
||||
@@ -82,6 +92,13 @@ public sealed class SqliteSessionRepository : ISessionRepository
|
||||
throw new InvalidOperationException($"session {session.Row.SessionGuid:D} is already stored");
|
||||
}
|
||||
|
||||
// Inside the write transaction, so a removal cannot slip between this and the insert (one writer): the entry
|
||||
// removed while its session ran is a named outcome, not the foreign key's SqliteException (2026-09-23).
|
||||
if (await c.ExecuteScalarAsync<long>(new CommandDefinition(_ownerExists, new { gameId = session.Row.GameId }, tx, cancellationToken: token)).ConfigureAwait(false) == 0)
|
||||
{
|
||||
throw new SessionOwnerMissingException($"session {session.Row.SessionGuid:D}: games row {session.Row.GameId} no longer exists");
|
||||
}
|
||||
|
||||
long id = await c.ExecuteScalarAsync<long>(new CommandDefinition(
|
||||
SessionRowColumns.Insert, SessionRowColumns.Parameters(session.Row), tx, cancellationToken: token)).ConfigureAwait(false);
|
||||
await InsertSegmentsAsync(c, tx, id, session.Segments, token).ConfigureAwait(false);
|
||||
@@ -98,6 +115,19 @@ public sealed class SqliteSessionRepository : ISessionRepository
|
||||
public ValueTask<bool> ExistsAsync(Guid sessionGuid, CancellationToken ct = default) =>
|
||||
_db.ReadAsync((c, token) => ExistsInAsync(c, null, sessionGuid, token), ct);
|
||||
|
||||
public ValueTask<long?> ResolveOwnerAsync(long gameId, string? exePath, DateTimeOffset startedAt, CancellationToken ct = default) =>
|
||||
_db.ReadAsync(async (c, token) =>
|
||||
{
|
||||
var p = new { gameId, path = exePath, startedAt = startedAt.ToUnixTimeMilliseconds() };
|
||||
long? byId = await c.ExecuteScalarAsync<long?>(new CommandDefinition(_ownerById, p, cancellationToken: token)).ConfigureAwait(false);
|
||||
if (byId is not null || exePath is null)
|
||||
{
|
||||
return byId;
|
||||
}
|
||||
|
||||
return await c.ExecuteScalarAsync<long?>(new CommandDefinition(_ownerByPath, p, cancellationToken: token)).ConfigureAwait(false);
|
||||
}, ct);
|
||||
|
||||
public ValueTask<SessionRow?> FindAsync(Guid sessionGuid, CancellationToken ct = default) =>
|
||||
_db.ReadAsync((c, token) => SqliteReaders.ReadOneAsync(
|
||||
c,
|
||||
|
||||
Loaded 100 of 167 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user