html2rss 0.29.1 → 0.31.0

data/lib/html2rss/mcp/outcome.rb

@@ -13,24 +13,16 @@ module Html2rss
       NextStep = Data.define(:name, :guidance)
 
       ##
-      # Closed set of agent next actions. Invalid names cannot be constructed.
+      # Closed set of agent next actions. Names are owned by {Playbook::GUIDANCE}.
       class NextStep
-        # Wire names for +next_step+.
-        NAMES = %i[done inspect recon validate apply scrape capture read_runtime test].freeze
+        # Frozen name → instance table built from {Playbook::GUIDANCE}.
+        ALL = Playbook::GUIDANCE.to_h { |name, guidance| [name, new(name:, guidance:)] }.freeze
+        private_class_method :new
 
         ##
         # @param name [Symbol, String]
-        # @param guidance [String, nil]
-        def initialize(name:, guidance: nil)
-          step = name.to_sym
-          raise ArgumentError, "unknown next_step: #{name.inspect}" unless NAMES.include?(step)
-
-          super(name: step, guidance: (guidance || Playbook::GUIDANCE.fetch(step)).freeze)
-        end
-
-        class << self
-          NAMES.each { |step| define_method(step) { new(name: step) } }
-        end
+        # @return [NextStep]
+        def self.[](name) = ALL.fetch(name.to_sym) { raise ArgumentError, "unknown next_step: #{name.inspect}" }
       end
 
       ##
@@ -107,12 +99,13 @@ module Html2rss
         end
 
         ##
-        # @param errors [Hash, nil] schema errors; +nil+ means success
+        # @param report [Html2rss::Config::ValidationReport]
         # @return [Outcome]
-        def validate(errors:)
-          ok = errors.nil?
-          next_step = ok ? NextStep.test : NextStep.validate
-          new(ok:, next_step:, guidance: next_step.guidance, payload: ok ? {} : { errors: })
+        def validate(report:)
+          ok = report.success?
+          next_step = ok ? NextStep[:test] : NextStep[:validate]
+          payload = ok ? {} : { issues: report.issues.map(&:to_h) }
+          new(ok:, next_step:, guidance: next_step.guidance, payload:)
         end
 
         ##
@@ -131,17 +124,17 @@ module Html2rss
         ##
         # @param batch_result [Html2rss::Batch::BatchResult]
         # @return [Outcome]
-        def batch_scrape(batch_result) = batch(batch_result, NextStep.scrape)
+        def batch_scrape(batch_result) = batch(batch_result, NextStep[:scrape])
 
         ##
         # @param batch_result [Html2rss::Batch::BatchResult]
         # @return [Outcome]
-        def batch_inspect(batch_result) = batch(batch_result, NextStep.inspect)
+        def batch_inspect(batch_result) = batch(batch_result, NextStep[:inspect])
 
         ##
         # @param batch_result [Html2rss::Batch::BatchResult]
         # @return [Outcome]
-        def batch_recon(batch_result) = batch(batch_result, NextStep.recon)
+        def batch_recon(batch_result) = batch(batch_result, NextStep[:recon])
 
         ##
         # @param rss [String]
@@ -151,7 +144,7 @@ module Html2rss
         # @return [Outcome]
         def apply(rss:, item_count:, empty: item_count.zero?, quality_report: nil)
           ok = !empty
-          next_step = ok ? NextStep.done : NextStep.inspect
+          next_step = ok ? NextStep[:done] : NextStep[:inspect]
           payload = { rss:, item_count: }
           payload[:quality_report] = quality_report if quality_report
           new(ok:, next_step:, guidance: next_step.guidance, payload:)
@@ -169,15 +162,15 @@ module Html2rss
         private
 
         def batch(batch_result, failure_step)
-          step = batch_result.successful.positive? ? NextStep.done : failure_step
+          step = batch_result.successful.positive? ? NextStep[:done] : failure_step
           new(ok: true, next_step: step, guidance: step.guidance, payload: batch_result.to_h)
         end
 
         def scrape_next_step(empty, botasaurus_configured:)
