phronomy 0.16.0 → 0.17.0

data/lib/phronomy/multi_agent/team_coordinator.rb

@@ -4,95 +4,34 @@ require "securerandom"
 
 module Phronomy
   module MultiAgent
-    # Implements the "Agent teams" coordination pattern (Anthropic blog, Pattern 3).
-    #
-    # @see https://claude.com/blog/multi-agent-coordination-patterns
-    #
-    # A coordinator LLM agent decomposes work into tasks and enqueues them
-    # dynamically via built-in tools. A fixed set of worker agents processes tasks
-    # sequentially — one task per worker per turn — carrying forward their
-    # conversation history across assignments to accumulate domain context over time.
-    #
-    # Workers are selected in sequence (the worker with the fewest accumulated
-    # messages is chosen by default). Task dispatch is synchronous; there is no
-    # concurrent or parallel execution.
-    #
-    # The coordinator is an {Agent::Base} subclass that has two built-in tools:
-    # - +enqueue_task+ — adds a task description to the queue
-    # - +finalize+     — signals that all tasks have been enqueued
-    #
-    # Worker persistence is implemented by passing each worker's accumulated
-    # +messages+ array back as a top-level +messages:+ argument on every subsequent
-    # +invoke+ call, so the LLM retains context across multiple task assignments.
-    #
-    # @example Basic usage
-    #   class MigrationTeam < Phronomy::MultiAgent::TeamCoordinator
-    #     coordinator_model        "claude-3-5-sonnet-20241022"
-    #     coordinator_instructions <<~INST
-    #       Analyze the request and enqueue one migration task per service.
-    #       Call enqueue_task for each service, then call finalize.
-    #     INST
-    #
-    #     pool size: 3, agent: MigrationAgent
-    #
-    #     aggregate do |assignments|
-    #       { reports: assignments.map { |a| { task: a[:task][:description], result: a[:result] } } }
-    #     end
-    #   end
-    #
-    #   result = MigrationTeam.new.invoke("Migrate all services to Rails 8")
+    # Coordinator/worker multi-agent pattern with persistent worker Agent state.
     class TeamCoordinator
-      # Holds per-worker context between task invocations.
-      # Worker persistence is implemented by carrying +messages+ forward on each
-      # successive +agent#invoke+ call as the top-level +messages:+ argument..
       WorkerState = Struct.new(
-        :index,    # Integer — 0-based worker index
-        :agent,    # Agent::Base instance
-        :messages, # Array  — accumulated conversation history
-        :status    # Symbol — :idle | :available | :done
+        :index,
+        :agent,
+        :transcript_size,
+        :status
       ) do
-        # Returns true when this worker is ready to accept the next task.
-        def available? = [:idle, :available].include?(status)
+        def available? = %i[idle available].include?(status)
       end
       private_constant :WorkerState
 
       class << self
-        # Sets the LLM model for the coordinator agent.
-        # Falls back to +Phronomy.configuration.default_model+ when not set.
-        #
-        # @param value [String, nil]
         # @api public
         def coordinator_model(value = nil)
           value ? @coordinator_model = value : @coordinator_model
         end
 
-        # Sets the system instructions for the coordinator agent.
-        # The prompt should direct the LLM to call +enqueue_task+ for each task
-        # and then call +finalize+ when all tasks are enqueued.
-        #
-        # @param value [String, nil]
         # @api public
         def coordinator_instructions(value = nil)
           value ? @coordinator_instructions = value : @coordinator_instructions
         end
 
-        # Sets the LLM provider for the coordinator agent.
-        # Required when using a custom +BASE_URL+ (e.g. LM Studio, Ollama, vLLM)
-        # so that RubyLLM does not attempt to resolve an unknown model name.
-        # Pass the same value as +LLMConfig::PROVIDER+ in your examples.
-        #
-        # @param value [Symbol, nil]
         # @api public
         def coordinator_provider(value = nil)
           value ? @coordinator_provider = value : @coordinator_provider
         end
 
