xeno 0.0.1

data/lib/xeno/channels.rb

@@ -0,0 +1,68 @@
+module Xeno
+  # The channel registry. A channel (a) normalizes platform input into user
+  # messages, (b) owns the session's continuation token, and (c) decides
+  # delivery of agent output. HTTP is built in; agent/channels/*.rb declare
+  # the rest via the DSL:
+  #
+  #   Xeno.channel :slack do
+  #     signing_secret Rails.application.credentials.dig(:slack, :signing_secret)
+  #     bot_token     Rails.application.credentials.dig(:slack, :bot_token)
+  #   end
+  #
+  # Delivery is a failable nicety: the durable truth lives in the transcript
+  # and event rows, so a failed post logs and moves on.
+  module Channels
+    module_function
+
+    def registry
+      @registry ||= {}
+    end
+
+    def register(name, channel)
+      registry[name.to_sym] = channel
+    end
+
+    def build(name, &block)
+      case name.to_sym
+      when :slack
+        Slack.new(&block)
+      else
+        raise Xeno::Error, "unknown channel type: #{name} (v0.1 ships :slack; http is built in)"
+      end
+    end
+
+    def for_session(session)
+      registry[session.channel&.to_sym]
+    end
+
+    def deliver_completion(session, content)
+      for_session(session)&.deliver_completion(session, content)
+    rescue StandardError => e
+      Rails.logger.warn("xeno: channel delivery failed for session #{session.id}: #{e.class}: #{e.message}")
+    end
+
+    def deliver_input_request(session, actions)
+      for_session(session)&.deliver_input_request(session, actions)
+    rescue StandardError => e
+      Rails.logger.warn("xeno: channel input-request delivery failed for session #{session.id}: #{e.class}: #{e.message}")
+    end
+
+    # A per-reply delta sink (post-then-edit streaming) when the session's
+    # channel opts in; nil otherwise. Failable nicety like all delivery.
+    def streamer_for(session)
+      channel = for_session(session)
+      return nil unless channel.respond_to?(:streamer_for)
+
+      channel.streamer_for(session)
+    rescue StandardError => e
+      Rails.logger.warn("xeno: channel streamer setup failed for session #{session.id}: #{e.class}: #{e.message}")
+      nil
+    end
+  end
+
+  def self.channel(name, &block)
+    channel = Channels.build(name, &block)
+    Channels.register(name, channel)
+    channel
+  end
+end

data/lib/xeno/compaction.rb

