fitzgibbon/madrigal - Change NQGY27YH53426MZ5LOSNZDDOXLWV2AOJGUJAJPXWUVX6EJ24KZ4AC

Harden CRDT editing flow and add responses provider

Created by G8qzBDPkyFWiTEg4ytm8NUw2bhYLjE9mvCJek2frJAVK on February 19, 2026

NQGY27YH53426MZ5LOSNZDDOXLWV2AOJGUJAJPXWUVX6EJ24KZ4AC

Dependencies

[2] MEKBQ4ELV5T3ZU5WD7FBAWXQLBCNJGD57RYBTEVAMMLO4LHOCKQAC

In channels

main

Change contents

Insertion in madrigal.el at line 27 [2.1]

[2.808]

(declare-function crdt-stop-session "crdt" (&optional session))
(declare-function crdt--stop-session "crdt" (session))

Insertion in madrigal.el at line 123 [2.1]

[2.4122]

(defun madrigal--drop-agent (agent-id)
  (let ((agent (gethash agent-id madrigal--agents)))
    (when agent
      (let ((session (madrigal--agent-session agent)))
        (when (madrigal--live-session-p session)
          (condition-case nil
              (crdt--stop-session session)
            (error
             (condition-case nil
                 (crdt-stop-session session)
               (error nil))))))
      (remhash agent-id madrigal--agents))))

Insertion in madrigal.el at line 175 [2.1]
[2.5547]
[2.5547]
```
          (orig-point (point))
```
Replacement in madrigal.el at line 180 [2.1]
B:BD[2.5683] → [2.5683:5709]
```
      (goto-char (point))
```
[2.5683]
[2.5709]
```
      (goto-char orig-point)
```
Replacement in madrigal.el at line 184 [2.1]
B:BD[2.5819] → [2.5819:5846]
```
            :point (point)
```
[2.5819]
[2.5846]
```
            :point orig-point
```

Replacement in madrigal.el at line 193 [2.1]

B:BD[2.6065] → [2.6065:6437]

    "When you need to edit files or buffers, call the tool exec_ops."
    "You may chain many operations in one call."
    "Prefer one exec_ops call containing a full sequence over multiple calls."
    "Use exact buffer/file paths and positions."
    "All edits happen in CRDT-managed replicas; avoid speculative rewrites."
    "Return concise text once edits are done.")

[2.6065]

[2.6437]

     "When you need to edit files or buffers, call the tool exec_ops."
     "You may chain many operations in one call."
     "Prefer one exec_ops call containing a full sequence over multiple calls."
     "Always read relevant text first before editing."
     "Use point/selection editing: goto_char, search_forward/backward, set_region."
     "Edit only via insert_text, delete_selection, replace_selection, replace_match, replace_in_selection."
     "All edits happen in CRDT-managed replicas; avoid speculative rewrites."
     "Return concise text once edits are done.")

Replacement in madrigal.el at line 251 [2.1]

B:BD[2.7955] → [2.7955:7997]

(defun madrigal--bounded-pos (buffer pos)

[2.7955]

[2.7997]

(defun madrigal--require-pos-in-buffer (buffer pos field)

Replacement in madrigal.el at line 253 [2.1]

B:BD[2.8027] → [2.8027:8073]

    (min (max (point-min) pos) (point-max))))

[2.8027]

[2.8073]

    (unless (and (integerp pos)
                 (<= (point-min) pos)
                 (<= pos (point-max)))
      (error "madrigal: %s out of bounds (%s not in [%s,%s])"
             field pos (point-min) (point-max))))
  pos)
(defun madrigal--sync-replica-point-from-buffer (source-buffer replica-buffer)
  (let ((source-point (with-current-buffer source-buffer (point))))
    (with-current-buffer replica-buffer
      (goto-char (min (max (point-min) source-point) (point-max))))))
(defun madrigal--set-region (buffer start end)
  (with-current-buffer buffer
    (madrigal--require-pos-in-buffer buffer start "start")
    (madrigal--require-pos-in-buffer buffer end "end")
    (goto-char end)
    (set-mark start)
    (setq mark-active t
          deactivate-mark nil)
    (cons (region-beginning) (region-end))))
(defun madrigal--clear-region (buffer)
  (with-current-buffer buffer
    (setq mark-active nil
          deactivate-mark t)
    (set-marker (mark-marker) nil)
    nil))
