mistri 0.4.1 → 0.5.0

data/lib/mistri/child.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Mistri
+  # A sub-agent as its parent (or the host UI) sees it: a window onto the
+  # child's own session. Everything here is derived from the store, so it
+  # reads the same from any process, while the child runs and forever after.
+  #
+  #   session.children            # => [#<Mistri::Child Magpie done>, ...]
+  #   child.status                # => :running, :done, :stopped, :failed
+  #   child.report                # the terminal entry's report, once finished
+  #   child.transcript(tail: 20)  # recent entries, image bytes stripped
+  #   child.say("Also check their pricing page")
+  #
+  # Status is a walk over the child's own entries: a terminal entry wins; a
+  # started child is :running while its lease holds and :interrupted once
+  # it lapses (with a lock adapter; without one there is no liveness signal
+  # and no-terminal stays :running); a dispatched-but-never-started child is
+  # :queued, honestly, because the host's queue owns that gap.
+  class Child
+    TERMINAL = "subagent_result"
+    DISPATCHED = "subagent_dispatched"
+    STARTED = "subagent_started"
+    # The states a worker can still be caught in: steerable, stoppable,
+    # worth waiting on.
+    LIVE = %i[running queued].freeze
+
+    attr_reader :name, :session_id
+
+    def self.lease_key(session_id) = "child:#{session_id}"
+
+    def self.stop_key(session_id) = "child-stop:#{session_id}"
+
+    def initialize(name:, session_id:, store:)
+      @name = name
+      @session_id = session_id
+      @store = store
+    end
+
+    def status
+      log = session.entries
+      terminal = log.reverse_each.find { |entry| entry["type"] == TERMINAL }
+      return terminal["status"].to_sym if terminal
+      if log.any? { |entry| entry["type"] == DISPATCHED } &&
+         log.none? { |entry| entry["type"] == STARTED }
+        return :queued
+      end
+      return :interrupted if Mistri.locks && !Mistri.locks.held?(self.class.lease_key(@session_id))
+
+      :running
+    end
+
+    # A terminal entry exists: the child ended as done, stopped, or failed
+    # and will never run again. The question a queue retry asks; its
+    # inverse (started but no terminal) is what makes a crashed child
+    # re-runnable.
+    def finished?
+      !terminal_entry.nil?
+    end
+
+    def report
+      terminal_entry&.fetch("report", nil)
+    end
+
+    # The terminal entry's error string, once failed.
+    def error
+      terminal_entry&.fetch("error", nil)
+    end
+
+    # Recent entries, oldest first, with inline image bytes replaced by a
+    # marker: transcripts are for reading and re-sending, not for hauling
+    # screenshots back into a context window.
+    def transcript(tail: 20)
+      entries = session.entries
+      entries = entries.last(tail) if tail
+      entries.map { |entry| self.class.strip_images(entry) }
+    end
+
+    # Queue a message the child folds at its next turn boundary. Delivery is
+    # honest, not instant: a child mid-step sees it after that step, and a
+    # child that finishes first never sees it.
+    def say(text)
+      session.steer(text)
+    end
+
+    # Ask a live child to stop, from any process. A running child's runner
+    # sees the flag within a tick and trips its own signal; a queued child
+    # is cancelled outright with a stopped terminal, which the runner
+    # honors by never starting it. Stop is cross-process by nature, so it
+    # needs a lock adapter; without one this returns false. An action that
+    # reports acceptance, not a predicate.
+    def stop # rubocop:disable Naming/PredicateMethod
+      return false unless Mistri.locks
+
+      session.append(TERMINAL, "status" => "stopped") if status == :queued
+      Mistri.locks.set_flag(self.class.stop_key(@session_id))
+      true
+    end
+
+    def to_h
+      { "name" => name, "session_id" => session_id, "status" => status.to_s }
+    end
+
+    def inspect
+      "#<Mistri::Child #{name} #{status}>"
+    end
+
+    def self.strip_images(value)
+      case value
+      when Hash
+        if value["data"] && value["mime_type"]
+          value.except("data").merge("omitted" => true)
+        else
+          value.transform_values { |nested| strip_images(nested) }
+        end
+      when Array then value.map { |nested| strip_images(nested) }
+      else value
+      end
+    end
+
+    private
+
+    def session
+      @session ||= Session.new(store: @store, id: @session_id)
+    end
+
+    def terminal_entry
+      session.entries.reverse_each.find { |entry| entry["type"] == TERMINAL }
+    end
+  end
+end

