silas 0.3.2 → 0.5.0

data/lib/silas/compactor.rb

@@ -0,0 +1,178 @@
+module Silas
+  # Keeps long sessions under the model's context window by summarising prior
+  # turns into a Compaction row — the alternative today is the provider
+  # rejecting the prompt and the turn failing.
+  #
+  # The design constraint comes from MessageBuilder: replayed executions must
+  # produce byte-identical message arrays, so a summary can never be computed
+  # at build time. Compaction is therefore an EFFECT, made exactly-once the
+  # same way tool effects are:
+  #
+  #   - ensure! runs at the top of each step, INSIDE the isolated continuation
+  #     step. A crash anywhere re-runs the whole step, and the unique index on
+  #     (session_id, up_to_turn_index) makes the claim idempotent.
+  #   - The summary model call happens once; the row it completes is what
+  #     MessageBuilder reads from then on. A crash mid-summary leaves a
+  #     pending row; the re-run summarises again and completes it — no step
+  #     ever executed against the lost draft.
+  #   - The boundary is fixed for the whole turn (all PRIOR turns, 0..index-1),
+  #     so a re-executed step finds the same row a crashed attempt created:
+  #     same rows in, same messages out.
+  #
+  # What it deliberately does not do (v1): compact within the current turn —
+  # a single turn's growth is bounded by max_steps, while a session's turn
+  # count is unbounded, and mid-turn boundaries would cut between a tool_use
+  # and its result. If the current turn alone outgrows the window, that is
+  # max_steps' problem, not compaction's.
+  module Compactor
+    module_function
+
+    SUMMARY_SYSTEM = <<~PROMPT.freeze
+      You are compacting the earlier part of a long conversation so it can
+      continue within the model's context window. Write a dense summary that
+      preserves everything a future turn might rely on: facts and figures,
+      decisions made, tool calls and their results (ids, amounts, names),
+      commitments given to the user, and anything explicitly left open.
+      Write it as plain prose. Do not add commentary about the summarisation
+      itself.
+    PROMPT
+
+    # Per-block caps keep the summarisation call itself well under the window.
+    TOOL_RESULT_CHARS = 2_000
+    TEXT_CHARS = 4_000
+
+    # Called before each step's model call. Returns the applicable completed
+    # Compaction (or nil), creating it first when the context has outgrown the
+    # threshold.
+    def ensure!(turn)
+      threshold = threshold_for(turn)
+      return Compaction.latest_for(turn) if threshold.nil? # feature off: existing rows still apply
+      return nil if turn.index.zero?                       # no prior turns to compact
+
+      boundary = turn.index - 1
+      if (existing = Compaction.find_by(session_id: turn.session_id, up_to_turn_index: boundary))
+        # Pending = a crash mid-summary. The trigger decision was already made
+        # and no step ever ran against the lost draft, so finish the claimed
+        # work rather than re-litigating the threshold.
+        summarise!(turn, existing) unless existing.completed?
+        return Compaction.latest_for(turn)
+      end
+
+      measured = measured_context(turn)
+      return Compaction.latest_for(turn) if measured.nil? || measured < threshold
+
+      row = claim!(turn, boundary, measured)
+      summarise!(turn, row) if row # nil: a racer claimed AND completed it
+      Compaction.latest_for(turn)
+    end
+
+    # The provider's own measure of the prompt: the last completed step's
+    # input_tokens IS the context size of the previous model call. Persisted,
+    # so a replayed trigger decision reads the same number.
+    def measured_context(turn)
+      Step.joins(:turn)
+          .where(silas_turns: { session_id: turn.session_id })
+          .where.not(input_tokens: nil)
+          .order(id: :desc).limit(1).pick(:input_tokens)
+    end
+
+    # config.compact_at: a Float in (0, 1] is a fraction of the model's
+    # registry context window (unknown window => off); an Integer is an
+    # absolute token threshold (works with any adapter — custom engines and
+    # the chaos harness have no registry entry). nil/false disables.
+    def threshold_for(turn)
+      setting = Silas.config.compact_at
+      return nil unless setting
+      return setting if setting.is_a?(Integer)
+
+      window = context_window_for(StepRunner.turn_model(turn))
+      window && (window * setting.to_f).to_i
+    end
+
+    def context_window_for(model)
+      ::RubyLLM.models.find(model).context_window
+    rescue StandardError
+      nil
+    end
+
+    def claim!(turn, boundary, measured)
+      Compaction.create!(
+        session_id: turn.session_id,
+        up_to_turn: Turn.find_by!(session_id: turn.session_id, index: boundary),
+        up_to_turn_index: boundary,
+        status: "pending",
+        tokens_before: measured
+      )
+    rescue ActiveRecord::RecordNotUnique
+      # A racing execution claimed it. Pending -> finish their summary work;
+      # completed -> nothing to do (nil tells the caller to just read).
+      row = Compaction.find_by!(session_id: turn.session_id, up_to_turn_index: boundary)
+      row.completed? ? nil : row
+    end
+
+    def summarise!(turn, row)
+      model = StepRunner.turn_model(turn)
+      Silas.instrument(:compact, session_id: turn.session_id, turn_id: turn.id,
+                                 up_to_turn_index: row.up_to_turn_index,
+                                 tokens_before: row.tokens_before, model: model) do |payload|
+        context = {
+          turn: turn, index: nil, compaction: true,
+          system: SUMMARY_SYSTEM,
+          messages: [ { role: "user", content: transcript_for(turn, row) } ],
+          tools: [], model: model, final_answer: nil, limits: {}
+        }
+
+        engine = Silas.resolved_adapter
+        result =
+          if (hook = Silas.config.around_model_call)
+            hook.call(context) { engine.execute_step(context) }
+          else
+            engine.execute_step(context)
+          end
+
+        summary = result.blocks.select { |b| b["type"] == "text" }.map { |b| b["text"] }.join
+        row.update!(status: "completed", summary: summary, model: model,
+                    input_tokens: result.usage&.dig(:input_tokens),
+                    output_tokens: result.usage&.dig(:output_tokens))
+        payload[:input_tokens] = row.input_tokens
+        payload[:output_tokens] = row.output_tokens
+      end
+    end
+
+    # The span rendered as a plain-text transcript — one user message into the
+    # summary call. Recursive by construction: a previous summary opens the
+    # transcript, so each compaction folds the last one in.
+    def transcript_for(turn, row)
+      parts = []
+      previous = Compaction.completed
+                           .where(session_id: turn.session_id)
+                           .where(up_to_turn_index: ...row.up_to_turn_index)
+                           .order(:up_to_turn_index).last
+      parts << "Earlier conversation, already summarised:\n#{previous.summary}" if previous
+
+      floor = previous ? previous.up_to_turn_index : -1
+      Turn.where(session_id: turn.session_id, index: (floor + 1)..row.up_to_turn_index)
+          .order(:index).each do |prior|
+        parts << "User: #{prior.input}"
+        Step.where(turn_id: prior.id).order(:index).select(&:completed?).each do |step|
+          parts.concat(step_lines(step))
+        end
+      end
+      parts.join("\n\n")
+    end
+
+    def step_lines(step)
+      lines = Array(step.response_blocks).filter_map do |b|
+        case b["type"]
+        when "text"       then "Assistant: #{b['text'].to_s.truncate(TEXT_CHARS)}"
+        when "structured" then "Assistant (structured answer): #{JSON.generate(b['data'])}"
+        end
+      end
+      ToolInvocation.where(step_id: step.id).order(:id).each do |inv|
+        lines << "Assistant called #{inv.tool_name}(#{JSON.generate(inv.arguments || {})}) " \
+                 "-> #{JSON.generate(inv.result || inv.status).truncate(TOOL_RESULT_CHARS)}"
+      end
+      lines
+    end
+  end
+end

