silas 0.4.0 → 0.5.0

data/lib/silas/adapters/ruby_llm.rb

@@ -1,39 +1,78 @@
 module Silas
   module Adapters
-    # The :ruby_llm adapter: ONE model call per step, streamed, with tool
-    # interception. Silas's Ledger owns tool execution, so tools are registered
-    # as halt-proxies — RubyLLM sees the schemas, but the moment the model
-    # requests a tool the proxy halts the chat loop and the calls are handed
-    # back to the framework untouched.
+    # The :ruby_llm adapter: ONE model call per step, streamed, with the tool
+    # calls handed back unexecuted.
+    #
+    # RubyLLM's `Chat#complete` runs the whole agentic loop — model, run tools,
+    # feed results back, model again. Silas needs a single move, because the
+    # step boundary IS the durability boundary (checkpoint, ledger, park). So
+    # Chat is used as the BUILDER it is — it owns model resolution, schema
+    # normalisation, system instructions and message construction — and the
+    # execution goes one layer down to `Provider#complete`, which is exactly
+    # what Chat itself calls for a single turn.
+    #
+    # Everything here is RubyLLM's public API: Chat's attr_readers (model,
+    # messages, tools, schema, tool_prefs), Provider.resolve, and
+    # Provider#complete. (Until 0.5 this used tool proxies that threw
+    # `RubyLLM::Tool::Halt` to abort the loop from inside — RubyLLM 2.0 removes
+    # Halt precisely because the loop became caller-controlled, so this binding
+    # is both simpler now and the forward-compatible one.)
     class RubyLLM < Base
-      INTERCEPTED = "__silas_intercepted__".freeze
-
       def execute_step(context, &on_event)
-        chat = build_chat(context, &on_event)
+        chat = build_chat(context)
 
         response = Silas.instrument(:step,
-                                                           turn_id: context[:turn]&.id,
-                                                           index: context[:index],
-                                                           model: context[:model]) do
+                                    turn_id: context[:turn]&.id,
+                                    index: context[:index],
+                                    model: context[:model]) do
           if on_event
-            # Streamed: RubyLLM's accumulator returns a Message identical in
-            # shape to the sync path, so to_result needs no branch. Chunks with
-            # tool-call fragments carry nil/empty content — only text streams.
-            chat.complete do |chunk|
+            # Fires before the HTTP request, matching what RubyLLM's
+            # before_message callback did under streaming — but ours, and
+            # explicitly ordered rather than incidentally so.
+            on_event.call(Event.new(type: :message_start, payload: {}))
+            complete(chat) do |chunk|
+              # Chunks carrying tool-call fragments have nil/empty content —
+              # only text streams.
               text = chunk.content
               on_event.call(Event.new(type: :text_delta, payload: { text: text })) if text.is_a?(String) && !text.empty?
             end
           else
-            chat.complete
+            complete(chat)
           end
         end
 
-        to_result(chat, response)
+        to_result(response, schema: chat.schema)
       end
 
       private
 
-      def build_chat(context, &on_event)
+      # One turn, tools advertised but never run. Streamed and sync return the
+      # same Message shape (the stream accumulator builds it), so there is no
+      # branch below this point.
+      def complete(chat, &block)
+        provider_for(chat.model).complete(
+          chat.messages,
+          tools: chat.tools,
+          tool_prefs: chat.tool_prefs,
+          temperature: nil,
+          model: chat.model,
+          schema: chat.schema,
+          &block
+        )
+      end
+
+      # Resolved from the model Chat already resolved, so the two can never
+      # disagree. Memoised per provider slug: the adapter instance is itself
+      # memoised on Silas (and dropped whenever config changes), and building a
+      # provider builds a Faraday connection — not something to redo per step.
+      # A benign race here costs one extra connection, never correctness.
+      def provider_for(model_info)
+        @providers ||= {}
+        @providers[model_info.provider] ||=
+          ::RubyLLM::Provider.resolve(model_info.provider).new(::RubyLLM.config)
+      end
+
+      def build_chat(context)
         chat = begin
           ::RubyLLM.chat(model: context[:model])
         rescue ::RubyLLM::ModelNotFoundError