data/lib/mistri/compactor.rb

@@ -5,7 +5,7 @@ require "json"
 module Mistri
   # Compacts a session in place: everything before a cut point is summarized
   # by the provider, and a compaction entry redirects replay to the summary
-  # plus the kept tail. Append-only — the full history stays in the store for
+  # plus the kept tail. Append-only: the full history stays in the store for
   # transcript UIs; only what the model sees shrinks. Callable from any
   # process (a UI button, a job), with or without a running agent.
   #

data/lib/mistri/console.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Mistri
+  # The management console: the tools an agent gets for managing the workers
+  # it spawns. Every tool is a thin wrapper over Session#children and the
+  # Child facade, the same functions a host UI calls, so nothing the agent
+  # can do is hidden from the user and nothing the user does confuses the
+  # agent. Tools are stateless: each call reads the calling session's
+  # children at that moment.
+  #
+  #   agent = Mistri::Agent.new(provider:, tools: [spawn, *Mistri::Console.tools])
+  #
+  # Workers are addressed by name or session id, uniformly, in every tool.
+  # When two workers share a name, the most recently spawned one answers;
+  # ids stay unambiguous.
+  module Console
+    READ_TIMEOUT = 300
+    POLL = 0.5
+
+    module_function
+
+    def tools(read_timeout: READ_TIMEOUT, poll: POLL)
+      [list_agents, read_agent(timeout: read_timeout, poll: poll), steer_agent, stop_agent]
+    end
+
+    def list_agents
+      Tool.define(
+        "list_agents",
+        "See your workers: who is running, who finished, who was stopped. " \
+        "Check here before spawning a duplicate."
+      ) do |_args, context|
+        children = context.session.children
+        next "You have no workers." if children.empty?
+
+        children.map do |child|
+          "#{child.name} (#{child.session_id[0, 8]}): #{child.status}"
+        end.join("\n")
+      end
+    end
+
+    def read_agent(timeout: READ_TIMEOUT, poll: POLL)
+      Tool.define(
+        "read_agent",
+        "Read what a worker has done so far without interrupting it, or pass " \
+        "wait to block until it finishes and get its report.",
+        schema: lambda {
+          string :agent, "The worker's name or session id", required: true
+          integer :tail, "How many recent entries to read (default 20)"
+          boolean :wait, "Block until the worker finishes, then return its report"
+        }
+      ) do |args, context|
+        child = Console.find(context.session, args["agent"])
+        next Console.unknown(context.session, args["agent"]) unless child
+
+        if args["wait"]
+          Console.await(child, timeout, poll, context.signal)
+        else
+          Console.render(child, args.fetch("tail", 20).to_i.clamp(1, 200))
+        end
+      end
+    end
+
+    def steer_agent
+      Tool.define(
+        "steer_agent",
+        "Redirect or correct a running worker. It sees your message at its " \
+        "next step; it may finish first. For a full restart, stop it and " \
+        "spawn again with better instructions.",
+        schema: lambda {
+          string :agent, "The worker's name or session id", required: true
+          string :message, "What the worker should know or do differently", required: true
+        }
+      ) do |args, context|
+        child = Console.find(context.session, args["agent"])
+        next Console.unknown(context.session, args["agent"]) unless child
+
+        status = child.status
+        if Child::LIVE.include?(status)
+          child.say(args.fetch("message"))
+          "Queued. #{child.name} sees it at its next step; it may finish first."
+        else
+          "#{child.name} is #{status}, so there is nothing to steer. " \
+            "Spawn a new worker for follow-up work."
+        end
+      end
+    end
+
+    def stop_agent
+      Tool.define(
+        "stop_agent",
+        "Stop one worker. Its partial work is kept and its transcript stays " \
+        "readable. Other workers and your own run continue.",
+        schema: lambda {
+          string :agent, "The worker's name or session id", required: true
+        }
+      ) do |args, context|
+        child = Console.find(context.session, args["agent"])
+        next Console.unknown(context.session, args["agent"]) unless child
+
+        status = child.status
+        if !Child::LIVE.include?(status)
+          "#{child.name} is already #{status}."
+        elsif !child.stop
+          "Stopping needs a lock adapter (Mistri.locks) and none is configured."
+        elsif status == :queued
+          "Cancelled. #{child.name} had not started and never will."
+        else
+          "Stop requested. #{child.name} halts within a second or two; " \
+            "its partial work stays readable through read_agent."
+        end
+      end
+    end
+
+    # Ids are advertised as unambiguous, so they resolve first: exact, then
+    # an 8+ character prefix (what list_agents displays). Names come last,
+    # latest spawn winning on duplicates, so a model-chosen name can never
+    # shadow another worker's id.
+    def find(session, ref)
+      children = session.children
+      children.find { |child| child.session_id == ref } ||
+        (ref.to_s.length >= 8 &&
+          children.find { |child| child.session_id.start_with?(ref) }) ||
+        children.reverse_each.find { |child| child.name == ref }
+    end
+
+    def unknown(session, ref)
+      names = session.children.map(&:name).uniq
+      known = names.empty? ? "you have no workers" : "your workers: #{names.join(", ")}"
+      "No worker matches #{ref.inspect}; #{known}."
+    end
+
+    # The wait is cooperative like everything else: the run's abort ends it
+    # promptly, never held hostage to the timeout.
+    def await(child, timeout, poll, signal = nil)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      while Child::LIVE.include?(status = child.status)
+        return "The wait was stopped; #{child.name} is still #{status}." if signal&.aborted?
+
+        if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+          return "#{child.name} is still #{status} after #{timeout.round}s. " \
+                 "Read it without wait to see progress, or stop it."
+        end
+        sleep poll
+      end
+      report = child.report
+      "#{child.name} #{child.status}." + (report ? "\n#{report}" : "")
+    end
+
+    # A compact, readable transcript for a model: one line per entry, text
+    # extracted, long values truncated. The gem never summarizes; the
+    # caller can.
+    def render(child, tail)
+      entries = child.transcript(tail: tail)
+      return "#{child.name} (#{child.status}): no entries yet." if entries.empty?
+
+      lines = entries.map { |entry| Console.line(entry) }.compact
+      "#{child.name} (#{child.status}), last #{lines.length} entries:\n#{lines.join("\n")}"
+    end
+
+    def line(entry)
+      case entry["type"]
+      when "message" then message_line(entry["message"] || {})
+      when Child::TERMINAL
+        ["#{entry["status"]}:", entry["report"] || entry["error"]].compact.join(" ")[0, 300]
+      end
+    end
+
+    # Tool calls ride the message's content as typed blocks, never as a
+    # separate key; render both channels from the blocks.
+    def message_line(message)
+      blocks = message["content"].is_a?(Array) ? message["content"] : []
+      calls = blocks.filter_map do |block|
+        next unless block.is_a?(Hash) && block["type"] == "tool_call"
+
+        "#{block["name"]}(#{JSON.generate(block["arguments"] || {})[0, 80]})"
+      end
+      text = Console.text_of(message["content"])
+      parts = [text[0, 240], *calls].reject { |part| part.to_s.empty? }
+      "#{message["role"]}: #{parts.join(" | ")}" unless parts.empty?
+    end
+
+    def text_of(content)
+      return content.to_s unless content.is_a?(Array)
+
+      content.filter_map { |block| block["text"] if block.is_a?(Hash) }.join(" ")
+    end
+  end
+end

