agentf 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6072a9a176fba8e2376b10cc125d78d450057c90c4aa5d95158797429504d1f5
-  data.tar.gz: f66dc58d0030e1ba289d3f7046811190b9ae818aca61021729c9da12d19e710c
+  metadata.gz: ace5a58ed6bfb8389d1e7a68349d7cc9f8d80b4093131a8cf2013388b001a08d
+  data.tar.gz: ba9a86b1c4b9e7e7edf62bed089d5cb3a1dddb9c5b4282c16e9be27438fec088
 SHA512:
-  metadata.gz: '0397d2603cc060239303773b370f14cc9585b94b4ba5109207ac7f705b18aec244f83443478c15c1ed40be4650c20f9f13d669f224dfc916374e924da4ab6cb1'
-  data.tar.gz: a8f7562d3bc1f8bd43897b4692c18a4096509d2c4ce413eaa1c992c61c2a7fada7c0c52228c543d62387c9a56c37672819f1becfd39240bc83066491947678f8
+  metadata.gz: 35767581d0b7561c1800464909dbf00524724527148b20f4f1ab911d846301d1a60333e8703d7b3db04e7d3d34e1a977d522fef236f8899692ae8a8c2bac65ad
+  data.tar.gz: 8d61e62517723d4bc4d39905dfb87b792d27ba1bfbe2b1eb6c445409b138091d072413ad21bffbe2cd584887d9a75f798df64f79601594ccb1029e9db54439f1

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

@@ -32,8 +32,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

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
 
@@ -64,13 +64,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
 
@@ -66,13 +66,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 +82,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
 
@@ -63,13 +63,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

data/lib/agentf/cli/memory.rb

@@ -13,7 +13,7 @@ module Agentf
     class Memory
       include ArgParser
 
-      VALID_EPISODE_TYPES = %w[pitfall lesson success business_intent feature_intent].freeze
+      VALID_EPISODE_TYPES = %w[episode lesson playbook business_intent feature_intent incident].freeze
 
       def initialize(reviewer: nil, memory: nil)
         @reviewer = reviewer || Commands::MemoryReviewer.new
@@ -28,12 +28,10 @@ module Agentf
         case command
         when "recent", "list"
           list_memories(args)
-        when "pitfalls"
-          list_pitfalls(args)
+        when "episodes"
+          list_episodes(args)
         when "lessons"
           list_lessons(args)
-        when "successes"
-          list_successes(args)
         when "intents"
           list_intents(args)
         when "business-intents"
@@ -44,14 +42,10 @@ module Agentf
           add_business_intent(args)
         when "add-feature-intent"
           add_feature_intent(args)
+        when "add-playbook"
+          add_playbook(args)
         when "add-lesson"
           add_episode("lesson", args)
-        when "add-success"
-          add_episode("success", args)
-        when "add-pitfall"
-          add_episode("pitfall", args)
-        when "tags"
-          list_tags
         when "search"
           search_memories(args)
         when "delete"
@@ -62,8 +56,6 @@ module Agentf
           subgraph(args)
         when "summary", "stats"
           show_summary
-        when "by-tag"
-          by_tag(args)
         when "by-agent"
           by_agent(args)
         when "by-type"
@@ -86,9 +78,10 @@ module Agentf
         output(result)
       end
 
-      def list_pitfalls(args)
+      def list_episodes(args)
         limit = extract_limit(args)
-        result = @reviewer.get_pitfalls(limit: limit)
+        outcome = parse_single_option(args, "--outcome=")
+        result = @reviewer.get_episodes(limit: limit, outcome: outcome)
         output(result)
       end
 
@@ -98,12 +91,6 @@ module Agentf
         output(result)
       end
 
-      def list_successes(args)
-        limit = extract_limit(args)
-        result = @reviewer.get_successes(limit: limit)
-        output(result)
-      end
-
       def list_intents(args)
         limit = extract_limit(args)
         kind = args.shift
@@ -141,16 +128,14 @@ module Agentf
           exit 1
         end
 
-        tags = parse_list_option(args, "--tags=")
         constraints = parse_list_option(args, "--constraints=")
         priority = parse_integer_option(args, "--priority=", default: 1)
 
         id = nil
