feat: Surface self-loop in command failures

Author: bzg

src/bark/commands.clj

@@ -657,14 +657,26 @@
                                         source-type target-type))}))
 
 (defn- record-target-failures!
-  [failure-ctx syntax target-mid target-eid valid?]
+  "Record a failure when a relation command's target lookup or
+  validation didn't pan out.  Distinguishes three modes:
+  - :unknown-target -- mid was given but no report matches.
+  - :self-loop      -- target resolves to the current report itself
+                        (a no-op self-reference, common when a new
+                        bug filed as a reply names its own thread root).
+  - :type-mismatch  -- target exists but the type constraint fails."
+  [failure-ctx syntax target-mid target-eid valid? report-eid]
   (when failure-ctx
     (cond
       (and target-mid (nil? target-eid))
       (record-failure! (assoc failure-ctx
                               :reason :unknown-target
                               :audience :author
                               :command (str syntax ": " target-mid)))
+      (and target-eid (= target-eid report-eid))
+      (record-failure! (assoc failure-ctx
+                              :reason :self-loop
+                              :audience :author
+                              :command (str syntax ": " target-mid)))
       (and target-eid (not valid?))
       (record-failure! (assoc failure-ctx
                               :reason :type-mismatch
@@ -674,8 +686,8 @@
 (defn- apply-related-to!
   "Pose / retract :related-to relations from a resolved commands map.
   Independent of report closure state; called from both `apply-lines!`
-  (open path) and `try-unclosed!` (closed path).  Emits failures for
-  unknown targets, ignores self-loops silently.
+  (open path) and `try-unclosed!` (closed path).  Records failures
+  for unknown targets and self-loops.
 
   Target mids resolve via `report-eid-by-mid` -- root or descendant --
   so a mid pointing at any email in a report's thread reaches that
@@ -700,7 +712,13 @@
                                     :audience :author
                                     :command  (str "Related-to: " mid))))
           (= report-eid target-eid)
-          (log/warn "Related-to: self-loop ignored" mid)
+          (do (log/warn (str "Related-to: " mid
+                             " -- targets the same report (self-loop) -- ignored"))
+              (when failure-ctx
+                (record-failure! (assoc failure-ctx
+                                        :reason   :self-loop
+                                        :audience :author
+                                        :command  (str "Related-to: " mid)))))
           :else
           (do (rel/pose-if-absent! conn {:from-eid  report-eid
                                          :to-eid    target-eid
@@ -985,10 +1003,13 @@
         (doseq [{:keys [resolved syntax target-mid]} rows
                 :let [tgt-eid (:target-eid resolved)
                       valid?  (:valid? resolved)]]
-          (record-target-failures! failure-ctx syntax target-mid tgt-eid valid?)
+          (record-target-failures! failure-ctx syntax target-mid tgt-eid valid? report-eid)
           (when (and tgt-eid (not valid?))
-            (log/warn (str syntax ": type mismatch -- source")
-                      source-type "vs target" (:target-type resolved))))
+            (if (= tgt-eid report-eid)
+              (log/warn (str syntax ": " target-mid
+                             " -- targets the same report (self-loop) -- ignored"))
+              (log/warn (str syntax ": type mismatch -- source")
+                        source-type "vs target" (:target-type resolved)))))
         (apply-related-to! conn report-eid resolved email-eid from-addr failure-ctx)))))
 
 (def ^:private unclose-relation-rows

src/bark/common.clj

@@ -52,6 +52,8 @@
 (def reason-labels
   "Human-readable labels for command-failure :reason keys."
   {:unknown-target     "unknown target"
+   :type-mismatch      "type mismatch between source and target"
+   :self-loop          "target is the same report as the source"
    :insufficient-scope "insufficient permissions"})
 
 ;; ---------------------------------------------------------------------------

test/bark/qualified_links_test.clj

@@ -293,6 +293,39 @@
                 ":supersedes relation still active (not retracted)")))
         (finally (close-and-cleanup! setup))))))
 
+(deftest superseded-by-self-loop-is-recorded
+  (testing "Superseded-by: <own-mid> records a :self-loop failure and
+            leaves the report open.  This catches the common pitfall
+            where a new [BUG] reply names its own thread root as the
+            superseder, which would otherwise no-op silently."
+    (let [{:keys [conn] :as setup} (fresh-conn)]
+      (try
+        (let [bug-mid     "<bug-self@x>"
+              bug-email   (mk-email! conn bug-mid "alice@x" #inst "2026-04-01")
+              bug-eid     (mk-report! conn bug-mid bug-email :bug)
+              cmd-eid     (mk-email! conn "<cmd-self@x>" "alice@x" #inst "2026-04-02")
+              cmd-email   {:db/id cmd-eid
+                           :email/author-address "alice@x"
+                           :email/date-sent #inst "2026-04-02"
+                           :email/body-text (str "Superseded-by: " bug-mid "\n")}
+              recorded    (atom [])]
+          (with-redefs [commands/record-failure! (fn [entry] (swap! recorded conj entry))]
+            (commands/apply-commands! conn bug-eid :bug cmd-email
+                                      {} {} :direct))
+          (let [after (d/pull (d/db conn)
+                              [:report/closed :report/close-reason] bug-eid)]
+            (is (nil? (:report/closed after))
+                "report stays open -- self-loop is rejected")
+            (is (nil? (:report/close-reason after))
+                "no close-reason")
+            (is (some #(= :self-loop (:reason %)) @recorded)
+                "a :self-loop failure was recorded")
+            (let [entry (some #(when (= :self-loop (:reason %)) %) @recorded)]
+              (is (= :author (:audience entry))
+                  "self-loop is routed to the author (the typo culprit)")
+              (is (= (str "Superseded-by: " bug-mid) (:command entry))))))
+        (finally (close-and-cleanup! setup))))))
+
 ;; ---------------------------------------------------------------------------
 ;; Phase 4 (partial): Duplicate-of directive
 ;; ---------------------------------------------------------------------------