(defun madrigal--region-bounds-required (buffer)
  (with-current-buffer buffer
    (unless (use-region-p)
      (error "madrigal: active region required"))
    (cons (region-beginning) (region-end))))

Insertion in madrigal.el at line 297 [2.1]

[2.8541]

    (madrigal--sync-replica-point-from-buffer target replica)

Replacement in madrigal.el at line 318 [2.1]

B:BD[2.9624] → [2.9624:10133]

             (let ((buf (find-file-noselect path)))
               (madrigal--ensure-shared-in-server buf)
               (setq network-name (madrigal--buffer-network-name buf))
               (setq replica (madrigal--ensure-agent-replica agent network-name))
               (setq row (append row
                                 (list (cons 'path path)
                                       (cons 'network_name network-name)
                                       (cons 'buffer (buffer-name replica))))))))

[2.9624]

[2.10133]

              (let ((buf (find-file-noselect path)))
                (madrigal--ensure-shared-in-server buf)
                (setq network-name (madrigal--buffer-network-name buf))
                (setq replica (madrigal--ensure-agent-replica agent network-name))
                (with-current-buffer replica
                  (goto-char (point-min)))
                (setq row (append row
                                  (list (cons 'path path)
                                        (cons 'network_name network-name)
                                        (cons 'buffer (buffer-name replica))))))))

Replacement in madrigal.el at line 338 [2.1]

B:BD[2.10701] → [2.10701:10875]

                  (name (madrigal--resolve-ref name0 results)))
             (setq replica (madrigal--ensure-agent-replica agent name))
             (setq network-name name)

[2.10701]

[2.10875]

                   (name (madrigal--resolve-ref name0 results)))
              (setq replica (madrigal--ensure-agent-replica agent name))
              (with-current-buffer replica
                (goto-char (point-min)))
              (setq network-name name)
              (setq row (append row
                                (list (cons 'network_name network-name)
                                      (cons 'buffer (buffer-name replica)))))))
          ("get_point"
           (with-current-buffer replica

Replacement in madrigal.el at line 349 [2.1]

B:BD[2.10910] → [2.10910:11273]

                               (list (cons 'network_name network-name)
                                     (cons 'buffer (buffer-name replica)))))))
          ("get_point"
           (setq row (append row
                             (list (cons 'point
                                         (with-current-buffer replica (point)))))))
          ("read_region"

[2.10910]

[2.11273]

                               (list (cons 'point (point))
                                     (cons 'region_active (and (use-region-p) t))
                                     (cons 'region_start (and (use-region-p) (region-beginning)))
                                     (cons 'region_end (and (use-region-p) (region-end))))))))
          ("goto_char"
           (let* ((pos0 (or (madrigal--alist-get* 'pos raw-op)
                            (madrigal--alist-get* :pos raw-op)))
                  (pos (madrigal--require-integer
                        (madrigal--resolve-ref pos0 results) "pos")))
             (with-current-buffer replica
               (madrigal--require-pos-in-buffer replica pos "pos")
               (goto-char pos)
               (setq row (append row (list (cons 'point (point))))))))
          ("search_forward"
           (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (madrigal--alist-get* :needle raw-op)))
                  (count0 (or (madrigal--alist-get* 'count raw-op)
                              (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))))))))
          ("search_backward"
           (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (madrigal--alist-get* :needle raw-op)))
                  (count0 (or (madrigal--alist-get* 'count raw-op)
                              (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)))))))))
          ("set_region"

Replacement in madrigal.el at line 430 [2.1]

B:BD[2.11784] → [2.11784:12122]

             (with-current-buffer replica
               (let ((s (madrigal--bounded-pos replica start))
                     (e (madrigal--bounded-pos replica end)))
                 (setq row (append row
                                   (list (cons 'text
                                               (buffer-substring-no-properties

[2.11784]

[2.12122]

             (let ((bounds (madrigal--set-region replica start end)))
               (setq row (append row
                                 (list (cons 'region_start (car bounds))
                                       (cons 'region_end (cdr bounds))
                                       (cons 'point (with-current-buffer replica (point))))))))
          ("clear_region"
           (madrigal--clear-region replica)
           (setq row (append row (list (cons 'region_active nil)))))
          ("read_region"
           (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                              (madrigal--alist-get* :start raw-op)))
                  (end0 (or (madrigal--alist-get* 'end raw-op)
                            (madrigal--alist-get* :end raw-op)))
                  (start (madrigal--require-integer
                          (madrigal--resolve-ref start0 results) "start"))
                   (end (madrigal--require-integer
                         (madrigal--resolve-ref end0 results) "end")))
              (with-current-buffer replica
                (madrigal--require-pos-in-buffer replica start "start")
                (madrigal--require-pos-in-buffer replica end "end")
                (let ((s start)
                      (e end))
                  (setq row (append row
                                    (list (cons 'text
                                                (buffer-substring-no-properties

Replacement in madrigal.el at line 457 [2.1]

B:BD[2.12247] → [2.12247:12463]

          ("insert_at"
           (let* ((pos0 (or (madrigal--alist-get* 'pos raw-op)
                            (madrigal--alist-get* :pos raw-op)))
                  (text0 (or (madrigal--alist-get* 'text raw-op)

[2.12247]

[2.12463]

          ("insert_text"
           (let* ((text0 (or (madrigal--alist-get* 'text raw-op)

Deletion in madrigal.el at line 460 [2.1]

B:BD[2.12530] → [2.12530:12649]

                  (pos (madrigal--require-integer
                        (madrigal--resolve-ref pos0 results) "pos"))

Deletion in madrigal.el at line 462 [2.1]

B:BD[2.12769] → [2.12769:12832]

               (goto-char (madrigal--bounded-pos replica pos))

Replacement in madrigal.el at line 466 [2.1]

B:BD[2.13035] → [2.13035:14222]

          ("delete_range"
           (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                              (madrigal--alist-get* :start raw-op)))
                  (end0 (or (madrigal--alist-get* 'end raw-op)
                            (madrigal--alist-get* :end raw-op)))
                  (start (madrigal--require-integer
                          (madrigal--resolve-ref start0 results) "start"))
                  (end (madrigal--require-integer
                        (madrigal--resolve-ref end0 results) "end")))
             (with-current-buffer replica
               (let ((s (madrigal--bounded-pos replica start))
                     (e (madrigal--bounded-pos replica end)))
                 (delete-region (min s e) (max s e))
                 (setq row (append row (list (cons 'point (point)))))))))
          ("replace_range"
           (let* ((start0 (or (madrigal--alist-get* 'start raw-op)
                              (madrigal--alist-get* :start raw-op)))
                  (end0 (or (madrigal--alist-get* 'end raw-op)
                            (madrigal--alist-get* :end raw-op)))
                  (text0 (or (madrigal--alist-get* 'text raw-op)

[2.13035]

[2.14222]

          ("delete_selection"
           (with-current-buffer replica
             (pcase-let ((`(,s . ,e) (madrigal--region-bounds-required replica)))
               (delete-region s e)
               (madrigal--clear-region replica)
               (setq row (append row
                                 (list (cons 'deleted (- e s))
                                       (cons 'point (point))))))))
          ("replace_selection"
           (let* ((text0 (or (madrigal--alist-get* 'text raw-op)

Deletion in madrigal.el at line 477 [2.1]

B:BD[2.14289] → [2.14289:14535]

                  (start (madrigal--require-integer
                          (madrigal--resolve-ref start0 results) "start"))
                  (end (madrigal--require-integer
                        (madrigal--resolve-ref end0 results) "end"))

Replacement in madrigal.el at line 479 [2.1]

B:BD[2.14655] → [2.14655:14872]

               (let ((s (madrigal--bounded-pos replica start))
                     (e (madrigal--bounded-pos replica end)))
                 (delete-region (min s e) (max s e))
                 (goto-char (min s e))

[2.14655]

[2.14872]

               (pcase-let ((`(,s . ,e) (madrigal--region-bounds-required replica)))
                 (delete-region s e)
                 (goto-char s)

Insertion in madrigal.el at line 483 [2.1]

[2.14903]

                 (madrigal--clear-region replica)

Insertion in madrigal.el at line 487 [2.1]

[2.15084]

          ("replace_match"
           (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (madrigal--alist-get* :needle raw-op)))
                  (text0 (or (madrigal--alist-get* 'text raw-op)
                             (madrigal--alist-get* :text raw-op)))
                  (count0 (or (madrigal--alist-get* 'count raw-op)
                              (madrigal--alist-get* :count raw-op)
                              1))
                  (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                  (text (format "%s" (madrigal--resolve-ref text0 results)))
                  (count (madrigal--require-integer
                          (madrigal--resolve-ref count0 results) "count")))
             (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 ((replaced 0)
                       (first-pos nil)
                       (last-pos nil))
                   (while (and (< replaced count)
                               (search-forward needle nil t))
                      (let ((mstart (- (point) (length needle)))
                            (mend (point)))
                        (delete-region mstart mend)
                        (goto-char mstart)
                        (insert text)
                        (setq replaced (1+ replaced)
                              last-pos (point))
                        (unless first-pos
                          (setq first-pos mstart))))
                   (when (= replaced 0)
                     (error "madrigal: needle not found from current point"))
                    (setq row (append row
                                      (list (cons 'replaced replaced)
                                            (cons 'first_pos first-pos)
                                            (cons 'point (or last-pos (point)))))))))))
          ("replace_in_selection"
           (let* ((bounds (madrigal--region-bounds-required replica))
                  (old0 (or (madrigal--alist-get* 'old_text raw-op)
                            (madrigal--alist-get* :old_text raw-op)))
                  (text0 (or (madrigal--alist-get* 'text raw-op)
                             (madrigal--alist-get* :text raw-op)))
                  (strict0 (or (madrigal--alist-get* 'strict raw-op)
                               (madrigal--alist-get* :strict raw-op)
                               t))
                  (old-text (format "%s" (madrigal--resolve-ref old0 results)))
                  (text (format "%s" (madrigal--resolve-ref text0 results)))
                  (strictp (not (memq strict0 '(nil :false false)))))
              (with-current-buffer replica
                (let* ((s (car bounds))
                       (e (cdr bounds))
                       (current (buffer-substring-no-properties s e)))
                  (when (and strictp (not (string= current old-text)))
                    (error "madrigal: replace_in_selection mismatch at [%d,%d]" s e))
                  (delete-region s e)
                  (goto-char s)
                  (insert text)
                  (madrigal--clear-region replica)
                  (setq row (append row
                                    (list (cons 'point (point))
                                          (cons 'inserted (length text)))))))))

Replacement in madrigal.el at line 563 [2.1]

B:BD[2.15778] → [2.15778:15819]

          :results (nreverse results))))

[2.15778]

[2.15819]

          :results (nreverse results))))))

Replacement in madrigal.el at line 570 [2.1]

B:BD[2.15926] → [2.15926:16219]

    "Execute a sequence of CRDT editing operations in the agent replica. "
    "Operations: open_file, list_buffers, switch_buffer, get_point, read_region, "
    "insert_at, delete_range, replace_range, save_buffer. "
    "Supports references like $1.point to consume previous step outputs.")

[2.15926]

[2.16219]

     "Execute a sequence of CRDT editing operations in the agent replica. "
     "Operations: open_file, list_buffers, switch_buffer, get_point, goto_char, "
     "search_forward, search_backward, set_region, clear_region, read_region, "
     "insert_text, delete_selection, replace_selection, replace_match, replace_in_selection, "
     "save_buffer. "
     "Supports references like $1.point to consume previous step outputs.")

Replacement in madrigal.el at line 643 [2.1]

B:BD[2.19000] → [2.19000:19553]

       (pcase (plist-get status :status)
         ('ok
          (let* ((res (plist-get status :result))
                 (text (or (plist-get res :text) ""))
                 (fallback (plist-get status :fallback)))
            (if fallback
                (message "madrigal: done (fallback %s). %s" fallback text)
              (message "madrigal: done. %s" text))))
         (_
          (message "madrigal: error (%s) %s"
                   (or (plist-get status :etype) 'error)
                   (or (plist-get status :message) "unknown"))))))))

[2.19000]

[2.19553]

       (unwind-protect
           (pcase (plist-get status :status)
             ('ok
              (let* ((res (plist-get status :result))
                     (text (or (plist-get res :text) ""))
                     (fallback (plist-get status :fallback)))
                (if fallback
                    (message "madrigal: done (fallback %s). %s" fallback text)
                  (message "madrigal: done. %s" text))))
             (_
              (message "madrigal: error (%s) %s"
                       (or (plist-get status :etype) 'error)
                       (or (plist-get status :message) "unknown"))))
         (madrigal--drop-agent agent-id))))))