-          return NextStep.done unless empty
-          return NextStep.read_runtime unless botasaurus_configured
+          return NextStep[:done] unless empty
+          return NextStep[:read_runtime] unless botasaurus_configured
 
-          NextStep.inspect
+          NextStep[:inspect]
         end
 
         def scrape_payload(items:, requested_strategy:, channel_title:, admission_drops:)
@@ -188,33 +181,33 @@ module Html2rss
         end
 
         def inspect_next_step(report)
-          return NextStep.recon if report.alternate_feeds?
-          return NextStep.capture if report.articles_count.positive?
+          return NextStep[:recon] if report.alternate_feeds?
+          return NextStep[:capture] if report.articles_count.positive?
 
-          NextStep.scrape
+          NextStep[:scrape]
         end
 
         def recon_next_step(result)
-          return NextStep.done if result.defer?
-          return NextStep.capture if result.build?
+          return NextStep[:done] if result.defer?
+          return NextStep[:capture] if result.build?
 
-          NextStep.scrape
+          NextStep[:scrape]
         end
 
         def capture_next_step(articles_count:, has_selectors:, native_feed: nil)
-          return NextStep.done if native_feed
+          return NextStep[:done] if native_feed
 
-          articles_count.positive? && has_selectors ? NextStep.test : NextStep.inspect
+          articles_count.positive? && has_selectors ? NextStep[:test] : NextStep[:inspect]
         end
 
         def test_next_step(test_result)
-          return NextStep.apply if test_result.success
+          return NextStep[:apply] if test_result.success
 
           kind = test_result.failure_kind
-          return NextStep.validate if kind&.schema?
-          return NextStep.capture if kind&.execution? || kind&.min_items? || kind&.quality?
+          return NextStep[:validate] if kind&.schema?
+          return NextStep[:capture] if kind&.execution? || kind&.min_items? || kind&.quality?
 
-          NextStep.capture
+          NextStep[:capture]
         end
 
         def test_guidance(test_result, next_step)
@@ -244,15 +237,15 @@ module Html2rss
 
         def next_step_for_error(error)
           case error
-          when RequestService::BotasaurusConfigurationError then NextStep.read_runtime
-          when Contract::UnpublishedRequestError then NextStep.validate
+          when RequestService::BotasaurusConfigurationError then NextStep[:read_runtime]
+          when Contract::UnpublishedRequestError then NextStep[:validate]
           when ArgumentError then argument_error_next_step(error)
-          else NextStep.inspect
+          else NextStep[:inspect]
           end
         end
 
         def argument_error_next_step(error)
-          XOR_ERROR.match?(error.message) ? NextStep.validate : NextStep.inspect
+          XOR_ERROR.match?(error.message) ? NextStep[:validate] : NextStep[:inspect]
         end
       end
     end

data/lib/html2rss/mcp/server/tools.rb

@@ -4,25 +4,37 @@ module Html2rss
   module MCP
     module Server
       ##
-      # MCP tool registration and outcome mapping over public html2rss APIs.
+      # MCP tool registry: typed {Tool} values over public html2rss APIs.
       module Tools # rubocop:disable Metrics/ModuleLength -- declarative registry + substantive handlers
