pwn 0.5.708 → 0.5.710

data/lib/pwn/ai/agent/policy.rb

@@ -665,24 +665,164 @@ module PWN
         end
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::Policy.begin_episode(session_id:, request:, kind:, engine:)
-              PWN::AI::Agent::Policy.observe_step(action: 'shell', ok: true, duration: 0.2)
-              PWN::AI::Agent::Policy.finish(session_id:, score: 0.8, verdict: :solved)
-              PWN::AI::Agent::Policy.q(state:, action:)
-              PWN::AI::Agent::Policy.advantage(state:, action:)   # Registry.rank term
-              PWN::AI::Agent::Policy.recommend(actions: %w[shell pwn_eval])
-              PWN::AI::Agent::Policy.evaluate(limit: 100)
-              PWN::AI::Agent::Policy.stats
-              PWN::AI::Agent::Policy.episode_budget_met?
-              PWN::AI::Agent::Policy.to_context
-              PWN::AI::Agent::Policy.lean!(dry_run: true)
-              PWN::AI::Agent::Policy.warmup!(limit: 200)
-              PWN::AI::Agent::Policy.reset
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Feature → discrete state
+            #{self}.state(
+              kind: 'optional - statement|question|autonomous_goal|…',
+              request: 'optional - user text / active English task',
+              last_action: 'optional - previous tool name',
+              fails: 'optional - in-turn failure count',
+              engine: 'optional - active engine',
+              request_kind: 'optional - request kind value consumed by #state',
+              task: 'optional - task value consumed by #state',
+              ts_state: 'optional - ts state value consumed by #state',
+              final: 'optional - final value consumed by #state',
+              score: 'optional - score value consumed by #state',
+              last: 'optional - last value consumed by #state',
+              fail_n: 'optional - fail n value consumed by #state'
+            )
+
+            # Run cold and return its result
+            #{self}.cold?
+
+            # Run warm and return its result
+            #{self}.warm?
+
+            # True once live returns, warmup-replayed trajectories, or a
+            #{self}.episode_budget_met?
+
+            # Episode / environment loop
+            #{self}.begin_episode(
+              session_id: 'optional - PWN::Sessions id (defaults to ep_)',
+              request: 'optional - user request',
+              kind: 'optional - request kind',
+              intent: 'optional - Loop.request_intent',
+              engine: 'optional - active engine',
+              ts_state: 'optional - TaskSummarizer state hash'
+            )
+
+            # Run observe step and return its result
+            #{self}.observe_step(
+              session_id: 'optional - must match begin_episode when set',
+              action: 'required - tool name',
+              ok: 'required - Boolean, Reward.semantic_ok',
+              duration: 'optional - Float seconds',
+              ts_state: 'optional - TaskSummarizer state',
+              request: 'optional - used if episode was not begun',
+              kind: 'optional - kind value consumed by #observe_step',
+              engine: 'optional - engine value consumed by #observe_step'
+            )
+
+            # Run finish and return its result
+            #{self}.finish(
+              session_id: 'optional - active episode id',
+              score: 'optional - Reward.judge 0..1 (training target)',
+              verdict: 'optional - solved|partial|wrong|refused',
+              proxy_ok: 'optional - Boolean fallback when no judge score',
+              ts_state: 'optional - ts state value consumed by #finish',
+              final: 'optional - final value consumed by #finish',
+              confidence: 'optional - confidence value consumed by #finish'
+            )
+
+            # Value-based update (Q-learning) + policy-gradient (REINFORCE)
+            #{self}.update_q!(
+              transition: 'required - Hash with :state :action :reward :next_state :terminal (defaults to opts)'
+            )
+
+            # Run update pg and return its result
+            #{self}.update_pg!(
+              state: 'required - state value consumed by #update_pg!',
+              action: 'required - action value consumed by #update_pg!',
+              advantage: 'required - scalar G_t − V(s)'
+            )
+
+            # Run q and return its result
+            #{self}.q(
+              state: 'optional - state value consumed by #q',
+              action: 'optional - action value consumed by #q'
+            )
+
+            # Run value and return its result
+            #{self}.value(
+              state: 'optional - state value consumed by #value'
+            )
+
+            # Q(s,a) − V(s). Unknown / cold-start pairs return 0 so rank is unchanged
+            #{self}.advantage(
+              state: 'optional - state value consumed by #advantage (defaults to current_state)',
+              action: 'optional - action value consumed by #advantage'
+            )
+
+            # Run recommend and return its result
+            #{self}.recommend(
+              state: 'optional - default current episode state',
+              actions: 'required - Array of tool names',
+              epsilon: 'optional - explore probability (default EPSILON)'
+            )
+
+            # Run current state and return its result
+            #{self}.current_state
+
+            # Run current episode and return its result
+            #{self}.current_episode
+
+            # Hermes split: snapshot + clear the live episode so Loop.maybe_finish_policy
+            #{self}.detach_episode!
+
+            # Run attach episode and return its result
+            #{self}.attach_episode!(
+              episode: 'optional - episode value consumed by #attach_episode!'
+            )
+
+            # Persistence / eval
+            #{self}.load
+
+            # Run save and return its result
+            #{self}.save(
+              table: 'optional - table value consumed by #save (defaults to load)'
+            )
+
+            # Run trajectories and return its result
+            #{self}.trajectories(
+              limit: 'optional - limit value consumed by #trajectories'
+            )
+
+            # Run stats and return its result
+            #{self}.stats
+
+            # Replay stored trajectories under the current Q table
+            #{self}.evaluate(
+              limit: 'optional - limit value consumed by #evaluate'
+            )
+
+            # Run to context and return its result
+            #{self}.to_context(
+              limit: 'optional - limit value consumed by #to_context'
+            )
+
+            # Run lean and return its result
+            #{self}.lean!(
+              dry_run: 'optional - dry run value consumed by #lean!'
+            )
+
+            # Run reset and return its result
+            #{self}.reset
+
+            # Run enabled and return its result
+            #{self}.enabled?
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+
+            # Replay stored trajectories into Q so a cold table is not empty advice
+            #{self}.warmup!(
+              limit: 'optional - limit value consumed by #warmup!'
+            )
+
+            # Run maybe warmup and return its result
+            #{self}.maybe_warmup!
+          "
+          constants.sort
         end
 
         # ----------------------------------------------------------------