@@ -0,0 +1,165 @@
+module Xeno
+  # Summarize-and-replace compaction, mixed into TurnRunner and executed as
+  # a claimed turn (kind: "compaction"). Riding the turn machinery buys the
+  # hard properties for free: the claim CAS makes it exclusive, session
+  # ordering queues it behind an active or parked turn, the heartbeat covers
+  # the summary model call, and a crash replays it (the applied result is
+  # recorded on the turn row, so replay never compacts twice).
+  #
+  # Shape: the system prompt survives untouched; the most recent
+  # `compaction_tail_turns` user-anchored turns survive verbatim (a tail cut
+  # at a user row can never separate an assistant's tool calls from their
+  # results); everything between is summarized by a throwaway model call
+  # (the active model, never persisted) and REPLACED — the summary is
+  # written into the earliest compacted row so both id- and created_at-
+  # ordering keep it in place, and the remaining rows are destroyed
+  # newest-first (results before the tool_calls they reference).
+  module Compaction
+    SUMMARY_PREFIX = "[Conversation summary — earlier messages were compacted]".freeze
+
+    COMPACTION_PROMPT = <<~PROMPT.freeze
+      You are compacting an agent conversation to reclaim context space.
+      Write a dense summary of the transcript below; it will REPLACE those
+      messages permanently. Separate completed work and decisions from
+      remaining or open work. Retain every constraint, preference, fact,
+      identifier, amount, and reference a future turn could need. Output
+      only the summary text.
+    PROMPT
+
+    private
+
+    def run_compaction
+      unless compaction_applied?
+        rows = @chat.messages_association.order(:id).to_a
+        plan = compaction_plan(rows)
+
+        if plan[:compact].size < 2
+          record_compaction_result(compacted_messages: 0)
+        else
+          summary = with_heartbeat { compaction_summary(plan[:compact]) }
+          apply_compaction!(plan, summary)
+        end
+      end
+
+      turn.fenced_update!(token, status: "completed", heartbeat_at: Time.current)
+      session.emit("turn.completed", { turn_id: turn.id, sequence: turn.sequence })
+      advance_session
+    end
+
+    def compaction_applied?
+      (turn.user_message || {}).key?("result")
+    end
+
+    # Everything strictly before the tail is compactable. The tail starts at
+    # the Nth-from-last user row; with too few turns there is nothing to do.
+    def compaction_plan(rows)
+      system_rows, convo = rows.partition { |row| row.role == "system" }
+      user_positions = convo.each_index.select { |i| convo[i].role == "user" }
+      tail_turns = [ Xeno.config.compaction_tail_turns.to_i, 1 ].max
+
+      if user_positions.size <= tail_turns
+        { system: system_rows, compact: [], tail: convo }
+      else
+        tail_start = user_positions[-tail_turns]
+        { system: system_rows, compact: convo[0...tail_start], tail: convo[tail_start..] }
+      end
+    end
+
+    # One model call on a throwaway chat — the active model with the agent's
+    # runtime options, no persistence, no tools. A previous summary (from an
+    # earlier compaction) is just an early row here and flows in whole.
+    def compaction_summary(rows)
+      options = definition.config.model_options
+      llm = RubyLLM.chat(
+        model: definition.config.resolved_model,
+        provider: options[:provider],
+        protocol: options[:protocol],
+        assume_model_exists: options.fetch(:assume_model_exists, false)
+      )
+      llm.with_instructions(COMPACTION_PROMPT)
+      response = llm.ask(render_compaction_transcript(rows))
+      response.content.to_s
+    end
+
+    def render_compaction_transcript(rows)
+      rows.map { |row|
+        parts = [ "#{row.role}:" ]
+        parts << row.content if row.content.present?
+        if row.respond_to?(:ruby_llm_tool_calls) && row.tool_call?
+          row.ruby_llm_tool_calls.each { |call| parts << "[called #{call.name}(#{call.arguments.to_json})]" }
+        end
+        parts.join(" ")
+      }.join("\n\n")
+    end
+
+    # The keeper (earliest compacted row) becomes the summary in place; the
+    # rest are destroyed newest-first. Rows, marker, and the
+    # compaction.completed event commit together — replay after any crash
+    # is a pure no-op past this transaction.
+    def apply_compaction!(plan, summary)
+      keeper, *rest = plan[:compact]
+
+      ActiveRecord::Base.transaction do
+        rest.reverse_each(&:destroy!)
+        # A parent tool call on a surviving earlier row would otherwise
+        # dangle a result FK at the repurposed keeper.
+        keeper.ruby_llm_tool_calls.destroy_all
+        keeper.ruby_llm_parent_tool_call&.update!(result: nil)
+        keeper.update!(
+          role: "user",
+          content: "#{SUMMARY_PREFIX}\n\n#{summary}",
+          thinking_text: nil, thinking_signature: nil
+        )
+        record_compaction_result(compacted_messages: plan[:compact].size)
+      end
+      sync_llm_messages
+    end
+
+    def record_compaction_result(compacted_messages:)
+      ActiveRecord::Base.transaction do
+        turn.fenced_update!(token,
+          user_message: (turn.user_message || {}).merge("result" => { "compacted_messages" => compacted_messages }))
+        session.emit("compaction.completed", { turn_id: turn.id, compacted_messages: compacted_messages })
+      end
+    end
+
+    # Between-turns trigger: after a message turn completes, stage a
+    # compaction turn when the last model call's context usage crossed the
+    # threshold share of the model's window (config fallback when the
+    # registry doesn't know the window).
+    def maybe_stage_compaction
+      threshold = Xeno.config.compaction_threshold
+      return unless threshold
+      return if turn.kind == "compaction"
+
+      limit = compaction_context_limit
+      return unless limit
+
+      used = compaction_tokens_used
+      return unless used && used >= (limit * threshold.to_f)
+      return if session.turns.where(kind: "compaction", status: %w[pending running]).exists?
+
+      session.stage_compaction_turn!(reason: "auto", used: used, limit: limit)
+    end
+
+    def compaction_context_limit
+      window = begin
+        @chat.to_llm.model&.context_window
+      rescue StandardError
+        nil
+      end
+      window || Xeno.config.compaction_context_window
+    end
+
+    # What the provider counted for the last completed call — the truthful
+    # "how full is the context" number, from the per-attempt usage ledger
+    # (message rows no longer carry token columns).
+    def compaction_tokens_used
+      last = @chat.ruby_llm_usages.where(operation: "chat", status: "succeeded")
+                  .where.not(input_tokens: nil).order(:created_at, :id).last
+      return nil unless last
+
+      last.input_tokens.to_i + last.output_tokens.to_i
+    end
+  end
+end

