agentf 0.3.0 → 0.4.0

data/lib/agentf/memory.rb

@@ -10,6 +10,8 @@ module Agentf
   module Memory
     # Redis-backed memory system for agent learning
     class RedisMemory
+      EDGE_INDEX = "edge:links"
+
       attr_reader :project
 
       def initialize(redis_url: nil, project: nil)
@@ -21,7 +23,7 @@ module Agentf
         ensure_indexes if @search_supported
       end
 
-      def store_task(content:, embedding: [], language: nil, task_type: nil, success: true, agent: "ARCHITECT")
+      def store_task(content:, embedding: [], language: nil, task_type: nil, success: true, agent: Agentf::AgentRoles::PLANNER)
         task_id = "task_#{SecureRandom.hex(4)}"
 
         data = {
@@ -42,9 +44,19 @@ module Agentf
         task_id
       end
 
-      def store_episode(type:, title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST", related_task_id: nil,
-                        metadata: {})
+      def store_episode(type:, title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER,
+                        related_task_id: nil, metadata: {}, entity_ids: [], relationships: [], parent_episode_id: nil, causal_from: nil)
         episode_id = "episode_#{SecureRandom.hex(4)}"
+        normalized_metadata = enrich_metadata(
+          metadata: metadata,
+          agent: agent,
+          type: type,
+          tags: tags,
+          entity_ids: entity_ids,
+          relationships: relationships,
+          parent_episode_id: parent_episode_id,
+          causal_from: causal_from
+        )
 
         data = {
           "id" => episode_id,
@@ -58,7 +70,11 @@ module Agentf
           "created_at" => Time.now.to_i,
           "agent" => agent,
           "related_task_id" => related_task_id || "",
-          "metadata" => metadata
+          "entity_ids" => entity_ids,
+          "relationships" => relationships,
+          "parent_episode_id" => parent_episode_id.to_s,
+          "causal_from" => causal_from.to_s,
+          "metadata" => normalized_metadata
         }
 
         key = "episodic:#{episode_id}"
@@ -79,10 +95,19 @@ module Agentf
           @client.set(key, payload)
         end
 
+        persist_relationship_edges(
+          episode_id: episode_id,
+          related_task_id: related_task_id,
+          relationships: relationships,
+          metadata: normalized_metadata,
+          tags: tags,
+          agent: agent
+        )
+
         episode_id
       end
 
-      def store_success(title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST")
+      def store_success(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
         store_episode(
           type: "success",
           title: title,
@@ -94,7 +119,7 @@ module Agentf
         )
       end
 
-      def store_pitfall(title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST")
+      def store_pitfall(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
         store_episode(
           type: "pitfall",
           title: title,
@@ -106,7 +131,7 @@ module Agentf
         )
       end
 
-      def store_lesson(title:, description:, context: "", code_snippet: "", tags: [], agent: "SPECIALIST")
+      def store_lesson(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
         store_episode(
           type: "lesson",
           title: title,
@@ -118,7 +143,7 @@ module Agentf
         )
       end
 
-      def store_business_intent(title:, description:, constraints: [], tags: [], agent: "WORKFLOW_ENGINE", priority: 1)
+      def store_business_intent(title:, description:, constraints: [], tags: [], agent: Agentf::AgentRoles::ORCHESTRATOR, priority: 1)
         context = constraints.any? ? "Constraints: #{constraints.join('; ')}" : ""
 
         store_episode(
@@ -136,7 +161,8 @@ module Agentf
         )
       end
 
-      def store_feature_intent(title:, description:, acceptance_criteria: [], non_goals: [], tags: [], agent: "ARCHITECT", related_task_id: nil)
+      def store_feature_intent(title:, description:, acceptance_criteria: [], non_goals: [], tags: [], agent: Agentf::AgentRoles::PLANNER,
+                               related_task_id: nil)
         context_parts = []
         context_parts << "Acceptance: #{acceptance_criteria.join('; ')}" if acceptance_criteria.any?
         context_parts << "Non-goals: #{non_goals.join('; ')}" if non_goals.any?
@@ -157,7 +183,8 @@ module Agentf
         )
       end
 
-      def store_incident(title:, description:, root_cause: "", resolution: "", tags: [], agent: "DEBUGGER", business_capability: nil)
+      def store_incident(title:, description:, root_cause: "", resolution: "", tags: [], agent: Agentf::AgentRoles::INCIDENT_RESPONDER,
+                         business_capability: nil)
         store_episode(
           type: "incident",
           title: title,
@@ -174,7 +201,7 @@ module Agentf
         )
       end
 
-      def store_playbook(title:, description:, steps: [], tags: [], agent: "ARCHITECT", feature_area: nil)
+      def store_playbook(title:, description:, steps: [], tags: [], agent: Agentf::AgentRoles::PLANNER, feature_area: nil)
         store_episode(
           type: "playbook",
           title: title,
@@ -226,7 +253,7 @@ module Agentf
           query = "@type:#{type} @project:{#{@project}}"
           search_episodic(query: query, limit: limit)
         else
-          fetch_memories_without_search(limit: [limit * 4, 100].min).select { |mem| mem["type"] == type }.first(limit)
+          fetch_memories_without_search(limit: 100).select { |mem| mem["type"] == type }.first(limit)
         end
       end
 
@@ -285,6 +312,50 @@ module Agentf
         all_tags.to_a
       end
 
+      def store_edge(source_id:, target_id:, relation:, weight: 1.0, tags: [], agent: Agentf::AgentRoles::ORCHESTRATOR, metadata: {})
+        edge_id = "edge_#{SecureRandom.hex(5)}"
+        data = {
+          "id" => edge_id,
+          "source_id" => source_id,
+          "target_id" => target_id,
+          "relation" => relation,
+          "weight" => weight.to_f,
+          "tags" => tags,
+          "project" => @project,
+          "agent" => agent,
+          "metadata" => metadata,
+          "created_at" => Time.now.to_i
+        }
+
+        key = "edge:#{edge_id}"
+        payload = JSON.generate(data)
+
+        if @json_supported
+          begin
+            @client.call("JSON.SET", key, ".", payload)
+          rescue Redis::CommandError => e
+            if missing_json_module?(e)
+              @json_supported = false
+              @client.set(key, payload)
+            else
+              raise
+            end
+          end
+        else
+          @client.set(key, payload)
+        end
+
+        edge_id
+      end
+
+      def neighbors(node_id:, relation: nil, depth: 1, limit: 50)
+        traverse_edges(seed_ids: [node_id], relation_filters: relation ? [relation] : nil, depth: depth, limit: limit)
+      end
+
+      def subgraph(seed_ids:, depth: 2, relation_filters: nil, limit: 200)
+        traverse_edges(seed_ids: seed_ids, relation_filters: relation_filters, depth: depth, limit: limit)
+      end
+
       def close
         @client.close
       end
@@ -295,8 +366,9 @@ module Agentf
         return unless @search_supported
 
         create_episodic_index
+        create_edge_index
       rescue Redis::CommandError => e
-        raise Redis::CommandError, "Failed to create episodic index: #{e.message}. Ensure Redis Stack with RediSearch is available." unless index_already_exists?(e)
+        raise Redis::CommandError, "Failed to create indexes: #{e.message}. Ensure Redis Stack with RediSearch is available." unless index_already_exists?(e)
       end
 
       def create_episodic_index
@@ -320,7 +392,31 @@ module Agentf
           "$.metadata.priority", "AS", "priority", "NUMERIC",
           "$.metadata.confidence", "AS", "confidence", "NUMERIC",
           "$.metadata.business_capability", "AS", "business_capability", "TAG",
-          "$.metadata.feature_area", "AS", "feature_area", "TAG"
+          "$.metadata.feature_area", "AS", "feature_area", "TAG",
+          "$.metadata.agent_role", "AS", "agent_role", "TAG",
+          "$.metadata.division", "AS", "division", "TAG",
+          "$.metadata.specialty", "AS", "specialty", "TAG",
+          "$.entity_ids[*]", "AS", "entity_ids", "TAG",
+          "$.parent_episode_id", "AS", "parent_episode_id", "TEXT",
+          "$.causal_from", "AS", "causal_from", "TEXT"
+        )
+      end
+
+      def create_edge_index
+        @client.call(
+          "FT.CREATE", EDGE_INDEX,
+          "ON", "JSON",
+          "PREFIX", "1", "edge:",
+          "SCHEMA",
+          "$.id", "AS", "id", "TEXT",
+          "$.source_id", "AS", "source_id", "TAG",
+          "$.target_id", "AS", "target_id", "TAG",
+          "$.relation", "AS", "relation", "TAG",
+          "$.project", "AS", "project", "TAG",
+          "$.agent", "AS", "agent", "TAG",
+          "$.weight", "AS", "weight", "NUMERIC",
+          "$.created_at", "AS", "created_at", "NUMERIC",
+          "$.tags", "AS", "tags", "TAG"
         )
       end
 
@@ -432,15 +528,15 @@ module Agentf
 
       def context_profile(agent)
         case agent.to_s.upcase
-        when "ARCHITECT"
+        when Agentf::AgentRoles::PLANNER
           { "preferred_types" => %w[business_intent feature_intent lesson playbook pitfall], "pitfall_penalty" => 0.1 }
-        when "SPECIALIST"
+        when Agentf::AgentRoles::ENGINEER
           { "preferred_types" => %w[playbook success lesson pitfall], "pitfall_penalty" => 0.05 }
-        when "TESTER"
+        when Agentf::AgentRoles::QA_TESTER
           { "preferred_types" => %w[lesson pitfall incident success], "pitfall_penalty" => 0.0 }
-        when "DEBUGGER"
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
           { "preferred_types" => %w[incident pitfall lesson], "pitfall_penalty" => 0.0 }
-        when "SECURITY"
+        when Agentf::AgentRoles::SECURITY_REVIEWER
           { "preferred_types" => %w[pitfall lesson incident], "pitfall_penalty" => 0.0 }
         else
           { "preferred_types" => %w[lesson pitfall success business_intent feature_intent], "pitfall_penalty" => 0.05 }
@@ -461,7 +557,7 @@ module Agentf
             confidence = 1.0 if confidence > 1.0
 
             type_score = preferred_types.include?(type) ? 1.0 : 0.25
-            agent_score = (memory["agent"] == agent || memory["agent"] == "WORKFLOW_ENGINE") ? 1.0 : 0.2
+            agent_score = (memory["agent"] == agent || memory["agent"] == Agentf::AgentRoles::ORCHESTRATOR) ? 1.0 : 0.2
             age_seconds = [now - memory.fetch("created_at", now).to_i, 0].max
             recency_score = 1.0 / (1.0 + (age_seconds / 86_400.0))
 
@@ -520,6 +616,235 @@ module Agentf
       def client_options
         { url: @redis_url }
       end
+
+      def persist_relationship_edges(episode_id:, related_task_id:, relationships:, metadata:, tags:, agent:)
+        if related_task_id && !related_task_id.to_s.strip.empty?
+          store_edge(source_id: episode_id, target_id: related_task_id, relation: "relates_to", tags: tags, agent: agent)
+        end
+
+        Array(relationships).each do |relation|
+          next unless relation.is_a?(Hash)
+
+          target = relation["to"] || relation[:to]
+          relation_type = relation["type"] || relation[:type] || "related"
+          next if target.to_s.strip.empty?
+
+          store_edge(
+            source_id: episode_id,
+            target_id: target,
+            relation: relation_type,
+            weight: (relation["weight"] || relation[:weight] || 1.0).to_f,
+            tags: tags,
+            agent: agent,
+            metadata: { "source_metadata" => extract_metadata_slice(metadata, %w[intent_kind agent_role division]) }
+          )
+        end
+
+        parent = metadata["parent_episode_id"].to_s
+        unless parent.empty?
+          store_edge(source_id: episode_id, target_id: parent, relation: "child_of", tags: tags, agent: agent)
+        end
+
+        causal_from = metadata["causal_from"].to_s
+        unless causal_from.empty?
+          store_edge(source_id: episode_id, target_id: causal_from, relation: "caused_by", tags: tags, agent: agent)
+        end
+      rescue StandardError
+        nil
+      end
+
+      def enrich_metadata(metadata:, agent:, type:, tags:, entity_ids:, relationships:, parent_episode_id:, causal_from:)
+        base = metadata.is_a?(Hash) ? metadata.dup : {}
+        base["agent_role"] = agent
+        base["division"] = infer_division(agent)
+        base["specialty"] = infer_specialty(agent)
+        base["capabilities"] = infer_capabilities(agent)
+        base["episode_type"] = type
+        base["tag_count"] = Array(tags).length
+        base["relationship_count"] = Array(relationships).length
+        base["entity_ids"] = Array(entity_ids)
+        base["parent_episode_id"] = parent_episode_id.to_s unless parent_episode_id.to_s.empty?
+        base["causal_from"] = causal_from.to_s unless causal_from.to_s.empty?
+        base
+      end
+
+      def infer_division(agent)
+        case agent
+        when Agentf::AgentRoles::PLANNER, Agentf::AgentRoles::ORCHESTRATOR, Agentf::AgentRoles::KNOWLEDGE_MANAGER
+          "strategy"
+        when Agentf::AgentRoles::ENGINEER, Agentf::AgentRoles::RESEARCHER, Agentf::AgentRoles::UI_ENGINEER
+          "engineering"
+        when Agentf::AgentRoles::QA_TESTER, Agentf::AgentRoles::REVIEWER, Agentf::AgentRoles::SECURITY_REVIEWER
+          "quality"
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
+          "operations"
+        else
+          "general"
+        end
+      end
+
+      def infer_specialty(agent)
+        case agent
+        when Agentf::AgentRoles::PLANNER
+          "planning"
+        when Agentf::AgentRoles::ENGINEER
+          "implementation"
+        when Agentf::AgentRoles::RESEARCHER
+          "discovery"
+        when Agentf::AgentRoles::QA_TESTER
+          "testing"
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
+          "debugging"
+        when Agentf::AgentRoles::UI_ENGINEER
+          "design-implementation"
+        when Agentf::AgentRoles::SECURITY_REVIEWER
+          "security"
+        when Agentf::AgentRoles::KNOWLEDGE_MANAGER
+          "documentation"
+        when Agentf::AgentRoles::REVIEWER
+          "review"
+        when Agentf::AgentRoles::ORCHESTRATOR
+          "orchestration"
+        else
+          "general"
+        end
+      end
+
+      def infer_capabilities(agent)
+        case agent
+        when Agentf::AgentRoles::PLANNER
+          %w[decompose prioritize plan]
+        when Agentf::AgentRoles::ENGINEER
+          %w[implement execute modify]
+        when Agentf::AgentRoles::RESEARCHER
+          %w[search map discover]
+        when Agentf::AgentRoles::QA_TESTER
+          %w[test validate report]
+        when Agentf::AgentRoles::INCIDENT_RESPONDER
+          %w[triage diagnose remediate]
+        when Agentf::AgentRoles::UI_ENGINEER
+          %w[design implement-ui validate-ui]
+        when Agentf::AgentRoles::SECURITY_REVIEWER
+          %w[scan assess harden]
+        when Agentf::AgentRoles::KNOWLEDGE_MANAGER
+          %w[summarize document synthesize]
+        when Agentf::AgentRoles::REVIEWER
+          %w[review approve reject]
+        else
+          %w[coordinate]
+        end
+      end
+
+      def traverse_edges(seed_ids:, relation_filters:, depth:, limit:)
+        current = Array(seed_ids).compact.map(&:to_s).reject(&:empty?).uniq
+        visited_nodes = Set.new(current)
+        visited_edges = Set.new
+        layers = []
+        edges = []
+
+        depth.to_i.times do |hop|
+          break if current.empty?
+
+          next_nodes = []
+          layer_edges = []
+          current.each do |node_id|
+            fetch_edges_for(node_id: node_id, relation_filters: relation_filters, limit: limit).each do |edge|
+              edge_id = edge["id"].to_s
+              next if edge_id.empty? || visited_edges.include?(edge_id)
+
+              visited_edges << edge_id
+              layer_edges << edge
+              target = edge["target_id"].to_s
+              next if target.empty? || visited_nodes.include?(target)
+
+              visited_nodes << target
+              next_nodes << target
+            end
+          end
+          layers << { "depth" => hop + 1, "count" => layer_edges.length }
+          edges.concat(layer_edges)
+          current = next_nodes.uniq
+          break if edges.length >= limit
+        end
+
+        {
+          "seed_ids" => seed_ids,
+          "nodes" => visited_nodes.to_a,
+          "edges" => edges.first(limit),
+          "layers" => layers,
+          "count" => [edges.length, limit].min
+        }
+      end
+
+      def fetch_edges_for(node_id:, relation_filters:, limit:)
+        if @search_supported
+          query = ["@source_id:{#{escape_tag(node_id)}}", "@project:{#{escape_tag(@project)}}"]
+          if relation_filters && relation_filters.any?
+            relations = relation_filters.map { |item| escape_tag(item.to_s) }.join("|")
+            query << "@relation:{#{relations}}"
+          end
+          search_json_index(index: EDGE_INDEX, query: query.join(" "), limit: limit)
+        else
+          fetch_edges_without_search(node_id: node_id, relation_filters: relation_filters, limit: limit)
+        end
+      end
+
+      def search_json_index(index:, query:, limit:)
+        results = @client.call(
+          "FT.SEARCH", index,
+          query,
+          "SORTBY", "created_at", "DESC",
+          "LIMIT", "0", limit.to_s
+        )
+        return [] unless results && results[0] > 0
+
+        records = []
+        (2...results.length).step(2) do |i|
+          item = results[i]
+          next unless item.is_a?(Array)
+
+          item.each_with_index do |part, j|
+            next unless part == "$" && j + 1 < item.length
+
+            begin
+              records << JSON.parse(item[j + 1])
+            rescue JSON::ParserError
+              nil
+            end
+          end
+        end
+        records
+      end
+
+      def fetch_edges_without_search(node_id:, relation_filters:, limit:)
+        edges = []
+        cursor = "0"
+        loop do
+          cursor, batch = @client.scan(cursor, match: "edge:*", count: 100)
+          batch.each do |key|
+            edge = load_episode(key)
+            next unless edge.is_a?(Hash)
+            next unless edge["source_id"].to_s == node_id.to_s
+            next unless edge["project"].to_s == @project.to_s
+            next if relation_filters && relation_filters.any? && !relation_filters.include?(edge["relation"])
+
+            edges << edge
+            return edges.first(limit) if edges.length >= limit
+          end
+          break if cursor == "0"
+        end
+        edges
+      end
+
+      def escape_tag(value)
+        value.to_s.gsub(/[\-{}\[\]|\\]/) { |m| "\\#{m}" }
+      end
+
+      def extract_metadata_slice(metadata, keys)
+        keys.each_with_object({}) do |key, acc|
+          acc[key] = metadata[key] if metadata.key?(key)
+        end
+      end
     end
 
     # Convenience method

data/lib/agentf/packs.rb

@@ -14,11 +14,11 @@ module Agentf
         "description" => "Thin models/controllers with services, queries, presenters, and policy reviews.",
         "keywords" => %w[rails activerecord rspec pundit viewcomponent hotwire turbo stimulus],
         "workflow_templates" => {
-          "feature" => %w[ARCHITECT EXPLORER SPECIALIST TESTER SECURITY REVIEWER DOCUMENTER],
-          "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER SECURITY REVIEWER],
-          "refactor" => %w[ARCHITECT EXPLORER SPECIALIST TESTER REVIEWER],
-          "quick_fix" => %w[SPECIALIST TESTER REVIEWER],
-          "exploration" => %w[EXPLORER]
+          "feature" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER KNOWLEDGE_MANAGER],
+          "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER],
+          "refactor" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER REVIEWER],
+          "quick_fix" => %w[ENGINEER QA_TESTER REVIEWER],
+          "exploration" => %w[RESEARCHER]
         }
       },
       "rails_37signals" => {
@@ -26,11 +26,11 @@ module Agentf
         "description" => "Resource-centric workflows favoring concerns, CRUD and model-rich patterns.",
         "keywords" => %w[rails concern crud closure model minitest hotwire],
         "workflow_templates" => {
-          "feature" => %w[ARCHITECT EXPLORER SPECIALIST TESTER REVIEWER DOCUMENTER],
-          "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER REVIEWER],
-          "refactor" => %w[ARCHITECT SPECIALIST TESTER REVIEWER],
-          "quick_fix" => %w[SPECIALIST REVIEWER],
-          "exploration" => %w[EXPLORER]
+          "feature" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER REVIEWER KNOWLEDGE_MANAGER],
+          "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER REVIEWER],
+          "refactor" => %w[PLANNER ENGINEER QA_TESTER REVIEWER],
+          "quick_fix" => %w[ENGINEER REVIEWER],
+          "exploration" => %w[RESEARCHER]
         }
       },
       "rails_feature_spec" => {
@@ -38,11 +38,11 @@ module Agentf
         "description" => "Feature-spec-first orchestration with planning and review emphasis.",
         "keywords" => %w[rails feature specification acceptance criteria],
         "workflow_templates" => {
-          "feature" => %w[ARCHITECT EXPLORER DESIGNER SPECIALIST TESTER REVIEWER DOCUMENTER],
-          "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER REVIEWER],
-          "refactor" => %w[ARCHITECT EXPLORER SPECIALIST TESTER REVIEWER],
-          "quick_fix" => %w[SPECIALIST REVIEWER],
-          "exploration" => %w[EXPLORER]
+          "feature" => %w[PLANNER RESEARCHER UI_ENGINEER ENGINEER QA_TESTER REVIEWER KNOWLEDGE_MANAGER],
+          "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER REVIEWER],
+          "refactor" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER REVIEWER],
+          "quick_fix" => %w[ENGINEER REVIEWER],
+          "exploration" => %w[RESEARCHER]
         }
       }
     }.freeze

