agentf 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6072a9a176fba8e2376b10cc125d78d450057c90c4aa5d95158797429504d1f5
-  data.tar.gz: f66dc58d0030e1ba289d3f7046811190b9ae818aca61021729c9da12d19e710c
+  metadata.gz: 9d0041ebcd3b112183ddb349312e4cab8d30237ed1108dbb55d928c525dd59ae
+  data.tar.gz: 2577b0dc7af10255d02d2dde419aaa8e1135aea4e36dd67cc10b5d55b1866ba6
 SHA512:
-  metadata.gz: '0397d2603cc060239303773b370f14cc9585b94b4ba5109207ac7f705b18aec244f83443478c15c1ed40be4650c20f9f13d669f224dfc916374e924da4ab6cb1'
-  data.tar.gz: a8f7562d3bc1f8bd43897b4692c18a4096509d2c4ce413eaa1c992c61c2a7fada7c0c52228c543d62387c9a56c37672819f1becfd39240bc83066491947678f8
+  metadata.gz: ceae3f4d97e84e9934eae6591b7a2be4ea6ed56e31f4555110f998a2f3551f8231572a8c56dd790815988772ad8f4584f5d043d0283828665bcb69ad033d9ef2
+  data.tar.gz: 2ff0e3ece10105b6632ebd8e34c5b78c870dc6b8e105dabc41bc7f472502a8c33aee1dc7d10f14fa0ffaea513553c24f1353a9bda7a6647117f200cf8a43de88

data/lib/agentf/agents/architect.rb

@@ -9,7 +9,7 @@ module Agentf
       DESCRIPTION = "Strategy, task decomposition, and memory retrieval."
       COMMANDS = %w[glob read_file memory].freeze
       MEMORY_CONCEPTS = {
-        "reads" => ["get_recent_memories", "get_pitfalls"],
+        "reads" => ["get_recent_memories", "get_episodes"],
         "writes" => [],
         "policy" => "Retrieve relevant memories before planning; do not duplicate runtime memory into static markdown."
       }.freeze
@@ -44,7 +44,7 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Capture constraints before decomposition", "Use recent memories and pitfalls in planning"],
+          "always" => ["Capture constraints before decomposition", "Use recent memories and negative episodes in planning"],
           "ask_first" => ["Changing architectural style from project defaults"],
           "never" => ["Skip task decomposition for non-trivial workflows"],
           "required_inputs" => [],
@@ -57,7 +57,7 @@ module Agentf
 
         # Retrieve relevant memories before planning
         recent = memory.get_recent_memories(limit: 5)
-        pitfalls = memory.get_pitfalls(limit: 3)
+        pitfalls = memory.get_episodes(limit: 3, outcome: "negative")
 
         context = {
           "task" => task,

data/lib/agentf/agents/base.rb

@@ -4,6 +4,7 @@ module Agentf
   module Agents
     # Base agent class
     class Base
+      include Agentf::Memory::ConfirmationHandler
       attr_reader :memory, :name
 
       def self.typed_name
@@ -32,8 +33,8 @@ module Agentf
 
       def self.memory_concepts
         {
-          "reads" => ["RedisMemory#get_recent_memories", "RedisMemory#get_pitfalls"],
-          "writes" => ["RedisMemory#store_lesson", "RedisMemory#store_success", "RedisMemory#store_pitfall"],
+          "reads" => ["RedisMemory#get_recent_memories", "RedisMemory#get_episodes"],
+          "writes" => ["RedisMemory#store_lesson", "RedisMemory#store_episode", "RedisMemory#store_playbook"],
           "policy" => "Memory is runtime state in Redis and should not be embedded as raw data in manifest markdown."
         }
       end
@@ -52,6 +53,10 @@ module Agentf
         }
       end
 
+      def self.writes_code?
+        false
+      end
+
       def initialize(memory)
         @memory = memory
         @name = self.class.typed_name
@@ -91,28 +96,8 @@ module Agentf
           result: result
         )
 
-      result
-    end
-
-    # Helper to centralize memory write confirmation handling.
-    # Yields a block that performs the memory write. If the memory layer
-    # requires confirmation (ask_first policy) a structured hash is
-    # returned with confirmation details so agents can merge that into
-    # their own return payloads or let the orchestrator handle prompting.
-    def safe_memory_write(attempted: {})
-      begin
-        yield
-      rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
-        log "[MEMORY] Confirmation required: #{e.message} -- details=#{e.details.inspect}"
-        {
-          "confirmation_required" => true,
-          "confirmation_details" => e.details,
-          "attempted" => attempted,
-          "confirmed_write_token" => "confirmed",
-          "confirmation_prompt" => "Ask the user whether to save this memory. If they approve, rerun the same tool with confirmedWrite=confirmed. If they decline, do not retry."
-        }
+        result
       end
     end
