@nbardy/oompa 0.2.0 → 0.3.1

package/README.md

@@ -85,7 +85,7 @@ This repo has a fleshed out version of the idea. The oompa loompas are organized
   "review_model": "codex:codex-5.2",
   "workers": [
     {"model": "claude:opus-4.5", "prompt": ["config/prompts/planner.md"], "iterations": 5, "count": 1},
-    {"model": "codex:codex-5.2-mini", "prompt": ["config/prompts/executor.md"], "iterations": 10, "count": 3}
+    {"model": "codex:codex-5.2-mini", "prompt": ["config/prompts/executor.md"], "iterations": 10, "count": 3, "can_plan": false}
   ]
 }
 ```
@@ -103,6 +103,7 @@ This spawns:
 | `prompt` | no | String or array of paths — concatenated into one prompt |
 | `iterations` | no | Max iterations per worker (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`) |
 
 #### Composable prompts
 

package/agentnet/src/agentnet/cli.clj

@@ -132,34 +132,38 @@
 ;; Commands
 ;; =============================================================================
 
+(declare cmd-swarm)
+
 (defn cmd-run
-  "Run orchestrator once"
+  "Run orchestrator — uses oompa.json if present, otherwise simple mode"
   [opts args]
-  (let [swarm-id (make-swarm-id)]
-    (if-let [specs (:worker-specs opts)]
-    ;; Mixed worker specs: --workers claude:5 codex:4
-    (let [workers (mapcat
-                    (fn [spec]
-                      (let [{:keys [harness count]} spec]
-                        (map-indexed
-                          (fn [idx _]
-                            (worker/create-worker
-                              {:id (format "%s-%d" (name harness) idx)
-                               :swarm-id swarm-id
-                               :harness harness
-                               :model (:model opts)
-                               :iterations 1}))
-                          (range count))))
-                    specs)]
-      (println (format "Running once with mixed workers (swarm %s):" swarm-id))
-      (doseq [spec specs]
-        (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
-      (println)
-      (worker/run-workers! workers))
-    ;; Simple mode
-    (do
-      (println (format "Swarm ID: %s" swarm-id))
-      (orchestrator/run-once! (assoc opts :swarm-id swarm-id))))))
+  (if (.exists (io/file "oompa.json"))
+    (cmd-swarm opts (or (seq args) ["oompa.json"]))
+    (let [swarm-id (make-swarm-id)]
+      (if-let [specs (:worker-specs opts)]
+        ;; Mixed worker specs: --workers claude:5 codex:4
+        (let [workers (mapcat
+                        (fn [spec]
+                          (let [{:keys [harness count]} spec]
+                            (map-indexed
+                              (fn [idx _]
+                                (worker/create-worker
+                                  {:id (format "%s-%d" (name harness) idx)
+                                   :swarm-id swarm-id
+                                   :harness harness
+                                   :model (:model opts)
+                                   :iterations 1}))
+                              (range count))))
+                        specs)]
+          (println (format "Running once with mixed workers (swarm %s):" swarm-id))
+          (doseq [spec specs]
+            (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
+          (println)
+          (worker/run-workers! workers))
+        ;; Simple mode
+        (do
+          (println (format "Swarm ID: %s" swarm-id))
+          (orchestrator/run-once! (assoc opts :swarm-id swarm-id)))))))
 
 (defn cmd-loop
   "Run orchestrator N times"
@@ -300,7 +304,7 @@
       (println "{")
       (println "  \"review_model\": \"codex:codex-5.2\",")
       (println "  \"workers\": [")
-      (println "    {\"model\": \"codex:codex-5.2-mini\", \"prompt\": \"prompts/executor.md\", \"iterations\": 10, \"count\": 3},")
+      (println "    {\"model\": \"codex:codex-5.2-mini\", \"prompt\": \"prompts/executor.md\", \"iterations\": 10, \"count\": 3, \"can_plan\": false},")
       (println "    {\"model\": \"claude:opus-4.5\", \"prompt\": [\"prompts/base.md\", \"prompts/planner.md\"], \"count\": 1}")
       (println "  ]")
       (println "}")
@@ -328,6 +332,7 @@
                            :model model
                            :iterations (or (:iterations wc) 10)
                            :prompts (:prompt wc)
+                           :can-plan (:can_plan wc)
                            :review-harness (:harness review-model)
                            :review-model (:model review-model)})))
                     expanded-workers)]

package/agentnet/src/agentnet/worker.clj

@@ -105,8 +105,9 @@
 
 (defn create-worker
   "Create a worker config.
-   :prompts is a string or vector of strings — paths to prompt files."
-  [{:keys [id swarm-id harness model iterations prompts review-harness review-model]}]
+   :prompts is a string or vector of strings — paths to prompt files.
+   :can-plan when false, worker waits for tasks before starting (backpressure)."
+  [{:keys [id swarm-id harness model iterations prompts can-plan review-harness review-model]}]
   {:id id
    :swarm-id swarm-id
    :harness (or harness :codex)
@@ -116,6 +117,7 @@
               (vector? prompts) prompts
               (string? prompts) [prompts]
               :else [])
+   :can-plan (if (some? can-plan) can-plan true)
    :review-harness review-harness
    :review-model review-model
    :completed 0
@@ -187,6 +189,7 @@
                    (process/sh cmd {:dir abs-worktree :in tagged-prompt :out :string :err :string})
                    (process/sh cmd {:dir abs-worktree :out :string :err :string}))
                  (catch Exception e
+                   (println (format "[%s] Agent exception: %s" id (.getMessage e)))
                    {:exit -1 :out "" :err (.getMessage e)}))]
 
     (when (= harness :codex)
@@ -280,18 +283,18 @@
 
 (defn- merge-to-main!
   "Merge worktree changes to main branch"
-  [wt-path wt-id worker-id]
+  [wt-path wt-id worker-id project-root]
   (println (format "[%s] Merging changes to main" worker-id))
   (let [;; Commit in worktree if needed
         _ (process/sh ["git" "add" "-A"] {:dir wt-path})
         _ (process/sh ["git" "commit" "-m" (str "Work from " wt-id) "--allow-empty"]
                       {:dir wt-path})
-        ;; Checkout main and merge
+        ;; Checkout main and merge (in project root, not worktree)
         checkout-result (process/sh ["git" "checkout" "main"]
-                                    {:out :string :err :string})
+                                    {:dir project-root :out :string :err :string})
         merge-result (when (zero? (:exit checkout-result))
                        (process/sh ["git" "merge" wt-id "--no-edit"]
-                                   {:out :string :err :string}))]
+                                   {:dir project-root :out :string :err :string}))]
     (and (zero? (:exit checkout-result))
          (zero? (:exit merge-result)))))
 
