woods 1.6.1 → 2.0.0.beta2

data/lib/woods/mcp/index_reader_pinning.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Woods
+  module MCP
+    # Pins reader-backed MCP handlers to one cached generation per request.
+    # Installed on each built server's singleton class so the captured reader
+    # never leaks to another Woods server or a foreign MCP::Server instance.
+    #
+    # Coverage is derived from every tool the server actually has registered
+    # at install time, not a hand-maintained allowlist. A static list of
+    # "reader tools" silently stopped covering new tools the moment one was
+    # added and nobody remembered to update the list — the pin wrapper once
+    # covered 14 of 28 non-reload tools this way, leaving retrieval,
+    # pipeline, snapshot, and feedback calls free to run concurrently with an
+    # exclusive reload. Pinning a handler that turns out not to touch the
+    # reader costs an uncontended mutex + refcount bump; leaving one
+    # unpinned that does touch it is the correctness bug. Default to pinned.
+    module IndexReaderPinning
+      # Tools deliberately left outside the pin gate, each with its own
+      # justification — anything not listed here is pinned by construction.
+      #
+      # `reload` — the exclusive writer `with_pinned_generation` exists to
+      # hold readers back from. Pinning its own handler would acquire a pin
+      # first and then, inside the same call, ask `with_exclusive_reload` to
+      # wait for every outstanding pin to drain — including the one the
+      # handler itself is still holding. Self-deadlock, not missed coverage.
+      #
+      # No other registered tool qualifies as of this audit round. The
+      # operator/feedback/snapshot handlers read their own collaborators
+      # (StatusReporter, the feedback store, the snapshot store) rather than
+      # the shared `reader`, so pinning them is a no-op today — but it is a
+      # free no-op, and the alternative is a hand-maintained allowlist that
+      # silently stops covering a handler the moment it starts reading
+      # `reader` too. Default to pinned; name the exception, don't guess it.
+      NON_READER_TOOL_NAMES = Set.new(
+        %w[
+          reload
+        ]
+      ).freeze
+
+      class << self
+        # @param server [MCP::Server]
+        # @param reader [Woods::MCP::IndexReader]
+        # @return [MCP::Server]
+        def install(server, reader:)
+          server.singleton_class.prepend(Dispatch)
+          server.instance_variable_set(:@woods_index_reader, reader)
+          server.instance_variable_set(
+            :@woods_index_reader_tool_names,
+            (server.tools.keys.to_set - NON_READER_TOOL_NAMES).freeze
+          )
+          server
+        end
+      end
+
+      module Dispatch
+        private
+
+        def call_tool(request, **kwargs)
+          reader = @woods_index_reader
+          tool_names = @woods_index_reader_tool_names
+          return super unless reader && tool_names&.include?(request[:name])
+
+          reader.with_pinned_generation { super }
+        end
+
+        def read_resource_contents(request, **kwargs)
+          reader = @woods_index_reader
+          return super unless reader
+
+          reader.with_pinned_generation { super }
+        end
+      end
+    end
+  end
+end

data/lib/woods/mcp/origin_guard.rb

@@ -39,7 +39,7 @@ module Woods
       LOOPBACK_HOSTS = %w[localhost 127.0.0.1 ::1 [::1]].freeze
 
       ALLOWED_METHODS = 'GET, POST, DELETE, OPTIONS'
-      ALLOWED_HEADERS = 'Authorization, Content-Type, Mcp-Session-Id'
+      ALLOWED_HEADERS = 'Authorization, Content-Type, MCP-Protocol-Version, Mcp-Method, Mcp-Name, Mcp-Session-Id'
 
       # Response bodies are emitted as constants so the rejected Origin /
       # Host value is NEVER echoed back to the caller — preventing a
@@ -48,14 +48,39 @@ module Woods
       FORBIDDEN_BODY = { jsonrpc: '2.0', error: { code: -32_002, message: 'Origin not allowed' }, id: nil }.to_json.freeze
       FORBIDDEN_HOST_BODY = { jsonrpc: '2.0', error: { code: -32_002, message: 'Host not allowed' }, id: nil }.to_json.freeze
 
