* feat(input): the arithmetic of controller statistics - classes, batteries, makers, one pad seen twice (D155-D163) Nothing reads a device yet. Domain.Input says whether an XInput state or a DualSense report is a pad in use and what its battery is, adds a battery's readings up, counts switches and decides when two entries are one pad; Application.Input holds one session's slices and turns them into a reading a second; InputSessionBuilder turns a session's readings into its totals, its controllers as JSON and its timeline. TelemetrySample can carry a reading. Every byte and reading under test was written by hand: no report from a real controller has passed through this code. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(input): a session can store what it was played with - schema 0024, the .partial file's chunk 11, both tiers (D160) Nine columns on sessions (the time in front and its four classes, the switches of method, the sources that answered, the controllers as JSON) and three on games (what a store lists of controller support), ADD COLUMN only. The .partial file gains chunk 11, so a session recovered after the Agent died keeps its readings. SessionFinalizer.Build stores them before the tier branch: hooked, unhooked and recovered sessions alike. The input series are sensor_blobs rows named input.*, which the sensors' read now leaves out and FindInputSensorsAsync returns. Nothing produces a reading yet. A ledger this build has opened cannot be opened by 0.1.0-beta.49 or earlier. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(input): the input reader, which the Agent does not start yet - raw input for controllers, XInput, the time of the last input (D155, D158, D159) Application.Input.InputReader takes a slice about ten times a second from Infrastructure.Input.Win32InputBackend, on the thread of InputDeviceHub, which exists only while a session has a view of it. It opens no device, sends nothing to one and registers for no keyboard or mouse. tools/input-readonly-check.ps1 holds its Windows calls to a list. With no controller at hand, what the reader does with one connected is not established. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * fix(input): an arm of XInputPad.Battery's switch said what the default says (Qodana, on #464 after it merged) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(input): no using that makes the file's own qualified names redundant (InspectCode) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(input): what InspectCode reported in the reader's tests - redundant casts, a hub disposed twice, a suppression not needed Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * wip(input): the Agent records what a session was played with - the switch, the terms, the legal texts Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * style(input): import order in the Agent's composition; no redundant qualifier in a test (InspectCode) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * wip(input): what a store lists of controller support, the input libraries, the game page's three rows * wip(input): the game page's details tests expect the three controller rows; the library names test without ToLowerInvariant Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * docs(guide): the settings page listed Controllers and input twice Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * feat(input): a session's summary says what it was played with - the shares, the controllers and their batteries, two charts, marks on the frame-time chart; Trend, Compare and the CSV export (D155-D163) Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(app): the bar's gap is named by the class that has it; one sentence for the frames session's own sensors Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> * test(app): the fixture's constant is named as the format check wants Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
151 KiB
08 — UI
WPF + WPF UI (Wpf.Ui, Fluent). Shell = ui:FluentWindow with custom ui:TitleBar, a thin classic Menu bar (file-level operations), and a left ui:NavigationView (PaneDisplayMode="LeftFluent") as primary navigation (since beta.34, D86, its items use
our copy of WPF UI 4.3.0's LeftFluent item template — FlLeftFluentNavigationViewItemTemplate in Styles/FrameLedger.xaml —
whose only change is that the selected page keeps its label; WPF UI's animates it away, and the owner's screenshot of
Compare showed the icon alone). Light/Dark/System themes via ApplicationThemeManager + SystemThemeWatcher; Mica backdrop on Windows 11 with automatic solid fallback on Windows 10. (beta.35, D91: a Windows contrast theme wins over all three while it is on — §Contrast.) All XAML follows 16_WPFUI_SYNTAX.md — that doc is mandatory reading before writing views.
Shell
┌────────────────────────────────────────────────────┐
│ ⬡ FrameLedger — □ ✕ │ ← ui:TitleBar (Mica, Snap Layouts)
│ File Tools Help │ ← classic Menu row (Fluent-styled)
├───┬────────────────────────────────────────────────┤
│ ▦ │ │
│ 🎮│ │
│ ⇄ │ NavigationView content │
│ ≡ │ (pages via INavigationService) │
│ │ │
│ ⚙ │ [InfoBar area · SnackbarPresenter] │
└───┴────────────────────────────────────────────────┘
status: Agent state shown as a pill in TitleBar trailing content + Dashboard card
A viewer over a copy, beta.15 (owner decision D52).
FrameLedger.exe --data-dir <folder>opens the ledger in<folder>— a COPY of a data folder — and keeps its log and crash dumps beside it. It starts and contacts no Agent: the pipe is one per user, and the Agent behind it records into the profile's ledger, so a request carrying the copy's game ids would act on other games (a consent written for the wrong one is rule 1's failure). Its composition holds no pipe client, no launcher, no update check and no Run-entry writer (Services.MachineFacingServices,ViewerModeTests); the pill reads Viewer — no Agent, a persistent InfoBar names the folder, and every control that would ask the Agent or change the PC is disabled — hooking, the exception's grant and withdrawal, re-enabling, Delete all sessions, the kill switch, the admin mode, the logon task, the Vulkan layer, Start with Windows, the automatic update check, Help ▸ Check for updates, Tools ▸ Update detection rules and the tray's Pause — and, since beta.18, every setting the Agent reads (the user-mode exception option and the three Recording numbers had been missed, and a change said the capture agent would read it) and the update channel beside the update check (ViewerModeTests.EverySettingTheAgentReadsIsOffInAViewer). The profile's own folder is refused however it is spelled (case, separators, a relative path, a junction), as is a folder that does not exist; a refusal is a message box and exit 2. The viewer's folder is its own single-instance key, so it runs beside the profile's App. D6 is unchanged: the Agent's--data-dirstays under--console.
NavigationView items: Dashboard · Games · Compare · Logs · Advanced (since 2026-11-11, D105: last in MenuItems, Visibility bound to Services.AdvancedOption.IsOn — there only while telemetry.advanced is on, §Advanced) — Settings lives in FooterMenuItems. Icons from SymbolIcon (Fluent System Icons; pick from the SymbolRegular enum — see 16 §Icons).
Menu bar
-
File: Add game… · Import library (Steam / GOG / Epic / itch.io / Xbox — since beta.33) · Export ▸ (Session CSV / Session JSON / Chart PNG) · Exit
-
Tools: Agent status… · Update detection rules · Vulkan layer registration… · Open data folder · Database maintenance…
-
Help: User guide (beta.12) · Check for updates · Report a bug… ·
DocumentationOnline documentation · Limitations · Accessibility (beta.35) · About FrameLedger (App / Developer / Third-party licenses tabs— built beta.12 as This app / Third-party licences / Legal documents, below)Help ▸ Accessibility, beta.35 (owner decision D88, 2026-11-09):
ACCESSIBILITY.md— the accessibility statement — as the build embeds it (Services.AccessibilityDocument), in aWindows/DocumentWindowof its own like Limitations, and after Limitations in the user guide's window so the guide's links to it open there. Information, not one of FR-11's documents. What it says and the checks behind it are §Accessibility below.Help ▸ Limitations, beta.10 (D36):
LIMITATIONS.mdas the build embeds it (Services.LimitationsDocument), in aread-only, scrolling WPF UIwindow of its own since beta.12 (MessageBoxwith Open on GitHubWindows/DocumentWindow, rendered — below; corrected 2026-10-04). It is information, not one of FR-11's documents: nothing is accepted or recorded, and the Disclaimer points at it.Help ▸ User guide, beta.12 (D44).
guide/—eightshort English pages for players (install, record a game, read your results, anti-cheat and safety, your data, questions and answers, the terms in plain words; since beta.17, D54, also the screens, every setting, what to do when something goes wrong and the words the App uses — twelve pages, and the wiki's End-user part; fourteen since 0.1.0-beta.50, with Advanced metrics (beta.39) and Controllers and input) — embedded in the App (Services.EmbeddedDocuments.Guide, titles from each page's first heading) and shown in aWindows/DocumentWindowwith a page list, Limitations last; a link between guide pages opens the page in the window. Help ▸ Documentation is Online documentation: the README at this build's source.GuideDocumentsTestsholds every page listed and titled and every link leading somewhere — and since beta.17 every section link (against the anchors the App's renderer gives the target), the contents in the App's order, and that Every setting and The screens name every setting the Settings page shows and every page and menu item of the main window.Documents are rendered, beta.12 (owner request 4, D45). Every Markdown document the App shows — the Legal Gate's three texts, Help ▸ Limitations, the update notes, About's documents — is drawn by
Markdown/MarkdownRenderer(Markdig1.4.01.5.0 since beta.31 — 1.4.2 in beta.30 —, BSD-2-Clause) into a WPFFlowDocumentinsideControls/MarkdownView(a read-onlyFlowDocumentScrollViewer: selectable, Ctrl+C, Ctrl+wheel zoom): headings, emphasis and strikethrough, inline and fenced code in monospace, quotes, nested and numbered lists, pipe tables with a header row, rules, links. HTML is off — a tag is shown as the text it is; no image is fetched — its description stands in; a node the renderer does not know is shown as its own source text, andMarkdownRendererTestsproves for every embedded document that no word of its plain text is lost and no table is left as|---|source. The GPL'sLICENSEis not Markdown: it is shown as written, monospace. Colours and the font are theme resources (16_WPFUI_SYNTAX§FlowDocument). The wheel and the render, beta.21 (owner request 2026-10-13: "scrolling the documents is slow"): a notch moves Windows' lines to scroll at a browser's line (100/3 DIP; three lines = 100 DIP, scaled by the zoom; a delta in proportion, so a touchpad's small deltas move a little; Windows' one screen at a time a screen) and eases there in about 120 ms unless Windows' animations are off — WPF moved a fixed 48 DIP per message, whatever its delta. At its ends the view leaves the wheel to what holds it (the update notes' dialog), and Ctrl+wheel stays the zoom. A page is rendered once (MarkdownView.Show; three bindings changing ask for one render, ahead of layout), and a view keeps the last 16 documents it rendered, so going back to a page costs its layout only (MarkdownViewTests). Links followMarkdown/MarkdownLinks: http, https and mailto throughIUrlOpener;#sectionscrolls to the heading (GitHub's anchors); a relative path resolves against the document's place in the repository and opens in the App when the window holds that page, on GitHub otherwise — at this build's own source (Services/RepositoryLinks: the release's tag, stamped byrelease.yml;mainfor a local build — every link saidblob/mainbefore); any other scheme (file:,javascript:, a drive or UNC path) is not followed, its address shown beside its text. Help ▸ Limitations is a window of its own (Windows/DocumentWindow, one page, Open on GitHub); Help ▸ About isWindows/AboutWindow, three tabs: This app — the version, and the program's Appropriate Legal Notices (GPLv3 §0, §5(d)): the copyright line, no warranty, the licence with the NOTICE terms, this version's source, View the licence / View NOTICE / Open the source code; Third-party licences —legal/THIRD_PARTY_NOTICES.mdand the package index, rendered, and Open the licences folder (the publishedlicenses\; a development build says it has none); Legal documents — EULA, GPL, Disclaimer, Privacy Policy, NOTICE, Trademarks. Asking again brings the open window forward (Services/DocumentWindows). Tests:MarkdownRendererTests,MarkdownLinksTests,DocumentWindowsTests.
The Menu sits in its own row below the TitleBar (never inside the drag region — 16 §Gotchas).
Menu bar as of 2026-09-14 (P4 PR-3). File ▸ Export is the submenu this section specifies — Session CSV / Session JSON write the session last selected on a Sessions tab or opened in a summary window (
Services/SessionSelection,SessionExportServiceover the summary window's own writers; no selection says so in the strip), Chart PNG opens that session's summary window, where the plot is. Help ▸ Documentation opens the README (IssueLink.Documentation;docs/is developer-facing). Help ▸ Report a bug… runsBugReportFlow(10_LOGGING§Bug report flow steps 2–4). Tools ▸ Update detection rules is PR-1's. File ▸ Import library… is PR-4's (ImportLibraryFlow→ the review checklistImportReviewPrompt/Dialogs/ImportReviewContent, aDataGridwith a tick column like Compare's picker — store, game, the executable to add, a note for "already in the library" / "no executable found" / "guessed — check it"; Add selected lands every row hooking off and shows the Games page;05_DETECTION§Platform signatures built note). Help ▸ Check for updates is PR-5's (Update/UpdateService.CheckInteractivelyAsync, the dialogs of11_UPDATER§Flow; a downloaded update is the shell's persistent InfoBar with the one button, disabled while a session runs — FR-12 — and "update available" is a tray balloon only while the window is off screen).Still "later build": Tools ▸ Database maintenance.Tools ▸ Database maintenance… is PR-7's (2026-09-15): aContentDialog(Dialogs/DatabaseMaintenanceContent,ViewModels/DatabaseMaintenanceViewModel) with four cards — Check integrity, Back up…, Sweep raw data…, Compact — and one status line; the sweep confirms in aMessageBoxwith a Danger button (§UX rules) and is sent to the Agent, compaction is refused while a session runs, and a backup is never written onto the ledger itself (06_DATA_MODEL§Retention built note). No menu item says "not built yet" any more:NotYetCommandand its two strings are gone.Built 2026-09-13 (P3 PR-2): the shell, and only the shell.
FluentWindow, the TitleBar with the Agent pill as trailing content, the Menu row (every item that a later slice builds says so in a 4 s snackbar rather than doing nothing), the NavigationView with the four items and Settings in the footer, the offlineInfoBarwith Retry,SnackbarPresenterandContentDialogHost. The Dashboard shows the Agent status card (HelloAck/StatusAck, every valueN/Auntil answered); Games, Compare and Logs are empty states; Settings has Appearance (theme + language, both persisted insettings— D16'sui.theme/ui.language). The App startsFrameLedger.Agent.exe --servebeside itself when the pipe is absent (07_IPC§Client behavior, 8 × 250 ms) and shows Missing when there is no Agent to start. (Since 2026-09-17: and only when no Agent already holds the data folder —07_IPC§Client behavior.) Measured on the dev box: first window at 1.3 s from process start (NFR-4's 2 s).The tray is PR-8's.Tray built 2026-09-14 (P3 PR-8b).Services/TrayHostoverTrayViewModel(no WPF in the view model,TrayViewModelTests): the four icons are drawn at start (TrayIcons, a PNG inside an in-memory.ico, because H.NotifyIcon 2.4.1 converts only file-backed image sources) and follow the pipe's session events — ● when any running session is Tier 1, ◐ when sessions run and none is measured, ⏸ when the Agent reports paused, the ring otherwise; the tooltip names the game. Menu: Open, Pause/Resume capture (onePauseCapture/ResumeCapturerequest; the state shown is thePauseAck's, never assumed), Agent status (the Dashboard), Exit (a real exit throughShellHost.Quit, whatever minimize-to-tray says); a left click opens the window. Minimize to tray on close hides the live window whenui.minimize_to_trayis on and a tray icon exists (WindowClosePolicy); a language rebuild's old window is unaffected. FR-3.8's balloon — "Session saved — — click to view" — is raised only while the window is off screen; on screen,the Dashboard'sthe App's snackbar carries the same event (one event, exactly one channel), and its click opens the summary window. (Corrected 2026-10-14, beta.23: the snackbar's notice was raised by the Dashboard's view model, and it reached the other pages only because no Dashboard ever went away — each visit made one, the root container kept every one, each subscribed, so twenty visits were twenty notices for one session. It isServices.SessionNoticesnow, one subscription for the App's life; the Dashboard listens only while it is on screen.) A safety event is never a balloon (TrayViewModelTestsasserts it). Tools ▸ Agent status… and Tools ▸ Vulkan layer registration… now navigate (Dashboard, Settings) instead of saying "not yet".
Tray (H.NotifyIcon): icon states idle / ● capturing (T1 hooked) / ◐ recording only (T2 — nothing measured) / ⏸ paused; menu: Open, Pause/Resume capture, Agent status, Exit. Closing the window minimizes to tray when enabled.
Notifications policy
- In-app, transient (rules updated, export done, non-fatal capture warning):
ISnackbarServicesnackbar, 4 s — shown only throughIMessageStrip(Services/SnackbarStrip) since beta.35, which says it to a screen reader as it shows it (D89;AnnouncementsTests.OnlyTheStripShowsASnackbarAndNoXamlSetsALiveSetting). - Every one of these is said to a screen reader as it appears (beta.35, owner decision D89) — §Accessibility, Screen readers.
- In-app, persistent (Agent offline,
PawnIO missing,update downloaded, a viewer's folder, the safety notices, an alpha build — since 2026-10-31, D74):ui:InfoBarbanner pinned above content with action button. (Corrected 2026-10-07: no PawnIO banner was ever built — CPU temperature reads N/A, and Settings ▸ System says it needs the admin mode and PawnIO; the viewer's banner (D52) and the safety notices were missing from the list.) - System-level, app possibly minimized (session saved with "View" action, capture error while in tray, update available): tray balloon/toast via H.NotifyIcon.
- One event → exactly one channel; never duplicate the same event across snackbar and tray.
Exception — safety events are never toasts. CaptureRefused, SafetyUnhook, and hook auto-disable get a dedicated dialog or persistent ui:InfoBar with the specific signal named in plain language ("Easy Anti-Cheat was detected in this game — FrameLedger will not inject into it"), a link to the safety documentation, and a one-click "capture without injection instead" action. These must never be dismissible-by-timeout: the user needs to understand why their data changed fidelity, or why capture stopped mid-session.
The "capture without injection instead" action is Tier 2, which needs an elevated Agent — rewritten 2026-08-28, and the button's whole meaning changed. There is no no-injection measurement, so this action cannot be offered as an alternative way to measure. What it may offer is recording the session anyway: duration, hardware telemetry and the reason nothing was measured. It needs no elevation. Label it for what it does — "record this session without measuring it" — because a button that says "capture without injection" beside a refusal reads as a second measurement path, and the previous wording was corrected once already for exactly that.
Built 2026-09-14 (P3 PR-8a).
Services/SafetyNoticessubscribes to the pipe's events and turnsCaptureRefused,SafetyUnhookandCaptureDegradedintoSafetyNotices the shell renders as anItemsControlofui:InfoBars inMainWindowrow 2, under the Agent banner and above every page — Error for a refusal and an unhook, Warning for a degrade,IsClosable="False", no timeout. The text is theSafety_*family (Safety_Refused_Named_Formatwith the family and the signal,_Unnamed,_CouldNotVerify,Safety_Unhooked_Format) followed on a refusal byNotice_Refused_Recording("the session is still recorded — duration and hardware telemetry — with every frame-derived value at N/A"). The one button isSafety_RecordWithoutMeasuringon 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. (That sentence became true on 2026-09-22: until then every refused session was discarded under the minimum length, and for one dayTargetUnreadableomitted 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.Tier2Reasonovercapture_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).On this PC, not in this game — beta.13 (§S23-3). A driver or a service is found machine-wide: while Easy Anti-Cheat's service runs for another title, every game refuses with
BlockedService, and the notice said the family "was detected in this game". The events carry the guard's own reason (guardReason,07_IPC), and aBlockedService/BlockedDriverrefusal readsSafety_Refused_MachineWide_Format("… is running on this PC (…): a driver or service, which may belong to another game or program …"), an unhookSafety_Unhooked_MachineWide_Format, and the summary's Tier-2 reasonSummary_Tier2_Why_MachineWide_Format; a module, a title list or a file in the game still reads "in this game".Safety_Unhooked_Formatlost "will not inject into this game again until you enable it again", untrue both ways since 2026-09-22 (a machine-wide finding turns no hooking off; a finding about the game turns it off for good, whichSafety_HookingTurnedOffthen says). Without aguardReason— an older Agent — the notice reads as before. Tests:SafetyNoticesTests.AServiceOrDriverIsOnThisPcAndAModuleIsInThisGame,…AnUnhookSaysWhereTheFindingWasAndPromisesNoReEnable,Tier2ReasonTests.Every notice in words — beta.18 (found while writing the guide, beta.17). Three texts printed what only the code knows. The gate's own refusals — Disable all hooking, a game blocked before — carry the gate's label where a finding carries its family, and the kill switch's notice read "kill switch was detected in this game (the global 'disable all hooking' switch is on (FR-2.4); …). FrameLedger will not inject into it, and nothing overrides that." They are said as the session's end now (
Formats.EndReasonText: "All hooking is switched off in Settings, so nothing was measured."), never as a finding. A refusal no family names read "The anti-cheat guard did not hook this game: reason RefusedByGuard.": the events carry the guard's own reason for every refusal since (07_IPC), and the sentence is its words — "… the game is 32-bit, and the hook runs in 64-bit games only."; an older Agent's readsEnd_RefusedByGuard. A 30 s re-scan that could not look while the game still ran read "Capture stopped: Access is denied. was detected while the game was running"; it readsSafety_Unhooked_Unnamed_Format("Capture stopped while the game was running — the game's process could not be opened — and FrameLedger unhooked."). AndCaptureDegradedprinted its reason raw and said the session went on — "The hook stopped (WriterSelfDisabled); the session continues without measuring." — where a stop ends it: the notice is the end's own sentence ("The measuring hook turned itself off after repeated faults, so measuring stopped."), andNotice_Degraded_Unknown_Formatnames only a reason this build has no words for. Tests:NoticesFromTheAgentTestsbuilds each event as the Agent does — the gate's verdicts, the native facade's (AntiCheatVerdict.FromNative),RecordedSessionEvents.PublishReason, the wire's codec — walks every refusal and every stop, and refuses an enum's name, a requirement's id or "reason X" in any notice; it went red on the unfixed code with exactly the texts above. Until then the notices' tests raised events written by hand ("GuardBlocked", "HookFaulted", a guard reason sent as the end), which no Agent sends.Corrected 2026-09-14, after the owner saw a red bar with no way out. WPF UI 4.3.0's
InfoBartemplate has noContentPresenter, so the action button above — placed as the InfoBar's Content, the only dismissal onceIsClosable="False"removed the X — was never rendered. The view model was right and the screen was wrong.Styles/FrameLedger.xamlnow carries the upstream template verbatim plus the presenter (16_WPFUI_SYNTAX§Gotchas), the same fix reaching the Agent-offline banner's Retry and the game page's Re-enable. Guarded byPagesLoadTests.TheInfoBarTemplateRendersItsContent, which renders both templates and fails when upstream gains a presenter — the signal to delete the copy.
The pre-scan's notice (2026-09-25, beta.8). The Agent's pre-scan of the library (
19_SAFETY§What a finding does to the game) sendsHookingTurnedOffwhen it turned off hooking the user had turned on;SafetyNoticesmakes it aSafetyNoticeof kindHookingOff— Error, persistent like the others, titled "{game}: hooking turned off" (Notice_HookingOff_Title_Format), the refusal sentence naming the family and the signal followed bySafety_HookingTurnedOff. It has noNotice_Refused_Recordingand its button is Dismiss, notSafety_RecordWithoutMeasuring: no session is running, so there is nothing to record without measuring. A finding on a game whose hooking was already off raises no notice; its card and its page say it (§Games).
FPS display rule (global, FR-4.2 / CLAUDE.md rule 6)
Reusable control FpsReadout (custom control styled with WPF UI theme brushes):
FG not detected →— "not detected" was two states, and they need two looks (2026-09-03,144 FPS03_METRICS§Rung 0's qualifier):- FG measured
none(a hook ran and saw no frame generation — no producer exists yet) →144 FPS, nothing else. - FG not measured (
fg_mode = N/A, every title today) →144 FPSas Presented FPS, with a mandatory qualifier chip from the runtime census: muted "FG not observed" when no frame-generation runtime was loaded in the process (tooltip: "no frame-generation runtime was loaded; this number cannot include in-process generated frames — statically linked FSR3-FG and driver-level AFMF excepted"), or a ⚠ warning chip "FG runtime loaded — may include generated frames" naming the module when one was. Never the word "Native", never a factor, never—.
- FG measured
- FG detected →
62 → 118 FPS (×1.9 FG)— Native first and visually primary (FontTypography="Subtitle"), Displayed second, factor as a small accent chip. Tooltip: "Native: frames rendered by the game · Displayed: frames shown on screen incl. generated frames". - A steady-state factor carries its share (2026-09-17). When
fg_factor_scope = steadythe readout is the generated shape —58 → 116 FPSwith the chip×2.0 FG · 75%— and the share is never omitted: the number describes the state the session spent most of its generating time in, not the session. Tooltip: why there is no session-wide factor (menus, loading, a settings change), what the number covers, and the refusal's own numbers. The "factor not counted" chip below remains for a session with no state long enough (03_METRICS§The steady state). - FG identified, count refused (2026-09-14 — a fourth shape,
FpsReadoutKind.IdentifiedUncounted).fg_modenames a technology andfg_factoris NULL: the owner's Black Myth: Wukong and Onimusha rows, where the tags named DLSS-G and the token count did not resolve. Until this date the readout fell into the "detected" shape and printedN/A → N/A FPS (×0.0 FG)— a factor nobody counted — while the game page saidDLSS-Gand the grid said N/A. Now:304 FPSas Presented FPS with a ⚠ warning chip "DLSS-G active — factor not counted", tooltip = the row'sfg_refusalin plain words ("no application-frame token was counted", "the frame-generation state changed mid-session", …) plus "read it as Displayed, not Native" — and since 2026-09-16 the refusal's numbers fromfg_refusal_detail("Bucket 3 of 8 measured 2.25 against 3.65 for the whole session, over 53 samples.", "2 swapchains presented during the session."), because the owner's four DLSS-G rows all read the same sentence and the sentence could not say why; the game page's measured row readsDLSS-G · factor not counted; Displayed and FG× sayN/A(no factor exists, and it is not a measured none). Never the word "Native", never a factor. Thefg_runtime_loadedchip also names the module now (FG runtime loaded (sl.dlss_g.dll) — may include generated frames) fromfg_runtime_census, as this rule always asked.FpsPresentation.FrameGenerationLabelis the one place the page and the live card build the label. - Tables get three columns (Native / Displayed / FG×); Displayed and FG× render
—whenfg_mode = noneandN/Awhen it is not measured — the two are different negatives and the table must not collapse them. The Native column carries the Presented figure with its qualifier when FG is not measured. - Charts: Native series default; "Displayed" toggle appears only when displayed data exists (FR-5.4).
Tri-state feature chips (RT / PT / RR)
TriStateChip custom control (WPF UI has no Chip primitive — build on Border + theme brushes, 16 §Custom controls): Yes = filled (accent) · No = outlined · N/A = dashed outline, muted foreground. Suffix icon shows source: 🔍 detected · ✎ manual · ↧ inherited. Click → (corrected 2026-10-04: the source is the chip's tooltip, and a click opens FR-8.3's dialog, ui:Flyout to overrideTriStateOverridePrompt — no flyout exists) (session-level) with "set as default for this game" checkbox (FR-8.3). Chips appear on session rows, session summary header, and game header.
Screens
All screens are Pages registered with the navigation page provider and navigated via INavigationService (16 §Navigation). ViewModels via CommunityToolkit.Mvvm, injected through DI (INavigableView<TViewModel> pattern).
Dashboard
- Agent status
ui:CardControl(state, capability badges asInfoBadge: telemetry source, Vulkan layer,ETW fallback, PawnIO/CPU-temp, elevation — Repair button on error). - Live capture cards (one per running session since beta.28, two to a row): game name, tier badge, elapsed, live
FpsReadout(5 s rolling), measuredrenderW×H → outputW×Hwith upscaler + quality, RT-active dot, CPU/GPU temp,per-process VRAMthe game's own VRAM and RAM (beta.12: read from outside the game, so a held session has them too), sparkline (last 120 s) fed bySessionProgress. Tier 1 shows measured settings — this is the payoff of hooking and should read as facts, not guesses. - Recent sessions list (last 10 across games) → click opens session summary.
- Totals strip: games tracked, total playtime, sessions this week (
ui:Cardrow).
Built 2026-09-14 (P3 PR-5): the Agent card, the live card, the recent list, the totals. The live card is
LiveCaptureViewModelover the pipe'sSessionStarted/SessionProgress/SessionCompleted(marshalled through the capturedSynchronizationContext): game, tier badge, elapsed, theFpsReadoutat 1 Hz under the display rule (Presented FPS with its census chip until frame generation is measured), the measuredrenderW×H → outputW×Hwith upscaler + quality, the RT chip, GPU/CPU temperature,per-process VRAM(corrected 2026-10-03: that line read the Overlay's per-present VRAM, which nothing produced, so it was always empty; since beta.12 it is "This game: VRAM … · RAM …" from the newest telemetry tick,GameMemoryText.Live).The sparkline is PR-6's.Recent =ISessionRepository.ListRecentAsync(10)with game names; a completed session reloads the lists (the row is in SQLite,07_IPC§Client behavior). Totals = the library's games,SummariseByGameAsyncplaytime,CountSinceAsync(now − 7 d).Capability badges and the Repair button are PR-8's with the Agent section.(Corrected 2026-10-04: PR-6 and PR-8 shipped without them. No sparkline exists, here or on the Games cards; the Agent card shows its facts as text, and the Vulkan layer state and the logon task's Repair are on Settings.)Amended 2026-09-23: the card shows every running session, measured or not. A session held unhooked (Tier 2 — hooking off, refused, unreadable) shows its name, the T2 badge, the elapsed time and the machine's temperatures from
SessionHeld, the line "Recording duration and sensors only — nothing is measured." and why, in the sentence its summary will carry (Formats.Tier2HoldReasonover the start'shold, the same wordsTier2Reasonreads fromcapture_notes) — and noFpsReadoutat all. A session the status lists at tier 2 with noholdhas not attached yet: its name and badge until the attach's start arrives, never the held line and never the "Attached — waiting" one. A hooked session takes the card from a held one, never the reverse. The card is seeded from the App-lifetimeLiveSessionswhen the Dashboard is built, so a session that started while another page was open is on it at once; the completion notice names the session that completed (SessionCompleted.gameName) and afaultedcompletion is no notice (the strip'sCaptureErroralready said it). Until this date the Agent announced only hooked sessions: every other game read "Nothing is being captured." while it ran.beta.28: one card per running session (the owner, 2026-10-20: "Thêm cơ chế hiển thị UI/UX Dashboard khi chạy >=2 game trong cùng 1 thời điểm"). The Agent records one session per executable, so two games run as two sessions, and until beta.28 the second showed only as Running sessions: 2 — the one card went to a hooked session and stayed with it.
DashboardViewModel.LiveCardskeeps aLiveCaptureViewModelper session, each fed only its own session's events (a card is made by its session's first event or seed and is one session's for life); hooked sessions come first, each kind in the order it started, and a card that changes place is moved, never rebuilt. The header counts the games from two on (2 games recording,Dashboard_Live_Count_Format) and the cards stand two to a row (LiveColumns); with none running, one card says Nothing is being captured. Each card is the card it was — name, tier badge, elapsed, the readout or why nothing is measured, the measured settings, the temperatures (the machine's, so alike on every card) and the game's own memory. Tests:DashboardViewModelTests(two games, a third, each ending),LiveCaptureViewModelTests, and the page inPagesLoadTests' surfaces with a hooked and a held session, in both themes and through a switch.
Games (grid → detail)
GridView-style panel of cover cards (ui:CardAction): name, platform badge, engine badge, total playtime, last played, mini trend sparkline (avg Native FPS last 10 sessions). Sort/filter/ui:AutoSuggestBoxsearch.
The filters, beta.34 (owner request 2026-11-06, D85) — specified here since P3 and never built: a row under the search and sort with Store, Engine (the stores and engines the library holds, each list naming its "everything" first; Added by hand for an entry with no store, Engine not identified for one with none), State (the card's one state, as its pill says it), Installed and Played, and Clear filters. While a filter or the search narrows the list the title counts what is shown of all (Games · 12 of 65). Kept while the App runs — the page is the window's (
WindowPageCache) — and not saved. Tests:GamesViewModelTests.TheFiltersNarrowTheLibraryAndTheHeaderCountsWhatIsShown. The library, beta.11 (owner requests 2026-10-03). The empty band on the right: the cards were 300 px in a plainWrapPanel, so at ~1350 px three fitted and a card's width was left unused; the grid is nowControls.UniformWrapPanel— as many columns as fit at 300 px or wider, every card an equal share of the width, each row as tall as its tallest card — and the pill row wraps instead of cutting its last pill. Grid or list (owner's choice: switch between the two): the button beside the sort shows the other view; the list is one row per game (name, store, engine, status, sessions, played, last played; double-click or Enter opens it), and the choice isui.library_view. The count is in the title (Games · 42). Refresh reads the library again, then asks the stores for games installed since (ImportLibraryFlow.RunAsync(onlyNew: true): No new games and no checklist when there are none), and every entry whose executable is not on disk carries a Not installed pill — its tooltip is the game page's own sentence for it, the drive that is not connected or the path the file is gone from (GameLibrary.ExecutableExistsandFormats.ExecutableMissingText, asked off the UI thread on every listing, never stored;nothing is removed for itsince beta.19 (D55) the Agent removes such an entry by itself after ten minutes when it has no session and no anti-cheat block or exception, and its drive is connected — Settings ▸ Data ▸ Remove uninstalled games, on by default; the page on screen hearsGameRemoved, reloads and says so in the snackbar (Games_Removed_Format); one with sessions keeps its pill. One check removes its games in one event each, milliseconds apart: the page waitsGamesViewModel.RemovalSettle(one second) after the first, then reads the library once and says them all in one notice — the count, five names and how many more,Games_Removed_Many_Format. It said each and reloaded each, and WPF UI 4.3.0'sSnackbarServiceshows every message at once in its one snackbar, so only the last name stayed on screen. And only the newest read of the library is shown: reads overlap — a session that ends, an import, a removal — and the one that started first could finish last, its executable checks waiting on a slow drive, and put back a removed game's card (GamesViewModel.LoadAsync,GamesViewModelTests.AnOlderReadThatFinishesLastIsNotShownOverANewerOne)). (beta.34, owner request 2026-11-06 — "switching to Games stalls 0.5–1.5 s",spike-notes§27: the window keeps the page it built and shows it again on every later visit, reading the library again behind it; the library is read on the thread pool; the cards appear before any executable is checked — 39 of the owner's 41 Steam games are on a USB drive that sleeps — and each card gets its Not installed pill when its check answers; a read keeps every card that would look the same; the list view is bounded (MaxHeight640) so it builds the rows on screen.GamesViewModelTests.TheCardsComeBeforeTheExecutableChecksAndThePillAfter,.APageShownAgainReadsTheLibraryAndKeepsTheCardsThatLookTheSame,WindowPageCacheTests.) The page reloads by itself while it is on screen when a session ends (SessionCompleted) or an import adds games (LibraryChanges— navigating to the page already on screen does nothing in WPF UI 4.3.0, so an import from the menu never showed until the page was left). Import (FR-1.2): the games already in the library — at this path or under another drive letter — are hidden by default (Show the N games already in the library brings them back, dimmed), and a row that cannot be imported has its box disabled; the XAML comment said "cannot be ticked" while a tick was taken and ignored. Tests:GamesViewModelTests,ImportLibraryFlowTests.RefreshOffersOnlyNewGamesAndSaysWhenThereAreNone,…GamesAlreadyInTheLibraryAreHiddenUntilAskedFor,PagesLoadTests.TheLibraryGridFillsItsWidthAndTheListViewReplacesIt,…TheImportChecklistRendersWithTheExistingRowsShown.
- Game detail:
- Header: cover (built in beta.23, the note below), name, publisher, version, platform, engine+version, API + Present Mode of last session,
FpsReadout(lifetime avg), TriState chips, Edit button. - Two clearly separated rows (
05_DETECTION§Capability hints — conflating these was the old design's core mistake):- Supports — greyed capability chips from files on disk ("Supports DLSS-G", "Supports XeSS"). Static inference. With none: not scanned yet until the Agent's sweep has read the executable, then none found (beta.21 — it read "not scanned yet" for every game that ships none of the files).
- Last session measured — accent chips with real values ("DLSS Quality · 1440p → 2160p", "Frame Generation DLSS-G ×1.9", "Ray Tracing: Yes"). Measured.
- Hooking control (
ui:CardControlwithToggleSwitch): off by default. Turning it on opens the consent dialog (FR-2.1). When the static anti-cheat pre-scan blocked it, the switch is disabled with the reason shown inline and no way to force it. When auto-disabled after crashes, anInfoBarexplains and offers manual re-enable.
- Header: cover (built in beta.23, the note below), name, publisher, version, platform, engine+version, API + Present Mode of last session,
What opening the page and choosing a session cost, beta.23 (owner request 2026-10-14;
spike-notes§21). The Sessions grid is bounded (MaxHeight520, as Compare's list is): inside the page's own scroller it was measured with no height limit and built every row — 100 sessions were 100 rows of 17 columns, 1.2–1.5 s to open the page; it builds the rows on screen now, scrolls itself, and hands the wheel to the page at its ends (PagesLoadTests.TheSessionsGridBuildsTheRowsOnScreenAndHandsTheWheelOnAtItsEnd). A session's series is read and decoded on the thread pool — Microsoft.Data.Sqlite completes its asynchronous calls synchronously, so the decode of a two-million-frame session ran on the UI thread whateverConfigureAwaitsaid — and what the charts derive from the whole session (one sort of its frames where the Distribution tab did three, the histogram, the percentile curve, the presents line) is worked out there once (Charts.SeriesDigest): choosing such a session froze the window 0.8–1.0 s, 17 ms now. Whether the executable is on disk is asked off the UI thread, as the library page has asked since beta.19.
The header's cover, built in beta.23 (owner decisions D60/D61, request 2026-10-14) — never before: the line above said "cover" from the first draft and nothing drew one. The image the user chose (Edit… ▸ Choose image…, a PNG copy ≤ 1200 px in the data folder's
covers\game-<id>-<unix ms>.png,games.cover_pathrelative to the data folder; Use the store's image drops it), else what the app of the store that installed the game keeps on this PC — Steam'sappcache\librarycache\<appid>\(its files flat or in hash-named folders:library_600x900.jpg/library_capsule.jpg,library_hero.jpg,header.jpg/library_header.jpg) and GOG GALAXY'swebcache\<user>\gog\<productId>\(*_glx_vertical_cover.webp,*_glx_bg_top_padding_*.webp). Which store installed the game is asked of the stores' own records, as Play asks (StoreRecords.Owning, D59) — Steam's and GOG's only, cached two minutes; nothing is downloaded (privacy.online_metadatastays reserved). The page: a band (ArtBand, rounded) holding the banner (ui:Image, as tall as its proportions make it, ≤ 240, fading into the band through an alpha mask set in code) above the usual header with the cover beside the name (120×180, or 230×107 for a landscape header); a game with no artwork shows no band. No text is drawn on a picture. The band's colour (Controls.ArtTint, D61): the cover's — else the banner's — dominant colour (Services.ColorMath: a hue histogram of a 48-px copy, vivid pixels weighted, a grey picture none) over the card's fill at the strongest opacity — ≤ 30 % on a dark theme, ≤ 22 % on a light one — at which primary and secondary text keep 4.5:1, tertiary 3:1, and the pills' and the warning's text 4.5:1 on their fills; recomputed through a resource reference when the theme changes; untinted with the option off, a grey picture or high contrast. Everything is read and decoded on the thread pool (Services.GameArt; the twelve newest images kept); the text shows first and the picture when ready. A chosen image's path is followed only when it is one of these names in the data folder'scovers, and never through a junction or a symbolic link — a viewer's copy (D52) could name a share, or hold a link to one. Settings ▸ Games: Show game artwork (ui.game_art) and Colour the game page from its artwork (ui.game_art_tint), both on. Tests:GameArtTests,CoverStoreTests,ColorMathTests(the hardest colours in both themes against the tests' own WCAG),EditGameViewModelTests,PagesLoadTests.EveryTextIsReadableInBothThemes(the surfaces' game page has artwork),…TheArtworkBandFollowsAThemeSwitchand…TheGamePagesArtworkIsDrawnwithAccessibilityTests.NoStyleOfAWpfUiControlLeavesOutItsTemplate(the cover once took its place and drew nothing, aui:Imagestyle not based on WPF UI's; caught in a render before it shipped). The library's cards still have no image.beta.33 (D79): an Xbox game's own pictures. A game the Xbox app or the Microsoft Store installed ships its pictures in its package folder, and
MicrosoftGame.confignames them: theSquare480x480Logo(elseSquare150x150Logo) is the cover, drawn square (150×150,ArtCoverIsSquare) so a logo is never cropped to a portrait, and theSplashScreenImage(1920×1080 on the owner's titles) is the banner. The square logo comes before a landscape header. Read from inside the package root only; the tooltip says Artwork from the game's own files (Xbox app) (Art_Source_Xbox).GameArtTests.AnXboxGamesSquareLogoIsItsCoverDrawnSquareAndItsSplashTheBanner.
Built 2026-09-14 (P3 PR-5): the grid, the detail page's header, the two rows, the hooking control and the Sessions tab. Grid:
ui:CardActioncards with platform / engine / hooking badges, sessions, playtime, last played (the sparkline is PR-6'sno sparkline was built — corrected 2026-10-04); search and sort in memory; FR-1.1 by File ▸ Add game…, the page's button, or an.exedropped on the page (a.lnkneeds the shell-link reader, later); FR-1.4 throughWpf.Ui.Controls.MessageBoxwith Keep sessions / Delete sessions too, revoking consent over the pipe FIRST when it was on. Detail: header (name, publisher · version · store · engine, last session's date and API, the last hooked session'sFpsReadout, the three chips resolved with the annotation and the game default —Application.TriState.TriStateResolution), Edit… (FR-1.3, aContentDialogbadging detected 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; since beta.19 the file dialog opens in the game's own folder —GameFolder.StartFolder: the store boundary's install folder (InstallRoot), an Unreal package's root above<Project>\Binaries\Win64, else the executable's folder, and the nearest folder still there when that one is gone; nothing for a drive that is not connected, where Windows opens its last folder; owner request 2026-10-12,GameFolderTests), 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 inProgram.Mainafter Velopack's hooks and before any window; a later start sets the event and exits 0, and the first instance brings its window forward throughShellHost.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.--diagnever claims),the guard-bypass switch since 2026-09-21withdrawn 2026-09-22 (the card, its dialog, the session mark and the export line are gone; a blocked row's toggle is disabled andSafety_Blocked_Toggle_Formatis the whole story; a refusal or unhook notice that turned hooking off ends withSafety_HookingTurnedOff—19_SAFETY§What a finding does to the game), Supports (fromcapability_flags;empty until P4's scan writes it, and the card says sowritten by the Agent's detection sweep since P4 PR-1, 2026-09-14 — the rule ids as product names viaCapabilityNames, "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 isOneWayfrom the row and its command runsHookingConsent(since beta.30 the command raises the switch's property whatever happened, so the switch reads the row again: a click flips it throughSetCurrentValue, and a command that changed nothing — declined, refused, no Agent — used to leave it showing on beside off, the owner's report of 2026-10-26); a refusal, a mismatch or a failure is a persistentInfoBaron the page (never a toast); a blocked row disables the switch withSafety_Blocked_Toggle_Formatinline; an unverified pre-scan leaves it enabled and says so; auto-disabled showsSafety_AutoDisabled_Formatwith the re-enable button. Sessions tab: theDataGridof FR-6.1 — every Tier-2 cell that is Tier-1-only readsN/A, a measured-none Displayed / FG× reads—, both with tooltips. Frametime / Distribution / Trend / Sensors / Latency say which build brings them (PR-6, PR-7).PagesLoadTestsloads every page and both control templates under the real theme dictionaries on an STA thread, so a binding typo is red in CI rather than aXamlParseExceptionat first navigation.The recording switch (2026-09-23, FR-1.6). A
ui:CardControlRecording above the hooking control, itsToggleSwitchOneWayfromgames.record_sessionsand its command writing the row throughGameLibrary.SetRecordingAsync(and, since beta.30, raising the switch's property after it, as the hooking switch's does) — no dialog (it deletes nothing; sessions already recorded stay) and nothing over the pipe (the Agent reads the table each tick). Status line Recorded when it runs / Ignored — nothing is recorded; the body says what off means (the program is not watched; a running session stops) and when to use it (a utility that starts with Windows). The library card shows Not recorded in place of the hooking badge, since an ignored program is never hooked whatever its hooking switch says. The hooking control stays independent: a user can keep a consent on an entry they stopped recording for a while.Anti-cheat games (2026-09-25, beta.8, owner decision). The Agent pre-scans every library entry now, so the App knows which games ship anti-cheat before anyone asks to hook them (
19_SAFETY§What a finding does to the game). The library card says Anti-cheat in place of Hooking off — the caution fill with primary text, the warning qualifier's pair thatContrastTestsmeasures in both themes — for an entry that is recorded (Not recorded still comes first). On the game's page the Hooking card is a switch that could only be refused, so whileui.hide_anticheat_hookingis on — its default, Settings ▸ Capture Hide hooking on anti-cheat games — the card and its lines give way to one Anti-cheat card: "Found: {what}. Hooking is off for this game and cannot be turned on; its sessions record play time and sensors only." Off, the card is back with the switch disabled andSafety_Blocked_Toggle_Formatunder it.{what}isServices.BlockedReasonTextover the storedReason|Family|Signal— "BattlEye — its module BEClient_x64.dll was loaded in the game", "Easy Anti-Cheat — its folder EasyAntiCheat ships with the game", "… is a listed title", "the game's store id … is listed" — and a row stored before that form is shown as it was. The crash auto-disable's re-enable bar is not offered on a blocked row: its one action could only be refused. Tests:GameDetailViewModelTests(hidden, shown, the card pill),BlockedReasonTextTests,PagesLoadTests.AnAntiCheatGamesPageRendersTheFindingInPlaceOfTheHookingCard.D38 (2026-10-03, beta.11): the trial. Not eligible: N successful hooked session(s), two are needed is gone — a grant needs no session. The card reads Exception in force since … — trial: N of 2 good sessions so far until the trial is over, Not eligible: an exception of this game ended during its trial on …, so none can be made again after a failed one, and Not eligible now: {family} was not found in the game's folder when it was checked where the tolerant scan found nothing of the family (it used to say the check "could not finish"). The Anti-cheat card of an eligible game says hooking is off unless you make a user-mode exception for it (below) — "cannot be turned on" beside a usable Make exception… contradicted itself. The disclosure (
ac-exception-dialog/2) names no session count and has a Trial paragraph. Tests:GameDetailViewModelTests.WhyAGameIsNotEligibleIsSaidOnItsPage,SettingsViewModelTests.TheExceptionOptionIsOffByDefaultAndItsListFollowsTheAgentsColumns,AntiCheatExceptionsTests.The user-mode exception (2026-09-26, beta.9, owner decision D33). While Settings' option is on, a blocked game's page shows a User-mode exception card with the Agent's answer about it (
Services.ExceptionViewoverGameRow.AcException— the App reads those columns and writes none): Eligible — no exception made with Make exception…; Checking… until the Agent has looked at this block; Not eligible: N successful hooked session(s), two are needed; Not eligible: the guard also found {family} ({signal}) — Aniimo's Kernel driver in the game folder (NEPKernel.sys); Not eligible: {family} is not user-mode throughout; and how the last exception ended. Make exception… opens the exception's disclosure (AntiCheatExceptionPrompt, textSafety_Exception_*versioned byAntiCheatExceptionDisclosure.Version, the primary button bound to the ticked I accept the risk of a ban for this game, Enter = Keep it blocked) and thenSetAntiCheatException; the Agent gathers the facts and grants or refuses, and the page says which. An exception in force brings the Hooking card back — even while anti-cheat cards are hidden — with its switch usable through FR-2.1's dialog as ever, the finding still under it; Withdraw exception ends it and turns hooking off. With the option off a kept exception is shown suspended and the switch is disabled again. The library card says Exception for a game carrying one; a hooked session under it is Hooked · exception in the Sessions tab (the tooltip names the family) and its summary has one line saying so. Tests:GameDetailViewModelTests.AnEligibleGameOffersTheExceptionAndOneInForceMakesTheSwitchUsable,…WhyAGameIsNotEligibleIsSaidOnItsPage,AntiCheatExceptionsTests.Details (2026-09-25, beta.8, schema 0011). A
ui:CardExpanderDetails under the two rows, expanded, says what the game's files and its store say (05_DETECTION§What the files say about themselves): Runs as (64-bit (x64) · 32-bit (x86) · ARM64 · .NET, any CPU (runs as 64-bit) · …), File version and Product version (the executable's PE resource — for an Unreal title often the engine's), Store ("Steam build 20374416", "GOG version 1.2.3", since beta.33 "Xbox version 1.3.5124.0" — or Version when the user typed it), Engine, and Ships with, one line per capability file: "DLSS: nvngx_dlss.dll 3.7.10.0", "XeSS: libxess.dll (no version)". A row the Agent has not read yet says so. The subtitle labels the store's version the same way and then drops the bare store name it would repeat. An executable that cannot run as x64 (x86, 32-bit-preferring .NET, ARM) disables the hooking switch withHooking_NotX64_Formatunder it and no re-enable bar — turning it on could only be refused (the Agent refusesExecutableNotX64anyway); a switch already on can still be turned off. Tests:GameDetailViewModelTests.TheDetailsCardSaysWhatTheFilesSayAndAnX86SwitchCannotBeTurnedOn,FormatsTests, and the page renders inPagesLoadTests. The Details card's NVIDIA App override row (same day) is the newest session that read a driver profile, in the same words; no row where none did. Tests:NvidiaOverridesTests,GameDetailViewModelTests.TheDetailsCardNamesTheNvidiaAppsOverridesFromTheNewestSessionThatReadThem. The Engine row carries the version, and an Engine version row says what it was read from (beta.10 for Unreal; beta.19 for Unity, Godot and RPG Maker; beta.20 for Ren'Py —05_DETECTION§Engine version): the player library, the data file's header, a data pack, a core script, the RGSS libraryGame.ininames or Ren'Py'srenpy/vc_version.py, and Not found in the game's files once the Agent has read such a title and found none. RPG Maker's witness names the maker on the page, the subtitle and the library card (RPG Maker MZ 1.10.0, RPG Maker VX Ace (RGSS 3.0.1);Formats.Engine(id, source)). Tests:GameDetailViewModelTests.TheDetailsCardSaysWhatAUnityGodotOrRpgMakerVersionWasReadFrom,FormatsTests.TheVersionsWitnessNamesTheMakerAndRgssSaysWhoseNumberItIs.
- Tabs (WPF
TabControl, Fluent-styled):- Sessions —
DataGrid: date, duration, tier badge (T1/T2), Native, Displayed, FG×, 1% Low, 0.1% Low, resolution + upscaler, max GPU temp, API, chips, ⚠ crash badge, tags. Row → Session summary.Multi-select → "Compare".(not built; Compare's own picker chooses) Tier-2 rows render—N/A(not blank, not zero) in Tier-1-only columns, with a tooltip explaining why (corrected 2026-10-04: as built ——means a measured none, §FPS display rule). - Frametime — ScottPlot timeline of selected session (decimated), stutter markers, sensor overlay toggle (temp on right axis).
- Distribution — FPS histogram + percentile curve of selected session(s).
- Trend — metric-over-date line (selector: Native avg / Displayed avg / 1% Low / 0.1% Low / max GPU temp), vertical hardware-change markers with tooltip "GPU driver 572.16 → 576.02" (FR-6.3). (The tooltip stood here unbuilt until beta.30 — 2026-10-26, owner decision D70: a numbered badge per day that changed, its changes in the list under the chart, the same text in the tooltip; below.)
- Sessions —
Across sessions, beta.11 (owner decision D39, FR-6.6). The Sessions tab opens with Sessions at a glance: a
TrendChartof every hooked session's Presented FPS (sessions that counted no generated frame), Native and Displayed (sessions where frame generation was measured — rule 6, never one inflated line) and 1% / 0.1% lows, oldest first, partial sessions hollow (TrendSeriesBuilder.Overview); a click near a session's points selects it in the grid and scrolls to it (TrendChart.SessionClicked). Under it, Delete all sessions… (FR-1.7) for this game. The Trend keeps its selector and adds Also draw: any other metric ticked is drawn on the same chart, its unit (TrendSeriesBuilder.UnitOf: FPS, °C, %, W, MB, ×) on the left axis when it is the selected metric's and on the right when it is a second one (marked ▸ in the legend); a metric in a third unit cannot be ticked, and when the selected metric changes to a third unit only the first ticked unit in the list stays ticked, so every ticked box has its line; the selected metric is not offered beside itself. One line alone keeps its name on the axis, as before. After any delete — here or in Settings — a summary window still open on a deleted session closes, and File ▸ Export lets go of it (SessionDeletion; ids are reused once the newest is gone). Tests:SessionDeletionAndOverviewTests.The display mode, beta.10 (FR-7.4,
03_METRICS§Display mode). The Last session measured row adds how that session was shown — the mode that lasted longest with its share and the window's size (Display: Borderless 92% · 2560×1440); the Sessions tab has a Display column for every session, Tier 2 included (the mode shown longest, with a tooltip carrying every share, the changes, the window on its monitor, the back buffer and the witness),N/Afor a session recorded before; the Trend has three more metrics — Exclusive fullscreen share %, Borderless share %, Windowed share % — over every session whatever its tier, never left out as a mid-session change (a mode switch resizes the swap chain, and the share is what that switch was), with no exclusive or borderless point for a session that had any time nothing could split (Services.DisplayText,Charts.TrendSeriesBuilder.DisplayShare).The game's own memory, beta.12 (owner decision D43,
03_METRICS§Game process memory). Read from outside the game once a second in either tier, it is shown wherever a session is (Services.GameMemoryText, from the stored columns andsensor_stats_json— never recomputed). The Sessions tab has VRAM (game) and RAM (game): the median · the peak, in Task Manager's units (MB below 1 GB, GB to two decimals, 1 GB = 1024 MB,Formats.Memory), the tooltip carrying the mean, the shared GPU memory's peak, the working set's and the commit's peaks, and how many processes were added together where an unpinned hold summed more than one. Where Windows did not report the private working set, the working set is shown and SAYS so ("(working set)") — never passed off as Task Manager's "Memory". The Trend replaces Max VRAM (game) — which readvram_proc_max_mb, a column nothing ever wrote, so it never had a point — with Median / Peak VRAM (game) and Median / Peak RAM (game) in GB, machine metrics that count Tier-2 sessions (the RAM lines are the private working set only: a working-set-only session has no point there rather than another quantity on the line); Avg RAM in use is the whole PC's, now in GB too. Compare adds the four as rows that rank nothing — a game that uses more of a card it has is not worse. The Sensors tab and the summary's Sensors section draw two memory plots in GB: Video memory (VRAM) — this game's dedicated and shared beside the whole graphics card's — and Memory (RAM) — this game's private working set (or its working set, labelled) beside the whole PC's; this game is one colour on both. The summary adds two cards, VRAM (this game) and RAM (this game) — the median, with "median · peak … · shared …" / "… · commit …" beneath — and a table, Statistics per series: every stored series' mean, median, minimum, peak and number of readings, each in its own unit (Services.SensorStatsTable); a session recorded before beta.12 shows one sentence instead of the table. The live card shows "This game: VRAM … · RAM …" from the newest tick, a held session included, and the CSV gains the# game_memory:header line. Tests:GameMemoryTextTests,SessionSummaryViewModelTests.TheGamesMemoryAndTheStoredStatisticsAreShownForASessionThatWasNotHooked,TrendSeriesBuilderTests,CompareViewModelTests,ChartMathTests.TheMemoryPlotFallsBackToTheWorkingSetUnderItsOwnName,LiveCaptureViewModelTests,SessionExporterTests. 5. Sensors — temp/load/power/VRAM timelines per session; per-process VRAM and adapter-wide VRAM as separate, differently-labelled series. Since beta.12 two memory plots in GB: Video memory (VRAM) (this game's dedicated and shared, the whole graphics card's) and Memory (RAM) (this game's private working set, the whole PC's). 6. Latency (Tier 1 + Reflex only) — PC latency timeline, avg/p95.
Built 2026-09-14 (P3 PR-7): tabs 2–6. Frametime and Distribution show the session selected in the Sessions tab (the same
FrametimeChart/DistributionChartas the summary window; a Tier-2 or retention-swept selection says why there is nothing). Trend:Charts/TrendSeriesBuilder— one point per hooked session oldest first under the selector (Average = Native where frame generation was measured and Presented where it was not, the note beside the chart says so; Displayed only where measured; the lows; max GPU °C), FR-6.4's exclusion ofsettings_changed_midsessionsessions by default with the toggle and the excluded count, and FR-6.3's markers — labelled dashed lines wherever two consecutive sessions' hardware snapshots differ in GPU driver, GPU, CPU, display mode or OS ("GPU driver: 572.16 → 576.02") (numbered since beta.30, the label's text in the list under the chart — below). Sensors: GPU core / hotspot °C, load % and power W (right axis) on one plot; VRAM on another withthe game's own per-presentthe adapter-widevram_proc(a held 1 Hz sample) andvram_adaptersensoras two differently-labelled series(corrected 2026-10-03: the Overlay never producedvram_proc, so the game's line was never drawn on any session; beta.12's two memory plots are described above). Latency: thelatency_usblob with the stored avg / p95 lines, shown only when Reflex reported (reflex_active); otherwise the tab says so. Since beta.14 the tab itself is shown only when one of the game's sessions measured latency (GameDetailViewModel.AnyLatency): nothing measures Reflex today, and a tab that could only say "no data" was noise.Trend, beta.14 (D49): nine more metrics — Time below 60 FPS %, Display under refresh rate %, Frame to frame ms, Render scale % (
100 / upscale_ratio), VSync share % and Frames per watt from hooked sessions; Avg GPU core clock MHz, Max GPU memory °C and Held back by power limit % from every session's telemetry. Each has its own unit (ms, MHz and FPS/W are new axes); a session recorded before beta.14 has no point (TrendSeriesBuilderTests).Trend, corrected 2026-09-25 (beta.8, owner item 6: "does Trend really work?"). It did not, on first open: the view model started loading before the page existed, and a load that finished first raised
TrendPresentedto nobody — the tab was blank until something reloaded it. The page now draws what the view model holds when it is made (PagesLoadTests.TheTrendIsDrawnWhenThePageIsMadeOnADateAxisThatKeepsItsLabel). Also: the date axis is created BEFORE the theme and the label (DateTimeTicksBottomreplaces the bottom axis, and made afterwards it dropped both); Average is two metrics — Presented FPS on sessions that counted no generated frame (never on one that did: its presented rate includes them, the single inflated number rule 6 forbids) and Native FPS where frame generation was measured — and the trend opens on Native when the newest measured session counted generated frames; the machine metrics count Tier-2 sessions too (a game never hooked had no trend); a point that describes part of its session — settings changed, or a steady state, for Native and Displayed as well as the factor — is drawn hollow and the note says so; hardware changes on one day are one marker (numbered since beta.30, its changes listed under the chart); the metric list is built in the language the page opens in; the empty text names the metric.Hardware-change markers, numbered — beta.30 (owner decision D70, "Số + danh sách"). The owner's screenshot of 2026-10-26 showed the label "Driver GPU: 32.0.16.1742 → 32.0.16.2101" with its top cut off: ScottPlot's
VerticalLinelabel grows up from the data area into the top-axis panel, which nothing sized for it (about 15 px for a 25 px box), every further line of a day's label was lost above the control's edge, and its white on the orange read 1.78:1 (dark) and 2.63:1 (light). Asked, the owner chose numbers and a list.TrendSeriesBuilder.Markersnumbers the days that changed oldest first (ChangeMarker: the number, the day, each change once) and the view model hands the same list to both charts and both lists, so a number means one day everywhere on the page. On the chart,ChangeMarkerPlottabledraws each day's dashed line in the data area and, in a band kept above it (Axes.Top.MinimumSize, measured from the badge's font), a numbered badge in the palette's orange withChartTheme.TextOn's text — black in both themes, 11.79:1 and 8.00:1 — joined to its line by a short connector;ChangeBadgeLayoutkeeps every badge inside the data area's width and off every other: too close, they stand aside in their lines' order; farther than about one badge from their lines, or with no room at all, the nearest neighbours become one badge for the run (3–5). A badge is never cut off and never over another, at any width; a day outside a zoomed range has no line and no badge. Under each chartChangeMarkerListgives every number its day (Formats.Day, the regional short date) and its changes in full, wrapping, with aChangeBadgechip in the badge's colours; the Trend's list stands with its chart. Pointing within 14 px of a line, or at a badge, shows the same text in a tooltip, which closes on a press, a wheel or leaving the chart. The pointer is read through the element's DPI now (GetPlotPixelPosition):WpfPlot.DisplayScaleis taken once, before the control has a window, and the overview's click used it.ChangeBadgeLayoutTests,PagesLoadTests.EveryChangeBadgeIsWholeInsideTheChartAndNoneIsOverAnother(the Trend's 640×320, the overview's 220 px, a 300 px window, markers on the data area's edges, thirty days in a row),ChartMathTests(the badge's text in both palettes) and the readable and theme-switch sweeps over the game page's list hold it.FPS with two decimals (same day, owner item 7). Settings ▸ Window: Show FPS with two decimals (
ui.fps_decimals, off by default) — every FPS figure throughFormats.FpsNumber: "62.40" when on, "62" when off, rounded half away from zero both ways (it rounded half to even).Services.FpsDecimalsholds it for the process likeLoggingLevel: read at start, moved at once by the toggle, shown by a page the next time it formats.Rule 6, the places that dropped the share (same day). A steady-state factor is never shown without its share: the readout line ("58 → 116 FPS (×2.0 FG · 75%)"), which the Average card and Compare use, and the Sessions grid's FG× column ("×2.0 · 75%"). The header's "Lifetime average" was the last measured session's readout and says so now.
Compare (same day). The best cell is in the accent colour — a local
Foregroundon the cell outranked the trigger, so it was only ever bold — and "best" is the best as shown (62.4 and 62.3 both read 62, both best); the load rows rank nothing; the percentile axis is 0–100 again (AutoScaleran afterSetLimitsXand undid it); exported PNGs have an opaque background (ChartTheme.SavePng: the window's colour under the transparent figure).
Play, beta.21 (owner decision D59: "1: press Play → the platform opens → it runs; 3: it runs at once; let me switch between the two"). A Play button heads a game's page (before Edit…, Primary) and sits on each library card's corner — over the card, not inside it, so the card stays one button — and in the list's first column. Settings ▸ Games ▸ Play button (
ui.play_mode): Through the store (the default) hands the game to the app of the store whose own records name its folder — the records the import reads (Application.Play.StoreRecords; the row'splatformis not trusted, detection may have rewritten it whilestore_idstayed the importer's) — Steamsteam://rungameid/<id>, the Epic Games Launchercom.epicgames.launcher://apps/<ns>%3A<item>%3A<app>?action=launch&silent=true, GOG GALAXYGalaxyClient.exe /command=runGame /gameId=<id> /path="<folder>", the itch appitch://install?game_id=<id>&launch(StoreLaunches: the forms the stores' own shortcuts and code use, measured on the owner's PC except Epic's; every id checked against its store's shape before the shell gets it). No store, GOG without GALAXY, or the App itself running as administrator: the agent starts the game instead, and the notice says why. Start directly sendsLaunchGame(launch mode): recorded from the first frame, never as administrator, refused for a recording-off entry. A viewer's (D52) Play is off and its composition holds noShellStarter. Tests:StoreLaunchesTests,StoreRecordsTests,GamePlayerTests,ViewerModeTests.beta.27: a Steam game may hand itself to Steam. Started by the agent — Start directly, or every press while the App runs as administrator — a game Steam's records name may leave within seconds and have Steam start it again (Lies of P, 2026-10-19;
spike-notes§23), and since beta.27 the game Steam starts is recorded. The notice says so for such a game (Play_Started_Steam_Format,Play_Elevated_Steam_Format;PlayResult.SteamGamefrom the same store records the store mode reads), and the Start directly tooltip and Settings ▸ Games ▸ Play button say it for every Steam game, the latter adding that a few will not start outside Steam at all. The owner offered two ways (2026-10-20: a note in the UI, or a fixed rule that Steam's games always go through Steam) and left the choice open; the note was taken because the rule would cost too much: three of the five Steam games started directly on 2026-10-20 ran and were measured from their first frame, and a Vulkan game is measured only when FrameLedger starts it (Everhex Demo).beta.33 (D80): a game the Xbox app or the Microsoft Store installed always starts through Windows. In either mode, and from an App running as administrator too, Play runs
explorer.exe shell:AppsFolder\<AUMID>— the user's shell activates the game's package, unelevated, as its Start-menu tile does (StoreLaunches: the AUMID is the record's<family name>!<application id>, checked against the shape Windows gives one). Started by its path a GDK game is never the game in its package (spike-notes§25), so no mode sendsLaunchGamefor it, and the agent answersPackagedGameto one that reaches it anyway (an entry the App found no package record for). The notices:Play_Xbox_Format(started),Play_Xbox_NotStarted_FormatandPlay_PackagedGame_Format(start it from the Xbox app or the Start menu), all warnings but the first; the Through the store and Start directly tooltips and Settings ▸ Games ▸ Play button say it. The session is attach mode,late_attach(04_CAPTURE§Launch mode vs attach mode). Tests:StoreLaunchesTests,GamePlayerTests,CaptureOrchestratorTests.
Session summary (secondary FluentWindow, also the post-session toast target)
Stat cards (Avg uses FpsReadout, Median, 1% Low, 0.1% Low, Min/Max, σ, stutter %, duration, Display — beta.10: the mode shown longest with its share and the window's size, both tiers; VRAM (this game) and RAM (this game) — beta.12: the median with the peak beneath, both tiers), Statistics per series (beta.12: every stored series' mean / median / minimum / peak), TriState chips, API/PresentMode/upscaler line, the display line (beta.10: every mode's share, the changes, the window on its monitor at its refresh rate, the back buffer and swap effect, and what the facts rested on — "the swap chain said whether it was exclusive" or "from the window alone: exclusive fullscreen cannot be told from borderless"; absent for a session recorded before), crash InfoBar (Severity=Error) when crashed, frametime chart, sensor strip, tags/notes editor, Export buttons.
beta.24 (D64): the DLSS line. Under the header's library line, the summary says which DLSS ran (
DlssText.Line): a generation only where the session shows one, with what it rests on — DLSS 4.5 (preset L), DLSS 4.5 (a ×6.0 frame-generation state), DLSS 3 (library 3.7.10) — else DLSS; then each DLSS library with its version and where it was loaded from (Super Resolution 310.5.0, from the graphics driver, preset L (2nd-gen transformer model)), then DLSS 5 runtime loaded when it was. The game page's Last session measured repeats the label; the CSV export gains# dlss:.DlssTextTests. (beta.34: two more rows — the NVIDIA App's Dynamic frame generation the driver reports applied is DLSS 4.5 (Dynamic multi frame generation, set in the NVIDIA App) (D83), and DLSS 5 (neural rendering on N % of rendered frames) heads the line where the game was seen running it, its library listed like the others, runtime loaded, not seen running where the Overlay looked and saw none (D84) —05_DETECTION§DLSS generation.)
0.1.0-beta.50 (D155-D163): Played with. Above the annotations, in either tier, the summary says what the session was played with (
Services.InputPresentation, from the row's stored totals andsessions.input_devices- nothing is recomputed from the series): a line saying how long it was read and how long the game was in front; a bar (Controls.InputShareBar, onShareBar, whichFgMixBarnow derives from too) and a table of the four classes - a controller, the keyboard and mouse, both at once, no input - each with its share of the time in front and its time; the number of changes between a controller and the keyboard and mouse; a Controllers table (name, connection, in use, connected, connected / dropped, and the battery: the state held longest and for how long, the first and last level, the drain); each maker's share where there were two; and one sentence for each thing the reader could not do or Windows showed twice. A session with no share says why in one line: the terms were not accepted yet, the game was never in front, or nothing was recorded. Two charts follow from the session'sinput.*series (Charts.InputSeries, gaps kept): Input over the session (InputTimelineChart: one row a class, a marker a second, each row named on the axis and each class with a marker shape of its own) and Controller battery (InputBatteryChart: a step line a controller, XInput's four levels drawn at thirds and labelled as four levels). A controller's connections, drops and batteries that fell to low areInputEvents: vertical lines on the timeline and, behind the Controller marks box, on the frame-time chart of a hooked session whose frames say where they sit on the sensors' clock (SessionSeries.SensorOffsetS) - each kind a line pattern of its own, sixty marks at most. The four classes take palette roles that exist (ChartPalette.InputFill: Native, Displayed, Sensor, MixNone), so no key was added. Trend hasControllerShareandKeyboardMouseShare(every tier, never partial); Compare has Played with and Controllers, never ranked; the CSV has# input:.InputPresentationTests,InputChartsTests; the summary the sweeps ofPagesLoadTestsdraw carries the block. Checked against synthetic sessions only.
beta.27: one window per session, and no DLSS line that says only DLSS. Opening a session whose summary window is open — from a Sessions tab, a notification, the game page — brings that window forward, restored if minimised, rather than opening a second (
SessionSummaryOpener; the owner had two windows of one Silent Hill 2 session, 2026-10-20). The DLSS line is not shown where it would say only DLSS: the header names the upscaler, and the NVIDIA App's override loads its libraries under names no census lists, which the Loaded: line prints (The Witcher 3, 2026-10-20).PagesLoadTests.OpeningAnOpenSessionAgainBringsItsOneWindowForward,DlssTextTests.
beta.24 (D63): the quality mode, on every surface alike. The summary's header line, a Sessions-tab row, the game page's Last session measured and the live card name the upscaler through one entry point (
Formats.UpscalerOf): the NVIDIA App's override where the driver reports it applied — DLSS (driver-reported) Quality · NVIDIA App, or DLSS · NVIDIA App override when its mode is not settled —, else the mode the game passed (DLSS Quality), else the name alone. Mode names come from the resources (Nv_Mode_*). Chart segments stay the hooks' (a segment carries no driver report). The driver line reads the report's mode in NGX's numbering (it read it through the profile's table until beta.24). CSV export:# quality_mode:(quality (nvidia_app),stored 9 (game),N/A).beta.25 (D65): FSR's mode reads the same way — FSR 3 Quality, FSR Native AA (
Fsr_Mode_NativeAa), andnative_aa (game)in the export — wherever the session's byte names one (03_METRICS§Upscaling).
beta.24 (D62): the frame-generation mix. Under the stat cards, Frame generation in this session — shown when the session stored a mix of two rows or more (
sessions.fg_mix,03_METRICS§The mix): a line saying how frame generation was set (the NVIDIA App's Frame Generation Mode from the stored driver profile — Set in the NVIDIA App: Dynamic, up to ×6, target: max refresh rate, Fixed ×4 — or Set in the game — no NVIDIA App frame-generation override; a value the driver ships in its own profile is said as the driver's; no line where no NVIDIA profile was read), a bar of the shares (Controls/FgMixBar: drawn from code in the chart palette — a state by its multiplier,Chart_MixNoneandChart_MixUnclassifiedfor the other two — following a theme switch throughApplicationBackgroundColorasArtTintdoes; announced by itsAutomationProperties.Name), and a table: a colour swatch, the row (×4.0 frame generation, No frame generation, Not classified), its share to two decimals (<0.01%for a sliver, never 0), its own Native → Displayed (one rate with no frame generation, none where no state was read), and its time. A sentence explains Not classified when the table has it. A session that counted frame generation and stored no mix — recorded before beta.24, or no state of 10 s — says so in one tertiary line. The CSV export gains# fg_mix:; the JSON carries the column in its aggregates. Tests:FgMixPresentationTests,NvidiaOverridesTests,SessionSummaryViewModelTests,SessionExporterTests, and the summary surface inPagesLoadTestscarries a mix so the block is read in both themes and through a switch.
beta.14 (D49): the new measurements, as cards and charts. The cards come in three methods (
AddFrameCards,AddPacingCards,AddMachineCards), every value read from the row — never recomputed — and N/A on a row written before beta.14:
- Time below 60 FPS with below 30 and display under {refresh} Hz beneath it — the refresh share named for the display because it is over the presents the display received (
03_METRICS§Pacing) — and Frame to frame; both carry (presented) where the session's statistics are over presents, as the lows do.- VSync ({share} of frames, with tearing allowed beneath), Ray tracing ({share} of frames and rays per pixel — the card appears only where ray tracing was measured), Game in focus (foreground ticks over drain ticks) and Capture quality (gaps · lost records · faults).
- The 1% Low card carries displayed: {presents' 1% low} beneath it where frames were generated (rule 6: beside the game's own, never instead of it).
- GPU clocks (core · memory, with fan and memory temperature beneath), GPU held back (power · heat, NVIDIA only) and Frames per watt (the game's own frames, GPU power only).
Charts: Render scale under Distribution (
Charts/RenderScaleChartoverRenderScaleSeries:100 × √(render pixels / output pixels)as steps — from therender_resblob where the resolution varied, a flat line at the row's extent where it did not, and a sentence where the upscaler's parameters were never measured), and on Sensors the card's memory temperature on the temperatures plot (its own palette colour,Chart_SensorTertiary: no existing one was 60 apart from all six beside it) and a fourth plot, Clocks and fan — core and memory clock in MHz, the fan in RPM on the right, and the ticks its power limit or heat held it back shaded behind them; collapsed when the session stored none of these. Tests:SessionSummaryViewModelTests(the new cards, a row before beta.14 at N/A, the displayed low),RenderScaleAndClocksTests,ChartMathTests.Built 2026-09-14 (P3 PR-6).
Windows/SessionSummaryWindow(a secondaryFluentWindowwith its ownContentDialogHost), opened from a Sessions-tab row (double-click or Open) and from the Dashboard's recent list. Stat cards read the STORED aggregates — never recomputed — with the lows labelled (presented) when frame generation was not measured (03_METRICS); a Tier-2 session shows N/A cards, a sentence, and no charts. Chips resolve throughTriStateResolutionand click into FR-8.3's dialog (TriStateOverridePrompt: measured / Yes / No / N/A, "also this game's default"); the override lands onsession_annotations, the measurement stays, clearing restores it. Bars: crash (Error), safety unhook (Warning). Charts (Charts/):SessionSeriesLoaderdecodes the blobs once — cumulative time, the generated and gap bits, the application-frame view withDomain.Metrics.StutterDetectorover it (the stored count's own rule), segments mapped from frame index to seconds, sensors aligned tot_mswith −1 dropped;FrametimeChartdraws the application-frame series (the every-present series behind the FR-5.4 toggle, shown only when generated frames exist), stutter markers coloured by cause wherepso_createdsays PSO compile (FR-5.5; the VRAM-budget cause has no per-frame source yet), the segment ribbon as alternating spans when there is more than one segment, and GPU temperature / load on the right axis behind the sensor toggle;DistributionChartdraws the FPS histogram and the percentile curve (Domain.Metrics.Percentile, so the two lows are two points on it).Honest charts, 2026-09-25 (beta.8, owner item 8: "fix the charts that are not reasonable"). Measured first on the owner's own Onimusha demo capture (DLSS FG ×3, read from a copy of the ledger): the title submits each generated frame half a millisecond after its application frame, so the "native" series — each application frame's interval to the present before it — was a generated frame's half millisecond, and the stored median read 2,073 FPS on a 60 FPS game. What changed, each with a test (
SessionSeriesLoaderTests,ChartMathTests,PagesLoadTests):
- One stream.
SessionSeriesLoadercharts the swapchain the statistics are over (SegmentBuilder.DominantStream, identified first, then the most presents) — the stored intervals are per swapchain, and two streams interleaved on one axis drew neither — with that stream's segments; the CSV export is the same stream (its header says so).- Application frame to application frame. The default series is each application frame's time from the previous application frame, the generated presents between them adding their intervals to it; a gap breaks the chain. It is labelled Application frames where frame generation was counted and Presents where it was not — never "Native" alone. A session whose presents were all generated (the
no_evaluationsrefusal) charts every present and says so.- The every-present line (FR-5.4's toggle) leaves out the presents after a gap, which were drawn as 0 ms frames, and a note says what it is not: presents are timed at submission, and a burst of generated frames is not the display's cadence.
- Segments are labelled with their settings (upscaler, render → output, frame generation) where the segment is wide enough; the label was computed for every segment and drawn for none.
- The sensor overlay is in step. Schema 0013's
frame_blobs.first_present_mssays where the first present sits on the sensors' clock; the overlay was drawn tens of seconds early (the launch and the loading screen). A session recorded before keeps the overlay off rather than drawn out of step; gaps are still closed up on the frame axis, and the note says how many when the overlay is on.- Distribution. The histogram is binned over the 0.5th–99.5th percentile, not min–max (one 0.3 ms non-frame set the axis to thousands of FPS), with the frames outside counted in a note, and its bars sit on their bins' centres (they sat half a bin left: ScottPlot's bins are lower edges). The percentile curve is drawn only where ten frames lie beyond a percentile on each side — FR-4.8's rule, generalised — so its 1% and 0.1% lows are marked exactly where the stat cards publish them, and the single shortest interval no longer sets the axis; the 0–100 axis holds.
- Sensors (the tab and a new section of the summary window): power on a watt axis at the right, the second plot is Memory (the game's VRAM, the adapter's, the system's RAM),
a per-present VRAM of 0 is a present the sample did not reach and is left out(corrected 2026-10-03: there was no per-present VRAM to draw — the Overlay never produced it; beta.12 replaced the plot with two, above), the time axis says where its zero is, and every line has its own colour in both themes (the light theme drew power and CPU temperature in one gold). A session that was not hooked charts its sensors — kept since 2026-09-22, shown nowhere until now.- The game page follows the Agent while it is shown: a
SessionCompletedfor this game reloads it (GameDetailViewModel.Attach/Detachon the page's Loaded / Unloaded; the link is a singleton and must not hold the page). Its sessions, trend and header were the ones it opened with. FR-5.3:Charts/Decimator— every bucket's min and max in order, ≤ 4000 points per series per draw, a 500k-point series keeps its spike and its dip (DecimatorTests). Zoom and pan are ScottPlot's. FR-9:SessionExporter— the CSV with03_METRICS§Export schema's column line verbatim and the#header block (tier, api, hardware, the tri-states with sources, the segments,the 1 Hz VRAM note— since beta.12 the# game_memory:line, and a note thatvram_mbis the in-game figure this build does not produce), InvariantCulture throughout, no rows for Tier 2; the JSON (frameledger-session/1: metadata, the row as aggregates with N/A omitted, segments, the annotation); PNG throughPlot.SavePng. Tags (comma-separated, de-duplicated) and notes save to the annotation row. FR-3.8 is an in-app notice onSessionCompleted(saved / discarded); the tray toast with "View" arrives with the tray (PR-8).The loaded libraries (2026-09-25, beta.8). Under the hardware line, a Tier-1 session says what it had loaded —
sessions.runtime_modules, written since P2 and shown nowhere until then — sorted, one line: "Loaded: nvngx_dlss.dll 310.2.1.0 (the game ships 3.7.10.0: another copy was loaded, for example by the driver or the NVIDIA App) · sl.interposer.dll 2,8,0,0". The comparison is with the game's own copy (games.library_versions) as the same four numbers (Formats.SameVersion: Streamline's2,8,0,0string equals2.8.0.0); it names a difference and never who made it. Older rows show their list the day this ships; a Tier-2 row has none and no line.The NVIDIA driver's side (2026-09-25, beta.8). Two more lines where they have something to say (
Services.NvidiaOverrides): the driver profile the game ran under and what it overrides — "NVIDIA profile “Clair Obscur: Expedition 33”: DLSS override (preset K, Quality) · Frame Generation override (×4, latest preset)", or "no DLSS or frame generation override", or the global profile's when none names the game — and what the driver reported applying in the game's process from its override bits ("NVIDIA driver, for this game's process: DLSS DLL chosen by the driver · preset K · Quality"). Smooth Motion is labelled a setting community tools document, not NVIDIA. Neither line is a measurement (03_METRICS§Upscaling); a machine without an NVIDIA driver shows neither.How it ended, and why (2026-09-25, beta.8, owner item 5). Under the header line, "How it ended: …" (
Formats.ExitText): a crash names its exception ("crashed (0xC0000005 access violation)", "0xC0000006 in-page I/O error: a disk or drive failed while the game read its files"), End task's exit code is an ordinary end said as what it is, and the event log's witness is named as such. The Tier-2 sentence has words for everySessionEndReason(Formats.EndReasonText, an enum-walk test keeps it so) and for every refusal no anti-cheat family names (Formats.GuardSentence: "The anti-cheat guard did not hook this game: the game is 32-bit…") — the safety notice and the enable-time refusal use the same words instead of " was detected in this game"; a launch that could not start says Windows' reason. The game page's missing-executable bar says whether the drive is not connected (FrameLedger finds the game again when it is) or the file is gone from its path, and so does the notice when enabling hooking meets an unreadable executable. Tests:ReasonTextTests,Tier2ReasonTests.
Compare
Session picker (2–5, cross-game allowed) → overlaid percentile curves + stat table with best-value highlighting; FG columns always show Native and Displayed separately. Export PNG.
beta.34 (owner request 2026-11-06, with a screenshot; D85). The list holds every session — it was the newest 200, read on the UI thread with one game lookup each; now one read of the names, on the thread pool — and filters by Game, Tier and Frame generation (with / without; a session that measured none is neither), with a count (6 of 131 sessions); a ticked session stays listed whatever the filters say. The selection bar — Pick 2 to 5 sessions, the count, Clear selection, Compare — sits above the list on the left: it was a window's width away. The columns are sized to what they hold with one filler column after them (three star columns spread a wide window into gaps, and the Tier column was exactly its header's width, so Tier and FPS touched); the date sorts by when; the settings-changed cell says Changed mid-session beside its icon, or a dash (it was blank). The result table's session labels sit over their columns: the header row has the metric column's 140 px first, as every row does. Tests:
CompareViewModelTests.TheFiltersNarrowTheListAndATickedSessionStaysOnIt, the page inPagesLoadTests' surfaces.
Mixed-tier guard (FR-6.2): selecting sessions from different capture tiers shows a blocking ContentDialog explaining that they measured different things; proceeding stamps the chart with a tier legend and greys out metrics unavailable in the lower tier. Sessions with settings_changed_midsession carry a warning icon and are excluded from trend lines by default.
Built 2026-09-14 (P3 PR-7).
CompareViewModeloverthe last 200 sessionsevery session (since beta.34) across games: aDataGridpicker with a checkbox column (Compare enabled at 2–5), the FR-6.4 warning icon per row; Compare asksIMixedTierPrompt(aContentDialog, default button Cancel) when the selection mixes tiers and compares nothing on a decline; a comparison that proceeds carriesCompare_Mixed_Legendas the plot's title and anInfoBar.CompareChartoverlays one percentile curve per hooked session (Charts/PercentileCurve, the distribution tab's own); the stat table is one row per metric — Native, Displayed and Presented FPS as three separate rows (never one column), Median, the lows, stutter time %, max GPU °C, duration — with the best value of each row bold and accent-coloured (higher wins for FPS, lower for temperature and stutter; N/A is never best), and a Tier-2 session's cells at N/A. Export PNG throughPlot.SavePng.beta.10: three rows after Duration — Display mode (every share), Window and Monitor (with its refresh rate) — facts, not scores: no mode is better than another, so none is ever marked best, and every tier has them.
beta.14 (D49): Time below 60 FPS and Frame to frame (lower is better), Display under refresh rate (lower is better), VSync share and Render scale (settings: no best), Avg GPU core clock and Held back by power limit (facts: no best), Max GPU memory °C (lower) and Frames per watt (higher). A statistic a present-only session has over its presents carries (presented) in its cell — the median, the lows, stutter, time below 60, frame to frame — beside a session whose same statistic is over the game's own frames; the best is decided on the number, never the label (
CompareViewModel.Row's label,CompareViewModelTests).
Logs
Tail view of ui-*.log / agent-*.log (toggle), level filter, search (ui:AutoSuggestBox), pause-scroll; buttons: Open logs folder, Export bug bundle (routes to 10_LOGGING flow).
Built 2026-09-14 (P3 PR-8a).
LogsViewModeloverServices/LogTail: the newest file of the chosen source (App / Agent) read withFileShare.ReadWrite— Serilog keeps it open — capped at the last 2 MB with the partial first line dropped, refreshed every 2 s while the page is on screen (the page's Loaded/Unloaded start and stop the timer) and never while paused; the level filter reads the[HH:mm:ss.fff LVL]prefix of 10_LOGGING's template(continuation lines such as stack frames keep only under All)— the App's; (corrected 2026-10-04: the Agent writes Serilog's default template, a date first, which the filter did not read, so Warning and Error showed no Agent line; since beta.12LogTail.LevelOfreads both) — continuation lines such as stack frames keep only under All; the search is a plainui:TextBox, not anAutoSuggestBox— there is nothing to suggest. The view is a read-onlyTextBoxin Consolas that scrolls to the end on every refresh unless paused. "Export bug bundle" is 10_LOGGING's step 2 and nothing more (see there). The status line says shown / total / file. Tests:LogTailTests,LogsViewModelTests, and the page renders inPagesLoadTests.
Advanced
Built 2026-11-11 (Advanced PR-7; owner decisions D101, D105, D107).
Pages/AdvancedPageoverViewModels/AdvancedViewModel, aTabControlof three tabs by what a value belongs to:
- This PC —
Services.AdvancedMachineFeed, watched betweenLoadedandUnloadedand while the page is visible (a window hidden to the tray lets go too), which is what makes the Agent read with no game running and stop when the page closes (D107). A status line says what the last request came to (Advanced_State_*: read at a time, waiting, off, no agent, an older agent, a viewer); About this PC is the facts under the catalog's groups; Right now is aDataGridof every series with the time it was read at — a sensor read every fifth tick is never shown as new; Over time is one catalog entry's last five minutes (Charts/AdvancedSeriesChart, a date axis).- Session — a selector of the newest fifty sessions that have a
session_advancedrow (ISessionRepository.ListAdvancedAsync), then the PC's facts as they were and the session's own, the stored statistics, and the entry's series over the session (SessionSeriesLoader.LoadAdvancedAsync:t_msis the clock, NaN is left out, a negative reading is kept). A session whose raw series retention removed keeps its statistics and says the series are gone. A session's summary has Advanced metrics… where the session has a row (SessionSummaryViewModel.HasAdvanced); it asks for that session throughServices.AdvancedSelectionand navigates, and a page already on screen takes the request at once.- Sources — every entry of
AdvancedMetricCatalog: its label, what it belongs to, its source, and Read, or the reason it is not (AdvReach_*), or — live — why its source is silent (AdvSource_*). An entry read inside the game (reachGame, 0.1.0-beta.40) says Read inside a game FrameLedger measures, when the game makes the call (Advanced_Status_InGame): it is not a state of the PC. What became of those entries in one session is in that session's sources line on the Session tab (Advanced_InGameLinewithAdvInGame_*): read, the game made none of the calls, or the session was not measured inside the game; a session stored before beta.40 has no such sentence. Since 0.1.0-beta.43 a session measured inside the game has one more (Advanced_InGameCallsLinewithAdvInGameCall_*): for what the game tells Streamline each frame and for how it configures FSR frame generation, each read, hooked - the game did not make the call, or not hooked - the game did not load the library that has the call. "Nothing here" then says which of the two it is. Since 0.1.0-beta.44 one more (Advanced_InGameFeatureCallsLine): for which version each Streamline feature is and for what each requires, the same three — except that hooked and not seen reads hooked - the game asks this while it starts, and did not ask again after FrameLedger attached (AdvInGameCall_NotAskedAgain,AdvancedLabels.InGameStartupCall): the usual case, and not a finding about the game. Since 0.1.0-beta.45 one more, and one only for six calls (Advanced_InGameMoreCallsLine,AdvancedPresenter.MoreCalls): Streamline's other calls - read: …; hooked, the game did not make the call: …; not hooked: …, each call under its own name (slIsFeatureSupported, a function's name and so not translated) in the group that is true of it, and the word for "none" where a group is empty. A session stored before has none of the six and no such sentence. The catalog'ssl.init.preferencescarries a reason of its own (AdvReach_BeforeAttach): Not read: the game makes this call once, before FrameLedger is inside it.Words. Every catalog entry, group, reason, source state and driver token is a
Strings.resxkey made from its own name (Adv_<id>,AdvGroup_*,AdvReach_*,AdvSource_*,AdvToken_*) inen,vi,ja; the English label of an entry is its summary in the catalog, and a test holds the two equal. A key that is not there — a token a newer build stored — reads as the stored text, never as nothing (ViewModels/AdvancedLabels).ViewModels/AdvancedPresenteris the pure mapping, each rule with a test.Charts. A family with more than eight members is drawn as its lowest, average and highest (
AdvancedPresenter.MaxLines), and the page says so; the table beside it lists every member. Lines differ by pattern as well as colour (ChartPatterns).A viewer (
--data-dir) has no Agent: This PC says so, the page opens on Session, and nothing is asked. The navigation item is there when the copy's option is on or the copy holds an advanced session (App.RunAsync).Accessibility (
ACCESSIBILITY.md§For contributors): one first-level heading, a level on every section; the two templates are implicit by type, so no page-local resource key is named; every row type overridesToStringso an item is read by its text; noLiveSetting— the readings change every second and are not announced; each chart has its name and says its numbers are in the table beside it. Tests:AdvancedPresenterTests,AdvancedViewModelTests,PagesLoadTests(the page among every surface, both themes, the contrast themes),AccessibilityTests(CtrlOneToFive…),GuideDocumentsTests.
Settings
Advanced metrics (2026-11-11, owner decision D101; Advanced PR-5). The Recording section has Advanced metrics (
telemetry.advanced, off by default, off in a viewer like every setting the Agent reads): oneui:CardControlwith aToggleSwitch, under Raw series kept per game. Its text says what is read, that off reads and stores nothing more, that it applies from the next session and that an earlier session is not filled in. The Agent reads it at each session's start, so the row gets the usual "Applied. The capture agent reads it at the next session" strip. The switch also setsAdvancedOption.IsOnat once, so the navigation item and Ctrl+6 follow it without a restart (§Advanced, PR-7). With it, three texts that said what an Agent running as administrator adds with PawnIO now name the processor's, the memory's and the motherboard's sensors beside the CPU temperature: the Agent section's elevation line, the first run's Agent step, and the admin mode's disclosure (agent-admin-dialog/2). Tests:SettingsViewModelTests.AdvancedMetricsIsOffByDefaultAndItsToggleIsPersisted,ViewerModeTests.EverySettingTheAgentReadsIsOffInAViewer,GuideDocumentsTests.TheSettingsPageOfTheGuideNamesEverySetting.beta.23 (owner decisions D60/D61). The Games section has, under the Play button, Show game artwork (
ui.game_art, on) and Colour the game page from its artwork (ui.game_art_tint, on; disabled while the first is off) — the game page's artwork and its band's colour (§Games › Game detail, The header's cover). Neither downloads anything; the App reads both at each page load, the Agent neither.beta.14 (owner request 2026-10-05: "an option to hide the scroll bars but still scroll"). The Window section has Hide scroll bars (
ui.hide_scrollbars, off by default). A bar's visibility is bound inside its scroller's template, which no style reaches, soServices.ScrollBarHidingsets the scrollers themselves:one class handler onclass handlers onScrollViewer's Loaded (registered at start besideDialogKeyboard) reaches every scroller the App showsScrollViewer's ScrollChanged and Loaded (registered at start besideDialogKeyboard) reach every scroller the App shows (corrected 2026-10-07, beta.17, the owner's screenshot of the Dashboard with its bar: WPF raises Loaded only where a subtree listens for it with a handler of its own, and a class handler is not one —16_WPFUI_SYNTAX§Gotchas. Settings, full of toggle switches whose template listens, lost its bar; the Dashboard, the first run, About, the user guide and a game's wide sessions table kept theirs. Every scroller raises ScrollChanged from its first layout), those inside a DataGrid, a TextBox, a rendered document and a dialog included. While on, an axis that isAutoorVisiblebecomesHidden— WPF's "no bar, still scrolls": wheel, keyboard and touch — and its own value is kept on it; aDisabledaxis is never touched (it lays its content out at the viewport's width). The toggle applies to the open windows at once, and off puts every kept value back. Tests:ScrollBarHidingTests(on hides every bar and the wheel still scrolls; off restores each; a scroller that loads later follows; since beta.17 a scroller laid out with no Loaded at all, and every page, window and dialog shown in a real window with the option on),SettingsViewModelTests.HidingScrollBars….
beta.11 (owner request 2026-10-03: "remove the Settings rows that have no button or similar"). Every row has a control now: the Games with hooking on card shows only while a game has hooking on (its empty sentence is gone); the Elevation card is gone and its state is the third line of Run the agent as administrator (its explanation a tooltip on it); the sentence under the language row is gone. A Data section has one row, Delete all sessions… (FR-1.7): the confirmation names how many, the Agent deletes them (
DeleteSessions), and the strip says what happened or why nothing was deleted (a session being recorded, no agent, an older agent). Tests:SettingsViewModelTests.DeleteAllSessionsAsksWithTheTotalThenGoesThroughTheAgent. Since beta.19 (D55) the Data section's first row is Remove uninstalled games (retention.remove_uninstalled_games, on by default, off in a viewer like every setting the Agent reads): its strip says the Agent reads it within 15 seconds (Settings_RemoveUninstalled_Applied), not at the next session — the detection sweep reads it at every pass. Tests:ViewerModeTests.EverySettingTheAgentReadsIsOffInAViewer,GuideDocumentsTests.TheSettingsPageOfTheGuideNamesEverySetting.
Sections per FR-10 using the WPF UI settings idiom: ui:CardControl/ui:CardExpander rows with ToggleSwitch, ComboBox, ui:NumberBox (numeric inputs — min session length, sensor interval, retention). Language switch applies immediately (09_I18N). Theme selector (Light/Dark/System) drives ApplicationThemeManager (16 §Theming) (beta.35, D91: a Windows contrast theme wins while it is on, §Contrast, and a line under the selector says so, bound to ContrastTheme.IsOn so it comes and goes with the page shown). Capture section (top, most important): the global hooking kill switch (ToggleSwitch, prominent) with a one-line summary of what it does; a list of games currently hook-enabled with a per-game revoke; Vulkan layer registration state + Register/Unregister; a link to the safety documentation. Turning the global switch off must take effect immediately, including for the Vulkan layer.
System (2026-09-21, FR "show the user's hardware"): a card above Legal stating this PC as a session's hardware snapshot would record it right now — processor, graphics card, graphics driver, memory, Windows build, primary display — through the same IHardwareSnapshotSource the Agent stamps sessions with, read on the thread pool when the page opens, a field that could not be read as N/A, with Copy (the same lines as text) and a note that nothing is sent anywhere and what CPU temperature needs. Its own SystemInfoViewModel, not SettingsViewModel's. The same snapshot is one tertiary line under the session summary's header (it was loaded for the export and shown nowhere), and --diag prints it; the bug bundle's sysinfo.json is deliberately NOT given it — its keys are the issue link's prefill.
Agent section: elevation state with a plain explanation of what elevation optionally unlocks (CPU temperature, elevated-game attach — ETW fallback, which no longer exists) and that it is not required by any capture tier; task state, Register/Repair/Remove task, "Start agent at logon", background capture toggle (removed in beta.12 — nothing read it; corrected 2026-10-04). Privacy: online-metadata opt-in with plain-language explanation. (Not shown since 2026-09-16: no code makes the request and privacy.online_metadata stays reserved — the built Settings below; struck 2026-10-14.) Legal: reopen documents.
The admin mode, beta.10 (owner decision D34;
01_ARCHITECTUREADR-9). The Agent section has a switch, Run the agent as administrator (capture.run_elevated, off by default). Turning it on opens aContentDialog(Services.AgentAdminPrompt, textFrameLedger.Shared'sSafety_AdminMode_*, versionagent-admin-dialog/2(/1until 2026-11-11, when Advanced metrics widened what the option adds — D101) in its corner) whose primary button is enabled only by ticking "I understand…" and whose default button keeps standard rights; declined, nothing is written. Either way the row is written and the Agent restarts — asked to stop over the pipe, its instance lock waited out, the connection's next round starting it the new way — except under a running session, which the restart would end: then the snackbar says the change applies at the Agent's next start. The elevation line says why a standard user's Agent is one when Windows was asked (HelloAck.ElevationOutcome: declined, answered by another account, could not start), and while the prompt waits the status pill reads Waiting for administrator permission (AgentConnectionState.Elevating).
Built 2026-09-14 (P3 PR-8a), with three rows deferred to PR-8b and one to PR-9.
SettingsViewModeloverApplication.Settings.RegisteredSettings(the registry of06_DATA_MODEL§Settings registry — every write is onesettingsrow, and a key the Agent reads gets the 4 s "Applied. The capture agent reads it at the next session start" line, D16 — but for turning the kill switch on, which says a game being measured stops at its next safety scan, within 30 seconds: beta.18; until then it said the next session start). Capture, first: the kill switch as aCardExpanderwhose header is the toggle and whose state line says "All hooking is off" / "Per-game settings decide" — it ishooking.kill_switch, the gate's fourth input (CaptureSessionconsults it at every 30 s re-scan, so a running measured session stops at its next scan; nothing else needs pushing); the hook-enabled list isgames.hook_enabledas the ledger has it, and its per-row "Turn off" isHookingConsent.DisableAsync—SetHookEnabled { enabled: false }over the pipe, the Agent clears the column, the App never writes a hook-state column (D15;SettingsViewModelTestsasserts the row is still enabled after a fake Agent acked); the Vulkan layer row readsHelloAck.VulkanLayerRegisteredand says "unknown" without a HelloAck; the safety link opens19_SAFETY_AND_ANTICHEAT.mdat the public repository in the user's browser (nothing is fetched). Recording: minimum session length, sensor interval and raw-series retention asui:NumberBoxes bounded by the registry; a value outside the range is refused in place (the previous value comes back, a warning names the range, nothing is written);background capture as a toggle with the honest sentence (recorded, measured only if hook-enabled and not Vulkan)(removed in beta.12, 2026-10-04: the toggle wrotecapture.background, which no Agent code read, so turning it off recorded every game anyway; with no way to start a game from the App, "off" could only have meant recording nothing. The key is reserved —06_DATA_MODEL§Settings registry). Agent: the elevation state fromHelloAck.Elevatedwith the paragraph above (not required by any tier; unlocks CPU temperature through PawnIO and attaching to elevated games); the logon task row says the scheduled task arrives with the tray build. Window: "Start FrameLedger with Windows" isInfrastructure.Startup.RunAtLogon— this user'sHKCU\…\Runvalue, quoted executable path, never HKLM — and the Run entry is the truth the toggle loads from; "Minimize to tray on close" is stored now and honoured when the tray exists. Privacy:— the card is not shown since 2026-09-16 (no code makes the request; the setting stays reserved). Updates (alpha, D73, 2026-10-31): in an alpha build the channel picker is locked and its line reads An alpha build updates only to newer alphas, whatever is chosen here… — an alpha's packages are on Velopack's own channel (privacy.online_metadata, off by default, with the network sentence11_UPDATER§Channels). The alpha's shell (D74): an ALPHA badge left of the Agent pill in the title bar for as long as it runs (its tooltip namesRuntimeInformation.FrameworkDescription), the window and taskbar titled FrameLedger Alpha, and a Warning InfoBar above every page at every start, closable for that run, whose button opens the Alpha notice (since beta.37, D97 and D98: its text is one of three — the experimental-build warning; the same naming "a prerelease .NET" where the runtime's description is a prerelease's; or, in an alpha cut while the alpha line rests, that the line is paused and to install the beta —Services/AlphaTexts,Shared.AlphaLine); About's version line names the runtime on every line, and--diagprintsrelease_line:and the runtime's description.Updates:
update.channelis read by PR-5's updater (beta = GitHub pre-releases; since beta.14 Automatic (Beta) or (Stable) first, the default, following the running copy — D47), andupdate.auto_check— the startup check, on by default — sits beside it. Logging:log.debugmoves this app'sLoggingLevelSwitchat once; the Agent has no reader for the key yet, and the row says so. Legal: reopen is a "not yet" line until PR-9's gate exists.Register/Unregister the layer, Register/Repair/Remove the task— PR-8b, with the Agent flags they need. Tests:SettingsViewModelTests(seven cases),RunAtLogonTests(Infrastructure, under a test's own value name), and the page renders inPagesLoadTests.8b built 2026-09-14. The Vulkan layer row gained Register / Unregister and the logon task row Register / Repair / Remove; each button runs the Agent's flag as a child process (
IAgentTool→FrameLedger.Agent.exe --register-vklayer/--unregister-vklayer/--install-task/--uninstall-task) and then re-reads the machine (IMaintenanceState: the HKCU key, Task Scheduler) — the text shown is what the machine holds, never what the button assumed. Register is enabled only while the layer DLL is staged, the registration is absent anda game has hooking ona hook-enabled game references the Vulkan loader (P4 PR-2, 2026-09-14:HookedGameViewModel.UsesVulkanfromcapability_flags) (the same rule the Agent's reconciler enforces on its own after every consent change and every sweep — the button is the repair tool,12_BUILD§The Vulkan layer is not registered at install time); Repair appears when the task's action names another path (a moved install). "Minimize to tray on close" is honoured.2026-09-25 (beta.8): Capture gained Hide hooking on anti-cheat games (
ui.hide_anticheat_hooking, on by default) between the kill switch and the Vulkan layer row — §Games says what it hides; the game's page reads it at each load. It hides a control that could only be refused, never the finding.2026-09-26 (beta.9, D33): Capture gained Allow hooking in games with user-mode anti-cheat that were measured before (
hooking.usermode_ac_exceptions, off by default), below the hide switch, and under it the User-mode exceptions list — the games the Agent found eligible (Make exception…), held back only by the session count, or carrying an exception (Withdraw), each with its finding, its successful hooked sessions and its state; with the option off only kept exceptions are listed, suspended. Checking… shows until the Agent has answered about every blocked game, and Refresh re-reads the list (the Agent's sweep runs every 15 s). The option is an Agent-read key and takes effect at the next session start and command.2026-10-03 (beta.11, D38): the option reads Allow hooking in games whose only anti-cheat runs in user mode, and its body names the trial. The list shows only rows with an action — eligible (Make exception…) or carrying an exception (Withdraw); "held back only by the session count" is gone with the count, and a game that can never qualify is explained on its own page. Each row is the game, its finding and its state — the state carries a grant's trial (Exception in force since … — trial: 1 of 2 good sessions so far), so the separate count line that repeated it is gone. Refresh shows only while a row is Checking…, the one time it can change anything.
First-run flow
- Legal Gate (FR-11): four documents, scrollable, links to GitHub-hosted versions, single Accept. An alpha build's gate shows a fifth (D74, 2026-10-31): the Alpha notice (
legal/ALPHA_NOTICE.md), accepted with the others underlegal_acceptance.doc = 'alpha'— and above the documents, under the summary, a second warning box with a tick box of its own (I understand that this is an experimental build and I use it at my own risk): Accept is disabled until it is ticked, every time an alpha's gate is shown. While the notice is outstanding the App holds the Agent's start (IAgentLink.SetNoticeHold, a hold of its own beside the updater's), because an alpha's Agent does not serve before it; Accept releases it and starts the Agent at once. About ▸ Legal documents lists the notice on every line, for information. Since beta.12 (D45) Accept covers three — the EULA, the Disclaimer, the Privacy Policy; the GPL is listed as your licence, with a line saying it needs no acceptance (GPLv3 §9), and gets nolegal_acceptancerow (06_DATA_MODEL). Rendered since beta.12 (§Menu, Documents are rendered): the Markdown texts drawn, the GPL as written; a link from one document to another the gate shows opens it in the gate; View on GitHub opens the document at this build's source, throughIUrlOpener. - Agent setup: runs unelevated by default — a short, honest paragraph explains that elevation is optional and unlocks CPU temperature and elevated-game attach.
and the Tier-2 ETW fallback. It must be explicit that without elevation there is no Tier 2— struck 2026-08-28: no tier needs elevation, so there is nothing to warn about here. Capability check results shown afterwards.with Tier-2 availability listed as its own badge— there is no availability to report. - Hooking explainer: what Tier 1 vs Tier 2 means — and it must be explicit that Tier 2 measures nothing, because the honest version of this screen is the one where a user who declines knows what they are declining — and that hooking stays off until enabled per game.
- Optional library import.
Built 2026-09-14 (P3 PR-9).
Windows/FirstRunWindowaroundControls/FirstRunContentoverFirstRunViewModel, shown byApplicationHostServicebefore the shell wheneverServices/LegalGatesays so — a first run, or a document whose version moved — and by Settings ▸ "Reopen the legal documents" in read-only mode. (1) The gate: the four documents ride in the assembly (LegalDocuments:legal/EULA.md, the rootLICENSEas the GPLv3 text,legal/DISCLAIMER.md,legal/PRIVACY_POLICY.md, embedded at build so the App shows the text this build was reviewed with; HTML authoring comments stripped;{{RELEASE_DATE}}left forrelease.yml), a list on the left, the text in a read-only box (raw Markdownrendered since beta.12), "View on GitHub" per document, one Accept that writesfourthreelegal_acceptancerows with each document's own**Version:**line((corrected 2026-10-04: since beta.12, D45, the GPL is shown for information and gets no row; an olderGPL-3.0-onlyfor the licence)gplrow is left as written), and Decline, which ends the host — the shell never appears. Closing the window without deciding is a decline. (2) Agent setup: the honest paragraph (unelevated by default; elevation optional, unlocks CPU temperature and elevated-game attach, required by no tier) and the facts fromHelloAckas they arrive — state, version, telemetry source, overlay build, CPU temperature, elevated — N/A until the Agent answers. (3) The explainer: the consent dialog's own reviewed Tier 1 / Tier 2 paragraphs (Safety_Consent_Hooked/_NotHooked, so the two screens cannot drift), that hooking stays off until enabled per game, and that the Disclaimer states the risk. (4)the import placeholder (P4)since P4 PR-4 (2026-09-14) a real pointer: the stores' libraries are imported from File ▸ Import library… once inside, every row hooking off (the step itself stays text — the review dialog needs the shell's dialog host, which the first-run window has not). D8 unchanged: the gate is not a consent precondition. Tests:LegalDocumentsTests,FirstRunViewModelTests(required on empty, one Accept =fourthree rows at the documents' versions, a moved version re-shows only that document, decline/close write nothing, read-only records nothing, the Agent facts), the two steps rendered inPagesLoadTests.NFR-4, measured 2026-09-14 on the dev box (Debug build, warm disk): the first window (the shell, or the first-run window on a first run) is logged every run as "shown N ms after process start" — 1.3–1.5 s for the shell across PR-2 to PR-8b's smoke runs and 0.83 s for the first-run window on PR-9's, under the 2 s ceiling; a 100-session game's list + annotations query is a few milliseconds (
SqliteSessionQueryTests, ceiling 500 ms asserted); charts draw at mostDecimator.DefaultBuckets × 2points per series per draw whatever the session size (DecimatorTestsover 500 000 points), which is what keeps pan/zoom interactive. The Win10 22H2 visual pass is the owner's (NFR-8, no VM here).
UX rules
- Empty states for every list ("No sessions yet — launch a tracked game and FrameLedger will do the rest").
- All destructive actions confirm via
Wpf.Ui.Controls.MessageBox(async — 16 §Dialogs): delete game/sessions, DB maintenance. - Notifications strictly per the policy above (snackbar / InfoBar / tray).
- Keyboard:
NavigationView items Ctrl+1…5; grids fully navigable; Esc closes flyouts/dialogs— §Accessibility below, since P4 PR-8 (2026-09-15); this bullet named three behaviours and none of them was built or checked. - No blocking dialogs during capture; errors surface as InfoBars/tray toasts.
- Charts and stat numbers use culture-aware formatting per active UI culture (09); colors only from theme resources or the per-theme chart palette (16 §ScottPlot).
- The mouse wheel scrolls whatever is under the pointer (beta.14). Every page scrolls itself
(
ScrollViewer.CanContentScroll="False"on thePage—16_WPFUI_SYNTAX§Gotchas: until beta.14 the wheel scrolled nothing on five pages, and the Logs tail did not follow the newest line); a scroller nested in a dialog hands the wheel on at its ends (ui:PassiveScrollViewer); over a chart a plain wheel scrolls the page and Ctrl+wheel zooms the chart (Charts/ChartWheel, every plot throughChartTheme.Attach) — drag still pans anddouble-click still resets, as ScottPlot does(corrected 2026-11-09: ScottPlot's left double-click toggled its render-time benchmark overlay; since beta.35 a double-click shows all of the chart,ChartTheme.ResetOnDoubleClick,ChartKeyboardTests). The import checklist scrolls inside its list and nowhere else, so its intro and its count stay put.
Accessibility
NFR-9 names three things — full keyboard navigation, adequate contrast in both Fluent themes, Per-Monitor V2 DPI — and this section is what they mean for this app, each with the test that holds it (P4 PR-8, 2026-09-15). Until then the requirement was one bullet under §UX rules, and nothing checked it.
The users' half is
ACCESSIBILITY.md(beta.35, owner decision D88, 2026-11-09): the goal — WCAG 2.2 AA as W3C's WCAG2ICT applies it to desktop software, a goal and never a conformance claim — what works, what does not and what to do instead, and how a barrier is reported (the Accessibility problem form,labels: [accessibility]) and handled (by severity, no promised times). It is embedded and shown under Help ▸ Accessibility. This section is the design and the checks; the statement says nothing this section does not hold, and a change that moves either changes both (AccessibilityDocumentTestsholds the statement's own rules: embedded as written, a goal and no claim, a form that exists, no struck text in a page the App shows). NFR-9 was widened the same day to screen readers and contrast themes (D88–D91).
Keyboard
| Keys | Does | Where |
|---|---|---|
Ctrl+1 … Ctrl+5 (and the numeric keypad's 1–5); Ctrl+6 since 2026-11-11 (D105) — the Advanced page, only while AdvancedOption.IsOn: ShellShortcuts refuses it otherwise, so the number stays free |
Dashboard · Games · Compare · Logs · Settings — and since beta.35 the page's first control takes the focus once it is shown, its title (the page's first-level heading) said to a screen reader; before, the focus stayed where it was, often on the page that had just gone | MainWindow InputBindings → MainWindowViewModel.NavigateToCommand → ShellShortcuts, then Services/PageFocus (the shell tells it each page shown, from NavigationView.Navigated) |
| Alt, F10 | Focuses the menu bar; arrows and Enter walk File / Tools / Help | WPF Menu, nothing custom |
| Alt + a menu's access key | Opens that menu — _File _Tools _Help; _Tệp _Công cụ Trợ _giúp; ファイル(_F) ツール(_T) ヘルプ(_H) (row added 2026-11-09: the keys existed since P3 and this table did not name them) |
the Menu_* strings' _ |
| Tab / Shift+Tab | Moves through a page in reading order | layout order; no TabIndex overrides |
| Arrows, Home/End, Page Up/Down | Move within a DataGrid (Sessions, Compare picker, Import checklist) |
DataGrid defaults |
| On a focused chart: arrows, Ctrl+arrow, A (beta.35, D90) | Pan, zoom, show all — ScottPlot's keys; the key is then the chart's, so the page neither scrolls nor moves the focus on (Tab still leaves) | Charts/ChartPlot, Charts/ChartKeys |
| Esc | Closes the open ContentDialog or MessageBox with no result — the same as its Close/Cancel button |
DialogKeyboard, one class handler per dialog type registered at start-up |
| Enter | In the consent dialog's phrase box: enables hooking once the phrase is typed exactly, does nothing before (beta.30, D69); elsewhere in a ContentDialog, the default button |
WPF's default button (ConsentPrompt: DefaultButton = Primary) and ConsentDialogContent.SwallowsEnter |
Focus after a dialog, and motion (beta.35). A ContentDialog gives the focus back to the control that opened it: WPF
UI 4.3.0's ContentDialogHostController stores Keyboard.FocusedElement when the dialog opens and focuses it again, at
DispatcherPriority.Input, when it closes — the App adds nothing, and
FocusAndMotionTests.AContentDialogGivesTheFocusBackToTheControlThatOpenedIt holds it (a first measurement said
otherwise; it ran on a thread with no dispatcher context, where the dialog's own finally never resumed). A WPF UI
MessageBox sets no owner — null before and after it is shown — so Services/MessageBoxes gives it the App's active
window: it opens over it and hands the focus back to it, not to another program; every box goes through it
(EveryMessageBoxGoesThroughMessageBoxes). A page slides in only while Windows' animation effects are on
(SystemParameters.ClientAreaAnimation, followed as it changes): Services/PageMotion sets the NavigationView's
Transition to None while they are off, where WPF UI 4.3.0 played FadeInWithSlide whatever they were.
Esc is the Close button, never the primary one. On the consent dialog (FR-2.1) that is "Keep it off" "Keep hooking
off" (the button's text, corrected 2026-10-07): nothing is
stamped. A dialog that offers no Close button is not dismissed by Esc, and the Legal Gate (FR-11) is a window of its own
(FirstRunWindow) with explicit Decline and Accept, on which Esc does nothing. WPF UI 4.3.0 handles no key in
either dialog type (its ContentDialog.cs and MessageBox.cs at tag 4.3.0 have no key handler — read 2026-09-15),
which is why the handler is ours. (Corrected 2026-10-26, beta.30: its code handles none, but ContentDialog's
TEMPLATE binds each button's IsDefault to DefaultButton and makes Close IsCancel — WPF's default and cancel
buttons, read at the 4.3.0 tag. So Enter goes to the default button: in the consent dialog that was Close until
beta.30, and a typed phrase followed by Enter declined (the owner's report; D69 above in the table). Esc reaches
DialogKeyboard first — it handles the bubbling KeyDown, and WPF's access keys run after the routing and skip a
handled key — so whether Esc alone would close a dialog through IsCancel is read from the template, not measured.)
Screen readers
- Every interactive control that shows no text of its own carries
AutomationProperties.Namefrom.resx— the toggles and choice boxes on Settings, the hooking switch on a game's page, and the icon-only close button in theInfoBartemplate. A control with visible text needs nothing: its text is its name. PagesLoadTests-style scan (AccessibilityTests.~~EveryTextlessControlHasAName~~ EveryInputThatShowsNoTextHasAnAutomationName— corrected 2026-10-04): everyButton,ToggleButton,ToggleSwitch,CheckBox,RadioButton,ComboBox,TextBox,NumberBox,PasswordBox,SliderandHyperlinkButtonin the App's XAML either has content or a name. A new unnamed one is red.- What a screen reader is given, swept on every surface (beta.35, D88).
PagesLoadTests.Automationhosts every page, window, dialog and control as the App hosts it, every tab shown in turn, and reads the UI Automation tree WPF builds — the tree Narrator reads: no Tab stop without an automation peer (a plainControl, WPF UI'sImage,CardandCardControltake the focus with no peer or an empty name), no item named by its type (WPF names a list's, a drop-down's and a grid row's item byToString(), and a template column's cell, which has no text of its own, byItem: <row>, Column Display Index: n), every focusable control named, no shown text hidden in a template (aTextBlockwhose templated parent is not aContentPresenteris no control element), and no two buttons in a list sharing a name. All five went red onmainfirst — the type-named items filled 190 lines over the surfaces and their tabs, the silent stops 37, and the safety InfoBar's title and message were hidden — and the fixes are: every item type speaks (ToString()throughServices/SpokenText:Choiceits label, a notice its title and text, a document page its title, a session row its date, length and tier…); the display-only controls (FpsReadout,TriStateChip,ChangeBadge) have aControls/SpokenTextAutomationPeer— a Text element named by their words, no children — and leave the tab order; a template column names its cells throughControls/CellName(a cell style based on WPF UI'sDefaultDataGridCellStyle, an empty cell read as empty); a row's button names its row (Open: …, Play: …, Turn off: …); the App's InfoBar template draws its title and message throughContentPresenters; implicit styles take a plainItemsControl, WPF UI'sImageandCardControlout of the tab order; aCardExpander's expand button is named after its header (Controls/ExpanderToggleName— WPF UI 4.3.0 leaves it unnamed). The FPS readout says rule 6 aloud: Native 62 FPS, displayed 118 FPS, frame generation ×1.9, a steady factor with its share, a stand-alone number with its qualifier (FpsPresentation.Spoken).ScreenReaderNamesTestsholds each piece. - Headings (beta.35, owner decision D90). A page's title (
FontTypography="Title") isAutomationProperties.HeadingLevel="Level1", a section title (Subtitle)Level2; aSubtitlethat shows a value — the Dashboard's three figures, a stat card's value, the FPS readout's line — saysNoneon purpose.AccessibilityTests.EveryTitleAndSubtitleDeclaresAHeadingLevel(every Title and Subtitle declares one),PagesLoadTests.EveryPageHasOneFirstLevelHeadingItsTitle. A rendered document's headings (the guide, LIMITATIONS, this statement, the legal texts) cannot be: aFlowDocumentParagraphhas no automation peer, so it has no heading level to give — stated inACCESSIBILITY.md§Known limitations. - Charts (beta.35, D90). Every plot is a
Charts/ChartPlot— ScottPlot'sWpfPlotwith a peer: an Image whose localized type is chart, named by itsAutomationProperties.Name(A11y_Chart_*), its help text where its numbers are as text (A11y_ChartData_*) and its keys (A11y_Chart_Keys); no children. Its focus is drawn with WPF UI'sDefaultControlFocusVisualStyle. No two series of a chart differ by colour alone (Charts/ChartPatterns: lines cycle solid / dashed / dotted / densely dashed, then take markers; point series cycle circle / triangle / square / diamond; the power and thermal limit spans are striped and dotted) —PagesLoadTests.NoChartTellsTwoSeriesApartByColourAlonereads every chart's legend on every surface and the Compare chart with five sessions. - What appears is said as it appears (beta.35, owner decision D89).
Services/IAnnouncer, over UI Automation's notification event inServices/UiaAnnouncer— the one place the App raises it, on its active window only (a game that has the screen is never interrupted; the tray's Windows notifications cover a hidden window) and only when a screen reader listens (AutomationPeer.ListenerExists). An Alert (ImportantAll, every one read): a safety notice as it arrives (SafetyNotices), a warning in the strip, the capture agent going offline, a game page's refusal or warning. A Status (MostRecentper activity, a newer one replacing one not yet read): the strip's info and success, the agent back (A11y_Agent_Connected), an update's step (Services/ShellAnnouncementssays a change only — the first state is read with the window, a download's percent ticks are one step, a rebuilt window re-reads the same state silently), a game page's success, every Database maintenance result line. The words are the window's, in its language.AnnouncementsTests,DatabaseMaintenanceViewModelTests.AResultIsSaidToAScreenReaderAsItAppears. Status lines that change after an action (the Database maintenance result) are(Corrected 2026-11-09: this announces nothing. WPF raisesAutomationProperties.LiveSetting="Polite".LiveRegionChangedonly when the app raises it — "you explicitly raise an event", Microsoft's What's new in accessibility for 4.7.1 — andTextBlockAutomationPeerraises none (dotnet/wpf); the App raised no automation event anywhere. The setting marks the line as a live region and no more. It came out the same day, for the announcement above; no XAML may set one.)
Contrast
Colours come from the WPF UI theme dictionaries and nothing else, so contrast is the Fluent themes' — both of which
meet it — and cannot be broken locally: AccessibilityTests.NoXamlHardCodesAColour fails on any #RRGGBB or named
colour in the App's XAML. The chart palette is the one a deliberate exception (16_WPFUI_SYNTAX §ScottPlot: one
palette per theme, chosen with the theme). (Corrected 2026-10-14, beta.23: the game page's artwork band is the second —
a colour worked out at run time from the artwork and the theme's own text and fill colours, at the strongest opacity at
which every text on it keeps 4.5:1 (tertiary 3:1), so it is held by construction rather than by the theme;
ColorMathTests checks the hardest colours in both themes against the tests' own WCAG, and PagesLoadTests measures the
rendered band. Its banner's fade is an alpha mask set in code, no colour at all.) (beta.30: the change markers' badges
and their chips in the list are the palette's orange under black or white chosen by contrast — ChartTheme.TextOn,
black in both themes, 11.79:1 and 8.00:1, where ScottPlot's white label read 1.78:1 and 2.63:1;
ChartMathTests.AChangeBadgesTextReadsOnItsOrangeInEachTheme. The orange LINE stays under 3:1 against the light
theme's background, as it was before; the badge and the list carry its information.)
"Cannot be broken locally" had a hole, closed 2026-09-16.
ui:Badge Appearance="Info"— the Games card's "Hooking on/off" and the edit dialog's "Detected" — paints its background with WPF UI'sPaletteLightBlueBrush, a fixed Material colour fromPalette.xamlthat is not in either theme dictionary, under the theme's white text:#03A9F4at 2.6:1 in dark, below AA-large, and no#in our XAML for the scan to catch. The hooking state is now aBorderin theHookStatePillstyle (ON: the accent pair the ×FG chip uses; OFF: the Pill's muted fill with secondary text), the Detected badge isSecondary, andContrastTestsholds it two ways: noui:Badgein the App's XAML usesAppearance="Info"(orCaution/Danger/Success— the same palette), and the WCAG ratio of every pill's (text, fill) pair, composited over the card and window backgrounds, is ≥ 4.5 in both theme dictionaries — with the old pair asserted below it, so the check is known to bite. The accent pair is measured against WPF UI's default accent; a user's system accent replaces it at runtime throughApplicationThemeManager, and WPF UI picks the on-accent text for it.And
Secondarywas a second hole, closed 2026-09-21 (the owner's screenshot: two empty white boxes where a Steam title's platform and engine were, beside a readable "Hooking off"). WPF UI 4.3.0'sSecondarytrigger repaints only the badge's background (ControlFillColorDefault);ForegroundstaysBadgeForeground, the on-accent colour of the DEFAULT badge, which in the light theme is near-white text on a near-white fill. The hooking pill beside it was readable because it sets its own foreground. The platform and engine tags and the Detected marker are now aBorderin theTagPillstyle withTagPillText(secondary text on the Pill's fill — the pairContrastTestsalready measures in both themes as "hooking off"), andContrastTests.NoBadgeUsesTheSecondaryAppearancerefuses a literalAppearance="Secondary"badge in the App's XAML. The title bar's Agent badge binds its appearance and never binds Secondary.The Dashboard's FG qualifier chip was reported with it and had the other defect: not contrast (caution fill under primary text, ≈ 12:1) but clipping — the pill sat in a star column with no trimming, so a sentence-length qualifier overflowed the row. The qualifier text trims with an ellipsis at 260 px (the readout's tooltip carries the full sentence), and the row's readout column is sized to content with the game's name trimming first.
A third hole, closed 2026-10-05 (beta.14; the owner's screenshot of File ▸ Import library in the dark theme: every row white, its text invisible, each tick box a sliver). A style
BasedOn="{StaticResource {x:Type DataGridRow}}", added in beta.11 to dim the rows already in the library: WPF UI 4.3.0 keys its row styleDefaultDataGridRowStyleand defines no implicit one, so the lookup fell through to Aero2's row and itsSystemColors.WindowBrush— a white no theme reaches, under the dark theme's white text. No#in our XAML, no palette badge: neither check above could see it, and light-theme rows read fine. The tick boxes were WPF UI'sCheckBox(MinWidth120, padding 11) in a 40 px column. Held three ways:AccessibilityTests.NoStyleIsBasedOnAnImplicitStyleTheThemeDoesNotDefine(everyBasedOntype has a style in the App's dictionaries),ImportReviewRenderTests(the rendered dialog, both themes: every cell's text against the composited colour painted under it ≥ 4.5:1, each ticked box drawn whole), andAccessibilityTests.NoDataGridCheckBoxColumn(Compare's checkbox column drew an Aero2 box). Each went red on the unfixed XAML before it went green.A fourth hole, closed 2026-10-07 (beta.17; the owner's screenshots of Settings after a theme switch: its descriptions light grey on white in Light, dark grey on dark in Dark). Every check above measures a theme as a surface is made under it; a switch while the surface is on screen is a different question. WPF UI 4.3.0's
ui:TextBlock Appearance="Secondary|Tertiary"— 129 texts in 20 files, nearly every description and caption — looks its brush up once and keeps it (16_WPFUI_SYNTAX§Gotchas), so the page on screen during a switch kept the old theme's muted text: Settings above all, where the theme is chosen. Pages are made again on each navigation, which is why only the page in view showed it. Those texts take theSecondaryText/TertiaryTextstyles now. Held two ways:ContrastTests.NoTextBlockTakesItsColourFromAppearance(noAppearanceon a TextBlock in any form, nor its code form), andPagesLoadTests.EveryTextFollowsAThemeSwitch(every page, the first run, About, the user guide, a session's summary, every dialog's content and the safety InfoBar, made under one theme, switched, and compared text by text with the same surface made fresh under the other — both ways). Both went red on the unfixed XAML, the second with 146 stale texts each way, before they went green.A fifth hole, closed 2026-10-07 (beta.18; the owner's screenshots of beta.17 in the dark theme: every page's title and section headings near-black on the dark window — beta.16's screenshot shows it too). This text had no colour of ours, because it had none. A page is shown in WPF UI's
NavigationViewContentPresenter, aFrame, and a Frame passes no inherited value into its page (InheritanceBehavior.SkipToAppNow), so a text that sets no colour falls to the TextBlock default, which WPF UI 4.3.0 makes black (16_WPFUI_SYNTAX§Gotchas). Cards, grids and controls set their own; the bare titles and headings did not: 19 texts on the six pages at 1.29:1. Every check above laid a page out straight in a window, whose text colour the page then inherited — a page the App never draws — and a page on screen during a theme switch did take the window's colour, while each navigation makes a new one that does not, so it came and went. Every page setsForeground="{DynamicResource TextFillColorPrimaryBrush}"on its root. Held two ways:AccessibilityTests.EveryPageSetsItsOwnTextColour, andPagesLoadTests.EveryTextIsReadableInBothThemes— every surface hosted as the App hosts it, a page in the presenter, and every text that shows ≥ 3:1 over the colour painted under it, in both themes.EveryTextFollowsAThemeSwitchhosts its pages in the presenter too since, and went red with them: a page made after a switch stayed black. All three went red on the unfixed XAML before they went green.
Windows contrast themes, followed (beta.35, owner decision D91). WPF UI 4.3.0 cannot be asked to do it:
ApplicationTheme.HighContrastnames no dictionary; its four high-contrast files (HC1 Dusk, HC2 Night sky, HCBlack Aquatic, HCWhite Desert) each hold 84 red#FFFF0000placeholders among 97 colours and 17 brushes that throw when the file is read alone; their colours are Windows 11's defaults, not the user's; and they put the window text on the accent. So whileSystemParameters.HighContrastis on,Services/WpfThemeApplierapplies the light or the dark Fluent theme as the contrast theme is (by its window colour), with no Mica and noSystemThemeWatcher, andServices/ContrastOverlayover it: every key of those four files in the user's colour for its role (Services/ContrastRoles— a key's role is the colour it has in all four, opaque colours only, because inside the App a brush that throws alone falls back to the Fluent theme's translucent fill:MenuBarItemBackgroundPressedread as the white of the window text, and a pressed menu item was white on white; ties and placeholders by the key's name), the keys transparent there transparent, three Fluent-only keys by role, the 21 accent keys WPF UI writes into the application's resources as the highlight, and the text on the accent as the highlight's text. The colours areSystemColors(ContrastPalette.FromSystem) — the user's own, edited or not, Windows 10's as well — and turning a theme on, editing it or turning it off is followed at once (SystemContrastSource). What the App draws itself readsContrastTheme.Active: the charts (ChartPalette.ForContrast, the theme's colours only, the series told apart byChartPatterns), a badge's text (ChartTheme.TextOn, the theme's colour that reads best on the fill), the mix bar, the artwork band (no tint), the Import list (no dimmed rows), the unsigned-update footer (the secondary text style, not an opacity). WPF UI's Danger button paints a fixed#F44336in its style, out of any resource's reach, so everyui:Buttontakes the App's implicit style (Styles/FrameLedger.xaml): a Danger button is the theme's own button while one is on, the message boxes' Delete included. Held byContrastThemeTests— the four files still placeholders; every key a role or transparent, none red; the roles the same over either Fluent theme; with each default theme's own colours the overlay is WPF UI's colours key for key, the text on the accent apart; an edited theme's colours reach every key; every Fluent colour key covered; every resource the App reads resolves;ThemePlan; the applier on and off at once — andPagesLoadTests.EveryTextIsInTheContrastThemesColoursAndReadable: every surface rendered under the four default themes and two edited ones, every text the theme's colour on the theme's colour at 4.5:1 or better. It went red first on the chips (window text on the highlight, 1.26–1.78:1), the Remove button (3.06–4.42:1 on#F44336) and the badges' black.
A sixth hole, closed 2026-11-09 (beta.35), found by measuring what no sweep renders. The title bar and the snackbars are no surface, and the 3:1 sweep let 3.68:1 pass. The capture agent's pill was a
ui:Badgewhose appearance was BOUND — Success, Info, Caution, Danger, WPF UI'sPalette*BrushunderBadgeForeground— soContrastTests, which reads literal attributes, never saw it: in the light theme 2.78, 2.63, 2.16 and 3.68:1. It isAgentPillnow (aPillonSystemFillColor{Success,Caution,Critical}BackgroundBrush, the theme's text), and a bound badge appearance is refused. WPF UI's Success and Caution snackbars are fixed colours under white in both themes, 2.78:1 and 2.16:1: the strip shows every message as Secondary, the theme's, 13.97:1 and 16.53:1, its icon saying the kind. And a Danger button's text was the theme's button text on#F44336— white in the dark theme, 3.68:1: the App's implicit button style putsTextFillColorDarkPrimaryBrushthere, 5.3:1 and 5.7:1.ContrastThemeTests.TheTitleBarsMarksReadInEveryState,ADangerButtonReadsInBothThemesAndIsTheThemesOwnButtonUnderAContrastTheme,NoButtonOrBadgeTakesAnAppearanceThatPaintsAFixedColourandAnnouncementsTests.EveryMessageOfTheStripIsDrawnInTheThemesOwnColourshold the three.
DPI
app.manifest declares Per-Monitor V2 (AccessibilityTests.TheManifestIsPerMonitorV2). A chart reads the pointer
through the element's DPI at that moment (WpfPlot.GetPlotPixelPosition, beta.30) — not WpfPlot.DisplayScale, which
ScottPlot reads once when the control is made, before it has a window.
Known gaps, stated
ScottPlot plots are not keyboard-operable (no focus, no pan/zoom by keys).(Corrected 2026-11-09, measured byChartKeyboardTestsin a window off the screen: a plot takes focus — ScottPlot's control is focusable and a Tab stop — and the keys ScottPlot reads reach it: the arrows pan, Ctrl with an arrow zooms, A shows all of it.What it is not is usable: it has no automation peer, so Narrator says nothing on reaching it, and it marks no key handled, so the page around it acts on the same arrow too.Since beta.35 it has a peer and keeps its keys, §Screen readers.) A chart's points are still not read one by one. The numbers behind them are on the session summary's stat cards and in File ▸ Export (CSV/JSON); the hardware-change markers' text is WPF text in the list under each trend chart (beta.30).No screen-reader pass with Narrator has been done; the names above are necessary, not proven sufficient. That pass is the owner's.The owner's pass, 2026-11-09: keyboard only with the mouse disconnected, and Narrator, on 0.1.0-beta.34 and 0.1.0-alpha.3 — every page, menu, dialog and setting reached and used, no fault.- What that pass could not show, found the same day by measuring the UI Automation tree WPF builds (in memory, on
.NET 10.0.14 — not by listening):
a drop-down's items are named by a record's printed form ((closed the same day, §Screen readers above);Choice { Value = dark, Label = Dark }) and plain lists' items by their type; a control with no automation peer that still takes focus — a chart, the FPS readout, the RT/PT/RR chips, the game's artwork — is a Tab stop Narrator says nothing about; text inside a control template (the safety notices' title and message, the readout, the chips) is hidden from the control view; nothing is announced; no text is a heading; several charts tell series apart by colour alonepage transitions play with Windows' animation effects off(not since beta.35, §Keyboard);Windows contrast themes are not followed(followed since beta.35, D91 — §Contrast).ACCESSIBILITY.md§Known limitations states each to users with what to do instead.