Add /delete-chat command to delete chats with confirmation

Deletes the current chat or a chat-id from the /resume list after a
confirm step, reusing the chat/delete path (chatEnd hook, tombstone,
chat/deleted notification) so clients close the chat automatically.
The current chat's turn is finished before deleting so the status
transition can't resurrect it as a ghost record.

Author: ericdallo

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - Add `/btw` command to ask a side question in a forked chat, keeping the current chat history clean. Runs immediately even while the chat is running (steered /btw is not queued).
+- Add `/delete-chat` command to permanently delete the current chat or a chat-id from the `/resume` list, asking confirmation first.
 
 ## 0.155.2
 

docs/features.md

@@ -135,6 +135,7 @@ The built-in commands are:
 - `/fork`: Fork the current chat into a new chat with the same history and settings.
 - `/btw`: Ask a side question in a forked chat, keeping the current chat history clean. Ex: `/btw how does X work?`.
 - `/resume`: Resume a chat from previous session of this workspace folder.
+- `/delete-chat`: Permanently delete the current chat or a chat-id from the `/resume` list, asking confirmation. Ex: `/delete-chat`, `/delete-chat 2`.
 - `/costs`: Show costs about current session.
 - `/config`: Show ECA config for troubleshooting.
 - `/doctor`: Show information about ECA, useful for troubleshooting.

src/eca/features/chat.clj

@@ -618,7 +618,7 @@
           (filter #({"preRequest" "prePrompt"} (:type (val %))))
           (sort-by key)))))
 
-(declare prompt prompt-messages!)
+(declare prompt prompt-messages! delete-chat)
 
 (defn ^:private tokenize-args [^String s]
   (if (string/blank? s)
@@ -1639,6 +1639,15 @@
                                                                               :title title)))))
                          (lifecycle/finish-chat-prompt! :idle (assoc chat-ctx :skip-post-request-hooks? true)))
         :new-chat-status (lifecycle/finish-chat-prompt! (:status result) (assoc chat-ctx :skip-post-request-hooks? true))
+        :delete-chat (let [{:keys [target-chat-id text]} result
+                           {:keys [db* messenger config metrics]} chat-ctx]
+                       (when text
+                         (lifecycle/send-content! chat-ctx :system {:type :text :text text}))
+                       ;; Finish the turn BEFORE deleting: finish-chat-prompt!'s
+                       ;; status transition on a deleted chat would resurrect it
+                       ;; as a ghost record.
+                       (lifecycle/finish-chat-prompt! :idle (assoc chat-ctx :skip-post-request-hooks? true))
+                       (delete-chat {:chat-id target-chat-id} db* messenger config metrics))
         :side-prompt (let [{:keys [target-chat-id target-title target-messages message notice-text]} result
                            {:keys [chat-id db*]} chat-ctx]
                        (lifecycle/send-content! chat-ctx :system {:type :text :text notice-text})

src/eca/features/commands.clj

@@ -228,6 +228,10 @@
                        :type :native
                        :description "Resume the specified chat-id. Blank to list chats or 'latest'."
                        :arguments [{:name "chat-id"}]}
+                      {:name "delete-chat"
+                       :type :native
+                       :description "Permanently delete the current chat or a chat-id from the /resume list, asking confirmation. (Ex: /delete-chat, /delete-chat 2)"
+                       :arguments [{:name "chat-id"}]}
                       {:name "export"
                        :type :native
                        :description "Export the current chat to a file or directory to transfer/import it elsewhere. Ex: /export /tmp/chat.edn or /export ."
@@ -821,6 +825,51 @@
                       :chats {chat-id {:title (:title chat)
                                        :messages (concat [{:role "system" :content [{:type :text :text (str "Resuming chat: " selected-chat-id)}]}]
                                                          (:messages chat))}}})))