-      def initialize(app, allowed_origins: nil)
+      # @param app [#call] The next Rack app in the middleware stack
+      # @param allowed_origins [Array<String>, #call, nil] Origin allow-list,
+      #   or a callable returning one. A callable is resolved (and memoized)
+      #   on the first guarded request, so an allow-list configured after the
+      #   middleware was inserted — e.g. in `config/initializers/woods.rb`,
+      #   which runs after Rails railtie initializers captured the middleware
+      #   arguments — still takes effect (#183). Empty/nil falls back to
+      #   {DEFAULT_ALLOWED}.
+      # @param path [String, nil] When set, only requests whose PATH_INFO
+      #   starts with this prefix are guarded — everything else passes
+      #   straight through to the app. Nil (the default) guards every request.
+      # @param enabled [#call, nil] Optional request-time predicate. When it
+      #   returns falsy the request passes through unguarded. Nil (the
+      #   default) means always guard.
+      def initialize(app, allowed_origins: nil, path: nil, enabled: nil)
         @app = app
-        @allowed = Array(allowed_origins).compact.reject { |o| o.to_s.strip.empty? }.map { |o| normalize(o) }
-        @allowed = DEFAULT_ALLOWED.dup if @allowed.empty?
-        @allowed_hosts = @allowed.map { |o| extract_host(o) }.compact.uniq
+        @path = path
+        @enabled = enabled
+        if allowed_origins.respond_to?(:call)
+          @allowed_source = allowed_origins
+        else
+          build_allow_list(allowed_origins)
+        end
       end
 
+      # Rack entry point. Out-of-scope requests (non-matching `path:` prefix
+      # or a falsy `enabled:` predicate) pass through untouched.
+      #
+      # @param env [Hash] Rack environment
+      # @return [Array] Rack response triple
       def call(env)
+        return @app.call(env) unless guard?(env)
+
         origin = env['HTTP_ORIGIN']
         method = env['REQUEST_METHOD']
         host = env['HTTP_HOST']
@@ -72,6 +97,40 @@ module Woods
 
       private
 
+      # @param env [Hash] Rack environment
+      # @return [Boolean] whether this request falls under the guard
+      def guard?(env)
+        return false if @path && !env['PATH_INFO'].to_s.start_with?(@path)
+        return false if @enabled && !@enabled.call
+
+        true
+      end
+
+      # Normalize a raw allow-list into `@allowed` + `@allowed_hosts`.
+      #
+      # @param origins [Array<String>, nil]
+      # @return [Array<String>] the normalized allow-list
+      def build_allow_list(origins)
+        allowed = Array(origins).compact.reject { |o| o.to_s.strip.empty? }.map { |o| normalize(o) }
+        allowed = DEFAULT_ALLOWED.dup if allowed.empty?
+        @allowed_hosts = allowed.map { |o| extract_host(o) }.compact.uniq
+        @allowed = allowed
+      end
+
+      # The allow-list, resolving a deferred source on first use. Memoized —
+      # configuration is settled by the time the first request arrives.
+      #
+      # @return [Array<String>]
+      def allowed
+        @allowed || build_allow_list(@allowed_source.call)
+      end
+
+      # @return [Array<String>] hosts extracted from the allow-list
+      def allowed_hosts
+        allowed
+        @allowed_hosts
+      end
+
       def normalize(origin)
         origin.to_s.sub(%r{/\z}, '').downcase
       end
@@ -96,13 +155,13 @@ module Woods
 
         return true if LOOPBACK_HOSTS.include?(bare)
 
-        @allowed_hosts.include?(normalized) || @allowed_hosts.include?(bare)
+        allowed_hosts.include?(normalized) || allowed_hosts.include?(bare)
       end
 
       def origin_allowed?(origin)
         return false if origin.match?(/[[:cntrl:]]/)
 
-        @allowed.include?(normalize(origin)) || @allowed.include?(normalize(origin).sub(/:\d+\z/, ''))
+        allowed.include?(normalize(origin)) || allowed.include?(normalize(origin).sub(/:\d+\z/, ''))
       end
 
       def preflight(origin)

