@nbardy/oompa 0.7.1 → 0.7.3

package/agentnet/src/agentnet/worker.clj

@@ -21,6 +21,7 @@
             [babashka.process :as process]
             [clojure.java.io :as io]
             [clojure.set]
+            [clojure.pprint :refer [print-table]]
             [clojure.string :as str]))
 
 ;; =============================================================================
@@ -40,6 +41,13 @@
 (def ^:private shutdown-requested? (atom false))
 
 (declare task-root-for-cwd)
+(declare verify-mergeable?)
+
+(defn- log-ts
+  "Readable wall-clock timestamp for worker log lines."
+  []
+  (.format (java.time.format.DateTimeFormatter/ofPattern "yyyy-MM-dd HH:mm:ss")
+           (java.time.LocalDateTime/now)))
 
 (defn- load-prompt
   "Load a prompt file. Tries path as-is first, then from package root."
@@ -47,6 +55,11 @@
   (or (agent/load-custom-prompt path)
       (agent/load-custom-prompt (str package-root "/" path))))
 
+(defn- snippet
+  [s limit]
+  (let [s (or s "")]
+    (subs s 0 (min limit (count s)))))
+
 (defn- build-template-tokens
   "Build token map for prompt template {var} substitution.
    Merges core/build-context (rich YAML header, queue, hotspots, etc.)
@@ -75,8 +88,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 +103,8 @@
         (str/replace "{TASKS_ROOT}" task-root))))
 
 (def ^:private default-max-working-resumes 5)
+(def ^:private default-max-needs-followups 1)
+(def ^:private default-max-wait-for-tasks 600)
 
 (defn create-worker
   "Create a worker config.
@@ -97,16 +112,23 @@
    :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).
-   :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]}]
+   :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).
+   :max-needs-followups max NEEDS_FOLLOWUP continuations in one cycle (default 1)."
+  [{:keys [id swarm-id harness model runs max-cycles iterations prompts can-plan reasoning
+           reviewers wait-between
+           max-working-resumes max-needs-followups 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 +136,15 @@
    :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)
+   :max-needs-followups (or max-needs-followups default-max-needs-followups)
    :completed 0
-   :status :idle})
+   :status :idle}))
 
 ;; =============================================================================
 ;; Task Execution
@@ -139,7 +161,9 @@
        "1. If you have meaningful changes: commit them and signal COMPLETE_AND_READY_FOR_MERGE\n"
        "2. If scope is too large: create follow-up tasks in tasks/pending/ for remaining work,\n"
        "   commit what you have (even partial notes/design docs), and signal COMPLETE_AND_READY_FOR_MERGE\n"
-       "3. If you are stuck and cannot make progress: signal __DONE__\n\n"
+       "3. If you truly cannot produce a merge-ready artifact this turn, signal NEEDS_FOLLOWUP\n"
+       "   and explain the remaining work. The framework will keep your claimed tasks and give you\n"
+       "   one targeted follow-up prompt. This is not success.\n\n"
        "Do NOT continue working without producing a signal."))
 
 (defn- build-context
@@ -181,11 +205,63 @@
                     "\n\n"
                     (if (seq claimed-ids)
                       "Work on your claimed tasks. Signal COMPLETE_AND_READY_FOR_MERGE when done."
-                      "No claims succeeded. CLAIM different tasks, or signal __DONE__ if no suitable work remains."))]
+                      "No claims succeeded. CLAIM different tasks. If you cannot finish a mergeable artifact after trying hard, signal NEEDS_FOLLOWUP with a short explanation."))]
     {:claimed claimed-ids
      :failed failed-ids
      :resume-prompt prompt}))
 
+(defn- active-claimed-task-ids
+  "Union of tasks claimed earlier in the cycle and tasks moved into current/
+   during the latest attempt."
+  [claimed-ids mv-claimed-tasks]
+  (-> (set claimed-ids)
+      (into mv-claimed-tasks)))
+
+(defn- recycle-task-id-set!
+  "Recycle a set of claimed task IDs from current/ back to pending/.
+   Returns a vector of recycled IDs."
+  [worker-id task-ids]
+  (let [task-ids (set (remove nil? task-ids))
+        recycled (when (seq task-ids)
+                   (tasks/recycle-tasks! task-ids))]
+    (when (seq recycled)
+      (println (format "[%s] Recycled %d claimed task(s): %s"
+                       worker-id (count recycled) (str/join ", " recycled))))
+    (vec (or recycled []))))
+
+(defn- recycle-active-claims!
+  "Recycle all claims active in the current cycle."
+  [worker-id claimed-ids mv-claimed-tasks]
+  (recycle-task-id-set! worker-id (active-claimed-task-ids claimed-ids mv-claimed-tasks)))
+
+(defn- build-needs-followup-prompt
+  "Prompt injected after NEEDS_FOLLOWUP so the worker keeps ownership and
+   closes the loop in the same cycle."
+  [claimed-ids output]
+  (let [context (build-context)
+        explanation (some-> output
+                            (str/replace #"(?is)^\s*NEEDS_FOLLOWUP\b[\s:.-]*" "")
+                            str/trim)]
+    (str "## NEEDS_FOLLOWUP Follow-up\n\n"
+         (if (seq claimed-ids)
+           (str "You still own these claimed tasks: "
+                (str/join ", " (sort claimed-ids))
+                "\n\n")
+           "You do not currently own any claimed tasks.\n\n")
+         "Continue the SAME cycle and finish a merge-ready artifact.\n"
+         "Do not output NEEDS_FOLLOWUP again unless you are still blocked after this follow-up.\n"
+         "Prefer the smallest useful diff. If scope is too large, create concrete follow-up tasks in the pending queue and still ship the artifact you have.\n\n"
+         (when (seq explanation)
+           (str "Your previous explanation:\n"
+                explanation
+                "\n\n"))
+         "Task Status: " (:task_status context) "\n"
+         "Remaining Pending:\n"
+         (if (str/blank? (:pending_tasks context))
+           "(none)"
+           (:pending_tasks context))
+         "\n\nWhen ready, signal COMPLETE_AND_READY_FOR_MERGE.")))
+
 (defn- run-agent!
   "Run agent with prompt, return {:output :done? :merge? :claim-ids :exit :session-id}.
    When resume? is true, continues the existing session with a lighter prompt.
@@ -239,36 +315,40 @@
         tagged-prompt (str "[oompa:" swarm-id* ":" id "] " prompt)
         abs-worktree (.getAbsolutePath (io/file worktree-path))
 
-        cmd (harness/build-cmd harness
-              {:cwd abs-worktree :model model :reasoning reasoning
-               :session-id session-id :resume? resume?
-               :prompt tagged-prompt :format? true})
-
         result (try
-                 (process/sh cmd {:dir abs-worktree
-                                  :in (harness/process-stdin harness tagged-prompt)
-                                  :out :string :err :string})
+                 (harness/run-command! harness
+                                       {:cwd abs-worktree :model model :reasoning reasoning
+                                        :session-id session-id :resume? resume?
+                                        :prompt tagged-prompt :format? true})
                  (catch Exception e
                    (println (format "[%s] Agent exception: %s" id (.getMessage e)))
                    {:exit -1 :out "" :err (.getMessage e)}))
 
-        {:keys [output session-id]}
-        (harness/parse-output harness (:out result) session-id)]
+        {:keys [output session-id warning raw-snippet]}
+        (harness/parse-output harness (:out result) session-id)
+        stderr-snippet (let [stderr (some-> (:err result) str/trim)]
+                         (when (seq stderr)
+                           (subs stderr 0 (min 400 (count stderr)))))]
 
     {:output output
      :exit (:exit result)
      :done? (agent/done-signal? output)
      :merge? (agent/merge-signal? output)
+     :needs-followup? (agent/needs-followup-signal? output)
      :claim-ids (agent/parse-claim-signal output)
-     :session-id session-id}))
+     :session-id session-id
+     :parse-warning warning
+     :raw-snippet raw-snippet
+     :stderr-snippet stderr-snippet}))
 
 (defn- run-reviewer!
   "Run reviewer on worktree changes.
    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]