data/lib/silas/configuration.rb

@@ -1,7 +1,9 @@
 module Silas
   class Configuration
-    # Inference engine seam: :ruby_llm, or any object responding to #execute_step.
-    attr_accessor :engine
+    # Inference adapter seam: :ruby_llm, or any object responding to
+    # #execute_step. (Named `engine` before 0.4 — see the deprecated alias
+    # below; "engine" already meant the Rails engine at Silas::Engine.)
+    attr_accessor :adapter
     # Default model when agent.yml doesn't specify one.
     attr_accessor :default_model
     # Active Job queue for agent turns.
@@ -14,6 +16,14 @@ module Silas
     attr_accessor :approval_ttl
     # Hard cap on model calls per turn (agent.yml can lower it per-agent).
     attr_accessor :max_steps
+    # Context compaction trigger. A Float in (0, 1] compacts when the measured
+    # context passes that fraction of the model's registry context window
+    # (models the registry doesn't know are never compacted). An Integer is an
+    # absolute token threshold — the form custom adapters need, since they
+    # have no registry entry. nil/false disables. Compaction summarises PRIOR
+    # turns into a persisted row (exactly-once, replay-deterministic); the
+    # current turn is never compacted.
+    attr_accessor :compact_at
     # Continuation isolation for loop steps. true in production (persistence
     # per step — the durability contract); specs may disable for inline runs.
     attr_accessor :isolate_steps