data/lib/woods/mcp/protocol_policy.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Woods
+  module MCP
+    # Protocol-level policy shared by both MCP servers (index and console).
+    #
+    # Everything here is a decision the MCP 2026-07-28 revision asks a server to
+    # make but the SDK cannot make for us: how long a list/read result stays
+    # fresh, who is allowed to cache it, and what order tools are advertised in.
+    #
+    # @see docs/design/MCP_2026_STRATEGY.md
+    module ProtocolPolicy
+      # SEP-2549 `cacheScope`. **Always `"private"`, deliberately not configurable.**
+      #
+      # Every result Woods can return describes the user's own codebase — tool
+      # descriptions naming their models, resource reads carrying their source.
+      # `"public"` authorises shared intermediaries (a corporate proxy, a gateway,
+      # a CDN in front of `woods-mcp-http`) to cache and re-serve that to other
+      # callers. The SDK's fallback when only `ttl_ms` is set is `"public"`, so
+      # setting the ttl and leaving the scope alone is the one combination that
+      # silently opts into the bad outcome — which is exactly why this is pinned
+      # rather than defaulted.
+      CACHE_SCOPE = 'private'
+
+      # SEP-2549 `ttlMs`, a freshness hint with max-age semantics (0 = do not cache).
+      #
+      # The SDK applies one server-level value to `tools/list`, `prompts/list`,
+      # `resources/list`, `resources/read` and `resources/templates/list` alike,
+      # so this has to be safe for the most volatile of them — a `resources/read`
+      # against an index a watch daemon may rewrite seconds from now.
+      #
+      # Ten seconds collapses the burst of list calls an agent makes when it
+      # opens a session without letting a daemon-driven index change go unseen
+      # for meaningfully longer than the poll interval that produced it. Callers
+      # that never run a daemon can raise it via WOODS_MCP_CACHE_TTL_MS.
+      DEFAULT_TTL_MS = 10_000
+
+      # Environment override for {DEFAULT_TTL_MS}. `0` disables caching.
+      TTL_ENV_KEY = 'WOODS_MCP_CACHE_TTL_MS'
+
+      class << self
+        # Resolved `ttlMs` for this process.
+        #
+        # A malformed or negative value falls back to the default rather than
+        # raising: this is a cache hint on a server an agent is mid-conversation
+        # with, and refusing to boot over a typo'd env var trades a mild
+        # performance regression for a total outage.
+        #
+        # @return [Integer] non-negative milliseconds
+        def ttl_ms
+          raw = ENV.fetch(TTL_ENV_KEY, nil)
+          return DEFAULT_TTL_MS if raw.nil? || raw.strip.empty?
+
+          value = Integer(raw, exception: false)
+          return DEFAULT_TTL_MS if value.nil? || value.negative?
+
+          value
+        end
+
+        # Keyword arguments for `MCP::Server.new` carrying the cache hints.
+        #
+        # @return [Hash{Symbol => Object}]
+        def cache_hints
+          { ttl_ms: ttl_ms, cache_scope: CACHE_SCOPE }
+        end
+
+        # Sort a built server's tools by name, in place.
+        #
+        # MCP 2026-07-28 asks servers to return `tools/list` in a deterministic
+        # order, explicitly so clients can cache the list and so the tool block
+        # lands identically in an LLM's prompt cache across turns. The SDK lists
+        # `@tools.values` — Hash insertion order — and Woods registers 14
+        # always-on tools followed by up to 15 more gated on which collaborators
+        # happen to be wired. Two hosts with different integrations therefore
+        # advertise the same tools in different orders, and enabling an
+        # integration reorders the block for everyone on that host.
+        #
+        # Sorting also fixes cursor pagination, which the SDK implements by
+        # offset over that same unordered collection.
+        #
+        # This reaches into an SDK ivar because `define_tool` is the only
+        # registration API and it appends. The reach is contained here and
+        # no-ops if the internal shape ever changes, so a future SDK refactor
+        # degrades to "unsorted, as before" rather than breaking the server.
+        #
+        # @param server [MCP::Server]
+        # @return [MCP::Server] the same server, for chaining
+        def sort_tools!(server)
+          tools = server.instance_variable_get(:@tools)
+          return server unless tools.is_a?(Hash)
+
+          server.instance_variable_set(:@tools, tools.sort_by { |name, _| name.to_s }.to_h)
+          server
+        end
+      end
+    end
+  end
+end

data/lib/woods/mcp/provider_probe.rb

@@ -3,6 +3,11 @@
 require 'net/http'
 require 'uri'
 
