phronomy 0.18.0 → 0.19.0

data/lib/phronomy/agent/execution_coordinator.rb

@@ -26,10 +26,14 @@ module Phronomy
           if error
             post_prep_failure(runtime, on_event, result_task, translated(error))
           else
-            register(prepared, result_task, mode: mode,
+            register(
+              prepared,
+              result_task,
+              mode: mode,
               approval_policy: approval_policy,
               approval_listener: approval_listener,
-              on_event: on_event)
+              on_event: on_event
+            )
           end
         end
         result_task
@@ -52,27 +56,37 @@ module Phronomy
           name: "agent-approval-resume:#{execution_id}"
         )
         runtime = Phronomy::Runtime.instance
-        preparation = runtime.offload.submit(on_full: :raise) do
-          execution = @agent.persistence.executions.load(execution_id)
-          unless execution.agent_id == @agent.agent_id && execution.status == :suspended
-            raise ArgumentError,
-              "execution is not a suspended execution of this agent: #{execution_id}"
-          end
-
-          activation = @agent.persistence.activations.fetch(execution_id)
-          unless activation
-            raise Phronomy::ExecutionRehydrationRequiredError,
+        activation = runtime.__agent_activations.fetch(execution_id)
+        unless activation
+          fail_task(
+            result_task,
+            Phronomy::ExecutionRehydrationRequiredError.new(
               "no live activation for #{execution_id}; durable rehydration is required"
-          end
+            )
+          )
+          return result_task
+        end
 
+        unless activation.agent.equal?(@agent) &&
+            activation.execution.status == :suspended
+          fail_task(
+            result_task,
+            ArgumentError.new(
+              "execution is not a suspended execution of this agent: #{execution_id}"
+            )
+          )
+          return result_task
+        end
+
+        preparation = runtime.offload.submit(on_full: :raise) do
           mark_resuming!(
-            execution_id,
+            activation,
             approval_request_id: approval_request_id,
             approved: approved
           )
           activation
         end
-        preparation.on_complete do |activation, error|
+        preparation.on_complete do |prepared_activation, error|
           if error
             fail_task(result_task, translated(error))
             next
@@ -80,20 +94,24 @@ module Phronomy
 
           begin
             start_resume(
-              activation,
+              prepared_activation,
               result_task,
               approved: approved,
               config: config
             )
           rescue => start_error
             commit = runtime.offload.submit(on_full: :raise) do
-              commit_failed(activation, activation.invocation, start_error)
+              commit_failed(
+                prepared_activation,
+                prepared_activation.invocation,
+                start_error
+              )
             end
             commit.on_complete do |terminal, commit_error|
               if commit_error
                 fail_task(result_task, commit_error)
               else
-                @agent.persistence.activations.delete(execution_id)
+                runtime.__agent_activations.delete(execution_id)
                 fail_task(result_task, terminal.fetch(:error))
               end
             end
@@ -101,22 +119,27 @@ module Phronomy
         end
         result_task
       rescue => error
-        fail_task(result_task, translated(error))
+        fail_task(result_task, translated(error)) if result_task
         result_task
       end
 
-      # Persists all Runtime events from the previous call, fixes the next
-      # Canonical LLM Input Manifest, and materializes the next Runtime Projection.
-      # This method is executed on an OffloadPool worker, never on EventLoop.
+      # Persists facts from the previous Provider/Tool cycle and fixes the next
+      # Manifest from the current local Agent state. This runs on OffloadPool.
       def prepare_next_llm_call(activation)
         snapshot = activation.runtime_snapshot
-        manifest = manifest_ref = updated = root = nil
+        root = @agent.agent_root
+        current = activation.execution
+        journal_records = @agent.send(:_journal_records_snapshot)
+        manifest = manifest_ref = updated = nil
 
         @agent.persistence.transaction do |tx|
-          root = tx.agents.load(@agent.agent_id)
-          current = tx.executions.load(activation.execution_id)
+          assert_local_durable_base!(tx, root)
           encoded_records, call_records = encode_runtime_records(
-            activation, tx: tx, snapshot: snapshot, context_candidate: true
+            activation,
+            tx: tx,
+            snapshot: snapshot,
+            context_candidate: true,
+            agent_root: root
           )
           staged = current.with(
             execution_revision: current.execution_revision,
@@ -131,28 +154,38 @@ module Phronomy
             config: invocation_config
           )
           manifest, manifest_ref = ContextAssembler.new(
-            agent: @agent, persistence: tx, policy: context_policy_for(staged)
+            agent: @agent,
+            persistence: tx,
+            policy: context_policy_for(staged),
+            journal_records: journal_records
           ).build_followup(
             base_manifest: activation.base_manifest,
-            agent_root: root, execution: staged,
-            config: invocation_config, patch: patch
+            agent_root: root,
+            execution: staged,
+            config: invocation_config,
+            patch: patch
           )
           refs = Array(staged.metadata["manifest_refs"]) + [manifest_ref]
           updated = staged.with(
             phase: :calling_llm,
             metadata: staged.metadata.merge(
-              "manifest_ref" => manifest_ref, "manifest_refs" => refs
+              "manifest_ref" => manifest_ref,
+              "manifest_refs" => refs
             )
           )
