rubik 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 220e106421fc0a5692890a2c3f3e7ba2296661c5ce60a96f62a3f8d5fcaa4c0a
-  data.tar.gz: 1a287e603bb553b11ebc1e0187f4a0d00e8e6b17a68c005311bc144635a1696a
+  metadata.gz: 38e5cb4f6771198e0b32d67b8ec5fabd72ae886fbb7b1fcdccffddd4c9e1cedb
+  data.tar.gz: 820079f88cde99e3e82caa3214b1f6d11e9bcbe4ee773f879a50370b208e1287
 SHA512:
-  metadata.gz: c02dbe25a9cc8a3af6a4c24187fc9115ad8ae5077c49e4842e2f03151ade01bedc4cc5e4709056a388a3934151b4a361422c30b1de92158e3d4c6d6d87c56743
-  data.tar.gz: db9835fd0913e3fad74ab68bdbd25137df95544579b2beed718237d09699e378fb2cbfde7da9341785f407d3aea9a43b98aedec34df1305278b93ddc3434adb6
+  metadata.gz: a92d6f084b0694076803d7240559c0a0bb68c52f06543d4ab0ec5a21af071d419e47e1c42db95b3fd324e43ffbaffbdd7c41834032f7a279b09a42be5df23289
+  data.tar.gz: f0de254f34eac1cc3a373b6e3cd07f69192f90fda8e73269fd23ff12b27c2a66aaa737db114e30286404e47de5391f8938b23c9ef642e44330502f19e730ab53

data/ATTRIBUTION.md

@@ -121,7 +121,7 @@ SOFTWARE.
 | **`strings-ansi`** | Piotr Murach | MIT | ANSI-aware string truncation and alignment for REPL formatters. |
 | **`reline`** | Hiroshi SHIBATA & Ruby Team | Ruby License / BSD-2-Clause | Line-editing, history navigation, autocompletion hooks, and headless terminal adaptation. |
 | **`prism`** | Kevin Newton & Ruby Core Team | MIT | High-performance Ruby parsing and AST extraction ([`Rubik::AST::RubyExtractor`](lib/rubik/ast/ruby_extractor.rb)). |
-| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,800+ unit, integration, and contract tests. |
+| **`minitest`** | Ryan Davis & seattlerb | MIT | Fast, modular test suite powering Rubik's 3,850+ unit, integration, and contract tests. |
 | **`rubocop`** | Bozhidar Batsov & contributors | MIT | Static code analysis, style enforcement, and architectural hygiene gates. |
 | **`benchmark`, `logger`, `pstore`, `reline`, `fiddle`** | Ruby core / rubygems teams | Ruby License / BSD-2-Clause | Ruby stdlib gems pinned explicitly in `rubik.gemspec` as they are unbundled from the default set in Ruby 3.4/3.5. |
 

data/CHANGELOG.md

@@ -6,9 +6,112 @@ commits, 2026-08-23 → 2026-10-09, see `git log`).
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
-## Unreleased
+## [0.4.0] - 2026-10-27
 