-        # Declarative MCP tool registrations consumed by {register_all}.
+        Tool = Data.define(:name, :title, :description, :input_schema, :annotations, :call)
+
+        ##
+        # One published MCP tool. +call+ is a lambda with explicit keyword defaults.
+        # +annotations+ is {Contract::ANNOTATIONS_OPEN_WORLD} unless a tool overrides it.
+        class Tool # rubocop:disable Lint/EmptyClass -- Data members only; handlers are +call+ lambdas
+        end
+
+        # Published MCP tools consumed by {Server.register_tools}.
         TOOLS = [
-          {
+          Tool.new(
             name: 'scrape',
-            kind: :url,
+            title: 'Scrape',
             description: 'One-shot article extraction as JSON Feed items. ' \
                          'Use when you need articles now without a saved config. ' \
-                         'strategy "auto" triggers fallback chain (faraday → botasaurus) for JS-rendered sites.',
+                         'strategy "auto" triggers fallback chain (default → botasaurus) for JS-rendered sites.',
             input_schema: Contract::SCRAPE_INPUT_SCHEMA,
-            handler: :scrape_outcome
-          },
-          {
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |url:, strategy: 'auto', limit: 25, items_selector: nil, **|
+              scrape_outcome(url:, strategy:, limit:, items_selector:)
+            }
+          ),
+          Tool.new(
             name: 'inspect',
-            kind: :url,
+            title: 'Inspect',
             description: 'Diagnostic page analysis (scrapers, SST, segments, final URL, status, ' \
                          'rel=alternate feeds). Use recon for BUILD/DEFER/DROP verdict and native_feed preference.',
             input_schema: Contract::INSPECT_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |url:, strategy: 'auto', **|
               Outcome.inspect(
                 report: PageRecon::Diagnostics.call(
@@ -30,45 +42,60 @@ module Html2rss
                 )
               )
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'recon',
-            kind: :url,
+            title: 'Recon',
             description: 'Curation verdict and native_feed preference for a URL. ' \
                          'Use after inspect when alternates warrant deeper recon, or when you need BUILD/DEFER/DROP.',
             input_schema: Contract::RECON_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |url:, strategy: 'auto', **|
               Outcome.recon(result: Html2rss.recon(url, strategy: Runtime.coerce_strategy(strategy)))
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'batch_scrape',
-            kind: :batch,
-            batch_method: :batch_scrape,
-            limit_default: 10,
+            title: 'Batch scrape',
             description: 'Scrape multiple URLs in parallel with per-URL error isolation. ' \
                          'Returns structured JSON Feed items and extraction counts.',
-            input_schema: Contract::BATCH_SCRAPE_INPUT_SCHEMA
-          },
-          {
+            input_schema: Contract::BATCH_SCRAPE_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, limit: 10, **|
+              Outcome.batch_scrape(
+                Batch.batch_scrape(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:, limit:)
+              )
+            }
+          ),
+          Tool.new(
             name: 'batch_inspect',
-            kind: :batch,
-            batch_method: :batch_inspect,
+            title: 'Batch inspect',
             description: 'Inspect multiple URLs in parallel with per-URL error isolation. ' \
                          'Returns final redirected URLs, status codes, and rel="alternate" feeds.',
-            input_schema: Contract::BATCH_INSPECT_INPUT_SCHEMA
-          },
-          {
+            input_schema: Contract::BATCH_INSPECT_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, **|
+              Outcome.batch_inspect(
+                Batch.batch_inspect(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:)
+              )
+            }
+          ),
+          Tool.new(
             name: 'batch_recon',
-            kind: :batch,
-            batch_method: :batch_recon,
+            title: 'Batch recon',
             description: 'Run recon across multiple URLs in parallel with per-URL error isolation. ' \
                          'Returns verdict, native_feed, and surface classification per URL.',
-            input_schema: Contract::BATCH_RECON_INPUT_SCHEMA
-          },
-          {
+            input_schema: Contract::BATCH_RECON_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |urls:, strategy: 'auto', concurrency: Batch::DEFAULT_CONCURRENCY, **|
+              Outcome.batch_recon(
+                Batch.batch_recon(urls:, strategy: Runtime.coerce_strategy(strategy), concurrency:)
+              )
+            }
+          ),
+          Tool.new(
             name: 'capture',
-            kind: :capture,
+            title: 'Capture',
             description: 'Derive a reusable html2rss feed config from a URL. ' \
                          'Use when the goal is a durable YAML (then test → apply). ' \
                          'Returns YAML inside payload.yaml (same serializer as CLI capture). ' \
@@ -76,134 +103,65 @@ module Html2rss
                          'enhance defaults from admission evidence (false when chrome drops are high). ' \
                          'Full schema options live in resource html2rss://schema.',
             input_schema: Contract::CAPTURE_INPUT_SCHEMA,
-            handler: :capture_outcome
-          },
-          {
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |url:, strategy: 'auto', items_selector: nil, force: false, topics: nil, title: nil,
+                              summary: nil, enhance: nil, limit: nil, max_redirects: nil, max_requests: nil, **|
+              capture_outcome(url:, strategy:, items_selector:, force:, topics:, title:, summary:,
+                              enhance:, limit:, max_redirects:, max_requests:)
+            }
+          ),
+          Tool.new(
             name: 'validate',
-            kind: :config_xor,
+            title: 'Validate',
             description: 'Validate a feed config hash XOR yaml string against the html2rss JSON schema. ' \
-                         'Call before test. Failures return isError with payload.errors. ' \
+                         'Call before test. Failures return isError with payload.issues. ' \
                          'Full schema lives in resource html2rss://schema.',
             input_schema: Contract::CONFIG_XOR_SCHEMA,
             annotations: Contract::ANNOTATIONS_VALIDATE,
             call: lambda { |config: nil, yaml: nil, **|
-              validation = Html2rss::Config.validate(ConfigArgument.parse(config:, yaml:).config)
-              Outcome.validate(errors: validation.success? ? nil : validation.errors.to_h)
+              Outcome.validate(report: Html2rss::Config.validate(ConfigArgument.parse(config:, yaml:).config))
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'test',
-            kind: :config_xor,
+            title: 'Test',
             description: 'Validate schema and execute live extraction (asserting >= min_items items). ' \
                          'Call after capture or validate; on success next_step is apply. ' \
                          'Returns test summary in payload with sample items, timing, failure_kind, ' \
                          'and quality_report (warnings for duplicate URLs, junk titles, native feed). ' \
                          'Set strict_quality to fail on duplicate URLs, >50% junk titles, or short titles.',
             input_schema: Contract::TEST_INPUT_SCHEMA,
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
             call: lambda { |config: nil, yaml: nil, min_items: 1, strict_quality: false,
                               compare_enhance: false, **kwargs|
               feed_config = ConfigArgument.parse(config:, yaml:).config
               test_args = { min_items:, strict_quality:, compare_enhance: }
               test_args[:strategy] = Runtime.coerce_strategy(kwargs[:strategy]) if kwargs.key?(:strategy)
-              test_result = Html2rss.test(feed_config, **test_args)
-              Outcome.test(test_result)
+              Outcome.test(Html2rss.test(feed_config, **test_args))
             }
-          },
-          {
+          ),
+          Tool.new(
             name: 'apply',
-            kind: :config_xor,
+            title: 'Apply',
             description: 'Apply a validated feed config (hash XOR yaml) and return RSS XML in payload.rss. ' \
                          'isError when the feed has zero items (ship gate). payload.item_count is RSS item count. ' \
                          'Use after test succeeds.',
             input_schema: Contract::APPLY_INPUT_SCHEMA,
-            handler: :apply_outcome
-          }
+            annotations: Contract::ANNOTATIONS_OPEN_WORLD,
+            call: lambda { |url:, config: nil, yaml: nil, **|
+              apply_outcome(url:, config:, yaml:)
+            }
+          )
         ].freeze
 
