woods 1.6.1 → 1.6.3

data/lib/woods/console/sql_noise_stripper.rb

@@ -24,7 +24,7 @@ module Woods
     #   SqlNoiseStripper.strip_literals("SELECT 'it\\'s ok' FROM t", dialect: :mysql)
     #   # => "SELECT '' FROM t"
     #
-    module SqlNoiseStripper
+    module SqlNoiseStripper # rubocop:disable Metrics/ModuleLength
       # Strips SQL line comments (`-- ...`) and block comments (`/* ... */`).
       # Line comments are stripped to (but not including) the newline so that
       # newline-separated statement structure is preserved for callers that
@@ -40,7 +40,7 @@ module Woods
 
       def self.strip_comments(sql)
         out = sql.gsub(LINE_COMMENT, '')
-        out.gsub(BLOCK_COMMENT, '')
+        out.gsub(BLOCK_COMMENT, ' ')
       end
 
       # Strips single-quoted string literals and (for the `:postgres` dialect)
@@ -53,7 +53,7 @@ module Woods
       # single-quote scanner.
       #
       # @param sql [String] the SQL string to process
-      # @param dialect [Symbol] `:postgres` (default) or `:mysql`.
+      # @param dialect [Symbol] `:postgres` (default), `:mysql`, or `:sqlite`.
       #   - `:postgres` — single-quoted strings support `''` as an apostrophe
       #     escape. Backslash is treated literally and does not escape quotes.
       #     Dollar-quoted strings (`$$...$$`, `$tag$...$tag$`) are also stripped.
@@ -61,13 +61,14 @@ module Woods
       #     and `''` (doubled-quote) as apostrophe escapes. Dollar-quoted strings
       #     are also stripped (MySQL does not use them, but stripping them is
       #     harmless and keeps the two dialects consistent).
+      #   - `:sqlite` — doubled apostrophes escape strings; dollar signs stay literal.
       # @return [String] a new string with all string literals replaced by `''`
       # @raise [ArgumentError] if an unsupported dialect is provided
       DOLLAR_QUOTED = /\$(\w*)\$.*?\$\1\$/m
       SINGLE_QUOTED_POSTGRES = /'(?:''|[^'])*'/m
       SINGLE_QUOTED_MYSQL    = /'(?:\\.|''|[^'])*'/m
 
-      SUPPORTED_DIALECTS = %i[postgres mysql].freeze
+      SUPPORTED_DIALECTS = %i[postgres mysql sqlite].freeze
       private_constant :SUPPORTED_DIALECTS
 
       def self.strip_literals(sql, dialect: :postgres)
@@ -77,7 +78,7 @@ module Woods
 
         # Strip dollar-quoted strings first so stray apostrophes inside them
         # do not interfere with the single-quote scanner.
-        out = sql.gsub(DOLLAR_QUOTED, "''")
+        out = dialect == :sqlite ? sql : sql.gsub(DOLLAR_QUOTED, "''")
 
         pattern = dialect == :mysql ? SINGLE_QUOTED_MYSQL : SINGLE_QUOTED_POSTGRES
         out.gsub(pattern, "''")
@@ -98,7 +99,7 @@ module Woods
       # character rather than swallowing the rest of the statement.
       #
       # @param sql [String] the SQL string to process
-      # @param dialect [Symbol] `:postgres` (default) or `:mysql` — controls
+      # @param dialect [Symbol] `:postgres` (default), `:mysql`, or `:sqlite` — controls
       #   single-quote escape rules (see {.strip_literals}).
       # @return [String] a new string with comments removed and every string
       #   literal replaced by `''`
@@ -126,7 +127,16 @@ module Woods
               out << ch
               i += 1
             end
-          elsif ch == '$' && (tag = dollar_tag_at(sql, i))
+          elsif ['"', '`'].include?(ch)
+            close = quoted_identifier_end(sql, i, ch)
+            if close
+              out << sql[i...close]
+              i = close
+            else
+              out << ch
+              i += 1
+            end
+          elsif dialect != :sqlite && ch == '$' && (tag = dollar_tag_at(sql, i))
             close = sql.index(tag, i + tag.length)
             if close
               out << "''"
