samagotchi 0.65.0 → 0.67.0

data/lib/samagotchi/tools/registry.rb

@@ -35,8 +35,15 @@ module Samagotchi
 
       def initialize
         @entries = {}
+        @toolkit = nil
       end
 
+      # The session's resolved toolkit (Toolkit::Resolved), which the lists
+      # below and #offered filter by; nil declares every tool (full). The
+      # Engine sets it at a turn's start, before the prompt is built, and
+      # only there: a request's declared tools never change mid-turn.
+      attr_accessor :toolkit
+
       # @return [Entry]
       def register(name, schema:, handler:, label: nil, preview: nil, targets: nil, refs: nil, source: "core", layer: nil)
         raise ArgumentError, "tool #{name} is already registered" if @entries.key?(name)
@@ -59,19 +66,40 @@ module Samagotchi
       # @return [Entry, nil]
       def offered(name, layers: [])
         entry = self[name]
-        entry if entry&.offered?(layers)
+        entry if entry&.offered?(layers) && declared?(entry)
+      end
+
+      # The entry +name+ names when the session's toolkit leaves it out (a
+      # real tool the model can't call here), nil otherwise.
+      # @return [Entry, nil]
+      def left_out(name, layers: [])
+        entry = self[name]
+        entry if entry&.offered?(layers) && !declared?(entry)
+      end
+
+      # The tools +toolkit+ (the session's by default) leaves out of a turn
+      # under +layers+.
+      # @return [Array<String>] in declaration order
+      def left_out_names(layers: [], toolkit: @toolkit)
+        ordered(@entries.values.select { |entry| entry.offered?(layers) && !declared?(entry, toolkit) }).map(&:name)
       end
 
+      # Every tool +source+ registered, declared or not (a plugin's tool set
+      # changing: Plugin::ToolSpec.apply).
+      # @return [Array<Entry>]
+      def by_source(source) = @entries.values.select { |entry| entry.source == source }
+
       # The tools a turn offers is per turn: +layers+, the turn's LLM
       # context layers (LLMContextStrategy), adds the tools gated by them.
       # Without layers (none, the default) the list is what it always was.
       # @return [Array<String>] in declaration order
-      def names(layers: []) = entries(layers: layers).map(&:name)
+      def names(layers: [], toolkit: @toolkit) = entries(layers: layers, toolkit: toolkit).map(&:name)
 
-      # @return [Array<Entry>] in declaration order
-      def entries(layers: [])
-        core, added = @entries.values.select { |entry| entry.offered?(layers) }.partition(&:core?)
-        core + added.sort_by { |entry| [entry.source.to_s, entry.name] }
+      # @return [Array<Entry>] in declaration order: the ones the turn's
+      #   layers offer and the session's toolkit declares
+      #   (+toolkit+: another one's, for what a change would declare)
+      def entries(layers: [], toolkit: @toolkit)
+        ordered(@entries.values.select { |entry| entry.offered?(layers) && declared?(entry, toolkit) })
       end
 
       # @return [Array<Hash>] the schemas, in declaration order
@@ -81,6 +109,15 @@ module Samagotchi
         @entries.freeze
         super
       end
+
+      private
+
+      def declared?(entry, toolkit = @toolkit) = toolkit.nil? || toolkit.declares?(entry)
+
+      def ordered(entries)
+        core, added = entries.partition(&:core?)
+        core + added.sort_by { |entry| [entry.source.to_s, entry.name] }
+      end
     end
   end
 end

data/lib/samagotchi/tools/task_create.rb

@@ -15,12 +15,12 @@ module Samagotchi
         return error if error
 
         [
-          "task_id: #{record.fetch("id")}",
-          "status: #{record.fetch("status")}",
-          "pid: #{record.fetch("pid")}",
-          "created_at: #{record.fetch("created_at")}",
-          "output_path: #{record.fetch("output_path")}",
-          "cwd: #{record.fetch("cwd")}"
+          "task_id: #{record.id}",
+          "status: #{record.status}",
+          "pid: #{record.pid}",
+          "created_at: #{record.created_at}",
+          "output_path: #{record.output_path}",
+          "cwd: #{record.cwd}"
         ].join("\n")
       rescue StandardError => e
         "Error: #{e.message}"

data/lib/samagotchi/tools/task_get.rb