data/lib/pwn/ai/agent/prompt_builder.rb

@@ -199,8 +199,10 @@ module PWN
           eval_s = ToolGuard.deadline_s(kind: :eval) if defined?(ToolGuard)
           shell_s = ToolGuard.deadline_s(kind: :shell) if defined?(ToolGuard)
           load_line = "load1=#{snap[:load1]} ncpu=#{snap[:ncpu]} mem_avail_mb=#{snap[:mem_avail_mb]}"
+          doc = (PWN::Plugins::PreflightChecker.host_summary if defined?(PWN::Plugins::PreflightChecker))
           "#{load_line} pwn_eval/shell timeout = conservative seconds for this host " \
-            "(defaults eval=#{eval_s || 20}s shell=#{shell_s || 30}s, clamped)."
+            "(defaults eval=#{eval_s || 20}s shell=#{shell_s || 30}s, clamped). " \
+            "#{doc}"
         rescue StandardError
           'load unknown — pass a conservative timeout on pwn_eval/shell anyway.'
         end
@@ -359,16 +361,24 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              system_prompt = PWN::AI::Agent::PromptBuilder.build(session_id: 'abc', request: 'nmap sweep 10/8')
-              PWN::AI::Agent::PromptBuilder.budget   # => {memory:, metrics:, mistakes:, learning:, extro:}
-
-              Override per-engine via:
-                PWN::Env[:ai][:ollama][:prompt_budget] = { memory: 4, extro: false }
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run build and return its result
+            #{self}.build(
+              session_id: 'optional - PWN::Sessions id to embed in the ENV block',
+              request: 'optional - user request; enables relevance-ranked MEMORY when provided',
+              thin: 'optional - thin value consumed by #build',
+              mode: 'optional - mode value consumed by #build',
+              expand_harness: 'optional - expand harness value consumed by #build',
+              stuck: 'optional - stuck value consumed by #build'
+            )
+
+            # Run budget and return its result
+            #{self}.budget
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

