pwn 0.5.708 → 0.5.709

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

@@ -1808,42 +1808,171 @@ module PWN
         # Display Usage for this Module
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              state = PWN::AI::Agent::TaskSummarizer.fresh(request: 'ship task briefs to execs')
-              plan = PWN::AI::Agent::TaskSummarizer.plan(request: state[:request], state: state)
-              text = PWN::AI::Agent::TaskSummarizer.emit_plan!(state: state)
-              # → "Goal: ...\nTangible tasks (N) — each may use many tools:\n  task 1/N: ...\n  task 2/N: ..."
-              # UI: on_tool.call('task', text, '')  # full text, no truncation
-              # One task brief for a whole tool collection (one-to-many):
-              pre = PWN::AI::Agent::TaskSummarizer.about_to(
-                tools: [{ name: 'shell' }, { name: 'pwn_eval' }],
-                state: state
-              )
-              # → "task k/N: <english> — via shell, pwn_eval (search+eval-ruby)"
-              ctx = PWN::AI::Agent::TaskSummarizer.plan_context(state: state)
-              focus = PWN::AI::Agent::TaskSummarizer.active_task_prompt(state: state)
-              # then real tools print on their own lines; record! stays silent by default
-              PWN::AI::Agent::TaskSummarizer.record!(
-                state: state,
-                name: 'shell',
-                args: 'ls',
-                result: '{success:true}'
-              )
-              line = PWN::AI::Agent::TaskSummarizer.flush!(state: state)  # optional closing brief
-              PWN::AI::Agent::TaskSummarizer.enabled?
-              PWN::AI::Agent::TaskSummarizer.verbose?
-              PWN::AI::Agent::TaskSummarizer.llm_plan_enabled?
-              PWN::AI::Agent::TaskSummarizer.unify_plan!(state: state, outline: plan_text)
-              PWN::AI::Agent::TaskSummarizer.tool_jargon_task?(item: '`shell`')
-              PWN::AI::Agent::TaskSummarizer.relevance_query(state: state, request: state[:request])
-              PWN::AI::Agent::TaskSummarizer.apply_prm_advancement!(state: state, rewards: [1, 1], intents: ['search'])
-              PWN::AI::Agent::TaskSummarizer.parse_outline_tasks(outline: plan_text)
-              PWN::AI::Agent::TaskSummarizer.every_n
-              PWN::AI::Agent::TaskSummarizer.interval_s
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run enabled and return its result
+            #{self}.enabled?
+
+            # Run verbose and return its result
+            #{self}.verbose?
+
+            # LLM plan generation is on by default. Set
+            #{self}.llm_plan_enabled?
+
+            # Run every n and return its result
+            #{self}.every_n
+
+            # Run interval s and return its result
+            #{self}.interval_s
+
+            # Per-run state (also safe for nested/swarm if callers keep their own hash)
+            #{self}.fresh(
+              request: 'optional - original user goal string'
+            )
+
+            # Every request gets a task compass. There is no request type
+            #{self}.needs_task_breakdown?
+
+            # Request → ordered tangible tasks (each may map to many tools)
+            #{self}.plan(
+              request: 'required - user goal string',
+              state: 'optional - fresh() hash to mutate',
+              tasks: 'optional - Array injected plan array (tests)',
+              llm_tasks: 'optional - injected LLM task array (tests)'
+            )
+
+            # Format the full plan as the task-summary body (shown in entirety)
+            #{self}.format_plan(
+              tasks: 'required - Array of task strings',
+              request: 'optional - goal string'
+            )
+
+            # Run emit plan and return its result
+            #{self}.emit_plan!(
+              state: 'required - state value consumed by #emit_plan!',
+              request: 'required - request value consumed by #emit_plan!'
+            )
+
+            # Prefer Reflect when module_reflection is on (teacher engine / gated)
+            #{self}.chat_for_plan(
+              request: 'required - user goal to decompose'
+            )
+
+            # Parse JSON array, fenced JSON, or numbered/bulleted plain text
+            #{self}.parse_llm_tasks(
+              raw: 'required - raw LLM response text'
+            )
+
+            # Thin offline fallback when the LLM is disabled or unavailable
+            #{self}.fallback_decompose(
+              goal: 'required - user goal string'
+            )
+
+            # Back-compat alias used by older call sites / specs
+            #{self}.heuristic_decompose(
+              goal: 'required - user goal string'
+            )
+
+            # High-level brief for a collection of impending tool calls
+            #{self}.about_to(
+              tools: 'optional - array of {name:, args:} or bare names',
+              name: 'optional - single tool name (legacy one-tool path)',
+              args: 'optional - single tool args (ignored for brief content)',
+              request: 'optional - goal text',
+              state: 'optional - fresh() hash'
+            )
+
+            # Active plain-English plan item (and index/n) for Loop / model steering
+            #{self}.active_task(
+              state: 'required - fresh() hash',
+              messages: 'optional - messages value consumed by #active_task'
+            )
+
+            # Remaining English work units that lack tool-result evidence
+            #{self}.unfinished_tasks(
+              state: 'required - fresh() hash',
+              messages: 'optional - Loop message array for extra coverage'
+            )
+
+            # True while a multi-step English plan still has uncovered work
+            #{self}.plan_open?(
+              state: 'required - fresh() hash',
+              messages: 'optional - Loop message array'
+            )
+
+            # Short block for engine messages: full plan + focus on active English task
+            #{self}.plan_context(
+              state: 'required - fresh() hash'
+            )
+
+            # Build a Registry/tool-router relevance string from English tasks
+            #{self}.relevance_query(
+              state: 'optional - fresh() hash',
+              request: 'optional - original user goal fallback'
+            )
+
+            # Inject / refresh the active-task focus into Loop messages when plan_idx changes
+            #{self}.active_task_prompt(
+              state: 'required - fresh() hash',
+              force: 'optional - Boolean re-emit even if idx unchanged',
+              messages: 'optional - messages value consumed by #active_task_prompt',
+              request: 'optional - request value consumed by #active_task_prompt'
+            )
+
+            # Pull the operators original ask out of curriculum / critic / GOAL+PLAN
+            #{self}.canonical_request(
+              request: 'required - raw user or wrapper string'
+            )
+
+            # True when a candidate plan item is tool jargon (e.g. `shell`,
+            #{self}.tool_jargon_task?(
+              item: 'required - candidate task string'
+            )
+
+            # Parse a plan_first / red_team surviving outline into tangible tasks
+            #{self}.parse_outline_tasks(
+              outline: 'required - free-text plan outline'
+            )
+
+            # After S4 red_team / plan_first: optionally rewrite ts_state[:plan]
+            #{self}.unify_plan!(
+              state: 'required - fresh() hash',
+              outline: 'required - plan_first text and/or red_team hint',
+              source: 'optional - :plan_first|:red_team|:merged (default :merged)'
+            )
+
+            # Advance or hold plan_idx from an R2 step batch
+            #{self}.apply_prm_advancement!(
+              state: 'required - fresh() hash',
+              rewards: 'required - Array of -1|0|1 (batch order)',
+              intents: 'optional - Array of intent verb strings for the batch',
+              names: 'optional - Array tool names in the batch',
+              result: 'optional - latest tool result string',
+              mistake: 'optional - truthy when a mistake fingerprint hit this batch'
+            )
+
+            # Record a completed tool. Does NOT emit task lines with results
+            #{self}.record!(
+              state: 'required - fresh() hash',
+              name: 'required - tool name',
+              args: 'optional - tool args',
+              result: 'optional - tool result string'
+            )
+
+            # Optional progress / done line (verbose or flush). Still plain English;
+            #{self}.emit!(
+              state: 'required - fresh() hash',
+              final: 'optional - Boolean closing brief (default: false)'
+            )
+
+            # Run flush and return its result
+            #{self}.flush!(
+              state: 'required - fresh() hash'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

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

