@nbardy/oompa 0.2.0 → 0.3.0

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

@@ -300,7 +300,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 +328,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.0",
   "description": "Git-worktree multi-agent swarm orchestrator for Codex and Claude",
   "license": "MIT",
   "type": "commonjs",