agentf 0.4.5 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 375fdc4ce17f8fe753e2f99a1ac35ee5a4ce2ac8b592812b924a4b755faf7827
-  data.tar.gz: 7d45fb33f315c8cd15fb4297556d063603d763fe3a0f9e79906a259f1dac6808
+  metadata.gz: 2cf35c1c3dd0c0b331de754c2805b3bbd27e9175a339ecb264509ab3ff5e843b
+  data.tar.gz: 1c552174bd8cfdfb0770f8a4c7ae19dd732c7c8e2d440f9197a5c210a0e55b1c
 SHA512:
-  metadata.gz: 4eb3d691ed13cae8b2780955eb4e059c878f1ad3f219ffe577d439b1695a7d5d3408d6770f2a7d1a3d45e78df678993a882eb130003e4bcc5c5e5759b7508051
-  data.tar.gz: 635accb75b7532c51cee21c02a5d54b9df35010e2db3c46efe3e788452cdaca5f9b35bfdc538969227dd0808cf4b3b37d1e0821f73f8c9431f2ec54dca12ea2e
+  metadata.gz: e60ee2faa826fe20c6845ab4250153838519456109893adcbba592e3a389a85520c00e3302a4bfb279e3b53b2c79c74afbe32a621a044837e904ca73dee37c54
+  data.tar.gz: d246b77664af5a645dc00afd17d0ea2799cf786d8c51f910212c7d24516e0f53a00bbeab81ec84b23a466d3a2185058bdbc89318aca932f20b7ef7c16be7e668

data/lib/agentf/agents/debugger.rb

@@ -45,8 +45,8 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Return analysis with root causes and suggested fix", "Persist debugging lesson"],
-          "ask_first" => ["Applying speculative fixes without reproducible error"],
+          "always" => ["Return analysis with root causes and suggested fix"],
+          "ask_first" => ["Applying speculative fixes without reproducible error", "Persisting debugging lessons to memory"],
           "never" => ["Discard stack trace context when available"],
           "required_inputs" => ["error_text"],
           "required_outputs" => ["analysis", "success"]

data/lib/agentf/agents/designer.rb

