@nbardy/oompa 0.6.0 → 0.7.1

package/agentnet/src/agentnet/cli.clj

@@ -5,7 +5,7 @@
      ./swarm.bb run                                    # Run all tasks once
      ./swarm.bb run --workers 4                        # With 4 parallel workers
      ./swarm.bb loop 20 --harness claude               # 20 iterations with Claude
-     ./swarm.bb loop --workers claude:5 codex:4 --iterations 20  # Mixed harnesses
+     ./swarm.bb loop --workers claude:5 opencode:2 --iterations 20  # Mixed harnesses
      ./swarm.bb swarm oompa.json                       # Multi-model from config
      ./swarm.bb prompt \"...\"                          # Ad-hoc task
      ./swarm.bb status                                 # Show last run
@@ -16,6 +16,8 @@
             [agentnet.worker :as worker]
             [agentnet.tasks :as tasks]
             [agentnet.agent :as agent]
+            [agentnet.harness :as harness]
+            [agentnet.runs :as runs]
             [babashka.process :as process]
             [clojure.string :as str]
             [clojure.java.io :as io]
@@ -30,20 +32,22 @@
     (Integer/parseInt s)
     (catch Exception _ default)))
 
+(def ^:private harnesses (harness/known-harnesses))
+
 (defn- make-swarm-id
   "Generate a short run-level swarm ID."
   []
   (subs (str (java.util.UUID/randomUUID)) 0 8))
 
 (defn- parse-worker-spec
-  "Parse 'harness:count' into {:harness :claude, :count 5}.
+  "Parse 'harness:count' into {:harness :opencode, :count 5}.
    Throws on invalid format."
   [s]
   (let [[harness count-str] (str/split s #":" 2)
         h (keyword harness)
         cnt (parse-int count-str 0)]
-    (when-not (#{:codex :claude} h)
-      (throw (ex-info (str "Unknown harness in worker spec: " s ". Use 'codex:N' or 'claude:N'") {})))
+    (when-not (harnesses h)
+      (throw (ex-info (str "Unknown harness in worker spec: " s ". Known: " (str/join ", " (map name (sort harnesses)))) {})))
     (when (zero? cnt)
       (throw (ex-info (str "Invalid count in worker spec: " s ". Use format 'harness:count'") {})))
     {:harness h :count cnt}))
@@ -80,7 +84,7 @@
         (= arg "--workers")
         (let [next-arg (second remaining)]
           (if (worker-spec? next-arg)
-            ;; Collect all worker specs: --workers claude:5 codex:4
+            ;; Collect all worker specs: --workers claude:5 opencode:2
             (let [[specs rest] (collect-worker-specs (next remaining))]
               (recur (assoc opts :worker-specs specs) rest))
             ;; Simple count: --workers 4
@@ -93,8 +97,8 @@
 
         (= arg "--harness")
         (let [h (keyword (second remaining))]
-          (when-not (#{:codex :claude} h)
-            (throw (ex-info (str "Unknown harness: " (second remaining) ". Use 'codex' or 'claude'") {})))
+          (when-not (harnesses h)
+            (throw (ex-info (str "Unknown harness: " (second remaining) ". Known: " (str/join ", " (map name (sort harnesses)))) {})))
           (recur (assoc opts :harness h)
                  (nnext remaining)))
 
@@ -135,14 +139,67 @@
 
 (declare cmd-swarm parse-model-string)
 
+(defn- check-git-clean!
+  "Abort if git working tree is dirty. Dirty index causes merge conflicts
+   and wasted worker iterations."
+  []
+  (let [result (process/sh ["git" "status" "--porcelain"]
+                           {:out :string :err :string})
+        output (str/trim (:out result))]
+    (when (and (zero? (:exit result)) (not (str/blank? output)))
+      (println "ERROR: Git working tree is dirty. Resolve before running swarm.")
+      (println)
+      (println output)
+      (println)
+      (println "Run 'git stash' or 'git commit' first.")
+      (System/exit 1))))
+
+(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
+  (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/*"]
+                              {: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))))
+
 (defn- probe-model
   "Send 'say ok' to a model via its harness CLI. Returns true if model responds.
-   Claude hangs without /dev/null stdin when spawned from bb."
-  [harness model]
+   Uses harness/build-probe-cmd for the command, /dev/null stdin to prevent hang."
+  [harness-kw model]
   (try
-    (let [cmd (case harness
-                :claude ["claude" "--model" model "-p" "[oompa:probe] say ok" "--max-turns" "1"]
-                :codex  ["codex" "exec" "--dangerously-bypass-approvals-and-sandbox" "--skip-git-repo-check" "--model" model "--" "[oompa:probe] say ok"])
+    (let [cmd (harness/build-probe-cmd harness-kw model)
           null-in (io/input-stream (io/file "/dev/null"))
           proc (process/process cmd {:out :string :err :string :in null-in})
           result (deref proc 30000 :timeout)]
@@ -187,7 +244,7 @@
     (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
+        ;; Mixed worker specs: --workers claude:5 opencode:2
         (let [workers (mapcat
                         (fn [spec]
                           (let [{:keys [harness count]} spec]
@@ -206,10 +263,10 @@
             (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
           (println)
           (worker/run-workers! workers))
-        ;; Simple mode
+        ;; Simple mode retired — use oompa.json or --workers harness:count
         (do
-          (println (format "Swarm ID: %s" swarm-id))
-          (orchestrator/run-once! (assoc opts :swarm-id swarm-id)))))))
+          (println "Simple mode is no longer supported. Use oompa.json or --workers harness:count.")
+          (System/exit 1))))))
 
 (defn cmd-loop
   "Run orchestrator N times"
@@ -219,7 +276,7 @@
                        (:iterations opts)
                        20)]
     (if-let [specs (:worker-specs opts)]
-      ;; Mixed worker specs: --workers claude:5 codex:4
+      ;; Mixed worker specs: --workers claude:5 opencode:2
       (let [workers (mapcat
                       (fn [spec]
                         (let [{:keys [harness count]} spec]
@@ -238,14 +295,10 @@
           (println (format "  %dx %s" (:count spec) (name (:harness spec)))))
         (println)
         (worker/run-workers! workers))
-      ;; Simple mode: --workers N --harness X
-      (let [model-str (if (:model opts)
-                        (format " (model: %s)" (:model opts))
-                        "")]
-        (println (format "Starting %d iterations with %s harness%s..."
-                         iterations (name (:harness opts)) model-str))
-        (println (format "Swarm ID: %s" swarm-id))
-        (orchestrator/run-loop! iterations (assoc opts :swarm-id swarm-id))))))
+      ;; Simple mode retired — use oompa.json or --workers harness:count
+      (do
+        (println "Simple mode is no longer supported. Use oompa.json or --workers harness:count.")
+        (System/exit 1)))))
 
 (defn cmd-prompt
   "Run ad-hoc prompt as single task"
@@ -265,25 +318,64 @@
       (orchestrator/run-once! opts))))
 
 (defn cmd-status
-  "Show status of last run"
+  "Show status of last run — reads event-sourced runs/{swarm-id}/ data."
   [opts args]
-  (let [runs-dir (io/file "runs")
-        files (when (.exists runs-dir)
-                (->> (.listFiles runs-dir)
-                     (filter #(.isFile %))
-                     (sort-by #(.lastModified %) >)))]
-    (if-let [latest (first files)]
-      (do
-        (println (format "Latest run: %s" (.getName latest)))
+  (let [run-ids (runs/list-runs)]
+    (if (seq run-ids)
+      (let [swarm-id (or (first args) (first run-ids))
+            started (runs/read-started swarm-id)
+            stopped (runs/read-stopped swarm-id)
+            cycles (runs/list-cycles swarm-id)
+            reviews (runs/list-reviews swarm-id)]
+        (println (format "Swarm: %s" swarm-id))
+        (when started
+          (println (format "  Started: %s" (:started-at started)))
+          (println (format "  PID:     %s" (or (:pid started) "N/A")))
+          (println (format "  Config:  %s" (or (:config-file started) "N/A")))
+          (println (format "  Workers: %d" (count (:workers started)))))
         (println)
-        (with-open [r (io/reader latest)]
-          (let [entries (mapv #(json/parse-string % true) (line-seq r))
-                by-status (group-by :status entries)]
-            (doseq [[status tasks] (sort-by first by-status)]
-              (println (format "%s: %d" (name status) (count tasks))))
+        (if stopped
+          (println (format "Stopped: %s (reason: %s%s)"
+                           (:stopped-at stopped)
+                           (:reason stopped)
+                           (if (:error stopped)
+                             (str ", error: " (:error stopped))
+                             "")))
+          (println "  (still running — no stopped event yet)"))
+        (when (seq cycles)
+          (println)
+          (println (format "Cycles: %d total" (count cycles)))
+          (doseq [c cycles]
+            (println (format "  %s-c%d: %s (%dms, claimed: %s)"
+                             (:worker-id c) (:cycle c)
+                             (:outcome c)
+                             (or (:duration-ms c) 0)
+                             (str/join ", " (or (:claimed-task-ids c) []))))))
+        (when (seq reviews)
+          (println)
+          (println (format "Reviews: %d total" (count reviews)))
+          (doseq [r reviews]
+            (println (format "  %s-c%d-r%d: %s"
+                             (:worker-id r) (:cycle r) (:round r)
+                             (:verdict r))))))
+      ;; Fall back to legacy JSONL format
+      (let [runs-dir (io/file "runs")
+            files (when (.exists runs-dir)
+                    (->> (.listFiles runs-dir)
+                         (filter #(.isFile %))
+                         (sort-by #(.lastModified %) >)))]
+        (if-let [latest (first files)]
+          (do
+            (println (format "Latest run (legacy): %s" (.getName latest)))
             (println)
-            (println (format "Total: %d tasks" (count entries))))))
-      (println "No runs found."))))
+            (with-open [r (io/reader latest)]
+              (let [entries (mapv #(json/parse-string % true) (line-seq r))
+                    by-status (group-by :status entries)]
+                (doseq [[status tasks] (sort-by first by-status)]
+                  (println (format "%s: %d" (name status) (count tasks))))
+                (println)
+                (println (format "Total: %d tasks" (count entries))))))
+          (println "No runs found."))))))
 
 (defn cmd-worktrees
   "List worktree status"
@@ -323,21 +415,43 @@
   "Check if agent backends are available"
   [opts args]
   (println "Checking agent backends...")
-  (doseq [agent-type [:codex :claude]]
-    (let [available? (agent/check-available agent-type)]
+  (doseq [harness-kw (sort (harness/known-harnesses))]
+    (let [available? (harness/check-available harness-kw)]
       (println (format "  %s: %s"
-                       (name agent-type)
+                       (name harness-kw)
                        (if available? "✓ available" "✗ not found"))))))
 
+(def ^:private reasoning-variants
+  #{"minimal" "low" "medium" "high" "max" "xhigh"})
+
 (defn- parse-model-string
   "Parse model string into {:harness :model :reasoning}.
-   Formats: 'harness:model', 'harness:model:reasoning', or just 'model'."
+
+   Supported formats:
+   - harness:model
+   - harness:model:reasoning (codex only)
+   - model (defaults harness to :codex)
+
+   Note: non-codex model identifiers may contain ':' (for example
+   openrouter/...:free). Those suffixes are preserved in :model."
   [s]
   (if (and s (str/includes? s ":"))
-    (let [parts (str/split s #":" 3)]
-      (case (count parts)
-        2 {:harness (keyword (first parts)) :model (second parts)}
-        3 {:harness (keyword (first parts)) :model (second parts) :reasoning (nth parts 2)}
+    (let [[harness-str rest*] (str/split s #":" 2)
+          harness (keyword harness-str)]
+      (if (contains? harnesses harness)
+        (if (= harness :codex)
+          ;; Codex may include a reasoning suffix at the end. Only treat the
+          ;; last segment as reasoning if it matches a known variant.
+          (if-let [idx (str/last-index-of rest* ":")]
+            (let [model* (subs rest* 0 idx)
+                  reasoning* (subs rest* (inc idx))]
+              (if (contains? reasoning-variants reasoning*)
+                {:harness harness :model model* :reasoning reasoning*}
+                {:harness harness :model rest*}))
+            {:harness harness :model rest*})
+          ;; Non-codex: preserve full model string (including any ':suffix').
+          {:harness harness :model rest*})
+        ;; Not a known harness prefix, treat as raw model on default harness.
         {:harness :codex :model s}))
     {:harness :codex :model s}))
 
@@ -354,14 +468,50 @@
       (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\": \"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.")
       (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)
-          review-model (some-> (:review_model config) parse-model-string)
+          ;; Parse reviewer config — supports both formats:
+          ;; Legacy: {"review_model": "harness:model:reasoning"}
+          ;; New:    {"reviewer": {"model": "harness:model:reasoning", "prompt": ["path.md"]}}
+          reviewer-config (:reviewer config)
+          review-parsed (cond
+                          reviewer-config
+                          (let [parsed (parse-model-string (:model reviewer-config))
+                                prompts (let [p (:prompt reviewer-config)]
+                                          (cond (vector? p) p
+                                                (string? p) [p]
+                                                :else []))]
+                            (assoc parsed :prompts prompts))
+
+                          (:review_model config)
+                          (parse-model-string (:review_model config))
+
+                          :else nil)
+
+          ;; Parse planner config — optional dedicated planner
+          ;; Runs in project root, no worktree/review/merge, respects max_pending backpressure
+          planner-config (:planner config)
+          planner-parsed (when planner-config
+                           (let [parsed (parse-model-string (:model planner-config))
+                                 prompts (let [p (:prompt planner-config)]
+                                           (cond (vector? p) p
+                                                 (string? p) [p]
+                                                 :else []))]
+                             (assoc parsed
+                                    :prompts prompts
+                                    :max-pending (or (:max_pending planner-config) 10))))
+
           worker-configs (:workers config)
 
           ;; Expand worker configs by count
@@ -383,14 +533,30 @@
                            :iterations (or (:iterations wc) 10)
                            :prompts (:prompt wc)
                            :can-plan (:can_plan wc)
-                           :review-harness (:harness review-model)
-                           :review-model (:model review-model)})))
+                           :wait-between (:wait_between wc)
+                           :max-working-resumes (:max_working_resumes wc)
+                           :review-harness (:harness review-parsed)
+                           :review-model (:model review-parsed)
+                           :review-prompts (:prompts review-parsed)})))
                     expanded-workers)]
 
       (println (format "Swarm config from %s:" config-file))
       (println (format "  Swarm ID: %s" swarm-id))
-      (when review-model
-        (println (format "  Review: %s:%s" (name (:harness review-model)) (:model review-model))))
+      (when planner-parsed
+        (println (format "  Planner: %s:%s (max_pending: %d%s)"
+                         (name (:harness planner-parsed))
+                         (:model planner-parsed)
+                         (:max-pending planner-parsed)
+                         (if (seq (:prompts planner-parsed))
+                           (str ", prompts: " (str/join ", " (:prompts planner-parsed)))
+                           ""))))
+      (when review-parsed
+        (println (format "  Reviewer: %s:%s%s"
+                         (name (:harness review-parsed))
+                         (:model review-parsed)
+                         (if (seq (:prompts review-parsed))
+                           (str " (prompts: " (str/join ", " (:prompts review-parsed)) ")")
+                           ""))))
       (println (format "  Workers: %d total" (count workers)))
       (doseq [[idx wc] (map-indexed vector worker-configs)]
         (let [{:keys [harness model reasoning]} (parse-model-string (:model wc))]
@@ -404,7 +570,27 @@
       (println)
 
       ;; Preflight: probe each unique model before launching workers
-      (validate-models! worker-configs review-model)
+      ;; Include planner model in validation if configured
+      (validate-models! (cond-> worker-configs
+                          planner-config (conj planner-config))
+                        review-parsed)
+
+      ;; Write started event to runs/{swarm-id}/started.json
+      (runs/write-started! swarm-id
+                           {:workers workers
+                            :planner-config planner-parsed
+                            :reviewer-config review-parsed
+                            :config-file config-file})
+      (println (format "\nStarted event written to runs/%s/started.json" swarm-id))
+
+      ;; Run planner if configured — synchronously before workers
+      (when planner-parsed
+        (println)
+        (println (format "  Planner: %s:%s (max_pending: %d)"
+                         (name (:harness planner-parsed))
+                         (:model planner-parsed)
+                         (:max-pending planner-parsed)))
+        (worker/run-planner! (assoc planner-parsed :swarm-id swarm-id)))
 
       ;; Run workers using new worker module
       (worker/run-workers! workers))))
@@ -428,6 +614,69 @@
       (doseq [t (tasks/list-current)]
         (println (format "  - %s: %s" (:id t) (:summary t)))))))
 
+(defn- find-latest-swarm-id
+  "Find the most recent swarm ID from runs/ directory."
+  []
+  (first (runs/list-runs)))
+
+(defn- read-swarm-pid
+  "Read PID from started.json for a swarm. Returns nil if not found."
+  [swarm-id]
+  (when-let [started (runs/read-started swarm-id)]
+    (:pid started)))
+
+(defn- pid-alive?
+  "Check if a process is alive via kill -0."
+  [pid]
+  (try
+    (zero? (:exit (process/sh ["kill" "-0" (str pid)]
+                              {:out :string :err :string})))
+    (catch Exception _ false)))
+
+(defn cmd-stop
+  "Send SIGTERM to running swarm — workers finish current cycle then exit"
+  [opts args]
+  (let [swarm-id (or (first args) (find-latest-swarm-id))]
+    (if-not swarm-id
+      (println "No swarm runs found.")
+      (let [stopped (runs/read-stopped swarm-id)]
+        (if stopped
+          (println (format "Swarm %s already stopped (reason: %s)" swarm-id (:reason stopped)))
+          (let [pid (read-swarm-pid swarm-id)]
+            (if-not pid
+              (println (format "No PID found for swarm %s" swarm-id))
+              (if-not (pid-alive? pid)
+                (do
+                  (println (format "Swarm %s PID %s is not running (stale). Writing stopped event." swarm-id pid))
+                  (runs/write-stopped! swarm-id :interrupted))
+                (do
+                  (println (format "Sending SIGTERM to swarm %s (PID %s)..." swarm-id pid))
+                  (println "Workers will finish their current cycle and exit.")
+                  (process/sh ["kill" (str pid)]))))))))))
+
+(defn cmd-kill
+  "Send SIGKILL to running swarm — immediate termination"
+  [opts args]
+  (let [swarm-id (or (first args) (find-latest-swarm-id))]
+    (if-not swarm-id
+      (println "No swarm runs found.")
+      (let [stopped (runs/read-stopped swarm-id)]
+        (if stopped
+          (println (format "Swarm %s already stopped (reason: %s)" swarm-id (:reason stopped)))
+          (let [pid (read-swarm-pid swarm-id)]
+            (if-not pid
+              (println (format "No PID found for swarm %s" swarm-id))
+              (if-not (pid-alive? pid)
+                (do
+                  (println (format "Swarm %s PID %s is not running (stale). Writing stopped event." swarm-id pid))
+                  (runs/write-stopped! swarm-id :interrupted))
+                (do
+                  (println (format "Sending SIGKILL to swarm %s (PID %s)..." swarm-id pid))
+                  ;; SIGKILL bypasses JVM shutdown hooks, so write stopped.json here
+                  (process/sh ["kill" "-9" (str pid)])
+                  (runs/write-stopped! swarm-id :interrupted)
+                  (println "Swarm killed."))))))))))
+
 (defn cmd-help
   "Print usage information"
   [opts args]
@@ -443,6 +692,8 @@
   (println "  prompt \"...\"     Run ad-hoc prompt")
   (println "  status           Show last run summary")
   (println "  worktrees        List worktree status")
+  (println "  stop [swarm-id]  Stop swarm gracefully (finish current cycle)")
+  (println "  kill [swarm-id]  Kill swarm immediately (SIGKILL)")
   (println "  cleanup          Remove all worktrees")
   (println "  context          Print context block")
   (println "  check            Check agent backends")
@@ -450,16 +701,16 @@
   (println)
   (println "Options:")
   (println "  --workers N              Number of parallel workers (default: 2)")
-  (println "  --workers H:N [H:N ...]  Mixed workers by harness (e.g., claude:5 codex:4)")
+  (println "  --workers H:N [H:N ...]  Mixed workers by harness (e.g., claude:5 opencode:2)")
   (println "  --iterations N           Number of iterations per worker (default: 1)")
-  (println "  --harness {codex,claude} Agent harness to use (default: codex)")
-  (println "  --model MODEL            Model to use (e.g., codex-5.2, opus-4.5)")
+  (println (str "  --harness {" (str/join "," (map name (sort harnesses))) "} Agent harness to use (default: codex)"))
+  (println "  --model MODEL            Model to use (e.g., codex:gpt-5.3-codex:medium, claude:opus, gemini:gemini-3-pro-preview)")
   (println "  --dry-run                Skip actual merges")
   (println "  --keep-worktrees         Don't cleanup worktrees after run")
   (println)
   (println "Examples:")
   (println "  ./swarm.bb loop 10 --harness codex --model gpt-5.3-codex --workers 3")
-  (println "  ./swarm.bb loop --workers claude:5 codex:4 --iterations 20")
+  (println "  ./swarm.bb loop --workers claude:5 opencode:2 --iterations 20")
   (println "  ./swarm.bb swarm oompa.json  # Run multi-model config"))
 
 ;; =============================================================================
@@ -473,6 +724,8 @@
    "tasks" cmd-tasks
    "prompt" cmd-prompt
    "status" cmd-status
+   "stop" cmd-stop
+   "kill" cmd-kill
    "worktrees" cmd-worktrees
    "cleanup" cmd-cleanup
    "context" cmd-context