agentf 0.4.7 → 0.6.0

data/lib/agentf/service/providers.rb

@@ -51,7 +51,8 @@ module Agentf
         end
 
         def pack_workflow_templates
-          Agentf::Packs.fetch(@pack).fetch("workflow_templates")
+          # Workflow templates are now provided by the orchestrator profiles
+          Agentf::WorkflowEngine::PROFILES.fetch(@pack, Agentf::WorkflowEngine::PROFILES["generic"]).fetch("workflow_templates")
         end
 
         def execute_agent(agent_name:, task:, context:, agents:, commands:, logger: nil)
@@ -60,67 +61,14 @@ module Agentf
           agent = agents[agent_name]
           return { "error" => "Agent #{agent_name} not found" } unless agent
 
-          result = case agent_name
-                   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}"
-                        {
-                          "source_file" => source_file,
-                          "test_file" => source_file.sub(/\.rb$/, "_spec.rb"),
-                          "tdd_phase" => "red",
-                          "passed" => false,
-                          "failure_signature" => failure_signature,
-                          "stdout" => "Intentional TDD red failure captured"
-                        }
-                      else
-                        template = tester_commands.generate_unit_tests(source_file)
-                        response = agent.generate_tests(source_file)
-                        response["generated_code"] = template.test_code
-                        response["tdd_phase"] = tdd_phase
-                        response["failure_signature"] = context["tdd_failure_signature"]
-                        response
-                      end
-                    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 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
+          # Provider no longer simulates TDD red-phase; delegate to Tester agent.
+
+          unless agent.respond_to?(:execute)
+            raise "Agent #{agent_name} does not implement execute"
+          end
+
+          # Delegate execution to the agent's unified entrypoint.
+          result = agent.execute(task: task, context: context || {}, agents: agents, commands: commands, logger: logger)
 
           logger&.call("→ #{agent_name} Complete")
           result

data/lib/agentf/version.rb

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

data/lib/agentf/workflow_engine.rb

@@ -8,6 +8,54 @@ require_relative "agent_policy"
 
 module Agentf
   class WorkflowEngine