-        # Configures the set of workers.
-        #
-        # @param size     [Integer] number of persistent worker instances (tasks are assigned sequentially)
-        # @param agent    [Class]   Agent::Base subclass used for all workers
-        # @param on_error [Symbol]  +:raise+ (default) propagates worker exceptions;
-        #                           +:skip+ records the failure and continues with remaining tasks
         # @api public
         def pool(size:, agent:, on_error: :raise)
           @pool_size = Integer(size)
@@ -100,57 +39,31 @@ module Phronomy
           @on_error = on_error
         end
 
-        # Customises the worker selection algorithm.
-        # The block receives an Array of available WorkerState objects and must
-        # return the one to assign the next task to.
-        # Default: worker with the fewest accumulated messages (round-robin-like).
-        #
-        # @yield [Array<WorkerState>] available workers
-        # @yieldreturn [WorkerState] the chosen worker
         # @api public
         def schedule(&block)
           @scheduler = block
         end
 
-        # Defines how task assignments are merged into the final return value.
-        # The block receives an Array of assignment Hashes:
-        #   { task: Hash, result: String|nil, worker: Integer, error: Exception|nil }
-        # When omitted, the raw assignments array is returned.
-        #
-        # @yield [Array<Hash>] all completed (and skipped) task assignments
         # @api public
         def aggregate(&block)
           @aggregator = block
         end
 
-        # @!visibility private
         def _coordinator_model = @coordinator_model
-        # @!visibility private
         def _coordinator_instructions = @coordinator_instructions
-        # @!visibility private
         def _coordinator_provider = @coordinator_provider
-        # @!visibility private
         def _pool_size = @pool_size || 1
-        # @!visibility private
         def _worker_agent = @worker_agent
-        # @!visibility private
         def _on_error = @on_error || :raise
-        # @!visibility private
         def _scheduler = @scheduler
-        # @!visibility private
         def _aggregator = @aggregator
       end
 
-      # Runs the full team coordination: coordinator generates tasks, workers
-      # process them sequentially, and the aggregate block merges the results.
-      #
-      # @param team_input [String, Hash] the high-level objective given to the coordinator
-      # @param config     [Hash]         reserved for future use
-      # @return [Object] the return value of the aggregate block, or the raw assignments Array
-      # @raise [ArgumentError] when +pool :agent+ has not been configured
       # @api public
       def invoke(team_input, config: {})
-        raise ArgumentError, "pool :agent must be configured before invoking" unless self.class._worker_agent
+        unless self.class._worker_agent
+          raise ArgumentError, "pool :agent must be configured before invoking"
+        end
 
         task_queue = []
         run_coordinator(team_input, task_queue)
@@ -158,26 +71,13 @@ module Phronomy
         finalize_result(assignments)
       end
 
-      # Streaming version of +invoke+. Yields a Hash event for each completed or
-      # failed task assignment.
-      #
-      # Yielded Hash keys:
-      #   :type   — +:task_completed+ or +:task_failed+
-      #   :worker — worker index (Integer)
-      #   :task   — the task Hash from the queue ({ id:, description:, metadata:, enqueued_at: })
-      #   :result — output string, or +nil+ on failure
-      #   :error  — Exception, or +nil+ on success
-      #
-      # @param team_input [String, Hash]
-      # @param config     [Hash]
-      # @yield [Hash] one event per completed/failed task
-      # @return [Object] same as +invoke+
-      # @raise [ArgumentError] when +pool :agent+ has not been configured
       # @api public
       def stream(team_input, config: {}, &block)
         return invoke(team_input, config: config) unless block
 
-        raise ArgumentError, "pool :agent must be configured before invoking" unless self.class._worker_agent
+        unless self.class._worker_agent
+          raise ArgumentError, "pool :agent must be configured before invoking"
+        end
 
         task_queue = []
         run_coordinator(team_input, task_queue)
@@ -187,23 +87,25 @@ module Phronomy
 
       private
 
