Release v0.6.38: avoid unnecessary RichEdit and cancel hidden history previews

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.24)
-project(KSwitcher VERSION 0.6.36 LANGUAGES CXX RC)
+project(KSwitcher VERSION 0.6.38 LANGUAGES CXX RC)
 if(NOT WIN32)
   message(FATAL_ERROR "KSwitcher uses native Windows APIs")
 endif()
@@ -48,6 +48,7 @@ else()
 endif()
 add_executable(KSwitcherOcrTests tests/ocr.cpp src/screenshot_launcher.cpp src/screenshot_activation.cpp src/app.cpp src/screenshot_notifications.cpp src/screenshot.cpp src/configuration.cpp src/ui.cpp resources/app.rc)
 target_link_libraries(KSwitcherOcrTests PRIVATE kscore)
+add_dependencies(KSwitcherOcrTests KSwitcherScreenshot)
 if(MSVC)
   set_property(TARGET kscore KSwitcher KSwitcherConfig KSwitcherScreenshot KSwitcherTests KSwitcherScrollTests KSwitcherIntegration KSwitcherInputTests KSwitcherOcrTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
   target_compile_options(kscore PRIVATE /W4 /utf-8)
@@ -65,6 +66,17 @@ else()
   target_link_options(KSwitcherOcrTests PRIVATE -static -static-libgcc -static-libstdc++)
 endif()
 enable_testing()
+add_executable(KSwitcherImageCaptureTests tests/image_capture.cpp)
+target_link_libraries(KSwitcherImageCaptureTests PRIVATE kscore)
+add_dependencies(KSwitcherImageCaptureTests KSwitcherScreenshot)
+if(MSVC)
+  target_compile_options(KSwitcherImageCaptureTests PRIVATE /utf-8)
+  set_property(TARGET KSwitcherImageCaptureTests PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+else()
+  target_link_options(KSwitcherImageCaptureTests PRIVATE -static -static-libgcc -static-libstdc++)
+endif()
+# Explicit interactive test: stop the resident first so its clipboard listener
+# does not capture the test fixtures. Like KSwitcherIntegration, not part of ctest.
 add_executable(KSwitcherDictionaryTests tests/dictionary.cpp)
 target_link_libraries(KSwitcherDictionaryTests PRIVATE kscore psapi)
 if(MSVC)

README.md

@@ -711,3 +711,17 @@ From v0.6.31, KSwitcher recovers trailing ordinary spaces omitted by Ctrl+C only
 ### Notification registration and Viber — v0.6.36
 
 Notification registration runs in KSwitcher.Screenshot.exe; keep all three executables together. Startup registration is asynchronous. Viber pastes allow 75 ms for clipboard notifications before Ctrl+V, retaining focus, ownership and selection checks. This mitigates an intermittent clipboard timing issue; it does not guarantee all Viber failures are resolved. UI Automation is unchanged.
+
+### Image history, OCR and duplicate fingerprints — v0.6.37
+
+Image clipboard capture and automatic/uncached manual history OCR run in short-lived KSwitcher.Screenshot.exe processes. Keep all three executables together. Original clipboard formats, image limits, privacy exclusions, Windows OCR, optional Tesseract and searchable encrypted OCR results are preserved. Background OCR is cancelled on shutdown or an OCR-profile change; late results do not recreate deleted entries.
+
+Consecutive duplicates use SHA-256 fingerprints inside the encrypted history index, including pixel fingerprints for equivalent image encodings. Older entries acquire fingerprints on first comparison without a bulk migration. Pins and OCR caches survive duplicate detection; non-consecutive copies still create separate entries. New text no longer loads the preceding image to rule out a duplicate. No shortcut, setting or default changed.
+
+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 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.
+
+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.

Release/README.md

@@ -1,17 +1,17 @@
 # Latest Windows release
 
-## v0.6.36 — 2026-11-04
+## v0.6.38 — 2026-11-04
 
 ## Changes
-- Notification registration now runs in the existing KSwitcher.Screenshot.exe helper. Startup launches it asynchronously and checks its exit status without blocking keyboard work; update notification registration waits in its background worker. Keep all three executables together. UI Automation and notification activation routes remain unchanged.
-- Viber paste now allows 75 ms for clipboard notifications to settle before sending Ctrl+V, then rechecks input, focus and clipboard ownership. This mitigates a suspected clipboard timing race: an intermittent corrupted Cyrillic paste was reproduced on the prior build. It is not a guarantee that every Viber timing issue is resolved; no blind paste retries or relaxed selection checks were added.
-- Added regression coverage for an explicitly selected middle range followed by a repeated shortcut without selection, preserving surrounding text, trailing spaces and the original clipboard. Updated the integration fixture to initialize shared predictor dictionaries.
-- Added reproducible standalone COM, UI Automation and Shell memory measurement tools. No shortcuts, settings or defaults changed.
+- 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.
+- 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.
+- 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.
+- 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.
 
 ## Validation
-Full staged build and tests cover dictionary equivalence for all 140,939 words, 105 sync checks, wheel batching, 304 native checks, 559 input checks, screenshot UI/PNG/registration, 48 updater checks and updater progress UI. Conversion integration passed 43 assertions. Eight actual Viber conversions passed on the development build, including two complete long-text layout cycles and selected/repeated middle-word conversion; test messages were not sent.
+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.
 
-A controlled fresh-launch before/after comparison (five private-working-set samples each, same installation and settings) measured 4.69 → 4.18 MiB, about 0.51 MiB saved. This is one local comparison, not a fixed memory limit or a long-term idle guarantee. The prior compact dictionaries and cache/idle memory reductions remain included.
+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.
 
 ## 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.

Release/SHA256SUMS.txt

@@ -1 +1 @@
-794d74113bddf13ffee7317cadee9c472bca3b84b3361796db58ff8023f66571  KSwitcher-win-x64.zip
+f430767d440581018e6adb33c153fb332318fa1eee5a162ddf32690d0b5a3391  KSwitcher-win-x64.zip

build.ps1

@@ -37,7 +37,7 @@ try {
     if ($LASTEXITCODE) { throw 'Configurator link failed' }
     Copy-Item -LiteralPath $configPath -Destination build/release/KSwitcher.Config.exe -Force
     $screenshotPath = Join-Path (Split-Path $executablePath) 'KSwitcher.Screenshot.exe'
-    & $compiler -mwindows -municode -static -s '-Wl,--gc-sections' build/core.o build/platform.o build/ocr.o build/screenshot.o build/screenshot_notifications.o build/screenshot_activation.o build/screenshot_main.o build/screenshot-res.o @libs -o $screenshotPath
+    & $compiler -mwindows -municode -static -s '-Wl,--gc-sections' build/core.o build/platform.o build/storage.o build/ocr.o build/screenshot.o build/screenshot_notifications.o build/screenshot_activation.o build/screenshot_main.o build/screenshot-res.o @libs -o $screenshotPath
     if ($LASTEXITCODE) { throw 'Screenshot link failed' }
     Copy-Item -LiteralPath $screenshotPath -Destination build/release/KSwitcher.Screenshot.exe -Force
     if ($Test) {
@@ -81,15 +81,21 @@ try {
         if ($LASTEXITCODE) { throw 'Updater progress UI tests failed' }
     }
     if ($Integration) {
+        $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' }
+        & $captureTest
+        if ($LASTEXITCODE) { throw 'Image capture tests failed' }
         & $compiler @common tests/integration.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/sync.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o build/KSwitcherIntegration.exe
         if ($LASTEXITCODE) { throw 'Integration test build failed' }
         & .\build\KSwitcherIntegration.exe
         if ($LASTEXITCODE) { throw 'Integration tests failed' }
     }
     if ($Ocr) {
-        & $compiler @common tests/ocr.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/sync.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o build/KSwitcherOcrTests.exe
+        $ocrTest = Join-Path (Split-Path $executablePath) 'KSwitcherOcrTests.exe'
+        & $compiler @common tests/ocr.cpp build/core.o build/platform.o build/autostart.o build/autocorrect.o build/storage.o build/sync.o build/ocr.o build/richtext.o build/update.o build/screenshot.o build/screenshot_launcher.o build/screenshot_activation.o build/screenshot_notifications.o build/app.o build/configuration.o build/ui.o build/screenshot-res.o @libs -static -s -o $ocrTest
         if ($LASTEXITCODE) { throw 'OCR test build failed' }
-        & .\build\KSwitcherOcrTests.exe
+        & $ocrTest
         if ($LASTEXITCODE) { throw 'OCR tests failed' }
     }
     foreach ($folder in @('build/dictionaries','build/release/dictionaries','build/staged/dictionaries')) {

resources/app.rc

@@ -9,8 +9,8 @@ IDC_SCREENSHOT_PENCIL CURSOR "icons/lucide/pencil.cur"
 1 RT_MANIFEST "app.manifest"
 201 RCDATA "update.ps1"
 1 VERSIONINFO
- FILEVERSION 0,6,36,0
- PRODUCTVERSION 0,6,36,0
+ FILEVERSION 0,6,38,0
+ PRODUCTVERSION 0,6,38,0
  FILEOS VOS_NT_WINDOWS32
  FILETYPE VFT_APP
 BEGIN
@@ -20,7 +20,7 @@ BEGIN
   BEGIN
    VALUE "FileDescription", "KSwitcher — native keyboard and clipboard utility"
    VALUE "ProductName", "KSwitcher"
-   VALUE "FileVersion", "0.6.36"
+   VALUE "FileVersion", "0.6.38"
   END
  END
  BLOCK "VarFileInfo"

src/app.cpp

@@ -536,7 +536,10 @@ void App::scheduleHistoryOcr(const Settings &config)
                         if (!entry.image || (entry.ocrState != 1 && entry.ocrProfile == profile)) continue;
                         try
                         {
-                            auto text = recognizeText(history->load(entry.id), config);
+                            auto text = history->recognizeImage(entry.id, config, [this, &profile] {
+                                std::lock_guard lock(jobsMutex);
+                                return stop || ocrProfile(historyOcrSettings) != profile;
+                            });
                             std::lock_guard lock(jobsMutex);
                             if (stop || ocrProfile(historyOcrSettings) != profile) continue;
                             if (history->saveOcr(entry.id, text, config))
@@ -1585,6 +1588,17 @@ void App::captureHistory()
                 for (auto &name : config.excluded)
                     if (lower(name) == lower(app))
                         return;
+                if (IsClipboardFormatAvailable(CF_DIB) || IsClipboardFormatAvailable(CF_DIBV5) ||
+                    IsClipboardFormatAvailable(CF_BITMAP) ||
+                    IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG")))
+                {
+                    if (history->captureImage(sequence, app, config))
+                    {
+                        scheduleHistoryOcr(config);
+                        PostMessageW(window, HistoryMessage, 0, 0);
+                    }
+                    return;
+                }
                 auto clip = readClipboard(window, (size_t)config.maxImageMiB * 1024 * 1024);
                 if (sequence != GetClipboardSequenceNumber())
                     return;
@@ -1622,7 +1636,9 @@ void App::recognizeEntry(std::wstring id)
             try
             {
                 auto cached = history->ocrText(id, ocrProfile(config));
-                auto text = cached ? *cached : recognizeText(history->load(id), config);
+                auto text = cached ? *cached : history->recognizeImage(id, config, [this] {
+                    std::lock_guard lock(jobsMutex); return stop;
+                });
                 if (!cached) history->saveOcr(id, text, config);
                 if (text.empty())
                 {

src/richtext.cpp

@@ -252,7 +252,7 @@ DWORD CALLBACK readStream(DWORD_PTR cookie, LPBYTE buffer, LONG size, LONG *read
     return 0;
 }
 } // namespace
-std::string richPreview(const Clip &clip)
+std::string richPreview(const Clip &clip, bool plainFallback)
 {
     for (const auto &f : clip.formats)
         if (f.name == L"Rich Text Format" && f.data.size() <= 65536)
@@ -276,6 +276,7 @@ std::string richPreview(const Clip &clip)
             {
             }
         }
+    if (!plainFallback) return {};
     auto text = clip.text();
     if (text.size() > 4096)
         text.resize(4096);

src/richtext.h

@@ -2,7 +2,7 @@
 #include "platform.h"
 namespace ks
 {
-std::string richPreview(const Clip &);
+std::string richPreview(const Clip &, bool plainFallback = true);
 HWND createRichText(HWND parent, int id, bool visible);
 bool setRichText(HWND, const std::string &);
 } // namespace ks

src/screenshot_main.cpp

@@ -1,5 +1,6 @@
 #include "screenshot.h"
 #include "screenshot_notifications.h"
+#include "storage.h"
 #include <commctrl.h>
 #include <shellapi.h>
 #include <roapi.h>
@@ -49,6 +50,14 @@ 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"--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);
+        auto initialized=CoInitializeEx(nullptr,COINIT_MULTITHREADED);
+        if(FAILED(initialized)) return 1;
+        int result=ocr ? ks::runHistoryOcr(request) : ks::runImageHistoryCapture(request);
+        CoUninitialize(); return result;
+    }
     if(argc>1 && std::wstring(argv[argc-1])==L"--write-log") {
         writeLog=true; --argc;
         ks::setLoggingEnabled(true);

src/storage.cpp

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <set>
 #include <sstream>
+#include <wincrypt.h>
 
 namespace ks
 {
@@ -374,9 +375,17 @@ Clip decodeClip(const Bytes &b)
 History::History(const std::filesystem::path &folder) : folder_(folder)
 {
     std::filesystem::create_directories(folder_);
+    loadIndex();
+}
+void History::loadIndex()
+{
+    std::vector<Entry> loaded;
     auto index = folder_ / L"index.dat";
     if (!std::filesystem::exists(index))
+    {
+        entries_.clear();
         return;
+    }
     auto j = parse(unprotect(readFile(index, 16 * 1024 * 1024)));
     if (!j.is_array() || j.size() > 10000)
         throw std::runtime_error("Invalid history index");
@@ -391,8 +400,88 @@ History::History(const std::filesystem::path &folder) : folder_(folder)
                    e.value("image", false),
                    e.value("files", false), e.value("ocrState", e.value("image", false) ? 1 : 0),
                    str(e, "ocrProfile", L"windows")};
+        if (e.value("fingerprintVersion", 0) == 1) {
+            item.contentHash = e.value("contentHash", std::string{});
+            item.imageHash = e.value("imageHash", std::string{});
+            item.pixelHash = e.value("pixelHash", std::string{});
+        }
         if (validId(item.id) && std::filesystem::exists(folder_ / (item.id + L".dat")))
-            entries_.push_back(std::move(item));
+            loaded.push_back(std::move(item));
+    }
+    entries_ = std::move(loaded);
+}
+bool History::captureImage(DWORD sequence, const std::wstring &app, const Settings &settings)
+{
+    // Serialize helper index changes with all resident history mutations. Only
+    // metadata is reloaded: GetClipboardData's image allocations die with the child.
+    std::lock_guard lock(mutex_);
+    if (sequence != GetClipboardSequenceNumber()) return false;
+    auto request = std::filesystem::absolute(folder_) / (L"capture-" + newSnippetId() + L".request");
+    struct Cleanup {
+        std::filesystem::path path;
+        ~Cleanup() { std::error_code ignored; std::filesystem::remove(path, ignored); }
+    } cleanup{request};
+    Json job{{"schema", 1}, {"sequence", sequence}, {"app", utf8(app)},
+             {"settings", Json::parse(encodeSettings(settings))}};
+    atomicWrite(request, protect(jsonBytes(job)));
+    auto helper = std::filesystem::path(executable()).parent_path() / L"KSwitcher.Screenshot.exe";
+    auto command = L"\"" + helper.wstring() + L"\" --capture-history \"" + 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(utf8(lastError(L"Cannot start image history helper")));
+    CloseHandle(process.hThread);
+    auto wait = WaitForSingleObject(process.hProcess, 30000);
+    DWORD result = ERROR_GEN_FAILURE;
+    if (wait != WAIT_OBJECT_0)
+    {
+        // Never release the index lock while a timed-out child can still write it.
+        TerminateProcess(process.hProcess, ERROR_TIMEOUT);
+        WaitForSingleObject(process.hProcess, INFINITE);
+    }
+    GetExitCodeProcess(process.hProcess, &result);
+    CloseHandle(process.hProcess);
+    loadIndex(); // Also reconcile any completed atomic save before a child failure.
+    if (wait != WAIT_OBJECT_0) throw std::runtime_error("Image history helper timed out");
+    if (result == 2) return false;
+    if (result == 3) throw std::runtime_error("Clipboard exceeds the configured size limit");
+    if (result) throw std::runtime_error("Image history helper failed: " + std::to_string(result));
+    return true;
+}
+int runImageHistoryCapture(const std::filesystem::path &request)
+{
+    try
+    {
+        if (!request.is_absolute() || !request.filename().wstring().starts_with(L"capture-") ||
+            request.extension() != L".request") return 1;
+        auto job = parse(unprotect(readFile(request, 4 * 1024 * 1024)));
+        if (job.at("schema") != 1) return 1;
+        auto sequence = job.at("sequence").get<DWORD>();
+        auto settings = decodeSettings(jsonBytes(job.at("settings")), readLayouts());
+        auto valid = [&] {
+            return settings.history && sequence == GetClipboardSequenceNumber() &&
+                !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"ExcludeClipboardContentFromMonitorProcessing")) &&
+                !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"Clipboard Viewer Ignore"));
+        };
+        if (!valid()) return 2;
+        if (!IsClipboardFormatAvailable(CF_DIB) && !IsClipboardFormatAvailable(CF_DIBV5) &&
+            !IsClipboardFormatAvailable(CF_BITMAP) &&
+            !IsClipboardFormatAvailable(RegisterClipboardFormatW(L"PNG"))) return 2;
+        auto clip = readClipboard(nullptr, size_t(settings.maxImageMiB) * 1024 * 1024);
+        if (!valid()) return 2;
+        for (const auto &format : clip.formats)
+            if (format.name == L"CanIncludeInClipboardHistory" && format.data.size() >= 4 &&
+                !format.data[0] && !format.data[1] && !format.data[2] && !format.data[3]) return 2;
+        History history(request.parent_path());
+        if (!valid()) return 2;
+        history.add(clip, str(job, "app"), settings);
+        return 0;
+    }
+    catch (const std::exception &e)
+    {
+        return std::string(e.what()) == "Clipboard exceeds the configured size limit" ? 3 : 1;
     }
 }
 void History::saveIndex()
@@ -406,7 +495,9 @@ void History::saveIndex()
                      {"at", e.at},
                      {"pinned", e.pinned},
                      {"image", e.image},
-                     {"files", e.files}, {"ocrState", e.ocrState}, {"ocrProfile", utf8(e.ocrProfile)}});
+                     {"files", e.files}, {"ocrState", e.ocrState}, {"ocrProfile", utf8(e.ocrProfile)},
+                     {"fingerprintVersion", 1}, {"contentHash", e.contentHash},
+                     {"imageHash", e.imageHash}, {"pixelHash", e.pixelHash}});
     atomicWrite(folder_ / L"index.dat", protect(jsonBytes(j)));
 }
 std::vector<Entry> History::entries() const