@@ -357,12 +357,111 @@ module PWN
         end
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              PWN::AI::Agent::ToolGuard.placeholder?(text: '...')
-              PWN::AI::Agent::ToolGuard.coerce_args(args: { value: 'id' }, required: %w[command])
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run present and return its result
+            #{self}.present?(
+              value: 'required - integer or string to pack/encode'
+            )
+
+            # Run placeholder and return its result
+            #{self}.placeholder?(
+              text: 'optional - text value consumed by #placeholder?'
+            )
+
+            # Run bashism and return its result
+            #{self}.bashism?(
+              text: 'optional - text value consumed by #bashism?'
+            )
+
+            # Run shell bash and return its result
+            #{self}.shell_bash?
+
+            # Run shell name and return its result
+            #{self}.shell_name
+
+            # Run protect http and return its result
+            #{self}.protect_http!
+
+            # Run protect core constants and return its result
+            #{self}.protect_core_constants!
+
+            # Coerce common wrong keys onto the first required schema field
+            #{self}.coerce_args(
+              args: 'optional - args value consumed by #coerce_args',
+              required: 'optional - Array required value consumed by #coerce_args'
+            )
+
+            # Run invalid payload and return its result
+            #{self}.invalid_payload(
+              hint: 'optional - hint value consumed by #invalid_payload',
+              shell: 'optional - shell value consumed by #invalid_payload (defaults to shell_name)'
+            )
+
+            # Run host load and return its result
+            #{self}.host_load
+
+            # Conservative wall-clock seconds for shell / pwn_eval
+            #{self}.deadline_s(
+              kind: 'optional - kind value consumed by #deadline_s',
+              timeout: 'optional - seconds to wait before giving up (defaults to opts[:timeout_s])',
+              timeout_s: 'optional - timeout s value consumed by #deadline_s'
+            )
+
+            # Run reset timeout budget and return its result
+            #{self}.reset_timeout_budget
+
+            # Run reset timeout budget and return its result
+            #{self}.reset_timeout_budget!
+
+            # Run mutation count and return its result
+            #{self}.mutation_count
+
+            # Run payload spent and return its result
+            #{self}.payload_spent
+
+            # Run note timeout and return its result
+            #{self}.note_timeout!(
+              timeout: 'optional - seconds to wait before giving up'
+            )
+
+            # Run next timeout and return its result
+            #{self}.next_timeout(
+              timeout: 'optional - seconds to wait before giving up',
+              spent: 'optional - spent value consumed by #next_timeout'
+            )
+
+            # Timeout policy (loop-law, not a skill):
+            #{self}.timeout_lesson(
+              tool: 'required - tool value consumed by #timeout_lesson',
+              timeout: 'required - seconds to wait before giving up'
+            )
+
+            # Run timeout result and return its result
+            #{self}.timeout_result(
+              timeout: 'required - seconds to wait before giving up',
+              tool: 'optional - tool value consumed by #timeout_result',
+              payload: 'optional - payload value consumed by #timeout_result',
+              task: 'optional - task value consumed by #timeout_result',
+              stdout: 'optional - stdout value consumed by #timeout_result',
+              stderr: 'optional - stderr value consumed by #timeout_result',
+              shell: 'required - shell value consumed by #timeout_result (defaults to shell_name)'
+            )
+
+            # Run timeout prior count and return its result
+            #{self}.timeout_prior_count(
+              tool: 'optional - tool value consumed by #timeout_prior_count'
+            )
+
+            # Run refuse copied persist and return its result
+            #{self}.refuse_copied_persist?(
+              name: 'optional - binary or identifier name',
+              args: 'optional - args value consumed by #refuse_copied_persist?'
+            )
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
       end
     end

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