-      # Phase 1: Run the coordinator LLM agent to populate task_queue.
       def run_coordinator(team_input, task_queue)
         coordinator = build_coordinator_agent(task_queue)
         input = team_input.is_a?(String) ? team_input : team_input.to_s
         coordinator.invoke(input)
       end
 
-      # Phase 2: Process tasks from the queue using the worker pool.
-      # Workers accumulate message history across assignments.
       def run_workers(task_queue, &event_block)
         pool_size = self.class._pool_size
         agent_class = self.class._worker_agent
         on_error = self.class._on_error
         scheduler = self.class._scheduler
 
-        workers = Array.new(pool_size) do |i|
-          WorkerState.new(index: i, agent: agent_class.new, messages: [], status: :idle)
+        workers = Array.new(pool_size) do |index|
+          WorkerState.new(
+            index: index,
+            agent: agent_class.new,
+            transcript_size: 0,
+            status: :idle
+          )
         end
 
         assignments = []
@@ -214,40 +116,45 @@ module Phronomy
           worker = scheduler ? scheduler.call(available) : default_scheduler(available)
 
           begin
-            # Worker agent retains conversation history in its Journal.
             result = worker.agent.invoke(task[:description])
-            worker.messages = Array(result[:messages])
+            worker.transcript_size = worker.agent.transcript.length
             worker.status = :available
-            entry = {task: task, result: result[:output], worker: worker.index, error: nil}
+            entry = {
+              task: task,
+              result: result[:output],
+              worker: worker.index,
+              error: nil
+            }
             assignments << entry
             event_block&.call(entry.merge(type: :task_completed))
-          rescue => e
+          rescue => error
             worker.status = :available
             raise unless on_error == :skip
 
-            entry = {task: task, result: nil, worker: worker.index, error: e}
+            entry = {
+              task: task,
+              result: nil,
+              worker: worker.index,
+              error: error
+            }
             assignments << entry
             event_block&.call(entry.merge(type: :task_failed))
           end
         end
 
-        workers.each { |w| w.status = :done }
+        workers.each { |worker| worker.status = :done }
         assignments
       end
 
-      # Phase 3: Apply the aggregate block (or return raw assignments).
       def finalize_result(assignments)
         aggregator = self.class._aggregator
         aggregator ? aggregator.call(assignments) : assignments
       end
 
-      # Default scheduler: assign to the worker with the fewest accumulated
-      # messages (promotes round-robin-like distribution across the pool).
       def default_scheduler(available_workers)
-        available_workers.min_by { |w| w.messages.size }
+        available_workers.min_by(&:transcript_size)
       end
 
-      # Build an anonymous coordinator Agent::Base with the two built-in tools.
       def build_coordinator_agent(task_queue)
         coordinator_model_val = self.class._coordinator_model
         coordinator_instructions_val = self.class._coordinator_instructions
@@ -260,13 +167,12 @@ module Phronomy
           model coordinator_model_val
           provider coordinator_provider_val if coordinator_provider_val
           instructions coordinator_instructions_val
-          tools enqueue_tool, finalize_tool
+          tools(enqueue_tool => nil, finalize_tool => nil)
         end
 
         coordinator_class.new
       end
 
-      # Builds the +enqueue_task+ tool. Each call appends a task Hash to task_queue.
       def build_enqueue_tool(task_queue)
         Class.new(Phronomy::Agent::Context::Capability::Base) do
           tool_name "enqueue_task"
@@ -275,15 +181,18 @@ module Phronomy
           param :metadata, type: :string, desc: "Optional metadata", required: false
 
           define_method(:execute) do |description:, metadata: nil|
-            task = {id: task_queue.size + 1, description: description, metadata: metadata, enqueued_at: Time.now}
+            task = {
+              id: task_queue.size + 1,
+              description: description,
+              metadata: metadata,
+              enqueued_at: Time.now
+            }
             task_queue << task
             "Task ##{task[:id]} enqueued: #{description}"
           end
         end
       end
 
