ace-herdr 0.4.0 → 0.5.0

data/lib/ace/herdr/organisms/inbox_context_service.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "../molecules/inbox_context_native_process"
+require_relative "../molecules/inbox_context_completion_client"
+require_relative "../molecules/native_queue_executor"
+require_relative "../molecules/herdr_executor"
+require_relative "inbox_context_server"
+require_relative "inbox_context_listener"
+
+module Ace
+  module Herdr
+    module Organisms
+      # The generated fixed entry calls these distinct methods only after its
+      # SAME installation owner selects normal start or retained initialization.
+      # There is no caller-supplied Inbox, epoch or native executable fallback.
+      class InboxContextService
+        ASSOCIATION = %i[cgroups configuration installation kernel manager].freeze
+        attr_reader :epoch, :configuration
+
+        def initialize(configuration:, epoch:, association:, listener:, store:)
+          @configuration, @epoch, @association, @listener, @store = configuration, epoch, association, listener, store
+        end
+
+        def serve
+          observed = Molecules::InboxContextLifetime.new(**@association).capture_epoch!
+          raise ValidationError, "context service epoch changed before ingress" unless observed == @epoch
+          @listener.serve
+        ensure
+          close
+        end
+
+        def close
+          raise ValidationError, "context service handlers remain unresolved" unless @listener.quiescent?
+          @store.close
+        end
+
+        def self.start!(stage:, installation:, bootstrap:)
+          run!(stage: stage, installation: installation, bootstrap: bootstrap, initialize_context: false)
+        end
+
+        def self.provision!(stage:, installation:, bootstrap:)
+          run!(stage: stage, installation: installation, bootstrap: bootstrap, initialize_context: true)
+        end
+
+        def self.run!(stage:, installation:, bootstrap:, initialize_context:)
+          configuration = Molecules::InboxContextServiceConfiguration.load(stage: stage)
+          constructed = nil
+          owner_method = initialize_context ? :with_initial_inbox_context : :with_inbox_context_service
+          prepared = bootstrap.public_send(owner_method, configuration: configuration, installation: installation) do |association|
+            unless association.is_a?(Hash) && association.keys.sort == ASSOCIATION && association.frozen? &&
+                association.fetch(:configuration).is_a?(Molecules::InboxContextServiceConfiguration) &&
+                association.fetch(:configuration).reference == configuration.reference && association.fetch(:configuration).data == configuration.data
+              raise ValidationError, "context service owner association differs"
+            end
+            selected = association.fetch(:configuration)
+            clients = selected.data.fetch("native_clients")
+            association.fetch(:installation).verify_inbox_native_projection!(
+              references: clients.values_at("codex", "pi", "herdr") + clients.fetch("dependencies"),
+              resources: clients.fetch("resources"), manager: association.fetch(:manager))
+            lifetime = Molecules::InboxContextLifetime.new(**association)
+            epoch = lifetime.capture_epoch!
+            data = selected.data
+            keys = Molecules::InboxContextKey.new(context_id: data.fetch("inbox_context_id"),
+              public_key_path: data.fetch("key").fetch("public_key_path"), config_path: data.fetch("key").fetch("configuration_path"))
+            key = keys.selected
+            process = Molecules::InboxContextNativeProcess.new(configuration: selected)
+            process.verify!
+            inbox = Inbox.new(deliveries_dir: data.fetch("deliveries_dir"),
+              executor: Molecules::HerdrExecutor.new(binary: clients.fetch("herdr").fetch("path"), process: process),
+              native: Molecules::NativeQueueExecutor.new(pi_client: clients.fetch("pi").fetch("path"), process: process))
+            store = Molecules::InboxContextStore.new(root: data.fetch("state_root"), uid: data.fetch("owner_credentials").fetch("uid"))
+            owner = InboxContextOwner.new(context_id: data.fetch("inbox_context_id"), deliveries_dir: data.fetch("deliveries_dir"),
+              grants: data.fetch("grants"), store: store, keys: keys, epoch: epoch, kernel: association.fetch(:kernel), inbox: inbox,
+              completion: Molecules::InboxContextCompletionClient.new(authority: data.fetch("authority"),
+                project_id: data.fetch("project_id"), mapping_id: data.fetch("native_mapping_id"), kernel: association.fetch(:kernel)))
+            if initialize_context
+              begin
+                owner.provision!
+              rescue Molecules::InboxContextStore::AlreadyProvisioned
+                owner.observe_initialized_epoch!
+              end
+            else
+              owner.activate_epoch!
+            end
+            server = InboxContextServer.new(owner: owner, context_id: data.fetch("inbox_context_id"), kernel: association.fetch(:kernel))
+            listener = InboxContextListener.new(configuration: selected, server: server, kernel: association.fetch(:kernel))
+            constructed = new(configuration: selected, epoch: epoch, association: association, listener: listener, store: store)
+          rescue Exception
+            store&.close
+            raise
+          end
+          # The initial owner completes its bounded existing Installer phase
+          # before returning this prepared instance. It cannot retain operator
+          # exclusion through the listener's unbounded serving lifetime.
+          unless prepared.is_a?(self) && prepared.configuration.reference == configuration.reference
+            raise ValidationError, "context service startup acknowledgement differs"
+          end
+          prepared.serve
+        ensure
+          constructed&.close if constructed.is_a?(self)
+        end
+        private_class_method :run!
+        private_class_method :new
+      end
+    end
+  end
+end