@@ -20,20 +20,20 @@ module Samagotchi
 
       def self.format_record(record)
         [
-          "task_id: #{record.fetch("id")}",
-          "status: #{record.fetch("status")}",
-          "command: #{record.fetch("command")}",
-          "cwd: #{record.fetch("cwd")}",
-          "pid: #{record.fetch("pid")}",
-          "created_at: #{record.fetch("created_at")}",
-          "started_at: #{record.fetch("started_at")}",
-          "finished_at: #{record["finished_at"]}",
-          "exit_code: #{record["exit_code"]}",
-          "stop_reason: #{record["stop_reason"]}",
-          "output_path: #{record.fetch("output_path")}",
+          "task_id: #{record.id}",
+          "status: #{record.status}",
+          "command: #{record.command}",
+          "cwd: #{record.cwd}",
+          "pid: #{record.pid}",
+          "created_at: #{record.created_at}",
+          "started_at: #{record.started_at}",
+          "finished_at: #{record.finished_at}",
+          "exit_code: #{record.exit_code}",
+          "stop_reason: #{record.stop_reason}",
+          "output_path: #{record.output_path}",
           # A handed-over execute's stderr has a log of its own.
-          ("stderr_path: #{record["stderr_path"]}" if record["stderr_path"]),
-          (TaskRuntime::USER_STOP_NOTE if TaskRuntime.stopped_by_user?(record))
+          ("stderr_path: #{record.stderr_path}" if record.stderr_path),
+          (TaskRuntime::USER_STOP_NOTE if record.stopped_by_user?)
         ].compact.join("\n")
       end
       private_class_method :format_record

data/lib/samagotchi/tools/task_list.rb

@@ -21,12 +21,12 @@ module Samagotchi
 
       def self.format_entry(record)
         [
-          "task_id: #{record.fetch("id")}",
-          "status: #{record.fetch("status")}",
-          "pid: #{record.fetch("pid")}",
-          "created_at: #{record.fetch("created_at")}",
-          "command: #{preview(record.fetch("command"))}",
-          "output_path: #{record.fetch("output_path")}"
+          "task_id: #{record.id}",
+          "status: #{record.status}",
+          "pid: #{record.pid}",
+          "created_at: #{record.created_at}",
+          "command: #{preview(record.command)}",
+          "output_path: #{record.output_path}"
         ].join("\n")
       end
       private_class_method :format_entry

data/lib/samagotchi/tools/task_record.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Tools
+    # A background task's record, as TaskRuntime keeps it in
+    # tmp/tasks/<id>/task.json. Read with .from_file, written with #to_file;
+    # an update is a #with. The values are as on disk: times are iso8601
+    # strings, +pid+ whatever the file holds (a hand-edited one may not be
+    # a number; TaskRuntime never signals that).
+    #
+    # The file keeps its key order (the members' order) and leaves out the
+    # optional keys while unset: +stderr_path+ and +handed_over_by+ (only a
+    # handed-over execute has them) and +stop_requested_by+ (only once a
+    # stop started). bundles/slow-commands reads these files on its own.
+    TaskRecord = Data.define(
+      :metadata_version, :id, :command, :cwd, :workspace_root, :status, :pid, :pid_started,
+      :created_at, :started_at, :finished_at, :exit_code, :stop_reason,
+      :output_path, :stderr_path, :exit_code_path, :handed_over_by, :stop_requested_by
+    ) do
+      self::METADATA_VERSION = 1
+      self::OPTIONAL = %i[stderr_path handed_over_by stop_requested_by].freeze
+
+      # A record for a task that just started (task_create), or that an
+      # execute hands over (TaskRuntime.adopt fills in +pid_started+ then).
+      # @param started_at [String] iso8601; also its +created_at+
+      def self.running(id:, command:, cwd:, pid:, started_at:, output_path:, exit_code_path:, pid_started: nil,
+                       stderr_path: nil, handed_over_by: nil)
+        new(metadata_version: self::METADATA_VERSION, id: id, command: command, cwd: cwd, workspace_root: Dir.pwd,
+            status: "running", pid: pid, pid_started: pid_started, created_at: started_at, started_at: started_at,
+            finished_at: nil, exit_code: nil, stop_reason: nil, output_path: output_path, stderr_path: stderr_path,
+            exit_code_path: exit_code_path, handed_over_by: handed_over_by, stop_requested_by: nil)
+      end
+
+      # @param data [Hash] the parsed task.json; a key it lacks reads nil
+      # @return [TaskRecord, nil] nil when +data+ isn't an object
+      def self.from_file(data)
+        return nil unless data.is_a?(Hash)
+
+        new(**members.to_h { |key| [key, data[key.to_s]] })
+      end
+
+      # @return [Hash] the task.json object, string keys in member order
+      def to_file
+        to_h.reject { |key, value| value.nil? && self.class::OPTIONAL.include?(key) }.transform_keys(&:to_s)
+      end
+
+      def running? = status == "running"
+
+      def stopped_by_user? = stop_reason == "stopped_by_user"
+    end
+  end
+end