-      # Builds the +finalize+ tool. Signals to the coordinator LLM that all tasks
-      # have been enqueued; returns a confirmation string.
       def build_finalize_tool(task_queue)
         Class.new(Phronomy::Agent::Context::Capability::Base) do
           tool_name "finalize"

data/lib/phronomy/vector_store/in_memory.rb

@@ -4,8 +4,8 @@ module Phronomy
   module VectorStore
     # Pure-Ruby in-memory vector store using cosine similarity.
     #
-    # Intended for tests, short-lived agents, and Retrieval::Semantic scenarios where
-    # the message count is small enough that a linear scan is fast enough.
+    # Intended for tests, short-lived agents, and small retrieval workloads where
+    # the document count is small enough that a linear scan is fast enough.
     #
     # @example
     #   store = Phronomy::VectorStore::InMemory.new

data/lib/phronomy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Phronomy
-  VERSION = "0.16.0"
+  VERSION = "0.17.0"
 end

data/lib/phronomy.rb

@@ -5,36 +5,18 @@ require "ruby_llm"
 require_relative "phronomy/ruby_llm_patches"
 
 loader = Zeitwerk::Loader.for_gem
-# Teach Zeitwerk that "llm" maps to "LLM" so that file names such as
-# ruby_llm_embeddings.rb resolve to RubyLLMEmbeddings (not RubyLlmEmbeddings).
 loader.inflector.inflect("ruby_llm_embeddings" => "RubyLLMEmbeddings")
-# RAG: Zeitwerk would infer "Rag" — override to "RAG".
 loader.inflector.inflect("rag" => "RAG")
-# FSMSession: Zeitwerk would infer "FsmSession" — override to "FSMSession".
-# Phronomy::FSMSession is the top-level cooperative execution engine shared by
-# WorkflowRunner, AgentInvocationSessionBuilder, and ToolInvocationSessionBuilder.
 loader.inflector.inflect("fsm_session" => "FSMSession")
-# LLMAdapter: Zeitwerk would infer "LlmAdapter" — override to "LLMAdapter".
 loader.inflector.inflect("llm_adapter" => "LLMAdapter")
-# LLMOperationResult: preserve the LLM acronym for the Agent result carrier.
 loader.inflector.inflect("llm_operation_result" => "LLMOperationResult")
-# LLMAdapter::RubyLLM: "ruby_llm" maps to "RubyLLM" (not "RubyLlm").
 loader.inflector.inflect("ruby_llm" => "RubyLLM")
-# CanonicalJSON: preserve uppercase JSON acronym.
 loader.inflector.inflect("canonical_json" => "CanonicalJSON")
-# RubyLLMMaterializer: preserve the double-uppercase LLM acronym.
 loader.inflector.inflect("ruby_llm_materializer" => "RubyLLMMaterializer")
-# LLMCallRecord: preserve uppercase LLM acronym.
 loader.inflector.inflect("llm_call_record" => "LLMCallRecord")
-# LLMInputManifest: preserve uppercase LLM acronym.
 loader.inflector.inflect("llm_input_manifest" => "LLMInputManifest")
-# LLMInputBuildContext / LLMInputPatch: preserve uppercase LLM acronym.
 loader.inflector.inflect("llm_input_build_context" => "LLMInputBuildContext")
 loader.inflector.inflect("llm_input_patch" => "LLMInputPatch")
-# Collapse engine/ so that its contents autoload directly under Phronomy::
-# (no Engine:: prefix).  e.g. engine/event_loop.rb => Phronomy::EventLoop.
-# This allows the execution engine to be organised in its own subdirectory
-# without changing any class names or callers.
 loader.collapse("#{__dir__}/phronomy/engine")
 loader.setup
 
@@ -42,70 +24,25 @@ require_relative "phronomy/version"
 require_relative "phronomy/token_usage"
 
 module Phronomy
-  # Exception hierarchy
   class Error < StandardError; end
   class ParseError < Error; end
   class RecursionLimitError < Error; end
   class ToolError < Error; end
