The owner ran the installed 0.1.0-beta.26 (sessions 64-71) and asked for the results to be checked, the two flaky tests fixed, bugs fixed, and a release if there were bugs. Read from a backup copy of the ledger and the logs (docs/spike-notes/23-owner-runs-2026-10-20.md). - FgWindow.IsNearWholeMultiplier: a window is a state's only within 10 % of a whole multiplier of two or more (FgSlices.Slice.IsActive); FgMixRecord.Parse reads stored rows by the same rule. Silent Hill 2 under Dynamic MFG listed x2.52 for 12.8 s - windows where the multiplier stepped; it now reads x2.0, x3.0, none and 7.36 % not classified. - NgxDriverState / CaptureSession: the driver is not asked after the game has gone, and CREATED | EVALUATE stand once a reading carried them. The last NGX reading, taken after the target exited, replaced every in-game one: none of the 14 answered sessions kept the two bits, so DLSS (driver-reported) and the NVIDIA App's mode (D63) never showed on an NGX-direct title. - CaptureOrchestrator: a launch says it ended on its own (Recorded) with the pids it recorded (Targets), so a process turned away while it ran - the game Steam starts after Lies of P hands itself over - is recorded when it ends; the launch's own process never is. - SessionSummaryOpener: one window per session; opening it again brings it forward. - DisplayTally: the sizes are the mode's last sample that saw the window (a game leaving exclusive fullscreen closes it first; five sessions stored none). - DlssText.Line: no line that says only "DLSS". - Tests: the guard's scan set includes the test host above the harness, which under a full gate releases modules while it starts its other classes - ModuleScanFailed (reproduced 1 run in 12 of the assembly with coverage; 15 of 15 green after), ProcessUnreadable on 2026-10-19. ShmDrainIntegrationTests.InjectAsync asks again on those two reasons only (4 times at most, 250 ms apart); the pause case waits for READY; every injection suite waits for the harness's flushed "presenting" line instead of 800 ms (tests/Shared/HarnessReady.cs). - Docs: 03_METRICS (the mix, the driver-reported rung, display sizes), 04_CAPTURE, 06_DATA_MODEL, 08_UI, 14_TESTING, 18_GPU_VENDOR_APIS, 19_SAFETY (direct starts counted by the crash safety - measured, the policy unchanged), LIMITATIONS, guide (troubleshooting, results), spike-notes section 23, HANDOFF items 20 and 21, CHANGELOG. Then, on the owner's word about Steam games (Play > Start directly says a Steam game may hand itself to Steam - the notice, the tooltip and Settings (en/vi/ja); why a note rather than a fixed Steam rule (beta.27 PR-1)): The owner, 2026-10-20: Steam games hand themselves to Steam; a note in the UI, or a fixed setting that Steam's games always go through the Steam client - the choice left open. The note: - GamePlayer: PlayResult.SteamGame - the game the agent starts (Start directly, or an App running as administrator, or a Steam record with no link) is one Steam's own records name; the notice then reads Play_Started_Steam_Format / Play_Elevated_Steam_Format. Store records are read once a press. - Strings: Play_ToolTip_Direct and Settings_PlayMode_Body say a Steam game may hand itself to Steam and the game Steam then starts is recorded; Settings adds that a few will not start outside Steam at all. en/vi/ja, ja marked review; Strings.Designer regenerated. - Why not the fixed rule: 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) - recorded in 08_UI. - Docs: 08_UI, guide/08-settings, LIMITATIONS, CHANGELOG. - Tests: GamePlayerTests (Steam started directly and elevated say it; a loose or GOG game does not). Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
113 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. Light/Dark/System themes via ApplicationThemeManager + SystemThemeWatcher; Mica backdrop on Windows 11 with automatic solid fallback on Windows 10. 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 — 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) · 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 · About FrameLedger (App / Developer / Third-party licenses tabs— built beta.12 as This app / Third-party licences / Legal documents, 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) — 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(Markdig 1.4.0, 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. - In-app, persistent (Agent offline,
PawnIO missing,update downloaded, a viewer's folder, the safety notices):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 card (visible during capture): 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.
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 library, beta.11 (owner requests 2026-10-03). The empty band on the right: the cards were 300 px in a plain
WrapPanel, 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)). 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.
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; 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— 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" — 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).
- 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"). 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; the metric list is built in the language the page opens in; the empty text names the metric.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).
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.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.
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).
CompareViewModelover the last 200 sessions 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.
Settings
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). 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/1in 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:privacy.online_metadata, off by default, with the network sentenceupdate.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. 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 no
legal_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 and double-click still resets, as ScottPlot does. 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.
Keyboard
| Keys | Does | Where |
|---|---|---|
| Ctrl+1 … Ctrl+5 (and the numeric keypad's 1–5) | Dashboard · Games · Compare · Logs · Settings | MainWindow InputBindings → MainWindowViewModel.NavigateToCommand → ShellShortcuts |
| Alt, F10 | Focuses the menu bar; arrows and Enter walk File / Tools / Help | WPF Menu, nothing custom |
| 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 |
| 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 |
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.
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.- Status lines that change after an action (the Database maintenance result) are
AutomationProperties.LiveSetting="Polite".
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.)
"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.
DPI
app.manifest declares Per-Monitor V2 (AccessibilityTests.TheManifestIsPerMonitorV2).
Known gaps, stated
- ScottPlot plots are not keyboard-operable (no focus, no pan/zoom by keys). The numbers behind them are on the session summary's stat cards and in File ▸ Export (CSV/JSON).
- No screen-reader pass with Narrator has been done; the names above are necessary, not proven sufficient. That pass is the owner's.