-          tx.executions.save(current.execution_id,
-            expected_revision: current.execution_revision, execution: updated)
+          tx.executions.save(
+            current.execution_id,
+            expected_revision: current.execution_revision,
+            execution: updated
+          )
         end
 
         activation.replace_execution(updated)
         activation.acknowledge_runtime_snapshot(snapshot)
 
         projection = RubyLLMMaterializer.new(
-          agent: @agent, persistence: @agent.persistence
+          agent: @agent,
+          persistence: @agent.persistence
         ).materialize(manifest: manifest, manifest_ref: manifest_ref)
         activation.replace_runtime_projection(projection)
         projection
@@ -160,8 +193,12 @@ module Phronomy
 
       def prepare(input, thread_id:, config:)
         raw_message = @agent.send(:extract_message, input)
-        execution, active_root = admit_execution(raw_message, thread_id: thread_id)
+        execution, active_root = admit_execution(
+          raw_message,
+          thread_id: thread_id
+        )
         @agent.__replace_root(active_root)
+        current_execution = execution
 
         begin
           effective_config = thread_id ? config.merge(thread_id: thread_id) : config
@@ -177,29 +214,27 @@ module Phronomy
             "invocation cancelled before context assembly"
           )
           filtered_message = @agent.send(:extract_message, filtered_input)
-          manifest = nil
-          manifest_ref = nil
-          active_execution = nil
+          manifest = manifest_ref = active_execution = nil
+          local_journal = @agent.send(:_journal_records_snapshot)
 
           @agent.persistence.transaction do |tx|
-            root = tx.agents.load(@agent.agent_id)
-            current = tx.executions.load(execution.execution_id)
+            assert_local_durable_base!(tx, active_root)
             filtered_ref = tx.contents.put_text(filtered_message)
             input_record = JournalRecord.new(
               agent_id: @agent.agent_id,
-              execution_id: current.execution_id,
+              execution_id: current_execution.execution_id,
               kind: :external_message,
               channel: :external,
               role: :user,
               content_ref: filtered_ref,
               correlation_id: thread_id,
-              context_generation: root.transcript_generation,
+              context_generation: active_root.transcript_generation,
               context_candidate: true
             )