@@ -439,12 +530,10 @@ void History::prune(const Settings &s)
         entries_.erase(entries_.begin() + i);
     }
 }
-bool sameClipboardImage(const Clip &a, const Clip &b)
+static const Format *clipboardImageFormat(const Clip &c)
 {
     // OLE DataObject / Ole Private Data change when Snipping Tool republishes
     // the same capture. They are transport metadata, not image identity.
-    auto image = [](const Clip &c) -> const Format *
-    {
         if (!c.text().empty())
             return nullptr;
         for (const auto &f : c.formats)
@@ -458,8 +547,42 @@ bool sameClipboardImage(const Clip &a, const Clip &b)
                 if (f.id == id && !f.data.empty())
                     return &f;
         return nullptr;
-    };
-    const auto *left = image(a), *right = image(b);
+}
+static std::string clipboardHash(const Bytes &bytes)
+{
+    struct Hash {
+        HCRYPTPROV provider{}; HCRYPTHASH hash{};
+        ~Hash() { if (hash) CryptDestroyHash(hash); if (provider) CryptReleaseContext(provider, 0); }
+    } state;
+    if (!CryptAcquireContextW(&state.provider, nullptr, nullptr, PROV_RSA_AES, CRYPT_VERIFYCONTEXT) ||
+        !CryptCreateHash(state.provider, CALG_SHA_256, 0, 0, &state.hash) ||
+        !CryptHashData(state.hash, bytes.data(), static_cast<DWORD>(bytes.size()), 0))
+        throw std::runtime_error("Cannot hash clipboard data");
+    BYTE digest[32]{}; DWORD size = sizeof(digest);
+    if (!CryptGetHashParam(state.hash, HP_HASHVAL, digest, &size, 0) || size != sizeof(digest))
+        throw std::runtime_error("Cannot read clipboard hash");
+    static constexpr char hex[] = "0123456789abcdef";
+    std::string result; result.reserve(64);
+    for (auto b : digest) { result += hex[b >> 4]; result += hex[b & 15]; }
+    return result;
+}
+static void imageFingerprints(Entry &entry, const Clip &clip, bool decodePixels = true)
+{
+    const auto *image = clipboardImageFormat(clip);
+    if (!image) return;
+    if (entry.imageHash.empty())
+        entry.imageHash = std::to_string(image->id) + ":" + utf8(image->name) + ":" + clipboardHash(image->data);
+    if (!decodePixels) return;
+    try {
+        auto pixels = decodeImage(clip);
+        entry.pixelHash = std::to_string(pixels.width) + "x" + std::to_string(pixels.height) + ":" + clipboardHash(pixels.bgra);
+    } catch (const std::exception &) {
+        // Undecodable images can still be compared by their original bytes.
+    }
+}
+bool sameClipboardImage(const Clip &a, const Clip &b)
+{
+    const auto *left = clipboardImageFormat(a), *right = clipboardImageFormat(b);
     if (!left || !right)
         return false;
     if (left->id == right->id && left->name == right->name && left->data == right->data)
@@ -483,16 +606,41 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
     auto data = encodeClip(clip);
     if (data.size() > uint64_t(s.maxImageMiB) * 1024 * 1024)
         return;
+    bool image = false, files = false;
+    for (const auto &f : clip.formats)
+    {
+        image |= f.id == CF_DIB || f.id == CF_DIBV5 || f.name == L"PNG";
+        files |= f.id == CF_HDROP;
+    }
     std::lock_guard lock(mutex_);
-    // Compare only the newest record; never keep image payloads in the resident index.
-    if (!entries_.empty())
+    Entry fingerprints;
+    fingerprints.contentHash = clipboardHash(data);
+    if (!entries_.empty() && entries_.front().contentHash == fingerprints.contentHash)
+        return;
+    imageFingerprints(fingerprints, clip, false);
+    if (!entries_.empty() && !fingerprints.imageHash.empty() && entries_.front().imageHash == fingerprints.imageHash)
+        return;
+    imageFingerprints(fingerprints, clip);
+    // Different payload kinds cannot be duplicates. Consult the index first so
+    // copying text after a screenshot never loads/decrypts the previous image.
+    if (!entries_.empty() && entries_.front().image == image && entries_.front().files == files)
     {
         try
         {
-            auto previous = load(entries_.front().id);
-            if (encodeClip(previous) == data || sameClipboardImage(previous, clip))
+            auto &previous = entries_.front();
+            bool migrated = previous.contentHash.empty();
+            if (migrated) {
+                auto oldClip = load(previous.id);
+                previous.contentHash = clipboardHash(encodeClip(oldClip));
+                imageFingerprints(previous, oldClip);
+            }
+            if (previous.contentHash == fingerprints.contentHash ||
+                (!fingerprints.imageHash.empty() && previous.imageHash == fingerprints.imageHash) ||
+                (!fingerprints.pixelHash.empty() && previous.pixelHash == fingerprints.pixelHash)) {
+                if (migrated) saveIndex();
                 return;
             }
+        }
         catch (...)
         {
         }
@@ -506,12 +654,6 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
     auto encrypted = protect(data);
     atomicWrite(folder_ / (id + L".dat"), encrypted);
     auto text = clip.text();
-    bool image = false, files = false;
-    for (auto &f : clip.formats)
-    {
-        image |= f.id == CF_DIB || f.id == CF_DIBV5 || f.name == L"PNG";
-        files |= f.id == CF_HDROP;
-    }
     if (text.empty())
         text = files ? L"[Files]" : image ? L"[Image]" : L"[Clipboard data]";
     for (auto &c : text)
@@ -524,7 +666,8 @@ void History::add(const Clip &clip, const std::wstring &app, const Settings &s)
     entries_.insert(entries_.begin(),
                     Entry{id, text, app, encrypted.size(),
                           (uint64_t(now.dwHighDateTime) << 32) | now.dwLowDateTime, false, image, files,
-                          image ? 1 : 0, ocrProfile(s)});
+                          image ? 1 : 0, ocrProfile(s), std::move(fingerprints.contentHash),
+                          std::move(fingerprints.imageHash), std::move(fingerprints.pixelHash)});
     prune(s);
     saveIndex();
 }