+require_relative 'errors'
+require_relative '../embedding/provider'
+require_relative '../embedding/openai'
+require_relative '../embedding/fake'
+
 module Woods
   module MCP
     # Probes an embedding provider's HTTP endpoint to confirm it is reachable
@@ -39,28 +44,62 @@ module Woods
       #   with +reason: "unauthorized"+ because an invalid key means the
       #   provider cannot be used; network failures raise with the appropriate
       #   reason string.
-      # - Any other class → raises +ArgumentError+.
+      # - {Woods::Embedding::Provider::Fake} → trivially reachable (#178).
+      #   The provider is deterministic and in-process; there is no endpoint
+      #   to probe, so the probe succeeds without any network I/O.
+      # - Any other object responding to +#embed+ and +#embed_batch+ — an
+      #   injected provider object, the third shape
+      #   {Woods::Builder#build_embedding_provider} accepts (#178) — is
+      #   presumed reachable. An arbitrary host-supplied implementation has
+      #   no endpoint contract this probe could exercise, so the probe
+      #   succeeds without any network I/O and the provider's first real
+      #   call surfaces connectivity or credential errors.
+      # - Anything else → raises +ArgumentError+.
       #
       # @param provider [Woods::Embedding::Provider::Ollama,
-      #   Woods::Embedding::Provider::OpenAI] a concrete embedding provider
+      #   Woods::Embedding::Provider::OpenAI,
+      #   Woods::Embedding::Provider::Fake, Object] a concrete embedding
+      #   provider, or an injected object implementing +#embed+/+#embed_batch+
       # @return [Object] the same +provider+ if reachable
       # @raise [Woods::MCP::ProviderUnreachable] if the endpoint is unreachable,
       #   times out, returns 5xx, or (for OpenAI) returns 401
-      # @raise [ArgumentError] if +provider+ is not a recognised provider class
+      # @raise [ArgumentError] if +provider+ is neither a recognised provider
+      #   class nor an object implementing +#embed+ and +#embed_batch+
       def self.reachable!(provider)
         case provider
         when Woods::Embedding::Provider::Ollama
           probe_ollama!(provider)
         when Woods::Embedding::Provider::OpenAI
           probe_openai!(provider)
+        when Woods::Embedding::Provider::Fake
+          # In-process, no endpoint: nothing to probe (#178). The case arm
+          # is deliberately empty — the method returns +provider+ below.
+          nil
         else
-          raise ArgumentError,
-                "#{self}.reachable! does not know how to probe #{provider.class} — " \
-                'add a provider-specific probe method or implement #probe_url'
+          unless provider_object?(provider)
+            raise ArgumentError,
+                  "#{self}.reachable! does not know how to probe #{provider.class} — " \
+                  'the object must implement #embed and #embed_batch, or be a known ' \
+                  'provider class (OpenAI, Ollama, Fake)'
+          end
+          # Injected provider object: presumed reachable (see above). The
+          # arm deliberately performs no network I/O — the method returns
+          # +provider+ below, like the Fake arm.
+          nil
         end
         provider
       end
 
+      # Duck-type check for an injected provider object — the same two-method
+      # contract {Woods::Builder#provider_object?} accepts (#178).
+      #
+      # @param provider [Object]
+      # @return [Boolean]
+      def self.provider_object?(provider)
+        provider.respond_to?(:embed) && provider.respond_to?(:embed_batch)
+      end
+      private_class_method :provider_object?
+
       # Probe the Ollama instance backing +provider+.
       #
       # @param provider [Woods::Embedding::Provider::Ollama]

data/lib/woods/mcp/renderers/markdown_renderer.rb

@@ -72,6 +72,14 @@ module Woods
             lines << line
           end
 
+          note = fetch_key(data, :note)
+          partial = fetch_key(data, :partial, false)
+          if partial || note
+            lines << ''
+            lines << '**partial:** true' if partial
+            lines << "**note:** #{note}" if note
+          end
+
           lines.join("\n").rstrip
         end
 
@@ -165,14 +173,16 @@ module Woods
             lines << ''
           end
 
-          %w[orphans dead_ends hubs cycles bridges].each do |section|
+          GRAPH_ANALYSIS_SECTIONS.each do |section|
             items = fetch_key(data, section)
             next unless items.is_a?(Array) && items.any?
 
             lines << "### #{section.tr('_', ' ').capitalize}"
             lines << ''
             items.each do |item|
