olyx-guardrails 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 789eb5e71a301345c3fd0d28e59ffee0b0d9cf67ee9686f0912e5a743ccd093b
-  data.tar.gz: d89fc57b450761fe6e530fa116e39413eeb17edeb9c73023fbd8247ace98a727
+  metadata.gz: d1ee4f7c6297bf8348c6d74feff8bd055ce23b819091893043d02a6695140cd2
+  data.tar.gz: e06e7f54f777a8e56da1fcbad45f92d327f30aea934467235a9bc4384dc2229d
 SHA512:
-  metadata.gz: 17390bf8cbd4961a4e4a669a5ca0b8f80afcf2663fceaea85e5fe31050e789252b5952ef8063ef80d8ffaa5b78f7e69d4a4c96dba8ce1724fcfe090ccb5f3e50
-  data.tar.gz: d3e28269e0760c9c09c83f25f8499b74391ee1d7ebf5d3d9ab1a4fe9236d56c2f90b63daa6c603068f6a40fa2398577d08a2f8631d1c05c37e01a478d9ec3a2a
+  metadata.gz: 1d85a8e9c03dc058fd188132a2754c4738063ddc79039eb5bd88c5dcf25555f3b266d6d4b29ee37503b7c25fe0beabc74d0cfe895f82ad16c82e93ff2351955b
+  data.tar.gz: 6e04d4fda8672b775475e0741b621ee850ab178656283a20c4fc1f27aa324112cb2ee5c883890dec97b53d423b7f65e6daa88006269574481c36e69128542afd

data/CHANGELOG.md

@@ -3,6 +3,39 @@
 All notable changes to olyx-guardrails are documented here.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [Unreleased]
+
+## [1.2.0] - 2026-10-02
+
+### Changed
+
+- Prompt-injection normalization now scans long inputs in overlapping bounded
+  windows instead of ignoring content after the first 20,000 characters.
+- Narrowed role-play matching so ordinary agent prompts do not block by
+  default.
+- Provider exceptions return a stable public error instead of exposing the
+  provider's exception message.
+- Confidentiality labels are no longer classified as credentials or used to
+  redact an entire input. Applications can enforce those labels with policy
+  rules when required.
+- Risk scores now describe findings independently from the policy's blocking
+  configuration.
+- Removed redundant scanner passes and consolidated internal configuration and
+  matching layers.
+- Simplified the public quality gate to tests, documentation, and RuboCop.
+
+## [1.1.3] - 2026-08-07
+
+### Changed
+
+- Added the Bundler release task expected by the trusted publishing workflow.
+
+## [1.1.2] - 2026-08-07
+
+### Changed
+
+- Added a tag-based RubyGems release workflow using trusted publishing.
+
 ## [1.1.1] - 2026-07-24
 
 ### Changed
@@ -27,7 +60,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   decision has zero risk.
 - The Rails generator provides copyable policy customization instructions and
   tests the customized YAML path.
-- Contributor setup, complete local quality validation, and maintainer release
+- Contributor setup, local validation, and maintainer release
   verification have canonical commands and documentation.
 - Closely coupled proxy objects were folded into their owning runtime,
   configuration, result-building, and notification components.
@@ -35,7 +68,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   ignored instead of being coerced across the untrusted provider boundary.
 - Contributor and Rails appraisal locks use the current `net-imap` patch.
 - CI refreshes the Ruby advisory database and blocks known-vulnerable locked
-  dependencies without making the offline local quality gate network-dependent.
+  dependencies without making offline local validation network-dependent.
 
 ## [1.0.0] - 2026-07-21
 
@@ -143,11 +176,8 @@ Initial public release.
 
 - The core has one lightweight runtime dependency, Ruby's `base64` bundled gem.
   Rails remains optional and is loaded only when used.