-    end
   end
 end

data/lib/agentf/agents/debugger.rb

@@ -66,13 +66,12 @@ module Agentf
 
           analysis = @commands.parse_error(error)
 
-          res = safe_memory_write(attempted: { action: "store_lesson", title: "Debugged: #{error[0..50]}...", tags: ["debugging", "error", "fix"], agent: name }) do
+          res = safe_memory_write(attempted: { action: "store_lesson", title: "Debugged: #{error[0..50]}...", agent: name }) do
             memory.store_episode(
               type: "lesson",
               title: "Debugged: #{error[0..50]}...",
               description: "Root cause: #{analysis.possible_causes.first}. Fix: #{analysis.suggested_fix}",
               context: context.to_s,
-              tags: ["debugging", "error", "fix"],
               agent: name
             )
           end

data/lib/agentf/agents/designer.rb

@@ -11,7 +11,7 @@ module Agentf
       COMMANDS = %w[generate_component validate_design_system].freeze
       MEMORY_CONCEPTS = {
         "reads" => [],
-        "writes" => ["store_success"],
+        "writes" => ["store_episode"],
         "policy" => "Capture successful design implementation patterns."
       }.freeze
 
@@ -45,14 +45,28 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Return generated component details", "Persist successful implementation pattern"],
+          "always" => [
+            "Return generated component details",
+            "Persist successful implementation pattern",
+            "Write a failing spec before implementing any new component or function (red)",
+            "Run the test suite to confirm the spec fails before writing implementation",
+            "Run the test suite again after implementation to confirm green"
+          ],
           "ask_first" => ["Changing primary UI framework", "Persisting successful implementation patterns to memory"],
-          "never" => ["Return empty generated code for successful design task"],
+          "never" => [
+            "Return empty generated code for successful design task",
+            "Create a new component or function without a corresponding spec file",
+            "Skip red/green verification when writing or modifying code"
+          ],
           "required_inputs" => ["design_spec"],
           "required_outputs" => ["component", "generated_code", "success"]
         }
       end
 
+      def self.writes_code?
+        true
+      end
+
       def initialize(memory, commands: nil)
         super(memory)
         @commands = commands || Agentf::Commands::Designer.new
@@ -64,13 +78,14 @@ module Agentf
 
           spec = @commands.generate_component("GeneratedComponent", design_spec)
 