@@ -43,26 +82,21 @@ module Silas
                 "or pick a registry-known model in config.default_model / agent.yml."
         end
         chat.with_instructions(context[:system]) if context[:system].present?
-        # agent.yml's final_answer schema: RubyLLM renders the provider's
-        # structured-output dialect and JSON-parses the response back to a
-        # Hash — which to_result persists as a "structured" block.
+        # agent.yml's final_answer schema: with_schema renders the provider's
+        # structured-output dialect. The response comes back as a JSON string
+        # (Chat#complete would have parsed it for us) — to_result does that.
         chat.with_schema(context[:final_answer]) if context[:final_answer].present?
-        context[:tools].each { |definition| chat.with_tool(HaltProxy.new(definition)) }
+        # with_tools (plural), not with_tool — 2.0 drops the singular form and
+        # the plural exists in both.
+        context[:tools].each { |definition| chat.with_tools(SchemaProxy.new(definition)) }
 
         replay_history(chat, context[:messages])
-
-        if on_event
-          # before_message replaces the deprecated on_new_message (gone in
-          # RubyLLM 2.0). Under streaming it fires BEFORE the HTTP request —
-          # deliberate; don't "fix" the earlier timing.
-          chat.before_message { on_event.call(Event.new(type: :message_start, payload: {})) }
-        end
         chat
       end
 
       # Rebuild the provider conversation from Silas's canonical rows. The last
-      # user message is delivered via ask-equivalent add_message; RubyLLM sends
-      # the whole array on complete.
+      # user message is delivered via ask-equivalent add_message; the whole
+      # array goes to the provider on complete.
       def replay_history(chat, messages)
         i = 0
         while i < messages.length
@@ -115,17 +149,13 @@ module Silas
         end
       end
 
-      # The halt-proxies stop the loop after the assistant's tool_use message
-      # was recorded on the chat; pull the LAST assistant message for the step.
-      def to_result(chat, response)
-        assistant = chat.messages.reverse.find { |m| m.role.to_s == "assistant" } || response
-
+      def to_result(assistant, schema:)
         blocks = []
-        content = assistant.content
+        content = structured_content(assistant, schema:)
         if content.is_a?(Hash)
-          # with_schema active: RubyLLM parsed the response to a Hash. Persist
-          # it as its own block type — content.to_s here would write Ruby's
-          # Hash#inspect string into the transcript as "text".
+          # with_schema active: persist the parsed payload as its own block type
+          # — content.to_s here would write Ruby's Hash#inspect string into the
+          # transcript as "text".
           blocks << { "type" => "structured", "data" => content }
         elsif content.to_s.present?
           blocks << { "type" => "text", "text" => content.to_s }
@@ -145,8 +175,31 @@ module Silas
         )
       end
 
-      # Presents an Silas tool schema to RubyLLM; halts instead of executing.
-      class HaltProxy < ::RubyLLM::Tool
+      # Chat#complete normally JSON-parses a schema response before handing it
+      # back; calling the provider directly means we do it. A response that
+      # doesn't parse stays a string rather than raising — a malformed payload
+      # is the model's problem to see in the transcript, not a crash.
+      def structured_content(assistant, schema:)
+        content = assistant.content
+        return content unless schema && content.is_a?(String) && !assistant.tool_call?
+
+        begin
+          JSON.parse(content)
+        rescue JSON::ParserError
+          content
+        end
+      end
+
+      # Carries a Silas tool's schema to the provider. Subclasses RubyLLM::Tool
+      # so it satisfies whatever the provider tool-renderers read (today: name,
+      # description, params_schema, parameters, provider_params) without Silas
+      # having to track that list.
+      #
+      # It has no #execute on purpose. Nothing calls it — the ledger owns tool
+      # execution — and RubyLLM::Tool#execute raises NotImplementedError, so if
+      # anything ever did, it fails loudly instead of feeding the model a
+      # sentinel.
+      class SchemaProxy < ::RubyLLM::Tool
         def initialize(definition)
           super()
           @definition = definition