data/lib/samagotchi/tools/task_runtime.rb

@@ -8,11 +8,13 @@ require "time"
 require_relative "../atomic_file"
 require_relative "../process_group"
 require_relative "shell"
+require_relative "task_record"
 
 module Samagotchi
   module Tools
-    # Execute requires nothing from here at load, and P1b's Execute will
-    # require this file: autoload keeps the two from requiring each other.
+    # Execute requires this file (it hands a command over with adopt), and
+    # this one needs Execute only at run time: autoload keeps the two from
+    # requiring each other.
     autoload :Execute, File.expand_path("execute", __dir__)
 
     module TaskRuntime
@@ -22,7 +24,7 @@ module Samagotchi
       EXIT_CODE_FILENAME = "exit_code"
       STOP_GRACE_SEC = 3.0
       STOP_POLL_INTERVAL_SEC = 0.1
-      METADATA_VERSION = 1
+      METADATA_VERSION = TaskRecord::METADATA_VERSION
       OUTPUT_TAIL_READ_BYTES = 16 * 1024
       SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
       # Set by chi (Builtins.parent_env); the model's env can't change it.
@@ -74,24 +76,9 @@ module Samagotchi
         # Read now, compared before each signal: a pid reused later is not this task.
         pid_started = ProcessGroup.start_time(pid)
 
-        now = timestamp
-        record = {
-          "metadata_version" => METADATA_VERSION,
-          "id" => task_id,
-          "command" => normalized_command,
-          "cwd" => resolved_cwd,
-          "workspace_root" => Dir.pwd,
-          "status" => "running",
-          "pid" => pid,
-          "pid_started" => pid_started,
-          "created_at" => now,
-          "started_at" => now,
-          "finished_at" => nil,
-          "exit_code" => nil,
-          "stop_reason" => nil,
-          "output_path" => output_path,
-          "exit_code_path" => exit_code_path
-        }
+        record = TaskRecord.running(id: task_id, command: normalized_command, cwd: resolved_cwd, pid: pid,
+                                    pid_started: pid_started, started_at: timestamp,
+                                    output_path: output_path, exit_code_path: exit_code_path)
 
         write_record(record)
         [record, nil]
@@ -102,41 +89,29 @@ module Samagotchi
       end
 
       # A record for a command chi already runs: an execute still running at
-      # its limit, handed over as a task (Execute::HANDED_OVER). Its logs and
+      # its limit, handed over as a task (Execute::HANDED_OVER), given as a
+      # TaskRecord.running whose +started_at+ is the spawn's. Its logs and
       # exit_code file stay where execute put them, so the paths must be
       # absolute; +stderr_path+ is a log of its own (task_wait tails it).
       # The pid's start time is read here, at the hand-over, not at the
       # spawn (a quick execute is spared the ps): read while execute's
       # detach waiter is still running, so the pid is still its child.
-      # @param started_at [Time] when execute spawned the command
-      # @return [Array(Hash, nil), Array(nil, String)] the record, or an error
-      def adopt(id:, command:, cwd:, pid:, started_at:, output_path:, stderr_path:, exit_code_path:)
+      # @param task [TaskRecord]
+      # @return [Array(TaskRecord, nil), Array(nil, String)] the record, or an error
+      def adopt(task)
+        id = task.id
         return [nil, "Error: invalid task id: #{id}"] unless TASK_ID_SHAPE.match?(id.to_s)
         return [nil, "Error: task already exists: #{id}"] if File.exist?(metadata_path(id))
 