-  (let [;; Get actual diff content (not just stat) — truncate to 8000 chars for prompt budget
+  [{:keys [id swarm-id reviewers]} worktree-path prev-feedback]
+  (let [start-ms (System/currentTimeMillis)
+        ;; 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})
         diff-content (let [d (:out diff-result)]
@@ -277,15 +357,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,46 +371,57 @@
                                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)
+                               res (try
+                                        (harness/run-command! harness {:cwd abs-wt :model model :prompt review-prompt})
+                                        (catch Exception e
+                                          {:exit -1 :out "" :err (.getMessage e)}))
+                               parsed (harness/parse-output harness (:out res) nil)
+                               output (or (:output parsed) "")
+                               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
                   (re-find #"VERDICT:\s*REJECTED" output) :needs-changes
                   (re-find #"(?i)\bAPPROVED\b" output) :approved
-                  :else :needs-changes)]
+                  :else :needs-changes)
+        duration-ms (- (System/currentTimeMillis) start-ms)]
 
     (println (format "[%s] Reviewer verdict: %s" id (name verdict)))
     (let [summary (subs output 0 (min 300 (count output)))]
@@ -346,14 +431,16 @@
     {:verdict verdict
      :comments (when (not= (:exit result) 0)
                  [(:err result)])
-     :output output}))
+     :output output
+     :duration-ms duration-ms}))
 
 (defn- run-fix!
   "Ask worker to fix issues based on reviewer feedback.
    all-feedback: vector of all reviewer outputs so far (accumulated across rounds).
    Returns {:output string, :exit int}"
   [{:keys [id swarm-id harness model]} worktree-path all-feedback]
-  (let [swarm-id* (or swarm-id "unknown")
+  (let [start-ms (System/currentTimeMillis)
+        swarm-id* (or swarm-id "unknown")
         feedback-text (if (> (count all-feedback) 1)
                         (str "The reviewer has given feedback across " (count all-feedback) " rounds.\n"
                              "Fix ALL outstanding issues:\n\n"
@@ -369,18 +456,17 @@
 
         abs-wt (.getAbsolutePath (io/file worktree-path))
 
-        cmd (harness/build-cmd harness
-              {:cwd abs-wt :model model :prompt fix-prompt})
-
         result (try
-                 (process/sh cmd {:dir abs-wt
-                                  :in (harness/process-stdin harness fix-prompt)
-                                  :out :string :err :string})
+                 (harness/run-command! harness
+                                       {:cwd abs-wt :model model :prompt fix-prompt})
                  (catch Exception e
-                   {:exit -1 :out "" :err (.getMessage e)}))]
+                   {:exit -1 :out "" :err (.getMessage e)}))
+        parsed (harness/parse-output harness (:out result) nil)
+        duration-ms (- (System/currentTimeMillis) start-ms)]
 
-    {:output (:out result)
-     :exit (:exit result)}))
+    {:output (:output parsed)
+     :exit (:exit result)
+     :duration-ms duration-ms}))
 
 (defn- collect-divergence-context
   "Collect context about how a worktree branch has diverged from main.
@@ -394,6 +480,65 @@
      :main-log   (or main-log "(none)")
      :diff-stat  (or diff-stat "(none)")}))
 
