pwn 0.5.708 → 0.5.710

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

@@ -1771,31 +1771,148 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::Learning.note_outcome(task: 'nmap sweep 10.0.0.0/24', success: true, details: '12 hosts up')
-              PWN::AI::Agent::Learning.outcomes(limit: 20, success: false)
-              PWN::AI::Agent::Learning.reflect(session_id: sid)              # LLM or heuristic → PWN::Memory
-              PWN::AI::Agent::Learning.auto_introspect(session_id: sid, request: req, final: text)
-              PWN::AI::Agent::Learning.distill_skill(name: 'quick_recon', session_id: sid)
-              PWN::AI::Agent::Learning.exemplars_for(request: 'nmap sweep 10/8')  # few-shot for Loop.run
-              PWN::AI::Agent::Learning.export_finetune(format: :sharegpt)        # -> ~/.pwn/finetune/*.jsonl
-              PWN::AI::Agent::Learning.consolidate(max_entries: 200)         # M1 semantic-merge + M3 importance-evict
-              PWN::AI::Agent::Learning.lean!                                 # memory + learning.jsonl prune
-              PWN::AI::Agent::Learning.gc_stores!                            # full ~/.pwn RL lean (mem/learn/mistakes/sessions)
-              PWN::AI::Agent::Learning.prune_outcomes!                       # learning.jsonl gold-keep cap
-              PWN::AI::Agent::Learning.purge_noise                            # one-shot GC of pre-R1 garbage lessons
-              PWN::AI::Agent::Learning.to_context(limit: 5)                  # injected by PromptBuilder
-              PWN::AI::Agent::Learning.stats
-              PWN::AI::Agent::Learning.reset
-
-              Enable end-of-run auto-learning with:
-                PWN::Env[:ai][:agent][:auto_introspect] = true
-              # auto_introspect throttles gc_stores! every PRUNE_EVERY_N_APPENDS
-              # outcomes so ~/.pwn stays lean without a manual GC turn.
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run note outcome and return its result
+            #{self}.note_outcome(
+              task: 'required - short description of what was attempted',
+              success: 'required - Boolean, did the attempt achieve its goal',
+              details: 'optional - free-form notes / error / evidence',
+              session_id: 'optional - PWN::Sessions id this outcome belongs to',
+              tags: 'optional - Array of String labels for later retrieval',
+              score: 'optional - score value consumed by #note_outcome',
+              judge_source: 'required - judge source value consumed by #note_outcome',
+              predicted: 'optional - predicted value consumed by #note_outcome',
+              confidence: 'optional - confidence value consumed by #note_outcome',
+              engine: 'optional - engine value consumed by #note_outcome'
+            )
+
+            # Run outcomes and return its result
+            #{self}.outcomes(
+              limit: 'optional - max entries returned newest-first (default 50)',
+              success: 'optional - filter by Boolean outcome',
+              tag: 'optional - filter by tag substring'
+            )
+
+            # Run stats and return its result
+            #{self}.stats
+
+            # Run to context and return its result
+            #{self}.to_context(
+              limit: 'optional - number of recent outcomes to surface (default 5)'
+            )
+
+            # Run exemplars for and return its result
+            #{self}.exemplars_for(
+              request: 'required - current user request',
+              limit: 'optional - max exemplar traces to return (default 1)',
+              max_msgs: 'optional - cap on messages per exemplar (default 6)'
+            )
+
+            # Run export finetune and return its result
+            #{self}.export_finetune(
+              format: 'optional - format value consumed by #export_finetune (defaults to :sharegpt))',
+              min_tools: 'optional - min tools value consumed by #export_finetune',
+              min_score: 'optional - min score value consumed by #export_finetune',
+              compress: 'optional - compress value consumed by #export_finetune',
+              out: 'optional - out value consumed by #export_finetune'
+            )
+
+            # Run distill skill and return its result
+            #{self}.distill_skill(
+              name: 'required - snake_case name for the new skill',
+              session_id: 'optional - PWN::Sessions id to mine (uses its transcript)',
+              content: 'optional - explicit markdown body; overrides transcript mining',
+              references: 'optional - Array of reference URLs / CWE / CVE / ATT&CK ids',
+              description: 'optional - description value consumed by #distill_skill'
+            )
+
+            # Fold RL artefacts (mistakes / structured_fix / an explicit lesson)
+            #{self}.update_skill(
+              dry_run: 'optional - dry run value consumed by #update_skill',
+              lesson: 'optional - lesson value consumed by #update_skill',
+              signature: 'optional - signature value consumed by #update_skill',
+              request: 'optional - request value consumed by #update_skill (defaults to opts[:query])',
+              query: 'optional - search query string',
+              name: 'required - binary or identifier name'
+            )
+
+            # Run reflect and return its result
+            #{self}.reflect(
+              session_id: 'required - PWN::Sessions id to analyse',
+              dry_run: 'optional - when true, do not write to Memory/Skills (default false)'
+            )
+
+            # Called by Loop.run when PWN::Env[:ai][:agent][:auto_introspect] is
+            #{self}.auto_introspect(
+              session_id: 'required - id of the just-completed session',
+              request: 'optional - original user request (for outcome logging)',
+              final: 'optional - final assistant answer (for outcome logging)',
+              inline: 'optional - inline value consumed by #auto_introspect',
+              predicted: 'optional - predicted value consumed by #auto_introspect',
+              plan: 'optional - plan value consumed by #auto_introspect',
+              ts_state: 'optional - ts state value consumed by #auto_introspect'
+            )
+
+            # Run flip last outcome and return its result
+            #{self}.flip_last_outcome(
+              session_id: 'optional - session id value consumed by #flip_last_outcome',
+              reason: 'optional - reason value consumed by #flip_last_outcome'
+            )
+
+            # Run consolidate and return its result
+            #{self}.consolidate(
+              max_entries: 'optional - hard cap on PWN::Memory size (default MAX_MEMORY_ENTRIES)'
+            )
+
+            # Run reset and return its result
+            #{self}.reset
+
+            # One-shot / on-load repair: rewrite tags+details where verdict label
+            #{self}.reconcile_verdict_tags!(
+              dry_run: 'optional - dry run value consumed by #reconcile_verdict_tags!'
+            )
+
+            # Run prune outcomes and return its result
+            #{self}.prune_outcomes!(
+              dry_run: 'optional - Boolean (default false)',
+              max_rows: 'optional - hard cap (default MAX_OUTCOME_ROWS)',
+              retain_days: 'optional - age floor for low-value drop',
+              recent_days: 'optional - always keep newer than this',
+              details_max: 'optional - details max value consumed by #prune_outcomes!',
+              gold_min_score: 'optional - gold min score value consumed by #prune_outcomes!'
+            )
+
+            # Memory lean + outcome prune
+            #{self}.lean!(
+              dry_run: 'optional - dry run value consumed by #lean!',
+              max_entries: 'optional - max entries value consumed by #lean!',
+              max_rows: 'optional - max rows value consumed by #lean!',
+              retain_days: 'optional - retain days value consumed by #lean!',
+              recent_days: 'optional - recent days value consumed by #lean!',
+              details_max: 'optional - details max value consumed by #lean!',
+              gold_min_score: 'optional - gold min score value consumed by #lean!'
+            )
+
+            # One-shot lean across memory + learning + mistakes + sessions
+            #{self}.gc_stores!(
+              dry_run: 'optional - Boolean (default false)',
+              current_session_id: 'optional - never delete this sessions id',
+              max_entries: 'optional - Memory consolidate cap',
+              max_rows: 'optional - learning.jsonl cap',
+              retain_days: 'optional - outcome / session age floor',
+              recent_days: 'optional - recent days value consumed by #gc_stores!',
+              details_max: 'optional - details max value consumed by #gc_stores!',
+              gold_min_score: 'optional - gold min score value consumed by #gc_stores!',
+              max_files: 'optional - max files value consumed by #gc_stores!'
+            )
+
+            # One-shot GC of the pre-R1 garbage: drops every PWN::Memory entry
+            #{self}.purge_noise
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

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