data/lib/xeno/configuration.rb

@@ -0,0 +1,118 @@
+module Xeno
+  # Gem-level runtime knobs, set from an initializer:
+  #
+  #   Xeno.configure do |config|
+  #     config.max_steps = 30
+  #   end
+  #
+  class Configuration
+    # Per-turn model-call budget (RubyLLM's own loop is unbounded; ours is not).
+    attr_accessor :max_steps
+
+    # A turn whose claim ledger reaches this many attempts is poison — it
+    # fails instead of retrying forever.
+    attr_accessor :max_turn_attempts
+
+    # A running turn whose heartbeat is older than this is presumed dead and
+    # reclaimable. Checkpoint replay makes takeover safe; a too-short window
+    # risks overlap with a live-but-slow owner, a too-long one stalls the
+    # session after a hard crash.
+    attr_accessor :turn_stale_after
+
+    # How often the background heartbeat beats while the runner is inside a
+    # model call or a tool body (the calls that can outlast turn_stale_after).
+    # nil (default) = a quarter of turn_stale_after, so a live owner always
+    # beats several times per staleness window.
+    attr_writer :heartbeat_interval
+
+    # Per-session token budgets, enforced BEFORE each model call from the
+    # persisted usage columns (the provider's own counts). Checked
+    # independently per axis; the call that crosses is allowed to finish —
+    # the NEXT call trips. Exceeded → deterministic turn failure with a
+    # budget.exceeded event; the session recovers via reset. nil =
+    # unlimited. Per-agent override: `limits input_tokens:, output_tokens:`
+    # in agent.rb (false disables an axis).
+    attr_accessor :max_input_tokens_per_session, :max_output_tokens_per_session
+
+    # Compaction triggers when the last model call's context usage crosses
+    # this fraction of the model's context window. nil/false
+    # disables automatic compaction (manual stays available).
+    attr_accessor :compaction_threshold
+
+    # Fallback context window (tokens) for models the registry doesn't know
+    # (assume_model_exists). nil = automatic compaction never triggers for
+    # unknown-window models.
+    attr_accessor :compaction_context_window
+
+    # How many of the most recent user-message-anchored turns survive a
+    # compaction verbatim (the "recent tail"). Everything earlier is
+    # summarized and replaced.
+    attr_accessor :compaction_tail_turns
+
+    # Optional lambda answering "is the worker shutting down?" — probed by
+    # the runner between steps; when true the turn releases its claim and
+    # re-enqueues itself so a deploy-style stop resumes promptly on the next
+    # worker instead of waiting out stale-heartbeat reclaim. nil = ask the
+    # queue adapter (`queue_adapter.stopping?` — Solid Queue flips it on
+    # worker shutdown; adapters that don't implement it just return false).
+    attr_accessor :stopping_check
+
+    # Fail-closed HTTP auth lambda. Receives the request; a falsy return is
+    # a 401; a truthy return becomes the request principal.
+    attr_accessor :authenticate
+
+    # How often the SSE stream polls for new events, in seconds.
+    attr_accessor :stream_poll_interval
+
+    # How many events one stream poll reads at most. Bounds the catch-up
+    # read on long sessions (a reconnect from index 0 pages through history
+    # in batches instead of loading every row in one query).
+    attr_accessor :stream_catch_up_batch
+
+    # Optional hard cap on how long one SSE connection is served (seconds).
+    # nil = until the session reaches a terminal status.
+    attr_accessor :stream_max_duration
+
+    # Optional lambda answering "is the server shutting down?" — when true,
+    # open SSE streams close themselves so a graceful stop doesn't wait out
+    # the in-flight-request window (Ctrl-C stays near-instant with tabs
+    # open). nil = detect Puma's graceful stop automatically.
+    attr_accessor :stream_shutdown_check
+
+    def initialize
+      @max_steps = 20
+      @max_turn_attempts = 5
+      @turn_stale_after = 5 * 60 # seconds
+      @heartbeat_interval = nil
+      @max_input_tokens_per_session = nil
+      @max_output_tokens_per_session = nil
+      @compaction_threshold = 0.9
+      @compaction_context_window = nil
+      @compaction_tail_turns = 2
+      @stopping_check = nil
+      @authenticate = nil
+      @stream_poll_interval = 0.25
+      @stream_catch_up_batch = 500
+      @stream_max_duration = nil
+      @stream_shutdown_check = nil
+    end
+
+    def turn_stale_after
+      @turn_stale_after.is_a?(Numeric) ? @turn_stale_after.seconds : @turn_stale_after
+    end
+
+    def heartbeat_interval
+      @heartbeat_interval || turn_stale_after / 4.0
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+end