data/lib/ace/herdr/organisms/inbox_guarded_wake.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+require_relative "../molecules/inbox_direct_effect_binding"
+
+module Ace
+  module Herdr
+    module Organisms
+      # DeliveryRecord owns notification intent; native IO is outside its lock.
+      module InboxGuardedWake
+        def guarded_wake_pending?(event:, binding:, claim:)
+          with_event(event, create_lock: false) do |record|
+            next false unless record&.state == "delivered"
+            guarded_queue_record!(record, binding, claim)
+            %w[pending not_issued].include?(record.inbox.dig("wake", "status"))
+          end
+        end
+
+        def prepare_guarded_wake(event:, binding:, claim:, operation_id:)
+          with_event(event, create_lock: false) do |record|
+            next nil unless record&.state == "delivered"
+            guarded_queue_record!(record, binding, claim)
+            wake = record.inbox.fetch("wake")
+            next nil unless %w[pending not_issued].include?(wake.fetch("status"))
+            unless wake.values_at("operation_id", "input_sha256") == [operation_id, binding.fetch("input_sha256")]
+              raise ValidationError, "guarded wake invocation differs"
+            end
+            issuing = wake.reject { |key, _| key == "code" }.merge("status" => "issuing")
+            save(record.advance_inbox(state: "delivered", inbox: record.inbox.merge("wake" => issuing),
+              detail: {"action" => "wake-issuing"}, timestamp: Time.now.utc.iso8601))
+            issuing
+          end
+        end
+
+        def finish_guarded_wake(event:, binding:, claim:, issuing:, result:)
+          with_event(event, create_lock: false) do |record|
+            guarded_queue_record!(record, binding, claim)
+            unless record.state == "delivered" && record.inbox.fetch("wake") == issuing && issuing.fetch("status") == "issuing"
+              raise ValidationError, "guarded wake completion changed"
+            end
+            status = case result.fetch("outcome")
+            when "submitted" then "sent"
+            when "not_issued" then "not_issued"
+            else "uncertain"
+            end
+            wake = issuing.merge("status" => status)
+            wake["code"] = result.fetch("code") if status == "not_issued"
+            record = record.advance_inbox(state: "delivered", inbox: record.inbox.merge("wake" => wake),
+              detail: {"action" => "wake-#{status}"}, timestamp: Time.now.utc.iso8601)
+            save(record)
+            public_record(record)
+          end
+        end
+
+        def verify_guarded_wake_admission!(binding:, claim:, operation_id:)
+          with_event(binding.fetch("event_id"), create_lock: false) do |record|
+            guarded_queue_record!(record, binding, claim)
+            unless claim.slice("claim_generation", "claim_owner") == record.inbox.slice("claim_generation", "claim_owner") &&
+                record.inbox.fetch("wake").values_at("operation_id", "input_sha256") == [operation_id, binding.fetch("input_sha256")]
+              raise ValidationError, "guarded wake admission association differs"
+            end
+            true
+          end
+        end
+
+        private
+
+        def queue_issuer!(record)
+          issuer = record.inbox.fetch("queue_issuer")
+          generation = record.inbox.fetch("claim_generation")
+          unless issuer.is_a?(Hash) && issuer.keys.sort == %w[input_sha256 key_generation operation_id] &&
+              issuer["operation_id"].is_a?(String) && issuer["operation_id"].match?(/\A[0-9a-f]{32}\z/) &&
+              issuer["key_generation"].is_a?(Integer) && issuer["key_generation"].positive? && generation.positive?
+            raise ValidationError, "guarded queue issuer differs"
+          end
+          original = record.inbox.fetch("original_context")
+          expected = Molecules::InboxDirectEffectBinding.build(purpose: "deliver", event_id: record.event_id,
+            attempt_id: record.inbox.fetch("attempt_id"), key_generation: issuer.fetch("key_generation"),
+            selection: {"expected_claim_generation" => generation - 1}, original: original)
+          owner = Digest::SHA256.hexdigest(JSON.generate([original.fetch("inbox_context_id"), issuer.fetch("operation_id")]))
+          retained_owner = record.inbox["claim_owner"]
+          unless issuer.fetch("input_sha256") == expected.fetch("input_sha256") &&
+              retained_owner == owner &&
+              record.history.count { |entry| entry.slice("action", "claim_generation", "claim_owner") ==
+                {"action" => "claim", "claim_generation" => generation, "claim_owner" => owner} } == 1
+            raise ValidationError, "guarded queue claim attribution differs"
+          end
+          issuer
+        end
+
+        def guarded_queue_record!(record, binding, claim)
+          issuer = queue_issuer!(record)
+          receipt = record.inbox.fetch("receipt")
+          unless binding.fetch("purpose") == "deliver" && binding.fetch("event_id") == record.event_id &&
+              record.inbox.fetch("original_context") == binding.slice(*Molecules::InboxDirectEffectBinding::ORIGINAL_FIELDS) &&
+              record.inbox.fetch("attempt_id") == binding.fetch("attempt_id") &&
+              claim.slice("claim_generation", "claim_owner") == record.inbox.slice("claim_generation", "claim_owner") &&
+              receipt.is_a?(Hash) && receipt.slice("event_id", "attempt_id", "claim_generation", "payload_sha256", "binding") ==
+                {"event_id" => record.event_id, "attempt_id" => record.inbox.fetch("attempt_id"), "claim_generation" => record.inbox.fetch("claim_generation"),
+                  "payload_sha256" => record.answer_digest, "binding" => record.inbox.fetch("binding")}
+            raise ValidationError, "guarded wake queue receipt differs"
+          end
+          wake = record.inbox.fetch("wake")
+          fields = %w[binding_digest claim_generation input_sha256 operation_id status]
+          fields << "code" if wake.is_a?(Hash) && wake["status"] == "not_issued"
+          unless wake.is_a?(Hash) && wake.keys.sort == fields.sort &&
+              %w[pending issuing sent not_issued uncertain none].include?(wake["status"]) &&
+              wake["claim_generation"] == record.inbox.fetch("claim_generation") && wake["binding_digest"] == record.inbox.fetch("original_binding_digest") &&
+              wake["operation_id"].is_a?(String) && wake["operation_id"].match?(/\A[0-9a-f]{32}\z/) &&
+              wake["input_sha256"].is_a?(String) && wake["input_sha256"].match?(/\A[0-9a-f]{64}\z/) &&
+              (wake["status"] != "not_issued" || %w[guard_mismatch origin_unavailable origin_exited agent_blocked agent_not_ready target_missing submission_busy].include?(wake["code"]))
+            raise ValidationError, "guarded wake retention differs"
+          end
+          issuer
+        end
+      end
+    end
+  end
+end

