Release v0.6.39: isolate history UI and image clipboard memory

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.24)
-project(KSwitcher VERSION 0.6.38 LANGUAGES CXX RC)
+project(KSwitcher VERSION 0.6.39 LANGUAGES CXX RC)
 if(NOT WIN32)
   message(FATAL_ERROR "KSwitcher uses native Windows APIs")
 endif()
@@ -66,6 +66,29 @@ else()
   target_link_options(KSwitcherOcrTests PRIVATE -static -static-libgcc -static-libstdc++)
 endif()
 enable_testing()
+add_executable(KSwitcherHistoryHostTests tests/history_host.cpp)
+target_link_libraries(KSwitcherHistoryHostTests PRIVATE kscore psapi)
+set_target_properties(KSwitcherHistoryHostTests PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/history-host-fixture-$<CONFIG>")
+add_dependencies(KSwitcherHistoryHostTests KSwitcher KSwitcherScreenshot)
+add_custom_command(TARGET KSwitcherHistoryHostTests POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:KSwitcher>" "$<TARGET_FILE_DIR:KSwitcherHistoryHostTests>/KSwitcher.exe"
+  COMMAND ${CMAKE_COMMAND} -E copy "$<TARGET_FILE:KSwitcherScreenshot>" "$<TARGET_FILE_DIR:KSwitcherHistoryHostTests>/KSwitcher.Screenshot.exe"
+  COMMAND ${CMAKE_COMMAND} -E touch "$<TARGET_FILE_DIR:KSwitcherHistoryHostTests>/.local-dev")
+if(MSVC)
+  target_compile_options(KSwitcherHistoryHostTests PRIVATE /utf-8)
+  set_property(TARGET KSwitcherHistoryHostTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+else()
+  target_link_options(KSwitcherHistoryHostTests PRIVATE -static -static-libgcc -static-libstdc++)
+endif()
+add_executable(KSwitcherClipboardSnapshotTests tests/clipboard_snapshot.cpp)
+target_link_libraries(KSwitcherClipboardSnapshotTests PRIVATE kscore psapi)
+add_dependencies(KSwitcherClipboardSnapshotTests KSwitcherScreenshot)
+if(MSVC)
+  target_compile_options(KSwitcherClipboardSnapshotTests PRIVATE /utf-8)
+  set_property(TARGET KSwitcherClipboardSnapshotTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+else()
+  target_link_options(KSwitcherClipboardSnapshotTests PRIVATE -static -static-libgcc -static-libstdc++)
+endif()
 add_executable(KSwitcherImageCaptureTests tests/image_capture.cpp)
 target_link_libraries(KSwitcherImageCaptureTests PRIVATE kscore)
 add_dependencies(KSwitcherImageCaptureTests KSwitcherScreenshot)

README.md

@@ -720,8 +720,10 @@ Consecutive duplicates use SHA-256 fingerprints inside the encrypted history ind
 
 Moving OCR isolates its temporary memory rather than reducing the combined processing peak. A controlled three-run comparison retained about 0.8 MiB less private RAM in the caller after recognition; combined peak RAM was about 55.6 MiB before and 56.6 MiB with the helper. Results depend on the image, OCR engine and system.
 
-### History previews and Escape — v0.6.38
+### History process and clipboard memory — v0.6.39
 
-History initializes RichEdit only for HTML/RTF previews. Plain text keeps Unicode and line breaks without RTF conversion; empty history and image-only previews do not load RichEdit unnecessarily. Plain and formatted text previews share the existing bounded text-preview cache.
+History opens in a separate, short-lived instance of **KSwitcher.exe**. **Esc** closes it even when focus is on the window or an action button, releasing Windows UI allocations with the process. The resident keeps keyboard hooks, clipboard capture and history storage. Search, selection and the top entry are preserved in encrypted view state. If a full-text item viewer is still open, the helper stays alive until the last viewer closes. Pin/delete, formatted/plain paste and OCR remain available; settings and default shortcuts are unchanged.
 
-Esc clears hidden rows/caches and cancels obsolete queued preview work, while retaining the selected/top entry for reopening. Already-needed RichEdit controls are cleared and reused. Clipboard contents, paste formatting, OCR, settings and shortcuts are unchanged. A local isolated comparison saved approximately 0.48–0.72 MiB private working set after Esc depending on content; this is not a fixed application footprint or a guarantee that all UI memory returns to the startup level.
+Image thumbnails are decoded in **KSwitcher.Screenshot.exe**, returning only bounded preview pixels. Image clipboard backup/restore also uses that helper and encrypted temporary files, with clipboard-sequence checks before restoring. Selection reads avoid loading image formats. Keep all three executables together; no fourth executable is required. Paste allows a brief foreground handoff after history closes while preserving cancellation checks. UI Automation remains in the resident.
+
+A live development-build test measured **4.37 MiB before history and 4.35 MiB after two open/Esc cycles**, compared with an earlier roughly 8–9 MiB plateau. A same-image clipboard-backup benchmark retained **12.78 MiB before versus 0.05 MiB after**. These measure private working set, not a guaranteed total footprint. Include all helpers when measuring active use: combined memory can be higher while history is open. No forced working-set trimming is used. Existing screenshots and shortcuts remain applicable. The v0.6.38 approach of retaining a hidden history window/RichEdit control is superseded by process termination.

Release/README.md

@@ -1,22 +1,22 @@
 # Latest Windows release
 
-## v0.6.38 — 2026-11-04
+## v0.6.39 — 2026-11-04
 
 ## Changes
-- Clipboard history loads RichEdit only when an HTML/RTF preview actually needs it. Empty history, plain text and image-only previews no longer initialize it unnecessarily.
+- Clipboard history runs in a separate, short-lived instance of KSwitcher.exe. Closing history with Esc releases its UI process instead of retaining Windows UI allocations in the resident. Esc also works when the window itself or an action button has focus.
-- Plain text previews retain Unicode and line breaks without converting the text to RTF. Plain and formatted preview payloads share the existing bounded text-preview cache.
+- Search, selected/top entry, pinning, deletion, formatted/plain paste and OCR remain available. Search and selection are saved in encrypted view state. An open full-text viewer keeps the history process alive until that viewer closes.
-- Esc still clears hidden history rows and preview caches while preserving the remembered selection/top item. Closing or replacing a search now cancels obsolete preview work before loading/decoding where possible, and discards completed stale results.
+- Large image clipboard backups and image thumbnail decoding run in KSwitcher.Screenshot.exe. Encrypted temporary files and clipboard-sequence checks preserve the clipboard without keeping full backup images in the resident. Selection reads avoid unnecessary image copies.
-- A RichEdit control that was needed for formatted text is cleared and reused, not repeatedly destroyed/recreated. This avoids additional initialization on reopening. Settings, shortcuts, stored clipboard contents, formatting on paste and OCR behavior are unchanged.
+- History paste waits briefly for the target application's foreground activation after the history process closes, while retaining input and clipboard ownership checks. Settings and default shortcuts are unchanged; UI Automation remains in the resident.
 
-## Validation
+## Validation and memory
-Staged build and tests cover dictionary equivalence for 140,939 words, 105 sync checks, wheel batching, 315 native checks, 561 input checks, screenshot UI/PNG/notification registration, 48 updater checks and updater progress UI. Added checks for plain previews without RichEdit, retained HTML rendering, lazy control creation and cleanup through Esc. Isolated real-window tests also verified formatted previews after reopening.
+The complete staged build passed dictionary equivalence (140,939 words), 105 sync checks, 315 native checks, 561 input checks, screenshot UI/save/registration, 48 updater checks and progress UI, clipboard snapshot/image capture integration, conversion/snippet integration and Windows OCR. Dedicated 500-entry history tests cover repeated Esc, search persistence, pin/delete, full-viewer lifetime, text/image paste, clipboard restoration, rejected foreign requests and helper shutdown. Actual selected/repeated Viber conversion and live Esc were also checked during development.
 
-A controlled local comparison measured 0.72 MiB less private working set after Esc for empty history, 0.66 MiB for plain text, 0.48 MiB for formatted text and 0.53 MiB for images. These are isolated test-process comparisons, not the application's total RAM or a guaranteed reduction on another computer. The reported 7 MiB plateau on a different laptop was not reproduced. No working-set trimming was used; closing the history window does not promise an exact return to startup memory.
+A local live development-build comparison measured **4.37 MiB before opening history and 4.35 MiB after two open/Esc cycles**, versus an earlier roughly 8–9 MiB plateau after closing history. A same-image backup benchmark reduced retained private resident memory from 12.78 MiB to 0.05 MiB. These are workload-specific observations, not a guaranteed footprint. Count all helper processes while history/OCR is active: combined active memory can be higher. No forced working-set trimming was used.
 
 ## Upgrade
 Choose **Update** in the tray menu. Legacy v0.3.0–v0.4.1 clients first receive the v0.4.2 compatibility bridge, then the current full release. v0.2.3 and earlier require manual installation.
 For manual installation, exit KSwitcher, close screenshot editors and extract the entire ZIP into its installation folder. Keep personal `data/` and customized dictionaries.
 
-Download **KSwitcher-win-x64.zip** with **SHA256SUMS.txt**. Keep all three executables together. The package contains no personal settings, credentials or clipboard history.
+Download **KSwitcher-win-x64.zip** with **SHA256SUMS.txt**. Keep all three executables together; history uses another instance of KSwitcher.exe, so no fourth executable is required. The package contains no personal settings, credentials or clipboard history.
 
 Publish stable `release-vX.Y.Z` tags matching the executable version. Keep `v0.4.2` as the last legacy tag.

Release/SHA256SUMS.txt

@@ -1 +1 @@
-f430767d440581018e6adb33c153fb332318fa1eee5a162ddf32690d0b5a3391  KSwitcher-win-x64.zip
+bf3a0fed23ea73dd8422b63fe2f2724e5b02e70c4c66f014c7ebb59222aa91fb  KSwitcher-win-x64.zip

build.ps1

@@ -81,6 +81,20 @@ try {
         if ($LASTEXITCODE) { throw 'Updater progress UI tests failed' }
     }
     if ($Integration) {
+        $historyFixture = Join-Path (Resolve-Path build) ('history-host-fixture-' + [guid]::NewGuid().ToString('N'))
+        New-Item -ItemType Directory $historyFixture | Out-Null
+        Copy-Item $executablePath,(Join-Path (Split-Path $executablePath) 'KSwitcher.Screenshot.exe') -Destination $historyFixture
+        Set-Content (Join-Path $historyFixture '.local-dev') 'Isolated history integration test'
+        $historyTest = Join-Path $historyFixture 'KSwitcherHistoryHostTests.exe'
+        & $compiler @common tests/history_host.cpp build/core.o build/platform.o build/storage.o build/ocr.o @libs -lpsapi -static -s -o $historyTest
+        if ($LASTEXITCODE) { throw 'History host test build failed' }
+        & $historyTest
+        if ($LASTEXITCODE) { throw 'History host tests failed' }
+        $snapshotTest = Join-Path (Split-Path $executablePath) 'KSwitcherClipboardSnapshotTests.exe'
+        & $compiler @common tests/clipboard_snapshot.cpp build/core.o build/platform.o build/storage.o build/ocr.o @libs -lpsapi -static -s -o $snapshotTest
+        if ($LASTEXITCODE) { throw 'Clipboard snapshot test build failed' }
+        & $snapshotTest
+        if ($LASTEXITCODE) { throw 'Clipboard snapshot tests failed' }
         $captureTest = Join-Path (Split-Path $executablePath) 'KSwitcherImageCaptureTests.exe'
         & $compiler @common tests/image_capture.cpp build/core.o build/platform.o build/storage.o build/ocr.o @libs -static -s -o $captureTest
         if ($LASTEXITCODE) { throw 'Image capture test build failed' }

src/app.cpp

@@ -15,6 +15,7 @@ namespace ks
 {
 #include "app_sync.inl"
 App *App::current = nullptr;
+#include "app_history.inl"
 namespace
 {
 const char *transformCommandName(int command)
@@ -71,7 +72,7 @@ class Transaction
     App &app;
     HWND target;
     uint64_t version;
-    Clip snapshot;
+    ClipboardSnapshot snapshot;
     DWORD expected{};
     bool captured{};
     mutable bool invalidLogged{};
@@ -87,7 +88,7 @@ class Transaction
         try
         {
             expected = GetClipboardSequenceNumber();
-            snapshot = readClipboard(app.window, 64 * 1024 * 1024);
+            snapshot.capture(app.window, expected);
             if (expected != GetClipboardSequenceNumber())
                 throw std::runtime_error("Clipboard changed while taking snapshot");
             captured = true;
@@ -103,7 +104,7 @@ class Transaction
         if (captured && GetClipboardSequenceNumber() == expected)
             try
             {
-                app.ownSequence = writeClipboard(app.window, snapshot);
+                app.ownSequence = snapshot.restore(app.window, expected);
             }
             catch (...)
             {
@@ -131,7 +132,7 @@ class Transaction
         if (GetClipboardSequenceNumber() != expected)
         {
             auto now = GetClipboardSequenceNumber();
-            if (adopted.empty() || !ownsClipboard(target) || readClipboard(app.window).text() != adopted ||
+            if (adopted.empty() || !ownsClipboard(target) || readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection).text() != adopted ||
                 GetClipboardSequenceNumber() != now)
                 throw std::runtime_error("Operation cancelled: another application changed the clipboard");
             expected = now;
@@ -153,7 +154,7 @@ class Transaction
         if (GetClipboardOwner() != app.window)
             throw std::runtime_error("Clipboard changed immediately after writing");
         auto text = c.text();
-        if ((!text.empty() && readClipboard(app.window).text() != text) ||
+        if ((!text.empty() && readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection).text() != text) ||
             GetClipboardSequenceNumber() != expected)
             throw std::runtime_error("Clipboard changed while verifying our write");
     }
@@ -227,7 +228,7 @@ class Transaction
             changed != GetClipboardSequenceNumber())
             throw std::runtime_error("Operation cancelled: copy did not belong to the target application");
         expected = changed;
-        auto clip = readClipboard(app.window);
+        auto clip = readClipboard(app.window, 32 * 1024 * 1024, ClipboardRead::Selection);
         auto text = clip.text();
         diagnosticEvent(L"Copy result number=" + std::to_wstring(number) + L" attempts=" +
             std::to_wstring(attempts) + L" elapsedMs=" + std::to_wstring(GetTickCount64() - started) +
@@ -405,7 +406,8 @@ class Transaction
     }
 };
 } // namespace
-App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot) : instance(h), smoke(test)
+App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot, HWND service)
+    : historyService(service), instance(h), smoke(test)
 {
     updateNotifier = notifyUpdateAvailable;
     current = this;
@@ -422,7 +424,7 @@ App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot) : instan
         registrationWarning = L"Settings were not loaded: " + wide(e.what());
     }
     setLoggingEnabled(settings.writeLog);
-    if (settings.autoCorrect)
+    if (settings.autoCorrect && !historyService)
         try { autoPredictor.configure(std::filesystem::path(executable()).parent_path() / L"dictionaries", settings.autoLanguages); }
         catch (const std::exception &e)
         {
@@ -441,6 +443,8 @@ App::App(HINSTANCE h, bool test, const std::filesystem::path &dataRoot) : instan
 }
 App::~App()
 {
+    if (auto host = historyController(historyProcess)) PostMessageW(host, WM_CLOSE, 0, 0);
+    if (historyProcess) CloseHandle(historyProcess);
     if (notificationRegistration) CloseHandle(notificationRegistration);
     if (syncWorker.joinable()) syncWorker.join();
     if (updateWorker.joinable())
@@ -688,6 +692,7 @@ void App::reloadLayouts()
 }
 void App::clearHistory()
 {
+    if (historyService) { remoteHistory("clear"); history->reload(); return; }
     if (busy) throw std::runtime_error("Wait for the current operation to finish.");
     if (history) history->clear();
     if (historyWindow) refreshHistory(*this);
@@ -1523,6 +1528,7 @@ void App::transform(int command, int snippet)
 }
 void App::pasteEntry(std::wstring id, bool plain)
 {
+    if (historyService) { remoteHistory("paste", id, plain); return; }
     if (installingUpdate) return;
     if (!history || busy.exchange(true))
         return;
@@ -1544,10 +1550,20 @@ void App::pasteEntry(std::wstring id, bool plain)
             } reset{busy};
             try
             {
-                for (int i = 0; i < 20 && !modifiersReleased(); ++i)
+                // Foreground activation crosses a process boundary when the
+                // history UI closes. Let the destination finish activation,
+                // while retaining the same input-version cancellation guard.
+                for (int i = 0; i < 20 && inputVersion == version &&
+                     (!modifiersReleased() || GetForegroundWindow() != target); ++i)
                     Sleep(10);
                 if (!modifiersReleased() || GetForegroundWindow() != target || inputVersion != version)
+                {
+                    log(L"History paste cancelled before transaction: foreground=" +
+                        std::to_wstring(GetForegroundWindow() == target) + L" modifiers=" +
+                        std::to_wstring(modifiersReleased()) + L" expectedVersion=" + std::to_wstring(version) +
+                        L" actualVersion=" + std::to_wstring(inputVersion.load()));
                     return;
+                }
                 auto clip = history->load(id);
                 if (plain)
                 {
@@ -1557,7 +1573,7 @@ void App::pasteEntry(std::wstring id, bool plain)
                     clip = textClip(text);
                 }
                 Transaction tx(*this, target, version);
-                tx.paste(clip);
+                log(tx.paste(clip) ? L"History paste: simulated paste completed" : L"History paste cancelled before simulated paste");
             }
             catch (const std::exception &e)
             {
@@ -1599,7 +1615,8 @@ void App::captureHistory()
                     }
                     return;
                 }
-                auto clip = readClipboard(window, (size_t)config.maxImageMiB * 1024 * 1024);
+                auto clip = readClipboard(window, (size_t)config.maxImageMiB * 1024 * 1024,
+                                          ClipboardRead::WithoutImages, sequence);
                 if (sequence != GetClipboardSequenceNumber())
                     return;
                 for (auto &f : clip.formats)
@@ -1618,6 +1635,7 @@ void App::captureHistory()
 }
 void App::recognizeEntry(std::wstring id)
 {
+    if (historyService) { remoteHistory("ocr", id); return; }
     if (!history || busy.exchange(true))
         return;
     auto sequence = GetClipboardSequenceNumber();
@@ -1788,7 +1806,37 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
     auto *app = current;
     if (!app)
         return DefWindowProcW(hwnd, msg, wp, lp);
-    if (msg == app->taskbarCreated && app->taskbarCreated)
+    if (app->historyService) {
+        if (msg == HistoryHostShow || msg == HistoryHostRefresh) {
+            try {
+                app->history->reload();
+                if (msg == HistoryHostShow) showHistory(*app);
+                else if (IsWindowVisible(app->historyWindow)) refreshHistory(*app);
+            } catch (const std::exception &e) { app->report(wide(e.what())); }
+            return 0;
+        }
+        if (msg == WM_TIMER) {
+            if (!IsWindow(app->historyService)) PostMessageW(hwnd, WM_CLOSE, 0, 0);
+            return 0;
+        }
+        if (msg == WM_CLOSE) {
+            EnumThreadWindows(GetCurrentThreadId(), [](HWND child, LPARAM) -> BOOL {
+                wchar_t name[64]{}; GetClassNameW(child, name, 64);
+                if (std::wstring(name) == L"KSwitcher.Entry" || std::wstring(name) == L"KSwitcher.History")
+                    DestroyWindow(child);
+                return TRUE;
+            }, 0);
+            DestroyWindow(hwnd);
+            return 0;
+        }
+        if (msg == WM_DESTROY) { PostQuitMessage(0); return 0; }
+        if (msg == ErrorMessage) {
+            std::unique_ptr<std::wstring> text(reinterpret_cast<std::wstring *>(lp));
+            MessageBoxW(app->historyWindow, text->c_str(), L"Clipboard history", MB_OK | MB_ICONWARNING);
+            return 0;
+        }
+    }
+    if (!app->historyService && msg == app->taskbarCreated && app->taskbarCreated)
     {
         app->addTray();
         return 0;
@@ -1902,6 +1950,7 @@ LRESULT CALLBACK App::windowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
     case WM_COPYDATA:
     {
         auto *data = (COPYDATASTRUCT *)lp;
+        if (data && data->dwData == HistoryRequest) return app->historyRequest((HWND)wp, *data);
         if (data && data->dwData >= ConfigRead && data->dwData < ConfigEnd)
         {
             if (app->installingUpdate) return FALSE;
@@ -1988,7 +2037,7 @@ int App::execute()
     WNDCLASSW cls{};
     cls.hInstance = instance;
     cls.lpfnWndProc = windowProc;
-    cls.lpszClassName = L"KSwitcher.Main";
+    cls.lpszClassName = historyService ? HistoryHostClass : L"KSwitcher.Main";
     cls.hIcon = LoadIconW(instance, MAKEINTRESOURCEW(IDI_KSWITCHER));
     RegisterClassW(&cls);
     window = CreateWindowExW(WS_EX_TOOLWINDOW, cls.lpszClassName, L"KSwitcher", WS_POPUP, 0, 0, 0, 0, nullptr,
@@ -2022,6 +2071,29 @@ int App::execute()
             }
             CoUninitialize();
         });
+    if (historyService) {
+        try {
+            auto bytes = unprotect(readFile(data / L"history-view.bin", 4 * 1024 * 1024));
+            auto state = HistoryJson::parse(bytes);
+            historySelection = wide(state.value("selection", std::string{}));
+            historyTop = wide(state.value("top", std::string{}));
+            historyQuery = wide(state.value("query", std::string{}));
+        } catch (...) {}
+        showHistory(*this);
+        remoteHistory("ready", std::to_wstring(reinterpret_cast<uintptr_t>(historyWindow)));
+        SetTimer(window, 1, 1000, nullptr);
+        MSG message{};
+        while (GetMessageW(&message, nullptr, 0, 0) > 0) {
+            if (message.message == WM_KEYDOWN && message.wParam == VK_ESCAPE && historyWindow &&
+                (message.hwnd == historyWindow || IsChild(historyWindow, message.hwnd))) {
+                SendMessageW(historyWindow, WM_CLOSE, 0, 0);
+                continue;
+            }
+            if (historyWindow && message.message == WM_SYSCHAR && IsDialogMessageW(historyWindow, &message)) continue;
+            TranslateMessage(&message); DispatchMessageW(&message);
+        }
+        return int(message.wParam);
+    }
     keyboardHook = SetWindowsHookExW(WH_KEYBOARD_LL, keyProc, instance, 0);
     mouseHook = SetWindowsHookExW(WH_MOUSE_LL, mouseProc, instance, 0);
     registerHotkeys(settings);
@@ -2058,7 +2130,7 @@ int App::execute()
                 continue;
         }
         // Preserve history-specific Enter/Shift+Enter and Ctrl+digit handling.
-        if (historyWindow && msg.message == WM_SYSCHAR && IsDialogMessageW(historyWindow, &msg))
+        if (!isolateHistory && historyWindow && msg.message == WM_SYSCHAR && IsDialogMessageW(historyWindow, &msg))
             continue;
         if (settingsWindow && IsDialogMessageW(settingsWindow, &msg))
             continue;

src/app.h

@@ -33,6 +33,10 @@ class App
 {
   public:
     HWND window{}, historyWindow{}, settingsWindow{}, snippetsWindow{};
+    HWND historyService{}; // Non-null only in the short-lived history UI process.
+    bool isolateHistory{};
+    unsigned historyEntryWindows{};
+    std::wstring historySelection, historyTop, historyQuery;
     HINSTANCE instance{};
     std::filesystem::path data;
     std::vector<Layout> layouts;
@@ -55,7 +59,7 @@ class App
     bool smoke{};
     int startCommand{};
     std::wstring updateStartupEvent;
-    App(HINSTANCE, bool = false, const std::filesystem::path &dataRoot = {});
+    App(HINSTANCE, bool = false, const std::filesystem::path &dataRoot = {}, HWND historyService = nullptr);
     ~App();
     int execute();
     void dispatch(int);
@@ -72,6 +76,11 @@ class App
     void applySettings(const Settings &);
     void reloadLayouts();
     void clearHistory();
+    void openHistoryProcess();
+    void refreshHistoryProcess();
+    void remoteHistory(const char *action, const std::wstring &id = {}, bool plain = false);
+    LRESULT historyRequest(HWND, const COPYDATASTRUCT &);
+    void saveHistoryView(const std::wstring &, const std::wstring &, const std::wstring &);
     void clearLog(bool previous);
     void setHotkeyCapture(HWND);
     bool isHotkey(DWORD, UINT);
@@ -88,6 +97,7 @@ class App
     friend struct InputRegressionAccess;
     void releaseIdleMemory(ULONGLONG now);
     HHOOK keyboardHook{}, mouseHook{};
+    HANDLE historyProcess{};
     std::mutex jobsMutex;
     std::condition_variable jobsReady;
     std::deque<std::function<void()>> jobs;

src/app_history.inl

@@ -0,0 +1,100 @@
+// History UI has no clipboard listener or hooks. The resident remains the only writer.
+namespace {
+constexpr ULONG_PTR HistoryRequest = 0x4b530200;
+constexpr UINT HistoryHostShow = WM_APP + 71, HistoryHostRefresh = WM_APP + 72;
+constexpr wchar_t HistoryHostClass[] = L"KSwitcher.HistoryHost";
+using HistoryJson = nlohmann::json;
+HWND historyController(HANDLE process)
+{
+    if (!process || WaitForSingleObject(process, 0) == WAIT_OBJECT_0) return nullptr;
+    auto window = FindWindowW(HistoryHostClass, nullptr);
+    DWORD pid{}; GetWindowThreadProcessId(window, &pid);
+    return pid == GetProcessId(process) ? window : nullptr;
+}
+}
+void App::openHistoryProcess()
+{
+    auto foreground = GetForegroundWindow();
+    if (foreground != window && foreground != historyWindow) pasteTarget = foreground;
+    if (historyProcess && WaitForSingleObject(historyProcess, 0) == WAIT_OBJECT_0) {
+        CloseHandle(historyProcess); historyProcess = nullptr; historyWindow = nullptr;
+    }
+    if (historyProcess) {
+        if (auto host = historyController(historyProcess)) {
+            AllowSetForegroundWindow(GetProcessId(historyProcess));
+            PostMessageW(host, HistoryHostShow, 0, 0);
+        }
+        return;
+    }
+    auto path = executable();
+    auto command = L"\"" + path + L"\" --history-host=" + std::to_wstring(reinterpret_cast<uintptr_t>(window));
+    STARTUPINFOW startup{sizeof(startup)};
+    startup.dwFlags = STARTF_USESHOWWINDOW; startup.wShowWindow = SW_HIDE;
+    PROCESS_INFORMATION child{};
+    if (!CreateProcessW(path.c_str(), command.data(), nullptr, nullptr, FALSE, CREATE_NO_WINDOW,
+                        nullptr, std::filesystem::path(path).parent_path().c_str(), &startup, &child))
+        throw std::runtime_error("Cannot start clipboard history window");
+    CloseHandle(child.hThread);
+    historyProcess = child.hProcess;
+    AllowSetForegroundWindow(child.dwProcessId);
+}
+void App::refreshHistoryProcess()
+{
+    if (auto host = historyController(historyProcess)) PostMessageW(host, HistoryHostRefresh, 0, 0);
+}
+void App::remoteHistory(const char *action, const std::wstring &id, bool plain)
+{
+    if (!historyService || !configurationPeer(historyService, L"KSwitcher.exe"))
+        throw std::runtime_error("KSwitcher has stopped. Reopen clipboard history.");
+    auto text = HistoryJson{{"action", action}, {"id", utf8(id)}, {"plain", plain}}.dump();
+    if (std::string_view(action) == "paste") {
+        DWORD residentPid{}; GetWindowThreadProcessId(historyService, &residentPid);
+        AllowSetForegroundWindow(residentPid);
+    }
+    COPYDATASTRUCT message{HistoryRequest, DWORD(text.size()), text.data()};
+    DWORD_PTR result{};
+    if (!SendMessageTimeoutW(historyService, WM_COPYDATA, reinterpret_cast<WPARAM>(window),
+                             reinterpret_cast<LPARAM>(&message), SMTO_ABORTIFHUNG | SMTO_ERRORONEXIT,
+                             15000, &result) || result != 1)
+        throw std::runtime_error("KSwitcher could not complete the history request. Reopen history and retry.");
+}
+LRESULT App::historyRequest(HWND sender, const COPYDATASTRUCT &message)
+{
+    DWORD pid{}; GetWindowThreadProcessId(sender, &pid);
+    if (!historyProcess || pid != GetProcessId(historyProcess) ||
+        !configurationPeer(sender, L"KSwitcher.exe") || message.cbData > 4096 ||
+        !message.cbData || !message.lpData || installingUpdate) return FALSE;
+    try {
+        const auto *first = static_cast<const char *>(message.lpData);
+        auto job = HistoryJson::parse(first, first + message.cbData);
+        auto action = job.at("action").get<std::string>();
+        auto id = wide(job.at("id").get<std::string>());
+        if (id.size() > 128) return FALSE;
+        if (action == "ready") {
+            auto ui = reinterpret_cast<HWND>(uintptr_t(std::stoull(id)));
+            DWORD uiPid{}; GetWindowThreadProcessId(ui, &uiPid);
+            wchar_t name[64]{}; GetClassNameW(ui, name, 64);
+            if (uiPid != pid || std::wstring(name) != L"KSwitcher.History") return FALSE;
+            historyWindow = ui;
+        } else if (action == "paste") {
+            if (busy || !history) return FALSE;
+            pasteEntry(id, job.at("plain").get<bool>());
+        } else if (action == "ocr") {
+            if (busy || !history) return FALSE;
+            recognizeEntry(id);
+        } else if (action == "clear") clearHistory();
+        else if (action == "pin" || action == "remove") {
+            if (busy || !history) return FALSE;
+            if (action == "pin") history->pin(id); else history->remove(id);
+        } else return FALSE;
+        return TRUE;
+    } catch (...) { return FALSE; }
+}
+void App::saveHistoryView(const std::wstring &selection, const std::wstring &top, const std::wstring &query)
+{
+    if (!historyService) return;
+    try {
+        auto text = HistoryJson{{"selection", utf8(selection)}, {"top", utf8(top)}, {"query", utf8(query)}}.dump();
+        atomicWrite(data / L"history-view.bin", protect(Bytes(text.begin(), text.end())));
+    } catch (...) {} // Closing the UI must still release its process if state cannot be saved.
+}

src/config_main.cpp

@@ -79,7 +79,7 @@ LRESULT CALLBACK controller(HWND window, UINT message, WPARAM wp, LPARAM lp)
 }
 // The configurator owns no history store, dictionaries, worker or input hooks.
 // All mutations are validated and committed by the resident process.
-App::App(HINSTANCE h, bool, const std::filesystem::path &) : instance(h)
+App::App(HINSTANCE h, bool, const std::filesystem::path &, HWND) : instance(h)
 {
     current = this;
     data = dataDirectory();

src/main.cpp

@@ -1,12 +1,27 @@
 #include "app.h"
 #include <shellapi.h>
 #include <shlobj.h>
+#include "configuration.h"
 int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR, int)
 {
     CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
     int argc{};
     auto argv = CommandLineToArgvW(GetCommandLineW(), &argc);
     std::wstring arg = argc > 1 ? argv[1] : L"";
+    if (argc == 2 && arg.starts_with(L"--history-host=")) {
+        LocalFree(argv);
+        int result = 1;
+        try {
+            auto service = reinterpret_cast<HWND>(uintptr_t(std::stoull(arg.substr(15))));
+            wchar_t name[64]{}; GetClassNameW(service, name, 64);
+            if (std::wstring(name) != L"KSwitcher.Main" || !ks::configurationPeer(service, L"KSwitcher.exe"))
+                throw std::runtime_error("Invalid history service");
+            ks::App app(instance, true, {}, service);
+            result = app.execute();
+        } catch (...) {}
+        CoUninitialize();
+        return result;
+    }
     if (arg.starts_with(L"--configure-autostart="))
     {
         int result = 1;
@@ -72,6 +87,7 @@ int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR, int)
     try
     {
         ks::App app(instance, arg == L"--smoke-test");
+        app.isolateHistory = !app.smoke;
         if (arg.starts_with(L"--update-ready-event="))
             app.updateStartupEvent = arg.substr(std::wstring(L"--update-ready-event=").size());
         else if (!arg.empty() && arg != L"--smoke-test")

src/platform.cpp

@@ -265,15 +265,27 @@ std::wstring processName(HWND window)
     CloseHandle(h);
     return ok ? std::filesystem::path(std::wstring(path, n)).stem().wstring() : L"";
 }
-Clip readClipboard(HWND window, size_t limit)
+Clip readClipboard(HWND window, size_t limit, ClipboardRead mode, std::optional<DWORD> expected)
 {
     ClipboardLock lock(window);
+    if (expected && *expected != GetClipboardSequenceNumber())
+        throw std::runtime_error("Clipboard changed while taking snapshot");
+    if (mode == ClipboardRead::WithoutImages &&
+        (IsClipboardFormatAvailable(CF_DIB) || IsClipboardFormatAvailable(CF_DIBV5) ||
+         IsClipboardFormatAvailable(CF_BITMAP) || IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG"))))
+        throw std::runtime_error("Clipboard changed to an image");
     Clip c;
     size_t total = 0;
     for (UINT f = EnumClipboardFormats(0); f; f = EnumClipboardFormats(f))
     {
         if (!globalFormat(f))
             continue;
+        wchar_t name[256]{};
+        if (f >= 0xc000) GetClipboardFormatNameW(f, name, 256);
+        if (mode == ClipboardRead::Selection && f != CF_UNICODETEXT &&
+            std::wstring_view(name) != L"VisualStudioEditorOperationsLineCutCopyClipboardTag" &&
+            std::wstring_view(name) != L"MSDEVLineSelect" && std::wstring_view(name) != L"vscode-editor-data")
+            continue;
         HANDLE handle = GetClipboardData(f);
         if (!handle)
             continue;
@@ -291,8 +303,6 @@ Clip readClipboard(HWND window, size_t limit)
         GlobalUnlock(handle);
         if (f >= 0xc000)
         {
-            wchar_t name[256]{};
-            GetClipboardFormatNameW(f, name, 256);
             format.name = name;
         }
         total += size;
@@ -300,7 +310,8 @@ Clip readClipboard(HWND window, size_t limit)
     }
     return c;
 }
-DWORD writeClipboard(HWND window, const Clip &c)
+DWORD writeClipboard(HWND window, const Clip &c) { return writeClipboardGuarded(window, c, {}); }
+DWORD writeClipboardGuarded(HWND window, const Clip &c, std::optional<DWORD> expected)
 {
     // Allocate all blocks before replacing any existing data.
     std::vector<std::pair<UINT, HGLOBAL>> blocks;
@@ -327,6 +338,8 @@ DWORD writeClipboard(HWND window, const Clip &c)
             blocks.emplace_back(id, h);
         }
         ClipboardLock lock(window);
+        if (expected && *expected != GetClipboardSequenceNumber())
+            throw std::runtime_error("Clipboard changed before restoring snapshot");
         if (!EmptyClipboard())
             throw std::runtime_error("Cannot replace clipboard");
         for (auto &[id, h] : blocks)

src/platform.h

@@ -43,8 +43,11 @@ bool ownsClipboard(HWND);
 bool webViewDescendant(DWORD owner, DWORD host,
                        const std::function<std::optional<std::pair<DWORD, std::wstring>>(DWORD)> &read);
 std::wstring processName(HWND);
-Clip readClipboard(HWND, size_t limit = 32 * 1024 * 1024);
+enum class ClipboardRead { All, Selection, WithoutImages };
+Clip readClipboard(HWND, size_t limit = 32 * 1024 * 1024,
+                   ClipboardRead = ClipboardRead::All, std::optional<DWORD> expected = {});
 DWORD writeClipboard(HWND, const Clip &);
+DWORD writeClipboardGuarded(HWND, const Clip &, std::optional<DWORD> expected);
 Clip textClip(const std::wstring &);
 bool chord(WORD key, UINT modifiers = 0);
 // Process-local marker, shared by every KSwitcher input producer (not an authentication token).

src/screenshot_main.cpp

@@ -50,6 +50,10 @@ int WINAPI wWinMain(HINSTANCE instance,HINSTANCE,PWSTR,int)
     std::wstring token;
     bool autoOpenEditor=false, writeLog=false;
     int argc{}; auto argv=CommandLineToArgvW(GetCommandLineW(),&argc);
+    if(argc==3 && std::wstring(argv[1])==L"--clipboard-snapshot") {
+        std::filesystem::path request=argv[2]; LocalFree(argv);
+        return ks::runClipboardSnapshot(request);
+    }
     if(argc==3 && (std::wstring(argv[1])==L"--capture-history" || std::wstring(argv[1])==L"--history-ocr")) {
         bool ocr=std::wstring(argv[1])==L"--history-ocr";
         std::filesystem::path request=argv[2]; LocalFree(argv);

src/storage.cpp

@@ -410,6 +410,87 @@ void History::loadIndex()
     }
     entries_ = std::move(loaded);
 }
+void History::reload() { std::lock_guard lock(mutex_); loadIndex(); }
+void ClipboardSnapshot::cleanup() noexcept
+{
+    if (request_.empty()) return;
+    std::error_code ignored;
+    for (const auto *suffix : {L"", L".snapshot", L".result"})
+        std::filesystem::remove(std::filesystem::path(request_.wstring() + suffix), ignored);
+    request_.clear();
+}
+ClipboardSnapshot::~ClipboardSnapshot() { cleanup(); }
+DWORD ClipboardSnapshot::run(bool restore, DWORD sequence)
+{
+    atomicWrite(request_, protect(jsonBytes(Json{{"schema", 1}, {"restore", restore}, {"sequence", sequence}})));
+    auto helper = std::filesystem::path(executable()).parent_path() / L"KSwitcher.Screenshot.exe";
+    auto command = L"\"" + helper.wstring() + L"\" --clipboard-snapshot \"" + request_.wstring() + L"\"";
+    STARTUPINFOW startup{sizeof(startup)};
+    startup.dwFlags = STARTF_USESHOWWINDOW; startup.wShowWindow = SW_HIDE;
+    PROCESS_INFORMATION process{};
+    if (!CreateProcessW(helper.c_str(), command.data(), nullptr, nullptr, FALSE, CREATE_NO_WINDOW,
+                        nullptr, helper.parent_path().c_str(), &startup, &process))
+        throw std::runtime_error("Cannot start clipboard snapshot helper");
+    CloseHandle(process.hThread);
+    auto wait = WaitForSingleObject(process.hProcess, 10000);
+    DWORD result = ERROR_GEN_FAILURE;
+    if (wait != WAIT_OBJECT_0)
+    {
+        TerminateProcess(process.hProcess, ERROR_TIMEOUT);
+        WaitForSingleObject(process.hProcess, INFINITE);
+    }
+    GetExitCodeProcess(process.hProcess, &result);
+    CloseHandle(process.hProcess);
+    if (wait != WAIT_OBJECT_0 || result) throw std::runtime_error("Clipboard snapshot helper failed");
+    return parse(unprotect(readFile(request_.wstring() + L".result", 4096))).at("sequence").get<DWORD>();
+}
+void ClipboardSnapshot::capture(HWND window, DWORD sequence)
+{
+    cleanup();
+    clip_ = {};
+    if (!IsClipboardFormatAvailable(CF_DIB) && !IsClipboardFormatAvailable(CF_DIBV5) &&
+        !IsClipboardFormatAvailable(CF_BITMAP) && !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG")))
+    {
+        clip_ = readClipboard(window, 64 * 1024 * 1024, ClipboardRead::WithoutImages, sequence);
+        return;
+    }
+    request_ = std::filesystem::temp_directory_path() / (L"ks-clipboard-" + newSnippetId() + L".request");
+    try { run(false, sequence); }
+    catch (...) { cleanup(); throw; }
+}
+DWORD ClipboardSnapshot::restore(HWND window, DWORD sequence)
+{
+    return request_.empty() ? writeClipboardGuarded(window, clip_, sequence) : run(true, sequence);
+}
+int runClipboardSnapshot(const std::filesystem::path &request)
+{
+    try
+    {
+        if (!request.is_absolute() || !request.filename().wstring().starts_with(L"ks-clipboard-") ||
+            request.extension() != L".request") return 1;
+        auto job = parse(unprotect(readFile(request, 4096)));
+        if (job.at("schema") != 1) return 1;
+        auto sequence = job.at("sequence").get<DWORD>();
+        const auto snapshot = request.wstring() + L".snapshot";
+        if (job.at("restore").get<bool>())
+        {
+            auto clip = decodeClip(unprotect(readFile(snapshot, 70 * 1024 * 1024)));
+            HWND window = CreateWindowExW(0, L"STATIC", L"", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, nullptr, nullptr);
+            if (!window) return 1;
+            struct WindowCleanup { HWND window; ~WindowCleanup() { DestroyWindow(window); } } cleanup{window};
+            sequence = writeClipboardGuarded(window, clip, sequence);
+        }
+        else
+        {
+            auto clip = readClipboard(nullptr, 64 * 1024 * 1024, ClipboardRead::All, sequence);
+            if (sequence != GetClipboardSequenceNumber()) return 2;
+            atomicWrite(snapshot, protect(encodeClip(clip)));
+        }
+        atomicWrite(request.wstring() + L".result", protect(jsonBytes(Json{{"sequence", sequence}})));
+        return 0;
+    }
+    catch (...) { return 1; }
+}
 bool History::captureImage(DWORD sequence, const std::wstring &app, const Settings &settings)
 {
     // Serialize helper index changes with all resident history mutations. Only
@@ -706,12 +787,12 @@ void History::clear()
         std::filesystem::remove(folder_ / (e.id + L".ocr"), ec);
     }
 }
-std::wstring History::recognizeImage(const std::wstring &id, const Settings &settings,
+static Bytes historyImageJob(const std::filesystem::path &folder, const std::wstring &id,
-                                    const std::function<bool()> &cancelled) const
+                             const Json &job, const std::function<bool()> &cancelled)
 {
     if (!validId(id)) throw std::runtime_error("Invalid history ID");
     if (cancelled && cancelled()) throw std::runtime_error("History OCR cancelled");
-    auto request = std::filesystem::absolute(folder_) / (L"ocr-" + newSnippetId() + L".request");
+    auto request = std::filesystem::absolute(folder) / (L"ocr-" + newSnippetId() + L".request");
     auto response = request; response += L".result";
     struct Cleanup {
         std::filesystem::path request, response;
@@ -721,9 +802,6 @@ std::wstring History::recognizeImage(const std::wstring &id, const Settings &set
             std::filesystem::remove(response, ignored);
         }
     } cleanup{request, response};
-    // Send only OCR options and the entry ID. The resident never loads image bytes.
-    Json job{{"schema", 1}, {"id", utf8(id)}, {"tesseract", settings.useTesseract},
-             {"path", utf8(settings.tesseractPath)}, {"languages", utf8(settings.tesseractLanguages)}};
     atomicWrite(request, protect(jsonBytes(job)));
     auto helper = std::filesystem::path(executable()).parent_path() / L"KSwitcher.Screenshot.exe";
     auto command = L"\"" + helper.wstring() + L"\" --history-ocr \"" + request.wstring() + L"\"";
@@ -755,11 +833,28 @@ std::wstring History::recognizeImage(const std::wstring &id, const Settings &set
     DWORD result{};
     if (!GetExitCodeProcess(child.handle, &result) || result)
         throw std::runtime_error("History OCR helper failed: " + std::to_string(result));
-    auto reply = parse(unprotect(readFile(response, 8 * 1024 * 1024)));
+    return unprotect(readFile(response, 8 * 1024 * 1024));
+}
+std::wstring History::recognizeImage(const std::wstring &id, const Settings &settings,
+                                    const std::function<bool()> &cancelled) const
+{
+    Json job{{"schema", 1}, {"id", utf8(id)}, {"tesseract", settings.useTesseract},
+             {"path", utf8(settings.tesseractPath)}, {"languages", utf8(settings.tesseractLanguages)}};
+    auto reply = parse(historyImageJob(folder_, id, job, cancelled));
     if (reply.at("schema") != 1 || str(reply, "id") != id)
         throw std::runtime_error("Invalid history OCR response");
     return str(reply, "text");
 }
+Pixels History::thumbnail(const std::wstring &id, const std::function<bool()> &cancelled) const
+{
+    auto bytes = historyImageJob(folder_, id, Json{{"schema", 1}, {"id", utf8(id)}, {"thumbnail", true}}, cancelled);
+    size_t at = 0;
+    auto width = get32(bytes, at), height = get32(bytes, at);
+    if (!width || !height || width > 208 || height > 128 || bytes.size() - at != width * height * 4)
+        throw std::runtime_error("Invalid history thumbnail response");
+    bytes.erase(bytes.begin(), bytes.begin() + at);
+    return Pixels{width, height, std::move(bytes)};
+}
 int runHistoryOcr(const std::filesystem::path &request)
 {
     try {
@@ -768,11 +863,20 @@ int runHistoryOcr(const std::filesystem::path &request)
         auto job = parse(unprotect(readFile(request, 1024 * 1024)));
         auto id = str(job, "id");
         if (job.at("schema") != 1 || !validId(id)) return 1;
+        auto clip = decodeClip(unprotect(readFile(request.parent_path() / (id + L".dat"), 80 * 1024 * 1024)));
+        if (job.value("thumbnail", false)) {
+            auto pixels = decodeImage(clip, 208, 128);
+            if (!pixels.width || !pixels.height) return 1;
+            Bytes reply;
+            put32(reply, pixels.width); put32(reply, pixels.height);
+            reply.insert(reply.end(), pixels.bgra.begin(), pixels.bgra.end());
+            atomicWrite(request.wstring() + L".result", protect(reply));
+            return 0;
+        }
         Settings settings;
         settings.useTesseract = job.at("tesseract").get<bool>();
         settings.tesseractPath = str(job, "path");
         settings.tesseractLanguages = str(job, "languages");
-        auto clip = decodeClip(unprotect(readFile(request.parent_path() / (id + L".dat"), 80 * 1024 * 1024)));
         auto text = utf8(recognizeText(clip, settings));
         if (text.size() > 1024 * 1024) return 1;
         auto response = request; response += L".result";

src/storage.h

@@ -4,6 +4,7 @@
 #include <functional>
 namespace ks
 {
+struct Pixels;
 Settings loadSettings(const std::filesystem::path &, const std::vector<Layout> &);
 Settings decodeSettings(const Bytes &, const std::vector<Layout> &);
 Bytes encodeSettings(const Settings &);
@@ -29,12 +30,14 @@ class History
 
   public:
     explicit History(const std::filesystem::path &);
+    void reload();
     std::vector<Entry> entries() const;
     Clip load(const std::wstring &id) const;
     void add(const Clip &, const std::wstring &app, const Settings &);
     bool captureImage(DWORD sequence, const std::wstring &app, const Settings &);
     std::wstring recognizeImage(const std::wstring &id, const Settings &,
                                 const std::function<bool()> &cancelled = {}) const;
+    Pixels thumbnail(const std::wstring &id, const std::function<bool()> &cancelled = {}) const;
     bool saveOcr(const std::wstring &id, const std::optional<std::wstring> &, const Settings &);
     std::optional<std::wstring> ocrText(const std::wstring &id, const std::wstring &profile = L"") const;
     void remove(const std::wstring &);
@@ -47,4 +50,20 @@ Clip decodeClip(const Bytes &);
 bool sameClipboardImage(const Clip &, const Clip &);
 int runImageHistoryCapture(const std::filesystem::path &request);
 int runHistoryOcr(const std::filesystem::path &request);
+// Image backups stay encrypted on disk and are read/written only by a short-lived helper.
+class ClipboardSnapshot
+{
+    Clip clip_;
+    std::filesystem::path request_;
+    void cleanup() noexcept;
+    DWORD run(bool restore, DWORD sequence);
+  public:
+    ClipboardSnapshot() = default;
+    ClipboardSnapshot(const ClipboardSnapshot &) = delete;
+    ClipboardSnapshot &operator=(const ClipboardSnapshot &) = delete;
+    ~ClipboardSnapshot();
+    void capture(HWND, DWORD sequence);
+    DWORD restore(HWND, DWORD sequence);
+};
+int runClipboardSnapshot(const std::filesystem::path &request);
 } // namespace ks

src/ui.cpp

@@ -549,11 +549,11 @@ void requestPreview(HWND w, HistoryView *v, const Entry &entry)
             auto result = new PreviewResult{generation, id, {}, {}};
             try
             {
-                auto clip = app->history->load(id);
-                if (!active->load()) { delete result; return; }
                 if (image)
-                    result->pixels = decodeImage(clip, 208, 128);
+                    result->pixels = app->history->thumbnail(id, [active] { return !active->load(); });
                 else {
+                    auto clip = app->history->load(id);
+                    if (!active->load()) { delete result; return; }
                     result->text.rtf = richPreview(clip, false);
                     if (result->text.rtf.empty()) {
                         result->text.plain = clip.text();
@@ -771,7 +771,10 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             {
                 if (!entry.empty())
                 {
-                    if (id == 112)
+                    if (v->app->historyService) {
+                        v->app->remoteHistory(id == 112 ? "pin" : "remove", entry);
+                        v->app->history->reload();
+                    } else if (id == 112)
                         v->app->history->pin(entry);
                     else
                         v->app->history->remove(entry);
@@ -907,6 +910,7 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             v->rememberedSelection = selected(w, v);
             int top = (int)SendDlgItemMessageW(w,102,LB_GETTOPINDEX,0,0);
             v->rememberedTop = top >= 0 && top < (int)v->items.size() ? v->items[top].id : L"";
+            v->app->saveHistoryView(v->rememberedSelection, v->rememberedTop, value(w, 101));
             KillTimer(w, 1);
             v->closed = true;
             v->previewActive->store(false);
@@ -918,6 +922,8 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             v->richTexts.clear();
             if (v->rich) SetWindowTextW(v->rich, L"");
             v->pending.clear();
+            if (v->app->historyService && !v->app->historyEntryWindows)
+                PostMessageW(v->app->window, WM_CLOSE, 0, 0);
             return 0;
         }
         case WM_NCDESTROY:
@@ -1681,13 +1687,19 @@ LRESULT CALLBACK snippetProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 #ifndef KS_CONFIG_APP
 LRESULT CALLBACK entryProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 {
+    if (msg == WM_NCCREATE)
+        SetWindowLongPtrW(w, GWLP_USERDATA, (LONG_PTR)((CREATESTRUCTW *)lp)->lpCreateParams);
     if (msg == WM_SIZE)
     {
         MoveWindow(GetDlgItem(w, 1), 10, 10, LOWORD(lp) - 20, HIWORD(lp) - 20, TRUE);
         return 0;
     }
-    if (msg == WM_NCDESTROY)
+    if (msg == WM_NCDESTROY) {
         disposeFont(w);
+        auto *app = (App *)GetWindowLongPtrW(w, GWLP_USERDATA);
+        if (app && app->historyService && app->historyEntryWindows && !--app->historyEntryWindows &&
+            !IsWindowVisible(app->historyWindow)) PostMessageW(app->window, WM_CLOSE, 0, 0);
+    }
     return DefWindowProcW(w, msg, wp, lp);
 }
 #endif
@@ -1695,6 +1707,7 @@ LRESULT CALLBACK entryProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
 #ifndef KS_CONFIG_APP
 void refreshHistory(App &app)
 {
+    if (app.isolateHistory) { app.refreshHistoryProcess(); return; }
     if (app.historyWindow)
     {
         auto *v = (HistoryView *)GetWindowLongPtrW(app.historyWindow, GWLP_USERDATA);
@@ -1703,6 +1716,7 @@ void refreshHistory(App &app)
 }
 void showHistory(App &app, bool visible)
 {
+    if (app.isolateHistory) { if (visible) app.openHistoryProcess(); return; }
     if (!app.history)
     {
         app.report(L"Clipboard history is unavailable. See the log in the data folder.");
@@ -1738,6 +1752,12 @@ void showHistory(App &app, bool visible)
         button(w, L"Clear &history…", 116, 546, 452, 150);
         SetWindowSubclass(list, historyKey, 1, (DWORD_PTR)w);
         SetWindowSubclass(GetDlgItem(w, 101), historyKey, 1, (DWORD_PTR)w);
+        if (app.historyService) {
+            auto *v = (HistoryView *)GetWindowLongPtrW(w, GWLP_USERDATA);
+            v->rememberedSelection = app.historySelection;
+            v->rememberedTop = app.historyTop;
+            SetDlgItemTextW(w, 101, app.historyQuery.c_str());
+        }
     }
     if (!visible) return;
     POINT cursor;
@@ -1894,6 +1914,7 @@ void showEntry(App &app, const std::wstring &id)
         }
         HWND w = makeWindow(app, L"KSwitcher.Entry", L"Clipboard item", entryProc, 720, 500,
                             WS_THICKFRAME | WS_MAXIMIZEBOX);
+        if (app.historyService) ++app.historyEntryWindows;
         auto field = edit(w, 1, 10, 10, 700, 480, ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL | WS_VSCROLL);
         SetWindowTextW(field, text.c_str());
         showRequestedWindow(w);

src/update.h

@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-inline constexpr wchar_t AppVersion[] = L"0.6.38";
+inline constexpr wchar_t AppVersion[] = L"0.6.39";
 inline constexpr UINT UpdateMessage = WM_APP + 7;
 inline constexpr UINT UpdateCheckIntervalMs = 6 * 60 * 60 * 1000;
 inline constexpr UINT UpdateNotificationRetryMs = 5 * 60 * 1000;

tests/clipboard_snapshot.cpp

@@ -0,0 +1,108 @@
+// Run with the resident stopped. The suite restores the original clipboard.
+#include "storage.h"
+#include "ocr.h"
+#include <psapi.h>
+#include <iostream>
+#include <algorithm>
+static void require(bool ok, const char *name) {
+    if (!ok) throw std::runtime_error(name);
+    std::cout << "PASS " << name << '\n';
+}
+static HWND owner() {
+    return CreateWindowExW(0,L"STATIC",L"Snapshot test",0,0,0,0,0,HWND_MESSAGE,nullptr,nullptr,nullptr);
+}
+static void child(const std::wstring &argument) {
+    auto exe=ks::executable(), command=L"\""+exe+L"\" "+argument;
+    STARTUPINFOW startup{sizeof(startup)}; startup.dwFlags=STARTF_USESHOWWINDOW; startup.wShowWindow=SW_HIDE;
+    PROCESS_INFORMATION p{};
+    if(!CreateProcessW(exe.c_str(),command.data(),nullptr,nullptr,FALSE,CREATE_NO_WINDOW,nullptr,nullptr,&startup,&p))
+        throw std::runtime_error("start fixture process");
+    CloseHandle(p.hThread);
+    auto wait=WaitForSingleObject(p.hProcess,30000); DWORD code=1;
+    if(wait!=WAIT_OBJECT_0) {TerminateProcess(p.hProcess,1);WaitForSingleObject(p.hProcess,INFINITE);}
+    GetExitCodeProcess(p.hProcess,&code); CloseHandle(p.hProcess);
+    if(code) throw std::runtime_error("fixture process failed");
+}
+static size_t resident() {
+    ks::Bytes b(1024*1024); auto ws=reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(b.data());
+    if(!QueryWorkingSet(GetCurrentProcess(),ws,DWORD(b.size()))) throw std::runtime_error("working set query");
+    size_t pages=0; for(size_t i=0;i<ws->NumberOfEntries;++i) if(!ws->WorkingSetInfo[i].Shared) ++pages;
+    return pages*4096;
+}
+static void verifyImage(HWND w) {
+    auto c=ks::readClipboard(w,64*1024*1024);
+    for(auto id:{CF_DIB,CF_DIBV5}) {
+        auto it=std::find_if(c.formats.begin(),c.formats.end(),[&](const auto &f){return f.id==UINT(id);});
+        require(it!=c.formats.end(),"restores image representation");
+        auto pixels=ks::decodeImage(ks::Clip{{*it}});
+        require(pixels.width==1566 && pixels.height==1068 && pixels.bgra.front()==77,"preserves image pixels");
+    }
+    require(c.text()==L"Snapshot mixed text","preserves accompanying text");
+}
+int main(int argc,char**argv) {
+    CoInitializeEx(nullptr,COINIT_MULTITHREADED);
+    HWND w=owner(); int result=0; ks::Clip original; bool saved=false;
+    try {
+        std::string mode=argc>1?argv[1]:"suite";
+        if(mode=="publish") {
+            ks::Pixels p{1566,1068,ks::Bytes(1566*1068*4,255)}; p.bgra[0]=77;
+            auto dib=ks::imageDib(p); auto v5=dib;
+            BITMAPV5HEADER h{}; h.bV5Size=sizeof(h); h.bV5Width=p.width; h.bV5Height=-p.height;
+            h.bV5Planes=1; h.bV5BitCount=32; h.bV5Compression=BI_BITFIELDS;
+            h.bV5RedMask=0xff0000; h.bV5GreenMask=0xff00; h.bV5BlueMask=0xff; h.bV5AlphaMask=0xff000000;
+            v5.id=CF_DIBV5; v5.data.resize(sizeof(h)+p.bgra.size());
+            memcpy(v5.data.data(),&h,sizeof(h)); memcpy(v5.data.data()+sizeof(h),p.bgra.data(),p.bgra.size());
+            auto clip=ks::textClip(L"Snapshot mixed text"); clip.formats.push_back(dib); clip.formats.push_back(v5);
+            ks::writeClipboard(w,clip);
+        } else if(mode=="old" || mode=="new") {
+            child(L"publish"); auto baseline=resident();
+            if(mode=="old") {
+                auto clip=ks::readClipboard(w,64*1024*1024);
+                ks::writeClipboard(w,ks::textClip(L"temporary")); ks::writeClipboard(w,clip);
+            } else {
+                ks::ClipboardSnapshot snapshot; snapshot.capture(w,GetClipboardSequenceNumber());
+                auto seq=ks::writeClipboard(w,ks::textClip(L"temporary"));
+                require(snapshot.restore(w,seq)==GetClipboardSequenceNumber(),"helper returns current sequence");
+            }
+            auto after=resident();
+            auto report="baseline="+std::to_string(baseline)+" after="+std::to_string(after)+" delta="+std::to_string(int64_t(after)-int64_t(baseline))+"\n";
+            auto path=std::filesystem::path(ks::executable()).parent_path()/(L"snapshot-memory-"+ks::wide(mode)+L".txt");
+            ks::atomicWrite(path,ks::Bytes(report.begin(),report.end()));
+            verifyImage(w); // Only after measuring: verification intentionally reads images.
+        } else {
+            original=ks::readClipboard(w,128*1024*1024); saved=true;
+            child(L"old"); child(L"new"); child(L"publish");
+            auto seq=GetClipboardSequenceNumber();
+            auto selected=ks::readClipboard(w,32*1024*1024,ks::ClipboardRead::Selection);
+            require(selected.formats.size()==1 && selected.text()==L"Snapshot mixed text","selection read excludes image data");
+            bool rejected=false;
+            try {ks::readClipboard(w,32*1024*1024,ks::ClipboardRead::WithoutImages,seq);} catch(...) {rejected=true;}
+            require(rejected,"resident rejects images before reading their data");
+            {
+                ks::ClipboardSnapshot snapshot; snapshot.capture(w,seq);
+                auto stale=ks::writeClipboard(w,ks::textClip(L"temporary"));
+                ks::writeClipboard(w,ks::textClip(L"external copy")); rejected=false;
+                try {snapshot.restore(w,stale);} catch(...) {rejected=true;}
+                require(rejected && ks::readClipboard(w).text()==L"external copy","stale image restore preserves external copy");
+            }
+            {
+                ks::ClipboardSnapshot snapshot; snapshot.capture(w,GetClipboardSequenceNumber());
+                auto temporary=ks::writeClipboard(w,ks::textClip(L"temporary"));
+                snapshot.restore(w,temporary);
+                require(ks::readClipboard(w).text()==L"external copy","text snapshot fast path restores clipboard");
+            }
+            {
+                ks::Clip empty; auto seqEmpty=ks::writeClipboard(w,empty);
+                ks::ClipboardSnapshot snapshot; snapshot.capture(w,seqEmpty);
+                snapshot.restore(w,ks::writeClipboard(w,ks::textClip(L"temporary")));
+                require(ks::readClipboard(w).formats.empty(),"empty clipboard restored");
+            }
+            auto marked=ks::textClip(L"line"); marked.formats.push_back({0,L"MSDEVLineSelect",ks::Bytes{1}});
+            ks::writeClipboard(w,marked);
+            require(ks::readClipboard(w,1024,ks::ClipboardRead::Selection).formats.size()==2,"selection reader preserves editor guard metadata");
+            std::cout<<"PASS clipboard snapshot suite\n";
+        }
+    } catch(const std::exception &e) {std::cerr<<"FAIL "<<e.what()<<'\n';result=1;}
+    if(saved) try {ks::writeClipboard(w,original);} catch(...) {result=1;}
+    DestroyWindow(w); CoUninitialize(); return result;
+}

tests/history_host.cpp

@@ -0,0 +1,169 @@
+// Run from an isolated fixture folder containing KSwitcher.exe and Screenshot.exe,
+// with the normal resident stopped. Never points at the installed user's data.
+#include "storage.h"
+#include "ocr.h"
+#include "json.hpp"
+#include <commctrl.h>
+#include <psapi.h>
+#include <iostream>
+static HWND editor{};
+static bool pastedImage{};
+static LRESULT CALLBACK targetProc(HWND w,UINT message,WPARAM wp,LPARAM lp) {
+    if(message==WM_SETFOCUS && editor) {SetFocus(editor);return 0;}
+    return DefWindowProcW(w,message,wp,lp);
+}
+static void require(bool ok,const char *what) {if(!ok)throw std::runtime_error(what);std::cout<<"PASS "<<what<<'\n';}
+static void pump() {MSG m;while(PeekMessageW(&m,nullptr,0,0,PM_REMOVE)){TranslateMessage(&m);DispatchMessageW(&m);}}
+template<class F> static void until(F condition,const char *what,DWORD timeout=10000) {
+    auto end=GetTickCount64()+timeout;
+    while(!condition()){if(GetTickCount64()>=end)throw std::runtime_error(what);pump();Sleep(10);}
+}
+static LRESULT send(HWND w,UINT message,WPARAM wp=0,LPARAM lp=0) {
+    DWORD_PTR result{};
+    if(!SendMessageTimeoutW(w,message,wp,lp,SMTO_ABORTIFHUNG,5000,&result))throw std::runtime_error("window request timed out");
+    return LRESULT(result);
+}
+static void command(HWND resident,int cmd) {
+    COPYDATASTRUCT data{1,sizeof(cmd),&cmd};send(resident,WM_COPYDATA,0,LPARAM(&data));
+}
+static size_t memory(HANDLE process) {
+    ks::Bytes bytes(1024*1024);auto ws=reinterpret_cast<PSAPI_WORKING_SET_INFORMATION*>(bytes.data());
+    if(!QueryWorkingSet(process,ws,DWORD(bytes.size())))throw std::runtime_error("memory query failed");
+    size_t pages=0;for(size_t i=0;i<ws->NumberOfEntries;++i)if(!ws->WorkingSetInfo[i].Shared)++pages;
+    return pages*4096;
+}
+static std::wstring editorText() {wchar_t text[256]{};GetWindowTextW(editor,text,256);return text;}
+static LRESULT CALLBACK editProc(HWND w,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR) {
+    if(message==WM_PASTE && IsClipboardFormatAvailable(CF_DIB)) {pastedImage=true;return 0;}
+    return DefSubclassProc(w,message,wp,lp);
+}
+static ks::Clip excluded(ks::Clip clip) {
+    clip.formats.push_back({0,L"ExcludeClipboardContentFromMonitorProcessing",ks::Bytes{0}});return clip;
+}
+int main() {
+    CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
+    PROCESS_INFORMATION process{};HWND resident{},target{};ks::Clip saved;bool captured=false;int result=0;
+    try {
+        auto folder=std::filesystem::path(ks::executable()).parent_path();
+        require(folder.filename().wstring().starts_with(L"history-host-fixture-"),"isolated fixture directory");
+        require(!FindWindowW(L"KSwitcher.Main",nullptr),"normal resident is stopped");
+        WNDCLASSW targetClass{};targetClass.lpfnWndProc=targetProc;targetClass.hInstance=GetModuleHandleW(nullptr);
+        targetClass.lpszClassName=L"KSwitcher.HistoryTestDestination";RegisterClassW(&targetClass);
+        target=CreateWindowExW(0,targetClass.lpszClassName,L"KSwitcher history test destination",WS_OVERLAPPEDWINDOW|WS_VISIBLE,
+                               50,50,500,250,nullptr,nullptr,nullptr,nullptr);
+        editor=CreateWindowExW(0,L"EDIT",L"",WS_CHILD|WS_VISIBLE|ES_MULTILINE,10,10,450,180,target,nullptr,nullptr,nullptr);
+        SetWindowSubclass(editor,editProc,1,0);
+        saved=ks::readClipboard(target,128*1024*1024);captured=true;
+        ks::writeClipboard(target,excluded(ks::textClip(L"fixture clipboard")));
+        auto settings=ks::loadSettings(folder/L"missing.json",ks::readLayouts());
+        settings.autoCorrect=false;settings.writeLog=true;settings.history=true;settings.maxItems=500;settings.maxMiB=100;
+        std::filesystem::create_directories(folder/L"data");
+        ks::saveSettings(folder/L"data/settings.json",settings);
+        ks::History history(folder/L"data/history");
+        history.clear(); // This executable only runs in its dedicated fixture directory.
+        ks::Pixels pixels{1566,1068,ks::Bytes(1566*1068*4,255)};
+        auto image=ks::Clip{{ks::imageDib(pixels)}};
+        history.add(image,L"test",settings);
+        auto imageId=history.entries().front().id;
+        // Seed once rather than rewriting the encrypted index 500 times. This
+        // also avoids measuring fixture creation in the resident under test.
+        auto indexPath=folder/L"data/history/index.dat";
+        auto rows=nlohmann::json::parse(ks::unprotect(ks::readFile(indexPath,1024*1024)));
+        for(int i=0;i<499;++i) {
+            auto id=ks::lower(ks::newSnippetId().substr(1,36)),text=L"History fixture "+std::to_wstring(i);
+            auto bytes=ks::protect(ks::encodeClip(ks::textClip(text)));
+            ks::atomicWrite(folder/L"data/history"/(id+L".dat"),bytes);
+            rows.insert(rows.begin(),nlohmann::json{{"id",ks::utf8(id)},{"preview",ks::utf8(text)},
+                {"app","test"},{"bytes",bytes.size()},{"at",i+1},{"pinned",false},{"image",false},{"files",false}});
+        }
+        auto encoded=rows.dump();ks::atomicWrite(indexPath,ks::protect(ks::Bytes(encoded.begin(),encoded.end())));
+        history.reload();
+        auto textId=history.entries().front().id;
+        auto exe=folder/L"KSwitcher.exe";auto line=L"\""+exe.wstring()+L"\"";
+        STARTUPINFOW startup{sizeof(startup)};startup.dwFlags=STARTF_USESHOWWINDOW;startup.wShowWindow=SW_HIDE;
+        require(CreateProcessW(exe.c_str(),line.data(),nullptr,nullptr,FALSE,CREATE_NO_WINDOW,nullptr,folder.c_str(),&startup,&process),"start isolated resident");
+        CloseHandle(process.hThread);process.hThread=nullptr;
+        until([&]{resident=FindWindowW(L"KSwitcher.Main",nullptr);return resident!=nullptr;},"resident startup");
+        auto base=memory(process.hProcess);
+        std::string forged="{\"action\":\"clear\",\"id\":\"\",\"plain\":false}";
+        COPYDATASTRUCT forgedRequest{0x4b530200,DWORD(forged.size()),forged.data()};
+        require(send(resident,WM_COPYDATA,WPARAM(target),LPARAM(&forgedRequest))==0,
+                "history rejects requests from an untrusted process");
+        auto open=[&] {
+            require(ks::activateWindow(target),"destination foreground");SetFocus(editor);command(resident,5);
+            HWND window{};
+            until([&]{window=FindWindowW(L"KSwitcher.History",nullptr);return window&&IsWindowVisible(window);},"history startup");
+            until([&]{return send(GetDlgItem(window,102),LB_GETCOUNT)>0;},"history rows");
+            DWORD pid{};GetWindowThreadProcessId(window,&pid);
+            require(pid!=process.dwProcessId,"history belongs to a separate process");
+            return window;
+        };
+        auto close=[&](HWND window) {
+            DWORD pid{};GetWindowThreadProcessId(window,&pid);HANDLE child=OpenProcess(SYNCHRONIZE,FALSE,pid);
+            PostMessageW(window,WM_KEYDOWN,VK_ESCAPE,0); // Escape also works with focus on the window itself.
+            until([&]{return WaitForSingleObject(child,0)==WAIT_OBJECT_0;},"history helper exits after Escape");
+            CloseHandle(child);
+            require(!FindWindowW(L"KSwitcher.History",nullptr),"Escape destroys history window");
+        };
+        for(int i=0;i<3;++i){auto w=open();until([&]{return send(GetDlgItem(w,102),LB_GETCOUNT)==500;},"all history rows loaded");require(true,"all history entries visible");close(w);}
+        auto idle=memory(process.hProcess);
+        std::cout<<"MEMORY resident_before="<<base<<" after_three_closes="<<idle<<'\n';
+        require(idle<base+2*1024*1024,"repeated history does not retain UI heap in resident");
+        auto w=open();send(w,WM_COMMAND,112);
+        until([&]{history.reload();return history.entries().front().pinned;},"resident pin mutation");
+        require(history.entries().front().id==textId,"pin preserves history identity");
+        send(GetDlgItem(w,101),WM_SETTEXT,0,LPARAM(L"History fixture 498"));
+        until([&]{return send(GetDlgItem(w,102),LB_GETCOUNT)==1;},"history search");
+        close(w);w=open();
+        wchar_t query[100]{};send(GetDlgItem(w,101),WM_GETTEXT,100,LPARAM(query));
+        require(std::wstring(query)==L"History fixture 498","search survives helper restart");
+        send(w,WM_COMMAND,114);
+        HWND entry{};until([&]{entry=FindWindowW(L"KSwitcher.Entry",nullptr);return entry!=nullptr;},"full item opens");
+        DWORD childPid{};GetWindowThreadProcessId(w,&childPid);HANDLE child=OpenProcess(SYNCHRONIZE,FALSE,childPid);
+        send(GetDlgItem(w,101),WM_KEYDOWN,VK_ESCAPE);
+        require(WaitForSingleObject(child,0)==WAIT_TIMEOUT && IsWindow(entry),"full item remains usable after closing history");
+        send(entry,WM_CLOSE);
+        until([&]{return WaitForSingleObject(child,0)==WAIT_OBJECT_0;},"helper exits after last full item closes");CloseHandle(child);
+        w=open();send(GetDlgItem(w,101),WM_SETTEXT,0,LPARAM(L""));
+        until([&]{return send(GetDlgItem(w,102),LB_GETCOUNT)==500;},"clear search");close(w);
+        ks::writeClipboard(target,excluded(image));
+        w=open();send(w,WM_COMMAND,111);
+        until([&]{return editorText()==L"History fixture 498";},"paste plain text into native editor");
+        until([&]{return IsClipboardFormatAvailable(CF_DIB)&&!FindWindowW(L"KSwitcher.HistoryHost",nullptr);},"image clipboard restored after paste");
+        require(ks::decodeImage(ks::readClipboard(target,64*1024*1024)).width==pixels.width,"image clipboard survives history paste");
+        auto afterPaste=memory(process.hProcess);
+        std::cout<<"MEMORY after_paste_with_image_backup="<<afterPaste<<'\n';
+        require(afterPaste<base+2*1024*1024,"image clipboard backup stays outside resident");
+        ks::writeClipboard(target,excluded(ks::textClip(L"keep clipboard")));
+        w=open();send(GetDlgItem(w,101),WM_SETTEXT,0,LPARAM(L"Image"));
+        until([&]{return send(GetDlgItem(w,102),LB_GETCOUNT)==1;},"image search");
+        pastedImage=false;send(w,WM_COMMAND,110);
+        until([&]{return pastedImage;},"image paste reaches destination");
+        until([&]{return ks::readClipboard(target).text()==L"keep clipboard";},"clipboard restored after image paste");
+        std::cout<<"MEMORY after_image_paste="<<memory(process.hProcess)<<'\n';
+        require(memory(process.hProcess)<base+2*1024*1024,"image paste does not retain full bitmap in resident");
+        until([&]{return !FindWindowW(L"KSwitcher.HistoryHost",nullptr);},"image paste helper exits");
+        w=open();send(w,WM_COMMAND,113);
+        until([&]{history.reload();return history.entries().size()==499;},"resident removes selected image");
+        GetWindowThreadProcessId(w,&childPid);child=OpenProcess(SYNCHRONIZE,FALSE,childPid);
+        // Startup update checks temporarily reject exit; retry after that
+        // operation finishes instead of treating its guard as a host leak.
+        ULONGLONG nextExit{};
+        until([&]{
+            if(WaitForSingleObject(process.hProcess,0)==WAIT_OBJECT_0) return true;
+            if(GetTickCount64()>=nextExit) {
+                command(resident,99);nextExit=GetTickCount64()+500;
+            }
+            return false;
+        },"resident accepts exit after startup update check",30000);
+        until([&]{return WaitForSingleObject(child,0)==WAIT_OBJECT_0;},"resident shutdown closes history helper");
+        CloseHandle(child);resident=nullptr;
+        std::cout<<"PASS isolated history host suite\n";
+    } catch(const std::exception &e){std::cerr<<"FAIL "<<e.what()<<" editor="<<ks::utf8(editorText())<<" foreground="<<(GetForegroundWindow()==target)<<'\n';result=1;}
+    if(resident)try{command(resident,99);}catch(...){}
+    if(process.hProcess){if(WaitForSingleObject(process.hProcess,10000)!=WAIT_OBJECT_0){TerminateProcess(process.hProcess,1);WaitForSingleObject(process.hProcess,INFINITE);}CloseHandle(process.hProcess);}
+    if(captured)try{ks::writeClipboard(target,saved);}catch(...){result=1;}
+    if(target) DestroyWindow(target);
+    CoUninitialize();
+    return result;
+}

tests/image_capture.cpp

@@ -29,6 +29,12 @@ int main() {
                 "helper persists fingerprints and resident reloads them");
         require(entries.back().id==pinned && entries.back().pinned,"helper preserves existing pinned entry");
         auto restored=history.load(entries.front().id);
+        auto thumbnail=history.thumbnail(entries.front().id);
+        require(thumbnail.width==pixels.width && thumbnail.height==pixels.height && thumbnail.bgra==pixels.bgra,
+                "helper thumbnail preserves small image pixels");
+        bool thumbnailCancelled=false;
+        try {history.thumbnail(entries.front().id,[]{return true;});} catch(...) {thumbnailCancelled=true;}
+        require(thumbnailCancelled,"closed history cancels thumbnail work");
         auto has=[&](const ks::Format &expected) {
             return std::any_of(restored.formats.begin(),restored.formats.end(),[&](const ks::Format &actual) {
                 return (expected.name.empty()?actual.id==expected.id:actual.name==expected.name) && actual.data==expected.data;
@@ -55,6 +61,16 @@ int main() {
         }
         require(rejected && history.entries().size()==2,"oversized image is rejected without changing index");
         require(GetClipboardSequenceNumber()==sequence,"rejection leaves clipboard unchanged");
+        settings.maxImageMiB=20;
+        history.add(ks::Clip{{ks::imageDib(pixels)}},L"thumbnail fixture",settings);
+        auto largeId=history.entries().front().id;
+        thumbnail=history.thumbnail(largeId);
+        require(thumbnail.width==208 && thumbnail.height==104 && thumbnail.bgra.size()==208*104*4,
+                "large image returns only bounded thumbnail pixels");
+        history.remove(largeId);
+        bool missingRejected=false;
+        try {history.thumbnail(largeId);} catch(...) {missingRejected=true;}
+        require(missingRejected,"deleted image cannot be previewed or recreated");
         for(const auto &file:std::filesystem::directory_iterator(folder))
             require(file.path().extension()!=L".request","encrypted capture request is cleaned up");
     } catch(const std::exception &e) {std::cerr << "FAIL " << e.what() << '\n';result=1;}

tests/integration.cpp

@@ -309,6 +309,8 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 app->settings.autoCorrect = true;
                 app->settings.switchLayout = true;
                 app->settings.autoLanguages = {L"en", L"ru"};
+                // Direct fixture mutations bypass applySettings' dictionary preload.
+                app->autoPredictor.configure(L"dictionaries", app->settings.autoLanguages);
                 app->settings.cycle = {app->layouts[en].id, app->layouts[ru].id};
                 ActivateKeyboardLayout(app->layouts[en].handle, 0);
                 prepare(L"ghbdtn ", false);
@@ -682,6 +684,7 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 app->settings.autoCorrect = true;
                 app->settings.switchLayout = true;
                 app->settings.autoLanguages = {L"en", L"ru"};
+                app->autoPredictor.configure(L"dictionaries", app->settings.autoLanguages);
                 app->settings.cycle = {app->layouts[en].id, app->layouts[ru].id};
                 app->autoCorrector = ks::AutoCorrector{};
                 ActivateKeyboardLayout(app->layouts[en].handle, 0);
@@ -731,6 +734,7 @@ LRESULT CALLBACK procedure(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 });
                 require(uk != app->layouts.end(), "Ukrainian layout available for punctuation-key regression");
                 app->settings.autoLanguages = {L"en", L"uk"};
+                app->autoPredictor.configure(L"dictionaries", app->settings.autoLanguages);
                 app->settings.cycle = {app->layouts[en].id, uk->id};
                 app->settings.autoWords[L"uk"] = {L"робить"};
                 app->autoCorrector = ks::AutoCorrector{};