@@ -31,6 +41,12 @@ module Silas
     # Memory (silas_memories): memory=false disables entirely; memory_approval
     # :always parks every remember for a human (default), :never auto-approves.
     attr_accessor :memory, :memory_approval, :memory_injection_limit
+    # The ask_question builtin (agent parks to ask the operator something;
+    # answered from the inbox/API). false removes it from the toolset — note
+    # that adding/removing a builtin changes the definitions digest, so turns
+    # PARKED across that change fail loudly on resume (the nondeterminism
+    # guard working as designed). Settle parked turns before flipping this.
+    attr_accessor :ask_question
     # Channels: name -> Channel subclass (wired by the Registry). Slack creds
     # default to credentials.dig(:silas, :slack, ...); nil disables Slack.
     attr_accessor :channel_resolver
@@ -39,8 +55,21 @@ module Silas
     # tools as MCP" seam).
     attr_accessor :mcp_server_host
 
+    # Renamed in 0.4, removed in 2.0. "engine" meant two unrelated things —
+    # the Rails engine (Silas::Engine) and the inference backend — the exact
+    # collision ActiveJob avoids by calling its seam QueueAdapters.
+    def engine
+      Silas.deprecator.warn("config.engine is deprecated; use config.adapter")
+      adapter
+    end
+
+    def engine=(value)
+      Silas.deprecator.warn("config.engine= is deprecated; use config.adapter=")
+      self.adapter = value
+    end
+
     # config.auth and the agent_sdk_* options were removed with the :agent_sdk
-    # engine in 0.2 (warning no-ops for one release) and hard-removed in 0.3 —
+    # adapter in 0.2 (warning no-ops for one release) and hard-removed in 0.3 —
     # a leftover write now raises NoMethodError. Delete them from your
     # initializer.
     # JSON API (mounted under /silas/api/v1).
@@ -83,7 +112,7 @@ module Silas
     end
 
     def initialize
-      @engine = :ruby_llm
+      @adapter = :ruby_llm
       # Must be resolvable by the installed ruby_llm's model registry — newer
       # Claude models may need `RubyLLM.models.refresh!` before they resolve.
       # (Sonnet 4.5 ships in every supported registry; never default a first
@@ -93,6 +122,7 @@ module Silas
       @around_model_call = nil
       @approval_ttl = 7.days
       @max_steps = 25
+      @compact_at = 0.9
       @isolate_steps = true
       @tool_resolver = nil
       @tool_definitions = nil
@@ -113,6 +143,7 @@ module Silas
       @memory = true
       @memory_approval = :always
       @memory_injection_limit = 8
+      @ask_question = true
       @sandbox_image = nil
       @sandbox_network = "none"
       @sandbox_memory = "512m"
@@ -142,11 +173,11 @@ module Silas
 
     # Fail-loud misconfiguration checks, run from Silas.configure and at boot.
     def boot_guard!
-      if engine == :agent_sdk
+      if adapter == :agent_sdk
         raise BootGuardError,
-              "the :agent_sdk engine was removed in Silas 0.2 — the claude -p subprocess " \
+              "the :agent_sdk adapter was removed in Silas 0.2 — the claude -p subprocess " \
               "integration is gone (its subscription-auth rationale was unreachable). " \
-              "Use engine :ruby_llm, the production path."
+              "Use adapter :ruby_llm, the production path."
       end
 
       check_provider_credentials!
@@ -159,7 +190,7 @@ module Silas
     # always a misconfiguration); warns in development so a fresh app can
     # still boot and browse the inbox before a key exists.
     def check_provider_credentials!