data/lib/ace/herdr/organisms/native_source_builder.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+require_relative "../molecules/native_source"
+require_relative "../molecules/bounded_process"
+
+module Ace
+  module Herdr
+    module Organisms
+      # Explicit source build, outside the installed protected deployment.
+      # No server contact, product execution, global tool selection or publication.
+      class NativeSourceBuilder
+        def initialize(selection: Molecules::NativeSource.new, runner: nil)
+          @selection = selection
+          @runner = runner || lambda do |argv, environment:, chdir:, timeout_s:|
+            Molecules::BoundedProcess.call(argv, environment: environment, chdir: chdir,
+              timeout_s: timeout_s, output_limit: 1_048_576)
+          end
+        end
+
+        def build(source:, output:, target:)
+          raise Molecules::NativeSource::Error, "native source builds must run as a nonroot build owner" if Process.euid.zero?
+          selected = @selection.selection
+          unless selected.fetch("targets").include?(target)
+            raise Molecules::NativeSource::Error, "unsupported native source build target"
+          end
+          validate_native_host!(target)
+          source = File.expand_path(source)
+          output = File.expand_path(output)
+          raise Molecules::NativeSource::Error, "native output must be new" if File.exist?(output) || File.symlink?(output)
+          raise Molecules::NativeSource::Error, "native source directory is unavailable" unless File.directory?(source) && !File.symlink?(source)
+          @environment = build_environment
+          @git = executable("git")
+          unless git(source, "status", "--porcelain", "--untracked-files=all").empty?
+            raise Molecules::NativeSource::Error, "native source checkout must be clean"
+          end
+          git(source, "cat-file", "-e", "#{selected.fetch("baseline_commit")}^{commit}")
+          tools = selected_tools
+          tool_digests = tool_digests(tools)
+          # Exclusive persistent output claim: failures never overwrite an older
+          # build or return an incomplete artifact as successful.
+          Dir.mkdir(output, 0o700)
+          staging = File.join(output, ".source-build")
+          Dir.mkdir(staging, 0o700)
+          checkout = File.join(staging, "source")
+          run([@git, "-c", "core.hooksPath=/dev/null", "clone", "--no-local", "--no-hardlinks", "--no-checkout", "--", source, checkout])
+          git(checkout, "checkout", "--detach", selected.fetch("baseline_commit"))
+          git(checkout, "am", "--committer-date-is-author-date", @selection.patch_path)
+          unless git(checkout, "rev-parse", "HEAD").strip == selected.fetch("source_commit") &&
+              git(checkout, "rev-parse", "HEAD^{tree}").strip == selected.fetch("source_tree")
+            raise Molecules::NativeSource::Error, "native patched source revision mismatch"
+          end
+          verify_source_files(checkout)
+          reject_ancestor_cargo_configuration(checkout)
+          cargo_home = File.join(staging, "cargo-home")
+          Dir.mkdir(cargo_home, 0o700)
+          compile_environment = @environment.merge("CARGO_HOME" => cargo_home,
+            "CARGO_TARGET_DIR" => File.join(staging, "target"), "RUSTC" => tools.fetch("rustc"),
+            "RUSTUP_TOOLCHAIN" => selected.fetch("rust_version"), "ZIG" => tools.fetch("zig"),
+            "CARGO_TARGET_#{target.upcase.tr("-", "_")}_LINKER" => tools.fetch("linker"))
+          run([tools.fetch("cargo"), "build", "--release", "--locked", "--target", target],
+            chdir: checkout, environment: compile_environment, timeout_s: 1800)
+          verify_source_files(checkout)
+          unless tool_digests(tools) == tool_digests
+            raise Molecules::NativeSource::Error, "native build tools changed during compilation"
+          end
+          artifact = @selection.read_regular(File.join(staging, "target", target, "release", "herdr"),
+            Molecules::NativeSource::MAX_ARTIFACT_BYTES)
+          receipt = @selection.receipt(build: {"target" => target, "profile" => "release",
+            "rust_version" => selected.fetch("rust_version"), "zig_version" => selected.fetch("zig_version"),
+            "tools_sha256" => tool_digests},
+            artifact: @selection.artifact_record(bytes: artifact, target: target))
+          write_new(File.join(output, "herdr"), artifact, 0o755)
+          FileUtils.remove_entry(staging)
+          write_new(File.join(output, "provenance.json"), JSON.pretty_generate(receipt) + "\n", 0o644)
+          @selection.verify_artifact(directory: output)
+        rescue SystemCallError, IOError, Timeout::Error, Molecules::BoundedProcess::PostLaunchError => error
+          raise Molecules::NativeSource::Error, "native source build failed: #{error.class}"
+        end
+
+        private
+
+        def validate_native_host!(target)
+          architecture = {"x86_64-unknown-linux-musl" => /\A(?:x86_64|amd64)\z/,
+            "aarch64-unknown-linux-musl" => /\A(?:aarch64|arm64)\z/}.fetch(target)
+          unless RbConfig::CONFIG.fetch("host_os").include?("linux") &&
+              architecture.match?(RbConfig::CONFIG.fetch("host_cpu"))
+            raise Molecules::NativeSource::Error, "native source builds require a matching Linux host; cross builds are unsupported"
+          end
+        end
+
+        def build_environment
+          selected = @selection.selection
+          committer = selected.fetch("committer")
+          environment = {"PATH" => ENV.fetch("PATH", "/usr/bin:/bin"), "HOME" => Dir.home,
+            "GIT_CONFIG_NOSYSTEM" => "1", "GIT_CONFIG_GLOBAL" => "/dev/null", "GIT_TERMINAL_PROMPT" => "0",
+            "GIT_COMMITTER_NAME" => committer.fetch("name"), "GIT_COMMITTER_EMAIL" => committer.fetch("email"),
+            "GIT_COMMITTER_DATE" => committer.fetch("date")}
+          environment["RUSTUP_HOME"] = ENV["RUSTUP_HOME"] if ENV["RUSTUP_HOME"] && !ENV["RUSTUP_HOME"].empty?
+          environment
+        end
+
+        def executable(name)
+          path = @environment.fetch("PATH").split(File::PATH_SEPARATOR).map { |directory| File.join(directory, name) }
+            .find { |candidate| File.file?(candidate) && File.executable?(candidate) }
+          raise Molecules::NativeSource::Error, "required native build tool is missing: #{name}" unless path
+          File.realpath(path)
+        end
+
+        def tool_digests(tools)
+          tools.transform_values do |path|
+            @selection.digest(@selection.read_regular(path, Molecules::NativeSource::MAX_ARTIFACT_BYTES))
+          end
+        end
+
+        def reject_ancestor_cargo_configuration(checkout)
+          current = File.dirname(checkout)
+          loop do
+            if %w[config config.toml].any? { |file| File.exist?(File.join(current, ".cargo", file)) || File.symlink?(File.join(current, ".cargo", file)) }
+              raise Molecules::NativeSource::Error, "native build has undeclared ancestor Cargo configuration"
+            end
+            parent = File.dirname(current)
+            break if parent == current
+            current = parent
+          end
+        end
+
+        def selected_tools
+          rustup = executable("rustup")
+          version = @selection.selection.fetch("rust_version")
+          tools = %w[cargo rustc].to_h do |name|
+            path = run([rustup, "which", "--toolchain", version, name]).strip
+            unless path.start_with?("/") && File.file?(path) && File.executable?(path)
+              raise Molecules::NativeSource::Error, "selected Rust tool is unavailable"
+            end
+            [name, File.realpath(path)]
+          end
+          tools["zig"] = executable("zig")
+          tools["linker"] = executable("musl-gcc")
+          unless run([tools.fetch("rustc"), "--version"]).start_with?("rustc #{version} ") &&
+              run([tools.fetch("cargo"), "--version"]).start_with?("cargo #{version} ") &&
+              run([tools.fetch("zig"), "version"]).strip == @selection.selection.fetch("zig_version")
+            raise Molecules::NativeSource::Error, "selected native build tool versions mismatch"
+          end
+          tools
+        end
+
+        def git(checkout, *arguments)
+          run([@git, "-c", "core.hooksPath=/dev/null", "-c", "commit.gpgsign=false", "-C", checkout, *arguments])
+        end
+
+        def verify_source_files(checkout)
+          %w[Cargo.lock rust-toolchain.toml].zip(%w[cargo_lock_sha256 rust_toolchain_sha256]).each do |file, key|
+            unless @selection.digest(@selection.read_regular(File.join(checkout, file), 1_048_576)) == @selection.selection.fetch(key)
+              raise Molecules::NativeSource::Error, "native source lock/toolchain bytes mismatch"
+            end
+          end
+          unless git(checkout, "status", "--porcelain", "--untracked-files=all").empty?
+            raise Molecules::NativeSource::Error, "native source changed during build"
+          end
+        end
+
+        def run(argv, chdir: nil, environment: @environment, timeout_s: 60)
+          result = @runner.call(argv, environment: environment, chdir: chdir, timeout_s: timeout_s)
+          unless result.status.success? && !result.oversized
+            raise Molecules::NativeSource::Error, "native build command failed or exceeded output bound"
+          end
+          result.stdout
+        end
+
+        def write_new(path, bytes, mode)
+          File.open(path, File::WRONLY | File::CREAT | File::EXCL, mode) do |file|
+            file.write(bytes)
+            file.flush
+            file.fsync
+            file.chmod(mode)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/herdr/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Herdr
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/ace/herdr.rb

