agentf 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ace5a58ed6bfb8389d1e7a68349d7cc9f8d80b4093131a8cf2013388b001a08d
-  data.tar.gz: ba9a86b1c4b9e7e7edf62bed089d5cb3a1dddb9c5b4282c16e9be27438fec088
+  metadata.gz: 9d0041ebcd3b112183ddb349312e4cab8d30237ed1108dbb55d928c525dd59ae
+  data.tar.gz: 2577b0dc7af10255d02d2dde419aaa8e1135aea4e36dd67cc10b5d55b1866ba6
 SHA512:
-  metadata.gz: 35767581d0b7561c1800464909dbf00524724527148b20f4f1ab911d846301d1a60333e8703d7b3db04e7d3d34e1a977d522fef236f8899692ae8a8c2bac65ad
-  data.tar.gz: 8d61e62517723d4bc4d39905dfb87b792d27ba1bfbe2b1eb6c445409b138091d072413ad21bffbe2cd584887d9a75f798df64f79601594ccb1029e9db54439f1
+  metadata.gz: ceae3f4d97e84e9934eae6591b7a2be4ea6ed56e31f4555110f998a2f3551f8231572a8c56dd790815988772ad8f4584f5d043d0283828665bcb69ad033d9ef2
+  data.tar.gz: 2ff0e3ece10105b6632ebd8e34c5b78c870dc6b8e105dabc41bc7f472502a8c33aee1dc7d10f14fa0ffaea513553c24f1353a9bda7a6647117f200cf8a43de88

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
@@ -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/designer.rb

@@ -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

data/lib/agentf/agents/specialist.rb

@@ -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 })
 

data/lib/agentf/agents/tester.rb

@@ -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

data/lib/agentf/cli/memory.rb

@@ -12,6 +12,7 @@ module Agentf
     #   - by_type accepts business_intent and feature_intent (finding #11)
     class Memory
       include ArgParser
+      include Agentf::Memory::ConfirmationHandler
 
       VALID_EPISODE_TYPES = %w[episode lesson playbook business_intent feature_intent incident].freeze
 
@@ -38,6 +39,10 @@ module Agentf
           list_business_intents(args)
         when "feature-intents"
           list_feature_intents(args)
+        when "add-intent"
+          add_intent(args)
+        when "add-episode"
+          add_episode_direct(args)
         when "add-business-intent"
           add_business_intent(args)
         when "add-feature-intent"
@@ -119,6 +124,24 @@ module Agentf
         output(@reviewer.get_feature_intents(limit: limit))
       end
 
+      def add_intent(args)
+        kind = args.shift.to_s.downcase
+        unless %w[business feature].include?(kind)
+          $stderr.puts "Error: add-intent requires kind (business|feature) as first argument"
+          exit 1
+        end
+        kind == "business" ? add_business_intent(args) : add_feature_intent(args)
+      end
+
+      def add_episode_direct(args)
+        type = args.shift.to_s
+        unless VALID_EPISODE_TYPES.include?(type)
+          $stderr.puts "Error: add-episode requires type as first argument (#{VALID_EPISODE_TYPES.join('|')})"
+          exit 1
+        end
+        add_episode(type, args)
+      end
+
       def add_business_intent(args)
         title = args.shift
         description = args.shift
@@ -132,7 +155,7 @@ module Agentf
         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, constraints: constraints, priority: priority } }) do
+        res = safe_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,
@@ -171,7 +194,7 @@ module Agentf
         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, acceptance: acceptance_criteria, non_goals: non_goals, related_task_id: related_task_id } }) do
+        res = safe_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,
@@ -211,7 +234,7 @@ module Agentf
         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
+        res = safe_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,
@@ -252,7 +275,7 @@ module Agentf
         outcome = parse_single_option(args, "--outcome=")
 
         id = nil
-        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
+        res = safe_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,
@@ -280,22 +303,6 @@ module Agentf
         end
       end
 
-      # Helper to standardize CLI memory write confirmation handling.
-      def safe_cli_memory_write(memory, attempted: {})
-        begin
-          yield
-          nil
-        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
-          {
-            "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 command with confirmation enabled. If they decline, do not retry."
-          }
-        end
-      end
-
       def search_memories(args)
         # Extract limit BEFORE joining remaining args as query (fixes finding #7)
         limit = extract_limit(args)