data/lib/agentf/service/providers.rb

@@ -61,18 +61,18 @@ module Agentf
           return { "error" => "Agent #{agent_name} not found" } unless agent
 
           result = case agent_name
-                   when "ARCHITECT"
-                     agent.plan_task(task)
-                   when "EXPLORER"
-                     query = context["explore_query"] || "*.rb"
-                     files = commands.fetch("explorer").glob(query)
-                     response = agent.explore(query)
-                     response["files"] = files
-                     response
-                   when "TESTER"
-                      source_file = context["source_file"] || "app/models/application_record.rb"
-                      tester_commands = commands.fetch("tester")
-                      tdd_phase = context["tdd_phase"] || "normal"
+                   when Agentf::AgentRoles::PLANNER
+                      agent.plan_task(task)
+                   when Agentf::AgentRoles::RESEARCHER
+                      query = context["explore_query"] || "*.rb"
+                      files = commands.fetch("explorer").glob(query)
+                      response = agent.explore(query)
+                      response["files"] = files
+                      response
+                   when Agentf::AgentRoles::QA_TESTER
+                       source_file = context["source_file"] || "app/models/application_record.rb"
+                       tester_commands = commands.fetch("tester")
+                       tdd_phase = context["tdd_phase"] || "normal"
 
                       if tdd_phase == "red"
                         failure_signature = "expected-failure:#{File.basename(source_file)}:#{Time.now.to_i}"
