Files
frameledger/docs/08_UI.md
T
poli0981andClaude Opus 5.5 24a87159f4 fix: the owner's eight sessions of 2026-10-20 - a x2.52 state, the driver's DLSS word lost at exit, Start directly losing the game Steam starts, two summary windows, display sizes, a bare DLSS line; the Steam note; the two load-flaky tests (beta.27 PR-1) (#330)
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>
2026-10-20 10:31:47 +07:00

113 KiB
Raw Blame History

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-dir stays 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… · Documentation Online 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.md as the build embeds it (Services.LimitationsDocument), in a read-only, scrolling WPF UI MessageBox with Open on GitHub window of its own since beta.12 (Windows/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/ — eight short 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 a Windows/DocumentWindow with 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. GuideDocumentsTests holds 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 WPF FlowDocument inside Controls/MarkdownView (a read-only FlowDocumentScrollViewer: 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, and MarkdownRendererTests proves for every embedded document that no word of its plain text is lost and no table is left as |---| source. The GPL's LICENSE is 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 follow Markdown/MarkdownLinks: http, https and mailto through IUrlOpener; #section scrolls 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 by release.yml; main for a local build — every link said blob/main before); 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 is Windows/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.md and the package index, rendered, and Open the licences folder (the published licenses\; 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, SessionExportService over 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… runs BugReportFlow (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 checklist ImportReviewPrompt / Dialogs/ImportReviewContent, a DataGrid with 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 of 11_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): a ContentDialog (Dialogs/DatabaseMaintenanceContent, ViewModels/DatabaseMaintenanceViewModel) with four cards — Check integrity, Back up…, Sweep raw data…, Compact — and one status line; the sweep confirms in a MessageBox with 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: NotYetCommand and 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 offline InfoBar with Retry, SnackbarPresenter and ContentDialogHost. The Dashboard shows the Agent status card (HelloAck/StatusAck, every value N/A until answered); Games, Compare and Logs are empty states; Settings has Appearance (theme + language, both persisted in settings — D16's ui.theme/ui.language). The App starts FrameLedger.Agent.exe --serve beside 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/TrayHost over TrayViewModel (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 (one PauseCapture/ResumeCapture request; the state shown is the PauseAck's, never assumed), Agent status (the Dashboard), Exit (a real exit through ShellHost.Quit, whatever minimize-to-tray says); a left click opens the window. Minimize to tray on close hides the live window when ui.minimize_to_tray is 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's the 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 is Services.SessionNotices now, one subscription for the App's life; the Dashboard listens only while it is on screen.) A safety event is never a balloon (TrayViewModelTests asserts 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): ISnackbarService snackbar, 4 s.
  • In-app, persistent (Agent offline, PawnIO missing, update downloaded, a viewer's folder, the safety notices): ui:InfoBar banner 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/SafetyNotices subscribes to the pipe's events and turns CaptureRefused, SafetyUnhook and CaptureDegraded into SafetyNotices the shell renders as an ItemsControl of ui:InfoBars in MainWindow row 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 the Safety_* family (Safety_Refused_Named_Format with the family and the signal, _Unnamed, _CouldNotVerify, Safety_Unhooked_Format) followed on a refusal by Notice_Refused_Recording ("the session is still recorded — duration and hardware telemetry — with every frame-derived value at N/A"). The one button is Safety_RecordWithoutMeasuring on a refusal and Dismiss otherwise; it removes the notice and does nothing else, because the Agent already records Tier 2 on a refusal (owner decision 2026-08-28) — the button is the user's acknowledgement, not a second request. (That sentence became true on 2026-09-22: until then every refused session was discarded under the minimum length, and for one day TargetUnreadable omitted the "still recorded" sentence for that reason. 04_CAPTURE §Tier selection.) The session summary of a Tier-2 row says WHY under its Tier-2 sentence (Formats.Tier2Reason over capture_notes: hooking off, the block on the row, the guard's family and signal, a process that could not be opened, or the end reason by name — Summary_Tier2_Why_*). CaptureError (non-fatal) goes to the 4 s strip. The safety documentation link lives on the Settings page's Capture section rather than in every notice. Tests: SafetyNoticesTests (the three kinds, the sentence per refusal reason, the strip for errors, nothing for a session event, dismiss only by the user).

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 a BlockedService / BlockedDriver refusal reads Safety_Refused_MachineWide_Format ("… is running on this PC (…): a driver or service, which may belong to another game or program …"), an unhook Safety_Unhooked_MachineWide_Format, and the summary's Tier-2 reason Summary_Tier2_Why_MachineWide_Format; a module, a title list or a file in the game still reads "in this game". Safety_Unhooked_Format lost "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, which Safety_HookingTurnedOff then says). Without a guardReason — 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 reads End_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 reads Safety_Unhooked_Unnamed_Format ("Capture stopped while the game was running — the game's process could not be opened — and FrameLedger unhooked."). And CaptureDegraded printed 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."), and Notice_Degraded_Unknown_Format names only a reason this build has no words for. Tests: NoticesFromTheAgentTests builds 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 InfoBar template has no ContentPresenter, so the action button above — placed as the InfoBar's Content, the only dismissal once IsClosable="False" removed the X — was never rendered. The view model was right and the screen was wrong. Styles/FrameLedger.xaml now 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 by PagesLoadTests.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) sends HookingTurnedOff when it turned off hooking the user had turned on; SafetyNotices makes it a SafetyNotice of kind HookingOff — Error, persistent like the others, titled "{game}: hooking turned off" (Notice_HookingOff_Title_Format), the refusal sentence naming the family and the signal followed by Safety_HookingTurnedOff. It has no Notice_Refused_Recording and its button is Dismiss, not Safety_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 → 144 FPS — "not detected" was two states, and they need two looks (2026-09-03, 03_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 FPS as 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 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 = steady the readout is the generated shape — 58 → 116 FPS with 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_mode names a technology and fg_factor is 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 printed N/A → N/A FPS (×0.0 FG) — a factor nobody counted — while the game page said DLSS-G and the grid said N/A. Now: 304 FPS as Presented FPS with a ⚠ warning chip "DLSS-G active — factor not counted", tooltip = the row's fg_refusal in 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 from fg_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 reads DLSS-G · factor not counted; Displayed and FG× say N/A (no factor exists, and it is not a measured none). Never the word "Native", never a factor. The fg_runtime_loaded chip also names the module now (FG runtime loaded (sl.dlss_g.dll) — may include generated frames) from fg_runtime_census, as this rule always asked. FpsPresentation.FrameGenerationLabel is the one place the page and the live card build the label.
  • Tables get three columns (Native / Displayed / FG×); Displayed and FG× render — when fg_mode = none and N/A when 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 → ui:Flyout to override (corrected 2026-10-04: the source is the chip's tooltip, and a click opens FR-8.3's dialog, TriStateOverridePrompt — 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 as InfoBadge: 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), measured renderW×H → outputW×H with upscaler + quality, RT-active dot, CPU/GPU temp, per-process VRAM the 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 by SessionProgress. 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:Card row).

Built 2026-09-14 (P3 PR-5): the Agent card, the live card, the recent list, the totals. The live card is LiveCaptureViewModel over the pipe's SessionStarted / SessionProgress / SessionCompleted (marshalled through the captured SynchronizationContext): game, tier badge, elapsed, the FpsReadout at 1 Hz under the display rule (Presented FPS with its census chip until frame generation is measured), the measured renderW×H → outputW×H with 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, SummariseByGameAsync playtime, 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.Tier2HoldReason over the start's hold, the same words Tier2Reason reads from capture_notes) — and no FpsReadout at all. A session the status lists at tier 2 with no hold has 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-lifetime LiveSessions when 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 a faulted completion is no notice (the strip's CaptureError already 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:AutoSuggestBox search.

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 now Controls.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 is ui.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.ExecutableExists and Formats.ExecutableMissingText, asked off the UI thread on every listing, never stored; nothing is removed for it since 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 hears GameRemoved, 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 waits GamesViewModel.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's SnackbarService shows 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:CardControl with ToggleSwitch): 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, an InfoBar explains and offers manual re-enable.

What opening the page and choosing a session cost, beta.23 (owner request 2026-10-14; spike-notes §21). The Sessions grid is bounded (MaxHeight 520, 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 whatever ConfigureAwait said — 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_path relative 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's appcache\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's webcache\<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_metadata stays 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's covers, 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), …TheArtworkBandFollowsAThemeSwitch and …TheGamePagesArtworkIsDrawn with AccessibilityTests.NoStyleOfAWpfUiControlLeavesOutItsTemplate (the cover once took its place and drew nothing, a ui:Image style 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:CardAction cards with platform / engine / hooking badges, sessions, playtime, last played (the sparkline is PR-6's no 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 .exe dropped on the page (a .lnk needs the shell-link reader, later); FR-1.4 through Wpf.Ui.Controls.MessageBox with 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's FpsReadout, the three chips resolved with the annotation and the game default — Application.TriState.TriStateResolution), Edit… (FR-1.3, a ContentDialog badging 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 in Program.Main after Velopack's hooks and before any window; a later start sets the event and exits 0, and the first instance brings its window forward through ShellHost.Reveal — from the tray too. Nothing stopped a second App before: the owner's log shows two started 360 ms apart, two tray icons, a second log file. --diag never claims), the guard-bypass switch since 2026-09-21 withdrawn 2026-09-22 (the card, its dialog, the session mark and the export line are gone; a blocked row's toggle is disabled and Safety_Blocked_Toggle_Format is the whole story; a refusal or unhook notice that turned hooking off ends with Safety_HookingTurnedOff — 19_SAFETY §What a finding does to the game), Supports (from capability_flags; empty until P4's scan writes it, and the card says so written by the Agent's detection sweep since P4 PR-1, 2026-09-14 — the rule ids as product names via CapabilityNames, "not scanned yet" only until the Agent's next tick) beside Last session measured (upscaler · resolution, frame generation, the non-N/A chips — accent pills, from the hooks). Hooking: the toggle is OneWay from the row and its command runs HookingConsent; a refusal, a mismatch or a failure is a persistent InfoBar on the page (never a toast); a blocked row disables the switch with Safety_Blocked_Toggle_Format inline; an unverified pre-scan leaves it enabled and says so; auto-disabled shows Safety_AutoDisabled_Format with the re-enable button. Sessions tab: the DataGrid of FR-6.1 — every Tier-2 cell that is Tier-1-only reads N/A, a measured-none Displayed / FG× reads —, both with tooltips. Frametime / Distribution / Trend / Sensors / Latency say which build brings them (PR-6, PR-7). PagesLoadTests loads 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 a XamlParseException at first navigation.

The recording switch (2026-09-23, FR-1.6). A ui:CardControl Recording above the hooking control, its ToggleSwitch OneWay from games.record_sessions and its command writing the row through GameLibrary.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 that ContrastTests measures 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 while ui.hide_anticheat_hooking is 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 and Safety_Blocked_Toggle_Format under it. {what} is Services.BlockedReasonText over the stored Reason|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.ExceptionView over GameRow.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, text Safety_Exception_* versioned by AntiCheatExceptionDisclosure.Version, the primary button bound to the ticked I accept the risk of a ban for this game, Enter = Keep it blocked) and then SetAntiCheatException; 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:CardExpander Details 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 with Hooking_NotX64_Format under it and no re-enable bar — turning it on could only be refused (the Agent refuses ExecutableNotX64 anyway); a switch already on can still be turned off. Tests: GameDetailViewModelTests.TheDetailsCardSaysWhatTheFilesSayAndAnX86SwitchCannotBeTurnedOn, FormatsTests, and the page renders in PagesLoadTests. 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 library Game.ini names or Ren'Py's renpy/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):
    1. 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).
    2. Frametime — ScottPlot timeline of selected session (decimated), stutter markers, sensor overlay toggle (temp on right axis).
    3. Distribution — FPS histogram + percentile curve of selected session(s).
    4. 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).