@@ -3071,52 +3071,59 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              final = PWN::AI::Agent::Loop.run(
-                request: 'what does `id` return on this host?',
-                session_id: PWN::Sessions.create[:id],
-                enabled_toolsets: %w[terminal pwn memory skills],
-                on_tool: ->(name, args, result) { puts "→ \#{name}: \#{result[0,1_024]}" },
-                system_role_content: 'You are a helpful assistant that can call tools to answer questions.'
-              )
-              # Live task summaries (default ON): BEFORE each tool *collection*,
-              # on_tool('task', high_level_brief, '') — one-to-many with real tools.
-              # Task lines never carry a result payload (no result row in the TUI).
-              # so repl.rb prints name=task with arg_preview=summary. Also coalesce bursts into
-              # via on_tool only: [ ts → pwn-ai → task ] <brief> (no [pwn-ai/task] prefix)
-              # Toggle via PWN::Env[:ai][:agent]:
-              #   task_summary: true|false
-              #   task_summary_every: 5          # emit every N tools
-              #   task_summary_interval_s: 8.0   # or every N seconds
-              #   task_summary_verbose: false
-
-              Supported engines: #{ENGINE_MODS.keys.join(', ')}
-              Set PWN::Env[:ai][:active] to choose.
-
-              Intent routing (all engines; critical for ollama/openwebui):
-                how-to / usage questions → text-only explanation (no tools, no plan_first)
-                pure prior-turn recall ("what did I just say?") → answer_recall (no tools)
-                pure greeting / light smalltalk → answer_greeting (no tools, no weather echo)
-                live sweeps are host-work goals like any other — pwn-ai does not
-                decide authorization
-              Local-model scaffolding (PWN::Env[:ai][:agent]):
-                :plan_first          - Boolean, plan-then-act pre-pass (default: local engine :ollama/:openwebui)
-                :tool_router         - Boolean/nil, slim Registry.definitions (nil=auto on for ollama)
-                :escalation_persona  - Swarm persona name for frontier corrective hints when stuck
-                :critic              - S3 constitutional critic before every final (Boolean)
-                :red_team_plan       - S4 adversarial plan review after plan_first (Boolean)
-                :counterfactual      - S2 A/B branch on REPEAT_THRESHOLD → DPO pair (Boolean)
-                :hindsight           - C3 HER-relabel failures (Boolean, default true)
-                :policy              - R5 live tabular Q / REINFORCE (Boolean, default true; advisory only)
-                :verify_as_reward    - E3 ground every final via extro_verify (Boolean)
-
-              P28 autonomy: incomplete-final detector refuses mid-goal handoffs.
-              Loop.run keeps CORE_TOOLS until may_finalize? — there is no
-              iteration-budget abort.
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run debug on and return its result
+            #{self}.debug_on?(
+              debug: 'optional - debug value consumed by #debug_on?'
+            )
+
+            # True only when the ask needs a live host/file/browser effect. World-knowledge
+            #{self}.catalog_lookup?(
+              request: 'required - request value consumed by #catalog_lookup?'
+            )
+
+            # Run world knowledge and return its result
+            #{self}.world_knowledge?(
+              request: 'required - request value consumed by #world_knowledge?'
+            )
+
+            # Run needs host work and return its result
+            #{self}.needs_host_work?(
+              request: 'required - request value consumed by #needs_host_work?'
+            )
+
+            # Run ollama wire messages and return its result
+            #{self}.ollama_wire_messages(
+              messages: 'required - in-memory OpenAI-ish messages (may have String args)'
+            )
+
+            # Run openai wire messages and return its result
+            #{self}.openai_wire_messages(
+              messages: 'required - in-memory OpenAI-ish messages (may have Hash args / internal keys)'
+            )
+
+            # Run request intent and return its result
+            #{self}.request_intent(
+              request: 'optional - request value consumed by #request_intent'
+            )
+
+            # Run run and return its result
+            #{self}.run(
+              request: 'required - what the human typed',
+              session_id: 'optional - PWN::Sessions id (transcript is appended to it)',
+              enabled_toolsets: 'optional - subset of Registry.toolsets, or nil for all',
+              on_tool: 'optional - ->(name, args, result) callback for live UI',
+              system_role_content: 'optional - override default system prompt (built from session_id if not provided)',
+              debug: 'optional - debug value consumed by #run',
+              from: 'optional - sender account or address to bind as operator',
+              account: 'optional - operator account id to bind',
+              force_tools: 'optional - force tools value consumed by #run'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

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