@@ -141,6 +151,7 @@ module Woods
           elsif ch == '/' && sql[i + 1] == '*'
             close = sql.index('*/', i + 2)
             if close
+              out << ' '
               i = close + 2
             else
               # Unterminated block comment: never under-detect. Leave it in
@@ -158,6 +169,23 @@ module Woods
         out
       end
 
+      # Preserve quoted identifiers while shielding their comment markers.
+      # @api private
+      def self.quoted_identifier_end(sql, start, quote)
+        i = start + 1
+        while i < sql.length
+          if sql[i] == quote
+            return i + 1 unless sql[i + 1] == quote
+
+            i += 2
+          else
+            i += 1
+          end
+        end
+        nil
+      end
+      private_class_method :quoted_identifier_end
+
       # Regexp matching a PostgreSQL dollar-quote opening tag (`$$` or
       # `$tag$`) at the start of the given slice.
       DOLLAR_TAG = /\A\$\w*\$/

data/lib/woods/console/sql_table_scanner.rb

@@ -120,11 +120,11 @@ module Woods
       #
       # @param sql [String, nil] the SQL string to scan
       # @return [Array<String>] identifiers in first-encounter order, deduplicated
-      def self.identifiers_in(sql)
+      def self.identifiers_in(sql, dialect: nil)
         return [] if sql.nil? || sql.empty?
 
         results = []
-        %i[postgres mysql].each do |dialect|
+        (dialect ? [dialect] : %i[postgres mysql]).each do |dialect|
           stripped = strip_noise(sql, dialect: dialect)
           collect_join_identifiers(stripped, results)
           collect_from_identifiers(stripped, results)
@@ -132,6 +132,49 @@ module Woods
         results.uniq
       end
 
+      # Table-factor prefixes, retaining commas after balanced subqueries and
+      # JOIN predicates. Each nested FROM/JOIN is also scanned independently.
+      # @param sql [String] noise-stripped SQL
+      # @return [Array<String>]
+      def self.relation_factors(sql)
+        sql.to_enum(:scan, /\b(?:FROM|JOIN)\s+/i).flat_map do
+          suffix = sql[Regexp.last_match.end(0)..]
+          split_top_level_commas(relation_clause(suffix))
+        end
+      end
+
+      # Quoted tokens shield punctuation and clause words; a closing parenthesis
+      # at depth zero ends this query's clause, not a nested table expression.
+      def self.relation_clause(suffix)
+        depth = 0
+        tokens = /
+          "(?:[^"]|"")*"|`(?:[^`]|``)*`|''|[()]|
+          \b(?:WHERE|GROUP|HAVING|ORDER|LIMIT|OFFSET|UNION|INTERSECT|EXCEPT|WINDOW)\b
+        /ix
+        suffix.to_enum(:scan, tokens).each do
+          token = Regexp.last_match[0]
+          start = Regexp.last_match.begin(0)
+          finish = Regexp.last_match.end(0)
+          boundary = token == ')' || relation_keyword_boundary?(suffix[0...start], suffix[finish..], token)
+          return suffix[0...start] if depth.zero? && boundary
+
+          depth += 1 if token == '('
+          depth -= 1 if token == ')'
+        end
+        suffix
+      end
+      private_class_method :relation_clause
+
+      def self.relation_keyword_boundary?(prefix, rest, token)
+        return false unless token.match?(/\A[A-Za-z]/)
+        return false if prefix.strip.empty? || prefix.match?(/(?:,|\bAS)\s*\z/i) || rest.lstrip.start_with?(',')
+        return rest.match?(/\A\s+BY\b/i) if %w[GROUP ORDER].include?(token.upcase)
+        return rest.match?(/\A\s+\w+\s+AS\b/i) if token.casecmp?('WINDOW')
+
+        true
+      end
+      private_class_method :relation_keyword_boundary?
+
       # @api private
       # Comments and literals must be stripped in a single combined pass —
       # stripping them separately lets a comment marker inside a literal
@@ -153,12 +196,9 @@ module Woods
 
       # @api private
       def self.collect_from_identifiers(sql, results)