@@ -563,6 +706,80 @@ void History::clear()
         std::filesystem::remove(folder_ / (e.id + L".ocr"), ec);
     }
 }
+std::wstring History::recognizeImage(const std::wstring &id, const Settings &settings,
+                                    const std::function<bool()> &cancelled) const
+{
+    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 response = request; response += L".result";
+    struct Cleanup {
+        std::filesystem::path request, response;
+        ~Cleanup() {
+            std::error_code ignored;
+            std::filesystem::remove(request, ignored);
+            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"\"";
+    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(utf8(lastError(L"Cannot start history OCR helper")));
+    CloseHandle(process.hThread);
+    struct Child {
+        HANDLE handle;
+        ~Child() {
+            if (WaitForSingleObject(handle, 0) != WAIT_OBJECT_0) {
+                TerminateProcess(handle, ERROR_CANCELLED);
+                WaitForSingleObject(handle, INFINITE);
+            }
+            CloseHandle(handle);
+        }
+    } child{process.hProcess};
+    auto deadline = GetTickCount64() + 60000;
+    for (;;) {
+        auto wait = WaitForSingleObject(child.handle, 100);
+        if (wait == WAIT_OBJECT_0) break;
+        if (wait != WAIT_TIMEOUT) throw std::runtime_error("Cannot wait for history OCR helper");
+        if (cancelled && cancelled()) throw std::runtime_error("History OCR cancelled");
+        if (GetTickCount64() >= deadline) throw std::runtime_error("History OCR helper timed out");
+    }
+    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)));
+    if (reply.at("schema") != 1 || str(reply, "id") != id)
+        throw std::runtime_error("Invalid history OCR response");
+    return str(reply, "text");
+}
+int runHistoryOcr(const std::filesystem::path &request)
+{
+    try {
+        if (!request.is_absolute() || !request.filename().wstring().starts_with(L"ocr-") ||
+            request.extension() != L".request") return 1;
+        auto job = parse(unprotect(readFile(request, 1024 * 1024)));
+        auto id = str(job, "id");
+        if (job.at("schema") != 1 || !validId(id)) return 1;
+        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";
+        atomicWrite(response, protect(jsonBytes(Json{{"schema", 1}, {"id", utf8(id)}, {"text", text}})));
+        return 0;
+    } catch (...) { return 1; }
+}
 bool History::saveOcr(const std::wstring &id, const std::optional<std::wstring> &text, const Settings &settings)
 {
     std::lock_guard lock(mutex_);

src/storage.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "platform.h"
 #include <mutex>
+#include <functional>
 namespace ks
 {
 Settings loadSettings(const std::filesystem::path &, const std::vector<Layout> &);
@@ -15,6 +16,7 @@ struct Entry
     bool pinned{}, image{}, files{};
     int ocrState{}; // 0: legacy/not applicable, 1: pending, 2: saved, 3: failed
     std::wstring ocrProfile = L"windows";
+    std::string contentHash, imageHash, pixelHash;
 };
 class History
 {
@@ -22,6 +24,7 @@ class History
     std::vector<Entry> entries_;
     mutable std::mutex mutex_;
     void saveIndex();
+    void loadIndex();
     void prune(const Settings &);
 
   public:
@@ -29,6 +32,9 @@ class History
     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;
     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 &);
@@ -39,4 +45,6 @@ class History
 Bytes encodeClip(const Clip &);
 Clip decodeClip(const Bytes &);
 bool sameClipboardImage(const Clip &, const Clip &);
+int runImageHistoryCapture(const std::filesystem::path &request);
+int runHistoryOcr(const std::filesystem::path &request);
 } // namespace ks

