agentf 0.6.0 → 0.8.0

data/.opencode/node_modules/zod/v4/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

data/.opencode/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../v4/mini/index.cjs"), exports);

data/.opencode/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

data/.opencode/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

data/.opencode/node_modules/zod/v4-mini/index.js

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

data/.opencode/node_modules/zod/v4-mini/package.json

@@ -0,0 +1,6 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts" 
+}

data/.opencode/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@opencode-ai/plugin": "1.2.24"
+  }
+}

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/explorer.rb

@@ -47,10 +47,18 @@ module Agentf
 
       # Search for pattern in files
       def grep(pattern, file_pattern: nil, context_lines: 2)
-        cmd = ["grep", "-rn"]
-        cmd << "--include=#{file_pattern || '*'}" if file_pattern
-        cmd << pattern
-        cmd << @base_path
+        use_rg = system("which rg > /dev/null 2>&1")
+
+        if use_rg
+          cmd = ["rg", "-n", "--no-heading", "--color", "never", "-C", context_lines.to_s, "--hidden", "--no-ignore"]
+          cmd += ["--glob", file_pattern] if file_pattern
+          cmd += [pattern, @base_path]
+        else
+          cmd = ["grep", "-rn"]
+          cmd << "--include=#{file_pattern || '*'}" if file_pattern
+          cmd += ["-C", context_lines.to_s] if context_lines && context_lines > 0
+          cmd += [pattern, @base_path]
+        end
 
         stdout, _stderr, _status = Open3.capture3(*cmd)
 

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