+    # Profiles previously lived in Agentf::Packs. They are now embedded in the
+    # orchestrator so there's a single source of truth for workflow templates
+    # and keyword-based inference used by both runtime orchestration and any
+    # installer/CLI functionality.
+    PROFILES = {
+      "generic" => {
+        "name" => "Generic",
+        "description" => "Default provider workflows without domain specialization.",
+        "keywords" => [],
+        "workflow_templates" => {}
+      },
+      "rails_standard" => {
+        "name" => "Rails Standard",
+        "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[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" => {
+        "name" => "Rails 37signals",
+        "description" => "Resource-centric workflows favoring concerns, CRUD and model-rich patterns.",
+        "keywords" => %w[rails concern crud closure model minitest hotwire],
+        "workflow_templates" => {
+          "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" => {
+        "name" => "Rails Feature Spec",
+        "description" => "Feature-spec-first orchestration with planning and review emphasis.",
+        "keywords" => %w[rails feature specification acceptance criteria],
+        "workflow_templates" => {
+          "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
     PROVIDERS = {
       opencode: Agentf::Service::Providers::OpenCode,
       copilot: Agentf::Service::Providers::Copilot
@@ -20,7 +68,8 @@ module Agentf
       @base_path = base_path || Agentf.config.base_path
       @name = Agentf::AgentRoles::ORCHESTRATOR
       @provider_ref = provider
-      @provider = build_provider(@provider_ref, pack: Agentf.config.default_pack)
+      # Initialize provider using the orchestrator's default profile ("generic").
+      @provider = build_provider(@provider_ref, pack: "generic")
 
       @explorer_commands = Commands::Explorer.new(base_path: @base_path)
       @tester_commands = Commands::Tester.new(base_path: @base_path)
@@ -51,7 +100,9 @@ module Agentf
       @workflow_state = {}
     end
 
-    def execute(task, context: nil)
+    # Unified execute entrypoint for the workflow engine. Accepts keyword
+    # `task:` for consistency with agent `execute` contracts.
+    def execute(task:, context: nil)
       log "=" * 60
       log "EXECUTING #{provider.name} WORKFLOW"
       log "=" * 60
@@ -136,10 +187,22 @@ module Agentf
       requested = context["pack"].to_s.strip
       return requested.downcase unless requested.empty?
 
-      default_pack = Agentf.config.default_pack.to_s.strip
-      return default_pack.downcase unless default_pack.empty? || default_pack.casecmp("generic").zero?
+      # No config-based default profile is kept; rely on orchestrator inference.
+      infer_profile(context.merge("task" => task))
+    end
+
+    def infer_profile(context = {})
+      text = [context["task"], context["design_spec"], context["stack"], context["framework"]]
+             .compact.join(" ").downcase
+      return "generic" if text.empty?
+
+      return "rails_standard" if includes_any_keyword?(text, PROFILES["rails_standard"]["keywords"])
+
+      "generic"
+    end
 
-      Agentf::Packs.infer(context.merge("task" => task))
+    def includes_any_keyword?(text, keywords)
+      keywords.any? { |keyword| text.include?(keyword) }
     end
 
     def log(message)
@@ -161,8 +224,12 @@ module Agentf
         enriched_context["tdd_failure_signature"] = @workflow_state.dig("tdd", "failure_signature")
       end
 
+      # For ENGINEER, provide the current TDD phase and the expected failing
+      # test signature so the engineer can attempt a repair. Do NOT change the
+      # orchestrator-wide TDD state here; phase transitions must be driven by
+      # QA TESTER results (to ensure tests actually pass/fail).
       if agent_name == Agentf::AgentRoles::ENGINEER
-        enriched_context["tdd_phase"] = "green"
+        enriched_context["tdd_phase"] = @workflow_state.dig("tdd", "phase")
         enriched_context["expected_test_fix"] = @workflow_state.dig("tdd", "failure_signature")
       end
 
@@ -170,14 +237,23 @@ module Agentf
         enriched_context["execution"] = @workflow_state["results"].last&.fetch("result", {}) || {}
       end
 
-      result = @provider.execute_agent(
-        agent_name: agent_name,
-        task: @workflow_state["task"],
-        context: enriched_context,
-        agents: @agents,
-        commands: command_registry,
-        logger: method(:log)
-      )
+      begin
+        result = @provider.execute_agent(
+          agent_name: agent_name,
+          task: @workflow_state["task"],
+          context: enriched_context,
+          agents: @agents,
+          commands: command_registry,
+          logger: method(:log)
+        )
+      rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+        # An agent attempted to persist memory but policy requires confirmation.
+        # Record the event and return a structured result that signals the
+        # orchestrator/UI to prompt the user. Do NOT set an "error" key so
+        # agent execution contract does not treat this as a failure.
+        handle_memory_confirmation(e, attempted: { action: "agent_persist", agent: agent_name })
+        return { "success" => false, "confirmation_required" => true, "confirmation_details" => e.details }
+      end
 
       policy_violations = @agent_policy.validate(
         agent_name: agent_name,
@@ -217,16 +293,15 @@ module Agentf
     def persist_feature_intent(task:, workflow_type:, context:)
       acceptance_criteria = Array(context["acceptance_criteria"])
       non_goals = Array(context["non_goals"])
-      tags = [workflow_type, @provider.name.downcase]
-
       @memory.store_feature_intent(
         title: task,
         description: "Workflow intent captured by workflow engine",
         acceptance_criteria: acceptance_criteria,
         non_goals: non_goals,
-        tags: tags,
         agent: @name
       )
+    rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+      handle_memory_confirmation(e, attempted: { action: "store_feature_intent", title: task })
     rescue StandardError => e
       log "Intent capture skipped: #{e.message}"
     end
@@ -235,51 +310,69 @@ module Agentf
       return unless result.is_a?(Hash)
 
       if result["error"]
-        @memory.store_pitfall(
-          title: "#{agent_name} execution failure",
-          description: result["error"],
-          context: @workflow_state["task"],
-          tags: [@workflow_state["workflow_type"], "workflow_error"],
-          agent: agent_name,
-          code_snippet: ""
-        )
+        begin
+          @memory.store_episode(
+            type: "episode",
+            title: "#{agent_name} execution failure",
+            description: result["error"],
+            context: @workflow_state["task"],
+            agent: agent_name,
+            outcome: "negative",
+            code_snippet: ""
+          )
+        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+          handle_memory_confirmation(e, attempted: { action: "store_episode", agent: agent_name, error: result["error"], outcome: "negative" })
+        end
         return
       end
 
       if agent_name == Agentf::AgentRoles::QA_TESTER && result["tdd_phase"] == "red" && result["passed"] == false
-        @memory.store_pitfall(
-          title: "TDD red phase captured",
-          description: result["failure_signature"] || "Intentional failing test captured",
-          context: @workflow_state["task"],
-          tags: [@workflow_state["workflow_type"], "tdd_red"],
-          agent: agent_name,
-          code_snippet: ""
-        )
+        begin
+          @memory.store_episode(
+            type: "episode",
+            title: "TDD red phase captured",
+            description: result["failure_signature"] || "Intentional failing test captured",
+            context: @workflow_state["task"],
+            agent: agent_name,
+            outcome: "negative",
+            code_snippet: ""
+          )
+        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+          handle_memory_confirmation(e, attempted: { action: "store_episode", agent: agent_name, tdd: true, outcome: "negative" })
+        end
         return
       end
 
       if agent_name == Agentf::AgentRoles::QA_TESTER && result["tdd_phase"] == "green" && result["passed"] == true
-        @memory.store_success(
-          title: "TDD green phase passed",
-          description: "Resolved failing test signature: #{result['failure_signature']}",
+        begin
+          @memory.store_episode(
+            type: "episode",
+            title: "TDD green phase passed",
+            description: "Resolved failing test signature: #{result['failure_signature']}",
+            context: @workflow_state["task"],
+            agent: agent_name,
+            outcome: "positive",
+            code_snippet: ""
+          )
+        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+          handle_memory_confirmation(e, attempted: { action: "store_episode", agent: agent_name, tdd: true, outcome: "positive" })
+        end
+        return
+      end
+
+      begin
+        @memory.store_lesson(
+          title: "#{agent_name} completed workflow step",
+          description: "Agent step completed for #{@workflow_state['workflow_type']} workflow",
           context: @workflow_state["task"],
-          tags: [@workflow_state["workflow_type"], "tdd_green"],
           agent: agent_name,
           code_snippet: ""
         )
-        return
+      rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+        handle_memory_confirmation(e, attempted: { action: "store_lesson", agent: agent_name })
       end
-
-      @memory.store_lesson(
-        title: "#{agent_name} completed workflow step",
-        description: "Agent step completed for #{@workflow_state['workflow_type']} workflow",
-        context: @workflow_state["task"],
-        tags: [@workflow_state["workflow_type"], "workflow_step"],
-        agent: agent_name,
-        code_snippet: ""
-      )
     rescue StandardError => e
-      log "Learning persistence skipped: #{e.message}"
+      log "Learning persistence skipped: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(6).join("\n  ")}" 
     end
 
     def summarize_workflow
@@ -334,22 +427,27 @@ module Agentf
       @workflow_state["results"] << { "agent" => "QA_TESTER_TDD_RED", "result" => red_result }
       persist_agent_learning(agent_name: Agentf::AgentRoles::QA_TESTER, result: red_result)
     rescue StandardError => e
-      log "TDD red phase skipped: #{e.message}"
+      log "TDD red phase skipped: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(6).join("\n  ")}" 
     end
 
     def transition_tdd_phase(agent_name:, result:)
       tdd = @workflow_state["tdd"]
       return unless tdd["enabled"]
 
-      if agent_name == Agentf::AgentRoles::ENGINEER
-        tdd["phase"] = "green"
-      elsif agent_name == Agentf::AgentRoles::QA_TESTER && tdd["phase"] == "green"
-        tdd["green_executed"] = true
+      # Phase transitions should be decided by QA_TESTER outcomes. When the
+      # QA tester reports a green phase and passing tests, mark the workflow
+      # as green. We avoid changing phase when ENGINEER executes to prevent
+      # optimistic transitions.
+      if agent_name == Agentf::AgentRoles::QA_TESTER
+        if result["tdd_phase"] == "green" && result["passed"] == true
+          tdd["phase"] = "green"
+          tdd["green_executed"] = true
+          tdd["failure_signature"] ||= result["failure_signature"]
+        elsif result["tdd_phase"] == "green"
+          # Tester indicated green but didn't confirm passing — keep guarded.
+          tdd["failure_signature"] ||= result["failure_signature"]
+        end
       end
-
-      return unless agent_name == Agentf::AgentRoles::QA_TESTER && result["tdd_phase"] == "green"
-
-      tdd["failure_signature"] ||= result["failure_signature"]
     end
 
     def record_workflow_metrics
@@ -360,18 +458,21 @@ module Agentf
 
       log "Metrics capture skipped: #{result['error']}"
     rescue StandardError => e
-      log "Metrics capture skipped: #{e.message}"
+      log "Metrics capture skipped: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(6).join("\n  ")}" 
     end
 
     def perform_architecture_review
       result = @architecture_commands.review_layer_violations
-      @memory.store_lesson(
-        title: "Architecture review completed",
-        description: "Layer violations: #{Array(result['violations']).length}",
-        context: @workflow_state["task"],
-        tags: [@workflow_state["workflow_type"], "architecture_review"],
-        agent: @name
-      )
+      begin
+        @memory.store_lesson(
+          title: "Architecture review completed",
+          description: "Layer violations: #{Array(result['violations']).length}",
+          context: @workflow_state["task"],
+          agent: @name
+        )
+      rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+        handle_memory_confirmation(e, attempted: { action: "store_lesson", agent: @name, context: @workflow_state["task"] })
+      end
       result
     rescue StandardError => e
       { "error" => e.message, "violations" => [] }
@@ -398,12 +499,13 @@ module Agentf
         title: "Workflow contract #{evaluation['stage']} #{evaluation['ok'] ? 'passed' : 'violated'}",
         description: "mode=#{evaluation['mode']} blocked=#{evaluation['blocked']}",
         context: JSON.generate(evaluation),
-        tags: ["workflow_contract", evaluation["stage"], evaluation["ok"] ? "pass" : "violation"],
         agent: @name,
         metadata: { "workflow_contract_event" => true }
       )
+    rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+      handle_memory_confirmation(e, attempted: { action: "store_episode", title: "Workflow contract #{evaluation['stage']}", agent: @name })
     rescue StandardError => e
-      log "Contract event persistence skipped: #{e.message}"
+      log "Contract event persistence skipped: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(6).join("\n  ")}" 
     end
 
     def append_policy_violations(policy_violations)
@@ -412,18 +514,44 @@ module Agentf
       @workflow_state["policy_violations"] ||= []
       @workflow_state["policy_violations"].concat(policy_violations)
       policy_violations.each do |violation|
-        @memory.store_episode(
-          type: "pitfall",
-          title: "Agent policy violation: #{violation['code']}",
-          description: violation["message"],
-          context: @workflow_state["task"],
-          tags: ["agent_policy", violation["agent"].to_s.downcase],
-          agent: @name,
-          metadata: { "policy_violation" => true, "severity" => violation["severity"] }
-        )
+        begin
+          @memory.store_episode(
+            type: "episode",
+            title: "Agent policy violation: #{violation['code']}",
+            description: violation["message"],
+            context: @workflow_state["task"],
+            agent: @name,
+            outcome: "negative",
+            metadata: { "policy_violation" => true, "severity" => violation["severity"] }
+          )
+        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+          handle_memory_confirmation(e, attempted: { action: "store_policy_violation", violation: violation, agent: @name })
+        end
       end
     rescue StandardError => e
-      log "Policy violation persistence skipped: #{e.message}"
+      log "Policy violation persistence skipped: #{e.class}: #{e.message}\n  #{Array(e.backtrace).first(6).join("\n  ")}" 
+    end
+
+    # Helper to format exceptions for concise logs. Exposed here so multiple
+    # rescue handlers can produce consistent output if desired in the future.
+    def format_exception(e)
+      "#{e.class}: #{e.message}\n  #{Array(e.backtrace).first(6).join("\n  ")}"
+    end
+
+    # Handle a memory confirmation exception by recording an event in the
+    # workflow_state and emitting a log. This allows the orchestrator or UI to
+    # surface a prompt to the user, and optionally retry the attempted action
+    # with explicit confirmation.
+    def handle_memory_confirmation(exception, attempted: {})
+      @workflow_state["memory_confirmation_required"] ||= []
+      entry = {
+        "timestamp" => Time.now.to_i,
+        "confirmation_required" => true,
+        "confirmation_details" => exception.details,
+        "attempted" => attempted
+      }
+      @workflow_state["memory_confirmation_required"] << entry
+      log "Memory confirmation required: #{exception.message} -- attempted=#{attempted.inspect}"
     end
   end
 end

data/lib/agentf.rb

@@ -16,7 +16,7 @@ module Agentf
     attr_reader :redis_url
     attr_accessor :project_name, :base_path, :metrics_enabled, :workflow_contract_enabled,
                   :workflow_contract_mode, :agent_contract_enabled, :agent_contract_mode,
-                  :default_pack, :gem_path
+                  :gem_path
 
     def initialize
       @redis_url = normalize_redis_url(ENV.fetch("REDIS_URL", "redis://localhost:6379"))
@@ -37,7 +37,7 @@ module Agentf
       @agent_contract_mode = normalize_contract_mode(
         ENV.fetch("AGENTF_AGENT_CONTRACT_MODE", "enforcing")
       )
-      @default_pack = ENV.fetch("AGENTF_DEFAULT_PACK", "generic").to_s.strip.downcase
+      # Default profile removed; orchestrator defaults to "generic" internally.
       @gem_path = ENV.fetch("AGENTF_GEM_PATH", nil)
     end
 
@@ -85,9 +85,16 @@ end
 require_relative "agentf/memory"
 require_relative "agentf/tools"
 require_relative "agentf/commands"
+require_relative "agentf/commands/registry"
 require_relative "agentf/service/providers"
+require_relative "agentf/embedding_provider"
 require_relative "agentf/context_builder"
-require_relative "agentf/packs"
+require_relative "agentf/evals/scenario"
+require_relative "agentf/evals/runner"
+require_relative "agentf/evals/report"
+# Profiles previously lived in lib/agentf/packs.rb; the profile data is now
+# embedded in the orchestrator (WorkflowEngine::PROFILES). The old file was
+# removed as part of simplifying the profile surface.
 require_relative "agentf/agent_policy"
 require_relative "agentf/agent_execution_contract"
 require_relative "agentf/workflow_contract"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agentf
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.6.0
 platform: ruby
 authors:
 - Neal Deters
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-11 00:00:00.000000000 Z
+date: 2026-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -108,9 +108,11 @@ files:
 - lib/agentf/agents/security.rb
 - lib/agentf/agents/specialist.rb
 - lib/agentf/agents/tester.rb
+- lib/agentf/cli/agent.rb
 - lib/agentf/cli/architecture.rb
 - lib/agentf/cli/arg_parser.rb
 - lib/agentf/cli/code.rb
+- lib/agentf/cli/eval.rb
 - lib/agentf/cli/install.rb
 - lib/agentf/cli/memory.rb
 - lib/agentf/cli/metrics.rb
@@ -123,14 +125,18 @@ files:
 - lib/agentf/commands/explorer.rb
 - lib/agentf/commands/memory_reviewer.rb
 - lib/agentf/commands/metrics.rb
+- lib/agentf/commands/registry.rb
 - lib/agentf/commands/security_scanner.rb
 - lib/agentf/commands/tester.rb
 - lib/agentf/context_builder.rb
+- lib/agentf/embedding_provider.rb
+- lib/agentf/evals/report.rb
+- lib/agentf/evals/runner.rb
+- lib/agentf/evals/scenario.rb
 - lib/agentf/installer.rb
 - lib/agentf/mcp/server.rb
 - lib/agentf/mcp/stub.rb
 - lib/agentf/memory.rb
-- lib/agentf/packs.rb
 - lib/agentf/service/providers.rb
 - lib/agentf/tools.rb
 - lib/agentf/tools/component_spec.rb

data/lib/agentf/packs.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Agentf
-  module Packs
-    PROFILES = {
-      "generic" => {
-        "name" => "Generic",
-        "description" => "Default provider workflows without domain specialization.",
-        "keywords" => [],
-        "workflow_templates" => {}
-      },
-      "rails_standard" => {
-        "name" => "Rails Standard",
-        "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[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" => {
-        "name" => "Rails 37signals",
-        "description" => "Resource-centric workflows favoring concerns, CRUD and model-rich patterns.",
-        "keywords" => %w[rails concern crud closure model minitest hotwire],
-        "workflow_templates" => {
-          "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" => {
-        "name" => "Rails Feature Spec",
-        "description" => "Feature-spec-first orchestration with planning and review emphasis.",
-        "keywords" => %w[rails feature specification acceptance criteria],
-        "workflow_templates" => {
-          "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
-
-    module_function
-
-    def all
-      PROFILES
-    end
-
-    def fetch(name)
-      PROFILES[name.to_s.downcase] || PROFILES["generic"]
-    end
-
-    def infer(context = {})
-      text = [context["task"], context["design_spec"], context["stack"], context["framework"]]
-             .compact.join(" ").downcase
-      return "generic" if text.empty?
-
-      return "rails_standard" if includes_any_keyword?(text, PROFILES["rails_standard"]["keywords"])
-
-      "generic"
-    end
-
-    def includes_any_keyword?(text, keywords)
-      keywords.any? { |keyword| text.include?(keyword) }
-    end
-  end
-end