-  # Base error for Phronomy-owned timed boundaries and generic timeout primitives.
   class TimeoutError < Error; end
-
   class ConfigurationError < Error; end
-
   class HandoffError < Error; end
 
-  # Raised when a network or transport layer call fails (e.g. LLM API unreachable,
-  # MCP server connection refused). Distinguishable from application-level errors
-  # so callers can apply network-specific retry logic.
   class TransportError < Error; end
-
-  # Raised when the LLM API returns a rate-limit response (HTTP 429 or equivalent).
-  # Callers should back off and retry after the indicated delay.
   class RateLimitError < TransportError; end
-
-  # Raised when the LLM API rejects the request due to an invalid or revoked API key.
-  # Callers should not retry without fixing the credentials.
   class AuthenticationError < TransportError; end
-
-  # Raised when the prompt exceeds the model's context window limit.
   class ContextLengthError < Error; end
-
-  # Raised when a workflow or agent execution is explicitly cancelled.
-  # Separate from TimeoutError (deadline exceeded) — this is an intentional stop.
   class CancellationError < Error; end
 
-  # Raised when {Agent#invoke} (a synchronous, blocking call) is attempted from
-  # inside an active scheduler task and +strict_runtime_guards+ is enabled.
-  #
-  # Calling a blocking invocation from within a scheduler task stalls the
-  # scheduler until the inner invocation completes, preventing other tasks from
-  # making progress (hidden deadlock risk).  Use {Agent#invoke_async} followed by
-  # +#await+ inside scheduler tasks instead.
-  #
-  # This error is only raised when:
-  #   Phronomy.configure { |c| c.strict_runtime_guards = true }
-  #
-  # By default a warning is logged and execution continues.
-  #
-  # @see Phronomy::Runtime.in_scheduler_context?
   class SchedulerReentrancyError < Error; end
-
-  # Raised when work is submitted to a Runtime whose shutdown has begun, or
-  # when a Runtime cannot be reset because owned resources are still alive.
   class RuntimeShutdownError < Error; end
-
-  # Raised when Runtime#shutdown is invoked from inside a Phronomy::Task.
   class RuntimeShutdownReentrancyError < RuntimeShutdownError; end
 
-  # Raised by {Phronomy::GeneratorVerifier#invoke} when +raise_if_untrusted: true+
-  # and the pipeline's combined confidence score falls below the configured threshold.
-  #
-  # @example
-  #   rescue Phronomy::LowConfidenceError => e
-  #     puts e.result.confidence   # => e.g. 0.45
-  #     puts e.result.output       # best-effort answer despite low confidence
   class LowConfidenceError < Error
-    # @return [Phronomy::GeneratorVerifier::Result] the untrusted result
     attr_reader :result
 
     def initialize(result)
@@ -114,9 +51,6 @@ module Phronomy
     end
   end
 
-  # Raised by a {Phronomy::Filter::Base} subclass when the filter rejects a
-  # value without transforming it (blocking the pipeline).
-  # @api public
   class FilterBlockError < Error
     attr_reader :filter
 
@@ -126,27 +60,12 @@ module Phronomy
     end
   end
 
-  # Raised when an operation is submitted to a {BlockingAdapterPool} that has
-  # already been shut down via {BlockingAdapterPool#shutdown}.
   class PoolShutdownError < Error; end
-
-  # Raised when a concurrency limit is exceeded and the configured backpressure
-  # strategy is +:raise+. The caller should back off and retry.
   class BackpressureError < Error; end
 