+(defn- first-nonblank-line
+  "Return first non-blank line from text for compact logging."
+  [s]
+  (some->> (or s "")
+           str/split-lines
+           (remove str/blank?)
+           first))
+
+(defn- classify-merge-failure
+  "Classify git merge/checkout failure text for better logs."
+  [failure-text]
+  (cond
+    (re-find #"untracked working tree files would be overwritten by merge" (or failure-text ""))
+    :untracked-overwrite
+    (re-find #"CONFLICT|Merge conflict" (or failure-text ""))
+    :conflict
+    (re-find #"Your local changes to the following files would be overwritten" (or failure-text ""))
+    :local-changes-overwrite
+    :else
+    :unknown))
+
+(defn- run-resolver-agent!
+  "Run resolver agent with divergence + failure context.
+   Returns :resolved when branch verifies as mergeable, else :failed."
+  [worker wt-path worker-id reason-details]
+  (println (format "[%s] Branch diverged from main, launching resolver agent%s"
+                   worker-id
+                   (if (str/blank? reason-details)
+                     ""
+                     (str " (" reason-details ")"))))
+  (let [{:keys [branch-log main-log diff-stat]} (collect-divergence-context wt-path)
+        resolve-prompt (str "[oompa:" (or (:swarm-id worker) "unknown") ":" worker-id "] "
+                            "Your branch cannot currently be merged safely into main.\n\n"
+                            (when-not (str/blank? reason-details)
+                              (str "Failure context from previous merge attempt:\n"
+                                   reason-details "\n\n"))
+                            "Your branch's commits (not on main):\n" branch-log "\n\n"
+                            "Commits on main since you branched:\n" main-log "\n\n"
+                            "Divergence scope:\n" diff-stat "\n\n"
+                            "Make this branch cleanly mergeable into main. "
+                            "Preserve the intent of your branch's changes.\n"
+                            "You have full git access — rebase, cherry-pick, resolve conflicts, "
+                            "or clean up merge blockers.\n"
+                            "When done, verify with: git diff main --stat")
+        abs-wt (.getAbsolutePath (io/file wt-path))
+        result (try
+                 (harness/run-command! (:harness worker)
+                                       {:cwd abs-wt :model (:model worker) :prompt resolve-prompt})
+                 (catch Exception e
+                   {:exit -1 :out "" :err (.getMessage e)}))]
+    (if (zero? (:exit result))
+      (if (verify-mergeable? wt-path)
+        (do (println (format "[%s] Agent resolved divergence, branch is mergeable" worker-id))
+            :resolved)
+        (do (println (format "[%s] Agent ran but branch still can't merge cleanly" worker-id))
+            :failed))
+      (do (println (format "[%s] Resolver agent failed (exit %d)" worker-id (:exit result)))
+          :failed))))
+
 (defn- verify-mergeable?
   "Dry-run merge to verify a worktree branch merges cleanly into main.
    Does NOT leave merge state behind — always cleans up the dry-run.
@@ -425,36 +570,10 @@
       ;; Conflict — abort merge to restore clean worktree state, then
       ;; hand the problem to the agent with full divergence context.
       (let [_ (process/sh ["git" "merge" "--abort"] {:dir wt-path})
-            _ (println (format "[%s] Branch diverged from main, launching resolver agent" worker-id))
-            {:keys [branch-log main-log diff-stat]} (collect-divergence-context wt-path)
-            resolve-prompt (str "[oompa:" (or (:swarm-id worker) "unknown") ":" worker-id "] "
-                                "Your branch has diverged from main and cannot merge cleanly.\n\n"
-                                "Your branch's commits (not on main):\n" branch-log "\n\n"
-                                "Commits on main since you branched:\n" main-log "\n\n"
-                                "Divergence scope:\n" diff-stat "\n\n"
-                                "Make this branch cleanly mergeable into main. "
-                                "Preserve the intent of your branch's changes.\n"
-                                "You have full git access — rebase, cherry-pick, resolve conflicts, "
-                                "whatever works.\n"
-                                "When done, verify with: git diff main --stat")
-            abs-wt (.getAbsolutePath (io/file wt-path))
-            cmd (harness/build-cmd (:harness worker)
-                  {:cwd abs-wt :model (:model worker) :prompt resolve-prompt})
-            result (try
-                     (process/sh cmd {:dir abs-wt
-                                      :in (harness/process-stdin (:harness worker) resolve-prompt)
-                                      :out :string :err :string})
-                     (catch Exception e
-                       {:exit -1 :out "" :err (.getMessage e)}))]
-        (if (zero? (:exit result))
-          ;; Agent ran — verify the branch actually merges cleanly now
-          (if (verify-mergeable? wt-path)
-            (do (println (format "[%s] Agent resolved divergence, branch is mergeable" worker-id))
-                :resolved)
-            (do (println (format "[%s] Agent ran but branch still can't merge cleanly" worker-id))
-                :failed))
-          (do (println (format "[%s] Resolver agent failed (exit %d)" worker-id (:exit result)))
-              :failed))))))
+            failure-snippet (first-nonblank-line (str (:out merge-result) "\n" (:err merge-result)))]
+        (run-resolver-agent! worker wt-path worker-id
+                             (str "sync_worktree_to_main failed"
+                                  (when failure-snippet (str ": " failure-snippet))))))))
 
 (defn- worktree-has-changes?
   "Check if worktree has committed OR uncommitted changes vs main.
@@ -474,9 +593,11 @@
 (defn- create-iteration-worktree!
   "Create a fresh worktree for an iteration. Returns {:dir :branch :path}.
    Force-removes stale worktree+branch from previous failed runs first."
-  [project-root worker-id iteration]
-  (let [wt-dir (format ".w%s-i%d" worker-id iteration)
-        wt-branch (format "oompa/%s-i%d" worker-id iteration)
+  [project-root swarm-id worker-id iteration]
+  (let [swarm-token (or swarm-id (subs (str (java.util.UUID/randomUUID)) 0 8))
+        work-id (format "s%s-%s-i%d" swarm-token worker-id iteration)
+        wt-dir (format ".w%s" work-id)
+        wt-branch (format "oompa/%s" work-id)
         wt-path (str project-root "/" wt-dir)]
     ;; Clean stale worktree/branch from previous failed runs
     (process/sh ["git" "worktree" "remove" wt-dir "--force"] {:dir project-root})
@@ -495,38 +616,201 @@
   (let [post-ids (tasks/current-task-ids)]
     (clojure.set/difference post-ids pre-current-ids)))
 
+(defn- now-ms
+  []
+  (System/currentTimeMillis))
+
+(defn- ms->seconds
+  [ms]
+  (/ ms 1000.0))
+
+(defn- pct-of
+  [part total]
+  (if (pos? total)
+    (* 100.0 (/ part (double total)))
+    0.0))
+
+(defn- init-cycle-timing
+  []
+  {:implementation-rounds-ms []
+   :reviewer-response-ms []
+   :review-fixes-ms []
+   :optional-review-ms []
+   :llm-calls []})
+
+(defn- add-llm-call
+  [timing section-name call-name duration-ms]
+  (let [timing (or timing (init-cycle-timing))
+        duration-ms (max 0 (long (or duration-ms 0)))]
+    (-> timing
+        (update section-name (fnil conj []) duration-ms)
+        (update :llm-calls conj {:name call-name
+                                 :section section-name
+                                 :duration-ms duration-ms}))))
+
+(defn- cycle-llm-total-ms
+  [timing]
+  (let [sections [:implementation-rounds-ms :reviewer-response-ms :review-fixes-ms :optional-review-ms]]
+    (->> sections
+         (map #(reduce + 0 (or (get timing %) [])))
+         (reduce + 0))))
+
+(defn- with-call-percent
+  [timing total-ms]
+  (update timing :llm-calls
+          (fn [calls]
+            (mapv (fn [{:keys [duration-ms] :as call}]
+                    (assoc call :percent (pct-of duration-ms total-ms)))
+                  calls))))
+
+(defn- format-timing-segment
+  [label durations total-ms]
+  (let [durations (vec (or durations []))
+        items (if (seq durations)
+                (str/join ", "
+                          (map #(format "%.2fs (%.1f%%)"
+                                        (ms->seconds %) (pct-of % total-ms))
+                               durations))
+                "-")
+        section-ms (reduce + 0 durations)]
+    (format "%s=[%s] %.2fs (%.1f%%)"
+            label
+            items
+            (ms->seconds section-ms)
+            (pct-of section-ms total-ms))))
+
+(defn- format-cycle-timing
+  [{:keys [implementation-rounds-ms reviewer-response-ms review-fixes-ms optional-review-ms]}
+   total-ms]
+  (let [llm-ms (cycle-llm-total-ms {:implementation-rounds-ms implementation-rounds-ms
+                                    :reviewer-response-ms reviewer-response-ms
+                                    :review-fixes-ms review-fixes-ms
+                                    :optional-review-ms optional-review-ms})
+        harness-ms (max 0 (- total-ms llm-ms))]
+    (str "timing: "
+         (format-timing-segment "Implementation" implementation-rounds-ms total-ms)
+         " | "
+         (format-timing-segment "Reviewer" reviewer-response-ms total-ms)
+         " | "
+         (format-timing-segment "Fixes" review-fixes-ms total-ms)
+         " | "
+         (format-timing-segment "OptionalReview" optional-review-ms total-ms)
+         " | LLM="
+         (format "%.2fs (%.1f%%)" (ms->seconds llm-ms) (pct-of llm-ms total-ms))
+         " | Harness="
+         (format "%.2fs (%.1f%%)" (ms->seconds harness-ms) (pct-of harness-ms total-ms))
+         " | Total="
+         (format "%.2fs" (ms->seconds total-ms)))))
+
+(defn- safe-number
+  [v]
+  (if (number? v) (long v) 0))
+
+(defn- safe-sum
+  [v]
+  (reduce + 0 (or v [])))
+
+(defn- format-ms
+  [ms]
+  (format "%.2fs" (ms->seconds (safe-number ms))))
+
+(defn- cycle-time-sum
+  [{:keys [implementation-rounds-ms reviewer-response-ms review-fixes-ms optional-review-ms] :as timing-ms}
+   duration-ms]
+  (let [impl (safe-sum implementation-rounds-ms)
+        review (safe-sum reviewer-response-ms)
+        fixes (safe-sum review-fixes-ms)
+        optional (safe-sum optional-review-ms)
+        total (safe-number duration-ms)
+        llm (+ impl review fixes optional)
+        harness (max 0 (- total llm))]
+    {:implementation-ms impl
+     :review-ms review
+     :fixes-ms fixes
+     :optional-review-ms optional
+     :llm-ms llm
+     :harness-ms harness
+     :total-ms total}))
+
+(def ^:private empty-cycle-total
+  {:implementation-ms 0
+   :review-ms 0
+   :fixes-ms 0
+   :optional-review-ms 0
+   :llm-ms 0
+   :harness-ms 0
+   :total-ms 0})
+
+(defn- aggregate-cycle-timings-by-worker
+  [swarm-id]
+  (reduce (fn [acc {:keys [worker-id timing-ms duration-ms]}]
+            (update acc worker-id
+                    (fn [current]
+                      (merge-with + (or current empty-cycle-total)
+                                  (cycle-time-sum timing-ms duration-ms)))))
+          {}
+          (or (when swarm-id (runs/list-cycles swarm-id)) [])))
+
+(defn- worker-summary-row
+  [{:keys [id status completed cycles-completed merges claims rejections errors recycled review-rounds-total] :as _worker}
+   {:keys [implementation-ms review-ms fixes-ms harness-ms total-ms]}]
+  {:Worker id
+   :Runs (or completed cycles-completed 0)
+   :Cycles (or cycles-completed 0)
+   :Status (name status)
+   :Merges (or merges 0)
+   :Claims (or claims 0)
+   :Rejects (or rejections 0)
+   :Errors (or errors 0)
+   :Recycled (or recycled 0)
+   :ReviewRounds (or review-rounds-total 0)
+   :ImplMs (format-ms implementation-ms)
+   :ReviewMs (format-ms review-ms)
+   :FixMs (format-ms fixes-ms)
+   :HarnessMs (format-ms harness-ms)
+   :TotalMs (format-ms total-ms)})
+
 (defn- emit-cycle-log!
-  "Write cycle event log. Called at every cycle exit point.
+  "Write cycle event log. Called at every cycle attempt 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
-   {:keys [outcome claimed-task-ids recycled-tasks error-snippet review-rounds]}]
-  (let [duration-ms (- (System/currentTimeMillis) start-ms)]
+  [swarm-id worker-id cycle attempt run start-ms session-id
+   {:keys [outcome claimed-task-ids recycled-tasks error-snippet review-rounds timing-ms
+           worktree-path signals]}]
+  (let [duration-ms (- (now-ms) start-ms)
+        timing-ms (or timing-ms (init-cycle-timing))
+        harness-ms (max 0 (- duration-ms (cycle-llm-total-ms timing-ms)))
+        timing-ms (with-call-percent (assoc timing-ms
+                                           :harness-ms harness-ms
+                                           :llm-calls (or (:llm-calls timing-ms) []))
+                                    duration-ms)]
     (runs/write-cycle-log!
       swarm-id worker-id cycle
-      {:outcome outcome
-       :duration-ms duration-ms
-       :claimed-task-ids (vec (or claimed-task-ids []))
-       :recycled-tasks (or recycled-tasks [])
-       :error-snippet error-snippet
-       :review-rounds (or review-rounds 0)
-       :session-id session-id})))
-
-(defn- recycle-orphaned-tasks!
-  "Recycle tasks that a worker claimed but didn't complete.
-   Compares current/ task IDs before and after the agent ran —
-   new IDs that appeared are tasks this worker claimed. On failure
-   or rejection, move them back to pending/ so other workers can
-   pick them up. Returns count of recycled tasks."
-  [worker-id pre-current-ids]
-  (let [post-current-ids (tasks/current-task-ids)
-        orphaned-ids (clojure.set/difference post-current-ids pre-current-ids)
-        recycled (when (seq orphaned-ids)
-                   (tasks/recycle-tasks! orphaned-ids))]
-    (when (seq recycled)
-      (println (format "[%s] Recycled %d orphaned task(s): %s"
-                       worker-id (count recycled) (str/join ", " recycled))))
-    (count (or recycled []))))
+      (cond-> {:run run
+               :attempt attempt
+               :outcome outcome
+               :duration-ms duration-ms
+               :claimed-task-ids (vec (or claimed-task-ids []))
+               :recycled-tasks (or recycled-tasks [])
+               :error-snippet error-snippet
+               :review-rounds (or review-rounds 0)
+               :session-id session-id
+               :timing-ms timing-ms}
+        worktree-path (assoc :worktree-path worktree-path)
+        (seq signals)  (assoc :signals (vec signals))))
+    (let [terminal-outcomes #{:merged :merge-failed :rejected :sync-failed :no-changes
+                              :executor-done :stuck :error :interrupted :needs-followup}]
+      (if (and outcome (contains? terminal-outcomes outcome))
+        (do
+          (println (format "[%s] %s" worker-id (format-cycle-timing timing-ms duration-ms)))
+          (when worktree-path
+            (println (format "[%s] worktree: %s" worker-id worktree-path)))
+          (when (seq signals)
+            (println (format "[%s] signals: %s" worker-id (str/join " → " signals)))))
+        (println (format "[%s] Cycle %d attempt %d continuing"
+                         worker-id cycle attempt))))))
+
+
 
 (defn- cleanup-worktree!
   "Remove worktree and branch."
@@ -567,7 +851,8 @@
 (defn- merge-to-main!
   "Merge worktree changes to main branch. Serialized via merge-lock to prevent
    concurrent workers from corrupting the git index. On success, moves claimed
-   tasks current→complete and annotates metadata. Returns true on success.
+   tasks current→complete and annotates metadata. Returns
+   {:ok? bool :reason keyword :message string}.
    claimed-task-ids: set of task IDs this worker claimed (framework owns completion)."
   [wt-path wt-id worker-id project-root review-rounds claimed-task-ids]
   (locking merge-lock
@@ -586,31 +871,66 @@
                          (process/sh ["git" "merge" wt-id "--no-edit"]
                                      {:dir project-root :out :string :err :string}))
           success (and (zero? (:exit checkout-result))
-                       (zero? (:exit merge-result)))]
+                       (zero? (:exit merge-result)))
+          failure-text (str/join "\n"
+                                 (remove str/blank?
+                                         [(:out checkout-result)
+                                          (:err checkout-result)
+                                          (when merge-result (:out merge-result))
+                                          (when merge-result (:err merge-result))]))
+          failure-reason (if (not (zero? (:exit checkout-result)))
+                           :checkout-failed
+                           (classify-merge-failure failure-text))]
       (if success
-        (do
+        (let [completed (when (seq claimed-task-ids)
+                          (tasks/complete-by-ids! claimed-task-ids))
+              completed-count (count (or completed []))]
           (println (format "[%s] Merge successful" worker-id))
           ;; Framework-owned completion: move claimed tasks current→complete
-          (when (seq claimed-task-ids)
-            (let [completed (tasks/complete-by-ids! claimed-task-ids)]
-              (when (seq completed)
-                (println (format "[%s] Completed %d task(s): %s"
-                                 worker-id (count completed) (str/join ", " completed))))))
+          (when (seq completed)
+            (println (format "[%s] Completed %d task(s): %s"
+                             worker-id completed-count (str/join ", " completed))))
           ;; Annotate completed tasks with metadata while still holding merge-lock
-          (annotate-completed-tasks! project-root worker-id review-rounds))
+          (annotate-completed-tasks! project-root worker-id review-rounds)
+          {:ok? true
+           :reason :merged
+           :message "merge successful"
+           :completed-count completed-count})
         ;; FAILED: Clean up git state before releasing merge-lock.
         ;; Without this, a conflict leaves .git/MERGE_HEAD and poisons the
         ;; shared index — every subsequent worker fails on `git checkout main`.
         (do
-          (println (format "[%s] MERGE FAILED: %s" worker-id
-                           (or (:err merge-result) (:err checkout-result))))
+          (println (format "[%s] MERGE FAILED (%s): %s"
+                           worker-id
+                           (name failure-reason)
+                           (or (first-nonblank-line failure-text)
+                               "no output")))
           (let [abort-result (process/sh ["git" "merge" "--abort"]
                                          {:dir project-root :out :string :err :string})]
             (when-not (zero? (:exit abort-result))
               ;; Abort failed (no merge in progress, or other issue) — hard reset.
               (process/sh ["git" "reset" "--hard" "HEAD"]
-                          {:dir project-root :out :string :err :string})))))
-      success)))
+                          {:dir project-root :out :string :err :string})))
+          {:ok? false
+           :reason failure-reason
+           :message (or (first-nonblank-line failure-text) "merge failed")})))))
+
+(defn- recover-merge-failure!
+  "On merge-to-main failure, launch resolver agent and retry merge once.
+   Must run outside merge-lock to avoid blocking other workers."
+  [worker wt-path wt-id worker-id project-root review-rounds claimed-task-ids merge-result]
+  (let [reason (:reason merge-result)
+        msg (:message merge-result)
+        _ (println (format "[%s] Launching resolver after merge failure (%s): %s"
+                           worker-id (name (or reason :unknown)) (or msg "merge failed")))
+        resolve-status (run-resolver-agent! worker wt-path worker-id
+                                            (str "merge_to_main failed (" (name (or reason :unknown)) ")"
+                                                 (when msg (str ": " msg))))]
+    (if (= :failed resolve-status)
+      merge-result
+      (do
+        (println (format "[%s] Retrying merge after resolver" worker-id))
+        (merge-to-main! wt-path wt-id worker-id project-root review-rounds claimed-task-ids)))))
 
 (defn- task-only-diff?
   "Check if all changes in worktree are task files only (no code changes).
@@ -640,16 +960,21 @@
    and fixer has full context of all prior feedback.
    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))