data/lib/mistri/dispatchers.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mistri
+  # How a background child actually executes. The spawn tool hands every
+  # dispatcher two things: the serializable spec (name, session_id,
+  # parent_session_id, type, instructions, tool_names, model, workspace,
+  # task) and a runner closure that executes the child in this process with
+  # everything already reconstructed.
+  #
+  # In-process dispatchers just call the runner. A queue dispatcher ignores
+  # the runner, enqueues the spec, and its job reconstructs the pieces from
+  # host registries and calls SubAgent.run_dispatched:
+  #
+  #   dispatcher: ->(spec, _runner) { ChildRunJob.perform_async(spec) }
+  #
+  # The runner closes over the spawn-time event sink, so in-process
+  # children keep streaming to whoever watched the spawn; that sink must
+  # outlive the parent's turn (a broadcast lambda does, a request-scoped
+  # object may not).
+  module Dispatchers
+    # Runs the child synchronously inside the spawn call and still answers
+    # in receipt form: background degrades gracefully where no concurrency
+    # exists (consoles, tests), and the receipt stays truthful because it
+    # reads the child's status after dispatch.
+    class Inline
+      def call(_spec, runner) = runner.call
+    end
+
+    # Real in-process background: the child runs on its own thread and the
+    # spawn call returns immediately. Enough for development and for hosts
+    # whose children are short; queue-backed hosts plug their own lambda.
+    class Thread
+      def call(spec, runner)
+        ::Thread.new do
+          runner.call
+        rescue StandardError => e
+          # The runner writes the child's failed terminal before re-raising;
+          # a thread must not die loudly into the process, but it must not
+          # die silently either, or there is no trace to debug from.
+          warn "mistri: background runner for #{spec["name"].inspect} crashed: " \
+               "#{e.class}: #{e.message}"
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/mistri/event.rb