-              lines << if item.is_a?(Hash) && item.key?('score')
+              lines << if item.is_a?(Hash) && item.key?('from')
+                         graph_edge_line(item, bold: true)
+                       elsif item.is_a?(Hash) && item.key?('score')
                          "- **#{item['identifier']}** (#{item['type']}) — score: #{item['score']}"
                        elsif item.is_a?(Hash)
                          "- **#{item['identifier']}** (#{item['type']}) — #{item['dependent_count']} dependents"
@@ -184,7 +194,9 @@ module Woods
             total_key = "#{section}_total"
             if data[total_key]
               lines << ''
-              lines << "_Showing #{items.size} of #{data[total_key]} (truncated)_"
+              offset = fetch_key(data, "#{section}_offset", 0)
+              position = offset.positive? ? " from offset #{offset}" : ''
+              lines << "_Showing #{items.size} of #{data[total_key]}#{position} (truncated)_"
             end
             lines << ''
           end
@@ -354,6 +366,40 @@ module Woods
 
         private
 
+        # One line for an edge-shaped report item (from, to, via, then the
+        # remaining keys in the order the report emits them).
+        #
+        # @param item [Hash] string-keyed
+        # @param bold [Boolean] wrap the endpoints in ** for markdown
+        # @return [String]
+        def graph_edge_line(item, bold:)
+          detail = item.except('from', 'to', 'via')
+                       .map { |key, value| "#{key}: #{edge_value(value)}" }.join(', ')
+          line = "#{edge_endpoint(item['from'], bold: bold)} -> #{edge_endpoint(item['to'], bold: bold)} " \
+                 "(#{item['via']})"
+          detail.empty? ? "- #{line}" : "- #{line}: #{detail}"
+        end
+
+        # A resolved endpoint is bolded (when markdown calls for it); a nil
+        # endpoint (an ambiguous foreign-key owner, for example) is a plain
+        # placeholder, never an empty bold pair (`****`).
+        #
+        # @param value [String, nil]
+        # @param bold [Boolean]
+        # @return [String]
+        def edge_endpoint(value, bold:)
+          return '(unresolved)' if value.nil?
+
+          bold ? "**#{value}**" : value
+        end
+
+        # @param value [Object] a detail hash value; arrays (e.g. `ambiguous_owners`) join
+        #   as plain text instead of printing Ruby's `Array#inspect` syntax.
+        # @return [Object]
+        def edge_value(value)
+          value.is_a?(Array) ? value.join(', ') : value
+        end
+
         def render_traversal(label, data)
           root = fetch_key(data, :root)
           found = data[:found] || data['found']
@@ -372,14 +418,36 @@ module Woods
           nodes.each do |id, info|
             depth = fetch_key(info, :depth) || 0
             deps = fetch_key(info, :deps, [])
+            # Present only where one identifier names units of several types,
+            # so the reader is told rather than shown one of them silently.
+            types = fetch_key(info, :types)
+            # Likewise for the database: the reader sets it only in a graph
+            # spanning more than one.
+            database = fetch_key(info, :database)
             indent = '  ' * depth
-            lines << "#{indent}- **#{id}**"
+            suffix = types ? " (#{Array(types).join(', ')})" : ''
+            suffix += " [#{database}]" if database
+            lines << "#{indent}- **#{id}**#{suffix}"
             deps.each { |d| lines << "#{indent}  - #{d}" }
           end
 
+          lines << '' << truncation_note(data, nodes.size) if fetch_key(data, :nodes_total)
+
           lines.join("\n").rstrip
         end
 
+        # The line `graph_analysis` prints over a paged section, reused
+        # verbatim for a paged traversal (B-183).
+        #
+        # @param data [Hash] the paged payload
+        # @param shown [Integer] entries in the page
+        # @return [String]
+        def truncation_note(data, shown)
+          offset = fetch_key(data, :nodes_offset, 0)
+          position = offset.positive? ? " from offset #{offset}" : ''
+          "_Showing #{shown} of #{fetch_key(data, :nodes_total)}#{position} (truncated)_"
+        end
+
         def render_metadata_section(metadata)
           lines = []
           lines << '### Metadata'

data/lib/woods/mcp/renderers/plain_renderer.rb

@@ -69,9 +69,17 @@ module Woods
           results.each do |r|
             ident = fetch_key(r, :identifier)
             type = fetch_key(r, :type)
