fitzgibbon/madrigal - Change F7MUSI5FFYOWTCR4CBL42CT3GE6UL66CQVJANCIISBLAMKRMQQ6AC

Harden search ops and reference handling for agent edit flows

Created by G8qzBDPkyFWiTEg4ytm8NUw2bhYLjE9mvCJek2frJAVK on February 19, 2026

F7MUSI5FFYOWTCR4CBL42CT3GE6UL66CQVJANCIISBLAMKRMQQ6AC

Dependencies

In channels

main

Change contents

Insertion in madrigal.el at line 347 [4.1]

[3.931]

     "open_file and switch_buffer place point at the beginning of the buffer."
     "search_forward/search_backward wrap by default; pass wrap=false for strict no-wrap."
     "For search ops, use needle (text/query aliases are accepted)."
     "References are 1-based over prior ops in the same exec_ops call, e.g. $2.point."

Replacement in madrigal.el at line 394 [4.1]

B:BD[4.7633] → [4.7633:7672]

             (step (nth idx results)))

[4.7633]

[4.7672]

             (step (or (nth idx results)
                       (car (last results)))))

Replacement in madrigal.el at line 522 [4.1]

B:BD[2.7686] → [2.7686:7758]

                                (madrigal--alist-get* :needle raw-op)))

[2.7686]

[2.7758]

                                (madrigal--alist-get* :needle raw-op)
                                (madrigal--alist-get* 'text raw-op)
                                (madrigal--alist-get* :text raw-op)
                                (madrigal--alist-get* 'query raw-op)
                                (madrigal--alist-get* :query raw-op)))

Replacement in madrigal.el at line 528 [4.1]

∅:D[2.7826] → [3.4735:6104]

B:BD[3.4735] → [3.4735:6104]