+  [worker wt-path worker-id iteration & [cycle-timing]]
+  (if (empty? (:reviewers worker))
     ;; No reviewer configured, auto-approve
-    {:approved? true :attempts 0}
+    {:approved? true :attempts 0 :timing (or cycle-timing (init-cycle-timing))}
 
     ;; Run review loop with accumulated feedback
     (loop [attempt 1
-           prev-feedback []]
+           prev-feedback []
+           timing (or cycle-timing (init-cycle-timing))]
       (println (format "[%s] Review attempt %d/%d" worker-id attempt max-review-retries))
-      (let [{:keys [verdict output]} (run-reviewer! worker wt-path prev-feedback)
+      (let [{:keys [verdict output duration-ms]} (run-reviewer! worker wt-path prev-feedback)
+            timing (add-llm-call timing
+                                 :reviewer-response-ms
+                                 (str "review_" attempt)
+                                 (or duration-ms 0))
             diff-files (diff-file-names wt-path)]
 
         ;; Persist review log for this round
@@ -657,13 +982,14 @@
           (runs/write-review-log! (:swarm-id worker) worker-id iteration attempt
                                   {:verdict verdict
                                    :output output
+                                   :duration-ms (or duration-ms 0)
                                    :diff-files (or diff-files [])}))
 
         (case verdict
           :approved
           (do
             (println (format "[%s] Reviewer APPROVED (attempt %d)" worker-id attempt))
-            {:approved? true :attempts attempt})
+            {:approved? true :attempts attempt :timing timing})
 
           ;; :needs-changes — always give the worker a chance to fix.
           ;; Hard rejection only happens when max review rounds are exhausted.
@@ -671,37 +997,49 @@
             (if (>= attempt max-review-retries)
               (do
                 (println (format "[%s] Max review retries reached (%d rounds)" worker-id attempt))
-                {:approved? false :attempts attempt})
+                {:approved? false :attempts attempt :timing timing})
               (do
                 (println (format "[%s] Reviewer requested changes, fixing..." worker-id))
-                (run-fix! worker wt-path all-feedback)
-                (recur (inc attempt) all-feedback)))))))))
+                (let [{:keys [duration-ms]} (run-fix! worker wt-path all-feedback)
+                      timing (add-llm-call timing
+                                           :review-fixes-ms
+                                           (str "fix_" attempt)
+                                           (or duration-ms 0))]
+                   (recur (inc attempt) all-feedback timing))))))))))
 
 ;; =============================================================================
 ;; 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)
