@nbardy/oompa 0.7.2 → 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.)
@@ -90,6 +103,7 @@
         (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
@@ -100,10 +114,11 @@
    :review-prompts paths to reviewer prompt files (loaded and concatenated for review).
    :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-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-wait-for-tasks]}]
+           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
@@ -127,6 +142,7 @@
                            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}))
 
@@ -145,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
@@ -187,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.
@@ -245,28 +315,31 @@
         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.
@@ -274,7 +347,8 @@
    prev-feedback: vector of previous review outputs (for multi-round context).
    Returns {:verdict :approved|:needs-changes|:rejected, :comments [...], :output string}"
   [{:keys [id swarm-id reviewers]} worktree-path prev-feedback]
-  (let [;; Get actual diff content (not just stat) — truncate to 8000 chars for prompt budget
+  (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)]
@@ -320,14 +394,12 @@
                                                 "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})
+                                        (harness/run-command! harness {:cwd abs-wt :model model :prompt review-prompt})
                                         (catch Exception e
                                           {:exit -1 :out "" :err (.getMessage e)}))
-                               output (or (:out res) "")
+                               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)
@@ -348,7 +420,8 @@
                   (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)))]
@@ -358,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"
@@ -381,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.
@@ -406,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.
@@ -437,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.
@@ -486,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})
@@ -507,39 +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 run 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
-      {:run run
-       :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."
@@ -580,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
@@ -599,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).
@@ -653,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]
+  [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
@@ -670,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.
@@ -684,11 +997,15 @@
             (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
@@ -716,11 +1033,13 @@
       (pos? (tasks/pending-count)) true
       (pos? (tasks/current-count)) true
       (>= waited max-wait-seconds)
-      (do (println (format "[%s] No tasks after %ds, giving up" worker-id waited))
+      (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-seconds)))
+            (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))))))
 
@@ -740,7 +1059,8 @@
    Cycle cap is controlled by :max-cycles (legacy key: :iterations)."
   [worker]
   (tasks/ensure-dirs!)
-  (let [{:keys [id runs max-cycles iterations swarm-id wait-between max-wait-for-tasks]} 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")]
@@ -759,6 +1079,7 @@
       (wait-for-tasks! id max-wait-for-tasks))
 
     (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}
@@ -766,7 +1087,9 @@
            wt-state nil
            claimed-ids #{}
            claim-resume-prompt nil
-           working-resumes 0]
+           working-resumes 0
+           needs-followups 0
+           signals []]
       (let [finish (fn [status]
                      (assoc worker :completed completed-runs
                                    :runs-completed completed-runs
@@ -783,6 +1106,8 @@
           (> cycle cycle-cap)
           (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] Completed %d/%d runs in %d cycles (%d merges, %d claims, %d rejections, %d errors, %d recycled)"
                              id completed-runs run-goal (dec cycle)
@@ -792,6 +1117,8 @@
           (>= 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)))
@@ -806,8 +1133,9 @@
                   (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 cycle current-run (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
@@ -820,8 +1148,8 @@
               (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))
+                (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))]
@@ -832,160 +1160,268 @@
                     (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))))
+                    (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 (System/currentTimeMillis)
+                      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)"
-                                         id (if resume? "Resuming" "Starting") cycle cycle-cap current-run run-goal))
+                      _ (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)
-                      {:keys [output exit done? merge? claim-ids] :as agent-result}
+                      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)
-                      mv-claimed-tasks (detect-claimed-tasks pre-current-ids)]
+                      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-orphaned-tasks! id pre-current-ids)
-                          metrics (-> metrics (update :errors inc) (update :recycled + recycled))
+                          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))
-                      (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))
+                      (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) (inc completed-runs) errors metrics nil nil #{} nil 0))))
+                        (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 claimed-ids claimed)
+                          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-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))
+                      (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))
-                        (do
+                        (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)
-                                all-claimed (into claimed-ids mv-claimed-tasks)]
+                          (let [sync-status (sync-worktree-to-main! worker (:path wt-state) id)]
                             (if (= :failed sync-status)
-                              (do
+                              (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-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
-                                                 {:outcome :sync-failed :claimed-task-ids (vec all-claimed)})
+                                (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 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)]
+                                (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-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
-                                                 {:outcome (if merged? :merged :merge-failed)
+                                (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 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)))]
+                                (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 (into claimed-ids mv-claimed-tasks)]
+                                  all-claimed active-claimed-ids]
                               (if (= :failed sync-status)
-                                (do
+                                (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-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
-                                                   {:outcome :sync-failed
+                                  (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) (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)]
+                                  (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-cycle-log! swarm-id id cycle current-run cycle-start-ms new-session-id
-                                                   {:outcome (if merged? :merged :merge-failed)
+                                  (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) (inc completed-runs) 0 metrics nil nil #{} nil 0))))
-                            (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
-                                  metrics (update metrics :recycled + recycled)]
+                                  (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-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))
+                              (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) (inc completed-runs) 0 metrics nil nil #{} nil 0)))))
-                      (let [recycled (recycle-orphaned-tasks! id pre-current-ids)
-                            metrics (update metrics :recycled + recycled)]
+                              (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-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))})
+                        (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 cycle) (inc completed-runs) 0 metrics nil nil #{} nil 0)))
+                        (recur (inc cycle) 1 (inc completed-runs) 0 metrics nil nil #{} nil 0 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))})
+                    (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))
-                      (recur (inc cycle) completed-runs 0 metrics nil nil #{} nil 0))
+                      (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-orphaned-tasks! id pre-current-ids)
-                              metrics (update metrics :recycled + recycled)]
+                        (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-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))})
+                          (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) (inc completed-runs) 0 metrics nil nil #{} nil 0))
+                          (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-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))
+                          (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-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))))))))))))))
+                          (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
@@ -1001,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.
@@ -1023,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
@@ -1091,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)}))