ace-bundle 0.44.2 → 0.45.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 772a24588e3034043a2fd8a401702b531e98fcf4d4f1b8e9d54da2395e10f52b
-  data.tar.gz: f05f0b8d92c6c2ae6a3921cb1a7dfb8078843f7da90b946268c3f6809639bd39
+  metadata.gz: 499c5ba424482d3c33a912bbf5fd65128e5963326095445b5a0fd081c9e30ae4
+  data.tar.gz: 6da09d023b7cb96e2ef3934974a0f48e614890666deb27928d12e6a43f0332f8
 SHA512:
-  metadata.gz: 860184154f36ab8015ce3636ce2a03671073367a601d997296ae3190b470d817ebbfb7cb696bd51ae376ec4608005d4043cd124bb700e0184aa5af5e31d98554
-  data.tar.gz: 3cbcc8c5019efbf54173be144686e453053c5c28298c8ae510223541158d891441464717a7ccf2482d863b56e5558b69d33fb3a00ebe8e9981eab0cdf5b77502
+  metadata.gz: f6c52aeb31efdd946038ed769c953c395b8557191ddad5ac173d6b8b56fc0297522bae4d46567c27c49d5c60c608c781ec8a5312844db51ea56c99c9a71c5030
+  data.tar.gz: 144acfa16735db88a83fdc9b1f48735f87b249519cae8ee0d4ba69a5af723e552819f1000fa0191a504fabebcf18575901457668f842789022ff57d128ce1b43

data/CHANGELOG.md

