Table of Contents

SavePoint v2 - decisions

The behavioral spec is the unpublished v1 plan (plan.md) and the inventories of v1's code; the screens follow v1's visual design, the mockup D22 and D40 refer to. This file records only where v2 departs from that spec or fills a gap in it. Each entry gives the decision, then the reason.

D1. Rewrite in C# / .NET 10 with Avalonia UI

The plan fixed Electron + TypeScript. The rewrite rules out TypeScript and calls for a native desktop stack, so v2 uses C# on .NET 10 with Avalonia UI:

  • No browser runtime, and a smaller memory footprint than Electron.
  • Avalonia runs on Windows, macOS and Linux, which keeps the plan's promise that a Linux/macOS adapter is additive. WPF and WinUI are Windows-only.
  • .NET covers what the TypeScript app needed npm packages for: Process with Kill(entireProcessTree: true) (replaces the hand-rolled taskkill tree kill; Linux git gets its own stop-then-kill walk, D31.11), process enumeration (replaces ps-list), DriveInfo (free space), FileVersionInfo (exe version), System.Text.Json (catalog), ArgumentList (no shell quoting of git arguments).
  • Mature test tooling (xUnit) and headless UI testing (Avalonia.Headless), including rendering screens to PNG for visual review.

D2. Keep the git-backed engine and bundled MinGit

Unchanged from the plan: one install repo and an optional external repo per game, Profile = branch, capture = commit, restore = checkout, split git-dir/work-tree. Git runs as a subprocess against a bundled git, never a system git. The engine shells out instead of using LibGit2Sharp, because libgit2 is weaker on large binary trees and packfiles, which is this workload. On Windows SavePoint starts the real git.exe under ucrt64/bin directly, not through the cmd/git.exe launcher, which saves one process per git call.

D3. No IPC layer; a service facade instead

A native app needs no renderer-to-main IPC, so the plan's IPC-boundary rules apply to a service facade the UI calls. The interfaces in src/Savepoint.Core/Api/ are the contract between Core and App; a fake backend implements them so screens could be built and tested before the services existed. Long operations run as jobs with progress events. Errors become catalog message ids before they reach any view. Views never touch git or the file system.

D4. UI copy in an ICU MessageFormat JSON catalog

The plan requires every user-visible string to come from a catalog with plural and select support, and a test that bans git vocabulary. v2 keeps v1's format (en.json, ICU MessageFormat) instead of .resx, so v1's finished copy carries over and translators keep one format. An ICU MessageFormat library formats messages; CultureInfo handles dates and numbers.

D5. Solution layout

  • src/Savepoint.Core (net10.0): domain, engine, services, platform interfaces. No UI references. OS-specific tables and calls live under Platform/Windows, Platform/Linux, Platform/MacOS behind interfaces, selected at runtime (D9).
  • src/Savepoint.App (Avalonia): views, view models, theme, localization, OS integration (dialogs, notifications).
  • tests/Savepoint.Core.Tests, tests/Savepoint.App.Tests (xUnit). The journey tests in tests/Savepoint.App.Tests/Features/EndToEnd/RealBackend/ walk first run, play, switching, older points, unsaved changes, a file in use, and storage moves.
  • tools/FakeGame: a stand-in game exe for end-to-end tests (v1 had the same tool).
  • build/: git fetch with SHA-256 verification, packaging scripts.

D6. Storefront auto-fetch stays out of scope

The plan marks it "Phase 6 (stretch, later)" and "deferred until v1's manual-capture model has proven itself". v2 ships the complete manual-capture model and no storefront fetching.

D7. Engine-based ignore suggestions and compression knobs stay out

v1 dogfooding dropped the background-jobs proposal's curated per-engine ignore lists (Idea B) and object-store compression knobs (Idea C): engine caches live in AppData, outside the tracked install, and git compression gains on binary assets are marginal. Capture speed came from git config tuning, which v2 keeps. One compression setting came back, for speed: pack.compression = 0 (D50).