@@ -341,15 +344,17 @@
    Returns {:status :done|:continue|:error, :task task-or-nil}"
   [worker iteration total-iterations]
   (let [worker-id (:id worker)
-        wt-id (format ".w%s-i%d" worker-id iteration)
+        project-root (System/getProperty "user.dir")
+        wt-dir (format ".w%s-i%d" worker-id iteration)
+        wt-branch (format "oompa/%s-i%d" worker-id iteration)
 
         ;; Create worktree
         _ (println (format "[%s] Starting iteration %d/%d" worker-id iteration total-iterations))
-        wt-path (str (System/getProperty "user.dir") "/" wt-id)]
+        wt-path (str project-root "/" wt-dir)]
 
     (try
-      ;; Setup worktree
-      (process/sh ["git" "worktree" "add" wt-id "-b" wt-id])
+      ;; Setup worktree (in project root) — dir starts with . but branch name must be valid
+      (process/sh ["git" "worktree" "add" wt-dir "-b" wt-branch] {:dir project-root})
 
       ;; Build context
       (let [context (build-context)
@@ -367,7 +372,7 @@
           ;; Agent errored
           (not (zero? exit))
           (do
-            (println (format "[%s] Agent error (exit %d)" worker-id exit))
+            (println (format "[%s] Agent error (exit %d): %s" worker-id exit (subs (or output "") 0 (min 200 (count (or output ""))))))
             {:status :error :exit exit})
 
           ;; Success - run review loop before merge
@@ -375,7 +380,7 @@
           (let [{:keys [approved?]} (review-loop! worker wt-path worker-id)]
             (if approved?
               (do
-                (merge-to-main! wt-path wt-id worker-id)
+                (merge-to-main! wt-path wt-branch worker-id project-root)
                 (println (format "[%s] Iteration %d/%d complete" worker-id iteration total-iterations))
                 {:status :continue})
               (do
@@ -383,13 +388,33 @@
                 {:status :continue})))))
 
       (finally
-        ;; Cleanup worktree
-        (process/sh ["git" "worktree" "remove" wt-id "--force"])))))
+        ;; Cleanup worktree (in project root)
+        (process/sh ["git" "worktree" "remove" wt-dir "--force"] {:dir project-root})))))
 
 ;; =============================================================================
 ;; Worker Loop
 ;; =============================================================================
 
+(def ^:private max-wait-for-tasks 60)
+(def ^:private wait-poll-interval 5)
+
+(defn- wait-for-tasks!
+  "Wait up to 60s for pending/current tasks to appear. Used for backpressure
+   on workers that can't create their own tasks (can_plan: false)."
+  [worker-id]
+  (loop [waited 0]
+    (cond
+      (pos? (tasks/pending-count)) true
+      (pos? (tasks/current-count)) true
+      (>= waited max-wait-for-tasks)
+      (do (println (format "[%s] No tasks after %ds, proceeding anyway" worker-id waited))
+          false)
+      :else
+      (do (when (zero? (mod waited 15))
+            (println (format "[%s] Waiting for tasks... (%ds)" worker-id waited)))
+          (Thread/sleep (* wait-poll-interval 1000))
+          (recur (+ waited wait-poll-interval))))))
+
 (defn run-worker!
   "Run worker loop until done or iterations exhausted.
 
@@ -403,6 +428,10 @@
                      (or (:model worker) "default")
                      iterations))
 
+    ;; Backpressure: workers that can't create tasks wait for tasks to exist
+    (when-not (:can-plan worker)
+      (wait-for-tasks! id))
+
     (loop [iter 1
            completed 0]
       (if (> iter iterations)

package/config/prompts/planner.md

@@ -6,5 +6,6 @@ You are a planner. You read the spec, explore the codebase, and create well-scop
 - Set :difficulty on each task (:easy, :medium, :hard) so the right worker picks it up.
 - Refine or split tasks that are too large or vague.
 - Check ../tasks/complete/ before creating duplicates.
-- You may also execute tasks if the queue is full and you see something quick to do.
+- Do NOT claim or complete tasks. Your job is to create them for other workers.
+- Do NOT write application code. Only write task .edn files.
 - Spend time thinking. Good task decomposition is the highest-leverage thing you can do.

package/oompa.example.json

@@ -12,7 +12,8 @@
       "model": "codex:codex-5.2-mini",
       "prompt": ["config/prompts/executor.md"],
       "iterations": 10,
-      "count": 3
+      "count": 3,
+      "can_plan": false
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbardy/oompa",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Git-worktree multi-agent swarm orchestrator for Codex and Claude",
   "license": "MIT",
   "type": "commonjs",