@nbardy/oompa 0.7.2 → 0.7.3

package/README.md

@@ -83,9 +83,9 @@ This repo has a fleshed out version of the idea. The oompa loompas are organized
 ```json
 {
   "workers": [
-    {"model": "claude:opus", "prompt": ["config/prompts/planner.md"], "iterations": 5, "count": 1},
-    {"model": "codex:gpt-5.3-codex:medium", "prompt": ["config/prompts/executor.md"], "iterations": 10, "count": 2, "can_plan": false},
-    {"model": "opencode:opencode/kimi-k2.5-free", "prompt": ["config/prompts/executor.md"], "iterations": 10, "count": 1, "can_plan": false}
+    {"model": "claude:opus", "prompt": ["config/prompts/planner.md"], "max_cycle": 5, "count": 1},
+    {"model": "codex:gpt-5.3-codex:medium", "prompt": ["config/prompts/executor.md"], "max_cycle": 10, "count": 2, "can_plan": false},
+    {"model": "opencode:opencode/kimi-k2.5-free", "prompt": ["config/prompts/executor.md"], "max_cycle": 10, "count": 1, "can_plan": false}
   ]
 }
 ```
@@ -101,11 +101,13 @@ This spawns:
 |-------|----------|-------------|
 | `model` | yes | `harness:model` or `harness:model:reasoning` (e.g. `codex:gpt-5.3-codex:medium`, `claude:opus`, `opencode:opencode/kimi-k2.5-free`) |
 | `prompt` | no | String or array of paths — concatenated into one prompt |
-| `iterations` | no | Max iterations per worker (default: 10) |
+| `max_cycle` | no | Max worker cycles for JSON config runs (default: 10) |
 | `count` | no | Number of workers with this config (default: 1) |
 | `can_plan` | no | If `false`, worker waits for tasks before starting (default: `true`) |
 | `max_wait_for_tasks` | no | Max seconds a `can_plan: false` worker waits for queue work (default: `600`) |
 
+`oompa loop` still uses the CLI flag `--iterations`. JSON worker configs use `max_cycle`.
+
 #### Composable prompts
 
 `prompt` accepts a string or an array. Arrays get concatenated, so you can reuse a shared base across workers:

package/agentnet/src/agentnet/agent.clj

