ace-assign 0.63.0 → 0.64.0

data/lib/ace/assign/molecules/evidence_journal.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require "digest"
 require "digest"
 require "fileutils"
 require "json"
 require "open3"
+require_relative "proposal_journal"
+require_relative "journal_mutation"
 
 module Ace
   module Assign
@@ -25,12 +26,25 @@ module Ace
       # reloads the authoritative ref and replays only still-valid,
       # non-duplicate events.
       class EvidenceJournal
+        include JournalMutation
+        include ProposalJournal
         CAS_ATTEMPTS = 3
 
+        # Selected by source composition, never by receipt or wire parameters.
+        def evidence_mode
+          @mode
+        end
+
         # @param repo_root [String] Git repository root holding the evidence ref
         # @param ref [String, nil] Evidence ref (default from config)
         # @param checkout_root [String, nil] Isolated checkout root (default from config)
-        def initialize(repo_root:, ref: nil, checkout_root: nil)
+        def initialize(repo_root:, ref: nil, checkout_root: nil, mode: :local,
+          evidence_reader: nil, service_authorizer: nil)
+          unless %i[local protected].include?(mode) &&
+              (mode != :protected || [evidence_reader, service_authorizer].all? { |owner| owner.respond_to?(:call) })
+            raise ArgumentError, "protected journal requires source-owned evidence and service boundaries"
+          end
+          @mode, @evidence_reader, @service_authorizer = mode, evidence_reader, service_authorizer
           @repo_root = repo_root
           @ref = ref || default_config("evidence_git_ref") || "refs/ace/execution"
           root = checkout_root || default_config("evidence_checkout_root") || ".ace-local/assign/evidence-checkout"
@@ -89,14 +103,36 @@ module Ace
           end
         end
 
+        # Build an event against the latest chain while holding the ref lock.
+        # Re-run the eligibility guard on each CAS retry, never append a
+        # stale chain continuation after another accepted writer.
+        def record(assignment_id:, attempt_id:, type:, payload:, guard: nil)
+          with_lock do
+            CAS_ATTEMPTS.times do
+              old = ref_value
+              ensure_checkout!
+              old = ref_value if old.nil?
+              sync_checkout(old)
+              guard&.call
+              previous = read_events(assignment_id).reverse.find { |event| event["attempt_id"] == attempt_id }&.fetch("digest")
+              event = Models::EvidenceEvent.build(type: type, attempt_id: attempt_id,
+                payload: payload, previous_digest: previous)
+              write_event_files(assignment_id, [event])
+              commit = commit_events(assignment_id, attempt_id, [event])
+              return commit if update_ref_cas(commit, old)
+            end
+            raise AttemptErrors::EvidenceUnavailable, "Evidence ref stayed conflicting during event recording"
+          end
+        end
+
         # Read all journal events recorded for an assignment, ordered by the
         # digest chain (never by filename: same-second events sort
         # alphabetically, which can invert lifecycle order).
         #
         # @param assignment_id [String] Assignment ID
         # @return [Array<Hash>] Parsed events in journal order