@@ -3,34 +3,6 @@
 require_relative "herdr/version"
 require "ace/support/config"
 
-module Ace
-  module Herdr
-    class Error < StandardError; end
-
-    # Raised when the caller's herdr workspace/session/pane cannot be resolved
-    class TargetResolutionError < Error; end
-
-    # Raised when arguments or refs fail validation
-    class ValidationError < Error; end
-
-    # Raised when a bounded wait exceeds its timeout
-    class WaitTimeoutError < Error; end
-
-    # Raised when a preset tab was created natively but a later
-    # materialization step (splits, commands, agents) failed; carries the
-    # created tab id so the owner can roll back exactly that tab.
-    class TabMaterializationError < Error
-      attr_reader :tab_id
-
-      def initialize(tab_id:, message:)
-        @tab_id = tab_id
-        super(message)
-      end
-    end
-  end
-end
-
-# Executor error hierarchy (subclasses Ace::Herdr::Error)
 require_relative "herdr/errors"
 
 # Load all ace-herdr components
@@ -39,6 +11,8 @@ require_relative "herdr/atoms/json_find"
 require_relative "herdr/models/delivery_record"
 require_relative "herdr/models/dispatch_outcome"
 require_relative "herdr/molecules/bounded_process"
+require_relative "herdr/molecules/native_source"
+require_relative "herdr/organisms/native_source_builder"
 require_relative "herdr/molecules/herdr_executor"
 require_relative "herdr/molecules/native_queue_executor"
 require_relative "herdr/molecules/pane_tidy_probe"