data/lib/pwn/ai/agent/prompt_cache.rb

@@ -197,19 +197,50 @@ module PWN
         end
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              parts  = PWN::AI::Agent::PromptCache.split_system(text: system_prompt)
-              blocks = PWN::AI::Agent::PromptCache.anthropic_system_blocks(text: system_prompt)
-              msgs   = PWN::AI::Agent::PromptCache.openai_messages(messages: [...])
-              inst   = PWN::AI::Agent::PromptCache.gemini_system_instruction(text: system_prompt)
-              key    = PWN::AI::Agent::PromptCache.cache_key(text: system_prompt)
-              # Engine chat_with_tools uses the helpers automatically when
-              # PWN::Env[:ai][:agent][:prompt_cache] is truthy (default).
-
-              Toggle via PWN::Env[:ai][:agent][:prompt_cache]
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run enabled and return its result
+            #{self}.enabled?(
+              engine: 'optional - engine value consumed by #enabled?'
+            )
+
+            # Run split system and return its result
+            #{self}.split_system(
+              text: 'required - text value consumed by #split_system'
+            )
+
+            # Run anthropic system blocks and return its result
+            #{self}.anthropic_system_blocks(
+              text: 'required - text value consumed by #anthropic_system_blocks'
+            )
+
+            # Run openai messages and return its result
+            #{self}.openai_messages(
+              messages: 'required - Array messages value consumed by #openai_messages'
+            )
+
+            # Run gemini system instruction and return its result
+            #{self}.gemini_system_instruction(
+              text: 'required - text value consumed by #gemini_system_instruction'
+            )
+
+            # Run cache key and return its result
+            #{self}.cache_key(
+              key: 'optional - key value consumed by #cache_key',
+              text: 'optional - text value consumed by #cache_key'
+            )
+
+            # Run cache marks and return its result
+            #{self}.cache_marks(
+              blocks: 'optional - Array blocks value consumed by #cache_marks'
+            )
+
+            # Run supports and return its result
+            #{self}.supports
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
 
         private_class_method def self.first_dynamic_index(opts = {})

data/lib/pwn/ai/agent/reflect.rb

@@ -175,19 +175,23 @@ module PWN
 
         public_class_method def self.help
           puts "USAGE:
+            # Run on and return its result
             #{self}.on(
               request: 'required - String - What you want the AI to reflect on',
               system_role_content: 'optional - context to set up the model behavior for reflection',
-              engine: 'optional - override engine (Symbol) for teacher-student reflection; defaults to PWN::Env[:ai][:reflect_engine]',
+              engine: 'optional - override engine for THIS reflection only (Symbol/String); defaults to PWN::Env[:ai][:reflect_engine] || :active',
+              model: 'optional - override model on the reflection engine for THIS call only; defaults to PWN::Env[:ai][:reflect_model]',
               spinner: 'optional - Boolean - Display spinner during operation (default: false)',
-              suppress_pii_warning: 'optional - Boolean - Suppress PII Warnings (default: false)'
+              suppress_pii_warning: 'optional - Boolean - Suppress PII Warnings (default: false)',
+              timeout: 'optional - seconds to wait before giving up',
+              temp: 'optional - temp value consumed by #on',
+              quiet: 'optional - quiet value consumed by #on'
             )
 
-            Teacher-student config:
-              PWN::Env[:ai][:reflect_engine] = :anthropic   # execute on :active, critique on :anthropic
-
+            # Print the AUTHOR(S) string for this module.
             #{self}.authors
           "
+          constants.sort
         end
       end
     end

data/lib/pwn/ai/agent/registry.rb