-- CI enforces RuboCop — including calibrated structural-complexity cops
-  (`Metrics/AbcSize`, `CyclomaticComplexity`, `PerceivedComplexity`,
-  `ClassLength`) in place of a separate complexity tool — and a RubyCritic
-  maintainability gate, alongside the Appraisal matrix across Rails 8.0
-  and 8.1.
+- CI enforces tests, documentation checks, RuboCop, and the Appraisal matrix
+  across Rails 8.0 and 8.1.
 - Native RDoc covers every supported public class, module, constant, attribute,
   and method. CI blocks undocumented additions to the explicit public API
   manifest while leaving implementation-only constants outside the

data/README.md

@@ -1,6 +1,7 @@
 # Olyx Guardrails
 
-[![Gem Version](https://badge.fury.io/rb/olyx-guardrails.svg)](https://rubygems.org/gems/olyx-guardrails)
+[![RubyGems](https://img.shields.io/gem/v/olyx-guardrails?label=rubygems)](https://rubygems.org/gems/olyx-guardrails)
+[![Release](https://img.shields.io/github/v/release/Olyx-labs/olyx-guardrails?label=release)](https://github.com/Olyx-labs/olyx-guardrails/releases/latest)
 [![Test](https://github.com/Olyx-labs/olyx-guardrails/actions/workflows/test.yml/badge.svg)](https://github.com/Olyx-labs/olyx-guardrails/actions/workflows/test.yml)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Olyx-labs/olyx-guardrails/badge)](https://securityscorecards.dev/viewer/?uri=github.com/Olyx-labs/olyx-guardrails)
 [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
@@ -28,7 +29,7 @@ discover model calls, or send application content to a third party.
 
 Rails is optional. The standalone Ruby API does not load Rails.
 
-The 1.1 release supports Rails 8.0 and 8.1. Only the listed Rails
+The 1.1 release line supports Rails 8.0 and 8.1. Only the listed Rails
 series are tested and supported. When a series reaches upstream end-of-life,
 a subsequent gem release may remove it instead of maintaining framework
 security fixes independently. Every support change is recorded in the

data/lib/olyx/guardrails/check_result_builder.rb

@@ -39,7 +39,7 @@ module Olyx
       end
 
       def risk(checks, ordered, analysis)
-        { risk_score: RiskScorer.call(checks, ordered, analysis), checks: ordered }
+        { risk_score: RiskScorer.call(checks, analysis), checks: ordered }
       end
 
       def analysis_result(analysis)

data/lib/olyx/guardrails/check_runner.rb

@@ -3,7 +3,6 @@
 require_relative 'check_result_builder'
 require_relative 'check_analyzer'
 require_relative 'check_set'
-require_relative 'check_pipeline'
 require_relative 'policy'
 require_relative 'validation'
 
@@ -24,7 +23,10 @@ module Olyx
 
       def call
         checks = CheckSet.call(@source, policy: @policy)
-        CheckPipeline.call(@source, checks, policy: @policy, llm_provider: @llm_provider)
+        merged, analysis = CheckAnalyzer.call(
+          checks, provider: @llm_provider, source: @source, policy: @policy
+        )
+        CheckResultBuilder.call(merged, analysis, @policy)
       end
 
       private

data/lib/olyx/guardrails/check_set.rb

@@ -1,33 +1,80 @@
 # frozen_string_literal: true
 
-require_relative 'checks/injection_check'
-require_relative 'checks/length_check'
-require_relative 'checks/pii_check'
-require_relative 'checks/policy_check'
-require_relative 'checks/secret_check'
-require_relative 'checks/skipped_checks'
+require_relative 'injection_detector'
+require_relative 'pii/text_scrubber'
+require_relative 'policy_scanner'
+require_relative 'secret_scanner'
 
 module Olyx
   module Guardrails
     # Coordinates independent deterministic checks for one normalized input.
     class CheckSet
-      CHECKS = {
-        pii: Checks::PiiCheck,
-        injection: Checks::InjectionCheck,
-        secret: Checks::SecretCheck,
-        policy: Checks::PolicyCheck
-      }.freeze
-
-      def self.call(source, policy:)
-        length = Checks::LengthCheck.call(source, policy)
-        content = length[:allowed] ? scan(source, policy) : Checks::SkippedChecks.call
+      def self.call(source, policy:, messages: nil)
+        length = length_check(source, policy)
+        content = length[:allowed] ? scan(source, policy, messages) : skipped_checks
         content.merge(length: length)
       end
 
-      def self.scan(source, policy)
-        CHECKS.to_h { |name, check| [name, check.call(source, policy)] }
+      def self.scan(source, policy, messages)
+        {
+          pii: pii_check(source, policy),
+          injection: injection_check(source, policy, messages),
+          secret: secret_check(source, policy),
+          policy: policy_check(source, policy)
+        }
       end
-      private_class_method :scan
+
+      def self.length_check(source, policy)
+        length = source.length
+        maximum = policy.max_input_length
+        { type: 'length', allowed: length <= maximum, length: length, max_length: maximum }
+      end
+
+      def self.pii_check(source, policy)
+        detected = Pii::TextScrubber.detect?(source)
+        { type: 'pii', allowed: !detected || !policy.block_pii?, detected: detected }
+      end
+
+      def self.injection_check(source, policy, messages)
+        scan = InjectionDetector.scan(messages || [{ 'role' => 'user', 'content' => source }])
+        attempt = scan[:injection_attempt]
+        {
+          type: 'injection',
+          allowed: !attempt || !policy.block_injections?,
+          injection_attempt: attempt,
+          patterns: scan[:patterns]
+        }
+      end
+
+      def self.secret_check(source, policy)
+        scan = SecretScanner.scan(source, custom_patterns: policy.secret_patterns)
+        leaked = scan[:leaked]
+        { type: 'secret', allowed: !leaked || !policy.block_secrets?, leaked: leaked, count: scan[:findings].size }
+      end
+
+      def self.policy_check(source, policy)
+        scan = PolicyScanner.scan(source, policy: policy)
+        findings = scan[:findings]
+        {
+          type: 'policy', allowed: !scan[:blocked], violated: scan[:violated],
+          count: findings.size, findings: findings
+        }
+      end
+
+      def self.skipped_checks
+        {
+          pii: skipped('pii', detected: false),
+          injection: skipped('injection', injection_attempt: false, patterns: []),
+          secret: skipped('secret', leaked: false, count: 0),
+          policy: skipped('policy', violated: false, count: 0, findings: [])
+        }
+      end
+
+      def self.skipped(type, **fields)
+        { type: type, allowed: true, skipped: true, **fields }
+      end
+      private_class_method :injection_check, :length_check, :pii_check, :policy_check, :scan,
+                           :secret_check, :skipped, :skipped_checks
     end
   end
 end

data/lib/olyx/guardrails/injection_patterns.rb

@@ -19,8 +19,7 @@ module Olyx
         /forget\s+(?:all\s+)?(?:your|previous)\s+instructions?/i,
         /your\s+(?:new\s+)?(?:instructions?\s+are|rules?\s+are)/i,
         /(?:override|bypass|ignore)\s+your\s+(?:instructions?|safety|restrictions?|filters?|rules?|training)/i,
-        /(?:pretend|act)\s+(?:you\s+are|as\s+if\s+you|as\s+a(?:n?\s+AI)?)/i,
-        /you\s+are\s+now\s+(?:a|an|free|DAN|unrestricted)/i,
+        /you\s+are\s+now\s+(?:an?\s+)?(?:free|DAN|unrestricted)(?:\s+AI)?/i,
         /(?:jailbreak|dan\s+mode|developer\s+mode|god\s+mode|unrestricted\s+mode)/i,
         /do\s+anything\s+now/i,
         /you\s+have\s+no\s+(?:restrictions?|limits?|rules?|filters?)/i,

data/lib/olyx/guardrails/llm_analysis.rb

@@ -6,6 +6,8 @@ module Olyx
   module Guardrails
     # Normalizes and bounds responses from an untrusted optional LLM provider.
     class LlmAnalysis
+      PROVIDER_ERROR = 'llm_provider failed'
+
       def self.call(provider, text, context)
         new(provider, text, context).call
       end
@@ -18,8 +20,8 @@ module Olyx
 
       def call
         Llm::AnalysisPipeline.call(@provider.call(@text, @context))
-      rescue StandardError => error
-        { error: error.message.to_s[0..200] }
+      rescue StandardError
+        { error: PROVIDER_ERROR }
       end
     end
   end

data/lib/olyx/guardrails/message_check_runner.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'check_pipeline'
-require_relative 'message_check_set'
+require_relative 'check_analyzer'
+require_relative 'check_result_builder'
+require_relative 'check_set'
 require_relative 'message_source'
 require_relative 'policy'
 require_relative 'validation'
@@ -16,8 +17,9 @@ module Olyx
 
         Validation.callable_or_nil!(llm_provider, name: 'llm_provider')
         source = MessageSource.call(messages)
-        checks = MessageCheckSet.call(source, messages, policy: policy)
-        CheckPipeline.call(source, checks, policy: policy, llm_provider: llm_provider)
+        checks = CheckSet.call(source, policy: policy, messages: messages)
+        merged, analysis = CheckAnalyzer.call(checks, provider: llm_provider, source: source, policy: policy)
+        CheckResultBuilder.call(merged, analysis, policy)
       end
     end
   end

data/lib/olyx/guardrails/pii/text_scrubber.rb

@@ -15,13 +15,27 @@ module Olyx
           PatternCatalog::ENTRIES.reduce(text) { |output, entry| replace(output, entry) }
         end
 
+        def detect?(text)
+          return false unless text.is_a?(String)
+
+          PatternCatalog::ENTRIES.any? { |entry| matches?(text, entry) }
+        end
+
         def replace(text, entry)
           pattern, replacement, validator = entry
           return text.gsub(pattern, replacement) unless validator
 
           text.gsub(pattern) { |match| validator.call(match) ? replacement : match }
         end
-        private_class_method :replace
+
+        def matches?(text, entry)
+          pattern, _, validator = entry
+          text.to_enum(:scan, pattern).any? do
+            match = Regexp.last_match[0]
+            !validator || validator.call(match)
+          end
+        end
+        private_class_method :matches?, :replace
       end
     end
   end

data/lib/olyx/guardrails/policy/match_collector.rb

@@ -2,6 +2,7 @@
 
 require_relative 'finding_order'
 require_relative 'rule_matcher'
+require_relative '../text/mapped_normalization'
 
 module Olyx
   module Guardrails
@@ -11,7 +12,12 @@ module Olyx
         module_function
 
         def call(source, rules)
-          findings = rules.each_with_index.flat_map { |rule, index| RuleMatcher.call(source, rule, index) }
+          return [] if rules.empty?
+
+          normalized = Text::MappedNormalization.new(source)
+          findings = rules.each_with_index.flat_map do |rule, index|
+            RuleMatcher.call(source, normalized, rule, index)
+          end
           findings.uniq { |finding| FindingOrder.identity(finding) }.sort_by { |finding| FindingOrder.key(finding) }
         end
       end

data/lib/olyx/guardrails/policy/rule_matcher.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'pattern_matcher'
-require_relative 'normalized_pattern_matcher'
-
 module Olyx
   module Guardrails
     module PolicyComponents
@@ -12,17 +9,37 @@ module Olyx
 
         module_function
 
-        def call(source, rule, index)
-          rule.patterns.flat_map { |pattern| matches(source, rule, index, pattern) }
+        def call(source, normalized, rule, index)
+          rule.patterns.flat_map { |pattern| matches(source, normalized, rule, index, pattern) }
         rescue TIMEOUT_ERROR
           raise ArgumentError, "policy rule #{rule.name.inspect} timed out"
         end
 
-        def matches(source, rule, index, pattern)
-          PatternMatcher.call(source, rule, index, pattern) +
-            NormalizedPatternMatcher.call(source, rule, index, pattern)
+        def matches(source, normalized, rule, index, pattern)
+          scan(source, rule, index, pattern) + normalized_matches(source, normalized, rule, index, pattern)
+        end
+
+        def scan(source, rule, index, pattern)
+          source.to_enum(:scan, pattern).map do
+            match = Regexp.last_match
+            finding(rule, index, match[0].to_s, match.begin(0), match.end(0))
+          end
+        end
+
+        def normalized_matches(source, normalized, rule, index, pattern)
+          return [] unless normalized.changed?
+
+          normalized.text.to_enum(:scan, pattern).map do
+            match = Regexp.last_match
+            starting, ending = normalized.original_span(match.begin(0), match.end(0))
+            finding(rule, index, source[starting...ending], starting, ending)
+          end
+        end
+
+        def finding(rule, index, full, starting, ending)
+          { rule: rule, rule_index: index, full: full, start: starting, end: ending }
         end
-        private_class_method :matches
+        private_class_method :finding, :matches, :normalized_matches, :scan
       end
     end
   end

data/lib/olyx/guardrails/policy.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
 require_relative 'policy/configuration_hash'
-require_relative 'policy/configuration'
+require_relative 'policy/name'
+require_relative 'policy/rule_collection'
+require_relative 'policy/secret_pattern_collection'
+require_relative 'enum_value'
+require_relative 'validation'
 
 module Olyx # :nodoc:
   module Guardrails
@@ -21,6 +25,27 @@ module Olyx # :nodoc:
     #
     # See docs/POLICIES.md for matching and replacement semantics.
     class Policy
+      LLM_FAILURE_MODE = EnumValue.new(
+        allowed: %i[allow block raise],
+        error: 'policy llm_failure_mode must be allow, block, or raise'
+      )
+      private_constant :LLM_FAILURE_MODE
+
+      # Returns the policy's stable String identifier.
+      attr_reader :name
+
+      # Returns the maximum accepted input length in Ruby characters.
+      attr_reader :max_input_length
+
+      # Returns +:allow+, +:block+, or +:raise+.
+      attr_reader :llm_failure_mode
+
+      # Returns the frozen custom secret regular-expression source Strings.
+      attr_reader :secret_patterns
+
+      # Returns the frozen PolicyRule collection.
+      attr_reader :rules
+
       # :call-seq:
       #   Policy.default -> Policy
       #
@@ -67,37 +92,25 @@ module Olyx # :nodoc:
         secret_patterns: [],
         rules: []
       )
-        @configuration = PolicyComponents::Configuration.new(
-          identity: [name, max_input_length],
-          blocking: [block_pii, block_injections, block_secrets],
-          restrictions: [llm_failure_mode, secret_patterns, rules]
-        )
+        @name = PolicyComponents::Name.call(name)
+        @max_input_length = Validation.non_negative_integer!(max_input_length, name: 'policy max_input_length')
+        @block_pii = Validation.boolean!(block_pii, name: 'policy block_pii')
+        @block_injections = Validation.boolean!(block_injections, name: 'policy block_injections')
+        @block_secrets = Validation.boolean!(block_secrets, name: 'policy block_secrets')
+        @llm_failure_mode = LLM_FAILURE_MODE.call(llm_failure_mode)
+        @secret_patterns = PolicyComponents::SecretPatternCollection.call(secret_patterns)
+        @rules = PolicyComponents::RuleCollection.call(rules)
         freeze
       end
 
-      # Returns the policy's stable String identifier.
-      def name = @configuration.identity.name
-
-      # Returns the maximum accepted input length in Ruby characters.
-      def max_input_length = @configuration.identity.max_input_length
-
-      # Returns +:allow+, +:block+, or +:raise+.
-      def llm_failure_mode = @configuration.restrictions.llm_failure_mode
-
-      # Returns the frozen custom secret regular-expression source Strings.
-      def secret_patterns = @configuration.restrictions.secret_patterns
-
-      # Returns the frozen PolicyRule collection.
-      def rules = @configuration.restrictions.rules
-
       # Returns whether PII findings block a decision.
-      def block_pii? = @configuration.blocking.pii?
+      def block_pii? = @block_pii
 
       # Returns whether prompt-injection findings block a decision.
-      def block_injections? = @configuration.blocking.injections?
+      def block_injections? = @block_injections
 
       # Returns whether secret findings block a decision.
-      def block_secrets? = @configuration.blocking.secrets?
+      def block_secrets? = @block_secrets
     end
   end
 end

data/lib/olyx/guardrails/policy_rule.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'policy_rule/configuration'
+require_relative 'policy_rule/pattern_compiler'
+require_relative 'validation'
 
 module Olyx # :nodoc:
   module Guardrails
@@ -10,6 +11,25 @@ module Olyx # :nodoc:
     # records safe fingerprints and offsets; it does not expose the matched
     # restricted text in public findings.
     class PolicyRule
+      MATCH_MODES = %i[substring whole_word regexp].freeze
+      NAME_FORMAT = /\A[a-z][a-z0-9_.:-]*\z/i
+      private_constant :MATCH_MODES, :NAME_FORMAT
+
+      # Returns the normalized String rule identifier.
+      attr_reader :name
+
+      # Returns the optional description, or +nil+.
+      attr_reader :description
+
+      # Returns +:substring+, +:whole_word+, or +:regexp+.
+      attr_reader :match
+
+      # Returns the frozen compiled Regexp collection.
+      attr_reader :patterns
+
+      # Returns the safe replacement used by redaction.
+      attr_reader :replacement
+
       # :call-seq:
       #   PolicyRule.new(name:, patterns: [], terms: [], match: :substring,
       #                  block: true, description: nil, replacement: nil)
@@ -28,34 +48,51 @@ module Olyx # :nodoc:
       # Invalid values and expressions that match empty text raise
       # ArgumentError.
       def initialize(name:, patterns: [], terms: [], match: :substring, block: true, description: nil, replacement: nil)
-        @identity = PolicyRuleComponents::IdentityConfiguration.new(name, description)
-        @matching = PolicyRuleComponents::MatchConfiguration.new(patterns, terms, match)
-        @enforcement = PolicyRuleComponents::EnforcementConfiguration.new(block, replacement || default_replacement)
+        @name = validate_name(name)
+        @description = validate_description(description)
+        @match = validate_match(match)
+        @patterns = PolicyRuleComponents::PatternCompiler.call(patterns: patterns, terms: terms, match: @match)
+        @block = Validation.boolean!(block, name: 'policy rule block')
+        @replacement = validate_replacement(replacement || default_replacement)
         freeze
       end
 
-      # Returns the normalized String rule identifier.
-      def name = @identity.name
+      # Returns whether a match blocks a decision.
+      def block? = @block
 
-      # Returns the optional description, or +nil+.
-      def description = @identity.description
+      private
 
-      # Returns +:substring+, +:whole_word+, or +:regexp+.
-      def match = @matching.mode
+      def default_replacement
+        "[RESTRICTED:#{@name.upcase}]"
+      end
 
-      # Returns the frozen compiled Regexp collection.
-      def patterns = @matching.patterns
+      def validate_name(value)
+        normalized = value.to_s
+        valid = (value.is_a?(String) || value.is_a?(Symbol)) && normalized.match?(NAME_FORMAT)
+        raise ArgumentError, 'policy rule name must be a String or Symbol identifier' unless valid
 
-      # Returns the safe replacement used by redaction.
-      def replacement = @enforcement.replacement
+        normalized.dup.freeze
+      end
 
-      # Returns whether a match blocks a decision.
-      def block? = @enforcement.block?
+      def validate_match(value)
+        normalized = value.respond_to?(:to_sym) ? value.to_sym : value
+        return normalized if MATCH_MODES.include?(normalized)
 
-      private
+        raise ArgumentError, 'policy rule match must be substring, whole_word, or regexp'
+      end
 
-      def default_replacement
-        "[RESTRICTED:#{@identity.name.upcase}]"
+      def validate_description(value)
+        return nil if value.nil?
+        return value.dup.freeze if value.is_a?(String) && !value.strip.empty? && value.length <= 500
+
+        raise ArgumentError, 'policy rule description must be a String of 1..500 characters or nil'
+      end
+
+      def validate_replacement(value)
+        valid = value.is_a?(String) && !value.empty? && value.length <= 100 && !value.match?(/[\r\n\t]/)
+        raise ArgumentError, 'policy rule replacement must be a single-line String of 1..100 characters' unless valid
+
+        value.dup.freeze
       end
     end
   end

data/lib/olyx/guardrails/rails.rb

@@ -3,15 +3,8 @@
 require 'active_support/notifications'
 require 'forwardable'
 require_relative '../guardrails'
-require_relative 'rails/active_job_handler'
-require_relative 'rails/action_cable'
 require_relative 'rails/active_model_validator'
-require_relative 'rails/controller'
-require_relative 'rails/enforcer'
-require_relative 'rails/graphql'
-require_relative 'rails/job'
 require_relative 'rails/runtime'
-require_relative 'rails/upload'
 
 module Olyx # :nodoc:
   module Guardrails
@@ -29,6 +22,14 @@ module Olyx # :nodoc:
     module Rails
       extend SingleForwardable
 
+      autoload :ActiveJobHandler, File.join(__dir__, 'rails/active_job_handler')
+      autoload :ActionCable, File.join(__dir__, 'rails/action_cable')
+      autoload :Controller, File.join(__dir__, 'rails/controller')
+      autoload :Enforcer, File.join(__dir__, 'rails/enforcer')
+      autoload :GraphQL, File.join(__dir__, 'rails/graphql')
+      autoload :Job, File.join(__dir__, 'rails/job')
+      autoload :Upload, File.join(__dir__, 'rails/upload')
+
       def self.runtime # :nodoc:
         @runtime ||= Runtime.new
       end

data/lib/olyx/guardrails/redaction/content_result.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../pii/text_scrubber'
+
 module Olyx
   module Guardrails
     module Redaction
@@ -13,13 +15,12 @@ module Olyx
         end
 
         def content(text, findings)
-          output = '[REDACTED]' if findings.any? { |finding| finding[:category] == 'confidentiality_marker' }
-          { text: output || text, findings: findings }
+          { text: text, findings: findings }
         end
 
         def detection(source, secret_scan, policy_redaction)
           {
-            pii_detected: PiiScrubber.scrub(source) != source,
+            pii_detected: Pii::TextScrubber.detect?(source),
             secret_leaked: secret_scan[:leaked],
             policy_violated: policy_redaction[:violated],
             policy_findings: policy_redaction[:findings]

data/lib/olyx/guardrails/risk/deterministic_score.rb

@@ -9,10 +9,8 @@ module Olyx
       module DeterministicScore
         module_function
 
-        def call(checks, ordered_checks)
-          score = CheckWeights.call(checks)
-          score += BLOCKED_RISK_WEIGHT if ordered_checks.any? { |check| !check[:allowed] }
-          score.clamp(0.0, 1.0).round(4)
+        def call(checks)
+          CheckWeights.call(checks).clamp(0.0, 1.0).round(4)
         end
       end
     end