@@ -561,10 +568,8 @@ module Agentf
             episodes                  List episode memories
             lessons                   List lessons learned
             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-intent <kind>         Store intent (kind: business|feature)
+            add-episode <type>        Store episode (type: #{VALID_EPISODE_TYPES.join("|")}) with --outcome=
             add-playbook              Store playbook memory
             add-lesson                Store lesson memory
             search <query>            Search memories semantically
@@ -585,11 +590,13 @@ module Agentf
             agentf memory recent -n 5
             agentf memory episodes --outcome=negative
             agentf memory intents business -n 5
-            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-intent business "Reliability" "Prioritize uptime" --constraints="No downtime;No vendor lock-in"
+            agentf memory add-intent feature "Agent handoff" "Improve continuity" --acceptance="Keeps context;Preserves task state"
+            agentf memory add-episode lesson "Refactor strategy" "Extracted adapter seam" --agent=PLANNER --outcome=positive
+            agentf memory add-episode incident "Auth regression" "JWT expiry not checked" --outcome=negative
             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 search "react" --type=lesson --outcome=positive
             agentf memory delete id episode_abcd
             agentf memory delete last -n 10 --scope=project
             agentf memory delete all --scope=all --yes

data/lib/agentf/commands/memory_reviewer.rb

@@ -19,6 +19,7 @@ module Agentf
             { "name" => "get_lessons", "type" => "function" },
             { "name" => "get_by_type", "type" => "function" },
             { "name" => "get_by_agent", "type" => "function" },
+            { "name" => "get_intents", "type" => "function" },
             { "name" => "search", "type" => "function" },
             { "name" => "get_summary", "type" => "function" },
             { "name" => "neighbors", "type" => "function" },
@@ -87,16 +88,15 @@ module Agentf
 
       # Get memories by agent
       def get_by_agent(agent, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        filtered = memories.select { |m| m["agent"] == agent }
-        format_memories(filtered.first(limit))
+        memories = @memory.get_memories_by_agent(agent: agent, limit: limit)
+        format_memories(memories)
       rescue => e
         { "error" => e.message }
       end
 
-      # Search memories by keyword in title or description
-      def search(query, limit: 10)
-        format_memories(@memory.search_memories(query: query, limit: limit))
+      # Search memories semantically with optional type, agent, and outcome filters
+      def search(query, limit: 10, type: nil, agent: nil, outcome: nil)
+        format_memories(@memory.search_memories(query: query, limit: limit, type: type, agent: agent, outcome: outcome))
       rescue => e
         { "error" => e.message }
       end

data/lib/agentf/installer.rb

@@ -150,7 +150,7 @@ module Agentf
 
       classes.map do |klass|
         target = File.join(root, layout.fetch("agents_dir"), layout.fetch("agent_filename").call(klass))
-        write_manifest(target, render_agent_manifest(klass, provider: provider))
+        write_manifest(target, render_agent_manifest(klass))
       end
     end
 
@@ -160,7 +160,7 @@ module Agentf
 
       manifests.map do |manifest|
         target = File.join(root, layout.fetch("commands_dir"), layout.fetch("command_filename").call(manifest))
-        write_manifest(target, render_command_manifest(manifest, provider: provider))
+        write_manifest(target, render_command_manifest(manifest))
       end
     end
 
@@ -237,7 +237,7 @@ module Agentf
       end
     end
 
-    def render_agent_manifest(klass, provider:)
+    def render_agent_manifest(klass)
       # Emit a minimal, stable manifest that acts as a pointer to the runtime
       # tool implemented by the plugin/CLI. Keep filename and `name` stable so
       # upgrades remain compatible with existing installs.
@@ -257,6 +257,9 @@ module Agentf
 
       description = klass.respond_to?(:description) ? klass.description.to_s.strip : ""
 
+      tdd_section = klass.respond_to?(:writes_code?) && klass.writes_code? ? tdd_requirement_section : ""
+      fallback = cli_fallback_section(klass)
+
       <<~MARKDOWN
         ---
         name: #{tool_name}
@@ -273,7 +276,50 @@ module Agentf
         do not retry the write.
 
         Policy Summary: #{policy_summary}
+        #{tdd_section}#{fallback}
+      MARKDOWN
+    end
+
+    def tdd_requirement_section
+      <<~MARKDOWN
+
+        ## TDD Requirement
+
+        This agent writes code. Every implementation MUST follow red/green discipline:
+
+        1. **Write the spec first** — create a failing test before any implementation code
+        2. **Run tests to confirm red** — verify the spec fails (`bundle exec rspec <spec_file>`)
+        3. **Implement the code** — write only enough to make the spec pass
+        4. **Run tests to confirm green** — verify all specs pass before reporting done
+        5. **Never skip** — do not create a class, method, or module without a corresponding spec file
+
+        Showing test output (red then green) is mandatory evidence of completion.
+      MARKDOWN
+    end
+
+    def cli_fallback_section(klass)
+      agent_name = klass.typed_name.downcase
+      read_cmds = READ_ACTIONS.values_at("get_recent_memories", "search").map { |a| "- `#{a[:cli]}`" }.join("\n")
+
+      write_actions = Array(klass.respond_to?(:memory_concepts) ? klass.memory_concepts["writes"] : [])
+        .map { |item| item.to_s.split("#").last }
+        .filter_map { |key| WRITE_ACTIONS[key] }
+        .map { |a| "- `#{a[:cli].gsub("<AGENT>", agent_name.upcase)}`" }
+        .join("\n")
 
+      write_section = write_actions.empty? ? "" : "\n**Memory writes**:\n#{write_actions}\n"
+
+      <<~MARKDOWN
+
+        ## CLI Fallback
+
+        If the `agentf` MCP server is unavailable, run equivalent commands directly in the terminal:
+
+        **Run this agent**: `agentf agent #{agent_name} "<input>"`
+
+        **Memory reads**:
+        #{read_cmds}
+        #{write_section}
       MARKDOWN
     end
 
@@ -329,9 +375,10 @@ module Agentf
       "agentf-#{name.to_s.downcase}"
     end
 
-    def render_command_manifest(manifest, provider:)
+    def render_command_manifest(manifest)
       cmd_name = command_identifier(manifest.fetch("name"))
       desc = manifest.fetch("description", "").to_s.strip
+      fallback = command_cli_fallback_section(manifest)
 
       <<~MARKDOWN
         ---
@@ -342,7 +389,45 @@ module Agentf
 
         IMPORTANT: Do not embed runtime logic here. Invoke the `#{cmd_name}` tool to perform
         any codebase or memory operations.
+        #{fallback}
+      MARKDOWN
+    end
+
+    def command_cli_fallback_section(manifest)
+      name = manifest.fetch("name")
+      cli_lines = case name
+                  when "explorer"
+                    [
+                      "`agentf code glob \"<pattern>\"`",
+                      "`agentf code grep \"<pattern>\"`",
+                      "`agentf code tree --depth=3`",
+                      "`agentf code related <file>`"
+                    ]
+                  when "memory"
+                    [
+                      "`#{READ_ACTIONS.fetch('get_recent_memories')[:cli]}`",
+                      "`#{READ_ACTIONS.fetch('search')[:cli]}`",
+                      "`#{READ_ACTIONS.fetch('get_episodes')[:cli]}`",
+                      "`#{WRITE_ACTIONS.fetch('store_lesson')[:cli]}`",
+                      "`#{WRITE_ACTIONS.fetch('store_episode')[:cli]}`"
+                    ]
+                  else
+                    [
+                      "`agentf code glob \"<pattern>\"`",
+                      "`#{READ_ACTIONS.fetch('get_recent_memories')[:cli]}`",
+                      "`#{READ_ACTIONS.fetch('search')[:cli]}`"
+                    ]
+                  end
+
+      tool_lines = cli_lines.map { |cmd| "- #{cmd}" }.join("\n")
+
+      <<~MARKDOWN
+
+        ## CLI Fallback
+
+        If the `agentf` MCP server is unavailable, run equivalent commands directly in the terminal:
 
+        #{tool_lines}
       MARKDOWN
     end
 

data/lib/agentf/mcp/server.rb

@@ -20,6 +20,7 @@ module Agentf
     #   AGENTF_MCP_ALLOW_WRITES   - true/false, controls memory write tools
     #   AGENTF_MCP_MAX_ARG_LENGTH - max length per string argument
     class Server
+      include Agentf::Memory::ConfirmationHandler
       ToolDefinition = Struct.new(:name, :description, :arguments, :handler, keyword_init: true)
 
       class ToolBuilder
@@ -189,21 +190,20 @@ module Agentf
         agentf-memory-episodes
         agentf-memory-lessons
         agentf-memory-intents
-        agentf-memory-business-intents
-        agentf-memory-feature-intents
+        agentf-memory-summary
         agentf-memory-neighbors
         agentf-memory-subgraph
+        agentf-memory-add-intent
+        agentf-memory-add-episode
         agentf-memory-add-playbook
         agentf-memory-add-lesson
-        agentf-memory-add-business-intent
-        agentf-memory-add-feature-intent
       ].freeze
 
       WRITE_TOOLS = Set.new(%w[
+        agentf-memory-add-intent
+        agentf-memory-add-episode
         agentf-memory-add-playbook
         agentf-memory-add-lesson
-        agentf-memory-add-business-intent
-        agentf-memory-add-feature-intent
       ]).freeze
 
       attr_reader :server, :guardrails
@@ -217,25 +217,6 @@ module Agentf
         @server = build_server
       end
 
-      # Helper to centralize confirmation handling for MCP server write tools.
-      # Yields the block that performs the memory write and returns either the
-      # block result or the normalized confirmation hash produced by
-      # Agentf::Agents::Base#safe_memory_write.
-      def safe_mcp_memory_write(memory, attempted: {})
-        begin
-          yield
-          nil
-        rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
-          {
-            "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, call the same tool again after confirmation. If they decline, do not retry."
-          }
-        end
-      end
-
       # Start the stdio read loop (blocks until stdin closes).
       def run
         @server.run
@@ -388,12 +369,15 @@ module Agentf
         end
 
         s.tool("agentf-memory-search") do
-          description "Search memories semantically."
+          description "Search memories semantically. Supports optional filters for type, agent, and outcome."
           argument :query, String, required: true, description: "Search query"
           argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          argument :type, String, required: false, description: "Filter by type: episode|lesson|playbook|business_intent|feature_intent|incident"
+          argument :agent, String, required: false, description: "Filter by agent name"
+          argument :outcome, String, required: false, description: "Filter by outcome: positive|negative|neutral"
           call do |args|
             mcp_server.send(:guard!, "agentf-memory-search", **args)
-            result = reviewer.search(args[:query], limit: args[:limit] || 10)
+            result = reviewer.search(args[:query], limit: args[:limit] || 10, type: args[:type], agent: args[:agent], outcome: args[:outcome])
             JSON.generate(result)
           end
         end
@@ -442,7 +426,7 @@ module Agentf
         end
 
         s.tool("agentf-memory-intents") do
-          description "List intents (business|feature)."
+          description "List intents (business|feature). Pass kind to filter."
           argument :kind, String, required: false, description: "Optional: business|feature"
           argument :limit, Integer, required: false, description: "How many results to return (1-100)"
           call do |args|
@@ -481,61 +465,85 @@ module Agentf
           end
         end
 
-        s.tool("agentf-memory-add-business-intent") do
-          description "Store a business intent in Redis."
+        s.tool("agentf-memory-add-intent") do
+          description "Store a business or feature intent. Pass kind: business or feature."
+          argument :kind, String, required: true, description: "Intent type: business|feature"
           argument :title, String, required: true, description: "Intent title"
           argument :description, String, required: true, description: "Intent description"
-          argument :constraints, Array, required: false, items: String, description: "Constraints"
-          argument :priority, Integer, required: false, description: "Priority"
+          argument :constraints, Array, required: false, items: String, description: "Business intent constraints"
+          argument :priority, Integer, required: false, description: "Business intent priority"
+          argument :acceptance, Array, required: false, items: String, description: "Feature intent acceptance criteria"
+          argument :non_goals, Array, required: false, items: String, description: "Feature intent non-goals"
+          argument :related_task_id, String, required: false, description: "Related task id (feature intents)"
           call do |args|
-            mcp_server.send(:guard!, "agentf-memory-add-business-intent", **args)
-              begin
-                id = nil
-                res = mcp_server.send(:safe_mcp_memory_write, memory, attempted: { tool: "agentf-memory-add-business-intent", args: args }) do
-                  id = memory.store_business_intent(
-                    title: args[:title],
-                    description: args[:description],
-                    constraints: args[:constraints] || [],
-                    priority: args[:priority] || 1
-                  )
-                end
-
-                if res.is_a?(Hash) && res["confirmation_required"]
-                  JSON.generate(confirmation_required: true, confirmation_details: res["confirmation_details"], attempted: res["attempted"])
-                else
-                  JSON.generate(id: id, type: "business_intent", status: "stored")
-                end
-              end
+            mcp_server.send(:guard!, "agentf-memory-add-intent", **args)
+            id = nil
+            kind = args[:kind].to_s.downcase
+            res = mcp_server.send(:safe_memory_write, memory, attempted: { tool: "agentf-memory-add-intent", args: args }) do
+              id = case kind
+                   when "business"
+                     memory.store_business_intent(
+                       title: args[:title],
+                       description: args[:description],
+                       constraints: args[:constraints] || [],
+                       priority: args[:priority] || 1
+                     )
+                   when "feature"
+                     memory.store_feature_intent(
+                       title: args[:title],
+                       description: args[:description],
+                       acceptance_criteria: args[:acceptance] || [],
+                       non_goals: args[:non_goals] || [],
+                       related_task_id: args[:related_task_id]
+                     )
+                   else
+                     raise ArgumentError, "kind must be business or feature, got: #{kind}"
+                   end
+            end
+            if res.is_a?(Hash) && res["confirmation_required"]
+              JSON.generate(confirmation_required: true, confirmation_details: res["confirmation_details"], attempted: res["attempted"])
+            else
+              JSON.generate(id: id, type: "#{kind}_intent", status: "stored")
+            end
           end
         end
 
-        s.tool("agentf-memory-add-feature-intent") do
-          description "Store a feature intent in Redis."
-          argument :title, String, required: true, description: "Intent title"
-          argument :description, String, required: true, description: "Intent description"
-          argument :acceptance, Array, required: false, items: String, description: "Acceptance criteria"
-          argument :non_goals, Array, required: false, items: String, description: "Non-goals"
-          argument :related_task_id, String, required: false, description: "Related task id"
+        s.tool("agentf-memory-add-episode") do
+          description "Store a memory episode with type and outcome (type: episode|lesson|incident|playbook, outcome: positive|negative|neutral)."
+          argument :type, String, required: true, description: "Episode type: episode|lesson|incident|playbook"
+          argument :title, String, required: true, description: "Episode title"
+          argument :description, String, required: true, description: "Episode description"
+          argument :outcome, String, required: false, description: "Outcome: positive|negative|neutral"
+          argument :agent, String, required: false, description: "Agent name"
+          argument :context, String, required: false, description: "Additional context"
+          argument :code_snippet, String, required: false, description: "Code snippet"
           call do |args|
-            mcp_server.send(:guard!, "agentf-memory-add-feature-intent", **args)
-              begin
-                id = nil
-                res = mcp_server.send(:safe_mcp_memory_write, memory, attempted: { tool: "agentf-memory-add-feature-intent", args: args }) do
-                  id = memory.store_feature_intent(
-                    title: args[:title],
-                    description: args[:description],
-                    acceptance_criteria: args[:acceptance] || [],
-                    non_goals: args[:non_goals] || [],
-                    related_task_id: args[:related_task_id]
-                  )
-                end
+            mcp_server.send(:guard!, "agentf-memory-add-episode", **args)
+            id = nil
+            res = mcp_server.send(:safe_memory_write, memory, attempted: { tool: "agentf-memory-add-episode", args: args }) do
+              id = memory.store_episode(
+                type: args[:type],
+                title: args[:title],
+                description: args[:description],
+                outcome: args[:outcome],
+                agent: args[:agent] || Agentf::AgentRoles::ENGINEER,
+                context: args[:context].to_s,
+                code_snippet: args[:code_snippet].to_s
+              )
+            end
+            if res.is_a?(Hash) && res["confirmation_required"]
+              JSON.generate(confirmation_required: true, confirmation_details: res["confirmation_details"], attempted: res["attempted"])
+            else
+              JSON.generate(id: id, type: args[:type], status: "stored")
+            end
+          end
+        end
 
-                if res.is_a?(Hash) && res["confirmation_required"]
-                  JSON.generate(confirmation_required: true, confirmation_details: res["confirmation_details"], attempted: res["attempted"])
-                else
-                  JSON.generate(id: id, type: "feature_intent", status: "stored")
-                end
-              end
+        s.tool("agentf-memory-summary") do
+          description "Get summary statistics: counts of memories by type, agent, and outcome."
+          call do |_args|
+            mcp_server.send(:guard!, "agentf-memory-summary")
+            JSON.generate(reviewer.get_summary)
           end
         end
 
@@ -602,7 +610,7 @@ module Agentf
             mcp_server.send(:guard!, "agentf-memory-add-lesson", **args)
               begin
                 id = nil
-                res = mcp_server.send(:safe_mcp_memory_write, memory, attempted: { tool: "agentf-memory-add-lesson", args: args }) do
+                res = mcp_server.send(:safe_memory_write, memory, attempted: { tool: "agentf-memory-add-lesson", args: args }) do
                   id = memory.store_episode(
                     type: "lesson",
                     title: args[:title],
@@ -639,7 +647,7 @@ module Agentf
             mcp_server.send(:guard!, "agentf-memory-add-playbook", **args)
               begin
                 id = nil
-                res = mcp_server.send(:safe_mcp_memory_write, memory, attempted: { tool: "agentf-memory-add-playbook", args: args }) do
+                res = mcp_server.send(:safe_memory_write, memory, attempted: { tool: "agentf-memory-add-playbook", args: args }) do
                   id = memory.store_playbook(
                     title: args[:title],
                     description: args[:description],

data/lib/agentf/memory/confirmation_handler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Agentf
+  module Memory
+    module ConfirmationHandler
+      # Wraps a memory write block and normalizes ConfirmationRequired into a
+      # structured hash so callers (MCP server, CLI, agents) can handle it
+      # uniformly. The optional `_memory` arg is accepted for call-site
+      # readability but is not used by this method.
+      def safe_memory_write(_memory = nil, attempted: {})
+        yield
+        nil
+      rescue Agentf::Memory::RedisMemory::ConfirmationRequired => e
+        {
+          "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."
+        }
+      end
+    end
+  end
+end

data/lib/agentf/memory.rb

@@ -282,6 +282,12 @@ module Agentf
         end
       end
 
+      def get_memories_by_agent(agent:, limit: 10)
+        collect_episode_records(scope: "project", agent: agent)
+          .sort_by { |mem| -(mem["created_at"] || 0) }
+          .first(limit)
+      end
+
       def get_intents(kind: nil, limit: 10)
         return get_memories_by_type(type: "business_intent", limit: limit) if kind == "business"
         return get_memories_by_type(type: "feature_intent", limit: limit) if kind == "feature"

data/lib/agentf/version.rb

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

data/lib/agentf.rb

@@ -83,6 +83,7 @@ end
 
 # Load submodules
 require_relative "agentf/memory"
+require_relative "agentf/memory/confirmation_handler"
 require_relative "agentf/tools"
 require_relative "agentf/commands"
 require_relative "agentf/commands/registry"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agentf
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Neal Deters
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-20 00:00:00.000000000 Z
+date: 2026-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -137,6 +137,7 @@ files:
 - lib/agentf/mcp/server.rb
 - lib/agentf/mcp/stub.rb
 - lib/agentf/memory.rb
+- lib/agentf/memory/confirmation_handler.rb
 - lib/agentf/service/providers.rb
 - lib/agentf/tools.rb
 - lib/agentf/tools/component_spec.rb