@@ -347,18 +347,71 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::Registry.discover
-              PWN::AI::Agent::Registry.definitions(enabled: %w[terminal pwn])
-              PWN::AI::Agent::Registry.definitions(relevance: 'nmap sweep 10/8')  # slim (needs :tool_router)
-              PWN::AI::Agent::Registry.rank(query: 'run a shell command')
-              PWN::AI::Agent::Registry.lookup(name: 'shell')   # => Entry
-              PWN::AI::Agent::Registry.toolsets                # => ["memory","pwn","skills","terminal"]
-              PWN::AI::Agent::Registry.register(name:, toolset:, schema:, handler:)
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run register and return its result
+            #{self}.register(
+              name: 'required - tool name exposed to the model',
+              toolset: 'required - grouping for enable/disable (terminal, file, pwn, memory…)',
+              schema: 'required - OpenAI function schema {name:, description:, parameters:}',
+              handler: 'required - ->(args_hash) { ... } returning a JSON-serialisable object',
+              check: 'optional - -> { bool } gate; tool only advertised when truthy',
+              max_chars: 'optional - cap on serialised result (default 24_000)'
+            )
+
+            # Run lookup and return its result
+            #{self}.lookup(
+              name: 'required - registered tool name'
+            )
+
+            # Run all and return its result
+            #{self}.all
+
+            # Run toolsets and return its result
+            #{self}.toolsets
+
+            # Run definitions and return its result
+            #{self}.definitions(
+              enabled: 'optional - Array of toolset names to include; nil = all whose check passes',
+              relevance: 'optional - user request; when set AND :tool_router is enabled, slim to CORE + top-K keyword matches',
+              top_k: 'optional - keyword-ranked tools to keep beyond CORE (default 10)',
+              order: 'optional - preference list forwarded only when this key is present',
+              preference: 'optional - alias of :order; same key-present rule',
+              kind: 'optional - kind value consumed by #definitions',
+              intent: 'optional - intent value consumed by #definitions',
+              core_only: 'optional - core only value consumed by #definitions'
+            )
+
+            # Run preference order and return its result
+            #{self}.preference_order(
+              order: 'optional - Array of tool names; explicit nil/[] disables',
+              preference: 'optional - alias of :order. Explicit key disables Env/DEFAULT fallback'
+            )
+
+            # Run apply preference and return its result
+            #{self}.apply_preference(
+              items: 'required - Array of Entry objects or OpenAI tool hashes',
+              order: 'optional - forwarded to preference_order only when the key is set',
+              preference: 'optional - alias of :order; same key-present rule',
+              entries: 'optional - entries value consumed by #apply_preference'
+            )
+
+            # Run rank and return its result
+            #{self}.rank(
+              query: 'required - user request text',
+              entries: 'optional - Entry pool to rank (default .all)',
+              order: 'optional - preference list forwarded to preference_order',
+              preference: 'optional - preference value consumed by #rank'
+            )
+
+            # Run discover and return its result
+            #{self}.discover(
+              force: 'optional - re-require tool files even if already discovered (default false)'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

data/lib/pwn/ai/agent/result.rb

@@ -105,16 +105,25 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              safe = PWN::AI::Agent::Result.condition(
-                content: json_string,
-                entry: PWN::AI::Agent::Registry.lookup(name: 'shell')
-              )
-              safe = PWN::AI::Agent::Result.redact(content: string)
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run condition and return its result
+            #{self}.condition(
+              content: 'required - String returned by Dispatch.call',
+              entry: 'optional - Registry::Entry (used for max_chars; nil → DEFAULT_MAX)'
+            )
+
+            # Engine-aware default: ollama keeps history inside a tight num_ctx;
+            #{self}.default_max
+
+            # Run redact and return its result
+            #{self}.redact(
+              content: 'required - String to scrub of credential-shaped substrings'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

data/lib/pwn/ai/agent/reward.rb

@@ -1331,7 +1331,8 @@ module PWN
           req_toks = request.downcase.scan(/[a-z0-9_]{3,}/).uniq
           fin_toks = final.downcase.scan(/[a-z0-9_]{3,}/).uniq
           overlap  = req_toks.empty? ? 1.0 : (req_toks & fin_toks).length.to_f / req_toks.length
-          score = [score, 0.35].min if overlap < 0.08 && req_toks.length >= 4 && score > 0.35
+          long_analytical = final.length >= 800
+          score = [score, 0.35].min if overlap < 0.08 && req_toks.length >= 4 && score > 0.35 && !long_analytical
           ev_score = ev ? ev[:score].to_f : 0.0
           bad   = trace.count { |t| !semantic_ok(name: 'shell', raw: t.to_s)[:semantic_ok] }
           ratio = trace.empty? ? 0.5 : 1.0 - (bad.to_f / trace.length)