-  # Raised by {CancellationScope#pop_queue} when the deadline expires before a
-  # result is available. Extends {TimeoutError} for backwards compatibility.
-  class ScopeTimeoutError < TimeoutError; end
-
-  # Deprecated compatibility constant. Workflow entry/exit actions are
-  # synchronous and the Workflow DSL no longer accepts +action_timeout:+.
-  class ActionTimeoutError < TimeoutError; end
-
-  # Raised when a {Phronomy::WorkflowContext} field is mutated from a thread
-  # that does not own the context (i.e. not the EventLoop dispatch thread).
-  # Only raised in EventLoop mode.  Use +context.merge(...)+ to produce a new
-  # context, or deliver updates as +:action_completed+ event payloads
-  # via {Agent::Base#invoke_async} + {Task#map}.
+  # Raised when a WorkflowContext field is mutated from a thread that does not
+  # own the context. Deliver asynchronous updates back to the Workflow as later
+  # events via Workflow#signal instead of mutating context from worker callbacks.
   class WorkflowContextOwnershipError < Error; end
 
   class << self
@@ -158,36 +77,10 @@ module Phronomy
       yield configuration
     end
 
-    # Resets the global Phronomy configuration to defaults.
-    #
-    # **Intended for test suites only.** Calling this in a production process
-    # will drop all runtime configuration (tracer, model, tokenizer, etc.)
-    # globally and immediately affect all subsequent agent and workflow calls.
-    #
-    # **Parallel test suites warning:** When tests run in parallel (e.g.
-    # `parallel_tests` or `parallel_rspec`), +reset_configuration!+ in one
-    # worker will clear configuration shared with other workers in the same
-    # process. Prefer process-isolation strategies (forked workers) over
-    # thread-based parallelism when using this method.
-    #
-    # Typical usage in a sequential test suite:
-    #   after { Phronomy.reset_configuration! }
     def reset_configuration!
       @configuration = Configuration.new
     end
 
-    # Yields the current {Configuration} object, then restores the original
-    # configuration on exit (even if the block raises).
-    #
-    # Intended for test helpers that need to temporarily override settings
-    # without permanently mutating the global configuration.
-    #
-    # @yield [config] the current {Configuration} instance (mutable)
-    # @example
-    #   Phronomy.with_configuration do |c|
-    #     c.logger = Logger.new($stdout)
-    #   end
-    # @api public
     def with_configuration
       original = @configuration&.dup
       yield configuration
@@ -195,16 +88,6 @@ module Phronomy
       @configuration = original
     end
 
-    # Shuts down and clears the process-wide default Runtime, then resets
-    # global configuration. Intended for test suites only.
-    #
-    # Runtime execution failure and resource cleanup are separate. The
-    # singleton is cleared when cleanup completed, even if execution failed.
-    #
-    # @param timeout [Numeric] maximum graceful wait for Runtime tasks and
-    #   EventLoop shutdown
-    # @return [Phronomy::Runtime::ShutdownResult]
-    # @api public
     def reset_runtime!(timeout: configuration.event_loop_stop_grace_seconds)
       previous_grace = @configuration&.event_loop_stop_grace_seconds
       result = Runtime.reset_default!(timeout: timeout)

data/scripts/api_snapshot.rb

@@ -4,23 +4,17 @@
 # scripts/api_snapshot.rb
 #
 # Dumps the public instance methods of all Stable/Beta public API classes to
-# JSON.  The snapshot is stored in spec/fixtures/api_snapshot.json and is used
+# JSON. The snapshot is stored in spec/fixtures/api_snapshot.json and is used
 # by spec/phronomy/api_compatibility_spec.rb to detect unintended API removals.
 #
 # Usage:
-#   # Regenerate spec/fixtures/api_snapshot.json (run when intentionally adding
-#   # or removing public API methods after updating the stability table):
 #   ruby scripts/api_snapshot.rb --write
-#
-#   # Print snapshot to stdout (useful for manual inspection):
 #   ruby scripts/api_snapshot.rb
 
 require "json"
 require "fileutils"
 require_relative "../lib/phronomy"
 