-        sql.scan(FROM_CLAUSE) do
-          clause = Regexp.last_match[:clause]
-          split_top_level_commas(clause).each do |chunk|
-            ident = lead_identifier(chunk)
-            results << ident if ident
-          end
+        relation_factors(sql).each do |chunk|
+          ident = lead_identifier(chunk)
+          results << ident if ident
         end
       end
       private_class_method :collect_from_identifiers
@@ -169,7 +209,7 @@ module Woods
         depth = 0
         buf = +''
         parts = []
-        clause.each_char do |ch|
+        clause.scan(/"(?:[^"]|"")*"|`(?:[^`]|``)*`|''|./m).each do |ch|
           case ch
           when '('
             depth += 1

data/lib/woods/console/sql_validator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'woods/console/sql_noise_stripper'
+require 'woods/console/sqlite_read_guard'
 
 # @see Woods
 module Woods
@@ -95,17 +96,17 @@ module Woods
         [kw, /\b#{kw}\b/i]
       end.freeze
 
-      # Frozen map of dangerous function name => regex matching a call to that function.
-      # Used by {#check_dangerous_functions!}.
-      DANGEROUS_FUNCTION_REGEXES = DANGEROUS_FUNCTIONS.to_h do |func|
-        [func, /\b#{func}\s*\(/i]
-      end.freeze
+      # @param dialect [Symbol, nil] Known connection dialect, when available
+      def initialize(dialect: nil)
+        @dialect = dialect
+      end
 
       # @raise [SqlValidationError] if the SQL is not a safe read-only statement
       def validate!(sql)
         raise SqlValidationError, 'SQL is empty' if sql.nil? || sql.strip.empty?
 
         normalized = sql.strip
+        SqliteReadGuard.validate!(normalized) if @dialect == :sqlite
 
         # Reject multiple statements (semicolons not inside string literals)
         if contains_multiple_statements?(normalized)
@@ -152,7 +153,7 @@ module Woods
       # @param sql [String]
       # @return [Boolean]
       def contains_multiple_statements?(sql)
-        stripped = SqlNoiseStripper.strip_noise(sql)
+        stripped = SqlNoiseStripper.strip_noise(sql, dialect: @dialect || :postgres)
         stripped.include?(';')
       end
 
@@ -191,8 +192,12 @@ module Woods
       # @param sql [String]
       # @raise [SqlValidationError] if a dangerous function is found
       def check_dangerous_functions!(sql)
-        DANGEROUS_FUNCTION_REGEXES.each do |func, pattern|
-          raise SqlValidationError, "Rejected: dangerous function #{func} is not allowed" if sql.match?(pattern)
+        view = SqlNoiseStripper.strip_noise(sql, dialect: @dialect || :postgres)
+        view.scan(/(?:"([^"\n]+)"|`([^`]+)`|\b([a-z_][a-z0-9_]*))\s*\(/i) do |quoted, backtick, bare|
+          func = (quoted || backtick || bare).downcase
+          next unless DANGEROUS_FUNCTIONS.include?(func)
+
+          raise SqlValidationError, "Rejected: dangerous function #{func} is not allowed"
         end
       end
 

data/lib/woods/console/sqlite_read_guard.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'woods/console/sql_noise_stripper'
+require 'woods/console/sql_table_scanner'
+
+module Woods
+  module Console
+    # Refuse SQLite-specific syntax outside the scanner's supported grammar.
+    # This is a conservative read boundary, not a general-purpose SQL parser.
+    module SqliteReadGuard
+      SIMPLE_IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+      UNSUPPORTED_SYNTAX = /\b(?:FROM|JOIN)(?=['"`(])/i
+      QUOTED_IDENTIFIER = /"(?:[^"]|"")*"|`(?:[^`]|``)*`/
+
+      # @param sql [String] SQL to execute on SQLite
+      # @raise [SqlValidationError] when an identifier or table factor cannot be checked
+      # @return [void]
+      def self.validate!(sql)
+        view = SqlNoiseStripper.strip_noise(sql, dialect: :sqlite)
+        refuse! if view.match?(UNSUPPORTED_SYNTAX)
+        SqlTableScanner.relation_factors(view).each do |factor|
+          factor.scan(QUOTED_IDENTIFIER) { |quoted| refuse! unless quoted[1...-1].match?(SIMPLE_IDENTIFIER) }
+          refuse! unless supported_factor?(factor.strip)
+        end
+      end
+
+      # A SELECT/WITH subquery has its own independently scanned table factors.
+      # Parenthesized table groups and string-quoted names are refused rather
+      # than silently omitted from the blocked-table scan.
+      def self.supported_factor?(factor)
+        return true if factor.match?(/\A\(\s*(?:SELECT|WITH)\b/i)
+
+        match = SqlTableScanner::LEAD_IDENT.match(factor)
+        match && factor[match.end(0)..].match?(/\A(?:\s|,|\)|\z)/)
+      end
+      private_class_method :supported_factor?
+
+      def self.refuse!
+        raise SqlValidationError,
+              'Rejected: unsupported SQLite identifier or table-reference syntax. ' \
+              'Use simple bare or double-quoted identifiers and SELECT subqueries.'
+      end
+      private_class_method :refuse!
+    end
+  end
+end

data/lib/woods/console/table_gate.rb

@@ -32,10 +32,10 @@ module Woods
 
       def active? = !(@blocked_bare.empty? && @blocked_qualified.empty?)
 
-      def check_sql!(sql)
+      def check_sql!(sql, dialect: nil)
         return unless active? && sql&.length&.positive?
 
-        SqlTableScanner.identifiers_in(sql).each do |raw|
+        SqlTableScanner.identifiers_in(sql, dialect: dialect).each do |raw|
           raise TableGateError, reject_message(raw) if blocked?(raw)
         end
       end

data/lib/woods/console/tool_specs.rb

@@ -5,7 +5,7 @@
 # Metrics/ModuleLength is disabled here because the module body is almost
 # entirely declarative data, not imperative logic. Decomposition would just
 # scatter the tool catalogue across many files with no readability gain.
-# rubocop:disable Metrics/ModuleLength
+# rubocop:disable-next Metrics/ModuleLength
 module Woods
   module Console
     module Server
@@ -549,4 +549,3 @@ module Woods
     end
   end
 end
-# rubocop:enable Metrics/ModuleLength

data/lib/woods/console/tools/tier1.rb

@@ -98,13 +98,12 @@ module Woods
         # @param scope [Hash, nil] Filter conditions
         # @param columns [Array<String>, nil] Columns to include
         # @return [Hash] Bridge request
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def console_recent(model:, order_by: 'created_at', direction: 'desc', limit: 10, scope: nil, columns: nil)
           limit = [limit, 50].min
           { tool: 'recent', params: { model: model, order_by: order_by, direction: direction,
                                       limit: limit, scope: scope, columns: columns }.compact }
         end
-        # rubocop:enable Metrics/ParameterLists
 
         # System health check.
         #

data/lib/woods/console/tools/tier4.rb

@@ -61,7 +61,7 @@ module Woods
         # @param scope [Hash, nil] Filter conditions
         # @param limit [Integer, nil] Row limit (max 10000)
         # @return [Hash] Bridge request
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def console_query(model:, select:, joins: nil, group_by: nil, having: nil, order: nil, scope: nil, limit: nil)
           limit = [limit, MAX_QUERY_LIMIT].min if limit
           {
@@ -78,7 +78,6 @@ module Woods
             }.compact
           }
         end
-        # rubocop:enable Metrics/ParameterLists
       end
     end
   end

data/lib/woods/mcp/http_transport_options.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Woods
+  module MCP
+    # Keep the SDK DNS-rebinding guard aligned with Woods' explicit allowlist.
+    # Empty configuration retains the SDK's strict loopback defaults.
+    module HttpTransportOptions
+      def self.for(origins)
+        normalized = Array(origins).map { |origin| origin.strip.downcase.delete_suffix('/') }.reject(&:empty?)
+        return {} if normalized.empty?
+
+        hosts = normalized.filter_map do |origin|
+          uri = URI.parse(origin)
+          uri.host if %w[http https].include?(uri.scheme)
+        rescue URI::InvalidURIError
+          nil
+        end
+        { allowed_origins: normalized, allowed_hosts: hosts.uniq }
+      end
+    end
+  end
+end

data/lib/woods/mcp/server.rb

@@ -93,15 +93,12 @@ module Woods
             )
           end
 
