fitzgibbon/madrigal - Change 3WLUGWU24VFKJ6AAFNOHE4EB5VF6M3NQRUTNXMI5DVMCMAI3ZFBQC

Simplify exec_ops to directional point/region workflow

Created by G8qzBDPkyFWiTEg4ytm8NUw2bhYLjE9mvCJek2frJAVK on February 19, 2026

3WLUGWU24VFKJ6AAFNOHE4EB5VF6M3NQRUTNXMI5DVMCMAI3ZFBQC

Dependencies

In channels

main

Change contents

Replacement in madrigal.el at line 390 [4.1]

B:BD[3.876] → [3.876:931]

B:BD[3.931] → [5.1:240]

B:BD[5.240] → [2.216:300]

∅:D[2.300] → [5.240:327]

B:BD[5.240] → [5.240:327]

∅:D[5.327] → [3.931:1123]

B:BD[3.931] → [3.931:1123]

B:BD[3.1123] → [6.321:392]

∅:D[6.392] → [3.1123:1250]

B:BD[3.1123] → [3.1123:1250]

     "Always read relevant text first before editing."
     "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)."
     "Search ops return found=false when no match; set required=true to fail hard."
     "References are 1-based over prior ops in the same exec_ops call, e.g. $2.point."
     "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."
     "Do not save files; saving is always the user's explicit choice."
     "All edits happen in CRDT-managed replicas; avoid speculative rewrites."
     "Return concise text once edits are done.")

[3.876]

[4.6437]

    "Always read relevant text first before editing."
    "open_file and switch_buffer place point at the beginning of the buffer."
    "Use move and search for navigation; both use a direction parameter."
    "For search ops, use needle (text/query aliases are accepted)."
    "move returns moved_chars; search returns match_length (0 when not found)."
    "Use set_mark and clear_region to control selections."
    "Edit only via insert_text, delete_selection, and replace_selection."
    "Do not save files; saving is always the user's explicit choice."
    "All edits happen in CRDT-managed replicas; avoid speculative rewrites."
    "Return concise text once edits are done.")

Replacement in madrigal.el at line 559 [4.1]

B:BD[4.8698] → [7.5935:6022]

              (op-name (if (symbolp op) (symbol-name op) op))
              (row nil))

[4.8698]

[4.8783]

             (op-name (if (symbolp op) (symbol-name op) op))
             (row nil))

Replacement in madrigal.el at line 568 [4.1]