@@ -176,16 +176,12 @@
   #"(?m)^\s*#oompa_directive:include_file\s+\"([^\"]+)\"\s*$")
 
 (defn- read-file-cached
-  "Read a prompt file once and cache by canonical path."
+  "Reads prompts fresh on each run so roles can be edited live. It is a fast op."
   [path]
   (when path
-    (if-let [cached (get @prompt-file-cache path)]
-      cached
-      (let [f (io/file path)]
-        (when (.exists f)
-          (let [content (slurp f)]
-            (swap! prompt-file-cache assoc path content)
-            content))))))
+    (let [f (io/file path)]
+      (when (.exists f)
+        (slurp f)))))
 
 (defn- resolve-include-path
   "Resolve an include path relative to the file that declares it."
@@ -276,6 +272,11 @@
   [output]
   (boolean (re-find #"COMPLETE_AND_READY_FOR_MERGE" (or output ""))))
 
+(defn needs-followup-signal?
+  "Check if output contains NEEDS_FOLLOWUP signal"
+  [output]
+  (boolean (re-find #"NEEDS_FOLLOWUP" (or output ""))))
+
 (defn parse-claim-signal
   "Extract task IDs from CLAIM(...) signal in output.
    Returns vector of task ID strings, or nil if no CLAIM signal found.

package/agentnet/src/agentnet/cli.clj

@@ -175,45 +175,145 @@
       (println "WARNING: Git working tree is dirty. You may experience merge conflicts.")
       (println output))))
 
-(defn- check-stale-worktrees!
-  "Abort if stale oompa worktrees or branches exist from a prior run.
-   Corrupted .git/worktrees/ entries poison git worktree add for ALL workers,
-   not just the worker whose entry is stale. (See swarm af32b180 — kimi-k2.5
-   w9 went 20/20 doing nothing because w10's corrupt commondir blocked it.)"
-  []
-  ;; Prune orphaned metadata first — cleans entries whose directories are gone
+(defn- dirty-worktree?
+  "Returns true if the git worktree at path has uncommitted changes."
+  [path]
+  (let [{:keys [exit out]} (process/sh ["git" "-C" path "status" "--porcelain"]
+                                       {:out :string :err :string})]
+    (and (zero? exit) (not (str/blank? out)))))
+
+(defn- worktree-branch-name
+  "Returns the current branch name for the worktree at path, or nil on failure."
+  [path]
+  (let [{:keys [exit out]} (process/sh ["git" "-C" path "rev-parse" "--abbrev-ref" "HEAD"]
+                                       {:out :string :err :string})]
+    (when (zero? exit) (str/trim out))))
+
+(defn- remove-stale-worktree!
+  "Remove a stale worktree directory and delete its branch."
+  [path branch]
+  (process/sh ["git" "worktree" "remove" "--force" path] {:out :string :err :string})
+  (when (and branch (not (str/blank? branch)) (not= branch "HEAD"))
+    (process/sh ["git" "branch" "-D" branch] {:out :string :err :string})))
+
+(defn- run-stale-review!
+  "Invoke the reviewer model on partial worktree changes.
+   Tries each reviewer in the fallback chain until one returns a verdict.
+   Returns :merge to merge the branch into main, :discard to throw it away."
+  [reviewer-configs worktree-path branch]
+  (let [diff-out (:out (process/sh ["git" "-C" worktree-path "diff" "HEAD"]
+                                   {:out :string :err :string}))
+        diff     (if (> (count diff-out) 8000)
+                   (str (subs diff-out 0 8000) "\n...[diff truncated at 8000 chars]")
+                   diff-out)
+        status-out (:out (process/sh ["git" "-C" worktree-path "status" "--short"]
+                                     {:out :string}))
+        prompt   (str "You are reviewing partial/incomplete changes from an interrupted swarm run.\n\n"
+                      "Branch: " branch "\n"
+                      "Status:\n" status-out "\n\n"
+                      "Diff:\n```\n" diff "\n```\n\n"
+                      "Should these changes be merged into main or discarded?\n"
+                      "MERGE if: changes are correct, complete, or valuable enough to keep.\n"
+                      "DISCARD if: changes are broken, trivial, or not worth merging.\n\n"
+                      "Your verdict MUST appear on its own line, exactly one of:\n"
+                      "VERDICT: MERGE\n"
+                      "VERDICT: DISCARD\n\n"
+                      "Then briefly explain why.\n")
+        result   (reduce (fn [_ {:keys [harness model]}]
+                           (try
+                             (let [cmd (harness/build-cmd harness {:model model :prompt prompt})
+                                   res (process/sh cmd
+                                                   {:in  (harness/process-stdin harness prompt)
+                                                    :out :string :err :string})
+                                   output       (:out res)
+                                   has-verdict? (or (re-find #"VERDICT:\s*MERGE" output)
+                                                    (re-find #"VERDICT:\s*DISCARD" output))]
+                               (if (and (zero? (:exit res)) has-verdict?)
+                                 (reduced res)
+                                 res))
+                             (catch Exception e
+                               {:exit -1 :out "" :err (.getMessage e)})))
+                         {:exit -1 :out ""}
+                         reviewer-configs)
+        output   (:out result)]
+    (cond
+      (re-find #"VERDICT:\s*MERGE"   output) :merge
+      (re-find #"VERDICT:\s*DISCARD" output) :discard
+      :else                                   :discard)))
+
+(defn- handle-stale-worktrees!
+  "Non-destructive startup check for existing oompa worktrees.
+
+   - Always runs `git worktree prune` to clear orphaned metadata.
+   - Never auto-removes/merges/discards worktrees at startup.
+   - Prints a warning summary so concurrent swarms are not disrupted.
+
+   This avoids clobbering active work from another swarm in the same repo."
+  [_reviewer-configs]
+  ;; Step 1: prune orphaned git metadata first
   (let [prune-result (process/sh ["git" "worktree" "prune"] {:out :string :err :string})]
     (when-not (zero? (:exit prune-result))
       (println "WARNING: git worktree prune failed:")
       (println (:err prune-result))))
-  (let [;; Find .ww* directories (oompa per-iteration worktree naming convention)
-        ls-result (process/sh ["find" "." "-maxdepth" "1" "-type" "d" "-name" ".ww*"]
-                              {:out :string})
-        stale-dirs (when (zero? (:exit ls-result))
-                     (->> (str/split-lines (:out ls-result))
-                          (remove str/blank?)))
-        ;; Find oompa/* branches
-        br-result (process/sh ["git" "branch" "--list" "oompa/*"]
+
+  ;; Step 2: discover existing oompa worktree dirs and oompa/* branches
+  (let [ls-result          (process/sh ["find" "." "-maxdepth" "1" "-type" "d" "-name" ".w*-i*"]
+                                       {:out :string})
+        stale-dirs         (when (zero? (:exit ls-result))
+                             (->> (str/split-lines (:out ls-result))
+                                  (remove str/blank?)))
+        br-result          (process/sh ["git" "branch" "--list" "oompa/*"] {:out :string})
+        all-oompa-branches (when (zero? (:exit br-result))
+                             (->> (str/split-lines (:out br-result))
+                                  (map str/trim)
+                                  (remove str/blank?)))]
+
+    (when (or (seq stale-dirs) (seq all-oompa-branches))
+      ;; Step 3: classify for warning output only (no mutation)
+      (let [classified      (mapv (fn [dir]
+                                    {:dir    dir
+                                     :branch (worktree-branch-name dir)
+                                     :dirty? (dirty-worktree? dir)})
+                                  stale-dirs)
+            clean           (filter (complement :dirty?) classified)
+            dirty           (filter :dirty? classified)
+            dir-branches    (set (keep :branch classified))
+            orphan-branches (remove #(contains? dir-branches %) all-oompa-branches)]
+        (println)
+        (println "WARNING: Existing oompa worktrees/branches detected; leaving them untouched.")
+        (println (format "  Worktrees: %d (%d dirty, %d clean)"
+                         (count classified) (count dirty) (count clean)))
+        (println (format "  Orphan branches: %d" (count orphan-branches)))
+        (when (seq dirty)
+          (println "  Dirty worktrees:")
+          (doseq [{:keys [dir branch]} dirty]
+            (println (format "    %s (branch: %s)" dir (or branch "unknown")))))
+        (println "  Run `oompa cleanup` manually when you want to reclaim them.")))))
+
+(defn- cleanup-iteration-worktrees!
+  "Remove swarm iteration worktree dirs (.w*-i*) and oompa/* branches.
+   Returns {:dirs-removed n :branches-removed n}."
+  []
+  (let [ls-result (process/sh ["find" "." "-maxdepth" "1" "-type" "d" "-name" ".w*-i*"]
                               {:out :string})
-        stale-branches (when (zero? (:exit br-result))
-                         (->> (str/split-lines (:out br-result))
-                              (map str/trim)
-                              (remove str/blank?)))]
-    (when (or (seq stale-dirs) (seq stale-branches))
-      (println "ERROR: Stale oompa worktrees detected from a prior run.")
-      (println "       Corrupt worktree metadata will cause worker failures.")
-      (println)
-      (when (seq stale-dirs)
-        (println (format "  Stale directories (%d):" (count stale-dirs)))
-        (doseq [d stale-dirs] (println (str "    " d))))
-      (when (seq stale-branches)
-        (println (format "  Stale branches (%d):" (count stale-branches)))
-        (doseq [b stale-branches] (println (str "    " b))))
-      (println)
-      (println "Clean up with:")
-      (println "  git worktree prune; for d in .ww*/; do git worktree remove --force \"$d\" 2>/dev/null; done; git branch --list 'oompa/*' | xargs git branch -D 2>/dev/null; rm -rf .ww*")
-      (println)
-      (System/exit 1))))
+        dirs (if (zero? (:exit ls-result))
+               (->> (str/split-lines (:out ls-result))
+                    (remove str/blank?))
+               [])
+        _ (doseq [dir dirs]
+            (remove-stale-worktree! dir (worktree-branch-name dir)))
+        br-result (process/sh ["git" "branch" "--list" "oompa/*"] {:out :string})
+        branches (if (zero? (:exit br-result))
+                   (->> (str/split-lines (:out br-result))
+                        (map str/trim)
+                        (remove str/blank?))
+                   [])
+        ;; Branches may already be deleted by remove-stale-worktree!, so ignore failures.
+        _ (doseq [b branches]
+            (process/sh ["git" "branch" "-D" b] {:out :string :err :string}))]
+    {:dirs-removed (count dirs)
+     :branches-removed (count branches)}))
+
 
 (defn- probe-model
   "Send 'say ok' to a model via its harness CLI. Returns true if model responds.
@@ -429,7 +529,11 @@
   [opts config-file]
   (print-preflight-warnings!)
   (when-not (.exists (io/file config-file))
-    (println (format "Config not found: %s" config-file))
+    (println (format "ERROR: Config file not found: %s" (.getCanonicalPath (io/file config-file))))
+    (println (format "       Working directory: %s" (.getCanonicalPath (io/file "."))))
+    (println)
+    (println "Tip: paths are relative to the working directory. Did you mean:")
+    (println (format "       oompa run --config oompa/%s" (.getName (io/file config-file))))
     (System/exit 1))
   (let [timeout-sec (or (:startup-timeout opts)
                         (parse-int (System/getenv "OOMPA_DETACH_STARTUP_TIMEOUT")
@@ -649,10 +753,10 @@
           (println "No runs found."))))))
 
 (def ^:private error-outcomes
-  #{"error" "merge-failed" "rejected" "stuck"})
+  #{"error" "merge-failed" "rejected" "stuck" "needs-followup"})
 
 (def ^:private terminal-run-outcomes
-  #{"merged" "rejected" "error" "merge-failed" "sync-failed" "stuck" "no-changes"})
+  #{"merged" "rejected" "error" "merge-failed" "sync-failed" "stuck" "no-changes" "needs-followup"})
 
 (defn- run-state
   "Derive run lifecycle state from started/stopped events + PID liveness."
@@ -826,15 +930,18 @@
       (println "No worktrees initialized."))))
 
 (defn cmd-cleanup
-  "Remove all worktrees"
+  "Remove all worktrees (legacy pool + swarm iteration worktrees)."
   [opts args]
   (let [state-file (io/file ".workers/state.edn")]
+    (println "Removing worktrees...")
     (if (.exists state-file)
       (let [pool (read-string (slurp state-file))]
-        (println "Removing worktrees...")
-        (worktree/cleanup-pool! pool)
-        (println "Done."))
-      (println "No worktrees to clean up."))))
+        (worktree/cleanup-pool! pool))
+      (println "No legacy pool worktrees to clean up."))
+    (let [{:keys [dirs-removed branches-removed]} (cleanup-iteration-worktrees!)]
+      (println (format "Removed %d swarm worktree dir(s) and %d oompa branch(es)."
+                       dirs-removed branches-removed)))
+    (println "Done.")))
 
 (defn cmd-context
   "Print current context (for debugging prompts)"
@@ -882,6 +989,30 @@
         {:harness :codex :model s}))
     {:harness :codex :model s}))
 
+(defn- parse-reviewer-entry
+  "Parse reviewer config entry from either:
+   1) string model spec: \"harness:model[:reasoning]\"
+   2) map: {:model \"...\" :prompt \"path\"|[...]}.
+   Returns nil for invalid entries."
+  [entry]
+  (cond
+    (string? entry)
+    (parse-model-string entry)
+
+    (map? entry)
+    (let [model (:model entry)]
+      (when (string? model)
+        (let [parsed (parse-model-string model)
+              prompts (let [p (:prompt entry)]
+                        (cond
+                          (vector? p) p
+                          (string? p) [p]
+                          :else []))]
+          (assoc parsed :prompts prompts))))
+
+    :else
+    nil))
+
 (defn cmd-swarm
   "Run multiple worker configs from oompa.json in parallel"
   [opts args]
@@ -889,35 +1020,36 @@
         f (io/file config-file)
         swarm-id (make-swarm-id)]
     (when-not (.exists f)
-      (println (format "Config file not found: %s" config-file))
+      (println (format "ERROR: Config file not found: %s" (.getCanonicalPath f)))
+      (println (format "       Working directory: %s" (.getCanonicalPath (io/file "."))))
       (println)
-      (println "Create oompa.json with format:")
-      (println "{")
-      (println "  \"workers\": [")
-      (println "    {\"model\": \"codex:gpt-5.3-codex:medium\", \"prompt\": \"prompts/executor.md\", \"iterations\": 10, \"count\": 3, \"can_plan\": false},")
-      (println "    {\"model\": \"claude:opus\", \"prompt\": [\"prompts/base.md\", \"prompts/planner.md\"], \"count\": 1},")
-      (println "    {\"model\": \"gemini:gemini-3-pro-preview\", \"prompt\": [\"prompts/executor.md\"], \"count\": 1}")
-      (println "  ]")
-      (println "}")
-      (println)
-      (println "prompt: string or array of paths — concatenated into one prompt.")
+      (println "Tip: paths are relative to the working directory. Did you mean:")
+      (println (format "       oompa run --config oompa/%s" (.getName f)))
       (System/exit 1))
     ;; Preflight: abort if git is dirty to prevent merge conflicts
     (check-git-clean!)