-          server = ::MCP::Server.new(
+          server = VersionAwareServer.new(
             name: 'woods',
             version: Woods::VERSION,
             resources: resources,
             resource_templates: resource_templates
           )
-          # Rewrite "Tool not found" into version-aware update guidance for agents
-          # running against an older gem than the skill they're following assumes.
-          server.singleton_class.prepend(VersionAwareToolDispatch)
 
           define_lookup_tool(server, reader, respond, respond_err, renderer)
           define_search_tool(server, reader, respond, respond_err, renderer)
@@ -200,11 +197,7 @@ module Woods
           meta[:config_key] = config_key if config_key
           meta[:doc_link] = doc_link if doc_link
           meta.merge!(extra) unless extra.empty?
-          ::MCP::Tool::Response.new(
-            [{ type: 'text', text: message }],
-            error: true,
-            meta: meta
-          )
+          ::MCP::Tool::Response.new([{ type: 'text', text: message }], error: true, meta: meta)
         end
 
         def truncate_section(array, limit)

data/lib/woods/mcp/version_aware_tool_dispatch.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
+require 'mcp'
 require_relative '../update_check'
 
 module Woods
   module MCP
-    # Prepended onto a built +MCP::Server+ instance so that a call to a tool the
+    # Prepended before +MCP::Server+ initialization so that a call to a tool the
     # installed gem does not define produces version-aware, self-healing
     # guidance instead of a bare "Tool not found".
     #
@@ -12,8 +13,7 @@ module Woods
     # to call a tool that only exists in a later Woods release. The upstream
     # +mcp+ gem raises +RequestHandlerError("Tool not found: X")+ with no seam to
     # customize the message, so we intercept the built server's +call_tool+
-    # (dispatched directly by +handle_request+, so a prepend on the instance is
-    # honored on both the stdio and HTTP transports) and re-raise with the
+    # before the SDK captures its bound handler method and re-raise with the
     # installed version plus an update hint the agent can relay to the user.
     #
     # Only the genuine tool-not-found case is rewritten; every other
@@ -43,5 +43,11 @@ module Woods
         error.error_type == :invalid_params && error.message.to_s.start_with?('Tool not found:')
       end
     end
+
+    # MCP 0.23 captures method(:call_tool) during initialization. The override
+    # must already exist then; a later singleton prepend misses that handler.
+    class VersionAwareServer < ::MCP::Server
+      prepend VersionAwareToolDispatch
+    end
   end
 end

data/lib/woods/retrieval/query_classifier.rb

@@ -30,9 +30,8 @@ module Woods
         debug: /\b(bug|error|fix|broken|failing|wrong|issue|problem|crash|exception)\b/i,
         implement: /\b(implement|add|create|build|write|make|generate)\b/i,
         compare: /\b(compare|difference|vs|versus|between|contrast)\b/i,
-        # rubocop:disable Layout/LineLength
+        # rubocop:disable-next Layout/LineLength
         framework: /\b(how does rails|what does rails|rails .+ work|work.+\brails\b|in rails\b|activerecord|actioncontroller|activejob|actionmailer|actioncable|actiontext|activestorage|solid_queue|solid_cache|solid_cable|kamal|propshaft|importmap|hotwire|turbo|stimulus|zeitwerk)\b/i,
-        # rubocop:enable Layout/LineLength
         reference: /\b(show me|what is|what are|list|options for|api|interface|signature)\b/i,
         understand: /\b(how|why|explain|understand|what happens|describe|overview)\b/i
       }.freeze