src/ui.cpp

@@ -468,12 +468,17 @@ struct SearchResult
     uint64_t generation;
     std::vector<Entry> items;
 };
+struct TextPreview
+{
+    std::string rtf;
+    std::wstring plain;
+};
 struct PreviewResult
 {
     uint64_t generation;
     std::wstring id;
     Pixels pixels;
-    std::string rtf;
+    TextPreview text;
 };
 struct HistoryView
 {
@@ -481,8 +486,9 @@ struct HistoryView
     std::vector<Entry> items;
     std::wstring rememberedSelection, rememberedTop;
     uint64_t generation{};
+    std::shared_ptr<std::atomic<bool>> previewActive = std::make_shared<std::atomic<bool>>(true);
     std::map<std::wstring, Pixels> thumbnails;
-    std::map<std::wstring, std::string> richTexts;
+    std::map<std::wstring, TextPreview> richTexts;
     HWND rich{};
     std::set<std::wstring> pending;
     bool scrolling{};
@@ -504,6 +510,8 @@ std::wstring selected(HWND w, HistoryView *v)
 }
 void search(HWND w, HistoryView *v)
 {
+    v->previewActive->store(false);
+    v->previewActive = std::make_shared<std::atomic<bool>>(true);
     v->closed = false;
     auto q = value(w, 101);
     auto generation = ++v->generation;
@@ -532,23 +540,31 @@ void requestPreview(HWND w, HistoryView *v, const Entry &entry)
     if (v->thumbnails.contains(id) || v->richTexts.contains(id) || !v->pending.insert(id).second)
         return;
     auto generation = v->generation;
+    auto active = v->previewActive;
     auto *app = v->app;
     app->enqueue(
-        [w, app, id, generation, image]
+        [w, app, id, generation, image, active]
         {
+            if (!active->load()) return;
             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);
-                else
-                    result->rtf = richPreview(clip);
+                else {
+                    result->text.rtf = richPreview(clip, false);
+                    if (result->text.rtf.empty()) {
+                        result->text.plain = clip.text();
+                        if (result->text.plain.size() > 4096) result->text.plain.resize(4096);
+                    }
+                }
             }
             catch (const std::exception &)
             {
             }
-            if (!PostMessageW(w, PreviewMessage, 0, (LPARAM)result))
+            if (!active->load() || !PostMessageW(w, PreviewMessage, 0, (LPARAM)result))
                 delete result;
         });
 }