@@ -6,6 +6,16 @@ The format is based on [Keep a Changelog][1], and this project adheres to [Seman
 
 ## [Unreleased]
 
+## [0.45.0] - 2026-10-10
+
+### Added
+
+- Ship protected task-context loading with the Runtime 0.3 API and held artifact verification.
+
+### Fixed
+
+- Require Runtime 0.3 and Herdr 0.5.1 so installed contexts cannot resolve missing producer modules.
+
 ## [0.44.2] - 2026-09-29
 
 ### Fixed

data/lib/ace/bundle/cli/commands/load.rb

@@ -79,6 +79,9 @@ module Ace
           # Resource limits
           option :max_size, type: :integer, desc: "Maximum file size in bytes"
           option :timeout, type: :integer, desc: "Command timeout in seconds"
+          option :mapping, type: :string, desc: "Original protected mapping for captured task context"
+          option :assignment, type: :string, desc: "Original protected assignment ID@SCOPE"
+          option :attempt, type: :string, desc: "Original protected attempt for captured task context"
 
           # Standard options (inherited from Base but need explicit definition for ace-support-cli)
           option :version, type: :boolean, desc: "Show version information"

data/lib/ace/bundle/molecules/protected_task_context.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+require "json"
+require "tmpdir"
+require "ace/runtime/molecules/protected_task_context_entry"
+require "ace/herdr/molecules/bounded_process"
+
+module Ace
+  module Bundle
+    module Molecules
+      # Fixed installed CLI boundary. Bundle does not import Assign, select its
+      # roster or resolve task context through project command templates.
+      class ProtectedTaskContext
+        TOKEN = /\A[A-Za-z0-9][A-Za-z0-9._-]{0,199}\z/
+        SCOPE = /\A[0-9]+(?:\.[0-9]+)*\z/
+        SHA = /\A[0-9a-f]{64}\z/
+        TEXT_LIMIT = 1_048_576
+        RESPONSE_LIMIT = 6_307_840
+        SELECTION_LIMIT = 65_536
+        PRINCIPAL_LIMIT = 1_024
+        STDERR_LIMIT = 16_384
+        DEADLINE = 30
+        SELECTOR_FIELDS = %w[mapping_id assignment_id attempt_id scope].freeze
+        ASSOCIATION_FIELDS = (SELECTOR_FIELDS + %w[definition_digest selection_sha256]).freeze
+
+        def initialize(entry_owner: Ace::Runtime::Molecules::ProtectedTaskContextEntry.new,
+          runner: Ace::Herdr::Molecules::BoundedProcess, uid: Process.uid, env: ENV)
+          @owner, @runner, @uid, @env = entry_owner, runner, uid, env
+        end
+
+        # nil means genuinely ordinary; every installed failure raises.
+        def load(uri, options: {})
+          selected = selected?(options)
+          @owner.with do |discovery|
+            unless discovery
+              unavailable!("installed entry is absent") if selected
+              next nil
+            end
+            principal = invoke(discovery, ["authority", "task-context-principal"], PRINCIPAL_LIMIT)
+            object!(principal, %w[schema uid protected_worker])
+            unless principal.fetch("schema") == "ace.assign.task-context-principal/v1" &&
+                principal.fetch("uid").is_a?(Integer) && principal.fetch("uid") == @uid && [true, false].include?(principal.fetch("protected_worker"))
+              mismatch!("actual caller classification")
+            end
+            next nil unless principal.fetch("protected_worker") || selected
+            task = uri.delete_prefix("task://")
+            mismatch!("task URI") unless uri.start_with?("task://") && task.match?(TOKEN)
+            selectors, argv = selectors!(options)
+            selection = invoke(discovery, ["authority", "task-context-selection", *argv], SELECTION_LIMIT)
+            object!(selection, ASSOCIATION_FIELDS + %w[schema task_context_entry])
+            association!(selection, selectors, "ace.assign.task-context-selection/v1")
+            original = validated_output_pin!(selection.fetch("task_context_entry"))
+            manifest_hint!(original)
+            result = invoke(original, ["authority", "task-context", *argv, "--task", task], RESPONSE_LIMIT)
+            object!(result, ASSOCIATION_FIELDS + %w[schema task_id text])
+            association!(result, selectors, "ace.assign.prepared-task-context/v1")
+            unless result.slice(*ASSOCIATION_FIELDS) == selection.slice(*ASSOCIATION_FIELDS) && result.fetch("task_id") == task
+              mismatch!("original prepared response association")
+            end
+            text = result.fetch("text")
+            mismatch!("captured text bound") unless text.is_a?(String) && text.valid_encoding? && text.bytesize.between?(1, TEXT_LIMIT)
+            text.freeze
+          end
+        rescue Ace::Runtime::Error, IOError, SystemCallError, Timeout::Error, Ace::Herdr::Molecules::BoundedProcess::PostLaunchError => error
+          unavailable!(error.message)
+        rescue KeyError, TypeError, NoMethodError, ArgumentError, JSON::ParserError, EncodingError
+          mismatch!("closed task-context response")
+        end
+
+        private
+
+        def selected?(options)
+          options.values_at(:mapping, :assignment, :attempt).any? { |value| value && !value.to_s.empty? } ||
+            %w[ACE_ASSIGN_LAUNCH_MAPPING ACE_ASSIGN_ASSIGNMENT_ID ACE_ASSIGN_ATTEMPT_ID ACE_ASSIGN_TASK_CONTEXT_ENTRY].any? { |key| !@env[key].to_s.empty? }
+        end
+
+        def selectors!(options)
+          mapping = hint!(options[:mapping], "ACE_ASSIGN_LAUNCH_MAPPING")
+          attempt = hint!(options[:attempt], "ACE_ASSIGN_ATTEMPT_ID")
+          scoped = hint!(options[:assignment], "ACE_ASSIGN_DEFAULT_TARGET", token: false)
+          assignment, scope = scoped.split("@", 2)
+          mismatch!("explicit scoped original assignment") unless assignment&.match?(TOKEN) && scope&.match?(SCOPE)
+          bare_hint = @env["ACE_ASSIGN_ASSIGNMENT_ID"].to_s
+          mismatch!("assignment hint differs") unless bare_hint.empty? || bare_hint == assignment
+          [{"mapping_id" => mapping, "assignment_id" => assignment, "attempt_id" => attempt, "scope" => scope},
+            ["--mapping", mapping, "--assignment", scoped, "--attempt", attempt]]
+        end
+
+        def hint!(explicit, key, token: true)
+          hint = @env[key].to_s
+          value = explicit || hint
+          unless value.is_a?(String) && value.encoding == Encoding::UTF_8 && value.valid_encoding? && !value.empty? &&
+              (hint.empty? || hint == value) && (!token || value.match?(TOKEN))
+            mismatch!("complete original selectors required")
+          end
+          value
+        end
+
+        def association!(record, selectors, schema)
+          unless record.fetch("schema") == schema && record.slice(*SELECTOR_FIELDS) == selectors &&
+              %w[definition_digest selection_sha256].all? { |key| record.fetch(key).is_a?(String) && record.fetch(key).match?(SHA) }
+            mismatch!("original prepared selectors or digest")
+          end
+        end
+
+        def manifest_hint!(pin)
+          hint = @env["ACE_ASSIGN_TASK_CONTEXT_ENTRY"].to_s
+          return if hint.empty?
+          mismatch!("manifest hint bound") if hint.bytesize > SELECTION_LIMIT
+          reference = JSON.parse(hint, create_additions: false, max_nesting: 8, allow_duplicate_key: false, allow_comments: false)
+          candidate = validated_output_pin!({"manifest" => reference, "wrapper" => pin.fetch("wrapper")})
+          mismatch!("manifest hint differs from original") unless candidate == pin
+        end
+
+        def validated_output_pin!(pin)
+          @owner.validate_pin!(pin)
+        rescue Ace::Runtime::Error, KeyError, TypeError, NoMethodError, ArgumentError
+          mismatch!("original entry reference fields")
+        end
+
+        def invoke(pin, arguments, limit)
+          @owner.with_entry(pin) do |entry|
+            with_selector(entry.pin.fetch("manifest")) do |selector|
+              result = @runner.call(["/proc/self/fd/4", "-I", "-S", "-B", "-", *arguments],
+                stdin_data: entry.body, timeout_s: DEADLINE, output_limit: limit, stderr_limit: STDERR_LIMIT,
+                descriptor_mapping: {4 => entry.interpreter, 5 => selector}, environment: {}, chdir: "/", cleanup_group: true)
+              unavailable!("fixed task-context command failed") unless result.status&.success?
+              mismatch!("fixed task-context output was truncated") if result.oversized
+              bytes = result.stdout
+              unless bytes.is_a?(String) && bytes.bytesize.between?(1, limit)
+                mismatch!("fixed task-context output bound")
+              end
+              text = bytes.dup.force_encoding(Encoding::UTF_8)
+              unless text.valid_encoding? && text.end_with?("\n") && text.count("\n") == 1
+                mismatch!("fixed task-context output framing")
+              end
+              record = JSON.parse(text, create_additions: false, max_nesting: 16, allow_duplicate_key: false, allow_comments: false)
+              mismatch!("fixed task-context output is not compact JSON") unless JSON.generate(record) + "\n" == text
+              record
+            end
+          end
+        end
+
+        # This private temporary transports only an untrusted manifest REF. The
+        # accepted code/interpreter come from retained protected handles above.
+        def with_selector(reference)
+          bytes = JSON.generate(reference) + "\n"
+          mismatch!("entry selector bound") if bytes.bytesize > SELECTION_LIMIT
+          Dir.mktmpdir("ace-task-context-", "/tmp") do |directory|
+            path = File.join(directory, "selector.json")
+            File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o600) do |writer|
+              writer.write(bytes); writer.flush
+              File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |reader|
+                unless reader.stat.file? && reader.stat.uid == Process.uid && (reader.stat.mode & 0o077).zero? &&
+                    [reader.stat.dev, reader.stat.ino, reader.stat.size] == [writer.stat.dev, writer.stat.ino, bytes.bytesize]
+                  unavailable!("private selector descriptor differs")
+                end
+                File.unlink(path)
+                yield reader
+              end
+            end
+          end
+        end
+
+        def object!(record, fields)
+          mismatch!("closed fixed task-context fields") unless record.is_a?(Hash) && record.keys.sort == fields.sort
+        end
+
+        def mismatch!(detail)
+          raise Ace::Bundle::Error, "prepared_input_mismatch: #{detail}"
+        end
+
+        def unavailable!(detail)
+          raise Ace::Bundle::Error, "prepared_input_unavailable: #{detail}"
+        end
+      end
+    end
+  end
+end