data/lib/woods/session_tracer/middleware.rb

@@ -85,7 +85,7 @@ module Woods
       # @param env [Hash] Rack environment
       # @param status [Integer] HTTP response status
       # @param duration_ms [Integer] Request duration in milliseconds
-      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable-next Metrics/MethodLength
       def record_request(env, status, duration_ms)
         path = env['PATH_INFO'] || ''
         return if excluded?(path)
@@ -116,7 +116,6 @@ module Woods
 
         @store.record(session_id, request_data)
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Extract session ID: X-Trace-Session header first, then session cookie, then fallback.
       #

data/lib/woods/session_tracer/session_flow_assembler.rb

@@ -24,7 +24,7 @@ module Woods
     #   doc = assembler.assemble("abc123", budget: 8000, depth: 1)
     #   puts doc.to_context
     #
-    # rubocop:disable Metrics/ClassLength
+    # rubocop:disable-next Metrics/ClassLength
     class SessionFlowAssembler
       ASYNC_TYPES = %w[job mailer].to_set.freeze
 
@@ -41,7 +41,7 @@ module Woods
       # @param budget [Integer] Maximum token budget (default: 8000)
       # @param depth [Integer] Expansion depth (0=metadata only, 1=direct deps, 2+=full flow)
       # @return [SessionFlowDocument] The assembled document
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       def assemble(session_id, budget: 8000, depth: 1)
         requests = @store.read(session_id)
         return empty_document(session_id) if requests.empty?