Across sessions, beta.11 (owner decision D39, FR-6.6). The Sessions tab opens with Sessions at a glance: a TrendChart of 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/A for 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 and sensor_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 read vram_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 / DistributionChart as 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 of settings_changed_midsession sessions 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 with the game's own per-present vram_proc (a held 1 Hz sample) and the adapter-wide vram_adapter sensor as two differently-labelled series (corrected 2026-10-03: the Overlay never produced vram_proc, so the game's line was never drawn on any session; beta.12's two memory plots are described above). Latency: the latency_us blob 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 TrendPresented to 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 (DateTimeTicksBottom replaces 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 through Formats.FpsNumber: "62.40" when on, "62" when off, rounded half away from zero both ways (it rounded half to even). Services.FpsDecimals holds it for the process like LoggingLevel: 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 Foreground on 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 (AutoScale ran after SetLimitsX and 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's platform is not trusted, detection may have rewritten it while store_id stayed the importer's) — Steam steam://rungameid/<id>, the Epic Games Launcher com.epicgames.launcher://apps/<ns>%3A<item>%3A<app>?action=launch&silent=true, GOG GALAXY GalaxyClient.exe /command=runGame /gameId=<id> /path="<folder>", the itch app itch://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 sends LaunchGame (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 no ShellStarter. 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.SteamGame from 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), and native_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_MixNone and Chart_MixUnclassified for the other two — following a theme switch through ApplicationBackgroundColor as ArtTint does; announced by its AutomationProperties.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 in PagesLoadTests carries 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/RenderScaleChart over RenderScaleSeries: 100 × √(render pixels / output pixels) as steps — from the render_res blob 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 secondary FluentWindow with its own ContentDialogHost), 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 through TriStateResolution and click into FR-8.3's dialog (TriStateOverridePrompt: measured / Yes / No / N/A, "also this game's default"); the override lands on session_annotations, the measurement stays, clearing restores it. Bars: crash (Error), safety unhook (Warning). Charts (Charts/): SessionSeriesLoader decodes the blobs once — cumulative time, the generated and gap bits, the application-frame view with Domain.Metrics.StutterDetector over it (the stored count's own rule), segments mapped from frame index to seconds, sensors aligned to t_ms with −1 dropped; FrametimeChart draws 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 where pso_created says 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; DistributionChart draws 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. SessionSeriesLoader charts 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_evaluations refusal) 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_ms says 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 SessionCompleted for this game reloads it (GameDetailViewModel.Attach / Detach on 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 with 03_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 that vram_mb is 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 through Plot.SavePng. Tags (comma-separated, de-duplicated) and notes save to the annotation row. FR-3.8 is an in-app notice on SessionCompleted (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's 2,8,0,0 string equals 2.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 every SessionEndReason (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). CompareViewModel over the last 200 sessions across games: a DataGrid picker with a checkbox column (Compare enabled at 2–5), the FR-6.4 warning icon per row; Compare asks IMixedTierPrompt (a ContentDialog, default button Cancel) when the selection mixes tiers and compares nothing on a decline; a comparison that proceeds carries Compare_Mixed_Legend as the plot's title and an InfoBar. CompareChart overlays 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 through Plot.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). LogsViewModel over Services/LogTail: the newest file of the chosen source (App / Agent) read with FileShare.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.12 LogTail.LevelOf reads both) — continuation lines such as stack frames keep only under All; the search is a plain ui:TextBox, not an AutoSuggestBox — there is nothing to suggest. The view is a read-only TextBox in 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 in PagesLoadTests.

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, so Services.ScrollBarHiding sets the scrollers themselves: one class handler on ScrollViewer's Loaded (registered at start beside DialogKeyboard) reaches every scroller the App shows class handlers on ScrollViewer's ScrollChanged and Loaded (registered at start beside DialogKeyboard) 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 is Auto or Visible becomes Hidden — WPF's "no bar, still scrolls": wheel, keyboard and touch — and its own value is kept on it; a Disabled axis 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_ARCHITECTURE ADR-9). The Agent section has a switch, Run the agent as administrator (capture.run_elevated, off by default). Turning it on opens a ContentDialog (Services.AgentAdminPrompt, text FrameLedger.Shared's Safety_AdminMode_*, version agent-admin-dialog/1 in its corner) whose primary button is enabled only by ticking "I understand…" and whose default button keeps standard rights; declined, nothing is written. Either way the row is written and the Agent restarts — asked to stop over the pipe, its instance lock waited out, the connection's next round starting it the new way — except under a running session, which the restart would end: then the snackbar says the change applies at the Agent's next start. The elevation line says why a standard user's Agent is one when Windows was asked (HelloAck.ElevationOutcome: declined, answered by another account, could not start), and while the prompt waits the status pill reads Waiting for administrator permission (AgentConnectionState.Elevating).