-        paths = { "output_path" => output_path, "stderr_path" => stderr_path, "exit_code_path" => exit_code_path }
-        relative = paths.find { |_, path| !File.absolute_path?(path.to_s) }
-        return [nil, "Error: #{relative[0]} must be absolute: #{relative[1]}"] if relative
+        relative = %i[output_path stderr_path exit_code_path].find { |key| !File.absolute_path?(task.public_send(key).to_s) }
+        return [nil, "Error: #{relative} must be absolute: #{task.public_send(relative)}"] if relative
+
+        pid = task.pid
         return [nil, "Error: not a process chi can stop: #{pid.inspect}"] unless ProcessGroup.signalable?(pid)
 
-        started = started_at.utc.iso8601
-        record = {
-          "metadata_version" => METADATA_VERSION,
-          "id" => id,
-          "command" => command.to_s.strip,
-          "cwd" => File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd),
-          "workspace_root" => Dir.pwd,
-          "status" => "running",
-          "pid" => pid,
-          "pid_started" => ProcessGroup.start_time(pid),
-          "created_at" => started,
-          "started_at" => started,
-          "finished_at" => nil,
-          "exit_code" => nil,
-          "stop_reason" => nil,
-          **paths,
-          "handed_over_by" => Execute::NAME
-        }
+        cwd = task.cwd
+        record = task.with(command: task.command.to_s.strip, cwd: File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd),
+                           pid_started: ProcessGroup.start_time(pid), handed_over_by: Execute::NAME)
         write_record(record)
         [record, nil]
       rescue StandardError => e
@@ -154,7 +129,7 @@ module Samagotchi
           next nil unless record
 
           refresh_record(record)
-        end.compact.sort_by { |record| record["created_at"].to_s }.reverse
+        end.compact.sort_by { |record| record.created_at.to_s }.reverse
       end
 
       # The tasks this conversation started that are still running: its
@@ -166,7 +141,7 @@ module Samagotchi
       def running_created_in(messages)
         created_ids_in(messages).filter_map do |id|
           record, _error = get_record(id)
-          { id: id, command: record["command"].to_s } if record&.fetch("status") == "running"
+          { id: id, command: record.command.to_s } if record&.running?
         end
       end
 
@@ -232,14 +207,12 @@ module Samagotchi
         path = File.join(root || Dir.pwd, TASKS_DIR, id, METADATA_FILENAME)
         return nil unless File.file?(path)
 
-        command = JSON.parse(File.read(path))["command"]
+        command = TaskRecord.from_file(JSON.parse(File.read(path)))&.command
         command.is_a?(String) && !command.strip.empty? ? command : nil
       rescue StandardError
         nil
       end
 
-      def stopped_by_user?(record) = record["stop_reason"] == "stopped_by_user"
-
       def get_record(task_id)
         record = load_record(task_id)
         return [nil, not_found(task_id)] unless record
@@ -271,19 +244,18 @@ module Samagotchi
         return [nil, not_found(task_id)] unless record
 
         refreshed = refresh_record(record)
-        return [refreshed, nil] unless refreshed["status"] == "running"
+        return [refreshed, nil] unless refreshed.running?
 
-        pid = refreshed["pid"]
         # Checked again just before the signal: never a group chi didn't start.
-        return [mark_not_chis(refreshed), nil] unless chis_group?(refreshed, started: refreshed["pid_started"])
+        return [mark_not_chis(refreshed), nil] unless chis_group?(refreshed, started: refreshed.pid_started)
 
-        refreshed["stop_requested_by"] = by.to_s
-        write_record(refreshed)
+        flagged = refreshed.with(stop_requested_by: by.to_s)
+        write_record(flagged)
 
         # A group that isn't ours (EPERM) is an error, not a stop.
-        ProcessGroup.stop(pid, grace: STOP_GRACE_SEC, poll: STOP_POLL_INTERVAL_SEC, quiet: [Errno::ESRCH])
+        ProcessGroup.stop(flagged.pid, grace: STOP_GRACE_SEC, poll: STOP_POLL_INTERVAL_SEC, quiet: [Errno::ESRCH])
 
-        updated = mark_stopped(refresh_record(refreshed))
+        updated = mark_stopped(refresh_record(flagged))
         write_record(updated)
 
         [updated, nil]