@@ -41,13 +41,16 @@ module PWN
 
         public_class_method def self.help
           puts "USAGE:
-            ai_analysis = PWN::AI::Agent::TransparentBrowser.analyze(
+            # Run analyze and return its result
+            #{self}.analyze(
               request: 'required - current step in the JavaScript debugging session to analyze',
               source_to_review: 'required - the block of JavaScript code in which the current step resides'
             )
 
+            # Print the AUTHOR(S) string for this module.
             #{self}.authors
           "
+          constants.sort
         end
       end
     end

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

@@ -180,27 +180,47 @@ module PWN
         end
 
         public_class_method def self.help
-          puts <<~USAGE
-            USAGE:
-              # Called from Learning.auto_introspect when Loop.run is on the
-              # stack. You almost never invoke this directly.
-              PWN::AI::Agent::TurnFinalizer.defer(
-                session_id: sid,
-                request: req,
-                final: text,
-                plan: plan,
-                ts_state: ts
-              )
-
-              # Specs / cron that need the learner to finish before assert:
-              PWN::AI::Agent::TurnFinalizer.join_all!(timeout: 15)
-
-              Toggle via PWN::Env[:ai][:agent][:defer_introspect]
-                true  (default) — Hermes split: learn after the reply
-                false           — legacy inline auto_introspect
-
-              #{self}.authors
-          USAGE
+          puts "USAGE:
+            # Run enter user path and return its result
+            #{self}.enter_user_path!
+
+            # Run leave user path and return its result
+            #{self}.leave_user_path!
+
+            # Run user path and return its result
+            #{self}.user_path?
+
+            # Run should defer and return its result
+            #{self}.should_defer?
+
+            # Run defer and return its result
+            #{self}.defer(
+              session_id: 'required - PWN::Sessions id',
+              request: 'optional - original user request',
+              final: 'optional - user-visible final answer',
+              predicted: 'optional - W3 predicted score',
+              plan: 'optional - tangible-task plan',
+              ts_state: 'optional - TaskSummarizer state'
+            )
+
+            # Run finalize and return its result
+            #{self}.finalize(
+              session_id: 'optional - request:, final:, predicted:, plan:, ts_state:',
+              should: 'optional - should value consumed by #finalize'
+            )
+
+            # Run join all and return its result
+            #{self}.join_all!(
+              timeout: 'optional - seconds to wait before giving up'
+            )
+
+            # Run pending and return its result
+            #{self}.pending
+
+            # Print the AUTHOR(S) string for this module.
+            #{self}.authors
+          "
+          constants.sort
         end
 
         private_class_method def self.track(opts = {})

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