@@ -92,32 +92,32 @@ module Agentf
                         response["failure_signature"] = context["tdd_failure_signature"]
                         response
                       end
-                    when "DEBUGGER"
-                     error = context["error"] || "No error provided"
-                     analysis = commands.fetch("debugger").parse_error(error)
-                     response = agent.diagnose(error, context: context["error_context"])
+                    when Agentf::AgentRoles::INCIDENT_RESPONDER
+                      error = context["error"] || "No error provided"
+                      analysis = commands.fetch("debugger").parse_error(error)
+                      response = agent.diagnose(error, context: context["error_context"])
                      response["analysis"] = {
                        "error_type" => analysis.error_type,
                        "root_cause" => analysis.possible_causes,
                        "suggested_fix" => analysis.suggested_fix
                      }
                      response
-                   when "DESIGNER"
-                     design_spec = context["design_spec"] || "Create a card component"
-                     spec = commands.fetch("designer").generate_component("GeneratedComponent", design_spec)
-                     response = agent.implement_design(design_spec)
-                     response["generated_code"] = spec.code
-                     response
-                   when "SPECIALIST"
-                     subtask = context["current_subtask"] || { "description" => task }
-                     agent.execute(subtask)
-                   when "SECURITY"
-                     agent.assess(task: task, context: context)
-                   when "REVIEWER"
-                     last_result = context["execution"] || {}
-                     agent.review(last_result)
-                   when "DOCUMENTER"
-                     agent.sync_docs("project")
+                    when Agentf::AgentRoles::UI_ENGINEER
+                      design_spec = context["design_spec"] || "Create a card component"
+                      spec = commands.fetch("designer").generate_component("GeneratedComponent", design_spec)
+                      response = agent.implement_design(design_spec)
+                      response["generated_code"] = spec.code
+                      response
+                    when Agentf::AgentRoles::ENGINEER
+                      subtask = context["current_subtask"] || { "description" => task }
+                      agent.execute(subtask)
+                    when Agentf::AgentRoles::SECURITY_REVIEWER
+                      agent.assess(task: task, context: context)
+                    when Agentf::AgentRoles::REVIEWER
+                      last_result = context["execution"] || {}
+                      agent.review(last_result)
+                    when Agentf::AgentRoles::KNOWLEDGE_MANAGER
+                      agent.sync_docs("project")
                    else
                      { "status" => "not_implemented" }
                    end
