fitzgibbon/madrigal - Change IWZF5VWU3D57MRTTJOW3T76BLZJN76QJURLCBMJFXIMS2W2VEU2AC

fix agent tooling again

Created by G8qzBDPkyFWiTEg4ytm8NUw2bhYLjE9mvCJek2frJAVK on February 19, 2026

IWZF5VWU3D57MRTTJOW3T76BLZJN76QJURLCBMJFXIMS2W2VEU2AC

Dependencies

In channels

main

Change contents

Replacement in madrigal.el at line 128 [4.1]

B:BD[3.1463] → [3.1463:1487]

  (insert (or text ""))

[3.1463]

[3.1487]

  (let ((body (replace-regexp-in-string
               "^#\\+end_example\\b"
               ",#+end_example"
               (or text "")
               nil
               nil
               0)))
    (insert body))

Insertion in madrigal.el at line 367 [4.1]

[5.240]

     "Search ops return found=false when no match; set required=true to fail hard."

Insertion in madrigal.el at line 408 [4.1]

[4.7366]

(defun madrigal--obj-has-key-p (obj key)
  (and (listp obj)
       (let* ((base (if (keywordp key)
                        (substring (symbol-name key) 1)
                      (and (symbolp key) (symbol-name key))))
              (plain (and base (intern base)))
              (kword (and base (intern (format ":%s" base)))))
         (or (and (symbolp key) (assq key obj))
             (and plain (assq plain obj))
             (and kword (assq kword obj))
             (and base (assoc base obj))
             (and (keywordp key) (plist-member obj key))))))

Replacement in madrigal.el at line 426 [4.1]

B:BD[4.7633] → [5.328:416]

∅:D[5.416] → [4.7672:7808]

B:BD[4.7672] → [4.7672:7808]

             (step (or (nth idx results)
                       (car (last results)))))
        (or (madrigal--alist-get* field step)
            (madrigal--alist-get* (intern (format ":%s" field)) step)
            value))

[4.7633]

[4.7808]

             (step-count (length results)))
        (unless (and (>= idx 0) (< idx step-count))
          (error "madrigal: invalid reference %s (step out of range)" value))
        (let* ((step (nth idx results))
               (resolved (or (madrigal--alist-get* field step)
                             (madrigal--alist-get* (intern (format ":%s" field)) step))))
          (if resolved
              resolved
            (error "madrigal: invalid reference %s (field missing)" value))))

Replacement in madrigal.el at line 438 [4.1]

B:BD[4.7868] → [4.7868:7954]

  (unless (integerp value)
    (error "madrigal: %s must be integer" field))
  value)

[4.7868]

[4.7954]

  (let ((parsed
         (cond
          ((integerp value) value)
          ((and (floatp value)
                (= value (truncate value)))
           (truncate value))
          ((and (stringp value)
                (string-match-p "^-?[0-9]+$" value))
           (string-to-number value))
          (t nil))))
    (unless (integerp parsed)
      (error "madrigal: %s must be integer" field))
    parsed))

Replacement in madrigal.el at line 588 [4.1]

B:BD[3.7616] → [3.7616:7686]

B:BD[3.7686] → [5.417:555]

            (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                (madrigal--alist-get* :needle raw-op)
                                (madrigal--alist-get* 'text raw-op)

[3.7616]

[5.555]

             (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                 (madrigal--alist-get* :needle raw-op)
                                 (madrigal--alist-get* 'text raw-op)

Replacement in madrigal.el at line 597 [4.1]

B:BD[5.867] → [5.867:2798]

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

[5.867]

[3.7901]

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

Replacement in madrigal.el at line 645 [4.1]

B:BD[3.7936] → [3.7936:8006]

B:BD[3.8006] → [5.2799:2937]

            (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                (madrigal--alist-get* :needle raw-op)
                                (madrigal--alist-get* 'text raw-op)

[3.7936]

[5.2937]

             (let* ((needle0 (or (madrigal--alist-get* 'needle raw-op)
                                 (madrigal--alist-get* :needle raw-op)
                                 (madrigal--alist-get* 'text raw-op)

Replacement in madrigal.el at line 654 [4.1]

B:BD[5.3249] → [5.3249:5211]

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

[5.3249]

[3.8239]

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

Replacement in madrigal.el at line 832 [4.1]

B:BD[3.10255] → [2.1429:2162]

∅:D[2.2162] → [4.15468:15658]

B:BD[4.15468] → [4.15468:15658]

             (unless madrigal-allow-save-buffer-op
               (error "madrigal: save_buffer disabled; user should save explicitly"))
             (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)))))))

[3.10255]

[3.10474]

             (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))
                   (setq row (append row
                                     (list (cons 'saved (and buffer-file-name t))
                                           (cons 'path buffer-file-name))))))))

Replacement in madrigal.el at line 864 [4.1]

B:BD[2.2252] → [2.2252:2416]

      "Operations: open_file, list_buffers, switch_buffer, get_point, goto_char, "
      "search_forward, search_backward, set_region, clear_region, read_region, "

[2.2252]

[2.2416]

       "Operations: open_file, list_buffers, switch_buffer, get_point, goto_char, "
       "search_forward, search_backward, set_region, clear_region, read_region, "

Replacement in madrigal.el at line 868 [4.1]

B:BD[2.2609] → [2.2609:2731]

       "search_forward/search_backward support needle plus text/query aliases and optional wrap boolean (default true). "

[2.2609]

[2.2731]

       "search_forward/search_backward support needle plus text/query aliases, optional wrap boolean (default true), and optional required boolean (default false). "

Replacement in madrigal.el at line 904 [4.1]

B:BD[3.12109] → [3.12109:12428]

             (lambda (final)
               (madrigal--log-round request-id round-no final)
               (if (plist-get final :tool-results)
                   (madrigal--run-model-loop provider prompt (1- rounds-left) done request-id (1+ round-no))
                 (funcall done (list :status 'ok :result final))))

[3.12109]

[3.12428]

              (lambda (final)
                (madrigal--log-round request-id round-no final)
                (if (and (plist-get final :tool-results)
                         (string-empty-p (or (plist-get final :text) "")))
                    (madrigal--run-model-loop provider prompt (1- rounds-left) done request-id (1+ round-no))
                  (funcall done (list :status 'ok :result final))))

Replacement in madrigal.el at line 916 [4.1]

B:BD[4.17221] → [4.17221:17248]

B:BD[4.17248] → [3.12679:12740]

∅:D[3.12740] → [4.17248:17297]

B:BD[4.17248] → [4.17248:17297]

B:BD[4.17297] → [3.12741:12947]

           (lambda (final)
             (madrigal--log-round request-id round-no final)
             (if (plist-get final :tool-results)
                 (madrigal--run-model-loop provider prompt (1- rounds-left) done request-id (1+ round-no))
               (funcall done (list :status 'ok :result final :fallback 'non-streaming-tool-use))))

[4.17000]

[4.17444]

            (lambda (final)
              (madrigal--log-round request-id round-no final)
              (if (and (plist-get final :tool-results)
                       (string-empty-p (or (plist-get final :text) "")))
                  (madrigal--run-model-loop provider prompt (1- rounds-left) done request-id (1+ round-no))
                (funcall done (list :status 'ok :result final :fallback 'non-streaming-tool-use))))