-# Classes and modules whose public API is tracked.
-# Add an entry whenever a new class/module is promoted to Stable or Beta in README.md.
 PUBLIC_API_ENTRIES = [
   # Stable
   Phronomy::Agent::Base,
@@ -37,8 +31,6 @@ PUBLIC_API_ENTRIES = [
   Phronomy::VectorStore::Base,
   Phronomy::VectorStore::InMemory,
   Phronomy::VectorStore::Embeddings::Base,
-  Phronomy::Agent::Context::Knowledge::Base,
-  Phronomy::Agent::Context::Knowledge::StaticKnowledge,
   Phronomy::Tracing::Base,
   Phronomy::Tracing::NullTracer,
   Phronomy::Eval::Runner,
@@ -47,7 +39,6 @@ PUBLIC_API_ENTRIES = [
   Phronomy::Tools::VectorSearch
 ].freeze
 
-# Baseline methods common to all Ruby objects — excluded from the snapshot.
 BASELINE_INSTANCE_METHODS = (
   Object.public_instance_methods |
   Kernel.public_instance_methods
@@ -60,7 +51,6 @@ BASELINE_CLASS_METHODS = (
 
 def snapshot_entry(klass)
   if klass.instance_of?(Module)
-    # Module — capture instance methods defined in this module only
     own_methods = klass.public_instance_methods(false).sort
     {
       "name" => klass.name,
@@ -68,7 +58,6 @@ def snapshot_entry(klass)
       "public_instance_methods" => own_methods
     }
   else
-    # Class — capture public instance methods minus universal baseline
     instance_methods = (klass.public_instance_methods - BASELINE_INSTANCE_METHODS).sort
     class_methods = (klass.public_methods(false) - BASELINE_CLASS_METHODS).sort
     {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phronomy
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Raizo T.C.S
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-08 00:00:00.000000000 Z
+date: 2026-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_llm
@@ -117,6 +117,7 @@ files:
 - docs/decisions/011-build-context-as-single-llm-input-authority.md
 - docs/decisions/011-delegate-transport-policy-to-adapters.md
 - docs/decisions/012-canonical-execution-log-and-context-policy.md
+- docs/decisions/013-journal-backed-knowledge-as-context-candidates.md
 - docs/mcp-client.md
 - examples/workflows/agent_event_mapping.rb
 - examples/workflows/generic_task_event_mapping.rb
@@ -137,9 +138,6 @@ files:
 - lib/phronomy/agent/concerns/filterable.rb
 - lib/phronomy/agent/context/capability/base.rb
 - lib/phronomy/agent/context/instruction/prompt_template.rb
-- lib/phronomy/agent/context/knowledge/base.rb
-- lib/phronomy/agent/context/knowledge/entity_knowledge.rb
-- lib/phronomy/agent/context/knowledge/static_knowledge.rb
 - lib/phronomy/agent/context_assembler.rb
 - lib/phronomy/agent/context_candidate.rb
 - lib/phronomy/agent/context_candidate_resolver.rb
@@ -159,7 +157,6 @@ files:
 - lib/phronomy/agent/context_selection_unit.rb
 - lib/phronomy/agent/derived_content_spec.rb
 - lib/phronomy/agent/execution_coordinator.rb
-- lib/phronomy/agent/fsm_runtime_adapter.rb
 - lib/phronomy/agent/immutable.rb
 - lib/phronomy/agent/journal_projection.rb
 - lib/phronomy/agent/journal_record.rb
@@ -236,12 +233,9 @@ files:
 - lib/phronomy/invalid_async_workflow_action_error.rb
 - lib/phronomy/invalid_context_budget_configuration_error.rb
 - lib/phronomy/invocation_context.rb
-- lib/phronomy/knowledge_source.rb
 - lib/phronomy/llm_adapter.rb
 - lib/phronomy/llm_adapter/base.rb
 - lib/phronomy/llm_adapter/ruby_llm.rb
-- lib/phronomy/llm_context_window/assembler.rb
-- lib/phronomy/llm_context_window/context_version_cache.rb
 - lib/phronomy/llm_context_window/token_budget.rb
 - lib/phronomy/llm_context_window/token_estimator.rb
 - lib/phronomy/metrics.rb