@@ -292,10 +264,10 @@ module Samagotchi
       end
 
       def refresh_record(record)
-        return record unless record["status"] == "running"
+        return record unless record.running?
 
-        pid = record["pid"]
-        return record if chis_group?(record, started: record["pid_started"])
+        pid = record.pid
+        return record if chis_group?(record, started: record.pid_started)
         # Gone: its exit code says how it ended.
         return mark_finished_without_exit_code(record) if ProcessGroup.signalable?(pid) && !ProcessGroup.alive?(pid)
 
@@ -307,7 +279,7 @@ module Samagotchi
       # ps per call on macOS (~5 ms), asked by each refresh (task_list,
       # task_get, each task_wait poll) so a reused pid reads as exited, and
       # by task_stop again just before the signal.
-      def chis_group?(record, started: nil) = ProcessGroup.leader?(record["pid"], started: started)
+      def chis_group?(record, started: nil) = ProcessGroup.leader?(record.pid, started: started)
 
       # A running record whose pid isn't a group chi started (NOT_CHIS_PROCESS)
       # ends as failed, unless its exit code or a stop on disk says more.
@@ -338,18 +310,18 @@ module Samagotchi
         path = metadata_path(task_id)
         return nil unless File.exist?(path)
 
-        JSON.parse(File.read(path))
+        TaskRecord.from_file(JSON.parse(File.read(path)))
       rescue JSON::ParserError
         nil
       end
 
       def write_record(record)
         ensure_tasks_dir
-        dir = task_dir_for(record.fetch("id"))
+        dir = task_dir_for(record.id)
         FileUtils.mkdir_p(dir)
 
         path = File.join(dir, METADATA_FILENAME)
-        AtomicFile.write(path, JSON.pretty_generate(record) + "\n")
+        AtomicFile.write(path, JSON.pretty_generate(record.to_file) + "\n")
       end
 
       def metadata_path(task_id)
@@ -434,26 +406,20 @@ module Samagotchi
 
       def mark_finished_without_exit_code(record, missing_reason: "process_ended_without_exit_code")
         record = current_record(record)
-        return record unless record["status"] == "running"
-
-        exit_code = read_exit_code(record["exit_code_path"])
-
-        if record["stop_requested_by"]
-          record["exit_code"] = exit_code
-          mark_stopped(record)
-        elsif exit_code.nil?
-          record["status"] = "failed"
-          record["exit_code"] = nil
-          record["stop_reason"] ||= missing_reason
-        elsif exit_code.zero?
-          record["status"] = "completed"
-          record["exit_code"] = 0
-        else
-          record["status"] = "failed"
-          record["exit_code"] = exit_code
-        end
-
-        record["finished_at"] ||= timestamp
+        return record unless record.running?
+
+        exit_code = read_exit_code(record.exit_code_path)
+        record =
+          if record.stop_requested_by
+            mark_stopped(record.with(exit_code: exit_code))
+          elsif exit_code.nil?
+            record.with(status: "failed", exit_code: nil, stop_reason: record.stop_reason || missing_reason)
+          elsif exit_code.zero?
+            record.with(status: "completed", exit_code: 0)
+          else
+            record.with(status: "failed", exit_code: exit_code)
+          end
+        record = record.with(finished_at: record.finished_at || timestamp)
         write_record(record)
         record
       end
@@ -461,18 +427,16 @@ module Samagotchi
       # The disk copy when it is newer than +record+: already finished, or
       # flagged by a stop that started after +record+ was read.
       def current_record(record)
-        disk = load_record(record.fetch("id"))
+        disk = load_record(record.id)
         return record unless disk
-        return disk if disk["status"] != "running" || disk["stop_requested_by"]
+        return disk if !disk.running? || disk.stop_requested_by
 
         record
       end
 
       def mark_stopped(record)
-        record["status"] = "stopped"
-        record["stop_reason"] = "stopped_by_#{record["stop_requested_by"]}"
-        record["finished_at"] ||= timestamp
-        record
+        record.with(status: "stopped", stop_reason: "stopped_by_#{record.stop_requested_by}",
+                    finished_at: record.finished_at || timestamp)
       end
 
       def read_exit_code(path)

data/lib/samagotchi/tools/task_stop.rb