@@ -47,6 +21,9 @@ require_relative "herdr/molecules/preset_loader"
 require_relative "herdr/molecules/preset_resolver"
 require_relative "herdr/organisms/deliverer"
 require_relative "herdr/organisms/inbox"
+require_relative "herdr/organisms/inbox_context_owner"
+require_relative "herdr/organisms/inbox_context_server"
+require_relative "herdr/molecules/inbox_context_client"
 require_relative "herdr/organisms/dispatcher"
 require_relative "herdr/organisms/control_surface"
 require_relative "herdr/organisms/runtime_adapter"

metadata

@@ -1,14 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: ace-herdr
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: ace-hitl-contract
   requirement: !ruby/object:Gem::Requirement
@@ -164,8 +198,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.22'
 description: Herdr agent orchestration with push delivery, agent bootstrap, dispatch,
-  and a durable attempt-linked inbox for exact-session Codex/Pi queue submission and
-  signed reconciliation. Implements the ace-hitl provider delivery contract.
+  and a durable attempt-linked inbox for submission to the original Codex/Pi terminal,
+  with explicit uncertain outcomes. Implements the ace-hitl provider delivery contract.
 email:
 - mc@cs3b.com
 executables:
@@ -193,6 +227,7 @@ files:
 - lib/ace/herdr/cli/commands/inbox.rb
 - lib/ace/herdr/cli/commands/list.rb
 - lib/ace/herdr/cli/commands/list_presets.rb