@@ -89,14 +89,17 @@ module PWN
 
         public_class_method def self.help
           puts "USAGE:
-            ai_analysis = #{self}.analyze(
-              request: 'required - high level description of vulnerability discovered (e.g. \"Discovered a SQLi vulnerability in /login\"',
+            # Run analyze and return its result
+            #{self}.analyze(
+              request: 'required - high level description of vulnerability discovered (e.g. Discovered a SQLi vulnerability in /login',
               markup_type: 'optional - specify the type of markup to generate :jira|:markdown|:html|:confluence|:xml (default: :jira)',
-              output_path: 'optional - full path to save the generated report as .md (e.g. /home/claw/reports/sqli-finding.md)'
+              output_path: 'optional - path to save the generated markdown report'
             )
 
+            # Print the AUTHOR(S) string for this module.
             #{self}.authors
           "
+          constants.sort
         end
       end
     end

data/lib/pwn/ai/agent.rb

@@ -47,6 +47,10 @@ module PWN
       end
 
       public_class_method def self.help
+        puts "USAGE:
+          # Display a List of Every PWN::AI Module
+          #{self}.authors
+        "
         constants.sort
       end
     end

data/lib/pwn/ai/anthropic.rb

@@ -862,25 +862,59 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          models = #{self}.get_models
+          # Run refresh oauth bearer token and return its result
+          #{self}.refresh_oauth_bearer_token(
+            refresh_token: 'required - Anthropic OAuth refresh_token',
+            client_id: 'optional - defaults to Claude Code public client',
+            token_uri: 'optional - defaults to platform.claude.com token endpoint',
+            bearer_token: 'optional - bearer token value consumed by #refresh_oauth_bearer_token',
+            expires_at: 'optional - expires at value consumed by #refresh_oauth_bearer_token'
+          )
+
+          # Run obtain oauth bearer token and return its result
+          #{self}.obtain_oauth_bearer_token(
+            client_id: 'optional - Claude Code public client id',
+            scope: 'optional - space-delimited scopes',
+            redirect_uri: 'optional - must match registered callback',
+            authorize_uri: 'optional - claude.ai authorize endpoint',
+            token_uri: 'optional - platform.claude.com token endpoint',
+            bearer_token: 'optional - bearer token value consumed by #obtain_oauth_bearer_token',
+            refresh_token: 'optional - refresh token value consumed by #obtain_oauth_bearer_token',
+            expires_at: 'optional - expires at value consumed by #obtain_oauth_bearer_token'
+          )
 
