Preserve full chat history across compactions

Instead of replacing all messages with a summary on compaction,
append a compact_marker tombstone followed by the summary message.
Messages sent to the LLM are filtered to only include those after
the last compact_marker, while the full history is preserved in
the database for UI replay on chat resume.

- Add messages-after-last-compact-marker utility (reverse scan)
- Filter past-messages/new-messages at all LLM-bound chokepoints
- Add compact_marker case in message-content->chat-content for UI
- Stop prune-tool-results! at tombstone boundary
- Filter hook all-messages to post-compaction segment

Closes #394

🤖 Generated with [eca](https://eca.dev)

Co-Authored-By: eca <git@eca.dev>

Author: ericdallo

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - Add `chatRetentionDays` config to control chat and cache cleanup retention period, default changed from 7 to 14 days. Set to 0 to disable cleanup. #393
+- Preserve full chat history across compactions using tombstone markers instead of replacing messages. #394
 
 ## 0.123.3
 

src/eca/db.clj

@@ -57,7 +57,7 @@
                         :status (or :idle :running :stopping :login)
                         :created-at :number
                         :login-provider :string
-                        :messages [{:role (or "user" "assistant" "tool_call" "tool_call_output" "reason")
+                        :messages [{:role (or "user" "assistant" "tool_call" "tool_call_output" "reason" "compact_marker" "server_tool_use" "server_tool_result")
                                     :content (or :string [::any-map]) ;; string for simple text, map/vector for structured content
                                     :content-id :string}]
                         :task {:next-id :number

src/eca/features/chat.clj

@@ -79,6 +79,10 @@
             (let [msg (nth messages i)
                   role (:role msg)]
               (cond
+                (= "compact_marker" role)
+                {:pruned-messages result
+                 :freed-tokens freed-tokens}
+
                 (= "tool_call_output" role)
                 (let [text (tool-output-text msg)
                       tokens (estimate-tokens text)]
@@ -192,7 +196,12 @@
               {:role :assistant
                :content {:type :reasonFinished
                          :id (:id message-content)
-                         :total-time-ms (:total-time-ms message-content)}}]))
+                         :total-time-ms (:total-time-ms message-content)}}]
+    "compact_marker" [{:role :system
+                       :content {:type :text
+                                 :text (if (:auto? message-content)
+                                         "── Chat auto-compacted ──"
+                                         "── Chat compacted ──")}}]))
 
 (defn ^:private send-chat-contents! [messages chat-ctx]
   (doseq [message messages]
@@ -444,7 +453,8 @@
         modify-allowed? (= source-type :prompt-message)
         run-hooks? (#{:prompt-message :eca-command :mcp-prompt} source-type)
         user-messages (if run-hooks?
-                        (let [past-messages (get-in @db* [:chats chat-id :messages] [])
+                        (let [past-messages (shared/messages-after-last-compact-marker
+                                             (get-in @db* [:chats chat-id :messages] []))
                               {:keys [final-prompt additional-contexts stop?]}
                               (run-pre-request-hooks! (assoc chat-ctx :message original-text
                                                              :all-messages (into past-messages user-messages)))]
@@ -538,7 +548,8 @@
                 :model-capabilities model-capabilities
                 :user-messages user-messages
                 :instructions  instructions
-                :past-messages (get-in @db* [:chats chat-id :messages] [])
+                :past-messages (shared/messages-after-last-compact-marker
+                                (get-in @db* [:chats chat-id :messages] []))
                 :config  config
                 :tools all-tools
                 :provider-auth provider-auth
@@ -643,7 +654,8 @@
                                                (do
                                                  (consume-steer-message! chat-id db* chat-ctx add-to-history!)
                                                  {:tools tc-all-tools
-                                                  :new-messages (get-in @db* [:chats chat-id :messages])})))))
+                                                  :new-messages (shared/messages-after-last-compact-marker
+                                                                  (get-in @db* [:chats chat-id :messages]))})))))
                                   received-msgs* add-to-history! user-messages)
                 :on-reason (fn [{:keys [status id text external-id delta-reasoning? redacted? data]}]
                              (lifecycle/assert-chat-not-stopped! chat-ctx)

src/eca/features/chat/tool_calls.clj

@@ -7,7 +7,7 @@
    [eca.features.tools.mcp :as f.tools.mcp]
    [eca.llm-util :as llm-util]
    [eca.logger :as logger]
-   [eca.shared :refer [assoc-some]]))
+   [eca.shared :as shared :refer [assoc-some]]))
 
 (set! *warn-on-reflection* true)
 
