agentf 0.5.0 → 0.6.0

data/lib/agentf/commands/memory_reviewer.rb

@@ -12,14 +12,11 @@ module Agentf
       def self.manifest
         {
           "name" => NAME,
-          "description" => "Review and query Redis-stored memories, pitfalls, and learnings.",
+          "description" => "Review and query Redis-stored memories, episodes, and learnings.",
           "commands" => [
             { "name" => "get_recent_memories", "type" => "function" },
-            { "name" => "get_pitfalls", "type" => "function" },
+            { "name" => "get_episodes", "type" => "function" },
             { "name" => "get_lessons", "type" => "function" },
-            { "name" => "get_successes", "type" => "function" },
-            { "name" => "get_all_tags", "type" => "function" },
-            { "name" => "get_by_tag", "type" => "function" },
             { "name" => "get_by_type", "type" => "function" },
             { "name" => "get_by_agent", "type" => "function" },
             { "name" => "search", "type" => "function" },
@@ -44,10 +41,9 @@ module Agentf
         { "error" => e.message }
       end
 
-      # Get all pitfalls (things that went wrong)
-      def get_pitfalls(limit: 10)
-        pitfalls = @memory.get_pitfalls(limit: limit)
-        format_memories(pitfalls)
+      def get_episodes(limit: 10, outcome: nil)
+        episodes = @memory.get_episodes(limit: limit, outcome: outcome)
+        format_memories(episodes)
       rescue => e
         { "error" => e.message }
       end
@@ -60,14 +56,6 @@ module Agentf
         { "error" => e.message }
       end
 
-      # Get all successes
-      def get_successes(limit: 10)
-        successes = @memory.get_memories_by_type(type: "success", limit: limit)
-        format_memories(successes)
-      rescue => e
-        { "error" => e.message }
-      end
-
       def get_business_intents(limit: 10)
         intents = @memory.get_intents(kind: "business", limit: limit)
         format_memories(intents)
@@ -89,28 +77,10 @@ module Agentf
         { "error" => e.message }
       end
 
-      # Get all unique tags from memories
-      def get_all_tags
-        tags = @memory.get_all_tags
-        { "tags" => tags.sort, "count" => tags.length }
-      rescue => e
-        { "error" => e.message }
-      end
-
-      # Get memories by tag
-      def get_by_tag(tag, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        filtered = memories.select { |m| m["tags"]&.include?(tag) }
-        format_memories(filtered.first(limit))
-      rescue => e
-        { "error" => e.message }
-      end
-
       # Get memories by type (pitfall, lesson, success)
       def get_by_type(type, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        filtered = memories.select { |m| m["type"] == type }
-        format_memories(filtered.first(limit))
+        memories = @memory.get_memories_by_type(type: type, limit: limit)
+        format_memories(memories)
       rescue => e
         { "error" => e.message }
       end
@@ -126,14 +96,7 @@ module Agentf
 
       # Search memories by keyword in title or description
       def search(query, limit: 10)
-        memories = @memory.get_recent_memories(limit: 100)
-        q = query.downcase
-        filtered = memories.select do |m|
-          m["title"]&.downcase&.include?(q) ||
-            m["description"]&.downcase&.include?(q) ||
-            m["context"]&.downcase&.include?(q)
-        end
-        format_memories(filtered.first(limit))
+        format_memories(@memory.search_memories(query: query, limit: limit))
       rescue => e
         { "error" => e.message }
       end
@@ -141,19 +104,22 @@ module Agentf
       # Get summary statistics
       def get_summary
         memories = @memory.get_recent_memories(limit: 100)
-        tags = @memory.get_all_tags
 
         {
           "total_memories" => memories.length,
           "by_type" => {
-            "pitfall" => memories.count { |m| m["type"] == "pitfall" },
+            "episode" => memories.count { |m| m["type"] == "episode" },
             "lesson" => memories.count { |m| m["type"] == "lesson" },
-            "success" => memories.count { |m| m["type"] == "success" },
+            "playbook" => memories.count { |m| m["type"] == "playbook" },
             "business_intent" => memories.count { |m| m["type"] == "business_intent" },
             "feature_intent" => memories.count { |m| m["type"] == "feature_intent" }
           },
+          "by_outcome" => {
+            "positive" => memories.count { |m| m["outcome"] == "positive" },
+            "negative" => memories.count { |m| m["outcome"] == "negative" },
+            "neutral" => memories.count { |m| m["outcome"] == "neutral" }
+          },
           "by_agent" => memories.each_with_object(Hash.new(0)) { |m, h| h[m["agent"]] += 1 },
-          "unique_tags" => tags.length,
           "project" => @project
         }
       rescue => e
@@ -189,7 +155,7 @@ module Agentf
           "description" => m["description"],
           "context" => m["context"],
           "code_snippet" => m["code_snippet"],
-          "tags" => m["tags"],
+          "outcome" => m["outcome"],
           "agent" => m["agent"],
           "metadata" => m["metadata"],
           "entity_ids" => m["entity_ids"],

data/lib/agentf/commands/metrics.rb

@@ -7,8 +7,6 @@ module Agentf
     class Metrics
       NAME = "metrics"
 
-      WORKFLOW_METRICS_TAG = "workflow_metric"
-
       def self.manifest
         {
           "name" => NAME,
@@ -30,12 +28,13 @@ module Agentf
         metrics = extract_metrics(workflow_state)
         begin
           @memory.store_episode(
-            type: "success",
+            type: "episode",
             title: metric_title(metrics),
             description: metric_description(metrics),
             context: metric_context(metrics),
-            tags: metric_tags(metrics),
             agent: Agentf::AgentRoles::ORCHESTRATOR,
+            outcome: "positive",
+            metadata: { "workflow_metric" => true },
             code_snippet: ""
           )
           { "status" => "recorded", "metrics" => metrics }
@@ -171,14 +170,6 @@ module Agentf
         }.to_json
       end
 
-      def metric_tags(metrics)
-        [
-          WORKFLOW_METRICS_TAG,
-          "provider:#{metrics['provider'].to_s.downcase}",
-          "workflow:#{metrics['workflow_type']}"
-        ]
-      end
-
       def top_contract_violations(records)
         counts = Hash.new(0)
         records.each do |record|
@@ -191,7 +182,7 @@ module Agentf
         memories = @memory.get_recent_memories(limit: limit)
 
         memories
-          .select { |m| Array(m["tags"]).include?(WORKFLOW_METRICS_TAG) }
+          .select { |m| m.dig("metadata", "workflow_metric") == true }
           .map do |m|
             context = parse_context_json(m["context"])
             context

data/lib/agentf/context_builder.rb

@@ -2,8 +2,9 @@
 
 module Agentf
   class ContextBuilder
-    def initialize(memory:)
+    def initialize(memory:, embedding_provider: Agentf::EmbeddingProvider.new)
       @memory = memory
+      @embedding_provider = embedding_provider
     end
 
     def build(agent:, workflow_state:, limit: 8)
@@ -13,23 +14,12 @@ module Agentf
       @memory.get_agent_context(
         agent: agent,
         task_type: task_type,
-        query_embedding: simple_embedding(task),
+        query_text: task,
+        query_embedding: @embedding_provider.embed(task),
         limit: limit
       )
     rescue StandardError
       { "agent" => agent, "intent" => [], "memories" => [], "similar_tasks" => [] }
     end
-
-    private
-
-    def simple_embedding(text)
-      normalized = text.to_s.downcase
-      [
-        normalized.include?("fix") || normalized.include?("bug") ? 1.0 : 0.0,
-        normalized.include?("feature") || normalized.include?("add") ? 1.0 : 0.0,
-        normalized.include?("security") ? 1.0 : 0.0,
-        normalized.length.to_f / 100.0
-      ]
-    end
   end
 end

data/lib/agentf/embedding_provider.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Agentf
+  class EmbeddingProvider
+    DIMENSIONS = 64
+
+    def initialize(dimensions: DIMENSIONS)
+      @dimensions = dimensions
+    end
+
+    def embed(text)
+      tokens = tokenize(text)
+      return [] if tokens.empty?
+
+      vector = Array.new(@dimensions, 0.0)
+      tokens.each do |token|
+        hash = Digest::SHA256.hexdigest(token)[0, 8].to_i(16)
+        vector[hash % @dimensions] += 1.0
+      end
+
+      magnitude = Math.sqrt(vector.sum { |value| value * value })
+      return vector if magnitude.zero?
+
+      vector.map { |value| (value / magnitude).round(8) }
+    end
+
+    private
+
+    def tokenize(text)
+      text.to_s.downcase.scan(/[a-z0-9_]+/).reject { |token| token.length < 2 }
+    end
+  end
+end

data/lib/agentf/installer.rb

@@ -9,12 +9,9 @@ module Agentf
   class Installer
     READ_ACTIONS = {
       "get_recent_memories" => { cli: "agentf memory recent -n 10", tool: "agentf-memory-recent" },
-      "get_pitfalls" => { cli: "agentf memory pitfalls -n 10", tool: "agentf-memory-recent" },
+      "get_episodes" => { cli: "agentf memory episodes -n 10", tool: "agentf-memory-episodes" },
       "get_lessons" => { cli: "agentf memory lessons -n 10", tool: "agentf-memory-recent" },
-      "get_successes" => { cli: "agentf memory successes -n 10", tool: "agentf-memory-recent" },
       "get_intents" => { cli: "agentf memory intents", tool: "agentf-memory-recent" },
-      "get_all_tags" => { cli: "agentf memory tags", tool: "agentf-memory-recent" },
-      "get_by_tag" => { cli: "agentf memory by-tag <tag> -n 10", tool: "agentf-memory-search" },
       "get_by_type" => { cli: "agentf memory by-type <type> -n 10", tool: "agentf-memory-search" },
       "get_by_agent" => { cli: "agentf memory by-agent <agent> -n 10", tool: "agentf-memory-search" },
       "search" => { cli: "agentf memory search \"<query>\" -n 10", tool: "agentf-memory-search" },
@@ -22,10 +19,10 @@ module Agentf
     }.freeze
 
     WRITE_ACTIONS = {
-      "store_lesson" => { cli: "agentf memory add-lesson \"<title>\" \"<description>\" --agent=<AGENT> --tags=learning", tool: "agentf-memory-add-lesson" },
-      "store_success" => { cli: "agentf memory add-success \"<title>\" \"<description>\" --agent=<AGENT> --tags=success", tool: "agentf-memory-add-success" },
-      "store_pitfall" => { cli: "agentf memory add-pitfall \"<title>\" \"<description>\" --agent=<AGENT> --tags=pitfall", tool: "agentf-memory-add-pitfall" },
-      "store_business_intent" => { cli: "agentf memory add-business-intent \"<title>\" \"<description>\" --tags=strategy", tool: "agentf-memory-add-business-intent" },
+      "store_lesson" => { cli: "agentf memory add-lesson \"<title>\" \"<description>\" --agent=<AGENT>", tool: "agentf-memory-add-lesson" },
+      "store_episode" => { cli: "agentf memory add-episode \"<title>\" \"<description>\" --outcome=positive --agent=<AGENT>", tool: "agentf-memory-episodes" },
+      "store_playbook" => { cli: "agentf memory add-playbook \"<title>\" \"<description>\" --steps=\"<step1>;<step2>\"", tool: "agentf-memory-add-playbook" },
+      "store_business_intent" => { cli: "agentf memory add-business-intent \"<title>\" \"<description>\"", tool: "agentf-memory-add-business-intent" },
       "store_feature_intent" => { cli: "agentf memory add-feature-intent \"<title>\" \"<description>\" --acceptance=\"<criteria>\"", tool: "agentf-memory-add-feature-intent" }
     }.freeze
 
@@ -84,6 +81,7 @@ module Agentf
         writes.concat(write_agents(root: root, layout: layout, provider: provider, only_agents: only_agents))
         writes.concat(write_commands(root: root, layout: layout, provider: provider, only_commands: only_commands))
         writes.concat(write_opencode_helpers(root: root)) if provider.to_s == "opencode"
+        writes.concat(write_copilot_helpers(root: root)) if provider.to_s == "copilot"
       end
 
       # Optionally install dependencies for opencode helper package.json
@@ -195,6 +193,12 @@ module Agentf
       writes
     end
 
+    def write_copilot_helpers(root:)
+      return [] unless root == @local_root
+
+      [write_copilot_mcp_json(root)]
+    end
+
     def opencode_plugin_runtime?
       @opencode_runtime == "plugin"
     end
@@ -351,8 +355,8 @@ module Agentf
         Copilot should call the local `agentf` MCP server tools for runtime actions.
 
         - Code discovery tools: `agentf-code-glob`, `agentf-code-grep`, `agentf-code-tree`, `agentf-code-related-files`
-        - Memory read tools: `agentf-memory-recent`, `agentf-memory-search`
-        - Memory write tools (if enabled): `agentf-memory-add-lesson`, `agentf-memory-add-success`, `agentf-memory-add-pitfall`
+        - Memory read tools: `agentf-memory-recent`, `agentf-memory-search`, `agentf-memory-episodes`
+        - Memory write tools (if enabled): `agentf-memory-add-lesson`, `agentf-memory-add-playbook`
 
         MCP server is started via `agentf mcp-server` and runs locally over stdio.
       MARKDOWN
@@ -365,8 +369,8 @@ module Agentf
       recommended_tools = case command_name
                            when "explorer"
                              "`agentf-code-glob`, `agentf-code-grep`, `agentf-code-tree`, `agentf-code-related-files`"
-                           when "memory"
-                             "`agentf-memory-recent`, `agentf-memory-search`, `agentf-memory-add-lesson`, `agentf-memory-add-success`, `agentf-memory-add-pitfall`"
+                            when "memory"
+                              "`agentf-memory-recent`, `agentf-memory-search`, `agentf-memory-episodes`, `agentf-memory-add-lesson`, `agentf-memory-add-playbook`"
                            else
                              "`agentf-code-glob`, `agentf-code-grep`, `agentf-memory-recent`, `agentf-memory-search`"
                           end
@@ -401,7 +405,7 @@ module Agentf
         1. Build plan from provider adapter (`Agentf::Service::Providers::OpenCode` or `Agentf::Service::Providers::Copilot`)
         2. Enrich each agent step with brain context from Redis memory
         3. Persist feature intent at workflow start
-        4. Persist lessons/pitfalls from each agent execution
+        4. Persist lessons and negative episodes from each agent execution
         5. Return full workflow state for manual review and future autonomous control
         6. Enforce workflow contract stages (`spec`, `plan`, `execute`, `review`, `finalize`) when enabled
 
@@ -691,17 +695,6 @@ module Agentf
                 return runAgentfCli(context.directory, "memory", "search", [_args.query, "-n", String(limit)]);
               },
             }),
-            "agentf-memory-by-tag": tool({
-              description: "Get Agentf memories by tag.",
-              args: {
-                tag: tool.schema.string().describe("Tag to filter by"),
-                limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
-              },
-              async execute(_args: any, context: any) {
-                const limit = _args.limit ?? 10;
-                return runAgentfCli(context.directory, "memory", "by-tag", [_args.tag, "-n", String(limit)]);
-              },
-            }),
             "agentf-memory-by-agent": tool({
               description: "Get Agentf memories by agent.",
               args: {
@@ -716,7 +709,7 @@ module Agentf
             "agentf-memory-by-type": tool({
               description: "Get Agentf memories by type.",
               args: {
-                type: tool.schema.string().describe("Memory type (pitfall|lesson|success|business_intent|feature_intent)"),
+                type: tool.schema.string().describe("Memory type (episode|lesson|playbook|business_intent|feature_intent|incident)"),
                 limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
               },
               async execute(_args: any, context: any) {
@@ -724,19 +717,17 @@ module Agentf
                 return runAgentfCli(context.directory, "memory", "by-type", [_args.type, "-n", String(limit)]);
               },
             }),
-            "agentf-memory-tags": tool({
-              description: "List all unique memory tags.",
-              args: {},
-              async execute(_args: any, context: any) {
-                return runAgentfCli(context.directory, "memory", "tags", []);
+            "agentf-memory-episodes": tool({
+              description: "List episode memories.",
+              args: {
+                outcome: tool.schema.string().optional().describe("Optional outcome filter (positive|negative|neutral)"),
+                limit: tool.schema.number().int().min(1).max(100).optional(),
               },
-            }),
-            "agentf-memory-pitfalls": tool({
-              description: "List pitfall memories.",
-              args: { limit: tool.schema.number().int().min(1).max(100).optional() },
               async execute(_args: any, context: any) {
                 const limit = _args.limit ?? 10;
-                return runAgentfCli(context.directory, "memory", "pitfalls", ["-n", String(limit)]);
+                const commandArgs = ["-n", String(limit)];
+                if (_args.outcome) commandArgs.push(`--outcome=${_args.outcome}`);
+                return runAgentfCli(context.directory, "memory", "episodes", commandArgs);
               },
             }),
             "agentf-memory-lessons": tool({
@@ -747,14 +738,6 @@ module Agentf
                 return runAgentfCli(context.directory, "memory", "lessons", ["-n", String(limit)]);
               },
             }),
-            "agentf-memory-successes": tool({
-              description: "List success memories.",
-              args: { limit: tool.schema.number().int().min(1).max(100).optional() },
-              async execute(_args: any, context: any) {
-                const limit = _args.limit ?? 10;
-                return runAgentfCli(context.directory, "memory", "successes", ["-n", String(limit)]);
-              },
-            }),
             "agentf-memory-intents": tool({
               description: "List intents (business, feature or both).",
               args: { kind: tool.schema.string().optional(), limit: tool.schema.number().int().min(1).max(100).optional() },
@@ -786,13 +769,11 @@ module Agentf
               args: {
                 title: tool.schema.string(),
                 description: tool.schema.string(),
-                tags: tool.schema.array(tool.schema.string()).optional(),
                 constraints: tool.schema.array(tool.schema.string()).optional(),
                 priority: tool.schema.number().int().optional(),
               },
               async execute(_args: any, context: any) {
                 const commandArgs = [_args.title, _args.description];
-                if (_args.tags?.length) commandArgs.push(`--tags=${_args.tags.join(",")}`);
                 if (_args.constraints?.length) commandArgs.push(`--constraints=${_args.constraints.join(";")}`);
                 if (Number.isInteger(_args.priority)) commandArgs.push(`--priority=${String(_args.priority)}`);
                 return runAgentfCli(context.directory, "memory", "add-business-intent", commandArgs);
@@ -803,14 +784,12 @@ module Agentf
               args: {
                 title: tool.schema.string(),
                 description: tool.schema.string(),
-                tags: tool.schema.array(tool.schema.string()).optional(),
                 acceptance: tool.schema.array(tool.schema.string()).optional(),
                 non_goals: tool.schema.array(tool.schema.string()).optional(),
                 related_task_id: tool.schema.string().optional(),
               },
               async execute(_args: any, context: any) {
                 const commandArgs = [_args.title, _args.description];
-                if (_args.tags?.length) commandArgs.push(`--tags=${_args.tags.join(",")}`);
                 if (_args.acceptance?.length) commandArgs.push(`--acceptance=${_args.acceptance.join(";")}`);
                 if (_args.non_goals?.length) commandArgs.push(`--non-goals=${_args.non_goals.join(";")}`);
                 if (_args.related_task_id) commandArgs.push(`--task=${_args.related_task_id}`);
@@ -856,52 +835,32 @@ module Agentf
                 title: tool.schema.string(),
                 description: tool.schema.string(),
                 agent: tool.schema.string().optional(),
-                tags: tool.schema.array(tool.schema.string()).optional(),
                 context: tool.schema.string().optional(),
               },
               async execute(_args: any, context: any) {
                 const commandArgs = [_args.title, _args.description];
                 if (_args.agent) commandArgs.push(`--agent=${_args.agent}`);
-                if (_args.tags?.length) commandArgs.push(`--tags=${_args.tags.join(",")}`);
                 if (_args.context) commandArgs.push(`--context=${_args.context}`);
 
                 return runAgentfCli(context.directory, "memory", "add-lesson", commandArgs);
               },
             }),
-            "agentf-memory-add-success": tool({
-              description: "Store a success memory in Redis.",
-              args: {
-                title: tool.schema.string(),
-                description: tool.schema.string(),
-                agent: tool.schema.string().optional(),
-                tags: tool.schema.array(tool.schema.string()).optional(),
-                context: tool.schema.string().optional(),
-              },
-              async execute(_args: any, context: any) {
-                const commandArgs = [_args.title, _args.description];
-                if (_args.agent) commandArgs.push(`--agent=${_args.agent}`);
-                if (_args.tags?.length) commandArgs.push(`--tags=${_args.tags.join(",")}`);
-                if (_args.context) commandArgs.push(`--context=${_args.context}`);
-
-                return runAgentfCli(context.directory, "memory", "add-success", commandArgs);
-              },
-            }),
-            "agentf-memory-add-pitfall": tool({
-              description: "Store a pitfall memory in Redis.",
+            "agentf-memory-add-playbook": tool({
+              description: "Store a playbook memory in Redis.",
               args: {
                 title: tool.schema.string(),
                 description: tool.schema.string(),
                 agent: tool.schema.string().optional(),
-                tags: tool.schema.array(tool.schema.string()).optional(),
-                context: tool.schema.string().optional(),
+                steps: tool.schema.array(tool.schema.string()).optional(),
+                feature_area: tool.schema.string().optional(),
               },
               async execute(_args: any, context: any) {
                 const commandArgs = [_args.title, _args.description];
                 if (_args.agent) commandArgs.push(`--agent=${_args.agent}`);
-                if (_args.tags?.length) commandArgs.push(`--tags=${_args.tags.join(",")}`);
-                if (_args.context) commandArgs.push(`--context=${_args.context}`);
+                if (_args.steps?.length) commandArgs.push(`--steps=${_args.steps.join(";")}`);
+                if (_args.feature_area) commandArgs.push(`--feature-area=${_args.feature_area}`);
 
-                return runAgentfCli(context.directory, "memory", "add-pitfall", commandArgs);
+                return runAgentfCli(context.directory, "memory", "add-playbook", commandArgs);
               },
             }),
           };
@@ -961,6 +920,10 @@ module Agentf
       JSON.pretty_generate(opencode_json_config(root))
     end
 
+    def render_copilot_mcp_json(root)
+      JSON.pretty_generate(copilot_mcp_config(root))
+    end
+
     def opencode_json_config(root)
       base = {
         "$schema" => "https://opencode.ai/config.json"
@@ -1019,6 +982,37 @@ module Agentf
       write_manifest(path, JSON.pretty_generate(merged))
     end
 
+    def copilot_mcp_config(root)
+      {
+        "servers" => {
+          "agentf" => {
+            "type" => "stdio",
+            "command" => "agentf",
+            "args" => ["mcp-server"]
+          }
+        }
+      }
+    end
+
+    def write_copilot_mcp_json(root)
+      path = File.join(root, ".vscode", "mcp.json")
+      new_content = JSON.parse(render_copilot_mcp_json(root))
+
+      return write_manifest(path, JSON.pretty_generate(new_content)) unless File.exist?(path)
+
+      begin
+        existing = JSON.parse(File.read(path))
+      rescue StandardError => e
+        warn "Failed to parse existing #{path}: #{e.message}"
+        return write_manifest(path, JSON.pretty_generate(new_content))
+      end
+
+      merged = existing.dup
+      merged["servers"] = (existing["servers"] || {}).merge(new_content.fetch("servers"))
+
+      write_manifest(path, JSON.pretty_generate(merged))
+    end
+
     def render_opencode_tsconfig
       <<~JSON
         {
@@ -1093,19 +1087,20 @@ module Agentf
         - `agent`: string
 
         ### 2. Episodic Memory (`episodic:*`)
-        Used for success, pitfall, lesson, and intent records.
+        Used for episode, lesson, playbook, and intent records.
 
         **Search index**: `episodic:logs`
 
         **Schema fields**:
         - `$.id`
         - `$.type`
+        - `$.outcome`
         - `$.title`
         - `$.description`
         - `$.project`
         - `$.context`
         - `$.code_snippet`
-        - `$.tags`
+        - `$.embedding`
         - `$.created_at`
         - `$.agent`
         - `$.related_task_id`
@@ -1116,9 +1111,9 @@ module Agentf
 
         - Read recent: `agentf memory recent -n 10`
         - Search: `agentf memory search "query" -n 10`
+        - List episodes: `agentf memory episodes -n 10 --outcome=negative`
         - Add lesson: `agentf memory add-lesson "<title>" "<description>" --agent=<AGENT>`
-        - Add success: `agentf memory add-success "<title>" "<description>" --agent=<AGENT>`
-        - Add pitfall: `agentf memory add-pitfall "<title>" "<description>" --agent=<AGENT>`
+        - Add playbook: `agentf memory add-playbook "<title>" "<description>" --steps="<step1>;<step2>"`
       MARKDOWN
     end
   end