@@ -602,9 +618,13 @@ void drawHistoryRow(HWND w, HistoryView *v, const DRAWITEMSTRUCT &draw)
     if (!entry.image && !entry.files)
     {
         auto rich = v->richTexts.find(entry.id);
-        if (rich != v->richTexts.end() && v->rich && !rich->second.empty())
+        if (rich != v->richTexts.end() && rich->second.rtf.empty())
+            text = (entry.pinned ? L"★  " : L"") + rich->second.plain;
+        if (rich != v->richTexts.end() && !rich->second.rtf.empty() && !v->rich)
+            v->rich = createRichText(w, 105, false);
+        if (rich != v->richTexts.end() && v->rich && !rich->second.rtf.empty())
         {
-            setRichText(v->rich, rich->second);
+            setRichText(v->rich, rich->second.rtf);
             CHARFORMAT2W format{};
             format.cbSize = sizeof(format);
             format.dwMask = CFM_COLOR;
@@ -825,14 +845,14 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
                 visible.insert(v->items[i].id);
                 if(v->items[i].id==result->id) { changed=intersection; repaint=true; }
             }
-            if (!result->rtf.empty())
-                v->richTexts[result->id] = std::move(result->rtf);
+            if (!result->text.rtf.empty() || !result->text.plain.empty())
+                v->richTexts[result->id] = std::move(result->text);
             else
                 v->thumbnails[result->id] = std::move(result->pixels);
             trimHistoryPreviews(v->thumbnails,visible,32,HistoryThumbnailBudget,
                                 [](const Pixels &p) { return p.bgra.capacity(); });
             trimHistoryPreviews(v->richTexts,visible,32,HistoryRichTextBudget,
-                                [](const std::string &s) { return s.capacity(); });
+                                [](const TextPreview &s) { return s.rtf.capacity() + s.plain.capacity() * sizeof(wchar_t); });
             if(repaint) InvalidateRect(list,&changed,FALSE);
             return 0;
         }