-          res = safe_memory_write(attempted: { action: "store_success", title: "Implemented design: #{design_spec}", tags: ["design", "ui", framework], agent: name }) do
-            memory.store_success(
+          res = safe_memory_write(attempted: { action: "store_episode", title: "Implemented design: #{design_spec}", outcome: "positive", agent: name }) do
+            memory.store_episode(
+              type: "episode",
               title: "Implemented design: #{design_spec}",
               description: "Created #{spec.name} in #{spec.framework}",
               context: "Framework: #{framework}",
-              tags: ["design", "ui", framework],
-              agent: name
+              agent: name,
+              outcome: "positive"
             )
           end
 

data/lib/agentf/agents/documenter.rb

@@ -57,8 +57,8 @@ module Agentf
 
         memories = memory.get_recent_memories(limit: 20)
 
-        successes = memories.select { |m| m["type"] == "success" }
-        pitfalls = memories.select { |m| m["type"] == "pitfall" }
+        successes = memories.select { |m| m["type"] == "episode" && m["outcome"] == "positive" }
+        pitfalls = memories.select { |m| m["type"] == "episode" && m["outcome"] == "negative" }
 
         log "Found #{successes.size} successes"
         log "Found #{pitfalls.size} pitfalls"

data/lib/agentf/agents/explorer.rb

@@ -63,12 +63,11 @@ module Agentf
 
         files = @commands.glob(query, file_types: nil)
 
-        res = safe_memory_write(attempted: { action: "store_lesson", title: "Research finding: #{query}", tags: ["research", "exploration"], agent: name }) do
+        res = safe_memory_write(attempted: { action: "store_lesson", title: "Research finding: #{query}", agent: name }) do
           memory.store_lesson(
             title: "Research finding: #{query}",
             description: "Found #{files.size} relevant files during exploration",
             context: "Search pattern: #{file_pattern || 'all files'}",
-            tags: ["research", "exploration"],
             agent: name
           )
         end

data/lib/agentf/agents/reviewer.rb

@@ -9,9 +9,9 @@ module Agentf
       DESCRIPTION = "Quality assurance and regression checking against memory."
       COMMANDS = %w[read_file memory].freeze
       MEMORY_CONCEPTS = {
-        "reads" => ["get_pitfalls", "get_recent_memories"],
+        "reads" => ["get_episodes", "get_recent_memories"],
         "writes" => [],
-        "policy" => "Validate outputs against known pitfalls before approval."
+        "policy" => "Validate outputs against known negative episodes before approval."
       }.freeze
 
       def self.description
@@ -56,14 +56,14 @@ module Agentf
         execute_with_contract(context: { "execution" => subtask_result }) do
           log "Reviewing subtask #{subtask_result['subtask_id']}"
 
-          pitfalls = memory.get_pitfalls(limit: 5)
-          memories = memory.get_recent_memories(limit: 5)
+            pitfalls = memory.get_episodes(limit: 5, outcome: "negative")
+            memories = memory.get_recent_memories(limit: 5)
 
           issues = []
 
-          pitfalls.each do |pitfall|
-            issues << "Warning: Known pitfall - #{pitfall['title']}" if pitfall["type"] == "pitfall"
-          end
+            pitfalls.each do |pitfall|
+              issues << "Warning: Known negative episode - #{pitfall['title']}" if pitfall["type"] == "episode"
+            end
 
           approved = issues.empty?
 

data/lib/agentf/agents/security.rb

@@ -11,7 +11,7 @@ module Agentf
       COMMANDS = %w[scan best_practices].freeze
       MEMORY_CONCEPTS = {
         "reads" => [],
-        "writes" => ["store_success", "store_pitfall"],
+        "writes" => ["store_episode"],
         "policy" => "Record findings while redacting sensitive values."
       }.freeze
 
@@ -66,24 +66,26 @@ module Agentf
           summary = summarize_findings(findings)
 
           if findings["issues"].empty?
-            res = safe_memory_write(attempted: { action: "store_success", title: "Security review passed", tags: ["security", "pass"], agent: name }) do
-              memory.store_success(
+            res = safe_memory_write(attempted: { action: "store_episode", title: "Security review passed", outcome: "positive", agent: name }) do
+              memory.store_episode(
+                type: "episode",
                 title: "Security review passed",
                 description: summary,
                 context: task,
-                tags: ["security", "pass"],
-                agent: name
+                agent: name,
+                outcome: "positive"
               )
             end
             return findings.merge(res) if res.is_a?(Hash) && res["confirmation_required"]
           else
-            res = safe_memory_write(attempted: { action: "store_pitfall", title: "Security findings detected", tags: ["security", "warning"], agent: name }) do
-              memory.store_pitfall(
+            res = safe_memory_write(attempted: { action: "store_episode", title: "Security findings detected", outcome: "negative", agent: name }) do
+              memory.store_episode(
+                type: "episode",
                 title: "Security findings detected",
                 description: summary,
                 context: task,
-                tags: ["security", "warning"],
-                agent: name
+                agent: name,
+                outcome: "negative"
               )
             end
             return findings.merge(res) if res.is_a?(Hash) && res["confirmation_required"]

data/lib/agentf/agents/specialist.rb

@@ -10,7 +10,7 @@ module Agentf
       COMMANDS = %w[read_file write_file run_command].freeze
       MEMORY_CONCEPTS = {
         "reads" => [],
-        "writes" => ["store_success", "store_pitfall"],
+        "writes" => ["store_episode"],
         "policy" => "Persist execution outcomes as lessons for downstream agents."
       }.freeze
 
@@ -44,14 +44,28 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Persist execution outcome", "Return deterministic success boolean"],
-          "ask_first" => ["Applying architecture style changes across unrelated modules", "Persisting execution outcomes to memory (success/pitfall)"] ,
-          "never" => ["Claim implementation complete without execution result"],
+          "always" => [
+            "Persist execution outcome",
+            "Return deterministic success boolean",
+            "Write a failing spec before adding any new class, method, or module (red)",
+            "Run the test suite to confirm the spec fails before writing implementation",
+            "Run the test suite again after implementation to confirm green"
+          ],
+          "ask_first" => ["Applying architecture style changes across unrelated modules", "Persisting execution outcomes to memory (success/pitfall)"],
+          "never" => [
+            "Claim implementation complete without execution result",
+            "Create a new class, method, or module without a corresponding spec file",
+            "Skip red/green verification when writing or modifying code"
+          ],
           "required_inputs" => ["description"],
           "required_outputs" => ["subtask_id", "success"]
         }
       end
 
+      def self.writes_code?
+        true
+      end
+
       def execute(task:, context: {}, agents: {}, commands: {}, logger: nil)
         subtask = task.is_a?(Hash) ? task : (context["current_subtask"] || { "description" => task })
 
@@ -66,13 +80,14 @@ module Agentf
           success = normalized_subtask.fetch("success", true)
 
           if success
-            res = safe_memory_write(attempted: { action: "store_success", title: "Completed: #{normalized_subtask['description']}", tags: ["implementation", normalized_subtask.fetch("language", "general")], agent: name }) do
-              memory.store_success(
+            res = safe_memory_write(attempted: { action: "store_episode", title: "Completed: #{normalized_subtask['description']}", outcome: "positive", agent: name }) do
+              memory.store_episode(
+                type: "episode",
                 title: "Completed: #{normalized_subtask['description']}",
                 description: "Successfully executed subtask #{normalized_subtask['id']}",
                 context: "Working on #{normalized_subtask.fetch('task', 'unknown task')}",
-                tags: ["implementation", normalized_subtask.fetch("language", "general")],
-                agent: name
+                agent: name,
+                outcome: "positive"
               )
             end
 
@@ -81,13 +96,14 @@ module Agentf
               return { "subtask_id" => normalized_subtask["id"], "success" => success, "result" => "Code executed", "confirmation_required" => true, "confirmation_details" => res["confirmation_details"], "attempted" => res["attempted"] }
             end
           else
-            res = safe_memory_write(attempted: { action: "store_pitfall", title: "Failed: #{normalized_subtask['description']}", tags: ["failure", "implementation"], agent: name }) do
-              memory.store_pitfall(
+            res = safe_memory_write(attempted: { action: "store_episode", title: "Failed: #{normalized_subtask['description']}", outcome: "negative", agent: name }) do
+              memory.store_episode(
+                type: "episode",
                 title: "Failed: #{normalized_subtask['description']}",
                 description: "Subtask #{normalized_subtask['id']} failed",
                 context: "Working on #{normalized_subtask.fetch('task', 'unknown task')}",
-                tags: ["failure", "implementation"],
-                agent: name
+                agent: name,
+                outcome: "negative"
               )
             end
 

data/lib/agentf/agents/tester.rb

@@ -11,7 +11,7 @@ module Agentf
       COMMANDS = %w[detect_framework generate_unit_tests run_tests].freeze
       MEMORY_CONCEPTS = {
         "reads" => [],
-        "writes" => ["store_success"],
+        "writes" => ["store_episode"],
         "policy" => "Persist test generation outcomes for future reuse."
       }.freeze
 
@@ -45,14 +45,28 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Produce framework-aware tests", "Verify red/green state when TDD enabled"],
+          "always" => [
+            "Produce framework-aware tests",
+            "Verify red/green state when TDD enabled",
+            "Write a failing spec before adding any new test helper, fixture, or shared example (red)",
+            "Run the test suite to confirm the spec fails before writing implementation",
+            "Run the test suite again after implementation to confirm green"
+          ],
           "ask_first" => ["Changing test framework conventions", "Persisting test-generation outcomes to memory"],
-          "never" => ["Mark passing when command output is uncertain"],
+          "never" => [
+            "Mark passing when command output is uncertain",
+            "Create a new test helper or shared example without a corresponding spec file",
+            "Skip red/green verification when writing or modifying test infrastructure code"
+          ],
           "required_inputs" => [],
           "required_outputs" => ["test_file"]
         }
       end
 
+      def self.writes_code?
+        true
+      end
+
       def initialize(memory, commands: nil)
         super(memory)
         @commands = commands || Agentf::Commands::Tester.new
@@ -63,13 +77,14 @@ module Agentf
 
         template = @commands.generate_unit_tests(code_file)
 
-        res = safe_memory_write(attempted: { action: "store_success", title: "Generated #{test_type} tests for #{code_file}", tags: ["testing", test_type, code_file.split(".").last], agent: name }) do
-          memory.store_success(
+        res = safe_memory_write(attempted: { action: "store_episode", title: "Generated #{test_type} tests for #{code_file}", outcome: "positive", agent: name }) do
+          memory.store_episode(
+            type: "episode",
             title: "Generated #{test_type} tests for #{code_file}",
             description: "Created #{template.test_file} with #{test_type} tests",
             context: "Test framework: #{template.framework}",
-            tags: ["testing", test_type, code_file.split(".").last],
-            agent: name
+            agent: name,
+            outcome: "positive"
           )
         end
 

data/lib/agentf/cli/eval.rb

@@ -113,7 +113,7 @@ module Agentf
 
           Examples:
             agentf eval list
-            agentf eval run engineer_store_success
+            agentf eval run engineer_episode_positive
             agentf eval report
             agentf eval run all --json
         HELP