@nbardy/oompa 0.7.1 → 0.7.2

package/agentnet/src/agentnet/worker.clj

@@ -75,8 +75,8 @@
         local-tasks (io/file cwd-file "tasks")
         parent-tasks (some-> cwd-file .getParentFile (io/file "tasks"))]
     (cond
-      (.exists local-tasks) "tasks"
       (and parent-tasks (.exists parent-tasks)) "../tasks"
+      (.exists local-tasks) "tasks"
       :else "tasks")))
 
 (defn- render-task-header
@@ -90,6 +90,7 @@
         (str/replace "{TASKS_ROOT}" task-root))))
 
 (def ^:private default-max-working-resumes 5)
+(def ^:private default-max-wait-for-tasks 600)
 
 (defn create-worker
   "Create a worker config.
@@ -97,16 +98,22 @@
    :can-plan when false, worker waits for tasks before starting (backpressure).
    :reasoning reasoning effort level (e.g. \"low\", \"medium\", \"high\") — codex only.
    :review-prompts paths to reviewer prompt files (loaded and concatenated for review).
-   :wait-between seconds to sleep between iterations (nil or 0 = no wait).
+   :wait-between seconds to sleep between cycles (nil or 0 = no wait).
+   :max-wait-for-tasks max seconds a non-planner waits for tasks before giving up (default 600).
    :max-working-resumes max consecutive working resumes before nudge+kill (default 5)."
-  [{:keys [id swarm-id harness model iterations prompts can-plan reasoning
-           review-harness review-model review-prompts wait-between
-           max-working-resumes]}]
+  [{:keys [id swarm-id harness model runs max-cycles iterations prompts can-plan reasoning
+           reviewers wait-between
+           max-working-resumes max-wait-for-tasks]}]
+  (let [cycle-cap (or max-cycles iterations runs 10)
+        run-goal (or runs iterations 10)]
   {:id id
    :swarm-id swarm-id
    :harness (or harness :codex)
    :model model
-   :iterations (or iterations 10)
+   ;; Legacy compatibility: :iterations remains the cycle cap.
+   :iterations cycle-cap
+   :max-cycles cycle-cap
+   :runs run-goal
    :prompts (cond
               (vector? prompts) prompts
               (string? prompts) [prompts]
@@ -114,15 +121,14 @@
    :can-plan (if (some? can-plan) can-plan true)
    :reasoning reasoning
    :wait-between (when (and wait-between (pos? wait-between)) wait-between)
-   :review-harness review-harness
-   :review-model review-model
-   :review-prompts (cond
-                     (vector? review-prompts) review-prompts
-                     (string? review-prompts) [review-prompts]
-                     :else [])
+   :max-wait-for-tasks (let [v (or max-wait-for-tasks default-max-wait-for-tasks)]
+                         (if (and (number? v) (pos? v))
+                           v
+                           default-max-wait-for-tasks))
+   :reviewers reviewers
    :max-working-resumes (or max-working-resumes default-max-working-resumes)
    :completed 0
-   :status :idle})
+   :status :idle}))
 
 ;; =============================================================================
 ;; Task Execution
@@ -267,7 +273,7 @@
    Uses custom review-prompts when configured, otherwise falls back to default.
    prev-feedback: vector of previous review outputs (for multi-round context).
    Returns {:verdict :approved|:needs-changes|:rejected, :comments [...], :output string}"
-  [{:keys [id swarm-id review-harness review-model review-prompts]} worktree-path prev-feedback]
+  [{:keys [id swarm-id reviewers]} worktree-path prev-feedback]
   (let [;; Get actual diff content (not just stat) — truncate to 8000 chars for prompt budget
         diff-result (process/sh ["git" "diff" "main"]
                                 {:dir worktree-path :out :string :err :string})
@@ -277,15 +283,9 @@
                          d))
 
         swarm-id* (or swarm-id "unknown")
-        custom-prompt (when (seq review-prompts)
-                        (->> review-prompts
-                             (map load-prompt)
-                             (remove nil?)
-                             (str/join "\n\n")))
 
         ;; Only include the most recent round's feedback — the worker has already
         ;; attempted fixes based on it, so the reviewer just needs to verify.