@@ -889,18 +909,19 @@ LRESULT CALLBACK historyProc(HWND w, UINT msg, WPARAM wp, LPARAM lp)
             v->rememberedTop = top >= 0 && top < (int)v->items.size() ? v->items[top].id : L"";
             KillTimer(w, 1);
             v->closed = true;
+            v->previewActive->store(false);
             ++v->generation; // Discard search/preview results queued before closing.
             ShowWindow(w, SW_HIDE);
             SendDlgItemMessageW(w,102,LB_RESETCONTENT,0,0);
             std::vector<Entry>().swap(v->items);
             v->thumbnails.clear();
             v->richTexts.clear();
-            if (v->rich)
-                SetWindowTextW(v->rich, L"");
+            if (v->rich) SetWindowTextW(v->rich, L"");
             v->pending.clear();
             return 0;
         }
         case WM_NCDESTROY:
+            v->previewActive->store(false);
             disposeFont(w);
             v->app->historyWindow = nullptr;
             delete v;
@@ -1702,7 +1723,6 @@ void showHistory(App &app, bool visible)
         HWND w = makeWindow(app, L"KSwitcher.History", L"Clipboard history", historyProc, 760, 500);
         app.historyWindow = w;
         windowLayoutState(w)->history = true;
-        ((HistoryView *)GetWindowLongPtrW(w, GWLP_USERDATA))->rich = createRichText(w, 105, false);
         label(w, L"&Search clipboard history", 16, 12, 500);
         edit(w, 101, 16, 38, 728);
         auto list = control(w, L"LISTBOX", L"",

src/update.h

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

tests/image_capture.cpp

@@ -0,0 +1,68 @@
+// Interactive clipboard test. Run with the resident stopped; the original
+// clipboard is restored. The helper must be beside this test executable.
+#include "storage.h"
+#include "ocr.h"
+#include <algorithm>
+#include <iostream>
+static void require(bool ok,const char *name) {
+    if(!ok) throw std::runtime_error(name);
+    std::cout << "PASS " << name << '\n';
+}
+int main() {
+    CoInitializeEx(nullptr,COINIT_MULTITHREADED);
+    HWND owner=CreateWindowExW(0,L"STATIC",L"Capture test",0,0,0,0,0,HWND_MESSAGE,nullptr,nullptr,nullptr);
+    ks::Clip saved; bool captured=false; int result=0;
+    auto folder=std::filesystem::temp_directory_path()/(L"KSwitcher-image-capture-"+std::to_wstring(GetCurrentProcessId()));
+    try {
+        saved=ks::readClipboard(owner,128*1024*1024); captured=true;
+        ks::Settings settings; settings.history=true;
+        ks::History history(folder);
+        history.add(ks::textClip(L"keep pinned"),L"test",settings);
+        auto pinned=history.entries().front().id; history.pin(pinned);
+        ks::Pixels pixels{32,16,ks::Bytes(32*16*4,255)};
+        ks::Clip image{{ks::imageDib(pixels),{0,L"PNG",ks::encodePng(pixels)}}};
+        auto sequence=ks::writeClipboard(owner,image);
+        require(history.captureImage(sequence,L"capture test",settings),"helper captures image");
+        auto entries=history.entries();
+        require(entries.size()==2 && entries.front().image && entries.front().ocrState==1,"resident reloads metadata with pending OCR");
+        require(entries.front().contentHash.size()==64 && !entries.front().pixelHash.empty(),
+                "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 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;
+            });
+        };
+        require(has(image.formats[0]) && has(image.formats[1]),
+                "encrypted history preserves both image representations");
+        require(ks::readFile(folder/(entries.front().id+L".dat"),1024*1024)!=ks::encodeClip(restored),"saved image is encrypted");
+        require(GetClipboardSequenceNumber()==sequence,"capture leaves clipboard unchanged");
+        require(history.captureImage(sequence,L"capture test",settings) && history.entries().size()==2,"duplicate capture is not added");
+        ks::writeClipboard(owner,ks::textClip(L"new clipboard"));
+        require(!history.captureImage(sequence,L"stale",settings) && history.entries().size()==2,"stale request does not save another clipboard");
+        for(auto name : {L"ExcludeClipboardContentFromMonitorProcessing",L"Clipboard Viewer Ignore",L"CanIncludeInClipboardHistory"}) {
+            auto blocked=image; blocked.formats.push_back({0,name,ks::Bytes(4,0)});
+            sequence=ks::writeClipboard(owner,blocked);
+            require(!history.captureImage(sequence,L"excluded",settings) && history.entries().size()==2,"clipboard privacy flag prevents capture");
+        }
+        pixels={1024,512,ks::Bytes(1024*512*4,255)};
+        sequence=ks::writeClipboard(owner,ks::Clip{{ks::imageDib(pixels)}});
+        settings.maxImageMiB=1;
+        bool rejected=false;
+        try {history.captureImage(sequence,L"oversized",settings);} catch(const std::exception &e) {
+            rejected=std::string(e.what())=="Clipboard exceeds the configured size limit";
+        }
+        require(rejected && history.entries().size()==2,"oversized image is rejected without changing index");
+        require(GetClipboardSequenceNumber()==sequence,"rejection leaves clipboard unchanged");
+        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;}
+    if(captured) try {ks::writeClipboard(owner,saved);} catch(...) {result=1;}
+    DestroyWindow(owner); CoUninitialize();
+    // Remove only the exact PID-specific fixture under the system temp directory.
+    std::error_code ignored;
+    if(std::filesystem::weakly_canonical(folder).parent_path()==std::filesystem::weakly_canonical(std::filesystem::temp_directory_path()))
+        std::filesystem::remove_all(folder,ignored);
+    return result;
+}