-        def read_events(assignment_id)
-          value = ref_value
+        def read_events(assignment_id, commit: ref_value)
+          value = commit
           return [] if value.nil?
 
           paths, stderr, status = git("ls-tree", "-r", "--name-only", value, "--",
@@ -197,7 +233,7 @@ module Ace
           %w[succeeded failed failed-settled].include?(state)
         end
 
-        def validate_terminal_receipt!(current, state, receipt)
+        def validate_terminal_receipt!(current, state, receipt, pending: nil)
           unless receipt.is_a?(Hash) && receipt.keys.sort == TERMINAL_RECEIPT_FIELDS.sort
             raise AttemptErrors::ReceiptRejected,
               "Service terminal receipt has invalid fields"
@@ -224,6 +260,16 @@ module Ace
             raise AttemptErrors::ReceiptRejected,
               "Service settlement requires a no-effect attestation artifact"
           end
+          if @mode == :protected
+            evidence_items.each do |item|
+              content = @evidence_reader.call(item, current, state, pending)
+              unless content.is_a?(String) && Digest::SHA256.hexdigest(content.b) == item["sha256"]
+                raise AttemptErrors::ReceiptRejected, "Canonical service evidence is unverifiable"
+              end
+              verify_service_attestation!(content, current, state)
+            end
+            return true
+          end
           repo_root = File.realpath(@repo_root)
           receipt["evidence"].each do |item|
             path = File.expand_path(item["ref"], repo_root)
@@ -241,24 +287,21 @@ module Ace
             end
             raise AttemptErrors::ReceiptRejected,
               "Service terminal receipt evidence is unverifiable: #{item["ref"]}" unless intact
-            attestation = /^ace-service-attestation request:#{Regexp.escape(current["request_id"])} \
-input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?$/
-            attested = File.read(real).scan(attestation).first
-            attested_outcome = state == "failed-settled" ? "failed" : state
-            unless attested && attested.first == attested_outcome &&
-                (state == "failed-settled" ? attested[2] == "true" : true)
-              raise AttemptErrors::ReceiptRejected,
-                "Service terminal receipt evidence does not attest #{attested_outcome}: #{item["ref"]}"
-            end
+            verify_service_attestation!(File.read(real), current, state)
           end
         end
 
-        def service_request(request_id)
+        def service_request(request_id, commit: ref_value)
           validate_request_id!(request_id)
-          value = ref_value
+          value = commit
           return nil unless value
           out, stderr, status = git("show", "#{value}:#{service_request_path(request_id)}")
-          return JSON.parse(out) if status.success?
+          if status.success?
+            record = JSON.parse(out)
+            verify_service_record!(record, commit: value) if @mode == :protected
+            validate_terminal_receipt!(record, record["state"], record["receipt"], pending: {commit: value}) if @mode == :protected && terminal_state?(record["state"])
+            return record
+          end
           return nil if stderr.include?("does not exist") || stderr.include?("exists on disk")
           raise AttemptErrors::EvidenceUnavailable, "Cannot read service request: #{stderr}"
         rescue JSON::ParserError
@@ -292,6 +335,12 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
         def settlement_evidence_intact?(record)
           receipt = record["receipt"]
           return false unless receipt.is_a?(Hash)
+          if @mode == :protected
+            commit = ref_value
+            verify_service_record!(record, commit: commit)
+            validate_terminal_receipt!(record, "failed-settled", receipt, pending: {commit: commit})
+            return true
+          end
           repo_root = File.realpath(@repo_root)
           Array(receipt["evidence"]).all? do |item|
             path = File.expand_path(item["ref"].to_s, repo_root)
@@ -307,10 +356,12 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
               false
             end
           end
+        rescue AttemptErrors::EvidenceUnavailable, AttemptErrors::ReceiptRejected
+          false
         end
 
-        def service_request_records
-          value = ref_value
+        def service_request_records(commit: ref_value)
+          value = commit
           return [] unless value
           paths, stderr, status = git("ls-tree", "-r", "--name-only", value, "--", "execution/requests/")
           raise AttemptErrors::EvidenceUnavailable, "Cannot read service request index: #{stderr}" unless status.success?
@@ -319,7 +370,9 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
             unless read_status.success?
               raise AttemptErrors::EvidenceUnavailable, "Cannot read service request #{path}: #{error}"
             end
-            JSON.parse(content)
+            record = JSON.parse(content)
+            verify_service_record!(record, commit: value) if @mode == :protected
+            record
           end
         rescue JSON::ParserError
           raise AttemptErrors::EvidenceUnavailable, "Corrupt service request index"
@@ -366,8 +419,8 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
         # ref itself (works even when the local assignment cache is gone).
         #
         # @return [Array<String>] Assignment IDs with journal evidence
-        def assignment_ids
-          value = ref_value
+        def assignment_ids(commit: ref_value)
+          value = commit
           return [] if value.nil?
 
           paths, stderr, status = git("ls-tree", "-d", "--name-only", value, "--", "execution/")
@@ -386,47 +439,20 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
               ensure_checkout!
               old = ref_value if old.nil?
               sync_checkout(old)
-              # Guards (for example authorization consumption) re-run inside
-              # the lock against the ref being committed, so a racing claim
-              # cannot slip through between the check and the CAS.
-              if guard
-                conflict = guard.call
-                if conflict
-                  raise AttemptErrors::Conflict,
-                    "Authorization reference already consumed by request #{conflict.fetch("request_id")}"
-                end
-              end
-              path = File.join(checkout_dir, service_request_path(request_id))
-              existing = File.exist?(path) ? JSON.parse(File.read(path)) : nil
-              if expected.nil? && existing
-                return existing if existing.except("state", "receipt", "reason", "claimed_at") ==
-                  replacement.except("state", "receipt", "reason", "claimed_at")
-                raise AttemptErrors::Conflict, "Service request #{request_id} has different input"
-              end
-              if expected && existing != expected
-                raise AttemptErrors::Conflict, "Service request #{request_id} changed during transition"
-              end
-              terminal = existing && %w[succeeded failed rejected].include?(existing["state"])
-              settlement = existing && existing["state"] == "failed" && replacement["state"] == "failed-settled"
-              if expected && existing && terminal && !settlement
-                raise AttemptErrors::InvalidState, "Service request #{request_id} is terminal"
-              end
-
-              FileUtils.mkdir_p(File.dirname(path))
-              File.write(path, JSON.pretty_generate(replacement))
+              prepared = prepare_service_update(request_id: request_id, expected: expected,
+                replacement: replacement, event_type: event_type, guard: guard)
+              return prepared.fetch(:record) if prepared[:replayed]
+              write_service_records([prepared])
               assignment_id = replacement.fetch("assignment_id")
               attempt_id = replacement.fetch("attempt_id")
               prior = read_events(assignment_id).reverse
                 .find { |entry| entry["attempt_id"] == attempt_id }&.fetch("digest")
-              payload = {"request_id" => request_id, "state" => replacement.fetch("state"),
-                         "input_digest" => replacement.fetch("input_digest"),
-                         "receipt_digest" => replacement["receipt"] &&
-                           Atoms::EvidenceDigest.digest(replacement["receipt"])}
               event = Models::EvidenceEvent.build(type: event_type, attempt_id: attempt_id,
-                payload: payload, previous_digest: prior)
+                payload: prepared.fetch(:event).fetch(:payload), previous_digest: prior)
               write_event_files(assignment_id, [event])
               git!("-C", checkout_dir, "add", "--", service_request_path(request_id),
                 "execution/#{assignment_id}/events")