-            staged = current.with(
-              execution_revision: current.execution_revision,
-              working_records: current.working_records + [input_record],
-              metadata: current.metadata.merge(
+            staged = current_execution.with(
+              execution_revision: current_execution.execution_revision,
+              working_records: current_execution.working_records + [input_record],
+              metadata: current_execution.metadata.merge(
                 "current_input_ref" => filtered_ref,
                 "current_input_record_id" => input_record.record_id
               )
@@ -207,10 +242,11 @@ module Phronomy
             manifest, manifest_ref = ContextAssembler.new(
               agent: @agent,
               persistence: tx,
-              policy: context_policy_for(staged)
+              policy: context_policy_for(staged),
+              journal_records: local_journal
             ).build_initial(
               input: filtered_input,
-              agent_root: root,
+              agent_root: active_root,
               execution: staged,
               config: effective_config,
               patch: @agent.send(
@@ -229,34 +265,35 @@ module Phronomy
               )
             )
             tx.executions.save(
-              current.execution_id,
-              expected_revision: current.execution_revision,
+              current_execution.execution_id,
+              expected_revision: current_execution.execution_revision,
               execution: active_execution
             )
           end
+          current_execution = active_execution
 
           projection = RubyLLMMaterializer.new(
             agent: @agent,
             persistence: @agent.persistence
           ).materialize(manifest: manifest, manifest_ref: manifest_ref)
-          Prepared.new(
+          Phronomy::Agent::ExecutionCoordinator::Prepared.new(
             execution: active_execution,
             runtime_projection: projection,
             filtered_input: filtered_input,
             config: effective_config
           )
         rescue => error
-          commit_preparation_failure(execution, error)
+          commit_preparation_failure(current_execution, error)
           raise
         end
       end
 
       def admit_execution(raw_message, thread_id:)
-        execution = nil
-        root = nil
+        root = @agent.agent_root
+        raise Phronomy::Error, "agent is closed: #{@agent.agent_id}" if root.lifecycle_status == :closed
+
+        execution = next_root = nil
         @agent.persistence.transaction do |tx|
-          root = tx.agents.load(@agent.agent_id)
-          raise Phronomy::Error, "agent is closed: #{@agent.agent_id}" if root.lifecycle_status == :closed
           input_ref = tx.contents.put_text(raw_message)
           input_record = JournalRecord.new(
             agent_id: @agent.agent_id,
@@ -290,29 +327,34 @@ module Phronomy
             agent_revision: root.agent_revision + 1,
             lifecycle_status: :active
           )
-          tx.agents.save(root.agent_id, expected_revision: root.agent_revision, root: next_root)
-          root = next_root
+          tx.agents.save(
+            root.agent_id,
+            expected_revision: root.agent_revision,
+            root: next_root
+          )
         end
-        [execution, root]
+        [execution, next_root]
       end
 
       def commit_preparation_failure(execution, error)
         translated_error = translated(error)
-        root = nil
+        root = @agent.agent_root
+        failed = next_root = appended = nil
+
         @agent.persistence.transaction do |tx|
-          current = tx.executions.load(execution.execution_id)
-          root = tx.agents.load(@agent.agent_id)
           error_ref = tx.contents.put_json(
             "class" => translated_error.class.name,
             "message" => translated_error.message
           )
-          audit_records = current.working_records.map do |record|
-            JournalRecord.from_h(record.to_h.merge("context_candidate" => false))
+          audit_records = execution.working_records.map do |record|
+            JournalRecord.from_h(
+              record.to_h.merge("context_candidate" => false)
+            )
           end
           terminal_status = terminal_status_for(translated_error)
           audit_records << JournalRecord.new(
             agent_id: @agent.agent_id,
-            execution_id: current.execution_id,
+            execution_id: execution.execution_id,
             kind: execution_terminal_kind(terminal_status),
             channel: :audit,
             content_ref: error_ref,
@@ -324,7 +366,7 @@ module Phronomy
             expected_position: root.journal_position,
             records: audit_records
           )
-          failed = current.with(
+          failed = execution.with(
             status: terminal_status,
             phase: terminal_status,
             working_records: [],
@@ -332,8 +374,8 @@ module Phronomy
             terminal_reason: translated_error.class.name
           )
           tx.executions.save(
-            current.execution_id,
-            expected_revision: current.execution_revision,
+            execution.execution_id,
+            expected_revision: execution.execution_revision,
             execution: failed
           )
           next_root = root.with(
@@ -341,10 +383,15 @@ module Phronomy
             journal_position: root.journal_position + appended.length,
             lifecycle_status: :idle
           )
-          tx.agents.save(root.agent_id, expected_revision: root.agent_revision, root: next_root)
-          root = next_root
+          tx.agents.save(
+            root.agent_id,
+            expected_revision: root.agent_revision,
+            root: next_root
+          )
         end
-        @agent.__replace_root(root)
+        @agent.send(:_append_journal_records, appended)
+        @agent.__replace_root(next_root)
+        failed
       end
 
       def register(prepared, result_task, mode:, approval_policy:, approval_listener:, on_event:)
@@ -355,8 +402,8 @@ module Phronomy
           coordinator: self,
           application_listener: on_event
         )
-        @agent.persistence.activations.register(activation)
         runtime = Phronomy::Runtime.instance
+        runtime.__agent_activations.register(activation)
         event_loop = runtime.event_loop
         effective_config = prepared.config.merge(
           phronomy_activation: activation,
@@ -388,8 +435,10 @@ module Phronomy
         event_loop.register(session, completion: source_task)
       rescue => error
         activation ||= AgentExecutionActivation.new(
-          execution: prepared.execution, agent: @agent,
-          runtime_projection: prepared.runtime_projection, coordinator: self,
+          execution: prepared.execution,
+          agent: @agent,
+          runtime_projection: prepared.runtime_projection,
+          coordinator: self,
           application_listener: on_event
         )
         finish(activation, result_task, activation.invocation, error)
@@ -411,7 +460,11 @@ module Phronomy
               payload: {command: command}
             )
           )
-          settle_without_listener(activation, result_task, outcome, commit_error) unless posted
+          unless posted
+            settle_without_listener(
+              activation, result_task, outcome, commit_error
+            )
+          end
         end
       rescue => caught
         fail_task(result_task, translated(caught))
@@ -431,8 +484,11 @@ module Phronomy
             )
           )
           settle_after_terminal(
-            command.result_task, callback_error,
-            terminal_event_type(command.error), nil, command.error
+            command.result_task,
+            callback_error,
+            terminal_event_type(command.error),
+            nil,
+            command.error
           )
         when AgentTerminalCommand
           deliver_execution_terminal(command)
@@ -445,7 +501,11 @@ module Phronomy
 
       def compute_terminal(activation, invocation, error)
         if (failure = activation.callback_failure)
-          terminal = commit_failed(activation, invocation, failure.to_stream_callback_error)
+          terminal = commit_failed(
+            activation,
+            invocation,
+            failure.to_stream_callback_error
+          )
           return {type: :failed, error: terminal.fetch(:error)}
         end
         if error
@@ -453,10 +513,14 @@ module Phronomy
           return {type: :failed, error: terminal.fetch(:error)}
         end
         if invocation&.phase == :suspended
-          return {type: :suspended, result: commit_suspended(activation, invocation)}
+          return {
+            type: :suspended,
+            result: commit_suspended(activation, invocation)
+          }
         end
         raise invocation.block_error if invocation.input_blocked? || invocation.output_blocked?
         raise invocation.error if invocation.error
+
         {type: :completed, result: commit_completed(activation, invocation)}
       rescue => caught
         terminal = commit_failed(activation, invocation, caught)
@@ -464,17 +528,20 @@ module Phronomy
       end
 
       def commit_suspended(activation, invocation)
-        execution = activation.execution
+        current = activation.execution
+        root = @agent.agent_root
         request = invocation.approval_request
         runtime_snapshot = activation.runtime_snapshot
-        suspended = nil
-        root = nil
+        suspended = next_root = nil
+
         @agent.persistence.transaction do |tx|
           encoded_records, call_records = encode_runtime_records(
-            activation, tx: tx, snapshot: runtime_snapshot, context_candidate: true
+            activation,
+            tx: tx,
+            snapshot: runtime_snapshot,
+            context_candidate: true,
+            agent_root: root
           )
-          root = tx.agents.load(@agent.agent_id)
-          current = tx.executions.load(execution.execution_id)
           request_ref = tx.contents.put_json(json_value(request.to_h))
           approval_record = JournalRecord.new(
             agent_id: @agent.agent_id,
@@ -502,33 +569,37 @@ module Phronomy
             agent_revision: root.agent_revision + 1,
             lifecycle_status: :suspended
           )
-          tx.agents.save(root.agent_id, expected_revision: root.agent_revision, root: next_root)
-          root = next_root
+          tx.agents.save(
+            root.agent_id,
+            expected_revision: root.agent_revision,
+            root: next_root
+          )
         end
         activation.acknowledge_runtime_snapshot(runtime_snapshot)
         activation.replace_execution(suspended)
-        @agent.__replace_root(root)
+        @agent.__replace_root(next_root)
         dispatch_approval_listener(invocation, request)
-        result_base(suspended, root).merge(
+        result_base(suspended, next_root).merge(
           suspended: true,
           approval_request: request
         )
       end
 
       def commit_completed(activation, invocation)
-        execution = activation.execution
+        current = activation.execution
+        root = @agent.agent_root
         runtime_snapshot = activation.runtime_snapshot
-        completed = nil
-        root = nil
-        appended = nil
+        completed = next_root = appended = nil
 
         @agent.persistence.transaction do |tx|
           encoded_records, call_records = encode_runtime_records(
-            activation, tx: tx, snapshot: runtime_snapshot, context_candidate: true
+            activation,
+            tx: tx,
+            snapshot: runtime_snapshot,
+            context_candidate: true,
+            agent_root: root
           )
           output_ref = tx.contents.put_text(invocation.output.to_s)
-          root = tx.agents.load(@agent.agent_id)
-          current = tx.executions.load(execution.execution_id)
           final_output_record = JournalRecord.new(
             agent_id: @agent.agent_id,
             execution_id: current.execution_id,
@@ -576,38 +647,47 @@ module Phronomy
             journal_position: root.journal_position + appended.length,
             lifecycle_status: :idle
           )
-          tx.agents.save(root.agent_id, expected_revision: root.agent_revision, root: next_root)
-          root = next_root
+          tx.agents.save(
+            root.agent_id,
+            expected_revision: root.agent_revision,
+            root: next_root
+          )
         end
         activation.acknowledge_runtime_snapshot(runtime_snapshot)
         activation.replace_execution(completed)
-        @agent.__replace_root(root)
-        result_base(completed, root).merge(
+        @agent.send(:_append_journal_records, appended)
+        @agent.__replace_root(next_root)
+        result_base(completed, next_root).merge(
           output: invocation.output,
           rejected: invocation.rejected || nil,
           usage: invocation.usage,
-          messages: transcript_messages(root)
+          messages: transcript_messages(next_root)
         ).compact
       end
 
       def commit_failed(activation, _invocation, error)
         translated_error = translated(error)
-        execution = activation.execution
+        current = activation.execution
+        root = @agent.agent_root
         runtime_snapshot = activation.runtime_snapshot
-        failed = nil
-        root = nil
+        failed = next_root = appended = nil
+
         @agent.persistence.transaction do |tx|
           encoded_records, call_records = encode_runtime_records(
-            activation, tx: tx, snapshot: runtime_snapshot, context_candidate: false
+            activation,
+            tx: tx,
+            snapshot: runtime_snapshot,
+            context_candidate: false,
+            agent_root: root
           )
           error_ref = tx.contents.put_json(
             "class" => translated_error.class.name,
             "message" => translated_error.message
           )
-          root = tx.agents.load(@agent.agent_id)
-          current = tx.executions.load(execution.execution_id)
           audit_records = (current.working_records + encoded_records).map do |record|
-            JournalRecord.from_h(record.to_h.merge("context_candidate" => false))
+            JournalRecord.from_h(
+              record.to_h.merge("context_candidate" => false)
+            )
           end
           terminal_status = terminal_status_for(translated_error)
           audit_records << JournalRecord.new(
@@ -642,18 +722,28 @@ module Phronomy
             journal_position: root.journal_position + appended.length,
             lifecycle_status: :idle
           )
-          tx.agents.save(root.agent_id, expected_revision: root.agent_revision, root: next_root)
-          root = next_root
+          tx.agents.save(
+            root.agent_id,
+            expected_revision: root.agent_revision,
+            root: next_root
+          )
         end
         activation.acknowledge_runtime_snapshot(runtime_snapshot)
         activation.replace_execution(failed)
-        @agent.__replace_root(root)
-        {error: translated_error, execution: failed, root: root}
+        @agent.send(:_append_journal_records, appended)
+        @agent.__replace_root(next_root)
+        {error: translated_error, execution: failed, root: next_root}
       end
 
-      def encode_runtime_records(activation, tx:, snapshot:, context_candidate:)
+      def encode_runtime_records(
+        activation,
+        tx:,
+        snapshot:,
+        context_candidate:,
+        agent_root:
+      )
         execution = activation.execution
-        root = tx.agents.load(@agent.agent_id)
+        root = agent_root
         records = []
         calls = []
 
@@ -665,10 +755,12 @@ module Phronomy
           call_error = intercepted ? nil : error
           output_ref = assistant_output_ref(tx, outcome)
           assistant_ref = assistant_message_ref(tx, outcome)
-          error_ref = call_error ? tx.contents.put_json(
-            "class" => call_error.class.name,
-            "message" => call_error.message
-          ) : nil
+          error_ref = if call_error
+            tx.contents.put_json(
+              "class" => call_error.class.name,
+              "message" => call_error.message
+            )
+          end
           usage_ref = if outcome && !outcome.usage.empty?
             tx.contents.put_json(json_value(outcome.usage))
           end
@@ -728,7 +820,9 @@ module Phronomy
             manifest_ref: active.fetch(:manifest_ref),
             started_at: active.fetch(:started_at),
             completed_at: Time.now.utc.iso8601(6),
-            metadata: {"reason" => "execution_terminalized_before_provider_settlement"}
+            metadata: {
+              "reason" => "execution_terminalized_before_provider_settlement"
+            }
           )
           calls << abandoned
           records << JournalRecord.new(
@@ -746,18 +840,12 @@ module Phronomy
         snapshot.fetch(:runtime_events).each do |event|
           case event.type
           when :tool_call
-            # Tool Calls remain part of the captured assistant message. The
-            # StreamEvent is an application/runtime notification only.
             next
           when :tool_result
             payload = event.payload
             llm_call_id = payload[:llm_call_id] || payload["llm_call_id"]
             tool_call_id = payload.fetch(:tool_call_id).to_s
             tool_name = payload.fetch(:tool_name).to_s
-
-            # The raw Tool return value is an execution fact, not an LLM message.
-            # Keep it in the complete Journal, but never expose it directly as a
-            # Context candidate.
             result_ref = put_runtime_content(tx, payload.fetch(:tool_result))
             records << JournalRecord.new(
               agent_id: @agent.agent_id,
@@ -775,8 +863,6 @@ module Phronomy
               }
             )
 
-            # Separately preserve the exact Tool message that was appended to
-            # RubyLLM Chat and therefore became eligible for a later Manifest.
             message_payload = if payload.key?(:tool_message)
               payload.fetch(:tool_message)
             else
@@ -803,56 +889,22 @@ module Phronomy
         [records, calls]
       end
 
-      def assistant_message_ref(tx, outcome)
-        return unless outcome
-
-        payload = {
-          "role" => "assistant",
-          "content" => json_value(outcome.content),
-          "tool_calls" => json_value(Array(outcome.tool_calls)),
-          "model_id" => outcome.metadata["model_id"]
-        }.compact
-        tx.contents.put_json(payload)
-      end
-
-      def assistant_message_metadata(outcome)
-        calls = Array(outcome&.tool_calls)
-        {
-          "tool_call_ids" => calls.map { |call| call.fetch("id").to_s },
-          "tool_names" => calls.map { |call| call.fetch("name").to_s }
-        }
-      end
-
-      def assistant_output_ref(tx, outcome)
-        return unless outcome&.content_present?
-
-        content = outcome.content
-        text = content.is_a?(String) ? content : Phronomy::CanonicalJSON.dump(content)
-        tx.contents.put_text(text)
-      end
+      def mark_resuming!(activation, approval_request_id:, approved:)
+        current = activation.execution
+        current_root = @agent.agent_root
+        unless current.agent_id == @agent.agent_id && current.status == :suspended
+          raise ArgumentError, "execution is not suspended: #{current.execution_id}"
+        end
 
-      def put_runtime_content(tx, value)
-        value.is_a?(String) ? tx.contents.put_text(value) : tx.contents.put_json(json_value(value))
-      end
+        request = current.approval_request || {}
+        request_id = request["id"] || request[:id]
+        unless request_id.to_s == approval_request_id.to_s
+          raise ArgumentError,
+            "approval request does not match execution #{current.execution_id}"
+        end
 
-      def mark_resuming!(execution_id, approval_request_id:, approved:)
-        root = nil
-        updated = nil
+        updated = next_root = nil
         @agent.persistence.transaction do |tx|
-          current = tx.executions.load(execution_id)
-          unless current.agent_id == @agent.agent_id && current.status == :suspended
-            raise ArgumentError,
-              "execution is not suspended: #{execution_id}"
-          end
-
-          request = current.approval_request || {}
-          request_id = request["id"] || request[:id]
-          unless request_id.to_s == approval_request_id.to_s
-            raise ArgumentError,
-              "approval request does not match execution #{execution_id}"
-          end
-
-          current_root = tx.agents.load(@agent.agent_id)
           decision_ref = tx.contents.put_json(
             "approval_request_id" => request_id.to_s,
             "approved" => !!approved
@@ -887,13 +939,151 @@ module Phronomy
             expected_revision: current_root.agent_revision,
             root: next_root
           )
-          root = next_root
         end
-        @agent.persistence.activations.fetch(execution_id)&.replace_execution(updated)
-        @agent.__replace_root(root)
+        activation.replace_execution(updated)
+        @agent.__replace_root(next_root)
         updated
       end
 
+      def assert_local_durable_base!(tx, root)
+        tx.assert_agent_watermark!(
+          agent_id: root.agent_id,
+          agent_revision: root.agent_revision,
+          journal_position: root.journal_position
+        )
+      end
+
+      def transcript_messages(root)
+        materializer = RubyLLMMaterializer.new(
+          agent: @agent,
+          persistence: @agent.persistence
+        )
+        materializer.materialize_journal_records(
+          JournalProjection.new(
+            agent_root: root,
+            records: @agent.send(:_journal_records_snapshot)
+          ).transcript_records
+        )
+      end
+
+      def deliver_execution_terminal(command)
+        activation = command.activation
+        registry = Phronomy::Runtime.instance.__agent_activations
+        if command.commit_error
+          callback_error = deliver_terminal(
+            activation,
+            :error,
+            error: command.commit_error
+          )
+          settle_after_terminal(
+            command.result_task,
+            callback_error,
+            :error,
+            nil,
+            command.commit_error
+          )
+          return
+        end
+
+        outcome = command.outcome
+        case outcome.fetch(:type)
+        when :suspended
+          result = outcome.fetch(:result)
+          callback_error = deliver_terminal(
+            activation,
+            :approval_required,
+            request: result.fetch(:approval_request)
+          )
+          settle_after_terminal(
+            command.result_task,
+            callback_error,
+            :approval_required,
+            result
+          )
+        when :completed
+          registry.delete(activation.execution_id)
+          result = outcome.fetch(:result)
+          callback_error = deliver_terminal(activation, :done, result)
+          settle_after_terminal(
+            command.result_task,
+            callback_error,
+            :done,
+            result
+          )
+        when :failed
+          registry.delete(activation.execution_id)
+          error = outcome.fetch(:error)
+          type = terminal_event_type(error)
+          callback_error = deliver_terminal(activation, type, error: error)
+          settle_after_terminal(
+            command.result_task,
+            callback_error,
+            type,
+            nil,
+            error
+          )
+        end
+      end
+
+      def settle_without_listener(activation, result_task, outcome, commit_error)
+        registry = Phronomy::Runtime.instance.__agent_activations
+        if commit_error
+          return fail_task(result_task, commit_error)
+        end
+
+        case outcome&.fetch(:type)
+        when :suspended
+          complete_task(result_task, outcome.fetch(:result))
+        when :completed
+          registry.delete(activation.execution_id)
+          complete_task(result_task, outcome.fetch(:result))
+        when :failed
+          registry.delete(activation.execution_id)
+          fail_task(result_task, outcome.fetch(:error))
+        else
+          registry.delete(activation.execution_id)
+          fail_task(
+            result_task,
+            Phronomy::RuntimeShutdownError.new(
+              "EventLoop is not accepting terminal delivery"
+            )
+          )
+        end
+      end
+
+      def assistant_message_ref(tx, outcome)
+        return unless outcome
+
+        payload = {
+          "role" => "assistant",
+          "content" => json_value(outcome.content),
+          "tool_calls" => json_value(Array(outcome.tool_calls)),
+          "model_id" => outcome.metadata["model_id"]
+        }.compact
+        tx.contents.put_json(payload)
+      end
+
+      def assistant_message_metadata(outcome)
+        calls = Array(outcome&.tool_calls)
+        {
+          "tool_call_ids" => calls.map { |call| call.fetch("id").to_s },
+          "tool_names" => calls.map { |call| call.fetch("name").to_s }
+        }
+      end
+
+      def assistant_output_ref(tx, outcome)
+        return unless outcome&.content_present?
+
+        content = outcome.content
+        text = content.is_a?(String) ? content : Phronomy::CanonicalJSON.dump(content)
+        tx.contents.put_text(text)
+      end
+
+      def put_runtime_content(tx, value)
+        value.is_a?(String) ?
+          tx.contents.put_text(value) : tx.contents.put_json(json_value(value))
+      end
+
       def start_resume(activation, result_task, approved:, config:)
         invocation = activation.invocation
         invocation.merge_config!(config)
@@ -909,7 +1099,12 @@ module Phronomy
         activation.session = parent_session
         source_task = Phronomy::Task.deferred(name: "#{result_task.name}-source")
         source_task.on_complete do |completed, error|
-          finish(activation, result_task, completed || parent_session.context, error)
+          finish(
+            activation,
+            result_task,
+            completed || parent_session.context,
+            error
+          )
         end
         event_loop.register(parent_session, completion: source_task)
         invocation.tool_invocations.each do |child|
@@ -936,6 +1131,7 @@ module Phronomy
         completion = Phronomy::Task.deferred(name: "tool-session:#{child.id}")
         completion.on_complete do |_result, error|
           next unless error
+
           child.mark_framework_failed!(error)
           runtime.event_loop.post_to_session(
             Phronomy::Event.new(
@@ -966,23 +1162,15 @@ module Phronomy
         ContextPolicyRegistry.default.resolve(descriptor)
       end
 
-      def transcript_messages(root)
-        materializer = RubyLLMMaterializer.new(
-          agent: @agent,
-          persistence: @agent.persistence
-        )
-        materializer.materialize_journal_records(
-          JournalProjection.new(
-            persistence: @agent.persistence,
-            agent_root: root
-          ).transcript_records
-        )
-      end
-
       def deliver_terminal(activation, type, payload)
         listener = activation.application_listener
         return nil unless listener
-        @agent.send(:_deliver_stream_event, listener, StreamEvent.new(type: type, payload: payload))
+
+        @agent.send(
+          :_deliver_stream_event,
+          listener,
+          StreamEvent.new(type: type, payload: payload)
+        )
       end
 
       def post_prep_failure(runtime, listener, result_task, error)
@@ -997,79 +1185,55 @@ module Phronomy
         fail_task(result_task, error) unless posted
       end
 
-      def deliver_execution_terminal(command)
-        activation = command.activation
-        if command.commit_error
-          callback_error = deliver_terminal(activation, :error, error: command.commit_error)
-          settle_after_terminal(command.result_task, callback_error, :error, nil, command.commit_error)
-          return
-        end
-        outcome = command.outcome
-        case outcome.fetch(:type)
-        when :suspended
-          result = outcome.fetch(:result)
-          callback_error = deliver_terminal(
-            activation, :approval_required,
-            request: result.fetch(:approval_request)
-          )
-          settle_after_terminal(command.result_task, callback_error, :approval_required, result)
-        when :completed
-          @agent.persistence.activations.delete(activation.execution_id)
-          result = outcome.fetch(:result)
-          callback_error = deliver_terminal(activation, :done, result)
-          settle_after_terminal(command.result_task, callback_error, :done, result)
-        when :failed
-          @agent.persistence.activations.delete(activation.execution_id)
-          error = outcome.fetch(:error)
-          type = terminal_event_type(error)
-          callback_error = deliver_terminal(activation, type, error: error)
-          settle_after_terminal(command.result_task, callback_error, type, nil, error)
-        end
-      end
-
-      def settle_without_listener(activation, result_task, outcome, commit_error)
-        return fail_task(result_task, commit_error) if commit_error
-        case outcome&.fetch(:type)
-        when :suspended then complete_task(result_task, outcome.fetch(:result))
-        when :completed
-          @agent.persistence.activations.delete(activation.execution_id)
-          complete_task(result_task, outcome.fetch(:result))
-        when :failed
-          @agent.persistence.activations.delete(activation.execution_id)
-          fail_task(result_task, outcome.fetch(:error))
-        else
-          fail_task(result_task, Phronomy::RuntimeShutdownError.new("EventLoop is not accepting terminal delivery"))
-        end
-      end
-
-      def settle_after_terminal(result_task, callback_error, event_type, result, execution_error = nil)
+      def settle_after_terminal(
+        result_task,
+        callback_error,
+        event_type,
+        result,
+        execution_error = nil
+      )
         if callback_error
           policy = Phronomy.configuration.stream_callback_error_policy
           @agent.send(
-            :_report_stream_callback_error, callback_error,
-            event: StreamEvent.new(type: event_type, payload: result || {error: execution_error}),
-            invocation_id: nil, callback_error_policy: policy
+            :_report_stream_callback_error,
+            callback_error,
+            event: StreamEvent.new(
+              type: event_type,
+              payload: result || {error: execution_error}
+            ),
+            invocation_id: nil,
+            callback_error_policy: policy
           )
           if policy == :fail_task && execution_error.nil?
-            return fail_task(result_task, @agent.send(
-              :_build_stream_callback_error,
-              event_type: event_type, callback_error: callback_error, result: result
-            ))
+            return fail_task(
+              result_task,
+              @agent.send(
+                :_build_stream_callback_error,
+                event_type: event_type,
+                callback_error: callback_error,
+                result: result
+              )
+            )
           end
         end
-        execution_error ? fail_task(result_task, execution_error) : complete_task(result_task, result)
+        execution_error ?
+          fail_task(result_task, execution_error) : complete_task(result_task, result)
       end
 
       def terminal_event_type(error)
         return :timeout if error.is_a?(Phronomy::TimeoutError)
         return :cancelled if error.is_a?(Phronomy::CancellationError)
+
         :error
       end
 
       def dispatch_approval_listener(invocation, request)
         listener = invocation.approval_listener
         return unless listener
-        Phronomy::Runtime.instance.offload.submit(on_full: :raise) { listener.call(request) }
+
+        Phronomy::Runtime.instance.offload.submit(on_full: :raise) do
+          listener.call(request)
+        end
       end
 
       def json_value(value)
@@ -1086,14 +1250,21 @@ module Phronomy
           if value.respond_to?(:to_h)
             json_value(value.to_h)
           else
-            raise ArgumentError, "unsupported canonical runtime value: #{value.class}"
+            raise ArgumentError,
+              "unsupported canonical runtime value: #{value.class}"
           end
         end
       end
 
       def terminal_status_for(error)
-        return :cancelled if defined?(Phronomy::CancellationError) && error.is_a?(Phronomy::CancellationError)
-        return :blocked if defined?(Phronomy::FilterBlockError) && error.is_a?(Phronomy::FilterBlockError)
+        if defined?(Phronomy::CancellationError) &&
+            error.is_a?(Phronomy::CancellationError)
+          return :cancelled
+        end
+        if defined?(Phronomy::FilterBlockError) &&
+            error.is_a?(Phronomy::FilterBlockError)
+          return :blocked
+        end
 
         :failed
       end