Built 2026-09-14 (P3 PR-8a), with three rows deferred to PR-8b and one to PR-9. SettingsViewModel over Application.Settings.RegisteredSettings (the registry of 06_DATA_MODEL §Settings registry — every write is one settings row, 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 a CardExpander whose header is the toggle and whose state line says "All hooking is off" / "Per-game settings decide" — it is hooking.kill_switch, the gate's fourth input (CaptureSession consults 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 is games.hook_enabled as the ledger has it, and its per-row "Turn off" is HookingConsent.DisableAsync — SetHookEnabled { enabled: false } over the pipe, the Agent clears the column, the App never writes a hook-state column (D15; SettingsViewModelTests asserts the row is still enabled after a fake Agent acked); the Vulkan layer row reads HelloAck.VulkanLayerRegistered and says "unknown" without a HelloAck; the safety link opens 19_SAFETY_AND_ANTICHEAT.md at the public repository in the user's browser (nothing is fetched). Recording: minimum session length, sensor interval and raw-series retention as ui: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 wrote capture.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 from HelloAck.Elevated with 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" is Infrastructure.Startup.RunAtLogon — this user's HKCU\…\Run value, 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: privacy.online_metadata, off by default, with the network sentence — the card is not shown since 2026-09-16 (no code makes the request; the setting stays reserved). Updates: update.channel is 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), and update.auto_check — the startup check, on by default — sits beside it. Logging: log.debug moves this app's LoggingLevelSwitch at 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 in PagesLoadTests.

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 and a game has hooking on a hook-enabled game references the Vulkan loader (P4 PR-2, 2026-09-14: HookedGameViewModel.UsesVulkan from capability_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

  1. 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_acceptance row (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, through IUrlOpener.
  2. 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.
  3. 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.
  4. Optional library import.

Built 2026-09-14 (P3 PR-9). Windows/FirstRunWindow around Controls/FirstRunContent over FirstRunViewModel, shown by ApplicationHostService before the shell whenever Services/LegalGate says 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 root LICENSE as 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 for release.yml), a list on the left, the text in a read-only box (raw Markdown rendered since beta.12), "View on GitHub" per document, one Accept that writes four three legal_acceptance rows with each document's own **Version:** line (GPL-3.0-only for the licence) (corrected 2026-10-04: since beta.12, D45, the GPL is shown for information and gets no row; an older gpl row 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 from HelloAck as 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 = four three 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 in PagesLoadTests.

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 most Decimator.DefaultBuckets × 2 points per series per draw whatever the session size (DecimatorTests over 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 the Page — 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 through ChartTheme.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.Name from .resx — the toggles and choice boxes on Settings, the hooking switch on a game's page, and the icon-only close button in the InfoBar template. A control with visible text needs nothing: its text is its name.
  • PagesLoadTests-style scan (AccessibilityTests.~~EveryTextlessControlHasAName~~ EveryInputThatShowsNoTextHasAnAutomationName — corrected 2026-10-04): every Button, ToggleButton, ToggleSwitch, CheckBox, RadioButton, ComboBox, TextBox, NumberBox, PasswordBox, Slider and HyperlinkButton in 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's PaletteLightBlueBrush, a fixed Material colour from Palette.xaml that is not in either theme dictionary, under the theme's white text: #03A9F4 at 2.6:1 in dark, below AA-large, and no # in our XAML for the scan to catch. The hooking state is now a Border in the HookStatePill style (ON: the accent pair the ×FG chip uses; OFF: the Pill's muted fill with secondary text), the Detected badge is Secondary, and ContrastTests holds it two ways: no ui:Badge in the App's XAML uses Appearance="Info" (or Caution/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 through ApplicationThemeManager, and WPF UI picks the on-accent text for it.

And Secondary was 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's Secondary trigger repaints only the badge's background (ControlFillColorDefault); Foreground stays BadgeForeground, 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 a Border in the TagPill style with TagPillText (secondary text on the Pill's fill — the pair ContrastTests already measures in both themes as "hooking off"), and ContrastTests.NoBadgeUsesTheSecondaryAppearance refuses a literal Appearance="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 style DefaultDataGridRowStyle and defines no implicit one, so the lookup fell through to Aero2's row and its SystemColors.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's CheckBox (MinWidth 120, padding 11) in a 40 px column. Held three ways: AccessibilityTests.NoStyleIsBasedOnAnImplicitStyleTheThemeDoesNotDefine (every BasedOn type 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), and AccessibilityTests.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 the SecondaryText / TertiaryText styles now. Held two ways: ContrastTests.NoTextBlockTakesItsColourFromAppearance (no Appearance on a TextBlock in any form, nor its code form), and PagesLoadTests.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, a Frame, 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 sets Foreground="{DynamicResource TextFillColorPrimaryBrush}" on its root. Held two ways: AccessibilityTests.EveryPageSetsItsOwnTextColour, and PagesLoadTests.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. EveryTextFollowsAThemeSwitch hosts 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.