todo -> task

Author: ericdallo

CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ## Unreleased
 
-- Add Todo tool #246
+- Add Task tool #246
 
 ## 0.109.5
 

resources/prompts/code_agent.md

@@ -28,18 +28,18 @@ You have tools at your disposal to solve the coding task. Follow these rules reg
 3. If you are not sure about file content or codebase structure pertaining to the user's request, use your tools to read files and gather the relevant information: do NOT guess or make up an answer.
 4. You have the capability to call multiple tools in a single response, batch your tool calls together for optimal performance.
 
-{% if toolEnabled_eca__todo %}
-## TODO Tool
+{% if toolEnabled_eca__task %}
+## Task Tool
 
-You have access to a `eca__todo` tool for tracking multi-step work within this chat.
+You have access to a `eca__task` tool for tracking multi-step work within this chat.
 
 ### Workflow:
-1. Use `plan` to create TODO with initial tasks
+1. Use `plan` to create task list with initial tasks
 2. Use `start` before working on a task (marks it as in_progress and requires an `active_summary`)
 3. Use `complete` only for tasks that are actually finished; for each targeted task, verify its acceptance criteria first.
 4. Use `add` if you discover additional work
 5. When a plan is fully completed and no further work is needed, always use the `clear` operation to clean up the workspace.
-6. When helpful, delegate focused work to subagents. You MAY start multiple independent tasks in parallel (keep the number of in_progress tasks small), then update/complete the TODO based on subagent outputs. Prefer that only the main agent updates the TODO; subagents should focus on producing outputs.
+6. When helpful, delegate focused work to subagents. You MAY start multiple independent tasks in parallel (keep the number of in_progress tasks small), then update/complete the task list based on subagent outputs. Prefer that only the main agent updates the task list; subagents should focus on producing outputs.
 
 ### Task tracking guidance:
 - Make sure to add acceptance criteria inside your task `description`.

resources/prompts/tools/todo.md resources/prompts/tools/task.mdresources/prompts/tools/todo.md renamed to resources/prompts/tools/task.md

@@ -12,17 +12,17 @@ When NOT to Use:
 - Quick fixes where tracking adds no organizational value
 
 Operations:
-- read: View current TODO state
-- plan: Create/replace TODO with initial tasks (required: tasks)
-- add: Append task(s) to existing TODO
+- read: View current task list state
+- plan: Create/replace task list with initial tasks (required: tasks)
+- add: Append task(s) to existing task list
 - update: Modify a single task metadata by `id` (subject, description, priority, blocked_by) — cannot change status
 - start: Begin work on tasks by `ids` (sets to in_progress; rejects blocked or done tasks). Requires `active_summary` to summarize what you are about to do.
 - complete: Mark tasks by `ids` as done (verify acceptance criteria in description first)
 - delete: Remove tasks by `ids`
-- clear: Reset entire TODO (removes all tasks)
+- clear: Reset entire task list (removes all tasks)
 
 Workflow:
-1. Use 'plan' to create TODO with initial tasks
+1. Use 'plan' to create task list with initial tasks
 2. Use 'start' before working on a task — marks it as in_progress and requires an `active_summary`
 3. Work sequentially by default. Batch 'start' or 'complete' operations (using multiple 'ids') ONLY for independent tasks being executed simultaneously (e.g., via subagents).
 4. Use 'complete' only for tasks that are actually finished; verify acceptance criteria first — the response tells you which tasks got unblocked

src/eca/config.clj

@@ -112,7 +112,7 @@
                                                  "eca__grep" {}
                                                  "eca__editor_diagnostics" {}
                                                  "eca__skill" {}
-                                                 "eca__todo" {}
+                                                 "eca__task" {}
                                                  "eca__spawn_agent" {}}
                                          :deny {"eca__shell_command"
                                                 {:argsMatchers {"command" dangerous-commands-regexes}}}}}}
@@ -134,7 +134,7 @@
                                                      "eca__grep" {}
                                                      "eca__editor_diagnostics" {}
                                                      "eca__skill" {}
-                                                     "eca__todo" {}}
+                                                     "eca__task" {}}
                                              :deny {"eca__shell_command"
                                                     {:argsMatchers {"command" dangerous-commands-regexes}}}}}}
            "general" {:mode "subagent"
@@ -162,7 +162,7 @@
                                  "eca__grep" {}
                                  "eca__editor_diagnostics" {}
                                  "eca__skill" {}
-                                 "eca__todo" {}
+                                 "eca__task" {}
                                  "eca__spawn_agent" {}}
                          :ask {}
                          :deny {}}

src/eca/db.clj

@@ -60,7 +60,7 @@
                         :messages [{:role (or "user" "assistant" "tool_call" "tool_call_output" "reason")
                                     :content (or :string [::any-map]) ;; string for simple text, map/vector for structured content
                                     :content-id :string}]
