rubik 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29ee7f0d84218a3bf3d2fe0699c2c37d7f260f6406231a46338f169410ae5c60
-  data.tar.gz: a600c600071a3267b8ab4cdfd0b2f755a2068f2cd8289949ae57e41383355d1b
+  metadata.gz: b8a3ecbfb98ba136f13800cc4a2d9ab68703b30c0086a3297c005abe6991d060
+  data.tar.gz: 72e1fff12c37f318f5e1b817d0ef88601110a83099f05edbd10c3d294564027c
 SHA512:
-  metadata.gz: fabc3ee65ba68ea6244727ba265232c1b05ac2bd06eee192a376dbfc6b6da746070bac6f129b750011803c2945f092096b5cd122065dd79bde224fcf9018892f
-  data.tar.gz: 30313695e55c4ae537d9d3acb27b1dbc7365d6db817e93b487e7612ce7c2921235deb7e92db6b2232e33b71569b65e1190f9c8c948bef8090fce093412fcc14c
+  metadata.gz: 7a17907eee5524e8053a9f73eb946ebe8766001a64ca17db048240837c1f154f7d2ba3650ce765e8ab830dc6da8840a1ea15e147490a03af1f5203d33b678294
+  data.tar.gz: 54d72614c2c6fd31a0ff482144c7953148d780516ea748f248027a6943d0b91c40fdfd64d1867036109f8b666bc3ce9ecb58516f0418f3c775335f249fead2b5

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

@@ -10,6 +10,108 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 Nothing yet.
 