@@ -15,7 +15,8 @@ module Mistri
   # events; nil where nothing ran (denials, interruptions).
   class Event < Data.define(:type, :content_index, :delta, :content, :tool_call,
                             :reason, :message, :error_message, :partial, :origin,
-                            :duration, :attempt, :max_attempts, :delay)
+                            :duration, :attempt, :max_attempts, :delay,
+                            :agent, :session_id, :status)
     # The stream types come from a provider mid-turn; the loop adds
     # :tool_result after it runs each tool, :approval_needed when a gated
     # call parks for a human, :compacting/:compaction around a context
@@ -23,6 +24,9 @@ module Mistri
     # waits out a transient failure, so one subscription sees the whole
     # exchange. :done and :error are loop-owned and terminal: only the
     # accepted attempt's terminal event reaches the subscriber.
+    # :subagent_report announces a background child's terminal outcome
+    # (agent, session_id, status; content carries the report), so a UI that
+    # watched the spawn can settle the child's lane the moment it ends.
     TYPES = %i[
       start
       text_start text_delta text_end
@@ -32,11 +36,13 @@ module Mistri
       tool_result approval_needed
       compacting compaction
       retry
+      subagent_report
     ].freeze
 
     def initialize(type:, content_index: nil, delta: nil, content: nil, tool_call: nil,
                    reason: nil, message: nil, error_message: nil, partial: nil, origin: nil,
-                   duration: nil, attempt: nil, max_attempts: nil, delay: nil)
+                   duration: nil, attempt: nil, max_attempts: nil, delay: nil,
+                   agent: nil, session_id: nil, status: nil)
       raise ArgumentError, "unknown event type #{type.inspect}" unless TYPES.include?(type)
 
       super
@@ -52,7 +58,7 @@ module Mistri
     def to_h
       { type:, content_index:, delta:, content:, tool_call: tool_call&.to_h,
         reason:, message: message&.to_h, error_message:, origin:, duration:,
-        attempt:, max_attempts:, delay: }.compact
+        attempt:, max_attempts:, delay:, agent:, session_id:, status: }.compact
     end
   end
 end

data/lib/mistri/locks/rails_cache.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Opt-in, exactly like Stores::ActiveRecord: the gem never requires Rails.
+# require "mistri/locks/rails_cache".
+module Mistri
+  module Locks
+    # Leases and flags over an ActiveSupport::Cache::Store (Redis-backed in
+    # any real deployment), so every process in the fleet reads the same
+    # truth. Pass any cache store duck; defaults to Rails.cache.
+    class RailsCache
+      def initialize(cache: nil, namespace: "mistri:locks")
+        @cache = cache || (defined?(Rails) && Rails.cache) ||
+                 raise(ConfigurationError, "no cache store; pass cache: or configure Rails.cache")
+        @namespace = namespace
+      end
+
+      def acquire(key, ttl:)
+        @cache.write(scoped(key), true, unless_exist: true, expires_in: ttl)
+      end
+
+      def renew(key, ttl:)
+        @cache.write(scoped(key), true, expires_in: ttl)
+        nil
+      end
+
+      def release(key)
+        @cache.delete(scoped(key))
+        nil
+      end
+
+      def held?(key)
+        @cache.exist?(scoped(key))
+      end
+
+      def set_flag(key, ttl: 300)
+        renew(key, ttl: ttl)
+      end
+
+      def flag?(key) = held?(key)
+
+      def clear_flag(key) = release(key)
+
+      private
+
+      def scoped(key) = "#{@namespace}:#{key}"
+    end
+  end
+end