-          # One-time Claude Pro/Max OAuth enrollment (PKCE paste flow):
-          bearer = #{self}.obtain_oauth_bearer_token
-          # Subsequent runs silently refresh via ai.anthropic.oauth.refresh_token
+          # Run get models and return its result
+          #{self}.get_models
+
+          # Native tool-calling adapter for PWN::AI::Agent::Loop
+          #{self}.chat_with_tools(
+            assistant_message: 'optional - <same hash> }',
+            messages: 'required - OpenAI-format messages array (system/user/assistant/tool)',
+            tools: 'optional - OpenAI tools array [{type:function, function:{...}}]',
+            tool_choice: 'optional - auto | none | required | {type:function, function:{name:..}}',
+            model: 'optional - overrides PWN::Env[:ai][:anthropic][:model]',
+            temp: 'optional - temperature (defaults to PWN::Env[:ai][:anthropic][:temp] || 1)',
+            max_tokens: 'optional - defaults to PWN::Env[:ai][:anthropic][:max_tokens] || 128_000',
+            timeout: 'optional - seconds (default 900)',
+            spinner: 'optional - display spinner (default false)'
+          )
 
-          response = #{self}.chat(
+          # Run chat and return its result
+          #{self}.chat(
             request: 'required - message to Anthropic',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:anthropic][:model])',
             temp: 'optional - creative response float (defaults to PWN::Env[:ai][:anthropic][:temp])',
             system_role_content: 'optional - context to set up the model behavior for conversation (Default: PWN::Env[:ai][:anthropic][:system_role_content])',
             response_history: 'optional - pass response back in to have a conversation',
-            speak_answer: 'optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
-            timeout: 'optional - timeout in seconds (defaults to 900)',
+            speak_answer: 'optional - optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
+            timeout: 'optional - optional timeout in seconds (defaults to 900)',
             spinner: 'optional - display spinner (defaults to false)'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/ai/gemini.rb

@@ -454,28 +454,38 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          models = #{self}.get_models
+          # Run get models and return its result
+          #{self}.get_models
+
+          # Native tool-calling adapter for PWN::AI::Agent::Loop
+          #{self}.chat_with_tools(
+            assistant_message: 'optional - <same hash> }',
+            messages: 'required - OpenAI-format messages array (system/user/assistant/tool)',
+            tools: 'optional - OpenAI tools array [{type:function, function:{...}}]',
+            tool_choice: 'optional - auto | none | required | {type:function, function:{name:..}}',
+            model: 'optional - overrides PWN::Env[:ai][:gemini][:model]',
+            temp: 'optional - temperature (defaults to PWN::Env[:ai][:gemini][:temp] || 1)',
+            max_tokens: 'optional - maxOutputTokens (defaults to 8192)',
+            timeout: 'optional - seconds (default 900)',
+            spinner: 'optional - display spinner (default false)'
+          )
 