-        ;; Including all prior rounds bloats the prompt and causes empty output.
         history-block (when (seq prev-feedback)
                         (let [latest (last prev-feedback)
                               truncated (if (> (count latest) 2000)
@@ -297,40 +297,52 @@
                                truncated
                                "\n\n")))
 
-        review-body (str (or custom-prompt
-                              (str "Review the changes in this worktree.\n"
-                                   "Focus on architecture and design, not style.\n"))
-                         "\n\nDiff:\n```\n" diff-content "\n```\n"
-                         (when history-block history-block)
-                         "\nYour verdict MUST be on its own line, exactly one of:\n"
-                         "VERDICT: APPROVED\n"
-                         "VERDICT: NEEDS_CHANGES\n\n"
-                         "Do NOT use REJECTED. Always use NEEDS_CHANGES with specific, "
-                         "actionable feedback explaining what must change and why. "
-                         "The worker will attempt fixes based on your feedback.\n"
-                         "After your verdict line, list every issue as a numbered item with "
-                         "the file path and what needs to change.\n")
-        review-prompt (str "[oompa:" swarm-id* ":" id "] " review-body)
-
         abs-wt (.getAbsolutePath (io/file worktree-path))
 
-        ;; No session, no resume, no format flags — reviewer is stateless one-shot
-        cmd (harness/build-cmd review-harness
-              {:cwd abs-wt :model review-model :prompt review-prompt})
-
-        result (try
-                 (process/sh cmd {:dir abs-wt
-                                  :in (harness/process-stdin review-harness review-prompt)
-                                  :out :string :err :string})
-                 (catch Exception e
-                   {:exit -1 :out "" :err (.getMessage e)}))
+        ;; Try each reviewer until one succeeds and returns a verdict
+        result (reduce (fn [_ {:keys [harness model prompts]}]
+                         (let [custom-prompt (when (seq prompts)
+                                               (->> prompts
+                                                    (map load-prompt)
+                                                    (remove nil?)
+                                                    (str/join "\n\n")))
+                               review-body (str (or custom-prompt
+                                                     (str "Review the changes in this worktree.\n"
+                                                          "Focus on architecture and design, not style.\n"))
+                                                "\n\nDiff:\n```\n" diff-content "\n```\n"
+                                                (when history-block history-block)
+                                                "\nYour verdict MUST be on its own line, exactly one of:\n"
+                                                "VERDICT: APPROVED\n"
+                                                "VERDICT: NEEDS_CHANGES\n\n"
+                                                "Do NOT use REJECTED. Always use NEEDS_CHANGES with specific, "
+                                                "actionable feedback explaining what must change and why. "
+                                                "The worker will attempt fixes based on your feedback.\n"
+                                                "After your verdict line, list every issue as a numbered item with "
+                                                "the file path and what needs to change.\n")
+                               review-prompt (str "[oompa:" swarm-id* ":" id "] " review-body)
+                               cmd (harness/build-cmd harness {:cwd abs-wt :model model :prompt review-prompt})
+                               res (try
+                                        (process/sh cmd {:dir abs-wt
+                                                         :in (harness/process-stdin harness review-prompt)
+                                                         :out :string :err :string})
+                                        (catch Exception e
+                                          {:exit -1 :out "" :err (.getMessage e)}))
+                               output (or (:out res) "")
+                               has-verdict? (or (re-find #"VERDICT:\s*APPROVED" output)
+                                                (re-find #"VERDICT:\s*NEEDS_CHANGES" output)
+                                                (re-find #"VERDICT:\s*REJECTED" output)
+                                                (re-find #"(?i)\bAPPROVED\b" output))]
+                           (if (and (= (:exit res) 0) has-verdict?)
+                             (reduced res)
+                             (do
+                               (println (format "[%s] Reviewer %s failed or returned no verdict, falling back..." id model))
+                               res))))
+                       {:exit -1 :out "" :err "No reviewers configured or no verdict returned"}
+                       reviewers)
 
         output (:out result)
 
-        ;; Parse verdict — require explicit VERDICT: prefix to avoid false matches.
-        ;; REJECTED is treated as NEEDS_CHANGES: the reviewer must always give
-        ;; actionable feedback so the worker can attempt fixes. Hard rejection
-        ;; only happens when max review rounds are exhausted.
+        ;; Parse verdict
         verdict (cond
                   (re-find #"VERDICT:\s*APPROVED" output) :approved
                   (re-find #"VERDICT:\s*NEEDS_CHANGES" output) :needs-changes
@@ -499,12 +511,13 @@
   "Write cycle event log. Called at every cycle exit point.
    session-id links to the Claude CLI conversation transcript on disk.
    No mutable summary state — all state is derived from immutable cycle logs."
-  [swarm-id worker-id cycle start-ms session-id
+  [swarm-id worker-id cycle run start-ms session-id
    {:keys [outcome claimed-task-ids recycled-tasks error-snippet review-rounds]}]
   (let [duration-ms (- (System/currentTimeMillis) start-ms)]
     (runs/write-cycle-log!
       swarm-id worker-id cycle
-      {:outcome outcome
+      {:run run
+       :outcome outcome
        :duration-ms duration-ms
        :claimed-task-ids (vec (or claimed-task-ids []))
        :recycled-tasks (or recycled-tasks [])
@@ -641,7 +654,7 @@
    Writes review logs to runs/{swarm-id}/reviews/ for post-mortem analysis.
    Returns {:approved? bool, :attempts int}"
   [worker wt-path worker-id iteration]
-  (if-not (and (:review-harness worker) (:review-model worker))
+  (if (empty? (:reviewers worker))
     ;; No reviewer configured, auto-approve
     {:approved? true :attempts 0}
 
@@ -681,27 +694,33 @@
 ;; Worker Loop
 ;; =============================================================================
 
-;; Workers wait up to 10 minutes for tasks to appear before giving up.
+;; Workers can wait for tasks before giving up; default is 10 minutes.
 ;; This keeps workers alive while planners/designers ramp up the queue.
-(def ^:private max-wait-for-tasks 600)
 (def ^:private wait-poll-interval 10)
-(def ^:private max-consecutive-errors 3)
+(def ^:private max-consecutive-errors 5)
+
+(defn- backoff-sleep! [id errors]
+  (when (< errors max-consecutive-errors)
+    (let [wait-sec (* 60 (int (Math/pow 2 (dec errors))))]
+      (println (format "[%s] Backing off for %d seconds before next retry (%d/%d)..." id wait-sec errors (dec max-consecutive-errors)))
+      (Thread/sleep (* 1000 wait-sec)))))
+
 
 (defn- wait-for-tasks!
-  "Wait up to 10 minutes for pending/current tasks to appear. Used for
-   backpressure on workers that can't create their own tasks (can_plan: false).
+  "Wait up to max-wait-seconds for pending/current tasks to appear.
+   Used for backpressure on workers that can't create their own tasks (can_plan: false).
    Polls every 10 seconds, logs every 60 seconds."
-  [worker-id]
+  [worker-id max-wait-seconds]
   (loop [waited 0]
     (cond
       (pos? (tasks/pending-count)) true
       (pos? (tasks/current-count)) true
-      (>= waited max-wait-for-tasks)
+      (>= waited max-wait-seconds)
       (do (println (format "[%s] No tasks after %ds, giving up" worker-id waited))
           false)
       :else
       (do (when (zero? (mod waited 60))
-            (println (format "[%s] Waiting for tasks... (%ds/%ds)" worker-id waited max-wait-for-tasks)))
+            (println (format "[%s] Waiting for tasks... (%ds/%ds)" worker-id waited max-wait-seconds)))
           (Thread/sleep (* wait-poll-interval 1000))
           (recur (+ waited wait-poll-interval))))))
 
@@ -716,267 +735,257 @@
 (defn run-worker!
   "Run worker loop with persistent sessions.
 
-   Sessions persist across iterations — agents resume where they left off.
-   Worktrees persist until COMPLETE_AND_READY_FOR_MERGE triggers review+merge.
-   __DONE__ stops the worker entirely (planners only).
-
-   Tracks per-worker metrics: merges, rejections, errors, review-rounds-total.
-   Returns final worker state with metrics attached."
+   A run is a terminal outcome (merged/rejected/error-like).
+   A cycle is one worker turn/resume. Multiple cycles may occur in one run.
+   Cycle cap is controlled by :max-cycles (legacy key: :iterations)."
   [worker]
   (tasks/ensure-dirs!)
-  (let [{:keys [id iterations swarm-id wait-between]} worker
+  (let [{:keys [id runs max-cycles iterations swarm-id wait-between max-wait-for-tasks]} worker
+        cycle-cap (or max-cycles iterations 10)
+        run-goal (or runs iterations 10)
         project-root (System/getProperty "user.dir")]
-    (println (format "[%s] Starting worker (%s:%s%s, %d iterations%s)"
+    (println (format "[%s] Starting worker (%s:%s%s, goal=%d runs, cap=%d cycles%s)"
                      id
                      (name (:harness worker))
                      (or (:model worker) "default")
                      (if (:reasoning worker) (str ":" (:reasoning worker)) "")
-                     iterations
+                     run-goal
+                     cycle-cap
                      (if wait-between (format ", %ds between" wait-between) "")))
 
-    ;; Backpressure: workers that can't create tasks wait for tasks to exist
-    (when-not (:can-plan worker)
-      (wait-for-tasks! id))
+    (when (and (not (:can-plan worker))
+               (not (pos? (tasks/pending-count)))
+               (not (pos? (tasks/current-count))))
+      (wait-for-tasks! id max-wait-for-tasks))
 
-    ;; metrics tracks: {:merges N :rejections N :errors N :recycled N :review-rounds-total N :claims N}
-    (loop [iter 1
-           completed 0
+    (loop [cycle 1
+           completed-runs 0
            consec-errors 0
            metrics {:merges 0 :rejections 0 :errors 0 :recycled 0 :review-rounds-total 0 :claims 0}
-           session-id nil            ;; persistent session-id (nil = start fresh)
-           wt-state nil              ;; {:dir :branch :path} or nil
-           claimed-ids #{}           ;; task IDs claimed this session (reset on worktree destroy)
-           claim-resume-prompt nil   ;; override prompt for next iteration (from CLAIM results)
-           working-resumes 0]        ;; consecutive "working" outcomes in current session
+           session-id nil
+           wt-state nil
+           claimed-ids #{}
+           claim-resume-prompt nil
+           working-resumes 0]
       (let [finish (fn [status]
-                     (assoc worker :completed completed :status status
+                     (assoc worker :completed completed-runs
+                                   :runs-completed completed-runs
+                                   :cycles-completed (dec cycle)
+                                   :status status
                                    :merges (:merges metrics)
                                    :rejections (:rejections metrics)
                                    :errors (:errors metrics)
                                    :recycled (:recycled metrics)
                                    :review-rounds-total (:review-rounds-total metrics)
-                                   :claims (:claims metrics)))]
+                                   :claims (:claims metrics)))
+            current-run (inc completed-runs)]
         (cond
-          (> iter iterations)
+          (> cycle cycle-cap)
           (do
-            ;; Cleanup any lingering worktree
             (when wt-state
               (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state)))
-            (println (format "[%s] Completed %d iterations (%d merges, %d claims, %d rejections, %d errors, %d recycled)"
-                             id completed (:merges metrics) (:claims metrics) (:rejections metrics) (:errors metrics) (:recycled metrics)))
+            (println (format "[%s] Completed %d/%d runs in %d cycles (%d merges, %d claims, %d rejections, %d errors, %d recycled)"
+                             id completed-runs run-goal (dec cycle)
+                             (:merges metrics) (:claims metrics) (:rejections metrics) (:errors metrics) (:recycled metrics)))
             (finish :exhausted))
 
+          (>= completed-runs run-goal)
+          (do
+            (when wt-state
+              (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state)))
+            (println (format "[%s] Reached run goal: %d/%d runs in %d cycles"
+                             id completed-runs run-goal (dec cycle)))
+            (finish :completed))
+
           @shutdown-requested?
           (do
-            (println (format "[%s] Shutdown requested, stopping after %d iterations" id (dec iter)))
+            (println (format "[%s] Shutdown requested, stopping after %d cycles" id (dec cycle)))
             (when wt-state
-              ;; Recycle any claimed tasks back to pending so other workers can pick them up
               (when (seq claimed-ids)
                 (let [recycled (tasks/recycle-tasks! claimed-ids)]
                   (when (seq recycled)
                     (println (format "[%s] Recycled %d claimed task(s) on shutdown" id (count recycled))))))
               (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state)))
-            (emit-cycle-log! swarm-id id iter (System/currentTimeMillis) session-id
-              {:outcome :interrupted})
+            (emit-cycle-log! swarm-id id cycle current-run (System/currentTimeMillis) session-id
+                             {:outcome :interrupted})
             (finish :interrupted))
 
           :else
           (do
-          ;; Sleep between iterations when wait_between is configured
-          (maybe-sleep-between! id wait-between iter)
-
-          ;; Backpressure: non-planner workers wait for tasks between iterations too
-          (when (and (not (:can-plan worker))
-                     (not (pos? (tasks/pending-count)))
-                     (not (pos? (tasks/current-count))))
-            (println (format "[%s] Queue empty, waiting for tasks before iteration %d" id iter))
-            (wait-for-tasks! id))
-
-          ;; Ensure worktree exists (create fresh if nil, reuse if persisted)
-          (let [wt-state (try
-                           (or wt-state (create-iteration-worktree! project-root id iter))
-                           (catch Exception e
-                             (println (format "[%s] Worktree creation failed: %s" id (.getMessage e)))
-                             nil))]
-            (if (nil? wt-state)
-              ;; Worktree creation failed — count as error
-              (let [errors (inc consec-errors)
-                    metrics (update metrics :errors inc)]
-                (if (>= errors max-consecutive-errors)
-                  (do
-                    (println (format "[%s] %d consecutive errors, stopping" id errors))
-                    (finish :error))
-                  (recur (inc iter) completed errors metrics nil nil #{} nil 0)))
-
-              ;; Worktree ready — run agent
-              (let [resume? (or (some? session-id) (some? claim-resume-prompt))
-                    iter-start-ms (System/currentTimeMillis)
-                    ;; Snapshot current/ task IDs before agent runs so we can
-                    ;; detect any direct mv claims (safety net for old behavior).
-                    pre-current-ids (tasks/current-task-ids)
-                    _ (println (format "[%s] %s iteration %d/%d"
-                                       id (if resume? "Resuming" "Starting") iter iterations))
-                    context (build-context)
-                    {:keys [output exit done? merge? claim-ids] :as agent-result}
-                    (run-agent! worker (:path wt-state) context session-id resume?
-                                :resume-prompt-override claim-resume-prompt)
-                    new-session-id (:session-id agent-result)
-                    ;; Safety net: detect any direct mv claims (old behavior)
-                    mv-claimed-tasks (detect-claimed-tasks pre-current-ids)]
-
-                (cond
-                  ;; Agent errored — recycle claimed tasks, cleanup, reset session
-                  (not (zero? exit))
-                  (let [errors (inc consec-errors)
-                        recycled (recycle-orphaned-tasks! id pre-current-ids)
-                        metrics (-> metrics
-                                    (update :errors inc)
-                                    (update :recycled + recycled))
-                        error-msg (subs (or output "") 0 (min 200 (count (or output ""))))]
-                    (println (format "[%s] Agent error (exit %d): %s" id exit error-msg))
-                    (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                      {:outcome :error :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
-                       :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))
-                       :error-snippet error-msg})
-                    (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                    (if (>= errors max-consecutive-errors)
-                      (do
-                        (println (format "[%s] %d consecutive errors, stopping" id errors))
-                        (finish :error))
-                      (recur (inc iter) completed errors metrics nil nil #{} nil 0)))
-
-                  ;; CLAIM signal — framework claims tasks, resumes agent with results
-                  ;; Only honored when no MERGE or DONE signal (lowest priority)
-                  (and (seq claim-ids) (not merge?) (not done?))
-                  (let [_ (println (format "[%s] CLAIM signal: %s" id (str/join ", " claim-ids)))
-                        {:keys [claimed failed resume-prompt]} (execute-claims! claim-ids)
-                        new-claimed-ids (into claimed-ids claimed)
-                        metrics (update metrics :claims + (count claimed))]
-                    (println (format "[%s] Claimed %d/%d tasks" id (count claimed) (count claim-ids)))
-                    (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                      {:outcome :claimed :claimed-task-ids (vec claimed)})
-                    (recur (inc iter) completed 0 metrics new-session-id wt-state
-                           new-claimed-ids resume-prompt 0))
-
-                  ;; COMPLETE_AND_READY_FOR_MERGE — review, merge, reset session
-                  merge?
-                  (if (worktree-has-changes? (:path wt-state))
-                    (if (task-only-diff? (:path wt-state))
-                      ;; Task-only changes — skip review, sync to main, auto-merge
-                      (do
-                        (println (format "[%s] Task-only diff, auto-merging" id))
-                        (let [sync-status (sync-worktree-to-main! worker (:path wt-state) id)
-                              all-claimed (into claimed-ids mv-claimed-tasks)]
-                          (if (= :failed sync-status)
-                            ;; Sync failed — cannot merge safely, skip
-                            (do
-                              (println (format "[%s] Sync to main failed, skipping merge" id))
-                              (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                                {:outcome :sync-failed :claimed-task-ids (vec all-claimed)})
-                              (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                              (recur (inc iter) completed 0 metrics nil nil #{} nil 0))
-                            ;; Synced — proceed with merge
-                            (let [merged? (merge-to-main! (:path wt-state) (:branch wt-state) id project-root 0 all-claimed)
-                                  metrics (if merged? (update metrics :merges inc) metrics)]
-                              (println (format "[%s] Cycle %d/%d complete" id iter iterations))
-                              (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                                {:outcome :merged :claimed-task-ids (vec all-claimed) :review-rounds 0})
-                              (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                              (recur (inc iter) (inc completed) 0 metrics nil nil #{} nil 0)))))
-                      ;; Code changes — full review loop
-                      (let [{:keys [approved? attempts]} (review-loop! worker (:path wt-state) id iter)
-                            ;; Don't pre-increment :merges — defer to after actual merge succeeds
-                            metrics (-> metrics
-                                        (update :review-rounds-total + (or attempts 0))
-                                        (cond-> (not approved?) (update :rejections inc)))]
-                        (if approved?
+            (maybe-sleep-between! id wait-between cycle)
+
+            (when (and (not (:can-plan worker))
+                       (not (pos? (tasks/pending-count)))
+                       (not (pos? (tasks/current-count))))
+              (println (format "[%s] Queue empty, waiting for tasks before cycle %d" id cycle))
+              (wait-for-tasks! id max-wait-for-tasks))
+
+            (let [wt-state (try
+                             (or wt-state (create-iteration-worktree! project-root id cycle))
+                             (catch Exception e
+                               (println (format "[%s] Worktree creation failed: %s" id (.getMessage e)))
+                               nil))]
+              (if (nil? wt-state)
+                (let [errors (inc consec-errors)
+                      metrics (update metrics :errors inc)]
+                  (if (>= errors max-consecutive-errors)
+                    (do
+                      (println (format "[%s] %d consecutive errors, stopping" id errors))
+                      (finish :error))
+                    (do (backoff-sleep! id errors) (recur (inc cycle) completed-runs errors metrics nil nil #{} nil 0))))
+
+                (let [resume? (or (some? session-id) (some? claim-resume-prompt))
+                      cycle-start-ms (System/currentTimeMillis)
+                      pre-current-ids (tasks/current-task-ids)
+                      _ (println (format "[%s] %s cycle %d/%d (run %d/%d)"
+                                         id (if resume? "Resuming" "Starting") cycle cycle-cap current-run run-goal))
+                      context (build-context)
+                      {:keys [output exit done? merge? claim-ids] :as agent-result}
+                      (run-agent! worker (:path wt-state) context session-id resume?
+                                  :resume-prompt-override claim-resume-prompt)
+                      new-session-id (:session-id agent-result)
+                      mv-claimed-tasks (detect-claimed-tasks pre-current-ids)]
+                  (cond
+                    (not (zero? exit))
+                    (let [errors (inc consec-errors)
+                          recycled (recycle-orphaned-tasks! id pre-current-ids)
+                          metrics (-> metrics (update :errors inc) (update :recycled + recycled))
+                          error-msg (subs (or output "") 0 (min 200 (count (or output ""))))]
+                      (println (format "[%s] Agent error (exit %d): %s" id exit error-msg))
+                      (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                       {:outcome :error
+                                        :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
+                                        :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))
+                                        :error-snippet error-msg})
+                      (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                      (if (>= errors max-consecutive-errors)
+                        (do
+                          (println (format "[%s] %d consecutive errors, stopping" id errors))
+                          (finish :error))
+                        (do (backoff-sleep! id errors) (recur (inc cycle) (inc completed-runs) errors metrics nil nil #{} nil 0))))
+
+                    (and (seq claim-ids) (not merge?) (not done?))
+                    (let [_ (println (format "[%s] CLAIM signal: %s" id (str/join ", " claim-ids)))
+                          {:keys [claimed resume-prompt]} (execute-claims! claim-ids)
+                          new-claimed-ids (into claimed-ids claimed)
+                          metrics (update metrics :claims + (count claimed))]
+                      (println (format "[%s] Claimed %d/%d tasks" id (count claimed) (count claim-ids)))
+                      (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                       {:outcome :claimed :claimed-task-ids (vec claimed)})
+                      (recur (inc cycle) completed-runs 0 metrics new-session-id wt-state
+                             new-claimed-ids resume-prompt 0))
+
+                    merge?
+                    (if (worktree-has-changes? (:path wt-state))
+                      (if (task-only-diff? (:path wt-state))
+                        (do
+                          (println (format "[%s] Task-only diff, auto-merging" id))
                           (let [sync-status (sync-worktree-to-main! worker (:path wt-state) id)
                                 all-claimed (into claimed-ids mv-claimed-tasks)]
                             (if (= :failed sync-status)
-                              ;; Sync failed after approval — treat as sync failure, skip merge
                               (do
-                                (println (format "[%s] Sync to main failed after approval, skipping merge" id))
-                                (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                                  {:outcome :sync-failed :claimed-task-ids (vec all-claimed)
-                                   :review-rounds (or attempts 0)})
+                                (println (format "[%s] Sync to main failed, skipping merge" id))
+                                (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                                 {:outcome :sync-failed :claimed-task-ids (vec all-claimed)})
                                 (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                                (recur (inc iter) completed 0 metrics nil nil #{} nil 0))
-                              ;; Synced — proceed with merge, capture return value
-                              (let [merged? (merge-to-main! (:path wt-state) (:branch wt-state) id project-root (or attempts 0) all-claimed)
+                                (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0))
+                              (let [merged? (merge-to-main! (:path wt-state) (:branch wt-state) id project-root 0 all-claimed)
                                     metrics (if merged? (update metrics :merges inc) metrics)]
-                                (println (format "[%s] Cycle %d/%d complete" id iter iterations))
-                                (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                                  {:outcome (if merged? :merged :merge-failed)
-                                   :claimed-task-ids (vec all-claimed)
-                                   :review-rounds (or attempts 0)})
+                                (println (format "[%s] Cycle %d/%d complete" id cycle cycle-cap))
+                                (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                                 {:outcome (if merged? :merged :merge-failed)
+                                                  :claimed-task-ids (vec all-claimed)
+                                                  :review-rounds 0})
                                 (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                                (recur (inc iter) (inc completed) 0 metrics nil nil #{} nil 0))))
-                          (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
-                                metrics (update metrics :recycled + recycled)]
-                            (println (format "[%s] Cycle %d/%d rejected" id iter iterations))
-                            (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                              {:outcome :rejected :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
-                               :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))
-                               :review-rounds (or attempts 0)})
-                            (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                            (recur (inc iter) completed 0 metrics nil nil #{} nil 0)))))
-                    (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
-                          metrics (update metrics :recycled + recycled)]
-                      (println (format "[%s] Merge signaled but no changes, skipping" id))
-                      (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                        {:outcome :no-changes :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
-                         :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))})
-                      (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                      (recur (inc iter) completed 0 metrics nil nil #{} nil 0)))
-
-                  ;; __DONE__ — agent signaled it finished this cycle's work.
-                  ;; Always reset session and continue to next iteration.
-                  ;; Planners re-plan as tasks complete; executors pick up new tasks.
-                  done?
-                  (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
-                        metrics (update metrics :recycled + recycled)]
-                    (println (format "[%s] __DONE__ signal, resetting session (iter %d/%d)" id iter iterations))
-                    (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                      {:outcome :executor-done :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
-                       :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))})
-                    (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                    (recur (inc iter) completed 0 metrics nil nil #{} nil 0))
-
-                  ;; No signal — agent still working, resume next iteration.
-                  ;; Track consecutive working resumes. After max-working-resumes,
-                  ;; inject a nudge prompt. If still no signal after nudge, kill session.
-                  :else
-                  (let [wr (inc working-resumes)
-                        max-wr (:max-working-resumes worker)]
-                    (cond
-                      ;; Already nudged last iteration, still no signal — stuck
-                      (> wr max-wr)
+                                (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0)))))
+                        (let [{:keys [approved? attempts]} (review-loop! worker (:path wt-state) id cycle)
+                              metrics (-> metrics
+                                          (update :review-rounds-total + (or attempts 0))
+                                          (cond-> (not approved?) (update :rejections inc)))]
+                          (if approved?
+                            (let [sync-status (sync-worktree-to-main! worker (:path wt-state) id)
+                                  all-claimed (into claimed-ids mv-claimed-tasks)]
+                              (if (= :failed sync-status)
+                                (do
+                                  (println (format "[%s] Sync to main failed after approval, skipping merge" id))
+                                  (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                                   {:outcome :sync-failed
+                                                    :claimed-task-ids (vec all-claimed)
+                                                    :review-rounds (or attempts 0)})
+                                  (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                                  (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0))
+                                (let [merged? (merge-to-main! (:path wt-state) (:branch wt-state) id project-root (or attempts 0) all-claimed)
+                                      metrics (if merged? (update metrics :merges inc) metrics)]
+                                  (println (format "[%s] Cycle %d/%d complete" id cycle cycle-cap))
+                                  (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                                   {:outcome (if merged? :merged :merge-failed)
+                                                    :claimed-task-ids (vec all-claimed)
+                                                    :review-rounds (or attempts 0)})
+                                  (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                                  (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0))))
+                            (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
+                                  metrics (update metrics :recycled + recycled)]
+                              (println (format "[%s] Cycle %d/%d rejected" id cycle cycle-cap))
+                              (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                               {:outcome :rejected
+                                                :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
+                                                :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))
+                                                :review-rounds (or attempts 0)})
+                              (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                              (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0)))))
                       (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
                             metrics (update metrics :recycled + recycled)]
-                        (println (format "[%s] Stuck after %d working resumes + nudge, resetting session" id wr))
-                        (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                          {:outcome :stuck :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
-                           :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))})
+                        (println (format "[%s] Merge signaled but no changes, skipping" id))
+                        (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                         {:outcome :no-changes
+                                          :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
+                                          :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))})
                         (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
-                        (recur (inc iter) completed 0 metrics nil nil #{} nil 0))
-
-                      ;; Hit the limit — nudge on next resume
-                      (= wr max-wr)
-                      (do
-                        (println (format "[%s] Working... %d/%d resumes, nudging agent to wrap up" id wr max-wr))
-                        (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                          {:outcome :working :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))})
-                        (recur (inc iter) completed 0 metrics new-session-id wt-state
-                               claimed-ids nudge-prompt wr))
-
-                      ;; Under limit — normal resume
-                      :else
-                      (do
-                        (println (format "[%s] Working... (will resume, %d/%d)" id wr max-wr))
-                        (emit-cycle-log! swarm-id id iter iter-start-ms new-session-id
-                          {:outcome :working :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))})
-                        (recur (inc iter) completed 0 metrics new-session-id wt-state
-                               claimed-ids nil wr))))))))))))))
+                        (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0)))
+
+                    done?
+                    (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
+                          metrics (update metrics :recycled + recycled)]
+                      (println (format "[%s] __DONE__ signal, resetting session (cycle %d/%d)" id cycle cycle-cap))
+                      (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                       {:outcome :executor-done
+                                        :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
+                                        :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))})
+                      (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                      (recur (inc cycle) completed-runs 0 metrics nil nil #{} nil 0))
+
+                    :else
+                    (let [wr (inc working-resumes)
+                          max-wr (:max-working-resumes worker)]
+                      (cond
+                        (> wr max-wr)
+                        (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
+                              metrics (update metrics :recycled + recycled)]
+                          (println (format "[%s] Stuck after %d working resumes + nudge, resetting session" id wr))
+                          (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                           {:outcome :stuck
+                                            :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))
+                                            :recycled-tasks (when (pos? recycled) (vec mv-claimed-tasks))})
+                          (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                          (recur (inc cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0))
+
+                        (= wr max-wr)
+                        (do
+                          (println (format "[%s] Working... %d/%d resumes, nudging agent to wrap up" id wr max-wr))
+                          (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                           {:outcome :working
+                                            :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))})
+                          (recur (inc cycle) completed-runs 0 metrics new-session-id wt-state
+                                 claimed-ids nudge-prompt wr))
+
+                        :else
+                        (do
+                          (println (format "[%s] Working... (will resume, %d/%d)" id wr max-wr))
+                          (emit-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
+                                           {:outcome :working
+                                            :claimed-task-ids (vec (into claimed-ids mv-claimed-tasks))})
+                          (recur (inc cycle) completed-runs 0 metrics new-session-id wt-state
+                                 claimed-ids nil wr))))))))))))))
 
 ;; =============================================================================
 ;; Multi-Worker Execution