@@ -814,15 +814,17 @@
                                                                      :text (or hook-stop-reason "Tool rejected by hook")})
                           (lifecycle/finish-chat-prompt! :idle chat-ctx) nil)
                       {:tools all-tools
-                       :new-messages (get-in @db* [:chats chat-id :messages])})
+                       :new-messages (shared/messages-after-last-compact-marker
+                                      (get-in @db* [:chats chat-id :messages]))})
                     (if (get-in @db* [:chats chat-id :subagent])
                       ;; Subagent: user can't provide rejection input directly, so continue
                       ;; the LLM loop with a rejection message letting the subagent adapt
                       (do (add-to-history! {:role "user"
                                             :content [{:type :text
                                                        :text "I rejected one or more tool calls. The tool call was not allowed. Try a different approach to complete the task."}]})
                           {:tools all-tools
-                           :new-messages (get-in @db* [:chats chat-id :messages])})
+                           :new-messages (shared/messages-after-last-compact-marker
+                                          (get-in @db* [:chats chat-id :messages]))})
                       (do (lifecycle/send-content! chat-ctx :system {:type :text
                                                                      :text "Tell ECA what to do differently for the rejected tool(s)"})
                           (add-to-history! {:role "user"
@@ -835,4 +837,5 @@
                   (if-let [continue-fn (:continue-fn chat-ctx)]
                     (continue-fn all-tools user-messages)
                     {:tools all-tools
-                     :new-messages (get-in @db* [:chats chat-id :messages])}))))))))))
+                     :new-messages (shared/messages-after-last-compact-marker
+                                    (get-in @db* [:chats chat-id :messages]))}))))))))))

src/eca/shared.clj

@@ -314,17 +314,37 @@
   (str (cache/workspace-cache-file (or (:initial-workspace-folders db)
                                        (:workspace-folders db)) "db.transit.json" uri->filename)))
 
+(defn messages-after-last-compact-marker
+  "Returns messages after the last compact_marker, or all messages if none exists.
+   Scans from the end for efficiency since markers are typically near the tail."
+  [messages]
+  (let [messages (vec messages)
+        n (count messages)
+        last-idx (loop [i (dec n)]
+                   (cond
+                     (neg? i) -1
+                     (= "compact_marker" (:role (messages i))) i
+                     :else (recur (dec i))))]
+    (if (neg? last-idx)
+      messages
+      (subvec messages (inc last-idx)))))
+
 (defn compact-side-effect!
-  "Performs side effects after chat compaction: replaces history with summary,
-   zeros token usage, and notifies the user."
+  "Performs side effects after chat compaction: appends a compact_marker tombstone
+   and summary to history, zeros token usage, and notifies the user."
   [{:keys [chat-id full-model db* messenger]} auto-compact?]
-  ;; Replace chat history with summary
+  ;; Append compact marker tombstone + summary to preserve full history
   (swap! db* (fn [db]
-               (assoc-in db [:chats chat-id :messages]
-                         [{:role "user"
-                           :content [{:type :text
-                                      :text (str "The conversation was compacted/summarized, consider this summary:\n"
-                                                 (get-in db [:chats chat-id :last-summary]))}]}])))
+               (let [summary (get-in db [:chats chat-id :last-summary])
+                     messages (get-in db [:chats chat-id :messages] [])]
+                 (assoc-in db [:chats chat-id :messages]
+                           (conj messages
+                                 {:role "compact_marker"
+                                  :content {:auto? (boolean auto-compact?)}}
+                                 {:role "user"
+                                  :content [{:type :text
+                                             :text (str "The conversation was compacted/summarized, consider this summary:\n"
+                                                        summary)}]})))))
 
   ;; Zero chat usage
   (swap! db* update-in [:chats chat-id] dissoc :usage)