-Nothing yet.
+A diagnostics-reach minor: the diagnostics engine gains native
+parsers for Python tracebacks, TypeScript/JavaScript compiler
+output, and C++ error streams, alongside an AST-graph correctness
+restore, multibyte-safe truncation, and hot-path performance
+streamlines.
+
+### Added
+
+- **Diagnostics parser speaks Python, TypeScript/JavaScript, and
+  C++ (#286):** Python tracebacks (`File "...", line N` headers
+  paired with exception lines) parse into structured entries with
+  syntax-vs-type categorization; tsc-style `file(line,col): error
+  TSxxxx:` and `file:line:col: error` streams parse with error codes
+  and columns; C++ compilers route through the existing zig/c
+  parser. Unrecognized output still falls back to the generic
+  parser.
+
+### Fixed
+
+- **AST plain-symbol lookups on file removal restored (#280, #282):**
+  PR #281's squash merge accidentally reverted the #280 work; the
+  reviewed restoration is back on main. Removing a file from the AST
+  graph again repairs only the plain symbol entries it owned, and
+  `SymbolMap` completes Hash parity (single-yield `#each`,
+  `#to_h` applied once, `#dig` raising `TypeError` on non-diggable
+  intermediates), with removal/parity edge cases covered by tests.
+- **Truncator output is valid UTF-8 at every step (#284):** byteslice
+  cutting multibyte characters midway left invalid byte sequences in
+  intermediate results and undercounted `omitted_chars`; sliced
+  substrings are now scrubbed immediately in all strategies, so
+  line counts and character statistics stay accurate.
+
+### Performance
+
+- **Python `extract_calls` is cheaper (#278):** the string scan and
+  filtering path is streamlined, cutting work in hot call-extraction.
+- **TokenEstimator message field evaluation streamlined (#279):**
+  per-message field access in token estimation is evaluated more
+  cheaply.
+- **Security classifier avoids per-call allocations (#283):** the
+  home-token list in `Engine#system_path?` is hoisted into a frozen
+  constant, removing an array allocation on every system-path check.
+
+### Changed
+
+- **No-behavior-change decompositions (#281, #285):**
+  `StepExecutor#execute_registered_tool` is split into private
+  helpers, with the file kept under the 350-line hygiene cap, and
+  the LLM registry's `register_provider_spec` extracts
+  `build_provider_instance` and `register_models_catalog` helpers.
+
+## [0.3.5] - 2026-10-24
+
+A vakanuvis-durability patch: the chronicler's digest pipeline stops
+losing in-flight work and serving stale reads, LSP diagnostics and
+document sync get hardened across the board, and AST call
+extraction runs measurably cheaper.
+
+### Fixed
+
+- **vakanuvis recall and digest are durable (#266, #267, #268,
+  #270, #271, #272):** in-place memory and wiki edits now register
+  as durable content updates for digest dirty tracking; superseded
+  records no longer surface as exact recall hits or pass smoke
+  checks; annal write failures and harness shutdown no longer
+  strand targeted digest jobs or events enqueued after the STOP
+  marker; the pending digest queue is bounded when the distiller is
+  unavailable; and the rogue-memory sweep preserves canonical
+  `mem.*` aliases, superseding raw duplicates in the canonical
+  line's favor.
+- **LSP diagnostics and sync hardened (#252, closes #245–#251):**
+  diagnostic freshness is tracked per canonical document — stale
+  versioned publications are rejected and pending or unversioned
+  analysis is reported accurately; document state and LSP frame
+  writes are serialized, and transport failures propagate to wake
+  pending requests; text-document synchronization capabilities are
+  honored (unsupported dynamic registrations rejected, save
+  notifications sent when supported); server selection is separated
+  from document language IDs, with crash history retained across
+  short-lived restarts; and structured executable/argv server
+  configuration is supported through discovery, repair and client
+  startup without invoking a shell.
+- **Anthropic API key resolution hardened (#261):** the reported
+  hardcoded-secret finding is confirmed a false positive (the
+  literal env-var name in error messages); `resolve_api_key` now
+  falls back to `ANTHROPIC_API_KEY` defensively when the configured
+  environment-variable name is blank or empty.
+
+### Performance
+
+- **AST call extraction is cheaper (#277):** the Go, Rust and
+  TypeScript extractors use zero-capture lookahead regexes and
+  frozen keyword-exclusion Sets — 35–80% fewer allocations and
+  ~25–27% faster in hot call-extraction paths, verified
+  output-identical.
+
+### Changed
+
+- **No-behavior-change decompositions (#254–#265):** oversized
+  methods across the OpenAI-compatible provider, goal-turn driving,
+  the MCP/workspace/session/model/context command registrations,
+  buffer registration and apply, subagent spawn and adapter process
+  management were split into helpers — same behavior, reviewable
+  units.
 
 ## [0.3.4] - 2026-10-23
 

data/lib/rubik/adapter/process.rb

@@ -2,6 +2,7 @@
 
 require "open3"
 require "timeout"
+require_relative "../log"
 
 module Rubik
   module Adapter
@@ -19,17 +20,19 @@ module Rubik
               pid = wait_thr.pid
               begin
                 stdin.close
-              rescue
-                nil
+              rescue StandardError => e
+                Rubik::Log.debug(:adapter, "stdin close failed during process execution: #{e.class}: #{e.message}")
               end
               t_out = Thread.new do
                 stdout.read
-              rescue
+              rescue StandardError => e
+                Rubik::Log.debug(:adapter, "stdout read failed during process execution: #{e.class}: #{e.message}")
                 ""
               end
               t_err = Thread.new do
                 stderr.read
-              rescue
+              rescue StandardError => e
+                Rubik::Log.debug(:adapter, "stderr read failed during process execution: #{e.class}: #{e.message}")
                 ""
               end
               begin
@@ -40,13 +43,13 @@ module Rubik
               ensure
                 begin
                   t_out.kill
-                rescue
-                  nil
+                rescue StandardError => e
+                  Rubik::Log.debug(:adapter, "t_out kill failed: #{e.class}: #{e.message}")
                 end
                 begin
                   t_err.kill
-                rescue
-                  nil
+                rescue StandardError => e
+                  Rubik::Log.debug(:adapter, "t_err kill failed: #{e.class}: #{e.message}")
                 end
               end
             end

data/lib/rubik/ast/go_extractor.rb

@@ -8,6 +8,10 @@ module Rubik
     class GoExtractor
       include BodyLoader
 
+      EXCLUDED_KEYWORDS = Set.new(
+        ["func", "if", "for", "return", "make", "append", "len", "cap", "panic", "recover"]
+      ).freeze
+
       def self.extract(file_path, content = nil)
         new(file_path, content).extract
       end
@@ -105,9 +109,12 @@ module Rubik
         )
       end
 
+      # PERF: Uses zero-capture lookahead and frozen Set lookup to eliminate
+      # intermediate 2D scan arrays, flatten/uniq allocations, and per-call array creation (~25% speedup, ~80% fewer allocations).
       def extract_calls(body, self_name)
-        calls = body.scan(/\b([A-Za-z0-9_]+)\s*\(/).flatten.uniq
-        calls.reject { |c| c == self_name || ["func", "if", "for", "return", "make", "append", "len", "cap", "panic", "recover"].include?(c) }
+        calls = body.scan(/\b[A-Za-z0-9_]+(?=\s*\()/).uniq
+        calls.delete_if { |c| c == self_name || EXCLUDED_KEYWORDS.include?(c) }
+        calls
       end
 
       def find_closing_brace(start_idx)

data/lib/rubik/ast/graph.rb

@@ -216,10 +216,29 @@ module Rubik
         lang = CacheStore::LANGUAGE_MAP[ext] || "code"
 
         existing.each do |sym|
-          @symbols.delete(sym.name) if @symbols[sym.name] == sym
           @qualified_symbols.delete("#{lang}:#{file_path}##{sym.name}")
           @qualified_symbols.delete("#{lang}:#{sym.file}##{sym.name}") if sym.file
         end
+
+        removed = {}.compare_by_identity
+        existing.each { |sym| removed[sym] = true }
+        existing.map(&:name).uniq.each do |name|
+          next unless removed.key?(@symbols[name])
+
+          replacement = _find_remaining_symbol_unlocked(name)
+          replacement ? @symbols[name] = replacement : @symbols.delete(name)
+        end
+      end
+
+      # The plain map keeps the most recently indexed definition of a name, so
+      # fall back to the most recently indexed file that still defines it.
+      def _find_remaining_symbol_unlocked(name)
+        @file_symbols.reverse_each do |_file_path, syms|
+          syms.reverse_each do |sym|
+            return sym if sym.name == name
+          end
+        end
+        nil
       end
 
       def _get_file_symbols_unlocked(file_path)

data/lib/rubik/ast/graph_extensions.rb

@@ -2,7 +2,9 @@
 
 module Rubik
   module AST
-    class SymbolMap
+    class SymbolMap < Hash
+      FETCH_DEFAULT = Object.new.freeze
+
       def values
         qualified_values = @qualified_symbols.sort_by { |key, _symbol| key }.map(&:last)
         qualified_ids = {}.compare_by_identity
@@ -18,6 +20,92 @@ module Rubik
       def empty?
         super && @qualified_symbols.empty?
       end
+
+      def fetch(key, default = FETCH_DEFAULT)
+        if key?(key)
+          self[key]
+        elsif block_given?
+          yield(key)
+        elsif !default.equal?(FETCH_DEFAULT)
+          default
+        else
+          raise KeyError, "key not found: #{key.inspect}"
+        end
+      end
+
+      def include?(key)
+        key?(key)
+      end
+      alias member? include?
+
+      def keys
+        (super + @qualified_symbols.keys).uniq
+      end
+
+      def each(&)
+        return enum_for(:each) unless block_given?
+
+        combined = (Hash.instance_method(:to_a).bind_call(self) + @qualified_symbols.to_a).uniq(&:first)
+        combined.each(&)
+        self
+      end
+      alias each_pair each
+
+      def each_key(&)
+        return enum_for(:each_key) unless block_given?
+
+        keys.each(&)
+        self
+      end
+
+      def each_value(&)
+        return enum_for(:each_value) unless block_given?
+
+        values.each(&)
+        self
+      end
+
+      def assoc(key)
+        return nil unless key?(key)
+
+        [key, self[key]]
+      end
+
+      def to_h(&)
+        h = Hash.instance_method(:to_h).bind_call(self)
+        @qualified_symbols.each { |k, v| h[k] ||= v }
+        if block_given?
+          h.each_with_object({}) do |(k, v), acc|
+            nk, nv = yield(k, v)
+            acc[nk] = nv
+          end
+        else
+          h
+        end
+      end
+
+      def dig(key, *rest)
+        val = self[key]
+        return val if rest.empty? || val.nil?
+        return val.dig(*rest) if val.respond_to?(:dig)
+
+        raise TypeError, "#{val.class} does not have #dig method"
+      end
+
+      def slice(*keys_to_slice)
+        plain = {}
+        qual = {}
+        plain_key_check = Hash.instance_method(:key?).bind(self)
+        plain_fetch = Hash.instance_method(:[]).bind(self)
+        keys_to_slice.each do |k|
+          if plain_key_check.call(k)
+            plain[k] = plain_fetch.call(k)
+          elsif @qualified_symbols.key?(k)
+            qual[k] = @qualified_symbols[k]
+          end
+        end
+        SymbolMap.new(plain, qual)
+      end
     end
 
     class Graph

data/lib/rubik/ast/python_extractor.rb

@@ -86,12 +86,12 @@ module Rubik
 
       private
 
+      # PERF: Uses zero-capture lookahead, scan with uniq, and delete_if filtering
+      # to eliminate Set instantiation and block allocations (~12% faster, ~26% fewer allocations).
       def extract_calls(body, self_name)
-        calls = Set.new
-        body.scan(/\b[A-Za-z0-9_]+(?=\s*\()/) do |c|
-          calls << c unless c == self_name || EXCLUDED_KEYWORDS.include?(c)
-        end
-        calls.to_a
+        calls = body.scan(/\b[A-Za-z0-9_]+(?=\s*\()/).uniq
+        calls.delete_if { |c| c == self_name || EXCLUDED_KEYWORDS.include?(c) }
+        calls
       end
 
       def find_block_end(start_idx, base_indent)

data/lib/rubik/ast/rust_extractor.rb

@@ -8,6 +8,10 @@ module Rubik
     class RustExtractor
       include BodyLoader
 
+      EXCLUDED_KEYWORDS = Set.new(
+        ["fn", "pub", "async", "if", "for", "while", "loop", "match", "return", "let", "mut"]
+      ).freeze
+
       def self.extract(file_path, content = nil)
         new(file_path, content).extract
       end
@@ -91,9 +95,12 @@ module Rubik
 
       private
 
+      # PERF: Uses zero-capture lookahead and frozen Set lookup to eliminate
+      # intermediate 2D scan arrays, flatten/uniq allocations, and per-call array creation (~27% speedup, ~80% fewer allocations).
       def extract_calls(body, self_name)
-        calls = body.scan(/\b([A-Za-z0-9_]+)(?:!|\s*\()/).flatten.uniq
-        calls.reject { |c| c == self_name || ["fn", "pub", "async", "if", "for", "while", "loop", "match", "return", "let", "mut"].include?(c) }
+        calls = body.scan(/\b[A-Za-z0-9_]+(?=!|\s*\()/).uniq
+        calls.delete_if { |c| c == self_name || EXCLUDED_KEYWORDS.include?(c) }
+        calls
       end
 
       def find_closing_brace(start_idx)

data/lib/rubik/ast/typescript_extractor.rb

@@ -8,6 +8,14 @@ module Rubik
     class TypeScriptExtractor
       include BodyLoader
 
+      EXCLUDED_KEYWORDS = Set.new(
+        [
+          "if", "else", "for", "while", "do", "switch", "case", "return", "catch", "function", "import",
+          "require", "typeof", "instanceof", "throw", "new", "try", "finally", "delete", "void", "yield",
+          "await", "super", "class", "interface", "type", "const", "let", "var"
+        ]
+      ).freeze
+
       def self.extract(file_path, content = nil)
         new(file_path, content).extract
       end
@@ -227,14 +235,12 @@ module Rubik
         [sym, next_i]
       end
 
+      # PERF: Uses zero-capture lookahead and frozen Set lookup to eliminate
+      # intermediate 2D scan arrays, flatten/uniq allocations, and per-call array creation (~27% speedup, ~35% fewer allocations).
       def extract_calls(body, self_name)
-        calls = body.scan(/\b([A-Za-z0-9_$]+)\s*\(/).flatten.uniq
-        keywords = [
-          "if", "else", "for", "while", "do", "switch", "case", "return", "catch", "function", "import",
-          "require", "typeof", "instanceof", "throw", "new", "try", "finally", "delete", "void", "yield",
-          "await", "super", "class", "interface", "type", "const", "let", "var"
-        ]
-        calls.reject { |c| c == self_name || keywords.include?(c) }
+        calls = body.scan(/\b[A-Za-z0-9_$]+(?=\s*\()/).uniq
+        calls.delete_if { |c| c == self_name || EXCLUDED_KEYWORDS.include?(c) }
+        calls
       end
 
       def find_closing_brace(start_idx)

data/lib/rubik/buffer/manager.rb

@@ -317,82 +317,20 @@ module Rubik
         @monitor.synchronize do
           applied_paths = []
           conflicts = []
-          keys_to_apply = if target_paths
-                            Array(target_paths).map { |p| sanitize_path(p, for_write: true) }
-                          else
-                            @dirty_files.keys.dup
-                          end
-
+          keys_to_apply = determine_keys_to_apply(target_paths)
           effective_policy = (policy || external_modification_policy).to_s.downcase
 
           keys_to_apply.each_with_index do |rel_path, index|
             next unless @dirty_files.key?(rel_path)
+            next unless validate_and_clean_garbage(rel_path)
 
-            unless PathValidator.valid?(rel_path)
-              @dirty_files.delete(rel_path)
-              @buffer.delete(rel_path)
-              @original_hashes.delete(rel_path)
-              @event_bus&.emit(:buffer_garbage_skipped, path: rel_path)
-              next
-            end
-
-            baseline = @original_hashes[rel_path]
-            current_disk = disk_hash(rel_path)
-
-            conflict = if baseline
-                         current_disk != baseline
-                       else
-                         !current_disk.nil?
-                       end
-
-            if conflict && effective_policy != "overwrite"
+            if external_conflict?(rel_path) && effective_policy != "overwrite"
               conflicts << rel_path
               @event_bus&.emit(:buffer_apply_conflict, paths: conflicts, path: rel_path)
               next
             end
 
-            full_path = File.expand_path(rel_path, @root_dir)
-
-            # TOCTOU close: re-verify containment immediately before the
-            # atomic write — a symlink planted between write-time sanitize
-            # and apply! must not redirect the write outside the workspace.
-            # Fail loud: an untrustworthy path is an attack signal or a
-            # mid-flight root misconfiguration, not a content problem; the
-            # entry stays dirty for a retry after remediation.
-            containment_kind, = containment_root(full_path)
-            unless containment_kind
-              @event_bus&.emit(:buffer_containment_blocked, path: rel_path)
-              # Commit what this run has seen so "apply! rewrites
-              # last_conflicts on every run" holds for readers (AutoApply's
-              # report_conflicts) even on the failure path.
-              @last_conflicts = conflicts
-              raise apply_failure(
-                "Write blocked: '#{rel_path}' resolves outside all allowed roots at apply time " \
-                "(possible symlink swap since buffering). Re-verify the workspace and retry.",
-                kind: :containment_blocked, applied: applied_paths, failed: rel_path,
-                pending: pending_after(keys_to_apply, index), conflicts: conflicts
-              )
-            end
-
-            content = @buffer[rel_path]
-
-            begin
-              Rubik::Platform.atomic_write(full_path, content)
-            rescue StandardError => e
-              @last_conflicts = conflicts
-              raise apply_failure(
-                "Apply failed for '#{rel_path}': #{e.class}: #{e.message}; " \
-                "#{applied_paths.empty? ? 'no file was written' : "already written: #{applied_paths.join(', ')}"}; " \
-                "#{pending_after(keys_to_apply, index).size} file(s) still dirty",
-                kind: :write_failed, applied: applied_paths, failed: rel_path,
-                pending: pending_after(keys_to_apply, index), conflicts: conflicts
-              ), cause: e
-            end
-
-            @original_hashes[rel_path] = Digest::SHA256.hexdigest(content)
-            @dirty_files.delete(rel_path)
-            @buffer.delete(rel_path)
-            applied_paths << rel_path
+            apply_single_entry(rel_path, index: index, keys_to_apply: keys_to_apply, applied_paths: applied_paths, conflicts: conflicts)
           end
 
           @last_conflicts = conflicts
@@ -443,6 +381,80 @@ module Rubik
 
       private
 
+      def determine_keys_to_apply(target_paths)
+        if target_paths
+          Array(target_paths).map { |p| sanitize_path(p, for_write: true) }
+        else
+          @dirty_files.keys.dup
+        end
+      end
+
+      def validate_and_clean_garbage(rel_path)
+        return true if PathValidator.valid?(rel_path)
+
+        @dirty_files.delete(rel_path)
+        @buffer.delete(rel_path)
+        @original_hashes.delete(rel_path)
+        @event_bus&.emit(:buffer_garbage_skipped, path: rel_path)
+        false
+      end
+
+      def external_conflict?(rel_path)
+        baseline = @original_hashes[rel_path]
+        current_disk = disk_hash(rel_path)
+
+        if baseline
+          current_disk != baseline
+        else
+          !current_disk.nil?
+        end
+      end
+
+      def apply_single_entry(rel_path, index:, keys_to_apply:, applied_paths:, conflicts:)
+        full_path = File.expand_path(rel_path, @root_dir)
+
+        # TOCTOU close: re-verify containment immediately before the
+        # atomic write — a symlink planted between write-time sanitize
+        # and apply! must not redirect the write outside the workspace.
+        # Fail loud: an untrustworthy path is an attack signal or a
+        # mid-flight root misconfiguration, not a content problem; the
+        # entry stays dirty for a retry after remediation.
+        containment_kind, = containment_root(full_path)
+        unless containment_kind
+          @event_bus&.emit(:buffer_containment_blocked, path: rel_path)
+          # Commit what this run has seen so "apply! rewrites
+          # last_conflicts on every run" holds for readers (AutoApply's
+          # report_conflicts) even on the failure path.
+          @last_conflicts = conflicts
+          raise apply_failure(
+            "Write blocked: '#{rel_path}' resolves outside all allowed roots at apply time " \
+            "(possible symlink swap since buffering). Re-verify the workspace and retry.",
+            kind: :containment_blocked, applied: applied_paths, failed: rel_path,
+            pending: pending_after(keys_to_apply, index), conflicts: conflicts
+          )
+        end
+
+        content = @buffer[rel_path]
+
+        begin
+          Rubik::Platform.atomic_write(full_path, content)
+        rescue StandardError => e
+          @last_conflicts = conflicts
+          raise apply_failure(
+            "Apply failed for '#{rel_path}': #{e.class}: #{e.message}; " \
+            "#{applied_paths.empty? ? 'no file was written' : "already written: #{applied_paths.join(', ')}"}; " \
+            "#{pending_after(keys_to_apply, index).size} file(s) still dirty",
+            kind: :write_failed, applied: applied_paths, failed: rel_path,
+            pending: pending_after(keys_to_apply, index), conflicts: conflicts
+          ), cause: e
+        end
+
+        @original_hashes[rel_path] = Digest::SHA256.hexdigest(content)
+        @dirty_files.delete(rel_path)
+        @buffer.delete(rel_path)
+        applied_paths << rel_path
+      end
+
       # Single source of boundary containment for both the sanitize_path
       # entry check and the apply! re-verification. Returns [kind, dir] with
       # kind :root / :external (dir is the LEXICAL matched root/external

data/lib/rubik/config/defaults.rb

@@ -171,6 +171,7 @@ module Rubik
             "distiller" => true,
             "max_steps" => 8,
             "flush_events" => 10,
+            "max_digest_jobs" => 100,
             "model" => nil,
             "retention" => "supersede",
             "root_turns" => true

data/lib/rubik/context/git_lister.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "../log"
 
 module Rubik
   module Context
@@ -27,7 +28,8 @@ module Rubik
         res.map! { |p| p.tr("\\", "/") } if out.include?("\\")
         res.uniq!
         res
-      rescue StandardError
+      rescue StandardError => e
+        Rubik::Log.debug(:context, "git ls-files execution failed for #{root_dir}: #{e.class}: #{e.message}")
         nil
       end