-    ;; Preflight: abort if stale worktrees from prior runs would poison git
-    (check-stale-worktrees!)
 
     (let [config (json/parse-string (slurp f) true)
-          ;; Parse reviewer config — supports both formats:
-          ;; Legacy: {"review_model": "harness:model:reasoning"}
-          ;; New:    {"reviewer": {"model": "harness:model:reasoning", "prompt": ["path.md"]}}
+          ;; Parse reviewer config — supports legacy + new formats.
           generic-reviewers (cond
                               (:review_models config)
-                              (mapv parse-model-string (:review_models config))
-                              
+                              (->> (:review_models config)
+                                   (map parse-reviewer-entry)
+                                   (remove nil?)
+                                   vec)
+
                               (:review_model config)
-                              [(parse-model-string (:review_model config))]
-                              
+                              (->> [(:review_model config)]
+                                   (map parse-reviewer-entry)
+                                   (remove nil?)
+                                   vec)
+
+                              (:reviewer config)
+                              (->> [(:reviewer config)]
+                                   (map parse-reviewer-entry)
+                                   (remove nil?)
+                                   vec)
+
                               :else [])
 
           ;; Parse planner config — optional dedicated planner
@@ -933,8 +1065,19 @@
                                     :prompts prompts
                                     :max-pending (or (:max_pending planner-config) 10))))
 