@@ -651,29 +651,139 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::Metrics.record(name: 'shell', success: true, duration: 0.42, engine: :ollama)
-              PWN::AI::Agent::Metrics.summary(limit: 10, engine: :ollama)
-              PWN::AI::Agent::Metrics.to_context(limit: 8, engine: :ollama)   # injected by PromptBuilder
-              PWN::AI::Agent::Metrics.ucb(name: 'shell')                 # C1 exploration bonus
-              PWN::AI::Agent::Metrics.thompson(name: 'shell')            # C1 Beta(ok+1,fail+1) sample
-              PWN::AI::Agent::Metrics.advantage(name: 'shell')           # C1 local − global (P20 judge-blended)
-              PWN::AI::Agent::Metrics.record_judge(name: 'shell', score: 0.8) # P20 ORM→metrics
-              PWN::AI::Agent::Metrics.judge_rate(name: 'shell')         # P20 mean ORM
-              PWN::AI::Agent::Metrics.effective_rate(name: 'shell')     # P20 proxy⋈judge
-              PWN::AI::Agent::Metrics.changepoints(within_secs: 3600)    # E1 CUSUM regime changes
-              PWN::AI::Agent::Metrics.record_calibration(predicted: 0.8, actual: 1.0, brier: 0.04, engine: :ollama)
-              PWN::AI::Agent::Metrics.calibration(engine: :ollama)       # W3 Brier / overconfidence
-              PWN::AI::Agent::Metrics.scale_prediction(predicted: 0.87) # temperature-scale before Policy/UI
-              PWN::AI::Agent::Metrics.scoreboard                        # tool_ok vs task_ok vs judge_ok
-              PWN::AI::Agent::Metrics.health_line
-              PWN::AI::Agent::Metrics.reset
-              PWN::AI::Agent::Metrics.load
-              PWN::AI::Agent::Metrics.save(metrics: hash)
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run load and return its result
+            #{self}.load
+
+            # Run save and return its result
+            #{self}.save(
+              metrics: 'required - Hash returned by .load / mutated in place'
+            )
+
+            # Run record and return its result
+            #{self}.record(
+              name: 'required - tool name that was dispatched',
+              success: 'required - Boolean, did the handler complete without error',
+              duration: 'optional - Float seconds the dispatch took',
+              error: 'optional - String error message when success is false',
+              engine: 'optional - Symbol/String AI engine that chose this tool (segments telemetry)'
+            )
+
+            # Run summary and return its result
+            #{self}.summary(
+              limit: 'optional - cap number of tools returned (default 25)',
+              engine: 'optional - only that engine\\s sub-bucket (falls back to global when absent)'
+            )
+
+            # Run to context and return its result
+            #{self}.to_context(
+              limit: 'optional - cap number of tools included (default 8)',
+              engine: 'optional - restrict to one engine\\s telemetry'
+            )
+
+            # P4 helper — Registry.rank calls this so β·advantage is scaled down
+            #{self}.proxy_trust
+
+            # Run ucb and return its result
+            #{self}.ucb(
+              name: 'optional - binary or identifier name',
+              c: 'optional - c value consumed by #ucb'
+            )
+
+            # Run thompson and return its result
+            #{self}.thompson(
+              name: 'optional - binary or identifier name'
+            )
+
+            # Run advantage and return its result
+            #{self}.advantage(
+              name: 'optional - binary or identifier name'
+            )
+
+            # Run prm advantage and return its result
+            #{self}.prm_advantage(
+              name: 'optional - binary or identifier name'
+            )
+
+            # Run prm n and return its result
+            #{self}.prm_n(
+              name: 'optional - binary or identifier name'
+            )
+
+            # P18 — called by Reward.prm after session annotate so live routing
+            #{self}.record_step_reward(
+              name: 'required - binary or identifier name',
+              reward: 'optional - reward value consumed by #record_step_reward'
+            )
+
+            # P20 — fold ORM judge (0..1) into per-tool telemetry so UCB /
+            #{self}.record_judge(
+              name: 'required - binary or identifier name',
+              score: 'optional - score value consumed by #record_judge',
+              confidence: 'optional - confidence value consumed by #record_judge',
+              source: 'optional - source value consumed by #record_judge'
+            )
+
+            # P1 — mean judge confidence for a tool (nil when no samples)
+            #{self}.judge_confidence(
+              name: 'optional - binary or identifier name'
+            )
+
+            # Mean judge score for a tool (nil when no ORM samples yet)
+            #{self}.judge_rate(
+              name: 'optional - binary or identifier name'
+            )
+
+            # Blended success rate: when proxy_distrust > 0 and judge samples
+            #{self}.effective_rate(
+              name: 'optional - binary or identifier name'
+            )
+
+            # Run changepoints and return its result
+            #{self}.changepoints(
+              cause: 'optional - :env_drift and does NOT count toward [REPEATING].',
+              within_secs: 'optional - within secs value consumed by #changepoints'
+            )
+
+            # W3 — plan_first emits p(success); Loop.run calls this with the
+            #{self}.record_calibration(
+              engine: 'optional - engine value consumed by #record_calibration (defaults to :global))',
+              brier: 'optional - brier value consumed by #record_calibration',
+              predicted: 'optional - predicted value consumed by #record_calibration',
+              actual: 'optional - actual value consumed by #record_calibration'
+            )
+
+            # Run calibration and return its result
+            #{self}.calibration(
+              engine: 'required - engine value consumed by #calibration'
+            )
+
+            # Run calibration green and return its result
+            #{self}.calibration_green?(
+              engine: 'optional - engine value consumed by #calibration_green?'
+            )
+
+            # Run scale prediction and return its result
+            #{self}.scale_prediction(
+              predicted: 'optional - predicted value consumed by #scale_prediction',
+              engine: 'optional - engine value consumed by #scale_prediction'
+            )
+
+            # Run scoreboard and return its result
+            #{self}.scoreboard(
+              engine: 'optional - engine value consumed by #scoreboard'
+            )
+
+            # Run health line and return its result
+            #{self}.health_line
+
+            # Run reset and return its result
+            #{self}.reset
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

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