@@ -1729,37 +1730,154 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              # Tier 1 — reward signal
-              PWN::AI::Agent::Reward.judge(request: req, final: text, session_id: sid)     # R1 ORM → {score:, verdict:, rationale:}
-              PWN::AI::Agent::Reward.prm(request: req, session_id: sid)                    # R2 PRM → per-step credit
-              PWN::AI::Agent::Reward.plan_coverage(plan: tasks, final: text, session_id: sid) # soft plan-quality feature
-              PWN::AI::Agent::Reward.sentinel                                              # R3 reward-hacking detector
-              PWN::AI::Agent::Reward.reset_sentinel                                        # wipe corrupt window + distrust
-              PWN::AI::Agent::Reward.warm_sentinel                                         # P10 fill R3 window from Learning outcomes
-              PWN::AI::Agent::Reward.semantic_ok(name: 'shell', raw: json, args: args)     # R4 kills phantom exit≠0 mistakes
-
-              # Tier 5 — preference pairs → DPO
-              PWN::AI::Agent::Reward.record_preference(prompt: p, rejected: r, chosen: c, source: :user_correction)
-              PWN::AI::Agent::Reward.preferences(limit: 100)
-              PWN::AI::Agent::Reward.export_dpo(format: :dpo)                              # W1 → ~/.pwn/finetune/pwn-dpo-*.jsonl (≤40%/source, scrubbed)
-              PWN::AI::Agent::Reward.export_dpo(format: :dpo, balance: false)              # raw dump (diagnostics)
-              PWN::AI::Agent::Reward.scrub_preferences(dry_run: true)                      # P15 ledger hygiene report
-              PWN::AI::Agent::Reward.scrub_preferences                                      # P15 rewrite jsonl (backup first)
-              PWN::AI::Agent::Reward.preference_balance(scrub: true)                       # P15 geometry-aware mix
-
-              # Tier 6 — grounded reward
-              PWN::AI::Agent::Reward.verify_as_reward(final: text)                         # E3 browser-verified reward
-
-              Config (PWN::Env[:ai][:agent]):
-                :verify_as_reward   - Boolean/nil, ground finals via extro_verify (nil=auto)
-                :reward_llm         - Boolean/nil, force ORM/PRM LLM teacher (nil=on for remote engines)
-                :reward_model       - optional cheaper model id for ORM/PRM (nil=active engine default)
-                :reward_llm_timeout - seconds for cheap ORM chat (default 12, clamp 2..30)
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # R1 — LLM Outcome Reward Model
+            #{self}.judge(
+              request: 'required - original user request',
+              final: 'required - assistant final answer',
+              session_id: 'optional - PWN::Sessions id (adds tool trace)',
+              trace: 'optional - Array of tool-result strings (overrides session_id)',
+              commit: 'optional - write score into learning.jsonl / sentinel (default true)',
+              critic_pass: 'optional - critic pass value consumed by #judge',
+              predicted: 'optional - predicted value consumed by #judge',
+              proxy_ok: 'optional - proxy ok value consumed by #judge'
+            )
+
+            # Run promote to success and return its result
+            #{self}.promote_to_success?(
+              orm: 'optional - orm value consumed by #promote_to_success?',
+              verify: 'optional - verify value consumed by #promote_to_success?',
+              critic: 'optional - critic value consumed by #promote_to_success?'
+            )
+
+            # Run prm and return its result
+            #{self}.prm(
+              request: 'required - user goal',
+              session_id: 'optional - session to score in place',
+              trace: 'optional - Array of {name:, args:, result:} or Strings'
+            )
+
+            # Plan-quality soft signal (W3 feature / Learning tag)
+            #{self}.plan_coverage(
+              plan: 'required - Array of task strings or outline text',
+              final: 'required - assistant final answer',
+              request: 'optional - original user request',
+              trace: 'optional - Array of tool-result strings',
+              session_id: 'optional - load trace from session when trace empty'
+            )
+
+            # R3 — Reward-hacking sentinel
+            #{self}.sentinel
+
+            # P4 — scalar 0.0..1.0 haircut applied to Metrics success / Registry β when
+            #{self}.proxy_distrust
+
+            # Run set proxy distrust and return its result
+            #{self}.set_proxy_distrust(
+              gap: 'optional - gap value consumed by #set_proxy_distrust',
+              proxy: 'optional - scheme://proxy_host:port, or tor',
+              judge: 'optional - judge value consumed by #set_proxy_distrust'
+            )
+
+            # Run clear proxy distrust and return its result
+            #{self}.clear_proxy_distrust
+
+            # One-shot: wipe sentinel window + distrust after deploying the
+            #{self}.reset_sentinel
+
+            # P10 — backfill the R3 ring from Learning outcomes so offline/local
+            #{self}.warm_sentinel(
+              limit: 'optional - limit value consumed by #warm_sentinel'
+            )
+
+            # R4 — Structured tool-result classifier
+            #{self}.semantic_ok(
+              name: 'required - tool name',
+              raw: 'required - JSON string returned by Dispatch.call',
+              args: 'optional - the tool call arguments (used for BENIGN_EXIT)'
+            )
+
+            # 2.2 — coarse recoverable shape beside the fingerprint. Paths are
+            #{self}.recoverable_shape(
+              err: 'optional - err value consumed by #recoverable_shape',
+              stderr: 'optional - stderr value consumed by #recoverable_shape',
+              exit_code: 'optional - exit code value consumed by #recoverable_shape'
+            )
+
+            # E3 — verify-as-reward (ground truth without a human)
+            #{self}.verify_as_reward(
+              final: 'optional - final value consumed by #verify_as_reward'
+            )
+
+            # Run record preference and return its result
+            #{self}.record_preference(
+              prompt: 'required - prompt value consumed by #record_preference',
+              rejected: 'required - rejected value consumed by #record_preference',
+              chosen: 'required - chosen value consumed by #record_preference',
+              force: 'optional - force value consumed by #record_preference',
+              source: 'optional - source value consumed by #record_preference (defaults to :unknown))',
+              shape: 'optional - shape value consumed by #record_preference',
+              meta: 'optional - meta value consumed by #record_preference'
+            )
+
+            # Share of `source` among the newest WRITE_SOURCE_WINDOW prefs
+            #{self}.write_source_quota(
+              source: 'optional - source value consumed by #write_source_quota'
+            )
+
+            # P0 — online generator mix report + urgency flags. Controllers
+            #{self}.generator_mix(
+              limit: 'optional - limit value consumed by #generator_mix (defaults to WRITE_SOURCE_WINDOW)'
+            )
+
+            # P0 ops — infer trajectory shape for legacy ledger rows that predate
+            #{self}.infer_shape(
+              row: 'optional - row value consumed by #infer_shape'
+            )
+
+            # P15 — keep only usable preference pairs for balance/export/promote
+            #{self}.usable_preference?(
+              row: 'optional - row value consumed by #usable_preference?'
+            )
+
+            # P15 — one-shot ledger hygiene. Filters in place (rewrite jsonl) or
+            #{self}.scrub_preferences(
+              dry_run: 'optional - dry run value consumed by #scrub_preferences'
+            )
+
+            # P15/P5 — geometry-aware source mix. scrub:true uses usable_preference?
+            #{self}.preference_balance(
+              limit: 'optional - limit value consumed by #preference_balance (defaults to 10_000)',
+              scrub: 'optional - scrub value consumed by #preference_balance'
+            )
+
+            # Run preferences and return its result
+            #{self}.preferences(
+              limit: 'optional - limit value consumed by #preferences (defaults to 500)',
+              source: 'required - source value consumed by #preferences'
+            )
+
+            # Run export dpo and return its result
+            #{self}.export_dpo(
+              format: 'optional - format value consumed by #export_dpo (defaults to :dpo))',
+              out: 'optional - out value consumed by #export_dpo',
+              scrub: 'optional - scrub value consumed by #export_dpo',
+              balance: 'optional - balance value consumed by #export_dpo',
+              source_cap: 'optional - source cap value consumed by #export_dpo'
+            )
+
+            # Run reset and return its result
+            #{self}.reset
+
+            # Weight a judge sample for sentinel / Learning haircuts
+            #{self}.judge_sample_weight(
+              source: 'optional - source value consumed by #judge_sample_weight'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end