data/lib/mistri/locks.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Mistri
+  # Cross-process coordination for hosts that run loops in more than one
+  # process: leases that say "this is alive right now" and flags that carry
+  # one-bit requests (stop) between processes. Everything expires on its
+  # own, so a crashed holder never wedges anything; a live holder renews on
+  # a heartbeat, so only dead ones expire.
+  #
+  # Configure once at boot:
+  #
+  #   Mistri.locks = Mistri::Locks::Memory.new          # single process
+  #   Mistri.locks = Mistri::Locks::RailsCache.new      # requires opt-in file
+  #
+  # An adapter implements six methods: acquire(key, ttl:) -> bool,
+  # renew(key, ttl:), release(key), held?(key), set_flag(key, ttl:),
+  # flag?(key), clear_flag(key). With no adapter configured, everything
+  # lease-aware degrades gracefully: children read :running instead of
+  # :interrupted, and holds are no-ops.
+  module Locks
+    LEASE_TTL = 180
+    HEARTBEAT = 60
+
+    module_function
+
+    # Hold a lease for the duration of a block of work: acquire, renew on a
+    # heartbeat from a background thread, release on the way out. Returns a
+    # Hold to release in an ensure, or nil when no adapter is configured or
+    # the lease is already held elsewhere: a caller that was refused must
+    # never renew or delete the real holder's key. Callers that need to
+    # tell refusal apart from no-adapter use the adapter's acquire directly.
+    #
+    # With stop_key: and signal:, the same thread watches the flag and trips
+    # the signal within a tick, so a stop request written in another process
+    # becomes this run's cooperative abort.
+    def hold(key, ttl: LEASE_TTL, heartbeat: HEARTBEAT, stop_key: nil, signal: nil)
+      adapter = Mistri.locks
+      return nil unless adapter
+      return nil unless adapter.acquire(key, ttl: ttl)
+
+      Hold.new(adapter, key, ttl, heartbeat, stop_key: stop_key, signal: signal)
+    end
+
+    # A held lease: one thread renews it on the heartbeat and watches the
+    # stop flag between renewals. Renewal runs on a monotonic deadline (the
+    # last sleep before it is the remaining fraction, never a full tick, so
+    # the cadence is exact and a lease can never lapse waiting for a tick to
+    # round up). release stops the thread (and joins it, so a mid-renewal
+    # tick can never re-stamp a lease that was just released) and deletes
+    # the key.
+    class Hold
+      def initialize(adapter, key, ttl, heartbeat, stop_key: nil, signal: nil)
+        @adapter = adapter
+        @key = key
+        @stopping = false
+        @thread = Thread.new do
+          deadline = now + heartbeat
+          until @stopping
+            sleep (deadline - now).clamp(0.01, 1.0)
+            break if @stopping
+
+            signal.abort!("stopped by user") if stop_key && signal && adapter.flag?(stop_key)
+            if now >= deadline
+              adapter.renew(key, ttl: ttl)
+              deadline = now + heartbeat
+            end
+          end
+        end
+      end
+
+      def release
+        @stopping = true
+        @thread.kill
+        @thread.join(2)
+        @adapter.release(@key)
+      end
+
+      private
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # The in-process adapter: real TTL semantics over a hash, for tests,
+    # development, and the thread dispatcher. Monitor-synchronized; expiry
+    # is judged at read time, so nothing needs a sweeper.
+    class Memory
+      def initialize
+        @entries = {}
+        @lock = Monitor.new
+      end
+
+      def acquire(key, ttl:)
+        @lock.synchronize do
+          return false if live?(key)
+
+          @entries[key] = deadline(ttl)
+          true
+        end
+      end
+
+      def renew(key, ttl:)
+        @lock.synchronize { @entries[key] = deadline(ttl) }
+        nil
+      end
+
+      def release(key)
+        @lock.synchronize { @entries.delete(key) }
+        nil
+      end
+
+      def held?(key)
+        @lock.synchronize { live?(key) }
+      end
+
+      def set_flag(key, ttl: 300)
+        renew(key, ttl: ttl)
+      end
+
+      def flag?(key) = held?(key)
+
+      def clear_flag(key) = release(key)
+
+      private
+
+      def live?(key)
+        deadline = @entries[key]
+        return false unless deadline
+        return true if deadline > now
+
+        @entries.delete(key)
+        false
+      end
+
+      def deadline(ttl) = now + ttl
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/mistri/mcp.rb

