0.9.17: mods outside the game folder, search, empty-start profiles, interface size, and the Code Cleanup milestone #227

Merged
ethan-hann merged 190 commits from integration-0917 into main 2026-10-27 09:02:51 -05:00
Owner

Features (1.0): mods folder outside the game folder as a third tracked folder (#202, D61); file links refused on Windows and snapshots holding links refused before writing (#207, #215, D62); search over games, profiles and History (#177, D64); new profiles that start with no saves or mods, only when the folder is safe in a snapshot (#206, D65); open game/mods/saves folders from the profile menu and a right-click menu (#204, #205); interface size 100-200% (#199, D63); chips edit in place (#203); the after-snapshot tidy is its own task, "Compacting snapshot files" (#201, D13.17); header snapshot button follows the row's run (#209).

Fixes: Linux process start times dated from the exact boot instant and the session start taken before launch (#216); space judged for all folders together on a snapshot and on a launch (#169, #171, D13.16); stopped-switch finish waits longer for a held note, handles read-only files and folder links, and names the step that failed (#196, #197, #198, D31.6); Activity keeps finished tasks across restarts (#160, D44.5); History filter and Sidebar/Library toggle keyboard and screen-reader fixes (#175, #176).

Code Cleanup: #173 #178 #179 #180 #181 #182 #183 #184 #185 #186 #187 #188 #190 #191 #210 #211 #212 #213 #214; the local Linux gate and Linux packaging run on the Linux VM, WSL and test retries retired (#195, #210, #211, D60).

Each feature was implemented test-first and reviewed; review findings were fixed in follow-up rounds on this branch. Docs: decisions D60-D65 and amendments, architecture, developer guide, ui-guide, user guide, standards' known violations, regenerated screenshots.

A gap analysis against the 40 issues closed the Medium gaps on this branch (discard never blocked by links, an empty-folder switch always asks, reachable reasons for the start-empty boxes, size choice keys, copy); the Low ones are filed as #221-#226.

Local gates on 386a9160: Windows gate passed (18496 tests, 0 failed, 73 listed skips); Linux gate on the VM passed (18480 tests, 0 failed, 145 listed skips).

Closes #160 #169 #171 #173 #175 #176 #177 #178 #179 #180 #181 #182 #183 #184 #185 #186 #187 #188 #190 #191 #195 #196 #197 #198 #199 #201 #202 #203 #204 #205 #206 #207 #209 #210 #211 #212 #213 #214 #215 #216

Features (1.0): mods folder outside the game folder as a third tracked folder (#202, D61); file links refused on Windows and snapshots holding links refused before writing (#207, #215, D62); search over games, profiles and History (#177, D64); new profiles that start with no saves or mods, only when the folder is safe in a snapshot (#206, D65); open game/mods/saves folders from the profile menu and a right-click menu (#204, #205); interface size 100-200% (#199, D63); chips edit in place (#203); the after-snapshot tidy is its own task, "Compacting snapshot files" (#201, D13.17); header snapshot button follows the row's run (#209). Fixes: Linux process start times dated from the exact boot instant and the session start taken before launch (#216); space judged for all folders together on a snapshot and on a launch (#169, #171, D13.16); stopped-switch finish waits longer for a held note, handles read-only files and folder links, and names the step that failed (#196, #197, #198, D31.6); Activity keeps finished tasks across restarts (#160, D44.5); History filter and Sidebar/Library toggle keyboard and screen-reader fixes (#175, #176). Code Cleanup: #173 #178 #179 #180 #181 #182 #183 #184 #185 #186 #187 #188 #190 #191 #210 #211 #212 #213 #214; the local Linux gate and Linux packaging run on the Linux VM, WSL and test retries retired (#195, #210, #211, D60). Each feature was implemented test-first and reviewed; review findings were fixed in follow-up rounds on this branch. Docs: decisions D60-D65 and amendments, architecture, developer guide, ui-guide, user guide, standards' known violations, regenerated screenshots. A gap analysis against the 40 issues closed the Medium gaps on this branch (discard never blocked by links, an empty-folder switch always asks, reachable reasons for the start-empty boxes, size choice keys, copy); the Low ones are filed as #221-#226. Local gates on 386a9160: Windows gate passed (18496 tests, 0 failed, 73 listed skips); Linux gate on the VM passed (18480 tests, 0 failed, 145 listed skips). Closes #160 #169 #171 #173 #175 #176 #177 #178 #179 #180 #181 #182 #183 #184 #185 #186 #187 #188 #190 #191 #195 #196 #197 #198 #199 #201 #202 #203 #204 #205 #206 #207 #209 #210 #211 #212 #213 #214 #215 #216
The screen factories no longer keep the whole FeatureContext. FeatureComposition builds SettingsDependencies and HistoryDependencies and hands them to the factory, as it does for Activity.
GalaxyCloudReader.SweepLeftovers and AppsMenuEntry stamped or compared DateTime.UtcNow. Both now take a TimeProvider: CoreBackend passes BackendOptions.Time, and FeatureComposition passes FeatureContext.Clock. The known-violation lines for both are removed from the standards.

Observed reds: GalaxyCloudReaderTests.A_copy_becomes_a_leftover_when_the_injected_clock_moves_past_its_age (Assert.True Expected: True Actual: False, the copy was swept at once on the real clock); AppsMenuEntryTests.The_icon_folder_is_touched_with_the_time_of_the_injected_clock (Expected 2000-12-24, Actual 2026-10-27).
ErrorCardViewModel, StorageSectionViewModel and ClearAllDataSectionViewModel no longer import Savepoint.Core.Services.Storage. The helper is pure string logic the App needs, so it lives in Savepoint.Core.Api.
Comment-only change: _shared, _forApp and _exitHooked each state the process-lifetime reason the standard asks for, and the known-violation line for them is removed from the standard. No behavior change; no test added.
UiProgress posts through the dispatcher the startup view model is given instead of capturing SynchronizationContext.Current. Tests pass ImmediateUiDispatcher. The one-line constructor change in the shared Games, Launch and screen harnesses is only the new argument.
CoreBackend is now IDisposable: Dispose releases its GitProcessRegistry, which ends its gits, clears its note and removes it from the list the process-exit handler closes, so a test process that builds thousands of backends no longer closes thousands of registries at exit. BackendWorkspace disposes every backend it built.

Observed reds (registry stubbed to do nothing): GitProcessRegistryReleaseTests.A_registry_made_for_the_app_is_closed_at_exit_until_it_is_released, Releasing_twice_does_nothing_the_second_time and Releasing_ends_what_runs_and_removes_the_note failed on Assert.False(); CoreBackendTests.Disposing_the_backend_takes_its_git_registry_off_the_exit_list failed on Assert.False() with Dispose emptied. Releasing_one_registry_leaves_another_on_the_list passed first and failed when Release cleared the whole list.
ActivityScreenViewModel, JobDetailsViewModel, GamesScreenViewModel, ProfileRowViewModel, NewProfileWizardViewModel and FreeUpSpaceViewModel declare their commands as [RelayCommand] methods with named CanExecute gates and NotifyCanExecuteChangedFor, instead of building them by hand. Command names are unchanged, so views and tests need no edits. Behavior-preserving; no red (existing tests are the safety net).
TourViewModel, HowItWorksViewModel, ContextualHelpViewModel, HelpSectionViewModel, JobStatusViewModel and ShellViewModel (AddGame, AddFromLibraries) declare their commands as [RelayCommand] methods with named gates. Command names are unchanged. The commands built inline for FirstRunViewModel and for error card actions stay hand-written. Behavior-preserving; no red (existing tests are the safety net).
TempFolder.TryCreateDirectoryLink joined the cmd.exe command into one string; it now adds one list item per argument, as TempTree.MakeJunction does, and reads both output streams. The known-violation line is removed from the standard. No behavior change; DirectorySizeTests, which makes a junction through it, stays green.
StorageSectionViewModel, StartupViewModel, HistoryScreenViewModel, SettingsScreenViewModel and ClearAllDataSectionViewModel declare their commands as [RelayCommand] methods with named CanExecute properties. Commands built for one object to hand to another stay hand-written. Pure refactor; existing tests stay green.
The log text for a failed file step said "Checkout could not update" even where no checkout ran (removing a standing file or a displaced file). It now says what was being done: write the point's copy, remove new files, remove files the point being left held, or remove files standing where the point being left had a folder. The text avoids the word checkout.

On Windows a read-only file standing where the old point had a folder made the delete fail, where git replacing the path would have cleared the attribute. The finish now clears it first, only for a file it has already decided to remove.

Observed reds:
- NotUpdatedMessageTests (9 cases): Assert.Equal failure, expected "Could not remove these new files: ..." but was "Checkout could not update: ...".
- FinishSwitchTests.A_read_only_file_standing_where_a_folder_was_is_replaced_by_the_finish: GitOperationException "Checkout could not update: Mods/Foo" from RemoveStanding.
build/gate-linux.ps1 exports the chosen commit with git archive, uploads it with
build/gate-linux.sh and runs build/gate.sh on the VM, in a fixed folder (~/gate) that
keeps build outputs between runs. Key authentication only; host, user, key and folder
come from parameters or SAVEPOINT_VM_* variables. The remote gate's exit code is the
script's exit code, one gate runs at a time (a second is refused with 75), and the log
is copied back to .tools/gate-linux-last.log. The VM is ext4, runs as an ordinary user and
has pwsh as a .NET tool like the CI job, so the CI skip list applies and no test retries.

The 9p mount, the .linux-gate worktree logic and build/expected-skips/linux-wsl.txt (with
its two tests) are gone. package-linux.ps1 still builds the Linux package under WSL.

No C# behavior changed: the removed tests only pinned the retired list. Verified by
running the script against the VM with a narrowed test set.
A_keep_that_cannot_be_removed_at_a_reclaim_is_a_reported_failure_not_a_raw_exception returned early off Windows and so passed on Linux without testing anything. It now calls Assert.SkipUnless and is listed in build/expected-skips/linux-ci.txt (linux-wsl.txt includes that list; there is no macOS list). It is the only early return on an OS check in the tests; the known-violation line is removed from the standard. The test still runs and passes on Windows.
The running app's default revealer is FileManagerRevealer, which passes Explorer's /select, switch and the path as list items. ProcessFileRevealer joined the Windows argument string by hand and switched on OS name strings. Red observed first: Without_a_revealer_the_running_apps_settings_reveal_files_through_the_platform_file_manager failed with Assert.IsType() Failure: expected FileManagerRevealer, actual ProcessFileRevealer. The per-OS start-up assertions that tested the removed class are covered by FileManagerTests.
A chip's text is now focusable. Enter or F2 on it, or a double-click, turns it
into a field holding its text (selected). Enter or leaving the field keeps the
change, Escape drops it, and focus returns to the chip after Enter or Escape.
A blank, repeated or unchanged edit leaves the chip as it was, with no message,
as an add does. The chip is named "Edit {value} in {list}", its field "Change
{value} in {list}", and its help text says how to edit it; all three are
catalog strings.

ChipItem becomes a small view model (editing state, own commands, and a text
that can change) instead of a record.

Observed reds before the code:
- Each_chip_is_named_for_editing_and_so_is_the_field_it_becomes: expected
  "Edit **/*.log in Files to leave out", actual "".
- Editing_a_chip_opens_its_text_as_a_field: Assert.True failed on IsEditing.
- Committing_an_edit_changes_that_chip_in_place_and_says_so_once: collections
  differ at index 1, expected "b2", actual "b".
- A_chip_is_focusable_and_named_for_editing_and_says_how: expected 3 chips,
  actual 0. The other view tests failed for the same missing chip target
  (index out of range finding the chip to focus).
Mutation checks: dropping the blank/repeated/unchanged guard and the
not-editing guard failed 6 view model tests; the focus-return tests failed
until the key handler listened for handled keys.
ExitGuard compared DateTime.UtcNow with a deadline for the library-run wait and the job wait, so a clock change could cut either short or stretch it. Both now measure elapsed time with a Stopwatch. The wall-clock search over src prints nothing. No behavior change under a steady clock; ExitGuardTests and LibraryRunExitTests stay green. A clock jump has no seam to test through, so no new test.
Both joined the left-off rules with a hard-coded ", ". They now use
common.listSeparator, as the launch dialog already does. No other user-visible
name list in the App was joined with a literal separator.

Observed reds before the fix:
- GameEditorSaveTests.The_rules_that_were_left_off_are_joined_with_the_catalog_separator:
  expected "**/*.log / **/*.dmp", actual "**/*.log, **/*.dmp".
- LibraryAddDialogViewModelTests.The_rules_that_now_apply_to_the_games_own_folder_only_are_joined_with_the_catalog_separator:
  same expected and actual.
Reading or clearing the switch note tried four times with waits of 30, 60 and 90 ms, so a note held by a virus scan or a backup tool was given up on after about 180 ms: the folder then showed a stopped switch with no known target (snapshots refused, only Discard offered), or the note was reported stuck.

Read and Clear now share one schedule in SwitchJournal.Waits (50, 100, 200, 400, 800 and 1000 ms, 2.55 s in all). Only a held note waits; a note that opens at once is read on the first try. The engine uses new ReadAsync and ClearAsync, which wait with Task.Delay and so never hold a thread (including the UI thread, which an Api call's first part can run on). The engine takes the delay from GitEngineOptions.SwitchNoteDelay so tests spend no real time. The synchronous Read and Clear remain for code with no async context; the maintenance refusal, which only needs the note's target for its message, does not wait.

Observed reds:
- SwitchJournalWaitTests.The_waits_add_up_to_two_or_three_seconds_and_never_shorten: Assert.InRange failure, actual 00:00:00.18.
- SwitchJournalWaitTests held-for-the-whole-wait (read and clear): "gave up after 00:00:00.1800000".
- SwitchJournalWaitTests scan-holds-for-a-second (read and clear): Assert.Equal failure, expected the note, actual an unknown note / Assert.True(cleared) false.
- UnreadableJournalTests status case: Assert.Equal failure, expected the note's target, actual an empty InterruptedSwitch.
- UnreadableJournalTests discard case: SwitchNoteStuckException.
Mutation checks: waiting before the first try failed the three no-wait tests; a blocking Thread.Sleep in place of the delay failed the thread-handback test.
CoreBackend.Create made the registry, put it on the list the process-exit handler closes, and then built the rest; a failure in that rest left it listed with no backend to release it. The rest is now built in Assemble, and Create releases the registry and rethrows if it fails.

Observed red: CoreBackendTests.A_backend_that_fails_to_build_leaves_no_git_registry_on_the_exit_list failed on Assert.False() (the registry was still on the exit list). The failure is forced through the Launch factory, which runs after the registry is made, and the registry is read from services.Runner.Options.Registry.
UseStorageFolderAsync, RecoverCatalogFileAsync, StartWithEmptyStorageAsync and ExportDefinitionAsync finish quickly and cannot be stopped halfway, so they take no token (D23). The implementations pass CancellationToken.None down, as the other short mutations do. The fake backend and every caller are updated. Red observed first: ShortMutationSignatureTests.A_short_mutation_cannot_be_cancelled_by_the_caller failed for all four members with Assert.DoesNotContain() Failure: Filter matched in collection.
# Conflicts:
#	src/Savepoint.App/Composition/FeatureComposition.Settings.cs
Retries existed for the WSL gate's 9p mount (D27). The Linux gate now runs on
the VM's ext4 and nothing sets SAVEPOINT_TEST_RETRIES, so build/TestRetry.targets,
build/report-retried-tests.sh, the Microsoft.Testing.Extensions.Retry package
version and the two test projects' imports are removed.

Without the extension --retry-failed-tests does not exist, so gate.ps1 and
gate.sh now treat it like any other narrowing argument and refuse it with a
message that says only a report (--report-*) is allowed.

Tests: GateArgumentTests runs copies of the gate scripts in an empty folder.
Observed red: The_windows_gate_refuses_a_retry_of_failed_tests (all four
spellings) failed with "the gate did not refuse --retry-failed-tests ..." since
the old script let the argument through to the build. The report-is-not-refused
tests passed first; mutating the report pattern in gate.ps1 made
The_windows_gate_does_not_refuse_a_report fail, then it was restored.
The bash variants skip on Windows and are listed as optional in windows.txt.
A game can name a third folder outside its install that holds its mods:
GameDefinition.Mods (JSON "mods"), RepoRole.Mods and ModsLocation. The key
is additive, so a catalog that holds one still reads in the previous
release, and a games.json from that release loads unchanged. The saves
role is never widened to "mods".

The validator requires a mods path when the folder is present and refuses
any nesting of the mods folder with the install or saves folder, placed on
mods.path. Normalize trims the path, Equals and GetHashCode cover it, and
the folder gets only the game-wide leave-out rules.

Templates carry it like the saves folder: "mods" for Windows and
libraryHints.modsByOs for Linux and macOS; 7 Days to Die names
{appData}\7DaysToDie\Mods, its Linux and macOS folders, and the Mods hint.

Observed reds (assertion failures):
- ModsFolderCatalogTests.Two_definitions_that_differ_only_in_the_mods_folder_are_not_equal: "Values are equal"
- ModsFolderCatalogTests.A_mods_folder_with_no_path_is_reported_on_the_mods_field: expected [mods.path modsPathRequired], actual []
- ModsFolderCatalogTests.Normalizing_trims_the_mods_path...: expected "D:\Mods", actual "  D:\Mods  "
- ModsFolderCatalogTests.A_mods_folder_that_nests_with_another_folder_is_reported_on_the_mods_field (7 cases): issues empty
- ModsFolderTemplateTests (4 tests, with the draft and the template file reverted): a draft has no mods folder
Mutation checks on tests that passed first: ExternalRole gaining "mods",
IgnorePathsFor giving mods the install-only rules, and a defaulted Mods
property each failed the matching test.
WithTwoProfilesAsync captured two profiles with real git in every test that used it. The world is now built once per free program name (a test that runs the stand-in game finds it by file name, which the snapshots hold, so tests running at once cannot share one) and each test gets a copy that is reopened as after a restart. Game arguments and the process name are set on the copy. BackendWorkspace.CopyOf takes the options the copy's backend needs.

The copy keeps the consent marker (its time is the template's), is rewritten to its own root, and changes nothing in the template: TwoProfileTemplatesTests pins the equality with a hand-built rig, no leak between tests, and distinct names and folders for tests at once. Mutation checks seen red: reusing a slot without taking it (names equal), and skipping the root rewrite (copy edits reached the template).

LaunchStoppedSwitchReviewTests: 2m08s before, 1m24s after; slowest test 11s, so its timeout drops from 150 s to 60 s.
When the target holds a link (git mode 120000, such as lib -> lib64 in a native Linux game) where the point being left holds a real folder, a switch killed after it made the link left the link standing there. The finish took no notice of it (a link to a folder is not a file, so the removal of standing files skipped it), git then refused to replace the folder, and the failure surfaced as "cannot be read" for the link. Discard was the only way out.

The removal of standing entries now handles a link: it takes away the link itself, never what it leads to, and keeps the guards a file has (no link above it, the name exactly as spelled, inside the approved folder). The scan now compares what stands where the target wants a link: a link of the right length is the stopped switch's own write and is not listed; a file, or a link to somewhere else, is listed as replaced so the launch dialog counts it. On Windows a plain file holding the link's text is compared like any other file.

Tests skip on Windows, which refuses folder links, and are listed in build/expected-skips/windows.txt.

Observed reds (Linux VM, one class, before the fix):
- A_switch_killed_after_it_made_the_link_where_the_old_folder_was_is_finished and Finishing_removes_the_link_and_never_what_it_leads_to: FileUnreadableException "'.../lib' cannot be read, so it could not be checked for changes".
- A_link_pointing_somewhere_else_is_listed_as_replaced... and A_file_the_player_put_where_the_old_folder_was_is_listed_as_replaced...: Assert.Equal collections differ, expected ["lib"], actual [].
Mutation check: treating every link as other content made The_review_does_not_list_the_link_the_killed_switch_made_as_replaced fail.
The Code Cleanup merges fixed the hand-built commands, the factories that kept FeatureContext, the Storage imports, UiProgress's SynchronizationContext, ProcessFileRevealer, and the four short mutations that took a token.
# Conflicts:
#	build/expected-skips/linux-ci.txt
- Close/Release now clears the running-git note only when this registry wrote it, and then leaves it holding just the earlier run's gits that still run. A backend that fails to build no longer deletes the previous run's note (D59.3/D59.4).
- Closing a registry rewrites the note for any other live registry on the same folder, so its gits are not left off until its next change.
- A git added after Close is ended at once (the caller has already started it, so refusing would leave it running unowned).
- KillAll and Close skip gits that are left to finish (reclaim, D46.1/D59.1); the next start settles them by their own marker, and they stay off the running-git note, which would otherwise get them killed after 10 s.
- Settings: ForThisApp takes the clock, so the apps menu entry is built once.
- Releasing_twice test replaced by one that fails if a second release removes another registry's note.

Observed reds:
- Releasing_twice_leaves_a_note_another_registry_wrote_in_between: the second release removed a note it had not written
- Releasing_a_registry_that_wrote_nothing_keeps_the_note_an_earlier_run_left: a registry that never wrote the note removed the one an earlier run left
- Releasing_keeps_the_gits_of_an_earlier_run_that_still_run_on_the_note: a git an earlier run left, still running, was dropped from the note
- Releasing_one_registry_leaves_the_gits_of_another_on_the_same_folder_on_the_note: the surviving registry's git is not on the note
- A_git_added_after_the_registry_closed_is_ended: a git started after the registry closed was left running
- Closing_leaves_a_git_that_is_left_to_finish_running_and_off_the_note: a git that finishes after SavePoint exits was ended when the registry closed
The test folder sits inside the checkout, so the copied gate.ps1 found the
real repository and waited on the machine-wide gate lock, which the gate
running the tests holds. The scripts now run with git unable to look above the
test folder, so a pass-through run stops before the lock. The pass-through
tests also assert the script printed its extra-arguments line.

Checked with the lock held by a second process: the class finished in 8 s.
CaptureBytesTests holds git until the capture reports it is finishing instead of 500 ms. ProfilesCaptureTests holds the first capture until the second is queued behind it (or has got in beside it) instead of 300 ms. StartupLeftoverGitTests drops a 600 ms wait the one-hour note delay already made redundant and ties its 2 s absence wait to the leftovers' wait. ConsentMarkerTests, DBusNotificationBusTests and PlayJourneyTests keep their delays with a comment that names the clock (the read's retry window, the bus daemon, git's whole-second file times).

Observed red: with the capture lock keyed per call, Two_captures_of_one_game_run_one_after_the_other failed on its overlap assertion; green again once restored. The two CaptureBytesTests finishing tests pass with the hold cut to zero on this machine because git add itself outlasts the sampling window, so their hold is not shown to matter here.
build/package-linux.ps1 now exports the commit with git archive, uploads it with
the new build/package-linux.sh, runs build/package.sh on the VM over SSH in its
own folder (~/package, with its own SDK, caches, tree and lock, never the gate's
~/gate), and copies the package back. A second run while one is going is refused
with exit code 75. The .linux-gate worktree logic and its .gitignore line are
gone. build/package.sh keeps its contract for CI; only its header comment changed.

Compared with the old script: -Distro and -AllowDirty are gone (the archive is
always the committed tree, tied to its commit), and the package lands in
artifacts/release/linux-x64 of this checkout (contents-linux-x64.txt beside it,
source/ with -Sources) instead of .linux-gate/artifacts/release/linux-x64.

Verified by running it end to end: cold 97 s (SDK install, git bundle download,
publish, pack), warm 24 s; the AppImage (63.7 MB) came back; a second run during
the first exited 75 with the holder line; the holder file was gone afterwards.
ThemePolishTests now names the three theme facts it pins. The render test headers (Games, History, Settings, Launch, Shell, GameEditor, Artwork, Help, StyleGallery) say the PNGs are compared with the previous render of the same screen after a change, which is what docs/ui-guide.md and docs/developer-guide.md tell a person to do. The launch flow's review of a half-switched folder is a product screen and is left as it is. A search of tests and tools for comments naming a milestone, slice, issue, task, review, pull request or build step found nothing else.
The local Linux gate and Linux packaging now run on the Linux test VM over SSH, the WSL skip list and test retries are gone, and the gates refuse --retry-failed-tests. D27, D48 and the packaging items point at D60.
With core.symlinks off, git for Windows records a file symlink as the text of its target and a switch or discard writes that text back as an ordinary file. A mod manager's symlink deployment then stops loading after the first switch. Capture, the capture preview, the switch (including the launch's pre-check of later folders), discard and clean now refuse, on Windows only, when a file they would read, write or remove is a symbolic link. The refusal is LinkedFileException with its own id error.capture.linkedFile; the error card names the file and tells the player to switch the mod manager to hardlink or move deployment. Linux and macOS keep storing and restoring links natively.

Detection sits in LinkedFolders.RefuseAny, the one place every linked-folder refusal already goes through. It lists each folder holding the files once and reads the reparse-point attribute that comes with the listing, so no file is opened. Measured on 100,000 files in 1,100 folders: 28 ms for the listing check in a standalone probe and 40 to 100 ms for the engine's whole RefuseAny; one FileInfo query per file took 1.6 s on all cores and 6.7 s on one; git ls-files -s after staging took 130 ms but staging 100,000 files took minutes, it cannot run before staging, and it misses the preview. A directory symbolic link that git lists as an entry is still reported as a linked folder.

Observed reds (assertion failures, before the check existed):
- LinkedFileTests.A_capture_refuses_a_file_link_and_names_it_and_stages_nothing: Assert.Throws() Failure: No exception was thrown, expected LinkedFileException
- LinkedFileTests.The_capture_candidates_refuse_a_file_link_too: No exception was thrown
- LinkedFileTests.Discard_that_would_overwrite_and_clean_that_would_delete_a_file_link_are_refused: No exception was thrown
- LinkedFileTests.A_switch_that_would_delete_a_file_link_is_refused_and_leaves_the_link(force: True): No exception was thrown
- LinkedFileTests.A_switch_that_would_write_over_a_file_link_is_refused_and_leaves_the_link and the force: False case: Exception type was not an exact match, actual DirtyWorkingTreeException
- ErrorCardViewModelTests.A_file_link_card_names_the_file_and_points_to_the_mod_managers_other_deployment_methods: Expected "A file in the game is a link", Actual "Something went wrong"
- A first version enumerated a folder that does not exist (a recorded file whose folder is gone, a folder a switch creates) and threw DirectoryNotFoundException; 47 FileFolderCollisionTests failed on it, fixed by listing inside the try, pinned by A_capture_of_a_folder_whose_recorded_files_are_all_gone_is_not_stopped_by_the_link_check.

Tests that passed on their first run got a mutation check: the ignore-list test and the case test fail when the listed-files filter or the case-insensitive comparison is removed, the folder symbolic link test fails when the folder/file classification is removed, the API-level, CheckSwitch and error-args tests fail when the check is disabled or the arg renamed.

Windows tests that need a file symlink skip when one cannot be made (Developer Mode or an elevated account); the Linux gate lists them as expected skips, the Windows list names them as optional, and the Linux-only storage test is a required Windows skip.
A game with a mods folder now has three folders in the order a switch
writes them: install, mods, saves (GameFolders). The mods folder gets its
own git directory (mods.git) and a consent marker whose role is "mods",
which any other spelling still fails to parse. Adding or editing a game
checks every pair of its folders for nesting by name and identity and
places the issue on the mods field when the mods folder is one of the pair.

The names of a game's git directories now come from one list on
StorageSnapshot, so Find the folder, the storage move, Clear all data and
the startup repair see mods.git as well. The free-up note carries a "mods"
key beside the two it had and still finishes a note written without it.
Recently removed groups a snapshot by capture event across three stores, so
a snapshot only the mods folder recorded is listed.

Observed reds:
- ConsentMarkerModsTests.A_mods_marker_is_written_with_the_role_mods_and_read_back: expected role "mods", actual "external"
- ConsentMarkerModsTests.Verify_passes_for_the_mods_role...: marker named the external role
- ModsStoreTests (9 of 11): GetFolderStatus listed [Install, External], no mods store or marker was made, an overlap of the mods folder with another game was not refused, mods inside saves was not refused, a re-pointed mods folder was not checked, orphan roles were [Install, External]
- ModsStorageTests: GitDirectory(Mods) was external.git; Find the folder said no history for a root holding mods.git alone; the adopted mods.git kept its [alias]; the move left no mods.git
- ModsFreeUpSpaceTests (9 of 9): a snapshot only the mods folder recorded failed the preview (Lead was null), free-up and stop-and-finish runs failed with it
Mutation checks on tests that passed first: dropping mods.git from the name list, lowercasing the marker role, and dropping the "mods" key each failed the matching tests.
ContractHarness (real side), JourneyRig and the AppBootstrap tests started a CoreBackend and never disposed it, so each left its git process registry on the exit list. Each now disposes its own backend in its dispose, after the jobs it started have ended and before its folders go. Test code only; no behavior change.
The tidy SavePoint starts by itself after a crowded snapshot (routine mode,
deletes nothing) was a Compact job, so Activity, the job pill, toasts,
notifications and error cards all called it "Freeing up space", which players
read as SavePoint deleting what they just added. The player's Free up space
(and the reclaim after deleting a profile) stay Compact.

- Core: JobKind.PackStorage, chosen by OptimizationService.Start from the
  mode; four pack step ids used by the routine run; the registry and
  JobOutcome treat it as preemptible and cancellable like Compact.
- App: titles, pill, toasts, OS notifications, steps, ErrorOperation.PackStorage
  with its own paused and canceled card text. The new text says "snapshot
  files" because the catalog lint retires "storage" and "on disk".
- Tests that found the routine job by JobKind.Compact now look for PackStorage.

Observed reds before the code:
- JobPreemptionTests.A_running_routine_optimization_can_be_preempted_...:
  expected Requested, actual NotCancellable.
- JobPreemptionTests.A_preempted_routine_optimization_reports_the_same_message:
  InvalidOperationException "A PackStorage job is never preempted."
- JobRowViewModelTests.A_job_is_named_in_plain_words_with_its_game(PackStorage):
  expected "Compacting snapshot files for Skyrim Special Edition", actual
  "Clearing SavePoint's data".
- Passed first run, then failed under mutation (kind and step choice reverted):
  ProfilesCaptureTests routine tests; (card copy branches removed):
  ErrorCardViewModelTests routine packing tests.
A snapshot writes a point in each of the game's stores under one capture
id, so the mods folder is saved on a new profile, on a later capture and
on its own when it is the only folder asked for. A failure in the mods
folder alone makes the job partial with the mods outcome, and a retry of
just that folder completes the same point. The mods folder leaves out the
game-wide rules and never the install-only ones.

The capture preview counts every file of the mods folder as a mod file,
where the install folder counts only the files its hints name.

Observed red:
- ModsCaptureTests.The_preview_lists_the_mods_folder_and_counts_every_file_in_it_as_a_mod_file: expected 2 mod files, actual 0
The other six capture tests passed on their first run, because the capture
runner already loops over every folder; they failed (7 of 7) when
GameFolders stopped listing the mods folder, then passed again.
Settings > Appearance gets an Interface size choice (100%, 125%, 150%,
175%, 200%) that multiplies the operating system's display scaling. It is
saved as AppSettings.UiScalePercent (older files read 100), applied by the
shell at start and on every settings change, and follows an open window
without a restart.

The main window lays its content out under a LayoutTransformControl bound
to a ScaleTransform the theme service publishes, so text, icons, spacing
and hit targets scale together; popups take their anchor's transform
(Popup.InheritsTransform), which carries the scale into flyouts, menus and
tooltips. The window's smallest size grows with the scale, capped to the
room the screen leaves.

Observed reds: UiScaleSettingsModelTests.* (Expected 100, Actual 99 with the
default mutated), UiScaleTests window/popup tests (Expected 1.5 Actual 1;
Expected 1.75 Actual 1; MinWidth Expected 960 Actual 640), AppearanceUiScale
tests (Expected [150] Actual []; Expected 200 Actual 100), the ScaleSelector
choice-list theory (No ListBox named ScaleSelector). Mutation checks: the
screen-fit cap and the same-scale early return each failed their tests when
removed; pointing the window at a missing resource failed both dialog tests.
ChipItem is a per-row view model now, so its remove command is declared with
[RelayCommand] like its edit commands (RemoveCommand). The chip is announced
as a button, so Space opens it for editing as well as Enter and F2, and the
help text says so.
The filter flyout held a plain ListBox although picking a profile is a
single choice. It is now a ChoiceListBox with an accessible name and a name
on each option, so assistive technology meets a radio group. Arrow keys,
Enter, Escape and click keep their behavior (the existing flyout keyboard
tests pass unchanged apart from asking for a ListBox subtype).

The lint that finds single-choice lists left as plain lists now also flags
a ListBox declared inside a Flyout.

Observed reds: No_choice_of_one_in_the_app_is_left_as_a_plain_list failed
listing HistoryScreenView.axaml with the flyout lint added. The group test
The_list_is_a_named_group_of_radio_buttons_for_screen_readers was first run
after the change; removing the list's name made it fail, confirming it
checks the name.
HoldsTarget asked FileInfo.Exists before looking for a link, and Exists is
false for a link to a folder, so the entry counted as nothing and was removed
without the dialog naming it. A link is now looked for first and always counts
as content the finish replaces. A link is compared by the git blob id of its
text, not its length (../mods/a and ../mods/b are the same length), and on
Windows any real link or junction standing where the target wants a link is
never the switch's own write, because core.symlinks is off there.

Git for Windows lists what a junction leads to and not the junction, so the
scan also looks at the written paths that have a folder above them in the old
point and takes any that are links.

The Windows switch refuses a junction at the old folder's place before the
finish (LinkedFolders), so the Windows branch of TryDeleteLink is reached only
when a link appears after that look; a test puts one there in the removal
step. The refusal itself is pinned by a Windows test.

Observed reds:
- FinishSwitchTests.The_review_lists_a_folder_link_standing_where_a_folder_was_as_replaced
  (Windows junction): Expected ["Mods/Foo"], Actual []
- FinishSwitchFolderLinkTests.A_link_to_another_place_whose_text_is_as_long_as_the_targets_is_listed_as_replaced
  (Linux, old code): Expected ["lib"], Actual []
- FinishSwitchFolderLinkTests.On_Windows_a_junction_standing_where_the_target_wants_a_link_is_listed_as_replaced
  (Windows rule removed): Expected ["lib"], Actual []
Mutation check: with the Windows branch of TryDeleteLink disabled,
A_folder_link_put_where_the_file_stood_after_it_was_looked_at_... fails with
"Could not remove these files standing where the point being left had a folder".
A discard writes the snapshot's own bytes over a file link and a clean deletes it; neither goes through the link, so only folder links are refused there. A stopped switch whose note cannot be read offers only Discard, and refusing it left the player no way out.

LinkedFolders.RefuseAny takes includeFileLinks (default on, for capture, preview and switch); discard and clean pass false.

Observed reds (before the change):
- A_discard_replaces_a_file_link_with_the_snapshots_file_and_leaves_what_the_link_led_to: LinkedFileException thrown by the discard
- A_clean_removes_a_new_file_link_and_leaves_what_the_link_led_to: LinkedFileException thrown by the clean
The leftover resync, the new-file retry and the displaced-file removal still
failed on a read-only file on Windows, where the stopped-switch finish had
already learned to remove one. They use the same helper now. The helper gave
the mark back to nothing: a file another program held stayed without its
read-only mark after the failed delete. It restores the mark when the file is
still there.

Observed reds (Windows):
- ReadOnlyRemovalTests.A_read_only_file_the_old_point_held_that_comes_back_while_a_switch_is_verified_is_removed:
  GitOperationException "Could not write the point's copy of these files: b-only.txt"
- ReadOnlyRemovalTests.A_read_only_new_file_that_appears_as_a_clean_ends_is_removed:
  GitOperationException "Could not remove these new files: late.txt"
- ReadOnlyRemovalTests.A_read_only_file_standing_where_the_switch_needs_a_folder_is_removed_by_the_switch:
  GitOperationException "Could not remove these files the point being left held: logs"
- ReadOnlyRemovalTests.A_read_only_file_that_another_program_holds_keeps_its_mark_when_the_finish_cannot_remove_it:
  "the file lost its read-only mark though it was not removed"
A launch resolves and reads three folders, checks the mods and saves
folders before the install is written, and switches install, then mods,
then saves. A profile that never saved the mods folder leaves it alone, as
a saves folder added later is, and the save after play adds it. A point
resolves in the mods folder like in the others and names the point where
the install has no commit. A switch stopped during the mods folder is
finished by the next launch of the same target with the install left where
it is and the saves untouched, and a stop on the way to an older point is
finished by that point.

LaunchPreview gains an optional Mods state, SessionState.Exited an optional
ChangedModsFileCount, and the skip-the-dialog case needs the mods folder to
match as well. The mod-file count of a profile adds every file of its mods
commit to the install files the hints name, and the switch summary counts a
mods change as a mod change. Duplicate copies the mods branch.

Observed reds:
- ModsLaunchTests.A_launch_of_a_profile_that_never_saved_the_mods_folder...: ProfileHasNoPointsException for the profile
- ModsLaunchTests.The_save_after_play_adds_the_mods_folder...: ProfileHasNoPointsException
- ModsLaunchTests.The_session_counts_the_files_that_changed_in_the_mods_folder_while_playing: expected 2, actual 0
- ModsLaunchPreviewTests (7 of 11): Assert.IsType null for the Mods state, mod count expected 4 actual 2, expected 2 actual null with no hints, Duplicate left the copy without a mods branch
The remaining tests passed on their first run on the generic launch code.
Mutations that each failed the matching tests: the check of the later
folders skipping the mods folder, and OnlySaveDiffers ignoring the mods
folder.
GetStatusAsync waited up to 2.55 seconds for a held switch note on every call,
so a refresh of many folders could stall on one scanner-held note. It takes
waitForNote (default true). The callers that read only the state of the files
(profile row state, the after-play save's clean check and file counts, the
discard log counts) pass false; the launch preview, the stopped-switch review,
captures and switches keep the waiting read because they act on the note's
target. The SwitchJournal.Waits comment now cites D31.6 instead of restating
the reasoning.

Observed red:
- UnreadableJournalTests.A_status_that_only_reports_does_not_wait_for_a_note_another_program_holds_open
  (Windows, parameter present but ignored): Expected 00:00:00, Actual 00:00:02.5500000
Mutation check: a no-wait read that always answers "no known target" fails
A_status_that_does_not_wait_still_reads_a_note_nobody_holds.
The toggle exists once in each layout's chrome. An arrow key changes the
choice, the shell swaps the layout, and the copy that held focus was hidden
with it, so focus was lost. The toggle view now marks an arrow key press
around the list's own handling; the view model raises FocusRequested when
that press switched the layout (and again if the save failed and the layout
was put back), and the copy on screen focuses the chosen option. Arrow keys
still move and wrap the choice as for any radio group; a click does not ask
for focus.

The choice-list focus theory no longer exempts the layout toggle, and its
setup finds the toggle again after choosing the first option swaps the
chrome.

Observed reds: An_arrow_key_leaves_focus_on_the_option_it_chose
(games-library, Toggle) failed with a ListBoxItem focused instead of the
toggle option; Arrow_keys_on_the_layout_toggle_keep_switching_the_layout_
without_the_player_touching_the_mouse failed with Actual: null focus.
Mutation checks: BeginKeyboardChoice made a no-op failed both; EndKeyboardChoice
that never clears failed A_later_pointer_switch_is_not_taken_for_a_keyboard_one.
The Games footer figure is refreshed through the shell's library refresh, which runs when any job but a launch ends, so the tidy needs no handler of its own in GamesScreenViewModel. Added a test for it. It passed on its first run; mutation check: excluding PackStorage from the shell's refresh made it fail with Expected 10 GB, Actual 41.2 GB, then restored. JobKind.PackStorage doc now says a tidy finishes a free-up the player confirmed that was cut off earlier (D46.2).
A snapshot taken before file links were refused (or while a program linked its files) can hold entries of mode 120000. Git for Windows writes such an entry back as a text file holding the link's path, which silently breaks the file. The refusal only looked at the folder on disk.

On Windows a switch (CheckSwitchAsync, the switch itself and the finish of a stopped one) now refuses, before anything is written, when the files it would write include a 120000 entry, and a discard refuses when a changed file's entry in the point is one. New SnapshotHasLinksException (error.switch.snapshotHasLinks) names the first file; the launch pre-check reaches it through CheckSwitchAsync, so a later folder's refusal leaves earlier folders alone. Switching away from such a snapshot, and discarding with the text file already in place, are not refused. Linux and macOS restore the link.

The linked-file copy no longer assumes a mod manager made the link and names the leave-out list as the other way forward.

Observed reds (before the change):
- Asking_whether_a_switch_is_possible_refuses_a_snapshot_that_holds_a_link_and_names_the_file: Assert.Throws failure, no exception was thrown
- A_switch_to_a_snapshot_that_holds_a_link_is_refused_before_anything_is_written (force false and true): no exception was thrown
- A_discard_that_would_restore_a_link_as_a_text_file_is_refused_and_writes_nothing: no exception was thrown
- A_snapshot_with_a_link_card_names_the_file_and_says_the_other_profiles_still_work: expected the new title, actual 'Something went wrong'
- A_file_link_card_reads_right_for_a_link_made_by_hand_and_offers_the_leave_out_list: 'made it yourself' not found
Tests that passed first (A_switch_away_from..., A_discard_leaves_alone...) failed under a mutation that refused unrelated entries.
The held-file probe opened whatever path it was given, and opening a folder
fails with access denied, so a folder (or a link to one) counted as a file
SavePoint could not read. A refusal over a folder link then said a file could
not be read, and a status whose only change was a file replaced by a link to a
folder reported the folder clean. The probe now answers null for a folder or a
link to one, so the caller falls through to the unsaved-changes answer.

Observed reds:
- FileLockProbeTests.A_folder_is_not_a_file_that_cannot_be_read and
  A_link_to_a_folder_is_not_a_file_that_cannot_be_read (Windows):
  Expected: null, Actual: Unreadable
- HeldFileStatusTests.A_file_replaced_by_a_link_to_a_folder_is_an_unsaved_change_and_not_a_file_that_cannot_be_read
  (Linux): Assert.False(status.IsClean) Actual: True
error.gitOperation.checkoutFailed is raised for a file another program holds
open, and also for a file that stayed after SavePoint tried to remove or write
it (a read-only mark it could not clear, access denied) and for a lock git
could not take. The neutral text and the switch text now say SavePoint could
not change the file and name the two usual causes, an open file and a
read-only one. The held-file preview text, the snapshot text and the free-up,
move and clear-data texts stay: they come only from a file another program
holds. The three assertions on the old words moved with the copy; no failing
run was observed first, since each is a plain string comparison.
History groups a capture event across three stores, so a change only the
mods folder recorded is a point of kind VersionAndMods with the mod files it
changed, and a point is in use only while the install and the mods folder
are both at its commits. A profile row counts every file of the mods folder
beside the install files the hints name, is active only with the mods
folder on its branch and clean, lists it among the unsaved folders, and
counts it for Take a snapshot now. Recently removed counts the mods
folder's files in a snapshot's mod count.

A game added from the library keeps the template's mods folder only when it
exists, and the result names the one it left out.

Observed reds:
- ModsHistoryTests (7 of 11): a mods-only capture listed as SaveOnly, the first point not in use (the mods entry had overwritten the saves entry), the row counted 1 where 3 was expected and null where 2, an unsaved mods file left the profile active, a never-saved mods folder left it active
- ModsLibraryTests.A_mods_folder_the_game_has_not_made_yet_is_left_out_and_the_result_says_so: expected Added, actual Refused
Duplicate, delete preview and bring back passed on their first run; making
Duplicate start the mods branch empty failed both Duplicate tests.
The chip text was a Border announced as a button through a control-type override, so a screen reader's invoke command (Narrator Caps+Enter, VoiceOver VO+Space, UIA Invoke) had nothing to press. It is now ChipEditButton, a Button that takes the Button theme: Enter, Space and the invoke command open the chip, F2 keeps its key binding, a mouse or touch click still does nothing so a double-click opens it. The remove button and focus-return logic skip the new button. Also restored the space after the colon on gameEditor.chip.remove in editor.json and corrected the tunnel-handler comment in ChipListView.axaml.cs.

Observed red: ChipListEditViewTests.A_screen_readers_invoke_command_on_a_chip_opens_it_for_editing failed with 'Assert.IsAssignableFrom() Failure: Value is an incompatible type. Expected IInvokeProvider, Actual NoneAutomationPeer'. A_single_click_on_a_chip_does_not_open_it passed on its first run; mutation check: making ChipEditButton.OnClick always click made it fail (Assert.False() Failure, Expected False, Actual True), then restored.
The standard says a test waits on a condition with a deadline and keeps a fixed delay only when a comment names an outside clock. About 55 waits had neither. Now:
- The 1100 ms waits for git's whole-second dates go through one helper, GitClock.NextSecondAsync, whose comment names the clock (17 sites in Core tests).
- Absence waits (a call is still waiting, nothing was written) use a named constant per class whose declaration comment says what the window proves. The windows keep their lengths, except GameStarterTests, which now uses the longer of its two windows for both.
- Timer-driven holds and cancels carry a comment on the line.
- The Copy test in ActivityScreenViewTests polls the clipboard instead of waiting 50 ms.
- The standard's verification grep is widened to Task.Delay( and lists the forms a hit may take; the Known violations entry is removed.

Test code and the standard only. Observed check for the one changed wait: with the view's clipboard write replaced by an empty string, Copy_puts_the_lines_on_the_clipboard fails with 'Expected start: Taking snapshot ...'; restored.
A hand-edited percent far outside the steps made the distance calculation overflow. The number is clamped to the step range first.

Observed reds: A_scale_that_is_not_one_of_the_steps_becomes_the_nearest_step(-2147483548) threw OverflowException (Negating the minimum value of a twos complement number is invalid); (int.MinValue) failed Assert.Equal: Expected 100, Actual 200.
Tests passed on their first run, so each got a mutation check: setting InheritsTransform to False on Popup in Base.axaml failed A_context_menu_opened_after_a_scale_change_is_drawn_at_that_scale and A_tooltip_shown_after_a_scale_change_is_drawn_at_that_scale (Expected 1.5, Actual 1) and the existing popup tests (restored). The edge test asserts the 200% scale as well as the position, so the same mutation fails it.
The doc comments that said a game has two folders now say every folder, and
the catalog gets the one string the new validation message id needs, because
the catalog lint requires every id used in source to have one. The rest of
the mods copy is left to the screens.

Observed red:
- CatalogLintTests.Every_key_used_in_source_exists_in_the_catalog: 'validation.game.modsPathRequired' is used in src/Savepoint.Core/Catalog/ValidationMessageIds.cs but is not in the catalog
After a keyboard layout switch the toggle asked for focus again when the save ended, pulling focus back from a player who had tabbed away. The second request is now its own event and the view takes focus only when it is nowhere or on a copy no longer shown. Adds tests for the slow save, the finished save and the failed save (layout back, copy on screen takes focus). FakeSettingsApi gains SaveGate to hold a save.

Observed red: Focus_the_player_moved_elsewhere_during_a_slow_save_stays_there failed Assert.Same (Expected the Nav list item, Actual ChoiceListBoxItem of the toggle). The other two passed on first run; mutation check: skipping the restore focus failed the failed-save test (Expected Visual, Actual null), and skipping all focus failed both.
The profile row's More actions menu now lists "Open game folder" and "Open saves folder" (one entry per folder the game has) between Duplicate and Delete. The menu is a single list on the row view model (ProfileMenuEntry) that the flyout binds to, keyed by folder role, so a further folder kind needs only a catalog label. The screen reads the folder statuses with each reload; choosing an entry reads them again, so a folder that went away since shows the existing "can't find the folder" message instead of opening, and a file manager that cannot start gets its own toast. The folder opens through IFileRevealer (FileManager.Reveal already opens a folder itself with explorer.exe / open / xdg-open as list arguments).

Observed reds (GamesScreenOpenFolderTests): A_row_menu_offers_the_game_folder_and_the_saves_folder_after_duplicate_and_before_delete - Collections differ at index 5, expected "open:install" actual "delete"; Choosing_the_saves_folder_opens_that_folder_on_this_machine, Choosing_the_game_folder_opens_the_install_folder, A_folder_that_is_gone_says_so_instead_of_opening, A_folder_that_went_missing_after_the_screen_loaded_is_caught_when_it_is_chosen, A_file_manager_that_cannot_start_is_reported - Assert.Single() Failure: The collection did not contain any matching items; A_game_without_a_saves_folder_offers_only_the_game_folder - expected ["open:install"] actual []; Every_row_offers_the_same_folders - "open:external" not found.
Passed on first run, then mutation-checked: A_folder_kind_with_no_label_of_its_own_still_reads_as_a_folder (select other branch changed, failed "Open thing"); Every_entry_of_the_row_menu_has_a_name_and_the_folder_entries_open_their_folder (name setter removed, failed 8 of 8).
A profile row opens its menu on right-click, the menu key and Shift+F10, in addition to the More actions button. Both flyouts bind to the row's single MenuEntries list and share one item theme, so they offer the same entries in the same order with the same enabled states. Avalonia opens a context menu from the menu key but not from Shift+F10, so the screen view raises the context request for the focused row on Shift+F10. The row keeps its spoken summary.

Observed reds (GamesScreenViewTests): Right_clicking_a_row_opens_the_same_menu_as_more_actions - Assert.NotEmpty() Failure: Collection was empty; The_menu_key_and_shift_f10_open_the_menu_of_the_focused_row (Apps and Shift+F10) - expected "Switch to this profile" actual null; A_row_with_a_right_click_menu_keeps_its_spoken_summary - Assert.NotNull() Failure on ContextFlyout. After the flyout was added the Apps case went green and Shift+F10 stayed red until the key handler was added.
The library add keeps only the folders the player was shown, as it does for
the saves folder. LibraryGame now names the template's mods folder and
whether it exists, and the add drops a mods folder the scan did not show as
there, so no consent marker is written into a folder the player never saw.

Observed reds:
- ModsLibraryTests.The_draft_of_a_scanned_game_carries_the_templates_mods_folder_and_the_scan_says_whether_it_is_there: expected the resolved mods path, actual null
- ModsLibraryTests.A_mods_folder_that_appeared_after_the_scan_is_left_out_because_the_player_was_not_shown_it: expected the folder in ModsFolderLeftOut, actual null
The header button gates on the loaded row's TakeSnapshotCommand, but nothing listened for that command's CanExecuteChanged, so the header only refreshed through the job events. A snapshot started from the row's menu (while it waited for the start request or its confirmation) left the header enabled. The screen now listens to each row's command and refreshes the header.

Observed red (GamesScreenActionsTests): The_header_button_is_off_and_says_so_from_the_moment_the_rows_snapshot_is_asked_for - Assert.True() Failure on "the header was told" (CanExecuteChanged never raised). Starting_the_rows_snapshot_turns_off_the_header_button_until_the_snapshot_ends passed on first run; mutation check (row.SetSnapshotBusy(false)) failed it and two older snapshot tests, then restored.
Red observed: ProcessInspectorTests.Linux_dates_a_start_from_the_boot_instant_to_the_hundredth_of_a_second_not_from_the_whole_second_boot_time
failed with an assertion: expected 00:16:43.430, actual 00:16:42.500 (the whole-second btime is used as the boot instant).
The inspector gains an unused clock parameter so the test compiles.
The interface size is lowered to the largest step the window's screen has room for (the screens need 640x420 times the size), without touching the saved choice; it comes back when the screen has room again. The window works out its smallest size, size and place on opening, when it moves to another screen, when the screen's scaling changes and when the size changes; a window that grows is kept inside the working area, and it opens centered at its final size.

Observed reds (against stubs that did nothing): The_largest_size_a_screen_has_room_for... (1920x1040 scaling 1, expected 200) Assert.Equal failed; A_wanted_size_the_screen_cannot_hold... (200, 125) expected 125 got 200; A_size_the_screen_has_no_room_for_is_drawn_at_the_largest_that_fits... failed Assert.Equal; MainWindowScreenFitTests: The_smallest_size_follows... Expected 100 Actual 150, A_saved_size_the_first_screen_has_no_room_for... Expected 100 Actual 200, A_window_opens_centered... Assert.InRange Actual 960, A_window_that_grows... window not inside the working area. Mutation checks: dropping the vertical clamp failed the grow test (640, 300, 1280, 840 is not inside 0, 0, 1920, 1040); dropping the room reset on close failed Closing_the_window_leaves_no_screen_limit (Expected 200, Actual 100).
btime drops the fraction of the boot second, so every start read from /proc was dated up to a second early. A starter that exits before the
first process look has no known start, and the game it handed over to was then rejected for starting before the session did (it began
about 40 ms after the session and was dated 0.9 s before). The boot instant is now the clock less /proc/uptime, kept as one anchor across
looks so a followed process keeps an equal start, and used only when it agrees with btime to about a second.

Observed on the Linux test VM: RealSessionTests.A_starter_named_in_the_definition_that_hands_over_to_a_process_it_started_is_followed_until_that_process_leaves
failed with Expected: NamedProcessEnded, Actual: NamedProcessNeverAppeared (5 of 5 runs).
Reds: ProcessInspectorTests.Linux_dates_a_start_from_the_boot_instant_to_the_hundredth_of_a_second_not_from_the_whole_second_boot_time
(expected 00:16:43.430, actual 00:16:42.500). The other two new tests passed first and failed under mutation (anchor never reused: start
differed by 3 ms; range check removed: start 00:31:39.500 instead of 00:16:42.500).
The size is read before the window exists so it opens at its final size and place instead of showing one frame at 100% and jumping. The read waits at most two seconds and falls back to 100%. The pinned Settings tab order now lists the Interface size stop between Theme and Layout, as drawn.

StartupUiScaleTests passed on their first run; mutation checks: reading the stored value plus one failed A_saved_number_that_is_no_step_reads_as_the_nearest_step; narrowing the catch failed A_read_that_throws_leaves_the_interface_at_100_percent. TabOrderTests.Settings_goes_down_the_sections_in_the_order_they_are_drawn was red on the batch (Expected Sidebar, Actual 100%) and is green with the stop listed.
The session start was read after the launcher returned. A starter that exits before the first look has no known start, so the lower bound for the
game it handed over to was that start; a game that began a few milliseconds before the launcher returned on a busy machine was rejected as older
than the session. The start is now read just before the program is started and passed to the watcher. The play duration and the launch record
begin at the same moment, a launcher's start time earlier than before.

Reds observed (assertion failures):
GameStarterTests.A_session_begins_when_the_program_is_asked_to_start_not_when_the_launcher_returns: expected 12:00:00.000, actual 12:00:00.300.
GameStarterTests.A_game_that_a_vanished_starter_handed_over_to_while_the_launcher_was_still_returning_is_followed: the session settled as never appeared.
A size the screen has no room for (the screens need 640x420 times the size) is switched off in Settings with a tooltip, an accessible name that says why, and a line under the row. A saved size that no longer fits shows as the largest that does, and the saved choice is left alone; it comes back when the screen has room. The shell passes the screen's largest size to Settings. Renders at the largest allowed size on a small working area prove the row stays in reach.

Observed reds (before the Appearance model followed the screen): A_size_the_screen_has_no_room_for_is_switched_off_with_the_reason (Expected False, Actual True); A_saved_size_the_screen_cannot_hold... (Expected 125, Actual 200); A_size_that_is_switched_off_cannot_be_chosen (Expected 100, Actual 200); The_shell_reports_the_largest_size... (Expected 150, Actual 200); The_screen_says_why_some_sizes_are_off... (Expected True, Actual False). MainWindowSmallScreenTests passed on first run; mutation checks: limiting by Nearest instead of Limit failed both (Expected 175 Actual 200; Expected 100 Actual 200); removing the IsEnabled binding failed the 1080p test (Expected 4, Actual 0). Not re-reading the saved size when room returns failed The_saved_size_comes_back_when_the_screen_has_room_again (Expected 200, Actual 125).
A save of several folders runs their captures side by side into one storage volume, and each capture checked only the floor plus its own files, so together they could still fill the drive. The runner now sums every folder's estimate and asks the engine once, before any folder is written. When the sum does not fit, every folder is reported failed with the usual disk-space error, whose figures cover the whole snapshot. A single folder skips the extra check, and a folder that cannot be estimated is left to its own capture to report.

The engine gains EstimateCaptureBytesAsync (the same stat-only figure the capture's own check uses, no hashing) and RequireCaptureRoom (floor plus the total against the storage volume, clearing temporary packs a stopped capture left in any of the folders first).

Observed red: ProfilesCaptureTests.Folders_saved_side_by_side_that_each_fit_but_not_together_are_refused_before_any_is_written failed with "Assert.Equal() Failure: Expected: Failed, Actual: Succeeded".
Mutation checks: ignoring the extra bytes, adding one byte, cleaning leftovers in the first folder only, and padding the estimate each made the new engine tests fail.
A point that recorded only the install folder was marked in use after a later mods-only change, because the mods folder was never compared; it kept Go back though going back would restore the older mods. InUse now compares every game folder against its commit at or before the point, as D61.2 says. HistoryPoint.InUse documents the contract.

Observed reds (before the fix, both assertion failures on Assert.False):
- ModsHistoryTests.An_install_only_point_is_not_in_use_once_a_later_mods_change_leaves_the_mods_folder_ahead_of_it: Expected False, Actual True
- ModsHistoryTests.A_mods_only_point_is_not_in_use_once_a_later_install_change_leaves_the_install_folder_ahead_of_it: Expected False, Actual True
GitProcessRegistry.Add took persist (named in the running-git note), which read as the opposite of GitRunner's SurvivesExit; a reclaim git that survives exit was added with persist: false. The flag is now survivesExit with the same polarity. No behavior change; GitProcessRegistryNoteTests stay green.
D53.1 checked saves paths only. The same check now runs over every template's mods paths on all systems.

Passed on first run, so mutation-checked: pointing the 7 Days to Die mods path at a Terraria folder made No_mods_folder_is_another_games_folder(7-days-to-die) fail with "'{appData}\Terraria\Mods' (windows) is a folder of 'Terraria', not of '7 Days to Die'." The template was restored.
Two registries on one runtime folder (a test restarts a backend on the same folder) each wrote the whole note, so the later write dropped the other's gits while both ran, and a close rewrote the survivor's gits to hide it. Each registry now has its own part of the note, keyed by a per-registry id, written under one lock; the top-level owner and one list of every git stay as 0.9.16 wrote them, so either version reads the other's note. A close removes only its own part (keeping the earlier run's gits that still run), and the WriteAgain workaround is gone. D59.6 rules unchanged.

Observed reds before the change (GitProcessRegistryNoteTests):
- Two_live_registries_on_one_folder_both_keep_their_gits_on_the_note: the second registry's write dropped the first registry's git from the note
- The_note_of_two_registries_keeps_the_owner_and_one_list_of_every_git_for_an_older_start: Assert.Contains failed, collection [35564], not found 27644
- A_registry_that_ends_a_git_leaves_the_gits_of_the_other_registry_on_the_note: Assert.True failed, the note never named both gits
RunningGitNoteTests.A_note_in_the_form_0_9_16_wrote_is_read passed on first run (a pin on the unchanged reader); mutation check: renaming the read property to gitz failed it and What_is_written_is_read_back.
ConsentMarker's role text, GameFolders.LogName and RemovedSnapshots.Group.In sent any role they did not name to saves/external. Each now names all three roles and throws ArgumentOutOfRangeException on another, as StorageSnapshot.GitDirectoryName does.

Observed reds (Assert.Throws failure, 'No exception was thrown', expected ArgumentOutOfRangeException):
- UnknownRoleTests.The_log_has_no_name_for_a_role_that_is_not_a_folder
- UnknownRoleTests.A_consent_marker_cannot_be_written_for_a_role_that_is_not_a_folder
- UnknownRoleTests.A_removed_snapshot_has_nothing_to_say_for_a_role_that_is_not_a_folder
The three mapping tests for the known roles passed on first run; they pin existing behavior the new arms must keep.
The editor gets a third folder field between the install and saves
sections with the saves section's parts: field, Browse, confirmed line,
full location, error, missing-folder card, common locations. An empty
field shows a strip saying most games keep mods in the game folder and
SavePoint already snapshots those. Clearing the field removes the
folder. The consent dialog lists the mods folder and NeedsConsent
covers it, so a template-drafted game no longer writes a mods marker
without naming that folder. Errors with role mods land under the mods
field, template drafts carry the mods folder, and pathsNested and
modsPathRequired read right for three folders. error.path.missing and
error.gameService.folderMismatch name the mods folder.

Observed reds (before the VM and view were written, with the new
properties declared as empty stubs): 23 of 24 GameEditorModsFolderTests
failed on assertions, for example "Assert.Equal() Failure: Strings
differ Expected: {appData}\7DaysToDie\Mods Actual: ''" (A_game_with_a_
mods_folder_opens_with_it_in_the_mods_field...), and "Collections differ
Expected [Game install folder, Mods folder, Saves folder] Actual
[Game install folder, Saves folder]" (A_new_game_with_a_mods_folder_
confirms_the_game_mods_and_saves_folders...). The view tests passed on
their first run; mutation check: pointing the empty-strip visibility at
HasNoSavesFolder failed An_empty_mods_field_shows_the_strip... with
"Assert.False() Failure Expected: False Actual: True"; asking consent
for the mods folder on every edit made the unchanged-folder tests fail
(the save waited on a consent dialog nobody answered).
The launch asked each later folder whether it could switch on its own, so two or three folders on one drive could each fit while together they ran out of room mid-launch. The launch now reads the volume of every folder, asks the first folder as well when another folder shares its drive, and adds up the growth of the folders on each shared volume. When the total does not fit it refuses before the first folder is written, with the usual disk-space error naming that drive and the whole shortfall. A folder that cannot fit alone is still refused with its own figures first. Only growth is summed: a folder that shrinks frees space after it is written, so it never makes room for another folder.

CheckSwitchAsync now returns the bytes the switch adds (never negative), GitEngine.RequireSwitchRoom judges a summed figure against one volume, and IDiskSpace.GetVolumeId names the volume a path is on (drive root on Windows, the deepest mount elsewhere).

Tests that held the install folder at its first free-space question to stop a switch part way now hold at the question of the switch itself, since the launch asks that folder two more times first.

Observed red: LaunchPreCheckTests.Folders_on_one_drive_that_each_fit_but_not_together_stop_the_launch_before_any_is_switched failed with "Assert.Equal() Failure: Values differ, Expected: Failed, Actual: Succeeded".
Mutation checks: grouping every folder under one volume, not clamping a shrink, ignoring the growth in RequireSwitchRoom, handing the launch one volume for all folders, and keying the Windows volume by folder instead of drive root each made a test fail.
A search box above the games in the rail, and in the library shelf's header,
narrows the list by name. Every typed word has to be found in the name, in any
order, ignoring case, accents and punctuation; the initials of a name count, so
"skyrim se" finds "Skyrim Special Edition". The selected game stays selected,
an empty result says "No games match." with a Clear search button, and opening
a game the search hides clears the search first.

The box is a shared control: placeholder, Clear button, Escape clears, Ctrl+F
(Cmd+F on macOS) focuses the search of the screen in front (the games' search
when a screen has none, never behind a dialog), an accessible name, and a live
region that says "3 of 120 games" once typing pauses for 600 ms. The icon rail
has no room for the box and lists every game.

Observed reds (assertion failures against stubs that matched nothing and
filtered nothing):
- SearchMatchingTests.Typed_words_may_come_from_anywhere_in_the_name_in_any_order: Assert.True() Failure, Expected True, Actual False
- SearchBoxViewModelTests.A_count_is_not_announced_until_typing_pauses: Expected "3 of 120 games", Actual ""
- ShellGameSearchTests.Typing_keeps_the_games_with_every_typed_word_in_the_name_ignoring_case: Expected "The Last Caretaker", Actual "Skyrim Special Edition"
- ShellGameSearchTests.Hundreds_of_games_are_filtered_by_name_and_keep_their_order: Expected 12, Actual 600
View tests passed on first run and were mutation checked: Escape key, the Clear
button's focus return, the dialog guard on Ctrl+F, the icon rail's hidden box and
the live region binding each broke a test when removed.
The registry now writes its finished jobs to activity-history.json beside the settings as each job ends (before it reads as finished), and lists those from the earlier run at start. What is kept: no more than the newest 100, none that finished over 30 days ago, and still five per game (the registry's existing rule). Only finished jobs are written, so nothing is ever restored as running; lines and results are not kept, a failed or partly done job keeps its first reason, and a clear-data job is never written. A missing file starts empty; a file that cannot be read starts empty with a log warning; a write that fails is logged and never fails the job. Clear all data deletes the file and stops the jobs finished at that moment from being written again.

Observed reds before the change (JobRegistryHistoryTests, ActivityHistoryTests, stubbed constructor and ClearSavedHistory):
- A_finished_job_is_listed_by_a_registry_started_later_on_the_same_file: Assert.Single failed, the collection was empty
- No_more_than_the_newest_100_finished_jobs_are_kept: Expected 100, Actual 0
- A_job_that_finished_29_days_ago_is_still_listed_after_a_restart and the 30-day, five-per-game, failed, canceled, partly-done and ordering tests: collections differ, nothing restored
- A_file_that_cannot_be_read_...: Assert.Single failed, no warning logged
- The_file_is_written_before_the_job_reads_as_finished: a job that had finished was not yet in the file
- A_snapshot_that_finished_is_still_in_Activity_after_the_backend_restarts_on_the_same_folders: Assert.Single failed, no match
- ClearAllLogTests (3 tests) failed while the new clear step threw for a missing folder; fixed by deleting only a file that exists
Passed on first run, mutation-checked: A_job_the_file_names_as_running_is_never_restored_as_running (removing the Running check failed it), A_job_that_clears_the_data_is_never_written (removing the ClearData check failed it), Clear_all_data_removes_the_saved_list_so_a_restart_lists_nothing (removing the clear step failed it).
A search box above the profile table narrows the profiles by name and notes,
with the same word matching as the games list. The table lists a filtered copy,
so the Take a snapshot button and the launch checks still see every profile.
A search nothing matches hides the table and says "No profiles match." with a
Clear search button. The search is kept while the screen reads the same game
again and is emptied, without an announcement, when another game is chosen.
Ctrl+F on the Games screen focuses it; the box announces "2 of 5 profiles"
once typing pauses.

Observed reds (assertion failures against a stub that listed nothing):
- GamesProfileSearchTests.With_nothing_typed_every_profile_is_listed_in_table_order: Actual [] for the five profile names
- GamesProfileSearchTests.Typing_also_looks_in_the_profiles_notes: Expected ["Hardcore run"], Actual []
- GamesProfileSearchTests.Choosing_another_game_clears_the_search_and_lists_all_its_profiles: Expected "", Actual "vanilla"
- GamesProfileSearchTests.The_count_left_is_announced_once_typing_pauses: Expected "2 of 5 profiles", Actual ""
View tests passed on first run and were mutation checked: putting the games
search before the screen's in the Ctrl+F order and showing the table on no match
each broke a test. TabOrderTests gains the "Search profiles" stop.
A finished row now reads "Took a snapshot of ...", "Compacted snapshot files for ...", "Switched ...'s files" (and the matching words for Launch, Compact, Move and Clear); a failed row reads "Couldn't ..." and a canceled one "Canceled ..."; a partly done row keeps the done wording beside its Partly done status. Every kind has its own catalog keys. Activity and the status pill no longer say "jobs": they say tasks. A finished task listed from an earlier run has no steps, so its details say so instead of "Nothing to show yet.". The footer says what is kept: five per game for up to 30 days, even after SavePoint closes.

Observed reds before the change (JobRowViewModelTests, run before the catalog and ActivityText edits): 31 failures, 29 cases of A_finished_job_is_named_in_the_past_tense_and_a_failed_or_canceled_one_says_so plus A_job_that_ends_changes_its_row_from_the_present_tense_to_the_past and A_screen_reader_hears_a_finished_job_without_progress_it_never_counted, each an Assert.Equal on the title still in the present tense.
The wording expectations in ActivityScreenViewModelTests, ActivityScreenViewTests and JobStatusViewModelTests were changed to tasks and the past tense in the same step; their reds were seen against the stale expectations when run after the change and fixed.
The two restored-task details tests passed on first run; mutation check: flipping the Running test in EmptyText failed both.
Four launch tests held the third free-space question on the install folder, so each depended on how many checks a launch makes before the switch. The rig now holds the first question that arrives once the job has said it is switching the install folder, and the tests use it.

Observed red: with the helper looking for the wrong folder name, LaunchSwitchFailureTests.Cancelling_the_switch_ends_the_launch_cancelled_and_leaves_a_state_a_second_launch_finishes_from failed with "the switch never reached the engine" (Assert.True() Failure). With the right name all four classes pass (LaunchSwitchFailureTests 4, LaunchStoppedSwitchReviewTests 11, LaunchUnfinishedSwitchTests 7, LaunchSwitchOnlyTests 9).
The volume key matched the folder's own spelling against the mount list, and on Windows the free space came from the drive letter of the spelling, so a folder reached through a junction or symbolic link was measured on the wrong volume and could be summed with folders that do not share its drive. DiskSpace now resolves the nearest existing folder to its real path before it reads either figure.

Observed reds (junction to the Windows folder on C:, test folder on F:): DiskSpaceTests.A_folder_reached_through_a_link_is_on_the_volume_the_link_leads_to failed with Assert.Equal() Failure, Expected: "C:\\" Actual: "F:\\"; A_folder_reached_through_a_link_reports_the_free_space_of_the_volume_the_link_leads_to failed with Assert.InRange() Failure, Range (0 - 268435456) Actual: 954504839168. Both skip where no second volume can be found or a link cannot be made, and are listed with ~ in both expected-skips files.
When another folder shares its drive, a launch asked the install folder the full switch question just to learn how many bytes the switch adds, which scans the whole work tree for unsaved changes and case clashes; the folder's own switch checks all of that again before it writes. The engine now has SwitchGrowthAsync, which reads the two points and the stored sizes only, and the launch uses it for the first folder. On a generated 20,000-file install folder the full question took 161 ms against 49 ms for a read of the points alone.

Observed reds (with the method present but returning 0): SwitchCheckTests.The_growth_of_a_switch_is_read_from_the_saved_points_alone_so_unsaved_changes_do_not_stop_it failed with Assert.Equal() Failure, Expected: 300000 Actual: 0. The frees-more-than-it-writes test passed on its first run; with the clamp removed it failed with Expected: 0 Actual: -300000, and the clamp is back.
Ran SwitchCheckTests 12, LaunchPreCheckTests 4 and LaunchSwitchFailureTests 4, all passing.
The Clear all data task was still running when the saved history was cleared, so it was never marked not-to-save, and the next task's write saved it. The save filter now skips that kind. A finished task of this run with no steps said its steps were not kept when SavePoint closed; the snapshot now carries Restored, set only for tasks listed from the file, and other empty finished tasks say they had no steps. The in-memory finished list applies the same 100 and 30 day limits as the file, so a run never lists more than the next start restores.

Observed reds:
- A_job_that_clears_the_data_is_not_written_by_the_next_job_either: Assert.Equal collections differ, expected [next] but actual [clear, next].
- A_running_registry_lists_no_more_than_the_newest_100_finished_jobs_as_the_next_start_does: collections differ, 105 listed instead of the newest 100.
- A_running_registry_drops_a_job_that_finished_over_30_days_ago_when_the_next_job_ends: failed, the 31 day old job was still listed.
- A_finished_task_of_this_run_with_no_steps_does_not_say_its_steps_were_lost_when_SavePoint_closed: expected "This task didn't have any steps to show." actual "The steps of this task weren't kept when SavePoint closed."
- A_finished_job_is_listed_by_a_registry_started_later_on_the_same_file (Restored): Assert.True failure with the flag unset.
A run that is exiting could delete or rewrite the note of a newer SavePoint that had already started: the single-instance guard is released before the exit handlers run. An update now leaves the note as it is when its owner is another process that is still running (matched by process id plus start time). A part of the note whose key is null, missing or not an id used to throw on the timer thread (ending the process) or drop every part; only that part is now skipped. Also covers that closing one registry keeps the other registry's part.

Observed reds:
- An_update_leaves_a_note_alone_when_another_process_that_still_runs_owns_it (with and without gits): the note was deleted or rewritten, assertion failed.
- A_part_with_a_key_that_is_not_an_id_is_skipped_and_the_others_stay("null"): Assert.Null failed, ArgumentNullException thrown from Update.
- A_part_with_a_key_that_is_not_an_id_is_skipped_and_the_others_stay("not-a-guid" and 42): Assert.Contains failed, the good part was dropped.
Mutation checks: An_update_replaces_a_note_whose_owner_has_ended fails when the IsRunning check is removed; Closing_one_registry_leaves_the_gits_of_the_other_registry_on_the_note fails when Close clears the whole note.
The Activity topic of How SavePoint works still said job twice and did not say that finished tasks outlive a restart.

Observed red: Activity_is_a_topic_of_its_own_that_names_what_it_lists_and_what_Details_and_Cancel_do failed with Assert.Contains, sub-string not found.
The launch dialog treats the mods folder as a third folder: its unsaved
and half-switched blocks, replaced-file note, discard and save-first
actions, held-file check and the "unsaved changes ask even when only
the saves differ" rule all cover it, in the order a switch writes the
folders (game, mods, saves). The version card shows when only the mods
differ and adds the mods switch to the size and time. The banner lists
the mods folder in its checks. After play, changed mods files get their
own note ("N files in your mods folder are new or changed") instead of
the update note. The partial-save card is rebuilt per folder, with one
sentence for each folder that is or is not in the snapshot, three rows
in folder order and one retry that names the folder or says "what
didn't save"; kept-as-new and left-alone copy name "your mods".
FolderRoles gives the catalog's select value for each folder, and
PartialSnapshotText holds the partial-save wording both cards share.

Every catalog message that selects on role, folder or part gets a mods
branch (Activity steps, error copy, launch dialog), enforced by a new
FolderCopyTests lint, and ErrorCopyTests renders the errors the Api
raises for the mods folder.

Observed reds: LaunchDialogModsFolderTests failed 9 of 9 on assertions
before the dialog change (for example "Dirty_folders_get_their_blocks_
in_the_order_the_switch_writes_them: Expected [Install, Mods, External]
Actual [Install, External]" and "A_stopped_switch_in_the_mods_folder_
says_how_many_files_the_finish_replaces: Expected '4 files in your mods
folder...' Actual ''"); FolderCopyTests.Every_message_that_words_itself_
by_folder_has_a_mods_branch listed 36 messages without a mods branch.
The flow, banner and post-play tests were first run with the code in
place, so each was checked by mutation: dropping the mods folder from
LaunchPreviewFolders failed the held-file, unsaved-asks, switch-again,
banner and block tests ("Assert.Empty() Failure: Collection was not
empty [StartAsync]" in Unsaved_changes_in_the_mods_folder_still_ask...);
making the mods note require more than 1000 files failed both
PostPlayModsNoteTests facts ("Expected 7 files in your mods folder..."
Actual ''); mapping Mods to "external" in FolderRoles.Name failed the
partial, kept-as-new and left-alone card tests.
The wizard's "What goes in the first snapshot" panel lists the mods
folder between the game and the saves with its file count and size. The
partial-snapshot card uses the same per-folder wording as the launch
card (shared PartialSnapshotText): one sentence for each folder, three
outcome rows in folder order, and a retry that names the one folder that
did not save or says "Retry what didn't save". The retry label for the
game folder is now the same as the launch card's.

The "snapshots from before" dialog says which folders hold the old
snapshots ("Found in the game folder, the mods folder, the saves
folder."). The library picker row and confirmation name a template's
mods folder when it exists; one that does not exist yet is shown as left
out, and the add result says so ("added without a mods folder, because
... doesn't exist yet"), the way a missing saves folder is.

The fake backend lists the mods folder in folder status, capture
preview and the delete preview, adds a library game with or without its
mods folder, and takes a changed-mods count for the exit of a session.

Observed reds: LibraryModsFolderTests failed 4 of 6 on assertions
("Expected 'Mods folder: C:\...\Mods' Actual ''"; "Assert.Single()
Failure: The collection did not contain any matching items" for the
left-out result line); ReconnectDialogModsFolderTests failed both facts
("Expected 'Found in the mods folder.' Actual ''"). The wizard tests were
first run with the code in place, so they were checked by mutation along
with the shared launch wording (see the launch commit); the two older
wizard tests that asserted the two-folder partial wording now assert the
per-folder wording.
SnapshotFolderNames.PartOf("mods.git") returned "other", so the move
and clear jobs showed the full engine path for a mods store. It now
returns "mods", and Describe gives the game folder with that part.
The engine-folder tests cover a three-folder game: the move reports the
mods folder by part, a clear that cannot remove an old mods store names
the game folder and the mods part, and the every-kind-of-job lint runs
against a game with a mods folder as well.

Observed red: SnapshotFolderNamesTests failed on assertions before the
change ("A_folder_name_is_one_of_the_three_plain_parts_or_other(name:
mods.git): Expected 'mods' Actual 'other'" and "A_path_inside_a_mods_
store...: Expected 'storage\alpha-1' Actual 'storage\alpha-1\mods.git\
objects\pack'"). The job-line tests passed on their first run because
they go through PartOf; the unit red above is the mutation check for
them.
A search row under the History header narrows the cards, the timeline, the
Saves column and the Recently removed section. A snapshot is found by its name,
its profile, what it holds (version, mods, "Saves only"), and its date: ISO
("2026-09"), the month and weekday names in the player's language, and the
shown form ("Sat Jul 4"), all read in the player's time zone, with the same
word matching, case and accent folding as the other lists. A choice group beside
the box, All, Saves or Game and mods, narrows by kind the way the two columns
split them; the profile filter flyout keeps picking a profile. Snapshots have
no notes of their own, so there is nothing more to search.

Everything is formatted once per read and typing only picks from it; a history
longer than 250 entries waits 250 ms for a pause in the typing so a word is one
redraw, not one per letter. A search nothing matches says so with a Clear search
button; Recently removed keeps its section and says "(1 of 2)" or that none
match. The count ("2 of 10 snapshots") is announced once typing pauses. The
search and kind choice last while the screen follows the same game and clear
when another game opens. UiFormatter gains DateSearchText.

Observed reds (assertion failures against a stub that listed every snapshot):
- HistorySearchTests.Typing_keeps_the_snapshots_with_every_typed_word_in_their_name_in_the_cards_and_both_lists: Collections differ
- HistorySearchTests.The_Saves_choice_keeps_the_snapshots_that_hold_saves_and_Game_and_mods_those_that_hold_the_game: Collections differ
- UiFormatterDateSearchTests.A_date_is_found_by_the_name_of_its_month_in_full_or_short_in_any_case: Expected True, Actual False
View and long-history tests passed on first run and were mutation checked:
the kind group's two-way binding, the points region binding, the removed
no-match line, the instant limit, and the search row's visibility each broke a
test. TabOrderTests gains "Search snapshots" and the kind group; the closed
explanation test now measures from the search row.
The open-folder fallback test used the mods role, which the catalog now labels (Open mods folder); it checks an unnamed role instead, and a new test pins the mods label. The error card test expected the old file-in-use switch body, which was reworded to also name a read-only file. Observed reds before the edit (reported by the batch): GamesScreenOpenFolderTests expected 'Open folder' got 'Open mods folder'; ErrorCardViewTests StartsWith 'Another program' failed on the reworded body. (#204) (#198)
The games' search box is hidden in the icon rail, and whether the rail is shown
depends on the layout as well as the width, so a layout change has to filter
the list again. Also centers the text in the shelf's slimmer search box and
strengthens the History test that the search survives a profile choice: the
reloaded set is narrowed by the same words and can leave nothing.

Observed red:
- ShellGameSearchTests.Switching_layout_in_a_narrow_window_applies_the_search_where_the_box_shows_and_ignores_it_where_it_does_not: Expected "Satisfactory", Actual "Skyrim Special Edition"
IProfilesApi.CreateAsync takes startEmpty. A named saves or mods folder gets a history that begins with an empty snapshot (as a duplicate's saves do) instead of a capture; install and the other folders capture as before. The install folder, and a folder the game does not have, are refused with validation.profile.startEmptyInvalid before a job is queued. No file on disk is touched: the next switch removes the files through the normal launch check. A retry of a folder that failed to start empty starts it empty again. Observed reds before the change (ProfileStartEmptyTests): An_empty_mods_start... Assert.Empty failed, Collection: [modA/info.xml]; An_empty_saves_start... Collection: [slot1.sav]; The_install_folder_can_never_start_empty and A_folder_the_game_does_not_have... Assert.False failed, Actual: True; The_row_of_a_profile_with_no_mods... Expected 0, Actual 1; the retry test Collection: [modA/info.xml]. Two guard tests passed on first run and were mutation-checked (deleting the folder after the empty start fails the no-disk-change test; not attaching an unborn HEAD fails the first-profile test). (#206)
LinkedFileException and SnapshotHasLinksException took their name argument from Path.GetFileName, which on Linux and macOS does not split on a backslash. The errors are only raised for Windows paths, but their arguments are built, logged and copied everywhere, so a Windows path came through whole as the name. A small internal helper now takes the last segment after either separator.

Observed red (Linux VM, ErrorTypesTests.Exception_reports_its_message_id_and_args, cases LinkedFile and SnapshotHasLinks): Assert.Equal Values differ, Expected: Cool Mod.esp, Actual: C:\Games\Alpha\Mods\Cool Mod.esp. The red cannot show on Windows, where GetFileName already splits both ways.
The combined check ran before any capture, so a folder that could not fit alone made every folder fail with the combined figure and the saves were not snapshotted, it left out folders marked left-at-launch that a save still writes as a first history, it listed and sized every folder a second time, it added no steps to the job's details when it refused, and an unreadable folder's error escaped as an unknown failure with no per-folder result.

Each capture now reports the bytes it would add, with its own room already found, to a CaptureRoomGate through CaptureRequest.BeforeWriting, right before it stores anything. The gate waits until every folder has reported or dropped out (nothing to write, left alone, refused alone, failed), then asks the volume once about the folders that reported. A folder that cannot fit alone drops out and is refused with its own figures while the others are saved and remembered for the retry; only folders that all fit alone but not together are refused together, each with the combined figures. A left-alone folder drops out by itself, so no prediction of what a capture will skip is needed. The runner's estimate pass and the engine's EstimateCaptureBytesAsync are gone, so no folder is listed twice, and a refusal now shows the usual steps.

Observed reds: ProfilesCaptureTests.A_folder_that_cannot_fit_alone_is_refused_with_its_own_figures_while_the_other_is_saved_and_a_retry_joins_the_same_snapshot failed with Assert.Equal() Failure, Expected: 601000 Actual: 801000. ProfilesCaptureTests.A_save_refused_for_room_says_in_its_details_what_it_tried_and_which_folders_failed failed with Assert.Contains() Failure: Filter not matched in collection (Collection: []). LaunchLeftFolderTests.A_left_folder_that_the_save_writes_as_a_first_history_counts_with_the_other_folders_for_the_room failed with Assert.All() Failure: 2 out of 2 items did not pass (error.diskSpace.low expected, actual null). Against the batch code on Windows, LaunchCompletionFailureTests.A_save_after_play_that_fails_in_every_folder_ends_the_session_with_the_error failed with Assert.IsType() Failure: Value is null, Expected CaptureResult, and CaptureResultPublishTests.A_capture_ends_as_soon_as_its_points_are_written_even_while_an_optimization_waits_on_the_same_game failed with "the capture never reached the engine"; both pass now (the second test also counts a question asked from the gate as the capture's).
Mutation checks: reporting one byte too many, dropping the empty-folder report, counting dropped-out folders, judging at a count of 3 and not judging on a drop-out each made the new tests fail.
Timing of a first snapshot of a generated 20,000-file install folder plus a saves folder (30 MB): before 48.6, 46.9 and 47.0 s, after 53.0, 51.7 and 46.3 s (the first two after runs coincided with other load); the extra listing pass that is gone cost 86 ms.
The longer footer note (what Activity keeps, five per game for up to 30 days) wraps to a second line beside the navigation at 150% on a 1366x768 screen, which left the task list 93 px to scroll in, under the 96 px the scaled-window audit requires. The list pane now keeps 10 px above and below its list instead of 14, which gives it back 8 px; the wording is unchanged.

Observed red: AppStateAuditTests.Every_state_passes_the_naming_target_size_and_scaled_window_audits for activity-jobs and activity-failed, "[150% on 1366x768, 910x432] ScrollViewer #PART_ScrollViewer [] has more to show but only 93 px to show it in". With the old one-line footer wording both passed, so the footer wrap is the cause.
A duplicate, a wizard-made profile or one brought back from History that the typed search does not match never appeared while other rows still matched. ApplyRows now clears the profile search (silently) when a profile id is new, as the games list does with RevealGame.

Observed reds: GamesProfileSearchTests.A_duplicate_the_search_would_hide_clears_the_search_so_it_shows, A_profile_made_with_the_wizard_that_the_search_would_hide_clears_the_search_so_it_shows and A_profile_brought_back_from_history_that_the_search_would_hide_clears_the_search_so_it_shows all failed with Assert.Equal() Failure: Expected "" Actual "modded". A_reload_that_adds_nothing_keeps_the_search passed first; mutation (clear on every reload) made it fail.
Rebuild fell back to the first game of the whole library, which a typed search may hide, leaving nothing marked in the list. It now prefers the first game the search lists and keeps the old fallback when the search lists none.

Observed red: ShellGameSearchTests.Removing_the_selected_game_selects_the_first_game_the_search_lists failed with Assert.Equal() Failure: Expected The Last Caretaker row, Actual Satisfactory row. Removing_the_selected_game_with_nothing_typed_selects_the_first_game passed first; mutation (last instead of first) made it fail.
The first step shows a box per folder the game has (saves, mods outside the install) and passes the choice to CreateAsync as startEmpty. The preview rows say which folders start with nothing, on both steps. The fake supports the option, refuses what the real backend refuses and shows 0 mod files for an empty mods start. The launch dialog needed no change: a target with no mods already reads 'Going from N mod files to no mods' with the size removed, and the saves caption says the saves folder is replaced; tests pin both. Observed reds before the wiring (NewProfileWizardStartEmptyTests): Ticking_no_mods... Expected [Mods], Actual []; Ticking_no_saves... Expected [External], Actual []; Ticking_both... Expected 2, Actual 0; preview test Expected 'Saves', Actual 'Current saves'; the fake row test Expected 0, Actual null. The view and launch dialog tests passed on first run (view written with the XAML, dialog behavior already existed); mutation checks: binding the mods choice to true and renaming the saves box failed two view tests. (#206)
Timeline, Saves and Groups were rebuilt as new lists with new group objects on every keystroke. They are now ObservableCollections synced with ListSync, the two age groups last as long as the points they were built for, and the timeline's last-entry flag is a property that changes in place, so a keystroke only adds and removes what stops or starts matching and a focused card keeps its focus.

Observed reds: HistorySearchTests.Typing_keeps_the_groups_cards_and_saves_that_still_match_as_the_same_objects (Assert.All failure: group Earlier not among the groups before), A_group_that_empties_and_fills_again_comes_back_as_the_same_group (Assert.Same: values are not the same instance), Typing_keeps_the_timeline_entries_that_still_match_and_moves_the_rails_end_without_replacing_them (Assert.All failure: rebuilt last entry not among the entries before).
# Conflicts:
#	src/Savepoint.Core/Services/Profiles/CaptureRunner.cs
The typing pause and the count announcement could still fire after the screen was let go. Dispose now ends both and cancels the read in flight. The shell does not dispose its screens today; that is reported separately.

Observed reds: HistorySearchTests.A_screen_that_is_let_go_does_not_narrow_its_list_when_a_typing_pause_ends (Assert.Equal expected 308 actual 1) and A_screen_that_is_let_go_says_no_count_when_the_announcement_pause_ends (Assert.Equal expected empty, actual "3 of 8 snapshots"), run against an empty Dispose.
The judging step of CaptureRoomGate caught only Savepoint, IO and access exceptions, so any other exception left the verdict unset: folders waiting on it hung until the user cancelled, holding the game lock. It now catches every exception and gives it to the waiting folders as the verdict.

When every folder's wait had already been cancelled, the failed verdict (a DiskSpaceException) had no reader and surfaced as an unobserved task exception. The gate now reads a failed verdict itself.

CaptureRunner announced a folder before the try whose finally drops the folder out of the gate; the announcement is now inside it, so no throw can skip DropOut. No test: no seam makes AddStep throw.

Observed reds:
- CaptureRoomGateTests.An_unexpected_failure_while_judging_fails_every_waiting_folder_instead_of_leaving_them_waiting: Expected FormatException, Actual TimeoutException (waiters hung 5s).
- CaptureRoomGateTests.A_save_stopped_before_the_verdict_leaves_no_unobserved_failure_behind: Assert.DoesNotContain() Failure: Filter matched in collection (unobserved DiskSpaceException).
The profile search box scrolls away with the table, so a player scrolled down saw a smaller table with no sign a filter was on. The table header now carries a short line such as "1 of 3 profiles" while a search narrows the table, from the existing search.profiles.count message. The shelf search box no longer stretches across the whole window (max width 420).

Observed reds: GamesProfileSearchTests.While_a_search_narrows_the_table_a_line_says_how_many_profiles_it_shows (Assert.True failure) and The_count_line_follows_the_search_as_it_changes (Item not found: ProfileCountText), both against stubbed properties; GamesProfileSearchViewTests.While_a_search_narrows_the_table_its_header_says_how_many_profiles_show (Assert.NotNull failure: Value is null); ShellGameSearchViewTests.The_shelf_search_does_not_stretch_across_a_wide_window (Assert.InRange 140-420, actual 1170). The_count_line_gives_way_to_the_no_match_line_when_nothing_matches passed against the stub; mutation (drop ShowRows from the gate) made it fail.
Install wording no longer claims the mods on a game that has a mods folder.
The partial-save card, kept-as-new, left-alone, retry label, row label and
banner check read "game version" when the game has a mods folder and keep
"game version and mods" when it does not (a hasMods select).

Also: the version card says the mods change when only the mods folder
differs at the same file count; pathsNested reads right for a two-folder
game; the always-on mods strip becomes a "Where do my mods live?" question
button; each Common locations pill set names its own field for screen
readers; the editor tab order is pinned through the mods section; a stale
comment and a missing space in editor.json are fixed.

Observed reds (assertion failures):
- LaunchFlowModsFolderTests.A_save_that_took_the_game_and_saves_folders_but_not_the_mods...:
  expected "Your game version is in the snapshot..." got "Your game version and mods are in the snapshot..."
- LaunchFlowModsFolderTests.The_banner_checks_list_the_mods_folder...:
  expected "Game version: already on 1.6.640..." got "Game version and mods: already on..."
- LaunchFlowModsFolderTests kept-as-new, left-alone, retry label cases: same shape.
- LaunchDialogModsFolderTests.A_mods_change_that_keeps_the_version_and_the_file_count...
  (feature disabled): expected ". The files in your mods folder change." got ". About 3.1 GB of files will be replaced..."
- GameEditorModsFolderTests.The_mods_field_has_a_question_button...: expected "Where do my mods live?" got "Stub".
- GameEditorModsFolderTests.A_mods_folder_inside_the_saves_folder...: expected the new pathsNested text, got the old one.
- GameEditorModsFolderViewTests pill names: expected "Documents, for the mods folder", got "" (binding removed).
- GameEditorModsFolderViewTests question button: No HelpQuestionView named ModsQuestion (name removed).
- TabOrderTests mods section (Browse button made a non-stop): expected "Browse for the mods folder", got "Documents, for the mods folder".
- LaunchDialogModsFolderTests.A_version_that_stays_with_mods_that_already_match...
  mutation (modsChange = Mods is not null): "The files in your mods folder change" found.
The tour is not a dialog, so the search shortcut pulled focus out from behind it. MainView now skips the shortcut while the tour shows; inside a text field on a pane it still goes to the search.

Observed red: ShellGameSearchViewTests.Ctrl_F_does_nothing_while_the_tour_runs_and_works_again_once_it_ends failed with Assert.Same() Failure: expected the focused Border, actual the profile search TextBox.
A new profile that starts the saves or mods folder empty left the folder's files in place as new changes, and the launch then offered to discard them. On a game's first profile, or for a folder with new changes since its profile, that was the only copy of the player's files.

Core now allows an empty start for a folder only when it sits on a profile's branch with no new changes (StartEmptyRule). CreateAsync refuses before queuing a job; the save checks again under the game's lock, so a retry of a folder that failed to start empty is refused too. The capture preview carries HeldInSnapshot per folder so the wizard can offer the box. SwitchSummary carries FilesRemoved from the switch diff.

Observed reds (ProfileStartEmptySafetyTests): first profile, new file, changed file, mods folder added later, retry after the folder gained a file: each "Assert.False() Failure, Expected False, Actual True" on the refused result (the profile was created); preview: HeldInSnapshot expected True, was False. ProfileStartEmptyTests switching tests: FilesRemoved expected 1, actual 0. The test that pinned the unsafe first-profile behavior is removed.
The wizard turns "Start with no saves" and "Start with no mods" off unless the capture preview says the folder's files are already in a snapshot. An off box shows "Take a snapshot first, so your current saves are kept." (mods likewise) as its visible hint and as its help text for screen readers, and never asks Core for an empty start even when set. The fake backend refuses the same way Core does.

The launch dialog's saves section gains "N files will be removed from your saves folder." from SwitchSummary.FilesRemoved.

Observed reds: NewProfileWizardStartEmptyTests (box reported on before the preview, hint was the normal text, Create still asked for an empty start for a folder no snapshot holds, fake accepted it): "Expected: False, Actual: True" and an unchanged hint; NewProfileWizardStartEmptyViewTests box switched off: IsEnabled "Expected: False, Actual: True"; LaunchDialogEmptyFolderTests: SavesRemovedText "Expected: 3 files will be removed from your saves folder., Actual: (empty)" and HasSavesRemoved "Expected: True, Actual: False". Mutation check: forcing CanStartWithoutSaves to false failed four wizard tests.
A template can name a mods folder the player never made (a player with no
mods). Adding the game then failed with "can't find the mods folder anymore"
on a game with no snapshots, while a library add already leaves the folder
out. The editor now asks the new IGamesApi.FolderExistsAsync after a template
fills the mods field (and when it opens on a template draft), leaves the field
empty when the folder is missing, and shows a note saying it can be added in
Edit game once there are mods.

The contract story gains a three-folder game so the fake and the real backend
are compared for the mods folder: add, folder status, first snapshot of all
three folders, and the new folder check. The one place the fake is simpler
(the real backend refuses to add a game whose mods folder is missing) is
pinned in the gaps test.

Observed reds (assertion failures):
- BackendContractTests.The_real_backend_tells_the_same_first_run_story_as_the_fake
  (real check stubbed true): fake "a mods folder that is not there yet: exists=False",
  real "exists=True".
- GameEditorModsFolderTests.Choosing_a_template_whose_mods_folder_does_not_exist_yet...:
  expected "" got "{appData}\7DaysToDie\Mods"; same for the opens-on-a-template case.
- GameEditorModsFolderViewTests note line: No Grid named ModsLeftOutLine.
- Mutations: dropping the clear in OnModsPathChanged fails
  Typing_a_mods_folder_takes_the_left_out_note_away; treating any template mods
  path as filled fails A_mods_folder_the_player_typed_stays_when_a_template_is_chosen...
# Conflicts:
#	src/Savepoint.Core/Services/Profiles/CaptureRunner.cs
Reword nineteen catalog entries (wizard start-empty hints, link and
unfinished-switch messages, activity footer and help, retry labels and
the like) in plain words, and update the tests that pin the old text.
Retry labels, the scale option name, the link-snapshot card and the
footer assertions changed with them.
The new profile wizard's partial-snapshot card, retry label, outcome rows and
first-snapshot preview named the game folder 'game version and mods' even when
the game keeps its mods in a folder of its own. They now pass whether the game
has a mods folder, as the launch flow does.

Observed red (NewProfileWizardModsFolderTests):
- The_preview_lists_the_game_the_mods_and_the_saves_folders...: Expected
  'Game version' Actual 'Game version and mods'
- A_snapshot_that_took_the_game_and_saves_but_not_the_mods...: StartsWith
  failure, body still said 'Your game version and mods are in the snapshot'
- A_snapshot_that_missed_the_game_folder_of_a_three_folder_game...: StartsWith
  failure on 'Your mods are in the snapshot. Your saves are in the snapshot.
  Your game version isn't yet.'
Observed red (gate log, Linux and Windows): AppearanceUiScaleTests.A_size_the_screen_has_no_room_for_is_switched_off_with_the_reason failed with Expected "175%, Your screen is too small for this size." Actual "175%. Your screen is too small for this size." The catalog's settings.scale.unavailableName reads "{size}. {reason}" on purpose; the test carried the old comma.
Observed red (gate log): LaunchUnfinishedSwitchFlowTests.A_switch_again_refused_for_changes_in_its_way_is_reviewed_with_discarding_as_the_only_way_out failed with Assert.Contains() Failure: Sub-string not found; the body now says "not in any snapshot" instead of "not saved".

Observed red (Linux gate log): GameEditorModsFolderTests.Choosing_a_template_fills_the_mods_field_and_choosing_another_without_one_clears_what_the_first_put_there expected {appData}\7DaysToDie\Mods and got empty; ...Choosing_a_template_whose_mods_folder_does_not_exist_yet_leaves_the_mods_field_empty_and_says_why expected {appData}\7DaysToDie\Saves and got empty. A template draft takes savesByOs/modsByOs on Linux and nothing from the Windows default, and the test template named no per-system folders. The test template now names the same folders for all three systems. The product is right: the real 7 Days to Die template names {userHome}/.local/share/7DaysToDie/Mods for Linux.
Observed red (Windows, re-run here; Linux gate log): all six BackendContractTests failed because the ContractRuns fixture threw System.TimeoutException: The switch never reached the folder it was to be stopped at. The hold skipped a fixed number of free-space questions for the install folder, and how many a launch asks depends on how the folders share drives. The hold now fires on the first question asked once the job reports that it is switching the install folder, the way the launch rig's HoldInstallSwitch does. All six pass on Windows.
Observed red (Windows gate): CaptureBatchesTests.A_link_is_planned_by_its_own_size_not_the_size_of_what_it_points_to threw LinkedFileException because a capture on Windows refuses a file link on purpose. The refusal is covered by LinkedFileTests.The_capture_candidates_refuse_a_file_link_too. The skip is a required line in expected-skips/windows.txt.
AGENTS.md says Windows gates share a lock and the VM gate has its own; D27's heading says it is retired; the developer guide says which package scripts refuse a dirty tree; the standards no longer point at removed known-violation lists; the user guide lists Open mods folder and does not promise a mods file count.
A stopped switch with an unreadable note offers only Discard, so Discard must never be refused for a link. It now restores every entry of the point except link entries (mode 120000), writes no text stub and touches nothing that stands at a link's path. A switch to such a snapshot is still refused.

Observed reds before the change (all three failed with SnapshotHasLinksException thrown by the discard instead of completing):
- A_discard_restores_the_other_files_and_does_not_write_a_text_file_where_the_point_holds_a_link
- A_discard_leaves_a_changed_file_standing_where_the_point_holds_a_link
- A_discard_of_a_stopped_switch_with_an_unreadable_note_gets_past_a_link_and_clears_the_note
The launch check now carries SwitchSummary.LeavesFolderEmpty (the switch removes files and the target holds none of the folder's), and the launch flow never skips its dialog for such a switch, so the dialog's removed-files line is shown.

Observed reds before the change:
- LaunchFlowBeginTests.A_switch_that_leaves_the_saves_folder_empty_asks_even_when_the_preference_is_on: Assert.Single() Failure: The collection was empty (the game started with no dialog).
- ProfileStartEmptyTests.Switching_to_a_profile_with_no_saves_empties_the_saves_folder_through_the_launch: the new LeavesFolderEmpty assertion failed once the flag was computed wrongly (mutation check).
The negative test (some saves removed, others stay, skip still applies) passed on its first run; it holds because the dialog is skipped only when the flag is false.
The capture preview now says why a folder cannot start empty (first profile, new or changed files, stopped switch or unreadable folder, other). The wizard words the reason by cause instead of always saying 'Take a snapshot first', and the reason text is a focus stop with a name of box plus reason while the box is off, since a switched-off checkbox takes no focus.

Observed reds before the change:
- ProfileStartEmptySafetyTests.The_preview_names_why_a_folder_cannot_start_empty: Expected FirstProfile, Actual None.
- ProfileStartEmptySafetyTests.The_preview_blames_a_stopped_switch_when_the_note_of_one_cannot_be_read: Expected StoppedSwitch, Actual None.
- NewProfileWizardStartEmptyTests (first profile, stopped switch, other, new changes, reason name): the hint still read 'Take a snapshot first, so your current saves are kept.' and the reason name was empty.
- NewProfileWizardStartEmptyViewTests.Tab_stops_on_the_reason_of_a_switched_off_box_and_a_screen_reader_hears_the_box_and_why: Tab from the notes field landed on a Button, not the reason.
The 'box is on' tests passed on first run; a mutation (box counted as off while on) made them fail.
The size choice no longer wraps from the last size it can reach to the first, so one arrow key at the largest fitting size cannot shrink the window. A switched-off size takes no focus, so the choice itself carries help text naming the sizes that are off and why.

Observed reds before the change:
- ChoiceListSemanticsTests.The_size_choice_stays_on_the_smallest_size_when_Left_is_pressed_there_and_still_steps_forward: Expected 0, Actual 4.
- ChoiceListSemanticsTests.The_size_choice_stays_on_the_last_size_it_can_reach_instead_of_wrapping_to_the_first: Expected 2, Actual 1.
- AppearanceUiScaleTests.The_group_help_names_every_size_that_is_off_and_why_...: Expected the help sentence, Actual empty string.
The group-help assertion in MainWindowSmallScreenTests passed on its first run because the binding was added with the property.
The snapshot-holds-links message now tells a mod manager player to switch to another profile and deploy the mods again. The game-wide leave-out list, its add button, the rules help, and the linked-file message no longer say 'both folders', which was wrong for a game with a mods folder.

Observed reds before the change:
- ErrorCardViewModelTests.A_snapshot_with_a_link_card_tells_a_mod_manager_player_to_deploy_the_mods_again_after_switching_away: body lacked the redeploy sentence.
- ErrorCardViewModelTests.A_file_link_card_reads_right_for_a_link_made_by_hand_and_offers_the_leave_out_list: body said "Files to leave out" without 'of every folder'.
- GameEditorFormTests.Each_list_has_its_own_add_name_help_text_and_remove_names and Both_lists_say_which_folders_they_reach: label read 'both folders'.
Expect the start-empty reason as a tab stop in the wizard's order (D65.2)
All checks were successful
Docs / site (push) Successful in 1m29s
Release / checksums (push) Successful in 37s
Release / linux (push) Successful in 2m23s
Docs / site (pull_request) Successful in 1m31s
Gate / windows (pull_request) Successful in 43m42s
Gate / linux (pull_request) Successful in 19m10s
Release / windows (push) Successful in 3m5s
386a916036
Sign in to join this conversation.
No reviewers
No milestone
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
ethan-hann/SavePoint!227
No description provided.