tests/input.cpp

@@ -912,6 +912,7 @@ int main(int argc, char **argv) {
             ks::showHistory(app,false);
             auto history=app.historyWindow;
             require(history&&!IsWindowVisible(history),"history layout tested without changing focus");
+            require(!GetDlgItem(history,105),"history creates no RichEdit control before formatted content is displayed");
             {
                 app.history=std::make_unique<ks::History>(temp/L"history-search");
                 app.history->add(ks::textClip(L"згенеруй приклад"),L"test",app.settings);
@@ -941,7 +942,9 @@ int main(int argc, char **argv) {
                 require(GetFocus()==originalFocus,"history search preserves focus");
                 SendDlgItemMessageW(history,102,LB_SETCURSEL,1,0);
                 ks::refreshHistory(app); // A result may still be in flight when closing.
-                SendMessageW(history,WM_CLOSE,0,0);
+                SendDlgItemMessageW(history,101,WM_KEYDOWN,VK_ESCAPE,0);
+                require(!IsWindowVisible(history) && !GetDlgItem(history,105),
+                        "Escape closes history and leaves no RichEdit control");
                 SendMessageW(history,WM_TIMER,1,0); // KillTimer cannot retract a posted timer message.
                 require(pumpUntil(0),"closing history releases list strings");
                 auto until=GetTickCount64()+250;

tests/ocr.cpp

@@ -59,6 +59,24 @@ int main(int argc, char **argv)
             app.settings.history = true;
             app.history->add(clip, L"OCR fixture", app.settings);
             auto id = app.history->entries().front().id;
+            auto isolated = app.history->recognizeImage(id, config);
+            if (isolated != text) throw std::runtime_error("Helper and in-process OCR results differ");
+            bool cancelled = false;
+            try { app.history->recognizeImage(id, config, [] { return true; }); }
+            catch (const std::exception &) { cancelled = true; }
+            if (!cancelled) throw std::runtime_error("Cancelled OCR request was executed");
+            auto invalid = config;
+            invalid.useTesseract = true;
+            invalid.tesseractPath = (temp / L"missing-tesseract.exe").wstring();
+            bool failed = false;
+            try { app.history->recognizeImage(id, invalid); }
+            catch (const std::exception &) { failed = true; }
+            if (!failed || app.history->entries().front().ocrState != 1)
+                throw std::runtime_error("Failed helper modified history metadata");
+            for (const auto &file : std::filesystem::directory_iterator(temp / L"history"))
+                if (file.path().filename().wstring().starts_with(L"ocr-"))
+                    throw std::runtime_error("OCR helper left temporary files");
+            std::cout << "PASS isolated OCR equivalence, cancellation, failure and encrypted IPC cleanup\n";
             if (tesseract)
             {
                 app.history->saveOcr(id, L"old Windows result", app.settings);

tests/tests.cpp

@@ -4,6 +4,7 @@
 #include "richtext.h"
 #include "storage.h"
 #include "diagnostics.h"
+#include "json.hpp"
 #include <algorithm>
 #include <iostream>
 #include <map>
@@ -189,6 +190,8 @@ int main(int argc, char **argv)
                 "HTML entities and Unicode survive without script text");
         require((effects(0, 6) & CFE_BOLD) != 0, "inline CSS bold is rendered");
         auto plain = ks::textClip(L"{\\literal} Привіт");
+        require(ks::richPreview(plain, false).empty(), "plain history preview does not require RichEdit");
+        require(!ks::richPreview(styled, false).empty(), "formatted history preview retains HTML rendering");
         ks::setRichText(rich, ks::richPreview(plain));
         GetWindowTextW(rich, rendered, 256);
         require(std::wstring(rendered) == plain.text(), "plain Unicode and RTF metacharacters are escaped");
@@ -635,6 +638,55 @@ int main(int argc, char **argv)
                     "Snipping Tool republish retains one pinned history entry");
             history.add(changedImage, L"SnippingTool", defaults);
             require(history.entries().size() == 2, "a new screenshot is retained");
+            auto copiedText = ks::textClip(L"text after screenshot");
+            history.add(copiedText, L"Editor", defaults);
+            history.add(copiedText, L"Editor", defaults);
+            require(history.entries().size() == 3 && !history.entries().front().image,
+                    "text after screenshot is retained and consecutive text duplicates are skipped");
+            history.add(changedImage, L"SnippingTool", defaults);
+            history.add(changedImage, L"SnippingTool", defaults);
+            require(history.entries().size() == 4 && history.entries().front().image,
+                    "image after text is retained and consecutive image duplicates are skipped");
+            history.add(withText, L"Editor", defaults);
+            require(history.entries().size() == 5,
+                    "mixed image and text payload is not discarded by metadata prefilter");
+        }
+        {
+            auto folder = temp / L"fingerprints";
+            ks::Settings defaults;
+            ks::History history(folder);
+            history.add(firstImage, L"test", defaults);
+            auto id = history.entries().front().id;
+            history.pin(id);
+            history.saveOcr(id, L"retained OCR", defaults);
+            ks::History reopened(folder);
+            require(reopened.entries().front().contentHash.size() == 64,
+                    "SHA-256 fingerprint survives encrypted index reload");
+            // Deny payload reads: duplicates must still be detected using only the index.
+            auto handle = CreateFileW((folder / (id + L".dat")).c_str(), GENERIC_READ, 0, nullptr,
+                                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+            require(handle != INVALID_HANDLE_VALUE, "lock image payload for no-read regression");
+            reopened.add(firstImage, L"test", defaults);
+            reopened.add(secondImage, L"test", defaults);
+            reopened.add(recoded, L"test", defaults);
+            CloseHandle(handle);
+            require(reopened.entries().size() == 1 && reopened.entries().front().pinned &&
+                    reopened.ocrText(id) == std::optional<std::wstring>(L"retained OCR"),
+                    "exact, OLE and pixel-equivalent duplicates need no payload read and retain pin/OCR");
+            auto index = nlohmann::json::parse(ks::unprotect(ks::readFile(folder / L"index.dat", 1024*1024)));
+            for (auto &entry : index)
+                for (auto key : {"fingerprintVersion", "contentHash", "imageHash", "pixelHash"}) entry.erase(key);
+            auto legacy = index.dump();
+            ks::atomicWrite(folder / L"index.dat", ks::protect(ks::Bytes(legacy.begin(), legacy.end())));
+            ks::History migrated(folder);
+            migrated.add(secondImage, L"test", defaults);
+            ks::History persisted(folder);
+            require(persisted.entries().size() == 1 && persisted.entries().front().contentHash.size() == 64,
+                    "legacy duplicate migrates fingerprints without adding or losing an entry");
+            persisted.add(changedImage, L"test", defaults);
+            require(persisted.entries().size() == 2, "pixel fingerprint preserves genuinely changed images");
+            persisted.add(firstImage, L"test", defaults);
+            require(persisted.entries().size() == 3, "hash deduplication remains consecutive rather than global");
         }
         ks::Settings settings;
         settings.writeLog = false;