-            lines << "  #{ident} (#{type})"
+            match = fetch_key(r, :match_field)
+            line = "  #{ident} (#{type})"
+            line += " - matched in #{match}" if match
+            lines << line
           end
 
+          note = fetch_key(data, :note)
+          partial = fetch_key(data, :partial, false)
+          lines << 'partial: true' if partial
+          lines << "note: #{note}" if note
+
           lines.join("\n").rstrip
         end
 
@@ -135,13 +143,15 @@ module Woods
             lines << ''
           end
 
-          %w[orphans dead_ends hubs cycles bridges].each do |section|
+          GRAPH_ANALYSIS_SECTIONS.each do |section|
             items = fetch_key(data, section)
             next unless items.is_a?(Array) && items.any?
 
             lines << "#{section.tr('_', ' ').upcase}:"
             items.each do |item|
-              lines << if item.is_a?(Hash)
+              lines << if item.is_a?(Hash) && item.key?('from')
+                         "  #{plain_edge_line(item)}"
+                       elsif item.is_a?(Hash)
                          "  #{item['identifier']} (#{item['type']}) - #{item['dependent_count']} dependents"
                        else
                          "  #{item}"
@@ -149,7 +159,11 @@ module Woods
             end
 
             total_key = "#{section}_total"
-            lines << "  (showing #{items.size} of #{data[total_key]})" if data[total_key]
+            offset = fetch_key(data, "#{section}_offset", 0)
+            if data[total_key]
+              position = offset.positive? ? " from offset #{offset}" : ''
+              lines << "  (showing #{items.size} of #{data[total_key]}#{position}; truncated)"
+            end
             lines << ''
           end
 
@@ -202,7 +216,8 @@ module Woods
             ident = fetch_key(r, :identifier)
             type = fetch_key(r, :type)
             modified = fetch_key(r, :last_modified) || '-'
-            lines << "  #{ident} (#{type}) - #{modified}"
+            author = fetch_key(r, :author) || '-'
+            lines << "  #{ident} (#{type}) - #{modified} - #{author}"
           end
 
           lines.join("\n").rstrip
@@ -223,6 +238,31 @@ module Woods
 
         private
 
+        # @param item [Hash] string-keyed edge-shaped report item
+        # @return [String]
+        def plain_edge_line(item)
+          detail = item.except('from', 'to', 'via')
+                       .map { |key, value| "#{key}: #{edge_value(value)}" }.join(', ')
+          line = "#{edge_endpoint(item['from'])} -> #{edge_endpoint(item['to'])} (#{item['via']})"
+          detail.empty? ? line : "#{line}: #{detail}"
+        end
+
+        # A nil endpoint (an ambiguous foreign-key owner, for example) prints
+        # as a placeholder rather than an empty string.
+        #
+        # @param value [String, nil]
+        # @return [String]
+        def edge_endpoint(value)
+          value.nil? ? '(unresolved)' : value
+        end
+
+        # @param value [Object] a detail hash value; arrays (e.g. `ambiguous_owners`) join
+        #   as plain text instead of printing Ruby's `Array#inspect` syntax.
+        # @return [Object]
+        def edge_value(value)
+          value.is_a?(Array) ? value.join(', ') : value
+        end
+
         def render_plain_traversal(label, data)
           root = fetch_key(data, :root)
           found = data[:found] || data['found']
@@ -241,11 +281,19 @@ module Woods
           nodes.each do |id, info|
             depth = fetch_key(info, :depth) || 0
             deps = fetch_key(info, :deps, [])
+            # Set by the reader only in a graph spanning more than one database.
+            database = fetch_key(info, :database)
             indent = '  ' * (depth + 1)
-            lines << "#{indent}#{id}"
+            lines << "#{indent}#{id}#{" [#{database}]" if database}"
             deps.each { |d| lines << "#{indent}  -> #{d}" }
           end
 
+          if fetch_key(data, :nodes_total)
+            offset = fetch_key(data, :nodes_offset, 0)
+            position = offset.positive? ? " from offset #{offset}" : ''
+            lines << "  (showing #{nodes.size} of #{fetch_key(data, :nodes_total)}#{position}; truncated)"
+          end
+
           lines.join("\n").rstrip
         end
       end