@@ -843,23 +843,132 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::Mistakes.record(tool: 'shell', error: 'nmpa: command not found', args: '{"command":"nmpa -sV"}')
-              PWN::AI::Agent::Mistakes.top(limit: 10, unresolved_only: true)
-              PWN::AI::Agent::Mistakes.find(signature: 'abc123def456')
-              PWN::AI::Agent::Mistakes.for_tool(tool: 'shell')
-              PWN::AI::Agent::Mistakes.resolve(signature: 'abc123def456', fix: 'binary is spelled `nmap`, not `nmpa`')
-              PWN::AI::Agent::Mistakes.correction_hint(tool: 'shell', error: err)  # inline self-correct
-              PWN::AI::Agent::Mistakes.to_context(limit: 6)                        # injected by PromptBuilder
-              PWN::AI::Agent::Mistakes.correction?(request: "no that's wrong")
-              PWN::AI::Agent::Mistakes.check_user_correction(request: req, session_id: sid)
-              PWN::AI::Agent::Mistakes.signature(tool: 'shell', error: err)
-              PWN::AI::Agent::Mistakes.operator_inbox(limit: 12)
-              PWN::AI::Agent::Mistakes.reset
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run load and return its result
+            #{self}.load
+
+            # Run save and return its result
+            #{self}.save(
+              store: 'optional - store value consumed by #save'
+            )
+
+            # Run signature and return its result
+            #{self}.signature(
+              tool: 'required - tool/component name that failed',
+              error: 'required - raw error text (will be normalised)'
+            )
+
+            # Run find and return its result
+            #{self}.find(
+              signature: 'optional - exact signature to fetch',
+              tool: 'optional - with error:, compute signature and fetch',
+              error: 'optional - raw error text (used with tool:)'
+            )
+
+            # Run for tool and return its result
+            #{self}.for_tool(
+              tool: 'required - tool name',
+              unresolved_only: 'optional - default false'
+            )
+
+            # Run record and return its result
+            #{self}.record(
+              tool: 'required - tool/component that produced the failure',
+              error: 'required - error text / message',
+              args: 'optional - args that triggered it (stored truncated as sample)',
+              session_id: 'optional - PWN::Sessions id',
+              source: 'optional - :tool | :user_correction | :loop | :model | :heuristic (default :tool)',
+              force: 'optional - force value consumed by #record',
+              meta: 'optional - meta value consumed by #record',
+              cause: 'optional - cause value consumed by #record (defaults to :self))',
+              shape: 'optional - shape value consumed by #record',
+              needs_code_change: 'optional - needs code change value consumed by #record'
+            )
+
+            # Run resolve and return its result
+            #{self}.resolve(
+              signature: 'required - mistake signature (from mistakes_list / .top)',
+              fix: 'required - what to do INSTEAD next time',
+              structured: 'optional - structured value consumed by #resolve',
+              clear_needs_code_change: 'optional - clear needs code change value consumed by #resolve'
+            )
+
+            # Run top and return its result
+            #{self}.top(
+              limit: 'optional - max rows (default 10)',
+              unresolved_only: 'optional - default true',
+              practiceable_only: 'optional - practiceable only value consumed by #top'
+            )
+
+            # Run extinguish and return its result
+            #{self}.extinguish!(
+              signature: 'optional - signature value consumed by #extinguish!',
+              shape: 'optional - shape value consumed by #extinguish!',
+              force: 'optional - force value consumed by #extinguish!'
+            )
+
+            # Auto-resolve parked items that already have a known extinguish recipe
+            #{self}.extinguish_parked!(
+              limit: 'optional - limit value consumed by #extinguish_parked!',
+              dry_run: 'optional - dry run value consumed by #extinguish_parked!'
+            )
+
+            # Run park and return its result
+            #{self}.park(
+              signature: 'required - signature value consumed by #park',
+              reason: 'optional - reason value consumed by #park'
+            )
+
+            # Operator inbox: parked / needs_code_change / needs_human scars that
+            #{self}.operator_inbox(
+              limit: 'optional - limit value consumed by #operator_inbox'
+            )
+
+            # Run to context and return its result
+            #{self}.to_context(
+              limit: 'optional - limit value consumed by #to_context (defaults to 6)',
+              request: 'optional - request value consumed by #to_context',
+              include_open: 'optional - include open value consumed by #to_context',
+              full: 'optional - full value consumed by #to_context'
+            )
+
+            # Run correction hint and return its result
+            #{self}.correction_hint(
+              tool: 'required - tool that just failed',
+              error: 'required - raw error it failed with'
+            )
+
+            # Run correction and return its result
+            #{self}.correction?(
+              request: 'optional - request value consumed by #correction?'
+            )
+
+            # Run check user correction and return its result
+            #{self}.check_user_correction(
+              request: 'required - the incoming user message',
+              session_id: 'optional - session to inspect for the previous answer'
+            )
+
+            # Run lean and return its result
+            #{self}.lean!(
+              dry_run: 'optional - Boolean (default false)',
+              max_resolved_kept: 'optional - cap on resolved-with-fix records',
+              resolved_min_age_days: 'optional - age before resolved count=1 may drop'
+            )
+
+            # Run reset and return its result
+            #{self}.reset
+
+            # Age-weighted count for [REPEATING] threshold — a ×8 signature from
+            #{self}.effective_count(
+              mistake: 'optional - mistake value consumed by #effective_count',
+              signature: 'optional - signature value consumed by #effective_count'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

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

@@ -67,15 +67,31 @@ module PWN
         end
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::OpenGoal.begin!(request: '...', session_id: '...')
-              PWN::AI::Agent::OpenGoal.current
-              PWN::AI::Agent::OpenGoal.resume?(request: 'continue')
-              PWN::AI::Agent::OpenGoal.clear!
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run goal file and return its result
+            #{self}.goal_file
+
+            # Run current and return its result
+            #{self}.current
+
+            # Run begin and return its result
+            #{self}.begin!(
+              request: 'required - request value consumed by #begin!',
+              session_id: 'optional - session id value consumed by #begin!'
+            )
+
+            # Run clear and return its result
+            #{self}.clear!
+
+            # Run resume and return its result
+            #{self}.resume?(
+              request: 'optional - request value consumed by #resume?'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end