data/lib/xeno/engine.rb

@@ -0,0 +1,29 @@
+module Xeno
+  class Engine < ::Rails::Engine
+    isolate_namespace Xeno
+
+    # agent/ is a Zeitwerk root namespaced under Xeno with per-slot
+    # submodules: agent/tools/get_weather.rb defines Xeno::Tools::GetWeather.
+    # Non-constant files are xeno's to load: agent.rb is a config DSL,
+    # schedules/ holds markdown, channels/ is a DSL slot in v0.1, lib/ is
+    # plain shared Ruby (required manually by the author).
+    initializer "xeno.agent_autoload", before: :setup_main_autoloader do |app|
+      agent_root = Xeno.agent_root
+      if agent_root&.directory?
+        autoloader = Rails.autoloaders.main
+        autoloader.push_dir(agent_root, namespace: Xeno)
+        autoloader.ignore(agent_root.join("agent.rb"))
+        autoloader.ignore(agent_root.join("instructions.rb"))
+        %w[schedules channels hooks skills lib].each do |dir|
+          autoloader.ignore(agent_root.join(dir))
+        end
+      end
+    end
+
+    # The cached definition holds tool classes; drop it whenever the app
+    # reloads so dev picks up edits under agent/.
+    config.to_prepare do
+      Xeno.reset_definition!
+    end
+  end
+end

data/lib/xeno/errors.rb

@@ -0,0 +1,40 @@
+module Xeno
+  class Error < StandardError; end
+
+  # Raised when a fenced write discovers its claim was reaped — the runner
+  # is a zombie and must abort without touching anything else.
+  class Fenced < Error; end
+
+  # Raised (internally) to park the turn: pending actions need human input.
+  # Never RubyLLM's cancel! — its cleanup destroys in-flight rows.
+  class Parked < Error
+    attr_reader :actions
+
+    def initialize(message = "turn parked awaiting input", actions: [])
+      super(message)
+      @actions = actions
+    end
+  end
+
+  # The per-turn runaway guard tripped.
+  class MaxStepsExceeded < Error; end
+
+  # A session token budget is spent: raised BEFORE the model call that
+  # would overspend. Deterministic turn failure; reset recovers the session.
+  class BudgetExceeded < Error
+    attr_reader :axis, :used, :limit
+
+    def initialize(axis:, used:, limit:)
+      @axis = axis
+      @used = used
+      @limit = limit
+      super("session #{axis} token budget exceeded (#{used}/#{limit})")
+    end
+  end
+
+  # Raised (internally) between runner steps when the worker is shutting
+  # down gracefully: the turn releases its claim and re-enqueues itself so
+  # the next worker resumes it promptly (the AJ Continuation checkpoint
+  # pattern). Not a failure — it never counts against the poison ladder.
+  class Interrupted < Error; end
+end

data/lib/xeno/hooks.rb