-        class << self # rubocop:disable Metrics/ClassLength -- registration engine + handlers
+        class << self
           ##
-          # Registers all MCP tools on +server+ via +registrar+ (Server.define_envelope_tool).
-          #
-          # @param server [::MCP::Server]
-          # @param registrar [Proc]
-          # @return [void]
-          def register_all(server, registrar:)
-            TOOLS.each { |entry| register_tool(server, registrar, entry) }
-          end
-
-          private
-
-          def register_tool(server, registrar, entry)
-            case entry[:kind]
-            when :url then register_url_tool(server, registrar, entry)
-            when :batch then register_batch_tool(server, registrar, entry)
-            when :config_xor then register_config_xor_tool(server, registrar, entry)
-            when :capture then register_capture_tool(server, registrar, entry)
-            else raise ArgumentError, "unknown tool kind: #{entry[:kind].inspect}"
-            end
-          end
-
-          def register_url_tool(server, registrar, entry)
-            handler = entry[:handler] ? method(entry[:handler]) : entry[:call]
-            registrar.call(
-              server,
-              name: entry[:name],
-              description: entry[:description],
-              input_schema: entry[:input_schema],
-              annotations: entry.fetch(:annotations, Contract::ANNOTATIONS_OPEN_WORLD)
-            ) do |**kwargs|
-              handler.call(**tool_kwargs(kwargs))
-            end
-          end
-
-          def register_batch_tool(server, registrar, entry) # rubocop:disable Metrics/MethodLength
-            name = entry[:name]
-            batch_method = entry[:batch_method]
-            limit_default = entry[:limit_default]
-            registrar.call(
-              server,
-              name:,
-              description: entry[:description],
-              input_schema: entry[:input_schema]
-            ) do |urls:, strategy: 'auto', **kwargs|
-              concurrency = kwargs.fetch(:concurrency, Batch::DEFAULT_CONCURRENCY)
-              batch_args = { urls:, strategy: Runtime.coerce_strategy(strategy), concurrency: }
-              batch_args[:limit] = kwargs.fetch(:limit, limit_default) unless limit_default.nil?
-              Outcome.public_send(name, Batch.public_send(batch_method, **batch_args))
-            end
-          end
-
-          def register_config_xor_tool(server, registrar, entry)
-            handler = entry[:handler] ? method(entry[:handler]) : entry[:call]
-            registrar.call(
-              server,
-              name: entry[:name],
-              description: entry[:description],
-              input_schema: entry[:input_schema],
-              annotations: entry.fetch(:annotations, Contract::ANNOTATIONS_OPEN_WORLD)
-            ) do |**kwargs|
-              handler.call(**tool_kwargs(kwargs))
-            end
-          end
-
-          def register_capture_tool(server, registrar, entry)
-            handler = method(entry[:handler])
-            registrar.call(
-              server,
-              name: entry[:name],
-              description: entry[:description],
-              input_schema: entry[:input_schema]
-            ) do |**kwargs|
-              handler.call(**tool_kwargs(kwargs))
-            end
-          end
-
-          def tool_kwargs(inputs)
-            args = inputs.dup
-            args.delete(:server_context)
-            args
-          end
-
+          # @api private
+          # @param url [String]
+          # @param strategy [String, Symbol]
+          # @param limit [Integer]
+          # @param items_selector [String, nil]
+          # @return [Outcome]
           def scrape_outcome(url:, strategy: 'auto', limit: 25, items_selector: nil)
             wire = Batch.scrape_wire(url:, strategy: Runtime.coerce_strategy(strategy), limit:, items_selector:)
             Outcome.scrape(
@@ -215,6 +173,20 @@ module Html2rss
             )
           end
 