+      "delete-chat" (let [confirm? (= "confirm" (some-> (last args) string/lower-case))
+                          target-arg (first (remove #(= "confirm" (some-> % string/lower-case)) args))
+                          other-chats (into {}
+                                            (filter #(and (not= chat-id (first %))
+                                                          (not (:subagent (second %)))))
+                                            (:chats db))
+                          ;; Same ordering as /resume so its listed ids work here.
+                          chats-ids (vec (sort-by #(:created-at (get other-chats %)) (keys other-chats)))
+                          target-id (cond
+                                      (nil? target-arg) chat-id
+                                      (= target-arg chat-id) chat-id
+                                      (contains? other-chats target-arg) target-arg
+                                      :else (when-let [n (parse-long target-arg)]
+                                              (nth chats-ids (dec n) nil)))
+                          target-chat (get-in db [:chats target-id])
+                          current? (= target-id chat-id)
+                          chat-message-fn (fn [text]
+                                            {:type :chat-messages
+                                             :chats {chat-id {:messages [{:role "system" :content [{:type :text :text text}]}]}}})
+                          describe-fn (fn [chat]
+                                        (or (:title chat)
+                                            (format "No chat title (%s user messages)"
+                                                    (or (:user-message-count (db/chat-list-meta chat)) 0))))]
+                      (cond
+                        (nil? target-id)
+                        (chat-message-fn "Chat ID not found. Run `/resume` to list chats.")
+
+                        (and (not current?)
+                             (db/hydrated? target-chat)
+                             (contains? #{:running :stopping} (:status target-chat)))
+                        (chat-message-fn (format "Chat '%s' has a running prompt, stop it before deleting." (describe-fn target-chat)))
+
+                        (not confirm?)
+                        (chat-message-fn
+                         (multi-str
+                          (if current?
+                            "This will permanently delete the current chat."
+                            (format "This will permanently delete chat: %s" (describe-fn target-chat)))
+                          (str "Run `/delete-chat " (when target-arg (str target-arg " ")) "confirm` to proceed.")))
+
+                        :else
+                        {:type :delete-chat
+                         :target-chat-id target-id
+                         :text (when-not current?
+                                 (format "Deleted chat: %s" (describe-fn target-chat)))}))
       "costs" (let [total-input-tokens (get-in db [:chats chat-id :usage :total-input-tokens] 0)
                     total-input-cache-creation-tokens (get-in db [:chats chat-id :usage :total-input-cache-creation-tokens] nil)
                     total-input-cache-read-tokens (get-in db [:chats chat-id :usage :total-input-cache-read-tokens] nil)

test/eca/features/chat_test.clj

@@ -1563,6 +1563,41 @@
         (is (string/includes? (:text @sent-content) "No response from prompt"))
         (is (= :idle @finished-status))))))
 
+(deftest delete-chat-command-test
+  (testing "/delete-chat asks confirmation and /delete-chat confirm deletes the chat"
+    (h/reset-components!)
+    (let [{:keys [chat-id]}
+          (prompt!
+           {:message "hi"}
+           {:all-tools-mock (constantly [])
+            :api-mock
+            (fn [{:keys [on-first-response-received on-message-received]}]
+              (on-first-response-received {:type :text :text "hello"})
+              (on-message-received {:type :text :text "hello"})
+              (on-message-received {:type :finish}))})
+          llm-mock (fn [& _] (throw (ex-info "commands should not call the LLM" {})))]
+      (h/reset-messenger!)
+      (prompt! {:message "/delete-chat" :chat-id chat-id}
+               {:all-tools-mock (constantly [])
+                :api-mock llm-mock})
+      (is (match?
+           {:chat-content-received
+            (m/embeds [{:chat-id chat-id
+                        :role "system"
+                        :content {:type :text
+                                  :text #(string/includes? % "Run `/delete-chat confirm` to proceed.")}}])}
+           (h/messages)))
+      (is (some? (get-in (h/db) [:chats chat-id]))
+          "chat is kept until deletion is confirmed")
+      (h/reset-messenger!)
+      (prompt! {:message "/delete-chat confirm" :chat-id chat-id}
+               {:all-tools-mock (constantly [])
+                :api-mock llm-mock})
+      (is (match? {:chat-deleted [{:chat-id chat-id}]}
+                  (h/messages)))
+      (is (nil? (get-in (h/db) [:chats chat-id])))
+      (is (contains? (:deleted-chat-ids (h/db)) chat-id)))))
+
 (deftest message->decision-test
   (testing "plain prompt message"
     (is (= {:type :prompt-message

test/eca/features/commands_test.clj

@@ -536,6 +536,62 @@
              (:config-updated (h/messages))))
       (is (= session-defaults (:last-config-notified (h/db)))))))
 
+(deftest delete-chat-command-test
+  (testing "no confirm asks for confirmation for the current chat"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-b" {:id "chat-b" :messages []}})
+    (let [result (f.commands/handle-command! "delete-chat" [] (command-context "chat-b"))]
+      (is (= :chat-messages (:type result)))
+      (is (string/includes? (get-in result [:chats "chat-b" :messages 0 :content 0 :text])
+                            "Run `/delete-chat confirm` to proceed."))))
+
+  (testing "confirm deletes the current chat"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-b" {:id "chat-b" :messages []}})
+    (is (= {:type :delete-chat :target-chat-id "chat-b" :text nil}
+           (f.commands/handle-command! "delete-chat" ["confirm"] (command-context "chat-b")))))
+
+  (testing "chat-id arg resolves like the /resume listing"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-a" {:id "chat-a" :created-at 1 :title "First" :messages []}
+                                 "chat-b" {:id "chat-b" :created-at 2 :messages []}
+                                 "chat-c" {:id "chat-c" :created-at 3 :title "Third" :messages []}})
+    (let [ask (f.commands/handle-command! "delete-chat" ["2"] (command-context "chat-b"))
+          result (f.commands/handle-command! "delete-chat" ["2" "confirm"] (command-context "chat-b"))]
+      (is (string/includes? (get-in ask [:chats "chat-b" :messages 0 :content 0 :text])
+                            "Run `/delete-chat 2 confirm` to proceed."))
+      (is (= {:type :delete-chat :target-chat-id "chat-c" :text "Deleted chat: Third"}
+             result))))
+
+  (testing "a literal chat id is accepted"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-a" {:id "chat-a" :created-at 1 :title "First" :messages []}
+                                 "chat-b" {:id "chat-b" :created-at 2 :messages []}})
+    (is (= {:type :delete-chat :target-chat-id "chat-a" :text "Deleted chat: First"}
+           (f.commands/handle-command! "delete-chat" ["chat-a" "confirm"] (command-context "chat-b")))))
+
+  (testing "unknown chat id"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-b" {:id "chat-b" :messages []}})
+    (let [result (f.commands/handle-command! "delete-chat" ["9" "confirm"] (command-context "chat-b"))]
+      (is (string/includes? (get-in result [:chats "chat-b" :messages 0 :content 0 :text])
+                            "Chat ID not found."))))
+
+  (testing "refuses deleting another chat with a running prompt"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-a" {:id "chat-a" :created-at 1 :title "Busy" :status :running :messages []}
+                                 "chat-b" {:id "chat-b" :created-at 2 :messages []}})
+    (let [result (f.commands/handle-command! "delete-chat" ["1" "confirm"] (command-context "chat-b"))]
+      (is (string/includes? (get-in result [:chats "chat-b" :messages 0 :content 0 :text])
+                            "has a running prompt"))))
+
+  (testing "stale running status of an index-only chat does not block deletion"
+    (h/reset-components!)
+    (swap! (h/db*) assoc :chats {"chat-a" {:id "chat-a" :created-at 1 :title "Stale" :status :running :index-only? true}
+                                 "chat-b" {:id "chat-b" :created-at 2 :messages []}})
+    (is (= {:type :delete-chat :target-chat-id "chat-a" :text "Deleted chat: Stale"}
+           (f.commands/handle-command! "delete-chat" ["1" "confirm"] (command-context "chat-b"))))))
+
 (deftest rules-command-test
   (testing "/rules shows static and path-scoped rules separately with filter metadata"
     (with-redefs [f.rules/all-rules (fn [_config _roots agent full-model]