+- lib/ace/herdr/cli/commands/native_source.rb
 - lib/ace/herdr/cli/commands/send.rb
 - lib/ace/herdr/cli/commands/support.rb
 - lib/ace/herdr/cli/commands/tab.rb
@@ -204,17 +239,41 @@ files:
 - lib/ace/herdr/models/dispatch_outcome.rb
 - lib/ace/herdr/molecules/bounded_process.rb
 - lib/ace/herdr/molecules/delivery_record_store.rb
+- lib/ace/herdr/molecules/guarded_native_origin.rb
 - lib/ace/herdr/molecules/herdr_executor.rb
+- lib/ace/herdr/molecules/inbox_cli_input.rb
+- lib/ace/herdr/molecules/inbox_context_client.rb
+- lib/ace/herdr/molecules/inbox_context_completion_client.rb
+- lib/ace/herdr/molecules/inbox_context_key.rb
+- lib/ace/herdr/molecules/inbox_context_lifetime.rb
+- lib/ace/herdr/molecules/inbox_context_native_process.rb
+- lib/ace/herdr/molecules/inbox_context_service_configuration.rb
+- lib/ace/herdr/molecules/inbox_context_store.rb
+- lib/ace/herdr/molecules/inbox_context_wire.rb
+- lib/ace/herdr/molecules/inbox_direct_effect_binding.rb
+- lib/ace/herdr/molecules/inbox_direct_result.rb
 - lib/ace/herdr/molecules/native_queue_executor.rb