@@ -133,11 +133,11 @@ module Agentf
       class OpenCode < Base
         def workflow_templates
           {
-            "feature" => %w[ARCHITECT EXPLORER DESIGNER SPECIALIST TESTER SECURITY REVIEWER DOCUMENTER],
-            "bugfix" => %w[ARCHITECT DEBUGGER SPECIALIST TESTER SECURITY REVIEWER],
-            "quick_fix" => %w[SPECIALIST SECURITY REVIEWER],
-            "exploration" => %w[EXPLORER],
-            "refactor" => %w[ARCHITECT EXPLORER SPECIALIST TESTER SECURITY REVIEWER]
+            "feature" => %w[PLANNER RESEARCHER UI_ENGINEER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER KNOWLEDGE_MANAGER],
+            "bugfix" => %w[PLANNER INCIDENT_RESPONDER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER],
+            "quick_fix" => %w[ENGINEER SECURITY_REVIEWER REVIEWER],
+            "exploration" => %w[RESEARCHER],
+            "refactor" => %w[PLANNER RESEARCHER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER]
           }
         end
       end
@@ -145,11 +145,11 @@ module Agentf
       class Copilot < Base
         def workflow_templates
           {
-            "feature" => %w[ARCHITECT SPECIALIST TESTER SECURITY REVIEWER DOCUMENTER],
-            "bugfix" => %w[DEBUGGER SPECIALIST TESTER SECURITY REVIEWER],
-            "quick_fix" => %w[SPECIALIST REVIEWER],
-            "exploration" => %w[EXPLORER],
-            "refactor" => %w[ARCHITECT SPECIALIST TESTER REVIEWER]
+            "feature" => %w[PLANNER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER KNOWLEDGE_MANAGER],
+            "bugfix" => %w[INCIDENT_RESPONDER ENGINEER QA_TESTER SECURITY_REVIEWER REVIEWER],
+            "quick_fix" => %w[ENGINEER REVIEWER],
+            "exploration" => %w[RESEARCHER],
+            "refactor" => %w[PLANNER ENGINEER QA_TESTER REVIEWER]
           }
         end
       end

data/lib/agentf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Agentf
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end