B:BD[3.6104] → [2.7827:7901]

                              (madrigal--alist-get* :count raw-op)
                              1))
                  (set-region0 (or (madrigal--alist-get* 'set_region raw-op)
                                   (madrigal--alist-get* :set_region raw-op)
                                   nil))
                  (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                  (count (madrigal--require-integer
                          (madrigal--resolve-ref count0 results) "count"))
                  (set-region-p (not (memq set-region0 '(nil :false false)))))
             (when (string-empty-p needle)
               (error "madrigal: needle must be non-empty"))
             (when (<= count 0)
               (error "madrigal: count must be > 0"))
             (with-current-buffer replica
               (let ((found nil))
                 (dotimes (_ count)
                   (setq found (search-forward needle nil t))
                   (unless found
                     (error "madrigal: search_forward needle not found")))
                 (when set-region-p
                   (madrigal--set-region replica (- (point) (length needle)) (point)))
                 (setq row (append row
                                   (list (cons 'point (point))
                                         (cons 'match_start (- (point) (length needle)))
                                         (cons 'match_end (point)))))))))

[2.7826]

[2.7901]

                               (madrigal--alist-get* :count raw-op)
                               1))
                   (set-region0 (or (madrigal--alist-get* 'set_region raw-op)
                                    (madrigal--alist-get* :set_region raw-op)
                                    nil))
                   (wrap0 (or (madrigal--alist-get* 'wrap raw-op)
                              (madrigal--alist-get* :wrap raw-op)
                              t))
                   (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                   (count (madrigal--require-integer
                           (madrigal--resolve-ref count0 results) "count"))
                   (set-region-p (not (memq set-region0 '(nil :false false))))
                   (wrap-p (not (memq wrap0 '(nil :false false)))))
              (when (string-empty-p needle)
                (error "madrigal: needle must be non-empty"))
              (when (<= count 0)
                (error "madrigal: count must be > 0"))
              (with-current-buffer replica
                (let ((found nil)
                      (wrapped nil))
                  (dotimes (_ count)
                    (setq found (search-forward needle nil t))
                    (unless found
                      (when wrap-p
                        (goto-char (point-min))
                        (setq wrapped t)
                        (setq found (search-forward needle nil t)))
                      (unless found
                        (error "madrigal: search_forward needle not found"))))
                  (when set-region-p
                    (madrigal--set-region replica (- (point) (length needle)) (point)))
                  (setq row (append row
                                    (list (cons 'point (point))
                                          (cons 'match_start (- (point) (length needle)))
                                          (cons 'match_end (point))
                                          (cons 'wrapped wrapped))))))))

Replacement in madrigal.el at line 566 [4.1]

B:BD[2.8006] → [2.8006:8078]

                                (madrigal--alist-get* :needle raw-op)))

[2.8006]

[2.8078]

                                (madrigal--alist-get* :needle raw-op)
                                (madrigal--alist-get* 'text raw-op)
                                (madrigal--alist-get* :text raw-op)
                                (madrigal--alist-get* 'query raw-op)
                                (madrigal--alist-get* :query raw-op)))

Replacement in madrigal.el at line 572 [4.1]

∅:D[2.8146] → [3.6413:7793]

B:BD[3.6413] → [3.6413:7793]

B:BD[3.7793] → [2.8147:8239]

                              (madrigal--alist-get* :count raw-op)
                              1))
                  (set-region0 (or (madrigal--alist-get* 'set_region raw-op)
                                   (madrigal--alist-get* :set_region raw-op)
                                   nil))
                  (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                  (count (madrigal--require-integer
                          (madrigal--resolve-ref count0 results) "count"))
                  (set-region-p (not (memq set-region0 '(nil :false false)))))
             (when (string-empty-p needle)
               (error "madrigal: needle must be non-empty"))
             (when (<= count 0)
               (error "madrigal: count must be > 0"))
             (with-current-buffer replica
               (let ((found nil))
                 (dotimes (_ count)
                   (setq found (search-backward needle nil t))
                   (unless found
                     (error "madrigal: search_backward needle not found")))
                 (when set-region-p
                   (madrigal--set-region replica found (+ found (length needle))))
                 (goto-char found)
                 (setq row (append row
                                   (list (cons 'point (point))
                                         (cons 'match_start found)
                                         (cons 'match_end (+ found (length needle))))))))))

[2.8146]

[2.8239]

                               (madrigal--alist-get* :count raw-op)
                               1))
                   (set-region0 (or (madrigal--alist-get* 'set_region raw-op)
                                    (madrigal--alist-get* :set_region raw-op)
                                    nil))
                   (wrap0 (or (madrigal--alist-get* 'wrap raw-op)
                              (madrigal--alist-get* :wrap raw-op)
                              t))
                   (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                   (count (madrigal--require-integer
                           (madrigal--resolve-ref count0 results) "count"))
                   (set-region-p (not (memq set-region0 '(nil :false false))))
                   (wrap-p (not (memq wrap0 '(nil :false false)))))
              (when (string-empty-p needle)
                (error "madrigal: needle must be non-empty"))
              (when (<= count 0)
                (error "madrigal: count must be > 0"))
              (with-current-buffer replica
                (let ((found nil)
                      (wrapped nil))
                  (dotimes (_ count)
                    (setq found (search-backward needle nil t))
                    (unless found
                      (when wrap-p
                        (goto-char (point-max))
                        (setq wrapped t)
                        (setq found (search-backward needle nil t)))
                      (unless found
                        (error "madrigal: search_backward needle not found"))))
                  (when set-region-p
                    (madrigal--set-region replica found (+ found (length needle))))
                  (goto-char found)
                  (setq row (append row
                                    (list (cons 'point (point))
                                          (cons 'match_start found)
                                          (cons 'match_end (+ found (length needle)))
                                          (cons 'wrapped wrapped))))))))

Replacement in madrigal.el at line 752 [4.1]
∅:D[2.10702] → [4.15726:15755]
B:BD[4.15726] → [4.15726:15755]
```
        (push row results)))
```
[2.10702]
[4.15755]
```
        (setq results (append results (list row)))))
```
Replacement in madrigal.el at line 754 [4.1]
B:BD[4.15778] → [2.10703:10744]
```
          :results (nreverse results))))
```
[4.15778]
[4.15819]
```
          :results results)))
```

Replacement in madrigal.el at line 764 [4.1]

B:BD[3.13932] → [3.13932:14124]

     "insert_text, delete_selection, replace_selection, replace_match, replace_in_selection, "
     "save_buffer. "
     "Supports references like $1.point to consume previous step outputs.")

[3.13932]

[4.16219]

      "insert_text, delete_selection, replace_selection, replace_match, replace_in_selection, "
      "save_buffer. "
      "search_forward/search_backward support needle plus text/query aliases and optional wrap boolean (default true). "
      "Supports references like $1.point to consume previous step outputs.")