data/lib/ace/bundle/organisms/bundle_loader.rb

@@ -21,6 +21,7 @@ require_relative "pr_bundle_loader"
 require_relative "../models/bundle_data"
 require_relative "../atoms/content_checker"
 require_relative "../atoms/typo_detector"
+require_relative "../molecules/protected_task_context"
 
 module Ace
   module Bundle
@@ -986,19 +987,17 @@ module Ace
           # Process files
           if config["files"] && config["files"].any?
             # Resolve any protocol references (e.g., wfi://workflow-name)
-            resolved_files = config["files"].filter_map do |file_ref|
-              resolved = resolve_file_reference(file_ref)
-              if !resolved && @review_safe_mode
+            source_inputs = resolve_file_inputs(config["files"]) do |file_ref|
+              if @review_safe_mode
                 data[:errors] << "Unresolved file source: #{file_ref}"
               end
-              resolved
             end
+            resolved_files = source_inputs.filter_map { |entry| entry[:path] }
             missing_sources = missing_review_sources(resolved_files, base_dir: @options[:base_dir] || project_root,
               exclude: config["exclude"] || [])
             missing_sources.each do |pattern|
               data[:errors] << "Unmatched required file pattern: #{pattern}"
             end
-            resolved_files -= missing_sources
 
             aggregator = Ace::Core::Molecules::FileAggregator.new(
               max_size: config["max_size"] || @options[:max_size],
@@ -1008,15 +1007,7 @@ module Ace
               exclude: config["exclude"] || []
             )
 