+- lib/ace/herdr/molecules/native_source.rb
 - lib/ace/herdr/molecules/pane_tidy_probe.rb
 - lib/ace/herdr/molecules/preset_loader.rb
 - lib/ace/herdr/molecules/preset_resolver.rb
+- lib/ace/herdr/molecules/protected_inbox_selection.rb
 - lib/ace/herdr/molecules/protected_native_control.rb
+- lib/ace/herdr/native_source/HERDR-LICENSE
+- lib/ace/herdr/native_source/guarded-prompt.patch
+- lib/ace/herdr/native_source/selection.json
 - lib/ace/herdr/organisms/control_surface.rb
 - lib/ace/herdr/organisms/deliverer.rb
 - lib/ace/herdr/organisms/dispatcher.rb
 - lib/ace/herdr/organisms/inbox.rb
-- lib/ace/herdr/organisms/protected_inbox.rb
+- lib/ace/herdr/organisms/inbox_context_direct_effects.rb
+- lib/ace/herdr/organisms/inbox_context_effects.rb
+- lib/ace/herdr/organisms/inbox_context_listener.rb
+- lib/ace/herdr/organisms/inbox_context_owner.rb
+- lib/ace/herdr/organisms/inbox_context_server.rb
+- lib/ace/herdr/organisms/inbox_context_service.rb
+- lib/ace/herdr/organisms/inbox_guarded_wake.rb
+- lib/ace/herdr/organisms/native_source_builder.rb
 - lib/ace/herdr/organisms/runtime_adapter.rb
 - lib/ace/herdr/organisms/tidy.rb
 - lib/ace/herdr/version.rb