@@ -154,11 +207,14 @@ module Silas
 
         def name = @definition["name"]
         def description = @definition["description"]
-        def params_schema = @definition["input_schema"]
 
-        def execute(**)
-          ::RubyLLM::Tool::Halt.new(INTERCEPTED)
-        end
+        # RubyLLM 1.x reads params_schema; 2.0 renames it parameters_schema
+        # (alongside parameters -> declared_parameters and provider_params ->
+        # provider_options, which we inherit rather than override). Answering to
+        # both is two lines and makes the proxy version-agnostic — confirmed
+        # against ruby_llm edge by the CI canary.
+        def params_schema = @definition["input_schema"]
+        def parameters_schema = @definition["input_schema"]
       end
     end
   end

data/lib/silas/channel.rb

@@ -57,6 +57,34 @@ module Silas
       Rails.application.message_verifier(TOKEN_PURPOSE)
     end
 
+    # A full one-click approve/decline URL for ANY transport — the signed token
+    # is the credential, so the link works in a WhatsApp message, a Discord
+    # embed, or an SMS exactly as it does in email.
+    #
+    # Built from the engine's own route set plus the discovered mount point,
+    # because a channel runs in a delivery job with no routing scope. The host
+    # is required and never guessed: a hostless approval link is a dead link,
+    # so this raises with the fix rather than shipping one.
+    def self.approval_url(invocation, action, host: nil)
+      options = default_url_options.merge(host: host || default_url_options[:host])
+      if options[:host].blank?
+        raise Error, "Silas::Channel.approval_url needs a host. Set " \
+                     "config.action_mailer.default_url_options = { host: \"example.com\" } " \
+                     "(or Rails.application.routes.default_url_options), or pass host:."
+      end
+
+      Silas::Engine.routes.url_helpers.channels_approval_url(
+        token: token_for(invocation, action),
+        script_name: Silas::Inbox.mount_path, **options
+      )
+    end
+
+    def self.default_url_options
+      mailer = Rails.application.config.action_mailer.default_url_options || {}
+      Rails.application.routes.default_url_options.merge(mailer)
+    end
+    private_class_method :default_url_options
+
     # --- outbound interface (subclasses implement) ---
     def deliver_answer(session:, text:)
       raise NotImplementedError, "#{self.class}#deliver_answer"
@@ -65,5 +93,12 @@ module Silas
     def deliver_approval(session:, invocation:)
       raise NotImplementedError, "#{self.class}#deliver_approval"
     end
+
+    # OPTIONAL: ask_question parks ping this instead of deliver_approval —
+    # define it on transports that can collect free text (the question is
+    # invocation.arguments["question"]; settle with invocation.answer!).
+    # Channels without it are simply not pinged; the question waits in the
+    # inbox. Deliberately NOT declared here raising NotImplementedError:
+    # respond_to? is the capability check.
   end
 end

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

@@ -16,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
@@ -33,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
@@ -108,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
@@ -128,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"

data/lib/silas/instrumentation.rb

@@ -26,11 +26,15 @@ module Silas
   #                    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 | in_doubt | budget), turn_id:, detail:
+  #   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 | declined | expired), tool:, by:,
-  #                    invocation_id:, turn_id:
+  #   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

data/lib/silas/ledger.rb

@@ -88,8 +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: "approval", turn_id: invocation.turn_id,
-                                    detail: invocation.tool_name)
+            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] })

data/lib/silas/log_subscriber.rb

@@ -48,6 +48,11 @@ class Silas::LogSubscriber < ActiveSupport::LogSubscriber
                          **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)

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?