-            # Check if any patterns contain glob characters
-            has_globs = resolved_files.any? { |f| f.include?("*") || f.include?("?") || f.include?("[") }
-
-            # Use aggregate for globs, aggregate_files for literal paths
-            result = if has_globs
-              aggregator.aggregate(resolved_files)
-            else
-              aggregator.aggregate_files(resolved_files)
-            end
+            result = aggregate_file_inputs(source_inputs, missing_sources, aggregator)
             data[:files] = result[:files]
             data[:errors].concat(result[:errors])
           end
@@ -1271,8 +1262,13 @@ module Ace
         end
 
         def load_protocol(protocol_ref)
+          if (text = protected_task_text(protocol_ref))
+            bundle = Models::BundleData.new(content: text, metadata: {protocol_ref: protocol_ref, protected_prepared: true})
+            bundle.source_files << {path: protocol_ref, content: text}
+            return bundle
+          end
           # Resolve protocol using ace-nav
-          resolved_path = resolve_protocol(protocol_ref)
+          resolved_path = resolve_protocol(protocol_ref, protected_checked: true)
 
           if resolved_path && File.exist?(resolved_path)
             # Load the resolved file
@@ -1287,7 +1283,10 @@ module Ace
           end
         end
 
-        def resolve_protocol(protocol_ref)
+        def resolve_protocol(protocol_ref, protected_checked: false)
+          if !protected_checked && protected_task_text(protocol_ref)
+            raise Ace::Bundle::Error, "Captured protected task context must be consumed as text, never a reopened pathname"
+          end
           require "ace/support/nav"
           engine = Ace::Support::Nav::Organisms::NavigationEngine.new
           if @review_safe_mode && engine.cmd_protocol?(protocol_ref.split("://", 2).first)
@@ -1317,10 +1316,16 @@ module Ace
           nil
         end
 