-        res = safe_cli_memory_write(@memory, attempted: { command: "add-business-intent", args: { title: title, description: description, tags: tags, constraints: constraints, priority: priority } }) do
+        res = safe_cli_memory_write(@memory, attempted: { command: "add-business-intent", args: { title: title, description: description, constraints: constraints, priority: priority } }) do
           id = @memory.store_business_intent(
             title: title,
             description: description,
-            tags: tags,
             constraints: constraints,
             priority: priority
           )
@@ -181,17 +166,15 @@ module Agentf
           exit 1
         end
 
-        tags = parse_list_option(args, "--tags=")
         acceptance_criteria = parse_list_option(args, "--acceptance=")
         non_goals = parse_list_option(args, "--non-goals=")
         related_task_id = parse_single_option(args, "--task=")
 
         id = nil
-        res = safe_cli_memory_write(@memory, attempted: { command: "add-feature-intent", args: { title: title, description: description, tags: tags, acceptance: acceptance_criteria, non_goals: non_goals, related_task_id: related_task_id } }) do
+        res = safe_cli_memory_write(@memory, attempted: { command: "add-feature-intent", args: { title: title, description: description, acceptance: acceptance_criteria, non_goals: non_goals, related_task_id: related_task_id } }) do
           id = @memory.store_feature_intent(
             title: title,
             description: description,
-            tags: tags,
             acceptance_criteria: acceptance_criteria,
             non_goals: non_goals,
             related_task_id: related_task_id
@@ -214,6 +197,46 @@ module Agentf
         end
       end
 
+      def add_playbook(args)
+        title = args.shift
+        description = args.shift
+
+        if title.to_s.empty? || description.to_s.empty?
+          $stderr.puts "Error: add-playbook requires <title> <description>"
+          exit 1
+        end
+
+        steps = parse_list_option(args, "--steps=")
+        feature_area = parse_single_option(args, "--feature-area=")
+        agent = parse_single_option(args, "--agent=") || Agentf::AgentRoles::PLANNER
+
+        id = nil
+        res = safe_cli_memory_write(@memory, attempted: { command: "add-playbook", args: { title: title, description: description, steps: steps, feature_area: feature_area, agent: agent } }) do
+          id = @memory.store_playbook(
+            title: title,
+            description: description,
+            steps: steps,
+            feature_area: feature_area,
+            agent: agent
+          )
+        end
+
+        if res.is_a?(Hash) && res["confirmation_required"]
+          if @json_output
+            puts JSON.generate(res)
+          else
+            $stderr.puts "Confirmation required to store playbook: #{res['confirmation_details'].inspect}"
+          end
+          return
+        end
+
+        if @json_output
+          puts JSON.generate({ "id" => id, "type" => "playbook", "status" => "stored" })
+        else
+          puts "Stored playbook: #{id}"
+        end
+      end
+
       def add_episode(type, args)
         title = args.shift
         description = args.shift
@@ -223,21 +246,21 @@ module Agentf
           exit 1
         end
 
-        tags = parse_list_option(args, "--tags=")
         context = parse_single_option(args, "--context=").to_s
         agent = parse_single_option(args, "--agent=") || Agentf::AgentRoles::ENGINEER
         code_snippet = parse_single_option(args, "--code=").to_s
+        outcome = parse_single_option(args, "--outcome=")
 
         id = nil
-        res = safe_cli_memory_write(@memory, attempted: { command: "add-#{type}", args: { title: title, description: description, tags: tags, context: context, agent: agent, code: code_snippet } }) do
+        res = safe_cli_memory_write(@memory, attempted: { command: "add-#{type}", args: { title: title, description: description, context: context, agent: agent, code: code_snippet, outcome: outcome } }) do
           id = @memory.store_episode(
             type: type,
             title: title,
             description: description,
             context: context,
-            tags: tags,
             agent: agent,
-            code_snippet: code_snippet
+            code_snippet: code_snippet,
+            outcome: outcome
           )
         end
 
@@ -273,21 +296,6 @@ module Agentf
         end
       end
 
-      def list_tags
-        result = @reviewer.get_all_tags
-        if @json_output
-          puts JSON.generate(result)
-          return
-        end
-
-        if result["tags"].empty?
-          puts "No tags found."
-        else
-          puts "Tags (#{result["count"]}):"
-          result["tags"].each { |tag| puts "  - #{tag}" }
-        end
-      end
-
       def search_memories(args)
         # Extract limit BEFORE joining remaining args as query (fixes finding #7)
         limit = extract_limit(args)
@@ -318,19 +326,12 @@ module Agentf
         puts ""
         puts "By agent:"
         result["by_agent"].each { |agent, count| puts "  #{agent}: #{count}" }
-        puts ""
-        puts "Unique tags: #{result["unique_tags"]}"
-      end
 
-      def by_tag(args)
-        tag = args.shift
-        if tag.nil? || tag.empty?
-          $stderr.puts "Error: by-tag requires a tag name"
-          exit 1
+        if result["by_outcome"].is_a?(Hash)
+          puts ""
+          puts "By outcome:"
+          result["by_outcome"].each { |outcome, count| puts "  #{outcome}: #{count}" }
         end
-        limit = extract_limit(args)
-        result = @reviewer.get_by_tag(tag, limit: limit)
-        output(result)
       end
 
       def by_agent(args)
@@ -540,8 +541,8 @@ module Agentf
           [#{mem["type"]&.upcase}] #{mem["title"]}
           #{mem["created_at"]} by #{mem["agent"]}
           #{mem["description"]}
+          #{"Outcome: #{mem['outcome']}" unless mem["outcome"].to_s.empty?}
           #{format_code(mem["code_snippet"]) unless mem["code_snippet"].to_s.empty?}
-          Tags: #{mem["tags"]&.join(", ") || "none"}
         OUTPUT
       end
 
@@ -557,26 +558,22 @@ module Agentf
 
           Commands:
             recent, list              List recent memories (default: 10)
-            pitfalls                  List pitfalls (things that went wrong)
+            episodes                  List episode memories
             lessons                   List lessons learned
-            successes                 List successes
             intents [kind]            List intents (kind: business|feature)
             business-intents          List business intents
             feature-intents           List feature intents
             add-business-intent       Store business intent
             add-feature-intent        Store feature intent
+            add-playbook              Store playbook memory
             add-lesson                Store lesson memory
-            add-success               Store success memory
-            add-pitfall               Store pitfall memory
-            tags                      List all unique tags
-            search <query>            Search memories by keyword
+            search <query>            Search memories semantically
             delete id <memory_id>     Delete one memory and related edges
             delete last -n <count>    Delete most recent memories
             delete all                Delete memories and graph/task keys
             neighbors <id>            Traverse graph edges from a memory id
             subgraph <ids>            Build graph from comma-separated seed ids
             summary, stats            Show summary statistics
-            by-tag <tag>              Get memories with specific tag
             by-agent <agent>          Get memories from specific agent
             by-type <type>            Get memories by type (#{VALID_EPISODE_TYPES.join("|")})
 
@@ -586,18 +583,17 @@ module Agentf
 
           Examples:
             agentf memory recent -n 5
-            agentf memory pitfalls
+            agentf memory episodes --outcome=negative
             agentf memory intents business -n 5
-            agentf memory add-business-intent "Reliability" "Prioritize uptime" --tags=ops,platform --constraints="No downtime;No vendor lock-in"
+            agentf memory add-business-intent "Reliability" "Prioritize uptime" --constraints="No downtime;No vendor lock-in"
             agentf memory add-feature-intent "Agent handoff" "Improve orchestrator continuity" --acceptance="Keeps context;Preserves task state"
-            agentf memory add-lesson "Refactor strategy" "Extracted adapter seam" --agent=PLANNER --tags=architecture
-            agentf memory add-success "Provider install works" "Installed copilot + opencode manifests" --agent=ENGINEER
+            agentf memory add-playbook "Release rollout" "Safe deploy sequence" --steps="deploy canary;monitor;promote"
+            agentf memory add-lesson "Refactor strategy" "Extracted adapter seam" --agent=PLANNER
             agentf memory search "react"
             agentf memory delete id episode_abcd
             agentf memory delete last -n 10 --scope=project
             agentf memory delete all --scope=all --yes
             agentf memory neighbors episode_abcd --depth=2
-            agentf memory by-tag "performance"
             agentf memory summary
         HELP
       end

data/lib/agentf/cli/router.rb

@@ -75,7 +75,7 @@ module Agentf
           Usage: agentf <command> [subcommand] [options]
 
           Commands:
-            memory       Manage agent memory (lessons, pitfalls, successes, intents)
+            memory       Manage agent memory (episodes, lessons, playbooks, intents)
             code         Explore codebase (glob, grep, tree, related files)
             metrics      Show workflow success and provider parity metrics
             architecture Analyze architecture layers and violations