@@ -89,7 +89,6 @@ module Woods
           token_count: token_count
         )
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       private
 
@@ -115,7 +114,7 @@ module Woods
       # Resolve dependencies for a unit, separating sync deps from async side effects.
       #
       # @return [Array<String>] Non-async dependency identifiers added
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
       def resolve_dependencies(unit_id, seen_units, context_pool,
                                side_effects, step, dependency_map, depth)
         graph = @reader.dependency_graph
@@ -154,7 +153,6 @@ module Woods
 
         added
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ParameterLists, Metrics/PerceivedComplexity
 
       # Expand transitive dependencies (depth 2+).
       #
@@ -249,6 +247,5 @@ module Woods
         SessionFlowDocument.new(session_id: session_id)
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/woods/session_tracer/session_flow_document.rb

@@ -23,7 +23,7 @@ module Woods
     #   doc.to_markdown   # => human-readable document
     #   doc.to_context    # => LLM XML format
     #
-    # rubocop:disable Metrics/ClassLength
+    # rubocop:disable-next Metrics/ClassLength
     class SessionFlowDocument
       attr_reader :session_id, :steps, :context_pool, :side_effects,
                   :dependency_map, :token_count, :generated_at
@@ -35,7 +35,7 @@ module Woods
       # @param dependency_map [Hash<String, Array<String>>] Unit -> dependency identifiers
       # @param token_count [Integer] Estimated total tokens
       # @param generated_at [String, nil] ISO8601 timestamp (defaults to now)
-      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable-next Metrics/ParameterLists
       def initialize(session_id:, steps: [], context_pool: {}, side_effects: [],
                      dependency_map: {}, token_count: 0, generated_at: nil)
         @session_id = session_id
@@ -46,7 +46,6 @@ module Woods
         @token_count = token_count
         @generated_at = generated_at || Time.now.utc.iso8601
       end
-      # rubocop:enable Metrics/ParameterLists
 
       # Serialize to a JSON-compatible Hash.
       #
@@ -86,7 +85,7 @@ module Woods
       # Render as human-readable Markdown.
       #
       # @return [String]
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def to_markdown
         lines = []
         lines << "## Session: #{@session_id}"
@@ -146,14 +145,13 @@ module Woods
 
         lines.join("\n")
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       # Render as LLM-consumable XML context.
       #
       # Follows the format from docs/CONTEXT_AND_CHUNKING.md.
       #
       # @return [String]
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def to_context
         lines = []
         header = "<session_context session_id=\"#{@session_id}\" requests=\"#{@steps.size}\" " \
@@ -201,7 +199,6 @@ module Woods
         lines << '</session_context>'
         lines.join("\n")
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       # @api private
       def self.deep_symbolize_keys(obj)
@@ -218,6 +215,5 @@ module Woods
       end
       private_class_method :deep_symbolize_keys
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/woods/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Woods
-  VERSION = '1.6.1'
+  VERSION = '1.6.3'
 end