-      return unless engine == :ruby_llm && defined?(::RubyLLM)
+      return unless adapter == :ruby_llm && defined?(::RubyLLM)
 
       providers = ::RubyLLM::Provider.providers.values
       configured = providers.any? do |provider|
@@ -168,7 +199,7 @@ module Silas
       end
       return if configured
 
-      message = "[Silas] engine :ruby_llm has no configured provider — no API key is set on " \
+      message = "[Silas] adapter :ruby_llm has no configured provider — no API key is set on " \
                 "RubyLLM.config. Set one in config/initializers/ruby_llm.rb, e.g. " \
                 "RubyLLM.configure { |c| c.anthropic_api_key = ENV[\"ANTHROPIC_API_KEY\"] } " \
                 "— the first agent turn will fail without it."

data/lib/silas/delta_buffer.rb

@@ -1,5 +1,5 @@
 module Silas
-  # Coalesces model text deltas into ~10Hz "silas.delta" notifications carrying
+  # Coalesces model text deltas into ~10Hz "delta.silas" notifications carrying
   # the ACCUMULATED text so far — subscribers replace rather than append, which
   # is idempotent under a crash-restream (same step id, fresh stream overwrites
   # itself) and ordering-safe under Turbo. Deltas are decoration over the
@@ -38,8 +38,8 @@ module Silas
 
       @published = @text.length
       @last_publish = clock