data/lib/ace/herdr/organisms/protected_inbox.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "inbox"
-require_relative "../molecules/protected_native_control"
-require_relative "../molecules/herdr_executor"
-require_relative "../molecules/native_queue_executor"
-require_relative "../molecules/bounded_process"
-
-module Ace
-  module Herdr
-    module Organisms
-      # Fixed construction for the canonical authority consumer. Callers of the
-      # public protocol cannot inject this factory or its collaborators.
-      module ProtectedInbox
-        class PaneReader
-          def initialize(control)
-            @control = control
-          end
-
-          def pane_get_bounded(pane)
-            result = @control.request("pane.get", {"pane_id" => pane})
-            Molecules::ExecutionResult.new(stdout: JSON.generate({"result" => result}), stderr: "",
-              success: true, exit_code: 0)
-          rescue Ace::Runtime::RuntimeUnavailableError
-            raise ExecutorUnavailableError, "original protected native endpoint is unavailable"
-          end
-        end
-
-        class PiIdentity
-          def initialize(client)
-            runner = lambda do |argv, stdin_data:, timeout_s:|
-              unless argv == [client, "--identity"] && stdin_data.empty?
-                raise ExecutorUnavailableError, "protected inbox permits identity inspection only"
-              end
-              result = Molecules::BoundedProcess.call(argv, stdin_data: stdin_data,
-                timeout_s: timeout_s, environment: {})
-              raise ExecutorError, "Pi identity output is oversized" if result.oversized
-              [result.stdout, result.stderr, result.status]
-            end
-            @native = Molecules::NativeQueueExecutor.new(pi_client: client, runner: runner)
-          end
-
-          def pi_identity
-            @native.pi_identity
-          end
-        end
-
-        module_function
-
-        # The Assign resolver has verified context paths/key/client. native is
-        # the immutable canonical stage, not current process discovery. Endpoint
-        # liveness is checked lazily only if Inbox actually observes replacement.
-        def build(context:, mapping:, native:, kernel: Ace::Runtime::Molecules::ProtectedLinux.new)
-          native_fields = %w[server_identity socket_identity workspace_id]
-          unless native.is_a?(Hash) && native_fields.all? { |key| native.key?(key) }
-            raise ValidationError, "canonical native stage is unavailable"
-          end
-          fixed = JSON.parse(JSON.generate(mapping))
-          fixed["native"].merge!(native.slice(*native_fields))
-          control = Molecules::ProtectedNativeControl.new(mapping: fixed, kernel: kernel)
-          key = OpenSSL::PKey.read(File.binread(context.fetch("receipt_public_key")))
-          unless key.is_a?(OpenSSL::PKey::RSA) && !key.private?
-            raise ValidationError, "protected inbox requires a public RSA key"
-          end
-          Inbox.new(executor: PaneReader.new(control), native: PiIdentity.new(context.fetch("pi_queue_client")),
-            deliveries_dir: context.fetch("deliveries_dir"), receipt_public_key: key)
-        rescue KeyError, SystemCallError, OpenSSL::PKey::PKeyError
-          raise ValidationError, "protected inbox fixed context is unavailable"
-        end
-      end
-    end
-  end
-end