@@ -0,0 +1,37 @@
+module Xeno
+  # Observe-only event handlers from agent/hooks/*.rb:
+  #
+  #   Xeno.hook "turn.completed" do |event|
+  #     Metrics.increment("agent.turns", tags: [event.session.channel])
+  #   end
+  #
+  #   Xeno.hook "*" do |event| ... end   # every event
+  #
+  # Semantics:
+  # - Handlers fire AFTER the event row is durably committed (after_commit),
+  #   typed handlers first, then the wildcard. The block receives the
+  #   Xeno::Event record (event_type, data, index, session).
+  # - Observe-only: return values are ignored; hooks cannot veto anything
+  #   or inject model context. A raising handler is logged and skipped — a
+  #   hook can never break the runtime or fail the turn.
+  # - AT-LEAST-ONCE: replayed steps re-emit new events with new indexes.
+  #   Key once-per-step side effects on (turn_id, step) from the data; key
+  #   stored content on (session_id, index).
+  module Hooks
+    module_function
+
+    def dispatch(event, definition: Xeno.definition)
+      hooks = definition.respond_to?(:hooks) ? definition.hooks : {}
+      return if hooks.empty?
+
+      handlers = Array(hooks[event.event_type]) + Array(hooks["*"])
+      handlers.each do |handler|
+        handler.call(event)
+      rescue StandardError => e
+        Rails.logger.warn(
+          "xeno: hook for #{event.event_type} raised #{e.class}: #{e.message} — hooks are observe-only, continuing"
+        )
+      end
+    end
+  end
+end

data/lib/xeno/info.rb

@@ -0,0 +1,75 @@
+module Xeno
+  # Renders the resolved agent for `rake xeno:info` — the discovery
+  # diagnostics surface.
+  module Info
+    module_function
+
+    def render(definition = Xeno.definition)
+      lines = []
+      lines << "Agent: #{definition.name}"
+      lines << "Root:  #{definition.root}"
+      lines << "Model: #{definition.config.resolved_model}#{format_options(definition.config.model_options)}"
+      lines << ""
+
+      dynamic_suffix = definition.dynamic_instructions? ? " + dynamic (instructions.rb, resolved per turn)" : ""
+      if definition.instructions
+        preview = definition.instructions.strip.lines.first&.strip
+        lines << "Instructions: instructions.md (#{definition.instructions.bytesize} bytes)#{dynamic_suffix} — #{preview}"
+      elsif definition.dynamic_instructions?
+        lines << "Instructions: dynamic only (instructions.rb, resolved per turn)"
+      else
+        lines << "Instructions: MISSING"
+      end
+
+      lines << ""
+      lines << "Tools (#{definition.tools.size}):"
+      if definition.tools.any?
+        width = definition.tools.keys.map(&:length).max
+        definition.tools.each do |tool_name, klass|
+          lines << "  #{tool_name.ljust(width)}  #{klass.name}  — #{klass.description || '(no description)'}"
+        end
+      else
+        lines << "  (none — add agent/tools/*.rb)"
+      end
+
+      if definition.schedules.any?
+        lines << ""
+        lines << "Schedules (#{definition.schedules.size}):"
+        width = definition.schedules.keys.map(&:length).max
+        definition.schedules.each do |schedule_name, schedule|
+          lines << "  #{schedule_name.ljust(width)}  #{schedule.cron}  — #{schedule.prompt.lines.first&.strip}"
+        end
+      end
+
+      if definition.channels.any?
+        lines << ""
+        lines << "Channels (#{definition.channels.size} + http built-in):"
+        definition.channels.each_key do |channel_name|
+          lines << "  #{channel_name}"
+        end
+      end
+
+      if definition.respond_to?(:hooks) && definition.hooks.any?
+        lines << ""
+        lines << "Hooks (observe-only, at-least-once):"
+        definition.hooks.each do |event_type, handlers|
+          lines << "  #{event_type}  — #{handlers.size} handler#{'s' if handlers.size > 1}"
+        end
+      end
+
+      if definition.diagnostics.any?
+        lines << ""
+        lines << "Diagnostics:"
+        definition.diagnostics.each do |diag|
+          lines << "  [#{diag.level.upcase}] #{diag.message}"
+        end
+      end
+
+      lines.join("\n")
+    end
+
+    def format_options(options)
+      options.empty? ? "" : " #{options.inspect}"
+    end
+  end
+end

data/lib/xeno/inputs.rb