-      (do (println (format "[%s] No tasks after %ds, giving up" worker-id waited))
+      (>= waited max-wait-seconds)
+      (do (println (format "[%s] [%s] No tasks after %ds, giving up"
+                           worker-id (log-ts) 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] [%s] Waiting for tasks... (%ds/%ds)"
+                             worker-id (log-ts) waited max-wait-seconds)))
           (Thread/sleep (* wait-poll-interval 1000))
           (recur (+ waited wait-poll-interval))))))
 
@@ -716,267 +1054,374 @@
 (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 max-needs-followups]} 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
+           attempt 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
+           needs-followups 0
+           signals []]
       (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
+              (when (seq claimed-ids)
+                (recycle-task-id-set! id claimed-ids))
               (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
+              (when (seq claimed-ids)
+                (recycle-task-id-set! id claimed-ids))
+              (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 attempt current-run (now-ms) session-id
+                             {:timing-ms (init-cycle-timing)
+                              :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?
-                          (let [sync-status (sync-worktree-to-main! worker (:path wt-state) id)
-                                all-claimed (into claimed-ids mv-claimed-tasks)]
+            (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 swarm-id 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) 1 completed-runs errors metrics nil nil #{} nil 0 0 []))))
+
+                (let [resume? (or (some? session-id) (some? claim-resume-prompt))
+                      cycle-start-ms (now-ms)
+                      cycle-timing (init-cycle-timing)
+                      pre-current-ids (tasks/current-task-ids)
+                      _ (println (format "[%s] %s cycle %d/%d (run %d/%d, attempt %d)"
+                                         id
+                                         (if (= attempt 1) "Starting" "Resuming")
+                                         cycle cycle-cap current-run run-goal attempt))
+                      context (build-context)
+                      agent-start-ms (now-ms)
+                      {:keys [output exit done? merge? needs-followup? claim-ids parse-warning raw-snippet] :as agent-result}
+                      (run-agent! worker (:path wt-state) context session-id resume?
+                                  :resume-prompt-override claim-resume-prompt)
+                      cycle-timing (add-llm-call cycle-timing
+                                                 :implementation-rounds-ms
+                                                 "implementation"
+                                                 (- (now-ms) agent-start-ms))
+                      new-session-id (:session-id agent-result)
+                      stderr-snippet (:stderr-snippet agent-result)
+                      mv-claimed-tasks (detect-claimed-tasks pre-current-ids)
+                      active-claimed-ids (active-claimed-task-ids claimed-ids mv-claimed-tasks)
+                      wt-path (:path wt-state)
+                      ;; Classify the signal for this attempt
+                      signal-label (cond
+                                     (not (zero? exit)) (str "error:exit-" exit)
+                                     (and (seq claim-ids) (not merge?) (not done?))
+                                     (str "claim:" (str/join "," claim-ids))
+                                     merge? "merge"
+                                     done? "done"
+                                     needs-followup? "needs-followup"
+                                     :else "working")
+                      signals (conj signals signal-label)
+                      emit! (fn [opts]
+                              (emit-cycle-log! swarm-id id cycle attempt current-run cycle-start-ms new-session-id
+                                               (merge {:worktree-path wt-path :signals signals} opts)))]
+                  (cond
+                    (not (zero? exit))
+                    (let [errors (inc consec-errors)
+                          recycled (recycle-active-claims! id claimed-ids mv-claimed-tasks)
+                          metrics (-> metrics (update :errors inc) (update :recycled + (count recycled)))
+                          error-msg (subs (or output "") 0 (min 200 (count (or output ""))))]
+                      (println (format "[%s] Agent error (exit %d): %s" id exit error-msg))
+                      (when (seq stderr-snippet)
+                        (println (format "[%s] Agent stderr snippet: %s"
+                                         id
+                                         (snippet (str/replace stderr-snippet #"\s+" " ") 240))))
+                      (emit!
+                                       {:timing-ms cycle-timing
+                                        :outcome :error
+                                        :claimed-task-ids (vec active-claimed-ids)
+                                        :recycled-tasks (seq recycled)
+                                        :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) 1 (inc completed-runs) errors metrics nil nil #{} nil 0 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 active-claimed-ids claimed)
+                          metrics (update metrics :claims + (count claimed))]
+                      (println (format "[%s] Claimed %d/%d tasks" id (count claimed) (count claim-ids)))
+                      (emit!
+                                       {:timing-ms cycle-timing
+                                        :outcome :claimed :claimed-task-ids (vec claimed)})
+                      (recur cycle (inc attempt) completed-runs 0 metrics new-session-id wt-state
+                             new-claimed-ids resume-prompt 0 0 signals))
+
+                    merge?
+                    (if (worktree-has-changes? (:path wt-state))
+                      (if (task-only-diff? (:path wt-state))
+                        (let [all-claimed active-claimed-ids]
+                          (println (format "[%s] Task-only diff, auto-merging" id))
+                          (let [sync-status (sync-worktree-to-main! worker (:path wt-state) id)]
                             (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)})
+                              (let [recycled (recycle-task-id-set! id all-claimed)
+                                    metrics (update metrics :recycled + (count recycled))]
+                                (println (format "[%s] Sync to main failed, skipping merge" id))
+                                (emit!
+                                                 {:timing-ms cycle-timing
+                                                  :outcome :sync-failed
+                                                  :claimed-task-ids (vec all-claimed)
+                                                  :recycled-tasks (seq recycled)})
                                 (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)
-                                    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)})
+                                (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 []))
+                              (let [merge-result (merge-to-main! (:path wt-state) (:branch wt-state) id project-root 0 all-claimed)
+                                    merge-result (if (:ok? merge-result)
+                                                   merge-result
+                                                   (recover-merge-failure! worker (:path wt-state) (:branch wt-state)
+                                                                           id project-root 0 all-claimed merge-result))
+                                    merged? (:ok? merge-result)
+                                    recycled (when-not merged?
+                                               (recycle-task-id-set! id all-claimed))
+                                    completed-count (or (:completed-count merge-result) 0)
+                                    metrics (cond-> metrics
+                                              (and merged? (pos? completed-count)) (update :merges inc)
+                                              (seq recycled) (update :recycled + (count recycled)))]
+                                (println (format "[%s] Cycle %d/%d complete" id cycle cycle-cap))
+                                (emit!
+                                                 {:timing-ms cycle-timing
+                                                  :outcome (if merged? :merged :merge-failed)
+                                                  :claimed-task-ids (vec all-claimed)
+                                                  :recycled-tasks (seq recycled)
+                                                  :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)
-                      (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))})
+                                (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 [])))))
+                              (let [{:keys [approved? attempts timing]} (review-loop! worker (:path wt-state) id cycle cycle-timing)
+                                    cycle-timing (or timing cycle-timing)
+                                    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 active-claimed-ids]
+                              (if (= :failed sync-status)
+                                (let [recycled (recycle-task-id-set! id all-claimed)
+                                      metrics (update metrics :recycled + (count recycled))]
+                                  (println (format "[%s] Sync to main failed after approval, skipping merge" id))
+                                  (emit!
+                                                   {:timing-ms cycle-timing
+                                                    :outcome :sync-failed
+                                                    :claimed-task-ids (vec all-claimed)
+                                                    :recycled-tasks (seq recycled)
+                                                    :review-rounds (or attempts 0)})
+                                  (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                                  (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 []))
+                                (let [merge-result (merge-to-main! (:path wt-state) (:branch wt-state) id project-root (or attempts 0) all-claimed)
+                                      merge-result (if (:ok? merge-result)
+                                                     merge-result
+                                                     (recover-merge-failure! worker (:path wt-state) (:branch wt-state)
+                                                                             id project-root (or attempts 0) all-claimed merge-result))
+                                      merged? (:ok? merge-result)
+                                      recycled (when-not merged?
+                                                 (recycle-task-id-set! id all-claimed))
+                                      completed-count (or (:completed-count merge-result) 0)
+                                      metrics (cond-> metrics
+                                                (and merged? (pos? completed-count)) (update :merges inc)
+                                                (seq recycled) (update :recycled + (count recycled)))]
+                                  (println (format "[%s] Cycle %d/%d complete" id cycle cycle-cap))
+                                  (emit!
+                                                   {:timing-ms cycle-timing
+                                                    :outcome (if merged? :merged :merge-failed)
+                                                    :claimed-task-ids (vec all-claimed)
+                                                    :recycled-tasks (seq recycled)
+                                                    :review-rounds (or attempts 0)})
+                                  (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                                  (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 []))))
+                            (let [recycled (recycle-active-claims! id claimed-ids mv-claimed-tasks)
+                                  metrics (update metrics :recycled + (count recycled))]
+                              (println (format "[%s] Cycle %d/%d rejected" id cycle cycle-cap))
+                              (emit!
+                                               {:timing-ms cycle-timing
+                                                :outcome :rejected
+                                                :claimed-task-ids (vec active-claimed-ids)
+                                                :recycled-tasks (seq recycled)
+                                                :review-rounds (or attempts 0)})
+                              (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                              (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 [])))))
+                      (let [recycled (recycle-active-claims! id claimed-ids mv-claimed-tasks)
+                            metrics (update metrics :recycled + (count recycled))]
+                        (println (format "[%s] Merge signaled but no changes, skipping" id))
+                        (emit!
+                                         {:timing-ms cycle-timing
+                                          :outcome :no-changes
+                                          :claimed-task-ids (vec active-claimed-ids)
+                                          :recycled-tasks (seq recycled)})
                         (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) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 [])))
+
+                    done?
+                    (let [recycled (recycle-active-claims! id claimed-ids mv-claimed-tasks)
+                          metrics (-> metrics
+                                      (update :recycled + (count recycled))
+                                      (update :errors inc))]
+                      (println (format "[%s] Invalid __DONE__ signal from executor; stopping worker (cycle %d/%d)" id cycle cycle-cap))
+                      (emit!
+                                       {:timing-ms cycle-timing
+                                        :outcome :error
+                                        :claimed-task-ids (vec active-claimed-ids)
+                                        :recycled-tasks (seq recycled)
+                                        :error-snippet "__DONE__ is not a valid executor signal; use CLAIM(...) or COMPLETE_AND_READY_FOR_MERGE"})
+                      (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                      (finish :error))
+
+                    needs-followup?
+                    (let [summary (subs (or output "") 0 (min 240 (count (or output ""))))
+                          next-followups (inc needs-followups)]
+                      (emit!
+                                       {:timing-ms cycle-timing
+                                        :outcome :needs-followup
+                                        :claimed-task-ids (vec active-claimed-ids)
+                                        :error-snippet summary})
+                      (if (> next-followups max-needs-followups)
+                        (let [recycled (recycle-active-claims! id claimed-ids mv-claimed-tasks)
+                              metrics (-> metrics
+                                          (update :recycled + (count recycled))
+                                          (update :errors inc))]
+                          (println (format "[%s] NEEDS_FOLLOWUP exhausted (%d/%d); stopping worker" id next-followups max-needs-followups))
+                          (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                          (finish :error))
+                        (let [followup-prompt (build-needs-followup-prompt active-claimed-ids output)]
+                          (println (format "[%s] NEEDS_FOLLOWUP signal; continuing cycle with follow-up prompt (%d/%d)"
+                                           id next-followups max-needs-followups))
+                          (recur cycle (inc attempt) completed-runs 0 metrics new-session-id wt-state
+                                 active-claimed-ids followup-prompt 0 next-followups signals))))
+
+                    :else
+                    (let [wr (inc working-resumes)
+                          max-wr (:max-working-resumes worker)]
+                      (when parse-warning
+                        (if (str/includes? parse-warning "AUTH_REQUIRED:")
+                          (println (format "[%s] LOGIN ISSUE: %s"
+                                           id
+                                           (str/replace parse-warning #"^AUTH_REQUIRED:\s*" "")))
+                          (println (format "[%s] WARNING: %s" id parse-warning))))
+                      (when (and parse-warning (seq raw-snippet))
+                        (println (format "[%s] Raw output snippet: %s"
+                                         id
+                                         (snippet (str/replace raw-snippet #"\s+" " ") 240))))
+                      (when (seq stderr-snippet)
+                        (println (format "[%s] Agent stderr snippet: %s"
+                                         id
+                                         (snippet (str/replace stderr-snippet #"\s+" " ") 240))))
+                      (cond
+                        (> wr max-wr)
+                        (let [recycled (recycle-active-claims! id claimed-ids mv-claimed-tasks)
+                              metrics (update metrics :recycled + (count recycled))]
+                          (println (format "[%s] Stuck after %d working resumes + nudge, resetting session" id wr))
+                          (emit!
+                                           {:timing-ms cycle-timing
+                                            :outcome :stuck
+                                            :claimed-task-ids (vec active-claimed-ids)
+                                            :recycled-tasks (seq recycled)})
+                          (cleanup-worktree! project-root (:dir wt-state) (:branch wt-state))
+                          (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 0 []))
+
+                        (= wr max-wr)
+                        (do
+                          (println (format "[%s] Working... %d/%d resumes, nudging agent to wrap up" id wr max-wr))
+                          (emit!
+                                           {:timing-ms cycle-timing
+                                            :outcome :working
+                                            :claimed-task-ids (vec active-claimed-ids)})
+                          (recur cycle (inc attempt) completed-runs 0 metrics new-session-id wt-state
+                                 active-claimed-ids nudge-prompt wr needs-followups signals))
+
+                        :else
+                        (do
+                          (println (format "[%s] Working... (will resume, %d/%d)" id wr max-wr))
+                          (emit!
+                                           {:timing-ms cycle-timing
+                                            :outcome :working
+                                            :claimed-task-ids (vec active-claimed-ids)})
+                          (recur cycle (inc attempt) completed-runs 0 metrics new-session-id wt-state
+                                 active-claimed-ids nil wr needs-followups signals))))))))))))))
 
 ;; =============================================================================
 ;; Multi-Worker Execution
@@ -992,7 +1437,14 @@
    Returns seq of final worker states."
   [workers]
   (tasks/ensure-dirs!)
-  (let [swarm-id (-> workers first :swarm-id)]
+  (let [swarm-id (-> workers first :swarm-id)
+        stale-current (tasks/list-current)]
+    (when (seq stale-current)
+      (println (format "WARNING: %d task(s) already in current/ from a previous run. These may be stale claims."
+                       (count stale-current)))
+      (doseq [t stale-current]
+        (println (format "  - %s: %s" (:id t) (:summary t))))
+      (println "  Run `oompa requeue` to move them back to pending/ if they are stale."))
     (println (format "Launching %d workers..." (count workers)))
 
     ;; Register JVM shutdown hook so SIGTERM/SIGINT triggers graceful stop.
@@ -1014,27 +1466,38 @@
                       (map-indexed
                         (fn [idx worker]
                           (let [worker (assoc worker :id (or (:id worker) (str "w" idx)))]
-                            (future (run-worker! worker))))
+                            (future
+                              (try
+                                (run-worker! worker)
+                                (catch Exception e
+                                  (println (format "[%s] FATAL: %s" (:id worker) (.getMessage e)))
+                                  (.printStackTrace e)
+                                  (throw e))))))
                         workers))]
 
         (println "All workers launched. Waiting for completion...")
-        (let [results (mapv deref futures)]
+        (let [results (mapv (fn [f]
+                              (try
+                                (deref f)
+                                (catch Exception e
+                                  (println (format "Worker future failed: %s" (.getMessage e)))
+                                  {:status :fatal-error :error (.getMessage e)})))
+                            futures)]
           ;; Clean exit — tell shutdown hook not to write stopped.json
           (reset! shutdown-requested? false)
           ;; Remove the hook so it doesn't accumulate across calls
           (try (.removeShutdownHook (Runtime/getRuntime) hook) (catch Exception _))
           (println "\nAll workers complete.")
-          (doseq [w results]
-            (println (format "  [%s] %s - %d completed, %d merges, %d claims, %d rejections, %d errors, %d recycled, %d review rounds"
-                             (:id w)
-                             (name (:status w))
-                             (:completed w)
-                             (or (:merges w) 0)
-                             (or (:claims w) 0)
-                             (or (:rejections w) 0)
-                             (or (:errors w) 0)
-                             (or (:recycled w) 0)
-                             (or (:review-rounds-total w) 0))))
+          (let [timing-by-worker (aggregate-cycle-timings-by-worker swarm-id)
+                rows (mapv (fn [result]
+                             (let [row-id (or (:id result) "")
+                                   totals (get timing-by-worker row-id empty-cycle-total)]
+                               (worker-summary-row result totals)))
+                            results)]
+            (println "\nWorker Summary")
+            (print-table [:Worker :Runs :Cycles :Status :Merges :Claims :Rejects :Errors :Recycled
+                          :ReviewRounds :ImplMs :ReviewMs :FixMs :HarnessMs :TotalMs]
+                         rows))
 
           ;; Write stopped event — all state derivable from cycle logs
           (when swarm-id
@@ -1082,16 +1545,12 @@
             tagged-prompt (str "[oompa:" swarm-id* ":planner] " prompt-text)
             abs-root (.getAbsolutePath (io/file project-root))
 
-            cmd (harness/build-cmd harness
-                  {:cwd abs-root :model model :prompt tagged-prompt})
-
             _ (println (format "[planner] Running (%s:%s, max_pending: %d, current: %d)"
                                (name harness) (or model "default") max-pending pending-before))
 
             result (try
-                     (process/sh cmd {:dir abs-root
-                                      :in (harness/process-stdin harness tagged-prompt)
-                                      :out :string :err :string})
+                     (harness/run-command! harness
+                                           {:cwd abs-root :model model :prompt tagged-prompt})
                      (catch Exception e
                        (println (format "[planner] Agent exception: %s" (.getMessage e)))
                        {:exit -1 :out "" :err (.getMessage e)}))