+
           worker-configs (:workers config)
 
+          ;; Require max_cycle to be present on all workers
+          _ (doseq [[idx wc] (map-indexed vector worker-configs)]
+              (when (or (:iterations wc) (:max_cycles wc))
+                (println (format "ERROR: Worker %d uses deprecated 'iterations' or 'max_cycles'. Consolidate strictly on 'max_cycle'." idx))
+                (System/exit 1))
+              (when-not (:max_cycle wc)
+                (println (format "ERROR: Worker %d missing 'max_cycle' in config." idx))
+                (System/exit 1)))
+
+
           ;; Expand worker configs by count
           expanded-workers (mapcat (fn [wc]
                                      (let [cnt (or (:count wc) 1)]
@@ -945,16 +1088,38 @@
           workers (map-indexed
                     (fn [idx wc]
                       (let [{:keys [harness model reasoning]} (parse-model-string (:model wc))
-                            ;; Support per-worker reviewer override
-                            worker-reviewer-config (:reviewer wc)
-                            specific-reviewer (when worker-reviewer-config
-                                                (let [parsed (parse-model-string (:model worker-reviewer-config))
-                                                      prompts (let [p (:prompt worker-reviewer-config)]
-                                                                (cond (vector? p) p
-                                                                      (string? p) [p]
-                                                                      :else []))]
-                                                  (assoc parsed :prompts prompts)))
-                            all-reviewers (->> (concat (if specific-reviewer [specific-reviewer] []) generic-reviewers)
+                            ;; Support per-worker reviewer override (legacy + new):
+                            ;; - review_model: "harness:model"
+                            ;; - review_models: ["harness:model", ...]
+                            ;; - reviewer: {model, prompt}
+                            ;; - reviewers: [string|map, ...]
+                            worker-reviewers (cond
+                                               (:reviewers wc)
+                                               (->> (:reviewers wc)
+                                                    (map parse-reviewer-entry)
+                                                    (remove nil?)
+                                                    vec)
+
+                                               (:review_models wc)
+                                               (->> (:review_models wc)
+                                                    (map parse-reviewer-entry)
+                                                    (remove nil?)
+                                                    vec)
+
+                                               (:reviewer wc)
+                                               (->> [(:reviewer wc)]
+                                                    (map parse-reviewer-entry)
+                                                    (remove nil?)
+                                                    vec)
+
+                                               (:review_model wc)
+                                               (->> [(:review_model wc)]
+                                                    (map parse-reviewer-entry)
+                                                    (remove nil?)
+                                                    vec)
+
+                                               :else [])
+                            all-reviewers (->> (concat worker-reviewers generic-reviewers)
                                                (map #(select-keys % [:harness :model :reasoning :prompts]))
                                                (distinct)
                                                (vec))]
@@ -964,9 +1129,9 @@
                            :harness harness
                            :model model
                            :reasoning reasoning
-                           :runs (or (:runs wc) (:iterations wc) 10)
-                           :max-cycles (or (:max_cycles wc) (:iterations wc) (:runs wc) 10)
-                           :iterations (or (:iterations wc) 10)
+                           :runs (or (:runs wc) 10)
+                           :max-cycles (:max_cycle wc)
+                           :iterations (:max_cycle wc)
                            :prompts (:prompt wc)
                            :can-plan (:can_plan wc)
                            :wait-between (:wait_between wc)
@@ -975,6 +1140,10 @@
                            :reviewers all-reviewers})))
                     expanded-workers)]
 
+      ;; Preflight: handle stale worktrees from prior runs before launching workers.
+      ;; Empty ones are auto-cleaned silently; dirty ones trigger an interactive review.
+      (handle-stale-worktrees! generic-reviewers)
+
       (println (format "Swarm config from %s:" config-file))
       (println (format "  Swarm ID: %s" swarm-id))
       (when planner-parsed
@@ -996,8 +1165,8 @@
                            (name harness)
                            model
                            (if reasoning (str ":" reasoning) "")
-                           (or (:runs wc) (:iterations wc) 10)
-                           (or (:max_cycles wc) (:iterations wc) (:runs wc) 10)
+                           (or (:runs wc) 10)
+                           (:max_cycle wc)
                            (if (:prompt wc) (str ", " (:prompt wc)) "")))))
       (println)
 