test/eca/features/chat_test.clj

@@ -296,7 +296,26 @@
 
   (testing "handles empty message history"
     (let [db* (atom {:chats {"c1" {:messages []}}})]
-      (is (zero? (#'f.chat/prune-tool-results! db* "c1" {}))))))
+      (is (zero? (#'f.chat/prune-tool-results! db* "c1" {})))))
+
+  (testing "stops at compact_marker boundary, does not prune pre-compaction messages"
+    (let [large-text (apply str (repeat 100000 "x"))
+          messages [(make-tool-call-msg "old")
+                    (make-tool-output-msg "old" large-text)
+                    {:role "compact_marker" :content {:auto? false}}
+                    {:role "user" :content [{:type :text :text "summary"}]}
+                    (make-tool-call-msg "new")
+                    (make-tool-output-msg "new" large-text)]
+          db* (atom {:chats {"c1" {:messages messages}}})
+          freed (#'f.chat/prune-tool-results! db* "c1" {:protect-budget 0})]
+      (is (pos? freed))
+      (let [pruned (get-in @db* [:chats "c1" :messages])]
+        ;; Pre-compaction tool output should be untouched
+        (is (= large-text
+               (get-in (nth pruned 1) [:content :output :contents 0 :text])))
+        ;; Post-compaction tool output should be cleared
+        (is (= "[content cleared to reduce context size]"
+               (get-in (nth pruned 5) [:content :output :contents 0 :text])))))))
 
 (deftest contexts-in-prompt-test
   (testing "When prompt contains @file we add a user message"

test/eca/shared_test.clj

@@ -203,4 +203,38 @@
   (testing "returns nil when base is blank"
     (is (nil? (shared/join-api-url "   " "/chat/completions")))))
 
+(deftest messages-after-last-compact-marker-test
+  (testing "returns all messages when no compact_marker exists"
+    (let [messages [{:role "user" :content [{:type :text :text "hello"}]}
+                    {:role "assistant" :content [{:type :text :text "hi"}]}]]
+      (is (= messages (shared/messages-after-last-compact-marker messages)))))
+
+  (testing "returns messages after the last compact_marker"
+    (let [messages [{:role "user" :content [{:type :text :text "old msg"}]}
+                    {:role "compact_marker" :content {:auto? false}}
+                    {:role "user" :content [{:type :text :text "summary"}]}
+                    {:role "assistant" :content [{:type :text :text "response"}]}]]
+      (is (= [{:role "user" :content [{:type :text :text "summary"}]}
+              {:role "assistant" :content [{:type :text :text "response"}]}]
+             (shared/messages-after-last-compact-marker messages)))))
+
+  (testing "handles multiple compact_markers, returns after last one"
+    (let [messages [{:role "user" :content [{:type :text :text "old"}]}
+                    {:role "compact_marker" :content {:auto? false}}
+                    {:role "user" :content [{:type :text :text "summary 1"}]}
+                    {:role "compact_marker" :content {:auto? true}}
+                    {:role "user" :content [{:type :text :text "summary 2"}]}
+                    {:role "assistant" :content [{:type :text :text "latest"}]}]]
+      (is (= [{:role "user" :content [{:type :text :text "summary 2"}]}
+              {:role "assistant" :content [{:type :text :text "latest"}]}]
+             (shared/messages-after-last-compact-marker messages)))))
+
+  (testing "returns empty when compact_marker is last message"
+    (let [messages [{:role "user" :content [{:type :text :text "old"}]}
+                    {:role "compact_marker" :content {:auto? false}}]]
+      (is (= [] (shared/messages-after-last-compact-marker messages)))))
+
+  (testing "handles empty messages"
+    (is (= [] (shared/messages-after-last-compact-marker [])))))
+