B:BD[4.8948] → [7.6174:6407]

                ("open_file"
            (let* ((path0 (or (madrigal--alist-get* 'path raw-op)
                              (madrigal--alist-get* :path raw-op)))
                   (create0 (or (madrigal--alist-get* 'create raw-op)

[4.8948]

[4.9172]

          ("open_file"
           (let* ((path0 (or (madrigal--alist-get* 'path raw-op)
                             (madrigal--alist-get* :path raw-op)))
                  (create0 (or (madrigal--alist-get* 'create raw-op)

Replacement in madrigal.el at line 579 [4.1]

B:BD[4.9624] → [3.2565:3170]

B:BD[3.3170] → [7.6408:6926]

∅:D[7.6926] → [4.10632:10701]

B:BD[4.10632] → [4.10632:10701]

B:BD[4.10701] → [3.3171:3620]

B:BD[3.3620] → [7.6927:7581]

∅:D[7.7581] → [3.4219:4500]

B:BD[3.4219] → [3.4219:4500]

B:BD[3.4500] → [7.7582:7616]

B:BD[7.7616] → [2.1765:1976]

∅:D[2.1976] → [5.555:763]

B:BD[5.555] → [5.555:763]

∅:D[5.763] → [7.7758:7826]

B:BD[7.7758] → [7.7758:7826]

B:BD[7.7826] → [5.764:867]

B:BD[5.867] → [2.1977:4801]

∅:D[5.2798] → [7.7901:7936]

∅:D[2.4801] → [7.7901:7936]

B:BD[7.7901] → [7.7901:7936]

B:BD[7.7936] → [2.4802:5013]

∅:D[2.5013] → [5.2937:3145]

B:BD[5.2937] → [5.2937:3145]

∅:D[5.3145] → [7.8078:8146]

B:BD[7.8078] → [7.8078:8146]

B:BD[7.8146] → [5.3146:3249]

B:BD[5.3249] → [2.5014:6417]

              (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))))))))
                ("list_buffers"
            (let (names)
              (maphash (lambda (k _v) (push k names))
                       (crdt--session-buffer-table madrigal--server-session))
              (setq row (append row (list (cons 'buffers (nreverse names)))))))
                ("switch_buffer"
            (let* ((name0 (or (madrigal--alist-get* 'network_name raw-op)
                              (madrigal--alist-get* :network_name raw-op)
                              (madrigal--alist-get* 'buffer raw-op)
                             (madrigal--alist-get* :buffer raw-op)))
                   (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
              (setq row (append row
                                (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)
                                 (madrigal--alist-get* 'text raw-op)
                                (madrigal--alist-get* :text raw-op)
                                (madrigal--alist-get* 'query raw-op)
                                (madrigal--alist-get* :query 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))
                    (required0 (or (madrigal--alist-get* 'required raw-op)
                                   (madrigal--alist-get* :required raw-op)
                                   nil))
                    (wrap-present (or (madrigal--obj-has-key-p raw-op 'wrap)
                                      (madrigal--obj-has-key-p raw-op :wrap)))
                    (wrap0 (or (madrigal--alist-get* 'wrap raw-op)
                               (madrigal--alist-get* :wrap raw-op)))
                    (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))))
                    (required-p (not (memq required0 '(nil :false false))))
                    (wrap-p (if wrap-present
                                (not (memq wrap0 '(nil :false false)))
                              t)))
               (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)
                       (missing nil))
                   (cl-loop repeat count do
                            (progn
                              (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
                                (setq missing t)
                                (cl-return))))
                   (when (and missing required-p)
                     (error "madrigal: search_forward needle not found"))
                   (when (and found set-region-p)
                     (madrigal--set-region replica (- (point) (length needle)) (point)))
                   (setq row (append row
                                     (list (cons 'found (and found t))
                                           (cons 'point (point))
                                           (cons 'match_start (and found (- (point) (length needle))))
                                           (cons 'match_end (and found (point)))
                                           (cons 'wrapped wrapped))))))))
                ("search_backward"
             (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                 (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)))
                   (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))
                    (required0 (or (madrigal--alist-get* 'required raw-op)
                                   (madrigal--alist-get* :required raw-op)
                                   nil))
                    (wrap-present (or (madrigal--obj-has-key-p raw-op 'wrap)
                                      (madrigal--obj-has-key-p raw-op :wrap)))
                    (wrap0 (or (madrigal--alist-get* 'wrap raw-op)
                               (madrigal--alist-get* :wrap raw-op)))
                    (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))))
                    (required-p (not (memq required0 '(nil :false false))))
                    (wrap-p (if wrap-present
                                (not (memq wrap0 '(nil :false false)))
                              t)))
               (when (string-empty-p needle)
                 (error "madrigal: needle must be non-empty"))
               (when (<= count 0)
                 (error "madrigal: count must be > 0"))

[4.9624]

[2.6417]

             (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))

Replacement in madrigal.el at line 584 [4.1]

B:BD[2.6461] → [2.6461:7892]

∅:D[5.5211] → [7.8239:8471]

∅:D[2.7892] → [7.8239:8471]

B:BD[7.8239] → [7.8239:8471]

∅:D[7.8471] → [4.11472:11784]

B:BD[4.11472] → [4.11472:11784]

B:BD[4.11784] → [3.7909:8160]

B:BD[3.8160] → [7.8472:8949]

∅:D[7.8949] → [3.8619:9353]

B:BD[3.8619] → [3.8619:9353]

∅:D[3.9353] → [4.12122:12247]

B:BD[4.12122] → [4.12122:12247]

B:BD[4.12247] → [7.8950:9194]

∅:D[7.9194] → [4.12727:12769]

B:BD[4.12727] → [4.12727:12769]

B:BD[4.12832] → [4.12832:12861]

                 (let ((found nil)
                       (wrapped nil)
                       (missing nil))
                   (cl-loop repeat count do
                            (progn
                              (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
                                (setq missing t)
                                (cl-return))))
                   (when (and missing required-p)
                     (error "madrigal: search_backward needle not found"))
                   (when (and found set-region-p)
                     (madrigal--set-region replica found (+ found (length needle))))
                   (when found
                     (goto-char found))
                   (setq row (append row
                                     (list (cons 'found (and found t))
                                           (cons 'point (point))
                                           (cons 'match_start found)
                                           (cons 'match_end (and found (+ found (length needle))))
                                           (cons 'wrapped wrapped))))))))
                ("set_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")))
             (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
                                                (min s e)
                                                (max s e))))))))))
                ("insert_text"
            (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                              (madrigal--alist-get* :text raw-op)))
                   (text (format "%s" (madrigal--resolve-ref text0 results))))
             (with-current-buffer replica
               (insert text)

[2.6461]

[4.12861]

                 (goto-char (point-min)))

Replacement in madrigal.el at line 586 [4.1]

B:BD[4.12898] → [4.12898:13035]

B:BD[4.13035] → [7.9195:9391]

∅:D[7.9391] → [3.9632:9847]

B:BD[3.9632] → [3.9632:9847]

B:BD[3.9847] → [7.9392:9642]

                                 (list (cons 'point (point))
                                       (cons 'inserted (length text))))))))
                ("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)
                              (madrigal--alist-get* :text raw-op)))
                   (text (format "%s" (madrigal--resolve-ref text0 results))))

[4.12898]

[4.14613]

                                 (list (cons 'path path)
                                       (cons 'network_name network-name)
                                       (cons 'buffer (buffer-name replica))))))))
          ("list_buffers"
           (let (names)
             (maphash (lambda (k _v) (push k names))
                      (crdt--session-buffer-table madrigal--server-session))
             (setq row (append row (list (cons 'buffers (nreverse names)))))))
          ("switch_buffer"
           (let* ((name0 (or (madrigal--alist-get* 'network_name raw-op)
                             (madrigal--alist-get* :network_name raw-op)
                             (madrigal--alist-get* 'buffer raw-op)
                             (madrigal--alist-get* :buffer raw-op)))
                  (name (madrigal--resolve-ref name0 results)))
             (setq replica (madrigal--ensure-agent-replica agent name))

Replacement in madrigal.el at line 602 [4.1]

B:BD[4.14655] → [3.9944:10096]

∅:D[3.10096] → [4.14872:14903]

B:BD[4.14872] → [4.14872:14903]

B:BD[4.14903] → [3.10097:10147]

∅:D[3.10147] → [4.14903:15084]

B:BD[4.14903] → [4.14903:15084]

B:BD[4.15084] → [7.9643:9884]

∅:D[7.9884] → [3.10380:10447]

B:BD[3.10380] → [3.10380:10447]

               (pcase-let ((`(,s . ,e) (madrigal--region-bounds-required replica)))
                 (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)))))))))
                ("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)))

[4.14655]

[3.10447]

               (goto-char (point-min)))
             (setq network-name name)
             (setq row (append row
                               (list (cons 'network_name network-name)
                                     (cons 'buffer (buffer-name replica)))))))
          ("move"
           (let* ((direction0 (or (madrigal--alist-get* 'direction raw-op)
                                  (madrigal--alist-get* :direction raw-op)
                                  'forward))
                  (unit0 (or (madrigal--alist-get* 'unit raw-op)
                             (madrigal--alist-get* :unit raw-op)
                             (madrigal--alist-get* 'by raw-op)
                             (madrigal--alist-get* :by raw-op)
                             'char))

Replacement in madrigal.el at line 619 [4.1]

B:BD[3.10615] → [3.10615:10773]

                  (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                  (text (format "%s" (madrigal--resolve-ref text0 results)))

[3.10615]

[3.10773]

                  (direction (downcase (format "%s" (madrigal--resolve-ref direction0 results))))
                  (unit (downcase (format "%s" (madrigal--resolve-ref unit0 results))))

Replacement in madrigal.el at line 622 [4.1]

B:BD[3.10825] → [3.10825:11004]

                          (madrigal--resolve-ref count0 results) "count")))
             (when (string-empty-p needle)
              (error "madrigal: needle must be non-empty"))

[3.10825]

[3.11004]

                          (madrigal--resolve-ref count0 results) "count"))
                  (forward-p (string= direction "forward")))
             (unless (member direction '("forward" "backward"))
               (error "madrigal: move direction must be forward/backward"))
             (unless (member unit '("char" "line" "word" "symbol" "sexp" "buffer"))
               (error "madrigal: move unit must be char/line/word/symbol/sexp/buffer"))

Insertion in madrigal.el at line 630 [4.1]

[3.11090]

             (with-current-buffer replica
               (let ((before (point)))
                (pcase unit
                  ("char" (funcall (if forward-p #'forward-char #'backward-char) count))
                  ("line" (forward-line (if forward-p count (- count))))
                  ("word" (funcall (if forward-p #'forward-word #'backward-word) count))
                  ("symbol" (forward-symbol (if forward-p count (- count))))
                  ("sexp" (funcall (if forward-p #'forward-sexp #'backward-sexp) count))
                  ("buffer" (goto-char (if forward-p (point-max) (point-min)))))
                (setq row (append row
                                  (list (cons 'moved_chars (abs (- (point) before))))))))))
          ("search"
           (let* ((direction0 (or (madrigal--alist-get* 'direction raw-op)
                                  (madrigal--alist-get* :direction raw-op)
                                  'forward))
                  (needle0 (or (madrigal--alist-get* 'needle raw-op)
                               (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)))
                  (direction (downcase (format "%s" (madrigal--resolve-ref direction0 results))))
                  (needle (format "%s" (madrigal--resolve-ref needle0 results)))
                  (forward-p (string= direction "forward"))
                  (backward-p (string= direction "backward")))
             (unless (or forward-p backward-p)
               (error "madrigal: search direction must be forward/backward"))
             (when (string-empty-p needle)
               (error "madrigal: needle must be non-empty"))

Replacement in madrigal.el at line 660 [4.1]

B:BD[3.11133] → [3.11133:11915]

                 (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"))

[3.11133]

[3.11915]

                (let ((found nil)
                      (match-len (length needle)))
                  (setq found (if forward-p
                                  (search-forward needle nil t)
                                (search-backward needle nil t)))
                  (setq row (append row
                                    (list (cons 'match_length (if found match-len 0)))))))))
          ("set_mark"
           (with-current-buffer replica
             (push-mark (point) t t)
             (setq mark-active t
                   deactivate-mark nil)
             (setq row (append row
                               (list (cons 'mark_set t)
                                     (cons 'region_active (and (use-region-p) t)))))))
          ("clear_region"
           (madrigal--clear-region replica)
           (setq row (append row (list (cons 'region_active nil)))))
          ("read_selection"
           (with-current-buffer replica
              (if (use-region-p)
                  (let* ((s (region-beginning))
                         (e (region-end))
                         (text (buffer-substring-no-properties s e)))

Replacement in madrigal.el at line 685 [4.1]

B:BD[3.11957] → [3.11957:12099]

B:BD[3.12099] → [7.9885:10223]

∅:D[7.10223] → [3.12429:12961]

B:BD[3.12429] → [3.12429:12961]

                                      (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)))))

[3.11957]

[3.12961]

                                      (list (cons 'text text)
                                            (cons 'length (length text))))))
                (setq row (append row
                                  (list (cons 'text "")
                                        (cons 'length 0)))))))
          ("insert_text"
           (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                              (madrigal--alist-get* :text raw-op)))
                   (text (format "%s" (madrigal--resolve-ref text0 results))))

Replacement in madrigal.el at line 695 [4.1]

B:BD[3.13004] → [3.13004:13312]

                (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))

[3.13004]

[3.13312]

                (insert text)
                (setq row (append row
                                  (list (cons 'success t)))))))
          ("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 'success t)))))))
          ("replace_selection"
           (let* ((text0 (or (madrigal--alist-get* 'text raw-op)
                              (madrigal--alist-get* :text raw-op)))
                   (text (format "%s" (madrigal--resolve-ref text0 results))))
              (with-current-buffer replica
                (pcase-let ((`(,s . ,e) (madrigal--region-bounds-required replica)))

Replacement in madrigal.el at line 716 [4.1]

B:BD[3.13505] → [3.13505:13649]

B:BD[3.13649] → [7.10224:10255]

B:BD[7.10255] → [2.7893:7946]

                                    (list (cons 'point (point))
                                          (cons 'inserted (length text)))))))))
                ("save_buffer"
             (if (not madrigal-allow-save-buffer-op)

[3.13505]

[2.7946]

                                    (list (cons 'success t))))))))
          ("save_buffer"
           (if (not madrigal-allow-save-buffer-op)
               (setq row (append row
                                 (list (cons 'saved nil)
                                       (cons 'skipped t)
                                       (cons 'reason "user-save-required"))))
             (let ((server-buffer (madrigal--server-buffer-from-network-name network-name)))
               (unless (buffer-live-p server-buffer)
                 (error "madrigal: no server buffer for %s" network-name))
               (unless (madrigal--flush-replica-to-server
                        replica agent-session server-buffer madrigal-save-sync-timeout)
                 (error "madrigal: timed out waiting for CRDT sync before save"))
               (with-current-buffer server-buffer
                 (when (and buffer-file-name (buffer-modified-p))
                   (save-buffer))

Replacement in madrigal.el at line 733 [4.1]

B:BD[2.7985] → [2.7985:9003]

∅:D[2.9003] → [7.10474:10554]

B:BD[4.15658] → [7.10474:10554]

                                   (list (cons 'saved nil)
                                         (cons 'skipped t)
                                         (cons 'reason "user-save-required"))))
               (let ((server-buffer (madrigal--server-buffer-from-network-name network-name)))
                 (unless (buffer-live-p server-buffer)
                   (error "madrigal: no server buffer for %s" network-name))
                 (unless (madrigal--flush-replica-to-server
                          replica agent-session server-buffer madrigal-save-sync-timeout)
                   (error "madrigal: timed out waiting for CRDT sync before save"))
                 (with-current-buffer server-buffer
                   (when (and buffer-file-name (buffer-modified-p))
                     (save-buffer))
                   (setq row (append row
                                     (list (cons 'saved (and buffer-file-name t))
                                           (cons 'path buffer-file-name))))))))
                (_
                 (error "madrigal: unknown op %s" op-name)))

[2.7985]

[7.10554]

                                   (list (cons 'saved (and buffer-file-name t))
                                         (cons 'path buffer-file-name))))))))
          (_
           (error "madrigal: unknown op %s" op-name)))

Replacement in madrigal.el at line 750 [4.1]

B:BD[6.2252] → [2.9004:9170]

∅:D[2.9170] → [6.2416:2513]

B:BD[6.2416] → [6.2416:2513]

       "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. "

[6.2252]

[6.2513]

       "Operations: open_file, list_buffers, switch_buffer, move, search, set_mark, clear_region, read_selection, "
       "insert_text, delete_selection, replace_selection. "

Replacement in madrigal.el at line 753 [4.1]

B:BD[6.2609] → [2.9171:9337]

∅:D[2.9337] → [6.2731:2809]

B:BD[6.2731] → [6.2731:2809]

       "search_forward/search_backward support needle plus text/query aliases, optional wrap boolean (default true), and optional required boolean (default false). "
       "Supports references like $1.point to consume previous step outputs.")

[6.2609]

[4.16219]

       "move returns moved_chars. search supports direction (forward/backward) and needle (text/query aliases); it returns match_length (0 when not found). "
       "Supports references like $1.field to consume previous step outputs.")