@@ -46,7 +46,7 @@ module Agentf
       def self.policy_boundaries
         {
           "always" => ["Return generated component details", "Persist successful implementation pattern"],
-          "ask_first" => ["Changing primary UI framework"],
+          "ask_first" => ["Changing primary UI framework", "Persisting successful implementation patterns to memory"],
           "never" => ["Return empty generated code for successful design task"],
           "required_inputs" => ["design_spec"],
           "required_outputs" => ["component", "generated_code", "success"]

data/lib/agentf/agents/explorer.rb

@@ -45,8 +45,8 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Return concrete file evidence", "Persist exploration breadcrumbs"],
-          "ask_first" => ["Scanning outside configured base path"],
+          "always" => ["Return concrete file evidence"],
+          "ask_first" => ["Scanning outside configured base path", "Persisting exploration breadcrumbs to memory"],
           "never" => ["Mutate project files during exploration"],
           "required_inputs" => [],
           "required_outputs" => ["files", "context_gathered"]

data/lib/agentf/agents/security.rb

@@ -45,8 +45,8 @@ module Agentf
 
       def self.policy_boundaries
         {
-          "always" => ["Return issue list and best practices", "Persist outcome as success or pitfall"],
-          "ask_first" => ["Allowing known secret patterns in context"],
+          "always" => ["Return issue list and best practices"],
+          "ask_first" => ["Allowing known secret patterns in context", "Persisting security scan findings to memory"],
           "never" => ["Echo raw secrets in output"],
           "required_inputs" => ["task"],
           "required_outputs" => ["issues", "best_practices"]

data/lib/agentf/agents/specialist.rb

@@ -45,7 +45,7 @@ module Agentf
       def self.policy_boundaries
         {
           "always" => ["Persist execution outcome", "Return deterministic success boolean"],
-          "ask_first" => ["Applying architecture style changes across unrelated modules"],
+          "ask_first" => ["Applying architecture style changes across unrelated modules", "Persisting execution outcomes to memory (success/pitfall)"] ,
           "never" => ["Claim implementation complete without execution result"],
           "required_inputs" => ["description"],
           "required_outputs" => ["subtask_id", "success"]

data/lib/agentf/agents/tester.rb

@@ -46,7 +46,7 @@ module Agentf
       def self.policy_boundaries
         {
           "always" => ["Produce framework-aware tests", "Verify red/green state when TDD enabled"],
-          "ask_first" => ["Changing test framework conventions"],
+          "ask_first" => ["Changing test framework conventions", "Persisting test-generation outcomes to memory"],
           "never" => ["Mark passing when command output is uncertain"],
           "required_inputs" => [],
           "required_outputs" => ["test_file"]

data/lib/agentf/installer.rb

@@ -25,8 +25,8 @@ module Agentf
       "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-lesson" },
-      "store_feature_intent" => { cli: "agentf memory add-feature-intent \"<title>\" \"<description>\" --acceptance=\"<criteria>\"", tool: "agentf-memory-add-lesson" }
+      "store_business_intent" => { cli: "agentf memory add-business-intent \"<title>\" \"<description>\" --tags=strategy", 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
 
     PROVIDER_LAYOUTS = {
@@ -631,6 +631,165 @@ 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, context) {
+                  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: {
+                  agent: tool.schema.string().describe("Agent name"),
+                  limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
+                },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "by-agent", [args.agent, "-n", String(limit)]);
+                },
+              }),
+              "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)"),
+                  limit: tool.schema.number().int().min(1).max(100).optional().describe("How many results to return"),
+                },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  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, context) {
+                  return runAgentfCli(context.directory, "memory", "tags", []);
+                },
+              }),
+              "agentf-memory-pitfalls": tool({
+                description: "List pitfall memories.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "pitfalls", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-lessons": tool({
+                description: "List lesson memories.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  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, context) {
+                  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() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  const kind = args.kind ? String(args.kind) : "";
+                  const cmdArgs = kind ? [kind, "-n", String(limit)] : ["-n", String(limit)];
+                  return runAgentfCli(context.directory, "memory", "intents", cmdArgs);
+                },
+              }),
+              "agentf-memory-business-intents": tool({
+                description: "List business intents.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "business-intents", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-feature-intents": tool({
+                description: "List feature intents.",
+                args: { limit: tool.schema.number().int().min(1).max(100).optional() },
+                async execute(args, context) {
+                  const limit = args.limit ?? 10;
+                  return runAgentfCli(context.directory, "memory", "feature-intents", ["-n", String(limit)]);
+                },
+              }),
+              "agentf-memory-add-business-intent": tool({
+                description: "Store a business intent in Redis.",
+                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, context) {
+                  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);
+                },
+              }),
+              "agentf-memory-add-feature-intent": tool({
+                description: "Store a feature intent in Redis.",
+                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, context) {
+                  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}`);
+                  return runAgentfCli(context.directory, "memory", "add-feature-intent", commandArgs);
+                },
+              }),
+              "agentf-memory-neighbors": tool({
+                description: "Get neighboring memory nodes by edge traversal.",
+                args: {
+                  node_id: tool.schema.string(),
+                  relation: tool.schema.string().optional(),
+                  depth: tool.schema.number().int().optional(),
+                  limit: tool.schema.number().int().optional(),
+                },
+                async execute(args, context) {
+                  const commandArgs = [args.node_id];
+                  if (args.relation) commandArgs.push(`--relation=${args.relation}`);
+                  if (Number.isInteger(args.depth)) commandArgs.push(`--depth=${String(args.depth)}`);
+                  if (Number.isInteger(args.limit)) commandArgs.push(`-n`, String(args.limit));
+                  return runAgentfCli(context.directory, "memory", "neighbors", commandArgs);
+                },
+              }),
+              "agentf-memory-subgraph": tool({
+                description: "Build a subgraph from seed ids.",
+                args: {
+                  seed_ids: tool.schema.array(tool.schema.string()),
+                  relation_filters: tool.schema.array(tool.schema.string()).optional(),
+                  depth: tool.schema.number().int().optional(),
+                  limit: tool.schema.number().int().optional(),
+                },
+                async execute(args, context) {
+                  const seeds = (args.seed_ids || []).join(",");
+                  const commandArgs = [seeds];
+                  if (args.relation_filters?.length) commandArgs.push(`--relation=${args.relation_filters.join(",")}`);
+                  if (Number.isInteger(args.depth)) commandArgs.push(`--depth=${String(args.depth)}`);
+                  if (Number.isInteger(args.limit)) commandArgs.push(`-n`, String(args.limit));
+                  return runAgentfCli(context.directory, "memory", "subgraph", commandArgs);
+                },
+              }),
               "agentf-memory-add-lesson": tool({
                 description: "Store a lesson memory in Redis.",
                 args: {

data/lib/agentf/mcp/server.rb

@@ -28,17 +28,31 @@ module Agentf
         agentf-architecture-analyze-layers
         agentf-memory-recent
         agentf-memory-search
+        agentf-memory-by-tag
+        agentf-memory-by-agent
+        agentf-memory-by-type
+        agentf-memory-tags
+        agentf-memory-pitfalls
+        agentf-memory-lessons
+        agentf-memory-successes
+        agentf-memory-intents
+        agentf-memory-business-intents
+        agentf-memory-feature-intents
         agentf-memory-neighbors
         agentf-memory-subgraph
         agentf-memory-add-lesson
         agentf-memory-add-success
         agentf-memory-add-pitfall
+        agentf-memory-add-business-intent
+        agentf-memory-add-feature-intent
       ].freeze
 
       WRITE_TOOLS = Set.new(%w[
         agentf-memory-add-lesson
         agentf-memory-add-success
         agentf-memory-add-pitfall
+        agentf-memory-add-business-intent
+        agentf-memory-add-feature-intent
       ]).freeze
 
       attr_reader :server, :guardrails
@@ -214,6 +228,160 @@ module Agentf
           end
         end
 
+        s.tool("agentf-memory-by-tag") do
+          description "Get memories by tag."
+          argument :tag, String, required: true, description: "Tag to filter"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-by-tag", **args)
+            result = reviewer.get_by_tag(args[:tag], limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-by-agent") do
+          description "Get memories by agent."
+          argument :agent, String, required: true, description: "Agent name"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-by-agent", **args)
+            result = reviewer.get_by_agent(args[:agent], limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-by-type") do
+          description "Get memories by type."
+          argument :type, String, required: true, description: "Memory type"
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-by-type", **args)
+            result = reviewer.get_by_type(args[:type], limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-tags") do
+          description "List all unique memory tags."
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-tags", **args)
+            result = reviewer.get_all_tags
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-pitfalls") do
+          description "List pitfall memories."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-pitfalls", **args)
+            result = reviewer.get_pitfalls(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-lessons") do
+          description "List lesson memories."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-lessons", **args)
+            result = reviewer.get_lessons(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-successes") do
+          description "List success memories."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-successes", **args)
+            result = reviewer.get_successes(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-intents") do
+          description "List intents (business|feature)."
+          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|
+            mcp_server.send(:guard!, "agentf-memory-intents", **args)
+            kind = args[:kind]
+            limit = args[:limit] || 10
+            result = case kind
+                     when "business"
+                       reviewer.get_business_intents(limit: limit)
+                     when "feature"
+                       reviewer.get_feature_intents(limit: limit)
+                     else
+                       reviewer.get_intents(limit: limit)
+                     end
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-business-intents") do
+          description "List business intents."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-business-intents", **args)
+            result = reviewer.get_business_intents(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-feature-intents") do
+          description "List feature intents."
+          argument :limit, Integer, required: false, description: "How many results to return (1-100)"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-feature-intents", **args)
+            result = reviewer.get_feature_intents(limit: args[:limit] || 10)
+            JSON.generate(result)
+          end
+        end
+
+        s.tool("agentf-memory-add-business-intent") do
+          description "Store a business intent in Redis."
+          argument :title, String, required: true, description: "Intent title"
+          argument :description, String, required: true, description: "Intent description"
+          argument :tags, Array, required: false, items: String, description: "Tags"
+          argument :constraints, Array, required: false, items: String, description: "Constraints"
+          argument :priority, Integer, required: false, description: "Priority"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-add-business-intent", **args)
+            id = memory.store_business_intent(
+              title: args[:title],
+              description: args[:description],
+              tags: args[:tags] || [],
+              constraints: args[:constraints] || [],
+              priority: args[:priority] || 1
+            )
+            JSON.generate(id: id, type: "business_intent", status: "stored")
+          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 :tags, Array, required: false, items: String, description: "Tags"
+          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"
+          call do |args|
+            mcp_server.send(:guard!, "agentf-memory-add-feature-intent", **args)
+            id = memory.store_feature_intent(
+              title: args[:title],
+              description: args[:description],
+              tags: args[:tags] || [],
+              acceptance_criteria: args[:acceptance] || [],
+              non_goals: args[:non_goals] || [],
+              related_task_id: args[:related_task_id]
+            )
+            JSON.generate(id: id, type: "feature_intent", status: "stored")
+          end
+        end
+
         s.tool("agentf-memory-neighbors") do
           description "Get neighboring memory nodes by edge traversal."
           argument :node_id, String, required: true, description: "Starting node id"

data/lib/agentf/memory.rb

@@ -45,7 +45,39 @@ module Agentf
       end
 
       def store_episode(type:, title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER,
-                        related_task_id: nil, metadata: {}, entity_ids: [], relationships: [], parent_episode_id: nil, causal_from: nil)
+                        related_task_id: nil, metadata: {}, entity_ids: [], relationships: [], parent_episode_id: nil, causal_from: nil, confirm: nil)
+        # Determine persistence preference from the agent's policy boundaries.
+        # Precedence: never > always > ask_first > none.
+        auto_confirm = ENV['AGENTF_AUTO_CONFIRM_MEMORIES'] == 'true'
+        pref = persistence_preference_for(agent)
+
+        case pref
+        when :never
+          begin
+            puts "[MEMORY] Skipping persistence for #{agent}: policy forbids persisting memories"
+          rescue StandardError
+          end
+          return nil
+        when :always
+          # proceed without requiring explicit confirm
+        when :ask_first
+          unless agent == Agentf::AgentRoles::ORCHESTRATOR || confirm == true || auto_confirm
+            begin
+              puts "[MEMORY] Skipping persistence for #{agent}: confirmation required by policy"
+            rescue StandardError
+            end
+            return nil
+          end
+        else
+          # default conservative behavior: require explicit confirm (or env opt-in)
+          unless agent == Agentf::AgentRoles::ORCHESTRATOR || confirm == true || auto_confirm
+            begin
+              puts "[MEMORY] Skipping persistence for #{agent}: confirmation required"
+            rescue StandardError
+            end
+            return nil
+          end
+        end
         episode_id = "episode_#{SecureRandom.hex(4)}"
         normalized_metadata = enrich_metadata(
           metadata: metadata,
@@ -107,52 +139,56 @@ module Agentf
         episode_id
       end
 
-      def store_success(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
-        store_episode(
+      def store_success(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER, confirm: nil)
+         store_episode(
           type: "success",
           title: title,
           description: description,
           context: context,
           code_snippet: code_snippet,
           tags: tags,
-          agent: agent
+           agent: agent,
+           confirm: confirm
         )
       end
 
-      def store_pitfall(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
-        store_episode(
+      def store_pitfall(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER, confirm: nil)
+         store_episode(
           type: "pitfall",
           title: title,
           description: description,
           context: context,
           code_snippet: code_snippet,
           tags: tags,
-          agent: agent
+           agent: agent,
+           confirm: confirm
         )
       end
 
-      def store_lesson(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER)
-        store_episode(
+      def store_lesson(title:, description:, context: "", code_snippet: "", tags: [], agent: Agentf::AgentRoles::ENGINEER, confirm: nil)
+         store_episode(
           type: "lesson",
           title: title,
           description: description,
           context: context,
           code_snippet: code_snippet,
           tags: tags,
-          agent: agent
+           agent: agent,
+           confirm: confirm
         )
       end
 
-      def store_business_intent(title:, description:, constraints: [], tags: [], agent: Agentf::AgentRoles::ORCHESTRATOR, priority: 1)
+      def store_business_intent(title:, description:, constraints: [], tags: [], agent: Agentf::AgentRoles::ORCHESTRATOR, priority: 1, confirm: nil)
         context = constraints.any? ? "Constraints: #{constraints.join('; ')}" : ""
 
-        store_episode(
+         store_episode(
           type: "business_intent",
           title: title,
           description: description,
           context: context,
           tags: tags,
-          agent: agent,
+           agent: agent,
+           confirm: confirm,
           metadata: {
             "intent_kind" => "business",
             "constraints" => constraints,
@@ -162,18 +198,19 @@ module Agentf
       end
 
       def store_feature_intent(title:, description:, acceptance_criteria: [], non_goals: [], tags: [], agent: Agentf::AgentRoles::PLANNER,
-                               related_task_id: nil)
+                                related_task_id: nil, confirm: nil)
         context_parts = []
         context_parts << "Acceptance: #{acceptance_criteria.join('; ')}" if acceptance_criteria.any?
         context_parts << "Non-goals: #{non_goals.join('; ')}" if non_goals.any?
 
-        store_episode(
+         store_episode(
           type: "feature_intent",
           title: title,
           description: description,
           context: context_parts.join(" | "),
           tags: tags,
           agent: agent,
+           confirm: confirm,
           related_task_id: related_task_id,
           metadata: {
             "intent_kind" => "feature",
@@ -858,6 +895,54 @@ module Agentf
         base
       end
 
+      # Determine whether writes from the given agent should require explicit
+      # confirmation. We consider agents that declare "ask_first" policy
+      # boundaries to be conservative and require confirmation before persisting
+      # memories. Agent classes register policy boundaries on their class
+      # definitions (see agents/*). When agent is provided as a role string
+      # (eg. "ENGINEER") we try to match against known agent classes.
+      def agent_requires_confirmation?(agent)
+        begin
+          # If a developer passed an agent class-like string, try to map it to
+          # the loaded agent class and inspect its policy_boundaries.
+          candidate = Agentf::Agents.constants
+                      .map { |c| Agentf::Agents.const_get(c) }
+                      .find do |klass|
+                        klass.is_a?(Class) && klass.respond_to?(:policy_boundaries) && klass.typed_name == agent
+                      end
+
+          return false unless candidate
+
+          boundaries = candidate.policy_boundaries
+          ask_first = Array(boundaries["ask_first"]) rescue []
+          !ask_first.empty?
+        rescue StandardError
+          false
+        end
+      end
+
+      # Inspect loaded agent classes for explicit persistence preference.
+      # Returns one of: :always, :ask_first, :never, or nil when unknown.
+      def persistence_preference_for(agent)
+        begin
+          candidate = Agentf::Agents.constants
+                      .map { |c| Agentf::Agents.const_get(c) }
+                      .find do |klass|
+                        klass.is_a?(Class) && klass.respond_to?(:policy_boundaries) && klass.typed_name == agent
+                      end
+
+          return nil unless candidate
+
+          boundaries = candidate.policy_boundaries
+          return :never if Array(boundaries["never"]).any?
+          return :always if Array(boundaries["always"]).any? && Array(boundaries["ask_first"]).empty?
+          return :ask_first if Array(boundaries["ask_first"]).any?
+          nil
+        rescue StandardError
+          nil
+        end
+      end
+
       def infer_division(agent)
         case agent
         when Agentf::AgentRoles::PLANNER, Agentf::AgentRoles::ORCHESTRATOR, Agentf::AgentRoles::KNOWLEDGE_MANAGER

data/lib/agentf/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agentf
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.7
 platform: ruby
 authors:
 - Neal Deters
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-10 00:00:00.000000000 Z
+date: 2026-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis