samagotchi 0.22.0 → 0.24.0

data/lib/samagotchi/tool_call_parser.rb

@@ -25,7 +25,7 @@ module Samagotchi
       result = text.to_s
       while (open_pos = result.index(open))
         close_pos = result.index(close, open_pos + open.length)
-        result = result[0...open_pos] + (close_pos ? result[close_pos + close.length..] : "")
+        result = result[0...open_pos] + (close_pos ? result[(close_pos + close.length)..] : "")
       end
       result.strip
     end
@@ -37,7 +37,7 @@ module Samagotchi
     class Gemma
       # Digits after the first character: plugin tools may have them
       # (Plugin::Api::TOOL_NAME).
-      TOOL_CALL_BODY_RE   = /\Acall:([a-z_][a-z0-9_]{0,49})\{/
+      TOOL_CALL_BODY_RE = /\Acall:([a-z_][a-z0-9_]{0,49})\{/
       THOUGHT_CHANNEL_OPEN  = ModelProfile::GEMMA_THOUGHT_CHANNEL_OPEN
       THOUGHT_CHANNEL_CLOSE = ModelProfile::GEMMA_THOUGHT_CHANNEL_CLOSE
       CONTROL_TOKEN_START = "<|"
@@ -102,7 +102,7 @@ module Samagotchi
         while (open_pos = result.index(THOUGHT_CHANNEL_OPEN))
           close_pos = result.index(THOUGHT_CHANNEL_CLOSE, open_pos)
           result = if close_pos
-                     result[0...open_pos] + result[close_pos + THOUGHT_CHANNEL_CLOSE.length..]
+                     result[0...open_pos] + result[(close_pos + THOUGHT_CHANNEL_CLOSE.length)..]
                    else
                      result[0...open_pos]
                    end
@@ -128,11 +128,10 @@ module Samagotchi
         pos = start
         while (p = text.index(CONTROL_TOKEN_START, pos))
           # Skip over a <|"|> token entirely
-          if text[p, @string_delim.length] == @string_delim
-            pos = p + @string_delim.length
-          else
-            return p
-          end
+          return p unless text[p, @string_delim.length] == @string_delim
+
+          pos = p + @string_delim.length
+
         end
         nil
       end
@@ -213,7 +212,7 @@ module Samagotchi
             e = params_raw.index(@string_delim, s + @string_delim.length)
             break unless e
 
-            arr << params_raw[s + @string_delim.length...e]
+            arr << params_raw[(s + @string_delim.length)...e]
             pos = e + @string_delim.length
           end
           unless arr.empty?
@@ -334,13 +333,13 @@ module Samagotchi
 
       def strip_thought(text)
         # Remove all complete <think>...</think> blocks with the newlines after them
-        result = text.gsub(/<think>.*?<\/think>\n*/m, '')
+        result = text.gsub(%r{<think>.*?</think>\n*}m, "")
         # Remove any stray opening tags
-        result = result.gsub(/<think>.*?(?=\n|$)/m, '')
+        result = result.gsub(/<think>.*?(?=\n|$)/m, "")
         # Remove any orphaned closing tags (and the whitespace around them)
         # The answer's own blank lines stay: they are its markdown paragraphs
         # and lists (a chat host's answer is saved as stripped here).
-        result.gsub(/^\s*<\/think>\s*/m, '')
+        result.gsub(%r{^\s*</think>\s*}m, "")
       end
 
       def strip_tool_calls(text)
@@ -365,11 +364,11 @@ module Samagotchi
       def qwen_params(body)
         params = {}
 
-        body.scan(/<parameter=(\w+)>(.*?)<\/parameter>/m) do |key, value|
+        body.scan(%r{<parameter=(\w+)>(.*?)</parameter>}m) do |key, value|
           params[key.to_s.downcase] = trim_tag_newline(value)
         end
 
-        body.scan(/<arg_key>(.*?)<\/arg_key>\s*<arg_value>(.*?)<\/arg_value>/m) do |key, value|
+        body.scan(%r{<arg_key>(.*?)</arg_key>\s*<arg_value>(.*?)</arg_value>}m) do |key, value|
           params[key.to_s.downcase.strip] = trim_tag_newline(value)
         end
 

data/lib/samagotchi/tool_declarations.rb

@@ -71,7 +71,7 @@ module Samagotchi
               description: "Content to write to the file"
             }
           },
-          required: ["path", "content"]
+          required: %w[path content]
         }
       },
       {
@@ -101,7 +101,7 @@ module Samagotchi
               description: "Optional end line (1-based, inclusive) for range mode. Must be provided with start_line."
             }
           },
-          required: ["path", "new_text"]
+          required: %w[path new_text]
         }
       },
       {
@@ -148,7 +148,7 @@ module Samagotchi
               description: "Set true to save this entry as a model-specific overlay for the current model only (<name>.<model>.md); it is auto-appended when the entry is read under that model and never listed in the index."
             }
           },
-          required: ["name", "content", "scope"]
+          required: %w[name content scope]
         }
       },
       {
@@ -268,7 +268,7 @@ module Samagotchi
               description: "How often to remind (1-1440 minutes, i.e. up to 1 day)"
             }
           },
-          required: ["name", "description", "interval_minutes"]
+          required: %w[name description interval_minutes]
         }
       },
       {
@@ -321,7 +321,7 @@ module Samagotchi
               description: "The note: what the other session should know (up to 16 KiB)"
             }
           },
-          required: ["session", "text"]
+          required: %w[session text]
         }
       },
       {
@@ -399,30 +399,15 @@ module Samagotchi
               description: "Allow freeform/Other text alongside selection. Default false."
             }
           },
-          required: ["question", "options"]
+          required: %w[question options]
         }
       }
     ].freeze
 
-    # Where Gemma's declaration text says something the schema doesn't: extra
-    # description text, and explicit required:false on optional parameters.
+    # Where Gemma's declaration text says something the schema doesn't:
+    # extra description text.
     GEMMA_PARAM_OVERRIDES = {
       "edit" => { new_text: { description: "Replacement text (required)" } },
-      "task_wait" => {
-        timeout: { required: false },
-        tail_lines: { required: false },
-        done_pattern: { required: false }
-      },
-      "delegate" => {
-        model: { required: false },
-        session: { required: false },
-        wait: { required: false },
-        timeout: { required: false }
-      },
-      "delegate_result" => {
-        session: { required: false },
-        timeout: { required: false }
-      },
       "ask_user_question" => {
         options: { description: "2-8 answer options as strings (labels). Single/multi selection via multi_select flag." }
       }
@@ -440,26 +425,42 @@ module Samagotchi
 
     module_function
 
-    # Gemma 4 <|tool>declaration:NAME{…}<tool|> blocks for every tool, one per line group.
+    # Gemma 4 <|tool>declaration:NAME{…}<tool|> blocks for every tool, back
+    # to back, as Gemma 4's chat template declares tools.
     # @param schemas [Array<Hash>] a Tools::Registry's schemas
     def gemma_declarations(schemas = TOOL_SCHEMAS)
-      schemas.map { |schema| gemma_declaration(schema) }.join("\n")
+      schemas.map { |schema| gemma_declaration(schema) }.join
     end
 
+    # One declaration in the template's shape: properties sorted by name,
+    # types upper-cased, the required names as a list.
     def gemma_declaration(schema)
       q = GEMMA_QUOTE
-      required = Array(schema[:parameters][:required])
+      parameters = schema[:parameters] || {}
       overrides = GEMMA_PARAM_OVERRIDES.fetch(schema[:name], {})
-      lines = schema[:parameters][:properties].map do |name, param|
-        override = overrides.fetch(name, {})
-        description = override.fetch(:description, param[:description])
-        line = "    #{name}:{type:#{q}#{param[:type]}#{q}, description:#{q}#{description}#{q}"
-        req = override.fetch(:required, required.include?(name.to_s) ? true : nil)
-        line += ", required:#{req}" unless req.nil?
-        "#{line}}"
+      properties = (parameters[:properties] || {}).to_h do |name, param|
+        [name.to_s, param.merge(overrides.fetch(name.to_sym, {}))]
       end
-      params = lines.empty? ? "  parameters:{}" : "  parameters:{\n#{lines.join(",\n")}\n  }"
-      "<|tool>declaration:#{schema[:name]}{\n  description:#{q}#{schema[:description]}#{q},\n#{params}\n}<tool|>"
+      required = Array(parameters[:required]).map(&:to_s)
+      fields = []
+      fields << "properties:{#{gemma_properties(properties)}}" unless properties.empty?
+      fields << "required:[#{required.map { |name| "#{q}#{name}#{q}" }.join(",")}]" unless required.empty?
+      fields << "type:#{q}#{(parameters[:type] || "object").to_s.upcase}#{q}"
+      "<|tool>declaration:#{schema[:name]}{description:#{q}#{schema[:description]}#{q},parameters:{#{fields.join(",")}}}<tool|>"
+    end
+
+    def gemma_properties(properties)
+      q = GEMMA_QUOTE
+      properties.sort.map do |name, param|
+        fields = []
+        fields << "description:#{q}#{param[:description]}#{q}" unless param[:description].to_s.empty?
+        items = param[:items]
+        if param[:type].to_s.casecmp?("array") && items.is_a?(Hash) && !items.empty?
+          fields << "items:{#{items.sort_by { |key, _| key.to_s }.map { |key, value| "#{key}:#{q}#{value.to_s.upcase}#{q}" if key.to_s == "type" }.compact.join(",")}}"
+        end
+        fields << "type:#{q}#{param[:type].to_s.upcase}#{q}"
+        "#{name}:{#{fields.join(",")}}"
+      end.join(",")
     end
 
     # The schemas for the chat path's tools: array: +schemas+ with

data/lib/samagotchi/tool_runner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "tool_activity"
+require_relative "tool_view"
 require_relative "guardrails"
 require_relative "vision_context"
 require_relative "log"
@@ -55,6 +56,9 @@ module Samagotchi
       # The worker runs in its session's working directory.
       title = ToolActivity.tool_title(call[:name], call, cwd: Dir.pwd)
       started[:title] = title if title
+      # The full command for a richer UI (params stays cut at 80).
+      view = ToolView.for(call[:name], call)&.to_h
+      started[:view] = view if view
       emit(on_stream_event, started)
 
       # The ask comes after tool_call_started: the UI shows the tool line,
@@ -95,6 +99,9 @@ module Samagotchi
       completed[:images] = images if images&.any?
       completed[:diff] = diff if diff
       completed[:waited_ms] = waited_ms if waited_ms
+      # Also here: a UI that missed the start (a replay gap) builds its row
+      # from this event.
+      completed[:view] = view if view
       emit(on_stream_event, completed)
       # After the completed event: a hook's card (check-in, skills) prints
       # under the call's tool row, not before it.

data/lib/samagotchi/tool_view.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "tools/execute"
+require_relative "tools/task_create"
+
+module Samagotchi
+  # What a richer UI shows of a tool call beyond its one-line params: the
+  # full command of an execute / task_create (whitespace kept), and the
+  # call's own cwd: argument. Built by the server on every path (the live
+  # tool_call_started, the bridge's snapshot and replay, a reload from the
+  # saved call), so the UIs never parse the call themselves. params and its
+  # 80-char cut stay as they are (the guardrails, "ran as:", the TUI).
+  #
+  # +truncated+: the command was longer than COMMAND_LIMIT and is cut to it;
+  # +chars+ is then its full length.
+  ToolView = Data.define(:command, :cwd, :truncated, :chars) do
+    def to_h = super.compact.reject { |_key, value| value == false }
+  end
+
+  class ToolView
+    # The longest command a view carries (the spike's longest was 3,799).
+    COMMAND_LIMIT = 8_000
+
+    TOOLS = [Tools::Execute::NAME, Tools::TaskCreate::NAME].freeze
+
+    # @return [ToolView, nil] nil for a tool without a view and for an
+    #   empty command
+    def self.for(tool_name, call)
+      return nil unless TOOLS.include?(tool_name) && call.is_a?(Hash)
+
+      command = call[:content].to_s
+      return nil if command.strip.empty?
+
+      cwd = call[:cwd].to_s.strip
+      truncated = command.length > COMMAND_LIMIT
+      new(command: truncated ? command[0, COMMAND_LIMIT] : command, cwd: cwd.empty? ? nil : cwd,
+          truncated: truncated, chars: truncated ? command.length : nil)
+    end
+  end
+end

data/lib/samagotchi/tools/ask_user_question.rb

@@ -56,7 +56,7 @@ module Samagotchi
 
       # Booleans the way models send them (Gemma passes "true"/"false").
       def self.to_bool(value)
-        return value if value == true || value == false
+        return value if [true, false].include?(value)
 
         %w[1 true yes on].include?(value.to_s.strip.downcase)
       end
@@ -90,6 +90,7 @@ module Samagotchi
           begin
             parsed = JSON.parse(s)
             return parsed.dup if parsed.is_a?(Array)
+
             # If parsed is a String like "a, b", fall through to split
             if parsed.is_a?(String)
               s = parsed
@@ -124,8 +125,6 @@ module Samagotchi
           parts = t.split(/[,;\n]+/).map(&:strip)
           # Strip surrounding quotes from each part
           parts.map { |p| p.gsub(/\A["'\s]+|["'\s]+\z/, "").strip }
-        else
-          return nil
         end
       end
 
@@ -143,7 +142,7 @@ module Samagotchi
         s = s.strip
         return nil if s.empty?
         return nil if s.match?(/\A[\[\],\s]+\z/)
-        return nil if s == "]" || s == "["
+        return nil if ["]", "["].include?(s)
 
         s
       end

data/lib/samagotchi/tools/builtin_calls.rb

@@ -87,7 +87,7 @@ module Samagotchi
         # one of its keys must be a property; the rest must all be.
         unknown = ([path_key].compact + Array(o[:verbatim]) + Array(o[:also]) + o.fetch(:aliases, {}).keys) - properties
         unknown << content_keys.join("/") unless content_keys.empty? || content_keys.intersect?(properties)
-        raise ArgumentError, "#{name}: overrides name no schema property: #{unknown.join(', ')}" unless unknown.empty?
+        raise ArgumentError, "#{name}: overrides name no schema property: #{unknown.join(", ")}" unless unknown.empty?
         raise ArgumentError, "#{name}: a property would replace the call's name" if fields.include?("name")
 
         Row.new(name: name, content_keys: content_keys, path_key: path_key, fields: fields,

data/lib/samagotchi/tools/delegate.rb

@@ -155,7 +155,7 @@ module Samagotchi
       # true unless told otherwise; text-based parsers hand strings over.
       def self.parse_wait(value)
         return true if value.nil? || value.to_s.strip.empty?
-        return value if value == true || value == false
+        return value if [true, false].include?(value)
 
         !%w[false 0 no off].include?(value.to_s.strip.downcase)
       end

data/lib/samagotchi/tools/delegate_relay.rb

@@ -137,7 +137,7 @@ module Samagotchi
 
       # execute: git push origin main
       def what_text(facts)
-        facts = facts.is_a?(Hash) ? facts : {}
+        facts = {} unless facts.is_a?(Hash)
         tool = facts[:label] || facts[:tool] || "tool"
         what = facts[:command] || Array(facts[:paths]).join(", ")
         what = facts[:args].to_s if what.to_s.empty?

data/lib/samagotchi/tools/delegate_wait.rb

@@ -216,7 +216,6 @@ module Samagotchi
           preview[:tail]
         ].join("\n")
       end
-
     end
   end
 end

data/lib/samagotchi/tools/edit.rb

@@ -27,7 +27,7 @@ module Samagotchi
         updated, message = result
         File.write(path, updated)
         message
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 
@@ -49,16 +49,16 @@ module Samagotchi
         old_text = old_text.to_s
         new_text = new_text.to_s
 
-        source = read.(path)
+        source = read.call(path)
         count  = count_occurrences(source, old_text)
 
         return "Error: old text not found in #{path}" if count == 0
         return "Error: old text matches #{count} times in #{path}; make it unique" if count > 1
 
         idx     = source.index(old_text)
-        updated = source[0, idx] + new_text + source[idx + old_text.length..]
+        updated = source[0, idx] + new_text + source[(idx + old_text.length)..]
         [updated, "Edited #{path}: replaced #{old_text.bytesize} bytes with #{new_text.bytesize} bytes"]
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 
@@ -77,7 +77,7 @@ module Samagotchi
         # guessed start would silently overwrite the top of the file.
         return START_LINE_REQUIRED if start_num.nil?
 
-        source = read.(path)
+        source = read.call(path)
         lines = source.lines
         total_lines = lines.length
 
@@ -94,12 +94,11 @@ module Samagotchi
         end_value = nil
         if end_provided
           if end_num > total_lines
-            if OutputGuardrails.env_bool("SAMAGOTCHI_EDIT_ALLOW_OOR_END", default: true)
-              clamp_note = " (end_line #{end_num} exceeds #{total_lines} lines; clamped to line #{total_lines})"
-              end_value = total_lines
-            else
-              return "Error: range out of bounds for #{path}: file has #{total_lines} lines"
-            end
+            return "Error: range out of bounds for #{path}: file has #{total_lines} lines" unless OutputGuardrails.env_bool("SAMAGOTCHI_EDIT_ALLOW_OOR_END", default: true)
+
+            clamp_note = " (end_line #{end_num} exceeds #{total_lines} lines; clamped to line #{total_lines})"
+            end_value = total_lines
+
           else
             end_value = end_num
           end
@@ -107,6 +106,7 @@ module Samagotchi
           unless OutputGuardrails.env_bool("SAMAGOTCHI_EDIT_END_OPTIONAL", default: true)
             return "Error: start_line and end_line must both be provided for range edits"
           end
+
           end_value = total_lines
         end
 
@@ -118,13 +118,13 @@ module Samagotchi
         suffix = lines[end_value..]&.join.to_s
         # Ensure new_text ends with a newline when a suffix follows so that the
         # first suffix line isn't concatenated onto the last replacement line.
-        normalized = (!new_text.empty? && !suffix.empty? && !new_text.end_with?("\n")) ? new_text + "\n" : new_text
+        normalized = !new_text.empty? && !suffix.empty? && !new_text.end_with?("\n") ? new_text + "\n" : new_text
         updated = prefix + normalized + suffix
 
         replaced_lines = (end_value - start_num) + 1
         new_line_count = new_text.lines.length
         [updated, "Edited #{path}: replaced lines #{start_num}-#{end_value} (#{replaced_lines} lines) with #{new_line_count} lines#{clamp_note}"]
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
       private_class_method :apply_range_mode
@@ -136,6 +136,7 @@ module Samagotchi
         while (i = haystack.index(needle, pos))
           count += 1
           break if count > 1  # early exit — we only care whether it's 0, 1, or >1
+
           pos = i + needle.length
         end
         count

data/lib/samagotchi/tools/execute.rb

@@ -67,7 +67,7 @@ module Samagotchi
         stopped_result("Error: command timed out after #{timeout_sec}s\n#{TIMEOUT_HINT}", e)
       rescue CommandCancelled => e
         stopped_result("Error: command stopped by the user after #{e.elapsed.round}s (killed; rerun it if still needed)", e)
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 
@@ -186,7 +186,7 @@ module Samagotchi
           @thread = Thread.new do
             Thread.current.report_on_exception = false
             loop { @buffer << io.readpartial(READ_CHUNK_BYTES) }
-          rescue EOFError, IOError
+          rescue IOError # EOFError is one
             nil
           end
         end
@@ -221,9 +221,7 @@ module Samagotchi
         signal_process(pid, "TERM")
 
         deadline = monotonic_time + STOP_GRACE_SEC
-        while process_alive?(pid) && monotonic_time < deadline
-          sleep(STOP_POLL_INTERVAL_SEC)
-        end
+        sleep(STOP_POLL_INTERVAL_SEC) while process_alive?(pid) && monotonic_time < deadline
 
         signal_process(pid, "KILL") if process_alive?(pid)
       end

data/lib/samagotchi/tools/list_reminders.rb

@@ -10,7 +10,7 @@ module Samagotchi
 
       def self.name        = NAME
 
-      def self.call(content, reminder_store: nil)
+      def self.call(_content, reminder_store: nil)
         return "Error: reminder_store not configured" unless reminder_store
 
         reminder_store.list

data/lib/samagotchi/tools/memory.rb

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 require "fileutils"
@@ -46,6 +45,7 @@ module Samagotchi
         if names.empty?
           return "Error: no memory names provided"
         end
+
         bad = names.find { |name| invalid_name?(name) }
         return invalid_name_error(bad) if bad
 
@@ -58,34 +58,34 @@ module Samagotchi
           found = false
           resolved_scopes.each do |resolved_scope|
             path = memory_path(name, resolved_scope)
-            if File.exist?(path)
-              body = File.read(path, encoding: "UTF-8")
-              # Append model-specific overlay if key is provided and overlay exists.
-              [model_key, fallback_model_key].compact.each do |key|
-                overlay_path = ModelOverlay.overlay_path_for(name, key, resolved_scope)
-                next unless overlay_path && File.exist?(overlay_path)
-
-                body += SEPARATOR + "Model-specific guidance (#{key}):\n" + File.read(overlay_path, encoding: "UTF-8")
-                break
-              end
-              results << body
-              found = true
+            next unless File.exist?(path)
+
+            body = File.read(path, encoding: "UTF-8")
+            # Append model-specific overlay if key is provided and overlay exists.
+            [model_key, fallback_model_key].compact.each do |key|
+              overlay_path = ModelOverlay.overlay_path_for(name, key, resolved_scope)
+              next unless overlay_path && File.exist?(overlay_path)
+
+              body += SEPARATOR + "Model-specific guidance (#{key}):\n" + File.read(overlay_path, encoding: "UTF-8")
               break
             end
+            results << body
+            found = true
+            break
           end
           missing << name unless found
         end
 
         if results.empty? && !missing.empty?
-          "Error: memory not found: #{missing.join(', ')}"
+          "Error: memory not found: #{missing.join(", ")}"
         elsif missing.empty?
           results.join(SEPARATOR)
         else
-          results.join(SEPARATOR) + SEPARATOR + "Error: memory not found: #{missing.join(', ')}"
+          results.join(SEPARATOR) + SEPARATOR + "Error: memory not found: #{missing.join(", ")}"
         end
       rescue Errno::ENOENT => e
         "Error: #{e.message}"
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 
@@ -108,7 +108,7 @@ module Samagotchi
         return nil if value.empty?
         return value if VALID_SCOPES.include?(value)
 
-        raise ArgumentError, "invalid scope '#{scope}', expected one of: #{VALID_SCOPES.join(', ')}"
+        raise ArgumentError, "invalid scope '#{scope}', expected one of: #{VALID_SCOPES.join(", ")}"
       end
 
       def self.scoped_index(scope)
@@ -157,6 +157,7 @@ module Samagotchi
         return MemoryRead.invalid_name_error(entry_name) if MemoryRead.invalid_name?(entry_name)
         return "Error: scope is required" if scope.to_s.strip.empty?
         return "Error: content is required" if body.empty?
+
         resolved_scope = MemoryRead.normalize_scope(scope)
 
         if current_model_only
@@ -195,14 +196,12 @@ module Samagotchi
 
         # The verbatim "write to index.md" behavior (path: "index") must not
         # trigger upsert logic.
-        unless entry_name == MEMORY_INDEX
-          if manage_index(resolved_scope, entry_name, bytes, description)
-            message += " Index line refreshed automatically."
-          end
+        if !(entry_name == MEMORY_INDEX) && manage_index(resolved_scope, entry_name, bytes, description)
+          message += " Index line refreshed automatically."
         end
 
         message
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 

data/lib/samagotchi/tools/read.rb

@@ -65,7 +65,7 @@ module Samagotchi
         build_truncated_preview(path: path, file_size: size, preview_bytes: preview_bytes)
       rescue Errno::ENOENT
         "Error: file not found: #{path}"
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 
@@ -124,6 +124,7 @@ module Samagotchi
 
         start_num = parse_positive_line_number(start_line, "start_line")
         return start_num if start_num.is_a?(String)
+
         # end_line alone reads from the top of the file.
         start_num ||= 1
 
@@ -145,12 +146,11 @@ module Samagotchi
         # the historical hard error instead.
         clamp_note = ""
         if end_provided && end_num > total_lines
-          if OutputGuardrails.env_bool("SAMAGOTCHI_READ_ALLOW_OOR_END", default: true)
-            clamp_note = "\n[read: end_line #{end_num} exceeds #{total_lines} lines; returning lines #{start_num}-#{total_lines}]"
-            end_num = total_lines
-          else
-            return "Error: range out of bounds for #{path}: file has #{total_lines} lines"
-          end
+          return "Error: range out of bounds for #{path}: file has #{total_lines} lines" unless OutputGuardrails.env_bool("SAMAGOTCHI_READ_ALLOW_OOR_END", default: true)
+
+          clamp_note = "\n[read: end_line #{end_num} exceeds #{total_lines} lines; returning lines #{start_num}-#{total_lines}]"
+          end_num = total_lines
+
         end
 
         # A start past EOF is genuinely unusable -> keep a hard error.  A slice

data/lib/samagotchi/tools/task_create.rb

@@ -22,7 +22,7 @@ module Samagotchi
           "output_path: #{record.fetch("output_path")}",
           "cwd: #{record.fetch("cwd")}"
         ].join("\n")
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
     end

data/lib/samagotchi/tools/task_get.rb

@@ -14,7 +14,7 @@ module Samagotchi
         return error if error
 
         format_record(record)
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end
 

data/lib/samagotchi/tools/task_list.rb

@@ -15,7 +15,7 @@ module Samagotchi
         return "No tasks found." if records.empty?
 
         records.map { |record| format_entry(record) }.join("\n\n")
-      rescue => e
+      rescue StandardError => e
         "Error: #{e.message}"
       end