-          response = #{self}.chat(
+          # Run chat and return its result
+          #{self}.chat(
             request: 'required - message to Gemini',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:gemini][:model])',
             temp: 'optional - creative response float (defaults to PWN::Env[:ai][:gemini][:temp])',
             system_role_content: 'optional - context to set up the model behavior for conversation (Default: PWN::Env[:ai][:gemini][:system_role_content])',
             response_history: 'optional - pass response back in to have a conversation',
-            speak_answer: 'optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
-            timeout: 'optional - timeout in seconds (defaults to 900)',
+            speak_answer: 'optional - optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
+            timeout: 'optional - optional timeout in seconds (defaults to 900)',
             spinner: 'optional - display spinner (defaults to false)'
           )
 
-          response = #{self}.chat_with_tools(
-            messages: 'required - OpenAI-format messages array',
-            tools: 'optional - OpenAI tools array',
-            tool_choice: 'optional - auto | none | required | {function:{name:..}}',
-            model: 'optional - overrides PWN::Env[:ai][:gemini][:model]'
-          )
-
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/ai/grok.rb

@@ -705,21 +705,59 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          models = #{self}.get_models
+          # Run refresh oauth bearer token and return its result
+          #{self}.refresh_oauth_bearer_token(
+            refresh_token: 'required - xAI OAuth refresh_token',
+            client_id: 'optional - defaults to public Grok-CLI client',
+            token_uri: 'optional - defaults to https://auth.x.ai/oauth2/token',
+            bearer_token: 'optional - bearer token value consumed by #refresh_oauth_bearer_token',
+            expires_at: 'optional - expires at value consumed by #refresh_oauth_bearer_token'
+          )
+
+          # Run obtain oauth bearer token and return its result
+          #{self}.obtain_oauth_bearer_token(
+            client_id: 'optional - xAI OAuth Client ID (defaults to public Grok-CLI client)',
+            scope: 'optional - space-delimited scopes (defaults to XAI_OAUTH_SCOPE)',
+            timeout: 'optional - seconds to wait for user consent (default 300)',
+            api: 'optional - access at consent time.',
+            token_uri: 'optional - token uri value consumed by #obtain_oauth_bearer_token',
+            bearer_token: 'optional - bearer token value consumed by #obtain_oauth_bearer_token',
+            refresh_token: 'optional - refresh token value consumed by #obtain_oauth_bearer_token',
+            expires_at: 'optional - expires at value consumed by #obtain_oauth_bearer_token'
+          )
+
+          # Run get models and return its result
+          #{self}.get_models
+
+          # Run chat with tools and return its result
+          #{self}.chat_with_tools(
+            messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
+            tools: 'optional - OpenAI tools array [{type:function, function:{...}}]',
+            tool_choice: 'optional - auto | none | required | {type:function, function:{name:..}}',
+            model: 'optional - overrides PWN::Env[:ai][:grok][:model]',
+            temp: 'optional - temperature (defaults to PWN::Env[:ai][:grok][:temp] || 1)',
+            timeout: 'optional - seconds (default 180)',
+            spinner: 'optional - display spinner (default false)',
+            quiet: 'optional - quiet value consumed by #chat_with_tools'
+          )
 
-          response = #{self}.chat(
+          # Run chat and return its result
+          #{self}.chat(
             request: 'required - message to Grok',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:grok][:model])',
-            temp: 'optional - creative response float (defaults to PWN::Env[:ai][:grok][:temp])',
+            temp: 'optional - creative response float (deafults to PWN::Env[:ai][:grok][:temp])',
             system_role_content: 'optional - context to set up the model behavior for conversation (Default: PWN::Env[:ai][:grok][:system_role_content])',
             response_history: 'optional - pass response back in to have a conversation',
-            speak_answer: 'optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
-            timeout: 'optional - timeout in seconds (defaults to 900)'.
-            spinner: 'optional - display spinner (defaults to false)'
+            speak_answer: 'optional - optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',
+            timeout: 'optional - optional timeout in seconds (defaults to 900)',
+            spinner: 'optional - display spinner (defaults to false)',
+            quiet: 'optional - quiet value consumed by #chat'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end