-        def resolve_file_reference(file_ref)
+        def protected_task_text(reference)
+          return nil unless reference.is_a?(String) && reference.start_with?("task://")
+          @protected_task_context ||= Molecules::ProtectedTaskContext.new
+          @protected_task_context.load(reference, options: @options)
+        end
+
+        def resolve_file_reference(file_ref, protected_checked: false)
           # Check if it's a protocol reference (contains ://)
           if file_ref.match?(/^[\w-]+:\/\//)
-            resolve_protocol(file_ref)
+            resolve_protocol(file_ref, protected_checked: protected_checked)
           elsif file_ref.start_with?("./") && @template_dir
             # Resolve ./ paths relative to the template file's directory
             File.join(@template_dir, file_ref)
@@ -1330,6 +1335,45 @@ module Ace
           end
         end
 
+        def resolve_file_inputs(references)
+          references.filter_map do |reference|
+            if (text = protected_task_text(reference))
+              {record: {path: reference, content: text}}
+            elsif (path = resolve_file_reference(reference, protected_checked: true))
+              {path: path}
+            else
+              yield reference if block_given?
+              nil
+            end
+          end
+        end
+
+        def aggregate_file_inputs(inputs, missing, aggregator)
+          paths = inputs.filter_map { |entry| entry[:path] } - missing
+          unless inputs.any? { |entry| entry[:record] }
+            return aggregate_paths(paths, aggregator)
+          end
+          # Retained protocol text enters the existing content record interface,
+          # without a temporary pathname. Preserve mixed source order.
+          inputs.each_with_object({files: [], errors: []}) do |entry, result|
+            if entry[:record]
+              result[:files] << entry.fetch(:record)
+            elsif !missing.include?(entry.fetch(:path))
+              part = aggregate_paths([entry.fetch(:path)], aggregator)
+              result[:files].concat(part.fetch(:files))
+              result[:errors].concat(part.fetch(:errors))
+            end
+          end
+        end
+
+        def aggregate_paths(paths, aggregator)
+          if paths.any? { |path| path.include?("*") || path.include?("?") || path.include?("[") }
+            aggregator.aggregate(paths)
+          else
+            aggregator.aggregate_files(paths)
+          end
+        end
+
         # Process content for a specific section
         def process_section_content(bundle, section_name, section_data, options, bundle_config = {})
           # Process all content types that are present in the section
@@ -1356,21 +1400,19 @@ module Ace
           return unless files.any?
 
           # Resolve any protocol references (e.g., wfi://workflow-name)
-          resolved_files = files.filter_map do |file_ref|
-            resolved = resolve_file_reference(file_ref)
-            if !resolved && @review_safe_mode
+          source_inputs = resolve_file_inputs(files) do |file_ref|
+            if @review_safe_mode
               bundle.metadata[:errors] ||= []
               bundle.metadata[:errors] << "Section '#{section_name}': unresolved file source: #{file_ref}"
             end
-            resolved
           end
+          resolved_files = source_inputs.filter_map { |entry| entry[:path] }
           missing_sources = missing_review_sources(resolved_files, base_dir: options[:base_dir] || project_root,
             exclude: section_data[:exclude] || section_data["exclude"] || [])
           missing_sources.each do |pattern|
             bundle.metadata[:errors] ||= []
             bundle.metadata[:errors] << "Section '#{section_name}': unmatched required file pattern: #{pattern}"
           end
-          resolved_files -= missing_sources
 
           aggregator = Ace::Core::Molecules::FileAggregator.new(
             max_size: options[:max_size] || options["max_size"],
@@ -1380,15 +1422,7 @@ module Ace
             exclude: section_data[:exclude] || section_data["exclude"] || []
           )
 
-          # Check if any patterns contain glob characters
-          has_globs = resolved_files.any? { |f| f.include?("*") || f.include?("?") || f.include?("[") }
-
-          # Use aggregate for globs, aggregate_files for literal paths to preserve order
-          result = if has_globs
-            aggregator.aggregate(resolved_files)
-          else
-            aggregator.aggregate_files(resolved_files)
-          end
+          result = aggregate_file_inputs(source_inputs, missing_sources, aggregator)
 
           # Store section files in section data
           section_data[:_processed_files] = result[:files]
@@ -1491,6 +1525,13 @@ module Ace
           files_in_content = bundle.source_files.any? &&
             (!bundle_config["embed_document_source"] || @section_processor.has_sections?({"bundle" => bundle_config}))
 
+          if (text = protected_task_text(base_ref))
+            bundle.content = [text, (bundle.content if files_in_content)].compact.join("\n\n")
+            bundle.metadata.merge!(base_ref: base_ref, base_type: "protected_prepared")
+            bundle.source_files << {path: base_ref, content: text}
+            return
+          end
+
           # Check if base_ref looks like a file reference (has protocol, slashes, or is a known path pattern)
           # This heuristic helps prioritize file resolution for extension-less files
           has_protocol = base_ref.match?(/^[\w-]+:\/\//)
@@ -1499,7 +1540,7 @@ module Ace
             (@review_safe_mode && base_ref.match?(/\.(?:md|markdown|txt|json|ya?ml)\z/i))
 
           # Try to resolve as file reference first (handles extension-less files like README, CONTEXT)
-          resolved_path = resolve_file_reference(base_ref)
+          resolved_path = resolve_file_reference(base_ref, protected_checked: true)
 
           # Check if we successfully resolved to an existing file
           if resolved_path && File.exist?(resolved_path)

data/lib/ace/bundle/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Bundle
-    VERSION = "0.44.2"
+    VERSION = "0.45.0"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-bundle
 version: !ruby/object:Gem::Version
-  version: 0.44.2
+  version: 0.45.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -107,6 +107,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.28'
+- !ruby/object:Gem::Dependency
+  name: ace-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: ace-herdr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
 - !ruby/object:Gem::Dependency
   name: ace-compressor
   requirement: !ruby/object:Gem::Requirement
@@ -172,6 +200,7 @@ files:
 - lib/ace/bundle/molecules/bundle_file_writer.rb
 - lib/ace/bundle/molecules/bundle_merger.rb
 - lib/ace/bundle/molecules/preset_manager.rb
+- lib/ace/bundle/molecules/protected_task_context.rb
 - lib/ace/bundle/molecules/section_compressor.rb
 - lib/ace/bundle/molecules/section_formatter.rb
 - lib/ace/bundle/molecules/section_processor.rb