@@ -1046,6 +1215,26 @@
       (doseq [t (tasks/list-current)]
         (println (format "  - %s: %s" (:id t) (:summary t)))))))
 
+(defn cmd-requeue
+  "Move current/ tasks back to pending/.
+   With args, only requeue those task IDs. Without args, requeue all current tasks."
+  [opts args]
+  (tasks/ensure-dirs!)
+  (let [current-ids (->> (tasks/list-current) (map :id) set)
+        requested-ids (if (seq args) (set args) current-ids)
+        recyclable-ids (set (filter current-ids requested-ids))
+        recycled (if (seq args)
+                   (tasks/recycle-tasks! recyclable-ids)
+                   (tasks/recycle-all-current!))
+        missing (sort (remove recyclable-ids requested-ids))]
+    (if (seq recycled)
+      (println (format "Requeued %d task(s): %s"
+                       (count recycled)
+                       (str/join ", " recycled)))
+      (println "No current tasks were requeued."))
+    (when (seq missing)
+      (println (format "Not in current/: %s" (str/join ", " missing))))))
+
 (defn- find-latest-swarm-id
   "Find the most recent swarm ID from runs/ directory."
   []
@@ -1121,6 +1310,7 @@
   (println "  loop N           Run N iterations")
   (println "  swarm [file]     Run multiple worker configs from oompa.json (parallel)")
   (println "  tasks            Show task status (pending/current/complete)")
+  (println "  requeue [ids..]  Move current tasks back to pending")
   (println "  prompt \"...\"     Run ad-hoc prompt")
   (println "  status           Show running swarms")
   (println "  info             Show detailed summary of the last run")
@@ -1186,6 +1376,7 @@
    "loop" cmd-loop
    "swarm" cmd-swarm
    "tasks" cmd-tasks
+   "requeue" cmd-requeue
    "prompt" cmd-prompt
    "status" cmd-status
    "info" cmd-info