@@ -5,7 +5,7 @@ require "json"
 module Mistri
   # Bridge Model Context Protocol servers into Mistri tools: list a server's
   # tools, hand them to an agent, and everything the harness already does
-  # composes — approval gates on third-party write tools, retries, sub-agent
+  # composes: approval gates on third-party write tools, retries, sub-agent
   # pools, the ui channel.
   #
   #   client = Mistri::MCP::Client.new(url: "https://mcp.linear.app/mcp",

data/lib/mistri/providers/fake.rb

@@ -67,18 +67,32 @@ module Mistri
         kind == :text ? Content::Text.new(text:) : Content::Thinking.new(thinking: text)
       end
 
+      # Arguments stream in chunks, and every delta's partial carries the
+      # in-progress call with the arguments parsed so far, the same shape a
+      # real assembler builds, so a consumer that renders tool input as it
+      # arrives (a page preview, a code block) is testable headless.
       def stream_tool_call(spec, position, blocks, emit)
         spec = spec.transform_keys(&:to_sym)
         call = ToolCall.new(id: spec[:id] || "call_#{position + 1}", name: spec[:name],
                             arguments: (spec[:arguments] || {}).transform_keys(&:to_s))
         index = blocks.size
         emit_event(emit, :toolcall_start, blocks, content_index: index)
-        emit_event(emit, :toolcall_delta, blocks, content_index: index,
-                                                  delta: JSON.generate(call.arguments))
+        built = +""
+        JSON.generate(call.arguments).scan(/.{1,#{@chunk_size}}/m) do |chunk|
+          built << chunk
+          emit_event(emit, :toolcall_delta, blocks + [in_progress(call, built)],
+                     content_index: index, delta: chunk)
+        end
         blocks << call
         emit_event(emit, :toolcall_end, blocks, content_index: index, tool_call: call)
       end
 
+      def in_progress(call, json)
+        parsed = PartialJson.parse(json)
+        ToolCall.new(id: call.id, name: call.name,
+                     arguments: parsed.is_a?(Hash) ? parsed : {})
+      end
+
       def finish(turn, blocks, emit)
         reason = turn[:stop_reason] ||
                  (blocks.any?(ToolCall) ? StopReason::TOOL_USE : StopReason::STOP)

data/lib/mistri/result.rb

@@ -12,8 +12,12 @@ module Mistri
   # output is a task's validated value, nil on plain runs. usage is the
   # run's own accounting: every persisted turn plus compaction calls, summed
   # (a resumed run counts from the resume; task sums across its fix passes).
-  Result = Data.define(:message, :status, :pending, :output, :usage) do
-    def initialize(message:, status:, pending: [], output: nil, usage: Usage.zero)
+  # handed_off marks a run that ended because an ends_turn tool executed:
+  # complete, but the final word was the tool's, and whatever comes next (a
+  # human's answer) arrives as the next run's input.
+  Result = Data.define(:message, :status, :pending, :output, :usage, :handed_off) do
+    def initialize(message:, status:, pending: [], output: nil, usage: Usage.zero,
+                   handed_off: false)
       super
     end
 
@@ -22,6 +26,7 @@ module Mistri
     def aborted? = status == :aborted
     def stopped_by_budget? = status == :budget
     def errored? = status == :error
+    def handed_off? = handed_off
 
     def text = message&.text
     def stop_reason = message&.stop_reason