+              stage_service_records([prepared])
               state = replacement.fetch("state")
               git!("-C", checkout_dir, "-c", "user.name=ace-assign", "-c", "user.email=ace-assign@localhost",
                 "commit", "-m", "evidence: service request #{request_id} #{state}")
@@ -437,6 +463,120 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
           end
         end
 
+        # Shared owner for ordinary service writes and atomic authority
+        # imports. Call only after checkout sync, under this journal's CAS lock.
+        def prepare_service_update(request_id:, expected:, replacement:, event_type:, guard: nil, pending: nil)
+          validate_request_id!(request_id)
+          unless replacement.is_a?(Hash) && replacement["request_id"] == request_id &&
+              %w[service_claim service_transition].include?(event_type) &&
+              %w[accepted uncertain rejected succeeded failed failed-settled].include?(replacement["state"])
+            raise ArgumentError, "invalid service update plan"
+          end
+          existing = service_request(request_id)
+          if expected.nil? && existing
+            return {record: existing, replayed: true} if existing.except("state", "receipt", "reason", "claimed_at") ==
+              replacement.except("state", "receipt", "reason", "claimed_at")
+            raise AttemptErrors::Conflict, "Service request #{request_id} has different input"
+          end
+          if expected && existing != expected
+            raise AttemptErrors::Conflict, "Service request #{request_id} changed during transition"
+          end
+          if expected.nil?
+            unless event_type == "service_claim" && %w[accepted uncertain rejected].include?(replacement["state"])
+              raise AttemptErrors::InvalidState, "Service request needs an initial claim"
+            end
+            if %w[accepted uncertain].include?(replacement["state"])
+              if replacement["authorization"].to_s.start_with?("proposal-")
+                unless respond_to?(:proposal_authorize!, true)
+                  raise AttemptErrors::UnauthorizedIdentity, "Canonical proposal producer is unavailable"
+                end
+                proposal_authorize!(replacement["authorization"], replacement)
+              end
+              conflict = authorization_conflict(replacement)
+              raise_authorization_conflict!(conflict) if conflict
+            end
+          else
+            unless event_type == "service_transition"
+              raise AttemptErrors::InvalidState, "Existing service request needs a transition"
+            end
+            terminal = %w[succeeded failed rejected failed-settled].include?(existing["state"])
+            settlement = replacement["state"] == "failed-settled" &&
+              (existing["state"] == "failed" || (existing["state"] == "rejected" && existing["consumed"] != false))
+            if terminal && !settlement
+              raise AttemptErrors::InvalidState, "Service request #{request_id} is terminal"
+            end
+            mutable = %w[state receipt reason claimed_at failed_at dispatch_phase no_effect_challenge
+              challenge_generation challenge_event_digest completion_digest]
+            unless existing.except(*mutable) == replacement.except(*mutable)
+              raise AttemptErrors::Conflict, "Service request #{request_id} changed immutable binding"
+            end
+          end
+          conflict = guard&.call
+          raise_authorization_conflict!(conflict) if conflict
+          @service_authorizer.call(existing, replacement, pending) if @mode == :protected
+          validate_terminal_receipt!(replacement, replacement["state"], replacement["receipt"], pending: pending) if terminal_state?(replacement["state"])
+          payload = {"request_id" => request_id, "state" => replacement.fetch("state"),
+                     "input_digest" => replacement.fetch("input_digest"),
+                     "record_digest" => Atoms::EvidenceDigest.digest(replacement),
+                     "receipt_digest" => replacement["receipt"] && Atoms::EvidenceDigest.digest(replacement["receipt"])}
+          {record: replacement, path: service_request_path(request_id),
+           event: {type: event_type, payload: payload}, replayed: false}
+        end
+
+        def prepare_service_updates(updates, assignment_id:, attempt_id:, pending:)
+          unless updates.is_a?(Array) && updates.length <= 1
+            raise ArgumentError, "one service update is allowed per authority mutation"
+          end
+          updates.map do |update|
+            unless update.is_a?(Hash) && update.keys.sort == %i[event_type expected replacement request_id].sort &&
+                update.dig(:replacement, "assignment_id") == assignment_id && update.dig(:replacement, "attempt_id") == attempt_id
+              raise ArgumentError, "service update does not match mutation attempt"
+            end
+            prepare_service_update(**update, pending: pending)
+          end.reject { |prepared| prepared[:replayed] }
+        end
+
+        def write_service_records(records)
+          records.each do |prepared|
+            path = File.join(checkout_dir, prepared.fetch(:path))
+            FileUtils.mkdir_p(File.dirname(path))
+            File.write(path, JSON.pretty_generate(prepared.fetch(:record)))
+          end
+        end
+
+        def stage_service_records(records)
+          stage_mutation_blobs(records.to_h { |prepared| [prepared.fetch(:path), JSON.pretty_generate(prepared.fetch(:record))] })
+        end
+
+        def verify_service_record!(record, commit: ref_value)
+          events = read_events(record.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == record.fetch("attempt_id") }
+          unless Models::EvidenceEvent.chain_valid?(events)
+            raise AttemptErrors::EvidenceUnavailable, "Canonical service event chain is unverifiable"
+          end
+          event = events.reverse.find do |entry|
+            %w[service_claim service_transition].include?(entry["type"]) && entry.dig("payload", "request_id") == record["request_id"]
+          end
+          unless event && event.dig("payload", "record_digest") == Atoms::EvidenceDigest.digest(record)
+            raise AttemptErrors::EvidenceUnavailable, "Canonical service record does not match accepted event"
+          end
+        rescue KeyError, TypeError
+          raise AttemptErrors::EvidenceUnavailable, "Canonical service record has invalid binding"
+        end
+
+        def raise_authorization_conflict!(conflict)
+          raise AttemptErrors::Conflict,
+            "Authorization reference already consumed by request #{conflict.fetch('request_id')}"
+        end
+
+        def verify_service_attestation!(content, request, state)
+          expression = /^ace-service-attestation request:#{Regexp.escape(request["request_id"])} input:#{Regexp.escape(request["input_digest"])} outcome:(\S+)( no-effect:(\S+))?$/
+          attested = content.scan(expression).first
+          outcome = state == "failed-settled" ? "failed" : state
+          unless attested && attested.first == outcome && (state != "failed-settled" || attested[2] == "true")
+            raise AttemptErrors::ReceiptRejected, "Service terminal evidence does not attest #{outcome}"
+          end
+        end
+
         def service_request_path(request_id)
           "execution/requests/#{request_id}.json"
         end
