textus 0.51.0 → 0.53.0

data/lib/textus/hooks/builtin.rb

@@ -1,70 +0,0 @@
-require "json"
-require "csv"
-require "yaml"
-require "rexml/document"
-
-module Textus
-  module Hooks
-    module Builtin
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def self.register_all(events:, rpc:) # rubocop:disable Lint/UnusedMethodArgument
-        rpc.register(:resolve_handler, :json) do |caps:, config:, args:|
-          _ = caps
-          _ = args
-          data = JSON.parse(config["bytes"].to_s)
-          { _meta: {}, body: YAML.dump(data) }
-        end
-
-        rpc.register(:resolve_handler, :csv) do |caps:, config:, args:|
-          _ = caps
-          _ = args
-          rows = CSV.parse(config["bytes"].to_s, headers: true).map(&:to_h)
-          { _meta: {}, body: YAML.dump(rows) }
-        end
-
-        rpc.register(:resolve_handler, :"markdown-links") do |caps:, config:, args:|
-          _ = caps
-          _ = args
-          links = config["bytes"].to_s.scan(%r{\[([^\]]+)\]\((https?://[^)\s]+)\)}).map do |text, href|
-            { "text" => text, "href" => href }
-          end
-          { _meta: {}, body: YAML.dump(links) }
-        end
-
-        rpc.register(:resolve_handler, :"ical-events") do |caps:, config:, args:|
-          _ = caps
-          _ = args
-          events_list = []
-          current = nil
-          config["bytes"].to_s.each_line do |line|
-            line = line.strip
-            case line
-            when "BEGIN:VEVENT" then current = {}
-            when "END:VEVENT"
-              events_list << current if current
-              current = nil
-            when /\A(SUMMARY|DTSTART|DTEND|UID|LOCATION|DESCRIPTION):(.*)\z/
-              current[Regexp.last_match(1).downcase] = Regexp.last_match(2) if current
-            end
-          end
-          { _meta: {}, body: YAML.dump(events_list) }
-        end
-
-        rpc.register(:resolve_handler, :rss) do |caps:, config:, args:|
-          _ = caps
-          _ = args
-          doc = REXML::Document.new(config["bytes"].to_s)
-          items = doc.elements.to_a("//item").map do |item|
-            {
-              "title" => item.elements["title"]&.text,
-              "link" => item.elements["link"]&.text,
-              "pubDate" => item.elements["pubDate"]&.text,
-            }
-          end
-          { _meta: {}, body: YAML.dump(items) }
-        end
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
-    end
-  end
-end

data/lib/textus/hooks/loader.rb

@@ -1,54 +0,0 @@
-module Textus
-  module Hooks
-    class Loader
-      # A small DSL object passed to user hook blocks. Routes `.on(...)` to the
-      # EventBus and `.rpc(...)` / `.register(...)` to the RpcRegistry.
-      class Dsl
-        def initialize(events:, rpc:)
-          @events = events
-          @rpc    = rpc
-        end
-
-        # Pubsub registration — delegates to EventBus.
-        # Also handles RPC event names by delegating to RpcRegistry.
-        def on(event, name, keys: nil, &)
-          if Hooks::Catalog::RPC.key?(event.to_sym)
-            @rpc.register(event, name, &)
-          else
-            @events.register(event, name, keys: keys, &)
-          end
-        end
-
-        # Explicit RPC registration.
-        def register(event, name, &)
-          @rpc.register(event, name, &)
-        end
-      end
-
-      def initialize(events:, rpc:)
-        @events = events
-        @rpc    = rpc
-        @dsl    = Dsl.new(events: @events, rpc: @rpc)
-      end
-
-      def load_dir(dir)
-        return unless File.directory?(dir)
-
-        # Discard any leftover blocks from a prior partial load.
-        Textus.drain_hook_blocks
-
-        Dir.glob(File.join(dir, "**/*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
-          load(f)
-        rescue StandardError, ScriptError => e
-          raise UsageError.new("failed loading hook #{File.basename(f)}: #{e.class}: #{e.message}")
-        end
-
-        Textus.drain_hook_blocks.each do |blk|
-          blk.call(@dsl)
-        rescue StandardError, ScriptError => e
-          raise UsageError.new("failed registering hook: #{e.class}: #{e.message}")
-        end
-      end
-    end
-  end
-end

data/lib/textus/hooks/rpc_registry.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Hooks
-    class RpcRegistry
-      def initialize
-        @table = Hash.new { |h, k| h[k] = {} }
-      end
-
-      def register(event, name, &blk)
-        event_sym = event.to_sym
-        raise UsageError.new("#{event_sym} is a pubsub event; register on EventBus") if Catalog::PUBSUB.key?(event_sym)
-
-        required = Catalog::RPC[event_sym] or raise UsageError.new("unknown RPC event: #{event}")
-        sig = Signature.new(blk)
-        missing = sig.missing(required)
-        raise UsageError.new("#{event_sym} RPC must accept kwargs: #{required.join(", ")} (missing: #{missing.join(", ")})") if missing.any?
-
-        name = name.to_sym
-        raise UsageError.new("#{event_sym} '#{name}' already registered") if @table[event_sym].key?(name)
-
-        @table[event_sym][name] = blk
-      end
-
-      def names(event) = @table[event.to_sym].keys
-
-      def callable(event, name)
-        @table[event.to_sym][name.to_sym] or raise UsageError.new("unknown #{event}: #{name}")
-      end
-
-      # Invoke a registered callable, injecting `caps:` only if the callable
-      # declares it (or accepts keyrest). Mis-named kwargs (e.g. the legacy
-      # `store:`) are rejected at registration time, not here.
-      def invoke(event, name, caps:, **other)
-        blk = callable(event, name)
-        sig = Signature.new(blk)
-        kwargs = other.dup
-        kwargs[:caps] = caps if sig.accepts_keyrest? || sig.declared_keys.include?(:caps)
-        blk.call(**kwargs)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/key_delete_prefix.rb

@@ -1,48 +0,0 @@
-module Textus
-  module Maintenance
-    # Bulk-delete every leaf key under `prefix`.
-    class KeyDeletePrefix
-      extend Textus::Contract::DSL
-
-      verb     :key_delete_prefix
-      summary  "Bulk-delete every leaf key under prefix."
-      surfaces :cli, :mcp
-      cli      "key delete-prefix"
-      arg :prefix,  String, required: true, positional: true, description: "every leaf key under this dotted prefix is deleted"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the keys that would be deleted without deleting them; " \
-                                           "defaults to false, so omitting it deletes immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-      end
-
-      def call(prefix, dry_run: false)
-        raise UsageError.new("prefix required") if prefix.nil? || prefix.empty?
-
-        leaves = Read::List.new(container: @container)
-                           .call(prefix: prefix)
-                           .map { |r| r.is_a?(Hash) ? (r["key"] || r[:key]) : r }
-
-        warnings = leaves.empty? ? ["no keys under #{prefix}"] : []
-        steps = leaves.map { |k| { "op" => "delete", "key" => k } }
-
-        plan = Plan.new(steps: steps, warnings: warnings)
-        return plan if dry_run
-
-        steps.each do |s|
-          delete.call(s["key"])
-        end
-        plan
-      end
-
-      private
-
-      def delete
-        Write::KeyDelete.new(container: @container, call: @call)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/key_mv_prefix.rb

@@ -1,68 +0,0 @@
-module Textus
-  module Maintenance
-    # Bulk-rename every leaf key under `from_prefix` to `to_prefix`.
-    # Calls Write::KeyMv directly for each entry — emits one audit row per file moved.
-    class KeyMvPrefix
-      extend Textus::Contract::DSL
-
-      verb     :key_mv_prefix
-      summary  "Bulk-rename every leaf key under from_prefix to to_prefix. Dry-run returns a Plan; apply with dry_run: false."
-      surfaces :cli, :mcp
-      cli      "key mv-prefix"
-      arg :from_prefix, String, required: true, positional: true, description: "dotted prefix whose leaf keys are renamed"
-      arg :to_prefix,   String, required: true, positional: true, description: "dotted prefix the keys are renamed to"
-      arg :dry_run,     :boolean, default: false,
-                                  description: "when true, returns the planned moves without applying them; " \
-                                               "defaults to false, so omitting it applies the rename immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-      end
-
-      def call(from_prefix, to_prefix, dry_run: false)
-        raise UsageError.new("from_prefix and to_prefix required") if from_prefix.nil? || to_prefix.nil?
-
-        leaves = list_leaves_under(from_prefix)
-
-        # When from_prefix is itself a leaf, `delete_prefix("#{from_prefix}.")`
-        # finds no trailing dot to strip, so the tail keeps the whole key and the
-        # move silently targets "to_prefix.<full-from_prefix>". Refuse it — a
-        # single-key rename is `mv`'s job, not the bulk prefix verb's.
-        if leaves.include?(from_prefix)
-          raise UsageError.new("from_prefix '#{from_prefix}' is itself a leaf — use `mv` to rename a single key")
-        end
-
-        warnings = []
-        warnings << "no keys under #{from_prefix}" if leaves.empty?
-
-        steps = leaves.map do |old_key|
-          tail = old_key.delete_prefix("#{from_prefix}.")
-          new_key = "#{to_prefix}.#{tail}"
-          { "op" => "mv", "from" => old_key, "to" => new_key }
-        end
-
-        plan = Plan.new(steps: steps, warnings: warnings)
-        return plan if dry_run
-
-        steps.each do |s|
-          mv.call(s["from"], s["to"], dry_run: false)
-        end
-        plan
-      end
-
-      private
-
-      def list_leaves_under(prefix)
-        Read::List.new(container: @container)
-                  .call(prefix: prefix)
-                  .map { |row| row.is_a?(Hash) ? (row["key"] || row[:key]) : row }
-      end
-
-      def mv
-        Write::KeyMv.new(container: @container, call: @call)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/reconcile.rb

@@ -1,160 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Maintenance
-    # Two-phase convergence pass (ADR 0093). Replaces the old Lifecycle-reporter
-    # sweep.
-    #
-    # Phase 1 — Produce (non-destructive): re-render ALL derived entries (cheap,
-    # idempotent) plus every intake entry past its source.ttl (stale-only, so
-    # external sources are not hammered). Driven by Produce::Engine.
-    #
-    # Phase 2 — Retention sweep (destructive): drop or archive entries past their
-    # retention ttl. Driven by Domain::Retention::Sweep. The old refresh/warn
-    # actions are gone — intake re-pull is now Produce's responsibility.
-    class Reconcile
-      extend Textus::Contract::DSL
-
-      verb     :reconcile
-      summary  "Run the convergence pass: produce derived + stale intake, then drop/archive aged entries; report health."
-      surfaces :cli, :mcp
-      cli      "reconcile"
-      arg :prefix,  String, description: "restrict the sweep to keys under this dotted prefix"
-      arg :zone,    String, description: "restrict the sweep to entries in this zone"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, report what the pass WOULD do without applying; " \
-                                           "defaults to false, so omitting it produces + drops/archives immediately"
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-      end
-
-      def call(prefix: nil, zone: nil, dry_run: false)
-        file_stat = Textus::Ports::Storage::FileStat.new
-        retention_rows = Textus::Domain::Retention::Sweep.new(
-          manifest: @container.manifest, file_stat: file_stat, clock: Textus::Ports::Clock.new,
-        ).call(prefix: prefix, zone: zone)
-
-        produce_keys = produce_scope(prefix, zone, file_stat)
-        health = Read::Doctor.new(container: @container, call: @call).call
-        return dry_run_result(produce_keys, retention_rows, health) if dry_run
-
-        # reconcile is the authoritative "make everything current now" pass, so
-        # it subsumes any in-flight reactive produce: drain pending async
-        # produce-on-write threads first, both to fold their work in and to free
-        # the shared maintenance lock (BuildLock is non-blocking — a thread still
-        # holding it would make the acquire below raise BuildInProgress). ADR 0093.
-        Textus::Produce::Engine::AsyncRunner.drain
-
-        Textus::Ports::BuildLock.with(root: @container.root) do
-          produced = Textus::Produce::Engine.new(container: @container, call: @call).call(keys: produce_keys)
-          swept = apply(retention_rows)
-          publish_failed(swept[:failed]) unless swept[:failed].empty?
-          apply_result(produced, swept, health)
-        end
-      end
-
-      private
-
-      # The full produce scope (ADR 0093): every derived entry (always
-      # re-render — cheap, idempotent), every entry that mirrors a publish_tree
-      # (the nested-subtree publishers, ADR 0047 — mirrored each pass so a
-      # removed source leaf is swept from the published tree), every authored
-      # leaf with a `publish.to` target (the single-file canon publishers —
-      # docs/README.md, the architecture index, the root README; ADR 0103 —
-      # converged each pass so a stale published copy is rewritten and the
-      # `reconcile`-is-a-no-op check guards them), plus every intake entry past
-      # its source.ttl (re-pull only when due, so external sources aren't
-      # hammered). Ttl-less intake entries (:no_policy) are skipped — they have
-      # no freshness contract and are never auto-re-pulled (ADR 0099). All are
-      # idempotent: publish writes only when the target's content changed.
-      def produce_scope(prefix, zone, file_stat)
-        publishable = @container.manifest.data.entries
-                                .select { |e| e.derived? || !e.publish_tree.nil? || !e.publish_to.empty? }
-                                .select { |e| in_scope?(e, prefix, zone) }.map(&:key)
-        stale_intake = Textus::Domain::Freshness::Evaluator.new(
-          manifest: @container.manifest, file_stat: file_stat, clock: Textus::Ports::Clock.new,
-        ).stale_intake_keys(prefix: prefix, zone: zone)
-        (publishable + stale_intake).uniq
-      end
-
-      def in_scope?(entry, prefix, zone)
-        return false if zone && entry.zone != zone
-        return false if prefix && !entry.key.start_with?(prefix)
-
-        true
-      end
-
-      def dry_run_result(produce_keys, rows, health)
-        {
-          "protocol" => Textus::PROTOCOL, "ok" => true, "dry_run" => true,
-          "would_produce" => produce_keys,
-          "would_drop" => action_keys(rows, "drop"),
-          "would_archive" => action_keys(rows, "archive"),
-          "health" => health
-        }
-      end
-
-      def apply_result(produced, swept, health)
-        {
-          "protocol" => Textus::PROTOCOL,
-          "ok" => produced[:failed].empty? && swept[:failed].empty?,
-          "dry_run" => false,
-          "produced" => produced[:produced],
-          "produce_failed" => produced[:failed],
-          "dropped" => swept[:dropped], "archived" => swept[:archived],
-          "failed" => swept[:failed],
-          "health" => health
-        }
-      end
-
-      def action_keys(rows, action)
-        rows.select { |r| r["action"] == action }.map { |r| r["key"] }
-      end
-
-      def publish_failed(failed)
-        @container.events.publish(
-          :reconcile_failed,
-          ctx: Textus::Hooks::Context.for(container: @container, call: @call),
-          failed: failed,
-        )
-      end
-
-      # Phase 2: destructive retention only (drop/archive). No refresh — intake
-      # re-pull is Produce's job (Phase 1). ADR 0093.
-      def apply(rows)
-        out = { dropped: [], archived: [], failed: [] }
-        delete = Write::KeyDelete.new(container: @container, call: @call)
-        rows.each do |row|
-          key = row["key"]
-          begin
-            case row["action"]
-            when "drop"
-              delete.call(key)
-              out[:dropped] << key
-            when "archive"
-              archive_leaf(row)
-              delete.call(key)
-              out[:archived] << key
-            end
-          rescue Textus::Error => e
-            out[:failed] << { "key" => key, "error" => e.message }
-          end
-        end
-        out
-      end
-
-      # Copy the leaf into <store>/archive/<relative-path> before deletion.
-      # (Lifted from the retired RetentionSweep#archive_leaf.)
-      def archive_leaf(row)
-        src  = row["path"]
-        root = @container.root.to_s
-        rel  = src.delete_prefix("#{root}/")
-        dest = File.join(root, "archive", rel)
-        FileUtils.mkdir_p(File.dirname(dest))
-        FileUtils.cp(src, dest)
-      end
-    end
-  end
-end

data/lib/textus/maintenance/rule_lint.rb

@@ -1,66 +0,0 @@
-require "yaml"
-
-module Textus
-  module Maintenance
-    # Compare the live manifest's `rules:` block against a candidate
-    # YAML string. Returns a Plan describing rule additions/removals/
-    # changes. Does NOT write anything.
-    class RuleLint
-      extend Textus::Contract::DSL
-
-      verb     :rule_lint
-      summary  "Diff candidate manifest YAML's rules against the live manifest. No writes."
-      surfaces :cli, :mcp
-      cli      "rule lint"
-      arg :candidate_yaml, String, required: true, wire_name: :against, source: :file,
-                                   description: "path to candidate manifest YAML; its `rules:` block is diffed against the live manifest"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-        @root      = container.root
-      end
-
-      def call(candidate_yaml:)
-        live_rules      = current_rules
-        candidate_rules = parse_candidate(candidate_yaml)
-
-        live_by_match      = live_rules.to_h { |r| [r["match"], r] }
-        candidate_by_match = candidate_rules.to_h { |r| [r["match"], r] }
-
-        steps = (candidate_by_match.keys - live_by_match.keys).map do |m|
-          { "op" => "add_rule", "match" => m, "rule" => candidate_by_match[m] }
-        end
-        (live_by_match.keys - candidate_by_match.keys).each do |m|
-          steps << { "op" => "remove_rule", "match" => m }
-        end
-        (live_by_match.keys & candidate_by_match.keys).each do |m|
-          next if live_by_match[m] == candidate_by_match[m]
-
-          steps << { "op" => "change_rule", "match" => m,
-                     "from" => live_by_match[m], "to" => candidate_by_match[m] }
-        end
-
-        Plan.new(steps: steps, warnings: [])
-      end
-
-      private
-
-      def current_rules
-        raw = YAML.safe_load_file(File.join(@root, "manifest.yaml"),
-                                  permitted_classes: [Symbol], aliases: false)
-        Array(raw["rules"])
-      end
-
-      def parse_candidate(yaml_text)
-        raw = YAML.safe_load(yaml_text, permitted_classes: [Symbol], aliases: false)
-        raise UsageError.new("candidate is not a YAML mapping") unless raw.is_a?(Hash)
-
-        Array(raw["rules"])
-      rescue Psych::Exception => e
-        raise UsageError.new("candidate YAML parse error: #{e.message}")
-      end
-    end
-  end
-end

data/lib/textus/maintenance/zone_mv.rb

@@ -1,64 +0,0 @@
-require "yaml"
-
-module Textus
-  module Maintenance
-    # Rename a zone — rewrites the manifest's zones[] entry, rewrites
-    # the `zone:` field on every entry under the old zone, and moves
-    # every file from zones/<old>/ to zones/<new>/.
-    class ZoneMv
-      extend Textus::Contract::DSL
-
-      verb     :zone_mv
-      summary  "Rename a zone — manifest + files. Refuses if destination exists."
-      surfaces :cli, :mcp
-      cli      "zone mv"
-      arg :from,    String, required: true, positional: true, description: "current zone name"
-      arg :to,      String, required: true, positional: true, description: "new zone name; refused if a zone by this name already exists"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the planned zone move without applying it; " \
-                                           "defaults to false, so omitting it applies the move immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-        @manifest  = container.manifest
-        @root      = container.root
-      end
-
-      def call(from, to, dry_run: false)
-        raise UsageError.new("from and to required") if from.nil? || to.nil? || from.empty? || to.empty?
-        raise UsageError.new("zone '#{from}' not declared") unless @manifest.data.declared_zone_kinds.key?(from)
-
-        dest_dir = File.join(@root, "zones", to)
-        raise UsageError.new("destination 'zones/#{to}' already exists") if File.exist?(dest_dir)
-
-        affected_keys = @manifest.data.entries.select { |e| e.zone == from }.map(&:key)
-
-        steps  = [{ "op" => "rename_zone", "from" => from, "to" => to }]
-        steps += affected_keys.map { |k| { "op" => "mv", "from" => k, "to" => "#{to}#{k[from.length..]}" } }
-
-        plan = Plan.new(steps: steps, warnings: [])
-        return plan if dry_run
-
-        rewrite_manifest!(from, to)
-        FileUtils.mv(File.join(@root, "zones", from), dest_dir)
-        plan
-      end
-
-      private
-
-      def rewrite_manifest!(from, to)
-        path = File.join(@root, "manifest.yaml")
-        raw = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: false)
-        raw["zones"].each { |z| z["name"] = to if z["name"] == from }
-        raw["entries"].each do |e|
-          e["zone"] = to if e["zone"] == from
-          e["key"]  = e["key"].sub(/\A#{Regexp.escape(from)}(\.|\z)/, "#{to}\\1")
-          e["path"] = e["path"].sub(%r{\A#{Regexp.escape(from)}(/|\z)}, "#{to}\\1")
-        end
-        File.write(path, YAML.dump(raw))
-      end
-    end
-  end
-end

data/lib/textus/maintenance.rb

@@ -1,15 +0,0 @@
-module Textus
-  # Bulk and structural changes to a textus store. Each use case returns
-  # a Plan when called with dry_run: true, and applies the plan when
-  # called with dry_run: false.
-  module Maintenance
-    # A Plan is a JSON-shaped preview. Steps are op-tagged hashes the
-    # use case knows how to apply. Warnings are strings surfaced to
-    # the operator (skipped keys, ambiguities).
-    Plan = Data.define(:steps, :warnings) do
-      def to_h
-        { "steps" => steps, "warnings" => warnings }
-      end
-    end
-  end
-end

data/lib/textus/mcp/catalog.rb

@@ -1,70 +0,0 @@
-module Textus
-  module MCP
-    # Derives the entire MCP tool surface from the per-verb contracts
-    # (ADR 0039). `tool_schemas` feeds tools/list; `call` is the generic
-    # tools/call dispatch: map JSON args -> (positional, keyword) per the
-    # contract, invoke the verb through the role scope, then shape the
-    # return value with the contract's default view. No per-tool code.
-    module Catalog
-      module_function
-
-      # Contracts of every MCP-surfaced verb, in Dispatcher order.
-      def specs
-        Textus::Dispatcher::VERBS.values
-                                 .select { |k| mcp_surfaced?(k) }
-                                 .map(&:contract)
-      end
-
-      def tool_schemas
-        specs.map do |s|
-          { name: s.verb.to_s, description: s.summary, inputSchema: s.input_schema }
-        end.freeze
-      end
-
-      def names
-        specs.map { |s| s.verb.to_s }
-      end
-
-      # MCP-surfaced read verbs, by Dispatcher class namespace — the agent's
-      # real read/discovery surface. `boot.agent_quickstart.read_verbs` derives
-      # from this so it can never advertise a verb the agent cannot call, nor
-      # omit one it can (ADR 0056). Excludes Write/Maintenance.
-      def read_verbs
-        Textus::Dispatcher::VERBS
-          .select { |_verb, klass| mcp_surfaced?(klass) && klass.name.start_with?("Textus::Read::") }
-          .keys.map(&:to_s)
-      end
-
-      # MCP-surfaced write verbs, by Dispatcher class namespace — the mirror of
-      # read_verbs for the write side. `boot.agent_quickstart.write_verbs` derives
-      # from this so it advertises bare verb names the agent can call (no `--as`/
-      # `--stdin` CLI framing), finishing the de-CLI-ing of the agent surface
-      # (ADR 0056, ADR 0057).
-      def write_verbs
-        Textus::Dispatcher::VERBS
-          .select { |_verb, klass| mcp_surfaced?(klass) && klass.name.start_with?("Textus::Write::") }
-          .keys.map(&:to_s)
-      end
-
-      def mcp_surfaced?(klass)
-        klass.respond_to?(:contract?) && klass.contract? && klass.contract.mcp?
-      end
-
-      def call(name, session:, store:, args:)
-        klass = Textus::Dispatcher::VERBS[name.to_sym]
-        raise ToolError.new("unknown tool: #{name}") unless klass && mcp_surfaced?(klass)
-
-        spec = klass.contract
-        inputs = Textus::Contract::Binder.inputs_from_wire(spec, args)
-        result = store.as(session.role).dispatch_bound(spec.verb, inputs, session: session)
-        Textus::Contract::View.render(spec, :default, result, inputs)
-      rescue Textus::Contract::MissingArgs => e
-        raise ToolError.new("#{spec.verb}: missing #{e.missing.map { |a| a.wire.to_s }.join(", ")}")
-      rescue ContractDrift, CursorExpired
-        raise
-      rescue Textus::Error => e
-        raise ToolError.new("#{name}: #{e.message}")
-      end
-    end
-  end
-end