Fix chats randomly disappearing from /resume after restart

The per-workspace chat cache dir was named <prefix>_<hash> with the prefix
taken from the first workspace folder, so folder order/parent differences
resolved the same workspace to different dirs and split chats across them.
Key the dir by the order-independent hash, keep the prefix cosmetic, and
merge any fragmented dirs into the canonical one on load (newest chat wins),
recovering already-stranded chats.

eca-intellij #20

Author: ericdallo

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - New `eca read-chat` CLI command for streaming raw chat DB cache records as JSONL.
+- Fix chats randomly disappearing from `/resume` after restart: key the workspace chat cache on the order-independent workspace hash and merge caches fragmented across differently-named dirs. (eca-intellij #20)
 
 ## 0.136.0
 

src/eca/cache.clj

@@ -17,14 +17,20 @@
                        (io/file (System/getProperty "user.home") ".cache"))]
     (io/file cache-home "eca")))
 
+(defn ^:private sorted-workspace-paths
+  "Absolute workspace paths, de-duplicated and sorted, so the result is stable
+   regardless of the order the editor reports its workspace folders."
+  [workspaces uri->filename-fn]
+  (->> workspaces
+       (map #(str (fs/absolutize (fs/file (uri->filename-fn (:uri %))))))
+       (distinct)
+       (sort)))
+
 (defn workspaces-hash
-  "Returns an 8-char base64 (URL-safe, no padding) hash key for the given workspace set."
+  "Returns an 8-char base64 (URL-safe, no padding) hash key for the given workspace set.
+   Order-independent: the same set of folders always yields the same hash."
   [workspaces uri->filename-fn]
-  (let [paths (->> workspaces
-                   (map #(str (fs/absolutize (fs/file (uri->filename-fn (:uri %))))))
-                   (distinct)
-                   (sort))
-        joined (string/join ":" paths)
+  (let [joined (string/join ":" (sorted-workspace-paths workspaces uri->filename-fn))
         md (java.security.MessageDigest/getInstance "SHA-256")
         digest (.digest (doto md (.update (.getBytes joined "UTF-8"))))
         encoder (-> (java.util.Base64/getUrlEncoder)
@@ -38,44 +44,50 @@
 
 (defn ^:private workspace-dir-name
   "Returns a human-readable directory name for the workspace cache.
-   Format: <sanitized-project-name>_<hash>, or just <hash> if no name is available."
+   Format: <sanitized-project-name>_<hash>, or just <hash> if no name is available.
+   The prefix comes from the sorted-first workspace path so it stays stable
+   regardless of folder order; it is purely cosmetic - the <hash> is the identity."
   [workspaces uri->filename-fn]
   (let [hash (workspaces-hash workspaces uri->filename-fn)
-        first-uri (some-> workspaces first :uri)
-        project-name (when first-uri
-                       (some-> (uri->filename-fn first-uri)
-                               fs/file-name
-                               str
-                               not-empty))
+        project-name (some-> (first (sorted-workspace-paths workspaces uri->filename-fn))
+                             fs/file-name
+                             str
+                             not-empty)
         sanitized (when project-name
                     (let [s (string/replace project-name #"[^a-zA-Z0-9._-]" "_")]
                       (subs s 0 (min max-prefix-length (count s)))))]
     (if (not-empty sanitized)
       (str sanitized "_" hash)
       hash)))
 
-(defn ^:private migrate-workspace-cache-dir!
-  "Migrates old hash-only workspace cache directory to new human-readable format."
-  [^File old-dir ^File new-dir]
-  (try
-    (fs/move old-dir new-dir)
-    (logger/info logger-tag (str "Migrated workspace cache from " old-dir " to " new-dir))
-    (catch Exception e
-      (logger/warn logger-tag "Failed to migrate workspace cache directory:" (.getMessage e)))))
-
 (defn workspace-cache-file
-  "Returns a File object for a workspace-specific cache file."
+  "Returns a File object for a workspace-specific cache file.
+   The directory identity is the order-independent <hash>; the human-readable
+   prefix is cosmetic. Healing of caches fragmented across differently-named
+   dirs for the same workspace is handled by eca.db/consolidate-workspace-cache!."
   [workspaces filename uri->filename-fn]
-  (let [dir-name (workspace-dir-name workspaces uri->filename-fn)
-        hash-only (workspaces-hash workspaces uri->filename-fn)
-        base (global-dir)
-        new-dir (io/file base dir-name)
-        old-dir (io/file base hash-only)]
-    (when (and (not= dir-name hash-only)
-               (not (fs/exists? new-dir))
-               (fs/exists? old-dir))
-      (migrate-workspace-cache-dir! old-dir new-dir))
-    (io/file new-dir filename)))
+  (io/file (global-dir) (workspace-dir-name workspaces uri->filename-fn) filename))
+
+(defn redundant-workspace-cache-files
+  "Returns the cache files named `filename` that live in directories belonging to
+   the same workspace set as the canonical dir but under a different name - i.e.
+   legacy hash-only dirs, or dirs prefixed from a different folder order. The
+   canonical dir is excluded. Used to heal fragmented chat caches."
+  [workspaces filename uri->filename-fn]
+  (let [hash (workspaces-hash workspaces uri->filename-fn)
+        canonical-dir-name (workspace-dir-name workspaces uri->filename-fn)
+        base (global-dir)]
+    (if (fs/exists? base)
+      (->> (fs/list-dir base)
+           (filter fs/directory?)
+           (map #(str (fs/file-name %)))
+           (filter (fn [n] (or (= n hash)
+                               (string/ends-with? n (str "_" hash)))))
+           (remove #(= % canonical-dir-name))
+           (map #(io/file base % filename))
+           (filter fs/exists?)
+           (vec))
+      [])))
 
 (def ^:private tool-call-outputs-dir-name "toolCallOutputs")
 (def ^:private plugins-dir-name "plugins")

src/eca/db.clj

@@ -264,14 +264,58 @@
     (when (= version (:version cache))
       cache)))
 
+(defn ^:private chat-recency [chat]
+  (or (:updated-at chat) (:created-at chat) 0))
+
+(defn ^:private merge-chats
+  "Merges chat maps into one. On a duplicate chat id, keeps the entry with the
+   greater recency (`:updated-at`, falling back to `:created-at`), so a newer
+   chat is never clobbered by a staler copy living in another cache dir."
+  [chat-maps]
+  (reduce (fn [acc chats]
+            (reduce-kv (fn [m id chat]
+                         (if-let [existing (get m id)]
+                           (if (> (chat-recency chat) (chat-recency existing))
+                             (assoc m id chat)
+                             m)
+                           (assoc m id chat)))
+                       acc
+                       chats))
+          {}
+          chat-maps))
+
+(defn consolidate-workspace-cache!
+  "Heals chat caches that fragmented across multiple directories for the same
+   workspace set (legacy hash-only dirs, or dirs prefixed from a different folder
+   order). Merges every matching cache into the canonical dir (newest chat wins)
+   and removes the redundant dirs. Best-effort and idempotent."
+  [workspaces metrics]
+  (try
+    (let [redundant (cache/redundant-workspace-cache-files workspaces "db.transit.json" shared/uri->filename)]
+      (when (seq redundant)
+        (let [canonical (transit-global-by-workspaces-db-file workspaces)
+              caches (keep #(read-cache % metrics) (cons canonical redundant))
+              merged (merge-chats (map :chats caches))]
+          (logger/info logger-tag (str "Consolidating " (count redundant) " redundant workspace cache dir(s) into " canonical))
+          (upsert-cache! {:chats merged :version version} canonical metrics)
+          (doseq [^java.io.File f redundant]
+            (try
+              (fs/delete-tree (.getParentFile f))
+              (catch Throwable e
+                (logger/warn logger-tag (str "Could not remove redundant cache dir " (.getParentFile f)) e)))))))
+    (catch Throwable e
+      (logger/warn logger-tag "Could not consolidate workspace cache" e))))
+
 (defn load-db-from-cache! [db* config metrics]
   (when-not (:pureConfig config)
     (when-let [global-cache (read-global-cache metrics)]
       (logger/info logger-tag "Loading from global-cache caches...")
       (swap! db* shared/deep-merge global-cache))
-    (when-let [global-by-workspace-cache (read-global-by-workspaces-cache (:workspace-folders @db*) metrics)]
-      (logger/info logger-tag "Loading from workspace-cache caches...")
-      (swap! db* shared/deep-merge global-by-workspace-cache))))
+    (let [workspaces (:workspace-folders @db*)]
+      (consolidate-workspace-cache! workspaces metrics)
+      (when-let [global-by-workspace-cache (read-global-by-workspaces-cache workspaces metrics)]
+        (logger/info logger-tag "Loading from workspace-cache caches...")
+        (swap! db* shared/deep-merge global-by-workspace-cache)))))
 
 (defn ^:private normalize-db-for-workspace-write [db]
   (-> (select-keys db [:chats])

test/eca/cache_test.clj

@@ -83,41 +83,43 @@
       (let [result (dir-name [] identity)]
         (is (re-matches #".{8}" result))))
 
-    (testing "uses first workspace name when multiple workspaces"
-      (let [workspaces [{:uri "/home/user/first-project"}
-                        {:uri "/home/user/second-project"}]
-            result (dir-name workspaces identity)]
-        (is (re-matches #"first-project_.{8}" result))))))
-
-(deftest workspace-cache-file-migration-test
-  (testing "migrates old hash-only directory to new format"
+    (testing "uses sorted-first workspace name regardless of folder order"
+      (let [a {:uri "/home/user/first-project"}
+            b {:uri "/home/user/second-project"}]
+        (is (re-matches #"first-project_.{8}" (dir-name [a b] identity)))
+        (is (= (dir-name [a b] identity) (dir-name [b a] identity)))))))
+
+(deftest workspaces-hash-order-independent-test
+  (testing "the same set of folders hashes the same regardless of order"
+    (let [a {:uri "/home/user/aaa"}
+          b {:uri "/home/user/bbb"}]
+      (is (= (cache/workspaces-hash [a b] identity)
+             (cache/workspaces-hash [b a] identity))))))
+
+(deftest workspace-cache-file-stable-test
+  (testing "resolves to the same canonical file regardless of folder order"
     (with-temp-cache-dir
-      (let [workspaces [{:uri "/home/user/my-project"}]
-            hash-only (cache/workspaces-hash workspaces identity)
-            old-dir (io/file (cache/global-dir) hash-only)]
-        ;; Create old-format directory with a cache file
-        (fs/create-dirs old-dir)
-        (spit (io/file old-dir "db.transit.json") "{}")
-
-        (let [result (cache/workspace-cache-file workspaces "db.transit.json" identity)]
-          (is (not (fs/exists? old-dir)) "Old directory should be renamed")
-          (is (fs/exists? (.getParentFile result)) "New directory should exist")
-          (is (= "{}" (slurp result)) "Migrated file content should be preserved")
-          (is (re-find #"my-project_" (str result)) "New path should contain project name")))))
-
-  (testing "does not migrate when new directory already exists"
+      (let [a {:uri "/home/user/aaa"}
+            b {:uri "/home/user/bbb"}]
+        (is (= (str (cache/workspace-cache-file [a b] "db.transit.json" identity))
+               (str (cache/workspace-cache-file [b a] "db.transit.json" identity))))))))
+
+(deftest redundant-workspace-cache-files-test
+  (testing "finds legacy hash-only and differently-prefixed dirs for the same workspace, excluding canonical"
     (with-temp-cache-dir
       (let [workspaces [{:uri "/home/user/my-project"}]
-            hash-only (cache/workspaces-hash workspaces identity)
-            old-dir (io/file (cache/global-dir) hash-only)
-            result-before (cache/workspace-cache-file workspaces "db.transit.json" identity)
-            new-dir (.getParentFile result-before)]
-        ;; Create both directories
-        (fs/create-dirs old-dir)
-        (spit (io/file old-dir "db.transit.json") "old")
-        (fs/create-dirs new-dir)
-        (spit (io/file new-dir "db.transit.json") "new")
-
-        (let [result (cache/workspace-cache-file workspaces "db.transit.json" identity)]
-          (is (fs/exists? old-dir) "Old directory should remain untouched")
-          (is (= "new" (slurp result)) "Should use new directory content"))))))
+            ws-hash (cache/workspaces-hash workspaces identity)
+            base (cache/global-dir)
+            canonical (cache/workspace-cache-file workspaces "db.transit.json" identity)
+            hash-only-file (io/file base ws-hash "db.transit.json")
+            other-prefixed-file (io/file base (str "old_" ws-hash) "db.transit.json")]
+        (fs/create-dirs (.getParentFile canonical))
+        (spit canonical "canonical")
+        (fs/create-dirs (.getParentFile hash-only-file))
+        (spit hash-only-file "legacy")
+        (fs/create-dirs (.getParentFile other-prefixed-file))
+        (spit other-prefixed-file "other")
+        (let [redundant (set (map str (cache/redundant-workspace-cache-files workspaces "db.transit.json" identity)))]
+          (is (contains? redundant (str hash-only-file)))
+          (is (contains? redundant (str other-prefixed-file)))
+          (is (not (contains? redundant (str canonical)))))))))

test/eca/db_test.clj

@@ -5,7 +5,8 @@
    [clojure.test :refer [deftest is testing]]
    [cognitect.transit :as transit]
    [eca.cache :as cache]
-   [eca.db :as db])
+   [eca.db :as db]
+   [eca.shared :as shared])
   (:import
    [java.io File]))
 
@@ -231,3 +232,26 @@
       (is (contains? (:chats result) "no-msgs-key")))
     (testing ":tool-calls runtime state is stripped before persisting"
       (is (not (contains? (get-in result [:chats "with-msg"]) :tool-calls))))))
+
+(deftest consolidate-workspace-cache!-merges-and-removes-redundant-dirs-test
+  (testing "merges chats from a hash-only dir into the canonical dir (newest wins) and removes the redundant dir"
+    (let [tmpdir (str (fs/create-temp-dir))]
+      (with-redefs [cache/global-dir (constantly (io/file tmpdir))]
+        (try
+          (let [workspaces [{:uri "file:///home/user/projX"}]
+                canonical (cache/workspace-cache-file workspaces "db.transit.json" shared/uri->filename)
+                ws-hash (cache/workspaces-hash workspaces shared/uri->filename)
+                hash-only-dir (io/file (cache/global-dir) ws-hash)
+                hash-only-file (io/file hash-only-dir "db.transit.json")
+                upsert! @#'db/upsert-cache!]
+            ;; canonical holds an older copy of chat "a"
+            (upsert! {:version db/version :chats {"a" {:id "a" :updated-at 100 :title "old-a"}}} canonical nil)
+            ;; a legacy hash-only dir holds a newer "a" plus an extra chat "b"
+            (upsert! {:version db/version :chats {"a" {:id "a" :updated-at 200 :title "new-a"}
+                                                  "b" {:id "b" :updated-at 50 :title "b"}}} hash-only-file nil)
+            (db/consolidate-workspace-cache! workspaces nil)
+            (let [merged (:chats (read-transit-file canonical))]
+              (is (= #{"a" "b"} (set (keys merged))) "all chats end up in the canonical dir")
+              (is (= "new-a" (get-in merged ["a" :title])) "newest :updated-at wins on conflict")
+              (is (not (fs/exists? hash-only-dir)) "redundant dir is removed")))
+          (finally (fs/delete-tree tmpdir)))))))