@@ -0,0 +1,78 @@
+module Xeno
+  # Resolving parked work: approvals, denials, and question answers. Each
+  # resolution updates the action and — once no other action on the turn is
+  # still awaiting input — flips the turn back to pending and enqueues the
+  # resume job. A parked session holds zero compute; this is the only way
+  # back in.
+  module Inputs
+    module_function
+
+    def approve!(action, principal: nil)
+      resolve(action) do
+        action.update!(status: "approved", resolved_at: Time.current, resolved_by: principal)
+      end
+    end
+
+    def deny!(action, reason: nil, principal: nil)
+      resolve(action) do
+        content = JSON.generate({ denied: true, reason: reason || "denied by user" })
+        action.update!(
+          status: "denied",
+          output: { "content" => content },
+          resolved_at: Time.current,
+          resolved_by: principal
+        )
+      end
+    end
+
+    def answer!(action, answer, principal: nil)
+      raise ArgumentError, "not a question: #{action.tool_name}" unless action.kind == "question"
+
+      resolve(action) do
+        action.update!(
+          status: "completed",
+          output: { "content" => JSON.generate({ answer: answer }) },
+          resolved_at: Time.current,
+          resolved_by: principal
+        )
+      end
+    end
+
+    # Shared plumbing: guard the state, apply the resolution, resume when
+    # the turn has nothing else to wait for. Resolution, status flip, and
+    # the resume enqueue commit in ONE transaction: on a DB-backed queue
+    # (Solid Queue shares the app database, and ActiveJob 8.1 enqueues
+    # in-transaction by default) a crash can never separate "approved" from
+    # "job exists" — either everything landed or the input is still pending
+    # and the human just retries. Backends that defer or lose the enqueue
+    # fall back to the reaper's sweeps.
+    def resolve(action)
+      unless action.status == "pending_approval"
+        raise Xeno::Error, "action #{action.id} is not awaiting input (status: #{action.status})"
+      end
+
+      ActiveRecord::Base.transaction do
+        yield
+        resume_turn(action.turn)
+      end
+      action
+    end
+
+    # Resuming with unanswered inputs would generate against partial tool
+    # results (an invalid provider state) — the runner would just re-park,
+    # so don't bother waking it until everything is resolved.
+    def resume_turn(turn)
+      return if turn.actions.where(status: "pending_approval").exists?
+
+      # Resumes are human-driven and unbounded — counted apart from the
+      # failure `attempts` so approvals can never poison the turn (H2).
+      resumed = Turn.where(id: turn.id, status: "waiting")
+                    .update_all("status = 'pending', resumes = resumes + 1")
+      return unless resumed == 1
+
+      turn.session.update!(status: "running") if turn.session.status == "waiting"
+      turn.enqueue!
+      turn
+    end
+  end
+end

data/lib/xeno/reaper.rb

@@ -0,0 +1,52 @@
+module Xeno
+  # The second half of the failure matrix: nothing else owns turns that
+  # fall out of the retry ladder. The reaper finds work that SHOULD be
+  # running but has no live owner and re-enqueues it. Duplicate-safe by
+  # construction — the claim CAS means a redundant TurnJob exits quietly,
+  # and a poisoned turn fails properly at claim time.
+  #
+  # Wiring: ReaperJob rides Solid Queue's recurring machinery (a managed
+  # entry written by Schedules.sync! in mounted mode, storage/recurring.yml
+  # in standalone mode). Other queue backends trigger it however they run
+  # periodic work: `Xeno::ReaperJob.perform_later` or `bin/rails xeno:reap`.
+  module Reaper
+    module_function
+
+    # One sweep. Rescues, in order:
+    # 1. running turns with a stale heartbeat — the owner died mid-step
+    #    (kill -9) or the queue exhausted its retries with the job in the
+    #    failed set; claim! reclaims these directly.
+    # 2. stale pending turns — staged or released-for-retry, but no job
+    #    ever came back (lost/discarded job).
+    # 3. waiting turns with nothing left to wait for — every action
+    #    resolved but the resume enqueue never happened (crash between
+    #    resolve and enqueue). Genuinely parked turns are never touched.
+    def sweep!(stale_before: Xeno.config.turn_stale_after.ago)
+      rescued = []
+
+      Turn.where(status: "running")
+          .where("heartbeat_at IS NULL OR heartbeat_at < ?", stale_before)
+          .find_each do |turn|
+        turn.enqueue!
+        rescued << turn
+      end
+
+      Turn.where(status: "pending")
+          .where(updated_at: ...stale_before)
+          .find_each do |turn|
+        turn.enqueue!
+        rescued << turn
+      end
+
+      Turn.where(status: "waiting")
+          .where(updated_at: ...stale_before)
+          .find_each do |turn|
+        next if turn.actions.where(status: "pending_approval").exists?
+
+        rescued << turn if Inputs.resume_turn(turn)
+      end
+
+      rescued
+    end
+  end
+end