@@ -14,12 +14,12 @@ module Samagotchi
         return error if error
 
         [
-          "task_id: #{record.fetch("id")}",
-          "status: #{record.fetch("status")}",
-          "exit_code: #{record["exit_code"]}",
-          "finished_at: #{record["finished_at"]}",
-          "stop_reason: #{record["stop_reason"]}",
-          "output_path: #{record.fetch("output_path")}"
+          "task_id: #{record.id}",
+          "status: #{record.status}",
+          "exit_code: #{record.exit_code}",
+          "finished_at: #{record.finished_at}",
+          "stop_reason: #{record.stop_reason}",
+          "output_path: #{record.output_path}"
         ].join("\n")
       rescue StandardError => e
         "Error: #{e.message}"

data/lib/samagotchi/tools/task_wait.rb

@@ -39,8 +39,7 @@ module Samagotchi
           record, error = TaskRuntime.get_record(task_id)
           return error if error
 
-          status = record.fetch("status")
-          return finished_response(record, tail_lines) unless status == "running"
+          return finished_response(record, tail_lines) unless record.running?
 
           if completion_pattern
             output_tail = output_tail(record, tail_lines)
@@ -56,7 +55,7 @@ module Samagotchi
 
         # Timeout reached — do one final refresh to capture the latest status
         refreshed, = TaskRuntime.get_record(task_id)
-        return finished_response(refreshed, tail_lines) unless refreshed.fetch("status") == "running"
+        return finished_response(refreshed, tail_lines) unless refreshed.running?
 
         format_response(refreshed, wait_result: "timeout", output_tail: output_tail(refreshed, tail_lines), tail_lines: tail_lines)
       rescue StandardError => e
@@ -68,7 +67,7 @@ module Samagotchi
       def self.cancelled_response(task_id, tail_lines, started)
         record, error = TaskRuntime.get_record(task_id)
         return error if error
-        return finished_response(record, tail_lines) unless record.fetch("status") == "running"
+        return finished_response(record, tail_lines) unless record.running?
 
         note = [
           "note: the user stopped the turn while waiting; the task is STILL RUNNING.",
@@ -83,7 +82,7 @@ module Samagotchi
       # A task the user stopped also says so, with the tail of its output:
       # the model sees where the job was cut off.
       def self.finished_response(record, tail_lines)
-        return format_response(record) unless TaskRuntime.stopped_by_user?(record)
+        return format_response(record) unless record.stopped_by_user?
 
         format_response(record, output_tail: output_tail(record, tail_lines), tail_lines: tail_lines,
                                extra: [TaskRuntime::USER_STOP_NOTE])
@@ -91,14 +90,14 @@ module Samagotchi
       private_class_method :finished_response
 
       def self.output_tail(record, tail_lines)
-        TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+        TaskRuntime.output_tail_lines(record.output_path, tail_lines)
       end
       private_class_method :output_tail
 
       # The last lines of a handed-over execute's stderr log (stderr_path),
       # "" for a task_create task (one log) or an empty stderr.
       def self.stderr_tail(record, tail_lines)
-        path = record["stderr_path"]
+        path = record.stderr_path
         return "" if path.to_s.empty? || tail_lines.nil?
 
         TaskRuntime.output_tail_lines(path, [tail_lines, STDERR_TAIL_LINES_MAX].min)
@@ -107,13 +106,13 @@ module Samagotchi
 
       def self.format_response(record, wait_result: nil, output_tail: nil, tail_lines: nil, extra: [])
         lines = [
-          "task_id: #{record.fetch("id")}",
-          "status: #{record.fetch("status")}",
-          "exit_code: #{record["exit_code"]}",
-          "stop_reason: #{record["stop_reason"]}",
-          "output_path: #{record.fetch("output_path")}"
+          "task_id: #{record.id}",
+          "status: #{record.status}",
+          "exit_code: #{record.exit_code}",
+          "stop_reason: #{record.stop_reason}",
+          "output_path: #{record.output_path}"
         ]
-        lines << "stderr_path: #{record["stderr_path"]}" if record["stderr_path"]
+        lines << "stderr_path: #{record.stderr_path}" if record.stderr_path
         return lines.join("\n") unless output_tail
 
         lines << "wait_result: #{wait_result}" if wait_result