-      ActiveSupport::Notifications.instrument(
-        "silas.delta",
+      Silas.instrument(
+        :delta,
         session_id: @turn.session_id, turn_id: @turn.id,
         step_id: @step.id, step_index: @step.index, text: @text.dup
       )

data/lib/silas/deprecator.rb

@@ -0,0 +1,16 @@
+module Silas
+  # One deprecator for the whole gem, so hosts can control the noise the way
+  # they control Rails' own:
+  #
+  #   Silas.deprecator.behavior = :raise    # or :warn (default), :silence
+  #
+  # Rails registers it in application.deprecators (see Silas::Engine), which
+  # means `config.active_support.report_deprecations = false` silences Silas
+  # along with everything else, and a host can opt into raising in CI.
+  #
+  # Every deprecation message names BOTH the replacement and the version it
+  # disappears in — a warning you can't act on is just noise.
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("2.0", "Silas")
+  end
+end

data/lib/silas/engine.rb

@@ -1,6 +1,6 @@
 module Silas
   # The Rails engine (not to be confused with inference adapters under
-  # Silas::Engines::*). Full engine: Silas is Rails-native by thesis.
+  # Silas::Adapters::*). Full engine: Silas is Rails-native by thesis.
   class Engine < ::Rails::Engine
     isolate_namespace Silas
 
@@ -33,12 +33,25 @@ module Silas
       end
     end
 
+    # Register with Rails so hosts control Silas's deprecations exactly as they
+    # control everyone else's: config.active_support.report_deprecations,
+    # or `config.silas.deprecator.behavior = :raise` in CI.
+    initializer "silas.deprecator" do |app|
+      app.deprecators[:silas] = Silas.deprecator if app.respond_to?(:deprecators)
+    end
+
     initializer "silas.boot_guard", after: :load_config_initializers do
       Silas.config.boot_guard!
     end
 
+    # Turn the loop's notifications into log lines. Attaching here (rather than
+    # at require time) means a host that never boots Rails pays nothing.
+    initializer "silas.log_subscriber" do
+      Silas::LogSubscriber.attach_to :silas if defined?(Silas::LogSubscriber)
+    end
+
     # Live token streaming into the inbox trace: one process-wide subscriber on
-    # "silas.delta"; a no-op unless turbo-rails is present and streaming is on.
+    # "delta.silas"; a no-op unless turbo-rails is present and streaming is on.
     initializer "silas.delta_broadcaster" do
       Silas::Inbox::DeltaBroadcaster.subscribe!
     end

data/lib/silas/eval/driver.rb

@@ -34,7 +34,7 @@ module Silas
         engine = scenario.real? ? nil : ScriptedEngine.new(scenario.steps)
         base_resolver = Silas.config.tool_resolver
         Silas.configure do |c|
-          c.engine = engine if engine
+          c.adapter = engine if engine
           c.isolate_steps = false
           c.max_steps = scenario.max_steps if scenario.max_steps
           if scenario.stubs.any?

data/lib/silas/eval/dsl.rb

@@ -22,7 +22,7 @@ module Silas
       # on_step(0, text:, call: {name:, arguments:}, calls: [ {…}, … ])
       def on_step(index, text: nil, call: nil, calls: [])
         tcs = (calls + [ call ].compact).each_with_index.map do |c, n|
-          Silas::Engines::ToolCall.new(id: "eval_s#{index}_#{n}", name: c[:name].to_s,
+          Silas::Adapters::ToolCall.new(id: "eval_s#{index}_#{n}", name: c[:name].to_s,
                                        arguments: (c[:arguments] || {}).stringify_keys)
         end
         blocks = []

data/lib/silas/eval/scripted_engine.rb

@@ -3,7 +3,7 @@ module Silas
     # The productized FakeEngine: a pure function of context[:index] that lets an
     # eval script the MODEL's decisions while the REAL Ledger runs the REAL tools —
     # so assertions see a genuine transcript.
-    class ScriptedEngine < Silas::Engines::Base
+    class ScriptedEngine < Silas::Adapters::Base
       attr_reader :calls
 
       def initialize(steps)
@@ -17,7 +17,7 @@ module Silas
         spec = @steps[i]
         return terminal("OK.") unless spec
 
-        Silas::Engines::Result.new(
+        Silas::Adapters::Result.new(
           blocks: spec[:blocks],
           tool_calls: spec[:tool_calls],
           stop_reason: spec[:tool_calls].empty? ? "end_turn" : "tool_use",
@@ -28,7 +28,7 @@ module Silas
       private
 
       def terminal(text)
-        Silas::Engines::Result.new(blocks: [ { "type" => "text", "text" => text } ],
+        Silas::Adapters::Result.new(blocks: [ { "type" => "text", "text" => text } ],
                                    tool_calls: [], stop_reason: "end_turn",
                                    usage: { input_tokens: 1, output_tokens: 1 })
       end

data/lib/silas/inbox/delta_broadcaster.rb

@@ -12,7 +12,7 @@ module Silas
     # the whole step partial (dom_id target) and supersedes anything streamed
     # into the inner text container.
     module DeltaBroadcaster
-      EVENT = "silas.delta".freeze
+      EVENT = "delta.silas".freeze
 
       class << self
         def subscribe!

data/lib/silas/instrumentation.rb

@@ -0,0 +1,59 @@
+module Silas
+  # ActiveSupport::Notifications for the durable loop.
+  #
+  # Until now the loop was silent: a turn could start, park for a human, get
+  # rescued after a kill -9, breach a budget, and finish — without emitting a
+  # single line. This is the seam for logs, APM spans, and metrics.
+  #
+  # Names follow the Rails convention `<event>.silas` (like `sql.active_record`),
+  # so `ActiveSupport::Notifications.subscribe(/\.silas\z/)` gets everything.
+  #
+  #   ActiveSupport::Notifications.subscribe("tool.silas") do |event|
+  #     StatsD.timing("agent.tool", event.duration, tags: ["tool:#{event.payload[:tool]}"])
+  #   end
+  #
+  # ## Events and payloads
+  #
+  # Every payload carries `turn_id` and `session_id` where they exist, so any
+  # subscriber can correlate without joining.
+  #
+  #   turn.silas       status:, reason:, steps:, session_id:, turn_id:, agent:
+  #                    Duration = the whole turn INCLUDING parked time.
+  #   step.silas       index:, model:, turn_id:  (one model call)
+  #   tool.silas       tool:, effect_mode:, status:, approval_state:,
+  #                    invocation_id:, turn_id:
+  #                    Duration = the tool's own execution. The single most
+  #                    useful span in the system.
+  #   delta.silas      session_id:, turn_id:, step_id:, step_index:, text:
+  #                    Streamed text so far (see DeltaBuffer). High frequency.
+  #   park.silas       reason: (approval | question | in_doubt | budget),
+  #                    turn_id:, detail:
+  #   resume.silas     turn_id:, parked_for: (seconds a human took)
+  #   approval.silas   action: (approved | answered | declined | expired),
+  #                    tool:, by:, invocation_id:, turn_id:
+  #   budget.silas     reason: (max_cost | max_input_tokens | timeout), turn_id:
+  #   compact.silas    session_id:, turn_id:, up_to_turn_index:, tokens_before:,
+  #                    input_tokens:, output_tokens:, model:
+  #                    Duration = the summarisation model call.
+  #   rescue.silas     rescued: (jobs retried), stranded: (turns failed)
+  #   nondeterminism.silas  turn_id:, was:, now:  (digest changed mid-turn)
+  module Instrumentation
+    module_function
+
+    def instrument(event, **payload, &block)
+      ActiveSupport::Notifications.instrument("#{event}.silas", **payload, &block)
+    end
+  end
+
+  # Silas.instrument(:tool, tool: "issue_refund") { ... }
+  def self.instrument(event, **payload, &block)
+    Instrumentation.instrument(event, **payload, &block)
+  end
+
+  # The logger Silas writes through; hosts can point it elsewhere.
+  mattr_accessor :logger, default: nil
+
+  def self.logger
+    @@logger ||= (defined?(Rails) && Rails.logger) || ActiveSupport::Logger.new($stdout)
+  end
+end

data/lib/silas/ledger.rb

@@ -88,6 +88,8 @@ module Silas
           when :user_approval
             invocation.update!(approval_state: "required",
                                approval_expires_at: Silas.config.approval_ttl.from_now)
+            Silas.instrument(:park, reason: invocation.question? ? "question" : "approval",
+                                    turn_id: invocation.turn_id, detail: invocation.tool_name)
             return :parked
           when Hash # {denied: "reason"} — eve's shape
             invocation.update!(status: "failed", result: { "denied" => verdict[:denied] })
@@ -107,6 +109,16 @@ module Silas
       end
 
       def execute!(invocation, tool)
+        Silas.instrument(:tool, tool: invocation.tool_name, effect_mode: invocation.effect_mode,
+                                invocation_id: invocation.id, turn_id: invocation.turn_id) do |payload|
+          run_tool!(invocation, tool).tap do
+            payload[:status] = invocation.reload.status
+            payload[:approval_state] = invocation.approval_state
+          end
+        end
+      end
+
+      def run_tool!(invocation, tool)
         tool.session = invocation.turn.session if tool.respond_to?(:session=)
         args = invocation.arguments.symbolize_keys
 
@@ -149,6 +161,8 @@ module Silas
           # decline! = "it ran / abandon", operator supplies the outcome.
           invocation.update!(status: "in_doubt", approval_state: "required",
                              approval_expires_at: Silas.config.approval_ttl.from_now)
+          Silas.instrument(:park, reason: "in_doubt", turn_id: invocation.turn_id,
+                                  detail: invocation.tool_name)
           :parked
         end
       end

data/lib/silas/log_subscriber.rb

@@ -0,0 +1,83 @@
+require "active_support/log_subscriber"
+
+# Turns the loop's notifications into log lines, at levels that match what an
+# operator actually wants paged about: parks and rescues are INFO (a human is
+# now in the loop, or a crash was recovered), budget breaches and
+# nondeterminism are WARN, failed turns are ERROR, and the per-step/per-token
+# chatter stays DEBUG.
+#
+# Attach is automatic (see Silas::Engine). To silence just Silas:
+#   Silas.logger = Logger.new(IO::NULL)
+class Silas::LogSubscriber < ActiveSupport::LogSubscriber
+  def turn(event)
+    status = event.payload[:status]
+    line = formatted_event(event, action: "Turn #{status}",
+                           **event.payload.slice(:turn_id, :session_id, :agent, :steps, :reason).compact)
+    status.to_s == "failed" ? error(line) : info(line)
+  end
+
+  def step(event)
+    debug formatted_event(event, action: "Model call",
+                          **event.payload.slice(:turn_id, :index, :model).compact)
+  end
+
+  def tool(event)
+    line = formatted_event(event, action: "Tool #{event.payload[:tool]}",
+                           **event.payload.slice(:effect_mode, :status, :approval_state, :turn_id).compact)
+    event.payload[:status].to_s == "failed" ? warn(line) : info(line)
+  end
+
+  def park(event)
+    info formatted_event(event, action: "Turn parked (#{event.payload[:reason]})",
+                         **event.payload.slice(:turn_id, :detail).compact)
+  end
+
+  def resume(event)
+    parked_for = event.payload[:parked_for]
+    info formatted_event(event, action: "Turn resumed after #{parked_for&.round(1)}s parked",
+                         **event.payload.slice(:turn_id).compact)
+  end
+
+  def approval(event)
+    info formatted_event(event, action: "Approval #{event.payload[:action]}",
+                         **event.payload.slice(:tool, :by, :turn_id).compact)
+  end
+
+  def budget(event)
+    warn formatted_event(event, action: "Budget reached (#{event.payload[:reason]})",
+                         **event.payload.slice(:turn_id).compact)
+  end
+
+  def compact(event)
+    info formatted_event(event, action: "Compacted through turn #{event.payload[:up_to_turn_index]}",
+                         **event.payload.slice(:session_id, :turn_id, :tokens_before, :output_tokens).compact)
+  end
+
+  def nondeterminism(event)
+    error formatted_event(event, action: "Definitions changed mid-turn",
+                          **event.payload.slice(:turn_id, :was, :now).compact)
+  end
+
+  def rescue(event)
+    payload = event.payload
+    return if payload[:rescued].to_i.zero? && payload[:stranded].to_i.zero?
+
+    info formatted_event(event, action: "Rescuer", **payload.slice(:rescued, :stranded))
+  end
+
+  # delta.silas is deliberately NOT logged — it fires many times per second
+  # per running turn. Subscribe to it directly if you want the firehose.
+
+  private
+    def formatted_event(event, action:, **attributes)
+      "Silas-#{Silas::VERSION} #{action} (#{event.duration.round(1)}ms)  #{formatted_attributes(**attributes)}"
+    end
+
+    def formatted_attributes(**attributes)
+      attributes.map { |attr, value| "#{attr}: #{value.inspect}" }.join(", ")
+    end
+
+    def logger
+      Silas.logger
+    end
+end

data/lib/silas/message_builder.rb

@@ -16,7 +16,19 @@ module Silas
     def call(turn, upto_index:)
       messages = []
 
+      # A completed Compaction row replaces turns 0..up_to_turn_index with its
+      # persisted summary. Reading the ROW keeps this deterministic: the
+      # summary was generated once (Compactor's CAS claim) and never
+      # recomputed, so same rows -> same array, compacted or not.
+      compaction = Compaction.latest_for(turn)
+      floor = -1
+      if compaction
+        messages << { role: "user", content: compaction_preamble(compaction) }
+        floor = compaction.up_to_turn_index
+      end
+
       Turn.where(session_id: turn.session_id).order(:index).each do |prior|
+        next if prior.index <= floor
         break if prior.index >= turn.index
 
         messages << { role: "user", content: prior.input }
@@ -28,6 +40,13 @@ module Silas
       messages
     end
 
+    # Pure function of the row — no clock, no counts of anything mutable.
+    def compaction_preamble(compaction)
+      "[The earlier part of this conversation was summarised to stay within " \
+        "the context window. Summary of everything before this point:]\n\n" \
+        "#{compaction.summary}"
+    end
+
     def step_messages(turn, upto_index:)
       Step.where(turn_id: turn.id).order(:index).each_with_object([]) do |step, acc|
         next unless step.completed?

data/lib/silas/registry.rb

@@ -50,8 +50,10 @@ module Silas
     # and compile order are deterministic. Deliberately NOT in #definitions or
     # #digest — a schedule is a trigger, not a model-visible capability.
     def schedules
-      @schedules ||= Dir[@root.join("app/agent/schedules/**/*.{md,rb}")].sort
-                         .map { |f| Schedule.parse(Pathname(f), root: @root) }
+      @schedules ||= (
+        Dir[@root.join("app/agent/schedules/**/*.{md,rb}")].sort +
+        Dir[@root.join("app/agents/*/schedules/**/*.{md,rb}")].sort
+      ).map { |f| Schedule.parse(Pathname(f), root: @root) }
     end
 
     # name => Channel subclass. Filename identity, like tools. Also not in the
@@ -70,6 +72,7 @@ module Silas
     # subagents exist (root only — subagents never get delegate: depth-1).
     def builtins
       b = {}
+      b["ask_question"] = Silas::Tools::AskQuestion if Silas.config.ask_question
       b["load_skill"] = Silas::Tools::LoadSkill if skills.any?
       b["delegate"] = Silas::Tools::Delegate if subagent_dirs.any?
       b["run_code"] = Silas::Tools::RunCode if Silas.sandbox_enabled?