@@ -451,9 +591,11 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
         def derive_state(events)
           return nil unless events.any? { |event| event["type"] == "intent" }
 
-          state = "running"
+          state = "reserved"
           events.each do |event|
             case event["type"]
+            when "process_start"
+              state = "running"
             when "receipt_accepted"
               state = event.dig("payload", "receipt", "verdict") || state
             when "transition"
@@ -469,19 +611,24 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
           process_start = events.reverse.find do |event|
             event["type"] == "process_start" && event["attempt_id"] == attempt_id
           end
-          candidate_head = events.select { |event| event["type"] == "receipt_accepted" }
-            .map { |event| event.dig("payload", "receipt", "head") }
-            .compact
-            .first
+          candidate_head = nil
+          events.each do |event|
+            case event["type"]
+            when "candidate_invalidated" then candidate_head = nil
+            when "receipt_accepted" then candidate_head ||= event.dig("payload", "receipt", "head")
+            when "delivery"
+              candidate_head = event.dig("payload", "head") if %w[intent result].include?(event.dig("payload", "stage"))
+            end
+          end
           binding = Models::AttemptBinding.new(
             attempt_id: attempt_id,
             assignment_id: assignment_id,
             scope: intent_payload["scope"],
             project_id: intent_payload["project_id"],
             task_id: intent_payload["task_id"],
-            actor: process_start&.dig("payload", "actor") || "recovered",
-            role: process_start&.dig("payload", "role") || "coordinator",
-            runtime: process_start&.dig("payload", "runtime") || "recovered",
+            actor: process_start&.dig("payload", "actor") || intent_payload["actor"] || "recovered",
+            role: process_start&.dig("payload", "role") || intent_payload["role"] || "coordinator",
+            runtime: process_start&.dig("payload", "runtime") || intent_payload["runtime"] || "recovered",
             base_head: intent_payload["base_head"],
             evidence_git_ref: ref,
             created_at: parse_event_time(intent_time(events, attempt_id))
@@ -602,6 +749,11 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
             lock.flock(File::LOCK_EX)
             begin
               yield
+            rescue StandardError
+              # No rejected writer may leave staged or untracked transaction
+              # data for the next writer to admit. This checkout is disposable.
+              sync_checkout(ref_value) if File.exist?(File.join(checkout_dir, ".git"))
+              raise
             ensure
               lock.flock(File::LOCK_UN)
             end
@@ -648,6 +800,9 @@ input:#{Regexp.escape(current["input_digest"])} outcome:(\S+)( no-effect:(\S+))?
           return if target.nil?
 
           git!("-C", checkout_dir, "reset", "--hard", target)
+          # All writers use this boundary, including CAS retries. Only the
+          # journal's disposable namespaces are cleaned, never the candidate.
+          git!("-C", checkout_dir, "clean", "-fd", "--", "execution", "evidence")
         rescue AttemptErrors::EvidenceUnavailable
           # Stale, broken, or unregistered worktree: rebuild from scratch.
           FileUtils.rm_rf(checkout_dir)

data/lib/ace/assign/molecules/execution_identity_resolver.rb

@@ -13,7 +13,7 @@ module Ace
       # Actor identity is derived from the execution boundary, never granted
       # by command flags or receipt claims. Two adapters ship:
       # - `local` — the interactive operator is the coordinator; identity
-      #   comes from the OS login boundary.
+      #   comes from the kernel process account (equal real/effective UID).
       # - `service` — a trusted service executor supplies a structured
       #   identity through a configured environment variable; the executor
       #   owns OS/process enforcement.
@@ -25,14 +25,17 @@ module Ace
         TRUSTED_ROLES = %w[coordinator service].freeze
 
         # Resolved boundary identity.
-        Identity = Struct.new(:actor, :role, :runtime, :adapter, keyword_init: true)
+        Identity = Struct.new(:actor, :role, :runtime, :adapter, :process_pid, :runtime_binding, keyword_init: true)
 
         # @param adapter [String, nil] "local" or "service" (default from config)
         # @param service_env [String, nil] Env var carrying the service identity (default from config)
-        def initialize(adapter: nil, service_env: nil)
+        def initialize(adapter: nil, service_env: nil, runtime_resolver: Ace::Runtime, env: ENV, caller_pid: Process.ppid)
           section = Ace::Assign.config["attempt"] || {}
           @adapter = adapter || section["identity_adapter"] || "local"
           @service_env = service_env || section["service_identity_env"] || "ACE_ASSIGN_SERVICE_IDENTITY"
+          @runtime_resolver = runtime_resolver
+          @env = env
+          @caller_pid = caller_pid
         end
 
         # @return [Identity] Trusted boundary identity
@@ -55,19 +58,41 @@ module Ace
         private
 
         def from_local_boundary
-          actor = Etc.getlogin || ENV["USER"] || ENV["LOGNAME"]
-          if actor.nil? || actor.strip.empty?
-            raise AttemptErrors::UnauthorizedIdentity, "No OS login identity available at the execution boundary"
+          uid, euid = Process.uid, Process.euid
+          unless uid == euid
+            raise AttemptErrors::UnauthorizedIdentity, "Local execution requires equal real and effective UIDs"
           end
 
+          account = local_account(euid)
+          verify_local_credentials!(uid, euid)
+          binding = native_process_binding
+          verify_local_credentials!(uid, euid)
           Identity.new(
-            actor: actor.strip,
+            actor: account.name,
             role: "coordinator",
             runtime: "local:#{Socket.gethostname}",
-            adapter: "local"
+            adapter: "local",
+            process_pid: binding&.dig("process_identity", "pid"),
+            runtime_binding: binding
           )
         end
 
+        def local_account(euid)
+          account = Etc.getpwuid(euid)
+          unless account && account.uid == euid && account.name.is_a?(String) && !account.name.strip.empty?
+            raise AttemptErrors::UnauthorizedIdentity, "No valid kernel process account for effective UID #{euid}"
+          end
+          account
+        rescue ArgumentError, SystemCallError
+          raise AttemptErrors::UnauthorizedIdentity, "Cannot resolve kernel process account for effective UID #{euid}"
+        end
+
+        def verify_local_credentials!(uid, euid)
+          unless Process.uid == uid && Process.euid == euid
+            raise AttemptErrors::UnauthorizedIdentity, "Local execution credentials changed during identity resolution"
+          end
+        end
+
         def from_service_env
           raw = ENV[@service_env].to_s.strip
           if raw.empty?
@@ -89,7 +114,22 @@ module Ace
               "Service identity must supply actor, runtime, and a role in #{ROLES.join('/')}"
           end
 
-          Identity.new(actor: actor, role: role, runtime: runtime, adapter: "service")
+          pid = data["process_pid"]
+          if pid && (!pid.is_a?(Integer) || !pid.positive?)
+            raise AttemptErrors::UnauthorizedIdentity, "Service process_pid must be a positive integer"
+          end
+          Identity.new(actor: actor, role: role, runtime: runtime, adapter: "service", process_pid: pid)
+        end
+
+        def native_process_binding
+          adapter = Ace::Runtime::Molecules::RuntimeSelector.new(
+            config: Ace::Runtime.config, registry: @runtime_resolver, env: @env).resolve
+          context = adapter.context
+          return nil unless context[:in_runtime] && context[:pane]
+
+          adapter.process_binding(pane: context[:pane], caller_pid: @caller_pid)
+        rescue Ace::Runtime::Error
+          nil
         end
       end
     end