+          ##
+          # @api private
+          # @param url [String]
+          # @param strategy [String, Symbol]
+          # @param items_selector [String, nil]
+          # @param force [Boolean]
+          # @param topics [Array<String>, nil]
+          # @param title [String, nil]
+          # @param summary [String, nil]
+          # @param enhance [Boolean, nil]
+          # @param limit [Integer, nil]
+          # @param max_redirects [Integer, nil]
+          # @param max_requests [Integer, nil]
+          # @return [Outcome]
           def capture_outcome(url:, strategy: 'auto', items_selector: nil, force: false, topics: nil, title: nil, # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
                               summary: nil, enhance: nil, limit: nil, max_redirects: nil, max_requests: nil)
             plan = Runtime.coerce_strategy(strategy)
@@ -245,6 +217,12 @@ module Html2rss
             )
           end
 
+          ##
+          # @api private
+          # @param url [String]
+          # @param config [Hash, nil]
+          # @param yaml [String, nil]
+          # @return [Outcome]
           def apply_outcome(url:, config: nil, yaml: nil)
             feed_config = HashUtil.deep_dup(ConfigArgument.parse(config:, yaml:).config)
             feed_config[:channel] ||= {}
@@ -253,12 +231,14 @@ module Html2rss
             apply_feed_outcome(feed_config, feed_result, outcome)
           end
 