-                        :todo {:next-id :number
+                        :task {:next-id :number
                                :active-summary (or :string nil)
                                :tasks [{:id :number
                                         :subject :string

src/eca/features/tools.clj

@@ -13,7 +13,7 @@
    [eca.features.tools.mcp.clojure-mcp]
    [eca.features.tools.shell :as f.tools.shell]
    [eca.features.tools.skill :as f.tools.skill]
-   [eca.features.tools.todo :as f.tools.todo]
+   [eca.features.tools.task :as f.tools.task]
    [eca.features.tools.util :as tools.util]
    [eca.logger :as logger]
    [eca.messenger :as messenger]
@@ -149,7 +149,7 @@
           f.tools.editor/definitions
           f.tools.chat/definitions
           f.tools.skill/definitions
-          f.tools.todo/definitions
+          f.tools.task/definitions
           (f.tools.agent/definitions config)
           (f.tools.custom/definitions config))))
 
@@ -160,9 +160,9 @@
   "Filter tools for subagent execution.
 
    - Excludes spawn_agent to prevent nesting.
-   - Excludes todo because TODO state is currently chat-local; it should be managed by the parent agent."
+   - Excludes task because task list state is currently chat-local; it should be managed by the parent agent."
   [tools]
-  (filterv #(not (contains? #{"spawn_agent" "todo"} (:name %))) tools))
+  (filterv #(not (contains? #{"spawn_agent" "task"} (:name %))) tools))
 
 (defn all-tools
   "Returns all available tools, including both native ECA tools

src/eca/features/tools/todo.clj src/eca/features/tools/task.cljsrc/eca/features/tools/todo.clj renamed to src/eca/features/tools/task.clj

@@ -1,4 +1,4 @@
-(ns eca.features.tools.todo
+(ns eca.features.tools.task
   (:require
    [clojure.string :as str]
    [eca.features.tools.util :as tools.util]))
@@ -7,7 +7,7 @@
 
 ;; --- Helpers ---
 
-(def ^:private empty-todo {:next-id 1 :active-summary nil :tasks []})
+(def ^:private empty-task {:next-id 1 :active-summary nil :tasks []})
 (def ^:private valid-priorities #{:high :medium :low})
 
 (defn ^:private error [msg]
@@ -32,23 +32,23 @@
 
 ;; --- State management ---
 
-(defn get-todo
-  "Get TODO state for the chat."
+(defn get-task
+  "Get task list state for the chat."
   [db chat-id]
-  (get-in db [:chats chat-id :todo] empty-todo))
+  (get-in db [:chats chat-id :task] empty-task))
 
-(defn ^:private mutate-todo!
-  "Atomically update TODO for a chat via compare-and-set loop.
+(defn ^:private mutate-task!
+  "Atomically update task list for a chat via compare-and-set loop.
    `mutate-fn` receives current state, returns {:state ...} or {:error true ...}.
    Extra keys in the result map are preserved."
   [db* chat-id mutate-fn]
   (loop []
     (let [db @db*
-          state (get-todo db chat-id)
+          state (get-task db chat-id)
           result (mutate-fn state)]
       (if (:error result)
         result
-        (let [new-db (assoc-in db [:chats chat-id :todo] (:state result))]
+        (let [new-db (assoc-in db [:chats chat-id :task] (:state result))]
           (if (compare-and-set! db* db new-db)
             result
             (recur)))))))
@@ -226,13 +226,13 @@
            (str/join "\n" (map read-task-line-full tasks))
            "(none)"))))
 
-(defn ^:private todo-details
+(defn ^:private task-details
   "Structured data for client rendering."
   [state]
   (let [{:keys [tasks active-summary]} state
         tasks-by-id (task-index tasks)
         {:keys [done in-progress pending]} (status-counts tasks)]
-    (cond-> {:type :todo
+    (cond-> {:type :task
              :in-progress-task-ids (mapv :id (filter #(= :in-progress (:status %)) tasks))
              :tasks (mapv (fn [{:keys [id subject description status priority blocked-by]}]
                             (cond-> {:id id
@@ -247,40 +247,40 @@
       active-summary (assoc :active-summary active-summary))))
 
 (defn ^:private success [state text]
-  (assoc (tools.util/single-text-content text) :details (todo-details state)))
+  (assoc (tools.util/single-text-content text) :details (task-details state)))
 
 (defn ^:private format-tasks-list [tasks]
   (str/join "\n" (map read-task-line-short tasks)))
 
-(defmethod tools.util/tool-call-details-after-invocation :todo
+(defmethod tools.util/tool-call-details-after-invocation :task
   [_name _arguments before-details result _ctx]
   (or (:details result) before-details))
 
 ;; --- Operations ---
 
 (defn ^:private op-read [_arguments {:keys [db chat-id]}]
-  (let [state (get-todo db chat-id)]
+  (let [state (get-task db chat-id)]
     (success state (read-text state))))
 
 (defn ^:private op-plan [{:strs [tasks]} {:keys [db* chat-id]}]
   (or (when-not (and (sequential? tasks) (seq tasks))
         (error "plan requires 'tasks' (non-empty array)"))
-      (let [result (mutate-todo! db* chat-id
+      (let [result (mutate-task! db* chat-id
                                  (fn [_state]
-                                   (let [built (build-tasks empty-todo tasks)]
+                                   (let [built (build-tasks empty-task tasks)]
                                      (if (:error built)
                                        built
                                        (or (detect-cycle (:tasks built))
-                                           {:state (assoc empty-todo
+                                           {:state (assoc empty-task
                                                           :tasks (:tasks built)
                                                           :next-id (inc (count (:tasks built))))})))))]
         (if (:error result)
           result
           (success (:state result)
-                   (str "TODO created with " (count (get-in result [:state :tasks])) " tasks"))))))
+                   (str "Task list created with " (count (get-in result [:state :tasks])) " tasks"))))))
 
 (defn ^:private op-add [{:strs [tasks task] :as _arguments} {:keys [db* chat-id]}]
-  (let [result (mutate-todo! db* chat-id
+  (let [result (mutate-task! db* chat-id
                              (fn [state]
                                (cond
                                  tasks
@@ -317,7 +317,7 @@
 (def ^:private updatable-keys #{"subject" "description" "priority" "blocked_by"})
 
 (defn ^:private op-update [{:strs [id task]} {:keys [db* chat-id]}]
-  (let [result (mutate-todo! db* chat-id
+  (let [result (mutate-task! db* chat-id
                              (fn [state]
                                (let [[id err] (resolve-id state id)]
                                  (or err
@@ -372,7 +372,7 @@
 
 (defn ^:private op-start [{:strs [ids active_summary]} {:keys [db* chat-id]}]
   (or (require-nonblank "active_summary" active_summary)
-      (let [result (mutate-todo! db* chat-id
+      (let [result (mutate-task! db* chat-id
                                  (fn [state]
                                    (let [tasks-by-id (task-index (:tasks state))
                                          [ids err] (resolve-ids state ids)]
@@ -406,7 +406,7 @@
     state))
 
 (defn ^:private op-complete [{:strs [ids]} {:keys [db* chat-id]}]
-  (let [result (mutate-todo! db* chat-id
+  (let [result (mutate-task! db* chat-id
                              (fn [state]
                                (let [tasks-by-id (task-index (:tasks state))
                                      [ids err] (resolve-ids state ids)]
@@ -444,7 +444,7 @@
                         (format "\nUnblocked: %s" (str/join ", " unblocked)))))))))
 
 (defn ^:private op-delete [{:strs [ids]} {:keys [db* chat-id]}]
-  (let [result (mutate-todo! db* chat-id
+  (let [result (mutate-task! db* chat-id
                              (fn [state]
                                (let [[ids err] (resolve-ids state ids)]
                                  (or err
@@ -465,10 +465,10 @@
                        (format-tasks-list (:deleted result)))))))
 
 (defn ^:private op-clear [_arguments {:keys [db* chat-id]}]
-  (let [result (mutate-todo! db* chat-id (fn [_] {:state empty-todo}))]
+  (let [result (mutate-task! db* chat-id (fn [_] {:state empty-task}))]
     (if (:error result)
       result
-      (success (:state result) "TODO cleared"))))
+      (success (:state result) "Task list cleared"))))
 
 ;; --- Dispatch ---
 
@@ -482,16 +482,16 @@
    "delete" op-delete
    "clear" op-clear})
 
-(defn ^:private execute-todo [arguments ctx]
+(defn ^:private execute-task [arguments ctx]
   (let [op (get arguments "op")
         handler (get ops op)]
     (if handler
       (handler arguments ctx)
       (error (str "Unknown operation: " op)))))
 
 (def definitions
-  {"todo"
-   {:description (tools.util/read-tool-description "todo")
+  {"task"
+   {:description (tools.util/read-tool-description "task")
     :parameters {:type "object"
                  :properties {:op {:type "string"
                                    :enum ["read" "plan" "add" "update" "start" "complete" "delete" "clear"]
@@ -520,4 +520,4 @@
                                                            :blocked_by {:type "array" :items {:type "integer"}}}
                                               :required ["subject" "description"]}}}
                  :required ["op"]}
-    :handler execute-todo}})
+    :handler execute-task}})