Logs and crash dumps (decided 2026-10-24). Three extensions are left out by default, and nothing else. A mod loader rewrites its log on every run, so each session warned of an update and added a version-and-mods snapshot. Across the Steam and GOG installs measured on the dev PC, .log, .dmp and .mdmp files were always run-time output. Folder names such as crash, cache or shaderCache are not safe (shipped tools, shader caches and game data use them), and .tmp and .bak are real content in some games.

  • Two lists. IgnorePaths applies to both folders; InstallIgnorePaths (JSON installIgnorePaths, absent in older definition files) to the game's own folder only. GameDefinition.IgnorePathsFor(role) gives the install folder both lists, install-only rules first, and the saves folder only the first. The last matching rule wins, so a later negation in the both-folders list, such as !keep.log, overrides a default. Every exclude file, capture, preview, switch and folder-move check reads it.
  • The defaults are install-only. New games (manual Add, templates, library import) start with **/*.log, **/*.dmp and **/*.mdmp in "Files to leave out of the game's own folder", shown and removable like any rule. A blank new game explains them in a note; templates and imported files do not. Existing games are not changed. A first design made the defaults game-wide and dropped a rule whenever the saves folder held a match, so Unity games, which keep Player.log there, lost it entirely, and the message called the log a save. Logs in the saves folder are small and change with the saves, so they stay in snapshots.
  • A game-wide default is checked against the saves. A game-wide rule equal to a default string (from a definition file or a template) is checked when a game is added (by hand or from the library), reconnected or started fresh: one ls-files -o -i walk with a private list, never the saved exclude file, over the saves folder, the index and every profile's newest point. A rule that would name one of those files moves to the install-only list, where it is always safe, and the editor or library dialog says which (gameEditor.ignorePaths.savesKept, library.add.line.rulesMoved). If the check cannot run, those rules move too, a warning is logged, and the message says SavePoint could not check (savesUnchecked, rulesMovedUnchecked), because adding a game must not fail. A rule the player types is kept as typed.
  • The after-play offer. When every changed file in the game's own folder is a log or crash dump, the after-play dialog says so instead of the update note and offers "Leave these out from now on". Candidate rules are picked ignoring case and offered only if git, under the install folder's own core.ignorecase, names every changed file. They go into the install-only list, so they need no saves check and never affect the saves folder. A file another program holds is judged by its name: a held log still gets the offer, a held game file the update note.
  • History and the switch counts never count logs and crash dumps as mod files, for older snapshots too.
  • Rules are patterns, not regular expressions (decided 2026-10-27, #242). The rules go into git's exclude list, so they take its patterns: *, **, ?, [abc], a leading / to anchor at the folder, a trailing / for a folder, a leading ! to take a file back, and the last match wins. Regular expressions would mean filtering every file outside git, which is slow on a large install. The editor says which syntax works.

D8. "Clear all data" is a v2 requirement

v1 left it as a TODO. v2 ships it in Settings behind a typed confirmation. It removes SavePoint's own storage, catalog, and consent markers, and never deletes or rolls back files in a game's install or save folders.

D9. v2 ships on Windows, Linux, and macOS

Decided 2026-10-20, replacing the plan's "Windows only for v1, seams for later":

  • Git is bundled on every platform, so the user installs nothing: MinGit 2.56.0.2 for win-x64 and win-arm64 (D10's Windows fallback), and GitHub Desktop's portable builds (dugite-native v2.53.0-4) for macOS x64/arm64 and Linux x64/arm64. Each is pinned by URL and SHA-256 in build/git-manifest.json and checked before extraction. build/fetch-git.sh reads the manifest through tools/PackageSources, so it needs no JSON tool, under a short lock so parallel builds do not build that tool twice.
  • Path-safety denylist tables and path tokens cover all three OSes, as the plan sketches. Tokens follow each OS's conventions (XDG dirs on Linux, ~/Library/Application Support on macOS).
  • Launch covers Windows .exe, Linux native binaries and scripts, macOS .app bundles, and storefront URIs through each OS's opener. A managed PE parser reads exe versions, so they work for Windows games under Proton too.
  • Notifications, single-instance, folder reveal, and OS theme detection sit behind platform interfaces, one implementation per OS.
  • Copy that names the OS ("Match Windows", "a Windows folder") is OS-aware through ICU select.
  • Packaging: an installer per OS (Windows installer + portable, macOS app bundle, Linux AppImage).
  • Verification: the full suite runs natively on Windows. Linux runs on the local Linux test VM (D60) and natively in CI (D48.9). macOS cannot run here, so its code stays on shared POSIX paths, data-driven tests cover its tables, and it is flagged as unverified on real hardware.

D10. Library and tool choices (verified 2026-10-20)

Need Choice Why
SDK .NET SDK 10.0.401 The version the repository builds with
UI toolkit Avalonia 12.1.4 (Avalonia, .Desktop, .Themes.Fluent) Current stable, active; 12 makes compiled bindings the default
MVVM CommunityToolkit.Mvvm 8.4.2 Source-generated observable properties and commands
Tests xunit.v3 + xunit.runner.visualstudio + Microsoft.NET.Test.Sdk; Avalonia.Headless.XUnit 12.1.4 xunit 2.x is deprecated; Avalonia's headless runner targets v3
ICU messages MessageFormat (jeffijoe) 8.0.0 Plural, select, =N, #; one formatter instance per locale on the UI thread
Exe version AsmResolver.PE.Win32Resources 6.0.1 Managed PE resource parser, works on every OS (FileVersionInfo reads native PE version info only on Windows)
Packaging Velopack 1.2.161 (vpk) Installer + portable from one command on all three OSes; skip 1.2.158 (flagged broken)
Windows toasts Windows Runtime ToastNotificationManager with our own AUMID, set on the Velopack shortcut (superseded by D26) No third-party dependency; the toolkit packages are archived or deprecated
Bundled git See D9; Windows fallback MinGit 2.56.0.2 (SHA-256 da35e72aa21c005a5a0d298cfbae110bc1609a815730ea0dde84b01a1b3cd3be) Official build with published hash

D11. Port Material Color Utilities instead of depending on a C# port

The MD3 palette needs HCT, SchemeTonalSpot, and the surface-container roles. The only C# port with those roles (Bdziam.DynamicColor 0.0.11) has not changed since April 2025 and has an unclear license. v2 ports the needed subset of Google's Apache-2.0 library, with attribution. Golden vectors from the official @material/material-color-utilities 0.3.0 (the version v1 pinned) check all five seeds in both modes; the v1 design's token table is a second check for the blue seed.

D12. Static, subset fonts built from the official variable fonts

Avalonia does not render variable fonts, and Roboto, Roboto Mono (OFL 1.1), and Material Symbols Rounded (Apache-2.0) ship only as variable fonts. v2 instantiates static weights with fontTools and subsets Material Symbols to the icons the UI uses, at its default axes (FILL 0, wght 400, GRAD 0, opsz 24). The generator lives in build/fonts/; the generated fonts and their licenses are committed. Icons are referenced by code point, not ligature.

The app icon is the blue accent's primary with the bookmark glyph, filled at 32 px and smaller (the outline goes soft there) and outlined above, colored by the palette code. Windows windows use savepoint.ico, so the title bar and taskbar pick a frame drawn for their size; elsewhere they use the 256 px PNG.

D13. Resolutions for v1 defects found during the inventory

  1. Consent marker and ignore rules stay out of the game folders' history. v2 never writes a .gitignore into a game's folder. The folder's rules (ignorePaths, plus installIgnorePaths for the game's own folder, D7) and the marker file name go to <gitDir>/info/exclude in SavePoint's storage. The marker is never committed, so checking out an older point cannot rewrite it. Previews read the same exclude file and never write into the work tree. The marker is the one file SavePoint adds to a game folder; otherwise it writes only to its own settings, snapshot and log folders.

  2. A corrupt catalog file is never overwritten. A missing file means an empty catalog. Unreadable or invalid JSON raises CatalogCorruptException, the app shows a recovery screen naming the file, and nothing is written until it is resolved. Recovery moves the corrupt file aside, never deletes it. Every overwrite first copies the previous good file to <name>.bak. The catalog's camelCase JSON keeps v1's shapes, so a v1 catalog can be read.

  3. Catalog writes are serialized through one async lock per catalog store.

  4. Sessions live for the process lifetime. Settings changes and storage moves swap dependencies; they never rebuild the launch orchestrator or drop a running session.

  5. A running game blocks destructive operations on that game: delete game, delete profile, storage move, and clear all data refuse with a specific message until the session ends. A profile delete is also blocked while that profile is loaded (BlockedBy: active profile, running game).

  6. versionOverride is part of the Profile schema.

  7. History sorts by DateTimeOffset, never by string.

  8. Launch checks both folders for unsaved changes before switching either.

  9. Profile delete validates both folders before deleting from either, so a refused delete changes nothing.

  10. A grace for a launcher stub stays, two minutes since 0.9.2. At 30 seconds it ended a link start's session while a slow launcher was still starting the game, even with a process name set. The running card offers "I'm done playing" from the first second, so the wait never blocks the user. SavePoint looks at the process list every 2 seconds. The after-play dialog says how the session ended:

    • Nothing SavePoint could see ran (a link start, or a started program that exited within the relaunch window) and the name never showed up: "SavePoint didn't see the game running" instead of a play time, suggesting the name may be wrong or the game slower than two minutes to start.
    • The started program ran past the relaunch window but the name never showed up: the session ends at that program's exit after the grace, the play time is real, and a softer hint says to check the name.
    • Both offer "Open Edit game", which leaves the new changes as they are (like Not now) and opens the editor. With the after-play dialog off, a toast says the same once.
    • SavePoint could not read the list of running programs for the whole grace: the dialog says it couldn't tell how long you played and blames nothing.

    A clean quit (decided 2026-10-27, #255). When the started program was seen running under the game's process name, ran for at least 10 seconds (CleanQuitMinimumRun), and then exits with code 0 inside the relaunch window, with no other copy seen and nothing followed, the session ends two process-list looks (about 4 s) after the exit instead of after the grace. A player who quit Balatro after 17 seconds otherwise waited two minutes. A clean exit before 10 seconds is a store's relaunch stub, which exits within a second or two and has the store start the game again, so it keeps the whole grace and the new copy is followed. An error exit keeps the whole grace, a copy that appears within the two looks is still followed, and the after-play guard (D67.5) still refuses a snapshot if the game turns out to be running.

    An error exit (decided 2026-10-25, after Valve's cstrike.sh failed outside Steam's runtime on Linux). A started program that closes within the relaunch window with an error code does not shorten the grace, because a Steam game started directly exits with code 1 and Steam starts it again, sometimes a minute later. The running card says at once that the program closed with that code and SavePoint is still watching; the note goes when the game appears. If nothing appears by the end of the grace, the session ends as "The program closed right away" with the code and a suggestion to start Steam first, because starting the game through Steam can update it (D67). On Linux, choosing "Run the program" for a game in a Steam library folder (steamapps/common) makes the editor say such games usually need Steam to start them.

    Calling the player back (#150). When the after-play dialog opens while SavePoint is not in front (Steam or a launcher often takes the focus as a game quits), SavePoint posts a notification naming the game and, on Windows, flashes its taskbar button. It never takes the focus itself.

    A starter that hands over (decided 2026-10-25). A started program that only starts the real game elsewhere in its folder (Eve Online's eve.exe starts SharedCache\...\exefile.exe) is followed through its children:

    • Only when the program SavePoint started exits within the relaunch window.
    • Only processes SavePoint started, directly or further down, whose program file lies inside the game's install folder. Never a process outside it (a store client, a launcher such as Battle.net, a browser), one whose path cannot be read, or a crash reporter a game ships in its folder. Crash reporters are recognized by their program's file name, or on Linux by the first 15 characters the kernel keeps of a name.
    • Following does not count as seeing the game: the grace for the configured name runs from the starter's exit as before, and the game appearing ends the following. Only when the grace runs out while a followed process is alive does the session stay open, ending when the last one exits, with the play time up to then.
    • A link start follows nothing new. "Already running" counts followed processes too.
    • A child counts only if it started after its parent (and after the session began, when the starter was already gone at the first look), so a reused process id is not taken for one.
    • Windows and Linux report parents and start times; macOS does not, so it behaves as before. Windows keeps a dead parent's id and follows it directly. On Linux an orphan is handed to another parent, so when the starter is gone before SavePoint sees its child (#145), SavePoint links the game without the parent id: exactly one process in the game folder that started after the session began and within the relaunch window after the starter, is not a crash reporter, and is not a child of a process started during the session. With two or more such processes it follows none and logs them. The first decision stands for the session.

    A Steam link on Linux (#57). With a process name set, the grace does not run while Steam's launch helper for that game is alive: a reaper process whose command line has SteamLaunch AppId=<id>. Checked on the Linux VM for a native and a Proton game, it lives from the link until the game exits. So a slow launch or a first-run Proton setup does not end the session early, and a wrong or empty process name ends it two minutes after the game quits rather than after it started. Windows, macOS, program starts and other stores are unchanged.

  11. exePath must be relative to the install folder and must not escape it (..). The editor's Browse converts a picked file to a relative path or refuses one outside the install folder.

  12. Process-name matching is case-insensitive on Windows and macOS and ignores a trailing .exe difference. On Linux it also matches the executable's file name, because the kernel truncates process names to 15 characters, which would break games run through Proton.

  13. Read-only git calls run with GIT_OPTIONAL_LOCKS=0, so previews and row stats never take index.lock during a capture or switch.

  14. Duplicate and discard take the per-game lock.

  15. Exe version reads are cached by the blob id of the exe at that profile's tip.

  16. Free-space checks target the volume that is written: the storage volume for captures and optimization, the game folder's volume for switches. A snapshot also counts the size of its new and changed files before it writes anything (2026-10-26; packs are written without zlib, D50, so the store grows by about that much), so a snapshot that would fill the drive is refused up front with the space it needs. When that check fails, temporary packs a stopped snapshot left are removed first (never while a leftover git still runs, D59) and the space is judged again. A launch asks the folders after the first whether they can switch (space, case clashes, links, unsaved work, an unfinished switch) before it changes the first one, which refuses on its own before writing, so a refusal in the saves folder never leaves the install on another profile. Folders are also judged together (2026-10-27). A snapshot sums the new and changed bytes of the folders that fit on their own and checks the sum against the storage drive, once each has passed its own check and before any stores anything. As a result, a folder that cannot fit is refused alone, and the others are still saved as a partial snapshot. A launch sums the growth of the folders that share a drive (shrinking folders count as zero, since they free space only once written). It asks the first folder too when another shares its drive. A folder that cannot fit on its own is still refused with its own figures first. Content already in the store does not count when a snapshot would otherwise be refused (#170). The check first judges the raw sizes and reads nothing when they fit, so a drive with room pays nothing extra. Only when they do not fit does it read the smallest changed files, up to 64 MiB in all. It leaves out any file whose content (the id git would give it) is already stored. Everything not read counts in full, including files git streams (128 MiB and over): they need room in a pack while git works, even when stored. The estimate can therefore only be too high, except for a file that changes between the read and the add, which the 64 MiB limit keeps under the 100 MiB floor. Same name and size was rejected as a signal, because saves and patched files often keep their size. On 4000 changed files (about 50 MB), the check takes about 0.1 s with room and 0.5 s on a nearly full drive. A folder that fits on its own reports its raw size when several folders are judged together. If the sum of those figures does not fit, each folder is asked for its reduced figure, which reads its files as above, and the sum of those is judged again, so a refusal needs the reduced total not to fit either (#240). The progress bar's byte total uses the reduced figure only when a check already found it, because finding it takes reads. Files git streams still count in full: telling that they are stored would need stat data kept for every snapshot, which changes what is stored, so it is not done.

  17. Automatic optimization is preemptible. It starts after a capture when a repo passes 5000 loose objects. A launch, capture, or delete on the same game cancels it (repacking is safe to interrupt) and proceeds; the next capture triggers it again. It is its own job kind, PackStorage, shown as "Compacting snapshot files" (2026-10-27). It used to share Free up space's kind and words, and right after a first snapshot "Freeing up space" read as SavePoint deleting the new profile. It deletes nothing the player can see, except that it finishes a cut-off Free up space the player already confirmed (D46.2). Free up space stops it and runs. A tidy, or a player's Free up space, stopped so another task could go first reads "Stopped", not "Canceled".

  18. Cancel reaches every cancellable job. Captures (including post-play), switches, optimization, and storage moves take the job's cancellation token. A session wait is not cancellable; "I'm done playing" ends it.

  19. Launch flow state lives above the views, so changing screens, layouts, or the selected game never loses a running session or its post-play prompt. A finished or failed session stays visible until that game's next launch.

  20. Partial results are judged per folder. A job that succeeded for one folder and failed for the other is partial everywhere (the "Half of that save worked" card, which says the other folder was not included), never success. A folder skipped on purpose (FolderOutcome.Skipped) is Ok, not Saved, and the card shows it as kept as it was.

  21. Every failure has visible copy. The five message ids v1 could emit without a catalog entry get entries, and no action fails silently. The ids v2 adds to v1's: error.storageRelocation.cancelled (OperationCancelledByUserException), CompactionPreemptedException (error.compaction.preempted), GameRunningException (error.gameService.gameRunning), LaunchWindowsProgramException (error.launch.windowsProgram), CatalogCorruptException (error.catalog.corrupt), GitUnavailableException (error.git.unavailable), StorageStillReachableException, StorageDefaultFolderHasHistoryException, StorageFolderHasLinkException, the profile refusals (error.profile.notLoaded, error.removed.notFound, error.removed.notRestorable), StorageWriteFailedException, StorageUnreachableException, StorageHistoryNotFoundException, StorageRemoveFailedException, StorageSourceUnreadableException, StorageInsideInstallFolderException, FileUnreadableException.

  22. Game notes survive editing.

  23. Default storage root is a local, never-synced folder: %LOCALAPPDATA%\SavePoint Data\Storage on Windows (outside the folder the setup owns, D38), $XDG_DATA_HOME/savepoint/storage on Linux, ~/Library/Application Support/SavePoint/Storage on macOS. v1 used Documents\SavePoint, which OneDrive commonly syncs, a bad home for tens of GB of game data. First run shows the location; Settings can move it.

  24. Git never reads the user's global or system config. Every git process runs with GIT_CONFIG_NOSYSTEM=1, GIT_CONFIG_GLOBAL pointed at an empty file, and a fixed identity, so a user's commit.gpgsign, hooks path, or aliases cannot change what SavePoint does.

D14. Playing from an older point, then saving

Replace after a normal session (decided 2026-10-24). "Replace with this session" targets the newest snapshot (by date across both folders) that History lists under the played profile, using History's capture-id grouping and its rule that the first profile in catalog order owns a snapshot. Each folder with something unsaved is judged:

  • The snapshot has no commit there: the unsaved files become a new commit, and nothing is rewritten.
  • It has a commit that is the profile's newest in the folder and reached by no other profile's branch: SavePoint rewrites it.
  • Anything else refuses the folder.

Replace is offered only when no folder refuses and at least one is rewritten, so never with nothing unsaved. The rule runs again inside the save, under the game's lock. If a folder changed after the dialog and the rule now fails, every folder is saved as a new snapshot and the result says so ("kept as new", the only place that card appears). The rewritten and added commits all carry the session's new capture id, so the replacement is one snapshot under a new id, and the old id leaves the rewritten folders. The per-folder verdict goes into the save's plan when it is judged: a folder judged clean that is written before it is saved gets a plain commit, never a rewrite, and a retry of a failed save follows the first judgment.

So a profile made from another, or a duplicate, never rewrites a snapshot it shares and has nothing to replace until it takes one of its own; the source profile cannot rewrite the shared snapshot either until it has a newer one. Before, New profile offered the other profile's snapshot by name.

A session that changed nothing (decided 2026-10-25). When a session not started from an older snapshot leaves both folders unchanged, the after-play dialog preselects Not now as the main button. Keeping is still offered but not recommended, since it would only copy the last snapshot. The Linux desktop checks found the dialog saying nothing was found while recommending keeping.

Saving after playing from an older point. The v1 plan ("Save history within one Profile") requires two choices: move the profile forward from that point, so the newer points leave the profile (recoverable through Recently removed, D44.4), or fork a new profile there, the safer default. v1 never built this; it threw detachedCaptureNotSupported, later patched with keep-as-new in the launch dialog. v2 builds it:

  • The post-play dialog offers Keep this as a new profile (default, name prefilled), Continue "" from here (moves the profile forward, after a second confirmation naming how many newer points leave the profile), and Not now. Since 2026-10-27 Not now is one of the choices only, with no second Not now button in the footer, whose one button acts on the chosen card; Escape still dismisses. Default snapshot and session names date themselves in the catalog language's medium form ("Session - Jul 8, 2026"), with any character a name refuses turned into a hyphen.
  • SessionCompletion variants: CaptureNew(message), UpdateExisting(message) (amend), ForkNewProfile(name, message), MoveForward(message), Skip.
  • Engine: fork = create a branch at the current (detached) commit, switch to it without touching files, commit. Move forward = point the branch at the current commit (reset --soft semantics on the branch ref, never touching files), then commit. Both refuse unless the folder is on the commit the session started from or a descendant of it.

D15. History points and "Go back to this"

A history point is one capture event. Each capture writes a Savepoint-Capture: <guid> trailer into every commit it creates (one per folder), so points are grouped exactly, never by matching timestamps. The trailer is never shown.

  • Point kinds (2j): Version, mods and save (both folders changed), Version and mods (install only), Save only (external only). The card's line ("Save only ยท 1.6.640 with 212 mod files") reads the install state current at that point.
  • Go back to this opens the launch flow targeted at that point. Each folder is restored to its commit for that point; a folder the capture did not touch, to that profile's latest commit at or before the point. A point that is not the profile's tip restores detached, and the next capture after playing follows D14 (fork by default).
  • The launch dialog's save picker is the same mechanism restricted to the target profile's save points (plan step 2 and 2b).

D16. Large incompressible files skip delta compression

Per the plan's Maintenance section, every repo gets <gitDir>/info/attributes (not a file in the game folder, D13.1). It marks already-compressed formats -delta: archives (zip 7z rar gz xz zst cab), media (mp4 webm mkv bik bk2 usm ogg mp3 flac), common game containers (pak ucas utoc bsa ba2 archive vpk pck), and Unity's block-compressed containers (bundle unity3d assetbundle resource; measured in D50). Text and small binaries keep delta compression. So do Unity's assets and resS, which are not block-compressed and shrank to 13 to 68% under zlib in real installs.

D17. Deleting a profile warns about history only it holds

The plan says Delete "warns if it's the only place holding some history". v2 computes, per folder, the points reachable from that profile and no other (rev-list <branch> --not <every other profile branch>). The confirmation names how many points will be lost and that the next storage optimization frees their space; zero means a plain confirmation.

D18. Startup checks and recovery

Before any screen, SavePoint verifies the bundled git (git --version); a failure shows an error screen naming the path and what to reinstall. Stale index.lock files under the storage root are removed once, by the first startup check and before any git work, because each one then predates the process (SavePoint is single-instance and owns every git process on its repos, D31), once the gits a stopped SavePoint left running have been ended (D59); while one cannot be ended, no lock is removed. During a run, a lock is removed only under the game's lock with no SavePoint git process in flight for that repo. A corrupt catalog file shows D13.2's recovery screen.

D19. Onboarding and editor guidance from the plan's risk table

  • First run and the game editor warn against online games protected by anti-cheat (the plan's explicit non-goal), without detecting them. The warning gives the reason, since there is no technical conflict: SavePoint never injects into a game, reads its memory, or hooks it. Anti-cheat checks the game's own files, so changed or rolled-back files can get an account flagged; those games also forbid mods, require the latest version online, and keep progress on their servers. Games playable offline with anti-cheat off for mods are fine.
  • The editor's cloud-saves warning shows only when the game's store syncs its saves; when SavePoint cannot tell, the advice sits behind a "Does my store sync saves?" button (D56).
  • The editor shows each warning only where it applies (2026-10-26): the Steam update warning only for Through Steam, anti-cheat and the explanations of the optional fields behind question buttons, and the optional fields (rules, extra options, stop detection, Steam app id) under a "More settings" card that is closed when adding a game, open when editing one that uses them, and opens itself when a field inside has an error. The editor is a column of cards (2026-10-27, #242): Game (required: name, install folder, how to start), Saves, Mods, Artwork and More settings. The Mods card holds the mods folder outside the game folder (D61) and the mod files inside it; the system file and folder pickers add those as paths relative to the install folder (#247). Each question button has its own text and links to How SavePoint works where a topic exists. Screen readers hear each card heading with its tag ("Game, Required"); More settings is a heading too. The line that a rule must not match the saves stays next to the rules.
  • Long paths: core.longpaths=true everywhere, and the engine's tests include a tree deeper than 260 characters on Windows.

D20. Translator workflow

v1's FormatJS extraction step becomes two tests plus a short guide: every key referenced from XAML or C# exists in en.json, en.json has no unreferenced keys, and every other catalog (<locale>.json) has exactly the same keys with ICU arguments matching English. D39 refines how a language is added: catalogs are embedded at build time, so a language ships in a new build, and Settings shows no list until a second catalog exists.

D21. Licensing of the bundled git

Distributing git means shipping the GPLv2 text and a written source offer pointing at the exact upstream tags (git-for-windows v2.56.0.windows.2, git v2.53.0, dugite-native v2.53.0-4). SavePoint works only on local repositories, so the bundle is pruned of what it never uses (Git Credential Manager and its UI assemblies, Git LFS, network helpers), which also shrinks the installer; what stays is listed in THIRD-PARTY-NOTICES.md with its license. From 0.9.5 the source archives (the three tags and every MSYS2 and MINGW package in MinGit) are published once per bundled git version as their own release (git-sources-<MinGit version>), which each app release links to instead of carrying about 55 identical archives. 0.9.2 to 0.9.4 keep theirs so their checksums still hold.

D22. Colors come from SchemeTonalSpot; the mockup hexes are approximate

The v1 design's token table was drawn with the legacy Scheme API (its light primary #00639D and light onPrimaryContainer #001D34 match it exactly), while v1 shipped SchemeTonalSpot at contrast 0, as the design instructs ("derive them from the theme instead", "hardcoding these hexes would break the accent-preset feature"). v2 follows v1: every role comes from SchemeTonalSpot. Dark mode lands within a few units of the table; light primaries are slightly less saturated. Fidelity and Content match the light primary better but turn primary containers into the saturated seed color, further from the mockup, so they were rejected. Roles M3 does not define (warning, success) come from fixed-hue tonal palettes at M3's error tones (40/100/90/10 light, 80/20/30/90 dark): warning from the mockup's gold #F5D488 (the first pass used amber #f9a825, which read orange), success from green #2e7d32.

D23. Api contract details settled after the contract was written

  • History count: the header counts capture events (D15 points), not column rows. The mockup's "9 points kept" double-counts a point in both columns; the seeded data says 8.
  • Cancelled reads: a read whose token is cancelled fails with error.operation.cancelled; view models discard results of requests they cancelled and never show it. Mutations other than job starters take no cancellation token, because stopping one halfway is worse than finishing it.
  • New profile rows: the catalog row is written when the profile's first capture saves at least one folder. A capture that saves nothing leaves no row and no branch (fixes v1 defect 9). A partial result keeps the row and shows the "Half of that save worked" card with a retry for the missing folder.
  • Settings save: ISettingsApi.SaveAsync never changes StorageRoot or LastOptimizedAt; only RelocateStorageAsync moves storage and only optimization jobs set the optimized date.

D24. Public APIs carry XML documentation; project docs ship with v2

  • Every public type and member in Savepoint.Core has an XML doc comment (///): a <summary> stating the contract (what it promises, failure ids it can return, threading of events), plus <param>, <returns>, <remarks> only where they add to the name. CS1591 is an error for Savepoint.Core. Savepoint.App documents its public view-model and service surface the same way, generated and view code-behind exempt (D39 refines this).
  • The one-line comment rule covers inline implementation comments only. API docs are the contract, readable without opening the code.
  • Already-merged Core code got a documentation pass before the warning was switched on.
  • Project documentation (README, user guide, developer guide covering architecture, building, testing, and adding a language) is a v2 deliverable, completed with the packaging work. The API reference is generated from the XML docs (D55).

D25. No Git LFS; large files handled by git's own store and geometric repacking

Git LFS is pruned on purpose. It solves network transfer by keeping large files on a server, and SavePoint has no remote. Locally it would add a second object store with its own cleanup (git lfs prune), a clean/smudge filter on every tracked file, and a failure mode where a broken filter leaves pointer files in the game folder. Git's own store already keeps each distinct file content once across every profile.

LFS would have avoided one real cost: a full git repack -a -d rewrites every object, so on a 60 GB install each optimization would copy 60 GB. v2 therefore:

  • optimizes with geometric repacking (git repack -d --geometric=2, automatic and manual), which packs new objects and merges only small packs. It weighs packs by object count, though, so a capture's streamed pack (a few huge objects) is always the lightest and was rolled up within a few routine repacks, rewriting every big archive (git 2.56: about 85 GiB for Cyberpunk on the second routine repack after the first snapshot). So every pack a capture's add writes gets a .keep (written atomically, text starting SavePoint:), which geometric repacking honors. Each routine repack also first keeps any pack of at least 128 MiB holding at most 1024 objects (read from its .idx header), which covers stores from before the keeps and a keep a failed write missed; a routine-merged pack of small saves holds far more objects and stays in the geometric sequence. Free up space keeps a kept pack while everything in it is still reached, and rewrites only a pack holding something it frees (D28);
  • sets core.bigFileThreshold=128m, so larger files stream into the store without delta search (game binaries and archives rarely delta well) and without loading whole into memory;
  • keeps the D16 -delta list for compressed formats below that size.

D26. OS integration without a Windows-specific target framework

WinRT toasts (ToastNotificationManager, D10) need the net10.0-windows10.0.x target framework, which would split every build by OS. v2 keeps one net10.0 target and uses:

  • Windows notifications: Shell_NotifyIconW info notifications through P/Invoke on the main window's handle, which Windows 10 and 11 deliver as toasts under the app's name and icon. Supersedes D10's WinRT row.
  • Linux notifications: org.freedesktop.Notifications.Notify over D-Bus with Tmds.DBus.Protocol, which Avalonia's Linux backend already depends on; skipped when no notification service runs.
  • macOS notifications: osascript -e 'display notification ...' (no signing or entitlement needed).
  • Notifications fire only while the window is unfocused or minimized, and only for capture, optimize, storage move, and clear-data jobs (the v1 proposal's rule), never for launches (D13.10 and D49.6 add the after-play callback and switches).
  • Single instance: a named mutex per user plus a named pipe; a second launch asks the first to show and focus its window, then exits. D39 adds an exclusive lock on a file beside the socket. Either guard alone keeps a second copy out, which covers a machine that gives no mutex (another session, a sandbox): without the mutex the file decides, without a writable file the mutex decides. A machine that allows neither keeps every copy from running, because two copies on the same repositories would remove each other's git locks as stale. The lock belongs to the open handle, so a crashed copy blocks nobody.
  • Reduced motion: read from the OS (Windows SPI_GETCLIENTAREAANIMATION, macOS accessibility "reduce motion", GNOME enable-animations) into ThemeService.ReduceMotion.
  • Reveal in file manager: Explorer /select, open -R, xdg-open on the folder. On Linux every folder SavePoint opens (the profile menu, About, the startup screen, the crash window) watches xdg-open for 3 seconds and reports an opener that exits with an error.
  • Linux apps menu entry (opt-in): a plain AppImage has no desktop entry, so GNOME shows a generic icon.
    • Settings offers "Add SavePoint to your apps menu" only on Linux, when APPIMAGE names an absolute path and SavePoint runs from inside APPDIR (every program started from another AppImage inherits its APPIMAGE).
    • It writes the 256 and 512 px icons under icons/hicolor/<size>/apps/savepoint.png, then $XDG_DATA_HOME/applications/savepoint.desktop (default ~/.local/share; Exec is the quoted AppImage path, TryExec the same so desktops hide the entry when the file is gone, StartupWMClass=SavePoint, Categories=Utility;, a Comment from the catalog, marked X-SavePoint-Managed=true). Each file goes through a randomly named temp file and a rename, so a failed add or update leaves the previous entry.
    • An entry without the marker, or anything at that path that is not a regular file of at most 64 KB, is someone else's and is never changed or removed. An entry whose Exec or TryExec names another file, or whose icon is gone, shows as out of date with Update.
    • Remove deletes the entry and SavePoint's icons (also icons left by an entry deleted by hand), then the icon size folders Add created (recorded as X-SavePoint-Created-Folders) when empty. A folder it did not create, or one with anything else in it, stays.
    • update-desktop-database runs on the user's applications folder when present. gtk-update-icon-cache runs only when the user already has an icon cache (otherwise the folder's time is touched), so SavePoint never leaves a cache file of its own. Failures are ignored; nothing asks for administrator rights.

D27. The Linux gate retried failed tests up to twice, and said which (retired by D60)

The local Linux gate runs under WSL on the repository's /mnt/f drvfs (9p) mount, where the sources live. That mount shows rename/visibility races ordinary Linux file systems do not (a file just renamed into place is briefly "not found"), so file-heavy tests fail at random, a different one each run. The Linux gate re-runs failed tests up to twice and prints every test that needed a retry; three failures fail the gate. The Windows gate never retries, so real races in SavePoint's logic are still caught. Product code does not treat "file not found" as transient, since on a real file system that would hide genuine losses. Retired by D60: the local Linux gate now runs on ext4 on the Linux VM, and no gate retries.

D28. What a capture stores, and how optimization reclaims space

  • A game folder's own .gitignore files are not honored. SavePoint must restore exactly what was on disk, byte for byte, so only its exclude list (info/exclude: the marker and the game's ignorePaths) decides what is skipped. Capture lists files itself (ls-files -z -o -m -d --exclude-from=<gitDir>/info/exclude, never --exclude-standard) and stages them with add -f --pathspec-from-file=- --pathspec-file-nul. Recorded paths that are gone, including a file a folder replaced, leave the index first through update-index --force-remove, because the folder's name as a pathspec would let -f add left-out files inside it. Status, unsaved-change detection and previews use the same listing; clean uses clean -fdx with SavePoint's patterns as -e. So a file a mod's .gitignore names is still saved, detected as unsaved, and cleaned on discard. A file SavePoint's own patterns name that a point already recorded follows D41.2 (a switch and a discard leave it on disk, a save stops recording it), so a discard with patterns is no longer one hard reset.
  • Nested version-control folders are refused, not half-saved. A folder inside the game with its own .git (a mod cloned from GitHub) would be stored as an empty pointer whose files never come back, or fail the capture. Capture and preview detect any nested .git directory or file and refuse with error.capture.nestedRepository, naming the folder, before staging anything. The user moves the mod's hidden history folder out and captures again.
  • Two optimization modes (refines D25).
    • Routine (repack -d --geometric=2) runs after captures and never rewrites the kept large packs (D25).
    • Reclaim expires reflogs, then works out what nothing reaches (every object, against rev-list --objects --all --indexed-objects, which covers the Recently removed records as refs) and which kept packs hold any of it (from their .idx). Only such a pack loses SavePoint's keep (one starting SavePoint: or empty; a keep anything else wrote stays). It runs repack -a -d when a pack holds something freed, repack -d when only loose objects need packing, else no repack, and always prune --expire=now, dropping everything no profile reaches. A fully reached kept pack is never rewritten: on a copy of Cyberpunk 2077 (91 GB), Free up space with nothing to free went from 5 minutes and a whole-store rewrite to well under a second.
    • Reclaim asks for the floor plus what it will rewrite, worked out before anything is cleared (counting the records it will clear as gone) and checked again before it runs. It refuses a folder with an unfinished switch, whose note may name a commit only the note reaches. It runs on Free up space and automatically after a profile or game delete (preemptible, D13.17), which D17's "freed by the next optimization" relies on.
    • Repos keep core.logAllRefUpdates=false; reflogs add nothing for SavePoint.
  • Profile branch names are always lowercase (CatalogIds), so case-only collisions on case-insensitive file systems cannot happen. The case probe asks about the marker file inside the folder first, so a folder that is itself a mount root is judged by its own drive.
  • Symbolic links inside game folders: see D29.

D29. Engine safety rules from the engine review

An independent review reproduced three ways the engine could damage files. These rules are enforced in the engine itself, not only in callers:

  1. No folder links inside a tracked folder on Windows. Git for Windows follows directory junctions and symlinks, so a switch or discard could delete or overwrite files outside the game folder. Capture, preview, switch, discard, and clean scan the work tree for directory reparse points (junctions, directory symlinks, mount points) and refuse with error.capture.linkedFolder naming the first one; nothing is staged or written. On Linux and macOS git stores symlinks as links and never follows them, so they are captured and restored as links (native games ship .so symlinks). D62 covers file links on Windows.
  2. A switch never runs over unsaved changes. Non-forced checkout refuses a folder with unsaved changes (DirtyWorkingTreeException) instead of letting the verify/re-sync pass overwrite them. The launch flow resolves them first (D13.8); this holds the guarantee for every caller.
  3. Clean and discard refuse a folder with no saved point (error.profile.noPoints): "discard" would mean deleting the whole game folder.
  4. Repo delete only deletes a SavePoint git directory: it must sit inside the storage root (component-wise containment) and carry SavePoint's config stamp and git's layout (HEAD, objects/), or the delete is refused untouched.

D30. Game artwork from Steam and GOG, the name tint as fallback, the user's own image always wins

Requested 2026-10-21. This amends the v1 design ("v1 has no art source ... Do not invent artwork"): publisher artwork is not invented, the tint stays the fallback, and nothing is generated.

  • Precedence: the user's own image; Steam art for a Steam app id the user stored; GOG Galaxy's cached art for the product named by the install folder's goggame-*.info; Steam art for a detected Steam app id; the tint. A GOG product id outranks a detected Steam id because GOG and retail builds carry other apps' ids; an id the user typed is taken as meant.

  • Sources: Steam and GOG Galaxy's local cache, no SteamDB. SteamDB asks not to be scraped, sits behind bot protection, and serves Steam's CDN images anyway. Other sources need an account key (SteamGridDB, IGDB) and are out of scope.

  • GOG (added 2026-10-24). A GOG install folder holds no cover (goggame-<id>.ico is an icon), but Galaxy keeps the covers it shows on disk, so no network or database access is needed.

    • The product id is the most common rootGameId across the goggame-*.info files, else gameId, digits only. A game with DLC has one file per product, all sharing the base game's rootGameId (Cyberpunk 2077 has three, and the add-on's sorts first). Older games have no rootGameId.
    • The images are %ProgramData%\GOG.com\Galaxy\webcache\<account digits>\gog\<id>\<sha256>_glx_vertical_cover.webp (342x482, tall) and ..._glx_bg_top_padding_7.webp (1600x650, a darkened background without the title, wide), newest across accounts. On one PC on 2026-10-24, 927 of 930 cached products had the cover. A game Galaxy has not cached gets no GOG art.
    • The cache is looked up on Windows only; Galaxy's folder on macOS is unchecked.
  • The Steam app id is an optional SteamAppId (positive integer) on the game definition, editable in the editor's Artwork section; templates may carry it. A stored id always wins. Otherwise the artwork service detects one at lookup time, in order:

    1. a steam://run/<id> or steam://rungameid/<id> launch link;
    2. an install folder <library>/steamapps/common/<dir> whose sibling <library>/steamapps/appmanifest_<id>.acf names <dir> as its installdir (case-insensitive on Windows and macOS);
    3. a steam_appid.txt holding only digits, with any surrounding whitespace and NUL bytes, in the install folder or else a subfolder up to three levels down (shallowest first, at most 200 folders, never through a link).

    Detection reads files only and never writes the catalog. The manifest comes before the file because games ship files with other ids: on one PC's 174 installed games (2026-10-23), Mafia III, House Flipper, and Fallout 4 GOTY carry another app's id in steam_appid.txt, 13 of 25 install-folder files end in a newline and a NUL byte, and 13 games keep the file only in a subfolder such as Binaries/Win64, x64, or bin.

  • Two images per game, chosen by tile shape. The wide card block uses header.jpg (460x215); the square tiles (rail 24, headers 34/40) use library_600x900.jpg, center-cropped. Both are drawn uniform-to-fill, clipped to the tile's radius. A tile switches to the wide image at a width of 1.5 times its height. The user's own image serves every shape.

  • Where Steam images come from, in order:

    1. The Steam client's local cache, no network: <Steam>/appcache/librarycache/<id>/ and any subfolder, or the older flat <id>_header.jpg / <id>_library_600x900.jpg. Newer games are cached in hashed subfolders as library_header.jpg (460x215, wide) and library_capsule.jpg (300x450, tall); both names are accepted. On a cache of 950 apps (2026-10-23), the old names found 720 wide and 380 tall images; with the new names, 893 and 454. The Steam folder is HKCU\Software\Valve\Steam\SteamPath on Windows; ~/.steam/steam, ~/.local/share/Steam, and the Flatpak ~/.var/app/com.valvesoftware.Steam/.local/share/Steam on Linux; ~/Library/Application Support/Steam on macOS. A game with a GOG product id and no stored Steam id asks Galaxy's cache first.
    2. Only with the LookUpArtworkOnline setting on (the default), Steam's CDN at https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/<id>/<file>, then https://cdn.cloudflare.steamstatic.com/steam/apps/<id>/<file>.
    3. Newer games are served only under a hashed path (.../apps/<id>/<40-hex>/<file>), and both plain addresses return 404. Only then does SavePoint ask Steam's public store API, https://api.steampowered.com/IStoreBrowseService/GetItems/v1 (no key), once per app, for the asset names, and fetch library_capsule_2x, else library_capsule, for the tall image and header for the wide one from shared.akamai.steamstatic.com. The answer's URL format must name the same app, and each asset name must be an optional 40-hex folder and a plain .jpg file name. Checked 2026-10-23 against the live servers for app 3669870 (hashed paths only) and two older games (plain paths); the first version of this decision, verified on two old-layout games, missed the newer layout.
  • Network rules: HTTPS GET only, to the two image hosts and the one API host. Any 3xx is a failure, so no redirect is followed. A 10-second timeout, a 5 MB cap, and an image/jpeg, image/png, or image/webp content type (Steam serves some library images as PNG data); the bytes must decode as an image before the file is kept. At most two requests in flight. No cookies. The only identifying data sent are the app id in the URL and SavePoint's name and version as the user agent. These are the app's only network requests; with the setting off it makes none.

  • Timing and misses: lookups start after the library has rendered and never delay a screen. A read never waits: it returns what is on disk and starts any lookup in the background. An answer is found, not found, or no id; a missing app id counts as a miss. A miss (404 or no id) is kept in lookup.json with its time and retried after 7 days, or sooner on "Look again", a changed app id, or turning the setting back on. A connection failure is not remembered, in the run or across a restart, is logged once (a warning, D34), and leaves art already kept.

  • Storage: images live under SavePoint's configuration folder (<config>/artwork/<gameId>/), not the storage root, so a storage move leaves them alone. Steam's images, local-cache ones too, are copied in as steam-wide.jpg and steam-square.jpg, so a Steam library change cannot take them away. GOG's are kept as gog-wide.webp and gog-square.webp, dropped once Steam's are found or the install folder points at another product. Deleting a game removes its folder; "Clear all data" removes them all. The user's own image is copied in on save as custom.<ext>, never referenced in place, and accepted only if it decodes as PNG, JPEG, or WebP and is at most 25 MB; otherwise the editor shows error.artwork.notAnImage or error.artwork.tooLarge.

  • UI: a tile shows the tint until its image is decoded (off the UI thread, at display size), so lists never wait or flicker. The tile is decoration for assistive technology, since the game name is always beside it. The editor's Artwork section has a preview, the source ("From Steam", "From GOG Galaxy", "Your image", or "No artwork found"), "Choose image...", "Remove your image" when one is set, "Look again" (disabled while the app id field is being edited), and the optional Steam app ID field with the detected id as its hint. If saving the artwork fails after the game saved, the editor stays open on the saved game with the error. Settings > Appearance adds "Look up game artwork online", noting that artwork already on this computer is used either way.

  • API: a separate IArtworkApi (get, set the user's image, clear it, look again, and a change event keyed by game id), so IGamesApi, the game summaries, the fake backend, the contract tests, and the launch work stay unchanged. Tests use a fake Steam folder and HTTP handler and never reach the network: lookup is off unless BackendOptions.ArtworkHttp supplies a handler, and only the app's bootstrap supplies the real one.

D31. Fixes from the backend and launch review

The backend and launch review (BL-001 to BL-033) found two ways the backend could lose history or files and several ways it could mislead the player. Rules adopted:

  1. "Update existing" rewrites only the point the player named (BL-001). A folder whose newest commit carries that point's capture id is amended. A folder that changed but whose newest commit belongs to another point gets a new commit with the same capture id, so the update stays one point and no other point is rewritten.
  2. Ignore patterns never depend on an earlier call (BL-002). Status, discard, clean, capture, and preview read the game's current patterns from its definition on every call, and saving a game rewrites each folder's info/exclude under the game lock.
  3. A missing storage folder is unreachable, not empty (BL-004). SavePoint creates the storage folder only on first run, when no root is saved. Otherwise a missing root raises error.storage.unreachable everywhere the snapshot is read, so History shows that rather than an empty list. A move refuses a source with no game folders while the catalog lists games, unless it holds only the "Start with an empty folder" marker (D48.6). Game delete refuses while storage is unreachable. A move scan that cannot read an entry fails and names it (BL-003).
  4. Re-pointing a folder with history is checked (BL-005). When an edit changes the path of a folder with saved points, SavePoint counts how many files of that folder's newest point are present at the same relative paths in the new folder. Under half, the editor warns with both counts and needs an explicit confirmation. The discard confirmation names the folder and counts the files it removes (DirtyNewFileCount) and restores. Discard is not refused, since bringing back deleted files is legitimate.
  5. Discard never runs under an open game (BL-006). It is refused while any session for the game is open (including Exited and Completing) or its process runs, checked again inside the game lock. The fake backend refuses the same way, so screen tests run against the real rule (RC-011).
  6. An unfinished switch is its own folder state (BL-007). FolderLaunchState reports it with a LaunchTarget the App can start; "Switch again" starts that recorded target, completing the switch. The target names the branch (InterruptedSwitch.ToBranch) because profiles can share a point (a duplicate starts at its source's). A half-switched folder counts the files git lists, is never offered "Keep as a new profile", and is always offered Discard. A switch note that exists but cannot be read (after waiting up to about 2.5 s, since a scanner or backup tool may hold it) is an unfinished switch with no known target: snapshots and switches refuse, and only Discard is offered, which removes the note (D57). Finishing a switch that was stopped part way (2026-10-26): the finish first writes the target's copy of the files the stopped switch was changing, skipping those that already hold it, removes any file or link the stopped switch left where the old point had a folder (git would refuse to clear that folder otherwise; the main checkout writes it back), and only then moves the folder to the target, so a switch killed mid-checkout finishes instead of being refused as unsaved changes. Any other change in the folder, an edited file the switch removes, or a folder SavePoint could not check, holds the finish back before anything is written and offers only Discard, with copy saying why. The launch dialog says how many files finishing will replace, because a half-written file and one changed since the switch stopped look alike, and names them for the saves folder (up to 5). A case-only rename is finished on Windows and macOS too. Calls made after real use (2026-10-27):
    • Waiting for a held note. Reading or clearing a note retries after 50, 100, 200, 400, 800 and 1000 ms (2.55 s in all), without holding a thread. Common practice sets the size. SQLite retries a file antivirus holds for about 1.4 s, and Git for Windows retries for 71 ms before it asks. The earlier 180 ms gave up on a normal scan and pushed a player toward Discard for nothing. Measured on 2026-10-27, Defender held none of the files for a read, an exclusive open, a delete or a replace (p99 and max 0 ms), because it scans inside the close (#225). The PC was a mid-range Windows 11 Home machine (4 cores, 8 GB, Defender real-time on), tested idle and with three copy and compress workers at full CPU. Each case used 600 small files, written plainly and through a temp file and rename, including .exe and .ps1 lookalikes. The schedule stays as sized, since a wait costs nothing unless something does hold the file. Other scanners, backup tools and cloud sync clients were not measured. A status that only reports reads the note once, without waiting.
    • Links are removed as links. A link (or a junction on Windows) standing where the old point had a folder is removed as the link itself, never through it, so what it points to is untouched. A link the stopped switch did not write is listed as replaced, like any other file: on Windows any link (the switch writes a link as a plain file there), elsewhere one whose text does not match the target's.
    • Read-only files. On Windows a finish clears the read-only mark on a file it removes, as git's own path writes would replace it, and puts the mark back if the file could not be removed.
    • Errors name the step. A finish that cannot write or remove a file says which step and which file, not that git could not update.
  7. A partial after-play save is retried as the same choice (BL-008). The orchestrator and the profiles service share one CaptureRunner; a retry reruns that completion's plan for the failed folders under the original capture id, so the session still yields one point.
  8. A folder a profile never saved is left alone (BL-012). Launching a profile with no points in one folder (a saves folder added later) leaves that folder as it is; the after-play capture adds it. No empty branches are seeded.
  9. One function picks the commit that stands for a point in a folder (BL-024), shared by History and the launch resolver. A folder with no commit at or before the point is left as it is. Points are ordered by a millisecond capture time in the Savepoint-Captured-At trailer, then commit order, so two captures within one second cannot be confused.
  10. A storage move deletes the old copies, and reports what it could not remove. After the copy is verified and SavePoint has switched roots, the old git directories are deleted (v1 left them). One that cannot be removed (another program has it open, say) is named in the job's lines and left; StorageRelocationResult lists them, the job ends Partial when the list is not empty, and the App shows it. Removal ignores cancellation once the switch is done. A move first writes an in-progress marker in its destination, and a later move to a folder still carrying it is refused with copy saying an earlier move did not finish (BL-019).
  11. Closing during a long job asks first (BL-019). Closing during clear-all, a storage move, or a switch (which leaves the folder with a mix of two snapshots) asks. So does closing during a snapshot (decided 2026-10-25), since stopping it keeps nothing: Minimize (the default; the snapshot finishes and the job notification says when, D26), Close and stop the snapshot, or Stay open. A Free up space past its point of no return offers only "Quit when it's done" and waits (D45.3). A minimized window is restored before any question. A Free up space before its point of no return, and a switch before it changes a folder, stop without asking, since they lose nothing. A system shutdown or log-off never waits on a question. Otherwise exit cancels cancellable jobs and waits up to three seconds, and any git still running is killed as the process ends, so no git outlives the app (an AppImage's mount stays only while a child holds it). A SavePoint stopped from outside skips that; D59 covers it. On Linux the kill stops the whole git tree first, then kills it: a stopped tree cannot fork, so no child started mid-walk escapes to init, and .NET's Kill(entireProcessTree: true) left a window in which an exit left git stopped under init.
  12. Consent-marker game ids are validated (BL-013). A marker whose gameId fails the catalog's id rule counts as corrupt, and the storage paths refuse rooted ids, separators, and dot segments, so no marker path can leave the storage root (on Windows a UNC id would send the user's network login hash to a remote server).
  13. Errors keep their meaning (BL-026). A git failure that is not a file in use gets its own message id and copy; a duplicate game and "no saved history to reconnect" get typed errors.

Every other finding was fixed as recommended. D18's stale-lock rule is restated to match the code: the startup sweep removes every lock once, before any git work (BL-029). UnavailableLaunchApi and its copy move to the test project, since every shipped build has the orchestrator (YAGNI-001); error.launch.unavailable is gone and BackendOptions.Launch is required.

D32. Builds send no telemetry

Avalonia's packages bring in Avalonia.BuildServices, whose AvaloniaStats task sends anonymous build telemetry (machine id, hashed project and machine names, OS, tooling) from every compile unless AVALONIA_TELEMETRY_OPTOUT=1 is set. SavePoint is local-first and its builds run by the hundred on developers' machines, so Directory.Build.targets defines an empty AvaloniaStats target that replaces the package's, whatever the environment holds. The shipped app was never affected (the telemetry is build-time only). The .NET CLI's telemetry is off through DOTNET_CLI_TELEMETRY_OPTOUT=1, set by the gate scripts and the test runner script.

D33. Packaging with Velopack, no automatic update checks

v2 packages with Velopack 1.2.161 (newest stable on 2026-10-21), an installer and a portable build per OS. The Velopack package goes in the App, and VelopackApp.Build().Run() is the first call in Main. The vpk CLI is pinned as a local tool in .config/dotnet-tools.json, never installed globally.

  • Windows (win-x64): a self-contained dotnet publish, then vpk pack, giving SavePoint-Setup.exe (per-user install, Start menu shortcut, uninstall entry) and SavePoint-Portable.zip.
  • Linux (linux-x64): the same on Linux (on the Linux VM here, D60), giving an .AppImage.
  • macOS: vpk pack must run on macOS and the result must be signed and notarized, neither possible here, so macOS packages are documented but not produced (D9).
  • Every package holds the app, the pruned git bundle in git/ (copied by build/Git.targets on publish), THIRD-PARTY-NOTICES.md, and licenses/. Each release publishes or links the source archives of its git bundles (D21).
  • No automatic update checks. The app makes no request the user did not ask for (D30's artwork lookup is the only one, behind its setting), and no release feed exists. Velopack contacts a feed only when the app calls UpdateManager, which v2 never does. A newer release installs over an older one by running its setup. An opt-in "check for updates" waits for a feed and its own decision.
  • Versions: one Version property in Directory.Build.props (semver, pre-release until 1.0) feeds the assembly versions, the About section, and vpk pack --packVersion. Every package of a version shares the number, so the scripts put the commit into the informational version (0.9.0+<commit>).
  • Settled while building it:
    • Version: 0.9.0.
    • Startup order: VelopackApp.Build().Run() is literally the first statement of Main, because vpk checks for it there and warns about a wrapper. A test reads Main's IL to pin it.
    • vpk flags: --shortcuts StartMenuRoot (no desktop shortcut), --skip-updates, and an --exclude dropping .pdb files and the two XML doc files.
    • Outputs:
      • Windows: SavePoint-win-Setup.exe, SavePoint-win-Portable.zip, SavePoint-<version>-full.nupkg (named after the pack id, D38), and vpk's release index files.
      • Linux: SavePoint.AppImage and SavePoint-<version>-linux-full.nupkg.
    • From the final review (D41): a tree with uncommitted changes is refused unless a trial package is asked for. Each package's contents are listed in artifacts/release/contents-<rid>/ and checked for the git bundle, the notices, and the license texts.
  • Source archives. Their hashes, all three tag hashes included, are pinned in build/git-manifest.json (since 0.9.0). The -Sources run prints each tag archive's SHA-256, checks every download against its pin before anything is published, fails on a mismatch, and keeps only matching downloads (D42). The MSYS2 and MINGW package sources D21 promises are published since 0.9.2 (from 0.9.5 in the git sources release): build/msys2-sources.json pins one archive per package line in MinGit's etc/package-versions.txt (50 archives, about 670 MiB, from repo.msys2.org and Git for Windows' pacman-repo releases). A file in artifacts/release/source/packages/ the list no longer names is removed before any download, so a release never publishes sources for packages it does not ship. A MinGit update regenerates the list with build/msys2-sources.ps1, which checks each archive's signature against a pinned key before taking its hash. Both package scripts read the JSON lists through tools/PackageSources, so a reformatted list reads the same.
  • Releases from CI. The tag's draft pre-release is created if missing. Files over 95,000,000 bytes go up as 90 MiB .partN pieces, because Cloudflare refuses larger uploads; a re-run replaces the assets and removes stale pieces. Each package job hashes its files before upload (every file, every piece, each split file whole), uploads the list as SHA256SUMS-<folder>.txt, and passes it on as a job output. The last job reads only the release's asset list: it checks every asset against the lists by name and size (and the pieces' numbering), writes SHA256SUMS.txt, removes the per-job lists, and adds the "Source code of the bundled git" link. It downloads nothing, because the workflow's token cannot read the draft. build/release-assets.ps1 -Action Checksums, run by hand, does the same from the uploaded lists.
  • Not yet covered: the packages are unsigned, so SmartScreen warns on the setup.

D34. A local diagnostic log and a crash handler

v1's plan keeps each error's English message as detail "for logs and a Show details toggle", but nothing wrote a log, so a reported failure or crash left no trace.

  • Core logs through IDiagnosticLog (information, warning, error, each with an optional exception), passed in BackendOptions. The default writes nothing, so tests stay quiet. Core gains no logging dependency and no static state.

  • What is logged:

    • start-up: app version, the commit the package was built from, OS, the git bundle's path and version, and each startup check's result;
    • every Api failure, once, in ApiGuard, with the member's name, message id, English message, exception type and stack: a SavepointException as a warning, anything else as an error. A caller's own cancellation is not logged, because screens cancel reads on every navigation;
    • every job's start, end, status, and duration;
    • launch session changes, once per phase, not per progress tick;
    • each step of a storage move or a clear-all;
    • failed git commands as warnings (probes allow some exit codes): the arguments, exit code, and end of stderr;
    • from the final review (D41): a failed artwork lookup as a warning; what a discard, a switch, a save that left a folder alone or skipped it, a profile delete, and a game delete did, with paths, bytes, and branch tips removed (D41.10); an exception thrown by an event subscriber.

    Paths appear as they are; the log never leaves the machine.

  • The App writes files with Serilog 4.4.0 and Serilog.Sinks.File 7.0.0, proven libraries for rolling, size limits, and safe writes. The logger is passed in, never the static Log. Files are savepoint-<date>.log in the platform's logs folder (AppDirectories.LogsDir), rolled daily and at 10 MB, newest 14 kept. The sink is unbuffered, so every line reaches the disk at once. The backend wraps the log so a throwing log can never break the Api's no-exception rule.

  • Unhandled exceptions from the UI thread, the thread pool, or unobserved tasks are logged; an unobserved task exception is also observed. A UI-thread or domain-level crash asks running jobs to stop, shows a last window ("SavePoint ran into a problem and has to close") with Show details and the log folder, and exits with code 1, because continuing in an unknown state could touch game folders wrongly. A second crash while that window is up is only logged; with no responsive UI thread the handler gives up on the window after 5 seconds.

  • Settings > About gets "Open the log folder". "Clear all data" empties the log folder except the file in use, which IDiagnosticLog.CurrentFile names: Windows refuses to delete it, and Linux or macOS would unlink the live file.

  • The startup screen for a backend that failed to start names the log folder and opens it.

D35. The "only the save changes" switch belongs to the check before playing

v1's visual spec gives one setting two homes. The launch dialog's "Don't ask again when only the save changes" box (2b) writes it, matching the code: it skips the pre-launch check when only the save would change. Settings (2k) lists it under "When you finish playing" as "Skip the confirmation when only the save changes", which reads as the after-play question (UX-012).

Behavior stays as the launch dialog defines it. Settings gives the switch its own "Before you play" group, labeled "Skip the check before playing when only the save changes", captioned "A change to the game version or mods always shows the check." A switch that would leave a folder empty always shows it too (D65). "When you finish playing" keeps only "Ask whether to save the session".

D36. Calls on the UX and accessibility review's open questions

  • OS scaling (OQ1). SavePoint works at 150% on 1366x768 and 200% on 1920x1080, about 960x490 logical pixels after the taskbar. The window's minimum size fits that (times the Interface size, D63), every screen scrolls vertically instead of clipping, and headless renders at those sizes prove it.
  • Slow scans (OQ2). Play shows "Checking your files..." at once, before the preview returns; "Save them first" shows progress too. The log (D34) times the scans.
  • Screen readers (OQ3). Live regions raise the UI Automation live-region event when their text changes, and banners and error cards are announced when they appear; tests assert the events. A manual Narrator and NVDA pass is on the dogfood run, since it cannot be automated here.
  • Focus after a refresh (OQ4) and the History filter's arrow keys (OQ8): a headless test settles each.
  • Artwork disclosure (OQ5). The lookup stays on by default (D30). The first-run screen says in one line that SavePoint downloads cover art for Steam games from Steam and that Settings can turn it off, disclosing the one network request before it happens.
  • Re-pointing a folder (OQ6): D31 item 4. The "only the save changes" switch (OQ7): D35.
  • Rules kept from the review. An accessible name contains the visible text, so voice control can say what it sees. RoleContrastTests computes contrast from the generated palette, so a regressing theme change fails a test. In the rail, arrow keys only mark a game, so they never pull the player off a half-filled Settings page. The shelf shows only on Games with no page open, so there a selection is all a pick needs.

D37. Fixes from the recheck of the review fixes

The recheck of D31 found 29 fixed, 1 fixed differently, 3 partly fixed, 0 open, plus four new warnings (RC-001 to RC-004) and eleven suggestions. The recommended fixes are adopted, with these calls:

  1. Storage that is gone for good (RC-001; refined by D41.4 to D41.6 and D42.1). Unreachable storage is a startup finding, like an unavailable git, with three choices:

    • "Try again", once the drive is back;
    • "Find the folder": re-point the saved root at a folder holding SavePoint's stamped git directories for the catalog's games, a settings change that copies nothing;
    • "Start with an empty folder", after a confirmation naming the old path. It starts over in the platform's default storage folder and leaves the old folder, and its snapshots, untouched and unused.

    Each choice checks again that the storage is lost once it holds the exclusive gate, so a second choice queued behind the first cannot replace the root the first found. If the storage is reachable by then, SavePoint says so and changes nothing, and the player uses Try again. When a choice fails, the startup screen shows the message and the folder the error names, on the error card's path surface.

  2. A folder a profile never saved (RC-002, refines D31 item 8). It is still left as it is but read like every other folder, so another profile's unsaved changes there block the launch with their owner named. The profile's first save of it is a new history (a root commit, CaptureMode.Root), never a fork of another profile's branch: it holds what the folder holds now, from whatever branch the folder is on. Where the repository already has a point, it writes one even when nothing changed. On a repository with none it is a normal capture, and an empty folder gets an empty branch.

  3. Folders "Go back to this" leaves alone (RC-003).

    • Each one's commit and branch at launch are recorded as its start, so fork and move-forward check it like every other folder.
    • "Continue from here" is offered only when that start lies on the profile's own branch.
    • For "Keep as a new point" and "Update existing", whether such a folder is saved or skipped is decided before the save, never discovered as a half-failure.
  4. Stray folders in the storage root (RC-004 and the scan suggestion). A folder whose name is not a game id, such as "game - Copy", never fails a move after the switch. A move carries everything in the storage root and removes a readable non-game folder from the old root with the rest; only a folder that cannot be opened and is not named like a game folder stays. The move fails (sourceUnreadable) only when anything else in the storage cannot be read.

  5. Files held open (the suggestions on the racy fix). The launch preview names a held file and offers "Try again" instead of Keep and Discard; a switch can also stop before it starts on a file it found in use. A folder whose only changes are held files counts as clean for a switch; a save treats it as "cannot tell" (D41.1). Only a sharing or lock violation counts as "in use"; access denied gets its own message, naming the file.

The three partly fixed findings (BL-019, BL-026, BL-032) were completed. On macOS an application-level shutdown (Cmd+Q) also asks during clear-all or a storage move, because Cmd+Q can bypass the window close the exit guard hooks; this is not yet checked on a Mac.

D38. The installer's folder is never SavePoint's data folder

Velopack's Windows setup installs into %LOCALAPPDATA%\<pack id> and replaces or removes that whole folder on install and uninstall. D33's pack id SavePoint made the setup own %LOCALAPPDATA%\SavePoint, where SavePoint also kept its default storage (every game's history) and logs, so uninstalling, or installing over a portable copy that had run, would have deleted them. Found while writing the dogfood checklist, before any package was installed.

  • The pack id is SavePoint on every platform (decided 2026-10-25, before 1.0), Windows one release after Linux (Linux in 0.9.11, Windows in 0.9.12). It lives in <SavepointPackId> in Directory.Build.props, which both package scripts read; 0.9.11 alone kept SavePointApp for package.ps1 through a temporary <SavepointWindowsPackId>. On Linux the id names the AppImage's desktop entry and window class (DesktopIdentity.WindowClass), which GNOME showed as the notification sender. An earlier split kept SavePointApp on Windows only to stay clear of the data folder; one name everywhere was wanted. An install made under the old id does not update to the new one.
  • SavePoint's data is never inside the folder the setup owns. The setup empties %LOCALAPPDATA%\<pack id> on install (keeping a renamed copy only to roll back a failed install) and uninstall, replaces only the app files on update, and never touches %APPDATA%. So on Windows the default storage, logs and runtime folder live in %LOCALAPPDATA%\SavePoint Data (Storage, Logs, Runtime), and the catalog stays in %APPDATA%\SavePoint. Settings refuses, and flags if already saved, a storage folder inside %LOCALAPPDATA%\SavePoint (what a SavePoint setup empties) or %LOCALAPPDATA%\SavePointApp (where every install made before the switch keeps its app files).
  • Data in the old place moves once. At startup, before anything reads the store, if %LOCALAPPDATA%\SavePoint\Storage holds stores, the new default is missing or empty, and the saved root is blank or that old default, the folder is renamed to the new default (one same-drive rename, instant and atomic). The setting follows, and the rename is undone if it cannot be written. Old log files move one by one without overwriting. A storage folder chosen elsewhere never moves.
    • If the rename fails (a file in use, access denied), or the new default holds other files, the data stays and the old folder becomes the saved root, so the history is not hidden behind an empty default. A warning that stays until dismissed, and a Settings note, say to move the snapshot folder before installing or removing SavePoint.
    • A move stopped between the rename and the setting (settings name the old default, now empty or gone, while the new default holds stores) is finished at the next start by saving the new default. Settings naming the new default while it is missing or empty and the old folder holds stores finish the same way. The rename is undone only when the settings, read again, still name the old folder or none, so a write that landed but could not be read back is never undone.
    • When the history's folder cannot be saved as the root at all (settings cannot be written), it is used for that run only, nothing written: the history shows, the warning and note appear, and the next start tries again. The same holds after a failed undo.
    • A folder holding only the "Start with an empty folder" marker counts as empty throughout.
  • The Windows switch is staged. Every Windows release up to 0.9.10 was packed as SavePointApp but kept its data in %LOCALAPPDATA%\SavePoint, which a SavePoint setup renames and empties before the app runs. So 0.9.11 adds the move and keeps the Windows pack id SavePointApp (installed over an older one it leaves %LOCALAPPDATA%\SavePoint alone, and its first start moves the data out), and 0.9.12 switches Windows to SavePoint. An install that skips 0.9.11 loses what was left in the old folder. The SavePoint setup does not update a SavePointApp install: it installs beside it (Settings > Apps lists "SavePoint 0.9.11" and "SavePoint 0.9.12") and takes over the Start menu shortcut. Removing the old one from Windows Settings > Apps leaves the data and the shortcut (checked on the Windows VM on 2026-10-25: 0.9.11 with data in SavePoint Data, then the 0.9.12 setup, then removing 0.9.11).
  • Downloads keep the app's name: vpk names them SavePoint-win-Setup.exe, SavePoint-win-Portable.zip and SavePoint.AppImage from the pack id.
  • A test pins the rule. PackageLocationTests checks that no data folder lies inside %LOCALAPPDATA%\<pack id> and that both scripts take the pack id from the build properties.
  • Uninstalling keeps the user's data. "Remove all SavePoint data" before uninstalling removes it too.
  • A storage move refuses a destination inside SavePoint's install folder, which the next update or uninstall would delete.

D39. Calls on the final gap analysis

The final gap analysis (GAP-001 to GAP-027) is settled:

  • Languages (GAP-010, GAP-011; refines D20). v2 ships English only. Catalogs are embedded at build time, so a language is added as Localization/Assets/Lang/<code>/*.json and a rebuild. Settings shows no language list until a second catalog exists. The saved locale stays en; its validation message says only that the language is not available. The developer guide has an "Adding a language" section.
  • API reference (GAP-013; refines D24). No reference site then (D55 later builds one from Core): SavePoint has no SDK, and the XML docs reach every IDE. D24's compiler enforcement stays for Core. The App's public surface exists for XAML binding, so CS1591 stays off there, and the App documents its non-obvious contracts by hand (GAP-027).
  • Profile rows (GAP-016). A row stays a tab stop, because it carries the row's spoken summary, and Enter on a focused row starts Play. The table's semantics stay.
  • Built for the polish pass:
    • real byte progress during a switch (GAP-009);
    • the single-instance lock-file fallback (D26), with the app icon on the "already running" window (GAP-014);
    • the unreachable stand-ins removed from the shipped app: startup.unavailable.*, StartupPhase.Unavailable, and the placeholder screen with its copy (GAP-017);
    • path-safety and overlap errors that carry the folder's role (GAP-015);
    • a copy pass (GAP-018, GAP-019): American spelling, one dash style (D44.8 later bans the em dash), and helper lines ending with a period;
    • re-rendering 2a-2l and 3a-3c, reviewed against the mockups (GAP-007).
  • Still open (GAP-004, GAP-006, GAP-008): the manual dogfood run and code signing, tracked in the issue tracker. SavePoint's license is settled: GPL-3.0-or-later (LICENSE).
  • The final code review (GAP-005) runs after the polish pass, over everything since the backend review.

D40. Mockup differences left after the final renders

The final renders (2a-2l, 3a-3c) were compared with the v1 screenshots. Differences a decision covers (D19, D23, D30, D36, the accessibility review) stand. The rest:

  • History groups say "Last 7 days", not "This week" (2j). "This week" leaves open whether the week starts Sunday, Monday, or seven days ago; the grouping is the last seven days.
  • Quiet text uses the SubtleText role at tone 40 (light) and 70 (dark), not outline (the token table). outline fails WCAG AA for body-size text on the surface colors; the role keeps the lighter look at a passing contrast.
  • The saves folder preview shows the full resolved path (2f). A shortened path can hide which of two similar folders was chosen, and the editor is where that mistake is caught.
  • The "Try something like..." suggestion on a refused folder sits in the error's paragraph (2l), not on a colored line under the path, so it reads as part of its error.
  • The launch banner (2a) is pinned at the bottom of the pane, as the mockup draws it, above the storage footer, and the checking, saving, and running cards go there too. A failure or partial-result card stays under the table and scrolls into view: it can be about 200 px tall and, pinned, would leave the table about 17 px at the smallest window. Toasts float over the content, so a Games pane shorter than 300 px (the library layout at a window height of 460 px or less) cannot pin even the shorter cards; there they scroll with the profiles.
  • Theme measures. shell:BrandMark centers the bookmark by its ink, not its em box, to match the app icon. Md3DialogPadding is 30: the 26 of air around a dialog's content plus room for a footer button's focus ring.

D41. Calls on the final code review

The final code review (FR-001 to FR-032, YAGNI-001 to YAGNI-006) found no critical findings and six warnings, and confirmed the engine review's fixes. Findings not named here were fixed as recommended or skipped with a one-line reason.

  1. A held file is "cannot tell" when saving (FR-001, refines D37.5). For a switch, a folder whose only changes are files SavePoint cannot open still counts as clean, and the launch names the file and offers "Try again". A save never skips such a folder as clean: it runs, fails with the held-file error naming the file, and the existing retry applies. The after-play dialog counts held files. So an unchanged file another program holds also fails "Update existing" until it is let go, since SavePoint cannot tell it is unchanged without reading it.
  2. Files the ignore list names (FR-002, settles an engine review finding; amended by D43.1). A switch leaves every such file exactly as it is on disk, whether or not a point recorded it, and never refuses because of one, except where a file and a folder would share a path (D43.1). A save stops recording such a file, so later points do not hold it; earlier points keep it. A discard leaves it too. A switch stopped part way must still leave it as it was. A forced switch also protects a named file both points record alike (found in review: it was written back over the player's copy). A path that is a file at one point and a folder at the other is classified whole (each group of paths gets its own index), so a switch between them never removes a named file.
  3. "Try again" after a failed check re-enters the check for the target the player chose (FR-003). Nothing from an earlier start carries over.
  4. A storage root change gives every listed game its repositories (FR-004). After "Start with an empty folder", and for each game a "Find the folder" target lacks, SavePoint creates the game's empty repositories at once (InitAsync, for each folder whose consent marker names the game). A folder that cannot be confirmed then is skipped with a log line, and its first save makes the repository. If the repositories cannot be written (writeFailed), the player can try again once the drive has room or the folder is not read-only. Games and profiles stay listed, each profile starts its history again with its next save, and the confirmation says so.
  5. Git never runs a program a repository names (FR-005). Every git process starts with hooks pointed at an empty folder SavePoint owns and core.fsmonitor off, set through the environment (GIT_CONFIG_COUNT, which outranks a repository's own config). A repository's config keeps only the keys git init writes plus SavePoint's own. A folder adopted through "Find the folder" has its configs rewritten and hooks folders emptied before any other git call.
  6. "Find the folder" runs a storage move's destination checks (FR-006): the installer-owned folder (D38), an unfinished move's marker, and overlap with game folders.
  7. A left folder never forks another profile's history (FR-009). D37.2 wins over the fork "Keep as a new profile" would make: that folder's first point in the new profile has nothing behind it.
  8. The fallback after-play choices for an older point decide "Continue" from the recorded starts alone (FR-010), as D37.3 does, with no folder read.
  9. Unreadable settings mean online artwork lookup is off (FR-018). Privacy wins over art. SavePoint leaves an unreadable settings file as it found it.
  10. Successful discards and deletes are logged (FR-021): the folder or game, what was removed, and how many files, so the log answers what SavePoint deleted.
  11. Switch progress moves while git removes files (FR-029). The dialog's share and time left follow whichever of files and bytes is further along, so a removal-heavy switch never stands at 0%. Sizes come from the stored snapshot (SwitchSummary), never from reading the folder. From the end of the writes to the end of the switch, the dialog and Activity say "Making sure every file is in place" instead of a stalled figure.
    • One index refresh. After git writes the files, a switch or discard refreshes the index once (git update-index -q --refresh) before checking every file. A file written in the same second as the index cannot be trusted by its time, and every status SavePoint runs sets GIT_OPTIONAL_LOCKS=0, so nothing else rewrote the index and every later status, preview, dirty check and checkout read such files in full. On a 12 GB install with one 4 GB file (NVMe), removing that file went from about 42 s across the Go back preview, the launch's status read and the switch to about 2 s. Writing it still reads it once, in the refresh (about 8 s for 4 GB), the content check D41 keeps.
    • Left-out files are read once. A named file differing from the target was read in full three more times (the checkout's own refresh, this refresh, the check of every file) only to be left alone. The aligned index now marks those entries skip-worktree until the check ends, so the alignment is the one read (a 2 GB left-out cache: about 22 s to about 15 s).
    • The alignment skips files that cannot match. A left-out file that is absent, or whose size differs from the target's, cannot hold the target's bytes, so its entry is written from the switch plan with update-index -z --index-info (mode 0 for a path the target lacks); git reads an unstamped entry before trusting it. Only a same-size file, a link, a gitlink or an unknown size goes through reset <tree> -- <paths>, which keeps a valid stamp for a file already holding the target's bytes. Removals go first, then the reset, then the written entries, so the reset's refresh stays small. On the bundled git, a 2 GB left-out cache differing in size took the alignment from about 12.4 s to 0.34 s, and the whole switch from 12.8 s to 0.71 s.
    • No mark stays. The mark is cleared in every outcome. A killed SavePoint cannot clear it, so every switch, discard and save first clears any mark it finds: SavePoint never wants one at rest, and a leftover would hide a change from every later save. It finds them by reading the index file itself (versions 2 to 4), asking git only when an entry carries a mark, and asks git for anything it cannot be sure of (a damaged or unfamiliar index, a mismatched checksum, a split or sparse index, a repository not using SHA-1). An index of 50,000 entries takes about 35 ms against 65 to 77 ms for git, and far less when smaller.
  12. Restructures are deferred (FR-022, FR-027) unless a fix needs the shared piece; the move's destination checks are shared with "Find the folder" (item 6).
  13. YAGNI: members kept only for tests or for paths no shipped build reaches go (YAGNI-001, 002, 004, 006, and 003 unless item 7's or FR-008's fix makes the path live). The 1024 px icon and IconGen's output folder stay for a future macOS package (YAGNI-005).
  14. Documentation (FR-028, FR-032's doc half) is a separate documentation pass, not part of the fixes.

D42. Calls on the recheck of the final review's fixes

The recheck found 25 of 38 items fixed and none open, plus RF-001 to RF-027 (five warnings), each fixed as recommended, except:

  1. "Find the folder" never follows a link (RF-001, RF-002). A candidate whose game folder, git directory, hooks folder, or config is a link, or resolves outside the candidate, is refused whole, before anything is written, with its own error naming the path. A repository config counts as current only when its text is exactly what SavePoint would write, so it is rewritten whenever it holds anything beyond git init's keys and SavePoint's block, whatever its stamp. Every git process also runs with commit.gpgSign and tag.gpgSign off, so no repository setting can name a program SavePoint runs.
  2. "Update existing" is a save (RF-014). Its point stops holding files the ignore list names, like every later save (D41.2); earlier points keep them. No change.
  3. Copy never suggests emptying a folder that holds history (RF-026). "Start with an empty folder" will not go ahead while the default folder holds snapshots, which it judges by a stamped git directory there having a branch, so a start that failed part way can be made again. The refusal says to move that folder away to start over, or to use it through "Find the folder".
  4. The Linux package is built from Windows like the Linux gate (RF-007). Linux git cannot follow a worktree made by Windows git, so build/package-linux.ps1 checks the commit out into the Linux-only worktree, asks Windows git for the commit and whether the tree is clean, and hands the commit to package.sh under WSL, which uses a given commit instead of asking git. D60 moved this to the Linux VM: the script sends the commit's tree there and runs package.sh.
  5. YAGNI-002 is done now (recheck note): the reason to defer it ended with the merge.

D43. Calls on the focused review of the last fix round

The focused review found one critical finding: a switch or discard that writes a file where the player's disk holds a folder deletes every ignore-listed file inside it, because git treats ignored files as expendable (LR-001). Settled:

  1. A file and a folder cannot share a path, so the switch refuses rather than delete (amends D41.2). When a switch or discard would write a file where the work tree holds a folder that still has files the operation does not itself remove (ignore-listed or untracked), or make a folder where the work tree holds an untracked or ignore-listed file, it refuses before writing, with its own error naming the folder and the file. The player moves or deletes those files and tries again. Silently deleting a file the player asked SavePoint to leave alone is never acceptable, and leaving the profile's file unwritten would leave the install silently incomplete. The check is on the file system, not git's rule for ignored files. A forced switch and a discard still remove plain new files inside such a folder, as they remove any new file the discard confirmation counted; they refuse over ignore-listed files and anything inside a nested repository. A non-forced switch refuses over any new file earlier, as unsaved work.
  2. Aligning the index never loses an entry silently (LR-002). The alignment works on a copy of the index, compared with the original before it is swapped in. Clean profile content that a named path displaces is handled under the switch journal, and any refusal puts the saved original index back.
  3. "Find the folder" walks every folder of a candidate git directory for links, and every recursive engine walk skips links (LR-003), since a repository can gain a link after adoption.
  4. A git directory cannot redirect git (LR-009). Every git process that names a repository runs with GIT_COMMON_DIR set to that git directory (per call, next to GIT_DIR). Git still reads refs through a commondir file even then, so every engine operation refuses a git directory holding one, and "Find the folder" refuses a candidate whose git directory holds a commondir file or whose objects/info/alternates names a path.
  5. The suggestions (LR-004 to LR-008) were fixed as recommended, or skipped with a one-line reason.

D44. Plain language, in-app help, an Activity screen, and a way back for removed snapshots

Dogfooding showed that some wording confused even readers who know git, and SavePoint's players may never have heard of version control. Banning the git words was not enough: "point", "switch", "left alone", "half switched", and "storage" still described the engine, not what a player sees. A plain-language audit and a sweep of v1's shipped renderer (which found v1's per-game Jobs tab missing) are settled as follows; the project chose items 1, 4, and 5.

  1. The vocabulary (decided: "snapshot"). The app keeps snapshots: a copy of a profile's game version, mods, and saves at one moment. "Save" means only the game's own save files. SavePoint's act is "take a snapshot" in status lines, "Keep" in choices, and "Create profile" in the wizard. The rest of the audit's table is adopted as written: "new changes" (not "unsaved changes"), "Loaded now" for every in-use marker, "Go back (to this)" as the one action on any snapshot, "Replace "X" with this session", "Continue "X" from this session", "a mix of two snapshots", "not included", "snapshot folder", "Free up space", "Files to leave out", and "game settings file". This departs from the v1 spec's copy rules as the audit lists; the History title keeps "...you can go back to". Copy may gain the audit's placeholders ({ownerName}, {pointName}, {profileName}).
  2. Permanence is stated where the choice is made: in the option's title or its confirm button, not only a subtitle.
  3. The profile row counts every snapshot of the profile (not only of the saves folder), with the ownership rule History's profile filter uses, so it matches History (a duplicate with no snapshot of its own reads 0). The row menu gains Take a snapshot now, which the no-snapshot error also points to; a profile that is not loaded is refused with error.profile.notLoaded before a job is queued.
  4. A way back for removed snapshots (decided). Snapshots that "Continue "X" from this session" or "Replace "X" with this session" take off a profile are listed in History under Recently removed until the next "Free up space", and each can be brought back as a new profile. The copy says exactly that, instead of promising a recovery the app cannot do. This supersedes the "recoverable until the next optimization" wording D14 and D28 had. As built:
    • Each removed snapshot is recorded before its profile moves, so a stop between the two leaves only a harmless record for a commit its branch still reaches (the listing skips those), never a commit neither on its branch nor recorded.
    • Branch listings, History, the delete-profile warning, the row count, and the launch resolver read only refs/heads.
    • Only Free up space clears the records; the automatic reclaim after a delete keeps them. Every Free up space (Settings, the Games footer, the library layout's game menu) asks first when it would delete some, and OptimizationMode.ReclaimClearingRemoved deletes them in one transaction. Settings' button is called Free up space and, before it is pressed, says how many snapshots in Recently removed it would delete for good (2026-10-27). It also says about how much space comes back (D66).
    • A profile brought back and later deleted puts its snapshot back in the list.
    • A saves-only snapshot whose origin profile is gone and whose install snapshot became another profile cannot be brought back (no install to start from).
    • Bring back creates every branch in both folders or none. A folder the snapshot did not record starts at the origin profile's latest commit at or before it.
    • A snapshot recorded in one folder only, whose other folder's commit with the same capture id a live profile still holds (a Replace or Continue that changed one folder), would fold into that profile's point if brought back as it is. So Bring back copies the recorded commit under a new snapshot id (same tree, parents, message, dates and empty-folders list), and one update-ref --stdin transaction creates the new profile's branch at the copy, records the copy and deletes the old record. The new point shows on its own; if that profile is deleted later, the snapshot is listed again under the new id. If a later step fails (the other folder's branch, or saving the profile), the branches are taken back and the snapshot stays listed under the new id, ready to bring back.
  5. An Activity screen (decided). A new rail item lists running and recent jobs for the selected game, with an "All games" filter that adds the jobs spanning every game (a snapshot-folder move, clearing SavePoint's data).
    • Each job shows what it is, its profile, status, progress, and times; Cancel stops one that can be stopped.
    • Details shows its output in plain words from the catalog (file paths and steps, never git's own text; the App formats each step's arguments). It is selectable for copying (Cmd+C on macOS, Ctrl+C elsewhere), follows new lines unless the player scrolled up, and says when it shows only part of a job's lines (LinesDropped tells a reader which lines are new). Every job kind writes steps, launch and free-up-space included, so no details are empty.
    • SavePoint remembers each game's last five finished tasks. A task the player has open stays listed until they pick another, so one more can show. The order keeps a busy game from pushing another game's tasks out. Since 2026-10-27 the list is kept across restarts in activity-history.json in the catalog folder. The file holds at most the newest 100 tasks, none older than 30 days (the same limits apply to the list while SavePoint runs). SavePoint writes it (temp file, then rename) as each task ends and before the task reads as finished. A running task is never written, so nothing comes back as running. A restored task keeps its title, status and first reason but not its steps, and its details say the steps were not kept. Clear all data deletes the file and is never itself written. An unreadable file starts the list empty and is logged. Finished rows read in the past tense ("Took a snapshot of ..."), and the player-facing word is "task".
    • The Games screen's tab strip links to Activity, and the job status pill opens it. The Games footer gains Free up space for that game, as v1 had.
  6. In-app help. A first-run tour of four steps (the profile row, Play, History, New profile) runs once after the first profile is made, can be skipped at every step, and can be replayed from Settings > Help. Six "What's this?" explanations open in place next to ideas such as snapshots, new changes, and replacing a snapshot. A "How SavePoint works" page in Settings > Help (also F1 and a link on the first-run screen) covers profiles, snapshots, playing, keeping a session, going back, Recently removed, Activity, freeing up space, how the game starts, files to leave out and cloud saves (added 2026-10-26, reached from the editor's question buttons), and ends with what cannot be undone. The app explains itself at three decisions: the first older-snapshot choice, a permanent discard, and the first Replace. All of it works by keyboard and screen reader, goes through the catalog (help.json), and stays out of an experienced player's way. As built: the page opens as a pane over the screen it covers, which is kept and comes back. The "seen" flags for the tour and the three decision notes live in the settings file (additive fields). The tour is marked seen when it starts, so closing mid-tour does not restart it, and it starts at most once per run. Explanations inside a dialog leave out the link to the page. Settings' theme, layout, and accent selectors no longer scroll themselves into view on open (Settings opened scrolled down and hid its title).
  7. Measuring it. Dogfooding is the comprehension test for now; a five-player test (the audit's OQ5) is a follow-up.
  8. No em dashes (decided; replaces D39's dash style). Many readers take an em dash for machine-written text. An aside is its own sentence or a comma clause, and the catalog lint rejects an em dash anywhere. The ellipsis and the middle dot stay.

D45. Calls on the review of the D44 work

The review found 3 critical findings, 4 warnings, and 11 suggestions, all in Recently removed, its copy, and one Activity cancel. Recording, both reclaim modes, moves, clear-all, delete game, reconnect, and keeping removed snapshots out of every profile view were sound. Settled:

  1. A removed snapshot is one unit (DR-001). It is identified by its capture, and each folder's commit comes from its own record, never inferred from which commits no branch reaches. Its card and Bring back use exactly those commits. It stays listed until every folder commit is on a profile's branch again.
  2. Free up space deletes only what it counted and asked about (DR-002). The preview counts and names the records; the job deletes those and no others. Records written after the preview stay, including every record of a snapshot that gained one since, and a run that found none deletes none.
  3. Free up space never says "nothing was lost" after it lost something (DR-003). It checks space for every folder before touching a record and deletes the counted records in every folder before reclaiming anything; from then on it cannot be canceled (the Activity row, the exit guard, and the copy say so). A refusal or stop before that point changes nothing.
  4. Only a profile's branch keeps a snapshot out of Recently removed (DR-004). A branch with no profile row (a crashed Bring back or Duplicate, a profile not reconnected) neither hides a removed snapshot nor keeps Free up space from freeing it.
  5. Copy says what really happens (DR-005, DR-006). The delete-profile warning says when its snapshots go to Recently removed instead of away for good, and Settings says which automatic cleanups run and that they keep Recently removed.
  6. Canceling a switch from Activity asks first and tells the truth (DR-007), like the launch's "Stop switching": the folder is left with a mix of two snapshots until the switch is finished or the changes are discarded.
  7. The suggestions were fixed as recommended, or skipped with a one-line reason.

D46. Calls on the recheck of D45

The recheck found 14 of 18 fixed, no critical findings, 3 warnings. Settled:

  1. A git SavePoint starts must not outlive it unnoticed (RR-001). A note in the git directory and a wait at the next start and before every game write, not a job object: .NET cannot tie a child's life to the app portably (Windows needs native job-object calls, Linux has no parent-death signal for a .NET child, macOS has neither). The wait applies only while that git still runs, matched by start time. Known cost: after a kill during a long repack, the next start waits for that git, and the startup screen says SavePoint is finishing a cleanup it started earlier. D59 (2026-10-26) adds a Windows job object and a note for every other git; the reclaim gits this item notes stay outside the job, so they still finish.
  2. A free-up cut off between its folders is finished, not undone (RR-002), because the player confirmed the deletion. Its note names every ref in both folders. Startup and every later free-up finish a note they find; until then the listing, the preview, and Bring back treat its refs as gone.
  3. The delete-profile warning judges each folder's commit on its own (RR-003).
  4. An all-games Free up space cannot be stopped between games (RR-004). Once it deletes, it runs to the end: one rule ("once it deletes, it finishes") and no "stopped after some games" state for players to decode.
  5. The preview token is opaque (RR-005, done 2026-10-24). Only the preview issues a FreeUpSpaceToken: its constructor is internal, and it carries an HMAC-SHA256 seal over its records with a random key held for the process's life, so the run refuses a hand-built or edited token before deleting anything. A token is good only in the process that issued it. Each record still carries the value the preview read, which also stops a stale token from deleting a moved branch. Tests issue or forge tokens through InternalsVisibleTo.
  6. DR-004 also removes a stray branch no profile names when every snapshot that branch alone holds is being deleted anyway. Free up space never deletes HEAD's branch or one a profile names, and an unreadable HEAD offers none. DR-003 follows D45.3 (no cancel once deleting starts) rather than the review's cancel between games.

D47. SavePoint's repositories do not trust a file's change time

The first native Linux CI run showed a preview counting an unchanged file. Git compares each file's stat data with the index, including the change time (ctime) by default. A permission change, an antivirus pass, or a backup tool moves ctime without editing the file, so git reports it modified, and the preview reads it again or, when it cannot, counts its whole size as new bytes.

The managed repository config sets core.trustCtime = false (config stamp 5, picked up the next time SavePoint touches an existing repository; D50 raises it to 6). Size and modification time still catch real edits. A program that rewrites a file at the same size and restores its old modification time would go unnoticed, which game launchers and mod managers do not do in practice.

D48. Calls on the way to 1.0

  1. The gate runs the App and Core test modules side by side. The one-module rule came from a machine-load problem that is gone. The App module runs one test at a time for most of its run (its UI tests share one headless UI thread), so running it beside Core uses idle threads. Each module keeps 4 test threads, and the gate keeps below-normal priority and the machine-wide lock. D70.3 later split the App module into lanes and gave Core 4 to 8 threads. Three consecutive Windows gates passed this way with no flaky test, under the load of four implementer agents building and testing at once.
  2. A skip the OS's list does not name fails the gate, because a broken skip probe would turn real tests into skips while the gate passed. The lists in build/expected-skips/ name each test that may skip by full name, so a new platform-specific test is a one-line edit. Lines with ~ mark timing-dependent skips. The local Linux gate on the Linux VM uses the CI list (D60).
  3. The error card never renders raw text (D44.5 holds there too). "Show details" explains in plain words and offers "Copy details for support", which copies the exception and git's output for a bug report; nothing technical is drawn. The crash window is the one exception (decided 2026-10-24): it opens after something unexpected broke, has no error code to translate, and is what support needs, so its Show details box may show the raw text. Nothing technical shows before the player asks, and "Copy details for support" copies exactly what the box shows: version and build, system, where it crashed, the log folder, and the exception.
  4. Error copy knows the operation. A held file or a full disk reads differently for a switch, a snapshot, Free up space, a snapshot-folder move and Clear all data. The App takes the operation from the job kind or the screen; an error without one gets neutral copy.
  5. Storage moves and clears name folders, not git's internals. Job lines report one line per game folder and part (game files or saves), and Settings' left-behind cards name the game's folder.
  6. A move from an empty storage folder is allowed only from SavePoint's own empty start. "Start with an empty folder" writes a marker into the folder it makes; a storage folder holding only that marker is SavePoint's own, has nothing to lose, and can move. An empty folder without it, or one with anything else in it, stays refused, since it may be the wrong drive at that path (BL-004).
  7. A link start's grace is two minutes (D13.10), and the editor suggests the process name. Without a process name, SavePoint cannot tell when a game started through a link closes.
    • The suggestion. With the link method chosen and the name empty, the editor suggests the likely game program from the install folder (launchers, anti-cheat bootstraps, redistributables, crash reporters and tools ranked down) and says why. On this machine it picks a sensible program for all but two of 205 installed games. The editor's start-file list uses the same ranking (programs the suggestion would drop follow, by depth and size). A program the player chose is never replaced, and the list is asked for again when the game's name changes.
    • Linux installs have their own shapes (checked on the Linux test VM in October 2026, after Counter-Strike: Source was given Valve's vpk tool). A program named after a launcher script beside it wins (cstrike.sh gives cstrike_linux64, a 16 KB program smaller than every tool). Scripts rank below programs. Valve's tools (vpk, bspzip, vtf2tga, simdtest) and Steam's client binaries are never suggested. Unity's .x86_64 builds rank up, and Unreal's Binaries/Linux folder counts like Win64.
    • The started program is not the game it hands over to, even under the same name: a Steam game started directly often exits at once and has Steam start it again, which ended the session after a second. When the started program exits within 30 seconds with an error code, SavePoint waits up to the grace for a same-named program with another process id and follows it; a clean exit (code 0) of the named program after at least 10 seconds of running waits only two process-list looks (D13.10); when it ran longer, its exit ends the session at once, so a normal quit is not held up. When the started program was the game and no copy follows, the session ends at its exit, so the wait never counts as play time. The log names how a session ended and the process ids it followed.
  8. On Linux, a git that has exited but was never reaped counts as gone. The stamp check and the wait at start read the process state from /proc, like the process list, so a container whose PID 1 never reaps does not make the next start wait forever.
  9. Where the gates and CI run. CI runs the Linux gate natively and the Windows gate on a self-hosted Windows 11 VM running forgejo-runner in host mode under a standard account, label windows. The Linux CI job installs PowerShell, gpg and dbus-daemon (for the notification tests). PowerShell 7 is necessary on every OS for the full test run, because the build and release scripts' tests drive those scripts through it. The App tests load the Linux Skia build that needs no fontconfig, so the Linux VM needs nothing beyond what its gate script installs (D60). The Linux desktop checks cover what no gate can: single instance (a second start brings the first window forward), whose tests skip in CI, and case-only clashes on an NTFS or exFAT drive. A full run of both test projects starts tens of thousands of processes; on some Windows machines security or monitoring software slows every process start to a second or more and keeps memory for each exited process until reboot.
  10. Files are edited only with an editor or the agent harness's Edit tool. sed, awk, perl, python, PowerShell and shell redirects are banned for edits: they fail silently, report false successes, and can change other files.

D49. Switching to a profile or snapshot without playing

Play was the only way to load a profile's files, so a player who wanted only the files (to work on mods in a mod manager, copy a save, back up the folder by hand, or start the game another way) had to start the game and quit it.

  1. A switch is a launch that stops before the start. ILaunchApi.SwitchAsync runs the launch's own preparation (the check, the preview, the guards for new changes, a running game and held files, and the progress dialog, worded for a switch) as a JobKind.Switch job and stops where a launch would start the game. One pipeline means the two cannot drift apart.
  2. No session, no play time, no after-play dialog. Nothing waits for the game to exit, and the last-played time stays. The profile reads "Loaded now" afterwards.
  3. The game stays claimed for the whole switch job. A launch, a second switch, a discard, a game or profile delete, a snapshot-folder move and Clear all data are refused meanwhile with their own message (error.gameService.switching: SavePoint is switching that game's files right now), not the running-game one. The claim is released on every exit path, including cancel and failure.
  4. A stopped switch recovers like a launch's. Stopped while writing files, the folder is left unfinished; the next switch to the same point finishes it, and Play to another point is refused until then.
  5. Try again and the recovery buttons stay a switch. "Try again", "Finish the switch" and "Review the changes" after a failed switch start another switch, never the game.
  6. A switch notifies when it finishes, like the other long jobs: a toast says the files are in place and the game was not started. A launch does not, since the game opening is the signal.
  7. The errors that said "Play this profile first" offer the switch. error.profile.notLoaded opens a confirmation with "Switch to this profile", and error.gameService.profileActive offers a switch to the first other profile in the table.
  8. Labels say whether the game starts (2026-10-26). A review found "Go back to this" and "Switch to this snapshot" did not say which one starts the game, and "Switch" is profile wording. History now offers "Go back and play" and "Go back without playing" on cards, timeline entries and save rows. A profile that is not loaded shows "Switch and play" instead of Play, so the player knows files change first; while the row's state is not known yet it shows Play. "Take a snapshot" also sits beside the Profiles tab and is off while a snapshot of that game runs, so a second press cannot queue a second one.

D50. Packs are written without zlib

Files above core.bigFileThreshold (128 MiB) stream straight into a pack, which core.looseCompression = 0 does not cover and pack.compression does. On a real 85 GiB install (Cyberpunk 2077 from GOG: 5,068 files, 98.8% of the bytes in 17 archives over the threshold), a first snapshot took 35 minutes with the default compression and 9 minutes with pack.compression = 0 (about 44 against 168 MB/s), for a store 2.4% larger (85.2 against 83.1 GiB). Two default runs differed by 4% in time and gave byte-identical stores. Game archives are already compressed, so zlib spends most of a large capture to save little.

The managed repository config sets pack.compression = 0 (config stamp 6, raised to 7 by D58, picked up the next time SavePoint touches an existing repository). Only captures write without zlib. The routine and reclaim repacks (when a reclaim repacks at all, D28) use zlib level 1 for objects they pack anew, so small saves and configs stay compressed, and reuse data already in a pack as it is, so the big streamed archives and existing stores are not rewritten. Byte progress during a big first snapshot tracks the bytes read more closely, since what is written is what was read.

  • Batches for progress. Git prints its file list through a buffered output (GIT_FLUSH=1 does not change that for git add -v: 300 names arrived in the last half second of a 7 s add either way). So a watched capture stages its files under 128 MiB in batches of at most 2 GiB or 2000 files, and every file at or over 128 MiB (core.bigFileThreshold) in one last add. Each batch's names arrive when it ends; a stopped batch's names are dropped, since git never finished storing them. Every name becomes one detail line whatever the progress throttling drops. Details shows the newest 200 lines, and a job keeps its newest 20,000 for Copy (about 3 MB; a first Cyberpunk 2077 snapshot writes about 5,200). On 5.5 GB of mixed files the batches cost 1 to 5% over one add (about 0.3 s per extra git start). An unwatched capture is still one add, and the snapshot is the same tree either way.
  • The big file named is an estimate. Big files are stored last. "Probably copying " and, during the last add, "Probably still on : about X of Y" name the file by matching the bytes stored so far against the big files in git's order (tracked files first, in index order, then new files by path).
  • All big files go in one add. Git writes one pack per add for streamed files, and the geometric repack weighs packs by object count (D25), so one pack per big file would be merged by the first routine repack, rewriting every big archive. One add writes one pack, which its keep (D25) holds through every routine repack.
  • Vanished files and stopped captures. Before each batch, files that are gone and were never recorded are dropped from it, so a temporary file a launcher deletes mid-capture does not fail the snapshot. A capture stopped after some batches leaves them staged; the next one finishes the rest, and its count includes what was already staged.
  • The silent end. Git says nothing while it closes the last pack and writes the index. Once the store holds at least 99% of the bytes and has not grown for 8 seconds (longer than git takes to hash a 128 MiB file before writing it), the progress text says SavePoint is making sure everything is stored safely (common.progress.finishing) instead of a stalled figure. Known limit: a game whose files repeat more than about 1% of their bytes stores less than it reads, never reaches that mark, and keeps the old figure to the end.
  • Known cost: big raw assets stay raw. Large uncompressed assets (raw audio or textures over 128 MiB) are stored at full size, and since the streamed pack is kept, no later repack compresses them. On 5 GB of generated files (raw textures, noisy PCM audio, random archives and 3,000 small files; Ryzen 9 7950X, NVMe), adding the big files at level 1 instead of 0 took 97 s instead of 53 s for a store 15% smaller (4.1 GB against 4.8 GB). Big raw textures shrank to about 53%, big noisy PCM to about 95% (recorded audio usually does better), archives not at all; files under 128 MiB compress the same either way. Level 0 stays: the add is CPU-bound, so the extra time grows on a mid-range PC, and most games ship compressed archives. If a measured game keeps more than about a fifth of its snapshot in raw files over 128 MiB, compress just those types in a separate add at level 1 (git has no per-file pack level).

Repacks at level 1, and Unity bundles skip delta search. The first routine repack after a big first snapshot spent most of its time on archives that gain nothing. On a real 21.5 GB Unity install (7 Days to Die: 18,090 files, 285 bundles holding 14 GB; repack -d --geometric=2 over 11.7 GB of loose objects with 4 pack threads, on NVMe), the first snapshot took 200 s and the repack 570 s, about 240 s of it delta search over the bundles. Unity's bundles are block-compressed and shrank only 1 to 7% under zlib, so D16's -delta list gained Unity's block-compressed containers. Zlib's default level cost about 100 s more than level 1. Level 0 saved another 170 s but stored the compressible small files raw, for a store 14% larger (20.3 against 17.8 GB). So the routine and reclaim repacks run at pack.compression = 1: 316 s instead of 570 s, for a store 1% larger (17.45 against 17.25 GB). Data already in a pack is still copied as it is, so existing stores and update rollback are untouched, and the attributes file is rewritten with every write, so existing stores take the new list at their next snapshot. .raw heightmaps and .wav audio stay delta-searched: delta saved 330 MB on the heightmaps for about 60 s. The reclaim repack at level 1 was not measured separately.

D51. Snapshots keep empty folders

Cyberpunk 2077 ships an empty archive\pc\mod folder that mod tools expect. After a profile put a file in it and a switch went back, the folder was gone: git tracks files only and prunes a folder it empties.

  1. The list travels in the commit. Each snapshot's commit message carries a Savepoint-Empty-Folders: trailer, a one-line JSON array of its innermost empty folders (their parents come back with them). As part of the commit object, it follows the snapshot through every history operation (Recently removed, Bring back, keep as a new profile, Free up space, a snapshot-folder move) with no extra step. A git note was rejected because it needs its own ref and a copy whenever SavePoint makes a new commit from an old one; a tree entry would be written into the game folder (D13.1 forbids anything but the game's own files) or pruned as unreachable.
  2. Nothing but the folders themselves goes into the game folder. No placeholder files.
  3. Restoring only creates. A switch, go back, forced switch, finishing a stopped switch, discard and clean create each missing listed folder, skipping one the exclude list names, one under a link, and one where a file stands. A switch does not remove an empty folder the target lacks (git's own pruning is unchanged). Discard and clean still remove empty folders the point does not hold.
  4. The list honors SavePoint's excludes only. It is filtered through info/exclude with a work tree set inside the git directory, so a .gitignore in the game folder cannot add to or negate it. Folders under links, inside nested repositories, or with unsafe names are never listed.
  5. Older snapshots have no list and behave as before.

Known limit: adding or removing only an empty folder is no change to git, so it makes no new snapshot, and the list keeps the folders as of the last real change.

D52. Adding many games at once from the Steam and GOG libraries

Players with large libraries added games one at a time. "Add games from your libraries" scans what is installed and adds a ticked set in one go.

  1. What is scanned. Steam: libraryfolders.vdf and each appmanifest_*.acf; a game is installed when steamapps/common/<installdir> exists (an installed game's manifest can carry update states). Steam's own tools (Proton, the Linux runtime, redistributables, SteamVR) are left out. Steam through Flatpak or Snap, and on macOS, is found too. GOG Galaxy (Windows): its install records in the registry, add-ons dropped. Left out: an install path that is not fully qualified, an installdir with separators, dot segments or a trailing dot or space, and any folder holding another installed game's folder. Apps sharing one folder are listed once, under the app a template describes, else the lowest app id. Non-games (benchmarks, editors) still show, since Steam does not mark them.
  2. Matching a template. Store id first (Steam app id, GOG id), then the install folder name, ignoring case. Templates carry these in an optional libraryHints block (steamAppIds, steamInstallDirs, gogIds, gogFolders, and savesByOs per system) that never reaches a stored game.
  3. What is added. The checklist has search, sort by name, store or known saves folder, "Hide games already added", and select all or none. Nothing starts ticked, and added games cannot be ticked. Every add goes through the single add's checks (validation, path safety, overlap). The player confirms once, with every game's folders named. Only the install folder and a saves folder the scan saw existing are added; a saves folder that appears later, or a template folder that does not exist yet, is left out and named in the result. A template's program is used only on Windows and only when it is in the install folder; otherwise the store link starts the game, and a link start with no process name from its template gets one suggested from the install folder (D48.7).
  4. "Already added" means the install folder overlaps a game's install folder, a saves folder another game tracks, or the same Steam app id (a GOG copy is never judged by a template's Steam id). A second install of the same Steam app cannot be added.
  5. A loop, not a job. The UI adds the games one by one through the Api, with per-game progress and "Stop after this game". Activity does not list it, but quitting while it runs asks first and stops after the current game. One game's failure is reported for that game and does not stop the rest.
  6. GOG Galaxy's own folders are protected like Steam's (D40): Galaxy's program folder and its default Games folder are refused as a game folder; games inside Games are accepted.
  7. Reading the stores does not hold the storage lock, so a scan of slow or missing drives never blocks a snapshot-folder move. The scan can be canceled and stops when its dialog closes.

D53. Templates for many games

SavePoint ships templates for about 320 games (it shipped one): the games installed on the test machine and widely played PC games, each from researched facts with a source (PCGamingWiki, the store's manifests, folders seen on a real machine). Templates are discovered from the embedded resources, so adding one is adding a JSON file.

  1. A wrong saves path is worse than none. A template carries a saves folder only when a source names it and SavePoint has a token for it. Saves under a per-user id, in Steam's userdata folder, inside the install folder, or with several candidate folders get no saves folder and a plain note saying why, so the player picks it. Tests check every template: it loads, its ids and store folders are safe, every saves path resolves through the real tokens on its system and is not a file or a broad folder (Documents, AppData, the home folder), and no path names another game's folder.
  2. Linux and macOS use only their own entries. A draft there takes the saves folder from that system's savesByOs entry or leaves it blank. A Windows path does not carry over, since games under Proton save inside their prefix and native ports elsewhere.
  3. The template picker searches. It matches the way the list searches do (D64.1): each typed word may appear anywhere in the game's name, ignoring case, accents and punctuation, and a name's initials count too.
  4. Every template is checked against its wiki page, matched through its Steam app id, its saves folder compared with the page's save rows, including the Steam-specific row: where a Steam copy saves in Steam's userdata folder, the template leaves the folder blank. At release 152 templates carry a saves folder, each matching its page; 168 leave it to the player.
  5. Template notes come from the catalog (2026-10-26). Add a game now shows a picked template's note, so the notes are a closed set of sentences (where the saves are, or that the game uses anti-cheat), each mapped to a catalog key in the App; an unknown sentence shows nothing, and a test fails any shipped note made of other text. The blanket "Turn off Steam Cloud" sentence left all 249 notes that carried it (D56).
  6. Templates stay reachable after the first game (2026-10-26). Add a game lists matching templates under the Name field as the player types (matched as the list searches match, D64.1, then ranked: whole-name start first, then first-word start, then list order) and offers "Pick from the game list" in its header, and the library picker points to the list for games it cannot see (Epic, Game Pass, manual installs). A pick fills only the details the player has not typed; a detail still holding the previous pick's value counts as not typed, so a second pick replaces the first.

D54. Which game version SavePoint shows

The version on a profile comes from the start program's version resource. Reading the product string first showed engine build ids: Grounded read ++Game+release.1.4.7-CL-196638. Checked on 2026-10-24 against 252 game programs on one PC (Steam and GOG):

  1. Unreal build ids (a string starting with ++ or holding -CL-<digits>) give only a dotted number of three or four parts inside them (Grounded 1.4.7, Borderlands 4 1.11.0.0), or nothing. Two-part numbers like Release-4.26 are the engine's.
  2. Engine versions are not game versions. Unity players (a "Unity Version" string, or a product version like 2022.3.62f2 (<hash>)), a program whose product name is "Unreal Engine", and the fixed numeric version of Epic Games or Unreal executables (the engine version, 4.27.2.0 or 5.6.1.0) show no version.
  3. Placeholders (1.0.0.0, 1.0.0, 1.0) and strings without a digit (^VersionString^) are no version; a rejected product string falls through to the file string. The fixed numeric version is used only when the program has no version string at all. A game that really calls itself 1.0 shows nothing; the player can type the version on the profile.

D55. A documentation site built from the repository

The guides and an API reference are published as one static site (decided 2026-10-25), built with DocFX from this repository, not a repository of their own: the reference comes from the doc comments Savepoint.Core must carry (CS1591 is an error there), so one commit keeps site and code in step. It publishes from main, so guide changes show without a release. The site replaces the wiki, whose sync script broke whenever a guide was renamed; the forge's wiki link points at the site, and the dogfood checklist that lived only on the wiki is docs/dogfood-checklist.md.

  1. Only Savepoint.Core is in the reference. It is the contract the app is built on; the app's view models are not an API anyone calls.
  2. It is hosted on a self-run git-pages server, behind the forge's proxy, as the project site SavePoint on a host shared with other projects (docs.tortal.tech; its front page comes from its own repository, docs-index). Forgejo has no pages feature. The server's wildcard setting maps each path to the forge repository of the same name and accepts that repository's workflow token, so no publishing secret is stored and a project can publish only its own site. git-pages' TXT-record method was tried first and admits only a host's front page.
  3. It looks like the app: the Material roles the app derives from the default accent, light and dark, the app's Roboto, and the app icon. The stylesheet holds the computed colors, so a new default accent means computing them again.
  4. It is public, like the repository.
  5. The server is set up once, as a Docker Compose stack on Unraid, by the record below. The site is about 50 MB before compression.

Server setup record.

  1. Make the data folder, owned by the user the container runs as: mkdir -p /mnt/user/appdata/git-pages/data && chown -R 99:100 /mnt/user/appdata/git-pages.

  2. Write /mnt/user/appdata/git-pages/config.toml (also owned by 99:100). It replaces the image's own config, so it repeats the listeners and adds the wildcard. docs.tortal.tech matches the wildcard as <user>.tortal.tech with <user> = docs, which the clone URL ignores:

    [server]
    pages = "tcp/:3000"
    proxy = "tcp/:3001"
    metrics = "tcp/:3002"
    
    [[wildcard]]
    domain = "tortal.tech"
    clone-url = "https://git.tortal.tech/ethan-hann/<project>.git"
    index-repo = "docs-index"
    index-repo-branch = "main"
    authorization = "forgejo"
    

    Only names the proxy sends to the container are served, so the wide domain reaches no other host.

  3. Add a stack with this compose file and start it. Standalone mode serves plain HTTP on the container's port 3000 and keeps the sites on the file system. TLS comes from the proxy. Host port 3090 was free on the server when this was set up.

    services:
      git-pages:
        image: codeberg.org/git-pages/git-pages:latest
        container_name: git-pages
        restart: unless-stopped
        user: "99:100"
        ports:
          - "3090:3000"
        volumes:
          - /mnt/user/appdata/git-pages/data:/app/data
          - /mnt/user/appdata/git-pages/config.toml:/app/config.toml:ro
    
  4. In Nginx Proxy Manager, add a proxy host for docs.tortal.tech to the server's port 3090, with the *.tortal.tech certificate and Force SSL. The upload is an HTTP PUT of the site as an archive, so the proxy must allow bodies of 100 MB (client_max_body_size 100m; under Advanced).

  5. Add a DNS record for docs that reaches the proxy (a proxied CNAME, like the other names). A resolver on the network may keep a "no address" answer for a while if the name was looked up before the record existed.

  6. Set the repository variable DOCS_SITE_URL to https://docs.tortal.tech/ (Settings > Actions > Variables), then start the Docs workflow by hand once to publish.

If Cloudflare proxies the name, the upload must get through it. Cloudflare refuses bodies over 100 MB and may block the upload tool's user agent. If the first upload is refused, add a WAF skip rule for PUT requests to that host.

D56. Cloud saves: what the stores do, and when the editor warns

The editor used to tell every player to turn off the store's cloud saves, or the store would sync older saves over the ones SavePoint puts back. Tests with real clients in October 2026 (Balatro on Steam, on a Linux VM and a Windows PC sharing one account; Deus Ex on GOG Galaxy 2.0) showed that is only half true, so the note now shows only for games whose store syncs saves, and says what actually happens (decided 2026-10-25).

  1. Neither store does anything while the game is closed. Steam syncs at launch (download only) and at exit (upload); Galaxy syncs before launch (pull) and after exit (push and pull). SavePoint changes saves only while the game is closed.
  2. Changed saves are kept. Steam compares each file's hash with its own cache, treats a difference as a local change, and uploads it at exit; file dates do not matter, so older content with an older date uploads like new content. Galaxy kept a changed save and uploaded it. Neither asked anything on one PC.
  3. Removed saves come back. Both stores treat a file missing at launch as "the cloud has it" and download it again, silently, every time; neither ever uploads a deletion. So going back to a snapshot from before a save, or switching to a profile with fewer saves, does not stick on a cloud-synced game: the save comes back and becomes part of that profile's next snapshot. Cloud saves must be off before the next launch to avoid it. Writing placeholder files instead of removing was rejected: the game would read them as saves.
  4. A second PC can raise a conflict, never a silent overwrite. When the cloud holds a newer change from another PC and the local saves changed too, Steam shows "Cloud Conflict" (Cloud Save or Local Save) and will not start the game until one is picked; Local Save keeps SavePoint's files and uploads them. Galaxy's two-PC behavior was not tested.
  5. Reading the setting. Nothing is ever written to a store's files.
    • Steam: userdata/<account>/7/remote/sharedconfig.vdf, UserRoamingConfigStore > Software > Valve > Steam > apps > <appid> > cloudenabled ("1" on, "0" off). Steam writes the key only for games the player toggled, and cloud is on by default, so a missing key with userdata/<account>/<appid>/remotecache.vdf present reads as on. The file roams with the account, so the setting is the same on every PC. The account is Steam's active user (HKCU\Software\Valve\Steam\ActiveProcess\ActiveUser on Windows), else the one loginusers.vdf marks (MostRecent, then AutoLogin, then the only or latest-timestamp user), else the only userdata folder.
    • GOG Galaxy (Windows only): ProductSettings.cloudStorage for gameReleaseKey 'gog_<id>' in %ProgramData%\GOG.com\Galaxy\storage\galaxy-2.0.db. Toggling the game's "Sync local saves with GOG Galaxy Cloud" setting flips this column; CloudSavesConfiguration.enabled stays 1 and only means the game supports cloud saves. A new install has cloud on. No row reads as off (Galaxy does not manage that game), and featureCloudSaves: false in %LOCALAPPDATA%\GOG.com\Galaxy\Configuration\config.json turns it off for every game. SavePoint reads a copy of the database and its write-ahead log, never the live file, checks the live files did not change during the copy (once more, then gives up), and deletes the copy. The answer is cached for the session until the database or its log changes. Reading it needs Microsoft.Data.Sqlite; the Linux and macOS packages leave it and its native library out (App references it with ExcludeAssets for those runtimes), saving about 2 MB each.
    • Any read failure, or a game from neither store, is "can't tell", which puts softer advice behind a "Does my store sync saves?" button; "on" is a warning under the saves folder.
  6. The note follows the form. The editor checks again 400 ms after the Steam app id or the install folder stops changing, and an older answer never replaces a newer one.

D57. A game folder is pinned before git deletes or overwrites files

A security review (2026-10-25) found a check-then-use gap: a discard, clean or switch checked path safety and the consent marker once, then ran several git processes that each reopened the folder by name. On a shared PC, another account able to write to the folder above a game folder could swap it for a junction in between, and SavePoint would delete or overwrite files in a folder that account cannot write to.

  1. Check, then pin. Before a discard, clean or switch, path safety judges the folder (and its link-resolved real path), then the folder is pinned: its real path, plus its file identity (the file ID on Windows, device and inode through statx on Linux and stat on macOS, #167). If an identity cannot be read, the pin relies on the real path and the consent marker, and the failure is logged on every OS. Git runs with GIT_WORK_TREE and its working directory set to the pinned real path, so a folder the player reached through a junction still works. SavePoint's own file steps (removing leftovers and displaced files, recreating empty folders) also work on the real path.
  2. Recheck right before each destructive step. Every git call that writes (reset --hard, checkout --force, clean, the resync) and every file loop that deletes or creates rechecks the pin and the marker immediately before it starts. A changed folder stops the operation with error.path.changed; a refused switch restores what it touched and clears its note.
  3. On Windows the folder is held open for the whole operation without delete sharing (opened as itself, not through a link, and compared by identity with the pin), so it cannot be renamed or replaced. Git, Explorer and scanners working inside it are unaffected.
  4. Switch notes fail closed. A note that exists but cannot be read after the wait D31.6 sets is an unfinished switch with no known target (D31.6). A discard that cannot remove the note says so (error.launch.switchNoteStuck) instead of leaving the player in a loop.
  5. Known limits. Linux and macOS have no hold. A symlink swap is caught by the real path, and a folder put at the same real path is caught by its identity. A swap in the moment between a recheck and the process start is not caught. The macOS identity read has not yet run on a Mac (#2). Pinned operations use the real path, so git's untracked cache is rebuilt when a junction-reached folder alternates between snapshots and switches (performance only).
  6. No identity on FAT and exFAT. On Linux, FAT and exFAT make inode numbers up as directory entries are cached. The same folder can then report another identity on a later read, and a destructive step would stop with "folder changed" with no swap (#244). The host probe reads the file system type with statfs. PathSafety.Pin takes no identity for vfat/msdos (0x4d44) and exfat (0x2011BAB0), a case item 1 already handles: the real path and the consent marker stand in, and the missing identity is logged. Other file systems are unchanged. The statfs read has not run against a real FAT or exFAT volume (docs/testing-on-mac-and-linux.md).

D58. Surviving a power cut right after a snapshot or switch

A resilience review (2026-10-25) found that git's writes were not flushed to disk, so a power cut seconds after a snapshot or switch could leave the index (git's record of the folder) empty or cut short. With the bundled git, every command then fails with "index file smaller than expected", and SavePoint had no way back: every snapshot, switch and discard of that game failed.

  1. Writes are flushed. The managed config sets core.fsync = committed,index,reference (config stamp 7, after D47's 5 and D50's 6). core.fsyncMethod is fsync on every system. batch was tried first: it stages objects in a temporary object folder and moves them at the end, which on Windows fails an add that also streams a big file into a pack (D50) with "unable to migrate temporary objects", and on Linux it is weaker on some file systems. Measured on the Windows bundle, alternating runs with medians of 4: a 5,000-file, 200 MB snapshot took 14.5 s without and 13.8 s with; one 2 GB streamed file took 11.5 s without and 11.4 s with. The cost is within noise.
  2. A damaged index is rebuilt from the last snapshot. When git reports index damage on one of its own fatal: or error: lines, the operation holding the game's lock rebuilds the index into a side file from the last snapshot (read-tree HEAD, or an empty index for a folder with no snapshot yet), refreshes its file data so later reads stay fast, and swaps it in through index.lock, so the real index is never missing. The damaged copy is kept as savepoint-damaged-index-<time>.tmp (the newest 3), and the failed command runs once more. No game file is touched.
  3. Only the lock holder repairs. A read without the lock fails softly (profile rows show an unknown state, the snapshot preview its soft failure) and the next locked operation repairs. The launch preview repairs under the lock and reads again, so a damaged index never blocks Play. A repair is refused once a switch has written the index itself, since that index cannot be power-cut damage.
  4. When the last snapshot cannot be read either, the index is left as it was and the player sees error.gitOperation.recordDamaged: SavePoint's record of the folder is damaged, most likely by a power cut, and the game files were not changed. A rebuild that fails for disk space, a held file or access keeps its own error.

D59. No git keeps running after SavePoint is stopped from outside

A resilience review (2026-10-25) found that a SavePoint ended from Task Manager, kill -9 or the OOM killer leaves its git running, and the next start removed that git's locks because D18 assumed nothing of SavePoint's could still be running. D46.1 chose a note plus a wait over a job object for reclaim gits only; this extends the idea to every git.

  1. Windows: a kill-on-close job object. Every git SavePoint starts goes into one job object that ends with the app, however it ends. Reclaim gits (D46.1) stay out of it, so a long repack still finishes. A git that cannot be put in the job is logged and runs on, covered by item 2. Games are never put in it.
  2. Every OS: a note of running gits. A per-user running-git.json in the runtime folder lists the app's own stamp and each running git's stamp (process id plus start time), written 500 ms after the set changes and only when it differs, so short gits cost nothing; it is cleared on a normal exit. Matching by stamp, not by path, works under an AppImage (a new mount each launch) and a translocated macOS app, and never touches another user's or another program's git.
  3. At start: settle a noted reclaim (D46.1, waited for without a limit), then end the noted gits whose owner is gone (wait up to 10 s, then end each one after checking its start time again, so a reused process id is never hit), then remove stale locks, then finish a cut-off free-up. While the startup screen waits it says SavePoint is waiting for a task it started before it closed.
  4. A leftover that cannot be ended (for example one an elevated SavePoint started) keeps its stamp for the whole run: stale locks are never removed and reclaims and free-ups refuse while it runs. Game writes are not blocked by it.
  5. Known limit. Linux has no way to tie a .NET child's life to the app, and a git started and orphaned within 500 ms is not in the note; both end on their own long before the next start in practice.
  6. Who clears the note. A normal exit leaves reclaim gits running. They have their own record, which the next start settles first (D46.1). Each backend keeps its own part of the note, keyed by an id of its own. The note also keeps the top-level owner and list of every git that 0.9.16 reads, so both versions read each other's note. A backend's close removes only its own part and keeps the earlier run's gits that still run, so a start that fails to build, or one of two backends on the same folder, never drops another run's gits. A run that is exiting never rewrites a note a newer, still-running SavePoint already owns.

D60. The local Linux gate runs on the Linux test VM

The local Linux gate ran under WSL on a 9p mount of the Windows drive. That mount is case-insensitive and cannot hold permissions or Unix sockets, so it needed its own skip list and test retries (D27), and it passed a test that failed on real ext4 in CI (a stopped switch where a file stood where a folder had been).

  1. build/gate-linux.ps1 runs build/gate.sh on the Linux VM over SSH, with a key only. It sends the committed tree of the commit it is given, so a local branch that was never pushed can be gated, and it brings the log and the exit code back. The VM keeps its own SDK, PowerShell and caches in ~/gate and build outputs between runs. A full run takes about 16 minutes on its 4 cores.
  2. The VM uses the CI skip list. It is ext4, runs as an ordinary user, and has sockets, permissions and case-sensitive names, as the CI container does. linux-wsl.txt is gone.
  3. No gate retries tests. Retries existed only for the 9p mount. The retry targets and their package are removed, and the gates refuse --retry-failed-tests, so a flaky test fails and is fixed.
  4. Local Linux packaging runs on the VM too (build/package-linux.ps1, in ~/package), and the .linux-gate worktree is gone.
  5. One heavy run on the VM at a time. The VM gate and a VM package run each lock their own folder and also share ~/.savepoint-vm/heavy.lock, so they never run together on the 4-core VM (timing-sensitive tests would fail with no retries left). A Windows gate can run beside either. Each run ends by pruning SDKs and runtimes it no longer uses and caches untouched for 30 days.
  6. A stale VM lock is broken, not waited on (2026-10-27). A run killed by a VM reset can leave a process holding a lock file. When the lock's note is missing, names a dead process, or predates the last boot, and is still stale on a second look, the next run ends the leftover processes holding the file and takes the lock (build/vm-common.sh). A live holder is still refused with exit 75.

D61. A mods folder outside the game folder

Some games keep their mods outside the install folder: 7 Days to Die loads them from %APPDATA%\7DaysToDie\Mods. A profile could not hold them, so a switch left the last profile's mods in place (#202).

  1. A third named folder, not a list. A game may name a mods folder (mods: { "path": ... } in the catalog), stored in its own mods.git with a consent marker of role mods. The install, saves and mods folders each have their own rules (below), so a list of folders with a kind would still need a rule per kind, and it would change the catalog's shape in a way 0.9.16 cannot read. The mods key is additive: 0.9.16 reads a newer catalog and sees the game without its mods folder. external.role stays saves only.
  2. How the mods folder behaves. Like the install folder: Duplicate copies it, a switch puts the profile's mods back, every file in it counts as a mod file (plus the install folder's mod hints), and a profile is in use only when its install and mods folders both hold its snapshot. A mods folder that no profile has a snapshot of yet (named after the profiles were made) holds nobody's files. Until its first snapshot, it does not count against a profile being in use, and its files are not that profile's unsaved changes. The next snapshot captures it (#221). A mods-only change shows in History as a version-and-mods snapshot. Like the saves folder: a profile with no snapshot of it leaves the folder alone at launch (D37.2), and it gets only the game-wide leave-out rules, not the install-only ones (D7).
  3. Every pair of a game's folders is disjoint. Install, saves and mods may not be the same folder or sit inside one another, checked by name and by file identity, and none may overlap another game's folders. The issue is shown on the later field. Nested folders would be snapshotted twice, and a switch in one would read as unsaved changes in the other.
  4. Switch order: install, mods, saves. Every folder after the first is asked whether it can switch before the first is written (space, case clashes, links, held files), as with two folders. A switch stopped between folders is finished per folder (D31.6). The later folders were never touched.
  5. Templates. A template carries a mods folder the same way it carries saves (D53.2): mods on Windows, modsByOs elsewhere. 7 Days to Die gets {appData}\7DaysToDie\Mods and the matching Linux and macOS folders, plus Mods as an install mod hint, since the game also loads mods from its own folder. A library add, and the editor when it fills in a template, keep the mods folder only when it exists; otherwise the editor says the folder was left out until it exists. The library list counts a game as already added when its install folder or its mods folder matches an added game's (#221). The macOS mods folder is not yet checked on a Mac (#2).
  6. Known limits. A player who goes back to 0.9.16 and then saves an edit of the game drops the mods key from the catalog. mods.git and the folder's marker survive, and entering the path again reconnects them. A cut-off Free up space that 0.9.16 finishes leaves the mods store's part for the next Free up space in a newer build, and a storage move or Clear all data in 0.9.16 leaves mods.git in the old storage folder. Nothing is lost. A mod manager's own files in the folder (such as Vortex's deployment record) travel with the snapshot. Clearing the mods field in Edit game, as with the saves field, deletes nothing: it releases the folder's marker and keeps mods.git until the game is deleted, so entering the same path again asks for consent and reconnects that history.
  7. Links. A mod manager that deploys by file link (Vortex across drives) cannot be snapshotted on Windows, where git restores a link as a text file. D62 refuses such folders.

SavePoint turns git's symlink support off on Windows (creating a link needs Developer Mode or admin), so git stores a file link as a link entry and a switch writes a plain text file holding the link's path in its place. A mod manager that deploys by file link (Vortex, when its staging folder is on another drive) stops loading after the first switch, and its record of what it deployed no longer matches the folder. A real 7 Days to Die mods folder holding 843 links showed this (#207).

  1. Capture, the preview and the switch refuse a folder that holds a file link on Windows, as D29.1 refuses folder links, with error.capture.linkedFile naming the file and the ways forward: switch the mod manager to hardlink or move deployment, replace a hand-made link with the real file, or leave the file out of snapshots. A link the leave-out rules name passes.
  2. Discard and clean refuse folder links only. They remove a file link itself and never go through it, so the file it leads to is untouched. A player who must throw a folder's changes away (a stopped switch with an unreadable note offers only Discard, D31.6) is never blocked by a link. On Windows a discard back to a point that holds link entries restores everything else and leaves whatever stands at each link's path as it is: it never writes a text file in a link's place.
  3. A switch to a snapshot that already holds link entries is refused on Windows before anything is written (error.switch.snapshotHasLinks): snapshots taken before this rule may hold them, and putting them back would write text files. The launch asks every later folder first (D61.4), so no folder is half-switched. The card suggests another snapshot or profile, and redeploying the mods in the mod manager.
  4. The check reads the attributes that come with listing each folder once: 28 ms for 100,000 files in 1,100 folders, against 1.6 s for a file query per file on all cores. Asking git for link entries only works after staging, too late to refuse before anything is staged and unusable in the preview. Files compressed with compact (CompactGUI) are not reparse points and cost nothing extra.
  5. Linux and macOS store and restore links natively and are not affected.

D63. Interface size

On large, high-resolution screens SavePoint looked small (#199). Settings > Appearance has an Interface size of 100, 125, 150, 175 or 200%, on top of the OS's own scaling, applied at once to the window, its dialogs, menus, flyouts and tooltips.

  1. A layout transform at the window's root. Avalonia's top level offers only a render transform, which blurs text and does not reflow the layout. A layout transform scales text, spacing and hit targets together, and every popup takes its anchor's transform. The crash and "already running" windows stay at 100%. They are kept minimal so they work when the rest of the app does not.
  2. Only sizes the screen can hold are offered. The screens are built for 640x420 (D36), so a size needs that room times the size in the working area of the window's screen. A size that does not fit is switched off with the reason, read out by screen readers, so the control that undoes a size is always reachable. A saved size that no longer fits (a smaller monitor) is drawn at the largest size that fits and comes back when there is room. The saved choice is never changed. Arrow keys stop at the last size that fits instead of wrapping to 100%, and the group's help text names the sizes that are off and why. A size change keeps the size choice in view.
  3. The window follows its screen. The minimum size is the 100% minimum times the size, capped to the working area. It is recalculated when the window moves to another screen, the screen's scaling changes, or the size changes. A window that grows is moved to stay on screen.
  4. The saved size applies before the window is shown, so the window opens centered at its final size instead of jumping after the first frame. The setting is uiScalePercent. An older settings file reads 100, and an out-of-range value is drawn at the nearest step.

D64. Searching games, profiles and History

A player with hundreds of games, many profiles, or months of sessions needs to find one quickly (#177). The games list, a game's profile table, and its History each have a search box.

  1. Matching. Every typed word must appear somewhere in the text, ignoring case, accents and punctuation, and a name's initials count too, so "skyrim se" finds "Skyrim Special Edition". The games list searches names. Profiles search names and notes. History searches a snapshot's name, its profile, what it holds, and its date. A date matches as 2026-09, as month and weekday names in the player's language, and as shown on screen, in the player's time zone. Snapshots have no notes of their own, so History also searches the notes of each snapshot's profile. A Recently removed snapshot is found by the notes of the profile it left (#223). The template picker and Add a game's Name field use the same matching and add a ranking (D53.6), so the same text finds the same games everywhere.
  2. History's kind choice (All, Saves, Game and mods) follows History's two columns: Saves is every snapshot the Saves column lists, and Game and mods is every one the timeline lists. Recently removed is searched too.
  3. Keys and screen readers. Ctrl+F (Cmd+F on macOS) focuses the search of the screen in front, falling back to the games search, and does nothing behind a dialog or while the tour runs. On the Games screen it goes to the profile search. Ctrl+Shift+F (Cmd+Shift+F) goes to the games search from anywhere, so the games list is not reached only by Tab. Where no games box shows (the icon rail, or no games added yet) the key leaves focus alone and announces why, because the rail's width follows the window and a key press must not resize it. A second Ctrl+F was rejected as hard to discover and surprising for screen-reader players. Each box's tooltip names its key, which screen readers also get as its accelerator key. The profile search stays above the profile table while the profiles area is at least 240 layout pixels tall (the same at every interface size, D63). It scrolls with the profiles below that height, or when a card below the table would not fit beside the pinned box. Focus follows the box when it moves, keeping the text and the caret (#219). Escape clears. A live region says how many match ("3 of 120 games") 600 ms after typing pauses, so typing does not flood a screen reader. While Recently removed is closed, History's count covers the snapshots listed and names the hidden matches apart ("1 of 8 snapshots, plus 1 of 2 in Recently removed"). That way the number matches the list on screen and the closed matches are still heard. A game whose only snapshots are in the closed section hears "1 of 1 snapshot in Recently removed". Every "no matches" message has a Clear search button, a Tab stop that puts focus back in the search box. A keyboard player is therefore never left with Escape as the only way out (#223). In History it also puts the kind choice back on All, since the kind alone can empty the list.
  4. Filtering happens in the view models over what they already hold, with no new Core query. History waits 250 ms after typing when it holds more than 250 entries, and a keystroke only adds and removes cards, keeping the ones still shown. History draws only the entries in view (#217): a game with 3000 snapshots opens in under 0.2 s headless instead of about 9 s. Each entry reports its place in the whole list to screen readers, a card's name starts with its group ("Earlier: ..."), and the group titles are headings. Windows UI Automation reads this. Orca and VoiceOver count only the entries drawn, a known limit for the manual pass. While a search narrows the profile table, its header says how many show ("1 of 3 profiles").
  5. The narrow icon rail has no room for a box, so it lists every game. Opening a game the search hides clears the search first. The profile and History searches clear when another game is picked, and the profile search clears when a new profile arrives (a new, duplicated or brought-back profile never hides behind it).

D65. A new profile can start with no saves or no mods

To try a setup quickly (a fresh 7 Days to Die run with one mod), a player can make a profile whose saves or mods folder starts empty (#206).

  1. An empty start is a real empty snapshot of that folder. The new profile gets an empty history in the folder's store instead of a capture; the other folders are captured as usual. Because it is a snapshot, not a folder the profile never saved, the next switch to the profile empties the folder through the normal launch dialog, which says what it removes and asks first (D44.2). The "only the save changes" setting (D35) never skips that dialog for a switch that would leave a folder empty. Creating the profile changes nothing on disk. The game folder can never start empty (D29.3).
  2. Only folders already safe in a snapshot can start empty. A folder may start empty only when it is on one of the game's profiles with no new changes, nothing unreadable and no unfinished switch, so its current files are in a snapshot and the empty start can never lose them. Otherwise the wizard's box is off and Core refuses. The reason is shown by cause (a first profile, new changes, a stopped switch, or files SavePoint can't check now) and is a Tab stop, so keyboard and screen-reader players reach it. A folder without SavePoint's marker is previewed without its file count (its row says SavePoint can't count the files), and its box says to confirm it in Edit game (D65.4). A game's first profile therefore cannot start empty. A folder that does not exist yet is safe. Core checks again under the game's lock when the snapshot runs.
  3. The launch dialog counts removed saves files ("N files will be removed from your saves folder.") on any switch that removes some.
  4. Unusual folder states follow the same rule: never lose a file no snapshot holds (#222). A file a leave-out rule covers does not block, because no snapshot holds it but no switch removes it either. A held or unreadable file, another game's or a damaged marker, or any other failure reading the folder blocks with its own reason (SavePoint can't check the files right now). A folder on an older snapshot blocks with a reason of its own (D72). Taking a snapshot would not fix any of these (#235). A stopped switch keeps its own reason. A folder that does not exist is safe: the empty start fails for that folder alone, the other folders are saved, and a retry checks again. A folder made again by hand, without SavePoint's marker, is refused. The reason sends the player to confirm it in Edit game, because a snapshot of it would be refused until then. A missing, foreign or damaged marker is reported for that folder alone. The preview still lists the other folders. The wizard's box gives the reason: confirm the folder in Edit game for a missing marker, or SavePoint can't check the files right now for the others. Its first snapshot count is left out (#241).

D66. Free up space says about how much space it frees

Free up space now says about how much space comes back ("about 1.2 GB"), as well as how many snapshots in Recently removed it deletes for good (D44.4). It says both before it runs, in Settings and in the Games footer's confirmation (#228).

  1. Only data nothing kept reaches counts. One rev-list --objects lists what the deleted snapshots reach and the kept ones do not. That list can still name data an older kept snapshot holds. So the walk a reclaim already makes over everything kept (kept snapshots, the current snapshot and git's index) is subtracted. One cat-file --batch-check then sums the stored size of what is left. No file contents are read. Packing can move the real figure a little either way, so the text says "about".
  2. Off the UI thread, cancellable and cached. The answer is kept per store under a digest of every snapshot name, the current snapshot, the index file's size and time, and the snapshots it would delete. Taking, removing or restoring a snapshot, or a run, therefore asks again. On a seeded store of 6000 snapshots and 77,696 objects (88 MB) it took about 0.9 s and matched the data a run then freed. The kept walk is the one D28 measured on a 91 GB store.
  3. The count never waits for the size. Settings shows the count at once and adds the size when it arrives. A confirmation names the size when it is ready within 1.5 s and otherwise asks without it. A failed estimate is logged and says nothing about size. Confirming a run cancels the estimate first, so its git reads never compete with the run's repack. The Games footer asks nothing if the player picked another game while it waited. Follow-ups are in #238 and #244.
  4. Hardening (#238, #244). The Games footer starts the estimate when a game is picked. The 1.5 s wait at the confirmation then only collects an answer that is usually ready, and picking another game cancels it. Settings cancels its estimate when the screen is left. The folders of a game, and the games of an all-games estimate, are measured side by side as the listing is, at most 6 walks at once across the whole call. The records a cut-off run's note names count as dropped, since the next run finishes them first. The cache key also holds the pack files' names, sizes and times, because a repack moves no ref yet changes the stored size. The estimate reads without the game's lock, which a long walk would otherwise hold against snapshots and launches. So that Delete game never meets a pack the estimate holds open, deleting a game cancels that game's running estimates and waits for their gits to exit first (the call ends as cancelled). Clearing all data does not do this yet.

D67. A Steam game started from its program waits for Steam, never goes through it

Balatro, set to run its program, quit at once with Steam closed: it needs Steam running but never starts Steam itself (#243). Steam's own launch path (Play, steam://rungameid, -applaunch) would start it, but it installs a waiting update first, which overwrites a version the player switched to. No Steam setting reliably stops that. Keeping the player's chosen version comes first, so SavePoint never starts a game through Steam on the player's behalf.

  1. Only a Steam install counts. A game needs Steam when it runs its program, the OS can run that program, and its install folder is under a steamapps/common folder. A Steam app id alone does not count, because the library scan and the templates give GOG and retail copies one too, and those must keep playing with Steam closed.
  2. Check before anything changes. For such a game the launch first checks that Steam is running and signed in: on Windows the registry's ActiveProcess pid is a live Steam process and ActiveUser is not zero; elsewhere a Steam process runs. The launch preview reports it too, so the player is asked before the launch dialog, and no folder is read or switched until Steam is ready. A switch without play, a link start and other games never ask. On Linux and macOS a Windows program (a Proton game) skips the check and is refused later as before.
  3. Start Steam, Play without Steam, or Not now. Start Steam starts only the Steam client (-silent, no app id and no link), then waits inside the launch job up to 90 s until Steam is ready (signed in on Windows; running on Linux and macOS, where Steam's own files show no reliable signed-in state), and the player can press Stop waiting. Play without Steam starts the program as it is, for a game that does not need Steam. Not now, a cancel, a timeout or a client that will not start change nothing.
  4. Steam must not have touched the game. The game's appmanifest is read, never written (D56.5), before Steam starts, again once Steam is ready but before any folder is switched, and again just before the program starts. The launch is refused when a reading taken with Steam running shows an update or validation in progress (StateFlags), or a buildid or LastUpdated different from the first reading. Before the switch the refusal says nothing in the game folders was changed (error.launch.steamUpdatingBeforeSwitch); after it, that the update may have changed the game's files (error.launch.steamUpdatingGame). A reading taken with Steam closed never refuses on its own, so a flag left by a crashed update cannot block the game. An update that is only waiting does not refuse. Play without Steam skips every reading.
  5. The session is not over while the game runs. After play, a choice that takes a snapshot is refused while the game or the program SavePoint started still runs. SavePoint also looks again two process-list intervals (4 s) after a recent exit to catch a relaunch, and shows "Checking the game has closed" meanwhile. The refusal offers Choose again; Skip is never refused.
  6. Known limits. A game outside a steamapps/common folder gets no card, and libraryfolders.vdf is not read. The StateFlags meanings come from community sources. Steam can still update an install by itself while SavePoint is not launching; noticing that after play is #250. A client that cannot be started at all (a Flatpak or Snap Steam has no steam on the path) fails as error.launch.steamCannotStart. This differs from error.launch.steamDidNotStart, which is for a client that started and never signed in. The waiting step carries the wait in seconds, taken from SteamWaitOptions, for the card to show. A Steam game (one SteamGames.NeedsClient accepts) with no process name that exits with code 0 within the relaunch window ends as ProgramQuitAtStart, so an Init-only Steam game gets the same hint as one that exits with an error. Any other game that quits quickly with code 0 ends as ChildExited and gets no Steam hint. With a process name set, a clean quick exit still ends as NamedProcessNeverAppeared. Balatro and other real Steam games, and the research's update test, still need a hand check.

D68. The profile table follows the game folders as they change

A file changed in a tracked folder showed on the profile table only after the player left the Games screen and came back (#245).

  1. Only the game on screen is watched. While the Games screen shows a game, SavePoint watches its install, saves and mods folders (subfolders included) behind an IFolderWatcher seam. The watch is set up off the UI thread and is ready before the status scan starts, so no change slips between them. Setting it up on the Linux VM took about 262 ms for 3,031 folders (Linux adds one watch per folder). It stops when another game is picked, the screen is left, or the app closes.
  2. One read per burst. A burst of changes leads to one status read, 750 ms after it settles and at most 5 s after the first change, so a game that writes a log all the time cannot starve the table. After a slow read the next waits at least twice as long as that read took, so a big install is never scanned back to back. One read runs at a time, with one more after it if changes came meanwhile. The read is the profile table's own status query, off the UI thread, with no loading flicker.
  3. Quiet while SavePoint, the game or the player is elsewhere. Changes are not read while a job for that game runs, while the launch flow owns it, while it is being played, or while the SavePoint window is in the background or minimized. A scan would compete with the game for the disk. The job end and the after-play flow read the status anyway.
  4. Returning to the window reads only when something may have been missed. A change that arrived while the window was away, a watcher error, or a folder the watch does not cover leads to one read when the player comes back; otherwise nothing is read. A watcher error or overflow, or a folder that appears later, sets the watch up again. A folder that cannot be watched (for example past Linux's inotify limit) is logged once and read on each return. The cost of one read on a 90 GB install is not yet measured.

D69. Only the games list scrolls, and nothing runs off sideways

  1. Sidebar (#239). The destinations, the search box and the add buttons stay put, and only the games list scrolls, with its scrollbar in its own strip so it never covers a title. A long game name is trimmed at the rail's edge. In a short window the brand and the "Your games" heading hide, so the list keeps room.
  2. Library shelf (#237). The game cards wrap to the next row and the shelf scrolls up and down in its own area, about a row and a half tall (one compact row in a short window), so the page never scrolls sideways at any window size or interface size.
  3. An audit keeps it that way. A test renders every app state at 960x460, 910x432 and 640x420 and fails when a scroll area scrolls or clips sideways, when a control or text ends past its scroll area or the window, or when unwrapped text needs more room than it gets. Its first run also fixed History's timeline buttons and heading, the profile table's cells, the error card's buttons and the icon rail.

D70. A leaner, faster test suite

An audit on 2026-10-27 found the suite's 19,087 cases padded and its CI slow for a different reason: about 3,000 Core theory rows asserted nothing and about 400 repeated another class, while the time sat in about 970 slow cases (53.6 of 70 summed minutes) and in a Windows CI VM with 2 physical cores where the App tests run one at a time. Agents copy the patterns they see, so padded tests would multiply.

  1. Tests must be able to fail. The standard .agents/coding-standards/tests-meaningful-and-fast.md sets the rules: no case that cannot fail for a product regression, no theory rows that skip their assertion (filter the data, or loop and name every failing item), no duplicate coverage, honest fakes with contract stories, cheap setups. The template theories became loops (6,433 cases to 56), placeholder and compiler-guaranteed tests went, and the render-only test classes run only with SAVEPOINT_RENDER=1 (no test draws a picture in a normal gate run).
  2. Cheaper setups. Slow Core classes build their git world once and copy it per test (for example LaunchUpdateExistingTests 95 s to 46 s); UI sweeps share windows across configurations (JobPillPlacementTests 97 s to 56 s), and three layout audits run on one render per state.
  3. The App tests run in three processes. Each lane in build/app-test-lanes.txt (EndToEnd, the real-backend journeys, and the rest by exclusion, so a new namespace lands in the rest) gets its own headless UI thread, beside Core. A count check fails the gate when the lanes' test methods differ from the full listing. Below 10 GB of available memory the App tests run as one process again, after the first lane run filled a 7 GB Linux VM. The reading is the smaller of the free memory and what is left of a container's cgroup limit (the limit less the memory the container already uses). A reading that cannot be made also picks the single process. A small Linux VM therefore always runs one App process and no longer mirrors the lanes of Linux CI, a trade made to protect small machines. Core gets 4 to 8 threads, since it became the slowest process once the App lanes shrank. Output streams live with each process's name, so a hung lane shows in CI. No retries (D60).
  4. Formatting is checked once in CI. dotnet format gives the same answer on every OS, so only the Linux CI job runs it; the Windows job passes -SkipFormat (decided by the owner, 2026-10-27). Local gates keep it, and both CI gates stay required.
  5. The Windows CI VM is a mid-range PC. It went from 2 physical cores and 8 GB to 4 cores (8 threads) and 16 GB, which cut the Windows job from about 44 to 34 minutes before the changes above. The first pull request gate with the lanes (0.9.22, 2026-10-30) took 34.6 minutes of wall clock for both jobs together.

D71. Published releases are copied to the GitHub mirror by a separate workflow

The push mirror sends every commit and tag to GitHub but no releases, so a visitor there saw nothing to download (#270).

  1. A workflow of its own, not a step of the release workflow. release.yml builds a draft on the tag push, and the notes are added and the release published by hand afterwards, so the copy has to follow the publish. .forgejo/workflows/github-mirror.yml runs on release with the types published and edited. It also runs by hand (workflow_dispatch) with a tag input that takes a tag or all. The script is idempotent, so the manual run is the fallback for an event that did not fire and the way to sync a release edited long ago. The Forgejo release event was not tried against the live server when this was written; the manual run does not depend on it. A draft is skipped.
  2. The script is build/mirror-release.ps1, PowerShell like the other release scripts, run on the Linux runner. It waits up to 5 minutes for the tag to arrive from the push mirror and fails with a message when it does not (the tag must exist before the release, or GitHub would create it from the default branch). It then creates the release or brings the name, notes and prerelease flag of the existing one in line, sends every file under its own name, skips a file GitHub already holds with the same hash, replaces one that differs, and removes one Forgejo no longer has. Split files go as the same .partN pieces. The link row to the sources release is not copied, because it is not a file.
  3. Checks. Each file is hashed after it comes down and compared with the Forgejo release's SHA256SUMS.txt before it is sent, so a file that differs from the list is never sent. A release with no SHA256SUMS.txt, or with a file the list does not name (other than the list itself), fails before anything is sent. After the upload the digest GitHub reports for the asset must equal that hash (the size, when GitHub reports none). GitHub hashes what it received, so this catches a damaged upload without downloading every file again. Early releases split large files into <name>.partN assets and list only the whole file's hash, so a group of parts is checked as one: no part may be missing, and the parts joined in numeric order must hash to the list's entry for <name>; the parts are then sent as they are, each checked after upload against its own hash. A file already on GitHub is left alone only when its reported digest equals the list. When GitHub reports no digest, the script downloads that file (from api.github.com, and the signed address GitHub redirects to, which gets no token) and hashes it. It replaces the file when the hash differs.
  4. The token goes to two hosts. The repository secret GH_MIRROR_TOKEN is a fine-grained GitHub token for ethan-hann/SavePoint alone with Contents read and write. The script checks the host of every request and sends it only to api.github.com and uploads.github.com (a test switch also allows a server on the local machine). It reaches curl on standard input, never as an argument or in a file, is never printed, and the secret is set on the one step that runs the script. Reading the Forgejo release uses the job's own token, sent only to the Forgejo server.
  5. No secret yet is not a failure for a release event. A release published before GH_MIRROR_TOKEN exists ends the run with a notice and exit 0, without contacting a server; a manual run with no secret fails.
  6. Backfill is one manual run with the tag all: every published v* release, oldest first, with the same checks. A release that fails is reported at the end and does not stop the others. Run it once after the secret is added. All mirror runs share one queue (a single concurrency group), and the script sends make_latest as true only for the highest-numbered published release that is not a prerelease and false for every other, on create and on update, so a release copied or edited late never becomes GitHub's latest.

D72. A folder left on an older snapshot has its own empty-start reason

After Go back, a folder sits on an older snapshot, and the new profile wizard's box said SavePoint can't check the files and to close programs using them (D65.4). That sent the player to the wrong step (#249).

  1. Core names the case. StartEmptyBlock.OlderSnapshot is reported when a folder is on an older snapshot instead of a profile's newest, with or without changes since. It takes the place of Other for that case only. The check order of D65.2 is unchanged, and Core still refuses the empty start, with the same "can't check" refusal as Other, because a snapshot of such a folder is refused too.
  2. The wizard's box says the step that helps. "This folder is on an older snapshot after Go back. Load one of this game's profiles first, then try again." Loading a profile puts the folder on that profile's newest snapshot, after which the box can turn on. The reason is on that folder's box alone, like the others.