+          private
+
           def apply_feed_outcome(feed_config, feed_result, outcome) # rubocop:disable Metrics/MethodLength -- quality_report + RSS payload
             rss = feed_result.to_rss
             quality_report = Html2rss::Test.quality_report_for(
               rss.items,
               channel_url: feed_config.dig(:channel, :url).to_s,
-              raw_config: feed_config,
+              config: Html2rss::Config.from_hash(feed_config),
               feed_result:,
               pipeline_outcome: outcome,
               probe_native_feed: false

data/lib/html2rss/mcp/server.rb

@@ -10,7 +10,7 @@ module Html2rss
     # This module maps MCP kwargs to those APIs, then {Outcome} + {Contract} shape the envelope.
     #
     # Strategy note: MCP +auto+ passes through to FeedPipeline AutoFallback
-    # (faraday → botasaurus). Concrete strategies are used as-is.
+    # (default → botasaurus). Concrete strategies are used as-is.
     # Botasaurus requires +BOTASAURUS_SCRAPER_URL+.
     module Server # rubocop:disable Metrics/ModuleLength
       # MCP server display name.
@@ -20,6 +20,9 @@ module Html2rss
       # Loopback bind for HTTP transport (local use only).
       HTTP_BIND_HOST = '127.0.0.1'
 
+      # Supported transport names.
+      TRANSPORTS = Set[:stdio, :http].freeze
+
       # Declarative MCP resource registrations consumed by {register_resources}.
       RESOURCES = [
         {
@@ -29,7 +32,7 @@ module Html2rss
           mime_type: 'application/json',
           body: lambda {
             [{ uri: 'html2rss://schema', mimeType: 'application/json',
-               text: Html2rss::Config.json_schema_json(pretty: true) }]
+               text: Html2rss::Config::Schema.json_schema_json(pretty: true) }]
           }
         },
         {
@@ -93,7 +96,7 @@ module Html2rss
         # @param transport [Symbol] +:stdio+ or +:http+
         # @param port [Integer] port for HTTP transport
         def start(transport: :stdio, port: 8080)
-          raise ArgumentError, "Unknown transport: #{transport.inspect}" unless %i[stdio http].include?(transport)
+          raise ArgumentError, "Unknown transport: #{transport.inspect}" unless TRANSPORTS.include?(transport)
 
           configure_daemon_logging!
           app = build
@@ -137,8 +140,12 @@ module Html2rss
 
         def protocol_configuration
           ::MCP::Configuration.new.tap do |config|
-            config.exception_reporter = method(:report_protocol_exception)
-            config.around_request = method(:around_protocol_request)
+            config.exception_reporter = lambda { |error, server_context|
+              report_protocol_exception(error, server_context)
+            }
+            config.around_request = lambda { |data, &block|
+              around_protocol_request(data, &block)
+            }
             config.validate_tool_call_results = true
           end
         end
@@ -217,26 +224,27 @@ module Html2rss
           tool_error_response(error)
         end
 
+        def register_tools(server)
+          Tools::TOOLS.each { |tool| register_envelope_tool(server, tool) }
+        end
+
         # rubocop:disable-next Metrics/MethodLength -- listing fields stay together
-        def define_envelope_tool(server, name:, description:, input_schema:,
-                                 annotations: Contract::ANNOTATIONS_OPEN_WORLD)
-          run = method(:handle_tool_call)
+        def register_envelope_tool(server, tool)
+          invoke = ->(&block) { handle_tool_call(&block) }
           server.define_tool(
-            name:,
-            title: Contract::TITLES.fetch(name.to_sym),
-            description:,
-            annotations:,
-            input_schema:,
+            name: tool.name,
+            title: tool.title,
+            description: tool.description,
+            annotations: tool.annotations,
+            input_schema: tool.input_schema,
             output_schema: Contract.output_schema
           ) do |**kwargs|
-            run.call { yield(**kwargs) }
+            args = kwargs.dup
+            args.delete(:server_context)
+            invoke.call { tool.call.call(**args) }
           end
         end
 
-        def register_tools(server)
-          Tools.register_all(server, registrar: method(:define_envelope_tool))
-        end
-
         def register_resources(server)
           RESOURCES.each do |entry|
             server.define_resource(
@@ -251,7 +259,7 @@ module Html2rss
         end
 
         def register_prompts(server) # rubocop:disable Metrics/MethodLength -- prompt argument mapping
-          to_result = method(:prompt_result)
+          to_result = ->(text) { prompt_result(text) }
           PROMPTS.each do |entry|
             arguments = entry[:arguments].map do |spec|
               ::MCP::Prompt::Argument.new(name: spec[:name], description: spec[:description],

data/lib/html2rss/page_recon/README.md

@@ -13,7 +13,7 @@
 | `alternate_feeds`  | `rel=alternate` RSS/Atom links found in HTML                                |
 | `surface_category` | AutoSource surface class (`high_entropy_surface`, `unsupported_surface`, …) |
 | `articles_count`   | Cheap AutoSource extract (limit 10) — diagnostic only, not ship quality     |
-| `strategy`         | Concrete transport used (`inspect` maps `auto` → Faraday)                   |
+| `strategy`         | Concrete transport used (`inspect` maps `auto` → default (HTTPX))           |
 
 CLI text output omits `requested_url`; it prints the requested URL as the card title. The `Final:` line appears **only when** `final_url` differs from `requested_url`:
 
@@ -39,16 +39,16 @@ bin/html2rss inspect https://www.example
 # high_entropy_surface, articles (no Final: line — requested equals final)
 ```
 
-Cross-host redirects (e.g. `apex.example` → `www.example`) no longer pin a stale `Host` header from the entry URL. `Config::RequestHeaders` omits `Host` by default; Faraday/Net::HTTP sets it per hop from the current request URL.
+Cross-host redirects (e.g. `apex.example` → `www.example`) no longer pin a stale `Host` header from the entry URL. `Config::RequestHeaders` omits `Host` by default; HTTPX sets it per hop from the current request URL.
 
-When the first streamed fetch loses the redirect payload (empty body at the final URL), `FaradayStrategy` retries once without streaming so inspect/recon see the same HTML as a direct canonical URL fetch.
+When the first streamed fetch loses the redirect payload (empty body at the final URL), `HttpxStrategy` retries once without streaming so inspect/recon see the same HTML as a direct canonical URL fetch.
 
 ### What to do
 
 1. **Prefer the canonical URL** — if you know the site lives on `www`, pass that URL to inspect, recon, capture, and scrape.
 2. **Read the `Final:` line** — when `final_url` differs from what you typed and status is 4xx, retry inspect on `final_url` before assuming the site is unreachable.
 3. **Do not treat apex 403 as “redirect skipped”** — check JSON output (`--format json`) for `requested_url` vs `final_url` when text output is ambiguous.
-4. **Blocked surfaces** — if the canonical URL still fails, try `strategy: botasaurus` on inspect (MCP) or escalate to recon/capture with browser strategy; Faraday-only inspect is intentionally cheap.
+4. **Blocked surfaces** — if the canonical URL still fails, try `strategy: botasaurus` on inspect (MCP) or escalate to recon/capture with browser strategy; default (HTTPX)-only inspect is intentionally cheap.
 
 ## inspect ≠ recon
 
@@ -65,5 +65,5 @@ Follow golden-path `next_step` from MCP envelopes; do not call recon when inspec
 | ----------------------------------- | -------------------------------------------------------------------- |
 | Diagnostic fetch + assess           | `PageRecon::Diagnostics` → `PageRecon.probe`                         |
 | Surface class + cheap article count | `PageRecon::Assessment`                                              |
-| Redirect follow + terminal retry    | `RequestService::FaradayStrategy`                                    |
+| Redirect follow + terminal retry    | `RequestService::HttpxStrategy`                                      |
 | Outbound header normalization       | `Config::RequestHeaders` (no default `Host`; explicit override only) |