+## [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
+
+A security-hardening patch: three injection/traversal findings in
+child-process enumeration, the docker sandbox driver and overlay
+storage are closed, scan-heavy paths got faster, and a wave of
+oversized REPL/LLM methods was decomposed with no behavior change.
+
+### Fixed
+
+- **Command injection in child-process enumeration (#238):**
+  `direct_child_pids` interpolated the target pid into backtick
+  shells (`pgrep -P #{pid}` / `ps --ppid #{pid}`); both lookups now
+  run through array-parameterized `Open3.capture2` calls, so pid
+  values never reach a shell for re-parsing.
+- **Command injection in the docker sandbox driver (#237):**
+  `DockerDriver#available?` and container cleanup built command
+  strings with interpolation (`docker rm -f #{container_name}`);
+  both now use array-form `system`, keeping shell metacharacters
+  inert.
+- **Path traversal in OverlayStorage (#232):** overlay directories
+  are validated against an allowlist of the four known overlay dirs
+  resolved under their trusted roots, manifests and every
+  command/tool write path are containment-checked, and traversal
+  attempts are rejected loudly with a `[SECURITY]` warning instead
+  of escaping the overlay root.
+
+### Performance
+
+- **Faster scanning internals (#220, #225, #227, #228, #244):**
+  storage indexing parses JSON lines with less string churn;
+  `Session::Replayer` streams with `File.foreach`;
+  `Buffer::Manager#all_files` prunes `.git` traversal;
+  `FuzzyMatcher#find_closest_subsequence` tightens its inner loop;
+  and `clean_utf8_deep` gains an allocation-free fast path
+  (Symbol#name validation, Hash-based cycle tracking, ~3.3x on
+  clean input). `Buffer::Manager#diff_all` also reads through
+  `Platform.read_text`, so on-disk content is UTF-8-tagged
+  consistently (#226).
+
+### Changed
+
+- **No-behavior-change decompositions (#231, #233, #234, #235,
+  #239, #240, #242, #243):** oversized REPL command registrations
+  (workspace allow-list, goal, agent providers, allow-cmd, LSP),
+  the LLM client's `post_json`, `GoalLedger::Patch#normalize_op`
+  and config `Defaults` scalar validation were split into helper
+  methods — same behavior, reviewable units.
+
 ## [0.3.3] - 2026-10-21
 
 A field-incident patch: subagent runs get a lifetime step ceiling,

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/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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "find"
 require "digest"
 require "pathname"
 require "monitor"
@@ -265,10 +266,27 @@ module Rubik
       # for callers that only need a fuzzy-match candidate list.
       def all_files
         buffer_keys = @monitor.synchronize { @buffer.keys }
+        return buffer_keys unless File.directory?(@root_dir)
+
         disk_files = begin
-          Dir.glob("**/*", File::FNM_DOTMATCH, base: @root_dir).reject do |f|
-            f.start_with?(".git") || File.directory?(File.expand_path(f, @root_dir))
+          files = []
+          root_size = @root_dir.bytesize
+          Find.find(@root_dir) do |path|
+            next if path.bytesize == root_size
+
+            rel = path.byteslice((root_size + 1)..-1)
+            rel = rel.tr("\\", "/") if File::ALT_SEPARATOR
+
+            if rel.start_with?(".git")
+              Find.prune if File.directory?(path)
+              next
+            end
+
+            next if File.directory?(path)
+
+            files << rel
           end
+          files
         rescue SystemCallError
           []
         end
@@ -282,7 +300,7 @@ module Rubik
 
         diffs = snapshot.map do |rel_path, new_content|
           full_path = File.expand_path(rel_path, @root_dir)
-          orig_content = File.exist?(full_path) ? Rubik::Platform.normalize_newlines(File.read(full_path)) : ""
+          orig_content = File.exist?(full_path) ? Rubik::Platform.normalize_newlines(Rubik::Platform.read_text(full_path)) : ""
           Diff.unified_diff(rel_path, orig_content, new_content)
         end
 
@@ -299,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
@@ -425,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

@@ -162,35 +162,26 @@ module Rubik
           "maestro_gate" => true,
           "auto_pause_on_network_error" => true,
           "reactive_wakeup" => true,
-          # Vakanüvis arka plan kronikçisi (storage/vakanuvis; plan
-          # 2026-10-04 K1-K9): deterministik annal + wiki derleyicisi.
-          # enabled: Düzlem 1 harness'i kur/kurulama; distiller: Düzlem 2
-          # LLM doğumu (token üst sınırı flush_events x max_steps);
-          # flush_events: damıtıcı doğumu için olay eşiği; model: nil =
-          # root provider; retention: supersede (iz bırak) | purge (sil);
-          # root_turns: REPL kök-turn'leri de annal'a yazılsın mı
-          # (root-turn planı 2026-10-04; kapalıyken abonelik kurulmaz).
+          # Vakanüvis arka plan kronikçisi (plan 2026-10-04 K1-K9): deterministik
+          # annal + wiki derleyicisi. enabled: harness kur/kurulama; distiller:
+          # Düzlem 2 LLM doğumu (bütçe: flush_events x max_steps); model: nil =
+          # root provider; retention: supersede|purge; root_turns: kök-turn annal'ı.
           "vakanuvis" => {
             "enabled" => true,
             "distiller" => true,
             "max_steps" => 8,
             "flush_events" => 10,
+            "max_digest_jobs" => 100,
             "model" => nil,
             "retention" => "supersede",
             "root_turns" => true
           },
-          # Pruner (repl/pruner): yarı deterministik KÖK pencere temizleyicisi.
-          # DEFAULT ON (kullanıcı kararı 2026-10-10) — deterministik yığın
-          # (trim_conversation_window! / ContextCompactor / EmergencyCompactor)
-          # her zaman güvenlik ağıdır; subagent kanalları bu özellikten asla
-          # etkilenmez; opt-out: "enabled" => false (kill-switch). enabled:
-          # harness'i kur (prune_context aracı + !prune komutu açılır);
-          # trigger_ratio: turn sonu pencere tahmini girdi tavanının bu
-          # oranına ulaşınca LLM budayıcı doğar (0.85'lik kör trim'den ÖNCE
-          # anlamsal sıkıştırma); target_ratio: plan yalnızca sonuç bu
-          # orana sığıyorsa uygulanır; max_steps/model: budayıcı bütçesi
-          # (nil = root provider); min_turns_between: otomatik doğum oranı
-          # sınırlayıcısı (turn sayısı).
+          # Pruner (repl/pruner): yarı deterministik KÖK pencere temizleyicisi,
+          # DEFAULT ON (kullanıcı kararı 2026-10-10; kill-switch: enabled=false).
+          # trigger_ratio: tahmini girdi tavanının bu oranında LLM budayıcı doğar
+          # (kör trim'den ÖNCE anlamsal sıkıştırma); target_ratio: plan sadece
+          # sonuca sığıyorsa uygulanır; max_steps/model: budayıcı bütçesi (nil =
+          # root provider); min_turns_between: otomatik doğum oranı sınırlayıcısı.
           "pruner" => {
             "enabled" => true,
             "trigger_ratio" => 0.6,
@@ -216,6 +207,12 @@ module Rubik
 
       private
 
+      def validate_prompt_grace_value!(key, value)
+        return unless key == "ui.prompt_grace_window_ms" && !(value.is_a?(Integer) && value >= 0)
+
+        raise ArgumentError, "ui.prompt_grace_window_ms must be a non-negative integer (milliseconds)"
+      end
+
       def validate_schema(config, schema = DEFAULT_CONFIG, prefix = "", strict: false)
         raise ArgumentError, "Configuration must be a Hash, got #{config.class}" unless config.is_a?(Hash)
 

data/lib/rubik/config.rb

@@ -163,12 +163,6 @@ module Rubik
 
     private
 
-    def validate_prompt_grace_value!(key, value)
-      return unless key == "ui.prompt_grace_window_ms" && !(value.is_a?(Integer) && value >= 0)
-
-      raise ArgumentError, "ui.prompt_grace_window_ms must be a non-negative integer (milliseconds)"
-    end
-
     # save! returns itself for no-write scopes; persist outcomes are hashes.
     def persist_result(res)
       res.is_a?(Hash) ? res : { ok: 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
 

data/lib/rubik/llm/anthropic.rb

@@ -56,8 +56,11 @@ module Rubik
         return opts[:api_key] if opts.key?(:api_key) && !opts[:api_key].nil?
         return @api_key if @api_key && !@api_key.to_s.empty?
 
-        env_name = opts[:api_key_env] || @api_key_env || "ANTHROPIC_API_KEY"
-        ENV.fetch(env_name, nil)
+        env_name = opts[:api_key_env]
+        env_name = @api_key_env if env_name.nil? || env_name.to_s.empty?
+        env_name = "ANTHROPIC_API_KEY" if env_name.nil? || env_name.to_s.empty?
+
+        ENV.fetch(env_name.to_s, nil)
       end
 
       def complete(messages, opts = {})